]> git.ipfire.org Git - thirdparty/linux.git/blame - include/linux/fs.h
Merge tag 'io_uring-6.16-20250630' of git://git.kernel.dk/linux
[thirdparty/linux.git] / include / linux / fs.h
CommitLineData
b2441318 1/* SPDX-License-Identifier: GPL-2.0 */
1da177e4
LT
2#ifndef _LINUX_FS_H
3#define _LINUX_FS_H
4
8b17e540 5#include <linux/vfsdebug.h>
1da177e4 6#include <linux/linkage.h>
5dd43ce2 7#include <linux/wait_bit.h>
1da177e4
LT
8#include <linux/kdev_t.h>
9#include <linux/dcache.h>
3f8206d4 10#include <linux/path.h>
1da177e4
LT
11#include <linux/stat.h>
12#include <linux/cache.h>
1da177e4 13#include <linux/list.h>
bc3b14cb 14#include <linux/list_lru.h>
4f5e65a1 15#include <linux/llist.h>
1da177e4 16#include <linux/radix-tree.h>
b93b0163 17#include <linux/xarray.h>
6b2dbba8 18#include <linux/rbtree.h>
1da177e4 19#include <linux/init.h>
914e2637 20#include <linux/pid.h>
187f1882 21#include <linux/bug.h>
1b1dcc1b 22#include <linux/mutex.h>
c8c06efa 23#include <linux/rwsem.h>
baabda26 24#include <linux/mm_types.h>
3bd858ab 25#include <linux/capability.h>
6188e10d 26#include <linux/semaphore.h>
c75b1d94 27#include <linux/fcntl.h>
ceb5bdc2 28#include <linux/rculist_bl.h>
07b8ce1e 29#include <linux/atomic.h>
83aeeada 30#include <linux/shrinker.h>
c1aab02d 31#include <linux/migrate_mode.h>
92361636 32#include <linux/uidgid.h>
5accdf82 33#include <linux/lockdep.h>
c2b1ad80 34#include <linux/percpu-rwsem.h>
853b39a7 35#include <linux/workqueue.h>
fceef393 36#include <linux/delayed_call.h>
85787090 37#include <linux/uuid.h>
5660e13d 38#include <linux/errseq.h>
d9a08a9e 39#include <linux/ioprio.h>
bbe7449e 40#include <linux/fs_types.h>
f1fffbd4
RV
41#include <linux/build_bug.h>
42#include <linux/stddef.h>
a6435940 43#include <linux/mount.h>
e6c9a714 44#include <linux/cred.h>
a793d79e 45#include <linux/mnt_idmapping.h>
8b9f3ac5 46#include <linux/slab.h>
0e4a8621 47#include <linux/maple_tree.h>
fe3944fb 48#include <linux/rw_hint.h>
90ee6ed7 49#include <linux/file_ref.h>
0e152beb 50#include <linux/unicode.h>
1da177e4 51
1da177e4 52#include <asm/byteorder.h>
607ca46e 53#include <uapi/linux/fs.h>
1da177e4 54
b83ae6d4 55struct backing_dev_info;
52ebea74 56struct bdi_writeback;
2f8b5444 57struct bio;
5a72e899 58struct io_comp_batch;
a5694255 59struct export_operations;
10c5db28 60struct fiemap_extent_info;
a885c8c4 61struct hd_geometry;
1da177e4 62struct iovec;
92198f7e 63struct kiocb;
57cc7215 64struct kobject;
1da177e4
LT
65struct pipe_inode_info;
66struct poll_table_struct;
67struct kstatfs;
68struct vm_area_struct;
69struct vfsmount;
745ca247 70struct cred;
a509bc1a 71struct swap_info_struct;
55985dd7 72struct seq_file;
7b7a8665 73struct workqueue_struct;
3b93f911 74struct iov_iter;
3e7807d5 75struct fscrypt_inode_info;
0b81d077 76struct fscrypt_operations;
5585f2af
EB
77struct fsverity_info;
78struct fsverity_operations;
07a3b8d0
AG
79struct fsnotify_mark_connector;
80struct fsnotify_sb_info;
f3a09c92 81struct fs_context;
d7167b14 82struct fs_parameter_spec;
4c5b4799 83struct fileattr;
6f7db389 84struct iomap_ops;
1da177e4 85
74bf17cf 86extern void __init inode_init(void);
1da177e4 87extern void __init inode_init_early(void);
4248b0da
MG
88extern void __init files_init(void);
89extern void __init files_maxfiles_init(void);
1da177e4 90
518de9b3 91extern unsigned long get_max_files(void);
9b80a184 92extern unsigned int sysctl_nr_open;
dded4f4d 93
ddef7ed2
CH
94typedef __kernel_rwf_t rwf_t;
95
1da177e4
LT
96struct buffer_head;
97typedef int (get_block_t)(struct inode *inode, sector_t iblock,
98 struct buffer_head *bh_result, int create);
187372a3 99typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
7b7a8665 100 ssize_t bytes, void *private);
1da177e4 101
bbc1096a
DH
102#define MAY_EXEC 0x00000001
103#define MAY_WRITE 0x00000002
104#define MAY_READ 0x00000004
105#define MAY_APPEND 0x00000008
106#define MAY_ACCESS 0x00000010
107#define MAY_OPEN 0x00000020
108#define MAY_CHDIR 0x00000040
109/* called from RCU mode, don't block */
110#define MAY_NOT_BLOCK 0x00000080
111
112/*
113 * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
75abe329 114 * to O_WRONLY and O_RDWR via the strange trick in do_dentry_open()
bbc1096a
DH
115 */
116
117/* file is open for reading */
0a4f544d 118#define FMODE_READ ((__force fmode_t)(1 << 0))
bbc1096a 119/* file is open for writing */
0a4f544d 120#define FMODE_WRITE ((__force fmode_t)(1 << 1))
bbc1096a 121/* file is seekable */
0a4f544d 122#define FMODE_LSEEK ((__force fmode_t)(1 << 2))
bbc1096a 123/* file can be accessed using pread */
0a4f544d 124#define FMODE_PREAD ((__force fmode_t)(1 << 3))
bbc1096a 125/* file can be accessed using pwrite */
0a4f544d 126#define FMODE_PWRITE ((__force fmode_t)(1 << 4))
bbc1096a 127/* File is opened for execution with sys_execve / sys_uselib */
0a4f544d 128#define FMODE_EXEC ((__force fmode_t)(1 << 5))
ddd65e19 129/* File writes are restricted (block device specific) */
1b0aabcc 130#define FMODE_WRITE_RESTRICTED ((__force fmode_t)(1 << 6))
c34fc6f2
PS
131/* File supports atomic writes */
132#define FMODE_CAN_ATOMIC_WRITE ((__force fmode_t)(1 << 7))
0a4f544d 133
c34fc6f2 134/* FMODE_* bit 8 */
0a4f544d 135
bbc1096a 136/* 32bit hashes as llseek() offset (for directories) */
0a4f544d 137#define FMODE_32BITHASH ((__force fmode_t)(1 << 9))
bbc1096a 138/* 64bit hashes as llseek() offset (for directories) */
0a4f544d 139#define FMODE_64BITHASH ((__force fmode_t)(1 << 10))
bbc1096a
DH
140
141/*
142 * Don't update ctime and mtime.
143 *
144 * Currently a special hack for the XFS open_by_handle ioctl, but we'll
145 * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
146 */
0a4f544d 147#define FMODE_NOCMTIME ((__force fmode_t)(1 << 11))
bbc1096a
DH
148
149/* Expect random access pattern */
0a4f544d 150#define FMODE_RANDOM ((__force fmode_t)(1 << 12))
bbc1096a 151
641bb439 152/* FMODE_* bit 13 */
bbc1096a
DH
153
154/* File is opened with O_PATH; almost nothing can be done with it */
0a4f544d 155#define FMODE_PATH ((__force fmode_t)(1 << 14))
bbc1096a 156
2be7d348 157/* File needs atomic accesses to f_pos */
0a4f544d 158#define FMODE_ATOMIC_POS ((__force fmode_t)(1 << 15))
83f936c7 159/* Write access to underlying fs */
0a4f544d 160#define FMODE_WRITER ((__force fmode_t)(1 << 16))
7f7f25e8 161/* Has read method(s) */
0a4f544d 162#define FMODE_CAN_READ ((__force fmode_t)(1 << 17))
7f7f25e8 163/* Has write method(s) */
0a4f544d 164#define FMODE_CAN_WRITE ((__force fmode_t)(1 << 18))
9c225f26 165
0a4f544d
CB
166#define FMODE_OPENED ((__force fmode_t)(1 << 19))
167#define FMODE_CREATED ((__force fmode_t)(1 << 20))
f5d11409 168
10dce8af 169/* File is stream-like */
0a4f544d 170#define FMODE_STREAM ((__force fmode_t)(1 << 21))
10dce8af 171
a2ad63da 172/* File supports DIRECT IO */
0a4f544d 173#define FMODE_CAN_ODIRECT ((__force fmode_t)(1 << 22))
a2ad63da 174
0a4f544d 175#define FMODE_NOREUSE ((__force fmode_t)(1 << 23))
17e81022 176
62d53c4a 177/* File is embedded in backing_file object */
a94204f4
AG
178#define FMODE_BACKING ((__force fmode_t)(1 << 24))
179
180/*
181 * Together with FMODE_NONOTIFY_PERM defines which fsnotify events shouldn't be
182 * generated (see below)
183 */
184#define FMODE_NONOTIFY ((__force fmode_t)(1 << 25))
62d53c4a 185
a94204f4
AG
186/*
187 * Together with FMODE_NONOTIFY defines which fsnotify events shouldn't be
188 * generated (see below)
189 */
190#define FMODE_NONOTIFY_PERM ((__force fmode_t)(1 << 26))
bbc1096a 191
91f9943e 192/* File is capable of returning -EAGAIN if I/O will block */
0a4f544d 193#define FMODE_NOWAIT ((__force fmode_t)(1 << 27))
a07b2000
AV
194
195/* File represents mount that needs unmounting */
0a4f544d 196#define FMODE_NEED_UNMOUNT ((__force fmode_t)(1 << 28))
b745fafa 197
d3b1084d 198/* File does not contribute to nr_files count */
0a4f544d 199#define FMODE_NOACCOUNT ((__force fmode_t)(1 << 29))
80175539 200
a94204f4
AG
201/*
202 * The two FMODE_NONOTIFY* define which fsnotify events should not be generated
203 * for a file. These are the possible values of (f->f_mode &
204 * FMODE_FSNOTIFY_MASK) and their meaning:
205 *
206 * FMODE_NONOTIFY - suppress all (incl. non-permission) events.
207 * FMODE_NONOTIFY_PERM - suppress permission (incl. pre-content) events.
208 * FMODE_NONOTIFY | FMODE_NONOTIFY_PERM - suppress only pre-content events.
209 */
210#define FMODE_FSNOTIFY_MASK \
211 (FMODE_NONOTIFY | FMODE_NONOTIFY_PERM)
212
213#define FMODE_FSNOTIFY_NONE(mode) \
214 ((mode & FMODE_FSNOTIFY_MASK) == FMODE_NONOTIFY)
215#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
216#define FMODE_FSNOTIFY_PERM(mode) \
217 ((mode & FMODE_FSNOTIFY_MASK) == 0 || \
218 (mode & FMODE_FSNOTIFY_MASK) == (FMODE_NONOTIFY | FMODE_NONOTIFY_PERM))
219#define FMODE_FSNOTIFY_HSM(mode) \
220 ((mode & FMODE_FSNOTIFY_MASK) == 0)
221#else
222#define FMODE_FSNOTIFY_PERM(mode) 0
223#define FMODE_FSNOTIFY_HSM(mode) 0
224#endif
225
1da177e4
LT
226/*
227 * Attribute flags. These should be or-ed together to figure out what
228 * has been changed!
229 */
9767d749
MS
230#define ATTR_MODE (1 << 0)
231#define ATTR_UID (1 << 1)
232#define ATTR_GID (1 << 2)
233#define ATTR_SIZE (1 << 3)
234#define ATTR_ATIME (1 << 4)
235#define ATTR_MTIME (1 << 5)
236#define ATTR_CTIME (1 << 6)
237#define ATTR_ATIME_SET (1 << 7)
238#define ATTR_MTIME_SET (1 << 8)
239#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
9767d749
MS
240#define ATTR_KILL_SUID (1 << 11)
241#define ATTR_KILL_SGID (1 << 12)
242#define ATTR_FILE (1 << 13)
243#define ATTR_KILL_PRIV (1 << 14)
244#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
245#define ATTR_TIMES_SET (1 << 16)
f2b20f6e 246#define ATTR_TOUCH (1 << 17)
7e8ae848 247#define ATTR_DELEG (1 << 18) /* Delegated attrs. Don't break write delegations */
1da177e4 248
787fb6bc
MS
249/*
250 * Whiteout is represented by a char device. The following constants define the
251 * mode and device number to use.
252 */
253#define WHITEOUT_MODE 0
254#define WHITEOUT_DEV 0
255
1da177e4
LT
256/*
257 * This is the Inode Attributes structure, used for notify_change(). It
258 * uses the above definitions as flags, to know which values have changed.
259 * Also, in this manner, a Filesystem can look at only the values it cares
260 * about. Basically, these are the attributes that the VFS layer can
261 * request to change from the FS layer.
262 *
263 * Derek Atkins <warlord@MIT.EDU> 94-10-20
264 */
265struct iattr {
266 unsigned int ia_valid;
267 umode_t ia_mode;
45c31150
CB
268 /*
269 * The two anonymous unions wrap structures with the same member.
270 *
271 * Filesystems raising FS_ALLOW_IDMAP need to use ia_vfs{g,u}id which
272 * are a dedicated type requiring the filesystem to use the dedicated
273 * helpers. Other filesystem can continue to use ia_{g,u}id until they
274 * have been ported.
b27c82e1
CB
275 *
276 * They always contain the same value. In other words FS_ALLOW_IDMAP
277 * pass down the same value on idmapped mounts as they would on regular
278 * mounts.
45c31150
CB
279 */
280 union {
281 kuid_t ia_uid;
282 vfsuid_t ia_vfsuid;
283 };
284 union {
285 kgid_t ia_gid;
286 vfsgid_t ia_vfsgid;
287 };
1da177e4 288 loff_t ia_size;
95582b00
DD
289 struct timespec64 ia_atime;
290 struct timespec64 ia_mtime;
291 struct timespec64 ia_ctime;
cc4e69de
MS
292
293 /*
25985edc 294 * Not an attribute, but an auxiliary info for filesystems wanting to
cc4e69de
MS
295 * implement an ftruncate() like method. NOTE: filesystem should
296 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
297 */
298 struct file *ia_file;
1da177e4
LT
299};
300
1da177e4
LT
301/*
302 * Includes for diskquotas.
303 */
304#include <linux/quota.h>
305
69c433ed
MS
306/*
307 * Maximum number of layers of fs stack. Needs to be limited to
308 * prevent kernel stack overflow
309 */
310#define FILESYSTEM_MAX_STACK_DEPTH 2
311
994fc28c
ZB
312/**
313 * enum positive_aop_returns - aop return codes with specific semantics
314 *
315 * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
316 * completed, that the page is still locked, and
317 * should be considered active. The VM uses this hint
318 * to return the page to the active list -- it won't
319 * be a candidate for writeback again in the near
320 * future. Other callers must be careful to unlock
321 * the page if they get this return. Returned by
322 * writepage();
323 *
324 * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
325 * unlocked it and the page might have been truncated.
326 * The caller should back up to acquiring a new page and
327 * trying again. The aop will be taking reasonable
328 * precautions not to livelock. If the caller held a page
329 * reference, it should drop it before retrying. Returned
7e0a1265 330 * by read_folio().
994fc28c
ZB
331 *
332 * address_space_operation functions return these large constants to indicate
333 * special semantics to the caller. These are much larger than the bytes in a
334 * page to allow for functions that return the number of bytes operated on in a
335 * given page.
336 */
337
338enum positive_aop_returns {
339 AOP_WRITEPAGE_ACTIVATE = 0x80000,
340 AOP_TRUNCATED_PAGE = 0x80001,
341};
342
1da177e4
LT
343/*
344 * oh the beauties of C type declarations.
345 */
346struct page;
347struct address_space;
348struct writeback_control;
8151b4c8 349struct readahead_control;
1da177e4 350
ce71bfea
JA
351/* Match RWF_* bits to IOCB bits */
352#define IOCB_HIPRI (__force int) RWF_HIPRI
353#define IOCB_DSYNC (__force int) RWF_DSYNC
354#define IOCB_SYNC (__force int) RWF_SYNC
355#define IOCB_NOWAIT (__force int) RWF_NOWAIT
356#define IOCB_APPEND (__force int) RWF_APPEND
c34fc6f2 357#define IOCB_ATOMIC (__force int) RWF_ATOMIC
af6505e5 358#define IOCB_DONTCACHE (__force int) RWF_DONTCACHE
ce71bfea
JA
359
360/* non-RWF related bits - start at 16 */
361#define IOCB_EVENTFD (1 << 16)
362#define IOCB_DIRECT (1 << 17)
363#define IOCB_WRITE (1 << 18)
dd3e6d50 364/* iocb->ki_waitq is valid */
ce71bfea
JA
365#define IOCB_WAITQ (1 << 19)
366#define IOCB_NOIO (1 << 20)
6c7ef543
JA
367/* can use bio alloc cache */
368#define IOCB_ALLOC_CACHE (1 << 21)
9cf3516c
JA
369/*
370 * IOCB_DIO_CALLER_COMP can be set by the iocb owner, to indicate that the
371 * iocb completion can be passed back to the owner for execution from a safe
372 * context rather than needing to be punted through a workqueue. If this
373 * flag is set, the bio completion handling may set iocb->dio_complete to a
374 * handler function and iocb->private to context information for that handler.
375 * The issuer should call the handler with that context information from task
376 * context to complete the processing of the iocb. Note that while this
377 * provides a task context for the dio_complete() callback, it should only be
378 * used on the completion side for non-IO generating completions. It's fine to
379 * call blocking functions from this callback, but they should not wait for
380 * unrelated IO (like cache flushing, new IO generation, etc).
381 */
382#define IOCB_DIO_CALLER_COMP (1 << 22)
b820de74
BVA
383/* kiocb is a read or write operation submitted by fs/aio.c. */
384#define IOCB_AIO_RW (1 << 23)
4de2ce04 385#define IOCB_HAS_METADATA (1 << 24)
e2e40f2c 386
f6c73a11
RHI
387/* for use in trace events */
388#define TRACE_IOCB_STRINGS \
389 { IOCB_HIPRI, "HIPRI" }, \
390 { IOCB_DSYNC, "DSYNC" }, \
391 { IOCB_SYNC, "SYNC" }, \
392 { IOCB_NOWAIT, "NOWAIT" }, \
393 { IOCB_APPEND, "APPEND" }, \
af6505e5
JA
394 { IOCB_ATOMIC, "ATOMIC" }, \
395 { IOCB_DONTCACHE, "DONTCACHE" }, \
f6c73a11
RHI
396 { IOCB_EVENTFD, "EVENTFD"}, \
397 { IOCB_DIRECT, "DIRECT" }, \
398 { IOCB_WRITE, "WRITE" }, \
399 { IOCB_WAITQ, "WAITQ" }, \
400 { IOCB_NOIO, "NOIO" }, \
9cf3516c 401 { IOCB_ALLOC_CACHE, "ALLOC_CACHE" }, \
6bdd3a01
CH
402 { IOCB_DIO_CALLER_COMP, "CALLER_COMP" }, \
403 { IOCB_AIO_RW, "AIO_RW" }, \
404 { IOCB_HAS_METADATA, "AIO_HAS_METADATA" }
f6c73a11 405
e2e40f2c
CH
406struct kiocb {
407 struct file *ki_filp;
408 loff_t ki_pos;
6b19b766 409 void (*ki_complete)(struct kiocb *iocb, long ret);
e2e40f2c
CH
410 void *private;
411 int ki_flags;
d9a08a9e 412 u16 ki_ioprio; /* See linux/ioprio.h */
732f25a2 413 u8 ki_write_stream;
9cf3516c
JA
414 union {
415 /*
416 * Only used for async buffered reads, where it denotes the
417 * page waitqueue associated with completing the read. Valid
418 * IFF IOCB_WAITQ is set.
419 */
420 struct wait_page_queue *ki_waitq;
421 /*
422 * Can be used for O_DIRECT IO, where the completion handling
423 * is punted back to the issuer of the IO. May only be set
424 * if IOCB_DIO_CALLER_COMP is set by the issuer, and the issuer
425 * must then check for presence of this handler when ki_complete
426 * is invoked. The data passed in to this handler must be
427 * assigned to ->private when dio_complete is assigned.
428 */
429 ssize_t (*dio_complete)(void *data);
430 };
84c4e1f8 431};
e2e40f2c
CH
432
433static inline bool is_sync_kiocb(struct kiocb *kiocb)
434{
435 return kiocb->ki_complete == NULL;
436}
437
1da177e4 438struct address_space_operations {
5efe7448 439 int (*read_folio)(struct file *, struct folio *);
1da177e4
LT
440
441 /* Write back some dirty pages from this mapping. */
442 int (*writepages)(struct address_space *, struct writeback_control *);
443
3a3bae50 444 /* Mark a folio dirty. Return true if this dirtied it */
6f31a5a2 445 bool (*dirty_folio)(struct address_space *, struct folio *);
1da177e4 446
8151b4c8 447 void (*readahead)(struct readahead_control *);
1da177e4 448
afddba49 449 int (*write_begin)(struct file *, struct address_space *mapping,
9d6b0cd7 450 loff_t pos, unsigned len,
1da86618 451 struct folio **foliop, void **fsdata);
afddba49
NP
452 int (*write_end)(struct file *, struct address_space *mapping,
453 loff_t pos, unsigned len, unsigned copied,
a225800f 454 struct folio *folio, void *fsdata);
afddba49 455
1da177e4
LT
456 /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
457 sector_t (*bmap)(struct address_space *, sector_t);
128d1f82 458 void (*invalidate_folio) (struct folio *, size_t offset, size_t len);
fa29000b 459 bool (*release_folio)(struct folio *, gfp_t);
d2329aa0 460 void (*free_folio)(struct folio *folio);
c8b8e32d 461 ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
b969c4ab 462 /*
5490da4f 463 * migrate the contents of a folio to the specified target. If
ef277c73 464 * migrate_mode is MIGRATE_ASYNC, it must not block.
b969c4ab 465 */
5490da4f
MWO
466 int (*migrate_folio)(struct address_space *, struct folio *dst,
467 struct folio *src, enum migrate_mode);
072acba6 468 int (*launder_folio)(struct folio *);
2e7e80f7
MWO
469 bool (*is_partially_uptodate) (struct folio *, size_t from,
470 size_t count);
520f301c 471 void (*is_dirty_writeback) (struct folio *, bool *dirty, bool *wb);
af7628d6 472 int (*error_remove_folio)(struct address_space *, struct folio *);
62c230bc
MG
473
474 /* swapfile support */
a509bc1a
MG
475 int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
476 sector_t *span);
477 void (*swap_deactivate)(struct file *file);
e1209d3a 478 int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
1da177e4
LT
479};
480
7dcda1c9
JA
481extern const struct address_space_operations empty_aops;
482
eb797a8e
MW
483/**
484 * struct address_space - Contents of a cacheable, mappable object.
485 * @host: Owner, either the inode or the block_device.
486 * @i_pages: Cached pages.
730633f0
JK
487 * @invalidate_lock: Guards coherency between page cache contents and
488 * file offset->disk block mappings in the filesystem during invalidates.
489 * It is also used to block modification of page cache contents through
490 * memory mappings.
eb797a8e 491 * @gfp_mask: Memory allocation flags to use for allocating pages.
e8e17ee9 492 * @i_mmap_writable: Number of VM_SHARED, VM_MAYWRITE mappings.
09d91cda 493 * @nr_thps: Number of THPs in the pagecache (non-shmem only).
eb797a8e
MW
494 * @i_mmap: Tree of private and shared mappings.
495 * @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable.
496 * @nrpages: Number of page entries, protected by the i_pages lock.
eb797a8e
MW
497 * @writeback_index: Writeback starts here.
498 * @a_ops: Methods.
499 * @flags: Error bits and flags (AS_*).
500 * @wb_err: The most recent error which has occurred.
600f111e
MWO
501 * @i_private_lock: For use by the owner of the address_space.
502 * @i_private_list: For use by the owner of the address_space.
503 * @i_private_data: For use by the owner of the address_space.
eb797a8e 504 */
1da177e4 505struct address_space {
eb797a8e
MW
506 struct inode *host;
507 struct xarray i_pages;
730633f0 508 struct rw_semaphore invalidate_lock;
eb797a8e
MW
509 gfp_t gfp_mask;
510 atomic_t i_mmap_writable;
09d91cda
SL
511#ifdef CONFIG_READ_ONLY_THP_FOR_FS
512 /* number of thp, only for non-shmem files */
513 atomic_t nr_thps;
514#endif
eb797a8e 515 struct rb_root_cached i_mmap;
eb797a8e 516 unsigned long nrpages;
eb797a8e
MW
517 pgoff_t writeback_index;
518 const struct address_space_operations *a_ops;
519 unsigned long flags;
5660e13d 520 errseq_t wb_err;
600f111e
MWO
521 spinlock_t i_private_lock;
522 struct list_head i_private_list;
d3b1a9a7 523 struct rw_semaphore i_mmap_rwsem;
600f111e 524 void * i_private_data;
3859a271 525} __attribute__((aligned(sizeof(long)))) __randomize_layout;
1da177e4
LT
526 /*
527 * On most architectures that alignment is already the case; but
25985edc 528 * must be enforced here for CRIS, to let the least significant bit
1da177e4
LT
529 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
530 */
1da177e4 531
ff9c745b
MW
532/* XArray tags, for tagging dirty and writeback pages in the pagecache. */
533#define PAGECACHE_TAG_DIRTY XA_MARK_0
534#define PAGECACHE_TAG_WRITEBACK XA_MARK_1
535#define PAGECACHE_TAG_TOWRITE XA_MARK_2
536
1da177e4 537/*
ff9c745b 538 * Returns true if any of the pages in the mapping are marked with the tag.
1da177e4 539 */
ff9c745b
MW
540static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
541{
542 return xa_marked(&mapping->i_pages, tag);
543}
1da177e4 544
8b28f621
DB
545static inline void i_mmap_lock_write(struct address_space *mapping)
546{
c8c06efa 547 down_write(&mapping->i_mmap_rwsem);
8b28f621
DB
548}
549
c0d0381a
MK
550static inline int i_mmap_trylock_write(struct address_space *mapping)
551{
552 return down_write_trylock(&mapping->i_mmap_rwsem);
553}
554
8b28f621
DB
555static inline void i_mmap_unlock_write(struct address_space *mapping)
556{
c8c06efa 557 up_write(&mapping->i_mmap_rwsem);
8b28f621
DB
558}
559
6d4675e6
MK
560static inline int i_mmap_trylock_read(struct address_space *mapping)
561{
562 return down_read_trylock(&mapping->i_mmap_rwsem);
563}
564
3dec0ba0
DB
565static inline void i_mmap_lock_read(struct address_space *mapping)
566{
567 down_read(&mapping->i_mmap_rwsem);
568}
569
570static inline void i_mmap_unlock_read(struct address_space *mapping)
571{
572 up_read(&mapping->i_mmap_rwsem);
573}
574
34ae204f
MK
575static inline void i_mmap_assert_locked(struct address_space *mapping)
576{
577 lockdep_assert_held(&mapping->i_mmap_rwsem);
578}
579
580static inline void i_mmap_assert_write_locked(struct address_space *mapping)
581{
582 lockdep_assert_held_write(&mapping->i_mmap_rwsem);
583}
584
1da177e4
LT
585/*
586 * Might pages of this file be mapped into userspace?
587 */
588static inline int mapping_mapped(struct address_space *mapping)
589{
f808c13f 590 return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root);
1da177e4
LT
591}
592
593/*
594 * Might pages of this file have been modified in userspace?
e8e17ee9 595 * Note that i_mmap_writable counts all VM_SHARED, VM_MAYWRITE vmas: do_mmap
1da177e4
LT
596 * marks vma as VM_SHARED if it is shared, and the file was opened for
597 * writing i.e. vma may be mprotected writable even if now readonly.
4bb5f5d9
DR
598 *
599 * If i_mmap_writable is negative, no new writable mappings are allowed. You
600 * can only deny writable mappings, if none exists right now.
1da177e4
LT
601 */
602static inline int mapping_writably_mapped(struct address_space *mapping)
603{
4bb5f5d9
DR
604 return atomic_read(&mapping->i_mmap_writable) > 0;
605}
606
607static inline int mapping_map_writable(struct address_space *mapping)
608{
609 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
610 0 : -EPERM;
611}
612
613static inline void mapping_unmap_writable(struct address_space *mapping)
614{
615 atomic_dec(&mapping->i_mmap_writable);
616}
617
618static inline int mapping_deny_writable(struct address_space *mapping)
619{
620 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
621 0 : -EBUSY;
622}
623
624static inline void mapping_allow_writable(struct address_space *mapping)
625{
626 atomic_inc(&mapping->i_mmap_writable);
1da177e4
LT
627}
628
629/*
630 * Use sequence counter to get consistent i_size on 32-bit processors.
631 */
632#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
633#include <linux/seqlock.h>
634#define __NEED_I_SIZE_ORDERED
635#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
636#else
637#define i_size_ordered_init(inode) do { } while (0)
638#endif
639
f19d4a8f
AV
640struct posix_acl;
641#define ACL_NOT_CACHED ((void *)(-1))
332f606b
MS
642/*
643 * ACL_DONT_CACHE is for stacked filesystems, that rely on underlying fs to
cac2f8b8
CB
644 * cache the ACL. This also means that ->get_inode_acl() can be called in RCU
645 * mode with the LOOKUP_RCU flag.
332f606b 646 */
2a3a2a3f 647#define ACL_DONT_CACHE ((void *)(-3))
f19d4a8f 648
b8a7a3a6
AG
649static inline struct posix_acl *
650uncached_acl_sentinel(struct task_struct *task)
651{
652 return (void *)task + 1;
653}
654
655static inline bool
656is_uncached_acl(struct posix_acl *acl)
657{
658 return (long)acl & 1;
659}
660
3ddcd056
LT
661#define IOP_FASTPERM 0x0001
662#define IOP_LOOKUP 0x0002
663#define IOP_NOFOLLOW 0x0004
d0a5b995 664#define IOP_XATTR 0x0008
76fca90e 665#define IOP_DEFAULT_READLINK 0x0010
9fed2c0f 666#define IOP_MGTIME 0x0020
ea382199 667#define IOP_CACHED_LINK 0x0040
3ddcd056
LT
668
669/*
670 * Keep mostly read-only and often accessed (especially for
671 * the RCU path lookup and 'stat' data) fields at the beginning
672 * of the 'struct inode'
673 */
1da177e4 674struct inode {
44a7d7a8 675 umode_t i_mode;
3ddcd056 676 unsigned short i_opflags;
92361636
EB
677 kuid_t i_uid;
678 kgid_t i_gid;
3ddcd056
LT
679 unsigned int i_flags;
680
681#ifdef CONFIG_FS_POSIX_ACL
682 struct posix_acl *i_acl;
683 struct posix_acl *i_default_acl;
684#endif
685
44a7d7a8
NP
686 const struct inode_operations *i_op;
687 struct super_block *i_sb;
3ddcd056 688 struct address_space *i_mapping;
44a7d7a8 689
13e12d14
LT
690#ifdef CONFIG_SECURITY
691 void *i_security;
692#endif
44a7d7a8 693
3ddcd056
LT
694 /* Stat data, not accessed from path walking */
695 unsigned long i_ino;
a78ef704
MS
696 /*
697 * Filesystems may only read i_nlink directly. They shall use the
698 * following functions for modification:
699 *
700 * (set|clear|inc|drop)_nlink
701 * inode_(inc|dec)_link_count
702 */
703 union {
704 const unsigned int i_nlink;
705 unsigned int __i_nlink;
706 };
3ddcd056 707 dev_t i_rdev;
2f9d3df8 708 loff_t i_size;
3aa63a56
JL
709 time64_t i_atime_sec;
710 time64_t i_mtime_sec;
711 time64_t i_ctime_sec;
712 u32 i_atime_nsec;
713 u32 i_mtime_nsec;
714 u32 i_ctime_nsec;
715 u32 i_generation;
6cdbb0ef
TT
716 spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
717 unsigned short i_bytes;
69448867 718 u8 i_blkbits;
fe3944fb 719 enum rw_hint i_write_hint;
3ddcd056
LT
720 blkcnt_t i_blocks;
721
722#ifdef __NEED_I_SIZE_ORDERED
723 seqcount_t i_size_seqcount;
724#endif
725
726 /* Misc */
2b111edb
CB
727 u32 i_state;
728 /* 32-bit hole */
9902af79 729 struct rw_semaphore i_rwsem;
13e12d14 730
44a7d7a8 731 unsigned long dirtied_when; /* jiffies of first dirtying */
a2f48706 732 unsigned long dirtied_time_when;
44a7d7a8 733
1da177e4 734 struct hlist_node i_hash;
c7f54084 735 struct list_head i_io_list; /* backing dev IO list */
52ebea74
TH
736#ifdef CONFIG_CGROUP_WRITEBACK
737 struct bdi_writeback *i_wb; /* the associated cgroup wb */
2a814908
TH
738
739 /* foreign inode detection, see wbc_detach_inode() */
740 int i_wb_frn_winner;
741 u16 i_wb_frn_avg_time;
742 u16 i_wb_frn_history;
52ebea74 743#endif
7ccf19a8 744 struct list_head i_lru; /* inode LRU list */
1da177e4 745 struct list_head i_sb_list;
6c60d2b5 746 struct list_head i_wb_list; /* backing dev writeback list */
fa0d7e3d 747 union {
b3d9b7a3 748 struct hlist_head i_dentry;
fa0d7e3d
NP
749 struct rcu_head i_rcu;
750 };
f02a9ad1 751 atomic64_t i_version;
8019ad13 752 atomic64_t i_sequence; /* see futex */
2f9d3df8 753 atomic_t i_count;
bd5fe6c5 754 atomic_t i_dio_count;
6cdbb0ef 755 atomic_t i_writecount;
387e3746 756#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
d984ea60
MZ
757 atomic_t i_readcount; /* struct files open RO */
758#endif
fdb0da89
AV
759 union {
760 const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
761 void (*free_inode)(struct inode *);
762 };
4a075e39 763 struct file_lock_context *i_flctx;
1da177e4 764 struct address_space i_data;
ea382199
MG
765 union {
766 struct list_head i_devices;
767 int i_linklen;
768 };
4c154168
TT
769 union {
770 struct pipe_inode_info *i_pipe;
577c4eb0 771 struct cdev *i_cdev;
61ba64fc 772 char *i_link;
84e710da 773 unsigned i_dir_seq;
4c154168 774 };
1da177e4 775
1da177e4 776
3be25f49
EP
777#ifdef CONFIG_FSNOTIFY
778 __u32 i_fsnotify_mask; /* all events this inode cares about */
3aa63a56 779 /* 32-bit hole reserved for expanding i_fsnotify_mask */
08991e83 780 struct fsnotify_mark_connector __rcu *i_fsnotify_marks;
0eeca283
RL
781#endif
782
643fa961 783#ifdef CONFIG_FS_ENCRYPTION
3e7807d5 784 struct fscrypt_inode_info *i_crypt_info;
0b81d077
JK
785#endif
786
5585f2af
EB
787#ifdef CONFIG_FS_VERITY
788 struct fsverity_info *i_verity_info;
789#endif
790
8e18e294 791 void *i_private; /* fs or device private pointer */
3859a271 792} __randomize_layout;
1da177e4 793
ea382199
MG
794static inline void inode_set_cached_link(struct inode *inode, char *link, int linklen)
795{
3eb7e951
MG
796 VFS_WARN_ON_INODE(strlen(link) != linklen, inode);
797 VFS_WARN_ON_INODE(inode->i_opflags & IOP_CACHED_LINK, inode);
ea382199
MG
798 inode->i_link = link;
799 inode->i_linklen = linklen;
800 inode->i_opflags |= IOP_CACHED_LINK;
801}
802
da18ecbf
CB
803/*
804 * Get bit address from inode->i_state to use with wait_var_event()
805 * infrastructre.
806 */
807#define inode_state_wait_address(inode, bit) ((char *)&(inode)->i_state + (bit))
808
809struct wait_queue_head *inode_bit_waitqueue(struct wait_bit_queue_entry *wqe,
810 struct inode *inode, u32 bit);
811
812static inline void inode_wake_up_bit(struct inode *inode, u32 bit)
813{
814 /* Caller is responsible for correct memory barriers. */
815 wake_up_var(inode_state_wait_address(inode, bit));
816}
817
50e17c00
DD
818struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
819
93407472
FF
820static inline unsigned int i_blocksize(const struct inode *node)
821{
822 return (1 << node->i_blkbits);
823}
824
1d3382cb
AV
825static inline int inode_unhashed(struct inode *inode)
826{
827 return hlist_unhashed(&inode->i_hash);
828}
829
5bef9151
AV
830/*
831 * __mark_inode_dirty expects inodes to be hashed. Since we don't
832 * want special inodes in the fileset inode space, we make them
833 * appear hashed, but do not put on any lists. hlist_del()
834 * will work fine and require no locking.
835 */
836static inline void inode_fake_hash(struct inode *inode)
837{
838 hlist_add_fake(&inode->i_hash);
839}
840
f2eace23
IM
841/*
842 * inode->i_mutex nesting subclasses for the lock validator:
843 *
844 * 0: the object of the current VFS operation
845 * 1: parent
846 * 2: child/target
40bd22c9
BF
847 * 3: xattr
848 * 4: second non-directory
d1b72cc6
MS
849 * 5: second parent (when locking independent directories in rename)
850 *
851 * I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two
40bd22c9 852 * non-directories at once.
f2eace23
IM
853 *
854 * The locking order between these classes is
d1b72cc6 855 * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
f2eace23
IM
856 */
857enum inode_i_mutex_lock_class
858{
859 I_MUTEX_NORMAL,
860 I_MUTEX_PARENT,
861 I_MUTEX_CHILD,
4df46240 862 I_MUTEX_XATTR,
d1b72cc6
MS
863 I_MUTEX_NONDIR2,
864 I_MUTEX_PARENT2,
f2eace23
IM
865};
866
5955102c
AV
867static inline void inode_lock(struct inode *inode)
868{
9902af79 869 down_write(&inode->i_rwsem);
5955102c
AV
870}
871
d8c5507c
MK
872static inline __must_check int inode_lock_killable(struct inode *inode)
873{
874 return down_write_killable(&inode->i_rwsem);
875}
876
5955102c
AV
877static inline void inode_unlock(struct inode *inode)
878{
9902af79
AV
879 up_write(&inode->i_rwsem);
880}
881
882static inline void inode_lock_shared(struct inode *inode)
883{
884 down_read(&inode->i_rwsem);
885}
886
d8c5507c
MK
887static inline __must_check int inode_lock_shared_killable(struct inode *inode)
888{
889 return down_read_killable(&inode->i_rwsem);
890}
891
9902af79
AV
892static inline void inode_unlock_shared(struct inode *inode)
893{
894 up_read(&inode->i_rwsem);
5955102c
AV
895}
896
897static inline int inode_trylock(struct inode *inode)
898{
9902af79
AV
899 return down_write_trylock(&inode->i_rwsem);
900}
901
902static inline int inode_trylock_shared(struct inode *inode)
903{
904 return down_read_trylock(&inode->i_rwsem);
5955102c
AV
905}
906
907static inline int inode_is_locked(struct inode *inode)
908{
9902af79 909 return rwsem_is_locked(&inode->i_rwsem);
5955102c
AV
910}
911
912static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
913{
9902af79 914 down_write_nested(&inode->i_rwsem, subclass);
5955102c
AV
915}
916
01c2e13d
DW
917static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
918{
919 down_read_nested(&inode->i_rwsem, subclass);
920}
921
730633f0
JK
922static inline void filemap_invalidate_lock(struct address_space *mapping)
923{
924 down_write(&mapping->invalidate_lock);
925}
926
927static inline void filemap_invalidate_unlock(struct address_space *mapping)
928{
929 up_write(&mapping->invalidate_lock);
930}
931
932static inline void filemap_invalidate_lock_shared(struct address_space *mapping)
933{
934 down_read(&mapping->invalidate_lock);
935}
936
937static inline int filemap_invalidate_trylock_shared(
938 struct address_space *mapping)
939{
940 return down_read_trylock(&mapping->invalidate_lock);
941}
942
943static inline void filemap_invalidate_unlock_shared(
944 struct address_space *mapping)
945{
946 up_read(&mapping->invalidate_lock);
947}
948
375e289e
BF
949void lock_two_nondirectories(struct inode *, struct inode*);
950void unlock_two_nondirectories(struct inode *, struct inode*);
951
7506ae6a
JK
952void filemap_invalidate_lock_two(struct address_space *mapping1,
953 struct address_space *mapping2);
954void filemap_invalidate_unlock_two(struct address_space *mapping1,
955 struct address_space *mapping2);
956
957
1da177e4
LT
958/*
959 * NOTE: in a 32bit arch with a preemptable kernel and
960 * an UP compile the i_size_read/write must be atomic
961 * with respect to the local cpu (unlike with preempt disabled),
962 * but they don't need to be atomic with respect to other cpus like in
963 * true SMP (so they need either to either locally disable irq around
964 * the read or for example on x86 they can be still implemented as a
965 * cmpxchg8b without the need of the lock prefix). For SMP compiles
966 * and 64bit archs it makes no difference if preempt is enabled or not.
967 */
48ed214d 968static inline loff_t i_size_read(const struct inode *inode)
1da177e4
LT
969{
970#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
971 loff_t i_size;
972 unsigned int seq;
973
974 do {
975 seq = read_seqcount_begin(&inode->i_size_seqcount);
976 i_size = inode->i_size;
977 } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
978 return i_size;
2496396f 979#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
1da177e4
LT
980 loff_t i_size;
981
982 preempt_disable();
983 i_size = inode->i_size;
984 preempt_enable();
985 return i_size;
986#else
d8f899d1
BL
987 /* Pairs with smp_store_release() in i_size_write() */
988 return smp_load_acquire(&inode->i_size);
1da177e4
LT
989#endif
990}
991
7762f5a0
MS
992/*
993 * NOTE: unlike i_size_read(), i_size_write() does need locking around it
994 * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
995 * can be lost, resulting in subsequent i_size_read() calls spinning forever.
996 */
1da177e4
LT
997static inline void i_size_write(struct inode *inode, loff_t i_size)
998{
999#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
74e3d1e1 1000 preempt_disable();
1da177e4
LT
1001 write_seqcount_begin(&inode->i_size_seqcount);
1002 inode->i_size = i_size;
1003 write_seqcount_end(&inode->i_size_seqcount);
74e3d1e1 1004 preempt_enable();
2496396f 1005#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
1da177e4
LT
1006 preempt_disable();
1007 inode->i_size = i_size;
1008 preempt_enable();
1009#else
d8f899d1
BL
1010 /*
1011 * Pairs with smp_load_acquire() in i_size_read() to ensure
1012 * changes related to inode size (such as page contents) are
1013 * visible before we see the changed inode size.
1014 */
1015 smp_store_release(&inode->i_size, i_size);
1da177e4
LT
1016#endif
1017}
1018
48ed214d 1019static inline unsigned iminor(const struct inode *inode)
1da177e4
LT
1020{
1021 return MINOR(inode->i_rdev);
1022}
1023
48ed214d 1024static inline unsigned imajor(const struct inode *inode)
1da177e4
LT
1025{
1026 return MAJOR(inode->i_rdev);
1027}
1028
1da177e4 1029struct fown_struct {
1934b212 1030 struct file *file; /* backpointer for security modules */
1da177e4 1031 rwlock_t lock; /* protects pid, uid, euid fields */
609d7fa9
EB
1032 struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
1033 enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
92361636 1034 kuid_t uid, euid; /* uid/euid of process setting the owner */
1da177e4
LT
1035 int signum; /* posix.1b rt signal to be delivered on IO */
1036};
1037
c790fbf2
MWO
1038/**
1039 * struct file_ra_state - Track a file's readahead state.
1040 * @start: Where the most recent readahead started.
1041 * @size: Number of pages read in the most recent readahead.
84dacdbd
N
1042 * @async_size: Numer of pages that were/are not needed immediately
1043 * and so were/are genuinely "ahead". Start next readahead when
1044 * the first of these pages is accessed.
1045 * @ra_pages: Maximum size of a readahead request, copied from the bdi.
c790fbf2
MWO
1046 * @mmap_miss: How many mmap accesses missed in the page cache.
1047 * @prev_pos: The last byte in the most recent read request.
84dacdbd
N
1048 *
1049 * When this structure is passed to ->readahead(), the "most recent"
1050 * readahead means the current readahead.
1da177e4
LT
1051 */
1052struct file_ra_state {
c790fbf2
MWO
1053 pgoff_t start;
1054 unsigned int size;
1055 unsigned int async_size;
1056 unsigned int ra_pages;
1057 unsigned int mmap_miss;
1058 loff_t prev_pos;
1da177e4 1059};
1da177e4 1060
5ce1110b
FW
1061/*
1062 * Check if @index falls in the readahead windows.
1063 */
1064static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
1065{
f9acc8c7
FW
1066 return (index >= ra->start &&
1067 index < ra->start + ra->size);
5ce1110b
FW
1068}
1069
c0390d54
CB
1070/**
1071 * struct file - Represents a file
c0390d54
CB
1072 * @f_lock: Protects f_ep, f_flags. Must not be taken from IRQ context.
1073 * @f_mode: FMODE_* flags often used in hotpaths
1074 * @f_op: file operations
1075 * @f_mapping: Contents of a cacheable, mappable object.
1076 * @private_data: filesystem or driver specific data
1077 * @f_inode: cached inode
1078 * @f_flags: file flags
1079 * @f_iocb_flags: iocb flags
1080 * @f_cred: stashed credentials of creator/opener
e249056c 1081 * @f_owner: file owner
c0390d54
CB
1082 * @f_path: path of the file
1083 * @f_pos_lock: lock protecting file position
5e9b50de 1084 * @f_pipe: specific to pipes
c0390d54 1085 * @f_pos: file position
c0390d54 1086 * @f_security: LSM security context of this file
c0390d54
CB
1087 * @f_wb_err: writeback error
1088 * @f_sb_err: per sb writeback errors
1089 * @f_ep: link of all epoll hooks for this file
1090 * @f_task_work: task work entry point
1091 * @f_llist: work queue entrypoint
1092 * @f_ra: file's readahead state
ea566e18 1093 * @f_freeptr: Pointer used by SLAB_TYPESAFE_BY_RCU file cache (don't touch.)
e249056c 1094 * @f_ref: reference count
a7bc2e8d 1095 */
1da177e4 1096struct file {
c0390d54
CB
1097 spinlock_t f_lock;
1098 fmode_t f_mode;
a7bc2e8d 1099 const struct file_operations *f_op;
c0390d54
CB
1100 struct address_space *f_mapping;
1101 void *private_data;
1102 struct inode *f_inode;
1103 unsigned int f_flags;
1104 unsigned int f_iocb_flags;
1105 const struct cred *f_cred;
e249056c 1106 struct fown_struct *f_owner;
c0390d54
CB
1107 /* --- cacheline 1 boundary (64 bytes) --- */
1108 struct path f_path;
2f512016 1109 union {
5e9b50de
CB
1110 /* regular files (with FMODE_ATOMIC_POS) and directories */
1111 struct mutex f_pos_lock;
1112 /* pipes */
1113 u64 f_pipe;
e87f2c26 1114 };
c0390d54 1115 loff_t f_pos;
50462062 1116#ifdef CONFIG_SECURITY
c0390d54 1117 void *f_security;
50462062 1118#endif
11068e0b 1119 /* --- cacheline 2 boundary (128 bytes) --- */
c0390d54
CB
1120 errseq_t f_wb_err;
1121 errseq_t f_sb_err;
1da177e4 1122#ifdef CONFIG_EPOLL
c0390d54
CB
1123 struct hlist_head *f_ep;
1124#endif
1125 union {
1126 struct callback_head f_task_work;
1127 struct llist_node f_llist;
1128 struct file_ra_state f_ra;
ea566e18 1129 freeptr_t f_freeptr;
c0390d54 1130 };
e249056c 1131 file_ref_t f_ref;
c0390d54 1132 /* --- cacheline 3 boundary (192 bytes) --- */
3859a271
KC
1133} __randomize_layout
1134 __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
1da177e4 1135
990d6c2d
AK
1136struct file_handle {
1137 __u32 handle_bytes;
1138 int handle_type;
1139 /* file identifier */
68d6f4f3 1140 unsigned char f_handle[] __counted_by(handle_bytes);
990d6c2d
AK
1141};
1142
cb0942b8
AV
1143static inline struct file *get_file(struct file *f)
1144{
90ee6ed7 1145 file_ref_inc(&f->f_ref);
cb0942b8
AV
1146 return f;
1147}
0ede61d8
CB
1148
1149struct file *get_file_rcu(struct file __rcu **f);
61d4fb0b 1150struct file *get_file_active(struct file **f);
0ede61d8 1151
90ee6ed7 1152#define file_count(f) file_ref_read(&(f)->f_ref)
1da177e4
LT
1153
1154#define MAX_NON_LFS ((1UL<<31) - 1)
1155
1156/* Page cache limit. The filesystems should put that into their s_maxbytes
1157 limits, otherwise bad things can happen in VM. */
1158#if BITS_PER_LONG==32
0cc3b0ec 1159#define MAX_LFS_FILESIZE ((loff_t)ULONG_MAX << PAGE_SHIFT)
1da177e4 1160#elif BITS_PER_LONG==64
0cc3b0ec 1161#define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX)
1da177e4
LT
1162#endif
1163
7ca76311 1164/* legacy typedef, should eventually be removed */
17fa388d 1165typedef void *fl_owner_t;
1da177e4 1166
a7231a97 1167struct file_lock;
c69ff407 1168struct file_lease;
a7231a97 1169
1da177e4
LT
1170/* The following constant reflects the upper bound of the file/locking space */
1171#ifndef OFFSET_MAX
ea258f15
ZL
1172#define OFFSET_MAX type_max(loff_t)
1173#define OFFT_OFFSET_MAX type_max(off_t)
1da177e4
LT
1174#endif
1175
1934b212
CB
1176int file_f_owner_allocate(struct file *file);
1177static inline struct fown_struct *file_f_owner(const struct file *file)
1178{
1179 return READ_ONCE(file->f_owner);
1180}
1181
bfcd17a6
TP
1182extern void send_sigio(struct fown_struct *fown, int fd, int band);
1183
ee296d7c
JL
1184static inline struct inode *file_inode(const struct file *f)
1185{
1186 return f->f_inode;
1187}
1188
3058fca1
AG
1189/*
1190 * file_dentry() is a relic from the days that overlayfs was using files with a
1191 * "fake" path, meaning, f_path on overlayfs and f_inode on underlying fs.
1192 * In those days, file_dentry() was needed to get the underlying fs dentry that
1193 * matches f_inode.
1194 * Files with "fake" path should not exist nowadays, so use an assertion to make
1195 * sure that file_dentry() was not papering over filesystem bugs.
1196 */
d101a125
MS
1197static inline struct dentry *file_dentry(const struct file *file)
1198{
3058fca1
AG
1199 struct dentry *dentry = file->f_path.dentry;
1200
1201 WARN_ON_ONCE(d_inode(dentry) != file_inode(file));
1202 return dentry;
d101a125
MS
1203}
1204
1da177e4 1205struct fasync_struct {
7a107c0f 1206 rwlock_t fa_lock;
989a2979
ED
1207 int magic;
1208 int fa_fd;
1209 struct fasync_struct *fa_next; /* singly linked list */
1210 struct file *fa_file;
1211 struct rcu_head fa_rcu;
1da177e4
LT
1212};
1213
1214#define FASYNC_MAGIC 0x4601
1215
1216/* SMP safe fasync helpers: */
1217extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
f7347ce4
LT
1218extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1219extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1220extern struct fasync_struct *fasync_alloc(void);
1221extern void fasync_free(struct fasync_struct *);
1222
1da177e4
LT
1223/* can be called from interrupts */
1224extern void kill_fasync(struct fasync_struct **, int, int);
1da177e4 1225
e0b93edd 1226extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
bccb5c39 1227extern int f_setown(struct file *filp, int who, int force);
1da177e4 1228extern void f_delown(struct file *filp);
609d7fa9 1229extern pid_t f_getown(struct file *filp);
1934b212 1230extern int send_sigurg(struct file *file);
1da177e4 1231
e462ec50
DH
1232/*
1233 * sb->s_flags. Note that these mirror the equivalent MS_* flags where
1234 * represented in both.
1235 */
f15afbd3
HG
1236#define SB_RDONLY BIT(0) /* Mount read-only */
1237#define SB_NOSUID BIT(1) /* Ignore suid and sgid bits */
1238#define SB_NODEV BIT(2) /* Disallow access to device special files */
1239#define SB_NOEXEC BIT(3) /* Disallow program execution */
1240#define SB_SYNCHRONOUS BIT(4) /* Writes are synced at once */
1241#define SB_MANDLOCK BIT(6) /* Allow mandatory locks on an FS */
1242#define SB_DIRSYNC BIT(7) /* Directory modifications are synchronous */
1243#define SB_NOATIME BIT(10) /* Do not update access times. */
1244#define SB_NODIRATIME BIT(11) /* Do not update directory access times */
1245#define SB_SILENT BIT(15)
5aa8fd9c 1246#define SB_POSIXACL BIT(16) /* Supports POSIX ACLs */
f15afbd3
HG
1247#define SB_INLINECRYPT BIT(17) /* Use blk-crypto for encrypted files */
1248#define SB_KERNMOUNT BIT(22) /* this is a kern_mount call */
1249#define SB_I_VERSION BIT(23) /* Update inode I_version field */
1250#define SB_LAZYTIME BIT(25) /* Update the on-disk [acm]times lazily */
e462ec50
DH
1251
1252/* These sb flags are internal to the kernel */
2c18a63b 1253#define SB_DEAD BIT(21)
5e874914 1254#define SB_DYING BIT(24)
f15afbd3
HG
1255#define SB_FORCE BIT(27)
1256#define SB_NOSEC BIT(28)
1257#define SB_BORN BIT(29)
1258#define SB_ACTIVE BIT(30)
1259#define SB_NOUSER BIT(31)
e462ec50 1260
c843843e 1261/* These flags relate to encoding and casefolding */
9e28059d
TT
1262#define SB_ENC_STRICT_MODE_FL (1 << 0)
1263#define SB_ENC_NO_COMPAT_FALLBACK_FL (1 << 1)
c843843e
DR
1264
1265#define sb_has_strict_encoding(sb) \
1266 (sb->s_encoding_flags & SB_ENC_STRICT_MODE_FL)
1267
9e28059d
TT
1268#if IS_ENABLED(CONFIG_UNICODE)
1269#define sb_no_casefold_compat_fallback(sb) \
1270 (sb->s_encoding_flags & SB_ENC_NO_COMPAT_FALLBACK_FL)
1271#else
1272#define sb_no_casefold_compat_fallback(sb) (1)
1273#endif
1274
1da177e4
LT
1275/*
1276 * Umount options
1277 */
1278
1279#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
1280#define MNT_DETACH 0x00000002 /* Just detach from the tree */
1281#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
db1f05bb
MS
1282#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
1283#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
1da177e4 1284
46b15caa
TH
1285/* sb->s_iflags */
1286#define SB_I_CGROUPWB 0x00000001 /* cgroup-aware writeback enabled */
90f8572b 1287#define SB_I_NOEXEC 0x00000002 /* Ignore executables on this fs */
a2982cc9 1288#define SB_I_NODEV 0x00000004 /* Ignore devices on this fs */
1cb039f3 1289#define SB_I_STABLE_WRITES 0x00000008 /* don't modify blks until WB is done */
1da177e4 1290
8654df4e
EB
1291/* sb->s_iflags to limit user namespace mounts */
1292#define SB_I_USERNS_VISIBLE 0x00000010 /* fstype already mounted */
57b56ac6
MZ
1293#define SB_I_IMA_UNVERIFIABLE_SIGNATURE 0x00000020
1294#define SB_I_UNTRUSTED_MOUNTER 0x00000040
1f65e57d 1295#define SB_I_EVM_HMAC_UNSUPPORTED 0x00000080
1da177e4 1296
32b1924b 1297#define SB_I_SKIP_SYNC 0x00000100 /* Skip superblock at global sync */
0b3ea092 1298#define SB_I_PERSB_BDI 0x00000200 /* has a per-sb bdi */
a128b054 1299#define SB_I_TS_EXPIRY_WARNED 0x00000400 /* warned about timestamp range expiry */
04b94071 1300#define SB_I_RETIRED 0x00000800 /* superblock shouldn't be reused */
5aa8fd9c 1301#define SB_I_NOUMASK 0x00001000 /* VFS does not apply umask */
2097154a 1302#define SB_I_NOIDMAP 0x00002000 /* No idmapped mounts on this superblock */
f156524e 1303#define SB_I_ALLOW_HSM 0x00004000 /* Allow HSM events on this superblock */
32b1924b 1304
5accdf82
JK
1305/* Possible states of 'frozen' field */
1306enum {
1307 SB_UNFROZEN = 0, /* FS is unfrozen */
1308 SB_FREEZE_WRITE = 1, /* Writes, dir ops, ioctls frozen */
5accdf82
JK
1309 SB_FREEZE_PAGEFAULT = 2, /* Page faults stopped as well */
1310 SB_FREEZE_FS = 3, /* For internal FS use (e.g. to stop
1311 * internal threads if needed) */
1312 SB_FREEZE_COMPLETE = 4, /* ->freeze_fs finished successfully */
1313};
1314
1315#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1316
1317struct sb_writers {
880b9577 1318 unsigned short frozen; /* Is sb frozen? */
7366f8b6
CB
1319 int freeze_kcount; /* How many kernel freeze requests? */
1320 int freeze_ucount; /* How many userspace freeze requests? */
1af33317 1321 const void *freeze_owner; /* Owner of the freeze */
8129ed29 1322 struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
5accdf82
JK
1323};
1324
1da177e4
LT
1325struct super_block {
1326 struct list_head s_list; /* Keep this first */
1327 dev_t s_dev; /* search index; _not_ kdev_t */
270ba5f7
RK
1328 unsigned char s_blocksize_bits;
1329 unsigned long s_blocksize;
42cb56ae 1330 loff_t s_maxbytes; /* Max file size */
1da177e4 1331 struct file_system_type *s_type;
ee9b6d61 1332 const struct super_operations *s_op;
61e225dc 1333 const struct dquot_operations *dq_op;
0d54b217 1334 const struct quotactl_ops *s_qcop;
39655164 1335 const struct export_operations *s_export_op;
1da177e4 1336 unsigned long s_flags;
46b15caa 1337 unsigned long s_iflags; /* internal SB_I_* flags */
1da177e4
LT
1338 unsigned long s_magic;
1339 struct dentry *s_root;
1340 struct rw_semaphore s_umount;
1da177e4 1341 int s_count;
1da177e4 1342 atomic_t s_active;
50462062 1343#ifdef CONFIG_SECURITY
1da177e4 1344 void *s_security;
50462062 1345#endif
e346fb6d 1346 const struct xattr_handler * const *s_xattr;
643fa961 1347#ifdef CONFIG_FS_ENCRYPTION
0b81d077 1348 const struct fscrypt_operations *s_cop;
d7e7b9af 1349 struct fscrypt_keyring *s_master_keys; /* master crypto keys in use */
5585f2af
EB
1350#endif
1351#ifdef CONFIG_FS_VERITY
1352 const struct fsverity_operations *s_vop;
c843843e 1353#endif
5298d4bf 1354#if IS_ENABLED(CONFIG_UNICODE)
c843843e
DR
1355 struct unicode_map *s_encoding;
1356 __u16 s_encoding_flags;
bbbc3fb6 1357#endif
f1ee6162 1358 struct hlist_bl_head s_roots; /* alternate root dentries for NFS */
39f7c4db 1359 struct list_head s_mounts; /* list of mounts; _not_ for fs use */
f3a60882
CB
1360 struct block_device *s_bdev; /* can go away once we use an accessor for @s_bdev_file */
1361 struct file *s_bdev_file;
32a88aa1 1362 struct backing_dev_info *s_bdi;
acaebfd8 1363 struct mtd_info *s_mtd;
a5166169 1364 struct hlist_node s_instances;
2c5f648a 1365 unsigned int s_quota_types; /* Bitmask of supported quota types */
1da177e4
LT
1366 struct quota_info s_dquot; /* Diskquota specific options */
1367
5accdf82 1368 struct sb_writers s_writers;
1da177e4 1369
99c228a9
AG
1370 /*
1371 * Keep s_fs_info, s_time_gran, s_fsnotify_mask, and
07a3b8d0 1372 * s_fsnotify_info together for cache efficiency. They are frequently
99c228a9
AG
1373 * accessed and rarely modified.
1374 */
1375 void *s_fs_info; /* Filesystem private info */
1376
1377 /* Granularity of c/m/atime in ns (cannot be worse than a second) */
1378 u32 s_time_gran;
188d20bc
DD
1379 /* Time limits for c/m/atime in seconds */
1380 time64_t s_time_min;
1381 time64_t s_time_max;
99c228a9 1382#ifdef CONFIG_FSNOTIFY
71ff58ce 1383 u32 s_fsnotify_mask;
07a3b8d0 1384 struct fsnotify_sb_info *s_fsnotify_info;
99c228a9
AG
1385#endif
1386
ae8c5117
KO
1387 /*
1388 * q: why are s_id and s_sysfs_name not the same? both are human
1389 * readable strings that identify the filesystem
1390 * a: s_id is allowed to change at runtime; it's used in log messages,
1391 * and we want to when a device starts out as single device (s_id is dev
1392 * name) but then a device is hot added and we have to switch to
1393 * identifying it by UUID
1394 * but s_sysfs_name is a handle for programmatic access, and can't
1395 * change at runtime
1396 */
85787090
CH
1397 char s_id[32]; /* Informational name */
1398 uuid_t s_uuid; /* UUID */
a4af51ce 1399 u8 s_uuid_len; /* Default 16, possibly smaller for weird filesystems */
1da177e4 1400
ae8c5117
KO
1401 /* if set, fs shows up under sysfs at /sys/fs/$FSTYP/s_sysfs_name */
1402 char s_sysfs_name[UUID_STRING_LEN + 1];
1da177e4 1403
8de52778 1404 unsigned int s_max_links;
1da177e4
LT
1405
1406 /*
1407 * The next field is for VFS *only*. No filesystems have any business
1408 * even looking at it. You had been warned.
1409 */
a11f3a05 1410 struct mutex s_vfs_rename_mutex; /* Kludge */
1da177e4 1411
79c0b2df
MS
1412 /*
1413 * Filesystem subtype. If non-empty the filesystem type field
1414 * in /proc/mounts will be "type.subtype"
1415 */
a0c9a8b8 1416 const char *s_subtype;
b3b304a2 1417
c8aebb0c 1418 const struct dentry_operations *s_d_op; /* default d_op for dentries */
9fdfdcf1 1419
1720f5dd 1420 struct shrinker *s_shrink; /* per-sb shrinker handle */
4ed5e82f 1421
7ada4db8
MS
1422 /* Number of inodes with nlink == 0 but still referenced */
1423 atomic_long_t s_remove_count;
1424
d7439fb1 1425 /* Read-only state of the superblock is being changed */
4ed5e82f 1426 int s_readonly_remount;
7b7a8665 1427
735e4ae5
JL
1428 /* per-sb errseq_t for reporting writeback errors via syncfs */
1429 errseq_t s_wb_err;
1430
7b7a8665
CH
1431 /* AIO completions deferred from interrupt context */
1432 struct workqueue_struct *s_dio_done_wq;
215752fc 1433 struct hlist_head s_pins;
f6041567 1434
6e4eab57
EB
1435 /*
1436 * Owning user namespace and default context in which to
1437 * interpret filesystem uids, gids, quotas, device nodes,
1438 * xattrs and security labels.
1439 */
1440 struct user_namespace *s_user_ns;
1441
f6041567 1442 /*
7d10f70f
WL
1443 * The list_lru structure is essentially just a pointer to a table
1444 * of per-node lru lists, each of which has its own spinlock.
1445 * There is no need to put them into separate cachelines.
f6041567 1446 */
7d10f70f
WL
1447 struct list_lru s_dentry_lru;
1448 struct list_lru s_inode_lru;
e2fec7c3 1449 struct rcu_head rcu;
853b39a7 1450 struct work_struct destroy_work;
69c433ed 1451
e97fedb9 1452 struct mutex s_sync_lock; /* sync serialisation lock */
69c433ed
MS
1453
1454 /*
1455 * Indicates how deep in a filesystem stack this SB is
1456 */
1457 int s_stack_depth;
74278da9
DC
1458
1459 /* s_inode_list_lock protects s_inodes */
1460 spinlock_t s_inode_list_lock ____cacheline_aligned_in_smp;
1461 struct list_head s_inodes; /* all inodes */
6c60d2b5
DC
1462
1463 spinlock_t s_inode_wblist_lock;
1464 struct list_head s_inodes_wb; /* writeback inodes */
3859a271 1465} __randomize_layout;
1da177e4 1466
a1ec9040
CB
1467static inline struct user_namespace *i_user_ns(const struct inode *inode)
1468{
1469 return inode->i_sb->s_user_ns;
1470}
1471
81754357
SF
1472/* Helper functions so that in most cases filesystems will
1473 * not need to deal directly with kuid_t and kgid_t and can
1474 * instead deal with the raw numeric values that are stored
1475 * in the filesystem.
1476 */
1477static inline uid_t i_uid_read(const struct inode *inode)
1478{
a1ec9040 1479 return from_kuid(i_user_ns(inode), inode->i_uid);
81754357
SF
1480}
1481
1482static inline gid_t i_gid_read(const struct inode *inode)
1483{
a1ec9040 1484 return from_kgid(i_user_ns(inode), inode->i_gid);
81754357
SF
1485}
1486
1487static inline void i_uid_write(struct inode *inode, uid_t uid)
1488{
a1ec9040 1489 inode->i_uid = make_kuid(i_user_ns(inode), uid);
81754357
SF
1490}
1491
1492static inline void i_gid_write(struct inode *inode, gid_t gid)
1493{
a1ec9040 1494 inode->i_gid = make_kgid(i_user_ns(inode), gid);
81754357
SF
1495}
1496
234a3113 1497/**
e67fe633
CB
1498 * i_uid_into_vfsuid - map an inode's i_uid down according to an idmapping
1499 * @idmap: idmap of the mount the inode was found from
234a3113
CB
1500 * @inode: inode to map
1501 *
e67fe633 1502 * Return: whe inode's i_uid mapped down according to @idmap.
234a3113
CB
1503 * If the inode's i_uid has no mapping INVALID_VFSUID is returned.
1504 */
e67fe633 1505static inline vfsuid_t i_uid_into_vfsuid(struct mnt_idmap *idmap,
234a3113
CB
1506 const struct inode *inode)
1507{
4d7ca409 1508 return make_vfsuid(idmap, i_user_ns(inode), inode->i_uid);
e6c9a714
CB
1509}
1510
1f36146a
CB
1511/**
1512 * i_uid_needs_update - check whether inode's i_uid needs to be updated
0dbe12f2 1513 * @idmap: idmap of the mount the inode was found from
1f36146a
CB
1514 * @attr: the new attributes of @inode
1515 * @inode: the inode to update
1516 *
1517 * Check whether the $inode's i_uid field needs to be updated taking idmapped
1518 * mounts into account if the filesystem supports it.
1519 *
1520 * Return: true if @inode's i_uid field needs to be updated, false if not.
1521 */
0dbe12f2 1522static inline bool i_uid_needs_update(struct mnt_idmap *idmap,
1f36146a
CB
1523 const struct iattr *attr,
1524 const struct inode *inode)
1525{
1526 return ((attr->ia_valid & ATTR_UID) &&
1527 !vfsuid_eq(attr->ia_vfsuid,
e67fe633 1528 i_uid_into_vfsuid(idmap, inode)));
1f36146a
CB
1529}
1530
1531/**
1532 * i_uid_update - update @inode's i_uid field
0dbe12f2 1533 * @idmap: idmap of the mount the inode was found from
1f36146a
CB
1534 * @attr: the new attributes of @inode
1535 * @inode: the inode to update
1536 *
1537 * Safely update @inode's i_uid field translating the vfsuid of any idmapped
1538 * mount into the filesystem kuid.
1539 */
0dbe12f2 1540static inline void i_uid_update(struct mnt_idmap *idmap,
1f36146a
CB
1541 const struct iattr *attr,
1542 struct inode *inode)
1543{
1544 if (attr->ia_valid & ATTR_UID)
4d7ca409 1545 inode->i_uid = from_vfsuid(idmap, i_user_ns(inode),
1f36146a
CB
1546 attr->ia_vfsuid);
1547}
1548
234a3113 1549/**
e67fe633
CB
1550 * i_gid_into_vfsgid - map an inode's i_gid down according to an idmapping
1551 * @idmap: idmap of the mount the inode was found from
234a3113
CB
1552 * @inode: inode to map
1553 *
e67fe633 1554 * Return: the inode's i_gid mapped down according to @idmap.
234a3113
CB
1555 * If the inode's i_gid has no mapping INVALID_VFSGID is returned.
1556 */
e67fe633 1557static inline vfsgid_t i_gid_into_vfsgid(struct mnt_idmap *idmap,
234a3113
CB
1558 const struct inode *inode)
1559{
4d7ca409 1560 return make_vfsgid(idmap, i_user_ns(inode), inode->i_gid);
e6c9a714
CB
1561}
1562
1f36146a
CB
1563/**
1564 * i_gid_needs_update - check whether inode's i_gid needs to be updated
0dbe12f2 1565 * @idmap: idmap of the mount the inode was found from
1f36146a
CB
1566 * @attr: the new attributes of @inode
1567 * @inode: the inode to update
1568 *
1569 * Check whether the $inode's i_gid field needs to be updated taking idmapped
1570 * mounts into account if the filesystem supports it.
1571 *
1572 * Return: true if @inode's i_gid field needs to be updated, false if not.
1573 */
0dbe12f2 1574static inline bool i_gid_needs_update(struct mnt_idmap *idmap,
1f36146a
CB
1575 const struct iattr *attr,
1576 const struct inode *inode)
1577{
1578 return ((attr->ia_valid & ATTR_GID) &&
1579 !vfsgid_eq(attr->ia_vfsgid,
e67fe633 1580 i_gid_into_vfsgid(idmap, inode)));
1f36146a
CB
1581}
1582
1583/**
1584 * i_gid_update - update @inode's i_gid field
0dbe12f2 1585 * @idmap: idmap of the mount the inode was found from
1f36146a
CB
1586 * @attr: the new attributes of @inode
1587 * @inode: the inode to update
1588 *
1589 * Safely update @inode's i_gid field translating the vfsgid of any idmapped
1590 * mount into the filesystem kgid.
1591 */
0dbe12f2 1592static inline void i_gid_update(struct mnt_idmap *idmap,
1f36146a
CB
1593 const struct iattr *attr,
1594 struct inode *inode)
1595{
1596 if (attr->ia_valid & ATTR_GID)
4d7ca409 1597 inode->i_gid = from_vfsgid(idmap, i_user_ns(inode),
1f36146a
CB
1598 attr->ia_vfsgid);
1599}
1600
db998553
CB
1601/**
1602 * inode_fsuid_set - initialize inode's i_uid field with callers fsuid
1603 * @inode: inode to initialize
c14329d3 1604 * @idmap: idmap of the mount the inode was found from
db998553
CB
1605 *
1606 * Initialize the i_uid field of @inode. If the inode was found/created via
c14329d3 1607 * an idmapped mount map the caller's fsuid according to @idmap.
db998553
CB
1608 */
1609static inline void inode_fsuid_set(struct inode *inode,
c14329d3 1610 struct mnt_idmap *idmap)
db998553 1611{
c14329d3 1612 inode->i_uid = mapped_fsuid(idmap, i_user_ns(inode));
db998553
CB
1613}
1614
1615/**
1616 * inode_fsgid_set - initialize inode's i_gid field with callers fsgid
1617 * @inode: inode to initialize
c14329d3 1618 * @idmap: idmap of the mount the inode was found from
db998553
CB
1619 *
1620 * Initialize the i_gid field of @inode. If the inode was found/created via
c14329d3 1621 * an idmapped mount map the caller's fsgid according to @idmap.
db998553
CB
1622 */
1623static inline void inode_fsgid_set(struct inode *inode,
c14329d3 1624 struct mnt_idmap *idmap)
db998553 1625{
c14329d3 1626 inode->i_gid = mapped_fsgid(idmap, i_user_ns(inode));
db998553
CB
1627}
1628
8e538913
CB
1629/**
1630 * fsuidgid_has_mapping() - check whether caller's fsuid/fsgid is mapped
1631 * @sb: the superblock we want a mapping in
4609e1f1 1632 * @idmap: idmap of the relevant mount
8e538913
CB
1633 *
1634 * Check whether the caller's fsuid and fsgid have a valid mapping in the
1635 * s_user_ns of the superblock @sb. If the caller is on an idmapped mount map
4609e1f1 1636 * the caller's fsuid and fsgid according to the @idmap first.
8e538913
CB
1637 *
1638 * Return: true if fsuid and fsgid is mapped, false if not.
1639 */
1640static inline bool fsuidgid_has_mapping(struct super_block *sb,
4609e1f1 1641 struct mnt_idmap *idmap)
8e538913 1642{
476860b3
CB
1643 struct user_namespace *fs_userns = sb->s_user_ns;
1644 kuid_t kuid;
1645 kgid_t kgid;
1646
c14329d3 1647 kuid = mapped_fsuid(idmap, fs_userns);
476860b3
CB
1648 if (!uid_valid(kuid))
1649 return false;
c14329d3 1650 kgid = mapped_fsgid(idmap, fs_userns);
476860b3
CB
1651 if (!gid_valid(kgid))
1652 return false;
1653 return kuid_has_mapping(fs_userns, kuid) &&
1654 kgid_has_mapping(fs_userns, kgid);
8e538913
CB
1655}
1656
9b6304c1
JL
1657struct timespec64 current_time(struct inode *inode);
1658struct timespec64 inode_set_ctime_current(struct inode *inode);
7f2c86cb
JL
1659struct timespec64 inode_set_ctime_deleg(struct inode *inode,
1660 struct timespec64 update);
9b6304c1 1661
077c212f
JL
1662static inline time64_t inode_get_atime_sec(const struct inode *inode)
1663{
3aa63a56 1664 return inode->i_atime_sec;
077c212f
JL
1665}
1666
1667static inline long inode_get_atime_nsec(const struct inode *inode)
1668{
3aa63a56 1669 return inode->i_atime_nsec;
077c212f
JL
1670}
1671
1672static inline struct timespec64 inode_get_atime(const struct inode *inode)
1673{
3aa63a56
JL
1674 struct timespec64 ts = { .tv_sec = inode_get_atime_sec(inode),
1675 .tv_nsec = inode_get_atime_nsec(inode) };
1676
1677 return ts;
077c212f
JL
1678}
1679
1680static inline struct timespec64 inode_set_atime_to_ts(struct inode *inode,
1681 struct timespec64 ts)
1682{
3aa63a56
JL
1683 inode->i_atime_sec = ts.tv_sec;
1684 inode->i_atime_nsec = ts.tv_nsec;
077c212f
JL
1685 return ts;
1686}
1687
1688static inline struct timespec64 inode_set_atime(struct inode *inode,
1689 time64_t sec, long nsec)
1690{
1691 struct timespec64 ts = { .tv_sec = sec,
1692 .tv_nsec = nsec };
3aa63a56 1693
077c212f
JL
1694 return inode_set_atime_to_ts(inode, ts);
1695}
1696
1697static inline time64_t inode_get_mtime_sec(const struct inode *inode)
1698{
3aa63a56 1699 return inode->i_mtime_sec;
077c212f
JL
1700}
1701
1702static inline long inode_get_mtime_nsec(const struct inode *inode)
1703{
3aa63a56 1704 return inode->i_mtime_nsec;
077c212f
JL
1705}
1706
1707static inline struct timespec64 inode_get_mtime(const struct inode *inode)
1708{
3aa63a56
JL
1709 struct timespec64 ts = { .tv_sec = inode_get_mtime_sec(inode),
1710 .tv_nsec = inode_get_mtime_nsec(inode) };
1711 return ts;
077c212f
JL
1712}
1713
1714static inline struct timespec64 inode_set_mtime_to_ts(struct inode *inode,
1715 struct timespec64 ts)
1716{
3aa63a56
JL
1717 inode->i_mtime_sec = ts.tv_sec;
1718 inode->i_mtime_nsec = ts.tv_nsec;
077c212f
JL
1719 return ts;
1720}
1721
1722static inline struct timespec64 inode_set_mtime(struct inode *inode,
1723 time64_t sec, long nsec)
1724{
1725 struct timespec64 ts = { .tv_sec = sec,
1726 .tv_nsec = nsec };
1727 return inode_set_mtime_to_ts(inode, ts);
1728}
1729
4e40eff0
JL
1730/*
1731 * Multigrain timestamps
1732 *
1733 * Conditionally use fine-grained ctime and mtime timestamps when there
1734 * are users actively observing them via getattr. The primary use-case
1735 * for this is NFS clients that use the ctime to distinguish between
1736 * different states of the file, and that are often fooled by multiple
1737 * operations that occur in the same coarse-grained timer tick.
1738 */
1739#define I_CTIME_QUERIED ((u32)BIT(31))
1740
077c212f
JL
1741static inline time64_t inode_get_ctime_sec(const struct inode *inode)
1742{
3aa63a56 1743 return inode->i_ctime_sec;
077c212f
JL
1744}
1745
1746static inline long inode_get_ctime_nsec(const struct inode *inode)
1747{
4e40eff0 1748 return inode->i_ctime_nsec & ~I_CTIME_QUERIED;
077c212f
JL
1749}
1750
9b6304c1
JL
1751static inline struct timespec64 inode_get_ctime(const struct inode *inode)
1752{
3aa63a56
JL
1753 struct timespec64 ts = { .tv_sec = inode_get_ctime_sec(inode),
1754 .tv_nsec = inode_get_ctime_nsec(inode) };
1755
1756 return ts;
9b6304c1
JL
1757}
1758
4e40eff0 1759struct timespec64 inode_set_ctime_to_ts(struct inode *inode, struct timespec64 ts);
9b6304c1
JL
1760
1761/**
1762 * inode_set_ctime - set the ctime in the inode
1763 * @inode: inode in which to set the ctime
1764 * @sec: tv_sec value to set
1765 * @nsec: tv_nsec value to set
1766 *
1767 * Set the ctime in @inode to { @sec, @nsec }
1768 */
1769static inline struct timespec64 inode_set_ctime(struct inode *inode,
1770 time64_t sec, long nsec)
1771{
1772 struct timespec64 ts = { .tv_sec = sec,
1773 .tv_nsec = nsec };
1774
1775 return inode_set_ctime_to_ts(inode, ts);
1776}
1da177e4 1777
077c212f
JL
1778struct timespec64 simple_inode_init_ts(struct inode *inode);
1779
1da177e4
LT
1780/*
1781 * Snapshotting support.
1782 */
1da177e4 1783
9b852342
DW
1784/*
1785 * These are internal functions, please use sb_start_{write,pagefault,intwrite}
1786 * instead.
1787 */
1788static inline void __sb_end_write(struct super_block *sb, int level)
1789{
1790 percpu_up_read(sb->s_writers.rw_sem + level-1);
1791}
1792
1793static inline void __sb_start_write(struct super_block *sb, int level)
1794{
f73bae83 1795 percpu_down_read_freezable(sb->s_writers.rw_sem + level - 1, true);
9b852342
DW
1796}
1797
1798static inline bool __sb_start_write_trylock(struct super_block *sb, int level)
1799{
1800 return percpu_down_read_trylock(sb->s_writers.rw_sem + level - 1);
1801}
5accdf82 1802
bee9182d 1803#define __sb_writers_acquired(sb, lev) \
8129ed29 1804 percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
bee9182d 1805#define __sb_writers_release(sb, lev) \
c01a5d89 1806 percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], _THIS_IP_)
bee9182d 1807
8802e580
AG
1808/**
1809 * __sb_write_started - check if sb freeze level is held
1810 * @sb: the super we write to
1811 * @level: the freeze level
1812 *
c39e2ae3
VN
1813 * * > 0 - sb freeze level is held
1814 * * 0 - sb freeze level is not held
1815 * * < 0 - !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN
8802e580
AG
1816 */
1817static inline int __sb_write_started(const struct super_block *sb, int level)
1818{
1819 return lockdep_is_held_type(sb->s_writers.rw_sem + level - 1, 1);
1820}
1821
3d5cd491
AG
1822/**
1823 * sb_write_started - check if SB_FREEZE_WRITE is held
1824 * @sb: the super we write to
1825 *
1826 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
1827 */
7f8d12ea
NA
1828static inline bool sb_write_started(const struct super_block *sb)
1829{
8802e580 1830 return __sb_write_started(sb, SB_FREEZE_WRITE);
7f8d12ea
NA
1831}
1832
21b32e6a
AG
1833/**
1834 * sb_write_not_started - check if SB_FREEZE_WRITE is not held
1835 * @sb: the super we write to
1836 *
1837 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
1838 */
1839static inline bool sb_write_not_started(const struct super_block *sb)
1840{
1841 return __sb_write_started(sb, SB_FREEZE_WRITE) <= 0;
1842}
1843
3d5cd491
AG
1844/**
1845 * file_write_started - check if SB_FREEZE_WRITE is held
1846 * @file: the file we write to
1847 *
1848 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
1849 * May be false positive with !S_ISREG, because file_start_write() has
1850 * no effect on !S_ISREG.
1851 */
1852static inline bool file_write_started(const struct file *file)
1853{
1854 if (!S_ISREG(file_inode(file)->i_mode))
1855 return true;
1856 return sb_write_started(file_inode(file)->i_sb);
1857}
1858
21b32e6a
AG
1859/**
1860 * file_write_not_started - check if SB_FREEZE_WRITE is not held
1861 * @file: the file we write to
1862 *
1863 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
1864 * May be false positive with !S_ISREG, because file_start_write() has
1865 * no effect on !S_ISREG.
1866 */
1867static inline bool file_write_not_started(const struct file *file)
1868{
1869 if (!S_ISREG(file_inode(file)->i_mode))
1870 return true;
1871 return sb_write_not_started(file_inode(file)->i_sb);
7f8d12ea
NA
1872}
1873
5accdf82
JK
1874/**
1875 * sb_end_write - drop write access to a superblock
1876 * @sb: the super we wrote to
1877 *
1878 * Decrement number of writers to the filesystem. Wake up possible waiters
1879 * wanting to freeze the filesystem.
1880 */
1881static inline void sb_end_write(struct super_block *sb)
1882{
1883 __sb_end_write(sb, SB_FREEZE_WRITE);
1884}
1885
1886/**
1887 * sb_end_pagefault - drop write access to a superblock from a page fault
1888 * @sb: the super we wrote to
1889 *
1890 * Decrement number of processes handling write page fault to the filesystem.
1891 * Wake up possible waiters wanting to freeze the filesystem.
1892 */
1893static inline void sb_end_pagefault(struct super_block *sb)
1894{
1895 __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
1896}
1897
1898/**
1899 * sb_end_intwrite - drop write access to a superblock for internal fs purposes
1900 * @sb: the super we wrote to
1901 *
1902 * Decrement fs-internal number of writers to the filesystem. Wake up possible
1903 * waiters wanting to freeze the filesystem.
1904 */
1905static inline void sb_end_intwrite(struct super_block *sb)
1906{
1907 __sb_end_write(sb, SB_FREEZE_FS);
1908}
1909
1910/**
1911 * sb_start_write - get write access to a superblock
1912 * @sb: the super we write to
1913 *
1914 * When a process wants to write data or metadata to a file system (i.e. dirty
1915 * a page or an inode), it should embed the operation in a sb_start_write() -
1916 * sb_end_write() pair to get exclusion against file system freezing. This
1917 * function increments number of writers preventing freezing. If the file
1918 * system is already frozen, the function waits until the file system is
1919 * thawed.
1920 *
1921 * Since freeze protection behaves as a lock, users have to preserve
1922 * ordering of freeze protection and other filesystem locks. Generally,
1923 * freeze protection should be the outermost lock. In particular, we have:
1924 *
1925 * sb_start_write
1926 * -> i_mutex (write path, truncate, directory ops, ...)
1927 * -> s_umount (freeze_super, thaw_super)
1928 */
1929static inline void sb_start_write(struct super_block *sb)
1930{
8a3c84b6 1931 __sb_start_write(sb, SB_FREEZE_WRITE);
5accdf82
JK
1932}
1933
8a3c84b6 1934static inline bool sb_start_write_trylock(struct super_block *sb)
5accdf82 1935{
8a3c84b6 1936 return __sb_start_write_trylock(sb, SB_FREEZE_WRITE);
5accdf82
JK
1937}
1938
1939/**
1940 * sb_start_pagefault - get write access to a superblock from a page fault
1941 * @sb: the super we write to
1942 *
1943 * When a process starts handling write page fault, it should embed the
1944 * operation into sb_start_pagefault() - sb_end_pagefault() pair to get
1945 * exclusion against file system freezing. This is needed since the page fault
1946 * is going to dirty a page. This function increments number of running page
1947 * faults preventing freezing. If the file system is already frozen, the
1948 * function waits until the file system is thawed.
1949 *
1950 * Since page fault freeze protection behaves as a lock, users have to preserve
1951 * ordering of freeze protection and other filesystem locks. It is advised to
c1e8d7c6 1952 * put sb_start_pagefault() close to mmap_lock in lock ordering. Page fault
5accdf82
JK
1953 * handling code implies lock dependency:
1954 *
c1e8d7c6 1955 * mmap_lock
5accdf82
JK
1956 * -> sb_start_pagefault
1957 */
1958static inline void sb_start_pagefault(struct super_block *sb)
1959{
8a3c84b6 1960 __sb_start_write(sb, SB_FREEZE_PAGEFAULT);
5accdf82
JK
1961}
1962
39015399 1963/**
5accdf82
JK
1964 * sb_start_intwrite - get write access to a superblock for internal fs purposes
1965 * @sb: the super we write to
1966 *
1967 * This is the third level of protection against filesystem freezing. It is
1968 * free for use by a filesystem. The only requirement is that it must rank
1969 * below sb_start_pagefault.
1970 *
1971 * For example filesystem can call sb_start_intwrite() when starting a
1972 * transaction which somewhat eases handling of freezing for internal sources
1973 * of filesystem changes (internal fs threads, discarding preallocation on file
1974 * close, etc.).
1975 */
1976static inline void sb_start_intwrite(struct super_block *sb)
1977{
8a3c84b6 1978 __sb_start_write(sb, SB_FREEZE_FS);
5accdf82 1979}
1da177e4 1980
8a3c84b6 1981static inline bool sb_start_intwrite_trylock(struct super_block *sb)
0c8e3fe3 1982{
8a3c84b6 1983 return __sb_start_write_trylock(sb, SB_FREEZE_FS);
0c8e3fe3
AG
1984}
1985
01beba79 1986bool inode_owner_or_capable(struct mnt_idmap *idmap,
21cb47be 1987 const struct inode *inode);
3bd858ab 1988
1da177e4
LT
1989/*
1990 * VFS helper functions..
1991 */
abf08576 1992int vfs_create(struct mnt_idmap *, struct inode *,
6521f891 1993 struct dentry *, umode_t, bool);
c54b3869
N
1994struct dentry *vfs_mkdir(struct mnt_idmap *, struct inode *,
1995 struct dentry *, umode_t);
abf08576 1996int vfs_mknod(struct mnt_idmap *, struct inode *, struct dentry *,
6521f891 1997 umode_t, dev_t);
abf08576 1998int vfs_symlink(struct mnt_idmap *, struct inode *,
6521f891 1999 struct dentry *, const char *);
abf08576 2000int vfs_link(struct dentry *, struct mnt_idmap *, struct inode *,
6521f891 2001 struct dentry *, struct inode **);
abf08576
CB
2002int vfs_rmdir(struct mnt_idmap *, struct inode *, struct dentry *);
2003int vfs_unlink(struct mnt_idmap *, struct inode *, struct dentry *,
6521f891 2004 struct inode **);
9fe61450 2005
92cb01c7
CB
2006/**
2007 * struct renamedata - contains all information required for renaming
abf08576 2008 * @old_mnt_idmap: idmap of the old mount the inode was found from
92cb01c7
CB
2009 * @old_dir: parent of source
2010 * @old_dentry: source
abf08576 2011 * @new_mnt_idmap: idmap of the new mount the inode was found from
92cb01c7
CB
2012 * @new_dir: parent of destination
2013 * @new_dentry: destination
2014 * @delegated_inode: returns an inode needing a delegation break
2015 * @flags: rename flags
2016 */
9fe61450 2017struct renamedata {
abf08576 2018 struct mnt_idmap *old_mnt_idmap;
9fe61450
CB
2019 struct inode *old_dir;
2020 struct dentry *old_dentry;
abf08576 2021 struct mnt_idmap *new_mnt_idmap;
9fe61450
CB
2022 struct inode *new_dir;
2023 struct dentry *new_dentry;
2024 struct inode **delegated_inode;
2025 unsigned int flags;
2026} __randomize_layout;
a3c751a5 2027
9fe61450 2028int vfs_rename(struct renamedata *);
a3c751a5 2029
abf08576 2030static inline int vfs_whiteout(struct mnt_idmap *idmap,
6521f891 2031 struct inode *dir, struct dentry *dentry)
a3c751a5 2032{
abf08576 2033 return vfs_mknod(idmap, dir, dentry, S_IFCHR | WHITEOUT_MODE,
6521f891 2034 WHITEOUT_DEV);
a3c751a5 2035}
1da177e4 2036
d56e0ddb
AG
2037struct file *kernel_tmpfile_open(struct mnt_idmap *idmap,
2038 const struct path *parentpath,
2039 umode_t mode, int open_flag,
2040 const struct cred *cred);
cbb0b9d4 2041struct file *kernel_file_open(const struct path *path, int flags,
af58dc1f 2042 const struct cred *cred);
af7bd4dc 2043
8e6c848e
AV
2044int vfs_mkobj(struct dentry *, umode_t,
2045 int (*f)(struct dentry *, umode_t, void *),
2046 void *);
2047
c04011fe 2048int vfs_fchown(struct file *file, uid_t user, gid_t group);
9e96c8c0 2049int vfs_fchmod(struct file *file, umode_t mode);
fd5ad30c 2050int vfs_utimes(const struct path *path, struct timespec64 *times);
c04011fe 2051
f326565c 2052int vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
9df6702a 2053
2952db0f
AB
2054#ifdef CONFIG_COMPAT
2055extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
2056 unsigned long arg);
2057#else
2058#define compat_ptr_ioctl NULL
2059#endif
2060
8c744fb8
CH
2061/*
2062 * VFS file helper functions.
2063 */
f2d40141 2064void inode_init_owner(struct mnt_idmap *idmap, struct inode *inode,
21cb47be 2065 const struct inode *dir, umode_t mode);
a2982cc9 2066extern bool may_open_dev(const struct path *path);
9452e93e 2067umode_t mode_strip_sgid(struct mnt_idmap *idmap,
2b3416ce 2068 const struct inode *dir, umode_t mode);
9b6a14f0
YT
2069bool in_group_or_capable(struct mnt_idmap *idmap,
2070 const struct inode *inode, vfsgid_t vfsgid);
c4b929b8 2071
1da177e4
LT
2072/*
2073 * This is the "filldir" function type, used by readdir() to let
2074 * the kernel specify what kind of dirent layout it wants to have.
2075 * This allows the kernel to read directories into kernel space or
2076 * to have different dirent layouts depending on the binary type.
25885a35 2077 * Return 'true' to keep going and 'false' if there are no more entries.
1da177e4 2078 */
ac7576f4 2079struct dir_context;
25885a35 2080typedef bool (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
ac7576f4
MS
2081 unsigned);
2082
5c0ba4e0 2083struct dir_context {
a09acf4b 2084 filldir_t actor;
bb6f619b 2085 loff_t pos;
e0410e95
MS
2086 /*
2087 * Filesystems MUST NOT MODIFY count, but may use as a hint:
2088 * 0 unknown
2089 * > 0 space in buffer (assume at least one entry)
2090 * INT_MAX unlimited
2091 */
2092 int count;
5c0ba4e0 2093};
bb6f619b 2094
8d911700
MS
2095/* If OR-ed with d_type, pending signals are not checked */
2096#define FILLDIR_FLAG_NOINTR 0x1000
2097
b4caecd4
CH
2098/*
2099 * These flags let !MMU mmap() govern direct device mapping vs immediate
2100 * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
2101 *
2102 * NOMMU_MAP_COPY: Copy can be mapped (MAP_PRIVATE)
2103 * NOMMU_MAP_DIRECT: Can be mapped directly (MAP_SHARED)
2104 * NOMMU_MAP_READ: Can be mapped for reading
2105 * NOMMU_MAP_WRITE: Can be mapped for writing
2106 * NOMMU_MAP_EXEC: Can be mapped for execution
2107 */
2108#define NOMMU_MAP_COPY 0x00000001
2109#define NOMMU_MAP_DIRECT 0x00000008
2110#define NOMMU_MAP_READ VM_MAYREAD
2111#define NOMMU_MAP_WRITE VM_MAYWRITE
2112#define NOMMU_MAP_EXEC VM_MAYEXEC
2113
2114#define NOMMU_VMFLAGS \
2115 (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
2116
2e5dfc99
DW
2117/*
2118 * These flags control the behavior of the remap_file_range function pointer.
2119 * If it is called with len == 0 that means "remap to end of source file".
5c437fa2 2120 * See Documentation/filesystems/vfs.rst for more details about this call.
2e5dfc99
DW
2121 *
2122 * REMAP_FILE_DEDUP: only remap if contents identical (i.e. deduplicate)
eca3654e 2123 * REMAP_FILE_CAN_SHORTEN: caller can handle a shortened request
2e5dfc99
DW
2124 */
2125#define REMAP_FILE_DEDUP (1 << 0)
eca3654e 2126#define REMAP_FILE_CAN_SHORTEN (1 << 1)
2e5dfc99
DW
2127
2128/*
2129 * These flags signal that the caller is ok with altering various aspects of
2130 * the behavior of the remap operation. The changes must be made by the
2131 * implementation; the vfs remap helper functions can take advantage of them.
2132 * Flags in this category exist to preserve the quirky behavior of the hoisted
2133 * btrfs clone/dedupe ioctls.
2e5dfc99 2134 */
eca3654e 2135#define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN)
b4caecd4 2136
10bc8e4a
AG
2137/*
2138 * These flags control the behavior of vfs_copy_file_range().
2139 * They are not available to the user via syscall.
2140 *
2141 * COPY_FILE_SPLICE: call splice direct instead of fs clone/copy ops
2142 */
2143#define COPY_FILE_SPLICE (1 << 0)
2144
293bc982 2145struct iov_iter;
ee692a21 2146struct io_uring_cmd;
6faddda6 2147struct offset_ctx;
293bc982 2148
210a03c9
CB
2149typedef unsigned int __bitwise fop_flags_t;
2150
1da177e4
LT
2151struct file_operations {
2152 struct module *owner;
210a03c9 2153 fop_flags_t fop_flags;
1da177e4
LT
2154 loff_t (*llseek) (struct file *, loff_t, int);
2155 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1da177e4 2156 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
293bc982
AV
2157 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
2158 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
5a72e899
JA
2159 int (*iopoll)(struct kiocb *kiocb, struct io_comp_batch *,
2160 unsigned int flags);
61922694 2161 int (*iterate_shared) (struct file *, struct dir_context *);
a3f8683b 2162 __poll_t (*poll) (struct file *, struct poll_table_struct *);
1da177e4
LT
2163 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
2164 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
2165 int (*mmap) (struct file *, struct vm_area_struct *);
2166 int (*open) (struct inode *, struct file *);
75e1fcc0 2167 int (*flush) (struct file *, fl_owner_t id);
1da177e4 2168 int (*release) (struct inode *, struct file *);
02c24a82 2169 int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1da177e4
LT
2170 int (*fasync) (int, struct file *, int);
2171 int (*lock) (struct file *, int, struct file_lock *);
1da177e4
LT
2172 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
2173 int (*check_flags)(int);
1da177e4 2174 int (*flock) (struct file *, int, struct file_lock *);
cbb7e577
JA
2175 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
2176 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
2bfc6685 2177 void (*splice_eof)(struct file *file);
c69ff407 2178 int (*setlease)(struct file *, int, struct file_lease **, void **);
2fe17c10
CH
2179 long (*fallocate)(struct file *file, int mode, loff_t offset,
2180 loff_t len);
a3816ab0 2181 void (*show_fdinfo)(struct seq_file *m, struct file *f);
b4caecd4
CH
2182#ifndef CONFIG_MMU
2183 unsigned (*mmap_capabilities)(struct file *);
2184#endif
04b38d60
CH
2185 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
2186 loff_t, size_t, unsigned int);
42ec3d4c
DW
2187 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
2188 struct file *file_out, loff_t pos_out,
2189 loff_t len, unsigned int remap_flags);
45cd0faa 2190 int (*fadvise)(struct file *, loff_t, loff_t, int);
ee692a21 2191 int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags);
de97fcb3
JA
2192 int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *,
2193 unsigned int poll_flags);
c84bf6dd 2194 int (*mmap_prepare)(struct vm_area_desc *);
3859a271 2195} __randomize_layout;
1da177e4 2196
210a03c9
CB
2197/* Supports async buffered reads */
2198#define FOP_BUFFER_RASYNC ((__force fop_flags_t)(1 << 0))
2199/* Supports async buffered writes */
2200#define FOP_BUFFER_WASYNC ((__force fop_flags_t)(1 << 1))
2201/* Supports synchronous page faults for mappings */
2202#define FOP_MMAP_SYNC ((__force fop_flags_t)(1 << 2))
2203/* Supports non-exclusive O_DIRECT writes from multiple threads */
2204#define FOP_DIO_PARALLEL_WRITE ((__force fop_flags_t)(1 << 3))
886b94d2
MWO
2205/* Contains huge pages */
2206#define FOP_HUGE_PAGES ((__force fop_flags_t)(1 << 4))
641bb439
CB
2207/* Treat loff_t as unsigned (e.g., /dev/mem) */
2208#define FOP_UNSIGNED_OFFSET ((__force fop_flags_t)(1 << 5))
8cf9a01e 2209/* Supports asynchronous lock callbacks */
09ee2a67 2210#define FOP_ASYNC_LOCK ((__force fop_flags_t)(1 << 6))
af6505e5 2211/* File system supports uncached read/write buffered IO */
7b2b67db 2212#define FOP_DONTCACHE ((__force fop_flags_t)(1 << 7))
210a03c9 2213
3e327154
LT
2214/* Wrap a directory iterator that needs exclusive inode access */
2215int wrap_directory_iterator(struct file *, struct dir_context *,
2216 int (*) (struct file *, struct dir_context *));
2217#define WRAP_DIR_ITER(x) \
2218 static int shared_##x(struct file *file , struct dir_context *ctx) \
2219 { return wrap_directory_iterator(file, ctx, x); }
2220
1da177e4 2221struct inode_operations {
00cd8dd3 2222 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
fceef393 2223 const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
4609e1f1 2224 int (*permission) (struct mnt_idmap *, struct inode *, int);
cac2f8b8 2225 struct posix_acl * (*get_inode_acl)(struct inode *, int, bool);
44a7d7a8
NP
2226
2227 int (*readlink) (struct dentry *, char __user *,int);
44a7d7a8 2228
6c960e68 2229 int (*create) (struct mnt_idmap *, struct inode *,struct dentry *,
549c7297 2230 umode_t, bool);
1da177e4
LT
2231 int (*link) (struct dentry *,struct inode *,struct dentry *);
2232 int (*unlink) (struct inode *,struct dentry *);
7a77db95 2233 int (*symlink) (struct mnt_idmap *, struct inode *,struct dentry *,
549c7297 2234 const char *);
88d5baf6
N
2235 struct dentry *(*mkdir) (struct mnt_idmap *, struct inode *,
2236 struct dentry *, umode_t);
1da177e4 2237 int (*rmdir) (struct inode *,struct dentry *);
5ebb29be 2238 int (*mknod) (struct mnt_idmap *, struct inode *,struct dentry *,
549c7297 2239 umode_t,dev_t);
e18275ae 2240 int (*rename) (struct mnt_idmap *, struct inode *, struct dentry *,
520c8b16 2241 struct inode *, struct dentry *, unsigned int);
c1632a0f 2242 int (*setattr) (struct mnt_idmap *, struct dentry *, struct iattr *);
b74d24f7 2243 int (*getattr) (struct mnt_idmap *, const struct path *,
549c7297 2244 struct kstat *, u32, unsigned int);
1da177e4 2245 ssize_t (*listxattr) (struct dentry *, char *, size_t);
c4b929b8
MF
2246 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
2247 u64 len);
913e9928 2248 int (*update_time)(struct inode *, int);
d9585277 2249 int (*atomic_open)(struct inode *, struct dentry *,
30d90494 2250 struct file *, unsigned open_flag,
44907d79 2251 umode_t create_mode);
011e2b71 2252 int (*tmpfile) (struct mnt_idmap *, struct inode *,
863f144f 2253 struct file *, umode_t);
77435322 2254 struct posix_acl *(*get_acl)(struct mnt_idmap *, struct dentry *,
7420332a 2255 int);
13e83a49 2256 int (*set_acl)(struct mnt_idmap *, struct dentry *,
549c7297 2257 struct posix_acl *, int);
8782a9ae 2258 int (*fileattr_set)(struct mnt_idmap *idmap,
4c5b4799
MS
2259 struct dentry *dentry, struct fileattr *fa);
2260 int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);
6faddda6 2261 struct offset_ctx *(*get_offset_ctx)(struct inode *inode);
44a7d7a8 2262} ____cacheline_aligned;
1da177e4 2263
c84bf6dd
LS
2264/* Did the driver provide valid mmap hook configuration? */
2265static inline bool file_has_valid_mmap_hooks(struct file *file)
2266{
2267 bool has_mmap = file->f_op->mmap;
2268 bool has_mmap_prepare = file->f_op->mmap_prepare;
2269
2270 /* Hooks are mutually exclusive. */
2271 if (WARN_ON_ONCE(has_mmap && has_mmap_prepare))
2272 return false;
6669d1aa 2273 if (!has_mmap && !has_mmap_prepare)
c84bf6dd
LS
2274 return false;
2275
2276 return true;
2277}
2278
bb666b7c
LS
2279int compat_vma_mmap_prepare(struct file *file, struct vm_area_struct *vma);
2280
f74ac015
MS
2281static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
2282{
bb666b7c
LS
2283 if (file->f_op->mmap_prepare)
2284 return compat_vma_mmap_prepare(file, vma);
c84bf6dd 2285
f74ac015
MS
2286 return file->f_op->mmap(file, vma);
2287}
2288
c84bf6dd
LS
2289static inline int __call_mmap_prepare(struct file *file,
2290 struct vm_area_desc *desc)
2291{
2292 return file->f_op->mmap_prepare(desc);
2293}
2294
1da177e4
LT
2295extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
2296extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
29732938
ZB
2297extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
2298 loff_t, size_t, unsigned int);
5b9932f6 2299int remap_verify_area(struct file *file, loff_t pos, loff_t len, bool write);
6f7db389
SR
2300int __generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2301 struct file *file_out, loff_t pos_out,
2302 loff_t *len, unsigned int remap_flags,
2303 const struct iomap_ops *dax_read_ops);
2304int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2305 struct file *file_out, loff_t pos_out,
2306 loff_t *count, unsigned int remap_flags);
42ec3d4c
DW
2307extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
2308 struct file *file_out, loff_t pos_out,
452ce659 2309 loff_t len, unsigned int remap_flags);
54dbc151
DW
2310extern int vfs_dedupe_file_range(struct file *file,
2311 struct file_dedupe_range *same);
42ec3d4c
DW
2312extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
2313 struct file *dst_file, loff_t dst_pos,
df365836 2314 loff_t len, unsigned int remap_flags);
f1825366 2315
7366f8b6
CB
2316/**
2317 * enum freeze_holder - holder of the freeze
2318 * @FREEZE_HOLDER_KERNEL: kernel wants to freeze or thaw filesystem
2319 * @FREEZE_HOLDER_USERSPACE: userspace wants to freeze or thaw filesystem
2320 * @FREEZE_MAY_NEST: whether nesting freeze and thaw requests is allowed
1af33317 2321 * @FREEZE_EXCL: a freeze that can only be undone by the owner
7366f8b6
CB
2322 *
2323 * Indicate who the owner of the freeze or thaw request is and whether
2324 * the freeze needs to be exclusive or can nest.
2325 * Without @FREEZE_MAY_NEST, multiple freeze and thaw requests from the
2326 * same holder aren't allowed. It is however allowed to hold a single
2327 * @FREEZE_HOLDER_USERSPACE and a single @FREEZE_HOLDER_KERNEL freeze at
2328 * the same time. This is relied upon by some filesystems during online
2329 * repair or similar.
2330 */
880b9577
DW
2331enum freeze_holder {
2332 FREEZE_HOLDER_KERNEL = (1U << 0),
2333 FREEZE_HOLDER_USERSPACE = (1U << 1),
7366f8b6 2334 FREEZE_MAY_NEST = (1U << 2),
1af33317 2335 FREEZE_EXCL = (1U << 3),
880b9577 2336};
1da177e4 2337
1da177e4
LT
2338struct super_operations {
2339 struct inode *(*alloc_inode)(struct super_block *sb);
2340 void (*destroy_inode)(struct inode *);
fdb0da89 2341 void (*free_inode)(struct inode *);
1da177e4 2342
aa385729 2343 void (*dirty_inode) (struct inode *, int flags);
a9185b41 2344 int (*write_inode) (struct inode *, struct writeback_control *wbc);
45321ac5 2345 int (*drop_inode) (struct inode *);
be7ce416 2346 void (*evict_inode) (struct inode *);
1da177e4 2347 void (*put_super) (struct super_block *);
1da177e4 2348 int (*sync_fs)(struct super_block *sb, int wait);
1af33317 2349 int (*freeze_super) (struct super_block *, enum freeze_holder who, const void *owner);
c4be0c1d 2350 int (*freeze_fs) (struct super_block *);
1af33317 2351 int (*thaw_super) (struct super_block *, enum freeze_holder who, const void *owner);
c4be0c1d 2352 int (*unfreeze_fs) (struct super_block *);
726c3342 2353 int (*statfs) (struct dentry *, struct kstatfs *);
1da177e4 2354 int (*remount_fs) (struct super_block *, int *, char *);
42faad99 2355 void (*umount_begin) (struct super_block *);
1da177e4 2356
34c80b1d 2357 int (*show_options)(struct seq_file *, struct dentry *);
d861c630 2358 int (*show_devname)(struct seq_file *, struct dentry *);
a6322de6 2359 int (*show_path)(struct seq_file *, struct dentry *);
64132379 2360 int (*show_stats)(struct seq_file *, struct dentry *);
0e51a720 2361#ifdef CONFIG_QUOTA
1da177e4
LT
2362 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
2363 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
ccb49011 2364 struct dquot __rcu **(*get_dquots)(struct inode *);
0e51a720 2365#endif
4101b624
VD
2366 long (*nr_cached_objects)(struct super_block *,
2367 struct shrink_control *);
2368 long (*free_cached_objects)(struct super_block *,
2369 struct shrink_control *);
87efb390 2370 void (*shutdown)(struct super_block *sb);
1da177e4
LT
2371};
2372
bbc1096a
DH
2373/*
2374 * Inode flags - they have no relation to superblock flags now
2375 */
6414e9b0
EB
2376#define S_SYNC (1 << 0) /* Writes are synced at once */
2377#define S_NOATIME (1 << 1) /* Do not update access times */
2378#define S_APPEND (1 << 2) /* Append-only file */
2379#define S_IMMUTABLE (1 << 3) /* Immutable file */
2380#define S_DEAD (1 << 4) /* removed, but still open directory */
2381#define S_NOQUOTA (1 << 5) /* Inode is not counted to quota */
2382#define S_DIRSYNC (1 << 6) /* Directory modifications are synchronous */
2383#define S_NOCMTIME (1 << 7) /* Do not update file c/mtime */
2384#define S_SWAPFILE (1 << 8) /* Do not truncate: swapon got its bmaps */
2385#define S_PRIVATE (1 << 9) /* Inode is fs-internal */
2386#define S_IMA (1 << 10) /* Inode has an associated IMA struct */
2387#define S_AUTOMOUNT (1 << 11) /* Automount/referral quasi-directory */
2388#define S_NOSEC (1 << 12) /* no suid or xattr security attributes */
6cd176a5 2389#ifdef CONFIG_FS_DAX
6414e9b0 2390#define S_DAX (1 << 13) /* Direct Access, avoiding the page cache */
fbbbad4b 2391#else
6414e9b0 2392#define S_DAX 0 /* Make all the DAX code disappear */
fbbbad4b 2393#endif
6414e9b0
EB
2394#define S_ENCRYPTED (1 << 14) /* Encrypted file (using fs/crypto/) */
2395#define S_CASEFOLD (1 << 15) /* Casefolded file */
2396#define S_VERITY (1 << 16) /* Verity file (using fs/verity/) */
1bd9c4e4 2397#define S_KERNEL_FILE (1 << 17) /* File is in use by the kernel (eg. fs/cachefiles) */
19bbfe7b 2398#define S_ANON_INODE (1 << 19) /* Inode is an anonymous inode */
bbc1096a
DH
2399
2400/*
2401 * Note that nosuid etc flags are inode-specific: setting some file-system
2402 * flags just means all the inodes inherit those flags by default. It might be
2403 * possible to override it selectively if you really wanted to with some
2404 * ioctl() that is not currently implemented.
2405 *
e462ec50 2406 * Exception: SB_RDONLY is always applied to the entire file system.
bbc1096a
DH
2407 *
2408 * Unfortunately, it is possible to change a filesystems flags with it mounted
2409 * with files in use. This means that all of the inodes will not have their
2410 * i_flags updated. Hence, i_flags no longer inherit the superblock mount
2411 * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
2412 */
2413#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
2414
1751e8a6 2415static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
94e92e7a 2416#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
e462ec50 2417#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
bbc1096a 2418 ((inode)->i_flags & S_SYNC))
e462ec50 2419#define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \
bbc1096a 2420 ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
e462ec50
DH
2421#define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK)
2422#define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY|SB_NOATIME)
2423#define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION)
bbc1096a
DH
2424
2425#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
2426#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
2427#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
e4e8b47a
MK
2428
2429#ifdef CONFIG_FS_POSIX_ACL
e462ec50 2430#define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL)
e4e8b47a
MK
2431#else
2432#define IS_POSIXACL(inode) 0
2433#endif
bbc1096a
DH
2434
2435#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
2436#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
e964fc77
AD
2437
2438#ifdef CONFIG_SWAP
bbc1096a 2439#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
e964fc77
AD
2440#else
2441#define IS_SWAPFILE(inode) ((void)(inode), 0U)
2442#endif
2443
bbc1096a
DH
2444#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2445#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2446#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2447#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
fbbbad4b 2448#define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2ee6a576 2449#define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
b886ee3e 2450#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
5585f2af 2451#define IS_VERITY(inode) ((inode)->i_flags & S_VERITY)
bbc1096a 2452
787fb6bc
MS
2453#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2454 (inode)->i_rdev == WHITEOUT_DEV)
19bbfe7b 2455#define IS_ANON_FILE(inode) ((inode)->i_flags & S_ANON_INODE)
787fb6bc 2456
4609e1f1 2457static inline bool HAS_UNMAPPED_ID(struct mnt_idmap *idmap,
ba73d987 2458 struct inode *inode)
0bd23d09 2459{
e67fe633
CB
2460 return !vfsuid_valid(i_uid_into_vfsuid(idmap, inode)) ||
2461 !vfsgid_valid(i_gid_into_vfsgid(idmap, inode));
0bd23d09
EB
2462}
2463
c75b1d94
JA
2464static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
2465{
2466 *kiocb = (struct kiocb) {
2467 .ki_filp = filp,
164f4064 2468 .ki_flags = filp->f_iocb_flags,
20578bdf 2469 .ki_ioprio = get_current_ioprio(),
c75b1d94
JA
2470 };
2471}
2472
5dcdc43e
JX
2473static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
2474 struct file *filp)
2475{
2476 *kiocb = (struct kiocb) {
2477 .ki_filp = filp,
2478 .ki_flags = kiocb_src->ki_flags,
5dcdc43e
JX
2479 .ki_ioprio = kiocb_src->ki_ioprio,
2480 .ki_pos = kiocb_src->ki_pos,
2481 };
2482}
2483
1c0eeaf5 2484/*
250df6ed 2485 * Inode state bits. Protected by inode->i_lock
1c0eeaf5 2486 *
1e9d6333
EB
2487 * Four bits determine the dirty state of the inode: I_DIRTY_SYNC,
2488 * I_DIRTY_DATASYNC, I_DIRTY_PAGES, and I_DIRTY_TIME.
1c0eeaf5
JE
2489 *
2490 * Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
2491 * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
2492 * various stages of removing an inode.
2493 *
eaff8079 2494 * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
1c0eeaf5 2495 *
e7ca2d41 2496 * I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
1e9d6333
EB
2497 * fdatasync() (unless I_DIRTY_DATASYNC is also set).
2498 * Timestamp updates are the usual cause.
2499 * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
000cb48e
JK
2500 * these changes separately from I_DIRTY_SYNC so that we
2501 * don't have to write inode on fdatasync() when only
1e9d6333 2502 * e.g. the timestamps have changed.
1c0eeaf5 2503 * I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
cbfecb92 2504 * I_DIRTY_TIME The inode itself has dirty timestamps, and the
1e9d6333
EB
2505 * lazytime mount option is enabled. We keep track of this
2506 * separately from I_DIRTY_SYNC in order to implement
2507 * lazytime. This gets cleared if I_DIRTY_INODE
cbfecb92
LC
2508 * (I_DIRTY_SYNC and/or I_DIRTY_DATASYNC) gets set. But
2509 * I_DIRTY_TIME can still be set if I_DIRTY_SYNC is already
2510 * in place because writeback might already be in progress
2511 * and we don't want to lose the time update
eaff8079
CH
2512 * I_NEW Serves as both a mutex and completion notification.
2513 * New inodes set I_NEW. If two processes both create
2514 * the same inode, one of them will release its inode and
2515 * wait for I_NEW to be released before returning.
2516 * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
2517 * also cause waiting on I_NEW, without I_NEW actually
2518 * being set. find_inode() uses this to prevent returning
2519 * nearly-dead inodes.
1c0eeaf5
JE
2520 * I_WILL_FREE Must be set when calling write_inode_now() if i_count
2521 * is zero. I_FREEING must be set when I_WILL_FREE is
2522 * cleared.
2523 * I_FREEING Set when inode is about to be freed but still has dirty
2524 * pages or buffers attached or the inode itself is still
2525 * dirty.
dbd5768f
JK
2526 * I_CLEAR Added by clear_inode(). In this state the inode is
2527 * clean and can be destroyed. Inode keeps I_FREEING.
1c0eeaf5
JE
2528 *
2529 * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
2530 * prohibited for many purposes. iget() must wait for
2531 * the inode to be completely released, then create it
2532 * anew. Other functions will just ignore such inodes,
eaff8079 2533 * if appropriate. I_NEW is used for waiting.
1c0eeaf5 2534 *
169ebd90
JK
2535 * I_SYNC Writeback of inode is running. The bit is set during
2536 * data writeback, and cleared with a wakeup on the bit
2537 * address once it is done. The bit is also used to pin
2538 * the inode in memory for flusher thread.
1c0eeaf5 2539 *
bd5fe6c5
CH
2540 * I_REFERENCED Marks the inode as recently references on the LRU list.
2541 *
682aa8e1
TH
2542 * I_WB_SWITCH Cgroup bdi_writeback switching in progress. Used to
2543 * synchronize competing switching instances and to tell
b93b0163 2544 * wb stat updates to grab the i_pages lock. See
a9519def 2545 * inode_switch_wbs_work_fn() for details.
682aa8e1 2546 *
ad0af710
AG
2547 * I_OVL_INUSE Used by overlayfs to get exclusive ownership on upper
2548 * and work dirs among overlayfs mounts.
2549 *
c2b6d621
AV
2550 * I_CREATING New object's inode in the middle of setting up.
2551 *
dae2f8ed
IW
2552 * I_DONTCACHE Evict inode as soon as it is not used anymore.
2553 *
5afced3b
JK
2554 * I_SYNC_QUEUED Inode is queued in b_io or b_more_io writeback lists.
2555 * Used to detect that mark_inode_dirty() should not move
2556 * inode between dirty lists.
2557 *
08276bda
DH
2558 * I_PINNING_FSCACHE_WB Inode is pinning an fscache object for writeback.
2559 *
2a062983
ZC
2560 * I_LRU_ISOLATING Inode is pinned being isolated from LRU without holding
2561 * i_count.
2562 *
1c0eeaf5 2563 * Q: What is the difference between I_WILL_FREE and I_FREEING?
2ed634c9
CB
2564 *
2565 * __I_{SYNC,NEW,LRU_ISOLATING} are used to derive unique addresses to wait
2566 * upon. There's one free address left.
1c0eeaf5 2567 */
2ed634c9 2568#define __I_NEW 0
eaff8079 2569#define I_NEW (1 << __I_NEW)
2ed634c9 2570#define __I_SYNC 1
1c0eeaf5 2571#define I_SYNC (1 << __I_SYNC)
2ed634c9
CB
2572#define __I_LRU_ISOLATING 2
2573#define I_LRU_ISOLATING (1 << __I_LRU_ISOLATING)
2574
2575#define I_DIRTY_SYNC (1 << 3)
2576#define I_DIRTY_DATASYNC (1 << 4)
2577#define I_DIRTY_PAGES (1 << 5)
2578#define I_WILL_FREE (1 << 6)
2579#define I_FREEING (1 << 7)
2580#define I_CLEAR (1 << 8)
2581#define I_REFERENCED (1 << 9)
f4e0c30c 2582#define I_LINKABLE (1 << 10)
0ae45f63 2583#define I_DIRTY_TIME (1 << 11)
2ed634c9
CB
2584#define I_WB_SWITCH (1 << 12)
2585#define I_OVL_INUSE (1 << 13)
2586#define I_CREATING (1 << 14)
2587#define I_DONTCACHE (1 << 15)
2588#define I_SYNC_QUEUED (1 << 16)
2589#define I_PINNING_NETFS_WB (1 << 17)
1da177e4 2590
0e11f644
CH
2591#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
2592#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
0ae45f63 2593#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
1da177e4
LT
2594
2595extern void __mark_inode_dirty(struct inode *, int);
2596static inline void mark_inode_dirty(struct inode *inode)
2597{
2598 __mark_inode_dirty(inode, I_DIRTY);
2599}
2600
2601static inline void mark_inode_dirty_sync(struct inode *inode)
2602{
2603 __mark_inode_dirty(inode, I_DIRTY_SYNC);
2604}
2605
ed296c6c
EB
2606/*
2607 * Returns true if the given inode itself only has dirty timestamps (its pages
2608 * may still be dirty) and isn't currently being allocated or freed.
2609 * Filesystems should call this if when writing an inode when lazytime is
2610 * enabled, they want to opportunistically write the timestamps of other inodes
2611 * located very nearby on-disk, e.g. in the same inode block. This returns true
2612 * if the given inode is in need of such an opportunistic update. Requires
2613 * i_lock, or at least later re-checking under i_lock.
2614 */
2615static inline bool inode_is_dirtytime_only(struct inode *inode)
2616{
2617 return (inode->i_state & (I_DIRTY_TIME | I_NEW |
2618 I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME;
2619}
2620
7ada4db8
MS
2621extern void inc_nlink(struct inode *inode);
2622extern void drop_nlink(struct inode *inode);
2623extern void clear_nlink(struct inode *inode);
2624extern void set_nlink(struct inode *inode, unsigned int nlink);
d8c76e6f
DH
2625
2626static inline void inode_inc_link_count(struct inode *inode)
2627{
2628 inc_nlink(inode);
66d21730
AD
2629 mark_inode_dirty(inode);
2630}
2631
9a53c3a7
DH
2632static inline void inode_dec_link_count(struct inode *inode)
2633{
2634 drop_nlink(inode);
66d21730
AD
2635 mark_inode_dirty(inode);
2636}
2637
c3b2da31
JB
2638enum file_time_flags {
2639 S_ATIME = 1,
2640 S_MTIME = 2,
2641 S_CTIME = 4,
2642 S_VERSION = 8,
2643};
2644
c6718543 2645extern bool atime_needs_update(const struct path *, struct inode *);
badcf2b7 2646extern void touch_atime(const struct path *);
913e9928 2647int inode_update_time(struct inode *inode, int flags);
e60feb44 2648
1da177e4
LT
2649static inline void file_accessed(struct file *file)
2650{
2651 if (!(file->f_flags & O_NOATIME))
68ac1234 2652 touch_atime(&file->f_path);
1da177e4
LT
2653}
2654
e38f7f53 2655extern int file_modified(struct file *file);
66fa3ced 2656int kiocb_modified(struct kiocb *iocb);
e38f7f53 2657
c3765016 2658int sync_inode_metadata(struct inode *inode, int wait);
1da177e4 2659
1da177e4
LT
2660struct file_system_type {
2661 const char *name;
2662 int fs_flags;
bbc1096a
DH
2663#define FS_REQUIRES_DEV 1
2664#define FS_BINARY_MOUNTDATA 2
2665#define FS_HAS_SUBTYPE 4
0c55cfc4 2666#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
0b3b094a 2667#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */
a6435940 2668#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */
4e40eff0 2669#define FS_MGTIME 64 /* FS uses multigrain timestamps */
a64e5a59 2670#define FS_LBS 128 /* FS supports LBS */
bbc1096a 2671#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
f3a09c92 2672 int (*init_fs_context)(struct fs_context *);
d7167b14 2673 const struct fs_parameter_spec *parameters;
c96e41e9
AV
2674 struct dentry *(*mount) (struct file_system_type *, int,
2675 const char *, void *);
1da177e4
LT
2676 void (*kill_sb) (struct super_block *);
2677 struct module *owner;
2678 struct file_system_type * next;
a5166169 2679 struct hlist_head fs_supers;
d475fd42 2680
cf516249 2681 struct lock_class_key s_lock_key;
897c6ff9 2682 struct lock_class_key s_umount_key;
51ee049e 2683 struct lock_class_key s_vfs_rename_key;
5accdf82 2684 struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
d475fd42
PZ
2685
2686 struct lock_class_key i_lock_key;
2687 struct lock_class_key i_mutex_key;
730633f0 2688 struct lock_class_key invalidate_lock_key;
14358e6d 2689 struct lock_class_key i_mutex_dir_key;
1da177e4
LT
2690};
2691
7f78e035
EB
2692#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2693
4e40eff0
JL
2694/**
2695 * is_mgtime: is this inode using multigrain timestamps
2696 * @inode: inode to test for multigrain timestamps
2697 *
2698 * Return true if the inode uses multigrain timestamps, false otherwise.
2699 */
2700static inline bool is_mgtime(const struct inode *inode)
2701{
9fed2c0f 2702 return inode->i_opflags & IOP_MGTIME;
4e40eff0
JL
2703}
2704
152a0836
AV
2705extern struct dentry *mount_bdev(struct file_system_type *fs_type,
2706 int flags, const char *dev_name, void *data,
2707 int (*fill_super)(struct super_block *, void *, int));
3c26ff6e
AV
2708extern struct dentry *mount_nodev(struct file_system_type *fs_type,
2709 int flags, void *data,
2710 int (*fill_super)(struct super_block *, void *, int));
ea441d11 2711extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
04b94071 2712void retire_super(struct super_block *sb);
1da177e4
LT
2713void generic_shutdown_super(struct super_block *sb);
2714void kill_block_super(struct super_block *sb);
2715void kill_anon_super(struct super_block *sb);
2716void kill_litter_super(struct super_block *sb);
2717void deactivate_super(struct super_block *sb);
74dbbdd7 2718void deactivate_locked_super(struct super_block *sb);
1da177e4 2719int set_anon_super(struct super_block *s, void *data);
cb50b348 2720int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
0ee5dc67
AV
2721int get_anon_bdev(dev_t *);
2722void free_anon_bdev(dev_t);
cb50b348
AV
2723struct super_block *sget_fc(struct fs_context *fc,
2724 int (*test)(struct super_block *, struct fs_context *),
2725 int (*set)(struct super_block *, struct fs_context *));
1da177e4
LT
2726struct super_block *sget(struct file_system_type *type,
2727 int (*test)(struct super_block *,void *),
2728 int (*set)(struct super_block *,void *),
9249e17f 2729 int flags, void *data);
69881be3 2730struct super_block *sget_dev(struct fs_context *fc, dev_t dev);
1da177e4
LT
2731
2732/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
8447d848
MG
2733#define fops_get(fops) ({ \
2734 const struct file_operations *_fops = (fops); \
2735 (((_fops) && try_module_get((_fops)->owner) ? (_fops) : NULL)); \
2736})
2737
2738#define fops_put(fops) ({ \
2739 const struct file_operations *_fops = (fops); \
2740 if (_fops) \
2741 module_put((_fops)->owner); \
2742})
2743
e84f9e57
AV
2744/*
2745 * This one is to be used *ONLY* from ->open() instances.
2746 * fops must be non-NULL, pinned down *and* module dependencies
2747 * should be sufficient to pin the caller down as well.
2748 */
2749#define replace_fops(f, fops) \
2750 do { \
2751 struct file *__file = (f); \
2752 fops_put(__file->f_op); \
2753 BUG_ON(!(__file->f_op = (fops))); \
2754 } while(0)
1da177e4
LT
2755
2756extern int register_filesystem(struct file_system_type *);
2757extern int unregister_filesystem(struct file_system_type *);
f0bb5aaf 2758extern int vfs_statfs(const struct path *, struct kstatfs *);
c8b91acc
AV
2759extern int user_statfs(const char __user *, struct kstatfs *);
2760extern int fd_statfs(int, struct kstatfs *);
1af33317
CB
2761int freeze_super(struct super_block *super, enum freeze_holder who,
2762 const void *freeze_owner);
2763int thaw_super(struct super_block *super, enum freeze_holder who,
2764 const void *freeze_owner);
fca39346
JK
2765extern __printf(2, 3)
2766int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
2767extern int super_setup_bdi(struct super_block *sb);
1da177e4 2768
a4af51ce
KO
2769static inline void super_set_uuid(struct super_block *sb, const u8 *uuid, unsigned len)
2770{
2771 if (WARN_ON(len > sizeof(sb->s_uuid)))
2772 len = sizeof(sb->s_uuid);
2773 sb->s_uuid_len = len;
2774 memcpy(&sb->s_uuid, uuid, len);
2775}
2776
ae8c5117
KO
2777/* set sb sysfs name based on sb->s_bdev */
2778static inline void super_set_sysfs_name_bdev(struct super_block *sb)
2779{
2780 snprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), "%pg", sb->s_bdev);
2781}
2782
2783/* set sb sysfs name based on sb->s_uuid */
2784static inline void super_set_sysfs_name_uuid(struct super_block *sb)
2785{
2786 WARN_ON(sb->s_uuid_len != sizeof(sb->s_uuid));
2787 snprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), "%pU", sb->s_uuid.b);
2788}
2789
2790/* set sb sysfs name based on sb->s_id */
2791static inline void super_set_sysfs_name_id(struct super_block *sb)
2792{
2793 strscpy(sb->s_sysfs_name, sb->s_id, sizeof(sb->s_sysfs_name));
2794}
2795
2796/* try to use something standard before you use this */
2797__printf(2, 3)
2798static inline void super_set_sysfs_name_generic(struct super_block *sb, const char *fmt, ...)
2799{
2800 va_list args;
2801
2802 va_start(args, fmt);
2803 vsnprintf(sb->s_sysfs_name, sizeof(sb->s_sysfs_name), fmt, args);
2804 va_end(args);
2805}
2806
ce3b0f8d
AV
2807extern int current_umask(void);
2808
5a14696c
BF
2809extern void ihold(struct inode * inode);
2810extern void iput(struct inode *);
541d4c79
JL
2811int inode_update_timestamps(struct inode *inode, int flags);
2812int generic_update_time(struct inode *, int);
5a14696c 2813
f87fd4c2 2814/* /sys/fs */
00d26666 2815extern struct kobject *fs_kobj;
f87fd4c2 2816
09cbfeaf 2817#define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
bfcd17a6 2818
1da177e4 2819/* fs/open.c */
adb5c247 2820struct audit_names;
91a27b2a 2821struct filename {
adb5c247
JL
2822 const char *name; /* pointer to actual string */
2823 const __user char *uptr; /* original userland pointer */
03adc61e 2824 atomic_t refcnt;
1c949843 2825 struct audit_names *aname;
fd2f7cb5 2826 const char iname[];
91a27b2a 2827};
f1fffbd4 2828static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
1da177e4 2829
4a00c673 2830static inline struct mnt_idmap *file_mnt_idmap(const struct file *file)
256c8aed
CB
2831{
2832 return mnt_idmap(file->f_path.mnt);
2833}
2834
bb49e9e7
CB
2835/**
2836 * is_idmapped_mnt - check whether a mount is mapped
2837 * @mnt: the mount to check
2838 *
256c8aed 2839 * If @mnt has an non @nop_mnt_idmap attached to it then @mnt is mapped.
bb49e9e7
CB
2840 *
2841 * Return: true if mount is mapped, false if not.
2842 */
2843static inline bool is_idmapped_mnt(const struct vfsmount *mnt)
2844{
256c8aed 2845 return mnt_idmap(mnt) != &nop_mnt_idmap;
bb49e9e7
CB
2846}
2847
29d80d50 2848int vfs_truncate(const struct path *, loff_t);
abf08576 2849int do_truncate(struct mnt_idmap *, struct dentry *, loff_t start,
643fe55a 2850 unsigned int time_attrs, struct file *filp);
72c72bdf 2851extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
3e63cbb1 2852 loff_t len);
29d80d50
YT
2853int do_sys_open(int dfd, const char __user *filename, int flags,
2854 umode_t mode);
669abf4e 2855extern struct file *file_open_name(struct filename *, int, umode_t);
a218d0fd 2856extern struct file *filp_open(const char *, int, umode_t);
ffb37ca3 2857extern struct file *file_open_root(const struct path *,
378c6520 2858 const char *, int, umode_t);
ffb37ca3
AV
2859static inline struct file *file_open_root_mnt(struct vfsmount *mnt,
2860 const char *name, int flags, umode_t mode)
2861{
2862 return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root},
2863 name, flags, mode);
2864}
62d53c4a
AG
2865struct file *dentry_open(const struct path *path, int flags,
2866 const struct cred *creds);
ebe55960
AV
2867struct file *dentry_open_nonotify(const struct path *path, int flags,
2868 const struct cred *cred);
62d53c4a
AG
2869struct file *dentry_create(const struct path *path, int flags, umode_t mode,
2870 const struct cred *cred);
def3ae83 2871struct path *backing_file_user_path(struct file *f);
62d53c4a
AG
2872
2873/*
08582d67
AG
2874 * When mmapping a file on a stackable filesystem (e.g., overlayfs), the file
2875 * stored in ->vm_file is a backing file whose f_inode is on the underlying
3efdc78f
AV
2876 * filesystem. When the mapped file path and inode number are displayed to
2877 * user (e.g. via /proc/<pid>/maps), these helpers should be used to get the
2878 * path and inode number to display to the user, which is the path of the fd
2879 * that user has requested to map and the inode number that would be returned
2880 * by fstat() on that same fd.
08582d67 2881 */
3efdc78f 2882/* Get the path to display in /proc/<pid>/maps */
08582d67 2883static inline const struct path *file_user_path(struct file *f)
62d53c4a
AG
2884{
2885 if (unlikely(f->f_mode & FMODE_BACKING))
def3ae83 2886 return backing_file_user_path(f);
62d53c4a
AG
2887 return &f->f_path;
2888}
3efdc78f
AV
2889/* Get the inode whose inode number to display in /proc/<pid>/maps */
2890static inline const struct inode *file_user_inode(struct file *f)
2891{
2892 if (unlikely(f->f_mode & FMODE_BACKING))
2893 return d_inode(backing_file_user_path(f)->dentry);
2894 return file_inode(f);
2895}
62d53c4a 2896
19f391eb
AV
2897static inline struct file *file_clone_open(struct file *file)
2898{
2899 return dentry_open(&file->f_path, file->f_flags, file->f_cred);
2900}
1da177e4 2901extern int filp_close(struct file *, fl_owner_t id);
91a27b2a 2902
dff60734 2903extern struct filename *getname_flags(const char __user *, int);
8228e2c3 2904extern struct filename *getname_uflags(const char __user *, int);
1bb77256
MG
2905static inline struct filename *getname(const char __user *name)
2906{
2907 return getname_flags(name, 0);
2908}
c4ad8f98 2909extern struct filename *getname_kernel(const char *);
e896474f
AV
2910extern struct filename *__getname_maybe_null(const char __user *);
2911static inline struct filename *getname_maybe_null(const char __user *name, int flags)
2912{
2913 if (!(flags & AT_EMPTY_PATH))
2914 return getname(name);
2915
2916 if (!name)
2917 return NULL;
2918 return __getname_maybe_null(name);
2919}
55422d0b 2920extern void putname(struct filename *name);
f9fde814 2921DEFINE_FREE(putname, struct filename *, if (!IS_ERR_OR_NULL(_T)) putname(_T))
91a27b2a 2922
61185101
MG
2923static inline struct filename *refname(struct filename *name)
2924{
2925 atomic_inc(&name->refcnt);
2926 return name;
2927}
2928
30d90494 2929extern int finish_open(struct file *file, struct dentry *dentry,
be12af3e 2930 int (*open)(struct inode *, struct file *));
e45198a6 2931extern int finish_no_open(struct file *file, struct dentry *dentry);
1da177e4 2932
9751b338
MS
2933/* Helper for the simple case when original dentry is used */
2934static inline int finish_open_simple(struct file *file, int error)
2935{
2936 if (error)
2937 return error;
2938
2939 return finish_open(file, file->f_path.dentry, NULL);
2940}
2941
1da177e4
LT
2942/* fs/dcache.c */
2943extern void __init vfs_caches_init_early(void);
4248b0da 2944extern void __init vfs_caches_init(void);
1da177e4 2945
b86c089b
CL
2946extern struct kmem_cache *names_cachep;
2947
a608ca21 2948#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
3446a8aa 2949#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
1da177e4 2950
a212b105 2951extern struct super_block *blockdev_superblock;
a212b105
TH
2952static inline bool sb_is_blkdev_sb(struct super_block *sb)
2953{
dd0dca22 2954 return IS_ENABLED(CONFIG_BLOCK) && sb == blockdev_superblock;
47e4491b 2955}
5c0d6b60 2956
b818f09e 2957void emergency_thaw_all(void);
60b0680f 2958extern int sync_filesystem(struct super_block *);
9361401e 2959extern const struct file_operations def_blk_fops;
4b6f5d20 2960extern const struct file_operations def_chr_fops;
1da177e4
LT
2961
2962/* fs/char_dev.c */
8a932f73 2963#define CHRDEV_MAJOR_MAX 512
49db08c3
LW
2964/* Marks the bottom of the first segment of free char majors */
2965#define CHRDEV_MAJOR_DYN_END 234
a5d31a3f
LG
2966/* Marks the top and bottom of the second segment of free char majors */
2967#define CHRDEV_MAJOR_DYN_EXT_START 511
2968#define CHRDEV_MAJOR_DYN_EXT_END 384
2969
1da177e4
LT
2970extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2971extern int register_chrdev_region(dev_t, unsigned, const char *);
1905b1bf
TH
2972extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2973 unsigned int count, const char *name,
2974 const struct file_operations *fops);
2975extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2976 unsigned int count, const char *name);
1da177e4 2977extern void unregister_chrdev_region(dev_t, unsigned);
68eef3b4 2978extern void chrdev_show(struct seq_file *,off_t);
1da177e4 2979
1905b1bf
TH
2980static inline int register_chrdev(unsigned int major, const char *name,
2981 const struct file_operations *fops)
2982{
2983 return __register_chrdev(major, 0, 256, name, fops);
2984}
2985
2986static inline void unregister_chrdev(unsigned int major, const char *name)
2987{
2988 __unregister_chrdev(major, 0, 256, name);
2989}
2990
1da177e4
LT
2991extern void init_special_inode(struct inode *, umode_t, dev_t);
2992
2993/* Invalid inode operations -- fs/bad_inode.c */
2994extern void make_bad_inode(struct inode *);
0e3ef1fe 2995extern bool is_bad_inode(struct inode *);
1da177e4 2996
a823e458
JL
2997extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2998 loff_t lend);
5660e13d
JL
2999extern int __must_check file_check_and_advance_wb_err(struct file *file);
3000extern int __must_check file_write_and_wait_range(struct file *file,
3001 loff_t start, loff_t end);
dddc559f
JA
3002int filemap_fdatawrite_range_kick(struct address_space *mapping, loff_t start,
3003 loff_t end);
5660e13d 3004
a823e458
JL
3005static inline int file_write_and_wait(struct file *file)
3006{
3007 return file_write_and_wait_range(file, 0, LLONG_MAX);
3008}
3009
8018ab05
CH
3010extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
3011 int datasync);
3012extern int vfs_fsync(struct file *file, int datasync);
e2592217 3013
22f96b38
JA
3014extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
3015 unsigned int flags);
3016
91b94c5d
AV
3017static inline bool iocb_is_dsync(const struct kiocb *iocb)
3018{
3019 return (iocb->ki_flags & IOCB_DSYNC) ||
3020 IS_SYNC(iocb->ki_filp->f_mapping->host);
3021}
3022
e2592217
CH
3023/*
3024 * Sync the bytes written if this was a synchronous write. Expect ki_pos
3025 * to already be updated for the write, and will return either the amount
3026 * of bytes passed in, or an error if syncing the file failed.
3027 */
3028static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
3029{
91b94c5d 3030 if (iocb_is_dsync(iocb)) {
e2592217
CH
3031 int ret = vfs_fsync_range(iocb->ki_filp,
3032 iocb->ki_pos - count, iocb->ki_pos - 1,
3033 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1);
3034 if (ret)
3035 return ret;
1d445757
JA
3036 } else if (iocb->ki_flags & IOCB_DONTCACHE) {
3037 struct address_space *mapping = iocb->ki_filp->f_mapping;
3038
8510edf1
JX
3039 filemap_fdatawrite_range_kick(mapping, iocb->ki_pos - count,
3040 iocb->ki_pos - 1);
e2592217
CH
3041 }
3042
3043 return count;
d311d79d 3044}
e2592217 3045
1da177e4
LT
3046extern void emergency_sync(void);
3047extern void emergency_remount(void);
30460e1e 3048
9361401e 3049#ifdef CONFIG_BLOCK
30460e1e
CM
3050extern int bmap(struct inode *inode, sector_t *block);
3051#else
3052static inline int bmap(struct inode *inode, sector_t *block)
3053{
3054 return -EINVAL;
3055}
9361401e 3056#endif
30460e1e 3057
abf08576 3058int notify_change(struct mnt_idmap *, struct dentry *,
2f221d6f 3059 struct iattr *, struct inode **);
4609e1f1
CB
3060int inode_permission(struct mnt_idmap *, struct inode *, int);
3061int generic_permission(struct mnt_idmap *, struct inode *, int);
02f92b38
CB
3062static inline int file_permission(struct file *file, int mask)
3063{
4609e1f1 3064 return inode_permission(file_mnt_idmap(file),
47291baa 3065 file_inode(file), mask);
02f92b38
CB
3066}
3067static inline int path_permission(const struct path *path, int mask)
3068{
4609e1f1 3069 return inode_permission(mnt_idmap(path->mnt),
47291baa 3070 d_inode(path->dentry), mask);
02f92b38 3071}
9452e93e 3072int __check_sticky(struct mnt_idmap *idmap, struct inode *dir,
ba73d987 3073 struct inode *inode);
1da177e4 3074
f696a365
MS
3075static inline bool execute_ok(struct inode *inode)
3076{
3077 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
3078}
3079
6e3e2c43
AV
3080static inline bool inode_wrong_type(const struct inode *inode, umode_t mode)
3081{
3082 return (inode->i_mode ^ mode) & S_IFMT;
3083}
3084
f6c05b9e
AG
3085/**
3086 * file_start_write - get write access to a superblock for regular file io
3087 * @file: the file we want to write to
3088 *
3089 * This is a variant of sb_start_write() which is a noop on non-regualr file.
3090 * Should be matched with a call to file_end_write().
3091 */
8d71db4f
AV
3092static inline void file_start_write(struct file *file)
3093{
3094 if (!S_ISREG(file_inode(file)->i_mode))
3095 return;
8a3c84b6 3096 sb_start_write(file_inode(file)->i_sb);
8d71db4f
AV
3097}
3098
5ae98f15
JK
3099static inline bool file_start_write_trylock(struct file *file)
3100{
3101 if (!S_ISREG(file_inode(file)->i_mode))
3102 return true;
8a3c84b6 3103 return sb_start_write_trylock(file_inode(file)->i_sb);
5ae98f15
JK
3104}
3105
f6c05b9e
AG
3106/**
3107 * file_end_write - drop write access to a superblock of a regular file
3108 * @file: the file we wrote to
3109 *
3110 * Should be matched with a call to file_start_write().
3111 */
8d71db4f
AV
3112static inline void file_end_write(struct file *file)
3113{
3114 if (!S_ISREG(file_inode(file)->i_mode))
3115 return;
f6c05b9e 3116 sb_end_write(file_inode(file)->i_sb);
8d71db4f 3117}
bfe219d3 3118
ed0360bb
AG
3119/**
3120 * kiocb_start_write - get write access to a superblock for async file io
3121 * @iocb: the io context we want to submit the write with
3122 *
3123 * This is a variant of sb_start_write() for async io submission.
3124 * Should be matched with a call to kiocb_end_write().
3125 */
3126static inline void kiocb_start_write(struct kiocb *iocb)
3127{
3128 struct inode *inode = file_inode(iocb->ki_filp);
3129
3130 sb_start_write(inode->i_sb);
3131 /*
3132 * Fool lockdep by telling it the lock got released so that it
3133 * doesn't complain about the held lock when we return to userspace.
3134 */
3135 __sb_writers_release(inode->i_sb, SB_FREEZE_WRITE);
3136}
3137
3138/**
3139 * kiocb_end_write - drop write access to a superblock after async file io
3140 * @iocb: the io context we sumbitted the write with
3141 *
3142 * Should be matched with a call to kiocb_start_write().
3143 */
3144static inline void kiocb_end_write(struct kiocb *iocb)
3145{
3146 struct inode *inode = file_inode(iocb->ki_filp);
3147
3148 /*
3149 * Tell lockdep we inherited freeze protection from submission thread.
3150 */
3151 __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
3152 sb_end_write(inode->i_sb);
8d71db4f 3153}
bfe219d3 3154
07b8ce1e 3155/*
592ca09b
DH
3156 * This is used for regular files where some users -- especially the
3157 * currently executed binary in a process, previously handled via
3158 * VM_DENYWRITE -- cannot handle concurrent write (and maybe mmap
3159 * read-write shared) accesses.
3160 *
07b8ce1e
AV
3161 * get_write_access() gets write permission for a file.
3162 * put_write_access() releases this write permission.
592ca09b
DH
3163 * deny_write_access() denies write access to a file.
3164 * allow_write_access() re-enables write access to a file.
3165 *
3166 * The i_writecount field of an inode can have the following values:
3167 * 0: no write access, no denied write access
3168 * < 0: (-i_writecount) users that denied write access to the file.
3169 * > 0: (i_writecount) users that have write access to the file.
07b8ce1e
AV
3170 *
3171 * Normally we operate on that counter with atomic_{inc,dec} and it's safe
3172 * except for the cases where we don't hold i_writecount yet. Then we need to
3173 * use {get,deny}_write_access() - these functions check the sign and refuse
3174 * to do the change if sign is wrong.
3175 */
3176static inline int get_write_access(struct inode *inode)
3177{
3178 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
3179}
3180static inline int deny_write_access(struct file *file)
3181{
496ad9aa 3182 struct inode *inode = file_inode(file);
07b8ce1e
AV
3183 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
3184}
1da177e4
LT
3185static inline void put_write_access(struct inode * inode)
3186{
3187 atomic_dec(&inode->i_writecount);
3188}
3189static inline void allow_write_access(struct file *file)
3190{
3191 if (file)
496ad9aa 3192 atomic_inc(&file_inode(file)->i_writecount);
1da177e4 3193}
0357ef03
AG
3194
3195/*
3196 * Do not prevent write to executable file when watched by pre-content events.
3197 *
3198 * Note that FMODE_FSNOTIFY_HSM mode is set depending on pre-content watches at
3199 * the time of file open and remains constant for entire lifetime of the file,
3200 * so if pre-content watches are added post execution or removed before the end
3201 * of the execution, it will not cause i_writecount reference leak.
3202 */
3203static inline int exe_file_deny_write_access(struct file *exe_file)
3204{
3205 if (unlikely(FMODE_FSNOTIFY_HSM(exe_file->f_mode)))
3206 return 0;
3207 return deny_write_access(exe_file);
3208}
3209static inline void exe_file_allow_write_access(struct file *exe_file)
3210{
3211 if (unlikely(!exe_file || FMODE_FSNOTIFY_HSM(exe_file->f_mode)))
3212 return;
3213 allow_write_access(exe_file);
3214}
3215
95101401
AG
3216static inline void file_set_fsnotify_mode(struct file *file, fmode_t mode)
3217{
3218 file->f_mode &= ~FMODE_FSNOTIFY_MASK;
3219 file->f_mode |= mode;
3220}
3221
f1fe29b4
DH
3222static inline bool inode_is_open_for_write(const struct inode *inode)
3223{
3224 return atomic_read(&inode->i_writecount) > 0;
3225}
3226
387e3746 3227#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
a5c96ebf
MZ
3228static inline void i_readcount_dec(struct inode *inode)
3229{
45e0d4b9 3230 BUG_ON(atomic_dec_return(&inode->i_readcount) < 0);
a5c96ebf
MZ
3231}
3232static inline void i_readcount_inc(struct inode *inode)
3233{
3234 atomic_inc(&inode->i_readcount);
3235}
3236#else
3237static inline void i_readcount_dec(struct inode *inode)
3238{
3239 return;
3240}
3241static inline void i_readcount_inc(struct inode *inode)
3242{
3243 return;
3244}
3245#endif
ed8cae8b 3246extern int do_pipe_flags(int *, int);
1da177e4 3247
bdd1d2d3 3248extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
61a707c5 3249ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
e13ec939 3250extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
73e18f7c 3251extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
1da177e4
LT
3252extern struct file * open_exec(const char *);
3253
3254/* fs/dcache.c -- generic fs support functions */
a6e5787f 3255extern bool is_subdir(struct dentry *, struct dentry *);
640eb7e7 3256extern bool path_is_under(const struct path *, const struct path *);
1da177e4 3257
9bf39ab2
MS
3258extern char *file_path(struct file *, char *, int);
3259
42c3732f
CL
3260/**
3261 * is_dot_dotdot - returns true only if @name is "." or ".."
3262 * @name: file name to check
3263 * @len: length of file name, in bytes
3264 */
3265static inline bool is_dot_dotdot(const char *name, size_t len)
3266{
3267 return len && unlikely(name[0] == '.') &&
3268 (len == 1 || (len == 2 && name[1] == '.'));
3269}
3270
1da177e4
LT
3271#include <linux/err.h>
3272
3273/* needed for stackable file system support */
965c8e59 3274extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
1da177e4 3275
965c8e59 3276extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
1da177e4 3277
9897713f
MH
3278extern int inode_init_always_gfp(struct super_block *, struct inode *, gfp_t);
3279static inline int inode_init_always(struct super_block *sb, struct inode *inode)
3280{
3281 return inode_init_always_gfp(sb, inode, GFP_NOFS);
3282}
3283
1da177e4 3284extern void inode_init_once(struct inode *);
2aa15890 3285extern void address_space_init_once(struct address_space *mapping);
1da177e4
LT
3286extern struct inode * igrab(struct inode *);
3287extern ino_t iunique(struct super_block *, ino_t);
3288extern int inode_needs_sync(struct inode *inode);
45321ac5 3289extern int generic_delete_inode(struct inode *inode);
9bcb4b73
AV
3290static inline int generic_drop_inode(struct inode *inode)
3291{
88149082 3292 return !inode->i_nlink || inode_unhashed(inode);
9bcb4b73 3293}
2c567af4 3294extern void d_mark_dontcache(struct inode *inode);
1da177e4 3295
88bd5121
AA
3296extern struct inode *ilookup5_nowait(struct super_block *sb,
3297 unsigned long hashval, int (*test)(struct inode *, void *),
3298 void *data);
1da177e4
LT
3299extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
3300 int (*test)(struct inode *, void *), void *data);
3301extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
3302
80ea09a0
MS
3303extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
3304 int (*test)(struct inode *, void *),
3305 int (*set)(struct inode *, void *),
3306 void *data);
7180f8d9
MG
3307struct inode *iget5_locked(struct super_block *, unsigned long,
3308 int (*test)(struct inode *, void *),
3309 int (*set)(struct inode *, void *), void *);
3310struct inode *iget5_locked_rcu(struct super_block *, unsigned long,
3311 int (*test)(struct inode *, void *),
3312 int (*set)(struct inode *, void *), void *);
1da177e4 3313extern struct inode * iget_locked(struct super_block *, unsigned long);
fe032c42
TT
3314extern struct inode *find_inode_nowait(struct super_block *,
3315 unsigned long,
3316 int (*match)(struct inode *,
3317 unsigned long, void *),
3318 void *data);
3f19b2ab
DH
3319extern struct inode *find_inode_rcu(struct super_block *, unsigned long,
3320 int (*)(struct inode *, void *), void *);
3321extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long);
261bca86
AV
3322extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
3323extern int insert_inode_locked(struct inode *);
e096d0c7
JB
3324#ifdef CONFIG_DEBUG_LOCK_ALLOC
3325extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
3326#else
3327static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
3328#endif
1da177e4 3329extern void unlock_new_inode(struct inode *);
c2b6d621 3330extern void discard_new_inode(struct inode *);
85fe4025 3331extern unsigned int get_next_ino(void);
799ea9e9 3332extern void evict_inodes(struct super_block *sb);
3e9d80a8 3333void dump_mapping(const struct address_space *);
1da177e4 3334
e809d5f0 3335/*
b6334e2c 3336 * Userspace may rely on the inode number being non-zero. For example, glibc
e809d5f0
CD
3337 * simply ignores files with zero i_ino in unlink() and other places.
3338 *
3339 * As an additional complication, if userspace was compiled with
3340 * _FILE_OFFSET_BITS=32 on a 64-bit kernel we'll only end up reading out the
3341 * lower 32 bits, so we need to check that those aren't zero explicitly. With
3342 * _FILE_OFFSET_BITS=64, this may cause some harmless false-negatives, but
3343 * better safe than sorry.
3344 */
3345static inline bool is_zero_ino(ino_t ino)
3346{
3347 return (u32)ino == 0;
3348}
3349
88d2ae0e
KO
3350/*
3351 * inode->i_lock must be held
3352 */
3353static inline void __iget(struct inode *inode)
3354{
3355 atomic_inc(&inode->i_count);
3356}
3357
b46980fe 3358extern void iget_failed(struct inode *);
dbd5768f 3359extern void clear_inode(struct inode *);
2e00c97e 3360extern void __destroy_inode(struct inode *);
1479be62
MG
3361struct inode *alloc_inode(struct super_block *sb);
3362static inline struct inode *new_inode_pseudo(struct super_block *sb)
3363{
3364 return alloc_inode(sb);
3365}
a209dfc7 3366extern struct inode *new_inode(struct super_block *sb);
ff0c7d15 3367extern void free_inode_nonrcu(struct inode *inode);
9452e93e 3368extern int setattr_should_drop_suidgid(struct mnt_idmap *, struct inode *);
66a67c86 3369extern int file_remove_privs_flags(struct file *file, unsigned int flags);
5fa8e0a1 3370extern int file_remove_privs(struct file *);
4f704d9a
CB
3371int setattr_should_drop_sgid(struct mnt_idmap *idmap,
3372 const struct inode *inode);
1da177e4 3373
8b9f3ac5
MS
3374/*
3375 * This must be used for allocating filesystems specific inodes to set
3376 * up the inode reclaim context correctly.
3377 */
a5674119 3378#define alloc_inode_sb(_sb, _cache, _gfp) kmem_cache_alloc_lru(_cache, &_sb->s_inode_lru, _gfp)
8b9f3ac5 3379
1da177e4 3380extern void __insert_inode_hash(struct inode *, unsigned long hashval);
646ec461
CH
3381static inline void insert_inode_hash(struct inode *inode)
3382{
1da177e4
LT
3383 __insert_inode_hash(inode, inode->i_ino);
3384}
f2ee7abf
ED
3385
3386extern void __remove_inode_hash(struct inode *);
3387static inline void remove_inode_hash(struct inode *inode)
3388{
cbedaac6 3389 if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
f2ee7abf
ED
3390 __remove_inode_hash(inode);
3391}
3392
646ec461 3393extern void inode_sb_list_add(struct inode *inode);
51b8c1fe 3394extern void inode_add_lru(struct inode *inode);
1da177e4 3395
1da177e4
LT
3396extern int sb_set_blocksize(struct super_block *, int);
3397extern int sb_min_blocksize(struct super_block *, int);
3398
3399extern int generic_file_mmap(struct file *, struct vm_area_struct *);
3400extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
3309dd04 3401extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
f6f7a25a 3402int generic_write_checks_count(struct kiocb *iocb, loff_t *count);
02e83f46
DW
3403extern int generic_write_check_limits(struct file *file, loff_t pos,
3404 loff_t *count);
a3171351 3405extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
87fa0f3e
CH
3406ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *to,
3407 ssize_t already_read);
ed978a81 3408extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
8174202b 3409extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
8174202b 3410extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
1af5bb49 3411extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
800ba295 3412ssize_t generic_perform_write(struct kiocb *, struct iov_iter *);
44fff0fa
CH
3413ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,
3414 ssize_t direct_written, ssize_t buffered_written);
88e6faef 3415
18e9710e 3416ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
ddef7ed2 3417 rwf_t flags);
abbb6589 3418ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
ddef7ed2 3419 rwf_t flags);
5dcdc43e
JX
3420ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
3421 struct iov_iter *iter);
3422ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
3423 struct iov_iter *iter);
dbe4e192 3424
88e6faef 3425/* fs/splice.c */
07073eb0
DH
3426ssize_t filemap_splice_read(struct file *in, loff_t *ppos,
3427 struct pipe_inode_info *pipe,
3428 size_t len, unsigned int flags);
69df79a4
DH
3429ssize_t copy_splice_read(struct file *in, loff_t *ppos,
3430 struct pipe_inode_info *pipe,
3431 size_t len, unsigned int flags);
8d020765 3432extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
cbb7e577 3433 struct file *, loff_t *, size_t, unsigned int);
1c118596 3434
88e6faef 3435
1da177e4
LT
3436extern void
3437file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
965c8e59 3438extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
46a1c2c7 3439extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
965c8e59 3440extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
5760495a 3441extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
965c8e59 3442 int whence, loff_t maxsize, loff_t eof);
d688d65a
CB
3443loff_t generic_llseek_cookie(struct file *file, loff_t offset, int whence,
3444 u64 *cookie);
1bf9d14d
AV
3445extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
3446 int whence, loff_t size);
b25472f9
AV
3447extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
3448extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
87112933 3449int rw_verify_area(int, struct file *, const loff_t *, size_t);
1da177e4
LT
3450extern int generic_file_open(struct inode * inode, struct file * filp);
3451extern int nonseekable_open(struct inode * inode, struct file * filp);
10dce8af 3452extern int stream_open(struct inode * inode, struct file * filp);
1da177e4 3453
9361401e 3454#ifdef CONFIG_BLOCK
8a4c1e42 3455typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
facd07b0 3456 loff_t file_offset);
1da177e4
LT
3457
3458enum {
1e431f5c
CH
3459 /* need locking between buffered and direct access */
3460 DIO_LOCKING = 0x01,
3461
3462 /* filesystem does not support filling holes */
3463 DIO_SKIP_HOLES = 0x02,
1da177e4
LT
3464};
3465
17f8c842
OS
3466ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
3467 struct block_device *bdev, struct iov_iter *iter,
c8b8e32d 3468 get_block_t get_block,
0aaf08de 3469 dio_iodone_t end_io,
17f8c842 3470 int flags);
7bb46a67 3471
17f8c842
OS
3472static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
3473 struct inode *inode,
c8b8e32d 3474 struct iov_iter *iter,
17f8c842 3475 get_block_t get_block)
1da177e4 3476{
17f8c842 3477 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
0aaf08de 3478 get_block, NULL, DIO_LOCKING | DIO_SKIP_HOLES);
1da177e4 3479}
9361401e 3480#endif
1da177e4 3481
1c48d441 3482bool inode_dio_finished(const struct inode *inode);
1d59d61f 3483void inode_dio_wait(struct inode *inode);
1c48d441 3484void inode_dio_wait_interruptible(struct inode *inode);
fe0f07d0 3485
39015399 3486/**
fe0f07d0
JA
3487 * inode_dio_begin - signal start of a direct I/O requests
3488 * @inode: inode the direct I/O happens on
3489 *
3490 * This is called once we've finished processing a direct I/O request,
3491 * and is used to wake up callers waiting for direct I/O to be quiesced.
3492 */
3493static inline void inode_dio_begin(struct inode *inode)
3494{
3495 atomic_inc(&inode->i_dio_count);
3496}
3497
39015399 3498/**
fe0f07d0
JA
3499 * inode_dio_end - signal finish of a direct I/O requests
3500 * @inode: inode the direct I/O happens on
3501 *
3502 * This is called once we've finished processing a direct I/O request,
3503 * and is used to wake up callers waiting for direct I/O to be quiesced.
3504 */
3505static inline void inode_dio_end(struct inode *inode)
3506{
3507 if (atomic_dec_and_test(&inode->i_dio_count))
1c48d441 3508 wake_up_var(&inode->i_dio_count);
fe0f07d0 3509}
1d59d61f 3510
5f16f322
TT
3511extern void inode_set_flags(struct inode *inode, unsigned int flags,
3512 unsigned int mask);
3513
4b6f5d20 3514extern const struct file_operations generic_ro_fops;
1da177e4
LT
3515
3516#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
3517
ea382199 3518extern int readlink_copy(char __user *, int, const char *, int);
1da177e4 3519extern int page_readlink(struct dentry *, char __user *, int);
b4c173df
MS
3520extern const char *page_get_link_raw(struct dentry *, struct inode *,
3521 struct delayed_call *);
fceef393
AV
3522extern const char *page_get_link(struct dentry *, struct inode *,
3523 struct delayed_call *);
3524extern void page_put_link(void *);
1da177e4 3525extern int page_symlink(struct inode *inode, const char *symname, int len);
c5ef1c42 3526extern const struct inode_operations page_symlink_inode_operations;
fceef393 3527extern void kfree_link(void *);
4e40eff0 3528void fill_mg_cmtime(struct kstat *stat, u32 request_mask, struct inode *inode);
0d72b928 3529void generic_fillattr(struct mnt_idmap *, u32, struct inode *, struct kstat *);
4f911138 3530void generic_fill_statx_attr(struct inode *inode, struct kstat *stat);
0f9ca80f
PS
3531void generic_fill_statx_atomic_writes(struct kstat *stat,
3532 unsigned int unit_min,
5d894321
JG
3533 unsigned int unit_max,
3534 unsigned int unit_max_opt);
a528d35e
DH
3535extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
3536extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
b462707e 3537void __inode_add_bytes(struct inode *inode, loff_t bytes);
1da177e4 3538void inode_add_bytes(struct inode *inode, loff_t bytes);
1c8924eb 3539void __inode_sub_bytes(struct inode *inode, loff_t bytes);
1da177e4 3540void inode_sub_bytes(struct inode *inode, loff_t bytes);
f4a8116a
JK
3541static inline loff_t __inode_get_bytes(struct inode *inode)
3542{
3543 return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
3544}
1da177e4
LT
3545loff_t inode_get_bytes(struct inode *inode);
3546void inode_set_bytes(struct inode *inode, loff_t bytes);
fceef393
AV
3547const char *simple_get_link(struct dentry *, struct inode *,
3548 struct delayed_call *);
61ba64fc 3549extern const struct inode_operations simple_symlink_inode_operations;
1da177e4 3550
5c0ba4e0 3551extern int iterate_dir(struct file *, struct dir_context *);
1da177e4 3552
09f1bde4
CH
3553int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
3554 int flags);
da9aa5d9 3555int vfs_fstat(int fd, struct kstat *stat);
a528d35e
DH
3556
3557static inline int vfs_stat(const char __user *filename, struct kstat *stat)
3558{
0b2c6693 3559 return vfs_fstatat(AT_FDCWD, filename, stat, 0);
a528d35e
DH
3560}
3561static inline int vfs_lstat(const char __user *name, struct kstat *stat)
3562{
0b2c6693 3563 return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
a528d35e 3564}
a528d35e 3565
d60874cd 3566extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
fd4a0edf 3567extern int vfs_readlink(struct dentry *, char __user *, int);
1da177e4 3568
ee416bcd 3569extern struct file_system_type *get_filesystem(struct file_system_type *fs);
c18479fe 3570extern void put_filesystem(struct file_system_type *fs);
1da177e4 3571extern struct file_system_type *get_fs_type(const char *name);
1da177e4 3572extern void drop_super(struct super_block *sb);
ba6379f7 3573extern void drop_super_exclusive(struct super_block *sb);
b47e42d1 3574extern void iterate_supers(void (*f)(struct super_block *, void *), void *arg);
43e15cdb
AV
3575extern void iterate_supers_type(struct file_system_type *,
3576 void (*)(struct super_block *, void *), void *);
1af33317
CB
3577void filesystems_freeze(void);
3578void filesystems_thaw(void);
1da177e4
LT
3579
3580extern int dcache_dir_open(struct inode *, struct file *);
3581extern int dcache_dir_close(struct inode *, struct file *);
3582extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
5f99f4e7 3583extern int dcache_readdir(struct file *, struct dir_context *);
c1632a0f 3584extern int simple_setattr(struct mnt_idmap *, struct dentry *,
549c7297 3585 struct iattr *);
b74d24f7 3586extern int simple_getattr(struct mnt_idmap *, const struct path *,
549c7297 3587 struct kstat *, u32, unsigned int);
726c3342 3588extern int simple_statfs(struct dentry *, struct kstatfs *);
20955e89 3589extern int simple_open(struct inode *inode, struct file *file);
1da177e4
LT
3590extern int simple_link(struct dentry *, struct inode *, struct dentry *);
3591extern int simple_unlink(struct inode *, struct dentry *);
3592extern int simple_rmdir(struct inode *, struct dentry *);
0c476792
JL
3593void simple_rename_timestamp(struct inode *old_dir, struct dentry *old_dentry,
3594 struct inode *new_dir, struct dentry *new_dentry);
6429e463
LB
3595extern int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry,
3596 struct inode *new_dir, struct dentry *new_dentry);
e18275ae 3597extern int simple_rename(struct mnt_idmap *, struct inode *,
549c7297
CB
3598 struct dentry *, struct inode *, struct dentry *,
3599 unsigned int);
a3d1e7eb
AV
3600extern void simple_recursive_removal(struct dentry *,
3601 void (*callback)(struct dentry *));
02c24a82 3602extern int noop_fsync(struct file *, loff_t, loff_t, int);
f44c7763 3603extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
1da177e4 3604extern int simple_empty(struct dentry *);
afddba49 3605extern int simple_write_begin(struct file *file, struct address_space *mapping,
9d6b0cd7 3606 loff_t pos, unsigned len,
1da86618 3607 struct folio **foliop, void **fsdata);
c1e3dbe9 3608extern const struct address_space_operations ram_aops;
b26d4cd3 3609extern int always_delete_dentry(const struct dentry *);
6987843f 3610extern struct inode *alloc_anon_inode(struct super_block *);
c69ff407 3611extern int simple_nosetlease(struct file *, int, struct file_lease **, void **);
b26d4cd3 3612extern const struct dentry_operations simple_dentry_operations;
1da177e4 3613
00cd8dd3 3614extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
1da177e4 3615extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
4b6f5d20 3616extern const struct file_operations simple_dir_operations;
c5ef1c42 3617extern const struct inode_operations simple_dir_inode_operations;
fbabfd0f
EB
3618extern void make_empty_dir_inode(struct inode *inode);
3619extern bool is_empty_dir_inode(struct inode *inode);
cda37124 3620struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
1da177e4 3621struct dentry *d_alloc_name(struct dentry *, const char *);
cda37124
EB
3622extern int simple_fill_super(struct super_block *, unsigned long,
3623 const struct tree_descr *);
1f5ce9e9 3624extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
1da177e4
LT
3625extern void simple_release_fs(struct vfsmount **mount, int *count);
3626
93b07113
AM
3627extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
3628 loff_t *ppos, const void *from, size_t available);
6a727b43
JS
3629extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3630 const void __user *from, size_t count);
1da177e4 3631
6faddda6 3632struct offset_ctx {
0e4a8621
CL
3633 struct maple_tree mt;
3634 unsigned long next_offset;
6faddda6
CL
3635};
3636
3637void simple_offset_init(struct offset_ctx *octx);
3638int simple_offset_add(struct offset_ctx *octx, struct dentry *dentry);
3639void simple_offset_remove(struct offset_ctx *octx, struct dentry *dentry);
5a1a25be
CL
3640int simple_offset_rename(struct inode *old_dir, struct dentry *old_dentry,
3641 struct inode *new_dir, struct dentry *new_dentry);
6faddda6
CL
3642int simple_offset_rename_exchange(struct inode *old_dir,
3643 struct dentry *old_dentry,
3644 struct inode *new_dir,
3645 struct dentry *new_dentry);
3646void simple_offset_destroy(struct offset_ctx *octx);
3647
3648extern const struct file_operations simple_offset_dir_operations;
3649
ac13a829 3650extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
02c24a82 3651extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
d5aacad5 3652
30ca22c7
PL
3653extern int generic_check_addressable(unsigned, u64);
3654
70dfe3f0 3655extern void generic_set_sb_d_ops(struct super_block *sb);
6a79a4e1
GKB
3656extern int generic_ci_match(const struct inode *parent,
3657 const struct qstr *name,
3658 const struct qstr *folded_name,
3659 const u8 *de_name, u32 de_name_len);
c843843e 3660
0e152beb 3661#if IS_ENABLED(CONFIG_UNICODE)
458532c8
AA
3662int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str);
3663int generic_ci_d_compare(const struct dentry *dentry, unsigned int len,
3664 const char *str, const struct qstr *name);
3665
0e152beb
AA
3666/**
3667 * generic_ci_validate_strict_name - Check if a given name is suitable
3668 * for a directory
3669 *
3670 * This functions checks if the proposed filename is valid for the
3671 * parent directory. That means that only valid UTF-8 filenames will be
3672 * accepted for casefold directories from filesystems created with the
3673 * strict encoding flag. That also means that any name will be
3674 * accepted for directories that doesn't have casefold enabled, or
3675 * aren't being strict with the encoding.
3676 *
3677 * @dir: inode of the directory where the new file will be created
3678 * @name: name of the new file
3679 *
3680 * Return:
33b091c0
AA
3681 * * True: if the filename is suitable for this directory. It can be
3682 * true if a given name is not suitable for a strict encoding
3683 * directory, but the directory being used isn't strict
0e152beb 3684 * * False if the filename isn't suitable for this directory. This only
33b091c0
AA
3685 * happens when a directory is casefolded and the filesystem is strict
3686 * about its encoding.
0e152beb
AA
3687 */
3688static inline bool generic_ci_validate_strict_name(struct inode *dir, struct qstr *name)
3689{
3690 if (!IS_CASEFOLDED(dir) || !sb_has_strict_encoding(dir->i_sb))
3691 return true;
3692
3693 /*
3694 * A casefold dir must have a encoding set, unless the filesystem
3695 * is corrupted
3696 */
3697 if (WARN_ON_ONCE(!dir->i_sb->s_encoding))
3698 return true;
3699
3700 return !utf8_validate(dir->i_sb->s_encoding, name);
3701}
3702#else
3703static inline bool generic_ci_validate_strict_name(struct inode *dir, struct qstr *name)
3704{
3705 return true;
3706}
3707#endif
3708
2824083d
GKB
3709static inline bool sb_has_encoding(const struct super_block *sb)
3710{
3711#if IS_ENABLED(CONFIG_UNICODE)
3712 return !!sb->s_encoding;
3713#else
3714 return false;
3715#endif
3716}
c843843e 3717
4609e1f1 3718int may_setattr(struct mnt_idmap *idmap, struct inode *inode,
7bb698f0 3719 unsigned int ia_valid);
c1632a0f 3720int setattr_prepare(struct mnt_idmap *, struct dentry *, struct iattr *);
25d9e2d1 3721extern int inode_newsize_ok(const struct inode *, loff_t offset);
c1632a0f 3722void setattr_copy(struct mnt_idmap *, struct inode *inode,
2f221d6f 3723 const struct iattr *attr);
1da177e4 3724
c3b2da31 3725extern int file_update_time(struct file *file);
1da177e4 3726
f05a3849 3727static inline bool vma_is_dax(const struct vm_area_struct *vma)
baabda26
DW
3728{
3729 return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
3730}
3731
2bb6d283
DW
3732static inline bool vma_is_fsdax(struct vm_area_struct *vma)
3733{
3734 struct inode *inode;
3735
52650c8b 3736 if (!IS_ENABLED(CONFIG_FS_DAX) || !vma->vm_file)
2bb6d283
DW
3737 return false;
3738 if (!vma_is_dax(vma))
3739 return false;
3740 inode = file_inode(vma->vm_file);
230f5a89 3741 if (S_ISCHR(inode->i_mode))
2bb6d283
DW
3742 return false; /* device-dax */
3743 return true;
3744}
3745
2ba48ce5
AV
3746static inline int iocb_flags(struct file *file)
3747{
3748 int res = 0;
3749 if (file->f_flags & O_APPEND)
3750 res |= IOCB_APPEND;
efbe3c24 3751 if (file->f_flags & O_DIRECT)
2ba48ce5 3752 res |= IOCB_DIRECT;
91b94c5d 3753 if (file->f_flags & O_DSYNC)
dde0c2e7
CH
3754 res |= IOCB_DSYNC;
3755 if (file->f_flags & __O_SYNC)
3756 res |= IOCB_SYNC;
2ba48ce5
AV
3757 return res;
3758}
3759
c34fc6f2
PS
3760static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags,
3761 int rw_type)
fdd2f5b7 3762{
1752f0ad
PB
3763 int kiocb_flags = 0;
3764
ce71bfea
JA
3765 /* make sure there's no overlap between RWF and private IOCB flags */
3766 BUILD_BUG_ON((__force int) RWF_SUPPORTED & IOCB_EVENTFD);
3767
1752f0ad
PB
3768 if (!flags)
3769 return 0;
fdd2f5b7
GR
3770 if (unlikely(flags & ~RWF_SUPPORTED))
3771 return -EOPNOTSUPP;
73fa7547
RF
3772 if (unlikely((flags & RWF_APPEND) && (flags & RWF_NOAPPEND)))
3773 return -EINVAL;
fdd2f5b7 3774
b745fafa 3775 if (flags & RWF_NOWAIT) {
91f9943e 3776 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT))
b745fafa 3777 return -EOPNOTSUPP;
b745fafa 3778 }
c34fc6f2
PS
3779 if (flags & RWF_ATOMIC) {
3780 if (rw_type != WRITE)
3781 return -EOPNOTSUPP;
3782 if (!(ki->ki_filp->f_mode & FMODE_CAN_ATOMIC_WRITE))
3783 return -EOPNOTSUPP;
3784 }
af6505e5
JA
3785 if (flags & RWF_DONTCACHE) {
3786 /* file system must support it */
3787 if (!(ki->ki_filp->f_op->fop_flags & FOP_DONTCACHE))
3788 return -EOPNOTSUPP;
3789 /* DAX mappings not supported */
3790 if (IS_DAX(ki->ki_filp->f_mapping->host))
3791 return -EOPNOTSUPP;
3792 }
ce71bfea 3793 kiocb_flags |= (__force int) (flags & RWF_SUPPORTED);
fdd2f5b7 3794 if (flags & RWF_SYNC)
ce71bfea 3795 kiocb_flags |= IOCB_DSYNC;
1752f0ad 3796
73fa7547
RF
3797 if ((flags & RWF_NOAPPEND) && (ki->ki_flags & IOCB_APPEND)) {
3798 if (IS_APPEND(file_inode(ki->ki_filp)))
3799 return -EPERM;
3800 ki->ki_flags &= ~IOCB_APPEND;
3801 }
3802
1752f0ad 3803 ki->ki_flags |= kiocb_flags;
fdd2f5b7
GR
3804 return 0;
3805}
3806
1da177e4
LT
3807/* Transaction based IO helpers */
3808
3809/*
3810 * An argresp is stored in an allocated page and holds the
3811 * size of the argument or response, along with its content
3812 */
3813struct simple_transaction_argresp {
3814 ssize_t size;
5e01fdff 3815 char data[];
1da177e4
LT
3816};
3817
3818#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
3819
3820char *simple_transaction_get(struct file *file, const char __user *buf,
3821 size_t size);
3822ssize_t simple_transaction_read(struct file *file, char __user *buf,
3823 size_t size, loff_t *pos);
3824int simple_transaction_release(struct inode *inode, struct file *file);
3825
76791ab2 3826void simple_transaction_set(struct file *file, size_t n);
1da177e4 3827
acaefc25
AB
3828/*
3829 * simple attribute files
3830 *
3831 * These attributes behave similar to those in sysfs:
3832 *
3833 * Writing to an attribute immediately sets a value, an open file can be
3834 * written to multiple times.
3835 *
3836 * Reading from an attribute creates a buffer from the value that might get
3837 * read with multiple read calls. When the attribute has been read
3838 * completely, no further read calls are possible until the file is opened
3839 * again.
3840 *
3841 * All attributes contain a text representation of a numeric value
3842 * that are accessed with the get() and set() functions.
3843 */
2e41f274 3844#define DEFINE_SIMPLE_ATTRIBUTE_XSIGNED(__fops, __get, __set, __fmt, __is_signed) \
acaefc25
AB
3845static int __fops ## _open(struct inode *inode, struct file *file) \
3846{ \
3847 __simple_attr_check_format(__fmt, 0ull); \
3848 return simple_attr_open(inode, file, __get, __set, __fmt); \
3849} \
828c0950 3850static const struct file_operations __fops = { \
acaefc25
AB
3851 .owner = THIS_MODULE, \
3852 .open = __fops ## _open, \
74bedc4d 3853 .release = simple_attr_release, \
acaefc25 3854 .read = simple_attr_read, \
2e41f274 3855 .write = (__is_signed) ? simple_attr_write_signed : simple_attr_write, \
1ec5584e 3856 .llseek = generic_file_llseek, \
68be3029 3857}
acaefc25 3858
2e41f274
AM
3859#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
3860 DEFINE_SIMPLE_ATTRIBUTE_XSIGNED(__fops, __get, __set, __fmt, false)
3861
3862#define DEFINE_SIMPLE_ATTRIBUTE_SIGNED(__fops, __get, __set, __fmt) \
3863 DEFINE_SIMPLE_ATTRIBUTE_XSIGNED(__fops, __get, __set, __fmt, true)
3864
b9075fa9
JP
3865static inline __printf(1, 2)
3866void __simple_attr_check_format(const char *fmt, ...)
acaefc25
AB
3867{
3868 /* don't do anything, just let the compiler check the arguments; */
3869}
3870
3871int simple_attr_open(struct inode *inode, struct file *file,
8b88b099 3872 int (*get)(void *, u64 *), int (*set)(void *, u64),
acaefc25 3873 const char *fmt);
74bedc4d 3874int simple_attr_release(struct inode *inode, struct file *file);
acaefc25
AB
3875ssize_t simple_attr_read(struct file *file, char __user *buf,
3876 size_t len, loff_t *ppos);
3877ssize_t simple_attr_write(struct file *file, const char __user *buf,
3878 size_t len, loff_t *ppos);
2e41f274
AM
3879ssize_t simple_attr_write_signed(struct file *file, const char __user *buf,
3880 size_t len, loff_t *ppos);
acaefc25 3881
4be28540 3882struct ctl_table;
6e7c1770 3883int __init list_bdev_fs_names(char *buf, size_t size);
62239ac2 3884
3cd90ea4 3885#define __FMODE_EXEC ((__force int) FMODE_EXEC)
1a44bc8c 3886
6d125529 3887#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
ebe55960 3888#define OPEN_FMODE(flag) ((__force fmode_t)((flag + 1) & O_ACCMODE))
5300990c 3889
d37177ba 3890static inline bool is_sxid(umode_t mode)
69b45732 3891{
8d84e39d 3892 return mode & (S_ISUID | S_ISGID);
69b45732
AK
3893}
3894
9452e93e 3895static inline int check_sticky(struct mnt_idmap *idmap,
ba73d987 3896 struct inode *dir, struct inode *inode)
cbdf35bc
MS
3897{
3898 if (!(dir->i_mode & S_ISVTX))
3899 return 0;
3900
9452e93e 3901 return __check_sticky(idmap, dir, inode);
cbdf35bc
MS
3902}
3903
69b45732
AK
3904static inline void inode_has_no_xattr(struct inode *inode)
3905{
e462ec50 3906 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC))
69b45732
AK
3907 inode->i_flags |= S_NOSEC;
3908}
3909
a7400222
AV
3910static inline bool is_root_inode(struct inode *inode)
3911{
3912 return inode == inode->i_sb->s_root->d_inode;
3913}
3914
5f99f4e7
AV
3915static inline bool dir_emit(struct dir_context *ctx,
3916 const char *name, int namelen,
3917 u64 ino, unsigned type)
3918{
25885a35 3919 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type);
5f99f4e7
AV
3920}
3921static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
3922{
3923 return ctx->actor(ctx, ".", 1, ctx->pos,
25885a35 3924 file->f_path.dentry->d_inode->i_ino, DT_DIR);
5f99f4e7
AV
3925}
3926static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
3927{
3928 return ctx->actor(ctx, "..", 2, ctx->pos,
f378ec4e 3929 d_parent_ino(file->f_path.dentry), DT_DIR);
5f99f4e7
AV
3930}
3931static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
3932{
3933 if (ctx->pos == 0) {
3934 if (!dir_emit_dot(file, ctx))
3935 return false;
3936 ctx->pos = 1;
3937 }
3938 if (ctx->pos == 1) {
3939 if (!dir_emit_dotdot(file, ctx))
3940 return false;
3941 ctx->pos = 2;
3942 }
3943 return true;
3944}
5ded75ec
AV
3945static inline bool dir_relax(struct inode *inode)
3946{
5955102c
AV
3947 inode_unlock(inode);
3948 inode_lock(inode);
5ded75ec
AV
3949 return !IS_DEADDIR(inode);
3950}
5f99f4e7 3951
ae05327a
AV
3952static inline bool dir_relax_shared(struct inode *inode)
3953{
3954 inode_unlock_shared(inode);
3955 inode_lock_shared(inode);
3956 return !IS_DEADDIR(inode);
3957}
3958
90f8572b 3959extern bool path_noexec(const struct path *path);
21fc61c7 3960extern void inode_nohighmem(struct inode *inode);
90f8572b 3961
45cd0faa
AG
3962/* mm/fadvise.c */
3963extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
3964 int advice);
cf1ea059
JK
3965extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
3966 int advice);
45cd0faa 3967
1bc6d445
CB
3968static inline bool vfs_empty_path(int dfd, const char __user *path)
3969{
3970 char c;
3971
3972 if (dfd < 0)
3973 return false;
3974
3975 /* We now allow NULL to be used for empty path. */
3976 if (!path)
3977 return true;
3978
3979 if (unlikely(get_user(c, path)))
3980 return false;
3981
3982 return !c;
3983}
3984
c3be7ebb 3985int generic_atomic_write_valid(struct kiocb *iocb, struct iov_iter *iter);
c34fc6f2 3986
1da177e4 3987#endif /* _LINUX_FS_H */