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_am.c
21 *
22 * VARIATIONS : 31
23 *
24 * EVENTS TESTED: DM_EVENT_ATTRIBUTE
25 * DM_EVENT_CLOSE
26 * DM_EVENT_DESTROY
27 *
28 * API'S TESTED : dm_set_return_on_destroy
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 pthread_t tid;
42 dm_sessid_t sid;
43 char dmMsgBuf[4096];
44 char *mountPt;
45 char *deviceNm;
46 char DummyFile[FILENAME_MAX];
47 char DummySubdir[FILENAME_MAX];
48
49 /* Variables for thread communications */
50 dm_eventtype_t eventExpected;
51 dm_eventtype_t eventReceived;
52 dm_response_t eventResponse;
53 void *hanp1, *hanp2, *ahanp1;
54 size_t hlen1, hlen2, ahlen1;
55 char name1[FILENAME_MAX];
56
57 void *Thread(void *);
58
main(int argc,char ** argv)59 int main(int argc, char **argv)
60 {
61
62 char *varstr;
63 int rc;
64 int varStatus;
65 char *szSessionInfo = "dm_test session info";
66 char *szFuncName;
67 dm_eventset_t events;
68 dm_size_t maxAttrSize;
69 void *fshanp;
70 size_t fshlen;
71 dm_eventset_t AMevents;
72
73 DMOPT_PARSE(argc, argv);
74 DMLOG_START();
75
76 DMEV_ZERO(events);
77 DMEV_SET(DM_EVENT_MOUNT, events);
78
79 /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION!!! */
80 if ((rc = dm_init_service(&varstr)) != 0) {
81 DMLOG_PRINT(DMLVL_ERR,
82 "dm_init_service failed! (rc = %d, errno = %d)\n",
83 rc, errno);
84 DM_EXIT();
85 } else if ((rc = dm_create_session(DM_NO_SESSION, szSessionInfo, &sid))
86 == -1) {
87 DMLOG_PRINT(DMLVL_ERR,
88 "dm_create_session failed! (rc = %d, errno = %d)\n",
89 rc, errno);
90 DM_EXIT();
91 } else
92 if ((rc =
93 dm_set_disp(sid, DM_GLOBAL_HANP, DM_GLOBAL_HLEN, DM_NO_TOKEN,
94 &events, DM_EVENT_MAX)) == -1) {
95 DMLOG_PRINT(DMLVL_ERR,
96 "dm_set_disp failed! (rc = %d, errno = %d)\n", rc,
97 errno);
98 dm_destroy_session(sid);
99 DM_EXIT();
100 } else if ((rc = pthread_create(&tid, NULL, Thread, NULL)) != 0) {
101 DMLOG_PRINT(DMLVL_ERR,
102 "pthread_create failed! (rc = %d, errno = %d)\n",
103 rc, errno);
104 dm_destroy_session(sid);
105 DM_EXIT();
106 } else if ((rc = dmimpl_mount(&mountPt, &deviceNm)) == -1) {
107 DMLOG_PRINT(DMLVL_ERR,
108 "dmimpl_mount failed! (rc = %d, errno = %d)\n", rc,
109 errno);
110 dm_destroy_session(sid);
111 DM_EXIT();
112 } else {
113 sprintf(DummyFile, "%s/%s", mountPt, DUMMY_FILE);
114 sprintf(DummySubdir, "%s/%s", mountPt, DUMMY_SUBDIR);
115
116 remove(DummyFile);
117 rmdir(DummySubdir);
118 }
119
120 DMLOG_PRINT(DMLVL_DEBUG,
121 "Starting DMAPI asynchronous metadata event tests\n");
122
123 /*
124 * First batch of tests will be with events enabled on file system,
125 * so set up events on fs accordingly
126 */
127 rc = dm_path_to_fshandle(mountPt, &fshanp, &fshlen);
128 if (rc == -1) {
129 DMLOG_PRINT(DMLVL_ERR,
130 "dm_path_to_handle(fs) failed! (rc = %d, errno = %d)\n",
131 rc, errno);
132 dm_destroy_session(sid);
133 DM_EXIT();
134 }
135
136 DMEV_ZERO(events);
137 DMEV_SET(DM_EVENT_PREUNMOUNT, events);
138 DMEV_SET(DM_EVENT_UNMOUNT, events);
139 DMEV_SET(DM_EVENT_POSTCREATE, events);
140 DMEV_SET(DM_EVENT_ATTRIBUTE, events);
141 DMEV_SET(DM_EVENT_CLOSE, events);
142 rc = dm_set_eventlist(sid, fshanp, fshlen, DM_NO_TOKEN, &events,
143 DM_EVENT_MAX);
144 if (rc == -1) {
145 DMLOG_PRINT(DMLVL_ERR,
146 "dm_set_eventlist(fs) failed! (rc = %d, errno = %d)\n",
147 rc, errno);
148 dm_destroy_session(sid);
149 DM_EXIT();
150 }
151
152 /*
153 * TEST : chmod - enabled on fs
154 * EXPECTED: DM_EVENT_ATTRIBUTE
155 */
156 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 1)) {
157 dm_ino_t ino;
158
159 /* Variation set up */
160 eventExpected = DM_EVENT_ATTRIBUTE;
161 eventReceived = DM_EVENT_INVALID;
162 eventResponse = DM_RESP_CONTINUE;
163 rc = mkdir(DummySubdir, DUMMY_DIR_RO_MODE);
164 if (rc == -1) {
165 DMLOG_PRINT(DMLVL_DEBUG,
166 "Unable to set up variation! (errno = %d)\n",
167 errno);
168 DMVAR_SKIP();
169 } else {
170 /* Variation */
171 EVENT_DELIVERY_DELAY;
172 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s)\n", DummySubdir);
173 rc = chmod(DummySubdir, O_RDWR);
174 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s) returned %d\n",
175 DummySubdir, rc);
176 EVENT_DELIVERY_DELAY;
177 if ((varStatus =
178 DMVAR_CHKPASSEXP(0, rc, eventExpected,
179 eventReceived)) == DMSTAT_PASS) {
180 struct stat statfs;
181
182 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
183 rc |= stat(DummySubdir, &statfs);
184 if (rc == -1) {
185 DMLOG_PRINT(DMLVL_ERR,
186 "Unable to obtain inode!\n");
187 varStatus = DMSTAT_FAIL;
188 } else
189 if (dm_handle_cmp
190 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
191 DMLOG_PRINT(DMLVL_ERR,
192 "Object/entry handles NOT same!\n");
193 varStatus = DMSTAT_FAIL;
194 } else if (ino != statfs.st_ino) {
195 DMLOG_PRINT(DMLVL_ERR,
196 "Object handle NOT correct! (%lld vs %d)\n",
197 ino, statfs.st_ino);
198 varStatus = DMSTAT_FAIL;
199 } else if (!(statfs.st_mode & O_RDWR)) {
200 DMLOG_PRINT(DMLVL_ERR,
201 "Object mode NOT correct! (%x vs %x)\n",
202 O_RDWR, statfs.st_mode);
203 varStatus = DMSTAT_FAIL;
204 } else if (strcmp(name1, DUMMY_SUBDIR) != 0) {
205 DMLOG_PRINT(DMLVL_ERR,
206 "Entry name NOT correct! (%s vs %s)\n",
207 name1, DUMMY_SUBDIR);
208 varStatus = DMSTAT_FAIL;
209 }
210 }
211 DMVAR_END(varStatus);
212
213 /* Variation clean up */
214 EVENT_DELIVERY_DELAY;
215 rc = rmdir(DummySubdir);
216 if (rc == -1) {
217 DMLOG_PRINT(DMLVL_DEBUG,
218 "Unable to clean up variation! (errno = %d)\n",
219 errno);
220 }
221 }
222 }
223
224 /*
225 * TEST : chown - enabled on fs
226 * EXPECTED: DM_EVENT_ATTRIBUTE
227 */
228 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 2)) {
229 dm_ino_t ino;
230
231 /* Variation set up */
232 eventExpected = DM_EVENT_ATTRIBUTE;
233 eventReceived = DM_EVENT_INVALID;
234 eventResponse = DM_RESP_CONTINUE;
235 rc = mkdir(DummySubdir, DUMMY_DIR_RO_MODE);
236 if (rc == -1) {
237 DMLOG_PRINT(DMLVL_DEBUG,
238 "Unable to set up variation! (errno = %d)\n",
239 errno);
240 DMVAR_SKIP();
241 } else {
242 /* Variation */
243 EVENT_DELIVERY_DELAY;
244 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s)\n", DummySubdir);
245 rc = chown(DummySubdir, DUMMY_UID, DUMMY_GID);
246 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s) returned %d\n",
247 DummySubdir, rc);
248 EVENT_DELIVERY_DELAY;
249 if ((varStatus =
250 DMVAR_CHKPASSEXP(0, rc, eventExpected,
251 eventReceived)) == DMSTAT_PASS) {
252 struct stat statfs;
253
254 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
255 rc |= stat(DummySubdir, &statfs);
256 if (rc == -1) {
257 DMLOG_PRINT(DMLVL_ERR,
258 "Unable to obtain inode!\n");
259 varStatus = DMSTAT_FAIL;
260 } else
261 if (dm_handle_cmp
262 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
263 DMLOG_PRINT(DMLVL_ERR,
264 "Object/entry handles NOT same!\n");
265 varStatus = DMSTAT_FAIL;
266 } else if (ino != statfs.st_ino) {
267 DMLOG_PRINT(DMLVL_ERR,
268 "Object handle NOT correct! (%lld vs %d)\n",
269 ino, statfs.st_ino);
270 varStatus = DMSTAT_FAIL;
271 } else if (statfs.st_uid != DUMMY_UID) {
272 DMLOG_PRINT(DMLVL_ERR,
273 "Object uid NOT correct! (%x vs %x)\n",
274 DUMMY_UID, statfs.st_uid);
275 varStatus = DMSTAT_FAIL;
276 } else if (statfs.st_gid != DUMMY_GID) {
277 DMLOG_PRINT(DMLVL_ERR,
278 "Object gid NOT correct! (%x vs %x)\n",
279 DUMMY_GID, statfs.st_gid);
280 varStatus = DMSTAT_FAIL;
281 } else if (strcmp(name1, DUMMY_SUBDIR) != 0) {
282 DMLOG_PRINT(DMLVL_ERR,
283 "Entry name NOT correct! (%s vs %s)\n",
284 name1, DUMMY_SUBDIR);
285 varStatus = DMSTAT_FAIL;
286 }
287 }
288 DMVAR_END(varStatus);
289
290 /* Variation clean up */
291 EVENT_DELIVERY_DELAY;
292 rc = rmdir(DummySubdir);
293 if (rc == -1) {
294 DMLOG_PRINT(DMLVL_DEBUG,
295 "Unable to clean up variation! (errno = %d)\n",
296 errno);
297 }
298 }
299 }
300
301 /*
302 * TEST : close - enabled on fs
303 * EXPECTED: DM_EVENT_CLOSE
304 */
305 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 3)) {
306 int fd1, fd2;
307
308 /* Variation set up */
309 eventExpected = DM_EVENT_CLOSE;
310 eventReceived = DM_EVENT_INVALID;
311 eventResponse = DM_RESP_CONTINUE;
312 if ((rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE)) == -1) {
313 /* No clean up */
314 } else if ((fd1 = open(DummySubdir, O_DIRECTORY)) == -1) {
315 rmdir(DummySubdir);
316 } else if ((fd2 = open(DummySubdir, O_DIRECTORY)) == -1) {
317 close(fd1);
318 rmdir(DummySubdir);
319 }
320 if (fd1 == -1 || fd2 == -1 || fd1 == fd2) {
321 DMLOG_PRINT(DMLVL_DEBUG,
322 "Unable to set up variation! (errno = %d)\n",
323 errno);
324 DMVAR_SKIP();
325 } else {
326 /* Variation */
327 eventExpected = DM_EVENT_INVALID;
328 eventReceived = DM_EVENT_INVALID;
329 EVENT_DELIVERY_DELAY;
330 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1\n", fd1);
331 rc = close(fd1);
332 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1 returned %d\n",
333 fd1, rc);
334 EVENT_DELIVERY_DELAY;
335 if ((varStatus =
336 DMVAR_CHKPASSEXP(0, rc, eventExpected,
337 eventReceived)) == DMSTAT_PASS) {
338 eventExpected = DM_EVENT_CLOSE;
339 EVENT_DELIVERY_DELAY;
340 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #2\n", fd2);
341 rc = close(fd2);
342 DMLOG_PRINT(DMLVL_DEBUG,
343 "close(%d) #2 returned %d\n", fd2,
344 rc);
345 EVENT_DELIVERY_DELAY;
346 varStatus =
347 DMVAR_CHKPASSEXP(0, rc, eventExpected,
348 eventReceived);
349 }
350 DMVAR_END(varStatus);
351
352 /* Variation clean up */
353 EVENT_DELIVERY_DELAY;
354 rc = rmdir(DummySubdir);
355 if (rc == -1) {
356 DMLOG_PRINT(DMLVL_DEBUG,
357 "Unable to clean up variation! (errno = %d)\n",
358 errno);
359 }
360 }
361 }
362
363 /*
364 * TEST : chmod - enabled on fs
365 * EXPECTED: DM_EVENT_ATTRIBUTE
366 */
367 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 1)) {
368 int fd;
369 dm_ino_t ino;
370
371 /* Variation set up */
372 eventExpected = DM_EVENT_ATTRIBUTE;
373 eventReceived = DM_EVENT_INVALID;
374 eventResponse = DM_RESP_CONTINUE;
375 if ((fd =
376 open(DummyFile, O_RDONLY | O_CREAT,
377 DUMMY_FILE_RO_MODE)) == -1) {
378 /* No clean up */
379 } else if ((rc = close(fd)) == -1) {
380 remove(DummyFile);
381 }
382 if (fd == -1 || rc == -1) {
383 DMLOG_PRINT(DMLVL_DEBUG,
384 "Unable to set up variation! (errno = %d)\n",
385 errno);
386 DMVAR_SKIP();
387 } else {
388 /* Variation */
389 EVENT_DELIVERY_DELAY;
390 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s)\n", DummyFile);
391 rc = chmod(DummyFile, O_RDWR);
392 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s) returned %d\n",
393 DummyFile, rc);
394 EVENT_DELIVERY_DELAY;
395 if ((varStatus =
396 DMVAR_CHKPASSEXP(0, rc, eventExpected,
397 eventReceived)) == DMSTAT_PASS) {
398 struct stat statfs;
399
400 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
401 rc |= stat(DummyFile, &statfs);
402 if (rc == -1) {
403 DMLOG_PRINT(DMLVL_ERR,
404 "Unable to obtain inode!\n");
405 varStatus = DMSTAT_FAIL;
406 } else
407 if (dm_handle_cmp
408 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
409 DMLOG_PRINT(DMLVL_ERR,
410 "Object/entry handles NOT same!\n");
411 varStatus = DMSTAT_FAIL;
412 } else if (ino != statfs.st_ino) {
413 DMLOG_PRINT(DMLVL_ERR,
414 "Object handle NOT correct! (%lld vs %d)\n",
415 ino, statfs.st_ino);
416 varStatus = DMSTAT_FAIL;
417 } else if (!(statfs.st_mode & O_RDWR)) {
418 DMLOG_PRINT(DMLVL_ERR,
419 "Object mode NOT correct! (%x vs %x)\n",
420 O_RDWR, statfs.st_mode);
421 varStatus = DMSTAT_FAIL;
422 } else if (strcmp(name1, DUMMY_FILE) != 0) {
423 DMLOG_PRINT(DMLVL_ERR,
424 "Entry name NOT correct! (%s vs %s)\n",
425 name1, DUMMY_FILE);
426 varStatus = DMSTAT_FAIL;
427 }
428 }
429 DMVAR_END(varStatus);
430
431 /* Variation clean up */
432 EVENT_DELIVERY_DELAY;
433 rc = remove(DummyFile);
434 if (rc == -1) {
435 DMLOG_PRINT(DMLVL_DEBUG,
436 "Unable to clean up variation! (errno = %d)\n",
437 errno);
438 }
439 }
440 }
441
442 /*
443 * TEST : chown - enabled on fs
444 * EXPECTED: DM_EVENT_ATTRIBUTE
445 */
446 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 2)) {
447 int fd;
448 dm_ino_t ino;
449
450 /* Variation set up */
451 eventExpected = DM_EVENT_ATTRIBUTE;
452 eventReceived = DM_EVENT_INVALID;
453 eventResponse = DM_RESP_CONTINUE;
454 if ((fd =
455 open(DummyFile, O_RDONLY | O_CREAT,
456 DUMMY_FILE_RO_MODE)) == -1) {
457 /* No clean up */
458 } else if ((rc = close(fd)) == -1) {
459 remove(DummyFile);
460 }
461 if (fd == -1 || rc == -1) {
462 DMLOG_PRINT(DMLVL_DEBUG,
463 "Unable to set up variation! (errno = %d)\n",
464 errno);
465 DMVAR_SKIP();
466 } else {
467 /* Variation */
468 EVENT_DELIVERY_DELAY;
469 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s)\n", DummyFile);
470 rc = chown(DummyFile, DUMMY_UID, DUMMY_GID);
471 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s) returned %d\n",
472 DummyFile, rc);
473 EVENT_DELIVERY_DELAY;
474 if ((varStatus =
475 DMVAR_CHKPASSEXP(0, rc, eventExpected,
476 eventReceived)) == DMSTAT_PASS) {
477 struct stat statfs;
478
479 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
480 rc |= stat(DummyFile, &statfs);
481 if (rc == -1) {
482 DMLOG_PRINT(DMLVL_ERR,
483 "Unable to obtain inode!\n");
484 varStatus = DMSTAT_FAIL;
485 } else
486 if (dm_handle_cmp
487 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
488 DMLOG_PRINT(DMLVL_ERR,
489 "Object/entry handles NOT same!\n");
490 varStatus = DMSTAT_FAIL;
491 } else if (ino != statfs.st_ino) {
492 DMLOG_PRINT(DMLVL_ERR,
493 "Object handle NOT correct! (%lld vs %d)\n",
494 ino, statfs.st_ino);
495 varStatus = DMSTAT_FAIL;
496 } else if (statfs.st_uid != DUMMY_UID) {
497 DMLOG_PRINT(DMLVL_ERR,
498 "Object uid NOT correct! (%x vs %x)\n",
499 DUMMY_UID, statfs.st_uid);
500 varStatus = DMSTAT_FAIL;
501 } else if (statfs.st_gid != DUMMY_GID) {
502 DMLOG_PRINT(DMLVL_ERR,
503 "Object gid NOT correct! (%x vs %x)\n",
504 DUMMY_GID, statfs.st_gid);
505 varStatus = DMSTAT_FAIL;
506 } else if (strcmp(name1, DUMMY_FILE) != 0) {
507 DMLOG_PRINT(DMLVL_ERR,
508 "Entry name NOT correct! (%s vs %s)\n",
509 name1, DUMMY_FILE);
510 varStatus = DMSTAT_FAIL;
511 }
512 }
513 DMVAR_END(varStatus);
514
515 /* Variation clean up */
516 EVENT_DELIVERY_DELAY;
517 rc = remove(DummyFile);
518 if (rc == -1) {
519 DMLOG_PRINT(DMLVL_DEBUG,
520 "Unable to clean up variation! (errno = %d)\n",
521 errno);
522 }
523 }
524 }
525
526 /*
527 * TEST : close - enabled on fs
528 * EXPECTED: DM_EVENT_CLOSE
529 */
530 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 3)) {
531 int fd1, fd2;
532
533 /* Variation set up */
534 eventExpected = DM_EVENT_CLOSE;
535 eventReceived = DM_EVENT_INVALID;
536 eventResponse = DM_RESP_CONTINUE;
537 if ((fd1 =
538 open(DummyFile, O_RDONLY | O_CREAT,
539 DUMMY_FILE_RO_MODE)) == -1) {
540 /* No clean up */
541 } else if ((fd2 = open(DummyFile, O_RDONLY)) == -1) {
542 close(fd1);
543 remove(DummyFile);
544 }
545 if (fd1 == -1 || fd2 == -1 || fd1 == fd2) {
546 DMLOG_PRINT(DMLVL_DEBUG,
547 "Unable to set up variation! (errno = %d)\n",
548 errno);
549 DMVAR_SKIP();
550 } else {
551 /* Variation */
552 eventExpected = DM_EVENT_INVALID;
553 eventReceived = DM_EVENT_INVALID;
554 EVENT_DELIVERY_DELAY;
555 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1\n", fd1);
556 rc = close(fd1);
557 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1 returned %d\n",
558 fd1, rc);
559 EVENT_DELIVERY_DELAY;
560 if ((varStatus =
561 DMVAR_CHKPASSEXP(0, rc, eventExpected,
562 eventReceived)) == DMSTAT_PASS) {
563 eventExpected = DM_EVENT_CLOSE;
564 EVENT_DELIVERY_DELAY;
565 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #2\n", fd2);
566 rc = close(fd2);
567 DMLOG_PRINT(DMLVL_DEBUG,
568 "close(%d) #2 returned %d\n", fd2,
569 rc);
570 EVENT_DELIVERY_DELAY;
571 varStatus =
572 DMVAR_CHKPASSEXP(0, rc, eventExpected,
573 eventReceived);
574 }
575 DMVAR_END(varStatus);
576
577 /* Variation clean up */
578 EVENT_DELIVERY_DELAY;
579 rc = remove(DummyFile);
580 if (rc == -1) {
581 DMLOG_PRINT(DMLVL_DEBUG,
582 "Unable to clean up variation! (errno = %d)\n",
583 errno);
584 }
585 }
586 }
587
588 /* Wait for all pending messages to be handled */
589 EVENT_DELIVERY_DELAY_LOOP;
590
591 /*
592 * Next batch of tests will be with events enabled on object, so
593 * clear events on fs
594 */
595 rc = dm_path_to_fshandle(mountPt, &fshanp, &fshlen);
596 if (rc == -1) {
597 DMLOG_PRINT(DMLVL_ERR,
598 "dm_path_to_handle failed! (rc = %d, errno = %d)\n",
599 rc, errno);
600 dm_destroy_session(sid);
601 DM_EXIT();
602 }
603
604 DMEV_ZERO(events);
605 DMEV_SET(DM_EVENT_PREUNMOUNT, events);
606 DMEV_SET(DM_EVENT_UNMOUNT, events);
607 DMEV_SET(DM_EVENT_POSTCREATE, events);
608 rc = dm_set_eventlist(sid, fshanp, fshlen, DM_NO_TOKEN, &events,
609 DM_EVENT_MAX);
610 if (rc == -1) {
611 DMLOG_PRINT(DMLVL_ERR,
612 "dm_set_eventlist(fs) failed! (rc = %d, errno = %d)\n",
613 rc, errno);
614 dm_destroy_session(sid);
615 DM_EXIT();
616 }
617
618 DMEV_ZERO(AMevents);
619 DMEV_SET(DM_EVENT_ATTRIBUTE, AMevents);
620 DMEV_SET(DM_EVENT_CLOSE, AMevents);
621
622 /*
623 * TEST : chmod - enabled on directory
624 * EXPECTED: DM_EVENT_ATTRIBUTE
625 */
626 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 4)) {
627 void *hanp;
628 size_t hlen;
629 dm_ino_t ino;
630
631 /* Variation set up */
632 eventExpected = DM_EVENT_ATTRIBUTE;
633 eventReceived = DM_EVENT_INVALID;
634 eventResponse = DM_RESP_CONTINUE;
635 if ((rc = mkdir(DummySubdir, DUMMY_DIR_RO_MODE)) == -1) {
636 /* No clean up */
637 } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen))
638 == -1) {
639 rmdir(DummySubdir);
640 } else
641 if ((rc =
642 dm_set_eventlist(sid, hanp, hlen, DM_NO_TOKEN,
643 &AMevents, DM_EVENT_MAX)) == -1) {
644 dm_handle_free(hanp, hlen);
645 rmdir(DummySubdir);
646 }
647 if (rc == -1) {
648 DMLOG_PRINT(DMLVL_DEBUG,
649 "Unable to set up variation! (errno = %d)\n",
650 errno);
651 DMVAR_SKIP();
652 } else {
653 /* Variation */
654 EVENT_DELIVERY_DELAY;
655 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s)\n", DummySubdir);
656 rc = chmod(DummySubdir, O_RDWR);
657 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s) returned %d\n",
658 DummySubdir, rc);
659 EVENT_DELIVERY_DELAY;
660 if ((varStatus =
661 DMVAR_CHKPASSEXP(0, rc, eventExpected,
662 eventReceived)) == DMSTAT_PASS) {
663 struct stat statfs;
664
665 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
666 rc |= stat(DummySubdir, &statfs);
667 if (rc == -1) {
668 DMLOG_PRINT(DMLVL_ERR,
669 "Unable to obtain inode!\n");
670 varStatus = DMSTAT_FAIL;
671 } else
672 if (dm_handle_cmp
673 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
674 DMLOG_PRINT(DMLVL_ERR,
675 "Object/entry handles NOT same!\n");
676 varStatus = DMSTAT_FAIL;
677 } else if (ino != statfs.st_ino) {
678 DMLOG_PRINT(DMLVL_ERR,
679 "Object handle NOT correct! (%lld vs %d)\n",
680 ino, statfs.st_ino);
681 varStatus = DMSTAT_FAIL;
682 } else if (!(statfs.st_mode & O_RDWR)) {
683 DMLOG_PRINT(DMLVL_ERR,
684 "Object mode NOT correct! (%x vs %x)\n",
685 O_RDWR, statfs.st_mode);
686 varStatus = DMSTAT_FAIL;
687 } else if (strcmp(name1, DUMMY_SUBDIR) != 0) {
688 DMLOG_PRINT(DMLVL_ERR,
689 "Entry name NOT correct! (%s vs %s)\n",
690 name1, DUMMY_SUBDIR);
691 varStatus = DMSTAT_FAIL;
692 }
693 }
694 DMVAR_END(varStatus);
695
696 /* Variation clean up */
697 EVENT_DELIVERY_DELAY;
698 rc = rmdir(DummySubdir);
699 if (rc == -1) {
700 DMLOG_PRINT(DMLVL_DEBUG,
701 "Unable to clean up variation! (errno = %d)\n",
702 errno);
703 }
704 dm_handle_free(hanp, hlen);
705 }
706 }
707
708 /*
709 * TEST : chown - enabled on directory
710 * EXPECTED: DM_EVENT_ATTRIBUTE
711 */
712 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 5)) {
713 void *hanp;
714 size_t hlen;
715 dm_ino_t ino;
716
717 /* Variation set up */
718 eventExpected = DM_EVENT_ATTRIBUTE;
719 eventReceived = DM_EVENT_INVALID;
720 eventResponse = DM_RESP_CONTINUE;
721 if ((rc = mkdir(DummySubdir, DUMMY_DIR_RO_MODE)) == -1) {
722 /* No clean up */
723 } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen))
724 == -1) {
725 rmdir(DummySubdir);
726 } else
727 if ((rc =
728 dm_set_eventlist(sid, hanp, hlen, DM_NO_TOKEN,
729 &AMevents, DM_EVENT_MAX)) == -1) {
730 dm_handle_free(hanp, hlen);
731 rmdir(DummySubdir);
732 }
733 if (rc == -1) {
734 DMLOG_PRINT(DMLVL_DEBUG,
735 "Unable to set up variation! (errno = %d)\n",
736 errno);
737 DMVAR_SKIP();
738 } else {
739 /* Variation */
740 EVENT_DELIVERY_DELAY;
741 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s)\n", DummySubdir);
742 rc = chown(DummySubdir, DUMMY_UID, DUMMY_GID);
743 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s) returned %d\n",
744 DummySubdir, rc);
745 EVENT_DELIVERY_DELAY;
746 if ((varStatus =
747 DMVAR_CHKPASSEXP(0, rc, eventExpected,
748 eventReceived)) == DMSTAT_PASS) {
749 struct stat statfs;
750
751 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
752 rc |= stat(DummySubdir, &statfs);
753 if (rc == -1) {
754 DMLOG_PRINT(DMLVL_ERR,
755 "Unable to obtain inode!\n");
756 varStatus = DMSTAT_FAIL;
757 } else
758 if (dm_handle_cmp
759 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
760 DMLOG_PRINT(DMLVL_ERR,
761 "Object/entry handles NOT same!\n");
762 varStatus = DMSTAT_FAIL;
763 } else if (ino != statfs.st_ino) {
764 DMLOG_PRINT(DMLVL_ERR,
765 "Object handle NOT correct! (%lld vs %d)\n",
766 ino, statfs.st_ino);
767 varStatus = DMSTAT_FAIL;
768 } else if (statfs.st_uid != DUMMY_UID) {
769 DMLOG_PRINT(DMLVL_ERR,
770 "Object uid NOT correct! (%x vs %x)\n",
771 DUMMY_UID, statfs.st_uid);
772 varStatus = DMSTAT_FAIL;
773 } else if (statfs.st_gid != DUMMY_GID) {
774 DMLOG_PRINT(DMLVL_ERR,
775 "Object gid NOT correct! (%x vs %x)\n",
776 DUMMY_GID, statfs.st_gid);
777 varStatus = DMSTAT_FAIL;
778 } else if (strcmp(name1, DUMMY_SUBDIR) != 0) {
779 DMLOG_PRINT(DMLVL_ERR,
780 "Entry name NOT correct! (%s vs %s)\n",
781 name1, DUMMY_SUBDIR);
782 varStatus = DMSTAT_FAIL;
783 }
784 }
785 DMVAR_END(varStatus);
786
787 /* Variation clean up */
788 EVENT_DELIVERY_DELAY;
789 rc = rmdir(DummySubdir);
790 if (rc == -1) {
791 DMLOG_PRINT(DMLVL_DEBUG,
792 "Unable to clean up variation! (errno = %d)\n",
793 errno);
794 }
795 dm_handle_free(hanp, hlen);
796 }
797 }
798
799 /*
800 * TEST : close - enabled on directory
801 * EXPECTED: DM_EVENT_CLOSE
802 */
803 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 6)) {
804 int fd1, fd2;
805 void *hanp;
806 size_t hlen;
807
808 /* Variation set up */
809 eventExpected = DM_EVENT_CLOSE;
810 eventReceived = DM_EVENT_INVALID;
811 eventResponse = DM_RESP_CONTINUE;
812 if ((rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE)) == -1) {
813 /* No clean up */
814 } else if ((fd1 = open(DummySubdir, O_DIRECTORY)) == -1) {
815 rmdir(DummySubdir);
816 } else if ((fd2 = open(DummySubdir, O_DIRECTORY)) == -1) {
817 close(fd1);
818 rmdir(DummySubdir);
819 } else if ((rc = dm_fd_to_handle(fd2, &hanp, &hlen)) == -1) {
820 close(fd2);
821 close(fd1);
822 rmdir(DummySubdir);
823 } else
824 if ((rc =
825 dm_set_eventlist(sid, hanp, hlen, DM_NO_TOKEN,
826 &AMevents, DM_EVENT_MAX)) == -1) {
827 dm_handle_free(hanp, hlen);
828 close(fd2);
829 close(fd1);
830 rmdir(DummySubdir);
831 }
832 if (fd1 == -1 || fd2 == -1 || fd1 == fd2) {
833 DMLOG_PRINT(DMLVL_DEBUG,
834 "Unable to set up variation! (errno = %d)\n",
835 errno);
836 DMVAR_SKIP();
837 } else {
838 /* Variation */
839 eventExpected = DM_EVENT_INVALID;
840 eventReceived = DM_EVENT_INVALID;
841 EVENT_DELIVERY_DELAY;
842 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1\n", fd1);
843 rc = close(fd1);
844 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1 returned %d\n",
845 fd1, rc);
846 EVENT_DELIVERY_DELAY;
847 if ((varStatus =
848 DMVAR_CHKPASSEXP(0, rc, eventExpected,
849 eventReceived)) == DMSTAT_PASS) {
850 eventExpected = DM_EVENT_CLOSE;
851 EVENT_DELIVERY_DELAY;
852 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #2\n", fd2);
853 rc = close(fd2);
854 DMLOG_PRINT(DMLVL_DEBUG,
855 "close(%d) #2 returned %d\n", fd2,
856 rc);
857 EVENT_DELIVERY_DELAY;
858 varStatus =
859 DMVAR_CHKPASSEXP(0, rc, eventExpected,
860 eventReceived);
861 }
862 DMVAR_END(varStatus);
863
864 /* Variation clean up */
865 EVENT_DELIVERY_DELAY;
866 rc = rmdir(DummySubdir);
867 if (rc == -1) {
868 DMLOG_PRINT(DMLVL_DEBUG,
869 "Unable to clean up variation! (errno = %d)\n",
870 errno);
871 }
872 dm_handle_free(hanp, hlen);
873 }
874 }
875
876 /*
877 * TEST : chmod - enabled on file
878 * EXPECTED: DM_EVENT_ATTRIBUTE
879 */
880 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 4)) {
881 int fd;
882 void *hanp;
883 size_t hlen;
884 dm_ino_t ino;
885
886 /* Variation set up */
887 eventExpected = DM_EVENT_ATTRIBUTE;
888 eventReceived = DM_EVENT_INVALID;
889 eventResponse = DM_RESP_CONTINUE;
890 if ((fd =
891 open(DummyFile, O_RDONLY | O_CREAT,
892 DUMMY_FILE_RO_MODE)) == -1) {
893 /* No clean up */
894 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
895 close(fd);
896 remove(DummyFile);
897 } else if (((rc = close(fd)) == -1) ||
898 ((rc =
899 dm_set_eventlist(sid, hanp, hlen, DM_NO_TOKEN,
900 &AMevents,
901 DM_EVENT_MAX)) == -1)) {
902 dm_handle_free(hanp, hlen);
903 remove(DummyFile);
904 }
905 if (fd == -1 || rc == -1) {
906 DMLOG_PRINT(DMLVL_DEBUG,
907 "Unable to set up variation! (errno = %d)\n",
908 errno);
909 DMVAR_SKIP();
910 } else {
911 /* Variation */
912 EVENT_DELIVERY_DELAY;
913 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s)\n", DummyFile);
914 rc = chmod(DummyFile, O_RDWR);
915 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s) returned %d\n",
916 DummyFile, rc);
917 EVENT_DELIVERY_DELAY;
918 if ((varStatus =
919 DMVAR_CHKPASSEXP(0, rc, eventExpected,
920 eventReceived)) == DMSTAT_PASS) {
921 struct stat statfs;
922
923 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
924 rc |= stat(DummyFile, &statfs);
925 if (rc == -1) {
926 DMLOG_PRINT(DMLVL_ERR,
927 "Unable to obtain inode!\n");
928 varStatus = DMSTAT_FAIL;
929 } else
930 if (dm_handle_cmp
931 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
932 DMLOG_PRINT(DMLVL_ERR,
933 "Object/entry handles NOT same!\n");
934 varStatus = DMSTAT_FAIL;
935 } else if (ino != statfs.st_ino) {
936 DMLOG_PRINT(DMLVL_ERR,
937 "Object handle NOT correct! (%lld vs %d)\n",
938 ino, statfs.st_ino);
939 varStatus = DMSTAT_FAIL;
940 } else if (!(statfs.st_mode & O_RDWR)) {
941 DMLOG_PRINT(DMLVL_ERR,
942 "Object mode NOT correct! (%x vs %x)\n",
943 O_RDWR, statfs.st_mode);
944 varStatus = DMSTAT_FAIL;
945 } else if (strcmp(name1, DUMMY_FILE) != 0) {
946 DMLOG_PRINT(DMLVL_ERR,
947 "Entry name NOT correct! (%s vs %s)\n",
948 name1, DUMMY_FILE);
949 varStatus = DMSTAT_FAIL;
950 }
951 }
952 DMVAR_END(varStatus);
953
954 /* Variation clean up */
955 EVENT_DELIVERY_DELAY;
956 rc = remove(DummyFile);
957 if (rc == -1) {
958 DMLOG_PRINT(DMLVL_DEBUG,
959 "Unable to clean up variation! (errno = %d)\n",
960 errno);
961 }
962 }
963 }
964
965 /*
966 * TEST : chown - enabled on file
967 * EXPECTED: DM_EVENT_ATTRIBUTE
968 */
969 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 5)) {
970 int fd;
971 void *hanp;
972 size_t hlen;
973 dm_ino_t ino;
974
975 /* Variation set up */
976 eventExpected = DM_EVENT_ATTRIBUTE;
977 eventReceived = DM_EVENT_INVALID;
978 eventResponse = DM_RESP_CONTINUE;
979 if ((fd =
980 open(DummyFile, O_RDONLY | O_CREAT,
981 DUMMY_FILE_RO_MODE)) == -1) {
982 /* No clean up */
983 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
984 close(fd);
985 remove(DummyFile);
986 } else if (((rc = close(fd)) == -1) ||
987 ((rc =
988 dm_set_eventlist(sid, hanp, hlen, DM_NO_TOKEN,
989 &AMevents,
990 DM_EVENT_MAX)) == -1)) {
991 dm_handle_free(hanp, hlen);
992 remove(DummyFile);
993 }
994 if (fd == -1 || rc == -1) {
995 DMLOG_PRINT(DMLVL_DEBUG,
996 "Unable to set up variation! (errno = %d)\n",
997 errno);
998 DMVAR_SKIP();
999 } else {
1000 /* Variation */
1001 EVENT_DELIVERY_DELAY;
1002 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s)\n", DummyFile);
1003 rc = chown(DummyFile, DUMMY_UID, DUMMY_GID);
1004 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s) returned %d\n",
1005 DummyFile, rc);
1006 EVENT_DELIVERY_DELAY;
1007 if ((varStatus =
1008 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1009 eventReceived)) == DMSTAT_PASS) {
1010 struct stat statfs;
1011
1012 rc = dm_handle_to_ino(ahanp1, ahlen1, &ino);
1013 rc |= stat(DummyFile, &statfs);
1014 if (rc == -1) {
1015 DMLOG_PRINT(DMLVL_ERR,
1016 "Unable to obtain inode!\n");
1017 varStatus = DMSTAT_FAIL;
1018 } else
1019 if (dm_handle_cmp
1020 (hanp2, hlen2, ahanp1, ahlen1) != 0) {
1021 DMLOG_PRINT(DMLVL_ERR,
1022 "Object/entry handles NOT same!\n");
1023 varStatus = DMSTAT_FAIL;
1024 } else if (ino != statfs.st_ino) {
1025 DMLOG_PRINT(DMLVL_ERR,
1026 "Object handle NOT correct! (%lld vs %d)\n",
1027 ino, statfs.st_ino);
1028 varStatus = DMSTAT_FAIL;
1029 } else if (statfs.st_uid != DUMMY_UID) {
1030 DMLOG_PRINT(DMLVL_ERR,
1031 "Object uid NOT correct! (%x vs %x)\n",
1032 DUMMY_UID, statfs.st_uid);
1033 varStatus = DMSTAT_FAIL;
1034 } else if (statfs.st_gid != DUMMY_GID) {
1035 DMLOG_PRINT(DMLVL_ERR,
1036 "Object gid NOT correct! (%x vs %x)\n",
1037 DUMMY_GID, statfs.st_gid);
1038 varStatus = DMSTAT_FAIL;
1039 } else if (strcmp(name1, DUMMY_FILE) != 0) {
1040 DMLOG_PRINT(DMLVL_ERR,
1041 "Entry name NOT correct! (%s vs %s)\n",
1042 name1, DUMMY_FILE);
1043 varStatus = DMSTAT_FAIL;
1044 }
1045 }
1046 DMVAR_END(varStatus);
1047
1048 /* Variation clean up */
1049 EVENT_DELIVERY_DELAY;
1050 rc = remove(DummyFile);
1051 if (rc == -1) {
1052 DMLOG_PRINT(DMLVL_DEBUG,
1053 "Unable to clean up variation! (errno = %d)\n",
1054 errno);
1055 }
1056 }
1057 }
1058
1059 /*
1060 * TEST : close - enabled on file
1061 * EXPECTED: DM_EVENT_CLOSE
1062 */
1063 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 6)) {
1064 int fd1, fd2;
1065 void *hanp;
1066 size_t hlen;
1067
1068 /* Variation set up */
1069 eventExpected = DM_EVENT_CLOSE;
1070 eventReceived = DM_EVENT_INVALID;
1071 eventResponse = DM_RESP_CONTINUE;
1072 if ((fd1 =
1073 open(DummyFile, O_RDONLY | O_CREAT,
1074 DUMMY_FILE_RO_MODE)) == -1) {
1075 /* No clean up */
1076 } else if ((fd2 = open(DummyFile, O_RDONLY)) == -1) {
1077 close(fd1);
1078 remove(DummyFile);
1079 } else if ((rc = dm_fd_to_handle(fd2, &hanp, &hlen)) == -1) {
1080 close(fd2);
1081 close(fd1);
1082 remove(DummyFile);
1083 } else
1084 if ((rc =
1085 dm_set_eventlist(sid, hanp, hlen, DM_NO_TOKEN,
1086 &AMevents, DM_EVENT_MAX)) == -1) {
1087 dm_handle_free(hanp, hlen);
1088 close(fd2);
1089 close(fd1);
1090 remove(DummyFile);
1091 }
1092 if (fd1 == -1 || fd2 == -1 || fd1 == fd2) {
1093 DMLOG_PRINT(DMLVL_DEBUG,
1094 "Unable to set up variation! (errno = %d)\n",
1095 errno);
1096 DMVAR_SKIP();
1097 } else {
1098 /* Variation */
1099 eventExpected = DM_EVENT_INVALID;
1100 eventReceived = DM_EVENT_INVALID;
1101 EVENT_DELIVERY_DELAY;
1102 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1\n", fd1);
1103 rc = close(fd1);
1104 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1 returned %d\n",
1105 fd1, rc);
1106 EVENT_DELIVERY_DELAY;
1107 if ((varStatus =
1108 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1109 eventReceived)) == DMSTAT_PASS) {
1110 eventExpected = DM_EVENT_CLOSE;
1111 EVENT_DELIVERY_DELAY;
1112 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #2\n", fd2);
1113 rc = close(fd2);
1114 DMLOG_PRINT(DMLVL_DEBUG,
1115 "close(%d) #2 returned %d\n", fd2,
1116 rc);
1117 EVENT_DELIVERY_DELAY;
1118 varStatus =
1119 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1120 eventReceived);
1121 }
1122 DMVAR_END(varStatus);
1123
1124 /* Variation clean up */
1125 EVENT_DELIVERY_DELAY;
1126 rc = remove(DummyFile);
1127 if (rc == -1) {
1128 DMLOG_PRINT(DMLVL_DEBUG,
1129 "Unable to clean up variation! (errno = %d)\n",
1130 errno);
1131 }
1132 dm_handle_free(hanp, hlen);
1133 }
1134 }
1135
1136 /* Wait for all pending messages to be handled */
1137 EVENT_DELIVERY_DELAY_LOOP;
1138
1139 /*
1140 * Last batch of tests will be with events disabled
1141 */
1142
1143 /*
1144 * TEST : chmod - disabled
1145 * EXPECTED: DM_EVENT_ATTRIBUTE
1146 */
1147 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 7)) {
1148
1149 /* Variation set up */
1150 eventExpected = DM_EVENT_ATTRIBUTE;
1151 eventReceived = DM_EVENT_INVALID;
1152 eventResponse = DM_RESP_CONTINUE;
1153 rc = mkdir(DummySubdir, DUMMY_DIR_RO_MODE);
1154 if (rc == -1) {
1155 DMLOG_PRINT(DMLVL_DEBUG,
1156 "Unable to set up variation! (errno = %d)\n",
1157 errno);
1158 DMVAR_SKIP();
1159 } else {
1160 /* Variation */
1161 EVENT_DELIVERY_DELAY;
1162 eventExpected = DM_EVENT_INVALID;
1163 eventReceived = DM_EVENT_INVALID;
1164 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s)\n", DummySubdir);
1165 rc = chmod(DummySubdir, O_RDWR);
1166 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s) returned %d\n",
1167 DummySubdir, rc);
1168 EVENT_DELIVERY_DELAY;
1169 DMVAR_END(DMVAR_CHKPASSEXP
1170 (0, rc, eventExpected, eventReceived));
1171
1172 /* Variation clean up */
1173 EVENT_DELIVERY_DELAY;
1174 rc = rmdir(DummySubdir);
1175 if (rc == -1) {
1176 DMLOG_PRINT(DMLVL_DEBUG,
1177 "Unable to clean up variation! (errno = %d)\n",
1178 errno);
1179 }
1180 }
1181 }
1182
1183 /*
1184 * TEST : chown - disabled
1185 * EXPECTED: DM_EVENT_ATTRIBUTE
1186 */
1187 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 8)) {
1188
1189 /* Variation set up */
1190 eventExpected = DM_EVENT_ATTRIBUTE;
1191 eventReceived = DM_EVENT_INVALID;
1192 eventResponse = DM_RESP_CONTINUE;
1193 rc = mkdir(DummySubdir, DUMMY_DIR_RO_MODE);
1194 if (rc == -1) {
1195 DMLOG_PRINT(DMLVL_DEBUG,
1196 "Unable to set up variation! (errno = %d)\n",
1197 errno);
1198 DMVAR_SKIP();
1199 } else {
1200 /* Variation */
1201 EVENT_DELIVERY_DELAY;
1202 eventExpected = DM_EVENT_INVALID;
1203 eventReceived = DM_EVENT_INVALID;
1204 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s)\n", DummySubdir);
1205 rc = chown(DummySubdir, DUMMY_UID, DUMMY_GID);
1206 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s) returned %d\n",
1207 DummySubdir, rc);
1208 EVENT_DELIVERY_DELAY;
1209 DMVAR_END(DMVAR_CHKPASSEXP
1210 (0, rc, eventExpected, eventReceived));
1211
1212 /* Variation clean up */
1213 EVENT_DELIVERY_DELAY;
1214 rc = rmdir(DummySubdir);
1215 if (rc == -1) {
1216 DMLOG_PRINT(DMLVL_DEBUG,
1217 "Unable to clean up variation! (errno = %d)\n",
1218 errno);
1219 }
1220 }
1221 }
1222
1223 /*
1224 * TEST : close - disabled
1225 * EXPECTED: DM_EVENT_CLOSE
1226 */
1227 if (DMVAR_EXEC(DIR_ASYNC_META_EVENT_BASE + 9)) {
1228 int fd1, fd2;
1229
1230 /* Variation set up */
1231 eventExpected = DM_EVENT_CLOSE;
1232 eventReceived = DM_EVENT_INVALID;
1233 eventResponse = DM_RESP_CONTINUE;
1234 if ((rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE)) == -1) {
1235 /* No clean up */
1236 } else if ((fd1 = open(DummySubdir, O_DIRECTORY)) == -1) {
1237 rmdir(DummySubdir);
1238 } else if ((fd2 = open(DummySubdir, O_DIRECTORY)) == -1) {
1239 close(fd1);
1240 rmdir(DummySubdir);
1241 }
1242 if (fd1 == -1 || fd2 == -1 || fd1 == fd2) {
1243 DMLOG_PRINT(DMLVL_DEBUG,
1244 "Unable to set up variation! (errno = %d)\n",
1245 errno);
1246 DMVAR_SKIP();
1247 } else {
1248 /* Variation */
1249 eventExpected = DM_EVENT_INVALID;
1250 eventReceived = DM_EVENT_INVALID;
1251 EVENT_DELIVERY_DELAY;
1252 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1\n", fd1);
1253 rc = close(fd1);
1254 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1 returned %d\n",
1255 fd1, rc);
1256 EVENT_DELIVERY_DELAY;
1257 if ((varStatus =
1258 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1259 eventReceived)) == DMSTAT_PASS) {
1260 eventExpected = DM_EVENT_INVALID;
1261 eventReceived = DM_EVENT_INVALID;
1262 EVENT_DELIVERY_DELAY;
1263 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #2\n", fd2);
1264 rc = close(fd2);
1265 DMLOG_PRINT(DMLVL_DEBUG,
1266 "close(%d) #2 returned %d\n", fd2,
1267 rc);
1268 EVENT_DELIVERY_DELAY;
1269 varStatus =
1270 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1271 eventReceived);
1272 }
1273 DMVAR_END(varStatus);
1274
1275 /* Variation clean up */
1276 EVENT_DELIVERY_DELAY;
1277 rc = rmdir(DummySubdir);
1278 if (rc == -1) {
1279 DMLOG_PRINT(DMLVL_DEBUG,
1280 "Unable to clean up variation! (errno = %d)\n",
1281 errno);
1282 }
1283 }
1284 }
1285
1286 /*
1287 * TEST : chmod - disabled
1288 * EXPECTED: DM_EVENT_ATTRIBUTE
1289 */
1290 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 7)) {
1291 int fd;
1292
1293 /* Variation set up */
1294 eventExpected = DM_EVENT_ATTRIBUTE;
1295 eventReceived = DM_EVENT_INVALID;
1296 eventResponse = DM_RESP_CONTINUE;
1297 if ((fd =
1298 open(DummyFile, O_RDONLY | O_CREAT,
1299 DUMMY_FILE_RO_MODE)) == -1) {
1300 /* No clean up */
1301 } else if ((rc = close(fd)) == -1) {
1302 remove(DummyFile);
1303 }
1304 if (fd == -1 || rc == -1) {
1305 DMLOG_PRINT(DMLVL_DEBUG,
1306 "Unable to set up variation! (errno = %d)\n",
1307 errno);
1308 DMVAR_SKIP();
1309 } else {
1310 /* Variation */
1311 EVENT_DELIVERY_DELAY;
1312 eventExpected = DM_EVENT_INVALID;
1313 eventReceived = DM_EVENT_INVALID;
1314 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s)\n", DummyFile);
1315 rc = chmod(DummyFile, O_RDWR);
1316 DMLOG_PRINT(DMLVL_DEBUG, "chmod(%s) returned %d\n",
1317 DummyFile, rc);
1318 EVENT_DELIVERY_DELAY;
1319 DMVAR_END(DMVAR_CHKPASSEXP
1320 (0, rc, eventExpected, eventReceived));
1321
1322 /* Variation clean up */
1323 EVENT_DELIVERY_DELAY;
1324 rc = remove(DummyFile);
1325 if (rc == -1) {
1326 DMLOG_PRINT(DMLVL_DEBUG,
1327 "Unable to clean up variation! (errno = %d)\n",
1328 errno);
1329 }
1330 }
1331 }
1332
1333 /*
1334 * TEST : chown - disabled
1335 * EXPECTED: DM_EVENT_ATTRIBUTE
1336 */
1337 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 8)) {
1338 int fd;
1339
1340 /* Variation set up */
1341 eventExpected = DM_EVENT_ATTRIBUTE;
1342 eventReceived = DM_EVENT_INVALID;
1343 eventResponse = DM_RESP_CONTINUE;
1344 if ((fd =
1345 open(DummyFile, O_RDONLY | O_CREAT,
1346 DUMMY_FILE_RO_MODE)) == -1) {
1347 /* No clean up */
1348 } else if ((rc = close(fd)) == -1) {
1349 remove(DummyFile);
1350 }
1351 if (fd == -1 || rc == -1) {
1352 DMLOG_PRINT(DMLVL_DEBUG,
1353 "Unable to set up variation! (errno = %d)\n",
1354 errno);
1355 DMVAR_SKIP();
1356 } else {
1357 /* Variation */
1358 EVENT_DELIVERY_DELAY;
1359 eventExpected = DM_EVENT_INVALID;
1360 eventReceived = DM_EVENT_INVALID;
1361 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s)\n", DummyFile);
1362 rc = chown(DummyFile, DUMMY_UID, DUMMY_GID);
1363 DMLOG_PRINT(DMLVL_DEBUG, "chown(%s) returned %d\n",
1364 DummyFile, rc);
1365 EVENT_DELIVERY_DELAY;
1366 DMVAR_END(DMVAR_CHKPASSEXP
1367 (0, rc, eventExpected, eventReceived));
1368
1369 /* Variation clean up */
1370 EVENT_DELIVERY_DELAY;
1371 rc = remove(DummyFile);
1372 if (rc == -1) {
1373 DMLOG_PRINT(DMLVL_DEBUG,
1374 "Unable to clean up variation! (errno = %d)\n",
1375 errno);
1376 }
1377 }
1378 }
1379
1380 /*
1381 * TEST : close - disabled
1382 * EXPECTED: DM_EVENT_CLOSE
1383 */
1384 if (DMVAR_EXEC(FILE_ASYNC_META_EVENT_BASE + 9)) {
1385 int fd1, fd2;
1386
1387 /* Variation set up */
1388 eventExpected = DM_EVENT_CLOSE;
1389 eventReceived = DM_EVENT_INVALID;
1390 eventResponse = DM_RESP_CONTINUE;
1391 if ((fd1 =
1392 open(DummyFile, O_RDONLY | O_CREAT,
1393 DUMMY_FILE_RO_MODE)) == -1) {
1394 /* No clean up */
1395 } else if ((fd2 = open(DummyFile, O_RDONLY)) == -1) {
1396 close(fd1);
1397 remove(DummyFile);
1398 }
1399 if (fd1 == -1 || fd2 == -1 || fd1 == fd2) {
1400 DMLOG_PRINT(DMLVL_DEBUG,
1401 "Unable to set up variation! (errno = %d)\n",
1402 errno);
1403 DMVAR_SKIP();
1404 } else {
1405 /* Variation */
1406 eventExpected = DM_EVENT_INVALID;
1407 eventReceived = DM_EVENT_INVALID;
1408 EVENT_DELIVERY_DELAY;
1409 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1\n", fd1);
1410 rc = close(fd1);
1411 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #1 returned %d\n",
1412 fd1, rc);
1413 EVENT_DELIVERY_DELAY;
1414 if ((varStatus =
1415 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1416 eventReceived)) == DMSTAT_PASS) {
1417 eventExpected = DM_EVENT_INVALID;
1418 eventReceived = DM_EVENT_INVALID;
1419 EVENT_DELIVERY_DELAY;
1420 DMLOG_PRINT(DMLVL_DEBUG, "close(%d) #2\n", fd2);
1421 rc = close(fd2);
1422 DMLOG_PRINT(DMLVL_DEBUG,
1423 "close(%d) #2 returned %d\n", fd2,
1424 rc);
1425 EVENT_DELIVERY_DELAY;
1426 varStatus =
1427 DMVAR_CHKPASSEXP(0, rc, eventExpected,
1428 eventReceived);
1429 }
1430 DMVAR_END(varStatus);
1431
1432 /* Variation clean up */
1433 EVENT_DELIVERY_DELAY;
1434 rc = remove(DummyFile);
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 /* From here on out we're only interested in the destroy event */
1444 DMEV_ZERO(events);
1445 DMEV_SET(DM_EVENT_PREUNMOUNT, events);
1446 DMEV_SET(DM_EVENT_UNMOUNT, events);
1447 DMEV_SET(DM_EVENT_DESTROY, events);
1448 rc = dm_set_eventlist(sid, fshanp, fshlen, DM_NO_TOKEN, &events,
1449 DM_EVENT_MAX);
1450 if (rc == -1) {
1451 DMLOG_PRINT(DMLVL_ERR,
1452 "dm_set_eventlist failed! (rc = %d, errno = %d)\n",
1453 rc, errno);
1454 dm_destroy_session(sid);
1455 DM_EXIT();
1456 }
1457
1458 rc = dm_get_config(fshanp, fshlen, DM_CONFIG_MAX_ATTR_ON_DESTROY,
1459 &maxAttrSize);
1460 if (rc == -1) {
1461 DMLOG_PRINT(DMLVL_ERR,
1462 "dm_get_config failed! (rc = %d, errno = %d)\n", rc,
1463 errno);
1464 dm_destroy_session(sid);
1465 DM_EXIT();
1466 } else {
1467 DMLOG_PRINT(DMLVL_DEBUG, "DM_CONFIG_MAX_ATTR_ON_DESTROY %d\n",
1468 maxAttrSize);
1469 }
1470
1471 szFuncName = "dm_set_return_on_destroy";
1472
1473 /*
1474 * TEST : dm_set_return_on_destroy - invalid sid
1475 * EXPECTED: rc = -1, errno = EINVAL
1476 */
1477 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 1)) {
1478 int fd;
1479 void *hanp, *fshanp;
1480 size_t hlen, fshlen;
1481 dm_attrname_t attrname;
1482 char buf[ATTR_VALUELEN];
1483
1484 /* Variation set up */
1485 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1486 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1487 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1488 if ((fd =
1489 open(DummyFile, O_RDWR | O_CREAT,
1490 DUMMY_FILE_RW_MODE)) == -1) {
1491 /* No clean up */
1492 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1493 close(fd);
1494 remove(DummyFile);
1495 } else
1496 if (((rc =
1497 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1498 0, sizeof(buf), buf)) == -1)
1499 ||
1500 ((rc =
1501 dm_path_to_fshandle(DummyFile, &fshanp,
1502 &fshlen)) == -1)) {
1503 close(fd);
1504 remove(DummyFile);
1505 dm_handle_free(hanp, hlen);
1506 }
1507 if (fd == -1 || rc == -1) {
1508 DMLOG_PRINT(DMLVL_DEBUG,
1509 "Unable to set up variation! (errno = %d)\n",
1510 errno);
1511 DMVAR_SKIP();
1512 } else {
1513 /* Variation */
1514 EVENT_DELIVERY_DELAY;
1515 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid sid)\n",
1516 szFuncName);
1517 rc = dm_set_return_on_destroy(INVALID_ADDR, fshanp,
1518 fshlen, DM_NO_TOKEN,
1519 &attrname, DM_TRUE);
1520 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
1521
1522 /* Variation clean up */
1523 rc = close(fd);
1524 rc |= remove(DummyFile);
1525 if (rc == -1) {
1526 DMLOG_PRINT(DMLVL_DEBUG,
1527 "Unable to clean up variation! (errno = %d)\n",
1528 errno);
1529 }
1530 dm_handle_free(hanp, hlen);
1531 dm_handle_free(fshanp, fshlen);
1532 }
1533 }
1534
1535 /*
1536 * TEST : dm_set_return_on_destroy - invalid hanp
1537 * EXPECTED: rc = -1, errno = EFAULT
1538 */
1539 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 2)) {
1540 int fd;
1541 void *hanp, *fshanp;
1542 size_t hlen, fshlen;
1543 dm_attrname_t attrname;
1544 char buf[ATTR_VALUELEN];
1545
1546 /* Variation set up */
1547 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1548 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1549 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1550 if ((fd =
1551 open(DummyFile, O_RDWR | O_CREAT,
1552 DUMMY_FILE_RW_MODE)) == -1) {
1553 /* No clean up */
1554 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1555 close(fd);
1556 remove(DummyFile);
1557 } else
1558 if (((rc =
1559 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1560 0, sizeof(buf), buf)) == -1)
1561 ||
1562 ((rc =
1563 dm_path_to_fshandle(DummyFile, &fshanp,
1564 &fshlen)) == -1)) {
1565 close(fd);
1566 remove(DummyFile);
1567 dm_handle_free(hanp, hlen);
1568 }
1569 if (fd == -1 || rc == -1) {
1570 DMLOG_PRINT(DMLVL_DEBUG,
1571 "Unable to set up variation! (errno = %d)\n",
1572 errno);
1573 DMVAR_SKIP();
1574 } else {
1575 /* Variation */
1576 EVENT_DELIVERY_DELAY;
1577 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n",
1578 szFuncName);
1579 rc = dm_set_return_on_destroy(sid, (void *)INVALID_ADDR,
1580 fshlen, DM_NO_TOKEN,
1581 &attrname, DM_TRUE);
1582 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT);
1583
1584 /* Variation clean up */
1585 rc = close(fd);
1586 rc |= remove(DummyFile);
1587 if (rc == -1) {
1588 DMLOG_PRINT(DMLVL_DEBUG,
1589 "Unable to clean up variation! (errno = %d)\n",
1590 errno);
1591 }
1592 dm_handle_free(hanp, hlen);
1593 dm_handle_free(fshanp, fshlen);
1594 }
1595 }
1596
1597 /*
1598 * TEST : dm_set_return_on_destroy - invalid hlen
1599 * EXPECTED: rc = -1, errno = EBADF
1600 */
1601 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 3)) {
1602 int fd;
1603 void *hanp, *fshanp;
1604 size_t hlen, fshlen;
1605 dm_attrname_t attrname;
1606 char buf[ATTR_VALUELEN];
1607
1608 /* Variation set up */
1609 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1610 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1611 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1612 if ((fd =
1613 open(DummyFile, O_RDWR | O_CREAT,
1614 DUMMY_FILE_RW_MODE)) == -1) {
1615 /* No clean up */
1616 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1617 close(fd);
1618 remove(DummyFile);
1619 } else
1620 if (((rc =
1621 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1622 0, sizeof(buf), buf)) == -1)
1623 ||
1624 ((rc =
1625 dm_path_to_fshandle(DummyFile, &fshanp,
1626 &fshlen)) == -1)) {
1627 close(fd);
1628 remove(DummyFile);
1629 dm_handle_free(hanp, hlen);
1630 }
1631 if (fd == -1 || rc == -1) {
1632 DMLOG_PRINT(DMLVL_DEBUG,
1633 "Unable to set up variation! (errno = %d)\n",
1634 errno);
1635 DMVAR_SKIP();
1636 } else {
1637 /* Variation */
1638 EVENT_DELIVERY_DELAY;
1639 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n",
1640 szFuncName);
1641 rc = dm_set_return_on_destroy(sid, fshanp, INVALID_ADDR,
1642 DM_NO_TOKEN, &attrname,
1643 DM_TRUE);
1644 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF);
1645
1646 /* Variation clean up */
1647 rc = close(fd);
1648 rc |= remove(DummyFile);
1649 if (rc == -1) {
1650 DMLOG_PRINT(DMLVL_DEBUG,
1651 "Unable to clean up variation! (errno = %d)\n",
1652 errno);
1653 }
1654 dm_handle_free(hanp, hlen);
1655 dm_handle_free(fshanp, fshlen);
1656 }
1657 }
1658
1659 /*
1660 * TEST : dm_set_return_on_destroy - invalid token
1661 * EXPECTED: rc = -1, errno = EINVAL
1662 */
1663 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 4)) {
1664 int fd;
1665 void *hanp, *fshanp;
1666 size_t hlen, fshlen;
1667 dm_attrname_t attrname;
1668 char buf[ATTR_VALUELEN];
1669
1670 /* Variation set up */
1671 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1672 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1673 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1674 if ((fd =
1675 open(DummyFile, O_RDWR | O_CREAT,
1676 DUMMY_FILE_RW_MODE)) == -1) {
1677 /* No clean up */
1678 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1679 close(fd);
1680 remove(DummyFile);
1681 } else
1682 if (((rc =
1683 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1684 0, sizeof(buf), buf)) == -1)
1685 ||
1686 ((rc =
1687 dm_path_to_fshandle(DummyFile, &fshanp,
1688 &fshlen)) == -1)) {
1689 close(fd);
1690 remove(DummyFile);
1691 dm_handle_free(hanp, hlen);
1692 }
1693 if (fd == -1 || rc == -1) {
1694 DMLOG_PRINT(DMLVL_DEBUG,
1695 "Unable to set up variation! (errno = %d)\n",
1696 errno);
1697 DMVAR_SKIP();
1698 } else {
1699 /* Variation */
1700 EVENT_DELIVERY_DELAY;
1701 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid token)\n",
1702 szFuncName);
1703 rc = dm_set_return_on_destroy(sid, fshanp, fshlen,
1704 INVALID_ADDR, &attrname,
1705 DM_TRUE);
1706 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
1707
1708 /* Variation clean up */
1709 rc = close(fd);
1710 rc |= remove(DummyFile);
1711 if (rc == -1) {
1712 DMLOG_PRINT(DMLVL_DEBUG,
1713 "Unable to clean up variation! (errno = %d)\n",
1714 errno);
1715 }
1716 dm_handle_free(hanp, hlen);
1717 dm_handle_free(fshanp, fshlen);
1718 }
1719 }
1720
1721 /*
1722 * TEST : dm_set_return_on_destroy - invalid attrnamep
1723 * EXPECTED: rc = -1, errno = EFAULT
1724 *
1725 * This variation uncovered XFS BUG #14 (non-0 return code from
1726 * copy_from_user returned)
1727 */
1728 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 5)) {
1729 int fd;
1730 void *hanp, *fshanp;
1731 size_t hlen, fshlen;
1732 dm_attrname_t attrname;
1733 char buf[ATTR_VALUELEN];
1734
1735 /* Variation set up */
1736 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1737 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1738 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1739 if ((fd =
1740 open(DummyFile, O_RDWR | O_CREAT,
1741 DUMMY_FILE_RW_MODE)) == -1) {
1742 /* No clean up */
1743 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1744 close(fd);
1745 remove(DummyFile);
1746 } else
1747 if (((rc =
1748 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1749 0, sizeof(buf), buf)) == -1)
1750 ||
1751 ((rc =
1752 dm_path_to_fshandle(DummyFile, &fshanp,
1753 &fshlen)) == -1)) {
1754 close(fd);
1755 remove(DummyFile);
1756 dm_handle_free(hanp, hlen);
1757 }
1758 if (fd == -1 || rc == -1) {
1759 DMLOG_PRINT(DMLVL_DEBUG,
1760 "Unable to set up variation! (errno = %d)\n",
1761 errno);
1762 DMVAR_SKIP();
1763 } else {
1764 /* Variation */
1765 EVENT_DELIVERY_DELAY;
1766 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid attrnamep)\n",
1767 szFuncName);
1768 rc = dm_set_return_on_destroy(sid, fshanp, fshlen,
1769 DM_NO_TOKEN,
1770 (dm_attrname_t *)
1771 INVALID_ADDR, DM_TRUE);
1772 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT);
1773
1774 /* Variation clean up */
1775 rc = close(fd);
1776 rc |= remove(DummyFile);
1777 if (rc == -1) {
1778 DMLOG_PRINT(DMLVL_DEBUG,
1779 "Unable to clean up variation! (errno = %d)\n",
1780 errno);
1781 }
1782 dm_handle_free(hanp, hlen);
1783 dm_handle_free(fshanp, fshlen);
1784 }
1785 }
1786
1787 /*
1788 * TEST : dm_set_return_on_destroy - DM_NO_SESSION sid
1789 * EXPECTED: rc = -1, errno = EINVAL
1790 */
1791 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 6)) {
1792 int fd;
1793 void *hanp, *fshanp;
1794 size_t hlen, fshlen;
1795 dm_attrname_t attrname;
1796 char buf[ATTR_VALUELEN];
1797
1798 /* Variation set up */
1799 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1800 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1801 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1802 if ((fd =
1803 open(DummyFile, O_RDWR | O_CREAT,
1804 DUMMY_FILE_RW_MODE)) == -1) {
1805 /* No clean up */
1806 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1807 close(fd);
1808 remove(DummyFile);
1809 } else
1810 if (((rc =
1811 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1812 0, sizeof(buf), buf)) == -1)
1813 ||
1814 ((rc =
1815 dm_path_to_fshandle(DummyFile, &fshanp,
1816 &fshlen)) == -1)) {
1817 close(fd);
1818 remove(DummyFile);
1819 dm_handle_free(hanp, hlen);
1820 }
1821 if (fd == -1 || rc == -1) {
1822 DMLOG_PRINT(DMLVL_DEBUG,
1823 "Unable to set up variation! (errno = %d)\n",
1824 errno);
1825 DMVAR_SKIP();
1826 } else {
1827 /* Variation */
1828 EVENT_DELIVERY_DELAY;
1829 DMLOG_PRINT(DMLVL_DEBUG, "%s(DM_NO_SESSION sid)\n",
1830 szFuncName);
1831 rc = dm_set_return_on_destroy(DM_NO_SESSION, fshanp,
1832 fshlen, DM_NO_TOKEN,
1833 &attrname, DM_TRUE);
1834 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
1835
1836 /* Variation clean up */
1837 rc = close(fd);
1838 rc |= remove(DummyFile);
1839 if (rc == -1) {
1840 DMLOG_PRINT(DMLVL_DEBUG,
1841 "Unable to clean up variation! (errno = %d)\n",
1842 errno);
1843 }
1844 dm_handle_free(hanp, hlen);
1845 dm_handle_free(fshanp, fshlen);
1846 }
1847 }
1848
1849 /*
1850 * TEST : dm_set_return_on_destroy - different sid
1851 * EXPECTED: rc = -1, errno = EINVAL
1852 */
1853 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 7)) {
1854 int fd;
1855 void *hanp, *fshanp;
1856 size_t hlen, fshlen;
1857 dm_attrname_t attrname;
1858 char buf[ATTR_VALUELEN];
1859 dm_sessid_t newsid;
1860
1861 /* Variation set up */
1862 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1863 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1864 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1865 if ((fd =
1866 open(DummyFile, O_RDWR | O_CREAT,
1867 DUMMY_FILE_RW_MODE)) == -1) {
1868 /* No clean up */
1869 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1870 close(fd);
1871 remove(DummyFile);
1872 } else
1873 if (((rc =
1874 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1875 0, sizeof(buf), buf)) == -1)
1876 ||
1877 ((rc =
1878 dm_path_to_fshandle(DummyFile, &fshanp,
1879 &fshlen)) == -1)) {
1880 close(fd);
1881 remove(DummyFile);
1882 dm_handle_free(hanp, hlen);
1883 } else
1884 if ((rc =
1885 dm_create_session(DM_NO_SESSION, szSessionInfo,
1886 &newsid)) == -1) {
1887 close(fd);
1888 remove(DummyFile);
1889 dm_handle_free(hanp, hlen);
1890 dm_handle_free(fshanp, fshlen);
1891 }
1892 if (fd == -1 || rc == -1) {
1893 DMLOG_PRINT(DMLVL_DEBUG,
1894 "Unable to set up variation! (errno = %d)\n",
1895 errno);
1896 DMVAR_SKIP();
1897 } else {
1898 /* Variation */
1899 EVENT_DELIVERY_DELAY;
1900 DMLOG_PRINT(DMLVL_DEBUG, "%s(different sid)\n",
1901 szFuncName);
1902 rc = dm_set_return_on_destroy(newsid, fshanp, fshlen,
1903 DM_NO_TOKEN, &attrname,
1904 DM_FALSE);
1905 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
1906
1907 /* Variation clean up */
1908 rc = close(fd);
1909 rc |= remove(DummyFile);
1910 rc |= dm_destroy_session(newsid);
1911 if (rc == -1) {
1912 DMLOG_PRINT(DMLVL_DEBUG,
1913 "Unable to clean up variation! (errno = %d)\n",
1914 errno);
1915 }
1916 dm_handle_free(hanp, hlen);
1917 dm_handle_free(fshanp, fshlen);
1918 }
1919 }
1920
1921 /*
1922 * TEST : dm_set_return_on_destroy - file handle
1923 * EXPECTED: rc = -1, errno = EINVAL
1924 */
1925 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 8)) {
1926 int fd;
1927 void *hanp;
1928 size_t hlen;
1929 dm_attrname_t attrname;
1930 char buf[ATTR_VALUELEN];
1931
1932 /* Variation set up */
1933 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1934 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1935 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1936 if ((fd =
1937 open(DummyFile, O_RDWR | O_CREAT,
1938 DUMMY_FILE_RW_MODE)) == -1) {
1939 /* No clean up */
1940 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
1941 close(fd);
1942 remove(DummyFile);
1943 } else
1944 if ((rc =
1945 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
1946 0, sizeof(buf), buf)) == -1) {
1947 close(fd);
1948 remove(DummyFile);
1949 dm_handle_free(hanp, hlen);
1950 }
1951 if (fd == -1 || rc == -1) {
1952 DMLOG_PRINT(DMLVL_DEBUG,
1953 "Unable to set up variation! (errno = %d)\n",
1954 errno);
1955 DMVAR_SKIP();
1956 } else {
1957 /* Variation */
1958 EVENT_DELIVERY_DELAY;
1959 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n",
1960 szFuncName);
1961 rc = dm_set_return_on_destroy(sid, hanp, hlen,
1962 DM_NO_TOKEN, &attrname,
1963 DM_TRUE);
1964 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
1965
1966 /* Variation clean up */
1967 rc = close(fd);
1968 rc |= remove(DummyFile);
1969 if (rc == -1) {
1970 DMLOG_PRINT(DMLVL_DEBUG,
1971 "Unable to clean up variation! (errno = %d)\n",
1972 errno);
1973 }
1974 dm_handle_free(hanp, hlen);
1975 }
1976 }
1977
1978 /*
1979 * TEST : dm_set_return_on_destroy - directory handle
1980 * EXPECTED: rc = -1, errno = EINVAL
1981 */
1982 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 9)) {
1983 void *hanp;
1984 size_t hlen;
1985 dm_attrname_t attrname;
1986 char buf[ATTR_VALUELEN];
1987
1988 /* Variation set up */
1989 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
1990 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
1991 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
1992 if ((rc = mkdir(DummySubdir, DUMMY_DIR_RW_MODE)) == -1) {
1993 /* No clean up */
1994 } else if ((rc = dm_path_to_handle(DummySubdir, &hanp, &hlen))
1995 == -1) {
1996 rmdir(DummySubdir);
1997 } else
1998 if ((rc =
1999 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
2000 0, sizeof(buf), buf)) == -1) {
2001 rmdir(DummySubdir);
2002 dm_handle_free(hanp, hlen);
2003 }
2004 if (rc == -1) {
2005 DMLOG_PRINT(DMLVL_DEBUG,
2006 "Unable to set up variation! (errno = %d)\n",
2007 errno);
2008 DMVAR_SKIP();
2009 } else {
2010 /* Variation */
2011 EVENT_DELIVERY_DELAY;
2012 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n",
2013 szFuncName);
2014 rc = dm_set_return_on_destroy(sid, hanp, hlen,
2015 DM_NO_TOKEN, &attrname,
2016 DM_TRUE);
2017 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
2018
2019 /* Variation clean up */
2020 rc = rmdir(DummySubdir);
2021 if (rc == -1) {
2022 DMLOG_PRINT(DMLVL_DEBUG,
2023 "Unable to clean up variation! (errno = %d)\n",
2024 errno);
2025 }
2026 dm_handle_free(hanp, hlen);
2027 }
2028 }
2029
2030 /*
2031 * TEST : dm_set_return_on_destroy - global handle
2032 * EXPECTED: rc = -1, errno = EBADF
2033 */
2034 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 10)) {
2035 dm_attrname_t attrname;
2036
2037 /* Variation set up */
2038 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
2039 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
2040
2041 /* Variation */
2042 EVENT_DELIVERY_DELAY;
2043 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName);
2044 rc = dm_set_return_on_destroy(sid, DM_GLOBAL_HANP,
2045 DM_GLOBAL_HLEN, DM_NO_TOKEN,
2046 &attrname, DM_TRUE);
2047 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF);
2048
2049 /* Variation clean up */
2050 }
2051
2052 /*
2053 * TEST : dm_set_return_on_destroy - valid
2054 * EXPECTED: rc = -1, errno = EINVAL
2055 */
2056 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 11)) {
2057 int fd;
2058 void *hanp, *fshanp;
2059 size_t hlen, fshlen;
2060 dm_attrname_t attrname;
2061 char buf[ATTR_VALUELEN];
2062
2063 /* Variation set up */
2064 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
2065 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
2066 memcpy(buf, ATTR_VALUE, ATTR_VALUELEN);
2067 if ((fd =
2068 open(DummyFile, O_RDWR | O_CREAT,
2069 DUMMY_FILE_RW_MODE)) == -1) {
2070 /* No clean up */
2071 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
2072 close(fd);
2073 remove(DummyFile);
2074 } else
2075 if (((rc =
2076 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
2077 0, sizeof(buf), buf)) == -1)
2078 ||
2079 ((rc =
2080 dm_path_to_fshandle(DummyFile, &fshanp,
2081 &fshlen)) == -1)) {
2082 close(fd);
2083 remove(DummyFile);
2084 dm_handle_free(hanp, hlen);
2085 }
2086 if (fd == -1 || rc == -1) {
2087 DMLOG_PRINT(DMLVL_DEBUG,
2088 "Unable to set up variation! (errno = %d)\n",
2089 errno);
2090 DMVAR_SKIP();
2091 } else {
2092 /* Variation */
2093 EVENT_DELIVERY_DELAY;
2094 DMLOG_PRINT(DMLVL_DEBUG, "%s(valid)\n", szFuncName);
2095 rc = dm_set_return_on_destroy(sid, fshanp, fshlen,
2096 DM_NO_TOKEN, &attrname,
2097 DM_TRUE);
2098 DMVAR_ENDPASSEXP(szFuncName, 0, rc);
2099
2100 /* Variation clean up */
2101 rc = close(fd);
2102 rc |= remove(DummyFile);
2103 if (rc == -1) {
2104 DMLOG_PRINT(DMLVL_DEBUG,
2105 "Unable to clean up variation! (errno = %d)\n",
2106 errno);
2107 }
2108 dm_handle_free(hanp, hlen);
2109 dm_handle_free(fshanp, fshlen);
2110 }
2111 }
2112
2113 /*
2114 * TEST : dm_set_return_on_destroy - zero length attribute
2115 * EXPECTED: rc = -1, errno = EINVAL
2116 */
2117 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 12)) {
2118 int fd;
2119 void *hanp, *fshanp;
2120 size_t hlen, fshlen;
2121 dm_attrname_t attrname;
2122
2123 /* Variation set up */
2124 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
2125 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
2126 if ((fd =
2127 open(DummyFile, O_RDWR | O_CREAT,
2128 DUMMY_FILE_RW_MODE)) == -1) {
2129 /* No clean up */
2130 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
2131 close(fd);
2132 remove(DummyFile);
2133 } else
2134 if (((rc =
2135 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN, &attrname,
2136 0, 0, NULL)) == -1)
2137 ||
2138 ((rc =
2139 dm_path_to_fshandle(DummyFile, &fshanp,
2140 &fshlen)) == -1)) {
2141 close(fd);
2142 remove(DummyFile);
2143 dm_handle_free(hanp, hlen);
2144 }
2145 if (fd == -1 || rc == -1) {
2146 DMLOG_PRINT(DMLVL_DEBUG,
2147 "Unable to set up variation! (errno = %d)\n",
2148 errno);
2149 DMVAR_SKIP();
2150 } else {
2151 /* Variation */
2152 EVENT_DELIVERY_DELAY;
2153 DMLOG_PRINT(DMLVL_DEBUG, "%s(zero len attr)\n",
2154 szFuncName);
2155 rc = dm_set_return_on_destroy(sid, fshanp, fshlen,
2156 DM_NO_TOKEN, &attrname,
2157 DM_TRUE);
2158 DMVAR_ENDPASSEXP(szFuncName, 0, rc);
2159
2160 /* Variation clean up */
2161 rc = close(fd);
2162 rc |= remove(DummyFile);
2163 if (rc == -1) {
2164 DMLOG_PRINT(DMLVL_DEBUG,
2165 "Unable to clean up variation! (errno = %d)\n",
2166 errno);
2167 }
2168 dm_handle_free(hanp, hlen);
2169 dm_handle_free(fshanp, fshlen);
2170 }
2171 }
2172
2173 /*
2174 * TEST : dm_set_return_on_destroy - attribute too big
2175 * EXPECTED: rc = 0
2176 */
2177 if (DMVAR_EXEC(SET_RETURN_ON_DESTROY_BASE + 13)) {
2178 int fd;
2179 void *hanp, *fshanp;
2180 size_t hlen, fshlen;
2181 dm_attrname_t attrname;
2182 char *buf;
2183
2184 /* Variation set up */
2185 memset(attrname.an_chars, 0, DM_ATTR_NAME_SIZE);
2186 memcpy(attrname.an_chars, ATTR_NAME, DM_ATTR_NAME_SIZE);
2187 if ((fd =
2188 open(DummyFile, O_RDWR | O_CREAT,
2189 DUMMY_FILE_RW_MODE)) == -1) {
2190 /* No clean up */
2191 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
2192 close(fd);
2193 remove(DummyFile);
2194 } else if ((buf = malloc(maxAttrSize + 1)) == NULL) {
2195 dm_handle_free(hanp, hlen);
2196 close(fd);
2197 remove(DummyFile);
2198 } else if ((memset(buf, '4', maxAttrSize + 1) == NULL) ||
2199 ((rc =
2200 dm_set_dmattr(sid, hanp, hlen, DM_NO_TOKEN,
2201 &attrname, 0, maxAttrSize + 1,
2202 buf)) == -1)
2203 ||
2204 ((rc =
2205 dm_path_to_fshandle(DummyFile, &fshanp,
2206 &fshlen)) == -1)) {
2207 free(buf);
2208 dm_handle_free(hanp, hlen);
2209 close(fd);
2210 remove(DummyFile);
2211 }
2212 if (fd == -1 || rc == -1 || buf == NULL) {
2213 DMLOG_PRINT(DMLVL_DEBUG,
2214 "Unable to set up variation! (errno = %d)\n",
2215 errno);
2216 DMVAR_SKIP();
2217 } else {
2218 /* Variation */
2219 EVENT_DELIVERY_DELAY;
2220 DMLOG_PRINT(DMLVL_DEBUG, "%s(attr too big)\n",
2221 szFuncName);
2222 rc = dm_set_return_on_destroy(sid, fshanp, fshlen,
2223 DM_NO_TOKEN, &attrname,
2224 DM_TRUE);
2225 DMVAR_ENDPASSEXP(szFuncName, 0, rc);
2226
2227 /* Variation clean up */
2228 rc = close(fd);
2229 rc |= remove(DummyFile);
2230 if (rc == -1) {
2231 DMLOG_PRINT(DMLVL_DEBUG,
2232 "Unable to clean up variation! (errno = %d)\n",
2233 errno);
2234 }
2235 free(buf);
2236 dm_handle_free(hanp, hlen);
2237 dm_handle_free(fshanp, fshlen);
2238 }
2239 }
2240
2241 dm_handle_free(fshanp, fshlen);
2242
2243 /* Wait for all pending messages to be handled */
2244 EVENT_DELIVERY_DELAY_LOOP;
2245
2246 rc = umount(mountPt);
2247 if (rc == -1) {
2248 DMLOG_PRINT(DMLVL_ERR, "umount failed! (rc = %d, errno = %d)\n",
2249 rc, errno);
2250 }
2251
2252 pthread_join(tid, NULL);
2253
2254 rc = dm_destroy_session(sid);
2255 if (rc == -1) {
2256 DMLOG_PRINT(DMLVL_ERR,
2257 "dm_destroy_session failed! (rc = %d, errno = %d)\n",
2258 rc, errno);
2259 }
2260
2261 DMLOG_STOP();
2262
2263 tst_exit();
2264 }
2265
Thread(void * parm)2266 void *Thread(void *parm)
2267 {
2268 int rc;
2269 size_t dmMsgBufLen;
2270 dm_eventmsg_t *dmMsg;
2271 int bMounted = DM_FALSE;
2272 int type;
2273 dm_token_t token;
2274 dm_eventset_t events;
2275 dm_response_t response;
2276
2277 do {
2278 /* Loop until message received (wait could be interrupted) */
2279 do {
2280 DMLOG_PRINT(DMLVL_DEBUG, "Waiting for event...\n");
2281 dmMsgBufLen = 0;
2282
2283 rc = dm_get_events(sid, 1, DM_EV_WAIT, sizeof(dmMsgBuf),
2284 dmMsgBuf, &dmMsgBufLen);
2285 DMLOG_PRINT(DMLVL_DEBUG,
2286 "... dm_get_events returned %d (errno %d)\n",
2287 rc, errno);
2288 } while ((rc == -1) && (errno == EINTR) && (dmMsgBufLen == 0));
2289
2290 if (rc) {
2291 DMLOG_PRINT(DMLVL_ERR,
2292 "dm_get_events failed with rc = %d, errno = %d\n",
2293 rc, errno);
2294 dm_destroy_session(sid);
2295 DM_EXIT();
2296 } else {
2297 dmMsg = (dm_eventmsg_t *) dmMsgBuf;
2298 token = dmMsg->ev_token;
2299 type = dmMsg->ev_type;
2300
2301 DMLOG_PRINT(DMLVL_DEBUG, "Received message %d\n", type);
2302 }
2303
2304 if (type == DM_EVENT_MOUNT) {
2305 /* SPECIAL CASE: need to set disposition, events and response */
2306 dm_mount_event_t *me =
2307 DM_GET_VALUE(dmMsg, ev_data, dm_mount_event_t *);
2308 void *lhanp = DM_GET_VALUE(me, me_handle1, void *);
2309 size_t lhlen = DM_GET_LEN(me, me_handle1);
2310
2311 DMLOG_PRINT(DMLVL_DEBUG, "Message is DM_EVENT_MOUNT\n");
2312 DMLOG_PRINT(DMLVL_DEBUG, " Mode: %x\n", me->me_mode);
2313 DMLOG_PRINT(DMLVL_DEBUG, " File system handle: %p\n",
2314 lhanp);
2315 DMLOG_PRINT(DMLVL_DEBUG,
2316 " File system handle length: %d\n", lhlen);
2317 DMLOG_PRINT(DMLVL_DEBUG, " Mountpoint handle: %p\n",
2318 DM_GET_VALUE(me, me_handle2, void *));
2319 DMLOG_PRINT(DMLVL_DEBUG,
2320 " Mountpoint handle length: %d\n",
2321 DM_GET_LEN(me, me_handle2));
2322 DMLOG_PRINT(DMLVL_DEBUG, " Mountpoint path: %s\n",
2323 DM_GET_VALUE(me, me_name1, char *));
2324 DMLOG_PRINT(DMLVL_DEBUG, " Media designator: %s\n",
2325 DM_GET_VALUE(me, me_name2, char *));
2326 DMLOG_PRINT(DMLVL_DEBUG, " Root handle: %p\n",
2327 DM_GET_VALUE(me, me_roothandle, void *));
2328 DMLOG_PRINT(DMLVL_DEBUG, " Root handle length: %d\n",
2329 DM_GET_LEN(me, me_roothandle));
2330
2331 bMounted = dm_handle_is_valid(lhanp, lhlen);
2332
2333 /*rc = dm_request_right(sid, lhanp, lhlen, token, DM_RR_WAIT, DM_RIGHT_EXCL);
2334 if (rc == -1) {
2335 DMLOG_PRINT(DMLVL_ERR, "dm_request_right failed! (rc = %d, errno = %d)\n", rc, errno);
2336 dm_destroy_session(sid);
2337 DM_EXIT();
2338 } */
2339
2340 DMEV_ZERO(events);
2341 DMEV_SET(DM_EVENT_PREUNMOUNT, events);
2342 DMEV_SET(DM_EVENT_UNMOUNT, events);
2343 DMEV_SET(DM_EVENT_POSTCREATE, events);
2344 DMEV_SET(DM_EVENT_ATTRIBUTE, events);
2345 DMEV_SET(DM_EVENT_CLOSE, events);
2346 DMEV_SET(DM_EVENT_DESTROY, events);
2347 rc = dm_set_disp(sid, lhanp, lhlen, DM_NO_TOKEN,
2348 &events, DM_EVENT_MAX);
2349 if (rc == -1) {
2350 DMLOG_PRINT(DMLVL_ERR,
2351 "dm_set_disp failed! (rc = %d, errno = %d)\n",
2352 rc, errno);
2353 dm_destroy_session(sid);
2354 DM_EXIT();
2355 }
2356
2357 /*rc = dm_release_right(sid, lhanp, lhlen, token);
2358 if (rc == -1) {
2359 DMLOG_PRINT(DMLVL_ERR, "dm_request_right failed! (rc = %d, errno = %d)\n", rc, errno);
2360 dm_destroy_session(sid);
2361 DM_EXIT();
2362 } */
2363
2364 response = DM_RESP_CONTINUE;
2365 } else if (type == DM_EVENT_PREUNMOUNT) {
2366 /* SPECIAL CASE: need to set response */
2367 dm_namesp_event_t *nse =
2368 DM_GET_VALUE(dmMsg, ev_data, dm_namesp_event_t *);
2369
2370 DMLOG_PRINT(DMLVL_DEBUG,
2371 "Message is DM_EVENT_PREUNMOUNT\n");
2372 DMLOG_PRINT(DMLVL_DEBUG, " Unmount mode: %x\n",
2373 nse->ne_mode);
2374 DMLOG_PRINT(DMLVL_DEBUG, " File system handle: %p\n",
2375 DM_GET_VALUE(nse, ne_handle1, void *));
2376 DMLOG_PRINT(DMLVL_DEBUG,
2377 " File system handle length: %d\n",
2378 DM_GET_LEN(nse, ne_handle1));
2379 DMLOG_PRINT(DMLVL_DEBUG,
2380 " Root directory handle: %p\n",
2381 DM_GET_VALUE(nse, ne_handle2, void *));
2382 DMLOG_PRINT(DMLVL_DEBUG,
2383 " Root directory handle length: %d\n",
2384 DM_GET_LEN(nse, ne_handle2));
2385
2386 response = DM_RESP_CONTINUE;
2387 } else if (type == DM_EVENT_UNMOUNT) {
2388 /* SPECIAL CASE: need to set response and bMounted */
2389 dm_namesp_event_t *nse =
2390 DM_GET_VALUE(dmMsg, ev_data, dm_namesp_event_t *);
2391
2392 DMLOG_PRINT(DMLVL_DEBUG,
2393 "Message is DM_EVENT_UNMOUNT\n");
2394 DMLOG_PRINT(DMLVL_DEBUG, " Unmount mode: %x\n",
2395 nse->ne_mode);
2396 DMLOG_PRINT(DMLVL_DEBUG, " File system handle: %p\n",
2397 DM_GET_VALUE(nse, ne_handle1, void *));
2398 DMLOG_PRINT(DMLVL_DEBUG,
2399 " File system handle length: %d\n",
2400 DM_GET_LEN(nse, ne_handle1));
2401 DMLOG_PRINT(DMLVL_DEBUG, " Return code: %x\n",
2402 nse->ne_retcode);
2403 if (nse->ne_retcode == 0) {
2404 bMounted = DM_FALSE;
2405 }
2406
2407 response = DM_RESP_CONTINUE;
2408 } else if (type == DM_EVENT_POSTCREATE) {
2409 /* SPECIAL CASE: need to save entry info */
2410 dm_namesp_event_t *nse =
2411 DM_GET_VALUE(dmMsg, ev_data, dm_namesp_event_t *);
2412 hanp2 = DM_GET_VALUE(nse, ne_handle2, void *);
2413 hlen2 = DM_GET_LEN(nse, ne_handle2);
2414 strcpy(name1, DM_GET_VALUE(nse, ne_name1, char *));
2415
2416 DMLOG_PRINT(DMLVL_DEBUG,
2417 "Message is DM_EVENT_POSTCREATE\n");
2418 DMLOG_PRINT(DMLVL_DEBUG, " Mode: %x\n", nse->ne_mode);
2419 DMLOG_PRINT(DMLVL_DEBUG, " Parent handle: %p\n",
2420 DM_GET_VALUE(nse, ne_handle1, void *));
2421 DMLOG_PRINT(DMLVL_DEBUG, " Parent handle length: %d\n",
2422 DM_GET_LEN(nse, ne_handle1));
2423 DMLOG_PRINT(DMLVL_DEBUG, " Entry handle: %p\n", hanp2);
2424 DMLOG_PRINT(DMLVL_DEBUG, " Entry handle length: %d\n",
2425 hlen2);
2426 DMLOG_PRINT(DMLVL_DEBUG, " Entry name: %s\n", name1);
2427 DMLOG_PRINT(DMLVL_DEBUG, " Return code: %x\n",
2428 nse->ne_retcode);
2429
2430 /* No response needed */
2431 response = DM_RESP_INVALID;
2432 } else {
2433 eventReceived = type;
2434 response = eventResponse;
2435
2436 switch (type) {
2437 case DM_EVENT_ATTRIBUTE:
2438 {
2439 dm_namesp_event_t *nse =
2440 DM_GET_VALUE(dmMsg, ev_data,
2441 dm_namesp_event_t *);
2442 ahanp1 =
2443 DM_GET_VALUE(nse, ne_handle1,
2444 void *);
2445 ahlen1 = DM_GET_LEN(nse, ne_handle1);
2446
2447 DMLOG_PRINT(DMLVL_DEBUG,
2448 "Message is DM_EVENT_ATTRIBUTE\n");
2449 DMLOG_PRINT(DMLVL_DEBUG,
2450 " Object handle: %p\n",
2451 ahanp1);
2452 DMLOG_PRINT(DMLVL_DEBUG,
2453 " Object handle length: %d\n",
2454 ahlen1);
2455
2456 response = DM_RESP_INVALID;
2457 break;
2458 }
2459
2460 case DM_EVENT_CLOSE:
2461 {
2462 dm_namesp_event_t *nse =
2463 DM_GET_VALUE(dmMsg, ev_data,
2464 dm_namesp_event_t *);
2465 ahanp1 =
2466 DM_GET_VALUE(nse, ne_handle1,
2467 void *);
2468 ahlen1 = DM_GET_LEN(nse, ne_handle1);
2469
2470 DMLOG_PRINT(DMLVL_DEBUG,
2471 "Message is DM_EVENT_CLOSE\n");
2472 DMLOG_PRINT(DMLVL_DEBUG,
2473 " Object handle: %p\n",
2474 ahanp1);
2475 DMLOG_PRINT(DMLVL_DEBUG,
2476 " Object handle length: %d\n",
2477 ahlen1);
2478
2479 response = DM_RESP_INVALID;
2480 break;
2481 }
2482
2483 case DM_EVENT_DESTROY:
2484 {
2485 dm_destroy_event_t *de =
2486 DM_GET_VALUE(dmMsg, ev_data,
2487 dm_destroy_event_t *);
2488 ahanp1 =
2489 DM_GET_VALUE(de, ds_handle, void *);
2490 ahlen1 = DM_GET_LEN(de, ds_handle);
2491
2492 DMLOG_PRINT(DMLVL_DEBUG,
2493 "Message is DM_EVENT_DESTROY\n");
2494 DMLOG_PRINT(DMLVL_DEBUG,
2495 " Object handle: %p\n",
2496 ahanp1);
2497 DMLOG_PRINT(DMLVL_DEBUG,
2498 " Object handle length: %d\n",
2499 ahlen1);
2500 if (de->ds_attrname.an_chars[0]) {
2501 int attrlen =
2502 DM_GET_LEN(de, ds_attrcopy);
2503
2504 DMLOG_PRINT(DMLVL_DEBUG,
2505 " Attribute name: %.*s\n",
2506 8,
2507 de->ds_attrname.
2508 an_chars);
2509 DMLOG_PRINT(DMLVL_DEBUG,
2510 " Attribute value length: %d\n",
2511 attrlen);
2512 if (attrlen) {
2513 DMLOG_PRINT(DMLVL_DEBUG,
2514 " Attribute value: %s\n",
2515 DM_GET_VALUE
2516 (de,
2517 ds_attrcopy,
2518 char *));
2519 }
2520 }
2521
2522 response = DM_RESP_INVALID;
2523 break;
2524 }
2525
2526 default:
2527 {
2528 DMLOG_PRINT(DMLVL_ERR,
2529 "Message is unexpected!\n");
2530 response = DM_RESP_ABORT;
2531 break;
2532 }
2533 }
2534 }
2535
2536 if (response != DM_RESP_INVALID) {
2537 DMLOG_PRINT(DMLVL_DEBUG,
2538 "Responding to message %d with %d\n", type,
2539 response);
2540 rc = dm_respond_event(sid, token, response,
2541 response ==
2542 DM_RESP_ABORT ? ABORT_ERRNO : 0,
2543 0, NULL);
2544 }
2545 } while (bMounted);
2546
2547 pthread_exit(0);
2548 }
2549