Commit | Line | Data |
---|---|---|
7a5cf791 AV |
1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #include <linux/syscalls.h> | |
3 | #include <linux/export.h> | |
4 | #include <linux/uaccess.h> | |
5 | #include <linux/fs_struct.h> | |
6 | #include <linux/fs.h> | |
7 | #include <linux/slab.h> | |
8 | #include <linux/prefetch.h> | |
9 | #include "mount.h" | |
10 | ||
11 | static int prepend(char **buffer, int *buflen, const char *str, int namelen) | |
12 | { | |
13 | *buflen -= namelen; | |
14 | if (*buflen < 0) | |
15 | return -ENAMETOOLONG; | |
16 | *buffer -= namelen; | |
17 | memcpy(*buffer, str, namelen); | |
18 | return 0; | |
19 | } | |
20 | ||
21 | /** | |
22 | * prepend_name - prepend a pathname in front of current buffer pointer | |
23 | * @buffer: buffer pointer | |
24 | * @buflen: allocated length of the buffer | |
25 | * @name: name string and length qstr structure | |
26 | * | |
27 | * With RCU path tracing, it may race with d_move(). Use READ_ONCE() to | |
28 | * make sure that either the old or the new name pointer and length are | |
29 | * fetched. However, there may be mismatch between length and pointer. | |
30 | * The length cannot be trusted, we need to copy it byte-by-byte until | |
31 | * the length is reached or a null byte is found. It also prepends "/" at | |
32 | * the beginning of the name. The sequence number check at the caller will | |
33 | * retry it again when a d_move() does happen. So any garbage in the buffer | |
34 | * due to mismatched pointer and length will be discarded. | |
35 | * | |
36 | * Load acquire is needed to make sure that we see that terminating NUL. | |
37 | */ | |
38 | static int prepend_name(char **buffer, int *buflen, const struct qstr *name) | |
39 | { | |
40 | const char *dname = smp_load_acquire(&name->name); /* ^^^ */ | |
41 | u32 dlen = READ_ONCE(name->len); | |
42 | char *p; | |
43 | ||
44 | *buflen -= dlen + 1; | |
45 | if (*buflen < 0) | |
46 | return -ENAMETOOLONG; | |
47 | p = *buffer -= dlen + 1; | |
48 | *p++ = '/'; | |
49 | while (dlen--) { | |
50 | char c = *dname++; | |
51 | if (!c) | |
52 | break; | |
53 | *p++ = c; | |
54 | } | |
55 | return 0; | |
56 | } | |
57 | ||
58 | /** | |
59 | * prepend_path - Prepend path string to a buffer | |
60 | * @path: the dentry/vfsmount to report | |
61 | * @root: root vfsmnt/dentry | |
62 | * @buffer: pointer to the end of the buffer | |
63 | * @buflen: pointer to buffer length | |
64 | * | |
65 | * The function will first try to write out the pathname without taking any | |
66 | * lock other than the RCU read lock to make sure that dentries won't go away. | |
67 | * It only checks the sequence number of the global rename_lock as any change | |
68 | * in the dentry's d_seq will be preceded by changes in the rename_lock | |
69 | * sequence number. If the sequence number had been changed, it will restart | |
70 | * the whole pathname back-tracing sequence again by taking the rename_lock. | |
71 | * In this case, there is no need to take the RCU read lock as the recursive | |
72 | * parent pointer references will keep the dentry chain alive as long as no | |
73 | * rename operation is performed. | |
74 | */ | |
75 | static int prepend_path(const struct path *path, | |
76 | const struct path *root, | |
77 | char **buffer, int *buflen) | |
78 | { | |
79 | struct dentry *dentry; | |
80 | struct vfsmount *vfsmnt; | |
81 | struct mount *mnt; | |
82 | int error = 0; | |
83 | unsigned seq, m_seq = 0; | |
84 | char *bptr; | |
85 | int blen; | |
86 | ||
87 | rcu_read_lock(); | |
88 | restart_mnt: | |
89 | read_seqbegin_or_lock(&mount_lock, &m_seq); | |
90 | seq = 0; | |
91 | rcu_read_lock(); | |
92 | restart: | |
93 | bptr = *buffer; | |
94 | blen = *buflen; | |
95 | error = 0; | |
96 | dentry = path->dentry; | |
97 | vfsmnt = path->mnt; | |
98 | mnt = real_mount(vfsmnt); | |
99 | read_seqbegin_or_lock(&rename_lock, &seq); | |
100 | while (dentry != root->dentry || vfsmnt != root->mnt) { | |
101 | struct dentry * parent; | |
102 | ||
103 | if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) { | |
104 | struct mount *parent = READ_ONCE(mnt->mnt_parent); | |
105 | /* Escaped? */ | |
106 | if (dentry != vfsmnt->mnt_root) { | |
107 | bptr = *buffer; | |
108 | blen = *buflen; | |
109 | error = 3; | |
110 | break; | |
111 | } | |
112 | /* Global root? */ | |
113 | if (mnt != parent) { | |
114 | dentry = READ_ONCE(mnt->mnt_mountpoint); | |
115 | mnt = parent; | |
116 | vfsmnt = &mnt->mnt; | |
117 | continue; | |
118 | } | |
f2683bd8 AV |
119 | if (is_mounted(vfsmnt) && !is_anon_ns(mnt->mnt_ns)) |
120 | error = 1; // absolute root | |
121 | else | |
122 | error = 2; // detached or not attached yet | |
7a5cf791 AV |
123 | break; |
124 | } | |
125 | parent = dentry->d_parent; | |
126 | prefetch(parent); | |
127 | error = prepend_name(&bptr, &blen, &dentry->d_name); | |
128 | if (error) | |
129 | break; | |
130 | ||
131 | dentry = parent; | |
132 | } | |
133 | if (!(seq & 1)) | |
134 | rcu_read_unlock(); | |
135 | if (need_seqretry(&rename_lock, seq)) { | |
136 | seq = 1; | |
137 | goto restart; | |
138 | } | |
139 | done_seqretry(&rename_lock, seq); | |
140 | ||
141 | if (!(m_seq & 1)) | |
142 | rcu_read_unlock(); | |
143 | if (need_seqretry(&mount_lock, m_seq)) { | |
144 | m_seq = 1; | |
145 | goto restart_mnt; | |
146 | } | |
147 | done_seqretry(&mount_lock, m_seq); | |
148 | ||
149 | if (error >= 0 && bptr == *buffer) { | |
150 | if (--blen < 0) | |
151 | error = -ENAMETOOLONG; | |
152 | else | |
153 | *--bptr = '/'; | |
154 | } | |
155 | *buffer = bptr; | |
156 | *buflen = blen; | |
157 | return error; | |
158 | } | |
159 | ||
160 | /** | |
161 | * __d_path - return the path of a dentry | |
162 | * @path: the dentry/vfsmount to report | |
163 | * @root: root vfsmnt/dentry | |
164 | * @buf: buffer to return value in | |
165 | * @buflen: buffer length | |
166 | * | |
167 | * Convert a dentry into an ASCII path name. | |
168 | * | |
169 | * Returns a pointer into the buffer or an error code if the | |
170 | * path was too long. | |
171 | * | |
172 | * "buflen" should be positive. | |
173 | * | |
174 | * If the path is not reachable from the supplied root, return %NULL. | |
175 | */ | |
176 | char *__d_path(const struct path *path, | |
177 | const struct path *root, | |
178 | char *buf, int buflen) | |
179 | { | |
180 | char *res = buf + buflen; | |
181 | int error; | |
182 | ||
183 | prepend(&res, &buflen, "\0", 1); | |
184 | error = prepend_path(path, root, &res, &buflen); | |
185 | ||
186 | if (error < 0) | |
187 | return ERR_PTR(error); | |
188 | if (error > 0) | |
189 | return NULL; | |
190 | return res; | |
191 | } | |
192 | ||
193 | char *d_absolute_path(const struct path *path, | |
194 | char *buf, int buflen) | |
195 | { | |
196 | struct path root = {}; | |
197 | char *res = buf + buflen; | |
198 | int error; | |
199 | ||
200 | prepend(&res, &buflen, "\0", 1); | |
201 | error = prepend_path(path, &root, &res, &buflen); | |
202 | ||
203 | if (error > 1) | |
204 | error = -EINVAL; | |
205 | if (error < 0) | |
206 | return ERR_PTR(error); | |
207 | return res; | |
208 | } | |
209 | ||
210 | /* | |
211 | * same as __d_path but appends "(deleted)" for unlinked files. | |
212 | */ | |
213 | static int path_with_deleted(const struct path *path, | |
214 | const struct path *root, | |
215 | char **buf, int *buflen) | |
216 | { | |
217 | prepend(buf, buflen, "\0", 1); | |
218 | if (d_unlinked(path->dentry)) { | |
219 | int error = prepend(buf, buflen, " (deleted)", 10); | |
220 | if (error) | |
221 | return error; | |
222 | } | |
223 | ||
224 | return prepend_path(path, root, buf, buflen); | |
225 | } | |
226 | ||
227 | static int prepend_unreachable(char **buffer, int *buflen) | |
228 | { | |
229 | return prepend(buffer, buflen, "(unreachable)", 13); | |
230 | } | |
231 | ||
232 | static void get_fs_root_rcu(struct fs_struct *fs, struct path *root) | |
233 | { | |
234 | unsigned seq; | |
235 | ||
236 | do { | |
237 | seq = read_seqcount_begin(&fs->seq); | |
238 | *root = fs->root; | |
239 | } while (read_seqcount_retry(&fs->seq, seq)); | |
240 | } | |
241 | ||
242 | /** | |
243 | * d_path - return the path of a dentry | |
244 | * @path: path to report | |
245 | * @buf: buffer to return value in | |
246 | * @buflen: buffer length | |
247 | * | |
248 | * Convert a dentry into an ASCII path name. If the entry has been deleted | |
249 | * the string " (deleted)" is appended. Note that this is ambiguous. | |
250 | * | |
251 | * Returns a pointer into the buffer or an error code if the path was | |
252 | * too long. Note: Callers should use the returned pointer, not the passed | |
253 | * in buffer, to use the name! The implementation often starts at an offset | |
254 | * into the buffer, and may leave 0 bytes at the start. | |
255 | * | |
256 | * "buflen" should be positive. | |
257 | */ | |
258 | char *d_path(const struct path *path, char *buf, int buflen) | |
259 | { | |
260 | char *res = buf + buflen; | |
261 | struct path root; | |
262 | int error; | |
263 | ||
264 | /* | |
265 | * We have various synthetic filesystems that never get mounted. On | |
266 | * these filesystems dentries are never used for lookup purposes, and | |
267 | * thus don't need to be hashed. They also don't need a name until a | |
268 | * user wants to identify the object in /proc/pid/fd/. The little hack | |
269 | * below allows us to generate a name for these objects on demand: | |
270 | * | |
271 | * Some pseudo inodes are mountable. When they are mounted | |
272 | * path->dentry == path->mnt->mnt_root. In that case don't call d_dname | |
273 | * and instead have d_path return the mounted path. | |
274 | */ | |
275 | if (path->dentry->d_op && path->dentry->d_op->d_dname && | |
276 | (!IS_ROOT(path->dentry) || path->dentry != path->mnt->mnt_root)) | |
277 | return path->dentry->d_op->d_dname(path->dentry, buf, buflen); | |
278 | ||
279 | rcu_read_lock(); | |
280 | get_fs_root_rcu(current->fs, &root); | |
281 | error = path_with_deleted(path, &root, &res, &buflen); | |
282 | rcu_read_unlock(); | |
283 | ||
284 | if (error < 0) | |
285 | res = ERR_PTR(error); | |
286 | return res; | |
287 | } | |
288 | EXPORT_SYMBOL(d_path); | |
289 | ||
290 | /* | |
291 | * Helper function for dentry_operations.d_dname() members | |
292 | */ | |
293 | char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen, | |
294 | const char *fmt, ...) | |
295 | { | |
296 | va_list args; | |
297 | char temp[64]; | |
298 | int sz; | |
299 | ||
300 | va_start(args, fmt); | |
301 | sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1; | |
302 | va_end(args); | |
303 | ||
304 | if (sz > sizeof(temp) || sz > buflen) | |
305 | return ERR_PTR(-ENAMETOOLONG); | |
306 | ||
307 | buffer += buflen - sz; | |
308 | return memcpy(buffer, temp, sz); | |
309 | } | |
310 | ||
311 | char *simple_dname(struct dentry *dentry, char *buffer, int buflen) | |
312 | { | |
313 | char *end = buffer + buflen; | |
314 | /* these dentries are never renamed, so d_lock is not needed */ | |
315 | if (prepend(&end, &buflen, " (deleted)", 11) || | |
316 | prepend(&end, &buflen, dentry->d_name.name, dentry->d_name.len) || | |
317 | prepend(&end, &buflen, "/", 1)) | |
318 | end = ERR_PTR(-ENAMETOOLONG); | |
319 | return end; | |
320 | } | |
7a5cf791 AV |
321 | |
322 | /* | |
323 | * Write full pathname from the root of the filesystem into the buffer. | |
324 | */ | |
325 | static char *__dentry_path(struct dentry *d, char *buf, int buflen) | |
326 | { | |
327 | struct dentry *dentry; | |
328 | char *end, *retval; | |
329 | int len, seq = 0; | |
330 | int error = 0; | |
331 | ||
332 | if (buflen < 2) | |
333 | goto Elong; | |
334 | ||
335 | rcu_read_lock(); | |
336 | restart: | |
337 | dentry = d; | |
338 | end = buf + buflen; | |
339 | len = buflen; | |
340 | prepend(&end, &len, "\0", 1); | |
341 | /* Get '/' right */ | |
342 | retval = end-1; | |
343 | *retval = '/'; | |
344 | read_seqbegin_or_lock(&rename_lock, &seq); | |
345 | while (!IS_ROOT(dentry)) { | |
346 | struct dentry *parent = dentry->d_parent; | |
347 | ||
348 | prefetch(parent); | |
349 | error = prepend_name(&end, &len, &dentry->d_name); | |
350 | if (error) | |
351 | break; | |
352 | ||
353 | retval = end; | |
354 | dentry = parent; | |
355 | } | |
356 | if (!(seq & 1)) | |
357 | rcu_read_unlock(); | |
358 | if (need_seqretry(&rename_lock, seq)) { | |
359 | seq = 1; | |
360 | goto restart; | |
361 | } | |
362 | done_seqretry(&rename_lock, seq); | |
363 | if (error) | |
364 | goto Elong; | |
365 | return retval; | |
366 | Elong: | |
367 | return ERR_PTR(-ENAMETOOLONG); | |
368 | } | |
369 | ||
370 | char *dentry_path_raw(struct dentry *dentry, char *buf, int buflen) | |
371 | { | |
372 | return __dentry_path(dentry, buf, buflen); | |
373 | } | |
374 | EXPORT_SYMBOL(dentry_path_raw); | |
375 | ||
376 | char *dentry_path(struct dentry *dentry, char *buf, int buflen) | |
377 | { | |
378 | char *p = NULL; | |
379 | char *retval; | |
380 | ||
381 | if (d_unlinked(dentry)) { | |
382 | p = buf + buflen; | |
383 | if (prepend(&p, &buflen, "//deleted", 10) != 0) | |
384 | goto Elong; | |
385 | buflen++; | |
386 | } | |
387 | retval = __dentry_path(dentry, buf, buflen); | |
388 | if (!IS_ERR(retval) && p) | |
389 | *p = '/'; /* restore '/' overriden with '\0' */ | |
390 | return retval; | |
391 | Elong: | |
392 | return ERR_PTR(-ENAMETOOLONG); | |
393 | } | |
394 | ||
395 | static void get_fs_root_and_pwd_rcu(struct fs_struct *fs, struct path *root, | |
396 | struct path *pwd) | |
397 | { | |
398 | unsigned seq; | |
399 | ||
400 | do { | |
401 | seq = read_seqcount_begin(&fs->seq); | |
402 | *root = fs->root; | |
403 | *pwd = fs->pwd; | |
404 | } while (read_seqcount_retry(&fs->seq, seq)); | |
405 | } | |
406 | ||
407 | /* | |
408 | * NOTE! The user-level library version returns a | |
409 | * character pointer. The kernel system call just | |
410 | * returns the length of the buffer filled (which | |
411 | * includes the ending '\0' character), or a negative | |
412 | * error value. So libc would do something like | |
413 | * | |
414 | * char *getcwd(char * buf, size_t size) | |
415 | * { | |
416 | * int retval; | |
417 | * | |
418 | * retval = sys_getcwd(buf, size); | |
419 | * if (retval >= 0) | |
420 | * return buf; | |
421 | * errno = -retval; | |
422 | * return NULL; | |
423 | * } | |
424 | */ | |
425 | SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size) | |
426 | { | |
427 | int error; | |
428 | struct path pwd, root; | |
429 | char *page = __getname(); | |
430 | ||
431 | if (!page) | |
432 | return -ENOMEM; | |
433 | ||
434 | rcu_read_lock(); | |
435 | get_fs_root_and_pwd_rcu(current->fs, &root, &pwd); | |
436 | ||
437 | error = -ENOENT; | |
438 | if (!d_unlinked(pwd.dentry)) { | |
439 | unsigned long len; | |
440 | char *cwd = page + PATH_MAX; | |
441 | int buflen = PATH_MAX; | |
442 | ||
443 | prepend(&cwd, &buflen, "\0", 1); | |
444 | error = prepend_path(&pwd, &root, &cwd, &buflen); | |
445 | rcu_read_unlock(); | |
446 | ||
447 | if (error < 0) | |
448 | goto out; | |
449 | ||
450 | /* Unreachable from current root */ | |
451 | if (error > 0) { | |
452 | error = prepend_unreachable(&cwd, &buflen); | |
453 | if (error) | |
454 | goto out; | |
455 | } | |
456 | ||
457 | error = -ERANGE; | |
458 | len = PATH_MAX + page - cwd; | |
459 | if (len <= size) { | |
460 | error = len; | |
461 | if (copy_to_user(buf, cwd, len)) | |
462 | error = -EFAULT; | |
463 | } | |
464 | } else { | |
465 | rcu_read_unlock(); | |
466 | } | |
467 | ||
468 | out: | |
469 | __putname(page); | |
470 | return error; | |
471 | } |