git.oblomov.eu Git - linux-2.6/blob - fs/fuse/dev.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2005  Miklos Szeredi <miklos@szeredi.hu>
   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
  20 MODULE_ALIAS_MISCDEV(FUSE_MINOR);
  21
  22 static kmem_cache_t *fuse_req_cachep;
  23
  24 static inline struct fuse_conn *fuse_get_conn(struct file *file)
  25 {
  26         struct fuse_conn *fc;
  27         spin_lock(&fuse_lock);
  28         fc = file->private_data;
  29         if (fc && !fc->mounted)
  30                 fc = NULL;
  31         spin_unlock(&fuse_lock);
  32         return fc;
  33 }
  34
  35 static inline void fuse_request_init(struct fuse_req *req)
  36 {
  37         memset(req, 0, sizeof(*req));
  38         INIT_LIST_HEAD(&req->list);
  39         init_waitqueue_head(&req->waitq);
  40         atomic_set(&req->count, 1);
  41 }
  42
  43 struct fuse_req *fuse_request_alloc(void)
  44 {
  45         struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, SLAB_KERNEL);
  46         if (req)
  47                 fuse_request_init(req);
  48         return req;
  49 }
  50
  51 void fuse_request_free(struct fuse_req *req)
  52 {
  53         kmem_cache_free(fuse_req_cachep, req);
  54 }
  55
  56 static inline void block_sigs(sigset_t *oldset)
  57 {
  58         sigset_t mask;
  59
  60         siginitsetinv(&mask, sigmask(SIGKILL));
  61         sigprocmask(SIG_BLOCK, &mask, oldset);
  62 }
  63
  64 static inline void restore_sigs(sigset_t *oldset)
  65 {
  66         sigprocmask(SIG_SETMASK, oldset, NULL);
  67 }
  68
  69 void fuse_reset_request(struct fuse_req *req)
  70 {
  71         int preallocated = req->preallocated;
  72         BUG_ON(atomic_read(&req->count) != 1);
  73         fuse_request_init(req);
  74         req->preallocated = preallocated;
  75 }
  76
  77 static void __fuse_get_request(struct fuse_req *req)
  78 {
  79         atomic_inc(&req->count);
  80 }
  81
  82 /* Must be called with > 1 refcount */
  83 static void __fuse_put_request(struct fuse_req *req)
  84 {
  85         BUG_ON(atomic_read(&req->count) < 2);
  86         atomic_dec(&req->count);
  87 }
  88
  89 static struct fuse_req *do_get_request(struct fuse_conn *fc)
  90 {
  91         struct fuse_req *req;
  92
  93         spin_lock(&fuse_lock);
  94         BUG_ON(list_empty(&fc->unused_list));
  95         req = list_entry(fc->unused_list.next, struct fuse_req, list);
  96         list_del_init(&req->list);
  97         spin_unlock(&fuse_lock);
  98         fuse_request_init(req);
  99         req->preallocated = 1;
 100         req->in.h.uid = current->fsuid;
 101         req->in.h.gid = current->fsgid;
 102         req->in.h.pid = current->pid;
 103         return req;
 104 }
 105
 106 /* This can return NULL, but only in case it's interrupted by a SIGKILL */
 107 struct fuse_req *fuse_get_request(struct fuse_conn *fc)
 108 {
 109         int intr;
 110         sigset_t oldset;
 111
 112         block_sigs(&oldset);
 113         intr = down_interruptible(&fc->outstanding_sem);
 114         restore_sigs(&oldset);
 115         return intr ? NULL : do_get_request(fc);
 116 }
 117
 118 static void fuse_putback_request(struct fuse_conn *fc, struct fuse_req *req)
 119 {
 120         spin_lock(&fuse_lock);
 121         if (req->preallocated)
 122                 list_add(&req->list, &fc->unused_list);
 123         else
 124                 fuse_request_free(req);
 125
 126         /* If we are in debt decrease that first */
 127         if (fc->outstanding_debt)
 128                 fc->outstanding_debt--;
 129         else
 130                 up(&fc->outstanding_sem);
 131         spin_unlock(&fuse_lock);
 132 }
 133
 134 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
 135 {
 136         if (atomic_dec_and_test(&req->count))
 137                 fuse_putback_request(fc, req);
 138 }
 139
 140 void fuse_release_background(struct fuse_req *req)
 141 {
 142         iput(req->inode);
 143         iput(req->inode2);
 144         if (req->file)
 145                 fput(req->file);
 146         spin_lock(&fuse_lock);
 147         list_del(&req->bg_entry);
 148         spin_unlock(&fuse_lock);
 149 }
 150
 151 /*
 152  * This function is called when a request is finished.  Either a reply
 153  * has arrived or it was interrupted (and not yet sent) or some error
 154  * occurred during communication with userspace, or the device file was
 155  * closed.  It decreases the reference count for the request.  In case
 156  * of a background request the reference to the stored objects are
 157  * released.  The requester thread is woken up (if still waiting), and
 158  * finally the request is either freed or put on the unused_list
 159  *
 160  * Called with fuse_lock, unlocks it
 161  */
 162 static void request_end(struct fuse_conn *fc, struct fuse_req *req)
 163 {
 164         int putback;
 165         req->finished = 1;
 166         putback = atomic_dec_and_test(&req->count);
 167         spin_unlock(&fuse_lock);
 168         if (req->background) {
 169                 down_read(&fc->sbput_sem);
 170                 if (fc->mounted)
 171                         fuse_release_background(req);
 172                 up_read(&fc->sbput_sem);
 173         }
 174         wake_up(&req->waitq);
 175         if (req->in.h.opcode == FUSE_INIT) {
 176                 int i;
 177
 178                 if (req->misc.init_in_out.major != FUSE_KERNEL_VERSION)
 179                         fc->conn_error = 1;
 180
 181                 fc->minor = req->misc.init_in_out.minor;
 182
 183                 /* After INIT reply is received other requests can go
 184                    out.  So do (FUSE_MAX_OUTSTANDING - 1) number of
 185                    up()s on outstanding_sem.  The last up() is done in
 186                    fuse_putback_request() */
 187                 for (i = 1; i < FUSE_MAX_OUTSTANDING; i++)
 188                         up(&fc->outstanding_sem);
 189         } else if (req->in.h.opcode == FUSE_RELEASE && req->inode == NULL) {
 190                 /* Special case for failed iget in CREATE */
 191                 u64 nodeid = req->in.h.nodeid;
 192                 __fuse_get_request(req);
 193                 fuse_reset_request(req);
 194                 fuse_send_forget(fc, req, nodeid, 1);
 195                 putback = 0;
 196         }
 197         if (putback)
 198                 fuse_putback_request(fc, req);
 199 }
 200
 201 /*
 202  * Unfortunately request interruption not just solves the deadlock
 203  * problem, it causes problems too.  These stem from the fact, that an
 204  * interrupted request is continued to be processed in userspace,
 205  * while all the locks and object references (inode and file) held
 206  * during the operation are released.
 207  *
 208  * To release the locks is exactly why there's a need to interrupt the
 209  * request, so there's not a lot that can be done about this, except
 210  * introduce additional locking in userspace.
 211  *
 212  * More important is to keep inode and file references until userspace
 213  * has replied, otherwise FORGET and RELEASE could be sent while the
 214  * inode/file is still used by the filesystem.
 215  *
 216  * For this reason the concept of "background" request is introduced.
 217  * An interrupted request is backgrounded if it has been already sent
 218  * to userspace.  Backgrounding involves getting an extra reference to
 219  * inode(s) or file used in the request, and adding the request to
 220  * fc->background list.  When a reply is received for a background
 221  * request, the object references are released, and the request is
 222  * removed from the list.  If the filesystem is unmounted while there
 223  * are still background requests, the list is walked and references
 224  * are released as if a reply was received.
 225  *
 226  * There's one more use for a background request.  The RELEASE message is
 227  * always sent as background, since it doesn't return an error or
 228  * data.
 229  */
 230 static void background_request(struct fuse_conn *fc, struct fuse_req *req)
 231 {
 232         req->background = 1;
 233         list_add(&req->bg_entry, &fc->background);
 234         if (req->inode)
 235                 req->inode = igrab(req->inode);
 236         if (req->inode2)
 237                 req->inode2 = igrab(req->inode2);
 238         if (req->file)
 239                 get_file(req->file);
 240 }
 241
 242 /* Called with fuse_lock held.  Releases, and then reacquires it. */
 243 static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
 244 {
 245         sigset_t oldset;
 246
 247         spin_unlock(&fuse_lock);
 248         block_sigs(&oldset);
 249         wait_event_interruptible(req->waitq, req->finished);
 250         restore_sigs(&oldset);
 251         spin_lock(&fuse_lock);
 252         if (req->finished)
 253                 return;
 254
 255         req->out.h.error = -EINTR;
 256         req->interrupted = 1;
 257         if (req->locked) {
 258                 /* This is uninterruptible sleep, because data is
 259                    being copied to/from the buffers of req.  During
 260                    locked state, there mustn't be any filesystem
 261                    operation (e.g. page fault), since that could lead
 262                    to deadlock */
 263                 spin_unlock(&fuse_lock);
 264                 wait_event(req->waitq, !req->locked);
 265                 spin_lock(&fuse_lock);
 266         }
 267         if (!req->sent && !list_empty(&req->list)) {
 268                 list_del(&req->list);
 269                 __fuse_put_request(req);
 270         } else if (!req->finished && req->sent)
 271                 background_request(fc, req);
 272 }
 273
 274 static unsigned len_args(unsigned numargs, struct fuse_arg *args)
 275 {
 276         unsigned nbytes = 0;
 277         unsigned i;
 278
 279         for (i = 0; i < numargs; i++)
 280                 nbytes += args[i].size;
 281
 282         return nbytes;
 283 }
 284
 285 static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
 286 {
 287         fc->reqctr++;
 288         /* zero is special */
 289         if (fc->reqctr == 0)
 290                 fc->reqctr = 1;
 291         req->in.h.unique = fc->reqctr;
 292         req->in.h.len = sizeof(struct fuse_in_header) +
 293                 len_args(req->in.numargs, (struct fuse_arg *) req->in.args);
 294         if (!req->preallocated) {
 295                 /* If request is not preallocated (either FORGET or
 296                    RELEASE), then still decrease outstanding_sem, so
 297                    user can't open infinite number of files while not
 298                    processing the RELEASE requests.  However for
 299                    efficiency do it without blocking, so if down()
 300                    would block, just increase the debt instead */
 301                 if (down_trylock(&fc->outstanding_sem))
 302                         fc->outstanding_debt++;
 303         }
 304         list_add_tail(&req->list, &fc->pending);
 305         wake_up(&fc->waitq);
 306 }
 307
 308 /*
 309  * This can only be interrupted by a SIGKILL
 310  */
 311 void request_send(struct fuse_conn *fc, struct fuse_req *req)
 312 {
 313         req->isreply = 1;
 314         spin_lock(&fuse_lock);
 315         if (!fc->connected)
 316                 req->out.h.error = -ENOTCONN;
 317         else if (fc->conn_error)
 318                 req->out.h.error = -ECONNREFUSED;
 319         else {
 320                 queue_request(fc, req);
 321                 /* acquire extra reference, since request is still needed
 322                    after request_end() */
 323                 __fuse_get_request(req);
 324
 325                 request_wait_answer(fc, req);
 326         }
 327         spin_unlock(&fuse_lock);
 328 }
 329
 330 static void request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
 331 {
 332         spin_lock(&fuse_lock);
 333         if (fc->connected) {
 334                 queue_request(fc, req);
 335                 spin_unlock(&fuse_lock);
 336         } else {
 337                 req->out.h.error = -ENOTCONN;
 338                 request_end(fc, req);
 339         }
 340 }
 341
 342 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req)
 343 {
 344         req->isreply = 0;
 345         request_send_nowait(fc, req);
 346 }
 347
 348 void request_send_background(struct fuse_conn *fc, struct fuse_req *req)
 349 {
 350         req->isreply = 1;
 351         spin_lock(&fuse_lock);
 352         background_request(fc, req);
 353         spin_unlock(&fuse_lock);
 354         request_send_nowait(fc, req);
 355 }
 356
 357 void fuse_send_init(struct fuse_conn *fc)
 358 {
 359         /* This is called from fuse_read_super() so there's guaranteed
 360            to be a request available */
 361         struct fuse_req *req = do_get_request(fc);
 362         struct fuse_init_in_out *arg = &req->misc.init_in_out;
 363         arg->major = FUSE_KERNEL_VERSION;
 364         arg->minor = FUSE_KERNEL_MINOR_VERSION;
 365         req->in.h.opcode = FUSE_INIT;
 366         req->in.numargs = 1;
 367         req->in.args[0].size = sizeof(*arg);
 368         req->in.args[0].value = arg;
 369         req->out.numargs = 1;
 370         req->out.args[0].size = sizeof(*arg);
 371         req->out.args[0].value = arg;
 372         request_send_background(fc, req);
 373 }
 374
 375 /*
 376  * Lock the request.  Up to the next unlock_request() there mustn't be
 377  * anything that could cause a page-fault.  If the request was already
 378  * interrupted bail out.
 379  */
 380 static inline int lock_request(struct fuse_req *req)
 381 {
 382         int err = 0;
 383         if (req) {
 384                 spin_lock(&fuse_lock);
 385                 if (req->interrupted)
 386                         err = -ENOENT;
 387                 else
 388                         req->locked = 1;
 389                 spin_unlock(&fuse_lock);
 390         }
 391         return err;
 392 }
 393
 394 /*
 395  * Unlock request.  If it was interrupted during being locked, the
 396  * requester thread is currently waiting for it to be unlocked, so
 397  * wake it up.
 398  */
 399 static inline void unlock_request(struct fuse_req *req)
 400 {
 401         if (req) {
 402                 spin_lock(&fuse_lock);
 403                 req->locked = 0;
 404                 if (req->interrupted)
 405                         wake_up(&req->waitq);
 406                 spin_unlock(&fuse_lock);
 407         }
 408 }
 409
 410 struct fuse_copy_state {
 411         int write;
 412         struct fuse_req *req;
 413         const struct iovec *iov;
 414         unsigned long nr_segs;
 415         unsigned long seglen;
 416         unsigned long addr;
 417         struct page *pg;
 418         void *mapaddr;
 419         void *buf;
 420         unsigned len;
 421 };
 422
 423 static void fuse_copy_init(struct fuse_copy_state *cs, int write,
 424                            struct fuse_req *req, const struct iovec *iov,
 425                            unsigned long nr_segs)
 426 {
 427         memset(cs, 0, sizeof(*cs));
 428         cs->write = write;
 429         cs->req = req;
 430         cs->iov = iov;
 431         cs->nr_segs = nr_segs;
 432 }
 433
 434 /* Unmap and put previous page of userspace buffer */
 435 static inline void fuse_copy_finish(struct fuse_copy_state *cs)
 436 {
 437         if (cs->mapaddr) {
 438                 kunmap_atomic(cs->mapaddr, KM_USER0);
 439                 if (cs->write) {
 440                         flush_dcache_page(cs->pg);
 441                         set_page_dirty_lock(cs->pg);
 442                 }
 443                 put_page(cs->pg);
 444                 cs->mapaddr = NULL;
 445         }
 446 }
 447
 448 /*
 449  * Get another pagefull of userspace buffer, and map it to kernel
 450  * address space, and lock request
 451  */
 452 static int fuse_copy_fill(struct fuse_copy_state *cs)
 453 {
 454         unsigned long offset;
 455         int err;
 456
 457         unlock_request(cs->req);
 458         fuse_copy_finish(cs);
 459         if (!cs->seglen) {
 460                 BUG_ON(!cs->nr_segs);
 461                 cs->seglen = cs->iov[0].iov_len;
 462                 cs->addr = (unsigned long) cs->iov[0].iov_base;
 463                 cs->iov ++;
 464                 cs->nr_segs --;
 465         }
 466         down_read(&current->mm->mmap_sem);
 467         err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
 468                              &cs->pg, NULL);
 469         up_read(&current->mm->mmap_sem);
 470         if (err < 0)
 471                 return err;
 472         BUG_ON(err != 1);
 473         offset = cs->addr % PAGE_SIZE;
 474         cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
 475         cs->buf = cs->mapaddr + offset;
 476         cs->len = min(PAGE_SIZE - offset, cs->seglen);
 477         cs->seglen -= cs->len;
 478         cs->addr += cs->len;
 479
 480         return lock_request(cs->req);
 481 }
 482
 483 /* Do as much copy to/from userspace buffer as we can */
 484 static inline int fuse_copy_do(struct fuse_copy_state *cs, void **val,
 485                                unsigned *size)
 486 {
 487         unsigned ncpy = min(*size, cs->len);
 488         if (val) {
 489                 if (cs->write)
 490                         memcpy(cs->buf, *val, ncpy);
 491                 else
 492                         memcpy(*val, cs->buf, ncpy);
 493                 *val += ncpy;
 494         }
 495         *size -= ncpy;
 496         cs->len -= ncpy;
 497         cs->buf += ncpy;
 498         return ncpy;
 499 }
 500
 501 /*
 502  * Copy a page in the request to/from the userspace buffer.  Must be
 503  * done atomically
 504  */
 505 static inline int fuse_copy_page(struct fuse_copy_state *cs, struct page *page,
 506                                  unsigned offset, unsigned count, int zeroing)
 507 {
 508         if (page && zeroing && count < PAGE_SIZE) {
 509                 void *mapaddr = kmap_atomic(page, KM_USER1);
 510                 memset(mapaddr, 0, PAGE_SIZE);
 511                 kunmap_atomic(mapaddr, KM_USER1);
 512         }
 513         while (count) {
 514                 int err;
 515                 if (!cs->len && (err = fuse_copy_fill(cs)))
 516                         return err;
 517                 if (page) {
 518                         void *mapaddr = kmap_atomic(page, KM_USER1);
 519                         void *buf = mapaddr + offset;
 520                         offset += fuse_copy_do(cs, &buf, &count);
 521                         kunmap_atomic(mapaddr, KM_USER1);
 522                 } else
 523                         offset += fuse_copy_do(cs, NULL, &count);
 524         }
 525         if (page && !cs->write)
 526                 flush_dcache_page(page);
 527         return 0;
 528 }
 529
 530 /* Copy pages in the request to/from userspace buffer */
 531 static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
 532                            int zeroing)
 533 {
 534         unsigned i;
 535         struct fuse_req *req = cs->req;
 536         unsigned offset = req->page_offset;
 537         unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);
 538
 539         for (i = 0; i < req->num_pages && (nbytes || zeroing); i++) {
 540                 struct page *page = req->pages[i];
 541                 int err = fuse_copy_page(cs, page, offset, count, zeroing);
 542                 if (err)
 543                         return err;
 544
 545                 nbytes -= count;
 546                 count = min(nbytes, (unsigned) PAGE_SIZE);
 547                 offset = 0;
 548         }
 549         return 0;
 550 }
 551
 552 /* Copy a single argument in the request to/from userspace buffer */
 553 static int fuse_copy_one(struct fuse_copy_state *cs, void *val, unsigned size)
 554 {
 555         while (size) {
 556                 int err;
 557                 if (!cs->len && (err = fuse_copy_fill(cs)))
 558                         return err;
 559                 fuse_copy_do(cs, &val, &size);
 560         }
 561         return 0;
 562 }
 563
 564 /* Copy request arguments to/from userspace buffer */
 565 static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
 566                           unsigned argpages, struct fuse_arg *args,
 567                           int zeroing)
 568 {
 569         int err = 0;
 570         unsigned i;
 571
 572         for (i = 0; !err && i < numargs; i++)  {
 573                 struct fuse_arg *arg = &args[i];
 574                 if (i == numargs - 1 && argpages)
 575                         err = fuse_copy_pages(cs, arg->size, zeroing);
 576                 else
 577                         err = fuse_copy_one(cs, arg->value, arg->size);
 578         }
 579         return err;
 580 }
 581
 582 /* Wait until a request is available on the pending list */
 583 static void request_wait(struct fuse_conn *fc)
 584 {
 585         DECLARE_WAITQUEUE(wait, current);
 586
 587         add_wait_queue_exclusive(&fc->waitq, &wait);
 588         while (fc->mounted && list_empty(&fc->pending)) {
 589                 set_current_state(TASK_INTERRUPTIBLE);
 590                 if (signal_pending(current))
 591                         break;
 592
 593                 spin_unlock(&fuse_lock);
 594                 schedule();
 595                 spin_lock(&fuse_lock);
 596         }
 597         set_current_state(TASK_RUNNING);
 598         remove_wait_queue(&fc->waitq, &wait);
 599 }
 600
 601 /*
 602  * Read a single request into the userspace filesystem's buffer.  This
 603  * function waits until a request is available, then removes it from
 604  * the pending list and copies request data to userspace buffer.  If
 605  * no reply is needed (FORGET) or request has been interrupted or
 606  * there was an error during the copying then it's finished by calling
 607  * request_end().  Otherwise add it to the processing list, and set
 608  * the 'sent' flag.
 609  */
 610 static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
 611                               unsigned long nr_segs, loff_t *off)
 612 {
 613         int err;
 614         struct fuse_conn *fc;
 615         struct fuse_req *req;
 616         struct fuse_in *in;
 617         struct fuse_copy_state cs;
 618         unsigned reqsize;
 619
 620         spin_lock(&fuse_lock);
 621         fc = file->private_data;
 622         err = -EPERM;
 623         if (!fc)
 624                 goto err_unlock;
 625         request_wait(fc);
 626         err = -ENODEV;
 627         if (!fc->mounted)
 628                 goto err_unlock;
 629         err = -ERESTARTSYS;
 630         if (list_empty(&fc->pending))
 631                 goto err_unlock;
 632
 633         req = list_entry(fc->pending.next, struct fuse_req, list);
 634         list_del_init(&req->list);
 635         spin_unlock(&fuse_lock);
 636
 637         in = &req->in;
 638         reqsize = req->in.h.len;
 639         fuse_copy_init(&cs, 1, req, iov, nr_segs);
 640         err = -EINVAL;
 641         if (iov_length(iov, nr_segs) >= reqsize) {
 642                 err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
 643                 if (!err)
 644                         err = fuse_copy_args(&cs, in->numargs, in->argpages,
 645                                              (struct fuse_arg *) in->args, 0);
 646         }
 647         fuse_copy_finish(&cs);
 648
 649         spin_lock(&fuse_lock);
 650         req->locked = 0;
 651         if (!err && req->interrupted)
 652                 err = -ENOENT;
 653         if (err) {
 654                 if (!req->interrupted)
 655                         req->out.h.error = -EIO;
 656                 request_end(fc, req);
 657                 return err;
 658         }
 659         if (!req->isreply)
 660                 request_end(fc, req);
 661         else {
 662                 req->sent = 1;
 663                 list_add_tail(&req->list, &fc->processing);
 664                 spin_unlock(&fuse_lock);
 665         }
 666         return reqsize;
 667
 668  err_unlock:
 669         spin_unlock(&fuse_lock);
 670         return err;
 671 }
 672
 673 static ssize_t fuse_dev_read(struct file *file, char __user *buf,
 674                              size_t nbytes, loff_t *off)
 675 {
 676         struct iovec iov;
 677         iov.iov_len = nbytes;
 678         iov.iov_base = buf;
 679         return fuse_dev_readv(file, &iov, 1, off);
 680 }
 681
 682 /* Look up request on processing list by unique ID */
 683 static struct fuse_req *request_find(struct fuse_conn *fc, u64 unique)
 684 {
 685         struct list_head *entry;
 686
 687         list_for_each(entry, &fc->processing) {
 688                 struct fuse_req *req;
 689                 req = list_entry(entry, struct fuse_req, list);
 690                 if (req->in.h.unique == unique)
 691                         return req;
 692         }
 693         return NULL;
 694 }
 695
 696 static int copy_out_args(struct fuse_copy_state *cs, struct fuse_out *out,
 697                          unsigned nbytes)
 698 {
 699         unsigned reqsize = sizeof(struct fuse_out_header);
 700
 701         if (out->h.error)
 702                 return nbytes != reqsize ? -EINVAL : 0;
 703
 704         reqsize += len_args(out->numargs, out->args);
 705
 706         if (reqsize < nbytes || (reqsize > nbytes && !out->argvar))
 707                 return -EINVAL;
 708         else if (reqsize > nbytes) {
 709                 struct fuse_arg *lastarg = &out->args[out->numargs-1];
 710                 unsigned diffsize = reqsize - nbytes;
 711                 if (diffsize > lastarg->size)
 712                         return -EINVAL;
 713                 lastarg->size -= diffsize;
 714         }
 715         return fuse_copy_args(cs, out->numargs, out->argpages, out->args,
 716                               out->page_zeroing);
 717 }
 718
 719 /*
 720  * Write a single reply to a request.  First the header is copied from
 721  * the write buffer.  The request is then searched on the processing
 722  * list by the unique ID found in the header.  If found, then remove
 723  * it from the list and copy the rest of the buffer to the request.
 724  * The request is finished by calling request_end()
 725  */
 726 static ssize_t fuse_dev_writev(struct file *file, const struct iovec *iov,
 727                                unsigned long nr_segs, loff_t *off)
 728 {
 729         int err;
 730         unsigned nbytes = iov_length(iov, nr_segs);
 731         struct fuse_req *req;
 732         struct fuse_out_header oh;
 733         struct fuse_copy_state cs;
 734         struct fuse_conn *fc = fuse_get_conn(file);
 735         if (!fc)
 736                 return -ENODEV;
 737
 738         fuse_copy_init(&cs, 0, NULL, iov, nr_segs);
 739         if (nbytes < sizeof(struct fuse_out_header))
 740                 return -EINVAL;
 741
 742         err = fuse_copy_one(&cs, &oh, sizeof(oh));
 743         if (err)
 744                 goto err_finish;
 745         err = -EINVAL;
 746         if (!oh.unique || oh.error <= -1000 || oh.error > 0 ||
 747             oh.len != nbytes)
 748                 goto err_finish;
 749
 750         spin_lock(&fuse_lock);
 751         req = request_find(fc, oh.unique);
 752         err = -EINVAL;
 753         if (!req)
 754                 goto err_unlock;
 755
 756         list_del_init(&req->list);
 757         if (req->interrupted) {
 758                 request_end(fc, req);
 759                 fuse_copy_finish(&cs);
 760                 return -ENOENT;
 761         }
 762         req->out.h = oh;
 763         req->locked = 1;
 764         cs.req = req;
 765         spin_unlock(&fuse_lock);
 766
 767         err = copy_out_args(&cs, &req->out, nbytes);
 768         fuse_copy_finish(&cs);
 769
 770         spin_lock(&fuse_lock);
 771         req->locked = 0;
 772         if (!err) {
 773                 if (req->interrupted)
 774                         err = -ENOENT;
 775         } else if (!req->interrupted)
 776                 req->out.h.error = -EIO;
 777         request_end(fc, req);
 778
 779         return err ? err : nbytes;
 780
 781  err_unlock:
 782         spin_unlock(&fuse_lock);
 783  err_finish:
 784         fuse_copy_finish(&cs);
 785         return err;
 786 }
 787
 788 static ssize_t fuse_dev_write(struct file *file, const char __user *buf,
 789                               size_t nbytes, loff_t *off)
 790 {
 791         struct iovec iov;
 792         iov.iov_len = nbytes;
 793         iov.iov_base = (char __user *) buf;
 794         return fuse_dev_writev(file, &iov, 1, off);
 795 }
 796
 797 static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
 798 {
 799         struct fuse_conn *fc = fuse_get_conn(file);
 800         unsigned mask = POLLOUT | POLLWRNORM;
 801
 802         if (!fc)
 803                 return -ENODEV;
 804
 805         poll_wait(file, &fc->waitq, wait);
 806
 807         spin_lock(&fuse_lock);
 808         if (!list_empty(&fc->pending))
 809                 mask |= POLLIN | POLLRDNORM;
 810         spin_unlock(&fuse_lock);
 811
 812         return mask;
 813 }
 814
 815 /* Abort all requests on the given list (pending or processing) */
 816 static void end_requests(struct fuse_conn *fc, struct list_head *head)
 817 {
 818         while (!list_empty(head)) {
 819                 struct fuse_req *req;
 820                 req = list_entry(head->next, struct fuse_req, list);
 821                 list_del_init(&req->list);
 822                 req->out.h.error = -ECONNABORTED;
 823                 request_end(fc, req);
 824                 spin_lock(&fuse_lock);
 825         }
 826 }
 827
 828 static int fuse_dev_release(struct inode *inode, struct file *file)
 829 {
 830         struct fuse_conn *fc;
 831
 832         spin_lock(&fuse_lock);
 833         fc = file->private_data;
 834         if (fc) {
 835                 fc->connected = 0;
 836                 end_requests(fc, &fc->pending);
 837                 end_requests(fc, &fc->processing);
 838                 fuse_release_conn(fc);
 839         }
 840         spin_unlock(&fuse_lock);
 841         return 0;
 842 }
 843
 844 struct file_operations fuse_dev_operations = {
 845         .owner          = THIS_MODULE,
 846         .llseek         = no_llseek,
 847         .read           = fuse_dev_read,
 848         .readv          = fuse_dev_readv,
 849         .write          = fuse_dev_write,
 850         .writev         = fuse_dev_writev,
 851         .poll           = fuse_dev_poll,
 852         .release        = fuse_dev_release,
 853 };
 854
 855 static struct miscdevice fuse_miscdevice = {
 856         .minor = FUSE_MINOR,
 857         .name  = "fuse",
 858         .fops = &fuse_dev_operations,
 859 };
 860
 861 int __init fuse_dev_init(void)
 862 {
 863         int err = -ENOMEM;
 864         fuse_req_cachep = kmem_cache_create("fuse_request",
 865                                             sizeof(struct fuse_req),
 866                                             0, 0, NULL, NULL);
 867         if (!fuse_req_cachep)
 868                 goto out;
 869
 870         err = misc_register(&fuse_miscdevice);
 871         if (err)
 872                 goto out_cache_clean;
 873
 874         return 0;
 875
 876  out_cache_clean:
 877         kmem_cache_destroy(fuse_req_cachep);
 878  out:
 879         return err;
 880 }
 881
 882 void fuse_dev_cleanup(void)
 883 {
 884         misc_deregister(&fuse_miscdevice);
 885         kmem_cache_destroy(fuse_req_cachep);
 886 }