~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/core/net-procfs.c

Version: ~ [ linux-4.20-rc6 ] ~ [ linux-4.19.8 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.87 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.144 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.166 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.128 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.61 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
368 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp