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 static int prepend(char **buffer, int *buflen, const char *str, int namelen)
17 memcpy(*buffer, str, namelen);
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
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.
36 * Load acquire is needed to make sure that we see that terminating NUL.
38 static int prepend_name(char **buffer, int *buflen, const struct qstr *name)
40 const char *dname = smp_load_acquire(&name->name); /* ^^^ */
41 u32 dlen = READ_ONCE(name->len);
47 p = *buffer -= dlen + 1;
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
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.
75 static int prepend_path(const struct path *path,
76 const struct path *root,
77 char **buffer, int *buflen)
79 struct dentry *dentry;
80 struct vfsmount *vfsmnt;
83 unsigned seq, m_seq = 0;
89 read_seqbegin_or_lock(&mount_lock, &m_seq);
96 dentry = path->dentry;
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;
103 if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {
104 struct mount *parent = READ_ONCE(mnt->mnt_parent);
105 struct mnt_namespace *mnt_ns;
108 if (dentry != vfsmnt->mnt_root) {
116 dentry = READ_ONCE(mnt->mnt_mountpoint);
121 mnt_ns = READ_ONCE(mnt->mnt_ns);
122 /* open-coded is_mounted() to use local mnt_ns */
123 if (!IS_ERR_OR_NULL(mnt_ns) && !is_anon_ns(mnt_ns))
124 error = 1; // absolute root
126 error = 2; // detached or not attached yet
129 parent = dentry->d_parent;
131 error = prepend_name(&bptr, &blen, &dentry->d_name);
139 if (need_seqretry(&rename_lock, seq)) {
143 done_seqretry(&rename_lock, seq);
147 if (need_seqretry(&mount_lock, m_seq)) {
151 done_seqretry(&mount_lock, m_seq);
153 if (error >= 0 && bptr == *buffer) {
155 error = -ENAMETOOLONG;
165 * __d_path - return the path of a dentry
166 * @path: the dentry/vfsmount to report
167 * @root: root vfsmnt/dentry
168 * @buf: buffer to return value in
169 * @buflen: buffer length
171 * Convert a dentry into an ASCII path name.
173 * Returns a pointer into the buffer or an error code if the
176 * "buflen" should be positive.
178 * If the path is not reachable from the supplied root, return %NULL.
180 char *__d_path(const struct path *path,
181 const struct path *root,
182 char *buf, int buflen)
184 char *res = buf + buflen;
187 prepend(&res, &buflen, "\0", 1);
188 error = prepend_path(path, root, &res, &buflen);
191 return ERR_PTR(error);
197 char *d_absolute_path(const struct path *path,
198 char *buf, int buflen)
200 struct path root = {};
201 char *res = buf + buflen;
204 prepend(&res, &buflen, "\0", 1);
205 error = prepend_path(path, &root, &res, &buflen);
210 return ERR_PTR(error);
215 * same as __d_path but appends "(deleted)" for unlinked files.
217 static int path_with_deleted(const struct path *path,
218 const struct path *root,
219 char **buf, int *buflen)
221 prepend(buf, buflen, "\0", 1);
222 if (d_unlinked(path->dentry)) {
223 int error = prepend(buf, buflen, " (deleted)", 10);
228 return prepend_path(path, root, buf, buflen);
231 static int prepend_unreachable(char **buffer, int *buflen)
233 return prepend(buffer, buflen, "(unreachable)", 13);
236 static void get_fs_root_rcu(struct fs_struct *fs, struct path *root)
241 seq = read_seqcount_begin(&fs->seq);
243 } while (read_seqcount_retry(&fs->seq, seq));
247 * d_path - return the path of a dentry
248 * @path: path to report
249 * @buf: buffer to return value in
250 * @buflen: buffer length
252 * Convert a dentry into an ASCII path name. If the entry has been deleted
253 * the string " (deleted)" is appended. Note that this is ambiguous.
255 * Returns a pointer into the buffer or an error code if the path was
256 * too long. Note: Callers should use the returned pointer, not the passed
257 * in buffer, to use the name! The implementation often starts at an offset
258 * into the buffer, and may leave 0 bytes at the start.
260 * "buflen" should be positive.
262 char *d_path(const struct path *path, char *buf, int buflen)
264 char *res = buf + buflen;
269 * We have various synthetic filesystems that never get mounted. On
270 * these filesystems dentries are never used for lookup purposes, and
271 * thus don't need to be hashed. They also don't need a name until a
272 * user wants to identify the object in /proc/pid/fd/. The little hack
273 * below allows us to generate a name for these objects on demand:
275 * Some pseudo inodes are mountable. When they are mounted
276 * path->dentry == path->mnt->mnt_root. In that case don't call d_dname
277 * and instead have d_path return the mounted path.
279 if (path->dentry->d_op && path->dentry->d_op->d_dname &&
280 (!IS_ROOT(path->dentry) || path->dentry != path->mnt->mnt_root))
281 return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
284 get_fs_root_rcu(current->fs, &root);
285 error = path_with_deleted(path, &root, &res, &buflen);
289 res = ERR_PTR(error);
292 EXPORT_SYMBOL(d_path);
295 * Helper function for dentry_operations.d_dname() members
297 char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
298 const char *fmt, ...)
305 sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1;
308 if (sz > sizeof(temp) || sz > buflen)
309 return ERR_PTR(-ENAMETOOLONG);
311 buffer += buflen - sz;
312 return memcpy(buffer, temp, sz);
315 char *simple_dname(struct dentry *dentry, char *buffer, int buflen)
317 char *end = buffer + buflen;
318 /* these dentries are never renamed, so d_lock is not needed */
319 if (prepend(&end, &buflen, " (deleted)", 11) ||
320 prepend(&end, &buflen, dentry->d_name.name, dentry->d_name.len) ||
321 prepend(&end, &buflen, "/", 1))
322 end = ERR_PTR(-ENAMETOOLONG);
327 * Write full pathname from the root of the filesystem into the buffer.
329 static char *__dentry_path(struct dentry *d, char *buf, int buflen)
331 struct dentry *dentry;
344 prepend(&end, &len, "\0", 1);
348 read_seqbegin_or_lock(&rename_lock, &seq);
349 while (!IS_ROOT(dentry)) {
350 struct dentry *parent = dentry->d_parent;
353 error = prepend_name(&end, &len, &dentry->d_name);
362 if (need_seqretry(&rename_lock, seq)) {
366 done_seqretry(&rename_lock, seq);
371 return ERR_PTR(-ENAMETOOLONG);
374 char *dentry_path_raw(struct dentry *dentry, char *buf, int buflen)
376 return __dentry_path(dentry, buf, buflen);
378 EXPORT_SYMBOL(dentry_path_raw);
380 char *dentry_path(struct dentry *dentry, char *buf, int buflen)
385 if (d_unlinked(dentry)) {
387 if (prepend(&p, &buflen, "//deleted", 10) != 0)
391 retval = __dentry_path(dentry, buf, buflen);
392 if (!IS_ERR(retval) && p)
393 *p = '/'; /* restore '/' overriden with '\0' */
396 return ERR_PTR(-ENAMETOOLONG);
399 static void get_fs_root_and_pwd_rcu(struct fs_struct *fs, struct path *root,
405 seq = read_seqcount_begin(&fs->seq);
408 } while (read_seqcount_retry(&fs->seq, seq));
412 * NOTE! The user-level library version returns a
413 * character pointer. The kernel system call just
414 * returns the length of the buffer filled (which
415 * includes the ending '\0' character), or a negative
416 * error value. So libc would do something like
418 * char *getcwd(char * buf, size_t size)
422 * retval = sys_getcwd(buf, size);
429 SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
432 struct path pwd, root;
433 char *page = __getname();
439 get_fs_root_and_pwd_rcu(current->fs, &root, &pwd);
442 if (!d_unlinked(pwd.dentry)) {
444 char *cwd = page + PATH_MAX;
445 int buflen = PATH_MAX;
447 prepend(&cwd, &buflen, "\0", 1);
448 error = prepend_path(&pwd, &root, &cwd, &buflen);
454 /* Unreachable from current root */
456 error = prepend_unreachable(&cwd, &buflen);
462 len = PATH_MAX + page - cwd;
465 if (copy_to_user(buf, cwd, len))