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