1 /* 2 * linux/fs/proc/net.c 3 * 4 * Copyright (C) 2007 5 * 6 * Author: Eric Biederman <ebiederm@xmission.com> 7 * 8 * proc net directory handling functions 9 */ 10 11 #include <asm/uaccess.h> 12 13 #include <linux/errno.h> 14 #include <linux/time.h> 15 #include <linux/proc_fs.h> 16 #include <linux/stat.h> 17 #include <linux/init.h> 18 #include <linux/sched.h> 19 #include <linux/module.h> 20 #include <linux/bitops.h> 21 #include <linux/mount.h> 22 #include <linux/nsproxy.h> 23 #include <net/net_namespace.h> 24 #include <linux/seq_file.h> 25 26 #include "internal.h" 27 28 29 static struct net *get_proc_net(const struct inode *inode) 30 { 31 return maybe_get_net(PDE_NET(PDE(inode))); 32 } 33 34 int seq_open_net(struct inode *ino, struct file *f, 35 const struct seq_operations *ops, int size) 36 { 37 struct net *net; 38 struct seq_net_private *p; 39 40 BUG_ON(size < sizeof(*p)); 41 42 net = get_proc_net(ino); 43 if (net == NULL) 44 return -ENXIO; 45 46 p = __seq_open_private(f, ops, size); 47 if (p == NULL) { 48 put_net(net); 49 return -ENOMEM; 50 } 51 #ifdef CONFIG_NET_NS 52 p->net = net; 53 #endif 54 return 0; 55 } 56 EXPORT_SYMBOL_GPL(seq_open_net); 57 58 int single_open_net(struct inode *inode, struct file *file, 59 int (*show)(struct seq_file *, void *)) 60 { 61 int err; 62 struct net *net; 63 64 err = -ENXIO; 65 net = get_proc_net(inode); 66 if (net == NULL) 67 goto err_net; 68 69 err = single_open(file, show, net); 70 if (err < 0) 71 goto err_open; 72 73 return 0; 74 75 err_open: 76 put_net(net); 77 err_net: 78 return err; 79 } 80 EXPORT_SYMBOL_GPL(single_open_net); 81 82 int seq_release_net(struct inode *ino, struct file *f) 83 { 84 struct seq_file *seq; 85 86 seq = f->private_data; 87 88 put_net(seq_file_net(seq)); 89 seq_release_private(ino, f); 90 return 0; 91 } 92 EXPORT_SYMBOL_GPL(seq_release_net); 93 94 int single_release_net(struct inode *ino, struct file *f) 95 { 96 struct seq_file *seq = f->private_data; 97 put_net(seq->private); 98 return single_release(ino, f); 99 } 100 EXPORT_SYMBOL_GPL(single_release_net); 101 102 static struct net *get_proc_task_net(struct inode *dir) 103 { 104 struct task_struct *task; 105 struct nsproxy *ns; 106 struct net *net = NULL; 107 108 rcu_read_lock(); 109 task = pid_task(proc_pid(dir), PIDTYPE_PID); 110 if (task != NULL) { 111 ns = task_nsproxy(task); 112 if (ns != NULL) 113 net = get_net(ns->net_ns); 114 } 115 rcu_read_unlock(); 116 117 return net; 118 } 119 120 static struct dentry *proc_tgid_net_lookup(struct inode *dir, 121 struct dentry *dentry, struct nameidata *nd) 122 { 123 struct dentry *de; 124 struct net *net; 125 126 de = ERR_PTR(-ENOENT); 127 net = get_proc_task_net(dir); 128 if (net != NULL) { 129 de = proc_lookup_de(net->proc_net, dir, dentry); 130 put_net(net); 131 } 132 return de; 133 } 134 135 static int proc_tgid_net_getattr(struct vfsmount *mnt, struct dentry *dentry, 136 struct kstat *stat) 137 { 138 struct inode *inode = dentry->d_inode; 139 struct net *net; 140 141 net = get_proc_task_net(inode); 142 143 generic_fillattr(inode, stat); 144 145 if (net != NULL) { 146 stat->nlink = net->proc_net->nlink; 147 put_net(net); 148 } 149 150 return 0; 151 } 152 153 const struct inode_operations proc_net_inode_operations = { 154 .lookup = proc_tgid_net_lookup, 155 .getattr = proc_tgid_net_getattr, 156 }; 157 158 static int proc_tgid_net_readdir(struct file *filp, void *dirent, 159 filldir_t filldir) 160 { 161 int ret; 162 struct net *net; 163 164 ret = -EINVAL; 165 net = get_proc_task_net(filp->f_path.dentry->d_inode); 166 if (net != NULL) { 167 ret = proc_readdir_de(net->proc_net, filp, dirent, filldir); 168 put_net(net); 169 } 170 return ret; 171 } 172 173 const struct file_operations proc_net_operations = { 174 .llseek = generic_file_llseek, 175 .read = generic_read_dir, 176 .readdir = proc_tgid_net_readdir, 177 }; 178 179 180 struct proc_dir_entry *proc_net_fops_create(struct net *net, 181 const char *name, mode_t mode, const struct file_operations *fops) 182 { 183 return proc_create(name, mode, net->proc_net, fops); 184 } 185 EXPORT_SYMBOL_GPL(proc_net_fops_create); 186 187 void proc_net_remove(struct net *net, const char *name) 188 { 189 remove_proc_entry(name, net->proc_net); 190 } 191 EXPORT_SYMBOL_GPL(proc_net_remove); 192 193 static __net_init int proc_net_ns_init(struct net *net) 194 { 195 struct proc_dir_entry *netd, *net_statd; 196 int err; 197 198 err = -ENOMEM; 199 netd = kzalloc(sizeof(*netd), GFP_KERNEL); 200 if (!netd) 201 goto out; 202 203 netd->data = net; 204 netd->nlink = 2; 205 netd->name = "net"; 206 netd->namelen = 3; 207 netd->parent = &proc_root; 208 209 err = -EEXIST; 210 net_statd = proc_net_mkdir(net, "stat", netd); 211 if (!net_statd) 212 goto free_net; 213 214 net->proc_net = netd; 215 net->proc_net_stat = net_statd; 216 return 0; 217 218 free_net: 219 kfree(netd); 220 out: 221 return err; 222 } 223 224 static __net_exit void proc_net_ns_exit(struct net *net) 225 { 226 remove_proc_entry("stat", net->proc_net); 227 kfree(net->proc_net); 228 } 229 230 static struct pernet_operations __net_initdata proc_net_ns_ops = { 231 .init = proc_net_ns_init, 232 .exit = proc_net_ns_exit, 233 }; 234 235 int __init proc_net_init(void) 236 { 237 proc_symlink("net", NULL, "self/net"); 238 239 return register_pernet_subsys(&proc_net_ns_ops); 240 } 241