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 : token.c
21 *
22 * VARIATIONS : 9
23 *
24 * API'S TESTED : dm_getall_tokens
25 */
26 #include <string.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <errno.h>
30 #include <pthread.h>
31 #include <unistd.h>
32 #include <sys/stat.h>
33 #include <sys/mount.h>
34 #include <fcntl.h>
35 #include "dm_test.h"
36
37 #define TOKBUF_NUM 10
38 #define TOKBUF_LEN (TOKBUF_NUM * sizeof(dm_token_t))
39
40 pthread_t tid;
41 dm_sessid_t sid;
42 char dmMsgBuf[4096];
43 char *mountPt;
44 char *deviceNm;
45 char DummySubdir[FILENAME_MAX];
46 dm_token_t createToken;
47
48 void *Thread(void *);
49 void *TokenThread(void *);
50
main(int argc,char ** argv)51 int main(int argc, char **argv)
52 {
53
54 char *szFuncName;
55 char *varstr;
56 int rc;
57 char *szSessionInfo = "dm_test session info";
58 dm_eventset_t events;
59
60 DMOPT_PARSE(argc, argv);
61 DMLOG_START();
62
63 DMEV_ZERO(events);
64 DMEV_SET(DM_EVENT_MOUNT, events);
65
66 /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION!!! */
67 if ((rc = dm_init_service(&varstr)) != 0) {
68 DMLOG_PRINT(DMLVL_ERR,
69 "dm_init_service failed! (rc = %d, errno = %d)\n",
70 rc, errno);
71 DM_EXIT();
72 } else if ((rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &sid))
73 == -1) {
74 DMLOG_PRINT(DMLVL_ERR,
75 "dm_create_session failed! (rc = %d, errno = %d)\n",
76 rc, errno);
77 DM_EXIT();
78 } else
79 if ((rc =
80 dm_set_disp(sid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, DM_NO_TOKEN,
81 &events, DM_EVENT_MAX)) == -1) {
82 DMLOG_PRINT(DMLVL_ERR,
83 "dm_set_disp failed! (rc = %d, errno = %d)\n", rc,
84 errno);
85 dm_destroy_session(sid);
86 DM_EXIT();
87 } else if ((rc = pthread_create(&tid, NULL, Thread, NULL)) != 0) {
88 DMLOG_PRINT(DMLVL_ERR,
89 "pthread_create failed! (rc = %d, errno = %d)\n",
90 rc, errno);
91 dm_destroy_session(sid);
92 DM_EXIT();
93 } else if ((rc = dmimpl_mount(&mountPt, &deviceNm)) == -1) {
94 DMLOG_PRINT(DMLVL_ERR,
95 "dmimpl_mount failed! (rc = %d, errno = %d)\n", rc,
96 errno);
97 dm_destroy_session(sid);
98 DM_EXIT();
99 } else {
100 sprintf(DummySubdir, "%s/%s", mountPt, DUMMY_SUBDIR);
101
102 rmdir(DummySubdir);
103 }
104
105 DMLOG_PRINT(DMLVL_DEBUG, "Starting DMAPI tokens tests\n");
106
107 szFuncName = "dm_getall_tokens";
108
109 /*
110 * TEST : dm_getall_tokens - invalid sid
111 * EXPECTED: rc = -1, errno = EINVAL
112 */
113 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 1)) {
114 dm_token_t buf[TOKBUF_NUM];
115 u_int nelem;
116 char msgbuf[MSG_DATALEN];
117 dm_token_t token;
118
119 /* Variation set up */
120 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
121 rc = dm_create_userevent(sid, MSG_DATALEN, msgbuf, &token);
122 if (rc == -1) {
123 DMLOG_PRINT(DMLVL_DEBUG,
124 "Unable to set up variation! (errno = %d)\n",
125 errno);
126 DMVAR_SKIP();
127 } else {
128 /* Variation */
129 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n",
130 szFuncName);
131 rc = dm_getall_tokens(INVALID_ADDR, TOKBUF_NUM, buf,
132 &nelem);
133 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
134
135 /* Variation clean up */
136 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
137 0, NULL);
138 if (rc == -1) {
139 DMLOG_PRINT(DMLVL_DEBUG,
140 "Unable to clean up variation! (errno = %d)\n",
141 errno);
142 }
143 }
144 }
145
146 /*
147 * TEST : dm_getall_tokens - invalid nelem
148 * EXPECTED: rc = -1, errno = E2BIG
149 */
150 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 2)) {
151 dm_token_t buf[TOKBUF_NUM];
152 u_int nelem;
153 char msgbuf[MSG_DATALEN];
154 dm_token_t token;
155
156 /* Variation set up */
157 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
158 rc = dm_create_userevent(sid, MSG_DATALEN, msgbuf, &token);
159 if (rc == -1) {
160 DMLOG_PRINT(DMLVL_DEBUG,
161 "Unable to set up variation! (errno = %d)\n",
162 errno);
163 DMVAR_SKIP();
164 } else {
165 /* Variation */
166 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid nelem)\n",
167 szFuncName);
168 rc = dm_getall_tokens(sid, 0, buf, &nelem);
169 if (rc == -1) {
170 if (errno == E2BIG) {
171 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n",
172 nelem);
173 if (nelem == 1) {
174 DMLOG_PRINT(DMLVL_DEBUG,
175 "%s passed with expected rc = %d and expected errno = %d\n",
176 szFuncName, -1,
177 E2BIG);
178 DMVAR_PASS();
179 } else {
180 DMLOG_PRINT(DMLVL_ERR,
181 "%s failed with expected rc = %d and expected errno = %d but unexpected nelem (%d vs %d)\n",
182 szFuncName, -1,
183 E2BIG, nelem, 1);
184 DMVAR_FAIL();
185 }
186 } else {
187 DMLOG_PRINT(DMLVL_ERR,
188 "%s failed with expected rc = %d but unexpected errno = %d\n",
189 szFuncName, -1, errno);
190 DMVAR_FAIL();
191 }
192 } else {
193 DMLOG_PRINT(DMLVL_ERR,
194 "%s failed with unexpected rc = %d\n",
195 szFuncName, rc);
196 DMVAR_FAIL();
197 }
198
199 /* Variation clean up */
200 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
201 0, NULL);
202 if (rc == -1) {
203 DMLOG_PRINT(DMLVL_DEBUG,
204 "Unable to clean up variation! (errno = %d)\n",
205 errno);
206 }
207 }
208 }
209
210 /*
211 * TEST : dm_getall_tokens - invalid tokenbufp
212 * EXPECTED: rc = -1, errno = EFAULT
213 */
214 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 3)) {
215 u_int nelem;
216 char msgbuf[MSG_DATALEN];
217 dm_token_t token;
218
219 /* Variation set up */
220 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
221 rc = dm_create_userevent(sid, MSG_DATALEN, msgbuf, &token);
222 if (rc == -1) {
223 DMLOG_PRINT(DMLVL_DEBUG,
224 "Unable to set up variation! (errno = %d)\n",
225 errno);
226 DMVAR_SKIP();
227 } else {
228 /* Variation */
229 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid tokenbufp)\n",
230 szFuncName);
231 rc = dm_getall_tokens(sid, TOKBUF_NUM,
232 (dm_token_t *) INVALID_ADDR,
233 &nelem);
234 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT);
235
236 /* Variation clean up */
237 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
238 0, NULL);
239 if (rc == -1) {
240 DMLOG_PRINT(DMLVL_DEBUG,
241 "Unable to clean up variation! (errno = %d)\n",
242 errno);
243 }
244 }
245 }
246
247 /*
248 * TEST : dm_getall_tokens - invalid nelemp
249 * EXPECTED: rc = -1, errno = EFAULT
250 */
251 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 4)) {
252 dm_token_t buf[TOKBUF_NUM];
253 char msgbuf[MSG_DATALEN];
254 dm_token_t token;
255
256 /* Variation set up */
257 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
258 rc = dm_create_userevent(sid, MSG_DATALEN, msgbuf, &token);
259 if (rc == -1) {
260 DMLOG_PRINT(DMLVL_DEBUG,
261 "Unable to set up variation! (errno = %d)\n",
262 errno);
263 DMVAR_SKIP();
264 } else {
265 /* Variation */
266 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid nelemp)\n",
267 szFuncName);
268 rc = dm_getall_tokens(sid, TOKBUF_NUM, buf,
269 (u_int *) INVALID_ADDR);
270 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT);
271
272 /* Variation clean up */
273 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
274 0, NULL);
275 if (rc == -1) {
276 DMLOG_PRINT(DMLVL_DEBUG,
277 "Unable to clean up variation! (errno = %d)\n",
278 errno);
279 }
280 }
281 }
282
283 /*
284 * TEST : dm_getall_tokens - one userevent token
285 * EXPECTED: rc = 0
286 */
287 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 5)) {
288 dm_token_t buf[TOKBUF_NUM];
289 u_int nelem;
290 char msgbuf[MSG_DATALEN];
291 dm_token_t token;
292
293 /* Variation set up */
294 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
295 rc = dm_create_userevent(sid, MSG_DATALEN, msgbuf, &token);
296 if (rc == -1) {
297 DMLOG_PRINT(DMLVL_DEBUG,
298 "Unable to set up variation! (errno = %d)\n",
299 errno);
300 DMVAR_SKIP();
301 } else {
302 /* Variation */
303 DMLOG_PRINT(DMLVL_DEBUG, "%s(one userevent token)\n",
304 szFuncName);
305 rc = dm_getall_tokens(sid, TOKBUF_NUM, buf, &nelem);
306 if (rc == 0) {
307 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem);
308 if (nelem == 1) {
309 DMLOG_PRINT(DMLVL_DEBUG,
310 "token 0: %d\n", buf[0]);
311 if (token == buf[0]) {
312 DMLOG_PRINT(DMLVL_DEBUG,
313 "%s passed with expected rc = %d\n",
314 szFuncName, 0);
315 DMVAR_PASS();
316 } else {
317 DMLOG_PRINT(DMLVL_ERR,
318 "%s failed with expected rc = %d but unexpected token (%d vs %d)\n",
319 szFuncName, 0,
320 token, buf[0]);
321 DMVAR_FAIL();
322 }
323 } else {
324 DMLOG_PRINT(DMLVL_ERR,
325 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n",
326 szFuncName, 0, nelem, 1);
327 DMVAR_FAIL();
328 }
329 } else {
330 DMLOG_PRINT(DMLVL_ERR,
331 "%s failed with unexpected rc = %d (errno = %d)\n",
332 szFuncName, rc, errno);
333 DMVAR_FAIL();
334 }
335
336 /* Variation clean up */
337 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
338 0, NULL);
339 if (rc == -1) {
340 DMLOG_PRINT(DMLVL_DEBUG,
341 "Unable to clean up variation! (errno = %d)\n",
342 errno);
343 }
344 }
345 }
346
347 /*
348 * TEST : dm_getall_tokens - two userevent tokens
349 * EXPECTED: rc = 0
350 */
351 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 6)) {
352 dm_token_t buf[TOKBUF_NUM];
353 u_int nelem;
354 char msgbuf[MSG_DATALEN];
355 dm_token_t token1, token2;
356
357 /* Variation set up */
358 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
359 if ((rc =
360 dm_create_userevent(sid, MSG_DATALEN, msgbuf,
361 &token1)) == -1) {
362 /* No clean up */
363 } else
364 if ((rc =
365 dm_create_userevent(sid, MSG_DATALEN, msgbuf,
366 &token2)) == -1) {
367 dm_respond_event(sid, token1, DM_RESP_CONTINUE, 0, 0,
368 NULL);
369 }
370 if (rc == -1) {
371 DMLOG_PRINT(DMLVL_DEBUG,
372 "Unable to set up variation! (errno = %d)\n",
373 errno);
374 DMVAR_SKIP();
375 } else {
376 /* Variation */
377 DMLOG_PRINT(DMLVL_DEBUG, "%s(two userevent tokens)\n",
378 szFuncName);
379 rc = dm_getall_tokens(sid, TOKBUF_NUM, buf, &nelem);
380 if (rc == 0) {
381 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem);
382 if (nelem == 2) {
383 DMLOG_PRINT(DMLVL_DEBUG,
384 "token 0: %d\n", buf[0]);
385 DMLOG_PRINT(DMLVL_DEBUG,
386 "token 1: %d\n", buf[1]);
387 if (token1 == buf[0]
388 || token1 == buf[1]) {
389 if (token2 == buf[0]
390 || token2 == buf[1]) {
391 DMLOG_PRINT(DMLVL_DEBUG,
392 "%s passed with expected rc = %d\n",
393 szFuncName,
394 0);
395 DMVAR_PASS();
396 } else {
397 DMLOG_PRINT(DMLVL_ERR,
398 "%s failed with expected rc = %d but token = %d not in buf\n",
399 szFuncName,
400 0, token2);
401 DMVAR_FAIL();
402 }
403 } else {
404 DMLOG_PRINT(DMLVL_ERR,
405 "%s failed with expected rc = %d but token = %d not in buf\n",
406 szFuncName, 0,
407 token1);
408 DMVAR_FAIL();
409 }
410 } else {
411 DMLOG_PRINT(DMLVL_ERR,
412 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n",
413 szFuncName, 0, nelem, 1);
414 DMVAR_FAIL();
415 }
416 } else {
417 DMLOG_PRINT(DMLVL_ERR,
418 "%s failed with unexpected rc = %d (errno = %d)\n",
419 szFuncName, rc, errno);
420 DMVAR_FAIL();
421 }
422
423 /* Variation clean up */
424 rc = dm_respond_event(sid, token2, DM_RESP_CONTINUE, 0,
425 0, NULL);
426 rc |=
427 dm_respond_event(sid, token1, DM_RESP_CONTINUE, 0,
428 0, NULL);
429 if (rc == -1) {
430 DMLOG_PRINT(DMLVL_DEBUG,
431 "Unable to clean up variation! (errno = %d)\n",
432 errno);
433 }
434 }
435 }
436
437 /*
438 * TEST : dm_getall_tokens - one event token
439 * EXPECTED: rc = 0
440 */
441 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 7)) {
442 dm_token_t buf[TOKBUF_NUM];
443 u_int nelem;
444 pthread_t tidToken;
445
446 /* Variation set up */
447 createToken = 0;
448 rc = pthread_create(&tidToken, NULL, TokenThread, NULL);
449 if (rc == -1) {
450 DMLOG_PRINT(DMLVL_DEBUG,
451 "Unable to set up variation! (errno = %d)\n",
452 errno);
453 DMVAR_SKIP();
454 } else {
455 /* Variation */
456 /* Wait for DM_EVENT_CREATE event to set token */
457 while (createToken == 0) {
458 EVENT_DELIVERY_DELAY;
459 }
460 DMLOG_PRINT(DMLVL_DEBUG, "%s(one event token)\n",
461 szFuncName);
462 rc = dm_getall_tokens(sid, TOKBUF_NUM, buf, &nelem);
463 if (rc == 0) {
464 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem);
465 if (nelem == 1) {
466 DMLOG_PRINT(DMLVL_DEBUG,
467 "token 0: %d\n", buf[0]);
468 if (buf[0] == createToken) {
469 DMLOG_PRINT(DMLVL_DEBUG,
470 "%s passed with expected rc = %d\n",
471 szFuncName, 0);
472 DMVAR_PASS();
473 } else {
474 DMLOG_PRINT(DMLVL_ERR,
475 "%s failed with expected rc = %d but unexpected token (%d vs %d)\n",
476 szFuncName, 0,
477 buf[0],
478 createToken);
479 DMVAR_FAIL();
480 }
481 } else {
482 DMLOG_PRINT(DMLVL_ERR,
483 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n",
484 szFuncName, 0, nelem, 1);
485 DMVAR_FAIL();
486 }
487 } else {
488 DMLOG_PRINT(DMLVL_ERR,
489 "%s failed with unexpected rc = %d (errno = %d)\n",
490 szFuncName, rc, errno);
491 DMVAR_FAIL();
492 }
493
494 /* Variation clean up */
495 pthread_join(tidToken, NULL);
496 }
497 }
498
499 /*
500 * TEST : dm_getall_tokens - one event token, one userevent token
501 * EXPECTED: rc = 0
502 */
503 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 8)) {
504 dm_token_t buf[TOKBUF_NUM];
505 u_int nelem;
506 char msgbuf[MSG_DATALEN];
507 dm_token_t token;
508 pthread_t tidToken;
509
510 /* Variation set up */
511 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
512 createToken = 0;
513 if ((rc =
514 dm_create_userevent(sid, MSG_DATALEN, msgbuf,
515 &token)) == -1) {
516 /* No clean up */
517 } else
518 if ((rc =
519 pthread_create(&tidToken, NULL, TokenThread,
520 NULL)) == -1) {
521 dm_respond_event(sid, token, DM_RESP_CONTINUE, 0, 0,
522 NULL);
523 }
524 if (rc == -1) {
525 DMLOG_PRINT(DMLVL_DEBUG,
526 "Unable to clean up variation! (errno = %d)\n",
527 errno);
528 DMVAR_SKIP();
529 } else {
530 /* Variation */
531 /* Wait for DM_EVENT_CREATE event to set token */
532 while (createToken == 0) {
533 EVENT_DELIVERY_DELAY;
534 }
535 DMLOG_PRINT(DMLVL_DEBUG,
536 "%s(one event token, one userevent token)\n",
537 szFuncName);
538 rc = dm_getall_tokens(sid, TOKBUF_NUM, buf, &nelem);
539 if (rc == 0) {
540 DMLOG_PRINT(DMLVL_DEBUG, "nelem = %d\n", nelem);
541 if (nelem == 2) {
542 DMLOG_PRINT(DMLVL_DEBUG,
543 "token 0: %d\n", buf[0]);
544 DMLOG_PRINT(DMLVL_DEBUG,
545 "token 1: %d\n", buf[1]);
546 if (token == buf[0] || token == buf[1]) {
547 if (createToken == buf[0]
548 || createToken == buf[1]) {
549 DMLOG_PRINT(DMLVL_DEBUG,
550 "%s passed with expected rc = %d\n",
551 szFuncName,
552 0);
553 DMVAR_PASS();
554 } else {
555 DMLOG_PRINT(DMLVL_ERR,
556 "%s failed with expected rc = %d but token = %d not in buf\n",
557 szFuncName,
558 0,
559 createToken);
560 DMVAR_FAIL();
561 }
562 } else {
563 DMLOG_PRINT(DMLVL_ERR,
564 "%s failed with expected rc = %d but token = %d not in buf\n",
565 szFuncName, 0,
566 token);
567 DMVAR_FAIL();
568 }
569 } else {
570 DMLOG_PRINT(DMLVL_ERR,
571 "%s failed with expected rc = %d but unexpected nelem (%d vs %d)\n",
572 szFuncName, 0, nelem, 1);
573 DMVAR_FAIL();
574 }
575 } else {
576 DMLOG_PRINT(DMLVL_ERR,
577 "%s failed with unexpected rc = %d (errno = %d)\n",
578 szFuncName, rc, errno);
579 DMVAR_FAIL();
580 }
581
582 /* Variation clean up */
583 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
584 0, NULL);
585 if (rc == -1) {
586 DMLOG_PRINT(DMLVL_DEBUG,
587 "Unable to clean up variation! (errno = %d)\n",
588 errno);
589 }
590 pthread_join(tidToken, NULL);
591 }
592 }
593
594 /*
595 * TEST : dm_getall_tokens - DM_NO_SESSION sid
596 * EXPECTED: rc = -1, errno = EINVAL
597 */
598 if (DMVAR_EXEC(GETALL_TOKENS_BASE + 9)) {
599 dm_token_t buf[TOKBUF_NUM];
600 u_int nelem;
601 char msgbuf[MSG_DATALEN];
602 dm_token_t token;
603
604 /* Variation set up */
605 memcpy(msgbuf, MSG_DATA, MSG_DATALEN);
606 rc = dm_create_userevent(sid, MSG_DATALEN, msgbuf, &token);
607 if (rc == -1) {
608 DMLOG_PRINT(DMLVL_DEBUG,
609 "Unable to clean up variation! (errno = %d)\n",
610 errno);
611 DMVAR_SKIP();
612 } else {
613 /* Variation */
614 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION, sid)\n",
615 szFuncName);
616 rc = dm_getall_tokens(DM_NO_SESSION, TOKBUF_NUM, buf,
617 &nelem);
618 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
619
620 /* Variation clean up */
621 rc = dm_respond_event(sid, token, DM_RESP_CONTINUE, 0,
622 0, NULL);
623 if (rc == -1) {
624 DMLOG_PRINT(DMLVL_DEBUG,
625 "Unable to clean up variation! (errno = %d)\n",
626 errno);
627 }
628 }
629 }
630
631 rc = umount(mountPt);
632 if (rc == -1) {
633 DMLOG_PRINT(DMLVL_ERR, "umount failed! (rc = %d, errno = %d)\n",
634 rc, errno);
635 }
636
637 pthread_join(tid, NULL);
638
639 rc = dm_destroy_session(sid);
640 if (rc == -1) {
641 DMLOG_PRINT(DMLVL_ERR,
642 "dm_destroy_session failed! (rc = %d, errno = %d)\n",
643 rc, errno);
644 }
645
646 DMLOG_STOP();
647
648 tst_exit();
649 }
650
Thread(void * parm)651 void *Thread(void *parm)
652 {
653 int rc;
654 size_t dmMsgBufLen;
655 dm_eventmsg_t *dmMsg;
656 int bMounted = DM_FALSE;
657 dm_eventtype_t type;
658 dm_token_t token;
659 dm_eventset_t events;
660 dm_response_t response;
661
662 do {
663 /* Loop until message received (wait could be interrupted) */
664 do {
665 DMLOG_PRINT(DMLVL_DEBUG, "Waiting for event...\n");
666 dmMsgBufLen = 0;
667
668 rc = dm_get_events(sid, 1, DM_EV_WAIT, sizeof(dmMsgBuf),
669 dmMsgBuf, &dmMsgBufLen);
670 DMLOG_PRINT(DMLVL_DEBUG,
671 "... dm_get_events returned %d (errno %d)\n",
672 rc, errno);
673 } while ((rc == -1) && (errno == EINTR) && (dmMsgBufLen == 0));
674
675 if (rc) {
676 DMLOG_PRINT(DMLVL_ERR,
677 "dm_get_events failed with rc = %d, errno = %d\n",
678 rc, errno);
679 dm_destroy_session(sid);
680 DM_EXIT();
681 } else {
682 dmMsg = (dm_eventmsg_t *) dmMsgBuf;
683 token = dmMsg->ev_token;
684 type = dmMsg->ev_type;
685
686 DMLOG_PRINT(DMLVL_DEBUG, "Received message %d\n", type);
687 }
688
689 if (type == DM_EVENT_MOUNT) {
690 /* SPECIAL CASE: need to set disposition, events and response */
691 dm_mount_event_t *me =
692 DM_GET_VALUE(dmMsg, ev_data, dm_mount_event_t *);
693 void *hanp = DM_GET_VALUE(me, me_handle1, void *);
694 size_t hlen = DM_GET_LEN(me, me_handle1);
695
696 DMLOG_PRINT(DMLVL_DEBUG, "Message is DM_EVENT_MOUNT\n");
697 DMLOG_PRINT(DMLVL_DEBUG, " Mode: %x\n", me->me_mode);
698 DMLOG_PRINT(DMLVL_DEBUG, " File system handle: %p\n",
699 hanp);
700 DMLOG_PRINT(DMLVL_DEBUG,
701 " File system handle length: %d\n", hlen);
702 DMLOG_PRINT(DMLVL_DEBUG, " Mountpoint handle: %p\n",
703 DM_GET_VALUE(me, me_handle2, void *));
704 DMLOG_PRINT(DMLVL_DEBUG,
705 " Mountpoint handle length: %d\n",
706 DM_GET_LEN(me, me_handle2));
707 DMLOG_PRINT(DMLVL_DEBUG, " Mountpoint path: %s\n",
708 DM_GET_VALUE(me, me_name1, char *));
709 DMLOG_PRINT(DMLVL_DEBUG, " Media designator: %s\n",
710 DM_GET_VALUE(me, me_name2, char *));
711 DMLOG_PRINT(DMLVL_DEBUG, " Root handle: %p\n",
712 DM_GET_VALUE(me, me_roothandle, void *));
713 DMLOG_PRINT(DMLVL_DEBUG, " Root handle length: %d\n",
714 DM_GET_LEN(me, me_roothandle));
715
716 bMounted = dm_handle_is_valid(hanp, hlen);
717
718 rc = dm_request_right(sid, hanp, hlen, token,
719 DM_RR_WAIT, DM_RIGHT_EXCL);
720 if (rc == -1) {
721 DMLOG_PRINT(DMLVL_ERR,
722 "dm_request_right failed! (rc = %d, errno = %d)\n",
723 rc, errno);
724 dm_destroy_session(sid);
725 DM_EXIT();
726 }
727
728 DMEV_ZERO(events);
729 DMEV_SET(DM_EVENT_PREUNMOUNT, events);
730 DMEV_SET(DM_EVENT_UNMOUNT, events);
731 DMEV_SET(DM_EVENT_CREATE, events);
732 rc = dm_set_disp(sid, hanp, hlen, token, &events,
733 DM_EVENT_MAX);
734 if (rc == -1) {
735 DMLOG_PRINT(DMLVL_ERR,
736 "dm_set_disp failed! (rc = %d, errno = %d)\n",
737 rc, errno);
738 dm_destroy_session(sid);
739 DM_EXIT();
740 }
741
742 rc = dm_set_eventlist(sid, hanp, hlen, token, &events,
743 DM_EVENT_MAX);
744 if (rc == -1) {
745 DMLOG_PRINT(DMLVL_ERR,
746 "dm_set_eventlist failed! (rc = %d, errno = %d)\n",
747 rc, errno);
748 dm_destroy_session(sid);
749 DM_EXIT();
750 }
751
752 rc = dm_release_right(sid, hanp, hlen, token);
753 if (rc == -1) {
754 DMLOG_PRINT(DMLVL_ERR,
755 "dm_request_right failed! (rc = %d, errno = %d)\n",
756 rc, errno);
757 dm_destroy_session(sid);
758 DM_EXIT();
759 }
760
761 response = DM_RESP_CONTINUE;
762 } else if (type == DM_EVENT_UNMOUNT) {
763 dm_namesp_event_t *nse =
764 DM_GET_VALUE(dmMsg, ev_data, dm_namesp_event_t *);
765 if (nse->ne_retcode == 0) {
766 bMounted = DM_FALSE;
767 }
768
769 response = DM_RESP_CONTINUE;
770 } else {
771 switch (type) {
772 case DM_EVENT_PREUNMOUNT:
773 response = DM_RESP_CONTINUE;
774 break;
775
776 case DM_EVENT_CREATE:
777 {
778 dm_namesp_event_t *nse =
779 DM_GET_VALUE(dmMsg, ev_data,
780 dm_namesp_event_t *);
781
782 DMLOG_PRINT(DMLVL_DEBUG,
783 "Message is DM_EVENT_CREATE\n");
784 DMLOG_PRINT(DMLVL_DEBUG, " Mode: %x\n",
785 nse->ne_mode);
786 DMLOG_PRINT(DMLVL_DEBUG,
787 " Parent handle: %p\n",
788 DM_GET_VALUE(nse,
789 ne_handle1,
790 void *));
791 DMLOG_PRINT(DMLVL_DEBUG,
792 " Parent handle length: %d\n",
793 DM_GET_LEN(nse,
794 ne_handle1));
795 DMLOG_PRINT(DMLVL_DEBUG,
796 " Entry name: %s\n",
797 DM_GET_VALUE(nse, ne_name1,
798 char *));
799
800 createToken = token;
801 DMLOG_PRINT(DMLVL_DEBUG,
802 " Token: %d\n",
803 createToken);
804
805 /* Wait for main thread to call dm_getall_tokens */
806 sleep(3);
807
808 response = DM_RESP_CONTINUE;
809 break;
810 }
811
812 default:
813 {
814 DMLOG_PRINT(DMLVL_ERR,
815 "Message is unexpected!\n");
816 response = DM_RESP_ABORT;
817 break;
818 }
819 }
820 }
821
822 if (response != DM_RESP_INVALID) {
823 DMLOG_PRINT(DMLVL_DEBUG,
824 "Responding to message %d with %d\n", type,
825 response);
826 rc = dm_respond_event(sid, token, response,
827 response ==
828 DM_RESP_ABORT ? ABORT_ERRNO : 0,
829 0, NULL);
830 }
831 } while (bMounted);
832
833 pthread_exit(0);
834 }
835
TokenThread(void * parm)836 void *TokenThread(void *parm)
837 {
838 int rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE);
839
840 if (rc != -1) {
841 rmdir(DummySubdir);
842 }
843
844 pthread_exit(0);
845 }
846