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#ifdef CONFIG_IMA
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 int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
1023 unsigned long (*lm_owner_key)(struct file_lock *);
1024 fl_owner_t (*lm_get_owner)(fl_owner_t);
1025 void (*lm_put_owner)(fl_owner_t);
1026 void (*lm_notify)(struct file_lock *);
1027 int (*lm_grant)(struct file_lock *, int);
1028 bool (*lm_break)(struct file_lock *);
1029 int (*lm_change)(struct file_lock *, int, struct list_head *);
1030 void (*lm_setup)(struct file_lock *, void **);
1031};
1032
1033struct lock_manager {
1034 struct list_head list;
1035
1036
1037
1038
1039 bool block_opens;
1040};
1041
1042struct net;
1043void locks_start_grace(struct net *, struct lock_manager *);
1044void locks_end_grace(struct lock_manager *);
1045bool locks_in_grace(struct net *);
1046bool opens_in_grace(struct net *);
1047
1048
1049#include <linux/nfs_fs_i.h>
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068struct file_lock {
1069 struct file_lock *fl_blocker;
1070 struct list_head fl_list;
1071 struct hlist_node fl_link;
1072 struct list_head fl_blocked_requests;
1073
1074
1075 struct list_head fl_blocked_member;
1076
1077
1078 fl_owner_t fl_owner;
1079 unsigned int fl_flags;
1080 unsigned char fl_type;
1081 unsigned int fl_pid;
1082 int fl_link_cpu;
1083 wait_queue_head_t fl_wait;
1084 struct file *fl_file;
1085 loff_t fl_start;
1086 loff_t fl_end;
1087
1088 struct fasync_struct * fl_fasync;
1089
1090 unsigned long fl_break_time;
1091 unsigned long fl_downgrade_time;
1092
1093 const struct file_lock_operations *fl_ops;
1094 const struct lock_manager_operations *fl_lmops;
1095 union {
1096 struct nfs_lock_info nfs_fl;
1097 struct nfs4_lock_info nfs4_fl;
1098 struct {
1099 struct list_head link;
1100 int state;
1101 unsigned int debug_id;
1102 } afs;
1103 } fl_u;
1104} __randomize_layout;
1105
1106struct file_lock_context {
1107 spinlock_t flc_lock;
1108 struct list_head flc_flock;
1109 struct list_head flc_posix;
1110 struct list_head flc_lease;
1111};
1112
1113
1114#ifndef OFFSET_MAX
1115#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
1116#define OFFSET_MAX INT_LIMIT(loff_t)
1117#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
1118#endif
1119
1120extern void send_sigio(struct fown_struct *fown, int fd, int band);
1121
1122#define locks_inode(f) file_inode(f)
1123
1124#ifdef CONFIG_FILE_LOCKING
1125extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
1126extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1127 struct flock *);
1128
1129#if BITS_PER_LONG == 32
1130extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
1131extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1132 struct flock64 *);
1133#endif
1134
1135extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1136extern int fcntl_getlease(struct file *filp);
1137
1138
1139void locks_free_lock_context(struct inode *inode);
1140void locks_free_lock(struct file_lock *fl);
1141extern void locks_init_lock(struct file_lock *);
1142extern struct file_lock * locks_alloc_lock(void);
1143extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1144extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
1145extern void locks_remove_posix(struct file *, fl_owner_t);
1146extern void locks_remove_file(struct file *);
1147extern void locks_release_private(struct file_lock *);
1148extern void posix_test_lock(struct file *, struct file_lock *);
1149extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1150extern int locks_delete_block(struct file_lock *);
1151extern int vfs_test_lock(struct file *, struct file_lock *);
1152extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
1153extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1154extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
1155extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
1156extern void lease_get_mtime(struct inode *, struct timespec64 *time);
1157extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
1158extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
1159extern int lease_modify(struct file_lock *, int, struct list_head *);
1160struct files_struct;
1161extern void show_fd_locks(struct seq_file *f,
1162 struct file *filp, struct files_struct *files);
1163#else
1164static inline int fcntl_getlk(struct file *file, unsigned int cmd,
1165 struct flock __user *user)
1166{
1167 return -EINVAL;
1168}
1169
1170static inline int fcntl_setlk(unsigned int fd, struct file *file,
1171 unsigned int cmd, struct flock __user *user)
1172{
1173 return -EACCES;
1174}
1175
1176#if BITS_PER_LONG == 32
1177static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
1178 struct flock64 __user *user)
1179{
1180 return -EINVAL;
1181}
1182
1183static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1184 unsigned int cmd, struct flock64 __user *user)
1185{
1186 return -EACCES;
1187}
1188#endif
1189static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1190{
1191 return -EINVAL;
1192}
1193
1194static inline int fcntl_getlease(struct file *filp)
1195{
1196 return F_UNLCK;
1197}
1198
1199static inline void
1200locks_free_lock_context(struct inode *inode)
1201{
1202}
1203
1204static inline void locks_init_lock(struct file_lock *fl)
1205{
1206 return;
1207}
1208
1209static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
1210{
1211 return;
1212}
1213
1214static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1215{
1216 return;
1217}
1218
1219static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1220{
1221 return;
1222}
1223
1224static inline void locks_remove_file(struct file *filp)
1225{
1226 return;
1227}
1228
1229static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1230{
1231 return;
1232}
1233
1234static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1235 struct file_lock *conflock)
1236{
1237 return -ENOLCK;
1238}
1239
1240static inline int locks_delete_block(struct file_lock *waiter)
1241{
1242 return -ENOENT;
1243}
1244
1245static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1246{
1247 return 0;
1248}
1249
1250static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
1251 struct file_lock *fl, struct file_lock *conf)
1252{
1253 return -ENOLCK;
1254}
1255
1256static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1257{
1258 return 0;
1259}
1260
1261static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1262{
1263 return -ENOLCK;
1264}
1265
1266static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1267{
1268 return 0;
1269}
1270
1271static inline void lease_get_mtime(struct inode *inode,
1272 struct timespec64 *time)
1273{
1274 return;
1275}
1276
1277static inline int generic_setlease(struct file *filp, long arg,
1278 struct file_lock **flp, void **priv)
1279{
1280 return -EINVAL;
1281}
1282
1283static inline int vfs_setlease(struct file *filp, long arg,
1284 struct file_lock **lease, void **priv)
1285{
1286 return -EINVAL;
1287}
1288
1289static inline int lease_modify(struct file_lock *fl, int arg,
1290 struct list_head *dispose)
1291{
1292 return -EINVAL;
1293}
1294
1295struct files_struct;
1296static inline void show_fd_locks(struct seq_file *f,
1297 struct file *filp, struct files_struct *files) {}
1298#endif
1299
1300static inline struct inode *file_inode(const struct file *f)
1301{
1302 return f->f_inode;
1303}
1304
1305static inline struct dentry *file_dentry(const struct file *file)
1306{
1307 return d_real(file->f_path.dentry, file_inode(file));
1308}
1309
1310static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
1311{
1312 return locks_lock_inode_wait(locks_inode(filp), fl);
1313}
1314
1315struct fasync_struct {
1316 rwlock_t fa_lock;
1317 int magic;
1318 int fa_fd;
1319 struct fasync_struct *fa_next;
1320 struct file *fa_file;
1321 struct rcu_head fa_rcu;
1322};
1323
1324#define FASYNC_MAGIC 0x4601
1325
1326
1327extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
1328extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1329extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1330extern struct fasync_struct *fasync_alloc(void);
1331extern void fasync_free(struct fasync_struct *);
1332
1333
1334extern void kill_fasync(struct fasync_struct **, int, int);
1335
1336extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1337extern int f_setown(struct file *filp, unsigned long arg, int force);
1338extern void f_delown(struct file *filp);
1339extern pid_t f_getown(struct file *filp);
1340extern int send_sigurg(struct fown_struct *fown);
1341
1342
1343
1344
1345
1346#define SB_RDONLY 1
1347#define SB_NOSUID 2
1348#define SB_NODEV 4
1349#define SB_NOEXEC 8
1350#define SB_SYNCHRONOUS 16
1351#define SB_MANDLOCK 64
1352#define SB_DIRSYNC 128
1353#define SB_NOATIME 1024
1354#define SB_NODIRATIME 2048
1355#define SB_SILENT 32768
1356#define SB_POSIXACL (1<<16)
1357#define SB_KERNMOUNT (1<<22)
1358#define SB_I_VERSION (1<<23)
1359#define SB_LAZYTIME (1<<25)
1360
1361
1362#define SB_SUBMOUNT (1<<26)
1363#define SB_FORCE (1<<27)
1364#define SB_NOSEC (1<<28)
1365#define SB_BORN (1<<29)
1366#define SB_ACTIVE (1<<30)
1367#define SB_NOUSER (1<<31)
1368
1369
1370
1371
1372
1373#define MNT_FORCE 0x00000001
1374#define MNT_DETACH 0x00000002
1375#define MNT_EXPIRE 0x00000004
1376#define UMOUNT_NOFOLLOW 0x00000008
1377#define UMOUNT_UNUSED 0x80000000
1378
1379
1380#define SB_I_CGROUPWB 0x00000001
1381#define SB_I_NOEXEC 0x00000002
1382#define SB_I_NODEV 0x00000004
1383#define SB_I_MULTIROOT 0x00000008
1384
1385
1386#define SB_I_USERNS_VISIBLE 0x00000010
1387#define SB_I_IMA_UNVERIFIABLE_SIGNATURE 0x00000020
1388#define SB_I_UNTRUSTED_MOUNTER 0x00000040
1389
1390
1391enum {
1392 SB_UNFROZEN = 0,
1393 SB_FREEZE_WRITE = 1,
1394 SB_FREEZE_PAGEFAULT = 2,
1395 SB_FREEZE_FS = 3,
1396
1397 SB_FREEZE_COMPLETE = 4,
1398};
1399
1400#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1401
1402struct sb_writers {
1403 int frozen;
1404 wait_queue_head_t wait_unfrozen;
1405 struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
1406};
1407
1408struct super_block {
1409 struct list_head s_list;
1410 dev_t s_dev;
1411 unsigned char s_blocksize_bits;
1412 unsigned long s_blocksize;
1413 loff_t s_maxbytes;
1414 struct file_system_type *s_type;
1415 const struct super_operations *s_op;
1416 const struct dquot_operations *dq_op;
1417 const struct quotactl_ops *s_qcop;
1418 const struct export_operations *s_export_op;
1419 unsigned long s_flags;
1420 unsigned long s_iflags;
1421 unsigned long s_magic;
1422 struct dentry *s_root;
1423 struct rw_semaphore s_umount;
1424 int s_count;
1425 atomic_t s_active;
1426#ifdef CONFIG_SECURITY
1427 void *s_security;
1428#endif
1429 const struct xattr_handler **s_xattr;
1430#ifdef CONFIG_FS_ENCRYPTION
1431 const struct fscrypt_operations *s_cop;
1432#endif
1433 struct hlist_bl_head s_roots;
1434 struct list_head s_mounts;
1435 struct block_device *s_bdev;
1436 struct backing_dev_info *s_bdi;
1437 struct mtd_info *s_mtd;
1438 struct hlist_node s_instances;
1439 unsigned int s_quota_types;
1440 struct quota_info s_dquot;
1441
1442 struct sb_writers s_writers;
1443
1444
1445
1446
1447
1448
1449 void *s_fs_info;
1450
1451
1452 u32 s_time_gran;
1453#ifdef CONFIG_FSNOTIFY
1454 __u32 s_fsnotify_mask;
1455 struct fsnotify_mark_connector __rcu *s_fsnotify_marks;
1456#endif
1457
1458 char s_id[32];
1459 uuid_t s_uuid;
1460
1461 unsigned int s_max_links;
1462 fmode_t s_mode;
1463
1464
1465
1466
1467
1468 struct mutex s_vfs_rename_mutex;
1469
1470
1471
1472
1473
1474 const char *s_subtype;
1475
1476 const struct dentry_operations *s_d_op;
1477
1478
1479
1480
1481 int cleancache_poolid;
1482
1483 struct shrinker s_shrink;
1484
1485
1486 atomic_long_t s_remove_count;
1487
1488
1489 atomic_long_t s_fsnotify_inode_refs;
1490
1491
1492 int s_readonly_remount;
1493
1494
1495 struct workqueue_struct *s_dio_done_wq;
1496 struct hlist_head s_pins;
1497
1498
1499
1500
1501
1502
1503 struct user_namespace *s_user_ns;
1504
1505
1506
1507
1508
1509
1510 struct list_lru s_dentry_lru;
1511 struct list_lru s_inode_lru;
1512 struct rcu_head rcu;
1513 struct work_struct destroy_work;
1514
1515 struct mutex s_sync_lock;
1516
1517
1518
1519
1520 int s_stack_depth;
1521
1522
1523 spinlock_t s_inode_list_lock ____cacheline_aligned_in_smp;
1524 struct list_head s_inodes;
1525
1526 spinlock_t s_inode_wblist_lock;
1527 struct list_head s_inodes_wb;
1528} __randomize_layout;
1529
1530
1531
1532
1533
1534
1535static inline uid_t i_uid_read(const struct inode *inode)
1536{
1537 return from_kuid(inode->i_sb->s_user_ns, inode->i_uid);
1538}
1539
1540static inline gid_t i_gid_read(const struct inode *inode)
1541{
1542 return from_kgid(inode->i_sb->s_user_ns, inode->i_gid);
1543}
1544
1545static inline void i_uid_write(struct inode *inode, uid_t uid)
1546{
1547 inode->i_uid = make_kuid(inode->i_sb->s_user_ns, uid);
1548}
1549
1550static inline void i_gid_write(struct inode *inode, gid_t gid)
1551{
1552 inode->i_gid = make_kgid(inode->i_sb->s_user_ns, gid);
1553}
1554
1555extern struct timespec64 timespec64_trunc(struct timespec64 t, unsigned gran);
1556extern struct timespec64 current_time(struct inode *inode);
1557
1558
1559
1560
1561
1562void __sb_end_write(struct super_block *sb, int level);
1563int __sb_start_write(struct super_block *sb, int level, bool wait);
1564
1565#define __sb_writers_acquired(sb, lev) \
1566 percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1567#define __sb_writers_release(sb, lev) \
1568 percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1569
1570
1571
1572
1573
1574
1575
1576
1577static inline void sb_end_write(struct super_block *sb)
1578{
1579 __sb_end_write(sb, SB_FREEZE_WRITE);
1580}
1581
1582
1583
1584
1585
1586
1587
1588
1589static inline void sb_end_pagefault(struct super_block *sb)
1590{
1591 __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
1592}
1593
1594
1595
1596
1597
1598
1599
1600
1601static inline void sb_end_intwrite(struct super_block *sb)
1602{
1603 __sb_end_write(sb, SB_FREEZE_FS);
1604}
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625static inline void sb_start_write(struct super_block *sb)
1626{
1627 __sb_start_write(sb, SB_FREEZE_WRITE, true);
1628}
1629
1630static inline int sb_start_write_trylock(struct super_block *sb)
1631{
1632 return __sb_start_write(sb, SB_FREEZE_WRITE, false);
1633}
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654static inline void sb_start_pagefault(struct super_block *sb)
1655{
1656 __sb_start_write(sb, SB_FREEZE_PAGEFAULT, true);
1657}
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672static inline void sb_start_intwrite(struct super_block *sb)
1673{
1674 __sb_start_write(sb, SB_FREEZE_FS, true);
1675}
1676
1677static inline int sb_start_intwrite_trylock(struct super_block *sb)
1678{
1679 return __sb_start_write(sb, SB_FREEZE_FS, false);
1680}
1681
1682
1683extern bool inode_owner_or_capable(const struct inode *inode);
1684
1685
1686
1687
1688extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
1689extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
1690extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
1691extern int vfs_symlink(struct inode *, struct dentry *, const char *);
1692extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
1693extern int vfs_rmdir(struct inode *, struct dentry *);
1694extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
1695extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
1696extern int vfs_whiteout(struct inode *, struct dentry *);
1697
1698extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
1699 int open_flag);
1700
1701int vfs_mkobj(struct dentry *, umode_t,
1702 int (*f)(struct dentry *, umode_t, void *),
1703 void *);
1704
1705extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1706
1707
1708
1709
1710extern void inode_init_owner(struct inode *inode, const struct inode *dir,
1711 umode_t mode);
1712extern bool may_open_dev(const struct path *path);
1713
1714
1715
1716struct fiemap_extent_info {
1717 unsigned int fi_flags;
1718 unsigned int fi_extents_mapped;
1719 unsigned int fi_extents_max;
1720 struct fiemap_extent __user *fi_extents_start;
1721
1722};
1723int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
1724 u64 phys, u64 len, u32 flags);
1725int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
1726
1727
1728
1729
1730
1731
1732
1733struct dir_context;
1734typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
1735 unsigned);
1736
1737struct dir_context {
1738 filldir_t actor;
1739 loff_t pos;
1740};
1741
1742struct block_device_operations;
1743
1744
1745
1746
1747#define HAVE_COMPAT_IOCTL 1
1748#define HAVE_UNLOCKED_IOCTL 1
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760#define NOMMU_MAP_COPY 0x00000001
1761#define NOMMU_MAP_DIRECT 0x00000008
1762#define NOMMU_MAP_READ VM_MAYREAD
1763#define NOMMU_MAP_WRITE VM_MAYWRITE
1764#define NOMMU_MAP_EXEC VM_MAYEXEC
1765
1766#define NOMMU_VMFLAGS \
1767 (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777#define REMAP_FILE_DEDUP (1 << 0)
1778#define REMAP_FILE_CAN_SHORTEN (1 << 1)
1779
1780
1781
1782
1783
1784
1785
1786
1787#define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN)
1788
1789struct iov_iter;
1790
1791struct file_operations {
1792 struct module *owner;
1793 loff_t (*llseek) (struct file *, loff_t, int);
1794 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1795 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1796 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
1797 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
1798 int (*iopoll)(struct kiocb *kiocb, bool spin);
1799 int (*iterate) (struct file *, struct dir_context *);
1800 int (*iterate_shared) (struct file *, struct dir_context *);
1801 __poll_t (*poll) (struct file *, struct poll_table_struct *);
1802 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1803 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1804 int (*mmap) (struct file *, struct vm_area_struct *);
1805 unsigned long mmap_supported_flags;
1806 int (*open) (struct inode *, struct file *);
1807 int (*flush) (struct file *, fl_owner_t id);
1808 int (*release) (struct inode *, struct file *);
1809 int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1810 int (*fasync) (int, struct file *, int);
1811 int (*lock) (struct file *, int, struct file_lock *);
1812 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
1813 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1814 int (*check_flags)(int);
1815 int (*flock) (struct file *, int, struct file_lock *);
1816 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1817 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1818 int (*setlease)(struct file *, long, struct file_lock **, void **);
1819 long (*fallocate)(struct file *file, int mode, loff_t offset,
1820 loff_t len);
1821 void (*show_fdinfo)(struct seq_file *m, struct file *f);
1822#ifndef CONFIG_MMU
1823 unsigned (*mmap_capabilities)(struct file *);
1824#endif
1825 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
1826 loff_t, size_t, unsigned int);
1827 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
1828 struct file *file_out, loff_t pos_out,
1829 loff_t len, unsigned int remap_flags);
1830 int (*fadvise)(struct file *, loff_t, loff_t, int);
1831} __randomize_layout;
1832
1833struct inode_operations {
1834 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
1835 const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
1836 int (*permission) (struct inode *, int);
1837 struct posix_acl * (*get_acl)(struct inode *, int);
1838
1839 int (*readlink) (struct dentry *, char __user *,int);
1840
1841 int (*create) (struct inode *,struct dentry *, umode_t, bool);
1842 int (*link) (struct dentry *,struct inode *,struct dentry *);
1843 int (*unlink) (struct inode *,struct dentry *);
1844 int (*symlink) (struct inode *,struct dentry *,const char *);
1845 int (*mkdir) (struct inode *,struct dentry *,umode_t);
1846 int (*rmdir) (struct inode *,struct dentry *);
1847 int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
1848 int (*rename) (struct inode *, struct dentry *,
1849 struct inode *, struct dentry *, unsigned int);
1850 int (*setattr) (struct dentry *, struct iattr *);
1851 int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);
1852 ssize_t (*listxattr) (struct dentry *, char *, size_t);
1853 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
1854 u64 len);
1855 int (*update_time)(struct inode *, struct timespec64 *, int);
1856 int (*atomic_open)(struct inode *, struct dentry *,
1857 struct file *, unsigned open_flag,
1858 umode_t create_mode);
1859 int (*tmpfile) (struct inode *, struct dentry *, umode_t);
1860 int (*set_acl)(struct inode *, struct posix_acl *, int);
1861} ____cacheline_aligned;
1862
1863static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
1864 struct iov_iter *iter)
1865{
1866 return file->f_op->read_iter(kio, iter);
1867}
1868
1869static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
1870 struct iov_iter *iter)
1871{
1872 return file->f_op->write_iter(kio, iter);
1873}
1874
1875static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
1876{
1877 return file->f_op->mmap(file, vma);
1878}
1879
1880ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
1881 unsigned long nr_segs, unsigned long fast_segs,
1882 struct iovec *fast_pointer,
1883 struct iovec **ret_pointer);
1884
1885extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *);
1886extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
1887extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
1888extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
1889 unsigned long, loff_t *, rwf_t);
1890extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
1891 loff_t, size_t, unsigned int);
1892extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
1893 struct file *file_out, loff_t pos_out,
1894 loff_t *count,
1895 unsigned int remap_flags);
1896extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
1897 struct file *file_out, loff_t pos_out,
1898 loff_t len, unsigned int remap_flags);
1899extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
1900 struct file *file_out, loff_t pos_out,
1901 loff_t len, unsigned int remap_flags);
1902extern int vfs_dedupe_file_range(struct file *file,
1903 struct file_dedupe_range *same);
1904extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
1905 struct file *dst_file, loff_t dst_pos,
1906 loff_t len, unsigned int remap_flags);
1907
1908
1909struct super_operations {
1910 struct inode *(*alloc_inode)(struct super_block *sb);
1911 void (*destroy_inode)(struct inode *);
1912 void (*free_inode)(struct inode *);
1913
1914 void (*dirty_inode) (struct inode *, int flags);
1915 int (*write_inode) (struct inode *, struct writeback_control *wbc);
1916 int (*drop_inode) (struct inode *);
1917 void (*evict_inode) (struct inode *);
1918 void (*put_super) (struct super_block *);
1919 int (*sync_fs)(struct super_block *sb, int wait);
1920 int (*freeze_super) (struct super_block *);
1921 int (*freeze_fs) (struct super_block *);
1922 int (*thaw_super) (struct super_block *);
1923 int (*unfreeze_fs) (struct super_block *);
1924 int (*statfs) (struct dentry *, struct kstatfs *);
1925 int (*remount_fs) (struct super_block *, int *, char *);
1926 void (*umount_begin) (struct super_block *);
1927
1928 int (*show_options)(struct seq_file *, struct dentry *);
1929 int (*show_devname)(struct seq_file *, struct dentry *);
1930 int (*show_path)(struct seq_file *, struct dentry *);
1931 int (*show_stats)(struct seq_file *, struct dentry *);
1932#ifdef CONFIG_QUOTA
1933 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
1934 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
1935 struct dquot **(*get_dquots)(struct inode *);
1936#endif
1937 int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
1938 long (*nr_cached_objects)(struct super_block *,
1939 struct shrink_control *);
1940 long (*free_cached_objects)(struct super_block *,
1941 struct shrink_control *);
1942};
1943
1944
1945
1946
1947#define S_SYNC 1
1948#define S_NOATIME 2
1949#define S_APPEND 4
1950#define S_IMMUTABLE 8
1951#define S_DEAD 16
1952#define S_NOQUOTA 32
1953#define S_DIRSYNC 64
1954#define S_NOCMTIME 128
1955#define S_SWAPFILE 256
1956#define S_PRIVATE 512
1957#define S_IMA 1024
1958#define S_AUTOMOUNT 2048
1959#define S_NOSEC 4096
1960#ifdef CONFIG_FS_DAX
1961#define S_DAX 8192
1962#else
1963#define S_DAX 0
1964#endif
1965#define S_ENCRYPTED 16384
1966#define S_CASEFOLD 32768
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
1982
1983static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
1984#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
1985#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
1986 ((inode)->i_flags & S_SYNC))
1987#define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \
1988 ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
1989#define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK)
1990#define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY|SB_NOATIME)
1991#define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION)
1992
1993#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
1994#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
1995#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
1996#define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL)
1997
1998#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
1999#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
2000#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
2001#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2002#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2003#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2004#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
2005#define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2006#define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
2007#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
2008
2009#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2010 (inode)->i_rdev == WHITEOUT_DEV)
2011
2012static inline bool HAS_UNMAPPED_ID(struct inode *inode)
2013{
2014 return !uid_valid(inode->i_uid) || !gid_valid(inode->i_gid);
2015}
2016
2017static inline enum rw_hint file_write_hint(struct file *file)
2018{
2019 if (file->f_write_hint != WRITE_LIFE_NOT_SET)
2020 return file->f_write_hint;
2021
2022 return file_inode(file)->i_write_hint;
2023}
2024
2025static inline int iocb_flags(struct file *file);
2026
2027static inline u16 ki_hint_validate(enum rw_hint hint)
2028{
2029 typeof(((struct kiocb *)0)->ki_hint) max_hint = -1;
2030
2031 if (hint <= max_hint)
2032 return hint;
2033 return 0;
2034}
2035
2036static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
2037{
2038 *kiocb = (struct kiocb) {
2039 .ki_filp = filp,
2040 .ki_flags = iocb_flags(filp),
2041 .ki_hint = ki_hint_validate(file_write_hint(filp)),
2042 .ki_ioprio = get_current_ioprio(),
2043 };
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#define I_DIRTY_SYNC (1 << 0)
2110#define I_DIRTY_DATASYNC (1 << 1)
2111#define I_DIRTY_PAGES (1 << 2)
2112#define __I_NEW 3
2113#define I_NEW (1 << __I_NEW)
2114#define I_WILL_FREE (1 << 4)
2115#define I_FREEING (1 << 5)
2116#define I_CLEAR (1 << 6)
2117#define __I_SYNC 7
2118#define I_SYNC (1 << __I_SYNC)
2119#define I_REFERENCED (1 << 8)
2120#define __I_DIO_WAKEUP 9
2121#define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP)
2122#define I_LINKABLE (1 << 10)
2123#define I_DIRTY_TIME (1 << 11)
2124#define __I_DIRTY_TIME_EXPIRED 12
2125#define I_DIRTY_TIME_EXPIRED (1 << __I_DIRTY_TIME_EXPIRED)
2126#define I_WB_SWITCH (1 << 13)
2127#define I_OVL_INUSE (1 << 14)
2128#define I_CREATING (1 << 15)
2129
2130#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
2131#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
2132#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
2133
2134extern void __mark_inode_dirty(struct inode *, int);
2135static inline void mark_inode_dirty(struct inode *inode)
2136{
2137 __mark_inode_dirty(inode, I_DIRTY);
2138}
2139
2140static inline void mark_inode_dirty_sync(struct inode *inode)
2141{
2142 __mark_inode_dirty(inode, I_DIRTY_SYNC);
2143}
2144
2145extern void inc_nlink(struct inode *inode);
2146extern void drop_nlink(struct inode *inode);
2147extern void clear_nlink(struct inode *inode);
2148extern void set_nlink(struct inode *inode, unsigned int nlink);
2149
2150static inline void inode_inc_link_count(struct inode *inode)
2151{
2152 inc_nlink(inode);
2153 mark_inode_dirty(inode);
2154}
2155
2156static inline void inode_dec_link_count(struct inode *inode)
2157{
2158 drop_nlink(inode);
2159 mark_inode_dirty(inode);
2160}
2161
2162enum file_time_flags {
2163 S_ATIME = 1,
2164 S_MTIME = 2,
2165 S_CTIME = 4,
2166 S_VERSION = 8,
2167};
2168
2169extern bool atime_needs_update(const struct path *, struct inode *);
2170extern void touch_atime(const struct path *);
2171static inline void file_accessed(struct file *file)
2172{
2173 if (!(file->f_flags & O_NOATIME))
2174 touch_atime(&file->f_path);
2175}
2176
2177int sync_inode(struct inode *inode, struct writeback_control *wbc);
2178int sync_inode_metadata(struct inode *inode, int wait);
2179
2180struct file_system_type {
2181 const char *name;
2182 int fs_flags;
2183#define FS_REQUIRES_DEV 1
2184#define FS_BINARY_MOUNTDATA 2
2185#define FS_HAS_SUBTYPE 4
2186#define FS_USERNS_MOUNT 8
2187#define FS_RENAME_DOES_D_MOVE 32768
2188 int (*init_fs_context)(struct fs_context *);
2189 const struct fs_parameter_description *parameters;
2190 struct dentry *(*mount) (struct file_system_type *, int,
2191 const char *, void *);
2192 void (*kill_sb) (struct super_block *);
2193 struct module *owner;
2194 struct file_system_type * next;
2195 struct hlist_head fs_supers;
2196
2197 struct lock_class_key s_lock_key;
2198 struct lock_class_key s_umount_key;
2199 struct lock_class_key s_vfs_rename_key;
2200 struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
2201
2202 struct lock_class_key i_lock_key;
2203 struct lock_class_key i_mutex_key;
2204 struct lock_class_key i_mutex_dir_key;
2205};
2206
2207#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2208
2209extern struct dentry *mount_ns(struct file_system_type *fs_type,
2210 int flags, void *data, void *ns, struct user_namespace *user_ns,
2211 int (*fill_super)(struct super_block *, void *, int));
2212#ifdef CONFIG_BLOCK
2213extern struct dentry *mount_bdev(struct file_system_type *fs_type,
2214 int flags, const char *dev_name, void *data,
2215 int (*fill_super)(struct super_block *, void *, int));
2216#else
2217static inline struct dentry *mount_bdev(struct file_system_type *fs_type,
2218 int flags, const char *dev_name, void *data,
2219 int (*fill_super)(struct super_block *, void *, int))
2220{
2221 return ERR_PTR(-ENODEV);
2222}
2223#endif
2224extern struct dentry *mount_single(struct file_system_type *fs_type,
2225 int flags, void *data,
2226 int (*fill_super)(struct super_block *, void *, int));
2227extern struct dentry *mount_nodev(struct file_system_type *fs_type,
2228 int flags, void *data,
2229 int (*fill_super)(struct super_block *, void *, int));
2230extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
2231void generic_shutdown_super(struct super_block *sb);
2232#ifdef CONFIG_BLOCK
2233void kill_block_super(struct super_block *sb);
2234#else
2235static inline void kill_block_super(struct super_block *sb)
2236{
2237 BUG();
2238}
2239#endif
2240void kill_anon_super(struct super_block *sb);
2241void kill_litter_super(struct super_block *sb);
2242void deactivate_super(struct super_block *sb);
2243void deactivate_locked_super(struct super_block *sb);
2244int set_anon_super(struct super_block *s, void *data);
2245int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
2246int get_anon_bdev(dev_t *);
2247void free_anon_bdev(dev_t);
2248struct super_block *sget_fc(struct fs_context *fc,
2249 int (*test)(struct super_block *, struct fs_context *),
2250 int (*set)(struct super_block *, struct fs_context *));
2251struct super_block *sget_userns(struct file_system_type *type,
2252 int (*test)(struct super_block *,void *),
2253 int (*set)(struct super_block *,void *),
2254 int flags, struct user_namespace *user_ns,
2255 void *data);
2256struct super_block *sget(struct file_system_type *type,
2257 int (*test)(struct super_block *,void *),
2258 int (*set)(struct super_block *,void *),
2259 int flags, void *data);
2260extern struct dentry *mount_pseudo_xattr(struct file_system_type *, char *,
2261 const struct super_operations *ops,
2262 const struct xattr_handler **xattr,
2263 const struct dentry_operations *dops,
2264 unsigned long);
2265
2266static inline struct dentry *
2267mount_pseudo(struct file_system_type *fs_type, char *name,
2268 const struct super_operations *ops,
2269 const struct dentry_operations *dops, unsigned long magic)
2270{
2271 return mount_pseudo_xattr(fs_type, name, ops, NULL, dops, magic);
2272}
2273
2274
2275#define fops_get(fops) \
2276 (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
2277#define fops_put(fops) \
2278 do { if (fops) module_put((fops)->owner); } while(0)
2279
2280
2281
2282
2283
2284#define replace_fops(f, fops) \
2285 do { \
2286 struct file *__file = (f); \
2287 fops_put(__file->f_op); \
2288 BUG_ON(!(__file->f_op = (fops))); \
2289 } while(0)
2290
2291extern int register_filesystem(struct file_system_type *);
2292extern int unregister_filesystem(struct file_system_type *);
2293extern struct vfsmount *kern_mount(struct file_system_type *);
2294extern void kern_unmount(struct vfsmount *mnt);
2295extern int may_umount_tree(struct vfsmount *);
2296extern int may_umount(struct vfsmount *);
2297extern long do_mount(const char *, const char __user *,
2298 const char *, unsigned long, void *);
2299extern struct vfsmount *collect_mounts(const struct path *);
2300extern void drop_collected_mounts(struct vfsmount *);
2301extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
2302 struct vfsmount *);
2303extern int vfs_statfs(const struct path *, struct kstatfs *);
2304extern int user_statfs(const char __user *, struct kstatfs *);
2305extern int fd_statfs(int, struct kstatfs *);
2306extern int freeze_super(struct super_block *super);
2307extern int thaw_super(struct super_block *super);
2308extern bool our_mnt(struct vfsmount *mnt);
2309extern __printf(2, 3)
2310int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
2311extern int super_setup_bdi(struct super_block *sb);
2312
2313extern int current_umask(void);
2314
2315extern void ihold(struct inode * inode);
2316extern void iput(struct inode *);
2317extern int generic_update_time(struct inode *, struct timespec64 *, int);
2318
2319
2320extern struct kobject *fs_kobj;
2321
2322#define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
2323
2324#ifdef CONFIG_MANDATORY_FILE_LOCKING
2325extern int locks_mandatory_locked(struct file *);
2326extern int locks_mandatory_area(struct inode *, struct file *, loff_t, loff_t, unsigned char);
2327
2328
2329
2330
2331
2332
2333static inline int __mandatory_lock(struct inode *ino)
2334{
2335 return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
2336}
2337
2338
2339
2340
2341
2342
2343static inline int mandatory_lock(struct inode *ino)
2344{
2345 return IS_MANDLOCK(ino) && __mandatory_lock(ino);
2346}
2347
2348static inline int locks_verify_locked(struct file *file)
2349{
2350 if (mandatory_lock(locks_inode(file)))
2351 return locks_mandatory_locked(file);
2352 return 0;
2353}
2354
2355static inline int locks_verify_truncate(struct inode *inode,
2356 struct file *f,
2357 loff_t size)
2358{
2359 if (!inode->i_flctx || !mandatory_lock(inode))
2360 return 0;
2361
2362 if (size < inode->i_size) {
2363 return locks_mandatory_area(inode, f, size, inode->i_size - 1,
2364 F_WRLCK);
2365 } else {
2366 return locks_mandatory_area(inode, f, inode->i_size, size - 1,
2367 F_WRLCK);
2368 }
2369}
2370
2371#else
2372
2373static inline int locks_mandatory_locked(struct file *file)
2374{
2375 return 0;
2376}
2377
2378static inline int locks_mandatory_area(struct inode *inode, struct file *filp,
2379 loff_t start, loff_t end, unsigned char type)
2380{
2381 return 0;
2382}
2383
2384static inline int __mandatory_lock(struct inode *inode)
2385{
2386 return 0;
2387}
2388
2389static inline int mandatory_lock(struct inode *inode)
2390{
2391 return 0;
2392}
2393
2394static inline int locks_verify_locked(struct file *file)
2395{
2396 return 0;
2397}
2398
2399static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
2400 size_t size)
2401{
2402 return 0;
2403}
2404
2405#endif
2406
2407
2408#ifdef CONFIG_FILE_LOCKING
2409static inline int break_lease(struct inode *inode, unsigned int mode)
2410{
2411
2412
2413
2414
2415
2416
2417 smp_mb();
2418 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2419 return __break_lease(inode, mode, FL_LEASE);
2420 return 0;
2421}
2422
2423static inline int break_deleg(struct inode *inode, unsigned int mode)
2424{
2425
2426
2427
2428
2429
2430
2431 smp_mb();
2432 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2433 return __break_lease(inode, mode, FL_DELEG);
2434 return 0;
2435}
2436
2437static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2438{
2439 int ret;
2440
2441 ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
2442 if (ret == -EWOULDBLOCK && delegated_inode) {
2443 *delegated_inode = inode;
2444 ihold(inode);
2445 }
2446 return ret;
2447}
2448
2449static inline int break_deleg_wait(struct inode **delegated_inode)
2450{
2451 int ret;
2452
2453 ret = break_deleg(*delegated_inode, O_WRONLY);
2454 iput(*delegated_inode);
2455 *delegated_inode = NULL;
2456 return ret;
2457}
2458
2459static inline int break_layout(struct inode *inode, bool wait)
2460{
2461 smp_mb();
2462 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2463 return __break_lease(inode,
2464 wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
2465 FL_LAYOUT);
2466 return 0;
2467}
2468
2469#else
2470static inline int break_lease(struct inode *inode, unsigned int mode)
2471{
2472 return 0;
2473}
2474
2475static inline int break_deleg(struct inode *inode, unsigned int mode)
2476{
2477 return 0;
2478}
2479
2480static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2481{
2482 return 0;
2483}
2484
2485static inline int break_deleg_wait(struct inode **delegated_inode)
2486{
2487 BUG();
2488 return 0;
2489}
2490
2491static inline int break_layout(struct inode *inode, bool wait)
2492{
2493 return 0;
2494}
2495
2496#endif
2497
2498
2499struct audit_names;
2500struct filename {
2501 const char *name;
2502 const __user char *uptr;
2503 int refcnt;
2504 struct audit_names *aname;
2505 const char iname[];
2506};
2507static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
2508
2509extern long vfs_truncate(const struct path *, loff_t);
2510extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
2511 struct file *filp);
2512extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
2513 loff_t len);
2514extern long do_sys_open(int dfd, const char __user *filename, int flags,
2515 umode_t mode);
2516extern struct file *file_open_name(struct filename *, int, umode_t);
2517extern struct file *filp_open(const char *, int, umode_t);
2518extern struct file *file_open_root(struct dentry *, struct vfsmount *,
2519 const char *, int, umode_t);
2520extern struct file * dentry_open(const struct path *, int, const struct cred *);
2521extern struct file * open_with_fake_path(const struct path *, int,
2522 struct inode*, const struct cred *);
2523static inline struct file *file_clone_open(struct file *file)
2524{
2525 return dentry_open(&file->f_path, file->f_flags, file->f_cred);
2526}
2527extern int filp_close(struct file *, fl_owner_t id);
2528
2529extern struct filename *getname_flags(const char __user *, int, int *);
2530extern struct filename *getname(const char __user *);
2531extern struct filename *getname_kernel(const char *);
2532extern void putname(struct filename *name);
2533
2534extern int finish_open(struct file *file, struct dentry *dentry,
2535 int (*open)(struct inode *, struct file *));
2536extern int finish_no_open(struct file *file, struct dentry *dentry);
2537
2538
2539
2540extern int ioctl_preallocate(struct file *filp, void __user *argp);
2541
2542
2543extern void __init vfs_caches_init_early(void);
2544extern void __init vfs_caches_init(void);
2545
2546extern struct kmem_cache *names_cachep;
2547
2548#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
2549#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
2550
2551#ifdef CONFIG_BLOCK
2552extern int register_blkdev(unsigned int, const char *);
2553extern void unregister_blkdev(unsigned int, const char *);
2554extern void bdev_unhash_inode(dev_t dev);
2555extern struct block_device *bdget(dev_t);
2556extern struct block_device *bdgrab(struct block_device *bdev);
2557extern void bd_set_size(struct block_device *, loff_t size);
2558extern void bd_forget(struct inode *inode);
2559extern void bdput(struct block_device *);
2560extern void invalidate_bdev(struct block_device *);
2561extern void iterate_bdevs(void (*)(struct block_device *, void *), void *);
2562extern int sync_blockdev(struct block_device *bdev);
2563extern void kill_bdev(struct block_device *);
2564extern struct super_block *freeze_bdev(struct block_device *);
2565extern void emergency_thaw_all(void);
2566extern void emergency_thaw_bdev(struct super_block *sb);
2567extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
2568extern int fsync_bdev(struct block_device *);
2569
2570extern struct super_block *blockdev_superblock;
2571
2572static inline bool sb_is_blkdev_sb(struct super_block *sb)
2573{
2574 return sb == blockdev_superblock;
2575}
2576#else
2577static inline void bd_forget(struct inode *inode) {}
2578static inline int sync_blockdev(struct block_device *bdev) { return 0; }
2579static inline void kill_bdev(struct block_device *bdev) {}
2580static inline void invalidate_bdev(struct block_device *bdev) {}
2581
2582static inline struct super_block *freeze_bdev(struct block_device *sb)
2583{
2584 return NULL;
2585}
2586
2587static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
2588{
2589 return 0;
2590}
2591
2592static inline int emergency_thaw_bdev(struct super_block *sb)
2593{
2594 return 0;
2595}
2596
2597static inline void iterate_bdevs(void (*f)(struct block_device *, void *), void *arg)
2598{
2599}
2600
2601static inline bool sb_is_blkdev_sb(struct super_block *sb)
2602{
2603 return false;
2604}
2605#endif
2606extern int sync_filesystem(struct super_block *);
2607extern const struct file_operations def_blk_fops;
2608extern const struct file_operations def_chr_fops;
2609#ifdef CONFIG_BLOCK
2610extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
2611extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
2612extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
2613extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
2614extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
2615 void *holder);
2616extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
2617 void *holder);
2618extern void blkdev_put(struct block_device *bdev, fmode_t mode);
2619extern int __blkdev_reread_part(struct block_device *bdev);
2620extern int blkdev_reread_part(struct block_device *bdev);
2621
2622#ifdef CONFIG_SYSFS
2623extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
2624extern void bd_unlink_disk_holder(struct block_device *bdev,
2625 struct gendisk *disk);
2626#else
2627static inline int bd_link_disk_holder(struct block_device *bdev,
2628 struct gendisk *disk)
2629{
2630 return 0;
2631}
2632static inline void bd_unlink_disk_holder(struct block_device *bdev,
2633 struct gendisk *disk)
2634{
2635}
2636#endif
2637#endif
2638
2639
2640#define CHRDEV_MAJOR_MAX 512
2641
2642#define CHRDEV_MAJOR_DYN_END 234
2643
2644#define CHRDEV_MAJOR_DYN_EXT_START 511
2645#define CHRDEV_MAJOR_DYN_EXT_END 384
2646
2647extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2648extern int register_chrdev_region(dev_t, unsigned, const char *);
2649extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2650 unsigned int count, const char *name,
2651 const struct file_operations *fops);
2652extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2653 unsigned int count, const char *name);
2654extern void unregister_chrdev_region(dev_t, unsigned);
2655extern void chrdev_show(struct seq_file *,off_t);
2656
2657static inline int register_chrdev(unsigned int major, const char *name,
2658 const struct file_operations *fops)
2659{
2660 return __register_chrdev(major, 0, 256, name, fops);
2661}
2662
2663static inline void unregister_chrdev(unsigned int major, const char *name)
2664{
2665 __unregister_chrdev(major, 0, 256, name);
2666}
2667
2668
2669#define BDEVNAME_SIZE 32
2670#define BDEVT_SIZE 10
2671
2672#ifdef CONFIG_BLOCK
2673#define BLKDEV_MAJOR_MAX 512
2674extern const char *__bdevname(dev_t, char *buffer);
2675extern const char *bdevname(struct block_device *bdev, char *buffer);
2676extern struct block_device *lookup_bdev(const char *);
2677extern void blkdev_show(struct seq_file *,off_t);
2678
2679#else
2680#define BLKDEV_MAJOR_MAX 0
2681#endif
2682
2683extern void init_special_inode(struct inode *, umode_t, dev_t);
2684
2685
2686extern void make_bad_inode(struct inode *);
2687extern bool is_bad_inode(struct inode *);
2688
2689#ifdef CONFIG_BLOCK
2690extern void check_disk_size_change(struct gendisk *disk,
2691 struct block_device *bdev, bool verbose);
2692extern int revalidate_disk(struct gendisk *);
2693extern int check_disk_change(struct block_device *);
2694extern int __invalidate_device(struct block_device *, bool);
2695extern int invalidate_partition(struct gendisk *, int);
2696#endif
2697unsigned long invalidate_mapping_pages(struct address_space *mapping,
2698 pgoff_t start, pgoff_t end);
2699
2700static inline void invalidate_remote_inode(struct inode *inode)
2701{
2702 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2703 S_ISLNK(inode->i_mode))
2704 invalidate_mapping_pages(inode->i_mapping, 0, -1);
2705}
2706extern int invalidate_inode_pages2(struct address_space *mapping);
2707extern int invalidate_inode_pages2_range(struct address_space *mapping,
2708 pgoff_t start, pgoff_t end);
2709extern int write_inode_now(struct inode *, int);
2710extern int filemap_fdatawrite(struct address_space *);
2711extern int filemap_flush(struct address_space *);
2712extern int filemap_fdatawait_keep_errors(struct address_space *mapping);
2713extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
2714 loff_t lend);
2715
2716static inline int filemap_fdatawait(struct address_space *mapping)
2717{
2718 return filemap_fdatawait_range(mapping, 0, LLONG_MAX);
2719}
2720
2721extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
2722 loff_t lend);
2723extern int filemap_write_and_wait(struct address_space *mapping);
2724extern int filemap_write_and_wait_range(struct address_space *mapping,
2725 loff_t lstart, loff_t lend);
2726extern int __filemap_fdatawrite_range(struct address_space *mapping,
2727 loff_t start, loff_t end, int sync_mode);
2728extern int filemap_fdatawrite_range(struct address_space *mapping,
2729 loff_t start, loff_t end);
2730extern int filemap_check_errors(struct address_space *mapping);
2731extern void __filemap_set_wb_err(struct address_space *mapping, int err);
2732
2733extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2734 loff_t lend);
2735extern int __must_check file_check_and_advance_wb_err(struct file *file);
2736extern int __must_check file_write_and_wait_range(struct file *file,
2737 loff_t start, loff_t end);
2738
2739static inline int file_write_and_wait(struct file *file)
2740{
2741 return file_write_and_wait_range(file, 0, LLONG_MAX);
2742}
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758static inline void filemap_set_wb_err(struct address_space *mapping, int err)
2759{
2760
2761 if (unlikely(err))
2762 __filemap_set_wb_err(mapping, err);
2763}
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775static inline int filemap_check_wb_err(struct address_space *mapping,
2776 errseq_t since)
2777{
2778 return errseq_check(&mapping->wb_err, since);
2779}
2780
2781
2782
2783
2784
2785
2786
2787
2788static inline errseq_t filemap_sample_wb_err(struct address_space *mapping)
2789{
2790 return errseq_sample(&mapping->wb_err);
2791}
2792
2793extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2794 int datasync);
2795extern int vfs_fsync(struct file *file, int datasync);
2796
2797extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
2798 unsigned int flags);
2799
2800
2801
2802
2803
2804
2805static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
2806{
2807 if (iocb->ki_flags & IOCB_DSYNC) {
2808 int ret = vfs_fsync_range(iocb->ki_filp,
2809 iocb->ki_pos - count, iocb->ki_pos - 1,
2810 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1);
2811 if (ret)
2812 return ret;
2813 }
2814
2815 return count;
2816}
2817
2818extern void emergency_sync(void);
2819extern void emergency_remount(void);
2820#ifdef CONFIG_BLOCK
2821extern sector_t bmap(struct inode *, sector_t);
2822#endif
2823extern int notify_change(struct dentry *, struct iattr *, struct inode **);
2824extern int inode_permission(struct inode *, int);
2825extern int generic_permission(struct inode *, int);
2826extern int __check_sticky(struct inode *dir, struct inode *inode);
2827
2828static inline bool execute_ok(struct inode *inode)
2829{
2830 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
2831}
2832
2833static inline void file_start_write(struct file *file)
2834{
2835 if (!S_ISREG(file_inode(file)->i_mode))
2836 return;
2837 __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
2838}
2839
2840static inline bool file_start_write_trylock(struct file *file)
2841{
2842 if (!S_ISREG(file_inode(file)->i_mode))
2843 return true;
2844 return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false);
2845}
2846
2847static inline void file_end_write(struct file *file)
2848{
2849 if (!S_ISREG(file_inode(file)->i_mode))
2850 return;
2851 __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
2852}
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870static inline int get_write_access(struct inode *inode)
2871{
2872 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
2873}
2874static inline int deny_write_access(struct file *file)
2875{
2876 struct inode *inode = file_inode(file);
2877 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
2878}
2879static inline void put_write_access(struct inode * inode)
2880{
2881 atomic_dec(&inode->i_writecount);
2882}
2883static inline void allow_write_access(struct file *file)
2884{
2885 if (file)
2886 atomic_inc(&file_inode(file)->i_writecount);
2887}
2888static inline bool inode_is_open_for_write(const struct inode *inode)
2889{
2890 return atomic_read(&inode->i_writecount) > 0;
2891}
2892
2893#ifdef CONFIG_IMA
2894static inline void i_readcount_dec(struct inode *inode)
2895{
2896 BUG_ON(!atomic_read(&inode->i_readcount));
2897 atomic_dec(&inode->i_readcount);
2898}
2899static inline void i_readcount_inc(struct inode *inode)
2900{
2901 atomic_inc(&inode->i_readcount);
2902}
2903#else
2904static inline void i_readcount_dec(struct inode *inode)
2905{
2906 return;
2907}
2908static inline void i_readcount_inc(struct inode *inode)
2909{
2910 return;
2911}
2912#endif
2913extern int do_pipe_flags(int *, int);
2914
2915#define __kernel_read_file_id(id) \
2916 id(UNKNOWN, unknown) \
2917 id(FIRMWARE, firmware) \
2918 id(FIRMWARE_PREALLOC_BUFFER, firmware) \
2919 id(MODULE, kernel-module) \
2920 id(KEXEC_IMAGE, kexec-image) \
2921 id(KEXEC_INITRAMFS, kexec-initramfs) \
2922 id(POLICY, security-policy) \
2923 id(X509_CERTIFICATE, x509-certificate) \
2924 id(MAX_ID, )
2925
2926#define __fid_enumify(ENUM, dummy) READING_ ## ENUM,
2927#define __fid_stringify(dummy, str) #str,
2928
2929enum kernel_read_file_id {
2930 __kernel_read_file_id(__fid_enumify)
2931};
2932
2933static const char * const kernel_read_file_str[] = {
2934 __kernel_read_file_id(__fid_stringify)
2935};
2936
2937static inline const char *kernel_read_file_id_str(enum kernel_read_file_id id)
2938{
2939 if ((unsigned)id >= READING_MAX_ID)
2940 return kernel_read_file_str[READING_UNKNOWN];
2941
2942 return kernel_read_file_str[id];
2943}
2944
2945extern int kernel_read_file(struct file *, void **, loff_t *, loff_t,
2946 enum kernel_read_file_id);
2947extern int kernel_read_file_from_path(const char *, void **, loff_t *, loff_t,
2948 enum kernel_read_file_id);
2949extern int kernel_read_file_from_fd(int, void **, loff_t *, loff_t,
2950 enum kernel_read_file_id);
2951extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
2952extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
2953extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
2954extern struct file * open_exec(const char *);
2955
2956
2957extern bool is_subdir(struct dentry *, struct dentry *);
2958extern bool path_is_under(const struct path *, const struct path *);
2959
2960extern char *file_path(struct file *, char *, int);
2961
2962#include <linux/err.h>
2963
2964
2965extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
2966
2967extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
2968
2969extern int inode_init_always(struct super_block *, struct inode *);
2970extern void inode_init_once(struct inode *);
2971extern void address_space_init_once(struct address_space *mapping);
2972extern struct inode * igrab(struct inode *);
2973extern ino_t iunique(struct super_block *, ino_t);
2974extern int inode_needs_sync(struct inode *inode);
2975extern int generic_delete_inode(struct inode *inode);
2976static inline int generic_drop_inode(struct inode *inode)
2977{
2978 return !inode->i_nlink || inode_unhashed(inode);
2979}
2980
2981extern struct inode *ilookup5_nowait(struct super_block *sb,
2982 unsigned long hashval, int (*test)(struct inode *, void *),
2983 void *data);
2984extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
2985 int (*test)(struct inode *, void *), void *data);
2986extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
2987
2988extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
2989 int (*test)(struct inode *, void *),
2990 int (*set)(struct inode *, void *),
2991 void *data);
2992extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
2993extern struct inode * iget_locked(struct super_block *, unsigned long);
2994extern struct inode *find_inode_nowait(struct super_block *,
2995 unsigned long,
2996 int (*match)(struct inode *,
2997 unsigned long, void *),
2998 void *data);
2999extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
3000extern int insert_inode_locked(struct inode *);
3001#ifdef CONFIG_DEBUG_LOCK_ALLOC
3002extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
3003#else
3004static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
3005#endif
3006extern void unlock_new_inode(struct inode *);
3007extern void discard_new_inode(struct inode *);
3008extern unsigned int get_next_ino(void);
3009extern void evict_inodes(struct super_block *sb);
3010
3011extern void __iget(struct inode * inode);
3012extern void iget_failed(struct inode *);
3013extern void clear_inode(struct inode *);
3014extern void __destroy_inode(struct inode *);
3015extern struct inode *new_inode_pseudo(struct super_block *sb);
3016extern struct inode *new_inode(struct super_block *sb);
3017extern void free_inode_nonrcu(struct inode *inode);
3018extern int should_remove_suid(struct dentry *);
3019extern int file_remove_privs(struct file *);
3020
3021extern void __insert_inode_hash(struct inode *, unsigned long hashval);
3022static inline void insert_inode_hash(struct inode *inode)
3023{
3024 __insert_inode_hash(inode, inode->i_ino);
3025}
3026
3027extern void __remove_inode_hash(struct inode *);
3028static inline void remove_inode_hash(struct inode *inode)
3029{
3030 if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
3031 __remove_inode_hash(inode);
3032}
3033
3034extern void inode_sb_list_add(struct inode *inode);
3035
3036#ifdef CONFIG_BLOCK
3037extern int bdev_read_only(struct block_device *);
3038#endif
3039extern int set_blocksize(struct block_device *, int);
3040extern int sb_set_blocksize(struct super_block *, int);
3041extern int sb_min_blocksize(struct super_block *, int);
3042
3043extern int generic_file_mmap(struct file *, struct vm_area_struct *);
3044extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
3045extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
3046extern int generic_remap_checks(struct file *file_in, loff_t pos_in,
3047 struct file *file_out, loff_t pos_out,
3048 loff_t *count, unsigned int remap_flags);
3049extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
3050extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
3051extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
3052extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
3053extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
3054
3055ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
3056 rwf_t flags);
3057ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
3058 rwf_t flags);
3059
3060
3061extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to);
3062extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from);
3063extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
3064 int datasync);
3065extern void block_sync_page(struct page *page);
3066
3067
3068extern ssize_t generic_file_splice_read(struct file *, loff_t *,
3069 struct pipe_inode_info *, size_t, unsigned int);
3070extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
3071 struct file *, loff_t *, size_t, unsigned int);
3072extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
3073 struct file *out, loff_t *, size_t len, unsigned int flags);
3074extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
3075 loff_t *opos, size_t len, unsigned int flags);
3076
3077
3078extern void
3079file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
3080extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
3081extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
3082extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
3083extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
3084extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
3085 int whence, loff_t maxsize, loff_t eof);
3086extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
3087 int whence, loff_t size);
3088extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
3089extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
3090extern int generic_file_open(struct inode * inode, struct file * filp);
3091extern int nonseekable_open(struct inode * inode, struct file * filp);
3092extern int stream_open(struct inode * inode, struct file * filp);
3093
3094#ifdef CONFIG_BLOCK
3095typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
3096 loff_t file_offset);
3097
3098enum {
3099
3100 DIO_LOCKING = 0x01,
3101
3102
3103 DIO_SKIP_HOLES = 0x02,
3104};
3105
3106void dio_end_io(struct bio *bio);
3107void dio_warn_stale_pagecache(struct file *filp);
3108
3109ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
3110 struct block_device *bdev, struct iov_iter *iter,
3111 get_block_t get_block,
3112 dio_iodone_t end_io, dio_submit_t submit_io,
3113 int flags);
3114
3115static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
3116 struct inode *inode,
3117 struct iov_iter *iter,
3118 get_block_t get_block)
3119{
3120 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
3121 get_block, NULL, NULL, DIO_LOCKING | DIO_SKIP_HOLES);
3122}
3123#endif
3124
3125void inode_dio_wait(struct inode *inode);
3126
3127
3128
3129
3130
3131
3132
3133
3134static inline void inode_dio_begin(struct inode *inode)
3135{
3136 atomic_inc(&inode->i_dio_count);
3137}
3138
3139
3140
3141
3142
3143
3144
3145
3146static inline void inode_dio_end(struct inode *inode)
3147{
3148 if (atomic_dec_and_test(&inode->i_dio_count))
3149 wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
3150}
3151
3152extern void inode_set_flags(struct inode *inode, unsigned int flags,
3153 unsigned int mask);
3154
3155extern const struct file_operations generic_ro_fops;
3156
3157#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
3158
3159extern int readlink_copy(char __user *, int, const char *);
3160extern int page_readlink(struct dentry *, char __user *, int);
3161extern const char *page_get_link(struct dentry *, struct inode *,
3162 struct delayed_call *);
3163extern void page_put_link(void *);
3164extern int __page_symlink(struct inode *inode, const char *symname, int len,
3165 int nofs);
3166extern int page_symlink(struct inode *inode, const char *symname, int len);
3167extern const struct inode_operations page_symlink_inode_operations;
3168extern void kfree_link(void *);
3169extern void generic_fillattr(struct inode *, struct kstat *);
3170extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
3171extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
3172void __inode_add_bytes(struct inode *inode, loff_t bytes);
3173void inode_add_bytes(struct inode *inode, loff_t bytes);
3174void __inode_sub_bytes(struct inode *inode, loff_t bytes);
3175void inode_sub_bytes(struct inode *inode, loff_t bytes);
3176static inline loff_t __inode_get_bytes(struct inode *inode)
3177{
3178 return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
3179}
3180loff_t inode_get_bytes(struct inode *inode);
3181void inode_set_bytes(struct inode *inode, loff_t bytes);
3182const char *simple_get_link(struct dentry *, struct inode *,
3183 struct delayed_call *);
3184extern const struct inode_operations simple_symlink_inode_operations;
3185
3186extern int iterate_dir(struct file *, struct dir_context *);
3187
3188extern int vfs_statx(int, const char __user *, int, struct kstat *, u32);
3189extern int vfs_statx_fd(unsigned int, struct kstat *, u32, unsigned int);
3190
3191static inline int vfs_stat(const char __user *filename, struct kstat *stat)
3192{
3193 return vfs_statx(AT_FDCWD, filename, AT_NO_AUTOMOUNT,
3194 stat, STATX_BASIC_STATS);
3195}
3196static inline int vfs_lstat(const char __user *name, struct kstat *stat)
3197{
3198 return vfs_statx(AT_FDCWD, name, AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT,
3199 stat, STATX_BASIC_STATS);
3200}
3201static inline int vfs_fstatat(int dfd, const char __user *filename,
3202 struct kstat *stat, int flags)
3203{
3204 return vfs_statx(dfd, filename, flags | AT_NO_AUTOMOUNT,
3205 stat, STATX_BASIC_STATS);
3206}
3207static inline int vfs_fstat(int fd, struct kstat *stat)
3208{
3209 return vfs_statx_fd(fd, stat, STATX_BASIC_STATS, 0);
3210}
3211
3212
3213extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
3214extern int vfs_readlink(struct dentry *, char __user *, int);
3215
3216extern int __generic_block_fiemap(struct inode *inode,
3217 struct fiemap_extent_info *fieinfo,
3218 loff_t start, loff_t len,
3219 get_block_t *get_block);
3220extern int generic_block_fiemap(struct inode *inode,
3221 struct fiemap_extent_info *fieinfo, u64 start,
3222 u64 len, get_block_t *get_block);
3223
3224extern struct file_system_type *get_filesystem(struct file_system_type *fs);
3225extern void put_filesystem(struct file_system_type *fs);
3226extern struct file_system_type *get_fs_type(const char *name);
3227extern struct super_block *get_super(struct block_device *);
3228extern struct super_block *get_super_thawed(struct block_device *);
3229extern struct super_block *get_super_exclusive_thawed(struct block_device *bdev);
3230extern struct super_block *get_active_super(struct block_device *bdev);
3231extern void drop_super(struct super_block *sb);
3232extern void drop_super_exclusive(struct super_block *sb);
3233extern void iterate_supers(void (*)(struct super_block *, void *), void *);
3234extern void iterate_supers_type(struct file_system_type *,
3235 void (*)(struct super_block *, void *), void *);
3236
3237extern int dcache_dir_open(struct inode *, struct file *);
3238extern int dcache_dir_close(struct inode *, struct file *);
3239extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
3240extern int dcache_readdir(struct file *, struct dir_context *);
3241extern int simple_setattr(struct dentry *, struct iattr *);
3242extern int simple_getattr(const struct path *, struct kstat *, u32, unsigned int);
3243extern int simple_statfs(struct dentry *, struct kstatfs *);
3244extern int simple_open(struct inode *inode, struct file *file);
3245extern int simple_link(struct dentry *, struct inode *, struct dentry *);
3246extern int simple_unlink(struct inode *, struct dentry *);
3247extern int simple_rmdir(struct inode *, struct dentry *);
3248extern int simple_rename(struct inode *, struct dentry *,
3249 struct inode *, struct dentry *, unsigned int);
3250extern int noop_fsync(struct file *, loff_t, loff_t, int);
3251extern int noop_set_page_dirty(struct page *page);
3252extern void noop_invalidatepage(struct page *page, unsigned int offset,
3253 unsigned int length);
3254extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
3255extern int simple_empty(struct dentry *);
3256extern int simple_readpage(struct file *file, struct page *page);
3257extern int simple_write_begin(struct file *file, struct address_space *mapping,
3258 loff_t pos, unsigned len, unsigned flags,
3259 struct page **pagep, void **fsdata);
3260extern int simple_write_end(struct file *file, struct address_space *mapping,
3261 loff_t pos, unsigned len, unsigned copied,
3262 struct page *page, void *fsdata);
3263extern int always_delete_dentry(const struct dentry *);
3264extern struct inode *alloc_anon_inode(struct super_block *);
3265extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
3266extern const struct dentry_operations simple_dentry_operations;
3267
3268extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
3269extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
3270extern const struct file_operations simple_dir_operations;
3271extern const struct inode_operations simple_dir_inode_operations;
3272extern void make_empty_dir_inode(struct inode *inode);
3273extern bool is_empty_dir_inode(struct inode *inode);
3274struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
3275struct dentry *d_alloc_name(struct dentry *, const char *);
3276extern int simple_fill_super(struct super_block *, unsigned long,
3277 const struct tree_descr *);
3278extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
3279extern void simple_release_fs(struct vfsmount **mount, int *count);
3280
3281extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
3282 loff_t *ppos, const void *from, size_t available);
3283extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3284 const void __user *from, size_t count);
3285
3286extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
3287extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
3288
3289extern int generic_check_addressable(unsigned, u64);
3290
3291#ifdef CONFIG_MIGRATION
3292extern int buffer_migrate_page(struct address_space *,
3293 struct page *, struct page *,
3294 enum migrate_mode);
3295extern int buffer_migrate_page_norefs(struct address_space *,
3296 struct page *, struct page *,
3297 enum migrate_mode);
3298#else
3299#define buffer_migrate_page NULL
3300#define buffer_migrate_page_norefs NULL
3301#endif
3302
3303extern int setattr_prepare(struct dentry *, struct iattr *);
3304extern int inode_newsize_ok(const struct inode *, loff_t offset);
3305extern void setattr_copy(struct inode *inode, const struct iattr *attr);
3306
3307extern int file_update_time(struct file *file);
3308
3309static inline bool io_is_direct(struct file *filp)
3310{
3311 return (filp->f_flags & O_DIRECT) || IS_DAX(filp->f_mapping->host);
3312}
3313
3314static inline bool vma_is_dax(struct vm_area_struct *vma)
3315{
3316 return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
3317}
3318
3319static inline bool vma_is_fsdax(struct vm_area_struct *vma)
3320{
3321 struct inode *inode;
3322
3323 if (!vma->vm_file)
3324 return false;
3325 if (!vma_is_dax(vma))
3326 return false;
3327 inode = file_inode(vma->vm_file);
3328 if (S_ISCHR(inode->i_mode))
3329 return false;
3330 return true;
3331}
3332
3333static inline int iocb_flags(struct file *file)
3334{
3335 int res = 0;
3336 if (file->f_flags & O_APPEND)
3337 res |= IOCB_APPEND;
3338 if (io_is_direct(file))
3339 res |= IOCB_DIRECT;
3340 if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))
3341 res |= IOCB_DSYNC;
3342 if (file->f_flags & __O_SYNC)
3343 res |= IOCB_SYNC;
3344 return res;
3345}
3346
3347static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
3348{
3349 if (unlikely(flags & ~RWF_SUPPORTED))
3350 return -EOPNOTSUPP;
3351
3352 if (flags & RWF_NOWAIT) {
3353 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT))
3354 return -EOPNOTSUPP;
3355 ki->ki_flags |= IOCB_NOWAIT;
3356 }
3357 if (flags & RWF_HIPRI)
3358 ki->ki_flags |= IOCB_HIPRI;
3359 if (flags & RWF_DSYNC)
3360 ki->ki_flags |= IOCB_DSYNC;
3361 if (flags & RWF_SYNC)
3362 ki->ki_flags |= (IOCB_DSYNC | IOCB_SYNC);
3363 if (flags & RWF_APPEND)
3364 ki->ki_flags |= IOCB_APPEND;
3365 return 0;
3366}
3367
3368static inline ino_t parent_ino(struct dentry *dentry)
3369{
3370 ino_t res;
3371
3372
3373
3374
3375
3376 spin_lock(&dentry->d_lock);
3377 res = dentry->d_parent->d_inode->i_ino;
3378 spin_unlock(&dentry->d_lock);
3379 return res;
3380}
3381
3382
3383
3384
3385
3386
3387
3388struct simple_transaction_argresp {
3389 ssize_t size;
3390 char data[0];
3391};
3392
3393#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
3394
3395char *simple_transaction_get(struct file *file, const char __user *buf,
3396 size_t size);
3397ssize_t simple_transaction_read(struct file *file, char __user *buf,
3398 size_t size, loff_t *pos);
3399int simple_transaction_release(struct inode *inode, struct file *file);
3400
3401void simple_transaction_set(struct file *file, size_t n);
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
3420static int __fops ## _open(struct inode *inode, struct file *file) \
3421{ \
3422 __simple_attr_check_format(__fmt, 0ull); \
3423 return simple_attr_open(inode, file, __get, __set, __fmt); \
3424} \
3425static const struct file_operations __fops = { \
3426 .owner = THIS_MODULE, \
3427 .open = __fops ## _open, \
3428 .release = simple_attr_release, \
3429 .read = simple_attr_read, \
3430 .write = simple_attr_write, \
3431 .llseek = generic_file_llseek, \
3432}
3433
3434static inline __printf(1, 2)
3435void __simple_attr_check_format(const char *fmt, ...)
3436{
3437
3438}
3439
3440int simple_attr_open(struct inode *inode, struct file *file,
3441 int (*get)(void *, u64 *), int (*set)(void *, u64),
3442 const char *fmt);
3443int simple_attr_release(struct inode *inode, struct file *file);
3444ssize_t simple_attr_read(struct file *file, char __user *buf,
3445 size_t len, loff_t *ppos);
3446ssize_t simple_attr_write(struct file *file, const char __user *buf,
3447 size_t len, loff_t *ppos);
3448
3449struct ctl_table;
3450int proc_nr_files(struct ctl_table *table, int write,
3451 void __user *buffer, size_t *lenp, loff_t *ppos);
3452int proc_nr_dentry(struct ctl_table *table, int write,
3453 void __user *buffer, size_t *lenp, loff_t *ppos);
3454int proc_nr_inodes(struct ctl_table *table, int write,
3455 void __user *buffer, size_t *lenp, loff_t *ppos);
3456int __init get_filesystem_list(char *buf);
3457
3458#define __FMODE_EXEC ((__force int) FMODE_EXEC)
3459#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
3460
3461#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
3462#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
3463 (flag & __FMODE_NONOTIFY)))
3464
3465static inline bool is_sxid(umode_t mode)
3466{
3467 return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
3468}
3469
3470static inline int check_sticky(struct inode *dir, struct inode *inode)
3471{
3472 if (!(dir->i_mode & S_ISVTX))
3473 return 0;
3474
3475 return __check_sticky(dir, inode);
3476}
3477
3478static inline void inode_has_no_xattr(struct inode *inode)
3479{
3480 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC))
3481 inode->i_flags |= S_NOSEC;
3482}
3483
3484static inline bool is_root_inode(struct inode *inode)
3485{
3486 return inode == inode->i_sb->s_root->d_inode;
3487}
3488
3489static inline bool dir_emit(struct dir_context *ctx,
3490 const char *name, int namelen,
3491 u64 ino, unsigned type)
3492{
3493 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
3494}
3495static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
3496{
3497 return ctx->actor(ctx, ".", 1, ctx->pos,
3498 file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
3499}
3500static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
3501{
3502 return ctx->actor(ctx, "..", 2, ctx->pos,
3503 parent_ino(file->f_path.dentry), DT_DIR) == 0;
3504}
3505static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
3506{
3507 if (ctx->pos == 0) {
3508 if (!dir_emit_dot(file, ctx))
3509 return false;
3510 ctx->pos = 1;
3511 }
3512 if (ctx->pos == 1) {
3513 if (!dir_emit_dotdot(file, ctx))
3514 return false;
3515 ctx->pos = 2;
3516 }
3517 return true;
3518}
3519static inline bool dir_relax(struct inode *inode)
3520{
3521 inode_unlock(inode);
3522 inode_lock(inode);
3523 return !IS_DEADDIR(inode);
3524}
3525
3526static inline bool dir_relax_shared(struct inode *inode)
3527{
3528 inode_unlock_shared(inode);
3529 inode_lock_shared(inode);
3530 return !IS_DEADDIR(inode);
3531}
3532
3533extern bool path_noexec(const struct path *path);
3534extern void inode_nohighmem(struct inode *inode);
3535
3536
3537extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
3538 int advice);
3539
3540#if defined(CONFIG_IO_URING)
3541extern struct sock *io_uring_get_socket(struct file *file);
3542#else
3543static inline struct sock *io_uring_get_socket(struct file *file)
3544{
3545 return NULL;
3546}
3547#endif
3548
3549#endif
3550