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