fs/fuse/dir.c

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