/*
 *
 *   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"
#include "usctest.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_resm(TCONF, "DEFAULTS: 10 1024*1024 4096 25");
	tst_exit();
	return 0;
}

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 = (char *)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 = (char *)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_resm(TBROK,
			 "\tThis is not ok for first child - check parameters.\n");
		tst_exit();
	}

	return 0;
}
