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

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

Version: ~ [ linux-5.16-rc1 ] ~ [ linux-5.15.2 ] ~ [ linux-5.14.18 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.79 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.159 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.217 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.255 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.290 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.292 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ 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 int dev_seq_open(struct inode *inode, struct file *file)
179 {
180         return seq_open_net(inode, file, &dev_seq_ops,
181                             sizeof(struct seq_net_private));
182 }
183 
184 static const struct file_operations dev_seq_fops = {
185         .open    = dev_seq_open,
186         .read    = seq_read,
187         .llseek  = seq_lseek,
188         .release = seq_release_net,
189 };
190 
191 static const struct seq_operations softnet_seq_ops = {
192         .start = softnet_seq_start,
193         .next  = softnet_seq_next,
194         .stop  = softnet_seq_stop,
195         .show  = softnet_seq_show,
196 };
197 
198 static int softnet_seq_open(struct inode *inode, struct file *file)
199 {
200         return seq_open(file, &softnet_seq_ops);
201 }
202 
203 static const struct file_operations softnet_seq_fops = {
204         .open    = softnet_seq_open,
205         .read    = seq_read,
206         .llseek  = seq_lseek,
207         .release = seq_release,
208 };
209 
210 static void *ptype_get_idx(loff_t pos)
211 {
212         struct packet_type *pt = NULL;
213         loff_t i = 0;
214         int t;
215 
216         list_for_each_entry_rcu(pt, &ptype_all, list) {
217                 if (i == pos)
218                         return pt;
219                 ++i;
220         }
221 
222         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
223                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
224                         if (i == pos)
225                                 return pt;
226                         ++i;
227                 }
228         }
229         return NULL;
230 }
231 
232 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
233         __acquires(RCU)
234 {
235         rcu_read_lock();
236         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
237 }
238 
239 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
240 {
241         struct packet_type *pt;
242         struct list_head *nxt;
243         int hash;
244 
245         ++*pos;
246         if (v == SEQ_START_TOKEN)
247                 return ptype_get_idx(0);
248 
249         pt = v;
250         nxt = pt->list.next;
251         if (pt->type == htons(ETH_P_ALL)) {
252                 if (nxt != &ptype_all)
253                         goto found;
254                 hash = 0;
255                 nxt = ptype_base[0].next;
256         } else
257                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
258 
259         while (nxt == &ptype_base[hash]) {
260                 if (++hash >= PTYPE_HASH_SIZE)
261                         return NULL;
262                 nxt = ptype_base[hash].next;
263         }
264 found:
265         return list_entry(nxt, struct packet_type, list);
266 }
267 
268 static void ptype_seq_stop(struct seq_file *seq, void *v)
269         __releases(RCU)
270 {
271         rcu_read_unlock();
272 }
273 
274 static int ptype_seq_show(struct seq_file *seq, void *v)
275 {
276         struct packet_type *pt = v;
277 
278         if (v == SEQ_START_TOKEN)
279                 seq_puts(seq, "Type Device      Function\n");
280         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
281                 if (pt->type == htons(ETH_P_ALL))
282                         seq_puts(seq, "ALL ");
283                 else
284                         seq_printf(seq, "%04x", ntohs(pt->type));
285 
286                 seq_printf(seq, " %-8s %pf\n",
287                            pt->dev ? pt->dev->name : "", pt->func);
288         }
289 
290         return 0;
291 }
292 
293 static const struct seq_operations ptype_seq_ops = {
294         .start = ptype_seq_start,
295         .next  = ptype_seq_next,
296         .stop  = ptype_seq_stop,
297         .show  = ptype_seq_show,
298 };
299 
300 static int ptype_seq_open(struct inode *inode, struct file *file)
301 {
302         return seq_open_net(inode, file, &ptype_seq_ops,
303                         sizeof(struct seq_net_private));
304 }
305 
306 static const struct file_operations ptype_seq_fops = {
307         .open    = ptype_seq_open,
308         .read    = seq_read,
309         .llseek  = seq_lseek,
310         .release = seq_release_net,
311 };
312 
313 
314 static int __net_init dev_proc_net_init(struct net *net)
315 {
316         int rc = -ENOMEM;
317 
318         if (!proc_create("dev", 0444, net->proc_net, &dev_seq_fops))
319                 goto out;
320         if (!proc_create("softnet_stat", 0444, net->proc_net,
321                          &softnet_seq_fops))
322                 goto out_dev;
323         if (!proc_create("ptype", 0444, net->proc_net, &ptype_seq_fops))
324                 goto out_softnet;
325 
326         if (wext_proc_init(net))
327                 goto out_ptype;
328         rc = 0;
329 out:
330         return rc;
331 out_ptype:
332         remove_proc_entry("ptype", net->proc_net);
333 out_softnet:
334         remove_proc_entry("softnet_stat", net->proc_net);
335 out_dev:
336         remove_proc_entry("dev", net->proc_net);
337         goto out;
338 }
339 
340 static void __net_exit dev_proc_net_exit(struct net *net)
341 {
342         wext_proc_exit(net);
343 
344         remove_proc_entry("ptype", net->proc_net);
345         remove_proc_entry("softnet_stat", net->proc_net);
346         remove_proc_entry("dev", net->proc_net);
347 }
348 
349 static struct pernet_operations __net_initdata dev_proc_ops = {
350         .init = dev_proc_net_init,
351         .exit = dev_proc_net_exit,
352 };
353 
354 static int dev_mc_seq_show(struct seq_file *seq, void *v)
355 {
356         struct netdev_hw_addr *ha;
357         struct net_device *dev = v;
358 
359         if (v == SEQ_START_TOKEN)
360                 return 0;
361 
362         netif_addr_lock_bh(dev);
363         netdev_for_each_mc_addr(ha, dev) {
364                 seq_printf(seq, "%-4d %-15s %-5d %-5d %*phN\n",
365                            dev->ifindex, dev->name,
366                            ha->refcount, ha->global_use,
367                            (int)dev->addr_len, ha->addr);
368         }
369         netif_addr_unlock_bh(dev);
370         return 0;
371 }
372 
373 static 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 
380 static 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 
386 static const struct file_operations dev_mc_seq_fops = {
387         .open    = dev_mc_seq_open,
388         .read    = seq_read,
389         .llseek  = seq_lseek,
390         .release = seq_release_net,
391 };
392 
393 static int __net_init dev_mc_net_init(struct net *net)
394 {
395         if (!proc_create("dev_mcast", 0, net->proc_net, &dev_mc_seq_fops))
396                 return -ENOMEM;
397         return 0;
398 }
399 
400 static void __net_exit dev_mc_net_exit(struct net *net)
401 {
402         remove_proc_entry("dev_mcast", net->proc_net);
403 }
404 
405 static struct pernet_operations __net_initdata dev_mc_net_ops = {
406         .init = dev_mc_net_init,
407         .exit = dev_mc_net_exit,
408 };
409 
410 int __init dev_proc_init(void)
411 {
412         int ret = register_pernet_subsys(&dev_proc_ops);
413         if (!ret)
414                 return register_pernet_subsys(&dev_mc_net_ops);
415         return ret;
416 }
417 

~ [ 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