+2004-04-09 Miklos Szeredi <mszeredi@inf.bme.hu>
+
+ * Check some limits so userspace won't get too big requests
+
2004-04-05 Miklos Szeredi <mszeredi@inf.bme.hu>
* Kill compile warning
/* Conservative buffer size for the client */
#define FUSE_MAX_IN 8192
+#define FUSE_NAME_MAX 1024
+#define FUSE_SYMLINK_MAX 4096
+#define FUSE_XATTR_SIZE_MAX 4096
+
struct fuse_entry_out {
unsigned long ino; /* Inode number */
unsigned long generation; /* Inode generation: ino:gen must
struct fuse_req *req;
req = (struct fuse_req *) kmem_cache_alloc(fuse_req_cachep, SLAB_NOFS);
- if(req) {
+ if (req) {
INIT_LIST_HEAD(&req->list);
req->issync = 0;
req->locked = 0;
static int request_restartable(enum fuse_opcode opcode)
{
- switch(opcode) {
+ switch (opcode) {
case FUSE_LOOKUP:
case FUSE_GETATTR:
case FUSE_READLINK:
spin_unlock(&fuse_lock);
intr = wait_event_interruptible(req->waitq, req->finished);
spin_lock(&fuse_lock);
- if(!intr)
+ if (!intr)
return;
/* Request interrupted... Wait for it to be unlocked */
- if(req->locked) {
+ if (req->locked) {
req->interrupted = 1;
spin_unlock(&fuse_lock);
wait_event(req->waitq, !req->locked);
/* Operations which modify the filesystem cannot safely be
restarted, because it is uncertain whether the operation has
completed or not... */
- if(req->sent && !request_restartable(req->in->h.opcode))
+ if (req->sent && !request_restartable(req->in->h.opcode))
req->out->h.error = -EINTR;
else
req->out->h.error = -ERESTARTSYS;
static int get_unique(struct fuse_conn *fc)
{
do fc->reqctr++;
- while(!fc->reqctr);
+ while (!fc->reqctr);
return fc->reqctr;
}
{
fuse_reqend_t endfunc = req->end;
- if(!endfunc) {
+ if (!endfunc) {
wake_up(&req->waitq);
spin_unlock(&fuse_lock);
} else {
struct fuse_req *req;
out->h.error = -ERESTARTSYS;
- if(down_interruptible(&fc->outstanding))
+ if (down_interruptible(&fc->outstanding))
return;
out->h.error = -ENOMEM;
req = request_new();
- if(req) {
+ if (req) {
req->in = in;
req->out = out;
req->issync = 1;
spin_lock(&fuse_lock);
out->h.error = -ENOTCONN;
- if(fc->file) {
+ if (fc->file) {
in->h.unique = get_unique(fc);
list_add_tail(&req->list, &fc->pending);
wake_up(&fc->waitq);
static inline void destroy_request(struct fuse_req *req)
{
- if(req) {
+ if (req) {
kfree(req->in);
request_free(req);
}
struct fuse_req *req;
req = request_new();
- if(!req)
+ if (!req)
return -ENOMEM;
req->in = in;
req->issync = 0;
spin_lock(&fuse_lock);
- if(!fc->file) {
+ if (!fc->file) {
spin_unlock(&fuse_lock);
request_free(req);
return -ENOTCONN;
BUG_ON(!end);
- if(down_trylock(&fc->outstanding))
+ if (down_trylock(&fc->outstanding))
return -EWOULDBLOCK;
err = -ENOMEM;
req = request_new();
- if(req) {
+ if (req) {
req->in = in;
req->out = out;
req->issync = 1;
spin_lock(&fuse_lock);
err = -ENOTCONN;
- if(fc->file) {
+ if (fc->file) {
in->h.unique = get_unique(fc);
list_add_tail(&req->list, &fc->pending);
wake_up(&fc->waitq);
DECLARE_WAITQUEUE(wait, current);
add_wait_queue_exclusive(&fc->waitq, &wait);
- while(fc->sb != NULL && list_empty(&fc->pending)) {
+ while (fc->sb != NULL && list_empty(&fc->pending)) {
set_current_state(TASK_INTERRUPTIBLE);
- if(signal_pending(current))
+ if (signal_pending(current))
break;
spin_unlock(&fuse_lock);
static inline int copy_in_one(const void *src, size_t srclen, char **dstp,
size_t *dstlenp)
{
- if(*dstlenp < srclen) {
+ if (*dstlenp < srclen) {
printk("fuse_dev_read: buffer too small\n");
return -EINVAL;
}
- if(copy_to_user(*dstp, src, srclen))
+ if (srclen && copy_to_user(*dstp, src, srclen))
return -EFAULT;
*dstp += srclen;
size_t orignbytes = nbytes;
err = copy_in_one(&in->h, sizeof(in->h), &buf, &nbytes);
- if(err)
+ if (err)
return err;
- for(i = 0; i < in->numargs; i++) {
+ for (i = 0; i < in->numargs; i++) {
struct fuse_in_arg *arg = &in->args[i];
err = copy_in_one(arg->value, arg->size, &buf, &nbytes);
- if(err)
+ if (err)
return err;
}
spin_lock(&fuse_lock);
request_wait(fc);
- if(fc->sb != NULL && !list_empty(&fc->pending)) {
+ if (fc->sb != NULL && !list_empty(&fc->pending)) {
req = list_entry(fc->pending.next, struct fuse_req, list);
list_del_init(&req->list);
req->locked = 1;
}
spin_unlock(&fuse_lock);
- if(fc->sb == NULL)
+ if (fc->sb == NULL)
return -ENODEV;
- if(req == NULL)
+ if (req == NULL)
return -EINTR;
ret = copy_in_args(req->in, buf, nbytes);
spin_lock(&fuse_lock);
- if(req->issync) {
- if(ret < 0) {
+ if (req->issync) {
+ if (ret < 0) {
req->out->h.error = -EPROTO;
req->finished = 1;
} else {
req->sent = 1;
}
req->locked = 0;
- if(ret < 0 || req->interrupted)
+ if (ret < 0 || req->interrupted)
/* Unlocks fuse_lock: */
request_end(fc, req);
else
list_for_each(entry, &fc->processing) {
struct fuse_req *tmp;
tmp = list_entry(entry, struct fuse_req, list);
- if(tmp->in->h.unique == unique) {
+ if (tmp->in->h.unique == unique) {
req = tmp;
break;
}
size_t *srclenp, int allowvar)
{
size_t dstlen = arg->size;
- if(*srclenp < dstlen) {
- if(!allowvar) {
+ if (*srclenp < dstlen) {
+ if (!allowvar) {
printk("fuse_dev_write: write is short\n");
return -EINVAL;
}
dstlen = *srclenp;
}
- if(dstlen) {
- if(copy_from_user(arg->value, *srcp, dstlen))
- return -EFAULT;
- }
+ if (dstlen && copy_from_user(arg->value, *srcp, dstlen))
+ return -EFAULT;
*srcp += dstlen;
*srclenp -= dstlen;
buf += sizeof(struct fuse_out_header);
nbytes -= sizeof(struct fuse_out_header);
- if(!out->h.error) {
- for(i = 0; i < out->numargs; i++) {
+ if (!out->h.error) {
+ for (i = 0; i < out->numargs; i++) {
struct fuse_out_arg *arg = &out->args[i];
int allowvar;
- if(out->argvar && i == out->numargs - 1)
+ if (out->argvar && i == out->numargs - 1)
allowvar = 1;
else
allowvar = 0;
err = copy_out_one(arg, &buf, &nbytes, allowvar);
- if(err)
+ if (err)
return err;
}
}
- if(nbytes != 0) {
+ if (nbytes != 0) {
printk("fuse_dev_write: write is long\n");
return -EINVAL;
}
static inline int copy_out_header(struct fuse_out_header *oh, const char *buf,
size_t nbytes)
{
- if(nbytes < sizeof(struct fuse_out_header)) {
+ if (nbytes < sizeof(struct fuse_out_header)) {
printk("fuse_dev_write: write is short\n");
return -EINVAL;
}
- if(copy_from_user(oh, buf, sizeof(struct fuse_out_header)))
+ if (copy_from_user(oh, buf, sizeof(struct fuse_out_header)))
return -EFAULT;
return 0;
{
struct inode *inode = iget(fc->sb, uh->ino);
int err = -ENOENT;
- if(inode) {
- if(inode->u.generic_ip) {
+ if (inode) {
+ if (inode->u.generic_ip) {
invalidate_inode_pages(inode);
err = 0;
}
return -EINVAL;
}
- if(copy_from_user(&uh, buf, sizeof(struct fuse_out_header)))
+ if (copy_from_user(&uh, buf, sizeof(struct fuse_out_header)))
return -EFAULT;
- switch(uh.opcode) {
+ switch (uh.opcode) {
case FUSE_INVALIDATE:
err = fuse_invalidate(fc, &uh);
break;
struct fuse_req *req;
struct fuse_out_header oh;
- if(!fc->sb)
+ if (!fc->sb)
return -EPERM;
err = copy_out_header(&oh, buf, nbytes);
- if(err)
+ if (err)
return err;
if (!oh.unique) {
spin_lock(&fuse_lock);
req = request_find(fc, oh.unique);
- if(req != NULL) {
+ if (req != NULL) {
list_del_init(&req->list);
req->locked = 1;
}
spin_unlock(&fuse_lock);
- if(!req)
+ if (!req)
return -ENOENT;
req->out->h = oh;
err = copy_out_args(req->out, buf, nbytes);
spin_lock(&fuse_lock);
- if(err)
+ if (err)
req->out->h.error = -EPROTO;
else {
/* fget() needs to be done in this context */
- if(req->in->h.opcode == FUSE_GETDIR && !oh.error)
+ if (req->in->h.opcode == FUSE_GETDIR && !oh.error)
process_getdir(req);
}
req->finished = 1;
request_end(fc, req);
out:
- if(!err)
+ if (!err)
return nbytes;
else
return err;
struct fuse_conn *fc = DEV_FC(file);
unsigned int mask = POLLOUT | POLLWRNORM;
- if(!fc->sb)
+ if (!fc->sb)
return -EPERM;
poll_wait(file, &fc->waitq, wait);
struct fuse_conn *fc;
fc = kmalloc(sizeof(*fc), GFP_KERNEL);
- if(fc != NULL) {
+ if (fc != NULL) {
fc->sb = NULL;
fc->file = NULL;
fc->flags = 0;
struct fuse_conn *fc;
fc = new_conn();
- if(!fc)
+ if (!fc)
return -ENOMEM;
fc->file = file;
static void end_requests(struct fuse_conn *fc, struct list_head *head)
{
- while(!list_empty(head)) {
+ while (!list_empty(head)) {
struct fuse_req *req;
req = list_entry(head->next, struct fuse_req, list);
list_del_init(&req->list);
- if(req->issync) {
+ if (req->issync) {
req->out->h.error = -ECONNABORTED;
req->finished = 1;
/* Unlocks fuse_lock: */
fuse_req_cachep = kmem_cache_create("fuser_request",
sizeof(struct fuse_req),
0, 0, NULL, NULL);
- if(!fuse_req_cachep)
+ if (!fuse_req_cachep)
return -ENOMEM;
proc_fs_fuse = proc_mkdir("fuse", proc_root_fs);
- if(proc_fs_fuse) {
+ if (proc_fs_fuse) {
struct proc_dir_entry *de;
proc_fs_fuse->owner = THIS_MODULE;
proc_fuse_dev = create_proc_entry("dev", S_IFSOCK | 0666,
proc_fs_fuse);
- if(proc_fuse_dev) {
+ if (proc_fuse_dev) {
proc_fuse_dev->owner = THIS_MODULE;
proc_fuse_dev->proc_fops = &fuse_dev_operations;
}
void fuse_dev_cleanup()
{
- if(proc_fs_fuse) {
+ if (proc_fs_fuse) {
remove_proc_entry("dev", proc_fs_fuse);
remove_proc_entry("version", proc_fs_fuse);
remove_proc_entry("fuse", proc_root_fs);
static void change_attributes(struct inode *inode, struct fuse_attr *attr)
{
- if(S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size) {
+ if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size) {
#ifdef KERNEL_2_6
invalidate_inode_pages(inode->i_mapping);
#else
{
inode->i_mode = attr->mode & S_IFMT;
i_size_write(inode, attr->size);
- if(S_ISREG(inode->i_mode)) {
+ if (S_ISREG(inode->i_mode)) {
inode->i_op = &fuse_file_inode_operations;
fuse_init_file_inode(inode);
}
- else if(S_ISDIR(inode->i_mode)) {
+ else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &fuse_dir_inode_operations;
inode->i_fop = &fuse_dir_operations;
}
- else if(S_ISLNK(inode->i_mode)) {
+ else if (S_ISLNK(inode->i_mode)) {
inode->i_op = &fuse_symlink_inode_operations;
}
- else if(S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
- S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)){
+ else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
+ S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)){
inode->i_op = &fuse_file_inode_operations;
init_special_inode(inode, inode->i_mode,
new_decode_dev(attr->rdev));
struct inode *inode;
inode = iget(sb, ino);
- if(inode) {
- if(!inode->u.generic_ip) {
+ if (inode) {
+ if (!inode->u.generic_ip) {
inode->i_generation = generation;
fuse_init_inode(inode, attr);
- } else if(inode->i_generation != generation)
+ } else if (inode->i_generation != generation)
printk("fuse_iget: bad generation for ino %lu\n", ino);
change_attributes(inode, attr);
struct fuse_in in = FUSE_IN_INIT;
struct fuse_out out = FUSE_OUT_INIT;
+
+ if (entry->d_name.len > FUSE_NAME_MAX)
+ return -ENAMETOOLONG;
+
in.h.opcode = FUSE_LOOKUP;
in.h.ino = dir->i_ino;
in.numargs = 1;
unsigned long nsec)
{
/* prevent wrapping of jiffies */
- if(sec + 1 >= LONG_MAX / HZ)
+ if (sec + 1 >= LONG_MAX / HZ)
return 0;
return jiffies + sec * HZ + nsec / (1000000000 / HZ);
struct inode *inode = NULL;
err = fuse_do_lookup(dir, entry, &outarg, &version);
- if(!err) {
+ if (!err) {
inode = fuse_iget(dir->i_sb, outarg.ino, outarg.generation,
&outarg.attr, version);
- if(!inode)
+ if (!inode)
return -ENOMEM;
- } else if(err != -ENOENT)
+ } else if (err != -ENOENT)
return err;
entry->d_time = time_to_jiffies(outarg.entry_valid,
struct inode *inode;
inode = fuse_iget(dir->i_sb, outarg->ino, outarg->generation,
&outarg->attr, version);
- if(!inode)
+ if (!inode)
return -ENOMEM;
/* Don't allow userspace to do really stupid things... */
- if((inode->i_mode ^ mode) & S_IFMT) {
+ if ((inode->i_mode ^ mode) & S_IFMT) {
iput(inode);
printk("fuse_mknod: inode has wrong type\n");
return -EINVAL;
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(out.h.error)
+ if (out.h.error)
return out.h.error;
return lookup_new_entry(dir, entry, &outarg, out.h.unique, mode);
out.args[0].size = sizeof(outarg);
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(out.h.error)
+ if (out.h.error)
return out.h.error;
return lookup_new_entry(dir, entry, &outarg, out.h.unique, S_IFDIR);
struct fuse_in in = FUSE_IN_INIT;
struct fuse_out out = FUSE_OUT_INIT;
struct fuse_entry_out outarg;
+ unsigned int len = strlen(link) + 1;
+
+ if (len > FUSE_SYMLINK_MAX)
+ return -ENAMETOOLONG;
in.h.opcode = FUSE_SYMLINK;
in.h.ino = dir->i_ino;
in.numargs = 2;
in.args[0].size = entry->d_name.len + 1;
in.args[0].value = entry->d_name.name;
- in.args[1].size = strlen(link) + 1;
+ in.args[1].size = len;
in.args[1].value = link;
out.numargs = 1;
out.args[0].size = sizeof(outarg);
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(out.h.error)
+ if (out.h.error)
return out.h.error;
return lookup_new_entry(dir, entry, &outarg, out.h.unique, S_IFLNK);
in.args[0].value = entry->d_name.name;
request_send(fc, &in, &out);
- if(!out.h.error) {
+ if (!out.h.error) {
/* Set nlink to zero so the inode can be cleared, if
the inode does have more links this will be
discovered at the next lookup/getattr */
in.args[0].size = entry->d_name.len + 1;
in.args[0].value = entry->d_name.name;
request_send(fc, &in, &out);
- if(!out.h.error)
+ if (!out.h.error)
entry->d_inode->i_nlink = 0;
return out.h.error;
out.args[0].size = sizeof(outarg);
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(out.h.error)
+ if (out.h.error)
return out.h.error;
/* Invalidate old entry, so attributes are refreshed */
out.args[0].value = &arg;
request_send(fc, &in, &out);
- if(!out.h.error)
+ if (!out.h.error)
change_attributes(inode, &arg.attr);
return out.h.error;
struct inode *inode = entry->d_inode;
struct fuse_conn *fc = INO_FC(inode);
- if(inode->i_ino == FUSE_ROOT_INO) {
- if(!(fc->flags & FUSE_ALLOW_OTHER) &&
- current->fsuid != fc->uid)
+ if (inode->i_ino == FUSE_ROOT_INO) {
+ if (!(fc->flags & FUSE_ALLOW_OTHER) &&
+ current->fsuid != fc->uid)
return -EACCES;
- } else if(!entry->d_time || time_before_eq(jiffies, entry->d_time))
+ } else if (!entry->d_time || time_before_eq(jiffies, entry->d_time))
return 0;
return fuse_do_getattr(inode);
{
struct fuse_conn *fc = INO_FC(inode);
- if(!(fc->flags & FUSE_ALLOW_OTHER) && current->fsuid != fc->uid)
+ if (!(fc->flags & FUSE_ALLOW_OTHER) && current->fsuid != fc->uid)
return -EACCES;
- else if(fc->flags & FUSE_DEFAULT_PERMISSIONS) {
+ else if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
int err = vfs_permission(inode, mask);
/* If permission is denied, try to refresh file
attributes. This is also needed, because the root
node will at first have no permissions */
- if(err == -EACCES) {
+ if (err == -EACCES) {
err = fuse_do_getattr(inode);
- if(!err)
+ if (!err)
err = vfs_permission(inode, mask);
}
static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
void *dstbuf, filldir_t filldir)
{
- while(nbytes >= FUSE_NAME_OFFSET) {
+ while (nbytes >= FUSE_NAME_OFFSET) {
struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
size_t reclen = FUSE_DIRENT_SIZE(dirent);
int over;
- if(dirent->namelen > NAME_MAX) {
+ if (dirent->namelen > NAME_MAX) {
printk("fuse_readdir: name too long\n");
return -EPROTO;
}
- if(reclen > nbytes)
+ if (reclen > nbytes)
break;
over = filldir(dstbuf, dirent->name, dirent->namelen,
file->f_pos, dirent->ino, dirent->type);
- if(over)
+ if (over)
break;
buf += reclen;
char *buf;
int ret;
- if(!cfile)
+ if (!cfile)
return -EISDIR;
buf = kmalloc(DIR_BUFSIZE, GFP_KERNEL);
- if(!buf)
+ if (!buf)
return -ENOMEM;
ret = kernel_read(cfile, file->f_pos, buf, DIR_BUFSIZE);
- if(ret < 0)
+ if (ret < 0)
printk("fuse_readdir: failed to read container file\n");
else
ret = parse_dirfile(buf, ret, file, dstbuf, filldir);
char *link;
link = (char *) __get_free_page(GFP_KERNEL);
- if(!link)
+ if (!link)
return ERR_PTR(-ENOMEM);
in.h.opcode = FUSE_READLINK;
out.args[0].size = PAGE_SIZE - 1;
out.args[0].value = link;
request_send(fc, &in, &out);
- if(out.h.error) {
+ if (out.h.error) {
free_page((unsigned long) link);
return ERR_PTR(out.h.error);
}
static void free_link(char *link)
{
- if(!IS_ERR(link))
+ if (!IS_ERR(link))
free_page((unsigned long) link);
}
out.args[0].size = sizeof(struct fuse_getdir_out);
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(!out.h.error) {
+ if (!out.h.error) {
struct file *cfile = outarg.file;
struct inode *inode;
- if(!cfile) {
+ if (!cfile) {
printk("fuse_getdir: invalid file\n");
return -EPROTO;
}
inode = cfile->f_dentry->d_inode;
- if(!S_ISREG(inode->i_mode)) {
+ if (!S_ISREG(inode->i_mode)) {
printk("fuse_getdir: not a regular file\n");
fput(cfile);
return -EPROTO;
{
struct file *cfile = file->private_data;
- if(cfile)
+ if (cfile)
fput(cfile);
return 0;
memset(fattr, 0, sizeof(*fattr));
- if(ivalid & ATTR_MODE)
+ if (ivalid & ATTR_MODE)
fvalid |= FATTR_MODE, fattr->mode = iattr->ia_mode;
- if(ivalid & ATTR_UID)
+ if (ivalid & ATTR_UID)
fvalid |= FATTR_UID, fattr->uid = iattr->ia_uid;
- if(ivalid & ATTR_GID)
+ if (ivalid & ATTR_GID)
fvalid |= FATTR_GID, fattr->gid = iattr->ia_gid;
- if(ivalid & ATTR_SIZE)
+ if (ivalid & ATTR_SIZE)
fvalid |= FATTR_SIZE, fattr->size = iattr->ia_size;
/* You can only _set_ these together (they may change by themselves) */
- if((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
+ if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
fvalid |= FATTR_ATIME | FATTR_MTIME;
#ifdef KERNEL_2_6
fattr->atime = iattr->ia_atime.tv_sec;
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(!out.h.error) {
- if(attr->ia_valid & ATTR_SIZE &&
- outarg.attr.size < i_size_read(inode))
+ if (!out.h.error) {
+ if (attr->ia_valid & ATTR_SIZE &&
+ outarg.attr.size < i_size_read(inode))
vmtruncate(inode, outarg.attr.size);
change_attributes(inode, &outarg.attr);
static int _fuse_dentry_revalidate(struct dentry *entry)
{
- if(!entry->d_inode)
+ if (!entry->d_inode)
return 0;
- else if(entry->d_time && time_after(jiffies, entry->d_time)) {
+ else if (entry->d_time && time_after(jiffies, entry->d_time)) {
struct inode *inode = entry->d_inode;
struct fuse_entry_out outarg;
int version;
ret = fuse_do_lookup(entry->d_parent->d_inode, entry, &outarg,
&version);
- if(ret)
+ if (ret)
return 0;
- if(outarg.ino != inode->i_ino)
+ if (outarg.ino != inode->i_ino)
return 0;
change_attributes(inode, &outarg.attr);
{
struct inode *inode = entry->d_inode;
int err = fuse_revalidate(entry);
- if(!err)
+ if (!err)
generic_fillattr(inode, stat);
return err;
struct fuse_out out = FUSE_OUT_INIT;
struct fuse_setxattr_in inarg;
+ if (size > FUSE_XATTR_SIZE_MAX)
+ return -E2BIG;
+
memset(&inarg, 0, sizeof(inarg));
inarg.size = size;
inarg.flags = flags;
in.args[1].value = name;
/* This is really two different operations rolled into one */
out.numargs = 1;
- if(size) {
+ if (size) {
out.argvar = 1;
out.args[0].size = size;
out.args[0].value = value;
out.args[0].value = &outarg;
}
request_send(fc, &in, &out);
- if(!out.h.error)
+ if (!out.h.error)
return size ? out.args[0].size : outarg.size;
else
return out.h.error;
in.args[0].value = &inarg;
/* This is really two different operations rolled into one */
out.numargs = 1;
- if(size) {
+ if (size) {
out.argvar = 1;
out.args[0].size = size;
out.args[0].value = list;
out.args[0].value = &outarg;
}
request_send(fc, &in, &out);
- if(!out.h.error)
+ if (!out.h.error)
return size ? out.args[0].size : outarg.size;
else
return out.h.error;
struct dentry *alias;
int err = fuse_lookup_iget(dir, entry, &inode);
- if(err)
+ if (err)
return ERR_PTR(err);
- if(inode && S_ISDIR(inode->i_mode) &&
- (alias = d_find_alias(inode)) != NULL) {
+ if (inode && S_ISDIR(inode->i_mode) &&
+ (alias = d_find_alias(inode)) != NULL) {
dput(alias);
iput(inode);
printk("fuse: cannot assign an existing directory\n");
#ifndef NO_MM
#define filemap_fdatawrite filemap_fdatasync
#else
-#define filemap_fdatawrite do {} while(0)
+#define filemap_fdatawrite do {} while (0)
#endif
#endif
int err;
err = generic_file_open(inode, file);
- if(err)
+ if (err)
return err;
/* If opening the root node, no lookup has been performed on
it, so the attributes must be refreshed */
- if(inode->i_ino == FUSE_ROOT_INO) {
+ if (inode->i_ino == FUSE_ROOT_INO) {
int err = fuse_do_getattr(inode);
- if(err)
+ if (err)
return err;
}
in.args[0].size = sizeof(inarg);
in.args[0].value = &inarg;
request_send(fc, &in, &out);
- if(!out.h.error && !(fc->flags & FUSE_KERNEL_CACHE)) {
+ if (!out.h.error && !(fc->flags & FUSE_KERNEL_CACHE)) {
#ifdef KERNEL_2_6
invalidate_inode_pages(inode->i_mapping);
#else
struct fuse_open_in *inarg = NULL;
unsigned int s = sizeof(struct fuse_in) + sizeof(struct fuse_open_in);
- if(file->f_mode & FMODE_WRITE)
+ if (file->f_mode & FMODE_WRITE)
filemap_fdatawrite(inode->i_mapping);
in = kmalloc(s, GFP_NOFS);
- if(!in)
+ if (!in)
return -ENOMEM;
memset(in, 0, s);
inarg = (struct fuse_open_in *) (in + 1);
in->numargs = 1;
in->args[0].size = sizeof(struct fuse_open_in);
in->args[0].value = inarg;
- if(!request_send_noreply(fc, in))
+ if (!request_send_noreply(fc, in))
return 0;
kfree(in);
out.args[0].value = buffer;
request_send(fc, &in, &out);
- if(!out.h.error) {
+ if (!out.h.error) {
size_t outsize = out.args[0].size;
- if(outsize < PAGE_CACHE_SIZE)
+ if (outsize < PAGE_CACHE_SIZE)
memset(buffer + outsize, 0, PAGE_CACHE_SIZE - outsize);
flush_dcache_page(page);
SetPageUptodate(page);
struct inode *inode = mapping->host;
struct fuse_conn *fc = INO_FC(inode);
- if(fc->flags & FUSE_LARGE_READ)
+ if (fc->flags & FUSE_LARGE_READ)
fuse_file_bigread(mapping, inode, *ppos, count);
return generic_file_read(filp, buf, count, ppos);
in.args[1].value = buffer + offset;
request_send(fc, &in, &out);
kunmap(page);
- if(out.h.error)
+ if (out.h.error)
SetPageError(page);
return out.h.error;
int count;
end_index = size >> PAGE_CACHE_SHIFT;
- if(page->index < end_index)
+ if (page->index < end_index)
count = PAGE_CACHE_SIZE;
else {
count = size & (PAGE_CACHE_SIZE - 1);
- if(page->index > end_index || count == 0)
+ if (page->index > end_index || count == 0)
return 0;
}
return count;
struct page *page = (struct page *) _page;
lock_page(page);
- if(out->h.error) {
+ if (out->h.error) {
SetPageError(page);
- if(out->h.error == -ENOSPC)
+ if (out->h.error == -ENOSPC)
set_bit(AS_ENOSPC, &page->mapping->flags);
else
set_bit(AS_EIO, &page->mapping->flags);
sizeof(struct fuse_write_in);
in = kmalloc(s, GFP_NOFS);
- if(!in)
+ if (!in)
return -ENOMEM;
memset(in, 0, s);
out = (struct fuse_out *)(in + 1);
in->args[1].size = count;
in->args[1].value = buffer + offset;
err = request_send_nonblock(fc, in, out, write_buffer_end, page);
- if(err) {
- if(err != -EWOULDBLOCK)
+ if (err) {
+ if (err != -EWOULDBLOCK)
SetPageError(page);
kunmap(page);
kfree(in);
unsigned count = get_write_count(inode, page);
err = -EINVAL;
- if(count) {
+ if (count) {
/* FIXME: check sync_mode, and wait for previous writes (or
signal userspace to do this) */
- if(wbc->nonblocking) {
+ if (wbc->nonblocking) {
err = write_buffer_nonblock(inode, page, 0, count);
- if(!err)
+ if (!err)
SetPageWriteback(page);
- else if(err == -EWOULDBLOCK) {
+ else if (err == -EWOULDBLOCK) {
__set_page_dirty_nobuffers(page);
err = 0;
}
struct inode *inode = page->mapping->host;
int count = get_write_count(inode, page);
err = -EINVAL;
- if(count)
+ if (count)
err = write_buffer(inode, page, 0, count);
unlock_page(page);
struct inode *inode = page->mapping->host;
err = write_buffer(inode, page, offset, to - offset);
- if(!err) {
+ if (!err) {
loff_t pos = (page->index << PAGE_CACHE_SHIFT) + to;
- if(pos > i_size_read(inode))
+ if (pos > i_size_read(inode))
i_size_write(inode, pos);
}
return err;
struct fuse_conn *fc = INO_FC(inode);
/* Readahead somehow defeats big reads on 2.6 (says Michael
Grigoriev) */
- if(fc->flags & FUSE_LARGE_READ)
+ if (fc->flags & FUSE_LARGE_READ)
inode->i_mapping->backing_dev_info->ra_pages = 0;
#endif
inode->i_fop = &fuse_file_operations;
struct fuse_forget_in *inarg = NULL;
unsigned int s = sizeof(struct fuse_in) + sizeof(struct fuse_forget_in);
- if(fc == NULL)
+ if (fc == NULL)
return;
in = kmalloc(s, GFP_NOFS);
- if(!in)
+ if (!in)
return;
memset(in, 0, s);
inarg = (struct fuse_forget_in *) (in + 1);
in->args[0].size = sizeof(struct fuse_forget_in);
in->args[0].value = inarg;
- if(!request_send_noreply(fc, in))
+ if (!request_send_noreply(fc, in))
return;
kfree(in);
out.args[0].size = sizeof(outarg);
out.args[0].value = &outarg;
request_send(fc, &in, &out);
- if(!out.h.error)
+ if (!out.h.error)
convert_fuse_statfs(buf, &outarg.st);
return out.h.error;
struct file *file;
struct inode *ino;
- if(d == NULL) {
+ if (d == NULL) {
printk("fuse_read_super: Bad mount data\n");
return NULL;
}
file = fget(d->fd);
ino = NULL;
- if(file)
+ if (file)
ino = file->f_dentry->d_inode;
- if(!ino || !proc_fuse_dev || proc_fuse_dev->low_ino != ino->i_ino) {
+ if (!ino || !proc_fuse_dev || proc_fuse_dev->low_ino != ino->i_ino) {
printk("fuse_read_super: Bad file: %i\n", d->fd);
goto out;
}
struct inode *inode;
struct dentry *entry;
- if(ino == 0)
+ if (ino == 0)
return ERR_PTR(-ESTALE);
inode = ilookup(sb, ino);
- if(!inode || inode->i_generation != generation)
+ if (!inode || inode->i_generation != generation)
return ERR_PTR(-ESTALE);
entry = d_alloc_anon(inode);
- if(!entry) {
+ if (!entry) {
iput(inode);
return ERR_PTR(-ENOMEM);
}
struct inode *root;
struct fuse_mount_data *d = data;
- if(!capable(CAP_SYS_ADMIN)) {
- if(d->flags & FUSE_ALLOW_OTHER)
+ if (!capable(CAP_SYS_ADMIN)) {
+ if (d->flags & FUSE_ALLOW_OTHER)
return -EPERM;
}
#endif
fc = get_conn(d);
- if(fc == NULL)
+ if (fc == NULL)
return -EINVAL;
spin_lock(&fuse_lock);
- if(fc->sb != NULL) {
+ if (fc->sb != NULL) {
printk("fuse_read_super: connection already mounted\n");
spin_unlock(&fuse_lock);
return -EINVAL;
SB_FC(sb) = fc;
root = get_root_inode(sb, d->rootmode);
- if(root == NULL) {
+ if (root == NULL) {
printk("fuse_read_super: failed to get root inode\n");
return -EINVAL;
}
sb->s_root = d_alloc_root(root);
- if(!sb->s_root)
+ if (!sb->s_root)
return -EINVAL;
return 0;
void *data, int silent)
{
int err = fuse_read_super(sb, data, silent);
- if(err)
+ if (err)
return NULL;
else
return sb;
int res;
res = register_filesystem(&fuse_fs_type);
- if(res)
+ if (res)
printk("fuse: failed to register filesystem\n");
return res;
/* Must be called with the fuse lock held */
void fuse_release_conn(struct fuse_conn *fc)
{
- if(fc->sb == NULL && fc->file == NULL) {
+ if (fc->sb == NULL && fc->file == NULL) {
kfree(fc);
}
}
FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
res = fuse_fs_init();
- if(res)
+ if (res)
goto err;
res = fuse_dev_init();
- if(res)
+ if (res)
goto err_fs_cleanup;
return 0;
projects / qemu-gpiodev / libfuse.git / commitdiff