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