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
11static 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 */
38static 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 */
75static 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();
88restart_mnt:
89 read_seqbegin_or_lock(&mount_lock, &m_seq);
90 seq = 0;
91 rcu_read_lock();
92restart:
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 }
119 if (!error)
120 error = is_mounted(vfsmnt) ? 1 : 2;
121 break;
122 }
123 parent = dentry->d_parent;
124 prefetch(parent);
125 error = prepend_name(&bptr, &blen, &dentry->d_name);
126 if (error)
127 break;
128
129 dentry = parent;
130 }
131 if (!(seq & 1))
132 rcu_read_unlock();
133 if (need_seqretry(&rename_lock, seq)) {
134 seq = 1;
135 goto restart;
136 }
137 done_seqretry(&rename_lock, seq);
138
139 if (!(m_seq & 1))
140 rcu_read_unlock();
141 if (need_seqretry(&mount_lock, m_seq)) {
142 m_seq = 1;
143 goto restart_mnt;
144 }
145 done_seqretry(&mount_lock, m_seq);
146
147 if (error >= 0 && bptr == *buffer) {
148 if (--blen < 0)
149 error = -ENAMETOOLONG;
150 else
151 *--bptr = '/';
152 }
153 *buffer = bptr;
154 *buflen = blen;
155 return error;
156}
157
158/**
159 * __d_path - return the path of a dentry
160 * @path: the dentry/vfsmount to report
161 * @root: root vfsmnt/dentry
162 * @buf: buffer to return value in
163 * @buflen: buffer length
164 *
165 * Convert a dentry into an ASCII path name.
166 *
167 * Returns a pointer into the buffer or an error code if the
168 * path was too long.
169 *
170 * "buflen" should be positive.
171 *
172 * If the path is not reachable from the supplied root, return %NULL.
173 */
174char *__d_path(const struct path *path,
175 const struct path *root,
176 char *buf, int buflen)
177{
178 char *res = buf + buflen;
179 int error;
180
181 prepend(&res, &buflen, "\0", 1);
182 error = prepend_path(path, root, &res, &buflen);
183
184 if (error < 0)
185 return ERR_PTR(error);
186 if (error > 0)
187 return NULL;
188 return res;
189}
190
191char *d_absolute_path(const struct path *path,
192 char *buf, int buflen)
193{
194 struct path root = {};
195 char *res = buf + buflen;
196 int error;
197
198 prepend(&res, &buflen, "\0", 1);
199 error = prepend_path(path, &root, &res, &buflen);
200
201 if (error > 1)
202 error = -EINVAL;
203 if (error < 0)
204 return ERR_PTR(error);
205 return res;
206}
207
208/*
209 * same as __d_path but appends "(deleted)" for unlinked files.
210 */
211static int path_with_deleted(const struct path *path,
212 const struct path *root,
213 char **buf, int *buflen)
214{
215 prepend(buf, buflen, "\0", 1);
216 if (d_unlinked(path->dentry)) {
217 int error = prepend(buf, buflen, " (deleted)", 10);
218 if (error)
219 return error;
220 }
221
222 return prepend_path(path, root, buf, buflen);
223}
224
225static int prepend_unreachable(char **buffer, int *buflen)
226{
227 return prepend(buffer, buflen, "(unreachable)", 13);
228}
229
230static void get_fs_root_rcu(struct fs_struct *fs, struct path *root)
231{
232 unsigned seq;
233
234 do {
235 seq = read_seqcount_begin(&fs->seq);
236 *root = fs->root;
237 } while (read_seqcount_retry(&fs->seq, seq));
238}
239
240/**
241 * d_path - return the path of a dentry
242 * @path: path to report
243 * @buf: buffer to return value in
244 * @buflen: buffer length
245 *
246 * Convert a dentry into an ASCII path name. If the entry has been deleted
247 * the string " (deleted)" is appended. Note that this is ambiguous.
248 *
249 * Returns a pointer into the buffer or an error code if the path was
250 * too long. Note: Callers should use the returned pointer, not the passed
251 * in buffer, to use the name! The implementation often starts at an offset
252 * into the buffer, and may leave 0 bytes at the start.
253 *
254 * "buflen" should be positive.
255 */
256char *d_path(const struct path *path, char *buf, int buflen)
257{
258 char *res = buf + buflen;
259 struct path root;
260 int error;
261
262 /*
263 * We have various synthetic filesystems that never get mounted. On
264 * these filesystems dentries are never used for lookup purposes, and
265 * thus don't need to be hashed. They also don't need a name until a
266 * user wants to identify the object in /proc/pid/fd/. The little hack
267 * below allows us to generate a name for these objects on demand:
268 *
269 * Some pseudo inodes are mountable. When they are mounted
270 * path->dentry == path->mnt->mnt_root. In that case don't call d_dname
271 * and instead have d_path return the mounted path.
272 */
273 if (path->dentry->d_op && path->dentry->d_op->d_dname &&
274 (!IS_ROOT(path->dentry) || path->dentry != path->mnt->mnt_root))
275 return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
276
277 rcu_read_lock();
278 get_fs_root_rcu(current->fs, &root);
279 error = path_with_deleted(path, &root, &res, &buflen);
280 rcu_read_unlock();
281
282 if (error < 0)
283 res = ERR_PTR(error);
284 return res;
285}
286EXPORT_SYMBOL(d_path);
287
288/*
289 * Helper function for dentry_operations.d_dname() members
290 */
291char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
292 const char *fmt, ...)
293{
294 va_list args;
295 char temp[64];
296 int sz;
297
298 va_start(args, fmt);
299 sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1;
300 va_end(args);
301
302 if (sz > sizeof(temp) || sz > buflen)
303 return ERR_PTR(-ENAMETOOLONG);
304
305 buffer += buflen - sz;
306 return memcpy(buffer, temp, sz);
307}
308
309char *simple_dname(struct dentry *dentry, char *buffer, int buflen)
310{
311 char *end = buffer + buflen;
312 /* these dentries are never renamed, so d_lock is not needed */
313 if (prepend(&end, &buflen, " (deleted)", 11) ||
314 prepend(&end, &buflen, dentry->d_name.name, dentry->d_name.len) ||
315 prepend(&end, &buflen, "/", 1))
316 end = ERR_PTR(-ENAMETOOLONG);
317 return end;
318}
319EXPORT_SYMBOL(simple_dname);
320
321/*
322 * Write full pathname from the root of the filesystem into the buffer.
323 */
324static char *__dentry_path(struct dentry *d, char *buf, int buflen)
325{
326 struct dentry *dentry;
327 char *end, *retval;
328 int len, seq = 0;
329 int error = 0;
330
331 if (buflen < 2)
332 goto Elong;
333
334 rcu_read_lock();
335restart:
336 dentry = d;
337 end = buf + buflen;
338 len = buflen;
339 prepend(&end, &len, "\0", 1);
340 /* Get '/' right */
341 retval = end-1;
342 *retval = '/';
343 read_seqbegin_or_lock(&rename_lock, &seq);
344 while (!IS_ROOT(dentry)) {
345 struct dentry *parent = dentry->d_parent;
346
347 prefetch(parent);
348 error = prepend_name(&end, &len, &dentry->d_name);
349 if (error)
350 break;
351
352 retval = end;
353 dentry = parent;
354 }
355 if (!(seq & 1))
356 rcu_read_unlock();
357 if (need_seqretry(&rename_lock, seq)) {
358 seq = 1;
359 goto restart;
360 }
361 done_seqretry(&rename_lock, seq);
362 if (error)
363 goto Elong;
364 return retval;
365Elong:
366 return ERR_PTR(-ENAMETOOLONG);
367}
368
369char *dentry_path_raw(struct dentry *dentry, char *buf, int buflen)
370{
371 return __dentry_path(dentry, buf, buflen);
372}
373EXPORT_SYMBOL(dentry_path_raw);
374
375char *dentry_path(struct dentry *dentry, char *buf, int buflen)
376{
377 char *p = NULL;
378 char *retval;
379
380 if (d_unlinked(dentry)) {
381 p = buf + buflen;
382 if (prepend(&p, &buflen, "//deleted", 10) != 0)
383 goto Elong;
384 buflen++;
385 }
386 retval = __dentry_path(dentry, buf, buflen);
387 if (!IS_ERR(retval) && p)
388 *p = '/'; /* restore '/' overriden with '\0' */
389 return retval;
390Elong:
391 return ERR_PTR(-ENAMETOOLONG);
392}
393
394static void get_fs_root_and_pwd_rcu(struct fs_struct *fs, struct path *root,
395 struct path *pwd)
396{
397 unsigned seq;
398
399 do {
400 seq = read_seqcount_begin(&fs->seq);
401 *root = fs->root;
402 *pwd = fs->pwd;
403 } while (read_seqcount_retry(&fs->seq, seq));
404}
405
406/*
407 * NOTE! The user-level library version returns a
408 * character pointer. The kernel system call just
409 * returns the length of the buffer filled (which
410 * includes the ending '\0' character), or a negative
411 * error value. So libc would do something like
412 *
413 * char *getcwd(char * buf, size_t size)
414 * {
415 * int retval;
416 *
417 * retval = sys_getcwd(buf, size);
418 * if (retval >= 0)
419 * return buf;
420 * errno = -retval;
421 * return NULL;
422 * }
423 */
424SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
425{
426 int error;
427 struct path pwd, root;
428 char *page = __getname();
429
430 if (!page)
431 return -ENOMEM;
432
433 rcu_read_lock();
434 get_fs_root_and_pwd_rcu(current->fs, &root, &pwd);
435
436 error = -ENOENT;
437 if (!d_unlinked(pwd.dentry)) {
438 unsigned long len;
439 char *cwd = page + PATH_MAX;
440 int buflen = PATH_MAX;
441
442 prepend(&cwd, &buflen, "\0", 1);
443 error = prepend_path(&pwd, &root, &cwd, &buflen);
444 rcu_read_unlock();
445
446 if (error < 0)
447 goto out;
448
449 /* Unreachable from current root */
450 if (error > 0) {
451 error = prepend_unreachable(&cwd, &buflen);
452 if (error)
453 goto out;
454 }
455
456 error = -ERANGE;
457 len = PATH_MAX + page - cwd;
458 if (len <= size) {
459 error = len;
460 if (copy_to_user(buf, cwd, len))
461 error = -EFAULT;
462 }
463 } else {
464 rcu_read_unlock();
465 }
466
467out:
468 __putname(page);
469 return error;
470}
471