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

#include <sys/sysmacros.h>
#include <sys/vnode.h>
#include "config.h"

void *rootdir = NULL;
EXPORT_SYMBOL(rootdir);

static kmem_cache_t *vn_cache;
static kmem_cache_t *vn_file_cache;

static spinlock_t vn_file_lock = SPIN_LOCK_UNLOCKED;
static LIST_HEAD(vn_file_list);

static vtype_t
vn_get_sol_type(umode_t mode)
{
	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() */

vnode_t *
vn_alloc(int flag)
{
	vnode_t *vp;

	vp = kmem_cache_alloc(vn_cache, flag);
	if (vp != NULL) {
		vp->v_file = NULL;
		vp->v_type = 0;
	}

	return vp;
} /* vn_alloc() */
EXPORT_SYMBOL(vn_alloc);

void
vn_free(vnode_t *vp)
{
	kmem_cache_free(vn_cache, vp);
} /* vn_free() */
EXPORT_SYMBOL(vn_free);

int
vn_open(const char *path, uio_seg_t seg, int flags, int mode,
	vnode_t **vpp, int x1, void *x2)
{
        struct file *fp;
        struct kstat stat;
        int rc, saved_umask;
	vnode_t *vp;

	BUG_ON(!(flags & (FWRITE | FREAD)));
	BUG_ON(seg != UIO_SYSSPACE);
	BUG_ON(!vpp);
	*vpp = NULL;

	if (!(flags & FCREAT) && (flags & FWRITE))
		flags |= FEXCL;

	/* Note for filp_open() the two low bits must be remapped to mean:
	 * 01 - read-only  -> 00 read-only
	 * 10 - write-only -> 01 write-only
	 * 11 - read-write -> 10 read-write
	 */
	flags--;

	if (flags & FCREAT)
		saved_umask = xchg(&current->fs->umask, 0);

        fp = filp_open(path, flags, mode);

	if (flags & FCREAT)
		(void)xchg(&current->fs->umask, saved_umask);

        if (IS_ERR(fp))
		return -PTR_ERR(fp);

        rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
	if (rc) {
		filp_close(fp, 0);
		return -rc;
	}

	vp = vn_alloc(KM_SLEEP);
	if (!vp) {
		filp_close(fp, 0);
		return ENOMEM;
	}

	mutex_enter(&vp->v_lock);
	vp->v_type = vn_get_sol_type(stat.mode);
	vp->v_file = fp;
	*vpp = vp;
	mutex_exit(&vp->v_lock);

	return 0;
} /* vn_open() */
EXPORT_SYMBOL(vn_open);

int
vn_openat(const char *path, uio_seg_t seg, int flags, int mode,
	  vnode_t **vpp, int x1, void *x2, vnode_t *vp, int fd)
{
	char *realpath;
	int rc;

	BUG_ON(vp != rootdir);

	realpath = kmalloc(strlen(path) + 2, GFP_KERNEL);
	if (!realpath)
		return ENOMEM;

	sprintf(realpath, "/%s", path);
	rc = vn_open(realpath, seg, flags, mode, vpp, x1, x2);

	kfree(realpath);

	return rc;
} /* vn_openat() */
EXPORT_SYMBOL(vn_openat);

int
vn_rdwr(uio_rw_t uio, vnode_t *vp, void *addr, ssize_t len, offset_t off,
	uio_seg_t seg, int x1, rlim64_t x2, void *x3, ssize_t *residp)
{
	loff_t offset;
	mm_segment_t saved_fs;
	struct file *fp;
	int rc;

	BUG_ON(!(uio == UIO_WRITE || uio == UIO_READ));
	BUG_ON(!vp);
	BUG_ON(!vp->v_file);
	BUG_ON(seg != UIO_SYSSPACE);
	BUG_ON(x1 != 0);
	BUG_ON(x2 != RLIM64_INFINITY);

	offset = off;
	fp = vp->v_file;

	/* 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 {
		if (rc != len)
			return EIO;
	}

	return 0;
} /* vn_rdwr() */
EXPORT_SYMBOL(vn_rdwr);

int
vn_close(vnode_t *vp, int flags, int x1, int x2, void *x3, void *x4)
{
	int rc;

	BUG_ON(!vp);
	BUG_ON(!vp->v_file);

        rc = filp_close(vp->v_file, 0);
        vn_free(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, uio_seg_t seg, int flags)
{
        struct dentry *dentry;
        struct nameidata nd;
        struct inode *inode = NULL;
        int rc = 0;

	BUG_ON(seg != UIO_SYSSPACE);
	BUG_ON(flags != RMFILE);

        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;
}
EXPORT_SYMBOL(vn_rename);

int
vn_getattr(vnode_t *vp, vattr_t *vap, int flags, void *x3, void *x4)
{
	struct file *fp;
        struct kstat stat;
	int rc;

	BUG_ON(!vp);
	BUG_ON(!vp->v_file);
	BUG_ON(!vap);

	fp = vp->v_file;

        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 0;
}
EXPORT_SYMBOL(vn_getattr);

int vn_fsync(vnode_t *vp, int flags, void *x3, void *x4)
{
	int datasync = 0;

	BUG_ON(!vp);
	BUG_ON(!vp->v_file);

	if (flags & FDSYNC)
		datasync = 1;

	return -file_fsync(vp->v_file, vp->v_file->f_dentry, datasync);
} /* vn_fsync() */
EXPORT_SYMBOL(vn_fsync);

/* Function must be called while holding the vn_file_lock */
static file_t *
file_find(int fd)
{
        file_t *fp;

	BUG_ON(!spin_is_locked(&vn_file_lock));

        list_for_each_entry(fp, &vn_file_list,  f_list) {
		if (fd == fp->f_fd) {
			BUG_ON(atomic_read(&fp->f_ref) == 0);
                        return fp;
		}
	}

        return NULL;
} /* file_find() */

file_t *
vn_getf(int fd)
{
        struct kstat stat;
	struct file *lfp;
	file_t *fp;
	vnode_t *vp;

	/* Already open just take an extra reference */
	spin_lock(&vn_file_lock);

	fp = file_find(fd);
	if (fp) {
		atomic_inc(&fp->f_ref);
		spin_unlock(&vn_file_lock);
		return fp;
	}

	spin_unlock(&vn_file_lock);

	/* File was not yet opened create the object and setup */
	fp = kmem_cache_alloc(vn_file_cache, 0);
	if (fp == NULL)
		goto out;

	mutex_enter(&fp->f_lock);

	fp->f_fd = fd;
	fp->f_offset = 0;
	atomic_inc(&fp->f_ref);

	lfp = fget(fd);
	if (lfp == NULL)
		goto out_mutex;

	vp = vn_alloc(KM_SLEEP);
	if (vp == NULL)
		goto out_fget;

        if (vfs_getattr(lfp->f_vfsmnt, lfp->f_dentry, &stat))
		goto out_vnode;

	mutex_enter(&vp->v_lock);
	vp->v_type = vn_get_sol_type(stat.mode);
	vp->v_file = lfp;
	mutex_exit(&vp->v_lock);

	fp->f_vnode = vp;
	fp->f_file = lfp;

	/* Put it on the tracking list */
	spin_lock(&vn_file_lock);
	list_add(&fp->f_list, &vn_file_list);
	spin_unlock(&vn_file_lock);

	mutex_exit(&fp->f_lock);
	return fp;

out_vnode:
	vn_free(vp);
out_fget:
	fput(lfp);
out_mutex:
	mutex_exit(&fp->f_lock);
	kmem_cache_free(vn_file_cache, fp);
out:
        return NULL;
} /* getf() */
EXPORT_SYMBOL(getf);

static void releasef_locked(file_t *fp)
{
	BUG_ON(fp->f_file == NULL);
	BUG_ON(fp->f_vnode == NULL);

	/* Unlinked from list, no refs, safe to free outside mutex */
	fput(fp->f_file);
	vn_free(fp->f_vnode);

	kmem_cache_free(vn_file_cache, fp);
}

void
vn_releasef(int fd)
{
	file_t *fp;

	spin_lock(&vn_file_lock);
	fp = file_find(fd);
	if (fp) {
		atomic_dec(&fp->f_ref);
		if (atomic_read(&fp->f_ref) > 0) {
			spin_unlock(&vn_file_lock);
			return;
		}

	        list_del(&fp->f_list);
		releasef_locked(fp);
	}
	spin_unlock(&vn_file_lock);

	return;
} /* releasef() */
EXPORT_SYMBOL(releasef);

static int
vn_cache_constructor(void *buf, void *cdrarg, int kmflags)
{
	struct vnode *vp = buf;

	mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL);

	return (0);
} /* vn_cache_constructor() */

static void
vn_cache_destructor(void *buf, void *cdrarg)
{
	struct vnode *vp = buf;

	mutex_destroy(&vp->v_lock);
} /* vn_cache_destructor() */

static int
vn_file_cache_constructor(void *buf, void *cdrarg, int kmflags)
{
	file_t *fp = buf;

	atomic_set(&fp->f_ref, 0);
        mutex_init(&fp->f_lock, NULL, MUTEX_DEFAULT, NULL);
	INIT_LIST_HEAD(&fp->f_list);

        return (0);
} /* file_cache_constructor() */

static void
vn_file_cache_destructor(void *buf, void *cdrarg)
{
	file_t *fp = buf;

	mutex_destroy(&fp->f_lock);
} /* vn_file_cache_destructor() */

int
vn_init(void)
{
	vn_cache = kmem_cache_create("spl_vn_cache", sizeof(struct vnode), 64,
	                             vn_cache_constructor,
				     vn_cache_destructor,
				     NULL, NULL, NULL, 0);

	vn_file_cache = kmem_cache_create("spl_vn_file_cache",
					  sizeof(file_t), 64,
				          vn_file_cache_constructor,
				          vn_file_cache_destructor,
				          NULL, NULL, NULL, 0);
	return 0;
} /* vn_init() */

void
vn_fini(void)
{
        file_t *fp, *next_fp;
	int rc, leaked = 0;

	spin_lock(&vn_file_lock);

        list_for_each_entry_safe(fp, next_fp, &vn_file_list,  f_list) {
	        list_del(&fp->f_list);
		releasef_locked(fp);
		leaked++;
	}

	rc = kmem_cache_destroy(vn_file_cache);
	if (rc)
		printk("spl: Warning leaked vn_file_cache objects, %d\n", rc);

	vn_file_cache = NULL;
	spin_unlock(&vn_file_lock);

	if (leaked > 0)
		printk("spl: Warning %d files leaked\n", leaked);

	rc = kmem_cache_destroy(vn_cache);
	if (rc)
		printk("spl: Warning leaked vn_cache objects, %d\n", rc);

	return;
} /* vn_fini() */
Commit	Line	Data
0b3cf046	1	#include <sys/sysmacros.h>
4b171585	2	#include <sys/vnode.h>
0b3cf046	3	#include "config.h"
0b3cf046	4
4b171585	5	void *rootdir = NULL;
	6	EXPORT_SYMBOL(rootdir);
	7
e4f1d29f	8	static kmem_cache_t *vn_cache;
	9	static kmem_cache_t *vn_file_cache;
	10
	11	static spinlock_t vn_file_lock = SPIN_LOCK_UNLOCKED;
	12	static LIST_HEAD(vn_file_list);
af828292	13
4b171585	14	static vtype_t
	15	vn_get_sol_type(umode_t mode)
	16	{
	17	if (S_ISREG(mode))
	18	return VREG;
	19
	20	if (S_ISDIR(mode))
	21	return VDIR;
	22
	23	if (S_ISCHR(mode))
	24	return VCHR;
	25
	26	if (S_ISBLK(mode))
	27	return VBLK;
	28
	29	if (S_ISFIFO(mode))
	30	return VFIFO;
	31
	32	if (S_ISLNK(mode))
	33	return VLNK;
	34
	35	if (S_ISSOCK(mode))
	36	return VSOCK;
	37
	38	if (S_ISCHR(mode))
	39	return VCHR;
	40
	41	return VNON;
	42	} /* vn_get_sol_type() */
	43
af828292	44	vnode_t *
	45	vn_alloc(int flag)
	46	{
	47	vnode_t *vp;
	48
	49	vp = kmem_cache_alloc(vn_cache, flag);
af828292	50	if (vp != NULL) {
e4f1d29f	51	vp->v_file = NULL;
af828292	52	vp->v_type = 0;
	53	}
	54
728b9dd8	55	return vp;
af828292	56	} /* vn_alloc() */
	57	EXPORT_SYMBOL(vn_alloc);
	58
	59	void
	60	vn_free(vnode_t *vp)
	61	{
	62	kmem_cache_free(vn_cache, vp);
	63	} /* vn_free() */
	64	EXPORT_SYMBOL(vn_free);
	65
0b3cf046	66	int
af828292	67	vn_open(const char *path, uio_seg_t seg, int flags, int mode,
4b171585	68	vnode_t *vpp, int x1, void x2)
0b3cf046	69	{
4b171585	70	struct file *fp;
4b171585	71	struct kstat stat;
728b9dd8	72	int rc, saved_umask;
0b3cf046	73	vnode_t *vp;
0b3cf046	74
728b9dd8	75	BUG_ON(!(flags & (FWRITE \| FREAD)));
4b171585	76	BUG_ON(seg != UIO_SYSSPACE);
	77	BUG_ON(!vpp);
	78	*vpp = NULL;
	79
	80	if (!(flags & FCREAT) && (flags & FWRITE))
	81	flags \|= FEXCL;
	82
728b9dd8	83	/* Note for filp_open() the two low bits must be remapped to mean:
	84	* 01 - read-only -> 00 read-only
	85	* 10 - write-only -> 01 write-only
	86	* 11 - read-write -> 10 read-write
	87	*/
	88	flags--;
0b3cf046	89
0b3cf046	90	if (flags & FCREAT)
4b171585	91	saved_umask = xchg(&current->fs->umask, 0);
0b3cf046	92
4b171585	93	fp = filp_open(path, flags, mode);
0b3cf046	94
0b3cf046	95	if (flags & FCREAT)
4b171585	96	(void)xchg(&current->fs->umask, saved_umask);
0b3cf046	97
4b171585	98	if (IS_ERR(fp))
728b9dd8	99	return -PTR_ERR(fp);
0b3cf046	100
4b171585	101	rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
	102	if (rc) {
	103	filp_close(fp, 0);
728b9dd8	104	return -rc;
0b3cf046	105	}
0b3cf046	106
af828292	107	vp = vn_alloc(KM_SLEEP);
4b171585	108	if (!vp) {
4b171585	109	filp_close(fp, 0);
728b9dd8	110	return ENOMEM;
4b171585	111	}
0b3cf046	112
e4f1d29f	113	mutex_enter(&vp->v_lock);
4b171585	114	vp->v_type = vn_get_sol_type(stat.mode);
e4f1d29f	115	vp->v_file = fp;
4b171585	116	*vpp = vp;
e4f1d29f	117	mutex_exit(&vp->v_lock);
0b3cf046	118
4b171585	119	return 0;
	120	} /* vn_open() */
	121	EXPORT_SYMBOL(vn_open);
0b3cf046	122
0b3cf046	123	int
af828292	124	vn_openat(const char *path, uio_seg_t seg, int flags, int mode,
4b171585	125	vnode_t *vpp, int x1, void x2, vnode_t *vp, int fd)
0b3cf046	126	{
4b171585	127	char *realpath;
4b171585	128	int rc;
0b3cf046	129
4b171585	130	BUG_ON(vp != rootdir);
0b3cf046	131
4b171585	132	realpath = kmalloc(strlen(path) + 2, GFP_KERNEL);
4b171585	133	if (!realpath)
728b9dd8	134	return ENOMEM;
0b3cf046	135
4b171585	136	sprintf(realpath, "/%s", path);
4b171585	137	rc = vn_open(realpath, seg, flags, mode, vpp, x1, x2);
0b3cf046	138
4b171585	139	kfree(realpath);
	140
	141	return rc;
	142	} /* vn_openat() */
	143	EXPORT_SYMBOL(vn_openat);
0b3cf046	144
0b3cf046	145	int
4b171585	146	vn_rdwr(uio_rw_t uio, vnode_t vp, void addr, ssize_t len, offset_t off,
af828292	147	uio_seg_t seg, int x1, rlim64_t x2, void x3, ssize_t residp)
0b3cf046	148	{
4b171585	149	loff_t offset;
	150	mm_segment_t saved_fs;
	151	struct file *fp;
	152	int rc;
	153
	154	BUG_ON(!(uio == UIO_WRITE \|\| uio == UIO_READ));
	155	BUG_ON(!vp);
e4f1d29f	156	BUG_ON(!vp->v_file);
4b171585	157	BUG_ON(seg != UIO_SYSSPACE);
	158	BUG_ON(x1 != 0);
	159	BUG_ON(x2 != RLIM64_INFINITY);
	160
	161	offset = off;
e4f1d29f	162	fp = vp->v_file;
4b171585	163
	164	/* Writable user data segment must be briefly increased for this
	165	* process so we can use the user space read call paths to write
	166	* in to memory allocated by the kernel. */
	167	saved_fs = get_fs();
	168	set_fs(get_ds());
	169
	170	if (uio & UIO_WRITE)
	171	rc = vfs_write(fp, addr, len, &offset);
	172	else
	173	rc = vfs_read(fp, addr, len, &offset);
	174
	175	set_fs(saved_fs);
	176
	177	if (rc < 0)
728b9dd8	178	return -rc;
0b3cf046	179
4b171585	180	if (residp) {
4b171585	181	*residp = len - rc;
0b3cf046	182	} else {
4b171585	183	if (rc != len)
728b9dd8	184	return EIO;
0b3cf046	185	}
0b3cf046	186
4b171585	187	return 0;
	188	} /* vn_rdwr() */
	189	EXPORT_SYMBOL(vn_rdwr);
	190
	191	int
2f5d55aa	192	vn_close(vnode_t vp, int flags, int x1, int x2, void x3, void *x4)
4b171585	193	{
	194	int rc;
	195
	196	BUG_ON(!vp);
e4f1d29f	197	BUG_ON(!vp->v_file);
4b171585	198
e4f1d29f	199	rc = filp_close(vp->v_file, 0);
af828292	200	vn_free(vp);
4b171585	201
728b9dd8	202	return -rc;
4b171585	203	} /* vn_close() */
	204	EXPORT_SYMBOL(vn_close);
	205
	206	static struct dentry lookup_hash(struct nameidata nd)
	207	{
	208	return __lookup_hash(&nd->last, nd->dentry, nd);
	209	} /* lookup_hash() */
	210
	211	/* Modified do_unlinkat() from linux/fs/namei.c, only uses exported symbols */
	212	int
af828292	213	vn_remove(const char *path, uio_seg_t seg, int flags)
4b171585	214	{
	215	struct dentry *dentry;
	216	struct nameidata nd;
	217	struct inode *inode = NULL;
	218	int rc = 0;
	219
2f5d55aa	220	BUG_ON(seg != UIO_SYSSPACE);
	221	BUG_ON(flags != RMFILE);
	222
4b171585	223	rc = path_lookup(path, LOOKUP_PARENT, &nd);
	224	if (rc)
	225	goto exit;
	226
	227	rc = -EISDIR;
	228	if (nd.last_type != LAST_NORM)
	229	goto exit1;
	230
	231	mutex_lock_nested(&nd.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
	232	dentry = lookup_hash(&nd);
	233	rc = PTR_ERR(dentry);
	234	if (!IS_ERR(dentry)) {
	235	/* Why not before? Because we want correct rc value */
	236	if (nd.last.name[nd.last.len])
	237	goto slashes;
	238	inode = dentry->d_inode;
	239	if (inode)
	240	atomic_inc(&inode->i_count);
	241	rc = vfs_unlink(nd.dentry->d_inode, dentry);
	242	exit2:
	243	dput(dentry);
	244	}
	245	mutex_unlock(&nd.dentry->d_inode->i_mutex);
	246	if (inode)
	247	iput(inode); /* truncate the inode here */
	248	exit1:
	249	path_release(&nd);
	250	exit:
728b9dd8	251	return -rc;
4b171585	252
	253	slashes:
	254	rc = !dentry->d_inode ? -ENOENT :
	255	S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
	256	goto exit2;
	257	} /* vn_remove() */
	258	EXPORT_SYMBOL(vn_remove);
	259
	260	/* Modified do_rename() from linux/fs/namei.c, only uses exported symbols */
	261	int
	262	vn_rename(const char oldname, const char newname, int x1)
	263	{
	264	struct dentry * old_dir, * new_dir;
	265	struct dentry * old_dentry, *new_dentry;
	266	struct dentry * trap;
	267	struct nameidata oldnd, newnd;
	268	int rc = 0;
	269
	270	rc = path_lookup(oldname, LOOKUP_PARENT, &oldnd);
	271	if (rc)
	272	goto exit;
	273
	274	rc = path_lookup(newname, LOOKUP_PARENT, &newnd);
	275	if (rc)
	276	goto exit1;
	277
	278	rc = -EXDEV;
	279	if (oldnd.mnt != newnd.mnt)
	280	goto exit2;
	281
	282	old_dir = oldnd.dentry;
	283	rc = -EBUSY;
	284	if (oldnd.last_type != LAST_NORM)
	285	goto exit2;
	286
	287	new_dir = newnd.dentry;
	288	if (newnd.last_type != LAST_NORM)
	289	goto exit2;
	290
	291	trap = lock_rename(new_dir, old_dir);
	292
	293	old_dentry = lookup_hash(&oldnd);
	294
	295	rc = PTR_ERR(old_dentry);
	296	if (IS_ERR(old_dentry))
	297	goto exit3;
	298
	299	/* source must exist */
	300	rc = -ENOENT;
	301	if (!old_dentry->d_inode)
	302	goto exit4;
	303
	304	/* unless the source is a directory trailing slashes give -ENOTDIR */
	305	if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
	306	rc = -ENOTDIR;
	307	if (oldnd.last.name[oldnd.last.len])
	308	goto exit4;
	309	if (newnd.last.name[newnd.last.len])
	310	goto exit4;
	311	}
	312
	313	/* source should not be ancestor of target */
	314	rc = -EINVAL;
	315	if (old_dentry == trap)
316	goto exit4;
317
318	new_dentry = lookup_hash(&newnd);
319	rc = PTR_ERR(new_dentry);
320	if (IS_ERR(new_dentry))
321	goto exit4;
322
323	/* target should not be an ancestor of source */
324	rc = -ENOTEMPTY;
325	if (new_dentry == trap)
326	goto exit5;
327
328	rc = vfs_rename(old_dir->d_inode, old_dentry,
329	new_dir->d_inode, new_dentry);
330	exit5:
331	dput(new_dentry);
332	exit4:
333	dput(old_dentry);
334	exit3:
335	unlock_rename(new_dir, old_dir);
336	exit2:
337	path_release(&newnd);
338	exit1:
339	path_release(&oldnd);
340	exit:
728b9dd8	341	return -rc;
0b3cf046	342	}
4b171585	343	EXPORT_SYMBOL(vn_rename);
0b3cf046	344
4b171585	345	int
36e6f861	346	vn_getattr(vnode_t vp, vattr_t vap, int flags, void x3, void x4)
0b3cf046	347	{
4b171585	348	struct file *fp;
	349	struct kstat stat;
	350	int rc;
	351
	352	BUG_ON(!vp);
e4f1d29f	353	BUG_ON(!vp->v_file);
4b171585	354	BUG_ON(!vap);
4b171585	355
e4f1d29f	356	fp = vp->v_file;
4b171585	357
	358	rc = vfs_getattr(fp->f_vfsmnt, fp->f_dentry, &stat);
	359	if (rc)
728b9dd8	360	return -rc;
4b171585	361
	362	vap->va_type = vn_get_sol_type(stat.mode);
	363	vap->va_mode = stat.mode;
	364	vap->va_uid = stat.uid;
	365	vap->va_gid = stat.gid;
	366	vap->va_fsid = 0;
	367	vap->va_nodeid = stat.ino;
	368	vap->va_nlink = stat.nlink;
	369	vap->va_size = stat.size;
	370	vap->va_blocksize = stat.blksize;
	371	vap->va_atime.tv_sec = stat.atime.tv_sec;
	372	vap->va_atime.tv_usec = stat.atime.tv_nsec / NSEC_PER_USEC;
	373	vap->va_mtime.tv_sec = stat.mtime.tv_sec;
	374	vap->va_mtime.tv_usec = stat.mtime.tv_nsec / NSEC_PER_USEC;
	375	vap->va_ctime.tv_sec = stat.ctime.tv_sec;
	376	vap->va_ctime.tv_usec = stat.ctime.tv_nsec / NSEC_PER_USEC;
	377	vap->va_rdev = stat.rdev;
	378	vap->va_blocks = stat.blocks;
	379
728b9dd8	380	return 0;
0b3cf046	381	}
4b171585	382	EXPORT_SYMBOL(vn_getattr);
4b171585	383
2f5d55aa	384	int vn_fsync(vnode_t vp, int flags, void x3, void *x4)
4b171585	385	{
36e6f861	386	int datasync = 0;
36e6f861	387
4b171585	388	BUG_ON(!vp);
e4f1d29f	389	BUG_ON(!vp->v_file);
4b171585	390
36e6f861	391	if (flags & FDSYNC)
	392	datasync = 1;
	393
728b9dd8	394	return -file_fsync(vp->v_file, vp->v_file->f_dentry, datasync);
4b171585	395	} /* vn_fsync() */
4b171585	396	EXPORT_SYMBOL(vn_fsync);
af828292	397
e4f1d29f	398	/* Function must be called while holding the vn_file_lock */
	399	static file_t *
	400	file_find(int fd)
	401	{
	402	file_t *fp;
	403
	404	BUG_ON(!spin_is_locked(&vn_file_lock));
	405
	406	list_for_each_entry(fp, &vn_file_list, f_list) {
	407	if (fd == fp->f_fd) {
	408	BUG_ON(atomic_read(&fp->f_ref) == 0);
	409	return fp;
	410	}
	411	}
	412
	413	return NULL;
	414	} /* file_find() */
	415
	416	file_t *
	417	vn_getf(int fd)
	418	{
	419	struct kstat stat;
	420	struct file *lfp;
	421	file_t *fp;
	422	vnode_t *vp;
	423
	424	/* Already open just take an extra reference */
	425	spin_lock(&vn_file_lock);
	426
	427	fp = file_find(fd);
	428	if (fp) {
	429	atomic_inc(&fp->f_ref);
	430	spin_unlock(&vn_file_lock);
e4f1d29f	431	return fp;
	432	}
	433
	434	spin_unlock(&vn_file_lock);
	435
	436	/* File was not yet opened create the object and setup */
	437	fp = kmem_cache_alloc(vn_file_cache, 0);
	438	if (fp == NULL)
	439	goto out;
	440
	441	mutex_enter(&fp->f_lock);
	442
	443	fp->f_fd = fd;
	444	fp->f_offset = 0;
	445	atomic_inc(&fp->f_ref);
	446
	447	lfp = fget(fd);
	448	if (lfp == NULL)
	449	goto out_mutex;
	450
	451	vp = vn_alloc(KM_SLEEP);
	452	if (vp == NULL)
	453	goto out_fget;
	454
	455	if (vfs_getattr(lfp->f_vfsmnt, lfp->f_dentry, &stat))
	456	goto out_vnode;
	457
	458	mutex_enter(&vp->v_lock);
	459	vp->v_type = vn_get_sol_type(stat.mode);
	460	vp->v_file = lfp;
	461	mutex_exit(&vp->v_lock);
	462
	463	fp->f_vnode = vp;
	464	fp->f_file = lfp;
	465
	466	/* Put it on the tracking list */
	467	spin_lock(&vn_file_lock);
	468	list_add(&fp->f_list, &vn_file_list);
	469	spin_unlock(&vn_file_lock);
	470
	471	mutex_exit(&fp->f_lock);
	472	return fp;
	473
	474	out_vnode:
e4f1d29f	475	vn_free(vp);
e4f1d29f	476	out_fget:
e4f1d29f	477	fput(lfp);
e4f1d29f	478	out_mutex:
e4f1d29f	479	mutex_exit(&fp->f_lock);
	480	kmem_cache_free(vn_file_cache, fp);
	481	out:
e4f1d29f	482	return NULL;
	483	} /* getf() */
	484	EXPORT_SYMBOL(getf);
	485
	486	static void releasef_locked(file_t *fp)
	487	{
	488	BUG_ON(fp->f_file == NULL);
	489	BUG_ON(fp->f_vnode == NULL);
	490
	491	/* Unlinked from list, no refs, safe to free outside mutex */
	492	fput(fp->f_file);
	493	vn_free(fp->f_vnode);
	494
	495	kmem_cache_free(vn_file_cache, fp);
	496	}
	497
	498	void
	499	vn_releasef(int fd)
	500	{
	501	file_t *fp;
	502
	503	spin_lock(&vn_file_lock);
	504	fp = file_find(fd);
	505	if (fp) {
	506	atomic_dec(&fp->f_ref);
	507	if (atomic_read(&fp->f_ref) > 0) {
	508	spin_unlock(&vn_file_lock);
	509	return;
	510	}
	511
	512	list_del(&fp->f_list);
	513	releasef_locked(fp);
	514	}
	515	spin_unlock(&vn_file_lock);
	516
	517	return;
	518	} /* releasef() */
	519	EXPORT_SYMBOL(releasef);
	520
af828292	521	static int
	522	vn_cache_constructor(void buf, void cdrarg, int kmflags)
	523	{
	524	struct vnode *vp = buf;
	525
	526	mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL);
	527
	528	return (0);
	529	} /* vn_cache_constructor() */
	530
	531	static void
	532	vn_cache_destructor(void buf, void cdrarg)
	533	{
	534	struct vnode *vp = buf;
	535
	536	mutex_destroy(&vp->v_lock);
	537	} /* vn_cache_destructor() */
	538
e4f1d29f	539	static int
	540	vn_file_cache_constructor(void buf, void cdrarg, int kmflags)
	541	{
	542	file_t *fp = buf;
	543
	544	atomic_set(&fp->f_ref, 0);
	545	mutex_init(&fp->f_lock, NULL, MUTEX_DEFAULT, NULL);
4e62fd41	546	INIT_LIST_HEAD(&fp->f_list);
e4f1d29f	547
	548	return (0);
	549	} /* file_cache_constructor() */
	550
	551	static void
	552	vn_file_cache_destructor(void buf, void cdrarg)
	553	{
	554	file_t *fp = buf;
	555
	556	mutex_destroy(&fp->f_lock);
	557	} /* vn_file_cache_destructor() */
	558
af828292	559	int
	560	vn_init(void)
	561	{
5d86345d	562	vn_cache = kmem_cache_create("spl_vn_cache", sizeof(struct vnode), 64,
	563	vn_cache_constructor,
	564	vn_cache_destructor,
af828292	565	NULL, NULL, NULL, 0);
e4f1d29f	566
	567	vn_file_cache = kmem_cache_create("spl_vn_file_cache",
	568	sizeof(file_t), 64,
	569	vn_file_cache_constructor,
	570	vn_file_cache_destructor,
	571	NULL, NULL, NULL, 0);
af828292	572	return 0;
	573	} /* vn_init() */
	574
	575	void
	576	vn_fini(void)
	577	{
e4f1d29f	578	file_t fp, next_fp;
	579	int rc, leaked = 0;
	580
	581	spin_lock(&vn_file_lock);
	582
	583	list_for_each_entry_safe(fp, next_fp, &vn_file_list, f_list) {
	584	list_del(&fp->f_list);
	585	releasef_locked(fp);
	586	leaked++;
	587	}
	588
	589	rc = kmem_cache_destroy(vn_file_cache);
	590	if (rc)
57d1b188	591	printk("spl: Warning leaked vn_file_cache objects, %d\n", rc);
e4f1d29f	592
	593	vn_file_cache = NULL;
	594	spin_unlock(&vn_file_lock);
	595
	596	if (leaked > 0)
8d0f1ee9	597	printk("spl: Warning %d files leaked\n", leaked);
e4f1d29f	598
	599	rc = kmem_cache_destroy(vn_cache);
	600	if (rc)
57d1b188	601	printk("spl: Warning leaked vn_cache objects, %d\n", rc);
e4f1d29f	602
e4f1d29f	603	return;
af828292	604	} /* vn_fini() */