1 #include <linux/proc_fs.h>
2 #include <linux/nsproxy.h>
3 #include <linux/sched.h>
4 #include <linux/ptrace.h>
5 #include <linux/fs_struct.h>
6 #include <linux/mount.h>
7 #include <linux/path.h>
8 #include <linux/namei.h>
9 #include <linux/file.h>
10 #include <linux/utsname.h>
11 #include <net/net_namespace.h>
12 #include <linux/ipc_namespace.h>
13 #include <linux/pid_namespace.h>
14 #include <linux/user_namespace.h>
18 static const struct proc_ns_operations
*ns_entries
[] = {
37 static const struct file_operations ns_file_operations
= {
41 static const struct inode_operations ns_inode_operations
= {
42 .setattr
= proc_setattr
,
45 static int ns_delete_dentry(const struct dentry
*dentry
)
47 /* Don't cache namespace inodes when not in use */
51 static char *ns_dname(struct dentry
*dentry
, char *buffer
, int buflen
)
53 struct inode
*inode
= dentry
->d_inode
;
54 const struct proc_ns_operations
*ns_ops
= PROC_I(inode
)->ns
.ns_ops
;
56 return dynamic_dname(dentry
, buffer
, buflen
, "%s:[%lu]",
57 ns_ops
->name
, inode
->i_ino
);
60 const struct dentry_operations ns_dentry_operations
=
62 .d_delete
= ns_delete_dentry
,
66 static struct dentry
*proc_ns_get_dentry(struct super_block
*sb
,
67 struct task_struct
*task
, const struct proc_ns_operations
*ns_ops
)
69 struct dentry
*dentry
, *result
;
71 struct proc_inode
*ei
;
72 struct qstr qname
= { .name
= "", };
75 ns
= ns_ops
->get(task
);
77 return ERR_PTR(-ENOENT
);
79 dentry
= d_alloc_pseudo(sb
, &qname
);
82 return ERR_PTR(-ENOMEM
);
85 inode
= iget_locked(sb
, ns_ops
->inum(ns
));
89 return ERR_PTR(-ENOMEM
);
93 if (inode
->i_state
& I_NEW
) {
94 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
95 inode
->i_op
= &ns_inode_operations
;
96 inode
->i_mode
= S_IFREG
| S_IRUGO
;
97 inode
->i_fop
= &ns_file_operations
;
98 ei
->ns
.ns_ops
= ns_ops
;
100 unlock_new_inode(inode
);
105 d_set_d_op(dentry
, &ns_dentry_operations
);
106 result
= d_instantiate_unique(dentry
, inode
);
115 static void *proc_ns_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
117 struct inode
*inode
= dentry
->d_inode
;
118 struct super_block
*sb
= inode
->i_sb
;
119 struct proc_inode
*ei
= PROC_I(inode
);
120 struct task_struct
*task
;
122 void *error
= ERR_PTR(-EACCES
);
124 task
= get_proc_task(inode
);
128 if (!ptrace_may_access(task
, PTRACE_MODE_READ
))
131 ns_path
.dentry
= proc_ns_get_dentry(sb
, task
, ei
->ns
.ns_ops
);
132 if (IS_ERR(ns_path
.dentry
)) {
133 error
= ERR_CAST(ns_path
.dentry
);
137 ns_path
.mnt
= mntget(nd
->path
.mnt
);
138 nd_jump_link(nd
, &ns_path
);
142 put_task_struct(task
);
147 static int proc_ns_readlink(struct dentry
*dentry
, char __user
*buffer
, int buflen
)
149 struct inode
*inode
= dentry
->d_inode
;
150 struct proc_inode
*ei
= PROC_I(inode
);
151 const struct proc_ns_operations
*ns_ops
= ei
->ns
.ns_ops
;
152 struct task_struct
*task
;
157 task
= get_proc_task(inode
);
161 if (!ptrace_may_access(task
, PTRACE_MODE_READ
))
165 ns
= ns_ops
->get(task
);
169 snprintf(name
, sizeof(name
), "%s:[%u]", ns_ops
->name
, ns_ops
->inum(ns
));
174 if (copy_to_user(buffer
, name
, len
))
179 put_task_struct(task
);
184 static const struct inode_operations proc_ns_link_inode_operations
= {
185 .readlink
= proc_ns_readlink
,
186 .follow_link
= proc_ns_follow_link
,
187 .setattr
= proc_setattr
,
190 static struct dentry
*proc_ns_instantiate(struct inode
*dir
,
191 struct dentry
*dentry
, struct task_struct
*task
, const void *ptr
)
193 const struct proc_ns_operations
*ns_ops
= ptr
;
195 struct proc_inode
*ei
;
196 struct dentry
*error
= ERR_PTR(-ENOENT
);
198 inode
= proc_pid_make_inode(dir
->i_sb
, task
);
203 inode
->i_mode
= S_IFLNK
|S_IRWXUGO
;
204 inode
->i_op
= &proc_ns_link_inode_operations
;
205 ei
->ns
.ns_ops
= ns_ops
;
207 d_set_d_op(dentry
, &pid_dentry_operations
);
208 d_add(dentry
, inode
);
209 /* Close the race of the process dying before we return the dentry */
210 if (pid_revalidate(dentry
, 0))
216 static int proc_ns_dir_readdir(struct file
*file
, struct dir_context
*ctx
)
218 struct task_struct
*task
= get_proc_task(file_inode(file
));
219 const struct proc_ns_operations
**entry
, **last
;
224 if (!dir_emit_dots(file
, ctx
))
226 if (ctx
->pos
>= 2 + ARRAY_SIZE(ns_entries
))
228 entry
= ns_entries
+ (ctx
->pos
- 2);
229 last
= &ns_entries
[ARRAY_SIZE(ns_entries
) - 1];
230 while (entry
<= last
) {
231 const struct proc_ns_operations
*ops
= *entry
;
232 if (!proc_fill_cache(file
, ctx
, ops
->name
, strlen(ops
->name
),
233 proc_ns_instantiate
, task
, ops
))
239 put_task_struct(task
);
243 const struct file_operations proc_ns_dir_operations
= {
244 .read
= generic_read_dir
,
245 .iterate
= proc_ns_dir_readdir
,
248 static struct dentry
*proc_ns_dir_lookup(struct inode
*dir
,
249 struct dentry
*dentry
, unsigned int flags
)
251 struct dentry
*error
;
252 struct task_struct
*task
= get_proc_task(dir
);
253 const struct proc_ns_operations
**entry
, **last
;
254 unsigned int len
= dentry
->d_name
.len
;
256 error
= ERR_PTR(-ENOENT
);
261 last
= &ns_entries
[ARRAY_SIZE(ns_entries
)];
262 for (entry
= ns_entries
; entry
< last
; entry
++) {
263 if (strlen((*entry
)->name
) != len
)
265 if (!memcmp(dentry
->d_name
.name
, (*entry
)->name
, len
))
271 error
= proc_ns_instantiate(dir
, dentry
, task
, *entry
);
273 put_task_struct(task
);
278 const struct inode_operations proc_ns_dir_inode_operations
= {
279 .lookup
= proc_ns_dir_lookup
,
280 .getattr
= pid_getattr
,
281 .setattr
= proc_setattr
,
284 struct file
*proc_ns_fget(int fd
)
290 return ERR_PTR(-EBADF
);
292 if (file
->f_op
!= &ns_file_operations
)
299 return ERR_PTR(-EINVAL
);
302 struct proc_ns
*get_proc_ns(struct inode
*inode
)
304 return &PROC_I(inode
)->ns
;
307 bool proc_ns_inode(struct inode
*inode
)
309 return inode
->i_fop
== &ns_file_operations
;