* Copyright (c) 2010 The NetBSD Foundation, Inc.

/* $NetBSD: t_vnops.c,v 1.63 2023/05/08 19:23:45 andvar Exp $ */

/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/time.h>

#include <assert.h>
#include <atf-c.h>
#include <ctype.h>
#include <fcntl.h>
#include <libgen.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <rump/rump_syscalls.h>
#include <rump/rump.h>

#include "../common/h_fsmacros.h"
#include "h_macros.h"

#define TESTFILE "afile"

#define USES_DIRS \
if (FSTYPE_SYSVBFS(tc)) \
atf_tc_skip("directories not supported by file system")

#define USES_SYMLINKS \
if (FSTYPE_SYSVBFS(tc) || FSTYPE_MSDOS(tc)) \
atf_tc_skip("symlinks not supported by file system")

static char *
md(char *buf, size_t buflen, const char *base, const char *tail)
{

snprintf(buf, buflen, "%s/%s", base, tail);
return buf;
}

static void
lookup_simple(const atf_tc_t *tc, const char *mountpath)
{
char pb[MAXPATHLEN], final[MAXPATHLEN];
struct stat sb1, sb2;

strcpy(final, mountpath);
snprintf(pb, sizeof(pb), "%s/../%s", mountpath, basename(final));
if (rump_sys_stat(pb, &sb1) == -1)
atf_tc_fail_errno("stat 1");

snprintf(pb, sizeof(pb), "%s/./../%s", mountpath, basename(final));
if (rump_sys_stat(pb, &sb2) == -1)
atf_tc_fail_errno("stat 2");

ATF_REQUIRE(memcmp(&sb1, &sb2, sizeof(sb1)) == 0);
}

static void
lookup_complex(const atf_tc_t *tc, const char *mountpath)
{
char pb[MAXPATHLEN];
struct stat sb1, sb2;
struct timespec atplus1, onesec;

USES_DIRS;

snprintf(pb, sizeof(pb), "%s/dir", mountpath);
if (rump_sys_mkdir(pb, 0777) == -1)
atf_tc_fail_errno("mkdir");
if (rump_sys_stat(pb, &sb1) == -1)
atf_tc_fail_errno("stat 1");

snprintf(pb, sizeof(pb), "%s/./dir/../././dir/.", mountpath);
if (rump_sys_stat(pb, &sb2) == -1)
atf_tc_fail_errno("stat 2");

/*
* The lookup is permitted to modify the access time of
* any directories searched - such a directory is the
* subject of this test. Any difference should cause
* the 2nd lookup atime to be >= the first, if it is ==, all is
* OK (atime is not required to be modified by the search, or
* both references may happen within the same clock tick), if the
* 2nd lookup atime is > the first, but not "too much" greater,
* just set it back, so the memcmp just below succeeds
* (assuming all else is OK).
*/
onesec.tv_sec = 1;
onesec.tv_nsec = 0;
timespecadd(&sb1.st_atimespec, &onesec, &atplus1);
if (timespeccmp(&sb2.st_atimespec, &sb1.st_atimespec, >) &&
timespeccmp(&sb2.st_atimespec, &atplus1, <))
sb2.st_atimespec = sb1.st_atimespec;

if (memcmp(&sb1, &sb2, sizeof(sb1)) != 0) {
printf("what\tsb1\t\tsb2\n");

#define FIELD(FN) \
printf(#FN "\t%lld\t%lld\n", \
(long long)sb1.FN, (long long)sb2.FN)
#define TIME(FN) \
printf(#FN "\t%lld.%ld\t%lld.%ld\n", \
(long long)sb1.FN.tv_sec, sb1.FN.tv_nsec, \
(long long)sb2.FN.tv_sec, sb2.FN.tv_nsec)

FIELD(st_dev);
FIELD(st_mode);
FIELD(st_ino);
FIELD(st_nlink);
FIELD(st_uid);
FIELD(st_gid);
FIELD(st_rdev);
TIME(st_atimespec);
TIME(st_mtimespec);
TIME(st_ctimespec);
TIME(st_birthtimespec);
FIELD(st_size);
FIELD(st_blocks);
FIELD(st_flags);
FIELD(st_gen);

#undef FIELD
#undef TIME

atf_tc_fail("stat results differ, see output for more details");
}
}

static void
dir_simple(const atf_tc_t *tc, const char *mountpath)
{
char pb[MAXPATHLEN];
struct stat sb;

USES_DIRS;

/* check we can create directories */
snprintf(pb, sizeof(pb), "%s/dir", mountpath);
if (rump_sys_mkdir(pb, 0777) == -1)
atf_tc_fail_errno("mkdir");
if (rump_sys_stat(pb, &sb) == -1)
atf_tc_fail_errno("stat new directory");

/* check we can remove them and that it makes them unreachable */
if (rump_sys_rmdir(pb) == -1)
atf_tc_fail_errno("rmdir");
if (rump_sys_stat(pb, &sb) != -1 || errno != ENOENT)
atf_tc_fail("ENOENT expected from stat");
}

static void
do_dir_slash(const atf_tc_t *tc, const char *mountpath, const char *addend)
{
char plain[MAXPATHLEN], with_slash[MAXPATHLEN];
struct stat sb;

USES_DIRS;

/* check we can create directories with one or more / appended */
snprintf(plain, sizeof(plain), "%s/dir%s", mountpath, addend);
snprintf(with_slash, sizeof(with_slash), "%s/dir/", mountpath);
if (rump_sys_mkdir(with_slash, 0777) == -1)
atf_tc_fail_errno("mkdir");
if (rump_sys_stat(plain, &sb) == -1)
atf_tc_fail_errno("stat new directory");
if (rump_sys_rmdir(plain) == -1)
atf_tc_fail_errno("rmdir");
if (rump_sys_stat(with_slash, &sb) != -1 || errno != ENOENT)
atf_tc_fail("ENOENT expected from stat");
}

static void
dir_slash(const atf_tc_t *tc, const char *mountpath)
{
do_dir_slash(tc, mountpath, "/");
}

static void
dir_2slash(const atf_tc_t *tc, const char *mountpath)
{
do_dir_slash(tc, mountpath, "//");
}

static void
dir_3slash(const atf_tc_t *tc, const char *mountpath)
{
do_dir_slash(tc, mountpath, "///");
}

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 */
snprintf(pb, sizeof(pb), "%s/dir", mountpath);
if (rump_sys_mkdir(pb, 0777) == -1)
atf_tc_fail_errno("mkdir");

snprintf(pb2, sizeof(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 (rv != -1 || errno != ENOTEMPTY)
atf_tc_fail("non-empty directory removed successfully");

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
dir_rmdirdotdot(const atf_tc_t *tc, const char *mp)
{
char pb[MAXPATHLEN];
int xerrno;

USES_DIRS;

FSTEST_ENTER();
RL(rump_sys_mkdir("test", 0777));
RL(rump_sys_chdir("test"));

RL(rump_sys_mkdir("subtest", 0777));
RL(rump_sys_chdir("subtest"));

md(pb, sizeof(pb), mp, "test/subtest");
RL(rump_sys_rmdir(pb));
md(pb, sizeof(pb), mp, "test");
RL(rump_sys_rmdir(pb));

if (FSTYPE_NFS(tc))
xerrno = ESTALE;
else
xerrno = ENOENT;
ATF_REQUIRE_ERRNO(xerrno, rump_sys_chdir("..") == -1);
FSTEST_EXIT();
}

static void
checkfile(const char *path, struct stat *refp)
{
char buf[MAXPATHLEN];
struct stat sb;
static int n = 1;

md(buf, sizeof(buf), path, "file");
if (rump_sys_stat(buf, &sb) == -1)
atf_tc_fail_errno("cannot stat file %d (%s)", n, buf);
if (memcmp(&sb, refp, sizeof(sb)) != 0)
atf_tc_fail("stat mismatch %d", n);
n++;
}

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, sizeof(pb1), mp, "dir1");
if (rump_sys_mkdir(pb1, 0777) == -1)
atf_tc_fail_errno("mkdir 1");

md(pb2, sizeof(pb2), mp, "dir2");
if (rump_sys_mkdir(pb2, 0777) == -1)
atf_tc_fail_errno("mkdir 2");
md(pb2, sizeof(pb2), mp, "dir2/subdir");
if (rump_sys_mkdir(pb2, 0777) == -1)
atf_tc_fail_errno("mkdir 3");

md(pb3, sizeof(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, sizeof(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, sizeof(pb1), mp, "dir3/.");
if (rump_sys_rename(pb1, pb3) != -1 || errno != EINVAL)
atf_tc_fail_errno("rename 2");
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, sizeof(pb1), mp, "dir2/dir");
md(pb2, sizeof(pb2), mp, "dir2");
if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL)
atf_tc_fail_errno("rename 4");

/* same for grandfather */
md(pb1, sizeof(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, sizeof(pb1), mp, "dir3");
md(pb2, sizeof(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, sizeof(pb1), mp, "dir2/somedir/../../dir3");
if (rump_sys_rename(pb2, pb1) == -1)
atf_tc_fail_errno("rename 8");
md(pb1, sizeof(pb1), mp, "dir2/../dir3");
checkfile(pb1, &ref);

/* atomic cross-directory rename */
md(pb3, sizeof(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, sizeof(pb1), mp, "parent");
md(pb2, sizeof(pb2), mp, "parent/dir1");
md(pb3, sizeof(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));
}

static void
rename_dotdot(const atf_tc_t *tc, const char *mp)
{

if (FSTYPE_RUMPFS(tc))
atf_tc_skip("rename not supported by file system");

USES_DIRS;

if (rump_sys_chdir(mp) == -1)
atf_tc_fail_errno("chdir mountpoint");

if (rump_sys_mkdir("dir1", 0777) == -1)
atf_tc_fail_errno("mkdir 1");
if (rump_sys_mkdir("dir2", 0777) == -1)
atf_tc_fail_errno("mkdir 2");

if (rump_sys_rename("dir1", "dir1/..") != -1 || errno != EINVAL)
atf_tc_fail_errno("self-dotdot to");

if (rump_sys_rename("dir1/..", "sometarget") != -1 || errno != EINVAL)
atf_tc_fail_errno("self-dotdot from");

if (rump_sys_rename("dir1", "dir2/..") != -1 || errno != EINVAL)
atf_tc_fail("other-dotdot");

rump_sys_chdir("/");
}

static void
rename_reg_nodir(const atf_tc_t *tc, const char *mp)
{
bool haslinks;
struct stat sb;
ino_t f1ino;

if (FSTYPE_RUMPFS(tc))
atf_tc_skip("rename not supported by file system");

if (rump_sys_chdir(mp) == -1)
atf_tc_fail_errno("chdir mountpoint");

if (FSTYPE_MSDOS(tc) || FSTYPE_SYSVBFS(tc))
haslinks = false;
else
haslinks = true;

if (rump_sys_mknod("file1", S_IFREG | 0777, -1) == -1)
atf_tc_fail_errno("create file");
if (rump_sys_mknod("file2", S_IFREG | 0777, -1) == -1)
atf_tc_fail_errno("create file");

if (rump_sys_stat("file1", &sb) == -1)
atf_tc_fail_errno("stat");
f1ino = sb.st_ino;

if (haslinks) {
if (rump_sys_link("file1", "file_link") == -1)
atf_tc_fail_errno("link");
if (rump_sys_stat("file_link", &sb) == -1)
atf_tc_fail_errno("stat");
ATF_REQUIRE_EQ(sb.st_ino, f1ino);
ATF_REQUIRE_EQ(sb.st_nlink, 2);
}

if (rump_sys_stat("file2", &sb) == -1)
atf_tc_fail_errno("stat");

if (rump_sys_rename("file1", "file3") == -1)
atf_tc_fail_errno("rename 1");
if (rump_sys_stat("file3", &sb) == -1)
atf_tc_fail_errno("stat 1");
if (haslinks) {
ATF_REQUIRE_EQ(sb.st_ino, f1ino);
}
if (rump_sys_stat("file1", &sb) != -1 || errno != ENOENT)
atf_tc_fail_errno("source 1");

if (rump_sys_rename("file3", "file2") == -1)
atf_tc_fail_errno("rename 2");
if (rump_sys_stat("file2", &sb) == -1)
atf_tc_fail_errno("stat 2");
if (haslinks) {
ATF_REQUIRE_EQ(sb.st_ino, f1ino);
}

if (rump_sys_stat("file3", &sb) != -1 || errno != ENOENT)
atf_tc_fail_errno("source 2");

if (haslinks) {
if (rump_sys_rename("file2", "file_link") == -1)
atf_tc_fail_errno("rename hardlink");
if (rump_sys_stat("file2", &sb) != -1 || errno != ENOENT)
atf_tc_fail_errno("source 3");
if (rump_sys_stat("file_link", &sb) == -1)
atf_tc_fail_errno("stat 2");
ATF_REQUIRE_EQ(sb.st_ino, f1ino);
ATF_REQUIRE_EQ(sb.st_nlink, 1);
}

ATF_CHECK_ERRNO(EFAULT, rump_sys_rename("file2", NULL) == -1);
ATF_CHECK_ERRNO(EFAULT, rump_sys_rename(NULL, "file2") == -1);

rump_sys_chdir("/");
}

/* PR kern/50607 */
static void
create_many(const atf_tc_t *tc, const char *mp)
{
char buf[64];
int nfiles = 2324; /* #Nancy */
int i;

/* takes forever with many files */
if (FSTYPE_MSDOS(tc))
nfiles /= 4;

RL(rump_sys_chdir(mp));

if (FSTYPE_SYSVBFS(tc)) {
/* fs doesn't support many files or subdirectories */
nfiles = 5;
} else {
/* msdosfs doesn't like many entries in the root directory */
RL(rump_sys_mkdir("subdir", 0777));
RL(rump_sys_chdir("subdir"));
}

/* create them */
#define TESTFN "testfile"
for (i = 0; i < nfiles; i++) {
int fd;

snprintf(buf, sizeof(buf), TESTFN "%d", i);
RL(fd = rump_sys_open(buf, O_RDWR|O_CREAT|O_EXCL, 0666));
RL(rump_sys_close(fd));
}

/* wipe them out */
for (i = 0; i < nfiles; i++) {
snprintf(buf, sizeof(buf), TESTFN "%d", i);
RLF(rump_sys_unlink(buf), "%s", buf);
}
#undef TESTFN

rump_sys_chdir("/");
}

/*
* Test creating files with one-character names using all possible
* character values. Failures to create the file are ignored as the
* characters allowed in file names vary by file system, but at least
* we can check that the fs does not crash, and if the file is
* successfully created, unlinking it should also succeed.
*/
static void
create_nonalphanum(const atf_tc_t *tc, const char *mp)
{
char buf[64];
int i;

RL(rump_sys_chdir(mp));

for (i = 0; i < 256; i++) {
int fd;
snprintf(buf, sizeof(buf), "%c", i);
fd = rump_sys_open(buf, O_RDWR|O_CREAT|O_EXCL, 0666);
if (fd == -1)
continue;
RLF(rump_sys_close(fd), "%d", fd);
RLF(rump_sys_unlink(buf), "%s", buf);
}
printf("\n");

rump_sys_chdir("/");
}

static void
create_nametoolong(const atf_tc_t *tc, const char *mp)
{
char *name;
int fd;
long val;
size_t len;

if (rump_sys_chdir(mp) == -1)
atf_tc_fail_errno("chdir mountpoint");

val = rump_sys_pathconf(".", _PC_NAME_MAX);
if (val == -1)
atf_tc_fail_errno("pathconf");

len = val + 1;
name = malloc(len+1);
if (name == NULL)
atf_tc_fail_errno("malloc");

memset(name, 'a', len);
*(name+len) = '\0';

val = rump_sys_pathconf(".", _PC_NO_TRUNC);
if (val == -1)
atf_tc_fail_errno("pathconf");

fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666);
if (val != 0 && (fd != -1 || errno != ENAMETOOLONG))
atf_tc_fail_errno("open");

if (val == 0 && rump_sys_close(fd) == -1)
atf_tc_fail_errno("close");
if (val == 0 && rump_sys_unlink(name) == -1)
atf_tc_fail_errno("unlink");

free(name);

rump_sys_chdir("/");
}

static void
create_exist(const atf_tc_t *tc, const char *mp)
{
const char *name = "hoge";
int fd;

RL(rump_sys_chdir(mp));
RL(fd = rump_sys_open(name, O_RDWR|O_CREAT|O_EXCL, 0666));
RL(rump_sys_close(fd));
RL(rump_sys_unlink(name));
RL(fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666));
RL(rump_sys_close(fd));
RL(fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666));
RL(rump_sys_close(fd));
ATF_REQUIRE_ERRNO(EEXIST,
(fd = rump_sys_open(name, O_RDWR|O_CREAT|O_EXCL, 0666)));
RL(rump_sys_unlink(name));
RL(rump_sys_chdir("/"));
}

static void
rename_nametoolong(const atf_tc_t *tc, const char *mp)
{
char *name;
int res, fd;
long val;
size_t len;

if (FSTYPE_RUMPFS(tc))
atf_tc_skip("rename not supported by file system");

if (rump_sys_chdir(mp) == -1)
atf_tc_fail_errno("chdir mountpoint");

val = rump_sys_pathconf(".", _PC_NAME_MAX);
if (val == -1)
atf_tc_fail_errno("pathconf");

len = val + 1;
name = malloc(len+1);
if (name == NULL)
atf_tc_fail_errno("malloc");

memset(name, 'a', len);
*(name+len) = '\0';

fd = rump_sys_open("dummy", O_RDWR|O_CREAT, 0666);
if (fd == -1)
atf_tc_fail_errno("open");
if (rump_sys_close(fd) == -1)
atf_tc_fail_errno("close");

val = rump_sys_pathconf(".", _PC_NO_TRUNC);
if (val == -1)
atf_tc_fail_errno("pathconf");

res = rump_sys_rename("dummy", name);
if (val != 0 && (res != -1 || errno != ENAMETOOLONG))
atf_tc_fail_errno("rename");

if (val == 0 && rump_sys_unlink(name) == -1)
atf_tc_fail_errno("unlink");

free(name);

rump_sys_chdir("/");
}

/*
* Test creating a symlink whose length is "len" bytes, not including
* the terminating NUL.
*/
static void
symlink_len(const atf_tc_t *tc, const char *mp, size_t len)
{
char *buf;
int r;

USES_SYMLINKS;

RLF(rump_sys_chdir(mp), "%s", mp);

buf = malloc(len + 1);
ATF_REQUIRE(buf);
memset(buf, 'a', len);
buf[len] = '\0';
r = rump_sys_symlink(buf, "afile");
if (r == -1) {
ATF_REQUIRE_ERRNO(ENAMETOOLONG, r);
} else {
RL(rump_sys_unlink("afile"));
}
free(buf);

RL(rump_sys_chdir("/"));
}

static void
symlink_zerolen(const atf_tc_t *tc, const char *mp)
{
symlink_len(tc, mp, 0);
}

static void
symlink_long(const atf_tc_t *tc, const char *mp)
{
/*
* Test lengths close to powers of two, as those are likely
* to be edge cases.
*/
size_t len;
int fuzz;
for (len = 2; len <= 65536; len *= 2) {
for (fuzz = -1; fuzz <= 1; fuzz++) {
symlink_len(tc, mp, len + fuzz);
}
}
}

static void
symlink_root(const atf_tc_t *tc, const char *mp)
{

USES_SYMLINKS;

RL(rump_sys_chdir(mp));
RL(rump_sys_symlink("/", "foo"));
RL(rump_sys_chdir("foo"));
}

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_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
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));

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 int
flock_compare(const void *p, const void *q)
{
int a = ((const struct flock *)p)->l_start;
int b = ((const struct flock *)q)->l_start;
return a < b ? -1 : (a > b ? 1 : 0);
}

/*
* Find all locks set by fcntl_getlock_pids test
* using GETLK for a range [start, start+end], and,
* if there is a blocking lock, recursively find
* all locks to the left (toward the beginning of
* a file) and to the right of the lock.
* The function also understands "until end of file"
* convention when len==0.
*/
static unsigned int
fcntl_getlocks(int fildes, off_t start, off_t len,
struct flock *lock, struct flock *end)
{
unsigned int rv = 0;
const struct flock l = { start, len, 0, F_RDLCK, SEEK_SET };

if (lock == end)
return rv;

RL(rump_sys_fcntl(fildes, F_GETLK, &l));

if (l.l_type == F_UNLCK)
return rv;

*lock++ = l;
rv += 1;

ATF_REQUIRE(l.l_whence == SEEK_SET);

if (l.l_start > start) {
unsigned int n =
fcntl_getlocks(fildes, start, l.l_start - start, lock, end);
rv += n;
lock += n;
if (lock == end)
return rv;
}

if (l.l_len == 0) /* does l spans until the end? */
return rv;

if (len == 0) /* are we looking for locks until the end? */ {
rv += fcntl_getlocks(fildes, l.l_start + l.l_len, len, lock, end);
} else if (l.l_start + l.l_len < start + len) {
len -= l.l_start + l.l_len - start;
rv += fcntl_getlocks(fildes, l.l_start + l.l_len, len, lock, end);
}

return rv;
}

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 (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
access_simple(const atf_tc_t *tc, const char *mp)
{
int fd;
int tmode;

FSTEST_ENTER();
RL(fd = rump_sys_open("tfile", O_CREAT | O_RDWR, 0777));
RL(rump_sys_close(fd));

#define ALLACC (F_OK | X_OK | W_OK | R_OK)
if (FSTYPE_SYSVBFS(tc) || FSTYPE_MSDOS(tc))
tmode = F_OK;
else
tmode = ALLACC;

RL(rump_sys_access("tfile", tmode));

/* PR kern/44648 */
ATF_REQUIRE_ERRNO(EINVAL, rump_sys_access("tfile", ALLACC+1) == -1);
#undef ALLACC
FSTEST_EXIT();
}

static void
read_directory(const atf_tc_t *tc, const char *mp)
{
char buf[1024];
int fd, res;
ssize_t size;

FSTEST_ENTER();
fd = rump_sys_open(".", O_DIRECTORY | O_RDONLY, 0777);
ATF_REQUIRE(fd != -1);

size = rump_sys_pread(fd, buf, sizeof(buf), 0);
ATF_CHECK(size != -1 || errno == EISDIR);
size = rump_sys_read(fd, buf, sizeof(buf));
ATF_CHECK(size != -1 || errno == EISDIR);

res = rump_sys_close(fd);
ATF_REQUIRE(res != -1);
FSTEST_EXIT();
}

static void
lstat_symlink(const atf_tc_t *tc, const char *mp)
{
const char *src, *dst;
int res;
struct stat st;

USES_SYMLINKS;

FSTEST_ENTER();

src = "source";
dst = "destination";

res = rump_sys_symlink(src, dst);
ATF_REQUIRE(res != -1);
res = rump_sys_lstat(dst, &st);
ATF_REQUIRE(res != -1);

ATF_CHECK(S_ISLNK(st.st_mode) != 0);
ATF_CHECK(st.st_size == (off_t)strlen(src));

FSTEST_EXIT();
}

ATF_TC_FSAPPLY(lookup_simple, "simple lookup (./.. on root)");
ATF_TC_FSAPPLY(lookup_complex, "lookup of non-dot entries");
ATF_TC_FSAPPLY(dir_simple, "mkdir/rmdir");
ATF_TC_FSAPPLY(dir_slash, "mkdir with appended slash");
ATF_TC_FSAPPLY(dir_2slash, "mkdir with two slashes appended");
ATF_TC_FSAPPLY(dir_3slash, "mkdir with three slashes appended");
ATF_TC_FSAPPLY(dir_notempty, "non-empty directories cannot be removed");
ATF_TC_FSAPPLY(dir_rmdirdotdot, "remove .. and try to cd out (PR kern/44657)");
ATF_TC_FSAPPLY(rename_dir, "exercise various directory renaming ops "
"(PR kern/44288)");
ATF_TC_FSAPPLY(rename_dotdot, "rename dir .. (PR kern/43617)");
ATF_TC_FSAPPLY(rename_reg_nodir, "rename regular files, no subdirectories");
ATF_TC_FSAPPLY(create_nametoolong, "create file with name too long");
ATF_TC_FSAPPLY(create_exist, "create with O_EXCL");
ATF_TC_FSAPPLY(rename_nametoolong, "rename to file with name too long");
ATF_TC_FSAPPLY(symlink_zerolen, "symlink with target of length 0");
ATF_TC_FSAPPLY(symlink_long, "symlink with target of length > 0");
ATF_TC_FSAPPLY(symlink_root, "symlink to root directory");
ATF_TC_FSAPPLY(attrs, "check setting attributes works");
ATF_TC_FSAPPLY(fcntl_lock, "check fcntl F_SETLK");
ATF_TC_FSAPPLY(fcntl_getlock_pids,"fcntl F_GETLK w/ many procs, PR kern/44494");
ATF_TC_FSAPPLY(access_simple, "access(2)");
ATF_TC_FSAPPLY(read_directory, "read(2) on directories");
ATF_TC_FSAPPLY(lstat_symlink, "lstat(2) values for symbolic links");

#undef FSTEST_IMGSIZE
#define FSTEST_IMGSIZE (1024*1024*64)
ATF_TC_FSAPPLY(create_many, "create many directory entries");
ATF_TC_FSAPPLY(create_nonalphanum, "non-alphanumeric filenames");

ATF_TP_ADD_TCS(tp)
{

ATF_TP_FSAPPLY(lookup_simple);
ATF_TP_FSAPPLY(lookup_complex);
ATF_TP_FSAPPLY(dir_simple);
ATF_TP_FSAPPLY(dir_notempty);
ATF_TP_FSAPPLY(dir_rmdirdotdot);
ATF_TP_FSAPPLY(dir_slash);
ATF_TP_FSAPPLY(dir_2slash);
ATF_TP_FSAPPLY(dir_3slash);
ATF_TP_FSAPPLY(rename_dir);
ATF_TP_FSAPPLY(rename_dotdot);
ATF_TP_FSAPPLY(rename_reg_nodir);
ATF_TP_FSAPPLY(create_many);
ATF_TP_FSAPPLY(create_nonalphanum);
ATF_TP_FSAPPLY(create_nametoolong);
ATF_TP_FSAPPLY(create_exist);
ATF_TP_FSAPPLY(rename_nametoolong);
ATF_TP_FSAPPLY(symlink_zerolen);
ATF_TP_FSAPPLY(symlink_long);
ATF_TP_FSAPPLY(symlink_root);
ATF_TP_FSAPPLY(attrs);
ATF_TP_FSAPPLY(fcntl_lock);
ATF_TP_FSAPPLY(fcntl_getlock_pids);
ATF_TP_FSAPPLY(access_simple);
ATF_TP_FSAPPLY(read_directory);
ATF_TP_FSAPPLY(lstat_symlink);

return atf_no_error();
}