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