FILE
fs.h
File preview with syntax highlighting.
linux-6.19.14/include/linux/fs.h
1/* SPDX-License-Identifier: GPL-2.0 */ 2#ifndef _LINUX_FS_H 3#define _LINUX_FS_H 4 5#include <linux/fs/super.h> 6#include <linux/vfsdebug.h> 7#include <linux/linkage.h> 8#include <linux/wait_bit.h> 9#include <linux/kdev_t.h> 10#include <linux/dcache.h> 11#include <linux/path.h> 12#include <linux/stat.h> 13#include <linux/cache.h> 14#include <linux/list.h> 15#include <linux/llist.h> 16#include <linux/radix-tree.h> 17#include <linux/xarray.h> 18#include <linux/rbtree.h> 19#include <linux/init.h> 20#include <linux/pid.h> 21#include <linux/bug.h> 22#include <linux/mutex.h> 23#include <linux/rwsem.h> 24#include <linux/mm_types.h> 25#include <linux/capability.h> 26#include <linux/semaphore.h> 27#include <linux/fcntl.h> 28#include <linux/rculist_bl.h> 29#include <linux/atomic.h> 30#include <linux/shrinker.h> 31#include <linux/migrate_mode.h> 32#include <linux/uidgid.h> 33#include <linux/lockdep.h> 34#include <linux/percpu-rwsem.h> 35#include <linux/workqueue.h> 36#include <linux/delayed_call.h> 37#include <linux/uuid.h> 38#include <linux/errseq.h> 39#include <linux/ioprio.h> 40#include <linux/build_bug.h> 41#include <linux/stddef.h> 42#include <linux/mount.h> 43#include <linux/cred.h> 44#include <linux/mnt_idmapping.h> 45#include <linux/slab.h> 46#include <linux/maple_tree.h> 47#include <linux/rw_hint.h> 48#include <linux/file_ref.h> 49#include <linux/unicode.h> 50 51#include <asm/byteorder.h> 52#include <uapi/linux/fs.h> 53 54struct bdi_writeback; 55struct bio; 56struct io_comp_batch; 57struct fiemap_extent_info; 58struct hd_geometry; 59struct iovec; 60struct kiocb; 61struct kobject; 62struct pipe_inode_info; 63struct poll_table_struct; 64struct kstatfs; 65struct vm_area_struct; 66struct vfsmount; 67struct cred; 68struct swap_info_struct; 69struct seq_file; 70struct iov_iter; 71struct fsnotify_mark_connector; 72struct fs_context; 73struct fs_parameter_spec; 74struct file_kattr; 75struct iomap_ops; 76struct delegated_inode; 77 78extern void __init inode_init(void); 79extern void __init inode_init_early(void); 80extern void __init files_init(void); 81extern void __init files_maxfiles_init(void); 82 83extern unsigned long get_max_files(void); 84extern unsigned int sysctl_nr_open; 85 86typedef __kernel_rwf_t rwf_t; 87 88struct buffer_head; 89typedef int (get_block_t)(struct inode *inode, sector_t iblock, 90 struct buffer_head *bh_result, int create); 91typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset, 92 ssize_t bytes, void *private); 93 94#define MAY_EXEC 0x00000001 95#define MAY_WRITE 0x00000002 96#define MAY_READ 0x00000004 97#define MAY_APPEND 0x00000008 98#define MAY_ACCESS 0x00000010 99#define MAY_OPEN 0x00000020 100#define MAY_CHDIR 0x00000040 101/* called from RCU mode, don't block */ 102#define MAY_NOT_BLOCK 0x00000080 103 104/* 105 * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond 106 * to O_WRONLY and O_RDWR via the strange trick in do_dentry_open() 107 */ 108 109/* file is open for reading */ 110#define FMODE_READ ((__force fmode_t)(1 << 0)) 111/* file is open for writing */ 112#define FMODE_WRITE ((__force fmode_t)(1 << 1)) 113/* file is seekable */ 114#define FMODE_LSEEK ((__force fmode_t)(1 << 2)) 115/* file can be accessed using pread */ 116#define FMODE_PREAD ((__force fmode_t)(1 << 3)) 117/* file can be accessed using pwrite */ 118#define FMODE_PWRITE ((__force fmode_t)(1 << 4)) 119/* File is opened for execution with sys_execve / sys_uselib */ 120#define FMODE_EXEC ((__force fmode_t)(1 << 5)) 121/* File writes are restricted (block device specific) */ 122#define FMODE_WRITE_RESTRICTED ((__force fmode_t)(1 << 6)) 123/* File supports atomic writes */ 124#define FMODE_CAN_ATOMIC_WRITE ((__force fmode_t)(1 << 7)) 125 126/* FMODE_* bit 8 */ 127 128/* 32bit hashes as llseek() offset (for directories) */ 129#define FMODE_32BITHASH ((__force fmode_t)(1 << 9)) 130/* 64bit hashes as llseek() offset (for directories) */ 131#define FMODE_64BITHASH ((__force fmode_t)(1 << 10)) 132 133/* 134 * Don't update ctime and mtime. 135 * 136 * Currently a special hack for the XFS open_by_handle ioctl, but we'll 137 * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon. 138 */ 139#define FMODE_NOCMTIME ((__force fmode_t)(1 << 11)) 140 141/* Expect random access pattern */ 142#define FMODE_RANDOM ((__force fmode_t)(1 << 12)) 143 144/* Supports IOCB_HAS_METADATA */ 145#define FMODE_HAS_METADATA ((__force fmode_t)(1 << 13)) 146 147/* File is opened with O_PATH; almost nothing can be done with it */ 148#define FMODE_PATH ((__force fmode_t)(1 << 14)) 149 150/* File needs atomic accesses to f_pos */ 151#define FMODE_ATOMIC_POS ((__force fmode_t)(1 << 15)) 152/* Write access to underlying fs */ 153#define FMODE_WRITER ((__force fmode_t)(1 << 16)) 154/* Has read method(s) */ 155#define FMODE_CAN_READ ((__force fmode_t)(1 << 17)) 156/* Has write method(s) */ 157#define FMODE_CAN_WRITE ((__force fmode_t)(1 << 18)) 158 159#define FMODE_OPENED ((__force fmode_t)(1 << 19)) 160#define FMODE_CREATED ((__force fmode_t)(1 << 20)) 161 162/* File is stream-like */ 163#define FMODE_STREAM ((__force fmode_t)(1 << 21)) 164 165/* File supports DIRECT IO */ 166#define FMODE_CAN_ODIRECT ((__force fmode_t)(1 << 22)) 167 168#define FMODE_NOREUSE ((__force fmode_t)(1 << 23)) 169 170/* File is embedded in backing_file object */ 171#define FMODE_BACKING ((__force fmode_t)(1 << 24)) 172 173/* 174 * Together with FMODE_NONOTIFY_PERM defines which fsnotify events shouldn't be 175 * generated (see below) 176 */ 177#define FMODE_NONOTIFY ((__force fmode_t)(1 << 25)) 178 179/* 180 * Together with FMODE_NONOTIFY defines which fsnotify events shouldn't be 181 * generated (see below) 182 */ 183#define FMODE_NONOTIFY_PERM ((__force fmode_t)(1 << 26)) 184 185/* File is capable of returning -EAGAIN if I/O will block */ 186#define FMODE_NOWAIT ((__force fmode_t)(1 << 27)) 187 188/* File represents mount that needs unmounting */ 189#define FMODE_NEED_UNMOUNT ((__force fmode_t)(1 << 28)) 190 191/* File does not contribute to nr_files count */ 192#define FMODE_NOACCOUNT ((__force fmode_t)(1 << 29)) 193 194/* 195 * The two FMODE_NONOTIFY* define which fsnotify events should not be generated 196 * for an open file. These are the possible values of 197 * (f->f_mode & FMODE_FSNOTIFY_MASK) and their meaning: 198 * 199 * FMODE_NONOTIFY - suppress all (incl. non-permission) events. 200 * FMODE_NONOTIFY_PERM - suppress permission (incl. pre-content) events. 201 * FMODE_NONOTIFY | FMODE_NONOTIFY_PERM - suppress only FAN_ACCESS_PERM. 202 */ 203#define FMODE_FSNOTIFY_MASK \ 204 (FMODE_NONOTIFY | FMODE_NONOTIFY_PERM) 205 206#define FMODE_FSNOTIFY_NONE(mode) \ 207 ((mode & FMODE_FSNOTIFY_MASK) == FMODE_NONOTIFY) 208#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 209#define FMODE_FSNOTIFY_HSM(mode) \ 210 ((mode & FMODE_FSNOTIFY_MASK) == 0 || \ 211 (mode & FMODE_FSNOTIFY_MASK) == (FMODE_NONOTIFY | FMODE_NONOTIFY_PERM)) 212#define FMODE_FSNOTIFY_ACCESS_PERM(mode) \ 213 ((mode & FMODE_FSNOTIFY_MASK) == 0) 214#else 215#define FMODE_FSNOTIFY_ACCESS_PERM(mode) 0 216#define FMODE_FSNOTIFY_HSM(mode) 0 217#endif 218 219/* 220 * Attribute flags. These should be or-ed together to figure out what 221 * has been changed! 222 */ 223#define ATTR_MODE (1 << 0) 224#define ATTR_UID (1 << 1) 225#define ATTR_GID (1 << 2) 226#define ATTR_SIZE (1 << 3) 227#define ATTR_ATIME (1 << 4) 228#define ATTR_MTIME (1 << 5) 229#define ATTR_CTIME (1 << 6) 230#define ATTR_ATIME_SET (1 << 7) 231#define ATTR_MTIME_SET (1 << 8) 232#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */ 233#define ATTR_CTIME_SET (1 << 10) 234#define ATTR_KILL_SUID (1 << 11) 235#define ATTR_KILL_SGID (1 << 12) 236#define ATTR_FILE (1 << 13) 237#define ATTR_KILL_PRIV (1 << 14) 238#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */ 239#define ATTR_TIMES_SET (1 << 16) 240#define ATTR_TOUCH (1 << 17) 241#define ATTR_DELEG (1 << 18) /* Delegated attrs. Don't break write delegations */ 242 243/* 244 * Whiteout is represented by a char device. The following constants define the 245 * mode and device number to use. 246 */ 247#define WHITEOUT_MODE 0 248#define WHITEOUT_DEV 0 249 250/* 251 * This is the Inode Attributes structure, used for notify_change(). It 252 * uses the above definitions as flags, to know which values have changed. 253 * Also, in this manner, a Filesystem can look at only the values it cares 254 * about. Basically, these are the attributes that the VFS layer can 255 * request to change from the FS layer. 256 * 257 * Derek Atkins <warlord@MIT.EDU> 94-10-20 258 */ 259struct iattr { 260 unsigned int ia_valid; 261 umode_t ia_mode; 262 /* 263 * The two anonymous unions wrap structures with the same member. 264 * 265 * Filesystems raising FS_ALLOW_IDMAP need to use ia_vfs{g,u}id which 266 * are a dedicated type requiring the filesystem to use the dedicated 267 * helpers. Other filesystem can continue to use ia_{g,u}id until they 268 * have been ported. 269 * 270 * They always contain the same value. In other words FS_ALLOW_IDMAP 271 * pass down the same value on idmapped mounts as they would on regular 272 * mounts. 273 */ 274 union { 275 kuid_t ia_uid; 276 vfsuid_t ia_vfsuid; 277 }; 278 union { 279 kgid_t ia_gid; 280 vfsgid_t ia_vfsgid; 281 }; 282 loff_t ia_size; 283 struct timespec64 ia_atime; 284 struct timespec64 ia_mtime; 285 struct timespec64 ia_ctime; 286 287 /* 288 * Not an attribute, but an auxiliary info for filesystems wanting to 289 * implement an ftruncate() like method. NOTE: filesystem should 290 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL). 291 */ 292 struct file *ia_file; 293}; 294 295/* 296 * Maximum number of layers of fs stack. Needs to be limited to 297 * prevent kernel stack overflow 298 */ 299#define FILESYSTEM_MAX_STACK_DEPTH 2 300 301/** 302 * enum positive_aop_returns - aop return codes with specific semantics 303 * 304 * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has 305 * completed, that the page is still locked, and 306 * should be considered active. The VM uses this hint 307 * to return the page to the active list -- it won't 308 * be a candidate for writeback again in the near 309 * future. Other callers must be careful to unlock 310 * the page if they get this return. Returned by 311 * writepage(); 312 * 313 * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has 314 * unlocked it and the page might have been truncated. 315 * The caller should back up to acquiring a new page and 316 * trying again. The aop will be taking reasonable 317 * precautions not to livelock. If the caller held a page 318 * reference, it should drop it before retrying. Returned 319 * by read_folio(). 320 * 321 * address_space_operation functions return these large constants to indicate 322 * special semantics to the caller. These are much larger than the bytes in a 323 * page to allow for functions that return the number of bytes operated on in a 324 * given page. 325 */ 326 327enum positive_aop_returns { 328 AOP_WRITEPAGE_ACTIVATE = 0x80000, 329 AOP_TRUNCATED_PAGE = 0x80001, 330}; 331 332/* 333 * oh the beauties of C type declarations. 334 */ 335struct page; 336struct address_space; 337struct writeback_control; 338struct readahead_control; 339 340/* Match RWF_* bits to IOCB bits */ 341#define IOCB_HIPRI (__force int) RWF_HIPRI 342#define IOCB_DSYNC (__force int) RWF_DSYNC 343#define IOCB_SYNC (__force int) RWF_SYNC 344#define IOCB_NOWAIT (__force int) RWF_NOWAIT 345#define IOCB_APPEND (__force int) RWF_APPEND 346#define IOCB_ATOMIC (__force int) RWF_ATOMIC 347#define IOCB_DONTCACHE (__force int) RWF_DONTCACHE 348#define IOCB_NOSIGNAL (__force int) RWF_NOSIGNAL 349 350/* non-RWF related bits - start at 16 */ 351#define IOCB_EVENTFD (1 << 16) 352#define IOCB_DIRECT (1 << 17) 353#define IOCB_WRITE (1 << 18) 354/* iocb->ki_waitq is valid */ 355#define IOCB_WAITQ (1 << 19) 356#define IOCB_NOIO (1 << 20) 357/* can use bio alloc cache */ 358#define IOCB_ALLOC_CACHE (1 << 21) 359/* kiocb is a read or write operation submitted by fs/aio.c. */ 360#define IOCB_AIO_RW (1 << 22) 361#define IOCB_HAS_METADATA (1 << 23) 362 363/* for use in trace events */ 364#define TRACE_IOCB_STRINGS \ 365 { IOCB_HIPRI, "HIPRI" }, \ 366 { IOCB_DSYNC, "DSYNC" }, \ 367 { IOCB_SYNC, "SYNC" }, \ 368 { IOCB_NOWAIT, "NOWAIT" }, \ 369 { IOCB_APPEND, "APPEND" }, \ 370 { IOCB_ATOMIC, "ATOMIC" }, \ 371 { IOCB_DONTCACHE, "DONTCACHE" }, \ 372 { IOCB_EVENTFD, "EVENTFD"}, \ 373 { IOCB_DIRECT, "DIRECT" }, \ 374 { IOCB_WRITE, "WRITE" }, \ 375 { IOCB_WAITQ, "WAITQ" }, \ 376 { IOCB_NOIO, "NOIO" }, \ 377 { IOCB_ALLOC_CACHE, "ALLOC_CACHE" }, \ 378 { IOCB_AIO_RW, "AIO_RW" }, \ 379 { IOCB_HAS_METADATA, "AIO_HAS_METADATA" } 380 381struct kiocb { 382 struct file *ki_filp; 383 loff_t ki_pos; 384 void (*ki_complete)(struct kiocb *iocb, long ret); 385 void *private; 386 int ki_flags; 387 u16 ki_ioprio; /* See linux/ioprio.h */ 388 u8 ki_write_stream; 389 390 /* 391 * Only used for async buffered reads, where it denotes the page 392 * waitqueue associated with completing the read. 393 * Valid IFF IOCB_WAITQ is set. 394 */ 395 struct wait_page_queue *ki_waitq; 396}; 397 398static inline bool is_sync_kiocb(struct kiocb *kiocb) 399{ 400 return kiocb->ki_complete == NULL; 401} 402 403struct address_space_operations { 404 int (*read_folio)(struct file *, struct folio *); 405 406 /* Write back some dirty pages from this mapping. */ 407 int (*writepages)(struct address_space *, struct writeback_control *); 408 409 /* Mark a folio dirty. Return true if this dirtied it */ 410 bool (*dirty_folio)(struct address_space *, struct folio *); 411 412 void (*readahead)(struct readahead_control *); 413 414 int (*write_begin)(const struct kiocb *, struct address_space *mapping, 415 loff_t pos, unsigned len, 416 struct folio **foliop, void **fsdata); 417 int (*write_end)(const struct kiocb *, struct address_space *mapping, 418 loff_t pos, unsigned len, unsigned copied, 419 struct folio *folio, void *fsdata); 420 421 /* Unfortunately this kludge is needed for FIBMAP. Don't use it */ 422 sector_t (*bmap)(struct address_space *, sector_t); 423 void (*invalidate_folio) (struct folio *, size_t offset, size_t len); 424 bool (*release_folio)(struct folio *, gfp_t); 425 void (*free_folio)(struct folio *folio); 426 ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter); 427 /* 428 * migrate the contents of a folio to the specified target. If 429 * migrate_mode is MIGRATE_ASYNC, it must not block. 430 */ 431 int (*migrate_folio)(struct address_space *, struct folio *dst, 432 struct folio *src, enum migrate_mode); 433 int (*launder_folio)(struct folio *); 434 bool (*is_partially_uptodate) (struct folio *, size_t from, 435 size_t count); 436 void (*is_dirty_writeback) (struct folio *, bool *dirty, bool *wb); 437 int (*error_remove_folio)(struct address_space *, struct folio *); 438 439 /* swapfile support */ 440 int (*swap_activate)(struct swap_info_struct *sis, struct file *file, 441 sector_t *span); 442 void (*swap_deactivate)(struct file *file); 443 int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter); 444}; 445 446extern const struct address_space_operations empty_aops; 447 448/** 449 * struct address_space - Contents of a cacheable, mappable object. 450 * @host: Owner, either the inode or the block_device. 451 * @i_pages: Cached pages. 452 * @invalidate_lock: Guards coherency between page cache contents and 453 * file offset->disk block mappings in the filesystem during invalidates. 454 * It is also used to block modification of page cache contents through 455 * memory mappings. 456 * @gfp_mask: Memory allocation flags to use for allocating pages. 457 * @i_mmap_writable: Number of VM_SHARED, VM_MAYWRITE mappings. 458 * @nr_thps: Number of THPs in the pagecache (non-shmem only). 459 * @i_mmap: Tree of private and shared mappings. 460 * @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable. 461 * @nrpages: Number of page entries, protected by the i_pages lock. 462 * @writeback_index: Writeback starts here. 463 * @a_ops: Methods. 464 * @flags: Error bits and flags (AS_*). 465 * @wb_err: The most recent error which has occurred. 466 * @i_private_lock: For use by the owner of the address_space. 467 * @i_private_list: For use by the owner of the address_space. 468 * @i_private_data: For use by the owner of the address_space. 469 */ 470struct address_space { 471 struct inode *host; 472 struct xarray i_pages; 473 struct rw_semaphore invalidate_lock; 474 gfp_t gfp_mask; 475 atomic_t i_mmap_writable; 476#ifdef CONFIG_READ_ONLY_THP_FOR_FS 477 /* number of thp, only for non-shmem files */ 478 atomic_t nr_thps; 479#endif 480 struct rb_root_cached i_mmap; 481 unsigned long nrpages; 482 pgoff_t writeback_index; 483 const struct address_space_operations *a_ops; 484 unsigned long flags; 485 errseq_t wb_err; 486 spinlock_t i_private_lock; 487 struct list_head i_private_list; 488 struct rw_semaphore i_mmap_rwsem; 489 void * i_private_data; 490} __attribute__((aligned(sizeof(long)))) __randomize_layout; 491 /* 492 * On most architectures that alignment is already the case; but 493 * must be enforced here for CRIS, to let the least significant bit 494 * of struct folio's "mapping" pointer be used for FOLIO_MAPPING_ANON. 495 */ 496 497/* XArray tags, for tagging dirty and writeback pages in the pagecache. */ 498#define PAGECACHE_TAG_DIRTY XA_MARK_0 499#define PAGECACHE_TAG_WRITEBACK XA_MARK_1 500#define PAGECACHE_TAG_TOWRITE XA_MARK_2 501 502/* 503 * Returns true if any of the pages in the mapping are marked with the tag. 504 */ 505static inline bool mapping_tagged(const struct address_space *mapping, xa_mark_t tag) 506{ 507 return xa_marked(&mapping->i_pages, tag); 508} 509 510static inline void i_mmap_lock_write(struct address_space *mapping) 511{ 512 down_write(&mapping->i_mmap_rwsem); 513} 514 515static inline int i_mmap_trylock_write(struct address_space *mapping) 516{ 517 return down_write_trylock(&mapping->i_mmap_rwsem); 518} 519 520static inline void i_mmap_unlock_write(struct address_space *mapping) 521{ 522 up_write(&mapping->i_mmap_rwsem); 523} 524 525static inline int i_mmap_trylock_read(struct address_space *mapping) 526{ 527 return down_read_trylock(&mapping->i_mmap_rwsem); 528} 529 530static inline void i_mmap_lock_read(struct address_space *mapping) 531{ 532 down_read(&mapping->i_mmap_rwsem); 533} 534 535static inline void i_mmap_unlock_read(struct address_space *mapping) 536{ 537 up_read(&mapping->i_mmap_rwsem); 538} 539 540static inline void i_mmap_assert_locked(struct address_space *mapping) 541{ 542 lockdep_assert_held(&mapping->i_mmap_rwsem); 543} 544 545static inline void i_mmap_assert_write_locked(struct address_space *mapping) 546{ 547 lockdep_assert_held_write(&mapping->i_mmap_rwsem); 548} 549 550/* 551 * Might pages of this file be mapped into userspace? 552 */ 553static inline int mapping_mapped(const struct address_space *mapping) 554{ 555 return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root); 556} 557 558/* 559 * Might pages of this file have been modified in userspace? 560 * Note that i_mmap_writable counts all VM_SHARED, VM_MAYWRITE vmas: do_mmap 561 * marks vma as VM_SHARED if it is shared, and the file was opened for 562 * writing i.e. vma may be mprotected writable even if now readonly. 563 * 564 * If i_mmap_writable is negative, no new writable mappings are allowed. You 565 * can only deny writable mappings, if none exists right now. 566 */ 567static inline int mapping_writably_mapped(const struct address_space *mapping) 568{ 569 return atomic_read(&mapping->i_mmap_writable) > 0; 570} 571 572static inline int mapping_map_writable(struct address_space *mapping) 573{ 574 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ? 575 0 : -EPERM; 576} 577 578static inline void mapping_unmap_writable(struct address_space *mapping) 579{ 580 atomic_dec(&mapping->i_mmap_writable); 581} 582 583static inline int mapping_deny_writable(struct address_space *mapping) 584{ 585 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ? 586 0 : -EBUSY; 587} 588 589static inline void mapping_allow_writable(struct address_space *mapping) 590{ 591 atomic_inc(&mapping->i_mmap_writable); 592} 593 594/* 595 * Use sequence counter to get consistent i_size on 32-bit processors. 596 */ 597#if BITS_PER_LONG==32 && defined(CONFIG_SMP) 598#include <linux/seqlock.h> 599#define __NEED_I_SIZE_ORDERED 600#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount) 601#else 602#define i_size_ordered_init(inode) do { } while (0) 603#endif 604 605struct posix_acl; 606#define ACL_NOT_CACHED ((void *)(-1)) 607/* 608 * ACL_DONT_CACHE is for stacked filesystems, that rely on underlying fs to 609 * cache the ACL. This also means that ->get_inode_acl() can be called in RCU 610 * mode with the LOOKUP_RCU flag. 611 */ 612#define ACL_DONT_CACHE ((void *)(-3)) 613 614static inline struct posix_acl * 615uncached_acl_sentinel(struct task_struct *task) 616{ 617 return (void *)task + 1; 618} 619 620static inline bool 621is_uncached_acl(struct posix_acl *acl) 622{ 623 return (long)acl & 1; 624} 625 626#define IOP_FASTPERM 0x0001 627#define IOP_LOOKUP 0x0002 628#define IOP_NOFOLLOW 0x0004 629#define IOP_XATTR 0x0008 630#define IOP_DEFAULT_READLINK 0x0010 631#define IOP_MGTIME 0x0020 632#define IOP_CACHED_LINK 0x0040 633#define IOP_FASTPERM_MAY_EXEC 0x0080 634 635/* 636 * Inode state bits. Protected by inode->i_lock 637 * 638 * Four bits determine the dirty state of the inode: I_DIRTY_SYNC, 639 * I_DIRTY_DATASYNC, I_DIRTY_PAGES, and I_DIRTY_TIME. 640 * 641 * Four bits define the lifetime of an inode. Initially, inodes are I_NEW, 642 * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at 643 * various stages of removing an inode. 644 * 645 * Two bits are used for locking and completion notification, I_NEW and I_SYNC. 646 * 647 * I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on 648 * fdatasync() (unless I_DIRTY_DATASYNC is also set). 649 * Timestamp updates are the usual cause. 650 * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of 651 * these changes separately from I_DIRTY_SYNC so that we 652 * don't have to write inode on fdatasync() when only 653 * e.g. the timestamps have changed. 654 * I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean. 655 * I_DIRTY_TIME The inode itself has dirty timestamps, and the 656 * lazytime mount option is enabled. We keep track of this 657 * separately from I_DIRTY_SYNC in order to implement 658 * lazytime. This gets cleared if I_DIRTY_INODE 659 * (I_DIRTY_SYNC and/or I_DIRTY_DATASYNC) gets set. But 660 * I_DIRTY_TIME can still be set if I_DIRTY_SYNC is already 661 * in place because writeback might already be in progress 662 * and we don't want to lose the time update 663 * I_NEW Serves as both a mutex and completion notification. 664 * New inodes set I_NEW. If two processes both create 665 * the same inode, one of them will release its inode and 666 * wait for I_NEW to be released before returning. 667 * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can 668 * also cause waiting on I_NEW, without I_NEW actually 669 * being set. find_inode() uses this to prevent returning 670 * nearly-dead inodes. 671 * I_WILL_FREE Must be set when calling write_inode_now() if i_count 672 * is zero. I_FREEING must be set when I_WILL_FREE is 673 * cleared. 674 * I_FREEING Set when inode is about to be freed but still has dirty 675 * pages or buffers attached or the inode itself is still 676 * dirty. 677 * I_CLEAR Added by clear_inode(). In this state the inode is 678 * clean and can be destroyed. Inode keeps I_FREEING. 679 * 680 * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are 681 * prohibited for many purposes. iget() must wait for 682 * the inode to be completely released, then create it 683 * anew. Other functions will just ignore such inodes, 684 * if appropriate. I_NEW is used for waiting. 685 * 686 * I_SYNC Writeback of inode is running. The bit is set during 687 * data writeback, and cleared with a wakeup on the bit 688 * address once it is done. The bit is also used to pin 689 * the inode in memory for flusher thread. 690 * 691 * I_REFERENCED Marks the inode as recently references on the LRU list. 692 * 693 * I_WB_SWITCH Cgroup bdi_writeback switching in progress. Used to 694 * synchronize competing switching instances and to tell 695 * wb stat updates to grab the i_pages lock. See 696 * inode_switch_wbs_work_fn() for details. 697 * 698 * I_OVL_INUSE Used by overlayfs to get exclusive ownership on upper 699 * and work dirs among overlayfs mounts. 700 * 701 * I_CREATING New object's inode in the middle of setting up. 702 * 703 * I_DONTCACHE Evict inode as soon as it is not used anymore. 704 * 705 * I_SYNC_QUEUED Inode is queued in b_io or b_more_io writeback lists. 706 * Used to detect that mark_inode_dirty() should not move 707 * inode between dirty lists. 708 * 709 * I_PINNING_FSCACHE_WB Inode is pinning an fscache object for writeback. 710 * 711 * I_LRU_ISOLATING Inode is pinned being isolated from LRU without holding 712 * i_count. 713 * 714 * Q: What is the difference between I_WILL_FREE and I_FREEING? 715 * 716 * __I_{SYNC,NEW,LRU_ISOLATING} are used to derive unique addresses to wait 717 * upon. There's one free address left. 718 */ 719 720enum inode_state_bits { 721 __I_NEW = 0U, 722 __I_SYNC = 1U, 723 __I_LRU_ISOLATING = 2U 724 /* reserved wait address bit 3 */ 725}; 726 727enum inode_state_flags_enum { 728 I_NEW = (1U << __I_NEW), 729 I_SYNC = (1U << __I_SYNC), 730 I_LRU_ISOLATING = (1U << __I_LRU_ISOLATING), 731 /* reserved flag bit 3 */ 732 I_DIRTY_SYNC = (1U << 4), 733 I_DIRTY_DATASYNC = (1U << 5), 734 I_DIRTY_PAGES = (1U << 6), 735 I_WILL_FREE = (1U << 7), 736 I_FREEING = (1U << 8), 737 I_CLEAR = (1U << 9), 738 I_REFERENCED = (1U << 10), 739 I_LINKABLE = (1U << 11), 740 I_DIRTY_TIME = (1U << 12), 741 I_WB_SWITCH = (1U << 13), 742 I_OVL_INUSE = (1U << 14), 743 I_CREATING = (1U << 15), 744 I_DONTCACHE = (1U << 16), 745 I_SYNC_QUEUED = (1U << 17), 746 I_PINNING_NETFS_WB = (1U << 18) 747}; 748 749#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC) 750#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES) 751#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME) 752 753/* 754 * Use inode_state_read() & friends to access. 755 */ 756struct inode_state_flags { 757 enum inode_state_flags_enum __state; 758}; 759 760/* 761 * Keep mostly read-only and often accessed (especially for 762 * the RCU path lookup and 'stat' data) fields at the beginning 763 * of the 'struct inode' 764 */ 765struct inode { 766 umode_t i_mode; 767 unsigned short i_opflags; 768 unsigned int i_flags; 769#ifdef CONFIG_FS_POSIX_ACL 770 struct posix_acl *i_acl; 771 struct posix_acl *i_default_acl; 772#endif 773 kuid_t i_uid; 774 kgid_t i_gid; 775 776 const struct inode_operations *i_op; 777 struct super_block *i_sb; 778 struct address_space *i_mapping; 779 780#ifdef CONFIG_SECURITY 781 void *i_security; 782#endif 783 784 /* Stat data, not accessed from path walking */ 785 unsigned long i_ino; 786 /* 787 * Filesystems may only read i_nlink directly. They shall use the 788 * following functions for modification: 789 * 790 * (set|clear|inc|drop)_nlink 791 * inode_(inc|dec)_link_count 792 */ 793 union { 794 const unsigned int i_nlink; 795 unsigned int __i_nlink; 796 }; 797 dev_t i_rdev; 798 loff_t i_size; 799 time64_t i_atime_sec; 800 time64_t i_mtime_sec; 801 time64_t i_ctime_sec; 802 u32 i_atime_nsec; 803 u32 i_mtime_nsec; 804 u32 i_ctime_nsec; 805 u32 i_generation; 806 spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */ 807 unsigned short i_bytes; 808 u8 i_blkbits; 809 enum rw_hint i_write_hint; 810 blkcnt_t i_blocks; 811 812#ifdef __NEED_I_SIZE_ORDERED 813 seqcount_t i_size_seqcount; 814#endif 815 816 /* Misc */ 817 struct inode_state_flags i_state; 818 /* 32-bit hole */ 819 struct rw_semaphore i_rwsem; 820 821 unsigned long dirtied_when; /* jiffies of first dirtying */ 822 unsigned long dirtied_time_when; 823 824 struct hlist_node i_hash; 825 struct list_head i_io_list; /* backing dev IO list */ 826#ifdef CONFIG_CGROUP_WRITEBACK 827 struct bdi_writeback *i_wb; /* the associated cgroup wb */ 828 829 /* foreign inode detection, see wbc_detach_inode() */ 830 int i_wb_frn_winner; 831 u16 i_wb_frn_avg_time; 832 u16 i_wb_frn_history; 833#endif 834 struct list_head i_lru; /* inode LRU list */ 835 struct list_head i_sb_list; 836 struct list_head i_wb_list; /* backing dev writeback list */ 837 union { 838 struct hlist_head i_dentry; 839 struct rcu_head i_rcu; 840 }; 841 atomic64_t i_version; 842 atomic64_t i_sequence; /* see futex */ 843 atomic_t i_count; 844 atomic_t i_dio_count; 845 atomic_t i_writecount; 846#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING) 847 atomic_t i_readcount; /* struct files open RO */ 848#endif 849 union { 850 const struct file_operations *i_fop; /* former ->i_op->default_file_ops */ 851 void (*free_inode)(struct inode *); 852 }; 853 struct file_lock_context *i_flctx; 854 struct address_space i_data; 855 union { 856 struct list_head i_devices; 857 int i_linklen; 858 }; 859 union { 860 struct pipe_inode_info *i_pipe; 861 struct cdev *i_cdev; 862 char *i_link; 863 unsigned i_dir_seq; 864 }; 865 866 867#ifdef CONFIG_FSNOTIFY 868 __u32 i_fsnotify_mask; /* all events this inode cares about */ 869 /* 32-bit hole reserved for expanding i_fsnotify_mask */ 870 struct fsnotify_mark_connector __rcu *i_fsnotify_marks; 871#endif 872 873 void *i_private; /* fs or device private pointer */ 874} __randomize_layout; 875 876/* 877 * i_state handling 878 * 879 * We hide all of it behind helpers so that we can validate consumers. 880 */ 881static inline enum inode_state_flags_enum inode_state_read_once(struct inode *inode) 882{ 883 return READ_ONCE(inode->i_state.__state); 884} 885 886static inline enum inode_state_flags_enum inode_state_read(struct inode *inode) 887{ 888 lockdep_assert_held(&inode->i_lock); 889 return inode->i_state.__state; 890} 891 892static inline void inode_state_set_raw(struct inode *inode, 893 enum inode_state_flags_enum flags) 894{ 895 WRITE_ONCE(inode->i_state.__state, inode->i_state.__state | flags); 896} 897 898static inline void inode_state_set(struct inode *inode, 899 enum inode_state_flags_enum flags) 900{ 901 lockdep_assert_held(&inode->i_lock); 902 inode_state_set_raw(inode, flags); 903} 904 905static inline void inode_state_clear_raw(struct inode *inode, 906 enum inode_state_flags_enum flags) 907{ 908 WRITE_ONCE(inode->i_state.__state, inode->i_state.__state & ~flags); 909} 910 911static inline void inode_state_clear(struct inode *inode, 912 enum inode_state_flags_enum flags) 913{ 914 lockdep_assert_held(&inode->i_lock); 915 inode_state_clear_raw(inode, flags); 916} 917 918static inline void inode_state_assign_raw(struct inode *inode, 919 enum inode_state_flags_enum flags) 920{ 921 WRITE_ONCE(inode->i_state.__state, flags); 922} 923 924static inline void inode_state_assign(struct inode *inode, 925 enum inode_state_flags_enum flags) 926{ 927 lockdep_assert_held(&inode->i_lock); 928 inode_state_assign_raw(inode, flags); 929} 930 931static inline void inode_state_replace_raw(struct inode *inode, 932 enum inode_state_flags_enum clearflags, 933 enum inode_state_flags_enum setflags) 934{ 935 enum inode_state_flags_enum flags; 936 flags = inode->i_state.__state; 937 flags &= ~clearflags; 938 flags |= setflags; 939 inode_state_assign_raw(inode, flags); 940} 941 942static inline void inode_state_replace(struct inode *inode, 943 enum inode_state_flags_enum clearflags, 944 enum inode_state_flags_enum setflags) 945{ 946 lockdep_assert_held(&inode->i_lock); 947 inode_state_replace_raw(inode, clearflags, setflags); 948} 949 950static inline void inode_set_cached_link(struct inode *inode, char *link, int linklen) 951{ 952 VFS_WARN_ON_INODE(strlen(link) != linklen, inode); 953 VFS_WARN_ON_INODE(inode->i_opflags & IOP_CACHED_LINK, inode); 954 inode->i_link = link; 955 inode->i_linklen = linklen; 956 inode->i_opflags |= IOP_CACHED_LINK; 957} 958 959/* 960 * Get bit address from inode->i_state to use with wait_var_event() 961 * infrastructre. 962 */ 963#define inode_state_wait_address(inode, bit) ((char *)&(inode)->i_state + (bit)) 964 965struct wait_queue_head *inode_bit_waitqueue(struct wait_bit_queue_entry *wqe, 966 struct inode *inode, u32 bit); 967 968static inline void inode_wake_up_bit(struct inode *inode, u32 bit) 969{ 970 /* Caller is responsible for correct memory barriers. */ 971 wake_up_var(inode_state_wait_address(inode, bit)); 972} 973 974struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode); 975 976static inline unsigned int i_blocksize(const struct inode *node) 977{ 978 return (1 << node->i_blkbits); 979} 980 981static inline int inode_unhashed(struct inode *inode) 982{ 983 return hlist_unhashed(&inode->i_hash); 984} 985 986/* 987 * __mark_inode_dirty expects inodes to be hashed. Since we don't 988 * want special inodes in the fileset inode space, we make them 989 * appear hashed, but do not put on any lists. hlist_del() 990 * will work fine and require no locking. 991 */ 992static inline void inode_fake_hash(struct inode *inode) 993{ 994 hlist_add_fake(&inode->i_hash); 995} 996 997void wait_on_new_inode(struct inode *inode); 998 999/* 1000 * inode->i_rwsem nesting subclasses for the lock validator: 1001 * 1002 * 0: the object of the current VFS operation 1003 * 1: parent 1004 * 2: child/target 1005 * 3: xattr 1006 * 4: second non-directory 1007 * 5: second parent (when locking independent directories in rename) 1008 * 1009 * I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two 1010 * non-directories at once. 1011 * 1012 * The locking order between these classes is 1013 * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory 1014 */ 1015enum inode_i_mutex_lock_class 1016{ 1017 I_MUTEX_NORMAL, 1018 I_MUTEX_PARENT, 1019 I_MUTEX_CHILD, 1020 I_MUTEX_XATTR, 1021 I_MUTEX_NONDIR2, 1022 I_MUTEX_PARENT2, 1023}; 1024 1025static inline void inode_lock(struct inode *inode) 1026{ 1027 down_write(&inode->i_rwsem); 1028} 1029 1030static inline __must_check int inode_lock_killable(struct inode *inode) 1031{ 1032 return down_write_killable(&inode->i_rwsem); 1033} 1034 1035static inline void inode_unlock(struct inode *inode) 1036{ 1037 up_write(&inode->i_rwsem); 1038} 1039 1040static inline void inode_lock_shared(struct inode *inode) 1041{ 1042 down_read(&inode->i_rwsem); 1043} 1044 1045static inline __must_check int inode_lock_shared_killable(struct inode *inode) 1046{ 1047 return down_read_killable(&inode->i_rwsem); 1048} 1049 1050static inline void inode_unlock_shared(struct inode *inode) 1051{ 1052 up_read(&inode->i_rwsem); 1053} 1054 1055static inline int inode_trylock(struct inode *inode) 1056{ 1057 return down_write_trylock(&inode->i_rwsem); 1058} 1059 1060static inline int inode_trylock_shared(struct inode *inode) 1061{ 1062 return down_read_trylock(&inode->i_rwsem); 1063} 1064 1065static inline int inode_is_locked(struct inode *inode) 1066{ 1067 return rwsem_is_locked(&inode->i_rwsem); 1068} 1069 1070static inline void inode_lock_nested(struct inode *inode, unsigned subclass) 1071{ 1072 down_write_nested(&inode->i_rwsem, subclass); 1073} 1074 1075static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass) 1076{ 1077 down_read_nested(&inode->i_rwsem, subclass); 1078} 1079 1080static inline void filemap_invalidate_lock(struct address_space *mapping) 1081{ 1082 down_write(&mapping->invalidate_lock); 1083} 1084 1085static inline void filemap_invalidate_unlock(struct address_space *mapping) 1086{ 1087 up_write(&mapping->invalidate_lock); 1088} 1089 1090static inline void filemap_invalidate_lock_shared(struct address_space *mapping) 1091{ 1092 down_read(&mapping->invalidate_lock); 1093} 1094 1095static inline int filemap_invalidate_trylock_shared( 1096 struct address_space *mapping) 1097{ 1098 return down_read_trylock(&mapping->invalidate_lock); 1099} 1100 1101static inline void filemap_invalidate_unlock_shared( 1102 struct address_space *mapping) 1103{ 1104 up_read(&mapping->invalidate_lock); 1105} 1106 1107void lock_two_nondirectories(struct inode *, struct inode*); 1108void unlock_two_nondirectories(struct inode *, struct inode*); 1109 1110void filemap_invalidate_lock_two(struct address_space *mapping1, 1111 struct address_space *mapping2); 1112void filemap_invalidate_unlock_two(struct address_space *mapping1, 1113 struct address_space *mapping2); 1114 1115 1116/* 1117 * NOTE: in a 32bit arch with a preemptable kernel and 1118 * an UP compile the i_size_read/write must be atomic 1119 * with respect to the local cpu (unlike with preempt disabled), 1120 * but they don't need to be atomic with respect to other cpus like in 1121 * true SMP (so they need either to either locally disable irq around 1122 * the read or for example on x86 they can be still implemented as a 1123 * cmpxchg8b without the need of the lock prefix). For SMP compiles 1124 * and 64bit archs it makes no difference if preempt is enabled or not. 1125 */ 1126static inline loff_t i_size_read(const struct inode *inode) 1127{ 1128#if BITS_PER_LONG==32 && defined(CONFIG_SMP) 1129 loff_t i_size; 1130 unsigned int seq; 1131 1132 do { 1133 seq = read_seqcount_begin(&inode->i_size_seqcount); 1134 i_size = inode->i_size; 1135 } while (read_seqcount_retry(&inode->i_size_seqcount, seq)); 1136 return i_size; 1137#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION) 1138 loff_t i_size; 1139 1140 preempt_disable(); 1141 i_size = inode->i_size; 1142 preempt_enable(); 1143 return i_size; 1144#else 1145 /* Pairs with smp_store_release() in i_size_write() */ 1146 return smp_load_acquire(&inode->i_size); 1147#endif 1148} 1149 1150/* 1151 * NOTE: unlike i_size_read(), i_size_write() does need locking around it 1152 * (normally i_rwsem), otherwise on 32bit/SMP an update of i_size_seqcount 1153 * can be lost, resulting in subsequent i_size_read() calls spinning forever. 1154 */ 1155static inline void i_size_write(struct inode *inode, loff_t i_size) 1156{ 1157#if BITS_PER_LONG==32 && defined(CONFIG_SMP) 1158 preempt_disable(); 1159 write_seqcount_begin(&inode->i_size_seqcount); 1160 inode->i_size = i_size; 1161 write_seqcount_end(&inode->i_size_seqcount); 1162 preempt_enable(); 1163#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION) 1164 preempt_disable(); 1165 inode->i_size = i_size; 1166 preempt_enable(); 1167#else 1168 /* 1169 * Pairs with smp_load_acquire() in i_size_read() to ensure 1170 * changes related to inode size (such as page contents) are 1171 * visible before we see the changed inode size. 1172 */ 1173 smp_store_release(&inode->i_size, i_size); 1174#endif 1175} 1176 1177static inline unsigned iminor(const struct inode *inode) 1178{ 1179 return MINOR(inode->i_rdev); 1180} 1181 1182static inline unsigned imajor(const struct inode *inode) 1183{ 1184 return MAJOR(inode->i_rdev); 1185} 1186 1187struct fown_struct { 1188 struct file *file; /* backpointer for security modules */ 1189 rwlock_t lock; /* protects pid, uid, euid fields */ 1190 struct pid *pid; /* pid or -pgrp where SIGIO should be sent */ 1191 enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */ 1192 kuid_t uid, euid; /* uid/euid of process setting the owner */ 1193 int signum; /* posix.1b rt signal to be delivered on IO */ 1194}; 1195 1196/** 1197 * struct file_ra_state - Track a file's readahead state. 1198 * @start: Where the most recent readahead started. 1199 * @size: Number of pages read in the most recent readahead. 1200 * @async_size: Numer of pages that were/are not needed immediately 1201 * and so were/are genuinely "ahead". Start next readahead when 1202 * the first of these pages is accessed. 1203 * @ra_pages: Maximum size of a readahead request, copied from the bdi. 1204 * @order: Preferred folio order used for most recent readahead. 1205 * @mmap_miss: How many mmap accesses missed in the page cache. 1206 * @prev_pos: The last byte in the most recent read request. 1207 * 1208 * When this structure is passed to ->readahead(), the "most recent" 1209 * readahead means the current readahead. 1210 */ 1211struct file_ra_state { 1212 pgoff_t start; 1213 unsigned int size; 1214 unsigned int async_size; 1215 unsigned int ra_pages; 1216 unsigned short order; 1217 unsigned short mmap_miss; 1218 loff_t prev_pos; 1219}; 1220 1221/* 1222 * Check if @index falls in the readahead windows. 1223 */ 1224static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index) 1225{ 1226 return (index >= ra->start && 1227 index < ra->start + ra->size); 1228} 1229 1230/** 1231 * struct file - Represents a file 1232 * @f_lock: Protects f_ep, f_flags. Must not be taken from IRQ context. 1233 * @f_mode: FMODE_* flags often used in hotpaths 1234 * @f_op: file operations 1235 * @f_mapping: Contents of a cacheable, mappable object. 1236 * @private_data: filesystem or driver specific data 1237 * @f_inode: cached inode 1238 * @f_flags: file flags 1239 * @f_iocb_flags: iocb flags 1240 * @f_cred: stashed credentials of creator/opener 1241 * @f_owner: file owner 1242 * @f_path: path of the file 1243 * @__f_path: writable alias for @f_path; *ONLY* for core VFS and only before 1244 * the file gets open 1245 * @f_pos_lock: lock protecting file position 1246 * @f_pipe: specific to pipes 1247 * @f_pos: file position 1248 * @f_security: LSM security context of this file 1249 * @f_wb_err: writeback error 1250 * @f_sb_err: per sb writeback errors 1251 * @f_ep: link of all epoll hooks for this file 1252 * @f_task_work: task work entry point 1253 * @f_llist: work queue entrypoint 1254 * @f_ra: file's readahead state 1255 * @f_freeptr: Pointer used by SLAB_TYPESAFE_BY_RCU file cache (don't touch.) 1256 * @f_ref: reference count 1257 */ 1258struct file { 1259 spinlock_t f_lock; 1260 fmode_t f_mode; 1261 const struct file_operations *f_op; 1262 struct address_space *f_mapping; 1263 void *private_data; 1264 struct inode *f_inode; 1265 unsigned int f_flags; 1266 unsigned int f_iocb_flags; 1267 const struct cred *f_cred; 1268 struct fown_struct *f_owner; 1269 /* --- cacheline 1 boundary (64 bytes) --- */ 1270 union { 1271 const struct path f_path; 1272 struct path __f_path; 1273 }; 1274 union { 1275 /* regular files (with FMODE_ATOMIC_POS) and directories */ 1276 struct mutex f_pos_lock; 1277 /* pipes */ 1278 u64 f_pipe; 1279 }; 1280 loff_t f_pos; 1281#ifdef CONFIG_SECURITY 1282 void *f_security; 1283#endif 1284 /* --- cacheline 2 boundary (128 bytes) --- */ 1285 errseq_t f_wb_err; 1286 errseq_t f_sb_err; 1287#ifdef CONFIG_EPOLL 1288 struct hlist_head *f_ep; 1289#endif 1290 union { 1291 struct callback_head f_task_work; 1292 struct llist_node f_llist; 1293 struct file_ra_state f_ra; 1294 freeptr_t f_freeptr; 1295 }; 1296 file_ref_t f_ref; 1297 /* --- cacheline 3 boundary (192 bytes) --- */ 1298} __randomize_layout 1299 __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */ 1300 1301struct file_handle { 1302 __u32 handle_bytes; 1303 int handle_type; 1304 /* file identifier */ 1305 unsigned char f_handle[] __counted_by(handle_bytes); 1306}; 1307 1308static inline struct file *get_file(struct file *f) 1309{ 1310 file_ref_inc(&f->f_ref); 1311 return f; 1312} 1313 1314struct file *get_file_rcu(struct file __rcu **f); 1315struct file *get_file_active(struct file **f); 1316 1317#define file_count(f) file_ref_read(&(f)->f_ref) 1318 1319#define MAX_NON_LFS ((1UL<<31) - 1) 1320 1321/* Page cache limit. The filesystems should put that into their s_maxbytes 1322 limits, otherwise bad things can happen in VM. */ 1323#if BITS_PER_LONG==32 1324#define MAX_LFS_FILESIZE ((loff_t)ULONG_MAX << PAGE_SHIFT) 1325#elif BITS_PER_LONG==64 1326#define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX) 1327#endif 1328 1329/* legacy typedef, should eventually be removed */ 1330typedef void *fl_owner_t; 1331 1332struct file_lock; 1333struct file_lease; 1334 1335/* The following constant reflects the upper bound of the file/locking space */ 1336#ifndef OFFSET_MAX 1337#define OFFSET_MAX type_max(loff_t) 1338#define OFFT_OFFSET_MAX type_max(off_t) 1339#endif 1340 1341int file_f_owner_allocate(struct file *file); 1342static inline struct fown_struct *file_f_owner(const struct file *file) 1343{ 1344 return READ_ONCE(file->f_owner); 1345} 1346 1347extern void send_sigio(struct fown_struct *fown, int fd, int band); 1348 1349static inline struct inode *file_inode(const struct file *f) 1350{ 1351 return f->f_inode; 1352} 1353 1354/* 1355 * file_dentry() is a relic from the days that overlayfs was using files with a 1356 * "fake" path, meaning, f_path on overlayfs and f_inode on underlying fs. 1357 * In those days, file_dentry() was needed to get the underlying fs dentry that 1358 * matches f_inode. 1359 * Files with "fake" path should not exist nowadays, so use an assertion to make 1360 * sure that file_dentry() was not papering over filesystem bugs. 1361 */ 1362static inline struct dentry *file_dentry(const struct file *file) 1363{ 1364 struct dentry *dentry = file->f_path.dentry; 1365 1366 WARN_ON_ONCE(d_inode(dentry) != file_inode(file)); 1367 return dentry; 1368} 1369 1370struct fasync_struct { 1371 rwlock_t fa_lock; 1372 int magic; 1373 int fa_fd; 1374 struct fasync_struct *fa_next; /* singly linked list */ 1375 struct file *fa_file; 1376 struct rcu_head fa_rcu; 1377}; 1378 1379#define FASYNC_MAGIC 0x4601 1380 1381/* SMP safe fasync helpers: */ 1382extern int fasync_helper(int, struct file *, int, struct fasync_struct **); 1383extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *); 1384extern int fasync_remove_entry(struct file *, struct fasync_struct **); 1385extern struct fasync_struct *fasync_alloc(void); 1386extern void fasync_free(struct fasync_struct *); 1387 1388/* can be called from interrupts */ 1389extern void kill_fasync(struct fasync_struct **, int, int); 1390 1391extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force); 1392extern int f_setown(struct file *filp, int who, int force); 1393extern void f_delown(struct file *filp); 1394extern pid_t f_getown(struct file *filp); 1395extern int send_sigurg(struct file *file); 1396 1397/* 1398 * Umount options 1399 */ 1400 1401#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */ 1402#define MNT_DETACH 0x00000002 /* Just detach from the tree */ 1403#define MNT_EXPIRE 0x00000004 /* Mark for expiry */ 1404#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */ 1405#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */ 1406 1407static inline struct user_namespace *i_user_ns(const struct inode *inode) 1408{ 1409 return inode->i_sb->s_user_ns; 1410} 1411 1412/* Helper functions so that in most cases filesystems will 1413 * not need to deal directly with kuid_t and kgid_t and can 1414 * instead deal with the raw numeric values that are stored 1415 * in the filesystem. 1416 */ 1417static inline uid_t i_uid_read(const struct inode *inode) 1418{ 1419 return from_kuid(i_user_ns(inode), inode->i_uid); 1420} 1421 1422static inline gid_t i_gid_read(const struct inode *inode) 1423{ 1424 return from_kgid(i_user_ns(inode), inode->i_gid); 1425} 1426 1427static inline void i_uid_write(struct inode *inode, uid_t uid) 1428{ 1429 inode->i_uid = make_kuid(i_user_ns(inode), uid); 1430} 1431 1432static inline void i_gid_write(struct inode *inode, gid_t gid) 1433{ 1434 inode->i_gid = make_kgid(i_user_ns(inode), gid); 1435} 1436 1437/** 1438 * i_uid_into_vfsuid - map an inode's i_uid down according to an idmapping 1439 * @idmap: idmap of the mount the inode was found from 1440 * @inode: inode to map 1441 * 1442 * Return: whe inode's i_uid mapped down according to @idmap. 1443 * If the inode's i_uid has no mapping INVALID_VFSUID is returned. 1444 */ 1445static inline vfsuid_t i_uid_into_vfsuid(struct mnt_idmap *idmap, 1446 const struct inode *inode) 1447{ 1448 return make_vfsuid(idmap, i_user_ns(inode), inode->i_uid); 1449} 1450 1451/** 1452 * i_uid_needs_update - check whether inode's i_uid needs to be updated 1453 * @idmap: idmap of the mount the inode was found from 1454 * @attr: the new attributes of @inode 1455 * @inode: the inode to update 1456 * 1457 * Check whether the $inode's i_uid field needs to be updated taking idmapped 1458 * mounts into account if the filesystem supports it. 1459 * 1460 * Return: true if @inode's i_uid field needs to be updated, false if not. 1461 */ 1462static inline bool i_uid_needs_update(struct mnt_idmap *idmap, 1463 const struct iattr *attr, 1464 const struct inode *inode) 1465{ 1466 return ((attr->ia_valid & ATTR_UID) && 1467 !vfsuid_eq(attr->ia_vfsuid, 1468 i_uid_into_vfsuid(idmap, inode))); 1469} 1470 1471/** 1472 * i_uid_update - update @inode's i_uid field 1473 * @idmap: idmap of the mount the inode was found from 1474 * @attr: the new attributes of @inode 1475 * @inode: the inode to update 1476 * 1477 * Safely update @inode's i_uid field translating the vfsuid of any idmapped 1478 * mount into the filesystem kuid. 1479 */ 1480static inline void i_uid_update(struct mnt_idmap *idmap, 1481 const struct iattr *attr, 1482 struct inode *inode) 1483{ 1484 if (attr->ia_valid & ATTR_UID) 1485 inode->i_uid = from_vfsuid(idmap, i_user_ns(inode), 1486 attr->ia_vfsuid); 1487} 1488 1489/** 1490 * i_gid_into_vfsgid - map an inode's i_gid down according to an idmapping 1491 * @idmap: idmap of the mount the inode was found from 1492 * @inode: inode to map 1493 * 1494 * Return: the inode's i_gid mapped down according to @idmap. 1495 * If the inode's i_gid has no mapping INVALID_VFSGID is returned. 1496 */ 1497static inline vfsgid_t i_gid_into_vfsgid(struct mnt_idmap *idmap, 1498 const struct inode *inode) 1499{ 1500 return make_vfsgid(idmap, i_user_ns(inode), inode->i_gid); 1501} 1502 1503/** 1504 * i_gid_needs_update - check whether inode's i_gid needs to be updated 1505 * @idmap: idmap of the mount the inode was found from 1506 * @attr: the new attributes of @inode 1507 * @inode: the inode to update 1508 * 1509 * Check whether the $inode's i_gid field needs to be updated taking idmapped 1510 * mounts into account if the filesystem supports it. 1511 * 1512 * Return: true if @inode's i_gid field needs to be updated, false if not. 1513 */ 1514static inline bool i_gid_needs_update(struct mnt_idmap *idmap, 1515 const struct iattr *attr, 1516 const struct inode *inode) 1517{ 1518 return ((attr->ia_valid & ATTR_GID) && 1519 !vfsgid_eq(attr->ia_vfsgid, 1520 i_gid_into_vfsgid(idmap, inode))); 1521} 1522 1523/** 1524 * i_gid_update - update @inode's i_gid field 1525 * @idmap: idmap of the mount the inode was found from 1526 * @attr: the new attributes of @inode 1527 * @inode: the inode to update 1528 * 1529 * Safely update @inode's i_gid field translating the vfsgid of any idmapped 1530 * mount into the filesystem kgid. 1531 */ 1532static inline void i_gid_update(struct mnt_idmap *idmap, 1533 const struct iattr *attr, 1534 struct inode *inode) 1535{ 1536 if (attr->ia_valid & ATTR_GID) 1537 inode->i_gid = from_vfsgid(idmap, i_user_ns(inode), 1538 attr->ia_vfsgid); 1539} 1540 1541/** 1542 * inode_fsuid_set - initialize inode's i_uid field with callers fsuid 1543 * @inode: inode to initialize 1544 * @idmap: idmap of the mount the inode was found from 1545 * 1546 * Initialize the i_uid field of @inode. If the inode was found/created via 1547 * an idmapped mount map the caller's fsuid according to @idmap. 1548 */ 1549static inline void inode_fsuid_set(struct inode *inode, 1550 struct mnt_idmap *idmap) 1551{ 1552 inode->i_uid = mapped_fsuid(idmap, i_user_ns(inode)); 1553} 1554 1555/** 1556 * inode_fsgid_set - initialize inode's i_gid field with callers fsgid 1557 * @inode: inode to initialize 1558 * @idmap: idmap of the mount the inode was found from 1559 * 1560 * Initialize the i_gid field of @inode. If the inode was found/created via 1561 * an idmapped mount map the caller's fsgid according to @idmap. 1562 */ 1563static inline void inode_fsgid_set(struct inode *inode, 1564 struct mnt_idmap *idmap) 1565{ 1566 inode->i_gid = mapped_fsgid(idmap, i_user_ns(inode)); 1567} 1568 1569/** 1570 * fsuidgid_has_mapping() - check whether caller's fsuid/fsgid is mapped 1571 * @sb: the superblock we want a mapping in 1572 * @idmap: idmap of the relevant mount 1573 * 1574 * Check whether the caller's fsuid and fsgid have a valid mapping in the 1575 * s_user_ns of the superblock @sb. If the caller is on an idmapped mount map 1576 * the caller's fsuid and fsgid according to the @idmap first. 1577 * 1578 * Return: true if fsuid and fsgid is mapped, false if not. 1579 */ 1580static inline bool fsuidgid_has_mapping(struct super_block *sb, 1581 struct mnt_idmap *idmap) 1582{ 1583 struct user_namespace *fs_userns = sb->s_user_ns; 1584 kuid_t kuid; 1585 kgid_t kgid; 1586 1587 kuid = mapped_fsuid(idmap, fs_userns); 1588 if (!uid_valid(kuid)) 1589 return false; 1590 kgid = mapped_fsgid(idmap, fs_userns); 1591 if (!gid_valid(kgid)) 1592 return false; 1593 return kuid_has_mapping(fs_userns, kuid) && 1594 kgid_has_mapping(fs_userns, kgid); 1595} 1596 1597struct timespec64 current_time(struct inode *inode); 1598struct timespec64 inode_set_ctime_current(struct inode *inode); 1599struct timespec64 inode_set_ctime_deleg(struct inode *inode, 1600 struct timespec64 update); 1601 1602static inline time64_t inode_get_atime_sec(const struct inode *inode) 1603{ 1604 return inode->i_atime_sec; 1605} 1606 1607static inline long inode_get_atime_nsec(const struct inode *inode) 1608{ 1609 return inode->i_atime_nsec; 1610} 1611 1612static inline struct timespec64 inode_get_atime(const struct inode *inode) 1613{ 1614 struct timespec64 ts = { .tv_sec = inode_get_atime_sec(inode), 1615 .tv_nsec = inode_get_atime_nsec(inode) }; 1616 1617 return ts; 1618} 1619 1620static inline struct timespec64 inode_set_atime_to_ts(struct inode *inode, 1621 struct timespec64 ts) 1622{ 1623 inode->i_atime_sec = ts.tv_sec; 1624 inode->i_atime_nsec = ts.tv_nsec; 1625 return ts; 1626} 1627 1628static inline struct timespec64 inode_set_atime(struct inode *inode, 1629 time64_t sec, long nsec) 1630{ 1631 struct timespec64 ts = { .tv_sec = sec, 1632 .tv_nsec = nsec }; 1633 1634 return inode_set_atime_to_ts(inode, ts); 1635} 1636 1637static inline time64_t inode_get_mtime_sec(const struct inode *inode) 1638{ 1639 return inode->i_mtime_sec; 1640} 1641 1642static inline long inode_get_mtime_nsec(const struct inode *inode) 1643{ 1644 return inode->i_mtime_nsec; 1645} 1646 1647static inline struct timespec64 inode_get_mtime(const struct inode *inode) 1648{ 1649 struct timespec64 ts = { .tv_sec = inode_get_mtime_sec(inode), 1650 .tv_nsec = inode_get_mtime_nsec(inode) }; 1651 return ts; 1652} 1653 1654static inline struct timespec64 inode_set_mtime_to_ts(struct inode *inode, 1655 struct timespec64 ts) 1656{ 1657 inode->i_mtime_sec = ts.tv_sec; 1658 inode->i_mtime_nsec = ts.tv_nsec; 1659 return ts; 1660} 1661 1662static inline struct timespec64 inode_set_mtime(struct inode *inode, 1663 time64_t sec, long nsec) 1664{ 1665 struct timespec64 ts = { .tv_sec = sec, 1666 .tv_nsec = nsec }; 1667 return inode_set_mtime_to_ts(inode, ts); 1668} 1669 1670/* 1671 * Multigrain timestamps 1672 * 1673 * Conditionally use fine-grained ctime and mtime timestamps when there 1674 * are users actively observing them via getattr. The primary use-case 1675 * for this is NFS clients that use the ctime to distinguish between 1676 * different states of the file, and that are often fooled by multiple 1677 * operations that occur in the same coarse-grained timer tick. 1678 */ 1679#define I_CTIME_QUERIED ((u32)BIT(31)) 1680 1681static inline time64_t inode_get_ctime_sec(const struct inode *inode) 1682{ 1683 return inode->i_ctime_sec; 1684} 1685 1686static inline long inode_get_ctime_nsec(const struct inode *inode) 1687{ 1688 return inode->i_ctime_nsec & ~I_CTIME_QUERIED; 1689} 1690 1691static inline struct timespec64 inode_get_ctime(const struct inode *inode) 1692{ 1693 struct timespec64 ts = { .tv_sec = inode_get_ctime_sec(inode), 1694 .tv_nsec = inode_get_ctime_nsec(inode) }; 1695 1696 return ts; 1697} 1698 1699struct timespec64 inode_set_ctime_to_ts(struct inode *inode, struct timespec64 ts); 1700 1701/** 1702 * inode_set_ctime - set the ctime in the inode 1703 * @inode: inode in which to set the ctime 1704 * @sec: tv_sec value to set 1705 * @nsec: tv_nsec value to set 1706 * 1707 * Set the ctime in @inode to { @sec, @nsec } 1708 */ 1709static inline struct timespec64 inode_set_ctime(struct inode *inode, 1710 time64_t sec, long nsec) 1711{ 1712 struct timespec64 ts = { .tv_sec = sec, 1713 .tv_nsec = nsec }; 1714 1715 return inode_set_ctime_to_ts(inode, ts); 1716} 1717 1718struct timespec64 simple_inode_init_ts(struct inode *inode); 1719 1720/* 1721 * Snapshotting support. 1722 */ 1723 1724/** 1725 * file_write_started - check if SB_FREEZE_WRITE is held 1726 * @file: the file we write to 1727 * 1728 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN. 1729 * May be false positive with !S_ISREG, because file_start_write() has 1730 * no effect on !S_ISREG. 1731 */ 1732static inline bool file_write_started(const struct file *file) 1733{ 1734 if (!S_ISREG(file_inode(file)->i_mode)) 1735 return true; 1736 return sb_write_started(file_inode(file)->i_sb); 1737} 1738 1739/** 1740 * file_write_not_started - check if SB_FREEZE_WRITE is not held 1741 * @file: the file we write to 1742 * 1743 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN. 1744 * May be false positive with !S_ISREG, because file_start_write() has 1745 * no effect on !S_ISREG. 1746 */ 1747static inline bool file_write_not_started(const struct file *file) 1748{ 1749 if (!S_ISREG(file_inode(file)->i_mode)) 1750 return true; 1751 return sb_write_not_started(file_inode(file)->i_sb); 1752} 1753 1754bool inode_owner_or_capable(struct mnt_idmap *idmap, 1755 const struct inode *inode); 1756 1757/* 1758 * VFS helper functions.. 1759 */ 1760int vfs_create(struct mnt_idmap *, struct dentry *, umode_t, 1761 struct delegated_inode *); 1762struct dentry *vfs_mkdir(struct mnt_idmap *, struct inode *, 1763 struct dentry *, umode_t, struct delegated_inode *); 1764int vfs_mknod(struct mnt_idmap *, struct inode *, struct dentry *, 1765 umode_t, dev_t, struct delegated_inode *); 1766int vfs_symlink(struct mnt_idmap *, struct inode *, 1767 struct dentry *, const char *, struct delegated_inode *); 1768int vfs_link(struct dentry *, struct mnt_idmap *, struct inode *, 1769 struct dentry *, struct delegated_inode *); 1770int vfs_rmdir(struct mnt_idmap *, struct inode *, struct dentry *, 1771 struct delegated_inode *); 1772int vfs_unlink(struct mnt_idmap *, struct inode *, struct dentry *, 1773 struct delegated_inode *); 1774 1775/** 1776 * struct renamedata - contains all information required for renaming 1777 * @mnt_idmap: idmap of the mount in which the rename is happening. 1778 * @old_parent: parent of source 1779 * @old_dentry: source 1780 * @new_parent: parent of destination 1781 * @new_dentry: destination 1782 * @delegated_inode: returns an inode needing a delegation break 1783 * @flags: rename flags 1784 */ 1785struct renamedata { 1786 struct mnt_idmap *mnt_idmap; 1787 struct dentry *old_parent; 1788 struct dentry *old_dentry; 1789 struct dentry *new_parent; 1790 struct dentry *new_dentry; 1791 struct delegated_inode *delegated_inode; 1792 unsigned int flags; 1793} __randomize_layout; 1794 1795int vfs_rename(struct renamedata *); 1796 1797static inline int vfs_whiteout(struct mnt_idmap *idmap, 1798 struct inode *dir, struct dentry *dentry) 1799{ 1800 return vfs_mknod(idmap, dir, dentry, S_IFCHR | WHITEOUT_MODE, 1801 WHITEOUT_DEV, NULL); 1802} 1803 1804struct file *kernel_tmpfile_open(struct mnt_idmap *idmap, 1805 const struct path *parentpath, 1806 umode_t mode, int open_flag, 1807 const struct cred *cred); 1808struct file *kernel_file_open(const struct path *path, int flags, 1809 const struct cred *cred); 1810 1811int vfs_mkobj(struct dentry *, umode_t, 1812 int (*f)(struct dentry *, umode_t, void *), 1813 void *); 1814 1815int vfs_fchown(struct file *file, uid_t user, gid_t group); 1816int vfs_fchmod(struct file *file, umode_t mode); 1817int vfs_utimes(const struct path *path, struct timespec64 *times); 1818 1819#ifdef CONFIG_COMPAT 1820extern long compat_ptr_ioctl(struct file *file, unsigned int cmd, 1821 unsigned long arg); 1822#else 1823#define compat_ptr_ioctl NULL 1824#endif 1825 1826/* 1827 * VFS file helper functions. 1828 */ 1829void inode_init_owner(struct mnt_idmap *idmap, struct inode *inode, 1830 const struct inode *dir, umode_t mode); 1831extern bool may_open_dev(const struct path *path); 1832umode_t mode_strip_sgid(struct mnt_idmap *idmap, 1833 const struct inode *dir, umode_t mode); 1834bool in_group_or_capable(struct mnt_idmap *idmap, 1835 const struct inode *inode, vfsgid_t vfsgid); 1836 1837/* 1838 * This is the "filldir" function type, used by readdir() to let 1839 * the kernel specify what kind of dirent layout it wants to have. 1840 * This allows the kernel to read directories into kernel space or 1841 * to have different dirent layouts depending on the binary type. 1842 * Return 'true' to keep going and 'false' if there are no more entries. 1843 */ 1844struct dir_context; 1845typedef bool (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, 1846 unsigned); 1847 1848struct dir_context { 1849 filldir_t actor; 1850 loff_t pos; 1851 /* 1852 * Filesystems MUST NOT MODIFY count, but may use as a hint: 1853 * 0 unknown 1854 * > 0 space in buffer (assume at least one entry) 1855 * INT_MAX unlimited 1856 */ 1857 int count; 1858 /* @actor supports these flags in d_type high bits */ 1859 unsigned int dt_flags_mask; 1860}; 1861 1862/* If OR-ed with d_type, pending signals are not checked */ 1863#define FILLDIR_FLAG_NOINTR 0x1000 1864 1865/* 1866 * These flags let !MMU mmap() govern direct device mapping vs immediate 1867 * copying more easily for MAP_PRIVATE, especially for ROM filesystems. 1868 * 1869 * NOMMU_MAP_COPY: Copy can be mapped (MAP_PRIVATE) 1870 * NOMMU_MAP_DIRECT: Can be mapped directly (MAP_SHARED) 1871 * NOMMU_MAP_READ: Can be mapped for reading 1872 * NOMMU_MAP_WRITE: Can be mapped for writing 1873 * NOMMU_MAP_EXEC: Can be mapped for execution 1874 */ 1875#define NOMMU_MAP_COPY 0x00000001 1876#define NOMMU_MAP_DIRECT 0x00000008 1877#define NOMMU_MAP_READ VM_MAYREAD 1878#define NOMMU_MAP_WRITE VM_MAYWRITE 1879#define NOMMU_MAP_EXEC VM_MAYEXEC 1880 1881#define NOMMU_VMFLAGS \ 1882 (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC) 1883 1884/* 1885 * These flags control the behavior of the remap_file_range function pointer. 1886 * If it is called with len == 0 that means "remap to end of source file". 1887 * See Documentation/filesystems/vfs.rst for more details about this call. 1888 * 1889 * REMAP_FILE_DEDUP: only remap if contents identical (i.e. deduplicate) 1890 * REMAP_FILE_CAN_SHORTEN: caller can handle a shortened request 1891 */ 1892#define REMAP_FILE_DEDUP (1 << 0) 1893#define REMAP_FILE_CAN_SHORTEN (1 << 1) 1894 1895/* 1896 * These flags signal that the caller is ok with altering various aspects of 1897 * the behavior of the remap operation. The changes must be made by the 1898 * implementation; the vfs remap helper functions can take advantage of them. 1899 * Flags in this category exist to preserve the quirky behavior of the hoisted 1900 * btrfs clone/dedupe ioctls. 1901 */ 1902#define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN) 1903 1904/* 1905 * These flags control the behavior of vfs_copy_file_range(). 1906 * They are not available to the user via syscall. 1907 * 1908 * COPY_FILE_SPLICE: call splice direct instead of fs clone/copy ops 1909 */ 1910#define COPY_FILE_SPLICE (1 << 0) 1911 1912struct iov_iter; 1913struct io_uring_cmd; 1914struct offset_ctx; 1915 1916typedef unsigned int __bitwise fop_flags_t; 1917 1918struct file_operations { 1919 struct module *owner; 1920 fop_flags_t fop_flags; 1921 loff_t (*llseek) (struct file *, loff_t, int); 1922 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); 1923 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); 1924 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *); 1925 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 1926 int (*iopoll)(struct kiocb *kiocb, struct io_comp_batch *, 1927 unsigned int flags); 1928 int (*iterate_shared) (struct file *, struct dir_context *); 1929 __poll_t (*poll) (struct file *, struct poll_table_struct *); 1930 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 1931 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 1932 int (*mmap) (struct file *, struct vm_area_struct *); 1933 int (*open) (struct inode *, struct file *); 1934 int (*flush) (struct file *, fl_owner_t id); 1935 int (*release) (struct inode *, struct file *); 1936 int (*fsync) (struct file *, loff_t, loff_t, int datasync); 1937 int (*fasync) (int, struct file *, int); 1938 int (*lock) (struct file *, int, struct file_lock *); 1939 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); 1940 int (*check_flags)(int); 1941 int (*flock) (struct file *, int, struct file_lock *); 1942 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); 1943 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); 1944 void (*splice_eof)(struct file *file); 1945 int (*setlease)(struct file *, int, struct file_lease **, void **); 1946 long (*fallocate)(struct file *file, int mode, loff_t offset, 1947 loff_t len); 1948 void (*show_fdinfo)(struct seq_file *m, struct file *f); 1949#ifndef CONFIG_MMU 1950 unsigned (*mmap_capabilities)(struct file *); 1951#endif 1952 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, 1953 loff_t, size_t, unsigned int); 1954 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in, 1955 struct file *file_out, loff_t pos_out, 1956 loff_t len, unsigned int remap_flags); 1957 int (*fadvise)(struct file *, loff_t, loff_t, int); 1958 int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags); 1959 int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *, 1960 unsigned int poll_flags); 1961 int (*mmap_prepare)(struct vm_area_desc *); 1962} __randomize_layout; 1963 1964/* Supports async buffered reads */ 1965#define FOP_BUFFER_RASYNC ((__force fop_flags_t)(1 << 0)) 1966/* Supports async buffered writes */ 1967#define FOP_BUFFER_WASYNC ((__force fop_flags_t)(1 << 1)) 1968/* Supports synchronous page faults for mappings */ 1969#define FOP_MMAP_SYNC ((__force fop_flags_t)(1 << 2)) 1970/* Supports non-exclusive O_DIRECT writes from multiple threads */ 1971#define FOP_DIO_PARALLEL_WRITE ((__force fop_flags_t)(1 << 3)) 1972/* Contains huge pages */ 1973#define FOP_HUGE_PAGES ((__force fop_flags_t)(1 << 4)) 1974/* Treat loff_t as unsigned (e.g., /dev/mem) */ 1975#define FOP_UNSIGNED_OFFSET ((__force fop_flags_t)(1 << 5)) 1976/* Supports asynchronous lock callbacks */ 1977#define FOP_ASYNC_LOCK ((__force fop_flags_t)(1 << 6)) 1978/* File system supports uncached read/write buffered IO */ 1979#define FOP_DONTCACHE ((__force fop_flags_t)(1 << 7)) 1980 1981/* Wrap a directory iterator that needs exclusive inode access */ 1982int wrap_directory_iterator(struct file *, struct dir_context *, 1983 int (*) (struct file *, struct dir_context *)); 1984#define WRAP_DIR_ITER(x) \ 1985 static int shared_##x(struct file *file , struct dir_context *ctx) \ 1986 { return wrap_directory_iterator(file, ctx, x); } 1987 1988struct inode_operations { 1989 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int); 1990 const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *); 1991 int (*permission) (struct mnt_idmap *, struct inode *, int); 1992 struct posix_acl * (*get_inode_acl)(struct inode *, int, bool); 1993 1994 int (*readlink) (struct dentry *, char __user *,int); 1995 1996 int (*create) (struct mnt_idmap *, struct inode *,struct dentry *, 1997 umode_t, bool); 1998 int (*link) (struct dentry *,struct inode *,struct dentry *); 1999 int (*unlink) (struct inode *,struct dentry *); 2000 int (*symlink) (struct mnt_idmap *, struct inode *,struct dentry *, 2001 const char *); 2002 struct dentry *(*mkdir) (struct mnt_idmap *, struct inode *, 2003 struct dentry *, umode_t); 2004 int (*rmdir) (struct inode *,struct dentry *); 2005 int (*mknod) (struct mnt_idmap *, struct inode *,struct dentry *, 2006 umode_t,dev_t); 2007 int (*rename) (struct mnt_idmap *, struct inode *, struct dentry *, 2008 struct inode *, struct dentry *, unsigned int); 2009 int (*setattr) (struct mnt_idmap *, struct dentry *, struct iattr *); 2010 int (*getattr) (struct mnt_idmap *, const struct path *, 2011 struct kstat *, u32, unsigned int); 2012 ssize_t (*listxattr) (struct dentry *, char *, size_t); 2013 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 2014 u64 len); 2015 int (*update_time)(struct inode *, int); 2016 int (*atomic_open)(struct inode *, struct dentry *, 2017 struct file *, unsigned open_flag, 2018 umode_t create_mode); 2019 int (*tmpfile) (struct mnt_idmap *, struct inode *, 2020 struct file *, umode_t); 2021 struct posix_acl *(*get_acl)(struct mnt_idmap *, struct dentry *, 2022 int); 2023 int (*set_acl)(struct mnt_idmap *, struct dentry *, 2024 struct posix_acl *, int); 2025 int (*fileattr_set)(struct mnt_idmap *idmap, 2026 struct dentry *dentry, struct file_kattr *fa); 2027 int (*fileattr_get)(struct dentry *dentry, struct file_kattr *fa); 2028 struct offset_ctx *(*get_offset_ctx)(struct inode *inode); 2029} ____cacheline_aligned; 2030 2031/* Did the driver provide valid mmap hook configuration? */ 2032static inline bool can_mmap_file(struct file *file) 2033{ 2034 bool has_mmap = file->f_op->mmap; 2035 bool has_mmap_prepare = file->f_op->mmap_prepare; 2036 2037 /* Hooks are mutually exclusive. */ 2038 if (WARN_ON_ONCE(has_mmap && has_mmap_prepare)) 2039 return false; 2040 if (!has_mmap && !has_mmap_prepare) 2041 return false; 2042 2043 return true; 2044} 2045 2046int __compat_vma_mmap(const struct file_operations *f_op, 2047 struct file *file, struct vm_area_struct *vma); 2048int compat_vma_mmap(struct file *file, struct vm_area_struct *vma); 2049 2050static inline int vfs_mmap(struct file *file, struct vm_area_struct *vma) 2051{ 2052 if (file->f_op->mmap_prepare) 2053 return compat_vma_mmap(file, vma); 2054 2055 return file->f_op->mmap(file, vma); 2056} 2057 2058static inline int vfs_mmap_prepare(struct file *file, struct vm_area_desc *desc) 2059{ 2060 return file->f_op->mmap_prepare(desc); 2061} 2062 2063extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *); 2064extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *); 2065extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *, 2066 loff_t, size_t, unsigned int); 2067int remap_verify_area(struct file *file, loff_t pos, loff_t len, bool write); 2068int __generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, 2069 struct file *file_out, loff_t pos_out, 2070 loff_t *len, unsigned int remap_flags, 2071 const struct iomap_ops *dax_read_ops); 2072int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, 2073 struct file *file_out, loff_t pos_out, 2074 loff_t *count, unsigned int remap_flags); 2075extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in, 2076 struct file *file_out, loff_t pos_out, 2077 loff_t len, unsigned int remap_flags); 2078extern int vfs_dedupe_file_range(struct file *file, 2079 struct file_dedupe_range *same); 2080extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos, 2081 struct file *dst_file, loff_t dst_pos, 2082 loff_t len, unsigned int remap_flags); 2083 2084/* 2085 * Inode flags - they have no relation to superblock flags now 2086 */ 2087#define S_SYNC (1 << 0) /* Writes are synced at once */ 2088#define S_NOATIME (1 << 1) /* Do not update access times */ 2089#define S_APPEND (1 << 2) /* Append-only file */ 2090#define S_IMMUTABLE (1 << 3) /* Immutable file */ 2091#define S_DEAD (1 << 4) /* removed, but still open directory */ 2092#define S_NOQUOTA (1 << 5) /* Inode is not counted to quota */ 2093#define S_DIRSYNC (1 << 6) /* Directory modifications are synchronous */ 2094#define S_NOCMTIME (1 << 7) /* Do not update file c/mtime */ 2095#define S_SWAPFILE (1 << 8) /* Do not truncate: swapon got its bmaps */ 2096#define S_PRIVATE (1 << 9) /* Inode is fs-internal */ 2097#define S_IMA (1 << 10) /* Inode has an associated IMA struct */ 2098#define S_AUTOMOUNT (1 << 11) /* Automount/referral quasi-directory */ 2099#define S_NOSEC (1 << 12) /* no suid or xattr security attributes */ 2100#ifdef CONFIG_FS_DAX 2101#define S_DAX (1 << 13) /* Direct Access, avoiding the page cache */ 2102#else 2103#define S_DAX 0 /* Make all the DAX code disappear */ 2104#endif 2105#define S_ENCRYPTED (1 << 14) /* Encrypted file (using fs/crypto/) */ 2106#define S_CASEFOLD (1 << 15) /* Casefolded file */ 2107#define S_VERITY (1 << 16) /* Verity file (using fs/verity/) */ 2108#define S_KERNEL_FILE (1 << 17) /* File is in use by the kernel (eg. fs/cachefiles) */ 2109#define S_ANON_INODE (1 << 19) /* Inode is an anonymous inode */ 2110 2111/* 2112 * Note that nosuid etc flags are inode-specific: setting some file-system 2113 * flags just means all the inodes inherit those flags by default. It might be 2114 * possible to override it selectively if you really wanted to with some 2115 * ioctl() that is not currently implemented. 2116 * 2117 * Exception: SB_RDONLY is always applied to the entire file system. 2118 * 2119 * Unfortunately, it is possible to change a filesystems flags with it mounted 2120 * with files in use. This means that all of the inodes will not have their 2121 * i_flags updated. Hence, i_flags no longer inherit the superblock mount 2122 * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org 2123 */ 2124#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg)) 2125 2126#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb) 2127#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \ 2128 ((inode)->i_flags & S_SYNC)) 2129#define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \ 2130 ((inode)->i_flags & (S_SYNC|S_DIRSYNC))) 2131#define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK) 2132#define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY|SB_NOATIME) 2133#define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION) 2134 2135#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA) 2136#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND) 2137#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE) 2138 2139#ifdef CONFIG_FS_POSIX_ACL 2140#define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL) 2141#else 2142#define IS_POSIXACL(inode) 0 2143#endif 2144 2145#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD) 2146#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME) 2147 2148#ifdef CONFIG_SWAP 2149#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE) 2150#else 2151#define IS_SWAPFILE(inode) ((void)(inode), 0U) 2152#endif 2153 2154#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE) 2155#define IS_IMA(inode) ((inode)->i_flags & S_IMA) 2156#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT) 2157#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC) 2158#define IS_DAX(inode) ((inode)->i_flags & S_DAX) 2159#define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED) 2160#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD) 2161#define IS_VERITY(inode) ((inode)->i_flags & S_VERITY) 2162 2163#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \ 2164 (inode)->i_rdev == WHITEOUT_DEV) 2165#define IS_ANON_FILE(inode) ((inode)->i_flags & S_ANON_INODE) 2166 2167static inline bool HAS_UNMAPPED_ID(struct mnt_idmap *idmap, 2168 struct inode *inode) 2169{ 2170 return !vfsuid_valid(i_uid_into_vfsuid(idmap, inode)) || 2171 !vfsgid_valid(i_gid_into_vfsgid(idmap, inode)); 2172} 2173 2174static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp) 2175{ 2176 *kiocb = (struct kiocb) { 2177 .ki_filp = filp, 2178 .ki_flags = filp->f_iocb_flags, 2179 .ki_ioprio = get_current_ioprio(), 2180 }; 2181} 2182 2183static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src, 2184 struct file *filp) 2185{ 2186 *kiocb = (struct kiocb) { 2187 .ki_filp = filp, 2188 .ki_flags = kiocb_src->ki_flags, 2189 .ki_ioprio = kiocb_src->ki_ioprio, 2190 .ki_pos = kiocb_src->ki_pos, 2191 }; 2192} 2193 2194extern void __mark_inode_dirty(struct inode *, int); 2195static inline void mark_inode_dirty(struct inode *inode) 2196{ 2197 __mark_inode_dirty(inode, I_DIRTY); 2198} 2199 2200static inline void mark_inode_dirty_sync(struct inode *inode) 2201{ 2202 __mark_inode_dirty(inode, I_DIRTY_SYNC); 2203} 2204 2205static inline int icount_read(const struct inode *inode) 2206{ 2207 return atomic_read(&inode->i_count); 2208} 2209 2210/* 2211 * Returns true if the given inode itself only has dirty timestamps (its pages 2212 * may still be dirty) and isn't currently being allocated or freed. 2213 * Filesystems should call this if when writing an inode when lazytime is 2214 * enabled, they want to opportunistically write the timestamps of other inodes 2215 * located very nearby on-disk, e.g. in the same inode block. This returns true 2216 * if the given inode is in need of such an opportunistic update. Requires 2217 * i_lock, or at least later re-checking under i_lock. 2218 */ 2219static inline bool inode_is_dirtytime_only(struct inode *inode) 2220{ 2221 return (inode_state_read_once(inode) & 2222 (I_DIRTY_TIME | I_NEW | I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME; 2223} 2224 2225extern void inc_nlink(struct inode *inode); 2226extern void drop_nlink(struct inode *inode); 2227extern void clear_nlink(struct inode *inode); 2228extern void set_nlink(struct inode *inode, unsigned int nlink); 2229 2230static inline void inode_inc_link_count(struct inode *inode) 2231{ 2232 inc_nlink(inode); 2233 mark_inode_dirty(inode); 2234} 2235 2236static inline void inode_dec_link_count(struct inode *inode) 2237{ 2238 drop_nlink(inode); 2239 mark_inode_dirty(inode); 2240} 2241 2242enum file_time_flags { 2243 S_ATIME = 1, 2244 S_MTIME = 2, 2245 S_CTIME = 4, 2246 S_VERSION = 8, 2247}; 2248 2249extern bool atime_needs_update(const struct path *, struct inode *); 2250extern void touch_atime(const struct path *); 2251int inode_update_time(struct inode *inode, int flags); 2252 2253static inline void file_accessed(struct file *file) 2254{ 2255 if (!(file->f_flags & O_NOATIME)) 2256 touch_atime(&file->f_path); 2257} 2258 2259extern int file_modified(struct file *file); 2260int kiocb_modified(struct kiocb *iocb); 2261 2262int sync_inode_metadata(struct inode *inode, int wait); 2263 2264struct file_system_type { 2265 const char *name; 2266 int fs_flags; 2267#define FS_REQUIRES_DEV 1 2268#define FS_BINARY_MOUNTDATA 2 2269#define FS_HAS_SUBTYPE 4 2270#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */ 2271#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */ 2272#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */ 2273#define FS_MGTIME 64 /* FS uses multigrain timestamps */ 2274#define FS_LBS 128 /* FS supports LBS */ 2275#define FS_POWER_FREEZE 256 /* Always freeze on suspend/hibernate */ 2276#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */ 2277 int (*init_fs_context)(struct fs_context *); 2278 const struct fs_parameter_spec *parameters; 2279 struct dentry *(*mount) (struct file_system_type *, int, 2280 const char *, void *); 2281 void (*kill_sb) (struct super_block *); 2282 struct module *owner; 2283 struct file_system_type * next; 2284 struct hlist_head fs_supers; 2285 2286 struct lock_class_key s_lock_key; 2287 struct lock_class_key s_umount_key; 2288 struct lock_class_key s_vfs_rename_key; 2289 struct lock_class_key s_writers_key[SB_FREEZE_LEVELS]; 2290 2291 struct lock_class_key i_lock_key; 2292 struct lock_class_key i_mutex_key; 2293 struct lock_class_key invalidate_lock_key; 2294 struct lock_class_key i_mutex_dir_key; 2295}; 2296 2297#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME) 2298 2299/** 2300 * is_mgtime: is this inode using multigrain timestamps 2301 * @inode: inode to test for multigrain timestamps 2302 * 2303 * Return true if the inode uses multigrain timestamps, false otherwise. 2304 */ 2305static inline bool is_mgtime(const struct inode *inode) 2306{ 2307 return inode->i_opflags & IOP_MGTIME; 2308} 2309 2310extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path); 2311void retire_super(struct super_block *sb); 2312void generic_shutdown_super(struct super_block *sb); 2313void kill_block_super(struct super_block *sb); 2314void kill_anon_super(struct super_block *sb); 2315void deactivate_super(struct super_block *sb); 2316void deactivate_locked_super(struct super_block *sb); 2317int set_anon_super(struct super_block *s, void *data); 2318int set_anon_super_fc(struct super_block *s, struct fs_context *fc); 2319int get_anon_bdev(dev_t *); 2320void free_anon_bdev(dev_t); 2321struct super_block *sget_fc(struct fs_context *fc, 2322 int (*test)(struct super_block *, struct fs_context *), 2323 int (*set)(struct super_block *, struct fs_context *)); 2324struct super_block *sget(struct file_system_type *type, 2325 int (*test)(struct super_block *,void *), 2326 int (*set)(struct super_block *,void *), 2327 int flags, void *data); 2328struct super_block *sget_dev(struct fs_context *fc, dev_t dev); 2329 2330/* Alas, no aliases. Too much hassle with bringing module.h everywhere */ 2331#define fops_get(fops) ({ \ 2332 const struct file_operations *_fops = (fops); \ 2333 (((_fops) && try_module_get((_fops)->owner) ? (_fops) : NULL)); \ 2334}) 2335 2336#define fops_put(fops) ({ \ 2337 const struct file_operations *_fops = (fops); \ 2338 if (_fops) \ 2339 module_put((_fops)->owner); \ 2340}) 2341 2342/* 2343 * This one is to be used *ONLY* from ->open() instances. 2344 * fops must be non-NULL, pinned down *and* module dependencies 2345 * should be sufficient to pin the caller down as well. 2346 */ 2347#define replace_fops(f, fops) \ 2348 do { \ 2349 struct file *__file = (f); \ 2350 fops_put(__file->f_op); \ 2351 BUG_ON(!(__file->f_op = (fops))); \ 2352 } while(0) 2353 2354extern int register_filesystem(struct file_system_type *); 2355extern int unregister_filesystem(struct file_system_type *); 2356extern int vfs_statfs(const struct path *, struct kstatfs *); 2357extern int user_statfs(const char __user *, struct kstatfs *); 2358extern int fd_statfs(int, struct kstatfs *); 2359extern __printf(2, 3) 2360int super_setup_bdi_name(struct super_block *sb, char *fmt, ...); 2361extern int super_setup_bdi(struct super_block *sb); 2362 2363static inline void super_set_uuid(struct super_block *sb, const u8 *uuid, unsigned len) 2364{ 2365 if (WARN_ON(len > sizeof(sb->s_uuid))) 2366 len = sizeof(sb->s_uuid); 2367 sb->s_uuid_len = len; 2368 memcpy(&sb->s_uuid, uuid, len); 2369} 2370 2371/* set sb sysfs name based on sb->s_bdev */ 2372static inline void super_set_sysfs_name_bdev(struct super_block *sb) 2373{ 2374 snprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), "%pg", sb->s_bdev); 2375} 2376 2377/* set sb sysfs name based on sb->s_uuid */ 2378static inline void super_set_sysfs_name_uuid(struct super_block *sb) 2379{ 2380 WARN_ON(sb->s_uuid_len != sizeof(sb->s_uuid)); 2381 snprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), "%pU", sb->s_uuid.b); 2382} 2383 2384/* set sb sysfs name based on sb->s_id */ 2385static inline void super_set_sysfs_name_id(struct super_block *sb) 2386{ 2387 strscpy(sb->s_sysfs_name, sb->s_id, sizeof(sb->s_sysfs_name)); 2388} 2389 2390/* try to use something standard before you use this */ 2391__printf(2, 3) 2392static inline void super_set_sysfs_name_generic(struct super_block *sb, const char *fmt, ...) 2393{ 2394 va_list args; 2395 2396 va_start(args, fmt); 2397 vsnprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), fmt, args); 2398 va_end(args); 2399} 2400 2401extern void ihold(struct inode * inode); 2402extern void iput(struct inode *); 2403void iput_not_last(struct inode *); 2404int inode_update_timestamps(struct inode *inode, int flags); 2405int generic_update_time(struct inode *, int); 2406 2407/* /sys/fs */ 2408extern struct kobject *fs_kobj; 2409 2410#define MAX_RW_COUNT (INT_MAX & PAGE_MASK) 2411 2412/* fs/open.c */ 2413struct audit_names; 2414struct filename { 2415 const char *name; /* pointer to actual string */ 2416 const __user char *uptr; /* original userland pointer */ 2417 atomic_t refcnt; 2418 struct audit_names *aname; 2419 const char iname[]; 2420}; 2421static_assert(offsetof(struct filename, iname) % sizeof(long) == 0); 2422 2423static inline struct mnt_idmap *file_mnt_idmap(const struct file *file) 2424{ 2425 return mnt_idmap(file->f_path.mnt); 2426} 2427 2428/** 2429 * is_idmapped_mnt - check whether a mount is mapped 2430 * @mnt: the mount to check 2431 * 2432 * If @mnt has an non @nop_mnt_idmap attached to it then @mnt is mapped. 2433 * 2434 * Return: true if mount is mapped, false if not. 2435 */ 2436static inline bool is_idmapped_mnt(const struct vfsmount *mnt) 2437{ 2438 return mnt_idmap(mnt) != &nop_mnt_idmap; 2439} 2440 2441int vfs_truncate(const struct path *, loff_t); 2442int do_truncate(struct mnt_idmap *, struct dentry *, loff_t start, 2443 unsigned int time_attrs, struct file *filp); 2444extern int vfs_fallocate(struct file *file, int mode, loff_t offset, 2445 loff_t len); 2446int do_sys_open(int dfd, const char __user *filename, int flags, 2447 umode_t mode); 2448extern struct file *file_open_name(struct filename *, int, umode_t); 2449extern struct file *filp_open(const char *, int, umode_t); 2450extern struct file *file_open_root(const struct path *, 2451 const char *, int, umode_t); 2452static inline struct file *file_open_root_mnt(struct vfsmount *mnt, 2453 const char *name, int flags, umode_t mode) 2454{ 2455 return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root}, 2456 name, flags, mode); 2457} 2458struct file *dentry_open(const struct path *path, int flags, 2459 const struct cred *creds); 2460struct file *dentry_open_nonotify(const struct path *path, int flags, 2461 const struct cred *cred); 2462struct file *dentry_create(const struct path *path, int flags, umode_t mode, 2463 const struct cred *cred); 2464const struct path *backing_file_user_path(const struct file *f); 2465 2466/* 2467 * When mmapping a file on a stackable filesystem (e.g., overlayfs), the file 2468 * stored in ->vm_file is a backing file whose f_inode is on the underlying 2469 * filesystem. When the mapped file path and inode number are displayed to 2470 * user (e.g. via /proc/<pid>/maps), these helpers should be used to get the 2471 * path and inode number to display to the user, which is the path of the fd 2472 * that user has requested to map and the inode number that would be returned 2473 * by fstat() on that same fd. 2474 */ 2475/* Get the path to display in /proc/<pid>/maps */ 2476static inline const struct path *file_user_path(const struct file *f) 2477{ 2478 if (unlikely(f->f_mode & FMODE_BACKING)) 2479 return backing_file_user_path(f); 2480 return &f->f_path; 2481} 2482/* Get the inode whose inode number to display in /proc/<pid>/maps */ 2483static inline const struct inode *file_user_inode(const struct file *f) 2484{ 2485 if (unlikely(f->f_mode & FMODE_BACKING)) 2486 return d_inode(backing_file_user_path(f)->dentry); 2487 return file_inode(f); 2488} 2489 2490static inline struct file *file_clone_open(struct file *file) 2491{ 2492 return dentry_open(&file->f_path, file->f_flags, file->f_cred); 2493} 2494extern int filp_close(struct file *, fl_owner_t id); 2495 2496extern struct filename *getname_flags(const char __user *, int); 2497extern struct filename *getname_uflags(const char __user *, int); 2498static inline struct filename *getname(const char __user *name) 2499{ 2500 return getname_flags(name, 0); 2501} 2502extern struct filename *getname_kernel(const char *); 2503extern struct filename *__getname_maybe_null(const char __user *); 2504static inline struct filename *getname_maybe_null(const char __user *name, int flags) 2505{ 2506 if (!(flags & AT_EMPTY_PATH)) 2507 return getname(name); 2508 2509 if (!name) 2510 return NULL; 2511 return __getname_maybe_null(name); 2512} 2513extern void putname(struct filename *name); 2514DEFINE_FREE(putname, struct filename *, if (!IS_ERR_OR_NULL(_T)) putname(_T)) 2515 2516static inline struct filename *refname(struct filename *name) 2517{ 2518 atomic_inc(&name->refcnt); 2519 return name; 2520} 2521 2522extern int finish_open(struct file *file, struct dentry *dentry, 2523 int (*open)(struct inode *, struct file *)); 2524extern int finish_no_open(struct file *file, struct dentry *dentry); 2525 2526/* Helper for the simple case when original dentry is used */ 2527static inline int finish_open_simple(struct file *file, int error) 2528{ 2529 if (error) 2530 return error; 2531 2532 return finish_open(file, file->f_path.dentry, NULL); 2533} 2534 2535/* fs/dcache.c */ 2536extern void __init vfs_caches_init_early(void); 2537extern void __init vfs_caches_init(void); 2538 2539extern struct kmem_cache *names_cachep; 2540 2541#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL) 2542#define __putname(name) kmem_cache_free(names_cachep, (void *)(name)) 2543 2544void emergency_thaw_all(void); 2545extern int sync_filesystem(struct super_block *); 2546extern const struct file_operations def_blk_fops; 2547extern const struct file_operations def_chr_fops; 2548 2549/* fs/char_dev.c */ 2550#define CHRDEV_MAJOR_MAX 512 2551/* Marks the bottom of the first segment of free char majors */ 2552#define CHRDEV_MAJOR_DYN_END 234 2553/* Marks the top and bottom of the second segment of free char majors */ 2554#define CHRDEV_MAJOR_DYN_EXT_START 511 2555#define CHRDEV_MAJOR_DYN_EXT_END 384 2556 2557extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *); 2558extern int register_chrdev_region(dev_t, unsigned, const char *); 2559extern int __register_chrdev(unsigned int major, unsigned int baseminor, 2560 unsigned int count, const char *name, 2561 const struct file_operations *fops); 2562extern void __unregister_chrdev(unsigned int major, unsigned int baseminor, 2563 unsigned int count, const char *name); 2564extern void unregister_chrdev_region(dev_t, unsigned); 2565extern void chrdev_show(struct seq_file *,off_t); 2566 2567static inline int register_chrdev(unsigned int major, const char *name, 2568 const struct file_operations *fops) 2569{ 2570 return __register_chrdev(major, 0, 256, name, fops); 2571} 2572 2573static inline void unregister_chrdev(unsigned int major, const char *name) 2574{ 2575 __unregister_chrdev(major, 0, 256, name); 2576} 2577 2578extern void init_special_inode(struct inode *, umode_t, dev_t); 2579 2580/* Invalid inode operations -- fs/bad_inode.c */ 2581extern void make_bad_inode(struct inode *); 2582extern bool is_bad_inode(struct inode *); 2583 2584extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart, 2585 loff_t lend); 2586extern int __must_check file_check_and_advance_wb_err(struct file *file); 2587extern int __must_check file_write_and_wait_range(struct file *file, 2588 loff_t start, loff_t end); 2589int filemap_flush_range(struct address_space *mapping, loff_t start, 2590 loff_t end); 2591 2592static inline int file_write_and_wait(struct file *file) 2593{ 2594 return file_write_and_wait_range(file, 0, LLONG_MAX); 2595} 2596 2597extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end, 2598 int datasync); 2599extern int vfs_fsync(struct file *file, int datasync); 2600 2601extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes, 2602 unsigned int flags); 2603 2604static inline bool iocb_is_dsync(const struct kiocb *iocb) 2605{ 2606 return (iocb->ki_flags & IOCB_DSYNC) || 2607 IS_SYNC(iocb->ki_filp->f_mapping->host); 2608} 2609 2610/* 2611 * Sync the bytes written if this was a synchronous write. Expect ki_pos 2612 * to already be updated for the write, and will return either the amount 2613 * of bytes passed in, or an error if syncing the file failed. 2614 */ 2615static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count) 2616{ 2617 if (iocb_is_dsync(iocb)) { 2618 int ret = vfs_fsync_range(iocb->ki_filp, 2619 iocb->ki_pos - count, iocb->ki_pos - 1, 2620 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1); 2621 if (ret) 2622 return ret; 2623 } else if (iocb->ki_flags & IOCB_DONTCACHE) { 2624 struct address_space *mapping = iocb->ki_filp->f_mapping; 2625 2626 filemap_flush_range(mapping, iocb->ki_pos - count, 2627 iocb->ki_pos - 1); 2628 } 2629 2630 return count; 2631} 2632 2633extern void emergency_sync(void); 2634extern void emergency_remount(void); 2635 2636#ifdef CONFIG_BLOCK 2637extern int bmap(struct inode *inode, sector_t *block); 2638#else 2639static inline int bmap(struct inode *inode, sector_t *block) 2640{ 2641 return -EINVAL; 2642} 2643#endif 2644 2645int notify_change(struct mnt_idmap *, struct dentry *, 2646 struct iattr *, struct delegated_inode *); 2647int inode_permission(struct mnt_idmap *, struct inode *, int); 2648int generic_permission(struct mnt_idmap *, struct inode *, int); 2649static inline int file_permission(struct file *file, int mask) 2650{ 2651 return inode_permission(file_mnt_idmap(file), 2652 file_inode(file), mask); 2653} 2654static inline int path_permission(const struct path *path, int mask) 2655{ 2656 return inode_permission(mnt_idmap(path->mnt), 2657 d_inode(path->dentry), mask); 2658} 2659int __check_sticky(struct mnt_idmap *idmap, struct inode *dir, 2660 struct inode *inode); 2661 2662static inline bool execute_ok(struct inode *inode) 2663{ 2664 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode); 2665} 2666 2667static inline bool inode_wrong_type(const struct inode *inode, umode_t mode) 2668{ 2669 return (inode->i_mode ^ mode) & S_IFMT; 2670} 2671 2672/** 2673 * file_start_write - get write access to a superblock for regular file io 2674 * @file: the file we want to write to 2675 * 2676 * This is a variant of sb_start_write() which is a noop on non-regular file. 2677 * Should be matched with a call to file_end_write(). 2678 */ 2679static inline void file_start_write(struct file *file) 2680{ 2681 if (!S_ISREG(file_inode(file)->i_mode)) 2682 return; 2683 sb_start_write(file_inode(file)->i_sb); 2684} 2685 2686static inline bool file_start_write_trylock(struct file *file) 2687{ 2688 if (!S_ISREG(file_inode(file)->i_mode)) 2689 return true; 2690 return sb_start_write_trylock(file_inode(file)->i_sb); 2691} 2692 2693/** 2694 * file_end_write - drop write access to a superblock of a regular file 2695 * @file: the file we wrote to 2696 * 2697 * Should be matched with a call to file_start_write(). 2698 */ 2699static inline void file_end_write(struct file *file) 2700{ 2701 if (!S_ISREG(file_inode(file)->i_mode)) 2702 return; 2703 sb_end_write(file_inode(file)->i_sb); 2704} 2705 2706/** 2707 * kiocb_start_write - get write access to a superblock for async file io 2708 * @iocb: the io context we want to submit the write with 2709 * 2710 * This is a variant of sb_start_write() for async io submission. 2711 * Should be matched with a call to kiocb_end_write(). 2712 */ 2713static inline void kiocb_start_write(struct kiocb *iocb) 2714{ 2715 struct inode *inode = file_inode(iocb->ki_filp); 2716 2717 sb_start_write(inode->i_sb); 2718 /* 2719 * Fool lockdep by telling it the lock got released so that it 2720 * doesn't complain about the held lock when we return to userspace. 2721 */ 2722 __sb_writers_release(inode->i_sb, SB_FREEZE_WRITE); 2723} 2724 2725/** 2726 * kiocb_end_write - drop write access to a superblock after async file io 2727 * @iocb: the io context we sumbitted the write with 2728 * 2729 * Should be matched with a call to kiocb_start_write(). 2730 */ 2731static inline void kiocb_end_write(struct kiocb *iocb) 2732{ 2733 struct inode *inode = file_inode(iocb->ki_filp); 2734 2735 /* 2736 * Tell lockdep we inherited freeze protection from submission thread. 2737 */ 2738 __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE); 2739 sb_end_write(inode->i_sb); 2740} 2741 2742/* 2743 * This is used for regular files where some users -- especially the 2744 * currently executed binary in a process, previously handled via 2745 * VM_DENYWRITE -- cannot handle concurrent write (and maybe mmap 2746 * read-write shared) accesses. 2747 * 2748 * get_write_access() gets write permission for a file. 2749 * put_write_access() releases this write permission. 2750 * deny_write_access() denies write access to a file. 2751 * allow_write_access() re-enables write access to a file. 2752 * 2753 * The i_writecount field of an inode can have the following values: 2754 * 0: no write access, no denied write access 2755 * < 0: (-i_writecount) users that denied write access to the file. 2756 * > 0: (i_writecount) users that have write access to the file. 2757 * 2758 * Normally we operate on that counter with atomic_{inc,dec} and it's safe 2759 * except for the cases where we don't hold i_writecount yet. Then we need to 2760 * use {get,deny}_write_access() - these functions check the sign and refuse 2761 * to do the change if sign is wrong. 2762 */ 2763static inline int get_write_access(struct inode *inode) 2764{ 2765 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY; 2766} 2767static inline int deny_write_access(struct file *file) 2768{ 2769 struct inode *inode = file_inode(file); 2770 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY; 2771} 2772static inline void put_write_access(struct inode * inode) 2773{ 2774 atomic_dec(&inode->i_writecount); 2775} 2776static inline void allow_write_access(struct file *file) 2777{ 2778 if (file) 2779 atomic_inc(&file_inode(file)->i_writecount); 2780} 2781 2782/* 2783 * Do not prevent write to executable file when watched by pre-content events. 2784 * 2785 * Note that FMODE_FSNOTIFY_HSM mode is set depending on pre-content watches at 2786 * the time of file open and remains constant for entire lifetime of the file, 2787 * so if pre-content watches are added post execution or removed before the end 2788 * of the execution, it will not cause i_writecount reference leak. 2789 */ 2790static inline int exe_file_deny_write_access(struct file *exe_file) 2791{ 2792 if (unlikely(FMODE_FSNOTIFY_HSM(exe_file->f_mode))) 2793 return 0; 2794 return deny_write_access(exe_file); 2795} 2796static inline void exe_file_allow_write_access(struct file *exe_file) 2797{ 2798 if (unlikely(!exe_file || FMODE_FSNOTIFY_HSM(exe_file->f_mode))) 2799 return; 2800 allow_write_access(exe_file); 2801} 2802 2803static inline void file_set_fsnotify_mode(struct file *file, fmode_t mode) 2804{ 2805 file->f_mode &= ~FMODE_FSNOTIFY_MASK; 2806 file->f_mode |= mode; 2807} 2808 2809static inline bool inode_is_open_for_write(const struct inode *inode) 2810{ 2811 return atomic_read(&inode->i_writecount) > 0; 2812} 2813 2814#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING) 2815static inline void i_readcount_dec(struct inode *inode) 2816{ 2817 BUG_ON(atomic_dec_return(&inode->i_readcount) < 0); 2818} 2819static inline void i_readcount_inc(struct inode *inode) 2820{ 2821 atomic_inc(&inode->i_readcount); 2822} 2823#else 2824static inline void i_readcount_dec(struct inode *inode) 2825{ 2826 return; 2827} 2828static inline void i_readcount_inc(struct inode *inode) 2829{ 2830 return; 2831} 2832#endif 2833extern int do_pipe_flags(int *, int); 2834 2835extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *); 2836ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos); 2837extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *); 2838extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *); 2839extern struct file * open_exec(const char *); 2840 2841/* fs/dcache.c -- generic fs support functions */ 2842extern bool is_subdir(struct dentry *, struct dentry *); 2843extern bool path_is_under(const struct path *, const struct path *); 2844u64 vfsmount_to_propagation_flags(struct vfsmount *mnt); 2845 2846extern char *file_path(struct file *, char *, int); 2847 2848/** 2849 * is_dot_dotdot - returns true only if @name is "." or ".." 2850 * @name: file name to check 2851 * @len: length of file name, in bytes 2852 */ 2853static inline bool is_dot_dotdot(const char *name, size_t len) 2854{ 2855 return len && unlikely(name[0] == '.') && 2856 (len == 1 || (len == 2 && name[1] == '.')); 2857} 2858 2859/** 2860 * name_contains_dotdot - check if a file name contains ".." path components 2861 * @name: File path string to check 2862 * Search for ".." surrounded by either '/' or start/end of string. 2863 */ 2864static inline bool name_contains_dotdot(const char *name) 2865{ 2866 size_t name_len; 2867 2868 name_len = strlen(name); 2869 return strcmp(name, "..") == 0 || 2870 strncmp(name, "../", 3) == 0 || 2871 strstr(name, "/../") != NULL || 2872 (name_len >= 3 && strcmp(name + name_len - 3, "/..") == 0); 2873} 2874 2875#include <linux/err.h> 2876 2877/* needed for stackable file system support */ 2878extern loff_t default_llseek(struct file *file, loff_t offset, int whence); 2879 2880extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence); 2881 2882extern int inode_init_always_gfp(struct super_block *, struct inode *, gfp_t); 2883static inline int inode_init_always(struct super_block *sb, struct inode *inode) 2884{ 2885 return inode_init_always_gfp(sb, inode, GFP_NOFS); 2886} 2887 2888extern void inode_init_once(struct inode *); 2889extern void address_space_init_once(struct address_space *mapping); 2890extern struct inode * igrab(struct inode *); 2891extern ino_t iunique(struct super_block *, ino_t); 2892extern int inode_needs_sync(struct inode *inode); 2893extern int inode_just_drop(struct inode *inode); 2894static inline int inode_generic_drop(struct inode *inode) 2895{ 2896 return !inode->i_nlink || inode_unhashed(inode); 2897} 2898extern void d_mark_dontcache(struct inode *inode); 2899 2900extern struct inode *ilookup5_nowait(struct super_block *sb, 2901 unsigned long hashval, int (*test)(struct inode *, void *), 2902 void *data, bool *isnew); 2903extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval, 2904 int (*test)(struct inode *, void *), void *data); 2905extern struct inode *ilookup(struct super_block *sb, unsigned long ino); 2906 2907extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval, 2908 int (*test)(struct inode *, void *), 2909 int (*set)(struct inode *, void *), 2910 void *data); 2911struct inode *iget5_locked(struct super_block *, unsigned long, 2912 int (*test)(struct inode *, void *), 2913 int (*set)(struct inode *, void *), void *); 2914struct inode *iget5_locked_rcu(struct super_block *, unsigned long, 2915 int (*test)(struct inode *, void *), 2916 int (*set)(struct inode *, void *), void *); 2917extern struct inode * iget_locked(struct super_block *, unsigned long); 2918extern struct inode *find_inode_nowait(struct super_block *, 2919 unsigned long, 2920 int (*match)(struct inode *, 2921 unsigned long, void *), 2922 void *data); 2923extern struct inode *find_inode_rcu(struct super_block *, unsigned long, 2924 int (*)(struct inode *, void *), void *); 2925extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long); 2926extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *); 2927extern int insert_inode_locked(struct inode *); 2928#ifdef CONFIG_DEBUG_LOCK_ALLOC 2929extern void lockdep_annotate_inode_mutex_key(struct inode *inode); 2930#else 2931static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { }; 2932#endif 2933extern void unlock_new_inode(struct inode *); 2934extern void discard_new_inode(struct inode *); 2935extern unsigned int get_next_ino(void); 2936extern void evict_inodes(struct super_block *sb); 2937void dump_mapping(const struct address_space *); 2938 2939/* 2940 * Userspace may rely on the inode number being non-zero. For example, glibc 2941 * simply ignores files with zero i_ino in unlink() and other places. 2942 * 2943 * As an additional complication, if userspace was compiled with 2944 * _FILE_OFFSET_BITS=32 on a 64-bit kernel we'll only end up reading out the 2945 * lower 32 bits, so we need to check that those aren't zero explicitly. With 2946 * _FILE_OFFSET_BITS=64, this may cause some harmless false-negatives, but 2947 * better safe than sorry. 2948 */ 2949static inline bool is_zero_ino(ino_t ino) 2950{ 2951 return (u32)ino == 0; 2952} 2953 2954static inline void __iget(struct inode *inode) 2955{ 2956 lockdep_assert_held(&inode->i_lock); 2957 atomic_inc(&inode->i_count); 2958} 2959 2960extern void iget_failed(struct inode *); 2961extern void clear_inode(struct inode *); 2962extern void __destroy_inode(struct inode *); 2963struct inode *alloc_inode(struct super_block *sb); 2964static inline struct inode *new_inode_pseudo(struct super_block *sb) 2965{ 2966 return alloc_inode(sb); 2967} 2968extern struct inode *new_inode(struct super_block *sb); 2969extern void free_inode_nonrcu(struct inode *inode); 2970extern int setattr_should_drop_suidgid(struct mnt_idmap *, struct inode *); 2971extern int file_remove_privs(struct file *); 2972int setattr_should_drop_sgid(struct mnt_idmap *idmap, 2973 const struct inode *inode); 2974 2975/* 2976 * This must be used for allocating filesystems specific inodes to set 2977 * up the inode reclaim context correctly. 2978 */ 2979#define alloc_inode_sb(_sb, _cache, _gfp) kmem_cache_alloc_lru(_cache, &_sb->s_inode_lru, _gfp) 2980 2981extern void __insert_inode_hash(struct inode *, unsigned long hashval); 2982static inline void insert_inode_hash(struct inode *inode) 2983{ 2984 __insert_inode_hash(inode, inode->i_ino); 2985} 2986 2987extern void __remove_inode_hash(struct inode *); 2988static inline void remove_inode_hash(struct inode *inode) 2989{ 2990 if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash)) 2991 __remove_inode_hash(inode); 2992} 2993 2994extern void inode_sb_list_add(struct inode *inode); 2995extern void inode_lru_list_add(struct inode *inode); 2996 2997int generic_file_mmap(struct file *, struct vm_area_struct *); 2998int generic_file_mmap_prepare(struct vm_area_desc *desc); 2999int generic_file_readonly_mmap(struct file *, struct vm_area_struct *); 3000int generic_file_readonly_mmap_prepare(struct vm_area_desc *desc); 3001extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *); 3002int generic_write_checks_count(struct kiocb *iocb, loff_t *count); 3003extern int generic_write_check_limits(struct file *file, loff_t pos, 3004 loff_t *count); 3005extern int generic_file_rw_checks(struct file *file_in, struct file *file_out); 3006ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *to, 3007 ssize_t already_read); 3008extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *); 3009extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *); 3010extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *); 3011extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *); 3012ssize_t generic_perform_write(struct kiocb *, struct iov_iter *); 3013ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter, 3014 ssize_t direct_written, ssize_t buffered_written); 3015 3016ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos, 3017 rwf_t flags); 3018ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos, 3019 rwf_t flags); 3020ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb, 3021 struct iov_iter *iter); 3022ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb, 3023 struct iov_iter *iter); 3024 3025/* fs/splice.c */ 3026ssize_t filemap_splice_read(struct file *in, loff_t *ppos, 3027 struct pipe_inode_info *pipe, 3028 size_t len, unsigned int flags); 3029ssize_t copy_splice_read(struct file *in, loff_t *ppos, 3030 struct pipe_inode_info *pipe, 3031 size_t len, unsigned int flags); 3032extern ssize_t iter_file_splice_write(struct pipe_inode_info *, 3033 struct file *, loff_t *, size_t, unsigned int); 3034 3035 3036extern void 3037file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping); 3038extern loff_t noop_llseek(struct file *file, loff_t offset, int whence); 3039extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize); 3040extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence); 3041extern loff_t generic_file_llseek_size(struct file *file, loff_t offset, 3042 int whence, loff_t maxsize, loff_t eof); 3043loff_t generic_llseek_cookie(struct file *file, loff_t offset, int whence, 3044 u64 *cookie); 3045extern loff_t fixed_size_llseek(struct file *file, loff_t offset, 3046 int whence, loff_t size); 3047extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t); 3048extern loff_t no_seek_end_llseek(struct file *, loff_t, int); 3049int rw_verify_area(int, struct file *, const loff_t *, size_t); 3050extern int generic_file_open(struct inode * inode, struct file * filp); 3051extern int nonseekable_open(struct inode * inode, struct file * filp); 3052extern int stream_open(struct inode * inode, struct file * filp); 3053 3054#ifdef CONFIG_BLOCK 3055typedef void (dio_submit_t)(struct bio *bio, struct inode *inode, 3056 loff_t file_offset); 3057 3058enum { 3059 /* need locking between buffered and direct access */ 3060 DIO_LOCKING = 0x01, 3061 3062 /* filesystem does not support filling holes */ 3063 DIO_SKIP_HOLES = 0x02, 3064}; 3065 3066ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode, 3067 struct block_device *bdev, struct iov_iter *iter, 3068 get_block_t get_block, 3069 dio_iodone_t end_io, 3070 int flags); 3071 3072static inline ssize_t blockdev_direct_IO(struct kiocb *iocb, 3073 struct inode *inode, 3074 struct iov_iter *iter, 3075 get_block_t get_block) 3076{ 3077 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter, 3078 get_block, NULL, DIO_LOCKING | DIO_SKIP_HOLES); 3079} 3080#endif 3081 3082bool inode_dio_finished(const struct inode *inode); 3083void inode_dio_wait(struct inode *inode); 3084void inode_dio_wait_interruptible(struct inode *inode); 3085 3086/** 3087 * inode_dio_begin - signal start of a direct I/O requests 3088 * @inode: inode the direct I/O happens on 3089 * 3090 * This is called once we've finished processing a direct I/O request, 3091 * and is used to wake up callers waiting for direct I/O to be quiesced. 3092 */ 3093static inline void inode_dio_begin(struct inode *inode) 3094{ 3095 atomic_inc(&inode->i_dio_count); 3096} 3097 3098/** 3099 * inode_dio_end - signal finish of a direct I/O requests 3100 * @inode: inode the direct I/O happens on 3101 * 3102 * This is called once we've finished processing a direct I/O request, 3103 * and is used to wake up callers waiting for direct I/O to be quiesced. 3104 */ 3105static inline void inode_dio_end(struct inode *inode) 3106{ 3107 if (atomic_dec_and_test(&inode->i_dio_count)) 3108 wake_up_var(&inode->i_dio_count); 3109} 3110 3111extern void inode_set_flags(struct inode *inode, unsigned int flags, 3112 unsigned int mask); 3113 3114extern const struct file_operations generic_ro_fops; 3115 3116#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m)) 3117 3118extern int readlink_copy(char __user *, int, const char *, int); 3119extern int page_readlink(struct dentry *, char __user *, int); 3120extern const char *page_get_link_raw(struct dentry *, struct inode *, 3121 struct delayed_call *); 3122extern const char *page_get_link(struct dentry *, struct inode *, 3123 struct delayed_call *); 3124extern void page_put_link(void *); 3125extern int page_symlink(struct inode *inode, const char *symname, int len); 3126extern const struct inode_operations page_symlink_inode_operations; 3127extern void kfree_link(void *); 3128void fill_mg_cmtime(struct kstat *stat, u32 request_mask, struct inode *inode); 3129void generic_fillattr(struct mnt_idmap *, u32, struct inode *, struct kstat *); 3130void generic_fill_statx_attr(struct inode *inode, struct kstat *stat); 3131void generic_fill_statx_atomic_writes(struct kstat *stat, 3132 unsigned int unit_min, 3133 unsigned int unit_max, 3134 unsigned int unit_max_opt); 3135extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int); 3136extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int); 3137void __inode_add_bytes(struct inode *inode, loff_t bytes); 3138void inode_add_bytes(struct inode *inode, loff_t bytes); 3139void __inode_sub_bytes(struct inode *inode, loff_t bytes); 3140void inode_sub_bytes(struct inode *inode, loff_t bytes); 3141static inline loff_t __inode_get_bytes(struct inode *inode) 3142{ 3143 return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes; 3144} 3145loff_t inode_get_bytes(struct inode *inode); 3146void inode_set_bytes(struct inode *inode, loff_t bytes); 3147const char *simple_get_link(struct dentry *, struct inode *, 3148 struct delayed_call *); 3149extern const struct inode_operations simple_symlink_inode_operations; 3150 3151extern int iterate_dir(struct file *, struct dir_context *); 3152 3153int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat, 3154 int flags); 3155int vfs_fstat(int fd, struct kstat *stat); 3156 3157static inline int vfs_stat(const char __user *filename, struct kstat *stat) 3158{ 3159 return vfs_fstatat(AT_FDCWD, filename, stat, 0); 3160} 3161static inline int vfs_lstat(const char __user *name, struct kstat *stat) 3162{ 3163 return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW); 3164} 3165 3166extern const char *vfs_get_link(struct dentry *, struct delayed_call *); 3167extern int vfs_readlink(struct dentry *, char __user *, int); 3168 3169extern struct file_system_type *get_filesystem(struct file_system_type *fs); 3170extern void put_filesystem(struct file_system_type *fs); 3171extern struct file_system_type *get_fs_type(const char *name); 3172extern void drop_super(struct super_block *sb); 3173extern void drop_super_exclusive(struct super_block *sb); 3174extern void iterate_supers(void (*f)(struct super_block *, void *), void *arg); 3175extern void iterate_supers_type(struct file_system_type *, 3176 void (*)(struct super_block *, void *), void *); 3177void filesystems_freeze(bool freeze_all); 3178void filesystems_thaw(void); 3179 3180void end_dirop(struct dentry *de); 3181 3182extern int dcache_dir_open(struct inode *, struct file *); 3183extern int dcache_dir_close(struct inode *, struct file *); 3184extern loff_t dcache_dir_lseek(struct file *, loff_t, int); 3185extern int dcache_readdir(struct file *, struct dir_context *); 3186extern int simple_setattr(struct mnt_idmap *, struct dentry *, 3187 struct iattr *); 3188extern int simple_getattr(struct mnt_idmap *, const struct path *, 3189 struct kstat *, u32, unsigned int); 3190extern int simple_statfs(struct dentry *, struct kstatfs *); 3191extern int simple_open(struct inode *inode, struct file *file); 3192extern int simple_link(struct dentry *, struct inode *, struct dentry *); 3193extern int simple_unlink(struct inode *, struct dentry *); 3194extern int simple_rmdir(struct inode *, struct dentry *); 3195extern void __simple_unlink(struct inode *, struct dentry *); 3196extern void __simple_rmdir(struct inode *, struct dentry *); 3197void simple_rename_timestamp(struct inode *old_dir, struct dentry *old_dentry, 3198 struct inode *new_dir, struct dentry *new_dentry); 3199extern int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry, 3200 struct inode *new_dir, struct dentry *new_dentry); 3201extern int simple_rename(struct mnt_idmap *, struct inode *, 3202 struct dentry *, struct inode *, struct dentry *, 3203 unsigned int); 3204extern void simple_recursive_removal(struct dentry *, 3205 void (*callback)(struct dentry *)); 3206extern void simple_remove_by_name(struct dentry *, const char *, 3207 void (*callback)(struct dentry *)); 3208extern void locked_recursive_removal(struct dentry *, 3209 void (*callback)(struct dentry *)); 3210extern int noop_fsync(struct file *, loff_t, loff_t, int); 3211extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter); 3212extern int simple_empty(struct dentry *); 3213extern int simple_write_begin(const struct kiocb *iocb, 3214 struct address_space *mapping, 3215 loff_t pos, unsigned len, 3216 struct folio **foliop, void **fsdata); 3217extern const struct address_space_operations ram_aops; 3218extern int always_delete_dentry(const struct dentry *); 3219extern struct inode *alloc_anon_inode(struct super_block *); 3220struct inode *anon_inode_make_secure_inode(struct super_block *sb, const char *name, 3221 const struct inode *context_inode); 3222extern int simple_nosetlease(struct file *, int, struct file_lease **, void **); 3223 3224extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags); 3225extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *); 3226extern const struct file_operations simple_dir_operations; 3227extern const struct inode_operations simple_dir_inode_operations; 3228extern void make_empty_dir_inode(struct inode *inode); 3229extern bool is_empty_dir_inode(struct inode *inode); 3230struct tree_descr { const char *name; const struct file_operations *ops; int mode; }; 3231struct dentry *d_alloc_name(struct dentry *, const char *); 3232extern int simple_fill_super(struct super_block *, unsigned long, 3233 const struct tree_descr *); 3234extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count); 3235extern void simple_release_fs(struct vfsmount **mount, int *count); 3236struct dentry *simple_start_creating(struct dentry *, const char *); 3237void simple_done_creating(struct dentry *); 3238 3239extern ssize_t simple_read_from_buffer(void __user *to, size_t count, 3240 loff_t *ppos, const void *from, size_t available); 3241extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, 3242 const void __user *from, size_t count); 3243 3244struct offset_ctx { 3245 struct maple_tree mt; 3246 unsigned long next_offset; 3247}; 3248 3249void simple_offset_init(struct offset_ctx *octx); 3250int simple_offset_add(struct offset_ctx *octx, struct dentry *dentry); 3251void simple_offset_remove(struct offset_ctx *octx, struct dentry *dentry); 3252void simple_offset_rename(struct inode *old_dir, struct dentry *old_dentry, 3253 struct inode *new_dir, struct dentry *new_dentry); 3254int simple_offset_rename_exchange(struct inode *old_dir, 3255 struct dentry *old_dentry, 3256 struct inode *new_dir, 3257 struct dentry *new_dentry); 3258void simple_offset_destroy(struct offset_ctx *octx); 3259 3260extern const struct file_operations simple_offset_dir_operations; 3261 3262extern int __generic_file_fsync(struct file *, loff_t, loff_t, int); 3263extern int generic_file_fsync(struct file *, loff_t, loff_t, int); 3264 3265extern int generic_check_addressable(unsigned, u64); 3266 3267extern void generic_set_sb_d_ops(struct super_block *sb); 3268extern int generic_ci_match(const struct inode *parent, 3269 const struct qstr *name, 3270 const struct qstr *folded_name, 3271 const u8 *de_name, u32 de_name_len); 3272 3273#if IS_ENABLED(CONFIG_UNICODE) 3274int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str); 3275int generic_ci_d_compare(const struct dentry *dentry, unsigned int len, 3276 const char *str, const struct qstr *name); 3277 3278/** 3279 * generic_ci_validate_strict_name - Check if a given name is suitable 3280 * for a directory 3281 * 3282 * This functions checks if the proposed filename is valid for the 3283 * parent directory. That means that only valid UTF-8 filenames will be 3284 * accepted for casefold directories from filesystems created with the 3285 * strict encoding flag. That also means that any name will be 3286 * accepted for directories that doesn't have casefold enabled, or 3287 * aren't being strict with the encoding. 3288 * 3289 * @dir: inode of the directory where the new file will be created 3290 * @name: name of the new file 3291 * 3292 * Return: 3293 * * True: if the filename is suitable for this directory. It can be 3294 * true if a given name is not suitable for a strict encoding 3295 * directory, but the directory being used isn't strict 3296 * * False if the filename isn't suitable for this directory. This only 3297 * happens when a directory is casefolded and the filesystem is strict 3298 * about its encoding. 3299 */ 3300static inline bool generic_ci_validate_strict_name(struct inode *dir, 3301 const struct qstr *name) 3302{ 3303 if (!IS_CASEFOLDED(dir) || !sb_has_strict_encoding(dir->i_sb)) 3304 return true; 3305 3306 /* 3307 * A casefold dir must have a encoding set, unless the filesystem 3308 * is corrupted 3309 */ 3310 if (WARN_ON_ONCE(!dir->i_sb->s_encoding)) 3311 return true; 3312 3313 return !utf8_validate(dir->i_sb->s_encoding, name); 3314} 3315#else 3316static inline bool generic_ci_validate_strict_name(struct inode *dir, 3317 const struct qstr *name) 3318{ 3319 return true; 3320} 3321#endif 3322 3323int may_setattr(struct mnt_idmap *idmap, struct inode *inode, 3324 unsigned int ia_valid); 3325int setattr_prepare(struct mnt_idmap *, struct dentry *, struct iattr *); 3326extern int inode_newsize_ok(const struct inode *, loff_t offset); 3327void setattr_copy(struct mnt_idmap *, struct inode *inode, 3328 const struct iattr *attr); 3329 3330extern int file_update_time(struct file *file); 3331 3332static inline bool file_is_dax(const struct file *file) 3333{ 3334 return file && IS_DAX(file->f_mapping->host); 3335} 3336 3337static inline bool vma_is_dax(const struct vm_area_struct *vma) 3338{ 3339 return file_is_dax(vma->vm_file); 3340} 3341 3342static inline bool vma_is_fsdax(struct vm_area_struct *vma) 3343{ 3344 struct inode *inode; 3345 3346 if (!IS_ENABLED(CONFIG_FS_DAX) || !vma->vm_file) 3347 return false; 3348 if (!vma_is_dax(vma)) 3349 return false; 3350 inode = file_inode(vma->vm_file); 3351 if (S_ISCHR(inode->i_mode)) 3352 return false; /* device-dax */ 3353 return true; 3354} 3355 3356static inline int iocb_flags(struct file *file) 3357{ 3358 int res = 0; 3359 if (file->f_flags & O_APPEND) 3360 res |= IOCB_APPEND; 3361 if (file->f_flags & O_DIRECT) 3362 res |= IOCB_DIRECT; 3363 if (file->f_flags & O_DSYNC) 3364 res |= IOCB_DSYNC; 3365 if (file->f_flags & __O_SYNC) 3366 res |= IOCB_SYNC; 3367 return res; 3368} 3369 3370static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags, 3371 int rw_type) 3372{ 3373 int kiocb_flags = 0; 3374 3375 /* make sure there's no overlap between RWF and private IOCB flags */ 3376 BUILD_BUG_ON((__force int) RWF_SUPPORTED & IOCB_EVENTFD); 3377 3378 if (!flags) 3379 return 0; 3380 if (unlikely(flags & ~RWF_SUPPORTED)) 3381 return -EOPNOTSUPP; 3382 if (unlikely((flags & RWF_APPEND) && (flags & RWF_NOAPPEND))) 3383 return -EINVAL; 3384 3385 if (flags & RWF_NOWAIT) { 3386 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT)) 3387 return -EOPNOTSUPP; 3388 } 3389 if (flags & RWF_ATOMIC) { 3390 if (rw_type != WRITE) 3391 return -EOPNOTSUPP; 3392 if (!(ki->ki_filp->f_mode & FMODE_CAN_ATOMIC_WRITE)) 3393 return -EOPNOTSUPP; 3394 } 3395 if (flags & RWF_DONTCACHE) { 3396 /* file system must support it */ 3397 if (!(ki->ki_filp->f_op->fop_flags & FOP_DONTCACHE)) 3398 return -EOPNOTSUPP; 3399 /* DAX mappings not supported */ 3400 if (IS_DAX(ki->ki_filp->f_mapping->host)) 3401 return -EOPNOTSUPP; 3402 } 3403 kiocb_flags |= (__force int) (flags & RWF_SUPPORTED); 3404 if (flags & RWF_SYNC) 3405 kiocb_flags |= IOCB_DSYNC; 3406 3407 if ((flags & RWF_NOAPPEND) && (ki->ki_flags & IOCB_APPEND)) { 3408 if (IS_APPEND(file_inode(ki->ki_filp))) 3409 return -EPERM; 3410 ki->ki_flags &= ~IOCB_APPEND; 3411 } 3412 3413 ki->ki_flags |= kiocb_flags; 3414 return 0; 3415} 3416 3417/* Transaction based IO helpers */ 3418 3419/* 3420 * An argresp is stored in an allocated page and holds the 3421 * size of the argument or response, along with its content 3422 */ 3423struct simple_transaction_argresp { 3424 ssize_t size; 3425 char data[]; 3426}; 3427 3428#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp)) 3429 3430char *simple_transaction_get(struct file *file, const char __user *buf, 3431 size_t size); 3432ssize_t simple_transaction_read(struct file *file, char __user *buf, 3433 size_t size, loff_t *pos); 3434int simple_transaction_release(struct inode *inode, struct file *file); 3435 3436void simple_transaction_set(struct file *file, size_t n); 3437 3438/* 3439 * simple attribute files 3440 * 3441 * These attributes behave similar to those in sysfs: 3442 * 3443 * Writing to an attribute immediately sets a value, an open file can be 3444 * written to multiple times. 3445 * 3446 * Reading from an attribute creates a buffer from the value that might get 3447 * read with multiple read calls. When the attribute has been read 3448 * completely, no further read calls are possible until the file is opened 3449 * again. 3450 * 3451 * All attributes contain a text representation of a numeric value 3452 * that are accessed with the get() and set() functions. 3453 */ 3454#define DEFINE_SIMPLE_ATTRIBUTE_XSIGNED(__fops, __get, __set, __fmt, __is_signed) \ 3455static int __fops ## _open(struct inode *inode, struct file *file) \ 3456{ \ 3457 __simple_attr_check_format(__fmt, 0ull); \ 3458 return simple_attr_open(inode, file, __get, __set, __fmt); \ 3459} \ 3460static const struct file_operations __fops = { \ 3461 .owner = THIS_MODULE, \ 3462 .open = __fops ## _open, \ 3463 .release = simple_attr_release, \ 3464 .read = simple_attr_read, \ 3465 .write = (__is_signed) ? simple_attr_write_signed : simple_attr_write, \ 3466 .llseek = generic_file_llseek, \ 3467} 3468 3469#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \ 3470 DEFINE_SIMPLE_ATTRIBUTE_XSIGNED(__fops, __get, __set, __fmt, false) 3471 3472#define DEFINE_SIMPLE_ATTRIBUTE_SIGNED(__fops, __get, __set, __fmt) \ 3473 DEFINE_SIMPLE_ATTRIBUTE_XSIGNED(__fops, __get, __set, __fmt, true) 3474 3475static inline __printf(1, 2) 3476void __simple_attr_check_format(const char *fmt, ...) 3477{ 3478 /* don't do anything, just let the compiler check the arguments; */ 3479} 3480 3481int simple_attr_open(struct inode *inode, struct file *file, 3482 int (*get)(void *, u64 *), int (*set)(void *, u64), 3483 const char *fmt); 3484int simple_attr_release(struct inode *inode, struct file *file); 3485ssize_t simple_attr_read(struct file *file, char __user *buf, 3486 size_t len, loff_t *ppos); 3487ssize_t simple_attr_write(struct file *file, const char __user *buf, 3488 size_t len, loff_t *ppos); 3489ssize_t simple_attr_write_signed(struct file *file, const char __user *buf, 3490 size_t len, loff_t *ppos); 3491 3492struct ctl_table; 3493int __init list_bdev_fs_names(char *buf, size_t size); 3494 3495#define __FMODE_EXEC ((__force int) FMODE_EXEC) 3496 3497#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE]) 3498#define OPEN_FMODE(flag) ((__force fmode_t)((flag + 1) & O_ACCMODE)) 3499 3500static inline bool is_sxid(umode_t mode) 3501{ 3502 return mode & (S_ISUID | S_ISGID); 3503} 3504 3505static inline int check_sticky(struct mnt_idmap *idmap, 3506 struct inode *dir, struct inode *inode) 3507{ 3508 if (!(dir->i_mode & S_ISVTX)) 3509 return 0; 3510 3511 return __check_sticky(idmap, dir, inode); 3512} 3513 3514static inline void inode_has_no_xattr(struct inode *inode) 3515{ 3516 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC)) 3517 inode->i_flags |= S_NOSEC; 3518} 3519 3520static inline bool is_root_inode(struct inode *inode) 3521{ 3522 return inode == inode->i_sb->s_root->d_inode; 3523} 3524 3525static inline bool dir_emit(struct dir_context *ctx, 3526 const char *name, int namelen, 3527 u64 ino, unsigned type) 3528{ 3529 unsigned int dt_mask = S_DT_MASK | ctx->dt_flags_mask; 3530 3531 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type & dt_mask); 3532} 3533static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx) 3534{ 3535 return ctx->actor(ctx, ".", 1, ctx->pos, 3536 file->f_path.dentry->d_inode->i_ino, DT_DIR); 3537} 3538static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx) 3539{ 3540 return ctx->actor(ctx, "..", 2, ctx->pos, 3541 d_parent_ino(file->f_path.dentry), DT_DIR); 3542} 3543static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx) 3544{ 3545 if (ctx->pos == 0) { 3546 if (!dir_emit_dot(file, ctx)) 3547 return false; 3548 ctx->pos = 1; 3549 } 3550 if (ctx->pos == 1) { 3551 if (!dir_emit_dotdot(file, ctx)) 3552 return false; 3553 ctx->pos = 2; 3554 } 3555 return true; 3556} 3557static inline bool dir_relax(struct inode *inode) 3558{ 3559 inode_unlock(inode); 3560 inode_lock(inode); 3561 return !IS_DEADDIR(inode); 3562} 3563 3564static inline bool dir_relax_shared(struct inode *inode) 3565{ 3566 inode_unlock_shared(inode); 3567 inode_lock_shared(inode); 3568 return !IS_DEADDIR(inode); 3569} 3570 3571extern bool path_noexec(const struct path *path); 3572extern void inode_nohighmem(struct inode *inode); 3573 3574/* mm/fadvise.c */ 3575extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len, 3576 int advice); 3577extern int generic_fadvise(struct file *file, loff_t offset, loff_t len, 3578 int advice); 3579 3580static inline bool vfs_empty_path(int dfd, const char __user *path) 3581{ 3582 char c; 3583 3584 if (dfd < 0) 3585 return false; 3586 3587 /* We now allow NULL to be used for empty path. */ 3588 if (!path) 3589 return true; 3590 3591 if (unlikely(get_user(c, path))) 3592 return false; 3593 3594 return !c; 3595} 3596 3597int generic_atomic_write_valid(struct kiocb *iocb, struct iov_iter *iter); 3598 3599static inline bool extensible_ioctl_valid(unsigned int cmd_a, 3600 unsigned int cmd_b, size_t min_size) 3601{ 3602 if (_IOC_DIR(cmd_a) != _IOC_DIR(cmd_b)) 3603 return false; 3604 if (_IOC_TYPE(cmd_a) != _IOC_TYPE(cmd_b)) 3605 return false; 3606 if (_IOC_NR(cmd_a) != _IOC_NR(cmd_b)) 3607 return false; 3608 if (_IOC_SIZE(cmd_a) < min_size) 3609 return false; 3610 return true; 3611} 3612 3613#endif /* _LINUX_FS_H */
~/
Read-only file preview.