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