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

source code of linux/include/linux/fs.h