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