Exemple #1
0
void setup()
{
	TEST_PAUSE;
	tst_tmpdir();
}
Exemple #2
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");
}
Exemple #3
0
/*
 * setup(void) - performs all ONE TIME setup for this test.
 * 	Exit the test program on receipt of unexpected signals.
 *	Create a temporary directory used to hold test directories created
 *	and change the directory to it.
 *	Verify that pid of process executing the test is root.
 *	Create a test directory on temporary directory and set the ownership
 *	of test directory to nobody user.
 *	Set the effective uid/gid of the process to that of nobody user.
 */
void
setup()
{

	/* Capture unexpected signals */
	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	/* Check that the test process id is super/root  */
	if (geteuid() != 0) {
		tst_brkm(TBROK, NULL, "Must be super/root for this test!"); 
		tst_exit();
	}

	/* Pause if that option was specified */
	TEST_PAUSE;

	/* Make a temp dir and cd to it */
	tst_tmpdir();

        /* fix permissions on the tmpdir */
        if (chmod(".", 0711) != 0) {
                tst_brkm(TBROK, cleanup, "chmod() failed");
        }

	/* Save the real user id of the test process */
        save_myuid = getuid();

	/* Save the process id of the test process */
        mypid = getpid();

	/* Get the node name to be created in the test */
	sprintf(node_name, TNODE, mypid);

	/* Get the uid/gid of guest user - nobody */
	if ((user1 = getpwnam(LTPUSER)) == NULL) {
		tst_brkm(TBROK, cleanup, "%s not in /etc/passwd",
			 LTPUSER);
	}
	user1_uid = user1->pw_uid;
	group1_gid = user1->pw_gid;

	/* Get effective group id of the test process */
        group2_gid = getegid();

	/*
	 * Create a test directory under temporary directory with the
	 * specified mode permissions, with uid/gid set to that of guest
	 * user and the test process.
	 */
	if (mkdir(DIR_TEMP, MODE_RWX) < 0) {
		tst_brkm(TBROK, cleanup, "mkdir(2) of %s failed", DIR_TEMP);
	}
	if (chown(DIR_TEMP, user1_uid, group2_gid) < 0) {
		tst_brkm(TBROK, cleanup, "chown(2) of %s failed", DIR_TEMP);
	}

	/*
	 * Verify that test directory created with expected permission modes
	 * and ownerships.
	 */
	if (stat(DIR_TEMP, &buf) < 0) {
		tst_brkm(TBROK, cleanup, "stat(2) of %s failed", DIR_TEMP);
	}

	/* Verify modes of test directory */
	if (buf.st_mode & S_ISGID) {
		tst_brkm(TBROK, cleanup,
			 "%s: Incorrect modes, setgid bit set", DIR_TEMP);
	}

	/* Verify group ID */
	if (buf.st_gid != group2_gid) {
		tst_brkm(TBROK, cleanup, "%s: Incorrect group", DIR_TEMP);
	}
	
   	/* 
	 * Set the effective group id and user id of the test process 
	 * to that of guest user.
	 */
	if (setgid(group1_gid) < 0) {
		tst_brkm(TBROK, cleanup,
			 "Unable to set process gid to that of ltp user");
	}
	if (setreuid(-1, user1_uid) < 0) {
		tst_brkm(TBROK, cleanup,
			 "Unable to set process uid to that of ltp user");
	}

	/* Save the real group ID of the current process */
	mygid = getgid();

	/* Change directory to DIR_TEMP */
	if (chdir(DIR_TEMP) < 0) {
		tst_brkm(TBROK, cleanup,
			 "Unable to change to %s directory", DIR_TEMP);
	}
}
Exemple #4
0
/* setup() - performs all ONE TIME setup for this test */
void setup()
{
	char nobody_uid[] = "nobody";
	struct passwd *ltpuser;

	tst_sig(FORK, DEF_HANDLER, cleanup);

	/* Check whether we are root */
	if (geteuid() != 0) {
		if (Type != NULL) {
			free(Type);
		}
		tst_brkm(TBROK, NULL, "Test must be run as root");
	}

	/* Switch to nobody user */
	if ((ltpuser = getpwnam(nobody_uid)) == NULL) {
		if (Type != NULL) {
			free(Type);
		}
		tst_brkm(TBROK, NULL, "\"nobody\" user not present");
	}
	if (seteuid(ltpuser->pw_uid) == -1) {
		if (Type != NULL) {
			free(Type);
		}
		tst_brkm(TBROK, NULL, "setuid failed to set the "
			 "effective uid to %d", ltpuser->pw_uid);
	}
	/* make a temp directory */
	tst_tmpdir();

	(void)sprintf(mntpoint, "mnt_%d", getpid());

	if (mkdir(mntpoint, DIR_MODE)) {
		tst_brkm(TBROK, cleanup1, "mkdir(%s, %#o) failed; errno = %d:"
			 " %s", mntpoint, DIR_MODE, errno, strerror(errno));
	}

	if (seteuid(0) == -1) {
		tst_brkm(TBROK, cleanup1, "setuid failed to set the effective"
			 " uid to %d", ltpuser->pw_uid);
	}
	/* set up expected error numbers */
	TEST_EXP_ENOS(exp_enos);

	if (access(device,F_OK)) {
		tst_brkm(TBROK, cleanup1,
			"Device '%s' does not exist", device);
	}

	TEST(mount(device, mntpoint, Type, 0, NULL));

	if (TEST_RETURN != 0) {
		tst_brkm(TBROK, cleanup1, "mount(2) failed to mount device %s "
			 "errno = %d : %s", device, TEST_ERRNO,
			 strerror(TEST_ERRNO));
	}

	TEST_PAUSE;

	return;
}
Exemple #5
0
static void setup(void)
{
	tst_tmpdir();
}
Exemple #6
0
int main(int ac, char **av)
{
	int lc;
	char *msg;
	int Hflag = 0;
	int sflag = 0;
	int huge_pagesize = 0;

	option_t options[] = {
		{"H:", &Hflag, &Hopt},
		{"s:", &sflag, &nr_opt},
		{NULL, NULL, NULL}
	};

	msg = parse_opts(ac, av, options, &help);
	if (msg)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s,"
			 " use -help", msg);

	if (!Hflag) {
		tst_tmpdir();
		Hopt = tst_get_tmpdir();
	}
	if (sflag)
		hugepages = SAFE_STRTOL(NULL, nr_opt, 0, LONG_MAX);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* Creat a temporary file used for huge mapping */
		fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666);
		if (fildes < 0)
			tst_brkm(TFAIL | TERRNO, cleanup, "open %s failed",
				 TEMPFILE);

		tst_count = 0;

		/* Note the number of free huge pages BEFORE testing */
		freepages = read_meminfo("HugePages_Free:");
		beforetest = freepages;

		/* Note the size of huge page size BEFORE testing */
		huge_pagesize = read_meminfo("Hugepagesize:");
		tst_resm(TINFO, "Size of huge pages is %d KB", huge_pagesize);

#if __WORDSIZE == 32
		tst_resm(TINFO, "Total amount of free huge pages is %d",
			 freepages);
		tst_resm(TINFO, "Max number allowed for 1 mmap file in"
			 " 32-bits is 128");
		if (freepages > 128)
			freepages = 128;
#endif
		mapsize = (long long)freepages *huge_pagesize * 1024;
		addr = mmap(NULL, mapsize, PROT_READ | PROT_WRITE,
			    MAP_SHARED, fildes, 0);
		sleep(2);
		if (addr == MAP_FAILED) {
			tst_resm(TFAIL | TERRNO, "mmap() Failed on %s",
				 TEMPFILE);
			close(fildes);
			continue;
		} else {
			tst_resm(TPASS,
				 "Succeeded mapping file using %ld pages",
				 freepages);
			/* force to allocate page and change HugePages_Free */
			*(int *)addr = 0;
		}

		/*
		 * Make sure the number of free huge pages
		 * AFTER testing decreased
		 */
		aftertest = read_meminfo("HugePages_Free:");
		hugepagesmapped = beforetest - aftertest;
		if (hugepagesmapped < 1)
			tst_resm(TWARN, "Number of HUGEPAGES_FREE stayed the"
				 " same. Okay if multiple copies running due"
				 " to test collision.");

		/* Clean up things in case we are looping */
		/* Unmap the mapped memory */
		if (munmap(addr, mapsize) != 0)
			tst_brkm(TFAIL | TERRNO, NULL, "munmap failed");

		close(fildes);
	}

	cleanup();
	tst_exit();
}
Exemple #7
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);
	float 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 = atof(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':
#if defined(__linux__)
#ifdef LARGE_FILE
			filesize = atoll(optarg);
#else /* LARGE_FILE */
			filesize = atoi(optarg);
#endif /* LARGE_FILE */
#elif defined(__FreeBSD__)
#else
			filesize = atol(optarg);
#endif
			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':
#if defined(__linux__)
#ifdef LARGE_FILE
			sparseoffset = atoll(optarg);
#else /* LARGE_FILE */
			sparseoffset = atoi(optarg);
#endif /* LARGE_FILE */
#elif defined(__FreeBSD__)
#else
			sparseoffset = atol(optarg);
#endif
			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 %f 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], SIGUSR1);
	(void)kill(wr_pid, SIGUSR1);

	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();
	tst_exit();
}

/*
 *  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;
	caddr_t paddr;
	int pagesize = sysconf(_SC_PAGE_SIZE);
	unsigned randpage;
	unsigned int seed;
	unsigned loopcnt;
	unsigned nloops;
	unsigned mappages;
	unsigned mapflags;
	unsigned i;
	struct sigaction sa_mapper;

	mapflags = MAP_SHARED;

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

	sa_mapper.sa_handler = clean_mapper;
	sa_mapper.sa_flags = 0;
	if (sigemptyset(&sa_mapper.sa_mask)) {
		perror("sigempty error");
		anyfail();
	}

	if (sigaction(SIGUSR1, &sa_mapper, 0) == -1) {
		perror("sigaction error SIGUSR1");
		anyfail();
	}
#ifdef LARGE_FILE
	if ((fd_mapper = open64(file, O_RDWR)) == -1) {
#else /* LARGE_FILE */
	if ((fd_mapper = open(file, O_RDWR)) == -1) {
#endif /* LARGE_FILE */
		perror("open error");
		anyfail();
	}
#ifdef LARGE_FILE
	if (fstat64(fd_mapper, &statbuf) == -1) {
#else /* LARGE_FILE */
	if (fstat(fd_mapper, &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_mapper = (size_t) (statbuf.st_size - sparseoffset);
	mappages = roundup(mapsize_mapper, pagesize) / pagesize;
	offset = sparseoffset;
	if (do_offset) {
		int pageoffset = lrand48() % mappages;
		int byteoffset = pageoffset * pagesize;
		offset += byteoffset;
		mapsize_mapper -= byteoffset;
		mappages -= pageoffset;
	}
#ifdef LARGE_FILE
	if ((maddr_mapper = mmap64(0, mapsize_mapper, PROT_READ | PROT_WRITE,
				   mapflags, fd_mapper,
				   offset)) == (caddr_t) - 1) {
#else /* LARGE_FILE */
	if ((maddr_mapper = mmap(0, mapsize_mapper, PROT_READ | PROT_WRITE,
				 mapflags, fd_mapper,
				 offset)) == (caddr_t) - 1) {
#endif /* LARGE_FILE */
		perror("mmap error");
		anyfail();
	}

	(void)close(fd_mapper);

	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_mapper,
			     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_mapper, offset / pagesize, nloops);
#endif /* LARGE_FILE */
	}

	/*
	 *  Now loop read/writing random pages.
	 */
	for (loopcnt = 0; loopcnt < nloops; loopcnt++) {
		randpage = lrand48() % mappages;
		paddr = maddr_mapper + (randpage * pagesize);	/* page address */

		if (randpage < mappages - 1 || !(mapsize_mapper % pagesize))
			validsize = pagesize;
		else
			validsize = mapsize_mapper % 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_mapper + (randpage * pagesize);	/* page address */
		if (msync(paddr, (mappages - randpage) * pagesize,
			  MS_SYNC) == -1) {
			perror("msync error");
			anyfail();
		}
	}
	if (munmap(maddr_mapper, mapsize_mapper) == -1) {
		perror("munmap failed");
		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 */
	struct sigaction sa_writer;

	sa_writer.sa_handler = clean_writer;
	sa_writer.sa_flags = 0;
	if (sigemptyset(&sa_writer.sa_mask)) {
		perror("sigempty error");
		anyfail();
	}

	if (sigaction(SIGUSR1, &sa_writer, 0) == -1) {
		perror("sigaction error SIGUSR1");
		anyfail();
	}
#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_writer = open64(file, O_RDWR)) == -1) {
#else /* LARGE_FILE */
	if ((fd_writer = open(file, O_RDWR)) == -1) {
#endif /* LARGE_FILE */
		perror("open error");
		anyfail();
	}
#ifdef LARGE_FILE
	if ((off = lseek64(fd_writer, 0, SEEK_END)) == -1) {
#else /* LARGE_FILE */
	if ((off = lseek(fd_writer, 0, SEEK_END)) == -1) {
#endif /* LARGE_FILE */
		perror("lseek error");
		anyfail();
	}

	for (;;) {
#ifdef LARGE_FILE
		if (fstat64(fd_writer, &statbuf) == -1) {
#else /* LARGE_FILE */
		if (fstat(fd_writer, &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_writer, 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_writer) == -1) {
				perror("fsync error");
				anyfail();
			}
		}
	}
	close(fd_writer);
}

/*
 *  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");
			close(fd);
			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);
				close(fd);
				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 */
				close(fd);
				return 0;
			}
		}
	}

	close(fd);
	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);
}

void clean_mapper(int sig)
{
	if (fd_mapper)
		close(fd_mapper);
	munmap(maddr_mapper, mapsize_mapper);
	exit(0);
}

void clean_writer(int sig)
{
	if (fd_writer)
		close(fd_writer);
	exit(0);
}

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;
}
int main()
{
	int wjh_ret = -1, wjh_f = -1, count = 0;
	//used for the 2nd test
	//make str > trunc_size characters long
	char str[] = "THIS IS JAYS TEST FILE DATA";
	int trunc_size = 4;
	int flag = O_RDONLY;

#ifdef DEBUG
	printf("Starting test, possible errnos are; EBADF(%d) EINVAL(%d)\n",
	       EBADF, EINVAL);
	printf("\t\tENOENT(%d) EACCES(%d) EPERM(%d)\n\n", ENOENT, EACCES,
	       EPERM);
#endif

	tst_tmpdir();

//TEST1: ftruncate on a socket is not valid, should fail w/ EINVAL

#ifdef DEBUG
	printf("Starting test1\n");
#endif
	wjh_f = socket(PF_INET, SOCK_STREAM, 0);
	wjh_ret = ftruncate(wjh_f, 1);
#ifdef DEBUG
	printf("DEBUG: fd: %d ret: %d errno(%d) %s\n",
	       wjh_f, wjh_ret, errno, strerror(errno));
#endif
	if (wjh_ret == -1 && errno == EINVAL) {
		tst_resm(TPASS, "Test Passed");
	} else {
		tst_resm(TFAIL,
			 "ftruncate(socket)=%i (wanted -1), errno=%i (wanted EINVAL %i)",
			 wjh_ret, errno, EINVAL);
	}
	close(wjh_f);
	errno = 0;
	wjh_ret = 0;
	wjh_f = -1;

//TEST2: ftruncate on fd not open for writing should be EINVAL

#ifdef DEBUG
	printf("\nStarting test2\n");
#endif
	//create a file and fill it so we can truncate it in ReadOnly mode
	//delete it first, ignore if it doesn't exist
	unlink(TESTFILE);
	errno = 0;
	wjh_f = open(TESTFILE, O_RDWR | O_CREAT, 0644);
	if (wjh_f == -1) {
		tst_resm(TFAIL | TERRNO, "open(%s) failed", TESTFILE);
		tst_rmdir();
		tst_exit();
	}
	while (count < strlen(str)) {
		if ((count += write(wjh_f, str, strlen(str))) == -1) {
			tst_resm(TFAIL | TERRNO, "write() failed");
			close(wjh_f);
			tst_rmdir();
			tst_exit();
		}
	}
	close(wjh_f);
	errno = 0;

//Uncomment below if you want it to succeed, O_RDWR => success
// flag = O_RDWR;
#ifdef DEBUG
	if (flag == O_RDWR) {
		printf("\tLooks like it should succeed!\n");
	}
#endif

	wjh_f = open(TESTFILE, flag);
	if (wjh_f == -1) {
		tst_resm(TFAIL | TERRNO, "open(%s) failed", TESTFILE);
		tst_rmdir();
		tst_exit();
	}
	wjh_ret = ftruncate(wjh_f, trunc_size);
#ifdef DEBUG
	printf("DEBUG: fd: %d ret: %d @ errno(%d) %s\n",
	       wjh_f, wjh_ret, errno, strerror(errno));
#endif
	if ((flag == O_RDONLY) && (wjh_ret == -1) && (errno == EINVAL)) {
		tst_resm(TPASS, "Test Passed");
	} else if ((flag == O_RDWR)) {
		if (wjh_ret == 0) {
			tst_resm(TPASS, "Test Succeeded!");
		} else {
			tst_resm(TFAIL | TERRNO,
				 "ftruncate(%s) should have succeeded, but didn't! ret="
				 "%d (wanted 0)", TESTFILE, wjh_ret);
		}
	} else			//flag was O_RDONLY but return codes wrong
	{
		tst_resm(TFAIL,
			 "ftruncate(rd_only_fd)=%i (wanted -1), errno=%i (wanted %i EINVAL)",
			 wjh_ret, errno, EINVAL);
	}
	close(wjh_f);
	errno = 0;
	wjh_ret = 0;
	wjh_f = -1;

//TEST3: invalid socket descriptor should fail w/ EBADF

#ifdef DEBUG
	printf("\nStarting test3\n");
#endif
	wjh_f = -999999;	//should be a bad file descriptor
	wjh_ret = ftruncate(wjh_f, trunc_size);
#ifdef DEBUG
	printf("DEBUG: fd: %d ret: %d @ errno(%d) %s\n",
	       wjh_f, wjh_ret, errno, strerror(errno));
#endif
	if (wjh_ret != -1 || errno != EBADF) {
		tst_resm(TFAIL | TERRNO,
			 "ftruncate(invalid_fd)=%d (wanted -1 and EBADF)",
			 wjh_ret);
	} else {
		tst_resm(TPASS, "Test Passed");
	}

	tst_rmdir();

//Done Testing
	tst_exit();
}
Exemple #9
0
int main(int argc, char **argv)
{
	int c, i;
	int file_size;
	int num_iter;
	double exec_time;
	int fd;
	void *status;
	pthread_t thid[2];
	long chld_args[3];
	extern char *optarg;
	struct sigaction sigptr;
	int ret;

	/* set up the default values */
	file_size = 1024;
	num_iter = 1000;
	exec_time = 24;

	while ((c = getopt(argc, argv, "hvl:s:x:")) != -1) {
		switch (c) {
		case 'h':
			usage(argv[0]);
			break;
		case 'l':
			if ((num_iter = atoi(optarg)) == 0)
				OPT_MISSING(argv[0], optopt);
			else if (num_iter < 0)
				printf
				    ("WARNING: bad argument. Using default %d\n",
				     (num_iter = 1000));
			break;
		case 's':
			if ((file_size = atoi(optarg)) == 0)
				OPT_MISSING(argv[0], optopt);
			else if (file_size < 0)
				printf
				    ("WARNING: bad argument. Using default %d\n",
				     (file_size = 1024));
			break;
		case 'v':
			verbose_print = 1;
			break;
		case 'x':
			exec_time = atof(optarg);
			if (exec_time == 0)
				OPT_MISSING(argv[0], optopt);
			else if (exec_time < 0)
				printf
				    ("WARNING: bad argument. Using default %.0f\n",
				     (exec_time = 24));
			break;
		default:
			usage(argv[0]);
			break;
		}
	}

	/* We don't want other mmap calls to map into same area as is
	 * used for test (mmap_address). The test expects read to return
	 * test pattern or read must fail with SIGSEGV. Find an area
	 * that we can use, which is unlikely to be chosen for other
	 * mmap calls. */
	distant_area = mmap(0, DISTANT_MMAP_SIZE, PROT_WRITE | PROT_READ,
		MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
	if (distant_area == (void *)-1)
		tst_brkm(TBROK | TERRNO, NULL, "distant_area: mmap()");
	SAFE_MUNMAP(NULL, distant_area, (size_t)DISTANT_MMAP_SIZE);
	distant_area += DISTANT_MMAP_SIZE / 2;

	if (verbose_print)
		tst_resm(TINFO, "Input parameters are: File size:  %d; "
			 "Scheduled to run:  %lf hours; "
			 "Number of mmap/write/read:  %d",
			 file_size, exec_time, num_iter);

	alarm(exec_time * 3600);

	/* Do not mask SIGSEGV, as we are interested in handling it. */
	sigptr.sa_sigaction = sig_handler;
	sigfillset(&sigptr.sa_mask);
	sigdelset(&sigptr.sa_mask, SIGSEGV);
	sigptr.sa_flags = SA_SIGINFO | SA_NODEFER;

	for (i = 0; sig_info[i].signum != -1; i++) {
		if (sigaction(sig_info[i].signum, &sigptr, NULL) == -1) {
			perror("man(): sigaction()");
			fprintf(stderr,
				"could not set handler for %s, errno = %d\n",
				sig_info[i].signame, errno);
			exit(-1);
		}
	}

	tst_tmpdir();

	for (;;) {
		if ((fd = mkfile(file_size)) == -1)
			tst_brkm(TBROK, NULL,
				 "main(): mkfile(): Failed to create temp file");

		if (verbose_print)
			tst_resm(TINFO, "Tmp file created");

		chld_args[0] = fd;
		chld_args[1] = file_size;
		chld_args[2] = num_iter;

		if ((ret =
		     pthread_create(&thid[0], NULL, map_write_unmap,
				    chld_args)))
			tst_brkm(TBROK, NULL, "main(): pthread_create(): %s",
				 strerror(ret));

		tst_resm(TINFO, "created writing thread[%lu]", thid[0]);

		if ((ret = pthread_create(&thid[1], NULL, read_mem, chld_args)))
			tst_brkm(TBROK, NULL, "main(): pthread_create(): %s",
				 strerror(ret));

		tst_resm(TINFO, "created reading thread[%lu]", thid[1]);

		for (i = 0; i < 2; i++) {
			if ((ret = pthread_join(thid[i], &status)))
				tst_brkm(TBROK, NULL,
					 "main(): pthread_join(): %s",
					 strerror(ret));

			if (status)
				tst_brkm(TFAIL, NULL,
					 "thread [%lu] - process exited "
					 "with %ld", thid[i], (long)status);
		}

		close(fd);
	}

	tst_rmdir();

	exit(0);
}
Exemple #10
0
/*
 * setup() - performs all ONE TIME setup for this test.
 *
 * 	     Get system page size, allocate and initialize the string dummy.
 * 	     Initialize addr such that it is more than one page below the break
 * 	     address of the process, and initialize one page region from addr
 * 	     with char 'A'.
 * 	     Creat a temporary directory and a file under it.
 * 	     Write some known data into file and get the size of the file.
 */
void 
setup()
{
	struct stat stat_buf;
	char Path_name[PATH_MAX];		/* pathname of temporary file*/
	char write_buf[] = "hello world\n";

	/* capture signals */
	tst_sig(FORK, DEF_HANDLER, cleanup);

	/* Pause if that option was specified */
	TEST_PAUSE;

	/* make a temp directory and cd to it */
	tst_tmpdir();

	/* Get the path of temporary file to be created */
	if (getcwd(Path_name, sizeof(Path_name)) == NULL) {
		tst_brkm(TFAIL, cleanup,
			 "getcwd fails to get current working directory");
	}

	/* Creat a temporary file used for mapping */
	if ((fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666)) < 0) {
		tst_brkm(TFAIL, cleanup,
			 "open() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
	}

	/* Write some data into temporary file */
	if (write(fildes, write_buf, strlen(write_buf)) != strlen(write_buf)) {
		tst_brkm(TFAIL, cleanup, 
			 "write() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
	}
	
	/* Get the size of temporary file */
	if (stat(TEMPFILE, &stat_buf) < 0) {
		tst_brkm(TFAIL, cleanup,
			 "stat() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
	}
	file_sz = stat_buf.st_size;

	/* Get the system page size */
	if ((page_sz = getpagesize()) < 0) {
		tst_brkm(TFAIL, cleanup,
			 "getpagesize() fails to get system page size");
		tst_exit();
	}

	/* Allocate and initialize dummy string of system page size bytes */
	if ((dummy = (char *)calloc(page_sz, sizeof(char))) == NULL) {
		tst_brkm(TFAIL, cleanup, "calloc() failed to allocate space");
		tst_exit();
	}

	/*
	 * Initialize addr to align with the first page boundary above the
	 * break address of the process.
	 */
	addr = (void *) (((intptr_t)sbrk(0) + (page_sz - 1)) & ~(page_sz - 1));

	/* Increase the break address of the process by 2 page size bytes */
	if ((intptr_t)sbrk(2 * page_sz) == -1) {
		tst_brkm(TFAIL, cleanup, "sbrk(2 * page_sz) failed");
	}

	/* Initialize one page region from addr with 'A' */
	memset(addr, 'A', page_sz);

	/* Create the command which will be executed in the test */
	sprintf(Cmd_buffer, "grep XYZ %s/%s > /dev/null", Path_name, TEMPFILE);
}
Exemple #11
0
int main(void)
{
	int k, j, pid, child, status, count;
	char name[128];

	/*
	 * Default values for run conditions.
	 */
	iterations = 50;
	nchild = 5;

	if (signal(SIGTERM, term) == SIG_ERR) {
		tst_resm(TFAIL, "first signal failed");

	}

	/*
	 * Make a directory to do this in; ignore error if already exists.
	 */
	local_flag = PASSED;
	parent_pid = getpid();
	tst_tmpdir();

	if (!startdir[0]) {
		if (getcwd(startdir, MAXPATHLEN) == NULL) {
			tst_resm(TBROK, "getcwd failed");

		}
	}
	cwd = startdir;
	strcat(dirname, cwd);
	sprintf(tmpname, "/ftest02.%d", getpid());
	strcat(dirname, tmpname);
	strcat(homedir, cwd);
	sprintf(tmpname, "/ftest02h.%d", getpid());
	strcat(homedir, tmpname);

	mkdir(dirname, 0755);
	mkdir(homedir, 0755);
	if (chdir(dirname) < 0) {
		tst_resm(TBROK, "\tCan't chdir(%s), error %d.", dirname, errno);
		cleanup();

	}
	dirlen = strlen(dirname);
	if (chdir(homedir) < 0) {
		tst_resm(TBROK, "\tCan't chdir(%s), error %d.", homedir, errno);
		cleanup();

	}

	for (k = 0; k < nchild; k++) {
		if ((child = fork()) == 0) {
			dotest(k, iterations);
			exit(0);
		}
		if (child < 0) {
			tst_brkm(TBROK | TERRNO, cleanup, "fork failed");
		}
		pidlist[k] = child;
	}

	/*
	 * Wait for children to finish.
	 */
	count = 0;
	while ((child = wait(&status)) > 0) {
		//tst_resm(TINFO,"Test{%d} exited status = 0x%x", child, status);
		//tst_resm(TINFO,"status is %d",status);
		if (status) {
			tst_resm(TFAIL, "Test{%d} failed, expected 0 exit.",
				 child);
			local_flag = FAILED;
		}
		++count;
	}

	/*
	 * Should have collected all children.
	 */
	if (count != nchild) {
		tst_resm(TFAIL, "Wrong # children waited on, count = %d",
			 count);
		local_flag = FAILED;
	}

	if (local_flag == FAILED)
		tst_resm(TFAIL, "Test failed in fork-wait part.");
	else
		tst_resm(TPASS, "Test passed in fork-wait part.");

	if (iterations > 26)
		iterations = 26;

	for (k = 0; k < nchild; k++)
		for (j = 0; j < iterations + 1; j++) {
			ft_mkname(name, dirname, k, j);
			rmdir(name);
			unlink(name);
		}

	chdir(startdir);

	pid = fork();

	if (pid < 0) {
		tst_brkm(TBROK | TERRNO, cleanup, "fork failed");
	}

	if (pid == 0) {
		execl("/bin/rm", "rm", "-rf", homedir, NULL);
		exit(1);
	} else
		wait(&status);

	if (status)
		tst_resm(TINFO,
			 "CAUTION - ftest02, '%s' may not have been removed.",
			 homedir);

	pid = fork();

	if (pid < 0) {
		tst_brkm(TBROK | TERRNO, cleanup, "fork failed");
	}

	if (pid == 0) {
		execl("/bin/rm", "rm", "-rf", dirname, NULL);
		exit(1);
	} else
		wait(&status);

	if (status) {
		tst_resm(TINFO,
			 "CAUTION - ftest02, '%s' may not have been removed.",
			 dirname);
	}

	sync();

	cleanup();

	tst_exit();
}
Exemple #12
0
/*
 * void
 * setup() - performs all ONE TIME setup for this test.
 *  Create a temporary directory and change directory to it.
 *  Create a test file under temporary directory and close it
 *  Change the ownership of testfile to that of "bin" user.
 *  Record the current time.
 */
void setup(void)
{
	int fildes;		/* file handle for temp file */
	char *tmpd = NULL;

	tst_require_root(NULL);

	tst_sig(FORK, DEF_HANDLER, cleanup);

	/* Pause if that option was specified
	 * TEST_PAUSE contains the code to fork the test with the -i option.
	 * You want to make sure you do this before you create your temporary
	 * directory.
	 */
	TEST_PAUSE;

	tst_tmpdir();

	/* get the name of the temporary directory */
	if ((tmpd = getcwd(tmpd, 0)) == NULL) {
		tst_brkm(TBROK, NULL, "getcwd failed");
	}

	/* Creat a temporary file under above directory */
	if ((fildes = creat(TEMP_FILE, FILE_MODE)) == -1) {
		tst_brkm(TBROK, cleanup,
			 "creat(%s, %#o) Failed, errno=%d :%s",
			 TEMP_FILE, FILE_MODE, errno, strerror(errno));
	}

	/* Close the temporary file created */
	if (close(fildes) < 0) {
		tst_brkm(TBROK, cleanup,
			 "close(%s) Failed, errno=%d : %s:",
			 TEMP_FILE, errno, strerror(errno));
	}

	/*
	 * Make sure that specified Mode permissions set as
	 * umask value may be different.
	 */
	if (chmod(TEMP_FILE, FILE_MODE) < 0) {
		tst_brkm(TBROK, cleanup,
			 "chmod(%s) Failed, errno=%d : %s:",
			 TEMP_FILE, errno, strerror(errno));
	}

	if (chmod(tmpd, 0711) != 0) {
		tst_brkm(TBROK, cleanup, "chmod() failed");
	}

	if ((ltpuser = getpwnam(LTPUSER2)) == NULL) {
		tst_brkm(TBROK, cleanup, "%s not found in /etc/passwd",
			 LTPUSER2);
	}

	/* get uid/gid of user accordingly */
	user_uid = ltpuser->pw_uid;
	group_gid = ltpuser->pw_gid;

	/*
	 * Change the ownership of test directory/file specified by
	 * pathname to that of user_uid and group_gid.
	 */
	if (chown(TEMP_FILE, user_uid, group_gid) < 0) {
		tst_brkm(TBROK, cleanup, "chown() of %s failed, error %d",
			 TEMP_FILE, errno);
	}

	/* Get the current time */
	if ((curr_time = time(&tloc)) < 0) {
		tst_brkm(TBROK, cleanup,
			 "time() failed to get current time, errno=%d", errno);
	}

	/*
	 * Sleep for a second so that mod time and access times will be
	 * different from the current time
	 */
	sleep(2);		/* sleep(1) on IA64 sometimes sleeps < 1 sec!! */

}
Exemple #13
0
int
main(int argc, char **argv)
{
	int lc;		 		 /* loop counter */
	char *msg;	 		 /* message returned from parse_opts */
	char cmd[50];

	/* parse standard options */
	if ((msg = parse_opts(argc, argv, (option_t*) NULL, NULL)) !=
	    (char *) NULL) {
		tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg);
	}

	if(STD_COPIES != 1) {
		tst_resm(TINFO, "-c option has no effect for this testcase - "
				"doesn't allow running more than one instance "
		 		"at a time");
		STD_COPIES = 1;
	}

	/* Load first kernel module */
	if( sprintf(cmd, "/sbin/insmod %s/%s.ko", dirname(argv[0]),
		DUMMY_MOD) <= 0) {
		tst_resm(TBROK, "sprintf failed");
		return 1;
	}
	if( (system(cmd)) != 0 ) {
		tst_resm(TBROK, "Failed to load %s module", DUMMY_MOD);
		return 1;
	}

	/* Load dependant kernel module */
        if( sprintf(cmd, "/sbin/insmod %s/%s.ko", dirname(argv[0]),
		DUMMY_MOD_DEP) <= 0) {
		tst_resm(TBROK, "sprintf failed");
		goto END;
	}
        if( (system(cmd)) != 0 ) {
		tst_resm(TBROK, "Failed to load %s module", DUMMY_MOD_DEP);
		goto END;
        }

	tst_tmpdir();
	if(setup() != 0) {
		return 1;
	}

	/* check looping state if -i option is given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* reset Tst_count in case we are looping */
		Tst_count = 0;

		/* Test the system call */
		TEST(delete_module(DUMMY_MOD));

		TEST_ERROR_LOG(TEST_ERRNO);
		if ( (TEST_RETURN == (int) EXP_RET_VAL ) &&
		     (TEST_ERRNO == EXP_ERRNO) ) {
			tst_resm(TPASS, "Expected failure for module in-use, "
		 			"errno: %d", TEST_ERRNO);
		} else {
			tst_resm(TFAIL, "Unexpected results for module in-use; "
		 			"returned %d (expected %d), errno %d "
					"(expected %d)", TEST_RETURN,
					EXP_RET_VAL, TEST_ERRNO, EXP_ERRNO);
		}
	}
	cleanup();
END:
	if(system("rmmod "DUMMY_MOD) != 0) {
		tst_resm(TBROK, "Failed to unload %s module", DUMMY_MOD);
		return 1;
	}

	/*NOTREACHED*/
	return 0;
}
Exemple #14
0
/*
 * setup() - performs all ONE TIME setup for this test.
 */
void
setup()
{
	char *cwdname = NULL;
	int fd;

	umask(0);

	/* capture signals */
	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	/* Pause if that option was specified */
	TEST_PAUSE;

	ltpuser = getpwnam(nobody_uid);
         if (setgid(ltpuser->pw_uid) == -1) {
                tst_resm(TINFO, "setgid failed to "
                         "to set the gid to %d",
                         ltpuser->pw_uid);
                perror("setgid");
         }
         if (setuid(ltpuser->pw_uid) == -1) {
                tst_resm(TINFO, "setuid failed to "
                         "to set the uid to %d",
                         ltpuser->pw_uid);
                perror("setuid");
         }


	/* make a temporary directory and cd to it */
	tst_tmpdir();

	/*
	 * set up a name that should generate an ENOTDIR error
	 */
	if ((cwdname = getcwd(cwdname, 0)) == NULL) {
		tst_brkm(TBROK, cleanup, "could not get currect directory");
	}

	sprintf(test_name5, "%s/fake.%d", cwdname, getpid());

	if ((fileHandle = creat(test_name5, 0444)) == -1) {
		tst_brkm(TBROK, cleanup, "creat(2) FAILED to create temp file");
	}

	sprintf(test_name3, "%s/fake.%d", test_name5, getpid());

	/* creat() and close a zero length file with executeable permission */
	sprintf(test_name6, "%s/execve03.%d", cwdname, getpid());

	if ((fd = creat(test_name6, 0755)) == -1) {
		tst_brkm(TBROK, cleanup, "creat() failed");
	}
	if (close(fd) == -1) {
		tst_brkm(TBROK, cleanup, "close() failed");
	}

	bad_addr = mmap(0, 1, PROT_NONE,
			MAP_PRIVATE_EXCEPT_UCLINUX|MAP_ANONYMOUS, 0, 0);
	if (bad_addr == MAP_FAILED) {
		tst_brkm(TBROK, cleanup, "mmap failed");
	}
	TC[3].tname = bad_addr;
}
Exemple #15
0
/*--------------------------------------------------------------------*/
int main(int ac, char *av[])
{
	int fildes;
	int ret = 0;
	char pbuf[BUFSIZ];

	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */
	int fail_count = 0;

	/*
	 * parse standard options
	 */
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) {
		tst_resm(TBROK, "OPTION PARSING ERROR - %s", msg);
		tst_exit();
	 }
	tst_tmpdir();
	local_flag = PASSED;
	sprintf(tempfile, "open09.%d", getpid());
/*--------------------------------------------------------------------*/
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		local_flag = PASSED;

		//block0:
		if ((fildes = creat(tempfile, 0600)) == -1) {
			tst_resm(TBROK, "\t\t\tcan't create '%s'", tempfile);
			tst_exit();
		} else {
			close(fildes);
			if ((fildes = open(tempfile, 1)) == -1) {
				tst_resm(TFAIL, "\t\t\topen failed");
				tst_exit();
			}
		}
		ret = read(fildes, pbuf, 1);
		if (ret != -1) {
			tst_resm(TFAIL, "read should not succeed");
			local_flag = FAILED;
		}
		close(fildes);

		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed in block0.");
		} else {
			tst_resm(TFAIL, "Test failed in block0.");
			fail_count++;
		}

		local_flag = PASSED;
	/*--------------------------------------------------------------------*/
		//block1:
		if ((fildes = open(tempfile, 0)) == -1) {
			tst_resm(TFAIL, "\t\t\topen failed");
			local_flag = FAILED;
		} else {
			ret = write(fildes, pbuf, 1);
			if (ret != -1) {
				tst_resm(TFAIL, "writeshould not succeed");
				local_flag = FAILED;
			}
		}
		close(fildes);
		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed in block1.");
		} else {
			tst_resm(TFAIL, "Test failed in block1.");
			fail_count++;
		}
	/*--------------------------------------------------------------------*/
		unlink(tempfile);
		tst_rmdir();

		if (fail_count == 0) {
			tst_resm(TPASS, "Test passed.");
		} else {
			tst_resm(TFAIL, "Test failed due to above failures.");
		}
	}			/* end for */
	tst_exit();
}
Exemple #16
0
static void setup(void)
{
	int ret;

	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	TEST_PAUSE;

	fs_type = tst_dev_fs_type();

	tst_tmpdir();

	device = tst_acquire_device(cleanup);
	if (!device)
		tst_brkm(TCONF, cleanup, "Failed to obtain block device");

	tst_mkfs(cleanup, device, fs_type, NULL, NULL);

	if (mkdir(mntpoint, DIR_MODE) < 0) {
		tst_brkm(TBROK | TERRNO, cleanup, "mkdir(%s, %#o) failed",
			 mntpoint, DIR_MODE);
	}

	/* Call mount(2) */
	tst_resm(TINFO, "mount %s to %s fs_type=%s", device, mntpoint, fs_type);
	TEST(mount(device, mntpoint, fs_type, 0, NULL));

	/* check return code */
	if (TEST_RETURN != 0) {
		tst_brkm(TBROK | TTERRNO, cleanup, "mount(2) failed");
	}
	mount_flag = 1;

	sprintf(fname, "%s/tfile_%d", mntpoint, getpid());
	fd = open(fname, O_RDWR | O_CREAT, 0700);
	if (fd == -1) {
		tst_brkm(TBROK | TERRNO, cleanup,
			 "open(%s, O_RDWR|O_CREAT,0700) failed", fname);
	}

	ret = write(fd, fname, 1);
	if (ret == -1) {
		tst_brkm(TBROK | TERRNO, cleanup,
			 "write(%d, %s, 1) failed", fd, fname);
	}

	/* close the file we have open */
	if (close(fd) == -1)
		tst_brkm(TBROK | TERRNO, cleanup, "close(%s) failed", fname);

	fd_notify = myinotify_init();

	if (fd_notify < 0) {
		if (errno == ENOSYS)
			tst_brkm(TCONF, cleanup,
				 "inotify is not configured in this kernel.");
		else
			tst_brkm(TBROK | TERRNO, cleanup,
				 "inotify_init failed");
	}

	wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS);
	if (wd < 0)
		tst_brkm(TBROK | TERRNO, cleanup,
			 "inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed.",
			 fd_notify, fname);
}
Exemple #17
0
/*--------------------------------------------------------------------*/
int main(int ac, char *av[])
{
	FILE *stream;
	char *junk = "abcdefghijklmnopqrstuvwxyz";
	char *inbuf;
	int ret;

	int lc;
	const char *msg;

	/*
	 * parse standard options
	 */
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
	tst_tmpdir();
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		local_flag = PASSED;

		sprintf(tempfile1, "stream04.%d", getpid());
	/*--------------------------------------------------------------------*/
		//block0:
		if ((stream = fopen(tempfile1, "a+")) == NULL) {
			tst_resm(TFAIL | TERRNO, "fopen(%s) a+ failed",
				 tempfile1);
			tst_rmdir();
			tst_exit();
		}
		/* write something and check */
		if ((ret =
		     fwrite(junk, sizeof(*junk), strlen(junk), stream)) == 0) {
			tst_resm(TFAIL, "fwrite failed: %s", strerror(errno));
			tst_rmdir();
			tst_exit();
		}

		if ((size_t) ret != strlen(junk)) {
			tst_resm(TFAIL,
				 "strlen(junk) = %zi != return value from fwrite = %zi",
				 strlen(junk), ret);
			local_flag = FAILED;
		}

		fclose(stream);
		if ((stream = fopen(tempfile1, "r+")) == NULL) {
			tst_resm(TFAIL, "fopen(%s) r+ failed: %s", tempfile1,
				 strerror(errno));
			tst_rmdir();
			tst_exit();
		}
		if ((inbuf = malloc(strlen(junk))) == 0) {
			tst_resm(TBROK, "test failed because of malloc: %s",
				 strerror(errno));
			tst_rmdir();
			tst_exit();
		}
		if ((ret =
		     fread(inbuf, sizeof(*junk), strlen(junk), stream)) == 0) {
			tst_resm(TFAIL, "fread failed: %s", strerror(errno));
			tst_rmdir();
			tst_exit();
		}
		if ((size_t) ret != strlen(junk)) {
			tst_resm(TFAIL,
				 "strlen(junk) = %zi != return value from fread = %zi",
				 strlen(junk), ret);
			local_flag = FAILED;
		}
		fclose(stream);
		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed.");
		} else {
			tst_resm(TFAIL, "Test failed.");
		}
	/*--------------------------------------------------------------------*/
		unlink(tempfile1);
	}			/* end for */
	tst_rmdir();
	tst_exit();
}
Exemple #18
0
/*
 * setup() - performs all ONE TIME setup for this test.
 *	     Get the system page size.
 *	     Create a temporary directory and a file under it.
 *	     Write some known data into file and close it.
 *	     Change the mode permissions on file to 0555.
 *	     Re-open the file for reading.
 */
void 
setup()
{
	char *tst_buff;			/* test buffer to hold known data */

	/* capture signals */
	tst_sig(NOFORK, sig_handler, cleanup);

	/* Pause if that option was specified */
	TEST_PAUSE;

	/* Get the system page size */
	if ((page_sz = getpagesize()) < 0) {
		tst_brkm(TFAIL, NULL,
			 "getpagesize() fails to get system page size");
		tst_exit();
	}

	/* Allocate space for the test buffer */
	if ((tst_buff = (char *)calloc(page_sz, sizeof(char))) == NULL) {
		tst_brkm(TFAIL, NULL,
			 "calloc() failed to allocate space for tst_buff");
		tst_exit();
	}

	/* Fill the test buffer with the known data */
	memset(tst_buff, 'A', page_sz);

	/* make a temp directory and cd to it */
	tst_tmpdir();

	/* Creat a temporary file used for mapping */
	if ((fildes = open(TEMPFILE, O_WRONLY | O_CREAT, 0666)) < 0) {
		tst_brkm(TFAIL, NULL, "open() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
		free(tst_buff);
		cleanup();
	}

	/* Write test buffer contents into temporary file */
	if (write(fildes, tst_buff, page_sz) < page_sz) {
		tst_brkm(TFAIL, NULL, "write() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
		free(tst_buff);
		cleanup();
	}

	/* Free the memory allocated for test buffer */
	free(tst_buff);

	/* Make sure proper permissions set on file */
	if (chmod(TEMPFILE, 0555) < 0) {
		tst_brkm(TFAIL, cleanup, "chmod() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
	}

	/* Close the temporary file opened for write */
	if (close(fildes) < 0) {
		tst_brkm(TFAIL, cleanup, "close() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
	}

	/* Allocate and initialize dummy string of system page size bytes */
	if ((dummy = (char *)calloc(page_sz, sizeof(char))) == NULL) {
		tst_brkm(TFAIL, cleanup,
			 "calloc() failed to allocate memory for dummy");
	}

	/* Open the temporary file again for reading */
	if ((fildes = open(TEMPFILE, O_RDONLY)) < 0) {
		tst_brkm(TFAIL, cleanup, "open(%s) with read-only Failed, "
			 "errno:%d", TEMPFILE, errno);
	}
}
Exemple #19
0
static void setup(void)
{
	tst_require_root(NULL);
	tst_tmpdir();
}
Exemple #20
0
/*--------------------------------------------------------------------*/
int main(int ac, char *av[])
{
	FILE *stream;
	char buf[10];
	int nr, fd;

	int lc;

	/*
	 * parse standard options
	 */
	tst_parse_opts(ac, av, NULL, NULL);
	tst_tmpdir();
	local_flag = PASSED;

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		local_flag = PASSED;

		sprintf(tempfile, "stream05.%d", getpid());
	/*--------------------------------------------------------------------*/
		//block0:
		if ((stream = fopen(tempfile, "a+")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) a+ failed: %s",
				 tempfile,
				 strerror(errno));
		}
		fprintf(stream, "a");
		fclose(stream);

		if ((stream = fopen(tempfile, "r+")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) r+ failed: %s",
				 tempfile,
				 strerror(errno));
		}

		/* check that ferror returns zero */
		if (ferror(stream) != 0) {
			tst_resm(TFAIL, "ferror did not return zero: %s",
				 strerror(errno));
			local_flag = FAILED;
		}

		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed in block0.");
		} else {
			tst_resm(TFAIL, "Test failed in block0.");
		}

		local_flag = PASSED;

	/*--------------------------------------------------------------------*/
		//block1:

		/* check that fileno returns valid file descriptor */
		fd = fileno(stream);
		if ((nr = read(fd, buf, 1)) < 0) {
			tst_brkm(TFAIL, NULL, "read failed: %s",
				 strerror(errno));
		}
		if (nr != 1) {
			tst_resm(TFAIL, "read did not read right number");
			local_flag = FAILED;
		}
		if (buf[0] != 'a') {
			tst_resm(TFAIL, "read returned bad values");
			local_flag = FAILED;
		}
		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed in block1.");
		} else {
			tst_resm(TFAIL, "Test failed in block1.");
		}

		local_flag = PASSED;
	/*--------------------------------------------------------------------*/
		//block2:

		/* read to EOF and ensure feof returns non-zero */
		fclose(stream);

		if ((stream = fopen(tempfile, "r+")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) r+ failed: %s",
				 tempfile,
				 strerror(errno));
		}
		if (feof(stream) != 0) {
			tst_resm(TFAIL,
				 "feof returned non-zero when it should not: %s",
				 strerror(errno));
			local_flag = FAILED;
		}
		fread(buf, 1, 2, stream);	/* read to EOF */
		if (feof(stream) == 0) {
			tst_resm(TFAIL,
				 "feof returned zero when it should not: %s",
				 strerror(errno));
			local_flag = FAILED;
		}

		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed in block2.");
		} else {
			tst_resm(TFAIL, "Test failed in block2.");
		}

		local_flag = PASSED;
	/*--------------------------------------------------------------------*/
		//block3:
		/* ensure clearerr works */
		clearerr(stream);
		if (feof(stream) != 0) {
			tst_resm(TFAIL, "clearerr failed: %s", strerror(errno));
			local_flag = FAILED;
		}
		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed in block3.");
		} else {
			tst_resm(TFAIL, "Test failed in block3.");
		}

		local_flag = PASSED;
	/*--------------------------------------------------------------------*/
		//block4:

		/* test fopen "b" flags -- should be allowed but ignored */
		(void)fclose(stream);

		if ((stream = fopen(tempfile, "rb")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) rb failed: %s",
				 tempfile,
				 strerror(errno));
		}
		(void)fclose(stream);

		if ((stream = fopen(tempfile, "wb")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) wb failed: %s",
				 tempfile,
				 strerror(errno));
		}
		(void)fclose(stream);

		if ((stream = fopen(tempfile, "ab")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) ab failed: %s",
				 tempfile,
				 strerror(errno));
		}
		(void)fclose(stream);

		if ((stream = fopen(tempfile, "rb+")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) rb+ failed: %s",
				 tempfile,
				 strerror(errno));
		}
		(void)fclose(stream);

		if ((stream = fopen(tempfile, "wb+")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) wb+ failed: %s",
				 tempfile,
				 strerror(errno));
		}
		(void)fclose(stream);

		if ((stream = fopen(tempfile, "ab+")) == NULL) {
			tst_brkm(TFAIL, NULL, "fopen(%s) ab+ failed: %s",
				 tempfile,
				 strerror(errno));
		}
		(void)fclose(stream);

		tst_resm(TPASS, "Test passed in block4.");
	/*--------------------------------------------------------------------*/
		unlink(tempfile);
	}			/* end for */
	tst_rmdir();
	tst_exit();
}
Exemple #21
0
/*--------------------------------------------------------------------*/
int main(int ac, char *av[])
{
	FILE *stream;
	int fd;
	int lc;
	char *msg;

         /*
          * parse standard options
          */
        if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

        local_flag = PASSED;
	tst_tmpdir();

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		sprintf(tempfile1, "stream1.%d", getpid());
	/*--------------------------------------------------------------------*/
	//block0:
		if (mknod(tempfile1, (S_IFIFO|0666), 0) != 0) {
			tst_resm(TFAIL,"mknod failed in block0: %s", strerror(errno));
			local_flag = FAILED;
			goto block1;
		}
		if ((stream=fopen(tempfile1,"w+")) == NULL) {
			tst_resm(TFAIL,"fopen(%s) w+ failed for pipe file: %s", tempfile1, strerror(errno));
			local_flag = FAILED;
		} else {
			fclose(stream);
		}
		if ((stream=fopen(tempfile1,"a+")) == NULL) {
			tst_resm(TFAIL,"fopen(%s) a+ failed: %s", tempfile1, strerror(errno));
			local_flag = FAILED;
		} else {
			fclose(stream);
			unlink(tempfile1);
		}
		if (local_flag == PASSED) {
		         tst_resm(TPASS, "Test passed in block0.");
		} else {
		         tst_resm(TFAIL, "Test failed in block0.");
	        }
		local_flag = PASSED;

	/*--------------------------------------------------------------------*/
	block1 :
		if ((fd = open("/dev/tty", O_WRONLY)) >= 0)
		{
			close(fd);
			if (( stream = fopen("/dev/tty","w"))==NULL) {
				tst_resm(TFAIL|TERRNO,"fopen(/dev/tty) write failed");
				local_flag = FAILED;
			} else {
				fclose(stream);
			}
		}
		if (local_flag == PASSED) {
		         tst_resm(TPASS, "Test passed in block1.");
		} else {
		         tst_resm(TFAIL, "Test failed in block1.");
	        }

	/*--------------------------------------------------------------------*/
	} /* end for */
	tst_rmdir();
	tst_exit();
}
Exemple #22
0
/*
 * setup() - performs all the ONE TIME setup for this test.
 */
void setup(void)
{
	key_t shmkey2;

	/* Switch to nobody user for correct error code collection */
	if (geteuid() != 0) {
		tst_brkm(TBROK, tst_exit, "Test must be run as root");
	}
	ltpuser = getpwnam(nobody_uid);
	if (setuid(ltpuser->pw_uid) == -1) {
		tst_resm(TINFO, "setuid failed to "
			 "to set the effective uid to %d", ltpuser->pw_uid);
		perror("setuid");
	}

	/* capture signals */
	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	/* Set up the expected error numbers for -e option */
	TEST_EXP_ENOS(exp_enos);

	/* Pause if that option was specified */
	TEST_PAUSE;

	/*
	 * Create a temporary directory and cd into it.
	 * This helps to ensure that a unique msgkey is created.
	 * See ../lib/libipc.c for more information.
	 */
	tst_tmpdir();

	/* get an IPC resource key */
	shmkey = getipckey();

	/* create a shared memory resource with read and write permissions */
	/* also post increment the shmkey for the next shmget call */
	if ((shm_id_2 = shmget(shmkey, INT_SIZE, SHM_RW | IPC_CREAT |
			       IPC_EXCL)) == -1) {
		tst_brkm(TBROK, cleanup, "Failed to create shared memory "
			 "resource #1 in setup()");
	}

	/* Get an new IPC resource key. */
	shmkey2 = getipckey();

	/* create a shared memory resource without read and write permissions */
	if ((shm_id_3 = shmget(shmkey2, INT_SIZE, IPC_CREAT | IPC_EXCL)) == -1) {
		tst_brkm(TBROK, cleanup, "Failed to create shared memory "
			 "resource #2 in setup()");
	}

	/* Probe an available linear address for attachment */
	if ((base_addr = shmat(shm_id_2, NULL, 0)) == (void *)-1) {
		tst_brkm(TBROK, cleanup, "Couldn't attach shared memory");
	}

	if (shmdt((const void *)base_addr) == -1) {
		tst_brkm(TBROK, cleanup, "Couldn't detach shared memory");
	}

	/* some architectures (e.g. parisc) are strange, so better always align to
	 * next SHMLBA address. */
	base_addr =
	    (void *)(((unsigned long)(base_addr) & ~(SHMLBA - 1)) + SHMLBA);
}
Exemple #23
0
void setup() {
	/* Capture signals if any */
	/* Create temporary directories */
	TEST_PAUSE;
	tst_tmpdir();
}
Exemple #24
0
/*
 * void
 * setup() -  Performs setup function for the test.
 *  Creat a temporary directory and change directory to it.
 *  Creat a testfile and write some data into it.
 *  Modify the mode permissions of testfile such that test process
 *  has read-only access to testfile.
 */
void 
setup()
{
	int i, fd;			/* counter, file handle for file */
	char tst_buff[BUF_SIZE];	/* data buffer for file */
	int wbytes;			/* no. of bytes written to file */
	int write_len = 0;

	/* capture signals */
	tst_sig(NOFORK, DEF_HANDLER, cleanup);
#if 0
	/* Switch to nobody user for correct error code collection */
        if (geteuid() != 0) {
                tst_brkm(TBROK, tst_exit, "Test must be run as root");
        }
         ltpuser = getpwnam(nobody_uid);
         if (setuid(ltpuser->pw_uid) == -1) {
                tst_resm(TINFO, "setuid failed to "
                         "to set the effective uid to %d",
                         ltpuser->pw_uid);
                perror("setuid");
         }
#endif
	/* Pause if that option was specified
	 * TEST_PAUSE contains the code to fork the test with the -i option.
	 * You want to make sure you do this before you create your temporary
	 * directory.
	 */
	TEST_PAUSE;

	/* make a temp directory and cd to it */
	tst_tmpdir();

	if ((fd = open(TESTFILE, O_RDWR|O_CREAT, FILE_MODE)) == -1) {
		tst_brkm(TBROK, cleanup,
			 "open(%s, O_RDWR|O_CREAT, %#o) Failed, errno=%d : %s",
			 TESTFILE, FILE_MODE, errno, strerror(errno));
		/*NOTREACHED*/
	}

	/* Fill the test buffer with the known data */
	for (i = 0; i < BUF_SIZE; i++) {
		tst_buff[i] = 'a';
	}
	
	/* Write to the file 1k data from the buffer */
	while (write_len < FILE_SIZE) {
		if ((wbytes = write(fd, tst_buff, sizeof(tst_buff))) <= 0) {
			tst_brkm(TBROK, cleanup,
				 "write(2) on %s Failed, errno=%d : %s",
				 TESTFILE, errno, strerror(errno));
			/*NOTREACHED*/
		} else {
			write_len += wbytes;
		}
	}

	if (close(fd) == -1) {
		tst_resm(TWARN, "close(%s) Failed, errno=%d : %s",
			 TESTFILE, errno, strerror(errno));
	}

	/* Modify mode permissions on the testfile */
	if (chmod(TESTFILE, NEW_MODE) < 0) {
		tst_brkm(TBROK, cleanup,
			 "chmod(2) on %s Failed, errno=%d : %s",
			 TESTFILE, errno, strerror(errno));
		/*NOTREACHED*/
	}
			
	/* Get the uid/gid of the process */
	User_id = getuid();
	Group_id = getgid();

}	/* End setup() */
Exemple #25
0
/*
 * setup() - performs all ONE TIME setup for this test.
 *
 * Set up signal handler to catch SIGSEGV.
 * Get system page size, create a temporary file for reading/writing,
 * write one byte data into it, map the open file for the specified
 * map length.
 */
void setup()
{
	size_t page_sz;		/* system page size */

	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	/* call signal function to trap the signal generated */
	if (signal(SIGSEGV, sig_handler) == SIG_ERR) {
		tst_brkm(TBROK, cleanup, "signal fails to catch signal");
		tst_exit();
	}

	TEST_PAUSE;

	/* Get the system page size */
	if ((page_sz = getpagesize()) < 0) {
		tst_brkm(TBROK, cleanup,
			 "getpagesize() fails to get system page size");
		tst_exit();
	}

	/*
	 * Get the length of the open file to be mapped into process
	 * address space.
	 */
	map_len = 3 * page_sz;

	tst_tmpdir();

	/* Creat a temporary file used for mapping */
	if ((fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666)) < 0) {
		tst_brkm(TBROK, cleanup, "open() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
		tst_exit();
	}

	/*
	 * move the file pointer to maplength position from the beginning
	 * of the file.
	 */
	if (lseek(fildes, map_len, SEEK_SET) == -1) {
		tst_brkm(TBROK, cleanup, "lseek() fails on %s, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
		tst_exit();
	}

	/* Write one byte into temporary file */
	if (write(fildes, "a", 1) != 1) {
		tst_brkm(TBROK, cleanup, "write() on %s Failed, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
		tst_exit();
	}

	/*
	 * map the open file 'TEMPFILE' from its beginning up to the maplength
	 * into the calling process's address space at the system choosen
	 * with read/write permissions to the the mapped region.
	 */
#ifdef UCLINUX
	/* MAP_SHARED is not implemented on uClinux */
	addr = mmap(0, map_len, PROT_READ | PROT_WRITE,
		    MAP_FILE | MAP_PRIVATE, fildes, 0);
#else
	addr = mmap(0, map_len, PROT_READ | PROT_WRITE,
		    MAP_FILE | MAP_SHARED, fildes, 0);
#endif

	/* check for the return value of mmap system call */
	if (addr == (char *)MAP_FAILED) {
		tst_brkm(TBROK, cleanup, "mmap() Failed on %s, errno=%d : %s",
			 TEMPFILE, errno, strerror(errno));
		tst_exit();
	}

}
Exemple #26
0
static void setup(void)
{
	FILE *fp;
	int fd;
	struct stat stat_buf;

	tst_require_root(NULL);

	if (stat(pathover, &stat_buf) == -1) {
		if (errno == ENOENT || errno == ENOTDIR)
			tst_brkm(TCONF, NULL,
			    "file %s does not exist in the system", pathover);
	}

	tst_sig(FORK, DEF_HANDLER, cleanup);
	TEST_PAUSE;
	tst_tmpdir();

	if (shmid != -1) {
		fp = fopen(PATH_SHMMAX, "r");
		if (fp == NULL)
			tst_brkm(TBROK|TERRNO, cleanup, "fopen");
		if (fgets(shmmax, BUFSIZ, fp) == NULL)
			tst_brkm(TBROK|TERRNO, cleanup, "fgets");
		fclose(fp);

		if (atol(shmmax) < (long)(length / 2 * hugepagesize)) {
			restore_shmmax = 1;
			fd = open(PATH_SHMMAX, O_RDWR);
			if (fd == -1)
				tst_brkm(TBROK|TERRNO, cleanup, "open");
			snprintf(buf, BUFSIZ, "%ld", (long)(length / 2 * hugepagesize));
			if (write(fd, buf, strlen(buf)) != strlen(buf))
				tst_brkm(TBROK|TERRNO, cleanup,
					"failed to change shmmax.");
		}
	}
	fp = fopen(path, "r+");
	if (fp == NULL)
		tst_brkm(TBROK|TERRNO, cleanup, "fopen");
	if (fgets(nr_hugepages, BUFSIZ, fp) == NULL)
		tst_brkm(TBROK|TERRNO, cleanup, "fgets");
	fclose(fp);
	/* Remove trailing newline. */
	nr_hugepages[strlen(nr_hugepages) - 1] = '\0';
	tst_resm(TINFO, "original nr_hugepages is %s", nr_hugepages);

	fd = open(path, O_RDWR);
	if (fd == -1)
		tst_brkm(TBROK|TERRNO, cleanup, "open");
	/* Reset. */
	if (write(fd, "0", 1) != 1)
		tst_brkm(TBROK|TERRNO, cleanup, "write");
	if (lseek(fd, 0, SEEK_SET) == -1)
		tst_brkm(TBROK|TERRNO, cleanup, "lseek");
	snprintf(buf, BUFSIZ, "%zd", size);
	if (write(fd, buf, strlen(buf)) != strlen(buf))
		tst_brkm(TBROK|TERRNO, cleanup,
			"failed to change nr_hugepages.");
	close(fd);

	fp = fopen(pathover, "r+");
	if (fp == NULL)
		tst_brkm(TBROK|TERRNO, cleanup, "fopen");
	if (fgets(nr_overcommit_hugepages, BUFSIZ, fp) == NULL)
		tst_brkm(TBROK|TERRNO, cleanup, "fgets");
	fclose(fp);
	nr_overcommit_hugepages[strlen(nr_overcommit_hugepages) - 1] = '\0';
	tst_resm(TINFO, "original nr_overcommit_hugepages is %s",
		nr_overcommit_hugepages);

	fd = open(pathover, O_RDWR);
	if (fd == -1)
		tst_brkm(TBROK|TERRNO, cleanup, "open");
	/* Reset. */
	if (write(fd, "0", 1) != 1)
		tst_brkm(TBROK|TERRNO, cleanup, "write");
	if (lseek(fd, 0, SEEK_SET) == -1)
		tst_brkm(TBROK|TERRNO, cleanup, "lseek");
	snprintf(buf, BUFSIZ, "%zd", size);
	if (write(fd, buf, strlen(buf)) != strlen(buf))
		tst_brkm(TBROK|TERRNO, cleanup,
			"failed to change nr_hugepages.");
	close(fd);

	/* XXX (garrcoop): memory leak. */
	snprintf(buf, BUFSIZ, "%s/hugemmap05", get_tst_tmpdir());
	if (mkdir(buf, 0700) == -1)
		tst_brkm(TBROK|TERRNO, cleanup, "mkdir");
	if (mount(NULL, buf, "hugetlbfs", 0, NULL) == -1)
		tst_brkm(TBROK|TERRNO, cleanup, "mount");
}
Exemple #27
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 (unlink(tmpname) == -1) {
		ERROR("unlink failed");
		anyfail();
	}
	(void)time(&t);
//	(void)printf("%s: Finished %s", argv[0], ctime(&t));
	ok_exit(); /* LTP Port */
	return 0;
}
Exemple #28
0
static void setup(void)
{
	TEST_PAUSE;
	tst_tmpdir();
}
Exemple #29
0
/*--------------------------------------------------------------------*/
int main(int ac, char *av[])
{
	FILE *stream;
	char buf[10];
	int i;
	int lc;
	char *msg;

	/*
	 * parse standard options
	 */
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	local_flag = PASSED;
	tst_tmpdir();
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		sprintf(tempfile1, "stream011.%d", getpid());
		sprintf(tempfile2, "stream012.%d", getpid());
	/*--------------------------------------------------------------------*/
		//block0:
		if ((stream = fopen(tempfile1, "a+")) == NULL) {
			tst_resm(TFAIL, "fopen(%s) a+ failed: %s", tempfile1,
				 strerror(errno));
			tst_exit();
		}
		fwrite("a", 1, 1, stream);
		if ((stream = freopen(tempfile2, "a+", stream)) == NULL) {
			tst_brkm(TFAIL | TERRNO, NULL, "freopen(%s) a+ failed",
				 tempfile2);
		}
		fwrite("a", 1, 1, stream);
		fclose(stream);

		/* now check that a single "a" is in each file */
		if ((stream = fopen(tempfile1, "r")) == NULL) {
			tst_brkm(TFAIL | TERRNO, NULL, "fopen(%s) r failed",
				 tempfile1);
		} else {
			for (i = 0; i < 10; i++)
				buf[i] = 0;
			fread(buf, 1, 1, stream);
			if ((buf[0] != 'a') || (buf[1] != 0)) {
				tst_resm(TFAIL, "bad contents in %s",
					 tempfile1);
				local_flag = FAILED;
			}
			fclose(stream);
		}
		if ((stream = fopen(tempfile2, "r")) == NULL) {
			tst_brkm(TFAIL | TERRNO, NULL, "fopen(%s) r failed",
				 tempfile2);
		} else {
			for (i = 0; i < 10; i++)
				buf[i] = 0;
			fread(buf, 1, 1, stream);
			if ((buf[0] != 'a') || (buf[1] != 0)) {
				tst_resm(TFAIL, "bad contents in %s",
					 tempfile2);
				local_flag = FAILED;
			}
			fclose(stream);
		}
		if (local_flag == PASSED) {
			tst_resm(TPASS, "Test passed.");
		} else {
			tst_resm(TFAIL, "Test failed.");
		}

		local_flag = PASSED;

	/*--------------------------------------------------------------------*/
		unlink(tempfile1);
		unlink(tempfile2);

	}			/* end for */
	tst_rmdir();
	tst_exit();
}
Exemple #30
0
/*
 * setup(void) - performs all ONE TIME setup for this test.
 * 	Exit the test program on receipt of unexpected signals.
 *	Create a temporary directory used to hold test directories created
 *	and change the directory to it.
 *	Verify that pid of process executing the test is root.
 *	Create a test directory on temporary directory and set the ownership
 *	of test directory to guest user and process, change mode permissions
 *	to set group id bit on it.
 *	Set the effective uid/gid of the process to that of guest user.
 */
void setup(void)
{
	tst_require_root();

	/* Capture unexpected signals */
	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	TEST_PAUSE;

	/* Make a temp dir and cd to it */
	tst_tmpdir();

	/* fix permissions on the tmpdir */
	if (chmod(".", 0711) != 0) {
		tst_brkm(TBROK, cleanup, "chmod() failed");
	}

	/* Save the real user id of the current test process */
	save_myuid = getuid();
	/* Save the process id of the current test process */
	mypid = getpid();

	/* Get the node name to be created in the test */
	sprintf(node_name, TNODE, mypid);

	/* Get the uid/gid of ltpuser user */
	if ((user1 = getpwnam(LTPUSER)) == NULL) {
		tst_brkm(TBROK, cleanup, "%s not in /etc/passwd", LTPUSER);
	}
	user1_uid = user1->pw_uid;
	group1_gid = user1->pw_gid;

	/* Get the effective group id of the test process */
	group2_gid = getegid();

	/*
	 * Create a test directory under temporary directory with the
	 * specified mode permissions, with uid/gid set to that of guest
	 * user and the test process.
	 */
	SAFE_MKDIR(cleanup, DIR_TEMP, MODE_RWX);
	SAFE_CHOWN(cleanup, DIR_TEMP, user1_uid, group2_gid);
	SAFE_CHMOD(cleanup, DIR_TEMP, MODE_SGID);

	/*
	 * Verify that test directory created with expected permission modes
	 * and ownerships.
	 */
	SAFE_STAT(cleanup, DIR_TEMP, &buf);

	/* Verify modes of test directory */
	if (!(buf.st_mode & S_ISGID)) {
		tst_brkm(TBROK, cleanup,
			 "%s: Incorrect modes, setgid bit not set", DIR_TEMP);
	}

	/* Verify group ID of test directory */
	if (buf.st_gid != group2_gid) {
		tst_brkm(TBROK, cleanup, "%s: Incorrect group", DIR_TEMP);
	}

	/*
	 * Set the effective group id and user id of the test process
	 * to that of guest user (nobody)
	 */
	SAFE_SETGID(cleanup, group1_gid);
	if (setreuid(-1, user1_uid) < 0) {
		tst_brkm(TBROK, cleanup,
			 "Unable to set process uid to that of ltp user");
	}

	/* Save the real group ID of the current process */
	mygid = getgid();

	/* Change directory to DIR_TEMP */
	SAFE_CHDIR(cleanup, DIR_TEMP);
}