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