blob: 80fdfad7c215c1f60693557625bcc3d852ad8c2f
1 | #include <linux/mount.h> |
2 | #include <linux/file.h> |
3 | #include <linux/fs.h> |
4 | #include <linux/proc_ns.h> |
5 | #include <linux/magic.h> |
6 | #include <linux/ktime.h> |
7 | #include <linux/seq_file.h> |
8 | #include <linux/user_namespace.h> |
9 | #include <linux/nsfs.h> |
10 | |
11 | static struct vfsmount *nsfs_mnt; |
12 | |
13 | static long ns_ioctl(struct file *filp, unsigned int ioctl, |
14 | unsigned long arg); |
15 | static const struct file_operations ns_file_operations = { |
16 | .llseek = no_llseek, |
17 | .unlocked_ioctl = ns_ioctl, |
18 | }; |
19 | |
20 | static char *ns_dname(struct dentry *dentry, char *buffer, int buflen) |
21 | { |
22 | struct inode *inode = d_inode(dentry); |
23 | const struct proc_ns_operations *ns_ops = dentry->d_fsdata; |
24 | |
25 | return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]", |
26 | ns_ops->name, inode->i_ino); |
27 | } |
28 | |
29 | static void ns_prune_dentry(struct dentry *dentry) |
30 | { |
31 | struct inode *inode = d_inode(dentry); |
32 | if (inode) { |
33 | struct ns_common *ns = inode->i_private; |
34 | atomic_long_set(&ns->stashed, 0); |
35 | } |
36 | } |
37 | |
38 | const struct dentry_operations ns_dentry_operations = |
39 | { |
40 | .d_prune = ns_prune_dentry, |
41 | .d_delete = always_delete_dentry, |
42 | .d_dname = ns_dname, |
43 | }; |
44 | |
45 | static void nsfs_evict(struct inode *inode) |
46 | { |
47 | struct ns_common *ns = inode->i_private; |
48 | clear_inode(inode); |
49 | ns->ops->put(ns); |
50 | } |
51 | |
52 | static void *__ns_get_path(struct path *path, struct ns_common *ns) |
53 | { |
54 | struct vfsmount *mnt = nsfs_mnt; |
55 | struct qstr qname = { .name = "", }; |
56 | struct dentry *dentry; |
57 | struct inode *inode; |
58 | unsigned long d; |
59 | |
60 | rcu_read_lock(); |
61 | d = atomic_long_read(&ns->stashed); |
62 | if (!d) |
63 | goto slow; |
64 | dentry = (struct dentry *)d; |
65 | if (!lockref_get_not_dead(&dentry->d_lockref)) |
66 | goto slow; |
67 | rcu_read_unlock(); |
68 | ns->ops->put(ns); |
69 | got_it: |
70 | path->mnt = mntget(mnt); |
71 | path->dentry = dentry; |
72 | return NULL; |
73 | slow: |
74 | rcu_read_unlock(); |
75 | inode = new_inode_pseudo(mnt->mnt_sb); |
76 | if (!inode) { |
77 | ns->ops->put(ns); |
78 | return ERR_PTR(-ENOMEM); |
79 | } |
80 | inode->i_ino = ns->inum; |
81 | inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); |
82 | inode->i_flags |= S_IMMUTABLE; |
83 | inode->i_mode = S_IFREG | S_IRUGO; |
84 | inode->i_fop = &ns_file_operations; |
85 | inode->i_private = ns; |
86 | |
87 | dentry = d_alloc_pseudo(mnt->mnt_sb, &qname); |
88 | if (!dentry) { |
89 | iput(inode); |
90 | return ERR_PTR(-ENOMEM); |
91 | } |
92 | d_instantiate(dentry, inode); |
93 | dentry->d_flags |= DCACHE_RCUACCESS; |
94 | dentry->d_fsdata = (void *)ns->ops; |
95 | d = atomic_long_cmpxchg(&ns->stashed, 0, (unsigned long)dentry); |
96 | if (d) { |
97 | d_delete(dentry); /* make sure ->d_prune() does nothing */ |
98 | dput(dentry); |
99 | cpu_relax(); |
100 | return ERR_PTR(-EAGAIN); |
101 | } |
102 | goto got_it; |
103 | } |
104 | |
105 | void *ns_get_path(struct path *path, struct task_struct *task, |
106 | const struct proc_ns_operations *ns_ops) |
107 | { |
108 | struct ns_common *ns; |
109 | void *ret; |
110 | |
111 | again: |
112 | ns = ns_ops->get(task); |
113 | if (!ns) |
114 | return ERR_PTR(-ENOENT); |
115 | |
116 | ret = __ns_get_path(path, ns); |
117 | if (IS_ERR(ret) && PTR_ERR(ret) == -EAGAIN) |
118 | goto again; |
119 | return ret; |
120 | } |
121 | |
122 | static int open_related_ns(struct ns_common *ns, |
123 | struct ns_common *(*get_ns)(struct ns_common *ns)) |
124 | { |
125 | struct path path = {}; |
126 | struct file *f; |
127 | void *err; |
128 | int fd; |
129 | |
130 | fd = get_unused_fd_flags(O_CLOEXEC); |
131 | if (fd < 0) |
132 | return fd; |
133 | |
134 | while (1) { |
135 | struct ns_common *relative; |
136 | |
137 | relative = get_ns(ns); |
138 | if (IS_ERR(relative)) { |
139 | put_unused_fd(fd); |
140 | return PTR_ERR(relative); |
141 | } |
142 | |
143 | err = __ns_get_path(&path, relative); |
144 | if (IS_ERR(err) && PTR_ERR(err) == -EAGAIN) |
145 | continue; |
146 | break; |
147 | } |
148 | if (IS_ERR(err)) { |
149 | put_unused_fd(fd); |
150 | return PTR_ERR(err); |
151 | } |
152 | |
153 | f = dentry_open(&path, O_RDONLY, current_cred()); |
154 | path_put(&path); |
155 | if (IS_ERR(f)) { |
156 | put_unused_fd(fd); |
157 | fd = PTR_ERR(f); |
158 | } else |
159 | fd_install(fd, f); |
160 | |
161 | return fd; |
162 | } |
163 | |
164 | static long ns_ioctl(struct file *filp, unsigned int ioctl, |
165 | unsigned long arg) |
166 | { |
167 | struct ns_common *ns = get_proc_ns(file_inode(filp)); |
168 | |
169 | switch (ioctl) { |
170 | case NS_GET_USERNS: |
171 | return open_related_ns(ns, ns_get_owner); |
172 | case NS_GET_PARENT: |
173 | if (!ns->ops->get_parent) |
174 | return -EINVAL; |
175 | return open_related_ns(ns, ns->ops->get_parent); |
176 | default: |
177 | return -ENOTTY; |
178 | } |
179 | } |
180 | |
181 | int ns_get_name(char *buf, size_t size, struct task_struct *task, |
182 | const struct proc_ns_operations *ns_ops) |
183 | { |
184 | struct ns_common *ns; |
185 | int res = -ENOENT; |
186 | ns = ns_ops->get(task); |
187 | if (ns) { |
188 | res = snprintf(buf, size, "%s:[%u]", ns_ops->name, ns->inum); |
189 | ns_ops->put(ns); |
190 | } |
191 | return res; |
192 | } |
193 | |
194 | struct file *proc_ns_fget(int fd) |
195 | { |
196 | struct file *file; |
197 | |
198 | file = fget(fd); |
199 | if (!file) |
200 | return ERR_PTR(-EBADF); |
201 | |
202 | if (file->f_op != &ns_file_operations) |
203 | goto out_invalid; |
204 | |
205 | return file; |
206 | |
207 | out_invalid: |
208 | fput(file); |
209 | return ERR_PTR(-EINVAL); |
210 | } |
211 | |
212 | static int nsfs_show_path(struct seq_file *seq, struct dentry *dentry) |
213 | { |
214 | struct inode *inode = d_inode(dentry); |
215 | const struct proc_ns_operations *ns_ops = dentry->d_fsdata; |
216 | |
217 | seq_printf(seq, "%s:[%lu]", ns_ops->name, inode->i_ino); |
218 | return 0; |
219 | } |
220 | |
221 | static const struct super_operations nsfs_ops = { |
222 | .statfs = simple_statfs, |
223 | .evict_inode = nsfs_evict, |
224 | .show_path = nsfs_show_path, |
225 | }; |
226 | static struct dentry *nsfs_mount(struct file_system_type *fs_type, |
227 | int flags, const char *dev_name, void *data) |
228 | { |
229 | return mount_pseudo(fs_type, "nsfs:", &nsfs_ops, |
230 | &ns_dentry_operations, NSFS_MAGIC); |
231 | } |
232 | static struct file_system_type nsfs = { |
233 | .name = "nsfs", |
234 | .mount = nsfs_mount, |
235 | .kill_sb = kill_anon_super, |
236 | }; |
237 | |
238 | void __init nsfs_init(void) |
239 | { |
240 | nsfs_mnt = kern_mount(&nsfs); |
241 | if (IS_ERR(nsfs_mnt)) |
242 | panic("can't set nsfs up\n"); |
243 | nsfs_mnt->mnt_sb->s_flags &= ~MS_NOUSER; |
244 | } |
245 |