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