1#ifndef _LINUX_FS_H 2#define _LINUX_FS_H 3 4 5#include <linux/linkage.h> 6#include <linux/wait.h> 7#include <linux/kdev_t.h> 8#include <linux/dcache.h> 9#include <linux/path.h> 10#include <linux/stat.h> 11#include <linux/cache.h> 12#include <linux/list.h> 13#include <linux/list_lru.h> 14#include <linux/llist.h> 15#include <linux/radix-tree.h> 16#include <linux/rbtree.h> 17#include <linux/init.h> 18#include <linux/pid.h> 19#include <linux/bug.h> 20#include <linux/mutex.h> 21#include <linux/rwsem.h> 22#include <linux/capability.h> 23#include <linux/semaphore.h> 24#include <linux/fiemap.h> 25#include <linux/rculist_bl.h> 26#include <linux/atomic.h> 27#include <linux/shrinker.h> 28#include <linux/migrate_mode.h> 29#include <linux/uidgid.h> 30#include <linux/lockdep.h> 31#include <linux/percpu-rwsem.h> 32#include <linux/blk_types.h> 33 34#include <asm/byteorder.h> 35#include <uapi/linux/fs.h> 36 37struct backing_dev_info; 38struct export_operations; 39struct hd_geometry; 40struct iovec; 41struct nameidata; 42struct kiocb; 43struct kobject; 44struct pipe_inode_info; 45struct poll_table_struct; 46struct kstatfs; 47struct vm_area_struct; 48struct vfsmount; 49struct cred; 50struct swap_info_struct; 51struct seq_file; 52struct workqueue_struct; 53struct iov_iter; 54struct vm_fault; 55 56extern void __init inode_init(void); 57extern void __init inode_init_early(void); 58extern void __init files_init(unsigned long); 59 60extern struct files_stat_struct files_stat; 61extern unsigned long get_max_files(void); 62extern int sysctl_nr_open; 63extern struct inodes_stat_t inodes_stat; 64extern int leases_enable, lease_break_time; 65extern int sysctl_protected_symlinks; 66extern int sysctl_protected_hardlinks; 67 68struct buffer_head; 69typedef int (get_block_t)(struct inode *inode, sector_t iblock, 70 struct buffer_head *bh_result, int create); 71typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset, 72 ssize_t bytes, void *private); 73typedef void (dax_iodone_t)(struct buffer_head *bh_map, int uptodate); 74 75#define MAY_EXEC 0x00000001 76#define MAY_WRITE 0x00000002 77#define MAY_READ 0x00000004 78#define MAY_APPEND 0x00000008 79#define MAY_ACCESS 0x00000010 80#define MAY_OPEN 0x00000020 81#define MAY_CHDIR 0x00000040 82/* called from RCU mode, don't block */ 83#define MAY_NOT_BLOCK 0x00000080 84 85/* 86 * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond 87 * to O_WRONLY and O_RDWR via the strange trick in __dentry_open() 88 */ 89 90/* file is open for reading */ 91#define FMODE_READ ((__force fmode_t)0x1) 92/* file is open for writing */ 93#define FMODE_WRITE ((__force fmode_t)0x2) 94/* file is seekable */ 95#define FMODE_LSEEK ((__force fmode_t)0x4) 96/* file can be accessed using pread */ 97#define FMODE_PREAD ((__force fmode_t)0x8) 98/* file can be accessed using pwrite */ 99#define FMODE_PWRITE ((__force fmode_t)0x10) 100/* File is opened for execution with sys_execve / sys_uselib */ 101#define FMODE_EXEC ((__force fmode_t)0x20) 102/* File is opened with O_NDELAY (only set for block devices) */ 103#define FMODE_NDELAY ((__force fmode_t)0x40) 104/* File is opened with O_EXCL (only set for block devices) */ 105#define FMODE_EXCL ((__force fmode_t)0x80) 106/* File is opened using open(.., 3, ..) and is writeable only for ioctls 107 (specialy hack for floppy.c) */ 108#define FMODE_WRITE_IOCTL ((__force fmode_t)0x100) 109/* 32bit hashes as llseek() offset (for directories) */ 110#define FMODE_32BITHASH ((__force fmode_t)0x200) 111/* 64bit hashes as llseek() offset (for directories) */ 112#define FMODE_64BITHASH ((__force fmode_t)0x400) 113 114/* 115 * Don't update ctime and mtime. 116 * 117 * Currently a special hack for the XFS open_by_handle ioctl, but we'll 118 * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon. 119 */ 120#define FMODE_NOCMTIME ((__force fmode_t)0x800) 121 122/* Expect random access pattern */ 123#define FMODE_RANDOM ((__force fmode_t)0x1000) 124 125/* File is huge (eg. /dev/kmem): treat loff_t as unsigned */ 126#define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000) 127 128/* File is opened with O_PATH; almost nothing can be done with it */ 129#define FMODE_PATH ((__force fmode_t)0x4000) 130 131/* File needs atomic accesses to f_pos */ 132#define FMODE_ATOMIC_POS ((__force fmode_t)0x8000) 133/* Write access to underlying fs */ 134#define FMODE_WRITER ((__force fmode_t)0x10000) 135/* Has read method(s) */ 136#define FMODE_CAN_READ ((__force fmode_t)0x20000) 137/* Has write method(s) */ 138#define FMODE_CAN_WRITE ((__force fmode_t)0x40000) 139 140/* File was opened by fanotify and shouldn't generate fanotify events */ 141#define FMODE_NONOTIFY ((__force fmode_t)0x4000000) 142 143/* 144 * Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector 145 * that indicates that they should check the contents of the iovec are 146 * valid, but not check the memory that the iovec elements 147 * points too. 148 */ 149#define CHECK_IOVEC_ONLY -1 150 151/* 152 * The below are the various read and write types that we support. Some of 153 * them include behavioral modifiers that send information down to the 154 * block layer and IO scheduler. Terminology: 155 * 156 * The block layer uses device plugging to defer IO a little bit, in 157 * the hope that we will see more IO very shortly. This increases 158 * coalescing of adjacent IO and thus reduces the number of IOs we 159 * have to send to the device. It also allows for better queuing, 160 * if the IO isn't mergeable. If the caller is going to be waiting 161 * for the IO, then he must ensure that the device is unplugged so 162 * that the IO is dispatched to the driver. 163 * 164 * All IO is handled async in Linux. This is fine for background 165 * writes, but for reads or writes that someone waits for completion 166 * on, we want to notify the block layer and IO scheduler so that they 167 * know about it. That allows them to make better scheduling 168 * decisions. So when the below references 'sync' and 'async', it 169 * is referencing this priority hint. 170 * 171 * With that in mind, the available types are: 172 * 173 * READ A normal read operation. Device will be plugged. 174 * READ_SYNC A synchronous read. Device is not plugged, caller can 175 * immediately wait on this read without caring about 176 * unplugging. 177 * READA Used for read-ahead operations. Lower priority, and the 178 * block layer could (in theory) choose to ignore this 179 * request if it runs into resource problems. 180 * WRITE A normal async write. Device will be plugged. 181 * WRITE_SYNC Synchronous write. Identical to WRITE, but passes down 182 * the hint that someone will be waiting on this IO 183 * shortly. The write equivalent of READ_SYNC. 184 * WRITE_ODIRECT Special case write for O_DIRECT only. 185 * WRITE_FLUSH Like WRITE_SYNC but with preceding cache flush. 186 * WRITE_FUA Like WRITE_SYNC but data is guaranteed to be on 187 * non-volatile media on completion. 188 * WRITE_FLUSH_FUA Combination of WRITE_FLUSH and FUA. The IO is preceded 189 * by a cache flush and data is guaranteed to be on 190 * non-volatile media on completion. 191 * 192 */ 193#define RW_MASK REQ_WRITE 194#define RWA_MASK REQ_RAHEAD 195 196#define READ 0 197#define WRITE RW_MASK 198#define READA RWA_MASK 199 200#define READ_SYNC (READ | REQ_SYNC) 201#define WRITE_SYNC (WRITE | REQ_SYNC | REQ_NOIDLE) 202#define WRITE_ODIRECT (WRITE | REQ_SYNC) 203#define WRITE_FLUSH (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH) 204#define WRITE_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FUA) 205#define WRITE_FLUSH_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH | REQ_FUA) 206 207/* 208 * Attribute flags. These should be or-ed together to figure out what 209 * has been changed! 210 */ 211#define ATTR_MODE (1 << 0) 212#define ATTR_UID (1 << 1) 213#define ATTR_GID (1 << 2) 214#define ATTR_SIZE (1 << 3) 215#define ATTR_ATIME (1 << 4) 216#define ATTR_MTIME (1 << 5) 217#define ATTR_CTIME (1 << 6) 218#define ATTR_ATIME_SET (1 << 7) 219#define ATTR_MTIME_SET (1 << 8) 220#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */ 221#define ATTR_ATTR_FLAG (1 << 10) 222#define ATTR_KILL_SUID (1 << 11) 223#define ATTR_KILL_SGID (1 << 12) 224#define ATTR_FILE (1 << 13) 225#define ATTR_KILL_PRIV (1 << 14) 226#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */ 227#define ATTR_TIMES_SET (1 << 16) 228 229/* 230 * Whiteout is represented by a char device. The following constants define the 231 * mode and device number to use. 232 */ 233#define WHITEOUT_MODE 0 234#define WHITEOUT_DEV 0 235 236/* 237 * This is the Inode Attributes structure, used for notify_change(). It 238 * uses the above definitions as flags, to know which values have changed. 239 * Also, in this manner, a Filesystem can look at only the values it cares 240 * about. Basically, these are the attributes that the VFS layer can 241 * request to change from the FS layer. 242 * 243 * Derek Atkins <warlord@MIT.EDU> 94-10-20 244 */ 245struct iattr { 246 unsigned int ia_valid; 247 umode_t ia_mode; 248 kuid_t ia_uid; 249 kgid_t ia_gid; 250 loff_t ia_size; 251 struct timespec ia_atime; 252 struct timespec ia_mtime; 253 struct timespec ia_ctime; 254 255 /* 256 * Not an attribute, but an auxiliary info for filesystems wanting to 257 * implement an ftruncate() like method. NOTE: filesystem should 258 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL). 259 */ 260 struct file *ia_file; 261}; 262 263/* 264 * Includes for diskquotas. 265 */ 266#include <linux/quota.h> 267 268/* 269 * Maximum number of layers of fs stack. Needs to be limited to 270 * prevent kernel stack overflow 271 */ 272#define FILESYSTEM_MAX_STACK_DEPTH 2 273 274/** 275 * enum positive_aop_returns - aop return codes with specific semantics 276 * 277 * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has 278 * completed, that the page is still locked, and 279 * should be considered active. The VM uses this hint 280 * to return the page to the active list -- it won't 281 * be a candidate for writeback again in the near 282 * future. Other callers must be careful to unlock 283 * the page if they get this return. Returned by 284 * writepage(); 285 * 286 * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has 287 * unlocked it and the page might have been truncated. 288 * The caller should back up to acquiring a new page and 289 * trying again. The aop will be taking reasonable 290 * precautions not to livelock. If the caller held a page 291 * reference, it should drop it before retrying. Returned 292 * by readpage(). 293 * 294 * address_space_operation functions return these large constants to indicate 295 * special semantics to the caller. These are much larger than the bytes in a 296 * page to allow for functions that return the number of bytes operated on in a 297 * given page. 298 */ 299 300enum positive_aop_returns { 301 AOP_WRITEPAGE_ACTIVATE = 0x80000, 302 AOP_TRUNCATED_PAGE = 0x80001, 303}; 304 305#define AOP_FLAG_UNINTERRUPTIBLE 0x0001 /* will not do a short write */ 306#define AOP_FLAG_CONT_EXPAND 0x0002 /* called from cont_expand */ 307#define AOP_FLAG_NOFS 0x0004 /* used by filesystem to direct 308 * helper code (eg buffer layer) 309 * to clear GFP_FS from alloc */ 310 311/* 312 * oh the beauties of C type declarations. 313 */ 314struct page; 315struct address_space; 316struct writeback_control; 317 318#define IOCB_EVENTFD (1 << 0) 319#define IOCB_APPEND (1 << 1) 320#define IOCB_DIRECT (1 << 2) 321 322struct kiocb { 323 struct file *ki_filp; 324 loff_t ki_pos; 325 void (*ki_complete)(struct kiocb *iocb, long ret, long ret2); 326 void *private; 327 int ki_flags; 328}; 329 330static inline bool is_sync_kiocb(struct kiocb *kiocb) 331{ 332 return kiocb->ki_complete == NULL; 333} 334 335static inline int iocb_flags(struct file *file); 336 337static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp) 338{ 339 *kiocb = (struct kiocb) { 340 .ki_filp = filp, 341 .ki_flags = iocb_flags(filp), 342 }; 343} 344 345/* 346 * "descriptor" for what we're up to with a read. 347 * This allows us to use the same read code yet 348 * have multiple different users of the data that 349 * we read from a file. 350 * 351 * The simplest case just copies the data to user 352 * mode. 353 */ 354typedef struct { 355 size_t written; 356 size_t count; 357 union { 358 char __user *buf; 359 void *data; 360 } arg; 361 int error; 362} read_descriptor_t; 363 364typedef int (*read_actor_t)(read_descriptor_t *, struct page *, 365 unsigned long, unsigned long); 366 367struct address_space_operations { 368 int (*writepage)(struct page *page, struct writeback_control *wbc); 369 int (*readpage)(struct file *, struct page *); 370 371 /* Write back some dirty pages from this mapping. */ 372 int (*writepages)(struct address_space *, struct writeback_control *); 373 374 /* Set a page dirty. Return true if this dirtied it */ 375 int (*set_page_dirty)(struct page *page); 376 377 int (*readpages)(struct file *filp, struct address_space *mapping, 378 struct list_head *pages, unsigned nr_pages); 379 380 int (*write_begin)(struct file *, struct address_space *mapping, 381 loff_t pos, unsigned len, unsigned flags, 382 struct page **pagep, void **fsdata); 383 int (*write_end)(struct file *, struct address_space *mapping, 384 loff_t pos, unsigned len, unsigned copied, 385 struct page *page, void *fsdata); 386 387 /* Unfortunately this kludge is needed for FIBMAP. Don't use it */ 388 sector_t (*bmap)(struct address_space *, sector_t); 389 void (*invalidatepage) (struct page *, unsigned int, unsigned int); 390 int (*releasepage) (struct page *, gfp_t); 391 void (*freepage)(struct page *); 392 ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter, loff_t offset); 393 /* 394 * migrate the contents of a page to the specified target. If 395 * migrate_mode is MIGRATE_ASYNC, it must not block. 396 */ 397 int (*migratepage) (struct address_space *, 398 struct page *, struct page *, enum migrate_mode); 399 int (*launder_page) (struct page *); 400 int (*is_partially_uptodate) (struct page *, unsigned long, 401 unsigned long); 402 void (*is_dirty_writeback) (struct page *, bool *, bool *); 403 int (*error_remove_page)(struct address_space *, struct page *); 404 405 /* swapfile support */ 406 int (*swap_activate)(struct swap_info_struct *sis, struct file *file, 407 sector_t *span); 408 void (*swap_deactivate)(struct file *file); 409}; 410 411extern const struct address_space_operations empty_aops; 412 413/* 414 * pagecache_write_begin/pagecache_write_end must be used by general code 415 * to write into the pagecache. 416 */ 417int pagecache_write_begin(struct file *, struct address_space *mapping, 418 loff_t pos, unsigned len, unsigned flags, 419 struct page **pagep, void **fsdata); 420 421int pagecache_write_end(struct file *, struct address_space *mapping, 422 loff_t pos, unsigned len, unsigned copied, 423 struct page *page, void *fsdata); 424 425struct address_space { 426 struct inode *host; /* owner: inode, block_device */ 427 struct radix_tree_root page_tree; /* radix tree of all pages */ 428 spinlock_t tree_lock; /* and lock protecting it */ 429 atomic_t i_mmap_writable;/* count VM_SHARED mappings */ 430 struct rb_root i_mmap; /* tree of private and shared mappings */ 431 struct rw_semaphore i_mmap_rwsem; /* protect tree, count, list */ 432 /* Protected by tree_lock together with the radix tree */ 433 unsigned long nrpages; /* number of total pages */ 434 unsigned long nrshadows; /* number of shadow entries */ 435 pgoff_t writeback_index;/* writeback starts here */ 436 const struct address_space_operations *a_ops; /* methods */ 437 unsigned long flags; /* error bits/gfp mask */ 438 spinlock_t private_lock; /* for use by the address_space */ 439 struct list_head private_list; /* ditto */ 440 void *private_data; /* ditto */ 441} __attribute__((aligned(sizeof(long)))); 442 /* 443 * On most architectures that alignment is already the case; but 444 * must be enforced here for CRIS, to let the least significant bit 445 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON. 446 */ 447struct request_queue; 448 449struct block_device { 450 dev_t bd_dev; /* not a kdev_t - it's a search key */ 451 int bd_openers; 452 struct inode * bd_inode; /* will die */ 453 struct super_block * bd_super; 454 struct mutex bd_mutex; /* open/close mutex */ 455 struct list_head bd_inodes; 456 void * bd_claiming; 457 void * bd_holder; 458 int bd_holders; 459 bool bd_write_holder; 460#ifdef CONFIG_SYSFS 461 struct list_head bd_holder_disks; 462#endif 463 struct block_device * bd_contains; 464 unsigned bd_block_size; 465 struct hd_struct * bd_part; 466 /* number of times partitions within this device have been opened. */ 467 unsigned bd_part_count; 468 int bd_invalidated; 469 struct gendisk * bd_disk; 470 struct request_queue * bd_queue; 471 struct list_head bd_list; 472 /* 473 * Private data. You must have bd_claim'ed the block_device 474 * to use this. NOTE: bd_claim allows an owner to claim 475 * the same device multiple times, the owner must take special 476 * care to not mess up bd_private for that case. 477 */ 478 unsigned long bd_private; 479 480 /* The counter of freeze processes */ 481 int bd_fsfreeze_count; 482 /* Mutex for freeze */ 483 struct mutex bd_fsfreeze_mutex; 484}; 485 486/* 487 * Radix-tree tags, for tagging dirty and writeback pages within the pagecache 488 * radix trees 489 */ 490#define PAGECACHE_TAG_DIRTY 0 491#define PAGECACHE_TAG_WRITEBACK 1 492#define PAGECACHE_TAG_TOWRITE 2 493 494int mapping_tagged(struct address_space *mapping, int tag); 495 496static inline void i_mmap_lock_write(struct address_space *mapping) 497{ 498 down_write(&mapping->i_mmap_rwsem); 499} 500 501static inline void i_mmap_unlock_write(struct address_space *mapping) 502{ 503 up_write(&mapping->i_mmap_rwsem); 504} 505 506static inline void i_mmap_lock_read(struct address_space *mapping) 507{ 508 down_read(&mapping->i_mmap_rwsem); 509} 510 511static inline void i_mmap_unlock_read(struct address_space *mapping) 512{ 513 up_read(&mapping->i_mmap_rwsem); 514} 515 516/* 517 * Might pages of this file be mapped into userspace? 518 */ 519static inline int mapping_mapped(struct address_space *mapping) 520{ 521 return !RB_EMPTY_ROOT(&mapping->i_mmap); 522} 523 524/* 525 * Might pages of this file have been modified in userspace? 526 * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff 527 * marks vma as VM_SHARED if it is shared, and the file was opened for 528 * writing i.e. vma may be mprotected writable even if now readonly. 529 * 530 * If i_mmap_writable is negative, no new writable mappings are allowed. You 531 * can only deny writable mappings, if none exists right now. 532 */ 533static inline int mapping_writably_mapped(struct address_space *mapping) 534{ 535 return atomic_read(&mapping->i_mmap_writable) > 0; 536} 537 538static inline int mapping_map_writable(struct address_space *mapping) 539{ 540 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ? 541 0 : -EPERM; 542} 543 544static inline void mapping_unmap_writable(struct address_space *mapping) 545{ 546 atomic_dec(&mapping->i_mmap_writable); 547} 548 549static inline int mapping_deny_writable(struct address_space *mapping) 550{ 551 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ? 552 0 : -EBUSY; 553} 554 555static inline void mapping_allow_writable(struct address_space *mapping) 556{ 557 atomic_inc(&mapping->i_mmap_writable); 558} 559 560/* 561 * Use sequence counter to get consistent i_size on 32-bit processors. 562 */ 563#if BITS_PER_LONG==32 && defined(CONFIG_SMP) 564#include <linux/seqlock.h> 565#define __NEED_I_SIZE_ORDERED 566#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount) 567#else 568#define i_size_ordered_init(inode) do { } while (0) 569#endif 570 571struct posix_acl; 572#define ACL_NOT_CACHED ((void *)(-1)) 573 574#define IOP_FASTPERM 0x0001 575#define IOP_LOOKUP 0x0002 576#define IOP_NOFOLLOW 0x0004 577 578/* 579 * Keep mostly read-only and often accessed (especially for 580 * the RCU path lookup and 'stat' data) fields at the beginning 581 * of the 'struct inode' 582 */ 583struct inode { 584 umode_t i_mode; 585 unsigned short i_opflags; 586 kuid_t i_uid; 587 kgid_t i_gid; 588 unsigned int i_flags; 589 590#ifdef CONFIG_FS_POSIX_ACL 591 struct posix_acl *i_acl; 592 struct posix_acl *i_default_acl; 593#endif 594 595 const struct inode_operations *i_op; 596 struct super_block *i_sb; 597 struct address_space *i_mapping; 598 599#ifdef CONFIG_SECURITY 600 void *i_security; 601#endif 602 603 /* Stat data, not accessed from path walking */ 604 unsigned long i_ino; 605 /* 606 * Filesystems may only read i_nlink directly. They shall use the 607 * following functions for modification: 608 * 609 * (set|clear|inc|drop)_nlink 610 * inode_(inc|dec)_link_count 611 */ 612 union { 613 const unsigned int i_nlink; 614 unsigned int __i_nlink; 615 }; 616 dev_t i_rdev; 617 loff_t i_size; 618 struct timespec i_atime; 619 struct timespec i_mtime; 620 struct timespec i_ctime; 621 spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */ 622 unsigned short i_bytes; 623 unsigned int i_blkbits; 624 blkcnt_t i_blocks; 625 626#ifdef __NEED_I_SIZE_ORDERED 627 seqcount_t i_size_seqcount; 628#endif 629 630 /* Misc */ 631 unsigned long i_state; 632 struct mutex i_mutex; 633 634 unsigned long dirtied_when; /* jiffies of first dirtying */ 635 unsigned long dirtied_time_when; 636 637 struct hlist_node i_hash; 638 struct list_head i_wb_list; /* backing dev IO list */ 639 struct list_head i_lru; /* inode LRU list */ 640 struct list_head i_sb_list; 641 union { 642 struct hlist_head i_dentry; 643 struct rcu_head i_rcu; 644 }; 645 u64 i_version; 646 atomic_t i_count; 647 atomic_t i_dio_count; 648 atomic_t i_writecount; 649#ifdef CONFIG_IMA 650 atomic_t i_readcount; /* struct files open RO */ 651#endif 652 const struct file_operations *i_fop; /* former ->i_op->default_file_ops */ 653 struct file_lock_context *i_flctx; 654 struct address_space i_data; 655 struct list_head i_devices; 656 union { 657 struct pipe_inode_info *i_pipe; 658 struct block_device *i_bdev; 659 struct cdev *i_cdev; 660 }; 661 662 __u32 i_generation; 663 664#ifdef CONFIG_FSNOTIFY 665 __u32 i_fsnotify_mask; /* all events this inode cares about */ 666 struct hlist_head i_fsnotify_marks; 667#endif 668 669 void *i_private; /* fs or device private pointer */ 670}; 671 672static inline int inode_unhashed(struct inode *inode) 673{ 674 return hlist_unhashed(&inode->i_hash); 675} 676 677/* 678 * inode->i_mutex nesting subclasses for the lock validator: 679 * 680 * 0: the object of the current VFS operation 681 * 1: parent 682 * 2: child/target 683 * 3: xattr 684 * 4: second non-directory 685 * 5: second parent (when locking independent directories in rename) 686 * 687 * I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two 688 * non-directories at once. 689 * 690 * The locking order between these classes is 691 * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory 692 */ 693enum inode_i_mutex_lock_class 694{ 695 I_MUTEX_NORMAL, 696 I_MUTEX_PARENT, 697 I_MUTEX_CHILD, 698 I_MUTEX_XATTR, 699 I_MUTEX_NONDIR2, 700 I_MUTEX_PARENT2, 701}; 702 703void lock_two_nondirectories(struct inode *, struct inode*); 704void unlock_two_nondirectories(struct inode *, struct inode*); 705 706/* 707 * NOTE: in a 32bit arch with a preemptable kernel and 708 * an UP compile the i_size_read/write must be atomic 709 * with respect to the local cpu (unlike with preempt disabled), 710 * but they don't need to be atomic with respect to other cpus like in 711 * true SMP (so they need either to either locally disable irq around 712 * the read or for example on x86 they can be still implemented as a 713 * cmpxchg8b without the need of the lock prefix). For SMP compiles 714 * and 64bit archs it makes no difference if preempt is enabled or not. 715 */ 716static inline loff_t i_size_read(const struct inode *inode) 717{ 718#if BITS_PER_LONG==32 && defined(CONFIG_SMP) 719 loff_t i_size; 720 unsigned int seq; 721 722 do { 723 seq = read_seqcount_begin(&inode->i_size_seqcount); 724 i_size = inode->i_size; 725 } while (read_seqcount_retry(&inode->i_size_seqcount, seq)); 726 return i_size; 727#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT) 728 loff_t i_size; 729 730 preempt_disable(); 731 i_size = inode->i_size; 732 preempt_enable(); 733 return i_size; 734#else 735 return inode->i_size; 736#endif 737} 738 739/* 740 * NOTE: unlike i_size_read(), i_size_write() does need locking around it 741 * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount 742 * can be lost, resulting in subsequent i_size_read() calls spinning forever. 743 */ 744static inline void i_size_write(struct inode *inode, loff_t i_size) 745{ 746#if BITS_PER_LONG==32 && defined(CONFIG_SMP) 747 preempt_disable(); 748 write_seqcount_begin(&inode->i_size_seqcount); 749 inode->i_size = i_size; 750 write_seqcount_end(&inode->i_size_seqcount); 751 preempt_enable(); 752#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT) 753 preempt_disable(); 754 inode->i_size = i_size; 755 preempt_enable(); 756#else 757 inode->i_size = i_size; 758#endif 759} 760 761/* Helper functions so that in most cases filesystems will 762 * not need to deal directly with kuid_t and kgid_t and can 763 * instead deal with the raw numeric values that are stored 764 * in the filesystem. 765 */ 766static inline uid_t i_uid_read(const struct inode *inode) 767{ 768 return from_kuid(&init_user_ns, inode->i_uid); 769} 770 771static inline gid_t i_gid_read(const struct inode *inode) 772{ 773 return from_kgid(&init_user_ns, inode->i_gid); 774} 775 776static inline void i_uid_write(struct inode *inode, uid_t uid) 777{ 778 inode->i_uid = make_kuid(&init_user_ns, uid); 779} 780 781static inline void i_gid_write(struct inode *inode, gid_t gid) 782{ 783 inode->i_gid = make_kgid(&init_user_ns, gid); 784} 785 786static inline unsigned iminor(const struct inode *inode) 787{ 788 return MINOR(inode->i_rdev); 789} 790 791static inline unsigned imajor(const struct inode *inode) 792{ 793 return MAJOR(inode->i_rdev); 794} 795 796extern struct block_device *I_BDEV(struct inode *inode); 797 798struct fown_struct { 799 rwlock_t lock; /* protects pid, uid, euid fields */ 800 struct pid *pid; /* pid or -pgrp where SIGIO should be sent */ 801 enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */ 802 kuid_t uid, euid; /* uid/euid of process setting the owner */ 803 int signum; /* posix.1b rt signal to be delivered on IO */ 804}; 805 806/* 807 * Track a single file's readahead state 808 */ 809struct file_ra_state { 810 pgoff_t start; /* where readahead started */ 811 unsigned int size; /* # of readahead pages */ 812 unsigned int async_size; /* do asynchronous readahead when 813 there are only # of pages ahead */ 814 815 unsigned int ra_pages; /* Maximum readahead window */ 816 unsigned int mmap_miss; /* Cache miss stat for mmap accesses */ 817 loff_t prev_pos; /* Cache last read() position */ 818}; 819 820/* 821 * Check if @index falls in the readahead windows. 822 */ 823static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index) 824{ 825 return (index >= ra->start && 826 index < ra->start + ra->size); 827} 828 829struct file { 830 union { 831 struct llist_node fu_llist; 832 struct rcu_head fu_rcuhead; 833 } f_u; 834 struct path f_path; 835 struct inode *f_inode; /* cached value */ 836 const struct file_operations *f_op; 837 838 /* 839 * Protects f_ep_links, f_flags. 840 * Must not be taken from IRQ context. 841 */ 842 spinlock_t f_lock; 843 atomic_long_t f_count; 844 unsigned int f_flags; 845 fmode_t f_mode; 846 struct mutex f_pos_lock; 847 loff_t f_pos; 848 struct fown_struct f_owner; 849 const struct cred *f_cred; 850 struct file_ra_state f_ra; 851 852 u64 f_version; 853#ifdef CONFIG_SECURITY 854 void *f_security; 855#endif 856 /* needed for tty driver, and maybe others */ 857 void *private_data; 858 859#ifdef CONFIG_EPOLL 860 /* Used by fs/eventpoll.c to link all the hooks to this file */ 861 struct list_head f_ep_links; 862 struct list_head f_tfile_llink; 863#endif /* #ifdef CONFIG_EPOLL */ 864 struct address_space *f_mapping; 865} __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */ 866 867struct file_handle { 868 __u32 handle_bytes; 869 int handle_type; 870 /* file identifier */ 871 unsigned char f_handle[0]; 872}; 873 874static inline struct file *get_file(struct file *f) 875{ 876 atomic_long_inc(&f->f_count); 877 return f; 878} 879#define get_file_rcu(x) atomic_long_inc_not_zero(&(x)->f_count) 880#define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1) 881#define file_count(x) atomic_long_read(&(x)->f_count) 882 883#define MAX_NON_LFS ((1UL<<31) - 1) 884 885/* Page cache limit. The filesystems should put that into their s_maxbytes 886 limits, otherwise bad things can happen in VM. */ 887#if BITS_PER_LONG==32 888#define MAX_LFS_FILESIZE (((loff_t)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1) 889#elif BITS_PER_LONG==64 890#define MAX_LFS_FILESIZE ((loff_t)0x7fffffffffffffffLL) 891#endif 892 893#define FL_POSIX 1 894#define FL_FLOCK 2 895#define FL_DELEG 4 /* NFSv4 delegation */ 896#define FL_ACCESS 8 /* not trying to lock, just looking */ 897#define FL_EXISTS 16 /* when unlocking, test for existence */ 898#define FL_LEASE 32 /* lease held on this file */ 899#define FL_CLOSE 64 /* unlock on close */ 900#define FL_SLEEP 128 /* A blocking lock */ 901#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ 902#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ 903#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ 904#define FL_LAYOUT 2048 /* outstanding pNFS layout */ 905 906/* 907 * Special return value from posix_lock_file() and vfs_lock_file() for 908 * asynchronous locking. 909 */ 910#define FILE_LOCK_DEFERRED 1 911 912/* legacy typedef, should eventually be removed */ 913typedef void *fl_owner_t; 914 915struct file_lock; 916 917struct file_lock_operations { 918 void (*fl_copy_lock)(struct file_lock *, struct file_lock *); 919 void (*fl_release_private)(struct file_lock *); 920}; 921 922struct lock_manager_operations { 923 int (*lm_compare_owner)(struct file_lock *, struct file_lock *); 924 unsigned long (*lm_owner_key)(struct file_lock *); 925 fl_owner_t (*lm_get_owner)(fl_owner_t); 926 void (*lm_put_owner)(fl_owner_t); 927 void (*lm_notify)(struct file_lock *); /* unblock callback */ 928 int (*lm_grant)(struct file_lock *, int); 929 bool (*lm_break)(struct file_lock *); 930 int (*lm_change)(struct file_lock *, int, struct list_head *); 931 void (*lm_setup)(struct file_lock *, void **); 932}; 933 934struct lock_manager { 935 struct list_head list; 936}; 937 938struct net; 939void locks_start_grace(struct net *, struct lock_manager *); 940void locks_end_grace(struct lock_manager *); 941int locks_in_grace(struct net *); 942 943/* that will die - we need it for nfs_lock_info */ 944#include <linux/nfs_fs_i.h> 945 946/* 947 * struct file_lock represents a generic "file lock". It's used to represent 948 * POSIX byte range locks, BSD (flock) locks, and leases. It's important to 949 * note that the same struct is used to represent both a request for a lock and 950 * the lock itself, but the same object is never used for both. 951 * 952 * FIXME: should we create a separate "struct lock_request" to help distinguish 953 * these two uses? 954 * 955 * The varous i_flctx lists are ordered by: 956 * 957 * 1) lock owner 958 * 2) lock range start 959 * 3) lock range end 960 * 961 * Obviously, the last two criteria only matter for POSIX locks. 962 */ 963struct file_lock { 964 struct file_lock *fl_next; /* singly linked list for this inode */ 965 struct list_head fl_list; /* link into file_lock_context */ 966 struct hlist_node fl_link; /* node in global lists */ 967 struct list_head fl_block; /* circular list of blocked processes */ 968 fl_owner_t fl_owner; 969 unsigned int fl_flags; 970 unsigned char fl_type; 971 unsigned int fl_pid; 972 int fl_link_cpu; /* what cpu's list is this on? */ 973 struct pid *fl_nspid; 974 wait_queue_head_t fl_wait; 975 struct file *fl_file; 976 loff_t fl_start; 977 loff_t fl_end; 978 979 struct fasync_struct * fl_fasync; /* for lease break notifications */ 980 /* for lease breaks: */ 981 unsigned long fl_break_time; 982 unsigned long fl_downgrade_time; 983 984 const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */ 985 const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */ 986 union { 987 struct nfs_lock_info nfs_fl; 988 struct nfs4_lock_info nfs4_fl; 989 struct { 990 struct list_head link; /* link in AFS vnode's pending_locks list */ 991 int state; /* state of grant or error if -ve */ 992 } afs; 993 } fl_u; 994}; 995 996struct file_lock_context { 997 spinlock_t flc_lock; 998 struct list_head flc_flock; 999 struct list_head flc_posix; 1000 struct list_head flc_lease; 1001}; 1002 1003/* The following constant reflects the upper bound of the file/locking space */ 1004#ifndef OFFSET_MAX 1005#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1))) 1006#define OFFSET_MAX INT_LIMIT(loff_t) 1007#define OFFT_OFFSET_MAX INT_LIMIT(off_t) 1008#endif 1009 1010#include <linux/fcntl.h> 1011 1012extern void send_sigio(struct fown_struct *fown, int fd, int band); 1013 1014#ifdef CONFIG_FILE_LOCKING 1015extern int fcntl_getlk(struct file *, unsigned int, struct flock __user *); 1016extern int fcntl_setlk(unsigned int, struct file *, unsigned int, 1017 struct flock __user *); 1018 1019#if BITS_PER_LONG == 32 1020extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 __user *); 1021extern int fcntl_setlk64(unsigned int, struct file *, unsigned int, 1022 struct flock64 __user *); 1023#endif 1024 1025extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg); 1026extern int fcntl_getlease(struct file *filp); 1027 1028/* fs/locks.c */ 1029void locks_free_lock_context(struct file_lock_context *ctx); 1030void locks_free_lock(struct file_lock *fl); 1031extern void locks_init_lock(struct file_lock *); 1032extern struct file_lock * locks_alloc_lock(void); 1033extern void locks_copy_lock(struct file_lock *, struct file_lock *); 1034extern void locks_copy_conflock(struct file_lock *, struct file_lock *); 1035extern void locks_remove_posix(struct file *, fl_owner_t); 1036extern void locks_remove_file(struct file *); 1037extern void locks_release_private(struct file_lock *); 1038extern void posix_test_lock(struct file *, struct file_lock *); 1039extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); 1040extern int posix_lock_inode_wait(struct inode *, struct file_lock *); 1041extern int posix_unblock_lock(struct file_lock *); 1042extern int vfs_test_lock(struct file *, struct file_lock *); 1043extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *); 1044extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl); 1045extern int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl); 1046extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type); 1047extern void lease_get_mtime(struct inode *, struct timespec *time); 1048extern int generic_setlease(struct file *, long, struct file_lock **, void **priv); 1049extern int vfs_setlease(struct file *, long, struct file_lock **, void **); 1050extern int lease_modify(struct file_lock *, int, struct list_head *); 1051struct files_struct; 1052extern void show_fd_locks(struct seq_file *f, 1053 struct file *filp, struct files_struct *files); 1054#else /* !CONFIG_FILE_LOCKING */ 1055static inline int fcntl_getlk(struct file *file, unsigned int cmd, 1056 struct flock __user *user) 1057{ 1058 return -EINVAL; 1059} 1060 1061static inline int fcntl_setlk(unsigned int fd, struct file *file, 1062 unsigned int cmd, struct flock __user *user) 1063{ 1064 return -EACCES; 1065} 1066 1067#if BITS_PER_LONG == 32 1068static inline int fcntl_getlk64(struct file *file, unsigned int cmd, 1069 struct flock64 __user *user) 1070{ 1071 return -EINVAL; 1072} 1073 1074static inline int fcntl_setlk64(unsigned int fd, struct file *file, 1075 unsigned int cmd, struct flock64 __user *user) 1076{ 1077 return -EACCES; 1078} 1079#endif 1080static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg) 1081{ 1082 return -EINVAL; 1083} 1084 1085static inline int fcntl_getlease(struct file *filp) 1086{ 1087 return F_UNLCK; 1088} 1089 1090static inline void 1091locks_free_lock_context(struct file_lock_context *ctx) 1092{ 1093} 1094 1095static inline void locks_init_lock(struct file_lock *fl) 1096{ 1097 return; 1098} 1099 1100static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) 1101{ 1102 return; 1103} 1104 1105static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl) 1106{ 1107 return; 1108} 1109 1110static inline void locks_remove_posix(struct file *filp, fl_owner_t owner) 1111{ 1112 return; 1113} 1114 1115static inline void locks_remove_file(struct file *filp) 1116{ 1117 return; 1118} 1119 1120static inline void posix_test_lock(struct file *filp, struct file_lock *fl) 1121{ 1122 return; 1123} 1124 1125static inline int posix_lock_file(struct file *filp, struct file_lock *fl, 1126 struct file_lock *conflock) 1127{ 1128 return -ENOLCK; 1129} 1130 1131static inline int posix_lock_inode_wait(struct inode *inode, 1132 struct file_lock *fl) 1133{ 1134 return -ENOLCK; 1135} 1136 1137static inline int posix_unblock_lock(struct file_lock *waiter) 1138{ 1139 return -ENOENT; 1140} 1141 1142static inline int vfs_test_lock(struct file *filp, struct file_lock *fl) 1143{ 1144 return 0; 1145} 1146 1147static inline int vfs_lock_file(struct file *filp, unsigned int cmd, 1148 struct file_lock *fl, struct file_lock *conf) 1149{ 1150 return -ENOLCK; 1151} 1152 1153static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl) 1154{ 1155 return 0; 1156} 1157 1158static inline int flock_lock_inode_wait(struct inode *inode, 1159 struct file_lock *request) 1160{ 1161 return -ENOLCK; 1162} 1163 1164static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) 1165{ 1166 return 0; 1167} 1168 1169static inline void lease_get_mtime(struct inode *inode, struct timespec *time) 1170{ 1171 return; 1172} 1173 1174static inline int generic_setlease(struct file *filp, long arg, 1175 struct file_lock **flp, void **priv) 1176{ 1177 return -EINVAL; 1178} 1179 1180static inline int vfs_setlease(struct file *filp, long arg, 1181 struct file_lock **lease, void **priv) 1182{ 1183 return -EINVAL; 1184} 1185 1186static inline int lease_modify(struct file_lock *fl, int arg, 1187 struct list_head *dispose) 1188{ 1189 return -EINVAL; 1190} 1191 1192struct files_struct; 1193static inline void show_fd_locks(struct seq_file *f, 1194 struct file *filp, struct files_struct *files) {} 1195#endif /* !CONFIG_FILE_LOCKING */ 1196 1197static inline struct inode *file_inode(const struct file *f) 1198{ 1199 return f->f_inode; 1200} 1201 1202static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl) 1203{ 1204 return posix_lock_inode_wait(file_inode(filp), fl); 1205} 1206 1207static inline int flock_lock_file_wait(struct file *filp, struct file_lock *fl) 1208{ 1209 return flock_lock_inode_wait(file_inode(filp), fl); 1210} 1211 1212struct fasync_struct { 1213 spinlock_t fa_lock; 1214 int magic; 1215 int fa_fd; 1216 struct fasync_struct *fa_next; /* singly linked list */ 1217 struct file *fa_file; 1218 struct rcu_head fa_rcu; 1219}; 1220 1221#define FASYNC_MAGIC 0x4601 1222 1223/* SMP safe fasync helpers: */ 1224extern int fasync_helper(int, struct file *, int, struct fasync_struct **); 1225extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *); 1226extern int fasync_remove_entry(struct file *, struct fasync_struct **); 1227extern struct fasync_struct *fasync_alloc(void); 1228extern void fasync_free(struct fasync_struct *); 1229 1230/* can be called from interrupts */ 1231extern void kill_fasync(struct fasync_struct **, int, int); 1232 1233extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force); 1234extern void f_setown(struct file *filp, unsigned long arg, int force); 1235extern void f_delown(struct file *filp); 1236extern pid_t f_getown(struct file *filp); 1237extern int send_sigurg(struct fown_struct *fown); 1238 1239struct mm_struct; 1240 1241/* 1242 * Umount options 1243 */ 1244 1245#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */ 1246#define MNT_DETACH 0x00000002 /* Just detach from the tree */ 1247#define MNT_EXPIRE 0x00000004 /* Mark for expiry */ 1248#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */ 1249#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */ 1250 1251 1252/* Possible states of 'frozen' field */ 1253enum { 1254 SB_UNFROZEN = 0, /* FS is unfrozen */ 1255 SB_FREEZE_WRITE = 1, /* Writes, dir ops, ioctls frozen */ 1256 SB_FREEZE_PAGEFAULT = 2, /* Page faults stopped as well */ 1257 SB_FREEZE_FS = 3, /* For internal FS use (e.g. to stop 1258 * internal threads if needed) */ 1259 SB_FREEZE_COMPLETE = 4, /* ->freeze_fs finished successfully */ 1260}; 1261 1262#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1) 1263 1264struct sb_writers { 1265 /* Counters for counting writers at each level */ 1266 struct percpu_counter counter[SB_FREEZE_LEVELS]; 1267 wait_queue_head_t wait; /* queue for waiting for 1268 writers / faults to finish */ 1269 int frozen; /* Is sb frozen? */ 1270 wait_queue_head_t wait_unfrozen; /* queue for waiting for 1271 sb to be thawed */ 1272#ifdef CONFIG_DEBUG_LOCK_ALLOC 1273 struct lockdep_map lock_map[SB_FREEZE_LEVELS]; 1274#endif 1275}; 1276 1277struct super_block { 1278 struct list_head s_list; /* Keep this first */ 1279 dev_t s_dev; /* search index; _not_ kdev_t */ 1280 unsigned char s_blocksize_bits; 1281 unsigned long s_blocksize; 1282 loff_t s_maxbytes; /* Max file size */ 1283 struct file_system_type *s_type; 1284 const struct super_operations *s_op; 1285 const struct dquot_operations *dq_op; 1286 const struct quotactl_ops *s_qcop; 1287 const struct export_operations *s_export_op; 1288 unsigned long s_flags; 1289 unsigned long s_magic; 1290 struct dentry *s_root; 1291 struct rw_semaphore s_umount; 1292 int s_count; 1293 atomic_t s_active; 1294#ifdef CONFIG_SECURITY 1295 void *s_security; 1296#endif 1297 const struct xattr_handler **s_xattr; 1298 1299 struct list_head s_inodes; /* all inodes */ 1300 struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */ 1301 struct list_head s_mounts; /* list of mounts; _not_ for fs use */ 1302 struct block_device *s_bdev; 1303 struct backing_dev_info *s_bdi; 1304 struct mtd_info *s_mtd; 1305 struct hlist_node s_instances; 1306 unsigned int s_quota_types; /* Bitmask of supported quota types */ 1307 struct quota_info s_dquot; /* Diskquota specific options */ 1308 1309 struct sb_writers s_writers; 1310 1311 char s_id[32]; /* Informational name */ 1312 u8 s_uuid[16]; /* UUID */ 1313 1314 void *s_fs_info; /* Filesystem private info */ 1315 unsigned int s_max_links; 1316 fmode_t s_mode; 1317 1318 /* Granularity of c/m/atime in ns. 1319 Cannot be worse than a second */ 1320 u32 s_time_gran; 1321 1322 /* 1323 * The next field is for VFS *only*. No filesystems have any business 1324 * even looking at it. You had been warned. 1325 */ 1326 struct mutex s_vfs_rename_mutex; /* Kludge */ 1327 1328 /* 1329 * Filesystem subtype. If non-empty the filesystem type field 1330 * in /proc/mounts will be "type.subtype" 1331 */ 1332 char *s_subtype; 1333 1334 /* 1335 * Saved mount options for lazy filesystems using 1336 * generic_show_options() 1337 */ 1338 char __rcu *s_options; 1339 const struct dentry_operations *s_d_op; /* default d_op for dentries */ 1340 1341 /* 1342 * Saved pool identifier for cleancache (-1 means none) 1343 */ 1344 int cleancache_poolid; 1345 1346 struct shrinker s_shrink; /* per-sb shrinker handle */ 1347 1348 /* Number of inodes with nlink == 0 but still referenced */ 1349 atomic_long_t s_remove_count; 1350 1351 /* Being remounted read-only */ 1352 int s_readonly_remount; 1353 1354 /* AIO completions deferred from interrupt context */ 1355 struct workqueue_struct *s_dio_done_wq; 1356 struct hlist_head s_pins; 1357 1358 /* 1359 * Keep the lru lists last in the structure so they always sit on their 1360 * own individual cachelines. 1361 */ 1362 struct list_lru s_dentry_lru ____cacheline_aligned_in_smp; 1363 struct list_lru s_inode_lru ____cacheline_aligned_in_smp; 1364 struct rcu_head rcu; 1365 1366 /* 1367 * Indicates how deep in a filesystem stack this SB is 1368 */ 1369 int s_stack_depth; 1370}; 1371 1372extern struct timespec current_fs_time(struct super_block *sb); 1373 1374/* 1375 * Snapshotting support. 1376 */ 1377 1378void __sb_end_write(struct super_block *sb, int level); 1379int __sb_start_write(struct super_block *sb, int level, bool wait); 1380 1381/** 1382 * sb_end_write - drop write access to a superblock 1383 * @sb: the super we wrote to 1384 * 1385 * Decrement number of writers to the filesystem. Wake up possible waiters 1386 * wanting to freeze the filesystem. 1387 */ 1388static inline void sb_end_write(struct super_block *sb) 1389{ 1390 __sb_end_write(sb, SB_FREEZE_WRITE); 1391} 1392 1393/** 1394 * sb_end_pagefault - drop write access to a superblock from a page fault 1395 * @sb: the super we wrote to 1396 * 1397 * Decrement number of processes handling write page fault to the filesystem. 1398 * Wake up possible waiters wanting to freeze the filesystem. 1399 */ 1400static inline void sb_end_pagefault(struct super_block *sb) 1401{ 1402 __sb_end_write(sb, SB_FREEZE_PAGEFAULT); 1403} 1404 1405/** 1406 * sb_end_intwrite - drop write access to a superblock for internal fs purposes 1407 * @sb: the super we wrote to 1408 * 1409 * Decrement fs-internal number of writers to the filesystem. Wake up possible 1410 * waiters wanting to freeze the filesystem. 1411 */ 1412static inline void sb_end_intwrite(struct super_block *sb) 1413{ 1414 __sb_end_write(sb, SB_FREEZE_FS); 1415} 1416 1417/** 1418 * sb_start_write - get write access to a superblock 1419 * @sb: the super we write to 1420 * 1421 * When a process wants to write data or metadata to a file system (i.e. dirty 1422 * a page or an inode), it should embed the operation in a sb_start_write() - 1423 * sb_end_write() pair to get exclusion against file system freezing. This 1424 * function increments number of writers preventing freezing. If the file 1425 * system is already frozen, the function waits until the file system is 1426 * thawed. 1427 * 1428 * Since freeze protection behaves as a lock, users have to preserve 1429 * ordering of freeze protection and other filesystem locks. Generally, 1430 * freeze protection should be the outermost lock. In particular, we have: 1431 * 1432 * sb_start_write 1433 * -> i_mutex (write path, truncate, directory ops, ...) 1434 * -> s_umount (freeze_super, thaw_super) 1435 */ 1436static inline void sb_start_write(struct super_block *sb) 1437{ 1438 __sb_start_write(sb, SB_FREEZE_WRITE, true); 1439} 1440 1441static inline int sb_start_write_trylock(struct super_block *sb) 1442{ 1443 return __sb_start_write(sb, SB_FREEZE_WRITE, false); 1444} 1445 1446/** 1447 * sb_start_pagefault - get write access to a superblock from a page fault 1448 * @sb: the super we write to 1449 * 1450 * When a process starts handling write page fault, it should embed the 1451 * operation into sb_start_pagefault() - sb_end_pagefault() pair to get 1452 * exclusion against file system freezing. This is needed since the page fault 1453 * is going to dirty a page. This function increments number of running page 1454 * faults preventing freezing. If the file system is already frozen, the 1455 * function waits until the file system is thawed. 1456 * 1457 * Since page fault freeze protection behaves as a lock, users have to preserve 1458 * ordering of freeze protection and other filesystem locks. It is advised to 1459 * put sb_start_pagefault() close to mmap_sem in lock ordering. Page fault 1460 * handling code implies lock dependency: 1461 * 1462 * mmap_sem 1463 * -> sb_start_pagefault 1464 */ 1465static inline void sb_start_pagefault(struct super_block *sb) 1466{ 1467 __sb_start_write(sb, SB_FREEZE_PAGEFAULT, true); 1468} 1469 1470/* 1471 * sb_start_intwrite - get write access to a superblock for internal fs purposes 1472 * @sb: the super we write to 1473 * 1474 * This is the third level of protection against filesystem freezing. It is 1475 * free for use by a filesystem. The only requirement is that it must rank 1476 * below sb_start_pagefault. 1477 * 1478 * For example filesystem can call sb_start_intwrite() when starting a 1479 * transaction which somewhat eases handling of freezing for internal sources 1480 * of filesystem changes (internal fs threads, discarding preallocation on file 1481 * close, etc.). 1482 */ 1483static inline void sb_start_intwrite(struct super_block *sb) 1484{ 1485 __sb_start_write(sb, SB_FREEZE_FS, true); 1486} 1487 1488 1489extern bool inode_owner_or_capable(const struct inode *inode); 1490 1491/* 1492 * VFS helper functions.. 1493 */ 1494extern int vfs_create(struct inode *, struct dentry *, umode_t, bool); 1495extern int vfs_mkdir(struct inode *, struct dentry *, umode_t); 1496extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t); 1497extern int vfs_symlink(struct inode *, struct dentry *, const char *); 1498extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **); 1499extern int vfs_rmdir(struct inode *, struct dentry *); 1500extern int vfs_unlink(struct inode *, struct dentry *, struct inode **); 1501extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int); 1502extern int vfs_whiteout(struct inode *, struct dentry *); 1503 1504/* 1505 * VFS dentry helper functions. 1506 */ 1507extern void dentry_unhash(struct dentry *dentry); 1508 1509/* 1510 * VFS file helper functions. 1511 */ 1512extern void inode_init_owner(struct inode *inode, const struct inode *dir, 1513 umode_t mode); 1514/* 1515 * VFS FS_IOC_FIEMAP helper definitions. 1516 */ 1517struct fiemap_extent_info { 1518 unsigned int fi_flags; /* Flags as passed from user */ 1519 unsigned int fi_extents_mapped; /* Number of mapped extents */ 1520 unsigned int fi_extents_max; /* Size of fiemap_extent array */ 1521 struct fiemap_extent __user *fi_extents_start; /* Start of 1522 fiemap_extent array */ 1523}; 1524int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical, 1525 u64 phys, u64 len, u32 flags); 1526int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags); 1527 1528/* 1529 * File types 1530 * 1531 * NOTE! These match bits 12..15 of stat.st_mode 1532 * (ie "(i_mode >> 12) & 15"). 1533 */ 1534#define DT_UNKNOWN 0 1535#define DT_FIFO 1 1536#define DT_CHR 2 1537#define DT_DIR 4 1538#define DT_BLK 6 1539#define DT_REG 8 1540#define DT_LNK 10 1541#define DT_SOCK 12 1542#define DT_WHT 14 1543 1544/* 1545 * This is the "filldir" function type, used by readdir() to let 1546 * the kernel specify what kind of dirent layout it wants to have. 1547 * This allows the kernel to read directories into kernel space or 1548 * to have different dirent layouts depending on the binary type. 1549 */ 1550struct dir_context; 1551typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, 1552 unsigned); 1553 1554struct dir_context { 1555 const filldir_t actor; 1556 loff_t pos; 1557}; 1558 1559struct block_device_operations; 1560 1561/* These macros are for out of kernel modules to test that 1562 * the kernel supports the unlocked_ioctl and compat_ioctl 1563 * fields in struct file_operations. */ 1564#define HAVE_COMPAT_IOCTL 1 1565#define HAVE_UNLOCKED_IOCTL 1 1566 1567/* 1568 * These flags let !MMU mmap() govern direct device mapping vs immediate 1569 * copying more easily for MAP_PRIVATE, especially for ROM filesystems. 1570 * 1571 * NOMMU_MAP_COPY: Copy can be mapped (MAP_PRIVATE) 1572 * NOMMU_MAP_DIRECT: Can be mapped directly (MAP_SHARED) 1573 * NOMMU_MAP_READ: Can be mapped for reading 1574 * NOMMU_MAP_WRITE: Can be mapped for writing 1575 * NOMMU_MAP_EXEC: Can be mapped for execution 1576 */ 1577#define NOMMU_MAP_COPY 0x00000001 1578#define NOMMU_MAP_DIRECT 0x00000008 1579#define NOMMU_MAP_READ VM_MAYREAD 1580#define NOMMU_MAP_WRITE VM_MAYWRITE 1581#define NOMMU_MAP_EXEC VM_MAYEXEC 1582 1583#define NOMMU_VMFLAGS \ 1584 (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC) 1585 1586 1587struct iov_iter; 1588 1589struct file_operations { 1590 struct module *owner; 1591 loff_t (*llseek) (struct file *, loff_t, int); 1592 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); 1593 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); 1594 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *); 1595 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 1596 int (*iterate) (struct file *, struct dir_context *); 1597 unsigned int (*poll) (struct file *, struct poll_table_struct *); 1598 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 1599 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 1600 int (*mmap) (struct file *, struct vm_area_struct *); 1601 int (*mremap)(struct file *, struct vm_area_struct *); 1602 int (*open) (struct inode *, struct file *); 1603 int (*flush) (struct file *, fl_owner_t id); 1604 int (*release) (struct inode *, struct file *); 1605 int (*fsync) (struct file *, loff_t, loff_t, int datasync); 1606 int (*aio_fsync) (struct kiocb *, int datasync); 1607 int (*fasync) (int, struct file *, int); 1608 int (*lock) (struct file *, int, struct file_lock *); 1609 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); 1610 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); 1611 int (*check_flags)(int); 1612 int (*flock) (struct file *, int, struct file_lock *); 1613 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); 1614 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); 1615 int (*setlease)(struct file *, long, struct file_lock **, void **); 1616 long (*fallocate)(struct file *file, int mode, loff_t offset, 1617 loff_t len); 1618 void (*show_fdinfo)(struct seq_file *m, struct file *f); 1619#ifndef CONFIG_MMU 1620 unsigned (*mmap_capabilities)(struct file *); 1621#endif 1622}; 1623 1624struct inode_operations { 1625 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int); 1626 void * (*follow_link) (struct dentry *, struct nameidata *); 1627 int (*permission) (struct inode *, int); 1628 struct posix_acl * (*get_acl)(struct inode *, int); 1629 1630 int (*readlink) (struct dentry *, char __user *,int); 1631 void (*put_link) (struct dentry *, struct nameidata *, void *); 1632 1633 int (*create) (struct inode *,struct dentry *, umode_t, bool); 1634 int (*link) (struct dentry *,struct inode *,struct dentry *); 1635 int (*unlink) (struct inode *,struct dentry *); 1636 int (*symlink) (struct inode *,struct dentry *,const char *); 1637 int (*mkdir) (struct inode *,struct dentry *,umode_t); 1638 int (*rmdir) (struct inode *,struct dentry *); 1639 int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t); 1640 int (*rename) (struct inode *, struct dentry *, 1641 struct inode *, struct dentry *); 1642 int (*rename2) (struct inode *, struct dentry *, 1643 struct inode *, struct dentry *, unsigned int); 1644 int (*setattr) (struct dentry *, struct iattr *); 1645 int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *); 1646 int (*setxattr) (struct dentry *, const char *,const void *,size_t,int); 1647 ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t); 1648 ssize_t (*listxattr) (struct dentry *, char *, size_t); 1649 int (*removexattr) (struct dentry *, const char *); 1650 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 1651 u64 len); 1652 int (*update_time)(struct inode *, struct timespec *, int); 1653 int (*atomic_open)(struct inode *, struct dentry *, 1654 struct file *, unsigned open_flag, 1655 umode_t create_mode, int *opened); 1656 int (*tmpfile) (struct inode *, struct dentry *, umode_t); 1657 int (*set_acl)(struct inode *, struct posix_acl *, int); 1658 1659 /* WARNING: probably going away soon, do not use! */ 1660} ____cacheline_aligned; 1661 1662ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector, 1663 unsigned long nr_segs, unsigned long fast_segs, 1664 struct iovec *fast_pointer, 1665 struct iovec **ret_pointer); 1666 1667extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *); 1668extern ssize_t __vfs_write(struct file *, const char __user *, size_t, loff_t *); 1669extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *); 1670extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *); 1671extern ssize_t vfs_readv(struct file *, const struct iovec __user *, 1672 unsigned long, loff_t *); 1673extern ssize_t vfs_writev(struct file *, const struct iovec __user *, 1674 unsigned long, loff_t *); 1675 1676struct super_operations { 1677 struct inode *(*alloc_inode)(struct super_block *sb); 1678 void (*destroy_inode)(struct inode *); 1679 1680 void (*dirty_inode) (struct inode *, int flags); 1681 int (*write_inode) (struct inode *, struct writeback_control *wbc); 1682 int (*drop_inode) (struct inode *); 1683 void (*evict_inode) (struct inode *); 1684 void (*put_super) (struct super_block *); 1685 int (*sync_fs)(struct super_block *sb, int wait); 1686 int (*freeze_super) (struct super_block *); 1687 int (*freeze_fs) (struct super_block *); 1688 int (*thaw_super) (struct super_block *); 1689 int (*unfreeze_fs) (struct super_block *); 1690 int (*statfs) (struct dentry *, struct kstatfs *); 1691 int (*remount_fs) (struct super_block *, int *, char *); 1692 void (*umount_begin) (struct super_block *); 1693 1694 int (*show_options)(struct seq_file *, struct dentry *); 1695 int (*show_devname)(struct seq_file *, struct dentry *); 1696 int (*show_path)(struct seq_file *, struct dentry *); 1697 int (*show_stats)(struct seq_file *, struct dentry *); 1698#ifdef CONFIG_QUOTA 1699 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); 1700 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t); 1701 struct dquot **(*get_dquots)(struct inode *); 1702#endif 1703 int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t); 1704 long (*nr_cached_objects)(struct super_block *, 1705 struct shrink_control *); 1706 long (*free_cached_objects)(struct super_block *, 1707 struct shrink_control *); 1708}; 1709 1710/* 1711 * Inode flags - they have no relation to superblock flags now 1712 */ 1713#define S_SYNC 1 /* Writes are synced at once */ 1714#define S_NOATIME 2 /* Do not update access times */ 1715#define S_APPEND 4 /* Append-only file */ 1716#define S_IMMUTABLE 8 /* Immutable file */ 1717#define S_DEAD 16 /* removed, but still open directory */ 1718#define S_NOQUOTA 32 /* Inode is not counted to quota */ 1719#define S_DIRSYNC 64 /* Directory modifications are synchronous */ 1720#define S_NOCMTIME 128 /* Do not update file c/mtime */ 1721#define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */ 1722#define S_PRIVATE 512 /* Inode is fs-internal */ 1723#define S_IMA 1024 /* Inode has an associated IMA struct */ 1724#define S_AUTOMOUNT 2048 /* Automount/referral quasi-directory */ 1725#define S_NOSEC 4096 /* no suid or xattr security attributes */ 1726#ifdef CONFIG_FS_DAX 1727#define S_DAX 8192 /* Direct Access, avoiding the page cache */ 1728#else 1729#define S_DAX 0 /* Make all the DAX code disappear */ 1730#endif 1731 1732/* 1733 * Note that nosuid etc flags are inode-specific: setting some file-system 1734 * flags just means all the inodes inherit those flags by default. It might be 1735 * possible to override it selectively if you really wanted to with some 1736 * ioctl() that is not currently implemented. 1737 * 1738 * Exception: MS_RDONLY is always applied to the entire file system. 1739 * 1740 * Unfortunately, it is possible to change a filesystems flags with it mounted 1741 * with files in use. This means that all of the inodes will not have their 1742 * i_flags updated. Hence, i_flags no longer inherit the superblock mount 1743 * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org 1744 */ 1745#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg)) 1746 1747#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY) 1748#define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || \ 1749 ((inode)->i_flags & S_SYNC)) 1750#define IS_DIRSYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \ 1751 ((inode)->i_flags & (S_SYNC|S_DIRSYNC))) 1752#define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK) 1753#define IS_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME) 1754#define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION) 1755 1756#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA) 1757#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND) 1758#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE) 1759#define IS_POSIXACL(inode) __IS_FLG(inode, MS_POSIXACL) 1760 1761#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD) 1762#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME) 1763#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE) 1764#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE) 1765#define IS_IMA(inode) ((inode)->i_flags & S_IMA) 1766#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT) 1767#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC) 1768#define IS_DAX(inode) ((inode)->i_flags & S_DAX) 1769 1770#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \ 1771 (inode)->i_rdev == WHITEOUT_DEV) 1772 1773/* 1774 * Inode state bits. Protected by inode->i_lock 1775 * 1776 * Three bits determine the dirty state of the inode, I_DIRTY_SYNC, 1777 * I_DIRTY_DATASYNC and I_DIRTY_PAGES. 1778 * 1779 * Four bits define the lifetime of an inode. Initially, inodes are I_NEW, 1780 * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at 1781 * various stages of removing an inode. 1782 * 1783 * Two bits are used for locking and completion notification, I_NEW and I_SYNC. 1784 * 1785 * I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on 1786 * fdatasync(). i_atime is the usual cause. 1787 * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of 1788 * these changes separately from I_DIRTY_SYNC so that we 1789 * don't have to write inode on fdatasync() when only 1790 * mtime has changed in it. 1791 * I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean. 1792 * I_NEW Serves as both a mutex and completion notification. 1793 * New inodes set I_NEW. If two processes both create 1794 * the same inode, one of them will release its inode and 1795 * wait for I_NEW to be released before returning. 1796 * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can 1797 * also cause waiting on I_NEW, without I_NEW actually 1798 * being set. find_inode() uses this to prevent returning 1799 * nearly-dead inodes. 1800 * I_WILL_FREE Must be set when calling write_inode_now() if i_count 1801 * is zero. I_FREEING must be set when I_WILL_FREE is 1802 * cleared. 1803 * I_FREEING Set when inode is about to be freed but still has dirty 1804 * pages or buffers attached or the inode itself is still 1805 * dirty. 1806 * I_CLEAR Added by clear_inode(). In this state the inode is 1807 * clean and can be destroyed. Inode keeps I_FREEING. 1808 * 1809 * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are 1810 * prohibited for many purposes. iget() must wait for 1811 * the inode to be completely released, then create it 1812 * anew. Other functions will just ignore such inodes, 1813 * if appropriate. I_NEW is used for waiting. 1814 * 1815 * I_SYNC Writeback of inode is running. The bit is set during 1816 * data writeback, and cleared with a wakeup on the bit 1817 * address once it is done. The bit is also used to pin 1818 * the inode in memory for flusher thread. 1819 * 1820 * I_REFERENCED Marks the inode as recently references on the LRU list. 1821 * 1822 * I_DIO_WAKEUP Never set. Only used as a key for wait_on_bit(). 1823 * 1824 * Q: What is the difference between I_WILL_FREE and I_FREEING? 1825 */ 1826#define I_DIRTY_SYNC (1 << 0) 1827#define I_DIRTY_DATASYNC (1 << 1) 1828#define I_DIRTY_PAGES (1 << 2) 1829#define __I_NEW 3 1830#define I_NEW (1 << __I_NEW) 1831#define I_WILL_FREE (1 << 4) 1832#define I_FREEING (1 << 5) 1833#define I_CLEAR (1 << 6) 1834#define __I_SYNC 7 1835#define I_SYNC (1 << __I_SYNC) 1836#define I_REFERENCED (1 << 8) 1837#define __I_DIO_WAKEUP 9 1838#define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP) 1839#define I_LINKABLE (1 << 10) 1840#define I_DIRTY_TIME (1 << 11) 1841#define __I_DIRTY_TIME_EXPIRED 12 1842#define I_DIRTY_TIME_EXPIRED (1 << __I_DIRTY_TIME_EXPIRED) 1843 1844#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES) 1845#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME) 1846 1847extern void __mark_inode_dirty(struct inode *, int); 1848static inline void mark_inode_dirty(struct inode *inode) 1849{ 1850 __mark_inode_dirty(inode, I_DIRTY); 1851} 1852 1853static inline void mark_inode_dirty_sync(struct inode *inode) 1854{ 1855 __mark_inode_dirty(inode, I_DIRTY_SYNC); 1856} 1857 1858extern void inc_nlink(struct inode *inode); 1859extern void drop_nlink(struct inode *inode); 1860extern void clear_nlink(struct inode *inode); 1861extern void set_nlink(struct inode *inode, unsigned int nlink); 1862 1863static inline void inode_inc_link_count(struct inode *inode) 1864{ 1865 inc_nlink(inode); 1866 mark_inode_dirty(inode); 1867} 1868 1869static inline void inode_dec_link_count(struct inode *inode) 1870{ 1871 drop_nlink(inode); 1872 mark_inode_dirty(inode); 1873} 1874 1875/** 1876 * inode_inc_iversion - increments i_version 1877 * @inode: inode that need to be updated 1878 * 1879 * Every time the inode is modified, the i_version field will be incremented. 1880 * The filesystem has to be mounted with i_version flag 1881 */ 1882 1883static inline void inode_inc_iversion(struct inode *inode) 1884{ 1885 spin_lock(&inode->i_lock); 1886 inode->i_version++; 1887 spin_unlock(&inode->i_lock); 1888} 1889 1890enum file_time_flags { 1891 S_ATIME = 1, 1892 S_MTIME = 2, 1893 S_CTIME = 4, 1894 S_VERSION = 8, 1895}; 1896 1897extern void touch_atime(const struct path *); 1898static inline void file_accessed(struct file *file) 1899{ 1900 if (!(file->f_flags & O_NOATIME)) 1901 touch_atime(&file->f_path); 1902} 1903 1904int sync_inode(struct inode *inode, struct writeback_control *wbc); 1905int sync_inode_metadata(struct inode *inode, int wait); 1906 1907struct file_system_type { 1908 const char *name; 1909 int fs_flags; 1910#define FS_REQUIRES_DEV 1 1911#define FS_BINARY_MOUNTDATA 2 1912#define FS_HAS_SUBTYPE 4 1913#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */ 1914#define FS_USERNS_DEV_MOUNT 16 /* A userns mount does not imply MNT_NODEV */ 1915#define FS_USERNS_VISIBLE 32 /* FS must already be visible */ 1916#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */ 1917 struct dentry *(*mount) (struct file_system_type *, int, 1918 const char *, void *); 1919 void (*kill_sb) (struct super_block *); 1920 struct module *owner; 1921 struct file_system_type * next; 1922 struct hlist_head fs_supers; 1923 1924 struct lock_class_key s_lock_key; 1925 struct lock_class_key s_umount_key; 1926 struct lock_class_key s_vfs_rename_key; 1927 struct lock_class_key s_writers_key[SB_FREEZE_LEVELS]; 1928 1929 struct lock_class_key i_lock_key; 1930 struct lock_class_key i_mutex_key; 1931 struct lock_class_key i_mutex_dir_key; 1932}; 1933 1934#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME) 1935 1936extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags, 1937 void *data, int (*fill_super)(struct super_block *, void *, int)); 1938extern struct dentry *mount_bdev(struct file_system_type *fs_type, 1939 int flags, const char *dev_name, void *data, 1940 int (*fill_super)(struct super_block *, void *, int)); 1941extern struct dentry *mount_single(struct file_system_type *fs_type, 1942 int flags, void *data, 1943 int (*fill_super)(struct super_block *, void *, int)); 1944extern struct dentry *mount_nodev(struct file_system_type *fs_type, 1945 int flags, void *data, 1946 int (*fill_super)(struct super_block *, void *, int)); 1947extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path); 1948void generic_shutdown_super(struct super_block *sb); 1949void kill_block_super(struct super_block *sb); 1950void kill_anon_super(struct super_block *sb); 1951void kill_litter_super(struct super_block *sb); 1952void deactivate_super(struct super_block *sb); 1953void deactivate_locked_super(struct super_block *sb); 1954int set_anon_super(struct super_block *s, void *data); 1955int get_anon_bdev(dev_t *); 1956void free_anon_bdev(dev_t); 1957struct super_block *sget(struct file_system_type *type, 1958 int (*test)(struct super_block *,void *), 1959 int (*set)(struct super_block *,void *), 1960 int flags, void *data); 1961extern struct dentry *mount_pseudo(struct file_system_type *, char *, 1962 const struct super_operations *ops, 1963 const struct dentry_operations *dops, 1964 unsigned long); 1965 1966/* Alas, no aliases. Too much hassle with bringing module.h everywhere */ 1967#define fops_get(fops) \ 1968 (((fops) && try_module_get((fops)->owner) ? (fops) : NULL)) 1969#define fops_put(fops) \ 1970 do { if (fops) module_put((fops)->owner); } while(0) 1971/* 1972 * This one is to be used *ONLY* from ->open() instances. 1973 * fops must be non-NULL, pinned down *and* module dependencies 1974 * should be sufficient to pin the caller down as well. 1975 */ 1976#define replace_fops(f, fops) \ 1977 do { \ 1978 struct file *__file = (f); \ 1979 fops_put(__file->f_op); \ 1980 BUG_ON(!(__file->f_op = (fops))); \ 1981 } while(0) 1982 1983extern int register_filesystem(struct file_system_type *); 1984extern int unregister_filesystem(struct file_system_type *); 1985extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data); 1986#define kern_mount(type) kern_mount_data(type, NULL) 1987extern void kern_unmount(struct vfsmount *mnt); 1988extern int may_umount_tree(struct vfsmount *); 1989extern int may_umount(struct vfsmount *); 1990extern long do_mount(const char *, const char __user *, 1991 const char *, unsigned long, void *); 1992extern struct vfsmount *collect_mounts(struct path *); 1993extern void drop_collected_mounts(struct vfsmount *); 1994extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *, 1995 struct vfsmount *); 1996extern int vfs_statfs(struct path *, struct kstatfs *); 1997extern int user_statfs(const char __user *, struct kstatfs *); 1998extern int fd_statfs(int, struct kstatfs *); 1999extern int vfs_ustat(dev_t, struct kstatfs *); 2000extern int freeze_super(struct super_block *super); 2001extern int thaw_super(struct super_block *super); 2002extern bool our_mnt(struct vfsmount *mnt); 2003 2004extern int current_umask(void); 2005 2006extern void ihold(struct inode * inode); 2007extern void iput(struct inode *); 2008extern int generic_update_time(struct inode *, struct timespec *, int); 2009 2010/* /sys/fs */ 2011extern struct kobject *fs_kobj; 2012 2013#define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK) 2014 2015#define FLOCK_VERIFY_READ 1 2016#define FLOCK_VERIFY_WRITE 2 2017 2018#ifdef CONFIG_FILE_LOCKING 2019extern int locks_mandatory_locked(struct file *); 2020extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t); 2021 2022/* 2023 * Candidates for mandatory locking have the setgid bit set 2024 * but no group execute bit - an otherwise meaningless combination. 2025 */ 2026 2027static inline int __mandatory_lock(struct inode *ino) 2028{ 2029 return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID; 2030} 2031 2032/* 2033 * ... and these candidates should be on MS_MANDLOCK mounted fs, 2034 * otherwise these will be advisory locks 2035 */ 2036 2037static inline int mandatory_lock(struct inode *ino) 2038{ 2039 return IS_MANDLOCK(ino) && __mandatory_lock(ino); 2040} 2041 2042static inline int locks_verify_locked(struct file *file) 2043{ 2044 if (mandatory_lock(file_inode(file))) 2045 return locks_mandatory_locked(file); 2046 return 0; 2047} 2048 2049static inline int locks_verify_truncate(struct inode *inode, 2050 struct file *filp, 2051 loff_t size) 2052{ 2053 if (inode->i_flctx && mandatory_lock(inode)) 2054 return locks_mandatory_area( 2055 FLOCK_VERIFY_WRITE, inode, filp, 2056 size < inode->i_size ? size : inode->i_size, 2057 (size < inode->i_size ? inode->i_size - size 2058 : size - inode->i_size) 2059 ); 2060 return 0; 2061} 2062 2063static inline int break_lease(struct inode *inode, unsigned int mode) 2064{ 2065 /* 2066 * Since this check is lockless, we must ensure that any refcounts 2067 * taken are done before checking i_flctx->flc_lease. Otherwise, we 2068 * could end up racing with tasks trying to set a new lease on this 2069 * file. 2070 */ 2071 smp_mb(); 2072 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) 2073 return __break_lease(inode, mode, FL_LEASE); 2074 return 0; 2075} 2076 2077static inline int break_deleg(struct inode *inode, unsigned int mode) 2078{ 2079 /* 2080 * Since this check is lockless, we must ensure that any refcounts 2081 * taken are done before checking i_flctx->flc_lease. Otherwise, we 2082 * could end up racing with tasks trying to set a new lease on this 2083 * file. 2084 */ 2085 smp_mb(); 2086 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) 2087 return __break_lease(inode, mode, FL_DELEG); 2088 return 0; 2089} 2090 2091static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) 2092{ 2093 int ret; 2094 2095 ret = break_deleg(inode, O_WRONLY|O_NONBLOCK); 2096 if (ret == -EWOULDBLOCK && delegated_inode) { 2097 *delegated_inode = inode; 2098 ihold(inode); 2099 } 2100 return ret; 2101} 2102 2103static inline int break_deleg_wait(struct inode **delegated_inode) 2104{ 2105 int ret; 2106 2107 ret = break_deleg(*delegated_inode, O_WRONLY); 2108 iput(*delegated_inode); 2109 *delegated_inode = NULL; 2110 return ret; 2111} 2112 2113static inline int break_layout(struct inode *inode, bool wait) 2114{ 2115 smp_mb(); 2116 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) 2117 return __break_lease(inode, 2118 wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, 2119 FL_LAYOUT); 2120 return 0; 2121} 2122 2123#else /* !CONFIG_FILE_LOCKING */ 2124static inline int locks_mandatory_locked(struct file *file) 2125{ 2126 return 0; 2127} 2128 2129static inline int locks_mandatory_area(int rw, struct inode *inode, 2130 struct file *filp, loff_t offset, 2131 size_t count) 2132{ 2133 return 0; 2134} 2135 2136static inline int __mandatory_lock(struct inode *inode) 2137{ 2138 return 0; 2139} 2140 2141static inline int mandatory_lock(struct inode *inode) 2142{ 2143 return 0; 2144} 2145 2146static inline int locks_verify_locked(struct file *file) 2147{ 2148 return 0; 2149} 2150 2151static inline int locks_verify_truncate(struct inode *inode, struct file *filp, 2152 size_t size) 2153{ 2154 return 0; 2155} 2156 2157static inline int break_lease(struct inode *inode, unsigned int mode) 2158{ 2159 return 0; 2160} 2161 2162static inline int break_deleg(struct inode *inode, unsigned int mode) 2163{ 2164 return 0; 2165} 2166 2167static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) 2168{ 2169 return 0; 2170} 2171 2172static inline int break_deleg_wait(struct inode **delegated_inode) 2173{ 2174 BUG(); 2175 return 0; 2176} 2177 2178static inline int break_layout(struct inode *inode, bool wait) 2179{ 2180 return 0; 2181} 2182 2183#endif /* CONFIG_FILE_LOCKING */ 2184 2185/* fs/open.c */ 2186struct audit_names; 2187struct filename { 2188 const char *name; /* pointer to actual string */ 2189 const __user char *uptr; /* original userland pointer */ 2190 struct audit_names *aname; 2191 int refcnt; 2192 const char iname[]; 2193}; 2194 2195extern long vfs_truncate(struct path *, loff_t); 2196extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs, 2197 struct file *filp); 2198extern int vfs_fallocate(struct file *file, int mode, loff_t offset, 2199 loff_t len); 2200extern long do_sys_open(int dfd, const char __user *filename, int flags, 2201 umode_t mode); 2202extern struct file *file_open_name(struct filename *, int, umode_t); 2203extern struct file *filp_open(const char *, int, umode_t); 2204extern struct file *file_open_root(struct dentry *, struct vfsmount *, 2205 const char *, int, umode_t); 2206extern struct file * dentry_open(const struct path *, int, const struct cred *); 2207extern int filp_close(struct file *, fl_owner_t id); 2208 2209extern struct filename *getname_flags(const char __user *, int, int *); 2210extern struct filename *getname(const char __user *); 2211extern struct filename *getname_kernel(const char *); 2212extern void putname(struct filename *name); 2213 2214enum { 2215 FILE_CREATED = 1, 2216 FILE_OPENED = 2 2217}; 2218extern int finish_open(struct file *file, struct dentry *dentry, 2219 int (*open)(struct inode *, struct file *), 2220 int *opened); 2221extern int finish_no_open(struct file *file, struct dentry *dentry); 2222 2223/* fs/ioctl.c */ 2224 2225extern int ioctl_preallocate(struct file *filp, void __user *argp); 2226 2227/* fs/dcache.c */ 2228extern void __init vfs_caches_init_early(void); 2229extern void __init vfs_caches_init(unsigned long); 2230 2231extern struct kmem_cache *names_cachep; 2232 2233#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL) 2234#define __putname(name) kmem_cache_free(names_cachep, (void *)(name)) 2235 2236#ifdef CONFIG_BLOCK 2237extern int register_blkdev(unsigned int, const char *); 2238extern void unregister_blkdev(unsigned int, const char *); 2239extern struct block_device *bdget(dev_t); 2240extern struct block_device *bdgrab(struct block_device *bdev); 2241extern void bd_set_size(struct block_device *, loff_t size); 2242extern void bd_forget(struct inode *inode); 2243extern void bdput(struct block_device *); 2244extern void invalidate_bdev(struct block_device *); 2245extern void iterate_bdevs(void (*)(struct block_device *, void *), void *); 2246extern int sync_blockdev(struct block_device *bdev); 2247extern void kill_bdev(struct block_device *); 2248extern struct super_block *freeze_bdev(struct block_device *); 2249extern void emergency_thaw_all(void); 2250extern int thaw_bdev(struct block_device *bdev, struct super_block *sb); 2251extern int fsync_bdev(struct block_device *); 2252extern int sb_is_blkdev_sb(struct super_block *sb); 2253#else 2254static inline void bd_forget(struct inode *inode) {} 2255static inline int sync_blockdev(struct block_device *bdev) { return 0; } 2256static inline void kill_bdev(struct block_device *bdev) {} 2257static inline void invalidate_bdev(struct block_device *bdev) {} 2258 2259static inline struct super_block *freeze_bdev(struct block_device *sb) 2260{ 2261 return NULL; 2262} 2263 2264static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb) 2265{ 2266 return 0; 2267} 2268 2269static inline void iterate_bdevs(void (*f)(struct block_device *, void *), void *arg) 2270{ 2271} 2272 2273static inline int sb_is_blkdev_sb(struct super_block *sb) 2274{ 2275 return 0; 2276} 2277#endif 2278extern int sync_filesystem(struct super_block *); 2279extern const struct file_operations def_blk_fops; 2280extern const struct file_operations def_chr_fops; 2281#ifdef CONFIG_BLOCK 2282extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long); 2283extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long); 2284extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long); 2285extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder); 2286extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode, 2287 void *holder); 2288extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, 2289 void *holder); 2290extern void blkdev_put(struct block_device *bdev, fmode_t mode); 2291#ifdef CONFIG_SYSFS 2292extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk); 2293extern void bd_unlink_disk_holder(struct block_device *bdev, 2294 struct gendisk *disk); 2295#else 2296static inline int bd_link_disk_holder(struct block_device *bdev, 2297 struct gendisk *disk) 2298{ 2299 return 0; 2300} 2301static inline void bd_unlink_disk_holder(struct block_device *bdev, 2302 struct gendisk *disk) 2303{ 2304} 2305#endif 2306#endif 2307 2308/* fs/char_dev.c */ 2309#define CHRDEV_MAJOR_HASH_SIZE 255 2310extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *); 2311extern int register_chrdev_region(dev_t, unsigned, const char *); 2312extern int __register_chrdev(unsigned int major, unsigned int baseminor, 2313 unsigned int count, const char *name, 2314 const struct file_operations *fops); 2315extern void __unregister_chrdev(unsigned int major, unsigned int baseminor, 2316 unsigned int count, const char *name); 2317extern void unregister_chrdev_region(dev_t, unsigned); 2318extern void chrdev_show(struct seq_file *,off_t); 2319 2320static inline int register_chrdev(unsigned int major, const char *name, 2321 const struct file_operations *fops) 2322{ 2323 return __register_chrdev(major, 0, 256, name, fops); 2324} 2325 2326static inline void unregister_chrdev(unsigned int major, const char *name) 2327{ 2328 __unregister_chrdev(major, 0, 256, name); 2329} 2330 2331/* fs/block_dev.c */ 2332#define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */ 2333#define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */ 2334 2335#ifdef CONFIG_BLOCK 2336#define BLKDEV_MAJOR_HASH_SIZE 255 2337extern const char *__bdevname(dev_t, char *buffer); 2338extern const char *bdevname(struct block_device *bdev, char *buffer); 2339extern struct block_device *lookup_bdev(const char *); 2340extern void blkdev_show(struct seq_file *,off_t); 2341 2342#else 2343#define BLKDEV_MAJOR_HASH_SIZE 0 2344#endif 2345 2346extern void init_special_inode(struct inode *, umode_t, dev_t); 2347 2348/* Invalid inode operations -- fs/bad_inode.c */ 2349extern void make_bad_inode(struct inode *); 2350extern int is_bad_inode(struct inode *); 2351 2352#ifdef CONFIG_BLOCK 2353/* 2354 * return READ, READA, or WRITE 2355 */ 2356#define bio_rw(bio) ((bio)->bi_rw & (RW_MASK | RWA_MASK)) 2357 2358/* 2359 * return data direction, READ or WRITE 2360 */ 2361#define bio_data_dir(bio) ((bio)->bi_rw & 1) 2362 2363extern void check_disk_size_change(struct gendisk *disk, 2364 struct block_device *bdev); 2365extern int revalidate_disk(struct gendisk *); 2366extern int check_disk_change(struct block_device *); 2367extern int __invalidate_device(struct block_device *, bool); 2368extern int invalidate_partition(struct gendisk *, int); 2369#endif 2370unsigned long invalidate_mapping_pages(struct address_space *mapping, 2371 pgoff_t start, pgoff_t end); 2372 2373static inline void invalidate_remote_inode(struct inode *inode) 2374{ 2375 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 2376 S_ISLNK(inode->i_mode)) 2377 invalidate_mapping_pages(inode->i_mapping, 0, -1); 2378} 2379extern int invalidate_inode_pages2(struct address_space *mapping); 2380extern int invalidate_inode_pages2_range(struct address_space *mapping, 2381 pgoff_t start, pgoff_t end); 2382extern int write_inode_now(struct inode *, int); 2383extern int filemap_fdatawrite(struct address_space *); 2384extern int filemap_flush(struct address_space *); 2385extern int filemap_fdatawait(struct address_space *); 2386extern int filemap_fdatawait_range(struct address_space *, loff_t lstart, 2387 loff_t lend); 2388extern int filemap_write_and_wait(struct address_space *mapping); 2389extern int filemap_write_and_wait_range(struct address_space *mapping, 2390 loff_t lstart, loff_t lend); 2391extern int __filemap_fdatawrite_range(struct address_space *mapping, 2392 loff_t start, loff_t end, int sync_mode); 2393extern int filemap_fdatawrite_range(struct address_space *mapping, 2394 loff_t start, loff_t end); 2395 2396extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end, 2397 int datasync); 2398extern int vfs_fsync(struct file *file, int datasync); 2399static inline int generic_write_sync(struct file *file, loff_t pos, loff_t count) 2400{ 2401 if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host)) 2402 return 0; 2403 return vfs_fsync_range(file, pos, pos + count - 1, 2404 (file->f_flags & __O_SYNC) ? 0 : 1); 2405} 2406extern void emergency_sync(void); 2407extern void emergency_remount(void); 2408#ifdef CONFIG_BLOCK 2409extern sector_t bmap(struct inode *, sector_t); 2410#endif 2411extern int notify_change(struct dentry *, struct iattr *, struct inode **); 2412extern int inode_permission(struct inode *, int); 2413extern int __inode_permission(struct inode *, int); 2414extern int generic_permission(struct inode *, int); 2415extern int __check_sticky(struct inode *dir, struct inode *inode); 2416 2417static inline bool execute_ok(struct inode *inode) 2418{ 2419 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode); 2420} 2421 2422static inline void file_start_write(struct file *file) 2423{ 2424 if (!S_ISREG(file_inode(file)->i_mode)) 2425 return; 2426 __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true); 2427} 2428 2429static inline bool file_start_write_trylock(struct file *file) 2430{ 2431 if (!S_ISREG(file_inode(file)->i_mode)) 2432 return true; 2433 return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false); 2434} 2435 2436static inline void file_end_write(struct file *file) 2437{ 2438 if (!S_ISREG(file_inode(file)->i_mode)) 2439 return; 2440 __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE); 2441} 2442 2443/* 2444 * get_write_access() gets write permission for a file. 2445 * put_write_access() releases this write permission. 2446 * This is used for regular files. 2447 * We cannot support write (and maybe mmap read-write shared) accesses and 2448 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode 2449 * can have the following values: 2450 * 0: no writers, no VM_DENYWRITE mappings 2451 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist 2452 * > 0: (i_writecount) users are writing to the file. 2453 * 2454 * Normally we operate on that counter with atomic_{inc,dec} and it's safe 2455 * except for the cases where we don't hold i_writecount yet. Then we need to 2456 * use {get,deny}_write_access() - these functions check the sign and refuse 2457 * to do the change if sign is wrong. 2458 */ 2459static inline int get_write_access(struct inode *inode) 2460{ 2461 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY; 2462} 2463static inline int deny_write_access(struct file *file) 2464{ 2465 struct inode *inode = file_inode(file); 2466 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY; 2467} 2468static inline void put_write_access(struct inode * inode) 2469{ 2470 atomic_dec(&inode->i_writecount); 2471} 2472static inline void allow_write_access(struct file *file) 2473{ 2474 if (file) 2475 atomic_inc(&file_inode(file)->i_writecount); 2476} 2477static inline bool inode_is_open_for_write(const struct inode *inode) 2478{ 2479 return atomic_read(&inode->i_writecount) > 0; 2480} 2481 2482#ifdef CONFIG_IMA 2483static inline void i_readcount_dec(struct inode *inode) 2484{ 2485 BUG_ON(!atomic_read(&inode->i_readcount)); 2486 atomic_dec(&inode->i_readcount); 2487} 2488static inline void i_readcount_inc(struct inode *inode) 2489{ 2490 atomic_inc(&inode->i_readcount); 2491} 2492#else 2493static inline void i_readcount_dec(struct inode *inode) 2494{ 2495 return; 2496} 2497static inline void i_readcount_inc(struct inode *inode) 2498{ 2499 return; 2500} 2501#endif 2502extern int do_pipe_flags(int *, int); 2503 2504extern int kernel_read(struct file *, loff_t, char *, unsigned long); 2505extern ssize_t kernel_write(struct file *, const char *, size_t, loff_t); 2506extern ssize_t __kernel_write(struct file *, const char *, size_t, loff_t *); 2507extern struct file * open_exec(const char *); 2508 2509/* fs/dcache.c -- generic fs support functions */ 2510extern int is_subdir(struct dentry *, struct dentry *); 2511extern int path_is_under(struct path *, struct path *); 2512 2513#include <linux/err.h> 2514 2515/* needed for stackable file system support */ 2516extern loff_t default_llseek(struct file *file, loff_t offset, int whence); 2517 2518extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence); 2519 2520extern int inode_init_always(struct super_block *, struct inode *); 2521extern void inode_init_once(struct inode *); 2522extern void address_space_init_once(struct address_space *mapping); 2523extern struct inode * igrab(struct inode *); 2524extern ino_t iunique(struct super_block *, ino_t); 2525extern int inode_needs_sync(struct inode *inode); 2526extern int generic_delete_inode(struct inode *inode); 2527static inline int generic_drop_inode(struct inode *inode) 2528{ 2529 return !inode->i_nlink || inode_unhashed(inode); 2530} 2531 2532extern struct inode *ilookup5_nowait(struct super_block *sb, 2533 unsigned long hashval, int (*test)(struct inode *, void *), 2534 void *data); 2535extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval, 2536 int (*test)(struct inode *, void *), void *data); 2537extern struct inode *ilookup(struct super_block *sb, unsigned long ino); 2538 2539extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *); 2540extern struct inode * iget_locked(struct super_block *, unsigned long); 2541extern struct inode *find_inode_nowait(struct super_block *, 2542 unsigned long, 2543 int (*match)(struct inode *, 2544 unsigned long, void *), 2545 void *data); 2546extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *); 2547extern int insert_inode_locked(struct inode *); 2548#ifdef CONFIG_DEBUG_LOCK_ALLOC 2549extern void lockdep_annotate_inode_mutex_key(struct inode *inode); 2550#else 2551static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { }; 2552#endif 2553extern void unlock_new_inode(struct inode *); 2554extern unsigned int get_next_ino(void); 2555 2556extern void __iget(struct inode * inode); 2557extern void iget_failed(struct inode *); 2558extern void clear_inode(struct inode *); 2559extern void __destroy_inode(struct inode *); 2560extern struct inode *new_inode_pseudo(struct super_block *sb); 2561extern struct inode *new_inode(struct super_block *sb); 2562extern void free_inode_nonrcu(struct inode *inode); 2563extern int should_remove_suid(struct dentry *); 2564extern int file_remove_suid(struct file *); 2565 2566extern void __insert_inode_hash(struct inode *, unsigned long hashval); 2567static inline void insert_inode_hash(struct inode *inode) 2568{ 2569 __insert_inode_hash(inode, inode->i_ino); 2570} 2571 2572extern void __remove_inode_hash(struct inode *); 2573static inline void remove_inode_hash(struct inode *inode) 2574{ 2575 if (!inode_unhashed(inode)) 2576 __remove_inode_hash(inode); 2577} 2578 2579extern void inode_sb_list_add(struct inode *inode); 2580 2581#ifdef CONFIG_BLOCK 2582extern void submit_bio(int, struct bio *); 2583extern int bdev_read_only(struct block_device *); 2584#endif 2585extern int set_blocksize(struct block_device *, int); 2586extern int sb_set_blocksize(struct super_block *, int); 2587extern int sb_min_blocksize(struct super_block *, int); 2588 2589extern int generic_file_mmap(struct file *, struct vm_area_struct *); 2590extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *); 2591extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *); 2592extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *); 2593extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *); 2594extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *); 2595extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *, loff_t); 2596extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t); 2597 2598ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos); 2599ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos); 2600 2601/* fs/block_dev.c */ 2602extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to); 2603extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from); 2604extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end, 2605 int datasync); 2606extern void block_sync_page(struct page *page); 2607 2608/* fs/splice.c */ 2609extern ssize_t generic_file_splice_read(struct file *, loff_t *, 2610 struct pipe_inode_info *, size_t, unsigned int); 2611extern ssize_t default_file_splice_read(struct file *, loff_t *, 2612 struct pipe_inode_info *, size_t, unsigned int); 2613extern ssize_t iter_file_splice_write(struct pipe_inode_info *, 2614 struct file *, loff_t *, size_t, unsigned int); 2615extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe, 2616 struct file *out, loff_t *, size_t len, unsigned int flags); 2617extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out, 2618 loff_t *opos, size_t len, unsigned int flags); 2619 2620 2621extern void 2622file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping); 2623extern loff_t noop_llseek(struct file *file, loff_t offset, int whence); 2624extern loff_t no_llseek(struct file *file, loff_t offset, int whence); 2625extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize); 2626extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence); 2627extern loff_t generic_file_llseek_size(struct file *file, loff_t offset, 2628 int whence, loff_t maxsize, loff_t eof); 2629extern loff_t fixed_size_llseek(struct file *file, loff_t offset, 2630 int whence, loff_t size); 2631extern int generic_file_open(struct inode * inode, struct file * filp); 2632extern int nonseekable_open(struct inode * inode, struct file * filp); 2633 2634ssize_t dax_do_io(struct kiocb *, struct inode *, struct iov_iter *, loff_t, 2635 get_block_t, dio_iodone_t, int flags); 2636int dax_clear_blocks(struct inode *, sector_t block, long size); 2637int dax_zero_page_range(struct inode *, loff_t from, unsigned len, get_block_t); 2638int dax_truncate_page(struct inode *, loff_t from, get_block_t); 2639int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t, 2640 dax_iodone_t); 2641int dax_pfn_mkwrite(struct vm_area_struct *, struct vm_fault *); 2642#define dax_mkwrite(vma, vmf, gb, iod) dax_fault(vma, vmf, gb, iod) 2643 2644#ifdef CONFIG_BLOCK 2645typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode, 2646 loff_t file_offset); 2647 2648enum { 2649 /* need locking between buffered and direct access */ 2650 DIO_LOCKING = 0x01, 2651 2652 /* filesystem does not support filling holes */ 2653 DIO_SKIP_HOLES = 0x02, 2654 2655 /* filesystem can handle aio writes beyond i_size */ 2656 DIO_ASYNC_EXTEND = 0x04, 2657 2658 /* inode/fs/bdev does not need truncate protection */ 2659 DIO_SKIP_DIO_COUNT = 0x08, 2660}; 2661 2662void dio_end_io(struct bio *bio, int error); 2663 2664ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode, 2665 struct block_device *bdev, struct iov_iter *iter, 2666 loff_t offset, get_block_t get_block, 2667 dio_iodone_t end_io, dio_submit_t submit_io, 2668 int flags); 2669 2670static inline ssize_t blockdev_direct_IO(struct kiocb *iocb, 2671 struct inode *inode, 2672 struct iov_iter *iter, loff_t offset, 2673 get_block_t get_block) 2674{ 2675 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter, 2676 offset, get_block, NULL, NULL, 2677 DIO_LOCKING | DIO_SKIP_HOLES); 2678} 2679#endif 2680 2681void inode_dio_wait(struct inode *inode); 2682 2683/* 2684 * inode_dio_begin - signal start of a direct I/O requests 2685 * @inode: inode the direct I/O happens on 2686 * 2687 * This is called once we've finished processing a direct I/O request, 2688 * and is used to wake up callers waiting for direct I/O to be quiesced. 2689 */ 2690static inline void inode_dio_begin(struct inode *inode) 2691{ 2692 atomic_inc(&inode->i_dio_count); 2693} 2694 2695/* 2696 * inode_dio_end - signal finish of a direct I/O requests 2697 * @inode: inode the direct I/O happens on 2698 * 2699 * This is called once we've finished processing a direct I/O request, 2700 * and is used to wake up callers waiting for direct I/O to be quiesced. 2701 */ 2702static inline void inode_dio_end(struct inode *inode) 2703{ 2704 if (atomic_dec_and_test(&inode->i_dio_count)) 2705 wake_up_bit(&inode->i_state, __I_DIO_WAKEUP); 2706} 2707 2708extern void inode_set_flags(struct inode *inode, unsigned int flags, 2709 unsigned int mask); 2710 2711extern const struct file_operations generic_ro_fops; 2712 2713#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m)) 2714 2715extern int readlink_copy(char __user *, int, const char *); 2716extern int page_readlink(struct dentry *, char __user *, int); 2717extern void *page_follow_link_light(struct dentry *, struct nameidata *); 2718extern void page_put_link(struct dentry *, struct nameidata *, void *); 2719extern int __page_symlink(struct inode *inode, const char *symname, int len, 2720 int nofs); 2721extern int page_symlink(struct inode *inode, const char *symname, int len); 2722extern const struct inode_operations page_symlink_inode_operations; 2723extern void kfree_put_link(struct dentry *, struct nameidata *, void *); 2724extern int generic_readlink(struct dentry *, char __user *, int); 2725extern void generic_fillattr(struct inode *, struct kstat *); 2726int vfs_getattr_nosec(struct path *path, struct kstat *stat); 2727extern int vfs_getattr(struct path *, struct kstat *); 2728void __inode_add_bytes(struct inode *inode, loff_t bytes); 2729void inode_add_bytes(struct inode *inode, loff_t bytes); 2730void __inode_sub_bytes(struct inode *inode, loff_t bytes); 2731void inode_sub_bytes(struct inode *inode, loff_t bytes); 2732loff_t inode_get_bytes(struct inode *inode); 2733void inode_set_bytes(struct inode *inode, loff_t bytes); 2734 2735extern int iterate_dir(struct file *, struct dir_context *); 2736 2737extern int vfs_stat(const char __user *, struct kstat *); 2738extern int vfs_lstat(const char __user *, struct kstat *); 2739extern int vfs_fstat(unsigned int, struct kstat *); 2740extern int vfs_fstatat(int , const char __user *, struct kstat *, int); 2741 2742extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, 2743 unsigned long arg); 2744extern int __generic_block_fiemap(struct inode *inode, 2745 struct fiemap_extent_info *fieinfo, 2746 loff_t start, loff_t len, 2747 get_block_t *get_block); 2748extern int generic_block_fiemap(struct inode *inode, 2749 struct fiemap_extent_info *fieinfo, u64 start, 2750 u64 len, get_block_t *get_block); 2751 2752extern void get_filesystem(struct file_system_type *fs); 2753extern void put_filesystem(struct file_system_type *fs); 2754extern struct file_system_type *get_fs_type(const char *name); 2755extern struct super_block *get_super(struct block_device *); 2756extern struct super_block *get_super_thawed(struct block_device *); 2757extern struct super_block *get_active_super(struct block_device *bdev); 2758extern void drop_super(struct super_block *sb); 2759extern void iterate_supers(void (*)(struct super_block *, void *), void *); 2760extern void iterate_supers_type(struct file_system_type *, 2761 void (*)(struct super_block *, void *), void *); 2762 2763extern int dcache_dir_open(struct inode *, struct file *); 2764extern int dcache_dir_close(struct inode *, struct file *); 2765extern loff_t dcache_dir_lseek(struct file *, loff_t, int); 2766extern int dcache_readdir(struct file *, struct dir_context *); 2767extern int simple_setattr(struct dentry *, struct iattr *); 2768extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *); 2769extern int simple_statfs(struct dentry *, struct kstatfs *); 2770extern int simple_open(struct inode *inode, struct file *file); 2771extern int simple_link(struct dentry *, struct inode *, struct dentry *); 2772extern int simple_unlink(struct inode *, struct dentry *); 2773extern int simple_rmdir(struct inode *, struct dentry *); 2774extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *); 2775extern int noop_fsync(struct file *, loff_t, loff_t, int); 2776extern int simple_empty(struct dentry *); 2777extern int simple_readpage(struct file *file, struct page *page); 2778extern int simple_write_begin(struct file *file, struct address_space *mapping, 2779 loff_t pos, unsigned len, unsigned flags, 2780 struct page **pagep, void **fsdata); 2781extern int simple_write_end(struct file *file, struct address_space *mapping, 2782 loff_t pos, unsigned len, unsigned copied, 2783 struct page *page, void *fsdata); 2784extern int always_delete_dentry(const struct dentry *); 2785extern struct inode *alloc_anon_inode(struct super_block *); 2786extern int simple_nosetlease(struct file *, long, struct file_lock **, void **); 2787extern const struct dentry_operations simple_dentry_operations; 2788 2789extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags); 2790extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *); 2791extern const struct file_operations simple_dir_operations; 2792extern const struct inode_operations simple_dir_inode_operations; 2793extern void make_empty_dir_inode(struct inode *inode); 2794extern bool is_empty_dir_inode(struct inode *inode); 2795struct tree_descr { char *name; const struct file_operations *ops; int mode; }; 2796struct dentry *d_alloc_name(struct dentry *, const char *); 2797extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *); 2798extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count); 2799extern void simple_release_fs(struct vfsmount **mount, int *count); 2800 2801extern ssize_t simple_read_from_buffer(void __user *to, size_t count, 2802 loff_t *ppos, const void *from, size_t available); 2803extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, 2804 const void __user *from, size_t count); 2805 2806extern int __generic_file_fsync(struct file *, loff_t, loff_t, int); 2807extern int generic_file_fsync(struct file *, loff_t, loff_t, int); 2808 2809extern int generic_check_addressable(unsigned, u64); 2810 2811#ifdef CONFIG_MIGRATION 2812extern int buffer_migrate_page(struct address_space *, 2813 struct page *, struct page *, 2814 enum migrate_mode); 2815#else 2816#define buffer_migrate_page NULL 2817#endif 2818 2819extern int inode_change_ok(const struct inode *, struct iattr *); 2820extern int inode_newsize_ok(const struct inode *, loff_t offset); 2821extern void setattr_copy(struct inode *inode, const struct iattr *attr); 2822 2823extern int file_update_time(struct file *file); 2824 2825extern int generic_show_options(struct seq_file *m, struct dentry *root); 2826extern void save_mount_options(struct super_block *sb, char *options); 2827extern void replace_mount_options(struct super_block *sb, char *options); 2828 2829static inline bool io_is_direct(struct file *filp) 2830{ 2831 return (filp->f_flags & O_DIRECT) || IS_DAX(file_inode(filp)); 2832} 2833 2834static inline int iocb_flags(struct file *file) 2835{ 2836 int res = 0; 2837 if (file->f_flags & O_APPEND) 2838 res |= IOCB_APPEND; 2839 if (io_is_direct(file)) 2840 res |= IOCB_DIRECT; 2841 return res; 2842} 2843 2844static inline ino_t parent_ino(struct dentry *dentry) 2845{ 2846 ino_t res; 2847 2848 /* 2849 * Don't strictly need d_lock here? If the parent ino could change 2850 * then surely we'd have a deeper race in the caller? 2851 */ 2852 spin_lock(&dentry->d_lock); 2853 res = dentry->d_parent->d_inode->i_ino; 2854 spin_unlock(&dentry->d_lock); 2855 return res; 2856} 2857 2858/* Transaction based IO helpers */ 2859 2860/* 2861 * An argresp is stored in an allocated page and holds the 2862 * size of the argument or response, along with its content 2863 */ 2864struct simple_transaction_argresp { 2865 ssize_t size; 2866 char data[0]; 2867}; 2868 2869#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp)) 2870 2871char *simple_transaction_get(struct file *file, const char __user *buf, 2872 size_t size); 2873ssize_t simple_transaction_read(struct file *file, char __user *buf, 2874 size_t size, loff_t *pos); 2875int simple_transaction_release(struct inode *inode, struct file *file); 2876 2877void simple_transaction_set(struct file *file, size_t n); 2878 2879/* 2880 * simple attribute files 2881 * 2882 * These attributes behave similar to those in sysfs: 2883 * 2884 * Writing to an attribute immediately sets a value, an open file can be 2885 * written to multiple times. 2886 * 2887 * Reading from an attribute creates a buffer from the value that might get 2888 * read with multiple read calls. When the attribute has been read 2889 * completely, no further read calls are possible until the file is opened 2890 * again. 2891 * 2892 * All attributes contain a text representation of a numeric value 2893 * that are accessed with the get() and set() functions. 2894 */ 2895#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \ 2896static int __fops ## _open(struct inode *inode, struct file *file) \ 2897{ \ 2898 __simple_attr_check_format(__fmt, 0ull); \ 2899 return simple_attr_open(inode, file, __get, __set, __fmt); \ 2900} \ 2901static const struct file_operations __fops = { \ 2902 .owner = THIS_MODULE, \ 2903 .open = __fops ## _open, \ 2904 .release = simple_attr_release, \ 2905 .read = simple_attr_read, \ 2906 .write = simple_attr_write, \ 2907 .llseek = generic_file_llseek, \ 2908} 2909 2910static inline __printf(1, 2) 2911void __simple_attr_check_format(const char *fmt, ...) 2912{ 2913 /* don't do anything, just let the compiler check the arguments; */ 2914} 2915 2916int simple_attr_open(struct inode *inode, struct file *file, 2917 int (*get)(void *, u64 *), int (*set)(void *, u64), 2918 const char *fmt); 2919int simple_attr_release(struct inode *inode, struct file *file); 2920ssize_t simple_attr_read(struct file *file, char __user *buf, 2921 size_t len, loff_t *ppos); 2922ssize_t simple_attr_write(struct file *file, const char __user *buf, 2923 size_t len, loff_t *ppos); 2924 2925struct ctl_table; 2926int proc_nr_files(struct ctl_table *table, int write, 2927 void __user *buffer, size_t *lenp, loff_t *ppos); 2928int proc_nr_dentry(struct ctl_table *table, int write, 2929 void __user *buffer, size_t *lenp, loff_t *ppos); 2930int proc_nr_inodes(struct ctl_table *table, int write, 2931 void __user *buffer, size_t *lenp, loff_t *ppos); 2932int __init get_filesystem_list(char *buf); 2933 2934#define __FMODE_EXEC ((__force int) FMODE_EXEC) 2935#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY) 2936 2937#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE]) 2938#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \ 2939 (flag & __FMODE_NONOTIFY))) 2940 2941static inline int is_sxid(umode_t mode) 2942{ 2943 return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP)); 2944} 2945 2946static inline int check_sticky(struct inode *dir, struct inode *inode) 2947{ 2948 if (!(dir->i_mode & S_ISVTX)) 2949 return 0; 2950 2951 return __check_sticky(dir, inode); 2952} 2953 2954static inline void inode_has_no_xattr(struct inode *inode) 2955{ 2956 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & MS_NOSEC)) 2957 inode->i_flags |= S_NOSEC; 2958} 2959 2960static inline bool is_root_inode(struct inode *inode) 2961{ 2962 return inode == inode->i_sb->s_root->d_inode; 2963} 2964 2965static inline bool dir_emit(struct dir_context *ctx, 2966 const char *name, int namelen, 2967 u64 ino, unsigned type) 2968{ 2969 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0; 2970} 2971static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx) 2972{ 2973 return ctx->actor(ctx, ".", 1, ctx->pos, 2974 file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0; 2975} 2976static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx) 2977{ 2978 return ctx->actor(ctx, "..", 2, ctx->pos, 2979 parent_ino(file->f_path.dentry), DT_DIR) == 0; 2980} 2981static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx) 2982{ 2983 if (ctx->pos == 0) { 2984 if (!dir_emit_dot(file, ctx)) 2985 return false; 2986 ctx->pos = 1; 2987 } 2988 if (ctx->pos == 1) { 2989 if (!dir_emit_dotdot(file, ctx)) 2990 return false; 2991 ctx->pos = 2; 2992 } 2993 return true; 2994} 2995static inline bool dir_relax(struct inode *inode) 2996{ 2997 mutex_unlock(&inode->i_mutex); 2998 mutex_lock(&inode->i_mutex); 2999 return !IS_DEADDIR(inode); 3000} 3001 3002#endif /* _LINUX_FS_H */ 3003