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