Subversion Repositories test_project

/*

  FUSE: Filesystem in Userspace

  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>

  This program can be distributed under the terms of the GNU GPL.

  See the file COPYING.

*/

#include "fuse_i.h"

#include <linux/pagemap.h>

#include <linux/slab.h>

#include <linux/file.h>

#include <linux/seq_file.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/parser.h>

#include <linux/statfs.h>

#include <linux/random.h>

#include <linux/sched.h>

MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");

MODULE_DESCRIPTION("Filesystem in Userspace");

MODULE_LICENSE("GPL");

static struct kmem_cache *fuse_inode_cachep;

struct list_head fuse_conn_list;

DEFINE_MUTEX(fuse_mutex);

#define FUSE_SUPER_MAGIC 0x65735546

struct fuse_mount_data {

        int fd;

        unsigned rootmode;

        unsigned user_id;

        unsigned group_id;

        unsigned fd_present : 1;

        unsigned rootmode_present : 1;

        unsigned user_id_present : 1;

        unsigned group_id_present : 1;

        unsigned flags;

        unsigned max_read;

        unsigned blksize;

};

static struct inode *fuse_alloc_inode(struct super_block *sb)

{

        struct inode *inode;

        struct fuse_inode *fi;

        inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);

        if (!inode)

                return NULL;

        fi = get_fuse_inode(inode);

        fi->i_time = 0;

        fi->nodeid = 0;

        fi->nlookup = 0;

        fi->attr_version = 0;

        INIT_LIST_HEAD(&fi->write_files);

        fi->forget_req = fuse_request_alloc();

        if (!fi->forget_req) {

                kmem_cache_free(fuse_inode_cachep, inode);

                return NULL;

        }

        return inode;

}

static void fuse_destroy_inode(struct inode *inode)

{

        struct fuse_inode *fi = get_fuse_inode(inode);

        BUG_ON(!list_empty(&fi->write_files));

        if (fi->forget_req)

                fuse_request_free(fi->forget_req);

        kmem_cache_free(fuse_inode_cachep, inode);

}

static void fuse_read_inode(struct inode *inode)

{

        /* No op */

}

void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,

                      unsigned long nodeid, u64 nlookup)

{

        struct fuse_forget_in *inarg = &req->misc.forget_in;

        inarg->nlookup = nlookup;

        req->in.h.opcode = FUSE_FORGET;

        req->in.h.nodeid = nodeid;

        req->in.numargs = 1;

        req->in.args[0].size = sizeof(struct fuse_forget_in);

        req->in.args[0].value = inarg;

        request_send_noreply(fc, req);

}

static void fuse_clear_inode(struct inode *inode)

{

        if (inode->i_sb->s_flags & MS_ACTIVE) {

                struct fuse_conn *fc = get_fuse_conn(inode);

                struct fuse_inode *fi = get_fuse_inode(inode);

                fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);

                fi->forget_req = NULL;

        }

}

static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)

{

        if (*flags & MS_MANDLOCK)

                return -EINVAL;

        return 0;

}

static void fuse_truncate(struct address_space *mapping, loff_t offset)

{

        /* See vmtruncate() */

        unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);

        truncate_inode_pages(mapping, offset);

        unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);

}

void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,

                            u64 attr_valid, u64 attr_version)

{

        struct fuse_conn *fc = get_fuse_conn(inode);

        struct fuse_inode *fi = get_fuse_inode(inode);

        loff_t oldsize;

        spin_lock(&fc->lock);

        if (attr_version != 0 && fi->attr_version > attr_version) {

                spin_unlock(&fc->lock);

                return;

        }

        fi->attr_version = ++fc->attr_version;

        fi->i_time = attr_valid;

        inode->i_ino     = attr->ino;

        inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);

        inode->i_nlink   = attr->nlink;

        inode->i_uid     = attr->uid;

        inode->i_gid     = attr->gid;

        inode->i_blocks  = attr->blocks;

        inode->i_atime.tv_sec   = attr->atime;

        inode->i_atime.tv_nsec  = attr->atimensec;

        inode->i_mtime.tv_sec   = attr->mtime;

        inode->i_mtime.tv_nsec  = attr->mtimensec;

        inode->i_ctime.tv_sec   = attr->ctime;

        inode->i_ctime.tv_nsec  = attr->ctimensec;

        if (attr->blksize != 0)

                inode->i_blkbits = ilog2(attr->blksize);

        else

                inode->i_blkbits = inode->i_sb->s_blocksize_bits;

        /*

         * Don't set the sticky bit in i_mode, unless we want the VFS

         * to check permissions.  This prevents failures due to the

         * check in may_delete().

         */

        fi->orig_i_mode = inode->i_mode;

        if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))

                inode->i_mode &= ~S_ISVTX;

        oldsize = inode->i_size;

        i_size_write(inode, attr->size);

        spin_unlock(&fc->lock);

        if (S_ISREG(inode->i_mode) && oldsize != attr->size) {

                if (attr->size < oldsize)

                        fuse_truncate(inode->i_mapping, attr->size);

                invalidate_inode_pages2(inode->i_mapping);

        }

}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)

{

        inode->i_mode = attr->mode & S_IFMT;

        inode->i_size = attr->size;

        if (S_ISREG(inode->i_mode)) {

                fuse_init_common(inode);

                fuse_init_file_inode(inode);

        } else if (S_ISDIR(inode->i_mode))

                fuse_init_dir(inode);

        else if (S_ISLNK(inode->i_mode))

                fuse_init_symlink(inode);

        else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||

                 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {

                fuse_init_common(inode);

                init_special_inode(inode, inode->i_mode,

                                   new_decode_dev(attr->rdev));

        } else

                BUG();

}

static int fuse_inode_eq(struct inode *inode, void *_nodeidp)

{

        unsigned long nodeid = *(unsigned long *) _nodeidp;

        if (get_node_id(inode) == nodeid)

                return 1;

        else

                return 0;

}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)

{

        unsigned long nodeid = *(unsigned long *) _nodeidp;

        get_fuse_inode(inode)->nodeid = nodeid;

        return 0;

}

struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,

                        int generation, struct fuse_attr *attr,

                        u64 attr_valid, u64 attr_version)

{

        struct inode *inode;

        struct fuse_inode *fi;

        struct fuse_conn *fc = get_fuse_conn_super(sb);

 retry:

        inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);

        if (!inode)

                return NULL;

        if ((inode->i_state & I_NEW)) {

                inode->i_flags |= S_NOATIME|S_NOCMTIME;

                inode->i_generation = generation;

                inode->i_data.backing_dev_info = &fc->bdi;

                fuse_init_inode(inode, attr);

                unlock_new_inode(inode);

        } else if ((inode->i_mode ^ attr->mode) & S_IFMT) {

                /* Inode has changed type, any I/O on the old should fail */

                make_bad_inode(inode);

                iput(inode);

                goto retry;

        }

        fi = get_fuse_inode(inode);

        spin_lock(&fc->lock);

        fi->nlookup ++;

        spin_unlock(&fc->lock);

        fuse_change_attributes(inode, attr, attr_valid, attr_version);

        return inode;

}

static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)

{

        if (flags & MNT_FORCE)

                fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));

}

static void fuse_send_destroy(struct fuse_conn *fc)

{

        struct fuse_req *req = fc->destroy_req;

        if (req && fc->conn_init) {

                fc->destroy_req = NULL;

                req->in.h.opcode = FUSE_DESTROY;

                req->force = 1;

                request_send(fc, req);

                fuse_put_request(fc, req);

        }

}

static void fuse_put_super(struct super_block *sb)

{

        struct fuse_conn *fc = get_fuse_conn_super(sb);

        fuse_send_destroy(fc);

        spin_lock(&fc->lock);

        fc->connected = 0;

        fc->blocked = 0;

        spin_unlock(&fc->lock);

        /* Flush all readers on this fs */

        kill_fasync(&fc->fasync, SIGIO, POLL_IN);

        wake_up_all(&fc->waitq);

        wake_up_all(&fc->blocked_waitq);

        wake_up_all(&fc->reserved_req_waitq);

        mutex_lock(&fuse_mutex);

        list_del(&fc->entry);

        fuse_ctl_remove_conn(fc);

        mutex_unlock(&fuse_mutex);

        fuse_conn_put(fc);

}

static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)

{

        stbuf->f_type    = FUSE_SUPER_MAGIC;

        stbuf->f_bsize   = attr->bsize;

        stbuf->f_frsize  = attr->frsize;

        stbuf->f_blocks  = attr->blocks;

        stbuf->f_bfree   = attr->bfree;

        stbuf->f_bavail  = attr->bavail;

        stbuf->f_files   = attr->files;

        stbuf->f_ffree   = attr->ffree;

        stbuf->f_namelen = attr->namelen;

        /* fsid is left zero */

}

static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)

{

        struct super_block *sb = dentry->d_sb;

        struct fuse_conn *fc = get_fuse_conn_super(sb);

        struct fuse_req *req;

        struct fuse_statfs_out outarg;

        int err;

        if (!fuse_allow_task(fc, current)) {

                buf->f_type = FUSE_SUPER_MAGIC;

                return 0;

        }

        req = fuse_get_req(fc);

        if (IS_ERR(req))

                return PTR_ERR(req);

        memset(&outarg, 0, sizeof(outarg));

        req->in.numargs = 0;

        req->in.h.opcode = FUSE_STATFS;

        req->in.h.nodeid = get_node_id(dentry->d_inode);

        req->out.numargs = 1;

        req->out.args[0].size =

                fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);

        req->out.args[0].value = &outarg;

        request_send(fc, req);

        err = req->out.h.error;

        if (!err)

                convert_fuse_statfs(buf, &outarg.st);

        fuse_put_request(fc, req);

        return err;

}

enum {

        OPT_FD,

        OPT_ROOTMODE,

        OPT_USER_ID,

        OPT_GROUP_ID,

        OPT_DEFAULT_PERMISSIONS,

        OPT_ALLOW_OTHER,

        OPT_MAX_READ,

        OPT_BLKSIZE,

        OPT_ERR

};

static match_table_t tokens = {

        {OPT_FD,                        "fd=%u"},

        {OPT_ROOTMODE,                  "rootmode=%o"},

        {OPT_USER_ID,                   "user_id=%u"},

        {OPT_GROUP_ID,                  "group_id=%u"},

        {OPT_DEFAULT_PERMISSIONS,       "default_permissions"},

        {OPT_ALLOW_OTHER,               "allow_other"},

        {OPT_MAX_READ,                  "max_read=%u"},

        {OPT_BLKSIZE,                   "blksize=%u"},

        {OPT_ERR,                       NULL}

};

static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)

{

        char *p;

        memset(d, 0, sizeof(struct fuse_mount_data));

        d->max_read = ~0;

        d->blksize = 512;

        while ((p = strsep(&opt, ",")) != NULL) {

                int token;

                int value;

                substring_t args[MAX_OPT_ARGS];

                if (!*p)

                        continue;

                token = match_token(p, tokens, args);

                switch (token) {

                case OPT_FD:

                        if (match_int(&args[0], &value))

                                return 0;

                        d->fd = value;

                        d->fd_present = 1;

                        break;

                case OPT_ROOTMODE:

                        if (match_octal(&args[0], &value))

                                return 0;

                        if (!fuse_valid_type(value))

                                return 0;

                        d->rootmode = value;

                        d->rootmode_present = 1;

                        break;

                case OPT_USER_ID:

                        if (match_int(&args[0], &value))

                                return 0;

                        d->user_id = value;

                        d->user_id_present = 1;

                        break;

                case OPT_GROUP_ID:

                        if (match_int(&args[0], &value))

                                return 0;

                        d->group_id = value;

                        d->group_id_present = 1;

                        break;

                case OPT_DEFAULT_PERMISSIONS:

                        d->flags |= FUSE_DEFAULT_PERMISSIONS;

                        break;

                case OPT_ALLOW_OTHER:

                        d->flags |= FUSE_ALLOW_OTHER;

                        break;

                case OPT_MAX_READ:

                        if (match_int(&args[0], &value))

                                return 0;

                        d->max_read = value;

                        break;

                case OPT_BLKSIZE:

                        if (!is_bdev || match_int(&args[0], &value))

                                return 0;

                        d->blksize = value;

                        break;

                default:

                        return 0;

                }

        }

        if (!d->fd_present || !d->rootmode_present ||

            !d->user_id_present || !d->group_id_present)

                return 0;

        return 1;

}

static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)

{

        struct fuse_conn *fc = get_fuse_conn_super(mnt->mnt_sb);

        seq_printf(m, ",user_id=%u", fc->user_id);

        seq_printf(m, ",group_id=%u", fc->group_id);

        if (fc->flags & FUSE_DEFAULT_PERMISSIONS)

                seq_puts(m, ",default_permissions");

        if (fc->flags & FUSE_ALLOW_OTHER)

                seq_puts(m, ",allow_other");

        if (fc->max_read != ~0)

                seq_printf(m, ",max_read=%u", fc->max_read);

        return 0;

}

static struct fuse_conn *new_conn(void)

{

        struct fuse_conn *fc;

        int err;

        fc = kzalloc(sizeof(*fc), GFP_KERNEL);

        if (fc) {

                spin_lock_init(&fc->lock);

                mutex_init(&fc->inst_mutex);

                atomic_set(&fc->count, 1);

                init_waitqueue_head(&fc->waitq);

                init_waitqueue_head(&fc->blocked_waitq);

                init_waitqueue_head(&fc->reserved_req_waitq);

                INIT_LIST_HEAD(&fc->pending);

                INIT_LIST_HEAD(&fc->processing);

                INIT_LIST_HEAD(&fc->io);

                INIT_LIST_HEAD(&fc->interrupts);

                atomic_set(&fc->num_waiting, 0);

                fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;

                fc->bdi.unplug_io_fn = default_unplug_io_fn;

                err = bdi_init(&fc->bdi);

                if (err) {

                        kfree(fc);

                        fc = NULL;

                        goto out;

                }

                fc->reqctr = 0;

                fc->blocked = 1;

                fc->attr_version = 1;

                get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));

        }

out:

        return fc;

}

void fuse_conn_put(struct fuse_conn *fc)

{

        if (atomic_dec_and_test(&fc->count)) {

                if (fc->destroy_req)

                        fuse_request_free(fc->destroy_req);

                mutex_destroy(&fc->inst_mutex);

                bdi_destroy(&fc->bdi);

                kfree(fc);

        }

}

struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)

{

        atomic_inc(&fc->count);

        return fc;

}

static struct inode *get_root_inode(struct super_block *sb, unsigned mode)

{

        struct fuse_attr attr;

        memset(&attr, 0, sizeof(attr));

        attr.mode = mode;

        attr.ino = FUSE_ROOT_ID;

        attr.nlink = 1;

        return fuse_iget(sb, 1, 0, &attr, 0, 0);

}

static const struct super_operations fuse_super_operations = {

        .alloc_inode    = fuse_alloc_inode,

        .destroy_inode  = fuse_destroy_inode,

        .read_inode     = fuse_read_inode,

        .clear_inode    = fuse_clear_inode,

        .drop_inode     = generic_delete_inode,

        .remount_fs     = fuse_remount_fs,

        .put_super      = fuse_put_super,

        .umount_begin   = fuse_umount_begin,

        .statfs         = fuse_statfs,

        .show_options   = fuse_show_options,

};

static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)

{

        struct fuse_init_out *arg = &req->misc.init_out;

        if (req->out.h.error || arg->major != FUSE_KERNEL_VERSION)

                fc->conn_error = 1;

        else {

                unsigned long ra_pages;

                if (arg->minor >= 6) {

                        ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;

                        if (arg->flags & FUSE_ASYNC_READ)

                                fc->async_read = 1;

                        if (!(arg->flags & FUSE_POSIX_LOCKS))

                                fc->no_lock = 1;

                        if (arg->flags & FUSE_ATOMIC_O_TRUNC)

                                fc->atomic_o_trunc = 1;

                } else {

                        ra_pages = fc->max_read / PAGE_CACHE_SIZE;

                        fc->no_lock = 1;

                }

                fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);

                fc->minor = arg->minor;

                fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;

                fc->conn_init = 1;

        }

        fuse_put_request(fc, req);

        fc->blocked = 0;

        wake_up_all(&fc->blocked_waitq);

}

static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)

{

        struct fuse_init_in *arg = &req->misc.init_in;

        arg->major = FUSE_KERNEL_VERSION;

        arg->minor = FUSE_KERNEL_MINOR_VERSION;

        arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;

        arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC;

        req->in.h.opcode = FUSE_INIT;

        req->in.numargs = 1;

        req->in.args[0].size = sizeof(*arg);

        req->in.args[0].value = arg;

        req->out.numargs = 1;

        /* Variable length arguement used for backward compatibility

           with interface version < 7.5.  Rest of init_out is zeroed

           by do_get_request(), so a short reply is not a problem */

        req->out.argvar = 1;

        req->out.args[0].size = sizeof(struct fuse_init_out);

        req->out.args[0].value = &req->misc.init_out;

        req->end = process_init_reply;

        request_send_background(fc, req);

}

static u64 conn_id(void)

{

        static u64 ctr = 1;

        return ctr++;

}

static int fuse_fill_super(struct super_block *sb, void *data, int silent)

{

        struct fuse_conn *fc;

        struct inode *root;

        struct fuse_mount_data d;

        struct file *file;

        struct dentry *root_dentry;

        struct fuse_req *init_req;

        int err;

        int is_bdev = sb->s_bdev != NULL;

        if (sb->s_flags & MS_MANDLOCK)

                return -EINVAL;

        if (!parse_fuse_opt((char *) data, &d, is_bdev))

                return -EINVAL;

        if (is_bdev) {

#ifdef CONFIG_BLOCK

                if (!sb_set_blocksize(sb, d.blksize))

                        return -EINVAL;

#endif

        } else {

                sb->s_blocksize = PAGE_CACHE_SIZE;

                sb->s_blocksize_bits = PAGE_CACHE_SHIFT;

        }

        sb->s_magic = FUSE_SUPER_MAGIC;

        sb->s_op = &fuse_super_operations;

        sb->s_maxbytes = MAX_LFS_FILESIZE;

        file = fget(d.fd);

        if (!file)

                return -EINVAL;

        if (file->f_op != &fuse_dev_operations)

                return -EINVAL;

        fc = new_conn();

        if (!fc)