Branch data Line data Source code
1 : : #ifndef _LINUX_FS_H
2 : : #define _LINUX_FS_H
3 : :
4 : :
5 : : #include <linux/linkage.h>
6 : : #include <linux/wait.h>
7 : : #include <linux/kdev_t.h>
8 : : #include <linux/dcache.h>
9 : : #include <linux/path.h>
10 : : #include <linux/stat.h>
11 : : #include <linux/cache.h>
12 : : #include <linux/list.h>
13 : : #include <linux/list_lru.h>
14 : : #include <linux/llist.h>
15 : : #include <linux/radix-tree.h>
16 : : #include <linux/rbtree.h>
17 : : #include <linux/init.h>
18 : : #include <linux/pid.h>
19 : : #include <linux/bug.h>
20 : : #include <linux/mutex.h>
21 : : #include <linux/capability.h>
22 : : #include <linux/semaphore.h>
23 : : #include <linux/fiemap.h>
24 : : #include <linux/rculist_bl.h>
25 : : #include <linux/atomic.h>
26 : : #include <linux/shrinker.h>
27 : : #include <linux/migrate_mode.h>
28 : : #include <linux/uidgid.h>
29 : : #include <linux/lockdep.h>
30 : : #include <linux/percpu-rwsem.h>
31 : : #include <linux/blk_types.h>
32 : :
33 : : #include <asm/byteorder.h>
34 : : #include <uapi/linux/fs.h>
35 : :
36 : : struct export_operations;
37 : : struct hd_geometry;
38 : : struct iovec;
39 : : struct nameidata;
40 : : struct kiocb;
41 : : struct kobject;
42 : : struct pipe_inode_info;
43 : : struct poll_table_struct;
44 : : struct kstatfs;
45 : : struct vm_area_struct;
46 : : struct vfsmount;
47 : : struct cred;
48 : : struct swap_info_struct;
49 : : struct seq_file;
50 : : struct workqueue_struct;
51 : :
52 : : extern void __init inode_init(void);
53 : : extern void __init inode_init_early(void);
54 : : extern void __init files_init(unsigned long);
55 : :
56 : : extern struct files_stat_struct files_stat;
57 : : extern unsigned long get_max_files(void);
58 : : extern int sysctl_nr_open;
59 : : extern struct inodes_stat_t inodes_stat;
60 : : extern int leases_enable, lease_break_time;
61 : : extern int sysctl_protected_symlinks;
62 : : extern int sysctl_protected_hardlinks;
63 : :
64 : : struct buffer_head;
65 : : typedef int (get_block_t)(struct inode *inode, sector_t iblock,
66 : : struct buffer_head *bh_result, int create);
67 : : typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
68 : : ssize_t bytes, void *private);
69 : :
70 : : #define MAY_EXEC 0x00000001
71 : : #define MAY_WRITE 0x00000002
72 : : #define MAY_READ 0x00000004
73 : : #define MAY_APPEND 0x00000008
74 : : #define MAY_ACCESS 0x00000010
75 : : #define MAY_OPEN 0x00000020
76 : : #define MAY_CHDIR 0x00000040
77 : : /* called from RCU mode, don't block */
78 : : #define MAY_NOT_BLOCK 0x00000080
79 : :
80 : : /*
81 : : * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
82 : : * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
83 : : */
84 : :
85 : : /* file is open for reading */
86 : : #define FMODE_READ ((__force fmode_t)0x1)
87 : : /* file is open for writing */
88 : : #define FMODE_WRITE ((__force fmode_t)0x2)
89 : : /* file is seekable */
90 : : #define FMODE_LSEEK ((__force fmode_t)0x4)
91 : : /* file can be accessed using pread */
92 : : #define FMODE_PREAD ((__force fmode_t)0x8)
93 : : /* file can be accessed using pwrite */
94 : : #define FMODE_PWRITE ((__force fmode_t)0x10)
95 : : /* File is opened for execution with sys_execve / sys_uselib */
96 : : #define FMODE_EXEC ((__force fmode_t)0x20)
97 : : /* File is opened with O_NDELAY (only set for block devices) */
98 : : #define FMODE_NDELAY ((__force fmode_t)0x40)
99 : : /* File is opened with O_EXCL (only set for block devices) */
100 : : #define FMODE_EXCL ((__force fmode_t)0x80)
101 : : /* File is opened using open(.., 3, ..) and is writeable only for ioctls
102 : : (specialy hack for floppy.c) */
103 : : #define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
104 : : /* 32bit hashes as llseek() offset (for directories) */
105 : : #define FMODE_32BITHASH ((__force fmode_t)0x200)
106 : : /* 64bit hashes as llseek() offset (for directories) */
107 : : #define FMODE_64BITHASH ((__force fmode_t)0x400)
108 : :
109 : : /*
110 : : * Don't update ctime and mtime.
111 : : *
112 : : * Currently a special hack for the XFS open_by_handle ioctl, but we'll
113 : : * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
114 : : */
115 : : #define FMODE_NOCMTIME ((__force fmode_t)0x800)
116 : :
117 : : /* Expect random access pattern */
118 : : #define FMODE_RANDOM ((__force fmode_t)0x1000)
119 : :
120 : : /* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
121 : : #define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
122 : :
123 : : /* File is opened with O_PATH; almost nothing can be done with it */
124 : : #define FMODE_PATH ((__force fmode_t)0x4000)
125 : :
126 : : /* File needs atomic accesses to f_pos */
127 : : #define FMODE_ATOMIC_POS ((__force fmode_t)0x8000)
128 : :
129 : : /* File was opened by fanotify and shouldn't generate fanotify events */
130 : : #define FMODE_NONOTIFY ((__force fmode_t)0x1000000)
131 : :
132 : : /*
133 : : * Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector
134 : : * that indicates that they should check the contents of the iovec are
135 : : * valid, but not check the memory that the iovec elements
136 : : * points too.
137 : : */
138 : : #define CHECK_IOVEC_ONLY -1
139 : :
140 : : /*
141 : : * The below are the various read and write types that we support. Some of
142 : : * them include behavioral modifiers that send information down to the
143 : : * block layer and IO scheduler. Terminology:
144 : : *
145 : : * The block layer uses device plugging to defer IO a little bit, in
146 : : * the hope that we will see more IO very shortly. This increases
147 : : * coalescing of adjacent IO and thus reduces the number of IOs we
148 : : * have to send to the device. It also allows for better queuing,
149 : : * if the IO isn't mergeable. If the caller is going to be waiting
150 : : * for the IO, then he must ensure that the device is unplugged so
151 : : * that the IO is dispatched to the driver.
152 : : *
153 : : * All IO is handled async in Linux. This is fine for background
154 : : * writes, but for reads or writes that someone waits for completion
155 : : * on, we want to notify the block layer and IO scheduler so that they
156 : : * know about it. That allows them to make better scheduling
157 : : * decisions. So when the below references 'sync' and 'async', it
158 : : * is referencing this priority hint.
159 : : *
160 : : * With that in mind, the available types are:
161 : : *
162 : : * READ A normal read operation. Device will be plugged.
163 : : * READ_SYNC A synchronous read. Device is not plugged, caller can
164 : : * immediately wait on this read without caring about
165 : : * unplugging.
166 : : * READA Used for read-ahead operations. Lower priority, and the
167 : : * block layer could (in theory) choose to ignore this
168 : : * request if it runs into resource problems.
169 : : * WRITE A normal async write. Device will be plugged.
170 : : * WRITE_SYNC Synchronous write. Identical to WRITE, but passes down
171 : : * the hint that someone will be waiting on this IO
172 : : * shortly. The write equivalent of READ_SYNC.
173 : : * WRITE_ODIRECT Special case write for O_DIRECT only.
174 : : * WRITE_FLUSH Like WRITE_SYNC but with preceding cache flush.
175 : : * WRITE_FUA Like WRITE_SYNC but data is guaranteed to be on
176 : : * non-volatile media on completion.
177 : : * WRITE_FLUSH_FUA Combination of WRITE_FLUSH and FUA. The IO is preceded
178 : : * by a cache flush and data is guaranteed to be on
179 : : * non-volatile media on completion.
180 : : *
181 : : */
182 : : #define RW_MASK REQ_WRITE
183 : : #define RWA_MASK REQ_RAHEAD
184 : :
185 : : #define READ 0
186 : : #define WRITE RW_MASK
187 : : #define READA RWA_MASK
188 : : #define KERNEL_READ (READ|REQ_KERNEL)
189 : : #define KERNEL_WRITE (WRITE|REQ_KERNEL)
190 : :
191 : : #define READ_SYNC (READ | REQ_SYNC)
192 : : #define WRITE_SYNC (WRITE | REQ_SYNC | REQ_NOIDLE)
193 : : #define WRITE_ODIRECT (WRITE | REQ_SYNC)
194 : : #define WRITE_FLUSH (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH)
195 : : #define WRITE_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FUA)
196 : : #define WRITE_FLUSH_FUA (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH | REQ_FUA)
197 : :
198 : : /*
199 : : * Attribute flags. These should be or-ed together to figure out what
200 : : * has been changed!
201 : : */
202 : : #define ATTR_MODE (1 << 0)
203 : : #define ATTR_UID (1 << 1)
204 : : #define ATTR_GID (1 << 2)
205 : : #define ATTR_SIZE (1 << 3)
206 : : #define ATTR_ATIME (1 << 4)
207 : : #define ATTR_MTIME (1 << 5)
208 : : #define ATTR_CTIME (1 << 6)
209 : : #define ATTR_ATIME_SET (1 << 7)
210 : : #define ATTR_MTIME_SET (1 << 8)
211 : : #define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
212 : : #define ATTR_ATTR_FLAG (1 << 10)
213 : : #define ATTR_KILL_SUID (1 << 11)
214 : : #define ATTR_KILL_SGID (1 << 12)
215 : : #define ATTR_FILE (1 << 13)
216 : : #define ATTR_KILL_PRIV (1 << 14)
217 : : #define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
218 : : #define ATTR_TIMES_SET (1 << 16)
219 : :
220 : : /*
221 : : * This is the Inode Attributes structure, used for notify_change(). It
222 : : * uses the above definitions as flags, to know which values have changed.
223 : : * Also, in this manner, a Filesystem can look at only the values it cares
224 : : * about. Basically, these are the attributes that the VFS layer can
225 : : * request to change from the FS layer.
226 : : *
227 : : * Derek Atkins <warlord@MIT.EDU> 94-10-20
228 : : */
229 : : struct iattr {
230 : : unsigned int ia_valid;
231 : : umode_t ia_mode;
232 : : kuid_t ia_uid;
233 : : kgid_t ia_gid;
234 : : loff_t ia_size;
235 : : struct timespec ia_atime;
236 : : struct timespec ia_mtime;
237 : : struct timespec ia_ctime;
238 : :
239 : : /*
240 : : * Not an attribute, but an auxiliary info for filesystems wanting to
241 : : * implement an ftruncate() like method. NOTE: filesystem should
242 : : * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
243 : : */
244 : : struct file *ia_file;
245 : : };
246 : :
247 : : /*
248 : : * Includes for diskquotas.
249 : : */
250 : : #include <linux/quota.h>
251 : :
252 : : /**
253 : : * enum positive_aop_returns - aop return codes with specific semantics
254 : : *
255 : : * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
256 : : * completed, that the page is still locked, and
257 : : * should be considered active. The VM uses this hint
258 : : * to return the page to the active list -- it won't
259 : : * be a candidate for writeback again in the near
260 : : * future. Other callers must be careful to unlock
261 : : * the page if they get this return. Returned by
262 : : * writepage();
263 : : *
264 : : * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
265 : : * unlocked it and the page might have been truncated.
266 : : * The caller should back up to acquiring a new page and
267 : : * trying again. The aop will be taking reasonable
268 : : * precautions not to livelock. If the caller held a page
269 : : * reference, it should drop it before retrying. Returned
270 : : * by readpage().
271 : : *
272 : : * address_space_operation functions return these large constants to indicate
273 : : * special semantics to the caller. These are much larger than the bytes in a
274 : : * page to allow for functions that return the number of bytes operated on in a
275 : : * given page.
276 : : */
277 : :
278 : : enum positive_aop_returns {
279 : : AOP_WRITEPAGE_ACTIVATE = 0x80000,
280 : : AOP_TRUNCATED_PAGE = 0x80001,
281 : : };
282 : :
283 : : #define AOP_FLAG_UNINTERRUPTIBLE 0x0001 /* will not do a short write */
284 : : #define AOP_FLAG_CONT_EXPAND 0x0002 /* called from cont_expand */
285 : : #define AOP_FLAG_NOFS 0x0004 /* used by filesystem to direct
286 : : * helper code (eg buffer layer)
287 : : * to clear GFP_FS from alloc */
288 : :
289 : : /*
290 : : * oh the beauties of C type declarations.
291 : : */
292 : : struct page;
293 : : struct address_space;
294 : : struct writeback_control;
295 : :
296 : : struct iov_iter {
297 : : const struct iovec *iov;
298 : : unsigned long nr_segs;
299 : : size_t iov_offset;
300 : : size_t count;
301 : : };
302 : :
303 : : size_t iov_iter_copy_from_user_atomic(struct page *page,
304 : : struct iov_iter *i, unsigned long offset, size_t bytes);
305 : : size_t iov_iter_copy_from_user(struct page *page,
306 : : struct iov_iter *i, unsigned long offset, size_t bytes);
307 : : void iov_iter_advance(struct iov_iter *i, size_t bytes);
308 : : int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
309 : : size_t iov_iter_single_seg_count(const struct iov_iter *i);
310 : :
311 : : static inline void iov_iter_init(struct iov_iter *i,
312 : : const struct iovec *iov, unsigned long nr_segs,
313 : : size_t count, size_t written)
314 : : {
315 : 3280269 : i->iov = iov;
316 : 3280269 : i->nr_segs = nr_segs;
317 : 3280269 : i->iov_offset = 0;
318 : 3280269 : i->count = count + written;
319 : :
320 : 3280269 : iov_iter_advance(i, written);
321 : : }
322 : :
323 : : static inline size_t iov_iter_count(struct iov_iter *i)
324 : : {
325 : : return i->count;
326 : : }
327 : :
328 : : /*
329 : : * "descriptor" for what we're up to with a read.
330 : : * This allows us to use the same read code yet
331 : : * have multiple different users of the data that
332 : : * we read from a file.
333 : : *
334 : : * The simplest case just copies the data to user
335 : : * mode.
336 : : */
337 : : typedef struct {
338 : : size_t written;
339 : : size_t count;
340 : : union {
341 : : char __user *buf;
342 : : void *data;
343 : : } arg;
344 : : int error;
345 : : } read_descriptor_t;
346 : :
347 : : typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
348 : : unsigned long, unsigned long);
349 : :
350 : : struct address_space_operations {
351 : : int (*writepage)(struct page *page, struct writeback_control *wbc);
352 : : int (*readpage)(struct file *, struct page *);
353 : :
354 : : /* Write back some dirty pages from this mapping. */
355 : : int (*writepages)(struct address_space *, struct writeback_control *);
356 : :
357 : : /* Set a page dirty. Return true if this dirtied it */
358 : : int (*set_page_dirty)(struct page *page);
359 : :
360 : : int (*readpages)(struct file *filp, struct address_space *mapping,
361 : : struct list_head *pages, unsigned nr_pages);
362 : :
363 : : int (*write_begin)(struct file *, struct address_space *mapping,
364 : : loff_t pos, unsigned len, unsigned flags,
365 : : struct page **pagep, void **fsdata);
366 : : int (*write_end)(struct file *, struct address_space *mapping,
367 : : loff_t pos, unsigned len, unsigned copied,
368 : : struct page *page, void *fsdata);
369 : :
370 : : /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
371 : : sector_t (*bmap)(struct address_space *, sector_t);
372 : : void (*invalidatepage) (struct page *, unsigned int, unsigned int);
373 : : int (*releasepage) (struct page *, gfp_t);
374 : : void (*freepage)(struct page *);
375 : : ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
376 : : loff_t offset, unsigned long nr_segs);
377 : : int (*get_xip_mem)(struct address_space *, pgoff_t, int,
378 : : void **, unsigned long *);
379 : : /*
380 : : * migrate the contents of a page to the specified target. If
381 : : * migrate_mode is MIGRATE_ASYNC, it must not block.
382 : : */
383 : : int (*migratepage) (struct address_space *,
384 : : struct page *, struct page *, enum migrate_mode);
385 : : int (*launder_page) (struct page *);
386 : : int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
387 : : unsigned long);
388 : : void (*is_dirty_writeback) (struct page *, bool *, bool *);
389 : : int (*error_remove_page)(struct address_space *, struct page *);
390 : :
391 : : /* swapfile support */
392 : : int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
393 : : sector_t *span);
394 : : void (*swap_deactivate)(struct file *file);
395 : : };
396 : :
397 : : extern const struct address_space_operations empty_aops;
398 : :
399 : : /*
400 : : * pagecache_write_begin/pagecache_write_end must be used by general code
401 : : * to write into the pagecache.
402 : : */
403 : : int pagecache_write_begin(struct file *, struct address_space *mapping,
404 : : loff_t pos, unsigned len, unsigned flags,
405 : : struct page **pagep, void **fsdata);
406 : :
407 : : int pagecache_write_end(struct file *, struct address_space *mapping,
408 : : loff_t pos, unsigned len, unsigned copied,
409 : : struct page *page, void *fsdata);
410 : :
411 : : struct backing_dev_info;
412 : : struct address_space {
413 : : struct inode *host; /* owner: inode, block_device */
414 : : struct radix_tree_root page_tree; /* radix tree of all pages */
415 : : spinlock_t tree_lock; /* and lock protecting it */
416 : : unsigned int i_mmap_writable;/* count VM_SHARED mappings */
417 : : struct rb_root i_mmap; /* tree of private and shared mappings */
418 : : struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
419 : : struct mutex i_mmap_mutex; /* protect tree, count, list */
420 : : /* Protected by tree_lock together with the radix tree */
421 : : unsigned long nrpages; /* number of total pages */
422 : : pgoff_t writeback_index;/* writeback starts here */
423 : : const struct address_space_operations *a_ops; /* methods */
424 : : unsigned long flags; /* error bits/gfp mask */
425 : : struct backing_dev_info *backing_dev_info; /* device readahead, etc */
426 : : spinlock_t private_lock; /* for use by the address_space */
427 : : struct list_head private_list; /* ditto */
428 : : void *private_data; /* ditto */
429 : : } __attribute__((aligned(sizeof(long))));
430 : : /*
431 : : * On most architectures that alignment is already the case; but
432 : : * must be enforced here for CRIS, to let the least significant bit
433 : : * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
434 : : */
435 : : struct request_queue;
436 : :
437 : : struct block_device {
438 : : dev_t bd_dev; /* not a kdev_t - it's a search key */
439 : : int bd_openers;
440 : : struct inode * bd_inode; /* will die */
441 : : struct super_block * bd_super;
442 : : struct mutex bd_mutex; /* open/close mutex */
443 : : struct list_head bd_inodes;
444 : : void * bd_claiming;
445 : : void * bd_holder;
446 : : int bd_holders;
447 : : bool bd_write_holder;
448 : : #ifdef CONFIG_SYSFS
449 : : struct list_head bd_holder_disks;
450 : : #endif
451 : : struct block_device * bd_contains;
452 : : unsigned bd_block_size;
453 : : struct hd_struct * bd_part;
454 : : /* number of times partitions within this device have been opened. */
455 : : unsigned bd_part_count;
456 : : int bd_invalidated;
457 : : struct gendisk * bd_disk;
458 : : struct request_queue * bd_queue;
459 : : struct list_head bd_list;
460 : : /*
461 : : * Private data. You must have bd_claim'ed the block_device
462 : : * to use this. NOTE: bd_claim allows an owner to claim
463 : : * the same device multiple times, the owner must take special
464 : : * care to not mess up bd_private for that case.
465 : : */
466 : : unsigned long bd_private;
467 : :
468 : : /* The counter of freeze processes */
469 : : int bd_fsfreeze_count;
470 : : /* Mutex for freeze */
471 : : struct mutex bd_fsfreeze_mutex;
472 : : };
473 : :
474 : : /*
475 : : * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
476 : : * radix trees
477 : : */
478 : : #define PAGECACHE_TAG_DIRTY 0
479 : : #define PAGECACHE_TAG_WRITEBACK 1
480 : : #define PAGECACHE_TAG_TOWRITE 2
481 : :
482 : : int mapping_tagged(struct address_space *mapping, int tag);
483 : :
484 : : /*
485 : : * Might pages of this file be mapped into userspace?
486 : : */
487 : : static inline int mapping_mapped(struct address_space *mapping)
488 : : {
489 : : return !RB_EMPTY_ROOT(&mapping->i_mmap) ||
490 : : !list_empty(&mapping->i_mmap_nonlinear);
491 : : }
492 : :
493 : : /*
494 : : * Might pages of this file have been modified in userspace?
495 : : * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
496 : : * marks vma as VM_SHARED if it is shared, and the file was opened for
497 : : * writing i.e. vma may be mprotected writable even if now readonly.
498 : : */
499 : : static inline int mapping_writably_mapped(struct address_space *mapping)
500 : : {
501 : : return mapping->i_mmap_writable != 0;
502 : : }
503 : :
504 : : /*
505 : : * Use sequence counter to get consistent i_size on 32-bit processors.
506 : : */
507 : : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
508 : : #include <linux/seqlock.h>
509 : : #define __NEED_I_SIZE_ORDERED
510 : : #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
511 : : #else
512 : : #define i_size_ordered_init(inode) do { } while (0)
513 : : #endif
514 : :
515 : : struct posix_acl;
516 : : #define ACL_NOT_CACHED ((void *)(-1))
517 : :
518 : : #define IOP_FASTPERM 0x0001
519 : : #define IOP_LOOKUP 0x0002
520 : : #define IOP_NOFOLLOW 0x0004
521 : :
522 : : /*
523 : : * Keep mostly read-only and often accessed (especially for
524 : : * the RCU path lookup and 'stat' data) fields at the beginning
525 : : * of the 'struct inode'
526 : : */
527 : : struct inode {
528 : : umode_t i_mode;
529 : : unsigned short i_opflags;
530 : : kuid_t i_uid;
531 : : kgid_t i_gid;
532 : : unsigned int i_flags;
533 : :
534 : : #ifdef CONFIG_FS_POSIX_ACL
535 : : struct posix_acl *i_acl;
536 : : struct posix_acl *i_default_acl;
537 : : #endif
538 : :
539 : : const struct inode_operations *i_op;
540 : : struct super_block *i_sb;
541 : : struct address_space *i_mapping;
542 : :
543 : : #ifdef CONFIG_SECURITY
544 : : void *i_security;
545 : : #endif
546 : :
547 : : /* Stat data, not accessed from path walking */
548 : : unsigned long i_ino;
549 : : /*
550 : : * Filesystems may only read i_nlink directly. They shall use the
551 : : * following functions for modification:
552 : : *
553 : : * (set|clear|inc|drop)_nlink
554 : : * inode_(inc|dec)_link_count
555 : : */
556 : : union {
557 : : const unsigned int i_nlink;
558 : : unsigned int __i_nlink;
559 : : };
560 : : dev_t i_rdev;
561 : : loff_t i_size;
562 : : struct timespec i_atime;
563 : : struct timespec i_mtime;
564 : : struct timespec i_ctime;
565 : : spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
566 : : unsigned short i_bytes;
567 : : unsigned int i_blkbits;
568 : : blkcnt_t i_blocks;
569 : :
570 : : #ifdef __NEED_I_SIZE_ORDERED
571 : : seqcount_t i_size_seqcount;
572 : : #endif
573 : :
574 : : /* Misc */
575 : : unsigned long i_state;
576 : : struct mutex i_mutex;
577 : :
578 : : unsigned long dirtied_when; /* jiffies of first dirtying */
579 : :
580 : : struct hlist_node i_hash;
581 : : struct list_head i_wb_list; /* backing dev IO list */
582 : : struct list_head i_lru; /* inode LRU list */
583 : : struct list_head i_sb_list;
584 : : union {
585 : : struct hlist_head i_dentry;
586 : : struct rcu_head i_rcu;
587 : : };
588 : : u64 i_version;
589 : : atomic_t i_count;
590 : : atomic_t i_dio_count;
591 : : atomic_t i_writecount;
592 : : const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
593 : : struct file_lock *i_flock;
594 : : struct address_space i_data;
595 : : #ifdef CONFIG_QUOTA
596 : : struct dquot *i_dquot[MAXQUOTAS];
597 : : #endif
598 : : struct list_head i_devices;
599 : : union {
600 : : struct pipe_inode_info *i_pipe;
601 : : struct block_device *i_bdev;
602 : : struct cdev *i_cdev;
603 : : };
604 : :
605 : : __u32 i_generation;
606 : :
607 : : #ifdef CONFIG_FSNOTIFY
608 : : __u32 i_fsnotify_mask; /* all events this inode cares about */
609 : : struct hlist_head i_fsnotify_marks;
610 : : #endif
611 : :
612 : : #ifdef CONFIG_IMA
613 : : atomic_t i_readcount; /* struct files open RO */
614 : : #endif
615 : : void *i_private; /* fs or device private pointer */
616 : : };
617 : :
618 : : static inline int inode_unhashed(struct inode *inode)
619 : : {
620 : 2306328 : return hlist_unhashed(&inode->i_hash);
621 : : }
622 : :
623 : : /*
624 : : * inode->i_mutex nesting subclasses for the lock validator:
625 : : *
626 : : * 0: the object of the current VFS operation
627 : : * 1: parent
628 : : * 2: child/target
629 : : * 3: xattr
630 : : * 4: second non-directory
631 : : * The last is for certain operations (such as rename) which lock two
632 : : * non-directories at once.
633 : : *
634 : : * The locking order between these classes is
635 : : * parent -> child -> normal -> xattr -> second non-directory
636 : : */
637 : : enum inode_i_mutex_lock_class
638 : : {
639 : : I_MUTEX_NORMAL,
640 : : I_MUTEX_PARENT,
641 : : I_MUTEX_CHILD,
642 : : I_MUTEX_XATTR,
643 : : I_MUTEX_NONDIR2
644 : : };
645 : :
646 : : void lock_two_nondirectories(struct inode *, struct inode*);
647 : : void unlock_two_nondirectories(struct inode *, struct inode*);
648 : :
649 : : /*
650 : : * NOTE: in a 32bit arch with a preemptable kernel and
651 : : * an UP compile the i_size_read/write must be atomic
652 : : * with respect to the local cpu (unlike with preempt disabled),
653 : : * but they don't need to be atomic with respect to other cpus like in
654 : : * true SMP (so they need either to either locally disable irq around
655 : : * the read or for example on x86 they can be still implemented as a
656 : : * cmpxchg8b without the need of the lock prefix). For SMP compiles
657 : : * and 64bit archs it makes no difference if preempt is enabled or not.
658 : : */
659 : : static inline loff_t i_size_read(const struct inode *inode)
660 : : {
661 : : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
662 : : loff_t i_size;
663 : : unsigned int seq;
664 : :
665 : : do {
666 : : seq = read_seqcount_begin(&inode->i_size_seqcount);
667 : 91970603 : i_size = inode->i_size;
668 [ + + + + : 91968079 : } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
+ + + + +
+ - + - +
- + # + ]
[ # # ][ + ]
669 : : return i_size;
670 : : #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
671 : : loff_t i_size;
672 : :
673 : : preempt_disable();
674 : : i_size = inode->i_size;
675 : : preempt_enable();
676 : : return i_size;
677 : : #else
678 : : return inode->i_size;
679 : : #endif
680 : : }
681 : :
682 : : /*
683 : : * NOTE: unlike i_size_read(), i_size_write() does need locking around it
684 : : * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
685 : : * can be lost, resulting in subsequent i_size_read() calls spinning forever.
686 : : */
687 : : static inline void i_size_write(struct inode *inode, loff_t i_size)
688 : : {
689 : : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
690 : 3838395 : preempt_disable();
691 : : write_seqcount_begin(&inode->i_size_seqcount);
692 : 3833593 : inode->i_size = i_size;
693 : : write_seqcount_end(&inode->i_size_seqcount);
694 : 3832497 : preempt_enable();
695 : : #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
696 : : preempt_disable();
697 : : inode->i_size = i_size;
698 : : preempt_enable();
699 : : #else
700 : : inode->i_size = i_size;
701 : : #endif
702 : : }
703 : :
704 : : /* Helper functions so that in most cases filesystems will
705 : : * not need to deal directly with kuid_t and kgid_t and can
706 : : * instead deal with the raw numeric values that are stored
707 : : * in the filesystem.
708 : : */
709 : : static inline uid_t i_uid_read(const struct inode *inode)
710 : : {
711 : : return from_kuid(&init_user_ns, inode->i_uid);
712 : : }
713 : :
714 : : static inline gid_t i_gid_read(const struct inode *inode)
715 : : {
716 : : return from_kgid(&init_user_ns, inode->i_gid);
717 : : }
718 : :
719 : : static inline void i_uid_write(struct inode *inode, uid_t uid)
720 : : {
721 : 1702350 : inode->i_uid = make_kuid(&init_user_ns, uid);
722 : : }
723 : :
724 : : static inline void i_gid_write(struct inode *inode, gid_t gid)
725 : : {
726 : 1702350 : inode->i_gid = make_kgid(&init_user_ns, gid);
727 : : }
728 : :
729 : : static inline unsigned iminor(const struct inode *inode)
730 : : {
731 : 15248 : return MINOR(inode->i_rdev);
732 : : }
733 : :
734 : : static inline unsigned imajor(const struct inode *inode)
735 : : {
736 : 0 : return MAJOR(inode->i_rdev);
737 : : }
738 : :
739 : : extern struct block_device *I_BDEV(struct inode *inode);
740 : :
741 : : struct fown_struct {
742 : : rwlock_t lock; /* protects pid, uid, euid fields */
743 : : struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
744 : : enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
745 : : kuid_t uid, euid; /* uid/euid of process setting the owner */
746 : : int signum; /* posix.1b rt signal to be delivered on IO */
747 : : };
748 : :
749 : : /*
750 : : * Track a single file's readahead state
751 : : */
752 : : struct file_ra_state {
753 : : pgoff_t start; /* where readahead started */
754 : : unsigned int size; /* # of readahead pages */
755 : : unsigned int async_size; /* do asynchronous readahead when
756 : : there are only # of pages ahead */
757 : :
758 : : unsigned int ra_pages; /* Maximum readahead window */
759 : : unsigned int mmap_miss; /* Cache miss stat for mmap accesses */
760 : : loff_t prev_pos; /* Cache last read() position */
761 : : };
762 : :
763 : : /*
764 : : * Check if @index falls in the readahead windows.
765 : : */
766 : : static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
767 : : {
768 [ # # ][ # # ]: 0 : return (index >= ra->start &&
769 : 0 : index < ra->start + ra->size);
770 : : }
771 : :
772 : : #define FILE_MNT_WRITE_TAKEN 1
773 : : #define FILE_MNT_WRITE_RELEASED 2
774 : :
775 : : struct file {
776 : : union {
777 : : struct llist_node fu_llist;
778 : : struct rcu_head fu_rcuhead;
779 : : } f_u;
780 : : struct path f_path;
781 : : #define f_dentry f_path.dentry
782 : : struct inode *f_inode; /* cached value */
783 : : const struct file_operations *f_op;
784 : :
785 : : /*
786 : : * Protects f_ep_links, f_flags.
787 : : * Must not be taken from IRQ context.
788 : : */
789 : : spinlock_t f_lock;
790 : : atomic_long_t f_count;
791 : : unsigned int f_flags;
792 : : fmode_t f_mode;
793 : : struct mutex f_pos_lock;
794 : : loff_t f_pos;
795 : : struct fown_struct f_owner;
796 : : const struct cred *f_cred;
797 : : struct file_ra_state f_ra;
798 : :
799 : : u64 f_version;
800 : : #ifdef CONFIG_SECURITY
801 : : void *f_security;
802 : : #endif
803 : : /* needed for tty driver, and maybe others */
804 : : void *private_data;
805 : :
806 : : #ifdef CONFIG_EPOLL
807 : : /* Used by fs/eventpoll.c to link all the hooks to this file */
808 : : struct list_head f_ep_links;
809 : : struct list_head f_tfile_llink;
810 : : #endif /* #ifdef CONFIG_EPOLL */
811 : : struct address_space *f_mapping;
812 : : #ifdef CONFIG_DEBUG_WRITECOUNT
813 : : unsigned long f_mnt_write_state;
814 : : #endif
815 : : } __attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
816 : :
817 : : struct file_handle {
818 : : __u32 handle_bytes;
819 : : int handle_type;
820 : : /* file identifier */
821 : : unsigned char f_handle[0];
822 : : };
823 : :
824 : : static inline struct file *get_file(struct file *f)
825 : : {
826 : 20523309 : atomic_long_inc(&f->f_count);
827 : : return f;
828 : : }
829 : : #define fput_atomic(x) atomic_long_add_unless(&(x)->f_count, -1, 1)
830 : : #define file_count(x) atomic_long_read(&(x)->f_count)
831 : :
832 : : #ifdef CONFIG_DEBUG_WRITECOUNT
833 : : static inline void file_take_write(struct file *f)
834 : : {
835 : : WARN_ON(f->f_mnt_write_state != 0);
836 : : f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
837 : : }
838 : : static inline void file_release_write(struct file *f)
839 : : {
840 : : f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
841 : : }
842 : : static inline void file_reset_write(struct file *f)
843 : : {
844 : : f->f_mnt_write_state = 0;
845 : : }
846 : : static inline void file_check_state(struct file *f)
847 : : {
848 : : /*
849 : : * At this point, either both or neither of these bits
850 : : * should be set.
851 : : */
852 : : WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
853 : : WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
854 : : }
855 : : static inline int file_check_writeable(struct file *f)
856 : : {
857 : : if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
858 : : return 0;
859 : : printk(KERN_WARNING "writeable file with no "
860 : : "mnt_want_write()\n");
861 : : WARN_ON(1);
862 : : return -EINVAL;
863 : : }
864 : : #else /* !CONFIG_DEBUG_WRITECOUNT */
865 : : static inline void file_take_write(struct file *filp) {}
866 : : static inline void file_release_write(struct file *filp) {}
867 : : static inline void file_reset_write(struct file *filp) {}
868 : : static inline void file_check_state(struct file *filp) {}
869 : : static inline int file_check_writeable(struct file *filp)
870 : : {
871 : : return 0;
872 : : }
873 : : #endif /* CONFIG_DEBUG_WRITECOUNT */
874 : :
875 : : #define MAX_NON_LFS ((1UL<<31) - 1)
876 : :
877 : : /* Page cache limit. The filesystems should put that into their s_maxbytes
878 : : limits, otherwise bad things can happen in VM. */
879 : : #if BITS_PER_LONG==32
880 : : #define MAX_LFS_FILESIZE (((loff_t)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
881 : : #elif BITS_PER_LONG==64
882 : : #define MAX_LFS_FILESIZE ((loff_t)0x7fffffffffffffffLL)
883 : : #endif
884 : :
885 : : #define FL_POSIX 1
886 : : #define FL_FLOCK 2
887 : : #define FL_DELEG 4 /* NFSv4 delegation */
888 : : #define FL_ACCESS 8 /* not trying to lock, just looking */
889 : : #define FL_EXISTS 16 /* when unlocking, test for existence */
890 : : #define FL_LEASE 32 /* lease held on this file */
891 : : #define FL_CLOSE 64 /* unlock on close */
892 : : #define FL_SLEEP 128 /* A blocking lock */
893 : : #define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */
894 : : #define FL_UNLOCK_PENDING 512 /* Lease is being broken */
895 : :
896 : : /*
897 : : * Special return value from posix_lock_file() and vfs_lock_file() for
898 : : * asynchronous locking.
899 : : */
900 : : #define FILE_LOCK_DEFERRED 1
901 : :
902 : : /*
903 : : * The POSIX file lock owner is determined by
904 : : * the "struct files_struct" in the thread group
905 : : * (or NULL for no owner - BSD locks).
906 : : *
907 : : * Lockd stuffs a "host" pointer into this.
908 : : */
909 : : typedef struct files_struct *fl_owner_t;
910 : :
911 : : struct file_lock_operations {
912 : : void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
913 : : void (*fl_release_private)(struct file_lock *);
914 : : };
915 : :
916 : : struct lock_manager_operations {
917 : : int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
918 : : unsigned long (*lm_owner_key)(struct file_lock *);
919 : : void (*lm_notify)(struct file_lock *); /* unblock callback */
920 : : int (*lm_grant)(struct file_lock *, struct file_lock *, int);
921 : : void (*lm_break)(struct file_lock *);
922 : : int (*lm_change)(struct file_lock **, int);
923 : : };
924 : :
925 : : struct lock_manager {
926 : : struct list_head list;
927 : : };
928 : :
929 : : struct net;
930 : : void locks_start_grace(struct net *, struct lock_manager *);
931 : : void locks_end_grace(struct lock_manager *);
932 : : int locks_in_grace(struct net *);
933 : :
934 : : /* that will die - we need it for nfs_lock_info */
935 : : #include <linux/nfs_fs_i.h>
936 : :
937 : : /*
938 : : * struct file_lock represents a generic "file lock". It's used to represent
939 : : * POSIX byte range locks, BSD (flock) locks, and leases. It's important to
940 : : * note that the same struct is used to represent both a request for a lock and
941 : : * the lock itself, but the same object is never used for both.
942 : : *
943 : : * FIXME: should we create a separate "struct lock_request" to help distinguish
944 : : * these two uses?
945 : : *
946 : : * The i_flock list is ordered by:
947 : : *
948 : : * 1) lock type -- FL_LEASEs first, then FL_FLOCK, and finally FL_POSIX
949 : : * 2) lock owner
950 : : * 3) lock range start
951 : : * 4) lock range end
952 : : *
953 : : * Obviously, the last two criteria only matter for POSIX locks.
954 : : */
955 : : struct file_lock {
956 : : struct file_lock *fl_next; /* singly linked list for this inode */
957 : : struct hlist_node fl_link; /* node in global lists */
958 : : struct list_head fl_block; /* circular list of blocked processes */
959 : : fl_owner_t fl_owner;
960 : : unsigned int fl_flags;
961 : : unsigned char fl_type;
962 : : unsigned int fl_pid;
963 : : int fl_link_cpu; /* what cpu's list is this on? */
964 : : struct pid *fl_nspid;
965 : : wait_queue_head_t fl_wait;
966 : : struct file *fl_file;
967 : : loff_t fl_start;
968 : : loff_t fl_end;
969 : :
970 : : struct fasync_struct * fl_fasync; /* for lease break notifications */
971 : : /* for lease breaks: */
972 : : unsigned long fl_break_time;
973 : : unsigned long fl_downgrade_time;
974 : :
975 : : const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */
976 : : const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
977 : : union {
978 : : struct nfs_lock_info nfs_fl;
979 : : struct nfs4_lock_info nfs4_fl;
980 : : struct {
981 : : struct list_head link; /* link in AFS vnode's pending_locks list */
982 : : int state; /* state of grant or error if -ve */
983 : : } afs;
984 : : } fl_u;
985 : : };
986 : :
987 : : /* The following constant reflects the upper bound of the file/locking space */
988 : : #ifndef OFFSET_MAX
989 : : #define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
990 : : #define OFFSET_MAX INT_LIMIT(loff_t)
991 : : #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
992 : : #endif
993 : :
994 : : #include <linux/fcntl.h>
995 : :
996 : : extern void send_sigio(struct fown_struct *fown, int fd, int band);
997 : :
998 : : #ifdef CONFIG_FILE_LOCKING
999 : : extern int fcntl_getlk(struct file *, struct flock __user *);
1000 : : extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1001 : : struct flock __user *);
1002 : :
1003 : : #if BITS_PER_LONG == 32
1004 : : extern int fcntl_getlk64(struct file *, struct flock64 __user *);
1005 : : extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1006 : : struct flock64 __user *);
1007 : : #endif
1008 : :
1009 : : extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1010 : : extern int fcntl_getlease(struct file *filp);
1011 : :
1012 : : /* fs/locks.c */
1013 : : void locks_free_lock(struct file_lock *fl);
1014 : : extern void locks_init_lock(struct file_lock *);
1015 : : extern struct file_lock * locks_alloc_lock(void);
1016 : : extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1017 : : extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
1018 : : extern void locks_remove_posix(struct file *, fl_owner_t);
1019 : : extern void locks_remove_flock(struct file *);
1020 : : extern void locks_release_private(struct file_lock *);
1021 : : extern void posix_test_lock(struct file *, struct file_lock *);
1022 : : extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1023 : : extern int posix_lock_file_wait(struct file *, struct file_lock *);
1024 : : extern int posix_unblock_lock(struct file_lock *);
1025 : : extern int vfs_test_lock(struct file *, struct file_lock *);
1026 : : extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
1027 : : extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1028 : : extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
1029 : : extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
1030 : : extern void lease_get_mtime(struct inode *, struct timespec *time);
1031 : : extern int generic_setlease(struct file *, long, struct file_lock **);
1032 : : extern int vfs_setlease(struct file *, long, struct file_lock **);
1033 : : extern int lease_modify(struct file_lock **, int);
1034 : : extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
1035 : : extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
1036 : : #else /* !CONFIG_FILE_LOCKING */
1037 : : static inline int fcntl_getlk(struct file *file, struct flock __user *user)
1038 : : {
1039 : : return -EINVAL;
1040 : : }
1041 : :
1042 : : static inline int fcntl_setlk(unsigned int fd, struct file *file,
1043 : : unsigned int cmd, struct flock __user *user)
1044 : : {
1045 : : return -EACCES;
1046 : : }
1047 : :
1048 : : #if BITS_PER_LONG == 32
1049 : : static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
1050 : : {
1051 : : return -EINVAL;
1052 : : }
1053 : :
1054 : : static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1055 : : unsigned int cmd, struct flock64 __user *user)
1056 : : {
1057 : : return -EACCES;
1058 : : }
1059 : : #endif
1060 : : static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1061 : : {
1062 : : return 0;
1063 : : }
1064 : :
1065 : : static inline int fcntl_getlease(struct file *filp)
1066 : : {
1067 : : return 0;
1068 : : }
1069 : :
1070 : : static inline void locks_init_lock(struct file_lock *fl)
1071 : : {
1072 : : return;
1073 : : }
1074 : :
1075 : : static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1076 : : {
1077 : : return;
1078 : : }
1079 : :
1080 : : static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1081 : : {
1082 : : return;
1083 : : }
1084 : :
1085 : : static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1086 : : {
1087 : : return;
1088 : : }
1089 : :
1090 : : static inline void locks_remove_flock(struct file *filp)
1091 : : {
1092 : : return;
1093 : : }
1094 : :
1095 : : static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1096 : : {
1097 : : return;
1098 : : }
1099 : :
1100 : : static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1101 : : struct file_lock *conflock)
1102 : : {
1103 : : return -ENOLCK;
1104 : : }
1105 : :
1106 : : static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
1107 : : {
1108 : : return -ENOLCK;
1109 : : }
1110 : :
1111 : : static inline int posix_unblock_lock(struct file_lock *waiter)
1112 : : {
1113 : : return -ENOENT;
1114 : : }
1115 : :
1116 : : static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1117 : : {
1118 : : return 0;
1119 : : }
1120 : :
1121 : : static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
1122 : : struct file_lock *fl, struct file_lock *conf)
1123 : : {
1124 : : return -ENOLCK;
1125 : : }
1126 : :
1127 : : static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1128 : : {
1129 : : return 0;
1130 : : }
1131 : :
1132 : : static inline int flock_lock_file_wait(struct file *filp,
1133 : : struct file_lock *request)
1134 : : {
1135 : : return -ENOLCK;
1136 : : }
1137 : :
1138 : : static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1139 : : {
1140 : : return 0;
1141 : : }
1142 : :
1143 : : static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
1144 : : {
1145 : : return;
1146 : : }
1147 : :
1148 : : static inline int generic_setlease(struct file *filp, long arg,
1149 : : struct file_lock **flp)
1150 : : {
1151 : : return -EINVAL;
1152 : : }
1153 : :
1154 : : static inline int vfs_setlease(struct file *filp, long arg,
1155 : : struct file_lock **lease)
1156 : : {
1157 : : return -EINVAL;
1158 : : }
1159 : :
1160 : : static inline int lease_modify(struct file_lock **before, int arg)
1161 : : {
1162 : : return -EINVAL;
1163 : : }
1164 : :
1165 : : static inline int lock_may_read(struct inode *inode, loff_t start,
1166 : : unsigned long len)
1167 : : {
1168 : : return 1;
1169 : : }
1170 : :
1171 : : static inline int lock_may_write(struct inode *inode, loff_t start,
1172 : : unsigned long len)
1173 : : {
1174 : : return 1;
1175 : : }
1176 : : #endif /* !CONFIG_FILE_LOCKING */
1177 : :
1178 : :
1179 : : struct fasync_struct {
1180 : : spinlock_t fa_lock;
1181 : : int magic;
1182 : : int fa_fd;
1183 : : struct fasync_struct *fa_next; /* singly linked list */
1184 : : struct file *fa_file;
1185 : : struct rcu_head fa_rcu;
1186 : : };
1187 : :
1188 : : #define FASYNC_MAGIC 0x4601
1189 : :
1190 : : /* SMP safe fasync helpers: */
1191 : : extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
1192 : : extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1193 : : extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1194 : : extern struct fasync_struct *fasync_alloc(void);
1195 : : extern void fasync_free(struct fasync_struct *);
1196 : :
1197 : : /* can be called from interrupts */
1198 : : extern void kill_fasync(struct fasync_struct **, int, int);
1199 : :
1200 : : extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1201 : : extern int f_setown(struct file *filp, unsigned long arg, int force);
1202 : : extern void f_delown(struct file *filp);
1203 : : extern pid_t f_getown(struct file *filp);
1204 : : extern int send_sigurg(struct fown_struct *fown);
1205 : :
1206 : : struct mm_struct;
1207 : :
1208 : : /*
1209 : : * Umount options
1210 : : */
1211 : :
1212 : : #define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
1213 : : #define MNT_DETACH 0x00000002 /* Just detach from the tree */
1214 : : #define MNT_EXPIRE 0x00000004 /* Mark for expiry */
1215 : : #define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
1216 : : #define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
1217 : :
1218 : : extern struct list_head super_blocks;
1219 : : extern spinlock_t sb_lock;
1220 : :
1221 : : /* Possible states of 'frozen' field */
1222 : : enum {
1223 : : SB_UNFROZEN = 0, /* FS is unfrozen */
1224 : : SB_FREEZE_WRITE = 1, /* Writes, dir ops, ioctls frozen */
1225 : : SB_FREEZE_PAGEFAULT = 2, /* Page faults stopped as well */
1226 : : SB_FREEZE_FS = 3, /* For internal FS use (e.g. to stop
1227 : : * internal threads if needed) */
1228 : : SB_FREEZE_COMPLETE = 4, /* ->freeze_fs finished successfully */
1229 : : };
1230 : :
1231 : : #define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1232 : :
1233 : : struct sb_writers {
1234 : : /* Counters for counting writers at each level */
1235 : : struct percpu_counter counter[SB_FREEZE_LEVELS];
1236 : : wait_queue_head_t wait; /* queue for waiting for
1237 : : writers / faults to finish */
1238 : : int frozen; /* Is sb frozen? */
1239 : : wait_queue_head_t wait_unfrozen; /* queue for waiting for
1240 : : sb to be thawed */
1241 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
1242 : : struct lockdep_map lock_map[SB_FREEZE_LEVELS];
1243 : : #endif
1244 : : };
1245 : :
1246 : : struct super_block {
1247 : : struct list_head s_list; /* Keep this first */
1248 : : dev_t s_dev; /* search index; _not_ kdev_t */
1249 : : unsigned char s_blocksize_bits;
1250 : : unsigned long s_blocksize;
1251 : : loff_t s_maxbytes; /* Max file size */
1252 : : struct file_system_type *s_type;
1253 : : const struct super_operations *s_op;
1254 : : const struct dquot_operations *dq_op;
1255 : : const struct quotactl_ops *s_qcop;
1256 : : const struct export_operations *s_export_op;
1257 : : unsigned long s_flags;
1258 : : unsigned long s_magic;
1259 : : struct dentry *s_root;
1260 : : struct rw_semaphore s_umount;
1261 : : int s_count;
1262 : : atomic_t s_active;
1263 : : #ifdef CONFIG_SECURITY
1264 : : void *s_security;
1265 : : #endif
1266 : : const struct xattr_handler **s_xattr;
1267 : :
1268 : : struct list_head s_inodes; /* all inodes */
1269 : : struct hlist_bl_head s_anon; /* anonymous dentries for (nfs) exporting */
1270 : : struct list_head s_mounts; /* list of mounts; _not_ for fs use */
1271 : : struct block_device *s_bdev;
1272 : : struct backing_dev_info *s_bdi;
1273 : : struct mtd_info *s_mtd;
1274 : : struct hlist_node s_instances;
1275 : : struct quota_info s_dquot; /* Diskquota specific options */
1276 : :
1277 : : struct sb_writers s_writers;
1278 : :
1279 : : char s_id[32]; /* Informational name */
1280 : : u8 s_uuid[16]; /* UUID */
1281 : :
1282 : : void *s_fs_info; /* Filesystem private info */
1283 : : unsigned int s_max_links;
1284 : : fmode_t s_mode;
1285 : :
1286 : : /* Granularity of c/m/atime in ns.
1287 : : Cannot be worse than a second */
1288 : : u32 s_time_gran;
1289 : :
1290 : : /*
1291 : : * The next field is for VFS *only*. No filesystems have any business
1292 : : * even looking at it. You had been warned.
1293 : : */
1294 : : struct mutex s_vfs_rename_mutex; /* Kludge */
1295 : :
1296 : : /*
1297 : : * Filesystem subtype. If non-empty the filesystem type field
1298 : : * in /proc/mounts will be "type.subtype"
1299 : : */
1300 : : char *s_subtype;
1301 : :
1302 : : /*
1303 : : * Saved mount options for lazy filesystems using
1304 : : * generic_show_options()
1305 : : */
1306 : : char __rcu *s_options;
1307 : : const struct dentry_operations *s_d_op; /* default d_op for dentries */
1308 : :
1309 : : /*
1310 : : * Saved pool identifier for cleancache (-1 means none)
1311 : : */
1312 : : int cleancache_poolid;
1313 : :
1314 : : struct shrinker s_shrink; /* per-sb shrinker handle */
1315 : :
1316 : : /* Number of inodes with nlink == 0 but still referenced */
1317 : : atomic_long_t s_remove_count;
1318 : :
1319 : : /* Being remounted read-only */
1320 : : int s_readonly_remount;
1321 : :
1322 : : /* AIO completions deferred from interrupt context */
1323 : : struct workqueue_struct *s_dio_done_wq;
1324 : :
1325 : : /*
1326 : : * Keep the lru lists last in the structure so they always sit on their
1327 : : * own individual cachelines.
1328 : : */
1329 : : struct list_lru s_dentry_lru ____cacheline_aligned_in_smp;
1330 : : struct list_lru s_inode_lru ____cacheline_aligned_in_smp;
1331 : : struct rcu_head rcu;
1332 : : };
1333 : :
1334 : : extern struct timespec current_fs_time(struct super_block *sb);
1335 : :
1336 : : /*
1337 : : * Snapshotting support.
1338 : : */
1339 : :
1340 : : void __sb_end_write(struct super_block *sb, int level);
1341 : : int __sb_start_write(struct super_block *sb, int level, bool wait);
1342 : :
1343 : : /**
1344 : : * sb_end_write - drop write access to a superblock
1345 : : * @sb: the super we wrote to
1346 : : *
1347 : : * Decrement number of writers to the filesystem. Wake up possible waiters
1348 : : * wanting to freeze the filesystem.
1349 : : */
1350 : : static inline void sb_end_write(struct super_block *sb)
1351 : : {
1352 : 4365580 : __sb_end_write(sb, SB_FREEZE_WRITE);
1353 : : }
1354 : :
1355 : : /**
1356 : : * sb_end_pagefault - drop write access to a superblock from a page fault
1357 : : * @sb: the super we wrote to
1358 : : *
1359 : : * Decrement number of processes handling write page fault to the filesystem.
1360 : : * Wake up possible waiters wanting to freeze the filesystem.
1361 : : */
1362 : : static inline void sb_end_pagefault(struct super_block *sb)
1363 : : {
1364 : 205596 : __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
1365 : : }
1366 : :
1367 : : /**
1368 : : * sb_end_intwrite - drop write access to a superblock for internal fs purposes
1369 : : * @sb: the super we wrote to
1370 : : *
1371 : : * Decrement fs-internal number of writers to the filesystem. Wake up possible
1372 : : * waiters wanting to freeze the filesystem.
1373 : : */
1374 : : static inline void sb_end_intwrite(struct super_block *sb)
1375 : : {
1376 : 271092 : __sb_end_write(sb, SB_FREEZE_FS);
1377 : : }
1378 : :
1379 : : /**
1380 : : * sb_start_write - get write access to a superblock
1381 : : * @sb: the super we write to
1382 : : *
1383 : : * When a process wants to write data or metadata to a file system (i.e. dirty
1384 : : * a page or an inode), it should embed the operation in a sb_start_write() -
1385 : : * sb_end_write() pair to get exclusion against file system freezing. This
1386 : : * function increments number of writers preventing freezing. If the file
1387 : : * system is already frozen, the function waits until the file system is
1388 : : * thawed.
1389 : : *
1390 : : * Since freeze protection behaves as a lock, users have to preserve
1391 : : * ordering of freeze protection and other filesystem locks. Generally,
1392 : : * freeze protection should be the outermost lock. In particular, we have:
1393 : : *
1394 : : * sb_start_write
1395 : : * -> i_mutex (write path, truncate, directory ops, ...)
1396 : : * -> s_umount (freeze_super, thaw_super)
1397 : : */
1398 : : static inline void sb_start_write(struct super_block *sb)
1399 : : {
1400 : 3450525 : __sb_start_write(sb, SB_FREEZE_WRITE, true);
1401 : : }
1402 : :
1403 : : static inline int sb_start_write_trylock(struct super_block *sb)
1404 : : {
1405 : 911541 : return __sb_start_write(sb, SB_FREEZE_WRITE, false);
1406 : : }
1407 : :
1408 : : /**
1409 : : * sb_start_pagefault - get write access to a superblock from a page fault
1410 : : * @sb: the super we write to
1411 : : *
1412 : : * When a process starts handling write page fault, it should embed the
1413 : : * operation into sb_start_pagefault() - sb_end_pagefault() pair to get
1414 : : * exclusion against file system freezing. This is needed since the page fault
1415 : : * is going to dirty a page. This function increments number of running page
1416 : : * faults preventing freezing. If the file system is already frozen, the
1417 : : * function waits until the file system is thawed.
1418 : : *
1419 : : * Since page fault freeze protection behaves as a lock, users have to preserve
1420 : : * ordering of freeze protection and other filesystem locks. It is advised to
1421 : : * put sb_start_pagefault() close to mmap_sem in lock ordering. Page fault
1422 : : * handling code implies lock dependency:
1423 : : *
1424 : : * mmap_sem
1425 : : * -> sb_start_pagefault
1426 : : */
1427 : : static inline void sb_start_pagefault(struct super_block *sb)
1428 : : {
1429 : 205379 : __sb_start_write(sb, SB_FREEZE_PAGEFAULT, true);
1430 : : }
1431 : :
1432 : : /*
1433 : : * sb_start_intwrite - get write access to a superblock for internal fs purposes
1434 : : * @sb: the super we write to
1435 : : *
1436 : : * This is the third level of protection against filesystem freezing. It is
1437 : : * free for use by a filesystem. The only requirement is that it must rank
1438 : : * below sb_start_pagefault.
1439 : : *
1440 : : * For example filesystem can call sb_start_intwrite() when starting a
1441 : : * transaction which somewhat eases handling of freezing for internal sources
1442 : : * of filesystem changes (internal fs threads, discarding preallocation on file
1443 : : * close, etc.).
1444 : : */
1445 : : static inline void sb_start_intwrite(struct super_block *sb)
1446 : : {
1447 : 271089 : __sb_start_write(sb, SB_FREEZE_FS, true);
1448 : : }
1449 : :
1450 : :
1451 : : extern bool inode_owner_or_capable(const struct inode *inode);
1452 : :
1453 : : /*
1454 : : * VFS helper functions..
1455 : : */
1456 : : extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
1457 : : extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
1458 : : extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
1459 : : extern int vfs_symlink(struct inode *, struct dentry *, const char *);
1460 : : extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
1461 : : extern int vfs_rmdir(struct inode *, struct dentry *);
1462 : : extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
1463 : : extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **);
1464 : :
1465 : : /*
1466 : : * VFS dentry helper functions.
1467 : : */
1468 : : extern void dentry_unhash(struct dentry *dentry);
1469 : :
1470 : : /*
1471 : : * VFS file helper functions.
1472 : : */
1473 : : extern void inode_init_owner(struct inode *inode, const struct inode *dir,
1474 : : umode_t mode);
1475 : : /*
1476 : : * VFS FS_IOC_FIEMAP helper definitions.
1477 : : */
1478 : : struct fiemap_extent_info {
1479 : : unsigned int fi_flags; /* Flags as passed from user */
1480 : : unsigned int fi_extents_mapped; /* Number of mapped extents */
1481 : : unsigned int fi_extents_max; /* Size of fiemap_extent array */
1482 : : struct fiemap_extent __user *fi_extents_start; /* Start of
1483 : : fiemap_extent array */
1484 : : };
1485 : : int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
1486 : : u64 phys, u64 len, u32 flags);
1487 : : int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
1488 : :
1489 : : /*
1490 : : * File types
1491 : : *
1492 : : * NOTE! These match bits 12..15 of stat.st_mode
1493 : : * (ie "(i_mode >> 12) & 15").
1494 : : */
1495 : : #define DT_UNKNOWN 0
1496 : : #define DT_FIFO 1
1497 : : #define DT_CHR 2
1498 : : #define DT_DIR 4
1499 : : #define DT_BLK 6
1500 : : #define DT_REG 8
1501 : : #define DT_LNK 10
1502 : : #define DT_SOCK 12
1503 : : #define DT_WHT 14
1504 : :
1505 : : /*
1506 : : * This is the "filldir" function type, used by readdir() to let
1507 : : * the kernel specify what kind of dirent layout it wants to have.
1508 : : * This allows the kernel to read directories into kernel space or
1509 : : * to have different dirent layouts depending on the binary type.
1510 : : */
1511 : : typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
1512 : : struct dir_context {
1513 : : const filldir_t actor;
1514 : : loff_t pos;
1515 : : };
1516 : :
1517 : : struct block_device_operations;
1518 : :
1519 : : /* These macros are for out of kernel modules to test that
1520 : : * the kernel supports the unlocked_ioctl and compat_ioctl
1521 : : * fields in struct file_operations. */
1522 : : #define HAVE_COMPAT_IOCTL 1
1523 : : #define HAVE_UNLOCKED_IOCTL 1
1524 : :
1525 : : struct file_operations {
1526 : : struct module *owner;
1527 : : loff_t (*llseek) (struct file *, loff_t, int);
1528 : : ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1529 : : ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1530 : : ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
1531 : : ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
1532 : : int (*iterate) (struct file *, struct dir_context *);
1533 : : unsigned int (*poll) (struct file *, struct poll_table_struct *);
1534 : : long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1535 : : long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1536 : : int (*mmap) (struct file *, struct vm_area_struct *);
1537 : : int (*open) (struct inode *, struct file *);
1538 : : int (*flush) (struct file *, fl_owner_t id);
1539 : : int (*release) (struct inode *, struct file *);
1540 : : int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1541 : : int (*aio_fsync) (struct kiocb *, int datasync);
1542 : : int (*fasync) (int, struct file *, int);
1543 : : int (*lock) (struct file *, int, struct file_lock *);
1544 : : ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
1545 : : unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1546 : : int (*check_flags)(int);
1547 : : int (*flock) (struct file *, int, struct file_lock *);
1548 : : ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1549 : : ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1550 : : int (*setlease)(struct file *, long, struct file_lock **);
1551 : : long (*fallocate)(struct file *file, int mode, loff_t offset,
1552 : : loff_t len);
1553 : : int (*show_fdinfo)(struct seq_file *m, struct file *f);
1554 : : };
1555 : :
1556 : : struct inode_operations {
1557 : : struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
1558 : : void * (*follow_link) (struct dentry *, struct nameidata *);
1559 : : int (*permission) (struct inode *, int);
1560 : : struct posix_acl * (*get_acl)(struct inode *, int);
1561 : :
1562 : : int (*readlink) (struct dentry *, char __user *,int);
1563 : : void (*put_link) (struct dentry *, struct nameidata *, void *);
1564 : :
1565 : : int (*create) (struct inode *,struct dentry *, umode_t, bool);
1566 : : int (*link) (struct dentry *,struct inode *,struct dentry *);
1567 : : int (*unlink) (struct inode *,struct dentry *);
1568 : : int (*symlink) (struct inode *,struct dentry *,const char *);
1569 : : int (*mkdir) (struct inode *,struct dentry *,umode_t);
1570 : : int (*rmdir) (struct inode *,struct dentry *);
1571 : : int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
1572 : : int (*rename) (struct inode *, struct dentry *,
1573 : : struct inode *, struct dentry *);
1574 : : int (*setattr) (struct dentry *, struct iattr *);
1575 : : int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
1576 : : int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
1577 : : ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
1578 : : ssize_t (*listxattr) (struct dentry *, char *, size_t);
1579 : : int (*removexattr) (struct dentry *, const char *);
1580 : : int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
1581 : : u64 len);
1582 : : int (*update_time)(struct inode *, struct timespec *, int);
1583 : : int (*atomic_open)(struct inode *, struct dentry *,
1584 : : struct file *, unsigned open_flag,
1585 : : umode_t create_mode, int *opened);
1586 : : int (*tmpfile) (struct inode *, struct dentry *, umode_t);
1587 : : int (*set_acl)(struct inode *, struct posix_acl *, int);
1588 : : } ____cacheline_aligned;
1589 : :
1590 : : ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
1591 : : unsigned long nr_segs, unsigned long fast_segs,
1592 : : struct iovec *fast_pointer,
1593 : : struct iovec **ret_pointer);
1594 : :
1595 : : extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
1596 : : extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
1597 : : extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
1598 : : unsigned long, loff_t *);
1599 : : extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
1600 : : unsigned long, loff_t *);
1601 : :
1602 : : struct super_operations {
1603 : : struct inode *(*alloc_inode)(struct super_block *sb);
1604 : : void (*destroy_inode)(struct inode *);
1605 : :
1606 : : void (*dirty_inode) (struct inode *, int flags);
1607 : : int (*write_inode) (struct inode *, struct writeback_control *wbc);
1608 : : int (*drop_inode) (struct inode *);
1609 : : void (*evict_inode) (struct inode *);
1610 : : void (*put_super) (struct super_block *);
1611 : : int (*sync_fs)(struct super_block *sb, int wait);
1612 : : int (*freeze_fs) (struct super_block *);
1613 : : int (*unfreeze_fs) (struct super_block *);
1614 : : int (*statfs) (struct dentry *, struct kstatfs *);
1615 : : int (*remount_fs) (struct super_block *, int *, char *);
1616 : : void (*umount_begin) (struct super_block *);
1617 : :
1618 : : int (*show_options)(struct seq_file *, struct dentry *);
1619 : : int (*show_devname)(struct seq_file *, struct dentry *);
1620 : : int (*show_path)(struct seq_file *, struct dentry *);
1621 : : int (*show_stats)(struct seq_file *, struct dentry *);
1622 : : #ifdef CONFIG_QUOTA
1623 : : ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
1624 : : ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
1625 : : #endif
1626 : : int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
1627 : : long (*nr_cached_objects)(struct super_block *, int);
1628 : : long (*free_cached_objects)(struct super_block *, long, int);
1629 : : };
1630 : :
1631 : : /*
1632 : : * Inode flags - they have no relation to superblock flags now
1633 : : */
1634 : : #define S_SYNC 1 /* Writes are synced at once */
1635 : : #define S_NOATIME 2 /* Do not update access times */
1636 : : #define S_APPEND 4 /* Append-only file */
1637 : : #define S_IMMUTABLE 8 /* Immutable file */
1638 : : #define S_DEAD 16 /* removed, but still open directory */
1639 : : #define S_NOQUOTA 32 /* Inode is not counted to quota */
1640 : : #define S_DIRSYNC 64 /* Directory modifications are synchronous */
1641 : : #define S_NOCMTIME 128 /* Do not update file c/mtime */
1642 : : #define S_SWAPFILE 256 /* Do not truncate: swapon got its bmaps */
1643 : : #define S_PRIVATE 512 /* Inode is fs-internal */
1644 : : #define S_IMA 1024 /* Inode has an associated IMA struct */
1645 : : #define S_AUTOMOUNT 2048 /* Automount/referral quasi-directory */
1646 : : #define S_NOSEC 4096 /* no suid or xattr security attributes */
1647 : :
1648 : : /*
1649 : : * Note that nosuid etc flags are inode-specific: setting some file-system
1650 : : * flags just means all the inodes inherit those flags by default. It might be
1651 : : * possible to override it selectively if you really wanted to with some
1652 : : * ioctl() that is not currently implemented.
1653 : : *
1654 : : * Exception: MS_RDONLY is always applied to the entire file system.
1655 : : *
1656 : : * Unfortunately, it is possible to change a filesystems flags with it mounted
1657 : : * with files in use. This means that all of the inodes will not have their
1658 : : * i_flags updated. Hence, i_flags no longer inherit the superblock mount
1659 : : * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
1660 : : */
1661 : : #define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
1662 : :
1663 : : #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
1664 : : #define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || \
1665 : : ((inode)->i_flags & S_SYNC))
1666 : : #define IS_DIRSYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
1667 : : ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
1668 : : #define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK)
1669 : : #define IS_NOATIME(inode) __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
1670 : : #define IS_I_VERSION(inode) __IS_FLG(inode, MS_I_VERSION)
1671 : :
1672 : : #define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
1673 : : #define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
1674 : : #define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
1675 : : #define IS_POSIXACL(inode) __IS_FLG(inode, MS_POSIXACL)
1676 : :
1677 : : #define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
1678 : : #define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
1679 : : #define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
1680 : : #define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
1681 : : #define IS_IMA(inode) ((inode)->i_flags & S_IMA)
1682 : : #define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
1683 : : #define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
1684 : :
1685 : : /*
1686 : : * Inode state bits. Protected by inode->i_lock
1687 : : *
1688 : : * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
1689 : : * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
1690 : : *
1691 : : * Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
1692 : : * until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
1693 : : * various stages of removing an inode.
1694 : : *
1695 : : * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
1696 : : *
1697 : : * I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
1698 : : * fdatasync(). i_atime is the usual cause.
1699 : : * I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
1700 : : * these changes separately from I_DIRTY_SYNC so that we
1701 : : * don't have to write inode on fdatasync() when only
1702 : : * mtime has changed in it.
1703 : : * I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
1704 : : * I_NEW Serves as both a mutex and completion notification.
1705 : : * New inodes set I_NEW. If two processes both create
1706 : : * the same inode, one of them will release its inode and
1707 : : * wait for I_NEW to be released before returning.
1708 : : * Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
1709 : : * also cause waiting on I_NEW, without I_NEW actually
1710 : : * being set. find_inode() uses this to prevent returning
1711 : : * nearly-dead inodes.
1712 : : * I_WILL_FREE Must be set when calling write_inode_now() if i_count
1713 : : * is zero. I_FREEING must be set when I_WILL_FREE is
1714 : : * cleared.
1715 : : * I_FREEING Set when inode is about to be freed but still has dirty
1716 : : * pages or buffers attached or the inode itself is still
1717 : : * dirty.
1718 : : * I_CLEAR Added by clear_inode(). In this state the inode is
1719 : : * clean and can be destroyed. Inode keeps I_FREEING.
1720 : : *
1721 : : * Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
1722 : : * prohibited for many purposes. iget() must wait for
1723 : : * the inode to be completely released, then create it
1724 : : * anew. Other functions will just ignore such inodes,
1725 : : * if appropriate. I_NEW is used for waiting.
1726 : : *
1727 : : * I_SYNC Writeback of inode is running. The bit is set during
1728 : : * data writeback, and cleared with a wakeup on the bit
1729 : : * address once it is done. The bit is also used to pin
1730 : : * the inode in memory for flusher thread.
1731 : : *
1732 : : * I_REFERENCED Marks the inode as recently references on the LRU list.
1733 : : *
1734 : : * I_DIO_WAKEUP Never set. Only used as a key for wait_on_bit().
1735 : : *
1736 : : * Q: What is the difference between I_WILL_FREE and I_FREEING?
1737 : : */
1738 : : #define I_DIRTY_SYNC (1 << 0)
1739 : : #define I_DIRTY_DATASYNC (1 << 1)
1740 : : #define I_DIRTY_PAGES (1 << 2)
1741 : : #define __I_NEW 3
1742 : : #define I_NEW (1 << __I_NEW)
1743 : : #define I_WILL_FREE (1 << 4)
1744 : : #define I_FREEING (1 << 5)
1745 : : #define I_CLEAR (1 << 6)
1746 : : #define __I_SYNC 7
1747 : : #define I_SYNC (1 << __I_SYNC)
1748 : : #define I_REFERENCED (1 << 8)
1749 : : #define __I_DIO_WAKEUP 9
1750 : : #define I_DIO_WAKEUP (1 << I_DIO_WAKEUP)
1751 : : #define I_LINKABLE (1 << 10)
1752 : :
1753 : : #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
1754 : :
1755 : : extern void __mark_inode_dirty(struct inode *, int);
1756 : : static inline void mark_inode_dirty(struct inode *inode)
1757 : : {
1758 : 3876981 : __mark_inode_dirty(inode, I_DIRTY);
1759 : : }
1760 : :
1761 : : static inline void mark_inode_dirty_sync(struct inode *inode)
1762 : : {
1763 : 869137 : __mark_inode_dirty(inode, I_DIRTY_SYNC);
1764 : : }
1765 : :
1766 : : extern void inc_nlink(struct inode *inode);
1767 : : extern void drop_nlink(struct inode *inode);
1768 : : extern void clear_nlink(struct inode *inode);
1769 : : extern void set_nlink(struct inode *inode, unsigned int nlink);
1770 : :
1771 : : static inline void inode_inc_link_count(struct inode *inode)
1772 : : {
1773 : 0 : inc_nlink(inode);
1774 : : mark_inode_dirty(inode);
1775 : : }
1776 : :
1777 : : static inline void inode_dec_link_count(struct inode *inode)
1778 : : {
1779 : 0 : drop_nlink(inode);
1780 : : mark_inode_dirty(inode);
1781 : : }
1782 : :
1783 : : /**
1784 : : * inode_inc_iversion - increments i_version
1785 : : * @inode: inode that need to be updated
1786 : : *
1787 : : * Every time the inode is modified, the i_version field will be incremented.
1788 : : * The filesystem has to be mounted with i_version flag
1789 : : */
1790 : :
1791 : : static inline void inode_inc_iversion(struct inode *inode)
1792 : : {
1793 : : spin_lock(&inode->i_lock);
1794 : 0 : inode->i_version++;
1795 : : spin_unlock(&inode->i_lock);
1796 : : }
1797 : :
1798 : : enum file_time_flags {
1799 : : S_ATIME = 1,
1800 : : S_MTIME = 2,
1801 : : S_CTIME = 4,
1802 : : S_VERSION = 8,
1803 : : };
1804 : :
1805 : : extern void touch_atime(const struct path *);
1806 : : static inline void file_accessed(struct file *file)
1807 : : {
1808 [ + - ][ + ]: 7159215 : if (!(file->f_flags & O_NOATIME))
[ + + ][ + + ]
1809 : 7157233 : touch_atime(&file->f_path);
1810 : : }
1811 : :
1812 : : int sync_inode(struct inode *inode, struct writeback_control *wbc);
1813 : : int sync_inode_metadata(struct inode *inode, int wait);
1814 : :
1815 : : struct file_system_type {
1816 : : const char *name;
1817 : : int fs_flags;
1818 : : #define FS_REQUIRES_DEV 1
1819 : : #define FS_BINARY_MOUNTDATA 2
1820 : : #define FS_HAS_SUBTYPE 4
1821 : : #define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
1822 : : #define FS_USERNS_DEV_MOUNT 16 /* A userns mount does not imply MNT_NODEV */
1823 : : #define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
1824 : : struct dentry *(*mount) (struct file_system_type *, int,
1825 : : const char *, void *);
1826 : : void (*kill_sb) (struct super_block *);
1827 : : struct module *owner;
1828 : : struct file_system_type * next;
1829 : : struct hlist_head fs_supers;
1830 : :
1831 : : struct lock_class_key s_lock_key;
1832 : : struct lock_class_key s_umount_key;
1833 : : struct lock_class_key s_vfs_rename_key;
1834 : : struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
1835 : :
1836 : : struct lock_class_key i_lock_key;
1837 : : struct lock_class_key i_mutex_key;
1838 : : struct lock_class_key i_mutex_dir_key;
1839 : : };
1840 : :
1841 : : #define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
1842 : :
1843 : : extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
1844 : : void *data, int (*fill_super)(struct super_block *, void *, int));
1845 : : extern struct dentry *mount_bdev(struct file_system_type *fs_type,
1846 : : int flags, const char *dev_name, void *data,
1847 : : int (*fill_super)(struct super_block *, void *, int));
1848 : : extern struct dentry *mount_single(struct file_system_type *fs_type,
1849 : : int flags, void *data,
1850 : : int (*fill_super)(struct super_block *, void *, int));
1851 : : extern struct dentry *mount_nodev(struct file_system_type *fs_type,
1852 : : int flags, void *data,
1853 : : int (*fill_super)(struct super_block *, void *, int));
1854 : : extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
1855 : : void generic_shutdown_super(struct super_block *sb);
1856 : : void kill_block_super(struct super_block *sb);
1857 : : void kill_anon_super(struct super_block *sb);
1858 : : void kill_litter_super(struct super_block *sb);
1859 : : void deactivate_super(struct super_block *sb);
1860 : : void deactivate_locked_super(struct super_block *sb);
1861 : : int set_anon_super(struct super_block *s, void *data);
1862 : : int get_anon_bdev(dev_t *);
1863 : : void free_anon_bdev(dev_t);
1864 : : struct super_block *sget(struct file_system_type *type,
1865 : : int (*test)(struct super_block *,void *),
1866 : : int (*set)(struct super_block *,void *),
1867 : : int flags, void *data);
1868 : : extern struct dentry *mount_pseudo(struct file_system_type *, char *,
1869 : : const struct super_operations *ops,
1870 : : const struct dentry_operations *dops,
1871 : : unsigned long);
1872 : :
1873 : : /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
1874 : : #define fops_get(fops) \
1875 : : (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
1876 : : #define fops_put(fops) \
1877 : : do { if (fops) module_put((fops)->owner); } while(0)
1878 : : /*
1879 : : * This one is to be used *ONLY* from ->open() instances.
1880 : : * fops must be non-NULL, pinned down *and* module dependencies
1881 : : * should be sufficient to pin the caller down as well.
1882 : : */
1883 : : #define replace_fops(f, fops) \
1884 : : do { \
1885 : : struct file *__file = (f); \
1886 : : fops_put(__file->f_op); \
1887 : : BUG_ON(!(__file->f_op = (fops))); \
1888 : : } while(0)
1889 : :
1890 : : extern int register_filesystem(struct file_system_type *);
1891 : : extern int unregister_filesystem(struct file_system_type *);
1892 : : extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
1893 : : #define kern_mount(type) kern_mount_data(type, NULL)
1894 : : extern void kern_unmount(struct vfsmount *mnt);
1895 : : extern int may_umount_tree(struct vfsmount *);
1896 : : extern int may_umount(struct vfsmount *);
1897 : : extern long do_mount(const char *, const char *, const char *, unsigned long, void *);
1898 : : extern struct vfsmount *collect_mounts(struct path *);
1899 : : extern void drop_collected_mounts(struct vfsmount *);
1900 : : extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
1901 : : struct vfsmount *);
1902 : : extern int vfs_statfs(struct path *, struct kstatfs *);
1903 : : extern int user_statfs(const char __user *, struct kstatfs *);
1904 : : extern int fd_statfs(int, struct kstatfs *);
1905 : : extern int vfs_ustat(dev_t, struct kstatfs *);
1906 : : extern int freeze_super(struct super_block *super);
1907 : : extern int thaw_super(struct super_block *super);
1908 : : extern bool our_mnt(struct vfsmount *mnt);
1909 : : extern bool fs_fully_visible(struct file_system_type *);
1910 : :
1911 : : extern int current_umask(void);
1912 : :
1913 : : extern void ihold(struct inode * inode);
1914 : : extern void iput(struct inode *);
1915 : :
1916 : : /* /sys/fs */
1917 : : extern struct kobject *fs_kobj;
1918 : :
1919 : : #define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)
1920 : :
1921 : : #define FLOCK_VERIFY_READ 1
1922 : : #define FLOCK_VERIFY_WRITE 2
1923 : :
1924 : : #ifdef CONFIG_FILE_LOCKING
1925 : : extern int locks_mandatory_locked(struct inode *);
1926 : : extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
1927 : :
1928 : : /*
1929 : : * Candidates for mandatory locking have the setgid bit set
1930 : : * but no group execute bit - an otherwise meaningless combination.
1931 : : */
1932 : :
1933 : : static inline int __mandatory_lock(struct inode *ino)
1934 : : {
1935 : 44 : return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
1936 : : }
1937 : :
1938 : : /*
1939 : : * ... and these candidates should be on MS_MANDLOCK mounted fs,
1940 : : * otherwise these will be advisory locks
1941 : : */
1942 : :
1943 : 44 : static inline int mandatory_lock(struct inode *ino)
1944 : : {
1945 [ + + ][ + + ]: 3348625 : return IS_MANDLOCK(ino) && __mandatory_lock(ino);
[ + + ][ + + ]
[ + + ][ + ]
1946 : : }
1947 : :
1948 : : static inline int locks_verify_locked(struct inode *inode)
1949 : : {
1950 [ - + ]: 106036 : if (mandatory_lock(inode))
1951 : 0 : return locks_mandatory_locked(inode);
1952 : : return 0;
1953 : : }
1954 : :
1955 : : static inline int locks_verify_truncate(struct inode *inode,
1956 : : struct file *filp,
1957 : : loff_t size)
1958 : : {
1959 [ + + ][ + + ]: 49439 : if (inode->i_flock && mandatory_lock(inode))
[ - + ][ # # ]
1960 [ + - ][ # # ]: 30 : return locks_mandatory_area(
1961 : : FLOCK_VERIFY_WRITE, inode, filp,
1962 : 30 : size < inode->i_size ? size : inode->i_size,
1963 : : (size < inode->i_size ? inode->i_size - size
1964 : : : size - inode->i_size)
1965 : : );
1966 : : return 0;
1967 : : }
1968 : :
1969 : : static inline int break_lease(struct inode *inode, unsigned int mode)
1970 : : {
1971 [ + + ][ - + ]: 2465293 : if (inode->i_flock)
1972 : 1088 : return __break_lease(inode, mode, FL_LEASE);
1973 : : return 0;
1974 : : }
1975 : :
1976 : : static inline int break_deleg(struct inode *inode, unsigned int mode)
1977 : : {
1978 [ + + ][ - + ]: 444798 : if (inode->i_flock)
[ - + ][ # # ]
[ - + ][ # # ]
[ + + ]
1979 : 18443 : return __break_lease(inode, mode, FL_DELEG);
1980 : : return 0;
1981 : : }
1982 : :
1983 : : static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
1984 : : {
1985 : : int ret;
1986 : :
1987 : : ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
1988 [ - + ][ - + ]: 444799 : if (ret == -EWOULDBLOCK && delegated_inode) {
[ - + ][ - + ]
1989 : 0 : *delegated_inode = inode;
1990 : 0 : ihold(inode);
1991 : : }
1992 : : return ret;
1993 : : }
1994 : :
1995 : : static inline int break_deleg_wait(struct inode **delegated_inode)
1996 : : {
1997 : : int ret;
1998 : :
1999 : : ret = break_deleg(*delegated_inode, O_WRONLY);
2000 : 0 : iput(*delegated_inode);
2001 : 0 : *delegated_inode = NULL;
2002 : : return ret;
2003 : : }
2004 : :
2005 : : #else /* !CONFIG_FILE_LOCKING */
2006 : : static inline int locks_mandatory_locked(struct inode *inode)
2007 : : {
2008 : : return 0;
2009 : : }
2010 : :
2011 : : static inline int locks_mandatory_area(int rw, struct inode *inode,
2012 : : struct file *filp, loff_t offset,
2013 : : size_t count)
2014 : : {
2015 : : return 0;
2016 : : }
2017 : :
2018 : : static inline int __mandatory_lock(struct inode *inode)
2019 : : {
2020 : : return 0;
2021 : : }
2022 : :
2023 : : static inline int mandatory_lock(struct inode *inode)
2024 : : {
2025 : : return 0;
2026 : : }
2027 : :
2028 : : static inline int locks_verify_locked(struct inode *inode)
2029 : : {
2030 : : return 0;
2031 : : }
2032 : :
2033 : : static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
2034 : : size_t size)
2035 : : {
2036 : : return 0;
2037 : : }
2038 : :
2039 : : static inline int break_lease(struct inode *inode, unsigned int mode)
2040 : : {
2041 : : return 0;
2042 : : }
2043 : :
2044 : : static inline int break_deleg(struct inode *inode, unsigned int mode)
2045 : : {
2046 : : return 0;
2047 : : }
2048 : :
2049 : : static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2050 : : {
2051 : : return 0;
2052 : : }
2053 : :
2054 : : static inline int break_deleg_wait(struct inode **delegated_inode)
2055 : : {
2056 : : BUG();
2057 : : return 0;
2058 : : }
2059 : :
2060 : : #endif /* CONFIG_FILE_LOCKING */
2061 : :
2062 : : /* fs/open.c */
2063 : : struct audit_names;
2064 : : struct filename {
2065 : : const char *name; /* pointer to actual string */
2066 : : const __user char *uptr; /* original userland pointer */
2067 : : struct audit_names *aname;
2068 : : bool separate; /* should "name" be freed? */
2069 : : };
2070 : :
2071 : : extern long vfs_truncate(struct path *, loff_t);
2072 : : extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
2073 : : struct file *filp);
2074 : : extern int do_fallocate(struct file *file, int mode, loff_t offset,
2075 : : loff_t len);
2076 : : extern long do_sys_open(int dfd, const char __user *filename, int flags,
2077 : : umode_t mode);
2078 : : extern struct file *file_open_name(struct filename *, int, umode_t);
2079 : : extern struct file *filp_open(const char *, int, umode_t);
2080 : : extern struct file *file_open_root(struct dentry *, struct vfsmount *,
2081 : : const char *, int);
2082 : : extern struct file * dentry_open(const struct path *, int, const struct cred *);
2083 : : extern int filp_close(struct file *, fl_owner_t id);
2084 : :
2085 : : extern struct filename *getname(const char __user *);
2086 : : extern struct filename *getname_kernel(const char *);
2087 : :
2088 : : enum {
2089 : : FILE_CREATED = 1,
2090 : : FILE_OPENED = 2
2091 : : };
2092 : : extern int finish_open(struct file *file, struct dentry *dentry,
2093 : : int (*open)(struct inode *, struct file *),
2094 : : int *opened);
2095 : : extern int finish_no_open(struct file *file, struct dentry *dentry);
2096 : :
2097 : : /* fs/ioctl.c */
2098 : :
2099 : : extern int ioctl_preallocate(struct file *filp, void __user *argp);
2100 : :
2101 : : /* fs/dcache.c */
2102 : : extern void __init vfs_caches_init_early(void);
2103 : : extern void __init vfs_caches_init(unsigned long);
2104 : :
2105 : : extern struct kmem_cache *names_cachep;
2106 : :
2107 : : extern void final_putname(struct filename *name);
2108 : :
2109 : : #define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
2110 : : #define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
2111 : : #ifndef CONFIG_AUDITSYSCALL
2112 : : #define putname(name) final_putname(name)
2113 : : #else
2114 : : extern void putname(struct filename *name);
2115 : : #endif
2116 : :
2117 : : #ifdef CONFIG_BLOCK
2118 : : extern int register_blkdev(unsigned int, const char *);
2119 : : extern void unregister_blkdev(unsigned int, const char *);
2120 : : extern struct block_device *bdget(dev_t);
2121 : : extern struct block_device *bdgrab(struct block_device *bdev);
2122 : : extern void bd_set_size(struct block_device *, loff_t size);
2123 : : extern void bd_forget(struct inode *inode);
2124 : : extern void bdput(struct block_device *);
2125 : : extern void invalidate_bdev(struct block_device *);
2126 : : extern void iterate_bdevs(void (*)(struct block_device *, void *), void *);
2127 : : extern int sync_blockdev(struct block_device *bdev);
2128 : : extern void kill_bdev(struct block_device *);
2129 : : extern struct super_block *freeze_bdev(struct block_device *);
2130 : : extern void emergency_thaw_all(void);
2131 : : extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
2132 : : extern int fsync_bdev(struct block_device *);
2133 : : extern int sb_is_blkdev_sb(struct super_block *sb);
2134 : : #else
2135 : : static inline void bd_forget(struct inode *inode) {}
2136 : : static inline int sync_blockdev(struct block_device *bdev) { return 0; }
2137 : : static inline void kill_bdev(struct block_device *bdev) {}
2138 : : static inline void invalidate_bdev(struct block_device *bdev) {}
2139 : :
2140 : : static inline struct super_block *freeze_bdev(struct block_device *sb)
2141 : : {
2142 : : return NULL;
2143 : : }
2144 : :
2145 : : static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
2146 : : {
2147 : : return 0;
2148 : : }
2149 : :
2150 : : static inline void iterate_bdevs(void (*f)(struct block_device *, void *), void *arg)
2151 : : {
2152 : : }
2153 : :
2154 : : static inline int sb_is_blkdev_sb(struct super_block *sb)
2155 : : {
2156 : : return 0;
2157 : : }
2158 : : #endif
2159 : : extern int sync_filesystem(struct super_block *);
2160 : : extern const struct file_operations def_blk_fops;
2161 : : extern const struct file_operations def_chr_fops;
2162 : : extern const struct file_operations bad_sock_fops;
2163 : : #ifdef CONFIG_BLOCK
2164 : : extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
2165 : : extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
2166 : : extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
2167 : : extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
2168 : : extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
2169 : : void *holder);
2170 : : extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
2171 : : void *holder);
2172 : : extern void blkdev_put(struct block_device *bdev, fmode_t mode);
2173 : : #ifdef CONFIG_SYSFS
2174 : : extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
2175 : : extern void bd_unlink_disk_holder(struct block_device *bdev,
2176 : : struct gendisk *disk);
2177 : : #else
2178 : : static inline int bd_link_disk_holder(struct block_device *bdev,
2179 : : struct gendisk *disk)
2180 : : {
2181 : : return 0;
2182 : : }
2183 : : static inline void bd_unlink_disk_holder(struct block_device *bdev,
2184 : : struct gendisk *disk)
2185 : : {
2186 : : }
2187 : : #endif
2188 : : #endif
2189 : :
2190 : : /* fs/char_dev.c */
2191 : : #define CHRDEV_MAJOR_HASH_SIZE 255
2192 : : extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2193 : : extern int register_chrdev_region(dev_t, unsigned, const char *);
2194 : : extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2195 : : unsigned int count, const char *name,
2196 : : const struct file_operations *fops);
2197 : : extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2198 : : unsigned int count, const char *name);
2199 : : extern void unregister_chrdev_region(dev_t, unsigned);
2200 : : extern void chrdev_show(struct seq_file *,off_t);
2201 : :
2202 : : static inline int register_chrdev(unsigned int major, const char *name,
2203 : : const struct file_operations *fops)
2204 : : {
2205 : 0 : return __register_chrdev(major, 0, 256, name, fops);
2206 : : }
2207 : :
2208 : : static inline void unregister_chrdev(unsigned int major, const char *name)
2209 : : {
2210 : 0 : __unregister_chrdev(major, 0, 256, name);
2211 : : }
2212 : :
2213 : : /* fs/block_dev.c */
2214 : : #define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
2215 : : #define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */
2216 : :
2217 : : #ifdef CONFIG_BLOCK
2218 : : #define BLKDEV_MAJOR_HASH_SIZE 255
2219 : : extern const char *__bdevname(dev_t, char *buffer);
2220 : : extern const char *bdevname(struct block_device *bdev, char *buffer);
2221 : : extern struct block_device *lookup_bdev(const char *);
2222 : : extern void blkdev_show(struct seq_file *,off_t);
2223 : :
2224 : : #else
2225 : : #define BLKDEV_MAJOR_HASH_SIZE 0
2226 : : #endif
2227 : :
2228 : : extern void init_special_inode(struct inode *, umode_t, dev_t);
2229 : :
2230 : : /* Invalid inode operations -- fs/bad_inode.c */
2231 : : extern void make_bad_inode(struct inode *);
2232 : : extern int is_bad_inode(struct inode *);
2233 : :
2234 : : #ifdef CONFIG_BLOCK
2235 : : /*
2236 : : * return READ, READA, or WRITE
2237 : : */
2238 : : #define bio_rw(bio) ((bio)->bi_rw & (RW_MASK | RWA_MASK))
2239 : :
2240 : : /*
2241 : : * return data direction, READ or WRITE
2242 : : */
2243 : : #define bio_data_dir(bio) ((bio)->bi_rw & 1)
2244 : :
2245 : : extern void check_disk_size_change(struct gendisk *disk,
2246 : : struct block_device *bdev);
2247 : : extern int revalidate_disk(struct gendisk *);
2248 : : extern int check_disk_change(struct block_device *);
2249 : : extern int __invalidate_device(struct block_device *, bool);
2250 : : extern int invalidate_partition(struct gendisk *, int);
2251 : : #endif
2252 : : unsigned long invalidate_mapping_pages(struct address_space *mapping,
2253 : : pgoff_t start, pgoff_t end);
2254 : :
2255 : : static inline void invalidate_remote_inode(struct inode *inode)
2256 : : {
2257 : : if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2258 : : S_ISLNK(inode->i_mode))
2259 : : invalidate_mapping_pages(inode->i_mapping, 0, -1);
2260 : : }
2261 : : extern int invalidate_inode_pages2(struct address_space *mapping);
2262 : : extern int invalidate_inode_pages2_range(struct address_space *mapping,
2263 : : pgoff_t start, pgoff_t end);
2264 : : extern int write_inode_now(struct inode *, int);
2265 : : extern int filemap_fdatawrite(struct address_space *);
2266 : : extern int filemap_flush(struct address_space *);
2267 : : extern int filemap_fdatawait(struct address_space *);
2268 : : extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
2269 : : loff_t lend);
2270 : : extern int filemap_write_and_wait(struct address_space *mapping);
2271 : : extern int filemap_write_and_wait_range(struct address_space *mapping,
2272 : : loff_t lstart, loff_t lend);
2273 : : extern int __filemap_fdatawrite_range(struct address_space *mapping,
2274 : : loff_t start, loff_t end, int sync_mode);
2275 : : extern int filemap_fdatawrite_range(struct address_space *mapping,
2276 : : loff_t start, loff_t end);
2277 : :
2278 : : extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2279 : : int datasync);
2280 : : extern int vfs_fsync(struct file *file, int datasync);
2281 : : static inline int generic_write_sync(struct file *file, loff_t pos, loff_t count)
2282 : : {
2283 [ + + ][ + - ]: 3397386 : if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host))
[ + + ]
2284 : : return 0;
2285 : 9075 : return vfs_fsync_range(file, pos, pos + count - 1,
2286 : 2 : (file->f_flags & __O_SYNC) ? 0 : 1);
2287 : : }
2288 : : extern void emergency_sync(void);
2289 : : extern void emergency_remount(void);
2290 : : #ifdef CONFIG_BLOCK
2291 : : extern sector_t bmap(struct inode *, sector_t);
2292 : : #endif
2293 : : extern int notify_change(struct dentry *, struct iattr *, struct inode **);
2294 : : extern int inode_permission(struct inode *, int);
2295 : : extern int generic_permission(struct inode *, int);
2296 : :
2297 : : static inline bool execute_ok(struct inode *inode)
2298 : : {
2299 [ # # ][ # # ]: 0 : return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
2300 : : }
2301 : :
2302 : : static inline struct inode *file_inode(struct file *f)
2303 : : {
2304 : : return f->f_inode;
2305 : : }
2306 : :
2307 : 4957785 : static inline void file_start_write(struct file *file)
2308 : : {
2309 [ + + ][ + + ]: 4957785 : if (!S_ISREG(file_inode(file)->i_mode))
[ + + ]
2310 : : return;
2311 : 3397479 : __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
2312 : : }
2313 : :
2314 : 1 : static inline bool file_start_write_trylock(struct file *file)
2315 : : {
2316 [ + - ]: 1 : if (!S_ISREG(file_inode(file)->i_mode))
2317 : : return true;
2318 : 1 : return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false);
2319 : : }
2320 : :
2321 : 4970130 : static inline void file_end_write(struct file *file)
2322 : : {
2323 [ + + ]: 4970130 : if (!S_ISREG(file_inode(file)->i_mode))
[ # # + + ]
[ + + ]
2324 : : return;
2325 : 3394501 : __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
2326 : : }
2327 : :
2328 : : /*
2329 : : * get_write_access() gets write permission for a file.
2330 : : * put_write_access() releases this write permission.
2331 : : * This is used for regular files.
2332 : : * We cannot support write (and maybe mmap read-write shared) accesses and
2333 : : * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
2334 : : * can have the following values:
2335 : : * 0: no writers, no VM_DENYWRITE mappings
2336 : : * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
2337 : : * > 0: (i_writecount) users are writing to the file.
2338 : : *
2339 : : * Normally we operate on that counter with atomic_{inc,dec} and it's safe
2340 : : * except for the cases where we don't hold i_writecount yet. Then we need to
2341 : : * use {get,deny}_write_access() - these functions check the sign and refuse
2342 : : * to do the change if sign is wrong.
2343 : : */
2344 : 0 : static inline int get_write_access(struct inode *inode)
2345 : : {
2346 [ + + ][ - + ]: 3684310 : return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
2347 : : }
2348 : 163819 : static inline int deny_write_access(struct file *file)
2349 : : {
2350 : : struct inode *inode = file_inode(file);
2351 [ + + ][ - + ]: 327619 : return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
2352 : : }
2353 : : static inline void put_write_access(struct inode * inode)
2354 : : {
2355 : 3235375 : atomic_dec(&inode->i_writecount);
2356 : : }
2357 : 163830 : static inline void allow_write_access(struct file *file)
2358 : : {
2359 [ + - ][ # # ]: 163825 : if (file)
[ # # ][ # # ]
2360 : 163830 : atomic_inc(&file_inode(file)->i_writecount);
2361 : : }
2362 : : static inline bool inode_is_open_for_write(const struct inode *inode)
2363 : : {
2364 : : return atomic_read(&inode->i_writecount) > 0;
2365 : : }
2366 : :
2367 : : #ifdef CONFIG_IMA
2368 : : static inline void i_readcount_dec(struct inode *inode)
2369 : : {
2370 : : BUG_ON(!atomic_read(&inode->i_readcount));
2371 : : atomic_dec(&inode->i_readcount);
2372 : : }
2373 : : static inline void i_readcount_inc(struct inode *inode)
2374 : : {
2375 : : atomic_inc(&inode->i_readcount);
2376 : : }
2377 : : #else
2378 : : static inline void i_readcount_dec(struct inode *inode)
2379 : : {
2380 : : return;
2381 : : }
2382 : : static inline void i_readcount_inc(struct inode *inode)
2383 : : {
2384 : : return;
2385 : : }
2386 : : #endif
2387 : : extern int do_pipe_flags(int *, int);
2388 : :
2389 : : extern int kernel_read(struct file *, loff_t, char *, unsigned long);
2390 : : extern ssize_t kernel_write(struct file *, const char *, size_t, loff_t);
2391 : : extern struct file * open_exec(const char *);
2392 : :
2393 : : /* fs/dcache.c -- generic fs support functions */
2394 : : extern int is_subdir(struct dentry *, struct dentry *);
2395 : : extern int path_is_under(struct path *, struct path *);
2396 : :
2397 : : #include <linux/err.h>
2398 : :
2399 : : /* needed for stackable file system support */
2400 : : extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
2401 : :
2402 : : extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
2403 : :
2404 : : extern int inode_init_always(struct super_block *, struct inode *);
2405 : : extern void inode_init_once(struct inode *);
2406 : : extern void address_space_init_once(struct address_space *mapping);
2407 : : extern struct inode * igrab(struct inode *);
2408 : : extern ino_t iunique(struct super_block *, ino_t);
2409 : : extern int inode_needs_sync(struct inode *inode);
2410 : : extern int generic_delete_inode(struct inode *inode);
2411 : : static inline int generic_drop_inode(struct inode *inode)
2412 : : {
2413 [ + + ][ + + ]: 804843 : return !inode->i_nlink || inode_unhashed(inode);
2414 : : }
2415 : :
2416 : : extern struct inode *ilookup5_nowait(struct super_block *sb,
2417 : : unsigned long hashval, int (*test)(struct inode *, void *),
2418 : : void *data);
2419 : : extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
2420 : : int (*test)(struct inode *, void *), void *data);
2421 : : extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
2422 : :
2423 : : extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
2424 : : extern struct inode * iget_locked(struct super_block *, unsigned long);
2425 : : extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
2426 : : extern int insert_inode_locked(struct inode *);
2427 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
2428 : : extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
2429 : : #else
2430 : : static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
2431 : : #endif
2432 : : extern void unlock_new_inode(struct inode *);
2433 : : extern unsigned int get_next_ino(void);
2434 : :
2435 : : extern void __iget(struct inode * inode);
2436 : : extern void iget_failed(struct inode *);
2437 : : extern void clear_inode(struct inode *);
2438 : : extern void __destroy_inode(struct inode *);
2439 : : extern struct inode *new_inode_pseudo(struct super_block *sb);
2440 : : extern struct inode *new_inode(struct super_block *sb);
2441 : : extern void free_inode_nonrcu(struct inode *inode);
2442 : : extern int should_remove_suid(struct dentry *);
2443 : : extern int file_remove_suid(struct file *);
2444 : :
2445 : : extern void __insert_inode_hash(struct inode *, unsigned long hashval);
2446 : : static inline void insert_inode_hash(struct inode *inode)
2447 : : {
2448 : 0 : __insert_inode_hash(inode, inode->i_ino);
2449 : : }
2450 : :
2451 : : extern void __remove_inode_hash(struct inode *);
2452 : : static inline void remove_inode_hash(struct inode *inode)
2453 : : {
2454 [ + + ]: 1678113 : if (!inode_unhashed(inode))
2455 : 279197 : __remove_inode_hash(inode);
2456 : : }
2457 : :
2458 : : extern void inode_sb_list_add(struct inode *inode);
2459 : :
2460 : : #ifdef CONFIG_BLOCK
2461 : : extern void submit_bio(int, struct bio *);
2462 : : extern int bdev_read_only(struct block_device *);
2463 : : #endif
2464 : : extern int set_blocksize(struct block_device *, int);
2465 : : extern int sb_set_blocksize(struct super_block *, int);
2466 : : extern int sb_min_blocksize(struct super_block *, int);
2467 : :
2468 : : extern int generic_file_mmap(struct file *, struct vm_area_struct *);
2469 : : extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
2470 : : extern int generic_file_remap_pages(struct vm_area_struct *, unsigned long addr,
2471 : : unsigned long size, pgoff_t pgoff);
2472 : : extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
2473 : : int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
2474 : : extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
2475 : : extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,
2476 : : loff_t *);
2477 : : extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
2478 : : extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
2479 : : unsigned long *, loff_t, loff_t *, size_t, size_t);
2480 : : extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
2481 : : unsigned long, loff_t, loff_t *, size_t, ssize_t);
2482 : : extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
2483 : : extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
2484 : : extern int generic_segment_checks(const struct iovec *iov,
2485 : : unsigned long *nr_segs, size_t *count, int access_flags);
2486 : :
2487 : : /* fs/block_dev.c */
2488 : : extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
2489 : : unsigned long nr_segs, loff_t pos);
2490 : : extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
2491 : : int datasync);
2492 : : extern void block_sync_page(struct page *page);
2493 : :
2494 : : /* fs/splice.c */
2495 : : extern ssize_t generic_file_splice_read(struct file *, loff_t *,
2496 : : struct pipe_inode_info *, size_t, unsigned int);
2497 : : extern ssize_t default_file_splice_read(struct file *, loff_t *,
2498 : : struct pipe_inode_info *, size_t, unsigned int);
2499 : : extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
2500 : : struct file *, loff_t *, size_t, unsigned int);
2501 : : extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
2502 : : struct file *out, loff_t *, size_t len, unsigned int flags);
2503 : :
2504 : : extern void
2505 : : file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
2506 : : extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
2507 : : extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
2508 : : extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
2509 : : extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
2510 : : extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
2511 : : int whence, loff_t maxsize, loff_t eof);
2512 : : extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
2513 : : int whence, loff_t size);
2514 : : extern int generic_file_open(struct inode * inode, struct file * filp);
2515 : : extern int nonseekable_open(struct inode * inode, struct file * filp);
2516 : :
2517 : : #ifdef CONFIG_FS_XIP
2518 : : extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
2519 : : loff_t *ppos);
2520 : : extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
2521 : : extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
2522 : : size_t len, loff_t *ppos);
2523 : : extern int xip_truncate_page(struct address_space *mapping, loff_t from);
2524 : : #else
2525 : : static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
2526 : : {
2527 : : return 0;
2528 : : }
2529 : : #endif
2530 : :
2531 : : #ifdef CONFIG_BLOCK
2532 : : typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
2533 : : loff_t file_offset);
2534 : :
2535 : : enum {
2536 : : /* need locking between buffered and direct access */
2537 : : DIO_LOCKING = 0x01,
2538 : :
2539 : : /* filesystem does not support filling holes */
2540 : : DIO_SKIP_HOLES = 0x02,
2541 : : };
2542 : :
2543 : : void dio_end_io(struct bio *bio, int error);
2544 : :
2545 : : ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
2546 : : struct block_device *bdev, const struct iovec *iov, loff_t offset,
2547 : : unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
2548 : : dio_submit_t submit_io, int flags);
2549 : :
2550 : : static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
2551 : : struct inode *inode, const struct iovec *iov, loff_t offset,
2552 : : unsigned long nr_segs, get_block_t get_block)
2553 : : {
2554 : 101202 : return __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2555 : : offset, nr_segs, get_block, NULL, NULL,
2556 : : DIO_LOCKING | DIO_SKIP_HOLES);
2557 : : }
2558 : : #endif
2559 : :
2560 : : void inode_dio_wait(struct inode *inode);
2561 : : void inode_dio_done(struct inode *inode);
2562 : :
2563 : : extern const struct file_operations generic_ro_fops;
2564 : :
2565 : : #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
2566 : :
2567 : : extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
2568 : : extern int page_readlink(struct dentry *, char __user *, int);
2569 : : extern void *page_follow_link_light(struct dentry *, struct nameidata *);
2570 : : extern void page_put_link(struct dentry *, struct nameidata *, void *);
2571 : : extern int __page_symlink(struct inode *inode, const char *symname, int len,
2572 : : int nofs);
2573 : : extern int page_symlink(struct inode *inode, const char *symname, int len);
2574 : : extern const struct inode_operations page_symlink_inode_operations;
2575 : : extern void kfree_put_link(struct dentry *, struct nameidata *, void *);
2576 : : extern int generic_readlink(struct dentry *, char __user *, int);
2577 : : extern void generic_fillattr(struct inode *, struct kstat *);
2578 : : int vfs_getattr_nosec(struct path *path, struct kstat *stat);
2579 : : extern int vfs_getattr(struct path *, struct kstat *);
2580 : : void __inode_add_bytes(struct inode *inode, loff_t bytes);
2581 : : void inode_add_bytes(struct inode *inode, loff_t bytes);
2582 : : void __inode_sub_bytes(struct inode *inode, loff_t bytes);
2583 : : void inode_sub_bytes(struct inode *inode, loff_t bytes);
2584 : : loff_t inode_get_bytes(struct inode *inode);
2585 : : void inode_set_bytes(struct inode *inode, loff_t bytes);
2586 : :
2587 : : extern int vfs_readdir(struct file *, filldir_t, void *);
2588 : : extern int iterate_dir(struct file *, struct dir_context *);
2589 : :
2590 : : extern int vfs_stat(const char __user *, struct kstat *);
2591 : : extern int vfs_lstat(const char __user *, struct kstat *);
2592 : : extern int vfs_fstat(unsigned int, struct kstat *);
2593 : : extern int vfs_fstatat(int , const char __user *, struct kstat *, int);
2594 : :
2595 : : extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
2596 : : unsigned long arg);
2597 : : extern int __generic_block_fiemap(struct inode *inode,
2598 : : struct fiemap_extent_info *fieinfo,
2599 : : loff_t start, loff_t len,
2600 : : get_block_t *get_block);
2601 : : extern int generic_block_fiemap(struct inode *inode,
2602 : : struct fiemap_extent_info *fieinfo, u64 start,
2603 : : u64 len, get_block_t *get_block);
2604 : :
2605 : : extern void get_filesystem(struct file_system_type *fs);
2606 : : extern void put_filesystem(struct file_system_type *fs);
2607 : : extern struct file_system_type *get_fs_type(const char *name);
2608 : : extern struct super_block *get_super(struct block_device *);
2609 : : extern struct super_block *get_super_thawed(struct block_device *);
2610 : : extern struct super_block *get_active_super(struct block_device *bdev);
2611 : : extern void drop_super(struct super_block *sb);
2612 : : extern void iterate_supers(void (*)(struct super_block *, void *), void *);
2613 : : extern void iterate_supers_type(struct file_system_type *,
2614 : : void (*)(struct super_block *, void *), void *);
2615 : :
2616 : : extern int dcache_dir_open(struct inode *, struct file *);
2617 : : extern int dcache_dir_close(struct inode *, struct file *);
2618 : : extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
2619 : : extern int dcache_readdir(struct file *, struct dir_context *);
2620 : : extern int simple_setattr(struct dentry *, struct iattr *);
2621 : : extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
2622 : : extern int simple_statfs(struct dentry *, struct kstatfs *);
2623 : : extern int simple_open(struct inode *inode, struct file *file);
2624 : : extern int simple_link(struct dentry *, struct inode *, struct dentry *);
2625 : : extern int simple_unlink(struct inode *, struct dentry *);
2626 : : extern int simple_rmdir(struct inode *, struct dentry *);
2627 : : extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
2628 : : extern int noop_fsync(struct file *, loff_t, loff_t, int);
2629 : : extern int simple_empty(struct dentry *);
2630 : : extern int simple_readpage(struct file *file, struct page *page);
2631 : : extern int simple_write_begin(struct file *file, struct address_space *mapping,
2632 : : loff_t pos, unsigned len, unsigned flags,
2633 : : struct page **pagep, void **fsdata);
2634 : : extern int simple_write_end(struct file *file, struct address_space *mapping,
2635 : : loff_t pos, unsigned len, unsigned copied,
2636 : : struct page *page, void *fsdata);
2637 : : extern int always_delete_dentry(const struct dentry *);
2638 : : extern struct inode *alloc_anon_inode(struct super_block *);
2639 : : extern const struct dentry_operations simple_dentry_operations;
2640 : :
2641 : : extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
2642 : : extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
2643 : : extern const struct file_operations simple_dir_operations;
2644 : : extern const struct inode_operations simple_dir_inode_operations;
2645 : : struct tree_descr { char *name; const struct file_operations *ops; int mode; };
2646 : : struct dentry *d_alloc_name(struct dentry *, const char *);
2647 : : extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
2648 : : extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
2649 : : extern void simple_release_fs(struct vfsmount **mount, int *count);
2650 : :
2651 : : extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
2652 : : loff_t *ppos, const void *from, size_t available);
2653 : : extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
2654 : : const void __user *from, size_t count);
2655 : :
2656 : : extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
2657 : :
2658 : : extern int generic_check_addressable(unsigned, u64);
2659 : :
2660 : : #ifdef CONFIG_MIGRATION
2661 : : extern int buffer_migrate_page(struct address_space *,
2662 : : struct page *, struct page *,
2663 : : enum migrate_mode);
2664 : : #else
2665 : : #define buffer_migrate_page NULL
2666 : : #endif
2667 : :
2668 : : extern int inode_change_ok(const struct inode *, struct iattr *);
2669 : : extern int inode_newsize_ok(const struct inode *, loff_t offset);
2670 : : extern void setattr_copy(struct inode *inode, const struct iattr *attr);
2671 : :
2672 : : extern int file_update_time(struct file *file);
2673 : :
2674 : : extern int generic_show_options(struct seq_file *m, struct dentry *root);
2675 : : extern void save_mount_options(struct super_block *sb, char *options);
2676 : : extern void replace_mount_options(struct super_block *sb, char *options);
2677 : :
2678 : : static inline ino_t parent_ino(struct dentry *dentry)
2679 : : {
2680 : : ino_t res;
2681 : :
2682 : : /*
2683 : : * Don't strictly need d_lock here? If the parent ino could change
2684 : : * then surely we'd have a deeper race in the caller?
2685 : : */
2686 : : spin_lock(&dentry->d_lock);
2687 : 3088 : res = dentry->d_parent->d_inode->i_ino;
2688 : : spin_unlock(&dentry->d_lock);
2689 : : return res;
2690 : : }
2691 : :
2692 : : /* Transaction based IO helpers */
2693 : :
2694 : : /*
2695 : : * An argresp is stored in an allocated page and holds the
2696 : : * size of the argument or response, along with its content
2697 : : */
2698 : : struct simple_transaction_argresp {
2699 : : ssize_t size;
2700 : : char data[0];
2701 : : };
2702 : :
2703 : : #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
2704 : :
2705 : : char *simple_transaction_get(struct file *file, const char __user *buf,
2706 : : size_t size);
2707 : : ssize_t simple_transaction_read(struct file *file, char __user *buf,
2708 : : size_t size, loff_t *pos);
2709 : : int simple_transaction_release(struct inode *inode, struct file *file);
2710 : :
2711 : : void simple_transaction_set(struct file *file, size_t n);
2712 : :
2713 : : /*
2714 : : * simple attribute files
2715 : : *
2716 : : * These attributes behave similar to those in sysfs:
2717 : : *
2718 : : * Writing to an attribute immediately sets a value, an open file can be
2719 : : * written to multiple times.
2720 : : *
2721 : : * Reading from an attribute creates a buffer from the value that might get
2722 : : * read with multiple read calls. When the attribute has been read
2723 : : * completely, no further read calls are possible until the file is opened
2724 : : * again.
2725 : : *
2726 : : * All attributes contain a text representation of a numeric value
2727 : : * that are accessed with the get() and set() functions.
2728 : : */
2729 : : #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
2730 : : static int __fops ## _open(struct inode *inode, struct file *file) \
2731 : : { \
2732 : : __simple_attr_check_format(__fmt, 0ull); \
2733 : : return simple_attr_open(inode, file, __get, __set, __fmt); \
2734 : : } \
2735 : : static const struct file_operations __fops = { \
2736 : : .owner = THIS_MODULE, \
2737 : : .open = __fops ## _open, \
2738 : : .release = simple_attr_release, \
2739 : : .read = simple_attr_read, \
2740 : : .write = simple_attr_write, \
2741 : : .llseek = generic_file_llseek, \
2742 : : };
2743 : :
2744 : : static inline __printf(1, 2)
2745 : : void __simple_attr_check_format(const char *fmt, ...)
2746 : : {
2747 : : /* don't do anything, just let the compiler check the arguments; */
2748 : : }
2749 : :
2750 : : int simple_attr_open(struct inode *inode, struct file *file,
2751 : : int (*get)(void *, u64 *), int (*set)(void *, u64),
2752 : : const char *fmt);
2753 : : int simple_attr_release(struct inode *inode, struct file *file);
2754 : : ssize_t simple_attr_read(struct file *file, char __user *buf,
2755 : : size_t len, loff_t *ppos);
2756 : : ssize_t simple_attr_write(struct file *file, const char __user *buf,
2757 : : size_t len, loff_t *ppos);
2758 : :
2759 : : struct ctl_table;
2760 : : int proc_nr_files(struct ctl_table *table, int write,
2761 : : void __user *buffer, size_t *lenp, loff_t *ppos);
2762 : : int proc_nr_dentry(struct ctl_table *table, int write,
2763 : : void __user *buffer, size_t *lenp, loff_t *ppos);
2764 : : int proc_nr_inodes(struct ctl_table *table, int write,
2765 : : void __user *buffer, size_t *lenp, loff_t *ppos);
2766 : : int __init get_filesystem_list(char *buf);
2767 : :
2768 : : #define __FMODE_EXEC ((__force int) FMODE_EXEC)
2769 : : #define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
2770 : :
2771 : : #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
2772 : : #define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
2773 : : (flag & __FMODE_NONOTIFY)))
2774 : :
2775 : : static inline int is_sxid(umode_t mode)
2776 : : {
2777 [ + + ][ + + ]: 3841 : return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
2778 : : }
2779 : :
2780 : : static inline void inode_has_no_xattr(struct inode *inode)
2781 : : {
2782 : : if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & MS_NOSEC))
2783 : : inode->i_flags |= S_NOSEC;
2784 : : }
2785 : :
2786 : : static inline bool dir_emit(struct dir_context *ctx,
2787 : : const char *name, int namelen,
2788 : : u64 ino, unsigned type)
2789 : : {
2790 : 238849 : return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
2791 : : }
2792 : : static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
2793 : : {
2794 : 3088 : return ctx->actor(ctx, ".", 1, ctx->pos,
2795 : 3088 : file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
2796 : : }
2797 : : static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
2798 : : {
2799 : 3088 : return ctx->actor(ctx, "..", 2, ctx->pos,
2800 : : parent_ino(file->f_path.dentry), DT_DIR) == 0;
2801 : : }
2802 : 5665 : static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
2803 : : {
2804 [ + + ][ + + ]: 5893 : if (ctx->pos == 0) {
2805 [ + - + - ]: 3088 : if (!dir_emit_dot(file, ctx))
2806 : : return false;
2807 : 3088 : ctx->pos = 1;
2808 : : }
2809 [ + + ][ + + ]: 5893 : if (ctx->pos == 1) {
2810 [ + - + - ]: 3088 : if (!dir_emit_dotdot(file, ctx))
2811 : : return false;
2812 : 3088 : ctx->pos = 2;
2813 : : }
2814 : : return true;
2815 : : }
2816 : : static inline bool dir_relax(struct inode *inode)
2817 : : {
2818 : 0 : mutex_unlock(&inode->i_mutex);
2819 : 0 : mutex_lock(&inode->i_mutex);
2820 : 0 : return !IS_DEADDIR(inode);
2821 : : }
2822 : :
2823 : : #endif /* _LINUX_FS_H */
|
