fs/fuse/dir.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2008  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/pagemap.h>
  12 #include <linux/file.h>
  13 #include <linux/sched.h>
  14 #include <linux/namei.h>
  15 #include <linux/slab.h>
  16
  17 static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
  18 {
  19         struct fuse_conn *fc = get_fuse_conn(dir);
  20         struct fuse_inode *fi = get_fuse_inode(dir);
  21
  22         if (!fc->do_readdirplus)
  23                 return false;
  24         if (!fc->readdirplus_auto)
  25                 return true;
  26         if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
  27                 return true;
  28         if (ctx->pos == 0)
  29                 return true;
  30         return false;
  31 }
  32
  33 static void fuse_advise_use_readdirplus(struct inode *dir)
  34 {
  35         struct fuse_inode *fi = get_fuse_inode(dir);
  36
  37         set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
  38 }
  39
  40 #if BITS_PER_LONG >= 64
  41 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
  42 {
  43         entry->d_time = time;
  44 }
  45
  46 static inline u64 fuse_dentry_time(struct dentry *entry)
  47 {
  48         return entry->d_time;
  49 }
  50 #else
  51 /*
  52  * On 32 bit archs store the high 32 bits of time in d_fsdata
  53  */
  54 static void fuse_dentry_settime(struct dentry *entry, u64 time)
  55 {
  56         entry->d_time = time;
  57         entry->d_fsdata = (void *) (unsigned long) (time >> 32);
  58 }
  59
  60 static u64 fuse_dentry_time(struct dentry *entry)
  61 {
  62         return (u64) entry->d_time +
  63                 ((u64) (unsigned long) entry->d_fsdata << 32);
  64 }
  65 #endif
  66
  67 /*
  68  * FUSE caches dentries and attributes with separate timeout.  The
  69  * time in jiffies until the dentry/attributes are valid is stored in
  70  * dentry->d_time and fuse_inode->i_time respectively.
  71  */
  72
  73 /*
  74  * Calculate the time in jiffies until a dentry/attributes are valid
  75  */
  76 static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
  77 {
  78         if (sec || nsec) {
  79                 struct timespec ts = {sec, nsec};
  80                 return get_jiffies_64() + timespec_to_jiffies(&ts);
  81         } else
  82                 return 0;
  83 }
  84
  85 /*
  86  * Set dentry and possibly attribute timeouts from the lookup/mk*
  87  * replies
  88  */
  89 static void fuse_change_entry_timeout(struct dentry *entry,
  90                                       struct fuse_entry_out *o)
  91 {
  92         fuse_dentry_settime(entry,
  93                 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
  94 }
  95
  96 static u64 attr_timeout(struct fuse_attr_out *o)
  97 {
  98         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
  99 }
 100
 101 static u64 entry_attr_timeout(struct fuse_entry_out *o)
 102 {
 103         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
 104 }
 105
 106 /*
 107  * Mark the attributes as stale, so that at the next call to
 108  * ->getattr() they will be fetched from userspace
 109  */
 110 void fuse_invalidate_attr(struct inode *inode)
 111 {
 112         get_fuse_inode(inode)->i_time = 0;
 113 }
 114
 115 /**
 116  * Mark the attributes as stale due to an atime change.  Avoid the invalidate if
 117  * atime is not used.
 118  */
 119 void fuse_invalidate_atime(struct inode *inode)
 120 {
 121         if (!IS_RDONLY(inode))
 122                 fuse_invalidate_attr(inode);
 123 }
 124
 125 /*
 126  * Just mark the entry as stale, so that a next attempt to look it up
 127  * will result in a new lookup call to userspace
 128  *
 129  * This is called when a dentry is about to become negative and the
 130  * timeout is unknown (unlink, rmdir, rename and in some cases
 131  * lookup)
 132  */
 133 void fuse_invalidate_entry_cache(struct dentry *entry)
 134 {
 135         fuse_dentry_settime(entry, 0);
 136 }
 137
 138 /*
 139  * Same as fuse_invalidate_entry_cache(), but also try to remove the
 140  * dentry from the hash
 141  */
 142 static void fuse_invalidate_entry(struct dentry *entry)
 143 {
 144         d_invalidate(entry);
 145         fuse_invalidate_entry_cache(entry);
 146 }
 147
 148 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
 149                              u64 nodeid, struct qstr *name,
 150                              struct fuse_entry_out *outarg)
 151 {
 152         memset(outarg, 0, sizeof(struct fuse_entry_out));
 153         req->in.h.opcode = FUSE_LOOKUP;
 154         req->in.h.nodeid = nodeid;
 155         req->in.numargs = 1;
 156         req->in.args[0].size = name->len + 1;
 157         req->in.args[0].value = name->name;
 158         req->out.numargs = 1;
 159         if (fc->minor < 9)
 160                 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 161         else
 162                 req->out.args[0].size = sizeof(struct fuse_entry_out);
 163         req->out.args[0].value = outarg;
 164 }
 165
 166 u64 fuse_get_attr_version(struct fuse_conn *fc)
 167 {
 168         u64 curr_version;
 169
 170         /*
 171          * The spin lock isn't actually needed on 64bit archs, but we
 172          * don't yet care too much about such optimizations.
 173          */
 174         spin_lock(&fc->lock);
 175         curr_version = fc->attr_version;
 176         spin_unlock(&fc->lock);
 177
 178         return curr_version;
 179 }
 180
 181 /*
 182  * Check whether the dentry is still valid
 183  *
 184  * If the entry validity timeout has expired and the dentry is
 185  * positive, try to redo the lookup.  If the lookup results in a
 186  * different inode, then let the VFS invalidate the dentry and redo
 187  * the lookup once more.  If the lookup results in the same inode,
 188  * then refresh the attributes, timeouts and mark the dentry valid.
 189  */
 190 static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
 191 {
 192         struct inode *inode;
 193         struct dentry *parent;
 194         struct fuse_conn *fc;
 195         struct fuse_inode *fi;
 196         int ret;
 197
 198         inode = ACCESS_ONCE(entry->d_inode);
 199         if (inode && is_bad_inode(inode))
 200                 goto invalid;
 201         else if (fuse_dentry_time(entry) < get_jiffies_64()) {
 202                 int err;
 203                 struct fuse_entry_out outarg;
 204                 struct fuse_req *req;
 205                 struct fuse_forget_link *forget;
 206                 u64 attr_version;
 207
 208                 /* For negative dentries, always do a fresh lookup */
 209                 if (!inode)
 210                         goto invalid;
 211
 212                 ret = -ECHILD;
 213                 if (flags & LOOKUP_RCU)
 214                         goto out;
 215
 216                 fc = get_fuse_conn(inode);
 217                 req = fuse_get_req_nopages(fc);
 218                 ret = PTR_ERR(req);
 219                 if (IS_ERR(req))
 220                         goto out;
 221
 222                 forget = fuse_alloc_forget();
 223                 if (!forget) {
 224                         fuse_put_request(fc, req);
 225                         ret = -ENOMEM;
 226                         goto out;
 227                 }
 228
 229                 attr_version = fuse_get_attr_version(fc);
 230
 231                 parent = dget_parent(entry);
 232                 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
 233                                  &entry->d_name, &outarg);
 234                 fuse_request_send(fc, req);
 235                 dput(parent);
 236                 err = req->out.h.error;
 237                 fuse_put_request(fc, req);
 238                 /* Zero nodeid is same as -ENOENT */
 239                 if (!err && !outarg.nodeid)
 240                         err = -ENOENT;
 241                 if (!err) {
 242                         fi = get_fuse_inode(inode);
 243                         if (outarg.nodeid != get_node_id(inode)) {
 244                                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
 245                                 goto invalid;
 246                         }
 247                         spin_lock(&fc->lock);
 248                         fi->nlookup++;
 249                         spin_unlock(&fc->lock);
 250                 }
 251                 kfree(forget);
 252                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
 253                         goto invalid;
 254
 255                 fuse_change_attributes(inode, &outarg.attr,
 256                                        entry_attr_timeout(&outarg),
 257                                        attr_version);
 258                 fuse_change_entry_timeout(entry, &outarg);
 259         } else if (inode) {
 260                 fi = get_fuse_inode(inode);
 261                 if (flags & LOOKUP_RCU) {
 262                         if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
 263                                 return -ECHILD;
 264                 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
 265                         parent = dget_parent(entry);
 266                         fuse_advise_use_readdirplus(parent->d_inode);
 267                         dput(parent);
 268                 }
 269         }
 270         ret = 1;
 271 out:
 272         return ret;
 273
 274 invalid:
 275         ret = 0;
 276
 277         if (!(flags & LOOKUP_RCU) && check_submounts_and_drop(entry) != 0)
 278                 ret = 1;
 279         goto out;
 280 }
 281
 282 static int invalid_nodeid(u64 nodeid)
 283 {
 284         return !nodeid || nodeid == FUSE_ROOT_ID;
 285 }
 286
 287 const struct dentry_operations fuse_dentry_operations = {
 288         .d_revalidate   = fuse_dentry_revalidate,
 289 };
 290
 291 int fuse_valid_type(int m)
 292 {
 293         return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
 294                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 295 }
 296
 297 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
 298                      struct fuse_entry_out *outarg, struct inode **inode)
 299 {
 300         struct fuse_conn *fc = get_fuse_conn_super(sb);
 301         struct fuse_req *req;
 302         struct fuse_forget_link *forget;
 303         u64 attr_version;
 304         int err;
 305
 306         *inode = NULL;
 307         err = -ENAMETOOLONG;
 308         if (name->len > FUSE_NAME_MAX)
 309                 goto out;
 310
 311         req = fuse_get_req_nopages(fc);
 312         err = PTR_ERR(req);
 313         if (IS_ERR(req))
 314                 goto out;
 315
 316         forget = fuse_alloc_forget();
 317         err = -ENOMEM;
 318         if (!forget) {
 319                 fuse_put_request(fc, req);
 320                 goto out;
 321         }
 322
 323         attr_version = fuse_get_attr_version(fc);
 324
 325         fuse_lookup_init(fc, req, nodeid, name, outarg);
 326         fuse_request_send(fc, req);
 327         err = req->out.h.error;
 328         fuse_put_request(fc, req);
 329         /* Zero nodeid is same as -ENOENT, but with valid timeout */
 330         if (err || !outarg->nodeid)
 331                 goto out_put_forget;
 332
 333         err = -EIO;
 334         if (!outarg->nodeid)
 335                 goto out_put_forget;
 336         if (!fuse_valid_type(outarg->attr.mode))
 337                 goto out_put_forget;
 338
 339         *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
 340                            &outarg->attr, entry_attr_timeout(outarg),
 341                            attr_version);
 342         err = -ENOMEM;
 343         if (!*inode) {
 344                 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
 345                 goto out;
 346         }
 347         err = 0;
 348
 349  out_put_forget:
 350         kfree(forget);
 351  out:
 352         return err;
 353 }
 354
 355 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 356                                   unsigned int flags)
 357 {
 358         int err;
 359         struct fuse_entry_out outarg;
 360         struct inode *inode;
 361         struct dentry *newent;
 362         bool outarg_valid = true;
 363
 364         err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
 365                                &outarg, &inode);
 366         if (err == -ENOENT) {
 367                 outarg_valid = false;
 368                 err = 0;
 369         }
 370         if (err)
 371                 goto out_err;
 372
 373         err = -EIO;
 374         if (inode && get_node_id(inode) == FUSE_ROOT_ID)
 375                 goto out_iput;
 376
 377         newent = d_materialise_unique(entry, inode);
 378         err = PTR_ERR(newent);
 379         if (IS_ERR(newent))
 380                 goto out_err;
 381
 382         entry = newent ? newent : entry;
 383         if (outarg_valid)
 384                 fuse_change_entry_timeout(entry, &outarg);
 385         else
 386                 fuse_invalidate_entry_cache(entry);
 387
 388         fuse_advise_use_readdirplus(dir);
 389         return newent;
 390
 391  out_iput:
 392         iput(inode);
 393  out_err:
 394         return ERR_PTR(err);
 395 }
 396
 397 /*
 398  * Atomic create+open operation
 399  *
 400  * If the filesystem doesn't support this, then fall back to separate
 401  * 'mknod' + 'open' requests.
 402  */
 403 static int fuse_create_open(struct inode *dir, struct dentry *entry,
 404                             struct file *file, unsigned flags,
 405                             umode_t mode, int *opened)
 406 {
 407         int err;
 408         struct inode *inode;
 409         struct fuse_conn *fc = get_fuse_conn(dir);
 410         struct fuse_req *req;
 411         struct fuse_forget_link *forget;
 412         struct fuse_create_in inarg;
 413         struct fuse_open_out outopen;
 414         struct fuse_entry_out outentry;
 415         struct fuse_file *ff;
 416
 417         /* Userspace expects S_IFREG in create mode */
 418         BUG_ON((mode & S_IFMT) != S_IFREG);
 419
 420         forget = fuse_alloc_forget();
 421         err = -ENOMEM;
 422         if (!forget)
 423                 goto out_err;
 424
 425         req = fuse_get_req_nopages(fc);
 426         err = PTR_ERR(req);
 427         if (IS_ERR(req))
 428                 goto out_put_forget_req;
 429
 430         err = -ENOMEM;
 431         ff = fuse_file_alloc(fc);
 432         if (!ff)
 433                 goto out_put_request;
 434
 435         if (!fc->dont_mask)
 436                 mode &= ~current_umask();
 437
 438         flags &= ~O_NOCTTY;
 439         memset(&inarg, 0, sizeof(inarg));
 440         memset(&outentry, 0, sizeof(outentry));
 441         inarg.flags = flags;
 442         inarg.mode = mode;
 443         inarg.umask = current_umask();
 444         req->in.h.opcode = FUSE_CREATE;
 445         req->in.h.nodeid = get_node_id(dir);
 446         req->in.numargs = 2;
 447         req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
 448                                                 sizeof(inarg);
 449         req->in.args[0].value = &inarg;
 450         req->in.args[1].size = entry->d_name.len + 1;
 451         req->in.args[1].value = entry->d_name.name;
 452         req->out.numargs = 2;
 453         if (fc->minor < 9)
 454                 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 455         else
 456                 req->out.args[0].size = sizeof(outentry);
 457         req->out.args[0].value = &outentry;
 458         req->out.args[1].size = sizeof(outopen);
 459         req->out.args[1].value = &outopen;
 460         fuse_request_send(fc, req);
 461         err = req->out.h.error;
 462         if (err)
 463                 goto out_free_ff;
 464
 465         err = -EIO;
 466         if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
 467                 goto out_free_ff;
 468
 469         fuse_put_request(fc, req);
 470         ff->fh = outopen.fh;
 471         ff->nodeid = outentry.nodeid;
 472         ff->open_flags = outopen.open_flags;
 473         inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
 474                           &outentry.attr, entry_attr_timeout(&outentry), 0);
 475         if (!inode) {
 476                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
 477                 fuse_sync_release(ff, flags);
 478                 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
 479                 err = -ENOMEM;
 480                 goto out_err;
 481         }
 482         kfree(forget);
 483         d_instantiate(entry, inode);
 484         fuse_change_entry_timeout(entry, &outentry);
 485         fuse_invalidate_attr(dir);
 486         err = finish_open(file, entry, generic_file_open, opened);
 487         if (err) {
 488                 fuse_sync_release(ff, flags);
 489         } else {
 490                 file->private_data = fuse_file_get(ff);
 491                 fuse_finish_open(inode, file);
 492         }
 493         return err;
 494
 495 out_free_ff:
 496         fuse_file_free(ff);
 497 out_put_request:
 498         fuse_put_request(fc, req);
 499 out_put_forget_req:
 500         kfree(forget);
 501 out_err:
 502         return err;
 503 }
 504
 505 static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
 506 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
 507                             struct file *file, unsigned flags,
 508                             umode_t mode, int *opened)
 509 {
 510         int err;
 511         struct fuse_conn *fc = get_fuse_conn(dir);
 512         struct dentry *res = NULL;
 513
 514         if (d_unhashed(entry)) {
 515                 res = fuse_lookup(dir, entry, 0);
 516                 if (IS_ERR(res))
 517                         return PTR_ERR(res);
 518
 519                 if (res)
 520                         entry = res;
 521         }
 522
 523         if (!(flags & O_CREAT) || entry->d_inode)
 524                 goto no_open;
 525
 526         /* Only creates */
 527         *opened |= FILE_CREATED;
 528
 529         if (fc->no_create)
 530                 goto mknod;
 531
 532         err = fuse_create_open(dir, entry, file, flags, mode, opened);
 533         if (err == -ENOSYS) {
 534                 fc->no_create = 1;
 535                 goto mknod;
 536         }
 537 out_dput:
 538         dput(res);
 539         return err;
 540
 541 mknod:
 542         err = fuse_mknod(dir, entry, mode, 0);
 543         if (err)
 544                 goto out_dput;
 545 no_open:
 546         return finish_no_open(file, res);
 547 }
 548
 549 /*
 550  * Code shared between mknod, mkdir, symlink and link
 551  */
 552 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
 553                             struct inode *dir, struct dentry *entry,
 554                             umode_t mode)
 555 {
 556         struct fuse_entry_out outarg;
 557         struct inode *inode;
 558         int err;
 559         struct fuse_forget_link *forget;
 560
 561         forget = fuse_alloc_forget();
 562         if (!forget) {
 563                 fuse_put_request(fc, req);
 564                 return -ENOMEM;
 565         }
 566
 567         memset(&outarg, 0, sizeof(outarg));
 568         req->in.h.nodeid = get_node_id(dir);
 569         req->out.numargs = 1;
 570         if (fc->minor < 9)
 571                 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 572         else
 573                 req->out.args[0].size = sizeof(outarg);
 574         req->out.args[0].value = &outarg;
 575         fuse_request_send(fc, req);
 576         err = req->out.h.error;
 577         fuse_put_request(fc, req);
 578         if (err)
 579                 goto out_put_forget_req;
 580
 581         err = -EIO;
 582         if (invalid_nodeid(outarg.nodeid))
 583                 goto out_put_forget_req;
 584
 585         if ((outarg.attr.mode ^ mode) & S_IFMT)
 586                 goto out_put_forget_req;
 587
 588         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 589                           &outarg.attr, entry_attr_timeout(&outarg), 0);
 590         if (!inode) {
 591                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
 592                 return -ENOMEM;
 593         }
 594         kfree(forget);
 595
 596         err = d_instantiate_no_diralias(entry, inode);
 597         if (err)
 598                 return err;
 599
 600         fuse_change_entry_timeout(entry, &outarg);
 601         fuse_invalidate_attr(dir);
 602         return 0;
 603
 604  out_put_forget_req:
 605         kfree(forget);
 606         return err;
 607 }
 608
 609 static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
 610                       dev_t rdev)
 611 {
 612         struct fuse_mknod_in inarg;
 613         struct fuse_conn *fc = get_fuse_conn(dir);
 614         struct fuse_req *req = fuse_get_req_nopages(fc);
 615         if (IS_ERR(req))
 616                 return PTR_ERR(req);
 617
 618         if (!fc->dont_mask)
 619                 mode &= ~current_umask();
 620
 621         memset(&inarg, 0, sizeof(inarg));
 622         inarg.mode = mode;
 623         inarg.rdev = new_encode_dev(rdev);
 624         inarg.umask = current_umask();
 625         req->in.h.opcode = FUSE_MKNOD;
 626         req->in.numargs = 2;
 627         req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
 628                                                 sizeof(inarg);
 629         req->in.args[0].value = &inarg;
 630         req->in.args[1].size = entry->d_name.len + 1;
 631         req->in.args[1].value = entry->d_name.name;
 632         return create_new_entry(fc, req, dir, entry, mode);
 633 }
 634
 635 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
 636                        bool excl)
 637 {
 638         return fuse_mknod(dir, entry, mode, 0);
 639 }
 640
 641 static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
 642 {
 643         struct fuse_mkdir_in inarg;
 644         struct fuse_conn *fc = get_fuse_conn(dir);
 645         struct fuse_req *req = fuse_get_req_nopages(fc);
 646         if (IS_ERR(req))
 647                 return PTR_ERR(req);
 648
 649         if (!fc->dont_mask)
 650                 mode &= ~current_umask();
 651
 652         memset(&inarg, 0, sizeof(inarg));
 653         inarg.mode = mode;
 654         inarg.umask = current_umask();
 655         req->in.h.opcode = FUSE_MKDIR;
 656         req->in.numargs = 2;
 657         req->in.args[0].size = sizeof(inarg);
 658         req->in.args[0].value = &inarg;
 659         req->in.args[1].size = entry->d_name.len + 1;
 660         req->in.args[1].value = entry->d_name.name;
 661         return create_new_entry(fc, req, dir, entry, S_IFDIR);
 662 }
 663
 664 static int fuse_symlink(struct inode *dir, struct dentry *entry,
 665                         const char *link)
 666 {
 667         struct fuse_conn *fc = get_fuse_conn(dir);
 668         unsigned len = strlen(link) + 1;
 669         struct fuse_req *req = fuse_get_req_nopages(fc);
 670         if (IS_ERR(req))
 671                 return PTR_ERR(req);
 672
 673         req->in.h.opcode = FUSE_SYMLINK;
 674         req->in.numargs = 2;
 675         req->in.args[0].size = entry->d_name.len + 1;
 676         req->in.args[0].value = entry->d_name.name;
 677         req->in.args[1].size = len;
 678         req->in.args[1].value = link;
 679         return create_new_entry(fc, req, dir, entry, S_IFLNK);
 680 }
 681
 682 static int fuse_unlink(struct inode *dir, struct dentry *entry)
 683 {
 684         int err;
 685         struct fuse_conn *fc = get_fuse_conn(dir);
 686         struct fuse_req *req = fuse_get_req_nopages(fc);
 687         if (IS_ERR(req))
 688                 return PTR_ERR(req);
 689
 690         req->in.h.opcode = FUSE_UNLINK;
 691         req->in.h.nodeid = get_node_id(dir);
 692         req->in.numargs = 1;
 693         req->in.args[0].size = entry->d_name.len + 1;
 694         req->in.args[0].value = entry->d_name.name;
 695         fuse_request_send(fc, req);
 696         err = req->out.h.error;
 697         fuse_put_request(fc, req);
 698         if (!err) {
 699                 struct inode *inode = entry->d_inode;
 700                 struct fuse_inode *fi = get_fuse_inode(inode);
 701
 702                 spin_lock(&fc->lock);
 703                 fi->attr_version = ++fc->attr_version;
 704                 /*
 705                  * If i_nlink == 0 then unlink doesn't make sense, yet this can
 706                  * happen if userspace filesystem is careless.  It would be
 707                  * difficult to enforce correct nlink usage so just ignore this
 708                  * condition here
 709                  */
 710                 if (inode->i_nlink > 0)
 711                         drop_nlink(inode);
 712                 spin_unlock(&fc->lock);
 713                 fuse_invalidate_attr(inode);
 714                 fuse_invalidate_attr(dir);
 715                 fuse_invalidate_entry_cache(entry);
 716         } else if (err == -EINTR)
 717                 fuse_invalidate_entry(entry);
 718         return err;
 719 }
 720
 721 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 722 {
 723         int err;
 724         struct fuse_conn *fc = get_fuse_conn(dir);
 725         struct fuse_req *req = fuse_get_req_nopages(fc);
 726         if (IS_ERR(req))
 727                 return PTR_ERR(req);
 728
 729         req->in.h.opcode = FUSE_RMDIR;
 730         req->in.h.nodeid = get_node_id(dir);
 731         req->in.numargs = 1;
 732         req->in.args[0].size = entry->d_name.len + 1;
 733         req->in.args[0].value = entry->d_name.name;
 734         fuse_request_send(fc, req);
 735         err = req->out.h.error;
 736         fuse_put_request(fc, req);
 737         if (!err) {
 738                 clear_nlink(entry->d_inode);
 739                 fuse_invalidate_attr(dir);
 740                 fuse_invalidate_entry_cache(entry);
 741         } else if (err == -EINTR)
 742                 fuse_invalidate_entry(entry);
 743         return err;
 744 }
 745
 746 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
 747                        struct inode *newdir, struct dentry *newent)
 748 {
 749         int err;
 750         struct fuse_rename_in inarg;
 751         struct fuse_conn *fc = get_fuse_conn(olddir);
 752         struct fuse_req *req = fuse_get_req_nopages(fc);
 753
 754         if (IS_ERR(req))
 755                 return PTR_ERR(req);
 756
 757         memset(&inarg, 0, sizeof(inarg));
 758         inarg.newdir = get_node_id(newdir);
 759         req->in.h.opcode = FUSE_RENAME;
 760         req->in.h.nodeid = get_node_id(olddir);
 761         req->in.numargs = 3;
 762         req->in.args[0].size = sizeof(inarg);
 763         req->in.args[0].value = &inarg;
 764         req->in.args[1].size = oldent->d_name.len + 1;
 765         req->in.args[1].value = oldent->d_name.name;
 766         req->in.args[2].size = newent->d_name.len + 1;
 767         req->in.args[2].value = newent->d_name.name;
 768         fuse_request_send(fc, req);
 769         err = req->out.h.error;
 770         fuse_put_request(fc, req);
 771         if (!err) {
 772                 /* ctime changes */
 773                 fuse_invalidate_attr(oldent->d_inode);
 774
 775                 fuse_invalidate_attr(olddir);
 776                 if (olddir != newdir)
 777                         fuse_invalidate_attr(newdir);
 778
 779                 /* newent will end up negative */
 780                 if (newent->d_inode) {
 781                         fuse_invalidate_attr(newent->d_inode);
 782                         fuse_invalidate_entry_cache(newent);
 783                 }
 784         } else if (err == -EINTR) {
 785                 /* If request was interrupted, DEITY only knows if the
 786                    rename actually took place.  If the invalidation
 787                    fails (e.g. some process has CWD under the renamed
 788                    directory), then there can be inconsistency between
 789                    the dcache and the real filesystem.  Tough luck. */
 790                 fuse_invalidate_entry(oldent);
 791                 if (newent->d_inode)
 792                         fuse_invalidate_entry(newent);
 793         }
 794
 795         return err;
 796 }
 797
 798 static int fuse_link(struct dentry *entry, struct inode *newdir,
 799                      struct dentry *newent)
 800 {
 801         int err;
 802         struct fuse_link_in inarg;
 803         struct inode *inode = entry->d_inode;
 804         struct fuse_conn *fc = get_fuse_conn(inode);
 805         struct fuse_req *req = fuse_get_req_nopages(fc);
 806         if (IS_ERR(req))
 807                 return PTR_ERR(req);
 808
 809         memset(&inarg, 0, sizeof(inarg));
 810         inarg.oldnodeid = get_node_id(inode);
 811         req->in.h.opcode = FUSE_LINK;
 812         req->in.numargs = 2;
 813         req->in.args[0].size = sizeof(inarg);
 814         req->in.args[0].value = &inarg;
 815         req->in.args[1].size = newent->d_name.len + 1;
 816         req->in.args[1].value = newent->d_name.name;
 817         err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
 818         /* Contrary to "normal" filesystems it can happen that link
 819            makes two "logical" inodes point to the same "physical"
 820            inode.  We invalidate the attributes of the old one, so it
 821            will reflect changes in the backing inode (link count,
 822            etc.)
 823         */
 824         if (!err) {
 825                 struct fuse_inode *fi = get_fuse_inode(inode);
 826
 827                 spin_lock(&fc->lock);
 828                 fi->attr_version = ++fc->attr_version;
 829                 inc_nlink(inode);
 830                 spin_unlock(&fc->lock);
 831                 fuse_invalidate_attr(inode);
 832         } else if (err == -EINTR) {
 833                 fuse_invalidate_attr(inode);
 834         }
 835         return err;
 836 }
 837
 838 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
 839                           struct kstat *stat)
 840 {
 841         unsigned int blkbits;
 842
 843         stat->dev = inode->i_sb->s_dev;
 844         stat->ino = attr->ino;
 845         stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 846         stat->nlink = attr->nlink;
 847         stat->uid = make_kuid(&init_user_ns, attr->uid);
 848         stat->gid = make_kgid(&init_user_ns, attr->gid);
 849         stat->rdev = inode->i_rdev;
 850         stat->atime.tv_sec = attr->atime;
 851         stat->atime.tv_nsec = attr->atimensec;
 852         stat->mtime.tv_sec = attr->mtime;
 853         stat->mtime.tv_nsec = attr->mtimensec;
 854         stat->ctime.tv_sec = attr->ctime;
 855         stat->ctime.tv_nsec = attr->ctimensec;
 856         stat->size = attr->size;
 857         stat->blocks = attr->blocks;
 858
 859         if (attr->blksize != 0)
 860                 blkbits = ilog2(attr->blksize);
 861         else
 862                 blkbits = inode->i_sb->s_blocksize_bits;
 863
 864         stat->blksize = 1 << blkbits;
 865 }
 866
 867 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
 868                            struct file *file)
 869 {
 870         int err;
 871         struct fuse_getattr_in inarg;
 872         struct fuse_attr_out outarg;
 873         struct fuse_conn *fc = get_fuse_conn(inode);
 874         struct fuse_req *req;
 875         u64 attr_version;
 876
 877         req = fuse_get_req_nopages(fc);
 878         if (IS_ERR(req))
 879                 return PTR_ERR(req);
 880
 881         attr_version = fuse_get_attr_version(fc);
 882
 883         memset(&inarg, 0, sizeof(inarg));
 884         memset(&outarg, 0, sizeof(outarg));
 885         /* Directories have separate file-handle space */
 886         if (file && S_ISREG(inode->i_mode)) {
 887                 struct fuse_file *ff = file->private_data;
 888
 889                 inarg.getattr_flags |= FUSE_GETATTR_FH;
 890                 inarg.fh = ff->fh;
 891         }
 892         req->in.h.opcode = FUSE_GETATTR;
 893         req->in.h.nodeid = get_node_id(inode);
 894         req->in.numargs = 1;
 895         req->in.args[0].size = sizeof(inarg);
 896         req->in.args[0].value = &inarg;
 897         req->out.numargs = 1;
 898         if (fc->minor < 9)
 899                 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
 900         else
 901                 req->out.args[0].size = sizeof(outarg);
 902         req->out.args[0].value = &outarg;
 903         fuse_request_send(fc, req);
 904         err = req->out.h.error;
 905         fuse_put_request(fc, req);
 906         if (!err) {
 907                 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
 908                         make_bad_inode(inode);
 909                         err = -EIO;
 910                 } else {
 911                         fuse_change_attributes(inode, &outarg.attr,
 912                                                attr_timeout(&outarg),
 913                                                attr_version);
 914                         if (stat)
 915                                 fuse_fillattr(inode, &outarg.attr, stat);
 916                 }
 917         }
 918         return err;
 919 }
 920
 921 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
 922                            struct file *file, bool *refreshed)
 923 {
 924         struct fuse_inode *fi = get_fuse_inode(inode);
 925         int err;
 926         bool r;
 927
 928         if (fi->i_time < get_jiffies_64()) {
 929                 r = true;
 930                 err = fuse_do_getattr(inode, stat, file);
 931         } else {
 932                 r = false;
 933                 err = 0;
 934                 if (stat) {
 935                         generic_fillattr(inode, stat);
 936                         stat->mode = fi->orig_i_mode;
 937                         stat->ino = fi->orig_ino;
 938                 }
 939         }
 940
 941         if (refreshed != NULL)
 942                 *refreshed = r;
 943
 944         return err;
 945 }
 946
 947 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
 948                              u64 child_nodeid, struct qstr *name)
 949 {
 950         int err = -ENOTDIR;
 951         struct inode *parent;
 952         struct dentry *dir;
 953         struct dentry *entry;
 954
 955         parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
 956         if (!parent)
 957                 return -ENOENT;
 958
 959         mutex_lock(&parent->i_mutex);
 960         if (!S_ISDIR(parent->i_mode))
 961                 goto unlock;
 962
 963         err = -ENOENT;
 964         dir = d_find_alias(parent);
 965         if (!dir)
 966                 goto unlock;
 967
 968         entry = d_lookup(dir, name);
 969         dput(dir);
 970         if (!entry)
 971                 goto unlock;
 972
 973         fuse_invalidate_attr(parent);
 974         fuse_invalidate_entry(entry);
 975
 976         if (child_nodeid != 0 && entry->d_inode) {
 977                 mutex_lock(&entry->d_inode->i_mutex);
 978                 if (get_node_id(entry->d_inode) != child_nodeid) {
 979                         err = -ENOENT;
 980                         goto badentry;
 981                 }
 982                 if (d_mountpoint(entry)) {
 983                         err = -EBUSY;
 984                         goto badentry;
 985                 }
 986                 if (S_ISDIR(entry->d_inode->i_mode)) {
 987                         shrink_dcache_parent(entry);
 988                         if (!simple_empty(entry)) {
 989                                 err = -ENOTEMPTY;
 990                                 goto badentry;
 991                         }
 992                         entry->d_inode->i_flags |= S_DEAD;
 993                 }
 994                 dont_mount(entry);
 995                 clear_nlink(entry->d_inode);
 996                 err = 0;
 997  badentry:
 998                 mutex_unlock(&entry->d_inode->i_mutex);
 999                 if (!err)
1000                         d_delete(entry);
1001         } else {
1002                 err = 0;
1003         }
1004         dput(entry);
1005
1006  unlock:
1007         mutex_unlock(&parent->i_mutex);
1008         iput(parent);
1009         return err;
1010 }
1011
1012 /*
1013  * Calling into a user-controlled filesystem gives the filesystem
1014  * daemon ptrace-like capabilities over the current process.  This
1015  * means, that the filesystem daemon is able to record the exact
1016  * filesystem operations performed, and can also control the behavior
1017  * of the requester process in otherwise impossible ways.  For example
1018  * it can delay the operation for arbitrary length of time allowing
1019  * DoS against the requester.
1020  *
1021  * For this reason only those processes can call into the filesystem,
1022  * for which the owner of the mount has ptrace privilege.  This
1023  * excludes processes started by other users, suid or sgid processes.
1024  */
1025 int fuse_allow_current_process(struct fuse_conn *fc)
1026 {
1027         const struct cred *cred;
1028
1029         if (fc->flags & FUSE_ALLOW_OTHER)
1030                 return 1;
1031
1032         cred = current_cred();
1033         if (uid_eq(cred->euid, fc->user_id) &&
1034             uid_eq(cred->suid, fc->user_id) &&
1035             uid_eq(cred->uid,  fc->user_id) &&
1036             gid_eq(cred->egid, fc->group_id) &&
1037             gid_eq(cred->sgid, fc->group_id) &&
1038             gid_eq(cred->gid,  fc->group_id))
1039                 return 1;
1040
1041         return 0;
1042 }
1043
1044 static int fuse_access(struct inode *inode, int mask)
1045 {
1046         struct fuse_conn *fc = get_fuse_conn(inode);
1047         struct fuse_req *req;
1048         struct fuse_access_in inarg;
1049         int err;
1050
1051         BUG_ON(mask & MAY_NOT_BLOCK);
1052
1053         if (fc->no_access)
1054                 return 0;
1055
1056         req = fuse_get_req_nopages(fc);
1057         if (IS_ERR(req))
1058                 return PTR_ERR(req);
1059
1060         memset(&inarg, 0, sizeof(inarg));
1061         inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1062         req->in.h.opcode = FUSE_ACCESS;
1063         req->in.h.nodeid = get_node_id(inode);
1064         req->in.numargs = 1;
1065         req->in.args[0].size = sizeof(inarg);
1066         req->in.args[0].value = &inarg;
1067         fuse_request_send(fc, req);
1068         err = req->out.h.error;
1069         fuse_put_request(fc, req);
1070         if (err == -ENOSYS) {
1071                 fc->no_access = 1;
1072                 err = 0;
1073         }
1074         return err;
1075 }
1076
1077 static int fuse_perm_getattr(struct inode *inode, int mask)
1078 {
1079         if (mask & MAY_NOT_BLOCK)
1080                 return -ECHILD;
1081
1082         return fuse_do_getattr(inode, NULL, NULL);
1083 }
1084
1085 /*
1086  * Check permission.  The two basic access models of FUSE are:
1087  *
1088  * 1) Local access checking ('default_permissions' mount option) based
1089  * on file mode.  This is the plain old disk filesystem permission
1090  * modell.
1091  *
1092  * 2) "Remote" access checking, where server is responsible for
1093  * checking permission in each inode operation.  An exception to this
1094  * is if ->permission() was invoked from sys_access() in which case an
1095  * access request is sent.  Execute permission is still checked
1096  * locally based on file mode.
1097  */
1098 static int fuse_permission(struct inode *inode, int mask)
1099 {
1100         struct fuse_conn *fc = get_fuse_conn(inode);
1101         bool refreshed = false;
1102         int err = 0;
1103
1104         if (!fuse_allow_current_process(fc))
1105                 return -EACCES;
1106
1107         /*
1108          * If attributes are needed, refresh them before proceeding
1109          */
1110         if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1111             ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1112                 struct fuse_inode *fi = get_fuse_inode(inode);
1113
1114                 if (fi->i_time < get_jiffies_64()) {
1115                         refreshed = true;
1116
1117                         err = fuse_perm_getattr(inode, mask);
1118                         if (err)
1119                                 return err;
1120                 }
1121         }
1122
1123         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1124                 err = generic_permission(inode, mask);
1125
1126                 /* If permission is denied, try to refresh file
1127                    attributes.  This is also needed, because the root
1128                    node will at first have no permissions */
1129                 if (err == -EACCES && !refreshed) {
1130                         err = fuse_perm_getattr(inode, mask);
1131                         if (!err)
1132                                 err = generic_permission(inode, mask);
1133                 }
1134
1135                 /* Note: the opposite of the above test does not
1136                    exist.  So if permissions are revoked this won't be
1137                    noticed immediately, only after the attribute
1138                    timeout has expired */
1139         } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1140                 err = fuse_access(inode, mask);
1141         } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1142                 if (!(inode->i_mode & S_IXUGO)) {
1143                         if (refreshed)
1144                                 return -EACCES;
1145
1146                         err = fuse_perm_getattr(inode, mask);
1147                         if (!err && !(inode->i_mode & S_IXUGO))
1148                                 return -EACCES;
1149                 }
1150         }
1151         return err;
1152 }
1153
1154 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1155                          struct dir_context *ctx)
1156 {
1157         while (nbytes >= FUSE_NAME_OFFSET) {
1158                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1159                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1160                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1161                         return -EIO;
1162                 if (reclen > nbytes)
1163                         break;
1164                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1165                         return -EIO;
1166
1167                 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1168                                dirent->ino, dirent->type))
1169                         break;
1170
1171                 buf += reclen;
1172                 nbytes -= reclen;
1173                 ctx->pos = dirent->off;
1174         }
1175
1176         return 0;
1177 }
1178
1179 static int fuse_direntplus_link(struct file *file,
1180                                 struct fuse_direntplus *direntplus,
1181                                 u64 attr_version)
1182 {
1183         int err;
1184         struct fuse_entry_out *o = &direntplus->entry_out;
1185         struct fuse_dirent *dirent = &direntplus->dirent;
1186         struct dentry *parent = file->f_path.dentry;
1187         struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1188         struct dentry *dentry;
1189         struct dentry *alias;
1190         struct inode *dir = parent->d_inode;
1191         struct fuse_conn *fc;
1192         struct inode *inode;
1193
1194         if (!o->nodeid) {
1195                 /*
1196                  * Unlike in the case of fuse_lookup, zero nodeid does not mean
1197                  * ENOENT. Instead, it only means the userspace filesystem did
1198                  * not want to return attributes/handle for this entry.
1199                  *
1200                  * So do nothing.
1201                  */
1202                 return 0;
1203         }
1204
1205         if (name.name[0] == '.') {
1206                 /*
1207                  * We could potentially refresh the attributes of the directory
1208                  * and its parent?
1209                  */
1210                 if (name.len == 1)
1211                         return 0;
1212                 if (name.name[1] == '.' && name.len == 2)
1213                         return 0;
1214         }
1215
1216         if (invalid_nodeid(o->nodeid))
1217                 return -EIO;
1218         if (!fuse_valid_type(o->attr.mode))
1219                 return -EIO;
1220
1221         fc = get_fuse_conn(dir);
1222
1223         name.hash = full_name_hash(name.name, name.len);
1224         dentry = d_lookup(parent, &name);
1225         if (dentry) {
1226                 inode = dentry->d_inode;
1227                 if (!inode) {
1228                         d_drop(dentry);
1229                 } else if (get_node_id(inode) != o->nodeid ||
1230                            ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1231                         err = d_invalidate(dentry);
1232                         if (err)
1233                                 goto out;
1234                 } else if (is_bad_inode(inode)) {
1235                         err = -EIO;
1236                         goto out;
1237                 } else {
1238                         struct fuse_inode *fi;
1239                         fi = get_fuse_inode(inode);
1240                         spin_lock(&fc->lock);
1241                         fi->nlookup++;
1242                         spin_unlock(&fc->lock);
1243
1244                         fuse_change_attributes(inode, &o->attr,
1245                                                entry_attr_timeout(o),
1246                                                attr_version);
1247
1248                         /*
1249                          * The other branch to 'found' comes via fuse_iget()
1250                          * which bumps nlookup inside
1251                          */
1252                         goto found;
1253                 }
1254                 dput(dentry);
1255         }
1256
1257         dentry = d_alloc(parent, &name);
1258         err = -ENOMEM;
1259         if (!dentry)
1260                 goto out;
1261
1262         inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1263                           &o->attr, entry_attr_timeout(o), attr_version);
1264         if (!inode)
1265                 goto out;
1266
1267         alias = d_materialise_unique(dentry, inode);
1268         err = PTR_ERR(alias);
1269         if (IS_ERR(alias))
1270                 goto out;
1271
1272         if (alias) {
1273                 dput(dentry);
1274                 dentry = alias;
1275         }
1276
1277 found:
1278         if (fc->readdirplus_auto)
1279                 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1280         fuse_change_entry_timeout(dentry, o);
1281
1282         err = 0;
1283 out:
1284         dput(dentry);
1285         return err;
1286 }
1287
1288 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1289                              struct dir_context *ctx, u64 attr_version)
1290 {
1291         struct fuse_direntplus *direntplus;
1292         struct fuse_dirent *dirent;
1293         size_t reclen;
1294         int over = 0;
1295         int ret;
1296
1297         while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1298                 direntplus = (struct fuse_direntplus *) buf;
1299                 dirent = &direntplus->dirent;
1300                 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1301
1302                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1303                         return -EIO;
1304                 if (reclen > nbytes)
1305                         break;
1306                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1307                         return -EIO;
1308
1309                 if (!over) {
1310                         /* We fill entries into dstbuf only as much as
1311                            it can hold. But we still continue iterating
1312                            over remaining entries to link them. If not,
1313                            we need to send a FORGET for each of those
1314                            which we did not link.
1315                         */
1316                         over = !dir_emit(ctx, dirent->name, dirent->namelen,
1317                                        dirent->ino, dirent->type);
1318                         ctx->pos = dirent->off;
1319                 }
1320
1321                 buf += reclen;
1322                 nbytes -= reclen;
1323
1324                 ret = fuse_direntplus_link(file, direntplus, attr_version);
1325                 if (ret)
1326                         fuse_force_forget(file, direntplus->entry_out.nodeid);
1327         }
1328
1329         return 0;
1330 }
1331
1332 static int fuse_readdir(struct file *file, struct dir_context *ctx)
1333 {
1334         int plus, err;
1335         size_t nbytes;
1336         struct page *page;
1337         struct inode *inode = file_inode(file);
1338         struct fuse_conn *fc = get_fuse_conn(inode);
1339         struct fuse_req *req;
1340         u64 attr_version = 0;
1341
1342         if (is_bad_inode(inode))
1343                 return -EIO;
1344
1345         req = fuse_get_req(fc, 1);
1346         if (IS_ERR(req))
1347                 return PTR_ERR(req);
1348
1349         page = alloc_page(GFP_KERNEL);
1350         if (!page) {
1351                 fuse_put_request(fc, req);
1352                 return -ENOMEM;
1353         }
1354
1355         plus = fuse_use_readdirplus(inode, ctx);
1356         req->out.argpages = 1;
1357         req->num_pages = 1;
1358         req->pages[0] = page;
1359         req->page_descs[0].length = PAGE_SIZE;
1360         if (plus) {
1361                 attr_version = fuse_get_attr_version(fc);
1362                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1363                                FUSE_READDIRPLUS);
1364         } else {
1365                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1366                                FUSE_READDIR);
1367         }
1368         fuse_request_send(fc, req);
1369         nbytes = req->out.args[0].size;
1370         err = req->out.h.error;
1371         fuse_put_request(fc, req);
1372         if (!err) {
1373                 if (plus) {
1374                         err = parse_dirplusfile(page_address(page), nbytes,
1375                                                 file, ctx,
1376                                                 attr_version);
1377                 } else {
1378                         err = parse_dirfile(page_address(page), nbytes, file,
1379                                             ctx);
1380                 }
1381         }
1382
1383         __free_page(page);
1384         fuse_invalidate_atime(inode);
1385         return err;
1386 }
1387
1388 static char *read_link(struct dentry *dentry)
1389 {
1390         struct inode *inode = dentry->d_inode;
1391         struct fuse_conn *fc = get_fuse_conn(inode);
1392         struct fuse_req *req = fuse_get_req_nopages(fc);
1393         char *link;
1394
1395         if (IS_ERR(req))
1396                 return ERR_CAST(req);
1397
1398         link = (char *) __get_free_page(GFP_KERNEL);
1399         if (!link) {
1400                 link = ERR_PTR(-ENOMEM);
1401                 goto out;
1402         }
1403         req->in.h.opcode = FUSE_READLINK;
1404         req->in.h.nodeid = get_node_id(inode);
1405         req->out.argvar = 1;
1406         req->out.numargs = 1;
1407         req->out.args[0].size = PAGE_SIZE - 1;
1408         req->out.args[0].value = link;
1409         fuse_request_send(fc, req);
1410         if (req->out.h.error) {
1411                 free_page((unsigned long) link);
1412                 link = ERR_PTR(req->out.h.error);
1413         } else
1414                 link[req->out.args[0].size] = '\0';
1415  out:
1416         fuse_put_request(fc, req);
1417         fuse_invalidate_atime(inode);
1418         return link;
1419 }
1420
1421 static void free_link(char *link)
1422 {
1423         if (!IS_ERR(link))
1424                 free_page((unsigned long) link);
1425 }
1426
1427 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1428 {
1429         nd_set_link(nd, read_link(dentry));
1430         return NULL;
1431 }
1432
1433 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1434 {
1435         free_link(nd_get_link(nd));
1436 }
1437
1438 static int fuse_dir_open(struct inode *inode, struct file *file)
1439 {
1440         return fuse_open_common(inode, file, true);
1441 }
1442
1443 static int fuse_dir_release(struct inode *inode, struct file *file)
1444 {
1445         fuse_release_common(file, FUSE_RELEASEDIR);
1446
1447         return 0;
1448 }
1449
1450 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1451                           int datasync)
1452 {
1453         return fuse_fsync_common(file, start, end, datasync, 1);
1454 }
1455
1456 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1457                             unsigned long arg)
1458 {
1459         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1460
1461         /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1462         if (fc->minor < 18)
1463                 return -ENOTTY;
1464
1465         return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1466 }
1467
1468 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1469                                    unsigned long arg)
1470 {
1471         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1472
1473         if (fc->minor < 18)
1474                 return -ENOTTY;
1475
1476         return fuse_ioctl_common(file, cmd, arg,
1477                                  FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1478 }
1479
1480 static bool update_mtime(unsigned ivalid)
1481 {
1482         /* Always update if mtime is explicitly set  */
1483         if (ivalid & ATTR_MTIME_SET)
1484                 return true;
1485
1486         /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1487         if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1488                 return false;
1489
1490         /* In all other cases update */
1491         return true;
1492 }
1493
1494 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1495 {
1496         unsigned ivalid = iattr->ia_valid;
1497
1498         if (ivalid & ATTR_MODE)
1499                 arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1500         if (ivalid & ATTR_UID)
1501                 arg->valid |= FATTR_UID,    arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
1502         if (ivalid & ATTR_GID)
1503                 arg->valid |= FATTR_GID,    arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
1504         if (ivalid & ATTR_SIZE)
1505                 arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1506         if (ivalid & ATTR_ATIME) {
1507                 arg->valid |= FATTR_ATIME;
1508                 arg->atime = iattr->ia_atime.tv_sec;
1509                 arg->atimensec = iattr->ia_atime.tv_nsec;
1510                 if (!(ivalid & ATTR_ATIME_SET))
1511                         arg->valid |= FATTR_ATIME_NOW;
1512         }
1513         if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1514                 arg->valid |= FATTR_MTIME;
1515                 arg->mtime = iattr->ia_mtime.tv_sec;
1516                 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1517                 if (!(ivalid & ATTR_MTIME_SET))
1518                         arg->valid |= FATTR_MTIME_NOW;
1519         }
1520 }
1521
1522 /*
1523  * Prevent concurrent writepages on inode
1524  *
1525  * This is done by adding a negative bias to the inode write counter
1526  * and waiting for all pending writes to finish.
1527  */
1528 void fuse_set_nowrite(struct inode *inode)
1529 {
1530         struct fuse_conn *fc = get_fuse_conn(inode);
1531         struct fuse_inode *fi = get_fuse_inode(inode);
1532
1533         BUG_ON(!mutex_is_locked(&inode->i_mutex));
1534
1535         spin_lock(&fc->lock);
1536         BUG_ON(fi->writectr < 0);
1537         fi->writectr += FUSE_NOWRITE;
1538         spin_unlock(&fc->lock);
1539         wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1540 }
1541
1542 /*
1543  * Allow writepages on inode
1544  *
1545  * Remove the bias from the writecounter and send any queued
1546  * writepages.
1547  */
1548 static void __fuse_release_nowrite(struct inode *inode)
1549 {
1550         struct fuse_inode *fi = get_fuse_inode(inode);
1551
1552         BUG_ON(fi->writectr != FUSE_NOWRITE);
1553         fi->writectr = 0;
1554         fuse_flush_writepages(inode);
1555 }
1556
1557 void fuse_release_nowrite(struct inode *inode)
1558 {
1559         struct fuse_conn *fc = get_fuse_conn(inode);
1560
1561         spin_lock(&fc->lock);
1562         __fuse_release_nowrite(inode);
1563         spin_unlock(&fc->lock);
1564 }
1565
1566 /*
1567  * Set attributes, and at the same time refresh them.
1568  *
1569  * Truncation is slightly complicated, because the 'truncate' request
1570  * may fail, in which case we don't want to touch the mapping.
1571  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1572  * and the actual truncation by hand.
1573  */
1574 int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1575                     struct file *file)
1576 {
1577         struct fuse_conn *fc = get_fuse_conn(inode);
1578         struct fuse_inode *fi = get_fuse_inode(inode);
1579         struct fuse_req *req;
1580         struct fuse_setattr_in inarg;
1581         struct fuse_attr_out outarg;
1582         bool is_truncate = false;
1583         loff_t oldsize;
1584         int err;
1585
1586         if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1587                 attr->ia_valid |= ATTR_FORCE;
1588
1589         err = inode_change_ok(inode, attr);
1590         if (err)
1591                 return err;
1592
1593         if (attr->ia_valid & ATTR_OPEN) {
1594                 if (fc->atomic_o_trunc)
1595                         return 0;
1596                 file = NULL;
1597         }
1598
1599         if (attr->ia_valid & ATTR_SIZE)
1600                 is_truncate = true;
1601
1602         req = fuse_get_req_nopages(fc);
1603         if (IS_ERR(req))
1604                 return PTR_ERR(req);
1605
1606         if (is_truncate) {
1607                 fuse_set_nowrite(inode);
1608                 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1609         }
1610
1611         memset(&inarg, 0, sizeof(inarg));
1612         memset(&outarg, 0, sizeof(outarg));
1613         iattr_to_fattr(attr, &inarg);
1614         if (file) {
1615                 struct fuse_file *ff = file->private_data;
1616                 inarg.valid |= FATTR_FH;
1617                 inarg.fh = ff->fh;
1618         }
1619         if (attr->ia_valid & ATTR_SIZE) {
1620                 /* For mandatory locking in truncate */
1621                 inarg.valid |= FATTR_LOCKOWNER;
1622                 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1623         }
1624         req->in.h.opcode = FUSE_SETATTR;
1625         req->in.h.nodeid = get_node_id(inode);
1626         req->in.numargs = 1;
1627         req->in.args[0].size = sizeof(inarg);
1628         req->in.args[0].value = &inarg;
1629         req->out.numargs = 1;
1630         if (fc->minor < 9)
1631                 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1632         else
1633                 req->out.args[0].size = sizeof(outarg);
1634         req->out.args[0].value = &outarg;
1635         fuse_request_send(fc, req);
1636         err = req->out.h.error;
1637         fuse_put_request(fc, req);
1638         if (err) {
1639                 if (err == -EINTR)
1640                         fuse_invalidate_attr(inode);
1641                 goto error;
1642         }
1643
1644         if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1645                 make_bad_inode(inode);
1646                 err = -EIO;
1647                 goto error;
1648         }
1649
1650         spin_lock(&fc->lock);
1651         fuse_change_attributes_common(inode, &outarg.attr,
1652                                       attr_timeout(&outarg));
1653         oldsize = inode->i_size;
1654         i_size_write(inode, outarg.attr.size);
1655
1656         if (is_truncate) {
1657                 /* NOTE: this may release/reacquire fc->lock */
1658                 __fuse_release_nowrite(inode);
1659         }
1660         spin_unlock(&fc->lock);
1661
1662         /*
1663          * Only call invalidate_inode_pages2() after removing
1664          * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1665          */
1666         if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1667                 truncate_pagecache(inode, outarg.attr.size);
1668                 invalidate_inode_pages2(inode->i_mapping);
1669         }
1670
1671         clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1672         return 0;
1673
1674 error:
1675         if (is_truncate)
1676                 fuse_release_nowrite(inode);
1677
1678         clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1679         return err;
1680 }
1681
1682 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1683 {
1684         struct inode *inode = entry->d_inode;
1685
1686         if (!fuse_allow_current_process(get_fuse_conn(inode)))
1687                 return -EACCES;
1688
1689         if (attr->ia_valid & ATTR_FILE)
1690                 return fuse_do_setattr(inode, attr, attr->ia_file);
1691         else
1692                 return fuse_do_setattr(inode, attr, NULL);
1693 }
1694
1695 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1696                         struct kstat *stat)
1697 {
1698         struct inode *inode = entry->d_inode;
1699         struct fuse_conn *fc = get_fuse_conn(inode);
1700
1701         if (!fuse_allow_current_process(fc))
1702                 return -EACCES;
1703
1704         return fuse_update_attributes(inode, stat, NULL, NULL);
1705 }
1706
1707 static int fuse_setxattr(struct dentry *entry, const char *name,
1708                          const void *value, size_t size, int flags)
1709 {
1710         struct inode *inode = entry->d_inode;
1711         struct fuse_conn *fc = get_fuse_conn(inode);
1712         struct fuse_req *req;
1713         struct fuse_setxattr_in inarg;
1714         int err;
1715
1716         if (fc->no_setxattr)
1717                 return -EOPNOTSUPP;
1718
1719         req = fuse_get_req_nopages(fc);
1720         if (IS_ERR(req))
1721                 return PTR_ERR(req);
1722
1723         memset(&inarg, 0, sizeof(inarg));
1724         inarg.size = size;
1725         inarg.flags = flags;
1726         req->in.h.opcode = FUSE_SETXATTR;
1727         req->in.h.nodeid = get_node_id(inode);
1728         req->in.numargs = 3;
1729         req->in.args[0].size = sizeof(inarg);
1730         req->in.args[0].value = &inarg;
1731         req->in.args[1].size = strlen(name) + 1;
1732         req->in.args[1].value = name;
1733         req->in.args[2].size = size;
1734         req->in.args[2].value = value;
1735         fuse_request_send(fc, req);
1736         err = req->out.h.error;
1737         fuse_put_request(fc, req);
1738         if (err == -ENOSYS) {
1739                 fc->no_setxattr = 1;
1740                 err = -EOPNOTSUPP;
1741         }
1742         if (!err)
1743                 fuse_invalidate_attr(inode);
1744         return err;
1745 }
1746
1747 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1748                              void *value, size_t size)
1749 {
1750         struct inode *inode = entry->d_inode;
1751         struct fuse_conn *fc = get_fuse_conn(inode);
1752         struct fuse_req *req;
1753         struct fuse_getxattr_in inarg;
1754         struct fuse_getxattr_out outarg;
1755         ssize_t ret;
1756
1757         if (fc->no_getxattr)
1758                 return -EOPNOTSUPP;
1759
1760         req = fuse_get_req_nopages(fc);
1761         if (IS_ERR(req))
1762                 return PTR_ERR(req);
1763
1764         memset(&inarg, 0, sizeof(inarg));
1765         inarg.size = size;
1766         req->in.h.opcode = FUSE_GETXATTR;
1767         req->in.h.nodeid = get_node_id(inode);
1768         req->in.numargs = 2;
1769         req->in.args[0].size = sizeof(inarg);
1770         req->in.args[0].value = &inarg;
1771         req->in.args[1].size = strlen(name) + 1;
1772         req->in.args[1].value = name;
1773         /* This is really two different operations rolled into one */
1774         req->out.numargs = 1;
1775         if (size) {
1776                 req->out.argvar = 1;
1777                 req->out.args[0].size = size;
1778                 req->out.args[0].value = value;
1779         } else {
1780                 req->out.args[0].size = sizeof(outarg);
1781                 req->out.args[0].value = &outarg;
1782         }
1783         fuse_request_send(fc, req);
1784         ret = req->out.h.error;
1785         if (!ret)
1786                 ret = size ? req->out.args[0].size : outarg.size;
1787         else {
1788                 if (ret == -ENOSYS) {
1789                         fc->no_getxattr = 1;
1790                         ret = -EOPNOTSUPP;
1791                 }
1792         }
1793         fuse_put_request(fc, req);
1794         return ret;
1795 }
1796
1797 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1798 {
1799         struct inode *inode = entry->d_inode;
1800         struct fuse_conn *fc = get_fuse_conn(inode);
1801         struct fuse_req *req;
1802         struct fuse_getxattr_in inarg;
1803         struct fuse_getxattr_out outarg;
1804         ssize_t ret;
1805
1806         if (!fuse_allow_current_process(fc))
1807                 return -EACCES;
1808
1809         if (fc->no_listxattr)
1810                 return -EOPNOTSUPP;
1811
1812         req = fuse_get_req_nopages(fc);
1813         if (IS_ERR(req))
1814                 return PTR_ERR(req);
1815
1816         memset(&inarg, 0, sizeof(inarg));
1817         inarg.size = size;
1818         req->in.h.opcode = FUSE_LISTXATTR;
1819         req->in.h.nodeid = get_node_id(inode);
1820         req->in.numargs = 1;
1821         req->in.args[0].size = sizeof(inarg);
1822         req->in.args[0].value = &inarg;
1823         /* This is really two different operations rolled into one */
1824         req->out.numargs = 1;
1825         if (size) {
1826                 req->out.argvar = 1;
1827                 req->out.args[0].size = size;
1828                 req->out.args[0].value = list;
1829         } else {
1830                 req->out.args[0].size = sizeof(outarg);
1831                 req->out.args[0].value = &outarg;
1832         }
1833         fuse_request_send(fc, req);
1834         ret = req->out.h.error;
1835         if (!ret)
1836                 ret = size ? req->out.args[0].size : outarg.size;
1837         else {
1838                 if (ret == -ENOSYS) {
1839                         fc->no_listxattr = 1;
1840                         ret = -EOPNOTSUPP;
1841                 }
1842         }
1843         fuse_put_request(fc, req);
1844         return ret;
1845 }
1846
1847 static int fuse_removexattr(struct dentry *entry, const char *name)
1848 {
1849         struct inode *inode = entry->d_inode;
1850         struct fuse_conn *fc = get_fuse_conn(inode);
1851         struct fuse_req *req;
1852         int err;
1853
1854         if (fc->no_removexattr)
1855                 return -EOPNOTSUPP;
1856
1857         req = fuse_get_req_nopages(fc);
1858         if (IS_ERR(req))
1859                 return PTR_ERR(req);
1860
1861         req->in.h.opcode = FUSE_REMOVEXATTR;
1862         req->in.h.nodeid = get_node_id(inode);
1863         req->in.numargs = 1;
1864         req->in.args[0].size = strlen(name) + 1;
1865         req->in.args[0].value = name;
1866         fuse_request_send(fc, req);
1867         err = req->out.h.error;
1868         fuse_put_request(fc, req);
1869         if (err == -ENOSYS) {
1870                 fc->no_removexattr = 1;
1871                 err = -EOPNOTSUPP;
1872         }
1873         if (!err)
1874                 fuse_invalidate_attr(inode);
1875         return err;
1876 }
1877
1878 static const struct inode_operations fuse_dir_inode_operations = {
1879         .lookup         = fuse_lookup,
1880         .mkdir          = fuse_mkdir,
1881         .symlink        = fuse_symlink,
1882         .unlink         = fuse_unlink,
1883         .rmdir          = fuse_rmdir,
1884         .rename         = fuse_rename,
1885         .link           = fuse_link,
1886         .setattr        = fuse_setattr,
1887         .create         = fuse_create,
1888         .atomic_open    = fuse_atomic_open,
1889         .mknod          = fuse_mknod,
1890         .permission     = fuse_permission,
1891         .getattr        = fuse_getattr,
1892         .setxattr       = fuse_setxattr,
1893         .getxattr       = fuse_getxattr,
1894         .listxattr      = fuse_listxattr,
1895         .removexattr    = fuse_removexattr,
1896 };
1897
1898 static const struct file_operations fuse_dir_operations = {
1899         .llseek         = generic_file_llseek,
1900         .read           = generic_read_dir,
1901         .iterate        = fuse_readdir,
1902         .open           = fuse_dir_open,
1903         .release        = fuse_dir_release,
1904         .fsync          = fuse_dir_fsync,
1905         .unlocked_ioctl = fuse_dir_ioctl,
1906         .compat_ioctl   = fuse_dir_compat_ioctl,
1907 };
1908
1909 static const struct inode_operations fuse_common_inode_operations = {
1910         .setattr        = fuse_setattr,
1911         .permission     = fuse_permission,
1912         .getattr        = fuse_getattr,
1913         .setxattr       = fuse_setxattr,
1914         .getxattr       = fuse_getxattr,
1915         .listxattr      = fuse_listxattr,
1916         .removexattr    = fuse_removexattr,
1917 };
1918
1919 static const struct inode_operations fuse_symlink_inode_operations = {
1920         .setattr        = fuse_setattr,
1921         .follow_link    = fuse_follow_link,
1922         .put_link       = fuse_put_link,
1923         .readlink       = generic_readlink,
1924         .getattr        = fuse_getattr,
1925         .setxattr       = fuse_setxattr,
1926         .getxattr       = fuse_getxattr,
1927         .listxattr      = fuse_listxattr,
1928         .removexattr    = fuse_removexattr,
1929 };
1930
1931 void fuse_init_common(struct inode *inode)
1932 {
1933         inode->i_op = &fuse_common_inode_operations;
1934 }
1935
1936 void fuse_init_dir(struct inode *inode)
1937 {
1938         inode->i_op = &fuse_dir_inode_operations;
1939         inode->i_fop = &fuse_dir_operations;
1940 }
1941
1942 void fuse_init_symlink(struct inode *inode)
1943 {
1944         inode->i_op = &fuse_symlink_inode_operations;
1945 }