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