fuse: fix reserved request wake up
[deliverable/linux.git] / fs / fuse / dev.c
CommitLineData
334f485d
MS
1/*
2 FUSE: Filesystem in Userspace
d7133114 3 Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
334f485d
MS
4
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
e18b890b 22static struct kmem_cache *fuse_req_cachep;
334f485d 23
8bfc016d 24static struct fuse_conn *fuse_get_conn(struct file *file)
334f485d 25{
0720b315
MS
26 /*
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;
334f485d
MS
31}
32
8bfc016d 33static void fuse_request_init(struct fuse_req *req)
334f485d
MS
34{
35 memset(req, 0, sizeof(*req));
36 INIT_LIST_HEAD(&req->list);
a4d27e75 37 INIT_LIST_HEAD(&req->intr_entry);
334f485d
MS
38 init_waitqueue_head(&req->waitq);
39 atomic_set(&req->count, 1);
40}
41
42struct fuse_req *fuse_request_alloc(void)
43{
e94b1766 44 struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_KERNEL);
334f485d
MS
45 if (req)
46 fuse_request_init(req);
47 return req;
48}
49
50void fuse_request_free(struct fuse_req *req)
51{
52 kmem_cache_free(fuse_req_cachep, req);
53}
54
8bfc016d 55static void block_sigs(sigset_t *oldset)
334f485d
MS
56{
57 sigset_t mask;
58
59 siginitsetinv(&mask, sigmask(SIGKILL));
60 sigprocmask(SIG_BLOCK, &mask, oldset);
61}
62
8bfc016d 63static void restore_sigs(sigset_t *oldset)
334f485d
MS
64{
65 sigprocmask(SIG_SETMASK, oldset, NULL);
66}
67
334f485d
MS
68static void __fuse_get_request(struct fuse_req *req)
69{
70 atomic_inc(&req->count);
71}
72
73/* Must be called with > 1 refcount */
74static void __fuse_put_request(struct fuse_req *req)
75{
76 BUG_ON(atomic_read(&req->count) < 2);
77 atomic_dec(&req->count);
78}
79
33649c91
MS
80static void fuse_req_init_context(struct fuse_req *req)
81{
82 req->in.h.uid = current->fsuid;
83 req->in.h.gid = current->fsgid;
84 req->in.h.pid = current->pid;
85}
86
ce1d5a49 87struct fuse_req *fuse_get_req(struct fuse_conn *fc)
334f485d 88{
08a53cdc
MS
89 struct fuse_req *req;
90 sigset_t oldset;
9bc5ddda 91 int intr;
08a53cdc
MS
92 int err;
93
9bc5ddda 94 atomic_inc(&fc->num_waiting);
08a53cdc 95 block_sigs(&oldset);
9bc5ddda 96 intr = wait_event_interruptible(fc->blocked_waitq, !fc->blocked);
08a53cdc 97 restore_sigs(&oldset);
9bc5ddda
MS
98 err = -EINTR;
99 if (intr)
100 goto out;
08a53cdc 101
51eb01e7
MS
102 err = -ENOTCONN;
103 if (!fc->connected)
104 goto out;
105
08a53cdc 106 req = fuse_request_alloc();
9bc5ddda 107 err = -ENOMEM;
ce1d5a49 108 if (!req)
9bc5ddda 109 goto out;
334f485d 110
33649c91 111 fuse_req_init_context(req);
9bc5ddda 112 req->waiting = 1;
334f485d 113 return req;
9bc5ddda
MS
114
115 out:
116 atomic_dec(&fc->num_waiting);
117 return ERR_PTR(err);
334f485d
MS
118}
119
33649c91
MS
120/*
121 * Return request in fuse_file->reserved_req. However that may
122 * currently be in use. If that is the case, wait for it to become
123 * available.
124 */
125static struct fuse_req *get_reserved_req(struct fuse_conn *fc,
126 struct file *file)
127{
128 struct fuse_req *req = NULL;
129 struct fuse_file *ff = file->private_data;
130
131 do {
de5e3dec 132 wait_event(fc->reserved_req_waitq, ff->reserved_req);
33649c91
MS
133 spin_lock(&fc->lock);
134 if (ff->reserved_req) {
135 req = ff->reserved_req;
136 ff->reserved_req = NULL;
137 get_file(file);
138 req->stolen_file = file;
139 }
140 spin_unlock(&fc->lock);
141 } while (!req);
142
143 return req;
144}
145
146/*
147 * Put stolen request back into fuse_file->reserved_req
148 */
149static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req)
150{
151 struct file *file = req->stolen_file;
152 struct fuse_file *ff = file->private_data;
153
154 spin_lock(&fc->lock);
155 fuse_request_init(req);
156 BUG_ON(ff->reserved_req);
157 ff->reserved_req = req;
de5e3dec 158 wake_up_all(&fc->reserved_req_waitq);
33649c91
MS
159 spin_unlock(&fc->lock);
160 fput(file);
161}
162
163/*
164 * Gets a requests for a file operation, always succeeds
165 *
166 * This is used for sending the FLUSH request, which must get to
167 * userspace, due to POSIX locks which may need to be unlocked.
168 *
169 * If allocation fails due to OOM, use the reserved request in
170 * fuse_file.
171 *
172 * This is very unlikely to deadlock accidentally, since the
173 * filesystem should not have it's own file open. If deadlock is
174 * intentional, it can still be broken by "aborting" the filesystem.
175 */
176struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file)
177{
178 struct fuse_req *req;
179
180 atomic_inc(&fc->num_waiting);
181 wait_event(fc->blocked_waitq, !fc->blocked);
182 req = fuse_request_alloc();
183 if (!req)
184 req = get_reserved_req(fc, file);
185
186 fuse_req_init_context(req);
187 req->waiting = 1;
188 return req;
189}
190
334f485d 191void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
7128ec2a
MS
192{
193 if (atomic_dec_and_test(&req->count)) {
9bc5ddda
MS
194 if (req->waiting)
195 atomic_dec(&fc->num_waiting);
33649c91
MS
196
197 if (req->stolen_file)
198 put_reserved_req(fc, req);
199 else
200 fuse_request_free(req);
7128ec2a
MS
201 }
202}
203
334f485d
MS
204/*
205 * This function is called when a request is finished. Either a reply
f9a2842e 206 * has arrived or it was aborted (and not yet sent) or some error
f43b155a 207 * occurred during communication with userspace, or the device file
51eb01e7
MS
208 * was closed. The requester thread is woken up (if still waiting),
209 * the 'end' callback is called if given, else the reference to the
210 * request is released
7128ec2a 211 *
d7133114 212 * Called with fc->lock, unlocks it
334f485d
MS
213 */
214static void request_end(struct fuse_conn *fc, struct fuse_req *req)
105f4d7a 215 __releases(fc->lock)
334f485d 216{
51eb01e7
MS
217 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
218 req->end = NULL;
d77a1d5b 219 list_del(&req->list);
a4d27e75 220 list_del(&req->intr_entry);
83cfd493 221 req->state = FUSE_REQ_FINISHED;
51eb01e7
MS
222 if (req->background) {
223 if (fc->num_background == FUSE_MAX_BACKGROUND) {
224 fc->blocked = 0;
225 wake_up_all(&fc->blocked_waitq);
226 }
f92b99b9
MS
227 if (fc->num_background == FUSE_CONGESTION_THRESHOLD) {
228 clear_bdi_congested(&fc->bdi, READ);
229 clear_bdi_congested(&fc->bdi, WRITE);
230 }
51eb01e7 231 fc->num_background--;
334f485d 232 }
51eb01e7
MS
233 spin_unlock(&fc->lock);
234 dput(req->dentry);
235 mntput(req->vfsmount);
334f485d 236 if (req->file)
51eb01e7
MS
237 fput(req->file);
238 wake_up(&req->waitq);
239 if (end)
240 end(fc, req);
241 else
242 fuse_put_request(fc, req);
334f485d
MS
243}
244
a4d27e75
MS
245static void wait_answer_interruptible(struct fuse_conn *fc,
246 struct fuse_req *req)
247{
248 if (signal_pending(current))
249 return;
250
251 spin_unlock(&fc->lock);
252 wait_event_interruptible(req->waitq, req->state == FUSE_REQ_FINISHED);
253 spin_lock(&fc->lock);
254}
255
256static void queue_interrupt(struct fuse_conn *fc, struct fuse_req *req)
257{
258 list_add_tail(&req->intr_entry, &fc->interrupts);
259 wake_up(&fc->waitq);
260 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
261}
262
d7133114 263/* Called with fc->lock held. Releases, and then reacquires it. */
7c352bdf 264static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
334f485d 265{
a4d27e75
MS
266 if (!fc->no_interrupt) {
267 /* Any signal may interrupt this */
268 wait_answer_interruptible(fc, req);
334f485d 269
a4d27e75
MS
270 if (req->aborted)
271 goto aborted;
272 if (req->state == FUSE_REQ_FINISHED)
273 return;
274
275 req->interrupted = 1;
276 if (req->state == FUSE_REQ_SENT)
277 queue_interrupt(fc, req);
278 }
279
280 if (req->force) {
281 spin_unlock(&fc->lock);
51eb01e7 282 wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
a4d27e75
MS
283 spin_lock(&fc->lock);
284 } else {
285 sigset_t oldset;
286
287 /* Only fatal signals may interrupt this */
51eb01e7 288 block_sigs(&oldset);
a4d27e75 289 wait_answer_interruptible(fc, req);
51eb01e7
MS
290 restore_sigs(&oldset);
291 }
334f485d 292
a4d27e75
MS
293 if (req->aborted)
294 goto aborted;
295 if (req->state == FUSE_REQ_FINISHED)
296 return;
297
298 req->out.h.error = -EINTR;
299 req->aborted = 1;
300
301 aborted:
334f485d
MS
302 if (req->locked) {
303 /* This is uninterruptible sleep, because data is
304 being copied to/from the buffers of req. During
305 locked state, there mustn't be any filesystem
306 operation (e.g. page fault), since that could lead
307 to deadlock */
d7133114 308 spin_unlock(&fc->lock);
334f485d 309 wait_event(req->waitq, !req->locked);
d7133114 310 spin_lock(&fc->lock);
334f485d 311 }
83cfd493 312 if (req->state == FUSE_REQ_PENDING) {
334f485d
MS
313 list_del(&req->list);
314 __fuse_put_request(req);
51eb01e7
MS
315 } else if (req->state == FUSE_REQ_SENT) {
316 spin_unlock(&fc->lock);
317 wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
318 spin_lock(&fc->lock);
319 }
334f485d
MS
320}
321
322static unsigned len_args(unsigned numargs, struct fuse_arg *args)
323{
324 unsigned nbytes = 0;
325 unsigned i;
326
327 for (i = 0; i < numargs; i++)
328 nbytes += args[i].size;
329
330 return nbytes;
331}
332
a4d27e75
MS
333static u64 fuse_get_unique(struct fuse_conn *fc)
334 {
335 fc->reqctr++;
336 /* zero is special */
337 if (fc->reqctr == 0)
338 fc->reqctr = 1;
339
340 return fc->reqctr;
341}
342
334f485d
MS
343static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
344{
a4d27e75 345 req->in.h.unique = fuse_get_unique(fc);
334f485d
MS
346 req->in.h.len = sizeof(struct fuse_in_header) +
347 len_args(req->in.numargs, (struct fuse_arg *) req->in.args);
334f485d 348 list_add_tail(&req->list, &fc->pending);
83cfd493 349 req->state = FUSE_REQ_PENDING;
9bc5ddda
MS
350 if (!req->waiting) {
351 req->waiting = 1;
352 atomic_inc(&fc->num_waiting);
353 }
334f485d 354 wake_up(&fc->waitq);
385a17bf 355 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
334f485d
MS
356}
357
7c352bdf 358void request_send(struct fuse_conn *fc, struct fuse_req *req)
334f485d
MS
359{
360 req->isreply = 1;
d7133114 361 spin_lock(&fc->lock);
1e9a4ed9 362 if (!fc->connected)
334f485d
MS
363 req->out.h.error = -ENOTCONN;
364 else if (fc->conn_error)
365 req->out.h.error = -ECONNREFUSED;
366 else {
367 queue_request(fc, req);
368 /* acquire extra reference, since request is still needed
369 after request_end() */
370 __fuse_get_request(req);
371
7c352bdf 372 request_wait_answer(fc, req);
334f485d 373 }
d7133114 374 spin_unlock(&fc->lock);
334f485d
MS
375}
376
334f485d
MS
377static void request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
378{
d7133114 379 spin_lock(&fc->lock);
1e9a4ed9 380 if (fc->connected) {
51eb01e7
MS
381 req->background = 1;
382 fc->num_background++;
383 if (fc->num_background == FUSE_MAX_BACKGROUND)
384 fc->blocked = 1;
f92b99b9
MS
385 if (fc->num_background == FUSE_CONGESTION_THRESHOLD) {
386 set_bdi_congested(&fc->bdi, READ);
387 set_bdi_congested(&fc->bdi, WRITE);
388 }
51eb01e7 389
334f485d 390 queue_request(fc, req);
d7133114 391 spin_unlock(&fc->lock);
334f485d
MS
392 } else {
393 req->out.h.error = -ENOTCONN;
394 request_end(fc, req);
395 }
396}
397
398void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req)
399{
400 req->isreply = 0;
401 request_send_nowait(fc, req);
402}
403
404void request_send_background(struct fuse_conn *fc, struct fuse_req *req)
405{
406 req->isreply = 1;
334f485d
MS
407 request_send_nowait(fc, req);
408}
409
334f485d
MS
410/*
411 * Lock the request. Up to the next unlock_request() there mustn't be
412 * anything that could cause a page-fault. If the request was already
f9a2842e 413 * aborted bail out.
334f485d 414 */
d7133114 415static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
334f485d
MS
416{
417 int err = 0;
418 if (req) {
d7133114 419 spin_lock(&fc->lock);
f9a2842e 420 if (req->aborted)
334f485d
MS
421 err = -ENOENT;
422 else
423 req->locked = 1;
d7133114 424 spin_unlock(&fc->lock);
334f485d
MS
425 }
426 return err;
427}
428
429/*
f9a2842e 430 * Unlock request. If it was aborted during being locked, the
334f485d
MS
431 * requester thread is currently waiting for it to be unlocked, so
432 * wake it up.
433 */
d7133114 434static void unlock_request(struct fuse_conn *fc, struct fuse_req *req)
334f485d
MS
435{
436 if (req) {
d7133114 437 spin_lock(&fc->lock);
334f485d 438 req->locked = 0;
f9a2842e 439 if (req->aborted)
334f485d 440 wake_up(&req->waitq);
d7133114 441 spin_unlock(&fc->lock);
334f485d
MS
442 }
443}
444
445struct fuse_copy_state {
d7133114 446 struct fuse_conn *fc;
334f485d
MS
447 int write;
448 struct fuse_req *req;
449 const struct iovec *iov;
450 unsigned long nr_segs;
451 unsigned long seglen;
452 unsigned long addr;
453 struct page *pg;
454 void *mapaddr;
455 void *buf;
456 unsigned len;
457};
458
d7133114
MS
459static void fuse_copy_init(struct fuse_copy_state *cs, struct fuse_conn *fc,
460 int write, struct fuse_req *req,
461 const struct iovec *iov, unsigned long nr_segs)
334f485d
MS
462{
463 memset(cs, 0, sizeof(*cs));
d7133114 464 cs->fc = fc;
334f485d
MS
465 cs->write = write;
466 cs->req = req;
467 cs->iov = iov;
468 cs->nr_segs = nr_segs;
469}
470
471/* Unmap and put previous page of userspace buffer */
8bfc016d 472static void fuse_copy_finish(struct fuse_copy_state *cs)
334f485d
MS
473{
474 if (cs->mapaddr) {
475 kunmap_atomic(cs->mapaddr, KM_USER0);
476 if (cs->write) {
477 flush_dcache_page(cs->pg);
478 set_page_dirty_lock(cs->pg);
479 }
480 put_page(cs->pg);
481 cs->mapaddr = NULL;
482 }
483}
484
485/*
486 * Get another pagefull of userspace buffer, and map it to kernel
487 * address space, and lock request
488 */
489static int fuse_copy_fill(struct fuse_copy_state *cs)
490{
491 unsigned long offset;
492 int err;
493
d7133114 494 unlock_request(cs->fc, cs->req);
334f485d
MS
495 fuse_copy_finish(cs);
496 if (!cs->seglen) {
497 BUG_ON(!cs->nr_segs);
498 cs->seglen = cs->iov[0].iov_len;
499 cs->addr = (unsigned long) cs->iov[0].iov_base;
500 cs->iov ++;
501 cs->nr_segs --;
502 }
503 down_read(&current->mm->mmap_sem);
504 err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
505 &cs->pg, NULL);
506 up_read(&current->mm->mmap_sem);
507 if (err < 0)
508 return err;
509 BUG_ON(err != 1);
510 offset = cs->addr % PAGE_SIZE;
511 cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
512 cs->buf = cs->mapaddr + offset;
513 cs->len = min(PAGE_SIZE - offset, cs->seglen);
514 cs->seglen -= cs->len;
515 cs->addr += cs->len;
516
d7133114 517 return lock_request(cs->fc, cs->req);
334f485d
MS
518}
519
520/* Do as much copy to/from userspace buffer as we can */
8bfc016d 521static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
334f485d
MS
522{
523 unsigned ncpy = min(*size, cs->len);
524 if (val) {
525 if (cs->write)
526 memcpy(cs->buf, *val, ncpy);
527 else
528 memcpy(*val, cs->buf, ncpy);
529 *val += ncpy;
530 }
531 *size -= ncpy;
532 cs->len -= ncpy;
533 cs->buf += ncpy;
534 return ncpy;
535}
536
537/*
538 * Copy a page in the request to/from the userspace buffer. Must be
539 * done atomically
540 */
8bfc016d
MS
541static int fuse_copy_page(struct fuse_copy_state *cs, struct page *page,
542 unsigned offset, unsigned count, int zeroing)
334f485d
MS
543{
544 if (page && zeroing && count < PAGE_SIZE) {
545 void *mapaddr = kmap_atomic(page, KM_USER1);
546 memset(mapaddr, 0, PAGE_SIZE);
547 kunmap_atomic(mapaddr, KM_USER1);
548 }
549 while (count) {
550 int err;
551 if (!cs->len && (err = fuse_copy_fill(cs)))
552 return err;
553 if (page) {
554 void *mapaddr = kmap_atomic(page, KM_USER1);
555 void *buf = mapaddr + offset;
556 offset += fuse_copy_do(cs, &buf, &count);
557 kunmap_atomic(mapaddr, KM_USER1);
558 } else
559 offset += fuse_copy_do(cs, NULL, &count);
560 }
561 if (page && !cs->write)
562 flush_dcache_page(page);
563 return 0;
564}
565
566/* Copy pages in the request to/from userspace buffer */
567static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
568 int zeroing)
569{
570 unsigned i;
571 struct fuse_req *req = cs->req;
572 unsigned offset = req->page_offset;
573 unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);
574
575 for (i = 0; i < req->num_pages && (nbytes || zeroing); i++) {
576 struct page *page = req->pages[i];
577 int err = fuse_copy_page(cs, page, offset, count, zeroing);
578 if (err)
579 return err;
580
581 nbytes -= count;
582 count = min(nbytes, (unsigned) PAGE_SIZE);
583 offset = 0;
584 }
585 return 0;
586}
587
588/* Copy a single argument in the request to/from userspace buffer */
589static int fuse_copy_one(struct fuse_copy_state *cs, void *val, unsigned size)
590{
591 while (size) {
592 int err;
593 if (!cs->len && (err = fuse_copy_fill(cs)))
594 return err;
595 fuse_copy_do(cs, &val, &size);
596 }
597 return 0;
598}
599
600/* Copy request arguments to/from userspace buffer */
601static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
602 unsigned argpages, struct fuse_arg *args,
603 int zeroing)
604{
605 int err = 0;
606 unsigned i;
607
608 for (i = 0; !err && i < numargs; i++) {
609 struct fuse_arg *arg = &args[i];
610 if (i == numargs - 1 && argpages)
611 err = fuse_copy_pages(cs, arg->size, zeroing);
612 else
613 err = fuse_copy_one(cs, arg->value, arg->size);
614 }
615 return err;
616}
617
a4d27e75
MS
618static int request_pending(struct fuse_conn *fc)
619{
620 return !list_empty(&fc->pending) || !list_empty(&fc->interrupts);
621}
622
334f485d
MS
623/* Wait until a request is available on the pending list */
624static void request_wait(struct fuse_conn *fc)
625{
626 DECLARE_WAITQUEUE(wait, current);
627
628 add_wait_queue_exclusive(&fc->waitq, &wait);
a4d27e75 629 while (fc->connected && !request_pending(fc)) {
334f485d
MS
630 set_current_state(TASK_INTERRUPTIBLE);
631 if (signal_pending(current))
632 break;
633
d7133114 634 spin_unlock(&fc->lock);
334f485d 635 schedule();
d7133114 636 spin_lock(&fc->lock);
334f485d
MS
637 }
638 set_current_state(TASK_RUNNING);
639 remove_wait_queue(&fc->waitq, &wait);
640}
641
a4d27e75
MS
642/*
643 * Transfer an interrupt request to userspace
644 *
645 * Unlike other requests this is assembled on demand, without a need
646 * to allocate a separate fuse_req structure.
647 *
648 * Called with fc->lock held, releases it
649 */
650static int fuse_read_interrupt(struct fuse_conn *fc, struct fuse_req *req,
651 const struct iovec *iov, unsigned long nr_segs)
105f4d7a 652 __releases(fc->lock)
a4d27e75
MS
653{
654 struct fuse_copy_state cs;
655 struct fuse_in_header ih;
656 struct fuse_interrupt_in arg;
657 unsigned reqsize = sizeof(ih) + sizeof(arg);
658 int err;
659
660 list_del_init(&req->intr_entry);
661 req->intr_unique = fuse_get_unique(fc);
662 memset(&ih, 0, sizeof(ih));
663 memset(&arg, 0, sizeof(arg));
664 ih.len = reqsize;
665 ih.opcode = FUSE_INTERRUPT;
666 ih.unique = req->intr_unique;
667 arg.unique = req->in.h.unique;
668
669 spin_unlock(&fc->lock);
670 if (iov_length(iov, nr_segs) < reqsize)
671 return -EINVAL;
672
673 fuse_copy_init(&cs, fc, 1, NULL, iov, nr_segs);
674 err = fuse_copy_one(&cs, &ih, sizeof(ih));
675 if (!err)
676 err = fuse_copy_one(&cs, &arg, sizeof(arg));
677 fuse_copy_finish(&cs);
678
679 return err ? err : reqsize;
680}
681
334f485d
MS
682/*
683 * Read a single request into the userspace filesystem's buffer. This
684 * function waits until a request is available, then removes it from
685 * the pending list and copies request data to userspace buffer. If
f9a2842e
MS
686 * no reply is needed (FORGET) or request has been aborted or there
687 * was an error during the copying then it's finished by calling
334f485d
MS
688 * request_end(). Otherwise add it to the processing list, and set
689 * the 'sent' flag.
690 */
ee0b3e67
BP
691static ssize_t fuse_dev_read(struct kiocb *iocb, const struct iovec *iov,
692 unsigned long nr_segs, loff_t pos)
334f485d
MS
693{
694 int err;
334f485d
MS
695 struct fuse_req *req;
696 struct fuse_in *in;
697 struct fuse_copy_state cs;
698 unsigned reqsize;
ee0b3e67 699 struct file *file = iocb->ki_filp;
0720b315
MS
700 struct fuse_conn *fc = fuse_get_conn(file);
701 if (!fc)
702 return -EPERM;
334f485d 703
1d3d752b 704 restart:
d7133114 705 spin_lock(&fc->lock);
e5ac1d1e
JD
706 err = -EAGAIN;
707 if ((file->f_flags & O_NONBLOCK) && fc->connected &&
a4d27e75 708 !request_pending(fc))
e5ac1d1e
JD
709 goto err_unlock;
710
334f485d
MS
711 request_wait(fc);
712 err = -ENODEV;
9ba7cbba 713 if (!fc->connected)
334f485d
MS
714 goto err_unlock;
715 err = -ERESTARTSYS;
a4d27e75 716 if (!request_pending(fc))
334f485d
MS
717 goto err_unlock;
718
a4d27e75
MS
719 if (!list_empty(&fc->interrupts)) {
720 req = list_entry(fc->interrupts.next, struct fuse_req,
721 intr_entry);
722 return fuse_read_interrupt(fc, req, iov, nr_segs);
723 }
724
334f485d 725 req = list_entry(fc->pending.next, struct fuse_req, list);
83cfd493 726 req->state = FUSE_REQ_READING;
d77a1d5b 727 list_move(&req->list, &fc->io);
334f485d
MS
728
729 in = &req->in;
1d3d752b
MS
730 reqsize = in->h.len;
731 /* If request is too large, reply with an error and restart the read */
732 if (iov_length(iov, nr_segs) < reqsize) {
733 req->out.h.error = -EIO;
734 /* SETXATTR is special, since it may contain too large data */
735 if (in->h.opcode == FUSE_SETXATTR)
736 req->out.h.error = -E2BIG;
737 request_end(fc, req);
738 goto restart;
334f485d 739 }
d7133114
MS
740 spin_unlock(&fc->lock);
741 fuse_copy_init(&cs, fc, 1, req, iov, nr_segs);
1d3d752b
MS
742 err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
743 if (!err)
744 err = fuse_copy_args(&cs, in->numargs, in->argpages,
745 (struct fuse_arg *) in->args, 0);
334f485d 746 fuse_copy_finish(&cs);
d7133114 747 spin_lock(&fc->lock);
334f485d 748 req->locked = 0;
f9a2842e 749 if (!err && req->aborted)
334f485d
MS
750 err = -ENOENT;
751 if (err) {
f9a2842e 752 if (!req->aborted)
334f485d
MS
753 req->out.h.error = -EIO;
754 request_end(fc, req);
755 return err;
756 }
757 if (!req->isreply)
758 request_end(fc, req);
759 else {
83cfd493 760 req->state = FUSE_REQ_SENT;
d77a1d5b 761 list_move_tail(&req->list, &fc->processing);
a4d27e75
MS
762 if (req->interrupted)
763 queue_interrupt(fc, req);
d7133114 764 spin_unlock(&fc->lock);
334f485d
MS
765 }
766 return reqsize;
767
768 err_unlock:
d7133114 769 spin_unlock(&fc->lock);
334f485d
MS
770 return err;
771}
772
334f485d
MS
773/* Look up request on processing list by unique ID */
774static struct fuse_req *request_find(struct fuse_conn *fc, u64 unique)
775{
776 struct list_head *entry;
777
778 list_for_each(entry, &fc->processing) {
779 struct fuse_req *req;
780 req = list_entry(entry, struct fuse_req, list);
a4d27e75 781 if (req->in.h.unique == unique || req->intr_unique == unique)
334f485d
MS
782 return req;
783 }
784 return NULL;
785}
786
787static int copy_out_args(struct fuse_copy_state *cs, struct fuse_out *out,
788 unsigned nbytes)
789{
790 unsigned reqsize = sizeof(struct fuse_out_header);
791
792 if (out->h.error)
793 return nbytes != reqsize ? -EINVAL : 0;
794
795 reqsize += len_args(out->numargs, out->args);
796
797 if (reqsize < nbytes || (reqsize > nbytes && !out->argvar))
798 return -EINVAL;
799 else if (reqsize > nbytes) {
800 struct fuse_arg *lastarg = &out->args[out->numargs-1];
801 unsigned diffsize = reqsize - nbytes;
802 if (diffsize > lastarg->size)
803 return -EINVAL;
804 lastarg->size -= diffsize;
805 }
806 return fuse_copy_args(cs, out->numargs, out->argpages, out->args,
807 out->page_zeroing);
808}
809
810/*
811 * Write a single reply to a request. First the header is copied from
812 * the write buffer. The request is then searched on the processing
813 * list by the unique ID found in the header. If found, then remove
814 * it from the list and copy the rest of the buffer to the request.
815 * The request is finished by calling request_end()
816 */
ee0b3e67
BP
817static ssize_t fuse_dev_write(struct kiocb *iocb, const struct iovec *iov,
818 unsigned long nr_segs, loff_t pos)
334f485d
MS
819{
820 int err;
821 unsigned nbytes = iov_length(iov, nr_segs);
822 struct fuse_req *req;
823 struct fuse_out_header oh;
824 struct fuse_copy_state cs;
ee0b3e67 825 struct fuse_conn *fc = fuse_get_conn(iocb->ki_filp);
334f485d 826 if (!fc)
a87046d8 827 return -EPERM;
334f485d 828
d7133114 829 fuse_copy_init(&cs, fc, 0, NULL, iov, nr_segs);
334f485d
MS
830 if (nbytes < sizeof(struct fuse_out_header))
831 return -EINVAL;
832
833 err = fuse_copy_one(&cs, &oh, sizeof(oh));
834 if (err)
835 goto err_finish;
836 err = -EINVAL;
837 if (!oh.unique || oh.error <= -1000 || oh.error > 0 ||
838 oh.len != nbytes)
839 goto err_finish;
840
d7133114 841 spin_lock(&fc->lock);
69a53bf2
MS
842 err = -ENOENT;
843 if (!fc->connected)
844 goto err_unlock;
845
334f485d 846 req = request_find(fc, oh.unique);
334f485d
MS
847 if (!req)
848 goto err_unlock;
849
f9a2842e 850 if (req->aborted) {
d7133114 851 spin_unlock(&fc->lock);
334f485d 852 fuse_copy_finish(&cs);
d7133114 853 spin_lock(&fc->lock);
222f1d69 854 request_end(fc, req);
334f485d
MS
855 return -ENOENT;
856 }
a4d27e75
MS
857 /* Is it an interrupt reply? */
858 if (req->intr_unique == oh.unique) {
859 err = -EINVAL;
860 if (nbytes != sizeof(struct fuse_out_header))
861 goto err_unlock;
862
863 if (oh.error == -ENOSYS)
864 fc->no_interrupt = 1;
865 else if (oh.error == -EAGAIN)
866 queue_interrupt(fc, req);
867
868 spin_unlock(&fc->lock);
869 fuse_copy_finish(&cs);
870 return nbytes;
871 }
872
873 req->state = FUSE_REQ_WRITING;
d77a1d5b 874 list_move(&req->list, &fc->io);
334f485d
MS
875 req->out.h = oh;
876 req->locked = 1;
877 cs.req = req;
d7133114 878 spin_unlock(&fc->lock);
334f485d
MS
879
880 err = copy_out_args(&cs, &req->out, nbytes);
881 fuse_copy_finish(&cs);
882
d7133114 883 spin_lock(&fc->lock);
334f485d
MS
884 req->locked = 0;
885 if (!err) {
f9a2842e 886 if (req->aborted)
334f485d 887 err = -ENOENT;
f9a2842e 888 } else if (!req->aborted)
334f485d
MS
889 req->out.h.error = -EIO;
890 request_end(fc, req);
891
892 return err ? err : nbytes;
893
894 err_unlock:
d7133114 895 spin_unlock(&fc->lock);
334f485d
MS
896 err_finish:
897 fuse_copy_finish(&cs);
898 return err;
899}
900
334f485d
MS
901static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
902{
334f485d 903 unsigned mask = POLLOUT | POLLWRNORM;
7025d9ad 904 struct fuse_conn *fc = fuse_get_conn(file);
334f485d 905 if (!fc)
7025d9ad 906 return POLLERR;
334f485d
MS
907
908 poll_wait(file, &fc->waitq, wait);
909
d7133114 910 spin_lock(&fc->lock);
7025d9ad
MS
911 if (!fc->connected)
912 mask = POLLERR;
a4d27e75 913 else if (request_pending(fc))
7025d9ad 914 mask |= POLLIN | POLLRDNORM;
d7133114 915 spin_unlock(&fc->lock);
334f485d
MS
916
917 return mask;
918}
919
69a53bf2
MS
920/*
921 * Abort all requests on the given list (pending or processing)
922 *
d7133114 923 * This function releases and reacquires fc->lock
69a53bf2 924 */
334f485d
MS
925static void end_requests(struct fuse_conn *fc, struct list_head *head)
926{
927 while (!list_empty(head)) {
928 struct fuse_req *req;
929 req = list_entry(head->next, struct fuse_req, list);
334f485d
MS
930 req->out.h.error = -ECONNABORTED;
931 request_end(fc, req);
d7133114 932 spin_lock(&fc->lock);
334f485d
MS
933 }
934}
935
69a53bf2
MS
936/*
937 * Abort requests under I/O
938 *
f9a2842e 939 * The requests are set to aborted and finished, and the request
69a53bf2
MS
940 * waiter is woken up. This will make request_wait_answer() wait
941 * until the request is unlocked and then return.
64c6d8ed
MS
942 *
943 * If the request is asynchronous, then the end function needs to be
944 * called after waiting for the request to be unlocked (if it was
945 * locked).
69a53bf2
MS
946 */
947static void end_io_requests(struct fuse_conn *fc)
948{
949 while (!list_empty(&fc->io)) {
64c6d8ed
MS
950 struct fuse_req *req =
951 list_entry(fc->io.next, struct fuse_req, list);
952 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
953
f9a2842e 954 req->aborted = 1;
69a53bf2
MS
955 req->out.h.error = -ECONNABORTED;
956 req->state = FUSE_REQ_FINISHED;
957 list_del_init(&req->list);
958 wake_up(&req->waitq);
64c6d8ed
MS
959 if (end) {
960 req->end = NULL;
961 /* The end function will consume this reference */
962 __fuse_get_request(req);
d7133114 963 spin_unlock(&fc->lock);
64c6d8ed
MS
964 wait_event(req->waitq, !req->locked);
965 end(fc, req);
d7133114 966 spin_lock(&fc->lock);
64c6d8ed 967 }
69a53bf2
MS
968 }
969}
970
971/*
972 * Abort all requests.
973 *
974 * Emergency exit in case of a malicious or accidental deadlock, or
975 * just a hung filesystem.
976 *
977 * The same effect is usually achievable through killing the
978 * filesystem daemon and all users of the filesystem. The exception
979 * is the combination of an asynchronous request and the tricky
980 * deadlock (see Documentation/filesystems/fuse.txt).
981 *
982 * During the aborting, progression of requests from the pending and
983 * processing lists onto the io list, and progression of new requests
984 * onto the pending list is prevented by req->connected being false.
985 *
986 * Progression of requests under I/O to the processing list is
f9a2842e
MS
987 * prevented by the req->aborted flag being true for these requests.
988 * For this reason requests on the io list must be aborted first.
69a53bf2
MS
989 */
990void fuse_abort_conn(struct fuse_conn *fc)
991{
d7133114 992 spin_lock(&fc->lock);
69a53bf2
MS
993 if (fc->connected) {
994 fc->connected = 0;
51eb01e7 995 fc->blocked = 0;
69a53bf2
MS
996 end_io_requests(fc);
997 end_requests(fc, &fc->pending);
998 end_requests(fc, &fc->processing);
999 wake_up_all(&fc->waitq);
51eb01e7 1000 wake_up_all(&fc->blocked_waitq);
385a17bf 1001 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
69a53bf2 1002 }
d7133114 1003 spin_unlock(&fc->lock);
69a53bf2
MS
1004}
1005
334f485d
MS
1006static int fuse_dev_release(struct inode *inode, struct file *file)
1007{
0720b315 1008 struct fuse_conn *fc = fuse_get_conn(file);
334f485d 1009 if (fc) {
d7133114 1010 spin_lock(&fc->lock);
1e9a4ed9 1011 fc->connected = 0;
334f485d
MS
1012 end_requests(fc, &fc->pending);
1013 end_requests(fc, &fc->processing);
d7133114 1014 spin_unlock(&fc->lock);
385a17bf 1015 fasync_helper(-1, file, 0, &fc->fasync);
bafa9654 1016 fuse_conn_put(fc);
385a17bf 1017 }
f543f253 1018
334f485d
MS
1019 return 0;
1020}
1021
385a17bf
JD
1022static int fuse_dev_fasync(int fd, struct file *file, int on)
1023{
1024 struct fuse_conn *fc = fuse_get_conn(file);
1025 if (!fc)
a87046d8 1026 return -EPERM;
385a17bf
JD
1027
1028 /* No locking - fasync_helper does its own locking */
1029 return fasync_helper(fd, file, on, &fc->fasync);
1030}
1031
4b6f5d20 1032const struct file_operations fuse_dev_operations = {
334f485d
MS
1033 .owner = THIS_MODULE,
1034 .llseek = no_llseek,
ee0b3e67
BP
1035 .read = do_sync_read,
1036 .aio_read = fuse_dev_read,
1037 .write = do_sync_write,
1038 .aio_write = fuse_dev_write,
334f485d
MS
1039 .poll = fuse_dev_poll,
1040 .release = fuse_dev_release,
385a17bf 1041 .fasync = fuse_dev_fasync,
334f485d
MS
1042};
1043
1044static struct miscdevice fuse_miscdevice = {
1045 .minor = FUSE_MINOR,
1046 .name = "fuse",
1047 .fops = &fuse_dev_operations,
1048};
1049
1050int __init fuse_dev_init(void)
1051{
1052 int err = -ENOMEM;
1053 fuse_req_cachep = kmem_cache_create("fuse_request",
1054 sizeof(struct fuse_req),
20c2df83 1055 0, 0, NULL);
334f485d
MS
1056 if (!fuse_req_cachep)
1057 goto out;
1058
1059 err = misc_register(&fuse_miscdevice);
1060 if (err)
1061 goto out_cache_clean;
1062
1063 return 0;
1064
1065 out_cache_clean:
1066 kmem_cache_destroy(fuse_req_cachep);
1067 out:
1068 return err;
1069}
1070
1071void fuse_dev_cleanup(void)
1072{
1073 misc_deregister(&fuse_miscdevice);
1074 kmem_cache_destroy(fuse_req_cachep);
1075}
This page took 0.315515 seconds and 5 git commands to generate.