1/* 2 * Copyright (c) International Business Machines Corp., 2004 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 12 * the GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 19/* 20 * TEST CASE : handle.c 21 * 22 * VARIATIONS : 156 23 * 24 * API'S TESTED : dm_path_to_handle 25 * dm_fd_to_handle 26 * dm_path_to_fshandle 27 * dm_handle_to_fshandle 28 * dm_handle_cmp 29 * dm_handle_free 30 * dm_handle_is_valid 31 * dm_handle_hash 32 * dm_handle_to_fsid 33 * dm_handle_to_igen 34 * dm_handle_to_ino 35 * dm_make_handle 36 * dm_make_fshandle 37 * dm_handle_to_path 38 * dm_sync_by_handle 39 */ 40#include <string.h> 41#include <stdio.h> 42#include <stdlib.h> 43#include <errno.h> 44#include <sys/stat.h> 45#include <fcntl.h> 46#include <unistd.h> 47#include "dm_test.h" 48 49#define PATHBUF_LEN 256 50 51#define DIR_LEVEL1 "level1" 52#define DIR_LEVEL2 "level1/level2" 53#define DIR_LEVEL3 "level1/level2/level3" 54#define DIR_LEVEL4 "level1/level2/level3/level4" 55#define FILE_LEVEL4 "level1/level2/level3/level4/dummy.txt" 56#define PATH_NOTDIR "dummy.txt/dummy.txt" 57#define FILE_NOTDMAPI "/usr/include/errno.h" 58#define PATH_TOOLONG "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456" 59 60char *mountPt; 61char DummySubdirFile[FILENAME_MAX]; 62dm_sessid_t sid; 63 64int main(int argc, char **argv) 65{ 66 67 char *szFuncName; 68 char *varstr; 69 int rc; 70 dm_boolean_t bRC; 71 char *szSessionInfo = "dm_test session info"; 72 void *mtpthanp, *curdirhanp; 73 size_t mtpthlen, curdirhlen; 74 75 DMOPT_PARSE(argc, argv); 76 DMLOG_START(); 77 78 if ((mountPt = DMOPT_GET("mtpt")) == NULL) { 79 DMLOG_PRINT(DMLVL_ERR, 80 "Missing mount point, use -mtpt (for example, -mtpt /dmapidir)\n"); 81 DM_EXIT(); 82 } else { 83 DMLOG_PRINT(DMLVL_DEBUG, "Mount point is %s\n", mountPt); 84 } 85 86 /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION!!! */ 87 if ((rc = dm_init_service(&varstr)) != 0) { 88 DMLOG_PRINT(DMLVL_ERR, 89 "dm_init_service failed! (rc = %d, errno = %d)\n", 90 rc, errno); 91 DM_EXIT(); 92 } else if ((rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &sid)) 93 != 0) { 94 DMLOG_PRINT(DMLVL_ERR, 95 "dm_create_session failed! (rc = %d, errno = %d)\n", 96 rc, errno); 97 DM_EXIT(); 98 } else 99 if (((rc = dm_path_to_handle(mountPt, &mtpthanp, &mtpthlen)) != 0) 100 || 101 ((rc = 102 dm_path_to_handle(CURRENT_DIR, &curdirhanp, 103 &curdirhlen)) != 0)) { 104 DMLOG_PRINT(DMLVL_ERR, 105 "dm_path_to_handle failed! (rc = %d, errno = %d)\n", 106 rc, errno); 107 DM_EXIT(); 108 } else if (dm_handle_cmp(mtpthanp, mtpthlen, curdirhanp, curdirhlen) != 109 0) { 110 DMLOG_PRINT(DMLVL_ERR, 111 "This test case must be run from the root directory of the DMAPI FS (%s)\n", 112 mountPt); 113 DM_EXIT(); 114 } else { 115 sprintf(DummySubdirFile, "%s/%s", mountPt, DUMMY_SUBDIR_FILE); 116 117 remove(DUMMY_SUBDIR_FILE); 118 unlink(DUMMY_SUBDIR_LINK); 119 rmdir(DUMMY_SUBDIR_SUBDIR); 120 remove(DUMMY_FILE); 121 remove(DUMMY_FILE2); 122 unlink(DUMMY_LINK); 123 rmdir(DUMMY_SUBDIR); 124 remove(FILE_LEVEL4); 125 rmdir(DIR_LEVEL4); 126 rmdir(DIR_LEVEL3); 127 rmdir(DIR_LEVEL2); 128 rmdir(DIR_LEVEL1); 129 } 130 131 DMLOG_PRINT(DMLVL_DEBUG, "Starting DMAPI handle tests\n"); 132 133 szFuncName = "dm_path_to_handle"; 134 135 /* 136 * TEST : dm_path_to_handle - invalid path 137 * EXPECTED: rc = -1, errno = EFAULT 138 * 139 * This variation uncovered XFS BUG #3 (0 return code from strnlen_user 140 * ignored, which indicated fault) 141 */ 142 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 1)) { 143 void *hanp; 144 size_t hlen; 145 146 /* Variation set up */ 147 148 /* Variation */ 149 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid path)\n", szFuncName); 150 rc = dm_path_to_handle((char *)INVALID_ADDR, &hanp, &hlen); 151 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 152 153 /* Variation clean up */ 154 } 155 156 /* 157 * TEST : dm_path_to_handle - nonexistent path, current directory 158 * EXPECTED: rc = -1, errno = ENOENT 159 */ 160 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 2)) { 161 void *hanp; 162 size_t hlen; 163 164 /* Variation set up */ 165 166 /* Variation */ 167 DMLOG_PRINT(DMLVL_DEBUG, "%s(nonexistent path in curdir)\n", 168 szFuncName); 169 rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen); 170 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOENT); 171 172 /* Variation clean up */ 173 } 174 175 /* 176 * TEST : dm_path_to_handle - file in current directory 177 * EXPECTED: rc = 0 178 */ 179 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 3)) { 180 int fd; 181 void *hanp; 182 size_t hlen; 183 184 /* Variation set up */ 185 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 186 if (fd == -1) { 187 DMLOG_PRINT(DMLVL_DEBUG, 188 "Unable to set up variation! (errno = %d)\n", 189 errno); 190 DMVAR_SKIP(); 191 } else { 192 /* Variation */ 193 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in curdir)\n", 194 szFuncName); 195 rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen); 196 if (rc == 0) { 197 DMLOG_PRINT(DMLVL_DEBUG, 198 "hanp = %p, hlen = %d\n", hanp, 199 hlen); 200 dm_LogHandle(hanp, hlen); 201 } 202 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 203 204 /* Variation clean up */ 205 rc = close(fd); 206 rc |= remove(DUMMY_FILE); 207 if (rc == -1) { 208 DMLOG_PRINT(DMLVL_DEBUG, 209 "Unable to clean up variation! (errno = %d)\n", 210 errno); 211 } 212 dm_handle_free(hanp, hlen); 213 } 214 } 215 216 /* 217 * TEST : dm_path_to_handle - link in current directory 218 * EXPECTED: rc = 0 219 */ 220 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 4)) { 221 int fd; 222 void *hanp; 223 size_t hlen; 224 225 /* Variation set up */ 226 if ((fd = 227 open(DUMMY_FILE, O_RDWR | O_CREAT, 228 DUMMY_FILE_RW_MODE)) == -1) { 229 /* no clean up */ 230 } else if ((rc = link(DUMMY_FILE, DUMMY_LINK)) == -1) { 231 close(fd); 232 remove(DUMMY_FILE); 233 } 234 if (fd == -1 || rc == -1) { 235 DMLOG_PRINT(DMLVL_DEBUG, 236 "Unable to set up variation! (errno = %d)\n", 237 errno); 238 DMVAR_SKIP(); 239 } else { 240 /* Variation */ 241 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in curdir)\n", 242 szFuncName); 243 rc = dm_path_to_handle(DUMMY_LINK, &hanp, &hlen); 244 if (rc == 0) { 245 DMLOG_PRINT(DMLVL_DEBUG, 246 "hanp = %p, hlen = %d\n", hanp, 247 hlen); 248 dm_LogHandle(hanp, hlen); 249 } 250 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 251 252 /* Variation clean up */ 253 rc = close(fd); 254 rc |= remove(DUMMY_FILE); 255 rc |= unlink(DUMMY_LINK); 256 if (rc == -1) { 257 DMLOG_PRINT(DMLVL_DEBUG, 258 "Unable to clean up variation! (errno = %d)\n", 259 errno); 260 } 261 dm_handle_free(hanp, hlen); 262 } 263 } 264 265 /* 266 * TEST : dm_path_to_handle - directory in current directory 267 * EXPECTED: rc = 0 268 */ 269 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 5)) { 270 void *hanp; 271 size_t hlen; 272 273 /* Variation set up */ 274 rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE); 275 if (rc == -1) { 276 DMLOG_PRINT(DMLVL_DEBUG, 277 "Unable to set up variation! (errno = %d)\n", 278 errno); 279 DMVAR_SKIP(); 280 } else { 281 /* Variation */ 282 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir in curdir)\n", 283 szFuncName); 284 rc = dm_path_to_handle(DUMMY_SUBDIR, &hanp, &hlen); 285 if (rc == 0) { 286 DMLOG_PRINT(DMLVL_DEBUG, 287 "hanp = %p, hlen = %d\n", hanp, 288 hlen); 289 dm_LogHandle(hanp, hlen); 290 } 291 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 292 293 /* Variation clean up */ 294 rc = rmdir(DUMMY_SUBDIR); 295 if (rc == -1) { 296 DMLOG_PRINT(DMLVL_DEBUG, 297 "Unable to set up variation! (errno = %d)\n", 298 errno); 299 } 300 dm_handle_free(hanp, hlen); 301 } 302 } 303 304 /* 305 * TEST : dm_path_to_handle - nonexistent path in subdirectory 306 * EXPECTED: rc = -1, errno = ENOENT 307 */ 308 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 6)) { 309 void *hanp; 310 size_t hlen; 311 312 /* Variation set up */ 313 rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE); 314 if (rc == -1) { 315 DMLOG_PRINT(DMLVL_DEBUG, 316 "Unable to set up variation! (errno = %d)\n", 317 errno); 318 DMVAR_SKIP(); 319 } else { 320 /* Variation */ 321 DMLOG_PRINT(DMLVL_DEBUG, 322 "%s(nonexistent path in subdir)\n", 323 szFuncName); 324 rc = dm_path_to_handle(DUMMY_SUBDIR_FILE, &hanp, &hlen); 325 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOENT); 326 327 /* Variation clean up */ 328 rc = rmdir(DUMMY_SUBDIR); 329 if (rc == -1) { 330 DMLOG_PRINT(DMLVL_DEBUG, 331 "Unable to set up variation! (errno = %d)\n", 332 errno); 333 } 334 } 335 } 336 337 /* 338 * TEST : dm_path_to_handle - file in subdirectory 339 * EXPECTED: rc = 0 340 */ 341 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 7)) { 342 int fd; 343 void *hanp; 344 size_t hlen; 345 346 /* Variation set up */ 347 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 348 /* No clean up */ 349 } else 350 if ((fd = 351 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 352 DUMMY_FILE_RW_MODE)) == -1) { 353 rmdir(DUMMY_SUBDIR); 354 } 355 if (rc == -1 || fd == -1) { 356 DMLOG_PRINT(DMLVL_DEBUG, 357 "Unable to set up variation! (errno = %d)\n", 358 errno); 359 DMVAR_SKIP(); 360 } else { 361 /* Variation */ 362 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in subdir)\n", 363 szFuncName); 364 rc = dm_path_to_handle(DUMMY_SUBDIR_FILE, &hanp, &hlen); 365 if (rc == 0) { 366 DMLOG_PRINT(DMLVL_DEBUG, 367 "hanp = %p, hlen = %d\n", hanp, 368 hlen); 369 dm_LogHandle(hanp, hlen); 370 } 371 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 372 373 /* Variation clean up */ 374 rc = close(fd); 375 rc |= remove(DUMMY_SUBDIR_FILE); 376 rc |= rmdir(DUMMY_SUBDIR); 377 if (rc == -1) { 378 DMLOG_PRINT(DMLVL_DEBUG, 379 "Unable to clean up variation! (errno = %d)\n", 380 errno); 381 } 382 dm_handle_free(hanp, hlen); 383 } 384 } 385 386 /* 387 * TEST : dm_path_to_handle - link in subdirectory 388 * EXPECTED: rc = 0 389 */ 390 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 8)) { 391 int fd; 392 void *hanp; 393 size_t hlen; 394 395 /* Variation set up */ 396 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 397 /* No clean up */ 398 } else 399 if ((fd = 400 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 401 DUMMY_FILE_RW_MODE)) == -1) { 402 rmdir(DUMMY_SUBDIR); 403 } else if ((rc = link(DUMMY_SUBDIR_FILE, DUMMY_SUBDIR_LINK)) == 404 -1) { 405 close(fd); 406 remove(DUMMY_SUBDIR_FILE); 407 rmdir(DUMMY_SUBDIR); 408 } 409 if (rc == -1 || fd == -1) { 410 DMLOG_PRINT(DMLVL_DEBUG, 411 "Unable to set up variation! (errno = %d)\n", 412 errno); 413 DMVAR_SKIP(); 414 } else { 415 /* Variation */ 416 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in subdir)\n", 417 szFuncName); 418 rc = dm_path_to_handle(DUMMY_SUBDIR_LINK, &hanp, &hlen); 419 if (rc == 0) { 420 DMLOG_PRINT(DMLVL_DEBUG, 421 "hanp = %p, hlen = %d\n", hanp, 422 hlen); 423 dm_LogHandle(hanp, hlen); 424 } 425 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 426 427 /* Variation clean up */ 428 rc = close(fd); 429 rc |= remove(DUMMY_SUBDIR_FILE); 430 rc |= unlink(DUMMY_SUBDIR_LINK); 431 rc |= rmdir(DUMMY_SUBDIR); 432 if (rc == -1) { 433 DMLOG_PRINT(DMLVL_DEBUG, 434 "Unable to clean up variation! (errno = %d)\n", 435 errno); 436 } 437 dm_handle_free(hanp, hlen); 438 } 439 } 440 441 /* 442 * TEST : dm_path_to_handle - directory in subdirectory 443 * EXPECTED: rc = 0 444 */ 445 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 9)) { 446 void *hanp; 447 size_t hlen; 448 449 /* Variation set up */ 450 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 451 /* No clean up */ 452 } else if ((rc = mkdir(DUMMY_SUBDIR_SUBDIR, DUMMY_DIR_RW_MODE)) 453 == -1) { 454 rmdir(DUMMY_SUBDIR); 455 } 456 if (rc == -1) { 457 DMLOG_PRINT(DMLVL_DEBUG, 458 "Unable to set up variation! (errno = %d)\n", 459 errno); 460 DMVAR_SKIP(); 461 } else { 462 /* Variation */ 463 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir in subdir)\n", 464 szFuncName); 465 rc = dm_path_to_handle(DUMMY_SUBDIR_SUBDIR, &hanp, 466 &hlen); 467 if (rc == 0) { 468 DMLOG_PRINT(DMLVL_DEBUG, 469 "hanp = %p, hlen = %d\n", hanp, 470 hlen); 471 dm_LogHandle(hanp, hlen); 472 } 473 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 474 475 /* Variation clean up */ 476 rc = rmdir(DUMMY_SUBDIR_SUBDIR); 477 rc |= rmdir(DUMMY_SUBDIR); 478 if (rc == -1) { 479 DMLOG_PRINT(DMLVL_DEBUG, 480 "Unable to clean up variation! (errno = %d)\n", 481 errno); 482 } 483 dm_handle_free(hanp, hlen); 484 } 485 } 486 487 /* 488 * TEST : dm_path_to_handle - path too long 489 * EXPECTED: rc = -1, errno = ENAMETOOLONG 490 */ 491 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 10)) { 492 void *hanp; 493 size_t hlen; 494 char *szTooLong = PATH_TOOLONG; 495 496 /* Variation set up */ 497 498 /* Variation */ 499 DMLOG_PRINT(DMLVL_DEBUG, "%s(path too long)\n", szFuncName); 500 rc = dm_path_to_handle(szTooLong, &hanp, &hlen); 501 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENAMETOOLONG); 502 503 /* Variation clean up */ 504 } 505 506 /* 507 * TEST : dm_path_to_handle - path includes invalid directory 508 * EXPECTED: rc = -1, errno = ENOTDIR 509 */ 510 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 11)) { 511 int fd; 512 void *hanp; 513 size_t hlen; 514 515 /* Variation set up */ 516 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 517 if (fd == -1) { 518 DMLOG_PRINT(DMLVL_DEBUG, 519 "Unable to set up variation! (errno = %d)\n", 520 errno); 521 DMVAR_SKIP(); 522 } else { 523 /* Variation */ 524 DMLOG_PRINT(DMLVL_DEBUG, "%s(path not dir)\n", 525 szFuncName); 526 rc = dm_path_to_handle(PATH_NOTDIR, &hanp, &hlen); 527 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOTDIR); 528 529 /* Variation clean up */ 530 rc = close(fd); 531 rc |= remove(DUMMY_FILE); 532 if (rc == -1) { 533 DMLOG_PRINT(DMLVL_DEBUG, 534 "Unable to clean up variation! (errno = %d)\n", 535 errno); 536 } 537 } 538 } 539 540 /* 541 * TEST : dm_path_to_handle - path not DMAPI 542 * EXPECTED: rc = -1, errno = ENXIO 543 * 544 * This variation uncovered XFS BUG #4 (EINVAL errno returned instead 545 * of ENXIO) 546 */ 547 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 12)) { 548 void *hanp; 549 size_t hlen; 550 551 /* Variation set up */ 552 553 /* Variation */ 554 DMLOG_PRINT(DMLVL_DEBUG, "%s(path not DMAPI)\n", szFuncName); 555 rc = dm_path_to_handle(FILE_NOTDMAPI, &hanp, &hlen); 556 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENXIO); 557 558 /* Variation clean up */ 559 } 560 561 /* 562 * TEST : dm_path_to_handle - invalid hanpp 563 * EXPECTED: rc = -1, errno = EFAULT 564 */ 565 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 13)) { 566#ifdef USER_SPACE_FAULTS 567 int fd; 568 size_t hlen; 569 570 /* Variation set up */ 571 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 572 if (fd == -1) { 573 DMLOG_PRINT(DMLVL_DEBUG, 574 "Unable to set up variation! (errno = %d)\n", 575 errno); 576 DMVAR_SKIP(); 577 } else { 578 /* Variation */ 579 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanpp)\n", 580 szFuncName); 581 rc = dm_path_to_handle(DUMMY_FILE, 582 (void **)INVALID_ADDR, &hlen); 583 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 584 585 /* Variation clean up */ 586 rc = close(fd); 587 rc |= remove(DUMMY_FILE); 588 if (rc == -1) { 589 DMLOG_PRINT(DMLVL_DEBUG, 590 "Unable to clean up variation! (errno = %d)\n", 591 errno); 592 } 593 } 594#else 595 DMLOG_PRINT(DMLVL_WARN, 596 "Test case not built with USER_SPACE_FAULTS defined\n"); 597 DMVAR_SKIP(); 598#endif 599 } 600 601 /* 602 * TEST : dm_path_to_handle - invalid hlenp 603 * EXPECTED: rc = -1, errno = EFAULT 604 */ 605 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 14)) { 606 int fd; 607 void *hanp; 608 609 /* Variation set up */ 610 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 611 if (fd == -1) { 612 DMLOG_PRINT(DMLVL_DEBUG, 613 "Unable to set up variation! (errno = %d)\n", 614 errno); 615 DMVAR_SKIP(); 616 } else { 617 /* Variation */ 618 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlenp)\n", 619 szFuncName); 620 rc = dm_path_to_handle(DUMMY_FILE, &hanp, 621 (size_t *) INVALID_ADDR); 622 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 623 624 /* Variation clean up */ 625 rc = close(fd); 626 rc |= remove(DUMMY_FILE); 627 if (rc == -1) { 628 DMLOG_PRINT(DMLVL_DEBUG, 629 "Unable to clean up variation! (errno = %d)\n", 630 errno); 631 } 632 } 633 } 634 635 /* 636 * TEST : dm_path_to_handle - different paths to same file 637 * EXPECTED: rc = 0 638 */ 639 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 15)) { 640 int fd; 641 void *hanp1, *hanp2; 642 size_t hlen1, hlen2; 643 644 /* Variation set up */ 645 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 646 /* No clean up */ 647 } else 648 if ((fd = 649 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 650 DUMMY_FILE_RW_MODE)) == -1) { 651 rmdir(DUMMY_SUBDIR); 652 } 653 if (rc == -1 || fd == -1) { 654 DMLOG_PRINT(DMLVL_DEBUG, 655 "Unable to set up variation! (errno = %d)\n", 656 errno); 657 DMVAR_SKIP(); 658 } else { 659 /* Variation */ 660 DMLOG_PRINT(DMLVL_DEBUG, "%s(%s)\n", szFuncName, 661 DUMMY_SUBDIR_FILE); 662 rc = dm_path_to_handle(DUMMY_SUBDIR_FILE, &hanp1, 663 &hlen1); 664 if (rc == 0) { 665 DMLOG_PRINT(DMLVL_DEBUG, 666 "hanp1 = %p, hlen1 = %d\n", hanp1, 667 hlen1); 668 dm_LogHandle(hanp1, hlen1); 669 DMLOG_PRINT(DMLVL_DEBUG, "%s(%s)\n", szFuncName, 670 DummySubdirFile); 671 rc = dm_path_to_handle(DummySubdirFile, &hanp2, 672 &hlen2); 673 if (rc == 0) { 674 DMLOG_PRINT(DMLVL_DEBUG, 675 "hanp2 = %p, hlen2 = %d\n", 676 hanp2, hlen2); 677 dm_LogHandle(hanp2, hlen2); 678 } 679 } 680 681 if (rc == 0) { 682 if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2) == 683 0) { 684 DMLOG_PRINT(DMLVL_DEBUG, 685 "%s passed with expected rc = %d and handles same\n", 686 szFuncName, rc); 687 DMVAR_PASS(); 688 } else { 689 DMLOG_PRINT(DMLVL_ERR, 690 "%s failed with expected rc = %d but handles NOT same\n", 691 szFuncName, rc); 692 DMVAR_FAIL(); 693 } 694 } else { 695 DMLOG_PRINT(DMLVL_ERR, 696 "%s failed with unexpected rc = %d (errno = %d)\n", 697 szFuncName, rc, errno); 698 DMVAR_FAIL(); 699 } 700 701 /* Variation clean up */ 702 rc = close(fd); 703 rc |= remove(DUMMY_SUBDIR_FILE); 704 rc |= rmdir(DUMMY_SUBDIR); 705 if (rc == -1) { 706 DMLOG_PRINT(DMLVL_DEBUG, 707 "Unable to clean up variation! (errno = %d)\n", 708 errno); 709 } 710 dm_handle_free(hanp1, hlen1); 711 dm_handle_free(hanp2, hlen2); 712 } 713 } 714 715 /* 716 * TEST : dm_path_to_handle - empty path 717 * EXPECTED: rc = 0 718 */ 719 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 16)) { 720 void *hanp; 721 size_t hlen; 722 723 /* Variation set up */ 724 725 /* Variation */ 726 DMLOG_PRINT(DMLVL_DEBUG, "%s(empty path)\n", szFuncName); 727 rc = dm_path_to_handle("", &hanp, &hlen); 728 if (rc == 0) { 729 DMLOG_PRINT(DMLVL_DEBUG, "hanp = %p, hlen = %d\n", hanp, 730 hlen); 731 dm_LogHandle(hanp, hlen); 732 733 if (dm_handle_cmp(mtpthanp, mtpthlen, hanp, hlen) == 0) { 734 DMLOG_PRINT(DMLVL_DEBUG, 735 "%s passed with expected rc = %d\n", 736 szFuncName, 0); 737 DMVAR_PASS(); 738 } else { 739 DMLOG_PRINT(DMLVL_ERR, 740 "%s failed with expected rc = %d but unexpected handle\n", 741 szFuncName, 0); 742 DMVAR_PASS(); 743 } 744 } else { 745 DMLOG_PRINT(DMLVL_ERR, 746 "%s failed with unexpected rc = %d (errno = %d)\n", 747 szFuncName, rc, errno); 748 DMVAR_FAIL(); 749 } 750 751 /* Variation clean up */ 752 dm_handle_free(hanp, hlen); 753 } 754 755 /* 756 * TEST : dm_path_to_handle - current directory path 757 * EXPECTED: rc = 0 758 */ 759 if (DMVAR_EXEC(PATH_TO_HANDLE_BASE + 17)) { 760 void *hanp; 761 size_t hlen; 762 763 /* Variation set up */ 764 765 /* Variation */ 766 DMLOG_PRINT(DMLVL_DEBUG, "%s(curdir path)\n", szFuncName); 767 rc = dm_path_to_handle(CURRENT_DIR, &hanp, &hlen); 768 if (rc == 0) { 769 DMLOG_PRINT(DMLVL_DEBUG, "hanp = %p, hlen = %d\n", hanp, 770 hlen); 771 dm_LogHandle(hanp, hlen); 772 773 if (dm_handle_cmp(mtpthanp, mtpthlen, hanp, hlen) == 0) { 774 DMLOG_PRINT(DMLVL_DEBUG, 775 "%s passed with expected rc = %d\n", 776 szFuncName, 0); 777 DMVAR_PASS(); 778 } else { 779 DMLOG_PRINT(DMLVL_ERR, 780 "%s failed with expected rc = %d but unexpected handle\n", 781 szFuncName, 0); 782 DMVAR_PASS(); 783 } 784 } else { 785 DMLOG_PRINT(DMLVL_ERR, 786 "%s failed with unexpected rc = %d (errno = %d)\n", 787 szFuncName, rc, errno); 788 DMVAR_FAIL(); 789 } 790 791 /* Variation clean up */ 792 dm_handle_free(hanp, hlen); 793 } 794 795 szFuncName = "dm_fd_to_handle"; 796 797 /* 798 * TEST : dm_fd_to_handle - invalid fd 799 * EXPECTED: rc = -1, errno = EBADF 800 */ 801 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 1)) { 802 void *hanp; 803 size_t hlen; 804 805 /* Variation set up */ 806 807 /* Variation */ 808 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid fd)\n", szFuncName); 809 rc = dm_fd_to_handle(INVALID_ADDR, &hanp, &hlen); 810 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 811 812 /* Variation clean up */ 813 } 814 815 /* 816 * TEST : dm_fd_to_handle - file fd in current directory 817 * EXPECTED: rc = 0 818 */ 819 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 2)) { 820 int fd; 821 void *hanp; 822 size_t hlen; 823 824 /* Variation set up */ 825 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 826 if (fd == -1) { 827 DMLOG_PRINT(DMLVL_DEBUG, 828 "Unable to set up variation! (errno = %d)\n", 829 errno); 830 DMVAR_SKIP(); 831 } else { 832 /* Variation */ 833 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in curdir)\n", 834 szFuncName); 835 rc = dm_fd_to_handle(fd, &hanp, &hlen); 836 if (rc == 0) { 837 DMLOG_PRINT(DMLVL_DEBUG, 838 "hanp = %p, hlen = %d\n", hanp, 839 hlen); 840 dm_LogHandle(hanp, hlen); 841 } 842 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 843 844 /* Variation clean up */ 845 rc = close(fd); 846 rc |= remove(DUMMY_FILE); 847 if (rc == -1) { 848 DMLOG_PRINT(DMLVL_DEBUG, 849 "Unable to clean up variation! (errno = %d)\n", 850 errno); 851 } 852 dm_handle_free(hanp, hlen); 853 } 854 } 855 856 /* 857 * TEST : dm_fd_to_handle - link fd in current directory 858 * EXPECTED: rc = 0 859 */ 860 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 3)) { 861 int fd_f, fd_l; 862 void *hanp; 863 size_t hlen; 864 865 /* Variation set up */ 866 if ((fd_f = 867 open(DUMMY_FILE, O_RDWR | O_CREAT, 868 DUMMY_FILE_RW_MODE)) == -1) { 869 /* No clean up */ 870 } else if ((rc = link(DUMMY_FILE, DUMMY_LINK)) == -1) { 871 close(fd_f); 872 remove(DUMMY_FILE); 873 } else if ((fd_l = open(DUMMY_FILE, O_RDWR)) == -1) { 874 unlink(DUMMY_LINK); 875 close(fd_f); 876 remove(DUMMY_FILE); 877 } 878 if (fd_f == -1 || rc == -1 || fd_l == -1) { 879 DMLOG_PRINT(DMLVL_DEBUG, 880 "Unable to set up variation! (errno = %d)\n", 881 errno); 882 DMVAR_SKIP(); 883 } else { 884 /* Variation */ 885 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in curdir)\n", 886 szFuncName); 887 rc = dm_fd_to_handle(fd_l, &hanp, &hlen); 888 if (rc == 0) { 889 DMLOG_PRINT(DMLVL_DEBUG, 890 "hanp = %p, hlen = %d\n", hanp, 891 hlen); 892 dm_LogHandle(hanp, hlen); 893 } 894 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 895 896 /* Variation clean up */ 897 rc = close(fd_f); 898 rc |= close(fd_l); 899 rc |= remove(DUMMY_FILE); 900 rc |= remove(DUMMY_LINK); 901 if (rc == -1) { 902 DMLOG_PRINT(DMLVL_DEBUG, 903 "Unable to clean up variation! (errno = %d)\n", 904 errno); 905 } 906 dm_handle_free(hanp, hlen); 907 } 908 } 909 910 /* 911 * TEST : dm_fd_to_handle - directory fd in current directory 912 * EXPECTED: rc = 0 913 */ 914 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 4)) { 915 int fd; 916 void *hanp; 917 size_t hlen; 918 919 /* Variation set up */ 920 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 921 /* No clean up */ 922 } else if ((fd = open(DUMMY_SUBDIR, O_DIRECTORY)) == -1) { 923 rmdir(DUMMY_SUBDIR); 924 } 925 if (rc == -1 || fd == -1) { 926 DMLOG_PRINT(DMLVL_DEBUG, 927 "Unable to set up variation! (errno = %d)\n", 928 errno); 929 DMVAR_SKIP(); 930 } else { 931 /* Variation */ 932 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir in curdir)\n", 933 szFuncName); 934 rc = dm_fd_to_handle(fd, &hanp, &hlen); 935 if (rc == 0) { 936 DMLOG_PRINT(DMLVL_DEBUG, 937 "hanp = %p, hlen = %d\n", hanp, 938 hlen); 939 dm_LogHandle(hanp, hlen); 940 } 941 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 942 943 /* Variation clean up */ 944 rc = close(fd); 945 rc |= rmdir(DUMMY_SUBDIR); 946 if (rc == -1) { 947 DMLOG_PRINT(DMLVL_DEBUG, 948 "Unable to set up variation! (errno = %d)\n", 949 errno); 950 } 951 dm_handle_free(hanp, hlen); 952 } 953 } 954 955 /* 956 * TEST : dm_fd_to_handle - file fd in subdirectory 957 * EXPECTED: rc = 0 958 */ 959 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 5)) { 960 int fd; 961 void *hanp; 962 size_t hlen; 963 964 /* Variation set up */ 965 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 966 /* No clean up */ 967 } else 968 if ((fd = 969 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 970 DUMMY_FILE_RW_MODE)) == -1) { 971 rmdir(DUMMY_SUBDIR); 972 } 973 if (rc == -1 || fd == -1) { 974 DMLOG_PRINT(DMLVL_DEBUG, 975 "Unable to set up variation! (errno = %d)\n", 976 errno); 977 DMVAR_SKIP(); 978 } else { 979 /* Variation */ 980 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in subdir)\n", 981 szFuncName); 982 rc = dm_fd_to_handle(fd, &hanp, &hlen); 983 if (rc == 0) { 984 DMLOG_PRINT(DMLVL_DEBUG, 985 "hanp = %p, hlen = %d\n", hanp, 986 hlen); 987 dm_LogHandle(hanp, hlen); 988 } 989 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 990 991 /* Variation clean up */ 992 rc = close(fd); 993 rc |= remove(DUMMY_SUBDIR_FILE); 994 rc |= rmdir(DUMMY_SUBDIR); 995 if (rc == -1) { 996 DMLOG_PRINT(DMLVL_DEBUG, 997 "Unable to clean up variation! (errno = %d)\n", 998 errno); 999 } 1000 dm_handle_free(hanp, hlen); 1001 } 1002 } 1003 1004 /* 1005 * TEST : dm_fd_to_handle - link fd in subdirectory 1006 * EXPECTED: rc = 0 1007 */ 1008 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 6)) { 1009 int fd_f, fd_l; 1010 void *hanp; 1011 size_t hlen; 1012 1013 /* Variation set up */ 1014 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 1015 /* No clean up */ 1016 } else 1017 if ((fd_f = 1018 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 1019 DUMMY_FILE_RW_MODE)) == -1) { 1020 rmdir(DUMMY_SUBDIR); 1021 } else if ((rc = link(DUMMY_SUBDIR_FILE, DUMMY_SUBDIR_LINK)) == 1022 -1) { 1023 remove(DUMMY_SUBDIR_FILE); 1024 close(fd_f); 1025 rmdir(DUMMY_SUBDIR); 1026 } else if ((fd_l = open(DUMMY_SUBDIR_FILE, O_RDWR)) == -1) { 1027 unlink(DUMMY_SUBDIR_LINK); 1028 close(fd_f); 1029 remove(DUMMY_SUBDIR_FILE); 1030 rmdir(DUMMY_SUBDIR); 1031 } 1032 if (rc == -1 || fd_f == -1 || fd_l == -1) { 1033 DMLOG_PRINT(DMLVL_DEBUG, 1034 "Unable to set up variation! (errno = %d)\n", 1035 errno); 1036 DMVAR_SKIP(); 1037 } else { 1038 /* Variation */ 1039 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in subdir)\n", 1040 szFuncName); 1041 rc = dm_fd_to_handle(fd_l, &hanp, &hlen); 1042 if (rc == 0) { 1043 DMLOG_PRINT(DMLVL_DEBUG, 1044 "hanp = %p, hlen = %d\n", hanp, 1045 hlen); 1046 dm_LogHandle(hanp, hlen); 1047 } 1048 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1049 1050 /* Variation clean up */ 1051 rc = close(fd_f); 1052 rc |= close(fd_l); 1053 rc |= remove(DUMMY_SUBDIR_FILE); 1054 rc |= unlink(DUMMY_SUBDIR_LINK); 1055 rc |= rmdir(DUMMY_SUBDIR); 1056 if (rc == -1) { 1057 DMLOG_PRINT(DMLVL_DEBUG, 1058 "Unable to clean up variation! (errno = %d)\n", 1059 errno); 1060 } 1061 dm_handle_free(hanp, hlen); 1062 } 1063 } 1064 1065 /* 1066 * TEST : dm_fd_to_handle - directory fd in subdirectory 1067 * EXPECTED: rc = 0 1068 */ 1069 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 7)) { 1070 int fd; 1071 void *hanp; 1072 size_t hlen; 1073 1074 /* Variation set up */ 1075 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 1076 /* No clean up */ 1077 } else if ((rc = mkdir(DUMMY_SUBDIR_SUBDIR, DUMMY_DIR_RW_MODE)) 1078 == -1) { 1079 rmdir(DUMMY_SUBDIR); 1080 } else if ((fd = open(DUMMY_SUBDIR_SUBDIR, O_DIRECTORY)) == -1) { 1081 rmdir(DUMMY_SUBDIR_SUBDIR); 1082 rmdir(DUMMY_SUBDIR); 1083 } 1084 if (rc == -1 || fd == -1) { 1085 DMLOG_PRINT(DMLVL_DEBUG, 1086 "Unable to set up variation! (errno = %d)\n", 1087 errno); 1088 DMVAR_SKIP(); 1089 } else { 1090 /* Variation */ 1091 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir in subdir)\n", 1092 szFuncName); 1093 rc = dm_fd_to_handle(fd, &hanp, &hlen); 1094 if (rc == 0) { 1095 DMLOG_PRINT(DMLVL_DEBUG, 1096 "hanp = %p, hlen = %d\n", hanp, 1097 hlen); 1098 dm_LogHandle(hanp, hlen); 1099 } 1100 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1101 1102 /* Variation clean up */ 1103 rc = close(fd); 1104 rc |= rmdir(DUMMY_SUBDIR_SUBDIR); 1105 rc |= rmdir(DUMMY_SUBDIR); 1106 if (rc == -1) { 1107 DMLOG_PRINT(DMLVL_DEBUG, 1108 "Unable to clean up variation! (errno = %d)\n", 1109 errno); 1110 } 1111 dm_handle_free(hanp, hlen); 1112 } 1113 } 1114 1115 /* 1116 * TEST : dm_fd_to_handle - fd not DMAPI 1117 * EXPECTED: rc = -1, errno = ENXIO 1118 * 1119 * This variation uncovered XFS BUG #27 (EBADF errno returned instead 1120 * of ENXIO) 1121 */ 1122 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 8)) { 1123 int fd; 1124 void *hanp; 1125 size_t hlen; 1126 1127 /* Variation set up */ 1128 fd = open(FILE_NOTDMAPI, O_RDONLY); 1129 if (fd == -1) { 1130 DMLOG_PRINT(DMLVL_DEBUG, 1131 "Unable to set up variation! (errno = %d)\n", 1132 errno); 1133 DMVAR_SKIP(); 1134 } else { 1135 /* Variation */ 1136 DMLOG_PRINT(DMLVL_DEBUG, "%s(fd not DMAPI)\n", 1137 szFuncName); 1138 rc = dm_fd_to_handle(fd, &hanp, &hlen); 1139 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENXIO); 1140 1141 /* Variation clean up */ 1142 rc = close(fd); 1143 if (rc == -1) { 1144 DMLOG_PRINT(DMLVL_DEBUG, 1145 "Unable to clean up variation! (errno = %d)\n", 1146 errno); 1147 } 1148 } 1149 } 1150 1151 /* 1152 * TEST : dm_fd_to_handle - invalid hanpp 1153 * EXPECTED: rc = -1, errno = EFAULT 1154 */ 1155 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 9)) { 1156#ifdef USER_SPACE_FAULTS 1157 int fd; 1158 size_t hlen; 1159 1160 /* Variation set up */ 1161 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 1162 if (fd == -1) { 1163 DMLOG_PRINT(DMLVL_DEBUG, 1164 "Unable to set up variation! (errno = %d)\n", 1165 errno); 1166 DMVAR_SKIP(); 1167 } else { 1168 /* Variation */ 1169 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanpp)\n", 1170 szFuncName); 1171 rc = dm_fd_to_handle(fd, (void **)INVALID_ADDR, &hlen); 1172 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1173 1174 /* Variation clean up */ 1175 rc = close(fd); 1176 rc |= remove(DUMMY_FILE); 1177 if (rc == -1) { 1178 DMLOG_PRINT(DMLVL_DEBUG, 1179 "Unable to clean up variation! (errno = %d)\n", 1180 errno); 1181 } 1182 } 1183#else 1184 DMLOG_PRINT(DMLVL_WARN, 1185 "Test case not built with USER_SPACE_FAULTS defined\n"); 1186 DMVAR_SKIP(); 1187#endif 1188 } 1189 1190 /* 1191 * TEST : dm_fd_to_handle - invalid hlenp 1192 * EXPECTED: rc = -1, errno = EFAULT 1193 */ 1194 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 10)) { 1195 int fd; 1196 void *hanp; 1197 1198 /* Variation set up */ 1199 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 1200 if (fd == -1) { 1201 DMLOG_PRINT(DMLVL_DEBUG, 1202 "Unable to set up variation! (errno = %d)\n", 1203 errno); 1204 DMVAR_SKIP(); 1205 } else { 1206 /* Variation */ 1207 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlenp)\n", 1208 szFuncName); 1209 rc = dm_fd_to_handle(fd, &hanp, 1210 (size_t *) INVALID_ADDR); 1211 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1212 1213 /* Variation clean up */ 1214 rc = close(fd); 1215 rc |= remove(DUMMY_FILE); 1216 if (rc == -1) { 1217 DMLOG_PRINT(DMLVL_DEBUG, 1218 "Unable to clean up variation! (errno = %d)\n", 1219 errno); 1220 } 1221 } 1222 } 1223 1224 /* 1225 * TEST : dm_fd_to_handle - stdin fd 1226 * EXPECTED: rc = -1, errno = ENXIO 1227 */ 1228 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 11)) { 1229 void *hanp; 1230 size_t hlen; 1231 1232 /* Variation set up */ 1233 1234 /* Variation */ 1235 DMLOG_PRINT(DMLVL_DEBUG, "%s(stdin fd)\n", szFuncName); 1236 rc = dm_fd_to_handle(0, &hanp, &hlen); 1237 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENXIO); 1238 1239 /* Variation clean up */ 1240 } 1241 1242 /* 1243 * TEST : dm_fd_to_handle - stdout fd 1244 * EXPECTED: rc = -1, errno = ENXIO 1245 */ 1246 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 12)) { 1247 void *hanp; 1248 size_t hlen; 1249 1250 /* Variation set up */ 1251 1252 /* Variation */ 1253 DMLOG_PRINT(DMLVL_DEBUG, "%s(stdout fd)\n", szFuncName); 1254 rc = dm_fd_to_handle(1, &hanp, &hlen); 1255 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENXIO); 1256 1257 /* Variation clean up */ 1258 } 1259 1260 /* 1261 * TEST : dm_fd_to_handle - stderr fd 1262 * EXPECTED: rc = -1, errno = ENXIO 1263 */ 1264 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 13)) { 1265 void *hanp; 1266 size_t hlen; 1267 1268 /* Variation set up */ 1269 1270 /* Variation */ 1271 DMLOG_PRINT(DMLVL_DEBUG, "%s(stderr fd)\n", szFuncName); 1272 rc = dm_fd_to_handle(2, &hanp, &hlen); 1273 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENXIO); 1274 1275 /* Variation clean up */ 1276 } 1277 1278 /* 1279 * TEST : dm_fd_to_handle - invalidated fd 1280 * EXPECTED: rc = -1, errno = EBADF 1281 */ 1282 if (DMVAR_EXEC(FD_TO_HANDLE_BASE + 14)) { 1283 int fd; 1284 void *hanp; 1285 size_t hlen; 1286 1287 /* Variation set up */ 1288 if ((fd = 1289 open(DUMMY_FILE, O_RDWR | O_CREAT, 1290 DUMMY_FILE_RW_MODE)) != -1) { 1291 rc = close(fd); 1292 } 1293 if (fd == -1 || rc == -1) { 1294 DMLOG_PRINT(DMLVL_DEBUG, 1295 "Unable to set up variation! (errno = %d)\n", 1296 errno); 1297 DMVAR_SKIP(); 1298 } else { 1299 /* Variation */ 1300 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated fd)\n", 1301 szFuncName); 1302 rc = dm_fd_to_handle(fd, &hanp, &hlen); 1303 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 1304 1305 /* Variation clean up */ 1306 rc = remove(DUMMY_FILE); 1307 if (rc == -1) { 1308 DMLOG_PRINT(DMLVL_DEBUG, 1309 "Unable to clean up variation! (errno = %d)\n", 1310 errno); 1311 } 1312 } 1313 } 1314 1315 szFuncName = "dm_path_to_fshandle"; 1316 1317 /* 1318 * TEST : dm_path_to_fshandle - invalid path 1319 * EXPECTED: rc = -1, errno = EFAULT 1320 * 1321 * This variation uncovered XFS BUG #5 (0 return code from strnlen_user 1322 * ignored, which indicated fault) 1323 */ 1324 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 1)) { 1325 void *hanp; 1326 size_t hlen; 1327 1328 /* Variation set up */ 1329 1330 /* Variation */ 1331 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid path)\n", szFuncName); 1332 rc = dm_path_to_fshandle((char *)INVALID_ADDR, &hanp, &hlen); 1333 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1334 1335 /* Variation clean up */ 1336 } 1337 1338 /* 1339 * TEST : dm_path_to_fshandle - nonexistent path in current directory 1340 * EXPECTED: rc = -1, errno = ENOENT 1341 */ 1342 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 2)) { 1343 void *hanp; 1344 size_t hlen; 1345 1346 /* Variation set up */ 1347 1348 /* Variation */ 1349 DMLOG_PRINT(DMLVL_DEBUG, "%s(nonexistent path in curdir)\n", 1350 szFuncName); 1351 rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen); 1352 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOENT); 1353 1354 /* Variation clean up */ 1355 } 1356 1357 /* 1358 * TEST : dm_path_to_fshandle - file in current directory 1359 * EXPECTED: rc = 0 1360 */ 1361 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 3)) { 1362 int fd; 1363 void *hanp; 1364 size_t hlen; 1365 1366 /* Variation set up */ 1367 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 1368 if (fd == -1) { 1369 DMLOG_PRINT(DMLVL_DEBUG, 1370 "Unable to set up variation! (errno = %d)\n", 1371 errno); 1372 DMVAR_SKIP(); 1373 } else { 1374 /* Variation */ 1375 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in curdir)\n", 1376 szFuncName); 1377 rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen); 1378 if (rc == 0) { 1379 DMLOG_PRINT(DMLVL_DEBUG, 1380 "hanp = %p, hlen = %d\n", hanp, 1381 hlen); 1382 dm_LogHandle(hanp, hlen); 1383 } 1384 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1385 1386 /* Variation clean up */ 1387 rc = close(fd); 1388 rc |= remove(DUMMY_FILE); 1389 if (rc == -1) { 1390 DMLOG_PRINT(DMLVL_DEBUG, 1391 "Unable to clean up variation! (errno = %d)\n", 1392 errno); 1393 } 1394 dm_handle_free(hanp, hlen); 1395 } 1396 } 1397 1398 /* 1399 * TEST : dm_path_to_fshandle - link in current directory 1400 * EXPECTED: rc = 0 1401 */ 1402 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 4)) { 1403 int fd; 1404 void *hanp; 1405 size_t hlen; 1406 1407 /* Variation set up */ 1408 if ((fd = 1409 open(DUMMY_FILE, O_RDWR | O_CREAT, 1410 DUMMY_FILE_RW_MODE)) == -1) { 1411 /* No clean up */ 1412 } else if ((rc = link(DUMMY_FILE, DUMMY_LINK)) == -1) { 1413 close(fd); 1414 remove(DUMMY_FILE); 1415 } 1416 if (fd == -1 || rc == -1) { 1417 DMLOG_PRINT(DMLVL_DEBUG, 1418 "Unable to set up variation! (errno = %d)\n", 1419 errno); 1420 DMVAR_SKIP(); 1421 } else { 1422 /* Variation */ 1423 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in curdir)\n", 1424 szFuncName); 1425 rc = dm_path_to_fshandle(DUMMY_LINK, &hanp, &hlen); 1426 if (rc == 0) { 1427 DMLOG_PRINT(DMLVL_DEBUG, 1428 "hanp = %p, hlen = %d\n", hanp, 1429 hlen); 1430 dm_LogHandle(hanp, hlen); 1431 } 1432 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1433 1434 /* Variation clean up */ 1435 rc = close(fd); 1436 rc |= remove(DUMMY_FILE); 1437 rc |= unlink(DUMMY_LINK); 1438 if (rc == -1) { 1439 DMLOG_PRINT(DMLVL_DEBUG, 1440 "Unable to clean up variation! (errno = %d)\n", 1441 errno); 1442 } 1443 dm_handle_free(hanp, hlen); 1444 } 1445 } 1446 1447 /* 1448 * TEST : dm_path_to_fshandle - directory in current directory 1449 * EXPECTED: rc = 0 1450 */ 1451 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 5)) { 1452 void *hanp; 1453 size_t hlen; 1454 1455 /* Variation set up */ 1456 rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE); 1457 if (rc == -1) { 1458 DMLOG_PRINT(DMLVL_DEBUG, 1459 "Unable to set up variation! (errno = %d)\n", 1460 errno); 1461 DMVAR_SKIP(); 1462 } else { 1463 /* Variation */ 1464 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir in curdir)\n", 1465 szFuncName); 1466 rc = dm_path_to_fshandle(DUMMY_SUBDIR, &hanp, &hlen); 1467 if (rc == 0) { 1468 DMLOG_PRINT(DMLVL_DEBUG, 1469 "hanp = %p, hlen = %d\n", hanp, 1470 hlen); 1471 dm_LogHandle(hanp, hlen); 1472 } 1473 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1474 1475 /* Variation clean up */ 1476 rc = rmdir(DUMMY_SUBDIR); 1477 if (rc == -1) { 1478 DMLOG_PRINT(DMLVL_DEBUG, 1479 "Unable to set up variation! (errno = %d)\n", 1480 errno); 1481 } 1482 dm_handle_free(hanp, hlen); 1483 } 1484 } 1485 1486 /* 1487 * TEST : dm_path_to_fshandle - nonexistent path in subdirectory 1488 * EXPECTED: rc = -1, errno = ENOENT 1489 */ 1490 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 6)) { 1491 void *hanp; 1492 size_t hlen; 1493 1494 /* Variation set up */ 1495 rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE); 1496 if (rc == -1) { 1497 DMLOG_PRINT(DMLVL_DEBUG, 1498 "Unable to set up variation! (errno = %d)\n", 1499 errno); 1500 DMVAR_SKIP(); 1501 } else { 1502 /* Variation */ 1503 DMLOG_PRINT(DMLVL_DEBUG, 1504 "%s(nonexistent path in subdir)\n", 1505 szFuncName); 1506 rc = dm_path_to_fshandle(DUMMY_SUBDIR_FILE, &hanp, 1507 &hlen); 1508 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOENT); 1509 1510 /* Variation clean up */ 1511 rc = rmdir(DUMMY_SUBDIR); 1512 if (rc == -1) { 1513 DMLOG_PRINT(DMLVL_DEBUG, 1514 "Unable to set up variation! (errno = %d)\n", 1515 errno); 1516 } 1517 } 1518 } 1519 1520 /* 1521 * TEST : dm_path_to_fshandle - file in subdirectory 1522 * EXPECTED: rc = 0 1523 */ 1524 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 7)) { 1525 int fd; 1526 void *hanp; 1527 size_t hlen; 1528 1529 /* Variation set up */ 1530 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 1531 /* No clean up */ 1532 } else 1533 if ((fd = 1534 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 1535 DUMMY_FILE_RW_MODE)) == -1) { 1536 rmdir(DUMMY_SUBDIR); 1537 } 1538 if (rc == -1 || fd == -1) { 1539 DMLOG_PRINT(DMLVL_DEBUG, 1540 "Unable to set up variation! (errno = %d)\n", 1541 errno); 1542 DMVAR_SKIP(); 1543 } else { 1544 /* Variation */ 1545 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in subdir)\n", 1546 szFuncName); 1547 rc = dm_path_to_fshandle(DUMMY_SUBDIR_FILE, &hanp, 1548 &hlen); 1549 if (rc == 0) { 1550 DMLOG_PRINT(DMLVL_DEBUG, 1551 "hanp = %p, hlen = %d\n", hanp, 1552 hlen); 1553 dm_LogHandle(hanp, hlen); 1554 } 1555 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1556 1557 /* Variation clean up */ 1558 rc = close(fd); 1559 rc |= remove(DUMMY_SUBDIR_FILE); 1560 rc |= rmdir(DUMMY_SUBDIR); 1561 if (rc == -1) { 1562 DMLOG_PRINT(DMLVL_DEBUG, 1563 "Unable to clean up variation! (errno = %d)\n", 1564 errno); 1565 } 1566 dm_handle_free(hanp, hlen); 1567 } 1568 } 1569 1570 /* 1571 * TEST : dm_path_to_fshandle - link in subdirectory 1572 * EXPECTED: rc = 0 1573 */ 1574 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 8)) { 1575 int fd; 1576 void *hanp; 1577 size_t hlen; 1578 1579 /* Variation set up */ 1580 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 1581 /* No clean up */ 1582 } else 1583 if ((fd = 1584 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 1585 DUMMY_FILE_RW_MODE)) == -1) { 1586 rmdir(DUMMY_SUBDIR); 1587 } else if ((rc = link(DUMMY_SUBDIR_FILE, DUMMY_SUBDIR_LINK)) == 1588 -1) { 1589 close(fd); 1590 remove(DUMMY_SUBDIR_FILE); 1591 rmdir(DUMMY_SUBDIR); 1592 } 1593 if (rc == -1 || fd == -1) { 1594 DMLOG_PRINT(DMLVL_DEBUG, 1595 "Unable to set up variation! (errno = %d)\n", 1596 errno); 1597 DMVAR_SKIP(); 1598 } else { 1599 /* Variation */ 1600 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in subdir)\n", 1601 szFuncName); 1602 rc = dm_path_to_fshandle(DUMMY_SUBDIR_LINK, &hanp, 1603 &hlen); 1604 if (rc == 0) { 1605 DMLOG_PRINT(DMLVL_DEBUG, 1606 "hanp = %p, hlen = %d\n", hanp, 1607 hlen); 1608 dm_LogHandle(hanp, hlen); 1609 } 1610 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1611 1612 /* Variation clean up */ 1613 rc = close(fd); 1614 rc |= remove(DUMMY_SUBDIR_FILE); 1615 rc |= unlink(DUMMY_SUBDIR_LINK); 1616 rc |= rmdir(DUMMY_SUBDIR); 1617 if (rc == -1) { 1618 DMLOG_PRINT(DMLVL_DEBUG, 1619 "Unable to clean up variation! (errno = %d)\n", 1620 errno); 1621 } 1622 dm_handle_free(hanp, hlen); 1623 } 1624 } 1625 1626 /* 1627 * TEST : dm_path_to_fshandle - directory in subdirectory 1628 * EXPECTED: rc = 0 1629 */ 1630 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 9)) { 1631 void *hanp; 1632 size_t hlen; 1633 1634 /* Variation set up */ 1635 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 1636 /* No clean up */ 1637 } else if ((rc = mkdir(DUMMY_SUBDIR_SUBDIR, DUMMY_DIR_RW_MODE)) 1638 == -1) { 1639 rmdir(DUMMY_SUBDIR); 1640 } 1641 if (rc == -1) { 1642 DMLOG_PRINT(DMLVL_DEBUG, 1643 "Unable to set up variation! (errno = %d)\n", 1644 errno); 1645 DMVAR_SKIP(); 1646 } else { 1647 /* Variation */ 1648 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir in subdir)\n", 1649 szFuncName); 1650 rc = dm_path_to_fshandle(DUMMY_SUBDIR_SUBDIR, &hanp, 1651 &hlen); 1652 if (rc == 0) { 1653 DMLOG_PRINT(DMLVL_DEBUG, 1654 "hanp = %p, hlen = %d\n", hanp, 1655 hlen); 1656 dm_LogHandle(hanp, hlen); 1657 } 1658 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1659 1660 /* Variation clean up */ 1661 rc = rmdir(DUMMY_SUBDIR_SUBDIR); 1662 rc |= rmdir(DUMMY_SUBDIR); 1663 if (rc == -1) { 1664 DMLOG_PRINT(DMLVL_DEBUG, 1665 "Unable to clean up variation! (errno = %d)\n", 1666 errno); 1667 } 1668 dm_handle_free(hanp, hlen); 1669 } 1670 } 1671 1672 /* 1673 * TEST : dm_path_to_fshandle - path too long 1674 * EXPECTED: rc = -1, errno = ENAMETOOLONG 1675 */ 1676 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 10)) { 1677 void *hanp; 1678 size_t hlen; 1679 char *szTooLong = PATH_TOOLONG; 1680 1681 /* Variation set up */ 1682 1683 /* Variation */ 1684 DMLOG_PRINT(DMLVL_DEBUG, "%s(path too long)\n", szFuncName); 1685 rc = dm_path_to_fshandle(szTooLong, &hanp, &hlen); 1686 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENAMETOOLONG); 1687 1688 /* Variation clean up */ 1689 } 1690 1691 /* 1692 * TEST : dm_path_to_fshandle - path includes invalid directory 1693 * EXPECTED: rc = -1, errno = ENOTDIR 1694 */ 1695 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 11)) { 1696 int fd; 1697 void *hanp; 1698 size_t hlen; 1699 1700 /* Variation set up */ 1701 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 1702 if (fd == -1) { 1703 DMLOG_PRINT(DMLVL_DEBUG, 1704 "Unable to set up variation! (errno = %d)\n", 1705 errno); 1706 DMVAR_SKIP(); 1707 } else { 1708 /* Variation */ 1709 DMLOG_PRINT(DMLVL_DEBUG, "%s(path not dir)\n", 1710 szFuncName); 1711 rc = dm_path_to_fshandle(PATH_NOTDIR, &hanp, &hlen); 1712 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOTDIR); 1713 1714 /* Variation clean up */ 1715 rc = close(fd); 1716 rc |= remove(DUMMY_FILE); 1717 if (rc == -1) { 1718 DMLOG_PRINT(DMLVL_DEBUG, 1719 "Unable to clean up variation! (errno = %d)\n", 1720 errno); 1721 } 1722 } 1723 } 1724 1725 /* 1726 * TEST : dm_path_to_fshandle - path not DMAPI 1727 * EXPECTED: rc = -1, errno = ENXIO 1728 * 1729 * This variation uncovered XFS BUG #6 (EINVAL errno returned instead 1730 * of ENXIO) 1731 */ 1732 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 12)) { 1733 void *hanp; 1734 size_t hlen; 1735 1736 /* Variation set up */ 1737 1738 /* Variation */ 1739 DMLOG_PRINT(DMLVL_DEBUG, "%s(path not DMAPI)\n", szFuncName); 1740 rc = dm_path_to_fshandle(FILE_NOTDMAPI, &hanp, &hlen); 1741 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENXIO); 1742 1743 /* Variation clean up */ 1744 } 1745 1746 /* 1747 * TEST : dm_path_to_fshandle - invalid hanpp 1748 * EXPECTED: rc = -1, errno = EFAULT 1749 */ 1750 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 13)) { 1751#ifdef USER_SPACE_FAULTS 1752 int fd; 1753 size_t hlen; 1754 1755 /* Variation set up */ 1756 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 1757 if (fd == -1) { 1758 DMLOG_PRINT(DMLVL_DEBUG, 1759 "Unable to set up variation! (errno = %d)\n", 1760 errno); 1761 DMVAR_SKIP(); 1762 } else { 1763 /* Variation */ 1764 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanpp)\n", 1765 szFuncName); 1766 rc = dm_path_to_fshandle(DUMMY_FILE, 1767 (void **)INVALID_ADDR, &hlen); 1768 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1769 1770 /* Variation clean up */ 1771 rc = close(fd); 1772 rc |= remove(DUMMY_FILE); 1773 if (rc == -1) { 1774 DMLOG_PRINT(DMLVL_DEBUG, 1775 "Unable to clean up variation! (errno = %d)\n", 1776 errno); 1777 } 1778 } 1779#else 1780 DMLOG_PRINT(DMLVL_WARN, 1781 "Test case not built with USER_SPACE_FAULTS defined\n"); 1782 DMVAR_SKIP(); 1783#endif 1784 } 1785 1786 /* 1787 * TEST : dm_path_to_fshandle - invalid hlenp 1788 * EXPECTED: rc = -1, errno = EFAULT 1789 */ 1790 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 14)) { 1791 int fd; 1792 void *hanp; 1793 1794 /* Variation set up */ 1795 fd = open(DUMMY_FILE, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 1796 if (fd == -1) { 1797 DMLOG_PRINT(DMLVL_DEBUG, 1798 "Unable to set up variation! (errno = %d)\n", 1799 errno); 1800 DMVAR_SKIP(); 1801 } else { 1802 /* Variation */ 1803 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlenp)\n", 1804 szFuncName); 1805 rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, 1806 (size_t *) INVALID_ADDR); 1807 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1808 1809 /* Variation clean up */ 1810 rc = close(fd); 1811 rc |= remove(DUMMY_FILE); 1812 if (rc == -1) { 1813 DMLOG_PRINT(DMLVL_DEBUG, 1814 "Unable to clean up variation! (errno = %d)\n", 1815 errno); 1816 } 1817 } 1818 } 1819 1820 /* 1821 * TEST : dm_path_to_fshandle - empty path 1822 * EXPECTED: rc = 0 1823 */ 1824 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 15)) { 1825 void *hanp; 1826 size_t hlen; 1827 1828 /* Variation set up */ 1829 1830 /* Variation */ 1831 DMLOG_PRINT(DMLVL_DEBUG, "%s(empty path)\n", szFuncName); 1832 rc = dm_path_to_fshandle("", &hanp, &hlen); 1833 if (rc == 0) { 1834 DMLOG_PRINT(DMLVL_DEBUG, "hanp = %p, hlen = %d\n", hanp, 1835 hlen); 1836 dm_LogHandle(hanp, hlen); 1837 } 1838 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1839 1840 /* Variation clean up */ 1841 dm_handle_free(hanp, hlen); 1842 } 1843 1844 /* 1845 * TEST : dm_path_to_fshandle - current directory path 1846 * EXPECTED: rc = 0 1847 */ 1848 if (DMVAR_EXEC(PATH_TO_FSHANDLE_BASE + 16)) { 1849 void *hanp; 1850 size_t hlen; 1851 1852 /* Variation set up */ 1853 1854 /* Variation */ 1855 DMLOG_PRINT(DMLVL_DEBUG, "%s(curdir path)\n", szFuncName); 1856 rc = dm_path_to_fshandle(CURRENT_DIR, &hanp, &hlen); 1857 if (rc == 0) { 1858 DMLOG_PRINT(DMLVL_DEBUG, "hanp = %p, hlen = %d\n", hanp, 1859 hlen); 1860 dm_LogHandle(hanp, hlen); 1861 } 1862 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1863 1864 /* Variation clean up */ 1865 dm_handle_free(hanp, hlen); 1866 } 1867 1868 szFuncName = "dm_handle_to_fshandle"; 1869 1870 /* 1871 * TEST : dm_handle_to_fshandle - invalid hanp 1872 * EXPECTED: rc = -1, errno = EFAULT 1873 */ 1874 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 1)) { 1875#ifdef USER_SPACE_FAULTS 1876 int fd; 1877 void *hanp, *fshanp; 1878 size_t hlen, fshlen; 1879 1880 /* Variation set up */ 1881 if ((fd = 1882 open(DUMMY_FILE, O_RDWR | O_CREAT, 1883 DUMMY_FILE_RW_MODE)) == -1) { 1884 /* No clean up */ 1885 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 1886 close(fd); 1887 remove(DUMMY_FILE); 1888 } 1889 if (fd == -1 || rc == -1) { 1890 DMLOG_PRINT(DMLVL_DEBUG, 1891 "Unable to set up variation! (errno = %d)\n", 1892 errno); 1893 DMVAR_SKIP(); 1894 } else { 1895 /* Variation */ 1896 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", 1897 szFuncName); 1898 rc = dm_handle_to_fshandle((void *)INVALID_ADDR, hlen, 1899 &fshanp, &fshlen); 1900 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1901 1902 /* Variation clean up */ 1903 rc = close(fd); 1904 rc |= remove(DUMMY_FILE); 1905 if (rc == -1) { 1906 DMLOG_PRINT(DMLVL_DEBUG, 1907 "Unable to clean up variation! (errno = %d)\n", 1908 errno); 1909 } 1910 dm_handle_free(hanp, hlen); 1911 } 1912#else 1913 DMLOG_PRINT(DMLVL_WARN, 1914 "Test case not built with USER_SPACE_FAULTS defined\n"); 1915 DMVAR_SKIP(); 1916#endif 1917 } 1918 1919 /* 1920 * TEST : dm_handle_to_fshandle - invalid hlen 1921 * EXPECTED: rc = -1, errno = EBADF 1922 */ 1923 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 2)) { 1924 int fd; 1925 void *hanp, *fshanp; 1926 size_t hlen, fshlen; 1927 1928 /* Variation set up */ 1929 if ((fd = 1930 open(DUMMY_FILE, O_RDWR | O_CREAT, 1931 DUMMY_FILE_RW_MODE)) == -1) { 1932 /* No clean up */ 1933 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 1934 close(fd); 1935 remove(DUMMY_FILE); 1936 } 1937 if (fd == -1 || rc == -1) { 1938 DMLOG_PRINT(DMLVL_DEBUG, 1939 "Unable to set up variation! (errno = %d)\n", 1940 errno); 1941 DMVAR_SKIP(); 1942 } else { 1943 /* Variation */ 1944 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n", 1945 szFuncName); 1946 rc = dm_handle_to_fshandle(hanp, INVALID_ADDR, &fshanp, 1947 &fshlen); 1948 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 1949 1950 /* Variation clean up */ 1951 rc = close(fd); 1952 rc |= remove(DUMMY_FILE); 1953 if (rc == -1) { 1954 DMLOG_PRINT(DMLVL_DEBUG, 1955 "Unable to clean up variation! (errno = %d)\n", 1956 errno); 1957 } 1958 dm_handle_free(hanp, hlen); 1959 } 1960 } 1961 1962 /* 1963 * TEST : dm_handle_to_fshandle - file handle 1964 * EXPECTED: rc = 0 1965 */ 1966 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 3)) { 1967 int fd; 1968 void *hanp, *fshanp; 1969 size_t hlen, fshlen; 1970 1971 /* Variation set up */ 1972 if ((fd = 1973 open(DUMMY_FILE, O_RDWR | O_CREAT, 1974 DUMMY_FILE_RW_MODE)) == -1) { 1975 /* No clean up */ 1976 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 1977 close(fd); 1978 remove(DUMMY_FILE); 1979 } 1980 if (fd == -1 || rc == -1) { 1981 DMLOG_PRINT(DMLVL_DEBUG, 1982 "Unable to set up variation! (errno = %d)\n", 1983 errno); 1984 DMVAR_SKIP(); 1985 } else { 1986 /* Variation */ 1987 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 1988 szFuncName); 1989 rc = dm_handle_to_fshandle(hanp, hlen, &fshanp, 1990 &fshlen); 1991 if (rc == 0) { 1992 DMLOG_PRINT(DMLVL_DEBUG, 1993 "fshanp = %p, fshlen = %d\n", 1994 fshanp, fshlen); 1995 dm_LogHandle(fshanp, fshlen); 1996 } 1997 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1998 1999 /* Variation clean up */ 2000 rc = close(fd); 2001 rc |= remove(DUMMY_FILE); 2002 if (rc == -1) { 2003 DMLOG_PRINT(DMLVL_DEBUG, 2004 "Unable to clean up variation! (errno = %d)\n", 2005 errno); 2006 } 2007 dm_handle_free(hanp, hlen); 2008 dm_handle_free(fshanp, fshlen); 2009 } 2010 } 2011 2012 /* 2013 * TEST : dm_handle_to_fshandle - directory handle 2014 * EXPECTED: rc = 0 2015 */ 2016 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 4)) { 2017 void *hanp, *fshanp; 2018 size_t hlen, fshlen; 2019 2020 /* Variation set up */ 2021 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 2022 /* No clean up */ 2023 } else if ((rc = dm_path_to_handle(DUMMY_SUBDIR, &hanp, &hlen)) 2024 == -1) { 2025 rmdir(DUMMY_SUBDIR); 2026 } 2027 if (rc == -1) { 2028 DMLOG_PRINT(DMLVL_DEBUG, 2029 "Unable to set up variation! (errno = %d)\n", 2030 errno); 2031 DMVAR_SKIP(); 2032 } else { 2033 /* Variation */ 2034 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 2035 szFuncName); 2036 rc = dm_handle_to_fshandle(hanp, hlen, &fshanp, 2037 &fshlen); 2038 if (rc == 0) { 2039 DMLOG_PRINT(DMLVL_DEBUG, 2040 "fshanp = %p, fshlen = %d\n", 2041 fshanp, fshlen); 2042 dm_LogHandle(fshanp, fshlen); 2043 } 2044 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 2045 2046 /* Variation clean up */ 2047 rc = rmdir(DUMMY_SUBDIR); 2048 if (rc == -1) { 2049 DMLOG_PRINT(DMLVL_DEBUG, 2050 "Unable to clean up variation! (errno = %d)\n", 2051 errno); 2052 } 2053 dm_handle_free(hanp, hlen); 2054 dm_handle_free(fshanp, fshlen); 2055 } 2056 } 2057 2058 /* 2059 * TEST : dm_handle_to_fshandle - fs handle 2060 * EXPECTED: rc = 0 2061 */ 2062 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 5)) { 2063 int fd; 2064 void *hanp, *fshanp; 2065 size_t hlen, fshlen; 2066 2067 /* Variation set up */ 2068 if ((fd = 2069 open(DUMMY_FILE, O_RDWR | O_CREAT, 2070 DUMMY_FILE_RW_MODE)) == -1) { 2071 /* No clean up */ 2072 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 2073 == -1) { 2074 close(fd); 2075 remove(DUMMY_FILE); 2076 } 2077 if (fd == -1 || rc == -1) { 2078 DMLOG_PRINT(DMLVL_DEBUG, 2079 "Unable to set up variation! (errno = %d)\n", 2080 errno); 2081 DMVAR_SKIP(); 2082 } else { 2083 /* Variation */ 2084 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName); 2085 rc = dm_handle_to_fshandle(hanp, hlen, &fshanp, 2086 &fshlen); 2087 if (rc == 0) { 2088 DMLOG_PRINT(DMLVL_DEBUG, 2089 "fshanp = %p, fshlen = %d\n", 2090 fshanp, fshlen); 2091 dm_LogHandle(fshanp, fshlen); 2092 } 2093 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 2094 2095 /* Variation clean up */ 2096 rc = close(fd); 2097 rc |= remove(DUMMY_FILE); 2098 if (rc == -1) { 2099 DMLOG_PRINT(DMLVL_DEBUG, 2100 "Unable to clean up variation! (errno = %d)\n", 2101 errno); 2102 } 2103 dm_handle_free(hanp, hlen); 2104 dm_handle_free(fshanp, fshlen); 2105 } 2106 } 2107 2108 /* 2109 * TEST : dm_handle_to_fshandle - invalid fshanpp 2110 * EXPECTED: rc = -1, errno = EFAULT 2111 */ 2112 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 6)) { 2113#ifdef USER_SPACE_FAULTS 2114 int fd; 2115 void *hanp; 2116 size_t hlen, fshlen; 2117 2118 /* Variation set up */ 2119 if ((fd = 2120 open(DUMMY_FILE, O_RDWR | O_CREAT, 2121 DUMMY_FILE_RW_MODE)) == -1) { 2122 /* No clean up */ 2123 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 2124 close(fd); 2125 remove(DUMMY_FILE); 2126 } 2127 if (fd == -1 || rc == -1) { 2128 DMLOG_PRINT(DMLVL_DEBUG, 2129 "Unable to set up variation! (errno = %d)\n", 2130 errno); 2131 DMVAR_SKIP(); 2132 } else { 2133 /* Variation */ 2134 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid fshanpp)\n", 2135 szFuncName); 2136 rc = dm_handle_to_fshandle(hanp, hlen, 2137 (void **)INVALID_ADDR, 2138 &fshlen); 2139 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 2140 2141 /* Variation clean up */ 2142 rc = close(fd); 2143 rc |= remove(DUMMY_FILE); 2144 if (rc == -1) { 2145 DMLOG_PRINT(DMLVL_DEBUG, 2146 "Unable to clean up variation! (errno = %d)\n", 2147 errno); 2148 } 2149 dm_handle_free(hanp, hlen); 2150 } 2151#else 2152 DMLOG_PRINT(DMLVL_WARN, 2153 "Test case not built with USER_SPACE_FAULTS defined\n"); 2154 DMVAR_SKIP(); 2155#endif 2156 } 2157 2158 /* 2159 * TEST : dm_handle_to_fshandle - invalid fshlenp 2160 * EXPECTED: rc = -1, errno = EFAULT 2161 */ 2162 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 7)) { 2163#ifdef USER_SPACE_FAULTS 2164 int fd; 2165 void *hanp, *fshanp; 2166 size_t hlen; 2167 2168 /* Variation set up */ 2169 if ((fd = 2170 open(DUMMY_FILE, O_RDWR | O_CREAT, 2171 DUMMY_FILE_RW_MODE)) == -1) { 2172 /* No clean up */ 2173 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 2174 close(fd); 2175 remove(DUMMY_FILE); 2176 } 2177 if (fd == -1 || rc == -1) { 2178 DMLOG_PRINT(DMLVL_DEBUG, 2179 "Unable to set up variation! (errno = %d)\n", 2180 errno); 2181 DMVAR_SKIP(); 2182 } else { 2183 /* Variation */ 2184 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid fshlenp)\n", 2185 szFuncName); 2186 rc = dm_handle_to_fshandle(hanp, hlen, &fshanp, 2187 (void *)INVALID_ADDR); 2188 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 2189 2190 /* Variation clean up */ 2191 rc = close(fd); 2192 rc |= remove(DUMMY_FILE); 2193 if (rc == -1) { 2194 DMLOG_PRINT(DMLVL_DEBUG, 2195 "Unable to clean up variation! (errno = %d)\n", 2196 errno); 2197 } 2198 dm_handle_free(hanp, hlen); 2199 } 2200#else 2201 DMLOG_PRINT(DMLVL_WARN, 2202 "Test case not built with USER_SPACE_FAULTS defined\n"); 2203 DMVAR_SKIP(); 2204#endif 2205 } 2206 2207 /* 2208 * TEST : dm_handle_to_fshandle - global handle 2209 * EXPECTED: rc = -1, errno = EBADF 2210 */ 2211 if (DMVAR_EXEC(HANDLE_TO_FSHANDLE_BASE + 8)) { 2212 void *fshanp; 2213 size_t fshlen; 2214 2215 /* Variation set up */ 2216 2217 /* Variation */ 2218 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 2219 rc = dm_handle_to_fshandle(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 2220 &fshanp, &fshlen); 2221 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 2222 2223 /* Variation clean up */ 2224 } 2225 2226 szFuncName = "dm_handle_cmp"; 2227 2228 /* 2229 * TEST : dm_handle_cmp - invalid hanp1 2230 * EXPECTED: rc != 0 2231 */ 2232 if (DMVAR_EXEC(HANDLE_CMP_BASE + 1)) { 2233#ifdef USER_SPACE_FAULTS 2234 int fd; 2235 void *hanp; 2236 size_t hlen; 2237 2238 /* Variation set up */ 2239 if ((fd = 2240 open(DUMMY_FILE, O_RDWR | O_CREAT, 2241 DUMMY_FILE_RW_MODE)) == -1) { 2242 /* No clean up */ 2243 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2244 -1) { 2245 close(fd); 2246 remove(DUMMY_FILE); 2247 } 2248 if (fd == -1 || rc == -1) { 2249 DMLOG_PRINT(DMLVL_DEBUG, 2250 "Unable to set up variation! (errno = %d)\n", 2251 errno); 2252 DMVAR_SKIP(); 2253 } else { 2254 /* Variation */ 2255 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp1)\n", 2256 szFuncName); 2257 rc = dm_handle_cmp((char *)INVALID_ADDR, hlen, hanp, 2258 hlen); 2259 if (rc != 0) { 2260 DMLOG_PRINT(DMLVL_DEBUG, 2261 "%s passed with expected rc = %d\n", 2262 szFuncName, rc); 2263 DMVAR_PASS(); 2264 } else { 2265 DMLOG_PRINT(DMLVL_ERR, 2266 "%s failed with unexpected rc = %d\n", 2267 szFuncName, rc); 2268 DMVAR_FAIL(); 2269 } 2270 2271 /* Variation clean up */ 2272 rc = close(fd); 2273 rc |= remove(DUMMY_FILE); 2274 if (rc == -1) { 2275 DMLOG_PRINT(DMLVL_DEBUG, 2276 "Unable to clean up variation! (errno = %d)\n", 2277 errno); 2278 } 2279 dm_handle_free(hanp, hlen); 2280 } 2281#else 2282 DMLOG_PRINT(DMLVL_WARN, 2283 "Test case not built with USER_SPACE_FAULTS defined\n"); 2284 DMVAR_SKIP(); 2285#endif 2286 } 2287 2288 /* 2289 * TEST : dm_handle_cmp - invalid hlen1 2290 * EXPECTED: rc != 0 2291 */ 2292 if (DMVAR_EXEC(HANDLE_CMP_BASE + 2)) { 2293 int fd; 2294 void *hanp; 2295 size_t hlen; 2296 2297 /* Variation set up */ 2298 if ((fd = 2299 open(DUMMY_FILE, O_RDWR | O_CREAT, 2300 DUMMY_FILE_RW_MODE)) == -1) { 2301 /* No clean up */ 2302 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2303 -1) { 2304 close(fd); 2305 remove(DUMMY_FILE); 2306 } 2307 if (fd == -1 || rc == -1) { 2308 DMLOG_PRINT(DMLVL_DEBUG, 2309 "Unable to set up variation! (errno = %d)\n", 2310 errno); 2311 DMVAR_SKIP(); 2312 } else { 2313 /* Variation */ 2314 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen1)\n", 2315 szFuncName); 2316 rc = dm_handle_cmp(hanp, INVALID_ADDR, hanp, hlen); 2317 if (rc != 0) { 2318 DMLOG_PRINT(DMLVL_DEBUG, 2319 "%s passed with expected rc = %d\n", 2320 szFuncName, rc); 2321 DMVAR_PASS(); 2322 } else { 2323 DMLOG_PRINT(DMLVL_ERR, 2324 "%s failed with unexpected rc = %d\n", 2325 szFuncName, rc); 2326 DMVAR_FAIL(); 2327 } 2328 2329 /* Variation clean up */ 2330 rc = close(fd); 2331 rc |= remove(DUMMY_FILE); 2332 if (rc == -1) { 2333 DMLOG_PRINT(DMLVL_DEBUG, 2334 "Unable to clean up variation! (errno = %d)\n", 2335 errno); 2336 } 2337 dm_handle_free(hanp, hlen); 2338 } 2339 } 2340 2341 /* 2342 * TEST : dm_handle_cmp - invalid hanp2 2343 * EXPECTED: rc != 0 2344 */ 2345 if (DMVAR_EXEC(HANDLE_CMP_BASE + 3)) { 2346#ifdef USER_SPACE_FAULTS 2347 int fd; 2348 void *hanp; 2349 size_t hlen; 2350 2351 /* Variation set up */ 2352 if ((fd = 2353 open(DUMMY_FILE, O_RDWR | O_CREAT, 2354 DUMMY_FILE_RW_MODE)) == -1) { 2355 /* No clean up */ 2356 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2357 -1) { 2358 close(fd); 2359 remove(DUMMY_FILE); 2360 } 2361 if (fd == -1 || rc == -1) { 2362 DMLOG_PRINT(DMLVL_DEBUG, 2363 "Unable to set up variation! (errno = %d)\n", 2364 errno); 2365 DMVAR_SKIP(); 2366 } else { 2367 /* Variation */ 2368 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp2)\n", 2369 szFuncName); 2370 rc = dm_handle_cmp(hanp, hlen, (char *)INVALID_ADDR, 2371 hlen); 2372 if (rc != 0) { 2373 DMLOG_PRINT(DMLVL_DEBUG, 2374 "%s passed with expected rc = %d\n", 2375 szFuncName, rc); 2376 DMVAR_PASS(); 2377 } else { 2378 DMLOG_PRINT(DMLVL_ERR, 2379 "%s failed with unexpected rc = %d\n", 2380 szFuncName, rc); 2381 DMVAR_FAIL(); 2382 } 2383 2384 /* Variation clean up */ 2385 rc = close(fd); 2386 rc |= remove(DUMMY_FILE); 2387 if (rc == -1) { 2388 DMLOG_PRINT(DMLVL_DEBUG, 2389 "Unable to clean up variation! (errno = %d)\n", 2390 errno); 2391 } 2392 dm_handle_free(hanp, hlen); 2393 } 2394#else 2395 DMLOG_PRINT(DMLVL_WARN, 2396 "Test case not built with USER_SPACE_FAULTS defined\n"); 2397 DMVAR_SKIP(); 2398#endif 2399 } 2400 2401 /* 2402 * TEST : dm_handle_cmp - invalid hlen2 2403 * EXPECTED: rc != 0 2404 */ 2405 if (DMVAR_EXEC(HANDLE_CMP_BASE + 4)) { 2406 int fd; 2407 void *hanp; 2408 size_t hlen; 2409 2410 /* Variation set up */ 2411 if ((fd = 2412 open(DUMMY_FILE, O_RDWR | O_CREAT, 2413 DUMMY_FILE_RW_MODE)) == -1) { 2414 /* No clean up */ 2415 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2416 -1) { 2417 close(fd); 2418 remove(DUMMY_FILE); 2419 } 2420 if (fd == -1 || rc == -1) { 2421 DMLOG_PRINT(DMLVL_DEBUG, 2422 "Unable to set up variation! (errno = %d)\n", 2423 errno); 2424 DMVAR_SKIP(); 2425 } else { 2426 /* Variation */ 2427 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen2)\n", 2428 szFuncName); 2429 rc = dm_handle_cmp(hanp, hlen, hanp, INVALID_ADDR); 2430 if (rc != 0) { 2431 DMLOG_PRINT(DMLVL_DEBUG, 2432 "%s passed with expected rc = %d\n", 2433 szFuncName, rc); 2434 DMVAR_PASS(); 2435 } else { 2436 DMLOG_PRINT(DMLVL_ERR, 2437 "%s failed with unexpected rc = %d\n", 2438 szFuncName, rc); 2439 DMVAR_FAIL(); 2440 } 2441 2442 /* Variation clean up */ 2443 rc = close(fd); 2444 rc |= remove(DUMMY_FILE); 2445 if (rc == -1) { 2446 DMLOG_PRINT(DMLVL_DEBUG, 2447 "Unable to clean up variation! (errno = %d)\n", 2448 errno); 2449 } 2450 dm_handle_free(hanp, hlen); 2451 } 2452 } 2453 2454 /* 2455 * TEST : dm_handle_cmp - hlen1 < hlen2 2456 * EXPECTED: rc != 0 2457 */ 2458 if (DMVAR_EXEC(HANDLE_CMP_BASE + 5)) { 2459 int fd; 2460 void *hanp; 2461 size_t hlen; 2462 2463 /* Variation set up */ 2464 if ((fd = 2465 open(DUMMY_FILE, O_RDWR | O_CREAT, 2466 DUMMY_FILE_RW_MODE)) == -1) { 2467 /* No clean up */ 2468 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2469 -1) { 2470 close(fd); 2471 remove(DUMMY_FILE); 2472 } 2473 if (fd == -1 || rc == -1) { 2474 DMLOG_PRINT(DMLVL_DEBUG, 2475 "Unable to set up variation! (errno = %d)\n", 2476 errno); 2477 DMVAR_SKIP(); 2478 } else { 2479 /* Variation */ 2480 DMLOG_PRINT(DMLVL_DEBUG, "%s(hlen1 < hlen2)\n", 2481 szFuncName); 2482 rc = dm_handle_cmp(hanp, hlen, hanp, hlen + 1); 2483 if (rc != 0) { 2484 DMLOG_PRINT(DMLVL_DEBUG, 2485 "%s passed with expected rc = %d\n", 2486 szFuncName, rc); 2487 DMVAR_PASS(); 2488 } else { 2489 DMLOG_PRINT(DMLVL_ERR, 2490 "%s failed with unexpected rc = %d\n", 2491 szFuncName, rc); 2492 DMVAR_FAIL(); 2493 } 2494 2495 /* Variation clean up */ 2496 rc = close(fd); 2497 rc |= remove(DUMMY_FILE); 2498 if (rc == -1) { 2499 DMLOG_PRINT(DMLVL_DEBUG, 2500 "Unable to clean up variation! (errno = %d)\n", 2501 errno); 2502 } 2503 dm_handle_free(hanp, hlen); 2504 } 2505 } 2506 2507 /* 2508 * TEST : dm_handle_cmp - hanp1 == hanp2 (same file handles) 2509 * EXPECTED: rc = 0 2510 */ 2511 if (DMVAR_EXEC(HANDLE_CMP_BASE + 6)) { 2512 int fd; 2513 void *hanp; 2514 size_t hlen; 2515 2516 /* Variation set up */ 2517 if ((fd = 2518 open(DUMMY_FILE, O_RDWR | O_CREAT, 2519 DUMMY_FILE_RW_MODE)) == -1) { 2520 /* No clean up */ 2521 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2522 -1) { 2523 close(fd); 2524 remove(DUMMY_FILE); 2525 } 2526 if (fd == -1 || rc == -1) { 2527 DMLOG_PRINT(DMLVL_DEBUG, 2528 "Unable to set up variation! (errno = %d)\n", 2529 errno); 2530 DMVAR_SKIP(); 2531 } else { 2532 /* Variation */ 2533 DMLOG_PRINT(DMLVL_DEBUG, 2534 "%s(hanp1 == hanp2, same file handle)\n", 2535 szFuncName); 2536 rc = dm_handle_cmp(hanp, hlen, hanp, hlen); 2537 if (rc == 0) { 2538 DMLOG_PRINT(DMLVL_DEBUG, 2539 "%s passed with expected rc = %d\n", 2540 szFuncName, rc); 2541 DMVAR_PASS(); 2542 } else { 2543 DMLOG_PRINT(DMLVL_ERR, 2544 "%s failed with unexpected rc = %d\n", 2545 szFuncName, rc); 2546 DMVAR_FAIL(); 2547 } 2548 2549 /* Variation clean up */ 2550 rc = close(fd); 2551 rc |= remove(DUMMY_FILE); 2552 if (rc == -1) { 2553 DMLOG_PRINT(DMLVL_DEBUG, 2554 "Unable to clean up variation! (errno = %d)\n", 2555 errno); 2556 } 2557 dm_handle_free(hanp, hlen); 2558 } 2559 } 2560 2561 /* 2562 * TEST : dm_handle_cmp - hanp1 == hanp2 (same fs handles) 2563 * EXPECTED: rc = 0 2564 */ 2565 if (DMVAR_EXEC(HANDLE_CMP_BASE + 7)) { 2566 int fd; 2567 void *hanp; 2568 size_t hlen; 2569 2570 /* Variation set up */ 2571 if ((fd = 2572 open(DUMMY_FILE, O_RDWR | O_CREAT, 2573 DUMMY_FILE_RW_MODE)) == -1) { 2574 /* No clean up */ 2575 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2576 -1) { 2577 close(fd); 2578 remove(DUMMY_FILE); 2579 } 2580 if (fd == -1 || rc == -1) { 2581 DMLOG_PRINT(DMLVL_DEBUG, 2582 "Unable to set up variation! (errno = %d)\n", 2583 errno); 2584 DMVAR_SKIP(); 2585 } else { 2586 /* Variation */ 2587 DMLOG_PRINT(DMLVL_DEBUG, 2588 "%s(hanp1 == hanp2, same fs handle)\n", 2589 szFuncName); 2590 rc = dm_handle_cmp(hanp, hlen, hanp, hlen); 2591 if (rc == 0) { 2592 DMLOG_PRINT(DMLVL_DEBUG, 2593 "%s passed with expected rc = %d\n", 2594 szFuncName, rc); 2595 DMVAR_PASS(); 2596 } else { 2597 DMLOG_PRINT(DMLVL_ERR, 2598 "%s failed with unexpected rc = %d\n", 2599 szFuncName, rc); 2600 DMVAR_FAIL(); 2601 } 2602 2603 /* Variation clean up */ 2604 rc = close(fd); 2605 rc |= remove(DUMMY_FILE); 2606 if (rc == -1) { 2607 DMLOG_PRINT(DMLVL_DEBUG, 2608 "Unable to clean up variation! (errno = %d)\n", 2609 errno); 2610 } 2611 dm_handle_free(hanp, hlen); 2612 } 2613 } 2614 2615 /* 2616 * TEST : dm_handle_cmp - hlen1 > hlen2 2617 * EXPECTED: rc != 0 2618 */ 2619 if (DMVAR_EXEC(HANDLE_CMP_BASE + 8)) { 2620 int fd; 2621 void *hanp; 2622 size_t hlen; 2623 2624 /* Variation set up */ 2625 if ((fd = 2626 open(DUMMY_FILE, O_RDWR | O_CREAT, 2627 DUMMY_FILE_RW_MODE)) == -1) { 2628 /* No clean up */ 2629 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 2630 -1) { 2631 close(fd); 2632 remove(DUMMY_FILE); 2633 } 2634 if (fd == -1 || rc == -1) { 2635 DMLOG_PRINT(DMLVL_DEBUG, 2636 "Unable to set up variation! (errno = %d)\n", 2637 errno); 2638 DMVAR_SKIP(); 2639 } else { 2640 /* Variation */ 2641 DMLOG_PRINT(DMLVL_DEBUG, "%s(hlen1 > hlen2)\n", 2642 szFuncName); 2643 rc = dm_handle_cmp(hanp, hlen, hanp, hlen - 1); 2644 if (rc != 0) { 2645 DMLOG_PRINT(DMLVL_DEBUG, 2646 "%s passed with expected rc = %d\n", 2647 szFuncName, rc); 2648 DMVAR_PASS(); 2649 } else { 2650 DMLOG_PRINT(DMLVL_ERR, 2651 "%s failed with unexpected rc = %d\n", 2652 szFuncName, rc); 2653 DMVAR_FAIL(); 2654 } 2655 2656 /* Variation clean up */ 2657 rc = close(fd); 2658 rc |= remove(DUMMY_FILE); 2659 if (rc == -1) { 2660 DMLOG_PRINT(DMLVL_DEBUG, 2661 "Unable to clean up variation! (errno = %d)\n", 2662 errno); 2663 } 2664 dm_handle_free(hanp, hlen); 2665 } 2666 } 2667 2668 /* 2669 * TEST : dm_handle_cmp - hanp1 == hanp2 (different file handles, same path) 2670 * EXPECTED: rc = 0 2671 */ 2672 if (DMVAR_EXEC(HANDLE_CMP_BASE + 9)) { 2673 int fd; 2674 void *hanp1, *hanp2; 2675 size_t hlen1, hlen2; 2676 2677 /* Variation set up */ 2678 if ((fd = 2679 open(DUMMY_FILE, O_RDWR | O_CREAT, 2680 DUMMY_FILE_RW_MODE)) == -1) { 2681 /* No clean up */ 2682 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp1, &hlen1)) 2683 == -1) { 2684 close(fd); 2685 remove(DUMMY_FILE); 2686 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp2, &hlen2)) 2687 == -1) { 2688 close(fd); 2689 remove(DUMMY_FILE); 2690 dm_handle_free(hanp1, hlen1); 2691 } 2692 if (fd == -1 || rc == -1) { 2693 DMLOG_PRINT(DMLVL_DEBUG, 2694 "Unable to set up variation! (errno = %d)\n", 2695 errno); 2696 DMVAR_SKIP(); 2697 } else { 2698 /* Variation */ 2699 DMLOG_PRINT(DMLVL_DEBUG, 2700 "%s(hanp1 == hanp2, diff file handles from same path)\n", 2701 szFuncName); 2702 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 2703 if (rc == 0) { 2704 DMLOG_PRINT(DMLVL_DEBUG, 2705 "%s passed with expected rc = %d\n", 2706 szFuncName, rc); 2707 DMVAR_PASS(); 2708 } else { 2709 DMLOG_PRINT(DMLVL_ERR, 2710 "%s failed with unexpected rc = %d\n", 2711 szFuncName, rc); 2712 DMVAR_FAIL(); 2713 } 2714 2715 /* Variation clean up */ 2716 rc = close(fd); 2717 rc |= remove(DUMMY_FILE); 2718 if (rc == -1) { 2719 DMLOG_PRINT(DMLVL_DEBUG, 2720 "Unable to clean up variation! (errno = %d)\n", 2721 errno); 2722 } 2723 dm_handle_free(hanp1, hlen1); 2724 dm_handle_free(hanp2, hlen2); 2725 } 2726 } 2727 2728 /* 2729 * TEST : dm_handle_cmp - hanp1 == hanp2 (different fs handles, same path) 2730 * EXPECTED: rc = 0 2731 */ 2732 if (DMVAR_EXEC(HANDLE_CMP_BASE + 10)) { 2733 int fd; 2734 void *hanp1, *hanp2; 2735 size_t hlen1, hlen2; 2736 2737 /* Variation set up */ 2738 if ((fd = 2739 open(DUMMY_FILE, O_RDWR | O_CREAT, 2740 DUMMY_FILE_RW_MODE)) == -1) { 2741 /* No clean up */ 2742 } else 2743 if ((rc = 2744 dm_path_to_fshandle(DUMMY_FILE, &hanp1, 2745 &hlen1)) == -1) { 2746 close(fd); 2747 remove(DUMMY_FILE); 2748 } else 2749 if ((rc = 2750 dm_path_to_fshandle(DUMMY_FILE, &hanp2, 2751 &hlen2)) == -1) { 2752 close(fd); 2753 remove(DUMMY_FILE); 2754 dm_handle_free(hanp1, hlen1); 2755 } 2756 if (fd == -1 || rc == -1) { 2757 DMLOG_PRINT(DMLVL_DEBUG, 2758 "Unable to set up variation! (errno = %d)\n", 2759 errno); 2760 DMVAR_SKIP(); 2761 } else { 2762 /* Variation */ 2763 DMLOG_PRINT(DMLVL_DEBUG, 2764 "%s(hanp1 == hanp2, diff fs handles from same path)\n", 2765 szFuncName); 2766 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 2767 if (rc == 0) { 2768 DMLOG_PRINT(DMLVL_DEBUG, 2769 "%s passed with expected rc = %d\n", 2770 szFuncName, rc); 2771 DMVAR_PASS(); 2772 } else { 2773 DMLOG_PRINT(DMLVL_ERR, 2774 "%s failed with unexpected rc = %d\n", 2775 szFuncName, rc); 2776 DMVAR_FAIL(); 2777 } 2778 2779 /* Variation clean up */ 2780 rc = close(fd); 2781 rc |= remove(DUMMY_FILE); 2782 if (rc == -1) { 2783 DMLOG_PRINT(DMLVL_DEBUG, 2784 "Unable to clean up variation! (errno = %d)\n", 2785 errno); 2786 } 2787 dm_handle_free(hanp1, hlen1); 2788 dm_handle_free(hanp2, hlen2); 2789 } 2790 } 2791 2792 /* 2793 * TEST : dm_handle_cmp - hanp1 == hanp2 (different file handles, one path, one fd) 2794 * EXPECTED: rc = 0 2795 */ 2796 if (DMVAR_EXEC(HANDLE_CMP_BASE + 11)) { 2797 int fd; 2798 void *hanp1, *hanp2; 2799 size_t hlen1, hlen2; 2800 2801 /* Variation set up */ 2802 if ((fd = 2803 open(DUMMY_FILE, O_RDWR | O_CREAT, 2804 DUMMY_FILE_RW_MODE)) == -1) { 2805 /* No clean up */ 2806 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp1, &hlen1)) 2807 == -1) { 2808 close(fd); 2809 remove(DUMMY_FILE); 2810 } else if ((rc = dm_fd_to_handle(fd, &hanp2, &hlen2)) == -1) { 2811 close(fd); 2812 remove(DUMMY_FILE); 2813 dm_handle_free(hanp1, hlen1); 2814 } 2815 if (fd == -1 || rc == -1) { 2816 DMLOG_PRINT(DMLVL_DEBUG, 2817 "Unable to set up variation! (errno = %d)\n", 2818 errno); 2819 DMVAR_SKIP(); 2820 } else { 2821 /* Variation */ 2822 DMLOG_PRINT(DMLVL_DEBUG, 2823 "%s(hanp1 == hanp2, diff file handles from path, fd)\n", 2824 szFuncName); 2825 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 2826 if (rc == 0) { 2827 DMLOG_PRINT(DMLVL_DEBUG, 2828 "%s passed with expected rc = %d\n", 2829 szFuncName, rc); 2830 DMVAR_PASS(); 2831 } else { 2832 DMLOG_PRINT(DMLVL_ERR, 2833 "%s failed with unexpected rc = %d\n", 2834 szFuncName, rc); 2835 DMVAR_FAIL(); 2836 } 2837 2838 /* Variation clean up */ 2839 rc = close(fd); 2840 rc |= remove(DUMMY_FILE); 2841 if (rc == -1) { 2842 DMLOG_PRINT(DMLVL_DEBUG, 2843 "Unable to clean up variation! (errno = %d)\n", 2844 errno); 2845 } 2846 dm_handle_free(hanp1, hlen1); 2847 dm_handle_free(hanp2, hlen2); 2848 } 2849 } 2850 2851 /* 2852 * TEST : dm_handle_cmp - hanp1 == hanp2 (different file handles, same fd) 2853 * EXPECTED: rc = 0 2854 */ 2855 if (DMVAR_EXEC(HANDLE_CMP_BASE + 12)) { 2856 int fd; 2857 void *hanp1, *hanp2; 2858 size_t hlen1, hlen2; 2859 2860 /* Variation set up */ 2861 if ((fd = 2862 open(DUMMY_FILE, O_RDWR | O_CREAT, 2863 DUMMY_FILE_RW_MODE)) == -1) { 2864 /* No clean up */ 2865 } else if ((rc = dm_fd_to_handle(fd, &hanp1, &hlen1)) == -1) { 2866 close(fd); 2867 remove(DUMMY_FILE); 2868 } else if ((rc = dm_fd_to_handle(fd, &hanp2, &hlen2)) == -1) { 2869 close(fd); 2870 remove(DUMMY_FILE); 2871 dm_handle_free(hanp1, hlen1); 2872 } 2873 if (fd == -1 || rc == -1) { 2874 DMLOG_PRINT(DMLVL_DEBUG, 2875 "Unable to set up variation! (errno = %d)\n", 2876 errno); 2877 DMVAR_SKIP(); 2878 } else { 2879 /* Variation */ 2880 DMLOG_PRINT(DMLVL_DEBUG, 2881 "%s(hanp1 == hanp2, diff file handles from same fd)\n", 2882 szFuncName); 2883 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 2884 if (rc == 0) { 2885 DMLOG_PRINT(DMLVL_DEBUG, 2886 "%s passed with expected rc = %d\n", 2887 szFuncName, rc); 2888 DMVAR_PASS(); 2889 } else { 2890 DMLOG_PRINT(DMLVL_ERR, 2891 "%s failed with unexpected rc = %d\n", 2892 szFuncName, rc); 2893 DMVAR_FAIL(); 2894 } 2895 2896 /* Variation clean up */ 2897 rc = close(fd); 2898 rc |= remove(DUMMY_FILE); 2899 if (rc == -1) { 2900 DMLOG_PRINT(DMLVL_DEBUG, 2901 "Unable to clean up variation! (errno = %d)\n", 2902 errno); 2903 } 2904 dm_handle_free(hanp1, hlen1); 2905 dm_handle_free(hanp2, hlen2); 2906 } 2907 } 2908 2909 /* 2910 * TEST : dm_handle_cmp - hanp1 != hanp2 (different path) 2911 * EXPECTED: rc != 0 2912 */ 2913 if (DMVAR_EXEC(HANDLE_CMP_BASE + 13)) { 2914 int fd1, fd2; 2915 void *hanp1, *hanp2; 2916 size_t hlen1, hlen2; 2917 2918 /* Variation set up */ 2919 if ((fd1 = 2920 open(DUMMY_FILE, O_RDWR | O_CREAT, 2921 DUMMY_FILE_RW_MODE)) == -1) { 2922 /* No clean up */ 2923 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp1, &hlen1)) 2924 == -1) { 2925 close(fd1); 2926 remove(DUMMY_FILE); 2927 } else 2928 if ((fd2 = 2929 open(DUMMY_FILE2, O_RDWR | O_CREAT, 2930 DUMMY_FILE_RW_MODE)) == -1) { 2931 close(fd1); 2932 remove(DUMMY_FILE); 2933 dm_handle_free(hanp1, hlen1); 2934 } else if ((rc = dm_path_to_handle(DUMMY_FILE2, &hanp2, &hlen2)) 2935 == -1) { 2936 close(fd1); 2937 remove(DUMMY_FILE); 2938 dm_handle_free(hanp1, hlen1); 2939 close(fd2); 2940 remove(DUMMY_FILE2); 2941 } 2942 if (fd1 == -1 || rc == -1 || fd2 == -1) { 2943 DMLOG_PRINT(DMLVL_DEBUG, 2944 "Unable to set up variation! (errno = %d)\n", 2945 errno); 2946 DMVAR_SKIP(); 2947 } else { 2948 /* Variation */ 2949 DMLOG_PRINT(DMLVL_DEBUG, 2950 "%s(hanp1 != hanp2, different paths)\n", 2951 szFuncName); 2952 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 2953 if (rc != 0) { 2954 DMLOG_PRINT(DMLVL_DEBUG, 2955 "%s passed with expected rc = %d\n", 2956 szFuncName, rc); 2957 DMVAR_PASS(); 2958 } else { 2959 DMLOG_PRINT(DMLVL_ERR, 2960 "%s failed with unexpected rc = %d\n", 2961 szFuncName, rc); 2962 DMVAR_FAIL(); 2963 } 2964 2965 /* Variation clean up */ 2966 rc = close(fd1); 2967 rc |= remove(DUMMY_FILE); 2968 rc |= close(fd2); 2969 rc |= remove(DUMMY_FILE2); 2970 if (rc == -1) { 2971 DMLOG_PRINT(DMLVL_DEBUG, 2972 "Unable to clean up variation! (errno = %d)\n", 2973 errno); 2974 } 2975 dm_handle_free(hanp1, hlen1); 2976 dm_handle_free(hanp2, hlen2); 2977 } 2978 } 2979 2980 /* 2981 * TEST : dm_handle_cmp - hanp1 != hanp2 (different fd) 2982 * EXPECTED: rc != 0 2983 */ 2984 if (DMVAR_EXEC(HANDLE_CMP_BASE + 14)) { 2985 int fd1, fd2; 2986 void *hanp1, *hanp2; 2987 size_t hlen1, hlen2; 2988 2989 /* Variation set up */ 2990 if ((fd1 = 2991 open(DUMMY_FILE, O_RDWR | O_CREAT, 2992 DUMMY_FILE_RW_MODE)) == -1) { 2993 /* No clean up */ 2994 } else if ((rc = dm_fd_to_handle(fd1, &hanp1, &hlen1)) == -1) { 2995 close(fd1); 2996 remove(DUMMY_FILE); 2997 } else 2998 if ((fd2 = 2999 open(DUMMY_FILE2, O_RDWR | O_CREAT, 3000 DUMMY_FILE_RW_MODE)) == -1) { 3001 close(fd1); 3002 remove(DUMMY_FILE); 3003 dm_handle_free(hanp1, hlen1); 3004 } else if ((rc = dm_fd_to_handle(fd2, &hanp2, &hlen2)) == -1) { 3005 close(fd1); 3006 remove(DUMMY_FILE); 3007 dm_handle_free(hanp1, hlen1); 3008 close(fd2); 3009 remove(DUMMY_FILE2); 3010 } 3011 if (fd1 == -1 || rc == -1 || fd2 == -1) { 3012 DMLOG_PRINT(DMLVL_DEBUG, 3013 "Unable to set up variation! (errno = %d)\n", 3014 errno); 3015 DMVAR_SKIP(); 3016 } else { 3017 /* Variation */ 3018 DMLOG_PRINT(DMLVL_DEBUG, 3019 "%s(hanp1 != hanp2, different fd's)\n", 3020 szFuncName); 3021 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 3022 if (rc != 0) { 3023 DMLOG_PRINT(DMLVL_DEBUG, 3024 "%s passed with expected rc = %d\n", 3025 szFuncName, rc); 3026 DMVAR_PASS(); 3027 } else { 3028 DMLOG_PRINT(DMLVL_ERR, 3029 "%s failed with unexpected rc = %d\n", 3030 szFuncName, rc); 3031 DMVAR_FAIL(); 3032 } 3033 3034 /* Variation clean up */ 3035 rc = close(fd1); 3036 rc |= remove(DUMMY_FILE); 3037 rc |= close(fd2); 3038 rc |= remove(DUMMY_FILE2); 3039 if (rc == -1) { 3040 DMLOG_PRINT(DMLVL_DEBUG, 3041 "Unable to clean up variation! (errno = %d)\n", 3042 errno); 3043 } 3044 dm_handle_free(hanp1, hlen1); 3045 dm_handle_free(hanp2, hlen2); 3046 } 3047 } 3048 3049 /* 3050 * TEST : dm_handle_cmp - hanp1 == hanp2 (global handle) 3051 * EXPECTED: rc = 0 3052 * 3053 * This variation uncovered XFS BUG #41 (fault occurred instead of 3054 * rc = 0) 3055 */ 3056 if (DMVAR_EXEC(HANDLE_CMP_BASE + 15)) { 3057 /* Variation set up */ 3058 3059 /* Variation */ 3060 DMLOG_PRINT(DMLVL_DEBUG, "%s(hanp1 == hanp2, global handle)\n", 3061 szFuncName); 3062 rc = dm_handle_cmp(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 3063 DM_GLOBAL_HANP, DM_GLOBAL_HLEN); 3064 if (rc == 0) { 3065 DMLOG_PRINT(DMLVL_DEBUG, 3066 "%s passed with expected rc = %d\n", 3067 szFuncName, rc); 3068 DMVAR_PASS(); 3069 } else { 3070 DMLOG_PRINT(DMLVL_ERR, 3071 "%s failed with unexpected rc = %d\n", 3072 szFuncName, rc); 3073 DMVAR_FAIL(); 3074 } 3075 3076 /* Variation clean up */ 3077 } 3078 3079 /* 3080 * TEST : dm_handle_cmp - hanp1 != hanp2 (file and global handle) 3081 * EXPECTED: rc = 0 3082 */ 3083 if (DMVAR_EXEC(HANDLE_CMP_BASE + 16)) { 3084 int fd; 3085 void *hanp; 3086 size_t hlen; 3087 3088 /* Variation set up */ 3089 if ((fd = 3090 open(DUMMY_FILE, O_RDWR | O_CREAT, 3091 DUMMY_FILE_RW_MODE)) == -1) { 3092 /* No clean up */ 3093 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3094 -1) { 3095 close(fd); 3096 remove(DUMMY_FILE); 3097 } 3098 if (fd == -1 || rc == -1) { 3099 DMLOG_PRINT(DMLVL_DEBUG, 3100 "Unable to set up variation! (errno = %d)\n", 3101 errno); 3102 DMVAR_SKIP(); 3103 } else { 3104 /* Variation */ 3105 DMLOG_PRINT(DMLVL_DEBUG, 3106 "%s(hanp1 != hanp2, file and global handle)\n", 3107 szFuncName); 3108 rc = dm_handle_cmp(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, hanp, 3109 hlen); 3110 if (rc != 0) { 3111 DMLOG_PRINT(DMLVL_DEBUG, 3112 "%s passed with expected rc = %d\n", 3113 szFuncName, rc); 3114 DMVAR_PASS(); 3115 } else { 3116 DMLOG_PRINT(DMLVL_ERR, 3117 "%s failed with unexpected rc = %d\n", 3118 szFuncName, rc); 3119 DMVAR_FAIL(); 3120 } 3121 3122 /* Variation clean up */ 3123 rc = close(fd); 3124 rc |= remove(DUMMY_FILE); 3125 if (rc == -1) { 3126 DMLOG_PRINT(DMLVL_DEBUG, 3127 "Unable to clean up variation! (errno = %d)\n", 3128 errno); 3129 } 3130 dm_handle_free(hanp, hlen); 3131 } 3132 } 3133 3134 szFuncName = "dm_handle_free"; 3135 3136 /* 3137 * TEST : dm_handle_free - invalid hanp 3138 * EXPECTED: return 3139 */ 3140 if (DMVAR_EXEC(HANDLE_FREE_BASE + 1)) { 3141#ifdef USER_SPACE_FAULTS 3142 /* Variation set up */ 3143 3144 /* Variation */ 3145 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", szFuncName); 3146 dm_handle_free((char *)INVALID_ADDR, FILE_HANDLELEN); 3147 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3148 DMVAR_PASS(); 3149 3150 /* Variation clean up */ 3151#else 3152 DMLOG_PRINT(DMLVL_WARN, 3153 "Test case not built with USER_SPACE_FAULTS defined\n"); 3154 DMVAR_SKIP(); 3155#endif 3156 } 3157 3158 /* 3159 * TEST : dm_handle_free - file handle from path 3160 * EXPECTED: return 3161 */ 3162 if (DMVAR_EXEC(HANDLE_FREE_BASE + 2)) { 3163 int fd; 3164 void *hanp; 3165 size_t hlen; 3166 3167 /* Variation set up */ 3168 if ((fd = 3169 open(DUMMY_FILE, O_RDWR | O_CREAT, 3170 DUMMY_FILE_RW_MODE)) == -1) { 3171 /* No clean up */ 3172 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3173 -1) { 3174 close(fd); 3175 remove(DUMMY_FILE); 3176 } 3177 if (fd == -1 || rc == -1) { 3178 DMLOG_PRINT(DMLVL_DEBUG, 3179 "Unable to set up variation! (errno = %d)\n", 3180 errno); 3181 DMVAR_SKIP(); 3182 } else { 3183 /* Variation */ 3184 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle from path)\n", 3185 szFuncName); 3186 dm_handle_free(hanp, hlen); 3187 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3188 DMVAR_PASS(); 3189 3190 /* Variation clean up */ 3191 rc = close(fd); 3192 rc |= remove(DUMMY_FILE); 3193 if (rc == -1) { 3194 DMLOG_PRINT(DMLVL_DEBUG, 3195 "Unable to clean up variation! (errno = %d)\n", 3196 errno); 3197 } 3198 } 3199 } 3200 3201 /* 3202 * TEST : dm_handle_free - file handle from fd 3203 * EXPECTED: return 3204 */ 3205 if (DMVAR_EXEC(HANDLE_FREE_BASE + 3)) { 3206 int fd; 3207 void *hanp; 3208 size_t hlen; 3209 3210 /* Variation set up */ 3211 if ((fd = 3212 open(DUMMY_FILE, O_RDWR | O_CREAT, 3213 DUMMY_FILE_RW_MODE)) == -1) { 3214 /* No clean up */ 3215 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 3216 close(fd); 3217 remove(DUMMY_FILE); 3218 } 3219 if (fd == -1 || rc == -1) { 3220 DMLOG_PRINT(DMLVL_DEBUG, 3221 "Unable to set up variation! (errno = %d)\n", 3222 errno); 3223 DMVAR_SKIP(); 3224 } else { 3225 /* Variation */ 3226 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle from fd)\n", 3227 szFuncName); 3228 dm_handle_free(hanp, hlen); 3229 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3230 DMVAR_PASS(); 3231 3232 /* Variation clean up */ 3233 rc = close(fd); 3234 rc |= remove(DUMMY_FILE); 3235 if (rc == -1) { 3236 DMLOG_PRINT(DMLVL_DEBUG, 3237 "Unable to clean up variation! (errno = %d)\n", 3238 errno); 3239 } 3240 } 3241 } 3242 3243 /* 3244 * TEST : dm_handle_free - fs handle from path 3245 * EXPECTED: return 3246 */ 3247 if (DMVAR_EXEC(HANDLE_FREE_BASE + 4)) { 3248 int fd; 3249 void *hanp; 3250 size_t hlen; 3251 3252 /* Variation set up */ 3253 if ((fd = 3254 open(DUMMY_FILE, O_RDWR | O_CREAT, 3255 DUMMY_FILE_RW_MODE)) == -1) { 3256 /* No clean up */ 3257 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 3258 == -1) { 3259 close(fd); 3260 remove(DUMMY_FILE); 3261 } 3262 if (fd == -1 || rc == -1) { 3263 DMLOG_PRINT(DMLVL_DEBUG, 3264 "Unable to set up variation! (errno = %d)\n", 3265 errno); 3266 DMVAR_SKIP(); 3267 } else { 3268 /* Variation */ 3269 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from path)\n", 3270 szFuncName); 3271 dm_handle_free(hanp, hlen); 3272 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3273 DMVAR_PASS(); 3274 3275 /* Variation clean up */ 3276 rc = close(fd); 3277 rc |= remove(DUMMY_FILE); 3278 if (rc == -1) { 3279 DMLOG_PRINT(DMLVL_DEBUG, 3280 "Unable to clean up variation! (errno = %d)\n", 3281 errno); 3282 } 3283 } 3284 } 3285 3286 /* 3287 * TEST : dm_handle_free - fs handle from handle 3288 * EXPECTED: return 3289 */ 3290 if (DMVAR_EXEC(HANDLE_FREE_BASE + 5)) { 3291 int fd; 3292 void *hanp1, *hanp2; 3293 size_t hlen1, hlen2; 3294 3295 /* Variation set up */ 3296 if ((fd = 3297 open(DUMMY_FILE, O_RDWR | O_CREAT, 3298 DUMMY_FILE_RW_MODE)) == -1) { 3299 /* No clean up */ 3300 } else if ((rc = dm_fd_to_handle(fd, &hanp1, &hlen1)) == -1) { 3301 close(fd); 3302 remove(DUMMY_FILE); 3303 } else 3304 if ((rc = 3305 dm_handle_to_fshandle(hanp1, hlen1, &hanp2, 3306 &hlen2)) == -1) { 3307 close(fd); 3308 remove(DUMMY_FILE); 3309 dm_handle_free(hanp1, hlen1); 3310 } 3311 if (fd == -1 || rc == -1) { 3312 DMLOG_PRINT(DMLVL_DEBUG, 3313 "Unable to set up variation! (errno = %d)\n", 3314 errno); 3315 DMVAR_SKIP(); 3316 } else { 3317 /* Variation */ 3318 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from handle)\n", 3319 szFuncName); 3320 dm_handle_free(hanp2, hlen2); 3321 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3322 DMVAR_PASS(); 3323 3324 /* Variation clean up */ 3325 rc = close(fd); 3326 rc |= remove(DUMMY_FILE); 3327 if (rc == -1) { 3328 DMLOG_PRINT(DMLVL_DEBUG, 3329 "Unable to clean up variation! (errno = %d)\n", 3330 errno); 3331 } 3332 dm_handle_free(hanp1, hlen1); 3333 } 3334 } 3335 3336 /* 3337 * TEST : dm_handle_free - file handle from make 3338 * EXPECTED: return 3339 */ 3340 if (DMVAR_EXEC(HANDLE_FREE_BASE + 6)) { 3341 int fd; 3342 void *hanp1, *hanp2; 3343 size_t hlen1, hlen2; 3344 dm_fsid_t fsid; 3345 dm_igen_t igen; 3346 dm_ino_t ino; 3347 3348 /* Variation set up */ 3349 if ((fd = 3350 open(DUMMY_FILE, O_RDWR | O_CREAT, 3351 DUMMY_FILE_RW_MODE)) == -1) { 3352 /* No clean up */ 3353 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp1, &hlen1)) 3354 == -1) { 3355 close(fd); 3356 remove(DUMMY_FILE); 3357 } else if (((rc = dm_handle_to_fsid(hanp1, hlen1, &fsid)) == -1) 3358 || ((rc = dm_handle_to_igen(hanp1, hlen1, &igen)) == 3359 -1) 3360 || ((rc = dm_handle_to_ino(hanp1, hlen1, &ino)) == 3361 -1) 3362 || 3363 ((rc = 3364 dm_make_handle(&fsid, &ino, &igen, &hanp2, 3365 &hlen2)) == -1)) { 3366 close(fd); 3367 remove(DUMMY_FILE); 3368 dm_handle_free(hanp1, hlen1); 3369 } 3370 if (fd == -1 || rc == -1) { 3371 DMLOG_PRINT(DMLVL_DEBUG, 3372 "Unable to set up variation! (errno = %d)\n", 3373 errno); 3374 DMVAR_SKIP(); 3375 } else { 3376 /* Variation */ 3377 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle from make)\n", 3378 szFuncName); 3379 dm_handle_free(hanp2, hlen2); 3380 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3381 DMVAR_PASS(); 3382 3383 /* Variation clean up */ 3384 rc = close(fd); 3385 rc |= remove(DUMMY_FILE); 3386 if (rc == -1) { 3387 DMLOG_PRINT(DMLVL_DEBUG, 3388 "Unable to clean up variation! (errno = %d)\n", 3389 errno); 3390 } 3391 dm_handle_free(hanp1, hlen1); 3392 dm_handle_free(hanp2, hlen2); 3393 } 3394 } 3395 3396 /* 3397 * TEST : dm_handle_free - fs handle from make 3398 * EXPECTED: return 3399 */ 3400 if (DMVAR_EXEC(HANDLE_FREE_BASE + 7)) { 3401 int fd; 3402 void *hanp1, *hanp2; 3403 size_t hlen1, hlen2; 3404 dm_fsid_t fsid; 3405 3406 /* Variation set up */ 3407 if ((fd = 3408 open(DUMMY_FILE, O_RDWR | O_CREAT, 3409 DUMMY_FILE_RW_MODE)) == -1) { 3410 /* No clean up */ 3411 } else 3412 if ((rc = 3413 dm_path_to_fshandle(DUMMY_FILE, &hanp1, 3414 &hlen1)) == -1) { 3415 close(fd); 3416 remove(DUMMY_FILE); 3417 } else if (((rc = dm_handle_to_fsid(hanp1, hlen1, &fsid)) == -1) 3418 || ((rc = dm_make_fshandle(&fsid, &hanp2, &hlen2)) == 3419 -1)) { 3420 close(fd); 3421 remove(DUMMY_FILE); 3422 dm_handle_free(hanp1, hlen1); 3423 } 3424 if (fd == -1 || rc == -1) { 3425 DMLOG_PRINT(DMLVL_DEBUG, 3426 "Unable to set up variation! (errno = %d)\n", 3427 errno); 3428 DMVAR_SKIP(); 3429 } else { 3430 /* Variation */ 3431 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from make)\n", 3432 szFuncName); 3433 dm_handle_free(hanp2, hlen2); 3434 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3435 DMVAR_PASS(); 3436 3437 /* Variation clean up */ 3438 rc = close(fd); 3439 rc |= remove(DUMMY_FILE); 3440 if (rc == -1) { 3441 DMLOG_PRINT(DMLVL_DEBUG, 3442 "Unable to clean up variation! (errno = %d)\n", 3443 errno); 3444 } 3445 dm_handle_free(hanp1, hlen1); 3446 } 3447 } 3448 3449 /* 3450 * TEST : dm_handle_free - global handle 3451 * EXPECTED: return 3452 */ 3453 if (DMVAR_EXEC(HANDLE_FREE_BASE + 8)) { 3454#ifdef USER_SPACE_FAULTS 3455 /* Variation set up */ 3456 3457 /* Variation */ 3458 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 3459 dm_handle_free(DM_GLOBAL_HANP, DM_GLOBAL_HLEN); 3460 DMLOG_PRINT(DMLVL_DEBUG, "%s passed\n", szFuncName); 3461 DMVAR_PASS(); 3462 3463 /* Variation clean up */ 3464#else 3465 DMLOG_PRINT(DMLVL_WARN, 3466 "Test case not built with USER_SPACE_FAULTS defined\n"); 3467 DMVAR_SKIP(); 3468#endif 3469 } 3470 3471 szFuncName = "dm_handle_is_valid"; 3472 3473 /* 3474 * TEST : dm_handle_is_valid - invalid hanp 3475 * EXPECTED: rc = DM_FALSE 3476 */ 3477 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 1)) { 3478#ifdef USER_SPACE_FAULTS 3479 /* Variation set up */ 3480 3481 /* Variation */ 3482 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", szFuncName); 3483 bRC = dm_handle_is_valid((char *)INVALID_ADDR, FILE_HANDLELEN); 3484 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3485 3486 /* Variation clean up */ 3487#else 3488 DMLOG_PRINT(DMLVL_WARN, 3489 "Test case not built with USER_SPACE_FAULTS defined\n"); 3490 DMVAR_SKIP(); 3491#endif 3492 } 3493 3494 /* 3495 * TEST : dm_handle_is_valid - file handle 3496 * EXPECTED: rc = DM_TRUE 3497 */ 3498 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 2)) { 3499 int fd; 3500 void *hanp; 3501 size_t hlen; 3502 3503 /* Variation set up */ 3504 if ((fd = 3505 open(DUMMY_FILE, O_RDWR | O_CREAT, 3506 DUMMY_FILE_RW_MODE)) == -1) { 3507 /* No clean up */ 3508 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3509 -1) { 3510 close(fd); 3511 remove(DUMMY_FILE); 3512 } 3513 if (fd == -1 || rc == -1) { 3514 DMLOG_PRINT(DMLVL_DEBUG, 3515 "Unable to set up variation! (errno = %d)\n", 3516 errno); 3517 DMVAR_SKIP(); 3518 } else { 3519 /* Variation */ 3520 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 3521 szFuncName); 3522 bRC = dm_handle_is_valid(hanp, hlen); 3523 DMVAR_ENDPASSEXP(szFuncName, DM_TRUE, bRC); 3524 3525 /* Variation clean up */ 3526 rc = close(fd); 3527 rc |= remove(DUMMY_FILE); 3528 if (rc == -1) { 3529 DMLOG_PRINT(DMLVL_DEBUG, 3530 "Unable to clean up variation! (errno = %d)\n", 3531 errno); 3532 } 3533 dm_handle_free(hanp, hlen); 3534 } 3535 } 3536 3537 /* 3538 * TEST : dm_handle_is_valid - file handle, hlen too small 3539 * EXPECTED: rc = DM_FALSE 3540 */ 3541 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 3)) { 3542 int fd; 3543 void *hanp; 3544 size_t hlen; 3545 3546 /* Variation set up */ 3547 if ((fd = 3548 open(DUMMY_FILE, O_RDWR | O_CREAT, 3549 DUMMY_FILE_RW_MODE)) == -1) { 3550 /* No clean up */ 3551 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3552 -1) { 3553 close(fd); 3554 remove(DUMMY_FILE); 3555 } 3556 if (fd == -1 || rc == -1) { 3557 DMLOG_PRINT(DMLVL_DEBUG, 3558 "Unable to set up variation! (errno = %d)\n", 3559 errno); 3560 DMVAR_SKIP(); 3561 } else { 3562 /* Variation */ 3563 DMLOG_PRINT(DMLVL_DEBUG, "%s(file hlen too small)\n", 3564 szFuncName); 3565 bRC = dm_handle_is_valid(hanp, hlen - 1); 3566 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3567 3568 /* Variation clean up */ 3569 rc = close(fd); 3570 rc |= remove(DUMMY_FILE); 3571 if (rc == -1) { 3572 DMLOG_PRINT(DMLVL_DEBUG, 3573 "Unable to clean up variation! (errno = %d)\n", 3574 errno); 3575 } 3576 dm_handle_free(hanp, hlen); 3577 } 3578 } 3579 3580 /* 3581 * TEST : dm_handle_is_valid - file handle, hlen too big 3582 * EXPECTED: rc = DM_FALSE 3583 */ 3584 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 4)) { 3585 int fd; 3586 void *hanp; 3587 size_t hlen; 3588 3589 /* Variation set up */ 3590 if ((fd = 3591 open(DUMMY_FILE, O_RDWR | O_CREAT, 3592 DUMMY_FILE_RW_MODE)) == -1) { 3593 /* No clean up */ 3594 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3595 -1) { 3596 close(fd); 3597 remove(DUMMY_FILE); 3598 } 3599 if (fd == -1 || rc == -1) { 3600 DMLOG_PRINT(DMLVL_DEBUG, 3601 "Unable to set up variation! (errno = %d)\n", 3602 errno); 3603 DMVAR_SKIP(); 3604 } else { 3605 /* Variation */ 3606 DMLOG_PRINT(DMLVL_DEBUG, "%s(file hlen too big)\n", 3607 szFuncName); 3608 bRC = dm_handle_is_valid(hanp, hlen + 1); 3609 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3610 3611 /* Variation clean up */ 3612 rc = close(fd); 3613 rc |= remove(DUMMY_FILE); 3614 if (rc == -1) { 3615 DMLOG_PRINT(DMLVL_DEBUG, 3616 "Unable to clean up variation! (errno = %d)\n", 3617 errno); 3618 } 3619 dm_handle_free(hanp, hlen); 3620 } 3621 } 3622 3623 /* 3624 * TEST : dm_handle_is_valid - modified file handle 3625 * EXPECTED: rc = DM_FALSE 3626 */ 3627 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 5)) { 3628 int fd; 3629 void *hanp; 3630 size_t hlen; 3631 3632 /* Variation set up */ 3633 if ((fd = 3634 open(DUMMY_FILE, O_RDWR | O_CREAT, 3635 DUMMY_FILE_RW_MODE)) == -1) { 3636 /* No clean up */ 3637 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3638 -1) { 3639 close(fd); 3640 remove(DUMMY_FILE); 3641 } 3642 if (fd == -1 || rc == -1) { 3643 DMLOG_PRINT(DMLVL_DEBUG, 3644 "Unable to set up variation! (errno = %d)\n", 3645 errno); 3646 DMVAR_SKIP(); 3647 } else { 3648 /* Variation */ 3649 memset(hanp, 0, hlen); 3650 DMLOG_PRINT(DMLVL_DEBUG, "%s(modified file handle)\n", 3651 szFuncName); 3652 bRC = dm_handle_is_valid(hanp, hlen); 3653 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3654 3655 /* Variation clean up */ 3656 rc = close(fd); 3657 rc |= remove(DUMMY_FILE); 3658 if (rc == -1) { 3659 DMLOG_PRINT(DMLVL_DEBUG, 3660 "Unable to clean up variation! (errno = %d)\n", 3661 errno); 3662 } 3663 dm_handle_free(hanp, hlen); 3664 } 3665 } 3666 3667 /* 3668 * TEST : dm_handle_is_valid - fs handle 3669 * EXPECTED: rc = DM_TRUE 3670 */ 3671 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 6)) { 3672 int fd; 3673 void *hanp; 3674 size_t hlen; 3675 3676 /* Variation set up */ 3677 if ((fd = 3678 open(DUMMY_FILE, O_RDWR | O_CREAT, 3679 DUMMY_FILE_RW_MODE)) == -1) { 3680 /* No clean up */ 3681 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 3682 == -1) { 3683 close(fd); 3684 remove(DUMMY_FILE); 3685 } 3686 if (fd == -1 || rc == -1) { 3687 DMLOG_PRINT(DMLVL_DEBUG, 3688 "Unable to set up variation! (errno = %d)\n", 3689 errno); 3690 DMVAR_SKIP(); 3691 } else { 3692 /* Variation */ 3693 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName); 3694 bRC = dm_handle_is_valid(hanp, hlen); 3695 DMVAR_ENDPASSEXP(szFuncName, DM_TRUE, bRC); 3696 3697 /* Variation clean up */ 3698 rc = close(fd); 3699 rc |= remove(DUMMY_FILE); 3700 if (rc == -1) { 3701 DMLOG_PRINT(DMLVL_DEBUG, 3702 "Unable to clean up variation! (errno = %d)\n", 3703 errno); 3704 } 3705 dm_handle_free(hanp, hlen); 3706 } 3707 } 3708 3709 /* 3710 * TEST : dm_handle_is_valid - fs handle, hlen too small 3711 * EXPECTED: rc = DM_FALSE 3712 */ 3713 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 7)) { 3714 int fd; 3715 void *hanp; 3716 size_t hlen; 3717 3718 /* Variation set up */ 3719 if ((fd = 3720 open(DUMMY_FILE, O_RDWR | O_CREAT, 3721 DUMMY_FILE_RW_MODE)) == -1) { 3722 /* No clean up */ 3723 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 3724 == -1) { 3725 close(fd); 3726 remove(DUMMY_FILE); 3727 } 3728 if (fd == -1 || rc == -1) { 3729 DMLOG_PRINT(DMLVL_DEBUG, 3730 "Unable to set up variation! (errno = %d)\n", 3731 errno); 3732 DMVAR_SKIP(); 3733 } else { 3734 /* Variation */ 3735 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs hlen too small)\n", 3736 szFuncName); 3737 bRC = dm_handle_is_valid(hanp, hlen - 1); 3738 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3739 3740 /* Variation clean up */ 3741 rc = close(fd); 3742 rc |= remove(DUMMY_FILE); 3743 if (rc == -1) { 3744 DMLOG_PRINT(DMLVL_DEBUG, 3745 "Unable to clean up variation! (errno = %d)\n", 3746 errno); 3747 } 3748 dm_handle_free(hanp, hlen); 3749 } 3750 } 3751 3752 /* 3753 * TEST : dm_handle_is_valid - fs handle, hlen too big 3754 * EXPECTED: rc = DM_FALSE 3755 */ 3756 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 8)) { 3757 int fd; 3758 void *hanp; 3759 size_t hlen; 3760 3761 /* Variation set up */ 3762 if ((fd = 3763 open(DUMMY_FILE, O_RDWR | O_CREAT, 3764 DUMMY_FILE_RW_MODE)) == -1) { 3765 /* No clean up */ 3766 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 3767 == -1) { 3768 close(fd); 3769 remove(DUMMY_FILE); 3770 } 3771 if (fd == -1 || rc == -1) { 3772 DMLOG_PRINT(DMLVL_DEBUG, 3773 "Unable to set up variation! (errno = %d)\n", 3774 errno); 3775 DMVAR_SKIP(); 3776 } else { 3777 /* Variation */ 3778 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs hlen too big)\n", 3779 szFuncName); 3780 bRC = dm_handle_is_valid(hanp, hlen + 1); 3781 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3782 3783 /* Variation clean up */ 3784 rc = close(fd); 3785 rc |= remove(DUMMY_FILE); 3786 if (rc == -1) { 3787 DMLOG_PRINT(DMLVL_DEBUG, 3788 "Unable to clean up variation! (errno = %d)\n", 3789 errno); 3790 } 3791 dm_handle_free(hanp, hlen); 3792 } 3793 } 3794 3795 /* 3796 * TEST : dm_handle_is_valid - modified fs handle 3797 * EXPECTED: rc = DM_FALSE 3798 */ 3799 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 9)) { 3800 int fd; 3801 void *hanp; 3802 size_t hlen; 3803 3804 /* Variation set up */ 3805 if ((fd = 3806 open(DUMMY_FILE, O_RDWR | O_CREAT, 3807 DUMMY_FILE_RW_MODE)) == -1) { 3808 /* No clean up */ 3809 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 3810 == -1) { 3811 close(fd); 3812 remove(DUMMY_FILE); 3813 } 3814 if (fd == -1 || rc == -1) { 3815 DMLOG_PRINT(DMLVL_DEBUG, 3816 "Unable to set up variation! (errno = %d)\n", 3817 errno); 3818 DMVAR_SKIP(); 3819 } else { 3820 /* Variation */ 3821 memset(hanp, 0, hlen); 3822 DMLOG_PRINT(DMLVL_DEBUG, "%s(modified fs handle)\n", 3823 szFuncName); 3824 bRC = dm_handle_is_valid(hanp, hlen); 3825 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3826 3827 /* Variation clean up */ 3828 rc = close(fd); 3829 rc |= remove(DUMMY_FILE); 3830 if (rc == -1) { 3831 DMLOG_PRINT(DMLVL_DEBUG, 3832 "Unable to clean up variation! (errno = %d)\n", 3833 errno); 3834 } 3835 dm_handle_free(hanp, hlen); 3836 } 3837 } 3838 3839 /* 3840 * TEST : dm_handle_is_valid - global handle 3841 * EXPECTED: rc = DM_TRUE 3842 */ 3843 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 10)) { 3844 /* Variation set up */ 3845 3846 /* Variation */ 3847 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 3848 bRC = dm_handle_is_valid(DM_GLOBAL_HANP, DM_GLOBAL_HLEN); 3849 DMVAR_ENDPASSEXP(szFuncName, DM_TRUE, bRC); 3850 3851 /* Variation clean up */ 3852 } 3853 3854 /* 3855 * TEST : dm_handle_is_valid - invalid handle 3856 * EXPECTED: rc = DM_FALSE 3857 */ 3858 if (DMVAR_EXEC(HANDLE_IS_VALID_BASE + 11)) { 3859 /* Variation set up */ 3860 3861 /* Variation */ 3862 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid handle)\n", szFuncName); 3863 bRC = dm_handle_is_valid(DM_INVALID_HANP, DM_INVALID_HLEN); 3864 DMVAR_ENDPASSEXP(szFuncName, DM_FALSE, bRC); 3865 3866 /* Variation clean up */ 3867 } 3868 3869 szFuncName = "dm_handle_hash"; 3870 3871 /* 3872 * TEST : dm_handle_hash - invalid hanp 3873 * EXPECTED: rc = ? 3874 */ 3875 if (DMVAR_EXEC(HANDLE_HASH_BASE + 1)) { 3876#ifdef USER_SPACE_FAULTS 3877 /* Variation set up */ 3878 3879 /* Variation */ 3880 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", szFuncName); 3881 rc = dm_handle_hash((char *)INVALID_ADDR, FILE_HANDLELEN); 3882 DMLOG_PRINT(DMLVL_DEBUG, "%s passed with rc = %u\n", 3883 szFuncName); 3884 DMVAR_PASS(); 3885 3886 /* Variation clean up */ 3887#else 3888 DMLOG_PRINT(DMLVL_WARN, 3889 "Test case not built with USER_SPACE_FAULTS defined\n"); 3890 DMVAR_SKIP(); 3891#endif 3892 } 3893 3894 /* 3895 * TEST : dm_handle_hash - file handle 3896 * EXPECTED: rc = ? 3897 */ 3898 if (DMVAR_EXEC(HANDLE_HASH_BASE + 2)) { 3899 int fd; 3900 void *hanp; 3901 size_t hlen; 3902 3903 /* Variation set up */ 3904 if ((fd = 3905 open(DUMMY_FILE, O_RDWR | O_CREAT, 3906 DUMMY_FILE_RW_MODE)) == -1) { 3907 /* No clean up */ 3908 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 3909 -1) { 3910 close(fd); 3911 remove(DUMMY_FILE); 3912 } 3913 if (fd == -1 || rc == -1) { 3914 DMLOG_PRINT(DMLVL_DEBUG, 3915 "Unable to set up variation! (errno = %d)\n", 3916 errno); 3917 DMVAR_SKIP(); 3918 } else { 3919 /* Variation */ 3920 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 3921 szFuncName); 3922 rc = dm_handle_hash(hanp, hlen); 3923 DMLOG_PRINT(DMLVL_DEBUG, "%s passed with rc = %u\n", 3924 szFuncName); 3925 DMVAR_PASS(); 3926 3927 /* Variation clean up */ 3928 rc = close(fd); 3929 rc |= remove(DUMMY_FILE); 3930 if (rc == -1) { 3931 DMLOG_PRINT(DMLVL_DEBUG, 3932 "Unable to clean up variation! (errno = %d)\n", 3933 errno); 3934 } 3935 dm_handle_free(hanp, hlen); 3936 } 3937 } 3938 3939 /* 3940 * TEST : dm_handle_hash - fs handle 3941 * EXPECTED: rc = ? 3942 */ 3943 if (DMVAR_EXEC(HANDLE_HASH_BASE + 3)) { 3944 int fd; 3945 void *hanp; 3946 size_t hlen; 3947 3948 /* Variation set up */ 3949 if ((fd = 3950 open(DUMMY_FILE, O_RDWR | O_CREAT, 3951 DUMMY_FILE_RW_MODE)) == -1) { 3952 /* No clean up */ 3953 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 3954 == -1) { 3955 close(fd); 3956 remove(DUMMY_FILE); 3957 } 3958 if (fd == -1 || rc == -1) { 3959 DMLOG_PRINT(DMLVL_DEBUG, 3960 "Unable to set up variation! (errno = %d)\n", 3961 errno); 3962 DMVAR_SKIP(); 3963 } else { 3964 /* Variation */ 3965 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName); 3966 rc = dm_handle_hash(hanp, hlen); 3967 DMLOG_PRINT(DMLVL_DEBUG, "%s passed with rc = %u\n", 3968 szFuncName); 3969 DMVAR_PASS(); 3970 3971 /* Variation clean up */ 3972 rc = close(fd); 3973 rc |= remove(DUMMY_FILE); 3974 if (rc == -1) { 3975 DMLOG_PRINT(DMLVL_DEBUG, 3976 "Unable to clean up variation! (errno = %d)\n", 3977 errno); 3978 } 3979 dm_handle_free(hanp, hlen); 3980 } 3981 } 3982 3983 /* 3984 * TEST : dm_handle_hash - global handle 3985 * EXPECTED: rc = ? 3986 */ 3987 if (DMVAR_EXEC(HANDLE_HASH_BASE + 4)) { 3988#ifdef USER_SPACE_FAULTS 3989 /* Variation set up */ 3990 3991 /* Variation */ 3992 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 3993 rc = dm_handle_hash(DM_GLOBAL_HANP, DM_GLOBAL_HLEN); 3994 DMLOG_PRINT(DMLVL_DEBUG, "%s passed with rc = %u\n", 3995 szFuncName); 3996 DMVAR_PASS(); 3997 3998 /* Variation clean up */ 3999#else 4000 DMLOG_PRINT(DMLVL_WARN, 4001 "Test case not built with USER_SPACE_FAULTS defined\n"); 4002 DMVAR_SKIP(); 4003#endif 4004 } 4005 4006 szFuncName = "dm_handle_to_fsid"; 4007 4008 /* 4009 * TEST : dm_handle_to_fsid - invalid hanp 4010 * EXPECTED: rc = -1, errno = EFAULT 4011 */ 4012 if (DMVAR_EXEC(HANDLE_TO_FSID_BASE + 1)) { 4013#ifdef USER_SPACE_FAULTS 4014 dm_fsid_t fsidp; 4015 4016 /* Variation set up */ 4017 4018 /* Variation */ 4019 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", szFuncName); 4020 rc = dm_handle_to_fsid((char *)INVALID_ADDR, FILE_HANDLELEN, 4021 &fsidp); 4022 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4023 4024 /* Variation clean up */ 4025#else 4026 DMLOG_PRINT(DMLVL_WARN, 4027 "Test case not built with USER_SPACE_FAULTS defined\n"); 4028 DMVAR_SKIP(); 4029#endif 4030 } 4031 4032 /* 4033 * TEST : dm_handle_to_fsid - invalid fsidp 4034 * EXPECTED: rc = -1, errno = EFAULT 4035 */ 4036 if (DMVAR_EXEC(HANDLE_TO_FSID_BASE + 2)) { 4037#ifdef USER_SPACE_FAULTS 4038 int fd; 4039 void *hanp; 4040 size_t hlen; 4041 4042 /* Variation set up */ 4043 if ((fd = 4044 open(DUMMY_FILE, O_RDWR | O_CREAT, 4045 DUMMY_FILE_RW_MODE)) == -1) { 4046 /* No clean up */ 4047 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4048 -1) { 4049 close(fd); 4050 remove(DUMMY_FILE); 4051 } 4052 if (fd == -1 || rc == -1) { 4053 DMLOG_PRINT(DMLVL_DEBUG, 4054 "Unable to set up variation! (errno = %d)\n", 4055 errno); 4056 DMVAR_SKIP(); 4057 } else { 4058 /* Variation */ 4059 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid fsidp)\n", 4060 szFuncName); 4061 rc = dm_handle_to_fsid(hanp, hlen, 4062 (dm_fsid_t *) INVALID_ADDR); 4063 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4064 4065 /* Variation clean up */ 4066 rc = close(fd); 4067 rc |= remove(DUMMY_FILE); 4068 if (rc == -1) { 4069 DMLOG_PRINT(DMLVL_DEBUG, 4070 "Unable to clean up variation! (errno = %d)\n", 4071 errno); 4072 } 4073 dm_handle_free(hanp, hlen); 4074 } 4075#else 4076 DMLOG_PRINT(DMLVL_WARN, 4077 "Test case not built with USER_SPACE_FAULTS defined\n"); 4078 DMVAR_SKIP(); 4079#endif 4080 } 4081 4082 /* 4083 * TEST : dm_handle_to_fsid - file handle 4084 * EXPECTED: rc = 0 4085 */ 4086 if (DMVAR_EXEC(HANDLE_TO_FSID_BASE + 3)) { 4087 int fd; 4088 void *hanp, *fshanp; 4089 size_t hlen, fshlen; 4090 dm_fsid_t fsidp; 4091 4092 /* Variation set up */ 4093 if ((fd = 4094 open(DUMMY_FILE, O_RDWR | O_CREAT, 4095 DUMMY_FILE_RW_MODE)) == -1) { 4096 /* No clean up */ 4097 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4098 -1) { 4099 close(fd); 4100 remove(DUMMY_FILE); 4101 } else 4102 if ((rc = 4103 dm_path_to_fshandle(DUMMY_FILE, &fshanp, 4104 &fshlen)) == -1) { 4105 close(fd); 4106 remove(DUMMY_FILE); 4107 dm_handle_free(hanp, hlen); 4108 } 4109 if (fd == -1 || rc == -1) { 4110 DMLOG_PRINT(DMLVL_DEBUG, 4111 "Unable to set up variation! (errno = %d)\n", 4112 errno); 4113 DMVAR_SKIP(); 4114 } else { 4115 /* Variation */ 4116 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 4117 szFuncName); 4118 rc = dm_handle_to_fsid(hanp, hlen, &fsidp); 4119 if (rc == 0) { 4120 if (memcmp(hanp, &fsidp, sizeof(dm_fsid_t)) == 4121 0) { 4122 DMLOG_PRINT(DMLVL_DEBUG, 4123 "%s passed with expected rc = %d\n", 4124 szFuncName, rc); 4125 DMVAR_PASS(); 4126 } else { 4127 DMLOG_PRINT(DMLVL_ERR, 4128 "%s failed with expected rc = %d but unexpected fsid (0x%16llX vs 0x%16llX)\n", 4129 szFuncName, rc, fsidp, 4130 *(dm_fsid_t *) hanp); 4131 DMVAR_FAIL(); 4132 } 4133 } else { 4134 DMLOG_PRINT(DMLVL_ERR, 4135 "%s failed with unexpected rc = %d (errno = %d)\n", 4136 szFuncName, rc, errno); 4137 DMVAR_FAIL(); 4138 } 4139 4140 /* Variation clean up */ 4141 rc = close(fd); 4142 rc |= remove(DUMMY_FILE); 4143 if (rc == -1) { 4144 DMLOG_PRINT(DMLVL_DEBUG, 4145 "Unable to clean up variation! (errno = %d)\n", 4146 errno); 4147 } 4148 dm_handle_free(hanp, hlen); 4149 dm_handle_free(fshanp, fshlen); 4150 } 4151 } 4152 4153 /* 4154 * TEST : dm_handle_to_fsid - fs handle 4155 * EXPECTED: rc = 0 4156 */ 4157 if (DMVAR_EXEC(HANDLE_TO_FSID_BASE + 4)) { 4158 int fd; 4159 void *hanp, *fshanp; 4160 size_t hlen, fshlen; 4161 dm_fsid_t fsidp; 4162 4163 /* Variation set up */ 4164 if ((fd = 4165 open(DUMMY_FILE, O_RDWR | O_CREAT, 4166 DUMMY_FILE_RW_MODE)) == -1) { 4167 /* No clean up */ 4168 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4169 -1) { 4170 close(fd); 4171 remove(DUMMY_FILE); 4172 } else 4173 if ((rc = 4174 dm_path_to_fshandle(DUMMY_FILE, &fshanp, 4175 &fshlen)) == -1) { 4176 close(fd); 4177 remove(DUMMY_FILE); 4178 dm_handle_free(hanp, hlen); 4179 } 4180 if (fd == -1 || rc == -1) { 4181 DMLOG_PRINT(DMLVL_DEBUG, 4182 "Unable to set up variation! (errno = %d)\n", 4183 errno); 4184 DMVAR_SKIP(); 4185 } else { 4186 /* Variation */ 4187 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName); 4188 rc = dm_handle_to_fsid(hanp, hlen, &fsidp); 4189 if (rc == 0) { 4190 if (memcmp(hanp, &fsidp, sizeof(dm_fsid_t)) == 4191 0) { 4192 DMLOG_PRINT(DMLVL_DEBUG, 4193 "%s passed with expected rc = %d\n", 4194 szFuncName, rc); 4195 DMVAR_PASS(); 4196 } else { 4197 DMLOG_PRINT(DMLVL_ERR, 4198 "%s failed with expected rc = %d but unexpected fsid (0x%16llX vs 0x%16llX)\n", 4199 szFuncName, rc, fsidp, 4200 *(dm_fsid_t *) hanp); 4201 DMVAR_FAIL(); 4202 } 4203 } else { 4204 DMLOG_PRINT(DMLVL_ERR, 4205 "%s failed with unexpected rc = %d (errno = %d)\n", 4206 szFuncName, rc, errno); 4207 DMVAR_FAIL(); 4208 } 4209 4210 /* Variation clean up */ 4211 rc = close(fd); 4212 rc |= remove(DUMMY_FILE); 4213 if (rc == -1) { 4214 DMLOG_PRINT(DMLVL_DEBUG, 4215 "Unable to clean up variation! (errno = %d)\n", 4216 errno); 4217 } 4218 dm_handle_free(hanp, hlen); 4219 dm_handle_free(fshanp, fshlen); 4220 } 4221 } 4222 4223 /* 4224 * TEST : dm_handle_to_fsid - global handle 4225 * EXPECTED: rc = -1, errno = EBADF 4226 */ 4227 if (DMVAR_EXEC(HANDLE_TO_FSID_BASE + 5)) { 4228 dm_fsid_t fsidp; 4229 4230 /* Variation set up */ 4231 4232 /* Variation */ 4233 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 4234 rc = dm_handle_to_fsid(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, &fsidp); 4235 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4236 4237 /* Variation clean up */ 4238 } 4239 4240 szFuncName = "dm_handle_to_igen"; 4241 4242 /* 4243 * TEST : dm_handle_to_igen - invalid hanp 4244 * EXPECTED: rc = -1, errno = EFAULT 4245 */ 4246 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 1)) { 4247#ifdef USER_SPACE_FAULTS 4248 dm_igen_t igen; 4249 4250 /* Variation set up */ 4251 4252 /* Variation */ 4253 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", szFuncName); 4254 rc = dm_handle_to_igen((char *)INVALID_ADDR, FILE_HANDLELEN, 4255 &igen); 4256 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4257 4258 /* Variation clean up */ 4259#else 4260 DMLOG_PRINT(DMLVL_WARN, 4261 "Test case not built with USER_SPACE_FAULTS defined\n"); 4262 DMVAR_SKIP(); 4263#endif 4264 } 4265 4266 /* 4267 * TEST : dm_handle_to_igen - invalid igenp 4268 * EXPECTED: rc = -1, errno = EFAULT 4269 */ 4270 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 2)) { 4271#ifdef USER_SPACE_FAULTS 4272 int fd; 4273 void *hanp; 4274 size_t hlen; 4275 4276 /* Variation set up */ 4277 if ((fd = 4278 open(DUMMY_FILE, O_RDWR | O_CREAT, 4279 DUMMY_FILE_RW_MODE)) == -1) { 4280 /* No clean up */ 4281 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4282 -1) { 4283 close(fd); 4284 remove(DUMMY_FILE); 4285 } 4286 if (fd == -1 || rc == -1) { 4287 DMLOG_PRINT(DMLVL_DEBUG, 4288 "Unable to set up variation! (errno = %d)\n", 4289 errno); 4290 DMVAR_SKIP(); 4291 } else { 4292 /* Variation */ 4293 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid igenp)\n", 4294 szFuncName); 4295 rc = dm_handle_to_igen(hanp, hlen, 4296 (dm_igen_t *) INVALID_ADDR); 4297 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4298 4299 /* Variation clean up */ 4300 rc = close(fd); 4301 rc |= remove(DUMMY_FILE); 4302 if (rc == -1) { 4303 DMLOG_PRINT(DMLVL_DEBUG, 4304 "Unable to clean up variation! (errno = %d)\n", 4305 errno); 4306 } 4307 dm_handle_free(hanp, hlen); 4308 } 4309#else 4310 DMLOG_PRINT(DMLVL_WARN, 4311 "Test case not built with USER_SPACE_FAULTS defined\n"); 4312 DMVAR_SKIP(); 4313#endif 4314 } 4315 4316 /* 4317 * TEST : dm_handle_to_igen - file handle 4318 * EXPECTED: rc = 0 4319 */ 4320 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 3)) { 4321 int fd; 4322 void *hanp; 4323 size_t hlen; 4324 dm_igen_t igen; 4325 4326 /* Variation set up */ 4327 if ((fd = 4328 open(DUMMY_FILE, O_RDWR | O_CREAT, 4329 DUMMY_FILE_RW_MODE)) == -1) { 4330 /* No clean up */ 4331 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4332 -1) { 4333 close(fd); 4334 remove(DUMMY_FILE); 4335 } 4336 if (fd == -1 || rc == -1) { 4337 DMLOG_PRINT(DMLVL_DEBUG, 4338 "Unable to set up variation! (errno = %d)\n", 4339 errno); 4340 DMVAR_SKIP(); 4341 } else { 4342 /* Variation */ 4343 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 4344 szFuncName); 4345 rc = dm_handle_to_igen(hanp, hlen, &igen); 4346 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 4347 4348 /* Variation clean up */ 4349 rc = close(fd); 4350 rc |= remove(DUMMY_FILE); 4351 if (rc == -1) { 4352 DMLOG_PRINT(DMLVL_DEBUG, 4353 "Unable to clean up variation! (errno = %d)\n", 4354 errno); 4355 } 4356 dm_handle_free(hanp, hlen); 4357 } 4358 } 4359 4360 /* 4361 * TEST : dm_handle_to_igen - directory handle 4362 * EXPECTED: rc = 0 4363 */ 4364 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 4)) { 4365 void *hanp; 4366 size_t hlen; 4367 dm_igen_t igen; 4368 4369 /* Variation set up */ 4370 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 4371 /* No clean up */ 4372 } else if ((rc = dm_path_to_handle(DUMMY_SUBDIR, &hanp, &hlen)) 4373 == -1) { 4374 rmdir(DUMMY_SUBDIR); 4375 } 4376 if (rc == -1) { 4377 DMLOG_PRINT(DMLVL_DEBUG, 4378 "Unable to set up variation! (errno = %d)\n", 4379 errno); 4380 DMVAR_SKIP(); 4381 } else { 4382 /* Variation */ 4383 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 4384 szFuncName); 4385 rc = dm_handle_to_igen(hanp, hlen, &igen); 4386 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 4387 4388 /* Variation clean up */ 4389 rc = rmdir(DUMMY_SUBDIR); 4390 if (rc == -1) { 4391 DMLOG_PRINT(DMLVL_DEBUG, 4392 "Unable to clean up variation! (errno = %d)\n", 4393 errno); 4394 } 4395 dm_handle_free(hanp, hlen); 4396 } 4397 } 4398 4399 /* 4400 * TEST : dm_handle_to_igen - fs handle from file 4401 * EXPECTED: rc = -1, errno = EBADF 4402 */ 4403 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 5)) { 4404 int fd; 4405 void *hanp; 4406 size_t hlen; 4407 dm_igen_t igen; 4408 4409 /* Variation set up */ 4410 if ((fd = 4411 open(DUMMY_FILE, O_RDWR | O_CREAT, 4412 DUMMY_FILE_RW_MODE)) == -1) { 4413 /* No clean up */ 4414 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 4415 == -1) { 4416 close(fd); 4417 remove(DUMMY_FILE); 4418 } 4419 if (fd == -1 || rc == -1) { 4420 DMLOG_PRINT(DMLVL_DEBUG, 4421 "Unable to set up variation! (errno = %d)\n", 4422 errno); 4423 DMVAR_SKIP(); 4424 } else { 4425 /* Variation */ 4426 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from file)\n", 4427 szFuncName); 4428 rc = dm_handle_to_igen(hanp, hlen, &igen); 4429 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4430 4431 /* Variation clean up */ 4432 rc = close(fd); 4433 rc |= remove(DUMMY_FILE); 4434 if (rc == -1) { 4435 DMLOG_PRINT(DMLVL_DEBUG, 4436 "Unable to clean up variation! (errno = %d)\n", 4437 errno); 4438 } 4439 dm_handle_free(hanp, hlen); 4440 } 4441 } 4442 4443 /* 4444 * TEST : dm_handle_to_igen - fs handle from directory 4445 * EXPECTED: rc = -1, errno = EBADF 4446 */ 4447 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 6)) { 4448 void *hanp; 4449 size_t hlen; 4450 dm_igen_t igen; 4451 4452 /* Variation set up */ 4453 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 4454 /* No clean up */ 4455 } else 4456 if ((rc = 4457 dm_path_to_fshandle(DUMMY_SUBDIR, &hanp, 4458 &hlen)) == -1) { 4459 rmdir(DUMMY_SUBDIR); 4460 } 4461 if (rc == -1) { 4462 DMLOG_PRINT(DMLVL_DEBUG, 4463 "Unable to set up variation! (errno = %d)\n", 4464 errno); 4465 DMVAR_SKIP(); 4466 } else { 4467 /* Variation */ 4468 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from dir)\n", 4469 szFuncName); 4470 rc = dm_handle_to_igen(hanp, hlen, &igen); 4471 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4472 4473 /* Variation clean up */ 4474 rc = rmdir(DUMMY_SUBDIR); 4475 if (rc == -1) { 4476 DMLOG_PRINT(DMLVL_DEBUG, 4477 "Unable to clean up variation! (errno = %d)\n", 4478 errno); 4479 } 4480 dm_handle_free(hanp, hlen); 4481 } 4482 } 4483 4484 /* 4485 * TEST : dm_handle_to_igen - global handle 4486 * EXPECTED: rc = -1, errno = EBADF 4487 */ 4488 if (DMVAR_EXEC(HANDLE_TO_IGEN_BASE + 7)) { 4489 dm_igen_t igen; 4490 4491 /* Variation set up */ 4492 4493 /* Variation */ 4494 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 4495 rc = dm_handle_to_igen(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, &igen); 4496 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4497 4498 /* Variation clean up */ 4499 } 4500 4501 szFuncName = "dm_handle_to_ino"; 4502 4503 /* 4504 * TEST : dm_handle_to_ino - invalid hanp 4505 * EXPECTED: rc = -1, errno = EFAULT 4506 */ 4507 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 1)) { 4508#ifdef USER_SPACE_FAULTS 4509 dm_ino_t ino; 4510 4511 /* Variation set up */ 4512 4513 /* Variation */ 4514 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", szFuncName); 4515 rc = dm_handle_to_ino((char *)INVALID_ADDR, FILE_HANDLELEN, 4516 &ino); 4517 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4518 4519 /* Variation clean up */ 4520#else 4521 DMLOG_PRINT(DMLVL_WARN, 4522 "Test case not built with USER_SPACE_FAULTS defined\n"); 4523 DMVAR_SKIP(); 4524#endif 4525 } 4526 4527 /* 4528 * TEST : dm_handle_to_ino - invalid inop 4529 * EXPECTED: rc = -1, errno = EFAULT 4530 */ 4531 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 2)) { 4532#ifdef USER_SPACE_FAULTS 4533 int fd; 4534 void *hanp; 4535 size_t hlen; 4536 4537 /* Variation set up */ 4538 if ((fd = 4539 open(DUMMY_FILE, O_RDWR | O_CREAT, 4540 DUMMY_FILE_RW_MODE)) == -1) { 4541 /* No clean up */ 4542 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4543 -1) { 4544 close(fd); 4545 remove(DUMMY_FILE); 4546 } 4547 if (fd == -1 || rc == -1) { 4548 DMLOG_PRINT(DMLVL_DEBUG, 4549 "Unable to set up variation! (errno = %d)\n", 4550 errno); 4551 DMVAR_SKIP(); 4552 } else { 4553 /* Variation */ 4554 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid inop)\n", 4555 szFuncName); 4556 rc = dm_handle_to_ino(hanp, hlen, 4557 (dm_ino_t *) INVALID_ADDR); 4558 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4559 4560 /* Variation clean up */ 4561 rc = close(fd); 4562 rc |= remove(DUMMY_FILE); 4563 if (rc == -1) { 4564 DMLOG_PRINT(DMLVL_DEBUG, 4565 "Unable to clean up variation! (errno = %d)\n", 4566 errno); 4567 } 4568 dm_handle_free(hanp, hlen); 4569 } 4570#else 4571 DMLOG_PRINT(DMLVL_WARN, 4572 "Test case not built with USER_SPACE_FAULTS defined\n"); 4573 DMVAR_SKIP(); 4574#endif 4575 } 4576 4577 /* 4578 * TEST : dm_handle_to_ino - file handle 4579 * EXPECTED: rc = 0 4580 */ 4581 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 3)) { 4582 int fd; 4583 void *hanp; 4584 size_t hlen; 4585 dm_ino_t ino; 4586 4587 /* Variation set up */ 4588 if ((fd = 4589 open(DUMMY_FILE, O_RDWR | O_CREAT, 4590 DUMMY_FILE_RW_MODE)) == -1) { 4591 /* No clean up */ 4592 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp, &hlen)) == 4593 -1) { 4594 close(fd); 4595 remove(DUMMY_FILE); 4596 } 4597 if (fd == -1 || rc == -1) { 4598 DMLOG_PRINT(DMLVL_DEBUG, 4599 "Unable to set up variation! (errno = %d)\n", 4600 errno); 4601 DMVAR_SKIP(); 4602 } else { 4603 /* Variation */ 4604 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 4605 szFuncName); 4606 rc = dm_handle_to_ino(hanp, hlen, &ino); 4607 if (rc == 0) { 4608 struct stat statfs; 4609 4610 DMLOG_PRINT(DMLVL_DEBUG, 4611 "%s passed with expected rc = %d\n", 4612 szFuncName, rc); 4613 rc = stat(DUMMY_FILE, &statfs); 4614 if (rc == 0) { 4615 if (ino == statfs.st_ino) { 4616 DMLOG_PRINT(DMLVL_DEBUG, 4617 "ino %d from stat() matches returned value\n", 4618 statfs.st_ino); 4619 DMVAR_PASS(); 4620 } else { 4621 DMLOG_PRINT(DMLVL_ERR, 4622 "BUT... ino %d from stat() does not match returned value %lld\n", 4623 statfs.st_ino, ino); 4624 DMVAR_FAIL(); 4625 } 4626 } else { 4627 DMLOG_PRINT(DMLVL_ERR, 4628 "BUT... stat() failed with rc = %d (errno = %d)\n", 4629 rc, errno); 4630 DMVAR_FAIL(); 4631 } 4632 } else { 4633 DMLOG_PRINT(DMLVL_ERR, 4634 "%s failed with unexpected rc = %d (errno = %d)\n", 4635 szFuncName, rc, errno); 4636 DMVAR_FAIL(); 4637 } 4638 4639 /* Variation clean up */ 4640 rc = close(fd); 4641 rc |= remove(DUMMY_FILE); 4642 if (rc == -1) { 4643 DMLOG_PRINT(DMLVL_DEBUG, 4644 "Unable to clean up variation! (errno = %d)\n", 4645 errno); 4646 } 4647 dm_handle_free(hanp, hlen); 4648 } 4649 } 4650 4651 /* 4652 * TEST : dm_handle_to_ino - directory handle 4653 * EXPECTED: rc = 0 4654 */ 4655 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 4)) { 4656 void *hanp; 4657 size_t hlen; 4658 dm_ino_t ino; 4659 4660 /* Variation set up */ 4661 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 4662 /* No clean up */ 4663 } else if ((rc = dm_path_to_handle(DUMMY_SUBDIR, &hanp, &hlen)) 4664 == -1) { 4665 rmdir(DUMMY_SUBDIR); 4666 } 4667 if (rc == -1) { 4668 DMLOG_PRINT(DMLVL_DEBUG, 4669 "Unable to set up variation! (errno = %d)\n", 4670 errno); 4671 DMVAR_SKIP(); 4672 } else { 4673 /* Variation */ 4674 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 4675 szFuncName); 4676 rc = dm_handle_to_ino(hanp, hlen, &ino); 4677 if (rc == 0) { 4678 struct stat statfs; 4679 4680 DMLOG_PRINT(DMLVL_DEBUG, 4681 "%s passed with expected rc = %d\n", 4682 szFuncName, rc); 4683 rc = stat(DUMMY_SUBDIR, &statfs); 4684 if (rc == 0) { 4685 if (ino == statfs.st_ino) { 4686 DMLOG_PRINT(DMLVL_DEBUG, 4687 "ino %d from stat() matches returned value\n", 4688 statfs.st_ino); 4689 DMVAR_PASS(); 4690 } else { 4691 DMLOG_PRINT(DMLVL_ERR, 4692 "BUT... ino %d from stat() does not match returned value %lld\n", 4693 statfs.st_ino, ino); 4694 DMVAR_FAIL(); 4695 } 4696 } else { 4697 DMLOG_PRINT(DMLVL_ERR, 4698 "BUT... stat() failed with rc = %d (errno = %d)\n", 4699 rc, errno); 4700 DMVAR_FAIL(); 4701 } 4702 } else { 4703 DMLOG_PRINT(DMLVL_ERR, 4704 "%s failed with unexpected rc = %d (errno = %d)\n", 4705 szFuncName, rc, errno); 4706 DMVAR_FAIL(); 4707 } 4708 4709 /* Variation clean up */ 4710 rc = rmdir(DUMMY_SUBDIR); 4711 if (rc == -1) { 4712 DMLOG_PRINT(DMLVL_DEBUG, 4713 "Unable to clean up variation! (errno = %d)\n", 4714 errno); 4715 } 4716 dm_handle_free(hanp, hlen); 4717 } 4718 } 4719 4720 /* 4721 * TEST : dm_handle_to_ino - fs handle from file 4722 * EXPECTED: rc = -1, errno = EBADF 4723 */ 4724 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 5)) { 4725 int fd; 4726 void *hanp; 4727 size_t hlen; 4728 dm_ino_t ino; 4729 4730 /* Variation set up */ 4731 if ((fd = 4732 open(DUMMY_FILE, O_RDWR | O_CREAT, 4733 DUMMY_FILE_RW_MODE)) == -1) { 4734 /* No clean up */ 4735 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 4736 == -1) { 4737 close(fd); 4738 remove(DUMMY_FILE); 4739 } 4740 if (fd == -1 || rc == -1) { 4741 DMLOG_PRINT(DMLVL_DEBUG, 4742 "Unable to set up variation! (errno = %d)\n", 4743 errno); 4744 DMVAR_SKIP(); 4745 } else { 4746 /* Variation */ 4747 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from file)\n", 4748 szFuncName); 4749 rc = dm_handle_to_ino(hanp, hlen, &ino); 4750 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4751 4752 /* Variation clean up */ 4753 rc = close(fd); 4754 rc |= remove(DUMMY_FILE); 4755 if (rc == -1) { 4756 DMLOG_PRINT(DMLVL_DEBUG, 4757 "Unable to clean up variation! (errno = %d)\n", 4758 errno); 4759 } 4760 dm_handle_free(hanp, hlen); 4761 } 4762 } 4763 4764 /* 4765 * TEST : dm_handle_to_ino - fs handle from directory 4766 * EXPECTED: rc = -1, errno = EBADF 4767 */ 4768 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 6)) { 4769 void *hanp; 4770 size_t hlen; 4771 dm_ino_t ino; 4772 4773 /* Variation set up */ 4774 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 4775 /* No clean up */ 4776 } else 4777 if ((rc = 4778 dm_path_to_fshandle(DUMMY_SUBDIR, &hanp, 4779 &hlen)) == -1) { 4780 rmdir(DUMMY_SUBDIR); 4781 } 4782 if (rc == -1) { 4783 DMLOG_PRINT(DMLVL_DEBUG, 4784 "Unable to set up variation! (errno = %d)\n", 4785 errno); 4786 DMVAR_SKIP(); 4787 } else { 4788 /* Variation */ 4789 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle from dir)\n", 4790 szFuncName); 4791 rc = dm_handle_to_ino(hanp, hlen, &ino); 4792 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4793 4794 /* Variation clean up */ 4795 rc = rmdir(DUMMY_SUBDIR); 4796 if (rc == -1) { 4797 DMLOG_PRINT(DMLVL_DEBUG, 4798 "Unable to clean up variation! (errno = %d)\n", 4799 errno); 4800 } 4801 dm_handle_free(hanp, hlen); 4802 } 4803 } 4804 4805 /* 4806 * TEST : dm_handle_to_ino - global handle 4807 * EXPECTED: rc = -1, errno = EBADF 4808 */ 4809 if (DMVAR_EXEC(HANDLE_TO_INO_BASE + 7)) { 4810 dm_ino_t ino; 4811 /* Variation set up */ 4812 4813 /* Variation */ 4814 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 4815 rc = dm_handle_to_ino(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, &ino); 4816 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 4817 4818 /* Variation clean up */ 4819 } 4820 4821 szFuncName = "dm_make_handle"; 4822 4823 /* 4824 * TEST : dm_make_handle - invalid fsidp 4825 * EXPECTED: rc = -1, errno = EFAULT 4826 */ 4827 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 1)) { 4828#ifdef USER_SPACE_FAULTS 4829 void *hanp; 4830 size_t hlen; 4831 dm_ino_t ino; 4832 dm_igen_t igen; 4833 4834 /* Variation set up */ 4835 4836 /* Variation */ 4837 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid fsidp)\n", szFuncName); 4838 rc = dm_make_handle((dm_fsid_t *) INVALID_ADDR, &ino, &igen, 4839 &hanp, &hlen); 4840 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4841 4842 /* Variation clean up */ 4843#else 4844 DMLOG_PRINT(DMLVL_WARN, 4845 "Test case not built with USER_SPACE_FAULTS defined\n"); 4846 DMVAR_SKIP(); 4847#endif 4848 } 4849 4850 /* 4851 * TEST : dm_make_handle - invalid inop 4852 * EXPECTED: rc = -1, errno = EFAULT 4853 */ 4854 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 2)) { 4855#ifdef USER_SPACE_FAULTS 4856 void *hanp; 4857 size_t hlen; 4858 dm_fsid_t fsid; 4859 dm_igen_t igen; 4860 4861 /* Variation set up */ 4862 4863 /* Variation */ 4864 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid inop)\n", szFuncName); 4865 rc = dm_make_handle(&fsid, (dm_ino_t *) INVALID_ADDR, &igen, 4866 &hanp, &hlen); 4867 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4868 4869 /* Variation clean up */ 4870#else 4871 DMLOG_PRINT(DMLVL_WARN, 4872 "Test case not built with USER_SPACE_FAULTS defined\n"); 4873 DMVAR_SKIP(); 4874#endif 4875 } 4876 4877 /* 4878 * TEST : dm_make_handle - invalid igenp 4879 * EXPECTED: rc = -1, errno = EFAULT 4880 */ 4881 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 3)) { 4882#ifdef USER_SPACE_FAULTS 4883 void *hanp; 4884 size_t hlen; 4885 dm_fsid_t fsid; 4886 dm_ino_t ino; 4887 4888 /* Variation set up */ 4889 4890 /* Variation */ 4891 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid igenp)\n", szFuncName); 4892 rc = dm_make_handle(&fsid, &ino, (dm_igen_t *) INVALID_ADDR, 4893 &hanp, &hlen); 4894 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4895 4896 /* Variation clean up */ 4897#else 4898 DMLOG_PRINT(DMLVL_WARN, 4899 "Test case not built with USER_SPACE_FAULTS defined\n"); 4900 DMVAR_SKIP(); 4901#endif 4902 } 4903 4904 /* 4905 * TEST : dm_make_handle - invalid hanpp 4906 * EXPECTED: rc = -1, errno = EFAULT 4907 */ 4908 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 4)) { 4909#ifdef USER_SPACE_FAULTS 4910 size_t hlen; 4911 dm_fsid_t fsid; 4912 dm_igen_t igen; 4913 dm_ino_t ino; 4914 4915 /* Variation set up */ 4916 4917 /* Variation */ 4918 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanpp)\n", szFuncName); 4919 rc = dm_make_handle(&fsid, &ino, &igen, (void **)INVALID_ADDR, 4920 &hlen); 4921 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4922 4923 /* Variation clean up */ 4924#else 4925 DMLOG_PRINT(DMLVL_WARN, 4926 "Test case not built with USER_SPACE_FAULTS defined\n"); 4927 DMVAR_SKIP(); 4928#endif 4929 } 4930 4931 /* 4932 * TEST : dm_make_handle - invalid hlenp 4933 * EXPECTED: rc = -1, errno = EFAULT 4934 */ 4935 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 5)) { 4936#ifdef USER_SPACE_FAULTS 4937 void *hanp; 4938 dm_fsid_t fsid; 4939 dm_igen_t igen; 4940 dm_ino_t ino; 4941 4942 /* Variation set up */ 4943 4944 /* Variation */ 4945 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlenp)\n", szFuncName); 4946 rc = dm_make_handle(&fsid, &ino, &igen, &hanp, 4947 (size_t *) INVALID_ADDR); 4948 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 4949 4950 /* Variation clean up */ 4951#else 4952 DMLOG_PRINT(DMLVL_WARN, 4953 "Test case not built with USER_SPACE_FAULTS defined\n"); 4954 DMVAR_SKIP(); 4955#endif 4956 } 4957 4958 /* 4959 * TEST : dm_make_handle - file 4960 * EXPECTED: rc = 0 4961 */ 4962 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 6)) { 4963 int fd; 4964 void *hanp1, *hanp2; 4965 size_t hlen1, hlen2; 4966 dm_fsid_t fsid; 4967 dm_igen_t igen; 4968 dm_ino_t ino; 4969 4970 /* Variation set up */ 4971 if ((fd = 4972 open(DUMMY_FILE, O_RDWR | O_CREAT, 4973 DUMMY_FILE_RW_MODE)) == -1) { 4974 /* No clean up */ 4975 } else if ((rc = dm_path_to_handle(DUMMY_FILE, &hanp1, &hlen1)) 4976 == -1) { 4977 close(fd); 4978 remove(DUMMY_FILE); 4979 } else if (((rc = dm_handle_to_fsid(hanp1, hlen1, &fsid)) == -1) 4980 || ((rc = dm_handle_to_igen(hanp1, hlen1, &igen)) == 4981 -1) 4982 || ((rc = dm_handle_to_ino(hanp1, hlen1, &ino)) == 4983 -1)) { 4984 dm_handle_free(hanp1, hlen1); 4985 close(fd); 4986 remove(DUMMY_FILE); 4987 } 4988 if (fd == -1 || rc == -1) { 4989 DMLOG_PRINT(DMLVL_DEBUG, 4990 "Unable to set up variation! (errno = %d)\n", 4991 errno); 4992 DMVAR_SKIP(); 4993 } else { 4994 /* Variation */ 4995 DMLOG_PRINT(DMLVL_DEBUG, "%s(file)\n", szFuncName); 4996 rc = dm_make_handle(&fsid, &ino, &igen, &hanp2, &hlen2); 4997 if (rc == 0) { 4998 DMLOG_PRINT(DMLVL_DEBUG, 4999 "hanp = %p, hlen = %d\n", hanp2, 5000 hlen2); 5001 dm_LogHandle(hanp2, hlen2); 5002 5003 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 5004 if (rc == 0) { 5005 DMLOG_PRINT(DMLVL_DEBUG, 5006 "%s passed with expected rc = 0\n", 5007 szFuncName); 5008 DMVAR_PASS(); 5009 } else { 5010 DMLOG_PRINT(DMLVL_ERR, 5011 "%s failed with expected rc = 0 but unexpected dm_handle_cmp rc = %d\n", 5012 szFuncName, rc); 5013 DMVAR_FAIL(); 5014 } 5015 } else { 5016 DMLOG_PRINT(DMLVL_ERR, 5017 "%s failed with unexpected rc = %d (errno = %d)\n", 5018 szFuncName, rc, errno); 5019 DMVAR_FAIL(); 5020 } 5021 5022 /* Variation clean up */ 5023 rc = close(fd); 5024 rc |= remove(DUMMY_FILE); 5025 if (rc == -1) { 5026 DMLOG_PRINT(DMLVL_DEBUG, 5027 "Unable to clean up variation! (errno = %d)\n", 5028 errno); 5029 } 5030 dm_handle_free(hanp1, hlen1); 5031 dm_handle_free(hanp2, hlen2); 5032 } 5033 } 5034 5035 /* 5036 * TEST : dm_make_handle - directory 5037 * EXPECTED: rc = 0 5038 */ 5039 if (DMVAR_EXEC(MAKE_HANDLE_BASE + 7)) { 5040 void *hanp1, *hanp2; 5041 size_t hlen1, hlen2; 5042 dm_fsid_t fsid; 5043 dm_igen_t igen; 5044 dm_ino_t ino; 5045 5046 /* Variation set up */ 5047 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 5048 /* No clean up */ 5049 } else 5050 if ((rc = 5051 dm_path_to_handle(DUMMY_SUBDIR, &hanp1, 5052 &hlen1)) == -1) { 5053 rmdir(DUMMY_SUBDIR); 5054 } else if (((rc = dm_handle_to_fsid(hanp1, hlen1, &fsid)) == -1) 5055 || ((rc = dm_handle_to_igen(hanp1, hlen1, &igen)) == 5056 -1) 5057 || ((rc = dm_handle_to_ino(hanp1, hlen1, &ino)) == 5058 -1)) { 5059 dm_handle_free(hanp1, hlen1); 5060 rmdir(DUMMY_SUBDIR); 5061 } 5062 if (rc == -1) { 5063 DMLOG_PRINT(DMLVL_DEBUG, 5064 "Unable to set up variation! (errno = %d)\n", 5065 errno); 5066 DMVAR_SKIP(); 5067 } else { 5068 /* Variation */ 5069 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir)\n", szFuncName); 5070 rc = dm_make_handle(&fsid, &ino, &igen, &hanp2, &hlen2); 5071 if (rc == 0) { 5072 DMLOG_PRINT(DMLVL_DEBUG, 5073 "hanp = %p, hlen = %d\n", hanp2, 5074 hlen2); 5075 dm_LogHandle(hanp2, hlen2); 5076 5077 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 5078 if (rc == 0) { 5079 DMLOG_PRINT(DMLVL_DEBUG, 5080 "%s passed with expected rc = 0\n", 5081 szFuncName); 5082 DMVAR_PASS(); 5083 } else { 5084 DMLOG_PRINT(DMLVL_ERR, 5085 "%s failed with expected rc = 0 but unexpected dm_handle_cmp rc = %d\n", 5086 szFuncName, rc); 5087 DMVAR_FAIL(); 5088 } 5089 } else { 5090 DMLOG_PRINT(DMLVL_ERR, 5091 "%s failed with unexpected rc = %d (errno = %d)\n", 5092 szFuncName, rc, errno); 5093 DMVAR_FAIL(); 5094 } 5095 5096 /* Variation clean up */ 5097 rc = rmdir(DUMMY_SUBDIR); 5098 if (rc == -1) { 5099 DMLOG_PRINT(DMLVL_DEBUG, 5100 "Unable to clean up variation! (errno = %d)\n", 5101 errno); 5102 } 5103 dm_handle_free(hanp1, hlen1); 5104 dm_handle_free(hanp2, hlen2); 5105 } 5106 } 5107 5108 szFuncName = "dm_make_fshandle"; 5109 5110 /* 5111 * TEST : dm_make_fshandle - invalid fsidp 5112 * EXPECTED: rc = -1, errno = EFAULT 5113 */ 5114 if (DMVAR_EXEC(MAKE_FSHANDLE_BASE + 1)) { 5115#ifdef USER_SPACE_FAULTS 5116 void *hanp; 5117 size_t hlen; 5118 5119 /* Variation set up */ 5120 5121 /* Variation */ 5122 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid fsidp)\n", szFuncName); 5123 rc = dm_make_fshandle((dm_fsid_t *) INVALID_ADDR, &hanp, &hlen); 5124 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5125 5126 /* Variation clean up */ 5127#else 5128 DMLOG_PRINT(DMLVL_WARN, 5129 "Test case not built with USER_SPACE_FAULTS defined\n"); 5130 DMVAR_SKIP(); 5131#endif 5132 } 5133 5134 /* 5135 * TEST : dm_make_fshandle - invalid hanpp 5136 * EXPECTED: rc = -1, errno = EFAULT 5137 */ 5138 if (DMVAR_EXEC(MAKE_FSHANDLE_BASE + 2)) { 5139#ifdef USER_SPACE_FAULTS 5140 size_t hlen; 5141 dm_fsid_t fsid; 5142 5143 /* Variation set up */ 5144 5145 /* Variation */ 5146 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanpp)\n", szFuncName); 5147 rc = dm_make_fshandle(&fsid, (void **)INVALID_ADDR, &hlen); 5148 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5149 5150 /* Variation clean up */ 5151#else 5152 DMLOG_PRINT(DMLVL_WARN, 5153 "Test case not built with USER_SPACE_FAULTS defined\n"); 5154 DMVAR_SKIP(); 5155#endif 5156 } 5157 5158 /* 5159 * TEST : dm_make_fshandle - invalid hlenp 5160 * EXPECTED: rc = -1, errno = EFAULT 5161 */ 5162 if (DMVAR_EXEC(MAKE_FSHANDLE_BASE + 3)) { 5163#ifdef USER_SPACE_FAULTS 5164 void *hanp; 5165 dm_fsid_t fsid; 5166 5167 /* Variation set up */ 5168 5169 /* Variation */ 5170 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlenp)\n", szFuncName); 5171 rc = dm_make_fshandle(&fsid, &hanp, (size_t *) INVALID_ADDR); 5172 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5173 5174 /* Variation clean up */ 5175#else 5176 DMLOG_PRINT(DMLVL_WARN, 5177 "Test case not built with USER_SPACE_FAULTS defined\n"); 5178 DMVAR_SKIP(); 5179#endif 5180 } 5181 5182 /* 5183 * TEST : dm_make_fshandle - file handle 5184 * EXPECTED: rc = 0 5185 */ 5186 if (DMVAR_EXEC(MAKE_FSHANDLE_BASE + 4)) { 5187 int fd; 5188 void *hanp1, *hanp2; 5189 size_t hlen1, hlen2; 5190 dm_fsid_t fsid; 5191 5192 /* Variation set up */ 5193 if ((fd = 5194 open(DUMMY_FILE, O_RDWR | O_CREAT, 5195 DUMMY_FILE_RW_MODE)) == -1) { 5196 /* No clean up */ 5197 } else 5198 if ((rc = 5199 dm_path_to_fshandle(DUMMY_FILE, &hanp1, 5200 &hlen1)) == -1) { 5201 close(fd); 5202 remove(DUMMY_FILE); 5203 } else if ((rc = dm_handle_to_fsid(hanp1, hlen1, &fsid)) == -1) { 5204 dm_handle_free(hanp1, hlen1); 5205 close(fd); 5206 remove(DUMMY_FILE); 5207 } 5208 if (fd == -1 || rc == -1) { 5209 DMLOG_PRINT(DMLVL_DEBUG, 5210 "Unable to set up variation! (errno = %d)\n", 5211 errno); 5212 DMVAR_SKIP(); 5213 } else { 5214 /* Variation */ 5215 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 5216 szFuncName); 5217 rc = dm_make_fshandle(&fsid, &hanp2, &hlen2); 5218 if (rc == 0) { 5219 DMLOG_PRINT(DMLVL_DEBUG, 5220 "hanp = %p, hlen = %d\n", hanp2, 5221 hlen2); 5222 dm_LogHandle(hanp2, hlen2); 5223 5224 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 5225 if (rc == 0) { 5226 DMLOG_PRINT(DMLVL_DEBUG, 5227 "%s passed with expected rc = 0\n", 5228 szFuncName); 5229 DMVAR_PASS(); 5230 } else { 5231 DMLOG_PRINT(DMLVL_ERR, 5232 "%s failed with expected rc = 0 but unexpected dm_handle_cmp rc = %d\n", 5233 szFuncName, rc); 5234 DMVAR_FAIL(); 5235 } 5236 } else { 5237 DMLOG_PRINT(DMLVL_ERR, 5238 "%s failed with unexpected rc = %d (errno = %d)\n", 5239 szFuncName, rc, errno); 5240 DMVAR_FAIL(); 5241 } 5242 5243 /* Variation clean up */ 5244 rc = close(fd); 5245 rc |= remove(DUMMY_FILE); 5246 if (rc == -1) { 5247 DMLOG_PRINT(DMLVL_DEBUG, 5248 "Unable to clean up variation! (errno = %d)\n", 5249 errno); 5250 } 5251 dm_handle_free(hanp1, hlen1); 5252 dm_handle_free(hanp2, hlen2); 5253 } 5254 } 5255 5256 /* 5257 * TEST : dm_make_fshandle - directory handle 5258 * EXPECTED: rc = 0 5259 */ 5260 if (DMVAR_EXEC(MAKE_FSHANDLE_BASE + 5)) { 5261 void *hanp1, *hanp2; 5262 size_t hlen1, hlen2; 5263 dm_fsid_t fsid; 5264 5265 /* Variation set up */ 5266 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 5267 /* No clean up */ 5268 } else 5269 if ((rc = 5270 dm_path_to_fshandle(DUMMY_SUBDIR, &hanp1, 5271 &hlen1)) == -1) { 5272 rmdir(DUMMY_SUBDIR); 5273 } else if ((rc = dm_handle_to_fsid(hanp1, hlen1, &fsid)) == -1) { 5274 dm_handle_free(hanp1, hlen1); 5275 rmdir(DUMMY_SUBDIR); 5276 } 5277 if (rc == -1) { 5278 DMLOG_PRINT(DMLVL_DEBUG, 5279 "Unable to set up variation! (errno = %d)\n", 5280 errno); 5281 DMVAR_SKIP(); 5282 } else { 5283 /* Variation */ 5284 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 5285 szFuncName); 5286 rc = dm_make_fshandle(&fsid, &hanp2, &hlen2); 5287 if (rc == 0) { 5288 DMLOG_PRINT(DMLVL_DEBUG, 5289 "hanp = %p, hlen = %d\n", hanp2, 5290 hlen2); 5291 dm_LogHandle(hanp2, hlen2); 5292 5293 rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2); 5294 if (rc == 0) { 5295 DMLOG_PRINT(DMLVL_DEBUG, 5296 "%s passed with expected rc = 0\n", 5297 szFuncName); 5298 DMVAR_PASS(); 5299 } else { 5300 DMLOG_PRINT(DMLVL_ERR, 5301 "%s failed with expected rc = 0 but unexpected dm_handle_cmp rc = %d\n", 5302 szFuncName, rc); 5303 DMVAR_FAIL(); 5304 } 5305 } else { 5306 DMLOG_PRINT(DMLVL_ERR, 5307 "%s failed with unexpected rc = %d (errno = %d)\n", 5308 szFuncName, rc, errno); 5309 DMVAR_FAIL(); 5310 } 5311 5312 /* Variation clean up */ 5313 rc = rmdir(DUMMY_SUBDIR); 5314 if (rc == -1) { 5315 DMLOG_PRINT(DMLVL_DEBUG, 5316 "Unable to clean up variation! (errno = %d)\n", 5317 errno); 5318 } 5319 dm_handle_free(hanp1, hlen1); 5320 dm_handle_free(hanp2, hlen2); 5321 } 5322 } 5323 5324 szFuncName = "dm_handle_to_path"; 5325 5326 /* 5327 * TEST : dm_handle_to_path - invalid dirhanp 5328 * EXPECTED: rc = -1, errno = EFAULT 5329 */ 5330 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 1)) { 5331 int fd; 5332 void *dirhanp, *targhanp; 5333 size_t dirhlen, targhlen; 5334 char pathbuf[PATHBUF_LEN]; 5335 size_t rlen; 5336 5337 /* Variation set up */ 5338 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5339 /* No clean up */ 5340 } else 5341 if ((fd = 5342 open(DUMMY_FILE, O_RDWR | O_CREAT, 5343 DUMMY_FILE_RW_MODE)) == -1) { 5344 dm_handle_free(dirhanp, dirhlen); 5345 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5346 -1) { 5347 close(fd); 5348 remove(DUMMY_FILE); 5349 dm_handle_free(dirhanp, dirhlen); 5350 } 5351 if (fd == -1 || rc == -1) { 5352 DMLOG_PRINT(DMLVL_DEBUG, 5353 "Unable to set up variation! (errno = %d)\n", 5354 errno); 5355 DMVAR_SKIP(); 5356 } else { 5357 /* Variation */ 5358 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid dirhanp)\n", 5359 szFuncName); 5360 rc = dm_handle_to_path((void *)INVALID_ADDR, dirhlen, 5361 targhanp, targhlen, PATHBUF_LEN, 5362 pathbuf, &rlen); 5363 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5364 5365 /* Variation clean up */ 5366 rc = close(fd); 5367 rc |= remove(DUMMY_FILE); 5368 if (rc == -1) { 5369 DMLOG_PRINT(DMLVL_DEBUG, 5370 "Unable to clean up variation! (errno = %d)\n", 5371 errno); 5372 } 5373 dm_handle_free(dirhanp, dirhlen); 5374 dm_handle_free(targhanp, targhlen); 5375 } 5376 } 5377 5378 /* 5379 * TEST : dm_handle_to_path - invalid dirhlen 5380 * EXPECTED: rc = -1, errno = EBADF 5381 */ 5382 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 2)) { 5383 int fd; 5384 void *dirhanp, *targhanp; 5385 size_t dirhlen, targhlen; 5386 char pathbuf[PATHBUF_LEN]; 5387 size_t rlen; 5388 5389 /* Variation set up */ 5390 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5391 /* No clean up */ 5392 } else 5393 if ((fd = 5394 open(DUMMY_FILE, O_RDWR | O_CREAT, 5395 DUMMY_FILE_RW_MODE)) == -1) { 5396 dm_handle_free(dirhanp, dirhlen); 5397 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5398 -1) { 5399 close(fd); 5400 remove(DUMMY_FILE); 5401 dm_handle_free(dirhanp, dirhlen); 5402 } 5403 if (fd == -1 || rc == -1) { 5404 DMLOG_PRINT(DMLVL_DEBUG, 5405 "Unable to set up variation! (errno = %d)\n", 5406 errno); 5407 DMVAR_SKIP(); 5408 } else { 5409 /* Variation */ 5410 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid dirhlen)\n", 5411 szFuncName); 5412 rc = dm_handle_to_path(dirhanp, INVALID_ADDR, targhanp, 5413 targhlen, PATHBUF_LEN, pathbuf, 5414 &rlen); 5415 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 5416 5417 /* Variation clean up */ 5418 rc = close(fd); 5419 rc |= remove(DUMMY_FILE); 5420 if (rc == -1) { 5421 DMLOG_PRINT(DMLVL_DEBUG, 5422 "Unable to clean up variation! (errno = %d)\n", 5423 errno); 5424 } 5425 dm_handle_free(dirhanp, dirhlen); 5426 dm_handle_free(targhanp, targhlen); 5427 } 5428 } 5429 5430 /* 5431 * TEST : dm_handle_to_path - invalid targhanp 5432 * EXPECTED: rc = -1, errno = EFAULT 5433 */ 5434 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 3)) { 5435 int fd; 5436 void *dirhanp, *targhanp; 5437 size_t dirhlen, targhlen; 5438 char pathbuf[PATHBUF_LEN]; 5439 size_t rlen; 5440 5441 /* Variation set up */ 5442 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5443 /* No clean up */ 5444 } else 5445 if ((fd = 5446 open(DUMMY_FILE, O_RDWR | O_CREAT, 5447 DUMMY_FILE_RW_MODE)) == -1) { 5448 dm_handle_free(dirhanp, dirhlen); 5449 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5450 -1) { 5451 close(fd); 5452 remove(DUMMY_FILE); 5453 dm_handle_free(dirhanp, dirhlen); 5454 } 5455 if (fd == -1 || rc == -1) { 5456 DMLOG_PRINT(DMLVL_DEBUG, 5457 "Unable to set up variation! (errno = %d)\n", 5458 errno); 5459 DMVAR_SKIP(); 5460 } else { 5461 /* Variation */ 5462 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid targhanp)\n", 5463 szFuncName); 5464 rc = dm_handle_to_path(dirhanp, dirhlen, 5465 (void *)INVALID_ADDR, targhlen, 5466 PATHBUF_LEN, pathbuf, &rlen); 5467 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5468 5469 /* Variation clean up */ 5470 rc = close(fd); 5471 rc |= remove(DUMMY_FILE); 5472 if (rc == -1) { 5473 DMLOG_PRINT(DMLVL_DEBUG, 5474 "Unable to clean up variation! (errno = %d)\n", 5475 errno); 5476 } 5477 dm_handle_free(dirhanp, dirhlen); 5478 dm_handle_free(targhanp, targhlen); 5479 } 5480 } 5481 5482 /* 5483 * TEST : dm_handle_to_path - invalid targhlen 5484 * EXPECTED: rc = -1, errno = EBADF 5485 */ 5486 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 4)) { 5487 int fd; 5488 void *dirhanp, *targhanp; 5489 size_t dirhlen, targhlen; 5490 char pathbuf[PATHBUF_LEN]; 5491 size_t rlen; 5492 5493 /* Variation set up */ 5494 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5495 /* No clean up */ 5496 } else 5497 if ((fd = 5498 open(DUMMY_FILE, O_RDWR | O_CREAT, 5499 DUMMY_FILE_RW_MODE)) == -1) { 5500 dm_handle_free(dirhanp, dirhlen); 5501 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5502 -1) { 5503 close(fd); 5504 remove(DUMMY_FILE); 5505 dm_handle_free(dirhanp, dirhlen); 5506 } 5507 if (fd == -1 || rc == -1) { 5508 DMLOG_PRINT(DMLVL_DEBUG, 5509 "Unable to set up variation! (errno = %d)\n", 5510 errno); 5511 DMVAR_SKIP(); 5512 } else { 5513 /* Variation */ 5514 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid targhlen)\n", 5515 szFuncName); 5516 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5517 INVALID_ADDR, PATHBUF_LEN, 5518 pathbuf, &rlen); 5519 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 5520 5521 /* Variation clean up */ 5522 rc = close(fd); 5523 rc |= remove(DUMMY_FILE); 5524 if (rc == -1) { 5525 DMLOG_PRINT(DMLVL_DEBUG, 5526 "Unable to clean up variation! (errno = %d)\n", 5527 errno); 5528 } 5529 dm_handle_free(dirhanp, dirhlen); 5530 dm_handle_free(targhanp, targhlen); 5531 } 5532 } 5533 5534 /* 5535 * TEST : dm_handle_to_path - invalid buflen 5536 * EXPECTED: rc = -1, errno = E2BIG 5537 */ 5538 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 5)) { 5539 int fd; 5540 void *dirhanp, *targhanp; 5541 size_t dirhlen, targhlen; 5542 char pathbuf[PATHBUF_LEN]; 5543 size_t rlen; 5544 5545 /* Variation set up */ 5546 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5547 /* No clean up */ 5548 } else 5549 if ((fd = 5550 open(DUMMY_FILE, O_RDWR | O_CREAT, 5551 DUMMY_FILE_RW_MODE)) == -1) { 5552 dm_handle_free(dirhanp, dirhlen); 5553 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5554 -1) { 5555 close(fd); 5556 remove(DUMMY_FILE); 5557 dm_handle_free(dirhanp, dirhlen); 5558 } 5559 if (fd == -1 || rc == -1) { 5560 DMLOG_PRINT(DMLVL_DEBUG, 5561 "Unable to set up variation! (errno = %d)\n", 5562 errno); 5563 DMVAR_SKIP(); 5564 } else { 5565 /* Variation */ 5566 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid buflen)\n", 5567 szFuncName); 5568 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5569 targhlen, 1, pathbuf, &rlen); 5570 DMVAR_ENDFAILEXP(szFuncName, -1, rc, E2BIG); 5571 5572 /* Variation clean up */ 5573 rc = close(fd); 5574 rc |= remove(DUMMY_FILE); 5575 if (rc == -1) { 5576 DMLOG_PRINT(DMLVL_DEBUG, 5577 "Unable to clean up variation! (errno = %d)\n", 5578 errno); 5579 } 5580 dm_handle_free(dirhanp, dirhlen); 5581 dm_handle_free(targhanp, targhlen); 5582 } 5583 } 5584 5585 /* 5586 * TEST : dm_handle_to_path - invalid pathbufp 5587 * EXPECTED: rc = -1, errno = EFAULT 5588 */ 5589 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 6)) { 5590 int fd; 5591 void *dirhanp, *targhanp; 5592 size_t dirhlen, targhlen; 5593 size_t rlen; 5594 5595 /* Variation set up */ 5596 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5597 /* No clean up */ 5598 } else 5599 if ((fd = 5600 open(DUMMY_FILE, O_RDWR | O_CREAT, 5601 DUMMY_FILE_RW_MODE)) == -1) { 5602 dm_handle_free(dirhanp, dirhlen); 5603 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5604 -1) { 5605 close(fd); 5606 remove(DUMMY_FILE); 5607 dm_handle_free(dirhanp, dirhlen); 5608 } 5609 if (fd == -1 || rc == -1) { 5610 DMLOG_PRINT(DMLVL_DEBUG, 5611 "Unable to set up variation! (errno = %d)\n", 5612 errno); 5613 DMVAR_SKIP(); 5614 } else { 5615 /* Variation */ 5616 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid pathbufp)\n", 5617 szFuncName); 5618 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5619 targhlen, PATHBUF_LEN, 5620 (char *)INVALID_ADDR, &rlen); 5621 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5622 5623 /* Variation clean up */ 5624 rc = close(fd); 5625 rc |= remove(DUMMY_FILE); 5626 if (rc == -1) { 5627 DMLOG_PRINT(DMLVL_DEBUG, 5628 "Unable to clean up variation! (errno = %d)\n", 5629 errno); 5630 } 5631 dm_handle_free(dirhanp, dirhlen); 5632 dm_handle_free(targhanp, targhlen); 5633 } 5634 } 5635 5636 /* 5637 * TEST : dm_handle_to_path - invalid rlenp 5638 * EXPECTED: rc = -1, errno = EFAULT 5639 */ 5640 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 7)) { 5641 int fd; 5642 void *dirhanp, *targhanp; 5643 size_t dirhlen, targhlen; 5644 char pathbuf[PATHBUF_LEN]; 5645 5646 /* Variation set up */ 5647 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5648 /* No clean up */ 5649 } else 5650 if ((fd = 5651 open(DUMMY_FILE, O_RDWR | O_CREAT, 5652 DUMMY_FILE_RW_MODE)) == -1) { 5653 dm_handle_free(dirhanp, dirhlen); 5654 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5655 -1) { 5656 close(fd); 5657 remove(DUMMY_FILE); 5658 dm_handle_free(dirhanp, dirhlen); 5659 } 5660 if (fd == -1 || rc == -1) { 5661 DMLOG_PRINT(DMLVL_DEBUG, 5662 "Unable to set up variation! (errno = %d)\n", 5663 errno); 5664 DMVAR_SKIP(); 5665 } else { 5666 /* Variation */ 5667 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid rlenp)\n", 5668 szFuncName); 5669 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5670 targhlen, PATHBUF_LEN, pathbuf, 5671 (size_t *) INVALID_ADDR); 5672 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 5673 5674 /* Variation clean up */ 5675 rc = close(fd); 5676 rc |= remove(DUMMY_FILE); 5677 if (rc == -1) { 5678 DMLOG_PRINT(DMLVL_DEBUG, 5679 "Unable to clean up variation! (errno = %d)\n", 5680 errno); 5681 } 5682 dm_handle_free(dirhanp, dirhlen); 5683 dm_handle_free(targhanp, targhlen); 5684 } 5685 } 5686 5687 /* 5688 * TEST : dm_handle_to_path - file dirhanp 5689 * EXPECTED: rc = -1, errno = EBADF 5690 */ 5691 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 8)) { 5692 int fd1, fd2; 5693 void *dirhanp, *targhanp; 5694 size_t dirhlen, targhlen; 5695 char pathbuf[PATHBUF_LEN]; 5696 size_t rlen; 5697 5698 /* Variation set up */ 5699 if ((fd1 = 5700 open(DUMMY_FILE, O_RDWR | O_CREAT, 5701 DUMMY_FILE_RW_MODE)) == -1) { 5702 /* No clean up */ 5703 } else if ((rc = dm_fd_to_handle(fd1, &targhanp, &targhlen)) == 5704 -1) { 5705 close(fd1); 5706 remove(DUMMY_FILE); 5707 } else 5708 if ((fd2 = 5709 open(DUMMY_FILE2, O_RDWR | O_CREAT, 5710 DUMMY_FILE_RW_MODE)) == -1) { 5711 close(fd1); 5712 remove(DUMMY_FILE); 5713 dm_handle_free(targhanp, targhlen); 5714 } else if ((rc = dm_fd_to_handle(fd2, &dirhanp, &dirhlen)) == 5715 -1) { 5716 close(fd2); 5717 remove(DUMMY_FILE2); 5718 close(fd1); 5719 remove(DUMMY_FILE); 5720 dm_handle_free(targhanp, targhlen); 5721 } 5722 if (fd1 == -1 || fd2 == -1 || rc == -1) { 5723 DMLOG_PRINT(DMLVL_DEBUG, 5724 "Unable to set up variation! (errno = %d)\n", 5725 errno); 5726 DMVAR_SKIP(); 5727 } else { 5728 /* Variation */ 5729 DMLOG_PRINT(DMLVL_DEBUG, "%s(file dirhanp)\n", 5730 szFuncName); 5731 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5732 targhlen, sizeof(pathbuf), 5733 pathbuf, &rlen); 5734 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 5735 5736 /* Variation clean up */ 5737 rc = close(fd1); 5738 rc |= close(fd2); 5739 rc |= remove(DUMMY_FILE); 5740 rc |= remove(DUMMY_FILE2); 5741 if (rc == -1) { 5742 DMLOG_PRINT(DMLVL_DEBUG, 5743 "Unable to clean up variation! (errno = %d)\n", 5744 errno); 5745 } 5746 dm_handle_free(dirhanp, dirhlen); 5747 dm_handle_free(targhanp, targhlen); 5748 } 5749 } 5750 5751 /* 5752 * TEST : dm_handle_to_path - directory targhanp 5753 * EXPECTED: rc = -1, errno = EBADF 5754 */ 5755 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 9)) { 5756 int fd; 5757 void *dirhanp, *targhanp; 5758 size_t dirhlen, targhlen; 5759 char pathbuf[PATHBUF_LEN]; 5760 size_t rlen; 5761 5762 /* Variation set up */ 5763 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5764 /* No clean up */ 5765 } else if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 5766 dm_handle_free(dirhanp, dirhlen); 5767 } else 5768 if ((rc = 5769 dm_path_to_handle(DUMMY_SUBDIR, &targhanp, 5770 &targhlen)) == -1) { 5771 rmdir(DUMMY_SUBDIR); 5772 dm_handle_free(dirhanp, dirhlen); 5773 } 5774 if (fd == -1 || rc == -1) { 5775 DMLOG_PRINT(DMLVL_DEBUG, 5776 "Unable to set up variation! (errno = %d)\n", 5777 errno); 5778 DMVAR_SKIP(); 5779 } else { 5780 /* Variation */ 5781 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir targhanp)\n", 5782 szFuncName); 5783 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5784 targhlen, sizeof(pathbuf), 5785 pathbuf, &rlen); 5786 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 5787 5788 /* Variation clean up */ 5789 rc = rmdir(DUMMY_SUBDIR); 5790 if (rc == -1) { 5791 DMLOG_PRINT(DMLVL_DEBUG, 5792 "Unable to clean up variation! (errno = %d)\n", 5793 errno); 5794 } 5795 dm_handle_free(dirhanp, dirhlen); 5796 dm_handle_free(targhanp, targhlen); 5797 } 5798 } 5799 5800 /* 5801 * TEST : dm_handle_to_path - absolute root directory 5802 * EXPECTED: rc = 0 5803 * 5804 * This variation uncovered XFS BUG #12 (only worked if dirhanp was 5805 * current directory) 5806 */ 5807 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 10)) { 5808 int fd; 5809 void *dirhanp, *targhanp; 5810 size_t dirhlen, targhlen; 5811 char pathbuf[PATHBUF_LEN]; 5812 size_t rlen; 5813 5814 /* Variation set up */ 5815 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 5816 /* No clean up */ 5817 } else 5818 if ((fd = 5819 open(DUMMY_FILE, O_RDWR | O_CREAT, 5820 DUMMY_FILE_RW_MODE)) == -1) { 5821 dm_handle_free(dirhanp, dirhlen); 5822 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5823 -1) { 5824 close(fd); 5825 remove(DUMMY_FILE); 5826 dm_handle_free(dirhanp, dirhlen); 5827 } 5828 if (fd == -1 || rc == -1) { 5829 DMLOG_PRINT(DMLVL_DEBUG, 5830 "Unable to set up variation! (errno = %d)\n", 5831 errno); 5832 DMVAR_SKIP(); 5833 } else { 5834 /* Variation */ 5835 DMLOG_PRINT(DMLVL_DEBUG, "%s(absolute root dir)\n", 5836 szFuncName); 5837 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5838 targhlen, sizeof(pathbuf), 5839 pathbuf, &rlen); 5840 if (rc == 0) { 5841 DMLOG_PRINT(DMLVL_DEBUG, 5842 "rlen = %d, pathbuf = \"%s\"\n", 5843 rlen, pathbuf); 5844 5845 if (strncmp(pathbuf, DUMMY_FILE, rlen) == 0) { 5846 *(pathbuf + rlen) = 0; 5847 DMLOG_PRINT(DMLVL_DEBUG, 5848 "%s passed with expected rc = %d and path = %s (length %d)\n", 5849 szFuncName, rc, pathbuf, 5850 rlen); 5851 DMVAR_PASS(); 5852 } else { 5853 DMLOG_PRINT(DMLVL_ERR, 5854 "%s failed with expected rc = %d but unexpected path (%s vs %s)\n", 5855 szFuncName, rc, pathbuf, 5856 DUMMY_FILE); 5857 DMVAR_FAIL(); 5858 } 5859 } else { 5860 DMLOG_PRINT(DMLVL_ERR, 5861 "%s failed with unexpected rc = %d (errno = %d)\n", 5862 szFuncName, rc, errno); 5863 DMVAR_FAIL(); 5864 } 5865 5866 /* Variation clean up */ 5867 rc = close(fd); 5868 rc |= remove(DUMMY_FILE); 5869 if (rc == -1) { 5870 DMLOG_PRINT(DMLVL_DEBUG, 5871 "Unable to clean up variation! (errno = %d)\n", 5872 errno); 5873 } 5874 dm_handle_free(dirhanp, dirhlen); 5875 dm_handle_free(targhanp, targhlen); 5876 } 5877 } 5878 5879 /* 5880 * TEST : dm_handle_to_path - relative root directory 5881 * EXPECTED: rc = 0 5882 */ 5883 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 11)) { 5884 int fd; 5885 void *dirhanp, *targhanp; 5886 size_t dirhlen, targhlen; 5887 char pathbuf[PATHBUF_LEN]; 5888 size_t rlen; 5889 5890 /* Variation set up */ 5891 if ((rc = dm_path_to_handle("", &dirhanp, &dirhlen)) == -1) { 5892 /* No clean up */ 5893 } else 5894 if ((fd = 5895 open(DUMMY_FILE, O_RDWR | O_CREAT, 5896 DUMMY_FILE_RW_MODE)) == -1) { 5897 dm_handle_free(dirhanp, dirhlen); 5898 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5899 -1) { 5900 close(fd); 5901 remove(DUMMY_FILE); 5902 dm_handle_free(dirhanp, dirhlen); 5903 } 5904 if (fd == -1 || rc == -1) { 5905 DMLOG_PRINT(DMLVL_DEBUG, 5906 "Unable to set up variation! (errno = %d)\n", 5907 errno); 5908 DMVAR_SKIP(); 5909 } else { 5910 /* Variation */ 5911 DMLOG_PRINT(DMLVL_DEBUG, "%s(relative root dir)\n", 5912 szFuncName); 5913 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5914 targhlen, sizeof(pathbuf), 5915 pathbuf, &rlen); 5916 if (rc == 0) { 5917 DMLOG_PRINT(DMLVL_DEBUG, 5918 "rlen = %d, pathbuf = \"%s\"\n", 5919 rlen, pathbuf); 5920 5921 if (strncmp(pathbuf, DUMMY_FILE, rlen) == 0) { 5922 *(pathbuf + rlen) = 0; 5923 DMLOG_PRINT(DMLVL_DEBUG, 5924 "%s passed with expected rc = %d and path = %s (length %d)\n", 5925 szFuncName, rc, pathbuf, 5926 rlen); 5927 DMVAR_PASS(); 5928 } else { 5929 DMLOG_PRINT(DMLVL_ERR, 5930 "%s failed with expected rc = %d but unexpected path (%s vs %s)\n", 5931 szFuncName, rc, pathbuf, 5932 DUMMY_FILE); 5933 DMVAR_FAIL(); 5934 } 5935 } else { 5936 DMLOG_PRINT(DMLVL_ERR, 5937 "%s failed with unexpected rc = %d (errno = %d)\n", 5938 szFuncName, rc, errno); 5939 DMVAR_FAIL(); 5940 } 5941 5942 /* Variation clean up */ 5943 rc = close(fd); 5944 rc |= remove(DUMMY_FILE); 5945 if (rc == -1) { 5946 DMLOG_PRINT(DMLVL_DEBUG, 5947 "Unable to clean up variation! (errno = %d)\n", 5948 errno); 5949 } 5950 dm_handle_free(dirhanp, dirhlen); 5951 dm_handle_free(targhanp, targhlen); 5952 } 5953 } 5954 5955 /* 5956 * TEST : dm_handle_to_path - file in subdirectory, one level 5957 * EXPECTED: rc = 0 5958 */ 5959 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 12)) { 5960 int fd; 5961 void *dirhanp, *targhanp; 5962 size_t dirhlen, targhlen; 5963 char pathbuf[PATHBUF_LEN]; 5964 size_t rlen; 5965 5966 /* Variation set up */ 5967 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 5968 /* No clean up */ 5969 } else 5970 if ((rc = 5971 dm_path_to_handle(DUMMY_SUBDIR, &dirhanp, 5972 &dirhlen)) == -1) { 5973 rmdir(DUMMY_SUBDIR); 5974 } else 5975 if ((fd = 5976 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 5977 DUMMY_FILE_RW_MODE)) == -1) { 5978 dm_handle_free(dirhanp, dirhlen); 5979 rmdir(DUMMY_SUBDIR); 5980 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 5981 -1) { 5982 close(fd); 5983 remove(DUMMY_SUBDIR_FILE); 5984 dm_handle_free(dirhanp, dirhlen); 5985 rmdir(DUMMY_SUBDIR); 5986 } 5987 if (fd == -1 || rc == -1) { 5988 DMLOG_PRINT(DMLVL_DEBUG, 5989 "Unable to set up variation! (errno = %d)\n", 5990 errno); 5991 DMVAR_SKIP(); 5992 } else { 5993 /* Variation */ 5994 DMLOG_PRINT(DMLVL_DEBUG, "%s(file in subdir)\n", 5995 szFuncName); 5996 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 5997 targhlen, sizeof(pathbuf), 5998 pathbuf, &rlen); 5999 if (rc == 0) { 6000 DMLOG_PRINT(DMLVL_DEBUG, 6001 "rlen = %d, pathbuf = \"%s\"\n", 6002 rlen, pathbuf); 6003 6004 if (strncmp(pathbuf, DUMMY_SUBDIR_FILE, rlen) == 6005 0) { 6006 *(pathbuf + rlen) = 0; 6007 DMLOG_PRINT(DMLVL_DEBUG, 6008 "%s passed with expected rc = %d and path = %s (length %d)\n", 6009 szFuncName, rc, pathbuf, 6010 rlen); 6011 DMVAR_PASS(); 6012 } else { 6013 DMLOG_PRINT(DMLVL_ERR, 6014 "%s failed with expected rc = %d but unexpected path (%s vs %s)\n", 6015 szFuncName, rc, pathbuf, 6016 DUMMY_SUBDIR_FILE); 6017 DMVAR_FAIL(); 6018 } 6019 } else { 6020 DMLOG_PRINT(DMLVL_ERR, 6021 "%s failed with unexpected rc = %d (errno = %d)\n", 6022 szFuncName, rc, errno); 6023 DMVAR_FAIL(); 6024 } 6025 6026 /* Variation clean up */ 6027 rc = close(fd); 6028 rc |= remove(DUMMY_SUBDIR_FILE); 6029 rc |= rmdir(DUMMY_SUBDIR); 6030 if (rc == -1) { 6031 DMLOG_PRINT(DMLVL_DEBUG, 6032 "Unable to clean up variation! (errno = %d)\n", 6033 errno); 6034 } 6035 dm_handle_free(dirhanp, dirhlen); 6036 dm_handle_free(targhanp, targhlen); 6037 } 6038 } 6039 6040 /* 6041 * TEST : dm_handle_to_path - link in subdirectory, one level 6042 * EXPECTED: rc = 0 6043 */ 6044 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 13)) { 6045 int fd; 6046 void *dirhanp, *targhanp; 6047 size_t dirhlen, targhlen; 6048 char pathbuf[PATHBUF_LEN]; 6049 size_t rlen; 6050 6051 /* Variation set up */ 6052 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 6053 /* No clean up */ 6054 } else 6055 if ((rc = 6056 dm_path_to_handle(DUMMY_SUBDIR, &dirhanp, 6057 &dirhlen)) == -1) { 6058 rmdir(DUMMY_SUBDIR); 6059 } else 6060 if ((fd = 6061 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 6062 DUMMY_FILE_RW_MODE)) == -1) { 6063 dm_handle_free(dirhanp, dirhlen); 6064 rmdir(DUMMY_SUBDIR); 6065 } else if ((rc = link(DUMMY_SUBDIR_FILE, DUMMY_SUBDIR_LINK)) == 6066 -1) { 6067 close(fd); 6068 rmdir(DUMMY_SUBDIR); 6069 dm_handle_free(dirhanp, dirhlen); 6070 rmdir(DUMMY_SUBDIR); 6071 } else 6072 if ((rc = 6073 dm_path_to_handle(DUMMY_SUBDIR_LINK, &targhanp, 6074 &targhlen)) == -1) { 6075 unlink(DUMMY_SUBDIR_LINK); 6076 close(fd); 6077 rmdir(DUMMY_SUBDIR); 6078 dm_handle_free(dirhanp, dirhlen); 6079 rmdir(DUMMY_SUBDIR); 6080 } 6081 if (rc == -1 || fd == -1) { 6082 DMLOG_PRINT(DMLVL_DEBUG, 6083 "Unable to set up variation! (errno = %d)\n", 6084 errno); 6085 DMVAR_SKIP(); 6086 } else { 6087 /* Variation */ 6088 DMLOG_PRINT(DMLVL_DEBUG, "%s(link in subdir)\n", 6089 szFuncName); 6090 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6091 targhlen, sizeof(pathbuf), 6092 pathbuf, &rlen); 6093 if (rc == 0) { 6094 DMLOG_PRINT(DMLVL_DEBUG, 6095 "rlen = %d, pathbuf = \"%s\"\n", 6096 rlen, pathbuf); 6097 6098 if (strncmp(pathbuf, DUMMY_SUBDIR_LINK, rlen) == 6099 0) { 6100 *(pathbuf + rlen) = 0; 6101 DMLOG_PRINT(DMLVL_DEBUG, 6102 "%s passed with expected rc = %d and path = %s (length %d)\n", 6103 szFuncName, rc, pathbuf, 6104 rlen); 6105 DMVAR_PASS(); 6106 } else { 6107 DMLOG_PRINT(DMLVL_ERR, 6108 "%s failed with expected rc = %d but unexpected path (%s vs %s)\n", 6109 szFuncName, rc, pathbuf, 6110 DUMMY_SUBDIR_LINK); 6111 DMVAR_FAIL(); 6112 } 6113 } else { 6114 DMLOG_PRINT(DMLVL_ERR, 6115 "%s failed with unexpected rc = %d (errno = %d)\n", 6116 szFuncName, rc, errno); 6117 DMVAR_FAIL(); 6118 } 6119 6120 /* Variation clean up */ 6121 rc = close(fd); 6122 rc |= remove(DUMMY_SUBDIR_FILE); 6123 rc |= unlink(DUMMY_SUBDIR_LINK); 6124 rc |= rmdir(DUMMY_SUBDIR); 6125 if (rc == -1) { 6126 DMLOG_PRINT(DMLVL_DEBUG, 6127 "Unable to clean up variation! (errno = %d)\n", 6128 errno); 6129 } 6130 dm_handle_free(dirhanp, dirhlen); 6131 dm_handle_free(targhanp, targhlen); 6132 } 6133 } 6134 6135 /* 6136 * TEST : dm_handle_to_path - file in subdirectory, multiple levels 6137 * EXPECTED: rc = 0 6138 */ 6139 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 14)) { 6140 int fd; 6141 void *dirhanp, *targhanp; 6142 size_t dirhlen, targhlen; 6143 char pathbuf[PATHBUF_LEN]; 6144 size_t rlen; 6145 6146 /* Variation set up */ 6147 if ((rc = mkdir(DIR_LEVEL1, DUMMY_DIR_RW_MODE)) == -1) { 6148 /* No clean up */ 6149 } else if ((rc = mkdir(DIR_LEVEL2, DUMMY_DIR_RW_MODE)) == -1) { 6150 rmdir(DIR_LEVEL1); 6151 } else if ((rc = mkdir(DIR_LEVEL3, DUMMY_DIR_RW_MODE)) == -1) { 6152 rmdir(DIR_LEVEL2); 6153 rmdir(DIR_LEVEL1); 6154 } else if ((rc = mkdir(DIR_LEVEL4, DUMMY_DIR_RW_MODE)) == -1) { 6155 rmdir(DIR_LEVEL3); 6156 rmdir(DIR_LEVEL2); 6157 rmdir(DIR_LEVEL1); 6158 } else 6159 if ((rc = 6160 dm_path_to_handle(DIR_LEVEL4, &dirhanp, 6161 &dirhlen)) == -1) { 6162 rmdir(DIR_LEVEL4); 6163 rmdir(DIR_LEVEL3); 6164 rmdir(DIR_LEVEL2); 6165 rmdir(DIR_LEVEL1); 6166 } else 6167 if ((fd = 6168 open(FILE_LEVEL4, O_RDWR | O_CREAT, 6169 DUMMY_FILE_RW_MODE)) == -1) { 6170 dm_handle_free(dirhanp, dirhlen); 6171 rmdir(DIR_LEVEL4); 6172 rmdir(DIR_LEVEL3); 6173 rmdir(DIR_LEVEL2); 6174 rmdir(DIR_LEVEL1); 6175 } else 6176 if ((rc = 6177 dm_path_to_handle(FILE_LEVEL4, &targhanp, 6178 &targhlen)) == -1) { 6179 close(fd); 6180 remove(FILE_LEVEL4); 6181 dm_handle_free(dirhanp, dirhlen); 6182 rmdir(DIR_LEVEL4); 6183 rmdir(DIR_LEVEL3); 6184 rmdir(DIR_LEVEL2); 6185 rmdir(DIR_LEVEL1); 6186 } 6187 if (fd == -1 || rc == -1) { 6188 DMLOG_PRINT(DMLVL_DEBUG, 6189 "Unable to set up variation! (errno = %d)\n", 6190 errno); 6191 DMVAR_SKIP(); 6192 } else { 6193 /* Variation */ 6194 DMLOG_PRINT(DMLVL_DEBUG, 6195 "%s(file in multiple subdir)\n", 6196 szFuncName); 6197 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6198 targhlen, sizeof(pathbuf), 6199 pathbuf, &rlen); 6200 if (rc == 0) { 6201 DMLOG_PRINT(DMLVL_DEBUG, 6202 "rlen = %d, pathbuf = \"%s\"\n", 6203 rlen, pathbuf); 6204 6205 if (strncmp(pathbuf, FILE_LEVEL4, rlen) == 0) { 6206 *(pathbuf + rlen) = 0; 6207 DMLOG_PRINT(DMLVL_DEBUG, 6208 "%s passed with expected rc = %d and path = %s (length %d)\n", 6209 szFuncName, rc, pathbuf, 6210 rlen); 6211 DMVAR_PASS(); 6212 } else { 6213 DMLOG_PRINT(DMLVL_ERR, 6214 "%s failed with expected rc = %d but unexpected path (%s vs %s)\n", 6215 szFuncName, rc, pathbuf, 6216 FILE_LEVEL4); 6217 DMVAR_FAIL(); 6218 } 6219 } else { 6220 DMLOG_PRINT(DMLVL_ERR, 6221 "%s failed with unexpected rc = %d (errno = %d)\n", 6222 szFuncName, rc, errno); 6223 DMVAR_FAIL(); 6224 } 6225 6226 /* Variation clean up */ 6227 rc = close(fd); 6228 rc |= remove(FILE_LEVEL4); 6229 rc |= rmdir(DIR_LEVEL4); 6230 rc |= rmdir(DIR_LEVEL3); 6231 rc |= rmdir(DIR_LEVEL2); 6232 rc |= rmdir(DIR_LEVEL1); 6233 if (rc == -1) { 6234 DMLOG_PRINT(DMLVL_DEBUG, 6235 "Unable to clean up variation! (errno = %d)\n", 6236 errno); 6237 } 6238 dm_handle_free(dirhanp, dirhlen); 6239 dm_handle_free(targhanp, targhlen); 6240 } 6241 } 6242 6243 /* 6244 * TEST : dm_handle_to_path - targhanp not in dirhanp 6245 * EXPECTED: rc = -1, errno = EINVAL 6246 */ 6247 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 15)) { 6248 int fd; 6249 void *dirhanp, *targhanp; 6250 size_t dirhlen, targhlen; 6251 char pathbuf[PATHBUF_LEN]; 6252 size_t rlen; 6253 6254 /* Variation set up */ 6255 if ((rc = mkdir(DIR_LEVEL1, DUMMY_DIR_RW_MODE)) == -1) { 6256 /* No clean up */ 6257 } else if ((rc = mkdir(DIR_LEVEL2, DUMMY_DIR_RW_MODE)) == -1) { 6258 rmdir(DIR_LEVEL1); 6259 } else if ((rc = mkdir(DIR_LEVEL3, DUMMY_DIR_RW_MODE)) == -1) { 6260 rmdir(DIR_LEVEL2); 6261 rmdir(DIR_LEVEL1); 6262 } else 6263 if ((rc = 6264 dm_path_to_handle(DIR_LEVEL3, &dirhanp, 6265 &dirhlen)) == -1) { 6266 rmdir(DIR_LEVEL3); 6267 rmdir(DIR_LEVEL2); 6268 rmdir(DIR_LEVEL1); 6269 } else if ((rc = mkdir(DIR_LEVEL4, DUMMY_DIR_RW_MODE)) == -1) { 6270 dm_handle_free(dirhanp, dirhlen); 6271 rmdir(DIR_LEVEL3); 6272 rmdir(DIR_LEVEL2); 6273 rmdir(DIR_LEVEL1); 6274 } else 6275 if ((fd = 6276 open(FILE_LEVEL4, O_RDWR | O_CREAT, 6277 DUMMY_FILE_RW_MODE)) == -1) { 6278 rmdir(DIR_LEVEL4); 6279 dm_handle_free(dirhanp, dirhlen); 6280 rmdir(DIR_LEVEL3); 6281 rmdir(DIR_LEVEL2); 6282 rmdir(DIR_LEVEL1); 6283 } else 6284 if ((rc = 6285 dm_path_to_handle(FILE_LEVEL4, &targhanp, 6286 &targhlen)) == -1) { 6287 close(fd); 6288 remove(FILE_LEVEL4); 6289 rmdir(DIR_LEVEL4); 6290 dm_handle_free(dirhanp, dirhlen); 6291 rmdir(DIR_LEVEL3); 6292 rmdir(DIR_LEVEL2); 6293 rmdir(DIR_LEVEL1); 6294 } 6295 if (fd == -1 || rc == -1) { 6296 DMLOG_PRINT(DMLVL_DEBUG, 6297 "Unable to set up variation! (errno = %d)\n", 6298 errno); 6299 DMVAR_SKIP(); 6300 } else { 6301 /* Variation */ 6302 DMLOG_PRINT(DMLVL_DEBUG, 6303 "%s(targhanp not in dirhanp)\n", 6304 szFuncName); 6305 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6306 targhlen, sizeof(pathbuf), 6307 pathbuf, &rlen); 6308 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 6309 6310 /* Variation clean up */ 6311 rc = close(fd); 6312 rc |= remove(FILE_LEVEL4); 6313 rc |= rmdir(DIR_LEVEL4); 6314 rc |= rmdir(DIR_LEVEL3); 6315 rc |= rmdir(DIR_LEVEL2); 6316 rc |= rmdir(DIR_LEVEL1); 6317 if (rc == -1) { 6318 DMLOG_PRINT(DMLVL_DEBUG, 6319 "Unable to clean up variation! (errno = %d)\n", 6320 errno); 6321 } 6322 dm_handle_free(dirhanp, dirhlen); 6323 dm_handle_free(targhanp, targhlen); 6324 } 6325 } 6326 6327 /* 6328 * TEST : dm_handle_to_path - fs dirhanp 6329 * EXPECTED: rc = -1, errno = EBADF 6330 */ 6331 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 16)) { 6332 int fd; 6333 void *dirhanp, *targhanp; 6334 size_t dirhlen, targhlen; 6335 char pathbuf[PATHBUF_LEN]; 6336 size_t rlen; 6337 6338 /* Variation set up */ 6339 if ((rc = 6340 dm_path_to_fshandle(mountPt, &dirhanp, &dirhlen)) == -1) { 6341 /* No clean up */ 6342 } else 6343 if ((fd = 6344 open(DUMMY_FILE, O_RDWR | O_CREAT, 6345 DUMMY_FILE_RW_MODE)) == -1) { 6346 dm_handle_free(dirhanp, dirhlen); 6347 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 6348 -1) { 6349 close(fd); 6350 remove(DUMMY_FILE); 6351 dm_handle_free(dirhanp, dirhlen); 6352 } 6353 if (fd == -1 || rc == -1) { 6354 DMLOG_PRINT(DMLVL_DEBUG, 6355 "Unable to set up variation! (errno = %d)\n", 6356 errno); 6357 DMVAR_SKIP(); 6358 } else { 6359 /* Variation */ 6360 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs dirhanp)\n", 6361 szFuncName); 6362 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6363 targhlen, PATHBUF_LEN, pathbuf, 6364 &rlen); 6365 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6366 6367 /* Variation clean up */ 6368 rc = close(fd); 6369 rc |= remove(DUMMY_FILE); 6370 if (rc == -1) { 6371 DMLOG_PRINT(DMLVL_DEBUG, 6372 "Unable to clean up variation! (errno = %d)\n", 6373 errno); 6374 } 6375 dm_handle_free(dirhanp, dirhlen); 6376 dm_handle_free(targhanp, targhlen); 6377 } 6378 } 6379 6380 /* 6381 * TEST : dm_handle_to_path - fs targhanp 6382 * EXPECTED: rc = -1, errno = EBADF 6383 */ 6384 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 17)) { 6385 int fd; 6386 void *dirhanp, *targhanp; 6387 size_t dirhlen, targhlen; 6388 char pathbuf[PATHBUF_LEN]; 6389 size_t rlen; 6390 6391 /* Variation set up */ 6392 if ((rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen)) == -1) { 6393 /* No clean up */ 6394 } else 6395 if ((fd = 6396 open(DUMMY_FILE, O_RDWR | O_CREAT, 6397 DUMMY_FILE_RW_MODE)) == -1) { 6398 dm_handle_free(dirhanp, dirhlen); 6399 } else 6400 if ((rc = 6401 dm_path_to_fshandle(DUMMY_FILE, &targhanp, 6402 &targhlen)) == -1) { 6403 close(fd); 6404 remove(DUMMY_FILE); 6405 dm_handle_free(dirhanp, dirhlen); 6406 } 6407 if (fd == -1 || rc == -1) { 6408 DMLOG_PRINT(DMLVL_DEBUG, 6409 "Unable to set up variation! (errno = %d)\n", 6410 errno); 6411 DMVAR_SKIP(); 6412 } else { 6413 /* Variation */ 6414 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs targhanp)\n", 6415 szFuncName); 6416 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6417 targhlen, PATHBUF_LEN, pathbuf, 6418 &rlen); 6419 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6420 6421 /* Variation clean up */ 6422 rc = close(fd); 6423 rc |= remove(DUMMY_FILE); 6424 if (rc == -1) { 6425 DMLOG_PRINT(DMLVL_DEBUG, 6426 "Unable to clean up variation! (errno = %d)\n", 6427 errno); 6428 } 6429 dm_handle_free(dirhanp, dirhlen); 6430 dm_handle_free(targhanp, targhlen); 6431 } 6432 } 6433 6434 /* 6435 * TEST : dm_handle_to_path - global dirhanp 6436 * EXPECTED: rc = -1, errno = EBADF 6437 */ 6438 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 18)) { 6439 int fd; 6440 void *targhanp; 6441 size_t targhlen; 6442 char pathbuf[PATHBUF_LEN]; 6443 size_t rlen; 6444 6445 /* Variation set up */ 6446 if ((fd = 6447 open(DUMMY_FILE, O_RDWR | O_CREAT, 6448 DUMMY_FILE_RW_MODE)) == -1) { 6449 /* No clean up */ 6450 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 6451 -1) { 6452 close(fd); 6453 remove(DUMMY_FILE); 6454 } 6455 if (fd == -1 || rc == -1) { 6456 DMLOG_PRINT(DMLVL_DEBUG, 6457 "Unable to set up variation! (errno = %d)\n", 6458 errno); 6459 DMVAR_SKIP(); 6460 } else { 6461 /* Variation */ 6462 DMLOG_PRINT(DMLVL_DEBUG, "%s(global dirhanp)\n", 6463 szFuncName); 6464 rc = dm_handle_to_path(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 6465 targhanp, targhlen, PATHBUF_LEN, 6466 pathbuf, &rlen); 6467 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6468 6469 /* Variation clean up */ 6470 rc = close(fd); 6471 rc |= remove(DUMMY_FILE); 6472 if (rc == -1) { 6473 DMLOG_PRINT(DMLVL_DEBUG, 6474 "Unable to clean up variation! (errno = %d)\n", 6475 errno); 6476 } 6477 dm_handle_free(targhanp, targhlen); 6478 } 6479 } 6480 6481 /* 6482 * TEST : dm_handle_to_path - global targhanp 6483 * EXPECTED: rc = -1, errno = EBADF 6484 */ 6485 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 19)) { 6486 void *dirhanp; 6487 size_t dirhlen; 6488 char pathbuf[PATHBUF_LEN]; 6489 size_t rlen; 6490 6491 /* Variation set up */ 6492 rc = dm_path_to_handle(mountPt, &dirhanp, &dirhlen); 6493 if (rc == -1) { 6494 DMLOG_PRINT(DMLVL_DEBUG, 6495 "Unable to set up variation! (errno = %d)\n", 6496 errno); 6497 DMVAR_SKIP(); 6498 } else { 6499 /* Variation */ 6500 DMLOG_PRINT(DMLVL_DEBUG, "%s(global targhanp)\n", 6501 szFuncName); 6502 rc = dm_handle_to_path(dirhanp, dirhlen, DM_GLOBAL_HANP, 6503 DM_GLOBAL_HLEN, PATHBUF_LEN, 6504 pathbuf, &rlen); 6505 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6506 6507 /* Variation clean up */ 6508 dm_handle_free(dirhanp, dirhlen); 6509 } 6510 } 6511 6512 /* 6513 * TEST : dm_handle_to_path - invalidated dirhanp 6514 * EXPECTED: rc = -1, errno = EBADF 6515 */ 6516 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 20)) { 6517 int fd; 6518 void *dirhanp, *targhanp; 6519 size_t dirhlen, targhlen; 6520 char pathbuf[PATHBUF_LEN]; 6521 size_t rlen; 6522 6523 /* Variation set up */ 6524 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 6525 /* No clean up */ 6526 } else 6527 if ((rc = 6528 dm_path_to_handle(DUMMY_SUBDIR, &dirhanp, 6529 &dirhlen)) == -1) { 6530 rmdir(DUMMY_SUBDIR); 6531 } else 6532 if ((fd = 6533 open(DUMMY_FILE, O_RDWR | O_CREAT, 6534 DUMMY_FILE_RW_MODE)) == -1) { 6535 dm_handle_free(dirhanp, dirhlen); 6536 rmdir(DUMMY_SUBDIR); 6537 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 6538 -1) { 6539 close(fd); 6540 remove(DUMMY_FILE); 6541 dm_handle_free(dirhanp, dirhlen); 6542 rmdir(DUMMY_SUBDIR); 6543 } else if ((rc = rmdir(DUMMY_SUBDIR)) == -1) { 6544 dm_handle_free(targhanp, targhlen); 6545 close(fd); 6546 remove(DUMMY_FILE); 6547 dm_handle_free(dirhanp, dirhlen); 6548 } 6549 if (fd == -1 || rc == -1) { 6550 DMLOG_PRINT(DMLVL_DEBUG, 6551 "Unable to set up variation! (errno = %d)\n", 6552 errno); 6553 DMVAR_SKIP(); 6554 } else { 6555 /* Variation */ 6556 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated dirhanp)\n", 6557 szFuncName); 6558 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6559 targhlen, sizeof(pathbuf), 6560 pathbuf, &rlen); 6561 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6562 6563 /* Variation clean up */ 6564 rc = close(fd); 6565 rc |= remove(DUMMY_FILE); 6566 if (rc == -1) { 6567 DMLOG_PRINT(DMLVL_DEBUG, 6568 "Unable to clean up variation! (errno = %d)\n", 6569 errno); 6570 } 6571 dm_handle_free(dirhanp, dirhlen); 6572 dm_handle_free(targhanp, targhlen); 6573 } 6574 } 6575 6576 /* 6577 * TEST : dm_handle_to_path - invalidated targhanp 6578 * EXPECTED: rc = -1, errno = EBADF 6579 */ 6580 if (DMVAR_EXEC(HANDLE_TO_PATH_BASE + 21)) { 6581 int fd; 6582 void *dirhanp, *targhanp; 6583 size_t dirhlen, targhlen; 6584 char pathbuf[PATHBUF_LEN]; 6585 size_t rlen; 6586 6587 /* Variation set up */ 6588 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 6589 /* No clean up */ 6590 } else 6591 if ((rc = 6592 dm_path_to_handle(DUMMY_SUBDIR, &dirhanp, 6593 &dirhlen)) == -1) { 6594 rmdir(DUMMY_SUBDIR); 6595 } else 6596 if ((fd = 6597 open(DUMMY_SUBDIR_FILE, O_RDWR | O_CREAT, 6598 DUMMY_FILE_RW_MODE)) == -1) { 6599 dm_handle_free(dirhanp, dirhlen); 6600 rmdir(DUMMY_SUBDIR); 6601 } else if ((rc = dm_fd_to_handle(fd, &targhanp, &targhlen)) == 6602 -1) { 6603 close(fd); 6604 remove(DUMMY_SUBDIR_FILE); 6605 dm_handle_free(dirhanp, dirhlen); 6606 rmdir(DUMMY_SUBDIR); 6607 } else if ((rc = close(fd)) == -1) { 6608 dm_handle_free(targhanp, targhlen); 6609 remove(DUMMY_SUBDIR_FILE); 6610 dm_handle_free(dirhanp, dirhlen); 6611 rmdir(DUMMY_SUBDIR); 6612 } else if ((rc = remove(DUMMY_SUBDIR_FILE)) == -1) { 6613 dm_handle_free(targhanp, targhlen); 6614 dm_handle_free(dirhanp, dirhlen); 6615 rmdir(DUMMY_SUBDIR); 6616 } 6617 if (fd == -1 || rc == -1) { 6618 DMLOG_PRINT(DMLVL_DEBUG, 6619 "Unable to set up variation! (errno = %d)\n", 6620 errno); 6621 DMVAR_SKIP(); 6622 } else { 6623 /* Variation */ 6624 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated targhanp)\n", 6625 szFuncName); 6626 rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, 6627 targhlen, sizeof(pathbuf), 6628 pathbuf, &rlen); 6629 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6630 6631 /* Variation clean up */ 6632 rc = rmdir(DUMMY_SUBDIR); 6633 if (rc == -1) { 6634 DMLOG_PRINT(DMLVL_DEBUG, 6635 "Unable to clean up variation! (errno = %d)\n", 6636 errno); 6637 } 6638 dm_handle_free(dirhanp, dirhlen); 6639 dm_handle_free(targhanp, targhlen); 6640 } 6641 } 6642 6643 szFuncName = "dm_sync_by_handle"; 6644 6645 /* 6646 * TEST : dm_sync_by_handle - invalid sid 6647 * EXPECTED: rc = -1, errno = EINVAL 6648 */ 6649 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 1)) { 6650 int fd; 6651 void *hanp; 6652 size_t hlen; 6653 6654 /* Variation set up */ 6655 if ((fd = 6656 open(DUMMY_FILE, O_RDWR | O_CREAT, 6657 DUMMY_FILE_RW_MODE)) == -1) { 6658 /* No clean up */ 6659 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 6660 close(fd); 6661 remove(DUMMY_FILE); 6662 } 6663 if (fd == -1 || rc == -1) { 6664 DMLOG_PRINT(DMLVL_DEBUG, 6665 "Unable to set up variation! (errno = %d)\n", 6666 errno); 6667 DMVAR_SKIP(); 6668 } else { 6669 /* Variation */ 6670 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", 6671 szFuncName); 6672 rc = dm_sync_by_handle(INVALID_ADDR, hanp, hlen, 6673 DM_NO_TOKEN); 6674 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 6675 6676 /* Variation clean up */ 6677 rc = close(fd); 6678 rc |= remove(DUMMY_FILE); 6679 if (rc == -1) { 6680 DMLOG_PRINT(DMLVL_DEBUG, 6681 "Unable to clean up variation! (errno = %d)\n", 6682 errno); 6683 } 6684 dm_handle_free(hanp, hlen); 6685 } 6686 } 6687 6688 /* 6689 * TEST : dm_sync_by_handle - DM_NO_SESSION sid 6690 * EXPECTED: rc = -1, errno = EINVAL 6691 */ 6692 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 2)) { 6693 int fd; 6694 void *hanp; 6695 size_t hlen; 6696 6697 /* Variation set up */ 6698 if ((fd = 6699 open(DUMMY_FILE, O_RDWR | O_CREAT, 6700 DUMMY_FILE_RW_MODE)) == -1) { 6701 /* No clean up */ 6702 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 6703 close(fd); 6704 remove(DUMMY_FILE); 6705 } 6706 if (fd == -1 || rc == -1) { 6707 DMLOG_PRINT(DMLVL_DEBUG, 6708 "Unable to set up variation! (errno = %d)\n", 6709 errno); 6710 DMVAR_SKIP(); 6711 } else { 6712 /* Variation */ 6713 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 6714 szFuncName); 6715 rc = dm_sync_by_handle(DM_NO_SESSION, hanp, hlen, 6716 DM_NO_TOKEN); 6717 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 6718 6719 /* Variation clean up */ 6720 rc = close(fd); 6721 rc |= remove(DUMMY_FILE); 6722 if (rc == -1) { 6723 DMLOG_PRINT(DMLVL_DEBUG, 6724 "Unable to clean up variation! (errno = %d)\n", 6725 errno); 6726 } 6727 dm_handle_free(hanp, hlen); 6728 } 6729 } 6730 6731 /* 6732 * TEST : dm_sync_by_handle - invalid hanp 6733 * EXPECTED: rc = -1, errno = EFAULT 6734 */ 6735 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 3)) { 6736 int fd; 6737 void *hanp; 6738 size_t hlen; 6739 6740 /* Variation set up */ 6741 if ((fd = 6742 open(DUMMY_FILE, O_RDWR | O_CREAT, 6743 DUMMY_FILE_RW_MODE)) == -1) { 6744 /* No clean up */ 6745 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 6746 close(fd); 6747 remove(DUMMY_FILE); 6748 } 6749 if (fd == -1 || rc == -1) { 6750 DMLOG_PRINT(DMLVL_DEBUG, 6751 "Unable to set up variation! (errno = %d)\n", 6752 errno); 6753 DMVAR_SKIP(); 6754 } else { 6755 /* Variation */ 6756 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", 6757 szFuncName); 6758 rc = dm_sync_by_handle(sid, (void *)INVALID_ADDR, hlen, 6759 DM_NO_TOKEN); 6760 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 6761 6762 /* Variation clean up */ 6763 rc = close(fd); 6764 rc |= remove(DUMMY_FILE); 6765 if (rc == -1) { 6766 DMLOG_PRINT(DMLVL_DEBUG, 6767 "Unable to clean up variation! (errno = %d)\n", 6768 errno); 6769 } 6770 dm_handle_free(hanp, hlen); 6771 } 6772 } 6773 6774 /* 6775 * TEST : dm_sync_by_handle - invalid hlen 6776 * EXPECTED: rc = -1, errno = EBADF 6777 */ 6778 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 4)) { 6779 int fd; 6780 void *hanp; 6781 size_t hlen; 6782 6783 /* Variation set up */ 6784 if ((fd = 6785 open(DUMMY_FILE, O_RDWR | O_CREAT, 6786 DUMMY_FILE_RW_MODE)) == -1) { 6787 /* No clean up */ 6788 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 6789 close(fd); 6790 remove(DUMMY_FILE); 6791 } 6792 if (fd == -1 || rc == -1) { 6793 DMLOG_PRINT(DMLVL_DEBUG, 6794 "Unable to set up variation! (errno = %d)\n", 6795 errno); 6796 DMVAR_SKIP(); 6797 } else { 6798 /* Variation */ 6799 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n", 6800 szFuncName); 6801 rc = dm_sync_by_handle(sid, hanp, INVALID_ADDR, 6802 DM_NO_TOKEN); 6803 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 6804 6805 /* Variation clean up */ 6806 rc = close(fd); 6807 rc |= remove(DUMMY_FILE); 6808 if (rc == -1) { 6809 DMLOG_PRINT(DMLVL_DEBUG, 6810 "Unable to clean up variation! (errno = %d)\n", 6811 errno); 6812 } 6813 dm_handle_free(hanp, hlen); 6814 } 6815 } 6816 6817 /* 6818 * TEST : dm_sync_by_handle - invalid token 6819 * EXPECTED: rc = -1, errno = EINVAL 6820 */ 6821 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 5)) { 6822 int fd; 6823 void *hanp; 6824 size_t hlen; 6825 6826 /* Variation set up */ 6827 if ((fd = 6828 open(DUMMY_FILE, O_RDWR | O_CREAT, 6829 DUMMY_FILE_RW_MODE)) == -1) { 6830 /* No clean up */ 6831 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 6832 close(fd); 6833 remove(DUMMY_FILE); 6834 } 6835 if (fd == -1 || rc == -1) { 6836 DMLOG_PRINT(DMLVL_DEBUG, 6837 "Unable to set up variation! (errno = %d)\n", 6838 errno); 6839 DMVAR_SKIP(); 6840 } else { 6841 /* Variation */ 6842 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", 6843 szFuncName); 6844 rc = dm_sync_by_handle(sid, hanp, hlen, INVALID_ADDR); 6845 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 6846 6847 /* Variation clean up */ 6848 rc = close(fd); 6849 rc |= remove(DUMMY_FILE); 6850 if (rc == -1) { 6851 DMLOG_PRINT(DMLVL_DEBUG, 6852 "Unable to clean up variation! (errno = %d)\n", 6853 errno); 6854 } 6855 dm_handle_free(hanp, hlen); 6856 } 6857 } 6858 6859 /* 6860 * TEST : dm_sync_by_handle - file handle 6861 * EXPECTED: rc = 0 6862 */ 6863 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 6)) { 6864 int fd; 6865 void *hanp; 6866 size_t hlen; 6867 6868 /* Variation set up */ 6869 if ((fd = 6870 open(DUMMY_FILE, O_RDWR | O_CREAT, 6871 DUMMY_FILE_RW_MODE)) == -1) { 6872 /* No clean up */ 6873 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 6874 close(fd); 6875 remove(DUMMY_FILE); 6876 } else 6877 if ((rc = 6878 (write(fd, DUMMY_STRING, DUMMY_STRLEN) == 6879 DUMMY_STRLEN) ? 0 : -1) == -1) { 6880 close(fd); 6881 remove(DUMMY_FILE); 6882 dm_handle_free(hanp, hlen); 6883 } 6884 if (fd == -1 || rc == -1) { 6885 DMLOG_PRINT(DMLVL_DEBUG, 6886 "Unable to set up variation! (errno = %d)\n", 6887 errno); 6888 DMVAR_SKIP(); 6889 } else { 6890 /* Variation */ 6891 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 6892 szFuncName); 6893 rc = dm_sync_by_handle(sid, hanp, hlen, DM_NO_TOKEN); 6894 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 6895 6896 /* Variation clean up */ 6897 rc = close(fd); 6898 rc |= remove(DUMMY_FILE); 6899 if (rc == -1) { 6900 DMLOG_PRINT(DMLVL_DEBUG, 6901 "Unable to clean up variation! (errno = %d)\n", 6902 errno); 6903 } 6904 dm_handle_free(hanp, hlen); 6905 } 6906 } 6907 6908 /* 6909 * TEST : dm_sync_by_handle - directory handle 6910 * EXPECTED: rc = -1, errno = EINVAL 6911 */ 6912 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 7)) { 6913 void *hanp; 6914 size_t hlen; 6915 6916 /* Variation set up */ 6917 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) { 6918 /* No clean up */ 6919 } else if ((rc = dm_path_to_handle(DUMMY_SUBDIR, &hanp, &hlen)) 6920 == -1) { 6921 rmdir(DUMMY_SUBDIR); 6922 } 6923 if (rc == -1) { 6924 DMLOG_PRINT(DMLVL_DEBUG, 6925 "Unable to set up variation! (errno = %d)\n", 6926 errno); 6927 DMVAR_SKIP(); 6928 } else { 6929 /* Variation */ 6930 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 6931 szFuncName); 6932 rc = dm_sync_by_handle(sid, hanp, hlen, DM_NO_TOKEN); 6933 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 6934 6935 /* Variation clean up */ 6936 rc = rmdir(DUMMY_SUBDIR); 6937 if (rc == -1) { 6938 DMLOG_PRINT(DMLVL_DEBUG, 6939 "Unable to clean up variation! (errno = %d)\n", 6940 errno); 6941 } 6942 dm_handle_free(hanp, hlen); 6943 } 6944 } 6945 6946 /* 6947 * TEST : dm_sync_by_handle - fs handle 6948 * EXPECTED: rc = -1, errno = EINVAL 6949 */ 6950 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 8)) { 6951 int fd; 6952 void *hanp; 6953 size_t hlen; 6954 6955 /* Variation set up */ 6956 if ((fd = 6957 open(DUMMY_FILE, O_RDWR | O_CREAT, 6958 DUMMY_FILE_RW_MODE)) == -1) { 6959 /* No clean up */ 6960 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen)) 6961 == -1) { 6962 close(fd); 6963 remove(DUMMY_FILE); 6964 } 6965 if (fd == -1 || rc == -1) { 6966 DMLOG_PRINT(DMLVL_DEBUG, 6967 "Unable to set up variation! (errno = %d)\n", 6968 errno); 6969 DMVAR_SKIP(); 6970 } else { 6971 /* Variation */ 6972 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName); 6973 rc = dm_sync_by_handle(sid, hanp, hlen, DM_NO_TOKEN); 6974 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 6975 6976 /* Variation clean up */ 6977 rc = close(fd); 6978 rc |= remove(DUMMY_FILE); 6979 if (rc == -1) { 6980 DMLOG_PRINT(DMLVL_DEBUG, 6981 "Unable to clean up variation! (errno = %d)\n", 6982 errno); 6983 } 6984 dm_handle_free(hanp, hlen); 6985 } 6986 } 6987 6988 /* 6989 * TEST : dm_sync_by_handle - global handle 6990 * EXPECTED: rc = -1, errno = EBADF 6991 */ 6992 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 9)) { 6993 /* Variation set up */ 6994 6995 /* Variation */ 6996 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 6997 rc = dm_sync_by_handle(sid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 6998 DM_NO_TOKEN); 6999 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 7000 7001 /* Variation clean up */ 7002 } 7003 7004 /* 7005 * TEST : dm_sync_by_handle - invalidated hanp 7006 * EXPECTED: rc = -1, errno = EBADF 7007 */ 7008 if (DMVAR_EXEC(SYNC_BY_HANDLE_BASE + 10)) { 7009 int fd; 7010 void *hanp; 7011 size_t hlen; 7012 7013 /* Variation set up */ 7014 if ((fd = 7015 open(DUMMY_FILE, O_RDWR | O_CREAT, 7016 DUMMY_FILE_RW_MODE)) == -1) { 7017 /* No clean up */ 7018 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) { 7019 close(fd); 7020 remove(DUMMY_FILE); 7021 } else if ((rc = close(fd)) == -1) { 7022 remove(DUMMY_FILE); 7023 dm_handle_free(hanp, hlen); 7024 } else if ((rc = remove(DUMMY_FILE)) == -1) { 7025 dm_handle_free(hanp, hlen); 7026 } 7027 if (fd == -1 || rc == -1) { 7028 DMLOG_PRINT(DMLVL_DEBUG, 7029 "Unable to set up variation! (errno = %d)\n", 7030 errno); 7031 DMVAR_SKIP(); 7032 } else { 7033 /* Variation */ 7034 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated hanp)\n", 7035 szFuncName); 7036 rc = dm_sync_by_handle(sid, hanp, hlen, DM_NO_TOKEN); 7037 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 7038 7039 /* Variation clean up */ 7040 dm_handle_free(hanp, hlen); 7041 } 7042 } 7043 7044 dm_handle_free(mtpthanp, mtpthlen); 7045 dm_handle_free(curdirhanp, curdirhlen); 7046 7047 DMLOG_STOP(); 7048 7049 tst_exit(); 7050 7051} 7052