1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2 | /* |
3 | * Copyright 1997-1998 Transmeta Corporation - All Rights Reserved |
4 | * Copyright 2005-2006 Ian Kent <raven@themaw.net> |
5 | */ |
6 | |
7 | /* Internal header file for autofs */ |
8 | |
9 | #include <linux/auto_fs.h> |
10 | #include <linux/auto_dev-ioctl.h> |
11 | |
12 | #include <linux/kernel.h> |
13 | #include <linux/slab.h> |
14 | #include <linux/time.h> |
15 | #include <linux/string.h> |
16 | #include <linux/wait.h> |
17 | #include <linux/sched.h> |
18 | #include <linux/sched/signal.h> |
19 | #include <linux/mount.h> |
20 | #include <linux/namei.h> |
21 | #include <linux/uaccess.h> |
22 | #include <linux/mutex.h> |
23 | #include <linux/spinlock.h> |
24 | #include <linux/list.h> |
25 | #include <linux/completion.h> |
26 | #include <linux/file.h> |
27 | #include <linux/magic.h> |
28 | #include <linux/fs_context.h> |
29 | #include <linux/fs_parser.h> |
30 | |
31 | /* This is the range of ioctl() numbers we claim as ours */ |
32 | #define AUTOFS_IOC_FIRST AUTOFS_IOC_READY |
33 | #define AUTOFS_IOC_COUNT 32 |
34 | |
35 | #define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION) |
36 | #define AUTOFS_DEV_IOCTL_IOC_COUNT \ |
37 | (AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD - AUTOFS_DEV_IOCTL_VERSION_CMD) |
38 | |
39 | #ifdef pr_fmt |
40 | #undef pr_fmt |
41 | #endif |
42 | #define pr_fmt(fmt) KBUILD_MODNAME ":pid:%d:%s: " fmt, current->pid, __func__ |
43 | |
44 | extern struct file_system_type autofs_fs_type; |
45 | |
46 | /* |
47 | * Unified info structure. This is pointed to by both the dentry and |
48 | * inode structures. Each file in the filesystem has an instance of this |
49 | * structure. It holds a reference to the dentry, so dentries are never |
50 | * flushed while the file exists. All name lookups are dealt with at the |
51 | * dentry level, although the filesystem can interfere in the validation |
52 | * process. Readdir is implemented by traversing the dentry lists. |
53 | */ |
54 | struct autofs_info { |
55 | struct dentry *dentry; |
56 | int flags; |
57 | |
58 | struct completion expire_complete; |
59 | |
60 | struct list_head active; |
61 | |
62 | struct list_head expiring; |
63 | |
64 | struct autofs_sb_info *sbi; |
65 | unsigned long last_used; |
66 | int count; |
67 | |
68 | kuid_t uid; |
69 | kgid_t gid; |
70 | struct rcu_head rcu; |
71 | }; |
72 | |
73 | #define AUTOFS_INF_EXPIRING (1<<0) /* dentry in the process of expiring */ |
74 | #define AUTOFS_INF_WANT_EXPIRE (1<<1) /* the dentry is being considered |
75 | * for expiry, so RCU_walk is |
76 | * not permitted. If it progresses to |
77 | * actual expiry attempt, the flag is |
78 | * not cleared when EXPIRING is set - |
79 | * in that case it gets cleared only |
80 | * when it comes to clearing EXPIRING. |
81 | */ |
82 | #define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */ |
83 | |
84 | struct autofs_wait_queue { |
85 | wait_queue_head_t queue; |
86 | struct autofs_wait_queue *next; |
87 | autofs_wqt_t wait_queue_token; |
88 | /* We use the following to see what we are waiting for */ |
89 | struct qstr name; |
90 | u32 offset; |
91 | u32 dev; |
92 | u64 ino; |
93 | kuid_t uid; |
94 | kgid_t gid; |
95 | pid_t pid; |
96 | pid_t tgid; |
97 | /* This is for status reporting upon return */ |
98 | int status; |
99 | unsigned int wait_ctr; |
100 | }; |
101 | |
102 | #define AUTOFS_SBI_MAGIC 0x6d4a556d |
103 | |
104 | #define AUTOFS_SBI_CATATONIC 0x0001 |
105 | #define AUTOFS_SBI_STRICTEXPIRE 0x0002 |
106 | #define AUTOFS_SBI_IGNORE 0x0004 |
107 | |
108 | struct autofs_sb_info { |
109 | u32 magic; |
110 | int pipefd; |
111 | struct file *pipe; |
112 | struct pid *oz_pgrp; |
113 | int version; |
114 | int sub_version; |
115 | int min_proto; |
116 | int max_proto; |
117 | unsigned int flags; |
118 | unsigned long exp_timeout; |
119 | unsigned int type; |
120 | struct super_block *sb; |
121 | struct mutex wq_mutex; |
122 | struct mutex pipe_mutex; |
123 | spinlock_t fs_lock; |
124 | struct autofs_wait_queue *queues; /* Wait queue pointer */ |
125 | spinlock_t lookup_lock; |
126 | struct list_head active_list; |
127 | struct list_head expiring_list; |
128 | struct rcu_head rcu; |
129 | }; |
130 | |
131 | static inline struct autofs_sb_info *autofs_sbi(struct super_block *sb) |
132 | { |
133 | return (struct autofs_sb_info *)(sb->s_fs_info); |
134 | } |
135 | |
136 | static inline struct autofs_info *autofs_dentry_ino(struct dentry *dentry) |
137 | { |
138 | return (struct autofs_info *)(dentry->d_fsdata); |
139 | } |
140 | |
141 | /* autofs_oz_mode(): do we see the man behind the curtain? (The |
142 | * processes which do manipulations for us in user space sees the raw |
143 | * filesystem without "magic".) |
144 | */ |
145 | static inline int autofs_oz_mode(struct autofs_sb_info *sbi) |
146 | { |
147 | return ((sbi->flags & AUTOFS_SBI_CATATONIC) || |
148 | task_pgrp(current) == sbi->oz_pgrp); |
149 | } |
150 | |
151 | static inline bool autofs_empty(struct autofs_info *ino) |
152 | { |
153 | return ino->count < 2; |
154 | } |
155 | |
156 | struct inode *autofs_get_inode(struct super_block *, umode_t); |
157 | void autofs_free_ino(struct autofs_info *); |
158 | |
159 | /* Expiration */ |
160 | int is_autofs_dentry(struct dentry *); |
161 | int autofs_expire_wait(const struct path *path, int rcu_walk); |
162 | int autofs_expire_run(struct super_block *, struct vfsmount *, |
163 | struct autofs_sb_info *, |
164 | struct autofs_packet_expire __user *); |
165 | int autofs_do_expire_multi(struct super_block *sb, struct vfsmount *mnt, |
166 | struct autofs_sb_info *sbi, unsigned int how); |
167 | int autofs_expire_multi(struct super_block *, struct vfsmount *, |
168 | struct autofs_sb_info *, int __user *); |
169 | |
170 | /* Device node initialization */ |
171 | |
172 | int autofs_dev_ioctl_init(void); |
173 | void autofs_dev_ioctl_exit(void); |
174 | |
175 | /* Operations structures */ |
176 | |
177 | extern const struct inode_operations autofs_symlink_inode_operations; |
178 | extern const struct inode_operations autofs_dir_inode_operations; |
179 | extern const struct file_operations autofs_dir_operations; |
180 | extern const struct file_operations autofs_root_operations; |
181 | extern const struct dentry_operations autofs_dentry_operations; |
182 | |
183 | /* VFS automount flags management functions */ |
184 | static inline void __managed_dentry_set_managed(struct dentry *dentry) |
185 | { |
186 | dentry->d_flags |= (DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT); |
187 | } |
188 | |
189 | static inline void managed_dentry_set_managed(struct dentry *dentry) |
190 | { |
191 | spin_lock(lock: &dentry->d_lock); |
192 | __managed_dentry_set_managed(dentry); |
193 | spin_unlock(lock: &dentry->d_lock); |
194 | } |
195 | |
196 | static inline void __managed_dentry_clear_managed(struct dentry *dentry) |
197 | { |
198 | dentry->d_flags &= ~(DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT); |
199 | } |
200 | |
201 | static inline void managed_dentry_clear_managed(struct dentry *dentry) |
202 | { |
203 | spin_lock(lock: &dentry->d_lock); |
204 | __managed_dentry_clear_managed(dentry); |
205 | spin_unlock(lock: &dentry->d_lock); |
206 | } |
207 | |
208 | /* Initializing function */ |
209 | |
210 | extern const struct fs_parameter_spec autofs_param_specs[]; |
211 | int autofs_init_fs_context(struct fs_context *fc); |
212 | struct autofs_info *autofs_new_ino(struct autofs_sb_info *); |
213 | void autofs_clean_ino(struct autofs_info *); |
214 | |
215 | static inline int autofs_check_pipe(struct file *pipe) |
216 | { |
217 | if (!(pipe->f_mode & FMODE_CAN_WRITE)) |
218 | return -EINVAL; |
219 | if (!S_ISFIFO(file_inode(pipe)->i_mode)) |
220 | return -EINVAL; |
221 | return 0; |
222 | } |
223 | |
224 | static inline void autofs_set_packet_pipe_flags(struct file *pipe) |
225 | { |
226 | /* We want a packet pipe */ |
227 | pipe->f_flags |= O_DIRECT; |
228 | /* We don't expect -EAGAIN */ |
229 | pipe->f_flags &= ~O_NONBLOCK; |
230 | } |
231 | |
232 | static inline int autofs_prepare_pipe(struct file *pipe) |
233 | { |
234 | int ret = autofs_check_pipe(pipe); |
235 | if (ret < 0) |
236 | return ret; |
237 | autofs_set_packet_pipe_flags(pipe); |
238 | return 0; |
239 | } |
240 | |
241 | /* Queue management functions */ |
242 | |
243 | int autofs_wait(struct autofs_sb_info *, |
244 | const struct path *, enum autofs_notify); |
245 | int autofs_wait_release(struct autofs_sb_info *, autofs_wqt_t, int); |
246 | void autofs_catatonic_mode(struct autofs_sb_info *); |
247 | |
248 | static inline u32 autofs_get_dev(struct autofs_sb_info *sbi) |
249 | { |
250 | return new_encode_dev(dev: sbi->sb->s_dev); |
251 | } |
252 | |
253 | static inline u64 autofs_get_ino(struct autofs_sb_info *sbi) |
254 | { |
255 | return d_inode(dentry: sbi->sb->s_root)->i_ino; |
256 | } |
257 | |
258 | static inline void __autofs_add_expiring(struct dentry *dentry) |
259 | { |
260 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
261 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
262 | |
263 | if (ino) { |
264 | if (list_empty(head: &ino->expiring)) |
265 | list_add(new: &ino->expiring, head: &sbi->expiring_list); |
266 | } |
267 | } |
268 | |
269 | static inline void autofs_add_expiring(struct dentry *dentry) |
270 | { |
271 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
272 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
273 | |
274 | if (ino) { |
275 | spin_lock(lock: &sbi->lookup_lock); |
276 | if (list_empty(head: &ino->expiring)) |
277 | list_add(new: &ino->expiring, head: &sbi->expiring_list); |
278 | spin_unlock(lock: &sbi->lookup_lock); |
279 | } |
280 | } |
281 | |
282 | static inline void autofs_del_expiring(struct dentry *dentry) |
283 | { |
284 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
285 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
286 | |
287 | if (ino) { |
288 | spin_lock(lock: &sbi->lookup_lock); |
289 | if (!list_empty(head: &ino->expiring)) |
290 | list_del_init(entry: &ino->expiring); |
291 | spin_unlock(lock: &sbi->lookup_lock); |
292 | } |
293 | } |
294 | |
295 | void autofs_kill_sb(struct super_block *); |
296 | |