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