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