aboutsummaryrefslogtreecommitdiffstats
path: root/net/core
diff options
context:
space:
mode:
authorCong Wang <xiyou.wangcong@gmail.com>2013-02-18 14:20:33 -0500
committerDavid S. Miller <davem@davemloft.net>2013-02-19 00:51:10 -0500
commit900ff8c6321418dafa03c22e215cb9646a2541b9 (patch)
treeda94d724e34cda801d23aea533a5575084d31a8d /net/core
parent45d213f5f8733ab4b5b2424b21c0034d54c5a866 (diff)
net: move procfs code to net/core/net-procfs.c
Similar to net/core/net-sysfs.c, group procfs code to a single unit. Cc: "David S. Miller" <davem@davemloft.net> Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'net/core')
-rw-r--r--net/core/Makefile1
-rw-r--r--net/core/dev.c384
-rw-r--r--net/core/dev_addr_lists.c74
-rw-r--r--net/core/net-procfs.c414
4 files changed, 417 insertions, 456 deletions
diff --git a/net/core/Makefile b/net/core/Makefile
index 0c5e3618c80b..b33b996f5dd6 100644
--- a/net/core/Makefile
+++ b/net/core/Makefile
@@ -13,6 +13,7 @@ obj-y += dev.o ethtool.o dev_addr_lists.o dst.o netevent.o \
13 13
14obj-$(CONFIG_XFRM) += flow.o 14obj-$(CONFIG_XFRM) += flow.o
15obj-y += net-sysfs.o 15obj-y += net-sysfs.o
16obj-$(CONFIG_PROC_FS) += net-procfs.o
16obj-$(CONFIG_NET_PKTGEN) += pktgen.o 17obj-$(CONFIG_NET_PKTGEN) += pktgen.o
17obj-$(CONFIG_NETPOLL) += netpoll.o 18obj-$(CONFIG_NETPOLL) += netpoll.o
18obj-$(CONFIG_NET_DMA) += user_dma.o 19obj-$(CONFIG_NET_DMA) += user_dma.o
diff --git a/net/core/dev.c b/net/core/dev.c
index decf55f9ad80..8d9ddb09f208 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -97,8 +97,6 @@
97#include <net/net_namespace.h> 97#include <net/net_namespace.h>
98#include <net/sock.h> 98#include <net/sock.h>
99#include <linux/rtnetlink.h> 99#include <linux/rtnetlink.h>
100#include <linux/proc_fs.h>
101#include <linux/seq_file.h>
102#include <linux/stat.h> 100#include <linux/stat.h>
103#include <net/dst.h> 101#include <net/dst.h>
104#include <net/pkt_sched.h> 102#include <net/pkt_sched.h>
@@ -110,7 +108,6 @@
110#include <linux/netpoll.h> 108#include <linux/netpoll.h>
111#include <linux/rcupdate.h> 109#include <linux/rcupdate.h>
112#include <linux/delay.h> 110#include <linux/delay.h>
113#include <net/wext.h>
114#include <net/iw_handler.h> 111#include <net/iw_handler.h>
115#include <asm/current.h> 112#include <asm/current.h>
116#include <linux/audit.h> 113#include <linux/audit.h>
@@ -141,41 +138,10 @@
141/* This should be increased if a protocol with a bigger head is added. */ 138/* This should be increased if a protocol with a bigger head is added. */
142#define GRO_MAX_HEAD (MAX_HEADER + 128) 139#define GRO_MAX_HEAD (MAX_HEADER + 128)
143 140
144/*
145 * The list of packet types we will receive (as opposed to discard)
146 * and the routines to invoke.
147 *
148 * Why 16. Because with 16 the only overlap we get on a hash of the
149 * low nibble of the protocol value is RARP/SNAP/X.25.
150 *
151 * NOTE: That is no longer true with the addition of VLAN tags. Not
152 * sure which should go first, but I bet it won't make much
153 * difference if we are running VLANs. The good news is that
154 * this protocol won't be in the list unless compiled in, so
155 * the average user (w/out VLANs) will not be adversely affected.
156 * --BLG
157 *
158 * 0800 IP
159 * 8100 802.1Q VLAN
160 * 0001 802.3
161 * 0002 AX.25
162 * 0004 802.2
163 * 8035 RARP
164 * 0005 SNAP
165 * 0805 X.25
166 * 0806 ARP
167 * 8137 IPX
168 * 0009 Localtalk
169 * 86DD IPv6
170 */
171
172#define PTYPE_HASH_SIZE (16)
173#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
174
175static DEFINE_SPINLOCK(ptype_lock); 141static DEFINE_SPINLOCK(ptype_lock);
176static DEFINE_SPINLOCK(offload_lock); 142static DEFINE_SPINLOCK(offload_lock);
177static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly; 143struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
178static struct list_head ptype_all __read_mostly; /* Taps */ 144struct list_head ptype_all __read_mostly; /* Taps */
179static struct list_head offload_base __read_mostly; 145static struct list_head offload_base __read_mostly;
180 146
181/* 147/*
@@ -4217,352 +4183,6 @@ softnet_break:
4217 goto out; 4183 goto out;
4218} 4184}
4219 4185
4220#ifdef CONFIG_PROC_FS
4221
4222#define BUCKET_SPACE (32 - NETDEV_HASHBITS - 1)
4223
4224#define get_bucket(x) ((x) >> BUCKET_SPACE)
4225#define get_offset(x) ((x) & ((1 << BUCKET_SPACE) - 1))
4226#define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
4227
4228static inline struct net_device *dev_from_same_bucket(struct seq_file *seq, loff_t *pos)
4229{
4230 struct net *net = seq_file_net(seq);
4231 struct net_device *dev;
4232 struct hlist_node *p;
4233 struct hlist_head *h;
4234 unsigned int count = 0, offset = get_offset(*pos);
4235
4236 h = &net->dev_name_head[get_bucket(*pos)];
4237 hlist_for_each_entry_rcu(dev, p, h, name_hlist) {
4238 if (++count == offset)
4239 return dev;
4240 }
4241
4242 return NULL;
4243}
4244
4245static inline struct net_device *dev_from_bucket(struct seq_file *seq, loff_t *pos)
4246{
4247 struct net_device *dev;
4248 unsigned int bucket;
4249
4250 do {
4251 dev = dev_from_same_bucket(seq, pos);
4252 if (dev)
4253 return dev;
4254
4255 bucket = get_bucket(*pos) + 1;
4256 *pos = set_bucket_offset(bucket, 1);
4257 } while (bucket < NETDEV_HASHENTRIES);
4258
4259 return NULL;
4260}
4261
4262/*
4263 * This is invoked by the /proc filesystem handler to display a device
4264 * in detail.
4265 */
4266void *dev_seq_start(struct seq_file *seq, loff_t *pos)
4267 __acquires(RCU)
4268{
4269 rcu_read_lock();
4270 if (!*pos)
4271 return SEQ_START_TOKEN;
4272
4273 if (get_bucket(*pos) >= NETDEV_HASHENTRIES)
4274 return NULL;
4275
4276 return dev_from_bucket(seq, pos);
4277}
4278
4279void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4280{
4281 ++*pos;
4282 return dev_from_bucket(seq, pos);
4283}
4284
4285void dev_seq_stop(struct seq_file *seq, void *v)
4286 __releases(RCU)
4287{
4288 rcu_read_unlock();
4289}
4290
4291static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
4292{
4293 struct rtnl_link_stats64 temp;
4294 const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
4295
4296 seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu "
4297 "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n",
4298 dev->name, stats->rx_bytes, stats->rx_packets,
4299 stats->rx_errors,
4300 stats->rx_dropped + stats->rx_missed_errors,
4301 stats->rx_fifo_errors,
4302 stats->rx_length_errors + stats->rx_over_errors +
4303 stats->rx_crc_errors + stats->rx_frame_errors,
4304 stats->rx_compressed, stats->multicast,
4305 stats->tx_bytes, stats->tx_packets,
4306 stats->tx_errors, stats->tx_dropped,
4307 stats->tx_fifo_errors, stats->collisions,
4308 stats->tx_carrier_errors +
4309 stats->tx_aborted_errors +
4310 stats->tx_window_errors +
4311 stats->tx_heartbeat_errors,
4312 stats->tx_compressed);
4313}
4314
4315/*
4316 * Called from the PROCfs module. This now uses the new arbitrary sized
4317 * /proc/net interface to create /proc/net/dev
4318 */
4319static int dev_seq_show(struct seq_file *seq, void *v)
4320{
4321 if (v == SEQ_START_TOKEN)
4322 seq_puts(seq, "Inter-| Receive "
4323 " | Transmit\n"
4324 " face |bytes packets errs drop fifo frame "
4325 "compressed multicast|bytes packets errs "
4326 "drop fifo colls carrier compressed\n");
4327 else
4328 dev_seq_printf_stats(seq, v);
4329 return 0;
4330}
4331
4332static struct softnet_data *softnet_get_online(loff_t *pos)
4333{
4334 struct softnet_data *sd = NULL;
4335
4336 while (*pos < nr_cpu_ids)
4337 if (cpu_online(*pos)) {
4338 sd = &per_cpu(softnet_data, *pos);
4339 break;
4340 } else
4341 ++*pos;
4342 return sd;
4343}
4344
4345static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
4346{
4347 return softnet_get_online(pos);
4348}
4349
4350static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4351{
4352 ++*pos;
4353 return softnet_get_online(pos);
4354}
4355
4356static void softnet_seq_stop(struct seq_file *seq, void *v)
4357{
4358}
4359
4360static int softnet_seq_show(struct seq_file *seq, void *v)
4361{
4362 struct softnet_data *sd = v;
4363
4364 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
4365 sd->processed, sd->dropped, sd->time_squeeze, 0,
4366 0, 0, 0, 0, /* was fastroute */
4367 sd->cpu_collision, sd->received_rps);
4368 return 0;
4369}
4370
4371static const struct seq_operations dev_seq_ops = {
4372 .start = dev_seq_start,
4373 .next = dev_seq_next,
4374 .stop = dev_seq_stop,
4375 .show = dev_seq_show,
4376};
4377
4378static int dev_seq_open(struct inode *inode, struct file *file)
4379{
4380 return seq_open_net(inode, file, &dev_seq_ops,
4381 sizeof(struct seq_net_private));
4382}
4383
4384static const struct file_operations dev_seq_fops = {
4385 .owner = THIS_MODULE,
4386 .open = dev_seq_open,
4387 .read = seq_read,
4388 .llseek = seq_lseek,
4389 .release = seq_release_net,
4390};
4391
4392static const struct seq_operations softnet_seq_ops = {
4393 .start = softnet_seq_start,
4394 .next = softnet_seq_next,
4395 .stop = softnet_seq_stop,
4396 .show = softnet_seq_show,
4397};
4398
4399static int softnet_seq_open(struct inode *inode, struct file *file)
4400{
4401 return seq_open(file, &softnet_seq_ops);
4402}
4403
4404static const struct file_operations softnet_seq_fops = {
4405 .owner = THIS_MODULE,
4406 .open = softnet_seq_open,
4407 .read = seq_read,
4408 .llseek = seq_lseek,
4409 .release = seq_release,
4410};
4411
4412static void *ptype_get_idx(loff_t pos)
4413{
4414 struct packet_type *pt = NULL;
4415 loff_t i = 0;
4416 int t;
4417
4418 list_for_each_entry_rcu(pt, &ptype_all, list) {
4419 if (i == pos)
4420 return pt;
4421 ++i;
4422 }
4423
4424 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
4425 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
4426 if (i == pos)
4427 return pt;
4428 ++i;
4429 }
4430 }
4431 return NULL;
4432}
4433
4434static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
4435 __acquires(RCU)
4436{
4437 rcu_read_lock();
4438 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
4439}
4440
4441static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4442{
4443 struct packet_type *pt;
4444 struct list_head *nxt;
4445 int hash;
4446
4447 ++*pos;
4448 if (v == SEQ_START_TOKEN)
4449 return ptype_get_idx(0);
4450
4451 pt = v;
4452 nxt = pt->list.next;
4453 if (pt->type == htons(ETH_P_ALL)) {
4454 if (nxt != &ptype_all)
4455 goto found;
4456 hash = 0;
4457 nxt = ptype_base[0].next;
4458 } else
4459 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
4460
4461 while (nxt == &ptype_base[hash]) {
4462 if (++hash >= PTYPE_HASH_SIZE)
4463 return NULL;
4464 nxt = ptype_base[hash].next;
4465 }
4466found:
4467 return list_entry(nxt, struct packet_type, list);
4468}
4469
4470static void ptype_seq_stop(struct seq_file *seq, void *v)
4471 __releases(RCU)
4472{
4473 rcu_read_unlock();
4474}
4475
4476static int ptype_seq_show(struct seq_file *seq, void *v)
4477{
4478 struct packet_type *pt = v;
4479
4480 if (v == SEQ_START_TOKEN)
4481 seq_puts(seq, "Type Device Function\n");
4482 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
4483 if (pt->type == htons(ETH_P_ALL))
4484 seq_puts(seq, "ALL ");
4485 else
4486 seq_printf(seq, "%04x", ntohs(pt->type));
4487
4488 seq_printf(seq, " %-8s %pF\n",
4489 pt->dev ? pt->dev->name : "", pt->func);
4490 }
4491
4492 return 0;
4493}
4494
4495static const struct seq_operations ptype_seq_ops = {
4496 .start = ptype_seq_start,
4497 .next = ptype_seq_next,
4498 .stop = ptype_seq_stop,
4499 .show = ptype_seq_show,
4500};
4501
4502static int ptype_seq_open(struct inode *inode, struct file *file)
4503{
4504 return seq_open_net(inode, file, &ptype_seq_ops,
4505 sizeof(struct seq_net_private));
4506}
4507
4508static const struct file_operations ptype_seq_fops = {
4509 .owner = THIS_MODULE,
4510 .open = ptype_seq_open,
4511 .read = seq_read,
4512 .llseek = seq_lseek,
4513 .release = seq_release_net,
4514};
4515
4516
4517static int __net_init dev_proc_net_init(struct net *net)
4518{
4519 int rc = -ENOMEM;
4520
4521 if (!proc_create("dev", S_IRUGO, net->proc_net, &dev_seq_fops))
4522 goto out;
4523 if (!proc_create("softnet_stat", S_IRUGO, net->proc_net,
4524 &softnet_seq_fops))
4525 goto out_dev;
4526 if (!proc_create("ptype", S_IRUGO, net->proc_net, &ptype_seq_fops))
4527 goto out_softnet;
4528
4529 if (wext_proc_init(net))
4530 goto out_ptype;
4531 rc = 0;
4532out:
4533 return rc;
4534out_ptype:
4535 remove_proc_entry("ptype", net->proc_net);
4536out_softnet:
4537 remove_proc_entry("softnet_stat", net->proc_net);
4538out_dev:
4539 remove_proc_entry("dev", net->proc_net);
4540 goto out;
4541}
4542
4543static void __net_exit dev_proc_net_exit(struct net *net)
4544{
4545 wext_proc_exit(net);
4546
4547 remove_proc_entry("ptype", net->proc_net);
4548 remove_proc_entry("softnet_stat", net->proc_net);
4549 remove_proc_entry("dev", net->proc_net);
4550}
4551
4552static struct pernet_operations __net_initdata dev_proc_ops = {
4553 .init = dev_proc_net_init,
4554 .exit = dev_proc_net_exit,
4555};
4556
4557static int __init dev_proc_init(void)
4558{
4559 return register_pernet_subsys(&dev_proc_ops);
4560}
4561#else
4562#define dev_proc_init() 0
4563#endif /* CONFIG_PROC_FS */
4564
4565
4566struct netdev_upper { 4186struct netdev_upper {
4567 struct net_device *dev; 4187 struct net_device *dev;
4568 bool master; 4188 bool master;
diff --git a/net/core/dev_addr_lists.c b/net/core/dev_addr_lists.c
index 89562529df45..bd2eb9d3e369 100644
--- a/net/core/dev_addr_lists.c
+++ b/net/core/dev_addr_lists.c
@@ -15,7 +15,6 @@
15#include <linux/rtnetlink.h> 15#include <linux/rtnetlink.h>
16#include <linux/export.h> 16#include <linux/export.h>
17#include <linux/list.h> 17#include <linux/list.h>
18#include <linux/proc_fs.h>
19 18
20/* 19/*
21 * General list handling functions 20 * General list handling functions
@@ -727,76 +726,3 @@ void dev_mc_init(struct net_device *dev)
727 __hw_addr_init(&dev->mc); 726 __hw_addr_init(&dev->mc);
728} 727}
729EXPORT_SYMBOL(dev_mc_init); 728EXPORT_SYMBOL(dev_mc_init);
730
731#ifdef CONFIG_PROC_FS
732#include <linux/seq_file.h>
733
734static int dev_mc_seq_show(struct seq_file *seq, void *v)
735{
736 struct netdev_hw_addr *ha;
737 struct net_device *dev = v;
738
739 if (v == SEQ_START_TOKEN)
740 return 0;
741
742 netif_addr_lock_bh(dev);
743 netdev_for_each_mc_addr(ha, dev) {
744 int i;
745
746 seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
747 dev->name, ha->refcount, ha->global_use);
748
749 for (i = 0; i < dev->addr_len; i++)
750 seq_printf(seq, "%02x", ha->addr[i]);
751
752 seq_putc(seq, '\n');
753 }
754 netif_addr_unlock_bh(dev);
755 return 0;
756}
757
758static const struct seq_operations dev_mc_seq_ops = {
759 .start = dev_seq_start,
760 .next = dev_seq_next,
761 .stop = dev_seq_stop,
762 .show = dev_mc_seq_show,
763};
764
765static int dev_mc_seq_open(struct inode *inode, struct file *file)
766{
767 return seq_open_net(inode, file, &dev_mc_seq_ops,
768 sizeof(struct seq_net_private));
769}
770
771static const struct file_operations dev_mc_seq_fops = {
772 .owner = THIS_MODULE,
773 .open = dev_mc_seq_open,
774 .read = seq_read,
775 .llseek = seq_lseek,
776 .release = seq_release_net,
777};
778
779#endif
780
781static int __net_init dev_mc_net_init(struct net *net)
782{
783 if (!proc_create("dev_mcast", 0, net->proc_net, &dev_mc_seq_fops))
784 return -ENOMEM;
785 return 0;
786}
787
788static void __net_exit dev_mc_net_exit(struct net *net)
789{
790 remove_proc_entry("dev_mcast", net->proc_net);
791}
792
793static struct pernet_operations __net_initdata dev_mc_net_ops = {
794 .init = dev_mc_net_init,
795 .exit = dev_mc_net_exit,
796};
797
798void __init dev_mcast_init(void)
799{
800 register_pernet_subsys(&dev_mc_net_ops);
801}
802
diff --git a/net/core/net-procfs.c b/net/core/net-procfs.c
new file mode 100644
index 000000000000..ac87066491e9
--- /dev/null
+++ b/net/core/net-procfs.c
@@ -0,0 +1,414 @@
1#include <linux/netdevice.h>
2#include <linux/proc_fs.h>
3#include <linux/seq_file.h>
4#include <net/wext.h>
5
6#define BUCKET_SPACE (32 - NETDEV_HASHBITS - 1)
7
8#define get_bucket(x) ((x) >> BUCKET_SPACE)
9#define get_offset(x) ((x) & ((1 << BUCKET_SPACE) - 1))
10#define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
11
12extern struct list_head ptype_all __read_mostly;
13extern struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
14
15static inline struct net_device *dev_from_same_bucket(struct seq_file *seq, loff_t *pos)
16{
17 struct net *net = seq_file_net(seq);
18 struct net_device *dev;
19 struct hlist_node *p;
20 struct hlist_head *h;
21 unsigned int count = 0, offset = get_offset(*pos);
22
23 h = &net->dev_name_head[get_bucket(*pos)];
24 hlist_for_each_entry_rcu(dev, p, h, name_hlist) {
25 if (++count == offset)
26 return dev;
27 }
28
29 return NULL;
30}
31
32static inline struct net_device *dev_from_bucket(struct seq_file *seq, loff_t *pos)
33{
34 struct net_device *dev;
35 unsigned int bucket;
36
37 do {
38 dev = dev_from_same_bucket(seq, pos);
39 if (dev)
40 return dev;
41
42 bucket = get_bucket(*pos) + 1;
43 *pos = set_bucket_offset(bucket, 1);
44 } while (bucket < NETDEV_HASHENTRIES);
45
46 return NULL;
47}
48
49/*
50 * This is invoked by the /proc filesystem handler to display a device
51 * in detail.
52 */
53static void *dev_seq_start(struct seq_file *seq, loff_t *pos)
54 __acquires(RCU)
55{
56 rcu_read_lock();
57 if (!*pos)
58 return SEQ_START_TOKEN;
59
60 if (get_bucket(*pos) >= NETDEV_HASHENTRIES)
61 return NULL;
62
63 return dev_from_bucket(seq, pos);
64}
65
66static void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
67{
68 ++*pos;
69 return dev_from_bucket(seq, pos);
70}
71
72static void dev_seq_stop(struct seq_file *seq, void *v)
73 __releases(RCU)
74{
75 rcu_read_unlock();
76}
77
78static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
79{
80 struct rtnl_link_stats64 temp;
81 const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
82
83 seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu "
84 "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n",
85 dev->name, stats->rx_bytes, stats->rx_packets,
86 stats->rx_errors,
87 stats->rx_dropped + stats->rx_missed_errors,
88 stats->rx_fifo_errors,
89 stats->rx_length_errors + stats->rx_over_errors +
90 stats->rx_crc_errors + stats->rx_frame_errors,
91 stats->rx_compressed, stats->multicast,
92 stats->tx_bytes, stats->tx_packets,
93 stats->tx_errors, stats->tx_dropped,
94 stats->tx_fifo_errors, stats->collisions,
95 stats->tx_carrier_errors +
96 stats->tx_aborted_errors +
97 stats->tx_window_errors +
98 stats->tx_heartbeat_errors,
99 stats->tx_compressed);
100}
101
102/*
103 * Called from the PROCfs module. This now uses the new arbitrary sized
104 * /proc/net interface to create /proc/net/dev
105 */
106static int dev_seq_show(struct seq_file *seq, void *v)
107{
108 if (v == SEQ_START_TOKEN)
109 seq_puts(seq, "Inter-| Receive "
110 " | Transmit\n"
111 " face |bytes packets errs drop fifo frame "
112 "compressed multicast|bytes packets errs "
113 "drop fifo colls carrier compressed\n");
114 else
115 dev_seq_printf_stats(seq, v);
116 return 0;
117}
118
119static struct softnet_data *softnet_get_online(loff_t *pos)
120{
121 struct softnet_data *sd = NULL;
122
123 while (*pos < nr_cpu_ids)
124 if (cpu_online(*pos)) {
125 sd = &per_cpu(softnet_data, *pos);
126 break;
127 } else
128 ++*pos;
129 return sd;
130}
131
132static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
133{
134 return softnet_get_online(pos);
135}
136
137static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
138{
139 ++*pos;
140 return softnet_get_online(pos);
141}
142
143static void softnet_seq_stop(struct seq_file *seq, void *v)
144{
145}
146
147static int softnet_seq_show(struct seq_file *seq, void *v)
148{
149 struct softnet_data *sd = v;
150
151 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
152 sd->processed, sd->dropped, sd->time_squeeze, 0,
153 0, 0, 0, 0, /* was fastroute */
154 sd->cpu_collision, sd->received_rps);
155 return 0;
156}
157
158static const struct seq_operations dev_seq_ops = {
159 .start = dev_seq_start,
160 .next = dev_seq_next,
161 .stop = dev_seq_stop,
162 .show = dev_seq_show,
163};
164
165static int dev_seq_open(struct inode *inode, struct file *file)
166{
167 return seq_open_net(inode, file, &dev_seq_ops,
168 sizeof(struct seq_net_private));
169}
170
171static const struct file_operations dev_seq_fops = {
172 .owner = THIS_MODULE,
173 .open = dev_seq_open,
174 .read = seq_read,
175 .llseek = seq_lseek,
176 .release = seq_release_net,
177};
178
179static const struct seq_operations softnet_seq_ops = {
180 .start = softnet_seq_start,
181 .next = softnet_seq_next,
182 .stop = softnet_seq_stop,
183 .show = softnet_seq_show,
184};
185
186static int softnet_seq_open(struct inode *inode, struct file *file)
187{
188 return seq_open(file, &softnet_seq_ops);
189}
190
191static const struct file_operations softnet_seq_fops = {
192 .owner = THIS_MODULE,
193 .open = softnet_seq_open,
194 .read = seq_read,
195 .llseek = seq_lseek,
196 .release = seq_release,
197};
198
199static void *ptype_get_idx(loff_t pos)
200{
201 struct packet_type *pt = NULL;
202 loff_t i = 0;
203 int t;
204
205 list_for_each_entry_rcu(pt, &ptype_all, list) {
206 if (i == pos)
207 return pt;
208 ++i;
209 }
210
211 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
212 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
213 if (i == pos)
214 return pt;
215 ++i;
216 }
217 }
218 return NULL;
219}
220
221static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
222 __acquires(RCU)
223{
224 rcu_read_lock();
225 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
226}
227
228static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
229{
230 struct packet_type *pt;
231 struct list_head *nxt;
232 int hash;
233
234 ++*pos;
235 if (v == SEQ_START_TOKEN)
236 return ptype_get_idx(0);
237
238 pt = v;
239 nxt = pt->list.next;
240 if (pt->type == htons(ETH_P_ALL)) {
241 if (nxt != &ptype_all)
242 goto found;
243 hash = 0;
244 nxt = ptype_base[0].next;
245 } else
246 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
247
248 while (nxt == &ptype_base[hash]) {
249 if (++hash >= PTYPE_HASH_SIZE)
250 return NULL;
251 nxt = ptype_base[hash].next;
252 }
253found:
254 return list_entry(nxt, struct packet_type, list);
255}
256
257static void ptype_seq_stop(struct seq_file *seq, void *v)
258 __releases(RCU)
259{
260 rcu_read_unlock();
261}
262
263static int ptype_seq_show(struct seq_file *seq, void *v)
264{
265 struct packet_type *pt = v;
266
267 if (v == SEQ_START_TOKEN)
268 seq_puts(seq, "Type Device Function\n");
269 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
270 if (pt->type == htons(ETH_P_ALL))
271 seq_puts(seq, "ALL ");
272 else
273 seq_printf(seq, "%04x", ntohs(pt->type));
274
275 seq_printf(seq, " %-8s %pF\n",
276 pt->dev ? pt->dev->name : "", pt->func);
277 }
278
279 return 0;
280}
281
282static const struct seq_operations ptype_seq_ops = {
283 .start = ptype_seq_start,
284 .next = ptype_seq_next,
285 .stop = ptype_seq_stop,
286 .show = ptype_seq_show,
287};
288
289static int ptype_seq_open(struct inode *inode, struct file *file)
290{
291 return seq_open_net(inode, file, &ptype_seq_ops,
292 sizeof(struct seq_net_private));
293}
294
295static const struct file_operations ptype_seq_fops = {
296 .owner = THIS_MODULE,
297 .open = ptype_seq_open,
298 .read = seq_read,
299 .llseek = seq_lseek,
300 .release = seq_release_net,
301};
302
303
304static int __net_init dev_proc_net_init(struct net *net)
305{
306 int rc = -ENOMEM;
307
308 if (!proc_create("dev", S_IRUGO, net->proc_net, &dev_seq_fops))
309 goto out;
310 if (!proc_create("softnet_stat", S_IRUGO, net->proc_net,
311 &softnet_seq_fops))
312 goto out_dev;
313 if (!proc_create("ptype", S_IRUGO, net->proc_net, &ptype_seq_fops))
314 goto out_softnet;
315
316 if (wext_proc_init(net))
317 goto out_ptype;
318 rc = 0;
319out:
320 return rc;
321out_ptype:
322 remove_proc_entry("ptype", net->proc_net);
323out_softnet:
324 remove_proc_entry("softnet_stat", net->proc_net);
325out_dev:
326 remove_proc_entry("dev", net->proc_net);
327 goto out;
328}
329
330static void __net_exit dev_proc_net_exit(struct net *net)
331{
332 wext_proc_exit(net);
333
334 remove_proc_entry("ptype", net->proc_net);
335 remove_proc_entry("softnet_stat", net->proc_net);
336 remove_proc_entry("dev", net->proc_net);
337}
338
339static struct pernet_operations __net_initdata dev_proc_ops = {
340 .init = dev_proc_net_init,
341 .exit = dev_proc_net_exit,
342};
343
344int __init dev_proc_init(void)
345{
346 return register_pernet_subsys(&dev_proc_ops);
347}
348
349static int dev_mc_seq_show(struct seq_file *seq, void *v)
350{
351 struct netdev_hw_addr *ha;
352 struct net_device *dev = v;
353
354 if (v == SEQ_START_TOKEN)
355 return 0;
356
357 netif_addr_lock_bh(dev);
358 netdev_for_each_mc_addr(ha, dev) {
359 int i;
360
361 seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
362 dev->name, ha->refcount, ha->global_use);
363
364 for (i = 0; i < dev->addr_len; i++)
365 seq_printf(seq, "%02x", ha->addr[i]);
366
367 seq_putc(seq, '\n');
368 }
369 netif_addr_unlock_bh(dev);
370 return 0;
371}
372
373static const struct seq_operations dev_mc_seq_ops = {
374 .start = dev_seq_start,
375 .next = dev_seq_next,
376 .stop = dev_seq_stop,
377 .show = dev_mc_seq_show,
378};
379
380static int dev_mc_seq_open(struct inode *inode, struct file *file)
381{
382 return seq_open_net(inode, file, &dev_mc_seq_ops,
383 sizeof(struct seq_net_private));
384}
385
386static const struct file_operations dev_mc_seq_fops = {
387 .owner = THIS_MODULE,
388 .open = dev_mc_seq_open,
389 .read = seq_read,
390 .llseek = seq_lseek,
391 .release = seq_release_net,
392};
393
394static int __net_init dev_mc_net_init(struct net *net)
395{
396 if (!proc_create("dev_mcast", 0, net->proc_net, &dev_mc_seq_fops))
397 return -ENOMEM;
398 return 0;
399}
400
401static void __net_exit dev_mc_net_exit(struct net *net)
402{
403 remove_proc_entry("dev_mcast", net->proc_net);
404}
405
406static struct pernet_operations __net_initdata dev_mc_net_ops = {
407 .init = dev_mc_net_init,
408 .exit = dev_mc_net_exit,
409};
410
411void __init dev_mcast_init(void)
412{
413 register_pernet_subsys(&dev_mc_net_ops);
414}
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-13 17:08:23 -0400