static void
dir_notempty(const atf_tc_t *tc, const char *mountpath)
{
char pb[MAXPATHLEN], pb2[MAXPATHLEN];
int fd, rv;
USES_DIRS;
/* check we can create directories */
sprintf(pb, "%s/dir", mountpath);
if (rump_sys_mkdir(pb, 0777) == -1)
atf_tc_fail_errno("mkdir");
sprintf(pb2, "%s/dir/file", mountpath);
fd = rump_sys_open(pb2, O_RDWR | O_CREAT, 0777);
if (fd == -1)
atf_tc_fail_errno("create file");
rump_sys_close(fd);
rv = rump_sys_rmdir(pb);
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
if (rv != -1 || errno != ENOTEMPTY)
atf_tc_fail("non-empty directory removed succesfully");
if (rump_sys_unlink(pb2) == -1)
atf_tc_fail_errno("cannot remove dir/file");
if (rump_sys_rmdir(pb) == -1)
atf_tc_fail_errno("remove directory");
}
static void
attrs(const atf_tc_t *tc, const char *mp)
{
struct stat sb, sb2;
struct timeval tv[2];
int fd;
FSTEST_ENTER();
RL(fd = rump_sys_open(TESTFILE, O_RDWR | O_CREAT, 0755));
RL(rump_sys_close(fd));
RL(rump_sys_stat(TESTFILE, &sb));
if (!(FSTYPE_MSDOS(tc) || FSTYPE_SYSVBFS(tc))) {
RL(rump_sys_chown(TESTFILE, 1, 2));
sb.st_uid = 1;
sb.st_gid = 2;
RL(rump_sys_chmod(TESTFILE, 0123));
sb.st_mode = (sb.st_mode & ~ACCESSPERMS) | 0123;
}
tv[0].tv_sec = 1000000000; /* need something >1980 for msdosfs */
tv[0].tv_usec = 1;
tv[1].tv_sec = 1000000002; /* need even seconds for msdosfs */
tv[1].tv_usec = 3;
RL(rump_sys_utimes(TESTFILE, tv));
RL(rump_sys_utimes(TESTFILE, tv)); /* XXX: utimes & birthtime */
sb.st_atimespec.tv_sec = 1000000000;
sb.st_atimespec.tv_nsec = 1000;
sb.st_mtimespec.tv_sec = 1000000002;
sb.st_mtimespec.tv_nsec = 3000;
RL(rump_sys_stat(TESTFILE, &sb2));
#define CHECK(a) ATF_REQUIRE_EQ(sb.a, sb2.a)
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
if (!(FSTYPE_MSDOS(tc) || FSTYPE_SYSVBFS(tc))) {
CHECK(st_uid);
CHECK(st_gid);
CHECK(st_mode);
}
if (!FSTYPE_MSDOS(tc)) {
/* msdosfs has only access date, not time */
CHECK(st_atimespec.tv_sec);
}
CHECK(st_mtimespec.tv_sec);
if (!(FSTYPE_EXT2FS(tc) || FSTYPE_MSDOS(tc) ||
FSTYPE_SYSVBFS(tc) || FSTYPE_V7FS(tc))) {
CHECK(st_atimespec.tv_nsec);
CHECK(st_mtimespec.tv_nsec);
}
#undef CHECK
FSTEST_EXIT();
}
static void
times(const atf_tc_t *tc, const char *mp)
{
const char *name = "file.test";
int fd;
unsigned int i, j;
struct timeval tmv[2];
static struct timeval tmvs[] = {
{ QUAD_MIN, 0 },
{ 0, 0 },
{ QUAD_MAX, 999999 }
};
FSTEST_ENTER();
if ((fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666)) == -1)
atf_tc_fail_errno("open");
if (rump_sys_close(fd) == -1)
atf_tc_fail_errno("close");
rump_pub_lwproc_rfork(RUMP_RFCFDG);
if (rump_sys_setuid(1) == -1)
atf_tc_fail_errno("setuid");
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
if (rump_sys_utimes(name, NULL) != -1 || errno != EACCES)
atf_tc_fail_errno("utimes");
rump_pub_lwproc_releaselwp();
if (rump_sys_utimes(name, NULL) == -1)
atf_tc_fail_errno("utimes");
for (i = 0; i < sizeof(tmvs) / sizeof(tmvs[0]); i++) {
for (j = 0; j < sizeof(tmvs) / sizeof(tmvs[0]); j++) {
tmv[0] = tmvs[i];
tmv[1] = tmvs[j];
rump_pub_lwproc_rfork(RUMP_RFCFDG);
if (rump_sys_setuid(1) == -1)
atf_tc_fail_errno("setuid");
if (rump_sys_utimes(name, tmv) != -1 || errno != EPERM)
atf_tc_fail_errno("utimes");
rump_pub_lwproc_releaselwp();
if (rump_sys_utimes(name, tmv) == -1)
atf_tc_fail_errno("utimes");
}
}
if (rump_sys_unlink(name) == -1)
atf_tc_fail_errno("unlink");
FSTEST_EXIT();
}
static void
flags(const atf_tc_t *tc, const char *mp)
{
const char *name = "file.test";
int fd, fflags;
struct stat st;
FSTEST_ENTER();
if ((fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666)) == -1)
atf_tc_fail_errno("open");
if (rump_sys_close(fd) == -1)
atf_tc_fail_errno("close");
if (rump_sys_stat(name, &st) == -1)
atf_tc_fail_errno("stat");
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
if (rump_sys_chflags(name, st.st_flags) == -1) {
if (errno == EOPNOTSUPP)
atf_tc_skip("file flags not supported by file system");
atf_tc_fail_errno("chflags");
}
fflags = st.st_flags | UF_IMMUTABLE;
rump_pub_lwproc_rfork(RUMP_RFCFDG);
if (rump_sys_setuid(1) == -1)
atf_tc_fail_errno("setuid");
fflags |= UF_IMMUTABLE;
if (rump_sys_chflags(name, fflags) != -1 || errno != EPERM)
atf_tc_fail_errno("chflags");
rump_pub_lwproc_releaselwp();
if (rump_sys_chflags(name, fflags) == -1)
atf_tc_fail_errno("chflags");
fflags &= ~UF_IMMUTABLE;
if (rump_sys_chflags(name, fflags) == -1)
atf_tc_fail_errno("chflags");
if (rump_sys_unlink(name) == -1)
atf_tc_fail_errno("unlink");
FSTEST_EXIT();
}
static void
fcntl_lock(const atf_tc_t *tc, const char *mp)
{
int fd, fd2;
struct flock l;
struct lwp *lwp1, *lwp2;
FSTEST_ENTER();
l.l_pid = 0;
l.l_start = l.l_len = 1024;
l.l_type = F_RDLCK | F_WRLCK;
l.l_whence = SEEK_END;
lwp1 = rump_pub_lwproc_curlwp();
RL(fd = rump_sys_open(TESTFILE, O_RDWR | O_CREAT, 0755));
RL(rump_sys_ftruncate(fd, 8192));
/* PR kern/43321 */
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
RL(rump_sys_fcntl(fd, F_SETLK, &l));
/* Next, we fork and try to lock the same area */
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
lwp2 = rump_pub_lwproc_curlwp();
RL(fd2 = rump_sys_open(TESTFILE, O_RDWR, 0));
ATF_REQUIRE_ERRNO(EAGAIN, rump_sys_fcntl(fd2, F_SETLK, &l));
/* Switch back and unlock... */
rump_pub_lwproc_switch(lwp1);
l.l_type = F_UNLCK;
RL(rump_sys_fcntl(fd, F_SETLK, &l));
/* ... and try to lock again */
rump_pub_lwproc_switch(lwp2);
l.l_type = F_RDLCK | F_WRLCK;
RL(rump_sys_fcntl(fd2, F_SETLK, &l));
RL(rump_sys_close(fd2));
rump_pub_lwproc_releaselwp();
RL(rump_sys_close(fd));
FSTEST_EXIT();
}
static void
dirperms(const atf_tc_t *tc, const char *mp)
{
char name[] = "dir.test/file.test";
char *dir = dirname(name);
int fd;
if (FSTYPE_SYSVBFS(tc))
atf_tc_skip("directories not supported by file system");
FSTEST_ENTER();
if (rump_sys_mkdir(dir, 0777) == -1)
atf_tc_fail_errno("mkdir");
rump_pub_lwproc_rfork(RUMP_RFCFDG);
if (rump_sys_setuid(1) == -1)
atf_tc_fail_errno("setuid");
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
if (rump_sys_open(name, O_RDWR|O_CREAT, 0666) != -1 || errno != EACCES)
atf_tc_fail_errno("open");
rump_pub_lwproc_releaselwp();
if ((fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666)) == -1)
atf_tc_fail_errno("open");
if (rump_sys_close(fd) == -1)
atf_tc_fail_errno("close");
rump_pub_lwproc_rfork(RUMP_RFCFDG);
if (rump_sys_setuid(1) == -1)
atf_tc_fail_errno("setuid");
if (rump_sys_unlink(name) != -1 || errno != EACCES)
atf_tc_fail_errno("unlink");
rump_pub_lwproc_releaselwp();
if (rump_sys_unlink(name) == -1)
atf_tc_fail_errno("unlink");
if (rump_sys_rmdir(dir) == -1)
atf_tc_fail_errno("rmdir");
FSTEST_EXIT();
}
static void
fcntl_getlock_pids(const atf_tc_t *tc, const char *mp)
{
/* test non-overlaping ranges */
struct flock expect[4];
const struct flock lock[4] = {
{ 0, 2, 0, F_WRLCK, SEEK_SET },
{ 2, 1, 0, F_WRLCK, SEEK_SET },
{ 7, 5, 0, F_WRLCK, SEEK_SET },
{ 4, 3, 0, F_WRLCK, SEEK_SET },
};
/* Add extra element to make sure recursion does't stop at array end */
struct flock result[5];
/* Add 5th process */
int fd[5];
pid_t pid[5];
struct lwp *lwp[5];
unsigned int i, j;
const off_t sz = 8192;
int omode = 0755;
int oflags = O_RDWR | O_CREAT;
memcpy(expect, lock, sizeof(lock));
FSTEST_ENTER();
/*
* First, we create 4 processes and let each lock a range of the
* file. Note that the third and fourth processes lock in
* "reverse" order, i.e. the greater pid locks a range before
* the lesser pid.
* Then, we create 5th process which doesn't lock anything.
*/
for (i = 0; i < __arraycount(lwp); i++) {
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
lwp[i] = rump_pub_lwproc_curlwp();
pid[i] = rump_sys_getpid();
RL(fd[i] = rump_sys_open(TESTFILE, oflags, omode));
oflags = O_RDWR;
omode = 0;
RL(rump_sys_ftruncate(fd[i], sz));
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be "
"broken");
if (i < __arraycount(lock)) {
RL(rump_sys_fcntl(fd[i], F_SETLK, &lock[i]));
expect[i].l_pid = pid[i];
}
}
qsort(expect, __arraycount(expect), sizeof(expect[0]), &flock_compare);
/*
* In the context of each process, recursively find all locks
* that would block the current process. Processes 1-4 don't
* see their own lock, we insert it to simplify checks.
* Process 5 sees all 4 locks.
*/
for (i = 0; i < __arraycount(lwp); i++) {
unsigned int nlocks;
rump_pub_lwproc_switch(lwp[i]);
memset(result, 0, sizeof(result));
nlocks = fcntl_getlocks(fd[i], 0, sz,
result, result + __arraycount(result));
if (i < __arraycount(lock)) {
ATF_REQUIRE(nlocks < __arraycount(result));
result[nlocks] = lock[i];
result[nlocks].l_pid = pid[i];
nlocks++;
}
ATF_CHECK_EQ(nlocks, __arraycount(expect));
qsort(result, nlocks, sizeof(result[0]), &flock_compare);
for (j = 0; j < nlocks; j++) {
ATF_CHECK_EQ(result[j].l_start, expect[j].l_start );
ATF_CHECK_EQ(result[j].l_len, expect[j].l_len );
ATF_CHECK_EQ(result[j].l_pid, expect[j].l_pid );
ATF_CHECK_EQ(result[j].l_type, expect[j].l_type );
ATF_CHECK_EQ(result[j].l_whence, expect[j].l_whence);
}
}
/*
* Release processes. This also releases the fds and locks
* making fs unmount possible
*/
for (i = 0; i < __arraycount(lwp); i++) {
rump_pub_lwproc_switch(lwp[i]);
rump_pub_lwproc_releaselwp();
}
FSTEST_EXIT();
}
static void
rename_dir(const atf_tc_t *tc, const char *mp)
{
char pb1[MAXPATHLEN], pb2[MAXPATHLEN], pb3[MAXPATHLEN];
struct stat ref, sb;
if (FSTYPE_RUMPFS(tc))
atf_tc_skip("rename not supported by file system");
USES_DIRS;
md(pb1, mp, "dir1");
if (rump_sys_mkdir(pb1, 0777) == -1)
atf_tc_fail_errno("mkdir 1");
md(pb2, mp, "dir2");
if (rump_sys_mkdir(pb2, 0777) == -1)
atf_tc_fail_errno("mkdir 2");
md(pb2, mp, "dir2/subdir");
if (rump_sys_mkdir(pb2, 0777) == -1)
atf_tc_fail_errno("mkdir 3");
md(pb3, mp, "dir1/file");
if (rump_sys_mknod(pb3, S_IFREG | 0777, -1) == -1)
atf_tc_fail_errno("create file");
if (rump_sys_stat(pb3, &ref) == -1)
atf_tc_fail_errno("stat of file");
/*
* First try ops which should succeed.
*/
/* rename within directory */
md(pb3, mp, "dir3");
if (rump_sys_rename(pb1, pb3) == -1)
atf_tc_fail_errno("rename 1");
checkfile(pb3, &ref);
/* rename directory onto itself (two ways, should fail) */
md(pb1, mp, "dir3/.");
if (rump_sys_rename(pb1, pb3) != -1 || errno != EINVAL)
atf_tc_fail_errno("rename 2");
if (FSTYPE_ZFS(tc))
atf_tc_expect_fail("PR kern/47656: Test known to be broken");
if (rump_sys_rename(pb3, pb1) != -1 || errno != EISDIR)
atf_tc_fail_errno("rename 3");
checkfile(pb3, &ref);
/* rename father of directory into directory */
md(pb1, mp, "dir2/dir");
md(pb2, mp, "dir2");
if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL)
atf_tc_fail_errno("rename 4");
/* same for grandfather */
md(pb1, mp, "dir2/subdir/dir2");
if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL)
atf_tc_fail("rename 5");
checkfile(pb3, &ref);
/* rename directory over a non-empty directory */
if (rump_sys_rename(pb2, pb3) != -1 || errno != ENOTEMPTY)
atf_tc_fail("rename 6");
/* cross-directory rename */
md(pb1, mp, "dir3");
md(pb2, mp, "dir2/somedir");
if (rump_sys_rename(pb1, pb2) == -1)
atf_tc_fail_errno("rename 7");
checkfile(pb2, &ref);
/* move to parent directory */
md(pb1, mp, "dir2/somedir/../../dir3");
if (rump_sys_rename(pb2, pb1) == -1)
atf_tc_fail_errno("rename 8");
md(pb1, mp, "dir2/../dir3");
checkfile(pb1, &ref);
/* atomic cross-directory rename */
md(pb3, mp, "dir2/subdir");
if (rump_sys_rename(pb1, pb3) == -1)
atf_tc_fail_errno("rename 9");
checkfile(pb3, &ref);
/* rename directory over an empty directory */
md(pb1, mp, "parent");
md(pb2, mp, "parent/dir1");
md(pb3, mp, "parent/dir2");
RL(rump_sys_mkdir(pb1, 0777));
RL(rump_sys_mkdir(pb2, 0777));
RL(rump_sys_mkdir(pb3, 0777));
RL(rump_sys_rename(pb2, pb3));
RL(rump_sys_stat(pb1, &sb));
if (! FSTYPE_MSDOS(tc))
ATF_CHECK_EQ(sb.st_nlink, 3);
RL(rump_sys_rmdir(pb3));
RL(rump_sys_rmdir(pb1));
}
