fs/fuse/dir.c

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