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