]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/can/proc.c
Merge tag 'for-linus-4.12-ofs-1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[mirror_ubuntu-bionic-kernel.git] / net / can / proc.c
1 /*
2 * proc.c - procfs support for Protocol family CAN core module
3 *
4 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of Volkswagen nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * Alternatively, provided that this notice is retained in full, this
20 * software may be distributed under the terms of the GNU General
21 * Public License ("GPL") version 2, in which case the provisions of the
22 * GPL apply INSTEAD OF those given above.
23 *
24 * The provided data structures and external interfaces from this code
25 * are not restricted to be used by modules with a GPL compatible license.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
38 * DAMAGE.
39 *
40 */
41
42 #include <linux/module.h>
43 #include <linux/proc_fs.h>
44 #include <linux/list.h>
45 #include <linux/rcupdate.h>
46 #include <linux/if_arp.h>
47 #include <linux/can/core.h>
48
49 #include "af_can.h"
50
51 /*
52 * proc filenames for the PF_CAN core
53 */
54
55 #define CAN_PROC_VERSION "version"
56 #define CAN_PROC_STATS "stats"
57 #define CAN_PROC_RESET_STATS "reset_stats"
58 #define CAN_PROC_RCVLIST_ALL "rcvlist_all"
59 #define CAN_PROC_RCVLIST_FIL "rcvlist_fil"
60 #define CAN_PROC_RCVLIST_INV "rcvlist_inv"
61 #define CAN_PROC_RCVLIST_SFF "rcvlist_sff"
62 #define CAN_PROC_RCVLIST_EFF "rcvlist_eff"
63 #define CAN_PROC_RCVLIST_ERR "rcvlist_err"
64
65 static int user_reset;
66
67 static const char rx_list_name[][8] = {
68 [RX_ERR] = "rx_err",
69 [RX_ALL] = "rx_all",
70 [RX_FIL] = "rx_fil",
71 [RX_INV] = "rx_inv",
72 };
73
74 /*
75 * af_can statistics stuff
76 */
77
78 static void can_init_stats(struct net *net)
79 {
80 struct s_stats *can_stats = net->can.can_stats;
81 struct s_pstats *can_pstats = net->can.can_pstats;
82 /*
83 * This memset function is called from a timer context (when
84 * can_stattimer is active which is the default) OR in a process
85 * context (reading the proc_fs when can_stattimer is disabled).
86 */
87 memset(can_stats, 0, sizeof(struct s_stats));
88 can_stats->jiffies_init = jiffies;
89
90 can_pstats->stats_reset++;
91
92 if (user_reset) {
93 user_reset = 0;
94 can_pstats->user_reset++;
95 }
96 }
97
98 static unsigned long calc_rate(unsigned long oldjif, unsigned long newjif,
99 unsigned long count)
100 {
101 unsigned long rate;
102
103 if (oldjif == newjif)
104 return 0;
105
106 /* see can_stat_update() - this should NEVER happen! */
107 if (count > (ULONG_MAX / HZ)) {
108 printk(KERN_ERR "can: calc_rate: count exceeded! %ld\n",
109 count);
110 return 99999999;
111 }
112
113 rate = (count * HZ) / (newjif - oldjif);
114
115 return rate;
116 }
117
118 void can_stat_update(unsigned long data)
119 {
120 struct net *net = (struct net *)data;
121 struct s_stats *can_stats = net->can.can_stats;
122 unsigned long j = jiffies; /* snapshot */
123
124 /* restart counting in timer context on user request */
125 if (user_reset)
126 can_init_stats(net);
127
128 /* restart counting on jiffies overflow */
129 if (j < can_stats->jiffies_init)
130 can_init_stats(net);
131
132 /* prevent overflow in calc_rate() */
133 if (can_stats->rx_frames > (ULONG_MAX / HZ))
134 can_init_stats(net);
135
136 /* prevent overflow in calc_rate() */
137 if (can_stats->tx_frames > (ULONG_MAX / HZ))
138 can_init_stats(net);
139
140 /* matches overflow - very improbable */
141 if (can_stats->matches > (ULONG_MAX / 100))
142 can_init_stats(net);
143
144 /* calc total values */
145 if (can_stats->rx_frames)
146 can_stats->total_rx_match_ratio = (can_stats->matches * 100) /
147 can_stats->rx_frames;
148
149 can_stats->total_tx_rate = calc_rate(can_stats->jiffies_init, j,
150 can_stats->tx_frames);
151 can_stats->total_rx_rate = calc_rate(can_stats->jiffies_init, j,
152 can_stats->rx_frames);
153
154 /* calc current values */
155 if (can_stats->rx_frames_delta)
156 can_stats->current_rx_match_ratio =
157 (can_stats->matches_delta * 100) /
158 can_stats->rx_frames_delta;
159
160 can_stats->current_tx_rate = calc_rate(0, HZ, can_stats->tx_frames_delta);
161 can_stats->current_rx_rate = calc_rate(0, HZ, can_stats->rx_frames_delta);
162
163 /* check / update maximum values */
164 if (can_stats->max_tx_rate < can_stats->current_tx_rate)
165 can_stats->max_tx_rate = can_stats->current_tx_rate;
166
167 if (can_stats->max_rx_rate < can_stats->current_rx_rate)
168 can_stats->max_rx_rate = can_stats->current_rx_rate;
169
170 if (can_stats->max_rx_match_ratio < can_stats->current_rx_match_ratio)
171 can_stats->max_rx_match_ratio = can_stats->current_rx_match_ratio;
172
173 /* clear values for 'current rate' calculation */
174 can_stats->tx_frames_delta = 0;
175 can_stats->rx_frames_delta = 0;
176 can_stats->matches_delta = 0;
177
178 /* restart timer (one second) */
179 mod_timer(&net->can.can_stattimer, round_jiffies(jiffies + HZ));
180 }
181
182 /*
183 * proc read functions
184 */
185
186 static void can_print_rcvlist(struct seq_file *m, struct hlist_head *rx_list,
187 struct net_device *dev)
188 {
189 struct receiver *r;
190
191 hlist_for_each_entry_rcu(r, rx_list, list) {
192 char *fmt = (r->can_id & CAN_EFF_FLAG)?
193 " %-5s %08x %08x %pK %pK %8ld %s\n" :
194 " %-5s %03x %08x %pK %pK %8ld %s\n";
195
196 seq_printf(m, fmt, DNAME(dev), r->can_id, r->mask,
197 r->func, r->data, r->matches, r->ident);
198 }
199 }
200
201 static void can_print_recv_banner(struct seq_file *m)
202 {
203 /*
204 * can1. 00000000 00000000 00000000
205 * ....... 0 tp20
206 */
207 seq_puts(m, " device can_id can_mask function"
208 " userdata matches ident\n");
209 }
210
211 static int can_stats_proc_show(struct seq_file *m, void *v)
212 {
213 struct net *net = m->private;
214 struct s_stats *can_stats = net->can.can_stats;
215 struct s_pstats *can_pstats = net->can.can_pstats;
216
217 seq_putc(m, '\n');
218 seq_printf(m, " %8ld transmitted frames (TXF)\n", can_stats->tx_frames);
219 seq_printf(m, " %8ld received frames (RXF)\n", can_stats->rx_frames);
220 seq_printf(m, " %8ld matched frames (RXMF)\n", can_stats->matches);
221
222 seq_putc(m, '\n');
223
224 if (net->can.can_stattimer.function == can_stat_update) {
225 seq_printf(m, " %8ld %% total match ratio (RXMR)\n",
226 can_stats->total_rx_match_ratio);
227
228 seq_printf(m, " %8ld frames/s total tx rate (TXR)\n",
229 can_stats->total_tx_rate);
230 seq_printf(m, " %8ld frames/s total rx rate (RXR)\n",
231 can_stats->total_rx_rate);
232
233 seq_putc(m, '\n');
234
235 seq_printf(m, " %8ld %% current match ratio (CRXMR)\n",
236 can_stats->current_rx_match_ratio);
237
238 seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n",
239 can_stats->current_tx_rate);
240 seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n",
241 can_stats->current_rx_rate);
242
243 seq_putc(m, '\n');
244
245 seq_printf(m, " %8ld %% max match ratio (MRXMR)\n",
246 can_stats->max_rx_match_ratio);
247
248 seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n",
249 can_stats->max_tx_rate);
250 seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n",
251 can_stats->max_rx_rate);
252
253 seq_putc(m, '\n');
254 }
255
256 seq_printf(m, " %8ld current receive list entries (CRCV)\n",
257 can_pstats->rcv_entries);
258 seq_printf(m, " %8ld maximum receive list entries (MRCV)\n",
259 can_pstats->rcv_entries_max);
260
261 if (can_pstats->stats_reset)
262 seq_printf(m, "\n %8ld statistic resets (STR)\n",
263 can_pstats->stats_reset);
264
265 if (can_pstats->user_reset)
266 seq_printf(m, " %8ld user statistic resets (USTR)\n",
267 can_pstats->user_reset);
268
269 seq_putc(m, '\n');
270 return 0;
271 }
272
273 static int can_stats_proc_open(struct inode *inode, struct file *file)
274 {
275 return single_open_net(inode, file, can_stats_proc_show);
276 }
277
278 static const struct file_operations can_stats_proc_fops = {
279 .owner = THIS_MODULE,
280 .open = can_stats_proc_open,
281 .read = seq_read,
282 .llseek = seq_lseek,
283 .release = single_release,
284 };
285
286 static int can_reset_stats_proc_show(struct seq_file *m, void *v)
287 {
288 struct net *net = m->private;
289 struct s_pstats *can_pstats = net->can.can_pstats;
290 struct s_stats *can_stats = net->can.can_stats;
291
292 user_reset = 1;
293
294 if (net->can.can_stattimer.function == can_stat_update) {
295 seq_printf(m, "Scheduled statistic reset #%ld.\n",
296 can_pstats->stats_reset + 1);
297 } else {
298 if (can_stats->jiffies_init != jiffies)
299 can_init_stats(net);
300
301 seq_printf(m, "Performed statistic reset #%ld.\n",
302 can_pstats->stats_reset);
303 }
304 return 0;
305 }
306
307 static int can_reset_stats_proc_open(struct inode *inode, struct file *file)
308 {
309 return single_open_net(inode, file, can_reset_stats_proc_show);
310 }
311
312 static const struct file_operations can_reset_stats_proc_fops = {
313 .owner = THIS_MODULE,
314 .open = can_reset_stats_proc_open,
315 .read = seq_read,
316 .llseek = seq_lseek,
317 .release = single_release,
318 };
319
320 static int can_version_proc_show(struct seq_file *m, void *v)
321 {
322 seq_printf(m, "%s\n", CAN_VERSION_STRING);
323 return 0;
324 }
325
326 static int can_version_proc_open(struct inode *inode, struct file *file)
327 {
328 return single_open_net(inode, file, can_version_proc_show);
329 }
330
331 static const struct file_operations can_version_proc_fops = {
332 .owner = THIS_MODULE,
333 .open = can_version_proc_open,
334 .read = seq_read,
335 .llseek = seq_lseek,
336 .release = single_release,
337 };
338
339 static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
340 struct net_device *dev,
341 struct dev_rcv_lists *d)
342 {
343 if (!hlist_empty(&d->rx[idx])) {
344 can_print_recv_banner(m);
345 can_print_rcvlist(m, &d->rx[idx], dev);
346 } else
347 seq_printf(m, " (%s: no entry)\n", DNAME(dev));
348
349 }
350
351 static int can_rcvlist_proc_show(struct seq_file *m, void *v)
352 {
353 /* double cast to prevent GCC warning */
354 int idx = (int)(long)PDE_DATA(m->file->f_inode);
355 struct net_device *dev;
356 struct dev_rcv_lists *d;
357 struct net *net = m->private;
358
359 seq_printf(m, "\nreceive list '%s':\n", rx_list_name[idx]);
360
361 rcu_read_lock();
362
363 /* receive list for 'all' CAN devices (dev == NULL) */
364 d = net->can.can_rx_alldev_list;
365 can_rcvlist_proc_show_one(m, idx, NULL, d);
366
367 /* receive list for registered CAN devices */
368 for_each_netdev_rcu(net, dev) {
369 if (dev->type == ARPHRD_CAN && dev->ml_priv)
370 can_rcvlist_proc_show_one(m, idx, dev, dev->ml_priv);
371 }
372
373 rcu_read_unlock();
374
375 seq_putc(m, '\n');
376 return 0;
377 }
378
379 static int can_rcvlist_proc_open(struct inode *inode, struct file *file)
380 {
381 return single_open_net(inode, file, can_rcvlist_proc_show);
382 }
383
384 static const struct file_operations can_rcvlist_proc_fops = {
385 .owner = THIS_MODULE,
386 .open = can_rcvlist_proc_open,
387 .read = seq_read,
388 .llseek = seq_lseek,
389 .release = single_release,
390 };
391
392 static inline void can_rcvlist_proc_show_array(struct seq_file *m,
393 struct net_device *dev,
394 struct hlist_head *rcv_array,
395 unsigned int rcv_array_sz)
396 {
397 unsigned int i;
398 int all_empty = 1;
399
400 /* check whether at least one list is non-empty */
401 for (i = 0; i < rcv_array_sz; i++)
402 if (!hlist_empty(&rcv_array[i])) {
403 all_empty = 0;
404 break;
405 }
406
407 if (!all_empty) {
408 can_print_recv_banner(m);
409 for (i = 0; i < rcv_array_sz; i++) {
410 if (!hlist_empty(&rcv_array[i]))
411 can_print_rcvlist(m, &rcv_array[i], dev);
412 }
413 } else
414 seq_printf(m, " (%s: no entry)\n", DNAME(dev));
415 }
416
417 static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
418 {
419 struct net_device *dev;
420 struct dev_rcv_lists *d;
421 struct net *net = m->private;
422
423 /* RX_SFF */
424 seq_puts(m, "\nreceive list 'rx_sff':\n");
425
426 rcu_read_lock();
427
428 /* sff receive list for 'all' CAN devices (dev == NULL) */
429 d = net->can.can_rx_alldev_list;
430 can_rcvlist_proc_show_array(m, NULL, d->rx_sff, ARRAY_SIZE(d->rx_sff));
431
432 /* sff receive list for registered CAN devices */
433 for_each_netdev_rcu(net, dev) {
434 if (dev->type == ARPHRD_CAN && dev->ml_priv) {
435 d = dev->ml_priv;
436 can_rcvlist_proc_show_array(m, dev, d->rx_sff,
437 ARRAY_SIZE(d->rx_sff));
438 }
439 }
440
441 rcu_read_unlock();
442
443 seq_putc(m, '\n');
444 return 0;
445 }
446
447 static int can_rcvlist_sff_proc_open(struct inode *inode, struct file *file)
448 {
449 return single_open_net(inode, file, can_rcvlist_sff_proc_show);
450 }
451
452 static const struct file_operations can_rcvlist_sff_proc_fops = {
453 .owner = THIS_MODULE,
454 .open = can_rcvlist_sff_proc_open,
455 .read = seq_read,
456 .llseek = seq_lseek,
457 .release = single_release,
458 };
459
460
461 static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
462 {
463 struct net_device *dev;
464 struct dev_rcv_lists *d;
465 struct net *net = m->private;
466
467 /* RX_EFF */
468 seq_puts(m, "\nreceive list 'rx_eff':\n");
469
470 rcu_read_lock();
471
472 /* eff receive list for 'all' CAN devices (dev == NULL) */
473 d = net->can.can_rx_alldev_list;
474 can_rcvlist_proc_show_array(m, NULL, d->rx_eff, ARRAY_SIZE(d->rx_eff));
475
476 /* eff receive list for registered CAN devices */
477 for_each_netdev_rcu(net, dev) {
478 if (dev->type == ARPHRD_CAN && dev->ml_priv) {
479 d = dev->ml_priv;
480 can_rcvlist_proc_show_array(m, dev, d->rx_eff,
481 ARRAY_SIZE(d->rx_eff));
482 }
483 }
484
485 rcu_read_unlock();
486
487 seq_putc(m, '\n');
488 return 0;
489 }
490
491 static int can_rcvlist_eff_proc_open(struct inode *inode, struct file *file)
492 {
493 return single_open_net(inode, file, can_rcvlist_eff_proc_show);
494 }
495
496 static const struct file_operations can_rcvlist_eff_proc_fops = {
497 .owner = THIS_MODULE,
498 .open = can_rcvlist_eff_proc_open,
499 .read = seq_read,
500 .llseek = seq_lseek,
501 .release = single_release,
502 };
503
504 /*
505 * can_init_proc - create main CAN proc directory and procfs entries
506 */
507 void can_init_proc(struct net *net)
508 {
509 /* create /proc/net/can directory */
510 net->can.proc_dir = proc_net_mkdir(net, "can", net->proc_net);
511
512 if (!net->can.proc_dir) {
513 printk(KERN_INFO "can: failed to create /proc/net/can . "
514 "CONFIG_PROC_FS missing?\n");
515 return;
516 }
517
518 /* own procfs entries from the AF_CAN core */
519 net->can.pde_version = proc_create(CAN_PROC_VERSION, 0644,
520 net->can.proc_dir,
521 &can_version_proc_fops);
522 net->can.pde_stats = proc_create(CAN_PROC_STATS, 0644,
523 net->can.proc_dir,
524 &can_stats_proc_fops);
525 net->can.pde_reset_stats = proc_create(CAN_PROC_RESET_STATS, 0644,
526 net->can.proc_dir,
527 &can_reset_stats_proc_fops);
528 net->can.pde_rcvlist_err = proc_create_data(CAN_PROC_RCVLIST_ERR, 0644,
529 net->can.proc_dir,
530 &can_rcvlist_proc_fops,
531 (void *)RX_ERR);
532 net->can.pde_rcvlist_all = proc_create_data(CAN_PROC_RCVLIST_ALL, 0644,
533 net->can.proc_dir,
534 &can_rcvlist_proc_fops,
535 (void *)RX_ALL);
536 net->can.pde_rcvlist_fil = proc_create_data(CAN_PROC_RCVLIST_FIL, 0644,
537 net->can.proc_dir,
538 &can_rcvlist_proc_fops,
539 (void *)RX_FIL);
540 net->can.pde_rcvlist_inv = proc_create_data(CAN_PROC_RCVLIST_INV, 0644,
541 net->can.proc_dir,
542 &can_rcvlist_proc_fops,
543 (void *)RX_INV);
544 net->can.pde_rcvlist_eff = proc_create(CAN_PROC_RCVLIST_EFF, 0644,
545 net->can.proc_dir,
546 &can_rcvlist_eff_proc_fops);
547 net->can.pde_rcvlist_sff = proc_create(CAN_PROC_RCVLIST_SFF, 0644,
548 net->can.proc_dir,
549 &can_rcvlist_sff_proc_fops);
550 }
551
552 /*
553 * can_remove_proc - remove procfs entries and main CAN proc directory
554 */
555 void can_remove_proc(struct net *net)
556 {
557 if (net->can.pde_version)
558 remove_proc_entry(CAN_PROC_VERSION, net->can.proc_dir);
559
560 if (net->can.pde_stats)
561 remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir);
562
563 if (net->can.pde_reset_stats)
564 remove_proc_entry(CAN_PROC_RESET_STATS, net->can.proc_dir);
565
566 if (net->can.pde_rcvlist_err)
567 remove_proc_entry(CAN_PROC_RCVLIST_ERR, net->can.proc_dir);
568
569 if (net->can.pde_rcvlist_all)
570 remove_proc_entry(CAN_PROC_RCVLIST_ALL, net->can.proc_dir);
571
572 if (net->can.pde_rcvlist_fil)
573 remove_proc_entry(CAN_PROC_RCVLIST_FIL, net->can.proc_dir);
574
575 if (net->can.pde_rcvlist_inv)
576 remove_proc_entry(CAN_PROC_RCVLIST_INV, net->can.proc_dir);
577
578 if (net->can.pde_rcvlist_eff)
579 remove_proc_entry(CAN_PROC_RCVLIST_EFF, net->can.proc_dir);
580
581 if (net->can.pde_rcvlist_sff)
582 remove_proc_entry(CAN_PROC_RCVLIST_SFF, net->can.proc_dir);
583
584 if (net->can.proc_dir)
585 remove_proc_entry("can", net->proc_net);
586 }