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.
501 lines
9.6 KiB
501 lines
9.6 KiB
/*
|
|
*
|
|
* Copyright (c) International Business Machines Corp., 2002
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
/* 11/18/2002 Port to LTP robbiew@us.ibm.com */
|
|
/* 06/30/2001 Port to Linux nsharoff@us.ibm.com */
|
|
|
|
/*
|
|
* NAME
|
|
* data_space.c -- test data space
|
|
*
|
|
* CALLS
|
|
* malloc (3)
|
|
*
|
|
* ALGORITHM
|
|
* Test VM for set of data-space intensive programs
|
|
*
|
|
*/
|
|
|
|
#define _XOPEN_SOURCE 500
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
#include <sys/types.h>
|
|
#include <errno.h>
|
|
#include <sys/wait.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
//void (*sigset(int, void(*)(int)))(int);
|
|
|
|
/** LTP Port **/
|
|
#include "test.h"
|
|
|
|
#define FAILED 0
|
|
#define PASSED 1
|
|
|
|
int local_flag = PASSED;
|
|
int block_number;
|
|
|
|
char *TCID = "data_space"; /* Test program identifier. */
|
|
int TST_TOTAL = 1; /* Total number of test cases. */
|
|
/**************/
|
|
|
|
#define MAXCHILD 100 /* max number of children to allow */
|
|
int allchild[MAXCHILD + 1];
|
|
#define K_1 1024
|
|
#define K_2 2048
|
|
#define K_4 4096
|
|
|
|
#define bd_arg(str) \
|
|
tst_brkm(TCONF, NULL, \
|
|
"bad argument - %s - could not parse as number.", str)
|
|
|
|
int nchild; /* # kids */
|
|
int csize; /* chunk size */
|
|
int iterations; /* # total iterations */
|
|
int rep_freq; /* report frequency */
|
|
int max_size; /* max file size */
|
|
int parent_pid;
|
|
|
|
int usage(char *);
|
|
int runtest();
|
|
int dotest(int, int);
|
|
void bfill(char *, char, int);
|
|
int dumpbuf(char *);
|
|
void dumpbits(char *, int);
|
|
int massmurder();
|
|
int okexit(int);
|
|
|
|
char *prog; /* invoked name */
|
|
int chld_flag = 0;
|
|
|
|
void cleanup(void)
|
|
{
|
|
tst_rmdir();
|
|
}
|
|
|
|
int usage(prog)
|
|
char *prog;
|
|
{
|
|
tst_resm(TCONF, "Usage: %s <nchild> <size> <chunk_size> <iterations>",
|
|
prog);
|
|
tst_brkm(TCONF, NULL, "DEFAULTS: 10 1024*1024 4096 25");
|
|
}
|
|
|
|
int main(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
int i = 1;
|
|
int term();
|
|
int chld();
|
|
|
|
prog = argv[0];
|
|
|
|
if (argc == 1) {
|
|
nchild = 10;
|
|
max_size = K_1 * K_1;
|
|
csize = K_4;
|
|
iterations = 25;
|
|
} else if (argc == 5) {
|
|
if (sscanf(argv[i++], "%d", &nchild) != 1)
|
|
bd_arg(argv[i - 1]);
|
|
if (sscanf(argv[i++], "%d", &max_size) != 1)
|
|
bd_arg(argv[i - 1]);
|
|
if (sscanf(argv[i++], "%d", &csize) != 1)
|
|
bd_arg(argv[i - 1]);
|
|
if (sscanf(argv[i++], "%d", &iterations) != 1)
|
|
bd_arg(argv[i - 1]);
|
|
if (nchild > MAXCHILD) {
|
|
tst_brkm(TBROK, NULL,
|
|
"FAILURE, %d children exceeded maximum allowed",
|
|
nchild);
|
|
}
|
|
} else
|
|
usage(prog);
|
|
|
|
tst_tmpdir();
|
|
|
|
parent_pid = getpid();
|
|
|
|
if (sigset(SIGTERM, (void (*)())term) == SIG_ERR) {
|
|
tst_brkm(TBROK, NULL, "first sigset failed");
|
|
}
|
|
if (sigset(SIGUSR1, (void (*)())chld) == SIG_ERR) {
|
|
tst_brkm(TBROK, NULL, "sigset shichld");
|
|
}
|
|
|
|
runtest();
|
|
tst_exit();
|
|
}
|
|
|
|
int runtest()
|
|
{
|
|
register int i;
|
|
int child;
|
|
int status;
|
|
int count;
|
|
|
|
for (i = 0; i < nchild; i++) {
|
|
chld_flag = 0;
|
|
switch (child = fork()) {
|
|
case -1:
|
|
tst_brkm(TBROK | TERRNO, cleanup, "fork failed");
|
|
case 0:
|
|
dotest(nchild, i);
|
|
exit(0);
|
|
}
|
|
allchild[i] = child;
|
|
while (!chld_flag)
|
|
sleep(1);
|
|
}
|
|
|
|
/*
|
|
* Wait for children to finish.
|
|
*/
|
|
|
|
count = 0;
|
|
while ((child = wait(&status)) > 0) {
|
|
#ifdef DEBUG
|
|
tst_resm(TINFO, "\t%s[%d] exited status = 0x%x\n", prog, child,
|
|
status);
|
|
#endif
|
|
if (status) {
|
|
tst_resm(TFAIL, "\tTest failed, expected 0 exit.\n");
|
|
local_flag = FAILED;
|
|
}
|
|
++count;
|
|
}
|
|
|
|
/*
|
|
* Should have collected all children.
|
|
*/
|
|
|
|
if (count != nchild) {
|
|
tst_resm(TFAIL, "\tWrong # children waited on, count = %d\n",
|
|
count);
|
|
local_flag = FAILED;
|
|
}
|
|
|
|
if (local_flag == FAILED)
|
|
tst_resm(TFAIL, "Test failed");
|
|
else
|
|
tst_resm(TPASS, "Test passed");
|
|
sync(); /* safeness */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* dotest()
|
|
* Children execute this.
|
|
*
|
|
* Randomly read/mod/write chunks with known pattern and check.
|
|
* When fill sectors, iterate.
|
|
*
|
|
*/
|
|
|
|
int nchunks;
|
|
|
|
#define CHUNK(i) ((i) * csize)
|
|
|
|
int dotest(testers, me)
|
|
int testers;
|
|
int me;
|
|
{
|
|
char *bits;
|
|
char *mondobuf;
|
|
char *val_buf;
|
|
char *zero_buf;
|
|
char *buf;
|
|
int count;
|
|
int collide;
|
|
char val;
|
|
int chunk;
|
|
|
|
/*
|
|
* Do the mondo-test.
|
|
*
|
|
* NOTE: If we run this with a lot of children, the last child
|
|
* processes may not have enough swap space to do these
|
|
* malloc's (mainly mondobuf). So if the malloc's don't
|
|
* work we just exit with zero status as long as we are
|
|
* not the first child.
|
|
*/
|
|
|
|
nchunks = max_size / csize;
|
|
bits = malloc((nchunks + 7) / 8);
|
|
if (bits == 0)
|
|
okexit(me);
|
|
val_buf = (char *)(malloc(csize));
|
|
if (val_buf == 0)
|
|
okexit(me);
|
|
zero_buf = (char *)(malloc(csize));
|
|
if (zero_buf == 0)
|
|
okexit(me);
|
|
mondobuf = malloc(max_size);
|
|
if (mondobuf == 0)
|
|
okexit(me);
|
|
|
|
kill(parent_pid, SIGUSR1);
|
|
|
|
/*
|
|
* No init sectors; allow file to be sparse.
|
|
*/
|
|
|
|
val = (64 / testers) * me + 1;
|
|
|
|
/*
|
|
* For each iteration:
|
|
* zap bits array
|
|
* loop:
|
|
* pick random chunk.
|
|
* if corresponding bit off {
|
|
* verify == 0. (sparse file)
|
|
* ++count;
|
|
* } else
|
|
* verify == val.
|
|
* write "val" on it.
|
|
* repeat until count = nchunks.
|
|
* ++val.
|
|
* Fill-in those chunks not yet seen.
|
|
*/
|
|
|
|
bfill(zero_buf, 0, csize);
|
|
bfill(mondobuf, 0, max_size);
|
|
|
|
srand(getpid());
|
|
while (iterations-- > 0) {
|
|
bfill(bits, 0, (nchunks + 7) / 8);
|
|
bfill(val_buf, val, csize);
|
|
count = 0;
|
|
collide = 0;
|
|
while (count < nchunks) {
|
|
chunk = rand() % nchunks;
|
|
buf = mondobuf + CHUNK(chunk);
|
|
|
|
/*
|
|
* If bit off, haven't seen it yet.
|
|
* Else, have. Verify values.
|
|
*/
|
|
|
|
if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0) {
|
|
if (memcmp(buf, zero_buf, csize)) {
|
|
tst_resm(TFAIL,
|
|
"\t%s[%d] bad verify @ %d (%p) for val %d count %d, should be 0x%x.\n",
|
|
prog, me, chunk, buf, val,
|
|
count, val - 1);
|
|
tst_resm(TINFO, "\tPrev ");
|
|
dumpbuf(buf - csize);
|
|
dumpbuf(buf);
|
|
tst_resm(TINFO, "\tNext ");
|
|
dumpbuf(buf + csize);
|
|
dumpbits(bits, (nchunks + 7) / 8);
|
|
tst_exit();
|
|
}
|
|
bits[chunk / 8] |= (1 << (chunk % 8));
|
|
++count;
|
|
} else {
|
|
++collide;
|
|
if (memcmp(buf, val_buf, csize)) {
|
|
tst_resm(TFAIL,
|
|
"\t%s[%d] bad verify @ %d (%p) for val %d count %d.\n",
|
|
prog, me, chunk, buf, val,
|
|
count);
|
|
tst_resm(TINFO, "\tPrev ");
|
|
dumpbuf(buf - csize);
|
|
dumpbuf(buf);
|
|
tst_resm(TINFO, "\tNext ");
|
|
dumpbuf(buf + csize);
|
|
dumpbits(bits, (nchunks + 7) / 8);
|
|
tst_exit();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write it.
|
|
*/
|
|
|
|
bfill(buf, val, csize);
|
|
|
|
if (count + collide > 2 * nchunks)
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* End of iteration, maybe before doing all chunks.
|
|
*/
|
|
#ifdef DEBUG
|
|
tst_resm(TINFO,
|
|
"\t%s[%d] val %d done, count = %d, collide = %d.\n",
|
|
prog, me, val, count, collide);
|
|
#endif
|
|
for (chunk = 0; chunk < nchunks; chunk++) {
|
|
if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0)
|
|
bfill(mondobuf + CHUNK(chunk), val, csize);
|
|
}
|
|
bfill(zero_buf, val, csize);
|
|
++val;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void bfill(buf, val, size)
|
|
register char *buf;
|
|
char val;
|
|
register int size;
|
|
{
|
|
register int i;
|
|
|
|
for (i = 0; i < size; i++)
|
|
buf[i] = val;
|
|
}
|
|
|
|
/*
|
|
* dumpbuf
|
|
* Dump the buffer.
|
|
*/
|
|
|
|
int dumpbuf(buf)
|
|
register char *buf;
|
|
{
|
|
register int i;
|
|
char val;
|
|
int idx;
|
|
int nout;
|
|
|
|
#ifdef DEBUG
|
|
tst_resm(TINFO, "Buf: ... ");
|
|
for (i = -10; i < 0; i++)
|
|
tst_resm(TINFO, "%x, ", buf[i]);
|
|
tst_resm(TINFO, "\n");
|
|
#endif
|
|
|
|
nout = 0;
|
|
idx = 0;
|
|
val = buf[0];
|
|
for (i = 0; i < csize; i++) {
|
|
if (buf[i] != val) {
|
|
#ifdef DEBUG
|
|
if (i == idx + 1)
|
|
tst_resm(TINFO, "%x, ", buf[idx] & 0xff);
|
|
else
|
|
tst_resm(TINFO, "%d*%x, ", i - idx,
|
|
buf[idx] & 0xff);
|
|
#endif
|
|
idx = i;
|
|
val = buf[i];
|
|
++nout;
|
|
}
|
|
if (nout > 10) {
|
|
#ifdef DEBUG
|
|
tst_resm(TINFO, " ... more\n");
|
|
#endif
|
|
return 0;
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
if (i == idx + 1)
|
|
tst_resm(TINFO, "%x\n", buf[idx] & 0xff);
|
|
else
|
|
tst_resm(TINFO, "%d*%x\n", i - idx, buf[idx]);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* dumpbits
|
|
* Dump the bit-map.
|
|
*/
|
|
|
|
void dumpbits(bits, size)
|
|
char *bits;
|
|
register int size;
|
|
{
|
|
#ifdef DEBUG
|
|
register char *buf;
|
|
|
|
tst_resm(TINFO, "Bits array:");
|
|
for (buf = bits; size > 0; --size, ++buf) {
|
|
if ((buf - bits) % 16 == 0)
|
|
tst_resm(TINFO, "\n%04x:\t", 8 * (buf - bits));
|
|
tst_resm(TINFO, "%02x ", (int)*buf & 0xff);
|
|
}
|
|
tst_resm(TINFO, "\n");
|
|
#endif
|
|
}
|
|
|
|
/* term()
|
|
*
|
|
* Parent - kill kids and return when signal arrives.
|
|
* Child - exit.
|
|
*/
|
|
int term()
|
|
{
|
|
#ifdef DEBUG
|
|
tst_resm(TINFO, "\tterm -[%d]- got sig term.\n", getpid());
|
|
#endif
|
|
|
|
if (parent_pid == getpid()) {
|
|
massmurder();
|
|
return 0;
|
|
}
|
|
|
|
exit(0);
|
|
}
|
|
|
|
int chld()
|
|
{
|
|
if (sigset(SIGUSR1, (void (*)())chld) == SIG_ERR) {
|
|
tst_resm(TBROK, "sigset shichld");
|
|
exit(1);
|
|
}
|
|
chld_flag++;
|
|
return 0;
|
|
}
|
|
|
|
int massmurder()
|
|
{
|
|
int i;
|
|
for (i = 0; i < MAXCHILD; i++) {
|
|
if (allchild[i]) {
|
|
kill(allchild[i], SIGTERM);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int okexit(me)
|
|
int me;
|
|
{
|
|
kill(parent_pid, SIGUSR1);
|
|
tst_resm(TINFO, "\tChild [%d] - cannot malloc buffer - exiting.\n", me);
|
|
if (me) {
|
|
tst_resm(TINFO, "\tThis is ok - probably swap space limit.\n");
|
|
tst_exit();
|
|
} else {
|
|
tst_brkm(TBROK,
|
|
NULL,
|
|
"\tThis is not ok for first child - check parameters.\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|