]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.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 optimistoc 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 * @buffer: buffer pointer
81 * @buflen: allocated length of the buffer
82 * @name: name string and length qstr structure
84 * With RCU path tracing, it may race with d_move(). Use READ_ONCE() to
85 * make sure that either the old or the new name pointer and length are
86 * fetched. However, there may be mismatch between length and pointer.
87 * But since the length cannot be trusted, we need to copy the name very
88 * carefully when doing the prepend_copy(). It also prepends "/" at
89 * the beginning of the name. The sequence number check at the caller will
90 * retry it again when a d_move() does happen. So any garbage in the buffer
91 * due to mismatched pointer and length will be discarded.
93 * Load acquire is needed to make sure that we see the new name data even
94 * if we might get the length wrong.
96 static bool prepend_name(struct prepend_buffer
*p
, const struct qstr
*name
)
98 const char *dname
= smp_load_acquire(&name
->name
); /* ^^^ */
99 u32 dlen
= READ_ONCE(name
->len
);
101 return prepend(p
, dname
, dlen
) && prepend_char(p
, '/');
104 static int __prepend_path(const struct dentry
*dentry
, const struct mount
*mnt
,
105 const struct path
*root
, struct prepend_buffer
*p
)
107 while (dentry
!= root
->dentry
|| &mnt
->mnt
!= root
->mnt
) {
108 const struct dentry
*parent
= READ_ONCE(dentry
->d_parent
);
110 if (dentry
== mnt
->mnt
.mnt_root
) {
111 struct mount
*m
= READ_ONCE(mnt
->mnt_parent
);
112 struct mnt_namespace
*mnt_ns
;
114 if (likely(mnt
!= m
)) {
115 dentry
= READ_ONCE(mnt
->mnt_mountpoint
);
120 mnt_ns
= READ_ONCE(mnt
->mnt_ns
);
121 /* open-coded is_mounted() to use local mnt_ns */
122 if (!IS_ERR_OR_NULL(mnt_ns
) && !is_anon_ns(mnt_ns
))
123 return 1; // absolute root
125 return 2; // detached or not attached yet
128 if (unlikely(dentry
== parent
))
133 if (!prepend_name(p
, &dentry
->d_name
))
141 * prepend_path - Prepend path string to a buffer
142 * @path: the dentry/vfsmount to report
143 * @root: root vfsmnt/dentry
144 * @buffer: pointer to the end of the buffer
145 * @buflen: pointer to buffer length
147 * The function will first try to write out the pathname without taking any
148 * lock other than the RCU read lock to make sure that dentries won't go away.
149 * It only checks the sequence number of the global rename_lock as any change
150 * in the dentry's d_seq will be preceded by changes in the rename_lock
151 * sequence number. If the sequence number had been changed, it will restart
152 * the whole pathname back-tracing sequence again by taking the rename_lock.
153 * In this case, there is no need to take the RCU read lock as the recursive
154 * parent pointer references will keep the dentry chain alive as long as no
155 * rename operation is performed.
157 static int prepend_path(const struct path
*path
,
158 const struct path
*root
,
159 struct prepend_buffer
*p
)
161 unsigned seq
, m_seq
= 0;
162 struct prepend_buffer b
;
167 read_seqbegin_or_lock(&mount_lock
, &m_seq
);
172 read_seqbegin_or_lock(&rename_lock
, &seq
);
173 error
= __prepend_path(path
->dentry
, real_mount(path
->mnt
), root
, &b
);
176 if (need_seqretry(&rename_lock
, seq
)) {
180 done_seqretry(&rename_lock
, seq
);
184 if (need_seqretry(&mount_lock
, m_seq
)) {
188 done_seqretry(&mount_lock
, m_seq
);
190 if (unlikely(error
== 3))
194 prepend_char(&b
, '/');
201 * __d_path - return the path of a dentry
202 * @path: the dentry/vfsmount to report
203 * @root: root vfsmnt/dentry
204 * @buf: buffer to return value in
205 * @buflen: buffer length
207 * Convert a dentry into an ASCII path name.
209 * Returns a pointer into the buffer or an error code if the
212 * "buflen" should be positive.
214 * If the path is not reachable from the supplied root, return %NULL.
216 char *__d_path(const struct path
*path
,
217 const struct path
*root
,
218 char *buf
, int buflen
)
220 DECLARE_BUFFER(b
, buf
, buflen
);
223 if (unlikely(prepend_path(path
, root
, &b
) > 0))
225 return extract_string(&b
);
228 char *d_absolute_path(const struct path
*path
,
229 char *buf
, int buflen
)
231 struct path root
= {};
232 DECLARE_BUFFER(b
, buf
, buflen
);
235 if (unlikely(prepend_path(path
, &root
, &b
) > 1))
236 return ERR_PTR(-EINVAL
);
237 return extract_string(&b
);
240 static void get_fs_root_rcu(struct fs_struct
*fs
, struct path
*root
)
245 seq
= read_seqcount_begin(&fs
->seq
);
247 } while (read_seqcount_retry(&fs
->seq
, seq
));
251 * d_path - return the path of a dentry
252 * @path: path to report
253 * @buf: buffer to return value in
254 * @buflen: buffer length
256 * Convert a dentry into an ASCII path name. If the entry has been deleted
257 * the string " (deleted)" is appended. Note that this is ambiguous.
259 * Returns a pointer into the buffer or an error code if the path was
260 * too long. Note: Callers should use the returned pointer, not the passed
261 * in buffer, to use the name! The implementation often starts at an offset
262 * into the buffer, and may leave 0 bytes at the start.
264 * "buflen" should be positive.
266 char *d_path(const struct path
*path
, char *buf
, int buflen
)
268 DECLARE_BUFFER(b
, buf
, buflen
);
272 * We have various synthetic filesystems that never get mounted. On
273 * these filesystems dentries are never used for lookup purposes, and
274 * thus don't need to be hashed. They also don't need a name until a
275 * user wants to identify the object in /proc/pid/fd/. The little hack
276 * below allows us to generate a name for these objects on demand:
278 * Some pseudo inodes are mountable. When they are mounted
279 * path->dentry == path->mnt->mnt_root. In that case don't call d_dname
280 * and instead have d_path return the mounted path.
282 if (path
->dentry
->d_op
&& path
->dentry
->d_op
->d_dname
&&
283 (!IS_ROOT(path
->dentry
) || path
->dentry
!= path
->mnt
->mnt_root
))
284 return path
->dentry
->d_op
->d_dname(path
->dentry
, buf
, buflen
);
287 get_fs_root_rcu(current
->fs
, &root
);
288 if (unlikely(d_unlinked(path
->dentry
)))
289 prepend(&b
, " (deleted)", 11);
292 prepend_path(path
, &root
, &b
);
295 return extract_string(&b
);
297 EXPORT_SYMBOL(d_path
);
300 * Helper function for dentry_operations.d_dname() members
302 char *dynamic_dname(struct dentry
*dentry
, char *buffer
, int buflen
,
303 const char *fmt
, ...)
310 sz
= vsnprintf(temp
, sizeof(temp
), fmt
, args
) + 1;
313 if (sz
> sizeof(temp
) || sz
> buflen
)
314 return ERR_PTR(-ENAMETOOLONG
);
316 buffer
+= buflen
- sz
;
317 return memcpy(buffer
, temp
, sz
);
320 char *simple_dname(struct dentry
*dentry
, char *buffer
, int buflen
)
322 DECLARE_BUFFER(b
, buffer
, buflen
);
323 /* these dentries are never renamed, so d_lock is not needed */
324 prepend(&b
, " (deleted)", 11);
325 prepend(&b
, dentry
->d_name
.name
, dentry
->d_name
.len
);
326 prepend_char(&b
, '/');
327 return extract_string(&b
);
331 * Write full pathname from the root of the filesystem into the buffer.
333 static char *__dentry_path(const struct dentry
*d
, struct prepend_buffer
*p
)
335 const struct dentry
*dentry
;
336 struct prepend_buffer b
;
343 read_seqbegin_or_lock(&rename_lock
, &seq
);
344 while (!IS_ROOT(dentry
)) {
345 const struct dentry
*parent
= dentry
->d_parent
;
348 if (!prepend_name(&b
, &dentry
->d_name
))
354 if (need_seqretry(&rename_lock
, seq
)) {
358 done_seqretry(&rename_lock
, seq
);
360 prepend_char(&b
, '/');
361 return extract_string(&b
);
364 char *dentry_path_raw(const struct dentry
*dentry
, char *buf
, int buflen
)
366 DECLARE_BUFFER(b
, buf
, buflen
);
369 return __dentry_path(dentry
, &b
);
371 EXPORT_SYMBOL(dentry_path_raw
);
373 char *dentry_path(const struct dentry
*dentry
, char *buf
, int buflen
)
375 DECLARE_BUFFER(b
, buf
, buflen
);
377 if (unlikely(d_unlinked(dentry
)))
378 prepend(&b
, "//deleted", 10);
381 return __dentry_path(dentry
, &b
);
384 static void get_fs_root_and_pwd_rcu(struct fs_struct
*fs
, struct path
*root
,
390 seq
= read_seqcount_begin(&fs
->seq
);
393 } while (read_seqcount_retry(&fs
->seq
, seq
));
397 * NOTE! The user-level library version returns a
398 * character pointer. The kernel system call just
399 * returns the length of the buffer filled (which
400 * includes the ending '\0' character), or a negative
401 * error value. So libc would do something like
403 * char *getcwd(char * buf, size_t size)
407 * retval = sys_getcwd(buf, size);
414 SYSCALL_DEFINE2(getcwd
, char __user
*, buf
, unsigned long, size
)
417 struct path pwd
, root
;
418 char *page
= __getname();
424 get_fs_root_and_pwd_rcu(current
->fs
, &root
, &pwd
);
426 if (unlikely(d_unlinked(pwd
.dentry
))) {
431 DECLARE_BUFFER(b
, page
, PATH_MAX
);
434 if (unlikely(prepend_path(&pwd
, &root
, &b
) > 0))
435 prepend(&b
, "(unreachable)", 13);
438 len
= PATH_MAX
- b
.len
;
439 if (unlikely(len
> PATH_MAX
))
440 error
= -ENAMETOOLONG
;
441 else if (unlikely(len
> size
))
443 else if (copy_to_user(buf
, b
.buf
, len
))