static void test(void)
{
int status;
/* unshares the mount ns */
if (unshare(CLONE_NEWNS) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "unshare failed");
/* makes sure parent mounts/umounts have no effect on a real system */
SAFE_MOUNT(cleanup, "none", "/", "none", MS_REC|MS_PRIVATE, NULL);
/* bind mounts DIRA to itself */
SAFE_MOUNT(cleanup, DIRA, DIRA, "none", MS_BIND, NULL);
/* makes mount DIRA shared */
SAFE_MOUNT(cleanup, "none", DIRA, "none", MS_SHARED, NULL);
if (do_clone_tests(CLONE_NEWNS, child_func, NULL, NULL, NULL) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "clone failed");
/* waits for child to make a slave mount */
TST_CHECKPOINT_PARENT_WAIT(cleanup, &checkpoint1);
/* bind mounts DIRB to DIRA making contents of DIRB visible
* in DIRA */
SAFE_MOUNT(cleanup, DIRB, DIRA, "none", MS_BIND, NULL);
TST_CHECKPOINT_SIGNAL_CHILD(cleanup, &checkpoint2);
TST_CHECKPOINT_PARENT_WAIT(cleanup, &checkpoint1);
SAFE_UMOUNT(cleanup, DIRA);
TST_CHECKPOINT_SIGNAL_CHILD(cleanup, &checkpoint2);
TST_CHECKPOINT_PARENT_WAIT(cleanup, &checkpoint1);
/* checks that slave mount doesn't propagate to shared mount */
if ((access(DIRA"/A", F_OK) == 0) && (access(DIRA"/B", F_OK) == -1))
tst_resm(TPASS, "propagation from slave mount passed");
else
tst_resm(TFAIL, "propagation form slave mount failed");
TST_CHECKPOINT_SIGNAL_CHILD(cleanup, &checkpoint2);
SAFE_WAIT(cleanup, &status);
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0)
tst_resm(TPASS, "propagation to slave mount passed");
else
tst_resm(TFAIL, "propagation to slave mount failed");
}
if (WIFSIGNALED(status)) {
tst_resm(TBROK, "child was killed with signal %s",
tst_strsig(WTERMSIG(status)));
return;
}
SAFE_UMOUNT(cleanup, DIRA);
}
static void test(void)
{
int status;
/* unshares the mount ns */
if (unshare(CLONE_NEWNS) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "unshare failed");
/* makes sure parent mounts/umounts have no effect on a real system */
SAFE_MOUNT(cleanup, "none", "/", "none", MS_REC|MS_PRIVATE, NULL);
/* bind mounts DIRA to itself */
SAFE_MOUNT(cleanup, DIRA, DIRA, "none", MS_BIND, NULL);
/* makes mount DIRA shared */
SAFE_MOUNT(cleanup, "none", DIRA, "none", MS_SHARED, NULL);
if (do_clone_tests(CLONE_NEWNS, child_func, NULL, NULL, NULL) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "clone failed");
/* bind mounts DIRB to DIRA making contents of DIRB visible
* in DIRA */
SAFE_MOUNT(cleanup, DIRB, DIRA, "none", MS_BIND, NULL);
TST_SAFE_CHECKPOINT_WAKE_AND_WAIT(cleanup, 0);
SAFE_UMOUNT(cleanup, DIRA);
TST_SAFE_CHECKPOINT_WAKE_AND_WAIT(cleanup, 0);
if (access(DIRA"/B", F_OK) == 0)
tst_resm(TPASS, "shared mount in child passed");
else
tst_resm(TFAIL, "shared mount in child failed");
TST_SAFE_CHECKPOINT_WAKE(cleanup, 0);
SAFE_WAIT(cleanup, &status);
if (WIFEXITED(status)) {
if ((WEXITSTATUS(status) == 0))
tst_resm(TPASS, "shared mount in parent passed");
else
tst_resm(TFAIL, "shared mount in parent failed");
}
if (WIFSIGNALED(status)) {
tst_resm(TBROK, "child was killed with signal %s",
tst_strsig(WTERMSIG(status)));
return;
}
SAFE_UMOUNT(cleanup, DIRA);
}
int main(int ac, char **av)
{
int lc;
int tc;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
SAFE_MOUNT(cleanup, device, MNTPOINT, fs_type, 0, NULL);
mount_flag = 1;
for (tc = 0; tc < TST_TOTAL; tc++)
test_umount2(tc);
if (mount_flag) {
SAFE_UMOUNT(cleanup, MNTPOINT);
mount_flag = 0;
}
}
cleanup();
tst_exit();
}
static void setup(void)
{
unsigned int i;
int fd;
SAFE_MKDIR(TMP_DIR, 0664);
SAFE_MOUNT(TMP_DIR, TMP_DIR, "tmpfs", 0, NULL);
fd = SAFE_OPEN(TEST_FILE, O_RDWR | O_CREAT, 0664);
/* Writing 40 KB of random data into this file [32 * 1280 = 40960] */
for (i = 0; i < 1280; i++)
SAFE_WRITE(1, fd, STR, strlen(STR));
SAFE_FSTAT(fd, &st);
/* Map the input file into shared memory */
sfile = SAFE_MMAP(NULL, st.st_size,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
/* Map the input file into private memory. MADV_HUGEPAGE only works
* with private anonymous pages */
amem = SAFE_MMAP(NULL, st.st_size,
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
SAFE_CLOSE(fd);
}
static void setup(void)
{
int ret;
SAFE_MKDIR(mntpoint, DIR_MODE);
SAFE_MOUNT(tst_device->dev, mntpoint, tst_device->fs_type, 0, NULL);
mount_flag = 1;
sprintf(fname, "%s/tfile_%d", mntpoint, getpid());
fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
ret = write(fd, fname, 1);
if (ret == -1) {
tst_brk(TBROK | TERRNO,
"write(%d, %s, 1) failed", fd, fname);
}
/* close the file we have open */
SAFE_CLOSE(fd);
fd_notify = myinotify_init();
if (fd_notify < 0) {
if (errno == ENOSYS)
tst_brk(TCONF,
"inotify is not configured in this kernel.");
else
tst_brk(TBROK | TERRNO,
"inotify_init failed");
}
tst_umount(mntpoint);
mount_flag = 0;
}
static void setup(void)
{
const char *fs_opts[3] = {"-b", "1024", NULL};
tst_sig(FORK, DEF_HANDLER, NULL);
tst_require_root();
TEST_PAUSE;
tst_tmpdir();
TST_CHECKPOINT_INIT(tst_rmdir);
page_size = getpagesize();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
tst_mkfs(cleanup, device, fs_type, fs_opts, "10240");
SAFE_MKDIR(cleanup, MNTPOINT, 0755);
/*
* Disable ext4 delalloc feature, so block will be allocated
* as soon as possible
*/
SAFE_MOUNT(cleanup, device, MNTPOINT, fs_type, 0, "nodelalloc");
mount_flag = 1;
SAFE_CHDIR(cleanup, MNTPOINT);
chdir_flag = 1;
}
static void setup(void)
{
check_hugepage();
hugepagesize = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
init_sys_sz_paths();
if (opt_sysfs) {
path = path_sys_sz_huge;
pathover = path_sys_sz_over;
} else {
path = PATH_PROC_HUGE;
pathover = PATH_PROC_OVER;
}
if (opt_alloc) {
size = atoi(opt_alloc);
length = (size + size * 0.5) * 2;
}
if (opt_shmid) {
SAFE_FILE_SCANF(PATH_SHMMAX, "%llu", &shmmax);
if (shmmax < (unsigned long long)(length / 2 * hugepagesize)) {
restore_shmmax = 1;
SAFE_FILE_PRINTF(PATH_SHMMAX, "%ld",
(length / 2 * hugepagesize));
}
}
SAFE_FILE_SCANF(path, "%ld", &nr_hugepages);
tst_res(TINFO, "original nr_hugepages is %ld", nr_hugepages);
/* Reset. */
SAFE_FILE_PRINTF(path, "%ld", size);
restore_nr_hgpgs = 1;
if (access(pathover, F_OK)) {
tst_brk(TCONF, "file %s does not exist in the system",
pathover);
}
SAFE_FILE_SCANF(pathover, "%ld", &nr_overcommit_hugepages);
tst_res(TINFO, "original nr_overcommit_hugepages is %ld",
nr_overcommit_hugepages);
/* Reset. */
SAFE_FILE_PRINTF(pathover, "%ld", size);
restore_overcomm_hgpgs = 1;
SAFE_MKDIR(MOUNT_DIR, 0700);
SAFE_MOUNT(NULL, MOUNT_DIR, "hugetlbfs", 0, NULL);
mounted = 1;
if (opt_shmid) {
/* Use /proc/meminfo to generate an IPC key. */
key = ftok(PATH_MEMINFO, strlen(PATH_MEMINFO));
if (key == -1)
tst_brk(TBROK | TERRNO, "ftok");
}
}
static void setup(void)
{
SAFE_MKDIR(MOUNT_NAME, 0755);
SAFE_MOUNT(MOUNT_NAME, MOUNT_NAME, "none", MS_BIND, NULL);
mount_created = 1;
SAFE_CHDIR(MOUNT_NAME);
SAFE_MKDIR(DIR_NAME, 0755);
sprintf(fname, "tfile_%d", getpid());
SAFE_FILE_PRINTF(fname, "1");
}
static void setup(void)
{
SAFE_MKDIR(mntpoint, 0755);
SAFE_MKFS(tst_device->dev, "xfs", NULL, NULL);
SAFE_MOUNT(tst_device->dev, mntpoint, "xfs", 0, "usrquota");
mount_flag = 1;
test_id = geteuid();
}
static void setup(void)
{
struct passwd *pw;
SAFE_MKFS(tst_device->dev, tst_device->fs_type, NULL, NULL);
SAFE_MKDIR(MNTPOINT, 0775);
SAFE_MOUNT(tst_device->dev, MNTPOINT, tst_device->fs_type, 0, NULL);
mount_flag = 1;
pw = SAFE_GETPWNAM("nobody");
SAFE_SETEUID(pw->pw_uid);
}
static void prepare_device(void)
{
if (tst_test->format_device) {
SAFE_MKFS(tdev.dev, tdev.fs_type, tst_test->dev_fs_opts,
tst_test->dev_extra_opt);
}
if (tst_test->mount_device) {
SAFE_MOUNT(tdev.dev, tst_test->mntpoint, tdev.fs_type,
tst_test->mnt_flags, tst_test->mnt_data);
mntpoint_mounted = 1;
}
}
static void test(void)
{
/* unshares the mount ns */
if (unshare(CLONE_NEWNS) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "unshare failed");
/* makes sure mounts/umounts have no effect on a real system */
SAFE_MOUNT(cleanup, "none", "/", "none", MS_REC|MS_PRIVATE, NULL);
/* bind mounts DIRA to itself */
SAFE_MOUNT(cleanup, DIRA, DIRA, "none", MS_BIND, NULL);
/* makes mount DIRA unbindable */
SAFE_MOUNT(cleanup, "none", DIRA, "none", MS_UNBINDABLE, NULL);
/* tries to bind mount unbindable DIRA to DIRB which should fail */
if (mount(DIRA, DIRB, "none", MS_BIND, NULL) == -1) {
tst_resm(TPASS, "unbindable mount passed");
} else {
SAFE_UMOUNT(cleanup, DIRB);
tst_resm(TFAIL, "unbindable mount faled");
}
SAFE_UMOUNT(cleanup, DIRA);
}
void setup(void)
{
save_nr_hugepages();
if (!Hopt)
Hopt = tst_get_tmpdir();
SAFE_MOUNT("none", Hopt, "hugetlbfs", 0, NULL);
if (nr_opt)
hugepages = SAFE_STRTOL(nr_opt, 0, LONG_MAX);
set_sys_tune("nr_hugepages", hugepages, 1);
snprintf(TEMPFILE, sizeof(TEMPFILE), "%s/mmapfile%d", Hopt, getpid());
}
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;
}
static void test_umount2(int i)
{
SAFE_MOUNT(cleanup, device, MNTPOINT, fs_type, 0, NULL);
mount_flag = 1;
TEST(umount2_retry(test_cases[i].mntpoint, UMOUNT_NOFOLLOW));
if (test_cases[i].exp_errno != 0)
verify_failure(i);
else
verify_success(i);
if (mount_flag) {
if (tst_umount(MNTPOINT))
tst_brkm(TBROK, cleanup, "umount() failed");
mount_flag = 0;
}
}
static void setup(void)
{
struct statvfs fs;
srand(getpid());
tst_tmpdir();
SAFE_MKDIR(tst_rmdir, MOUNT_DIR, 0777);
TST_CHECKPOINT_INIT(tst_rmdir);
if (statvfs(".", &fs) == -1)
tst_brkm(TFAIL | TERRNO, tst_rmdir, "statvfs failed");
if ((fs.f_flag & MS_MANDLOCK))
return;
tst_resm(TINFO, "TMPDIR does not support mandatory locks");
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
/* the kernel returns EPERM when CONFIG_MANDATORY_FILE_LOCKING is not
* supported - to avoid false negatives, mount the fs first without
* flags and then remount it as MS_MANDLOCK */
tst_mkfs(cleanup, device, fs_type, NULL, NULL);
SAFE_MOUNT(cleanup, device, MOUNT_DIR, fs_type, 0, NULL);
mount_flag = 1;
if (mount(NULL, MOUNT_DIR, NULL, MS_REMOUNT|MS_MANDLOCK, NULL) == -1) {
if (errno == EPERM) {
tst_brkm(TCONF, cleanup, "Mandatory locking (likely) "
"not supported by this system");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"Remount with MS_MANDLOCK failed");
}
}
}
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);
SAFE_MOUNT(cleanup, device, MNT_POINT, fs_type, MS_RDONLY, NULL);
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)
{
const char *mount_flags[] = {"noatime", "relatime", NULL};
TEST_PAUSE;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SAFE_MKDIR(cleanup, MNTPOINT, DIR_MODE);
if (tst_path_has_mnt_flags(cleanup, NULL, mount_flags)) {
const char *fs_type;
if ((tst_kvercmp(2, 6, 30)) < 0) {
tst_resm(TCONF,
"MS_STRICTATIME flags for mount(2) needs kernel 2.6.30 "
"or higher");
skip_noatime = 1;
return;
}
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device) {
tst_resm(TINFO, "Failed to obtain block device");
skip_noatime = 1;
goto end;
}
tst_mkfs(cleanup, device, fs_type, NULL, NULL);
SAFE_MOUNT(cleanup, device, MNTPOINT, fs_type, MS_STRICTATIME, NULL);
mount_flag = 1;
}
end:
SAFE_FILE_PRINTF(cleanup, TEST_FILE, TEST_FILE);
}
void setup(void)
{
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SAFE_MKDIR(cleanup, mntpoint_src, DIR_MODE);
SAFE_MKDIR(cleanup, mntpoint_des, DIR_MODE);
if (dflag) {
tst_mkfs(NULL, device, fstype, NULL, NULL);
SAFE_MOUNT(cleanup, device, mntpoint_src, fstype, 0, NULL);
}
SAFE_FILE_PRINTF(cleanup, file_src, "TEST FILE");
TEST_PAUSE;
}
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;
}
static void verify_umount(void)
{
if (mount_flag != 1) {
SAFE_MOUNT(tst_device->dev, MNTPOINT,
tst_device->fs_type, 0, NULL);
mount_flag = 1;
}
TEST(umount(MNTPOINT));
if (TEST_RETURN != 0 && TEST_ERRNO == EBUSY) {
tst_res(TINFO, "umount() Failed with EBUSY "
"possibly some daemon (gvfsd-trash) "
"is probing newly mounted dirs");
}
if (TEST_RETURN != 0) {
tst_res(TFAIL | TTERRNO, "umount() Failed");
return;
}
tst_res(TPASS, "umount() Passed");
mount_flag = 0;
}
void verify_inotify(void)
{
int ret;
int len, i, test_num;
int test_cnt = 0;
SAFE_MOUNT(tst_device->dev, mntpoint, tst_device->fs_type, 0, NULL);
mount_flag = 1;
wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS);
if (wd < 0) {
tst_brk(TBROK | TERRNO,
"inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed.",
fd_notify, fname);
}
event_set[test_cnt] = IN_UNMOUNT;
test_cnt++;
event_set[test_cnt] = IN_IGNORED;
test_cnt++;
/*check exit code from inotify_rm_watch */
test_cnt++;
tst_res(TINFO, "umount %s", tst_device->dev);
TEST(tst_umount(mntpoint));
if (TEST_RETURN != 0) {
tst_brk(TBROK, "umount(2) Failed "
"while unmounting errno = %d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
mount_flag = 0;
len = read(fd_notify, event_buf, EVENT_BUF_LEN);
if (len < 0) {
tst_brk(TBROK | TERRNO,
"read(%d, buf, %zu) failed", fd_notify, EVENT_BUF_LEN);
}
/* check events */
test_num = 0;
i = 0;
while (i < len) {
struct inotify_event *event;
event = (struct inotify_event *)&event_buf[i];
if (test_num >= (test_cnt - 1)) {
tst_res(TFAIL,
"get unnecessary event: wd=%d mask=%x "
"cookie=%u len=%u",
event->wd, event->mask,
event->cookie, event->len);
} else if (event_set[test_num] == event->mask) {
tst_res(TPASS, "get event: wd=%d mask=%x"
" cookie=%u len=%u",
event->wd, event->mask,
event->cookie, event->len);
} else {
tst_res(TFAIL, "get event: wd=%d mask=%x "
"(expected %x) cookie=%u len=%u",
event->wd, event->mask,
event_set[test_num],
event->cookie, event->len);
}
test_num++;
i += EVENT_SIZE + event->len;
}
for (; test_num < test_cnt - 1; test_num++) {
tst_res(TFAIL, "don't get event: mask=%x ",
event_set[test_num]);
}
ret = myinotify_rm_watch(fd_notify, wd);
if (ret != -1 || errno != EINVAL)
tst_res(TFAIL | TERRNO,
"inotify_rm_watch (%d, %d) didn't return EINVAL",
fd_notify, wd);
else
tst_res(TPASS, "inotify_rm_watch (%d, %d) returned EINVAL",
fd_notify, wd);
}
static void run(unsigned int test_case)
{
/* Work in child process - needed to undo unshare and chroot */
if (SAFE_FORK()) {
tst_reap_children();
return;
}
/* pivot_root requires no shared mounts exist in process namespace */
TEST(unshare(CLONE_NEWNS | CLONE_FS));
if (TST_RET == -1)
tst_brk(TFAIL | TERRNO, "unshare failed");
/*
* Create an initial root dir. pivot_root doesn't work if the initial root
* dir is a initramfs, so use chroot to create a safe environment
*/
SAFE_MOUNT("none", "/", NULL, MS_REC|MS_PRIVATE, NULL);
SAFE_MOUNT("none", CHROOT_DIR, "tmpfs", 0, 0);
SAFE_CHROOT(CHROOT_DIR);
SAFE_MKDIR(NEW_ROOT, 0777);
/*
* pivot_root only works if new_root is a mount point, so mount a tmpfs
* unless testing for that fail mode
*/
if (test_cases[test_case].test_case != NEW_ROOT_ON_CURRENT_ROOT)
SAFE_MOUNT("none", NEW_ROOT, "tmpfs", 0, 0);
/*
* Create put_old under new_root, unless testing for that specific fail
* mode
*/
const char* actual_put_old = NULL;
if (test_cases[test_case].test_case == PUT_OLD_NOT_UNDERNEATH_NEW_ROOT) {
actual_put_old = PUT_OLD_BAD;
SAFE_MKDIR(PUT_OLD_FS, 0777);
SAFE_MOUNT("none", PUT_OLD_FS, "tmpfs", 0, 0);
SAFE_MKDIR(PUT_OLD_BAD, 0777);
} else {
actual_put_old = PUT_OLD;
if (test_cases[test_case].test_case == PUT_OLD_NOT_DIR)
SAFE_CREAT(PUT_OLD, 0777);
else
SAFE_MKDIR(PUT_OLD, 0777);
}
if (test_cases[test_case].test_case == NO_CAP_SYS_ADMIN) {
#ifdef HAVE_LIBCAP
drop_cap_sys_admin();
#else
tst_res(TCONF,
"System doesn't have POSIX capabilities support");
return;
#endif
}
TEST(syscall(__NR_pivot_root, NEW_ROOT, actual_put_old));
if (test_cases[test_case].test_case == NORMAL) {
if (TST_RET)
tst_res(TFAIL | TERRNO, "pivot_root failed");
else
tst_res(TPASS, "pivot_root succeeded");
return;
}
if (TST_RET == 0) {
tst_res(TFAIL, "pivot_root succeeded unexpectedly");
return;
}
if (errno != test_cases[test_case].expected_error) {
tst_res(TFAIL | TERRNO, "pivot_root failed with wrong errno");
return;
}
tst_res(TPASS | TERRNO, "pivot_root failed as expectedly");
}
static void umount2_verify(void)
{
int ret;
char buf[256];
const char *str = "abcdefghijklmnopqrstuvwxyz";
SAFE_MOUNT(cleanup, device, MNTPOINT, fs_type, 0, NULL);
mount_flag = 1;
fd = SAFE_CREAT(cleanup, MNTPOINT "/file", FILE_MODE);
TEST(umount2(MNTPOINT, MNT_DETACH));
if (TEST_RETURN != 0) {
tst_resm(TFAIL | TTERRNO, "umount2(2) Failed");
goto EXIT;
}
mount_flag = 0;
/* check the unavailability for new access */
ret = access(MNTPOINT "/file", F_OK);
if (ret != -1) {
tst_resm(TFAIL, "umount2(2) MNT_DETACH flag "
"performed abnormally");
goto EXIT;
}
/*
* check the old fd still points to the file
* in previous mount point and is available
*/
SAFE_WRITE(cleanup, 1, fd, str, strlen(str));
SAFE_CLOSE(cleanup, fd);
SAFE_MOUNT(cleanup, device, MNTPOINT, fs_type, 0, NULL);
mount_flag = 1;
fd = SAFE_OPEN(cleanup, MNTPOINT "/file", O_RDONLY);
memset(buf, 0, sizeof(buf));
SAFE_READ(cleanup, 1, fd, buf, strlen(str));
if (strcmp(str, buf)) {
tst_resm(TFAIL, "umount2(2) MNT_DETACH flag "
"performed abnormally");
goto EXIT;
}
tst_resm(TPASS, "umount2(2) Passed");
EXIT:
SAFE_CLOSE(cleanup, fd);
fd = 0;
if (mount_flag) {
if (tst_umount(MNTPOINT))
tst_brkm(TBROK, cleanup, "umount() failed");
mount_flag = 0;
}
}