Esempio n. 1
0
File: rename06.c Progetto: kraj/ltp
/*
 * setup() - performs all ONE TIME setup for this test.
 */
void setup(void)
{

	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	TEST_PAUSE;

	/* Create a temporary directory and make it current. */
	tst_tmpdir();

	sprintf(fdir, "./tdir_%d", getpid());
	sprintf(mdir, "%s/rndir_%d", fdir, getpid());

	/* create "old" directory */
	if (stat(fdir, &buf1) != -1) {
		tst_brkm(TBROK, cleanup, "tmp directory %s found!", fdir);
	}
	SAFE_MKDIR(cleanup, fdir, 00770);
	SAFE_STAT(cleanup, fdir, &buf1);
	/* save "old"'s dev and ino */
	olddev = buf1.st_dev;
	oldino = buf1.st_ino;

	/* create another directory */
	if (stat(mdir, &buf2) != -1) {
		tst_brkm(TBROK, cleanup, "tmp directory %s found!", mdir);
	}
	SAFE_MKDIR(cleanup, mdir, 00770);

	SAFE_STAT(cleanup, mdir, &buf2);

	/* save "new"'s dev and ino */
	olddev1 = buf2.st_dev;
	oldino1 = buf2.st_ino;
}
Esempio n. 2
0
static void utimes_verify(const struct test_case_t *tc)
{
	struct stat st;
	struct timeval tmp_tv[2];

	if (tc->exp_errno == 0) {
		SAFE_STAT(cleanup, tc->pathname, &st);

		tmp_tv[0].tv_sec = st.st_atime;
		tmp_tv[0].tv_usec = 0;
		tmp_tv[1].tv_sec = st.st_mtime;
		tmp_tv[1].tv_usec = 0;
	}

	TEST(utimes(tc->pathname, tc->times));

	TEST_ERROR_LOG(TEST_ERRNO);

	if (TEST_ERRNO == tc->exp_errno) {
		tst_resm(TPASS | TTERRNO, "utimes() worked as expected");
	} else {
		tst_resm(TFAIL | TTERRNO,
			"utimes() failed unexpectedly; expected: %d - %s",
			tc->exp_errno, strerror(tc->exp_errno));
	}

	if (TEST_ERRNO == 0 && utimes(tc->pathname, tmp_tv) == -1)
			tst_brkm(TBROK | TERRNO, cleanup, "utimes() failed.");
}
Esempio n. 3
0
static void setup(void)
{
	struct stat c_buf, l_buf;

	if ((tst_kvercmp(2, 6, 16)) < 0)
		tst_brkm(TCONF, NULL, "This test needs kernel 2.6.16 or newer");

	tst_require_root(NULL);

	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	TEST_PAUSE;

	tst_tmpdir();

	dirfd = SAFE_OPEN(cleanup, "./", O_DIRECTORY);

	SAFE_TOUCH(cleanup, TESTFILE, 0600, NULL);

	SAFE_SYMLINK(cleanup, TESTFILE, TESTFILE_LINK);

	SAFE_STAT(cleanup, TESTFILE_LINK, &c_buf);

	SAFE_LSTAT(cleanup, TESTFILE_LINK, &l_buf);

	if (l_buf.st_uid == set_uid || l_buf.st_gid == set_gid) {
		tst_brkm(TBROK | TERRNO, cleanup,
			 "link_uid(%d) == set_uid(%d) or link_gid(%d) == "
			 "set_gid(%d)", l_buf.st_uid, set_uid, l_buf.st_gid,
			 set_gid);
	}
}
Esempio n. 4
0
File: ustat02.c Progetto: kraj/ltp
static void setup(void)
{
	struct stat buf;

	/* Find a valid device number */
	SAFE_STAT("/", &buf);

	root_dev = buf.st_dev;
}
Esempio n. 5
0
File: openat02.c Progetto: qyxia/ltp
void testfunc_noatime(void)
{
	struct stat file_stat, file_newstat;
	char buf;
	const char *flags[] = {"noatime", "relatime", NULL};
	int ret;

	if ((tst_kvercmp(2, 6, 8)) < 0) {
		tst_resm(TCONF, "test O_NOATIME flags for openat "
						"needs kernel 2.6.8 or higher");
		return;
	}

	ret = tst_path_has_mnt_flags(cleanup, NULL, flags);
	if (ret > 0) {
		tst_resm(TCONF, "test O_NOATIME flag for openat needs "
			"filesystems which are mounted without "
			"noatime and relatime");
		return;
	}

	SAFE_STAT(cleanup, TEST_FILE, &file_stat);

	sleep(1);

	TEST(openat(AT_FDCWD, TEST_FILE, O_NOATIME | O_RDONLY, 0777));

	if (TEST_RETURN == -1) {
		tst_resm(TFAIL | TTERRNO, "openat failed");
		return;
	}

	SAFE_READ(cleanup, 1, TEST_RETURN, &buf, 1);

	SAFE_CLOSE(cleanup, TEST_RETURN);

	SAFE_STAT(cleanup, TEST_FILE, &file_newstat);

	if (file_stat.st_atime == file_newstat.st_atime)
		tst_resm(TPASS, "test O_NOATIME for openat success");
	else
		tst_resm(TFAIL, "test O_NOATIME for openat failed");
}
Esempio n. 6
0
static void setup(void)
{
	struct stat buf;

	tst_sig(NOFORK, DEF_HANDLER, cleanup);

	TEST_PAUSE;

	/* Find a valid device number */
	SAFE_STAT(cleanup, "/", &buf);

	dev_num = buf.st_dev;
}
Esempio n. 7
0
static void test_noatime(void)
{
	char read_buf;
	struct stat old_stat, new_stat;

	if ((tst_kvercmp(2, 6, 8)) < 0) {
		tst_resm(TCONF,
			 "O_NOATIME flags test for open(2) needs kernel 2.6.8 "
			 "or higher");
		return;
	}

	if (skip_noatime) {
		tst_resm(TCONF,
		         "test O_NOATIME flag for open needs filesystems which "
		         "is mounted without noatime and relatime");
		return;
	}

	SAFE_STAT(cleanup, TEST_FILE, &old_stat);

	sleep(1);

	TEST(open(TEST_FILE, O_RDONLY | O_NOATIME, 0777));

	if (TEST_RETURN == -1) {
		tst_resm(TFAIL | TTERRNO, "open failed");
		return;
	}
	SAFE_READ(cleanup, 1, TEST_RETURN, &read_buf, 1);
	SAFE_CLOSE(cleanup, TEST_RETURN);
	SAFE_STAT(cleanup, TEST_FILE, &new_stat);

	if (old_stat.st_atime == new_stat.st_atime)
		tst_resm(TPASS, "test O_NOATIME for open success");
	else
		tst_resm(TFAIL, "test O_NOATIME for open failed");
}
Esempio n. 8
0
const char *tst_acquire_device(void (cleanup_fn)(void))
{
	char *dev;
	struct stat st;

	if (device_acquired)
		tst_brkm(TBROK, cleanup_fn, "Device allready acquired");

	if (!tst_tmpdir_created()) {
		tst_brkm(TBROK, cleanup_fn,
		         "Cannot acquire device without tmpdir() created");
	}

	dev = getenv("LTP_DEV");

	if (dev) {
		tst_resm(TINFO, "Using test device LTP_DEV='%s'", dev);

		SAFE_STAT(cleanup_fn, dev, &st);

		if (!S_ISBLK(st.st_mode)) {
			tst_brkm(TBROK, cleanup_fn,
			         "%s is not a block device", dev);
		}

		if (tst_fill_file(dev, 0, 1024, 512)) {
			tst_brkm(TBROK | TERRNO, cleanup_fn,
				 "Failed to clear the first 512k of %s", dev);
		}

		return dev;
	}

	if (tst_fill_file(DEV_FILE, 0, 1024, 102400)) {
		tst_brkm(TBROK | TERRNO, cleanup_fn,
		         "Failed to create " DEV_FILE);

	}

	if (find_free_loopdev())
		return NULL;

	attach_device(cleanup_fn, dev_path, DEV_FILE);

	device_acquired = 1;

	return dev_path;
}
Esempio n. 9
0
File: mount03.c Progetto: kraj/ltp
static void setup(void)
{
	char path[PATH_MAX];
	struct stat file_stat;

	tst_sig(FORK, DEF_HANDLER, cleanup);

	tst_require_root();

	tst_tmpdir();

	fs_type = tst_dev_fs_type();
	device = tst_acquire_device(cleanup);

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

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

	SAFE_MKDIR(cleanup, mntpoint, DIR_MODE);

	if (getcwd(path_name, sizeof(path_name)) == NULL)
		tst_brkm(TBROK, cleanup, "getcwd failed");

	if (chmod(path_name, DIR_MODE) != 0)
		tst_brkm(TBROK, cleanup, "chmod(%s, %#o) failed",
			 path_name, DIR_MODE);

	strncpy(path, path_name, PATH_MAX);
	snprintf(path_name, PATH_MAX, "%s/%s/", path, mntpoint);

	SAFE_MOUNT(cleanup, device, mntpoint, fs_type, 0, NULL);
	TST_RESOURCE_COPY(cleanup, "mount03_setuid_test", path_name);

	snprintf(file, PATH_MAX, "%smount03_setuid_test", path_name);
	SAFE_STAT(cleanup, file, &file_stat);

	if (file_stat.st_mode != SUID_MODE &&
	    chmod(file, SUID_MODE) < 0)
		tst_brkm(TBROK, cleanup,
			 "setuid for setuid_test failed");
	SAFE_UMOUNT(cleanup, mntpoint);

	TEST_PAUSE;
}
Esempio n. 10
0
static void test_verify(void)
{
	struct stat c_buf, l_buf;

	SAFE_STAT(cleanup, TESTFILE_LINK, &c_buf);

	SAFE_LSTAT(cleanup, TESTFILE_LINK, &l_buf);

	if (c_buf.st_uid != set_uid && l_buf.st_uid == set_uid &&
	    c_buf.st_gid != set_gid && l_buf.st_gid == set_gid) {
		tst_resm(TPASS, "fchownat() test AT_SYMLINK_NOFOLLOW success");
	} else {
		tst_resm(TFAIL,
			 "fchownat() test AT_SYMLINK_NOFOLLOW fail with uid=%d "
			 "link_uid=%d set_uid=%d | gid=%d link_gid=%d "
			 "set_gid=%d", c_buf.st_uid, l_buf.st_uid, set_uid,
			 c_buf.st_gid, l_buf.st_gid, set_gid);
	}
}
Esempio n. 11
0
static void setresgid_verify(void)
{
	struct stat buf;

	TEST(SETRESGID(cleanup, -1, ltpuser->pw_gid, -1));

	if (TEST_RETURN != 0) {
		tst_resm(TFAIL | TTERRNO, "setresgid failed unexpectedly");
		return;
	}

	SAFE_TOUCH(cleanup, "test_file", 0644, NULL);

	SAFE_STAT(cleanup, "test_file", &buf);

	if (ltpuser->pw_gid == buf.st_gid) {
		tst_resm(TPASS, "setresgid succeeded as expected");
	} else {
		tst_resm(TFAIL,
			 "setresgid failed unexpectedly; egid(%d) - st_gid(%d)",
			 ltpuser->pw_gid, buf.st_gid);
	}
}
Esempio n. 12
0
File: utime01.c Progetto: 1587/ltp
int main(int ac, char **av)
{
	struct stat stat_buf;	/* struct buffer to hold file info. */
	int lc;
	long type;
	time_t modf_time, access_time;
	time_t pres_time;	/* file modification/access/present time */

	tst_parse_opts(ac, av, NULL, NULL);

	setup();

	switch ((type = tst_fs_type(cleanup, "."))) {
	case TST_NFS_MAGIC:
		if (tst_kvercmp(2, 6, 18) < 0)
			tst_brkm(TCONF, cleanup, "Cannot do utime on a file"
				" on %s filesystem before 2.6.18",
				 tst_fs_type_name(type));
		break;
	case TST_V9FS_MAGIC:
		tst_brkm(TCONF, cleanup,
			 "Cannot do utime on a file on %s filesystem",
			 tst_fs_type_name(type));
		break;
	}

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

		tst_count = 0;

		/*
		 * Invoke utime(2) to set TEMP_FILE access and
		 * modification times to the current time.
		 */
		TEST(utime(TEMP_FILE, NULL));

		if (TEST_RETURN == -1) {
			tst_resm(TFAIL|TTERRNO, "utime(%s) failed", TEMP_FILE);
		} else {
			/*
			 * Sleep for a second so that mod time and
			 * access times will be different from the
			 * current time
			 */
			sleep(2);

			/*
			 * Get the current time now, after calling
			 * utime(2)
			 */
			pres_time = time(NULL);

			/*
			 * Get the modification and access times of
			 * temporary file using stat(2).
			 */
			SAFE_STAT(cleanup, TEMP_FILE, &stat_buf);
			modf_time = stat_buf.st_mtime;
			access_time = stat_buf.st_atime;

			/* Now do the actual verification */
			if (modf_time <= curr_time ||
			    modf_time >= pres_time ||
			    access_time <= curr_time ||
			    access_time >= pres_time) {
				tst_resm(TFAIL, "%s access and "
					 "modification times not set",
					 TEMP_FILE);
			} else {
				tst_resm(TPASS, "Functionality of "
					 "utime(%s, NULL) successful",
					 TEMP_FILE);
			}
		}
		tst_count++;
	}

	cleanup();
	tst_exit();
}
Esempio n. 13
0
int main(int ac, char **av)
{
	int lc;
	const char *msg;
	struct stat fbuf, lbuf;
	int cnt;
	char lname[255];

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

	if (links_arg) {
		nlinks = atoi(links_arg);

		if (nlinks == 0) {
			tst_brkm(TBROK, NULL,
			         "nlinks is not a positive number");
		}
	}

	setup();

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

		tst_count = 0;

		for (cnt = 1; cnt < nlinks; cnt++) {
			sprintf(lname, "%s%d", fname, cnt);
			TEST(link(fname, lname));

			if (TEST_RETURN == -1) {
				tst_resm(TFAIL,
					 "link(%s, %s) Failed, errno=%d : %s",
					 fname, lname, TEST_ERRNO,
					 strerror(TEST_ERRNO));
			}
		}

		SAFE_STAT(cleanup, fname, &fbuf);

		for (cnt = 1; cnt < nlinks; cnt++) {
			sprintf(lname, "%s%d", fname, cnt);

			SAFE_STAT(cleanup, lname, &lbuf);
			if (fbuf.st_nlink <= 1 || lbuf.st_nlink <= 1 ||
			    (fbuf.st_nlink != lbuf.st_nlink)) {

				tst_resm(TFAIL,
					 "link(%s, %s[1-%d]) ret %ld for %d "
				         "files, stat values do not match %d %d",
					 fname, fname, nlinks,
					 TEST_RETURN, nlinks,
					 (int)fbuf.st_nlink, (int)lbuf.st_nlink);
				break;
			}
		}
		if (cnt >= nlinks) {
			tst_resm(TPASS,
				 "link(%s, %s[1-%d]) ret %ld for %d files,"
			         "stat linkcounts match %d",
				 fname, fname, nlinks, TEST_RETURN,
				 nlinks, (int)fbuf.st_nlink);
		}

		for (cnt = 1; cnt < nlinks; cnt++) {
			sprintf(lname, "%s%d", fname, cnt);
			SAFE_UNLINK(cleanup, lname);
		}
	}

	cleanup();
	tst_exit();
}
Esempio n. 14
0
const char *tst_acquire_device_(void (cleanup_fn)(void), unsigned int size)
{
	int fd;
	char *dev;
	struct stat st;
	unsigned int acq_dev_size;
	uint64_t ltp_dev_size;

	acq_dev_size = size > 150 ? size : 150;

	if (device_acquired)
		tst_brkm(TBROK, cleanup_fn, "Device allready acquired");

	if (!tst_tmpdir_created()) {
		tst_brkm(TBROK, cleanup_fn,
		         "Cannot acquire device without tmpdir() created");
	}

	dev = getenv("LTP_DEV");

	if (dev) {
		tst_resm(TINFO, "Using test device LTP_DEV='%s'", dev);

		SAFE_STAT(cleanup_fn, dev, &st);

		if (!S_ISBLK(st.st_mode)) {
			tst_brkm(TBROK, cleanup_fn,
			         "%s is not a block device", dev);
		}

		fd = SAFE_OPEN(cleanup_fn, dev, O_RDONLY);
		SAFE_IOCTL(cleanup_fn, fd, BLKGETSIZE64, &ltp_dev_size);
		SAFE_CLOSE(cleanup_fn, fd);
		ltp_dev_size = ltp_dev_size/1024/1024;

		if (acq_dev_size <= ltp_dev_size) {
			if (tst_fill_file(dev, 0, 1024, 512)) {
				tst_brkm(TBROK | TERRNO, cleanup_fn,
					"Failed to clear the first 512k of %s", dev);
			}

			return dev;
		}

		tst_resm(TINFO, "Skipping $LTP_DEV size %"PRIu64"MB, requested size %uMB",
				ltp_dev_size, acq_dev_size);
	}

	if (tst_fill_file(DEV_FILE, 0, 1024, 1024 * acq_dev_size)) {
		tst_brkm(TBROK | TERRNO, cleanup_fn,
		         "Failed to create " DEV_FILE);

	}

	if (find_free_loopdev())
		return NULL;

	attach_device(cleanup_fn, dev_path, DEV_FILE);

	device_acquired = 1;

	return dev_path;
}
Esempio n. 15
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);
}
Esempio n. 16
0
int main(int ac, char **av)
{
	int lc;
	const char *msg;
	struct stat buf;
	int i, links;
	char lname[255];

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

	if (links_arg) {
		nlinks = atoi(links_arg);

		if (nlinks == 0) {
			tst_brkm(TBROK, NULL,
			         "nlinks is not a positive number");
		}

		if (nlinks > 1000) {
			tst_resm(TINFO,
				 "nlinks > 1000 - may get errno:%d (EMLINK)",
				 EMLINK);
		}
	}

	setup();

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

		if (nlinks)
			links = nlinks;
		else
			links = (lc % 90) + 10;

		/* Create links - 1 hardlinks so that the st_nlink == links */
		for (i = 1; i < links; i++) {
			sprintf(lname, "%s%d", fname, i);
			TEST(link(fname, lname));

			if (TEST_RETURN == -1) {
				tst_brkm(TFAIL | TTERRNO, cleanup,
					 "link(%s, %s) Failed", fname, lname);
			}
		}

		SAFE_STAT(cleanup, fname, &buf);

		if (buf.st_nlink != (nlink_t)links) {
			tst_resm(TFAIL, "Wrong number of links for "
			         "'%s' have %i, should be %i",
				 fname, (int)buf.st_nlink, links);
			goto unlink;
		}

		for (i = 1; i < links; i++) {
			sprintf(lname, "%s%d", fname, i);
			SAFE_STAT(cleanup, lname, &buf);
			if (buf.st_nlink != (nlink_t)links) {
				tst_resm(TFAIL,
				         "Wrong number of links for "
					 "'%s' have %i, should be %i",
					 lname, (int)buf.st_nlink, links);
				goto unlink;
			}
		}

		tst_resm(TPASS, "link() passed and linkcounts=%d match", links);

unlink:
		for (i = 1; i < links; i++) {
			sprintf(lname, "%s%d", fname, i);
			SAFE_UNLINK(cleanup, lname);
		}
	}

	cleanup();
	tst_exit();
}