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 */
14void 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 */
33void 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
49static 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
57void 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
87void 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
94void 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
111struct 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
132int 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}
153EXPORT_SYMBOL_GPL(unshare_fs_struct);
154
155int current_umask(void)
156{
157 return current->fs->umask;
158}
159EXPORT_SYMBOL(current_umask);
160
161/* to be mentioned only in INIT_TASK */
162struct 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