blob: e6e23a2ad4b3a2557d9afd23d76c363b0237fe1d [file] [log] [blame]
Miklos Szeredid8a5ba42005-09-09 13:10:26 -07001/*
2 FUSE: Filesystem in Userspace
Miklos Szeredid7133112006-04-10 22:54:55 -07003 Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
Miklos Szeredid8a5ba42005-09-09 13:10:26 -07004
5 This program can be distributed under the terms of the GNU GPL.
6 See the file COPYING.
7*/
8
9#include "fuse_i.h"
10
11#include <linux/pagemap.h>
12#include <linux/slab.h>
13#include <linux/file.h>
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070014#include <linux/seq_file.h>
15#include <linux/init.h>
16#include <linux/module.h>
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070017#include <linux/parser.h>
18#include <linux/statfs.h>
Miklos Szeredi9c8ef562006-06-25 05:48:55 -070019#include <linux/random.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040020#include <linux/sched.h>
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070021
22MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
23MODULE_DESCRIPTION("Filesystem in Userspace");
24MODULE_LICENSE("GPL");
25
Christoph Lametere18b8902006-12-06 20:33:20 -080026static struct kmem_cache *fuse_inode_cachep;
Miklos Szeredibafa9652006-06-25 05:48:51 -070027struct list_head fuse_conn_list;
28DEFINE_MUTEX(fuse_mutex);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070029
30#define FUSE_SUPER_MAGIC 0x65735546
31
32struct fuse_mount_data {
33 int fd;
34 unsigned rootmode;
35 unsigned user_id;
Miklos Szeredi87729a52005-09-09 13:10:34 -070036 unsigned group_id;
Miklos Szeredi5a533682005-09-09 13:10:34 -070037 unsigned fd_present : 1;
38 unsigned rootmode_present : 1;
39 unsigned user_id_present : 1;
40 unsigned group_id_present : 1;
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -070041 unsigned flags;
Miklos Szeredidb50b962005-09-09 13:10:33 -070042 unsigned max_read;
Miklos Szeredid8091612006-12-06 20:35:48 -080043 unsigned blksize;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070044};
45
46static struct inode *fuse_alloc_inode(struct super_block *sb)
47{
48 struct inode *inode;
49 struct fuse_inode *fi;
50
Christoph Lametere94b1762006-12-06 20:33:17 -080051 inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070052 if (!inode)
53 return NULL;
54
55 fi = get_fuse_inode(inode);
Miklos Szeredi0a0898c2006-07-30 03:04:10 -070056 fi->i_time = 0;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070057 fi->nodeid = 0;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -070058 fi->nlookup = 0;
John Muirfbee36b2007-11-28 16:22:02 -080059 fi->attr_version = 0;
Miklos Szeredi93a8c3c2007-10-18 03:07:03 -070060 INIT_LIST_HEAD(&fi->write_files);
Miklos Szeredie5e55582005-09-09 13:10:28 -070061 fi->forget_req = fuse_request_alloc();
62 if (!fi->forget_req) {
63 kmem_cache_free(fuse_inode_cachep, inode);
64 return NULL;
65 }
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070066
67 return inode;
68}
69
70static void fuse_destroy_inode(struct inode *inode)
71{
Miklos Szeredie5e55582005-09-09 13:10:28 -070072 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi93a8c3c2007-10-18 03:07:03 -070073 BUG_ON(!list_empty(&fi->write_files));
Miklos Szeredie5e55582005-09-09 13:10:28 -070074 if (fi->forget_req)
75 fuse_request_free(fi->forget_req);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070076 kmem_cache_free(fuse_inode_cachep, inode);
77}
78
79static void fuse_read_inode(struct inode *inode)
80{
81 /* No op */
82}
83
Miklos Szeredie5e55582005-09-09 13:10:28 -070084void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
Miklos Szeredi9e6268d2005-09-09 13:10:29 -070085 unsigned long nodeid, u64 nlookup)
Miklos Szeredie5e55582005-09-09 13:10:28 -070086{
87 struct fuse_forget_in *inarg = &req->misc.forget_in;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -070088 inarg->nlookup = nlookup;
Miklos Szeredie5e55582005-09-09 13:10:28 -070089 req->in.h.opcode = FUSE_FORGET;
90 req->in.h.nodeid = nodeid;
91 req->in.numargs = 1;
92 req->in.args[0].size = sizeof(struct fuse_forget_in);
93 req->in.args[0].value = inarg;
94 request_send_noreply(fc, req);
95}
96
Miklos Szeredid8a5ba42005-09-09 13:10:26 -070097static void fuse_clear_inode(struct inode *inode)
98{
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -070099 if (inode->i_sb->s_flags & MS_ACTIVE) {
100 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700101 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700102 fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700103 fi->forget_req = NULL;
104 }
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700105}
106
Miklos Szeredi71421252006-06-25 05:48:52 -0700107static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
108{
109 if (*flags & MS_MANDLOCK)
110 return -EINVAL;
111
112 return 0;
113}
114
Miklos Szeredie00d2c22007-10-16 23:31:01 -0700115static void fuse_truncate(struct address_space *mapping, loff_t offset)
116{
117 /* See vmtruncate() */
118 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
119 truncate_inode_pages(mapping, offset);
120 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
121}
122
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700123
124void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
125 u64 attr_valid, u64 attr_version)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700126{
Miklos Szeredi9ffbb912006-10-17 00:10:06 -0700127 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szerediebc14c42007-10-16 23:31:03 -0700128 struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredie00d2c22007-10-16 23:31:01 -0700129 loff_t oldsize;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700130
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700131 spin_lock(&fc->lock);
132 if (attr_version != 0 && fi->attr_version > attr_version) {
133 spin_unlock(&fc->lock);
134 return;
135 }
136 fi->attr_version = ++fc->attr_version;
137 fi->i_time = attr_valid;
138
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700139 inode->i_ino = attr->ino;
Miklos Szerediebc14c42007-10-16 23:31:03 -0700140 inode->i_mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700141 inode->i_nlink = attr->nlink;
142 inode->i_uid = attr->uid;
143 inode->i_gid = attr->gid;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700144 inode->i_blocks = attr->blocks;
145 inode->i_atime.tv_sec = attr->atime;
146 inode->i_atime.tv_nsec = attr->atimensec;
147 inode->i_mtime.tv_sec = attr->mtime;
148 inode->i_mtime.tv_nsec = attr->mtimensec;
149 inode->i_ctime.tv_sec = attr->ctime;
150 inode->i_ctime.tv_nsec = attr->ctimensec;
Miklos Szeredie00d2c22007-10-16 23:31:01 -0700151
Miklos Szeredi0e9663e2007-10-18 03:07:05 -0700152 if (attr->blksize != 0)
153 inode->i_blkbits = ilog2(attr->blksize);
154 else
155 inode->i_blkbits = inode->i_sb->s_blocksize_bits;
156
Miklos Szerediebc14c42007-10-16 23:31:03 -0700157 /*
158 * Don't set the sticky bit in i_mode, unless we want the VFS
159 * to check permissions. This prevents failures due to the
160 * check in may_delete().
161 */
162 fi->orig_i_mode = inode->i_mode;
163 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
164 inode->i_mode &= ~S_ISVTX;
165
Miklos Szeredie00d2c22007-10-16 23:31:01 -0700166 oldsize = inode->i_size;
167 i_size_write(inode, attr->size);
168 spin_unlock(&fc->lock);
169
170 if (S_ISREG(inode->i_mode) && oldsize != attr->size) {
171 if (attr->size < oldsize)
172 fuse_truncate(inode->i_mapping, attr->size);
Miklos Szeredib1009972007-10-16 23:31:01 -0700173 invalidate_inode_pages2(inode->i_mapping);
Miklos Szeredie00d2c22007-10-16 23:31:01 -0700174 }
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700175}
176
177static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
178{
179 inode->i_mode = attr->mode & S_IFMT;
Miklos Szeredi9ffbb912006-10-17 00:10:06 -0700180 inode->i_size = attr->size;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700181 if (S_ISREG(inode->i_mode)) {
182 fuse_init_common(inode);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700183 fuse_init_file_inode(inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700184 } else if (S_ISDIR(inode->i_mode))
185 fuse_init_dir(inode);
186 else if (S_ISLNK(inode->i_mode))
187 fuse_init_symlink(inode);
188 else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
189 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
190 fuse_init_common(inode);
191 init_special_inode(inode, inode->i_mode,
192 new_decode_dev(attr->rdev));
Miklos Szeredi39ee0592006-01-06 00:19:43 -0800193 } else
194 BUG();
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700195}
196
197static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
198{
199 unsigned long nodeid = *(unsigned long *) _nodeidp;
200 if (get_node_id(inode) == nodeid)
201 return 1;
202 else
203 return 0;
204}
205
206static int fuse_inode_set(struct inode *inode, void *_nodeidp)
207{
208 unsigned long nodeid = *(unsigned long *) _nodeidp;
209 get_fuse_inode(inode)->nodeid = nodeid;
210 return 0;
211}
212
213struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700214 int generation, struct fuse_attr *attr,
215 u64 attr_valid, u64 attr_version)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700216{
217 struct inode *inode;
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700218 struct fuse_inode *fi;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700219 struct fuse_conn *fc = get_fuse_conn_super(sb);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700220
221 retry:
222 inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
223 if (!inode)
224 return NULL;
225
226 if ((inode->i_state & I_NEW)) {
Miklos Szeredib36c31b2005-09-09 13:10:38 -0700227 inode->i_flags |= S_NOATIME|S_NOCMTIME;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700228 inode->i_generation = generation;
229 inode->i_data.backing_dev_info = &fc->bdi;
230 fuse_init_inode(inode, attr);
231 unlock_new_inode(inode);
232 } else if ((inode->i_mode ^ attr->mode) & S_IFMT) {
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700233 /* Inode has changed type, any I/O on the old should fail */
234 make_bad_inode(inode);
235 iput(inode);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700236 goto retry;
237 }
238
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700239 fi = get_fuse_inode(inode);
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700240 spin_lock(&fc->lock);
Miklos Szeredi9e6268d2005-09-09 13:10:29 -0700241 fi->nlookup ++;
Miklos Szeredi8da5ff22006-10-17 00:10:08 -0700242 spin_unlock(&fc->lock);
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700243 fuse_change_attributes(inode, attr, attr_valid, attr_version);
244
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700245 return inode;
246}
247
Trond Myklebust8b512d92006-06-09 09:34:18 -0400248static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800249{
Trond Myklebust8b512d92006-06-09 09:34:18 -0400250 if (flags & MNT_FORCE)
251 fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800252}
253
Miklos Szeredi0ec7ca42006-12-06 20:35:52 -0800254static void fuse_send_destroy(struct fuse_conn *fc)
255{
256 struct fuse_req *req = fc->destroy_req;
257 if (req && fc->conn_init) {
258 fc->destroy_req = NULL;
259 req->in.h.opcode = FUSE_DESTROY;
260 req->force = 1;
261 request_send(fc, req);
262 fuse_put_request(fc, req);
263 }
264}
265
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700266static void fuse_put_super(struct super_block *sb)
267{
268 struct fuse_conn *fc = get_fuse_conn_super(sb);
269
Miklos Szeredi0ec7ca42006-12-06 20:35:52 -0800270 fuse_send_destroy(fc);
Miklos Szeredid7133112006-04-10 22:54:55 -0700271 spin_lock(&fc->lock);
Miklos Szeredi9ba7cbb2006-01-16 22:14:34 -0800272 fc->connected = 0;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700273 fc->blocked = 0;
Miklos Szeredid7133112006-04-10 22:54:55 -0700274 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700275 /* Flush all readers on this fs */
Jeff Dike385a17b2006-04-10 22:54:52 -0700276 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700277 wake_up_all(&fc->waitq);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700278 wake_up_all(&fc->blocked_waitq);
Miklos Szeredide5e3de2007-10-16 23:31:00 -0700279 wake_up_all(&fc->reserved_req_waitq);
Miklos Szeredibafa9652006-06-25 05:48:51 -0700280 mutex_lock(&fuse_mutex);
281 list_del(&fc->entry);
282 fuse_ctl_remove_conn(fc);
283 mutex_unlock(&fuse_mutex);
284 fuse_conn_put(fc);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700285}
286
Miklos Szeredie5e55582005-09-09 13:10:28 -0700287static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
288{
289 stbuf->f_type = FUSE_SUPER_MAGIC;
290 stbuf->f_bsize = attr->bsize;
Miklos Szeredide5f1202006-01-06 00:19:37 -0800291 stbuf->f_frsize = attr->frsize;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700292 stbuf->f_blocks = attr->blocks;
293 stbuf->f_bfree = attr->bfree;
294 stbuf->f_bavail = attr->bavail;
295 stbuf->f_files = attr->files;
296 stbuf->f_ffree = attr->ffree;
297 stbuf->f_namelen = attr->namelen;
298 /* fsid is left zero */
299}
300
David Howells726c3342006-06-23 02:02:58 -0700301static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
Miklos Szeredie5e55582005-09-09 13:10:28 -0700302{
David Howells726c3342006-06-23 02:02:58 -0700303 struct super_block *sb = dentry->d_sb;
Miklos Szeredie5e55582005-09-09 13:10:28 -0700304 struct fuse_conn *fc = get_fuse_conn_super(sb);
305 struct fuse_req *req;
306 struct fuse_statfs_out outarg;
307 int err;
308
Miklos Szeredie57ac682007-10-18 03:06:58 -0700309 if (!fuse_allow_task(fc, current)) {
310 buf->f_type = FUSE_SUPER_MAGIC;
311 return 0;
312 }
313
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700314 req = fuse_get_req(fc);
315 if (IS_ERR(req))
316 return PTR_ERR(req);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700317
Miklos Szeredide5f1202006-01-06 00:19:37 -0800318 memset(&outarg, 0, sizeof(outarg));
Miklos Szeredie5e55582005-09-09 13:10:28 -0700319 req->in.numargs = 0;
320 req->in.h.opcode = FUSE_STATFS;
Miklos Szeredi5b35e8e2006-09-29 01:59:34 -0700321 req->in.h.nodeid = get_node_id(dentry->d_inode);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700322 req->out.numargs = 1;
Miklos Szeredide5f1202006-01-06 00:19:37 -0800323 req->out.args[0].size =
324 fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
Miklos Szeredie5e55582005-09-09 13:10:28 -0700325 req->out.args[0].value = &outarg;
326 request_send(fc, req);
327 err = req->out.h.error;
328 if (!err)
329 convert_fuse_statfs(buf, &outarg.st);
330 fuse_put_request(fc, req);
331 return err;
332}
333
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700334enum {
335 OPT_FD,
336 OPT_ROOTMODE,
337 OPT_USER_ID,
Miklos Szeredi87729a52005-09-09 13:10:34 -0700338 OPT_GROUP_ID,
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700339 OPT_DEFAULT_PERMISSIONS,
340 OPT_ALLOW_OTHER,
Miklos Szeredidb50b962005-09-09 13:10:33 -0700341 OPT_MAX_READ,
Miklos Szeredid8091612006-12-06 20:35:48 -0800342 OPT_BLKSIZE,
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700343 OPT_ERR
344};
345
346static match_table_t tokens = {
347 {OPT_FD, "fd=%u"},
348 {OPT_ROOTMODE, "rootmode=%o"},
349 {OPT_USER_ID, "user_id=%u"},
Miklos Szeredi87729a52005-09-09 13:10:34 -0700350 {OPT_GROUP_ID, "group_id=%u"},
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700351 {OPT_DEFAULT_PERMISSIONS, "default_permissions"},
352 {OPT_ALLOW_OTHER, "allow_other"},
Miklos Szeredidb50b962005-09-09 13:10:33 -0700353 {OPT_MAX_READ, "max_read=%u"},
Miklos Szeredid8091612006-12-06 20:35:48 -0800354 {OPT_BLKSIZE, "blksize=%u"},
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700355 {OPT_ERR, NULL}
356};
357
Miklos Szeredid8091612006-12-06 20:35:48 -0800358static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700359{
360 char *p;
361 memset(d, 0, sizeof(struct fuse_mount_data));
Miklos Szeredidb50b962005-09-09 13:10:33 -0700362 d->max_read = ~0;
Miklos Szeredid8091612006-12-06 20:35:48 -0800363 d->blksize = 512;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700364
365 while ((p = strsep(&opt, ",")) != NULL) {
366 int token;
367 int value;
368 substring_t args[MAX_OPT_ARGS];
369 if (!*p)
370 continue;
371
372 token = match_token(p, tokens, args);
373 switch (token) {
374 case OPT_FD:
375 if (match_int(&args[0], &value))
376 return 0;
377 d->fd = value;
Miklos Szeredi5a533682005-09-09 13:10:34 -0700378 d->fd_present = 1;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700379 break;
380
381 case OPT_ROOTMODE:
382 if (match_octal(&args[0], &value))
383 return 0;
Timo Savolaa5bfffac2007-04-08 16:04:00 -0700384 if (!fuse_valid_type(value))
385 return 0;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700386 d->rootmode = value;
Miklos Szeredi5a533682005-09-09 13:10:34 -0700387 d->rootmode_present = 1;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700388 break;
389
390 case OPT_USER_ID:
391 if (match_int(&args[0], &value))
392 return 0;
393 d->user_id = value;
Miklos Szeredi5a533682005-09-09 13:10:34 -0700394 d->user_id_present = 1;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700395 break;
396
Miklos Szeredi87729a52005-09-09 13:10:34 -0700397 case OPT_GROUP_ID:
398 if (match_int(&args[0], &value))
399 return 0;
400 d->group_id = value;
Miklos Szeredi5a533682005-09-09 13:10:34 -0700401 d->group_id_present = 1;
Miklos Szeredi87729a52005-09-09 13:10:34 -0700402 break;
403
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700404 case OPT_DEFAULT_PERMISSIONS:
405 d->flags |= FUSE_DEFAULT_PERMISSIONS;
406 break;
407
408 case OPT_ALLOW_OTHER:
409 d->flags |= FUSE_ALLOW_OTHER;
410 break;
411
Miklos Szeredidb50b962005-09-09 13:10:33 -0700412 case OPT_MAX_READ:
413 if (match_int(&args[0], &value))
414 return 0;
415 d->max_read = value;
416 break;
417
Miklos Szeredid8091612006-12-06 20:35:48 -0800418 case OPT_BLKSIZE:
419 if (!is_bdev || match_int(&args[0], &value))
420 return 0;
421 d->blksize = value;
422 break;
423
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700424 default:
425 return 0;
426 }
427 }
Miklos Szeredi5a533682005-09-09 13:10:34 -0700428
429 if (!d->fd_present || !d->rootmode_present ||
430 !d->user_id_present || !d->group_id_present)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700431 return 0;
432
433 return 1;
434}
435
436static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)
437{
438 struct fuse_conn *fc = get_fuse_conn_super(mnt->mnt_sb);
439
440 seq_printf(m, ",user_id=%u", fc->user_id);
Miklos Szeredi87729a52005-09-09 13:10:34 -0700441 seq_printf(m, ",group_id=%u", fc->group_id);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700442 if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
443 seq_puts(m, ",default_permissions");
444 if (fc->flags & FUSE_ALLOW_OTHER)
445 seq_puts(m, ",allow_other");
Miklos Szeredidb50b962005-09-09 13:10:33 -0700446 if (fc->max_read != ~0)
447 seq_printf(m, ",max_read=%u", fc->max_read);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700448 return 0;
449}
450
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700451static struct fuse_conn *new_conn(void)
452{
453 struct fuse_conn *fc;
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -0700454 int err;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700455
Miklos Szeredi6383bda2006-01-16 22:14:29 -0800456 fc = kzalloc(sizeof(*fc), GFP_KERNEL);
Miklos Szeredif543f252006-01-16 22:14:35 -0800457 if (fc) {
Miklos Szeredid7133112006-04-10 22:54:55 -0700458 spin_lock_init(&fc->lock);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700459 mutex_init(&fc->inst_mutex);
Miklos Szeredibafa9652006-06-25 05:48:51 -0700460 atomic_set(&fc->count, 1);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700461 init_waitqueue_head(&fc->waitq);
Miklos Szeredi08a53cd2006-04-10 22:54:59 -0700462 init_waitqueue_head(&fc->blocked_waitq);
Miklos Szeredide5e3de2007-10-16 23:31:00 -0700463 init_waitqueue_head(&fc->reserved_req_waitq);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700464 INIT_LIST_HEAD(&fc->pending);
465 INIT_LIST_HEAD(&fc->processing);
Miklos Szeredid77a1d52006-01-16 22:14:31 -0800466 INIT_LIST_HEAD(&fc->io);
Miklos Szeredia4d27e72006-06-25 05:48:54 -0700467 INIT_LIST_HEAD(&fc->interrupts);
Miklos Szeredi095da6c2006-01-16 22:14:52 -0800468 atomic_set(&fc->num_waiting, 0);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700469 fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
470 fc->bdi.unplug_io_fn = default_unplug_io_fn;
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -0700471 err = bdi_init(&fc->bdi);
472 if (err) {
473 kfree(fc);
474 fc = NULL;
475 goto out;
476 }
Miklos Szeredi334f4852005-09-09 13:10:27 -0700477 fc->reqctr = 0;
Miklos Szeredi08a53cd2006-04-10 22:54:59 -0700478 fc->blocked = 1;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700479 fc->attr_version = 1;
Miklos Szeredi9c8ef562006-06-25 05:48:55 -0700480 get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700481 }
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -0700482out:
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700483 return fc;
484}
485
Miklos Szeredibafa9652006-06-25 05:48:51 -0700486void fuse_conn_put(struct fuse_conn *fc)
487{
Miklos Szeredid2a85162006-10-17 00:10:11 -0700488 if (atomic_dec_and_test(&fc->count)) {
Miklos Szeredi0ec7ca42006-12-06 20:35:52 -0800489 if (fc->destroy_req)
490 fuse_request_free(fc->destroy_req);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700491 mutex_destroy(&fc->inst_mutex);
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -0700492 bdi_destroy(&fc->bdi);
Miklos Szeredibafa9652006-06-25 05:48:51 -0700493 kfree(fc);
Miklos Szeredid2a85162006-10-17 00:10:11 -0700494 }
Miklos Szeredibafa9652006-06-25 05:48:51 -0700495}
496
497struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
498{
499 atomic_inc(&fc->count);
500 return fc;
501}
502
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700503static struct inode *get_root_inode(struct super_block *sb, unsigned mode)
504{
505 struct fuse_attr attr;
506 memset(&attr, 0, sizeof(attr));
507
508 attr.mode = mode;
509 attr.ino = FUSE_ROOT_ID;
Miklos Szeredi074406f2007-10-16 23:31:02 -0700510 attr.nlink = 1;
Miklos Szeredi1fb69e72007-10-18 03:06:58 -0700511 return fuse_iget(sb, 1, 0, &attr, 0, 0);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700512}
513
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800514static const struct super_operations fuse_super_operations = {
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700515 .alloc_inode = fuse_alloc_inode,
516 .destroy_inode = fuse_destroy_inode,
517 .read_inode = fuse_read_inode,
518 .clear_inode = fuse_clear_inode,
Miklos Szerediead5f0b2007-05-23 13:57:54 -0700519 .drop_inode = generic_delete_inode,
Miklos Szeredi71421252006-06-25 05:48:52 -0700520 .remount_fs = fuse_remount_fs,
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700521 .put_super = fuse_put_super,
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800522 .umount_begin = fuse_umount_begin,
Miklos Szeredie5e55582005-09-09 13:10:28 -0700523 .statfs = fuse_statfs,
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700524 .show_options = fuse_show_options,
525};
526
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800527static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
528{
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800529 struct fuse_init_out *arg = &req->misc.init_out;
530
531 if (req->out.h.error || arg->major != FUSE_KERNEL_VERSION)
532 fc->conn_error = 1;
533 else {
Miklos Szeredi9cd68452006-02-01 03:04:40 -0800534 unsigned long ra_pages;
535
536 if (arg->minor >= 6) {
537 ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
538 if (arg->flags & FUSE_ASYNC_READ)
539 fc->async_read = 1;
Miklos Szeredi71421252006-06-25 05:48:52 -0700540 if (!(arg->flags & FUSE_POSIX_LOCKS))
541 fc->no_lock = 1;
Miklos Szeredi6ff958e2007-10-18 03:07:02 -0700542 if (arg->flags & FUSE_ATOMIC_O_TRUNC)
543 fc->atomic_o_trunc = 1;
Miklos Szeredi71421252006-06-25 05:48:52 -0700544 } else {
Miklos Szeredi9cd68452006-02-01 03:04:40 -0800545 ra_pages = fc->max_read / PAGE_CACHE_SIZE;
Miklos Szeredi71421252006-06-25 05:48:52 -0700546 fc->no_lock = 1;
547 }
Miklos Szeredi9cd68452006-02-01 03:04:40 -0800548
549 fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800550 fc->minor = arg->minor;
551 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
Miklos Szeredi0ec7ca42006-12-06 20:35:52 -0800552 fc->conn_init = 1;
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800553 }
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800554 fuse_put_request(fc, req);
Miklos Szeredi08a53cd2006-04-10 22:54:59 -0700555 fc->blocked = 0;
556 wake_up_all(&fc->blocked_waitq);
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800557}
558
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700559static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800560{
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800561 struct fuse_init_in *arg = &req->misc.init_in;
Miklos Szeredi095da6c2006-01-16 22:14:52 -0800562
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800563 arg->major = FUSE_KERNEL_VERSION;
564 arg->minor = FUSE_KERNEL_MINOR_VERSION;
Miklos Szeredi9cd68452006-02-01 03:04:40 -0800565 arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
Miklos Szeredid0186b22007-11-28 16:22:01 -0800566 arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC;
Miklos Szeredi9b9a0462006-01-16 22:14:44 -0800567 req->in.h.opcode = FUSE_INIT;
568 req->in.numargs = 1;
569 req->in.args[0].size = sizeof(*arg);
570 req->in.args[0].value = arg;
571 req->out.numargs = 1;
572 /* Variable length arguement used for backward compatibility
573 with interface version < 7.5. Rest of init_out is zeroed
574 by do_get_request(), so a short reply is not a problem */
575 req->out.argvar = 1;
576 req->out.args[0].size = sizeof(struct fuse_init_out);
577 req->out.args[0].value = &req->misc.init_out;
578 req->end = process_init_reply;
579 request_send_background(fc, req);
580}
581
Miklos Szeredibafa9652006-06-25 05:48:51 -0700582static u64 conn_id(void)
Miklos Szeredif543f252006-01-16 22:14:35 -0800583{
Miklos Szeredibafa9652006-06-25 05:48:51 -0700584 static u64 ctr = 1;
Miklos Szeredi0720b312006-04-10 22:54:55 -0700585 return ctr++;
Miklos Szeredif543f252006-01-16 22:14:35 -0800586}
587
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700588static int fuse_fill_super(struct super_block *sb, void *data, int silent)
589{
590 struct fuse_conn *fc;
591 struct inode *root;
592 struct fuse_mount_data d;
593 struct file *file;
Miklos Szeredif543f252006-01-16 22:14:35 -0800594 struct dentry *root_dentry;
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700595 struct fuse_req *init_req;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700596 int err;
Miklos Szeredid8091612006-12-06 20:35:48 -0800597 int is_bdev = sb->s_bdev != NULL;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700598
Miklos Szeredi71421252006-06-25 05:48:52 -0700599 if (sb->s_flags & MS_MANDLOCK)
600 return -EINVAL;
601
Miklos Szeredid8091612006-12-06 20:35:48 -0800602 if (!parse_fuse_opt((char *) data, &d, is_bdev))
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700603 return -EINVAL;
604
Miklos Szeredid8091612006-12-06 20:35:48 -0800605 if (is_bdev) {
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800606#ifdef CONFIG_BLOCK
Miklos Szeredid8091612006-12-06 20:35:48 -0800607 if (!sb_set_blocksize(sb, d.blksize))
608 return -EINVAL;
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800609#endif
Miklos Szeredid8091612006-12-06 20:35:48 -0800610 } else {
611 sb->s_blocksize = PAGE_CACHE_SIZE;
612 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
613 }
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700614 sb->s_magic = FUSE_SUPER_MAGIC;
615 sb->s_op = &fuse_super_operations;
616 sb->s_maxbytes = MAX_LFS_FILESIZE;
617
618 file = fget(d.fd);
619 if (!file)
620 return -EINVAL;
621
Miklos Szeredi0720b312006-04-10 22:54:55 -0700622 if (file->f_op != &fuse_dev_operations)
623 return -EINVAL;
624
Miklos Szeredi0720b312006-04-10 22:54:55 -0700625 fc = new_conn();
626 if (!fc)
627 return -ENOMEM;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700628
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700629 fc->flags = d.flags;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700630 fc->user_id = d.user_id;
Miklos Szeredi87729a52005-09-09 13:10:34 -0700631 fc->group_id = d.group_id;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700632 fc->max_read = d.max_read;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700633
Miklos Szeredif543f252006-01-16 22:14:35 -0800634 /* Used by get_root_inode() */
635 sb->s_fs_info = fc;
636
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700637 err = -ENOMEM;
638 root = get_root_inode(sb, d.rootmode);
Miklos Szeredif543f252006-01-16 22:14:35 -0800639 if (!root)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700640 goto err;
641
Miklos Szeredif543f252006-01-16 22:14:35 -0800642 root_dentry = d_alloc_root(root);
643 if (!root_dentry) {
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700644 iput(root);
645 goto err;
646 }
Miklos Szeredif543f252006-01-16 22:14:35 -0800647
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700648 init_req = fuse_request_alloc();
649 if (!init_req)
650 goto err_put_root;
651
Miklos Szeredi0ec7ca42006-12-06 20:35:52 -0800652 if (is_bdev) {
653 fc->destroy_req = fuse_request_alloc();
654 if (!fc->destroy_req)
655 goto err_put_root;
656 }
657
Miklos Szeredibafa9652006-06-25 05:48:51 -0700658 mutex_lock(&fuse_mutex);
Miklos Szeredi8aa09a52006-04-26 10:49:16 +0200659 err = -EINVAL;
660 if (file->private_data)
Miklos Szeredibafa9652006-06-25 05:48:51 -0700661 goto err_unlock;
Miklos Szeredi8aa09a52006-04-26 10:49:16 +0200662
Miklos Szeredibafa9652006-06-25 05:48:51 -0700663 fc->id = conn_id();
664 err = fuse_ctl_add_conn(fc);
665 if (err)
666 goto err_unlock;
667
668 list_add_tail(&fc->entry, &fuse_conn_list);
Miklos Szeredif543f252006-01-16 22:14:35 -0800669 sb->s_root = root_dentry;
Miklos Szeredif543f252006-01-16 22:14:35 -0800670 fc->connected = 1;
Miklos Szeredibafa9652006-06-25 05:48:51 -0700671 file->private_data = fuse_conn_get(fc);
672 mutex_unlock(&fuse_mutex);
Miklos Szeredi0720b312006-04-10 22:54:55 -0700673 /*
674 * atomic_dec_and_test() in fput() provides the necessary
675 * memory barrier for file->private_data to be visible on all
676 * CPUs after this
677 */
678 fput(file);
Miklos Szeredif543f252006-01-16 22:14:35 -0800679
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700680 fuse_send_init(fc, init_req);
Miklos Szeredif543f252006-01-16 22:14:35 -0800681
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700682 return 0;
683
Miklos Szeredibafa9652006-06-25 05:48:51 -0700684 err_unlock:
685 mutex_unlock(&fuse_mutex);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700686 fuse_request_free(init_req);
Miklos Szeredif543f252006-01-16 22:14:35 -0800687 err_put_root:
688 dput(root_dentry);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700689 err:
Miklos Szeredi0720b312006-04-10 22:54:55 -0700690 fput(file);
Miklos Szeredibafa9652006-06-25 05:48:51 -0700691 fuse_conn_put(fc);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700692 return err;
693}
694
David Howells454e2392006-06-23 02:02:57 -0700695static int fuse_get_sb(struct file_system_type *fs_type,
696 int flags, const char *dev_name,
697 void *raw_data, struct vfsmount *mnt)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700698{
David Howells454e2392006-06-23 02:02:57 -0700699 return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700700}
701
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800702static struct file_system_type fuse_fs_type = {
703 .owner = THIS_MODULE,
704 .name = "fuse",
Miklos Szeredi79c0b2d2007-05-08 00:25:43 -0700705 .fs_flags = FS_HAS_SUBTYPE,
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800706 .get_sb = fuse_get_sb,
707 .kill_sb = kill_anon_super,
708};
709
710#ifdef CONFIG_BLOCK
Miklos Szeredid6392f82006-12-06 20:35:44 -0800711static int fuse_get_sb_blk(struct file_system_type *fs_type,
712 int flags, const char *dev_name,
713 void *raw_data, struct vfsmount *mnt)
714{
715 return get_sb_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super,
716 mnt);
717}
718
Miklos Szeredid6392f82006-12-06 20:35:44 -0800719static struct file_system_type fuseblk_fs_type = {
720 .owner = THIS_MODULE,
721 .name = "fuseblk",
722 .get_sb = fuse_get_sb_blk,
723 .kill_sb = kill_block_super,
Alexey Dobriyanedad01e2007-06-16 10:16:05 -0700724 .fs_flags = FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
Miklos Szeredid6392f82006-12-06 20:35:44 -0800725};
726
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800727static inline int register_fuseblk(void)
728{
729 return register_filesystem(&fuseblk_fs_type);
730}
731
732static inline void unregister_fuseblk(void)
733{
734 unregister_filesystem(&fuseblk_fs_type);
735}
736#else
737static inline int register_fuseblk(void)
738{
739 return 0;
740}
741
742static inline void unregister_fuseblk(void)
743{
744}
745#endif
746
Christoph Lameter4ba9b9d2007-10-16 23:25:51 -0700747static void fuse_inode_init_once(struct kmem_cache *cachep, void *foo)
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700748{
749 struct inode * inode = foo;
750
Christoph Lametera35afb82007-05-16 22:10:57 -0700751 inode_init_once(inode);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700752}
753
754static int __init fuse_fs_init(void)
755{
756 int err;
757
758 err = register_filesystem(&fuse_fs_type);
759 if (err)
Miklos Szeredid6392f82006-12-06 20:35:44 -0800760 goto out;
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700761
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800762 err = register_fuseblk();
Miklos Szeredid6392f82006-12-06 20:35:44 -0800763 if (err)
764 goto out_unreg;
765
766 fuse_inode_cachep = kmem_cache_create("fuse_inode",
767 sizeof(struct fuse_inode),
768 0, SLAB_HWCACHE_ALIGN,
Paul Mundt20c2df82007-07-20 10:11:58 +0900769 fuse_inode_init_once);
Miklos Szeredid6392f82006-12-06 20:35:44 -0800770 err = -ENOMEM;
771 if (!fuse_inode_cachep)
772 goto out_unreg2;
773
774 return 0;
775
776 out_unreg2:
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800777 unregister_fuseblk();
Miklos Szeredid6392f82006-12-06 20:35:44 -0800778 out_unreg:
779 unregister_filesystem(&fuse_fs_type);
780 out:
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700781 return err;
782}
783
784static void fuse_fs_cleanup(void)
785{
786 unregister_filesystem(&fuse_fs_type);
Miklos Szeredi875d95e2006-12-06 20:35:54 -0800787 unregister_fuseblk();
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700788 kmem_cache_destroy(fuse_inode_cachep);
789}
790
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100791static struct kobject *fuse_kobj;
792static struct kobject *connections_kobj;
793
Miklos Szeredif543f252006-01-16 22:14:35 -0800794static int fuse_sysfs_init(void)
795{
796 int err;
797
Greg Kroah-Hartman00d26662007-10-29 14:17:23 -0600798 fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100799 if (!fuse_kobj) {
800 err = -ENOMEM;
Miklos Szeredif543f252006-01-16 22:14:35 -0800801 goto out_err;
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100802 }
Miklos Szeredif543f252006-01-16 22:14:35 -0800803
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100804 connections_kobj = kobject_create_and_add("connections", fuse_kobj);
805 if (!connections_kobj) {
806 err = -ENOMEM;
Miklos Szeredif543f252006-01-16 22:14:35 -0800807 goto out_fuse_unregister;
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100808 }
Miklos Szeredif543f252006-01-16 22:14:35 -0800809
810 return 0;
811
812 out_fuse_unregister:
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100813 kobject_unregister(fuse_kobj);
Miklos Szeredif543f252006-01-16 22:14:35 -0800814 out_err:
815 return err;
816}
817
818static void fuse_sysfs_cleanup(void)
819{
Greg Kroah-Hartman5c89e172007-10-29 20:13:17 +0100820 kobject_unregister(connections_kobj);
821 kobject_unregister(fuse_kobj);
Miklos Szeredif543f252006-01-16 22:14:35 -0800822}
823
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700824static int __init fuse_init(void)
825{
826 int res;
827
828 printk("fuse init (API version %i.%i)\n",
829 FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
830
Miklos Szeredibafa9652006-06-25 05:48:51 -0700831 INIT_LIST_HEAD(&fuse_conn_list);
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700832 res = fuse_fs_init();
833 if (res)
834 goto err;
835
Miklos Szeredi334f4852005-09-09 13:10:27 -0700836 res = fuse_dev_init();
837 if (res)
838 goto err_fs_cleanup;
839
Miklos Szeredif543f252006-01-16 22:14:35 -0800840 res = fuse_sysfs_init();
841 if (res)
842 goto err_dev_cleanup;
843
Miklos Szeredibafa9652006-06-25 05:48:51 -0700844 res = fuse_ctl_init();
845 if (res)
846 goto err_sysfs_cleanup;
847
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700848 return 0;
849
Miklos Szeredibafa9652006-06-25 05:48:51 -0700850 err_sysfs_cleanup:
851 fuse_sysfs_cleanup();
Miklos Szeredif543f252006-01-16 22:14:35 -0800852 err_dev_cleanup:
853 fuse_dev_cleanup();
Miklos Szeredi334f4852005-09-09 13:10:27 -0700854 err_fs_cleanup:
855 fuse_fs_cleanup();
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700856 err:
857 return res;
858}
859
860static void __exit fuse_exit(void)
861{
862 printk(KERN_DEBUG "fuse exit\n");
863
Miklos Szeredibafa9652006-06-25 05:48:51 -0700864 fuse_ctl_cleanup();
Miklos Szeredif543f252006-01-16 22:14:35 -0800865 fuse_sysfs_cleanup();
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700866 fuse_fs_cleanup();
Miklos Szeredi334f4852005-09-09 13:10:27 -0700867 fuse_dev_cleanup();
Miklos Szeredid8a5ba42005-09-09 13:10:26 -0700868}
869
870module_init(fuse_init);
871module_exit(fuse_exit);