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