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