mqprio: Avoid panic if no options are provided
[linux-2.6.git] / net / atm / proc.c
1 /* net/atm/proc.c - ATM /proc interface
2  *
3  * Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA
4  *
5  * seq_file api usage by romieu@fr.zoreil.com
6  *
7  * Evaluating the efficiency of the whole thing if left as an exercise to
8  * the reader.
9  */
10
11 #include <linux/module.h> /* for EXPORT_SYMBOL */
12 #include <linux/string.h>
13 #include <linux/types.h>
14 #include <linux/mm.h>
15 #include <linux/fs.h>
16 #include <linux/stat.h>
17 #include <linux/proc_fs.h>
18 #include <linux/seq_file.h>
19 #include <linux/errno.h>
20 #include <linux/atm.h>
21 #include <linux/atmdev.h>
22 #include <linux/netdevice.h>
23 #include <linux/atmclip.h>
24 #include <linux/init.h> /* for __init */
25 #include <linux/slab.h>
26 #include <net/net_namespace.h>
27 #include <net/atmclip.h>
28 #include <linux/uaccess.h>
29 #include <linux/param.h> /* for HZ */
30 #include <linux/atomic.h>
31 #include "resources.h"
32 #include "common.h" /* atm_proc_init prototype */
33 #include "signaling.h" /* to get sigd - ugly too */
34
35 static ssize_t proc_dev_atm_read(struct file *file, char __user *buf,
36                                  size_t count, loff_t *pos);
37
38 static const struct file_operations proc_atm_dev_ops = {
39         .owner =        THIS_MODULE,
40         .read =         proc_dev_atm_read,
41         .llseek =       noop_llseek,
42 };
43
44 static void add_stats(struct seq_file *seq, const char *aal,
45   const struct k_atm_aal_stats *stats)
46 {
47         seq_printf(seq, "%s ( %d %d %d %d %d )", aal,
48                    atomic_read(&stats->tx), atomic_read(&stats->tx_err),
49                    atomic_read(&stats->rx), atomic_read(&stats->rx_err),
50                    atomic_read(&stats->rx_drop));
51 }
52
53 static void atm_dev_info(struct seq_file *seq, const struct atm_dev *dev)
54 {
55         int i;
56
57         seq_printf(seq, "%3d %-8s", dev->number, dev->type);
58         for (i = 0; i < ESI_LEN; i++)
59                 seq_printf(seq, "%02x", dev->esi[i]);
60         seq_puts(seq, "  ");
61         add_stats(seq, "0", &dev->stats.aal0);
62         seq_puts(seq, "  ");
63         add_stats(seq, "5", &dev->stats.aal5);
64         seq_printf(seq, "\t[%d]", atomic_read(&dev->refcnt));
65         seq_putc(seq, '\n');
66 }
67
68 struct vcc_state {
69         int bucket;
70         struct sock *sk;
71         int family;
72 };
73
74 static inline int compare_family(struct sock *sk, int family)
75 {
76         return !family || (sk->sk_family == family);
77 }
78
79 static int __vcc_walk(struct sock **sock, int family, int *bucket, loff_t l)
80 {
81         struct sock *sk = *sock;
82
83         if (sk == SEQ_START_TOKEN) {
84                 for (*bucket = 0; *bucket < VCC_HTABLE_SIZE; ++*bucket) {
85                         struct hlist_head *head = &vcc_hash[*bucket];
86
87                         sk = hlist_empty(head) ? NULL : __sk_head(head);
88                         if (sk)
89                                 break;
90                 }
91                 l--;
92         }
93 try_again:
94         for (; sk; sk = sk_next(sk)) {
95                 l -= compare_family(sk, family);
96                 if (l < 0)
97                         goto out;
98         }
99         if (!sk && ++*bucket < VCC_HTABLE_SIZE) {
100                 sk = sk_head(&vcc_hash[*bucket]);
101                 goto try_again;
102         }
103         sk = SEQ_START_TOKEN;
104 out:
105         *sock = sk;
106         return (l < 0);
107 }
108
109 static inline void *vcc_walk(struct vcc_state *state, loff_t l)
110 {
111         return __vcc_walk(&state->sk, state->family, &state->bucket, l) ?
112                state : NULL;
113 }
114
115 static int __vcc_seq_open(struct inode *inode, struct file *file,
116         int family, const struct seq_operations *ops)
117 {
118         struct vcc_state *state;
119
120         state = __seq_open_private(file, ops, sizeof(*state));
121         if (state == NULL)
122                 return -ENOMEM;
123
124         state->family = family;
125         return 0;
126 }
127
128 static void *vcc_seq_start(struct seq_file *seq, loff_t *pos)
129         __acquires(vcc_sklist_lock)
130 {
131         struct vcc_state *state = seq->private;
132         loff_t left = *pos;
133
134         read_lock(&vcc_sklist_lock);
135         state->sk = SEQ_START_TOKEN;
136         return left ? vcc_walk(state, left) : SEQ_START_TOKEN;
137 }
138
139 static void vcc_seq_stop(struct seq_file *seq, void *v)
140         __releases(vcc_sklist_lock)
141 {
142         read_unlock(&vcc_sklist_lock);
143 }
144
145 static void *vcc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
146 {
147         struct vcc_state *state = seq->private;
148
149         v = vcc_walk(state, 1);
150         *pos += !!PTR_ERR(v);
151         return v;
152 }
153
154 static void pvc_info(struct seq_file *seq, struct atm_vcc *vcc)
155 {
156         static const char *const class_name[] = {
157                 "off", "UBR", "CBR", "VBR", "ABR"};
158         static const char *const aal_name[] = {
159                 "---",  "1",    "2",    "3/4",  /*  0- 3 */
160                 "???",  "5",    "???",  "???",  /*  4- 7 */
161                 "???",  "???",  "???",  "???",  /*  8-11 */
162                 "???",  "0",    "???",  "???"}; /* 12-15 */
163
164         seq_printf(seq, "%3d %3d %5d %-3s %7d %-5s %7d %-6s",
165                    vcc->dev->number, vcc->vpi, vcc->vci,
166                    vcc->qos.aal >= ARRAY_SIZE(aal_name) ? "err" :
167                    aal_name[vcc->qos.aal], vcc->qos.rxtp.min_pcr,
168                    class_name[vcc->qos.rxtp.traffic_class],
169                    vcc->qos.txtp.min_pcr,
170                    class_name[vcc->qos.txtp.traffic_class]);
171         if (test_bit(ATM_VF_IS_CLIP, &vcc->flags)) {
172                 struct clip_vcc *clip_vcc = CLIP_VCC(vcc);
173                 struct net_device *dev;
174
175                 dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : NULL;
176                 seq_printf(seq, "CLIP, Itf:%s, Encap:",
177                     dev ? dev->name : "none?");
178                 seq_printf(seq, "%s", clip_vcc->encap ? "LLC/SNAP" : "None");
179         }
180         seq_putc(seq, '\n');
181 }
182
183 static const char *vcc_state(struct atm_vcc *vcc)
184 {
185         static const char *const map[] = { ATM_VS2TXT_MAP };
186
187         return map[ATM_VF2VS(vcc->flags)];
188 }
189
190 static void vcc_info(struct seq_file *seq, struct atm_vcc *vcc)
191 {
192         struct sock *sk = sk_atm(vcc);
193
194         seq_printf(seq, "%pK ", vcc);
195         if (!vcc->dev)
196                 seq_printf(seq, "Unassigned    ");
197         else
198                 seq_printf(seq, "%3d %3d %5d ", vcc->dev->number, vcc->vpi,
199                         vcc->vci);
200         switch (sk->sk_family) {
201         case AF_ATMPVC:
202                 seq_printf(seq, "PVC");
203                 break;
204         case AF_ATMSVC:
205                 seq_printf(seq, "SVC");
206                 break;
207         default:
208                 seq_printf(seq, "%3d", sk->sk_family);
209         }
210         seq_printf(seq, " %04lx  %5d %7d/%7d %7d/%7d [%d]\n",
211                    vcc->flags, sk->sk_err,
212                    sk_wmem_alloc_get(sk), sk->sk_sndbuf,
213                    sk_rmem_alloc_get(sk), sk->sk_rcvbuf,
214                    atomic_read(&sk->sk_refcnt));
215 }
216
217 static void svc_info(struct seq_file *seq, struct atm_vcc *vcc)
218 {
219         if (!vcc->dev)
220                 seq_printf(seq, sizeof(void *) == 4 ?
221                            "N/A@%pK%10s" : "N/A@%pK%2s", vcc, "");
222         else
223                 seq_printf(seq, "%3d %3d %5d         ",
224                            vcc->dev->number, vcc->vpi, vcc->vci);
225         seq_printf(seq, "%-10s ", vcc_state(vcc));
226         seq_printf(seq, "%s%s", vcc->remote.sas_addr.pub,
227             *vcc->remote.sas_addr.pub && *vcc->remote.sas_addr.prv ? "+" : "");
228         if (*vcc->remote.sas_addr.prv) {
229                 int i;
230
231                 for (i = 0; i < ATM_ESA_LEN; i++)
232                         seq_printf(seq, "%02x", vcc->remote.sas_addr.prv[i]);
233         }
234         seq_putc(seq, '\n');
235 }
236
237 static int atm_dev_seq_show(struct seq_file *seq, void *v)
238 {
239         static char atm_dev_banner[] =
240                 "Itf Type    ESI/\"MAC\"addr "
241                 "AAL(TX,err,RX,err,drop) ...               [refcnt]\n";
242
243         if (v == &atm_devs)
244                 seq_puts(seq, atm_dev_banner);
245         else {
246                 struct atm_dev *dev = list_entry(v, struct atm_dev, dev_list);
247
248                 atm_dev_info(seq, dev);
249         }
250         return 0;
251 }
252
253 static const struct seq_operations atm_dev_seq_ops = {
254         .start  = atm_dev_seq_start,
255         .next   = atm_dev_seq_next,
256         .stop   = atm_dev_seq_stop,
257         .show   = atm_dev_seq_show,
258 };
259
260 static int atm_dev_seq_open(struct inode *inode, struct file *file)
261 {
262         return seq_open(file, &atm_dev_seq_ops);
263 }
264
265 static const struct file_operations devices_seq_fops = {
266         .open           = atm_dev_seq_open,
267         .read           = seq_read,
268         .llseek         = seq_lseek,
269         .release        = seq_release,
270 };
271
272 static int pvc_seq_show(struct seq_file *seq, void *v)
273 {
274         static char atm_pvc_banner[] =
275                 "Itf VPI VCI   AAL RX(PCR,Class) TX(PCR,Class)\n";
276
277         if (v == SEQ_START_TOKEN)
278                 seq_puts(seq, atm_pvc_banner);
279         else {
280                 struct vcc_state *state = seq->private;
281                 struct atm_vcc *vcc = atm_sk(state->sk);
282
283                 pvc_info(seq, vcc);
284         }
285         return 0;
286 }
287
288 static const struct seq_operations pvc_seq_ops = {
289         .start  = vcc_seq_start,
290         .next   = vcc_seq_next,
291         .stop   = vcc_seq_stop,
292         .show   = pvc_seq_show,
293 };
294
295 static int pvc_seq_open(struct inode *inode, struct file *file)
296 {
297         return __vcc_seq_open(inode, file, PF_ATMPVC, &pvc_seq_ops);
298 }
299
300 static const struct file_operations pvc_seq_fops = {
301         .open           = pvc_seq_open,
302         .read           = seq_read,
303         .llseek         = seq_lseek,
304         .release        = seq_release_private,
305 };
306
307 static int vcc_seq_show(struct seq_file *seq, void *v)
308 {
309         if (v == SEQ_START_TOKEN) {
310                 seq_printf(seq, sizeof(void *) == 4 ? "%-8s%s" : "%-16s%s",
311                         "Address ", "Itf VPI VCI   Fam Flags Reply "
312                         "Send buffer     Recv buffer      [refcnt]\n");
313         } else {
314                 struct vcc_state *state = seq->private;
315                 struct atm_vcc *vcc = atm_sk(state->sk);
316
317                 vcc_info(seq, vcc);
318         }
319         return 0;
320 }
321
322 static const struct seq_operations vcc_seq_ops = {
323         .start  = vcc_seq_start,
324         .next   = vcc_seq_next,
325         .stop   = vcc_seq_stop,
326         .show   = vcc_seq_show,
327 };
328
329 static int vcc_seq_open(struct inode *inode, struct file *file)
330 {
331         return __vcc_seq_open(inode, file, 0, &vcc_seq_ops);
332 }
333
334 static const struct file_operations vcc_seq_fops = {
335         .open           = vcc_seq_open,
336         .read           = seq_read,
337         .llseek         = seq_lseek,
338         .release        = seq_release_private,
339 };
340
341 static int svc_seq_show(struct seq_file *seq, void *v)
342 {
343         static const char atm_svc_banner[] =
344                 "Itf VPI VCI           State      Remote\n";
345
346         if (v == SEQ_START_TOKEN)
347                 seq_puts(seq, atm_svc_banner);
348         else {
349                 struct vcc_state *state = seq->private;
350                 struct atm_vcc *vcc = atm_sk(state->sk);
351
352                 svc_info(seq, vcc);
353         }
354         return 0;
355 }
356
357 static const struct seq_operations svc_seq_ops = {
358         .start  = vcc_seq_start,
359         .next   = vcc_seq_next,
360         .stop   = vcc_seq_stop,
361         .show   = svc_seq_show,
362 };
363
364 static int svc_seq_open(struct inode *inode, struct file *file)
365 {
366         return __vcc_seq_open(inode, file, PF_ATMSVC, &svc_seq_ops);
367 }
368
369 static const struct file_operations svc_seq_fops = {
370         .open           = svc_seq_open,
371         .read           = seq_read,
372         .llseek         = seq_lseek,
373         .release        = seq_release_private,
374 };
375
376 static ssize_t proc_dev_atm_read(struct file *file, char __user *buf,
377                                  size_t count, loff_t *pos)
378 {
379         struct atm_dev *dev;
380         unsigned long page;
381         int length;
382
383         if (count == 0)
384                 return 0;
385         page = get_zeroed_page(GFP_KERNEL);
386         if (!page)
387                 return -ENOMEM;
388         dev = PDE(file->f_path.dentry->d_inode)->data;
389         if (!dev->ops->proc_read)
390                 length = -EINVAL;
391         else {
392                 length = dev->ops->proc_read(dev, pos, (char *)page);
393                 if (length > count)
394                         length = -EINVAL;
395         }
396         if (length >= 0) {
397                 if (copy_to_user(buf, (char *)page, length))
398                         length = -EFAULT;
399                 (*pos)++;
400         }
401         free_page(page);
402         return length;
403 }
404
405 struct proc_dir_entry *atm_proc_root;
406 EXPORT_SYMBOL(atm_proc_root);
407
408
409 int atm_proc_dev_register(struct atm_dev *dev)
410 {
411         int error;
412
413         /* No proc info */
414         if (!dev->ops->proc_read)
415                 return 0;
416
417         error = -ENOMEM;
418         dev->proc_name = kasprintf(GFP_KERNEL, "%s:%d", dev->type, dev->number);
419         if (!dev->proc_name)
420                 goto err_out;
421
422         dev->proc_entry = proc_create_data(dev->proc_name, 0, atm_proc_root,
423                                            &proc_atm_dev_ops, dev);
424         if (!dev->proc_entry)
425                 goto err_free_name;
426         return 0;
427
428 err_free_name:
429         kfree(dev->proc_name);
430 err_out:
431         return error;
432 }
433
434 void atm_proc_dev_deregister(struct atm_dev *dev)
435 {
436         if (!dev->ops->proc_read)
437                 return;
438
439         remove_proc_entry(dev->proc_name, atm_proc_root);
440         kfree(dev->proc_name);
441 }
442
443 static struct atm_proc_entry {
444         char *name;
445         const struct file_operations *proc_fops;
446         struct proc_dir_entry *dirent;
447 } atm_proc_ents[] = {
448         { .name = "devices",    .proc_fops = &devices_seq_fops },
449         { .name = "pvc",        .proc_fops = &pvc_seq_fops },
450         { .name = "svc",        .proc_fops = &svc_seq_fops },
451         { .name = "vc",         .proc_fops = &vcc_seq_fops },
452         { .name = NULL,         .proc_fops = NULL }
453 };
454
455 static void atm_proc_dirs_remove(void)
456 {
457         static struct atm_proc_entry *e;
458
459         for (e = atm_proc_ents; e->name; e++) {
460                 if (e->dirent)
461                         remove_proc_entry(e->name, atm_proc_root);
462         }
463         proc_net_remove(&init_net, "atm");
464 }
465
466 int __init atm_proc_init(void)
467 {
468         static struct atm_proc_entry *e;
469         int ret;
470
471         atm_proc_root = proc_net_mkdir(&init_net, "atm", init_net.proc_net);
472         if (!atm_proc_root)
473                 goto err_out;
474         for (e = atm_proc_ents; e->name; e++) {
475                 struct proc_dir_entry *dirent;
476
477                 dirent = proc_create(e->name, S_IRUGO,
478                                      atm_proc_root, e->proc_fops);
479                 if (!dirent)
480                         goto err_out_remove;
481                 e->dirent = dirent;
482         }
483         ret = 0;
484 out:
485         return ret;
486
487 err_out_remove:
488         atm_proc_dirs_remove();
489 err_out:
490         ret = -ENOMEM;
491         goto out;
492 }
493
494 void atm_proc_exit(void)
495 {
496         atm_proc_dirs_remove();
497 }