int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ int i; struct test_case_t tc; /* parse standard options */ if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *)NULL) { tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg); } setup(); /* global setup */ /* The following loop checks looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); lc++) { /* reset Tst_count in case we are looping */ Tst_count = 0; /* setup test case paremeters */ setup_tc(lc, &tc); /* loop through the test cases */ for (i = 0; i < TST_TOTAL; i++) { /* * make the call using the TEST() macro - attempt * various invalid shared memory attaches */ errno = 0; addr = shmat(*(tc.shmid), base_addr + tc.offset, 0); TEST_ERRNO = errno; if (addr != (void *)-1) { tst_resm(TFAIL, "call succeeded unexpectedly"); continue; } TEST_ERROR_LOG(TEST_ERRNO); if (TEST_ERRNO == tc.error) { tst_resm(TPASS, "expected failure - errno = " "%d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } else { tst_resm(TFAIL, "call failed with an " "unexpected error - %d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } } } cleanup(); /*NOTREACHED*/ return 0; }
int main(int ac, char **av) { int lc; int i; struct test_case_t *tc; tc = NULL; tst_parse_opts(ac, av, NULL, NULL); tc = malloc(sizeof(struct test_case_t)); if (tc == NULL) tst_brkm(TBROK | TERRNO, cleanup, "malloc failed"); setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { tst_count = 0; for (i = 0; i < TST_TOTAL; i++) { setup_tc(i, tc); base_addr = probe_free_addr(); errno = 0; addr = shmat(*(tc->shmid), base_addr + tc->offset, 0); if (addr != (void *)-1) { tst_resm(TFAIL, "call succeeded unexpectedly"); continue; } if (errno == tc->error) tst_resm(TPASS | TERRNO, "shmat failed as expected"); else tst_resm(TFAIL, "shmat failed unexpectedly; expected: " "%d - %s", tc->error, strerror(tc->error)); } } cleanup(); tst_exit(); }
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ int i; struct test_case_t *tc; tc = NULL; if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); if ((tc = malloc(sizeof(struct test_case_t))) == NULL) tst_brkm(TBROK|TERRNO, cleanup, "malloc failed"); setup(); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; for (i = 0; i < TST_TOTAL; i++) { setup_tc(i, tc); errno = 0; addr = shmat(*(tc->shmid), base_addr + tc->offset, 0); if (addr != (void *)-1) { tst_resm(TFAIL, "call succeeded unexpectedly"); continue; } if (errno == tc->error) tst_resm(TPASS|TERRNO, "shmat failed as expected"); else tst_resm(TFAIL, "shmat failed unexpectedly; expected: " "%d - %s", tc->error, strerror(tc->error)); } } cleanup(); tst_exit(); }
/* * check_functionality - check various conditions to make sure they * are correct. */ void check_functionality(int i) { void *orig_add; int *shared; int fail = 0; struct shmid_ds buf; struct test_case_t tc; shared = (int *)addr; /* stat the shared memory ID */ if (shmctl(shm_id_1, IPC_STAT, &buf) == -1) { tst_brkm(TBROK, cleanup, "couldn't stat shared memory"); } /* check the number of attaches */ if (buf.shm_nattch != 1) { tst_resm(TFAIL, "# of attaches is incorrect"); return; } /* check the size of the segment */ if (buf.shm_segsz != INT_SIZE) { tst_resm(TFAIL, "segment size is incorrect"); return; } /* check for specific conditions depending on the type of attach */ switch (i) { case 0: /* * Check the functionality of the first call by simply * "writing" a value to the shared memory space. * If this fails the program will get a SIGSEGV, dump * core and exit. */ *shared = CASE0; break; case 1: /* * Check the functionality of the second call by writing * a value to the shared memory space and then checking * that the original address given was rounded down as * specified in the man page. */ setup_tc(1, &tc); *shared = CASE1; orig_add = addr + ((unsigned long)tc.offset % SHMLBA); if (orig_add != base_addr + tc.offset) { tst_resm(TFAIL, "shared memory address is not " "correct"); fail = 1; } break; case 2: /* * This time the shared memory is read only. Read the value * and check that it is equal to the value set in case #2, * because shared memory is persistent. */ if (*shared != CASE1) { tst_resm(TFAIL, "shared memory value isn't correct"); fail = 1; } break; } if (!fail) { tst_resm(TPASS, "conditions and functionality are correct"); } }
int main(int ac, char **av) { int lc; /* loop counter */ char *msg; /* message returned from parse_opts */ int i; struct test_case_t tc; void check_functionality(int); /* parse standard options */ if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *)NULL) { tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg); } setup(); /* global setup */ /* The following loop checks looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); lc++) { /* reset Tst_count in case we are looping */ Tst_count = 0; /* setup test case paremeters */ setup_tc(lc, &tc); /* loop through the test cases */ for (i = 0; i < TST_TOTAL; i++) { /* * Use TEST macro to make the call */ errno = 0; addr = shmat(*(tc.shmid), base_addr + tc.offset, tc.flags); TEST_ERRNO = errno; if (addr == (void *)-1) { tst_brkm(TFAIL, cleanup, "%s call failed - " "errno = %d : %s", TCID, TEST_ERRNO, strerror(TEST_ERRNO)); } else { if (STD_FUNCTIONAL_TEST) { check_functionality(i); } else { tst_resm(TPASS, "call succeeded"); } } /* * clean up things in case we are looping - in * this case, detach the shared memory */ if (shmdt((const void *)addr) == -1) { tst_brkm(TBROK, cleanup, "Couldn't detach shared memory"); } } } cleanup(); /*NOTREACHED*/ return 0; }