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