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