static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
/*
* create a file and use it to test whether chroot() is setting
* ENOTDIR if the argument is not a directory.
*/
(void)sprintf(fname, "tfile_%d", getpid());
fd = creat(fname, 0777);
if (fd == -1)
tst_brkm(TBROK, cleanup, "Failed to creat a temp file");
#if !defined(UCLINUX)
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].dir = bad_addr;
#endif
/*
* create two symbolic directory who point to each other to
* test ELOOP.
*/
SAFE_SYMLINK(cleanup, "sym_dir1/", "sym_dir2");
SAFE_SYMLINK(cleanup, "sym_dir2/", "sym_dir1");
}
static void setup(void)
{
int fd;
tst_require_root(NULL);
tst_tmpdir();
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
fd = SAFE_CREAT(cleanup, TEST_FILE5, 0777);
SAFE_CLOSE(cleanup, fd);
if (acct(TEST_FILE5) == -1) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"BSD process accounting is not configured in "
"this kernel");
} else {
tst_brkm(TBROK | TERRNO, cleanup, "acct failed unexpectedly");
}
}
/* turn off acct, so we are in a known state */
if (acct(NULL) == -1) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"BSD process accounting is not configured in "
"this kernel");
} else {
tst_brkm(TBROK | TERRNO, cleanup, "acct(NULL) failed");
}
}
/* ELOOP SETTING */
SAFE_SYMLINK(cleanup, TEST_FILE6, "test_file_eloop2");
SAFE_SYMLINK(cleanup, "test_file_eloop2", TEST_FILE6);
/* ENAMETOOLONG SETTING */
memset(nametoolong, 'a', PATH_MAX+1);
/* EROFS SETTING */
tst_mkfs(NULL, device, fstype, NULL);
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fstype, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
/* Create a file in the file system, then remount it as read-only */
fd = SAFE_CREAT(cleanup, TEST_FILE8, 0644);
SAFE_CLOSE(cleanup, fd);
if (mount(device, "mntpoint", fstype,
MS_REMOUNT | MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
}
static void setup(void)
{
int i;
const char *fs_type;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
SAFE_MKDIR(cleanup, "test_dir", DIR_MODE);
dir_fd = SAFE_OPEN(cleanup, "test_dir", O_DIRECTORY);
SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
SAFE_MKDIR(cleanup, "test_dir/test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop",
"test_dir/test_eloop/test_eloop");
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limits in kernel is hardwired to 40.
*/
for (i = 0; i < 43; i++)
strcat(test_file2, "/test_eloop");
tst_mkfs(cleanup, device, fs_type, NULL);
SAFE_MKDIR(cleanup, "test_dir/mntpoint", DIR_MODE);
if (mount(device, "test_dir/mntpoint", fs_type, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag_dir = 1;
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fs_type, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag_cur = 1;
TEST_EXP_ENOS(exp_enos);
}
static void setup(void)
{
int fd;
tst_require_root(NULL);
check_acct_in_kernel();
tst_tmpdir();
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
fd = SAFE_CREAT(cleanup, TEST_FILE5, 0777);
SAFE_CLOSE(cleanup, fd);
if (acct(TEST_FILE5) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "acct failed unexpectedly");
/* turn off acct, so we are in a known state */
if (acct(NULL) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "acct(NULL) failed");
/* ELOOP SETTING */
SAFE_SYMLINK(cleanup, TEST_FILE6, "test_file_eloop2");
SAFE_SYMLINK(cleanup, "test_file_eloop2", TEST_FILE6);
/* ENAMETOOLONG SETTING */
memset(nametoolong, 'a', PATH_MAX+1);
/* EROFS SETTING */
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);
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fs_type, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
/* Create a file in the file system, then remount it as read-only */
fd = SAFE_CREAT(cleanup, TEST_FILE8, 0644);
SAFE_CLOSE(cleanup, fd);
if (mount(device, "mntpoint", fs_type,
MS_REMOUNT | MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
}
void setup(void)
{
struct passwd *ltpuser;
char *bad_addr;
struct rlimit rlim;
sigset_t signalset;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root();
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
SAFE_TOUCH(cleanup, TEST_FILE1, NEW_MODE, NULL);
SAFE_TOUCH(cleanup, "t_file", FILE_MODE, NULL);
#if !defined(UCLINUX)
test_cases[2].pathname = (char *)get_high_address();
bad_addr = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
test_cases[3].pathname = bad_addr;
#endif
memset(long_pathname, 'a', PATH_MAX + 1);
SAFE_MKDIR(cleanup, TEST_DIR1, DIR_MODE);
SAFE_TOUCH(cleanup, TEST_FILE3, FILE_MODE, NULL);
SAFE_SYMLINK(cleanup, TEST_SYM1, TEST_SYM2);
SAFE_SYMLINK(cleanup, TEST_SYM2, TEST_SYM1);
rlim.rlim_cur = MAX_FSIZE;
rlim.rlim_max = MAX_FSIZE;
SAFE_SETRLIMIT(cleanup, RLIMIT_FSIZE, &rlim);
sigemptyset(&signalset);
sigaddset(&signalset, SIGXFSZ);
TEST(sigprocmask(SIG_BLOCK, &signalset, NULL));
if (TEST_RETURN != 0)
tst_brkm(TBROK | TTERRNO, cleanup, "sigprocmask");
}
static void setup(void)
{
int fd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
sprintf(fname, "fname_%d", getpid());
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0644);
SAFE_CLOSE(cleanup, fd);
sprintf(sname, "symlink_%d", getpid());
SAFE_SYMLINK(cleanup, fname, sname);
sprintf(dir, "dir_%d", getpid());
SAFE_MKDIR(cleanup, dir, 0755);
if ((fd_notify = myfanotify_init(FAN_CLASS_NOTIF | FAN_NONBLOCK,
O_RDONLY)) < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"fanotify is not configured in this kernel.");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"fanotify_init failed");
}
}
}
static void setup(void)
{
tst_require_root();
if ((tst_kvercmp(2, 6, 34)) < 0) {
tst_brkm(TCONF, NULL, "This test can only run on kernels "
"that are 2.6.34 or higher");
}
tst_sig(NOFORK, DEF_HANDLER, NULL);
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);
SAFE_SYMLINK(cleanup, MNTPOINT, SYMLINK);
TEST_PAUSE;
}
static void setup(void)
{
struct passwd *pw;
pw = SAFE_GETPWNAM("nobody");
uid = pw->pw_uid;
memset(longpathname, 'a', sizeof(longpathname) - 1);
SAFE_TOUCH(FNAME1, 0333, NULL);
SAFE_TOUCH(DNAME, 0644, NULL);
SAFE_SYMLINK(SNAME1, SNAME2);
SAFE_SYMLINK(SNAME2, SNAME1);
}
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);
}
}
void setup(void)
{
int i;
int fd;
tst_require_root(NULL);
tst_mkfs(NULL, device, fstype, NULL);
tst_sig(FORK, DEF_HANDLER, cleanup);
ltpuser = getpwnam("nobody");
if (ltpuser == NULL)
tst_brkm(TBROK | TERRNO, NULL, "getpwnam(\"nobody\") failed");
if (seteuid(ltpuser->pw_uid) == -1)
tst_brkm(TBROK | TERRNO, NULL, "seteuid(%d) failed",
ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
bad_addr = mmap(0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
if (bad_addr == MAP_FAILED)
tst_brkm(TBROK | TERRNO, cleanup, "mmap failed");
test_cases[3].pathname = bad_addr;
SAFE_SYMLINK(cleanup, "test_eloop1", "test_eloop2");
SAFE_SYMLINK(cleanup, "test_eloop2", "test_eloop1");
SAFE_SETEUID(cleanup, 0);
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fstype, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
for (i = 0; i < TST_TOTAL; i++)
if (test_cases[i].setupfunc != NULL)
test_cases[i].setupfunc();
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
SAFE_SYMLINK(cleanup, TEST_SYMLINK, "statfs_symlink_2");
SAFE_SYMLINK(cleanup, "statfs_symlink_2", TEST_SYMLINK);
memset(nametoolong, 'a', PATH_MAX+1);
SAFE_TOUCH(cleanup, TEST_FILE, 0644, NULL);
test_cases[0].path = SAFE_MMAP(cleanup, NULL, 1, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
}
static void setup(void)
{
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);
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
TEST_PAUSE;
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_TOUCH(cleanup, TEST_FILE, 0644, NULL);
memset(nametoolong, 'a', PATH_MAX+1);
SAFE_TOUCH(cleanup, TEST_EXIST, 0644, NULL);
SAFE_SYMLINK(cleanup, TEST_ELOOP, "test_file_eloop2");
SAFE_SYMLINK(cleanup, "test_file_eloop2", TEST_ELOOP);
SAFE_MKDIR(cleanup, "./tmp", DIR_MODE);
SAFE_TOUCH(cleanup, TEST_EACCES, 0666, NULL);
tst_mkfs(cleanup, device, fs_type, NULL);
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fs_type, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
max_hardlinks = tst_fs_fill_hardlinks(cleanup, "emlink_dir");
}
/*
* void
* setup(void) - performs all ONE TIME setup for this test.
* Exit the test program on receipt of unexpected signals.
* Create a temporary directory and change directory to it.
* Invoke iividual test setup functions according to the order
* set in struct. definition.
*/
void setup(void)
{
int i;
tst_sig(FORK, DEF_HANDLER, cleanup);
test_home = get_current_dir_name();
tst_require_root(NULL);
TEST_PAUSE;
tst_tmpdir();
tst_mkfs(NULL, device, fstype, NULL);
SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE);
/*
* mount a read-only file system for test EROFS
*/
if (mount(device, MNT_POINT, fstype, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
bad_addr = mmap(0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
if (bad_addr == MAP_FAILED)
tst_brkm(TBROK | TERRNO, cleanup, "mmap failed");
test_cases[3].pathname = bad_addr;
for (i = 0; i < TST_TOTAL; i++)
if (test_cases[i].setupfunc != NULL)
test_cases[i].setupfunc();
/*
* create two symbolic links who point to each other for
* test ELOOP.
*/
SAFE_SYMLINK(cleanup, "test_file4", "test_file5");
SAFE_SYMLINK(cleanup, "test_file5", "test_file4");
}
static void setup(void)
{
SAFE_TOUCH("testfile", 0644, NULL);
SAFE_SYMLINK("testfile", "symlink");
set_xattr("testfile", SECURITY_KEY1);
set_xattr("symlink", SECURITY_KEY2);
}
static void setup(void)
{
int i;
const char *fs_type;
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
tst_mkfs(cleanup, device, fs_type, NULL, NULL);
SAFE_MKDIR(cleanup, MNTPOINT, DIR_MODE);
if (mount(device, MNTPOINT, fs_type, 0, NULL) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
SAFE_MKDIR(cleanup, TESTDIR5, DIR_MODE);
if (mount(device, MNTPOINT, fs_type, MS_REMOUNT | MS_RDONLY,
NULL) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_MKDIR(cleanup, TESTDIR, DIR_MODE);
SAFE_TOUCH(cleanup, TESTFILE, FILE_MODE, NULL);
memset(longpathname, 'a', PATH_MAX + 1);
SAFE_TOUCH(cleanup, TESTFILE2, FILE_MODE, NULL);
#if !defined(UCLINUX)
test_cases[4].dir = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
#endif
/*
* NOTE: the ELOOP test is written based on that the
* consecutive symlinks limit in kernel is hardwired
* to 40.
*/
SAFE_MKDIR(cleanup, "loopdir", DIR_MODE);
SAFE_SYMLINK(cleanup, "../loopdir", "loopdir/loopdir");
for (i = 0; i < 43; i++)
strcat(looppathname, TESTDIR4);
}
void setup(void)
{
TEST_PAUSE;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SAFE_FILE_PRINTF(cleanup, TEST_FILE, "test file");
SAFE_SYMLINK(cleanup, TEST_FILE, SFILE);
}
static void setup(void)
{
ltpuser = SAFE_GETPWNAM("nobody");
SAFE_MKDIR(TEST_FILE, MODE2);
memset(long_name, 'a', PATH_MAX+1);
SAFE_TOUCH("file1", MODE1, NULL);
SAFE_MKDIR("dir6", MODE2);
SAFE_SYMLINK(TEST7_FILE, "test_file_eloop2");
SAFE_SYMLINK("test_file_eloop2", TEST7_FILE);
SAFE_MKFS(tst_device->dev, tst_device->fs_type, NULL, NULL);
SAFE_MKDIR("mntpoint", 0777);
SAFE_MOUNT(tst_device->dev, "mntpoint", tst_device->fs_type,
MS_RDONLY, NULL);
mount_flag = 1;
}
void setup(void)
{
struct passwd *ltpuser;
int i;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
SAFE_MKDIR(cleanup, DIR_TEMP, MODE_RWX);
SAFE_TOUCH(cleanup, TEST_FILE1, 0666, NULL);
SAFE_SYMLINK(cleanup, TEST_FILE1, SYM_FILE1);
SAFE_CHMOD(cleanup, DIR_TEMP, FILE_MODE);
SAFE_TOUCH(cleanup, TEST_FILE2, 0666, NULL);
SAFE_SYMLINK(cleanup, TEST_FILE2, SYM_FILE2);
memset(longpathname, 'a', PATH_MAX + 1);
SAFE_TOUCH(cleanup, TEST_FILE3, 0666, NULL);
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limit in kernel is hardwired to 40.
*/
SAFE_MKDIR(cleanup, "test_eloop", MODE_RWX);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(elooppathname, ELOOPFILE);
}
void setup(void)
{
struct passwd *ltpuser;
char *bad_addr;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
SAFE_TOUCH(cleanup, TEST_FILE1, NEW_MODE, NULL);
SAFE_TOUCH(cleanup, "t_file", FILE_MODE, NULL);
#if !defined(UCLINUX)
test_cases[2].pathname = (char *)get_high_address();
bad_addr = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
test_cases[3].pathname = bad_addr;
#endif
memset(long_pathname, 'a', PATH_MAX + 1);
SAFE_MKDIR(cleanup, TEST_DIR1, DIR_MODE);
SAFE_TOUCH(cleanup, TEST_FILE3, FILE_MODE, NULL);
SAFE_SYMLINK(cleanup, TEST_SYM1, TEST_SYM2);
SAFE_SYMLINK(cleanup, TEST_SYM2, TEST_SYM1);
}
static void setup(void)
{
int fd;
sprintf(fname, "fname_%d", getpid());
fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0644);
SAFE_CLOSE(fd);
sprintf(sname, "symlink_%d", getpid());
SAFE_SYMLINK(fname, sname);
sprintf(dir, "dir_%d", getpid());
SAFE_MKDIR(dir, 0755);
fd_notify = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF | FAN_NONBLOCK,
O_RDONLY);
}
static void setup(void)
{
int i;
const char *fs_type;
if (tst_kvercmp(2, 6, 16) < 0) {
tst_brkm(TCONF, NULL, "This test can only run on kernels "
"that are 2.6.16 and higher");
}
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
tst_mkfs(cleanup, device, fs_type, NULL, NULL);
TEST_PAUSE;
/*
* mount a read-only file system for EROFS test
*/
SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE);
if (mount(device, MNT_POINT, fs_type, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
dir_fd = SAFE_OPEN(cleanup, MNT_POINT, O_DIRECTORY);
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limits in kernel is hardwired to 40.
*/
SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(elooppathname, ELOPFILE);
}
static void setup(void)
{
int fd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root();
TEST_PAUSE;
tst_tmpdir();
if ((fd = open(TESTFILE, O_RDWR | O_CREAT, FILE_MODE)) == -1) {
tst_brkm(TBROK, cleanup, "open failed");
}
SAFE_CLOSE(cleanup, fd);
SAFE_SYMLINK(cleanup, TESTFILE, SFILE);
}
static void setup(void)
{
int i;
struct passwd *ltpuser;
const char *fs_type;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
tst_mkfs(cleanup, device, fs_type, NULL);
TEST_PAUSE;
/* mount a read-only file system for EROFS test */
SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE);
if (mount(device, MNT_POINT, fs_type, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
SAFE_MKDIR(cleanup, DIR_TEMP, DIR_TEMP_MODE);
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limits in kernel is hardwired to 40.
*/
SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(elooppathname, ELOPFILE);
}
static void setup(void)
{
int i;
const char *fs_type;
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
SAFE_MKDIR(cleanup, TEST_FILE1, DIR_MODE);
SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(test_file4, "/test_eloop");
tst_mkfs(cleanup, device, fs_type, NULL);
SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE);
if (mount(device, MNT_POINT, fs_type, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_TOUCH(cleanup, TEST_FILE2, 0644, NULL);
if (mount(device, MNT_POINT, fs_type,
MS_REMOUNT | MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
}
static void setup(void)
{
int i;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
tst_tmpdir();
TEST_EXP_ENOS(exp_enos);
TEST_PAUSE;
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);
SAFE_MKDIR(cleanup, MNTPOINT, 0755);
if (mount(device, MNTPOINT, fs_type, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_TOUCH(cleanup, TEST_EROFS, 0644, NULL);
SAFE_MKDIR(cleanup, TEST_EMLINK, 0755);
max_subdirs = tst_fs_fill_subdirs(cleanup, "emlink_dir");
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limits in kernel is hardwired to 40.
*/
SAFE_MKDIR(cleanup, "test_eloop", 0644);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(elooppathname, ELOPFILE);
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(NULL, nobody_uid);
SAFE_SETUID(NULL, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
if (tst_fill_file(TESTFILE, 'a', 1024, 1))
tst_brkm(TBROK, cleanup, "Failed to create " TESTFILE);
SAFE_SYMLINK(cleanup, TESTFILE, SFILE);
user_id = getuid();
group_id = getgid();
}
static void setup(void)
{
int i;
const char *fs_type;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_EXP_ENOS(exp_enos);
TEST_PAUSE;
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
memset(long_dir, 'a', PATH_MAX+1);
SAFE_TOUCH(cleanup, TST_EEXIST, MODE, NULL);
SAFE_TOUCH(cleanup, "tst_enotdir", MODE, NULL);
SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(loop_dir, "/test_eloop");
tst_mkfs(cleanup, device, fs_type, NULL);
SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE);
if (mount(device, MNT_POINT, fs_type, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
}
int main(int ac, char **av)
{
DIR *ddir, *opendir();
int fd;
char *filname = "chdirtest";
char *filenames[3];
int lc;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
TEST_EXP_ENOS(exp_enos);
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
SAFE_CHDIR(cleanup, testdir);
fd = SAFE_CREAT(cleanup, filname, 0000);
SAFE_CLOSE(cleanup, fd);
if ((ddir = opendir(".")) == NULL)
tst_brkm(TBROK | TERRNO, cleanup, "opendir(.) failed");
filenames[0] = ".";
filenames[1] = "..";
filenames[2] = filname;
checknames(filenames, sizeof(filenames) / sizeof(filenames[0]),
ddir);
closedir(ddir);
TEST(chdir(filname));
if (TEST_RETURN != -1)
tst_resm(TFAIL, "call succeeded unexpectedly");
else if (TEST_ERRNO != ENOTDIR)
tst_resm(TFAIL | TTERRNO,
"failed unexpectedly; wanted ENOTDIR");
else
tst_resm(TPASS, "failed as expected with ENOTDIR");
if (unlink(filname) == -1)
tst_brkm(TBROK | TERRNO, cleanup,
"Couldn't remove file");
SAFE_CHDIR(cleanup, "..");
/* ELOOP */
SAFE_SYMLINK(cleanup, "test_eloop1", "test_eloop2");
SAFE_SYMLINK(cleanup, "test_eloop2", "test_eloop1");
TEST(chdir("test_eloop1"));
if (TEST_RETURN != -1) {
tst_resm(TFAIL, "call succeeded unexpectedly");
} else if (TEST_ERRNO != ELOOP) {
tst_resm(TFAIL | TTERRNO,
"failed unexpectedly; wanted ELOOP");
} else {
tst_resm(TPASS, "failed as expected with ELOOP");
}
SAFE_UNLINK(cleanup, "test_eloop1");
SAFE_UNLINK(cleanup, "test_eloop2");
}
cleanup();
tst_exit();
}
static void setup(void)
{
long link_max = 0;
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);
tst_tmpdir();
TEST_PAUSE;
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_TOUCH(cleanup, TEST_FILE, 0644, NULL);
memset(nametoolong, 'a', PATH_MAX+1);
SAFE_TOUCH(cleanup, TEST_EXIST, 0644, NULL);
SAFE_SYMLINK(cleanup, TEST_ELOOP, "test_file_eloop2");
SAFE_SYMLINK(cleanup, "test_file_eloop2", TEST_ELOOP);
SAFE_MKDIR(cleanup, "./tmp", DIR_MODE);
SAFE_TOUCH(cleanup, TEST_EACCES, 0666, NULL);
tst_mkfs(NULL, device, fstype, NULL);
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fstype, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_TOUCH(cleanup, TEST_EMLINK, 0666, NULL);
fs_type = tst_fs_type(cleanup, "mntpoint");
if (fs_type == TST_XFS_MAGIC)
return;
while (1) {
sprintf(lname, "%s%ld", BASENAME, ++link_max);
TEST(link(TEST_EMLINK, lname));
if (TEST_RETURN == -1) {
switch (TEST_ERRNO) {
case EMLINK:
tst_resm(TINFO, "for %s the max links is %ld",
fstype, link_max);
break;
default:
tst_brkm(TBROK | TTERRNO, cleanup,
"Unexpected error: ");
break;
}
break;
}
}
}
static void setup(void)
{
char *tmpdir;
const char *fs_type;
int i;
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_brkm(TCONF, NULL,
"This test can only run on kernels that are "
"2.6.16 and higher");
}
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
TEST_PAUSE;
SAFE_TOUCH(cleanup, TESTFILE, FILEMODE, NULL);
SAFE_TOUCH(cleanup, TESTFILE2, FILEMODE, NULL);
tmpdir = tst_get_tmpdir();
sprintf(absoldpath, "%s/%s", tmpdir, TESTFILE2);
sprintf(absnewpath, "%s/%s", tmpdir, NEW_TESTFILE2);
free(tmpdir);
SAFE_MKDIR(cleanup, TESTDIR, DIRMODE);
SAFE_TOUCH(cleanup, TESTFILE3, FILEMODE, NULL);
SAFE_MKDIR(cleanup, NEW_TESTDIR, DIRMODE);
olddirfd = SAFE_OPEN(cleanup, TESTDIR, O_DIRECTORY);
newdirfd = SAFE_OPEN(cleanup, NEW_TESTDIR, O_DIRECTORY);
filefd = SAFE_OPEN(cleanup, TESTFILE4,
O_RDWR | O_CREAT, FILEMODE);
/*
* NOTE: the ELOOP test is written based on that the
* consecutive symlinks limit in kernel is hardwired
* to 40.
*/
SAFE_MKDIR(cleanup, "loopdir", DIRMODE);
SAFE_SYMLINK(cleanup, "../loopdir", "loopdir/loopdir");
for (i = 0; i < 43; i++)
strcat(looppathname, TESTDIR2);
tst_mkfs(cleanup, device, fs_type, NULL, NULL);
SAFE_MKDIR(cleanup, MNTPOINT, DIRMODE);
if (mount(device, MNTPOINT, fs_type, 0, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_TOUCH(cleanup, TESTFILE5, FILEMODE, NULL);
if (mount(device, MNTPOINT, fs_type,
MS_REMOUNT | MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
SAFE_MKDIR(cleanup, TESTDIR3, DIRMODE);
max_subdirs = tst_fs_fill_subdirs(cleanup, "testemlinkdir");
}
