fs.h 89.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
#ifndef _LINUX_FS_H
#define _LINUX_FS_H

/*
 * This file has definitions for some important file table
 * structures etc.
 */

#include <linux/limits.h>
#include <linux/ioctl.h>
11
#include <linux/blk_types.h>
12
#include <linux/types.h>
Linus Torvalds's avatar
Linus Torvalds committed
13
14
15
16
17
18
19
20
21
22
23
24
25

/*
 * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
 * the file limit at runtime and only root can increase the per-process
 * nr_file rlimit, so it's safe to set up a ridiculously high absolute
 * upper limit on files-per-process.
 *
 * Some programs (notably those using select()) may have to be 
 * recompiled to take full advantage of the new limits..  
 */

/* Fixed constants first: */
#undef NR_OPEN
26
27
#define INR_OPEN_CUR 1024	/* Initial setting for nfile rlimits */
#define INR_OPEN_MAX 4096	/* Hard limit for nfile rlimits */
Linus Torvalds's avatar
Linus Torvalds committed
28
29
30
31

#define BLOCK_SIZE_BITS 10
#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)

32
33
34
#define SEEK_SET	0	/* seek relative to beginning of file */
#define SEEK_CUR	1	/* seek relative to current file position */
#define SEEK_END	2	/* seek relative to end of file */
35
36
37
#define SEEK_DATA	3	/* seek to the next data */
#define SEEK_HOLE	4	/* seek to the next hole */
#define SEEK_MAX	SEEK_HOLE
38

Lukas Czerner's avatar
Lukas Czerner committed
39
struct fstrim_range {
40
41
42
	__u64 start;
	__u64 len;
	__u64 minlen;
Lukas Czerner's avatar
Lukas Czerner committed
43
44
};

Linus Torvalds's avatar
Linus Torvalds committed
45
46
/* And dynamically-tunable limits and defaults: */
struct files_stat_struct {
47
48
49
	unsigned long nr_files;		/* read only */
	unsigned long nr_free_files;	/* read only */
	unsigned long max_files;		/* tunable */
Linus Torvalds's avatar
Linus Torvalds committed
50
51
52
53
54
};

struct inodes_stat_t {
	int nr_inodes;
	int nr_unused;
55
	int dummy[5];		/* padding for sysctl ABI compatibility */
Linus Torvalds's avatar
Linus Torvalds committed
56
57
58
59
60
61
62
63
64
};


#define NR_FILE  8192	/* this can well be larger on a larger system */

#define MAY_EXEC 1
#define MAY_WRITE 2
#define MAY_READ 4
#define MAY_APPEND 8
65
#define MAY_ACCESS 16
66
#define MAY_OPEN 32
Eric Paris's avatar
Eric Paris committed
67
#define MAY_CHDIR 64
68
#define MAY_NOT_BLOCK 128	/* called from RCU mode, don't block */
Linus Torvalds's avatar
Linus Torvalds committed
69

70
71
72
73
74
/*
 * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
 * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
 */

75
/* file is open for reading */
76
#define FMODE_READ		((__force fmode_t)0x1)
77
/* file is open for writing */
78
#define FMODE_WRITE		((__force fmode_t)0x2)
79
/* file is seekable */
80
#define FMODE_LSEEK		((__force fmode_t)0x4)
81
/* file can be accessed using pread */
82
#define FMODE_PREAD		((__force fmode_t)0x8)
83
/* file can be accessed using pwrite */
84
#define FMODE_PWRITE		((__force fmode_t)0x10)
85
/* File is opened for execution with sys_execve / sys_uselib */
86
#define FMODE_EXEC		((__force fmode_t)0x20)
87
/* File is opened with O_NDELAY (only set for block devices) */
88
#define FMODE_NDELAY		((__force fmode_t)0x40)
89
/* File is opened with O_EXCL (only set for block devices) */
90
#define FMODE_EXCL		((__force fmode_t)0x80)
91
92
/* File is opened using open(.., 3, ..) and is writeable only for ioctls
   (specialy hack for floppy.c) */
93
#define FMODE_WRITE_IOCTL	((__force fmode_t)0x100)
94

95
96
97
98
99
100
/*
 * Don't update ctime and mtime.
 *
 * Currently a special hack for the XFS open_by_handle ioctl, but we'll
 * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
 */
101
#define FMODE_NOCMTIME		((__force fmode_t)0x800)
102

103
/* Expect random access pattern */
104
#define FMODE_RANDOM		((__force fmode_t)0x1000)
105

106
107
108
/* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
#define FMODE_UNSIGNED_OFFSET	((__force fmode_t)0x2000)

109
110
111
/* File is opened with O_PATH; almost nothing can be done with it */
#define FMODE_PATH		((__force fmode_t)0x4000)

Eric Paris's avatar
Eric Paris committed
112
/* File was opened by fanotify and shouldn't generate fanotify events */
113
#define FMODE_NONOTIFY		((__force fmode_t)0x1000000)
Eric Paris's avatar
Eric Paris committed
114

115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/*
 * The below are the various read and write types that we support. Some of
 * them include behavioral modifiers that send information down to the
 * block layer and IO scheduler. Terminology:
 *
 *	The block layer uses device plugging to defer IO a little bit, in
 *	the hope that we will see more IO very shortly. This increases
 *	coalescing of adjacent IO and thus reduces the number of IOs we
 *	have to send to the device. It also allows for better queuing,
 *	if the IO isn't mergeable. If the caller is going to be waiting
 *	for the IO, then he must ensure that the device is unplugged so
 *	that the IO is dispatched to the driver.
 *
 *	All IO is handled async in Linux. This is fine for background
 *	writes, but for reads or writes that someone waits for completion
 *	on, we want to notify the block layer and IO scheduler so that they
 *	know about it. That allows them to make better scheduling
 *	decisions. So when the below references 'sync' and 'async', it
 *	is referencing this priority hint.
 *
 * With that in mind, the available types are:
 *
 * READ			A normal read operation. Device will be plugged.
 * READ_SYNC		A synchronous read. Device is not plugged, caller can
 *			immediately wait on this read without caring about
 *			unplugging.
 * READA		Used for read-ahead operations. Lower priority, and the
142
 *			block layer could (in theory) choose to ignore this
143
144
 *			request if it runs into resource problems.
 * WRITE		A normal async write. Device will be plugged.
Jens Axboe's avatar
Jens Axboe committed
145
 * WRITE_SYNC		Synchronous write. Identical to WRITE, but passes down
146
 *			the hint that someone will be waiting on this IO
Jens Axboe's avatar
Jens Axboe committed
147
148
 *			shortly. The write equivalent of READ_SYNC.
 * WRITE_ODIRECT	Special case write for O_DIRECT only.
149
150
151
152
153
154
 * WRITE_FLUSH		Like WRITE_SYNC but with preceding cache flush.
 * WRITE_FUA		Like WRITE_SYNC but data is guaranteed to be on
 *			non-volatile media on completion.
 * WRITE_FLUSH_FUA	Combination of WRITE_FLUSH and FUA. The IO is preceded
 *			by a cache flush and data is guaranteed to be on
 *			non-volatile media on completion.
155
156
 *
 */
157
158
#define RW_MASK			REQ_WRITE
#define RWA_MASK		REQ_RAHEAD
159
160

#define READ			0
161
162
#define WRITE			RW_MASK
#define READA			RWA_MASK
163

Jens Axboe's avatar
Jens Axboe committed
164
#define READ_SYNC		(READ | REQ_SYNC)
165
#define READ_META		(READ | REQ_META)
Jens Axboe's avatar
Jens Axboe committed
166
167
#define WRITE_SYNC		(WRITE | REQ_SYNC | REQ_NOIDLE)
#define WRITE_ODIRECT		(WRITE | REQ_SYNC)
168
#define WRITE_META		(WRITE | REQ_META)
Jens Axboe's avatar
Jens Axboe committed
169
170
171
#define WRITE_FLUSH		(WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH)
#define WRITE_FUA		(WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FUA)
#define WRITE_FLUSH_FUA		(WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH | REQ_FUA)
Linus Torvalds's avatar
Linus Torvalds committed
172
173
174
175
176
177
178
179

#define SEL_IN		1
#define SEL_OUT		2
#define SEL_EX		4

/* public flags for file_system_type */
#define FS_REQUIRES_DEV 1 
#define FS_BINARY_MOUNTDATA 2
180
#define FS_HAS_SUBTYPE 4
Linus Torvalds's avatar
Linus Torvalds committed
181
#define FS_REVAL_DOT	16384	/* Check the paths ".", ".." for staleness */
182
183
184
185
#define FS_RENAME_DOES_D_MOVE	32768	/* FS will handle d_move()
					 * during rename() internally.
					 */

Linus Torvalds's avatar
Linus Torvalds committed
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
/*
 * These are the fs-independent mount-flags: up to 32 flags are supported
 */
#define MS_RDONLY	 1	/* Mount read-only */
#define MS_NOSUID	 2	/* Ignore suid and sgid bits */
#define MS_NODEV	 4	/* Disallow access to device special files */
#define MS_NOEXEC	 8	/* Disallow program execution */
#define MS_SYNCHRONOUS	16	/* Writes are synced at once */
#define MS_REMOUNT	32	/* Alter flags of a mounted FS */
#define MS_MANDLOCK	64	/* Allow mandatory locks on an FS */
#define MS_DIRSYNC	128	/* Directory modifications are synchronous */
#define MS_NOATIME	1024	/* Do not update access times. */
#define MS_NODIRATIME	2048	/* Do not update directory access times */
#define MS_BIND		4096
#define MS_MOVE		8192
#define MS_REC		16384
202
203
204
#define MS_VERBOSE	32768	/* War is peace. Verbosity is silence.
				   MS_VERBOSE is deprecated. */
#define MS_SILENT	32768
205
#define MS_POSIXACL	(1<<16)	/* VFS does not apply the umask */
Ram Pai's avatar
Ram Pai committed
206
#define MS_UNBINDABLE	(1<<17)	/* change to unbindable */
207
#define MS_PRIVATE	(1<<18)	/* change to private */
Ram Pai's avatar
Ram Pai committed
208
#define MS_SLAVE	(1<<19)	/* change to slave */
Ram Pai's avatar
Ram Pai committed
209
#define MS_SHARED	(1<<20)	/* change to shared */
Valerie Henson's avatar
Valerie Henson committed
210
#define MS_RELATIME	(1<<21)	/* Update atime relative to mtime/ctime. */
211
#define MS_KERNMOUNT	(1<<22) /* this is a kern_mount call */
212
#define MS_I_VERSION	(1<<23) /* Update inode I_version field */
213
#define MS_STRICTATIME	(1<<24) /* Always perform atime updates */
Al Viro's avatar
Al Viro committed
214
#define MS_NOSEC	(1<<28)
Al Viro's avatar
Al Viro committed
215
#define MS_BORN		(1<<29)
Linus Torvalds's avatar
Linus Torvalds committed
216
217
218
219
220
221
#define MS_ACTIVE	(1<<30)
#define MS_NOUSER	(1<<31)

/*
 * Superblock flags that can be altered by MS_REMOUNT
 */
222
#define MS_RMT_MASK	(MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

/*
 * Old magic mount flag and mask
 */
#define MS_MGC_VAL 0xC0ED0000
#define MS_MGC_MSK 0xffff0000

/* Inode flags - they have nothing to superblock flags now */

#define S_SYNC		1	/* Writes are synced at once */
#define S_NOATIME	2	/* Do not update access times */
#define S_APPEND	4	/* Append-only file */
#define S_IMMUTABLE	8	/* Immutable file */
#define S_DEAD		16	/* removed, but still open directory */
#define S_NOQUOTA	32	/* Inode is not counted to quota */
#define S_DIRSYNC	64	/* Directory modifications are synchronous */
#define S_NOCMTIME	128	/* Do not update file c/mtime */
#define S_SWAPFILE	256	/* Do not truncate: swapon got its bmaps */
#define S_PRIVATE	512	/* Inode is fs-internal */
242
#define S_IMA		1024	/* Inode has an associated IMA struct */
243
#define S_AUTOMOUNT	2048	/* Automount/referral quasi-directory */
244
#define S_NOSEC		4096	/* no suid or xattr security attributes */
Linus Torvalds's avatar
Linus Torvalds committed
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

/*
 * Note that nosuid etc flags are inode-specific: setting some file-system
 * flags just means all the inodes inherit those flags by default. It might be
 * possible to override it selectively if you really wanted to with some
 * ioctl() that is not currently implemented.
 *
 * Exception: MS_RDONLY is always applied to the entire file system.
 *
 * Unfortunately, it is possible to change a filesystems flags with it mounted
 * with files in use.  This means that all of the inodes will not have their
 * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
 * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
 */
#define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))

#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
#define IS_SYNC(inode)		(__IS_FLG(inode, MS_SYNCHRONOUS) || \
					((inode)->i_flags & S_SYNC))
#define IS_DIRSYNC(inode)	(__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
					((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
#define IS_MANDLOCK(inode)	__IS_FLG(inode, MS_MANDLOCK)
267
#define IS_NOATIME(inode)   __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
268
#define IS_I_VERSION(inode)   __IS_FLG(inode, MS_I_VERSION)
Linus Torvalds's avatar
Linus Torvalds committed
269
270
271
272
273
274
275
276
277
278

#define IS_NOQUOTA(inode)	((inode)->i_flags & S_NOQUOTA)
#define IS_APPEND(inode)	((inode)->i_flags & S_APPEND)
#define IS_IMMUTABLE(inode)	((inode)->i_flags & S_IMMUTABLE)
#define IS_POSIXACL(inode)	__IS_FLG(inode, MS_POSIXACL)

#define IS_DEADDIR(inode)	((inode)->i_flags & S_DEAD)
#define IS_NOCMTIME(inode)	((inode)->i_flags & S_NOCMTIME)
#define IS_SWAPFILE(inode)	((inode)->i_flags & S_SWAPFILE)
#define IS_PRIVATE(inode)	((inode)->i_flags & S_PRIVATE)
279
#define IS_IMA(inode)		((inode)->i_flags & S_IMA)
280
#define IS_AUTOMOUNT(inode)	((inode)->i_flags & S_AUTOMOUNT)
281
#define IS_NOSEC(inode)		((inode)->i_flags & S_NOSEC)
Linus Torvalds's avatar
Linus Torvalds committed
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311

/* the read-only stuff doesn't really belong here, but any other place is
   probably as bad and I don't want to create yet another include file. */

#define BLKROSET   _IO(0x12,93)	/* set device read-only (0 = read-write) */
#define BLKROGET   _IO(0x12,94)	/* get read-only status (0 = read_write) */
#define BLKRRPART  _IO(0x12,95)	/* re-read partition table */
#define BLKGETSIZE _IO(0x12,96)	/* return device size /512 (long *arg) */
#define BLKFLSBUF  _IO(0x12,97)	/* flush buffer cache */
#define BLKRASET   _IO(0x12,98)	/* set read ahead for block device */
#define BLKRAGET   _IO(0x12,99)	/* get current read ahead setting */
#define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
#define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
#define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
#define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
#define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
#if 0
#define BLKPG      _IO(0x12,105)/* See blkpg.h */

/* Some people are morons.  Do not use sizeof! */

#define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
#define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
/* This was here just to show that the number is taken -
   probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
#endif
/* A jump here: 108-111 have been used for various private purposes. */
#define BLKBSZGET  _IOR(0x12,112,size_t)
#define BLKBSZSET  _IOW(0x12,113,size_t)
#define BLKGETSIZE64 _IOR(0x12,114,size_t)	/* return device size in bytes (u64 *arg) */
312
313
314
315
#define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
#define BLKTRACESTART _IO(0x12,116)
#define BLKTRACESTOP _IO(0x12,117)
#define BLKTRACETEARDOWN _IO(0x12,118)
316
#define BLKDISCARD _IO(0x12,119)
Martin K. Petersen's avatar
Martin K. Petersen committed
317
318
319
320
#define BLKIOMIN _IO(0x12,120)
#define BLKIOOPT _IO(0x12,121)
#define BLKALIGNOFF _IO(0x12,122)
#define BLKPBSZGET _IO(0x12,123)
321
#define BLKDISCARDZEROES _IO(0x12,124)
Adrian Hunter's avatar
Adrian Hunter committed
322
#define BLKSECDISCARD _IO(0x12,125)
Linus Torvalds's avatar
Linus Torvalds committed
323
324
325
326

#define BMAP_IOCTL 1		/* obsolete - kept for compatibility */
#define FIBMAP	   _IO(0x00,1)	/* bmap access */
#define FIGETBSZ   _IO(0x00,2)	/* get the block size used for bmap */
327
328
#define FIFREEZE	_IOWR('X', 119, int)	/* Freeze */
#define FITHAW		_IOWR('X', 120, int)	/* Thaw */
Lukas Czerner's avatar
Lukas Czerner committed
329
#define FITRIM		_IOWR('X', 121, struct fstrim_range)	/* Trim */
Linus Torvalds's avatar
Linus Torvalds committed
330

331
332
333
334
#define	FS_IOC_GETFLAGS			_IOR('f', 1, long)
#define	FS_IOC_SETFLAGS			_IOW('f', 2, long)
#define	FS_IOC_GETVERSION		_IOR('v', 1, long)
#define	FS_IOC_SETVERSION		_IOW('v', 2, long)
Mark Fasheh's avatar
Mark Fasheh committed
335
#define FS_IOC_FIEMAP			_IOWR('f', 11, struct fiemap)
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
#define FS_IOC32_GETFLAGS		_IOR('f', 1, int)
#define FS_IOC32_SETFLAGS		_IOW('f', 2, int)
#define FS_IOC32_GETVERSION		_IOR('v', 1, int)
#define FS_IOC32_SETVERSION		_IOW('v', 2, int)

/*
 * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
 */
#define	FS_SECRM_FL			0x00000001 /* Secure deletion */
#define	FS_UNRM_FL			0x00000002 /* Undelete */
#define	FS_COMPR_FL			0x00000004 /* Compress file */
#define FS_SYNC_FL			0x00000008 /* Synchronous updates */
#define FS_IMMUTABLE_FL			0x00000010 /* Immutable file */
#define FS_APPEND_FL			0x00000020 /* writes to file may only append */
#define FS_NODUMP_FL			0x00000040 /* do not dump file */
#define FS_NOATIME_FL			0x00000080 /* do not update atime */
/* Reserved for compression usage... */
#define FS_DIRTY_FL			0x00000100
#define FS_COMPRBLK_FL			0x00000200 /* One or more compressed clusters */
#define FS_NOCOMP_FL			0x00000400 /* Don't compress */
#define FS_ECOMPR_FL			0x00000800 /* Compression error */
/* End compression flags --- maybe not all used */
#define FS_BTREE_FL			0x00001000 /* btree format dir */
#define FS_INDEX_FL			0x00001000 /* hash-indexed directory */
#define FS_IMAGIC_FL			0x00002000 /* AFS directory */
#define FS_JOURNAL_DATA_FL		0x00004000 /* Reserved for ext3 */
#define FS_NOTAIL_FL			0x00008000 /* file tail should not be merged */
#define FS_DIRSYNC_FL			0x00010000 /* dirsync behaviour (directories only) */
#define FS_TOPDIR_FL			0x00020000 /* Top of directory hierarchies*/
365
366
#define FS_EXTENT_FL			0x00080000 /* Extents */
#define FS_DIRECTIO_FL			0x00100000 /* Use direct i/o */
liubo's avatar
liubo committed
367
#define FS_NOCOW_FL			0x00800000 /* Do not cow file */
368
369
370
371
372
373
#define FS_RESERVED_FL			0x80000000 /* reserved for ext2 lib */

#define FS_FL_USER_VISIBLE		0x0003DFFF /* User visible flags */
#define FS_FL_USER_MODIFIABLE		0x000380FF /* User modifiable flags */


374
375
376
377
#define SYNC_FILE_RANGE_WAIT_BEFORE	1
#define SYNC_FILE_RANGE_WRITE		2
#define SYNC_FILE_RANGE_WAIT_AFTER	4

Linus Torvalds's avatar
Linus Torvalds committed
378
379
380
381
382
383
#ifdef __KERNEL__

#include <linux/linkage.h>
#include <linux/wait.h>
#include <linux/kdev_t.h>
#include <linux/dcache.h>
384
#include <linux/path.h>
Linus Torvalds's avatar
Linus Torvalds committed
385
386
387
388
389
390
#include <linux/stat.h>
#include <linux/cache.h>
#include <linux/list.h>
#include <linux/radix-tree.h>
#include <linux/prio_tree.h>
#include <linux/init.h>
391
#include <linux/pid.h>
392
#include <linux/mutex.h>
393
#include <linux/capability.h>
394
#include <linux/semaphore.h>
Mark Fasheh's avatar
Mark Fasheh committed
395
#include <linux/fiemap.h>
396
#include <linux/rculist_bl.h>
397
#include <linux/shrinker.h>
398
#include <linux/atomic.h>
Linus Torvalds's avatar
Linus Torvalds committed
399
400
401

#include <asm/byteorder.h>

402
struct export_operations;
403
struct hd_geometry;
Linus Torvalds's avatar
Linus Torvalds committed
404
405
struct iovec;
struct nameidata;
406
struct kiocb;
Alexey Dobriyan's avatar
Alexey Dobriyan committed
407
struct kobject;
Linus Torvalds's avatar
Linus Torvalds committed
408
409
410
411
412
struct pipe_inode_info;
struct poll_table_struct;
struct kstatfs;
struct vm_area_struct;
struct vfsmount;
413
struct cred;
Linus Torvalds's avatar
Linus Torvalds committed
414

415
extern void __init inode_init(void);
Linus Torvalds's avatar
Linus Torvalds committed
416
417
418
extern void __init inode_init_early(void);
extern void __init files_init(unsigned long);

419
extern struct files_stat_struct files_stat;
420
extern unsigned long get_max_files(void);
421
422
423
424
extern int sysctl_nr_open;
extern struct inodes_stat_t inodes_stat;
extern int leases_enable, lease_break_time;

Linus Torvalds's avatar
Linus Torvalds committed
425
426
427
struct buffer_head;
typedef int (get_block_t)(struct inode *inode, sector_t iblock,
			struct buffer_head *bh_result, int create);
428
typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
429
430
			ssize_t bytes, void *private, int ret,
			bool is_async);
Linus Torvalds's avatar
Linus Torvalds committed
431
432
433
434
435

/*
 * Attribute flags.  These should be or-ed together to figure out what
 * has been changed!
 */
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
#define ATTR_MODE	(1 << 0)
#define ATTR_UID	(1 << 1)
#define ATTR_GID	(1 << 2)
#define ATTR_SIZE	(1 << 3)
#define ATTR_ATIME	(1 << 4)
#define ATTR_MTIME	(1 << 5)
#define ATTR_CTIME	(1 << 6)
#define ATTR_ATIME_SET	(1 << 7)
#define ATTR_MTIME_SET	(1 << 8)
#define ATTR_FORCE	(1 << 9) /* Not a change, but a change it */
#define ATTR_ATTR_FLAG	(1 << 10)
#define ATTR_KILL_SUID	(1 << 11)
#define ATTR_KILL_SGID	(1 << 12)
#define ATTR_FILE	(1 << 13)
#define ATTR_KILL_PRIV	(1 << 14)
#define ATTR_OPEN	(1 << 15) /* Truncating from open(O_TRUNC) */
#define ATTR_TIMES_SET	(1 << 16)
Linus Torvalds's avatar
Linus Torvalds committed
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471

/*
 * This is the Inode Attributes structure, used for notify_change().  It
 * uses the above definitions as flags, to know which values have changed.
 * Also, in this manner, a Filesystem can look at only the values it cares
 * about.  Basically, these are the attributes that the VFS layer can
 * request to change from the FS layer.
 *
 * Derek Atkins <warlord@MIT.EDU> 94-10-20
 */
struct iattr {
	unsigned int	ia_valid;
	umode_t		ia_mode;
	uid_t		ia_uid;
	gid_t		ia_gid;
	loff_t		ia_size;
	struct timespec	ia_atime;
	struct timespec	ia_mtime;
	struct timespec	ia_ctime;
472
473

	/*
Lucas De Marchi's avatar
Lucas De Marchi committed
474
	 * Not an attribute, but an auxiliary info for filesystems wanting to
475
476
477
478
	 * implement an ftruncate() like method.  NOTE: filesystem should
	 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
	 */
	struct file	*ia_file;
Linus Torvalds's avatar
Linus Torvalds committed
479
480
481
482
483
484
485
};

/*
 * Includes for diskquotas.
 */
#include <linux/quota.h>

486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
/** 
 * enum positive_aop_returns - aop return codes with specific semantics
 *
 * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
 * 			    completed, that the page is still locked, and
 * 			    should be considered active.  The VM uses this hint
 * 			    to return the page to the active list -- it won't
 * 			    be a candidate for writeback again in the near
 * 			    future.  Other callers must be careful to unlock
 * 			    the page if they get this return.  Returned by
 * 			    writepage(); 
 *
 * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
 *  			unlocked it and the page might have been truncated.
 *  			The caller should back up to acquiring a new page and
 *  			trying again.  The aop will be taking reasonable
 *  			precautions not to livelock.  If the caller held a page
 *  			reference, it should drop it before retrying.  Returned
504
 *  			by readpage().
505
506
507
508
509
510
511
512
513
514
515
516
 *
 * address_space_operation functions return these large constants to indicate
 * special semantics to the caller.  These are much larger than the bytes in a
 * page to allow for functions that return the number of bytes operated on in a
 * given page.
 */

enum positive_aop_returns {
	AOP_WRITEPAGE_ACTIVATE	= 0x80000,
	AOP_TRUNCATED_PAGE	= 0x80001,
};

517
#define AOP_FLAG_UNINTERRUPTIBLE	0x0001 /* will not do a short write */
Nick Piggin's avatar
Nick Piggin committed
518
#define AOP_FLAG_CONT_EXPAND		0x0002 /* called from cont_expand */
519
520
521
#define AOP_FLAG_NOFS			0x0004 /* used by filesystem to direct
						* helper code (eg buffer layer)
						* to clear GFP_FS from alloc */
522

Linus Torvalds's avatar
Linus Torvalds committed
523
524
525
526
527
528
529
/*
 * oh the beauties of C type declarations.
 */
struct page;
struct address_space;
struct writeback_control;

Nick Piggin's avatar
Nick Piggin committed
530
531
532
533
534
535
536
537
538
539
540
541
struct iov_iter {
	const struct iovec *iov;
	unsigned long nr_segs;
	size_t iov_offset;
	size_t count;
};

size_t iov_iter_copy_from_user_atomic(struct page *page,
		struct iov_iter *i, unsigned long offset, size_t bytes);
size_t iov_iter_copy_from_user(struct page *page,
		struct iov_iter *i, unsigned long offset, size_t bytes);
void iov_iter_advance(struct iov_iter *i, size_t bytes);
542
int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
Nick Piggin's avatar
Nick Piggin committed
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
size_t iov_iter_single_seg_count(struct iov_iter *i);

static inline void iov_iter_init(struct iov_iter *i,
			const struct iovec *iov, unsigned long nr_segs,
			size_t count, size_t written)
{
	i->iov = iov;
	i->nr_segs = nr_segs;
	i->iov_offset = 0;
	i->count = count + written;

	iov_iter_advance(i, written);
}

static inline size_t iov_iter_count(struct iov_iter *i)
{
	return i->count;
}

562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
/*
 * "descriptor" for what we're up to with a read.
 * This allows us to use the same read code yet
 * have multiple different users of the data that
 * we read from a file.
 *
 * The simplest case just copies the data to user
 * mode.
 */
typedef struct {
	size_t written;
	size_t count;
	union {
		char __user *buf;
		void *data;
	} arg;
	int error;
} read_descriptor_t;

typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
		unsigned long, unsigned long);
Nick Piggin's avatar
Nick Piggin committed
583

Linus Torvalds's avatar
Linus Torvalds committed
584
585
586
587
588
589
590
struct address_space_operations {
	int (*writepage)(struct page *page, struct writeback_control *wbc);
	int (*readpage)(struct file *, struct page *);

	/* Write back some dirty pages from this mapping. */
	int (*writepages)(struct address_space *, struct writeback_control *);

591
	/* Set a page dirty.  Return true if this dirtied it */
Linus Torvalds's avatar
Linus Torvalds committed
592
593
594
595
596
	int (*set_page_dirty)(struct page *page);

	int (*readpages)(struct file *filp, struct address_space *mapping,
			struct list_head *pages, unsigned nr_pages);

597
598
599
600
601
602
603
	int (*write_begin)(struct file *, struct address_space *mapping,
				loff_t pos, unsigned len, unsigned flags,
				struct page **pagep, void **fsdata);
	int (*write_end)(struct file *, struct address_space *mapping,
				loff_t pos, unsigned len, unsigned copied,
				struct page *page, void *fsdata);

Linus Torvalds's avatar
Linus Torvalds committed
604
605
	/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
	sector_t (*bmap)(struct address_space *, sector_t);
606
	void (*invalidatepage) (struct page *, unsigned long);
Al Viro's avatar
Al Viro committed
607
	int (*releasepage) (struct page *, gfp_t);
608
	void (*freepage)(struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
609
610
	ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
			loff_t offset, unsigned long nr_segs);
611
612
	int (*get_xip_mem)(struct address_space *, pgoff_t, int,
						void **, unsigned long *);
613
	/* migrate the contents of a page to the specified target */
614
615
	int (*migratepage) (struct address_space *,
			struct page *, struct page *);
616
	int (*launder_page) (struct page *);
617
618
	int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
					unsigned long);
619
	int (*error_remove_page)(struct address_space *, struct page *);
Linus Torvalds's avatar
Linus Torvalds committed
620
621
};

Jens Axboe's avatar
Jens Axboe committed
622
623
extern const struct address_space_operations empty_aops;

624
625
626
627
628
629
630
631
632
633
634
635
/*
 * pagecache_write_begin/pagecache_write_end must be used by general code
 * to write into the pagecache.
 */
int pagecache_write_begin(struct file *, struct address_space *mapping,
				loff_t pos, unsigned len, unsigned flags,
				struct page **pagep, void **fsdata);

int pagecache_write_end(struct file *, struct address_space *mapping,
				loff_t pos, unsigned len, unsigned copied,
				struct page *page, void *fsdata);

Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639
struct backing_dev_info;
struct address_space {
	struct inode		*host;		/* owner: inode, block_device */
	struct radix_tree_root	page_tree;	/* radix tree of all pages */
Nick Piggin's avatar
Nick Piggin committed
640
	spinlock_t		tree_lock;	/* and lock protecting it */
Linus Torvalds's avatar
Linus Torvalds committed
641
642
643
	unsigned int		i_mmap_writable;/* count VM_SHARED mappings */
	struct prio_tree_root	i_mmap;		/* tree of private and shared mappings */
	struct list_head	i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
644
	struct mutex		i_mmap_mutex;	/* protect tree, count, list */
645
	/* Protected by tree_lock together with the radix tree */
Linus Torvalds's avatar
Linus Torvalds committed
646
647
	unsigned long		nrpages;	/* number of total pages */
	pgoff_t			writeback_index;/* writeback starts here */
648
	const struct address_space_operations *a_ops;	/* methods */
Linus Torvalds's avatar
Linus Torvalds committed
649
650
651
652
653
654
655
656
	unsigned long		flags;		/* error bits/gfp mask */
	struct backing_dev_info *backing_dev_info; /* device readahead, etc */
	spinlock_t		private_lock;	/* for use by the address_space */
	struct list_head	private_list;	/* ditto */
	struct address_space	*assoc_mapping;	/* ditto */
} __attribute__((aligned(sizeof(long))));
	/*
	 * On most architectures that alignment is already the case; but
Lucas De Marchi's avatar
Lucas De Marchi committed
657
	 * must be enforced here for CRIS, to let the least significant bit
Linus Torvalds's avatar
Linus Torvalds committed
658
659
660
661
662
	 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
	 */

struct block_device {
	dev_t			bd_dev;  /* not a kdev_t - it's a search key */
663
	int			bd_openers;
Linus Torvalds's avatar
Linus Torvalds committed
664
	struct inode *		bd_inode;	/* will die */
665
	struct super_block *	bd_super;
666
	struct mutex		bd_mutex;	/* open/close mutex */
Linus Torvalds's avatar
Linus Torvalds committed
667
	struct list_head	bd_inodes;
668
	void *			bd_claiming;
Linus Torvalds's avatar
Linus Torvalds committed
669
670
	void *			bd_holder;
	int			bd_holders;
671
	bool			bd_write_holder;
672
#ifdef CONFIG_SYSFS
673
	struct list_head	bd_holder_disks;
674
#endif
Linus Torvalds's avatar
Linus Torvalds committed
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
	struct block_device *	bd_contains;
	unsigned		bd_block_size;
	struct hd_struct *	bd_part;
	/* number of times partitions within this device have been opened. */
	unsigned		bd_part_count;
	int			bd_invalidated;
	struct gendisk *	bd_disk;
	struct list_head	bd_list;
	/*
	 * Private data.  You must have bd_claim'ed the block_device
	 * to use this.  NOTE:  bd_claim allows an owner to claim
	 * the same device multiple times, the owner must take special
	 * care to not mess up bd_private for that case.
	 */
	unsigned long		bd_private;
690
691
692
693
694

	/* The counter of freeze processes */
	int			bd_fsfreeze_count;
	/* Mutex for freeze */
	struct mutex		bd_fsfreeze_mutex;
Linus Torvalds's avatar
Linus Torvalds committed
695
696
697
698
699
700
701
702
};

/*
 * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
 * radix trees
 */
#define PAGECACHE_TAG_DIRTY	0
#define PAGECACHE_TAG_WRITEBACK	1
703
#define PAGECACHE_TAG_TOWRITE	2
Linus Torvalds's avatar
Linus Torvalds committed
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737

int mapping_tagged(struct address_space *mapping, int tag);

/*
 * Might pages of this file be mapped into userspace?
 */
static inline int mapping_mapped(struct address_space *mapping)
{
	return	!prio_tree_empty(&mapping->i_mmap) ||
		!list_empty(&mapping->i_mmap_nonlinear);
}

/*
 * Might pages of this file have been modified in userspace?
 * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
 * marks vma as VM_SHARED if it is shared, and the file was opened for
 * writing i.e. vma may be mprotected writable even if now readonly.
 */
static inline int mapping_writably_mapped(struct address_space *mapping)
{
	return mapping->i_mmap_writable != 0;
}

/*
 * Use sequence counter to get consistent i_size on 32-bit processors.
 */
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
#include <linux/seqlock.h>
#define __NEED_I_SIZE_ORDERED
#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
#else
#define i_size_ordered_init(inode) do { } while (0)
#endif

Al Viro's avatar
Al Viro committed
738
739
740
struct posix_acl;
#define ACL_NOT_CACHED ((void *)(-1))

741
742
743
744
745
746
747
748
749
#define IOP_FASTPERM	0x0001
#define IOP_LOOKUP	0x0002
#define IOP_NOFOLLOW	0x0004

/*
 * Keep mostly read-only and often accessed (especially for
 * the RCU path lookup and 'stat' data) fields at the beginning
 * of the 'struct inode'
 */
Linus Torvalds's avatar
Linus Torvalds committed
750
struct inode {
751
	umode_t			i_mode;
752
	unsigned short		i_opflags;
753
754
	uid_t			i_uid;
	gid_t			i_gid;
755
756
757
758
759
760
761
	unsigned int		i_flags;

#ifdef CONFIG_FS_POSIX_ACL
	struct posix_acl	*i_acl;
	struct posix_acl	*i_default_acl;
#endif

762
763
	const struct inode_operations	*i_op;
	struct super_block	*i_sb;
764
	struct address_space	*i_mapping;
765

766
767
768
#ifdef CONFIG_SECURITY
	void			*i_security;
#endif
769

770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
	/* Stat data, not accessed from path walking */
	unsigned long		i_ino;
	unsigned int		i_nlink;
	dev_t			i_rdev;
	loff_t			i_size;
	struct timespec		i_atime;
	struct timespec		i_mtime;
	struct timespec		i_ctime;
	unsigned int		i_blkbits;
	blkcnt_t		i_blocks;

#ifdef __NEED_I_SIZE_ORDERED
	seqcount_t		i_size_seqcount;
#endif

	/* Misc */
	unsigned long		i_state;
	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
	struct mutex		i_mutex;
789

790
791
	unsigned long		dirtied_when;	/* jiffies of first dirtying */

Linus Torvalds's avatar
Linus Torvalds committed
792
	struct hlist_node	i_hash;
Nick Piggin's avatar
Nick Piggin committed
793
794
	struct list_head	i_wb_list;	/* backing dev IO list */
	struct list_head	i_lru;		/* inode LRU list */
Linus Torvalds's avatar
Linus Torvalds committed
795
	struct list_head	i_sb_list;
Nick Piggin's avatar
Nick Piggin committed
796
797
798
799
	union {
		struct list_head	i_dentry;
		struct rcu_head		i_rcu;
	};
Linus Torvalds's avatar
Linus Torvalds committed
800
	atomic_t		i_count;
801
	u64			i_version;
Linus Torvalds's avatar
Linus Torvalds committed
802
	unsigned short          i_bytes;
Christoph Hellwig's avatar
Christoph Hellwig committed
803
	atomic_t		i_dio_count;
804
	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
Linus Torvalds's avatar
Linus Torvalds committed
805
806
807
808
809
810
	struct file_lock	*i_flock;
	struct address_space	i_data;
#ifdef CONFIG_QUOTA
	struct dquot		*i_dquot[MAXQUOTAS];
#endif
	struct list_head	i_devices;
811
812
	union {
		struct pipe_inode_info	*i_pipe;
813
		struct block_device	*i_bdev;
814
		struct cdev		*i_cdev;
815
	};
Linus Torvalds's avatar
Linus Torvalds committed
816
817
818

	__u32			i_generation;

819
820
#ifdef CONFIG_FSNOTIFY
	__u32			i_fsnotify_mask; /* all events this inode cares about */
821
	struct hlist_head	i_fsnotify_marks;
Robert Love's avatar
Robert Love committed
822
823
#endif

824
#ifdef CONFIG_IMA
825
	atomic_t		i_readcount; /* struct files open RO */
826
#endif
Linus Torvalds's avatar
Linus Torvalds committed
827
	atomic_t		i_writecount;
828
	void			*i_private; /* fs or device private pointer */
Linus Torvalds's avatar
Linus Torvalds committed
829
830
};

Al Viro's avatar
Al Viro committed
831
832
833
834
835
static inline int inode_unhashed(struct inode *inode)
{
	return hlist_unhashed(&inode->i_hash);
}

836
837
838
839
840
841
842
843
844
/*
 * inode->i_mutex nesting subclasses for the lock validator:
 *
 * 0: the object of the current VFS operation
 * 1: parent
 * 2: child/target
 * 3: quota file
 *
 * The locking order between these classes is
845
 * parent -> child -> normal -> xattr -> quota
846
847
848
849
850
851
 */
enum inode_i_mutex_lock_class
{
	I_MUTEX_NORMAL,
	I_MUTEX_PARENT,
	I_MUTEX_CHILD,
852
	I_MUTEX_XATTR,
853
854
855
	I_MUTEX_QUOTA
};

Linus Torvalds's avatar
Linus Torvalds committed
856
857
858
859
860
861
862
863
864
865
/*
 * NOTE: in a 32bit arch with a preemptable kernel and
 * an UP compile the i_size_read/write must be atomic
 * with respect to the local cpu (unlike with preempt disabled),
 * but they don't need to be atomic with respect to other cpus like in
 * true SMP (so they need either to either locally disable irq around
 * the read or for example on x86 they can be still implemented as a
 * cmpxchg8b without the need of the lock prefix). For SMP compiles
 * and 64bit archs it makes no difference if preempt is enabled or not.
 */
866
static inline loff_t i_size_read(const struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
{
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
	loff_t i_size;
	unsigned int seq;

	do {
		seq = read_seqcount_begin(&inode->i_size_seqcount);
		i_size = inode->i_size;
	} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
	return i_size;
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
	loff_t i_size;

	preempt_disable();
	i_size = inode->i_size;
	preempt_enable();
	return i_size;
#else
	return inode->i_size;
#endif
}

889
890
891
892
893
/*
 * NOTE: unlike i_size_read(), i_size_write() does need locking around it
 * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
 * can be lost, resulting in subsequent i_size_read() calls spinning forever.
 */
Linus Torvalds's avatar
Linus Torvalds committed
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
static inline void i_size_write(struct inode *inode, loff_t i_size)
{
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
	write_seqcount_begin(&inode->i_size_seqcount);
	inode->i_size = i_size;
	write_seqcount_end(&inode->i_size_seqcount);
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
	preempt_disable();
	inode->i_size = i_size;
	preempt_enable();
#else
	inode->i_size = i_size;
#endif
}

909
static inline unsigned iminor(const struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
910
911
912
913
{
	return MINOR(inode->i_rdev);
}

914
static inline unsigned imajor(const struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
915
916
917
918
919
920
921
922
{
	return MAJOR(inode->i_rdev);
}

extern struct block_device *I_BDEV(struct inode *inode);

struct fown_struct {
	rwlock_t lock;          /* protects pid, uid, euid fields */
923
924
	struct pid *pid;	/* pid or -pgrp where SIGIO should be sent */
	enum pid_type pid_type;	/* Kind of process group SIGIO should be sent to */
Linus Torvalds's avatar
Linus Torvalds committed
925
926
927
928
929
930
931
932
	uid_t uid, euid;	/* uid/euid of process setting the owner */
	int signum;		/* posix.1b rt signal to be delivered on IO */
};

/*
 * Track a single file's readahead state
 */
struct file_ra_state {
933
934
935
	pgoff_t start;			/* where readahead started */
	unsigned int size;		/* # of readahead pages */
	unsigned int async_size;	/* do asynchronous readahead when
936
					   there are only # of pages ahead */
937

938
	unsigned int ra_pages;		/* Maximum readahead window */
939
	unsigned int mmap_miss;		/* Cache miss stat for mmap accesses */
940
	loff_t prev_pos;		/* Cache last read() position */
Linus Torvalds's avatar
Linus Torvalds committed
941
942
};

943
944
945
946
947
/*
 * Check if @index falls in the readahead windows.
 */
static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
{
948
949
	return (index >= ra->start &&
		index <  ra->start + ra->size);
950
951
}

952
953
954
#define FILE_MNT_WRITE_TAKEN	1
#define FILE_MNT_WRITE_RELEASED	2

Linus Torvalds's avatar
Linus Torvalds committed
955
struct file {
956
957
958
959
960
961
962
963
	/*
	 * fu_list becomes invalid after file_free is called and queued via
	 * fu_rcuhead for RCU freeing
	 */
	union {
		struct list_head	fu_list;
		struct rcu_head 	fu_rcuhead;
	} f_u;
964
965
966
	struct path		f_path;
#define f_dentry	f_path.dentry
#define f_vfsmnt	f_path.mnt
967
	const struct file_operations	*f_op;
968
	spinlock_t		f_lock;  /* f_ep_links, f_flags, no IRQ */
Nick Piggin's avatar
Nick Piggin committed
969
970
971
#ifdef CONFIG_SMP
	int			f_sb_list_cpu;
#endif
Al Viro's avatar
Al Viro committed
972
	atomic_long_t		f_count;
Linus Torvalds's avatar
Linus Torvalds committed
973
	unsigned int 		f_flags;
974
	fmode_t			f_mode;
Linus Torvalds's avatar
Linus Torvalds committed
975
976
	loff_t			f_pos;
	struct fown_struct	f_owner;
977
	const struct cred	*f_cred;
Linus Torvalds's avatar
Linus Torvalds committed
978
979
	struct file_ra_state	f_ra;

980
	u64			f_version;
981
#ifdef CONFIG_SECURITY
Linus Torvalds's avatar
Linus Torvalds committed
982
	void			*f_security;
983
#endif
Linus Torvalds's avatar
Linus Torvalds committed
984
985
986
987
988
989
990
991
	/* needed for tty driver, and maybe others */
	void			*private_data;

#ifdef CONFIG_EPOLL
	/* Used by fs/eventpoll.c to link all the hooks to this file */
	struct list_head	f_ep_links;
#endif /* #ifdef CONFIG_EPOLL */
	struct address_space	*f_mapping;
992
993
994
#ifdef CONFIG_DEBUG_WRITECOUNT
	unsigned long f_mnt_write_state;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
995
996
};

997
998
999
1000
struct file_handle {
	__u32 handle_bytes;
	int handle_type;
	/* file identifier */