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