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