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