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 : event.c 21 * 22 * VARIATIONS : 41 23 * 24 * API'S TESTED : dm_get_events 25 * dm_respond_event 26 * dm_move_event 27 * dm_pending 28 */ 29#include <string.h> 30#include <stdio.h> 31#include <errno.h> 32#include <pthread.h> 33#include <unistd.h> 34#include <sys/stat.h> 35#include <sys/mount.h> 36#include <fcntl.h> 37#include <signal.h> 38#include "dm_test.h" 39 40#define MAX_EVENT (sizeof(dmMsgBuf)/(MSG_DATALEN+sizeof(dm_eventmsg_t))) 41 42pthread_t tid; 43dm_sessid_t sid; 44char dmMsgBuf[4096]; 45char command[4096]; 46char mountPt[FILENAME_MAX]; 47char deviceNm[FILENAME_MAX]; 48char *szFuncName; 49 50/* Variables for thread communications */ 51int expectedNumMsg; 52u_int eventsFlags; 53int rcRespond; 54int errnoRespond; 55 56void *Thread(void *); 57 58void LogEventMsgs(void *bufp) 59{ 60 int i = 0; 61 dm_eventmsg_t *em = (dm_eventmsg_t *) bufp; 62 63 while (em != NULL) { 64 DMLOG_PRINT(DMLVL_DEBUG, " eventmsg %d:\n", i++); 65 DMLOG_PRINT(DMLVL_DEBUG, " ev_type: %d\n", em->ev_type); 66 DMLOG_PRINT(DMLVL_DEBUG, " ev_token: %d\n", em->ev_token); 67 DMLOG_PRINT(DMLVL_DEBUG, " ev_sequence: %d\n", 68 em->ev_sequence); 69 DMLOG_PRINT(DMLVL_DEBUG, " ev_data: length %d, value %s\n", 70 DM_GET_LEN(em, ev_data), DM_GET_VALUE(em, ev_data, 71 dm_eventtype_t)); 72 73 em = DM_STEP_TO_NEXT(em, dm_eventmsg_t *); 74 } 75} 76 77dm_eventmsg_t *GetSyncEventMsg(void *bufp) 78{ 79 dm_eventmsg_t *em = (dm_eventmsg_t *) bufp; 80 81 while (em != NULL) { 82 if ((em->ev_type == DM_EVENT_USER) 83 && (em->ev_token != DM_INVALID_TOKEN)) { 84 return em; 85 } 86 em = DM_STEP_TO_NEXT(em, dm_eventmsg_t *); 87 } 88 89 return NULL; 90} 91 92int GetNumEventMsg(void *bufp) 93{ 94 dm_eventmsg_t *em = (dm_eventmsg_t *) bufp; 95 int i = 0; 96 97 while (em != NULL) { 98 i++; 99 em = DM_STEP_TO_NEXT(em, dm_eventmsg_t *); 100 } 101 return i; 102} 103 104int main(int argc, char **argv) 105{ 106 107 char *varstr; 108 int rc; 109 char *szSessionInfo = "dm_test session info"; 110 dm_eventset_t events; 111 112 DMOPT_PARSE(argc, argv); 113 DMLOG_START(); 114 115 DMEV_ZERO(events); 116 DMEV_SET(DM_EVENT_MOUNT, events); 117 118 /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION!!! */ 119 if ((rc = dm_init_service(&varstr)) != 0) { 120 DMLOG_PRINT(DMLVL_ERR, 121 "dm_init_service failed! (rc = %d, errno = %d)\n", 122 rc, errno); 123 DM_EXIT(); 124 } else if ((rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &sid)) 125 == -1) { 126 DMLOG_PRINT(DMLVL_ERR, 127 "dm_create_session failed! (rc = %d, errno = %d)\n", 128 rc, errno); 129 DM_EXIT(); 130 } 131 132 DMLOG_PRINT(DMLVL_DEBUG, "Starting DMAPI move event tests\n"); 133 134 szFuncName = "dm_get_events"; 135 136 /* 137 * TEST : dm_get_events - invalid sid 138 * EXPECTED: rc = -1, errno = EINVAL 139 */ 140 if (DMVAR_EXEC(GET_EVENTS_BASE + 1)) { 141 char buf[MSG_DATALEN]; 142 size_t rlen; 143 144 /* Variation set up */ 145 146 /* Variation */ 147 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", szFuncName); 148 rc = dm_get_events(INVALID_ADDR, 0, 0, sizeof(buf), buf, &rlen); 149 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 150 151 /* Variation clean up */ 152 } 153 154 /* 155 * TEST : dm_get_events - invalid buflen 156 * EXPECTED: rc = -1, errno = E2BIG 157 */ 158 if (DMVAR_EXEC(GET_EVENTS_BASE + 2)) { 159 char buf[MSG_DATALEN]; 160 161 /* Variation set up */ 162 memcpy(buf, MSG_DATA, MSG_DATALEN); 163 rc = pthread_create(&tid, NULL, Thread, 164 (void *)(GET_EVENTS_BASE + 2)); 165 if (rc == -1) { 166 DMLOG_PRINT(DMLVL_DEBUG, 167 "Unable to set up variation! (errno = %d)\n", 168 errno); 169 DMVAR_SKIP(); 170 } else { 171 /* Message thread finishes off variation */ 172 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 173 pthread_join(tid, NULL); 174 } 175 } 176 177 /* 178 * TEST : dm_get_events - invalid bufp 179 * EXPECTED: rc = -1, errno = EFAULT 180 */ 181 if (DMVAR_EXEC(GET_EVENTS_BASE + 3)) { 182 char buf[MSG_DATALEN]; 183 184 /* Variation set up */ 185 memcpy(buf, MSG_DATA, MSG_DATALEN); 186 rc = pthread_create(&tid, NULL, Thread, 187 (void *)(GET_EVENTS_BASE + 3)); 188 if (rc == -1) { 189 DMLOG_PRINT(DMLVL_DEBUG, 190 "Unable to set up variation! (errno = %d)\n", 191 errno); 192 DMVAR_SKIP(); 193 } else { 194 /* Message thread finishes off variation */ 195 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 196 pthread_join(tid, NULL); 197 } 198 } 199 200 /* 201 * TEST : dm_get_events - invalid rlenp 202 * EXPECTED: rc = -1, errno = EFAULT 203 */ 204 if (DMVAR_EXEC(GET_EVENTS_BASE + 4)) { 205 char buf[MSG_DATALEN]; 206 207 /* Variation set up */ 208 memcpy(buf, MSG_DATA, MSG_DATALEN); 209 rc = pthread_create(&tid, NULL, Thread, 210 (void *)(GET_EVENTS_BASE + 4)); 211 if (rc == -1) { 212 DMLOG_PRINT(DMLVL_DEBUG, 213 "Unable to set up variation! (errno = %d)\n", 214 errno); 215 DMVAR_SKIP(); 216 } else { 217 /* Message thread finishes off variation */ 218 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 219 pthread_join(tid, NULL); 220 } 221 } 222 223 /* 224 * TEST : dm_get_events - !DM_EV_WAIT with no messages 225 * EXPECTED: rc = -1, errno = EAGAIN 226 */ 227 if (DMVAR_EXEC(GET_EVENTS_BASE + 5)) { 228 229 /* Variation set up */ 230 rc = pthread_create(&tid, NULL, Thread, 231 (void *)(GET_EVENTS_BASE + 5)); 232 if (rc == -1) { 233 DMLOG_PRINT(DMLVL_DEBUG, 234 "Unable to set up variation! (errno = %d)\n", 235 errno); 236 DMVAR_SKIP(); 237 } else { 238 pthread_join(tid, NULL); 239 } 240 } 241 242 /* 243 * TEST : dm_get_events - !DM_EV_WAIT with one message 244 * EXPECTED: rc = 0 245 */ 246 if (DMVAR_EXEC(GET_EVENTS_BASE + 6)) { 247 char buf[MSG_DATALEN]; 248 249 /* Variation set up */ 250 expectedNumMsg = 1; 251 eventsFlags = 0; 252 memcpy(buf, MSG_DATA, MSG_DATALEN); 253 rc = pthread_create(&tid, NULL, Thread, 254 (void *)(GET_EVENTS_BASE + 6)); 255 if (rc == -1) { 256 DMLOG_PRINT(DMLVL_DEBUG, 257 "Unable to set up variation! (errno = %d)\n", 258 errno); 259 DMVAR_SKIP(); 260 } else { 261 /* Message thread finishes off variation */ 262 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 263 pthread_join(tid, NULL); 264 } 265 } 266 267 /* 268 * TEST : dm_get_events - DM_EV_WAIT with one message 269 * EXPECTED: rc = 0 270 */ 271 if (DMVAR_EXEC(GET_EVENTS_BASE + 7)) { 272 char buf[MSG_DATALEN]; 273 274 /* Variation set up */ 275 expectedNumMsg = 1; 276 eventsFlags = DM_EV_WAIT; 277 memcpy(buf, MSG_DATA, MSG_DATALEN); 278 rc = pthread_create(&tid, NULL, Thread, 279 (void *)(GET_EVENTS_BASE + 7)); 280 if (rc == -1) { 281 DMLOG_PRINT(DMLVL_DEBUG, 282 "Unable to set up variation! (errno = %d)\n", 283 errno); 284 DMVAR_SKIP(); 285 } else { 286 /* Message thread finishes off variation */ 287 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 288 pthread_join(tid, NULL); 289 } 290 } 291 292 /* 293 * TEST : dm_get_events - !DM_EV_WAIT with two messages 294 * EXPECTED: rc = 0 295 */ 296 if (DMVAR_EXEC(GET_EVENTS_BASE + 8)) { 297 char buf[MSG_DATALEN]; 298 299 /* Variation set up */ 300 expectedNumMsg = 2; 301 eventsFlags = 0; 302 memcpy(buf, MSG_DATA, MSG_DATALEN); 303 rc = dm_send_msg(sid, DM_MSGTYPE_ASYNC, MSG_DATALEN, buf); 304 if (rc != -1) { 305 rc = pthread_create(&tid, NULL, Thread, 306 (void *)(GET_EVENTS_BASE + 8)); 307 } 308 if (rc == -1) { 309 DMLOG_PRINT(DMLVL_DEBUG, 310 "Unable to set up variation! (errno = %d)\n", 311 errno); 312 DMVAR_SKIP(); 313 } else { 314 /* Message thread finishes off variation */ 315 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 316 pthread_join(tid, NULL); 317 } 318 } 319 320 /* 321 * TEST : dm_get_events - DM_EV_WAIT with two messages 322 * EXPECTED: rc = 0 323 */ 324 if (DMVAR_EXEC(GET_EVENTS_BASE + 9)) { 325 char buf[MSG_DATALEN]; 326 327 /* Variation set up */ 328 expectedNumMsg = 2; 329 eventsFlags = DM_EV_WAIT; 330 memcpy(buf, MSG_DATA, MSG_DATALEN); 331 rc = dm_send_msg(sid, DM_MSGTYPE_ASYNC, MSG_DATALEN, buf); 332 if (rc != -1) { 333 rc = pthread_create(&tid, NULL, Thread, 334 (void *)(GET_EVENTS_BASE + 9)); 335 } 336 if (rc == -1) { 337 DMLOG_PRINT(DMLVL_DEBUG, 338 "Unable to set up variation! (errno = %d)\n", 339 errno); 340 DMVAR_SKIP(); 341 } else { 342 /* Message thread finishes off variation */ 343 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 344 pthread_join(tid, NULL); 345 } 346 } 347 348 /* 349 * TEST : dm_get_events - !DM_EV_WAIT with more than MAX_EVENT messages 350 * EXPECTED: rc = 0 351 */ 352 if (DMVAR_EXEC(GET_EVENTS_BASE + 10)) { 353 int i, j; 354 char buf[MSG_DATALEN]; 355 356 /* Variation set up */ 357 expectedNumMsg = MAX_EVENT; 358 eventsFlags = 0; 359 for (i = 0, rc = 0; i < MAX_EVENT + 1 && rc == 0; i++) { 360 j = sprintf(buf, "Multi event message %d", i); 361 rc = dm_send_msg(sid, DM_MSGTYPE_ASYNC, j + 1, buf); 362 } 363 if (rc != -1) { 364 rc = pthread_create(&tid, NULL, Thread, 365 (void *)(GET_EVENTS_BASE + 10)); 366 } 367 if (rc == -1) { 368 DMLOG_PRINT(DMLVL_DEBUG, 369 "Unable to set up variation! (errno = %d)\n", 370 errno); 371 DMVAR_SKIP(); 372 } else { 373 /* Message thread finishes off variation */ 374 j = sprintf(buf, "Multi event message %d", i); 375 dm_send_msg(sid, DM_MSGTYPE_SYNC, j + 1, buf); 376 pthread_join(tid, NULL); 377 } 378 } 379 380 szFuncName = "dm_respond_event"; 381 382 /* 383 * TEST : dm_respond_event - invalid sid 384 * EXPECTED: rc = -1, errno = EINVAL 385 */ 386 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 1)) { 387 char buf[MSG_DATALEN]; 388 dm_token_t token; 389 390 /* Variation set up */ 391 memcpy(buf, MSG_DATA, MSG_DATALEN); 392 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 393 if (rc == -1) { 394 DMLOG_PRINT(DMLVL_DEBUG, 395 "Unable to set up variation! (errno = %d)\n", 396 errno); 397 DMVAR_SKIP(); 398 } else { 399 /* Variation */ 400 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", 401 szFuncName); 402 rc = dm_respond_event(INVALID_ADDR, token, 403 DM_RESP_CONTINUE, 0, sizeof(buf), 404 buf); 405 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 406 407 /* Variation clean up */ 408 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 409 0, NULL); 410 if (rc == -1) { 411 DMLOG_PRINT(DMLVL_DEBUG, 412 "Unable to clean up variation! (errno = %d)\n", 413 errno); 414 } 415 } 416 } 417 418 /* 419 * TEST : dm_respond_event - DM_NO_SESSION sid 420 * EXPECTED: rc = -1, errno = EINVAL 421 */ 422 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 2)) { 423 char buf[MSG_DATALEN]; 424 dm_token_t token; 425 426 /* Variation set up */ 427 memcpy(buf, MSG_DATA, MSG_DATALEN); 428 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 429 if (rc == -1) { 430 DMLOG_PRINT(DMLVL_DEBUG, 431 "Unable to set up variation! (errno = %d)\n", 432 errno); 433 DMVAR_SKIP(); 434 } else { 435 /* Variation */ 436 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 437 szFuncName); 438 rc = dm_respond_event(DM_NO_SESSION, token, 439 DM_RESP_CONTINUE, 0, sizeof(buf), 440 buf); 441 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 442 443 /* Variation clean up */ 444 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 445 0, NULL); 446 if (rc == -1) { 447 DMLOG_PRINT(DMLVL_DEBUG, 448 "Unable to clean up variation! (errno = %d)\n", 449 errno); 450 } 451 } 452 } 453 454 /* 455 * TEST : dm_respond_event - invalid token 456 * EXPECTED: rc = -1, errno = EINVAL 457 */ 458 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 3)) { 459 char buf[MSG_DATALEN]; 460 461 /* Variation set up */ 462 memcpy(buf, MSG_DATA, MSG_DATALEN); 463 464 /* Variation */ 465 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", szFuncName); 466 rc = dm_respond_event(sid, INVALID_ADDR, DM_RESP_CONTINUE, 0, 467 sizeof(buf), buf); 468 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 469 470 /* Variation clean up */ 471 } 472 473 /* 474 * TEST : dm_respond_event - DM_NO_TOKEN token 475 * EXPECTED: rc = -1, errno = EINVAL 476 */ 477 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 4)) { 478 char buf[MSG_DATALEN]; 479 480 /* Variation set up */ 481 memcpy(buf, MSG_DATA, MSG_DATALEN); 482 483 /* Variation */ 484 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_TOKEN token)\n", szFuncName); 485 rc = dm_respond_event(sid, DM_NO_TOKEN, DM_RESP_CONTINUE, 0, 486 sizeof(buf), buf); 487 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 488 489 /* Variation clean up */ 490 } 491 492 /* 493 * TEST : dm_respond_event - DM_INVALID_TOKEN token 494 * EXPECTED: rc = -1, errno = EINVAL 495 */ 496 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 5)) { 497 char buf[MSG_DATALEN]; 498 499 /* Variation set up */ 500 memcpy(buf, MSG_DATA, MSG_DATALEN); 501 502 /* Variation */ 503 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_INVALID_TOKEN token)\n", 504 szFuncName); 505 rc = dm_respond_event(sid, DM_INVALID_TOKEN, DM_RESP_CONTINUE, 506 0, sizeof(buf), buf); 507 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 508 509 /* Variation clean up */ 510 } 511 512 /* 513 * TEST : dm_respond_event - invalid response 514 * EXPECTED: rc = -1, errno = EINVAL 515 */ 516 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 6)) { 517 char buf[MSG_DATALEN]; 518 dm_token_t token; 519 520 /* Variation set up */ 521 memcpy(buf, MSG_DATA, MSG_DATALEN); 522 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 523 if (rc == -1) { 524 DMLOG_PRINT(DMLVL_DEBUG, 525 "Unable to set up variation! (errno = %d)\n", 526 errno); 527 DMVAR_SKIP(); 528 } else { 529 /* Variation */ 530 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid response)\n", 531 szFuncName); 532 rc = dm_respond_event(sid, token, INVALID_ADDR, 0, 533 sizeof(buf), buf); 534 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 535 536 /* Variation clean up */ 537 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 538 0, NULL); 539 if (rc == -1) { 540 DMLOG_PRINT(DMLVL_DEBUG, 541 "Unable to clean up variation! (errno = %d)\n", 542 errno); 543 } 544 } 545 } 546 547 /* 548 * TEST : dm_respond_event - invalid buflen 549 * EXPECTED: rc = -1, errno = E2BIG 550 * 551 * This variation uncovered XFS BUG #37 (0 returned instead of -1 and 552 * E2BIG) 553 */ 554 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 7)) { 555 char buf[MSG_DATALEN]; 556 dm_token_t token; 557 558 /* Variation set up */ 559 memcpy(buf, MSG_DATA, MSG_DATALEN); 560 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 561 if (rc == -1) { 562 DMLOG_PRINT(DMLVL_DEBUG, 563 "Unable to set up variation! (errno = %d)\n", 564 errno); 565 DMVAR_SKIP(); 566 } else { 567 /* Variation */ 568 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid response)\n", 569 szFuncName); 570 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 571 INVALID_ADDR, buf); 572 DMVAR_ENDFAILEXP(szFuncName, -1, rc, E2BIG); 573 574 /* Variation clean up */ 575 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 576 0, NULL); 577 if (rc == -1) { 578 DMLOG_PRINT(DMLVL_DEBUG, 579 "Unable to clean up variation! (errno = %d)\n", 580 errno); 581 } 582 } 583 } 584 585 /* 586 * TEST : dm_respond_event - invalidated token 587 * EXPECTED: rc = -1, errno = ESRCH 588 */ 589 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 8)) { 590 char buf[MSG_DATALEN]; 591 dm_token_t token; 592 593 /* Variation set up */ 594 memcpy(buf, MSG_DATA, MSG_DATALEN); 595 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 596 if (rc != -1) { 597 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 598 sizeof(buf), buf); 599 } 600 if (rc == -1) { 601 DMLOG_PRINT(DMLVL_DEBUG, 602 "Unable to set up variation! (errno = %d)\n", 603 errno); 604 DMVAR_SKIP(); 605 } else { 606 /* Variation */ 607 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated token)\n", 608 szFuncName); 609 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 610 sizeof(buf), buf); 611 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ESRCH); 612 613 /* Variation clean up */ 614 } 615 } 616 617 /* 618 * TEST : dm_respond_event - DM_RESP_INVALID 619 * EXPECTED: rc = -1, errno = EINVAL 620 */ 621 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 9)) { 622 char buf[MSG_DATALEN]; 623 624 /* Variation set up */ 625 memcpy(buf, MSG_DATA, MSG_DATALEN); 626 rc = pthread_create(&tid, NULL, Thread, 627 (void *)(RESPOND_EVENT_BASE + 9)); 628 if (rc == -1) { 629 DMLOG_PRINT(DMLVL_DEBUG, 630 "Unable to set up variation! (errno = %d)\n", 631 errno); 632 DMVAR_SKIP(); 633 } else { 634 /* Message thread finishes off variation */ 635 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 636 pthread_join(tid, NULL); 637 } 638 } 639 640 /* 641 * TEST : dm_respond_event - DM_RESP_CONTINUE with zero reterror 642 * EXPECTED: rc = 0 643 */ 644 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 10)) { 645 char buf[MSG_DATALEN]; 646 647 /* Variation set up */ 648 memcpy(buf, MSG_DATA, MSG_DATALEN); 649 rc = pthread_create(&tid, NULL, Thread, 650 (void *)(RESPOND_EVENT_BASE + 10)); 651 if (rc == -1) { 652 DMLOG_PRINT(DMLVL_DEBUG, 653 "Unable to set up variation! (errno = %d)\n", 654 errno); 655 DMVAR_SKIP(); 656 } else { 657 /* Message thread continues variation */ 658 rc = dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, 659 buf); 660 if (rcRespond == 0) { 661 if (rc == 0) { 662 DMLOG_PRINT(DMLVL_DEBUG, 663 "%s passed with expected rc = %d and expected dm_send_msg rc = %d\n", 664 szFuncName, rcRespond, rc); 665 DMVAR_PASS(); 666 } else { 667 DMLOG_PRINT(DMLVL_ERR, 668 "%s failed with expected rc = %d but unexpected dm_send_msg rc = %d and errno %d\n", 669 szFuncName, rcRespond, rc, 670 errno); 671 DMVAR_FAIL(); 672 } 673 } else { 674 DMLOG_PRINT(DMLVL_ERR, 675 "%s failed with unexpected rc = %d (errno = %d)\n", 676 szFuncName, rcRespond, 677 errnoRespond); 678 DMVAR_FAIL(); 679 } 680 pthread_join(tid, NULL); 681 } 682 } 683 684 /* 685 * TEST : dm_respond_event - DM_RESP_CONTINUE with non-zero reterror 686 * EXPECTED: rc = -1, errno = EINVAL 687 */ 688 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 11)) { 689 char buf[MSG_DATALEN]; 690 691 /* Variation set up */ 692 memcpy(buf, MSG_DATA, MSG_DATALEN); 693 rc = pthread_create(&tid, NULL, Thread, 694 (void *)(RESPOND_EVENT_BASE + 11)); 695 if (rc == -1) { 696 DMLOG_PRINT(DMLVL_DEBUG, 697 "Unable to set up variation! (errno = %d)\n", 698 errno); 699 DMVAR_SKIP(); 700 } else { 701 /* Message thread finishes off variation */ 702 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 703 pthread_join(tid, NULL); 704 } 705 } 706 707 /* 708 * TEST : dm_respond_event - DM_RESP_ABORT with zero reterror 709 * EXPECTED: rc = -1, errno = EINVAL 710 */ 711 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 12)) { 712 char buf[MSG_DATALEN]; 713 714 /* Variation set up */ 715 memcpy(buf, MSG_DATA, MSG_DATALEN); 716 rc = pthread_create(&tid, NULL, Thread, 717 (void *)(RESPOND_EVENT_BASE + 12)); 718 if (rc == -1) { 719 DMLOG_PRINT(DMLVL_DEBUG, 720 "Unable to set up variation! (errno = %d)\n", 721 errno); 722 DMVAR_SKIP(); 723 } else { 724 /* Message thread finishes off variation */ 725 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 726 pthread_join(tid, NULL); 727 } 728 } 729 730 /* 731 * TEST : dm_respond_event - DM_RESP_ABORT with non-zero reterror 732 * EXPECTED: rc = ABORT_ERRNO 733 */ 734 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 13)) { 735 char buf[MSG_DATALEN]; 736 737 /* Variation set up */ 738 memcpy(buf, MSG_DATA, MSG_DATALEN); 739 rc = pthread_create(&tid, NULL, Thread, 740 (void *)(RESPOND_EVENT_BASE + 13)); 741 if (rc == -1) { 742 DMLOG_PRINT(DMLVL_DEBUG, 743 "Unable to set up variation! (errno = %d)\n", 744 errno); 745 DMVAR_SKIP(); 746 } else { 747 /* Message thread continues variation */ 748 rc = dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, 749 buf); 750 if (rcRespond == 0) { 751 if (rc == -1) { 752 if (errno == ABORT_ERRNO) { 753 DMLOG_PRINT(DMLVL_DEBUG, 754 "%s passed with expected rc = %d and dm_send_msg rc = %d\n", 755 szFuncName, 756 rcRespond, rc); 757 DMVAR_PASS(); 758 } else { 759 DMLOG_PRINT(DMLVL_ERR, 760 "%s failed with expected rc = %d and dm_send_msg rc = %d but unexpected errno (%d vs %d)\n", 761 szFuncName, 762 rcRespond, rc, 763 errno, ABORT_ERRNO); 764 DMVAR_FAIL(); 765 } 766 } else { 767 DMLOG_PRINT(DMLVL_ERR, 768 "%s failed with expected rc = %d but unexpected dm_send_msg rc (%d vs %d)\n", 769 szFuncName, rcRespond, rc, 770 -1); 771 DMVAR_FAIL(); 772 } 773 } else { 774 DMLOG_PRINT(DMLVL_ERR, 775 "%s failed with unexpected rc = %d (errno = %d)\n", 776 szFuncName, rcRespond, 777 errnoRespond); 778 DMVAR_FAIL(); 779 } 780 pthread_join(tid, NULL); 781 } 782 } 783 784 /* 785 * TEST : dm_respond_event - DM_RESP_DONTCARE 786 * EXPECTED: rc = -1, errno = EINVAL 787 */ 788 if (DMVAR_EXEC(RESPOND_EVENT_BASE + 14)) { 789 char buf[MSG_DATALEN]; 790 791 /* Variation set up */ 792 memcpy(buf, MSG_DATA, MSG_DATALEN); 793 rc = pthread_create(&tid, NULL, Thread, 794 (void *)(RESPOND_EVENT_BASE + 14)); 795 if (rc == -1) { 796 DMLOG_PRINT(DMLVL_DEBUG, 797 "Unable to set up variation! (errno = %d)\n", 798 errno); 799 DMVAR_SKIP(); 800 } else { 801 /* Message thread finishes off variation */ 802 dm_send_msg(sid, DM_MSGTYPE_SYNC, MSG_DATALEN, buf); 803 pthread_join(tid, NULL); 804 } 805 } 806 807 szFuncName = "dm_move_event"; 808 809 /* 810 * TEST : dm_move_event - invalid srcsid 811 * EXPECTED: rc = -1, errno = EINVAL 812 */ 813 if (DMVAR_EXEC(MOVE_EVENT_BASE + 1)) { 814 dm_sessid_t targsid; 815 dm_token_t token, rtoken; 816 char buf[MSG_DATALEN]; 817 818 /* Variation set up */ 819 memcpy(buf, MSG_DATA, MSG_DATALEN); 820 if ((rc = 821 dm_create_session(DM_NO_SESSION, szSessionInfo, 822 &targsid)) == -1) { 823 /* No clean up */ 824 } else 825 if ((rc = 826 dm_create_userevent(sid, MSG_DATALEN, buf, 827 &token)) == -1) { 828 dm_destroy_session(targsid); 829 } 830 if (rc == -1) { 831 DMLOG_PRINT(DMLVL_DEBUG, 832 "Unable to set up variation! (errno = %d)\n", 833 errno); 834 DMVAR_SKIP(); 835 } else { 836 /* Variation */ 837 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid srcsid)\n", 838 szFuncName); 839 rc = dm_move_event(INVALID_ADDR, token, targsid, 840 &rtoken); 841 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 842 843 /* Variation clean up */ 844 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 845 0, NULL); 846 rc |= dm_destroy_session(targsid); 847 if (rc == -1) { 848 DMLOG_PRINT(DMLVL_DEBUG, 849 "Unable to clean up variation! (errno = %d)\n", 850 errno); 851 } 852 } 853 } 854 855 /* 856 * TEST : dm_move_event - DM_NO_SESSION srcsid 857 * EXPECTED: rc = -1, errno = EINVAL 858 */ 859 if (DMVAR_EXEC(MOVE_EVENT_BASE + 2)) { 860 dm_sessid_t targsid; 861 dm_token_t token, rtoken; 862 char buf[MSG_DATALEN]; 863 864 /* Variation set up */ 865 memcpy(buf, MSG_DATA, MSG_DATALEN); 866 if ((rc = 867 dm_create_session(DM_NO_SESSION, szSessionInfo, 868 &targsid)) == -1) { 869 /* No clean up */ 870 } else 871 if ((rc = 872 dm_create_userevent(sid, MSG_DATALEN, buf, 873 &token)) == -1) { 874 dm_destroy_session(targsid); 875 } 876 if (rc == -1) { 877 DMLOG_PRINT(DMLVL_DEBUG, 878 "Unable to set up variation! (errno = %d)\n", 879 errno); 880 DMVAR_SKIP(); 881 } else { 882 /* Variation */ 883 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION srcsid)\n", 884 szFuncName); 885 rc = dm_move_event(DM_NO_SESSION, token, targsid, 886 &rtoken); 887 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 888 889 /* Variation clean up */ 890 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 891 0, NULL); 892 rc |= dm_destroy_session(targsid); 893 if (rc == -1) { 894 DMLOG_PRINT(DMLVL_DEBUG, 895 "Unable to clean up variation! (errno = %d)\n", 896 errno); 897 } 898 } 899 } 900 901 /* 902 * TEST : dm_move_event - invalid token 903 * EXPECTED: rc = -1, errno = EINVAL 904 */ 905 if (DMVAR_EXEC(MOVE_EVENT_BASE + 3)) { 906 dm_sessid_t targsid; 907 dm_token_t token, rtoken; 908 char buf[MSG_DATALEN]; 909 910 /* Variation set up */ 911 memcpy(buf, MSG_DATA, MSG_DATALEN); 912 if ((rc = 913 dm_create_session(DM_NO_SESSION, szSessionInfo, 914 &targsid)) == -1) { 915 /* No clean up */ 916 } else 917 if ((rc = 918 dm_create_userevent(sid, MSG_DATALEN, buf, 919 &token)) == -1) { 920 dm_destroy_session(targsid); 921 } 922 if (rc == -1) { 923 DMLOG_PRINT(DMLVL_DEBUG, 924 "Unable to set up variation! (errno = %d)\n", 925 errno); 926 DMVAR_SKIP(); 927 } else { 928 /* Variation */ 929 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", 930 szFuncName); 931 rc = dm_move_event(sid, INVALID_ADDR, targsid, &rtoken); 932 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 933 934 /* Variation clean up */ 935 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 936 0, NULL); 937 rc |= dm_destroy_session(targsid); 938 if (rc == -1) { 939 DMLOG_PRINT(DMLVL_DEBUG, 940 "Unable to clean up variation! (errno = %d)\n", 941 errno); 942 } 943 } 944 } 945 946 /* 947 * TEST : dm_move_event - invalid targetsid 948 * EXPECTED: rc = -1, errno = EINVAL 949 */ 950 if (DMVAR_EXEC(MOVE_EVENT_BASE + 4)) { 951 dm_sessid_t targsid; 952 dm_token_t token, rtoken; 953 char buf[MSG_DATALEN]; 954 955 /* Variation set up */ 956 memcpy(buf, MSG_DATA, MSG_DATALEN); 957 if ((rc = 958 dm_create_session(DM_NO_SESSION, szSessionInfo, 959 &targsid)) == -1) { 960 /* No clean up */ 961 } else 962 if ((rc = 963 dm_create_userevent(sid, MSG_DATALEN, buf, 964 &token)) == -1) { 965 dm_destroy_session(targsid); 966 } 967 if (rc == -1) { 968 DMLOG_PRINT(DMLVL_DEBUG, 969 "Unable to set up variation! (errno = %d)\n", 970 errno); 971 DMVAR_SKIP(); 972 } else { 973 /* Variation */ 974 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid targetsid)\n", 975 szFuncName); 976 rc = dm_move_event(sid, token, INVALID_ADDR, &rtoken); 977 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 978 979 /* Variation clean up */ 980 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 981 0, NULL); 982 rc |= dm_destroy_session(targsid); 983 if (rc == -1) { 984 DMLOG_PRINT(DMLVL_DEBUG, 985 "Unable to clean up variation! (errno = %d)\n", 986 errno); 987 } 988 } 989 } 990 991 /* 992 * TEST : dm_move_event - DM_NO_SESSION targetsid 993 * EXPECTED: rc = -1, errno = EINVAL 994 */ 995 if (DMVAR_EXEC(MOVE_EVENT_BASE + 5)) { 996 dm_sessid_t targsid; 997 dm_token_t token, rtoken; 998 char buf[MSG_DATALEN]; 999 1000 /* Variation set up */ 1001 memcpy(buf, MSG_DATA, MSG_DATALEN); 1002 if ((rc = 1003 dm_create_session(DM_NO_SESSION, szSessionInfo, 1004 &targsid)) == -1) { 1005 /* No clean up */ 1006 } else 1007 if ((rc = 1008 dm_create_userevent(sid, MSG_DATALEN, buf, 1009 &token)) == -1) { 1010 dm_destroy_session(targsid); 1011 } 1012 if (rc == -1) { 1013 DMLOG_PRINT(DMLVL_DEBUG, 1014 "Unable to set up variation! (errno = %d)\n", 1015 errno); 1016 DMVAR_SKIP(); 1017 } else { 1018 /* Variation */ 1019 DMLOG_PRINT(DMLVL_DEBUG, 1020 "%s(DM_NO_SESSION targetsid)\n", 1021 szFuncName); 1022 rc = dm_move_event(sid, token, DM_NO_SESSION, &rtoken); 1023 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1024 1025 /* Variation clean up */ 1026 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1027 0, NULL); 1028 rc |= dm_destroy_session(targsid); 1029 if (rc == -1) { 1030 DMLOG_PRINT(DMLVL_DEBUG, 1031 "Unable to clean up variation! (errno = %d)\n", 1032 errno); 1033 } 1034 } 1035 } 1036 1037 /* 1038 * TEST : dm_move_event - invalid rtokenp 1039 * EXPECTED: rc = -1, errno = EFAULT 1040 * 1041 * This variation uncovered XFS BUG #36 (event moved to targetsid 1042 * despite failure) 1043 */ 1044 if (DMVAR_EXEC(MOVE_EVENT_BASE + 6)) { 1045 dm_sessid_t targsid; 1046 dm_token_t token; 1047 char buf[MSG_DATALEN]; 1048 1049 /* Variation set up */ 1050 memcpy(buf, MSG_DATA, MSG_DATALEN); 1051 if ((rc = 1052 dm_create_session(DM_NO_SESSION, szSessionInfo, 1053 &targsid)) == -1) { 1054 /* No clean up */ 1055 } else 1056 if ((rc = 1057 dm_create_userevent(sid, MSG_DATALEN, buf, 1058 &token)) == -1) { 1059 dm_destroy_session(targsid); 1060 } 1061 if (rc == -1) { 1062 DMLOG_PRINT(DMLVL_DEBUG, 1063 "Unable to set up variation! (errno = %d)\n", 1064 errno); 1065 DMVAR_SKIP(); 1066 } else { 1067 /* Variation */ 1068 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid rtokenp)\n", 1069 szFuncName); 1070 rc = dm_move_event(sid, token, targsid, 1071 (dm_token_t *) INVALID_ADDR); 1072 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1073 1074 /* Variation clean up */ 1075 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1076 0, NULL); 1077 rc |= dm_destroy_session(targsid); 1078 if (rc == -1) { 1079 DMLOG_PRINT(DMLVL_DEBUG, 1080 "Unable to clean up variation! (errno = %d)\n", 1081 errno); 1082 } 1083 } 1084 } 1085 1086 /* 1087 * TEST : dm_move_event - token not in session 1088 * EXPECTED: rc = -1, errno = ENOENT 1089 * 1090 * This variation uncovered XFS BUG #34 (ESRCH returned instead of 1091 * ENOENT) 1092 */ 1093 if (DMVAR_EXEC(MOVE_EVENT_BASE + 7)) { 1094 dm_sessid_t targsid; 1095 dm_token_t token, rtoken; 1096 char buf[MSG_DATALEN]; 1097 1098 /* Variation set up */ 1099 memcpy(buf, MSG_DATA, MSG_DATALEN); 1100 if ((rc = 1101 dm_create_session(DM_NO_SESSION, szSessionInfo, 1102 &targsid)) == -1) { 1103 /* No clean up */ 1104 } else 1105 if ((rc = 1106 dm_create_userevent(sid, MSG_DATALEN, buf, 1107 &token)) == -1) { 1108 dm_destroy_session(targsid); 1109 } 1110 if (rc == -1) { 1111 DMLOG_PRINT(DMLVL_DEBUG, 1112 "Unable to set up variation! (errno = %d)\n", 1113 errno); 1114 DMVAR_SKIP(); 1115 } else { 1116 /* Variation */ 1117 DMLOG_PRINT(DMLVL_DEBUG, "%s(token not in session)\n", 1118 szFuncName); 1119 rc = dm_move_event(targsid, token, sid, &rtoken); 1120 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ENOENT); 1121 1122 /* Variation clean up */ 1123 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1124 0, NULL); 1125 rc |= dm_destroy_session(targsid); 1126 if (rc == -1) { 1127 DMLOG_PRINT(DMLVL_DEBUG, 1128 "Unable to clean up variation! (errno = %d)\n", 1129 errno); 1130 } 1131 } 1132 } 1133 1134 /* 1135 * TEST : dm_move_event - srcsid == targetsid 1136 * EXPECTED: rc = 0 1137 */ 1138 if (DMVAR_EXEC(MOVE_EVENT_BASE + 8)) { 1139 dm_sessid_t targsid; 1140 dm_token_t token, rtoken; 1141 char buf[MSG_DATALEN]; 1142 size_t rlen; 1143 1144 /* Variation set up */ 1145 memcpy(buf, MSG_DATA, MSG_DATALEN); 1146 if ((rc = 1147 dm_create_session(DM_NO_SESSION, szSessionInfo, 1148 &targsid)) == -1) { 1149 /* No clean up */ 1150 } else 1151 if ((rc = 1152 dm_create_userevent(sid, MSG_DATALEN, buf, 1153 &token)) == -1) { 1154 dm_destroy_session(targsid); 1155 } 1156 if (rc == -1) { 1157 DMLOG_PRINT(DMLVL_DEBUG, 1158 "Unable to set up variation! (errno = %d)\n", 1159 errno); 1160 DMVAR_SKIP(); 1161 } else { 1162 /* Variation */ 1163 DMLOG_PRINT(DMLVL_DEBUG, "%s(srcsid == targetsid)\n", 1164 szFuncName); 1165 rc = dm_move_event(sid, token, sid, &rtoken); 1166 if (rc == 0) { 1167 DMLOG_PRINT(DMLVL_DEBUG, "rtoken = %d\n", 1168 rtoken); 1169 rc = dm_find_eventmsg(sid, rtoken, 1170 sizeof(dmMsgBuf), 1171 dmMsgBuf, &rlen); 1172 if (rc == 0 && rlen > 0) { 1173 DMLOG_PRINT(DMLVL_DEBUG, 1174 "%s passed with expected rc = %d\n", 1175 szFuncName, 0); 1176 DMVAR_PASS(); 1177 } else { 1178 DMLOG_PRINT(DMLVL_ERR, 1179 "%s failed with expected rc = %d but token %d NOT in src/target session %d\n", 1180 szFuncName, 0, token, sid); 1181 DMVAR_FAIL(); 1182 } 1183 } else { 1184 DMLOG_PRINT(DMLVL_ERR, 1185 "%s failed with unexpected rc = %d (errno = %d)\n", 1186 szFuncName, rc, errno); 1187 DMVAR_FAIL(); 1188 } 1189 1190 /* Variation clean up */ 1191 rc = dm_respond_event(sid, rtoken, DM_RESP_CONTINUE, 0, 1192 0, NULL); 1193 rc |= dm_destroy_session(targsid); 1194 if (rc == -1) { 1195 DMLOG_PRINT(DMLVL_DEBUG, 1196 "Unable to clean up variation! (errno = %d)\n", 1197 errno); 1198 } 1199 } 1200 } 1201 1202 /* 1203 * TEST : dm_move_event - srcsid != targetsid 1204 * EXPECTED: rc = 0 1205 * 1206 * This variation uncovered XFS BUG #35 (ESRCH returned instead of 1207 * EINVAL) 1208 */ 1209 if (DMVAR_EXEC(MOVE_EVENT_BASE + 9)) { 1210 dm_sessid_t targsid; 1211 dm_token_t token, rtoken; 1212 char buf[MSG_DATALEN]; 1213 size_t rlen; 1214 1215 /* Variation set up */ 1216 memcpy(buf, MSG_DATA, MSG_DATALEN); 1217 if ((rc = 1218 dm_create_session(DM_NO_SESSION, szSessionInfo, 1219 &targsid)) == -1) { 1220 /* No clean up */ 1221 } else 1222 if ((rc = 1223 dm_create_userevent(sid, MSG_DATALEN, buf, 1224 &token)) == -1) { 1225 dm_destroy_session(targsid); 1226 } 1227 if (rc == -1) { 1228 DMLOG_PRINT(DMLVL_DEBUG, 1229 "Unable to set up variation! (errno = %d)\n", 1230 errno); 1231 DMVAR_SKIP(); 1232 } else { 1233 /* Variation */ 1234 DMLOG_PRINT(DMLVL_DEBUG, "%s(srcsid != targetsid)\n", 1235 szFuncName); 1236 rc = dm_move_event(sid, token, targsid, &rtoken); 1237 if (rc == 0) { 1238 DMLOG_PRINT(DMLVL_DEBUG, "rtoken = %d\n", 1239 rtoken); 1240 rc = dm_find_eventmsg(sid, token, 1241 sizeof(dmMsgBuf), 1242 dmMsgBuf, &rlen); 1243 if (rc == -1 && errno == EINVAL) { 1244 rc = dm_find_eventmsg(targsid, rtoken, 1245 sizeof(dmMsgBuf), 1246 dmMsgBuf, &rlen); 1247 if (rc == 0 && rlen > 0) { 1248 DMLOG_PRINT(DMLVL_DEBUG, 1249 "%s passed with expected rc = %d\n", 1250 szFuncName, 0); 1251 DMVAR_PASS(); 1252 } else { 1253 DMLOG_PRINT(DMLVL_ERR, 1254 "%s failed with expected rc = %d but token %d NOT in target session %d\n", 1255 szFuncName, 0, 1256 token, targsid); 1257 DMVAR_FAIL(); 1258 } 1259 } else { 1260 DMLOG_PRINT(DMLVL_ERR, 1261 "%s failed with expected rc = %d but token %d still in source session %d\n", 1262 szFuncName, 0, token, sid); 1263 DMVAR_FAIL(); 1264 } 1265 } else { 1266 DMLOG_PRINT(DMLVL_ERR, 1267 "%s failed with unexpected rc = %d (errno = %d)\n", 1268 szFuncName, rc, errno); 1269 DMVAR_FAIL(); 1270 } 1271 1272 /* Variation clean up */ 1273 rc = dm_respond_event(targsid, rtoken, DM_RESP_CONTINUE, 1274 0, 0, NULL); 1275 rc |= dm_destroy_session(targsid); 1276 if (rc == -1) { 1277 DMLOG_PRINT(DMLVL_DEBUG, 1278 "Unable to clean up variation! (errno = %d)\n", 1279 errno); 1280 } 1281 } 1282 } 1283 1284 szFuncName = "dm_pending"; 1285 1286 /* 1287 * TEST : dm_pending - invalid sid 1288 * EXPECTED: rc = -1, errno = EINVAL 1289 */ 1290 if (DMVAR_EXEC(PENDING_BASE + 1)) { 1291 char buf[MSG_DATALEN]; 1292 dm_token_t token; 1293 dm_timestruct_t delay; 1294 1295 /* Variation set up */ 1296 memcpy(buf, MSG_DATA, MSG_DATALEN); 1297 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 1298 if (rc == -1) { 1299 DMLOG_PRINT(DMLVL_DEBUG, 1300 "Unable to set up variation! (errno = %d)\n", 1301 errno); 1302 DMVAR_SKIP(); 1303 } else { 1304 /* Variation */ 1305 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n", 1306 szFuncName); 1307 rc = dm_pending(INVALID_ADDR, token, &delay); 1308 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1309 1310 /* Variation clean up */ 1311 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1312 0, NULL); 1313 if (rc == -1) { 1314 DMLOG_PRINT(DMLVL_DEBUG, 1315 "Unable to clean up variation! (errno = %d)\n", 1316 errno); 1317 } 1318 } 1319 } 1320 1321 /* 1322 * TEST : dm_pending - DM_NO_SESSION sid 1323 * EXPECTED: rc = -1, errno = EINVAL 1324 */ 1325 if (DMVAR_EXEC(PENDING_BASE + 2)) { 1326 char buf[MSG_DATALEN]; 1327 dm_token_t token; 1328 dm_timestruct_t delay; 1329 1330 /* Variation set up */ 1331 memcpy(buf, MSG_DATA, MSG_DATALEN); 1332 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 1333 if (rc == -1) { 1334 DMLOG_PRINT(DMLVL_DEBUG, 1335 "Unable to set up variation! (errno = %d)\n", 1336 errno); 1337 DMVAR_SKIP(); 1338 } else { 1339 /* Variation */ 1340 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 1341 szFuncName); 1342 rc = dm_pending(DM_NO_SESSION, token, &delay); 1343 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1344 1345 /* Variation clean up */ 1346 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1347 0, NULL); 1348 if (rc == -1) { 1349 DMLOG_PRINT(DMLVL_DEBUG, 1350 "Unable to clean up variation! (errno = %d)\n", 1351 errno); 1352 } 1353 } 1354 } 1355 1356 /* 1357 * TEST : dm_pending - invalid token 1358 * EXPECTED: rc = -1, errno = EINVAL 1359 */ 1360 if (DMVAR_EXEC(PENDING_BASE + 3)) { 1361 dm_timestruct_t delay; 1362 1363 /* Variation set up */ 1364 1365 /* Variation */ 1366 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n", szFuncName); 1367 rc = dm_pending(sid, INVALID_ADDR, &delay); 1368 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1369 1370 /* Variation clean up */ 1371 } 1372 1373 /* 1374 * TEST : dm_pending - DM_NO_TOKEN token 1375 * EXPECTED: rc = -1, errno = EINVAL 1376 */ 1377 if (DMVAR_EXEC(PENDING_BASE + 4)) { 1378 dm_timestruct_t delay; 1379 1380 /* Variation set up */ 1381 1382 /* Variation */ 1383 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_TOKEN token)\n", szFuncName); 1384 rc = dm_pending(sid, DM_NO_TOKEN, &delay); 1385 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1386 1387 /* Variation clean up */ 1388 } 1389 1390 /* 1391 * TEST : dm_pending - DM_INVALID_TOKEN token 1392 * EXPECTED: rc = -1, errno = EINVAL 1393 */ 1394 if (DMVAR_EXEC(PENDING_BASE + 5)) { 1395 dm_timestruct_t delay; 1396 1397 /* Variation set up */ 1398 1399 /* Variation */ 1400 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_INVALID_TOKEN token)\n", 1401 szFuncName); 1402 rc = dm_pending(sid, DM_INVALID_TOKEN, &delay); 1403 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1404 1405 /* Variation clean up */ 1406 } 1407 1408 /* 1409 * TEST : dm_pending - invalid delay 1410 * EXPECTED: rc = -1, errno = EFAULT 1411 */ 1412 if (DMVAR_EXEC(PENDING_BASE + 6)) { 1413 char buf[MSG_DATALEN]; 1414 dm_token_t token; 1415 1416 /* Variation set up */ 1417 memcpy(buf, MSG_DATA, MSG_DATALEN); 1418 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 1419 if (rc == -1) { 1420 DMLOG_PRINT(DMLVL_DEBUG, 1421 "Unable to set up variation! (errno = %d)\n", 1422 errno); 1423 DMVAR_SKIP(); 1424 } else { 1425 /* Variation */ 1426 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n", 1427 szFuncName); 1428 rc = dm_pending(sid, token, 1429 (dm_timestruct_t *) INVALID_ADDR); 1430 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1431 1432 /* Variation clean up */ 1433 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1434 0, NULL); 1435 if (rc == -1) { 1436 DMLOG_PRINT(DMLVL_DEBUG, 1437 "Unable to clean up variation! (errno = %d)\n", 1438 errno); 1439 } 1440 } 1441 } 1442 1443 /* 1444 * TEST : dm_respond_event - invalidated token 1445 * EXPECTED: rc = -1, errno = ESRCH 1446 */ 1447 if (DMVAR_EXEC(PENDING_BASE + 7)) { 1448 char buf[MSG_DATALEN]; 1449 dm_token_t token; 1450 dm_timestruct_t delay; 1451 1452 /* Variation set up */ 1453 memcpy(buf, MSG_DATA, MSG_DATALEN); 1454 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 1455 if (rc != -1) { 1456 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1457 sizeof(buf), buf); 1458 } 1459 if (rc == -1) { 1460 DMLOG_PRINT(DMLVL_DEBUG, 1461 "Unable to set up variation! (errno = %d)\n", 1462 errno); 1463 DMVAR_SKIP(); 1464 } else { 1465 /* Variation */ 1466 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated token)\n", 1467 szFuncName); 1468 rc = dm_pending(sid, token, &delay); 1469 DMVAR_ENDFAILEXP(szFuncName, -1, rc, ESRCH); 1470 1471 /* Variation clean up */ 1472 } 1473 } 1474 1475 /* 1476 * TEST : dm_pending - valid 1477 * EXPECTED: rc = 0 1478 */ 1479 if (DMVAR_EXEC(PENDING_BASE + 8)) { 1480 char buf[MSG_DATALEN]; 1481 dm_token_t token; 1482 dm_timestruct_t delay; 1483 1484 /* Variation set up */ 1485 memcpy(buf, MSG_DATA, MSG_DATALEN); 1486 rc = dm_create_userevent(sid, MSG_DATALEN, buf, &token); 1487 if (rc == -1) { 1488 DMLOG_PRINT(DMLVL_DEBUG, 1489 "Unable to set up variation! (errno = %d)\n", 1490 errno); 1491 DMVAR_SKIP(); 1492 } else { 1493 /* Variation */ 1494 DMLOG_PRINT(DMLVL_DEBUG, "%s(valid)\n", szFuncName); 1495 rc = dm_pending(sid, token, &delay); 1496 DMVAR_ENDPASSEXP(szFuncName, 0, rc); 1497 1498 /* Variation clean up */ 1499 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1500 0, NULL); 1501 if (rc == -1) { 1502 DMLOG_PRINT(DMLVL_DEBUG, 1503 "Unable to clean up variation! (errno = %d)\n", 1504 errno); 1505 } 1506 } 1507 } 1508 1509 rc = dm_destroy_session(sid); 1510 if (rc == -1) { 1511 DMLOG_PRINT(DMLVL_ERR, 1512 "dm_destroy_session failed! (rc = %d, errno = %d)\n", 1513 rc, errno); 1514 } 1515 1516 DMLOG_STOP(); 1517 1518 tst_exit(); 1519} 1520 1521void *Thread(void *parm) 1522{ 1523 int rc; 1524 dm_token_t token; 1525 size_t rlen; 1526 dm_eventmsg_t *dmMsg; 1527 int numMsg; 1528 1529 EVENT_DELIVERY_DELAY; 1530 1531 switch ((long)parm) { 1532 case GET_EVENTS_BASE + 2: 1533 /* Variation */ 1534 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid buflen)\n", szFuncName); 1535 rc = dm_get_events(sid, MAX_EVENT, 0, 0, dmMsgBuf, &rlen); 1536 DMVAR_ENDFAILEXP(szFuncName, -1, rc, E2BIG); 1537 1538 /* Variation clean up */ 1539 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1540 dmMsgBuf, &rlen); 1541 if (rc == 0) { 1542 token = ((dm_eventmsg_t *) dmMsgBuf)->ev_token; 1543 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1544 0, NULL); 1545 } 1546 if (rc == -1) { 1547 DMLOG_PRINT(DMLVL_DEBUG, 1548 "Unable to clean up variation! (errno = %d)\n", 1549 errno); 1550 } 1551 break; 1552 1553 case GET_EVENTS_BASE + 3: 1554 /* Variation */ 1555 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid bufp)\n", szFuncName); 1556 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1557 (void *)INVALID_ADDR, &rlen); 1558 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1559 1560 /* Variation clean up */ 1561 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1562 dmMsgBuf, &rlen); 1563 if (rc == 0) { 1564 token = ((dm_eventmsg_t *) dmMsgBuf)->ev_token; 1565 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1566 0, NULL); 1567 } 1568 if (rc == -1) { 1569 DMLOG_PRINT(DMLVL_DEBUG, 1570 "Unable to clean up variation! (errno = %d)\n", 1571 errno); 1572 } 1573 break; 1574 1575 case GET_EVENTS_BASE + 4: 1576 /* Variation */ 1577 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid rlenp)\n", szFuncName); 1578 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1579 dmMsgBuf, (size_t *) INVALID_ADDR); 1580 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT); 1581 1582 /* Variation clean up */ 1583 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1584 dmMsgBuf, &rlen); 1585 if (rc == 0) { 1586 token = ((dm_eventmsg_t *) dmMsgBuf)->ev_token; 1587 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 1588 0, NULL); 1589 } 1590 if (rc == -1) { 1591 DMLOG_PRINT(DMLVL_DEBUG, 1592 "Unable to clean up variation! (errno = %d)\n", 1593 errno); 1594 } 1595 break; 1596 1597 case GET_EVENTS_BASE + 5: 1598 /* Variation */ 1599 DMLOG_PRINT(DMLVL_DEBUG, "%s(!DM_EV_WAIT with no messages)\n", 1600 szFuncName); 1601 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1602 dmMsgBuf, &rlen); 1603 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EAGAIN); 1604 1605 /* Variation clean up */ 1606 1607 break; 1608 1609 case GET_EVENTS_BASE + 6: 1610 case GET_EVENTS_BASE + 7: 1611 case GET_EVENTS_BASE + 8: 1612 case GET_EVENTS_BASE + 9: 1613 /* Variation */ 1614 DMLOG_PRINT(DMLVL_DEBUG, "%s(%s with %d message(s))\n", 1615 szFuncName, 1616 (eventsFlags & DM_EV_WAIT) ? "DM_EV_WAIT" : 1617 "!DM_EV_WAIT", expectedNumMsg); 1618 do { 1619 rlen = 0; 1620 rc = dm_get_events(sid, MAX_EVENT, eventsFlags, 1621 sizeof(dmMsgBuf), dmMsgBuf, &rlen); 1622 } while ((eventsFlags & DM_EV_WAIT) && (rc == -1) 1623 && (errno == EINTR) && (rlen == 0)); 1624 if (rc == 0) { 1625 LogEventMsgs(dmMsgBuf); 1626 numMsg = GetNumEventMsg(dmMsgBuf); 1627 dmMsg = GetSyncEventMsg(dmMsgBuf); 1628 DMLOG_PRINT(DMLVL_DEBUG, "rlen = %d\n", rlen); 1629 1630 if (numMsg == expectedNumMsg) { 1631 if (dmMsg != NULL) { 1632 if (dmMsg->ev_type == DM_EVENT_USER) { 1633 DMLOG_PRINT(DMLVL_DEBUG, 1634 "%s passed with expected rc = %d\n", 1635 szFuncName, 0); 1636 DMVAR_PASS(); 1637 } else { 1638 DMLOG_PRINT(DMLVL_ERR, 1639 "%s failed with expected rc = %d but unexpected event (%d vs %d)\n", 1640 szFuncName, 0, 1641 dmMsg->ev_type, 1642 DM_EVENT_USER); 1643 DMVAR_FAIL(); 1644 } 1645 } else { 1646 DMLOG_PRINT(DMLVL_ERR, 1647 "%s failed with expected rc = %d but no synchronous event\n", 1648 szFuncName, 0); 1649 DMVAR_FAIL(); 1650 } 1651 } else { 1652 DMLOG_PRINT(DMLVL_ERR, 1653 "%s failed with expected rc = %d but unexpected number of events (%d vs %d)\n", 1654 szFuncName, 0, numMsg, 1655 expectedNumMsg); 1656 DMVAR_FAIL(); 1657 } 1658 } else { 1659 dmMsg = NULL; 1660 DMLOG_PRINT(DMLVL_ERR, 1661 "%s failed with unexpected rc = %d (errno = %d)\n", 1662 szFuncName, rc, errno); 1663 DMVAR_FAIL(); 1664 } 1665 1666 /* Variation clean up */ 1667 rc = dm_respond_event(sid, 1668 dmMsg ? dmMsg-> 1669 ev_token : DM_INVALID_TOKEN, 1670 DM_RESP_CONTINUE, 0, 0, NULL); 1671 if (rc == -1) { 1672 DMLOG_PRINT(DMLVL_DEBUG, 1673 "Unable to clean up variation! (errno = %d)\n", 1674 errno); 1675 } 1676 1677 break; 1678 1679 case GET_EVENTS_BASE + 10: 1680 /* Variation */ 1681 DMLOG_PRINT(DMLVL_DEBUG, "%s(%s with %d messages)\n", 1682 szFuncName, 1683 (eventsFlags & DM_EV_WAIT) ? "DM_EV_WAIT" : 1684 "!DM_EV_WAIT", expectedNumMsg); 1685 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1686 dmMsgBuf, &rlen); 1687 if (rc == 0) { 1688 DMLOG_PRINT(DMLVL_DEBUG, "1st call:\n"); 1689 LogEventMsgs(dmMsgBuf); 1690 numMsg = GetNumEventMsg(dmMsgBuf); 1691 DMLOG_PRINT(DMLVL_DEBUG, "rlen = %d\n", rlen); 1692 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1693 dmMsgBuf, &rlen); 1694 if (rc == 0) { 1695 DMLOG_PRINT(DMLVL_DEBUG, "2nd call:\n"); 1696 DMLOG_PRINT(DMLVL_DEBUG, "rlen = %d\n", rlen); 1697 LogEventMsgs(dmMsgBuf); 1698 dmMsg = GetSyncEventMsg(dmMsgBuf); 1699 1700 if (numMsg == expectedNumMsg) { 1701 if (dmMsg != NULL) { 1702 if (dmMsg->ev_type == 1703 DM_EVENT_USER) { 1704 DMLOG_PRINT(DMLVL_DEBUG, 1705 "%s passed with expected rc = %d\n", 1706 szFuncName, 1707 0); 1708 DMVAR_PASS(); 1709 } else { 1710 DMLOG_PRINT(DMLVL_ERR, 1711 "%s failed with expected rc = %d but unexpected event (%d vs %d)\n", 1712 szFuncName, 1713 0, 1714 dmMsg-> 1715 ev_type, 1716 DM_EVENT_USER); 1717 DMVAR_FAIL(); 1718 } 1719 } else { 1720 DMLOG_PRINT(DMLVL_ERR, 1721 "%s failed with expected rc = %d but no synchronous event\n", 1722 szFuncName, 0); 1723 DMVAR_FAIL(); 1724 } 1725 } else { 1726 DMLOG_PRINT(DMLVL_ERR, 1727 "%s failed with expected rc = %d but unexpected number of events (%d vs %d)\n", 1728 szFuncName, 0, numMsg, 1729 expectedNumMsg); 1730 DMVAR_FAIL(); 1731 } 1732 } else { 1733 dmMsg = NULL; 1734 DMLOG_PRINT(DMLVL_ERR, 1735 "%s 2nd call failed with unexpected rc = %d (errno = %d)\n", 1736 szFuncName, rc, errno); 1737 DMVAR_FAIL(); 1738 } 1739 } else { 1740 dmMsg = NULL; 1741 DMLOG_PRINT(DMLVL_ERR, 1742 "%s 1st call failed with unexpected rc = %d (errno = %d)\n", 1743 szFuncName, rc, errno); 1744 DMVAR_FAIL(); 1745 } 1746 1747 /* Variation clean up */ 1748 rc = dm_respond_event(sid, 1749 dmMsg ? dmMsg-> 1750 ev_token : DM_INVALID_TOKEN, 1751 DM_RESP_CONTINUE, 0, 0, NULL); 1752 if (rc == -1) { 1753 DMLOG_PRINT(DMLVL_DEBUG, 1754 "Unable to clean up variation! (errno = %d)\n", 1755 errno); 1756 } 1757 1758 break; 1759 1760 case RESPOND_EVENT_BASE + 9: 1761 /* Variation */ 1762 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_RESP_INVALID)\n", szFuncName); 1763 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1764 dmMsgBuf, &rlen); 1765 if (rc == 0 && ((dmMsg = GetSyncEventMsg(dmMsgBuf)) != NULL)) { 1766 rc = dm_respond_event(sid, dmMsg->ev_token, 1767 DM_RESP_INVALID, 0, 0, NULL); 1768 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1769 1770 /* Variation clean up */ 1771 rc = dm_respond_event(sid, dmMsg->ev_token, 1772 DM_RESP_CONTINUE, 0, 0, NULL); 1773 if (rc == -1) { 1774 DMLOG_PRINT(DMLVL_DEBUG, 1775 "Unable to clean up variation! (errno = %d)\n", 1776 errno); 1777 } 1778 } else { 1779 DMLOG_PRINT(DMLVL_ERR, 1780 "Unable to obtain synchronous event! (rc = %d, errno = %d)\n", 1781 rc, errno); 1782 } 1783 break; 1784 1785 case RESPOND_EVENT_BASE + 10: 1786 /* Variation */ 1787 DMLOG_PRINT(DMLVL_DEBUG, 1788 "%s(DM_RESP_CONTINUE with zero reterror)\n", 1789 szFuncName); 1790 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1791 dmMsgBuf, &rlen); 1792 if (rc == 0 && ((dmMsg = GetSyncEventMsg(dmMsgBuf)) != NULL)) { 1793 rcRespond = 1794 dm_respond_event(sid, dmMsg->ev_token, 1795 DM_RESP_CONTINUE, 0, 0, NULL); 1796 errnoRespond = rcRespond == -1 ? errno : 0; 1797 } else { 1798 DMLOG_PRINT(DMLVL_ERR, 1799 "Unable to obtain synchronous event! (rc = %d, errno = %d)\n", 1800 rc, errno); 1801 } 1802 break; 1803 1804 case RESPOND_EVENT_BASE + 11: 1805 /* Variation */ 1806 DMLOG_PRINT(DMLVL_DEBUG, 1807 "%s(DM_RESP_CONTINUE with non-zero reterror)\n", 1808 szFuncName); 1809 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1810 dmMsgBuf, &rlen); 1811 if (rc == 0 && ((dmMsg = GetSyncEventMsg(dmMsgBuf)) != NULL)) { 1812 rc = dm_respond_event(sid, dmMsg->ev_token, 1813 DM_RESP_CONTINUE, ABORT_ERRNO, 0, 1814 NULL); 1815 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1816 1817 /* Variation clean up */ 1818 rc = dm_respond_event(sid, dmMsg->ev_token, 1819 DM_RESP_CONTINUE, 0, 0, NULL); 1820 if (rc == -1) { 1821 DMLOG_PRINT(DMLVL_DEBUG, 1822 "Unable to clean up variation! (errno = %d)\n", 1823 errno); 1824 } 1825 } else { 1826 DMLOG_PRINT(DMLVL_ERR, 1827 "Unable to obtain synchronous event! (rc = %d, errno = %d)\n", 1828 rc, errno); 1829 } 1830 break; 1831 1832 case RESPOND_EVENT_BASE + 12: 1833 /* Variation */ 1834 DMLOG_PRINT(DMLVL_DEBUG, 1835 "%s(DM_RESP_ABORT with zero reterror)\n", 1836 szFuncName); 1837 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1838 dmMsgBuf, &rlen); 1839 if (rc == 0 && ((dmMsg = GetSyncEventMsg(dmMsgBuf)) != NULL)) { 1840 rc = dm_respond_event(sid, dmMsg->ev_token, 1841 DM_RESP_ABORT, 0, 0, NULL); 1842 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1843 1844 /* Variation clean up */ 1845 rc = dm_respond_event(sid, dmMsg->ev_token, 1846 DM_RESP_CONTINUE, 0, 0, NULL); 1847 if (rc == -1) { 1848 DMLOG_PRINT(DMLVL_DEBUG, 1849 "Unable to clean up variation! (errno = %d)\n", 1850 errno); 1851 } 1852 } else { 1853 DMLOG_PRINT(DMLVL_ERR, 1854 "Unable to obtain synchronous event! (rc = %d, errno = %d)\n", 1855 rc, errno); 1856 } 1857 break; 1858 1859 case RESPOND_EVENT_BASE + 13: 1860 /* Variation */ 1861 DMLOG_PRINT(DMLVL_DEBUG, 1862 "%s(DM_RESP_ABORT with non-zero reterror)\n", 1863 szFuncName); 1864 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1865 dmMsgBuf, &rlen); 1866 if (rc == 0 && ((dmMsg = GetSyncEventMsg(dmMsgBuf)) != NULL)) { 1867 rcRespond = 1868 dm_respond_event(sid, dmMsg->ev_token, 1869 DM_RESP_ABORT, ABORT_ERRNO, 0, 1870 NULL); 1871 errnoRespond = rcRespond == -1 ? errno : 0; 1872 } else { 1873 DMLOG_PRINT(DMLVL_ERR, 1874 "Unable to obtain synchronous event! (rc = %d, errno = %d)\n", 1875 rc, errno); 1876 } 1877 break; 1878 1879 case RESPOND_EVENT_BASE + 14: 1880 /* Variation */ 1881 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_RESP_DONTCARE)\n", szFuncName); 1882 rc = dm_get_events(sid, MAX_EVENT, 0, sizeof(dmMsgBuf), 1883 dmMsgBuf, &rlen); 1884 if (rc == 0 && ((dmMsg = GetSyncEventMsg(dmMsgBuf)) != NULL)) { 1885 rc = dm_respond_event(sid, dmMsg->ev_token, 1886 DM_RESP_ABORT, 0, 0, NULL); 1887 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL); 1888 1889 /* Variation clean up */ 1890 rc = dm_respond_event(sid, dmMsg->ev_token, 1891 DM_RESP_CONTINUE, 0, 0, NULL); 1892 if (rc == -1) { 1893 DMLOG_PRINT(DMLVL_DEBUG, 1894 "Unable to clean up variation! (errno = %d)\n", 1895 errno); 1896 } 1897 } else { 1898 DMLOG_PRINT(DMLVL_ERR, 1899 "Unable to obtain synchronous event! (rc = %d, errno = %d)\n", 1900 rc, errno); 1901 } 1902 break; 1903 1904 } 1905 1906 pthread_exit(0); 1907} 1908