/*ARGSUSED*/ int main(int argc, char *argv[]) { caddr_t mmapaddr, munmap_begin; long pagesize = sysconf(_SC_PAGE_SIZE); int i; time_t t; (void)time(&t); //(void)printf("%s: Started %s", argv[0], ctime(&t)); if (sbrk(pagesize - ((u_long)sbrk(0)%(u_long)pagesize))==(char *)-1) { ERROR("couldn't round up brk to a page boundary"); local_flag = FAILED; anyfail(); } /* The brk is now at the begining of a page. */ if ((munmap_begin = mmapaddr = (caddr_t)sbrk(0)) == (caddr_t)-1) { ERROR("couldn't find top of brk"); local_flag = FAILED; anyfail(); } mmapaddr = 0; /* burn level 2 ptes by spacing mmaps 4Meg apart */ /* This should switch to large anonymous swap space granularity */ for (i = 0; i < GRAN_NUMBER; i++) { if (mmap(mmapaddr, pagesize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, 0, 0)==(caddr_t)-1) { ERROR("mmap failed"); local_flag = FAILED; anyfail(); } mmapaddr += NPTEPG*pagesize; } /* Free bizillion level2 ptes to switch to small granularity */ if (munmap(munmap_begin, (size_t)(mmapaddr-munmap_begin))) { ERROR("munmap failed"); local_flag = FAILED; anyfail(); } (void)time(&t); //(void)printf("%s: Finished %s", argv[0], ctime(&t)); ok_exit(); tst_exit(); }
int main(int argc, char *argv[]) { caddr_t mmapaddr; size_t pagesize = sysconf(_SC_PAGE_SIZE); time_t t; int sleep_time = 0; if (!argc) { (void)fprintf(stderr, "argc == 0\n"); anyfail(); } if (argc != 2 || !(sleep_time = atoi(argv[1]))) { (void)fprintf(stderr, "usage: %s sleep_time\n", argv[0]); anyfail(); } (void)time(&t); // (void)printf("%s: Started %s", argv[0], ctime(&t)); LTP Port if (sbrk(pagesize - ((unsigned long) sbrk(0) & (pagesize - 1))) == (char *)-1) { ERROR("couldn't round up brk"); anyfail(); } if ((mmapaddr = sbrk(0)) == (char *)-1) { ERROR("couldn't find top of brk"); anyfail(); } /* mmapaddr is now on a page boundary after the brk segment */ if (mmap (mmapaddr, (ANON_GRAN_PAGES_MAX * NMFPTEPG + 1) * pagesize, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0) == (caddr_t) - 1) { ERROR("large mmap failed"); printf("for this test to run, it needs a mmap space of\n"); printf("%d pages\n", (ANON_GRAN_PAGES_MAX * NMFPTEPG + 1)); return 1; } (void)sleep(sleep_time); (void)time(&t); // (void)printf("%s: Finished %s", argv[0], ctime(&t)); LTP Port ok_exit(); tst_exit(); }
int main(int argc, char *argv[]) { char *progname; unsigned c; extern char *optarg; unsigned nprocs = 0; unsigned procno; pid_t *pidarray=NULL; pid_t pid; uchar_t *buf, *ptr; unsigned int seed; int alarmtime = 0; struct sigaction sa; unsigned i, j; uchar_t data; int no_prob = 0; time_t t; int wait_stat; progname = *argv; pagesize = sysconf(_SC_PAGE_SIZE); if (argc < 2) { (void)fprintf(stderr, "usage: %s %s\n", progname, usage); anyfail(); } while ((c = getopt(argc, argv, "mdrp:t:s:")) != -1) { switch (c) { case 'd': debug = 1; break; case 't': alarmtime = atoi(optarg) * 60; break; case 'p': nprocs = atoi(optarg); break; case 'm': dosync = 1; break; case 's': mapsize = atoi(optarg); if (mapsize < 0) { (void)fprintf(stderr, "error: negative " "mapsize\n"); anyfail(); } break; case 'r': randloops = 1; break; default: (void)fprintf(stderr, "usage: %s %s\n", progname, usage); anyfail(); } } /* nprocs is unsigned */ if (nprocs > 255) { (void)fprintf(stderr, "invalid nprocs %d - (range 0-255)\n", nprocs); anyfail(); } (void)time(&t); // (void)printf("%s: Started %s", argv[0], ctime(&t)); LTP Port seed = initrand(); pattern = seed & 0xff; if (debug) { (void)printf("%s mapsize %d bytes, pattern %d\n", progname, mapsize, pattern); if (alarmtime) (void)printf("running for %d minutes\n", alarmtime/60); else (void)printf("running with no time limit\n"); } if ((mapaddr = mmap(0, mapsize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_SHARED, 0, 0)) == (caddr_t)-1) { perror("mmap error"); anyfail(); } if ((buf = (uchar_t *)malloc(pagesize)) == NULL || (pidarray = (pid_t *)malloc(nprocs*sizeof(pid_t))) == NULL) { perror("malloc error"); anyfail(); } for (i = 0; i < nprocs; i++) *(pidarray+i) = 0; /* * Initialize page compare buffer, then initialize map. */ for (i = 0, data = 0; i < pagesize; i++) { *(buf+i) = (data + pattern) & 0xff; if (++data == nprocs) data = 0; } mappages = roundup(mapsize, pagesize)/pagesize; ptr = (uchar_t *)mapaddr; for (i = 0; i < mappages; i++) { for (j = 0; j < pagesize; j++) *ptr++ = *(buf+j); } /* * Fork off mmap children. */ for (procno = 0; procno < nprocs; procno++) { switch (pid = fork()) { case -1: perror("fork error"); goto cleanup; case 0: child_mapper(procno, nprocs); exit(0); default: pidarray[procno] = pid; } } /* * Plan for death by signal. User may have specified * a time limit, in which set an alarm and catch SIGALRM. * Also catch and cleanup with SIGINT. */ sa.sa_handler = finish; sa.sa_flags = 0; if (sigemptyset(&sa.sa_mask)) { perror("sigemptyset error"); goto cleanup; } if (sigaction(SIGINT, &sa, 0) == -1) { perror("sigaction error"); goto cleanup; } if (alarmtime) { if (sigaction(SIGALRM, &sa, 0) == -1) { perror("sigaction error"); goto cleanup; } (void)alarm(alarmtime); } /* * Now wait for children and refork them as needed. */ while (!finished) { do { pid = wait(&wait_stat); } while (pid == -1 && errno == EINTR); /* * Block signals while processing child exit. */ if (sighold(SIGALRM) || sighold(SIGINT)) { perror("sighold error"); goto cleanup; } if (pid != -1) { /* * Check exit status, then refork with the * appropriate procno. */ if (!WIFEXITED(wait_stat) || WEXITSTATUS(wait_stat) != 0) { (void)fprintf(stderr, "child exit with err " "<x%x>\n", wait_stat); goto cleanup; } for (i = 0; i < nprocs; i++) if (pid == pidarray[i]) break; if (i == nprocs) { (void)fprintf(stderr, "unknown child pid %d, <x%x>\n", pid, wait_stat); goto cleanup; } if ((pid = fork()) == -1) { perror("fork error"); pidarray[i] = 0; goto cleanup; } else if (pid == 0) { /* child */ child_mapper(i, nprocs); exit(0); } else pidarray[i] = pid; } else { /* * wait returned an error. If EINTR, then * normal finish, else it's an unexpected * error... */ if (errno != EINTR || !finished) { perror("unexpected wait error"); goto cleanup; } } if (sigrelse(SIGALRM) || sigrelse(SIGINT)) { perror("sigrelse error"); goto cleanup; } } /* * Finished! Check the map for sanity, then kill all * the children and done!. */ if (sighold(SIGALRM)) { perror("sighold error"); goto cleanup; } (void)alarm(0); no_prob = 1; cleanup: for (i = 0; i < nprocs; i++) (void)kill(pidarray[i], SIGKILL); /* failure? oh well. */ while (wait(&wait_stat) != -1 || errno != ECHILD) continue; if (no_prob) { /* only check file if no errors */ if (!mapokay(buf)) { (void)fprintf(stderr, "map data incorrect!\n"); anyfail(); } else (void)printf("map data okay\n"); } (void)time(&t); // (void)printf("%s: Finished %s", argv[0], ctime(&t)); LTP POrt ok_exit(); return(0); }
/*ARGSUSED*/ int main(int argc, char *argv[]) { char *brk_max_addr, *hole_addr, *brk_start, *hole_start; size_t pagesize = (size_t)sysconf(_SC_PAGE_SIZE); time_t t; progname = argv[0]; (void)time(&t); // (void)printf("%s: Started %s", argv[0], ctime(&t)); if ((brk_start = sbrk(0)) == NEG1) { ERROR("initial sbrk failed"); anyfail(); } if ((u_long)brk_start % (u_long)pagesize) { if (sbrk(pagesize - ((u_long)brk_start % (u_long)pagesize)) == NEG1) { ERROR("couldn't round up brk to a page boundary"); anyfail(); } } /* The brk is now at the beginning of a page. */ if ((hole_addr = hole_start = sbrk(NUM_SEGS * 2 * pagesize)) == NEG1) { ERROR("couldn't brk large space for segments"); anyfail(); } if ((brk_max_addr = sbrk(0)) == NEG1) { ERROR("couldn't find top of brk"); anyfail(); } do_test((caddr_t)brk_max_addr, pagesize); /* now make holes and repeat test */ while (hole_addr + pagesize < brk_max_addr) { if (munmap(hole_addr, pagesize) == -1) { ERROR("failed to munmap odd hole in brk segment"); anyfail(); } hole_addr += 2 * pagesize; } if (brk_max_addr != sbrk(0)) { ERROR("do_test should leave the top of brk where it began"); anyfail(); } do_test((caddr_t)brk_max_addr, pagesize); /* Shrink brk */ if (sbrk(-NUM_SEGS * pagesize) == NEG1) { ERROR("couldn't brk back over holes"); anyfail(); } if ((brk_max_addr = sbrk(0)) == NEG1) { ERROR("couldn't find top of break again"); anyfail(); } /* sbrked over about half the holes */ hole_addr = hole_start + pagesize; /* munmap the other pages */ while (hole_addr + pagesize < brk_max_addr) { if (munmap(hole_addr, pagesize) == -1) { ERROR("failed to munmap even hole in brk segment"); anyfail(); } hole_addr += 2 * pagesize; } /* munmaped the rest of the brk except a little at the beginning */ if (brk(brk_start) == -1) { ERROR("failed to completely remove brk"); anyfail(); } if (sbrk(pagesize) == NEG1 || sbrk(-pagesize) == NEG1) { ERROR("failed to fiddle with brk at the end"); anyfail(); } /* Ask for a ridiculously large mmap region at a high address */ if (mmap((caddr_t)(1UL << (POINTER_SIZE - 1)) - pagesize, (size_t)((1UL << (POINTER_SIZE - 1)) - pagesize), PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_FIXED|MAP_SHARED, 0, 0) != (caddr_t)-1) { ERROR("really large mmap didn't fail"); anyfail(); } if (errno != ENOMEM && errno != EINVAL) { ERROR("really large mmap didn't set errno = ENOMEM nor EINVAL"); anyfail(); } (void)time(&t); // (void)printf("%s: Finished %s", argv[0], ctime(&t)); ok_exit(); tst_exit(); }
int main(int argc, char *argv[]) { char *progname; int fd; int c; extern char *optarg; unsigned nprocs = 0; unsigned procno; pid_t *pidarray=NULL; pid_t pid; pid_t wr_pid = 0; uchar_t *buf=NULL; unsigned int seed; int pagesize = sysconf(_SC_PAGE_SIZE); int alarmtime = 0; struct sigaction sa; unsigned i; int write_cnt; uchar_t data; int no_prob = 0; int wait_stat; time_t t; #ifdef LARGE_FILE off64_t bytes_left; #else /* LARGE_FILE */ off_t bytes_left; #endif /* LARGE_FILE */ progname = *argv; tst_tmpdir(); if (argc < 2) { (void)fprintf(stderr, "usage: %s %s\n", progname, usage); exit(1); } while ((c = getopt(argc, argv, "S:omdlrf:p:t:w:s:")) != -1) { switch (c) { case 'd': debug = 1; break; case 't': alarmtime = atoi(optarg) * 60; break; case 'p': nprocs = atoi(optarg); break; case 'l': leavefile = 1; break; case 's': sleeptime = atoi(optarg); if (sleeptime < 0) { (void)fprintf(stderr, "error: negative " "sleeptime\n"); anyfail(); } break; case 'w': growsize = atoi(optarg); if (growsize < 0) { (void)fprintf(stderr, "error: negative write " "size\n"); anyfail(); } break; case 'f': #ifdef LARGE_FILE filesize = atoll(optarg); #else /* LARGE_FILE */ filesize = atoi(optarg); #endif /* LARGE_FILE */ if (filesize < 0) { (void)fprintf(stderr, "error: negative " "filesize\n"); anyfail(); } break; case 'r': randloops = 1; break; case 'm': dosync = 1; break; case 'o': do_offset = 1; break; case 'S': #ifdef LARGE_FILE sparseoffset = atoll(optarg); #else /* LARGE_FILE */ sparseoffset = atoi(optarg); #endif /* LARGE_FILE */ if (sparseoffset % pagesize != 0) { fprintf(stderr, "sparseoffset must be pagesize multiple\n"); anyfail(); } break; default: (void)fprintf(stderr, "usage: %s %s\n", progname, usage); anyfail(); } } if (nprocs > 255) { (void)fprintf(stderr, "invalid nprocs %d - (range 0-255)\n", nprocs); anyfail(); } (void)time(&t); //(void)printf("%s: Started %s", argv[0], ctime(&t)); LTP Port (void)sprintf(filename, "%sout.%d", progname, getpid()); seed = initrand(); pattern = seed & 0xff; if (debug) { #ifdef LARGE_FILE (void)printf("creating file <%s> with %Ld bytes, pattern %d\n", filename, filesize, pattern); #else /* LARGE_FILE */ (void)printf("creating file <%s> with %ld bytes, pattern %d\n", filename, filesize, pattern); #endif /* LARGE_FILE */ if (alarmtime) (void)printf("running for %d minutes\n", alarmtime/60); else (void)printf("running with no time limit\n"); } /* * Plan for death by signal. User may have specified * a time limit, in which case set an alarm and catch SIGALRM. * Also catch and cleanup with SIGINT, SIGQUIT, and SIGTERM. */ sa.sa_handler = finish; sa.sa_flags = 0; if (sigemptyset(&sa.sa_mask)) { perror("sigempty error"); goto cleanup; } if (sigaction(SIGINT, &sa, 0) == -1) { perror("sigaction error SIGINT"); goto cleanup; } if (alarmtime) { if (sigaction(SIGALRM, &sa, 0) == -1) { perror("sigaction error"); goto cleanup; } (void)alarm(alarmtime); } /* If we get a SIGQUIT or SIGTERM, clean up and exit immediately. */ sa.sa_handler = clean_up_file; if (sigaction(SIGQUIT, &sa, 0) == -1) { perror("sigaction error SIGQUIT"); goto cleanup; } if (sigaction(SIGTERM, &sa, 0) == -1) { perror("sigaction error SIGTERM"); goto cleanup; } #ifdef LARGE_FILE if ((fd = open64(filename, O_CREAT|O_TRUNC|O_RDWR, 0664)) == -1) { #else /* LARGE_FILE */ if ((fd = open(filename, O_CREAT|O_TRUNC|O_RDWR, 0664)) == -1) { #endif /* LARGE_FILE */ perror("open error"); anyfail(); } if ((buf = (uchar_t *)malloc(pagesize+growsize)) == NULL || (pidarray = (pid_t *)malloc(nprocs*sizeof(pid_t))) == NULL) { perror("malloc error"); anyfail(); } for (i = 0; i < nprocs; i++) *(pidarray+i) = 0; for (i = 0, data = 0; i < pagesize; i++) { *(buf+i) = (data + pattern) & 0xff; if (++data == nprocs) data = 0; } for (data = 0; i < pagesize+growsize; i++) { *(buf+i) = (data + pattern) & 0xff; if (++data == nprocs) data = 0; } #ifdef LARGE_FILE if (lseek64(fd, sparseoffset, SEEK_SET) < 0) { #else /* LARGE_FILE */ if (lseek(fd, sparseoffset, SEEK_SET) < 0) { #endif /* LARGE_FILE */ perror("lseek"); anyfail(); } for (bytes_left = filesize; bytes_left; bytes_left -= c) { write_cnt = min(pagesize, bytes_left); if ((c = write(fd, (char *)buf, write_cnt)) != write_cnt) { if (c == -1) { perror("write error"); } else { (void)fprintf(stderr, "write: wrote %d of %d " "bytes\n", c, write_cnt); } (void)close(fd); (void)unlink(filename); anyfail(); } } (void)close(fd); /* * Fork off mmap children. */ for (procno = 0; procno < nprocs; procno++) { switch (pid = fork()) { case -1: perror("fork error"); goto cleanup; case 0: child_mapper(filename, procno, nprocs); exit(0); default: pidarray[procno] = pid; } } /* * Now fork off an additional process to continually * write to (and grow) the file. */ if ((wr_pid = fork()) == -1) { perror("fork error"); goto cleanup; } else if (wr_pid == 0) { /* child */ child_writer(filename, buf); exit(0); } /* * Now wait for children and refork them as needed. */ while (!finished) { pid = wait(&wait_stat); /* * Block signals while processing child exit. */ if (sighold(SIGALRM) || sighold(SIGINT)) { perror("sighold error"); goto cleanup; } if (pid != -1) { /* * Check exit status, then refork with the * appropriate procno. */ if (!WIFEXITED(wait_stat) || WEXITSTATUS(wait_stat) != 0) { (void)fprintf(stderr, "child exit with err " "<x%x>\n", wait_stat); goto cleanup; } for (i = 0; i < nprocs; i++) if (pid == pidarray[i]) break; if (i == nprocs) { if (pid == wr_pid) { (void)fprintf(stderr, "writer child unexpected exit <x%x>\n", wait_stat); wr_pid = 0; } else (void)fprintf(stderr, "unknown child " "pid %d, <x%x>\n", pid, wait_stat); goto cleanup; } if ((pid = fork()) == -1) { perror("fork error"); pidarray[i] = 0; goto cleanup; } else if (pid == 0) { /* child */ child_mapper(filename, i, nprocs); exit(0); } else pidarray[i] = pid; } else { /* * wait returned an error. If EINTR, then * normal finish, else it's an unexpected * error... */ if (errno != EINTR || !finished) { perror("unexpected wait error"); goto cleanup; } } if (sigrelse(SIGALRM) || sigrelse(SIGINT)) { perror("sigrelse error"); goto cleanup; } } /* * Finished! Check the file for sanity, then kill all * the children and done!. */ (void)alarm(0); no_prob = 1; cleanup: for (i = 0; i < nprocs; i++) (void)kill(pidarray[i], SIGKILL); (void)kill(wr_pid, SIGKILL); while (wait(&wait_stat) != -1 || errno != ECHILD) continue; if (no_prob) { /* only check file if no errors */ if (!fileokay(filename, buf)) { (void)fprintf(stderr, "file data incorrect!\n"); (void)printf(" leaving file <%s>\n", filename); anyfail(); } else { (void)printf("file data okay\n"); if (!leavefile) (void)unlink(filename); } } else (void)printf(" leaving file <%s>\n", filename); (void)time(&t); // (void)printf("%s: Finished %s", argv[0], ctime(&t)); LTP Port ok_exit(); return 0; } /* * Child process that reads/writes map. The child stats the file * to determine the size, maps the size of the file, then reads/writes * its own locations on random pages of the map (its locations being * determined based on nprocs & procno). After a specific number of * iterations, it exits. */ void child_mapper(char *file, unsigned procno, unsigned nprocs) { #ifdef LARGE_FILE struct stat64 statbuf; off64_t filesize; off64_t offset; #else /* LARGE_FILE */ struct stat statbuf; off_t filesize; off_t offset; #endif /* LARGE_FILE */ size_t validsize; size_t mapsize; caddr_t maddr, paddr; int fd; int pagesize = sysconf(_SC_PAGE_SIZE); unsigned randpage; unsigned int seed; unsigned loopcnt; unsigned nloops; unsigned mappages; unsigned mapflags; unsigned i; mapflags = MAP_SHARED; seed = initrand(); /* initialize random seed */ #ifdef LARGE_FILE if ((fd = open64(file, O_RDWR)) == -1) { #else /* LARGE_FILE */ if ((fd = open(file, O_RDWR)) == -1) { #endif /* LARGE_FILE */ perror("open error"); anyfail(); } #ifdef LARGE_FILE if (fstat64(fd, &statbuf) == -1) { #else /* LARGE_FILE */ if (fstat(fd, &statbuf) == -1) { #endif /* LARGE_FILE */ perror("stat error"); anyfail(); } filesize = statbuf.st_size; if (statbuf.st_size - sparseoffset > SIZE_MAX) { fprintf(stderr, "size_t overflow when setting up map\n"); anyfail(); } mapsize = (size_t)(statbuf.st_size - sparseoffset); mappages = roundup(mapsize, pagesize) / pagesize; offset = sparseoffset; if (do_offset) { int pageoffset = lrand48() % mappages; int byteoffset = pageoffset * pagesize; offset += byteoffset; mapsize -= byteoffset; mappages -= pageoffset; } #ifdef LARGE_FILE if ((maddr = mmap64(0, mapsize, PROT_READ|PROT_WRITE, mapflags, fd, offset)) == (caddr_t)-1) { #else /* LARGE_FILE */ if ((maddr = mmap(0, mapsize, PROT_READ|PROT_WRITE, mapflags, fd, offset)) == (caddr_t)-1) { #endif /* LARGE_FILE */ perror("mmap error"); anyfail(); } (void)close(fd); nloops = (randloops) ? (lrand48() % MAXLOOPS) : MAXLOOPS; if (debug) { #ifdef LARGE_FILE (void)printf("child %d (pid %ld): seed %d, fsize %Ld, " "mapsize %d, off %Ld, loop %d\n", procno, getpid(), seed, filesize, mapsize, offset/pagesize, nloops); #else /* LARGE_FILE */ (void)printf("child %d (pid %d): seed %d, fsize %ld, " "mapsize %ld, off %ld, loop %d\n", procno, getpid(), seed, filesize, (long)mapsize, offset/pagesize, nloops); #endif /* LARGE_FILE */ } /* * Now loop read/writing random pages. */ for (loopcnt = 0; loopcnt < nloops; loopcnt++) { randpage = lrand48() % mappages; paddr = maddr + (randpage * pagesize); /* page address */ if (randpage < mappages - 1 || !(mapsize % pagesize)) validsize = pagesize; else validsize = mapsize % pagesize; /* * Because one child is mapping file in extend mode, * it may be padded with zeros at end. So we can't * do an exact check -- accept known pattern OR zeros. */ for (i = procno; i < validsize; i += nprocs) { if (*((unsigned char *)(paddr+i)) != ((procno + pattern) & 0xff) && *((unsigned char *)(paddr+i)) != 0) { (void)fprintf(stderr, "child %d: invalid data " "<x%x>", procno, *((unsigned char *)(paddr+i))); (void)fprintf(stderr, " at pg %d off %d, exp " "<x%x>\n", randpage, i, (procno+pattern)&0xff); anyfail(); } /* * Now write it. */ *(paddr+i) = (procno + pattern) & 0xff; } } if (dosync) { /* * Exercise msync() as well! */ randpage = lrand48() % mappages; paddr = maddr + (randpage * pagesize); /* page address */ if (msync(paddr, (mappages - randpage)*pagesize, MS_SYNC) == -1) { perror("msync error"); anyfail(); } } exit(0); } /* * child_writer * The child process that continually (and slowly!!) grows * the file. The purpose of this is to exercise the code * supporting mapping of fragments. The map children are * constantly reforking and will pick up the map changes, etc. * This process executes until signalled (i.e. has no exit!) * unless error. */ void child_writer(char *file, uchar_t *buf) /* buf already set up in main */ { int fd; #ifdef LARGE_FILE struct stat64 statbuf; off64_t off; #else /* LARGE_FILE */ struct stat statbuf; off_t off; #endif /* LARGE_FILE */ int pagesize = sysconf(_SC_PAGE_SIZE); uchar_t *p; int cnt; #ifdef LARGE_FILE if ((fd = open64(file, O_RDWR)) == -1) { #else /* LARGE_FILE */ if ((fd = open(file, O_RDWR)) == -1) { #endif /* LARGE_FILE */ perror("open error"); anyfail(); } #ifdef LARGE_FILE if ((off = lseek64(fd, 0, SEEK_END)) == -1) { #else /* LARGE_FILE */ if ((off = lseek(fd, 0, SEEK_END)) == -1) { #endif /* LARGE_FILE */ perror("lseek error"); anyfail(); } for (;;) { #ifdef LARGE_FILE if (fstat64(fd, &statbuf) == -1) { #else /* LARGE_FILE */ if (fstat(fd, &statbuf) == -1) { #endif /* LARGE_FILE */ perror("fstat error"); anyfail(); } #ifdef LARGE_FILE if (debug) (void)printf("writer %d bytes at off %Ld, size %Ld\n", growsize, off, statbuf.st_size); #else /* LARGE_FILE */ if (debug) (void)printf("writer %d bytes at off %ld, size %ld\n", growsize, off, statbuf.st_size); #endif /* LARGE_FILE */ /* * Write some number of bytes, then sleep some * number of seconds... * Need to keep track of our offset so write the * right bytes. */ p = buf + (off % pagesize); if ((cnt = write(fd, p, growsize)) != growsize) { if (cnt == -1) perror("write error"); else (void)fprintf(stderr, "wrote %d of %d bytes\n", cnt, growsize); anyfail(); } off += growsize; (void)sleep(sleeptime); if (dosync) { if (fsync(fd) == -1) { perror("fsync error"); anyfail(); } } } } /* * Make sure file has all the correct data. */ int fileokay(char *file, uchar_t *expbuf) { #ifdef LARGE_FILE struct stat64 statbuf; #else /* LARGE_FILE */ struct stat statbuf; #endif /* LARGE_FILE */ size_t mapsize; uchar_t *readbuf; unsigned mappages; unsigned pagesize = sysconf(_SC_PAGE_SIZE); int fd; int cnt; unsigned i, j; #ifdef LARGE_FILE if ((fd = open64(file, O_RDONLY)) == -1) { #else /* LARGE_FILE */ if ((fd = open(file, O_RDONLY)) == -1) { #endif /* LARGE_FILE */ perror("open error"); anyfail(); } #ifdef LARGE_FILE if (fstat64(fd, &statbuf) == -1) { #else /* LARGE_FILE */ if (fstat(fd, &statbuf) == -1) { #endif /* LARGE_FILE */ perror("stat error"); anyfail(); } #ifdef LARGE_FILE if (lseek64(fd, sparseoffset, SEEK_SET) < 0) { #else /* LARGE_FILE */ if (lseek(fd, sparseoffset, SEEK_SET) < 0) { #endif /* LARGE_FILE */ perror("lseek"); exit(1); } readbuf = (uchar_t *)malloc(pagesize); if (statbuf.st_size - sparseoffset > SIZE_MAX) { fprintf(stderr, "size_t overflow when setting up map\n"); exit(1); } mapsize = (size_t)(statbuf.st_size - sparseoffset); mappages = roundup(mapsize, pagesize) / pagesize; for (i = 0; i < mappages; i++) { cnt = read(fd, (char *)readbuf, pagesize); if (cnt == -1) { perror("read error"); return(0); } else if (cnt != pagesize) { /* * Okay if at last page in file... */ if ((i * pagesize) + cnt != mapsize) { (void)fprintf(stderr, "read %d of %ld bytes\n", (i*pagesize)+cnt, (long)mapsize); return(0); } } /* * Compare read bytes of data. * May have zeros from map extend... */ for (j = 0; j < cnt; j++) { if (expbuf[j] != readbuf[j] && readbuf[j] != 0) { (void)fprintf(stderr, "read bad data: exp %c got %c", expbuf[j], readbuf[j]); #ifdef LARGE_FILE (void)fprintf(stderr, ", pg %d off %d, " "(fsize %Ld)\n", i, j, statbuf.st_size); #else /* LARGE_FILE */ (void)fprintf(stderr, ", pg %d off %d, " "(fsize %ld)\n", i, j, statbuf.st_size); #endif /* LARGE_FILE */ return(0); } } } return(1); } /*ARGSUSED*/ void finish(int sig) { finished++; /* finish nicely and check the file contents */ } /*ARGSUSED*/ void clean_up_file(int sig) { if (!leavefile) (void)unlink(filename); exit(1); } unsigned int initrand(void) { unsigned int seed; /* * Initialize random seed... Got this from a test written * by scooter: * Use srand/rand to diffuse the information from the * time and pid. If you start several processes, then * the time and pid information don't provide much * variation. */ srand((unsigned int)getpid()); seed = rand(); srand((unsigned int)time((time_t *)0)); seed = (seed ^ rand()) % 100000; srand48((long int)seed); return (seed); } /***** LTP Port *****/ void ok_exit() { tst_resm(TPASS, "Test passed\n"); tst_rmdir(); tst_exit(); } int anyfail() { tst_resm(TFAIL, "Test failed\n"); tst_rmdir(); tst_exit(); return(0); }
int main(int argc, char *argv[]) { caddr_t mmapaddr; size_t pagesize = sysconf(_SC_PAGE_SIZE); time_t t; int i; struct sigaction sa; tst_tmpdir(); if (!argc) { (void)fprintf(stderr, "argc == 0\n"); return 1; } if (argc != 1) { (void)fprintf(stderr, "usage: %s\n", argv[0]); return 1; } (void)time(&t); if ((fd = mkstemp(tmpname)) == -1) { ERROR("mkstemp failed"); anyfail(); } sa.sa_handler = cleanup; sa.sa_flags = 0; if (sigemptyset(&sa.sa_mask)) { ERROR("sigemptyset failed"); anyfail(); } CATCH_SIG(SIGINT); CATCH_SIG(SIGQUIT); CATCH_SIG(SIGTERM); if (sbrk(2*pagesize - ((ulong)sbrk(0) & (pagesize-1))) == (char *)-1) { CLEANERROR("couldn't round up brk"); anyfail(); } if ((mmapaddr = sbrk(0)) == (caddr_t)-1) { CLEANERROR("couldn't find top of brk"); anyfail(); } /* Write a page of garbage into the file, so we can mmap it without * asking for PROT_WRITE. */ for (i = pagesize; i; i--) *(mmapaddr-i) = 'a'; if (write(fd, (char *)mmapaddr-pagesize, pagesize) != pagesize) { CLEANERROR("write failed"); anyfail(); } if (mmap(mmapaddr, pagesize, PROT_NONE, MAP_FIXED|MAP_PRIVATE|MAP_FILE, fd, 0) != mmapaddr) { CLEANERROR("couldn't mmap file"); anyfail(); } /* * Since the file is mmapped, mmreg_new and uiomove_phys handle all * I/O */ if (lseek(fd, 0, SEEK_SET) != 0) { CLEANERROR("lseek failed"); anyfail(); } if (read(fd, (char *)mmapaddr, pagesize) != -1) { CLEANERROR("read succeded"); anyfail(); } if (errno != EFAULT) { CLEANERROR("read didn't set errno = EFAULT"); anyfail(); } if (write(fd, (char *)mmapaddr, pagesize) != -1) { CLEANERROR("write succeded"); anyfail(); } if (errno != EFAULT) { CLEANERROR("write didn't set errno = EFAULT"); anyfail(); } if (close(fd) == -1) { CLEANERROR("close failed"); anyfail(); } if (munmap(mmapaddr, pagesize) == -1) { CLEANERROR("munmap failed"); anyfail(); } if (unlink(tmpname) == -1) { ERROR("unlink failed"); anyfail(); } (void)time(&t); // (void)printf("%s: Finished %s", argv[0], ctime(&t)); ok_exit(); /* LTP Port */ tst_exit(); }
/*--------------------------------------------------------------*/ int main(int argc, char *argv[]) { register int i; int status, count, child, kidpid; int core, sig, ex; char *msg; if ((msg = parse_opts(argc, argv, (option_t *) NULL, NULL)) != (char *)NULL) { tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); } #ifdef UCLINUX maybe_run_child(&do_child, ""); #endif setup(); /* temp file is now open */ /*--------------------------------------------------------------*/ for (i = 0; i < ITER; i++) { if ((kidpid = FORK_OR_VFORK()) == 0) { #ifdef UCLINUX if (self_exec(argv[0], "")) { terror("self_exec failed (may be OK if under stress)"); if (instress()) ok_exit(); forkfail(); } #else do_child(); #endif } if (kidpid < 0) { terror("Fork failed (may be OK if under stress)"); if (instress()) ok_exit(); forkfail(); } count = 0; while ((child = wait(&status)) > 0) { count++; } if (count != 1) { fprintf(temp, "\twrong # children waited on.\n"); fprintf(temp, "\tgot %d, expected %d\n", count, 1); fail_exit(); } /* sig = status & 0177; core = status & 0200; ex = (status & 0xFF00) >> 8; */ /***** LTP Port *****/ sig = WTERMSIG(status); #ifdef WCOREDUMP core = WCOREDUMP(status); #endif ex = WIFEXITED(status); /**************/ if (!core) { fprintf(temp, "\tChild did not return core bit set!\n"); fprintf(temp, "\t iteration %d, exit stat = 0x%x\n", i, status); fprintf(temp, "\tCore = %d, sig = %d, ex = %d\n", core, sig, ex); local_flag = FAILED; } if (sig != SIGIOT) { fprintf(temp, "\tChild did not exit with SIGIOT (%d)\n", SIGIOT); fprintf(temp, "\t iteration %d, exit stat = 0x%x\n", i, status); fprintf(temp, "\tCore = %d, sig = %d, ex = %d\n", core, sig, ex); local_flag = FAILED; } if (local_flag == FAILED) break; } /*--------------------------------------------------------------*/ /* Clean up any files created by test before call to anyfail. */ unlink("core"); anyfail(); /* THIS CALL DOES NOT RETURN - EXITS!! */ return 0; }