]>
git.ipfire.org Git - thirdparty/linux.git/blob - fs/d_path.c
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>
7 #include <linux/slab.h>
8 #include <linux/prefetch.h>
11 struct prepend_buffer
{
15 #define DECLARE_BUFFER(__name, __buf, __len) \
16 struct prepend_buffer __name = {.buf = __buf + __len, .len = __len}
18 static char *extract_string(struct prepend_buffer
*p
)
20 if (likely(p
->len
>= 0))
22 return ERR_PTR(-ENAMETOOLONG
);
25 static bool prepend_char(struct prepend_buffer
*p
, unsigned char c
)
27 if (likely(p
->len
> 0)) {
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.
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.
47 static bool prepend_copy(void *dst
, const void *src
, int len
)
49 if (unlikely(copy_from_kernel_nofault(dst
, src
, len
))) {
50 memset(dst
, 'x', len
);
56 static bool prepend(struct prepend_buffer
*p
, const char *str
, int namelen
)
58 // Already overflowed?
63 if (p
->len
< namelen
) {
64 // Fill as much as possible from the end of the name
65 str
+= namelen
- p
->len
;
67 prepend_copy(p
->buf
, str
, p
->len
);
75 return prepend_copy(p
->buf
, str
, namelen
);
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
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.
92 * Load acquire is needed to make sure that we see the new name data even
93 * if we might get the length wrong.
95 static bool prepend_name(struct prepend_buffer
*p
, const struct qstr
*name
)
97 const char *dname
= smp_load_acquire(&name
->name
); /* ^^^ */
98 u32 dlen
= READ_ONCE(name
->len
);
100 return prepend(p
, dname
, dlen
) && prepend_char(p
, '/');
103 static int __prepend_path(const struct dentry
*dentry
, const struct mount
*mnt
,
104 const struct path
*root
, struct prepend_buffer
*p
)
106 while (dentry
!= root
->dentry
|| &mnt
->mnt
!= root
->mnt
) {
107 const struct dentry
*parent
= READ_ONCE(dentry
->d_parent
);
109 if (dentry
== mnt
->mnt
.mnt_root
) {
110 struct mount
*m
= READ_ONCE(mnt
->mnt_parent
);
111 struct mnt_namespace
*mnt_ns
;
113 if (likely(mnt
!= m
)) {
114 dentry
= READ_ONCE(mnt
->mnt_mountpoint
);
119 mnt_ns
= READ_ONCE(mnt
->mnt_ns
);
120 /* open-coded is_mounted() to use local mnt_ns */
121 if (!IS_ERR_OR_NULL(mnt_ns
) && !is_anon_ns(mnt_ns
))
122 return 1; // absolute root
124 return 2; // detached or not attached yet
127 if (unlikely(dentry
== parent
))
132 if (!prepend_name(p
, &dentry
->d_name
))
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
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.
155 static int prepend_path(const struct path
*path
,
156 const struct path
*root
,
157 struct prepend_buffer
*p
)
159 unsigned seq
, m_seq
= 0;
160 struct prepend_buffer b
;
165 read_seqbegin_or_lock(&mount_lock
, &m_seq
);
170 read_seqbegin_or_lock(&rename_lock
, &seq
);
171 error
= __prepend_path(path
->dentry
, real_mount(path
->mnt
), root
, &b
);
174 if (need_seqretry(&rename_lock
, seq
)) {
178 done_seqretry(&rename_lock
, seq
);
182 if (need_seqretry(&mount_lock
, m_seq
)) {
186 done_seqretry(&mount_lock
, m_seq
);
188 if (unlikely(error
== 3))
192 prepend_char(&b
, '/');
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
205 * Convert a dentry into an ASCII path name.
207 * Returns a pointer into the buffer or an error code if the
210 * "buflen" should be positive.
212 * If the path is not reachable from the supplied root, return %NULL.
214 char *__d_path(const struct path
*path
,
215 const struct path
*root
,
216 char *buf
, int buflen
)
218 DECLARE_BUFFER(b
, buf
, buflen
);
221 if (unlikely(prepend_path(path
, root
, &b
) > 0))
223 return extract_string(&b
);
226 char *d_absolute_path(const struct path
*path
,
227 char *buf
, int buflen
)
229 struct path root
= {};
230 DECLARE_BUFFER(b
, buf
, buflen
);
233 if (unlikely(prepend_path(path
, &root
, &b
) > 1))
234 return ERR_PTR(-EINVAL
);
235 return extract_string(&b
);
238 static void get_fs_root_rcu(struct fs_struct
*fs
, struct path
*root
)
243 seq
= read_seqcount_begin(&fs
->seq
);
245 } while (read_seqcount_retry(&fs
->seq
, seq
));
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
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.
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.
262 * "buflen" should be positive.
264 char *d_path(const struct path
*path
, char *buf
, int buflen
)
266 DECLARE_BUFFER(b
, buf
, buflen
);
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:
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.
280 if (path
->dentry
->d_op
&& path
->dentry
->d_op
->d_dname
&&
281 (!IS_ROOT(path
->dentry
) || path
->dentry
!= path
->mnt
->mnt_root
))
282 return path
->dentry
->d_op
->d_dname(path
->dentry
, buf
, buflen
);
285 get_fs_root_rcu(current
->fs
, &root
);
286 if (unlikely(d_unlinked(path
->dentry
)))
287 prepend(&b
, " (deleted)", 11);
290 prepend_path(path
, &root
, &b
);
293 return extract_string(&b
);
295 EXPORT_SYMBOL(d_path
);
298 * Helper function for dentry_operations.d_dname() members
300 char *dynamic_dname(char *buffer
, int buflen
, const char *fmt
, ...)
307 sz
= vsnprintf(temp
, sizeof(temp
), fmt
, args
) + 1;
310 if (sz
> sizeof(temp
) || sz
> buflen
)
311 return ERR_PTR(-ENAMETOOLONG
);
313 buffer
+= buflen
- sz
;
314 return memcpy(buffer
, temp
, sz
);
317 char *simple_dname(struct dentry
*dentry
, char *buffer
, int buflen
)
319 DECLARE_BUFFER(b
, buffer
, buflen
);
320 /* these dentries are never renamed, so d_lock is not needed */
321 prepend(&b
, " (deleted)", 11);
322 prepend(&b
, dentry
->d_name
.name
, dentry
->d_name
.len
);
323 prepend_char(&b
, '/');
324 return extract_string(&b
);
328 * Write full pathname from the root of the filesystem into the buffer.
330 static char *__dentry_path(const struct dentry
*d
, struct prepend_buffer
*p
)
332 const struct dentry
*dentry
;
333 struct prepend_buffer b
;
340 read_seqbegin_or_lock(&rename_lock
, &seq
);
341 while (!IS_ROOT(dentry
)) {
342 const struct dentry
*parent
= dentry
->d_parent
;
345 if (!prepend_name(&b
, &dentry
->d_name
))
351 if (need_seqretry(&rename_lock
, seq
)) {
355 done_seqretry(&rename_lock
, seq
);
357 prepend_char(&b
, '/');
358 return extract_string(&b
);
361 char *dentry_path_raw(const struct dentry
*dentry
, char *buf
, int buflen
)
363 DECLARE_BUFFER(b
, buf
, buflen
);
366 return __dentry_path(dentry
, &b
);
368 EXPORT_SYMBOL(dentry_path_raw
);
370 char *dentry_path(const struct dentry
*dentry
, char *buf
, int buflen
)
372 DECLARE_BUFFER(b
, buf
, buflen
);
374 if (unlikely(d_unlinked(dentry
)))
375 prepend(&b
, "//deleted", 10);
378 return __dentry_path(dentry
, &b
);
381 static void get_fs_root_and_pwd_rcu(struct fs_struct
*fs
, struct path
*root
,
387 seq
= read_seqcount_begin(&fs
->seq
);
390 } while (read_seqcount_retry(&fs
->seq
, seq
));
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
400 * char *getcwd(char * buf, size_t size)
404 * retval = sys_getcwd(buf, size);
411 SYSCALL_DEFINE2(getcwd
, char __user
*, buf
, unsigned long, size
)
414 struct path pwd
, root
;
415 char *page
= __getname();
421 get_fs_root_and_pwd_rcu(current
->fs
, &root
, &pwd
);
423 if (unlikely(d_unlinked(pwd
.dentry
))) {
428 DECLARE_BUFFER(b
, page
, PATH_MAX
);
431 if (unlikely(prepend_path(&pwd
, &root
, &b
) > 0))
432 prepend(&b
, "(unreachable)", 13);
435 len
= PATH_MAX
- b
.len
;
436 if (unlikely(len
> PATH_MAX
))
437 error
= -ENAMETOOLONG
;
438 else if (unlikely(len
> size
))
440 else if (copy_to_user(buf
, b
.buf
, len
))