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