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