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