blob: 6b5f74cb7b542441b9e1b9f7a27788982d238838 [file] [log] [blame]
Miklos Szeredi334f4852005-09-09 13:10:27 -07001/*
2 FUSE: Filesystem in Userspace
Miklos Szeredid7133112006-04-10 22:54:55 -07003 Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
Miklos Szeredi334f4852005-09-09 13:10:27 -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/init.h>
12#include <linux/module.h>
13#include <linux/poll.h>
14#include <linux/uio.h>
15#include <linux/miscdevice.h>
16#include <linux/pagemap.h>
17#include <linux/file.h>
18#include <linux/slab.h>
19
20MODULE_ALIAS_MISCDEV(FUSE_MINOR);
21
22static kmem_cache_t *fuse_req_cachep;
23
Miklos Szeredi8bfc0162006-01-16 22:14:28 -080024static struct fuse_conn *fuse_get_conn(struct file *file)
Miklos Szeredi334f4852005-09-09 13:10:27 -070025{
Miklos Szeredi0720b312006-04-10 22:54:55 -070026 /*
27 * Lockless access is OK, because file->private data is set
28 * once during mount and is valid until the file is released.
29 */
30 return file->private_data;
Miklos Szeredi334f4852005-09-09 13:10:27 -070031}
32
Miklos Szeredi8bfc0162006-01-16 22:14:28 -080033static void fuse_request_init(struct fuse_req *req)
Miklos Szeredi334f4852005-09-09 13:10:27 -070034{
35 memset(req, 0, sizeof(*req));
36 INIT_LIST_HEAD(&req->list);
37 init_waitqueue_head(&req->waitq);
38 atomic_set(&req->count, 1);
39}
40
41struct fuse_req *fuse_request_alloc(void)
42{
43 struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, SLAB_KERNEL);
44 if (req)
45 fuse_request_init(req);
46 return req;
47}
48
49void fuse_request_free(struct fuse_req *req)
50{
51 kmem_cache_free(fuse_req_cachep, req);
52}
53
Miklos Szeredi8bfc0162006-01-16 22:14:28 -080054static void block_sigs(sigset_t *oldset)
Miklos Szeredi334f4852005-09-09 13:10:27 -070055{
56 sigset_t mask;
57
58 siginitsetinv(&mask, sigmask(SIGKILL));
59 sigprocmask(SIG_BLOCK, &mask, oldset);
60}
61
Miklos Szeredi8bfc0162006-01-16 22:14:28 -080062static void restore_sigs(sigset_t *oldset)
Miklos Szeredi334f4852005-09-09 13:10:27 -070063{
64 sigprocmask(SIG_SETMASK, oldset, NULL);
65}
66
Miklos Szeredi334f4852005-09-09 13:10:27 -070067static void __fuse_get_request(struct fuse_req *req)
68{
69 atomic_inc(&req->count);
70}
71
72/* Must be called with > 1 refcount */
73static void __fuse_put_request(struct fuse_req *req)
74{
75 BUG_ON(atomic_read(&req->count) < 2);
76 atomic_dec(&req->count);
77}
78
Miklos Szeredi33649c92006-06-25 05:48:52 -070079static void fuse_req_init_context(struct fuse_req *req)
80{
81 req->in.h.uid = current->fsuid;
82 req->in.h.gid = current->fsgid;
83 req->in.h.pid = current->pid;
84}
85
Miklos Szeredice1d5a42006-04-10 22:54:58 -070086struct fuse_req *fuse_get_req(struct fuse_conn *fc)
Miklos Szeredi334f4852005-09-09 13:10:27 -070087{
Miklos Szeredi08a53cd2006-04-10 22:54:59 -070088 struct fuse_req *req;
89 sigset_t oldset;
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +020090 int intr;
Miklos Szeredi08a53cd2006-04-10 22:54:59 -070091 int err;
92
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +020093 atomic_inc(&fc->num_waiting);
Miklos Szeredi08a53cd2006-04-10 22:54:59 -070094 block_sigs(&oldset);
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +020095 intr = wait_event_interruptible(fc->blocked_waitq, !fc->blocked);
Miklos Szeredi08a53cd2006-04-10 22:54:59 -070096 restore_sigs(&oldset);
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +020097 err = -EINTR;
98 if (intr)
99 goto out;
Miklos Szeredi08a53cd2006-04-10 22:54:59 -0700100
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700101 err = -ENOTCONN;
102 if (!fc->connected)
103 goto out;
104
Miklos Szeredi08a53cd2006-04-10 22:54:59 -0700105 req = fuse_request_alloc();
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +0200106 err = -ENOMEM;
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700107 if (!req)
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +0200108 goto out;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700109
Miklos Szeredi33649c92006-06-25 05:48:52 -0700110 fuse_req_init_context(req);
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +0200111 req->waiting = 1;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700112 return req;
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +0200113
114 out:
115 atomic_dec(&fc->num_waiting);
116 return ERR_PTR(err);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700117}
118
Miklos Szeredi33649c92006-06-25 05:48:52 -0700119/*
120 * Return request in fuse_file->reserved_req. However that may
121 * currently be in use. If that is the case, wait for it to become
122 * available.
123 */
124static struct fuse_req *get_reserved_req(struct fuse_conn *fc,
125 struct file *file)
126{
127 struct fuse_req *req = NULL;
128 struct fuse_file *ff = file->private_data;
129
130 do {
131 wait_event(fc->blocked_waitq, ff->reserved_req);
132 spin_lock(&fc->lock);
133 if (ff->reserved_req) {
134 req = ff->reserved_req;
135 ff->reserved_req = NULL;
136 get_file(file);
137 req->stolen_file = file;
138 }
139 spin_unlock(&fc->lock);
140 } while (!req);
141
142 return req;
143}
144
145/*
146 * Put stolen request back into fuse_file->reserved_req
147 */
148static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req)
149{
150 struct file *file = req->stolen_file;
151 struct fuse_file *ff = file->private_data;
152
153 spin_lock(&fc->lock);
154 fuse_request_init(req);
155 BUG_ON(ff->reserved_req);
156 ff->reserved_req = req;
157 wake_up(&fc->blocked_waitq);
158 spin_unlock(&fc->lock);
159 fput(file);
160}
161
162/*
163 * Gets a requests for a file operation, always succeeds
164 *
165 * This is used for sending the FLUSH request, which must get to
166 * userspace, due to POSIX locks which may need to be unlocked.
167 *
168 * If allocation fails due to OOM, use the reserved request in
169 * fuse_file.
170 *
171 * This is very unlikely to deadlock accidentally, since the
172 * filesystem should not have it's own file open. If deadlock is
173 * intentional, it can still be broken by "aborting" the filesystem.
174 */
175struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file)
176{
177 struct fuse_req *req;
178
179 atomic_inc(&fc->num_waiting);
180 wait_event(fc->blocked_waitq, !fc->blocked);
181 req = fuse_request_alloc();
182 if (!req)
183 req = get_reserved_req(fc, file);
184
185 fuse_req_init_context(req);
186 req->waiting = 1;
187 return req;
188}
189
Miklos Szeredi334f4852005-09-09 13:10:27 -0700190void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
191{
Miklos Szeredi7128ec22006-02-04 23:27:40 -0800192 if (atomic_dec_and_test(&req->count)) {
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +0200193 if (req->waiting)
194 atomic_dec(&fc->num_waiting);
Miklos Szeredi33649c92006-06-25 05:48:52 -0700195
196 if (req->stolen_file)
197 put_reserved_req(fc, req);
198 else
199 fuse_request_free(req);
Miklos Szeredi7128ec22006-02-04 23:27:40 -0800200 }
201}
202
Miklos Szeredi6dbbcb12006-04-26 10:49:06 +0200203/*
Miklos Szeredi334f4852005-09-09 13:10:27 -0700204 * This function is called when a request is finished. Either a reply
Miklos Szeredif9a28422006-06-25 05:48:53 -0700205 * has arrived or it was aborted (and not yet sent) or some error
Miklos Szeredif43b1552006-01-16 22:14:26 -0800206 * occurred during communication with userspace, or the device file
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700207 * was closed. The requester thread is woken up (if still waiting),
208 * the 'end' callback is called if given, else the reference to the
209 * request is released
Miklos Szeredi7128ec22006-02-04 23:27:40 -0800210 *
Miklos Szeredid7133112006-04-10 22:54:55 -0700211 * Called with fc->lock, unlocks it
Miklos Szeredi334f4852005-09-09 13:10:27 -0700212 */
213static void request_end(struct fuse_conn *fc, struct fuse_req *req)
214{
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700215 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
216 req->end = NULL;
Miklos Szeredid77a1d52006-01-16 22:14:31 -0800217 list_del(&req->list);
Miklos Szeredi83cfd492006-01-16 22:14:31 -0800218 req->state = FUSE_REQ_FINISHED;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700219 if (req->background) {
220 if (fc->num_background == FUSE_MAX_BACKGROUND) {
221 fc->blocked = 0;
222 wake_up_all(&fc->blocked_waitq);
223 }
224 fc->num_background--;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700225 }
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700226 spin_unlock(&fc->lock);
227 dput(req->dentry);
228 mntput(req->vfsmount);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700229 if (req->file)
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700230 fput(req->file);
231 wake_up(&req->waitq);
232 if (end)
233 end(fc, req);
234 else
235 fuse_put_request(fc, req);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700236}
237
Miklos Szeredid7133112006-04-10 22:54:55 -0700238/* Called with fc->lock held. Releases, and then reacquires it. */
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700239static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700240{
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700241 sigset_t oldset;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700242
Miklos Szeredid7133112006-04-10 22:54:55 -0700243 spin_unlock(&fc->lock);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700244 if (req->force)
245 wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
246 else {
247 block_sigs(&oldset);
248 wait_event_interruptible(req->waitq,
249 req->state == FUSE_REQ_FINISHED);
250 restore_sigs(&oldset);
251 }
Miklos Szeredid7133112006-04-10 22:54:55 -0700252 spin_lock(&fc->lock);
Miklos Szeredif9a28422006-06-25 05:48:53 -0700253 if (req->state == FUSE_REQ_FINISHED && !req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700254 return;
255
Miklos Szeredif9a28422006-06-25 05:48:53 -0700256 if (!req->aborted) {
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800257 req->out.h.error = -EINTR;
Miklos Szeredif9a28422006-06-25 05:48:53 -0700258 req->aborted = 1;
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800259 }
Miklos Szeredi334f4852005-09-09 13:10:27 -0700260 if (req->locked) {
261 /* This is uninterruptible sleep, because data is
262 being copied to/from the buffers of req. During
263 locked state, there mustn't be any filesystem
264 operation (e.g. page fault), since that could lead
265 to deadlock */
Miklos Szeredid7133112006-04-10 22:54:55 -0700266 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700267 wait_event(req->waitq, !req->locked);
Miklos Szeredid7133112006-04-10 22:54:55 -0700268 spin_lock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700269 }
Miklos Szeredi83cfd492006-01-16 22:14:31 -0800270 if (req->state == FUSE_REQ_PENDING) {
Miklos Szeredi334f4852005-09-09 13:10:27 -0700271 list_del(&req->list);
272 __fuse_put_request(req);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700273 } else if (req->state == FUSE_REQ_SENT) {
274 spin_unlock(&fc->lock);
275 wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
276 spin_lock(&fc->lock);
277 }
Miklos Szeredi334f4852005-09-09 13:10:27 -0700278}
279
280static unsigned len_args(unsigned numargs, struct fuse_arg *args)
281{
282 unsigned nbytes = 0;
283 unsigned i;
284
285 for (i = 0; i < numargs; i++)
286 nbytes += args[i].size;
287
288 return nbytes;
289}
290
291static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
292{
293 fc->reqctr++;
294 /* zero is special */
295 if (fc->reqctr == 0)
296 fc->reqctr = 1;
297 req->in.h.unique = fc->reqctr;
298 req->in.h.len = sizeof(struct fuse_in_header) +
299 len_args(req->in.numargs, (struct fuse_arg *) req->in.args);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700300 list_add_tail(&req->list, &fc->pending);
Miklos Szeredi83cfd492006-01-16 22:14:31 -0800301 req->state = FUSE_REQ_PENDING;
Miklos Szeredi9bc5ddd2006-04-11 21:16:09 +0200302 if (!req->waiting) {
303 req->waiting = 1;
304 atomic_inc(&fc->num_waiting);
305 }
Miklos Szeredi334f4852005-09-09 13:10:27 -0700306 wake_up(&fc->waitq);
Jeff Dike385a17b2006-04-10 22:54:52 -0700307 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700308}
309
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700310/*
311 * This can only be interrupted by a SIGKILL
312 */
313void request_send(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700314{
315 req->isreply = 1;
Miklos Szeredid7133112006-04-10 22:54:55 -0700316 spin_lock(&fc->lock);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700317 if (!fc->connected)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700318 req->out.h.error = -ENOTCONN;
319 else if (fc->conn_error)
320 req->out.h.error = -ECONNREFUSED;
321 else {
322 queue_request(fc, req);
323 /* acquire extra reference, since request is still needed
324 after request_end() */
325 __fuse_get_request(req);
326
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700327 request_wait_answer(fc, req);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700328 }
Miklos Szeredid7133112006-04-10 22:54:55 -0700329 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700330}
331
Miklos Szeredi334f4852005-09-09 13:10:27 -0700332static void request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
333{
Miklos Szeredid7133112006-04-10 22:54:55 -0700334 spin_lock(&fc->lock);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700335 if (fc->connected) {
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700336 req->background = 1;
337 fc->num_background++;
338 if (fc->num_background == FUSE_MAX_BACKGROUND)
339 fc->blocked = 1;
340
Miklos Szeredi334f4852005-09-09 13:10:27 -0700341 queue_request(fc, req);
Miklos Szeredid7133112006-04-10 22:54:55 -0700342 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700343 } else {
344 req->out.h.error = -ENOTCONN;
345 request_end(fc, req);
346 }
347}
348
349void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req)
350{
351 req->isreply = 0;
352 request_send_nowait(fc, req);
353}
354
355void request_send_background(struct fuse_conn *fc, struct fuse_req *req)
356{
357 req->isreply = 1;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700358 request_send_nowait(fc, req);
359}
360
Miklos Szeredi334f4852005-09-09 13:10:27 -0700361/*
362 * Lock the request. Up to the next unlock_request() there mustn't be
363 * anything that could cause a page-fault. If the request was already
Miklos Szeredif9a28422006-06-25 05:48:53 -0700364 * aborted bail out.
Miklos Szeredi334f4852005-09-09 13:10:27 -0700365 */
Miklos Szeredid7133112006-04-10 22:54:55 -0700366static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700367{
368 int err = 0;
369 if (req) {
Miklos Szeredid7133112006-04-10 22:54:55 -0700370 spin_lock(&fc->lock);
Miklos Szeredif9a28422006-06-25 05:48:53 -0700371 if (req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700372 err = -ENOENT;
373 else
374 req->locked = 1;
Miklos Szeredid7133112006-04-10 22:54:55 -0700375 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700376 }
377 return err;
378}
379
380/*
Miklos Szeredif9a28422006-06-25 05:48:53 -0700381 * Unlock request. If it was aborted during being locked, the
Miklos Szeredi334f4852005-09-09 13:10:27 -0700382 * requester thread is currently waiting for it to be unlocked, so
383 * wake it up.
384 */
Miklos Szeredid7133112006-04-10 22:54:55 -0700385static void unlock_request(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700386{
387 if (req) {
Miklos Szeredid7133112006-04-10 22:54:55 -0700388 spin_lock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700389 req->locked = 0;
Miklos Szeredif9a28422006-06-25 05:48:53 -0700390 if (req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700391 wake_up(&req->waitq);
Miklos Szeredid7133112006-04-10 22:54:55 -0700392 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700393 }
394}
395
396struct fuse_copy_state {
Miklos Szeredid7133112006-04-10 22:54:55 -0700397 struct fuse_conn *fc;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700398 int write;
399 struct fuse_req *req;
400 const struct iovec *iov;
401 unsigned long nr_segs;
402 unsigned long seglen;
403 unsigned long addr;
404 struct page *pg;
405 void *mapaddr;
406 void *buf;
407 unsigned len;
408};
409
Miklos Szeredid7133112006-04-10 22:54:55 -0700410static void fuse_copy_init(struct fuse_copy_state *cs, struct fuse_conn *fc,
411 int write, struct fuse_req *req,
412 const struct iovec *iov, unsigned long nr_segs)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700413{
414 memset(cs, 0, sizeof(*cs));
Miklos Szeredid7133112006-04-10 22:54:55 -0700415 cs->fc = fc;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700416 cs->write = write;
417 cs->req = req;
418 cs->iov = iov;
419 cs->nr_segs = nr_segs;
420}
421
422/* Unmap and put previous page of userspace buffer */
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800423static void fuse_copy_finish(struct fuse_copy_state *cs)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700424{
425 if (cs->mapaddr) {
426 kunmap_atomic(cs->mapaddr, KM_USER0);
427 if (cs->write) {
428 flush_dcache_page(cs->pg);
429 set_page_dirty_lock(cs->pg);
430 }
431 put_page(cs->pg);
432 cs->mapaddr = NULL;
433 }
434}
435
436/*
437 * Get another pagefull of userspace buffer, and map it to kernel
438 * address space, and lock request
439 */
440static int fuse_copy_fill(struct fuse_copy_state *cs)
441{
442 unsigned long offset;
443 int err;
444
Miklos Szeredid7133112006-04-10 22:54:55 -0700445 unlock_request(cs->fc, cs->req);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700446 fuse_copy_finish(cs);
447 if (!cs->seglen) {
448 BUG_ON(!cs->nr_segs);
449 cs->seglen = cs->iov[0].iov_len;
450 cs->addr = (unsigned long) cs->iov[0].iov_base;
451 cs->iov ++;
452 cs->nr_segs --;
453 }
454 down_read(&current->mm->mmap_sem);
455 err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
456 &cs->pg, NULL);
457 up_read(&current->mm->mmap_sem);
458 if (err < 0)
459 return err;
460 BUG_ON(err != 1);
461 offset = cs->addr % PAGE_SIZE;
462 cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
463 cs->buf = cs->mapaddr + offset;
464 cs->len = min(PAGE_SIZE - offset, cs->seglen);
465 cs->seglen -= cs->len;
466 cs->addr += cs->len;
467
Miklos Szeredid7133112006-04-10 22:54:55 -0700468 return lock_request(cs->fc, cs->req);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700469}
470
471/* Do as much copy to/from userspace buffer as we can */
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800472static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700473{
474 unsigned ncpy = min(*size, cs->len);
475 if (val) {
476 if (cs->write)
477 memcpy(cs->buf, *val, ncpy);
478 else
479 memcpy(*val, cs->buf, ncpy);
480 *val += ncpy;
481 }
482 *size -= ncpy;
483 cs->len -= ncpy;
484 cs->buf += ncpy;
485 return ncpy;
486}
487
488/*
489 * Copy a page in the request to/from the userspace buffer. Must be
490 * done atomically
491 */
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800492static int fuse_copy_page(struct fuse_copy_state *cs, struct page *page,
493 unsigned offset, unsigned count, int zeroing)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700494{
495 if (page && zeroing && count < PAGE_SIZE) {
496 void *mapaddr = kmap_atomic(page, KM_USER1);
497 memset(mapaddr, 0, PAGE_SIZE);
498 kunmap_atomic(mapaddr, KM_USER1);
499 }
500 while (count) {
501 int err;
502 if (!cs->len && (err = fuse_copy_fill(cs)))
503 return err;
504 if (page) {
505 void *mapaddr = kmap_atomic(page, KM_USER1);
506 void *buf = mapaddr + offset;
507 offset += fuse_copy_do(cs, &buf, &count);
508 kunmap_atomic(mapaddr, KM_USER1);
509 } else
510 offset += fuse_copy_do(cs, NULL, &count);
511 }
512 if (page && !cs->write)
513 flush_dcache_page(page);
514 return 0;
515}
516
517/* Copy pages in the request to/from userspace buffer */
518static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
519 int zeroing)
520{
521 unsigned i;
522 struct fuse_req *req = cs->req;
523 unsigned offset = req->page_offset;
524 unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);
525
526 for (i = 0; i < req->num_pages && (nbytes || zeroing); i++) {
527 struct page *page = req->pages[i];
528 int err = fuse_copy_page(cs, page, offset, count, zeroing);
529 if (err)
530 return err;
531
532 nbytes -= count;
533 count = min(nbytes, (unsigned) PAGE_SIZE);
534 offset = 0;
535 }
536 return 0;
537}
538
539/* Copy a single argument in the request to/from userspace buffer */
540static int fuse_copy_one(struct fuse_copy_state *cs, void *val, unsigned size)
541{
542 while (size) {
543 int err;
544 if (!cs->len && (err = fuse_copy_fill(cs)))
545 return err;
546 fuse_copy_do(cs, &val, &size);
547 }
548 return 0;
549}
550
551/* Copy request arguments to/from userspace buffer */
552static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
553 unsigned argpages, struct fuse_arg *args,
554 int zeroing)
555{
556 int err = 0;
557 unsigned i;
558
559 for (i = 0; !err && i < numargs; i++) {
560 struct fuse_arg *arg = &args[i];
561 if (i == numargs - 1 && argpages)
562 err = fuse_copy_pages(cs, arg->size, zeroing);
563 else
564 err = fuse_copy_one(cs, arg->value, arg->size);
565 }
566 return err;
567}
568
569/* Wait until a request is available on the pending list */
570static void request_wait(struct fuse_conn *fc)
571{
572 DECLARE_WAITQUEUE(wait, current);
573
574 add_wait_queue_exclusive(&fc->waitq, &wait);
Miklos Szeredi9ba7cbb2006-01-16 22:14:34 -0800575 while (fc->connected && list_empty(&fc->pending)) {
Miklos Szeredi334f4852005-09-09 13:10:27 -0700576 set_current_state(TASK_INTERRUPTIBLE);
577 if (signal_pending(current))
578 break;
579
Miklos Szeredid7133112006-04-10 22:54:55 -0700580 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700581 schedule();
Miklos Szeredid7133112006-04-10 22:54:55 -0700582 spin_lock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700583 }
584 set_current_state(TASK_RUNNING);
585 remove_wait_queue(&fc->waitq, &wait);
586}
587
588/*
589 * Read a single request into the userspace filesystem's buffer. This
590 * function waits until a request is available, then removes it from
591 * the pending list and copies request data to userspace buffer. If
Miklos Szeredif9a28422006-06-25 05:48:53 -0700592 * no reply is needed (FORGET) or request has been aborted or there
593 * was an error during the copying then it's finished by calling
Miklos Szeredi334f4852005-09-09 13:10:27 -0700594 * request_end(). Otherwise add it to the processing list, and set
595 * the 'sent' flag.
596 */
597static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
598 unsigned long nr_segs, loff_t *off)
599{
600 int err;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700601 struct fuse_req *req;
602 struct fuse_in *in;
603 struct fuse_copy_state cs;
604 unsigned reqsize;
Miklos Szeredi0720b312006-04-10 22:54:55 -0700605 struct fuse_conn *fc = fuse_get_conn(file);
606 if (!fc)
607 return -EPERM;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700608
Miklos Szeredi1d3d7522006-01-06 00:19:40 -0800609 restart:
Miklos Szeredid7133112006-04-10 22:54:55 -0700610 spin_lock(&fc->lock);
Jeff Dikee5ac1d12006-04-10 22:54:53 -0700611 err = -EAGAIN;
612 if ((file->f_flags & O_NONBLOCK) && fc->connected &&
613 list_empty(&fc->pending))
614 goto err_unlock;
615
Miklos Szeredi334f4852005-09-09 13:10:27 -0700616 request_wait(fc);
617 err = -ENODEV;
Miklos Szeredi9ba7cbb2006-01-16 22:14:34 -0800618 if (!fc->connected)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700619 goto err_unlock;
620 err = -ERESTARTSYS;
621 if (list_empty(&fc->pending))
622 goto err_unlock;
623
624 req = list_entry(fc->pending.next, struct fuse_req, list);
Miklos Szeredi83cfd492006-01-16 22:14:31 -0800625 req->state = FUSE_REQ_READING;
Miklos Szeredid77a1d52006-01-16 22:14:31 -0800626 list_move(&req->list, &fc->io);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700627
628 in = &req->in;
Miklos Szeredi1d3d7522006-01-06 00:19:40 -0800629 reqsize = in->h.len;
630 /* If request is too large, reply with an error and restart the read */
631 if (iov_length(iov, nr_segs) < reqsize) {
632 req->out.h.error = -EIO;
633 /* SETXATTR is special, since it may contain too large data */
634 if (in->h.opcode == FUSE_SETXATTR)
635 req->out.h.error = -E2BIG;
636 request_end(fc, req);
637 goto restart;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700638 }
Miklos Szeredid7133112006-04-10 22:54:55 -0700639 spin_unlock(&fc->lock);
640 fuse_copy_init(&cs, fc, 1, req, iov, nr_segs);
Miklos Szeredi1d3d7522006-01-06 00:19:40 -0800641 err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
642 if (!err)
643 err = fuse_copy_args(&cs, in->numargs, in->argpages,
644 (struct fuse_arg *) in->args, 0);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700645 fuse_copy_finish(&cs);
Miklos Szeredid7133112006-04-10 22:54:55 -0700646 spin_lock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700647 req->locked = 0;
Miklos Szeredif9a28422006-06-25 05:48:53 -0700648 if (!err && req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700649 err = -ENOENT;
650 if (err) {
Miklos Szeredif9a28422006-06-25 05:48:53 -0700651 if (!req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700652 req->out.h.error = -EIO;
653 request_end(fc, req);
654 return err;
655 }
656 if (!req->isreply)
657 request_end(fc, req);
658 else {
Miklos Szeredi83cfd492006-01-16 22:14:31 -0800659 req->state = FUSE_REQ_SENT;
Miklos Szeredid77a1d52006-01-16 22:14:31 -0800660 list_move_tail(&req->list, &fc->processing);
Miklos Szeredid7133112006-04-10 22:54:55 -0700661 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700662 }
663 return reqsize;
664
665 err_unlock:
Miklos Szeredid7133112006-04-10 22:54:55 -0700666 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700667 return err;
668}
669
670static ssize_t fuse_dev_read(struct file *file, char __user *buf,
671 size_t nbytes, loff_t *off)
672{
673 struct iovec iov;
674 iov.iov_len = nbytes;
675 iov.iov_base = buf;
676 return fuse_dev_readv(file, &iov, 1, off);
677}
678
679/* Look up request on processing list by unique ID */
680static struct fuse_req *request_find(struct fuse_conn *fc, u64 unique)
681{
682 struct list_head *entry;
683
684 list_for_each(entry, &fc->processing) {
685 struct fuse_req *req;
686 req = list_entry(entry, struct fuse_req, list);
687 if (req->in.h.unique == unique)
688 return req;
689 }
690 return NULL;
691}
692
693static int copy_out_args(struct fuse_copy_state *cs, struct fuse_out *out,
694 unsigned nbytes)
695{
696 unsigned reqsize = sizeof(struct fuse_out_header);
697
698 if (out->h.error)
699 return nbytes != reqsize ? -EINVAL : 0;
700
701 reqsize += len_args(out->numargs, out->args);
702
703 if (reqsize < nbytes || (reqsize > nbytes && !out->argvar))
704 return -EINVAL;
705 else if (reqsize > nbytes) {
706 struct fuse_arg *lastarg = &out->args[out->numargs-1];
707 unsigned diffsize = reqsize - nbytes;
708 if (diffsize > lastarg->size)
709 return -EINVAL;
710 lastarg->size -= diffsize;
711 }
712 return fuse_copy_args(cs, out->numargs, out->argpages, out->args,
713 out->page_zeroing);
714}
715
716/*
717 * Write a single reply to a request. First the header is copied from
718 * the write buffer. The request is then searched on the processing
719 * list by the unique ID found in the header. If found, then remove
720 * it from the list and copy the rest of the buffer to the request.
721 * The request is finished by calling request_end()
722 */
723static ssize_t fuse_dev_writev(struct file *file, const struct iovec *iov,
724 unsigned long nr_segs, loff_t *off)
725{
726 int err;
727 unsigned nbytes = iov_length(iov, nr_segs);
728 struct fuse_req *req;
729 struct fuse_out_header oh;
730 struct fuse_copy_state cs;
731 struct fuse_conn *fc = fuse_get_conn(file);
732 if (!fc)
Miklos Szeredia87046d2006-04-10 22:54:56 -0700733 return -EPERM;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700734
Miklos Szeredid7133112006-04-10 22:54:55 -0700735 fuse_copy_init(&cs, fc, 0, NULL, iov, nr_segs);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700736 if (nbytes < sizeof(struct fuse_out_header))
737 return -EINVAL;
738
739 err = fuse_copy_one(&cs, &oh, sizeof(oh));
740 if (err)
741 goto err_finish;
742 err = -EINVAL;
743 if (!oh.unique || oh.error <= -1000 || oh.error > 0 ||
744 oh.len != nbytes)
745 goto err_finish;
746
Miklos Szeredid7133112006-04-10 22:54:55 -0700747 spin_lock(&fc->lock);
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800748 err = -ENOENT;
749 if (!fc->connected)
750 goto err_unlock;
751
Miklos Szeredi334f4852005-09-09 13:10:27 -0700752 req = request_find(fc, oh.unique);
753 err = -EINVAL;
754 if (!req)
755 goto err_unlock;
756
Miklos Szeredif9a28422006-06-25 05:48:53 -0700757 if (req->aborted) {
Miklos Szeredid7133112006-04-10 22:54:55 -0700758 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700759 fuse_copy_finish(&cs);
Miklos Szeredid7133112006-04-10 22:54:55 -0700760 spin_lock(&fc->lock);
Miklos Szeredi222f1d62006-01-16 22:14:25 -0800761 request_end(fc, req);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700762 return -ENOENT;
763 }
Miklos Szeredid77a1d52006-01-16 22:14:31 -0800764 list_move(&req->list, &fc->io);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700765 req->out.h = oh;
766 req->locked = 1;
767 cs.req = req;
Miklos Szeredid7133112006-04-10 22:54:55 -0700768 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700769
770 err = copy_out_args(&cs, &req->out, nbytes);
771 fuse_copy_finish(&cs);
772
Miklos Szeredid7133112006-04-10 22:54:55 -0700773 spin_lock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700774 req->locked = 0;
775 if (!err) {
Miklos Szeredif9a28422006-06-25 05:48:53 -0700776 if (req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700777 err = -ENOENT;
Miklos Szeredif9a28422006-06-25 05:48:53 -0700778 } else if (!req->aborted)
Miklos Szeredi334f4852005-09-09 13:10:27 -0700779 req->out.h.error = -EIO;
780 request_end(fc, req);
781
782 return err ? err : nbytes;
783
784 err_unlock:
Miklos Szeredid7133112006-04-10 22:54:55 -0700785 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700786 err_finish:
787 fuse_copy_finish(&cs);
788 return err;
789}
790
791static ssize_t fuse_dev_write(struct file *file, const char __user *buf,
792 size_t nbytes, loff_t *off)
793{
794 struct iovec iov;
795 iov.iov_len = nbytes;
796 iov.iov_base = (char __user *) buf;
797 return fuse_dev_writev(file, &iov, 1, off);
798}
799
800static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
801{
Miklos Szeredi334f4852005-09-09 13:10:27 -0700802 unsigned mask = POLLOUT | POLLWRNORM;
Miklos Szeredi7025d9a2006-04-10 22:54:50 -0700803 struct fuse_conn *fc = fuse_get_conn(file);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700804 if (!fc)
Miklos Szeredi7025d9a2006-04-10 22:54:50 -0700805 return POLLERR;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700806
807 poll_wait(file, &fc->waitq, wait);
808
Miklos Szeredid7133112006-04-10 22:54:55 -0700809 spin_lock(&fc->lock);
Miklos Szeredi7025d9a2006-04-10 22:54:50 -0700810 if (!fc->connected)
811 mask = POLLERR;
812 else if (!list_empty(&fc->pending))
813 mask |= POLLIN | POLLRDNORM;
Miklos Szeredid7133112006-04-10 22:54:55 -0700814 spin_unlock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700815
816 return mask;
817}
818
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800819/*
820 * Abort all requests on the given list (pending or processing)
821 *
Miklos Szeredid7133112006-04-10 22:54:55 -0700822 * This function releases and reacquires fc->lock
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800823 */
Miklos Szeredi334f4852005-09-09 13:10:27 -0700824static void end_requests(struct fuse_conn *fc, struct list_head *head)
825{
826 while (!list_empty(head)) {
827 struct fuse_req *req;
828 req = list_entry(head->next, struct fuse_req, list);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700829 req->out.h.error = -ECONNABORTED;
830 request_end(fc, req);
Miklos Szeredid7133112006-04-10 22:54:55 -0700831 spin_lock(&fc->lock);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700832 }
833}
834
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800835/*
836 * Abort requests under I/O
837 *
Miklos Szeredif9a28422006-06-25 05:48:53 -0700838 * The requests are set to aborted and finished, and the request
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800839 * waiter is woken up. This will make request_wait_answer() wait
840 * until the request is unlocked and then return.
Miklos Szeredi64c6d8e2006-01-16 22:14:42 -0800841 *
842 * If the request is asynchronous, then the end function needs to be
843 * called after waiting for the request to be unlocked (if it was
844 * locked).
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800845 */
846static void end_io_requests(struct fuse_conn *fc)
847{
848 while (!list_empty(&fc->io)) {
Miklos Szeredi64c6d8e2006-01-16 22:14:42 -0800849 struct fuse_req *req =
850 list_entry(fc->io.next, struct fuse_req, list);
851 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
852
Miklos Szeredif9a28422006-06-25 05:48:53 -0700853 req->aborted = 1;
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800854 req->out.h.error = -ECONNABORTED;
855 req->state = FUSE_REQ_FINISHED;
856 list_del_init(&req->list);
857 wake_up(&req->waitq);
Miklos Szeredi64c6d8e2006-01-16 22:14:42 -0800858 if (end) {
859 req->end = NULL;
860 /* The end function will consume this reference */
861 __fuse_get_request(req);
Miklos Szeredid7133112006-04-10 22:54:55 -0700862 spin_unlock(&fc->lock);
Miklos Szeredi64c6d8e2006-01-16 22:14:42 -0800863 wait_event(req->waitq, !req->locked);
864 end(fc, req);
Miklos Szeredid7133112006-04-10 22:54:55 -0700865 spin_lock(&fc->lock);
Miklos Szeredi64c6d8e2006-01-16 22:14:42 -0800866 }
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800867 }
868}
869
870/*
871 * Abort all requests.
872 *
873 * Emergency exit in case of a malicious or accidental deadlock, or
874 * just a hung filesystem.
875 *
876 * The same effect is usually achievable through killing the
877 * filesystem daemon and all users of the filesystem. The exception
878 * is the combination of an asynchronous request and the tricky
879 * deadlock (see Documentation/filesystems/fuse.txt).
880 *
881 * During the aborting, progression of requests from the pending and
882 * processing lists onto the io list, and progression of new requests
883 * onto the pending list is prevented by req->connected being false.
884 *
885 * Progression of requests under I/O to the processing list is
Miklos Szeredif9a28422006-06-25 05:48:53 -0700886 * prevented by the req->aborted flag being true for these requests.
887 * For this reason requests on the io list must be aborted first.
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800888 */
889void fuse_abort_conn(struct fuse_conn *fc)
890{
Miklos Szeredid7133112006-04-10 22:54:55 -0700891 spin_lock(&fc->lock);
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800892 if (fc->connected) {
893 fc->connected = 0;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700894 fc->blocked = 0;
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800895 end_io_requests(fc);
896 end_requests(fc, &fc->pending);
897 end_requests(fc, &fc->processing);
898 wake_up_all(&fc->waitq);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700899 wake_up_all(&fc->blocked_waitq);
Jeff Dike385a17b2006-04-10 22:54:52 -0700900 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800901 }
Miklos Szeredid7133112006-04-10 22:54:55 -0700902 spin_unlock(&fc->lock);
Miklos Szeredi69a53bf2006-01-16 22:14:41 -0800903}
904
Miklos Szeredi334f4852005-09-09 13:10:27 -0700905static int fuse_dev_release(struct inode *inode, struct file *file)
906{
Miklos Szeredi0720b312006-04-10 22:54:55 -0700907 struct fuse_conn *fc = fuse_get_conn(file);
Miklos Szeredi334f4852005-09-09 13:10:27 -0700908 if (fc) {
Miklos Szeredid7133112006-04-10 22:54:55 -0700909 spin_lock(&fc->lock);
Miklos Szeredi1e9a4ed2005-09-09 13:10:31 -0700910 fc->connected = 0;
Miklos Szeredi334f4852005-09-09 13:10:27 -0700911 end_requests(fc, &fc->pending);
912 end_requests(fc, &fc->processing);
Miklos Szeredid7133112006-04-10 22:54:55 -0700913 spin_unlock(&fc->lock);
Jeff Dike385a17b2006-04-10 22:54:52 -0700914 fasync_helper(-1, file, 0, &fc->fasync);
Miklos Szeredibafa9652006-06-25 05:48:51 -0700915 fuse_conn_put(fc);
Jeff Dike385a17b2006-04-10 22:54:52 -0700916 }
Miklos Szeredif543f252006-01-16 22:14:35 -0800917
Miklos Szeredi334f4852005-09-09 13:10:27 -0700918 return 0;
919}
920
Jeff Dike385a17b2006-04-10 22:54:52 -0700921static int fuse_dev_fasync(int fd, struct file *file, int on)
922{
923 struct fuse_conn *fc = fuse_get_conn(file);
924 if (!fc)
Miklos Szeredia87046d2006-04-10 22:54:56 -0700925 return -EPERM;
Jeff Dike385a17b2006-04-10 22:54:52 -0700926
927 /* No locking - fasync_helper does its own locking */
928 return fasync_helper(fd, file, on, &fc->fasync);
929}
930
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800931const struct file_operations fuse_dev_operations = {
Miklos Szeredi334f4852005-09-09 13:10:27 -0700932 .owner = THIS_MODULE,
933 .llseek = no_llseek,
934 .read = fuse_dev_read,
935 .readv = fuse_dev_readv,
936 .write = fuse_dev_write,
937 .writev = fuse_dev_writev,
938 .poll = fuse_dev_poll,
939 .release = fuse_dev_release,
Jeff Dike385a17b2006-04-10 22:54:52 -0700940 .fasync = fuse_dev_fasync,
Miklos Szeredi334f4852005-09-09 13:10:27 -0700941};
942
943static struct miscdevice fuse_miscdevice = {
944 .minor = FUSE_MINOR,
945 .name = "fuse",
946 .fops = &fuse_dev_operations,
947};
948
949int __init fuse_dev_init(void)
950{
951 int err = -ENOMEM;
952 fuse_req_cachep = kmem_cache_create("fuse_request",
953 sizeof(struct fuse_req),
954 0, 0, NULL, NULL);
955 if (!fuse_req_cachep)
956 goto out;
957
958 err = misc_register(&fuse_miscdevice);
959 if (err)
960 goto out_cache_clean;
961
962 return 0;
963
964 out_cache_clean:
965 kmem_cache_destroy(fuse_req_cachep);
966 out:
967 return err;
968}
969
970void fuse_dev_cleanup(void)
971{
972 misc_deregister(&fuse_miscdevice);
973 kmem_cache_destroy(fuse_req_cachep);
974}