fs/fuse/dir.c

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