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