net/ipx/ipx_proc.c

   1 /*
   2  *      IPX proc routines
   3  *
   4  *      Copyright(C) Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 2002
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/init.h>
   9 #ifdef CONFIG_PROC_FS
  10 #include <linux/proc_fs.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/seq_file.h>
  13 #include <net/tcp_states.h>
  14 #include <net/ipx.h>
  15
  16 static __inline__ struct ipx_interface *ipx_get_interface_idx(loff_t pos)
  17 {
  18         struct ipx_interface *i;
  19
  20         list_for_each_entry(i, &ipx_interfaces, node)
  21                 if (!pos--)
  22                         goto out;
  23         i = NULL;
  24 out:
  25         return i;
  26 }
  27
  28 static struct ipx_interface *ipx_interfaces_next(struct ipx_interface *i)
  29 {
  30         struct ipx_interface *rc = NULL;
  31
  32         if (i->node.next != &ipx_interfaces)
  33                 rc = list_entry(i->node.next, struct ipx_interface, node);
  34         return rc;
  35 }
  36
  37 static void *ipx_seq_interface_start(struct seq_file *seq, loff_t *pos)
  38 {
  39         loff_t l = *pos;
  40
  41         spin_lock_bh(&ipx_interfaces_lock);
  42         return l ? ipx_get_interface_idx(--l) : SEQ_START_TOKEN;
  43 }
  44
  45 static void *ipx_seq_interface_next(struct seq_file *seq, void *v, loff_t *pos)
  46 {
  47         struct ipx_interface *i;
  48
  49         ++*pos;
  50         if (v == SEQ_START_TOKEN)
  51                 i = ipx_interfaces_head();
  52         else
  53                 i = ipx_interfaces_next(v);
  54         return i;
  55 }
  56
  57 static void ipx_seq_interface_stop(struct seq_file *seq, void *v)
  58 {
  59         spin_unlock_bh(&ipx_interfaces_lock);
  60 }
  61
  62 static int ipx_seq_interface_show(struct seq_file *seq, void *v)
  63 {
  64         struct ipx_interface *i;
  65
  66         if (v == SEQ_START_TOKEN) {
  67                 seq_puts(seq, "Network    Node_Address   Primary  Device     "
  68                               "Frame_Type");
  69 #ifdef IPX_REFCNT_DEBUG
  70                 seq_puts(seq, "  refcnt");
  71 #endif
  72                 seq_puts(seq, "\n");
  73                 goto out;
  74         }
  75
  76         i = v;
  77         seq_printf(seq, "%08lX   ", (unsigned long int)ntohl(i->if_netnum));
  78         seq_printf(seq, "%02X%02X%02X%02X%02X%02X   ",
  79                         i->if_node[0], i->if_node[1], i->if_node[2],
  80                         i->if_node[3], i->if_node[4], i->if_node[5]);
  81         seq_printf(seq, "%-9s", i == ipx_primary_net ? "Yes" : "No");
  82         seq_printf(seq, "%-11s", ipx_device_name(i));
  83         seq_printf(seq, "%-9s", ipx_frame_name(i->if_dlink_type));
  84 #ifdef IPX_REFCNT_DEBUG
  85         seq_printf(seq, "%6d", atomic_read(&i->refcnt));
  86 #endif
  87         seq_puts(seq, "\n");
  88 out:
  89         return 0;
  90 }
  91
  92 static struct ipx_route *ipx_routes_head(void)
  93 {
  94         struct ipx_route *rc = NULL;
  95
  96         if (!list_empty(&ipx_routes))
  97                 rc = list_entry(ipx_routes.next, struct ipx_route, node);
  98         return rc;
  99 }
 100
 101 static struct ipx_route *ipx_routes_next(struct ipx_route *r)
 102 {
 103         struct ipx_route *rc = NULL;
 104
 105         if (r->node.next != &ipx_routes)
 106                 rc = list_entry(r->node.next, struct ipx_route, node);
 107         return rc;
 108 }
 109
 110 static __inline__ struct ipx_route *ipx_get_route_idx(loff_t pos)
 111 {
 112         struct ipx_route *r;
 113
 114         list_for_each_entry(r, &ipx_routes, node)
 115                 if (!pos--)
 116                         goto out;
 117         r = NULL;
 118 out:
 119         return r;
 120 }
 121
 122 static void *ipx_seq_route_start(struct seq_file *seq, loff_t *pos)
 123 {
 124         loff_t l = *pos;
 125         read_lock_bh(&ipx_routes_lock);
 126         return l ? ipx_get_route_idx(--l) : SEQ_START_TOKEN;
 127 }
 128
 129 static void *ipx_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
 130 {
 131         struct ipx_route *r;
 132
 133         ++*pos;
 134         if (v == SEQ_START_TOKEN)
 135                 r = ipx_routes_head();
 136         else
 137                 r = ipx_routes_next(v);
 138         return r;
 139 }
 140
 141 static void ipx_seq_route_stop(struct seq_file *seq, void *v)
 142 {
 143         read_unlock_bh(&ipx_routes_lock);
 144 }
 145
 146 static int ipx_seq_route_show(struct seq_file *seq, void *v)
 147 {
 148         struct ipx_route *rt;
 149
 150         if (v == SEQ_START_TOKEN) {
 151                 seq_puts(seq, "Network    Router_Net   Router_Node\n");
 152                 goto out;
 153         }
 154         rt = v;
 155         seq_printf(seq, "%08lX   ", (unsigned long int)ntohl(rt->ir_net));
 156         if (rt->ir_routed)
 157                 seq_printf(seq, "%08lX     %02X%02X%02X%02X%02X%02X\n",
 158                            (long unsigned int)ntohl(rt->ir_intrfc->if_netnum),
 159                            rt->ir_router_node[0], rt->ir_router_node[1],
 160                            rt->ir_router_node[2], rt->ir_router_node[3],
 161                            rt->ir_router_node[4], rt->ir_router_node[5]);
 162         else
 163                 seq_puts(seq, "Directly     Connected\n");
 164 out:
 165         return 0;
 166 }
 167
 168 static __inline__ struct sock *ipx_get_socket_idx(loff_t pos)
 169 {
 170         struct sock *s = NULL;
 171         struct hlist_node *node;
 172         struct ipx_interface *i;
 173
 174         list_for_each_entry(i, &ipx_interfaces, node) {
 175                 spin_lock_bh(&i->if_sklist_lock);
 176                 sk_for_each(s, node, &i->if_sklist) {
 177                         if (!pos)
 178                                 break;
 179                         --pos;
 180                 }
 181                 spin_unlock_bh(&i->if_sklist_lock);
 182                 if (!pos) {
 183                         if (node)
 184                                 goto found;
 185                         break;
 186                 }
 187         }
 188         s = NULL;
 189 found:
 190         return s;
 191 }
 192
 193 static void *ipx_seq_socket_start(struct seq_file *seq, loff_t *pos)
 194 {
 195         loff_t l = *pos;
 196
 197         spin_lock_bh(&ipx_interfaces_lock);
 198         return l ? ipx_get_socket_idx(--l) : SEQ_START_TOKEN;
 199 }
 200
 201 static void *ipx_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
 202 {
 203         struct sock* sk, *next;
 204         struct ipx_interface *i;
 205         struct ipx_sock *ipxs;
 206
 207         ++*pos;
 208         if (v == SEQ_START_TOKEN) {
 209                 sk = NULL;
 210                 i = ipx_interfaces_head();
 211                 if (!i)
 212                         goto out;
 213                 sk = sk_head(&i->if_sklist);
 214                 if (sk)
 215                         spin_lock_bh(&i->if_sklist_lock);
 216                 goto out;
 217         }
 218         sk = v;
 219         next = sk_next(sk);
 220         if (next) {
 221                 sk = next;
 222                 goto out;
 223         }
 224         ipxs = ipx_sk(sk);
 225         i = ipxs->intrfc;
 226         spin_unlock_bh(&i->if_sklist_lock);
 227         sk = NULL;
 228         for (;;) {
 229                 i = ipx_interfaces_next(i);
 230                 if (!i)
 231                         break;
 232                 spin_lock_bh(&i->if_sklist_lock);
 233                 if (!hlist_empty(&i->if_sklist)) {
 234                         sk = sk_head(&i->if_sklist);
 235                         break;
 236                 }
 237                 spin_unlock_bh(&i->if_sklist_lock);
 238         }
 239 out:
 240         return sk;
 241 }
 242
 243 static int ipx_seq_socket_show(struct seq_file *seq, void *v)
 244 {
 245         struct sock *s;
 246         struct ipx_sock *ipxs;
 247
 248         if (v == SEQ_START_TOKEN) {
 249 #ifdef CONFIG_IPX_INTERN
 250                 seq_puts(seq, "Local_Address               "
 251                               "Remote_Address              Tx_Queue  "
 252                               "Rx_Queue  State  Uid\n");
 253 #else
 254                 seq_puts(seq, "Local_Address  Remote_Address              "
 255                               "Tx_Queue  Rx_Queue  State  Uid\n");
 256 #endif
 257                 goto out;
 258         }
 259
 260         s = v;
 261         ipxs = ipx_sk(s);
 262 #ifdef CONFIG_IPX_INTERN
 263         seq_printf(seq, "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ",
 264                    (unsigned long)htonl(ipxs->intrfc->if_netnum),
 265                    ipxs->node[0], ipxs->node[1], ipxs->node[2], ipxs->node[3],
 266                    ipxs->node[4], ipxs->node[5], htons(ipxs->port));
 267 #else
 268         seq_printf(seq, "%08lX:%04X  ", (unsigned long) htonl(ipxs->intrfc->if_netnum),
 269                    htons(ipxs->port));
 270 #endif  /* CONFIG_IPX_INTERN */
 271         if (s->sk_state != TCP_ESTABLISHED)
 272                 seq_printf(seq, "%-28s", "Not_Connected");
 273         else {
 274                 seq_printf(seq, "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ",
 275                            (unsigned long)htonl(ipxs->dest_addr.net),
 276                            ipxs->dest_addr.node[0], ipxs->dest_addr.node[1],
 277                            ipxs->dest_addr.node[2], ipxs->dest_addr.node[3],
 278                            ipxs->dest_addr.node[4], ipxs->dest_addr.node[5],
 279                            htons(ipxs->dest_addr.sock));
 280         }
 281
 282         seq_printf(seq, "%08X  %08X  %02X     %03d\n",
 283                    atomic_read(&s->sk_wmem_alloc),
 284                    atomic_read(&s->sk_rmem_alloc),
 285                    s->sk_state, SOCK_INODE(s->sk_socket)->i_uid);
 286 out:
 287         return 0;
 288 }
 289
 290 static struct seq_operations ipx_seq_interface_ops = {
 291         .start  = ipx_seq_interface_start,
 292         .next   = ipx_seq_interface_next,
 293         .stop   = ipx_seq_interface_stop,
 294         .show   = ipx_seq_interface_show,
 295 };
 296
 297 static struct seq_operations ipx_seq_route_ops = {
 298         .start  = ipx_seq_route_start,
 299         .next   = ipx_seq_route_next,
 300         .stop   = ipx_seq_route_stop,
 301         .show   = ipx_seq_route_show,
 302 };
 303
 304 static struct seq_operations ipx_seq_socket_ops = {
 305         .start  = ipx_seq_socket_start,
 306         .next   = ipx_seq_socket_next,
 307         .stop   = ipx_seq_interface_stop,
 308         .show   = ipx_seq_socket_show,
 309 };
 310
 311 static int ipx_seq_route_open(struct inode *inode, struct file *file)
 312 {
 313         return seq_open(file, &ipx_seq_route_ops);
 314 }
 315
 316 static int ipx_seq_interface_open(struct inode *inode, struct file *file)
 317 {
 318         return seq_open(file, &ipx_seq_interface_ops);
 319 }
 320
 321 static int ipx_seq_socket_open(struct inode *inode, struct file *file)
 322 {
 323         return seq_open(file, &ipx_seq_socket_ops);
 324 }
 325
 326 static struct file_operations ipx_seq_interface_fops = {
 327         .owner          = THIS_MODULE,
 328         .open           = ipx_seq_interface_open,
 329         .read           = seq_read,
 330         .llseek         = seq_lseek,
 331         .release        = seq_release,
 332 };
 333
 334 static struct file_operations ipx_seq_route_fops = {
 335         .owner          = THIS_MODULE,
 336         .open           = ipx_seq_route_open,
 337         .read           = seq_read,
 338         .llseek         = seq_lseek,
 339         .release        = seq_release,
 340 };
 341
 342 static struct file_operations ipx_seq_socket_fops = {
 343         .owner          = THIS_MODULE,
 344         .open           = ipx_seq_socket_open,
 345         .read           = seq_read,
 346         .llseek         = seq_lseek,
 347         .release        = seq_release,
 348 };
 349
 350 static struct proc_dir_entry *ipx_proc_dir;
 351
 352 int __init ipx_proc_init(void)
 353 {
 354         struct proc_dir_entry *p;
 355         int rc = -ENOMEM;
 356
 357         ipx_proc_dir = proc_mkdir("ipx", proc_net);
 358
 359         if (!ipx_proc_dir)
 360                 goto out;
 361         p = create_proc_entry("interface", S_IRUGO, ipx_proc_dir);
 362         if (!p)
 363                 goto out_interface;
 364
 365         p->proc_fops = &ipx_seq_interface_fops;
 366         p = create_proc_entry("route", S_IRUGO, ipx_proc_dir);
 367         if (!p)
 368                 goto out_route;
 369
 370         p->proc_fops = &ipx_seq_route_fops;
 371         p = create_proc_entry("socket", S_IRUGO, ipx_proc_dir);
 372         if (!p)
 373                 goto out_socket;
 374
 375         p->proc_fops = &ipx_seq_socket_fops;
 376
 377         rc = 0;
 378 out:
 379         return rc;
 380 out_socket:
 381         remove_proc_entry("route", ipx_proc_dir);
 382 out_route:
 383         remove_proc_entry("interface", ipx_proc_dir);
 384 out_interface:
 385         remove_proc_entry("ipx", proc_net);
 386         goto out;
 387 }
 388
 389 void __exit ipx_proc_exit(void)
 390 {
 391         remove_proc_entry("interface", ipx_proc_dir);
 392         remove_proc_entry("route", ipx_proc_dir);
 393         remove_proc_entry("socket", ipx_proc_dir);
 394         remove_proc_entry("ipx", proc_net);
 395 }
 396
 397 #else /* CONFIG_PROC_FS */
 398
 399 int __init ipx_proc_init(void)
 400 {
 401         return 0;
 402 }
 403
 404 void __exit ipx_proc_exit(void)
 405 {
 406 }
 407
 408 #endif /* CONFIG_PROC_FS */