GNU Linux-libre 4.19.211-gnu1
[releases.git] / net / core / net-procfs.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/netdevice.h>
3 #include <linux/proc_fs.h>
4 #include <linux/seq_file.h>
5 #include <net/wext.h>
6
7 #define BUCKET_SPACE (32 - NETDEV_HASHBITS - 1)
8
9 #define get_bucket(x) ((x) >> BUCKET_SPACE)
10 #define get_offset(x) ((x) & ((1 << BUCKET_SPACE) - 1))
11 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
12
13 extern struct list_head ptype_all __read_mostly;
14 extern struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
15
16 static inline struct net_device *dev_from_same_bucket(struct seq_file *seq, loff_t *pos)
17 {
18         struct net *net = seq_file_net(seq);
19         struct net_device *dev;
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, h, name_hlist) {
25                 if (++count == offset)
26                         return dev;
27         }
28
29         return NULL;
30 }
31
32 static 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  */
53 static 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
66 static 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
72 static void dev_seq_stop(struct seq_file *seq, void *v)
73         __releases(RCU)
74 {
75         rcu_read_unlock();
76 }
77
78 static 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  */
106 static 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
119 static 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
132 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
133 {
134         return softnet_get_online(pos);
135 }
136
137 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
138 {
139         ++*pos;
140         return softnet_get_online(pos);
141 }
142
143 static void softnet_seq_stop(struct seq_file *seq, void *v)
144 {
145 }
146
147 static int softnet_seq_show(struct seq_file *seq, void *v)
148 {
149         struct softnet_data *sd = v;
150         unsigned int flow_limit_count = 0;
151
152 #ifdef CONFIG_NET_FLOW_LIMIT
153         struct sd_flow_limit *fl;
154
155         rcu_read_lock();
156         fl = rcu_dereference(sd->flow_limit);
157         if (fl)
158                 flow_limit_count = fl->count;
159         rcu_read_unlock();
160 #endif
161
162         seq_printf(seq,
163                    "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
164                    sd->processed, sd->dropped, sd->time_squeeze, 0,
165                    0, 0, 0, 0, /* was fastroute */
166                    0,   /* was cpu_collision */
167                    sd->received_rps, flow_limit_count);
168         return 0;
169 }
170
171 static const struct seq_operations dev_seq_ops = {
172         .start = dev_seq_start,
173         .next  = dev_seq_next,
174         .stop  = dev_seq_stop,
175         .show  = dev_seq_show,
176 };
177
178 static const struct seq_operations softnet_seq_ops = {
179         .start = softnet_seq_start,
180         .next  = softnet_seq_next,
181         .stop  = softnet_seq_stop,
182         .show  = softnet_seq_show,
183 };
184
185 static void *ptype_get_idx(loff_t pos)
186 {
187         struct packet_type *pt = NULL;
188         loff_t i = 0;
189         int t;
190
191         list_for_each_entry_rcu(pt, &ptype_all, list) {
192                 if (i == pos)
193                         return pt;
194                 ++i;
195         }
196
197         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
198                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
199                         if (i == pos)
200                                 return pt;
201                         ++i;
202                 }
203         }
204         return NULL;
205 }
206
207 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
208         __acquires(RCU)
209 {
210         rcu_read_lock();
211         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
212 }
213
214 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
215 {
216         struct packet_type *pt;
217         struct list_head *nxt;
218         int hash;
219
220         ++*pos;
221         if (v == SEQ_START_TOKEN)
222                 return ptype_get_idx(0);
223
224         pt = v;
225         nxt = pt->list.next;
226         if (pt->type == htons(ETH_P_ALL)) {
227                 if (nxt != &ptype_all)
228                         goto found;
229                 hash = 0;
230                 nxt = ptype_base[0].next;
231         } else
232                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
233
234         while (nxt == &ptype_base[hash]) {
235                 if (++hash >= PTYPE_HASH_SIZE)
236                         return NULL;
237                 nxt = ptype_base[hash].next;
238         }
239 found:
240         return list_entry(nxt, struct packet_type, list);
241 }
242
243 static void ptype_seq_stop(struct seq_file *seq, void *v)
244         __releases(RCU)
245 {
246         rcu_read_unlock();
247 }
248
249 static int ptype_seq_show(struct seq_file *seq, void *v)
250 {
251         struct packet_type *pt = v;
252
253         if (v == SEQ_START_TOKEN)
254                 seq_puts(seq, "Type Device      Function\n");
255         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
256                 if (pt->type == htons(ETH_P_ALL))
257                         seq_puts(seq, "ALL ");
258                 else
259                         seq_printf(seq, "%04x", ntohs(pt->type));
260
261                 seq_printf(seq, " %-8s %pf\n",
262                            pt->dev ? pt->dev->name : "", pt->func);
263         }
264
265         return 0;
266 }
267
268 static const struct seq_operations ptype_seq_ops = {
269         .start = ptype_seq_start,
270         .next  = ptype_seq_next,
271         .stop  = ptype_seq_stop,
272         .show  = ptype_seq_show,
273 };
274
275 static int __net_init dev_proc_net_init(struct net *net)
276 {
277         int rc = -ENOMEM;
278
279         if (!proc_create_net("dev", 0444, net->proc_net, &dev_seq_ops,
280                         sizeof(struct seq_net_private)))
281                 goto out;
282         if (!proc_create_seq("softnet_stat", 0444, net->proc_net,
283                          &softnet_seq_ops))
284                 goto out_dev;
285         if (!proc_create_net("ptype", 0444, net->proc_net, &ptype_seq_ops,
286                         sizeof(struct seq_net_private)))
287                 goto out_softnet;
288
289         if (wext_proc_init(net))
290                 goto out_ptype;
291         rc = 0;
292 out:
293         return rc;
294 out_ptype:
295         remove_proc_entry("ptype", net->proc_net);
296 out_softnet:
297         remove_proc_entry("softnet_stat", net->proc_net);
298 out_dev:
299         remove_proc_entry("dev", net->proc_net);
300         goto out;
301 }
302
303 static void __net_exit dev_proc_net_exit(struct net *net)
304 {
305         wext_proc_exit(net);
306
307         remove_proc_entry("ptype", net->proc_net);
308         remove_proc_entry("softnet_stat", net->proc_net);
309         remove_proc_entry("dev", net->proc_net);
310 }
311
312 static struct pernet_operations __net_initdata dev_proc_ops = {
313         .init = dev_proc_net_init,
314         .exit = dev_proc_net_exit,
315 };
316
317 static int dev_mc_seq_show(struct seq_file *seq, void *v)
318 {
319         struct netdev_hw_addr *ha;
320         struct net_device *dev = v;
321
322         if (v == SEQ_START_TOKEN)
323                 return 0;
324
325         netif_addr_lock_bh(dev);
326         netdev_for_each_mc_addr(ha, dev) {
327                 seq_printf(seq, "%-4d %-15s %-5d %-5d %*phN\n",
328                            dev->ifindex, dev->name,
329                            ha->refcount, ha->global_use,
330                            (int)dev->addr_len, ha->addr);
331         }
332         netif_addr_unlock_bh(dev);
333         return 0;
334 }
335
336 static const struct seq_operations dev_mc_seq_ops = {
337         .start = dev_seq_start,
338         .next  = dev_seq_next,
339         .stop  = dev_seq_stop,
340         .show  = dev_mc_seq_show,
341 };
342
343 static int __net_init dev_mc_net_init(struct net *net)
344 {
345         if (!proc_create_net("dev_mcast", 0, net->proc_net, &dev_mc_seq_ops,
346                         sizeof(struct seq_net_private)))
347                 return -ENOMEM;
348         return 0;
349 }
350
351 static void __net_exit dev_mc_net_exit(struct net *net)
352 {
353         remove_proc_entry("dev_mcast", net->proc_net);
354 }
355
356 static struct pernet_operations __net_initdata dev_mc_net_ops = {
357         .init = dev_mc_net_init,
358         .exit = dev_mc_net_exit,
359 };
360
361 int __init dev_proc_init(void)
362 {
363         int ret = register_pernet_subsys(&dev_proc_ops);
364         if (!ret)
365                 return register_pernet_subsys(&dev_mc_net_ops);
366         return ret;
367 }