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