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