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

#include "splat-internal.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_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 | FREAD | 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_test4() */

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

        return sub;
} /* splat_vnode_init() */

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

        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
4b171585	1	#include "splat-internal.h"
	2
	3	#define SPLAT_SUBSYSTEM_VNODE 0x0900
	4	#define SPLAT_VNODE_NAME "vnode"
	5	#define SPLAT_VNODE_DESC "Kernel Vnode Tests"
	6
	7	#define SPLAT_VNODE_TEST1_ID 0x0901
	8	#define SPLAT_VNODE_TEST1_NAME "vn_open"
	9	#define SPLAT_VNODE_TEST1_DESC "Vn_open Test"
	10
	11	#define SPLAT_VNODE_TEST2_ID 0x0902
	12	#define SPLAT_VNODE_TEST2_NAME "vn_openat"
	13	#define SPLAT_VNODE_TEST2_DESC "Vn_openat Test"
	14
	15	#define SPLAT_VNODE_TEST3_ID 0x0903
	16	#define SPLAT_VNODE_TEST3_NAME "vn_rdwr"
	17	#define SPLAT_VNODE_TEST3_DESC "Vn_rdwrt Test"
	18
	19	#define SPLAT_VNODE_TEST4_ID 0x0904
	20	#define SPLAT_VNODE_TEST4_NAME "vn_rename"
	21	#define SPLAT_VNODE_TEST4_DESC "Vn_rename Test"
	22
	23	#define SPLAT_VNODE_TEST5_ID 0x0905
	24	#define SPLAT_VNODE_TEST5_NAME "vn_getattr"
	25	#define SPLAT_VNODE_TEST5_DESC "Vn_getattr Test"
	26
	27	#define SPLAT_VNODE_TEST6_ID 0x0906
	28	#define SPLAT_VNODE_TEST6_NAME "vn_sync"
	29	#define SPLAT_VNODE_TEST6_DESC "Vn_sync Test"
	30
	31	#define SPLAT_VNODE_TEST_FILE "/etc/fstab"
	32	#define SPLAT_VNODE_TEST_FILE_AT "etc/fstab"
	33	#define SPLAT_VNODE_TEST_FILE_RW "/tmp/spl.vnode.tmp"
	34	#define SPLAT_VNODE_TEST_FILE_RW1 "/tmp/spl.vnode.tmp.1"
	35	#define SPLAT_VNODE_TEST_FILE_RW2 "/tmp/spl.vnode.tmp.2"
	36
	37	static int
	38	splat_vnode_test1(struct file file, void arg)
	39	{
	40	vnode_t *vp;
	41	int rc;
	42
	43	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
	44	FREAD, 0644, &vp, 0, 0))) {
	45	splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
	46	"Failed to vn_open test file: %s (%d)\n",
	47	SPLAT_VNODE_TEST_FILE, rc);
	48	return rc;
	49	}
	50
	51	rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	52	VN_RELE(vp);
	53
	54	if (rc) {
	55	splat_vprint(file, SPLAT_VNODE_TEST1_NAME,
	56	"Failed to vn_close test file: %s (%d)\n",
	57	SPLAT_VNODE_TEST_FILE, rc);
	58	return rc;
	59	}
	60
	61	splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully vn_open'ed "
	62	"and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);
	63
	64	return rc;
65	} /* splat_vnode_test1() */
66
67	static int
68	splat_vnode_test2(struct file file, void arg)
69	{
70	vnode_t *vp;
71	int rc;
72
73	if ((rc = vn_openat(SPLAT_VNODE_TEST_FILE_AT, UIO_SYSSPACE,
74	FREAD, 0644, &vp, 0, 0, rootdir, 0))) {
75	splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
76	"Failed to vn_openat test file: %s (%d)\n",
77	SPLAT_VNODE_TEST_FILE, rc);
78	return rc;
79	}
80
81	rc = VOP_CLOSE(vp, 0, 0, 0, 0, 0);
82	VN_RELE(vp);
83
84	if (rc) {
85	splat_vprint(file, SPLAT_VNODE_TEST2_NAME,
86	"Failed to vn_close test file: %s (%d)\n",
87	SPLAT_VNODE_TEST_FILE, rc);
88	return rc;
89	}
90
91	splat_vprint(file, SPLAT_VNODE_TEST2_NAME, "Successfully vn_openat'ed "
92	"and vn_closed test file: %s\n", SPLAT_VNODE_TEST_FILE);
93
94	return rc;
95	} /* splat_vnode_test2() */
96
97	static int
98	splat_vnode_test3(struct file file, void arg)
99	{
100	vnode_t *vp;
101	char buf1[32] = "SPL VNode Interface Test File\n";
102	char buf2[32] = "";
103	int rc;
104
105	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
106	FWRITE \| FREAD \| FCREAT \| FEXCL,
107	0644, &vp, 0, 0))) {
108	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
109	"Failed to vn_open test file: %s (%d)\n",
110	SPLAT_VNODE_TEST_FILE_RW, rc);
111	return rc;
112	}
113
114	rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
115	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
116	if (rc < 0) {
117	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
118	"Failed vn_rdwr write of test file: %s (%d)\n",
119	SPLAT_VNODE_TEST_FILE_RW, rc);
120	goto out;
121	}
122
123	rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
124	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
125	if (rc < 0) {
126	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
127	"Failed vn_rdwr read of test file: %s (%d)\n",
128	SPLAT_VNODE_TEST_FILE_RW, rc);
129	goto out;
130	}
131
132	if (strncmp(buf1, buf2, strlen(buf1))) {
133	rc = EINVAL;
134	splat_vprint(file, SPLAT_VNODE_TEST3_NAME,
135	"Failed strncmp data written does not match "
136	"data read\nWrote: %sRead: %s\n", buf1, buf2);
137	goto out;
138	}
139
140	rc = 0;
141	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Wrote: %s", buf1);
142	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Read: %s", buf2);
143	splat_vprint(file, SPLAT_VNODE_TEST3_NAME, "Successfully wrote and "
144	"read expected data pattern to test file: %s\n",
145	SPLAT_VNODE_TEST_FILE_RW);
146
147	out:
148	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
149	VN_RELE(vp);
2f5d55aa	150	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
4b171585	151
	152	return rc;
	153	} /* splat_vnode_test3() */
	154
	155	static int
	156	splat_vnode_test4(struct file file, void arg)
	157	{
	158	vnode_t *vp;
	159	char buf1[32] = "SPL VNode Interface Test File\n";
	160	char buf2[32] = "";
	161	int rc;
	162
	163	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE,
	164	FWRITE \| FREAD \| FCREAT \| FEXCL, 0644, &vp, 0, 0))) {
	165	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	166	"Failed to vn_open test file: %s (%d)\n",
	167	SPLAT_VNODE_TEST_FILE_RW1, rc);
	168	goto out;
	169	}
	170
	171	rc = vn_rdwr(UIO_WRITE, vp, buf1, strlen(buf1), 0,
	172	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	173	if (rc < 0) {
	174	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	175	"Failed vn_rdwr write of test file: %s (%d)\n",
	176	SPLAT_VNODE_TEST_FILE_RW1, rc);
	177	goto out2;
	178	}
	179
	180	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	181	VN_RELE(vp);
	182
	183	rc = vn_rename(SPLAT_VNODE_TEST_FILE_RW1,SPLAT_VNODE_TEST_FILE_RW2,0);
	184	if (rc) {
	185	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Failed vn_rename "
	186	"%s -> %s (%d)\n",
	187	SPLAT_VNODE_TEST_FILE_RW1,
	188	SPLAT_VNODE_TEST_FILE_RW2, rc);
	189	goto out;
	190	}
	191
	192	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE,
	193	FREAD \| FEXCL, 0644, &vp, 0, 0))) {
	194	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	195	"Failed to vn_open test file: %s (%d)\n",
	196	SPLAT_VNODE_TEST_FILE_RW2, rc);
	197	goto out;
	198	}
	199
	200	rc = vn_rdwr(UIO_READ, vp, buf2, strlen(buf1), 0,
	201	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	202	if (rc < 0) {
	203	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	204	"Failed vn_rdwr read of test file: %s (%d)\n",
	205	SPLAT_VNODE_TEST_FILE_RW2, rc);
	206	goto out2;
	207	}
	208
	209	if (strncmp(buf1, buf2, strlen(buf1))) {
	210	rc = EINVAL;
	211	splat_vprint(file, SPLAT_VNODE_TEST4_NAME,
	212	"Failed strncmp data written does not match "
	213	"data read\nWrote: %sRead: %s\n", buf1, buf2);
	214	goto out2;
215	}
216
217	rc = 0;
218	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Wrote to %s: %s",
219	SPLAT_VNODE_TEST_FILE_RW1, buf1);
220	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Read from %s: %s",
221	SPLAT_VNODE_TEST_FILE_RW2, buf2);
222	splat_vprint(file, SPLAT_VNODE_TEST4_NAME, "Successfully renamed "
223	"test file %s -> %s and verified data pattern\n",
224	SPLAT_VNODE_TEST_FILE_RW1, SPLAT_VNODE_TEST_FILE_RW2);
225	out2:
226	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
227	VN_RELE(vp);
228	out:
2f5d55aa	229	vn_remove(SPLAT_VNODE_TEST_FILE_RW1, UIO_SYSSPACE, RMFILE);
2f5d55aa	230	vn_remove(SPLAT_VNODE_TEST_FILE_RW2, UIO_SYSSPACE, RMFILE);
4b171585	231
	232	return rc;
	233	} /* splat_vnode_test4() */
	234
	235	static int
	236	splat_vnode_test5(struct file file, void arg)
	237	{
	238	vnode_t *vp;
	239	vattr_t vap;
	240	int rc;
	241
	242	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE, UIO_SYSSPACE,
	243	FREAD, 0644, &vp, 0, 0))) {
	244	splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
	245	"Failed to vn_open test file: %s (%d)\n",
	246	SPLAT_VNODE_TEST_FILE, rc);
	247	return rc;
	248	}
	249
	250	rc = VOP_GETATTR(vp, &vap, 0, 0, NULL);
	251	if (rc) {
	252	splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
	253	"Failed to vn_getattr test file: %s (%d)\n",
	254	SPLAT_VNODE_TEST_FILE, rc);
	255	goto out;
	256	}
	257
	258	if (vap.va_type != VREG) {
	259	rc = -EINVAL;
	260	splat_vprint(file, SPLAT_VNODE_TEST5_NAME,
	261	"Failed expected regular file type "
	262	"(%d != VREG): %s (%d)\n", vap.va_type,
	263	SPLAT_VNODE_TEST_FILE, rc);
	264	goto out;
	265	}
	266
	267	splat_vprint(file, SPLAT_VNODE_TEST1_NAME, "Successfully "
	268	"vn_getattr'ed test file: %s\n", SPLAT_VNODE_TEST_FILE);
	269
	270	out:
	271	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
	272	VN_RELE(vp);
	273
	274	return rc;
	275	} /* splat_vnode_test5() */
	276
	277	static int
	278	splat_vnode_test6(struct file file, void arg)
	279	{
	280	vnode_t *vp;
	281	char buf[32] = "SPL VNode Interface Test File\n";
	282	int rc;
	283
	284	if ((rc = vn_open(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE,
	285	FWRITE \| FREAD \| FCREAT \| FEXCL, 0644, &vp, 0, 0))) {
	286	splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
	287	"Failed to vn_open test file: %s (%d)\n",
	288	SPLAT_VNODE_TEST_FILE_RW, rc);
	289	return rc;
	290	}
	291
	292	rc = vn_rdwr(UIO_WRITE, vp, buf, strlen(buf), 0,
	293	UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
	294	if (rc < 0) {
295	splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
296	"Failed vn_rdwr write of test file: %s (%d)\n",
297	SPLAT_VNODE_TEST_FILE_RW, rc);
298	goto out;
299	}
300
301	rc = vn_fsync(vp, 0, 0, 0);
302	if (rc) {
303	splat_vprint(file, SPLAT_VNODE_TEST6_NAME,
304	"Failed vn_fsync of test file: %s (%d)\n",
305	SPLAT_VNODE_TEST_FILE_RW, rc);
306	goto out;
307	}
308
309	rc = 0;
310	splat_vprint(file, SPLAT_VNODE_TEST6_NAME, "Successfully "
311	"fsync'ed test file %s\n", SPLAT_VNODE_TEST_FILE_RW);
312	out:
313	VOP_CLOSE(vp, 0, 0, 0, 0, 0);
314	VN_RELE(vp);
2f5d55aa	315	vn_remove(SPLAT_VNODE_TEST_FILE_RW, UIO_SYSSPACE, RMFILE);
4b171585	316
	317	return rc;
	318	} /* splat_vnode_test4() */
	319
	320	splat_subsystem_t *
	321	splat_vnode_init(void)
	322	{
	323	splat_subsystem_t *sub;
	324
	325	sub = kmalloc(sizeof(*sub), GFP_KERNEL);
	326	if (sub == NULL)
	327	return NULL;
	328
	329	memset(sub, 0, sizeof(*sub));
	330	strncpy(sub->desc.name, SPLAT_VNODE_NAME, SPLAT_NAME_SIZE);
	331	strncpy(sub->desc.desc, SPLAT_VNODE_DESC, SPLAT_DESC_SIZE);
	332	INIT_LIST_HEAD(&sub->subsystem_list);
	333	INIT_LIST_HEAD(&sub->test_list);
	334	spin_lock_init(&sub->test_lock);
	335	sub->desc.id = SPLAT_SUBSYSTEM_VNODE;
	336
	337	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST1_NAME, SPLAT_VNODE_TEST1_DESC,
	338	SPLAT_VNODE_TEST1_ID, splat_vnode_test1);
	339	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST2_NAME, SPLAT_VNODE_TEST2_DESC,
	340	SPLAT_VNODE_TEST2_ID, splat_vnode_test2);
	341	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST3_NAME, SPLAT_VNODE_TEST3_DESC,
	342	SPLAT_VNODE_TEST3_ID, splat_vnode_test3);
	343	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST4_NAME, SPLAT_VNODE_TEST4_DESC,
	344	SPLAT_VNODE_TEST4_ID, splat_vnode_test4);
	345	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST5_NAME, SPLAT_VNODE_TEST5_DESC,
	346	SPLAT_VNODE_TEST5_ID, splat_vnode_test5);
	347	SPLAT_TEST_INIT(sub, SPLAT_VNODE_TEST6_NAME, SPLAT_VNODE_TEST6_DESC,
	348	SPLAT_VNODE_TEST6_ID, splat_vnode_test6);
	349
	350	return sub;
	351	} /* splat_vnode_init() */
	352
	353	void
	354	splat_vnode_fini(splat_subsystem_t *sub)
	355	{
	356	ASSERT(sub);
	357
	358	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST6_ID);
	359	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST5_ID);
	360	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST4_ID);
	361	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST3_ID);
	362	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST2_ID);
	363	SPLAT_TEST_FINI(sub, SPLAT_VNODE_TEST1_ID);
	364
	365	kfree(sub);
	366	} /* splat_vnode_fini() */
	367
	368	int
	369	splat_vnode_id(void)
	370	{
	371	return SPLAT_SUBSYSTEM_VNODE;
	372	} /* splat_vnode_id() */