blob: cdd73209eecb4483323434bff314fc9b8569296f [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001/* SPDX-License-Identifier: GPL-2.0-or-later */
David Howells07f3f052006-09-30 20:52:18 +02002/* fs/ internal definitions
3 *
4 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
David Howells07f3f052006-09-30 20:52:18 +02006 */
7
Andrew Morton5e6d12b2006-08-31 12:55:23 +02008struct super_block;
Al Viro9d412a42011-03-17 22:08:28 -04009struct file_system_type;
Christoph Hellwigae259a92016-06-21 09:23:11 +100010struct iomap;
Christoph Hellwigbefb5032016-09-19 11:24:49 +100011struct iomap_ops;
David Howellsa6f76f22008-11-14 10:39:24 +110012struct linux_binprm;
Al Viro3e93cd62009-03-29 19:00:13 -040013struct path;
Al Viroc7105362011-11-24 18:22:03 -050014struct mount;
Vladimir Davydov503c3582015-02-12 14:58:47 -080015struct shrink_control;
David Howells9bc61ab2018-11-04 03:19:03 -050016struct fs_context;
Al Virob964bf52021-01-25 22:24:28 -050017struct pipe_inode_info;
Al Viro06bbaa62022-09-26 11:59:14 -040018struct iov_iter;
Christian Brauner3707d842023-01-13 12:49:33 +010019struct mnt_idmap;
Christian Brauner460695a2024-06-27 16:11:41 +020020struct ns_common;
Andrew Morton5e6d12b2006-08-31 12:55:23 +020021
David Howells07f3f052006-09-30 20:52:18 +020022/*
Christoph Hellwig0dca4462021-09-07 16:13:03 +020023 * block/bdev.c
David Howells07f3f052006-09-30 20:52:18 +020024 */
David Howells93614012006-09-30 20:45:40 +020025#ifdef CONFIG_BLOCK
David Howells07f3f052006-09-30 20:52:18 +020026extern void __init bdev_cache_init(void);
Andrew Morton5e6d12b2006-08-31 12:55:23 +020027#else
28static inline void bdev_cache_init(void)
29{
30}
Christoph Hellwig3f1266f2020-06-20 09:16:41 +020031#endif /* CONFIG_BLOCK */
David Howells7b0de42d2006-08-29 19:06:07 +010032
David Howells07f3f052006-09-30 20:52:18 +020033/*
Akinobu Mita4db96b72014-10-09 15:26:55 -070034 * buffer.c
35 */
Matthew Wilcox (Oracle)d1bd0b42021-11-03 14:05:47 -040036int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,
Christoph Hellwig6d49cc82021-08-10 18:33:05 -070037 get_block_t *get_block, const struct iomap *iomap);
Akinobu Mita4db96b72014-10-09 15:26:55 -070038
39/*
David Howells07f3f052006-09-30 20:52:18 +020040 * char_dev.c
41 */
42extern void __init chrdev_init(void);
43
44/*
David Howells9bc61ab2018-11-04 03:19:03 -050045 * fs_context.c
46 */
David Howellsecdab1502018-11-01 23:36:09 +000047extern const struct fs_context_operations legacy_fs_context_ops;
David Howells9bc61ab2018-11-04 03:19:03 -050048extern int parse_monolithic_mount_data(struct fs_context *, void *);
David Howellsecdab1502018-11-01 23:36:09 +000049extern void vfs_clean_context(struct fs_context *fc);
50extern int finish_clean_context(struct fs_context *fc);
David Howells9bc61ab2018-11-04 03:19:03 -050051
52/*
David Howells0bdaea92012-06-25 12:55:46 +010053 * namei.c
54 */
David Howells31d921c2018-11-01 23:07:24 +000055extern int filename_lookup(int dfd, struct filename *name, unsigned flags,
56 struct path *path, struct path *root);
Dmitry Kadashev45f30da2021-07-08 13:34:44 +070057int do_rmdir(int dfd, struct filename *name);
58int do_unlinkat(int dfd, struct filename *name);
Christian Brauner4609e1f2023-01-13 12:49:22 +010059int may_linkat(struct mnt_idmap *idmap, const struct path *link);
Jens Axboee8866632020-09-26 17:20:17 -060060int do_renameat2(int olddfd, struct filename *oldname, int newdfd,
61 struct filename *newname, unsigned int flags);
Dmitry Kadashev45f30da2021-07-08 13:34:44 +070062int do_mkdirat(int dfd, struct filename *name, umode_t mode);
Dmitry Kadashev7a8721f2021-07-08 13:34:46 +070063int do_symlinkat(struct filename *from, int newdfd, struct filename *to);
Dmitry Kadashevcf30da92021-07-08 13:34:47 +070064int do_linkat(int olddfd, struct filename *old, int newdfd,
65 struct filename *new, int flags);
Miklos Szeredi9a879072024-05-02 20:35:57 +020066int vfs_tmpfile(struct mnt_idmap *idmap,
67 const struct path *parentpath,
68 struct file *file, umode_t mode);
David Howells0bdaea92012-06-25 12:55:46 +010069
70/*
David Howells07f3f052006-09-30 20:52:18 +020071 * namespace.c
72 */
Al Viroca71cf72016-11-20 19:45:28 -050073extern struct vfsmount *lookup_mnt(const struct path *);
Al Viro1e2d84642021-06-18 20:27:57 -040074extern int finish_automount(struct vfsmount *, const struct path *);
Al Viro6d59e7f2008-03-22 15:48:17 -040075
Miklos Szeredi4ed5e82f2011-11-21 12:11:31 +010076extern int sb_prepare_remount_readonly(struct super_block *);
Al Virof03c6592011-01-14 22:30:21 -050077
Al Viro6d59e7f2008-03-22 15:48:17 -040078extern void __init mnt_init(void);
Al Viro3e93cd62009-03-29 19:00:13 -040079
Amir Goldstein3e15dcf2023-09-08 16:28:59 +030080int mnt_get_write_access_file(struct file *file);
81void mnt_put_write_access_file(struct file *file);
Al Viro47cd813f2010-02-05 02:01:14 -050082
Al Viroa07b2002018-11-05 17:40:30 +000083extern void dissolve_on_fput(struct vfsmount *);
Al Viroa5f85d72022-03-01 00:05:29 -050084extern bool may_mount(void);
Christoph Hellwigc60166f2020-07-21 11:12:08 +020085
86int path_mount(const char *dev_name, struct path *path,
87 const char *type_page, unsigned long flags, void *data_page);
Christoph Hellwig09267de2020-07-23 08:23:08 +020088int path_umount(struct path *path, int flags);
Christoph Hellwigc60166f2020-07-21 11:12:08 +020089
Miklos Szeredi56c94c62023-10-25 16:02:01 +020090int show_path(struct seq_file *m, struct dentry *root);
91
Al Viro3e93cd62009-03-29 19:00:13 -040092/*
93 * fs_struct.c
94 */
Al Virodcf787f2013-03-01 23:51:07 -050095extern void chroot_fs_refs(const struct path *, const struct path *);
npiggin@suse.de864d7c42009-04-26 20:25:56 +100096
97/*
98 * file_table.c
99 */
Amir Goldstein62d53c42023-06-15 14:22:28 +0300100struct file *alloc_empty_file(int flags, const struct cred *cred);
101struct file *alloc_empty_file_noaccount(int flags, const struct cred *cred);
102struct file *alloc_empty_backing_file(int flags, const struct cred *cred);
Al Viro62c69432009-05-07 03:12:29 -0400103
Amir Goldstein83bc1d22023-10-09 18:37:10 +0300104static inline void file_put_write_access(struct file *file)
105{
106 put_write_access(file->f_inode);
107 mnt_put_write_access(file->f_path.mnt);
108 if (unlikely(file->f_mode & FMODE_BACKING))
Amir Goldsteindef3ae82023-10-09 18:37:12 +0300109 mnt_put_write_access(backing_file_user_path(file)->mnt);
Amir Goldstein83bc1d22023-10-09 18:37:10 +0300110}
111
Amir Goldsteind6da19c2022-08-16 17:53:17 +0300112static inline void put_file_access(struct file *file)
113{
114 if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
115 i_readcount_dec(file->f_inode);
116 } else if (file->f_mode & FMODE_WRITER) {
Amir Goldstein83bc1d22023-10-09 18:37:10 +0300117 file_put_write_access(file);
Amir Goldsteind6da19c2022-08-16 17:53:17 +0300118 }
119}
120
Al Viro62c69432009-05-07 03:12:29 -0400121/*
122 * super.c
123 */
David Howells8d0347f2018-11-04 09:28:36 -0500124extern int reconfigure_super(struct fs_context *);
Christian Braunerd8ce82e2023-08-18 16:00:49 +0200125extern bool super_trylock_shared(struct super_block *sb);
Christoph Hellwig4e7b5672020-11-23 13:38:40 +0100126struct super_block *user_get_super(dev_t, bool excl);
Christoph Hellwig60b49882020-11-16 15:21:18 +0100127void put_super(struct super_block *sb);
Al Viro20284ab2019-05-12 17:31:45 -0400128extern bool mount_capable(struct fs_context *);
Christoph Hellwig439bc392023-01-25 07:58:38 +0100129int sb_init_dio_done_wq(struct super_block *sb);
Al Viro482928d2009-12-19 10:10:39 -0500130
131/*
Jan Karad7439fb2023-06-20 13:28:32 +0200132 * Prepare superblock for changing its read-only state (i.e., either remount
133 * read-write superblock read-only or vice versa). After this function returns
134 * mnt_is_readonly() will return true for any mount of the superblock if its
135 * caller is able to observe any changes done by the remount. This holds until
136 * sb_end_ro_state_change() is called.
137 */
138static inline void sb_start_ro_state_change(struct super_block *sb)
139{
140 WRITE_ONCE(sb->s_readonly_remount, 1);
141 /*
142 * For RO->RW transition, the barrier pairs with the barrier in
143 * mnt_is_readonly() making sure if mnt_is_readonly() sees SB_RDONLY
144 * cleared, it will see s_readonly_remount set.
145 * For RW->RO transition, the barrier pairs with the barrier in
Amir Goldstein3e15dcf2023-09-08 16:28:59 +0300146 * mnt_get_write_access() before the mnt_is_readonly() check.
147 * The barrier makes sure if mnt_get_write_access() sees MNT_WRITE_HOLD
148 * already cleared, it will see s_readonly_remount set.
Jan Karad7439fb2023-06-20 13:28:32 +0200149 */
150 smp_wmb();
151}
152
153/*
154 * Ends section changing read-only state of the superblock. After this function
155 * returns if mnt_is_readonly() returns false, the caller will be able to
156 * observe all the changes remount did to the superblock.
157 */
158static inline void sb_end_ro_state_change(struct super_block *sb)
159{
160 /*
161 * This barrier provides release semantics that pairs with
162 * the smp_rmb() acquire semantics in mnt_is_readonly().
163 * This barrier pair ensure that when mnt_is_readonly() sees
164 * 0 for sb->s_readonly_remount, it will also see all the
165 * preceding flag changes that were made during the RO state
166 * change.
167 */
168 smp_wmb();
169 WRITE_ONCE(sb->s_readonly_remount, 0);
170}
171
172/*
Al Viro482928d2009-12-19 10:10:39 -0500173 * open.c
174 */
Al Viro47c805d2011-02-23 17:44:09 -0500175struct open_flags {
176 int open_flag;
Al Viroa218d0f2011-11-21 14:59:34 -0500177 umode_t mode;
Al Viro47c805d2011-02-23 17:44:09 -0500178 int acc_mode;
179 int intent;
Al Virof9652e12013-06-11 08:23:01 +0400180 int lookup_flags;
Al Viro47c805d2011-02-23 17:44:09 -0500181};
Jeff Layton669abf42012-10-10 16:43:10 -0400182extern struct file *do_filp_open(int dfd, struct filename *pathname,
Al Virof9652e12013-06-11 08:23:01 +0400183 const struct open_flags *op);
Al Viroffb37ca2021-04-01 19:00:57 -0400184extern struct file *do_file_open_root(const struct path *,
Al Virof9652e12013-06-11 08:23:01 +0400185 const char *, const struct open_flags *);
Jens Axboe35cb6d52019-12-13 11:10:11 -0700186extern struct open_how build_open_how(int flags, umode_t mode);
187extern int build_open_flags(const struct open_how *how, struct open_flags *op);
Christian Brauner24fa3ae2023-11-30 13:49:08 +0100188struct file *file_close_fd_locked(struct files_struct *files, unsigned fd);
Al Viroa8dade32010-10-24 11:13:10 -0400189
Tony Solomonik5f0d5942024-02-02 14:17:23 +0200190long do_ftruncate(struct file *file, loff_t length, int small);
Dominik Brodowski411d9472018-03-11 11:34:54 +0100191long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
Christoph Hellwig10977422020-07-22 11:41:02 +0200192int chmod_common(const struct path *path, umode_t mode);
Dominik Brodowski55731b32018-03-11 11:34:55 +0100193int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
194 int flag);
Christoph Hellwigb8734982020-07-22 11:13:26 +0200195int chown_common(const struct path *path, uid_t user, gid_t group);
Al Viroae2bb292018-07-10 13:22:28 -0400196extern int vfs_open(const struct path *, struct file *);
Aneesh Kumar K.Vbecfd1f2011-01-29 18:43:26 +0530197
Al Viroa8dade32010-10-24 11:13:10 -0400198/*
199 * inode.c
200 */
Vladimir Davydov503c3582015-02-12 14:58:47 -0800201extern long prune_icache_sb(struct super_block *sb, struct shrink_control *sc);
Christian Brauner9452e932023-01-13 12:49:27 +0100202int dentry_needs_remove_privs(struct mnt_idmap *, struct dentry *dentry);
203bool in_group_or_capable(struct mnt_idmap *idmap,
Christian Brauner11c2a872022-10-17 17:06:34 +0200204 const struct inode *inode, vfsgid_t vfsgid);
Dave Chinner55fa6092011-03-22 22:23:40 +1100205
Dave Chinnera66979a2011-03-22 22:23:41 +1100206/*
207 * fs-writeback.c
208 */
Glauber Costa3942c072013-08-28 10:17:53 +1000209extern long get_nr_dirty_inodes(void);
Christoph Hellwige127b9b2023-08-11 12:08:28 +0200210void invalidate_inodes(struct super_block *sb);
Al Viroa4464db2011-07-07 15:03:58 -0400211
212/*
213 * dcache.c
214 */
Miklos Szeredieed81002013-09-05 14:39:11 +0200215extern int d_set_mounted(struct dentry *dentry);
Vladimir Davydov503c3582015-02-12 14:58:47 -0800216extern long prune_dcache_sb(struct super_block *sb, struct shrink_control *sc);
Al Viroba65dc52016-06-10 11:32:47 -0400217extern struct dentry *d_alloc_cursor(struct dentry *);
Al Viroab1152d2019-03-15 22:58:11 -0400218extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
Al Viro7e5f7bb2019-05-20 13:44:57 +0100219extern char *simple_dname(struct dentry *, char *, int);
Al Viro9bdebc22019-06-29 18:31:24 -0400220extern void dput_to_list(struct dentry *, struct list_head *);
221extern void shrink_dentry_list(struct list_head *);
Al Viro0d486512023-11-10 15:22:40 -0500222extern void shrink_dcache_for_umount(struct super_block *);
223extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
224extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
225 const struct qstr *name, unsigned *seq);
Al Viro8a54b382023-11-11 16:01:27 -0500226extern void d_genocide(struct dentry *);
Al Viro06ae43f32013-03-20 13:19:30 -0400227
228/*
Al Viro599a0ac2013-03-12 09:58:10 -0400229 * pipe.c
230 */
231extern const struct file_operations pipefifo_fops;
Al Viro8fa1f1c2014-05-21 18:22:52 -0400232
233/*
234 * fs_pin.c
235 */
Al Virofdab6842015-01-11 10:57:27 -0500236extern void group_pin_kill(struct hlist_head *p);
Al Viro8fa1f1c2014-05-21 18:22:52 -0400237extern void mnt_pin_kill(struct mount *m);
Al Viroe149ed22014-11-01 10:57:28 -0400238
239/*
240 * fs/nsfs.c
241 */
Rasmus Villemoesbe218aa2016-09-15 00:15:34 +0200242extern const struct dentry_operations ns_dentry_operations;
Linus Torvalds98f3a9a2024-07-15 12:34:01 -0700243int open_namespace(struct ns_common *ns);
Al Viro66cf1912016-01-07 09:53:30 -0500244
Jens Axboe3934e362019-12-14 13:26:33 -0700245/*
246 * fs/stat.c:
247 */
Stefan Roesch1b6fe6e2022-02-25 10:53:26 -0800248
249int getname_statx_lookup_flags(int flags);
250int do_statx(int dfd, struct filename *filename, unsigned int flags,
Bijan Mottahedeh00187842020-05-22 21:31:17 -0700251 unsigned int mask, struct statx __user *buffer);
Mateusz Guzik0ef625b2024-06-25 17:18:06 +0200252int do_statx_fd(int fd, unsigned int flags, unsigned int mask,
253 struct statx __user *buffer);
Al Virob964bf52021-01-25 22:24:28 -0500254
255/*
256 * fs/splice.c:
257 */
Amir Goldstein0f292082023-12-12 11:44:36 +0200258ssize_t splice_file_to_pipe(struct file *in,
259 struct pipe_inode_info *opipe,
260 loff_t *offset,
261 size_t len, unsigned int flags);
Stefan Roesch1a917942022-04-24 18:10:46 -0600262
263/*
264 * fs/xattr.c:
265 */
266struct xattr_name {
267 char name[XATTR_NAME_MAX + 1];
268};
269
270struct xattr_ctx {
271 /* Value of attribute */
272 union {
273 const void __user *cvalue;
274 void __user *value;
275 };
276 void *kvalue;
277 size_t size;
278 /* Attribute name */
279 struct xattr_name *kname;
280 unsigned int flags;
281};
282
Stefan Roeschc975cad2022-04-24 18:13:50 -0600283
Christian Brauner5a6f52d2022-10-28 09:56:20 +0200284ssize_t do_getxattr(struct mnt_idmap *idmap,
Stefan Roeschc975cad2022-04-24 18:13:50 -0600285 struct dentry *d,
286 struct xattr_ctx *ctx);
287
Stefan Roesch1a917942022-04-24 18:10:46 -0600288int setxattr_copy(const char __user *name, struct xattr_ctx *ctx);
Christian Brauner5a6f52d2022-10-28 09:56:20 +0200289int do_setxattr(struct mnt_idmap *idmap, struct dentry *dentry,
Stefan Roesch1a917942022-04-24 18:10:46 -0600290 struct xattr_ctx *ctx);
Christian Brauner4609e1f2023-01-13 12:49:22 +0100291int may_write_xattr(struct mnt_idmap *idmap, struct inode *inode);
Al Viro06bbaa62022-09-26 11:59:14 -0400292
Christian Brauner318e6682022-09-22 17:17:22 +0200293#ifdef CONFIG_FS_POSIX_ACL
Christian Brauner5a6f52d2022-10-28 09:56:20 +0200294int do_set_acl(struct mnt_idmap *idmap, struct dentry *dentry,
Christian Brauner318e6682022-09-22 17:17:22 +0200295 const char *acl_name, const void *kvalue, size_t size);
Christian Brauner5a6f52d2022-10-28 09:56:20 +0200296ssize_t do_get_acl(struct mnt_idmap *idmap, struct dentry *dentry,
Christian Brauner318e6682022-09-22 17:17:22 +0200297 const char *acl_name, void *kvalue, size_t size);
298#else
Christian Brauner5a6f52d2022-10-28 09:56:20 +0200299static inline int do_set_acl(struct mnt_idmap *idmap,
Christian Brauner318e6682022-09-22 17:17:22 +0200300 struct dentry *dentry, const char *acl_name,
301 const void *kvalue, size_t size)
302{
303 return -EOPNOTSUPP;
304}
Christian Brauner5a6f52d2022-10-28 09:56:20 +0200305static inline ssize_t do_get_acl(struct mnt_idmap *idmap,
Christian Brauner318e6682022-09-22 17:17:22 +0200306 struct dentry *dentry, const char *acl_name,
307 void *kvalue, size_t size)
308{
309 return -EOPNOTSUPP;
310}
311#endif
Al Viro06bbaa62022-09-26 11:59:14 -0400312
313ssize_t __kernel_write_iter(struct file *file, struct iov_iter *from, loff_t *pos);
Christian Brauner72ae0172022-10-17 17:06:36 +0200314
315/*
316 * fs/attr.c
317 */
Christian Brauner3707d842023-01-13 12:49:33 +0100318struct mnt_idmap *alloc_mnt_idmap(struct user_namespace *mnt_userns);
319struct mnt_idmap *mnt_idmap_get(struct mnt_idmap *idmap);
320void mnt_idmap_put(struct mnt_idmap *idmap);
Christian Braunere9c52632024-03-01 10:26:03 +0100321struct stashed_operations {
322 void (*put_data)(void *data);
Christian Brauner9d9539d2024-03-12 10:39:44 +0100323 int (*init_inode)(struct inode *inode, void *data);
Christian Braunere9c52632024-03-01 10:26:03 +0100324};
Christian Brauner9d9539d2024-03-12 10:39:44 +0100325int path_from_stashed(struct dentry **stashed, struct vfsmount *mnt, void *data,
326 struct path *path);
Christian Brauner2558e3b2024-02-21 09:59:51 +0100327void stashed_dentry_prune(struct dentry *dentry);
Mateusz Guzik0ef625b2024-06-25 17:18:06 +0200328/**
329 * path_mounted - check whether path is mounted
330 * @path: path to check
331 *
332 * Determine whether @path refers to the root of a mount.
333 *
334 * Return: true if @path is the root of a mount, false if not.
335 */
336static inline bool path_mounted(const struct path *path)
337{
338 return path->mnt->mnt_root == path->dentry;
339}