/* * * Copyright (c) International Business Machines Corp., 2002 * Copyright (c) Cyril Hrubis chrubis@suse.cz 2009 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See * the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* * NAME * ftest05.c -- test file I/O (ported from SPIE, section2/filesuite/ftest6.c, by Airong Zhang) * * this is the same as ftest1, except that it uses lseek64 * * CALLS * lseek64, read, write * truncate, ftruncate, fsync, sync, fstat * * ALGORITHM * A bitmap is used to map pieces of a file. * Loop: pick a random piece of the file * if we haven't seen it before make sure it is zero, * write pattern * if we have seen it before make sure correct pattern. * * This was originally written by rbk - was program tfio.c * Modified by dale to integrate with test suites. * * RESTRICTIONS * Runs a long time with default args - can take others on input * line. Use with "term mode". * If run on vax the ftruncate will not be random - will always go to * start of file. NOTE: produces a very high load average!! * * CAUTION!! * If a file is supplied to this program with the "-f" option * it will be removed with a system("rm -rf filename") call. * */ #define _XOPEN_SOURCE 500 #define _LARGEFILE64_SOURCE 1 #include <stdio.h> #include <sys/types.h> #include <sys/wait.h> #include <sys/stat.h> #include <errno.h> #include <fcntl.h> #include <signal.h> #include <unistd.h> #include <inttypes.h> #include <sys/param.h> #include "test.h" #include "safe_macros.h" #include "libftest.h" char *TCID = "ftest05"; int TST_TOTAL = 1; static void setup(void); static void runtest(); static void dotest(int, int, int); static void domisc(int, int, char *); static void term(int sig); static void cleanup(void); #define PASSED 1 #define FAILED 0 #define MAXCHILD 25 #define K_1 1024 #define K_2 2048 #define K_4 4096 static int csize; /* chunk size */ static int iterations; /* # total iterations */ static off64_t max_size; /* max file size */ static int misc_intvl; /* for doing misc things; 0 ==> no */ static int nchild; /* how many children */ static int fd; /* file descriptor used by child */ static int parent_pid; static int pidlist[MAXCHILD]; static char test_name[2]; /* childs test directory name */ static char fuss[MAXPATHLEN]; /* directory to do this in */ static char homedir[MAXPATHLEN]; /* where we started */ static int local_flag; int main(int ac, char *av[]) { int lc; tst_parse_opts(ac, av, NULL, NULL); setup(); local_flag = PASSED; for (lc = 0; TEST_LOOPING(lc); lc++) { runtest(); if (local_flag == PASSED) tst_resm(TPASS, "Test passed."); else tst_resm(TFAIL, "Test failed."); } cleanup(); return 1; } static void setup(void) { /* * Make a directory to do this in; ignore error if already exists. * Save starting directory. */ tst_tmpdir(); getcwd(homedir, sizeof(homedir)); parent_pid = getpid(); if (!fuss[0]) sprintf(fuss, "./ftest05.%d", getpid()); mkdir(fuss, 0755); SAFE_CHDIR(NULL, fuss); /* * Default values for run conditions. */ iterations = 10; nchild = 5; csize = K_2; /* should run with 1, 2, and 4 K sizes */ max_size = K_1 * K_1; misc_intvl = 10; if (sigset(SIGTERM, term) == SIG_ERR) { tst_brkm(TBROK | TERRNO, NULL, "sigset (signo = SIGTERM) failed"); } local_flag = PASSED; } static void runtest(void) { int child, count, i, nwait, pid, status; nwait = 0; for (i = 0; i < nchild; i++) { test_name[0] = 'a' + i; test_name[1] = '\0'; fd = SAFE_OPEN(NULL, test_name, O_RDWR | O_CREAT | O_TRUNC, 0666); if ((child = fork()) == 0) { dotest(nchild, i, fd); tst_exit(); } close(fd); if (child < 0) { tst_brkm(TBROK | TERRNO, NULL, "fork failed"); } else { pidlist[i] = child; nwait++; } } /* * Wait for children to finish. */ count = 0; while (1) { if ((child = wait(&status)) >= 0) { if (status != 0) { tst_resm(TFAIL, "\tTest{%d} failed, expected 0 exit.", child); local_flag = FAILED; } ++count; } else if (errno != EINTR) break; } /* * Should have collected all children. */ if (count != nwait) { tst_resm(TFAIL, "\tWrong # children waited on, count = %d", count); local_flag = FAILED; } chdir(homedir); pid = fork(); if (pid < 0) { tst_brkm(TBROK | TERRNO, sync, "fork failed"); tst_exit(); } if (pid == 0) { execl("/bin/rm", "rm", "-rf", fuss, NULL); exit(1); } wait(&status); if (status) { tst_resm(TINFO, "CAUTION - ftest05, '%s' may not be removed", fuss); } sync(); } /* * dotest() * Children execute this. * * Randomly read/mod/write chunks with known pattern and check. * When fill sectors, iterate. */ #define NMISC 4 enum m_type { m_fsync, m_trunc, m_sync, m_fstat }; char *m_str[] = { "fsync", "trunc", "sync", "fstat" }; int misc_cnt[NMISC]; /* counts # of each kind of misc */ int file_max; /* file-max size */ int nchunks; int last_trunc = -1; int tr_flag; enum m_type type = m_fsync; #define CHUNK(i) (((off64_t)i) * csize) #define NEXTMISC ((rand() % misc_intvl) + 5) static void dotest(int testers, int me, int fd) { int i, count, collide, chunk, whenmisc, xfr; char *bits, *hold_bits, *buf, *val_buf, *zero_buf; char val; struct stat stat; nchunks = max_size / csize; if ((bits = calloc((nchunks + 7) / 8, 1)) == NULL) { perror("\tmalloc (bits)"); exit(1); } if ((hold_bits = calloc((nchunks + 7) / 8, 1)) == NULL) { perror("\tmalloc (bold_bits)"); exit(1); } if ((buf = (calloc(csize, 1))) == NULL) { perror("\tmalloc (buf)"); exit(1); } if ((val_buf = (calloc(csize, 1))) == NULL) { perror("\tmalloc (val_buf)"); exit(1); } if ((zero_buf = (calloc(csize, 1))) == NULL) { perror("\tmalloc (zero_buf)"); exit(1); } /* * No init sectors; allow file to be sparse. */ val = (64 / testers) * me + 1; /* * For each iteration: * zap bits array * loop: * pick random chunk, read it. * if corresponding bit off { * verify == 0. (sparse file) * ++count; * } else * verify == val. * write "val" on it. * repeat until count = nchunks. * ++val. */ srand(getpid()); if (misc_intvl) whenmisc = NEXTMISC; while (iterations-- > 0) { for (i = 0; i < NMISC; i++) misc_cnt[i] = 0; ftruncate(fd, 0); file_max = 0; memset(bits, 0, (nchunks + 7) / 8); memset(hold_bits, 0, (nchunks + 7) / 8); memset(val_buf, val, csize); memset(zero_buf, 0, csize); count = 0; collide = 0; while (count < nchunks) { chunk = rand() % nchunks; /* * Read it. */ if (lseek64(fd, CHUNK(chunk), 0) < (off64_t) 0) { tst_brkm(TFAIL | TERRNO, NULL, "\tTest[%d]: lseek64(0) fail at %Lx", me, CHUNK(chunk)); } if ((xfr = read(fd, buf, csize)) < 0) { tst_brkm(TFAIL | TERRNO, NULL, "\tTest[%d]: read fail at %Lx", me, CHUNK(chunk)); } /* * If chunk beyond EOF just write on it. * Else if bit off, haven't seen it yet. * Else, have. Verify values. */ //printf("%li %d", CHUNK(chunk), file_max ); if (CHUNK(chunk) >= file_max) { bits[chunk / 8] |= (1 << (chunk % 8)); ++count; } else if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0) { if (xfr != csize) { //tst_resm(TINFO, "\tTest[%d]: xfr=%d != %d, zero read.", // me, xfr, csize); tst_exit(); } if (memcmp(buf, zero_buf, csize)) { tst_resm(TFAIL, "\tTest[%d] bad verify @ 0x%Lx for val %d count %d xfr %d file_max 0x%x, should be %d.", me, CHUNK(chunk), val, count, xfr, file_max, zero_buf[0]); tst_resm(TINFO, "\tTest[%d]: last_trunc = 0x%x", me, last_trunc); fstat(fd, &stat); tst_resm(TINFO, "\tStat: size=%llx, ino=%x", stat.st_size, (unsigned)stat.st_ino); sync(); ft_dumpbuf(buf, csize); ft_dumpbits(bits, (nchunks + 7) / 8); ft_orbits(hold_bits, bits, (nchunks + 7) / 8); tst_resm(TINFO, "\tHold "); ft_dumpbits(hold_bits, (nchunks + 7) / 8); tst_exit(); } bits[chunk / 8] |= (1 << (chunk % 8)); ++count; } else { if (xfr != csize) { tst_brkm(TFAIL, NULL, "\tTest[%d]: xfr=%d != %d, val read.", me, xfr, csize); } ++collide; if (memcmp(buf, val_buf, csize)) { tst_resm(TFAIL, "\tTest[%d] bad verify @ 0x%Lx for val %d count %d xfr %d file_max 0x%x.", me, CHUNK(chunk), val, count, xfr, file_max); tst_resm(TINFO, "\tTest[%d]: last_trunc = 0x%x", me, last_trunc); fstat(fd, &stat); tst_resm(TINFO, "\tStat: size=%llx, ino=%x", stat.st_size, (unsigned)stat.st_ino); sync(); ft_dumpbuf(buf, csize); ft_dumpbits(bits, (nchunks + 7) / 8); ft_orbits(hold_bits, bits, (nchunks + 7) / 8); tst_resm(TINFO, "\tHold "); ft_dumpbits(hold_bits, (nchunks + 7) / 8); tst_exit(); } } /* * Write it. */ if (lseek64(fd, -((off64_t) xfr), 1) < (off64_t) 0) { tst_brkm(TFAIL | TERRNO, NULL, "\tTest[%d]: lseek64(1) fail at %Lx", me, CHUNK(chunk)); } if ((xfr = write(fd, val_buf, csize)) < csize) { if (errno == ENOSPC) { tst_resm(TFAIL, "\tTest[%d]: no space, exiting.", me); fsync(fd); } else { tst_resm(TFAIL | TERRNO, "\tTest[%d]: write fail at %Lx xfr %d", me, CHUNK(chunk), xfr); } tst_exit(); } if (CHUNK(chunk) + csize > file_max) file_max = CHUNK(chunk) + csize; /* * If hit "misc" interval, do it. */ if (misc_intvl && --whenmisc <= 0) { ft_orbits(hold_bits, bits, (nchunks + 7) / 8); domisc(me, fd, bits); whenmisc = NEXTMISC; } if (count + collide > 2 * nchunks) break; } /* * End of iteration, maybe before doing all chunks. */ fsync(fd); ++misc_cnt[m_fsync]; //tst_resm(TINFO, "\tTest{%d} val %d done, count = %d, collide = {%d}", // me, val, count, collide); //for (i = 0; i < NMISC; i++) // tst_resm(TINFO, "\t\tTest{%d}: {%d} %s's.", me, misc_cnt[i], m_str[i]); ++val; } } /* * domisc() * Inject misc syscalls into the thing. */ static void domisc(int me, int fd, char *bits) { int chunk; struct stat sb; if (type > m_fstat) type = m_fsync; switch (type) { case m_fsync: if (fsync(fd) < 0) { tst_resm(TFAIL | TERRNO, "\tTest[%d]: fsync error", me); } break; case m_trunc: chunk = rand() % (file_max / csize); file_max = CHUNK(chunk); last_trunc = file_max; if (tr_flag) { if (ftruncate(fd, file_max) < 0) { tst_brkm(TFAIL | TERRNO, NULL, "\tTest[%d]: ftruncate error @ 0x%x.", me, file_max); } tr_flag = 0; } else { if (truncate(test_name, file_max) < 0) { tst_brkm(TFAIL | TERRNO, NULL, "\tTest[%d]: truncate error @ 0x%x.", me, file_max); } tr_flag = 1; } for (; chunk % 8 != 0; chunk++) bits[chunk / 8] &= ~(1 << (chunk % 8)); for (; chunk < nchunks; chunk += 8) bits[chunk / 8] = 0; break; case m_sync: sync(); break; case m_fstat: if (fstat(fd, &sb) < 0) { tst_brkm(TFAIL | TERRNO, NULL, "\tTest[%d]: fstat() error.", me); } if (sb.st_size != file_max) { tst_brkm(TFAIL, NULL, "\tTest[%d]: fstat() mismatch; st_size=%" PRIx64 ",file_max=%x.", me, (int64_t) sb.st_size, file_max); } break; } ++misc_cnt[type]; ++type; } /* term() * * This is called when a SIGTERM signal arrives. */ static void term(int sig LTP_ATTRIBUTE_UNUSED) { int i; tst_resm(TINFO, "\tterm -[%d]- got sig term.", getpid()); /* * If run by hand we like to have the parent send the signal to * the child processes. This makes life easy. */ if (parent_pid == getpid()) { for (i = 0; i < nchild; i++) if (pidlist[i]) /* avoid embarassment */ kill(pidlist[i], SIGTERM); return; } tst_resm(TINFO, "\tunlinking '%s'", test_name); close(fd); if (unlink(test_name)) tst_resm(TBROK, "Unlink of '%s' failed, errno = %d.", test_name, errno); else tst_resm(TINFO, "Unlink of '%s' successful.", test_name); tst_exit(); } static void cleanup(void) { tst_rmdir(); tst_exit(); }