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"); }