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 : disp.c 21 * 22 * VARIATIONS : 155 23 * 24 * API'S TESTED : dm_get_config_events 25 * dm_set_disp 26 * dm_getall_disp 27 * dm_set_eventlist 28 * dm_get_eventlist 29 */ 30 #include <string.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <errno.h> 34 #include <pthread.h> 35 #include <unistd.h> 36 #include <sys/stat.h> 37 #include <sys/mount.h> 38 #include <fcntl.h> 39 #include "dm_test.h" 40 41 #define TMP_FILELEN 1000 42 43 pthread_t tid; 44 dm_sessid_t sid; 45 char dmMsgBuf[4096]; 46 char command[4096]; 47 char *mountPt; 48 char *deviceNm; 49 char DummyFile[FILENAME_MAX]; 50 char DummyFile2[FILENAME_MAX]; 51 char DummySubdir[FILENAME_MAX]; 52 53 void *Thread(void *); 54 55 int main(int argc, char **argv) 56 { 57 58 char *szFuncName; 59 char *varstr; 60 int i; 61 int rc; 62 char *szSessionInfo = "dm_test session info"; 63 dm_eventset_t events, maxEvents, minEvents; 64 void *fshanp; 65 size_t fshlen; 66 int varNum; 67 68 DMOPT_PARSE(argc, argv); 69 DMLOG_START(); 70 71 DMEV_ZERO(events); 72 DMEV_SET(DM_EVENT_MOUNT, events); 73 74 /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION!!! */ 75 if ((rc = dm_init_service(&varstr)) != 0) { 76 DMLOG_PRINT(DMLVL_ERR, 77 "dm_init_service failed! (rc = %d, errno = %d)\n", 78 rc, errno); 79 DM_EXIT(); 80 } else if ((rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &sid)) 81 == -1) { 82 DMLOG_PRINT(DMLVL_ERR, 83 "dm_create_session failed! (rc = %d, errno = %d)\n", 84 rc, errno); 85 DM_EXIT(); 86 } else 87 if ((rc = 88 dm_set_disp(sid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, DM_NO_TOKEN, 89 &events, DM_EVENT_MAX)) == -1) { 90 DMLOG_PRINT(DMLVL_ERR, 91 "dm_set_disp failed! (rc = %d, errno = %d)\n", rc, 92 errno); 93 dm_destroy_session(sid); 94 DM_EXIT(); 95 } else if ((rc = pthread_create(&tid, NULL, Thread, NULL)) != 0) { 96 DMLOG_PRINT(DMLVL_ERR, 97 "pthread_create failed! (rc = %d, errno = %d)\n", 98 rc, errno); 99 dm_destroy_session(sid); 100 DM_EXIT(); 101 } else if ((rc = dmimpl_mount(&mountPt, &deviceNm)) == -1) { 102 DMLOG_PRINT(DMLVL_ERR, 103 "dmimpl_mount failed! (rc = %d, errno = %d)\n", rc, 104 errno); 105 dm_destroy_session(sid); 106 DM_EXIT(); 107 } else { 108 int fd; 109 110 sprintf(DummyFile, "%s/%s", mountPt, DUMMY_FILE); 111 sprintf(DummyFile2, "%s/%s", mountPt, DUMMY_FILE2); 112 sprintf(DummySubdir, "%s/%s", mountPt, DUMMY_SUBDIR); 113 114 remove(DummyFile); 115 remove(DummyFile2); 116 rmdir(DummySubdir); 117 118 EVENT_DELIVERY_DELAY; 119 fd = open(DummyFile, O_RDWR | O_CREAT, DUMMY_FILE_RW_MODE); 120 if (fd != -1) { 121 for (i = 0; i < TMP_FILELEN / DUMMY_STRLEN; i++) { 122 if (write(fd, DUMMY_STRING, DUMMY_STRLEN) != 123 DUMMY_STRLEN) { 124 rc = -1; 125 break; 126 } 127 } 128 } else { 129 rc = -1; 130 } 131 if (rc != -1) { 132 rc = fsync(fd); 133 } 134 if (rc != -1) { 135 rc = close(fd); 136 } 137 if (rc == -1) { 138 DMLOG_PRINT(DMLVL_ERR, 139 "creating dummy file failed! (rc = %d, errno = %d)\n", 140 rc, errno); 141 dm_destroy_session(sid); 142 DM_EXIT(); 143 } 144 145 rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE); 146 if (rc == -1) { 147 DMLOG_PRINT(DMLVL_ERR, 148 "creating dummy dir failed! (rc = %d, errno = %d)\n", 149 rc, errno); 150 dm_destroy_session(sid); 151 DM_EXIT(); 152 } 153 154 DMEV_ZERO(maxEvents); 155 DMEV_SET(DM_EVENT_PREUNMOUNT, maxEvents); 156 DMEV_SET(DM_EVENT_UNMOUNT, maxEvents); 157 DMEV_SET(DM_EVENT_CREATE, maxEvents); 158 DMEV_SET(DM_EVENT_CLOSE, maxEvents); 159 DMEV_SET(DM_EVENT_POSTCREATE, maxEvents); 160 DMEV_SET(DM_EVENT_REMOVE, maxEvents); 161 DMEV_SET(DM_EVENT_POSTREMOVE, maxEvents); 162 DMEV_SET(DM_EVENT_RENAME, maxEvents); 163 DMEV_SET(DM_EVENT_POSTRENAME, maxEvents); 164 DMEV_SET(DM_EVENT_LINK, maxEvents); 165 DMEV_SET(DM_EVENT_POSTLINK, maxEvents); 166 DMEV_SET(DM_EVENT_SYMLINK, maxEvents); 167 DMEV_SET(DM_EVENT_POSTSYMLINK, maxEvents); 168 DMEV_SET(DM_EVENT_ATTRIBUTE, maxEvents); 169 DMEV_SET(DM_EVENT_DESTROY, maxEvents); 170 DMEV_SET(DM_EVENT_NOSPACE, maxEvents); 171 172 DMEV_ZERO(minEvents); 173 DMEV_SET(DM_EVENT_PREUNMOUNT, minEvents); 174 DMEV_SET(DM_EVENT_UNMOUNT, minEvents); 175 } 176 177 DMLOG_PRINT(DMLVL_DEBUG, 178 "Starting DMAPI disposition/eventlist tests\n"); 179 180 szFuncName = "dm_get_config_events"; 181 182 /* 183 * TEST : dm_get_config_events - invalid hanp 184 * EXPECTED: rc = -1, errno = EFAULT 185 */ 186 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 1)) { 187 void *hanp; 188 size_t hlen; 189 dm_eventset_t eventset; 190 u_int nelem; 191 192 /* Variation set up */ 193 rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen); 194 if (rc == -1) { 195 DMLOG_PRINT(DMLVL_DEBUG, 196 "Unable to set up variation! (errno = %d)\n", 197 errno); 198 DMVAR_SKIP(); 199 } else { 200 /* Variation */ 201 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", 202 szFuncName); 203 rc = dm_get_config_events((void *)INVALID_ADDR, hlen, 204 DM_EVENT_MAX, &eventset, 205 &nelem); 206 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 207 208 /* Variation clean up */ 209 dm_handle_free(hanp, hlen); 210 } 211 } 212 213 /* 214 * TEST : dm_get_config_events - invalid hlen 215 * EXPECTED: rc = -1, errno = EBADF 216 */ 217 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 2)) { 218 void *hanp; 219 size_t hlen; 220 dm_eventset_t eventset; 221 u_int nelem; 222 223 /* Variation set up */ 224 rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen); 225 if (rc == -1) { 226 DMLOG_PRINT(DMLVL_DEBUG, 227 "Unable to set up variation! (errno = %d)\n", 228 errno); 229 DMVAR_SKIP(); 230 } else { 231 /* Variation */ 232 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n", 233 szFuncName); 234 rc = dm_get_config_events(hanp, INVALID_ADDR, 235 DM_EVENT_MAX, &eventset, 236 &nelem); 237 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 238 239 /* Variation clean up */ 240 dm_handle_free(hanp, hlen); 241 } 242 } 243 244 /* 245 * TEST : dm_get_config_events - invalid nelem 246 * EXPECTED: rc = -1, errno = E2BIG 247 * 248 * This variation uncovered XFS BUG #18 (nelem not updated) 249 */ 250 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 3)) { 251 void *hanp; 252 size_t hlen; 253 dm_eventset_t eventset; 254 u_int nelem; 255 256 /* Variation set up */ 257 rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen); 258 if (rc == -1) { 259 DMLOG_PRINT(DMLVL_DEBUG, 260 "Unable to set up variation! (errno = %d)\n", 261 errno); 262 DMVAR_SKIP(); 263 } else { 264 /* Variation */ 265 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid nelem)\n", 266 szFuncName); 267 rc = dm_get_config_events(hanp, hlen, 0, &eventset, 268 &nelem); 269 if (rc == -1) { 270 if (errno == E2BIG) { 271 if (nelem == DM_EVENT_MAX) { 272 DMLOG_PRINT(DMLVL_DEBUG, 273 "%s passed with expected rc = %d and expected errno = %d (nelem = %d)\n", 274 szFuncName, rc, 275 errno, nelem); 276 DMVAR_PASS(); 277 } else { 278 DMLOG_PRINT(DMLVL_ERR, 279 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 280 szFuncName, rc, 281 nelem, 282 DM_EVENT_MAX); 283 DMVAR_FAIL(); 284 } 285 } else { 286 DMLOG_PRINT(DMLVL_ERR, 287 "%s failed with expected rc = %d but unexpected errno = %d\n", 288 szFuncName, rc, errno); 289 DMVAR_FAIL(); 290 } 291 } else { 292 DMLOG_PRINT(DMLVL_ERR, 293 "%s failed with unexpected rc = %d\n", 294 szFuncName, rc); 295 DMVAR_FAIL(); 296 } 297 298 /* Variation clean up */ 299 dm_handle_free(hanp, hlen); 300 } 301 } 302 303 /* 304 * TEST : dm_get_config_events - invalid eventsetp 305 * EXPECTED: rc = -1, errno = EFAULT 306 */ 307 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 4)) { 308 void *hanp; 309 size_t hlen; 310 u_int nelem; 311 312 /* Variation set up */ 313 rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen); 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, "%s(invalid eventsetp)\n", 322 szFuncName); 323 rc = dm_get_config_events(hanp, hlen, DM_EVENT_MAX, 324 (dm_eventset_t *) 325 INVALID_ADDR, &nelem); 326 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 327 328 /* Variation clean up */ 329 dm_handle_free(hanp, hlen); 330 } 331 } 332 333 /* 334 * TEST : dm_get_config_events - invalid nelemp 335 * EXPECTED: rc = -1, errno = EFAULT 336 */ 337 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 5)) { 338 void *hanp; 339 size_t hlen; 340 dm_eventset_t eventset; 341 342 /* Variation set up */ 343 rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen); 344 if (rc == -1) { 345 DMLOG_PRINT(DMLVL_DEBUG, 346 "Unable to set up variation! (errno = %d)\n", 347 errno); 348 DMVAR_SKIP(); 349 } else { 350 /* Variation */ 351 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid nelemp)\n", 352 szFuncName); 353 rc = dm_get_config_events(hanp, hlen, DM_EVENT_MAX, 354 &eventset, 355 (u_int *) INVALID_ADDR); 356 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 357 358 /* Variation clean up */ 359 dm_handle_free(hanp, hlen); 360 } 361 } 362 363 /* 364 * TEST : dm_get_config_events - fs handle 365 * EXPECTED: rc = 0 366 * 367 * This variation uncovered XFS BUG #19 (DM_EVENT_USER not returned) 368 */ 369 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 6)) { 370 void *hanp; 371 size_t hlen; 372 dm_eventset_t eventset; 373 u_int nelem; 374 375 /* Variation set up */ 376 rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen); 377 if (rc == -1) { 378 DMLOG_PRINT(DMLVL_DEBUG, 379 "Unable to set up variation! (errno = %d)\n", 380 errno); 381 DMVAR_SKIP(); 382 } else { 383 /* Variation */ 384 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName); 385 rc = dm_get_config_events(hanp, hlen, DM_EVENT_MAX, 386 &eventset, &nelem); 387 if (rc == 0) { 388 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 389 if (nelem == DM_EVENT_MAX) { 390 if (memcmp 391 (&eventset, &dmimpl_eventset, 392 sizeof(dm_eventset_t)) == 0) { 393 DMLOG_PRINT(DMLVL_DEBUG, 394 "%s passed with expected rc = %d\n", 395 szFuncName, 0); 396 DMVAR_PASS(); 397 } else { 398 DMLOG_PRINT(DMLVL_ERR, 399 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 400 szFuncName, 0, 401 eventset, 402 dmimpl_eventset); 403 DMVAR_FAIL(); 404 } 405 } else { 406 DMLOG_PRINT(DMLVL_ERR, 407 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 408 szFuncName, 0, nelem, 409 DM_EVENT_DESTROY + 1); 410 DMVAR_FAIL(); 411 } 412 } else { 413 DMLOG_PRINT(DMLVL_ERR, 414 "%s failed with unexpected rc = %d (errno = %d)\n", 415 szFuncName, rc, errno); 416 DMVAR_FAIL(); 417 } 418 419 /* Variation clean up */ 420 dm_handle_free(hanp, hlen); 421 } 422 } 423 424 /* 425 * TEST : dm_get_config_events - file handle 426 * EXPECTED: rc = 0 427 */ 428 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 7)) { 429 void *hanp; 430 size_t hlen; 431 dm_eventset_t eventset; 432 u_int nelem; 433 434 /* Variation set up */ 435 rc = dm_path_to_handle(DummyFile, &hanp, &hlen); 436 if (rc == -1) { 437 DMLOG_PRINT(DMLVL_DEBUG, 438 "Unable to set up variation! (errno = %d)\n", 439 errno); 440 DMVAR_SKIP(); 441 } else { 442 /* Variation */ 443 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 444 szFuncName); 445 rc = dm_get_config_events(hanp, hlen, DM_EVENT_MAX, 446 &eventset, &nelem); 447 if (rc == 0) { 448 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 449 if (nelem == DM_EVENT_MAX) { 450 if (memcmp 451 (&eventset, &dmimpl_eventset, 452 sizeof(dm_eventset_t)) == 0) { 453 DMLOG_PRINT(DMLVL_DEBUG, 454 "%s passed with expected rc = %d\n", 455 szFuncName, 0); 456 DMVAR_PASS(); 457 } else { 458 DMLOG_PRINT(DMLVL_ERR, 459 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 460 szFuncName, 0, 461 eventset, 462 dmimpl_eventset); 463 DMVAR_FAIL(); 464 } 465 } else { 466 DMLOG_PRINT(DMLVL_ERR, 467 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 468 szFuncName, 0, nelem, 469 DM_EVENT_DESTROY + 1); 470 DMVAR_FAIL(); 471 } 472 } else { 473 DMLOG_PRINT(DMLVL_ERR, 474 "%s failed with unexpected rc = %d (errno = %d)\n", 475 szFuncName, rc, errno); 476 DMVAR_FAIL(); 477 } 478 479 /* Variation clean up */ 480 dm_handle_free(hanp, hlen); 481 } 482 } 483 484 /* 485 * TEST : dm_get_config_events - dir handle 486 * EXPECTED: rc = 0 487 */ 488 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 8)) { 489 void *hanp; 490 size_t hlen; 491 dm_eventset_t eventset; 492 u_int nelem; 493 494 /* Variation set up */ 495 rc = dm_path_to_handle(DummySubdir, &hanp, &hlen); 496 if (rc == -1) { 497 DMLOG_PRINT(DMLVL_DEBUG, 498 "Unable to set up variation! (errno = %d)\n", 499 errno); 500 DMVAR_SKIP(); 501 } else { 502 /* Variation */ 503 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 504 szFuncName); 505 rc = dm_get_config_events(hanp, hlen, DM_EVENT_MAX, 506 &eventset, &nelem); 507 if (rc == 0) { 508 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 509 if (nelem == DM_EVENT_MAX) { 510 if (memcmp 511 (&eventset, &dmimpl_eventset, 512 sizeof(dm_eventset_t)) == 0) { 513 DMLOG_PRINT(DMLVL_DEBUG, 514 "%s passed with expected rc = %d\n", 515 szFuncName, 0); 516 DMVAR_PASS(); 517 } else { 518 DMLOG_PRINT(DMLVL_ERR, 519 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 520 szFuncName, 0, 521 eventset, 522 dmimpl_eventset); 523 DMVAR_FAIL(); 524 } 525 } else { 526 DMLOG_PRINT(DMLVL_ERR, 527 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 528 szFuncName, 0, nelem, 529 DM_EVENT_DESTROY + 1); 530 DMVAR_FAIL(); 531 } 532 } else { 533 DMLOG_PRINT(DMLVL_ERR, 534 "%s failed with unexpected rc = %d (errno = %d)\n", 535 szFuncName, rc, errno); 536 DMVAR_FAIL(); 537 } 538 539 /* Variation clean up */ 540 dm_handle_free(hanp, hlen); 541 } 542 } 543 544 /* 545 * TEST : dm_get_config_events - global handle 546 * EXPECTED: rc = -1, errno = EBADF 547 */ 548 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 9)) { 549 dm_eventset_t eventset; 550 u_int nelem; 551 552 /* Variation set up */ 553 554 /* Variation */ 555 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName); 556 rc = dm_get_config_events(DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 557 DM_EVENT_MAX, &eventset, &nelem); 558 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 559 560 /* Variation clean up */ 561 } 562 563 /* 564 * TEST : dm_get_config_events - invalidated handle 565 * EXPECTED: rc = -1, errno = EBADF 566 */ 567 if (DMVAR_EXEC(GET_CONFIG_EVENTS_BASE + 10)) { 568 void *hanp; 569 size_t hlen; 570 dm_eventset_t eventset; 571 u_int nelem; 572 573 /* Variation set up */ 574 sprintf(command, "cp %s %s", DummyFile, DummyFile2); 575 if ((rc = system(command)) == -1) { 576 /* No clean up */ 577 } else if ((rc = dm_path_to_handle(DummyFile2, &hanp, &hlen)) == 578 -1) { 579 remove(DummyFile2); 580 } else if ((rc = remove(DummyFile2)) == -1) { 581 dm_handle_free(hanp, hlen); 582 } 583 if (rc == -1) { 584 DMLOG_PRINT(DMLVL_DEBUG, 585 "Unable to set up variation! (errno = %d)\n", 586 errno); 587 DMVAR_SKIP(); 588 } else { 589 /* Variation */ 590 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated handle)\n", 591 szFuncName); 592 rc = dm_get_config_events(hanp, hlen, DM_EVENT_MAX, 593 &eventset, &nelem); 594 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 595 596 /* Variation clean up */ 597 dm_handle_free(hanp, hlen); 598 } 599 } 600 601 szFuncName = "dm_set_disp"; 602 603 /* 604 * TEST : dm_set_disp - DM_NO_SESSION sid 605 * EXPECTED: rc = -1, errno = EINVAL 606 */ 607 if (DMVAR_EXEC(SET_DISP_BASE + 1)) { 608 dm_sessid_t newsid; 609 void *hanp; 610 size_t hlen; 611 dm_eventset_t eventset = minEvents; 612 613 /* Variation set up */ 614 if ((rc = 615 dm_create_session(DM_NO_SESSION, szSessionInfo, 616 &newsid)) == -1) { 617 /* No clean up */ 618 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 619 == -1) { 620 dm_destroy_session(newsid); 621 } 622 if (rc == -1) { 623 DMLOG_PRINT(DMLVL_DEBUG, 624 "Unable to set up variation! (errno = %d)\n", 625 errno); 626 DMVAR_SKIP(); 627 } else { 628 /* Variation */ 629 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 630 szFuncName); 631 rc = dm_set_disp(DM_NO_SESSION, hanp, hlen, DM_NO_TOKEN, 632 &eventset, DM_EVENT_MAX); 633 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 634 635 /* Variation clean up */ 636 rc = dm_destroy_session(newsid); 637 if (rc == -1) { 638 DMLOG_PRINT(DMLVL_DEBUG, 639 "Unable to clean up variation! (errno = %d)\n", 640 errno); 641 } 642 dm_handle_free(hanp, hlen); 643 } 644 } 645 646 /* 647 * TEST : dm_set_disp - invalid sid 648 * EXPECTED: rc = -1, errno = EINVAL 649 */ 650 if (DMVAR_EXEC(SET_DISP_BASE + 2)) { 651 dm_sessid_t newsid; 652 void *hanp; 653 size_t hlen; 654 dm_eventset_t eventset = minEvents; 655 656 /* Variation set up */ 657 if ((rc = 658 dm_create_session(DM_NO_SESSION, szSessionInfo, 659 &newsid)) == -1) { 660 /* No clean up */ 661 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 662 == -1) { 663 dm_destroy_session(newsid); 664 } 665 if (rc == -1) { 666 DMLOG_PRINT(DMLVL_DEBUG, 667 "Unable to set up variation! (errno = %d)\n", 668 errno); 669 DMVAR_SKIP(); 670 } else { 671 /* Variation */ 672 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", 673 szFuncName); 674 rc = dm_set_disp(INVALID_ADDR, hanp, hlen, DM_NO_TOKEN, 675 &eventset, DM_EVENT_MAX); 676 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 677 678 /* Variation clean up */ 679 rc = dm_destroy_session(newsid); 680 if (rc == -1) { 681 DMLOG_PRINT(DMLVL_DEBUG, 682 "Unable to clean up variation! (errno = %d)\n", 683 errno); 684 } 685 dm_handle_free(hanp, hlen); 686 } 687 } 688 689 /* 690 * TEST : dm_set_disp - invalid hanp 691 * EXPECTED: rc = -1, errno = EFAULT 692 */ 693 if (DMVAR_EXEC(SET_DISP_BASE + 3)) { 694 dm_sessid_t newsid; 695 void *hanp; 696 size_t hlen; 697 dm_eventset_t eventset = minEvents; 698 699 /* Variation set up */ 700 if ((rc = 701 dm_create_session(DM_NO_SESSION, szSessionInfo, 702 &newsid)) == -1) { 703 /* No clean up */ 704 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 705 == -1) { 706 dm_destroy_session(newsid); 707 } 708 if (rc == -1) { 709 DMLOG_PRINT(DMLVL_DEBUG, 710 "Unable to set up variation! (errno = %d)\n", 711 errno); 712 DMVAR_SKIP(); 713 } else { 714 /* Variation */ 715 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", 716 szFuncName); 717 rc = dm_set_disp(newsid, (void *)INVALID_ADDR, hlen, 718 DM_NO_TOKEN, &eventset, DM_EVENT_MAX); 719 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 720 721 /* Variation clean up */ 722 rc = dm_destroy_session(newsid); 723 if (rc == -1) { 724 DMLOG_PRINT(DMLVL_DEBUG, 725 "Unable to clean up variation! (errno = %d)\n", 726 errno); 727 } 728 dm_handle_free(hanp, hlen); 729 } 730 } 731 732 /* 733 * TEST : dm_set_disp - invalid hlen 734 * EXPECTED: rc = -1, errno = EBADF 735 */ 736 if (DMVAR_EXEC(SET_DISP_BASE + 4)) { 737 dm_sessid_t newsid; 738 void *hanp; 739 size_t hlen; 740 dm_eventset_t eventset = minEvents; 741 742 /* Variation set up */ 743 if ((rc = 744 dm_create_session(DM_NO_SESSION, szSessionInfo, 745 &newsid)) == -1) { 746 /* No clean up */ 747 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 748 == -1) { 749 dm_destroy_session(newsid); 750 } 751 if (rc == -1) { 752 DMLOG_PRINT(DMLVL_DEBUG, 753 "Unable to set up variation! (errno = %d)\n", 754 errno); 755 DMVAR_SKIP(); 756 } else { 757 /* Variation */ 758 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n", 759 szFuncName); 760 rc = dm_set_disp(newsid, hanp, INVALID_ADDR, 761 DM_NO_TOKEN, &eventset, DM_EVENT_MAX); 762 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 763 764 /* Variation clean up */ 765 rc = dm_destroy_session(newsid); 766 if (rc == -1) { 767 DMLOG_PRINT(DMLVL_DEBUG, 768 "Unable to clean up variation! (errno = %d)\n", 769 errno); 770 } 771 dm_handle_free(hanp, hlen); 772 } 773 } 774 775 /* 776 * TEST : dm_set_disp - invalid token 777 * EXPECTED: rc = -1, errno = EINVAL 778 */ 779 if (DMVAR_EXEC(SET_DISP_BASE + 5)) { 780 dm_sessid_t newsid; 781 void *hanp; 782 size_t hlen; 783 dm_eventset_t eventset = minEvents; 784 785 /* Variation set up */ 786 if ((rc = 787 dm_create_session(DM_NO_SESSION, szSessionInfo, 788 &newsid)) == -1) { 789 /* No clean up */ 790 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 791 == -1) { 792 dm_destroy_session(newsid); 793 } 794 if (rc == -1) { 795 DMLOG_PRINT(DMLVL_DEBUG, 796 "Unable to set up variation! (errno = %d)\n", 797 errno); 798 DMVAR_SKIP(); 799 } else { 800 /* Variation */ 801 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", 802 szFuncName); 803 rc = dm_set_disp(newsid, hanp, hlen, INVALID_ADDR, 804 &eventset, DM_EVENT_MAX); 805 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 806 807 /* Variation clean up */ 808 rc = dm_destroy_session(newsid); 809 if (rc == -1) { 810 DMLOG_PRINT(DMLVL_DEBUG, 811 "Unable to clean up variation! (errno = %d)\n", 812 errno); 813 } 814 dm_handle_free(hanp, hlen); 815 } 816 } 817 818 /* 819 * TEST : dm_set_disp - invalid eventsetp 820 * EXPECTED: rc = -1, errno = EFAULT 821 */ 822 if (DMVAR_EXEC(SET_DISP_BASE + 6)) { 823 dm_sessid_t newsid; 824 void *hanp; 825 size_t hlen; 826 827 /* Variation set up */ 828 if ((rc = 829 dm_create_session(DM_NO_SESSION, szSessionInfo, 830 &newsid)) == -1) { 831 /* No clean up */ 832 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 833 == -1) { 834 dm_destroy_session(newsid); 835 } 836 if (rc == -1) { 837 DMLOG_PRINT(DMLVL_DEBUG, 838 "Unable to set up variation! (errno = %d)\n", 839 errno); 840 DMVAR_SKIP(); 841 } else { 842 /* Variation */ 843 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid eventsetp)\n", 844 szFuncName); 845 rc = dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 846 (dm_eventset_t *) INVALID_ADDR, 847 DM_EVENT_MAX); 848 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 849 850 /* Variation clean up */ 851 rc = dm_destroy_session(newsid); 852 if (rc == -1) { 853 DMLOG_PRINT(DMLVL_DEBUG, 854 "Unable to clean up variation! (errno = %d)\n", 855 errno); 856 } 857 dm_handle_free(hanp, hlen); 858 } 859 } 860 861 /* 862 * TEST : dm_set_disp - invalid maxevent 863 * EXPECTED: rc = -1, errno = EINVAL 864 */ 865 if (DMVAR_EXEC(SET_DISP_BASE + 7)) { 866 dm_sessid_t newsid; 867 void *hanp; 868 size_t hlen; 869 dm_eventset_t eventset = minEvents; 870 871 /* Variation set up */ 872 if ((rc = 873 dm_create_session(DM_NO_SESSION, szSessionInfo, 874 &newsid)) == -1) { 875 /* No clean up */ 876 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 877 == -1) { 878 dm_destroy_session(newsid); 879 } 880 if (rc == -1) { 881 DMLOG_PRINT(DMLVL_DEBUG, 882 "Unable to set up variation! (errno = %d)\n", 883 errno); 884 DMVAR_SKIP(); 885 } else { 886 /* Variation */ 887 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid maxevent)\n", 888 szFuncName); 889 rc = dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 890 &eventset, DM_EVENT_MAX + 1); 891 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 892 893 /* Variation clean up */ 894 rc = dm_destroy_session(newsid); 895 if (rc == -1) { 896 DMLOG_PRINT(DMLVL_DEBUG, 897 "Unable to clean up variation! (errno = %d)\n", 898 errno); 899 } 900 dm_handle_free(hanp, hlen); 901 } 902 } 903 904 /* 905 * TEST : dm_set_disp - file handle 906 * EXPECTED: rc = -1, errno = EINVAL 907 */ 908 if (DMVAR_EXEC(SET_DISP_BASE + 8)) { 909 dm_sessid_t newsid; 910 void *hanp; 911 size_t hlen; 912 dm_eventset_t eventset = minEvents; 913 914 /* Variation set up */ 915 if ((rc = 916 dm_create_session(DM_NO_SESSION, szSessionInfo, 917 &newsid)) == -1) { 918 /* No clean up */ 919 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 920 -1) { 921 dm_destroy_session(newsid); 922 } 923 if (rc == -1) { 924 DMLOG_PRINT(DMLVL_DEBUG, 925 "Unable to set up variation! (errno = %d)\n", 926 errno); 927 DMVAR_SKIP(); 928 } else { 929 /* Variation */ 930 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n", 931 szFuncName); 932 rc = dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 933 &eventset, DM_EVENT_MAX); 934 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 935 936 /* Variation clean up */ 937 rc = dm_destroy_session(newsid); 938 if (rc == -1) { 939 DMLOG_PRINT(DMLVL_DEBUG, 940 "Unable to clean up variation! (errno = %d)\n", 941 errno); 942 } 943 dm_handle_free(hanp, hlen); 944 } 945 } 946 947 /* 948 * TEST : dm_set_disp - directory handle 949 * EXPECTED: rc = -1, errno = EINVAL 950 */ 951 if (DMVAR_EXEC(SET_DISP_BASE + 9)) { 952 dm_sessid_t newsid; 953 void *hanp; 954 size_t hlen; 955 dm_eventset_t eventset = minEvents; 956 957 /* Variation set up */ 958 if ((rc = 959 dm_create_session(DM_NO_SESSION, szSessionInfo, 960 &newsid)) == -1) { 961 /* No clean up */ 962 } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen)) 963 == -1) { 964 dm_destroy_session(newsid); 965 } 966 if (rc == -1) { 967 DMLOG_PRINT(DMLVL_DEBUG, 968 "Unable to set up variation! (errno = %d)\n", 969 errno); 970 DMVAR_SKIP(); 971 } else { 972 /* Variation */ 973 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 974 szFuncName); 975 rc = dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 976 &eventset, DM_EVENT_MAX); 977 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 978 979 /* Variation clean up */ 980 rc = dm_destroy_session(newsid); 981 if (rc == -1) { 982 DMLOG_PRINT(DMLVL_DEBUG, 983 "Unable to clean up variation! (errno = %d)\n", 984 errno); 985 } 986 dm_handle_free(hanp, hlen); 987 } 988 } 989 990 /* 991 * TEST : dm_set_disp - invalid global handle event 992 * EXPECTED: rc = -1, errno = EINVAL 993 */ 994 if (DMVAR_EXEC(SET_DISP_BASE + 10)) { 995 dm_sessid_t newsid; 996 dm_eventset_t eventset; 997 998 /* Variation set up */ 999 DMEV_ZERO(eventset); 1000 DMEV_SET(DM_EVENT_POSTCREATE, eventset); 1001 rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &newsid); 1002 if (rc == -1) { 1003 DMLOG_PRINT(DMLVL_DEBUG, 1004 "Unable to set up variation! (errno = %d)\n", 1005 errno); 1006 DMVAR_SKIP(); 1007 } else { 1008 /* Variation */ 1009 DMLOG_PRINT(DMLVL_DEBUG, 1010 "%s(invalid global handle event)\n", 1011 szFuncName); 1012 rc = dm_set_disp(newsid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 1013 DM_NO_TOKEN, &eventset, DM_EVENT_MAX); 1014 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1015 1016 /* Variation clean up */ 1017 rc = dm_destroy_session(newsid); 1018 if (rc == -1) { 1019 DMLOG_PRINT(DMLVL_DEBUG, 1020 "Unable to clean up variation! (errno = %d)\n", 1021 errno); 1022 } 1023 } 1024 } 1025 1026 /* 1027 * TEST : dm_set_disp - invalid fs handle event 1028 * EXPECTED: rc = -1, errno = EINVAL 1029 */ 1030 if (DMVAR_EXEC(SET_DISP_BASE + 11)) { 1031 dm_sessid_t newsid; 1032 void *hanp; 1033 size_t hlen; 1034 dm_eventset_t eventset; 1035 1036 /* Variation set up */ 1037 DMEV_ZERO(eventset); 1038 DMEV_SET(DM_EVENT_MOUNT, eventset); 1039 if ((rc = 1040 dm_create_session(DM_NO_SESSION, szSessionInfo, 1041 &newsid)) == -1) { 1042 /* No clean up */ 1043 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1044 == -1) { 1045 dm_destroy_session(newsid); 1046 } 1047 if (rc == -1) { 1048 DMLOG_PRINT(DMLVL_DEBUG, 1049 "Unable to set up variation! (errno = %d)\n", 1050 errno); 1051 DMVAR_SKIP(); 1052 } else { 1053 /* Variation */ 1054 DMLOG_PRINT(DMLVL_DEBUG, 1055 "%s(invalid fs handle event)\n", 1056 szFuncName); 1057 rc = dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1058 &eventset, DM_EVENT_MAX); 1059 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1060 1061 /* Variation clean up */ 1062 rc = dm_destroy_session(newsid); 1063 if (rc == -1) { 1064 DMLOG_PRINT(DMLVL_DEBUG, 1065 "Unable to clean up variation! (errno = %d)\n", 1066 errno); 1067 } 1068 dm_handle_free(hanp, hlen); 1069 } 1070 } 1071 1072 /* 1073 * TEST : dm_set_disp - valid global handle event 1074 * EXPECTED: rc = 0 1075 */ 1076 if (DMVAR_EXEC(SET_DISP_BASE + 12)) { 1077 dm_sessid_t newsid; 1078 dm_eventset_t eventset; 1079 1080 /* Variation set up */ 1081 DMEV_ZERO(eventset); 1082 DMEV_SET(DM_EVENT_MOUNT, eventset); 1083 rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &newsid); 1084 if (rc == -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, 1092 "%s(valid global handle event)\n", 1093 szFuncName); 1094 rc = dm_set_disp(newsid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, 1095 DM_NO_TOKEN, &eventset, DM_EVENT_MAX); 1096 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1097 1098 /* Variation clean up */ 1099 rc = dm_destroy_session(newsid); 1100 if (rc == -1) { 1101 DMLOG_PRINT(DMLVL_DEBUG, 1102 "Unable to clean up variation! (errno = %d)\n", 1103 errno); 1104 } 1105 } 1106 } 1107 1108 /* 1109 * TEST : dm_set_disp - valid fs handle event 1110 * EXPECTED: rc = 0 1111 */ 1112 if (DMVAR_EXEC(SET_DISP_BASE + 13)) { 1113 dm_sessid_t newsid; 1114 void *hanp; 1115 size_t hlen; 1116 dm_eventset_t eventset; 1117 1118 /* Variation set up */ 1119 DMEV_ZERO(eventset); 1120 DMEV_SET(DM_EVENT_POSTCREATE, eventset); 1121 if ((rc = 1122 dm_create_session(DM_NO_SESSION, szSessionInfo, 1123 &newsid)) == -1) { 1124 /* No clean up */ 1125 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1126 == -1) { 1127 dm_destroy_session(newsid); 1128 } 1129 if (rc == -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(valid fs handle event)\n", 1137 szFuncName); 1138 rc = dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1139 &eventset, DM_EVENT_MAX); 1140 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1141 1142 /* Variation clean up */ 1143 rc = dm_destroy_session(newsid); 1144 if (rc == -1) { 1145 DMLOG_PRINT(DMLVL_DEBUG, 1146 "Unable to clean up variation! (errno = %d)\n", 1147 errno); 1148 } 1149 dm_handle_free(hanp, hlen); 1150 } 1151 } 1152 1153 szFuncName = "dm_getall_disp"; 1154 1155 /* 1156 * TEST : dm_getall_disp - DM_NO_SESSION sid 1157 * EXPECTED: rc = -1, errno = EINVAL 1158 */ 1159 if (DMVAR_EXEC(GETALL_DISP_BASE + 1)) { 1160 char buf[64]; 1161 size_t rlen; 1162 1163 /* Variation set up */ 1164 1165 /* Variation */ 1166 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", szFuncName); 1167 rc = dm_getall_disp(DM_NO_SESSION, sizeof(buf), buf, &rlen); 1168 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1169 1170 /* Variation clean up */ 1171 } 1172 1173 /* 1174 * TEST : dm_getall_disp - invalid sid 1175 * EXPECTED: rc = -1, errno = EINVAL 1176 */ 1177 if (DMVAR_EXEC(GETALL_DISP_BASE + 2)) { 1178 char buf[64]; 1179 size_t rlen; 1180 1181 /* Variation set up */ 1182 1183 /* Variation */ 1184 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", szFuncName); 1185 rc = dm_getall_disp(INVALID_ADDR, sizeof(buf), buf, &rlen); 1186 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1187 1188 /* Variation clean up */ 1189 } 1190 1191 /* 1192 * TEST : dm_getall_disp - invalidated sid 1193 * EXPECTED: rc = -1, errno = EINVAL 1194 */ 1195 if (DMVAR_EXEC(GETALL_DISP_BASE + 3)) { 1196 dm_sessid_t newsid; 1197 char buf[64]; 1198 size_t rlen; 1199 void *hanp; 1200 size_t hlen; 1201 1202 /* Variation set up */ 1203 if ((rc = 1204 dm_create_session(DM_NO_SESSION, szSessionInfo, 1205 &newsid)) == -1) { 1206 /* No clean up */ 1207 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1208 == -1) { 1209 dm_destroy_session(newsid); 1210 } else 1211 if ((rc = 1212 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1213 &maxEvents, DM_EVENT_MAX)) == -1) { 1214 dm_handle_free(hanp, hlen); 1215 dm_destroy_session(newsid); 1216 } else if ((rc = dm_destroy_session(newsid)) == -1) { 1217 dm_handle_free(hanp, hlen); 1218 } 1219 if (rc == -1) { 1220 DMLOG_PRINT(DMLVL_DEBUG, 1221 "Unable to set up variation! (errno = %d)\n", 1222 errno); 1223 DMVAR_SKIP(); 1224 } else { 1225 /* Variation */ 1226 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated sid)\n", 1227 szFuncName); 1228 rc = dm_getall_disp(newsid, sizeof(buf), buf, &rlen); 1229 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1230 1231 /* Variation clean up */ 1232 dm_handle_free(hanp, hlen); 1233 } 1234 } 1235 1236 /* 1237 * TEST : dm_getall_disp - NULL bufp 1238 * EXPECTED: rc = -1, errno EFAULT 1239 */ 1240 if (DMVAR_EXEC(GETALL_DISP_BASE + 4)) { 1241 dm_sessid_t newsid; 1242 char buf[64]; 1243 size_t rlen; 1244 void *hanp; 1245 size_t hlen; 1246 1247 /* Variation set up */ 1248 if ((rc = 1249 dm_create_session(DM_NO_SESSION, szSessionInfo, 1250 &newsid)) == -1) { 1251 /* No clean up */ 1252 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1253 == -1) { 1254 dm_destroy_session(newsid); 1255 } else 1256 if ((rc = 1257 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1258 &maxEvents, DM_EVENT_MAX)) == -1) { 1259 dm_handle_free(hanp, hlen); 1260 dm_destroy_session(newsid); 1261 } 1262 if (rc == -1) { 1263 DMLOG_PRINT(DMLVL_DEBUG, 1264 "Unable to set up variation! (errno = %d)\n", 1265 errno); 1266 DMVAR_SKIP(); 1267 } else { 1268 /* Variation */ 1269 DMLOG_PRINT(DMLVL_DEBUG, "%s(NULL bufp)\n", szFuncName); 1270 rc = dm_getall_disp(newsid, sizeof(buf), NULL, &rlen); 1271 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1272 1273 /* Variation clean up */ 1274 rc = dm_destroy_session(newsid); 1275 if (rc == -1) { 1276 DMLOG_PRINT(DMLVL_DEBUG, 1277 "Unable to clean up variation! (errno = %d)\n", 1278 errno); 1279 } 1280 dm_handle_free(hanp, hlen); 1281 } 1282 } 1283 1284 /* 1285 * TEST : dm_getall_disp - invalid bufp 1286 * EXPECTED: rc = -1, errno EFAULT 1287 */ 1288 if (DMVAR_EXEC(GETALL_DISP_BASE + 5)) { 1289 dm_sessid_t newsid; 1290 char buf[64]; 1291 size_t rlen; 1292 void *hanp; 1293 size_t hlen; 1294 1295 /* Variation set up */ 1296 if ((rc = 1297 dm_create_session(DM_NO_SESSION, szSessionInfo, 1298 &newsid)) == -1) { 1299 /* No clean up */ 1300 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1301 == -1) { 1302 dm_destroy_session(newsid); 1303 } else 1304 if ((rc = 1305 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1306 &maxEvents, DM_EVENT_MAX)) == -1) { 1307 dm_handle_free(hanp, hlen); 1308 dm_destroy_session(newsid); 1309 } 1310 if (rc == -1) { 1311 DMLOG_PRINT(DMLVL_DEBUG, 1312 "Unable to set up variation! (errno = %d)\n", 1313 errno); 1314 DMVAR_SKIP(); 1315 } else { 1316 /* Variation */ 1317 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid bufp)\n", 1318 szFuncName); 1319 rc = dm_getall_disp(newsid, sizeof(buf), 1320 (void *)INVALID_ADDR, &rlen); 1321 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1322 1323 /* Variation clean up */ 1324 rc = dm_destroy_session(newsid); 1325 if (rc == -1) { 1326 DMLOG_PRINT(DMLVL_DEBUG, 1327 "Unable to clean up variation! (errno = %d)\n", 1328 errno); 1329 } 1330 dm_handle_free(hanp, hlen); 1331 } 1332 } 1333 1334 /* 1335 * TEST : dm_getall_disp - NULL rlenp 1336 * EXPECTED: rc = -1, errno EFAULT 1337 */ 1338 if (DMVAR_EXEC(GETALL_DISP_BASE + 6)) { 1339 dm_sessid_t newsid; 1340 char buf[64]; 1341 void *hanp; 1342 size_t hlen; 1343 1344 /* Variation set up */ 1345 if ((rc = 1346 dm_create_session(DM_NO_SESSION, szSessionInfo, 1347 &newsid)) == -1) { 1348 /* No clean up */ 1349 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1350 == -1) { 1351 dm_destroy_session(newsid); 1352 } else 1353 if ((rc = 1354 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1355 &maxEvents, DM_EVENT_MAX)) == -1) { 1356 dm_handle_free(hanp, hlen); 1357 dm_destroy_session(newsid); 1358 } 1359 if (rc == -1) { 1360 DMLOG_PRINT(DMLVL_DEBUG, 1361 "Unable to set up variation! (errno = %d)\n", 1362 errno); 1363 DMVAR_SKIP(); 1364 } else { 1365 /* Variation */ 1366 DMLOG_PRINT(DMLVL_DEBUG, "%s(NULL rlenp)\n", 1367 szFuncName); 1368 rc = dm_getall_disp(newsid, sizeof(buf), buf, NULL); 1369 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1370 1371 /* Variation clean up */ 1372 rc = dm_destroy_session(newsid); 1373 if (rc == -1) { 1374 DMLOG_PRINT(DMLVL_DEBUG, 1375 "Unable to clean up variation! (errno = %d)\n", 1376 errno); 1377 } 1378 dm_handle_free(hanp, hlen); 1379 } 1380 } 1381 1382 /* 1383 * TEST : dm_getall_disp - invalid rlenp 1384 * EXPECTED: rc = -1, errno EFAULT 1385 */ 1386 if (DMVAR_EXEC(GETALL_DISP_BASE + 7)) { 1387 dm_sessid_t newsid; 1388 char buf[64]; 1389 void *hanp; 1390 size_t hlen; 1391 1392 /* Variation set up */ 1393 if ((rc = 1394 dm_create_session(DM_NO_SESSION, szSessionInfo, 1395 &newsid)) == -1) { 1396 /* No clean up */ 1397 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1398 == -1) { 1399 dm_destroy_session(newsid); 1400 } else 1401 if ((rc = 1402 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1403 &maxEvents, DM_EVENT_MAX)) == -1) { 1404 dm_handle_free(hanp, hlen); 1405 dm_destroy_session(newsid); 1406 } 1407 if (rc == -1) { 1408 DMLOG_PRINT(DMLVL_DEBUG, 1409 "Unable to set up variation! (errno = %d)\n", 1410 errno); 1411 DMVAR_SKIP(); 1412 } else { 1413 /* Variation */ 1414 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid rlenp)\n", 1415 szFuncName); 1416 rc = dm_getall_disp(newsid, sizeof(buf), buf, 1417 (size_t *) INVALID_ADDR); 1418 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1419 1420 /* Variation clean up */ 1421 rc = dm_destroy_session(newsid); 1422 if (rc == -1) { 1423 DMLOG_PRINT(DMLVL_DEBUG, 1424 "Unable to clean up variation! (errno = %d)\n", 1425 errno); 1426 } 1427 dm_handle_free(hanp, hlen); 1428 } 1429 } 1430 1431 /* 1432 * TEST : dm_getall_disp - zero buflen 1433 * EXPECTED: rc = -1, errno = E2BIG 1434 */ 1435 if (DMVAR_EXEC(GETALL_DISP_BASE + 8)) { 1436 dm_sessid_t newsid; 1437 char buf[64]; 1438 size_t rlen; 1439 void *hanp; 1440 size_t hlen; 1441 1442 /* Variation set up */ 1443 if ((rc = 1444 dm_create_session(DM_NO_SESSION, szSessionInfo, 1445 &newsid)) == -1) { 1446 /* No clean up */ 1447 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1448 == -1) { 1449 dm_destroy_session(newsid); 1450 } else 1451 if ((rc = 1452 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1453 &maxEvents, DM_EVENT_MAX)) == -1) { 1454 dm_handle_free(hanp, hlen); 1455 dm_destroy_session(newsid); 1456 } 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(buflen zero)\n", 1465 szFuncName); 1466 rc = dm_getall_disp(newsid, 0, buf, &rlen); 1467 if (rc == -1 && errno == E2BIG) { 1468 DMLOG_PRINT(DMLVL_DEBUG, "rlen = %d\n", rlen); 1469 } 1470 DMVAR_ENDFAILEXP(szFuncName, -1, rc, E2BIG); 1471 1472 /* Variation clean up */ 1473 rc = dm_destroy_session(newsid); 1474 if (rc == -1) { 1475 DMLOG_PRINT(DMLVL_DEBUG, 1476 "Unable to clean up variation! (errno = %d)\n", 1477 errno); 1478 } 1479 dm_handle_free(hanp, hlen); 1480 } 1481 } 1482 1483 /* 1484 * TEST : dm_getall_disp - valid 1485 * EXPECTED: rc = 0 1486 */ 1487 if (DMVAR_EXEC(GETALL_DISP_BASE + 9)) { 1488 dm_sessid_t newsid; 1489 char buf[64]; 1490 size_t rlen; 1491 void *hanp; 1492 size_t hlen; 1493 1494 /* Variation set up */ 1495 if ((rc = 1496 dm_create_session(DM_NO_SESSION, szSessionInfo, 1497 &newsid)) == -1) { 1498 /* No clean up */ 1499 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1500 == -1) { 1501 dm_destroy_session(newsid); 1502 } else 1503 if ((rc = 1504 dm_set_disp(newsid, hanp, hlen, DM_NO_TOKEN, 1505 &maxEvents, DM_EVENT_MAX)) == -1) { 1506 dm_handle_free(hanp, hlen); 1507 dm_destroy_session(newsid); 1508 } 1509 if (rc == -1) { 1510 DMLOG_PRINT(DMLVL_DEBUG, 1511 "Unable to set up variation! (errno = %d)\n", 1512 errno); 1513 DMVAR_SKIP(); 1514 } else { 1515 /* Variation */ 1516 DMLOG_PRINT(DMLVL_DEBUG, "%s(valid)\n", szFuncName); 1517 rc = dm_getall_disp(newsid, sizeof(buf), buf, &rlen); 1518 if (rc == 0) { 1519 DMLOG_PRINT(DMLVL_DEBUG, "rlen = %d\n", rlen); 1520 dm_dispinfo_t *di = (dm_dispinfo_t *) buf; 1521 if (rlen == sizeof(dm_dispinfo_t) + hlen) { 1522 if (dm_handle_cmp 1523 (hanp, hlen, 1524 DM_GET_VALUE(di, di_fshandle, 1525 void *), 1526 DM_GET_LEN(di, 1527 di_fshandle)) == 0) { 1528 if (di->di_eventset == 1529 maxEvents) { 1530 DMLOG_PRINT(DMLVL_DEBUG, 1531 "%s passed with expected rc = %d\n", 1532 szFuncName, 1533 0); 1534 DMVAR_PASS(); 1535 } else { 1536 DMLOG_PRINT(DMLVL_ERR, 1537 "%s failed with expected rc = %d but unexpected eventset (%llx vs %llx)\n", 1538 szFuncName, 1539 0, 1540 di-> 1541 di_eventset, 1542 maxEvents); 1543 DMVAR_FAIL(); 1544 } 1545 } else { 1546 DMLOG_PRINT(DMLVL_ERR, 1547 "%s failed with expected rc = %d but unexpected fs handle (%llx vs %llx)\n", 1548 szFuncName, 0, 1549 *(__u64 *) hanp, 1550 *(__u64 *) 1551 DM_GET_VALUE(di, 1552 di_fshandle, 1553 void 1554 *)); 1555 DMVAR_FAIL(); 1556 } 1557 } else { 1558 DMLOG_PRINT(DMLVL_ERR, 1559 "%s failed with expected rc = %d but unexpected rlen (%d vs %d)\n", 1560 szFuncName, 0, rlen, 1561 sizeof(dm_dispinfo_t) + 1562 hlen); 1563 DMVAR_FAIL(); 1564 } 1565 } else { 1566 DMLOG_PRINT(DMLVL_ERR, 1567 "%s failed with unexpected rc = %d (errno = %d)\n", 1568 szFuncName, rc, errno); 1569 DMVAR_FAIL(); 1570 } 1571 1572 /* Variation clean up */ 1573 rc = dm_destroy_session(newsid); 1574 if (rc == -1) { 1575 DMLOG_PRINT(DMLVL_DEBUG, 1576 "Unable to clean up variation! (errno = %d)\n", 1577 errno); 1578 } 1579 dm_handle_free(hanp, hlen); 1580 } 1581 } 1582 1583 szFuncName = "dm_set_eventlist"; 1584 1585 /* 1586 * TEST : dm_set_eventlist - DM_NO_SESSION sid 1587 * EXPECTED: rc = -1, errno = EINVAL 1588 */ 1589 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 1)) { 1590 dm_sessid_t newsid; 1591 void *hanp; 1592 size_t hlen; 1593 dm_eventset_t eventset = minEvents; 1594 1595 /* Variation set up */ 1596 if ((rc = 1597 dm_create_session(DM_NO_SESSION, szSessionInfo, 1598 &newsid)) == -1) { 1599 /* No clean up */ 1600 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1601 == -1) { 1602 dm_destroy_session(newsid); 1603 } 1604 if (rc == -1) { 1605 DMLOG_PRINT(DMLVL_DEBUG, 1606 "Unable to set up variation! (errno = %d)\n", 1607 errno); 1608 DMVAR_SKIP(); 1609 } else { 1610 /* Variation */ 1611 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 1612 szFuncName); 1613 rc = dm_set_eventlist(DM_NO_SESSION, hanp, hlen, 1614 DM_NO_TOKEN, &eventset, 1615 DM_EVENT_MAX); 1616 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1617 1618 /* Variation clean up */ 1619 rc = dm_destroy_session(newsid); 1620 if (rc == -1) { 1621 DMLOG_PRINT(DMLVL_DEBUG, 1622 "Unable to clean up variation! (errno = %d)\n", 1623 errno); 1624 } 1625 dm_handle_free(hanp, hlen); 1626 } 1627 } 1628 1629 /* 1630 * TEST : dm_set_eventlist - invalid sid 1631 * EXPECTED: rc = -1, errno = EINVAL 1632 */ 1633 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 2)) { 1634 dm_sessid_t newsid; 1635 void *hanp; 1636 size_t hlen; 1637 dm_eventset_t eventset = minEvents; 1638 1639 /* Variation set up */ 1640 if ((rc = 1641 dm_create_session(DM_NO_SESSION, szSessionInfo, 1642 &newsid)) == -1) { 1643 /* No clean up */ 1644 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1645 == -1) { 1646 dm_destroy_session(newsid); 1647 } 1648 if (rc == -1) { 1649 DMLOG_PRINT(DMLVL_DEBUG, 1650 "Unable to set up variation! (errno = %d)\n", 1651 errno); 1652 DMVAR_SKIP(); 1653 } else { 1654 /* Variation */ 1655 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", 1656 szFuncName); 1657 rc = dm_set_eventlist(INVALID_ADDR, hanp, hlen, 1658 DM_NO_TOKEN, &eventset, 1659 DM_EVENT_MAX); 1660 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1661 1662 /* Variation clean up */ 1663 rc = dm_destroy_session(newsid); 1664 if (rc == -1) { 1665 DMLOG_PRINT(DMLVL_DEBUG, 1666 "Unable to clean up variation! (errno = %d)\n", 1667 errno); 1668 } 1669 dm_handle_free(hanp, hlen); 1670 } 1671 } 1672 1673 /* 1674 * TEST : dm_set_eventlist - invalid hanp 1675 * EXPECTED: rc = -1, errno = EFAULT 1676 */ 1677 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 3)) { 1678 dm_sessid_t newsid; 1679 void *hanp; 1680 size_t hlen; 1681 dm_eventset_t eventset = minEvents; 1682 1683 /* Variation set up */ 1684 if ((rc = 1685 dm_create_session(DM_NO_SESSION, szSessionInfo, 1686 &newsid)) == -1) { 1687 /* No clean up */ 1688 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1689 == -1) { 1690 dm_destroy_session(newsid); 1691 } 1692 if (rc == -1) { 1693 DMLOG_PRINT(DMLVL_DEBUG, 1694 "Unable to set up variation! (errno = %d)\n", 1695 errno); 1696 DMVAR_SKIP(); 1697 } else { 1698 /* Variation */ 1699 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", 1700 szFuncName); 1701 rc = dm_set_eventlist(newsid, (void *)INVALID_ADDR, 1702 hlen, DM_NO_TOKEN, &eventset, 1703 DM_EVENT_MAX); 1704 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1705 1706 /* Variation clean up */ 1707 rc = dm_destroy_session(newsid); 1708 if (rc == -1) { 1709 DMLOG_PRINT(DMLVL_DEBUG, 1710 "Unable to clean up variation! (errno = %d)\n", 1711 errno); 1712 } 1713 dm_handle_free(hanp, hlen); 1714 } 1715 } 1716 1717 /* 1718 * TEST : dm_set_eventlist - invalid hlen 1719 * EXPECTED: rc = -1, errno = EBADF 1720 */ 1721 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 4)) { 1722 dm_sessid_t newsid; 1723 void *hanp; 1724 size_t hlen; 1725 dm_eventset_t eventset = minEvents; 1726 1727 /* Variation set up */ 1728 if ((rc = 1729 dm_create_session(DM_NO_SESSION, szSessionInfo, 1730 &newsid)) == -1) { 1731 /* No clean up */ 1732 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1733 == -1) { 1734 dm_destroy_session(newsid); 1735 } 1736 if (rc == -1) { 1737 DMLOG_PRINT(DMLVL_DEBUG, 1738 "Unable to set up variation! (errno = %d)\n", 1739 errno); 1740 DMVAR_SKIP(); 1741 } else { 1742 /* Variation */ 1743 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n", 1744 szFuncName); 1745 rc = dm_set_eventlist(newsid, hanp, INVALID_ADDR, 1746 DM_NO_TOKEN, &eventset, 1747 DM_EVENT_MAX); 1748 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 1749 1750 /* Variation clean up */ 1751 rc = dm_destroy_session(newsid); 1752 if (rc == -1) { 1753 DMLOG_PRINT(DMLVL_DEBUG, 1754 "Unable to clean up variation! (errno = %d)\n", 1755 errno); 1756 } 1757 dm_handle_free(hanp, hlen); 1758 } 1759 } 1760 1761 /* 1762 * TEST : dm_set_eventlist - invalid token 1763 * EXPECTED: rc = -1, errno = EINVAL 1764 */ 1765 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 5)) { 1766 dm_sessid_t newsid; 1767 void *hanp; 1768 size_t hlen; 1769 dm_eventset_t eventset = minEvents; 1770 1771 /* Variation set up */ 1772 if ((rc = 1773 dm_create_session(DM_NO_SESSION, szSessionInfo, 1774 &newsid)) == -1) { 1775 /* No clean up */ 1776 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1777 == -1) { 1778 dm_destroy_session(newsid); 1779 } 1780 if (rc == -1) { 1781 DMLOG_PRINT(DMLVL_DEBUG, 1782 "Unable to set up variation! (errno = %d)\n", 1783 errno); 1784 DMVAR_SKIP(); 1785 } else { 1786 /* Variation */ 1787 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", 1788 szFuncName); 1789 rc = dm_set_eventlist(newsid, hanp, hlen, INVALID_ADDR, 1790 &eventset, DM_EVENT_MAX); 1791 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1792 1793 /* Variation clean up */ 1794 rc = dm_destroy_session(newsid); 1795 if (rc == -1) { 1796 DMLOG_PRINT(DMLVL_DEBUG, 1797 "Unable to clean up variation! (errno = %d)\n", 1798 errno); 1799 } 1800 dm_handle_free(hanp, hlen); 1801 } 1802 } 1803 1804 /* 1805 * TEST : dm_set_eventlist - invalid eventsetp 1806 * EXPECTED: rc = -1, errno = EFAULT 1807 */ 1808 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 6)) { 1809 dm_sessid_t newsid; 1810 void *hanp; 1811 size_t hlen; 1812 1813 /* Variation set up */ 1814 if ((rc = 1815 dm_create_session(DM_NO_SESSION, szSessionInfo, 1816 &newsid)) == -1) { 1817 /* No clean up */ 1818 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1819 == -1) { 1820 dm_destroy_session(newsid); 1821 } 1822 if (rc == -1) { 1823 DMLOG_PRINT(DMLVL_DEBUG, 1824 "Unable to set up variation! (errno = %d)\n", 1825 errno); 1826 DMVAR_SKIP(); 1827 } else { 1828 /* Variation */ 1829 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid eventsetp)\n", 1830 szFuncName); 1831 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 1832 (dm_eventset_t *) INVALID_ADDR, 1833 DM_EVENT_MAX); 1834 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1835 1836 /* Variation clean up */ 1837 rc = dm_destroy_session(newsid); 1838 if (rc == -1) { 1839 DMLOG_PRINT(DMLVL_DEBUG, 1840 "Unable to clean up variation! (errno = %d)\n", 1841 errno); 1842 } 1843 dm_handle_free(hanp, hlen); 1844 } 1845 } 1846 1847 /* 1848 * TEST : dm_set_eventlist - invalid maxevent 1849 * EXPECTED: rc = -1, errno = EINVAL 1850 */ 1851 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 7)) { 1852 dm_sessid_t newsid; 1853 void *hanp; 1854 size_t hlen; 1855 dm_eventset_t eventset = minEvents; 1856 1857 /* Variation set up */ 1858 if ((rc = 1859 dm_create_session(DM_NO_SESSION, szSessionInfo, 1860 &newsid)) == -1) { 1861 /* No clean up */ 1862 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1863 == -1) { 1864 dm_destroy_session(newsid); 1865 } 1866 if (rc == -1) { 1867 DMLOG_PRINT(DMLVL_DEBUG, 1868 "Unable to set up variation! (errno = %d)\n", 1869 errno); 1870 DMVAR_SKIP(); 1871 } else { 1872 /* Variation */ 1873 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid maxevent)\n", 1874 szFuncName); 1875 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 1876 &eventset, DM_EVENT_MAX + 1); 1877 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1878 1879 /* Variation clean up */ 1880 rc = dm_destroy_session(newsid); 1881 if (rc == -1) { 1882 DMLOG_PRINT(DMLVL_DEBUG, 1883 "Unable to clean up variation! (errno = %d)\n", 1884 errno); 1885 } 1886 dm_handle_free(hanp, hlen); 1887 } 1888 } 1889 1890 /* 1891 * TEST : dm_set_eventlist - maxevent < high set event 1892 * EXPECTED: rc = 0 1893 */ 1894 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 8)) { 1895 dm_sessid_t newsid; 1896 void *hanp; 1897 size_t hlen; 1898 dm_eventset_t eventset; 1899 u_int nelem; 1900 1901 /* Variation set up */ 1902 DMEV_ZERO(eventset); 1903 DMEV_SET(DM_EVENT_ATTRIBUTE, eventset); 1904 if ((rc = 1905 dm_create_session(DM_NO_SESSION, szSessionInfo, 1906 &newsid)) == -1) { 1907 /* No clean up */ 1908 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1909 == -1) { 1910 dm_destroy_session(newsid); 1911 } else 1912 if ((rc = 1913 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 1914 &eventset, DM_EVENT_MAX)) == -1) { 1915 dm_handle_free(hanp, hlen); 1916 dm_destroy_session(newsid); 1917 } 1918 if (rc == -1) { 1919 DMLOG_PRINT(DMLVL_DEBUG, 1920 "Unable to set up variation! (errno = %d)\n", 1921 errno); 1922 DMVAR_SKIP(); 1923 } else { 1924 /* Variation */ 1925 eventset = minEvents; 1926 DMLOG_PRINT(DMLVL_DEBUG, 1927 "%s(maxevent < high set event)\n", 1928 szFuncName); 1929 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 1930 &eventset, DM_EVENT_ATTRIBUTE); 1931 if (rc == 0) { 1932 if ((dm_get_eventlist 1933 (newsid, hanp, hlen, DM_NO_TOKEN, 1934 DM_EVENT_MAX, &eventset, &nelem) == 0) 1935 && (nelem == DM_EVENT_ATTRIBUTE + 1) 1936 && 1937 (DMEV_ISSET(DM_EVENT_ATTRIBUTE, eventset))) 1938 { 1939 DMLOG_PRINT(DMLVL_DEBUG, 1940 "%s passed with expected rc = %d\n", 1941 szFuncName, 0); 1942 DMVAR_PASS(); 1943 } else { 1944 DMLOG_PRINT(DMLVL_ERR, 1945 "%s failed with expected rc = %d but high set event cleared\n", 1946 szFuncName, 0); 1947 DMVAR_FAIL(); 1948 } 1949 } else { 1950 DMLOG_PRINT(DMLVL_ERR, 1951 "%s failed with unexpected rc = %d (errno = %d)\n", 1952 szFuncName, rc, errno); 1953 DMVAR_FAIL(); 1954 } 1955 1956 /* Variation clean up */ 1957 rc = dm_destroy_session(newsid); 1958 if (rc == -1) { 1959 DMLOG_PRINT(DMLVL_DEBUG, 1960 "Unable to clean up variation! (errno = %d)\n", 1961 errno); 1962 } 1963 dm_handle_free(hanp, hlen); 1964 } 1965 } 1966 1967 /* 1968 * TEST : dm_set_eventlist - maxevent > high set event 1969 * EXPECTED: rc = 0 1970 */ 1971 if (DMVAR_EXEC(SET_EVENTLIST_BASE + 9)) { 1972 dm_sessid_t newsid; 1973 void *hanp; 1974 size_t hlen; 1975 dm_eventset_t eventset; 1976 u_int nelem; 1977 1978 /* Variation set up */ 1979 DMEV_ZERO(eventset); 1980 DMEV_SET(DM_EVENT_ATTRIBUTE, eventset); 1981 if ((rc = 1982 dm_create_session(DM_NO_SESSION, szSessionInfo, 1983 &newsid)) == -1) { 1984 /* No clean up */ 1985 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 1986 == -1) { 1987 dm_destroy_session(newsid); 1988 } else 1989 if ((rc = 1990 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 1991 &eventset, DM_EVENT_MAX)) == -1) { 1992 dm_handle_free(hanp, hlen); 1993 dm_destroy_session(newsid); 1994 } 1995 if (rc == -1) { 1996 DMLOG_PRINT(DMLVL_DEBUG, 1997 "Unable to set up variation! (errno = %d)\n", 1998 errno); 1999 DMVAR_SKIP(); 2000 } else { 2001 /* Variation */ 2002 eventset = minEvents; 2003 DMLOG_PRINT(DMLVL_DEBUG, 2004 "%s(maxevent > high set event)\n", 2005 szFuncName); 2006 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2007 &eventset, DM_EVENT_MAX); 2008 if (rc == 0) { 2009 if ((dm_get_eventlist 2010 (newsid, hanp, hlen, DM_NO_TOKEN, 2011 DM_EVENT_MAX, &eventset, &nelem) == 0) 2012 && (nelem == DM_EVENT_UNMOUNT + 1) 2013 && 2014 (!DMEV_ISSET(DM_EVENT_ATTRIBUTE, eventset))) 2015 { 2016 DMLOG_PRINT(DMLVL_DEBUG, 2017 "%s passed with expected rc = %d\n", 2018 szFuncName, 0); 2019 DMVAR_PASS(); 2020 } else { 2021 DMLOG_PRINT(DMLVL_ERR, 2022 "%s failed with expected rc = %d but high set event still set\n", 2023 szFuncName, 0); 2024 DMVAR_FAIL(); 2025 } 2026 } else { 2027 DMLOG_PRINT(DMLVL_ERR, 2028 "%s failed with unexpected rc = %d (errno = %d)\n", 2029 szFuncName, rc, errno); 2030 DMVAR_FAIL(); 2031 } 2032 2033 /* Variation clean up */ 2034 rc = dm_destroy_session(newsid); 2035 if (rc == -1) { 2036 DMLOG_PRINT(DMLVL_DEBUG, 2037 "Unable to clean up variation! (errno = %d)\n", 2038 errno); 2039 } 2040 dm_handle_free(hanp, hlen); 2041 } 2042 } 2043 2044 /* 2045 * Global handle dm_set_eventlist variations 2046 * 2047 * This variation uncovered XFS BUG #15 (EBADF errno returned instead 2048 * of EINVAL) 2049 */ 2050 for (i = 0, varNum = SET_EVENTLIST_BASE + 10; i < DM_EVENT_MAX; 2051 i++, varNum++) { 2052 if (DMVAR_EXEC(varNum)) { 2053 dm_sessid_t newsid; 2054 dm_eventset_t eventset; 2055 2056 /* Variation set up */ 2057 DMEV_ZERO(eventset); 2058 DMEV_SET(i, eventset); 2059 rc = dm_create_session(DM_NO_SESSION, szSessionInfo, 2060 &newsid); 2061 if (rc == -1) { 2062 DMLOG_PRINT(DMLVL_DEBUG, 2063 "Unable to set up variation! (errno = %d)\n", 2064 errno); 2065 DMVAR_SKIP(); 2066 } else { 2067 /* Variation */ 2068 DMLOG_PRINT(DMLVL_DEBUG, 2069 "%s(global handle, %s)\n", 2070 szFuncName, 2071 dmimpl_validEvents[i].name); 2072 rc = dm_set_eventlist(newsid, DM_GLOBAL_HANP, 2073 DM_GLOBAL_HLEN, 2074 DM_NO_TOKEN, &eventset, 2075 DM_EVENT_MAX); 2076 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 2077 2078 /* Variation clean up */ 2079 rc = dm_destroy_session(newsid); 2080 if (rc == -1) { 2081 DMLOG_PRINT(DMLVL_DEBUG, 2082 "Unable to clean up variation! (errno = %d)\n", 2083 errno); 2084 } 2085 } 2086 } 2087 } 2088 2089 /* 2090 * File system handle dm_set_eventlist variations 2091 */ 2092 for (i = 0; i < DM_EVENT_MAX; i++, varNum++) { 2093 if (DMVAR_EXEC(varNum)) { 2094 dm_sessid_t newsid; 2095 void *hanp; 2096 size_t hlen; 2097 dm_eventset_t eventset; 2098 2099 /* Variation set up */ 2100 DMEV_ZERO(eventset); 2101 DMEV_SET(i, eventset); 2102 if ((rc = 2103 dm_create_session(DM_NO_SESSION, szSessionInfo, 2104 &newsid)) == -1) { 2105 /* No clean up */ 2106 } else 2107 if ((rc = 2108 dm_path_to_fshandle(DummyFile, &hanp, 2109 &hlen)) == -1) { 2110 dm_destroy_session(newsid); 2111 } 2112 if (rc == -1) { 2113 DMLOG_PRINT(DMLVL_DEBUG, 2114 "Unable to set up variation! (errno = %d)\n", 2115 errno); 2116 DMVAR_SKIP(); 2117 } else { 2118 /* Variation */ 2119 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle, %s)\n", 2120 szFuncName, 2121 dmimpl_validEvents[i].name); 2122 rc = dm_set_eventlist(newsid, hanp, hlen, 2123 DM_NO_TOKEN, &eventset, 2124 DM_EVENT_MAX); 2125 if (dmimpl_validEvents[i].bFSHandle) 2126 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 2127 else 2128 DMVAR_ENDFAILEXP(szFuncName, -1, rc, 2129 EINVAL); 2130 2131 /* Variation clean up */ 2132 rc = dm_destroy_session(newsid); 2133 if (rc == -1) { 2134 DMLOG_PRINT(DMLVL_DEBUG, 2135 "Unable to clean up variation! (errno = %d)\n", 2136 errno); 2137 } 2138 dm_handle_free(hanp, hlen); 2139 } 2140 } 2141 } 2142 2143 /* 2144 * Directory handle dm_set_eventlist variations 2145 */ 2146 for (i = 0; i < DM_EVENT_MAX; i++, varNum++) { 2147 if (DMVAR_EXEC(varNum)) { 2148 dm_sessid_t newsid; 2149 void *hanp; 2150 size_t hlen; 2151 dm_eventset_t eventset; 2152 2153 /* Variation set up */ 2154 DMEV_ZERO(eventset); 2155 DMEV_SET(i, eventset); 2156 if ((rc = 2157 dm_create_session(DM_NO_SESSION, szSessionInfo, 2158 &newsid)) == -1) { 2159 /* No clean up */ 2160 } else 2161 if ((rc = 2162 dm_path_to_handle(DummySubdir, &hanp, 2163 &hlen)) == -1) { 2164 dm_destroy_session(newsid); 2165 } 2166 if (rc == -1) { 2167 DMLOG_PRINT(DMLVL_DEBUG, 2168 "Unable to set up variation! (errno = %d)\n", 2169 errno); 2170 DMVAR_SKIP(); 2171 } else { 2172 /* Variation */ 2173 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle, %s)\n", 2174 szFuncName, 2175 dmimpl_validEvents[i].name); 2176 rc = dm_set_eventlist(newsid, hanp, hlen, 2177 DM_NO_TOKEN, &eventset, 2178 DM_EVENT_MAX); 2179 if (dmimpl_validEvents[i].bDirHandle) 2180 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 2181 else 2182 DMVAR_ENDFAILEXP(szFuncName, -1, rc, 2183 EINVAL); 2184 2185 /* Variation clean up */ 2186 rc = dm_destroy_session(newsid); 2187 if (rc == -1) { 2188 DMLOG_PRINT(DMLVL_DEBUG, 2189 "Unable to clean up variation! (errno = %d)\n", 2190 errno); 2191 } 2192 dm_handle_free(hanp, hlen); 2193 } 2194 } 2195 } 2196 2197 /* 2198 * File handle dm_set_eventlist variations 2199 */ 2200 for (i = 0; i < DM_EVENT_MAX; i++, varNum++) { 2201 if (DMVAR_EXEC(varNum)) { 2202 dm_sessid_t newsid; 2203 void *hanp; 2204 size_t hlen; 2205 dm_eventset_t eventset; 2206 2207 /* Variation set up */ 2208 DMEV_ZERO(eventset); 2209 DMEV_SET(i, eventset); 2210 if ((rc = 2211 dm_create_session(DM_NO_SESSION, szSessionInfo, 2212 &newsid)) == -1) { 2213 /* No clean up */ 2214 } else 2215 if ((rc = 2216 dm_path_to_handle(DummyFile, &hanp, 2217 &hlen)) == -1) { 2218 dm_destroy_session(newsid); 2219 } 2220 if (rc == -1) { 2221 DMLOG_PRINT(DMLVL_DEBUG, 2222 "Unable to set up variation! (errno = %d)\n", 2223 errno); 2224 DMVAR_SKIP(); 2225 } else { 2226 /* Variation */ 2227 DMLOG_PRINT(DMLVL_DEBUG, 2228 "%s(file handle, %s)\n", szFuncName, 2229 dmimpl_validEvents[i].name); 2230 rc = dm_set_eventlist(newsid, hanp, hlen, 2231 DM_NO_TOKEN, &eventset, 2232 DM_EVENT_MAX); 2233 if (dmimpl_validEvents[i].bFileHandle) 2234 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 2235 else 2236 DMVAR_ENDFAILEXP(szFuncName, -1, rc, 2237 EINVAL); 2238 2239 /* Variation clean up */ 2240 rc = dm_destroy_session(newsid); 2241 if (rc == -1) { 2242 DMLOG_PRINT(DMLVL_DEBUG, 2243 "Unable to clean up variation! (errno = %d)\n", 2244 errno); 2245 } 2246 dm_handle_free(hanp, hlen); 2247 } 2248 } 2249 } 2250 2251 szFuncName = "dm_get_eventlist"; 2252 2253 /* 2254 * TEST : dm_get_eventlist - DM_NO_SESSION sid 2255 * EXPECTED: rc = -1, errno = EINVAL 2256 */ 2257 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 1)) { 2258 dm_sessid_t newsid; 2259 void *hanp; 2260 size_t hlen; 2261 dm_eventset_t ineventset, outeventset; 2262 u_int nelem; 2263 2264 /* Variation set up */ 2265 DMEV_ZERO(ineventset); 2266 DMEV_ZERO(outeventset); 2267 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2268 if ((rc = 2269 dm_create_session(DM_NO_SESSION, szSessionInfo, 2270 &newsid)) == -1) { 2271 /* No clean up */ 2272 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2273 == -1) { 2274 dm_destroy_session(newsid); 2275 } else 2276 if ((rc = 2277 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2278 &ineventset, DM_EVENT_MAX)) == -1) { 2279 dm_handle_free(hanp, hlen); 2280 dm_destroy_session(newsid); 2281 } 2282 if (rc == -1) { 2283 DMLOG_PRINT(DMLVL_DEBUG, 2284 "Unable to set up variation! (errno = %d)\n", 2285 errno); 2286 DMVAR_SKIP(); 2287 } else { 2288 /* Variation */ 2289 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 2290 szFuncName); 2291 rc = dm_get_eventlist(DM_NO_SESSION, hanp, hlen, 2292 DM_NO_TOKEN, DM_EVENT_MAX, 2293 &outeventset, &nelem); 2294 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 2295 2296 /* Variation clean up */ 2297 DMEV_ZERO(ineventset); 2298 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2299 &ineventset, DM_EVENT_MAX); 2300 rc |= dm_destroy_session(newsid); 2301 if (rc == -1) { 2302 DMLOG_PRINT(DMLVL_DEBUG, 2303 "Unable to clean up variation! (errno = %d)\n", 2304 errno); 2305 } 2306 dm_handle_free(hanp, hlen); 2307 } 2308 } 2309 2310 /* 2311 * TEST : dm_get_eventlist - invalid sid 2312 * EXPECTED: rc = -1, errno = EINVAL 2313 */ 2314 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 2)) { 2315 dm_sessid_t newsid; 2316 void *hanp; 2317 size_t hlen; 2318 dm_eventset_t ineventset, outeventset; 2319 u_int nelem; 2320 2321 /* Variation set up */ 2322 DMEV_ZERO(ineventset); 2323 DMEV_ZERO(outeventset); 2324 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2325 if ((rc = 2326 dm_create_session(DM_NO_SESSION, szSessionInfo, 2327 &newsid)) == -1) { 2328 /* No clean up */ 2329 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2330 == -1) { 2331 dm_destroy_session(newsid); 2332 } else 2333 if ((rc = 2334 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2335 &ineventset, DM_EVENT_MAX)) == -1) { 2336 dm_handle_free(hanp, hlen); 2337 dm_destroy_session(newsid); 2338 } 2339 if (rc == -1) { 2340 DMLOG_PRINT(DMLVL_DEBUG, 2341 "Unable to set up variation! (errno = %d)\n", 2342 errno); 2343 DMVAR_SKIP(); 2344 } else { 2345 /* Variation */ 2346 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", 2347 szFuncName); 2348 rc = dm_get_eventlist(INVALID_ADDR, hanp, hlen, 2349 DM_NO_TOKEN, DM_EVENT_MAX, 2350 &outeventset, &nelem); 2351 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 2352 2353 /* Variation clean up */ 2354 DMEV_ZERO(ineventset); 2355 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2356 &ineventset, DM_EVENT_MAX); 2357 rc |= dm_destroy_session(newsid); 2358 if (rc == -1) { 2359 DMLOG_PRINT(DMLVL_DEBUG, 2360 "Unable to clean up variation! (errno = %d)\n", 2361 errno); 2362 } 2363 dm_handle_free(hanp, hlen); 2364 } 2365 } 2366 2367 /* 2368 * TEST : dm_get_eventlist - invalid hanp 2369 * EXPECTED: rc = -1, errno = EFAULT 2370 */ 2371 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 3)) { 2372 dm_sessid_t newsid; 2373 void *hanp; 2374 size_t hlen; 2375 dm_eventset_t ineventset, outeventset; 2376 u_int nelem; 2377 2378 /* Variation set up */ 2379 DMEV_ZERO(ineventset); 2380 DMEV_ZERO(outeventset); 2381 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2382 if ((rc = 2383 dm_create_session(DM_NO_SESSION, szSessionInfo, 2384 &newsid)) == -1) { 2385 /* No clean up */ 2386 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2387 == -1) { 2388 dm_destroy_session(newsid); 2389 } else 2390 if ((rc = 2391 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2392 &ineventset, DM_EVENT_MAX)) == -1) { 2393 dm_handle_free(hanp, hlen); 2394 dm_destroy_session(newsid); 2395 } 2396 if (rc == -1) { 2397 DMLOG_PRINT(DMLVL_DEBUG, 2398 "Unable to set up variation! (errno = %d)\n", 2399 errno); 2400 DMVAR_SKIP(); 2401 } else { 2402 /* Variation */ 2403 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n", 2404 szFuncName); 2405 rc = dm_get_eventlist(newsid, (void *)INVALID_ADDR, 2406 hlen, DM_NO_TOKEN, DM_EVENT_MAX, 2407 &outeventset, &nelem); 2408 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 2409 2410 /* Variation clean up */ 2411 DMEV_ZERO(ineventset); 2412 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2413 &ineventset, DM_EVENT_MAX); 2414 rc |= dm_destroy_session(newsid); 2415 if (rc == -1) { 2416 DMLOG_PRINT(DMLVL_DEBUG, 2417 "Unable to clean up variation! (errno = %d)\n", 2418 errno); 2419 } 2420 dm_handle_free(hanp, hlen); 2421 } 2422 } 2423 2424 /* 2425 * TEST : dm_get_eventlist - invalid hlen 2426 * EXPECTED: rc = -1, errno = EBADF 2427 */ 2428 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 4)) { 2429 dm_sessid_t newsid; 2430 void *hanp; 2431 size_t hlen; 2432 dm_eventset_t ineventset, outeventset; 2433 u_int nelem; 2434 2435 /* Variation set up */ 2436 DMEV_ZERO(ineventset); 2437 DMEV_ZERO(outeventset); 2438 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2439 if ((rc = 2440 dm_create_session(DM_NO_SESSION, szSessionInfo, 2441 &newsid)) == -1) { 2442 /* No clean up */ 2443 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2444 == -1) { 2445 dm_destroy_session(newsid); 2446 } else 2447 if ((rc = 2448 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2449 &ineventset, DM_EVENT_MAX)) == -1) { 2450 dm_handle_free(hanp, hlen); 2451 dm_destroy_session(newsid); 2452 } 2453 if (rc == -1) { 2454 DMLOG_PRINT(DMLVL_DEBUG, 2455 "Unable to set up variation! (errno = %d)\n", 2456 errno); 2457 DMVAR_SKIP(); 2458 } else { 2459 /* Variation */ 2460 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n", 2461 szFuncName); 2462 rc = dm_get_eventlist(newsid, hanp, INVALID_ADDR, 2463 DM_NO_TOKEN, DM_EVENT_MAX, 2464 &outeventset, &nelem); 2465 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 2466 2467 /* Variation clean up */ 2468 DMEV_ZERO(ineventset); 2469 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2470 &ineventset, DM_EVENT_MAX); 2471 rc |= dm_destroy_session(newsid); 2472 if (rc == -1) { 2473 DMLOG_PRINT(DMLVL_DEBUG, 2474 "Unable to clean up variation! (errno = %d)\n", 2475 errno); 2476 } 2477 dm_handle_free(hanp, hlen); 2478 } 2479 } 2480 2481 /* 2482 * TEST : dm_get_eventlist - invalid token 2483 * EXPECTED: rc = -1, errno = EINVAL 2484 */ 2485 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 5)) { 2486 dm_sessid_t newsid; 2487 void *hanp; 2488 size_t hlen; 2489 dm_eventset_t ineventset, outeventset; 2490 u_int nelem; 2491 2492 /* Variation set up */ 2493 DMEV_ZERO(ineventset); 2494 DMEV_ZERO(outeventset); 2495 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2496 if ((rc = 2497 dm_create_session(DM_NO_SESSION, szSessionInfo, 2498 &newsid)) == -1) { 2499 /* No clean up */ 2500 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2501 == -1) { 2502 dm_destroy_session(newsid); 2503 } else 2504 if ((rc = 2505 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2506 &ineventset, DM_EVENT_MAX)) == -1) { 2507 dm_handle_free(hanp, hlen); 2508 dm_destroy_session(newsid); 2509 } 2510 if (rc == -1) { 2511 DMLOG_PRINT(DMLVL_DEBUG, 2512 "Unable to set up variation! (errno = %d)\n", 2513 errno); 2514 DMVAR_SKIP(); 2515 } else { 2516 /* Variation */ 2517 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", 2518 szFuncName); 2519 rc = dm_get_eventlist(newsid, hanp, hlen, INVALID_ADDR, 2520 DM_EVENT_MAX, &outeventset, 2521 &nelem); 2522 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 2523 2524 /* Variation clean up */ 2525 DMEV_ZERO(ineventset); 2526 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2527 &ineventset, DM_EVENT_MAX); 2528 rc |= dm_destroy_session(newsid); 2529 if (rc == -1) { 2530 DMLOG_PRINT(DMLVL_DEBUG, 2531 "Unable to clean up variation! (errno = %d)\n", 2532 errno); 2533 } 2534 dm_handle_free(hanp, hlen); 2535 } 2536 } 2537 2538 /* 2539 * TEST : dm_get_eventlist - directory handle 2540 * EXPECTED: rc = -1, errno = EINVAL 2541 * 2542 * This variation uncovered XFS BUG #16 (0 returned instead of -1 and 2543 * errno EINVAL) 2544 */ 2545 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 6)) { 2546 dm_sessid_t newsid; 2547 void *hanp; 2548 size_t hlen; 2549 dm_eventset_t ineventset, outeventset; 2550 u_int nelem; 2551 2552 /* Variation set up */ 2553 DMEV_ZERO(ineventset); 2554 DMEV_ZERO(outeventset); 2555 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2556 if ((rc = 2557 dm_create_session(DM_NO_SESSION, szSessionInfo, 2558 &newsid)) == -1) { 2559 /* No clean up */ 2560 } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen)) 2561 == -1) { 2562 dm_destroy_session(newsid); 2563 } else 2564 if ((rc = 2565 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2566 &ineventset, DM_EVENT_MAX)) == -1) { 2567 dm_handle_free(hanp, hlen); 2568 dm_destroy_session(newsid); 2569 } 2570 if (rc == -1) { 2571 DMLOG_PRINT(DMLVL_DEBUG, 2572 "Unable to set up variation! (errno = %d)\n", 2573 errno); 2574 DMVAR_SKIP(); 2575 } else { 2576 /* Variation */ 2577 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n", 2578 szFuncName); 2579 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2580 DM_EVENT_MAX, &outeventset, 2581 &nelem); 2582 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 2583 2584 /* Variation clean up */ 2585 DMEV_ZERO(ineventset); 2586 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2587 &ineventset, DM_EVENT_MAX); 2588 rc |= dm_destroy_session(newsid); 2589 if (rc == -1) { 2590 DMLOG_PRINT(DMLVL_DEBUG, 2591 "Unable to clean up variation! (errno = %d)\n", 2592 errno); 2593 } 2594 dm_handle_free(hanp, hlen); 2595 } 2596 } 2597 2598 /* 2599 * TEST : dm_get_eventlist - invalid nelem, fs handle 2600 * EXPECTED: rc = -1, errno = E2BIG 2601 * 2602 * This variation uncovered XFS BUG #17 (EINVAL errno returned instead 2603 * of E2BIG, nelemp not updated) 2604 */ 2605 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 7)) { 2606 dm_sessid_t newsid; 2607 void *hanp; 2608 size_t hlen; 2609 dm_eventset_t ineventset, outeventset; 2610 u_int nelem; 2611 2612 /* Variation set up */ 2613 DMEV_ZERO(ineventset); 2614 DMEV_ZERO(outeventset); 2615 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2616 if ((rc = 2617 dm_create_session(DM_NO_SESSION, szSessionInfo, 2618 &newsid)) == -1) { 2619 /* No clean up */ 2620 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2621 == -1) { 2622 dm_destroy_session(newsid); 2623 } else 2624 if ((rc = 2625 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2626 &ineventset, DM_EVENT_MAX)) == -1) { 2627 dm_handle_free(hanp, hlen); 2628 dm_destroy_session(newsid); 2629 } 2630 if (rc == -1) { 2631 DMLOG_PRINT(DMLVL_DEBUG, 2632 "Unable to set up variation! (errno = %d)\n", 2633 errno); 2634 DMVAR_SKIP(); 2635 } else { 2636 /* Variation */ 2637 DMLOG_PRINT(DMLVL_DEBUG, 2638 "%s(invalid nelem, fs handle)\n", 2639 szFuncName); 2640 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2641 0, &outeventset, &nelem); 2642 if (rc == -1) { 2643 if (errno == E2BIG) { 2644 if (nelem == DM_EVENT_ATTRIBUTE + 1) { 2645 DMLOG_PRINT(DMLVL_DEBUG, 2646 "%s passed with expected rc = %d and expected errno = %d (nelem = %d)\n", 2647 szFuncName, rc, 2648 errno, nelem); 2649 DMVAR_PASS(); 2650 } else { 2651 DMLOG_PRINT(DMLVL_ERR, 2652 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 2653 szFuncName, rc, 2654 nelem, 2655 DM_EVENT_ATTRIBUTE + 2656 1); 2657 DMVAR_FAIL(); 2658 } 2659 } else { 2660 DMLOG_PRINT(DMLVL_ERR, 2661 "%s failed with expected rc = %d but unexpected errno = %d\n", 2662 szFuncName, rc, errno); 2663 DMVAR_FAIL(); 2664 } 2665 } else { 2666 DMLOG_PRINT(DMLVL_ERR, 2667 "%s failed with unexpected rc = %d\n", 2668 szFuncName, rc); 2669 DMVAR_FAIL(); 2670 } 2671 2672 /* Variation clean up */ 2673 DMEV_ZERO(ineventset); 2674 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2675 &ineventset, DM_EVENT_MAX); 2676 rc |= dm_destroy_session(newsid); 2677 if (rc == -1) { 2678 DMLOG_PRINT(DMLVL_DEBUG, 2679 "Unable to clean up variation! (errno = %d)\n", 2680 errno); 2681 } 2682 dm_handle_free(hanp, hlen); 2683 } 2684 } 2685 2686 /* 2687 * TEST : dm_get_eventlist - invalid nelem, file handle 2688 * EXPECTED: rc = -1, errno = E2BIG 2689 */ 2690 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 8)) { 2691 dm_sessid_t newsid; 2692 void *hanp; 2693 size_t hlen; 2694 dm_eventset_t ineventset, outeventset; 2695 u_int nelem; 2696 2697 /* Variation set up */ 2698 DMEV_ZERO(ineventset); 2699 DMEV_ZERO(outeventset); 2700 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2701 if ((rc = 2702 dm_create_session(DM_NO_SESSION, szSessionInfo, 2703 &newsid)) == -1) { 2704 /* No clean up */ 2705 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 2706 -1) { 2707 dm_destroy_session(newsid); 2708 } else 2709 if ((rc = 2710 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2711 &ineventset, DM_EVENT_MAX)) == -1) { 2712 dm_handle_free(hanp, hlen); 2713 dm_destroy_session(newsid); 2714 } 2715 if (rc == -1) { 2716 DMLOG_PRINT(DMLVL_DEBUG, 2717 "Unable to set up variation! (errno = %d)\n", 2718 errno); 2719 DMVAR_SKIP(); 2720 } else { 2721 /* Variation */ 2722 DMLOG_PRINT(DMLVL_DEBUG, 2723 "%s(invalid nelem, file handle)\n", 2724 szFuncName); 2725 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2726 0, &outeventset, &nelem); 2727 if (rc == -1) { 2728 if (errno == E2BIG) { 2729 if (nelem == DM_EVENT_ATTRIBUTE + 1) { 2730 DMLOG_PRINT(DMLVL_DEBUG, 2731 "%s passed with expected rc = %d and expected errno = %d (nelem = %d)\n", 2732 szFuncName, rc, 2733 errno, nelem); 2734 DMVAR_PASS(); 2735 } else { 2736 DMLOG_PRINT(DMLVL_ERR, 2737 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 2738 szFuncName, rc, 2739 nelem, 2740 DM_EVENT_ATTRIBUTE + 2741 1); 2742 DMVAR_FAIL(); 2743 } 2744 } else { 2745 DMLOG_PRINT(DMLVL_ERR, 2746 "%s failed with expected rc = %d but unexpected errno = %d\n", 2747 szFuncName, rc, errno); 2748 DMVAR_FAIL(); 2749 } 2750 } else { 2751 DMLOG_PRINT(DMLVL_ERR, 2752 "%s failed with unexpected rc = %d\n", 2753 szFuncName, rc); 2754 DMVAR_FAIL(); 2755 } 2756 2757 /* Variation clean up */ 2758 DMEV_ZERO(ineventset); 2759 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2760 &ineventset, DM_EVENT_MAX); 2761 rc |= dm_destroy_session(newsid); 2762 if (rc == -1) { 2763 DMLOG_PRINT(DMLVL_DEBUG, 2764 "Unable to clean up variation! (errno = %d)\n", 2765 errno); 2766 } 2767 dm_handle_free(hanp, hlen); 2768 } 2769 } 2770 2771 /* 2772 * TEST : dm_get_eventlist - invalid eventsetp 2773 * EXPECTED: rc = -1, errno = EFAULT 2774 */ 2775 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 9)) { 2776 dm_sessid_t newsid; 2777 void *hanp; 2778 size_t hlen; 2779 dm_eventset_t ineventset, outeventset; 2780 u_int nelem; 2781 2782 /* Variation set up */ 2783 DMEV_ZERO(ineventset); 2784 DMEV_ZERO(outeventset); 2785 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2786 if ((rc = 2787 dm_create_session(DM_NO_SESSION, szSessionInfo, 2788 &newsid)) == -1) { 2789 /* No clean up */ 2790 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2791 == -1) { 2792 dm_destroy_session(newsid); 2793 } else 2794 if ((rc = 2795 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2796 &ineventset, DM_EVENT_MAX)) == -1) { 2797 dm_handle_free(hanp, hlen); 2798 dm_destroy_session(newsid); 2799 } 2800 if (rc == -1) { 2801 DMLOG_PRINT(DMLVL_DEBUG, 2802 "Unable to set up variation! (errno = %d)\n", 2803 errno); 2804 DMVAR_SKIP(); 2805 } else { 2806 /* Variation */ 2807 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid eventsetp)\n", 2808 szFuncName); 2809 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2810 DM_EVENT_MAX, 2811 (dm_eventset_t *) INVALID_ADDR, 2812 &nelem); 2813 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 2814 2815 /* Variation clean up */ 2816 DMEV_ZERO(ineventset); 2817 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2818 &ineventset, DM_EVENT_MAX); 2819 rc |= dm_destroy_session(newsid); 2820 if (rc == -1) { 2821 DMLOG_PRINT(DMLVL_DEBUG, 2822 "Unable to clean up variation! (errno = %d)\n", 2823 errno); 2824 } 2825 dm_handle_free(hanp, hlen); 2826 } 2827 } 2828 2829 /* 2830 * TEST : dm_get_eventlist - invalid nelemp 2831 * EXPECTED: rc = -1, errno = EFAULT 2832 */ 2833 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 10)) { 2834 dm_sessid_t newsid; 2835 void *hanp; 2836 size_t hlen; 2837 dm_eventset_t ineventset, outeventset; 2838 2839 /* Variation set up */ 2840 DMEV_ZERO(ineventset); 2841 DMEV_ZERO(outeventset); 2842 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 2843 if ((rc = 2844 dm_create_session(DM_NO_SESSION, szSessionInfo, 2845 &newsid)) == -1) { 2846 /* No clean up */ 2847 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2848 == -1) { 2849 dm_destroy_session(newsid); 2850 } else 2851 if ((rc = 2852 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2853 &ineventset, DM_EVENT_MAX)) == -1) { 2854 dm_handle_free(hanp, hlen); 2855 dm_destroy_session(newsid); 2856 } 2857 if (rc == -1) { 2858 DMLOG_PRINT(DMLVL_DEBUG, 2859 "Unable to set up variation! (errno = %d)\n", 2860 errno); 2861 DMVAR_SKIP(); 2862 } else { 2863 /* Variation */ 2864 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid nelemp)\n", 2865 szFuncName); 2866 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2867 DM_EVENT_MAX, &outeventset, 2868 (u_int *) INVALID_ADDR); 2869 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 2870 2871 /* Variation clean up */ 2872 DMEV_ZERO(ineventset); 2873 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2874 &ineventset, DM_EVENT_MAX); 2875 rc |= dm_destroy_session(newsid); 2876 if (rc == -1) { 2877 DMLOG_PRINT(DMLVL_DEBUG, 2878 "Unable to clean up variation! (errno = %d)\n", 2879 errno); 2880 } 2881 dm_handle_free(hanp, hlen); 2882 } 2883 } 2884 2885 /* 2886 * TEST : dm_get_eventlist - zero event, fs handle 2887 * EXPECTED: rc = 0 2888 */ 2889 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 11)) { 2890 dm_sessid_t newsid; 2891 void *hanp; 2892 size_t hlen; 2893 dm_eventset_t ineventset, outeventset; 2894 u_int nelem; 2895 2896 /* Variation set up */ 2897 DMEV_ZERO(ineventset); 2898 DMEV_ZERO(outeventset); 2899 if ((rc = 2900 dm_create_session(DM_NO_SESSION, szSessionInfo, 2901 &newsid)) == -1) { 2902 /* No clean up */ 2903 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 2904 == -1) { 2905 dm_destroy_session(newsid); 2906 } 2907 if (rc == -1) { 2908 DMLOG_PRINT(DMLVL_DEBUG, 2909 "Unable to set up variation! (errno = %d)\n", 2910 errno); 2911 DMVAR_SKIP(); 2912 } else { 2913 /* Variation */ 2914 DMLOG_PRINT(DMLVL_DEBUG, "%s(zero event, fs handle)\n", 2915 szFuncName); 2916 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2917 DM_EVENT_MAX, &outeventset, 2918 &nelem); 2919 if (rc == 0) { 2920 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 2921 if (nelem == 0) { 2922 if (memcmp 2923 (&ineventset, &outeventset, 2924 sizeof(dm_eventset_t)) == 0) { 2925 DMLOG_PRINT(DMLVL_DEBUG, 2926 "%s passed with expected rc = %d\n", 2927 szFuncName, 0); 2928 DMVAR_PASS(); 2929 } else { 2930 DMLOG_PRINT(DMLVL_ERR, 2931 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 2932 szFuncName, 0, 2933 ineventset, 2934 outeventset); 2935 DMVAR_FAIL(); 2936 } 2937 } else { 2938 DMLOG_PRINT(DMLVL_ERR, 2939 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 2940 szFuncName, 0, nelem, 0); 2941 DMVAR_FAIL(); 2942 } 2943 } else { 2944 DMLOG_PRINT(DMLVL_ERR, 2945 "%s failed with unexpected rc = %d (errno = %d)\n", 2946 szFuncName, rc, errno); 2947 DMVAR_FAIL(); 2948 } 2949 2950 /* Variation clean up */ 2951 rc = dm_destroy_session(newsid); 2952 if (rc == -1) { 2953 DMLOG_PRINT(DMLVL_DEBUG, 2954 "Unable to clean up variation! (errno = %d)\n", 2955 errno); 2956 } 2957 dm_handle_free(hanp, hlen); 2958 } 2959 } 2960 2961 /* 2962 * TEST : dm_get_eventlist - zero event, file handle 2963 * EXPECTED: rc = 0 2964 */ 2965 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 12)) { 2966 dm_sessid_t newsid; 2967 void *hanp; 2968 size_t hlen; 2969 dm_eventset_t ineventset, outeventset; 2970 u_int nelem; 2971 2972 /* Variation set up */ 2973 DMEV_ZERO(ineventset); 2974 DMEV_ZERO(outeventset); 2975 if ((rc = 2976 dm_create_session(DM_NO_SESSION, szSessionInfo, 2977 &newsid)) == -1) { 2978 /* No clean up */ 2979 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 2980 -1) { 2981 dm_destroy_session(newsid); 2982 } 2983 if (rc == -1) { 2984 DMLOG_PRINT(DMLVL_DEBUG, 2985 "Unable to set up variation! (errno = %d)\n", 2986 errno); 2987 DMVAR_SKIP(); 2988 } else { 2989 /* Variation */ 2990 DMLOG_PRINT(DMLVL_DEBUG, 2991 "%s(zero event, file handle)\n", 2992 szFuncName); 2993 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 2994 DM_EVENT_MAX, &outeventset, 2995 &nelem); 2996 if (rc == 0) { 2997 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 2998 if (nelem == 0) { 2999 if (memcmp 3000 (&ineventset, &outeventset, 3001 sizeof(dm_eventset_t)) == 0) { 3002 DMLOG_PRINT(DMLVL_DEBUG, 3003 "%s passed with expected rc = %d\n", 3004 szFuncName, 0); 3005 DMVAR_PASS(); 3006 } else { 3007 DMLOG_PRINT(DMLVL_ERR, 3008 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3009 szFuncName, 0, 3010 ineventset, 3011 outeventset); 3012 DMVAR_FAIL(); 3013 } 3014 } else { 3015 DMLOG_PRINT(DMLVL_ERR, 3016 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3017 szFuncName, 0, nelem, 0); 3018 DMVAR_FAIL(); 3019 } 3020 } else { 3021 DMLOG_PRINT(DMLVL_ERR, 3022 "%s failed with unexpected rc = %d (errno = %d)\n", 3023 szFuncName, rc, errno); 3024 DMVAR_FAIL(); 3025 } 3026 3027 /* Variation clean up */ 3028 rc = dm_destroy_session(newsid); 3029 if (rc == -1) { 3030 DMLOG_PRINT(DMLVL_DEBUG, 3031 "Unable to clean up variation! (errno = %d)\n", 3032 errno); 3033 } 3034 dm_handle_free(hanp, hlen); 3035 } 3036 } 3037 3038 /* 3039 * TEST : dm_get_eventlist - one event, fs handle 3040 * EXPECTED: rc = 0 3041 */ 3042 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 13)) { 3043 dm_sessid_t newsid; 3044 void *hanp; 3045 size_t hlen; 3046 dm_eventset_t ineventset, outeventset; 3047 u_int nelem; 3048 3049 /* Variation set up */ 3050 DMEV_ZERO(ineventset); 3051 DMEV_ZERO(outeventset); 3052 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 3053 if ((rc = 3054 dm_create_session(DM_NO_SESSION, szSessionInfo, 3055 &newsid)) == -1) { 3056 /* No clean up */ 3057 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 3058 == -1) { 3059 dm_destroy_session(newsid); 3060 } else 3061 if ((rc = 3062 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3063 &ineventset, DM_EVENT_MAX)) == -1) { 3064 dm_handle_free(hanp, hlen); 3065 dm_destroy_session(newsid); 3066 } 3067 if (rc == -1) { 3068 DMLOG_PRINT(DMLVL_DEBUG, 3069 "Unable to set up variation! (errno = %d)\n", 3070 errno); 3071 DMVAR_SKIP(); 3072 } else { 3073 /* Variation */ 3074 DMLOG_PRINT(DMLVL_DEBUG, "%s(one event, fs handle)\n", 3075 szFuncName); 3076 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3077 DM_EVENT_MAX, &outeventset, 3078 &nelem); 3079 if (rc == 0) { 3080 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3081 if (nelem == DM_EVENT_ATTRIBUTE + 1) { 3082 if (memcmp 3083 (&ineventset, &outeventset, 3084 sizeof(dm_eventset_t)) == 0) { 3085 DMLOG_PRINT(DMLVL_DEBUG, 3086 "%s passed with expected rc = %d\n", 3087 szFuncName, 0); 3088 DMVAR_PASS(); 3089 } else { 3090 DMLOG_PRINT(DMLVL_ERR, 3091 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3092 szFuncName, 0, 3093 ineventset, 3094 outeventset); 3095 DMVAR_FAIL(); 3096 } 3097 } else { 3098 DMLOG_PRINT(DMLVL_ERR, 3099 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3100 szFuncName, 0, nelem, 3101 DM_EVENT_ATTRIBUTE + 1); 3102 DMVAR_FAIL(); 3103 } 3104 } else { 3105 DMLOG_PRINT(DMLVL_ERR, 3106 "%s failed with unexpected rc = %d (errno = %d)\n", 3107 szFuncName, rc, errno); 3108 DMVAR_FAIL(); 3109 } 3110 3111 /* Variation clean up */ 3112 DMEV_ZERO(ineventset); 3113 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3114 &ineventset, DM_EVENT_MAX); 3115 rc |= dm_destroy_session(newsid); 3116 if (rc == -1) { 3117 DMLOG_PRINT(DMLVL_DEBUG, 3118 "Unable to clean up variation! (errno = %d)\n", 3119 errno); 3120 } 3121 dm_handle_free(hanp, hlen); 3122 } 3123 } 3124 3125 /* 3126 * TEST : dm_get_eventlist - one event, file handle 3127 * EXPECTED: rc = 0 3128 */ 3129 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 14)) { 3130 dm_sessid_t newsid; 3131 void *hanp; 3132 size_t hlen; 3133 dm_eventset_t ineventset, outeventset; 3134 u_int nelem; 3135 3136 /* Variation set up */ 3137 DMEV_ZERO(ineventset); 3138 DMEV_ZERO(outeventset); 3139 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 3140 if ((rc = 3141 dm_create_session(DM_NO_SESSION, szSessionInfo, 3142 &newsid)) == -1) { 3143 /* No clean up */ 3144 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 3145 -1) { 3146 dm_destroy_session(newsid); 3147 } else 3148 if ((rc = 3149 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3150 &ineventset, DM_EVENT_MAX)) == -1) { 3151 dm_handle_free(hanp, hlen); 3152 dm_destroy_session(newsid); 3153 } 3154 if (rc == -1) { 3155 DMLOG_PRINT(DMLVL_DEBUG, 3156 "Unable to set up variation! (errno = %d)\n", 3157 errno); 3158 DMVAR_SKIP(); 3159 } else { 3160 /* Variation */ 3161 DMLOG_PRINT(DMLVL_DEBUG, "%s(one event, file handle)\n", 3162 szFuncName); 3163 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3164 DM_EVENT_MAX, &outeventset, 3165 &nelem); 3166 if (rc == 0) { 3167 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3168 if (nelem == DM_EVENT_ATTRIBUTE + 1) { 3169 if (memcmp 3170 (&ineventset, &outeventset, 3171 sizeof(dm_eventset_t)) == 0) { 3172 DMLOG_PRINT(DMLVL_DEBUG, 3173 "%s passed with expected rc = %d\n", 3174 szFuncName, 0); 3175 DMVAR_PASS(); 3176 } else { 3177 DMLOG_PRINT(DMLVL_ERR, 3178 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3179 szFuncName, 0, 3180 ineventset, 3181 outeventset); 3182 DMVAR_FAIL(); 3183 } 3184 } else { 3185 DMLOG_PRINT(DMLVL_ERR, 3186 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3187 szFuncName, 0, nelem, 3188 DM_EVENT_ATTRIBUTE + 1); 3189 DMVAR_FAIL(); 3190 } 3191 } else { 3192 DMLOG_PRINT(DMLVL_ERR, 3193 "%s failed with unexpected rc = %d (errno = %d)\n", 3194 szFuncName, rc, errno); 3195 DMVAR_FAIL(); 3196 } 3197 3198 /* Variation clean up */ 3199 DMEV_ZERO(ineventset); 3200 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3201 &ineventset, DM_EVENT_MAX); 3202 rc |= dm_destroy_session(newsid); 3203 if (rc == -1) { 3204 DMLOG_PRINT(DMLVL_DEBUG, 3205 "Unable to clean up variation! (errno = %d)\n", 3206 errno); 3207 } 3208 dm_handle_free(hanp, hlen); 3209 } 3210 } 3211 3212 /* 3213 * TEST : dm_get_eventlist - multi event, fs handle 3214 * EXPECTED: rc = 0 3215 */ 3216 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 15)) { 3217 dm_sessid_t newsid; 3218 void *hanp; 3219 size_t hlen; 3220 dm_eventset_t ineventset, outeventset; 3221 u_int nelem; 3222 3223 /* Variation set up */ 3224 DMEV_ZERO(ineventset); 3225 DMEV_ZERO(outeventset); 3226 DMEV_SET(DM_EVENT_CLOSE, ineventset); 3227 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 3228 DMEV_SET(DM_EVENT_DESTROY, ineventset); 3229 if ((rc = 3230 dm_create_session(DM_NO_SESSION, szSessionInfo, 3231 &newsid)) == -1) { 3232 /* No clean up */ 3233 } else if ((rc = dm_path_to_fshandle(DummyFile, &hanp, &hlen)) 3234 == -1) { 3235 dm_destroy_session(newsid); 3236 } else 3237 if ((rc = 3238 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3239 &ineventset, DM_EVENT_MAX)) == -1) { 3240 dm_handle_free(hanp, hlen); 3241 dm_destroy_session(newsid); 3242 } 3243 if (rc == -1) { 3244 DMLOG_PRINT(DMLVL_DEBUG, 3245 "Unable to set up variation! (errno = %d)\n", 3246 errno); 3247 DMVAR_SKIP(); 3248 } else { 3249 /* Variation */ 3250 DMLOG_PRINT(DMLVL_DEBUG, "%s(multi event, fs handle)\n", 3251 szFuncName); 3252 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3253 DM_EVENT_MAX, &outeventset, 3254 &nelem); 3255 if (rc == 0) { 3256 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3257 if (nelem == DM_EVENT_DESTROY + 1) { 3258 if (memcmp 3259 (&ineventset, &outeventset, 3260 sizeof(dm_eventset_t)) == 0) { 3261 DMLOG_PRINT(DMLVL_DEBUG, 3262 "%s passed with expected rc = %d\n", 3263 szFuncName, 0); 3264 DMVAR_PASS(); 3265 } else { 3266 DMLOG_PRINT(DMLVL_ERR, 3267 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3268 szFuncName, 0, 3269 ineventset, 3270 outeventset); 3271 DMVAR_FAIL(); 3272 } 3273 } else { 3274 DMLOG_PRINT(DMLVL_ERR, 3275 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3276 szFuncName, 0, nelem, 3277 DM_EVENT_DESTROY + 1); 3278 DMVAR_FAIL(); 3279 } 3280 } else { 3281 DMLOG_PRINT(DMLVL_ERR, 3282 "%s failed with unexpected rc = %d (errno = %d)\n", 3283 szFuncName, rc, errno); 3284 DMVAR_FAIL(); 3285 } 3286 3287 /* Variation clean up */ 3288 DMEV_ZERO(ineventset); 3289 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3290 &ineventset, DM_EVENT_MAX); 3291 rc |= dm_destroy_session(newsid); 3292 if (rc == -1) { 3293 DMLOG_PRINT(DMLVL_DEBUG, 3294 "Unable to clean up variation! (errno = %d)\n", 3295 errno); 3296 } 3297 dm_handle_free(hanp, hlen); 3298 } 3299 } 3300 3301 /* 3302 * TEST : dm_get_eventlist - multi event, file handle 3303 * EXPECTED: rc = 0 3304 */ 3305 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 16)) { 3306 dm_sessid_t newsid; 3307 void *hanp; 3308 size_t hlen; 3309 dm_eventset_t ineventset, outeventset; 3310 u_int nelem; 3311 3312 /* Variation set up */ 3313 DMEV_ZERO(ineventset); 3314 DMEV_ZERO(outeventset); 3315 DMEV_SET(DM_EVENT_CLOSE, ineventset); 3316 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 3317 DMEV_SET(DM_EVENT_DESTROY, ineventset); 3318 if ((rc = 3319 dm_create_session(DM_NO_SESSION, szSessionInfo, 3320 &newsid)) == -1) { 3321 /* No clean up */ 3322 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 3323 -1) { 3324 dm_destroy_session(newsid); 3325 } else 3326 if ((rc = 3327 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3328 &ineventset, DM_EVENT_MAX)) == -1) { 3329 dm_handle_free(hanp, hlen); 3330 dm_destroy_session(newsid); 3331 } 3332 if (rc == -1) { 3333 DMLOG_PRINT(DMLVL_DEBUG, 3334 "Unable to set up variation! (errno = %d)\n", 3335 errno); 3336 DMVAR_SKIP(); 3337 } else { 3338 /* Variation */ 3339 DMLOG_PRINT(DMLVL_DEBUG, 3340 "%s(multi event, file handle)\n", 3341 szFuncName); 3342 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3343 DM_EVENT_MAX, &outeventset, 3344 &nelem); 3345 if (rc == 0) { 3346 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3347 if (nelem == DM_EVENT_DESTROY + 1) { 3348 if (memcmp 3349 (&ineventset, &outeventset, 3350 sizeof(dm_eventset_t)) == 0) { 3351 DMLOG_PRINT(DMLVL_DEBUG, 3352 "%s passed with expected rc = %d\n", 3353 szFuncName, 0); 3354 DMVAR_PASS(); 3355 } else { 3356 DMLOG_PRINT(DMLVL_ERR, 3357 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3358 szFuncName, 0, 3359 ineventset, 3360 outeventset); 3361 DMVAR_FAIL(); 3362 } 3363 } else { 3364 DMLOG_PRINT(DMLVL_ERR, 3365 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3366 szFuncName, 0, nelem, 3367 DM_EVENT_DESTROY + 1); 3368 DMVAR_FAIL(); 3369 } 3370 } else { 3371 DMLOG_PRINT(DMLVL_ERR, 3372 "%s failed with unexpected rc = %d (errno = %d)\n", 3373 szFuncName, rc, errno); 3374 DMVAR_FAIL(); 3375 } 3376 3377 /* Variation clean up */ 3378 DMEV_ZERO(ineventset); 3379 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3380 &ineventset, DM_EVENT_MAX); 3381 rc |= dm_destroy_session(newsid); 3382 if (rc == -1) { 3383 DMLOG_PRINT(DMLVL_DEBUG, 3384 "Unable to clean up variation! (errno = %d)\n", 3385 errno); 3386 } 3387 dm_handle_free(hanp, hlen); 3388 } 3389 } 3390 3391 /* 3392 * TEST : dm_get_eventlist - read event 3393 * EXPECTED: rc = 0 3394 */ 3395 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 17)) { 3396 dm_sessid_t newsid; 3397 void *hanp; 3398 size_t hlen; 3399 dm_eventset_t ineventset, outeventset; 3400 u_int nelem; 3401 dm_region_t region = { 0, 0, DM_REGION_READ }; 3402 dm_boolean_t exactflag; 3403 3404 /* Variation set up */ 3405 DMEV_ZERO(ineventset); 3406 DMEV_ZERO(outeventset); 3407 DMEV_SET(DM_EVENT_READ, ineventset); 3408 if ((rc = 3409 dm_create_session(DM_NO_SESSION, szSessionInfo, 3410 &newsid)) == -1) { 3411 /* No clean up */ 3412 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 3413 -1) { 3414 dm_destroy_session(newsid); 3415 } else 3416 if ((rc = 3417 dm_set_region(newsid, hanp, hlen, DM_NO_TOKEN, 1, 3418 ®ion, &exactflag)) == -1) { 3419 dm_handle_free(hanp, hlen); 3420 dm_destroy_session(newsid); 3421 } 3422 if (rc == -1) { 3423 DMLOG_PRINT(DMLVL_DEBUG, 3424 "Unable to set up variation! (errno = %d)\n", 3425 errno); 3426 DMVAR_SKIP(); 3427 } else { 3428 /* Variation */ 3429 DMLOG_PRINT(DMLVL_DEBUG, "%s(read event)\n", 3430 szFuncName); 3431 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3432 DM_EVENT_MAX, &outeventset, 3433 &nelem); 3434 if (rc == 0) { 3435 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3436 if (nelem == DM_EVENT_READ + 1) { 3437 if (memcmp 3438 (&ineventset, &outeventset, 3439 sizeof(dm_eventset_t)) == 0) { 3440 DMLOG_PRINT(DMLVL_DEBUG, 3441 "%s passed with expected rc = %d\n", 3442 szFuncName, 0); 3443 DMVAR_PASS(); 3444 } else { 3445 DMLOG_PRINT(DMLVL_ERR, 3446 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3447 szFuncName, 0, 3448 ineventset, 3449 outeventset); 3450 DMVAR_FAIL(); 3451 } 3452 } else { 3453 DMLOG_PRINT(DMLVL_ERR, 3454 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3455 szFuncName, 0, nelem, 3456 DM_EVENT_READ + 1); 3457 DMVAR_FAIL(); 3458 } 3459 } else { 3460 DMLOG_PRINT(DMLVL_ERR, 3461 "%s failed with unexpected rc = %d (errno = %d)\n", 3462 szFuncName, rc, errno); 3463 DMVAR_FAIL(); 3464 } 3465 3466 /* Variation clean up */ 3467 DMEV_ZERO(ineventset); 3468 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3469 &ineventset, DM_EVENT_MAX); 3470 rc |= dm_destroy_session(newsid); 3471 if (rc == -1) { 3472 DMLOG_PRINT(DMLVL_DEBUG, 3473 "Unable to clean up variation! (errno = %d)\n", 3474 errno); 3475 } 3476 dm_handle_free(hanp, hlen); 3477 } 3478 } 3479 3480 /* 3481 * TEST : dm_get_eventlist - write event 3482 * EXPECTED: rc = 0 3483 */ 3484 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 18)) { 3485 dm_sessid_t newsid; 3486 void *hanp; 3487 size_t hlen; 3488 dm_eventset_t ineventset, outeventset; 3489 u_int nelem; 3490 dm_region_t region = { 0, 10, DM_REGION_WRITE }; 3491 dm_boolean_t exactflag; 3492 3493 /* Variation set up */ 3494 DMEV_ZERO(ineventset); 3495 DMEV_ZERO(outeventset); 3496 DMEV_SET(DM_EVENT_WRITE, ineventset); 3497 if ((rc = 3498 dm_create_session(DM_NO_SESSION, szSessionInfo, 3499 &newsid)) == -1) { 3500 /* No clean up */ 3501 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 3502 -1) { 3503 dm_destroy_session(newsid); 3504 } else 3505 if ((rc = 3506 dm_set_region(newsid, hanp, hlen, DM_NO_TOKEN, 1, 3507 ®ion, &exactflag)) == -1) { 3508 dm_handle_free(hanp, hlen); 3509 dm_destroy_session(newsid); 3510 } 3511 if (rc == -1) { 3512 DMLOG_PRINT(DMLVL_DEBUG, 3513 "Unable to set up variation! (errno = %d)\n", 3514 errno); 3515 DMVAR_SKIP(); 3516 } else { 3517 /* Variation */ 3518 DMLOG_PRINT(DMLVL_DEBUG, "%s(write event)\n", 3519 szFuncName); 3520 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3521 DM_EVENT_MAX, &outeventset, 3522 &nelem); 3523 if (rc == 0) { 3524 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3525 if (nelem == DM_EVENT_WRITE + 1) { 3526 if (memcmp 3527 (&ineventset, &outeventset, 3528 sizeof(dm_eventset_t)) == 0) { 3529 DMLOG_PRINT(DMLVL_DEBUG, 3530 "%s passed with expected rc = %d\n", 3531 szFuncName, 0); 3532 DMVAR_PASS(); 3533 } else { 3534 DMLOG_PRINT(DMLVL_ERR, 3535 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3536 szFuncName, 0, 3537 ineventset, 3538 outeventset); 3539 DMVAR_FAIL(); 3540 } 3541 } else { 3542 DMLOG_PRINT(DMLVL_ERR, 3543 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3544 szFuncName, 0, nelem, 3545 DM_EVENT_WRITE + 1); 3546 DMVAR_FAIL(); 3547 } 3548 } else { 3549 DMLOG_PRINT(DMLVL_ERR, 3550 "%s failed with unexpected rc = %d (errno = %d)\n", 3551 szFuncName, rc, errno); 3552 DMVAR_FAIL(); 3553 } 3554 3555 /* Variation clean up */ 3556 DMEV_ZERO(ineventset); 3557 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3558 &ineventset, DM_EVENT_MAX); 3559 rc |= dm_destroy_session(newsid); 3560 if (rc == -1) { 3561 DMLOG_PRINT(DMLVL_DEBUG, 3562 "Unable to clean up variation! (errno = %d)\n", 3563 errno); 3564 } 3565 dm_handle_free(hanp, hlen); 3566 } 3567 } 3568 3569 /* 3570 * TEST : dm_get_eventlist - truncate event 3571 * EXPECTED: rc = 0 3572 */ 3573 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 19)) { 3574 dm_sessid_t newsid; 3575 void *hanp; 3576 size_t hlen; 3577 dm_eventset_t ineventset, outeventset; 3578 u_int nelem; 3579 dm_region_t region = 3580 { TMP_FILELEN - 10, 0, DM_REGION_TRUNCATE }; 3581 dm_boolean_t exactflag; 3582 3583 /* Variation set up */ 3584 DMEV_ZERO(ineventset); 3585 DMEV_ZERO(outeventset); 3586 DMEV_SET(DM_EVENT_TRUNCATE, ineventset); 3587 if ((rc = 3588 dm_create_session(DM_NO_SESSION, szSessionInfo, 3589 &newsid)) == -1) { 3590 /* No clean up */ 3591 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 3592 -1) { 3593 dm_destroy_session(newsid); 3594 } else 3595 if ((rc = 3596 dm_set_region(newsid, hanp, hlen, DM_NO_TOKEN, 1, 3597 ®ion, &exactflag)) == -1) { 3598 dm_handle_free(hanp, hlen); 3599 dm_destroy_session(newsid); 3600 } 3601 if (rc == -1) { 3602 DMLOG_PRINT(DMLVL_DEBUG, 3603 "Unable to set up variation! (errno = %d)\n", 3604 errno); 3605 DMVAR_SKIP(); 3606 } else { 3607 /* Variation */ 3608 DMLOG_PRINT(DMLVL_DEBUG, "%s(truncate event)\n", 3609 szFuncName); 3610 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3611 DM_EVENT_MAX, &outeventset, 3612 &nelem); 3613 if (rc == 0) { 3614 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3615 if (nelem == DM_EVENT_TRUNCATE + 1) { 3616 if (memcmp 3617 (&ineventset, &outeventset, 3618 sizeof(dm_eventset_t)) == 0) { 3619 DMLOG_PRINT(DMLVL_DEBUG, 3620 "%s passed with expected rc = %d\n", 3621 szFuncName, 0); 3622 DMVAR_PASS(); 3623 } else { 3624 DMLOG_PRINT(DMLVL_ERR, 3625 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3626 szFuncName, 0, 3627 ineventset, 3628 outeventset); 3629 DMVAR_FAIL(); 3630 } 3631 } else { 3632 DMLOG_PRINT(DMLVL_ERR, 3633 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3634 szFuncName, 0, nelem, 3635 DM_EVENT_TRUNCATE + 1); 3636 DMVAR_FAIL(); 3637 } 3638 } else { 3639 DMLOG_PRINT(DMLVL_ERR, 3640 "%s failed with unexpected rc = %d (errno = %d)\n", 3641 szFuncName, rc, errno); 3642 DMVAR_FAIL(); 3643 } 3644 3645 /* Variation clean up */ 3646 DMEV_ZERO(ineventset); 3647 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3648 &ineventset, DM_EVENT_MAX); 3649 rc |= dm_destroy_session(newsid); 3650 if (rc == -1) { 3651 DMLOG_PRINT(DMLVL_DEBUG, 3652 "Unable to clean up variation! (errno = %d)\n", 3653 errno); 3654 } 3655 dm_handle_free(hanp, hlen); 3656 } 3657 } 3658 3659 /* 3660 * TEST : dm_get_eventlist - event union, file handle 3661 * EXPECTED: rc = 0 3662 */ 3663 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 20)) { 3664 dm_sessid_t newsid; 3665 void *hanp; 3666 size_t hlen; 3667 dm_eventset_t ineventset, outeventset; 3668 u_int nelem; 3669 dm_region_t region = 3670 { TMP_FILELEN - 10, 0, DM_REGION_TRUNCATE }; 3671 dm_boolean_t exactflag; 3672 3673 /* Variation set up */ 3674 DMEV_ZERO(ineventset); 3675 DMEV_ZERO(outeventset); 3676 DMEV_SET(DM_EVENT_CLOSE, ineventset); 3677 DMEV_SET(DM_EVENT_ATTRIBUTE, ineventset); 3678 DMEV_SET(DM_EVENT_DESTROY, ineventset); 3679 if ((rc = 3680 dm_create_session(DM_NO_SESSION, szSessionInfo, 3681 &newsid)) == -1) { 3682 /* No clean up */ 3683 } else if ((rc = dm_path_to_handle(DummyFile, &hanp, &hlen)) == 3684 -1) { 3685 dm_destroy_session(newsid); 3686 } else 3687 if (((rc = 3688 dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3689 &ineventset, DM_EVENT_MAX)) == -1) 3690 || 3691 ((rc = 3692 dm_set_region(newsid, hanp, hlen, DM_NO_TOKEN, 1, 3693 ®ion, &exactflag)) == -1)) { 3694 dm_handle_free(hanp, hlen); 3695 dm_destroy_session(newsid); 3696 } 3697 if (rc == -1) { 3698 DMLOG_PRINT(DMLVL_DEBUG, 3699 "Unable to set up variation! (errno = %d)\n", 3700 errno); 3701 DMVAR_SKIP(); 3702 } else { 3703 /* Variation */ 3704 DMLOG_PRINT(DMLVL_DEBUG, 3705 "%s(event union, file handle)\n", 3706 szFuncName); 3707 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3708 DM_EVENT_MAX, &outeventset, 3709 &nelem); 3710 if (rc == 0) { 3711 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem); 3712 if (nelem == DM_EVENT_DESTROY + 1) { 3713 DMEV_SET(DM_EVENT_TRUNCATE, ineventset); 3714 if (memcmp 3715 (&ineventset, &outeventset, 3716 sizeof(dm_eventset_t)) == 0) { 3717 DMLOG_PRINT(DMLVL_DEBUG, 3718 "%s passed with expected rc = %d\n", 3719 szFuncName, 0); 3720 DMVAR_PASS(); 3721 } else { 3722 DMLOG_PRINT(DMLVL_ERR, 3723 "%s failed with expected rc = %d but eventsets not same (%llx vs %llx)\n", 3724 szFuncName, 0, 3725 ineventset, 3726 outeventset); 3727 DMVAR_FAIL(); 3728 } 3729 } else { 3730 DMLOG_PRINT(DMLVL_ERR, 3731 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n", 3732 szFuncName, 0, nelem, 3733 DM_EVENT_DESTROY + 1); 3734 DMVAR_FAIL(); 3735 } 3736 } else { 3737 DMLOG_PRINT(DMLVL_ERR, 3738 "%s failed with unexpected rc = %d (errno = %d)\n", 3739 szFuncName, rc, errno); 3740 DMVAR_FAIL(); 3741 } 3742 3743 /* Variation clean up */ 3744 DMEV_ZERO(ineventset); 3745 rc = dm_set_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3746 &ineventset, DM_EVENT_MAX); 3747 rc |= dm_destroy_session(newsid); 3748 if (rc == -1) { 3749 DMLOG_PRINT(DMLVL_DEBUG, 3750 "Unable to clean up variation! (errno = %d)\n", 3751 errno); 3752 } 3753 dm_handle_free(hanp, hlen); 3754 } 3755 } 3756 3757 /* 3758 * TEST : dm_get_eventlist - global handle 3759 * EXPECTED: rc = -1, errno = EBADF 3760 */ 3761 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 21)) { 3762 dm_sessid_t newsid; 3763 dm_eventset_t outeventset; 3764 u_int nelem; 3765 3766 /* Variation set up */ 3767 rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &newsid); 3768 if (rc == -1) { 3769 DMLOG_PRINT(DMLVL_DEBUG, 3770 "Unable to set up variation! (errno = %d)\n", 3771 errno); 3772 DMVAR_SKIP(); 3773 } else { 3774 /* Variation */ 3775 3776 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", 3777 szFuncName); 3778 rc = dm_get_eventlist(newsid, DM_GLOBAL_HANP, 3779 DM_GLOBAL_HLEN, DM_NO_TOKEN, 3780 DM_EVENT_MAX, &outeventset, 3781 &nelem); 3782 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 3783 3784 /* Variation clean up */ 3785 rc = dm_destroy_session(newsid); 3786 if (rc == -1) { 3787 DMLOG_PRINT(DMLVL_DEBUG, 3788 "Unable to clean up variation! (errno = %d)\n", 3789 errno); 3790 } 3791 } 3792 } 3793 3794 /* 3795 * TEST : dm_get_eventlist - invalidated file handle 3796 * EXPECTED: rc = -1, errno = EBADF 3797 */ 3798 if (DMVAR_EXEC(GET_EVENTLIST_BASE + 22)) { 3799 dm_sessid_t newsid; 3800 void *hanp; 3801 size_t hlen; 3802 dm_eventset_t ineventset, outeventset; 3803 u_int nelem; 3804 3805 /* Variation set up */ 3806 DMEV_ZERO(ineventset); 3807 DMEV_ZERO(outeventset); 3808 3809 sprintf(command, "cp %s %s", DummyFile, DummyFile2); 3810 if ((rc = system(command)) == -1) { 3811 /* No clean up */ 3812 } else 3813 if ((rc = 3814 dm_create_session(DM_NO_SESSION, szSessionInfo, 3815 &newsid)) == -1) { 3816 remove(DummyFile2); 3817 } else if ((rc = dm_path_to_handle(DummyFile2, &hanp, &hlen)) == 3818 -1) { 3819 dm_destroy_session(newsid); 3820 remove(DummyFile2); 3821 } else if ((rc = remove(DummyFile2)) == -1) { 3822 dm_handle_free(hanp, hlen); 3823 dm_destroy_session(newsid); 3824 } 3825 if (rc == -1) { 3826 DMLOG_PRINT(DMLVL_DEBUG, 3827 "Unable to set up variation! (errno = %d)\n", 3828 errno); 3829 DMVAR_SKIP(); 3830 } else { 3831 /* Variation */ 3832 DMLOG_PRINT(DMLVL_DEBUG, 3833 "%s(invalidated file handle)\n", 3834 szFuncName); 3835 rc = dm_get_eventlist(newsid, hanp, hlen, DM_NO_TOKEN, 3836 DM_EVENT_MAX, &outeventset, 3837 &nelem); 3838 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF); 3839 3840 /* Variation clean up */ 3841 rc = dm_destroy_session(newsid); 3842 if (rc == -1) { 3843 DMLOG_PRINT(DMLVL_DEBUG, 3844 "Unable to clean up variation! (errno = %d)\n", 3845 errno); 3846 } 3847 dm_handle_free(hanp, hlen); 3848 } 3849 } 3850 3851 /* We now need to repoint preunmount/unmount back to original session */ 3852 DMEV_ZERO(events); 3853 DMEV_SET(DM_EVENT_PREUNMOUNT, events); 3854 DMEV_SET(DM_EVENT_UNMOUNT, events); 3855 rc = dm_path_to_fshandle(DummyFile, &fshanp, &fshlen); 3856 if (rc == -1) { 3857 DMLOG_PRINT(DMLVL_ERR, 3858 "dm_path_to_fshandle failed! (rc = %d, errno = %d)\n", 3859 rc, errno); 3860 dm_destroy_session(sid); 3861 DM_EXIT(); 3862 } 3863 3864 rc = dm_set_disp(sid, fshanp, fshlen, DM_NO_TOKEN, &events, 3865 DM_EVENT_MAX); 3866 if (rc == -1) { 3867 DMLOG_PRINT(DMLVL_ERR, 3868 "dm_set_disp failed! (rc = %d, errno = %d)\n", rc, 3869 errno); 3870 dm_destroy_session(sid); 3871 DM_EXIT(); 3872 } 3873 3874 rc = dm_set_eventlist(sid, fshanp, fshlen, DM_NO_TOKEN, &events, 3875 DM_EVENT_MAX); 3876 if (rc == -1) { 3877 DMLOG_PRINT(DMLVL_ERR, 3878 "dm_set_eventlist failed! (rc = %d, errno = %d)\n", 3879 rc, errno); 3880 dm_destroy_session(sid); 3881 DM_EXIT(); 3882 } 3883 3884 remove(DummyFile); 3885 rmdir(DummySubdir); 3886 dm_handle_free(fshanp, fshlen); 3887 3888 rc = umount(mountPt); 3889 if (rc == -1) { 3890 DMLOG_PRINT(DMLVL_ERR, "umount failed! (rc = %d, errno = %d)\n", 3891 rc, errno); 3892 } 3893 3894 pthread_join(tid, NULL); 3895 3896 rc = dm_destroy_session(sid); 3897 if (rc == -1) { 3898 DMLOG_PRINT(DMLVL_ERR, 3899 "dm_destroy_session failed! (rc = %d, errno = %d)\n", 3900 rc, errno); 3901 } 3902 3903 DMLOG_STOP(); 3904 3905 tst_exit(); 3906 } 3907 3908 void *Thread(void *parm) 3909 { 3910 int rc; 3911 size_t dmMsgBufLen; 3912 dm_eventmsg_t *dmMsg; 3913 int bMounted = DM_FALSE; 3914 dm_eventtype_t type; 3915 dm_token_t token; 3916 dm_eventset_t events; 3917 dm_response_t response; 3918 3919 do { 3920 /* Loop until message received (wait could be interrupted) */ 3921 do { 3922 DMLOG_PRINT(DMLVL_DEBUG, "Waiting for event...\n"); 3923 dmMsgBufLen = 0; 3924 3925 rc = dm_get_events(sid, 1, DM_EV_WAIT, sizeof(dmMsgBuf), 3926 dmMsgBuf, &dmMsgBufLen); 3927 DMLOG_PRINT(DMLVL_DEBUG, 3928 "... dm_get_events returned %d (errno %d)\n", 3929 rc, errno); 3930 } while ((rc == -1) && (errno == EINTR) && (dmMsgBufLen == 0)); 3931 3932 if (rc) { 3933 DMLOG_PRINT(DMLVL_ERR, 3934 "dm_get_events failed with rc = %d, errno = %d\n", 3935 rc, errno); 3936 dm_destroy_session(sid); 3937 DM_EXIT(); 3938 } else { 3939 dmMsg = (dm_eventmsg_t *) dmMsgBuf; 3940 token = dmMsg->ev_token; 3941 type = dmMsg->ev_type; 3942 3943 DMLOG_PRINT(DMLVL_DEBUG, "Received message %d\n", type); 3944 } 3945 3946 if (type == DM_EVENT_MOUNT) { 3947 /* SPECIAL CASE: need to set disposition, events and response */ 3948 dm_mount_event_t *me = 3949 DM_GET_VALUE(dmMsg, ev_data, dm_mount_event_t *); 3950 void *lhanp = DM_GET_VALUE(me, me_handle1, void *); 3951 size_t lhlen = DM_GET_LEN(me, me_handle1); 3952 3953 DMLOG_PRINT(DMLVL_DEBUG, "Message is DM_EVENT_MOUNT\n"); 3954 DMLOG_PRINT(DMLVL_DEBUG, " Mode: %x\n", me->me_mode); 3955 DMLOG_PRINT(DMLVL_DEBUG, " File system handle: %p\n", 3956 lhanp); 3957 DMLOG_PRINT(DMLVL_DEBUG, 3958 " File system handle length: %d\n", lhlen); 3959 DMLOG_PRINT(DMLVL_DEBUG, " Mountpoint handle: %p\n", 3960 DM_GET_VALUE(me, me_handle2, void *)); 3961 DMLOG_PRINT(DMLVL_DEBUG, 3962 " Mountpoint handle length: %d\n", 3963 DM_GET_LEN(me, me_handle2)); 3964 DMLOG_PRINT(DMLVL_DEBUG, " Mountpoint path: %s\n", 3965 DM_GET_VALUE(me, me_name1, char *)); 3966 DMLOG_PRINT(DMLVL_DEBUG, " Media designator: %s\n", 3967 DM_GET_VALUE(me, me_name2, char *)); 3968 DMLOG_PRINT(DMLVL_DEBUG, " Root handle: %p\n", 3969 DM_GET_VALUE(me, me_roothandle, void *)); 3970 DMLOG_PRINT(DMLVL_DEBUG, " Root handle length: %d\n", 3971 DM_GET_LEN(me, me_roothandle)); 3972 3973 bMounted = dm_handle_is_valid(lhanp, lhlen); 3974 3975 rc = dm_request_right(sid, lhanp, lhlen, token, 3976 DM_RR_WAIT, DM_RIGHT_EXCL); 3977 if (rc == -1) { 3978 DMLOG_PRINT(DMLVL_ERR, 3979 "dm_request_right failed! (rc = %d, errno = %d)\n", 3980 rc, errno); 3981 dm_destroy_session(sid); 3982 DM_EXIT(); 3983 } 3984 3985 DMEV_ZERO(events); 3986 DMEV_SET(DM_EVENT_PREUNMOUNT, events); 3987 DMEV_SET(DM_EVENT_UNMOUNT, events); 3988 rc = dm_set_eventlist(sid, lhanp, lhlen, token, &events, 3989 DM_EVENT_MAX); 3990 if (rc == -1) { 3991 DMLOG_PRINT(DMLVL_ERR, 3992 "dm_set_eventlist failed! (rc = %d, errno = %d)\n", 3993 rc, errno); 3994 dm_destroy_session(sid); 3995 DM_EXIT(); 3996 } 3997 3998 rc = dm_release_right(sid, lhanp, lhlen, token); 3999 if (rc == -1) { 4000 DMLOG_PRINT(DMLVL_ERR, 4001 "dm_request_right failed! (rc = %d, errno = %d)\n", 4002 rc, errno); 4003 dm_destroy_session(sid); 4004 DM_EXIT(); 4005 } 4006 4007 response = DM_RESP_CONTINUE; 4008 } else if (type == DM_EVENT_UNMOUNT) { 4009 dm_namesp_event_t *nse = 4010 DM_GET_VALUE(dmMsg, ev_data, dm_namesp_event_t *); 4011 if (nse->ne_retcode == 0) { 4012 bMounted = DM_FALSE; 4013 } 4014 4015 response = DM_RESP_CONTINUE; 4016 } else { 4017 switch (type) { 4018 case DM_EVENT_PREUNMOUNT: 4019 case DM_EVENT_READ: 4020 case DM_EVENT_WRITE: 4021 case DM_EVENT_TRUNCATE: 4022 case DM_EVENT_CREATE: 4023 case DM_EVENT_REMOVE: 4024 case DM_EVENT_RENAME: 4025 case DM_EVENT_LINK: 4026 case DM_EVENT_SYMLINK: 4027 response = DM_RESP_CONTINUE; 4028 break; 4029 4030 case DM_EVENT_POSTCREATE: 4031 case DM_EVENT_POSTREMOVE: 4032 case DM_EVENT_POSTRENAME: 4033 case DM_EVENT_POSTLINK: 4034 case DM_EVENT_POSTSYMLINK: 4035 case DM_EVENT_ATTRIBUTE: 4036 case DM_EVENT_CLOSE: 4037 response = DM_RESP_INVALID; 4038 break; 4039 4040 default: 4041 { 4042 DMLOG_PRINT(DMLVL_ERR, 4043 "Message is unexpected!\n"); 4044 response = DM_RESP_ABORT; 4045 break; 4046 } 4047 } 4048 } 4049 4050 if (response != DM_RESP_INVALID) { 4051 DMLOG_PRINT(DMLVL_DEBUG, 4052 "Responding to message %d with %d\n", type, 4053 response); 4054 rc = dm_respond_event(sid, token, response, 4055 response == 4056 DM_RESP_ABORT ? ABORT_ERRNO : 0, 4057 0, NULL); 4058 } 4059 } while (bMounted); 4060 4061 pthread_exit(0); 4062 } 4063
