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