You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
638 lines
14 KiB
638 lines
14 KiB
/*
|
|
*
|
|
* 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
|
|
* ftest03.c -- test file I/O with readv and writev (ported from SPIE section2/filesuite/ftest4.c, by Airong Zhang)
|
|
*
|
|
* CALLS
|
|
* lseek, readv, writev,
|
|
* 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.
|
|
* Modified by G. Stevens to use readv and writev.
|
|
* Modofied by K. Hakim to integrate with SPIES.
|
|
*
|
|
* RESTRICTIONS
|
|
* 1. 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!!
|
|
*
|
|
* 2. The "csize" argument must be evenly divisible by MAXIOVCNT.
|
|
*
|
|
* 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
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#include <sys/uio.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
#include "test.h"
|
|
#include "safe_macros.h"
|
|
#include "libftest.h"
|
|
|
|
char *TCID = "ftest03";
|
|
int TST_TOTAL = 1;
|
|
|
|
#define PASSED 1
|
|
#define FAILED 0
|
|
|
|
static void setup(void);
|
|
static void runtest(void);
|
|
static void dotest(int, int, int);
|
|
static void domisc(int, int, char *);
|
|
static void term(int sig);
|
|
|
|
#define MAXCHILD 25
|
|
#define K_1 1024
|
|
#define K_2 2048
|
|
#define K_4 4096
|
|
#define MAXIOVCNT 16
|
|
|
|
static int csize; /* chunk size */
|
|
static int iterations; /* # total iterations */
|
|
static int 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();
|
|
|
|
for (lc = 0; TEST_LOOPING(lc); lc++) {
|
|
|
|
local_flag = PASSED;
|
|
|
|
runtest();
|
|
|
|
if (local_flag == PASSED) {
|
|
tst_resm(TPASS, "Test passed.");
|
|
} else {
|
|
tst_resm(TFAIL, "Test failed.");
|
|
}
|
|
|
|
tst_rmdir();
|
|
/* ??? so we are doing only one loop here ??? */
|
|
tst_exit();
|
|
}
|
|
|
|
tst_exit();
|
|
}
|
|
|
|
static void setup(void)
|
|
{
|
|
char wdbuf[MAXPATHLEN];
|
|
|
|
/*
|
|
* Make a directory to do this in; ignore error if already exists.
|
|
* Save starting directory.
|
|
*/
|
|
tst_tmpdir();
|
|
|
|
if (getcwd(homedir, sizeof(homedir)) == NULL) {
|
|
tst_brkm(TBROK | TERRNO, NULL, "getcwd() failed");
|
|
}
|
|
|
|
parent_pid = getpid();
|
|
|
|
if (!fuss[0])
|
|
sprintf(fuss, "%s/ftest03.%d", getcwd(wdbuf, sizeof(wdbuf)),
|
|
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) {
|
|
perror("sigset failed");
|
|
tst_brkm(TBROK, NULL, " sigset failed: signo = 15");
|
|
}
|
|
}
|
|
|
|
static void runtest(void)
|
|
{
|
|
pid_t pid;
|
|
int child, count, i, nwait, 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) {
|
|
//tst_resm(TINFO, "\tTest{%d} exited status = 0x%x", child, status);
|
|
if (status) {
|
|
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);
|
|
} else
|
|
wait(&status);
|
|
|
|
if (status) {
|
|
tst_resm(TINFO, "CAUTION - ftest03, '%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_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) ((i) * csize)
|
|
#define NEXTMISC ((rand() % misc_intvl) + 5)
|
|
|
|
static void dotest(int testers, int me, int fd)
|
|
{
|
|
char *bits, *hold_bits;
|
|
char val;
|
|
int chunk, whenmisc, xfr, count, collide, i;
|
|
|
|
/* Stuff for the readv call */
|
|
struct iovec r_iovec[MAXIOVCNT];
|
|
int r_ioveclen;
|
|
|
|
/* Stuff for the writev call */
|
|
struct iovec val_iovec[MAXIOVCNT];
|
|
struct iovec zero_iovec[MAXIOVCNT];
|
|
int w_ioveclen;
|
|
struct stat stat;
|
|
|
|
nchunks = max_size / csize;
|
|
whenmisc = 0;
|
|
|
|
if ((bits = malloc((nchunks + 7) / 8)) == 0) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
|
|
if ((hold_bits = malloc((nchunks + 7) / 8)) == 0) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
|
|
/*Allocate memory for the iovec buffers and init the iovec arrays */
|
|
r_ioveclen = w_ioveclen = csize / MAXIOVCNT;
|
|
|
|
/* Please note that the above statement implies that csize
|
|
* be evenly divisible by MAXIOVCNT.
|
|
*/
|
|
for (i = 0; i < MAXIOVCNT; i++) {
|
|
if ((r_iovec[i].iov_base = calloc(r_ioveclen, 1)) == 0) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
/* tst_exit(); */
|
|
}
|
|
r_iovec[i].iov_len = r_ioveclen;
|
|
|
|
/* Allocate unused memory areas between all the buffers to
|
|
* make things more diffult for the OS.
|
|
*/
|
|
if (malloc((i + 1) * 8) == NULL) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
|
|
if ((val_iovec[i].iov_base = calloc(w_ioveclen, 1)) == 0) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
|
|
val_iovec[i].iov_len = w_ioveclen;
|
|
|
|
if (malloc((i + 1) * 8) == NULL) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
|
|
if ((zero_iovec[i].iov_base = calloc(w_ioveclen, 1)) == 0) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
|
|
zero_iovec[i].iov_len = w_ioveclen;
|
|
|
|
if (malloc((i + 1) * 8) == NULL) {
|
|
tst_brkm(TBROK, NULL, "\tmalloc failed");
|
|
}
|
|
}
|
|
/*
|
|
* 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 unitl 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);
|
|
|
|
/* Have to fill the val and zero iov buffers in a different manner
|
|
*/
|
|
for (i = 0; i < MAXIOVCNT; i++) {
|
|
memset(val_iovec[i].iov_base, val,
|
|
val_iovec[i].iov_len);
|
|
memset(zero_iovec[i].iov_base, 0,
|
|
zero_iovec[i].iov_len);
|
|
|
|
}
|
|
|
|
count = 0;
|
|
collide = 0;
|
|
|
|
while (count < nchunks) {
|
|
chunk = rand() % nchunks;
|
|
/*
|
|
* Read it.
|
|
*/
|
|
if (lseek(fd, CHUNK(chunk), 0) < 0) {
|
|
tst_brkm(TFAIL,
|
|
NULL,
|
|
"\tTest[%d]: lseek(0) fail at %x, errno = %d.",
|
|
me, CHUNK(chunk), errno);
|
|
}
|
|
if ((xfr = readv(fd, &r_iovec[0], MAXIOVCNT)) < 0) {
|
|
tst_brkm(TFAIL,
|
|
NULL,
|
|
"\tTest[%d]: readv fail at %x, errno = %d.",
|
|
me, CHUNK(chunk), errno);
|
|
}
|
|
/*
|
|
* If chunk beyond EOF just write on it.
|
|
* Else if bit off, haven't seen it yet.
|
|
* Else, have. Verify values.
|
|
*/
|
|
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_brkm(TFAIL,
|
|
NULL,
|
|
"\tTest[%d]: xfr=%d != %d, zero read.",
|
|
me, xfr, csize);
|
|
}
|
|
for (i = 0; i < MAXIOVCNT; i++) {
|
|
if (memcmp
|
|
(r_iovec[i].iov_base,
|
|
zero_iovec[i].iov_base,
|
|
r_iovec[i].iov_len)) {
|
|
tst_resm(TFAIL,
|
|
"\tTest[%d] bad verify @ 0x%x for val %d count %d xfr %d file_max 0x%x, should be 0.",
|
|
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_dumpiov(&r_iovec[i]);
|
|
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;
|
|
for (i = 0; i < MAXIOVCNT; i++) {
|
|
if (memcmp
|
|
(r_iovec[i].iov_base,
|
|
val_iovec[i].iov_base,
|
|
r_iovec[i].iov_len)) {
|
|
tst_resm(TFAIL,
|
|
"\tTest[%d] bad verify @ 0x%x 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_dumpiov(&r_iovec[i]);
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
* Writev it.
|
|
*/
|
|
if (lseek(fd, -xfr, 1) < 0) {
|
|
tst_brkm(TFAIL,
|
|
NULL,
|
|
"\tTest[%d]: lseek(1) fail at %x, errno = %d.",
|
|
me, CHUNK(chunk), errno);
|
|
}
|
|
if ((xfr =
|
|
writev(fd, &val_iovec[0], MAXIOVCNT)) < csize) {
|
|
if (errno == ENOSPC) {
|
|
tst_resm(TFAIL,
|
|
"\tTest[%d]: no space, exiting.",
|
|
me);
|
|
fsync(fd);
|
|
tst_exit();
|
|
}
|
|
tst_brkm(TFAIL,
|
|
NULL,
|
|
"\tTest[%d]: writev fail at %x xfr %d, errno = %d.",
|
|
me, CHUNK(chunk), xfr, errno);
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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_brkm(TFAIL, NULL, "\tTest[%d]: fsync error %d.",
|
|
me,
|
|
errno);
|
|
}
|
|
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,
|
|
NULL,
|
|
"\tTest[%d]: ftruncate error %d @ 0x%x.",
|
|
me, errno, file_max);
|
|
}
|
|
tr_flag = 0;
|
|
} else {
|
|
if (truncate(test_name, file_max) < 0) {
|
|
tst_brkm(TFAIL,
|
|
NULL,
|
|
"\tTest[%d]: truncate error %d @ 0x%x.",
|
|
me, errno, 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_fstat:
|
|
if (fstat(fd, &sb) < 0) {
|
|
tst_brkm(TFAIL, NULL, "\tTest[%d]: fstat() error %d.",
|
|
me,
|
|
errno);
|
|
}
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* SIGTERM signal handler.
|
|
*/
|
|
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])
|
|
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(TBROK, "Unlink of '%s' successful.", test_name);
|
|
|
|
tst_exit();
|
|
}
|