- Implemented vnode interfaces and 6 test cases to the test suite.
- Re-implmented kobj support based on the vnode support. - Add TESTS option to check.sh, and removed delay after module load. git-svn-id: https://outreach.scidac.gov/svn/spl/trunk@39 7e1ea52c-4ff2-0310-8f11-9dd32ca42a1c
This commit is contained in:
behlendo
parent
9490c14835
commit
4b17158506
6
FIXME
6
FIXME
|
|
@ -11,8 +11,4 @@ sys/u8_textprep_data - AlL borrowed from libsolcompat
|
|||
sys/acl.h _ All borrowed from libsolcompat
|
||||
sys/acl_impl.h _ All borrowed from libsolcompat
|
||||
|
||||
* Fix failure in rw lock test 6
|
||||
|
||||
* Non-atomic 64bit support for kstat.h
|
||||
|
||||
* Write vnode interface
|
||||
* Implement solaris style atomic interfaces
|
||||
|
|
|
|||
|
|
@ -5,21 +5,16 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/vnode.h>
|
||||
|
||||
typedef struct _buf {
|
||||
struct file *fp;
|
||||
vnode_t *vp;
|
||||
} _buf_t;
|
||||
|
||||
extern void *rootdir;
|
||||
|
||||
extern struct _buf *kobj_open_file(const char *name);
|
||||
extern void kobj_close_file(struct _buf *file);
|
||||
extern int kobj_read_file(struct _buf *file, char *buf,
|
||||
unsigned size, unsigned off);
|
||||
ssize_t size, offset_t off);
|
||||
extern int kobj_get_filesize(struct _buf *file, uint64_t *size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -56,21 +56,6 @@ extern "C" {
|
|||
#define NICE_TO_PRIO(nice) (MAX_RT_PRIO + (nice) + 20)
|
||||
#define PRIO_TO_NICE(prio) ((prio) - MAX_RT_PRIO - 20)
|
||||
|
||||
#define kred NULL
|
||||
|
||||
#define FREAD 1
|
||||
#define FWRITE 2
|
||||
#define FCREAT O_CREAT
|
||||
#define FTRUNC O_TRUNC
|
||||
#define FOFFMAX O_LARGEFILE
|
||||
#define FSYNC O_SYNC
|
||||
#define FDSYNC O_DSYNC
|
||||
#define FRSYNC O_RSYNC
|
||||
#define FEXCL O_EXCL
|
||||
|
||||
#define FNODSYNC 0x10000 /* fsync pseudo flag */
|
||||
#define FNOFOLLOW 0x20000 /* don't follow symlinks */
|
||||
|
||||
/* Missing macros
|
||||
*/
|
||||
#define PAGESIZE PAGE_SIZE
|
||||
|
|
@ -136,7 +121,6 @@ extern int highbit(unsigned long i);
|
|||
#define zone_dataset_visible(x, y) (1)
|
||||
#define INGLOBALZONE(z) (1)
|
||||
|
||||
/* XXX - Borrowed from zfs project libsolcompat/include/sys/sysmacros.h */
|
||||
/* common macros */
|
||||
#ifndef MIN
|
||||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
|
|
|
|||
|
|
@ -1,7 +1,10 @@
|
|||
#ifndef _SPL_UIO_H
|
||||
#define _SPL_UIO_H
|
||||
|
||||
typedef enum uio_rw { UIO_READ, UIO_WRITE } uio_rw_t;
|
||||
typedef enum uio_rw {
|
||||
UIO_READ = 0,
|
||||
UIO_WRITE = 1,
|
||||
} uio_rw_t;
|
||||
|
||||
#define UIO_SYSSPACE 1
|
||||
|
||||
|
|
|
|||
|
|
@ -1,11 +1,56 @@
|
|||
#ifndef _SPL_VNODE_H
|
||||
#define _SPL_VNODE_H
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/syscalls.h>
|
||||
#include <linux/fcntl.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#include <linux/dcache.h>
|
||||
#include <linux/namei.h>
|
||||
#include <linux/fs.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/uio.h>
|
||||
|
||||
#define XVA_MAPSIZE 3
|
||||
#define XVA_MAGIC 0x78766174
|
||||
|
||||
#define FREAD 1
|
||||
#define FWRITE 2
|
||||
#define FCREAT O_CREAT
|
||||
#define FTRUNC O_TRUNC
|
||||
#define FOFFMAX O_LARGEFILE
|
||||
#define FSYNC O_SYNC
|
||||
#define FDSYNC O_DSYNC
|
||||
#define FRSYNC O_RSYNC
|
||||
#define FEXCL O_EXCL
|
||||
#define FDIRECT O_DIRECT
|
||||
|
||||
#define FNODSYNC 0x10000 /* fsync pseudo flag */
|
||||
#define FNOFOLLOW 0x20000 /* don't follow symlinks */
|
||||
|
||||
#define AT_TYPE 0x00001
|
||||
#define AT_MODE 0x00002
|
||||
#undef AT_UID /* Conflicts with linux/auxvec.h */
|
||||
#define AT_UID 0x00004
|
||||
#undef AT_GID /* Conflicts with linux/auxvec.h */
|
||||
#define AT_GID 0x00008
|
||||
#define AT_FSID 0x00010
|
||||
#define AT_NODEID 0x00020
|
||||
#define AT_NLINK 0x00040
|
||||
#define AT_SIZE 0x00080
|
||||
#define AT_ATIME 0x00100
|
||||
#define AT_MTIME 0x00200
|
||||
#define AT_CTIME 0x00400
|
||||
#define AT_RDEV 0x00800
|
||||
#define AT_BLKSIZE 0x01000
|
||||
#define AT_NBLOCKS 0x02000
|
||||
#define AT_SEQ 0x08000
|
||||
#define AT_XVATTR 0x10000
|
||||
|
||||
#define CRCREAT 0
|
||||
|
||||
typedef enum vtype {
|
||||
VNON = 0,
|
||||
VREG = 1,
|
||||
|
|
@ -22,14 +67,28 @@ typedef enum vtype {
|
|||
} vtype_t;
|
||||
|
||||
typedef struct vnode {
|
||||
uint64_t v_size;
|
||||
int v_fd;
|
||||
mode_t v_mode;
|
||||
char *v_path;
|
||||
struct file *v_fp;
|
||||
vtype_t v_type;
|
||||
} vnode_t;
|
||||
|
||||
typedef struct vattr {
|
||||
enum vtype va_type; /* vnode type */
|
||||
u_short va_mode; /* acc mode */
|
||||
short va_uid; /* owner uid */
|
||||
short va_gid; /* owner gid */
|
||||
long va_fsid; /* fs id */
|
||||
long va_nodeid; /* node # */
|
||||
short va_nlink; /* # links */
|
||||
u_long va_size; /* file size */
|
||||
long va_blocksize; /* block size */
|
||||
struct timeval va_atime; /* last acc */
|
||||
struct timeval va_mtime; /* last mod */
|
||||
struct timeval va_ctime; /* last chg */
|
||||
dev_t va_rdev; /* dev */
|
||||
long va_blocks; /* space used */
|
||||
} vattr_t;
|
||||
|
||||
#if 0
|
||||
typedef struct xoptattr {
|
||||
timestruc_t xoa_createtime; /* Create time of file */
|
||||
uint8_t xoa_archive;
|
||||
|
|
@ -46,12 +105,6 @@ typedef struct xoptattr {
|
|||
uint8_t xoa_av_modified;
|
||||
} xoptattr_t;
|
||||
|
||||
typedef struct vattr {
|
||||
uint_t va_mask; /* bit-mask of attributes */
|
||||
u_offset_t va_size; /* file size in bytes */
|
||||
} vattr_t;
|
||||
|
||||
|
||||
typedef struct xvattr {
|
||||
vattr_t xva_vattr; /* Embedded vattr structure */
|
||||
uint32_t xva_magic; /* Magic Number */
|
||||
|
|
@ -70,46 +123,28 @@ typedef struct vsecattr {
|
|||
void *vsa_dfaclentp; /* pointer to default ACL entries */
|
||||
size_t vsa_aclentsz; /* ACE size in bytes of vsa_aclentp */
|
||||
} vsecattr_t;
|
||||
#endif
|
||||
|
||||
#define AT_TYPE 0x00001
|
||||
#define AT_MODE 0x00002
|
||||
// #define AT_UID 0x00004 /* Conflicts with linux/auxvec.h */
|
||||
// #define AT_GID 0x00008 /* Conflicts with linux/auxvec.h */
|
||||
#define AT_FSID 0x00010
|
||||
#define AT_NODEID 0x00020
|
||||
#define AT_NLINK 0x00040
|
||||
#define AT_SIZE 0x00080
|
||||
#define AT_ATIME 0x00100
|
||||
#define AT_MTIME 0x00200
|
||||
#define AT_CTIME 0x00400
|
||||
#define AT_RDEV 0x00800
|
||||
#define AT_BLKSIZE 0x01000
|
||||
#define AT_NBLOCKS 0x02000
|
||||
#define AT_SEQ 0x08000
|
||||
#define AT_XVATTR 0x10000
|
||||
extern int vn_open(const char *path, int seg, int flags, int mode,
|
||||
vnode_t **vpp, int x1, void *x2);
|
||||
extern int vn_openat(const char *path, int seg, int flags, int mode,
|
||||
vnode_t **vpp, int x1, void *x2, vnode_t *vp, int fd);
|
||||
extern int vn_rdwr(uio_rw_t uio, vnode_t *vp, void *addr, ssize_t len,
|
||||
offset_t off, int seg, int x1, rlim64_t x2,
|
||||
void *x3, ssize_t *residp);
|
||||
extern int vn_close(vnode_t *vp, int flags, int x1, int x2, int x3, int x4);
|
||||
extern int vn_remove(const char *path, int x1, int x2);
|
||||
extern int vn_rename(const char *path1, const char *path2, int x1);
|
||||
extern int vn_getattr(vnode_t *vp, vattr_t *vap, int flags, int x3, void *x4);
|
||||
extern int vn_fsync(vnode_t *vp, int flags, int x3, int x4);
|
||||
|
||||
#define CRCREAT 0
|
||||
#define VOP_CLOSE vn_close
|
||||
#define VN_RELE(vp)
|
||||
#define VOP_GETATTR vn_getattr
|
||||
#define VOP_FSYNC vn_fsync
|
||||
#define VOP_PUTPAGE(vp, of, sz, fl, cr, ct)
|
||||
#define vn_is_readonly(vp) 0
|
||||
|
||||
#define VOP_CLOSE(vp, f, c, o, cr, ct) 0
|
||||
#define VOP_PUTPAGE(vp, of, sz, fl, cr, ct) 0
|
||||
#define VOP_GETATTR(vp, vap, fl, cr, ct) ((vap)->va_size = (vp)->v_size, 0)
|
||||
|
||||
#define VOP_FSYNC(vp, f, cr, ct) sys_fsync((vp)->v_fd)
|
||||
|
||||
#define VN_RELE(vp) vn_close(vp)
|
||||
|
||||
extern int vn_open(char *path, int x1, int oflags, int mode, vnode_t **vpp,
|
||||
int x2, int x3);
|
||||
extern int vn_openat(char *path, int x1, int oflags, int mode, vnode_t **vpp,
|
||||
int x2, int x3, vnode_t *vp, int fd);
|
||||
extern int vn_rdwr(int uio, vnode_t *vp, void *addr, ssize_t len,
|
||||
offset_t offset, int x1, int x2, rlim64_t x3, void *x4, ssize_t *residp);
|
||||
extern void vn_close(vnode_t *vp);
|
||||
|
||||
#define vn_remove(path, x1, x2) remove(path)
|
||||
#define vn_rename(from, to, seg) rename((from), (to))
|
||||
#define vn_is_readonly(vp) B_FALSE
|
||||
|
||||
extern vnode_t *rootdir;
|
||||
extern void *rootdir;
|
||||
|
||||
#endif /* SPL_VNODE_H */
|
||||
|
|
|
|||
|
|
@ -1,21 +1,18 @@
|
|||
#include <sys/kobj.h>
|
||||
#include "config.h"
|
||||
|
||||
void *rootdir = NULL;
|
||||
EXPORT_SYMBOL(rootdir);
|
||||
|
||||
struct _buf *
|
||||
kobj_open_file(const char *name)
|
||||
{
|
||||
struct _buf *file;
|
||||
struct file *fp;
|
||||
vnode_t *vp;
|
||||
int rc;
|
||||
|
||||
fp = filp_open(name, O_RDONLY, 0644);
|
||||
if (IS_ERR(fp))
|
||||
if ((rc = vn_open(name, UIO_SYSSPACE, FREAD, 0644, &vp, 0, 0)))
|
||||
return ((_buf_t *)-1UL);
|
||||
|
||||
file = kmem_zalloc(sizeof(_buf_t), KM_SLEEP);
|
||||
file->fp = fp;
|
||||
file = kmalloc(sizeof(_buf_t), GFP_KERNEL);
|
||||
file->vp = vp;
|
||||
|
||||
return file;
|
||||
} /* kobj_open_file() */
|
||||
|
|
@ -24,52 +21,34 @@ EXPORT_SYMBOL(kobj_open_file);
|
|||
void
|
||||
kobj_close_file(struct _buf *file)
|
||||
{
|
||||
filp_close(file->fp, 0);
|
||||
kmem_free(file, sizeof(_buf_t));
|
||||
VOP_CLOSE(file->vp, 0, 0, 0, 0, 0);
|
||||
VN_RELE(file->vp);
|
||||
kfree(file);
|
||||
|
||||
return;
|
||||
} /* kobj_close_file() */
|
||||
EXPORT_SYMBOL(kobj_close_file);
|
||||
|
||||
int
|
||||
kobj_read_file(struct _buf *file, char *buf, unsigned size, unsigned off)
|
||||
kobj_read_file(struct _buf *file, char *buf, ssize_t size, offset_t off)
|
||||
{
|
||||
loff_t offset = off;
|
||||
mm_segment_t saved_fs;
|
||||
int rc;
|
||||
|
||||
if (!file || !file->fp)
|
||||
return -EINVAL;
|
||||
|
||||
if (!file->fp->f_op || !file->fp->f_op->read)
|
||||
return -ENOSYS;
|
||||
|
||||
/* Writable user data segment must be briefly increased for this
|
||||
* process so we can use the user space read call paths to write
|
||||
* in to memory allocated by the kernel. */
|
||||
saved_fs = get_fs();
|
||||
set_fs(get_ds());
|
||||
rc = file->fp->f_op->read(file->fp, buf, size, &offset);
|
||||
set_fs(saved_fs);
|
||||
|
||||
return rc;
|
||||
return vn_rdwr(UIO_READ, file->vp, buf, size, off,
|
||||
UIO_SYSSPACE, 0, RLIM64_INFINITY, 0, NULL);
|
||||
} /* kobj_read_file() */
|
||||
EXPORT_SYMBOL(kobj_read_file);
|
||||
|
||||
int
|
||||
kobj_get_filesize(struct _buf *file, uint64_t *size)
|
||||
{
|
||||
struct kstat stat;
|
||||
vattr_t vap;
|
||||
int rc;
|
||||
|
||||
if (!file || !file->fp || !size)
|
||||
return -EINVAL;
|
||||
|
||||
rc = vfs_getattr(file->fp->f_vfsmnt, file->fp->f_dentry, &stat);
|
||||
rc = VOP_GETATTR(file->vp, &vap, 0, 0, NULL);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
*size = stat.size;
|
||||
*size = vap.va_size;
|
||||
|
||||
return rc;
|
||||
} /* kobj_get_filesize() */
|
||||
EXPORT_SYMBOL(kobj_get_filesize);
|
||||
|
|
|
|||
|
|
@ -1,168 +1,358 @@
|
|||
#include <sys/sysmacros.h>
|
||||
#include <sys/vnode.h>
|
||||
#include "config.h"
|
||||
|
||||
/*
|
||||
* XXX: currently borrrowed from libsolcompat until this
|
||||
* can be adapted to the linux kernel interfaces.
|
||||
*/
|
||||
#if 0
|
||||
/*
|
||||
* =========================================================================
|
||||
* vnode operations
|
||||
* =========================================================================
|
||||
*/
|
||||
/*
|
||||
* Note: for the xxxat() versions of these functions, we assume that the
|
||||
* starting vp is always rootdir (which is true for spa_directory.c, the only
|
||||
* ZFS consumer of these interfaces). We assert this is true, and then emulate
|
||||
* them by adding '/' in front of the path.
|
||||
*/
|
||||
void *rootdir = NULL;
|
||||
EXPORT_SYMBOL(rootdir);
|
||||
|
||||
/*ARGSUSED*/
|
||||
int
|
||||
vn_open(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2, int x3)
|
||||
static vtype_t
|
||||
vn_get_sol_type(umode_t mode)
|
||||
{
|
||||
int fd;
|
||||
if (S_ISREG(mode))
|
||||
return VREG;
|
||||
|
||||
if (S_ISDIR(mode))
|
||||
return VDIR;
|
||||
|
||||
if (S_ISCHR(mode))
|
||||
return VCHR;
|
||||
|
||||
if (S_ISBLK(mode))
|
||||
return VBLK;
|
||||
|
||||
if (S_ISFIFO(mode))
|
||||
return VFIFO;
|
||||
|
||||
if (S_ISLNK(mode))
|
||||
return VLNK;
|
||||
|
||||
if (S_ISSOCK(mode))
|
||||
return VSOCK;
|
||||
|
||||
if (S_ISCHR(mode))
|
||||
return VCHR;
|
||||
|
||||
return VNON;
|
||||
} /* vn_get_sol_type() */
|
||||
|
||||
int
|
||||
vn_open(const char *path, int seg, int flags, int mode,
|
||||
vnode_t **vpp, int x1, void *x2)
|
||||
{
|
||||
struct file *fp;
|
||||
struct kstat stat;
|
||||
int rc, saved_umask, flags_rw;
|
||||
vnode_t *vp;
|
||||
int old_umask;
|
||||
char realpath[MAXPATHLEN];
|
||||
struct stat64 st;
|
||||
|
||||
/*
|
||||
* If we're accessing a real disk from userland, we need to use
|
||||
* the character interface to avoid caching. This is particularly
|
||||
* important if we're trying to look at a real in-kernel storage
|
||||
* pool from userland, e.g. via zdb, because otherwise we won't
|
||||
* see the changes occurring under the segmap cache.
|
||||
* On the other hand, the stupid character device returns zero
|
||||
* for its size. So -- gag -- we open the block device to get
|
||||
* its size, and remember it for subsequent VOP_GETATTR().
|
||||
*/
|
||||
#if defined(__sun__) || defined(__sun)
|
||||
if (strncmp(path, "/dev/", 5) == 0) {
|
||||
#else
|
||||
if (0) {
|
||||
#endif
|
||||
char *dsk;
|
||||
fd = open64(path, O_RDONLY);
|
||||
if (fd == -1)
|
||||
return (errno);
|
||||
if (fstat64(fd, &st) == -1) {
|
||||
close(fd);
|
||||
return (errno);
|
||||
}
|
||||
close(fd);
|
||||
(void) sprintf(realpath, "%s", path);
|
||||
dsk = strstr(path, "/dsk/");
|
||||
if (dsk != NULL)
|
||||
(void) sprintf(realpath + (dsk - path) + 1, "r%s",
|
||||
dsk + 1);
|
||||
} else {
|
||||
(void) sprintf(realpath, "%s", path);
|
||||
if (!(flags & FCREAT) && stat64(realpath, &st) == -1)
|
||||
return (errno);
|
||||
}
|
||||
BUG_ON(seg != UIO_SYSSPACE);
|
||||
BUG_ON(!vpp);
|
||||
*vpp = NULL;
|
||||
|
||||
#ifdef __linux__
|
||||
if (!(flags & FCREAT) && S_ISBLK(st.st_mode)) {
|
||||
flags |= O_DIRECT;
|
||||
if (flags & FWRITE)
|
||||
flags |= O_EXCL;
|
||||
if (!(flags & FCREAT) && (flags & FWRITE))
|
||||
flags |= FEXCL;
|
||||
|
||||
flags_rw = flags & (FWRITE | FREAD);
|
||||
flags &= ~(FWRITE | FREAD);
|
||||
switch (flags_rw) {
|
||||
case FWRITE: flags |= O_WRONLY;
|
||||
case FREAD: flags |= O_RDONLY;
|
||||
case (FWRITE | FREAD): flags |= O_RDWR;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (flags & FCREAT)
|
||||
old_umask = umask(0);
|
||||
saved_umask = xchg(¤t->fs->umask, 0);
|
||||
|
||||
/*
|
||||
* The construct 'flags - FREAD' conveniently maps combinations of
|
||||
* FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR.
|
||||
*/
|
||||
fd = open64(realpath, flags - FREAD, mode);
|
||||
fp = filp_open(path, flags, mode);
|
||||
|
||||
if (flags & FCREAT)
|
||||
(void) umask(old_umask);
|
||||
(void)xchg(¤t->fs->umask, saved_umask);
|
||||
|
||||
if (fd == -1)
|
||||
return (errno);
|
||||
if (IS_ERR(fp))
|
||||
return PTR_ERR(fp);
|
||||
|
||||
if (fstat64(fd, &st) == -1) {
|
||||
close(fd);
|
||||
return (errno);
|
||||
rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
|
||||
if (rc) {
|
||||
filp_close(fp, 0);
|
||||
return rc;
|
||||
}
|
||||
|
||||
(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
|
||||
vp = kmalloc(sizeof(vnode_t), GFP_ATOMIC);
|
||||
if (!vp) {
|
||||
filp_close(fp, 0);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
*vpp = vp = umem_zalloc(sizeof (vnode_t), UMEM_NOFAIL);
|
||||
vp->v_type = vn_get_sol_type(stat.mode);
|
||||
vp->v_fp = fp;
|
||||
*vpp = vp;
|
||||
|
||||
vp->v_fd = fd;
|
||||
vp->v_size = st.st_size;
|
||||
vp->v_mode = st.st_mode;
|
||||
vp->v_path = spa_strdup(path);
|
||||
return 0;
|
||||
} /* vn_open() */
|
||||
EXPORT_SYMBOL(vn_open);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
int
|
||||
vn_openat(char *path, int x1, int flags, int mode, vnode_t **vpp, int x2,
|
||||
int x3, vnode_t *startvp, int fd)
|
||||
vn_openat(const char *path, int seg, int flags, int mode,
|
||||
vnode_t **vpp, int x1, void *x2, vnode_t *vp, int fd)
|
||||
{
|
||||
char *realpath = umem_alloc(strlen(path) + 2, UMEM_NOFAIL);
|
||||
int ret;
|
||||
char *realpath;
|
||||
int rc;
|
||||
|
||||
ASSERT(startvp == rootdir);
|
||||
(void) sprintf(realpath, "/%s", path);
|
||||
BUG_ON(vp != rootdir);
|
||||
|
||||
/* fd ignored for now, need if want to simulate nbmand support */
|
||||
ret = vn_open(realpath, x1, flags, mode, vpp, x2, x3);
|
||||
realpath = kmalloc(strlen(path) + 2, GFP_KERNEL);
|
||||
if (!realpath)
|
||||
return -ENOMEM;
|
||||
|
||||
umem_free(realpath, strlen(path) + 2);
|
||||
sprintf(realpath, "/%s", path);
|
||||
rc = vn_open(realpath, seg, flags, mode, vpp, x1, x2);
|
||||
|
||||
return (ret);
|
||||
}
|
||||
kfree(realpath);
|
||||
|
||||
return rc;
|
||||
} /* vn_openat() */
|
||||
EXPORT_SYMBOL(vn_openat);
|
||||
|
||||
/*ARGSUSED*/
|
||||
int
|
||||
vn_rdwr(int uio, vnode_t *vp, void *addr, ssize_t len, offset_t offset,
|
||||
int x1, int x2, rlim64_t x3, void *x4, ssize_t *residp)
|
||||
vn_rdwr(uio_rw_t uio, vnode_t *vp, void *addr, ssize_t len, offset_t off,
|
||||
int seg, int x1, rlim64_t x2, void *x3, ssize_t *residp)
|
||||
{
|
||||
ssize_t iolen, split;
|
||||
loff_t offset;
|
||||
mm_segment_t saved_fs;
|
||||
struct file *fp;
|
||||
int rc;
|
||||
|
||||
if (uio == UIO_READ) {
|
||||
iolen = pread64(vp->v_fd, addr, len, offset);
|
||||
BUG_ON(!(uio == UIO_WRITE || uio == UIO_READ));
|
||||
BUG_ON(!vp);
|
||||
BUG_ON(!vp->v_fp);
|
||||
BUG_ON(seg != UIO_SYSSPACE);
|
||||
BUG_ON(x1 != 0);
|
||||
BUG_ON(x2 != RLIM64_INFINITY);
|
||||
|
||||
offset = off;
|
||||
fp = vp->v_fp;
|
||||
|
||||
/* Writable user data segment must be briefly increased for this
|
||||
* process so we can use the user space read call paths to write
|
||||
* in to memory allocated by the kernel. */
|
||||
saved_fs = get_fs();
|
||||
set_fs(get_ds());
|
||||
|
||||
if (uio & UIO_WRITE)
|
||||
rc = vfs_write(fp, addr, len, &offset);
|
||||
else
|
||||
rc = vfs_read(fp, addr, len, &offset);
|
||||
|
||||
set_fs(saved_fs);
|
||||
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
|
||||
if (residp) {
|
||||
*residp = len - rc;
|
||||
} else {
|
||||
/*
|
||||
* To simulate partial disk writes, we split writes into two
|
||||
* system calls so that the process can be killed in between.
|
||||
*/
|
||||
#ifdef ZFS_DEBUG
|
||||
if (!S_ISBLK(vp->v_mode) && !S_ISCHR(vp->v_mode)) {
|
||||
split = (len > 0 ? rand() % len : 0);
|
||||
iolen = pwrite64(vp->v_fd, addr, split, offset);
|
||||
iolen += pwrite64(vp->v_fd, (char *)addr + split,
|
||||
len - split, offset + split);
|
||||
} else
|
||||
iolen = pwrite64(vp->v_fd, addr, len, offset);
|
||||
#else
|
||||
iolen = pwrite64(vp->v_fd, addr, len, offset);
|
||||
#endif
|
||||
if (rc != len)
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
if (iolen < 0)
|
||||
return (errno);
|
||||
if (residp)
|
||||
*residp = len - iolen;
|
||||
else if (iolen != len)
|
||||
return (EIO);
|
||||
return (0);
|
||||
}
|
||||
return 0;
|
||||
} /* vn_rdwr() */
|
||||
EXPORT_SYMBOL(vn_rdwr);
|
||||
|
||||
void
|
||||
vn_close(vnode_t *vp)
|
||||
int
|
||||
vn_close(vnode_t *vp, int flags, int x1, int x2, int x3, int x4)
|
||||
{
|
||||
close(vp->v_fd);
|
||||
spa_strfree(vp->v_path);
|
||||
umem_free(vp, sizeof (vnode_t));
|
||||
int rc;
|
||||
|
||||
BUG_ON(!vp);
|
||||
BUG_ON(!vp->v_fp);
|
||||
|
||||
rc = filp_close(vp->v_fp, 0);
|
||||
kfree(vp);
|
||||
|
||||
return rc;
|
||||
} /* vn_close() */
|
||||
EXPORT_SYMBOL(vn_close);
|
||||
|
||||
static struct dentry *lookup_hash(struct nameidata *nd)
|
||||
{
|
||||
return __lookup_hash(&nd->last, nd->dentry, nd);
|
||||
} /* lookup_hash() */
|
||||
|
||||
/* Modified do_unlinkat() from linux/fs/namei.c, only uses exported symbols */
|
||||
int
|
||||
vn_remove(const char *path, int x1, int x2)
|
||||
{
|
||||
struct dentry *dentry;
|
||||
struct nameidata nd;
|
||||
struct inode *inode = NULL;
|
||||
int rc = 0;
|
||||
|
||||
rc = path_lookup(path, LOOKUP_PARENT, &nd);
|
||||
if (rc)
|
||||
goto exit;
|
||||
|
||||
rc = -EISDIR;
|
||||
if (nd.last_type != LAST_NORM)
|
||||
goto exit1;
|
||||
|
||||
mutex_lock_nested(&nd.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
|
||||
dentry = lookup_hash(&nd);
|
||||
rc = PTR_ERR(dentry);
|
||||
if (!IS_ERR(dentry)) {
|
||||
/* Why not before? Because we want correct rc value */
|
||||
if (nd.last.name[nd.last.len])
|
||||
goto slashes;
|
||||
inode = dentry->d_inode;
|
||||
if (inode)
|
||||
atomic_inc(&inode->i_count);
|
||||
rc = vfs_unlink(nd.dentry->d_inode, dentry);
|
||||
exit2:
|
||||
dput(dentry);
|
||||
}
|
||||
mutex_unlock(&nd.dentry->d_inode->i_mutex);
|
||||
if (inode)
|
||||
iput(inode); /* truncate the inode here */
|
||||
exit1:
|
||||
path_release(&nd);
|
||||
exit:
|
||||
return rc;
|
||||
|
||||
slashes:
|
||||
rc = !dentry->d_inode ? -ENOENT :
|
||||
S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
|
||||
goto exit2;
|
||||
} /* vn_remove() */
|
||||
EXPORT_SYMBOL(vn_remove);
|
||||
|
||||
/* Modified do_rename() from linux/fs/namei.c, only uses exported symbols */
|
||||
int
|
||||
vn_rename(const char *oldname, const char *newname, int x1)
|
||||
{
|
||||
struct dentry * old_dir, * new_dir;
|
||||
struct dentry * old_dentry, *new_dentry;
|
||||
struct dentry * trap;
|
||||
struct nameidata oldnd, newnd;
|
||||
int rc = 0;
|
||||
|
||||
rc = path_lookup(oldname, LOOKUP_PARENT, &oldnd);
|
||||
if (rc)
|
||||
goto exit;
|
||||
|
||||
rc = path_lookup(newname, LOOKUP_PARENT, &newnd);
|
||||
if (rc)
|
||||
goto exit1;
|
||||
|
||||
rc = -EXDEV;
|
||||
if (oldnd.mnt != newnd.mnt)
|
||||
goto exit2;
|
||||
|
||||
old_dir = oldnd.dentry;
|
||||
rc = -EBUSY;
|
||||
if (oldnd.last_type != LAST_NORM)
|
||||
goto exit2;
|
||||
|
||||
new_dir = newnd.dentry;
|
||||
if (newnd.last_type != LAST_NORM)
|
||||
goto exit2;
|
||||
|
||||
trap = lock_rename(new_dir, old_dir);
|
||||
|
||||
old_dentry = lookup_hash(&oldnd);
|
||||
|
||||
rc = PTR_ERR(old_dentry);
|
||||
if (IS_ERR(old_dentry))
|
||||
goto exit3;
|
||||
|
||||
/* source must exist */
|
||||
rc = -ENOENT;
|
||||
if (!old_dentry->d_inode)
|
||||
goto exit4;
|
||||
|
||||
/* unless the source is a directory trailing slashes give -ENOTDIR */
|
||||
if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
|
||||
rc = -ENOTDIR;
|
||||
if (oldnd.last.name[oldnd.last.len])
|
||||
goto exit4;
|
||||
if (newnd.last.name[newnd.last.len])
|
||||
goto exit4;
|
||||
}
|
||||
|
||||
/* source should not be ancestor of target */
|
||||
rc = -EINVAL;
|
||||
if (old_dentry == trap)
|
||||
goto exit4;
|
||||
|
||||
new_dentry = lookup_hash(&newnd);
|
||||
rc = PTR_ERR(new_dentry);
|
||||
if (IS_ERR(new_dentry))
|
||||
goto exit4;
|
||||
|
||||
/* target should not be an ancestor of source */
|
||||
rc = -ENOTEMPTY;
|
||||
if (new_dentry == trap)
|
||||
goto exit5;
|
||||
|
||||
rc = vfs_rename(old_dir->d_inode, old_dentry,
|
||||
new_dir->d_inode, new_dentry);
|
||||
exit5:
|
||||
dput(new_dentry);
|
||||
exit4:
|
||||
dput(old_dentry);
|
||||
exit3:
|
||||
unlock_rename(new_dir, old_dir);
|
||||
exit2:
|
||||
path_release(&newnd);
|
||||
exit1:
|
||||
path_release(&oldnd);
|
||||
exit:
|
||||
return rc;
|
||||
}
|
||||
#endif
|
||||
EXPORT_SYMBOL(vn_rename);
|
||||
|
||||
int
|
||||
vn_getattr(vnode_t *vp, vattr_t *vap, int flags, int x3, void *x4)
|
||||
{
|
||||
struct file *fp;
|
||||
struct kstat stat;
|
||||
int rc;
|
||||
|
||||
BUG_ON(!vp);
|
||||
BUG_ON(!vp->v_fp);
|
||||
BUG_ON(!vap);
|
||||
|
||||
fp = vp->v_fp;
|
||||
|
||||
rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
vap->va_type = vn_get_sol_type(stat.mode);
|
||||
vap->va_mode = stat.mode;
|
||||
vap->va_uid = stat.uid;
|
||||
vap->va_gid = stat.gid;
|
||||
vap->va_fsid = 0;
|
||||
vap->va_nodeid = stat.ino;
|
||||
vap->va_nlink = stat.nlink;
|
||||
vap->va_size = stat.size;
|
||||
vap->va_blocksize = stat.blksize;
|
||||
vap->va_atime.tv_sec = stat.atime.tv_sec;
|
||||
vap->va_atime.tv_usec = stat.atime.tv_nsec / NSEC_PER_USEC;
|
||||
vap->va_mtime.tv_sec = stat.mtime.tv_sec;
|
||||
vap->va_mtime.tv_usec = stat.mtime.tv_nsec / NSEC_PER_USEC;
|
||||
vap->va_ctime.tv_sec = stat.ctime.tv_sec;
|
||||
vap->va_ctime.tv_usec = stat.ctime.tv_nsec / NSEC_PER_USEC;
|
||||
vap->va_rdev = stat.rdev;
|
||||
vap->va_blocks = stat.blocks;
|
||||
|
||||
return rc;
|
||||
}
|
||||
EXPORT_SYMBOL(vn_getattr);
|
||||
|
||||
int vn_fsync(vnode_t *vp, int flags, int x3, int x4)
|
||||
{
|
||||
BUG_ON(!vp);
|
||||
BUG_ON(!vp->v_fp);
|
||||
|
||||
return file_fsync(vp->v_fp, vp->v_fp->f_dentry, 0);
|
||||
} /* vn_fsync() */
|
||||
EXPORT_SYMBOL(vn_fsync);
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ splat-objs += splat-condvar.o
|
|||
splat-objs += splat-thread.o
|
||||
splat-objs += splat-rwlock.o
|
||||
splat-objs += splat-time.o
|
||||
splat-objs += splat-vnode.o
|
||||
splat-objs += splat-kobj.o
|
||||
|
||||
splatmodule := splat.ko
|
||||
|
|
|
|||
|
|
@ -591,6 +591,7 @@ splat_init(void)
|
|||
SPLAT_SUBSYSTEM_INIT(thread);
|
||||
SPLAT_SUBSYSTEM_INIT(rwlock);
|
||||
SPLAT_SUBSYSTEM_INIT(time);
|
||||
SPLAT_SUBSYSTEM_INIT(vnode);
|
||||
SPLAT_SUBSYSTEM_INIT(kobj);
|
||||
|
||||
dev = MKDEV(SPLAT_MAJOR, 0);
|
||||
|
|
@ -654,6 +655,7 @@ splat_fini(void)
|
|||
unregister_chrdev_region(dev, SPLAT_MINORS);
|
||||
|
||||
SPLAT_SUBSYSTEM_FINI(kobj);
|
||||
SPLAT_SUBSYSTEM_FINI(vnode);
|
||||
SPLAT_SUBSYSTEM_FINI(time);
|
||||
SPLAT_SUBSYSTEM_FINI(rwlock);
|
||||
SPLAT_SUBSYSTEM_FINI(thread);
|
||||
|
|
|
|||
|
|
@ -170,6 +170,7 @@ splat_subsystem_t * splat_rwlock_init(void);
|
|||
splat_subsystem_t * splat_taskq_init(void);
|
||||
splat_subsystem_t * splat_thread_init(void);
|
||||
splat_subsystem_t * splat_time_init(void);
|
||||
splat_subsystem_t * splat_vnode_init(void);
|
||||
splat_subsystem_t * splat_kobj_init(void);
|
||||
|
||||
void splat_condvar_fini(splat_subsystem_t *);
|
||||
|
|
@ -180,6 +181,7 @@ void splat_rwlock_fini(splat_subsystem_t *);
|
|||
void splat_taskq_fini(splat_subsystem_t *);
|
||||
void splat_thread_fini(splat_subsystem_t *);
|
||||
void splat_time_fini(splat_subsystem_t *);
|
||||
void splat_vnode_fini(splat_subsystem_t *);
|
||||
void splat_kobj_fini(splat_subsystem_t *);
|
||||
|
||||
int splat_condvar_id(void);
|
||||
|
|
@ -190,6 +192,7 @@ int splat_rwlock_id(void);
|
|||
int splat_taskq_id(void);
|
||||
int splat_thread_id(void);
|
||||
int splat_time_id(void);
|
||||
int splat_vnode_id(void);
|
||||
int splat_kobj_id(void);
|
||||
|
||||
#endif /* _SPLAT_INTERNAL_H */
|
||||
|
|
|
|||
|
|
@ -1,15 +1,15 @@
|
|||
#include "splat-internal.h"
|
||||
|
||||
#define SPLAT_SUBSYSTEM_KOBJ 0x0900
|
||||
#define SPLAT_SUBSYSTEM_KOBJ 0x0a00
|
||||
#define SPLAT_KOBJ_NAME "kobj"
|
||||
#define SPLAT_KOBJ_DESC "Kernel File Tests"
|
||||
|
||||
#define SPLAT_KOBJ_TEST1_ID 0x0901
|
||||
#define SPLAT_KOBJ_TEST1_NAME "kobj1"
|
||||
#define SPLAT_KOBJ_TEST1_ID 0x0a01
|
||||
#define SPLAT_KOBJ_TEST1_NAME "open"
|
||||
#define SPLAT_KOBJ_TEST1_DESC "File Open/Close Test"
|
||||
|
||||
#define SPLAT_KOBJ_TEST2_ID 0x0902
|
||||
#define SPLAT_KOBJ_TEST2_NAME "kobj2"
|
||||
#define SPLAT_KOBJ_TEST2_ID 0x0a02
|
||||
#define SPLAT_KOBJ_TEST2_NAME "size/read"
|
||||
#define SPLAT_KOBJ_TEST2_DESC "File Size/Read Test"
|
||||
|
||||
#define SPLAT_KOBJ_TEST_FILE "/etc/fstab"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,372 @@
|
|||
#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, 0, 0);
|
||||
|
||||
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, 0, 0);
|
||||
vn_remove(SPLAT_VNODE_TEST_FILE_RW2, 0, 0);
|
||||
|
||||
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, 0, 0);
|
||||
|
||||
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() */
|
||||
|
|
@ -19,6 +19,12 @@ if [ -n "$V" ]; then
|
|||
verbose="-v"
|
||||
fi
|
||||
|
||||
if [ -n "$TESTS" ]; then
|
||||
tests="$TESTS"
|
||||
else
|
||||
tests="-a"
|
||||
fi
|
||||
|
||||
if [ $(id -u) != 0 ]; then
|
||||
die "Must run as root"
|
||||
fi
|
||||
|
|
@ -37,8 +43,8 @@ echo "Loading ${spl_module}"
|
|||
echo "Loading ${splat_module}"
|
||||
/sbin/insmod ${splat_module} || die "Unable to load ${splat_module}"
|
||||
|
||||
sleep 3
|
||||
$splat_cmd -a $verbose
|
||||
while [ ! -c /dev/splatctl ]; do sleep 0.1; done
|
||||
$splat_cmd $tests $verbose
|
||||
|
||||
echo "Unloading ${splat_module}"
|
||||
/sbin/rmmod ${splat_module} || die "Failed to unload ${splat_module}"
|
||||
|
|
|
|||
Loading…
Reference in New Issue