| #include <linux/proc_fs.h> |
| #include <linux/nsproxy.h> |
| #include <linux/sched.h> |
| #include <linux/ptrace.h> |
| #include <linux/fs_struct.h> |
| #include <linux/mount.h> |
| #include <linux/path.h> |
| #include <linux/namei.h> |
| #include <linux/file.h> |
| #include <linux/utsname.h> |
| #include <net/net_namespace.h> |
| #include <linux/ipc_namespace.h> |
| #include <linux/pid_namespace.h> |
| #include "internal.h" |
| |
| |
| static const struct proc_ns_operations *ns_entries[] = { |
| #ifdef CONFIG_NET_NS |
| &netns_operations, |
| #endif |
| #ifdef CONFIG_UTS_NS |
| &utsns_operations, |
| #endif |
| #ifdef CONFIG_IPC_NS |
| &ipcns_operations, |
| #endif |
| #ifdef CONFIG_PID_NS |
| &pidns_operations, |
| #endif |
| &mntns_operations, |
| }; |
| |
| static const struct file_operations ns_file_operations = { |
| .llseek = no_llseek, |
| }; |
| |
| static const struct inode_operations ns_inode_operations = { |
| .setattr = proc_setattr, |
| }; |
| |
| static int ns_delete_dentry(const struct dentry *dentry) |
| { |
| /* Don't cache namespace inodes when not in use */ |
| return 1; |
| } |
| |
| static char *ns_dname(struct dentry *dentry, char *buffer, int buflen) |
| { |
| struct inode *inode = dentry->d_inode; |
| const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops; |
| |
| return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]", |
| ns_ops->name, inode->i_ino); |
| } |
| |
| const struct dentry_operations ns_dentry_operations = |
| { |
| .d_delete = ns_delete_dentry, |
| .d_dname = ns_dname, |
| }; |
| |
| static struct dentry *proc_ns_get_dentry(struct super_block *sb, |
| struct task_struct *task, const struct proc_ns_operations *ns_ops) |
| { |
| struct dentry *dentry, *result; |
| struct inode *inode; |
| struct proc_inode *ei; |
| struct qstr qname = { .name = "", }; |
| void *ns; |
| |
| ns = ns_ops->get(task); |
| if (!ns) |
| return ERR_PTR(-ENOENT); |
| |
| dentry = d_alloc_pseudo(sb, &qname); |
| if (!dentry) { |
| ns_ops->put(ns); |
| return ERR_PTR(-ENOMEM); |
| } |
| |
| inode = iget_locked(sb, ns_ops->inum(ns)); |
| if (!inode) { |
| dput(dentry); |
| ns_ops->put(ns); |
| return ERR_PTR(-ENOMEM); |
| } |
| |
| ei = PROC_I(inode); |
| if (inode->i_state & I_NEW) { |
| inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; |
| inode->i_op = &ns_inode_operations; |
| inode->i_mode = S_IFREG | S_IRUGO; |
| inode->i_fop = &ns_file_operations; |
| ei->ns_ops = ns_ops; |
| ei->ns = ns; |
| unlock_new_inode(inode); |
| } else { |
| ns_ops->put(ns); |
| } |
| |
| d_set_d_op(dentry, &ns_dentry_operations); |
| result = d_instantiate_unique(dentry, inode); |
| if (result) { |
| dput(dentry); |
| dentry = result; |
| } |
| |
| return dentry; |
| } |
| |
| static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd) |
| { |
| struct inode *inode = dentry->d_inode; |
| struct super_block *sb = inode->i_sb; |
| struct proc_inode *ei = PROC_I(inode); |
| struct task_struct *task; |
| struct dentry *ns_dentry; |
| void *error = ERR_PTR(-EACCES); |
| |
| task = get_proc_task(inode); |
| if (!task) |
| goto out; |
| |
| if (!ptrace_may_access(task, PTRACE_MODE_READ)) |
| goto out_put_task; |
| |
| ns_dentry = proc_ns_get_dentry(sb, task, ei->ns_ops); |
| if (IS_ERR(ns_dentry)) { |
| error = ERR_CAST(ns_dentry); |
| goto out_put_task; |
| } |
| |
| dput(nd->path.dentry); |
| nd->path.dentry = ns_dentry; |
| error = NULL; |
| |
| out_put_task: |
| put_task_struct(task); |
| out: |
| return error; |
| } |
| |
| static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen) |
| { |
| struct inode *inode = dentry->d_inode; |
| struct proc_inode *ei = PROC_I(inode); |
| const struct proc_ns_operations *ns_ops = ei->ns_ops; |
| struct task_struct *task; |
| void *ns; |
| char name[50]; |
| int len = -EACCES; |
| |
| task = get_proc_task(inode); |
| if (!task) |
| goto out; |
| |
| if (!ptrace_may_access(task, PTRACE_MODE_READ)) |
| goto out_put_task; |
| |
| len = -ENOENT; |
| ns = ns_ops->get(task); |
| if (!ns) |
| goto out_put_task; |
| |
| snprintf(name, sizeof(name), "%s:[%u]", ns_ops->name, ns_ops->inum(ns)); |
| len = strlen(name); |
| |
| if (len > buflen) |
| len = buflen; |
| if (copy_to_user(buffer, name, len)) |
| len = -EFAULT; |
| |
| ns_ops->put(ns); |
| out_put_task: |
| put_task_struct(task); |
| out: |
| return len; |
| } |
| |
| static const struct inode_operations proc_ns_link_inode_operations = { |
| .readlink = proc_ns_readlink, |
| .follow_link = proc_ns_follow_link, |
| .setattr = proc_setattr, |
| }; |
| |
| static struct dentry *proc_ns_instantiate(struct inode *dir, |
| struct dentry *dentry, struct task_struct *task, const void *ptr) |
| { |
| const struct proc_ns_operations *ns_ops = ptr; |
| struct inode *inode; |
| struct proc_inode *ei; |
| struct dentry *error = ERR_PTR(-ENOENT); |
| |
| inode = proc_pid_make_inode(dir->i_sb, task); |
| if (!inode) |
| goto out; |
| |
| ei = PROC_I(inode); |
| inode->i_mode = S_IFLNK|S_IRWXUGO; |
| inode->i_op = &proc_ns_link_inode_operations; |
| ei->ns_ops = ns_ops; |
| |
| d_set_d_op(dentry, &pid_dentry_operations); |
| d_add(dentry, inode); |
| /* Close the race of the process dying before we return the dentry */ |
| if (pid_revalidate(dentry, 0)) |
| error = NULL; |
| out: |
| return error; |
| } |
| |
| static int proc_ns_fill_cache(struct file *filp, void *dirent, |
| filldir_t filldir, struct task_struct *task, |
| const struct proc_ns_operations *ops) |
| { |
| return proc_fill_cache(filp, dirent, filldir, |
| ops->name, strlen(ops->name), |
| proc_ns_instantiate, task, ops); |
| } |
| |
| static int proc_ns_dir_readdir(struct file *filp, void *dirent, |
| filldir_t filldir) |
| { |
| int i; |
| struct dentry *dentry = filp->f_path.dentry; |
| struct inode *inode = dentry->d_inode; |
| struct task_struct *task = get_proc_task(inode); |
| const struct proc_ns_operations **entry, **last; |
| ino_t ino; |
| int ret; |
| |
| ret = -ENOENT; |
| if (!task) |
| goto out_no_task; |
| |
| ret = 0; |
| i = filp->f_pos; |
| switch (i) { |
| case 0: |
| ino = inode->i_ino; |
| if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) |
| goto out; |
| i++; |
| filp->f_pos++; |
| /* fall through */ |
| case 1: |
| ino = parent_ino(dentry); |
| if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) |
| goto out; |
| i++; |
| filp->f_pos++; |
| /* fall through */ |
| default: |
| i -= 2; |
| if (i >= ARRAY_SIZE(ns_entries)) { |
| ret = 1; |
| goto out; |
| } |
| entry = ns_entries + i; |
| last = &ns_entries[ARRAY_SIZE(ns_entries) - 1]; |
| while (entry <= last) { |
| if (proc_ns_fill_cache(filp, dirent, filldir, |
| task, *entry) < 0) |
| goto out; |
| filp->f_pos++; |
| entry++; |
| } |
| } |
| |
| ret = 1; |
| out: |
| put_task_struct(task); |
| out_no_task: |
| return ret; |
| } |
| |
| const struct file_operations proc_ns_dir_operations = { |
| .read = generic_read_dir, |
| .readdir = proc_ns_dir_readdir, |
| }; |
| |
| static struct dentry *proc_ns_dir_lookup(struct inode *dir, |
| struct dentry *dentry, struct nameidata *nd) |
| { |
| struct dentry *error; |
| struct task_struct *task = get_proc_task(dir); |
| const struct proc_ns_operations **entry, **last; |
| unsigned int len = dentry->d_name.len; |
| |
| error = ERR_PTR(-ENOENT); |
| |
| if (!task) |
| goto out_no_task; |
| |
| last = &ns_entries[ARRAY_SIZE(ns_entries)]; |
| for (entry = ns_entries; entry < last; entry++) { |
| if (strlen((*entry)->name) != len) |
| continue; |
| if (!memcmp(dentry->d_name.name, (*entry)->name, len)) |
| break; |
| } |
| if (entry == last) |
| goto out; |
| |
| error = proc_ns_instantiate(dir, dentry, task, *entry); |
| out: |
| put_task_struct(task); |
| out_no_task: |
| return error; |
| } |
| |
| const struct inode_operations proc_ns_dir_inode_operations = { |
| .lookup = proc_ns_dir_lookup, |
| .getattr = pid_getattr, |
| .setattr = proc_setattr, |
| }; |
| |
| struct file *proc_ns_fget(int fd) |
| { |
| struct file *file; |
| |
| file = fget(fd); |
| if (!file) |
| return ERR_PTR(-EBADF); |
| |
| if (file->f_op != &ns_file_operations) |
| goto out_invalid; |
| |
| return file; |
| |
| out_invalid: |
| fput(file); |
| return ERR_PTR(-EINVAL); |
| } |
| |
| bool proc_ns_inode(struct inode *inode) |
| { |
| return inode->i_fop == &ns_file_operations; |
| } |