2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
5 This program can be distributed under the terms of the GNU GPL.
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>
20 MODULE_ALIAS_MISCDEV(FUSE_MINOR);
22 static kmem_cache_t *fuse_req_cachep;
24 static struct fuse_conn *fuse_get_conn(struct file *file)
27 * Lockless access is OK, because file->private data is set
28 * once during mount and is valid until the file is released.
30 return file->private_data;
33 static void fuse_request_init(struct fuse_req *req)
35 memset(req, 0, sizeof(*req));
36 INIT_LIST_HEAD(&req->list);
37 init_waitqueue_head(&req->waitq);
38 atomic_set(&req->count, 1);
41 struct fuse_req *fuse_request_alloc(void)
43 struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, SLAB_KERNEL);
45 fuse_request_init(req);
49 void fuse_request_free(struct fuse_req *req)
51 kmem_cache_free(fuse_req_cachep, req);
54 static void block_sigs(sigset_t *oldset)
58 siginitsetinv(&mask, sigmask(SIGKILL));
59 sigprocmask(SIG_BLOCK, &mask, oldset);
62 static void restore_sigs(sigset_t *oldset)
64 sigprocmask(SIG_SETMASK, oldset, NULL);
68 * Reset request, so that it can be reused
70 * The caller must be _very_ careful to make sure, that it is holding
71 * the only reference to req
73 void fuse_reset_request(struct fuse_req *req)
75 int preallocated = req->preallocated;
76 BUG_ON(atomic_read(&req->count) != 1);
77 fuse_request_init(req);
78 req->preallocated = preallocated;
81 static void __fuse_get_request(struct fuse_req *req)
83 atomic_inc(&req->count);
86 /* Must be called with > 1 refcount */
87 static void __fuse_put_request(struct fuse_req *req)
89 BUG_ON(atomic_read(&req->count) < 2);
90 atomic_dec(&req->count);
93 static struct fuse_req *do_get_request(struct fuse_conn *fc)
98 BUG_ON(list_empty(&fc->unused_list));
99 req = list_entry(fc->unused_list.next, struct fuse_req, list);
100 list_del_init(&req->list);
101 spin_unlock(&fc->lock);
102 fuse_request_init(req);
103 req->preallocated = 1;
104 req->in.h.uid = current->fsuid;
105 req->in.h.gid = current->fsgid;
106 req->in.h.pid = current->pid;
110 /* This can return NULL, but only in case it's interrupted by a SIGKILL */
111 struct fuse_req *fuse_get_request(struct fuse_conn *fc)
116 atomic_inc(&fc->num_waiting);
118 intr = down_interruptible(&fc->outstanding_sem);
119 restore_sigs(&oldset);
121 atomic_dec(&fc->num_waiting);
124 return do_get_request(fc);
127 /* Must be called with fc->lock held */
128 static void fuse_putback_request(struct fuse_conn *fc, struct fuse_req *req)
130 if (req->preallocated) {
131 atomic_dec(&fc->num_waiting);
132 list_add(&req->list, &fc->unused_list);
134 fuse_request_free(req);
136 /* If we are in debt decrease that first */
137 if (fc->outstanding_debt)
138 fc->outstanding_debt--;
140 up(&fc->outstanding_sem);
143 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
145 if (atomic_dec_and_test(&req->count)) {
146 spin_lock(&fc->lock);
147 fuse_putback_request(fc, req);
148 spin_unlock(&fc->lock);
152 static void fuse_put_request_locked(struct fuse_conn *fc, struct fuse_req *req)
154 if (atomic_dec_and_test(&req->count))
155 fuse_putback_request(fc, req);
158 void fuse_release_background(struct fuse_conn *fc, struct fuse_req *req)
164 spin_lock(&fc->lock);
165 list_del(&req->bg_entry);
166 spin_unlock(&fc->lock);
170 * This function is called when a request is finished. Either a reply
171 * has arrived or it was interrupted (and not yet sent) or some error
172 * occurred during communication with userspace, or the device file
173 * was closed. In case of a background request the reference to the
174 * stored objects are released. The requester thread is woken up (if
175 * still waiting), the 'end' callback is called if given, else the
176 * reference to the request is released
178 * Releasing extra reference for foreground requests must be done
179 * within the same locked region as setting state to finished. This
180 * is because fuse_reset_request() may be called after request is
181 * finished and it must be the sole possessor. If request is
182 * interrupted and put in the background, it will return with an error
183 * and hence never be reset and reused.
185 * Called with fc->lock, unlocks it
187 static void request_end(struct fuse_conn *fc, struct fuse_req *req)
189 list_del(&req->list);
190 req->state = FUSE_REQ_FINISHED;
191 if (!req->background) {
192 wake_up(&req->waitq);
193 fuse_put_request_locked(fc, req);
194 spin_unlock(&fc->lock);
196 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
198 spin_unlock(&fc->lock);
199 down_read(&fc->sbput_sem);
201 fuse_release_background(fc, req);
202 up_read(&fc->sbput_sem);
206 fuse_put_request(fc, req);
211 * Unfortunately request interruption not just solves the deadlock
212 * problem, it causes problems too. These stem from the fact, that an
213 * interrupted request is continued to be processed in userspace,
214 * while all the locks and object references (inode and file) held
215 * during the operation are released.
217 * To release the locks is exactly why there's a need to interrupt the
218 * request, so there's not a lot that can be done about this, except
219 * introduce additional locking in userspace.
221 * More important is to keep inode and file references until userspace
222 * has replied, otherwise FORGET and RELEASE could be sent while the
223 * inode/file is still used by the filesystem.
225 * For this reason the concept of "background" request is introduced.
226 * An interrupted request is backgrounded if it has been already sent
227 * to userspace. Backgrounding involves getting an extra reference to
228 * inode(s) or file used in the request, and adding the request to
229 * fc->background list. When a reply is received for a background
230 * request, the object references are released, and the request is
231 * removed from the list. If the filesystem is unmounted while there
232 * are still background requests, the list is walked and references
233 * are released as if a reply was received.
235 * There's one more use for a background request. The RELEASE message is
236 * always sent as background, since it doesn't return an error or
239 static void background_request(struct fuse_conn *fc, struct fuse_req *req)
242 list_add(&req->bg_entry, &fc->background);
244 req->inode = igrab(req->inode);
246 req->inode2 = igrab(req->inode2);
251 /* Called with fc->lock held. Releases, and then reacquires it. */
252 static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
256 spin_unlock(&fc->lock);
258 wait_event_interruptible(req->waitq, req->state == FUSE_REQ_FINISHED);
259 restore_sigs(&oldset);
260 spin_lock(&fc->lock);
261 if (req->state == FUSE_REQ_FINISHED && !req->interrupted)
264 if (!req->interrupted) {
265 req->out.h.error = -EINTR;
266 req->interrupted = 1;
269 /* This is uninterruptible sleep, because data is
270 being copied to/from the buffers of req. During
271 locked state, there mustn't be any filesystem
272 operation (e.g. page fault), since that could lead
274 spin_unlock(&fc->lock);
275 wait_event(req->waitq, !req->locked);
276 spin_lock(&fc->lock);
278 if (req->state == FUSE_REQ_PENDING) {
279 list_del(&req->list);
280 __fuse_put_request(req);
281 } else if (req->state == FUSE_REQ_SENT)
282 background_request(fc, req);
285 static unsigned len_args(unsigned numargs, struct fuse_arg *args)
290 for (i = 0; i < numargs; i++)
291 nbytes += args[i].size;
296 static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
299 /* zero is special */
302 req->in.h.unique = fc->reqctr;
303 req->in.h.len = sizeof(struct fuse_in_header) +
304 len_args(req->in.numargs, (struct fuse_arg *) req->in.args);
305 if (!req->preallocated) {
306 /* If request is not preallocated (either FORGET or
307 RELEASE), then still decrease outstanding_sem, so
308 user can't open infinite number of files while not
309 processing the RELEASE requests. However for
310 efficiency do it without blocking, so if down()
311 would block, just increase the debt instead */
312 if (down_trylock(&fc->outstanding_sem))
313 fc->outstanding_debt++;
315 list_add_tail(&req->list, &fc->pending);
316 req->state = FUSE_REQ_PENDING;
318 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
322 * This can only be interrupted by a SIGKILL
324 void request_send(struct fuse_conn *fc, struct fuse_req *req)
327 spin_lock(&fc->lock);
329 req->out.h.error = -ENOTCONN;
330 else if (fc->conn_error)
331 req->out.h.error = -ECONNREFUSED;
333 queue_request(fc, req);
334 /* acquire extra reference, since request is still needed
335 after request_end() */
336 __fuse_get_request(req);
338 request_wait_answer(fc, req);
340 spin_unlock(&fc->lock);
343 static void request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
345 spin_lock(&fc->lock);
347 queue_request(fc, req);
348 spin_unlock(&fc->lock);
350 req->out.h.error = -ENOTCONN;
351 request_end(fc, req);
355 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req)
358 request_send_nowait(fc, req);
361 void request_send_background(struct fuse_conn *fc, struct fuse_req *req)
364 spin_lock(&fc->lock);
365 background_request(fc, req);
366 spin_unlock(&fc->lock);
367 request_send_nowait(fc, req);
371 * Lock the request. Up to the next unlock_request() there mustn't be
372 * anything that could cause a page-fault. If the request was already
373 * interrupted bail out.
375 static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
379 spin_lock(&fc->lock);
380 if (req->interrupted)
384 spin_unlock(&fc->lock);
390 * Unlock request. If it was interrupted during being locked, the
391 * requester thread is currently waiting for it to be unlocked, so
394 static void unlock_request(struct fuse_conn *fc, struct fuse_req *req)
397 spin_lock(&fc->lock);
399 if (req->interrupted)
400 wake_up(&req->waitq);
401 spin_unlock(&fc->lock);
405 struct fuse_copy_state {
406 struct fuse_conn *fc;
408 struct fuse_req *req;
409 const struct iovec *iov;
410 unsigned long nr_segs;
411 unsigned long seglen;
419 static void fuse_copy_init(struct fuse_copy_state *cs, struct fuse_conn *fc,
420 int write, struct fuse_req *req,
421 const struct iovec *iov, unsigned long nr_segs)
423 memset(cs, 0, sizeof(*cs));
428 cs->nr_segs = nr_segs;
431 /* Unmap and put previous page of userspace buffer */
432 static void fuse_copy_finish(struct fuse_copy_state *cs)
435 kunmap_atomic(cs->mapaddr, KM_USER0);
437 flush_dcache_page(cs->pg);
438 set_page_dirty_lock(cs->pg);
446 * Get another pagefull of userspace buffer, and map it to kernel
447 * address space, and lock request
449 static int fuse_copy_fill(struct fuse_copy_state *cs)
451 unsigned long offset;
454 unlock_request(cs->fc, cs->req);
455 fuse_copy_finish(cs);
457 BUG_ON(!cs->nr_segs);
458 cs->seglen = cs->iov[0].iov_len;
459 cs->addr = (unsigned long) cs->iov[0].iov_base;
463 down_read(¤t->mm->mmap_sem);
464 err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
466 up_read(¤t->mm->mmap_sem);
470 offset = cs->addr % PAGE_SIZE;
471 cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
472 cs->buf = cs->mapaddr + offset;
473 cs->len = min(PAGE_SIZE - offset, cs->seglen);
474 cs->seglen -= cs->len;
477 return lock_request(cs->fc, cs->req);
480 /* Do as much copy to/from userspace buffer as we can */
481 static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
483 unsigned ncpy = min(*size, cs->len);
486 memcpy(cs->buf, *val, ncpy);
488 memcpy(*val, cs->buf, ncpy);
498 * Copy a page in the request to/from the userspace buffer. Must be
501 static int fuse_copy_page(struct fuse_copy_state *cs, struct page *page,
502 unsigned offset, unsigned count, int zeroing)
504 if (page && zeroing && count < PAGE_SIZE) {
505 void *mapaddr = kmap_atomic(page, KM_USER1);
506 memset(mapaddr, 0, PAGE_SIZE);
507 kunmap_atomic(mapaddr, KM_USER1);
511 if (!cs->len && (err = fuse_copy_fill(cs)))
514 void *mapaddr = kmap_atomic(page, KM_USER1);
515 void *buf = mapaddr + offset;
516 offset += fuse_copy_do(cs, &buf, &count);
517 kunmap_atomic(mapaddr, KM_USER1);
519 offset += fuse_copy_do(cs, NULL, &count);
521 if (page && !cs->write)
522 flush_dcache_page(page);
526 /* Copy pages in the request to/from userspace buffer */
527 static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
531 struct fuse_req *req = cs->req;
532 unsigned offset = req->page_offset;
533 unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);
535 for (i = 0; i < req->num_pages && (nbytes || zeroing); i++) {
536 struct page *page = req->pages[i];
537 int err = fuse_copy_page(cs, page, offset, count, zeroing);
542 count = min(nbytes, (unsigned) PAGE_SIZE);
548 /* Copy a single argument in the request to/from userspace buffer */
549 static int fuse_copy_one(struct fuse_copy_state *cs, void *val, unsigned size)
553 if (!cs->len && (err = fuse_copy_fill(cs)))
555 fuse_copy_do(cs, &val, &size);
560 /* Copy request arguments to/from userspace buffer */
561 static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
562 unsigned argpages, struct fuse_arg *args,
568 for (i = 0; !err && i < numargs; i++) {
569 struct fuse_arg *arg = &args[i];
570 if (i == numargs - 1 && argpages)
571 err = fuse_copy_pages(cs, arg->size, zeroing);
573 err = fuse_copy_one(cs, arg->value, arg->size);
578 /* Wait until a request is available on the pending list */
579 static void request_wait(struct fuse_conn *fc)
581 DECLARE_WAITQUEUE(wait, current);
583 add_wait_queue_exclusive(&fc->waitq, &wait);
584 while (fc->connected && list_empty(&fc->pending)) {
585 set_current_state(TASK_INTERRUPTIBLE);
586 if (signal_pending(current))
589 spin_unlock(&fc->lock);
591 spin_lock(&fc->lock);
593 set_current_state(TASK_RUNNING);
594 remove_wait_queue(&fc->waitq, &wait);
598 * Read a single request into the userspace filesystem's buffer. This
599 * function waits until a request is available, then removes it from
600 * the pending list and copies request data to userspace buffer. If
601 * no reply is needed (FORGET) or request has been interrupted or
602 * there was an error during the copying then it's finished by calling
603 * request_end(). Otherwise add it to the processing list, and set
606 static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
607 unsigned long nr_segs, loff_t *off)
610 struct fuse_req *req;
612 struct fuse_copy_state cs;
614 struct fuse_conn *fc = fuse_get_conn(file);
619 spin_lock(&fc->lock);
621 if ((file->f_flags & O_NONBLOCK) && fc->connected &&
622 list_empty(&fc->pending))
630 if (list_empty(&fc->pending))
633 req = list_entry(fc->pending.next, struct fuse_req, list);
634 req->state = FUSE_REQ_READING;
635 list_move(&req->list, &fc->io);
639 /* If request is too large, reply with an error and restart the read */
640 if (iov_length(iov, nr_segs) < reqsize) {
641 req->out.h.error = -EIO;
642 /* SETXATTR is special, since it may contain too large data */
643 if (in->h.opcode == FUSE_SETXATTR)
644 req->out.h.error = -E2BIG;
645 request_end(fc, req);
648 spin_unlock(&fc->lock);
649 fuse_copy_init(&cs, fc, 1, req, iov, nr_segs);
650 err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
652 err = fuse_copy_args(&cs, in->numargs, in->argpages,
653 (struct fuse_arg *) in->args, 0);
654 fuse_copy_finish(&cs);
655 spin_lock(&fc->lock);
657 if (!err && req->interrupted)
660 if (!req->interrupted)
661 req->out.h.error = -EIO;
662 request_end(fc, req);
666 request_end(fc, req);
668 req->state = FUSE_REQ_SENT;
669 list_move_tail(&req->list, &fc->processing);
670 spin_unlock(&fc->lock);
675 spin_unlock(&fc->lock);
679 static ssize_t fuse_dev_read(struct file *file, char __user *buf,
680 size_t nbytes, loff_t *off)
683 iov.iov_len = nbytes;
685 return fuse_dev_readv(file, &iov, 1, off);
688 /* Look up request on processing list by unique ID */
689 static struct fuse_req *request_find(struct fuse_conn *fc, u64 unique)
691 struct list_head *entry;
693 list_for_each(entry, &fc->processing) {
694 struct fuse_req *req;
695 req = list_entry(entry, struct fuse_req, list);
696 if (req->in.h.unique == unique)
702 static int copy_out_args(struct fuse_copy_state *cs, struct fuse_out *out,
705 unsigned reqsize = sizeof(struct fuse_out_header);
708 return nbytes != reqsize ? -EINVAL : 0;
710 reqsize += len_args(out->numargs, out->args);
712 if (reqsize < nbytes || (reqsize > nbytes && !out->argvar))
714 else if (reqsize > nbytes) {
715 struct fuse_arg *lastarg = &out->args[out->numargs-1];
716 unsigned diffsize = reqsize - nbytes;
717 if (diffsize > lastarg->size)
719 lastarg->size -= diffsize;
721 return fuse_copy_args(cs, out->numargs, out->argpages, out->args,
726 * Write a single reply to a request. First the header is copied from
727 * the write buffer. The request is then searched on the processing
728 * list by the unique ID found in the header. If found, then remove
729 * it from the list and copy the rest of the buffer to the request.
730 * The request is finished by calling request_end()
732 static ssize_t fuse_dev_writev(struct file *file, const struct iovec *iov,
733 unsigned long nr_segs, loff_t *off)
736 unsigned nbytes = iov_length(iov, nr_segs);
737 struct fuse_req *req;
738 struct fuse_out_header oh;
739 struct fuse_copy_state cs;
740 struct fuse_conn *fc = fuse_get_conn(file);
744 fuse_copy_init(&cs, fc, 0, NULL, iov, nr_segs);
745 if (nbytes < sizeof(struct fuse_out_header))
748 err = fuse_copy_one(&cs, &oh, sizeof(oh));
752 if (!oh.unique || oh.error <= -1000 || oh.error > 0 ||
756 spin_lock(&fc->lock);
761 req = request_find(fc, oh.unique);
766 if (req->interrupted) {
767 spin_unlock(&fc->lock);
768 fuse_copy_finish(&cs);
769 spin_lock(&fc->lock);
770 request_end(fc, req);
773 list_move(&req->list, &fc->io);
777 spin_unlock(&fc->lock);
779 err = copy_out_args(&cs, &req->out, nbytes);
780 fuse_copy_finish(&cs);
782 spin_lock(&fc->lock);
785 if (req->interrupted)
787 } else if (!req->interrupted)
788 req->out.h.error = -EIO;
789 request_end(fc, req);
791 return err ? err : nbytes;
794 spin_unlock(&fc->lock);
796 fuse_copy_finish(&cs);
800 static ssize_t fuse_dev_write(struct file *file, const char __user *buf,
801 size_t nbytes, loff_t *off)
804 iov.iov_len = nbytes;
805 iov.iov_base = (char __user *) buf;
806 return fuse_dev_writev(file, &iov, 1, off);
809 static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
811 unsigned mask = POLLOUT | POLLWRNORM;
812 struct fuse_conn *fc = fuse_get_conn(file);
816 poll_wait(file, &fc->waitq, wait);
818 spin_lock(&fc->lock);
821 else if (!list_empty(&fc->pending))
822 mask |= POLLIN | POLLRDNORM;
823 spin_unlock(&fc->lock);
829 * Abort all requests on the given list (pending or processing)
831 * This function releases and reacquires fc->lock
833 static void end_requests(struct fuse_conn *fc, struct list_head *head)
835 while (!list_empty(head)) {
836 struct fuse_req *req;
837 req = list_entry(head->next, struct fuse_req, list);
838 req->out.h.error = -ECONNABORTED;
839 request_end(fc, req);
840 spin_lock(&fc->lock);
845 * Abort requests under I/O
847 * The requests are set to interrupted and finished, and the request
848 * waiter is woken up. This will make request_wait_answer() wait
849 * until the request is unlocked and then return.
851 * If the request is asynchronous, then the end function needs to be
852 * called after waiting for the request to be unlocked (if it was
855 static void end_io_requests(struct fuse_conn *fc)
857 while (!list_empty(&fc->io)) {
858 struct fuse_req *req =
859 list_entry(fc->io.next, struct fuse_req, list);
860 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
862 req->interrupted = 1;
863 req->out.h.error = -ECONNABORTED;
864 req->state = FUSE_REQ_FINISHED;
865 list_del_init(&req->list);
866 wake_up(&req->waitq);
869 /* The end function will consume this reference */
870 __fuse_get_request(req);
871 spin_unlock(&fc->lock);
872 wait_event(req->waitq, !req->locked);
874 spin_lock(&fc->lock);
880 * Abort all requests.
882 * Emergency exit in case of a malicious or accidental deadlock, or
883 * just a hung filesystem.
885 * The same effect is usually achievable through killing the
886 * filesystem daemon and all users of the filesystem. The exception
887 * is the combination of an asynchronous request and the tricky
888 * deadlock (see Documentation/filesystems/fuse.txt).
890 * During the aborting, progression of requests from the pending and
891 * processing lists onto the io list, and progression of new requests
892 * onto the pending list is prevented by req->connected being false.
894 * Progression of requests under I/O to the processing list is
895 * prevented by the req->interrupted flag being true for these
896 * requests. For this reason requests on the io list must be aborted
899 void fuse_abort_conn(struct fuse_conn *fc)
901 spin_lock(&fc->lock);
905 end_requests(fc, &fc->pending);
906 end_requests(fc, &fc->processing);
907 wake_up_all(&fc->waitq);
908 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
910 spin_unlock(&fc->lock);
913 static int fuse_dev_release(struct inode *inode, struct file *file)
915 struct fuse_conn *fc = fuse_get_conn(file);
917 spin_lock(&fc->lock);
919 end_requests(fc, &fc->pending);
920 end_requests(fc, &fc->processing);
921 spin_unlock(&fc->lock);
922 fasync_helper(-1, file, 0, &fc->fasync);
923 kobject_put(&fc->kobj);
929 static int fuse_dev_fasync(int fd, struct file *file, int on)
931 struct fuse_conn *fc = fuse_get_conn(file);
935 /* No locking - fasync_helper does its own locking */
936 return fasync_helper(fd, file, on, &fc->fasync);
939 const struct file_operations fuse_dev_operations = {
940 .owner = THIS_MODULE,
942 .read = fuse_dev_read,
943 .readv = fuse_dev_readv,
944 .write = fuse_dev_write,
945 .writev = fuse_dev_writev,
946 .poll = fuse_dev_poll,
947 .release = fuse_dev_release,
948 .fasync = fuse_dev_fasync,
951 static struct miscdevice fuse_miscdevice = {
954 .fops = &fuse_dev_operations,
957 int __init fuse_dev_init(void)
960 fuse_req_cachep = kmem_cache_create("fuse_request",
961 sizeof(struct fuse_req),
963 if (!fuse_req_cachep)
966 err = misc_register(&fuse_miscdevice);
968 goto out_cache_clean;
973 kmem_cache_destroy(fuse_req_cachep);
978 void fuse_dev_cleanup(void)
980 misc_deregister(&fuse_miscdevice);
981 kmem_cache_destroy(fuse_req_cachep);