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