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