Exemplo n.º 1
0
/*
 *  Child process that reads/writes map.  The child 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(unsigned procno, unsigned nprocs)
{
    uchar_t *paddr;
    unsigned randpage;
    unsigned int seed;
    unsigned loopcnt;
    unsigned nloops;
    unsigned i;


    seed = initrand();		/* initialize random seed */

    nloops = (randloops) ? (lrand48() % MAXLOOPS) : MAXLOOPS;

    if (debug)
        (void)printf("child %d (pid %d): seed %d, loop %d\n",
                     procno, getpid(), seed, nloops);

    /*
     *  Now loop read/writing random pages.
     */

    for (loopcnt = 0; loopcnt < nloops; loopcnt++) {
        randpage = lrand48() % mappages;
        /* find the page address */
        paddr = (uchar_t *)(mapaddr + (randpage * pagesize));

        for (i = procno; i < pagesize; i += nprocs) {
            if (*((unsigned char *)(paddr+i))
                    != ((procno + pattern) & 0xff)) {
                (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) {
        randpage = (unsigned)lrand48() % mappages;
        paddr = (uchar_t *)mapaddr + (randpage * pagesize);
        if (msync((caddr_t)paddr, (mappages-randpage)*pagesize,
                  MS_SYNC) == -1)
        {
            perror("msync error");
            anyfail();
        }
    }

    exit(0);
}
Exemplo n.º 2
0
/*
 *  Make sure file has all the correct data.
 */
int
mapokay(uchar_t *expbuf)
{
    uchar_t *ptr;
    unsigned i, j;

    ptr = (uchar_t *)mapaddr;
    for (i = 0; i < mappages; i++) {
        /*
         *  Compare read bytes of data.
         */
        for (j = 0; j < pagesize; j++) {
            if (*ptr != expbuf[j]) {
                (void)fprintf(stderr,
                              "bad map data: exp %c got %c)",
                              expbuf[j], *ptr);
                (void)fprintf(stderr, ", pg %d off %d\n", i, j);
                anyfail();
            }
            ptr++;
        }
    }

    return(1);
}
Exemplo n.º 3
0
/*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();
}
Exemplo n.º 4
0
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();
}
Exemplo n.º 5
0
static
void
do_test(caddr_t brk_max, long pagesize)
{
	if (mmap((caddr_t)((long)brk_max - 3*pagesize), (2*pagesize),
		PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE, 0, 0)
		== (caddr_t)-1)
	{
		ERROR("mmap failed");
		anyfail();
	}
	/* extend mmap */
	if (mmap((caddr_t)((long)brk_max - 2*pagesize), (2*pagesize),
		PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE, 0, 0)
		== (caddr_t)-1)
	{
		ERROR("mmap failed");
		anyfail();
	}
	if (sbrk(pagesize) == NEG1) {
		ERROR("sbrk failed to grow over mmaped region");
		anyfail();
	}
	if (sbrk(-pagesize) == NEG1) {
		ERROR("sbrk failed to shrink back to mmaped region");
		anyfail();
	}
	if (sbrk(-pagesize) == NEG1) {
		ERROR("sbrk failed to shrink over mmaped region more");
		anyfail();
	}
	if (sbrk(-pagesize) == NEG1) {
		ERROR("sbrk failed to shrink some more");
		anyfail();
	}
	if (sbrk(2 * pagesize) == NEG1) {
		ERROR("sbrk failed to change brk segment to original size");
		anyfail();
	}
}
Exemplo n.º 6
0
Arquivo: fmtmsg01.c Projeto: Nudiv/ltp
/*--------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	int fd, ret_val;
	FILE *fp;

	setup();		/* temp file is now open */
/*--------------------------------------------------------------*/
	blenter();

	/* Check that system SEV_LEVEL output is correct */

	close(2);		/* redirect stderr to file */
	fd = creat("fmtfile", 0644);
	ret_val = fmtmsg(MM_PRINT | MM_SOFT, "LTP:fmtmsg", MM_INFO,
			 "LTP fmtmsg() test1 message, NOT an error",
			 "This is correct output, no action needed",
			 "LTP:msg:001");
	close(fd);

	if (ret_val != 0) {
		fprintf(temp, "fmtmsg returned %d, expected 0\n\n", ret_val);
		local_flag = FAILED;
	}

	fp = fopen("fmtfile", "r");
	clearbuf();
	fread(buf, sizeof(buf[0]), strlen(str1), fp);
	if (strcmp(str1, buf) != 0) {
		fprintf(temp, "Expected string: %s\n", str1);
		fprintf(temp, "does not match\n");
		fprintf(temp, "received string: %s\n\n", buf);
		local_flag = FAILED;
	}

	/* Read past spaces in output */
	fread(&ch, sizeof(ch), 1, fp);
	while (isspace(ch))
		fread(&ch, sizeof(ch), 1, fp);
	ungetc(ch, fp);

	clearbuf();
	fread(buf, sizeof(buf[0]), strlen(str2), fp);
	fclose(fp);
	if (strcmp(str2, buf) != 0) {
		fprintf(temp, "Expected string: %s\n", str2);
		fprintf(temp, "does not match\n");
		fprintf(temp, "received string: %s\n\n", buf);
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	/* Check that a system defined SEV_LEVEL cannot get redefined */

	ret_val = addseverity(3, "INVALID");
	if (ret_val != MM_NOTOK) {
		fprintf(temp, "addseverity returned %d, expected MM_NOTOK\n",
			ret_val);
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	/* Check that we can define our own */
	/* SEV_LEVEL and output is correct  */

	ret_val = addseverity(5, "LTP_TEST");
	if (ret_val != MM_OK) {
		fprintf(temp, "addseverity returned %d, expected MM_OK\n",
			ret_val);
		local_flag = FAILED;
	}

	close(2);		/* redirect stderr to file */
	fd = creat("fmtfile", 0644);
	ret_val = fmtmsg(MM_PRINT | MM_HARD | MM_OPSYS, "LTP:fmtmsg", 5,
			 "LTP fmtmsg() test2 message, NOT an error",
			 "This is correct output, no action needed",
			 "LTP:msg:002");
	close(fd);

	if (ret_val != 0) {
		fprintf(temp, "fmtmsg returned %d, expected 0\n", ret_val);
		local_flag = FAILED;
	}

	fp = fopen("fmtfile", "r");
	clearbuf();
	fread(buf, sizeof(buf[0]), strlen(str3), fp);
	if (strcmp(str3, buf) != 0) {
		fprintf(temp, "Expected string: %s\n", str3);
		fprintf(temp, "does not match\n");
		fprintf(temp, "received string: %s\n\n", buf);
		local_flag = FAILED;
	}

	/* Read past spaces in output */
	fread(&ch, sizeof(ch), 1, fp);
	while (isspace(ch))
		fread(&ch, sizeof(ch), 1, fp);
	ungetc(ch, fp);

	clearbuf();
	fread(buf, sizeof(buf[0]), strlen(str4), fp);
	if (strcmp(str4, buf) != 0) {
		fprintf(temp, "Expected string: %s\n", str4);
		fprintf(temp, "does not match\n");
		fprintf(temp, "received string: %s\n\n", buf);
		local_flag = FAILED;
	}

	fclose(fp);
	remove("fmtfile");

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	/* Test result of writing to /dev/console */

	ret_val = fmtmsg(MM_CONSOLE | MM_HARD | MM_OPSYS, "LTP:fmtmsg", 5,
			 "LTP fmtmsg() test3 message, NOT an error",
			 "This is correct output, no action needed",
			 "LTP:msg:003");
	if (ret_val != MM_OK) {
		fprintf(temp, "fmtmsg returned %d, expected MM_OK\n", ret_val);
		fprintf(temp, "failed to write to console\n\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
/* Clean up any files created by test before call to anyfail.   */

	anyfail();		/* THIS CALL DOES NOT RETURN - EXITS!!  */
	tst_exit();
}
Exemplo n.º 7
0
Arquivo: kill12.c Projeto: 1587/ltp
/*--------------------------------------------------------------------*/
int main(int argc, char **argv)
{
/***** BEGINNING OF MAIN. *****/
	int pid, npid;
	int nsig, exno, nexno, status;
	int ret_val = 0;
	int core;
	void chsig();

#ifdef UCLINUX

	tst_parse_opts(argc, argv, NULL, NULL);

	maybe_run_child(&do_child, "dd", &temp, &sig);
#endif

	setup();
	//tempdir();            /* move to new directory */ 12/20/2003
	blenter();

	exno = 1;

	if (sigset(SIGCHLD, chsig) == SIG_ERR) {
		fprintf(temp, "\tsigset failed, errno = %d\n", errno);
		fail_exit();
	}

	for (sig = 1; sig < 14; sig++) {
		fflush(temp);
		chflag = 0;

		pid = FORK_OR_VFORK();
		if (pid < 0) {
			forkfail();
		}

		if (pid == 0) {
#ifdef UCLINUX
			if (self_exec(argv[0], "dd", temp, sig) < 0) {
				tst_brkm(TBROK, NULL, "self_exec FAILED - "
					 "terminating test.");
			}
#else
			do_child();
#endif
		} else {
			//fprintf(temp, "Testing signal %d\n", sig);

			while (!chflag)	/* wait for child */
				sleep(1);

			kill(pid, sig);	/* child should ignroe this sig */
			kill(pid, SIGCHLD);	/* child should exit */

#ifdef BCS
			while ((npid = wait(&status)) != pid
			       || (npid == -1 && errno == EINTR)) ;
			if (npid != pid) {
				fprintf(temp,
					"wait error: wait returned wrong pid\n");
				ret_val = 1;
			}
#else
			while ((npid = waitpid(pid, &status, 0)) != -1
			       || errno == EINTR) ;
#endif

			/*
			   nsig = status & 0177;
			   core = status & 0200;
			   nexno = (status & 0xff00) >> 8;
			 */
			/*****  LTP Port        *****/
			nsig = WTERMSIG(status);
#ifdef WCOREDUMP
			core = WCOREDUMP(status);
#endif
			nexno = WIFEXITED(status);
			/*****  **      **      *****/

			/* nsig is the signal number returned by wait
			   it should be 0, except when sig = 9          */

			if ((sig == 9) && (nsig != sig)) {
				fprintf(temp, "wait error: unexpected signal"
					" returned when the signal sent was 9"
					" The status of the process is %d \n",
					status);
				ret_val = 1;
			}
			if ((sig != 9) && (nsig != 0)) {
				fprintf(temp, "wait error: unexpected signal "
					"returned, the status of the process is "
					"%d  \n", status);
				ret_val = 1;
			}

			/* nexno is the exit number returned by wait
			   it should be 1, except when sig = 9          */

			if (sig == 9)
				if (nexno != 0) {
					fprintf(temp, "signal error: unexpected"
						" exit number returned when"
						" signal sent was 9, the status"
						" of the process is %d \n",
						status);
					ret_val = 1;
				} else;
			else if (nexno != 1) {
				fprintf(temp, "signal error: unexpected exit "
					"number returned,the status of the"
					" process is %d\n", status);
				ret_val = 1;
			}
		}
	}
	if (ret_val)
		local_flag = FAILED;

/*--------------------------------------------------------------------*/
	anyfail();
	tst_exit();
}					/******** END OF MAIN. ********/
Exemplo n.º 8
0
Arquivo: kill12.c Projeto: 1587/ltp
void fail_exit(void)
{
	local_flag = FAILED;
	anyfail();

}
Exemplo n.º 9
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();
}
Exemplo n.º 10
0
/*--------------------------------------------------------------*/
int main(void)
{
	setup();		/* temp file is now open        */

	npathdats = (sizeof(pathdat) / sizeof(pathdat[0]));
	ngoods = (sizeof(goodlist) / sizeof(goodlist[0]));
	nbads = (sizeof(badlist) / sizeof(badlist[0]));
	nmnem = (sizeof(mnem) / sizeof(mnem[0]));

	setup_path();

/*---------------- ENTER BLOCK 0 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall recursively descend the\n");
	fprintf(temp, "directory hierarchy rooted in path until it has\n");
	fprintf(temp,
		"traversed the whole tree, calling the function fn for\n");
	fprintf(temp, "each object in the directory tree, and return 0.\n\n");
#endif
	test1A();
	blexit();
/*--------------- EXIT BLOCK 0 ---------------------------------*/

/*---------------- ENTER BLOCK 1 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) when flags contains FTW_PHYS shall\n");
	fprintf(temp, "not traverse symbolic links.\n\n");
#endif
	test2A();
	blexit();
/*--------------- EXIT BLOCK 1 ---------------------------------*/

/*---------------- ENTER BLOCK 2 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp,
		"depth, int flags) when flags does not contain FTW_PHYS\n");
	fprintf(temp,
		"shall follow links instead of reporting them and shall\n");
	fprintf(temp, "not report the same file twice.\n\n");
#endif
	test3A();
	blexit();
/*--------------- EXIT BLOCK 2 ---------------------------------*/

/*---------------- ENTER BLOCK 3 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp,
		"depth, int flags) when flags contains FTW_DEPTH shall\n");
	fprintf(temp, "report all files in a directory before reporting the\n");
	fprintf(temp, "directory.\n\n");
#endif
	test4A();
	blexit();
/*--------------- EXIT BLOCK 3 ---------------------------------*/

/*---------------- ENTER BLOCK 4 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) when flags does not contain\n");
	fprintf(temp, "FTW_DEPTH shall report a directory before reporting\n");
	fprintf(temp, "the files in that directory.\n\n");
#endif
	test5A();
	blexit();
/*--------------- EXIT BLOCK 4 ---------------------------------*/

/*---------------- ENTER BLOCK 5 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp,
		"depth, int flags) when flags contains FTW_CHDIR shall\n");
	fprintf(temp,
		"change the current working directory to each directory\n");
	fprintf(temp, "as it reports files in that directory.\n\n");
#endif
	test6A();
	blexit();
/*--------------- EXIT BLOCK 5 ---------------------------------*/

/*---------------- ENTER BLOCK 6 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass the path-name of the\n");
	fprintf(temp, "current object as the first argument of the function\n");
	fprintf(temp, "fn.\n\n");
#endif
	test7A();
	blexit();
/*--------------- EXIT BLOCK 6 ---------------------------------*/

/*---------------- ENTER BLOCK 7 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass a pointer to a stat\n");
	fprintf(temp, "structure containing information about the current\n");
	fprintf(temp, "object as the second argument to fn.\n\n");
#endif
	test8A();
	blexit();
/*--------------- EXIT BLOCK 7 ---------------------------------*/

/*---------------- ENTER BLOCK 8 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_F as the third\n");
	fprintf(temp,
		"argument of the function fn when the object is a file.\n\n");
#endif
	test9A();
	blexit();
/*--------------- EXIT BLOCK 8 ---------------------------------*/

/*---------------- ENTER BLOCK 9 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_D as the third\n");
	fprintf(temp, "argument of the function fn when the object is a\n");
	fprintf(temp, "directory.\n\n");
#endif
	test10A();
	blexit();
/*--------------- EXIT BLOCK 9 ---------------------------------*/

/*---------------- ENTER BLOCK 10 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_DP as the third\n");
	fprintf(temp, "argument of the function fn when the object is a\n");
	fprintf(temp, "directory and subdirectories have been visited.\n\n");
#endif
	test11A();
	blexit();
/*--------------- EXIT BLOCK 10 ---------------------------------*/

/*---------------- ENTER BLOCK 11 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_SL as the third\n");
	fprintf(temp, "argument of the function fn when the object is a\n");
	fprintf(temp, "symbolic link.\n\n");
#endif
	test12A();
	blexit();
/*--------------- EXIT BLOCK 11 ---------------------------------*/

/*---------------- ENTER BLOCK 12 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_SLN as the third\n");
	fprintf(temp, "argument of the function fn when the object is a\n");
	fprintf(temp, "symbolic link that does not name an existing file.\n\n");
#endif
	test13A();
	blexit();
/*--------------- EXIT BLOCK 12 ---------------------------------*/

/*---------------- ENTER BLOCK 13 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_DNR as the third\n");
	fprintf(temp, "argument of the function fn when the object is a\n");
	fprintf(temp, "directory that cannot be read.\n\n");
#endif
	test14A();
	blexit();
/*--------------- EXIT BLOCK 13 ---------------------------------*/

/*---------------- ENTER BLOCK 14 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_NS as the third\n");
	fprintf(temp,
		"argument of the function fn when stat() failed on the\n");
	fprintf(temp, "object because of lack of appropriate permission.\n\n");
#endif
	test15A();
	blexit();
/*--------------- EXIT BLOCK 14 ---------------------------------*/

/*---------------- ENTER BLOCK 15 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass a structure which\n");
	fprintf(temp, "contains the offset into the pathname of the object\n");
	fprintf(temp, "and the depth relative to the root of the walk\n");
	fprintf(temp,
		"starting from 0 as the fourth argument of the function\n");
	fprintf(temp, "fn.\n\n");
#endif
	test16A();
	blexit();
/*--------------- EXIT BLOCK 15 ---------------------------------*/

/*---------------- ENTER BLOCK 16 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_SL as the third\n");
	fprintf(temp, "argument to the function fn if and only if the\n");
	fprintf(temp, "FTW_PHYS flag is included in flags.\n\n");
#endif
	test17A();
	blexit();
/*--------------- EXIT BLOCK 16 ---------------------------------*/

/*---------------- ENTER BLOCK 17 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall pass FTW_SLN as the third\n");
	fprintf(temp, "argument to the function fn if and only if the\n");
	fprintf(temp, "FTW_PHYS flag is not included in flags.\n\n");
#endif
	test18A();
	blexit();
/*--------------- EXIT BLOCK 17 ---------------------------------*/

/*---------------- ENTER BLOCK 18 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "On a call to int nftw(const char *path, int\n");
	fprintf(temp, "(*fn)(const char *, const struct stat *, int, struct\n");
	fprintf(temp,
		"FTW *), int depth, int flags) when the third argument\n");
	fprintf(temp, "passed to the function fn is FTW_DNR then the\n");
	fprintf(temp,
		"descendants of the directory shall not be processed.\n\n");
#endif
	test19A();
	blexit();
/*--------------- EXIT BLOCK 18 ---------------------------------*/

/*---------------- ENTER BLOCK 19 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp,
		"depth, int flags) shall close any file descriptors or\n");
	fprintf(temp,
		"directory streams used to traverse the directory tree.\n\n");
#endif
	test20A();
	blexit();
/*--------------- EXIT BLOCK 19 ---------------------------------*/

/*---------------- ENTER BLOCK 20 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "On a call to int nftw(const char *path, int\n");
	fprintf(temp, "(*fn)(const char *, const struct stat *, int, struct\n");
	fprintf(temp, "FTW *), int depth, int flags) depth shall be the\n");
	fprintf(temp,
		"maximum number of file descriptors used for the search.\n\n");
#endif
	test21A();
	blexit();
/*--------------- EXIT BLOCK 20 ---------------------------------*/

/*---------------- ENTER BLOCK 21 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) shall use at most one file\n");
	fprintf(temp, "descriptor for each directory level.\n\n");
#endif
	test22A();
	blexit();
/*--------------- EXIT BLOCK 21 ---------------------------------*/

/*---------------- ENTER BLOCK 22 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
	fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
	fprintf(temp, "depth, int flags) when the function fn returns a\n");
	fprintf(temp, "non-zero value shall stop and return the value\n");
	fprintf(temp, "returned by fn.\n\n");
#endif
	test23A();
	blexit();
/*--------------- EXIT BLOCK 22 ---------------------------------*/

/*---------------- ENTER BLOCK 23 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "ENAMETOOLONG in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp, "flags) when the length of path exceeds PATH_MAX.\n\n");
#endif
	test24A();
	blexit();
/*--------------- EXIT BLOCK 23 ---------------------------------*/

/*---------------- ENTER BLOCK 24 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "ENAMETOOLONG in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp, "flags) when a component of path exceeds NAME_MAX.\n\n");
#endif
	test25A();
	blexit();
/*--------------- EXIT BLOCK 24 ---------------------------------*/

/*---------------- ENTER BLOCK 25 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "ENOENT in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp,
		"flags) when path points to a file which does not exist.\n\n");
#endif
	test26A();
	blexit();
/*--------------- EXIT BLOCK 25 ---------------------------------*/

/*---------------- ENTER BLOCK 26 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "ENOENT in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp, "flags) when path points to an empty string.\n\n");
#endif
	test27A();
	blexit();
/*--------------- EXIT BLOCK 26 ---------------------------------*/

/*---------------- ENTER BLOCK 27 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "ENOTDIR in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp, "flags) when path is not a directory.\n\n");
#endif
	test28A();
	blexit();
/*--------------- EXIT BLOCK 27 ---------------------------------*/

/*---------------- ENTER BLOCK 28 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "EACCES in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp, "flags) when search permission is denied for any\n");
	fprintf(temp, "component of path.\n\n");
#endif
	test29A();
	blexit();
/*--------------- EXIT BLOCK 28 ---------------------------------*/

/*---------------- ENTER BLOCK 29 --------------------------------*/
	blenter();
#ifdef DEBUG
	fprintf(temp, "EACCES in errno and return -1 on a call to int\n");
	fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
	fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
	fprintf(temp, "flags) when read permission is denied for path.\n\n");
#endif
	test30A();
	blexit();
/*--------------- EXIT BLOCK 29 ---------------------------------*/

	cleanup_function();

	anyfail();		/* THIS CALL DOES NOT RETURN - EXITS!!  */
	tst_exit();
/*--------------------------------------------------------------*/
}
Exemplo n.º 11
0
/*--------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	register int i;
	int v1, v2;

	setup();		/* temp file is now open        */
/*--------------------------------------------------------------*/
	blenter();

#if defined(SYS_getpid)
	for (i = 0; i < ITER; i++) {
		v1 = getpid();
		v2 = syscall(SYS_getpid);
		if (v1 != v2) {
			fprintf(temp, "\tgetpid syscall failed.\n");
			fprintf(temp, "\t  iteration %d\n", i);
			local_flag = FAILED;
			break;
		}
	}
#else
	fprintf(temp, "\tgetpid syscall failed.\n");
	fprintf(temp, "\tSYS_getpid not defined\n");
	local_flag = FAILED;
#endif
	blexit();
/*--------------------------------------------------------------*/
	blenter();

#if defined(SYS_getuid) || defined(SYS_getuid32)
	for (i = 0; i < ITER; i++) {
		v1 = getuid();
#if defined(SYS_getuid)
		v2 = syscall(SYS_getuid);
#else
		v2 = syscall(SYS_getuid32);
#endif
		if (v1 != v2) {
			fprintf(temp, "\tgetuid syscall failed.\n");
			fprintf(temp, "\t  iteration %d\n", i);
			local_flag = FAILED;
			break;
		}
	}
#else
	fprintf(temp, "\tgetuid syscall failed.\n");
	fprintf(temp, "\tSYS_getuid and SYS_getuid32 not defined\n");
	local_flag = FAILED;
#endif
	blexit();
/*--------------------------------------------------------------*/
	blenter();

#if defined(SYS_getgid) || defined(SYS_getgid32)
	for (i = 0; i < ITER; i++) {
		v1 = getgid();
#if defined(SYS_getgid)
		v2 = syscall(SYS_getgid);
#else
		v2 = syscall(SYS_getgid32);
#endif
		if (v1 != v2) {
			fprintf(temp, "\tgetgid syscall failed.\n");
			fprintf(temp, "\t  iteration %d\n", i);
			local_flag = FAILED;
			break;
		}
	}
#else
	fprintf(temp, "\tgetgid syscall failed.\n");
	fprintf(temp, "\tSYS_getgid and SYS_getgid32 not defined\n");
	local_flag = FAILED;
#endif

	blexit();
/*--------------------------------------------------------------*/

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
	cleanup();
	tst_exit();

	anyfail();		/* THIS CALL DOES NOT RETURN - EXITS!!  */

}
Exemplo n.º 12
0
Arquivo: memcpy01.c Projeto: kraj/ltp
int main(int argc, char *argv[])
{
	char *p, *q;

	tst_parse_opts(argc, argv, NULL, NULL);

	setup();		/* temp file is now open        */
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[100];

	fill(p);
	q = &buf[800];
	memcpy(q, p, LEN);

	if (checkit(q)) {
		fprintf(temp, "\tcopy failed - missed data\n");
		local_flag = FAILED;
	}

	if (p[-1] || p[LEN]) {
		fprintf(temp, "\tcopy failed - 'to' bounds\n");
		local_flag = FAILED;
	}

	if (q[-1] || q[LEN]) {
		fprintf(temp, "\tcopy failed - 'from' bounds\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[800];

	fill(p);
	q = &buf[100];
	memcpy(q, p, LEN);

	if (checkit(q)) {
		fprintf(temp, "\tcopy failed - missed data\n");
		local_flag = FAILED;
	}

	if (p[-1] || p[LEN]) {
		fprintf(temp, "\tcopy failed - 'to' bounds\n");
		local_flag = FAILED;
	}

	if (q[-1] || q[LEN]) {
		fprintf(temp, "\tcopy failed - 'from' bounds\n");
		local_flag = FAILED;
	}

	blexit();

	anyfail();
	tst_exit();
}
Exemplo n.º 13
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();
}
Exemplo n.º 14
0
/*--------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	char *p, *q;

	setup();		/* temp file is now open        */
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[100];
	q = &buf[800];

	fill(p);
	fill(q);

	if (memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp fails - should have succeeded.\n");
		local_flag = FAILED;
	}

	p[LEN - 1] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	p[LEN - 1] = 'a';
	p[0] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	p[0] = 'a';
	q[LEN - 1] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	q[LEN - 1] = 'a';
	q[0] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	q[0] = 'a';

	if (memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp fails - should have succeeded.\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[800];
	q = &buf[100];

	fill(p);
	fill(q);

	if (memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp fails - should have succeeded.\n");
		local_flag = FAILED;
	}

	p[LEN - 1] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	p[LEN - 1] = 'a';
	p[0] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	p[0] = 'a';
	q[LEN - 1] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	q[LEN - 1] = 'a';
	q[0] = 0;

	if (!memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp succeeded - should have failed.\n");
		local_flag = FAILED;
	};

	q[0] = 'a';

	if (memcmp(p, q, LEN)) {
		fprintf(temp, "\tmemcmp fails - should have succeeded.\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
/* Clean up any files created by test before call to anyfail.	*/

	anyfail();		/* THIS CALL DOES NOT RETURN - EXITS!!  */
	tst_exit();
}
Exemplo n.º 15
0
/*--------------------------------------------------------------*/
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;
}
Exemplo n.º 16
0
/*--------------------------------------------------------------------*/
int main(int argc, char **argv)
{
/***** BEGINNING OF MAIN. *****/
	int core;
	int pid, npid;
	int nsig, exno, nexno, status;
	/*SIGIOT is 6, but since linux doesn't have SIGEMT, just using
	   SIGIOT for place filling */
	int signum[15];
	int j;
	int ret_val = 0;
#ifdef UCLINUX
	const char *msg;
#endif
	signum[1] = SIGHUP;
	signum[2] = SIGINT;
	signum[3] = SIGQUIT;
	signum[4] = SIGILL;
	signum[5] = SIGTRAP;
	signum[6] = SIGABRT;
	signum[7] = SIGIOT;
	signum[8] = SIGFPE;
	signum[9] = SIGKILL;
	signum[10] = SIGBUS;
	signum[11] = SIGSEGV;
	signum[12] = SIGSYS;
	signum[13] = SIGPIPE;
	signum[14] = SIGALRM;

#ifdef UCLINUX
	if ((msg = parse_opts(argc, argv, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	maybe_run_child(&do_child, "dd", &temp, &sig);
#endif

	setup();
	// tempdir();           /* move to new directory */
	blenter();

	exno = 1;
	unlink("core");

	for (j = 1; j < sizeof(signum) / sizeof(*signum); j++) {
		sig = signum[j];
		if (sig != SIGKILL)
#ifndef BCS
			if (sig != SIGSTOP)
#endif
				if (sigset(sig, SIG_DFL) == SIG_ERR) {
					fprintf(temp, "\tsigset(%d,,) fails\n",
						sig);
					local_flag = FAILED;
					fail_exit();
				}
		fflush(temp);
		pid = FORK_OR_VFORK();

		if (pid < 0) {
			forkfail();
		}

		/*
		 * Child process sleeps for up to 3 minutes giving the
		 * parent process a chance to kill it.
		 */
		if (pid == 0) {
#ifdef UCLINUX
			if (self_exec(argv[0], "dd", temp, sig) < 0) {
				tst_resm(TBROK, "self_exec FAILED - "
					 "terminating test.");
				tst_exit();
				tst_exit();
			}
#else
			do_child();
#endif
		}

		/*
		 * Parent process sends signal to child.
		 */

		//fprintf(temp, "Testing signal %d\n", sig); 12/12/02
		kill(pid, sig);
		npid = wait(&status);

		if (npid != pid) {
			fprintf(temp, "wait error: unexpected pid returned\n");
			ret_val = 1;
		}
		/* 12/20/02.
		   nsig = status & 0177;
		   core = status & 0200;
		   nexno = (status & 0xff00) >> 8;
		 */
		/*****  LTP Port        *****/
		nsig = WTERMSIG(status);
#ifdef WCOREDUMP
		core = WCOREDUMP(status);
#endif
		nexno = WIFEXITED(status);
		/*****  **      **      *****/

		//printf("nsig=%x, core=%x, status=%x\n", nsig,core, status); 12/12/2002

		/* to check if the core dump bit has been set, bit # 7 */
	/*****	LTP Port	*****/
		/*  12/12/02: [email protected]
		 *  SIGILL when is not caught or not ignored it causes
		 *  a core dump and program termination.  So moved the condition to
		 *  else part of the program.
		 *  SIGQUIT like SIGABRT normally causes a program to quit and
		 *  and dumps core.  So moved the condition to else part of the
		 *  program.
		 */
	/*****	**	**	*****/
		if (core) {
			if ((sig == 1) || (sig == 2)
			    /*|| (sig == 3) || */
			    /*(sig == 4) */
			    || (sig == 9) ||
			    (sig == 13) || (sig == 14) || (sig == 15)) {
				fprintf(temp,
					"signal error: core dump bit set for exception number %d\n",
					sig);
				ret_val = 1;
			}
		} else {
			if ((sig == 3) || (sig == 4) || (sig == 5) || (sig == 6)
			    || (sig == 7) || (sig == 8) || (sig == 10)
			    || (sig == 11) || (sig == 12)) {
				fprintf(temp,
					"signal error: core dump bit not set for exception number %d\n",
					sig);
				ret_val = 1;
			}
		}

		/* nsig is the signal number returned by wait */

		if (nsig != sig) {
			fprintf(temp,
				"wait error: unexpected signal %d returned, expected %d\n",
				nsig, sig);
			ret_val = 1;
		}

		/* nexno is the exit number returned by wait  */

		if (nexno != 0) {
			fprintf(temp,
				"signal error: unexpected exit number %d returned, expected 0\n",
				nexno);
			ret_val = 1;
		}
	}
	unlink("core");
	fflush(temp);
	if (ret_val)
		local_flag = FAILED;
	unlink("core");
	tst_rmdir();
/*--------------------------------------------------------------------*/
	anyfail();
	tst_exit();
}
Exemplo n.º 17
0
int main(int argc, char **argv) {
       char *progname;
       int status;
       int count = 0;
       int i, c;
       char *fname = "test.mmap-corruption";
       char *mem;
       unsigned long alarmtime = 0;
       struct sigaction sa;
       void finish(int sig);

       progname = *argv;
       while ((c = getopt(argc, argv, ":h:m:s:")) != -1) {
                switch (c) {
                case 'h':
                         alarmtime += atoi(optarg) * 60 * 60;
                         break;
                case 'm':
                         alarmtime += atoi(optarg) * 60;
                         break;
                case 's':
                         alarmtime += atoi(optarg);
                         break;
                default:
                        (void)fprintf(stderr, "usage: %s %s\n", progname,
                                usage);
                        anyfail();
                }
       }

        /*
         *  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");
                exit(1);
        }

        if (sigaction(SIGINT, &sa, 0) == -1) {
                perror("sigaction error SIGINT");
                exit(1);
        }
        if (alarmtime) {
                if (sigaction(SIGALRM, &sa, 0) == -1) {
                        perror("sigaction error");
                        exit(1);
                }
                (void)alarm(alarmtime);
                printf("mmap-corruption will run for=> %ld, seconds\n",alarmtime);
        } else { //Run for 5 secs only
                if (sigaction(SIGALRM, &sa, 0) == -1) {
                        perror("sigaction error");
                        exit(1);
                }
                (void)alarm(5);
                printf("mmap-corruption will run for=> 5, seconds\n");
        }
        /* If we get a SIGQUIT or SIGTERM, clean up and exit immediately. */
        sa.sa_handler = finish;
        if (sigaction(SIGQUIT, &sa, 0) == -1) {
                perror("sigaction error SIGQUIT");
                exit(1);
        }
        if (sigaction(SIGTERM, &sa, 0) == -1) {
                perror("sigaction error SIGTERM");
                exit(1);
        }

       tst_tmpdir();
       while (1) {
             unlink(fname);
             int fd = open(fname, O_CREAT | O_EXCL | O_RDWR, 0600);
             status = ftruncate(fd, kMemSize);

             mem = mmap(0, kMemSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
             // Fill the memory with 1s.
             memset(mem, 1, kMemSize);

             for (i = 0; i < kMemSize; i++) {
                  int byte_good = mem[i] != 0;
                  if (!byte_good && ((i % kPageSize) == 0)) {
                       //printf("%d ", i / kPageSize);
                       count++;
                  }
             }
             munmap(mem, kMemSize);
             close(fd);
             unlink(fname);
             if (count > 0) {
                 printf("Running %d bad page\n", count);
                 return 1;
             }
             count=0;
       }
     return 0;
}
Exemplo n.º 18
0
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);
}
Exemplo n.º 19
0
int main(int argc, char *argv[])
{
	char *buf;
	size_t pagesize = (size_t) sysconf(_SC_PAGE_SIZE);
	caddr_t mmapaddr;
	time_t t;
	int i, j;
	struct sigaction sa;
#ifdef LARGE_FILE
	off64_t startoffset;
	off64_t seekoff;
	off64_t mapoff;
#else /* LARGE_FILE */
	off_t startoffset;
	off_t seekoff;
	off_t mapoff;
#endif /* LARGE_FILE */

	if (argc < 2 || argc > 3) {
		(void)fprintf(stderr, "Usage: %s filename startoffset\n",
			      argv[0]);
		return 1;
	}
	filename = argv[1];

	if (argc >= 3) {
#ifdef LARGE_FILE
		startoffset = atoll(argv[2]);
#else /* LARGE_FILE */
		startoffset = atoi(argv[2]);
#endif /* LARGE_FILE */
	} else
		startoffset = pagesize;

	if (startoffset % pagesize != 0) {
		fprintf(stderr, "pagesize=%ld\n", (long)pagesize);
		fprintf(stderr, "startoffset must be a pagesize multiple\n");
		anyfail();	//LTP Port
	}
	(void)time(&t);
//      (void)printf("%s: Started %s", argv[0], ctime(&t));
	if ((buf = sbrk(6 * pagesize)) == (char *)-1) {
		ERROR("couldn't allocate buf");
		anyfail();	//LTP Port
	}
	if (sbrk(pagesize - ((ulong) sbrk(0) & (pagesize - 1))) == (char *)-1) {
		ERROR("couldn't round up brk");
		anyfail();	//LTP Port
	}
	if ((mmapaddr = (caddr_t) sbrk(0)) == (caddr_t) - 1) {
		ERROR("couldn't find top of brk");
		anyfail();	//LTP Port
	}
	sa.sa_handler = cleanup;
	sa.sa_flags = 0;
	if (sigemptyset(&sa.sa_mask)) {
		ERROR("sigemptyset failed");
		anyfail();	//LTP Port
	}
	CATCH_SIG(SIGINT);
	CATCH_SIG(SIGQUIT);
	CATCH_SIG(SIGTERM);
	tst_tmpdir();
#ifdef LARGE_FILE
	if ((rofd = open64(filename, O_RDONLY | O_CREAT, 0777)) == -1) {
#else /* LARGE_FILE */
	if ((rofd = open(filename, O_RDONLY | O_CREAT, 0777)) == -1) {
#endif /* LARGE_FILE */
		ERROR("read only open failed");
		anyfail();	//LTP Port
	}
#ifdef LARGE_FILE
	if ((rwfd = open64(filename, O_RDWR)) == -1) {
#else /* LARGE_FILE */
	if ((rwfd = open(filename, O_RDWR)) == -1) {
#endif /* LARGE_FILE */
		(void)close(rofd);
		(void)unlink(filename);
		ERROR("read/write open failed");
		anyfail();	//LTP Port
	}
#ifdef LARGE_FILE
	seekoff = startoffset + (off64_t) 64 *(off64_t) 6 *(off64_t) pagesize;
	if (lseek64(rwfd, seekoff, SEEK_SET) != seekoff) {
#else /* LARGE_FILE */
	seekoff = startoffset + (off_t) 64 *(off_t) 6 *(off_t) pagesize;
	if (lseek(rwfd, seekoff, SEEK_SET) != seekoff) {
#endif /* LARGE_FILE */
		CLEANERROR("first lseek failed");
		anyfail();	//LTP Port
	}
	i = 0;
	while (i < pagesize && write(rwfd, "b", 1) == 1)
		i++;
	if (i != pagesize) {
		CLEANERROR("write to extend file failed");
		anyfail();	//LTP Port
	}
	/* The file is now really big, and empty.
	 * Assuming disk blocks are 8k, and logical pages are 4k, there are
	 * two maps per page.  In order to test mapping at the beginning and
	 * ends of the block, mapping the whole block, or none of the block
	 * with different mappings on preceding and following blocks, each
	 * 3 blocks with 6 pages can be thought of as a binary number from 0 to
	 * 64 with a bit set for mapped or cleared for unmapped.  This number
	 * is represented by i.  The value j is used to look at the bits of i
	 * and decided to map the page or not.
	 * NOTE: None of the above assumptions are critical.
	 */
	for (i = 0; i < 64; i++) {
		for (j = 0; j < 6; j++) {
			if (i & (1 << j)) {
#ifdef LARGE_FILE
				mapoff = startoffset +
				    (off64_t) pagesize *(off64_t) (6 + i + j);
				if (mmap64(mmapaddr + pagesize * (6 * i + j),
					   pagesize, PROT_READ,
					   MAP_FILE | MAP_PRIVATE | MAP_FIXED,
					   rofd, mapoff)
				    == (caddr_t) - 1) {
#else /* LARGE_FILE */
				mapoff = startoffset +
				    (off_t) pagesize *(off_t) (6 + i + j);
				if (mmap(mmapaddr + pagesize * (6 * i + j),
					 pagesize, PROT_READ,
					 MAP_FILE | MAP_PRIVATE | MAP_FIXED,
					 rofd, mapoff)
				    == (caddr_t) - 1) {
#endif /* LARGE_FILE */
					CLEANERROR("mmap failed");
					anyfail();	//LTP Port
				}
			}
		}
	}
	/* done mapping */
	for (i = 0; i < 6 * pagesize; i++)
		buf[i] = 'a';
	/* write out 6 pages of stuff into each of the 64 six page sections */
#ifdef LARGE_FILE
	if (lseek64(rwfd, startoffset, SEEK_SET) != startoffset) {
#else /* LARGE_FILE */
	if (lseek(rwfd, startoffset, SEEK_SET) != startoffset) {
#endif /* LARGE_FILE */
		CLEANERROR("second lseek failed");
		anyfail();	//LTP Port
	}
	for (i = 0; i < 64; i++) {
		if (write(rwfd, buf, 6 * pagesize) != 6 * pagesize) {
			CLEANERROR("write failed");
			anyfail();	//LTP Port
		}
	}
	/* Just finished scribbling all over interwoven mmapped and unmapped
	 * regions.
	 */
	for (i = 0; i < 64; i++) {
		for (j = 0; j < 6; j++) {
			/* if mmaped && not updated */
			if ((i & (1 << j))
			    && *(mmapaddr + pagesize * (6 * i + j)) != 'a') {
				CLEANERROR("'a' missing from mmap");
				(void)fprintf(stderr, "i=%d\nj=%d\n"
					      "val=0x%x\n", i, j,
					      (int)(*
						    (mmapaddr +
						     pagesize * (6 * i + j))));
				anyfail();	//LTP Port
			}
		}
	}
	/* Just checked to see that each mmapped page at least had an 'a' at
	 * the beginning.
	 */
	CLEAN;
	(void)time(&t);
//      (void)printf("%s: Finished %s", argv[0], ctime(&t)); LTP Port
	(local_flag == FAILED) ? tst_resm(TFAIL, "Test failed\n") : tst_resm(TPASS, "Test passed\n");	//LTP Port
	tst_rmdir();
	tst_exit();		//LTP Port

	tst_exit();
}

/*****	LTP Port	*****/
int anyfail(void)
{
	tst_brkm(TFAIL, tst_rmdir, "Test failed\n");
}
Exemplo n.º 20
0
int main()
{
	char root[16];		//as pids can get much longer
	int gen_ret_val, ch_ret_val, level;
	int ret_val;
	int generate(), check();
	char path_list_string[PATH_STRING_LENGTH + 1];
	int status;
	int len;
	int term();

	slash[0] = '/';
	slash[1] = '\0';

	strcpy(path_string, "inode");
	sprintf(root, "A%d", getpid());
	strcat(path_string, root);

	strcpy(rm_string, "rm -rf ");
	strcat(rm_string, path_string);

	setup();

	if (signal(SIGTERM, (void (*)())term) == SIG_ERR) {
		fprintf(temp, "\tSIGTERM signal set failed!, errno=%d\n",
			errno);
		fail_exit();
	}

	blenter();

	/********************************/
	/*                              */
	/*  make the root directory for */
	/*  the tree                    */
	/*                              */
	/********************************/

	ret_val = mkdir(path_string, DIRECTORY_MODE);

	if (ret_val == -1) {
		perror("mkdir error");
		fprintf(temp, "\tcreating directory '%s'\n", path_string);
		fprintf(temp, "\t\n%s Impossible to create directory %s\n",
			root, path_string);
		fail_exit();
	}
#ifdef PRINT
	printf("\n%s\n", path_string);
#endif

	/****************************************/
	/*                                      */
	/*  create the "path_list" file, in     */
	/*  which the list of generated paths   */
	/*  will be stored so that they later   */
	/*  may be checked                      */
	/*                                      */
	/****************************************/

	strcpy(path_list_string, path_string);
	strcat(path_list_string, slash);
	strcat(path_list_string, "path_list");
	list_id = creat(path_list_string, FILE_MODE);
	if (list_id == -1) {
		fprintf(temp,
			"\t\n%s The path_list file cannot be created, errno=%d \n",
			root, errno);
		fail_exit();
	}

	/****************************************/
	/*                                      */
	/*   and store its name in path_list    */
	/*                                      */
	/****************************************/

	strcpy(write_string, path_string);
	len = strlen(write_string);
	write_string[len++] = 'D';
	write_string[len] = '\0';
	escrivez(write_string);

	/****************************************/
	/*                                      */
	/*   generate the directory-file tree   */
	/*                                      */
	/****************************************/

	level = 0;

#ifdef PRINT
	printf("\n\t%s\n\n", "GENERATING:");
#endif

	gen_ret_val = generate(path_string, level);

	if (gen_ret_val) {
		fprintf(temp,
			"Failure occured in generate routine, return value %d\n",
			gen_ret_val);
		local_flag = FAILED;
	}

	blexit();
	blenter();

	close(list_id);
	list_id = open(path_list_string, READ);
	if (list_id == -1) {
		fprintf(temp,
			"\t\n%s The path_list file cannot be opened for reading, errno=%d\n",
			root, errno);
		fail_exit();
	}
	list_stream = fdopen(list_id, "r");

	/****************************************/
	/*                                      */
	/*   check the directory-file tree      */
	/*      for correctness                 */
	/*                                      */
	/****************************************/

#ifdef PRINT
	printf("\n\t%s\n\n", "CHECKING:");
#endif

	ch_ret_val = check();

	if (ch_ret_val) {
		fprintf(temp,
			"Failure occured in check routine, return value %d\n",
			ch_ret_val);
		local_flag = FAILED;
	}

	status = fclose(list_stream);
	if (status != 0) {
		fprintf(temp,
			"Failed to close list_stream: ret=%d errno=%d (%s)\n",
			status, errno, strerror(errno));
		local_flag = FAILED;
	}

	blexit();

	/*
	 * Now fork and exec a system call to remove the directory.
	 */

#ifdef DEBUG
	fprintf(temp, "\nClean up:\trm string = %s\n", rm_string);
#endif
	fflush(stdout);
	fflush(temp);

	status = system(rm_string);

	if (status) {
		fprintf(temp, "Caution-``%s'' may have failed\n", rm_string);
		fprintf(temp, "rm command exit status = %d\n", status);
	}

	/****************************************/
	/*                                      */
	/*         .....and exit main           */
	/*                                      */
	/****************************************/

	anyfail();
	/***** NOT REACHED ******/
	tst_exit();
}
Exemplo n.º 21
0
/*--------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	char *p, *q;

	setup();		/* temp file is now open        */
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[100];

	fill(p);
	q = &buf[800];
	memcpy(q, p, LEN);

	if (checkit(q)) {
		fprintf(temp, "\tcopy failed - missed data\n");
		local_flag = FAILED;
	}

	if (p[-1] || p[LEN]) {
		fprintf(temp, "\tcopy failed - 'to' bounds\n");
		local_flag = FAILED;
	}

	if (q[-1] || q[LEN]) {
		fprintf(temp, "\tcopy failed - 'from' bounds\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[800];

	fill(p);
	q = &buf[100];
	memcpy(q, p, LEN);

	if (checkit(q)) {
		fprintf(temp, "\tcopy failed - missed data\n");
		local_flag = FAILED;
	}

	if (p[-1] || p[LEN]) {
		fprintf(temp, "\tcopy failed - 'to' bounds\n");
		local_flag = FAILED;
	}

	if (q[-1] || q[LEN]) {
		fprintf(temp, "\tcopy failed - 'from' bounds\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[800];

	fill(p);
	q = &buf[850];
	memcpy(q, p, LEN);

	if (checkit(q)) {
		fprintf(temp, "\tcopy failed - missed data\n");
		local_flag = FAILED;
	}

	if (p[-1]) {
		fprintf(temp, "\tcopy failed - 'to' bounds\n");
		local_flag = FAILED;
	}

	if (q[LEN]) {
		fprintf(temp, "\tcopy failed - 'from' bounds\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
	blenter();

	clearit();

	p = &buf[850];

	fill(p);
	q = &buf[800];
	memcpy(q, p, LEN);

	if (checkit(q)) {
		fprintf(temp, "\tcopy failed - missed data\n");
		local_flag = FAILED;
	}

	if (p[LEN]) {
		fprintf(temp, "\tcopy failed - 'to' bounds\n");
		local_flag = FAILED;
	}

	if (q[-1]) {
		fprintf(temp, "\tcopy failed - 'from' bounds\n");
		local_flag = FAILED;
	}

	blexit();
/*--------------------------------------------------------------*/
/* Clean up any files created by test before call to anyfail.	*/

	anyfail();		/* THIS CALL DOES NOT RETURN - EXITS!!  */
	tst_exit();
}
Exemplo n.º 22
0
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);
}