]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - include/linux/fs.h
block: remove per-queue plugging
[mirror_ubuntu-zesty-kernel.git] / include / linux / fs.h
CommitLineData
1da177e4
LT
1#ifndef _LINUX_FS_H
2#define _LINUX_FS_H
3
4/*
5 * This file has definitions for some important file table
6 * structures etc.
7 */
8
1da177e4
LT
9#include <linux/limits.h>
10#include <linux/ioctl.h>
7cc01581 11#include <linux/blk_types.h>
b31d42a5 12#include <linux/types.h>
1da177e4
LT
13
14/*
15 * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
16 * the file limit at runtime and only root can increase the per-process
17 * nr_file rlimit, so it's safe to set up a ridiculously high absolute
18 * upper limit on files-per-process.
19 *
20 * Some programs (notably those using select()) may have to be
21 * recompiled to take full advantage of the new limits..
22 */
23
24/* Fixed constants first: */
25#undef NR_OPEN
1da177e4
LT
26#define INR_OPEN 1024 /* Initial setting for nfile rlimits */
27
28#define BLOCK_SIZE_BITS 10
29#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
30
01bf466e
DH
31#define SEEK_SET 0 /* seek relative to beginning of file */
32#define SEEK_CUR 1 /* seek relative to current file position */
33#define SEEK_END 2 /* seek relative to end of file */
1ae7075b 34#define SEEK_MAX SEEK_END
01bf466e 35
367a51a3 36struct fstrim_range {
3a3a1af3
LM
37 __u64 start;
38 __u64 len;
39 __u64 minlen;
367a51a3
LC
40};
41
1da177e4
LT
42/* And dynamically-tunable limits and defaults: */
43struct files_stat_struct {
518de9b3
ED
44 unsigned long nr_files; /* read only */
45 unsigned long nr_free_files; /* read only */
46 unsigned long max_files; /* tunable */
1da177e4 47};
1da177e4
LT
48
49struct inodes_stat_t {
50 int nr_inodes;
51 int nr_unused;
9e7bf24b 52 int dummy[5]; /* padding for sysctl ABI compatibility */
1da177e4 53};
1da177e4 54
1da177e4
LT
55
56#define NR_FILE 8192 /* this can well be larger on a larger system */
57
58#define MAY_EXEC 1
59#define MAY_WRITE 2
60#define MAY_READ 4
61#define MAY_APPEND 8
e6305c43 62#define MAY_ACCESS 16
a110343f 63#define MAY_OPEN 32
9cfcac81 64#define MAY_CHDIR 64
1da177e4 65
55ec8217
PT
66/*
67 * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
68 * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
69 */
70
fc9161e5 71/* file is open for reading */
19adf9c5 72#define FMODE_READ ((__force fmode_t)0x1)
fc9161e5 73/* file is open for writing */
19adf9c5 74#define FMODE_WRITE ((__force fmode_t)0x2)
fc9161e5 75/* file is seekable */
19adf9c5 76#define FMODE_LSEEK ((__force fmode_t)0x4)
55ec8217 77/* file can be accessed using pread */
19adf9c5 78#define FMODE_PREAD ((__force fmode_t)0x8)
55ec8217 79/* file can be accessed using pwrite */
19adf9c5 80#define FMODE_PWRITE ((__force fmode_t)0x10)
fc9161e5 81/* File is opened for execution with sys_execve / sys_uselib */
19adf9c5 82#define FMODE_EXEC ((__force fmode_t)0x20)
fc9161e5 83/* File is opened with O_NDELAY (only set for block devices) */
19adf9c5 84#define FMODE_NDELAY ((__force fmode_t)0x40)
fc9161e5 85/* File is opened with O_EXCL (only set for block devices) */
19adf9c5 86#define FMODE_EXCL ((__force fmode_t)0x80)
fc9161e5
CH
87/* File is opened using open(.., 3, ..) and is writeable only for ioctls
88 (specialy hack for floppy.c) */
19adf9c5 89#define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
b500531e 90
4d4be482
CH
91/*
92 * Don't update ctime and mtime.
93 *
94 * Currently a special hack for the XFS open_by_handle ioctl, but we'll
95 * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
96 */
19adf9c5 97#define FMODE_NOCMTIME ((__force fmode_t)0x800)
4d4be482 98
0141450f 99/* Expect random access pattern */
19adf9c5 100#define FMODE_RANDOM ((__force fmode_t)0x1000)
0141450f 101
4a3956c7
KH
102/* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
103#define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
104
ecf081d1 105/* File was opened by fanotify and shouldn't generate fanotify events */
13bcbc00 106#define FMODE_NONOTIFY ((__force fmode_t)0x1000000)
ecf081d1 107
48e70bc1
JA
108/*
109 * The below are the various read and write types that we support. Some of
110 * them include behavioral modifiers that send information down to the
111 * block layer and IO scheduler. Terminology:
112 *
113 * The block layer uses device plugging to defer IO a little bit, in
114 * the hope that we will see more IO very shortly. This increases
115 * coalescing of adjacent IO and thus reduces the number of IOs we
116 * have to send to the device. It also allows for better queuing,
117 * if the IO isn't mergeable. If the caller is going to be waiting
118 * for the IO, then he must ensure that the device is unplugged so
119 * that the IO is dispatched to the driver.
120 *
121 * All IO is handled async in Linux. This is fine for background
122 * writes, but for reads or writes that someone waits for completion
123 * on, we want to notify the block layer and IO scheduler so that they
124 * know about it. That allows them to make better scheduling
125 * decisions. So when the below references 'sync' and 'async', it
126 * is referencing this priority hint.
127 *
128 * With that in mind, the available types are:
129 *
130 * READ A normal read operation. Device will be plugged.
131 * READ_SYNC A synchronous read. Device is not plugged, caller can
132 * immediately wait on this read without caring about
133 * unplugging.
134 * READA Used for read-ahead operations. Lower priority, and the
7cc01581 135 * block layer could (in theory) choose to ignore this
48e70bc1
JA
136 * request if it runs into resource problems.
137 * WRITE A normal async write. Device will be plugged.
48e70bc1
JA
138 * WRITE_SYNC_PLUG Synchronous write. Identical to WRITE, but passes down
139 * the hint that someone will be waiting on this IO
140 * shortly. The device must still be unplugged explicitly,
141 * WRITE_SYNC_PLUG does not do this as we could be
142 * submitting more writes before we actually wait on any
143 * of them.
144 * WRITE_SYNC Like WRITE_SYNC_PLUG, but also unplugs the device
145 * immediately after submission. The write equivalent
146 * of READ_SYNC.
d9449ce3 147 * WRITE_ODIRECT_PLUG Special case write for O_DIRECT only.
4fed947c
TH
148 * WRITE_FLUSH Like WRITE_SYNC but with preceding cache flush.
149 * WRITE_FUA Like WRITE_SYNC but data is guaranteed to be on
150 * non-volatile media on completion.
151 * WRITE_FLUSH_FUA Combination of WRITE_FLUSH and FUA. The IO is preceded
152 * by a cache flush and data is guaranteed to be on
153 * non-volatile media on completion.
48e70bc1
JA
154 *
155 */
7cc01581
TH
156#define RW_MASK REQ_WRITE
157#define RWA_MASK REQ_RAHEAD
7b6d91da
CH
158
159#define READ 0
7cc01581
TH
160#define WRITE RW_MASK
161#define READA RWA_MASK
7b6d91da
CH
162
163#define READ_SYNC (READ | REQ_SYNC | REQ_UNPLUG)
164#define READ_META (READ | REQ_META)
165#define WRITE_SYNC_PLUG (WRITE | REQ_SYNC | REQ_NOIDLE)
166#define WRITE_SYNC (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG)
167#define WRITE_ODIRECT_PLUG (WRITE | REQ_SYNC)
168#define WRITE_META (WRITE | REQ_META)
4fed947c
TH
169#define WRITE_FLUSH (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
170 REQ_FLUSH)
171#define WRITE_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
172 REQ_FUA)
173#define WRITE_FLUSH_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_UNPLUG | \
174 REQ_FLUSH | REQ_FUA)
1da177e4
LT
175
176#define SEL_IN 1
177#define SEL_OUT 2
178#define SEL_EX 4
179
180/* public flags for file_system_type */
181#define FS_REQUIRES_DEV 1
182#define FS_BINARY_MOUNTDATA 2
79c0b2df 183#define FS_HAS_SUBTYPE 4
1da177e4 184#define FS_REVAL_DOT 16384 /* Check the paths ".", ".." for staleness */
349457cc
MF
185#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move()
186 * during rename() internally.
187 */
188
1da177e4
LT
189/*
190 * These are the fs-independent mount-flags: up to 32 flags are supported
191 */
192#define MS_RDONLY 1 /* Mount read-only */
193#define MS_NOSUID 2 /* Ignore suid and sgid bits */
194#define MS_NODEV 4 /* Disallow access to device special files */
195#define MS_NOEXEC 8 /* Disallow program execution */
196#define MS_SYNCHRONOUS 16 /* Writes are synced at once */
197#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
198#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
199#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
200#define MS_NOATIME 1024 /* Do not update access times. */
201#define MS_NODIRATIME 2048 /* Do not update directory access times */
202#define MS_BIND 4096
203#define MS_MOVE 8192
204#define MS_REC 16384
9b04c997
TT
205#define MS_VERBOSE 32768 /* War is peace. Verbosity is silence.
206 MS_VERBOSE is deprecated. */
207#define MS_SILENT 32768
bf066c7d 208#define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
9676f0c6 209#define MS_UNBINDABLE (1<<17) /* change to unbindable */
07b20889 210#define MS_PRIVATE (1<<18) /* change to private */
a58b0eb8 211#define MS_SLAVE (1<<19) /* change to slave */
03e06e68 212#define MS_SHARED (1<<20) /* change to shared */
47ae32d6 213#define MS_RELATIME (1<<21) /* Update atime relative to mtime/ctime. */
8bf9725c 214#define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */
7a224228 215#define MS_I_VERSION (1<<23) /* Update inode I_version field */
d0adde57 216#define MS_STRICTATIME (1<<24) /* Always perform atime updates */
7a4dec53 217#define MS_BORN (1<<29)
1da177e4
LT
218#define MS_ACTIVE (1<<30)
219#define MS_NOUSER (1<<31)
220
221/*
222 * Superblock flags that can be altered by MS_REMOUNT
223 */
08b9fe6b 224#define MS_RMT_MASK (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
1da177e4
LT
225
226/*
227 * Old magic mount flag and mask
228 */
229#define MS_MGC_VAL 0xC0ED0000
230#define MS_MGC_MSK 0xffff0000
231
232/* Inode flags - they have nothing to superblock flags now */
233
234#define S_SYNC 1 /* Writes are synced at once */
235#define S_NOATIME 2 /* Do not update access times */
236#define S_APPEND 4 /* Append-only file */
237#define S_IMMUTABLE 8 /* Immutable file */
238#define S_DEAD 16 /* removed, but still open directory */
239#define S_NOQUOTA 32 /* Inode is not counted to quota */
240#define S_DIRSYNC 64 /* Directory modifications are synchronous */
241#define S_NOCMTIME 128 /* Do not update file c/mtime */
242#define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */
243#define S_PRIVATE 512 /* Inode is fs-internal */
196f5181 244#define S_IMA 1024 /* Inode has an associated IMA struct */
9875cf80 245#define S_AUTOMOUNT 2048 /* Automount/referral quasi-directory */
1da177e4
LT
246
247/*
248 * Note that nosuid etc flags are inode-specific: setting some file-system
249 * flags just means all the inodes inherit those flags by default. It might be
250 * possible to override it selectively if you really wanted to with some
251 * ioctl() that is not currently implemented.
252 *
253 * Exception: MS_RDONLY is always applied to the entire file system.
254 *
255 * Unfortunately, it is possible to change a filesystems flags with it mounted
256 * with files in use. This means that all of the inodes will not have their
257 * i_flags updated. Hence, i_flags no longer inherit the superblock mount
258 * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
259 */
260#define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
261
262#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
263#define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || \
264 ((inode)->i_flags & S_SYNC))
265#define IS_DIRSYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
266 ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
267#define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK)
37756ced 268#define IS_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
7a224228 269#define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION)
1da177e4
LT
270
271#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
272#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
273#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
1da177e4
LT
274#define IS_POSIXACL(inode) __IS_FLG(inode, MS_POSIXACL)
275
276#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
277#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
278#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
279#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
196f5181 280#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
9875cf80 281#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
1da177e4
LT
282
283/* the read-only stuff doesn't really belong here, but any other place is
284 probably as bad and I don't want to create yet another include file. */
285
286#define BLKROSET _IO(0x12,93) /* set device read-only (0 = read-write) */
287#define BLKROGET _IO(0x12,94) /* get read-only status (0 = read_write) */
288#define BLKRRPART _IO(0x12,95) /* re-read partition table */
289#define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */
290#define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */
291#define BLKRASET _IO(0x12,98) /* set read ahead for block device */
292#define BLKRAGET _IO(0x12,99) /* get current read ahead setting */
293#define BLKFRASET _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
294#define BLKFRAGET _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
295#define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
296#define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
297#define BLKSSZGET _IO(0x12,104)/* get block device sector size */
298#if 0
299#define BLKPG _IO(0x12,105)/* See blkpg.h */
300
301/* Some people are morons. Do not use sizeof! */
302
303#define BLKELVGET _IOR(0x12,106,size_t)/* elevator get */
304#define BLKELVSET _IOW(0x12,107,size_t)/* elevator set */
305/* This was here just to show that the number is taken -
306 probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
307#endif
308/* A jump here: 108-111 have been used for various private purposes. */
309#define BLKBSZGET _IOR(0x12,112,size_t)
310#define BLKBSZSET _IOW(0x12,113,size_t)
311#define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size in bytes (u64 *arg) */
2056a782
JA
312#define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
313#define BLKTRACESTART _IO(0x12,116)
314#define BLKTRACESTOP _IO(0x12,117)
315#define BLKTRACETEARDOWN _IO(0x12,118)
d30a2605 316#define BLKDISCARD _IO(0x12,119)
ac481c20
MP
317#define BLKIOMIN _IO(0x12,120)
318#define BLKIOOPT _IO(0x12,121)
319#define BLKALIGNOFF _IO(0x12,122)
320#define BLKPBSZGET _IO(0x12,123)
98262f27 321#define BLKDISCARDZEROES _IO(0x12,124)
8d57a98c 322#define BLKSECDISCARD _IO(0x12,125)
1da177e4
LT
323
324#define BMAP_IOCTL 1 /* obsolete - kept for compatibility */
325#define FIBMAP _IO(0x00,1) /* bmap access */
326#define FIGETBSZ _IO(0x00,2) /* get the block size used for bmap */
fcccf502
TS
327#define FIFREEZE _IOWR('X', 119, int) /* Freeze */
328#define FITHAW _IOWR('X', 120, int) /* Thaw */
367a51a3 329#define FITRIM _IOWR('X', 121, struct fstrim_range) /* Trim */
1da177e4 330
36695673
DH
331#define FS_IOC_GETFLAGS _IOR('f', 1, long)
332#define FS_IOC_SETFLAGS _IOW('f', 2, long)
333#define FS_IOC_GETVERSION _IOR('v', 1, long)
334#define FS_IOC_SETVERSION _IOW('v', 2, long)
c4b929b8 335#define FS_IOC_FIEMAP _IOWR('f', 11, struct fiemap)
36695673
DH
336#define FS_IOC32_GETFLAGS _IOR('f', 1, int)
337#define FS_IOC32_SETFLAGS _IOW('f', 2, int)
338#define FS_IOC32_GETVERSION _IOR('v', 1, int)
339#define FS_IOC32_SETVERSION _IOW('v', 2, int)
340
341/*
342 * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
343 */
344#define FS_SECRM_FL 0x00000001 /* Secure deletion */
345#define FS_UNRM_FL 0x00000002 /* Undelete */
346#define FS_COMPR_FL 0x00000004 /* Compress file */
347#define FS_SYNC_FL 0x00000008 /* Synchronous updates */
348#define FS_IMMUTABLE_FL 0x00000010 /* Immutable file */
349#define FS_APPEND_FL 0x00000020 /* writes to file may only append */
350#define FS_NODUMP_FL 0x00000040 /* do not dump file */
351#define FS_NOATIME_FL 0x00000080 /* do not update atime */
352/* Reserved for compression usage... */
353#define FS_DIRTY_FL 0x00000100
354#define FS_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
355#define FS_NOCOMP_FL 0x00000400 /* Don't compress */
356#define FS_ECOMPR_FL 0x00000800 /* Compression error */
357/* End compression flags --- maybe not all used */
358#define FS_BTREE_FL 0x00001000 /* btree format dir */
359#define FS_INDEX_FL 0x00001000 /* hash-indexed directory */
360#define FS_IMAGIC_FL 0x00002000 /* AFS directory */
361#define FS_JOURNAL_DATA_FL 0x00004000 /* Reserved for ext3 */
362#define FS_NOTAIL_FL 0x00008000 /* file tail should not be merged */
363#define FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
364#define FS_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
128e5eba
SW
365#define FS_EXTENT_FL 0x00080000 /* Extents */
366#define FS_DIRECTIO_FL 0x00100000 /* Use direct i/o */
36695673
DH
367#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
368
369#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */
370#define FS_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */
371
372
e46e4903
AM
373#define SYNC_FILE_RANGE_WAIT_BEFORE 1
374#define SYNC_FILE_RANGE_WRITE 2
375#define SYNC_FILE_RANGE_WAIT_AFTER 4
376
1da177e4
LT
377#ifdef __KERNEL__
378
379#include <linux/linkage.h>
380#include <linux/wait.h>
381#include <linux/types.h>
382#include <linux/kdev_t.h>
383#include <linux/dcache.h>
3f8206d4 384#include <linux/path.h>
1da177e4
LT
385#include <linux/stat.h>
386#include <linux/cache.h>
1da177e4
LT
387#include <linux/list.h>
388#include <linux/radix-tree.h>
389#include <linux/prio_tree.h>
390#include <linux/init.h>
914e2637 391#include <linux/pid.h>
1b1dcc1b 392#include <linux/mutex.h>
3bd858ab 393#include <linux/capability.h>
6188e10d 394#include <linux/semaphore.h>
c4b929b8 395#include <linux/fiemap.h>
ceb5bdc2 396#include <linux/rculist_bl.h>
1da177e4
LT
397
398#include <asm/atomic.h>
1da177e4
LT
399#include <asm/byteorder.h>
400
a5694255 401struct export_operations;
a885c8c4 402struct hd_geometry;
1da177e4
LT
403struct iovec;
404struct nameidata;
92198f7e 405struct kiocb;
57cc7215 406struct kobject;
1da177e4
LT
407struct pipe_inode_info;
408struct poll_table_struct;
409struct kstatfs;
410struct vm_area_struct;
411struct vfsmount;
745ca247 412struct cred;
1da177e4 413
74bf17cf 414extern void __init inode_init(void);
1da177e4 415extern void __init inode_init_early(void);
1da177e4
LT
416extern void __init files_init(unsigned long);
417
dded4f4d 418extern struct files_stat_struct files_stat;
518de9b3 419extern unsigned long get_max_files(void);
dded4f4d
JE
420extern int sysctl_nr_open;
421extern struct inodes_stat_t inodes_stat;
422extern int leases_enable, lease_break_time;
dded4f4d 423
1da177e4
LT
424struct buffer_head;
425typedef int (get_block_t)(struct inode *inode, sector_t iblock,
426 struct buffer_head *bh_result, int create);
92198f7e 427typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
40e2e973
CH
428 ssize_t bytes, void *private, int ret,
429 bool is_async);
1da177e4
LT
430
431/*
432 * Attribute flags. These should be or-ed together to figure out what
433 * has been changed!
434 */
9767d749
MS
435#define ATTR_MODE (1 << 0)
436#define ATTR_UID (1 << 1)
437#define ATTR_GID (1 << 2)
438#define ATTR_SIZE (1 << 3)
439#define ATTR_ATIME (1 << 4)
440#define ATTR_MTIME (1 << 5)
441#define ATTR_CTIME (1 << 6)
442#define ATTR_ATIME_SET (1 << 7)
443#define ATTR_MTIME_SET (1 << 8)
444#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
445#define ATTR_ATTR_FLAG (1 << 10)
446#define ATTR_KILL_SUID (1 << 11)
447#define ATTR_KILL_SGID (1 << 12)
448#define ATTR_FILE (1 << 13)
449#define ATTR_KILL_PRIV (1 << 14)
450#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
451#define ATTR_TIMES_SET (1 << 16)
1da177e4
LT
452
453/*
454 * This is the Inode Attributes structure, used for notify_change(). It
455 * uses the above definitions as flags, to know which values have changed.
456 * Also, in this manner, a Filesystem can look at only the values it cares
457 * about. Basically, these are the attributes that the VFS layer can
458 * request to change from the FS layer.
459 *
460 * Derek Atkins <warlord@MIT.EDU> 94-10-20
461 */
462struct iattr {
463 unsigned int ia_valid;
464 umode_t ia_mode;
465 uid_t ia_uid;
466 gid_t ia_gid;
467 loff_t ia_size;
468 struct timespec ia_atime;
469 struct timespec ia_mtime;
470 struct timespec ia_ctime;
cc4e69de
MS
471
472 /*
473 * Not an attribute, but an auxilary info for filesystems wanting to
474 * implement an ftruncate() like method. NOTE: filesystem should
475 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
476 */
477 struct file *ia_file;
1da177e4
LT
478};
479
1da177e4
LT
480/*
481 * Includes for diskquotas.
482 */
483#include <linux/quota.h>
484
994fc28c
ZB
485/**
486 * enum positive_aop_returns - aop return codes with specific semantics
487 *
488 * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
489 * completed, that the page is still locked, and
490 * should be considered active. The VM uses this hint
491 * to return the page to the active list -- it won't
492 * be a candidate for writeback again in the near
493 * future. Other callers must be careful to unlock
494 * the page if they get this return. Returned by
495 * writepage();
496 *
497 * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
498 * unlocked it and the page might have been truncated.
499 * The caller should back up to acquiring a new page and
500 * trying again. The aop will be taking reasonable
501 * precautions not to livelock. If the caller held a page
502 * reference, it should drop it before retrying. Returned
55144768 503 * by readpage().
994fc28c
ZB
504 *
505 * address_space_operation functions return these large constants to indicate
506 * special semantics to the caller. These are much larger than the bytes in a
507 * page to allow for functions that return the number of bytes operated on in a
508 * given page.
509 */
510
511enum positive_aop_returns {
512 AOP_WRITEPAGE_ACTIVATE = 0x80000,
513 AOP_TRUNCATED_PAGE = 0x80001,
514};
515
afddba49 516#define AOP_FLAG_UNINTERRUPTIBLE 0x0001 /* will not do a short write */
89e10787 517#define AOP_FLAG_CONT_EXPAND 0x0002 /* called from cont_expand */
54566b2c
NP
518#define AOP_FLAG_NOFS 0x0004 /* used by filesystem to direct
519 * helper code (eg buffer layer)
520 * to clear GFP_FS from alloc */
afddba49 521
1da177e4
LT
522/*
523 * oh the beauties of C type declarations.
524 */
525struct page;
526struct address_space;
527struct writeback_control;
1da177e4 528
2f718ffc
NP
529struct iov_iter {
530 const struct iovec *iov;
531 unsigned long nr_segs;
532 size_t iov_offset;
533 size_t count;
534};
535
536size_t iov_iter_copy_from_user_atomic(struct page *page,
537 struct iov_iter *i, unsigned long offset, size_t bytes);
538size_t iov_iter_copy_from_user(struct page *page,
539 struct iov_iter *i, unsigned long offset, size_t bytes);
540void iov_iter_advance(struct iov_iter *i, size_t bytes);
afddba49 541int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
2f718ffc
NP
542size_t iov_iter_single_seg_count(struct iov_iter *i);
543
544static inline void iov_iter_init(struct iov_iter *i,
545 const struct iovec *iov, unsigned long nr_segs,
546 size_t count, size_t written)
547{
548 i->iov = iov;
549 i->nr_segs = nr_segs;
550 i->iov_offset = 0;
551 i->count = count + written;
552
553 iov_iter_advance(i, written);
554}
555
556static inline size_t iov_iter_count(struct iov_iter *i)
557{
558 return i->count;
559}
560
8ab22b9a
HH
561/*
562 * "descriptor" for what we're up to with a read.
563 * This allows us to use the same read code yet
564 * have multiple different users of the data that
565 * we read from a file.
566 *
567 * The simplest case just copies the data to user
568 * mode.
569 */
570typedef struct {
571 size_t written;
572 size_t count;
573 union {
574 char __user *buf;
575 void *data;
576 } arg;
577 int error;
578} read_descriptor_t;
579
580typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
581 unsigned long, unsigned long);
2f718ffc 582
1da177e4
LT
583struct address_space_operations {
584 int (*writepage)(struct page *page, struct writeback_control *wbc);
585 int (*readpage)(struct file *, struct page *);
1da177e4
LT
586
587 /* Write back some dirty pages from this mapping. */
588 int (*writepages)(struct address_space *, struct writeback_control *);
589
4741c9fd 590 /* Set a page dirty. Return true if this dirtied it */
1da177e4
LT
591 int (*set_page_dirty)(struct page *page);
592
593 int (*readpages)(struct file *filp, struct address_space *mapping,
594 struct list_head *pages, unsigned nr_pages);
595
afddba49
NP
596 int (*write_begin)(struct file *, struct address_space *mapping,
597 loff_t pos, unsigned len, unsigned flags,
598 struct page **pagep, void **fsdata);
599 int (*write_end)(struct file *, struct address_space *mapping,
600 loff_t pos, unsigned len, unsigned copied,
601 struct page *page, void *fsdata);
602
1da177e4
LT
603 /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
604 sector_t (*bmap)(struct address_space *, sector_t);
2ff28e22 605 void (*invalidatepage) (struct page *, unsigned long);
27496a8c 606 int (*releasepage) (struct page *, gfp_t);
6072d13c 607 void (*freepage)(struct page *);
1da177e4
LT
608 ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
609 loff_t offset, unsigned long nr_segs);
70688e4d
NP
610 int (*get_xip_mem)(struct address_space *, pgoff_t, int,
611 void **, unsigned long *);
e965f963 612 /* migrate the contents of a page to the specified target */
2d1db3b1
CL
613 int (*migratepage) (struct address_space *,
614 struct page *, struct page *);
e3db7691 615 int (*launder_page) (struct page *);
8ab22b9a
HH
616 int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
617 unsigned long);
25718736 618 int (*error_remove_page)(struct address_space *, struct page *);
1da177e4
LT
619};
620
afddba49
NP
621/*
622 * pagecache_write_begin/pagecache_write_end must be used by general code
623 * to write into the pagecache.
624 */
625int pagecache_write_begin(struct file *, struct address_space *mapping,
626 loff_t pos, unsigned len, unsigned flags,
627 struct page **pagep, void **fsdata);
628
629int pagecache_write_end(struct file *, struct address_space *mapping,
630 loff_t pos, unsigned len, unsigned copied,
631 struct page *page, void *fsdata);
632
1da177e4
LT
633struct backing_dev_info;
634struct address_space {
635 struct inode *host; /* owner: inode, block_device */
636 struct radix_tree_root page_tree; /* radix tree of all pages */
19fd6231 637 spinlock_t tree_lock; /* and lock protecting it */
1da177e4
LT
638 unsigned int i_mmap_writable;/* count VM_SHARED mappings */
639 struct prio_tree_root i_mmap; /* tree of private and shared mappings */
640 struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
641 spinlock_t i_mmap_lock; /* protect tree, count, list */
642 unsigned int truncate_count; /* Cover race condition with truncate */
643 unsigned long nrpages; /* number of total pages */
644 pgoff_t writeback_index;/* writeback starts here */
f5e54d6e 645 const struct address_space_operations *a_ops; /* methods */
1da177e4
LT
646 unsigned long flags; /* error bits/gfp mask */
647 struct backing_dev_info *backing_dev_info; /* device readahead, etc */
648 spinlock_t private_lock; /* for use by the address_space */
649 struct list_head private_list; /* ditto */
650 struct address_space *assoc_mapping; /* ditto */
651} __attribute__((aligned(sizeof(long))));
652 /*
653 * On most architectures that alignment is already the case; but
654 * must be enforced here for CRIS, to let the least signficant bit
655 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
656 */
657
658struct block_device {
659 dev_t bd_dev; /* not a kdev_t - it's a search key */
660 struct inode * bd_inode; /* will die */
87d8fe1e 661 struct super_block * bd_super;
1da177e4 662 int bd_openers;
c039e313 663 struct mutex bd_mutex; /* open/close mutex */
1da177e4 664 struct list_head bd_inodes;
6b4517a7 665 void * bd_claiming;
1da177e4
LT
666 void * bd_holder;
667 int bd_holders;
77ea887e 668 bool bd_write_holder;
641dc636 669#ifdef CONFIG_SYSFS
49731baa 670 struct list_head bd_holder_disks;
641dc636 671#endif
1da177e4
LT
672 struct block_device * bd_contains;
673 unsigned bd_block_size;
674 struct hd_struct * bd_part;
675 /* number of times partitions within this device have been opened. */
676 unsigned bd_part_count;
677 int bd_invalidated;
678 struct gendisk * bd_disk;
679 struct list_head bd_list;
1da177e4
LT
680 /*
681 * Private data. You must have bd_claim'ed the block_device
682 * to use this. NOTE: bd_claim allows an owner to claim
683 * the same device multiple times, the owner must take special
684 * care to not mess up bd_private for that case.
685 */
686 unsigned long bd_private;
fcccf502
TS
687
688 /* The counter of freeze processes */
689 int bd_fsfreeze_count;
690 /* Mutex for freeze */
691 struct mutex bd_fsfreeze_mutex;
1da177e4
LT
692};
693
694/*
695 * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
696 * radix trees
697 */
698#define PAGECACHE_TAG_DIRTY 0
699#define PAGECACHE_TAG_WRITEBACK 1
f446daae 700#define PAGECACHE_TAG_TOWRITE 2
1da177e4
LT
701
702int mapping_tagged(struct address_space *mapping, int tag);
703
704/*
705 * Might pages of this file be mapped into userspace?
706 */
707static inline int mapping_mapped(struct address_space *mapping)
708{
709 return !prio_tree_empty(&mapping->i_mmap) ||
710 !list_empty(&mapping->i_mmap_nonlinear);
711}
712
713/*
714 * Might pages of this file have been modified in userspace?
715 * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
716 * marks vma as VM_SHARED if it is shared, and the file was opened for
717 * writing i.e. vma may be mprotected writable even if now readonly.
718 */
719static inline int mapping_writably_mapped(struct address_space *mapping)
720{
721 return mapping->i_mmap_writable != 0;
722}
723
724/*
725 * Use sequence counter to get consistent i_size on 32-bit processors.
726 */
727#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
728#include <linux/seqlock.h>
729#define __NEED_I_SIZE_ORDERED
730#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
731#else
732#define i_size_ordered_init(inode) do { } while (0)
733#endif
734
f19d4a8f
AV
735struct posix_acl;
736#define ACL_NOT_CACHED ((void *)(-1))
737
1da177e4 738struct inode {
44a7d7a8
NP
739 /* RCU path lookup touches following: */
740 umode_t i_mode;
741 uid_t i_uid;
742 gid_t i_gid;
743 const struct inode_operations *i_op;
744 struct super_block *i_sb;
745
746 spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
747 unsigned int i_flags;
748 struct mutex i_mutex;
749
750 unsigned long i_state;
751 unsigned long dirtied_when; /* jiffies of first dirtying */
752
1da177e4 753 struct hlist_node i_hash;
7ccf19a8
NP
754 struct list_head i_wb_list; /* backing dev IO list */
755 struct list_head i_lru; /* inode LRU list */
1da177e4 756 struct list_head i_sb_list;
fa0d7e3d
NP
757 union {
758 struct list_head i_dentry;
759 struct rcu_head i_rcu;
760 };
1da177e4
LT
761 unsigned long i_ino;
762 atomic_t i_count;
1da177e4 763 unsigned int i_nlink;
1da177e4 764 dev_t i_rdev;
4e70af56 765 unsigned int i_blkbits;
7a224228 766 u64 i_version;
1da177e4 767 loff_t i_size;
83b7b44e
ED
768#ifdef __NEED_I_SIZE_ORDERED
769 seqcount_t i_size_seqcount;
770#endif
1da177e4
LT
771 struct timespec i_atime;
772 struct timespec i_mtime;
773 struct timespec i_ctime;
a0f62ac6 774 blkcnt_t i_blocks;
1da177e4 775 unsigned short i_bytes;
1da177e4 776 struct rw_semaphore i_alloc_sem;
99ac48f5 777 const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
1da177e4
LT
778 struct file_lock *i_flock;
779 struct address_space *i_mapping;
780 struct address_space i_data;
781#ifdef CONFIG_QUOTA
782 struct dquot *i_dquot[MAXQUOTAS];
783#endif
1da177e4 784 struct list_head i_devices;
4c154168
TT
785 union {
786 struct pipe_inode_info *i_pipe;
eaf796e7 787 struct block_device *i_bdev;
577c4eb0 788 struct cdev *i_cdev;
4c154168 789 };
1da177e4
LT
790
791 __u32 i_generation;
792
3be25f49
EP
793#ifdef CONFIG_FSNOTIFY
794 __u32 i_fsnotify_mask; /* all events this inode cares about */
e61ce867 795 struct hlist_head i_fsnotify_marks;
0eeca283
RL
796#endif
797
a178d202
EP
798#ifdef CONFIG_IMA
799 /* protected by i_lock */
800 unsigned int i_readcount; /* struct files open RO */
801#endif
1da177e4 802 atomic_t i_writecount;
50462062 803#ifdef CONFIG_SECURITY
1da177e4 804 void *i_security;
f19d4a8f
AV
805#endif
806#ifdef CONFIG_FS_POSIX_ACL
807 struct posix_acl *i_acl;
808 struct posix_acl *i_default_acl;
50462062 809#endif
8e18e294 810 void *i_private; /* fs or device private pointer */
1da177e4
LT
811};
812
1d3382cb
AV
813static inline int inode_unhashed(struct inode *inode)
814{
815 return hlist_unhashed(&inode->i_hash);
816}
817
f2eace23
IM
818/*
819 * inode->i_mutex nesting subclasses for the lock validator:
820 *
821 * 0: the object of the current VFS operation
822 * 1: parent
823 * 2: child/target
824 * 3: quota file
825 *
826 * The locking order between these classes is
4df46240 827 * parent -> child -> normal -> xattr -> quota
f2eace23
IM
828 */
829enum inode_i_mutex_lock_class
830{
831 I_MUTEX_NORMAL,
832 I_MUTEX_PARENT,
833 I_MUTEX_CHILD,
4df46240 834 I_MUTEX_XATTR,
f2eace23
IM
835 I_MUTEX_QUOTA
836};
837
1da177e4
LT
838/*
839 * NOTE: in a 32bit arch with a preemptable kernel and
840 * an UP compile the i_size_read/write must be atomic
841 * with respect to the local cpu (unlike with preempt disabled),
842 * but they don't need to be atomic with respect to other cpus like in
843 * true SMP (so they need either to either locally disable irq around
844 * the read or for example on x86 they can be still implemented as a
845 * cmpxchg8b without the need of the lock prefix). For SMP compiles
846 * and 64bit archs it makes no difference if preempt is enabled or not.
847 */
48ed214d 848static inline loff_t i_size_read(const struct inode *inode)
1da177e4
LT
849{
850#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
851 loff_t i_size;
852 unsigned int seq;
853
854 do {
855 seq = read_seqcount_begin(&inode->i_size_seqcount);
856 i_size = inode->i_size;
857 } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
858 return i_size;
859#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
860 loff_t i_size;
861
862 preempt_disable();
863 i_size = inode->i_size;
864 preempt_enable();
865 return i_size;
866#else
867 return inode->i_size;
868#endif
869}
870
7762f5a0
MS
871/*
872 * NOTE: unlike i_size_read(), i_size_write() does need locking around it
873 * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
874 * can be lost, resulting in subsequent i_size_read() calls spinning forever.
875 */
1da177e4
LT
876static inline void i_size_write(struct inode *inode, loff_t i_size)
877{
878#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
879 write_seqcount_begin(&inode->i_size_seqcount);
880 inode->i_size = i_size;
881 write_seqcount_end(&inode->i_size_seqcount);
882#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
883 preempt_disable();
884 inode->i_size = i_size;
885 preempt_enable();
886#else
887 inode->i_size = i_size;
888#endif
889}
890
48ed214d 891static inline unsigned iminor(const struct inode *inode)
1da177e4
LT
892{
893 return MINOR(inode->i_rdev);
894}
895
48ed214d 896static inline unsigned imajor(const struct inode *inode)
1da177e4
LT
897{
898 return MAJOR(inode->i_rdev);
899}
900
901extern struct block_device *I_BDEV(struct inode *inode);
902
903struct fown_struct {
904 rwlock_t lock; /* protects pid, uid, euid fields */
609d7fa9
EB
905 struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
906 enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
1da177e4 907 uid_t uid, euid; /* uid/euid of process setting the owner */
1da177e4
LT
908 int signum; /* posix.1b rt signal to be delivered on IO */
909};
910
911/*
912 * Track a single file's readahead state
913 */
914struct file_ra_state {
937085aa
FW
915 pgoff_t start; /* where readahead started */
916 unsigned int size; /* # of readahead pages */
917 unsigned int async_size; /* do asynchronous readahead when
f9acc8c7 918 there are only # of pages ahead */
5ce1110b 919
937085aa 920 unsigned int ra_pages; /* Maximum readahead window */
1ebf26a9 921 unsigned int mmap_miss; /* Cache miss stat for mmap accesses */
f4e6b498 922 loff_t prev_pos; /* Cache last read() position */
1da177e4 923};
1da177e4 924
5ce1110b
FW
925/*
926 * Check if @index falls in the readahead windows.
927 */
928static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
929{
f9acc8c7
FW
930 return (index >= ra->start &&
931 index < ra->start + ra->size);
5ce1110b
FW
932}
933
ad775f5a
DH
934#define FILE_MNT_WRITE_TAKEN 1
935#define FILE_MNT_WRITE_RELEASED 2
936
1da177e4 937struct file {
2f512016
ED
938 /*
939 * fu_list becomes invalid after file_free is called and queued via
940 * fu_rcuhead for RCU freeing
941 */
942 union {
943 struct list_head fu_list;
944 struct rcu_head fu_rcuhead;
945 } f_u;
0f7fc9e4
JJS
946 struct path f_path;
947#define f_dentry f_path.dentry
948#define f_vfsmnt f_path.mnt
99ac48f5 949 const struct file_operations *f_op;
4a6a4499 950 spinlock_t f_lock; /* f_ep_links, f_flags, no IRQ */
6416ccb7
NP
951#ifdef CONFIG_SMP
952 int f_sb_list_cpu;
953#endif
516e0cc5 954 atomic_long_t f_count;
1da177e4 955 unsigned int f_flags;
aeb5d727 956 fmode_t f_mode;
1da177e4
LT
957 loff_t f_pos;
958 struct fown_struct f_owner;
d76b0d9b 959 const struct cred *f_cred;
1da177e4
LT
960 struct file_ra_state f_ra;
961
2b47c361 962 u64 f_version;
50462062 963#ifdef CONFIG_SECURITY
1da177e4 964 void *f_security;
50462062 965#endif
1da177e4
LT
966 /* needed for tty driver, and maybe others */
967 void *private_data;
968
969#ifdef CONFIG_EPOLL
970 /* Used by fs/eventpoll.c to link all the hooks to this file */
971 struct list_head f_ep_links;
1da177e4
LT
972#endif /* #ifdef CONFIG_EPOLL */
973 struct address_space *f_mapping;
ad775f5a
DH
974#ifdef CONFIG_DEBUG_WRITECOUNT
975 unsigned long f_mnt_write_state;
976#endif
1da177e4 977};
1da177e4 978
516e0cc5 979#define get_file(x) atomic_long_inc(&(x)->f_count)
d7065da0 980#define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1)
516e0cc5 981#define file_count(x) atomic_long_read(&(x)->f_count)
1da177e4 982
ad775f5a
DH
983#ifdef CONFIG_DEBUG_WRITECOUNT
984static inline void file_take_write(struct file *f)
985{
986 WARN_ON(f->f_mnt_write_state != 0);
987 f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
988}
989static inline void file_release_write(struct file *f)
990{
991 f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
992}
993static inline void file_reset_write(struct file *f)
994{
995 f->f_mnt_write_state = 0;
996}
997static inline void file_check_state(struct file *f)
998{
999 /*
1000 * At this point, either both or neither of these bits
1001 * should be set.
1002 */
1003 WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
1004 WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
1005}
1006static inline int file_check_writeable(struct file *f)
1007{
1008 if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
1009 return 0;
1010 printk(KERN_WARNING "writeable file with no "
1011 "mnt_want_write()\n");
1012 WARN_ON(1);
1013 return -EINVAL;
1014}
1015#else /* !CONFIG_DEBUG_WRITECOUNT */
1016static inline void file_take_write(struct file *filp) {}
1017static inline void file_release_write(struct file *filp) {}
1018static inline void file_reset_write(struct file *filp) {}
1019static inline void file_check_state(struct file *filp) {}
1020static inline int file_check_writeable(struct file *filp)
1021{
1022 return 0;
1023}
1024#endif /* CONFIG_DEBUG_WRITECOUNT */
1025
1da177e4
LT
1026#define MAX_NON_LFS ((1UL<<31) - 1)
1027
1028/* Page cache limit. The filesystems should put that into their s_maxbytes
1029 limits, otherwise bad things can happen in VM. */
1030#if BITS_PER_LONG==32
1031#define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
1032#elif BITS_PER_LONG==64
1033#define MAX_LFS_FILESIZE 0x7fffffffffffffffUL
1034#endif
1035
1036#define FL_POSIX 1
1037#define FL_FLOCK 2
1038#define FL_ACCESS 8 /* not trying to lock, just looking */
f475ae95 1039#define FL_EXISTS 16 /* when unlocking, test for existence */
1da177e4 1040#define FL_LEASE 32 /* lease held on this file */
75e1fcc0 1041#define FL_CLOSE 64 /* unlock on close */
1da177e4
LT
1042#define FL_SLEEP 128 /* A blocking lock */
1043
bde74e4b
MS
1044/*
1045 * Special return value from posix_lock_file() and vfs_lock_file() for
1046 * asynchronous locking.
1047 */
1048#define FILE_LOCK_DEFERRED 1
1049
1da177e4
LT
1050/*
1051 * The POSIX file lock owner is determined by
1052 * the "struct files_struct" in the thread group
1053 * (or NULL for no owner - BSD locks).
1054 *
1055 * Lockd stuffs a "host" pointer into this.
1056 */
1057typedef struct files_struct *fl_owner_t;
1058
1059struct file_lock_operations {
1da177e4
LT
1060 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
1061 void (*fl_release_private)(struct file_lock *);
1062};
1063
1064struct lock_manager_operations {
1065 int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
1066 void (*fl_notify)(struct file_lock *); /* unblock callback */
2beb6614 1067 int (*fl_grant)(struct file_lock *, struct file_lock *, int);
1da177e4
LT
1068 void (*fl_release_private)(struct file_lock *);
1069 void (*fl_break)(struct file_lock *);
1da177e4
LT
1070 int (*fl_change)(struct file_lock **, int);
1071};
1072
af558e33
BF
1073struct lock_manager {
1074 struct list_head list;
1075};
1076
1077void locks_start_grace(struct lock_manager *);
1078void locks_end_grace(struct lock_manager *);
1079int locks_in_grace(void);
1080
1da177e4
LT
1081/* that will die - we need it for nfs_lock_info */
1082#include <linux/nfs_fs_i.h>
1083
1084struct file_lock {
1085 struct file_lock *fl_next; /* singly linked list for this inode */
1086 struct list_head fl_link; /* doubly linked list of all locks */
1087 struct list_head fl_block; /* circular list of blocked processes */
1088 fl_owner_t fl_owner;
afc1246f
RK
1089 unsigned char fl_flags;
1090 unsigned char fl_type;
1da177e4 1091 unsigned int fl_pid;
ab1f1611 1092 struct pid *fl_nspid;
1da177e4
LT
1093 wait_queue_head_t fl_wait;
1094 struct file *fl_file;
1da177e4
LT
1095 loff_t fl_start;
1096 loff_t fl_end;
1097
1098 struct fasync_struct * fl_fasync; /* for lease break notifications */
1099 unsigned long fl_break_time; /* for nonblocking lease breaks */
1100
6aed6285 1101 const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */
7b021967 1102 const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
1da177e4
LT
1103 union {
1104 struct nfs_lock_info nfs_fl;
8d0a8a9d 1105 struct nfs4_lock_info nfs4_fl;
e8d6c554
DH
1106 struct {
1107 struct list_head link; /* link in AFS vnode's pending_locks list */
1108 int state; /* state of grant or error if -ve */
1109 } afs;
1da177e4
LT
1110 } fl_u;
1111};
1112
1113/* The following constant reflects the upper bound of the file/locking space */
1114#ifndef OFFSET_MAX
1115#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
1116#define OFFSET_MAX INT_LIMIT(loff_t)
1117#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
1118#endif
1119
1da177e4
LT
1120#include <linux/fcntl.h>
1121
bfcd17a6
TP
1122extern void send_sigio(struct fown_struct *fown, int fd, int band);
1123
bfcd17a6 1124#ifdef CONFIG_FILE_LOCKING
1da177e4 1125extern int fcntl_getlk(struct file *, struct flock __user *);
c293621b
PS
1126extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1127 struct flock __user *);
1da177e4
LT
1128
1129#if BITS_PER_LONG == 32
1130extern int fcntl_getlk64(struct file *, struct flock64 __user *);
c293621b
PS
1131extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1132 struct flock64 __user *);
1da177e4
LT
1133#endif
1134
1da177e4
LT
1135extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1136extern int fcntl_getlease(struct file *filp);
1137
1138/* fs/locks.c */
05fa3135 1139void locks_free_lock(struct file_lock *fl);
1da177e4 1140extern void locks_init_lock(struct file_lock *);
c5b1f0d9 1141extern struct file_lock * locks_alloc_lock(void);
1da177e4 1142extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1a747ee0 1143extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
1da177e4
LT
1144extern void locks_remove_posix(struct file *, fl_owner_t);
1145extern void locks_remove_flock(struct file *);
a9e61e25 1146extern void locks_release_private(struct file_lock *);
6d34ac19 1147extern void posix_test_lock(struct file *, struct file_lock *);
150b3934 1148extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1da177e4 1149extern int posix_lock_file_wait(struct file *, struct file_lock *);
64a318ee 1150extern int posix_unblock_lock(struct file *, struct file_lock *);
3ee17abd 1151extern int vfs_test_lock(struct file *, struct file_lock *);
150b3934 1152extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
9b9d2ab4 1153extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1da177e4
LT
1154extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
1155extern int __break_lease(struct inode *inode, unsigned int flags);
1156extern void lease_get_mtime(struct inode *, struct timespec *time);
0af1a450 1157extern int generic_setlease(struct file *, long, struct file_lock **);
a9933cea 1158extern int vfs_setlease(struct file *, long, struct file_lock **);
1da177e4
LT
1159extern int lease_modify(struct file_lock **, int);
1160extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
1161extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
b89f4321
AB
1162extern void lock_flocks(void);
1163extern void unlock_flocks(void);
bfcd17a6 1164#else /* !CONFIG_FILE_LOCKING */
c2aca5e5
SW
1165static inline int fcntl_getlk(struct file *file, struct flock __user *user)
1166{
1167 return -EINVAL;
1168}
1169
1170static inline int fcntl_setlk(unsigned int fd, struct file *file,
1171 unsigned int cmd, struct flock __user *user)
1172{
1173 return -EACCES;
1174}
1175
bfcd17a6 1176#if BITS_PER_LONG == 32
c2aca5e5
SW
1177static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
1178{
1179 return -EINVAL;
1180}
1181
1182static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1183 unsigned int cmd, struct flock64 __user *user)
1184{
1185 return -EACCES;
1186}
bfcd17a6 1187#endif
c2aca5e5
SW
1188static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1189{
1190 return 0;
1191}
1192
1193static inline int fcntl_getlease(struct file *filp)
1194{
1195 return 0;
1196}
1197
1198static inline void locks_init_lock(struct file_lock *fl)
1199{
1200 return;
1201}
1202
1203static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1204{
1205 return;
1206}
1207
1208static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1209{
1210 return;
1211}
1212
1213static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1214{
1215 return;
1216}
1217
1218static inline void locks_remove_flock(struct file *filp)
1219{
1220 return;
1221}
1222
1223static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1224{
1225 return;
1226}
1227
1228static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1229 struct file_lock *conflock)
1230{
1231 return -ENOLCK;
1232}
1233
1234static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
1235{
1236 return -ENOLCK;
1237}
1238
1239static inline int posix_unblock_lock(struct file *filp,
1240 struct file_lock *waiter)
1241{
1242 return -ENOENT;
1243}
1244
1245static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1246{
1247 return 0;
1248}
1249
1250static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
1251 struct file_lock *fl, struct file_lock *conf)
1252{
1253 return -ENOLCK;
1254}
1255
1256static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1257{
1258 return 0;
1259}
1260
1261static inline int flock_lock_file_wait(struct file *filp,
1262 struct file_lock *request)
1263{
1264 return -ENOLCK;
1265}
1266
1267static inline int __break_lease(struct inode *inode, unsigned int mode)
1268{
1269 return 0;
1270}
1271
1272static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
1273{
1274 return;
1275}
1276
1277static inline int generic_setlease(struct file *filp, long arg,
1278 struct file_lock **flp)
1279{
1280 return -EINVAL;
1281}
1282
1283static inline int vfs_setlease(struct file *filp, long arg,
1284 struct file_lock **lease)
1285{
1286 return -EINVAL;
1287}
1288
1289static inline int lease_modify(struct file_lock **before, int arg)
1290{
1291 return -EINVAL;
1292}
1293
1294static inline int lock_may_read(struct inode *inode, loff_t start,
1295 unsigned long len)
1296{
1297 return 1;
1298}
1299
1300static inline int lock_may_write(struct inode *inode, loff_t start,
1301 unsigned long len)
1302{
1303 return 1;
1304}
1305
b89f4321
AB
1306static inline void lock_flocks(void)
1307{
1308}
1309
1310static inline void unlock_flocks(void)
1311{
1312}
1313
bfcd17a6
TP
1314#endif /* !CONFIG_FILE_LOCKING */
1315
1da177e4
LT
1316
1317struct fasync_struct {
989a2979
ED
1318 spinlock_t fa_lock;
1319 int magic;
1320 int fa_fd;
1321 struct fasync_struct *fa_next; /* singly linked list */
1322 struct file *fa_file;
1323 struct rcu_head fa_rcu;
1da177e4
LT
1324};
1325
1326#define FASYNC_MAGIC 0x4601
1327
1328/* SMP safe fasync helpers: */
1329extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
f7347ce4
LT
1330extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1331extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1332extern struct fasync_struct *fasync_alloc(void);
1333extern void fasync_free(struct fasync_struct *);
1334
1da177e4
LT
1335/* can be called from interrupts */
1336extern void kill_fasync(struct fasync_struct **, int, int);
1da177e4 1337
609d7fa9 1338extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1da177e4
LT
1339extern int f_setown(struct file *filp, unsigned long arg, int force);
1340extern void f_delown(struct file *filp);
609d7fa9 1341extern pid_t f_getown(struct file *filp);
1da177e4
LT
1342extern int send_sigurg(struct fown_struct *fown);
1343
1344/*
1345 * Umount options
1346 */
1347
1348#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
1349#define MNT_DETACH 0x00000002 /* Just detach from the tree */
1350#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
db1f05bb
MS
1351#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
1352#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
1da177e4
LT
1353
1354extern struct list_head super_blocks;
1355extern spinlock_t sb_lock;
1356
1da177e4
LT
1357struct super_block {
1358 struct list_head s_list; /* Keep this first */
1359 dev_t s_dev; /* search index; _not_ kdev_t */
1da177e4 1360 unsigned char s_dirt;
270ba5f7
RK
1361 unsigned char s_blocksize_bits;
1362 unsigned long s_blocksize;
42cb56ae 1363 loff_t s_maxbytes; /* Max file size */
1da177e4 1364 struct file_system_type *s_type;
ee9b6d61 1365 const struct super_operations *s_op;
61e225dc 1366 const struct dquot_operations *dq_op;
0d54b217 1367 const struct quotactl_ops *s_qcop;
39655164 1368 const struct export_operations *s_export_op;
1da177e4
LT
1369 unsigned long s_flags;
1370 unsigned long s_magic;
1371 struct dentry *s_root;
1372 struct rw_semaphore s_umount;
7892f2f4 1373 struct mutex s_lock;
1da177e4 1374 int s_count;
1da177e4 1375 atomic_t s_active;
50462062 1376#ifdef CONFIG_SECURITY
1da177e4 1377 void *s_security;
50462062 1378#endif
bb435453 1379 const struct xattr_handler **s_xattr;
1da177e4
LT
1380
1381 struct list_head s_inodes; /* all inodes */
ceb5bdc2 1382 struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */
6416ccb7
NP
1383#ifdef CONFIG_SMP
1384 struct list_head __percpu *s_files;
1385#else
1da177e4 1386 struct list_head s_files;
6416ccb7 1387#endif
b5c84bf6 1388 /* s_dentry_lru, s_nr_dentry_unused protected by dcache.c lru locks */
da3bbdd4
KM
1389 struct list_head s_dentry_lru; /* unused dentry lru */
1390 int s_nr_dentry_unused; /* # of dentry on lru */
1da177e4
LT
1391
1392 struct block_device *s_bdev;
32a88aa1 1393 struct backing_dev_info *s_bdi;
acaebfd8 1394 struct mtd_info *s_mtd;
1da177e4
LT
1395 struct list_head s_instances;
1396 struct quota_info s_dquot; /* Diskquota specific options */
1397
1398 int s_frozen;
1399 wait_queue_head_t s_wait_unfrozen;
1400
1401 char s_id[32]; /* Informational name */
1402
1403 void *s_fs_info; /* Filesystem private info */
30c40d2c 1404 fmode_t s_mode;
1da177e4 1405
270ba5f7
RK
1406 /* Granularity of c/m/atime in ns.
1407 Cannot be worse than a second */
1408 u32 s_time_gran;
1409
1da177e4
LT
1410 /*
1411 * The next field is for VFS *only*. No filesystems have any business
1412 * even looking at it. You had been warned.
1413 */
a11f3a05 1414 struct mutex s_vfs_rename_mutex; /* Kludge */
1da177e4 1415
79c0b2df
MS
1416 /*
1417 * Filesystem subtype. If non-empty the filesystem type field
1418 * in /proc/mounts will be "type.subtype"
1419 */
1420 char *s_subtype;
b3b304a2
MS
1421
1422 /*
1423 * Saved mount options for lazy filesystems using
1424 * generic_show_options()
1425 */
4d2deb40 1426 char __rcu *s_options;
c8aebb0c 1427 const struct dentry_operations *s_d_op; /* default d_op for dentries */
1da177e4
LT
1428};
1429
1430extern struct timespec current_fs_time(struct super_block *sb);
1431
1432/*
1433 * Snapshotting support.
1434 */
1435enum {
1436 SB_UNFROZEN = 0,
1437 SB_FREEZE_WRITE = 1,
1438 SB_FREEZE_TRANS = 2,
1439};
1440
1441#define vfs_check_frozen(sb, level) \
1442 wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
1443
914e2637
AV
1444#define get_fs_excl() atomic_inc(&current->fs_excl)
1445#define put_fs_excl() atomic_dec(&current->fs_excl)
1446#define has_fs_excl() atomic_read(&current->fs_excl)
22e2c507 1447
3bd858ab 1448#define is_owner_or_cap(inode) \
da9592ed 1449 ((current_fsuid() == (inode)->i_uid) || capable(CAP_FOWNER))
3bd858ab 1450
914e2637
AV
1451/* not quite ready to be deprecated, but... */
1452extern void lock_super(struct super_block *);
1453extern void unlock_super(struct super_block *);
1da177e4
LT
1454
1455/*
1456 * VFS helper functions..
1457 */
1458extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
1459extern int vfs_mkdir(struct inode *, struct dentry *, int);
1460extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
db2e747b 1461extern int vfs_symlink(struct inode *, struct dentry *, const char *);
1da177e4
LT
1462extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
1463extern int vfs_rmdir(struct inode *, struct dentry *);
1464extern int vfs_unlink(struct inode *, struct dentry *);
1465extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
1466
1467/*
1468 * VFS dentry helper functions.
1469 */
1470extern void dentry_unhash(struct dentry *dentry);
1471
8c744fb8
CH
1472/*
1473 * VFS file helper functions.
1474 */
1475extern int file_permission(struct file *, int);
a1bd120d
DM
1476extern void inode_init_owner(struct inode *inode, const struct inode *dir,
1477 mode_t mode);
c4b929b8
MF
1478/*
1479 * VFS FS_IOC_FIEMAP helper definitions.
1480 */
1481struct fiemap_extent_info {
1482 unsigned int fi_flags; /* Flags as passed from user */
1483 unsigned int fi_extents_mapped; /* Number of mapped extents */
1484 unsigned int fi_extents_max; /* Size of fiemap_extent array */
ecf5632d
NK
1485 struct fiemap_extent __user *fi_extents_start; /* Start of
1486 fiemap_extent array */
c4b929b8
MF
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
1da177e4
LT
1492/*
1493 * File types
1494 *
1495 * NOTE! These match bits 12..15 of stat.st_mode
1496 * (ie "(i_mode >> 12) & 15").
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
1da177e4
LT
1508/*
1509 * This is the "filldir" function type, used by readdir() to let
1510 * the kernel specify what kind of dirent layout it wants to have.
1511 * This allows the kernel to read directories into kernel space or
1512 * to have different dirent layouts depending on the binary type.
1513 */
afefdbb2 1514typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
08f85851 1515struct block_device_operations;
1da177e4 1516
1da177e4
LT
1517/* These macros are for out of kernel modules to test that
1518 * the kernel supports the unlocked_ioctl and compat_ioctl
1519 * fields in struct file_operations. */
1520#define HAVE_COMPAT_IOCTL 1
1521#define HAVE_UNLOCKED_IOCTL 1
1522
1523/*
1524 * NOTE:
b19dd42f
AB
1525 * all file operations except setlease can be called without
1526 * the big kernel lock held in all filesystems.
1da177e4
LT
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 *);
1da177e4 1532 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
027445c3
BP
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);
1da177e4
LT
1535 int (*readdir) (struct file *, void *, filldir_t);
1536 unsigned int (*poll) (struct file *, struct poll_table_struct *);
1da177e4
LT
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 *);
75e1fcc0 1541 int (*flush) (struct file *, fl_owner_t id);
1da177e4 1542 int (*release) (struct inode *, struct file *);
7ea80859 1543 int (*fsync) (struct file *, int datasync);
1da177e4
LT
1544 int (*aio_fsync) (struct kiocb *, int datasync);
1545 int (*fasync) (int, struct file *, int);
1546 int (*lock) (struct file *, int, struct file_lock *);
1da177e4
LT
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);
1da177e4 1550 int (*flock) (struct file *, int, struct file_lock *);
cbb7e577
JA
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);
f9ffed26 1553 int (*setlease)(struct file *, long, struct file_lock **);
2fe17c10
CH
1554 long (*fallocate)(struct file *file, int mode, loff_t offset,
1555 loff_t len);
1da177e4
LT
1556};
1557
b74c79e9
NP
1558#define IPERM_FLAG_RCU 0x0001
1559
1da177e4 1560struct inode_operations {
1da177e4 1561 struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
44a7d7a8 1562 void * (*follow_link) (struct dentry *, struct nameidata *);
b74c79e9
NP
1563 int (*permission) (struct inode *, int, unsigned int);
1564 int (*check_acl)(struct inode *, int, unsigned int);
44a7d7a8
NP
1565
1566 int (*readlink) (struct dentry *, char __user *,int);
1567 void (*put_link) (struct dentry *, struct nameidata *, void *);
1568
1569 int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
1da177e4
LT
1570 int (*link) (struct dentry *,struct inode *,struct dentry *);
1571 int (*unlink) (struct inode *,struct dentry *);
1572 int (*symlink) (struct inode *,struct dentry *,const char *);
1573 int (*mkdir) (struct inode *,struct dentry *,int);
1574 int (*rmdir) (struct inode *,struct dentry *);
1575 int (*mknod) (struct inode *,struct dentry *,int,dev_t);
1576 int (*rename) (struct inode *, struct dentry *,
1577 struct inode *, struct dentry *);
1da177e4 1578 void (*truncate) (struct inode *);
1da177e4
LT
1579 int (*setattr) (struct dentry *, struct iattr *);
1580 int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
1581 int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
1582 ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
1583 ssize_t (*listxattr) (struct dentry *, char *, size_t);
1584 int (*removexattr) (struct dentry *, const char *);
f6b3ec23 1585 void (*truncate_range)(struct inode *, loff_t, loff_t);
c4b929b8
MF
1586 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
1587 u64 len);
44a7d7a8 1588} ____cacheline_aligned;
1da177e4
LT
1589
1590struct seq_file;
1591
eed4e51f
BP
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
1da177e4
LT
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
1da177e4
LT
1604struct super_operations {
1605 struct inode *(*alloc_inode)(struct super_block *sb);
1606 void (*destroy_inode)(struct inode *);
1607
1da177e4 1608 void (*dirty_inode) (struct inode *);
a9185b41 1609 int (*write_inode) (struct inode *, struct writeback_control *wbc);
45321ac5 1610 int (*drop_inode) (struct inode *);
be7ce416 1611 void (*evict_inode) (struct inode *);
1da177e4
LT
1612 void (*put_super) (struct super_block *);
1613 void (*write_super) (struct super_block *);
1614 int (*sync_fs)(struct super_block *sb, int wait);
c4be0c1d
TS
1615 int (*freeze_fs) (struct super_block *);
1616 int (*unfreeze_fs) (struct super_block *);
726c3342 1617 int (*statfs) (struct dentry *, struct kstatfs *);
1da177e4 1618 int (*remount_fs) (struct super_block *, int *, char *);
42faad99 1619 void (*umount_begin) (struct super_block *);
1da177e4
LT
1620
1621 int (*show_options)(struct seq_file *, struct vfsmount *);
b4629fe2 1622 int (*show_stats)(struct seq_file *, struct vfsmount *);
0e51a720 1623#ifdef CONFIG_QUOTA
1da177e4
LT
1624 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
1625 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
0e51a720 1626#endif
87d8fe1e 1627 int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
1da177e4
LT
1628};
1629
1c0eeaf5
JE
1630/*
1631 * Inode state bits. Protected by inode_lock.
1632 *
1633 * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
1634 * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
1635 *
1636 * Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
1637 * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
1638 * various stages of removing an inode.
1639 *
eaff8079 1640 * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
1c0eeaf5 1641 *
e7ca2d41
JE
1642 * I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
1643 * fdatasync(). i_atime is the usual cause.
000cb48e
JK
1644 * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
1645 * these changes separately from I_DIRTY_SYNC so that we
1646 * don't have to write inode on fdatasync() when only
1647 * mtime has changed in it.
1c0eeaf5 1648 * I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
eaff8079
CH
1649 * I_NEW Serves as both a mutex and completion notification.
1650 * New inodes set I_NEW. If two processes both create
1651 * the same inode, one of them will release its inode and
1652 * wait for I_NEW to be released before returning.
1653 * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
1654 * also cause waiting on I_NEW, without I_NEW actually
1655 * being set. find_inode() uses this to prevent returning
1656 * nearly-dead inodes.
1c0eeaf5
JE
1657 * I_WILL_FREE Must be set when calling write_inode_now() if i_count
1658 * is zero. I_FREEING must be set when I_WILL_FREE is
1659 * cleared.
1660 * I_FREEING Set when inode is about to be freed but still has dirty
1661 * pages or buffers attached or the inode itself is still
1662 * dirty.
b57922d9 1663 * I_CLEAR Added by end_writeback(). In this state the inode is clean
a4ffdde6 1664 * and can be destroyed. Inode keeps I_FREEING.
1c0eeaf5
JE
1665 *
1666 * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
1667 * prohibited for many purposes. iget() must wait for
1668 * the inode to be completely released, then create it
1669 * anew. Other functions will just ignore such inodes,
eaff8079 1670 * if appropriate. I_NEW is used for waiting.
1c0eeaf5 1671 *
eaff8079
CH
1672 * I_SYNC Synchonized write of dirty inode data. The bits is
1673 * set during data writeback, and cleared with a wakeup
1674 * on the bit address once it is done.
1c0eeaf5 1675 *
1c0eeaf5 1676 * Q: What is the difference between I_WILL_FREE and I_FREEING?
1c0eeaf5 1677 */
9e38d86f
NP
1678#define I_DIRTY_SYNC (1 << 0)
1679#define I_DIRTY_DATASYNC (1 << 1)
1680#define I_DIRTY_PAGES (1 << 2)
eaff8079
CH
1681#define __I_NEW 3
1682#define I_NEW (1 << __I_NEW)
9e38d86f
NP
1683#define I_WILL_FREE (1 << 4)
1684#define I_FREEING (1 << 5)
1685#define I_CLEAR (1 << 6)
eaff8079 1686#define __I_SYNC 7
1c0eeaf5 1687#define I_SYNC (1 << __I_SYNC)
9e38d86f 1688#define I_REFERENCED (1 << 8)
1da177e4
LT
1689
1690#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
1691
1692extern void __mark_inode_dirty(struct inode *, int);
1693static inline void mark_inode_dirty(struct inode *inode)
1694{
1695 __mark_inode_dirty(inode, I_DIRTY);
1696}
1697
1698static inline void mark_inode_dirty_sync(struct inode *inode)
1699{
1700 __mark_inode_dirty(inode, I_DIRTY_SYNC);
1701}
1702
71c42157
DH
1703/**
1704 * inc_nlink - directly increment an inode's link count
1705 * @inode: inode
1706 *
1707 * This is a low-level filesystem helper to replace any
1708 * direct filesystem manipulation of i_nlink. Currently,
1709 * it is only here for parity with dec_nlink().
1710 */
d8c76e6f 1711static inline void inc_nlink(struct inode *inode)
66d21730
AD
1712{
1713 inode->i_nlink++;
d8c76e6f
DH
1714}
1715
1716static inline void inode_inc_link_count(struct inode *inode)
1717{
1718 inc_nlink(inode);
66d21730
AD
1719 mark_inode_dirty(inode);
1720}
1721
71c42157
DH
1722/**
1723 * drop_nlink - directly drop an inode's link count
1724 * @inode: inode
1725 *
1726 * This is a low-level filesystem helper to replace any
1727 * direct filesystem manipulation of i_nlink. In cases
1728 * where we are attempting to track writes to the
1729 * filesystem, a decrement to zero means an imminent
1730 * write when the file is truncated and actually unlinked
1731 * on the filesystem.
1732 */
9a53c3a7 1733static inline void drop_nlink(struct inode *inode)
66d21730
AD
1734{
1735 inode->i_nlink--;
9a53c3a7
DH
1736}
1737
71c42157
DH
1738/**
1739 * clear_nlink - directly zero an inode's link count
1740 * @inode: inode
1741 *
1742 * This is a low-level filesystem helper to replace any
1743 * direct filesystem manipulation of i_nlink. See
1744 * drop_nlink() for why we care about i_nlink hitting zero.
1745 */
ce71ec36
DH
1746static inline void clear_nlink(struct inode *inode)
1747{
1748 inode->i_nlink = 0;
1749}
1750
9a53c3a7
DH
1751static inline void inode_dec_link_count(struct inode *inode)
1752{
1753 drop_nlink(inode);
66d21730
AD
1754 mark_inode_dirty(inode);
1755}
1756
25ec56b5
JNC
1757/**
1758 * inode_inc_iversion - increments i_version
1759 * @inode: inode that need to be updated
1760 *
1761 * Every time the inode is modified, the i_version field will be incremented.
1762 * The filesystem has to be mounted with i_version flag
1763 */
1764
1765static inline void inode_inc_iversion(struct inode *inode)
1766{
1767 spin_lock(&inode->i_lock);
1768 inode->i_version++;
1769 spin_unlock(&inode->i_lock);
1770}
1771
869243a0 1772extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
1da177e4
LT
1773static inline void file_accessed(struct file *file)
1774{
1775 if (!(file->f_flags & O_NOATIME))
0f7fc9e4 1776 touch_atime(file->f_path.mnt, file->f_path.dentry);
1da177e4
LT
1777}
1778
1779int sync_inode(struct inode *inode, struct writeback_control *wbc);
c3765016 1780int sync_inode_metadata(struct inode *inode, int wait);
1da177e4 1781
1da177e4
LT
1782struct file_system_type {
1783 const char *name;
1784 int fs_flags;
454e2398
DH
1785 int (*get_sb) (struct file_system_type *, int,
1786 const char *, void *, struct vfsmount *);
c96e41e9
AV
1787 struct dentry *(*mount) (struct file_system_type *, int,
1788 const char *, void *);
1da177e4
LT
1789 void (*kill_sb) (struct super_block *);
1790 struct module *owner;
1791 struct file_system_type * next;
1792 struct list_head fs_supers;
d475fd42 1793
cf516249 1794 struct lock_class_key s_lock_key;
897c6ff9 1795 struct lock_class_key s_umount_key;
51ee049e 1796 struct lock_class_key s_vfs_rename_key;
d475fd42
PZ
1797
1798 struct lock_class_key i_lock_key;
1799 struct lock_class_key i_mutex_key;
14358e6d 1800 struct lock_class_key i_mutex_dir_key;
d475fd42 1801 struct lock_class_key i_alloc_sem_key;
1da177e4
LT
1802};
1803
ceefda69
AV
1804extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
1805 void *data, int (*fill_super)(struct super_block *, void *, int));
152a0836
AV
1806extern struct dentry *mount_bdev(struct file_system_type *fs_type,
1807 int flags, const char *dev_name, void *data,
1808 int (*fill_super)(struct super_block *, void *, int));
454e2398 1809extern int get_sb_bdev(struct file_system_type *fs_type,
1da177e4 1810 int flags, const char *dev_name, void *data,
454e2398
DH
1811 int (*fill_super)(struct super_block *, void *, int),
1812 struct vfsmount *mnt);
fc14f2fe
AV
1813extern struct dentry *mount_single(struct file_system_type *fs_type,
1814 int flags, void *data,
1815 int (*fill_super)(struct super_block *, void *, int));
454e2398 1816extern int get_sb_single(struct file_system_type *fs_type,
1da177e4 1817 int flags, void *data,
454e2398
DH
1818 int (*fill_super)(struct super_block *, void *, int),
1819 struct vfsmount *mnt);
3c26ff6e
AV
1820extern struct dentry *mount_nodev(struct file_system_type *fs_type,
1821 int flags, void *data,
1822 int (*fill_super)(struct super_block *, void *, int));
454e2398 1823extern int get_sb_nodev(struct file_system_type *fs_type,
1da177e4 1824 int flags, void *data,
454e2398
DH
1825 int (*fill_super)(struct super_block *, void *, int),
1826 struct vfsmount *mnt);
1da177e4
LT
1827void generic_shutdown_super(struct super_block *sb);
1828void kill_block_super(struct super_block *sb);
1829void kill_anon_super(struct super_block *sb);
1830void kill_litter_super(struct super_block *sb);
1831void deactivate_super(struct super_block *sb);
74dbbdd7 1832void deactivate_locked_super(struct super_block *sb);
1da177e4
LT
1833int set_anon_super(struct super_block *s, void *data);
1834struct super_block *sget(struct file_system_type *type,
1835 int (*test)(struct super_block *,void *),
1836 int (*set)(struct super_block *,void *),
1837 void *data);
51139ada 1838extern struct dentry *mount_pseudo(struct file_system_type *, char *,
c74a1cbb
AV
1839 const struct super_operations *ops,
1840 const struct dentry_operations *dops,
1841 unsigned long);
a3ec947c 1842extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
1da177e4 1843
140236b4
AB
1844static inline void sb_mark_dirty(struct super_block *sb)
1845{
1846 sb->s_dirt = 1;
1847}
1848static inline void sb_mark_clean(struct super_block *sb)
1849{
1850 sb->s_dirt = 0;
1851}
1852static inline int sb_is_dirty(struct super_block *sb)
1853{
1854 return sb->s_dirt;
1855}
1856
1da177e4
LT
1857/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
1858#define fops_get(fops) \
1859 (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
1860#define fops_put(fops) \
1861 do { if (fops) module_put((fops)->owner); } while(0)
1862
1863extern int register_filesystem(struct file_system_type *);
1864extern int unregister_filesystem(struct file_system_type *);
8bf9725c
PE
1865extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
1866#define kern_mount(type) kern_mount_data(type, NULL)
1da177e4
LT
1867extern int may_umount_tree(struct vfsmount *);
1868extern int may_umount(struct vfsmount *);
1869extern long do_mount(char *, char *, char *, unsigned long, void *);
589ff870 1870extern struct vfsmount *collect_mounts(struct path *);
8aec0809 1871extern void drop_collected_mounts(struct vfsmount *);
1f707137
AV
1872extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
1873 struct vfsmount *);
ebabe9a9
CH
1874extern int vfs_statfs(struct path *, struct kstatfs *);
1875extern int statfs_by_dentry(struct dentry *, struct kstatfs *);
18e9e510
JB
1876extern int freeze_super(struct super_block *super);
1877extern int thaw_super(struct super_block *super);
1da177e4 1878
ce3b0f8d
AV
1879extern int current_umask(void);
1880
f87fd4c2 1881/* /sys/fs */
00d26666 1882extern struct kobject *fs_kobj;
f87fd4c2 1883
435f49a5 1884#define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)
bfcd17a6
TP
1885extern int rw_verify_area(int, struct file *, loff_t *, size_t);
1886
1da177e4
LT
1887#define FLOCK_VERIFY_READ 1
1888#define FLOCK_VERIFY_WRITE 2
1889
bfcd17a6 1890#ifdef CONFIG_FILE_LOCKING
1da177e4
LT
1891extern int locks_mandatory_locked(struct inode *);
1892extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
1893
1894/*
1895 * Candidates for mandatory locking have the setgid bit set
1896 * but no group execute bit - an otherwise meaningless combination.
1897 */
a16877ca
PE
1898
1899static inline int __mandatory_lock(struct inode *ino)
1900{
1901 return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
1902}
1903
1904/*
1905 * ... and these candidates should be on MS_MANDLOCK mounted fs,
1906 * otherwise these will be advisory locks
1907 */
1908
1909static inline int mandatory_lock(struct inode *ino)
1910{
1911 return IS_MANDLOCK(ino) && __mandatory_lock(ino);
1912}
1da177e4
LT
1913
1914static inline int locks_verify_locked(struct inode *inode)
1915{
a16877ca 1916 if (mandatory_lock(inode))
1da177e4
LT
1917 return locks_mandatory_locked(inode);
1918 return 0;
1919}
1920
1da177e4
LT
1921static inline int locks_verify_truncate(struct inode *inode,
1922 struct file *filp,
1923 loff_t size)
1924{
a16877ca 1925 if (inode->i_flock && mandatory_lock(inode))
1da177e4
LT
1926 return locks_mandatory_area(
1927 FLOCK_VERIFY_WRITE, inode, filp,
1928 size < inode->i_size ? size : inode->i_size,
1929 (size < inode->i_size ? inode->i_size - size
1930 : size - inode->i_size)
1931 );
1932 return 0;
1933}
1934
1935static inline int break_lease(struct inode *inode, unsigned int mode)
1936{
1937 if (inode->i_flock)
1938 return __break_lease(inode, mode);
1939 return 0;
1940}
bfcd17a6 1941#else /* !CONFIG_FILE_LOCKING */
af5df566
SW
1942static inline int locks_mandatory_locked(struct inode *inode)
1943{
1944 return 0;
1945}
1946
1947static inline int locks_mandatory_area(int rw, struct inode *inode,
1948 struct file *filp, loff_t offset,
1949 size_t count)
1950{
1951 return 0;
1952}
1953
1954static inline int __mandatory_lock(struct inode *inode)
1955{
1956 return 0;
1957}
1958
1959static inline int mandatory_lock(struct inode *inode)
1960{
1961 return 0;
1962}
1963
1964static inline int locks_verify_locked(struct inode *inode)
1965{
1966 return 0;
1967}
1968
1969static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
1970 size_t size)
1971{
1972 return 0;
1973}
1974
1975static inline int break_lease(struct inode *inode, unsigned int mode)
1976{
1977 return 0;
1978}
1979
bfcd17a6 1980#endif /* CONFIG_FILE_LOCKING */
1da177e4
LT
1981
1982/* fs/open.c */
1983
4a30131e
N
1984extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
1985 struct file *filp);
3e63cbb1
AJ
1986extern int do_fallocate(struct file *file, int mode, loff_t offset,
1987 loff_t len);
8e8a1407 1988extern long do_sys_open(int dfd, const char __user *filename, int flags,
5590ff0d 1989 int mode);
1da177e4 1990extern struct file *filp_open(const char *, int, int);
745ca247
DH
1991extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
1992 const struct cred *);
1da177e4
LT
1993extern int filp_close(struct file *, fl_owner_t id);
1994extern char * getname(const char __user *);
1995
3e63cbb1
AJ
1996/* fs/ioctl.c */
1997
1998extern int ioctl_preallocate(struct file *filp, void __user *argp);
1999
1da177e4
LT
2000/* fs/dcache.c */
2001extern void __init vfs_caches_init_early(void);
2002extern void __init vfs_caches_init(unsigned long);
2003
b86c089b
CL
2004extern struct kmem_cache *names_cachep;
2005
3446a8aa
VN
2006#define __getname_gfp(gfp) kmem_cache_alloc(names_cachep, (gfp))
2007#define __getname() __getname_gfp(GFP_KERNEL)
2008#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
1da177e4
LT
2009#ifndef CONFIG_AUDITSYSCALL
2010#define putname(name) __putname(name)
2011#else
2012extern void putname(const char *name);
2013#endif
2014
9361401e 2015#ifdef CONFIG_BLOCK
1da177e4 2016extern int register_blkdev(unsigned int, const char *);
f4480240 2017extern void unregister_blkdev(unsigned int, const char *);
1da177e4 2018extern struct block_device *bdget(dev_t);
dddac6a7 2019extern struct block_device *bdgrab(struct block_device *bdev);
1da177e4
LT
2020extern void bd_set_size(struct block_device *, loff_t size);
2021extern void bd_forget(struct inode *inode);
2022extern void bdput(struct block_device *);
585d3bc0
NP
2023extern void invalidate_bdev(struct block_device *);
2024extern int sync_blockdev(struct block_device *bdev);
2025extern struct super_block *freeze_bdev(struct block_device *);
c2d75438 2026extern void emergency_thaw_all(void);
585d3bc0
NP
2027extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
2028extern int fsync_bdev(struct block_device *);
9361401e
DH
2029#else
2030static inline void bd_forget(struct inode *inode) {}
47e4491b
AV
2031static inline int sync_blockdev(struct block_device *bdev) { return 0; }
2032static inline void invalidate_bdev(struct block_device *bdev) {}
2033
2034static inline struct super_block *freeze_bdev(struct block_device *sb)
2035{
2036 return NULL;
2037}
2038
2039static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
2040{
2041 return 0;
2042}
9361401e 2043#endif
60b0680f 2044extern int sync_filesystem(struct super_block *);
9361401e 2045extern const struct file_operations def_blk_fops;
4b6f5d20
AV
2046extern const struct file_operations def_chr_fops;
2047extern const struct file_operations bad_sock_fops;
2048extern const struct file_operations def_fifo_fops;
9361401e 2049#ifdef CONFIG_BLOCK
1da177e4 2050extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
56b26add 2051extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
1da177e4 2052extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
e525fd89 2053extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
d4d77629
TH
2054extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
2055 void *holder);
2056extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
2057 void *holder);
e525fd89 2058extern int blkdev_put(struct block_device *bdev, fmode_t mode);
641dc636 2059#ifdef CONFIG_SYSFS
e09b457b 2060extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
49731baa
TH
2061extern void bd_unlink_disk_holder(struct block_device *bdev,
2062 struct gendisk *disk);
641dc636 2063#else
e09b457b
TH
2064static inline int bd_link_disk_holder(struct block_device *bdev,
2065 struct gendisk *disk)
2066{
2067 return 0;
2068}
49731baa
TH
2069static inline void bd_unlink_disk_holder(struct block_device *bdev,
2070 struct gendisk *disk)
2071{
2072}
641dc636 2073#endif
9361401e 2074#endif
1da177e4
LT
2075
2076/* fs/char_dev.c */
68eef3b4 2077#define CHRDEV_MAJOR_HASH_SIZE 255
1da177e4
LT
2078extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2079extern int register_chrdev_region(dev_t, unsigned, const char *);
1905b1bf
TH
2080extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2081 unsigned int count, const char *name,
2082 const struct file_operations *fops);
2083extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2084 unsigned int count, const char *name);
1da177e4 2085extern void unregister_chrdev_region(dev_t, unsigned);
68eef3b4 2086extern void chrdev_show(struct seq_file *,off_t);
1da177e4 2087
1905b1bf
TH
2088static inline int register_chrdev(unsigned int major, const char *name,
2089 const struct file_operations *fops)
2090{
2091 return __register_chrdev(major, 0, 256, name, fops);
2092}
2093
2094static inline void unregister_chrdev(unsigned int major, const char *name)
2095{
2096 __unregister_chrdev(major, 0, 256, name);
2097}
2098
1da177e4
LT
2099/* fs/block_dev.c */
2100#define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
1f014290 2101#define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */
9361401e
DH
2102
2103#ifdef CONFIG_BLOCK
2104#define BLKDEV_MAJOR_HASH_SIZE 255
1da177e4
LT
2105extern const char *__bdevname(dev_t, char *buffer);
2106extern const char *bdevname(struct block_device *bdev, char *buffer);
2107extern struct block_device *lookup_bdev(const char *);
68eef3b4 2108extern void blkdev_show(struct seq_file *,off_t);
30c40d2c 2109
9361401e
DH
2110#else
2111#define BLKDEV_MAJOR_HASH_SIZE 0
2112#endif
1da177e4
LT
2113
2114extern void init_special_inode(struct inode *, umode_t, dev_t);
2115
2116/* Invalid inode operations -- fs/bad_inode.c */
2117extern void make_bad_inode(struct inode *);
2118extern int is_bad_inode(struct inode *);
2119
d2d9648e
DV
2120extern const struct file_operations read_pipefifo_fops;
2121extern const struct file_operations write_pipefifo_fops;
2122extern const struct file_operations rdwr_pipefifo_fops;
1da177e4
LT
2123
2124extern int fs_may_remount_ro(struct super_block *);
2125
9361401e 2126#ifdef CONFIG_BLOCK
1da177e4
LT
2127/*
2128 * return READ, READA, or WRITE
2129 */
2130#define bio_rw(bio) ((bio)->bi_rw & (RW_MASK | RWA_MASK))
2131
2132/*
2133 * return data direction, READ or WRITE
2134 */
2135#define bio_data_dir(bio) ((bio)->bi_rw & 1)
2136
c3279d14
AP
2137extern void check_disk_size_change(struct gendisk *disk,
2138 struct block_device *bdev);
0c002c2f 2139extern int revalidate_disk(struct gendisk *);
1da177e4 2140extern int check_disk_change(struct block_device *);
2ef41634 2141extern int __invalidate_device(struct block_device *);
1da177e4 2142extern int invalidate_partition(struct gendisk *, int);
9361401e 2143#endif
1da177e4
LT
2144unsigned long invalidate_mapping_pages(struct address_space *mapping,
2145 pgoff_t start, pgoff_t end);
54bc4855 2146
1da177e4
LT
2147static inline void invalidate_remote_inode(struct inode *inode)
2148{
2149 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2150 S_ISLNK(inode->i_mode))
fc0ecff6 2151 invalidate_mapping_pages(inode->i_mapping, 0, -1);
1da177e4
LT
2152}
2153extern int invalidate_inode_pages2(struct address_space *mapping);
2154extern int invalidate_inode_pages2_range(struct address_space *mapping,
2155 pgoff_t start, pgoff_t end);
2156extern int write_inode_now(struct inode *, int);
2157extern int filemap_fdatawrite(struct address_space *);
2158extern int filemap_flush(struct address_space *);
2159extern int filemap_fdatawait(struct address_space *);
d3bccb6f
JK
2160extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
2161 loff_t lend);
1da177e4
LT
2162extern int filemap_write_and_wait(struct address_space *mapping);
2163extern int filemap_write_and_wait_range(struct address_space *mapping,
2164 loff_t lstart, loff_t lend);
ebcf28e1
AM
2165extern int __filemap_fdatawrite_range(struct address_space *mapping,
2166 loff_t start, loff_t end, int sync_mode);
f4c0a0fd
JK
2167extern int filemap_fdatawrite_range(struct address_space *mapping,
2168 loff_t start, loff_t end);
ebcf28e1 2169
8018ab05
CH
2170extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2171 int datasync);
2172extern int vfs_fsync(struct file *file, int datasync);
148f948b 2173extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
1da177e4 2174extern void sync_supers(void);
1da177e4
LT
2175extern void emergency_sync(void);
2176extern void emergency_remount(void);
9361401e 2177#ifdef CONFIG_BLOCK
1da177e4 2178extern sector_t bmap(struct inode *, sector_t);
9361401e 2179#endif
1da177e4 2180extern int notify_change(struct dentry *, struct iattr *);
f419a2e3 2181extern int inode_permission(struct inode *, int);
b74c79e9
NP
2182extern int generic_permission(struct inode *, int, unsigned int,
2183 int (*check_acl)(struct inode *, int, unsigned int));
1da177e4 2184
f696a365
MS
2185static inline bool execute_ok(struct inode *inode)
2186{
2187 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
2188}
2189
1da177e4
LT
2190extern int get_write_access(struct inode *);
2191extern int deny_write_access(struct file *);
2192static inline void put_write_access(struct inode * inode)
2193{
2194 atomic_dec(&inode->i_writecount);
2195}
2196static inline void allow_write_access(struct file *file)
2197{
2198 if (file)
0f7fc9e4 2199 atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
1da177e4 2200}
ed8cae8b 2201extern int do_pipe_flags(int *, int);
be61a86d
UD
2202extern struct file *create_read_pipe(struct file *f, int flags);
2203extern struct file *create_write_pipe(int flags);
d6cbd281 2204extern void free_write_pipe(struct file *);
1da177e4 2205
a70e65df 2206extern struct file *do_filp_open(int dfd, const char *pathname,
6e8341a1 2207 int open_flag, int mode, int acc_mode);
3fb64190 2208extern int may_open(struct path *, int, int);
1da177e4 2209
6777d773 2210extern int kernel_read(struct file *, loff_t, char *, unsigned long);
1da177e4
LT
2211extern struct file * open_exec(const char *);
2212
2213/* fs/dcache.c -- generic fs support functions */
2214extern int is_subdir(struct dentry *, struct dentry *);
2096f759 2215extern int path_is_under(struct path *, struct path *);
1da177e4
LT
2216extern ino_t find_inode_number(struct dentry *, struct qstr *);
2217
2218#include <linux/err.h>
2219
2220/* needed for stackable file system support */
2221extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
2222
2223extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
2224
54e34621 2225extern int inode_init_always(struct super_block *, struct inode *);
1da177e4 2226extern void inode_init_once(struct inode *);
7de9c6ee 2227extern void ihold(struct inode * inode);
1da177e4
LT
2228extern void iput(struct inode *);
2229extern struct inode * igrab(struct inode *);
2230extern ino_t iunique(struct super_block *, ino_t);
2231extern int inode_needs_sync(struct inode *inode);
45321ac5
AV
2232extern int generic_delete_inode(struct inode *inode);
2233extern int generic_drop_inode(struct inode *inode);
1da177e4 2234
88bd5121
AA
2235extern struct inode *ilookup5_nowait(struct super_block *sb,
2236 unsigned long hashval, int (*test)(struct inode *, void *),
2237 void *data);
1da177e4
LT
2238extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
2239 int (*test)(struct inode *, void *), void *data);
2240extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
2241
2242extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
2243extern struct inode * iget_locked(struct super_block *, unsigned long);
261bca86
AV
2244extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
2245extern int insert_inode_locked(struct inode *);
1da177e4 2246extern void unlock_new_inode(struct inode *);
85fe4025 2247extern unsigned int get_next_ino(void);
1da177e4 2248
1da177e4 2249extern void __iget(struct inode * inode);
b46980fe 2250extern void iget_failed(struct inode *);
b0683aa6 2251extern void end_writeback(struct inode *);
2e00c97e 2252extern void __destroy_inode(struct inode *);
1da177e4 2253extern struct inode *new_inode(struct super_block *);
ff0c7d15 2254extern void free_inode_nonrcu(struct inode *inode);
01de85e0 2255extern int should_remove_suid(struct dentry *);
2f1936b8 2256extern int file_remove_suid(struct file *);
1da177e4
LT
2257
2258extern void __insert_inode_hash(struct inode *, unsigned long hashval);
2259extern void remove_inode_hash(struct inode *);
646ec461
CH
2260static inline void insert_inode_hash(struct inode *inode)
2261{
1da177e4
LT
2262 __insert_inode_hash(inode, inode->i_ino);
2263}
646ec461 2264extern void inode_sb_list_add(struct inode *inode);
1da177e4 2265
9361401e 2266#ifdef CONFIG_BLOCK
1da177e4
LT
2267extern void submit_bio(int, struct bio *);
2268extern int bdev_read_only(struct block_device *);
9361401e 2269#endif
1da177e4
LT
2270extern int set_blocksize(struct block_device *, int);
2271extern int sb_set_blocksize(struct super_block *, int);
2272extern int sb_min_blocksize(struct super_block *, int);
2273
2274extern int generic_file_mmap(struct file *, struct vm_area_struct *);
2275extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
2276extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
1da177e4 2277int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
027445c3 2278extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
e4dd9de3
JK
2279extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,
2280 loff_t *);
027445c3 2281extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
1da177e4
LT
2282extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
2283 unsigned long *, loff_t, loff_t *, size_t, size_t);
2284extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
2285 unsigned long, loff_t, loff_t *, size_t, ssize_t);
2286extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
2287extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
0ceb3314
DM
2288extern int generic_segment_checks(const struct iovec *iov,
2289 unsigned long *nr_segs, size_t *count, int access_flags);
88e6faef 2290
eef99380
CH
2291/* fs/block_dev.c */
2292extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
2293 unsigned long nr_segs, loff_t pos);
7ea80859 2294extern int blkdev_fsync(struct file *filp, int datasync);
eef99380 2295
88e6faef 2296/* fs/splice.c */
cbb7e577 2297extern ssize_t generic_file_splice_read(struct file *, loff_t *,
88e6faef 2298 struct pipe_inode_info *, size_t, unsigned int);
6818173b
MS
2299extern ssize_t default_file_splice_read(struct file *, loff_t *,
2300 struct pipe_inode_info *, size_t, unsigned int);
88e6faef 2301extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
cbb7e577 2302 struct file *, loff_t *, size_t, unsigned int);
88e6faef 2303extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
cbb7e577
JA
2304 struct file *out, loff_t *, size_t len, unsigned int flags);
2305extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
88e6faef
AM
2306 size_t len, unsigned int flags);
2307
1da177e4
LT
2308extern void
2309file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
ae6afc3f 2310extern loff_t noop_llseek(struct file *file, loff_t offset, int origin);
1da177e4
LT
2311extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
2312extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
9465efc9
AK
2313extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,
2314 int origin);
1da177e4
LT
2315extern int generic_file_open(struct inode * inode, struct file * filp);
2316extern int nonseekable_open(struct inode * inode, struct file * filp);
2317
ceffc078 2318#ifdef CONFIG_FS_XIP
eb6fe0c3
CO
2319extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
2320 loff_t *ppos);
ceffc078 2321extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
eb6fe0c3
CO
2322extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
2323 size_t len, loff_t *ppos);
ceffc078 2324extern int xip_truncate_page(struct address_space *mapping, loff_t from);
6d79125b
CO
2325#else
2326static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
2327{
2328 return 0;
2329}
ceffc078
CO
2330#endif
2331
9361401e 2332#ifdef CONFIG_BLOCK
facd07b0
JB
2333typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
2334 loff_t file_offset);
1da177e4
LT
2335
2336enum {
1e431f5c
CH
2337 /* need locking between buffered and direct access */
2338 DIO_LOCKING = 0x01,
2339
2340 /* filesystem does not support filling holes */
2341 DIO_SKIP_HOLES = 0x02,
1da177e4
LT
2342};
2343
eafdc7d1
CH
2344void dio_end_io(struct bio *bio, int error);
2345
2346ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
2347 struct block_device *bdev, const struct iovec *iov, loff_t offset,
2348 unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
2349 dio_submit_t submit_io, int flags);
7bb46a67 2350
1da177e4
LT
2351static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
2352 struct inode *inode, struct block_device *bdev, const struct iovec *iov,
1d8fa7a2 2353 loff_t offset, unsigned long nr_segs, get_block_t get_block,
1da177e4
LT
2354 dio_iodone_t end_io)
2355{
2356 return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
facd07b0 2357 nr_segs, get_block, end_io, NULL,
1e431f5c 2358 DIO_LOCKING | DIO_SKIP_HOLES);
1da177e4 2359}
9361401e 2360#endif
1da177e4 2361
4b6f5d20 2362extern const struct file_operations generic_ro_fops;
1da177e4
LT
2363
2364#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
2365
2366extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
2367extern int vfs_follow_link(struct nameidata *, const char *);
2368extern int page_readlink(struct dentry *, char __user *, int);
cc314eef
LT
2369extern void *page_follow_link_light(struct dentry *, struct nameidata *);
2370extern void page_put_link(struct dentry *, struct nameidata *, void *);
0adb25d2 2371extern int __page_symlink(struct inode *inode, const char *symname, int len,
54566b2c 2372 int nofs);
1da177e4 2373extern int page_symlink(struct inode *inode, const char *symname, int len);
c5ef1c42 2374extern const struct inode_operations page_symlink_inode_operations;
1da177e4
LT
2375extern int generic_readlink(struct dentry *, char __user *, int);
2376extern void generic_fillattr(struct inode *, struct kstat *);
2377extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
b462707e 2378void __inode_add_bytes(struct inode *inode, loff_t bytes);
1da177e4
LT
2379void inode_add_bytes(struct inode *inode, loff_t bytes);
2380void inode_sub_bytes(struct inode *inode, loff_t bytes);
2381loff_t inode_get_bytes(struct inode *inode);
2382void inode_set_bytes(struct inode *inode, loff_t bytes);
2383
2384extern int vfs_readdir(struct file *, filldir_t, void *);
2385
c7887325
DH
2386extern int vfs_stat(const char __user *, struct kstat *);
2387extern int vfs_lstat(const char __user *, struct kstat *);
1da177e4 2388extern int vfs_fstat(unsigned int, struct kstat *);
c7887325 2389extern int vfs_fstatat(int , const char __user *, struct kstat *, int);
1da177e4 2390
deb21db7
EZ
2391extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
2392 unsigned long arg);
e9079cce 2393extern int __generic_block_fiemap(struct inode *inode,
3a3076f4
JB
2394 struct fiemap_extent_info *fieinfo,
2395 loff_t start, loff_t len,
2396 get_block_t *get_block);
68c9d702
JB
2397extern int generic_block_fiemap(struct inode *inode,
2398 struct fiemap_extent_info *fieinfo, u64 start,
2399 u64 len, get_block_t *get_block);
1da177e4 2400
c18479fe
MS
2401extern void get_filesystem(struct file_system_type *fs);
2402extern void put_filesystem(struct file_system_type *fs);
1da177e4
LT
2403extern struct file_system_type *get_fs_type(const char *name);
2404extern struct super_block *get_super(struct block_device *);
4504230a 2405extern struct super_block *get_active_super(struct block_device *bdev);
1da177e4
LT
2406extern struct super_block *user_get_super(dev_t);
2407extern void drop_super(struct super_block *sb);
01a05b33 2408extern void iterate_supers(void (*)(struct super_block *, void *), void *);
1da177e4
LT
2409
2410extern int dcache_dir_open(struct inode *, struct file *);
2411extern int dcache_dir_close(struct inode *, struct file *);
2412extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
2413extern int dcache_readdir(struct file *, void *, filldir_t);
7bb46a67 2414extern int simple_setattr(struct dentry *, struct iattr *);
1da177e4 2415extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
726c3342 2416extern int simple_statfs(struct dentry *, struct kstatfs *);
1da177e4
LT
2417extern int simple_link(struct dentry *, struct inode *, struct dentry *);
2418extern int simple_unlink(struct inode *, struct dentry *);
2419extern int simple_rmdir(struct inode *, struct dentry *);
2420extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
1b061d92 2421extern int noop_fsync(struct file *, int);
1da177e4
LT
2422extern int simple_empty(struct dentry *);
2423extern int simple_readpage(struct file *file, struct page *page);
afddba49
NP
2424extern int simple_write_begin(struct file *file, struct address_space *mapping,
2425 loff_t pos, unsigned len, unsigned flags,
2426 struct page **pagep, void **fsdata);
2427extern int simple_write_end(struct file *file, struct address_space *mapping,
2428 loff_t pos, unsigned len, unsigned copied,
2429 struct page *page, void *fsdata);
1da177e4
LT
2430
2431extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
2432extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
4b6f5d20 2433extern const struct file_operations simple_dir_operations;
c5ef1c42 2434extern const struct inode_operations simple_dir_inode_operations;
4b6f5d20 2435struct tree_descr { char *name; const struct file_operations *ops; int mode; };
1da177e4 2436struct dentry *d_alloc_name(struct dentry *, const char *);
7d683a09 2437extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
1f5ce9e9 2438extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
1da177e4
LT
2439extern void simple_release_fs(struct vfsmount **mount, int *count);
2440
93b07113
AM
2441extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
2442 loff_t *ppos, const void *from, size_t available);
6a727b43
JS
2443extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
2444 const void __user *from, size_t count);
1da177e4 2445
1b061d92 2446extern int generic_file_fsync(struct file *, int);
d5aacad5 2447
30ca22c7
PL
2448extern int generic_check_addressable(unsigned, u64);
2449
e965f963 2450#ifdef CONFIG_MIGRATION
2d1db3b1
CL
2451extern int buffer_migrate_page(struct address_space *,
2452 struct page *, struct page *);
e965f963
CL
2453#else
2454#define buffer_migrate_page NULL
2455#endif
2456
25d9e2d1 2457extern int inode_change_ok(const struct inode *, struct iattr *);
2458extern int inode_newsize_ok(const struct inode *, loff_t offset);
6a1a90ad 2459extern void setattr_copy(struct inode *inode, const struct iattr *attr);
1da177e4 2460
870f4817 2461extern void file_update_time(struct file *file);
1da177e4 2462
b3b304a2
MS
2463extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
2464extern void save_mount_options(struct super_block *sb, char *options);
2a32cebd 2465extern void replace_mount_options(struct super_block *sb, char *options);
b3b304a2 2466
1da177e4
LT
2467static inline ino_t parent_ino(struct dentry *dentry)
2468{
2469 ino_t res;
2470
b5c84bf6
NP
2471 /*
2472 * Don't strictly need d_lock here? If the parent ino could change
2473 * then surely we'd have a deeper race in the caller?
2474 */
1da177e4
LT
2475 spin_lock(&dentry->d_lock);
2476 res = dentry->d_parent->d_inode->i_ino;
2477 spin_unlock(&dentry->d_lock);
2478 return res;
2479}
2480
1da177e4
LT
2481/* Transaction based IO helpers */
2482
2483/*
2484 * An argresp is stored in an allocated page and holds the
2485 * size of the argument or response, along with its content
2486 */
2487struct simple_transaction_argresp {
2488 ssize_t size;
2489 char data[0];
2490};
2491
2492#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
2493
2494char *simple_transaction_get(struct file *file, const char __user *buf,
2495 size_t size);
2496ssize_t simple_transaction_read(struct file *file, char __user *buf,
2497 size_t size, loff_t *pos);
2498int simple_transaction_release(struct inode *inode, struct file *file);
2499
76791ab2 2500void simple_transaction_set(struct file *file, size_t n);
1da177e4 2501
acaefc25
AB
2502/*
2503 * simple attribute files
2504 *
2505 * These attributes behave similar to those in sysfs:
2506 *
2507 * Writing to an attribute immediately sets a value, an open file can be
2508 * written to multiple times.
2509 *
2510 * Reading from an attribute creates a buffer from the value that might get
2511 * read with multiple read calls. When the attribute has been read
2512 * completely, no further read calls are possible until the file is opened
2513 * again.
2514 *
2515 * All attributes contain a text representation of a numeric value
2516 * that are accessed with the get() and set() functions.
2517 */
2518#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
2519static int __fops ## _open(struct inode *inode, struct file *file) \
2520{ \
2521 __simple_attr_check_format(__fmt, 0ull); \
2522 return simple_attr_open(inode, file, __get, __set, __fmt); \
2523} \
828c0950 2524static const struct file_operations __fops = { \
acaefc25
AB
2525 .owner = THIS_MODULE, \
2526 .open = __fops ## _open, \
74bedc4d 2527 .release = simple_attr_release, \
acaefc25
AB
2528 .read = simple_attr_read, \
2529 .write = simple_attr_write, \
1ec5584e 2530 .llseek = generic_file_llseek, \
acaefc25
AB
2531};
2532
2533static inline void __attribute__((format(printf, 1, 2)))
2534__simple_attr_check_format(const char *fmt, ...)
2535{
2536 /* don't do anything, just let the compiler check the arguments; */
2537}
2538
2539int simple_attr_open(struct inode *inode, struct file *file,
8b88b099 2540 int (*get)(void *, u64 *), int (*set)(void *, u64),
acaefc25 2541 const char *fmt);
74bedc4d 2542int simple_attr_release(struct inode *inode, struct file *file);
acaefc25
AB
2543ssize_t simple_attr_read(struct file *file, char __user *buf,
2544 size_t len, loff_t *ppos);
2545ssize_t simple_attr_write(struct file *file, const char __user *buf,
2546 size_t len, loff_t *ppos);
2547
4be28540 2548struct ctl_table;
8d65af78 2549int proc_nr_files(struct ctl_table *table, int write,
62239ac2 2550 void __user *buffer, size_t *lenp, loff_t *ppos);
312d3ca8
CH
2551int proc_nr_dentry(struct ctl_table *table, int write,
2552 void __user *buffer, size_t *lenp, loff_t *ppos);
cffbc8aa
DC
2553int proc_nr_inodes(struct ctl_table *table, int write,
2554 void __user *buffer, size_t *lenp, loff_t *ppos);
38e23c95 2555int __init get_filesystem_list(char *buf);
62239ac2 2556
3cd90ea4 2557#define __FMODE_EXEC ((__force int) FMODE_EXEC)
1a44bc8c
NK
2558#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
2559
6d125529 2560#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
ecf081d1 2561#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
1a44bc8c 2562 (flag & __FMODE_NONOTIFY)))
5300990c 2563
1da177e4
LT
2564#endif /* __KERNEL__ */
2565#endif /* _LINUX_FS_H */