1
2#ifndef _LINUX_FS_H
3#define _LINUX_FS_H
4
5#include <linux/linkage.h>
6#include <linux/wait_bit.h>
7#include <linux/kdev_t.h>
8#include <linux/dcache.h>
9#include <linux/path.h>
10#include <linux/stat.h>
11#include <linux/cache.h>
12#include <linux/list.h>
13#include <linux/list_lru.h>
14#include <linux/llist.h>
15#include <linux/radix-tree.h>
16#include <linux/xarray.h>
17#include <linux/rbtree.h>
18#include <linux/init.h>
19#include <linux/pid.h>
20#include <linux/bug.h>
21#include <linux/mutex.h>
22#include <linux/rwsem.h>
23#include <linux/mm_types.h>
24#include <linux/capability.h>
25#include <linux/semaphore.h>
26#include <linux/fcntl.h>
27#include <linux/rculist_bl.h>
28#include <linux/atomic.h>
29#include <linux/shrinker.h>
30#include <linux/migrate_mode.h>
31#include <linux/uidgid.h>
32#include <linux/lockdep.h>
33#include <linux/percpu-rwsem.h>
34#include <linux/workqueue.h>
35#include <linux/delayed_call.h>
36#include <linux/uuid.h>
37#include <linux/errseq.h>
38#include <linux/ioprio.h>
39#include <linux/fs_types.h>
40#include <linux/build_bug.h>
41#include <linux/stddef.h>
42#include <linux/mount.h>
43#include <linux/cred.h>
44
45#include <asm/byteorder.h>
46#include <uapi/linux/fs.h>
47
48struct backing_dev_info;
49struct bdi_writeback;
50struct bio;
51struct export_operations;
52struct fiemap_extent_info;
53struct hd_geometry;
54struct iovec;
55struct kiocb;
56struct kobject;
57struct pipe_inode_info;
58struct poll_table_struct;
59struct kstatfs;
60struct vm_area_struct;
61struct vfsmount;
62struct cred;
63struct swap_info_struct;
64struct seq_file;
65struct workqueue_struct;
66struct iov_iter;
67struct fscrypt_info;
68struct fscrypt_operations;
69struct fsverity_info;
70struct fsverity_operations;
71struct fs_context;
72struct fs_parameter_spec;
73struct fileattr;
74
75extern void __init inode_init(void);
76extern void __init inode_init_early(void);
77extern void __init files_init(void);
78extern void __init files_maxfiles_init(void);
79
80extern struct files_stat_struct files_stat;
81extern unsigned long get_max_files(void);
82extern unsigned int sysctl_nr_open;
83extern struct inodes_stat_t inodes_stat;
84extern int leases_enable, lease_break_time;
85extern int sysctl_protected_symlinks;
86extern int sysctl_protected_hardlinks;
87extern int sysctl_protected_fifos;
88extern int sysctl_protected_regular;
89
90typedef __kernel_rwf_t rwf_t;
91
92struct buffer_head;
93typedef int (get_block_t)(struct inode *inode, sector_t iblock,
94 struct buffer_head *bh_result, int create);
95typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
96 ssize_t bytes, void *private);
97
98#define MAY_EXEC 0x00000001
99#define MAY_WRITE 0x00000002
100#define MAY_READ 0x00000004
101#define MAY_APPEND 0x00000008
102#define MAY_ACCESS 0x00000010
103#define MAY_OPEN 0x00000020
104#define MAY_CHDIR 0x00000040
105
106#define MAY_NOT_BLOCK 0x00000080
107
108
109
110
111
112
113
114#define FMODE_READ ((__force fmode_t)0x1)
115
116#define FMODE_WRITE ((__force fmode_t)0x2)
117
118#define FMODE_LSEEK ((__force fmode_t)0x4)
119
120#define FMODE_PREAD ((__force fmode_t)0x8)
121
122#define FMODE_PWRITE ((__force fmode_t)0x10)
123
124#define FMODE_EXEC ((__force fmode_t)0x20)
125
126#define FMODE_NDELAY ((__force fmode_t)0x40)
127
128#define FMODE_EXCL ((__force fmode_t)0x80)
129
130
131#define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
132
133#define FMODE_32BITHASH ((__force fmode_t)0x200)
134
135#define FMODE_64BITHASH ((__force fmode_t)0x400)
136
137
138
139
140
141
142
143#define FMODE_NOCMTIME ((__force fmode_t)0x800)
144
145
146#define FMODE_RANDOM ((__force fmode_t)0x1000)
147
148
149#define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
150
151
152#define FMODE_PATH ((__force fmode_t)0x4000)
153
154
155#define FMODE_ATOMIC_POS ((__force fmode_t)0x8000)
156
157#define FMODE_WRITER ((__force fmode_t)0x10000)
158
159#define FMODE_CAN_READ ((__force fmode_t)0x20000)
160
161#define FMODE_CAN_WRITE ((__force fmode_t)0x40000)
162
163#define FMODE_OPENED ((__force fmode_t)0x80000)
164#define FMODE_CREATED ((__force fmode_t)0x100000)
165
166
167#define FMODE_STREAM ((__force fmode_t)0x200000)
168
169
170#define FMODE_NONOTIFY ((__force fmode_t)0x4000000)
171
172
173#define FMODE_NOWAIT ((__force fmode_t)0x8000000)
174
175
176#define FMODE_NEED_UNMOUNT ((__force fmode_t)0x10000000)
177
178
179#define FMODE_NOACCOUNT ((__force fmode_t)0x20000000)
180
181
182#define FMODE_BUF_RASYNC ((__force fmode_t)0x40000000)
183
184
185
186
187
188#define ATTR_MODE (1 << 0)
189#define ATTR_UID (1 << 1)
190#define ATTR_GID (1 << 2)
191#define ATTR_SIZE (1 << 3)
192#define ATTR_ATIME (1 << 4)
193#define ATTR_MTIME (1 << 5)
194#define ATTR_CTIME (1 << 6)
195#define ATTR_ATIME_SET (1 << 7)
196#define ATTR_MTIME_SET (1 << 8)
197#define ATTR_FORCE (1 << 9)
198#define ATTR_KILL_SUID (1 << 11)
199#define ATTR_KILL_SGID (1 << 12)
200#define ATTR_FILE (1 << 13)
201#define ATTR_KILL_PRIV (1 << 14)
202#define ATTR_OPEN (1 << 15)
203#define ATTR_TIMES_SET (1 << 16)
204#define ATTR_TOUCH (1 << 17)
205
206
207
208
209
210#define WHITEOUT_MODE 0
211#define WHITEOUT_DEV 0
212
213
214
215
216
217
218
219
220
221
222struct iattr {
223 unsigned int ia_valid;
224 umode_t ia_mode;
225 kuid_t ia_uid;
226 kgid_t ia_gid;
227 loff_t ia_size;
228 struct timespec64 ia_atime;
229 struct timespec64 ia_mtime;
230 struct timespec64 ia_ctime;
231
232
233
234
235
236
237 struct file *ia_file;
238};
239
240
241
242
243#include <linux/quota.h>
244
245
246
247
248
249#define FILESYSTEM_MAX_STACK_DEPTH 2
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277enum positive_aop_returns {
278 AOP_WRITEPAGE_ACTIVATE = 0x80000,
279 AOP_TRUNCATED_PAGE = 0x80001,
280};
281
282#define AOP_FLAG_CONT_EXPAND 0x0001
283#define AOP_FLAG_NOFS 0x0002
284
285
286
287
288
289
290struct page;
291struct address_space;
292struct writeback_control;
293struct readahead_control;
294
295
296
297
298
299enum rw_hint {
300 WRITE_LIFE_NOT_SET = 0,
301 WRITE_LIFE_NONE = RWH_WRITE_LIFE_NONE,
302 WRITE_LIFE_SHORT = RWH_WRITE_LIFE_SHORT,
303 WRITE_LIFE_MEDIUM = RWH_WRITE_LIFE_MEDIUM,
304 WRITE_LIFE_LONG = RWH_WRITE_LIFE_LONG,
305 WRITE_LIFE_EXTREME = RWH_WRITE_LIFE_EXTREME,
306};
307
308
309#define IOCB_HIPRI (__force int) RWF_HIPRI
310#define IOCB_DSYNC (__force int) RWF_DSYNC
311#define IOCB_SYNC (__force int) RWF_SYNC
312#define IOCB_NOWAIT (__force int) RWF_NOWAIT
313#define IOCB_APPEND (__force int) RWF_APPEND
314
315
316#define IOCB_EVENTFD (1 << 16)
317#define IOCB_DIRECT (1 << 17)
318#define IOCB_WRITE (1 << 18)
319
320#define IOCB_WAITQ (1 << 19)
321#define IOCB_NOIO (1 << 20)
322
323struct kiocb {
324 struct file *ki_filp;
325
326
327 randomized_struct_fields_start
328
329 loff_t ki_pos;
330 void (*ki_complete)(struct kiocb *iocb, long ret, long ret2);
331 void *private;
332 int ki_flags;
333 u16 ki_hint;
334 u16 ki_ioprio;
335 union {
336 unsigned int ki_cookie;
337 struct wait_page_queue *ki_waitq;
338 };
339
340 randomized_struct_fields_end
341};
342
343static inline bool is_sync_kiocb(struct kiocb *kiocb)
344{
345 return kiocb->ki_complete == NULL;
346}
347
348
349
350
351
352
353
354
355
356
357typedef struct {
358 size_t written;
359 size_t count;
360 union {
361 char __user *buf;
362 void *data;
363 } arg;
364 int error;
365} read_descriptor_t;
366
367typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
368 unsigned long, unsigned long);
369
370struct address_space_operations {
371 int (*writepage)(struct page *page, struct writeback_control *wbc);
372 int (*readpage)(struct file *, struct page *);
373
374
375 int (*writepages)(struct address_space *, struct writeback_control *);
376
377
378 int (*set_page_dirty)(struct page *page);
379
380
381
382
383
384 int (*readpages)(struct file *filp, struct address_space *mapping,
385 struct list_head *pages, unsigned nr_pages);
386 void (*readahead)(struct readahead_control *);
387
388 int (*write_begin)(struct file *, struct address_space *mapping,
389 loff_t pos, unsigned len, unsigned flags,
390 struct page **pagep, void **fsdata);
391 int (*write_end)(struct file *, struct address_space *mapping,
392 loff_t pos, unsigned len, unsigned copied,
393 struct page *page, void *fsdata);
394
395
396 sector_t (*bmap)(struct address_space *, sector_t);
397 void (*invalidatepage) (struct page *, unsigned int, unsigned int);
398 int (*releasepage) (struct page *, gfp_t);
399 void (*freepage)(struct page *);
400 ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
401
402
403
404
405 int (*migratepage) (struct address_space *,
406 struct page *, struct page *, enum migrate_mode);
407 bool (*isolate_page)(struct page *, isolate_mode_t);
408 void (*putback_page)(struct page *);
409 int (*launder_page) (struct page *);
410 int (*is_partially_uptodate) (struct page *, unsigned long,
411 unsigned long);
412 void (*is_dirty_writeback) (struct page *, bool *, bool *);
413 int (*error_remove_page)(struct address_space *, struct page *);
414
415
416 int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
417 sector_t *span);
418 void (*swap_deactivate)(struct file *file);
419};
420
421extern const struct address_space_operations empty_aops;
422
423
424
425
426
427int pagecache_write_begin(struct file *, struct address_space *mapping,
428 loff_t pos, unsigned len, unsigned flags,
429 struct page **pagep, void **fsdata);
430
431int pagecache_write_end(struct file *, struct address_space *mapping,
432 loff_t pos, unsigned len, unsigned copied,
433 struct page *page, void *fsdata);
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453struct address_space {
454 struct inode *host;
455 struct xarray i_pages;
456 gfp_t gfp_mask;
457 atomic_t i_mmap_writable;
458#ifdef CONFIG_READ_ONLY_THP_FOR_FS
459
460 atomic_t nr_thps;
461#endif
462 struct rb_root_cached i_mmap;
463 struct rw_semaphore i_mmap_rwsem;
464 unsigned long nrpages;
465 pgoff_t writeback_index;
466 const struct address_space_operations *a_ops;
467 unsigned long flags;
468 errseq_t wb_err;
469 spinlock_t private_lock;
470 struct list_head private_list;
471 void *private_data;
472} __attribute__((aligned(sizeof(long)))) __randomize_layout;
473
474
475
476
477
478
479
480#define PAGECACHE_TAG_DIRTY XA_MARK_0
481#define PAGECACHE_TAG_WRITEBACK XA_MARK_1
482#define PAGECACHE_TAG_TOWRITE XA_MARK_2
483
484
485
486
487static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
488{
489 return xa_marked(&mapping->i_pages, tag);
490}
491
492static inline void i_mmap_lock_write(struct address_space *mapping)
493{
494 down_write(&mapping->i_mmap_rwsem);
495}
496
497static inline int i_mmap_trylock_write(struct address_space *mapping)
498{
499 return down_write_trylock(&mapping->i_mmap_rwsem);
500}
501
502static inline void i_mmap_unlock_write(struct address_space *mapping)
503{
504 up_write(&mapping->i_mmap_rwsem);
505}
506
507static inline void i_mmap_lock_read(struct address_space *mapping)
508{
509 down_read(&mapping->i_mmap_rwsem);
510}
511
512static inline void i_mmap_unlock_read(struct address_space *mapping)
513{
514 up_read(&mapping->i_mmap_rwsem);
515}
516
517static inline void i_mmap_assert_locked(struct address_space *mapping)
518{
519 lockdep_assert_held(&mapping->i_mmap_rwsem);
520}
521
522static inline void i_mmap_assert_write_locked(struct address_space *mapping)
523{
524 lockdep_assert_held_write(&mapping->i_mmap_rwsem);
525}
526
527
528
529
530static inline int mapping_mapped(struct address_space *mapping)
531{
532 return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root);
533}
534
535
536
537
538
539
540
541
542
543
544static inline int mapping_writably_mapped(struct address_space *mapping)
545{
546 return atomic_read(&mapping->i_mmap_writable) > 0;
547}
548
549static inline int mapping_map_writable(struct address_space *mapping)
550{
551 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
552 0 : -EPERM;
553}
554
555static inline void mapping_unmap_writable(struct address_space *mapping)
556{
557 atomic_dec(&mapping->i_mmap_writable);
558}
559
560static inline int mapping_deny_writable(struct address_space *mapping)
561{
562 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
563 0 : -EBUSY;
564}
565
566static inline void mapping_allow_writable(struct address_space *mapping)
567{
568 atomic_inc(&mapping->i_mmap_writable);
569}
570
571
572
573
574#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
575#include <linux/seqlock.h>
576#define __NEED_I_SIZE_ORDERED
577#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
578#else
579#define i_size_ordered_init(inode) do { } while (0)
580#endif
581
582struct posix_acl;
583#define ACL_NOT_CACHED ((void *)(-1))
584#define ACL_DONT_CACHE ((void *)(-3))
585
586static inline struct posix_acl *
587uncached_acl_sentinel(struct task_struct *task)
588{
589 return (void *)task + 1;
590}
591
592static inline bool
593is_uncached_acl(struct posix_acl *acl)
594{
595 return (long)acl & 1;
596}
597
598#define IOP_FASTPERM 0x0001
599#define IOP_LOOKUP 0x0002
600#define IOP_NOFOLLOW 0x0004
601#define IOP_XATTR 0x0008
602#define IOP_DEFAULT_READLINK 0x0010
603
604struct fsnotify_mark_connector;
605
606
607
608
609
610
611struct inode {
612 umode_t i_mode;
613 unsigned short i_opflags;
614 kuid_t i_uid;
615 kgid_t i_gid;
616 unsigned int i_flags;
617
618#ifdef CONFIG_FS_POSIX_ACL
619 struct posix_acl *i_acl;
620 struct posix_acl *i_default_acl;
621#endif
622
623 const struct inode_operations *i_op;
624 struct super_block *i_sb;
625 struct address_space *i_mapping;
626
627#ifdef CONFIG_SECURITY
628 void *i_security;
629#endif
630
631
632 unsigned long i_ino;
633
634
635
636
637
638
639
640 union {
641 const unsigned int i_nlink;
642 unsigned int __i_nlink;
643 };
644 dev_t i_rdev;
645 loff_t i_size;
646 struct timespec64 i_atime;
647 struct timespec64 i_mtime;
648 struct timespec64 i_ctime;
649 spinlock_t i_lock;
650 unsigned short i_bytes;
651 u8 i_blkbits;
652 u8 i_write_hint;
653 blkcnt_t i_blocks;
654
655#ifdef __NEED_I_SIZE_ORDERED
656 seqcount_t i_size_seqcount;
657#endif
658
659
660 unsigned long i_state;
661 struct rw_semaphore i_rwsem;
662
663 unsigned long dirtied_when;
664 unsigned long dirtied_time_when;
665
666 struct hlist_node i_hash;
667 struct list_head i_io_list;
668#ifdef CONFIG_CGROUP_WRITEBACK
669 struct bdi_writeback *i_wb;
670
671
672 int i_wb_frn_winner;
673 u16 i_wb_frn_avg_time;
674 u16 i_wb_frn_history;
675#endif
676 struct list_head i_lru;
677 struct list_head i_sb_list;
678 struct list_head i_wb_list;
679 union {
680 struct hlist_head i_dentry;
681 struct rcu_head i_rcu;
682 };
683 atomic64_t i_version;
684 atomic64_t i_sequence;
685 atomic_t i_count;
686 atomic_t i_dio_count;
687 atomic_t i_writecount;
688#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
689 atomic_t i_readcount;
690#endif
691 union {
692 const struct file_operations *i_fop;
693 void (*free_inode)(struct inode *);
694 };
695 struct file_lock_context *i_flctx;
696 struct address_space i_data;
697 struct list_head i_devices;
698 union {
699 struct pipe_inode_info *i_pipe;
700 struct cdev *i_cdev;
701 char *i_link;
702 unsigned i_dir_seq;
703 };
704
705 __u32 i_generation;
706
707#ifdef CONFIG_FSNOTIFY
708 __u32 i_fsnotify_mask;
709 struct fsnotify_mark_connector __rcu *i_fsnotify_marks;
710#endif
711
712#ifdef CONFIG_FS_ENCRYPTION
713 struct fscrypt_info *i_crypt_info;
714#endif
715
716#ifdef CONFIG_FS_VERITY
717 struct fsverity_info *i_verity_info;
718#endif
719
720 void *i_private;
721} __randomize_layout;
722
723struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
724
725static inline unsigned int i_blocksize(const struct inode *node)
726{
727 return (1 << node->i_blkbits);
728}
729
730static inline int inode_unhashed(struct inode *inode)
731{
732 return hlist_unhashed(&inode->i_hash);
733}
734
735
736
737
738
739
740
741static inline void inode_fake_hash(struct inode *inode)
742{
743 hlist_add_fake(&inode->i_hash);
744}
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762enum inode_i_mutex_lock_class
763{
764 I_MUTEX_NORMAL,
765 I_MUTEX_PARENT,
766 I_MUTEX_CHILD,
767 I_MUTEX_XATTR,
768 I_MUTEX_NONDIR2,
769 I_MUTEX_PARENT2,
770};
771
772static inline void inode_lock(struct inode *inode)
773{
774 down_write(&inode->i_rwsem);
775}
776
777static inline void inode_unlock(struct inode *inode)
778{
779 up_write(&inode->i_rwsem);
780}
781
782static inline void inode_lock_shared(struct inode *inode)
783{
784 down_read(&inode->i_rwsem);
785}
786
787static inline void inode_unlock_shared(struct inode *inode)
788{
789 up_read(&inode->i_rwsem);
790}
791
792static inline int inode_trylock(struct inode *inode)
793{
794 return down_write_trylock(&inode->i_rwsem);
795}
796
797static inline int inode_trylock_shared(struct inode *inode)
798{
799 return down_read_trylock(&inode->i_rwsem);
800}
801
802static inline int inode_is_locked(struct inode *inode)
803{
804 return rwsem_is_locked(&inode->i_rwsem);
805}
806
807static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
808{
809 down_write_nested(&inode->i_rwsem, subclass);
810}
811
812static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
813{
814 down_read_nested(&inode->i_rwsem, subclass);
815}
816
817void lock_two_nondirectories(struct inode *, struct inode*);
818void unlock_two_nondirectories(struct inode *, struct inode*);
819
820
821
822
823
824
825
826
827
828
829
830static inline loff_t i_size_read(const struct inode *inode)
831{
832#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
833 loff_t i_size;
834 unsigned int seq;
835
836 do {
837 seq = read_seqcount_begin(&inode->i_size_seqcount);
838 i_size = inode->i_size;
839 } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
840 return i_size;
841#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
842 loff_t i_size;
843
844 preempt_disable();
845 i_size = inode->i_size;
846 preempt_enable();
847 return i_size;
848#else
849 return inode->i_size;
850#endif
851}
852
853
854
855
856
857
858static inline void i_size_write(struct inode *inode, loff_t i_size)
859{
860#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
861 preempt_disable();
862 write_seqcount_begin(&inode->i_size_seqcount);
863 inode->i_size = i_size;
864 write_seqcount_end(&inode->i_size_seqcount);
865 preempt_enable();
866#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
867 preempt_disable();
868 inode->i_size = i_size;
869 preempt_enable();
870#else
871 inode->i_size = i_size;
872#endif
873}
874
875static inline unsigned iminor(const struct inode *inode)
876{
877 return MINOR(inode->i_rdev);
878}
879
880static inline unsigned imajor(const struct inode *inode)
881{
882 return MAJOR(inode->i_rdev);
883}
884
885struct fown_struct {
886 rwlock_t lock;
887 struct pid *pid;
888 enum pid_type pid_type;
889 kuid_t uid, euid;
890 int signum;
891};
892
893
894
895
896
897
898
899
900
901
902struct file_ra_state {
903 pgoff_t start;
904 unsigned int size;
905 unsigned int async_size;
906 unsigned int ra_pages;
907 unsigned int mmap_miss;
908 loff_t prev_pos;
909};
910
911
912
913
914static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
915{
916 return (index >= ra->start &&
917 index < ra->start + ra->size);
918}
919
920struct file {
921 union {
922 struct llist_node fu_llist;
923 struct rcu_head fu_rcuhead;
924 } f_u;
925 struct path f_path;
926 struct inode *f_inode;
927 const struct file_operations *f_op;
928
929
930
931
932
933 spinlock_t f_lock;
934 enum rw_hint f_write_hint;
935 atomic_long_t f_count;
936 unsigned int f_flags;
937 fmode_t f_mode;
938 struct mutex f_pos_lock;
939 loff_t f_pos;
940 struct fown_struct f_owner;
941 const struct cred *f_cred;
942 struct file_ra_state f_ra;
943
944 u64 f_version;
945#ifdef CONFIG_SECURITY
946 void *f_security;
947#endif
948
949 void *private_data;
950
951#ifdef CONFIG_EPOLL
952
953 struct hlist_head *f_ep;
954#endif
955 struct address_space *f_mapping;
956 errseq_t f_wb_err;
957 errseq_t f_sb_err;
958} __randomize_layout
959 __attribute__((aligned(4)));
960
961struct file_handle {
962 __u32 handle_bytes;
963 int handle_type;
964
965 unsigned char f_handle[];
966};
967
968static inline struct file *get_file(struct file *f)
969{
970 atomic_long_inc(&f->f_count);
971 return f;
972}
973#define get_file_rcu_many(x, cnt) \
974 atomic_long_add_unless(&(x)->f_count, (cnt), 0)
975#define get_file_rcu(x) get_file_rcu_many((x), 1)
976#define file_count(x) atomic_long_read(&(x)->f_count)
977
978#define MAX_NON_LFS ((1UL<<31) - 1)
979
980
981
982#if BITS_PER_LONG==32
983#define MAX_LFS_FILESIZE ((loff_t)ULONG_MAX << PAGE_SHIFT)
984#elif BITS_PER_LONG==64
985#define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX)
986#endif
987
988#define FL_POSIX 1
989#define FL_FLOCK 2
990#define FL_DELEG 4
991#define FL_ACCESS 8
992#define FL_EXISTS 16
993#define FL_LEASE 32
994#define FL_CLOSE 64
995#define FL_SLEEP 128
996#define FL_DOWNGRADE_PENDING 256
997#define FL_UNLOCK_PENDING 512
998#define FL_OFDLCK 1024
999#define FL_LAYOUT 2048
1000
1001#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE)
1002
1003
1004
1005
1006
1007#define FILE_LOCK_DEFERRED 1
1008
1009
1010typedef void *fl_owner_t;
1011
1012struct file_lock;
1013
1014struct file_lock_operations {
1015 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
1016 void (*fl_release_private)(struct file_lock *);
1017};
1018
1019struct lock_manager_operations {
1020 fl_owner_t (*lm_get_owner)(fl_owner_t);
1021 void (*lm_put_owner)(fl_owner_t);
1022 void (*lm_notify)(struct file_lock *);
1023 int (*lm_grant)(struct file_lock *, int);
1024 bool (*lm_break)(struct file_lock *);
1025 int (*lm_change)(struct file_lock *, int, struct list_head *);
1026 void (*lm_setup)(struct file_lock *, void **);
1027 bool (*lm_breaker_owns_lease)(struct file_lock *);
1028};
1029
1030struct lock_manager {
1031 struct list_head list;
1032
1033
1034
1035
1036 bool block_opens;
1037};
1038
1039struct net;
1040void locks_start_grace(struct net *, struct lock_manager *);
1041void locks_end_grace(struct lock_manager *);
1042bool locks_in_grace(struct net *);
1043bool opens_in_grace(struct net *);
1044
1045
1046#include <linux/nfs_fs_i.h>
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065struct file_lock {
1066 struct file_lock *fl_blocker;
1067 struct list_head fl_list;
1068 struct hlist_node fl_link;
1069 struct list_head fl_blocked_requests;
1070
1071
1072 struct list_head fl_blocked_member;
1073
1074
1075 fl_owner_t fl_owner;
1076 unsigned int fl_flags;
1077 unsigned char fl_type;
1078 unsigned int fl_pid;
1079 int fl_link_cpu;
1080 wait_queue_head_t fl_wait;
1081 struct file *fl_file;
1082 loff_t fl_start;
1083 loff_t fl_end;
1084
1085 struct fasync_struct * fl_fasync;
1086
1087 unsigned long fl_break_time;
1088 unsigned long fl_downgrade_time;
1089
1090 const struct file_lock_operations *fl_ops;
1091 const struct lock_manager_operations *fl_lmops;
1092 union {
1093 struct nfs_lock_info nfs_fl;
1094 struct nfs4_lock_info nfs4_fl;
1095 struct {
1096 struct list_head link;
1097 int state;
1098 unsigned int debug_id;
1099 } afs;
1100 } fl_u;
1101} __randomize_layout;
1102
1103struct file_lock_context {
1104 spinlock_t flc_lock;
1105 struct list_head flc_flock;
1106 struct list_head flc_posix;
1107 struct list_head flc_lease;
1108};
1109
1110
1111#ifndef OFFSET_MAX
1112#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
1113#define OFFSET_MAX INT_LIMIT(loff_t)
1114#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
1115#endif
1116
1117extern void send_sigio(struct fown_struct *fown, int fd, int band);
1118
1119#define locks_inode(f) file_inode(f)
1120
1121#ifdef CONFIG_FILE_LOCKING
1122extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
1123extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1124 struct flock *);
1125
1126#if BITS_PER_LONG == 32
1127extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
1128extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1129 struct flock64 *);
1130#endif
1131
1132extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1133extern int fcntl_getlease(struct file *filp);
1134
1135
1136void locks_free_lock_context(struct inode *inode);
1137void locks_free_lock(struct file_lock *fl);
1138extern void locks_init_lock(struct file_lock *);
1139extern struct file_lock * locks_alloc_lock(void);
1140extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1141extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
1142extern void locks_remove_posix(struct file *, fl_owner_t);
1143extern void locks_remove_file(struct file *);
1144extern void locks_release_private(struct file_lock *);
1145extern void posix_test_lock(struct file *, struct file_lock *);
1146extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1147extern int locks_delete_block(struct file_lock *);
1148extern int vfs_test_lock(struct file *, struct file_lock *);
1149extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
1150extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1151extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
1152extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
1153extern void lease_get_mtime(struct inode *, struct timespec64 *time);
1154extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
1155extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
1156extern int lease_modify(struct file_lock *, int, struct list_head *);
1157
1158struct notifier_block;
1159extern int lease_register_notifier(struct notifier_block *);
1160extern void lease_unregister_notifier(struct notifier_block *);
1161
1162struct files_struct;
1163extern void show_fd_locks(struct seq_file *f,
1164 struct file *filp, struct files_struct *files);
1165#else
1166static inline int fcntl_getlk(struct file *file, unsigned int cmd,
1167 struct flock __user *user)
1168{
1169 return -EINVAL;
1170}
1171
1172static inline int fcntl_setlk(unsigned int fd, struct file *file,
1173 unsigned int cmd, struct flock __user *user)
1174{
1175 return -EACCES;
1176}
1177
1178#if BITS_PER_LONG == 32
1179static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
1180 struct flock64 __user *user)
1181{
1182 return -EINVAL;
1183}
1184
1185static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1186 unsigned int cmd, struct flock64 __user *user)
1187{
1188 return -EACCES;
1189}
1190#endif
1191static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1192{
1193 return -EINVAL;
1194}
1195
1196static inline int fcntl_getlease(struct file *filp)
1197{
1198 return F_UNLCK;
1199}
1200
1201static inline void
1202locks_free_lock_context(struct inode *inode)
1203{
1204}
1205
1206static inline void locks_init_lock(struct file_lock *fl)
1207{
1208 return;
1209}
1210
1211static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
1212{
1213 return;
1214}
1215
1216static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1217{
1218 return;
1219}
1220
1221static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1222{
1223 return;
1224}
1225
1226static inline void locks_remove_file(struct file *filp)
1227{
1228 return;
1229}
1230
1231static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1232{
1233 return;
1234}
1235
1236static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1237 struct file_lock *conflock)
1238{
1239 return -ENOLCK;
1240}
1241
1242static inline int locks_delete_block(struct file_lock *waiter)
1243{
1244 return -ENOENT;
1245}
1246
1247static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1248{
1249 return 0;
1250}
1251
1252static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
1253 struct file_lock *fl, struct file_lock *conf)
1254{
1255 return -ENOLCK;
1256}
1257
1258static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1259{
1260 return 0;
1261}
1262
1263static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1264{
1265 return -ENOLCK;
1266}
1267
1268static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1269{
1270 return 0;
1271}
1272
1273static inline void lease_get_mtime(struct inode *inode,
1274 struct timespec64 *time)
1275{
1276 return;
1277}
1278
1279static inline int generic_setlease(struct file *filp, long arg,
1280 struct file_lock **flp, void **priv)
1281{
1282 return -EINVAL;
1283}
1284
1285static inline int vfs_setlease(struct file *filp, long arg,
1286 struct file_lock **lease, void **priv)
1287{
1288 return -EINVAL;
1289}
1290
1291static inline int lease_modify(struct file_lock *fl, int arg,
1292 struct list_head *dispose)
1293{
1294 return -EINVAL;
1295}
1296
1297struct files_struct;
1298static inline void show_fd_locks(struct seq_file *f,
1299 struct file *filp, struct files_struct *files) {}
1300#endif
1301
1302static inline struct inode *file_inode(const struct file *f)
1303{
1304 return f->f_inode;
1305}
1306
1307static inline struct dentry *file_dentry(const struct file *file)
1308{
1309 return d_real(file->f_path.dentry, file_inode(file));
1310}
1311
1312static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
1313{
1314 return locks_lock_inode_wait(locks_inode(filp), fl);
1315}
1316
1317struct fasync_struct {
1318 rwlock_t fa_lock;
1319 int magic;
1320 int fa_fd;
1321 struct fasync_struct *fa_next;
1322 struct file *fa_file;
1323 struct rcu_head fa_rcu;
1324};
1325
1326#define FASYNC_MAGIC 0x4601
1327
1328
1329extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
1330extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1331extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1332extern struct fasync_struct *fasync_alloc(void);
1333extern void fasync_free(struct fasync_struct *);
1334
1335
1336extern void kill_fasync(struct fasync_struct **, int, int);
1337
1338extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1339extern int f_setown(struct file *filp, unsigned long arg, int force);
1340extern void f_delown(struct file *filp);
1341extern pid_t f_getown(struct file *filp);
1342extern int send_sigurg(struct fown_struct *fown);
1343
1344
1345
1346
1347
1348#define SB_RDONLY 1
1349#define SB_NOSUID 2
1350#define SB_NODEV 4
1351#define SB_NOEXEC 8
1352#define SB_SYNCHRONOUS 16
1353#define SB_MANDLOCK 64
1354#define SB_DIRSYNC 128
1355#define SB_NOATIME 1024
1356#define SB_NODIRATIME 2048
1357#define SB_SILENT 32768
1358#define SB_POSIXACL (1<<16)
1359#define SB_INLINECRYPT (1<<17)
1360#define SB_KERNMOUNT (1<<22)
1361#define SB_I_VERSION (1<<23)
1362#define SB_LAZYTIME (1<<25)
1363
1364
1365#define SB_SUBMOUNT (1<<26)
1366#define SB_FORCE (1<<27)
1367#define SB_NOSEC (1<<28)
1368#define SB_BORN (1<<29)
1369#define SB_ACTIVE (1<<30)
1370#define SB_NOUSER (1<<31)
1371
1372
1373#define SB_ENC_STRICT_MODE_FL (1 << 0)
1374
1375#define sb_has_strict_encoding(sb) \
1376 (sb->s_encoding_flags & SB_ENC_STRICT_MODE_FL)
1377
1378
1379
1380
1381
1382#define MNT_FORCE 0x00000001
1383#define MNT_DETACH 0x00000002
1384#define MNT_EXPIRE 0x00000004
1385#define UMOUNT_NOFOLLOW 0x00000008
1386#define UMOUNT_UNUSED 0x80000000
1387
1388
1389#define SB_I_CGROUPWB 0x00000001
1390#define SB_I_NOEXEC 0x00000002
1391#define SB_I_NODEV 0x00000004
1392#define SB_I_STABLE_WRITES 0x00000008
1393
1394
1395#define SB_I_USERNS_VISIBLE 0x00000010
1396#define SB_I_IMA_UNVERIFIABLE_SIGNATURE 0x00000020
1397#define SB_I_UNTRUSTED_MOUNTER 0x00000040
1398
1399#define SB_I_SKIP_SYNC 0x00000100
1400
1401
1402enum {
1403 SB_UNFROZEN = 0,
1404 SB_FREEZE_WRITE = 1,
1405 SB_FREEZE_PAGEFAULT = 2,
1406 SB_FREEZE_FS = 3,
1407
1408 SB_FREEZE_COMPLETE = 4,
1409};
1410
1411#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1412
1413struct sb_writers {
1414 int frozen;
1415 wait_queue_head_t wait_unfrozen;
1416 struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
1417};
1418
1419struct super_block {
1420 struct list_head s_list;
1421 dev_t s_dev;
1422 unsigned char s_blocksize_bits;
1423 unsigned long s_blocksize;
1424 loff_t s_maxbytes;
1425 struct file_system_type *s_type;
1426 const struct super_operations *s_op;
1427 const struct dquot_operations *dq_op;
1428 const struct quotactl_ops *s_qcop;
1429 const struct export_operations *s_export_op;
1430 unsigned long s_flags;
1431 unsigned long s_iflags;
1432 unsigned long s_magic;
1433 struct dentry *s_root;
1434 struct rw_semaphore s_umount;
1435 int s_count;
1436 atomic_t s_active;
1437#ifdef CONFIG_SECURITY
1438 void *s_security;
1439#endif
1440 const struct xattr_handler **s_xattr;
1441#ifdef CONFIG_FS_ENCRYPTION
1442 const struct fscrypt_operations *s_cop;
1443 struct key *s_master_keys;
1444#endif
1445#ifdef CONFIG_FS_VERITY
1446 const struct fsverity_operations *s_vop;
1447#endif
1448#ifdef CONFIG_UNICODE
1449 struct unicode_map *s_encoding;
1450 __u16 s_encoding_flags;
1451#endif
1452 struct hlist_bl_head s_roots;
1453 struct list_head s_mounts;
1454 struct block_device *s_bdev;
1455 struct backing_dev_info *s_bdi;
1456 struct mtd_info *s_mtd;
1457 struct hlist_node s_instances;
1458 unsigned int s_quota_types;
1459 struct quota_info s_dquot;
1460
1461 struct sb_writers s_writers;
1462
1463
1464
1465
1466
1467
1468 void *s_fs_info;
1469
1470
1471 u32 s_time_gran;
1472
1473 time64_t s_time_min;
1474 time64_t s_time_max;
1475#ifdef CONFIG_FSNOTIFY
1476 __u32 s_fsnotify_mask;
1477 struct fsnotify_mark_connector __rcu *s_fsnotify_marks;
1478#endif
1479
1480 char s_id[32];
1481 uuid_t s_uuid;
1482
1483 unsigned int s_max_links;
1484 fmode_t s_mode;
1485
1486
1487
1488
1489
1490 struct mutex s_vfs_rename_mutex;
1491
1492
1493
1494
1495
1496 const char *s_subtype;
1497
1498 const struct dentry_operations *s_d_op;
1499
1500
1501
1502
1503 int cleancache_poolid;
1504
1505 struct shrinker s_shrink;
1506
1507
1508 atomic_long_t s_remove_count;
1509
1510
1511 atomic_long_t s_fsnotify_inode_refs;
1512
1513
1514 int s_readonly_remount;
1515
1516
1517 errseq_t s_wb_err;
1518
1519
1520 struct workqueue_struct *s_dio_done_wq;
1521 struct hlist_head s_pins;
1522
1523
1524
1525
1526
1527
1528 struct user_namespace *s_user_ns;
1529
1530
1531
1532
1533
1534
1535 struct list_lru s_dentry_lru;
1536 struct list_lru s_inode_lru;
1537 struct rcu_head rcu;
1538 struct work_struct destroy_work;
1539
1540 struct mutex s_sync_lock;
1541
1542
1543
1544
1545 int s_stack_depth;
1546
1547
1548 spinlock_t s_inode_list_lock ____cacheline_aligned_in_smp;
1549 struct list_head s_inodes;
1550
1551 spinlock_t s_inode_wblist_lock;
1552 struct list_head s_inodes_wb;
1553} __randomize_layout;
1554
1555
1556
1557
1558
1559
1560static inline uid_t i_uid_read(const struct inode *inode)
1561{
1562 return from_kuid(inode->i_sb->s_user_ns, inode->i_uid);
1563}
1564
1565static inline gid_t i_gid_read(const struct inode *inode)
1566{
1567 return from_kgid(inode->i_sb->s_user_ns, inode->i_gid);
1568}
1569
1570static inline void i_uid_write(struct inode *inode, uid_t uid)
1571{
1572 inode->i_uid = make_kuid(inode->i_sb->s_user_ns, uid);
1573}
1574
1575static inline void i_gid_write(struct inode *inode, gid_t gid)
1576{
1577 inode->i_gid = make_kgid(inode->i_sb->s_user_ns, gid);
1578}
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588static inline kuid_t kuid_into_mnt(struct user_namespace *mnt_userns,
1589 kuid_t kuid)
1590{
1591 return make_kuid(mnt_userns, __kuid_val(kuid));
1592}
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602static inline kgid_t kgid_into_mnt(struct user_namespace *mnt_userns,
1603 kgid_t kgid)
1604{
1605 return make_kgid(mnt_userns, __kgid_val(kgid));
1606}
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616static inline kuid_t i_uid_into_mnt(struct user_namespace *mnt_userns,
1617 const struct inode *inode)
1618{
1619 return kuid_into_mnt(mnt_userns, inode->i_uid);
1620}
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630static inline kgid_t i_gid_into_mnt(struct user_namespace *mnt_userns,
1631 const struct inode *inode)
1632{
1633 return kgid_into_mnt(mnt_userns, inode->i_gid);
1634}
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644static inline kuid_t kuid_from_mnt(struct user_namespace *mnt_userns,
1645 kuid_t kuid)
1646{
1647 return KUIDT_INIT(from_kuid(mnt_userns, kuid));
1648}
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658static inline kgid_t kgid_from_mnt(struct user_namespace *mnt_userns,
1659 kgid_t kgid)
1660{
1661 return KGIDT_INIT(from_kgid(mnt_userns, kgid));
1662}
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676static inline kuid_t mapped_fsuid(struct user_namespace *mnt_userns)
1677{
1678 return kuid_from_mnt(mnt_userns, current_fsuid());
1679}
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693static inline kgid_t mapped_fsgid(struct user_namespace *mnt_userns)
1694{
1695 return kgid_from_mnt(mnt_userns, current_fsgid());
1696}
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706static inline void inode_fsuid_set(struct inode *inode,
1707 struct user_namespace *mnt_userns)
1708{
1709 inode->i_uid = mapped_fsuid(mnt_userns);
1710}
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720static inline void inode_fsgid_set(struct inode *inode,
1721 struct user_namespace *mnt_userns)
1722{
1723 inode->i_gid = mapped_fsgid(mnt_userns);
1724}
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737static inline bool fsuidgid_has_mapping(struct super_block *sb,
1738 struct user_namespace *mnt_userns)
1739{
1740 struct user_namespace *s_user_ns = sb->s_user_ns;
1741
1742 return kuid_has_mapping(s_user_ns, mapped_fsuid(mnt_userns)) &&
1743 kgid_has_mapping(s_user_ns, mapped_fsgid(mnt_userns));
1744}
1745
1746extern struct timespec64 current_time(struct inode *inode);
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756static inline void __sb_end_write(struct super_block *sb, int level)
1757{
1758 percpu_up_read(sb->s_writers.rw_sem + level-1);
1759}
1760
1761static inline void __sb_start_write(struct super_block *sb, int level)
1762{
1763 percpu_down_read(sb->s_writers.rw_sem + level - 1);
1764}
1765
1766static inline bool __sb_start_write_trylock(struct super_block *sb, int level)
1767{
1768 return percpu_down_read_trylock(sb->s_writers.rw_sem + level - 1);
1769}
1770
1771#define __sb_writers_acquired(sb, lev) \
1772 percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1773#define __sb_writers_release(sb, lev) \
1774 percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1775
1776
1777
1778
1779
1780
1781
1782
1783static inline void sb_end_write(struct super_block *sb)
1784{
1785 __sb_end_write(sb, SB_FREEZE_WRITE);
1786}
1787
1788
1789
1790
1791
1792
1793
1794
1795static inline void sb_end_pagefault(struct super_block *sb)
1796{
1797 __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
1798}
1799
1800
1801
1802
1803
1804
1805
1806
1807static inline void sb_end_intwrite(struct super_block *sb)
1808{
1809 __sb_end_write(sb, SB_FREEZE_FS);
1810}
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831static inline void sb_start_write(struct super_block *sb)
1832{
1833 __sb_start_write(sb, SB_FREEZE_WRITE);
1834}
1835
1836static inline bool sb_start_write_trylock(struct super_block *sb)
1837{
1838 return __sb_start_write_trylock(sb, SB_FREEZE_WRITE);
1839}
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860static inline void sb_start_pagefault(struct super_block *sb)
1861{
1862 __sb_start_write(sb, SB_FREEZE_PAGEFAULT);
1863}
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878static inline void sb_start_intwrite(struct super_block *sb)
1879{
1880 __sb_start_write(sb, SB_FREEZE_FS);
1881}
1882
1883static inline bool sb_start_intwrite_trylock(struct super_block *sb)
1884{
1885 return __sb_start_write_trylock(sb, SB_FREEZE_FS);
1886}
1887
1888bool inode_owner_or_capable(struct user_namespace *mnt_userns,
1889 const struct inode *inode);
1890
1891
1892
1893
1894int vfs_create(struct user_namespace *, struct inode *,
1895 struct dentry *, umode_t, bool);
1896int vfs_mkdir(struct user_namespace *, struct inode *,
1897 struct dentry *, umode_t);
1898int vfs_mknod(struct user_namespace *, struct inode *, struct dentry *,
1899 umode_t, dev_t);
1900int vfs_symlink(struct user_namespace *, struct inode *,
1901 struct dentry *, const char *);
1902int vfs_link(struct dentry *, struct user_namespace *, struct inode *,
1903 struct dentry *, struct inode **);
1904int vfs_rmdir(struct user_namespace *, struct inode *, struct dentry *);
1905int vfs_unlink(struct user_namespace *, struct inode *, struct dentry *,
1906 struct inode **);
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919struct renamedata {
1920 struct user_namespace *old_mnt_userns;
1921 struct inode *old_dir;
1922 struct dentry *old_dentry;
1923 struct user_namespace *new_mnt_userns;
1924 struct inode *new_dir;
1925 struct dentry *new_dentry;
1926 struct inode **delegated_inode;
1927 unsigned int flags;
1928} __randomize_layout;
1929
1930int vfs_rename(struct renamedata *);
1931
1932static inline int vfs_whiteout(struct user_namespace *mnt_userns,
1933 struct inode *dir, struct dentry *dentry)
1934{
1935 return vfs_mknod(mnt_userns, dir, dentry, S_IFCHR | WHITEOUT_MODE,
1936 WHITEOUT_DEV);
1937}
1938
1939struct dentry *vfs_tmpfile(struct user_namespace *mnt_userns,
1940 struct dentry *dentry, umode_t mode, int open_flag);
1941
1942int vfs_mkobj(struct dentry *, umode_t,
1943 int (*f)(struct dentry *, umode_t, void *),
1944 void *);
1945
1946int vfs_fchown(struct file *file, uid_t user, gid_t group);
1947int vfs_fchmod(struct file *file, umode_t mode);
1948int vfs_utimes(const struct path *path, struct timespec64 *times);
1949
1950extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1951
1952#ifdef CONFIG_COMPAT
1953extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
1954 unsigned long arg);
1955#else
1956#define compat_ptr_ioctl NULL
1957#endif
1958
1959
1960
1961
1962void inode_init_owner(struct user_namespace *mnt_userns, struct inode *inode,
1963 const struct inode *dir, umode_t mode);
1964extern bool may_open_dev(const struct path *path);
1965
1966
1967
1968
1969
1970
1971
1972struct dir_context;
1973typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
1974 unsigned);
1975
1976struct dir_context {
1977 filldir_t actor;
1978 loff_t pos;
1979};
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991#define NOMMU_MAP_COPY 0x00000001
1992#define NOMMU_MAP_DIRECT 0x00000008
1993#define NOMMU_MAP_READ VM_MAYREAD
1994#define NOMMU_MAP_WRITE VM_MAYWRITE
1995#define NOMMU_MAP_EXEC VM_MAYEXEC
1996
1997#define NOMMU_VMFLAGS \
1998 (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008#define REMAP_FILE_DEDUP (1 << 0)
2009#define REMAP_FILE_CAN_SHORTEN (1 << 1)
2010
2011
2012
2013
2014
2015
2016
2017
2018#define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN)
2019
2020struct iov_iter;
2021
2022struct file_operations {
2023 struct module *owner;
2024 loff_t (*llseek) (struct file *, loff_t, int);
2025 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
2026 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
2027 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
2028 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
2029 int (*iopoll)(struct kiocb *kiocb, bool spin);
2030 int (*iterate) (struct file *, struct dir_context *);
2031 int (*iterate_shared) (struct file *, struct dir_context *);
2032 __poll_t (*poll) (struct file *, struct poll_table_struct *);
2033 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
2034 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
2035 int (*mmap) (struct file *, struct vm_area_struct *);
2036 unsigned long mmap_supported_flags;
2037 int (*open) (struct inode *, struct file *);
2038 int (*flush) (struct file *, fl_owner_t id);
2039 int (*release) (struct inode *, struct file *);
2040 int (*fsync) (struct file *, loff_t, loff_t, int datasync);
2041 int (*fasync) (int, struct file *, int);
2042 int (*lock) (struct file *, int, struct file_lock *);
2043 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
2044 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
2045 int (*check_flags)(int);
2046 int (*flock) (struct file *, int, struct file_lock *);
2047 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
2048 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
2049 int (*setlease)(struct file *, long, struct file_lock **, void **);
2050 long (*fallocate)(struct file *file, int mode, loff_t offset,
2051 loff_t len);
2052 void (*show_fdinfo)(struct seq_file *m, struct file *f);
2053#ifndef CONFIG_MMU
2054 unsigned (*mmap_capabilities)(struct file *);
2055#endif
2056 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
2057 loff_t, size_t, unsigned int);
2058 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
2059 struct file *file_out, loff_t pos_out,
2060 loff_t len, unsigned int remap_flags);
2061 int (*fadvise)(struct file *, loff_t, loff_t, int);
2062} __randomize_layout;
2063
2064struct inode_operations {
2065 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
2066 const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
2067 int (*permission) (struct user_namespace *, struct inode *, int);
2068 struct posix_acl * (*get_acl)(struct inode *, int);
2069
2070 int (*readlink) (struct dentry *, char __user *,int);
2071
2072 int (*create) (struct user_namespace *, struct inode *,struct dentry *,
2073 umode_t, bool);
2074 int (*link) (struct dentry *,struct inode *,struct dentry *);
2075 int (*unlink) (struct inode *,struct dentry *);
2076 int (*symlink) (struct user_namespace *, struct inode *,struct dentry *,
2077 const char *);
2078 int (*mkdir) (struct user_namespace *, struct inode *,struct dentry *,
2079 umode_t);
2080 int (*rmdir) (struct inode *,struct dentry *);
2081 int (*mknod) (struct user_namespace *, struct inode *,struct dentry *,
2082 umode_t,dev_t);
2083 int (*rename) (struct user_namespace *, struct inode *, struct dentry *,
2084 struct inode *, struct dentry *, unsigned int);
2085 int (*setattr) (struct user_namespace *, struct dentry *,
2086 struct iattr *);
2087 int (*getattr) (struct user_namespace *, const struct path *,
2088 struct kstat *, u32, unsigned int);
2089 ssize_t (*listxattr) (struct dentry *, char *, size_t);
2090 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
2091 u64 len);
2092 int (*update_time)(struct inode *, struct timespec64 *, int);
2093 int (*atomic_open)(struct inode *, struct dentry *,
2094 struct file *, unsigned open_flag,
2095 umode_t create_mode);
2096 int (*tmpfile) (struct user_namespace *, struct inode *,
2097 struct dentry *, umode_t);
2098 int (*set_acl)(struct user_namespace *, struct inode *,
2099 struct posix_acl *, int);
2100 int (*fileattr_set)(struct user_namespace *mnt_userns,
2101 struct dentry *dentry, struct fileattr *fa);
2102 int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);
2103} ____cacheline_aligned;
2104
2105static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
2106 struct iov_iter *iter)
2107{
2108 return file->f_op->read_iter(kio, iter);
2109}
2110
2111static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
2112 struct iov_iter *iter)
2113{
2114 return file->f_op->write_iter(kio, iter);
2115}
2116
2117static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
2118{
2119 return file->f_op->mmap(file, vma);
2120}
2121
2122extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
2123extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
2124extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
2125 loff_t, size_t, unsigned int);
2126extern ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in,
2127 struct file *file_out, loff_t pos_out,
2128 size_t len, unsigned int flags);
2129extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2130 struct file *file_out, loff_t pos_out,
2131 loff_t *count,
2132 unsigned int remap_flags);
2133extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
2134 struct file *file_out, loff_t pos_out,
2135 loff_t len, unsigned int remap_flags);
2136extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
2137 struct file *file_out, loff_t pos_out,
2138 loff_t len, unsigned int remap_flags);
2139extern int vfs_dedupe_file_range(struct file *file,
2140 struct file_dedupe_range *same);
2141extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
2142 struct file *dst_file, loff_t dst_pos,
2143 loff_t len, unsigned int remap_flags);
2144
2145
2146struct super_operations {
2147 struct inode *(*alloc_inode)(struct super_block *sb);
2148 void (*destroy_inode)(struct inode *);
2149 void (*free_inode)(struct inode *);
2150
2151 void (*dirty_inode) (struct inode *, int flags);
2152 int (*write_inode) (struct inode *, struct writeback_control *wbc);
2153 int (*drop_inode) (struct inode *);
2154 void (*evict_inode) (struct inode *);
2155 void (*put_super) (struct super_block *);
2156 int (*sync_fs)(struct super_block *sb, int wait);
2157 int (*freeze_super) (struct super_block *);
2158 int (*freeze_fs) (struct super_block *);
2159 int (*thaw_super) (struct super_block *);
2160 int (*unfreeze_fs) (struct super_block *);
2161 int (*statfs) (struct dentry *, struct kstatfs *);
2162 int (*remount_fs) (struct super_block *, int *, char *);
2163 void (*umount_begin) (struct super_block *);
2164
2165 int (*show_options)(struct seq_file *, struct dentry *);
2166 int (*show_devname)(struct seq_file *, struct dentry *);
2167 int (*show_path)(struct seq_file *, struct dentry *);
2168 int (*show_stats)(struct seq_file *, struct dentry *);
2169#ifdef CONFIG_QUOTA
2170 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
2171 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
2172 struct dquot **(*get_dquots)(struct inode *);
2173#endif
2174 long (*nr_cached_objects)(struct super_block *,
2175 struct shrink_control *);
2176 long (*free_cached_objects)(struct super_block *,
2177 struct shrink_control *);
2178};
2179
2180
2181
2182
2183#define S_SYNC (1 << 0)
2184#define S_NOATIME (1 << 1)
2185#define S_APPEND (1 << 2)
2186#define S_IMMUTABLE (1 << 3)
2187#define S_DEAD (1 << 4)
2188#define S_NOQUOTA (1 << 5)
2189#define S_DIRSYNC (1 << 6)
2190#define S_NOCMTIME (1 << 7)
2191#define S_SWAPFILE (1 << 8)
2192#define S_PRIVATE (1 << 9)
2193#define S_IMA (1 << 10)
2194#define S_AUTOMOUNT (1 << 11)
2195#define S_NOSEC (1 << 12)
2196#ifdef CONFIG_FS_DAX
2197#define S_DAX (1 << 13)
2198#else
2199#define S_DAX 0
2200#endif
2201#define S_ENCRYPTED (1 << 14)
2202#define S_CASEFOLD (1 << 15)
2203#define S_VERITY (1 << 16)
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
2219
2220static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
2221#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
2222#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
2223 ((inode)->i_flags & S_SYNC))
2224#define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \
2225 ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
2226#define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK)
2227#define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY|SB_NOATIME)
2228#define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION)
2229
2230#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
2231#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
2232#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
2233#define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL)
2234
2235#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
2236#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
2237#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
2238#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2239#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2240#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2241#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
2242#define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2243#define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
2244#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
2245#define IS_VERITY(inode) ((inode)->i_flags & S_VERITY)
2246
2247#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2248 (inode)->i_rdev == WHITEOUT_DEV)
2249
2250static inline bool HAS_UNMAPPED_ID(struct user_namespace *mnt_userns,
2251 struct inode *inode)
2252{
2253 return !uid_valid(i_uid_into_mnt(mnt_userns, inode)) ||
2254 !gid_valid(i_gid_into_mnt(mnt_userns, inode));
2255}
2256
2257static inline enum rw_hint file_write_hint(struct file *file)
2258{
2259 if (file->f_write_hint != WRITE_LIFE_NOT_SET)
2260 return file->f_write_hint;
2261
2262 return file_inode(file)->i_write_hint;
2263}
2264
2265static inline int iocb_flags(struct file *file);
2266
2267static inline u16 ki_hint_validate(enum rw_hint hint)
2268{
2269 typeof(((struct kiocb *)0)->ki_hint) max_hint = -1;
2270
2271 if (hint <= max_hint)
2272 return hint;
2273 return 0;
2274}
2275
2276static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
2277{
2278 *kiocb = (struct kiocb) {
2279 .ki_filp = filp,
2280 .ki_flags = iocb_flags(filp),
2281 .ki_hint = ki_hint_validate(file_write_hint(filp)),
2282 .ki_ioprio = get_current_ioprio(),
2283 };
2284}
2285
2286static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
2287 struct file *filp)
2288{
2289 *kiocb = (struct kiocb) {
2290 .ki_filp = filp,
2291 .ki_flags = kiocb_src->ki_flags,
2292 .ki_hint = kiocb_src->ki_hint,
2293 .ki_ioprio = kiocb_src->ki_ioprio,
2294 .ki_pos = kiocb_src->ki_pos,
2295 };
2296}
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375#define I_DIRTY_SYNC (1 << 0)
2376#define I_DIRTY_DATASYNC (1 << 1)
2377#define I_DIRTY_PAGES (1 << 2)
2378#define __I_NEW 3
2379#define I_NEW (1 << __I_NEW)
2380#define I_WILL_FREE (1 << 4)
2381#define I_FREEING (1 << 5)
2382#define I_CLEAR (1 << 6)
2383#define __I_SYNC 7
2384#define I_SYNC (1 << __I_SYNC)
2385#define I_REFERENCED (1 << 8)
2386#define __I_DIO_WAKEUP 9
2387#define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP)
2388#define I_LINKABLE (1 << 10)
2389#define I_DIRTY_TIME (1 << 11)
2390#define I_WB_SWITCH (1 << 13)
2391#define I_OVL_INUSE (1 << 14)
2392#define I_CREATING (1 << 15)
2393#define I_DONTCACHE (1 << 16)
2394#define I_SYNC_QUEUED (1 << 17)
2395
2396#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
2397#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
2398#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
2399
2400extern void __mark_inode_dirty(struct inode *, int);
2401static inline void mark_inode_dirty(struct inode *inode)
2402{
2403 __mark_inode_dirty(inode, I_DIRTY);
2404}
2405
2406static inline void mark_inode_dirty_sync(struct inode *inode)
2407{
2408 __mark_inode_dirty(inode, I_DIRTY_SYNC);
2409}
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420static inline bool inode_is_dirtytime_only(struct inode *inode)
2421{
2422 return (inode->i_state & (I_DIRTY_TIME | I_NEW |
2423 I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME;
2424}
2425
2426extern void inc_nlink(struct inode *inode);
2427extern void drop_nlink(struct inode *inode);
2428extern void clear_nlink(struct inode *inode);
2429extern void set_nlink(struct inode *inode, unsigned int nlink);
2430
2431static inline void inode_inc_link_count(struct inode *inode)
2432{
2433 inc_nlink(inode);
2434 mark_inode_dirty(inode);
2435}
2436
2437static inline void inode_dec_link_count(struct inode *inode)
2438{
2439 drop_nlink(inode);
2440 mark_inode_dirty(inode);
2441}
2442
2443enum file_time_flags {
2444 S_ATIME = 1,
2445 S_MTIME = 2,
2446 S_CTIME = 4,
2447 S_VERSION = 8,
2448};
2449
2450extern bool atime_needs_update(const struct path *, struct inode *);
2451extern void touch_atime(const struct path *);
2452static inline void file_accessed(struct file *file)
2453{
2454 if (!(file->f_flags & O_NOATIME))
2455 touch_atime(&file->f_path);
2456}
2457
2458extern int file_modified(struct file *file);
2459
2460int sync_inode(struct inode *inode, struct writeback_control *wbc);
2461int sync_inode_metadata(struct inode *inode, int wait);
2462
2463struct file_system_type {
2464 const char *name;
2465 int fs_flags;
2466#define FS_REQUIRES_DEV 1
2467#define FS_BINARY_MOUNTDATA 2
2468#define FS_HAS_SUBTYPE 4
2469#define FS_USERNS_MOUNT 8
2470#define FS_DISALLOW_NOTIFY_PERM 16
2471#define FS_ALLOW_IDMAP 32
2472#define FS_THP_SUPPORT 8192
2473#define FS_RENAME_DOES_D_MOVE 32768
2474 int (*init_fs_context)(struct fs_context *);
2475 const struct fs_parameter_spec *parameters;
2476 struct dentry *(*mount) (struct file_system_type *, int,
2477 const char *, void *);
2478 void (*kill_sb) (struct super_block *);
2479 struct module *owner;
2480 struct file_system_type * next;
2481 struct hlist_head fs_supers;
2482
2483 struct lock_class_key s_lock_key;
2484 struct lock_class_key s_umount_key;
2485 struct lock_class_key s_vfs_rename_key;
2486 struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
2487
2488 struct lock_class_key i_lock_key;
2489 struct lock_class_key i_mutex_key;
2490 struct lock_class_key i_mutex_dir_key;
2491};
2492
2493#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2494
2495extern struct dentry *mount_bdev(struct file_system_type *fs_type,
2496 int flags, const char *dev_name, void *data,
2497 int (*fill_super)(struct super_block *, void *, int));
2498extern struct dentry *mount_single(struct file_system_type *fs_type,
2499 int flags, void *data,
2500 int (*fill_super)(struct super_block *, void *, int));
2501extern struct dentry *mount_nodev(struct file_system_type *fs_type,
2502 int flags, void *data,
2503 int (*fill_super)(struct super_block *, void *, int));
2504extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
2505void generic_shutdown_super(struct super_block *sb);
2506void kill_block_super(struct super_block *sb);
2507void kill_anon_super(struct super_block *sb);
2508void kill_litter_super(struct super_block *sb);
2509void deactivate_super(struct super_block *sb);
2510void deactivate_locked_super(struct super_block *sb);
2511int set_anon_super(struct super_block *s, void *data);
2512int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
2513int get_anon_bdev(dev_t *);
2514void free_anon_bdev(dev_t);
2515struct super_block *sget_fc(struct fs_context *fc,
2516 int (*test)(struct super_block *, struct fs_context *),
2517 int (*set)(struct super_block *, struct fs_context *));
2518struct super_block *sget(struct file_system_type *type,
2519 int (*test)(struct super_block *,void *),
2520 int (*set)(struct super_block *,void *),
2521 int flags, void *data);
2522
2523
2524#define fops_get(fops) \
2525 (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
2526#define fops_put(fops) \
2527 do { if (fops) module_put((fops)->owner); } while(0)
2528
2529
2530
2531
2532
2533#define replace_fops(f, fops) \
2534 do { \
2535 struct file *__file = (f); \
2536 fops_put(__file->f_op); \
2537 BUG_ON(!(__file->f_op = (fops))); \
2538 } while(0)
2539
2540extern int register_filesystem(struct file_system_type *);
2541extern int unregister_filesystem(struct file_system_type *);
2542extern struct vfsmount *kern_mount(struct file_system_type *);
2543extern void kern_unmount(struct vfsmount *mnt);
2544extern int may_umount_tree(struct vfsmount *);
2545extern int may_umount(struct vfsmount *);
2546extern long do_mount(const char *, const char __user *,
2547 const char *, unsigned long, void *);
2548extern struct vfsmount *collect_mounts(const struct path *);
2549extern void drop_collected_mounts(struct vfsmount *);
2550extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
2551 struct vfsmount *);
2552extern int vfs_statfs(const struct path *, struct kstatfs *);
2553extern int user_statfs(const char __user *, struct kstatfs *);
2554extern int fd_statfs(int, struct kstatfs *);
2555extern int freeze_super(struct super_block *super);
2556extern int thaw_super(struct super_block *super);
2557extern bool our_mnt(struct vfsmount *mnt);
2558extern __printf(2, 3)
2559int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
2560extern int super_setup_bdi(struct super_block *sb);
2561
2562extern int current_umask(void);
2563
2564extern void ihold(struct inode * inode);
2565extern void iput(struct inode *);
2566extern int generic_update_time(struct inode *, struct timespec64 *, int);
2567
2568
2569extern struct kobject *fs_kobj;
2570
2571#define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
2572
2573#ifdef CONFIG_MANDATORY_FILE_LOCKING
2574extern int locks_mandatory_locked(struct file *);
2575extern int locks_mandatory_area(struct inode *, struct file *, loff_t, loff_t, unsigned char);
2576
2577
2578
2579
2580
2581
2582static inline int __mandatory_lock(struct inode *ino)
2583{
2584 return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
2585}
2586
2587
2588
2589
2590
2591
2592static inline int mandatory_lock(struct inode *ino)
2593{
2594 return IS_MANDLOCK(ino) && __mandatory_lock(ino);
2595}
2596
2597static inline int locks_verify_locked(struct file *file)
2598{
2599 if (mandatory_lock(locks_inode(file)))
2600 return locks_mandatory_locked(file);
2601 return 0;
2602}
2603
2604static inline int locks_verify_truncate(struct inode *inode,
2605 struct file *f,
2606 loff_t size)
2607{
2608 if (!inode->i_flctx || !mandatory_lock(inode))
2609 return 0;
2610
2611 if (size < inode->i_size) {
2612 return locks_mandatory_area(inode, f, size, inode->i_size - 1,
2613 F_WRLCK);
2614 } else {
2615 return locks_mandatory_area(inode, f, inode->i_size, size - 1,
2616 F_WRLCK);
2617 }
2618}
2619
2620#else
2621
2622static inline int locks_mandatory_locked(struct file *file)
2623{
2624 return 0;
2625}
2626
2627static inline int locks_mandatory_area(struct inode *inode, struct file *filp,
2628 loff_t start, loff_t end, unsigned char type)
2629{
2630 return 0;
2631}
2632
2633static inline int __mandatory_lock(struct inode *inode)
2634{
2635 return 0;
2636}
2637
2638static inline int mandatory_lock(struct inode *inode)
2639{
2640 return 0;
2641}
2642
2643static inline int locks_verify_locked(struct file *file)
2644{
2645 return 0;
2646}
2647
2648static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
2649 size_t size)
2650{
2651 return 0;
2652}
2653
2654#endif
2655
2656
2657#ifdef CONFIG_FILE_LOCKING
2658static inline int break_lease(struct inode *inode, unsigned int mode)
2659{
2660
2661
2662
2663
2664
2665
2666 smp_mb();
2667 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2668 return __break_lease(inode, mode, FL_LEASE);
2669 return 0;
2670}
2671
2672static inline int break_deleg(struct inode *inode, unsigned int mode)
2673{
2674
2675
2676
2677
2678
2679
2680 smp_mb();
2681 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2682 return __break_lease(inode, mode, FL_DELEG);
2683 return 0;
2684}
2685
2686static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2687{
2688 int ret;
2689
2690 ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
2691 if (ret == -EWOULDBLOCK && delegated_inode) {
2692 *delegated_inode = inode;
2693 ihold(inode);
2694 }
2695 return ret;
2696}
2697
2698static inline int break_deleg_wait(struct inode **delegated_inode)
2699{
2700 int ret;
2701
2702 ret = break_deleg(*delegated_inode, O_WRONLY);
2703 iput(*delegated_inode);
2704 *delegated_inode = NULL;
2705 return ret;
2706}
2707
2708static inline int break_layout(struct inode *inode, bool wait)
2709{
2710 smp_mb();
2711 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2712 return __break_lease(inode,
2713 wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
2714 FL_LAYOUT);
2715 return 0;
2716}
2717
2718#else
2719static inline int break_lease(struct inode *inode, unsigned int mode)
2720{
2721 return 0;
2722}
2723
2724static inline int break_deleg(struct inode *inode, unsigned int mode)
2725{
2726 return 0;
2727}
2728
2729static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2730{
2731 return 0;
2732}
2733
2734static inline int break_deleg_wait(struct inode **delegated_inode)
2735{
2736 BUG();
2737 return 0;
2738}
2739
2740static inline int break_layout(struct inode *inode, bool wait)
2741{
2742 return 0;
2743}
2744
2745#endif
2746
2747
2748struct audit_names;
2749struct filename {
2750 const char *name;
2751 const __user char *uptr;
2752 int refcnt;
2753 struct audit_names *aname;
2754 const char iname[];
2755};
2756static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
2757
2758static inline struct user_namespace *file_mnt_user_ns(struct file *file)
2759{
2760 return mnt_user_ns(file->f_path.mnt);
2761}
2762extern long vfs_truncate(const struct path *, loff_t);
2763int do_truncate(struct user_namespace *, struct dentry *, loff_t start,
2764 unsigned int time_attrs, struct file *filp);
2765extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
2766 loff_t len);
2767extern long do_sys_open(int dfd, const char __user *filename, int flags,
2768 umode_t mode);
2769extern struct file *file_open_name(struct filename *, int, umode_t);
2770extern struct file *filp_open(const char *, int, umode_t);
2771extern struct file *file_open_root(const struct path *,
2772 const char *, int, umode_t);
2773static inline struct file *file_open_root_mnt(struct vfsmount *mnt,
2774 const char *name, int flags, umode_t mode)
2775{
2776 return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root},
2777 name, flags, mode);
2778}
2779extern struct file * dentry_open(const struct path *, int, const struct cred *);
2780extern struct file * open_with_fake_path(const struct path *, int,
2781 struct inode*, const struct cred *);
2782static inline struct file *file_clone_open(struct file *file)
2783{
2784 return dentry_open(&file->f_path, file->f_flags, file->f_cred);
2785}
2786extern int filp_close(struct file *, fl_owner_t id);
2787
2788extern struct filename *getname_flags(const char __user *, int, int *);
2789extern struct filename *getname(const char __user *);
2790extern struct filename *getname_kernel(const char *);
2791extern void putname(struct filename *name);
2792
2793extern int finish_open(struct file *file, struct dentry *dentry,
2794 int (*open)(struct inode *, struct file *));
2795extern int finish_no_open(struct file *file, struct dentry *dentry);
2796
2797
2798extern void __init vfs_caches_init_early(void);
2799extern void __init vfs_caches_init(void);
2800
2801extern struct kmem_cache *names_cachep;
2802
2803#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
2804#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
2805
2806extern struct super_block *blockdev_superblock;
2807static inline bool sb_is_blkdev_sb(struct super_block *sb)
2808{
2809 return IS_ENABLED(CONFIG_BLOCK) && sb == blockdev_superblock;
2810}
2811
2812void emergency_thaw_all(void);
2813extern int sync_filesystem(struct super_block *);
2814extern const struct file_operations def_blk_fops;
2815extern const struct file_operations def_chr_fops;
2816
2817
2818#define CHRDEV_MAJOR_MAX 512
2819
2820#define CHRDEV_MAJOR_DYN_END 234
2821
2822#define CHRDEV_MAJOR_DYN_EXT_START 511
2823#define CHRDEV_MAJOR_DYN_EXT_END 384
2824
2825extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2826extern int register_chrdev_region(dev_t, unsigned, const char *);
2827extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2828 unsigned int count, const char *name,
2829 const struct file_operations *fops);
2830extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2831 unsigned int count, const char *name);
2832extern void unregister_chrdev_region(dev_t, unsigned);
2833extern void chrdev_show(struct seq_file *,off_t);
2834
2835static inline int register_chrdev(unsigned int major, const char *name,
2836 const struct file_operations *fops)
2837{
2838 return __register_chrdev(major, 0, 256, name, fops);
2839}
2840
2841static inline void unregister_chrdev(unsigned int major, const char *name)
2842{
2843 __unregister_chrdev(major, 0, 256, name);
2844}
2845
2846extern void init_special_inode(struct inode *, umode_t, dev_t);
2847
2848
2849extern void make_bad_inode(struct inode *);
2850extern bool is_bad_inode(struct inode *);
2851
2852unsigned long invalidate_mapping_pages(struct address_space *mapping,
2853 pgoff_t start, pgoff_t end);
2854
2855void invalidate_mapping_pagevec(struct address_space *mapping,
2856 pgoff_t start, pgoff_t end,
2857 unsigned long *nr_pagevec);
2858
2859static inline void invalidate_remote_inode(struct inode *inode)
2860{
2861 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2862 S_ISLNK(inode->i_mode))
2863 invalidate_mapping_pages(inode->i_mapping, 0, -1);
2864}
2865extern int invalidate_inode_pages2(struct address_space *mapping);
2866extern int invalidate_inode_pages2_range(struct address_space *mapping,
2867 pgoff_t start, pgoff_t end);
2868extern int write_inode_now(struct inode *, int);
2869extern int filemap_fdatawrite(struct address_space *);
2870extern int filemap_flush(struct address_space *);
2871extern int filemap_fdatawait_keep_errors(struct address_space *mapping);
2872extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
2873 loff_t lend);
2874extern int filemap_fdatawait_range_keep_errors(struct address_space *mapping,
2875 loff_t start_byte, loff_t end_byte);
2876
2877static inline int filemap_fdatawait(struct address_space *mapping)
2878{
2879 return filemap_fdatawait_range(mapping, 0, LLONG_MAX);
2880}
2881
2882extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
2883 loff_t lend);
2884extern bool filemap_range_needs_writeback(struct address_space *,
2885 loff_t lstart, loff_t lend);
2886extern int filemap_write_and_wait_range(struct address_space *mapping,
2887 loff_t lstart, loff_t lend);
2888extern int __filemap_fdatawrite_range(struct address_space *mapping,
2889 loff_t start, loff_t end, int sync_mode);
2890extern int filemap_fdatawrite_range(struct address_space *mapping,
2891 loff_t start, loff_t end);
2892extern int filemap_check_errors(struct address_space *mapping);
2893extern void __filemap_set_wb_err(struct address_space *mapping, int err);
2894
2895static inline int filemap_write_and_wait(struct address_space *mapping)
2896{
2897 return filemap_write_and_wait_range(mapping, 0, LLONG_MAX);
2898}
2899
2900extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2901 loff_t lend);
2902extern int __must_check file_check_and_advance_wb_err(struct file *file);
2903extern int __must_check file_write_and_wait_range(struct file *file,
2904 loff_t start, loff_t end);
2905
2906static inline int file_write_and_wait(struct file *file)
2907{
2908 return file_write_and_wait_range(file, 0, LLONG_MAX);
2909}
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925static inline void filemap_set_wb_err(struct address_space *mapping, int err)
2926{
2927
2928 if (unlikely(err))
2929 __filemap_set_wb_err(mapping, err);
2930}
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942static inline int filemap_check_wb_err(struct address_space *mapping,
2943 errseq_t since)
2944{
2945 return errseq_check(&mapping->wb_err, since);
2946}
2947
2948
2949
2950
2951
2952
2953
2954
2955static inline errseq_t filemap_sample_wb_err(struct address_space *mapping)
2956{
2957 return errseq_sample(&mapping->wb_err);
2958}
2959
2960
2961
2962
2963
2964
2965
2966
2967static inline errseq_t file_sample_sb_err(struct file *file)
2968{
2969 return errseq_sample(&file->f_path.dentry->d_sb->s_wb_err);
2970}
2971
2972extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2973 int datasync);
2974extern int vfs_fsync(struct file *file, int datasync);
2975
2976extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
2977 unsigned int flags);
2978
2979
2980
2981
2982
2983
2984static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
2985{
2986 if (iocb->ki_flags & IOCB_DSYNC) {
2987 int ret = vfs_fsync_range(iocb->ki_filp,
2988 iocb->ki_pos - count, iocb->ki_pos - 1,
2989 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1);
2990 if (ret)
2991 return ret;
2992 }
2993
2994 return count;
2995}
2996
2997extern void emergency_sync(void);
2998extern void emergency_remount(void);
2999
3000#ifdef CONFIG_BLOCK
3001extern int bmap(struct inode *inode, sector_t *block);
3002#else
3003static inline int bmap(struct inode *inode, sector_t *block)
3004{
3005 return -EINVAL;
3006}
3007#endif
3008
3009int notify_change(struct user_namespace *, struct dentry *,
3010 struct iattr *, struct inode **);
3011int inode_permission(struct user_namespace *, struct inode *, int);
3012int generic_permission(struct user_namespace *, struct inode *, int);
3013static inline int file_permission(struct file *file, int mask)
3014{
3015 return inode_permission(file_mnt_user_ns(file),
3016 file_inode(file), mask);
3017}
3018static inline int path_permission(const struct path *path, int mask)
3019{
3020 return inode_permission(mnt_user_ns(path->mnt),
3021 d_inode(path->dentry), mask);
3022}
3023int __check_sticky(struct user_namespace *mnt_userns, struct inode *dir,
3024 struct inode *inode);
3025
3026static inline bool execute_ok(struct inode *inode)
3027{
3028 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
3029}
3030
3031static inline bool inode_wrong_type(const struct inode *inode, umode_t mode)
3032{
3033 return (inode->i_mode ^ mode) & S_IFMT;
3034}
3035
3036static inline void file_start_write(struct file *file)
3037{
3038 if (!S_ISREG(file_inode(file)->i_mode))
3039 return;
3040 sb_start_write(file_inode(file)->i_sb);
3041}
3042
3043static inline bool file_start_write_trylock(struct file *file)
3044{
3045 if (!S_ISREG(file_inode(file)->i_mode))
3046 return true;
3047 return sb_start_write_trylock(file_inode(file)->i_sb);
3048}
3049
3050static inline void file_end_write(struct file *file)
3051{
3052 if (!S_ISREG(file_inode(file)->i_mode))
3053 return;
3054 __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
3055}
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073static inline int get_write_access(struct inode *inode)
3074{
3075 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
3076}
3077static inline int deny_write_access(struct file *file)
3078{
3079 struct inode *inode = file_inode(file);
3080 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
3081}
3082static inline void put_write_access(struct inode * inode)
3083{
3084 atomic_dec(&inode->i_writecount);
3085}
3086static inline void allow_write_access(struct file *file)
3087{
3088 if (file)
3089 atomic_inc(&file_inode(file)->i_writecount);
3090}
3091static inline bool inode_is_open_for_write(const struct inode *inode)
3092{
3093 return atomic_read(&inode->i_writecount) > 0;
3094}
3095
3096#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
3097static inline void i_readcount_dec(struct inode *inode)
3098{
3099 BUG_ON(!atomic_read(&inode->i_readcount));
3100 atomic_dec(&inode->i_readcount);
3101}
3102static inline void i_readcount_inc(struct inode *inode)
3103{
3104 atomic_inc(&inode->i_readcount);
3105}
3106#else
3107static inline void i_readcount_dec(struct inode *inode)
3108{
3109 return;
3110}
3111static inline void i_readcount_inc(struct inode *inode)
3112{
3113 return;
3114}
3115#endif
3116extern int do_pipe_flags(int *, int);
3117
3118extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
3119ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
3120extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
3121extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
3122extern struct file * open_exec(const char *);
3123
3124
3125extern bool is_subdir(struct dentry *, struct dentry *);
3126extern bool path_is_under(const struct path *, const struct path *);
3127
3128extern char *file_path(struct file *, char *, int);
3129
3130#include <linux/err.h>
3131
3132
3133extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
3134
3135extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
3136
3137extern int inode_init_always(struct super_block *, struct inode *);
3138extern void inode_init_once(struct inode *);
3139extern void address_space_init_once(struct address_space *mapping);
3140extern struct inode * igrab(struct inode *);
3141extern ino_t iunique(struct super_block *, ino_t);
3142extern int inode_needs_sync(struct inode *inode);
3143extern int generic_delete_inode(struct inode *inode);
3144static inline int generic_drop_inode(struct inode *inode)
3145{
3146 return !inode->i_nlink || inode_unhashed(inode);
3147}
3148extern void d_mark_dontcache(struct inode *inode);
3149
3150extern struct inode *ilookup5_nowait(struct super_block *sb,
3151 unsigned long hashval, int (*test)(struct inode *, void *),
3152 void *data);
3153extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
3154 int (*test)(struct inode *, void *), void *data);
3155extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
3156
3157extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
3158 int (*test)(struct inode *, void *),
3159 int (*set)(struct inode *, void *),
3160 void *data);
3161extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
3162extern struct inode * iget_locked(struct super_block *, unsigned long);
3163extern struct inode *find_inode_nowait(struct super_block *,
3164 unsigned long,
3165 int (*match)(struct inode *,
3166 unsigned long, void *),
3167 void *data);
3168extern struct inode *find_inode_rcu(struct super_block *, unsigned long,
3169 int (*)(struct inode *, void *), void *);
3170extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long);
3171extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
3172extern int insert_inode_locked(struct inode *);
3173#ifdef CONFIG_DEBUG_LOCK_ALLOC
3174extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
3175#else
3176static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
3177#endif
3178extern void unlock_new_inode(struct inode *);
3179extern void discard_new_inode(struct inode *);
3180extern unsigned int get_next_ino(void);
3181extern void evict_inodes(struct super_block *sb);
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193static inline bool is_zero_ino(ino_t ino)
3194{
3195 return (u32)ino == 0;
3196}
3197
3198extern void __iget(struct inode * inode);
3199extern void iget_failed(struct inode *);
3200extern void clear_inode(struct inode *);
3201extern void __destroy_inode(struct inode *);
3202extern struct inode *new_inode_pseudo(struct super_block *sb);
3203extern struct inode *new_inode(struct super_block *sb);
3204extern void free_inode_nonrcu(struct inode *inode);
3205extern int should_remove_suid(struct dentry *);
3206extern int file_remove_privs(struct file *);
3207
3208extern void __insert_inode_hash(struct inode *, unsigned long hashval);
3209static inline void insert_inode_hash(struct inode *inode)
3210{
3211 __insert_inode_hash(inode, inode->i_ino);
3212}
3213
3214extern void __remove_inode_hash(struct inode *);
3215static inline void remove_inode_hash(struct inode *inode)
3216{
3217 if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
3218 __remove_inode_hash(inode);
3219}
3220
3221extern void inode_sb_list_add(struct inode *inode);
3222
3223extern int sb_set_blocksize(struct super_block *, int);
3224extern int sb_min_blocksize(struct super_block *, int);
3225
3226extern int generic_file_mmap(struct file *, struct vm_area_struct *);
3227extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
3228extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
3229extern int generic_write_check_limits(struct file *file, loff_t pos,
3230 loff_t *count);
3231extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
3232ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *to,
3233 ssize_t already_read);
3234extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
3235extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
3236extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
3237extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
3238extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
3239
3240ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
3241 rwf_t flags);
3242ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
3243 rwf_t flags);
3244ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
3245 struct iov_iter *iter);
3246ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
3247 struct iov_iter *iter);
3248
3249
3250extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
3251 int datasync);
3252
3253
3254extern ssize_t generic_file_splice_read(struct file *, loff_t *,
3255 struct pipe_inode_info *, size_t, unsigned int);
3256extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
3257 struct file *, loff_t *, size_t, unsigned int);
3258extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
3259 struct file *out, loff_t *, size_t len, unsigned int flags);
3260extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
3261 loff_t *opos, size_t len, unsigned int flags);
3262
3263
3264extern void
3265file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
3266extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
3267extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
3268extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
3269extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
3270extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
3271 int whence, loff_t maxsize, loff_t eof);
3272extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
3273 int whence, loff_t size);
3274extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
3275extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
3276extern int generic_file_open(struct inode * inode, struct file * filp);
3277extern int nonseekable_open(struct inode * inode, struct file * filp);
3278extern int stream_open(struct inode * inode, struct file * filp);
3279
3280#ifdef CONFIG_BLOCK
3281typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
3282 loff_t file_offset);
3283
3284enum {
3285
3286 DIO_LOCKING = 0x01,
3287
3288
3289 DIO_SKIP_HOLES = 0x02,
3290};
3291
3292ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
3293 struct block_device *bdev, struct iov_iter *iter,
3294 get_block_t get_block,
3295 dio_iodone_t end_io, dio_submit_t submit_io,
3296 int flags);
3297
3298static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
3299 struct inode *inode,
3300 struct iov_iter *iter,
3301 get_block_t get_block)
3302{
3303 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
3304 get_block, NULL, NULL, DIO_LOCKING | DIO_SKIP_HOLES);
3305}
3306#endif
3307
3308void inode_dio_wait(struct inode *inode);
3309
3310
3311
3312
3313
3314
3315
3316
3317static inline void inode_dio_begin(struct inode *inode)
3318{
3319 atomic_inc(&inode->i_dio_count);
3320}
3321
3322
3323
3324
3325
3326
3327
3328
3329static inline void inode_dio_end(struct inode *inode)
3330{
3331 if (atomic_dec_and_test(&inode->i_dio_count))
3332 wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
3333}
3334
3335
3336
3337
3338void dio_warn_stale_pagecache(struct file *filp);
3339
3340extern void inode_set_flags(struct inode *inode, unsigned int flags,
3341 unsigned int mask);
3342
3343extern const struct file_operations generic_ro_fops;
3344
3345#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
3346
3347extern int readlink_copy(char __user *, int, const char *);
3348extern int page_readlink(struct dentry *, char __user *, int);
3349extern const char *page_get_link(struct dentry *, struct inode *,
3350 struct delayed_call *);
3351extern void page_put_link(void *);
3352extern int __page_symlink(struct inode *inode, const char *symname, int len,
3353 int nofs);
3354extern int page_symlink(struct inode *inode, const char *symname, int len);
3355extern const struct inode_operations page_symlink_inode_operations;
3356extern void kfree_link(void *);
3357void generic_fillattr(struct user_namespace *, struct inode *, struct kstat *);
3358extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
3359extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
3360void __inode_add_bytes(struct inode *inode, loff_t bytes);
3361void inode_add_bytes(struct inode *inode, loff_t bytes);
3362void __inode_sub_bytes(struct inode *inode, loff_t bytes);
3363void inode_sub_bytes(struct inode *inode, loff_t bytes);
3364static inline loff_t __inode_get_bytes(struct inode *inode)
3365{
3366 return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
3367}
3368loff_t inode_get_bytes(struct inode *inode);
3369void inode_set_bytes(struct inode *inode, loff_t bytes);
3370const char *simple_get_link(struct dentry *, struct inode *,
3371 struct delayed_call *);
3372extern const struct inode_operations simple_symlink_inode_operations;
3373
3374extern int iterate_dir(struct file *, struct dir_context *);
3375
3376int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
3377 int flags);
3378int vfs_fstat(int fd, struct kstat *stat);
3379
3380static inline int vfs_stat(const char __user *filename, struct kstat *stat)
3381{
3382 return vfs_fstatat(AT_FDCWD, filename, stat, 0);
3383}
3384static inline int vfs_lstat(const char __user *name, struct kstat *stat)
3385{
3386 return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
3387}
3388
3389extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
3390extern int vfs_readlink(struct dentry *, char __user *, int);
3391
3392extern struct file_system_type *get_filesystem(struct file_system_type *fs);
3393extern void put_filesystem(struct file_system_type *fs);
3394extern struct file_system_type *get_fs_type(const char *name);
3395extern struct super_block *get_super(struct block_device *);
3396extern struct super_block *get_active_super(struct block_device *bdev);
3397extern void drop_super(struct super_block *sb);
3398extern void drop_super_exclusive(struct super_block *sb);
3399extern void iterate_supers(void (*)(struct super_block *, void *), void *);
3400extern void iterate_supers_type(struct file_system_type *,
3401 void (*)(struct super_block *, void *), void *);
3402
3403extern int dcache_dir_open(struct inode *, struct file *);
3404extern int dcache_dir_close(struct inode *, struct file *);
3405extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
3406extern int dcache_readdir(struct file *, struct dir_context *);
3407extern int simple_setattr(struct user_namespace *, struct dentry *,
3408 struct iattr *);
3409extern int simple_getattr(struct user_namespace *, const struct path *,
3410 struct kstat *, u32, unsigned int);
3411extern int simple_statfs(struct dentry *, struct kstatfs *);
3412extern int simple_open(struct inode *inode, struct file *file);
3413extern int simple_link(struct dentry *, struct inode *, struct dentry *);
3414extern int simple_unlink(struct inode *, struct dentry *);
3415extern int simple_rmdir(struct inode *, struct dentry *);
3416extern int simple_rename(struct user_namespace *, struct inode *,
3417 struct dentry *, struct inode *, struct dentry *,
3418 unsigned int);
3419extern void simple_recursive_removal(struct dentry *,
3420 void (*callback)(struct dentry *));
3421extern int noop_fsync(struct file *, loff_t, loff_t, int);
3422extern void noop_invalidatepage(struct page *page, unsigned int offset,
3423 unsigned int length);
3424extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
3425extern int simple_empty(struct dentry *);
3426extern int simple_write_begin(struct file *file, struct address_space *mapping,
3427 loff_t pos, unsigned len, unsigned flags,
3428 struct page **pagep, void **fsdata);
3429extern const struct address_space_operations ram_aops;
3430extern int always_delete_dentry(const struct dentry *);
3431extern struct inode *alloc_anon_inode(struct super_block *);
3432extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
3433extern const struct dentry_operations simple_dentry_operations;
3434
3435extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
3436extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
3437extern const struct file_operations simple_dir_operations;
3438extern const struct inode_operations simple_dir_inode_operations;
3439extern void make_empty_dir_inode(struct inode *inode);
3440extern bool is_empty_dir_inode(struct inode *inode);
3441struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
3442struct dentry *d_alloc_name(struct dentry *, const char *);
3443extern int simple_fill_super(struct super_block *, unsigned long,
3444 const struct tree_descr *);
3445extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
3446extern void simple_release_fs(struct vfsmount **mount, int *count);
3447
3448extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
3449 loff_t *ppos, const void *from, size_t available);
3450extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3451 const void __user *from, size_t count);
3452
3453extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
3454extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
3455
3456extern int generic_check_addressable(unsigned, u64);
3457
3458extern void generic_set_encrypted_ci_d_ops(struct dentry *dentry);
3459
3460#ifdef CONFIG_MIGRATION
3461extern int buffer_migrate_page(struct address_space *,
3462 struct page *, struct page *,
3463 enum migrate_mode);
3464extern int buffer_migrate_page_norefs(struct address_space *,
3465 struct page *, struct page *,
3466 enum migrate_mode);
3467#else
3468#define buffer_migrate_page NULL
3469#define buffer_migrate_page_norefs NULL
3470#endif
3471
3472int setattr_prepare(struct user_namespace *, struct dentry *, struct iattr *);
3473extern int inode_newsize_ok(const struct inode *, loff_t offset);
3474void setattr_copy(struct user_namespace *, struct inode *inode,
3475 const struct iattr *attr);
3476
3477extern int file_update_time(struct file *file);
3478
3479static inline bool vma_is_dax(const struct vm_area_struct *vma)
3480{
3481 return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
3482}
3483
3484static inline bool vma_is_fsdax(struct vm_area_struct *vma)
3485{
3486 struct inode *inode;
3487
3488 if (!IS_ENABLED(CONFIG_FS_DAX) || !vma->vm_file)
3489 return false;
3490 if (!vma_is_dax(vma))
3491 return false;
3492 inode = file_inode(vma->vm_file);
3493 if (S_ISCHR(inode->i_mode))
3494 return false;
3495 return true;
3496}
3497
3498static inline int iocb_flags(struct file *file)
3499{
3500 int res = 0;
3501 if (file->f_flags & O_APPEND)
3502 res |= IOCB_APPEND;
3503 if (file->f_flags & O_DIRECT)
3504 res |= IOCB_DIRECT;
3505 if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))
3506 res |= IOCB_DSYNC;
3507 if (file->f_flags & __O_SYNC)
3508 res |= IOCB_SYNC;
3509 return res;
3510}
3511
3512static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
3513{
3514 int kiocb_flags = 0;
3515
3516
3517 BUILD_BUG_ON((__force int) RWF_SUPPORTED & IOCB_EVENTFD);
3518
3519 if (!flags)
3520 return 0;
3521 if (unlikely(flags & ~RWF_SUPPORTED))
3522 return -EOPNOTSUPP;
3523
3524 if (flags & RWF_NOWAIT) {
3525 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT))
3526 return -EOPNOTSUPP;
3527 kiocb_flags |= IOCB_NOIO;
3528 }
3529 kiocb_flags |= (__force int) (flags & RWF_SUPPORTED);
3530 if (flags & RWF_SYNC)
3531 kiocb_flags |= IOCB_DSYNC;
3532
3533 ki->ki_flags |= kiocb_flags;
3534 return 0;
3535}
3536
3537static inline ino_t parent_ino(struct dentry *dentry)
3538{
3539 ino_t res;
3540
3541
3542
3543
3544
3545 spin_lock(&dentry->d_lock);
3546 res = dentry->d_parent->d_inode->i_ino;
3547 spin_unlock(&dentry->d_lock);
3548 return res;
3549}
3550
3551
3552
3553
3554
3555
3556
3557struct simple_transaction_argresp {
3558 ssize_t size;
3559 char data[];
3560};
3561
3562#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
3563
3564char *simple_transaction_get(struct file *file, const char __user *buf,
3565 size_t size);
3566ssize_t simple_transaction_read(struct file *file, char __user *buf,
3567 size_t size, loff_t *pos);
3568int simple_transaction_release(struct inode *inode, struct file *file);
3569
3570void simple_transaction_set(struct file *file, size_t n);
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
3589static int __fops ## _open(struct inode *inode, struct file *file) \
3590{ \
3591 __simple_attr_check_format(__fmt, 0ull); \
3592 return simple_attr_open(inode, file, __get, __set, __fmt); \
3593} \
3594static const struct file_operations __fops = { \
3595 .owner = THIS_MODULE, \
3596 .open = __fops ## _open, \
3597 .release = simple_attr_release, \
3598 .read = simple_attr_read, \
3599 .write = simple_attr_write, \
3600 .llseek = generic_file_llseek, \
3601}
3602
3603static inline __printf(1, 2)
3604void __simple_attr_check_format(const char *fmt, ...)
3605{
3606
3607}
3608
3609int simple_attr_open(struct inode *inode, struct file *file,
3610 int (*get)(void *, u64 *), int (*set)(void *, u64),
3611 const char *fmt);
3612int simple_attr_release(struct inode *inode, struct file *file);
3613ssize_t simple_attr_read(struct file *file, char __user *buf,
3614 size_t len, loff_t *ppos);
3615ssize_t simple_attr_write(struct file *file, const char __user *buf,
3616 size_t len, loff_t *ppos);
3617
3618struct ctl_table;
3619int proc_nr_files(struct ctl_table *table, int write,
3620 void *buffer, size_t *lenp, loff_t *ppos);
3621int proc_nr_dentry(struct ctl_table *table, int write,
3622 void *buffer, size_t *lenp, loff_t *ppos);
3623int proc_nr_inodes(struct ctl_table *table, int write,
3624 void *buffer, size_t *lenp, loff_t *ppos);
3625int __init get_filesystem_list(char *buf);
3626
3627#define __FMODE_EXEC ((__force int) FMODE_EXEC)
3628#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
3629
3630#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
3631#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
3632 (flag & __FMODE_NONOTIFY)))
3633
3634static inline bool is_sxid(umode_t mode)
3635{
3636 return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
3637}
3638
3639static inline int check_sticky(struct user_namespace *mnt_userns,
3640 struct inode *dir, struct inode *inode)
3641{
3642 if (!(dir->i_mode & S_ISVTX))
3643 return 0;
3644
3645 return __check_sticky(mnt_userns, dir, inode);
3646}
3647
3648static inline void inode_has_no_xattr(struct inode *inode)
3649{
3650 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC))
3651 inode->i_flags |= S_NOSEC;
3652}
3653
3654static inline bool is_root_inode(struct inode *inode)
3655{
3656 return inode == inode->i_sb->s_root->d_inode;
3657}
3658
3659static inline bool dir_emit(struct dir_context *ctx,
3660 const char *name, int namelen,
3661 u64 ino, unsigned type)
3662{
3663 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
3664}
3665static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
3666{
3667 return ctx->actor(ctx, ".", 1, ctx->pos,
3668 file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
3669}
3670static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
3671{
3672 return ctx->actor(ctx, "..", 2, ctx->pos,
3673 parent_ino(file->f_path.dentry), DT_DIR) == 0;
3674}
3675static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
3676{
3677 if (ctx->pos == 0) {
3678 if (!dir_emit_dot(file, ctx))
3679 return false;
3680 ctx->pos = 1;
3681 }
3682 if (ctx->pos == 1) {
3683 if (!dir_emit_dotdot(file, ctx))
3684 return false;
3685 ctx->pos = 2;
3686 }
3687 return true;
3688}
3689static inline bool dir_relax(struct inode *inode)
3690{
3691 inode_unlock(inode);
3692 inode_lock(inode);
3693 return !IS_DEADDIR(inode);
3694}
3695
3696static inline bool dir_relax_shared(struct inode *inode)
3697{
3698 inode_unlock_shared(inode);
3699 inode_lock_shared(inode);
3700 return !IS_DEADDIR(inode);
3701}
3702
3703extern bool path_noexec(const struct path *path);
3704extern void inode_nohighmem(struct inode *inode);
3705
3706
3707extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
3708 int advice);
3709extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
3710 int advice);
3711
3712
3713
3714
3715
3716
3717static inline int inode_drain_writes(struct inode *inode)
3718{
3719 inode_dio_wait(inode);
3720 return filemap_write_and_wait(inode->i_mapping);
3721}
3722
3723#endif
3724