1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * fs/libfs.c 4 * Library for filesystems writers. 5 */ 6 7 #include <linux/blkdev.h> 8 #include <linux/export.h> 9 #include <linux/pagemap.h> 10 #include <linux/slab.h> 11 #include <linux/cred.h> 12 #include <linux/mount.h> 13 #include <linux/vfs.h> 14 #include <linux/quotaops.h> 15 #include <linux/mutex.h> 16 #include <linux/namei.h> 17 #include <linux/exportfs.h> 18 #include <linux/writeback.h> 19 #include <linux/buffer_head.h> /* sync_mapping_buffers */ 20 #include <linux/fs_context.h> 21 #include <linux/pseudo_fs.h> 22 #include <linux/fsnotify.h> 23 #include <linux/unicode.h> 24 #include <linux/fscrypt.h> 25 26 #include <linux/uaccess.h> 27 28 #include "internal.h" 29 30 int simple_getattr(struct user_namespace *mnt_userns, const struct path *path, 31 struct kstat *stat, u32 request_mask, 32 unsigned int query_flags) 33 { 34 struct inode *inode = d_inode(path->dentry); 35 generic_fillattr(&init_user_ns, inode, stat); 36 stat->blocks = inode->i_mapping->nrpages << (PAGE_SHIFT - 9); 37 return 0; 38 } 39 EXPORT_SYMBOL(simple_getattr); 40 41 int simple_statfs(struct dentry *dentry, struct kstatfs *buf) 42 { 43 buf->f_type = dentry->d_sb->s_magic; 44 buf->f_bsize = PAGE_SIZE; 45 buf->f_namelen = NAME_MAX; 46 return 0; 47 } 48 EXPORT_SYMBOL(simple_statfs); 49 50 /* 51 * Retaining negative dentries for an in-memory filesystem just wastes 52 * memory and lookup time: arrange for them to be deleted immediately. 53 */ 54 int always_delete_dentry(const struct dentry *dentry) 55 { 56 return 1; 57 } 58 EXPORT_SYMBOL(always_delete_dentry); 59 60 const struct dentry_operations simple_dentry_operations = { 61 .d_delete = always_delete_dentry, 62 }; 63 EXPORT_SYMBOL(simple_dentry_operations); 64 65 /* 66 * Lookup the data. This is trivial - if the dentry didn't already 67 * exist, we know it is negative. Set d_op to delete negative dentries. 68 */ 69 struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 70 { 71 if (dentry->d_name.len > NAME_MAX) 72 return ERR_PTR(-ENAMETOOLONG); 73 if (!dentry->d_sb->s_d_op) 74 d_set_d_op(dentry, &simple_dentry_operations); 75 d_add(dentry, NULL); 76 return NULL; 77 } 78 EXPORT_SYMBOL(simple_lookup); 79 80 int dcache_dir_open(struct inode *inode, struct file *file) 81 { 82 file->private_data = d_alloc_cursor(file->f_path.dentry); 83 84 return file->private_data ? 0 : -ENOMEM; 85 } 86 EXPORT_SYMBOL(dcache_dir_open); 87 88 int dcache_dir_close(struct inode *inode, struct file *file) 89 { 90 dput(file->private_data); 91 return 0; 92 } 93 EXPORT_SYMBOL(dcache_dir_close); 94 95 /* parent is locked at least shared */ 96 /* 97 * Returns an element of siblings' list. 98 * We are looking for <count>th positive after <p>; if 99 * found, dentry is grabbed and returned to caller. 100 * If no such element exists, NULL is returned. 101 */ 102 static struct dentry *scan_positives(struct dentry *cursor, 103 struct list_head *p, 104 loff_t count, 105 struct dentry *last) 106 { 107 struct dentry *dentry = cursor->d_parent, *found = NULL; 108 109 spin_lock(&dentry->d_lock); 110 while ((p = p->next) != &dentry->d_subdirs) { 111 struct dentry *d = list_entry(p, struct dentry, d_child); 112 // we must at least skip cursors, to avoid livelocks 113 if (d->d_flags & DCACHE_DENTRY_CURSOR) 114 continue; 115 if (simple_positive(d) && !--count) { 116 spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED); 117 if (simple_positive(d)) 118 found = dget_dlock(d); 119 spin_unlock(&d->d_lock); 120 if (likely(found)) 121 break; 122 count = 1; 123 } 124 if (need_resched()) { 125 list_move(&cursor->d_child, p); 126 p = &cursor->d_child; 127 spin_unlock(&dentry->d_lock); 128 cond_resched(); 129 spin_lock(&dentry->d_lock); 130 } 131 } 132 spin_unlock(&dentry->d_lock); 133 dput(last); 134 return found; 135 } 136 137 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence) 138 { 139 struct dentry *dentry = file->f_path.dentry; 140 switch (whence) { 141 case 1: 142 offset += file->f_pos; 143 fallthrough; 144 case 0: 145 if (offset >= 0) 146 break; 147 fallthrough; 148 default: 149 return -EINVAL; 150 } 151 if (offset != file->f_pos) { 152 struct dentry *cursor = file->private_data; 153 struct dentry *to = NULL; 154 155 inode_lock_shared(dentry->d_inode); 156 157 if (offset > 2) 158 to = scan_positives(cursor, &dentry->d_subdirs, 159 offset - 2, NULL); 160 spin_lock(&dentry->d_lock); 161 if (to) 162 list_move(&cursor->d_child, &to->d_child); 163 else 164 list_del_init(&cursor->d_child); 165 spin_unlock(&dentry->d_lock); 166 dput(to); 167 168 file->f_pos = offset; 169 170 inode_unlock_shared(dentry->d_inode); 171 } 172 return offset; 173 } 174 EXPORT_SYMBOL(dcache_dir_lseek); 175 176 /* Relationship between i_mode and the DT_xxx types */ 177 static inline unsigned char dt_type(struct inode *inode) 178 { 179 return (inode->i_mode >> 12) & 15; 180 } 181 182 /* 183 * Directory is locked and all positive dentries in it are safe, since 184 * for ramfs-type trees they can't go away without unlink() or rmdir(), 185 * both impossible due to the lock on directory. 186 */ 187 188 int dcache_readdir(struct file *file, struct dir_context *ctx) 189 { 190 struct dentry *dentry = file->f_path.dentry; 191 struct dentry *cursor = file->private_data; 192 struct list_head *anchor = &dentry->d_subdirs; 193 struct dentry *next = NULL; 194 struct list_head *p; 195 196 if (!dir_emit_dots(file, ctx)) 197 return 0; 198 199 if (ctx->pos == 2) 200 p = anchor; 201 else if (!list_empty(&cursor->d_child)) 202 p = &cursor->d_child; 203 else 204 return 0; 205 206 while ((next = scan_positives(cursor, p, 1, next)) != NULL) { 207 if (!dir_emit(ctx, next->d_name.name, next->d_name.len, 208 d_inode(next)->i_ino, dt_type(d_inode(next)))) 209 break; 210 ctx->pos++; 211 p = &next->d_child; 212 } 213 spin_lock(&dentry->d_lock); 214 if (next) 215 list_move_tail(&cursor->d_child, &next->d_child); 216 else 217 list_del_init(&cursor->d_child); 218 spin_unlock(&dentry->d_lock); 219 dput(next); 220 221 return 0; 222 } 223 EXPORT_SYMBOL(dcache_readdir); 224 225 ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos) 226 { 227 return -EISDIR; 228 } 229 EXPORT_SYMBOL(generic_read_dir); 230 231 const struct file_operations simple_dir_operations = { 232 .open = dcache_dir_open, 233 .release = dcache_dir_close, 234 .llseek = dcache_dir_lseek, 235 .read = generic_read_dir, 236 .iterate_shared = dcache_readdir, 237 .fsync = noop_fsync, 238 }; 239 EXPORT_SYMBOL(simple_dir_operations); 240 241 const struct inode_operations simple_dir_inode_operations = { 242 .lookup = simple_lookup, 243 }; 244 EXPORT_SYMBOL(simple_dir_inode_operations); 245 246 static struct dentry *find_next_child(struct dentry *parent, struct dentry *prev) 247 { 248 struct dentry *child = NULL; 249 struct list_head *p = prev ? &prev->d_child : &parent->d_subdirs; 250 251 spin_lock(&parent->d_lock); 252 while ((p = p->next) != &parent->d_subdirs) { 253 struct dentry *d = container_of(p, struct dentry, d_child); 254 if (simple_positive(d)) { 255 spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED); 256 if (simple_positive(d)) 257 child = dget_dlock(d); 258 spin_unlock(&d->d_lock); 259 if (likely(child)) 260 break; 261 } 262 } 263 spin_unlock(&parent->d_lock); 264 dput(prev); 265 return child; 266 } 267 268 void simple_recursive_removal(struct dentry *dentry, 269 void (*callback)(struct dentry *)) 270 { 271 struct dentry *this = dget(dentry); 272 while (true) { 273 struct dentry *victim = NULL, *child; 274 struct inode *inode = this->d_inode; 275 276 inode_lock(inode); 277 if (d_is_dir(this)) 278 inode->i_flags |= S_DEAD; 279 while ((child = find_next_child(this, victim)) == NULL) { 280 // kill and ascend 281 // update metadata while it's still locked 282 inode->i_ctime = current_time(inode); 283 clear_nlink(inode); 284 inode_unlock(inode); 285 victim = this; 286 this = this->d_parent; 287 inode = this->d_inode; 288 inode_lock(inode); 289 if (simple_positive(victim)) { 290 d_invalidate(victim); // avoid lost mounts 291 if (d_is_dir(victim)) 292 fsnotify_rmdir(inode, victim); 293 else 294 fsnotify_unlink(inode, victim); 295 if (callback) 296 callback(victim); 297 dput(victim); // unpin it 298 } 299 if (victim == dentry) { 300 inode->i_ctime = inode->i_mtime = 301 current_time(inode); 302 if (d_is_dir(dentry)) 303 drop_nlink(inode); 304 inode_unlock(inode); 305 dput(dentry); 306 return; 307 } 308 } 309 inode_unlock(inode); 310 this = child; 311 } 312 } 313 EXPORT_SYMBOL(simple_recursive_removal); 314 315 static const struct super_operations simple_super_operations = { 316 .statfs = simple_statfs, 317 }; 318 319 static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc) 320 { 321 struct pseudo_fs_context *ctx = fc->fs_private; 322 struct inode *root; 323 324 s->s_maxbytes = MAX_LFS_FILESIZE; 325 s->s_blocksize = PAGE_SIZE; 326 s->s_blocksize_bits = PAGE_SHIFT; 327 s->s_magic = ctx->magic; 328 s->s_op = ctx->ops ?: &simple_super_operations; 329 s->s_xattr = ctx->xattr; 330 s->s_time_gran = 1; 331 root = new_inode(s); 332 if (!root) 333 return -ENOMEM; 334 335 /* 336 * since this is the first inode, make it number 1. New inodes created 337 * after this must take care not to collide with it (by passing 338 * max_reserved of 1 to iunique). 339 */ 340 root->i_ino = 1; 341 root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR; 342 root->i_atime = root->i_mtime = root->i_ctime = current_time(root); 343 s->s_root = d_make_root(root); 344 if (!s->s_root) 345 return -ENOMEM; 346 s->s_d_op = ctx->dops; 347 return 0; 348 } 349 350 static int pseudo_fs_get_tree(struct fs_context *fc) 351 { 352 return get_tree_nodev(fc, pseudo_fs_fill_super); 353 } 354 355 static void pseudo_fs_free(struct fs_context *fc) 356 { 357 kfree(fc->fs_private); 358 } 359 360 static const struct fs_context_operations pseudo_fs_context_ops = { 361 .free = pseudo_fs_free, 362 .get_tree = pseudo_fs_get_tree, 363 }; 364 365 /* 366 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that 367 * will never be mountable) 368 */ 369 struct pseudo_fs_context *init_pseudo(struct fs_context *fc, 370 unsigned long magic) 371 { 372 struct pseudo_fs_context *ctx; 373 374 ctx = kzalloc(sizeof(struct pseudo_fs_context), GFP_KERNEL); 375 if (likely(ctx)) { 376 ctx->magic = magic; 377 fc->fs_private = ctx; 378 fc->ops = &pseudo_fs_context_ops; 379 fc->sb_flags |= SB_NOUSER; 380 fc->global = true; 381 } 382 return ctx; 383 } 384 EXPORT_SYMBOL(init_pseudo); 385 386 int simple_open(struct inode *inode, struct file *file) 387 { 388 if (inode->i_private) 389 file->private_data = inode->i_private; 390 return 0; 391 } 392 EXPORT_SYMBOL(simple_open); 393 394 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 395 { 396 struct inode *inode = d_inode(old_dentry); 397 398 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode); 399 inc_nlink(inode); 400 ihold(inode); 401 dget(dentry); 402 d_instantiate(dentry, inode); 403 return 0; 404 } 405 EXPORT_SYMBOL(simple_link); 406 407 int simple_empty(struct dentry *dentry) 408 { 409 struct dentry *child; 410 int ret = 0; 411 412 spin_lock(&dentry->d_lock); 413 list_for_each_entry(child, &dentry->d_subdirs, d_child) { 414 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED); 415 if (simple_positive(child)) { 416 spin_unlock(&child->d_lock); 417 goto out; 418 } 419 spin_unlock(&child->d_lock); 420 } 421 ret = 1; 422 out: 423 spin_unlock(&dentry->d_lock); 424 return ret; 425 } 426 EXPORT_SYMBOL(simple_empty); 427 428 int simple_unlink(struct inode *dir, struct dentry *dentry) 429 { 430 struct inode *inode = d_inode(dentry); 431 432 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode); 433 drop_nlink(inode); 434 dput(dentry); 435 return 0; 436 } 437 EXPORT_SYMBOL(simple_unlink); 438 439 int simple_rmdir(struct inode *dir, struct dentry *dentry) 440 { 441 if (!simple_empty(dentry)) 442 return -ENOTEMPTY; 443 444 drop_nlink(d_inode(dentry)); 445 simple_unlink(dir, dentry); 446 drop_nlink(dir); 447 return 0; 448 } 449 EXPORT_SYMBOL(simple_rmdir); 450 451 int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry, 452 struct inode *new_dir, struct dentry *new_dentry) 453 { 454 bool old_is_dir = d_is_dir(old_dentry); 455 bool new_is_dir = d_is_dir(new_dentry); 456 457 if (old_dir != new_dir && old_is_dir != new_is_dir) { 458 if (old_is_dir) { 459 drop_nlink(old_dir); 460 inc_nlink(new_dir); 461 } else { 462 drop_nlink(new_dir); 463 inc_nlink(old_dir); 464 } 465 } 466 old_dir->i_ctime = old_dir->i_mtime = 467 new_dir->i_ctime = new_dir->i_mtime = 468 d_inode(old_dentry)->i_ctime = 469 d_inode(new_dentry)->i_ctime = current_time(old_dir); 470 471 return 0; 472 } 473 EXPORT_SYMBOL_GPL(simple_rename_exchange); 474 475 int simple_rename(struct user_namespace *mnt_userns, struct inode *old_dir, 476 struct dentry *old_dentry, struct inode *new_dir, 477 struct dentry *new_dentry, unsigned int flags) 478 { 479 struct inode *inode = d_inode(old_dentry); 480 int they_are_dirs = d_is_dir(old_dentry); 481 482 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE)) 483 return -EINVAL; 484 485 if (flags & RENAME_EXCHANGE) 486 return simple_rename_exchange(old_dir, old_dentry, new_dir, new_dentry); 487 488 if (!simple_empty(new_dentry)) 489 return -ENOTEMPTY; 490 491 if (d_really_is_positive(new_dentry)) { 492 simple_unlink(new_dir, new_dentry); 493 if (they_are_dirs) { 494 drop_nlink(d_inode(new_dentry)); 495 drop_nlink(old_dir); 496 } 497 } else if (they_are_dirs) { 498 drop_nlink(old_dir); 499 inc_nlink(new_dir); 500 } 501 502 old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime = 503 new_dir->i_mtime = inode->i_ctime = current_time(old_dir); 504 505 return 0; 506 } 507 EXPORT_SYMBOL(simple_rename); 508 509 /** 510 * simple_setattr - setattr for simple filesystem 511 * @mnt_userns: user namespace of the target mount 512 * @dentry: dentry 513 * @iattr: iattr structure 514 * 515 * Returns 0 on success, -error on failure. 516 * 517 * simple_setattr is a simple ->setattr implementation without a proper 518 * implementation of size changes. 519 * 520 * It can either be used for in-memory filesystems or special files 521 * on simple regular filesystems. Anything that needs to change on-disk 522 * or wire state on size changes needs its own setattr method. 523 */ 524 int simple_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 525 struct iattr *iattr) 526 { 527 struct inode *inode = d_inode(dentry); 528 int error; 529 530 error = setattr_prepare(mnt_userns, dentry, iattr); 531 if (error) 532 return error; 533 534 if (iattr->ia_valid & ATTR_SIZE) 535 truncate_setsize(inode, iattr->ia_size); 536 setattr_copy(mnt_userns, inode, iattr); 537 mark_inode_dirty(inode); 538 return 0; 539 } 540 EXPORT_SYMBOL(simple_setattr); 541 542 static int simple_readpage(struct file *file, struct page *page) 543 { 544 clear_highpage(page); 545 flush_dcache_page(page); 546 SetPageUptodate(page); 547 unlock_page(page); 548 return 0; 549 } 550 551 int simple_write_begin(struct file *file, struct address_space *mapping, 552 loff_t pos, unsigned len, unsigned flags, 553 struct page **pagep, void **fsdata) 554 { 555 struct page *page; 556 pgoff_t index; 557 558 index = pos >> PAGE_SHIFT; 559 560 page = grab_cache_page_write_begin(mapping, index, flags); 561 if (!page) 562 return -ENOMEM; 563 564 *pagep = page; 565 566 if (!PageUptodate(page) && (len != PAGE_SIZE)) { 567 unsigned from = pos & (PAGE_SIZE - 1); 568 569 zero_user_segments(page, 0, from, from + len, PAGE_SIZE); 570 } 571 return 0; 572 } 573 EXPORT_SYMBOL(simple_write_begin); 574 575 /** 576 * simple_write_end - .write_end helper for non-block-device FSes 577 * @file: See .write_end of address_space_operations 578 * @mapping: " 579 * @pos: " 580 * @len: " 581 * @copied: " 582 * @page: " 583 * @fsdata: " 584 * 585 * simple_write_end does the minimum needed for updating a page after writing is 586 * done. It has the same API signature as the .write_end of 587 * address_space_operations vector. So it can just be set onto .write_end for 588 * FSes that don't need any other processing. i_mutex is assumed to be held. 589 * Block based filesystems should use generic_write_end(). 590 * NOTE: Even though i_size might get updated by this function, mark_inode_dirty 591 * is not called, so a filesystem that actually does store data in .write_inode 592 * should extend on what's done here with a call to mark_inode_dirty() in the 593 * case that i_size has changed. 594 * 595 * Use *ONLY* with simple_readpage() 596 */ 597 static int simple_write_end(struct file *file, struct address_space *mapping, 598 loff_t pos, unsigned len, unsigned copied, 599 struct page *page, void *fsdata) 600 { 601 struct inode *inode = page->mapping->host; 602 loff_t last_pos = pos + copied; 603 604 /* zero the stale part of the page if we did a short copy */ 605 if (!PageUptodate(page)) { 606 if (copied < len) { 607 unsigned from = pos & (PAGE_SIZE - 1); 608 609 zero_user(page, from + copied, len - copied); 610 } 611 SetPageUptodate(page); 612 } 613 /* 614 * No need to use i_size_read() here, the i_size 615 * cannot change under us because we hold the i_mutex. 616 */ 617 if (last_pos > inode->i_size) 618 i_size_write(inode, last_pos); 619 620 set_page_dirty(page); 621 unlock_page(page); 622 put_page(page); 623 624 return copied; 625 } 626 627 /* 628 * Provides ramfs-style behavior: data in the pagecache, but no writeback. 629 */ 630 const struct address_space_operations ram_aops = { 631 .readpage = simple_readpage, 632 .write_begin = simple_write_begin, 633 .write_end = simple_write_end, 634 .dirty_folio = noop_dirty_folio, 635 }; 636 EXPORT_SYMBOL(ram_aops); 637 638 /* 639 * the inodes created here are not hashed. If you use iunique to generate 640 * unique inode values later for this filesystem, then you must take care 641 * to pass it an appropriate max_reserved value to avoid collisions. 642 */ 643 int simple_fill_super(struct super_block *s, unsigned long magic, 644 const struct tree_descr *files) 645 { 646 struct inode *inode; 647 struct dentry *root; 648 struct dentry *dentry; 649 int i; 650 651 s->s_blocksize = PAGE_SIZE; 652 s->s_blocksize_bits = PAGE_SHIFT; 653 s->s_magic = magic; 654 s->s_op = &simple_super_operations; 655 s->s_time_gran = 1; 656 657 inode = new_inode(s); 658 if (!inode) 659 return -ENOMEM; 660 /* 661 * because the root inode is 1, the files array must not contain an 662 * entry at index 1 663 */ 664 inode->i_ino = 1; 665 inode->i_mode = S_IFDIR | 0755; 666 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); 667 inode->i_op = &simple_dir_inode_operations; 668 inode->i_fop = &simple_dir_operations; 669 set_nlink(inode, 2); 670 root = d_make_root(inode); 671 if (!root) 672 return -ENOMEM; 673 for (i = 0; !files->name || files->name[0]; i++, files++) { 674 if (!files->name) 675 continue; 676 677 /* warn if it tries to conflict with the root inode */ 678 if (unlikely(i == 1)) 679 printk(KERN_WARNING "%s: %s passed in a files array" 680 "with an index of 1!\n", __func__, 681 s->s_type->name); 682 683 dentry = d_alloc_name(root, files->name); 684 if (!dentry) 685 goto out; 686 inode = new_inode(s); 687 if (!inode) { 688 dput(dentry); 689 goto out; 690 } 691 inode->i_mode = S_IFREG | files->mode; 692 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); 693 inode->i_fop = files->ops; 694 inode->i_ino = i; 695 d_add(dentry, inode); 696 } 697 s->s_root = root; 698 return 0; 699 out: 700 d_genocide(root); 701 shrink_dcache_parent(root); 702 dput(root); 703 return -ENOMEM; 704 } 705 EXPORT_SYMBOL(simple_fill_super); 706 707 static DEFINE_SPINLOCK(pin_fs_lock); 708 709 int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count) 710 { 711 struct vfsmount *mnt = NULL; 712 spin_lock(&pin_fs_lock); 713 if (unlikely(!*mount)) { 714 spin_unlock(&pin_fs_lock); 715 mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL); 716 if (IS_ERR(mnt)) 717 return PTR_ERR(mnt); 718 spin_lock(&pin_fs_lock); 719 if (!*mount) 720 *mount = mnt; 721 } 722 mntget(*mount); 723 ++*count; 724 spin_unlock(&pin_fs_lock); 725 mntput(mnt); 726 return 0; 727 } 728 EXPORT_SYMBOL(simple_pin_fs); 729 730 void simple_release_fs(struct vfsmount **mount, int *count) 731 { 732 struct vfsmount *mnt; 733 spin_lock(&pin_fs_lock); 734 mnt = *mount; 735 if (!--*count) 736 *mount = NULL; 737 spin_unlock(&pin_fs_lock); 738 mntput(mnt); 739 } 740 EXPORT_SYMBOL(simple_release_fs); 741 742 /** 743 * simple_read_from_buffer - copy data from the buffer to user space 744 * @to: the user space buffer to read to 745 * @count: the maximum number of bytes to read 746 * @ppos: the current position in the buffer 747 * @from: the buffer to read from 748 * @available: the size of the buffer 749 * 750 * The simple_read_from_buffer() function reads up to @count bytes from the 751 * buffer @from at offset @ppos into the user space address starting at @to. 752 * 753 * On success, the number of bytes read is returned and the offset @ppos is 754 * advanced by this number, or negative value is returned on error. 755 **/ 756 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, 757 const void *from, size_t available) 758 { 759 loff_t pos = *ppos; 760 size_t ret; 761 762 if (pos < 0) 763 return -EINVAL; 764 if (pos >= available || !count) 765 return 0; 766 if (count > available - pos) 767 count = available - pos; 768 ret = copy_to_user(to, from + pos, count); 769 if (ret == count) 770 return -EFAULT; 771 count -= ret; 772 *ppos = pos + count; 773 return count; 774 } 775 EXPORT_SYMBOL(simple_read_from_buffer); 776 777 /** 778 * simple_write_to_buffer - copy data from user space to the buffer 779 * @to: the buffer to write to 780 * @available: the size of the buffer 781 * @ppos: the current position in the buffer 782 * @from: the user space buffer to read from 783 * @count: the maximum number of bytes to read 784 * 785 * The simple_write_to_buffer() function reads up to @count bytes from the user 786 * space address starting at @from into the buffer @to at offset @ppos. 787 * 788 * On success, the number of bytes written is returned and the offset @ppos is 789 * advanced by this number, or negative value is returned on error. 790 **/ 791 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, 792 const void __user *from, size_t count) 793 { 794 loff_t pos = *ppos; 795 size_t res; 796 797 if (pos < 0) 798 return -EINVAL; 799 if (pos >= available || !count) 800 return 0; 801 if (count > available - pos) 802 count = available - pos; 803 res = copy_from_user(to + pos, from, count); 804 if (res == count) 805 return -EFAULT; 806 count -= res; 807 *ppos = pos + count; 808 return count; 809 } 810 EXPORT_SYMBOL(simple_write_to_buffer); 811 812 /** 813 * memory_read_from_buffer - copy data from the buffer 814 * @to: the kernel space buffer to read to 815 * @count: the maximum number of bytes to read 816 * @ppos: the current position in the buffer 817 * @from: the buffer to read from 818 * @available: the size of the buffer 819 * 820 * The memory_read_from_buffer() function reads up to @count bytes from the 821 * buffer @from at offset @ppos into the kernel space address starting at @to. 822 * 823 * On success, the number of bytes read is returned and the offset @ppos is 824 * advanced by this number, or negative value is returned on error. 825 **/ 826 ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, 827 const void *from, size_t available) 828 { 829 loff_t pos = *ppos; 830 831 if (pos < 0) 832 return -EINVAL; 833 if (pos >= available) 834 return 0; 835 if (count > available - pos) 836 count = available - pos; 837 memcpy(to, from + pos, count); 838 *ppos = pos + count; 839 840 return count; 841 } 842 EXPORT_SYMBOL(memory_read_from_buffer); 843 844 /* 845 * Transaction based IO. 846 * The file expects a single write which triggers the transaction, and then 847 * possibly a read which collects the result - which is stored in a 848 * file-local buffer. 849 */ 850 851 void simple_transaction_set(struct file *file, size_t n) 852 { 853 struct simple_transaction_argresp *ar = file->private_data; 854 855 BUG_ON(n > SIMPLE_TRANSACTION_LIMIT); 856 857 /* 858 * The barrier ensures that ar->size will really remain zero until 859 * ar->data is ready for reading. 860 */ 861 smp_mb(); 862 ar->size = n; 863 } 864 EXPORT_SYMBOL(simple_transaction_set); 865 866 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size) 867 { 868 struct simple_transaction_argresp *ar; 869 static DEFINE_SPINLOCK(simple_transaction_lock); 870 871 if (size > SIMPLE_TRANSACTION_LIMIT - 1) 872 return ERR_PTR(-EFBIG); 873 874 ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL); 875 if (!ar) 876 return ERR_PTR(-ENOMEM); 877 878 spin_lock(&simple_transaction_lock); 879 880 /* only one write allowed per open */ 881 if (file->private_data) { 882 spin_unlock(&simple_transaction_lock); 883 free_page((unsigned long)ar); 884 return ERR_PTR(-EBUSY); 885 } 886 887 file->private_data = ar; 888 889 spin_unlock(&simple_transaction_lock); 890 891 if (copy_from_user(ar->data, buf, size)) 892 return ERR_PTR(-EFAULT); 893 894 return ar->data; 895 } 896 EXPORT_SYMBOL(simple_transaction_get); 897 898 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 899 { 900 struct simple_transaction_argresp *ar = file->private_data; 901 902 if (!ar) 903 return 0; 904 return simple_read_from_buffer(buf, size, pos, ar->data, ar->size); 905 } 906 EXPORT_SYMBOL(simple_transaction_read); 907 908 int simple_transaction_release(struct inode *inode, struct file *file) 909 { 910 free_page((unsigned long)file->private_data); 911 return 0; 912 } 913 EXPORT_SYMBOL(simple_transaction_release); 914 915 /* Simple attribute files */ 916 917 struct simple_attr { 918 int (*get)(void *, u64 *); 919 int (*set)(void *, u64); 920 char get_buf[24]; /* enough to store a u64 and "\n\0" */ 921 char set_buf[24]; 922 void *data; 923 const char *fmt; /* format for read operation */ 924 struct mutex mutex; /* protects access to these buffers */ 925 }; 926 927 /* simple_attr_open is called by an actual attribute open file operation 928 * to set the attribute specific access operations. */ 929 int simple_attr_open(struct inode *inode, struct file *file, 930 int (*get)(void *, u64 *), int (*set)(void *, u64), 931 const char *fmt) 932 { 933 struct simple_attr *attr; 934 935 attr = kzalloc(sizeof(*attr), GFP_KERNEL); 936 if (!attr) 937 return -ENOMEM; 938 939 attr->get = get; 940 attr->set = set; 941 attr->data = inode->i_private; 942 attr->fmt = fmt; 943 mutex_init(&attr->mutex); 944 945 file->private_data = attr; 946 947 return nonseekable_open(inode, file); 948 } 949 EXPORT_SYMBOL_GPL(simple_attr_open); 950 951 int simple_attr_release(struct inode *inode, struct file *file) 952 { 953 kfree(file->private_data); 954 return 0; 955 } 956 EXPORT_SYMBOL_GPL(simple_attr_release); /* GPL-only? This? Really? */ 957 958 /* read from the buffer that is filled with the get function */ 959 ssize_t simple_attr_read(struct file *file, char __user *buf, 960 size_t len, loff_t *ppos) 961 { 962 struct simple_attr *attr; 963 size_t size; 964 ssize_t ret; 965 966 attr = file->private_data; 967 968 if (!attr->get) 969 return -EACCES; 970 971 ret = mutex_lock_interruptible(&attr->mutex); 972 if (ret) 973 return ret; 974 975 if (*ppos && attr->get_buf[0]) { 976 /* continued read */ 977 size = strlen(attr->get_buf); 978 } else { 979 /* first read */ 980 u64 val; 981 ret = attr->get(attr->data, &val); 982 if (ret) 983 goto out; 984 985 size = scnprintf(attr->get_buf, sizeof(attr->get_buf), 986 attr->fmt, (unsigned long long)val); 987 } 988 989 ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size); 990 out: 991 mutex_unlock(&attr->mutex); 992 return ret; 993 } 994 EXPORT_SYMBOL_GPL(simple_attr_read); 995 996 /* interpret the buffer as a number to call the set function with */ 997 ssize_t simple_attr_write(struct file *file, const char __user *buf, 998 size_t len, loff_t *ppos) 999 { 1000 struct simple_attr *attr; 1001 unsigned long long val; 1002 size_t size; 1003 ssize_t ret; 1004 1005 attr = file->private_data; 1006 if (!attr->set) 1007 return -EACCES; 1008 1009 ret = mutex_lock_interruptible(&attr->mutex); 1010 if (ret) 1011 return ret; 1012 1013 ret = -EFAULT; 1014 size = min(sizeof(attr->set_buf) - 1, len); 1015 if (copy_from_user(attr->set_buf, buf, size)) 1016 goto out; 1017 1018 attr->set_buf[size] = '\0'; 1019 ret = kstrtoull(attr->set_buf, 0, &val); 1020 if (ret) 1021 goto out; 1022 ret = attr->set(attr->data, val); 1023 if (ret == 0) 1024 ret = len; /* on success, claim we got the whole input */ 1025 out: 1026 mutex_unlock(&attr->mutex); 1027 return ret; 1028 } 1029 EXPORT_SYMBOL_GPL(simple_attr_write); 1030 1031 /** 1032 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation 1033 * @sb: filesystem to do the file handle conversion on 1034 * @fid: file handle to convert 1035 * @fh_len: length of the file handle in bytes 1036 * @fh_type: type of file handle 1037 * @get_inode: filesystem callback to retrieve inode 1038 * 1039 * This function decodes @fid as long as it has one of the well-known 1040 * Linux filehandle types and calls @get_inode on it to retrieve the 1041 * inode for the object specified in the file handle. 1042 */ 1043 struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid, 1044 int fh_len, int fh_type, struct inode *(*get_inode) 1045 (struct super_block *sb, u64 ino, u32 gen)) 1046 { 1047 struct inode *inode = NULL; 1048 1049 if (fh_len < 2) 1050 return NULL; 1051 1052 switch (fh_type) { 1053 case FILEID_INO32_GEN: 1054 case FILEID_INO32_GEN_PARENT: 1055 inode = get_inode(sb, fid->i32.ino, fid->i32.gen); 1056 break; 1057 } 1058 1059 return d_obtain_alias(inode); 1060 } 1061 EXPORT_SYMBOL_GPL(generic_fh_to_dentry); 1062 1063 /** 1064 * generic_fh_to_parent - generic helper for the fh_to_parent export operation 1065 * @sb: filesystem to do the file handle conversion on 1066 * @fid: file handle to convert 1067 * @fh_len: length of the file handle in bytes 1068 * @fh_type: type of file handle 1069 * @get_inode: filesystem callback to retrieve inode 1070 * 1071 * This function decodes @fid as long as it has one of the well-known 1072 * Linux filehandle types and calls @get_inode on it to retrieve the 1073 * inode for the _parent_ object specified in the file handle if it 1074 * is specified in the file handle, or NULL otherwise. 1075 */ 1076 struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid, 1077 int fh_len, int fh_type, struct inode *(*get_inode) 1078 (struct super_block *sb, u64 ino, u32 gen)) 1079 { 1080 struct inode *inode = NULL; 1081 1082 if (fh_len <= 2) 1083 return NULL; 1084 1085 switch (fh_type) { 1086 case FILEID_INO32_GEN_PARENT: 1087 inode = get_inode(sb, fid->i32.parent_ino, 1088 (fh_len > 3 ? fid->i32.parent_gen : 0)); 1089 break; 1090 } 1091 1092 return d_obtain_alias(inode); 1093 } 1094 EXPORT_SYMBOL_GPL(generic_fh_to_parent); 1095 1096 /** 1097 * __generic_file_fsync - generic fsync implementation for simple filesystems 1098 * 1099 * @file: file to synchronize 1100 * @start: start offset in bytes 1101 * @end: end offset in bytes (inclusive) 1102 * @datasync: only synchronize essential metadata if true 1103 * 1104 * This is a generic implementation of the fsync method for simple 1105 * filesystems which track all non-inode metadata in the buffers list 1106 * hanging off the address_space structure. 1107 */ 1108 int __generic_file_fsync(struct file *file, loff_t start, loff_t end, 1109 int datasync) 1110 { 1111 struct inode *inode = file->f_mapping->host; 1112 int err; 1113 int ret; 1114 1115 err = file_write_and_wait_range(file, start, end); 1116 if (err) 1117 return err; 1118 1119 inode_lock(inode); 1120 ret = sync_mapping_buffers(inode->i_mapping); 1121 if (!(inode->i_state & I_DIRTY_ALL)) 1122 goto out; 1123 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) 1124 goto out; 1125 1126 err = sync_inode_metadata(inode, 1); 1127 if (ret == 0) 1128 ret = err; 1129 1130 out: 1131 inode_unlock(inode); 1132 /* check and advance again to catch errors after syncing out buffers */ 1133 err = file_check_and_advance_wb_err(file); 1134 if (ret == 0) 1135 ret = err; 1136 return ret; 1137 } 1138 EXPORT_SYMBOL(__generic_file_fsync); 1139 1140 /** 1141 * generic_file_fsync - generic fsync implementation for simple filesystems 1142 * with flush 1143 * @file: file to synchronize 1144 * @start: start offset in bytes 1145 * @end: end offset in bytes (inclusive) 1146 * @datasync: only synchronize essential metadata if true 1147 * 1148 */ 1149 1150 int generic_file_fsync(struct file *file, loff_t start, loff_t end, 1151 int datasync) 1152 { 1153 struct inode *inode = file->f_mapping->host; 1154 int err; 1155 1156 err = __generic_file_fsync(file, start, end, datasync); 1157 if (err) 1158 return err; 1159 return blkdev_issue_flush(inode->i_sb->s_bdev); 1160 } 1161 EXPORT_SYMBOL(generic_file_fsync); 1162 1163 /** 1164 * generic_check_addressable - Check addressability of file system 1165 * @blocksize_bits: log of file system block size 1166 * @num_blocks: number of blocks in file system 1167 * 1168 * Determine whether a file system with @num_blocks blocks (and a 1169 * block size of 2**@blocksize_bits) is addressable by the sector_t 1170 * and page cache of the system. Return 0 if so and -EFBIG otherwise. 1171 */ 1172 int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks) 1173 { 1174 u64 last_fs_block = num_blocks - 1; 1175 u64 last_fs_page = 1176 last_fs_block >> (PAGE_SHIFT - blocksize_bits); 1177 1178 if (unlikely(num_blocks == 0)) 1179 return 0; 1180 1181 if ((blocksize_bits < 9) || (blocksize_bits > PAGE_SHIFT)) 1182 return -EINVAL; 1183 1184 if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) || 1185 (last_fs_page > (pgoff_t)(~0ULL))) { 1186 return -EFBIG; 1187 } 1188 return 0; 1189 } 1190 EXPORT_SYMBOL(generic_check_addressable); 1191 1192 /* 1193 * No-op implementation of ->fsync for in-memory filesystems. 1194 */ 1195 int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync) 1196 { 1197 return 0; 1198 } 1199 EXPORT_SYMBOL(noop_fsync); 1200 1201 ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter) 1202 { 1203 /* 1204 * iomap based filesystems support direct I/O without need for 1205 * this callback. However, it still needs to be set in 1206 * inode->a_ops so that open/fcntl know that direct I/O is 1207 * generally supported. 1208 */ 1209 return -EINVAL; 1210 } 1211 EXPORT_SYMBOL_GPL(noop_direct_IO); 1212 1213 /* Because kfree isn't assignment-compatible with void(void*) ;-/ */ 1214 void kfree_link(void *p) 1215 { 1216 kfree(p); 1217 } 1218 EXPORT_SYMBOL(kfree_link); 1219 1220 struct inode *alloc_anon_inode(struct super_block *s) 1221 { 1222 static const struct address_space_operations anon_aops = { 1223 .dirty_folio = noop_dirty_folio, 1224 }; 1225 struct inode *inode = new_inode_pseudo(s); 1226 1227 if (!inode) 1228 return ERR_PTR(-ENOMEM); 1229 1230 inode->i_ino = get_next_ino(); 1231 inode->i_mapping->a_ops = &anon_aops; 1232 1233 /* 1234 * Mark the inode dirty from the very beginning, 1235 * that way it will never be moved to the dirty 1236 * list because mark_inode_dirty() will think 1237 * that it already _is_ on the dirty list. 1238 */ 1239 inode->i_state = I_DIRTY; 1240 inode->i_mode = S_IRUSR | S_IWUSR; 1241 inode->i_uid = current_fsuid(); 1242 inode->i_gid = current_fsgid(); 1243 inode->i_flags |= S_PRIVATE; 1244 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); 1245 return inode; 1246 } 1247 EXPORT_SYMBOL(alloc_anon_inode); 1248 1249 /** 1250 * simple_nosetlease - generic helper for prohibiting leases 1251 * @filp: file pointer 1252 * @arg: type of lease to obtain 1253 * @flp: new lease supplied for insertion 1254 * @priv: private data for lm_setup operation 1255 * 1256 * Generic helper for filesystems that do not wish to allow leases to be set. 1257 * All arguments are ignored and it just returns -EINVAL. 1258 */ 1259 int 1260 simple_nosetlease(struct file *filp, long arg, struct file_lock **flp, 1261 void **priv) 1262 { 1263 return -EINVAL; 1264 } 1265 EXPORT_SYMBOL(simple_nosetlease); 1266 1267 /** 1268 * simple_get_link - generic helper to get the target of "fast" symlinks 1269 * @dentry: not used here 1270 * @inode: the symlink inode 1271 * @done: not used here 1272 * 1273 * Generic helper for filesystems to use for symlink inodes where a pointer to 1274 * the symlink target is stored in ->i_link. NOTE: this isn't normally called, 1275 * since as an optimization the path lookup code uses any non-NULL ->i_link 1276 * directly, without calling ->get_link(). But ->get_link() still must be set, 1277 * to mark the inode_operations as being for a symlink. 1278 * 1279 * Return: the symlink target 1280 */ 1281 const char *simple_get_link(struct dentry *dentry, struct inode *inode, 1282 struct delayed_call *done) 1283 { 1284 return inode->i_link; 1285 } 1286 EXPORT_SYMBOL(simple_get_link); 1287 1288 const struct inode_operations simple_symlink_inode_operations = { 1289 .get_link = simple_get_link, 1290 }; 1291 EXPORT_SYMBOL(simple_symlink_inode_operations); 1292 1293 /* 1294 * Operations for a permanently empty directory. 1295 */ 1296 static struct dentry *empty_dir_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 1297 { 1298 return ERR_PTR(-ENOENT); 1299 } 1300 1301 static int empty_dir_getattr(struct user_namespace *mnt_userns, 1302 const struct path *path, struct kstat *stat, 1303 u32 request_mask, unsigned int query_flags) 1304 { 1305 struct inode *inode = d_inode(path->dentry); 1306 generic_fillattr(&init_user_ns, inode, stat); 1307 return 0; 1308 } 1309 1310 static int empty_dir_setattr(struct user_namespace *mnt_userns, 1311 struct dentry *dentry, struct iattr *attr) 1312 { 1313 return -EPERM; 1314 } 1315 1316 static ssize_t empty_dir_listxattr(struct dentry *dentry, char *list, size_t size) 1317 { 1318 return -EOPNOTSUPP; 1319 } 1320 1321 static const struct inode_operations empty_dir_inode_operations = { 1322 .lookup = empty_dir_lookup, 1323 .permission = generic_permission, 1324 .setattr = empty_dir_setattr, 1325 .getattr = empty_dir_getattr, 1326 .listxattr = empty_dir_listxattr, 1327 }; 1328 1329 static loff_t empty_dir_llseek(struct file *file, loff_t offset, int whence) 1330 { 1331 /* An empty directory has two entries . and .. at offsets 0 and 1 */ 1332 return generic_file_llseek_size(file, offset, whence, 2, 2); 1333 } 1334 1335 static int empty_dir_readdir(struct file *file, struct dir_context *ctx) 1336 { 1337 dir_emit_dots(file, ctx); 1338 return 0; 1339 } 1340 1341 static const struct file_operations empty_dir_operations = { 1342 .llseek = empty_dir_llseek, 1343 .read = generic_read_dir, 1344 .iterate_shared = empty_dir_readdir, 1345 .fsync = noop_fsync, 1346 }; 1347 1348 1349 void make_empty_dir_inode(struct inode *inode) 1350 { 1351 set_nlink(inode, 2); 1352 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; 1353 inode->i_uid = GLOBAL_ROOT_UID; 1354 inode->i_gid = GLOBAL_ROOT_GID; 1355 inode->i_rdev = 0; 1356 inode->i_size = 0; 1357 inode->i_blkbits = PAGE_SHIFT; 1358 inode->i_blocks = 0; 1359 1360 inode->i_op = &empty_dir_inode_operations; 1361 inode->i_opflags &= ~IOP_XATTR; 1362 inode->i_fop = &empty_dir_operations; 1363 } 1364 1365 bool is_empty_dir_inode(struct inode *inode) 1366 { 1367 return (inode->i_fop == &empty_dir_operations) && 1368 (inode->i_op == &empty_dir_inode_operations); 1369 } 1370 1371 #if IS_ENABLED(CONFIG_UNICODE) 1372 /* 1373 * Determine if the name of a dentry should be casefolded. 1374 * 1375 * Return: if names will need casefolding 1376 */ 1377 static bool needs_casefold(const struct inode *dir) 1378 { 1379 return IS_CASEFOLDED(dir) && dir->i_sb->s_encoding; 1380 } 1381 1382 /** 1383 * generic_ci_d_compare - generic d_compare implementation for casefolding filesystems 1384 * @dentry: dentry whose name we are checking against 1385 * @len: len of name of dentry 1386 * @str: str pointer to name of dentry 1387 * @name: Name to compare against 1388 * 1389 * Return: 0 if names match, 1 if mismatch, or -ERRNO 1390 */ 1391 static int generic_ci_d_compare(const struct dentry *dentry, unsigned int len, 1392 const char *str, const struct qstr *name) 1393 { 1394 const struct dentry *parent = READ_ONCE(dentry->d_parent); 1395 const struct inode *dir = READ_ONCE(parent->d_inode); 1396 const struct super_block *sb = dentry->d_sb; 1397 const struct unicode_map *um = sb->s_encoding; 1398 struct qstr qstr = QSTR_INIT(str, len); 1399 char strbuf[DNAME_INLINE_LEN]; 1400 int ret; 1401 1402 if (!dir || !needs_casefold(dir)) 1403 goto fallback; 1404 /* 1405 * If the dentry name is stored in-line, then it may be concurrently 1406 * modified by a rename. If this happens, the VFS will eventually retry 1407 * the lookup, so it doesn't matter what ->d_compare() returns. 1408 * However, it's unsafe to call utf8_strncasecmp() with an unstable 1409 * string. Therefore, we have to copy the name into a temporary buffer. 1410 */ 1411 if (len <= DNAME_INLINE_LEN - 1) { 1412 memcpy(strbuf, str, len); 1413 strbuf[len] = 0; 1414 qstr.name = strbuf; 1415 /* prevent compiler from optimizing out the temporary buffer */ 1416 barrier(); 1417 } 1418 ret = utf8_strncasecmp(um, name, &qstr); 1419 if (ret >= 0) 1420 return ret; 1421 1422 if (sb_has_strict_encoding(sb)) 1423 return -EINVAL; 1424 fallback: 1425 if (len != name->len) 1426 return 1; 1427 return !!memcmp(str, name->name, len); 1428 } 1429 1430 /** 1431 * generic_ci_d_hash - generic d_hash implementation for casefolding filesystems 1432 * @dentry: dentry of the parent directory 1433 * @str: qstr of name whose hash we should fill in 1434 * 1435 * Return: 0 if hash was successful or unchanged, and -EINVAL on error 1436 */ 1437 static int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str) 1438 { 1439 const struct inode *dir = READ_ONCE(dentry->d_inode); 1440 struct super_block *sb = dentry->d_sb; 1441 const struct unicode_map *um = sb->s_encoding; 1442 int ret = 0; 1443 1444 if (!dir || !needs_casefold(dir)) 1445 return 0; 1446 1447 ret = utf8_casefold_hash(um, dentry, str); 1448 if (ret < 0 && sb_has_strict_encoding(sb)) 1449 return -EINVAL; 1450 return 0; 1451 } 1452 1453 static const struct dentry_operations generic_ci_dentry_ops = { 1454 .d_hash = generic_ci_d_hash, 1455 .d_compare = generic_ci_d_compare, 1456 }; 1457 #endif 1458 1459 #ifdef CONFIG_FS_ENCRYPTION 1460 static const struct dentry_operations generic_encrypted_dentry_ops = { 1461 .d_revalidate = fscrypt_d_revalidate, 1462 }; 1463 #endif 1464 1465 #if defined(CONFIG_FS_ENCRYPTION) && IS_ENABLED(CONFIG_UNICODE) 1466 static const struct dentry_operations generic_encrypted_ci_dentry_ops = { 1467 .d_hash = generic_ci_d_hash, 1468 .d_compare = generic_ci_d_compare, 1469 .d_revalidate = fscrypt_d_revalidate, 1470 }; 1471 #endif 1472 1473 /** 1474 * generic_set_encrypted_ci_d_ops - helper for setting d_ops for given dentry 1475 * @dentry: dentry to set ops on 1476 * 1477 * Casefolded directories need d_hash and d_compare set, so that the dentries 1478 * contained in them are handled case-insensitively. Note that these operations 1479 * are needed on the parent directory rather than on the dentries in it, and 1480 * while the casefolding flag can be toggled on and off on an empty directory, 1481 * dentry_operations can't be changed later. As a result, if the filesystem has 1482 * casefolding support enabled at all, we have to give all dentries the 1483 * casefolding operations even if their inode doesn't have the casefolding flag 1484 * currently (and thus the casefolding ops would be no-ops for now). 1485 * 1486 * Encryption works differently in that the only dentry operation it needs is 1487 * d_revalidate, which it only needs on dentries that have the no-key name flag. 1488 * The no-key flag can't be set "later", so we don't have to worry about that. 1489 * 1490 * Finally, to maximize compatibility with overlayfs (which isn't compatible 1491 * with certain dentry operations) and to avoid taking an unnecessary 1492 * performance hit, we use custom dentry_operations for each possible 1493 * combination rather than always installing all operations. 1494 */ 1495 void generic_set_encrypted_ci_d_ops(struct dentry *dentry) 1496 { 1497 #ifdef CONFIG_FS_ENCRYPTION 1498 bool needs_encrypt_ops = dentry->d_flags & DCACHE_NOKEY_NAME; 1499 #endif 1500 #if IS_ENABLED(CONFIG_UNICODE) 1501 bool needs_ci_ops = dentry->d_sb->s_encoding; 1502 #endif 1503 #if defined(CONFIG_FS_ENCRYPTION) && IS_ENABLED(CONFIG_UNICODE) 1504 if (needs_encrypt_ops && needs_ci_ops) { 1505 d_set_d_op(dentry, &generic_encrypted_ci_dentry_ops); 1506 return; 1507 } 1508 #endif 1509 #ifdef CONFIG_FS_ENCRYPTION 1510 if (needs_encrypt_ops) { 1511 d_set_d_op(dentry, &generic_encrypted_dentry_ops); 1512 return; 1513 } 1514 #endif 1515 #if IS_ENABLED(CONFIG_UNICODE) 1516 if (needs_ci_ops) { 1517 d_set_d_op(dentry, &generic_ci_dentry_ops); 1518 return; 1519 } 1520 #endif 1521 } 1522 EXPORT_SYMBOL(generic_set_encrypted_ci_d_ops); 1523