[mirror_spl.git] / modules / splat / splat-vnode.c

/*
 *  This file is part of the SPL: Solaris Porting Layer.
 *
 *  Copyright (c) 2008 Lawrence Livermore National Security, LLC.
 *  Produced at Lawrence Livermore National Laboratory
 *  Written by:
 *          Brian Behlendorf <behlendorf1@llnl.gov>,
 *          Herb Wartens <wartens2@llnl.gov>,
 *          Jim Garlick <garlick@llnl.gov>
 *  UCRL-CODE-235197
 *
 *  This is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
 */

#include "splat-internal.h"
#include <linux/rcupdate.h>

#define SPLAT_SUBSYSTEM_VNODE		0x0900
#define SPLAT_VNODE_NAME		"vnode"
#define SPLAT_VNODE_DESC		"Kernel Vnode Tests"

#define SPLAT_VNODE_TEST1_ID		0x0901
#define SPLAT_VNODE_TEST1_NAME		"vn_open"
#define SPLAT_VNODE_TEST1_DESC		"Vn_open Test"

#define SPLAT_VNODE_TEST2_ID		0x0902
#define SPLAT_VNODE_TEST2_NAME		"vn_openat"
#define SPLAT_VNODE_TEST2_DESC		"Vn_openat Test"

#define SPLAT_VNODE_TEST3_ID		0x0903
#define SPLAT_VNODE_TEST3_NAME		"vn_rdwr"
#define SPLAT_VNODE_TEST3_DESC		"Vn_rdwrt Test"

#define SPLAT_VNODE_TEST4_ID		0x0904
#define SPLAT_VNODE_TEST4_NAME		"vn_rename"
#define SPLAT_VNODE_TEST4_DESC		"Vn_rename Test"

#define SPLAT_VNODE_TEST5_ID		0x0905
#define SPLAT_VNODE_TEST5_NAME		"vn_getattr"
#define SPLAT_VNODE_TEST5_DESC		"Vn_getattr Test"

#define SPLAT_VNODE_TEST6_ID		0x0906
#define SPLAT_VNODE_TEST6_NAME		"vn_sync"
#define SPLAT_VNODE_TEST6_DESC		"Vn_sync Test"

#define SPLAT_VNODE_TEST7_ID		0x0907
#define SPLAT_VNODE_TEST7_NAME		"vn_getf"
#define SPLAT_VNODE_TEST7_DESC		"vn_getf/vn_releasef Test"

#define SPLAT_VNODE_TEST_FILE		"/etc/fstab"
#define SPLAT_VNODE_TEST_FILE_AT	"etc/fstab"
#define SPLAT_VNODE_TEST_FILE_RW	"/tmp/spl.vnode.tmp"
#define SPLAT_VNODE_TEST_FILE_RW1	"/tmp/spl.vnode.tmp.1"
#define SPLAT_VNODE_TEST_FILE_RW2	"/tmp/spl.vnode.tmp.2"

static int
splat_vnode_test1(struct file *file, void *arg)
{
	vnode_t *vp;
	int rc;

	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
			  FREAD, 0644, &vp, 0, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
			     "Failed to vn_open test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE, rc);
		return rc;
	}

        rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);

	if (rc) {
		splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
			     "Failed to vn_close test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE, rc);
		return rc;
	}

	splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully vn_open'ed "
		     "and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);

        return rc;
} /* splat_vnode_test1() */

static int
splat_vnode_test2(struct file *file, void *arg)
{
	vnode_t *vp;
	int rc;

	if ((rc = vn_openat(SPLAT_VNODE_TEST_FILE_AT, UIO_SYSSPACE,
			    FREAD, 0644, &vp, 0, 0, rootdir, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
			     "Failed to vn_openat test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE, rc);
		return rc;
	}

        rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);

	if (rc) {
		splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
			     "Failed to vn_close test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE, rc);
		return rc;
	}

	splat_vprint(file, SPLAT_VNODE_TEST2_NAME, "Successfully vn_openat'ed "
		     "and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);

        return rc;
} /* splat_vnode_test2() */

static int
splat_vnode_test3(struct file *file, void *arg)
{
	vnode_t *vp;
	char buf1[32] = "SPL VNode Interface Test File\n";
	char buf2[32] = "";
	int rc;

	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
			  FWRITE | FREAD | FCREAT | FEXCL,
			  0644, &vp, 0, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
			     "Failed to vn_open test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		return rc;
	}

        rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
			     "Failed vn_rdwr write of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		goto out;
	}

        rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
			     "Failed vn_rdwr read of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		goto out;
	}

	if (strncmp(buf1, buf2, strlen(buf1))) {
		rc = -EINVAL;
		splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
			     "Failed strncmp data written does not match "
			     "data read\nWrote: %sRead:  %s\n", buf1, buf2);
		goto out;
	}

	rc = 0;
	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read:  %s", buf2);
	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
		     "read expected data pattern to test file: %s\n",
		     SPLAT_VNODE_TEST_FILE_RW);

out:
        VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);
	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);

        return rc;
} /* splat_vnode_test3() */

static int
splat_vnode_test4(struct file *file, void *arg)
{
	vnode_t *vp;
	char buf1[32] = "SPL VNode Interface Test File\n";
	char buf2[32] = "";
	int rc;

	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE,
			  FWRITE | FREAD | FCREAT | FEXCL, 0644, &vp, 0, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
			     "Failed to vn_open test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW1, rc);
		goto out;
	}

        rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
			     "Failed vn_rdwr write of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW1, rc);
		goto out2;
	}

        VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);

	rc = vn_rename(SPLAT_VNODE_TEST_FILE_RW1,SPLAT_VNODE_TEST_FILE_RW2,0);
	if (rc) {
		splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Failed vn_rename "
			     "%s -> %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW1,
			     SPLAT_VNODE_TEST_FILE_RW2, rc);
		goto out;
	}

	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE,
			  FREAD | FEXCL, 0644, &vp, 0, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
			     "Failed to vn_open test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW2, rc);
		goto out;
	}

        rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
			     "Failed vn_rdwr read of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW2, rc);
		goto out2;
	}

	if (strncmp(buf1, buf2, strlen(buf1))) {
		rc = EINVAL;
		splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
			     "Failed strncmp data written does not match "
			     "data read\nWrote: %sRead:  %s\n", buf1, buf2);
		goto out2;
	}

	rc = 0;
	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Wrote to %s:  %s",
		     SPLAT_VNODE_TEST_FILE_RW1, buf1);
	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Read from %s: %s",
		     SPLAT_VNODE_TEST_FILE_RW2, buf2);
	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Successfully renamed "
		     "test file %s -> %s and verified data pattern\n",
		     SPLAT_VNODE_TEST_FILE_RW1, SPLAT_VNODE_TEST_FILE_RW2);
out2:
        VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);
out:
	vn_remove(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE, RMFILE);
	vn_remove(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE, RMFILE);

        return rc;
} /* splat_vnode_test4() */

static int
splat_vnode_test5(struct file *file, void *arg)
{
	vnode_t *vp;
	vattr_t vap;
	int rc;

	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
			  FREAD, 0644, &vp, 0, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
			     "Failed to vn_open test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE, rc);
		return rc;
	}

	rc = VOP_GETATTR(vp, &vap, 0, 0, NULL);
	if (rc) {
		splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
			     "Failed to vn_getattr test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE, rc);
		goto out;
	}

	if (vap.va_type != VREG) {
		rc = -EINVAL;
		splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
			     "Failed expected regular file type "
			     "(%d != VREG): %s (%d)\n", vap.va_type,
			     SPLAT_VNODE_TEST_FILE, rc);
		goto out;
	}

	splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully "
		     "vn_getattr'ed test file: %s\n", SPLAT_VNODE_TEST_FILE);

out:
        VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);

        return rc;
} /* splat_vnode_test5() */

static int
splat_vnode_test6(struct file *file, void *arg)
{
	vnode_t *vp;
	char buf[32] = "SPL VNode Interface Test File\n";
	int rc;

	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
			  FWRITE | FCREAT | FEXCL, 0644, &vp, 0, 0))) {
		splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
			     "Failed to vn_open test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		return rc;
	}

        rc = vn_rdwr(UIO_WRITE, vp, buf, strlen(buf), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
			     "Failed vn_rdwr write of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		goto out;
	}

	rc = vn_fsync(vp, 0, 0, 0);
	if (rc) {
		splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
			     "Failed vn_fsync of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		goto out;
	}

	rc = 0;
	splat_vprint(file, SPLAT_VNODE_TEST6_NAME, "Successfully "
		     "fsync'ed test file %s\n", SPLAT_VNODE_TEST_FILE_RW);
out:
        VOP_CLOSE(vp, 0, 0, 0, 0, 0);
        VN_RELE(vp);
	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);

        return rc;
} /* splat_vnode_test6() */

/* Basically a slightly modified version of sys_close() */
static int
fd_uninstall(int fd)
{
        struct file *fp;
        struct files_struct *files = current->files;
        struct fdtable *fdt;

        spin_lock(&files->file_lock);
        fdt = files_fdtable(files);

        if (fd >= fdt->max_fds)
                goto out_unlock;

        fp = fdt->fd[fd];
        if (!fp)
                goto out_unlock;

        rcu_assign_pointer(fdt->fd[fd], NULL);
        FD_CLR(fd, fdt->close_on_exec);

	 /* Dropping the lock here exposes a minor race but it allows me
	  * to use the existing kernel interfaces for this, and for a test
	  * case I think that's reasonable. */
        spin_unlock(&files->file_lock);
        put_unused_fd(fd);

out_unlock:
        spin_unlock(&files->file_lock);
        return -EBADF;
} /* fd_uninstall() */

static int
splat_vnode_test7(struct file *file, void *arg)
{
	char buf1[32] = "SPL VNode Interface Test File\n";
	char buf2[32] = "";
	struct file *lfp;
	file_t *fp;
	int rc, fd;

	/* Prep work needed to test getf/releasef */
	fd = get_unused_fd();
	if (fd < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
			     "Failed to get unused fd (%d)\n", fd);
		return fd;
	}

        lfp = filp_open(SPLAT_VNODE_TEST_FILE_RW, O_RDWR|O_CREAT|O_EXCL, 0644);
	if (IS_ERR(lfp)) {
		put_unused_fd(fd);
		rc = PTR_ERR(lfp);
		splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
			     "Failed to filp_open: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		return rc;
	}

	/* Pair up the new fd and lfp in the current context, this allows
	 * getf to lookup the file struct simply by the known open fd */
	fd_install(fd, lfp);

	/* Actual getf()/releasef() test */
	fp = vn_getf(fd);
	if (fp == NULL) {
		rc = -EINVAL;
		splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
			     "Failed to getf fd %d: (%d)\n", fd, rc);
		goto out;
	}

        rc = vn_rdwr(UIO_WRITE, fp->f_vnode, buf1, strlen(buf1), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
			     "Failed vn_rdwr write of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		goto out;
	}

        rc = vn_rdwr(UIO_READ, fp->f_vnode, buf2, strlen(buf1), 0,
                     UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	if (rc < 0) {
		splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
			     "Failed vn_rdwr read of test file: %s (%d)\n",
			     SPLAT_VNODE_TEST_FILE_RW, rc);
		goto out;
	}

	if (strncmp(buf1, buf2, strlen(buf1))) {
		rc = -EINVAL;
		splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
			     "Failed strncmp data written does not match "
			     "data read\nWrote: %sRead:  %s\n", buf1, buf2);
		goto out;
	}

	rc = 0;
	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read:  %s", buf2);
	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
		     "read expected data pattern to test file: %s\n",
		     SPLAT_VNODE_TEST_FILE_RW);
out:
	vn_releasef(fd);
	fd_uninstall(fd);
        filp_close(lfp, 0);
	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);

        return rc;
} /* splat_vnode_test7() */

splat_subsystem_t *
splat_vnode_init(void)
{
        splat_subsystem_t *sub;

        sub = kmalloc(sizeof(*sub), GFP_KERNEL);
        if (sub == NULL)
                return NULL;

        memset(sub, 0, sizeof(*sub));
        strncpy(sub->desc.name, SPLAT_VNODE_NAME, SPLAT_NAME_SIZE);
	strncpy(sub->desc.desc, SPLAT_VNODE_DESC, SPLAT_DESC_SIZE);
        INIT_LIST_HEAD(&sub->subsystem_list);
	INIT_LIST_HEAD(&sub->test_list);
        spin_lock_init(&sub->test_lock);
        sub->desc.id = SPLAT_SUBSYSTEM_VNODE;

        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST1_NAME, SPLAT_VNODE_TEST1_DESC,
	                SPLAT_VNODE_TEST1_ID, splat_vnode_test1);
        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST2_NAME, SPLAT_VNODE_TEST2_DESC,
	                SPLAT_VNODE_TEST2_ID, splat_vnode_test2);
        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST3_NAME, SPLAT_VNODE_TEST3_DESC,
	                SPLAT_VNODE_TEST3_ID, splat_vnode_test3);
        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST4_NAME, SPLAT_VNODE_TEST4_DESC,
	                SPLAT_VNODE_TEST4_ID, splat_vnode_test4);
        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST5_NAME, SPLAT_VNODE_TEST5_DESC,
	                SPLAT_VNODE_TEST5_ID, splat_vnode_test5);
        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST6_NAME, SPLAT_VNODE_TEST6_DESC,
	                SPLAT_VNODE_TEST6_ID, splat_vnode_test6);
        SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST7_NAME, SPLAT_VNODE_TEST7_DESC,
	                SPLAT_VNODE_TEST7_ID, splat_vnode_test7);

        return sub;
} /* splat_vnode_init() */

void
splat_vnode_fini(splat_subsystem_t *sub)
{
        ASSERT(sub);

        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST7_ID);
        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST6_ID);
        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST5_ID);
        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST4_ID);
        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST3_ID);
        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST2_ID);
        SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST1_ID);

        kfree(sub);
} /* splat_vnode_fini() */

int
splat_vnode_id(void)
{
        return SPLAT_SUBSYSTEM_VNODE;
} /* splat_vnode_id() */
Commit	Line	Data
715f6251	1	/*
	2	* This file is part of the SPL: Solaris Porting Layer.
	3	*
	4	* Copyright (c) 2008 Lawrence Livermore National Security, LLC.
	5	* Produced at Lawrence Livermore National Laboratory
	6	* Written by:
	7	* Brian Behlendorf <behlendorf1@llnl.gov>,
	8	* Herb Wartens <wartens2@llnl.gov>,
	9	* Jim Garlick <garlick@llnl.gov>
	10	* UCRL-CODE-235197
	11	*
	12	* This is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This is distributed in the hope that it will be useful, but WITHOUT
	18	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	19	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	20	* for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License along
	23	* with this program; if not, write to the Free Software Foundation, Inc.,
	24	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	25	*/
	26
4b171585	27	#include "splat-internal.h"
e4f1d29f	28	#include <linux/rcupdate.h>
4b171585	29
	30	#define SPLAT_SUBSYSTEM_VNODE 0x0900
	31	#define SPLAT_VNODE_NAME "vnode"
	32	#define SPLAT_VNODE_DESC "Kernel Vnode Tests"
	33
	34	#define SPLAT_VNODE_TEST1_ID 0x0901
	35	#define SPLAT_VNODE_TEST1_NAME "vn_open"
	36	#define SPLAT_VNODE_TEST1_DESC "Vn_open Test"
	37
	38	#define SPLAT_VNODE_TEST2_ID 0x0902
	39	#define SPLAT_VNODE_TEST2_NAME "vn_openat"
	40	#define SPLAT_VNODE_TEST2_DESC "Vn_openat Test"
	41
	42	#define SPLAT_VNODE_TEST3_ID 0x0903
	43	#define SPLAT_VNODE_TEST3_NAME "vn_rdwr"
	44	#define SPLAT_VNODE_TEST3_DESC "Vn_rdwrt Test"
	45
	46	#define SPLAT_VNODE_TEST4_ID 0x0904
	47	#define SPLAT_VNODE_TEST4_NAME "vn_rename"
	48	#define SPLAT_VNODE_TEST4_DESC "Vn_rename Test"
	49
	50	#define SPLAT_VNODE_TEST5_ID 0x0905
	51	#define SPLAT_VNODE_TEST5_NAME "vn_getattr"
	52	#define SPLAT_VNODE_TEST5_DESC "Vn_getattr Test"
	53
	54	#define SPLAT_VNODE_TEST6_ID 0x0906
	55	#define SPLAT_VNODE_TEST6_NAME "vn_sync"
	56	#define SPLAT_VNODE_TEST6_DESC "Vn_sync Test"
	57
e4f1d29f	58	#define SPLAT_VNODE_TEST7_ID 0x0907
4e62fd41	59	#define SPLAT_VNODE_TEST7_NAME "vn_getf"
4e62fd41	60	#define SPLAT_VNODE_TEST7_DESC "vn_getf/vn_releasef Test"
e4f1d29f	61
4b171585	62	#define SPLAT_VNODE_TEST_FILE "/etc/fstab"
	63	#define SPLAT_VNODE_TEST_FILE_AT "etc/fstab"
	64	#define SPLAT_VNODE_TEST_FILE_RW "/tmp/spl.vnode.tmp"
	65	#define SPLAT_VNODE_TEST_FILE_RW1 "/tmp/spl.vnode.tmp.1"
	66	#define SPLAT_VNODE_TEST_FILE_RW2 "/tmp/spl.vnode.tmp.2"
	67
	68	static int
	69	splat_vnode_test1(struct file file, void arg)
	70	{
	71	vnode_t *vp;
	72	int rc;
	73
	74	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
	75	FREAD, 0644, &vp, 0, 0))) {
	76	splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
	77	"Failed to vn_open test file: %s (%d)\n",
	78	SPLAT_VNODE_TEST_FILE, rc);
	79	return rc;
	80	}
	81
	82	rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	83	VN_RELE(vp);
	84
	85	if (rc) {
	86	splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
	87	"Failed to vn_close test file: %s (%d)\n",
	88	SPLAT_VNODE_TEST_FILE, rc);
	89	return rc;
	90	}
	91
	92	splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully vn_open'ed "
	93	"and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);
	94
	95	return rc;
	96	} /* splat_vnode_test1() */
	97
	98	static int
	99	splat_vnode_test2(struct file file, void arg)
	100	{
	101	vnode_t *vp;
	102	int rc;
	103
	104	if ((rc = vn_openat(SPLAT_VNODE_TEST_FILE_AT, UIO_SYSSPACE,
	105	FREAD, 0644, &vp, 0, 0, rootdir, 0))) {
	106	splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
	107	"Failed to vn_openat test file: %s (%d)\n",
	108	SPLAT_VNODE_TEST_FILE, rc);
	109	return rc;
	110	}
	111
	112	rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	113	VN_RELE(vp);
	114
	115	if (rc) {
	116	splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
	117	"Failed to vn_close test file: %s (%d)\n",
	118	SPLAT_VNODE_TEST_FILE, rc);
	119	return rc;
	120	}
	121
	122	splat_vprint(file, SPLAT_VNODE_TEST2_NAME, "Successfully vn_openat'ed "
	123	"and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);
	124
	125	return rc;
126	} /* splat_vnode_test2() */
127
128	static int
129	splat_vnode_test3(struct file file, void arg)
130	{
131	vnode_t *vp;
132	char buf1[32] = "SPL VNode Interface Test File\n";
133	char buf2[32] = "";
134	int rc;
135
136	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
137	FWRITE \| FREAD \| FCREAT \| FEXCL,
138	0644, &vp, 0, 0))) {
139	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
140	"Failed to vn_open test file: %s (%d)\n",
141	SPLAT_VNODE_TEST_FILE_RW, rc);
142	return rc;
143	}
144
145	rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
146	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
147	if (rc < 0) {
148	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
149	"Failed vn_rdwr write of test file: %s (%d)\n",
150	SPLAT_VNODE_TEST_FILE_RW, rc);
151	goto out;
152	}
153
154	rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
155	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
156	if (rc < 0) {
157	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
158	"Failed vn_rdwr read of test file: %s (%d)\n",
159	SPLAT_VNODE_TEST_FILE_RW, rc);
160	goto out;
161	}
162
163	if (strncmp(buf1, buf2, strlen(buf1))) {
e4f1d29f	164	rc = -EINVAL;
4b171585	165	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
	166	"Failed strncmp data written does not match "
	167	"data read\nWrote: %sRead: %s\n", buf1, buf2);
	168	goto out;
	169	}
	170
	171	rc = 0;
	172	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
	173	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read: %s", buf2);
	174	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
	175	"read expected data pattern to test file: %s\n",
	176	SPLAT_VNODE_TEST_FILE_RW);
	177
	178	out:
	179	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	180	VN_RELE(vp);
2f5d55aa	181	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
4b171585	182
	183	return rc;
	184	} /* splat_vnode_test3() */
	185
	186	static int
	187	splat_vnode_test4(struct file file, void arg)
	188	{
	189	vnode_t *vp;
	190	char buf1[32] = "SPL VNode Interface Test File\n";
	191	char buf2[32] = "";
	192	int rc;
	193
	194	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE,
	195	FWRITE \| FREAD \| FCREAT \| FEXCL, 0644, &vp, 0, 0))) {
	196	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	197	"Failed to vn_open test file: %s (%d)\n",
	198	SPLAT_VNODE_TEST_FILE_RW1, rc);
	199	goto out;
	200	}
	201
	202	rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
	203	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	204	if (rc < 0) {
	205	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	206	"Failed vn_rdwr write of test file: %s (%d)\n",
	207	SPLAT_VNODE_TEST_FILE_RW1, rc);
	208	goto out2;
	209	}
	210
	211	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	212	VN_RELE(vp);
	213
	214	rc = vn_rename(SPLAT_VNODE_TEST_FILE_RW1,SPLAT_VNODE_TEST_FILE_RW2,0);
	215	if (rc) {
	216	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Failed vn_rename "
	217	"%s -> %s (%d)\n",
	218	SPLAT_VNODE_TEST_FILE_RW1,
	219	SPLAT_VNODE_TEST_FILE_RW2, rc);
	220	goto out;
	221	}
	222
	223	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE,
	224	FREAD \| FEXCL, 0644, &vp, 0, 0))) {
	225	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	226	"Failed to vn_open test file: %s (%d)\n",
	227	SPLAT_VNODE_TEST_FILE_RW2, rc);
	228	goto out;
	229	}
	230
	231	rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
	232	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	233	if (rc < 0) {
	234	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	235	"Failed vn_rdwr read of test file: %s (%d)\n",
	236	SPLAT_VNODE_TEST_FILE_RW2, rc);
	237	goto out2;
	238	}
	239
	240	if (strncmp(buf1, buf2, strlen(buf1))) {
	241	rc = EINVAL;
	242	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	243	"Failed strncmp data written does not match "
	244	"data read\nWrote: %sRead: %s\n", buf1, buf2);
	245	goto out2;
246	}
247
248	rc = 0;
249	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Wrote to %s: %s",
250	SPLAT_VNODE_TEST_FILE_RW1, buf1);
251	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Read from %s: %s",
252	SPLAT_VNODE_TEST_FILE_RW2, buf2);
253	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Successfully renamed "
254	"test file %s -> %s and verified data pattern\n",
255	SPLAT_VNODE_TEST_FILE_RW1, SPLAT_VNODE_TEST_FILE_RW2);
256	out2:
257	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
258	VN_RELE(vp);
259	out:
2f5d55aa	260	vn_remove(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE, RMFILE);
2f5d55aa	261	vn_remove(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE, RMFILE);
4b171585	262
	263	return rc;
	264	} /* splat_vnode_test4() */
	265
	266	static int
	267	splat_vnode_test5(struct file file, void arg)
	268	{
	269	vnode_t *vp;
	270	vattr_t vap;
	271	int rc;
	272
	273	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
	274	FREAD, 0644, &vp, 0, 0))) {
	275	splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
	276	"Failed to vn_open test file: %s (%d)\n",
	277	SPLAT_VNODE_TEST_FILE, rc);
	278	return rc;
	279	}
	280
	281	rc = VOP_GETATTR(vp, &vap, 0, 0, NULL);
	282	if (rc) {
	283	splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
	284	"Failed to vn_getattr test file: %s (%d)\n",
	285	SPLAT_VNODE_TEST_FILE, rc);
	286	goto out;
	287	}
	288
	289	if (vap.va_type != VREG) {
	290	rc = -EINVAL;
	291	splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
	292	"Failed expected regular file type "
	293	"(%d != VREG): %s (%d)\n", vap.va_type,
	294	SPLAT_VNODE_TEST_FILE, rc);
	295	goto out;
	296	}
	297
	298	splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully "
	299	"vn_getattr'ed test file: %s\n", SPLAT_VNODE_TEST_FILE);
	300
	301	out:
	302	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	303	VN_RELE(vp);
	304
	305	return rc;
	306	} /* splat_vnode_test5() */
	307
	308	static int
	309	splat_vnode_test6(struct file file, void arg)
	310	{
	311	vnode_t *vp;
	312	char buf[32] = "SPL VNode Interface Test File\n";
	313	int rc;
	314
	315	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
728b9dd8	316	FWRITE \| FCREAT \| FEXCL, 0644, &vp, 0, 0))) {
4b171585	317	splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
	318	"Failed to vn_open test file: %s (%d)\n",
	319	SPLAT_VNODE_TEST_FILE_RW, rc);
	320	return rc;
	321	}
	322
	323	rc = vn_rdwr(UIO_WRITE, vp, buf, strlen(buf), 0,
	324	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	325	if (rc < 0) {
	326	splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
	327	"Failed vn_rdwr write of test file: %s (%d)\n",
	328	SPLAT_VNODE_TEST_FILE_RW, rc);
	329	goto out;
	330	}
	331
	332	rc = vn_fsync(vp, 0, 0, 0);
	333	if (rc) {
	334	splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
	335	"Failed vn_fsync of test file: %s (%d)\n",
	336	SPLAT_VNODE_TEST_FILE_RW, rc);
	337	goto out;
	338	}
	339
	340	rc = 0;
	341	splat_vprint(file, SPLAT_VNODE_TEST6_NAME, "Successfully "
	342	"fsync'ed test file %s\n", SPLAT_VNODE_TEST_FILE_RW);
	343	out:
	344	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	345	VN_RELE(vp);
2f5d55aa	346	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
4b171585	347
4b171585	348	return rc;
e4f1d29f	349	} /* splat_vnode_test6() */
	350
	351	/* Basically a slightly modified version of sys_close() */
	352	static int
	353	fd_uninstall(int fd)
	354	{
	355	struct file *fp;
	356	struct files_struct *files = current->files;
	357	struct fdtable *fdt;
	358
	359	spin_lock(&files->file_lock);
	360	fdt = files_fdtable(files);
	361
	362	if (fd >= fdt->max_fds)
	363	goto out_unlock;
	364
	365	fp = fdt->fd[fd];
	366	if (!fp)
	367	goto out_unlock;
	368
	369	rcu_assign_pointer(fdt->fd[fd], NULL);
	370	FD_CLR(fd, fdt->close_on_exec);
	371
	372	/* Dropping the lock here exposes a minor race but it allows me
	373	* to use the existing kernel interfaces for this, and for a test
	374	* case I think that's reasonable. */
	375	spin_unlock(&files->file_lock);
	376	put_unused_fd(fd);
	377
	378	out_unlock:
	379	spin_unlock(&files->file_lock);
	380	return -EBADF;
	381	} /* fd_uninstall() */
	382
	383	static int
	384	splat_vnode_test7(struct file file, void arg)
	385	{
	386	char buf1[32] = "SPL VNode Interface Test File\n";
	387	char buf2[32] = "";
	388	struct file *lfp;
	389	file_t *fp;
	390	int rc, fd;
	391
	392	/* Prep work needed to test getf/releasef */
	393	fd = get_unused_fd();
	394	if (fd < 0) {
	395	splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
	396	"Failed to get unused fd (%d)\n", fd);
	397	return fd;
	398	}
	399
	400	lfp = filp_open(SPLAT_VNODE_TEST_FILE_RW, O_RDWR\|O_CREAT\|O_EXCL, 0644);
	401	if (IS_ERR(lfp)) {
	402	put_unused_fd(fd);
	403	rc = PTR_ERR(lfp);
	404	splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
	405	"Failed to filp_open: %s (%d)\n",
	406	SPLAT_VNODE_TEST_FILE_RW, rc);
	407	return rc;
	408	}
	409
	410	/* Pair up the new fd and lfp in the current context, this allows
	411	* getf to lookup the file struct simply by the known open fd */
	412	fd_install(fd, lfp);
413
414	/* Actual getf()/releasef() test */
415	fp = vn_getf(fd);
416	if (fp == NULL) {
417	rc = -EINVAL;
418	splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
419	"Failed to getf fd %d: (%d)\n", fd, rc);
420	goto out;
421	}
422
423	rc = vn_rdwr(UIO_WRITE, fp->f_vnode, buf1, strlen(buf1), 0,
424	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
425	if (rc < 0) {
426	splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
427	"Failed vn_rdwr write of test file: %s (%d)\n",
428	SPLAT_VNODE_TEST_FILE_RW, rc);
429	goto out;
430	}
431
432	rc = vn_rdwr(UIO_READ, fp->f_vnode, buf2, strlen(buf1), 0,
433	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
434	if (rc < 0) {
435	splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
436	"Failed vn_rdwr read of test file: %s (%d)\n",
437	SPLAT_VNODE_TEST_FILE_RW, rc);
438	goto out;
439	}
440
441	if (strncmp(buf1, buf2, strlen(buf1))) {
442	rc = -EINVAL;
443	splat_vprint(file, SPLAT_VNODE_TEST7_NAME,
444	"Failed strncmp data written does not match "
445	"data read\nWrote: %sRead: %s\n", buf1, buf2);
446	goto out;
447	}
448
449	rc = 0;
450	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
451	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read: %s", buf2);
452	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
453	"read expected data pattern to test file: %s\n",
454	SPLAT_VNODE_TEST_FILE_RW);
455	out:
456	vn_releasef(fd);
457	fd_uninstall(fd);
458	filp_close(lfp, 0);
459	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
460
461	return rc;
462	} /* splat_vnode_test7() */
4b171585	463
	464	splat_subsystem_t *
	465	splat_vnode_init(void)
	466	{
	467	splat_subsystem_t *sub;
	468
	469	sub = kmalloc(sizeof(*sub), GFP_KERNEL);
	470	if (sub == NULL)
	471	return NULL;
	472
	473	memset(sub, 0, sizeof(*sub));
	474	strncpy(sub->desc.name, SPLAT_VNODE_NAME, SPLAT_NAME_SIZE);
	475	strncpy(sub->desc.desc, SPLAT_VNODE_DESC, SPLAT_DESC_SIZE);
	476	INIT_LIST_HEAD(&sub->subsystem_list);
	477	INIT_LIST_HEAD(&sub->test_list);
	478	spin_lock_init(&sub->test_lock);
	479	sub->desc.id = SPLAT_SUBSYSTEM_VNODE;
	480
	481	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST1_NAME, SPLAT_VNODE_TEST1_DESC,
	482	SPLAT_VNODE_TEST1_ID, splat_vnode_test1);
	483	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST2_NAME, SPLAT_VNODE_TEST2_DESC,
	484	SPLAT_VNODE_TEST2_ID, splat_vnode_test2);
	485	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST3_NAME, SPLAT_VNODE_TEST3_DESC,
	486	SPLAT_VNODE_TEST3_ID, splat_vnode_test3);
	487	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST4_NAME, SPLAT_VNODE_TEST4_DESC,
	488	SPLAT_VNODE_TEST4_ID, splat_vnode_test4);
	489	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST5_NAME, SPLAT_VNODE_TEST5_DESC,
	490	SPLAT_VNODE_TEST5_ID, splat_vnode_test5);
	491	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST6_NAME, SPLAT_VNODE_TEST6_DESC,
	492	SPLAT_VNODE_TEST6_ID, splat_vnode_test6);
e4f1d29f	493	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST7_NAME, SPLAT_VNODE_TEST7_DESC,
e4f1d29f	494	SPLAT_VNODE_TEST7_ID, splat_vnode_test7);
4b171585	495
	496	return sub;
	497	} /* splat_vnode_init() */
	498
	499	void
	500	splat_vnode_fini(splat_subsystem_t *sub)
	501	{
	502	ASSERT(sub);
	503
e4f1d29f	504	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST7_ID);
4b171585	505	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST6_ID);
	506	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST5_ID);
	507	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST4_ID);
	508	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST3_ID);
	509	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST2_ID);
	510	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST1_ID);
	511
	512	kfree(sub);
	513	} /* splat_vnode_fini() */
	514
	515	int
	516	splat_vnode_id(void)
	517	{
	518	return SPLAT_SUBSYSTEM_VNODE;
	519	} /* splat_vnode_id() */