#include <sys/cred.h>
#include <sys/vnode.h>
#include <linux/falloc.h>
-#include <spl-debug.h>
-
-#ifdef SS_DEBUG_SUBSYS
-#undef SS_DEBUG_SUBSYS
-#endif
-
-#define SS_DEBUG_SUBSYS SS_VNODE
vnode_t *rootdir = (vnode_t *)0xabcd1234;
EXPORT_SYMBOL(rootdir);
vn_alloc(int flag)
{
vnode_t *vp;
- SENTRY;
vp = kmem_cache_alloc(vn_cache, flag);
if (vp != NULL) {
vp->v_type = 0;
}
- SRETURN(vp);
+ return (vp);
} /* vn_alloc() */
EXPORT_SYMBOL(vn_alloc);
void
vn_free(vnode_t *vp)
{
- SENTRY;
kmem_cache_free(vn_cache, vp);
- SEXIT;
} /* vn_free() */
EXPORT_SYMBOL(vn_free);
int rc, saved_umask = 0;
gfp_t saved_gfp;
vnode_t *vp;
- SENTRY;
ASSERT(flags & (FWRITE | FREAD));
ASSERT(seg == UIO_SYSSPACE);
(void)xchg(¤t->fs->umask, saved_umask);
if (IS_ERR(fp))
- SRETURN(-PTR_ERR(fp));
+ return (-PTR_ERR(fp));
#ifdef HAVE_2ARGS_VFS_GETATTR
rc = vfs_getattr(&fp->f_path, &stat);
#endif
if (rc) {
filp_close(fp, 0);
- SRETURN(-rc);
+ return (-rc);
}
vp = vn_alloc(KM_SLEEP);
if (!vp) {
filp_close(fp, 0);
- SRETURN(ENOMEM);
+ return (ENOMEM);
}
saved_gfp = mapping_gfp_mask(fp->f_mapping);
*vpp = vp;
mutex_exit(&vp->v_lock);
- SRETURN(0);
+ return (0);
} /* vn_open() */
EXPORT_SYMBOL(vn_open);
{
char *realpath;
int len, rc;
- SENTRY;
ASSERT(vp == rootdir);
len = strlen(path) + 2;
realpath = kmalloc(len, GFP_KERNEL);
if (!realpath)
- SRETURN(ENOMEM);
+ return (ENOMEM);
(void)snprintf(realpath, len, "/%s", path);
rc = vn_open(realpath, seg, flags, mode, vpp, x1, x2);
kfree(realpath);
- SRETURN(rc);
+ return (rc);
} /* vn_openat() */
EXPORT_SYMBOL(vn_openat);
mm_segment_t saved_fs;
struct file *fp;
int rc;
- SENTRY;
ASSERT(uio == UIO_WRITE || uio == UIO_READ);
ASSERT(vp);
fp->f_pos = offset;
if (rc < 0)
- SRETURN(-rc);
+ return (-rc);
if (residp) {
*residp = len - rc;
} else {
if (rc != len)
- SRETURN(EIO);
+ return (EIO);
}
- SRETURN(0);
+ return (0);
} /* vn_rdwr() */
EXPORT_SYMBOL(vn_rdwr);
vn_close(vnode_t *vp, int flags, int x1, int x2, void *x3, void *x4)
{
int rc;
- SENTRY;
ASSERT(vp);
ASSERT(vp->v_file);
rc = filp_close(vp->v_file, 0);
vn_free(vp);
- SRETURN(-rc);
+ return (-rc);
} /* vn_close() */
EXPORT_SYMBOL(vn_close);
struct path parent;
struct inode *inode = NULL;
int rc = 0;
- SENTRY;
ASSERT(seg == UIO_SYSSPACE);
ASSERT(flags == RMFILE);
dentry = spl_kern_path_locked(path, &parent);
rc = PTR_ERR(dentry);
if (!IS_ERR(dentry)) {
- if (parent.dentry->d_name.name[parent.dentry->d_name.len])
- SGOTO(slashes, rc = 0);
+ if (parent.dentry->d_name.name[parent.dentry->d_name.len]) {
+ rc = 0;
+ goto slashes;
+ }
inode = dentry->d_inode;
- if (inode)
+ if (inode) {
atomic_inc(&inode->i_count);
- else
- SGOTO(slashes, rc = 0);
+ } else {
+ rc = 0;
+ goto slashes;
+ }
#ifdef HAVE_2ARGS_VFS_UNLINK
rc = vfs_unlink(parent.dentry->d_inode, dentry);
iput(inode); /* truncate the inode here */
path_put(&parent);
- SRETURN(-rc);
+ return (-rc);
slashes:
rc = !dentry->d_inode ? -ENOENT :
S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
- SGOTO(exit1, rc);
+ goto exit1;
} /* vn_remove() */
EXPORT_SYMBOL(vn_remove);
struct dentry *trap;
struct path old_parent, new_parent;
int rc = 0;
- SENTRY;
old_dentry = spl_kern_path_locked(oldname, &old_parent);
- if (IS_ERR(old_dentry))
- SGOTO(exit, rc = PTR_ERR(old_dentry));
+ if (IS_ERR(old_dentry)) {
+ rc = PTR_ERR(old_dentry);
+ goto exit;
+ }
spl_inode_unlock(old_parent.dentry->d_inode);
new_dentry = spl_kern_path_locked(newname, &new_parent);
- if (IS_ERR(new_dentry))
- SGOTO(exit2, rc = PTR_ERR(new_dentry));
+ if (IS_ERR(new_dentry)) {
+ rc = PTR_ERR(new_dentry);
+ goto exit2;
+ }
spl_inode_unlock(new_parent.dentry->d_inode);
rc = -EXDEV;
if (old_parent.mnt != new_parent.mnt)
- SGOTO(exit3, rc);
+ goto exit3;
old_dir = old_parent.dentry;
new_dir = new_parent.dentry;
/* source should not be ancestor of target */
rc = -EINVAL;
if (old_dentry == trap)
- SGOTO(exit4, rc);
+ goto exit4;
/* target should not be an ancestor of source */
rc = -ENOTEMPTY;
if (new_dentry == trap)
- SGOTO(exit4, rc);
+ goto exit4;
/* source must exist */
rc = -ENOENT;
if (!old_dentry->d_inode)
- SGOTO(exit4, rc);
+ goto exit4;
/* unless the source is a directory trailing slashes give -ENOTDIR */
if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
rc = -ENOTDIR;
if (old_dentry->d_name.name[old_dentry->d_name.len])
- SGOTO(exit4, rc);
+ goto exit4;
if (new_dentry->d_name.name[new_dentry->d_name.len])
- SGOTO(exit4, rc);
+ goto exit4;
}
#if defined(HAVE_4ARGS_VFS_RENAME)
dput(old_dentry);
path_put(&old_parent);
exit:
- SRETURN(-rc);
+ return (-rc);
}
EXPORT_SYMBOL(vn_rename);
struct file *fp;
struct kstat stat;
int rc;
- SENTRY;
ASSERT(vp);
ASSERT(vp->v_file);
rc = vfs_getattr(fp->f_path.mnt, fp->f_dentry, &stat);
#endif
if (rc)
- SRETURN(-rc);
+ return (-rc);
vap->va_type = vn_mode_to_vtype(stat.mode);
vap->va_mode = stat.mode;
vap->va_rdev = stat.rdev;
vap->va_nblocks = stat.blocks;
- SRETURN(0);
+ return (0);
}
EXPORT_SYMBOL(vn_getattr);
int vn_fsync(vnode_t *vp, int flags, void *x3, void *x4)
{
int datasync = 0;
- SENTRY;
ASSERT(vp);
ASSERT(vp->v_file);
if (flags & FDSYNC)
datasync = 1;
- SRETURN(-spl_filp_fsync(vp->v_file, datasync));
+ return (-spl_filp_fsync(vp->v_file, datasync));
} /* vn_fsync() */
EXPORT_SYMBOL(vn_fsync);
offset_t offset, void *x6, void *x7)
{
int error = EOPNOTSUPP;
- SENTRY;
if (cmd != F_FREESP || bfp->l_whence != 0)
- SRETURN(EOPNOTSUPP);
+ return (EOPNOTSUPP);
ASSERT(vp);
ASSERT(vp->v_file);
FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE,
bfp->l_start, bfp->l_len);
if (error == 0)
- SRETURN(0);
+ return (0);
#endif
#ifdef HAVE_INODE_TRUNCATE_RANGE
if (end % PAGE_SIZE != 0) {
end &= ~(off_t)(PAGE_SIZE - 1);
if (end <= bfp->l_start)
- SRETURN(0);
+ return (0);
}
--end;
vp->v_file->f_dentry->d_inode,
bfp->l_start, end
);
- SRETURN(0);
+ return (0);
}
#endif
- SRETURN(error);
+ return (error);
}
EXPORT_SYMBOL(vn_space);
file_t *fp;
vnode_t *vp;
int rc = 0;
- SENTRY;
/* Already open just take an extra reference */
spin_lock(&vn_file_lock);
if (fp) {
atomic_inc(&fp->f_ref);
spin_unlock(&vn_file_lock);
- SRETURN(fp);
+ return (fp);
}
spin_unlock(&vn_file_lock);
/* File was not yet opened create the object and setup */
fp = kmem_cache_alloc(vn_file_cache, KM_SLEEP);
if (fp == NULL)
- SGOTO(out, rc);
+ goto out;
mutex_enter(&fp->f_lock);
lfp = fget(fd);
if (lfp == NULL)
- SGOTO(out_mutex, rc);
+ goto out_mutex;
vp = vn_alloc(KM_SLEEP);
if (vp == NULL)
- SGOTO(out_fget, rc);
+ goto out_fget;
#ifdef HAVE_2ARGS_VFS_GETATTR
rc = vfs_getattr(&lfp->f_path, &stat);
rc = vfs_getattr(lfp->f_path.mnt, lfp->f_dentry, &stat);
#endif
if (rc)
- SGOTO(out_vnode, rc);
+ goto out_vnode;
mutex_enter(&vp->v_lock);
vp->v_type = vn_mode_to_vtype(stat.mode);
spin_unlock(&vn_file_lock);
mutex_exit(&fp->f_lock);
- SRETURN(fp);
+ return (fp);
out_vnode:
vn_free(vp);
mutex_exit(&fp->f_lock);
kmem_cache_free(vn_file_cache, fp);
out:
- SRETURN(NULL);
+ return (NULL);
} /* getf() */
EXPORT_SYMBOL(getf);
vn_releasef(int fd)
{
file_t *fp;
- SENTRY;
spin_lock(&vn_file_lock);
fp = file_find(fd);
atomic_dec(&fp->f_ref);
if (atomic_read(&fp->f_ref) > 0) {
spin_unlock(&vn_file_lock);
- SEXIT;
return;
}
}
spin_unlock(&vn_file_lock);
- SEXIT;
return;
} /* releasef() */
EXPORT_SYMBOL(releasef);
struct path path;
mm_segment_t saved_fs;
int rc;
- SENTRY;
/*
* user_path_dir() and __user_walk() both expect 'filename' to be
rc = user_path_dir(filename, &path);
if (rc)
- SGOTO(out, rc);
+ goto out;
rc = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
if (rc)
- SGOTO(dput_and_out, rc);
+ goto dput_and_out;
vn_set_fs_pwd(current->fs, &path);
out:
set_fs(saved_fs);
- SRETURN(-rc);
+ return (-rc);
} /* vn_set_pwd() */
EXPORT_SYMBOL(vn_set_pwd);
int
spl_vn_init(void)
{
- SENTRY;
vn_cache = kmem_cache_create("spl_vn_cache",
sizeof(struct vnode), 64,
vn_cache_constructor,
vn_file_cache_constructor,
vn_file_cache_destructor,
NULL, NULL, NULL, KMC_KMEM);
- SRETURN(0);
+ return (0);
} /* vn_init() */
void
{
file_t *fp, *next_fp;
int leaked = 0;
- SENTRY;
spin_lock(&vn_file_lock);
spin_unlock(&vn_file_lock);
if (leaked > 0)
- SWARN("Warning %d files leaked\n", leaked);
+ printk(KERN_WARNING "WARNING: %d vnode files leaked\n", leaked);
kmem_cache_destroy(vn_file_cache);
kmem_cache_destroy(vn_cache);
- SEXIT;
return;
} /* vn_fini() */
projects / mirror_spl.git / blobdiff