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