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