1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/export.h>
3 #include <linux/sched/signal.h>
4 #include <linux/sched/task.h>
5 #include <linux/fs.h>
6 #include <linux/path.h>
7 #include <linux/slab.h>
8 #include <linux/fs_struct.h>
9 #include <linux/init_task.h>
10 #include "internal.h"
11
12 /*
13 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.
14 * It can block.
15 */
set_fs_root(struct fs_struct * fs,const struct path * path)16 void set_fs_root(struct fs_struct *fs, const struct path *path)
17 {
18 struct path old_root;
19
20 path_get(path);
21 write_seqlock(&fs->seq);
22 old_root = fs->root;
23 fs->root = *path;
24 write_sequnlock(&fs->seq);
25 if (old_root.dentry)
26 path_put(&old_root);
27 }
28
29 /*
30 * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values.
31 * It can block.
32 */
set_fs_pwd(struct fs_struct * fs,const struct path * path)33 void set_fs_pwd(struct fs_struct *fs, const struct path *path)
34 {
35 struct path old_pwd;
36
37 path_get(path);
38 write_seqlock(&fs->seq);
39 old_pwd = fs->pwd;
40 fs->pwd = *path;
41 write_sequnlock(&fs->seq);
42
43 if (old_pwd.dentry)
44 path_put(&old_pwd);
45 }
46
replace_path(struct path * p,const struct path * old,const struct path * new)47 static inline int replace_path(struct path *p, const struct path *old, const struct path *new)
48 {
49 if (likely(p->dentry != old->dentry || p->mnt != old->mnt))
50 return 0;
51 *p = *new;
52 return 1;
53 }
54
chroot_fs_refs(const struct path * old_root,const struct path * new_root)55 void chroot_fs_refs(const struct path *old_root, const struct path *new_root)
56 {
57 struct task_struct *g, *p;
58 struct fs_struct *fs;
59 int count = 0;
60
61 read_lock(&tasklist_lock);
62 for_each_process_thread(g, p) {
63 task_lock(p);
64 fs = p->fs;
65 if (fs) {
66 int hits = 0;
67 write_seqlock(&fs->seq);
68 hits += replace_path(&fs->root, old_root, new_root);
69 hits += replace_path(&fs->pwd, old_root, new_root);
70 while (hits--) {
71 count++;
72 path_get(new_root);
73 }
74 write_sequnlock(&fs->seq);
75 }
76 task_unlock(p);
77 }
78 read_unlock(&tasklist_lock);
79 while (count--)
80 path_put(old_root);
81 }
82
free_fs_struct(struct fs_struct * fs)83 void free_fs_struct(struct fs_struct *fs)
84 {
85 path_put(&fs->root);
86 path_put(&fs->pwd);
87 kmem_cache_free(fs_cachep, fs);
88 }
89
exit_fs(struct task_struct * tsk)90 void exit_fs(struct task_struct *tsk)
91 {
92 struct fs_struct *fs = tsk->fs;
93
94 if (fs) {
95 int kill;
96 task_lock(tsk);
97 read_seqlock_excl(&fs->seq);
98 tsk->fs = NULL;
99 kill = !--fs->users;
100 read_sequnlock_excl(&fs->seq);
101 task_unlock(tsk);
102 if (kill)
103 free_fs_struct(fs);
104 }
105 }
106
copy_fs_struct(struct fs_struct * old)107 struct fs_struct *copy_fs_struct(struct fs_struct *old)
108 {
109 struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
110 /* We don't need to lock fs - think why ;-) */
111 if (fs) {
112 fs->users = 1;
113 fs->in_exec = 0;
114 seqlock_init(&fs->seq);
115 fs->umask = old->umask;
116
117 read_seqlock_excl(&old->seq);
118 fs->root = old->root;
119 path_get(&fs->root);
120 fs->pwd = old->pwd;
121 path_get(&fs->pwd);
122 read_sequnlock_excl(&old->seq);
123 }
124 return fs;
125 }
126
unshare_fs_struct(void)127 int unshare_fs_struct(void)
128 {
129 struct fs_struct *fs = current->fs;
130 struct fs_struct *new_fs = copy_fs_struct(fs);
131 int kill;
132
133 if (!new_fs)
134 return -ENOMEM;
135
136 task_lock(current);
137 read_seqlock_excl(&fs->seq);
138 kill = !--fs->users;
139 current->fs = new_fs;
140 read_sequnlock_excl(&fs->seq);
141 task_unlock(current);
142
143 if (kill)
144 free_fs_struct(fs);
145
146 return 0;
147 }
148 EXPORT_SYMBOL_GPL(unshare_fs_struct);
149
150 /* to be mentioned only in INIT_TASK */
151 struct fs_struct init_fs = {
152 .users = 1,
153 .seq = __SEQLOCK_UNLOCKED(init_fs.seq),
154 .umask = 0022,
155 };
156