1 /* 2 * atalk_proc.c - proc support for Appletalk 3 * 4 * Copyright(c) Arnaldo Carvalho de Melo <acme@conectiva.com.br> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation, version 2. 9 */ 10 11 #include <linux/init.h> 12 #include <linux/proc_fs.h> 13 #include <linux/seq_file.h> 14 #include <net/net_namespace.h> 15 #include <net/sock.h> 16 #include <linux/atalk.h> 17 #include <linux/export.h> 18 19 20 static __inline__ struct atalk_iface *atalk_get_interface_idx(loff_t pos) 21 { 22 struct atalk_iface *i; 23 24 for (i = atalk_interfaces; pos && i; i = i->next) 25 --pos; 26 27 return i; 28 } 29 30 static void *atalk_seq_interface_start(struct seq_file *seq, loff_t *pos) 31 __acquires(atalk_interfaces_lock) 32 { 33 loff_t l = *pos; 34 35 read_lock_bh(&atalk_interfaces_lock); 36 return l ? atalk_get_interface_idx(--l) : SEQ_START_TOKEN; 37 } 38 39 static void *atalk_seq_interface_next(struct seq_file *seq, void *v, loff_t *pos) 40 { 41 struct atalk_iface *i; 42 43 ++*pos; 44 if (v == SEQ_START_TOKEN) { 45 i = NULL; 46 if (atalk_interfaces) 47 i = atalk_interfaces; 48 goto out; 49 } 50 i = v; 51 i = i->next; 52 out: 53 return i; 54 } 55 56 static void atalk_seq_interface_stop(struct seq_file *seq, void *v) 57 __releases(atalk_interfaces_lock) 58 { 59 read_unlock_bh(&atalk_interfaces_lock); 60 } 61 62 static int atalk_seq_interface_show(struct seq_file *seq, void *v) 63 { 64 struct atalk_iface *iface; 65 66 if (v == SEQ_START_TOKEN) { 67 seq_puts(seq, "Interface Address Networks " 68 "Status\n"); 69 goto out; 70 } 71 72 iface = v; 73 seq_printf(seq, "%-16s %04X:%02X %04X-%04X %d\n", 74 iface->dev->name, ntohs(iface->address.s_net), 75 iface->address.s_node, ntohs(iface->nets.nr_firstnet), 76 ntohs(iface->nets.nr_lastnet), iface->status); 77 out: 78 return 0; 79 } 80 81 static __inline__ struct atalk_route *atalk_get_route_idx(loff_t pos) 82 { 83 struct atalk_route *r; 84 85 for (r = atalk_routes; pos && r; r = r->next) 86 --pos; 87 88 return r; 89 } 90 91 static void *atalk_seq_route_start(struct seq_file *seq, loff_t *pos) 92 __acquires(atalk_routes_lock) 93 { 94 loff_t l = *pos; 95 96 read_lock_bh(&atalk_routes_lock); 97 return l ? atalk_get_route_idx(--l) : SEQ_START_TOKEN; 98 } 99 100 static void *atalk_seq_route_next(struct seq_file *seq, void *v, loff_t *pos) 101 { 102 struct atalk_route *r; 103 104 ++*pos; 105 if (v == SEQ_START_TOKEN) { 106 r = NULL; 107 if (atalk_routes) 108 r = atalk_routes; 109 goto out; 110 } 111 r = v; 112 r = r->next; 113 out: 114 return r; 115 } 116 117 static void atalk_seq_route_stop(struct seq_file *seq, void *v) 118 __releases(atalk_routes_lock) 119 { 120 read_unlock_bh(&atalk_routes_lock); 121 } 122 123 static int atalk_seq_route_show(struct seq_file *seq, void *v) 124 { 125 struct atalk_route *rt; 126 127 if (v == SEQ_START_TOKEN) { 128 seq_puts(seq, "Target Router Flags Dev\n"); 129 goto out; 130 } 131 132 if (atrtr_default.dev) { 133 rt = &atrtr_default; 134 seq_printf(seq, "Default %04X:%02X %-4d %s\n", 135 ntohs(rt->gateway.s_net), rt->gateway.s_node, 136 rt->flags, rt->dev->name); 137 } 138 139 rt = v; 140 seq_printf(seq, "%04X:%02X %04X:%02X %-4d %s\n", 141 ntohs(rt->target.s_net), rt->target.s_node, 142 ntohs(rt->gateway.s_net), rt->gateway.s_node, 143 rt->flags, rt->dev->name); 144 out: 145 return 0; 146 } 147 148 static void *atalk_seq_socket_start(struct seq_file *seq, loff_t *pos) 149 __acquires(atalk_sockets_lock) 150 { 151 read_lock_bh(&atalk_sockets_lock); 152 return seq_hlist_start_head(&atalk_sockets, *pos); 153 } 154 155 static void *atalk_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos) 156 { 157 return seq_hlist_next(v, &atalk_sockets, pos); 158 } 159 160 static void atalk_seq_socket_stop(struct seq_file *seq, void *v) 161 __releases(atalk_sockets_lock) 162 { 163 read_unlock_bh(&atalk_sockets_lock); 164 } 165 166 static int atalk_seq_socket_show(struct seq_file *seq, void *v) 167 { 168 struct sock *s; 169 struct atalk_sock *at; 170 171 if (v == SEQ_START_TOKEN) { 172 seq_printf(seq, "Type Local_addr Remote_addr Tx_queue " 173 "Rx_queue St UID\n"); 174 goto out; 175 } 176 177 s = sk_entry(v); 178 at = at_sk(s); 179 180 seq_printf(seq, "%02X %04X:%02X:%02X %04X:%02X:%02X %08X:%08X " 181 "%02X %u\n", 182 s->sk_type, ntohs(at->src_net), at->src_node, at->src_port, 183 ntohs(at->dest_net), at->dest_node, at->dest_port, 184 sk_wmem_alloc_get(s), 185 sk_rmem_alloc_get(s), 186 s->sk_state, 187 from_kuid_munged(seq_user_ns(seq), sock_i_uid(s))); 188 out: 189 return 0; 190 } 191 192 static const struct seq_operations atalk_seq_interface_ops = { 193 .start = atalk_seq_interface_start, 194 .next = atalk_seq_interface_next, 195 .stop = atalk_seq_interface_stop, 196 .show = atalk_seq_interface_show, 197 }; 198 199 static const struct seq_operations atalk_seq_route_ops = { 200 .start = atalk_seq_route_start, 201 .next = atalk_seq_route_next, 202 .stop = atalk_seq_route_stop, 203 .show = atalk_seq_route_show, 204 }; 205 206 static const struct seq_operations atalk_seq_socket_ops = { 207 .start = atalk_seq_socket_start, 208 .next = atalk_seq_socket_next, 209 .stop = atalk_seq_socket_stop, 210 .show = atalk_seq_socket_show, 211 }; 212 213 static int atalk_seq_interface_open(struct inode *inode, struct file *file) 214 { 215 return seq_open(file, &atalk_seq_interface_ops); 216 } 217 218 static int atalk_seq_route_open(struct inode *inode, struct file *file) 219 { 220 return seq_open(file, &atalk_seq_route_ops); 221 } 222 223 static int atalk_seq_socket_open(struct inode *inode, struct file *file) 224 { 225 return seq_open(file, &atalk_seq_socket_ops); 226 } 227 228 static const struct file_operations atalk_seq_interface_fops = { 229 .owner = THIS_MODULE, 230 .open = atalk_seq_interface_open, 231 .read = seq_read, 232 .llseek = seq_lseek, 233 .release = seq_release, 234 }; 235 236 static const struct file_operations atalk_seq_route_fops = { 237 .owner = THIS_MODULE, 238 .open = atalk_seq_route_open, 239 .read = seq_read, 240 .llseek = seq_lseek, 241 .release = seq_release, 242 }; 243 244 static const struct file_operations atalk_seq_socket_fops = { 245 .owner = THIS_MODULE, 246 .open = atalk_seq_socket_open, 247 .read = seq_read, 248 .llseek = seq_lseek, 249 .release = seq_release, 250 }; 251 252 static struct proc_dir_entry *atalk_proc_dir; 253 254 int __init atalk_proc_init(void) 255 { 256 struct proc_dir_entry *p; 257 int rc = -ENOMEM; 258 259 atalk_proc_dir = proc_mkdir("atalk", init_net.proc_net); 260 if (!atalk_proc_dir) 261 goto out; 262 263 p = proc_create("interface", S_IRUGO, atalk_proc_dir, 264 &atalk_seq_interface_fops); 265 if (!p) 266 goto out_interface; 267 268 p = proc_create("route", S_IRUGO, atalk_proc_dir, 269 &atalk_seq_route_fops); 270 if (!p) 271 goto out_route; 272 273 p = proc_create("socket", S_IRUGO, atalk_proc_dir, 274 &atalk_seq_socket_fops); 275 if (!p) 276 goto out_socket; 277 278 p = proc_create("arp", S_IRUGO, atalk_proc_dir, &atalk_seq_arp_fops); 279 if (!p) 280 goto out_arp; 281 282 rc = 0; 283 out: 284 return rc; 285 out_arp: 286 remove_proc_entry("socket", atalk_proc_dir); 287 out_socket: 288 remove_proc_entry("route", atalk_proc_dir); 289 out_route: 290 remove_proc_entry("interface", atalk_proc_dir); 291 out_interface: 292 remove_proc_entry("atalk", init_net.proc_net); 293 goto out; 294 } 295 296 void __exit atalk_proc_exit(void) 297 { 298 remove_proc_entry("interface", atalk_proc_dir); 299 remove_proc_entry("route", atalk_proc_dir); 300 remove_proc_entry("socket", atalk_proc_dir); 301 remove_proc_entry("arp", atalk_proc_dir); 302 remove_proc_entry("atalk", init_net.proc_net); 303 } 304