This source file includes following definitions.
- is_sync_kiocb
- mapping_tagged
- i_mmap_lock_write
- i_mmap_unlock_write
- i_mmap_lock_read
- i_mmap_unlock_read
- mapping_mapped
- mapping_writably_mapped
- mapping_map_writable
- mapping_unmap_writable
- mapping_deny_writable
- mapping_allow_writable
- uncached_acl_sentinel
- is_uncached_acl
- i_blocksize
- inode_unhashed
- inode_fake_hash
- inode_lock
- inode_unlock
- inode_lock_shared
- inode_unlock_shared
- inode_trylock
- inode_trylock_shared
- inode_is_locked
- inode_lock_nested
- inode_lock_shared_nested
- i_size_read
- i_size_write
- iminor
- imajor
- ra_has_index
- get_file
- fcntl_getlk
- fcntl_setlk
- fcntl_getlk64
- fcntl_setlk64
- fcntl_setlease
- fcntl_getlease
- locks_free_lock_context
- locks_init_lock
- locks_copy_conflock
- locks_copy_lock
- locks_remove_posix
- locks_remove_file
- posix_test_lock
- posix_lock_file
- locks_delete_block
- vfs_test_lock
- vfs_lock_file
- vfs_cancel_lock
- locks_lock_inode_wait
- __break_lease
- lease_get_mtime
- generic_setlease
- vfs_setlease
- lease_modify
- show_fd_locks
- file_inode
- file_dentry
- locks_lock_file_wait
- i_uid_read
- i_gid_read
- i_uid_write
- i_gid_write
- sb_end_write
- sb_end_pagefault
- sb_end_intwrite
- sb_start_write
- sb_start_write_trylock
- sb_start_pagefault
- sb_start_intwrite
- sb_start_intwrite_trylock
- call_read_iter
- call_write_iter
- call_mmap
- sb_rdonly
- HAS_UNMAPPED_ID
- file_write_hint
- ki_hint_validate
- init_sync_kiocb
- mark_inode_dirty
- mark_inode_dirty_sync
- inode_inc_link_count
- inode_dec_link_count
- file_accessed
- mount_bdev
- kill_block_super
- __mandatory_lock
- mandatory_lock
- locks_verify_locked
- locks_verify_truncate
- locks_mandatory_locked
- locks_mandatory_area
- __mandatory_lock
- mandatory_lock
- locks_verify_locked
- locks_verify_truncate
- break_lease
- break_deleg
- try_break_deleg
- break_deleg_wait
- break_layout
- break_lease
- break_deleg
- try_break_deleg
- break_deleg_wait
- break_layout
- file_clone_open
- sb_is_blkdev_sb
- bd_forget
- sync_blockdev
- kill_bdev
- invalidate_bdev
- freeze_bdev
- thaw_bdev
- emergency_thaw_bdev
- iterate_bdevs
- sb_is_blkdev_sb
- bd_link_disk_holder
- bd_unlink_disk_holder
- register_chrdev
- unregister_chrdev
- invalidate_remote_inode
- filemap_fdatawait
- file_write_and_wait
- filemap_set_wb_err
- filemap_check_wb_err
- filemap_sample_wb_err
- filemap_nr_thps
- filemap_nr_thps_inc
- filemap_nr_thps_dec
- generic_write_sync
- execute_ok
- file_start_write
- file_start_write_trylock
- file_end_write
- get_write_access
- deny_write_access
- put_write_access
- allow_write_access
- inode_is_open_for_write
- i_readcount_dec
- i_readcount_inc
- i_readcount_dec
- i_readcount_inc
- __kernel_read_file_id
- kernel_read_file_id_str
- generic_drop_inode
- lockdep_annotate_inode_mutex_key
- insert_inode_hash
- remove_inode_hash
- blockdev_direct_IO
- inode_dio_begin
- inode_dio_end
- __inode_get_bytes
- vfs_stat
- vfs_lstat
- vfs_fstatat
- vfs_fstat
- io_is_direct
- vma_is_dax
- vma_is_fsdax
- iocb_flags
- kiocb_set_rw_flags
- parent_ino
- __printf
- is_sxid
- check_sticky
- inode_has_no_xattr
- is_root_inode
- dir_emit
- dir_emit_dot
- dir_emit_dotdot
- dir_emit_dots
- dir_relax
- dir_relax_shared
- io_uring_get_socket
- simple_fill_fsxattr
- inode_drain_writes
1
2 #ifndef _LINUX_FS_H
3 #define _LINUX_FS_H
4
5 #include <linux/linkage.h>
6 #include <linux/wait_bit.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/xarray.h>
17 #include <linux/rbtree.h>
18 #include <linux/init.h>
19 #include <linux/pid.h>
20 #include <linux/bug.h>
21 #include <linux/mutex.h>
22 #include <linux/rwsem.h>
23 #include <linux/mm_types.h>
24 #include <linux/capability.h>
25 #include <linux/semaphore.h>
26 #include <linux/fcntl.h>
27 #include <linux/fiemap.h>
28 #include <linux/rculist_bl.h>
29 #include <linux/atomic.h>
30 #include <linux/shrinker.h>
31 #include <linux/migrate_mode.h>
32 #include <linux/uidgid.h>
33 #include <linux/lockdep.h>
34 #include <linux/percpu-rwsem.h>
35 #include <linux/workqueue.h>
36 #include <linux/delayed_call.h>
37 #include <linux/uuid.h>
38 #include <linux/errseq.h>
39 #include <linux/ioprio.h>
40 #include <linux/fs_types.h>
41 #include <linux/build_bug.h>
42 #include <linux/stddef.h>
43
44 #include <asm/byteorder.h>
45 #include <uapi/linux/fs.h>
46
47 struct backing_dev_info;
48 struct bdi_writeback;
49 struct bio;
50 struct export_operations;
51 struct hd_geometry;
52 struct iovec;
53 struct kiocb;
54 struct kobject;
55 struct pipe_inode_info;
56 struct poll_table_struct;
57 struct kstatfs;
58 struct vm_area_struct;
59 struct vfsmount;
60 struct cred;
61 struct swap_info_struct;
62 struct seq_file;
63 struct workqueue_struct;
64 struct iov_iter;
65 struct fscrypt_info;
66 struct fscrypt_operations;
67 struct fsverity_info;
68 struct fsverity_operations;
69 struct fs_context;
70 struct fs_parameter_description;
71
72 extern void __init inode_init(void);
73 extern void __init inode_init_early(void);
74 extern void __init files_init(void);
75 extern void __init files_maxfiles_init(void);
76
77 extern struct files_stat_struct files_stat;
78 extern unsigned long get_max_files(void);
79 extern unsigned int sysctl_nr_open;
80 extern struct inodes_stat_t inodes_stat;
81 extern int leases_enable, lease_break_time;
82 extern int sysctl_protected_symlinks;
83 extern int sysctl_protected_hardlinks;
84 extern int sysctl_protected_fifos;
85 extern int sysctl_protected_regular;
86
87 typedef __kernel_rwf_t rwf_t;
88
89 struct buffer_head;
90 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
91 struct buffer_head *bh_result, int create);
92 typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
93 ssize_t bytes, void *private);
94
95 #define MAY_EXEC 0x00000001
96 #define MAY_WRITE 0x00000002
97 #define MAY_READ 0x00000004
98 #define MAY_APPEND 0x00000008
99 #define MAY_ACCESS 0x00000010
100 #define MAY_OPEN 0x00000020
101 #define MAY_CHDIR 0x00000040
102
103 #define MAY_NOT_BLOCK 0x00000080
104
105
106
107
108
109
110
111 #define FMODE_READ ((__force fmode_t)0x1)
112
113 #define FMODE_WRITE ((__force fmode_t)0x2)
114
115 #define FMODE_LSEEK ((__force fmode_t)0x4)
116
117 #define FMODE_PREAD ((__force fmode_t)0x8)
118
119 #define FMODE_PWRITE ((__force fmode_t)0x10)
120
121 #define FMODE_EXEC ((__force fmode_t)0x20)
122
123 #define FMODE_NDELAY ((__force fmode_t)0x40)
124
125 #define FMODE_EXCL ((__force fmode_t)0x80)
126
127
128 #define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
129
130 #define FMODE_32BITHASH ((__force fmode_t)0x200)
131
132 #define FMODE_64BITHASH ((__force fmode_t)0x400)
133
134
135
136
137
138
139
140 #define FMODE_NOCMTIME ((__force fmode_t)0x800)
141
142
143 #define FMODE_RANDOM ((__force fmode_t)0x1000)
144
145
146 #define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
147
148
149 #define FMODE_PATH ((__force fmode_t)0x4000)
150
151
152 #define FMODE_ATOMIC_POS ((__force fmode_t)0x8000)
153
154 #define FMODE_WRITER ((__force fmode_t)0x10000)
155
156 #define FMODE_CAN_READ ((__force fmode_t)0x20000)
157
158 #define FMODE_CAN_WRITE ((__force fmode_t)0x40000)
159
160 #define FMODE_OPENED ((__force fmode_t)0x80000)
161 #define FMODE_CREATED ((__force fmode_t)0x100000)
162
163
164 #define FMODE_STREAM ((__force fmode_t)0x200000)
165
166
167 #define FMODE_NONOTIFY ((__force fmode_t)0x4000000)
168
169
170 #define FMODE_NOWAIT ((__force fmode_t)0x8000000)
171
172
173 #define FMODE_NEED_UNMOUNT ((__force fmode_t)0x10000000)
174
175
176 #define FMODE_NOACCOUNT ((__force fmode_t)0x20000000)
177
178
179
180
181
182
183
184 #define CHECK_IOVEC_ONLY -1
185
186
187
188
189
190 #define ATTR_MODE (1 << 0)
191 #define ATTR_UID (1 << 1)
192 #define ATTR_GID (1 << 2)
193 #define ATTR_SIZE (1 << 3)
194 #define ATTR_ATIME (1 << 4)
195 #define ATTR_MTIME (1 << 5)
196 #define ATTR_CTIME (1 << 6)
197 #define ATTR_ATIME_SET (1 << 7)
198 #define ATTR_MTIME_SET (1 << 8)
199 #define ATTR_FORCE (1 << 9)
200 #define ATTR_KILL_SUID (1 << 11)
201 #define ATTR_KILL_SGID (1 << 12)
202 #define ATTR_FILE (1 << 13)
203 #define ATTR_KILL_PRIV (1 << 14)
204 #define ATTR_OPEN (1 << 15)
205 #define ATTR_TIMES_SET (1 << 16)
206 #define ATTR_TOUCH (1 << 17)
207
208
209
210
211
212 #define WHITEOUT_MODE 0
213 #define WHITEOUT_DEV 0
214
215
216
217
218
219
220
221
222
223
224 struct iattr {
225 unsigned int ia_valid;
226 umode_t ia_mode;
227 kuid_t ia_uid;
228 kgid_t ia_gid;
229 loff_t ia_size;
230 struct timespec64 ia_atime;
231 struct timespec64 ia_mtime;
232 struct timespec64 ia_ctime;
233
234
235
236
237
238
239 struct file *ia_file;
240 };
241
242
243
244
245 #include <linux/quota.h>
246
247
248
249
250
251 #define FILESYSTEM_MAX_STACK_DEPTH 2
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279 enum positive_aop_returns {
280 AOP_WRITEPAGE_ACTIVATE = 0x80000,
281 AOP_TRUNCATED_PAGE = 0x80001,
282 };
283
284 #define AOP_FLAG_CONT_EXPAND 0x0001
285 #define AOP_FLAG_NOFS 0x0002
286
287
288
289
290
291
292 struct page;
293 struct address_space;
294 struct writeback_control;
295
296
297
298
299
300 enum rw_hint {
301 WRITE_LIFE_NOT_SET = 0,
302 WRITE_LIFE_NONE = RWH_WRITE_LIFE_NONE,
303 WRITE_LIFE_SHORT = RWH_WRITE_LIFE_SHORT,
304 WRITE_LIFE_MEDIUM = RWH_WRITE_LIFE_MEDIUM,
305 WRITE_LIFE_LONG = RWH_WRITE_LIFE_LONG,
306 WRITE_LIFE_EXTREME = RWH_WRITE_LIFE_EXTREME,
307 };
308
309 #define IOCB_EVENTFD (1 << 0)
310 #define IOCB_APPEND (1 << 1)
311 #define IOCB_DIRECT (1 << 2)
312 #define IOCB_HIPRI (1 << 3)
313 #define IOCB_DSYNC (1 << 4)
314 #define IOCB_SYNC (1 << 5)
315 #define IOCB_WRITE (1 << 6)
316 #define IOCB_NOWAIT (1 << 7)
317
318 struct kiocb {
319 struct file *ki_filp;
320
321
322 randomized_struct_fields_start
323
324 loff_t ki_pos;
325 void (*ki_complete)(struct kiocb *iocb, long ret, long ret2);
326 void *private;
327 int ki_flags;
328 u16 ki_hint;
329 u16 ki_ioprio;
330 unsigned int ki_cookie;
331
332 randomized_struct_fields_end
333 };
334
335 static inline bool is_sync_kiocb(struct kiocb *kiocb)
336 {
337 return kiocb->ki_complete == NULL;
338 }
339
340
341
342
343
344
345
346
347
348
349 typedef struct {
350 size_t written;
351 size_t count;
352 union {
353 char __user *buf;
354 void *data;
355 } arg;
356 int error;
357 } read_descriptor_t;
358
359 typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
360 unsigned long, unsigned long);
361
362 struct address_space_operations {
363 int (*writepage)(struct page *page, struct writeback_control *wbc);
364 int (*readpage)(struct file *, struct page *);
365
366
367 int (*writepages)(struct address_space *, struct writeback_control *);
368
369
370 int (*set_page_dirty)(struct page *page);
371
372
373
374
375
376 int (*readpages)(struct file *filp, struct address_space *mapping,
377 struct list_head *pages, unsigned nr_pages);
378
379 int (*write_begin)(struct file *, struct address_space *mapping,
380 loff_t pos, unsigned len, unsigned flags,
381 struct page **pagep, void **fsdata);
382 int (*write_end)(struct file *, struct address_space *mapping,
383 loff_t pos, unsigned len, unsigned copied,
384 struct page *page, void *fsdata);
385
386
387 sector_t (*bmap)(struct address_space *, sector_t);
388 void (*invalidatepage) (struct page *, unsigned int, unsigned int);
389 int (*releasepage) (struct page *, gfp_t);
390 void (*freepage)(struct page *);
391 ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
392
393
394
395
396 int (*migratepage) (struct address_space *,
397 struct page *, struct page *, enum migrate_mode);
398 bool (*isolate_page)(struct page *, isolate_mode_t);
399 void (*putback_page)(struct page *);
400 int (*launder_page) (struct page *);
401 int (*is_partially_uptodate) (struct page *, unsigned long,
402 unsigned long);
403 void (*is_dirty_writeback) (struct page *, bool *, bool *);
404 int (*error_remove_page)(struct address_space *, struct page *);
405
406
407 int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
408 sector_t *span);
409 void (*swap_deactivate)(struct file *file);
410 };
411
412 extern const struct address_space_operations empty_aops;
413
414
415
416
417
418 int pagecache_write_begin(struct file *, struct address_space *mapping,
419 loff_t pos, unsigned len, unsigned flags,
420 struct page **pagep, void **fsdata);
421
422 int pagecache_write_end(struct file *, struct address_space *mapping,
423 loff_t pos, unsigned len, unsigned copied,
424 struct page *page, void *fsdata);
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445 struct address_space {
446 struct inode *host;
447 struct xarray i_pages;
448 gfp_t gfp_mask;
449 atomic_t i_mmap_writable;
450 #ifdef CONFIG_READ_ONLY_THP_FOR_FS
451
452 atomic_t nr_thps;
453 #endif
454 struct rb_root_cached i_mmap;
455 struct rw_semaphore i_mmap_rwsem;
456 unsigned long nrpages;
457 unsigned long nrexceptional;
458 pgoff_t writeback_index;
459 const struct address_space_operations *a_ops;
460 unsigned long flags;
461 errseq_t wb_err;
462 spinlock_t private_lock;
463 struct list_head private_list;
464 void *private_data;
465 } __attribute__((aligned(sizeof(long)))) __randomize_layout;
466
467
468
469
470
471 struct request_queue;
472
473 struct block_device {
474 dev_t bd_dev;
475 int bd_openers;
476 struct inode * bd_inode;
477 struct super_block * bd_super;
478 struct mutex bd_mutex;
479 void * bd_claiming;
480 void * bd_holder;
481 int bd_holders;
482 bool bd_write_holder;
483 #ifdef CONFIG_SYSFS
484 struct list_head bd_holder_disks;
485 #endif
486 struct block_device * bd_contains;
487 unsigned bd_block_size;
488 u8 bd_partno;
489 struct hd_struct * bd_part;
490
491 unsigned bd_part_count;
492 int bd_invalidated;
493 struct gendisk * bd_disk;
494 struct request_queue * bd_queue;
495 struct backing_dev_info *bd_bdi;
496 struct list_head bd_list;
497
498
499
500
501
502
503 unsigned long bd_private;
504
505
506 int bd_fsfreeze_count;
507
508 struct mutex bd_fsfreeze_mutex;
509 } __randomize_layout;
510
511
512 #define PAGECACHE_TAG_DIRTY XA_MARK_0
513 #define PAGECACHE_TAG_WRITEBACK XA_MARK_1
514 #define PAGECACHE_TAG_TOWRITE XA_MARK_2
515
516
517
518
519 static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
520 {
521 return xa_marked(&mapping->i_pages, tag);
522 }
523
524 static inline void i_mmap_lock_write(struct address_space *mapping)
525 {
526 down_write(&mapping->i_mmap_rwsem);
527 }
528
529 static inline void i_mmap_unlock_write(struct address_space *mapping)
530 {
531 up_write(&mapping->i_mmap_rwsem);
532 }
533
534 static inline void i_mmap_lock_read(struct address_space *mapping)
535 {
536 down_read(&mapping->i_mmap_rwsem);
537 }
538
539 static inline void i_mmap_unlock_read(struct address_space *mapping)
540 {
541 up_read(&mapping->i_mmap_rwsem);
542 }
543
544
545
546
547 static inline int mapping_mapped(struct address_space *mapping)
548 {
549 return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root);
550 }
551
552
553
554
555
556
557
558
559
560
561 static inline int mapping_writably_mapped(struct address_space *mapping)
562 {
563 return atomic_read(&mapping->i_mmap_writable) > 0;
564 }
565
566 static inline int mapping_map_writable(struct address_space *mapping)
567 {
568 return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
569 0 : -EPERM;
570 }
571
572 static inline void mapping_unmap_writable(struct address_space *mapping)
573 {
574 atomic_dec(&mapping->i_mmap_writable);
575 }
576
577 static inline int mapping_deny_writable(struct address_space *mapping)
578 {
579 return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
580 0 : -EBUSY;
581 }
582
583 static inline void mapping_allow_writable(struct address_space *mapping)
584 {
585 atomic_inc(&mapping->i_mmap_writable);
586 }
587
588
589
590
591 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
592 #include <linux/seqlock.h>
593 #define __NEED_I_SIZE_ORDERED
594 #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
595 #else
596 #define i_size_ordered_init(inode) do { } while (0)
597 #endif
598
599 struct posix_acl;
600 #define ACL_NOT_CACHED ((void *)(-1))
601 #define ACL_DONT_CACHE ((void *)(-3))
602
603 static inline struct posix_acl *
604 uncached_acl_sentinel(struct task_struct *task)
605 {
606 return (void *)task + 1;
607 }
608
609 static inline bool
610 is_uncached_acl(struct posix_acl *acl)
611 {
612 return (long)acl & 1;
613 }
614
615 #define IOP_FASTPERM 0x0001
616 #define IOP_LOOKUP 0x0002
617 #define IOP_NOFOLLOW 0x0004
618 #define IOP_XATTR 0x0008
619 #define IOP_DEFAULT_READLINK 0x0010
620
621 struct fsnotify_mark_connector;
622
623
624
625
626
627
628 struct inode {
629 umode_t i_mode;
630 unsigned short i_opflags;
631 kuid_t i_uid;
632 kgid_t i_gid;
633 unsigned int i_flags;
634
635 #ifdef CONFIG_FS_POSIX_ACL
636 struct posix_acl *i_acl;
637 struct posix_acl *i_default_acl;
638 #endif
639
640 const struct inode_operations *i_op;
641 struct super_block *i_sb;
642 struct address_space *i_mapping;
643
644 #ifdef CONFIG_SECURITY
645 void *i_security;
646 #endif
647
648
649 unsigned long i_ino;
650
651
652
653
654
655
656
657 union {
658 const unsigned int i_nlink;
659 unsigned int __i_nlink;
660 };
661 dev_t i_rdev;
662 loff_t i_size;
663 struct timespec64 i_atime;
664 struct timespec64 i_mtime;
665 struct timespec64 i_ctime;
666 spinlock_t i_lock;
667 unsigned short i_bytes;
668 u8 i_blkbits;
669 u8 i_write_hint;
670 blkcnt_t i_blocks;
671
672 #ifdef __NEED_I_SIZE_ORDERED
673 seqcount_t i_size_seqcount;
674 #endif
675
676
677 unsigned long i_state;
678 struct rw_semaphore i_rwsem;
679
680 unsigned long dirtied_when;
681 unsigned long dirtied_time_when;
682
683 struct hlist_node i_hash;
684 struct list_head i_io_list;
685 #ifdef CONFIG_CGROUP_WRITEBACK
686 struct bdi_writeback *i_wb;
687
688
689 int i_wb_frn_winner;
690 u16 i_wb_frn_avg_time;
691 u16 i_wb_frn_history;
692 #endif
693 struct list_head i_lru;
694 struct list_head i_sb_list;
695 struct list_head i_wb_list;
696 union {
697 struct hlist_head i_dentry;
698 struct rcu_head i_rcu;
699 };
700 atomic64_t i_version;
701 atomic64_t i_sequence;
702 atomic_t i_count;
703 atomic_t i_dio_count;
704 atomic_t i_writecount;
705 #if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
706 atomic_t i_readcount;
707 #endif
708 union {
709 const struct file_operations *i_fop;
710 void (*free_inode)(struct inode *);
711 };
712 struct file_lock_context *i_flctx;
713 struct address_space i_data;
714 struct list_head i_devices;
715 union {
716 struct pipe_inode_info *i_pipe;
717 struct block_device *i_bdev;
718 struct cdev *i_cdev;
719 char *i_link;
720 unsigned i_dir_seq;
721 };
722
723 __u32 i_generation;
724
725 #ifdef CONFIG_FSNOTIFY
726 __u32 i_fsnotify_mask;
727 struct fsnotify_mark_connector __rcu *i_fsnotify_marks;
728 #endif
729
730 #ifdef CONFIG_FS_ENCRYPTION
731 struct fscrypt_info *i_crypt_info;
732 #endif
733
734 #ifdef CONFIG_FS_VERITY
735 struct fsverity_info *i_verity_info;
736 #endif
737
738 void *i_private;
739 } __randomize_layout;
740
741 struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
742
743 static inline unsigned int i_blocksize(const struct inode *node)
744 {
745 return (1 << node->i_blkbits);
746 }
747
748 static inline int inode_unhashed(struct inode *inode)
749 {
750 return hlist_unhashed(&inode->i_hash);
751 }
752
753
754
755
756
757
758
759 static inline void inode_fake_hash(struct inode *inode)
760 {
761 hlist_add_fake(&inode->i_hash);
762 }
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780 enum inode_i_mutex_lock_class
781 {
782 I_MUTEX_NORMAL,
783 I_MUTEX_PARENT,
784 I_MUTEX_CHILD,
785 I_MUTEX_XATTR,
786 I_MUTEX_NONDIR2,
787 I_MUTEX_PARENT2,
788 };
789
790 static inline void inode_lock(struct inode *inode)
791 {
792 down_write(&inode->i_rwsem);
793 }
794
795 static inline void inode_unlock(struct inode *inode)
796 {
797 up_write(&inode->i_rwsem);
798 }
799
800 static inline void inode_lock_shared(struct inode *inode)
801 {
802 down_read(&inode->i_rwsem);
803 }
804
805 static inline void inode_unlock_shared(struct inode *inode)
806 {
807 up_read(&inode->i_rwsem);
808 }
809
810 static inline int inode_trylock(struct inode *inode)
811 {
812 return down_write_trylock(&inode->i_rwsem);
813 }
814
815 static inline int inode_trylock_shared(struct inode *inode)
816 {
817 return down_read_trylock(&inode->i_rwsem);
818 }
819
820 static inline int inode_is_locked(struct inode *inode)
821 {
822 return rwsem_is_locked(&inode->i_rwsem);
823 }
824
825 static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
826 {
827 down_write_nested(&inode->i_rwsem, subclass);
828 }
829
830 static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
831 {
832 down_read_nested(&inode->i_rwsem, subclass);
833 }
834
835 void lock_two_nondirectories(struct inode *, struct inode*);
836 void unlock_two_nondirectories(struct inode *, struct inode*);
837
838
839
840
841
842
843
844
845
846
847
848 static inline loff_t i_size_read(const struct inode *inode)
849 {
850 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
851 loff_t i_size;
852 unsigned int seq;
853
854 do {
855 seq = read_seqcount_begin(&inode->i_size_seqcount);
856 i_size = inode->i_size;
857 } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
858 return i_size;
859 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
860 loff_t i_size;
861
862 preempt_disable();
863 i_size = inode->i_size;
864 preempt_enable();
865 return i_size;
866 #else
867 return inode->i_size;
868 #endif
869 }
870
871
872
873
874
875
876 static inline void i_size_write(struct inode *inode, loff_t i_size)
877 {
878 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
879 preempt_disable();
880 write_seqcount_begin(&inode->i_size_seqcount);
881 inode->i_size = i_size;
882 write_seqcount_end(&inode->i_size_seqcount);
883 preempt_enable();
884 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
885 preempt_disable();
886 inode->i_size = i_size;
887 preempt_enable();
888 #else
889 inode->i_size = i_size;
890 #endif
891 }
892
893 static inline unsigned iminor(const struct inode *inode)
894 {
895 return MINOR(inode->i_rdev);
896 }
897
898 static inline unsigned imajor(const struct inode *inode)
899 {
900 return MAJOR(inode->i_rdev);
901 }
902
903 extern struct block_device *I_BDEV(struct inode *inode);
904
905 struct fown_struct {
906 rwlock_t lock;
907 struct pid *pid;
908 enum pid_type pid_type;
909 kuid_t uid, euid;
910 int signum;
911 };
912
913
914
915
916 struct file_ra_state {
917 pgoff_t start;
918 unsigned int size;
919 unsigned int async_size;
920
921
922 unsigned int ra_pages;
923 unsigned int mmap_miss;
924 loff_t prev_pos;
925 };
926
927
928
929
930 static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
931 {
932 return (index >= ra->start &&
933 index < ra->start + ra->size);
934 }
935
936 struct file {
937 union {
938 struct llist_node fu_llist;
939 struct rcu_head fu_rcuhead;
940 } f_u;
941 struct path f_path;
942 struct inode *f_inode;
943 const struct file_operations *f_op;
944
945
946
947
948
949 spinlock_t f_lock;
950 enum rw_hint f_write_hint;
951 atomic_long_t f_count;
952 unsigned int f_flags;
953 fmode_t f_mode;
954 struct mutex f_pos_lock;
955 loff_t f_pos;
956 struct fown_struct f_owner;
957 const struct cred *f_cred;
958 struct file_ra_state f_ra;
959
960 u64 f_version;
961 #ifdef CONFIG_SECURITY
962 void *f_security;
963 #endif
964
965 void *private_data;
966
967 #ifdef CONFIG_EPOLL
968
969 struct list_head f_ep_links;
970 struct list_head f_tfile_llink;
971 #endif
972 struct address_space *f_mapping;
973 errseq_t f_wb_err;
974 } __randomize_layout
975 __attribute__((aligned(4)));
976
977 struct file_handle {
978 __u32 handle_bytes;
979 int handle_type;
980
981 unsigned char f_handle[];
982 };
983
984 static inline struct file *get_file(struct file *f)
985 {
986 atomic_long_inc(&f->f_count);
987 return f;
988 }
989 #define get_file_rcu_many(x, cnt) \
990 atomic_long_add_unless(&(x)->f_count, (cnt), 0)
991 #define get_file_rcu(x) get_file_rcu_many((x), 1)
992 #define file_count(x) atomic_long_read(&(x)->f_count)
993
994 #define MAX_NON_LFS ((1UL<<31) - 1)
995
996
997
998 #if BITS_PER_LONG==32
999 #define MAX_LFS_FILESIZE ((loff_t)ULONG_MAX << PAGE_SHIFT)
1000 #elif BITS_PER_LONG==64
1001 #define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX)
1002 #endif
1003
1004 #define FL_POSIX 1
1005 #define FL_FLOCK 2
1006 #define FL_DELEG 4
1007 #define FL_ACCESS 8
1008 #define FL_EXISTS 16
1009 #define FL_LEASE 32
1010 #define FL_CLOSE 64
1011 #define FL_SLEEP 128
1012 #define FL_DOWNGRADE_PENDING 256
1013 #define FL_UNLOCK_PENDING 512
1014 #define FL_OFDLCK 1024
1015 #define FL_LAYOUT 2048
1016
1017 #define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE)
1018
1019
1020
1021
1022
1023 #define FILE_LOCK_DEFERRED 1
1024
1025
1026 typedef void *fl_owner_t;
1027
1028 struct file_lock;
1029
1030 struct file_lock_operations {
1031 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
1032 void (*fl_release_private)(struct file_lock *);
1033 };
1034
1035 struct lock_manager_operations {
1036 fl_owner_t (*lm_get_owner)(fl_owner_t);
1037 void (*lm_put_owner)(fl_owner_t);
1038 void (*lm_notify)(struct file_lock *);
1039 int (*lm_grant)(struct file_lock *, int);
1040 bool (*lm_break)(struct file_lock *);
1041 int (*lm_change)(struct file_lock *, int, struct list_head *);
1042 void (*lm_setup)(struct file_lock *, void **);
1043 };
1044
1045 struct lock_manager {
1046 struct list_head list;
1047
1048
1049
1050
1051 bool block_opens;
1052 };
1053
1054 struct net;
1055 void locks_start_grace(struct net *, struct lock_manager *);
1056 void locks_end_grace(struct lock_manager *);
1057 bool locks_in_grace(struct net *);
1058 bool opens_in_grace(struct net *);
1059
1060
1061 #include <linux/nfs_fs_i.h>
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080 struct file_lock {
1081 struct file_lock *fl_blocker;
1082 struct list_head fl_list;
1083 struct hlist_node fl_link;
1084 struct list_head fl_blocked_requests;
1085
1086
1087 struct list_head fl_blocked_member;
1088
1089
1090 fl_owner_t fl_owner;
1091 unsigned int fl_flags;
1092 unsigned char fl_type;
1093 unsigned int fl_pid;
1094 int fl_link_cpu;
1095 wait_queue_head_t fl_wait;
1096 struct file *fl_file;
1097 loff_t fl_start;
1098 loff_t fl_end;
1099
1100 struct fasync_struct * fl_fasync;
1101
1102 unsigned long fl_break_time;
1103 unsigned long fl_downgrade_time;
1104
1105 const struct file_lock_operations *fl_ops;
1106 const struct lock_manager_operations *fl_lmops;
1107 union {
1108 struct nfs_lock_info nfs_fl;
1109 struct nfs4_lock_info nfs4_fl;
1110 struct {
1111 struct list_head link;
1112 int state;
1113 unsigned int debug_id;
1114 } afs;
1115 } fl_u;
1116 } __randomize_layout;
1117
1118 struct file_lock_context {
1119 spinlock_t flc_lock;
1120 struct list_head flc_flock;
1121 struct list_head flc_posix;
1122 struct list_head flc_lease;
1123 };
1124
1125
1126 #ifndef OFFSET_MAX
1127 #define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
1128 #define OFFSET_MAX INT_LIMIT(loff_t)
1129 #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
1130 #endif
1131
1132 extern void send_sigio(struct fown_struct *fown, int fd, int band);
1133
1134 #define locks_inode(f) file_inode(f)
1135
1136 #ifdef CONFIG_FILE_LOCKING
1137 extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
1138 extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1139 struct flock *);
1140
1141 #if BITS_PER_LONG == 32
1142 extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
1143 extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1144 struct flock64 *);
1145 #endif
1146
1147 extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1148 extern int fcntl_getlease(struct file *filp);
1149
1150
1151 void locks_free_lock_context(struct inode *inode);
1152 void locks_free_lock(struct file_lock *fl);
1153 extern void locks_init_lock(struct file_lock *);
1154 extern struct file_lock * locks_alloc_lock(void);
1155 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1156 extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
1157 extern void locks_remove_posix(struct file *, fl_owner_t);
1158 extern void locks_remove_file(struct file *);
1159 extern void locks_release_private(struct file_lock *);
1160 extern void posix_test_lock(struct file *, struct file_lock *);
1161 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1162 extern int locks_delete_block(struct file_lock *);
1163 extern int vfs_test_lock(struct file *, struct file_lock *);
1164 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
1165 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1166 extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
1167 extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
1168 extern void lease_get_mtime(struct inode *, struct timespec64 *time);
1169 extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
1170 extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
1171 extern int lease_modify(struct file_lock *, int, struct list_head *);
1172
1173 struct notifier_block;
1174 extern int lease_register_notifier(struct notifier_block *);
1175 extern void lease_unregister_notifier(struct notifier_block *);
1176
1177 struct files_struct;
1178 extern void show_fd_locks(struct seq_file *f,
1179 struct file *filp, struct files_struct *files);
1180 #else
1181 static inline int fcntl_getlk(struct file *file, unsigned int cmd,
1182 struct flock __user *user)
1183 {
1184 return -EINVAL;
1185 }
1186
1187 static inline int fcntl_setlk(unsigned int fd, struct file *file,
1188 unsigned int cmd, struct flock __user *user)
1189 {
1190 return -EACCES;
1191 }
1192
1193 #if BITS_PER_LONG == 32
1194 static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
1195 struct flock64 __user *user)
1196 {
1197 return -EINVAL;
1198 }
1199
1200 static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1201 unsigned int cmd, struct flock64 __user *user)
1202 {
1203 return -EACCES;
1204 }
1205 #endif
1206 static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1207 {
1208 return -EINVAL;
1209 }
1210
1211 static inline int fcntl_getlease(struct file *filp)
1212 {
1213 return F_UNLCK;
1214 }
1215
1216 static inline void
1217 locks_free_lock_context(struct inode *inode)
1218 {
1219 }
1220
1221 static inline void locks_init_lock(struct file_lock *fl)
1222 {
1223 return;
1224 }
1225
1226 static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
1227 {
1228 return;
1229 }
1230
1231 static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1232 {
1233 return;
1234 }
1235
1236 static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1237 {
1238 return;
1239 }
1240
1241 static inline void locks_remove_file(struct file *filp)
1242 {
1243 return;
1244 }
1245
1246 static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1247 {
1248 return;
1249 }
1250
1251 static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1252 struct file_lock *conflock)
1253 {
1254 return -ENOLCK;
1255 }
1256
1257 static inline int locks_delete_block(struct file_lock *waiter)
1258 {
1259 return -ENOENT;
1260 }
1261
1262 static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1263 {
1264 return 0;
1265 }
1266
1267 static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
1268 struct file_lock *fl, struct file_lock *conf)
1269 {
1270 return -ENOLCK;
1271 }
1272
1273 static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1274 {
1275 return 0;
1276 }
1277
1278 static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1279 {
1280 return -ENOLCK;
1281 }
1282
1283 static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1284 {
1285 return 0;
1286 }
1287
1288 static inline void lease_get_mtime(struct inode *inode,
1289 struct timespec64 *time)
1290 {
1291 return;
1292 }
1293
1294 static inline int generic_setlease(struct file *filp, long arg,
1295 struct file_lock **flp, void **priv)
1296 {
1297 return -EINVAL;
1298 }
1299
1300 static inline int vfs_setlease(struct file *filp, long arg,
1301 struct file_lock **lease, void **priv)
1302 {
1303 return -EINVAL;
1304 }
1305
1306 static inline int lease_modify(struct file_lock *fl, int arg,
1307 struct list_head *dispose)
1308 {
1309 return -EINVAL;
1310 }
1311
1312 struct files_struct;
1313 static inline void show_fd_locks(struct seq_file *f,
1314 struct file *filp, struct files_struct *files) {}
1315 #endif
1316
1317 static inline struct inode *file_inode(const struct file *f)
1318 {
1319 return f->f_inode;
1320 }
1321
1322 static inline struct dentry *file_dentry(const struct file *file)
1323 {
1324 return d_real(file->f_path.dentry, file_inode(file));
1325 }
1326
1327 static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
1328 {
1329 return locks_lock_inode_wait(locks_inode(filp), fl);
1330 }
1331
1332 struct fasync_struct {
1333 rwlock_t fa_lock;
1334 int magic;
1335 int fa_fd;
1336 struct fasync_struct *fa_next;
1337 struct file *fa_file;
1338 struct rcu_head fa_rcu;
1339 };
1340
1341 #define FASYNC_MAGIC 0x4601
1342
1343
1344 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
1345 extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1346 extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1347 extern struct fasync_struct *fasync_alloc(void);
1348 extern void fasync_free(struct fasync_struct *);
1349
1350
1351 extern void kill_fasync(struct fasync_struct **, int, int);
1352
1353 extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1354 extern int f_setown(struct file *filp, unsigned long arg, int force);
1355 extern void f_delown(struct file *filp);
1356 extern pid_t f_getown(struct file *filp);
1357 extern int send_sigurg(struct fown_struct *fown);
1358
1359
1360
1361
1362
1363 #define SB_RDONLY 1
1364 #define SB_NOSUID 2
1365 #define SB_NODEV 4
1366 #define SB_NOEXEC 8
1367 #define SB_SYNCHRONOUS 16
1368 #define SB_MANDLOCK 64
1369 #define SB_DIRSYNC 128
1370 #define SB_NOATIME 1024
1371 #define SB_NODIRATIME 2048
1372 #define SB_SILENT 32768
1373 #define SB_POSIXACL (1<<16)
1374 #define SB_KERNMOUNT (1<<22)
1375 #define SB_I_VERSION (1<<23)
1376 #define SB_LAZYTIME (1<<25)
1377
1378
1379 #define SB_SUBMOUNT (1<<26)
1380 #define SB_FORCE (1<<27)
1381 #define SB_NOSEC (1<<28)
1382 #define SB_BORN (1<<29)
1383 #define SB_ACTIVE (1<<30)
1384 #define SB_NOUSER (1<<31)
1385
1386
1387
1388
1389
1390 #define MNT_FORCE 0x00000001
1391 #define MNT_DETACH 0x00000002
1392 #define MNT_EXPIRE 0x00000004
1393 #define UMOUNT_NOFOLLOW 0x00000008
1394 #define UMOUNT_UNUSED 0x80000000
1395
1396
1397 #define SB_I_CGROUPWB 0x00000001
1398 #define SB_I_NOEXEC 0x00000002
1399 #define SB_I_NODEV 0x00000004
1400 #define SB_I_MULTIROOT 0x00000008
1401
1402
1403 #define SB_I_USERNS_VISIBLE 0x00000010
1404 #define SB_I_IMA_UNVERIFIABLE_SIGNATURE 0x00000020
1405 #define SB_I_UNTRUSTED_MOUNTER 0x00000040
1406
1407
1408 enum {
1409 SB_UNFROZEN = 0,
1410 SB_FREEZE_WRITE = 1,
1411 SB_FREEZE_PAGEFAULT = 2,
1412 SB_FREEZE_FS = 3,
1413
1414 SB_FREEZE_COMPLETE = 4,
1415 };
1416
1417 #define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1418
1419 struct sb_writers {
1420 int frozen;
1421 wait_queue_head_t wait_unfrozen;
1422 struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
1423 };
1424
1425 struct super_block {
1426 struct list_head s_list;
1427 dev_t s_dev;
1428 unsigned char s_blocksize_bits;
1429 unsigned long s_blocksize;
1430 loff_t s_maxbytes;
1431 struct file_system_type *s_type;
1432 const struct super_operations *s_op;
1433 const struct dquot_operations *dq_op;
1434 const struct quotactl_ops *s_qcop;
1435 const struct export_operations *s_export_op;
1436 unsigned long s_flags;
1437 unsigned long s_iflags;
1438 unsigned long s_magic;
1439 struct dentry *s_root;
1440 struct rw_semaphore s_umount;
1441 int s_count;
1442 atomic_t s_active;
1443 #ifdef CONFIG_SECURITY
1444 void *s_security;
1445 #endif
1446 const struct xattr_handler **s_xattr;
1447 #ifdef CONFIG_FS_ENCRYPTION
1448 const struct fscrypt_operations *s_cop;
1449 struct key *s_master_keys;
1450 #endif
1451 #ifdef CONFIG_FS_VERITY
1452 const struct fsverity_operations *s_vop;
1453 #endif
1454 struct hlist_bl_head s_roots;
1455 struct list_head s_mounts;
1456 struct block_device *s_bdev;
1457 struct backing_dev_info *s_bdi;
1458 struct mtd_info *s_mtd;
1459 struct hlist_node s_instances;
1460 unsigned int s_quota_types;
1461 struct quota_info s_dquot;
1462
1463 struct sb_writers s_writers;
1464
1465
1466
1467
1468
1469
1470 void *s_fs_info;
1471
1472
1473 u32 s_time_gran;
1474
1475 time64_t s_time_min;
1476 time64_t s_time_max;
1477 #ifdef CONFIG_FSNOTIFY
1478 __u32 s_fsnotify_mask;
1479 struct fsnotify_mark_connector __rcu *s_fsnotify_marks;
1480 #endif
1481
1482 char s_id[32];
1483 uuid_t s_uuid;
1484
1485 unsigned int s_max_links;
1486 fmode_t s_mode;
1487
1488
1489
1490
1491
1492 struct mutex s_vfs_rename_mutex;
1493
1494
1495
1496
1497
1498 const char *s_subtype;
1499
1500 const struct dentry_operations *s_d_op;
1501
1502
1503
1504
1505 int cleancache_poolid;
1506
1507 struct shrinker s_shrink;
1508
1509
1510 atomic_long_t s_remove_count;
1511
1512
1513 atomic_long_t s_fsnotify_inode_refs;
1514
1515
1516 int s_readonly_remount;
1517
1518
1519 struct workqueue_struct *s_dio_done_wq;
1520 struct hlist_head s_pins;
1521
1522
1523
1524
1525
1526
1527 struct user_namespace *s_user_ns;
1528
1529
1530
1531
1532
1533
1534 struct list_lru s_dentry_lru;
1535 struct list_lru s_inode_lru;
1536 struct rcu_head rcu;
1537 struct work_struct destroy_work;
1538
1539 struct mutex s_sync_lock;
1540
1541
1542
1543
1544 int s_stack_depth;
1545
1546
1547 spinlock_t s_inode_list_lock ____cacheline_aligned_in_smp;
1548 struct list_head s_inodes;
1549
1550 spinlock_t s_inode_wblist_lock;
1551 struct list_head s_inodes_wb;
1552 } __randomize_layout;
1553
1554
1555
1556
1557
1558
1559 static inline uid_t i_uid_read(const struct inode *inode)
1560 {
1561 return from_kuid(inode->i_sb->s_user_ns, inode->i_uid);
1562 }
1563
1564 static inline gid_t i_gid_read(const struct inode *inode)
1565 {
1566 return from_kgid(inode->i_sb->s_user_ns, inode->i_gid);
1567 }
1568
1569 static inline void i_uid_write(struct inode *inode, uid_t uid)
1570 {
1571 inode->i_uid = make_kuid(inode->i_sb->s_user_ns, uid);
1572 }
1573
1574 static inline void i_gid_write(struct inode *inode, gid_t gid)
1575 {
1576 inode->i_gid = make_kgid(inode->i_sb->s_user_ns, gid);
1577 }
1578
1579 extern struct timespec64 timespec64_trunc(struct timespec64 t, unsigned gran);
1580 extern struct timespec64 current_time(struct inode *inode);
1581
1582
1583
1584
1585
1586 void __sb_end_write(struct super_block *sb, int level);
1587 int __sb_start_write(struct super_block *sb, int level, bool wait);
1588
1589 #define __sb_writers_acquired(sb, lev) \
1590 percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1591 #define __sb_writers_release(sb, lev) \
1592 percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1593
1594
1595
1596
1597
1598
1599
1600
1601 static inline void sb_end_write(struct super_block *sb)
1602 {
1603 __sb_end_write(sb, SB_FREEZE_WRITE);
1604 }
1605
1606
1607
1608
1609
1610
1611
1612
1613 static inline void sb_end_pagefault(struct super_block *sb)
1614 {
1615 __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
1616 }
1617
1618
1619
1620
1621
1622
1623
1624
1625 static inline void sb_end_intwrite(struct super_block *sb)
1626 {
1627 __sb_end_write(sb, SB_FREEZE_FS);
1628 }
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649 static inline void sb_start_write(struct super_block *sb)
1650 {
1651 __sb_start_write(sb, SB_FREEZE_WRITE, true);
1652 }
1653
1654 static inline int sb_start_write_trylock(struct super_block *sb)
1655 {
1656 return __sb_start_write(sb, SB_FREEZE_WRITE, false);
1657 }
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678 static inline void sb_start_pagefault(struct super_block *sb)
1679 {
1680 __sb_start_write(sb, SB_FREEZE_PAGEFAULT, true);
1681 }
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696 static inline void sb_start_intwrite(struct super_block *sb)
1697 {
1698 __sb_start_write(sb, SB_FREEZE_FS, true);
1699 }
1700
1701 static inline int sb_start_intwrite_trylock(struct super_block *sb)
1702 {
1703 return __sb_start_write(sb, SB_FREEZE_FS, false);
1704 }
1705
1706
1707 extern bool inode_owner_or_capable(const struct inode *inode);
1708
1709
1710
1711
1712 extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
1713 extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
1714 extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
1715 extern int vfs_symlink(struct inode *, struct dentry *, const char *);
1716 extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
1717 extern int vfs_rmdir(struct inode *, struct dentry *);
1718 extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
1719 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
1720 extern int vfs_whiteout(struct inode *, struct dentry *);
1721
1722 extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
1723 int open_flag);
1724
1725 int vfs_mkobj(struct dentry *, umode_t,
1726 int (*f)(struct dentry *, umode_t, void *),
1727 void *);
1728
1729 extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1730
1731 #ifdef CONFIG_COMPAT
1732 extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
1733 unsigned long arg);
1734 #else
1735 #define compat_ptr_ioctl NULL
1736 #endif
1737
1738
1739
1740
1741 extern void inode_init_owner(struct inode *inode, const struct inode *dir,
1742 umode_t mode);
1743 extern bool may_open_dev(const struct path *path);
1744
1745
1746
1747 struct fiemap_extent_info {
1748 unsigned int fi_flags;
1749 unsigned int fi_extents_mapped;
1750 unsigned int fi_extents_max;
1751 struct fiemap_extent __user *fi_extents_start;
1752
1753 };
1754 int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
1755 u64 phys, u64 len, u32 flags);
1756 int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
1757
1758
1759
1760
1761
1762
1763
1764 struct dir_context;
1765 typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
1766 unsigned);
1767
1768 struct dir_context {
1769 filldir_t actor;
1770 loff_t pos;
1771 };
1772
1773 struct block_device_operations;
1774
1775
1776
1777
1778 #define HAVE_COMPAT_IOCTL 1
1779 #define HAVE_UNLOCKED_IOCTL 1
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791 #define NOMMU_MAP_COPY 0x00000001
1792 #define NOMMU_MAP_DIRECT 0x00000008
1793 #define NOMMU_MAP_READ VM_MAYREAD
1794 #define NOMMU_MAP_WRITE VM_MAYWRITE
1795 #define NOMMU_MAP_EXEC VM_MAYEXEC
1796
1797 #define NOMMU_VMFLAGS \
1798 (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808 #define REMAP_FILE_DEDUP (1 << 0)
1809 #define REMAP_FILE_CAN_SHORTEN (1 << 1)
1810
1811
1812
1813
1814
1815
1816
1817
1818 #define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN)
1819
1820 struct iov_iter;
1821
1822 struct file_operations {
1823 struct module *owner;
1824 loff_t (*llseek) (struct file *, loff_t, int);
1825 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1826 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1827 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
1828 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
1829 int (*iopoll)(struct kiocb *kiocb, bool spin);
1830 int (*iterate) (struct file *, struct dir_context *);
1831 int (*iterate_shared) (struct file *, struct dir_context *);
1832 __poll_t (*poll) (struct file *, struct poll_table_struct *);
1833 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1834 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1835 int (*mmap) (struct file *, struct vm_area_struct *);
1836 unsigned long mmap_supported_flags;
1837 int (*open) (struct inode *, struct file *);
1838 int (*flush) (struct file *, fl_owner_t id);
1839 int (*release) (struct inode *, struct file *);
1840 int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1841 int (*fasync) (int, struct file *, int);
1842 int (*lock) (struct file *, int, struct file_lock *);
1843 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
1844 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1845 int (*check_flags)(int);
1846 int (*flock) (struct file *, int, struct file_lock *);
1847 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1848 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1849 int (*setlease)(struct file *, long, struct file_lock **, void **);
1850 long (*fallocate)(struct file *file, int mode, loff_t offset,
1851 loff_t len);
1852 void (*show_fdinfo)(struct seq_file *m, struct file *f);
1853 #ifndef CONFIG_MMU
1854 unsigned (*mmap_capabilities)(struct file *);
1855 #endif
1856 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
1857 loff_t, size_t, unsigned int);
1858 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
1859 struct file *file_out, loff_t pos_out,
1860 loff_t len, unsigned int remap_flags);
1861 int (*fadvise)(struct file *, loff_t, loff_t, int);
1862 } __randomize_layout;
1863
1864 struct inode_operations {
1865 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
1866 const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
1867 int (*permission) (struct inode *, int);
1868 struct posix_acl * (*get_acl)(struct inode *, int);
1869
1870 int (*readlink) (struct dentry *, char __user *,int);
1871
1872 int (*create) (struct inode *,struct dentry *, umode_t, bool);
1873 int (*link) (struct dentry *,struct inode *,struct dentry *);
1874 int (*unlink) (struct inode *,struct dentry *);
1875 int (*symlink) (struct inode *,struct dentry *,const char *);
1876 int (*mkdir) (struct inode *,struct dentry *,umode_t);
1877 int (*rmdir) (struct inode *,struct dentry *);
1878 int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
1879 int (*rename) (struct inode *, struct dentry *,
1880 struct inode *, struct dentry *, unsigned int);
1881 int (*setattr) (struct dentry *, struct iattr *);
1882 int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);
1883 ssize_t (*listxattr) (struct dentry *, char *, size_t);
1884 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
1885 u64 len);
1886 int (*update_time)(struct inode *, struct timespec64 *, int);
1887 int (*atomic_open)(struct inode *, struct dentry *,
1888 struct file *, unsigned open_flag,
1889 umode_t create_mode);
1890 int (*tmpfile) (struct inode *, struct dentry *, umode_t);
1891 int (*set_acl)(struct inode *, struct posix_acl *, int);
1892 } ____cacheline_aligned;
1893
1894 static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
1895 struct iov_iter *iter)
1896 {
1897 return file->f_op->read_iter(kio, iter);
1898 }
1899
1900 static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
1901 struct iov_iter *iter)
1902 {
1903 return file->f_op->write_iter(kio, iter);
1904 }
1905
1906 static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
1907 {
1908 return file->f_op->mmap(file, vma);
1909 }
1910
1911 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
1912 unsigned long nr_segs, unsigned long fast_segs,
1913 struct iovec *fast_pointer,
1914 struct iovec **ret_pointer);
1915
1916 extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *);
1917 extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
1918 extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
1919 extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
1920 unsigned long, loff_t *, rwf_t);
1921 extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
1922 loff_t, size_t, unsigned int);
1923 extern ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in,
1924 struct file *file_out, loff_t pos_out,
1925 size_t len, unsigned int flags);
1926 extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
1927 struct file *file_out, loff_t pos_out,
1928 loff_t *count,
1929 unsigned int remap_flags);
1930 extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
1931 struct file *file_out, loff_t pos_out,
1932 loff_t len, unsigned int remap_flags);
1933 extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
1934 struct file *file_out, loff_t pos_out,
1935 loff_t len, unsigned int remap_flags);
1936 extern int vfs_dedupe_file_range(struct file *file,
1937 struct file_dedupe_range *same);
1938 extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
1939 struct file *dst_file, loff_t dst_pos,
1940 loff_t len, unsigned int remap_flags);
1941
1942
1943 struct super_operations {
1944 struct inode *(*alloc_inode)(struct super_block *sb);
1945 void (*destroy_inode)(struct inode *);
1946 void (*free_inode)(struct inode *);
1947
1948 void (*dirty_inode) (struct inode *, int flags);
1949 int (*write_inode) (struct inode *, struct writeback_control *wbc);
1950 int (*drop_inode) (struct inode *);
1951 void (*evict_inode) (struct inode *);
1952 void (*put_super) (struct super_block *);
1953 int (*sync_fs)(struct super_block *sb, int wait);
1954 int (*freeze_super) (struct super_block *);
1955 int (*freeze_fs) (struct super_block *);
1956 int (*thaw_super) (struct super_block *);
1957 int (*unfreeze_fs) (struct super_block *);
1958 int (*statfs) (struct dentry *, struct kstatfs *);
1959 int (*remount_fs) (struct super_block *, int *, char *);
1960 void (*umount_begin) (struct super_block *);
1961
1962 int (*show_options)(struct seq_file *, struct dentry *);
1963 int (*show_devname)(struct seq_file *, struct dentry *);
1964 int (*show_path)(struct seq_file *, struct dentry *);
1965 int (*show_stats)(struct seq_file *, struct dentry *);
1966 #ifdef CONFIG_QUOTA
1967 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
1968 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
1969 struct dquot **(*get_dquots)(struct inode *);
1970 #endif
1971 int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
1972 long (*nr_cached_objects)(struct super_block *,
1973 struct shrink_control *);
1974 long (*free_cached_objects)(struct super_block *,
1975 struct shrink_control *);
1976 };
1977
1978
1979
1980
1981 #define S_SYNC 1
1982 #define S_NOATIME 2
1983 #define S_APPEND 4
1984 #define S_IMMUTABLE 8
1985 #define S_DEAD 16
1986 #define S_NOQUOTA 32
1987 #define S_DIRSYNC 64
1988 #define S_NOCMTIME 128
1989 #define S_SWAPFILE 256
1990 #define S_PRIVATE 512
1991 #define S_IMA 1024
1992 #define S_AUTOMOUNT 2048
1993 #define S_NOSEC 4096
1994 #ifdef CONFIG_FS_DAX
1995 #define S_DAX 8192
1996 #else
1997 #define S_DAX 0
1998 #endif
1999 #define S_ENCRYPTED 16384
2000 #define S_CASEFOLD 32768
2001 #define S_VERITY 65536
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016 #define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
2017
2018 static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
2019 #define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
2020 #define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
2021 ((inode)->i_flags & S_SYNC))
2022 #define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \
2023 ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
2024 #define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK)
2025 #define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY|SB_NOATIME)
2026 #define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION)
2027
2028 #define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
2029 #define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
2030 #define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
2031 #define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL)
2032
2033 #define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
2034 #define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
2035 #define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
2036 #define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2037 #define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2038 #define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2039 #define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
2040 #define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2041 #define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
2042 #define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
2043 #define IS_VERITY(inode) ((inode)->i_flags & S_VERITY)
2044
2045 #define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2046 (inode)->i_rdev == WHITEOUT_DEV)
2047
2048 static inline bool HAS_UNMAPPED_ID(struct inode *inode)
2049 {
2050 return !uid_valid(inode->i_uid) || !gid_valid(inode->i_gid);
2051 }
2052
2053 static inline enum rw_hint file_write_hint(struct file *file)
2054 {
2055 if (file->f_write_hint != WRITE_LIFE_NOT_SET)
2056 return file->f_write_hint;
2057
2058 return file_inode(file)->i_write_hint;
2059 }
2060
2061 static inline int iocb_flags(struct file *file);
2062
2063 static inline u16 ki_hint_validate(enum rw_hint hint)
2064 {
2065 typeof(((struct kiocb *)0)->ki_hint) max_hint = -1;
2066
2067 if (hint <= max_hint)
2068 return hint;
2069 return 0;
2070 }
2071
2072 static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
2073 {
2074 *kiocb = (struct kiocb) {
2075 .ki_filp = filp,
2076 .ki_flags = iocb_flags(filp),
2077 .ki_hint = ki_hint_validate(file_write_hint(filp)),
2078 .ki_ioprio = get_current_ioprio(),
2079 };
2080 }
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145 #define I_DIRTY_SYNC (1 << 0)
2146 #define I_DIRTY_DATASYNC (1 << 1)
2147 #define I_DIRTY_PAGES (1 << 2)
2148 #define __I_NEW 3
2149 #define I_NEW (1 << __I_NEW)
2150 #define I_WILL_FREE (1 << 4)
2151 #define I_FREEING (1 << 5)
2152 #define I_CLEAR (1 << 6)
2153 #define __I_SYNC 7
2154 #define I_SYNC (1 << __I_SYNC)
2155 #define I_REFERENCED (1 << 8)
2156 #define __I_DIO_WAKEUP 9
2157 #define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP)
2158 #define I_LINKABLE (1 << 10)
2159 #define I_DIRTY_TIME (1 << 11)
2160 #define __I_DIRTY_TIME_EXPIRED 12
2161 #define I_DIRTY_TIME_EXPIRED (1 << __I_DIRTY_TIME_EXPIRED)
2162 #define I_WB_SWITCH (1 << 13)
2163 #define I_OVL_INUSE (1 << 14)
2164 #define I_CREATING (1 << 15)
2165
2166 #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
2167 #define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
2168 #define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
2169
2170 extern void __mark_inode_dirty(struct inode *, int);
2171 static inline void mark_inode_dirty(struct inode *inode)
2172 {
2173 __mark_inode_dirty(inode, I_DIRTY);
2174 }
2175
2176 static inline void mark_inode_dirty_sync(struct inode *inode)
2177 {
2178 __mark_inode_dirty(inode, I_DIRTY_SYNC);
2179 }
2180
2181 extern void inc_nlink(struct inode *inode);
2182 extern void drop_nlink(struct inode *inode);
2183 extern void clear_nlink(struct inode *inode);
2184 extern void set_nlink(struct inode *inode, unsigned int nlink);
2185
2186 static inline void inode_inc_link_count(struct inode *inode)
2187 {
2188 inc_nlink(inode);
2189 mark_inode_dirty(inode);
2190 }
2191
2192 static inline void inode_dec_link_count(struct inode *inode)
2193 {
2194 drop_nlink(inode);
2195 mark_inode_dirty(inode);
2196 }
2197
2198 enum file_time_flags {
2199 S_ATIME = 1,
2200 S_MTIME = 2,
2201 S_CTIME = 4,
2202 S_VERSION = 8,
2203 };
2204
2205 extern bool atime_needs_update(const struct path *, struct inode *);
2206 extern void touch_atime(const struct path *);
2207 static inline void file_accessed(struct file *file)
2208 {
2209 if (!(file->f_flags & O_NOATIME))
2210 touch_atime(&file->f_path);
2211 }
2212
2213 extern int file_modified(struct file *file);
2214
2215 int sync_inode(struct inode *inode, struct writeback_control *wbc);
2216 int sync_inode_metadata(struct inode *inode, int wait);
2217
2218 struct file_system_type {
2219 const char *name;
2220 int fs_flags;
2221 #define FS_REQUIRES_DEV 1
2222 #define FS_BINARY_MOUNTDATA 2
2223 #define FS_HAS_SUBTYPE 4
2224 #define FS_USERNS_MOUNT 8
2225 #define FS_DISALLOW_NOTIFY_PERM 16
2226 #define FS_RENAME_DOES_D_MOVE 32768
2227 int (*init_fs_context)(struct fs_context *);
2228 const struct fs_parameter_description *parameters;
2229 struct dentry *(*mount) (struct file_system_type *, int,
2230 const char *, void *);
2231 void (*kill_sb) (struct super_block *);
2232 struct module *owner;
2233 struct file_system_type * next;
2234 struct hlist_head fs_supers;
2235
2236 struct lock_class_key s_lock_key;
2237 struct lock_class_key s_umount_key;
2238 struct lock_class_key s_vfs_rename_key;
2239 struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
2240
2241 struct lock_class_key i_lock_key;
2242 struct lock_class_key i_mutex_key;
2243 struct lock_class_key i_mutex_dir_key;
2244 };
2245
2246 #define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2247
2248 #ifdef CONFIG_BLOCK
2249 extern struct dentry *mount_bdev(struct file_system_type *fs_type,
2250 int flags, const char *dev_name, void *data,
2251 int (*fill_super)(struct super_block *, void *, int));
2252 #else
2253 static inline struct dentry *mount_bdev(struct file_system_type *fs_type,
2254 int flags, const char *dev_name, void *data,
2255 int (*fill_super)(struct super_block *, void *, int))
2256 {
2257 return ERR_PTR(-ENODEV);
2258 }
2259 #endif
2260 extern struct dentry *mount_single(struct file_system_type *fs_type,
2261 int flags, void *data,
2262 int (*fill_super)(struct super_block *, void *, int));
2263 extern struct dentry *mount_nodev(struct file_system_type *fs_type,
2264 int flags, void *data,
2265 int (*fill_super)(struct super_block *, void *, int));
2266 extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
2267 void generic_shutdown_super(struct super_block *sb);
2268 #ifdef CONFIG_BLOCK
2269 void kill_block_super(struct super_block *sb);
2270 #else
2271 static inline void kill_block_super(struct super_block *sb)
2272 {
2273 BUG();
2274 }
2275 #endif
2276 void kill_anon_super(struct super_block *sb);
2277 void kill_litter_super(struct super_block *sb);
2278 void deactivate_super(struct super_block *sb);
2279 void deactivate_locked_super(struct super_block *sb);
2280 int set_anon_super(struct super_block *s, void *data);
2281 int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
2282 int get_anon_bdev(dev_t *);
2283 void free_anon_bdev(dev_t);
2284 struct super_block *sget_fc(struct fs_context *fc,
2285 int (*test)(struct super_block *, struct fs_context *),
2286 int (*set)(struct super_block *, struct fs_context *));
2287 struct super_block *sget(struct file_system_type *type,
2288 int (*test)(struct super_block *,void *),
2289 int (*set)(struct super_block *,void *),
2290 int flags, void *data);
2291
2292
2293 #define fops_get(fops) \
2294 (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
2295 #define fops_put(fops) \
2296 do { if (fops) module_put((fops)->owner); } while(0)
2297
2298
2299
2300
2301
2302 #define replace_fops(f, fops) \
2303 do { \
2304 struct file *__file = (f); \
2305 fops_put(__file->f_op); \
2306 BUG_ON(!(__file->f_op = (fops))); \
2307 } while(0)
2308
2309 extern int register_filesystem(struct file_system_type *);
2310 extern int unregister_filesystem(struct file_system_type *);
2311 extern struct vfsmount *kern_mount(struct file_system_type *);
2312 extern void kern_unmount(struct vfsmount *mnt);
2313 extern int may_umount_tree(struct vfsmount *);
2314 extern int may_umount(struct vfsmount *);
2315 extern long do_mount(const char *, const char __user *,
2316 const char *, unsigned long, void *);
2317 extern struct vfsmount *collect_mounts(const struct path *);
2318 extern void drop_collected_mounts(struct vfsmount *);
2319 extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
2320 struct vfsmount *);
2321 extern int vfs_statfs(const struct path *, struct kstatfs *);
2322 extern int user_statfs(const char __user *, struct kstatfs *);
2323 extern int fd_statfs(int, struct kstatfs *);
2324 extern int freeze_super(struct super_block *super);
2325 extern int thaw_super(struct super_block *super);
2326 extern bool our_mnt(struct vfsmount *mnt);
2327 extern __printf(2, 3)
2328 int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
2329 extern int super_setup_bdi(struct super_block *sb);
2330
2331 extern int current_umask(void);
2332
2333 extern void ihold(struct inode * inode);
2334 extern void iput(struct inode *);
2335 extern int generic_update_time(struct inode *, struct timespec64 *, int);
2336
2337
2338 extern struct kobject *fs_kobj;
2339
2340 #define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
2341
2342 #ifdef CONFIG_MANDATORY_FILE_LOCKING
2343 extern int locks_mandatory_locked(struct file *);
2344 extern int locks_mandatory_area(struct inode *, struct file *, loff_t, loff_t, unsigned char);
2345
2346
2347
2348
2349
2350
2351 static inline int __mandatory_lock(struct inode *ino)
2352 {
2353 return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
2354 }
2355
2356
2357
2358
2359
2360
2361 static inline int mandatory_lock(struct inode *ino)
2362 {
2363 return IS_MANDLOCK(ino) && __mandatory_lock(ino);
2364 }
2365
2366 static inline int locks_verify_locked(struct file *file)
2367 {
2368 if (mandatory_lock(locks_inode(file)))
2369 return locks_mandatory_locked(file);
2370 return 0;
2371 }
2372
2373 static inline int locks_verify_truncate(struct inode *inode,
2374 struct file *f,
2375 loff_t size)
2376 {
2377 if (!inode->i_flctx || !mandatory_lock(inode))
2378 return 0;
2379
2380 if (size < inode->i_size) {
2381 return locks_mandatory_area(inode, f, size, inode->i_size - 1,
2382 F_WRLCK);
2383 } else {
2384 return locks_mandatory_area(inode, f, inode->i_size, size - 1,
2385 F_WRLCK);
2386 }
2387 }
2388
2389 #else
2390
2391 static inline int locks_mandatory_locked(struct file *file)
2392 {
2393 return 0;
2394 }
2395
2396 static inline int locks_mandatory_area(struct inode *inode, struct file *filp,
2397 loff_t start, loff_t end, unsigned char type)
2398 {
2399 return 0;
2400 }
2401
2402 static inline int __mandatory_lock(struct inode *inode)
2403 {
2404 return 0;
2405 }
2406
2407 static inline int mandatory_lock(struct inode *inode)
2408 {
2409 return 0;
2410 }
2411
2412 static inline int locks_verify_locked(struct file *file)
2413 {
2414 return 0;
2415 }
2416
2417 static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
2418 size_t size)
2419 {
2420 return 0;
2421 }
2422
2423 #endif
2424
2425
2426 #ifdef CONFIG_FILE_LOCKING
2427 static inline int break_lease(struct inode *inode, unsigned int mode)
2428 {
2429
2430
2431
2432
2433
2434
2435 smp_mb();
2436 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2437 return __break_lease(inode, mode, FL_LEASE);
2438 return 0;
2439 }
2440
2441 static inline int break_deleg(struct inode *inode, unsigned int mode)
2442 {
2443
2444
2445
2446
2447
2448
2449 smp_mb();
2450 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2451 return __break_lease(inode, mode, FL_DELEG);
2452 return 0;
2453 }
2454
2455 static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2456 {
2457 int ret;
2458
2459 ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
2460 if (ret == -EWOULDBLOCK && delegated_inode) {
2461 *delegated_inode = inode;
2462 ihold(inode);
2463 }
2464 return ret;
2465 }
2466
2467 static inline int break_deleg_wait(struct inode **delegated_inode)
2468 {
2469 int ret;
2470
2471 ret = break_deleg(*delegated_inode, O_WRONLY);
2472 iput(*delegated_inode);
2473 *delegated_inode = NULL;
2474 return ret;
2475 }
2476
2477 static inline int break_layout(struct inode *inode, bool wait)
2478 {
2479 smp_mb();
2480 if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2481 return __break_lease(inode,
2482 wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
2483 FL_LAYOUT);
2484 return 0;
2485 }
2486
2487 #else
2488 static inline int break_lease(struct inode *inode, unsigned int mode)
2489 {
2490 return 0;
2491 }
2492
2493 static inline int break_deleg(struct inode *inode, unsigned int mode)
2494 {
2495 return 0;
2496 }
2497
2498 static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2499 {
2500 return 0;
2501 }
2502
2503 static inline int break_deleg_wait(struct inode **delegated_inode)
2504 {
2505 BUG();
2506 return 0;
2507 }
2508
2509 static inline int break_layout(struct inode *inode, bool wait)
2510 {
2511 return 0;
2512 }
2513
2514 #endif
2515
2516
2517 struct audit_names;
2518 struct filename {
2519 const char *name;
2520 const __user char *uptr;
2521 int refcnt;
2522 struct audit_names *aname;
2523 const char iname[];
2524 };
2525 static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
2526
2527 extern long vfs_truncate(const struct path *, loff_t);
2528 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
2529 struct file *filp);
2530 extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
2531 loff_t len);
2532 extern long do_sys_open(int dfd, const char __user *filename, int flags,
2533 umode_t mode);
2534 extern struct file *file_open_name(struct filename *, int, umode_t);
2535 extern struct file *filp_open(const char *, int, umode_t);
2536 extern struct file *file_open_root(struct dentry *, struct vfsmount *,
2537 const char *, int, umode_t);
2538 extern struct file * dentry_open(const struct path *, int, const struct cred *);
2539 extern struct file * open_with_fake_path(const struct path *, int,
2540 struct inode*, const struct cred *);
2541 static inline struct file *file_clone_open(struct file *file)
2542 {
2543 return dentry_open(&file->f_path, file->f_flags, file->f_cred);
2544 }
2545 extern int filp_close(struct file *, fl_owner_t id);
2546
2547 extern struct filename *getname_flags(const char __user *, int, int *);
2548 extern struct filename *getname(const char __user *);
2549 extern struct filename *getname_kernel(const char *);
2550 extern void putname(struct filename *name);
2551
2552 extern int finish_open(struct file *file, struct dentry *dentry,
2553 int (*open)(struct inode *, struct file *));
2554 extern int finish_no_open(struct file *file, struct dentry *dentry);
2555
2556
2557
2558 extern int ioctl_preallocate(struct file *filp, void __user *argp);
2559
2560
2561 extern void __init vfs_caches_init_early(void);
2562 extern void __init vfs_caches_init(void);
2563
2564 extern struct kmem_cache *names_cachep;
2565
2566 #define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
2567 #define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
2568
2569 #ifdef CONFIG_BLOCK
2570 extern int register_blkdev(unsigned int, const char *);
2571 extern void unregister_blkdev(unsigned int, const char *);
2572 extern void bdev_unhash_inode(dev_t dev);
2573 extern struct block_device *bdget(dev_t);
2574 extern struct block_device *bdgrab(struct block_device *bdev);
2575 extern void bd_set_size(struct block_device *, loff_t size);
2576 extern void bd_forget(struct inode *inode);
2577 extern void bdput(struct block_device *);
2578 extern void invalidate_bdev(struct block_device *);
2579 extern void iterate_bdevs(void (*)(struct block_device *, void *), void *);
2580 extern int sync_blockdev(struct block_device *bdev);
2581 extern void kill_bdev(struct block_device *);
2582 extern struct super_block *freeze_bdev(struct block_device *);
2583 extern void emergency_thaw_all(void);
2584 extern void emergency_thaw_bdev(struct super_block *sb);
2585 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
2586 extern int fsync_bdev(struct block_device *);
2587
2588 extern struct super_block *blockdev_superblock;
2589
2590 static inline bool sb_is_blkdev_sb(struct super_block *sb)
2591 {
2592 return sb == blockdev_superblock;
2593 }
2594 #else
2595 static inline void bd_forget(struct inode *inode) {}
2596 static inline int sync_blockdev(struct block_device *bdev) { return 0; }
2597 static inline void kill_bdev(struct block_device *bdev) {}
2598 static inline void invalidate_bdev(struct block_device *bdev) {}
2599
2600 static inline struct super_block *freeze_bdev(struct block_device *sb)
2601 {
2602 return NULL;
2603 }
2604
2605 static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
2606 {
2607 return 0;
2608 }
2609
2610 static inline int emergency_thaw_bdev(struct super_block *sb)
2611 {
2612 return 0;
2613 }
2614
2615 static inline void iterate_bdevs(void (*f)(struct block_device *, void *), void *arg)
2616 {
2617 }
2618
2619 static inline bool sb_is_blkdev_sb(struct super_block *sb)
2620 {
2621 return false;
2622 }
2623 #endif
2624 extern int sync_filesystem(struct super_block *);
2625 extern const struct file_operations def_blk_fops;
2626 extern const struct file_operations def_chr_fops;
2627 #ifdef CONFIG_BLOCK
2628 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
2629 extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
2630 extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
2631 extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
2632 extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
2633 void *holder);
2634 extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
2635 void *holder);
2636 extern struct block_device *bd_start_claiming(struct block_device *bdev,
2637 void *holder);
2638 extern void bd_finish_claiming(struct block_device *bdev,
2639 struct block_device *whole, void *holder);
2640 extern void bd_abort_claiming(struct block_device *bdev,
2641 struct block_device *whole, void *holder);
2642 extern void blkdev_put(struct block_device *bdev, fmode_t mode);
2643 extern int __blkdev_reread_part(struct block_device *bdev);
2644 extern int blkdev_reread_part(struct block_device *bdev);
2645
2646 #ifdef CONFIG_SYSFS
2647 extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
2648 extern void bd_unlink_disk_holder(struct block_device *bdev,
2649 struct gendisk *disk);
2650 #else
2651 static inline int bd_link_disk_holder(struct block_device *bdev,
2652 struct gendisk *disk)
2653 {
2654 return 0;
2655 }
2656 static inline void bd_unlink_disk_holder(struct block_device *bdev,
2657 struct gendisk *disk)
2658 {
2659 }
2660 #endif
2661 #endif
2662
2663
2664 #define CHRDEV_MAJOR_MAX 512
2665
2666 #define CHRDEV_MAJOR_DYN_END 234
2667
2668 #define CHRDEV_MAJOR_DYN_EXT_START 511
2669 #define CHRDEV_MAJOR_DYN_EXT_END 384
2670
2671 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2672 extern int register_chrdev_region(dev_t, unsigned, const char *);
2673 extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2674 unsigned int count, const char *name,
2675 const struct file_operations *fops);
2676 extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2677 unsigned int count, const char *name);
2678 extern void unregister_chrdev_region(dev_t, unsigned);
2679 extern void chrdev_show(struct seq_file *,off_t);
2680
2681 static inline int register_chrdev(unsigned int major, const char *name,
2682 const struct file_operations *fops)
2683 {
2684 return __register_chrdev(major, 0, 256, name, fops);
2685 }
2686
2687 static inline void unregister_chrdev(unsigned int major, const char *name)
2688 {
2689 __unregister_chrdev(major, 0, 256, name);
2690 }
2691
2692
2693 #define BDEVNAME_SIZE 32
2694 #define BDEVT_SIZE 10
2695
2696 #ifdef CONFIG_BLOCK
2697 #define BLKDEV_MAJOR_MAX 512
2698 extern const char *__bdevname(dev_t, char *buffer);
2699 extern const char *bdevname(struct block_device *bdev, char *buffer);
2700 extern struct block_device *lookup_bdev(const char *);
2701 extern void blkdev_show(struct seq_file *,off_t);
2702
2703 #else
2704 #define BLKDEV_MAJOR_MAX 0
2705 #endif
2706
2707 extern void init_special_inode(struct inode *, umode_t, dev_t);
2708
2709
2710 extern void make_bad_inode(struct inode *);
2711 extern bool is_bad_inode(struct inode *);
2712
2713 #ifdef CONFIG_BLOCK
2714 extern void check_disk_size_change(struct gendisk *disk,
2715 struct block_device *bdev, bool verbose);
2716 extern int revalidate_disk(struct gendisk *);
2717 extern int check_disk_change(struct block_device *);
2718 extern int __invalidate_device(struct block_device *, bool);
2719 extern int invalidate_partition(struct gendisk *, int);
2720 #endif
2721 unsigned long invalidate_mapping_pages(struct address_space *mapping,
2722 pgoff_t start, pgoff_t end);
2723
2724 static inline void invalidate_remote_inode(struct inode *inode)
2725 {
2726 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2727 S_ISLNK(inode->i_mode))
2728 invalidate_mapping_pages(inode->i_mapping, 0, -1);
2729 }
2730 extern int invalidate_inode_pages2(struct address_space *mapping);
2731 extern int invalidate_inode_pages2_range(struct address_space *mapping,
2732 pgoff_t start, pgoff_t end);
2733 extern int write_inode_now(struct inode *, int);
2734 extern int filemap_fdatawrite(struct address_space *);
2735 extern int filemap_flush(struct address_space *);
2736 extern int filemap_fdatawait_keep_errors(struct address_space *mapping);
2737 extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
2738 loff_t lend);
2739 extern int filemap_fdatawait_range_keep_errors(struct address_space *mapping,
2740 loff_t start_byte, loff_t end_byte);
2741
2742 static inline int filemap_fdatawait(struct address_space *mapping)
2743 {
2744 return filemap_fdatawait_range(mapping, 0, LLONG_MAX);
2745 }
2746
2747 extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
2748 loff_t lend);
2749 extern int filemap_write_and_wait(struct address_space *mapping);
2750 extern int filemap_write_and_wait_range(struct address_space *mapping,
2751 loff_t lstart, loff_t lend);
2752 extern int __filemap_fdatawrite_range(struct address_space *mapping,
2753 loff_t start, loff_t end, int sync_mode);
2754 extern int filemap_fdatawrite_range(struct address_space *mapping,
2755 loff_t start, loff_t end);
2756 extern int filemap_check_errors(struct address_space *mapping);
2757 extern void __filemap_set_wb_err(struct address_space *mapping, int err);
2758
2759 extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2760 loff_t lend);
2761 extern int __must_check file_check_and_advance_wb_err(struct file *file);
2762 extern int __must_check file_write_and_wait_range(struct file *file,
2763 loff_t start, loff_t end);
2764
2765 static inline int file_write_and_wait(struct file *file)
2766 {
2767 return file_write_and_wait_range(file, 0, LLONG_MAX);
2768 }
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784 static inline void filemap_set_wb_err(struct address_space *mapping, int err)
2785 {
2786
2787 if (unlikely(err))
2788 __filemap_set_wb_err(mapping, err);
2789 }
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801 static inline int filemap_check_wb_err(struct address_space *mapping,
2802 errseq_t since)
2803 {
2804 return errseq_check(&mapping->wb_err, since);
2805 }
2806
2807
2808
2809
2810
2811
2812
2813
2814 static inline errseq_t filemap_sample_wb_err(struct address_space *mapping)
2815 {
2816 return errseq_sample(&mapping->wb_err);
2817 }
2818
2819 static inline int filemap_nr_thps(struct address_space *mapping)
2820 {
2821 #ifdef CONFIG_READ_ONLY_THP_FOR_FS
2822 return atomic_read(&mapping->nr_thps);
2823 #else
2824 return 0;
2825 #endif
2826 }
2827
2828 static inline void filemap_nr_thps_inc(struct address_space *mapping)
2829 {
2830 #ifdef CONFIG_READ_ONLY_THP_FOR_FS
2831 atomic_inc(&mapping->nr_thps);
2832 #else
2833 WARN_ON_ONCE(1);
2834 #endif
2835 }
2836
2837 static inline void filemap_nr_thps_dec(struct address_space *mapping)
2838 {
2839 #ifdef CONFIG_READ_ONLY_THP_FOR_FS
2840 atomic_dec(&mapping->nr_thps);
2841 #else
2842 WARN_ON_ONCE(1);
2843 #endif
2844 }
2845
2846 extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2847 int datasync);
2848 extern int vfs_fsync(struct file *file, int datasync);
2849
2850 extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
2851 unsigned int flags);
2852
2853
2854
2855
2856
2857
2858 static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
2859 {
2860 if (iocb->ki_flags & IOCB_DSYNC) {
2861 int ret = vfs_fsync_range(iocb->ki_filp,
2862 iocb->ki_pos - count, iocb->ki_pos - 1,
2863 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1);
2864 if (ret)
2865 return ret;
2866 }
2867
2868 return count;
2869 }
2870
2871 extern void emergency_sync(void);
2872 extern void emergency_remount(void);
2873 #ifdef CONFIG_BLOCK
2874 extern sector_t bmap(struct inode *, sector_t);
2875 #endif
2876 extern int notify_change(struct dentry *, struct iattr *, struct inode **);
2877 extern int inode_permission(struct inode *, int);
2878 extern int generic_permission(struct inode *, int);
2879 extern int __check_sticky(struct inode *dir, struct inode *inode);
2880
2881 static inline bool execute_ok(struct inode *inode)
2882 {
2883 return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
2884 }
2885
2886 static inline void file_start_write(struct file *file)
2887 {
2888 if (!S_ISREG(file_inode(file)->i_mode))
2889 return;
2890 __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
2891 }
2892
2893 static inline bool file_start_write_trylock(struct file *file)
2894 {
2895 if (!S_ISREG(file_inode(file)->i_mode))
2896 return true;
2897 return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false);
2898 }
2899
2900 static inline void file_end_write(struct file *file)
2901 {
2902 if (!S_ISREG(file_inode(file)->i_mode))
2903 return;
2904 __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
2905 }
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923 static inline int get_write_access(struct inode *inode)
2924 {
2925 return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
2926 }
2927 static inline int deny_write_access(struct file *file)
2928 {
2929 struct inode *inode = file_inode(file);
2930 return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
2931 }
2932 static inline void put_write_access(struct inode * inode)
2933 {
2934 atomic_dec(&inode->i_writecount);
2935 }
2936 static inline void allow_write_access(struct file *file)
2937 {
2938 if (file)
2939 atomic_inc(&file_inode(file)->i_writecount);
2940 }
2941 static inline bool inode_is_open_for_write(const struct inode *inode)
2942 {
2943 return atomic_read(&inode->i_writecount) > 0;
2944 }
2945
2946 #if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
2947 static inline void i_readcount_dec(struct inode *inode)
2948 {
2949 BUG_ON(!atomic_read(&inode->i_readcount));
2950 atomic_dec(&inode->i_readcount);
2951 }
2952 static inline void i_readcount_inc(struct inode *inode)
2953 {
2954 atomic_inc(&inode->i_readcount);
2955 }
2956 #else
2957 static inline void i_readcount_dec(struct inode *inode)
2958 {
2959 return;
2960 }
2961 static inline void i_readcount_inc(struct inode *inode)
2962 {
2963 return;
2964 }
2965 #endif
2966 extern int do_pipe_flags(int *, int);
2967
2968 #define __kernel_read_file_id(id) \
2969 id(UNKNOWN, unknown) \
2970 id(FIRMWARE, firmware) \
2971 id(FIRMWARE_PREALLOC_BUFFER, firmware) \
2972 id(MODULE, kernel-module) \
2973 id(KEXEC_IMAGE, kexec-image) \
2974 id(KEXEC_INITRAMFS, kexec-initramfs) \
2975 id(POLICY, security-policy) \
2976 id(X509_CERTIFICATE, x509-certificate) \
2977 id(MAX_ID, )
2978
2979 #define __fid_enumify(ENUM, dummy) READING_ ## ENUM,
2980 #define __fid_stringify(dummy, str) #str,
2981
2982 enum kernel_read_file_id {
2983 __kernel_read_file_id(__fid_enumify)
2984 };
2985
2986 static const char * const kernel_read_file_str[] = {
2987 __kernel_read_file_id(__fid_stringify)
2988 };
2989
2990 static inline const char *kernel_read_file_id_str(enum kernel_read_file_id id)
2991 {
2992 if ((unsigned)id >= READING_MAX_ID)
2993 return kernel_read_file_str[READING_UNKNOWN];
2994
2995 return kernel_read_file_str[id];
2996 }
2997
2998 extern int kernel_read_file(struct file *, void **, loff_t *, loff_t,
2999 enum kernel_read_file_id);
3000 extern int kernel_read_file_from_path(const char *, void **, loff_t *, loff_t,
3001 enum kernel_read_file_id);
3002 extern int kernel_read_file_from_fd(int, void **, loff_t *, loff_t,
3003 enum kernel_read_file_id);
3004 extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
3005 extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
3006 extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
3007 extern struct file * open_exec(const char *);
3008
3009
3010 extern bool is_subdir(struct dentry *, struct dentry *);
3011 extern bool path_is_under(const struct path *, const struct path *);
3012
3013 extern char *file_path(struct file *, char *, int);
3014
3015 #include <linux/err.h>
3016
3017
3018 extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
3019
3020 extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
3021
3022 extern int inode_init_always(struct super_block *, struct inode *);
3023 extern void inode_init_once(struct inode *);
3024 extern void address_space_init_once(struct address_space *mapping);
3025 extern struct inode * igrab(struct inode *);
3026 extern ino_t iunique(struct super_block *, ino_t);
3027 extern int inode_needs_sync(struct inode *inode);
3028 extern int generic_delete_inode(struct inode *inode);
3029 static inline int generic_drop_inode(struct inode *inode)
3030 {
3031 return !inode->i_nlink || inode_unhashed(inode);
3032 }
3033
3034 extern struct inode *ilookup5_nowait(struct super_block *sb,
3035 unsigned long hashval, int (*test)(struct inode *, void *),
3036 void *data);
3037 extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
3038 int (*test)(struct inode *, void *), void *data);
3039 extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
3040
3041 extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
3042 int (*test)(struct inode *, void *),
3043 int (*set)(struct inode *, void *),
3044 void *data);
3045 extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
3046 extern struct inode * iget_locked(struct super_block *, unsigned long);
3047 extern struct inode *find_inode_nowait(struct super_block *,
3048 unsigned long,
3049 int (*match)(struct inode *,
3050 unsigned long, void *),
3051 void *data);
3052 extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
3053 extern int insert_inode_locked(struct inode *);
3054 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3055 extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
3056 #else
3057 static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
3058 #endif
3059 extern void unlock_new_inode(struct inode *);
3060 extern void discard_new_inode(struct inode *);
3061 extern unsigned int get_next_ino(void);
3062 extern void evict_inodes(struct super_block *sb);
3063
3064 extern void __iget(struct inode * inode);
3065 extern void iget_failed(struct inode *);
3066 extern void clear_inode(struct inode *);
3067 extern void __destroy_inode(struct inode *);
3068 extern struct inode *new_inode_pseudo(struct super_block *sb);
3069 extern struct inode *new_inode(struct super_block *sb);
3070 extern void free_inode_nonrcu(struct inode *inode);
3071 extern int should_remove_suid(struct dentry *);
3072 extern int file_remove_privs(struct file *);
3073
3074 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
3075 static inline void insert_inode_hash(struct inode *inode)
3076 {
3077 __insert_inode_hash(inode, inode->i_ino);
3078 }
3079
3080 extern void __remove_inode_hash(struct inode *);
3081 static inline void remove_inode_hash(struct inode *inode)
3082 {
3083 if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
3084 __remove_inode_hash(inode);
3085 }
3086
3087 extern void inode_sb_list_add(struct inode *inode);
3088
3089 #ifdef CONFIG_BLOCK
3090 extern int bdev_read_only(struct block_device *);
3091 #endif
3092 extern int set_blocksize(struct block_device *, int);
3093 extern int sb_set_blocksize(struct super_block *, int);
3094 extern int sb_min_blocksize(struct super_block *, int);
3095
3096 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
3097 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
3098 extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
3099 extern int generic_remap_checks(struct file *file_in, loff_t pos_in,
3100 struct file *file_out, loff_t pos_out,
3101 loff_t *count, unsigned int remap_flags);
3102 extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
3103 extern int generic_copy_file_checks(struct file *file_in, loff_t pos_in,
3104 struct file *file_out, loff_t pos_out,
3105 size_t *count, unsigned int flags);
3106 extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
3107 extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
3108 extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
3109 extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
3110 extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
3111
3112 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
3113 rwf_t flags);
3114 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
3115 rwf_t flags);
3116
3117
3118 extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to);
3119 extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from);
3120 extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
3121 int datasync);
3122 extern void block_sync_page(struct page *page);
3123
3124
3125 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
3126 struct pipe_inode_info *, size_t, unsigned int);
3127 extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
3128 struct file *, loff_t *, size_t, unsigned int);
3129 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
3130 struct file *out, loff_t *, size_t len, unsigned int flags);
3131 extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
3132 loff_t *opos, size_t len, unsigned int flags);
3133
3134
3135 extern void
3136 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
3137 extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
3138 extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
3139 extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
3140 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
3141 extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
3142 int whence, loff_t maxsize, loff_t eof);
3143 extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
3144 int whence, loff_t size);
3145 extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
3146 extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
3147 extern int generic_file_open(struct inode * inode, struct file * filp);
3148 extern int nonseekable_open(struct inode * inode, struct file * filp);
3149 extern int stream_open(struct inode * inode, struct file * filp);
3150
3151 #ifdef CONFIG_BLOCK
3152 typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
3153 loff_t file_offset);
3154
3155 enum {
3156
3157 DIO_LOCKING = 0x01,
3158
3159
3160 DIO_SKIP_HOLES = 0x02,
3161 };
3162
3163 void dio_end_io(struct bio *bio);
3164 void dio_warn_stale_pagecache(struct file *filp);
3165
3166 ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
3167 struct block_device *bdev, struct iov_iter *iter,
3168 get_block_t get_block,
3169 dio_iodone_t end_io, dio_submit_t submit_io,
3170 int flags);
3171
3172 static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
3173 struct inode *inode,
3174 struct iov_iter *iter,
3175 get_block_t get_block)
3176 {
3177 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
3178 get_block, NULL, NULL, DIO_LOCKING | DIO_SKIP_HOLES);
3179 }
3180 #endif
3181
3182 void inode_dio_wait(struct inode *inode);
3183
3184
3185
3186
3187
3188
3189
3190
3191 static inline void inode_dio_begin(struct inode *inode)
3192 {
3193 atomic_inc(&inode->i_dio_count);
3194 }
3195
3196
3197
3198
3199
3200
3201
3202
3203 static inline void inode_dio_end(struct inode *inode)
3204 {
3205 if (atomic_dec_and_test(&inode->i_dio_count))
3206 wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
3207 }
3208
3209 extern void inode_set_flags(struct inode *inode, unsigned int flags,
3210 unsigned int mask);
3211
3212 extern const struct file_operations generic_ro_fops;
3213
3214 #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
3215
3216 extern int readlink_copy(char __user *, int, const char *);
3217 extern int page_readlink(struct dentry *, char __user *, int);
3218 extern const char *page_get_link(struct dentry *, struct inode *,
3219 struct delayed_call *);
3220 extern void page_put_link(void *);
3221 extern int __page_symlink(struct inode *inode, const char *symname, int len,
3222 int nofs);
3223 extern int page_symlink(struct inode *inode, const char *symname, int len);
3224 extern const struct inode_operations page_symlink_inode_operations;
3225 extern void kfree_link(void *);
3226 extern void generic_fillattr(struct inode *, struct kstat *);
3227 extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
3228 extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
3229 void __inode_add_bytes(struct inode *inode, loff_t bytes);
3230 void inode_add_bytes(struct inode *inode, loff_t bytes);
3231 void __inode_sub_bytes(struct inode *inode, loff_t bytes);
3232 void inode_sub_bytes(struct inode *inode, loff_t bytes);
3233 static inline loff_t __inode_get_bytes(struct inode *inode)
3234 {
3235 return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
3236 }
3237 loff_t inode_get_bytes(struct inode *inode);
3238 void inode_set_bytes(struct inode *inode, loff_t bytes);
3239 const char *simple_get_link(struct dentry *, struct inode *,
3240 struct delayed_call *);
3241 extern const struct inode_operations simple_symlink_inode_operations;
3242
3243 extern int iterate_dir(struct file *, struct dir_context *);
3244
3245 extern int vfs_statx(int, const char __user *, int, struct kstat *, u32);
3246 extern int vfs_statx_fd(unsigned int, struct kstat *, u32, unsigned int);
3247
3248 static inline int vfs_stat(const char __user *filename, struct kstat *stat)
3249 {
3250 return vfs_statx(AT_FDCWD, filename, AT_NO_AUTOMOUNT,
3251 stat, STATX_BASIC_STATS);
3252 }
3253 static inline int vfs_lstat(const char __user *name, struct kstat *stat)
3254 {
3255 return vfs_statx(AT_FDCWD, name, AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT,
3256 stat, STATX_BASIC_STATS);
3257 }
3258 static inline int vfs_fstatat(int dfd, const char __user *filename,
3259 struct kstat *stat, int flags)
3260 {
3261 return vfs_statx(dfd, filename, flags | AT_NO_AUTOMOUNT,
3262 stat, STATX_BASIC_STATS);
3263 }
3264 static inline int vfs_fstat(int fd, struct kstat *stat)
3265 {
3266 return vfs_statx_fd(fd, stat, STATX_BASIC_STATS, 0);
3267 }
3268
3269
3270 extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
3271 extern int vfs_readlink(struct dentry *, char __user *, int);
3272
3273 extern int __generic_block_fiemap(struct inode *inode,
3274 struct fiemap_extent_info *fieinfo,
3275 loff_t start, loff_t len,
3276 get_block_t *get_block);
3277 extern int generic_block_fiemap(struct inode *inode,
3278 struct fiemap_extent_info *fieinfo, u64 start,
3279 u64 len, get_block_t *get_block);
3280
3281 extern struct file_system_type *get_filesystem(struct file_system_type *fs);
3282 extern void put_filesystem(struct file_system_type *fs);
3283 extern struct file_system_type *get_fs_type(const char *name);
3284 extern struct super_block *get_super(struct block_device *);
3285 extern struct super_block *get_super_thawed(struct block_device *);
3286 extern struct super_block *get_super_exclusive_thawed(struct block_device *bdev);
3287 extern struct super_block *get_active_super(struct block_device *bdev);
3288 extern void drop_super(struct super_block *sb);
3289 extern void drop_super_exclusive(struct super_block *sb);
3290 extern void iterate_supers(void (*)(struct super_block *, void *), void *);
3291 extern void iterate_supers_type(struct file_system_type *,
3292 void (*)(struct super_block *, void *), void *);
3293
3294 extern int dcache_dir_open(struct inode *, struct file *);
3295 extern int dcache_dir_close(struct inode *, struct file *);
3296 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
3297 extern int dcache_readdir(struct file *, struct dir_context *);
3298 extern int simple_setattr(struct dentry *, struct iattr *);
3299 extern int simple_getattr(const struct path *, struct kstat *, u32, unsigned int);
3300 extern int simple_statfs(struct dentry *, struct kstatfs *);
3301 extern int simple_open(struct inode *inode, struct file *file);
3302 extern int simple_link(struct dentry *, struct inode *, struct dentry *);
3303 extern int simple_unlink(struct inode *, struct dentry *);
3304 extern int simple_rmdir(struct inode *, struct dentry *);
3305 extern int simple_rename(struct inode *, struct dentry *,
3306 struct inode *, struct dentry *, unsigned int);
3307 extern int noop_fsync(struct file *, loff_t, loff_t, int);
3308 extern int noop_set_page_dirty(struct page *page);
3309 extern void noop_invalidatepage(struct page *page, unsigned int offset,
3310 unsigned int length);
3311 extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
3312 extern int simple_empty(struct dentry *);
3313 extern int simple_readpage(struct file *file, struct page *page);
3314 extern int simple_write_begin(struct file *file, struct address_space *mapping,
3315 loff_t pos, unsigned len, unsigned flags,
3316 struct page **pagep, void **fsdata);
3317 extern int simple_write_end(struct file *file, struct address_space *mapping,
3318 loff_t pos, unsigned len, unsigned copied,
3319 struct page *page, void *fsdata);
3320 extern int always_delete_dentry(const struct dentry *);
3321 extern struct inode *alloc_anon_inode(struct super_block *);
3322 extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
3323 extern const struct dentry_operations simple_dentry_operations;
3324
3325 extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
3326 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
3327 extern const struct file_operations simple_dir_operations;
3328 extern const struct inode_operations simple_dir_inode_operations;
3329 extern void make_empty_dir_inode(struct inode *inode);
3330 extern bool is_empty_dir_inode(struct inode *inode);
3331 struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
3332 struct dentry *d_alloc_name(struct dentry *, const char *);
3333 extern int simple_fill_super(struct super_block *, unsigned long,
3334 const struct tree_descr *);
3335 extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
3336 extern void simple_release_fs(struct vfsmount **mount, int *count);
3337
3338 extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
3339 loff_t *ppos, const void *from, size_t available);
3340 extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3341 const void __user *from, size_t count);
3342
3343 extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
3344 extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
3345
3346 extern int generic_check_addressable(unsigned, u64);
3347
3348 #ifdef CONFIG_MIGRATION
3349 extern int buffer_migrate_page(struct address_space *,
3350 struct page *, struct page *,
3351 enum migrate_mode);
3352 extern int buffer_migrate_page_norefs(struct address_space *,
3353 struct page *, struct page *,
3354 enum migrate_mode);
3355 #else
3356 #define buffer_migrate_page NULL
3357 #define buffer_migrate_page_norefs NULL
3358 #endif
3359
3360 extern int setattr_prepare(struct dentry *, struct iattr *);
3361 extern int inode_newsize_ok(const struct inode *, loff_t offset);
3362 extern void setattr_copy(struct inode *inode, const struct iattr *attr);
3363
3364 extern int file_update_time(struct file *file);
3365
3366 static inline bool io_is_direct(struct file *filp)
3367 {
3368 return (filp->f_flags & O_DIRECT) || IS_DAX(filp->f_mapping->host);
3369 }
3370
3371 static inline bool vma_is_dax(struct vm_area_struct *vma)
3372 {
3373 return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
3374 }
3375
3376 static inline bool vma_is_fsdax(struct vm_area_struct *vma)
3377 {
3378 struct inode *inode;
3379
3380 if (!vma->vm_file)
3381 return false;
3382 if (!vma_is_dax(vma))
3383 return false;
3384 inode = file_inode(vma->vm_file);
3385 if (S_ISCHR(inode->i_mode))
3386 return false;
3387 return true;
3388 }
3389
3390 static inline int iocb_flags(struct file *file)
3391 {
3392 int res = 0;
3393 if (file->f_flags & O_APPEND)
3394 res |= IOCB_APPEND;
3395 if (io_is_direct(file))
3396 res |= IOCB_DIRECT;
3397 if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))
3398 res |= IOCB_DSYNC;
3399 if (file->f_flags & __O_SYNC)
3400 res |= IOCB_SYNC;
3401 return res;
3402 }
3403
3404 static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
3405 {
3406 if (unlikely(flags & ~RWF_SUPPORTED))
3407 return -EOPNOTSUPP;
3408
3409 if (flags & RWF_NOWAIT) {
3410 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT))
3411 return -EOPNOTSUPP;
3412 ki->ki_flags |= IOCB_NOWAIT;
3413 }
3414 if (flags & RWF_HIPRI)
3415 ki->ki_flags |= IOCB_HIPRI;
3416 if (flags & RWF_DSYNC)
3417 ki->ki_flags |= IOCB_DSYNC;
3418 if (flags & RWF_SYNC)
3419 ki->ki_flags |= (IOCB_DSYNC | IOCB_SYNC);
3420 if (flags & RWF_APPEND)
3421 ki->ki_flags |= IOCB_APPEND;
3422 return 0;
3423 }
3424
3425 static inline ino_t parent_ino(struct dentry *dentry)
3426 {
3427 ino_t res;
3428
3429
3430
3431
3432
3433 spin_lock(&dentry->d_lock);
3434 res = dentry->d_parent->d_inode->i_ino;
3435 spin_unlock(&dentry->d_lock);
3436 return res;
3437 }
3438
3439
3440
3441
3442
3443
3444
3445 struct simple_transaction_argresp {
3446 ssize_t size;
3447 char data[0];
3448 };
3449
3450 #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
3451
3452 char *simple_transaction_get(struct file *file, const char __user *buf,
3453 size_t size);
3454 ssize_t simple_transaction_read(struct file *file, char __user *buf,
3455 size_t size, loff_t *pos);
3456 int simple_transaction_release(struct inode *inode, struct file *file);
3457
3458 void simple_transaction_set(struct file *file, size_t n);
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476 #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
3477 static int __fops ## _open(struct inode *inode, struct file *file) \
3478 { \
3479 __simple_attr_check_format(__fmt, 0ull); \
3480 return simple_attr_open(inode, file, __get, __set, __fmt); \
3481 } \
3482 static const struct file_operations __fops = { \
3483 .owner = THIS_MODULE, \
3484 .open = __fops ## _open, \
3485 .release = simple_attr_release, \
3486 .read = simple_attr_read, \
3487 .write = simple_attr_write, \
3488 .llseek = generic_file_llseek, \
3489 }
3490
3491 static inline __printf(1, 2)
3492 void __simple_attr_check_format(const char *fmt, ...)
3493 {
3494
3495 }
3496
3497 int simple_attr_open(struct inode *inode, struct file *file,
3498 int (*get)(void *, u64 *), int (*set)(void *, u64),
3499 const char *fmt);
3500 int simple_attr_release(struct inode *inode, struct file *file);
3501 ssize_t simple_attr_read(struct file *file, char __user *buf,
3502 size_t len, loff_t *ppos);
3503 ssize_t simple_attr_write(struct file *file, const char __user *buf,
3504 size_t len, loff_t *ppos);
3505
3506 struct ctl_table;
3507 int proc_nr_files(struct ctl_table *table, int write,
3508 void __user *buffer, size_t *lenp, loff_t *ppos);
3509 int proc_nr_dentry(struct ctl_table *table, int write,
3510 void __user *buffer, size_t *lenp, loff_t *ppos);
3511 int proc_nr_inodes(struct ctl_table *table, int write,
3512 void __user *buffer, size_t *lenp, loff_t *ppos);
3513 int __init get_filesystem_list(char *buf);
3514
3515 #define __FMODE_EXEC ((__force int) FMODE_EXEC)
3516 #define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
3517
3518 #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
3519 #define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
3520 (flag & __FMODE_NONOTIFY)))
3521
3522 static inline bool is_sxid(umode_t mode)
3523 {
3524 return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
3525 }
3526
3527 static inline int check_sticky(struct inode *dir, struct inode *inode)
3528 {
3529 if (!(dir->i_mode & S_ISVTX))
3530 return 0;
3531
3532 return __check_sticky(dir, inode);
3533 }
3534
3535 static inline void inode_has_no_xattr(struct inode *inode)
3536 {
3537 if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC))
3538 inode->i_flags |= S_NOSEC;
3539 }
3540
3541 static inline bool is_root_inode(struct inode *inode)
3542 {
3543 return inode == inode->i_sb->s_root->d_inode;
3544 }
3545
3546 static inline bool dir_emit(struct dir_context *ctx,
3547 const char *name, int namelen,
3548 u64 ino, unsigned type)
3549 {
3550 return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
3551 }
3552 static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
3553 {
3554 return ctx->actor(ctx, ".", 1, ctx->pos,
3555 file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
3556 }
3557 static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
3558 {
3559 return ctx->actor(ctx, "..", 2, ctx->pos,
3560 parent_ino(file->f_path.dentry), DT_DIR) == 0;
3561 }
3562 static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
3563 {
3564 if (ctx->pos == 0) {
3565 if (!dir_emit_dot(file, ctx))
3566 return false;
3567 ctx->pos = 1;
3568 }
3569 if (ctx->pos == 1) {
3570 if (!dir_emit_dotdot(file, ctx))
3571 return false;
3572 ctx->pos = 2;
3573 }
3574 return true;
3575 }
3576 static inline bool dir_relax(struct inode *inode)
3577 {
3578 inode_unlock(inode);
3579 inode_lock(inode);
3580 return !IS_DEADDIR(inode);
3581 }
3582
3583 static inline bool dir_relax_shared(struct inode *inode)
3584 {
3585 inode_unlock_shared(inode);
3586 inode_lock_shared(inode);
3587 return !IS_DEADDIR(inode);
3588 }
3589
3590 extern bool path_noexec(const struct path *path);
3591 extern void inode_nohighmem(struct inode *inode);
3592
3593
3594 extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
3595 int advice);
3596 extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
3597 int advice);
3598
3599 #if defined(CONFIG_IO_URING)
3600 extern struct sock *io_uring_get_socket(struct file *file);
3601 #else
3602 static inline struct sock *io_uring_get_socket(struct file *file)
3603 {
3604 return NULL;
3605 }
3606 #endif
3607
3608 int vfs_ioc_setflags_prepare(struct inode *inode, unsigned int oldflags,
3609 unsigned int flags);
3610
3611 int vfs_ioc_fssetxattr_check(struct inode *inode, const struct fsxattr *old_fa,
3612 struct fsxattr *fa);
3613
3614 static inline void simple_fill_fsxattr(struct fsxattr *fa, __u32 xflags)
3615 {
3616 memset(fa, 0, sizeof(*fa));
3617 fa->fsx_xflags = xflags;
3618 }
3619
3620
3621
3622
3623
3624
3625 static inline int inode_drain_writes(struct inode *inode)
3626 {
3627 inode_dio_wait(inode);
3628 return filemap_write_and_wait(inode->i_mapping);
3629 }
3630
3631 #endif