Merge tag 'f2fs-for-v3.10' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk...
[platform/adaptation/renesas_rcar/renesas_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 struct proc_dir_entry *can_dir;
66 static struct proc_dir_entry *pde_version;
67 static struct proc_dir_entry *pde_stats;
68 static struct proc_dir_entry *pde_reset_stats;
69 static struct proc_dir_entry *pde_rcvlist_all;
70 static struct proc_dir_entry *pde_rcvlist_fil;
71 static struct proc_dir_entry *pde_rcvlist_inv;
72 static struct proc_dir_entry *pde_rcvlist_sff;
73 static struct proc_dir_entry *pde_rcvlist_eff;
74 static struct proc_dir_entry *pde_rcvlist_err;
75
76 static int user_reset;
77
78 static const char rx_list_name[][8] = {
79         [RX_ERR] = "rx_err",
80         [RX_ALL] = "rx_all",
81         [RX_FIL] = "rx_fil",
82         [RX_INV] = "rx_inv",
83         [RX_EFF] = "rx_eff",
84 };
85
86 /*
87  * af_can statistics stuff
88  */
89
90 static void can_init_stats(void)
91 {
92         /*
93          * This memset function is called from a timer context (when
94          * can_stattimer is active which is the default) OR in a process
95          * context (reading the proc_fs when can_stattimer is disabled).
96          */
97         memset(&can_stats, 0, sizeof(can_stats));
98         can_stats.jiffies_init = jiffies;
99
100         can_pstats.stats_reset++;
101
102         if (user_reset) {
103                 user_reset = 0;
104                 can_pstats.user_reset++;
105         }
106 }
107
108 static unsigned long calc_rate(unsigned long oldjif, unsigned long newjif,
109                                unsigned long count)
110 {
111         unsigned long rate;
112
113         if (oldjif == newjif)
114                 return 0;
115
116         /* see can_stat_update() - this should NEVER happen! */
117         if (count > (ULONG_MAX / HZ)) {
118                 printk(KERN_ERR "can: calc_rate: count exceeded! %ld\n",
119                        count);
120                 return 99999999;
121         }
122
123         rate = (count * HZ) / (newjif - oldjif);
124
125         return rate;
126 }
127
128 void can_stat_update(unsigned long data)
129 {
130         unsigned long j = jiffies; /* snapshot */
131
132         /* restart counting in timer context on user request */
133         if (user_reset)
134                 can_init_stats();
135
136         /* restart counting on jiffies overflow */
137         if (j < can_stats.jiffies_init)
138                 can_init_stats();
139
140         /* prevent overflow in calc_rate() */
141         if (can_stats.rx_frames > (ULONG_MAX / HZ))
142                 can_init_stats();
143
144         /* prevent overflow in calc_rate() */
145         if (can_stats.tx_frames > (ULONG_MAX / HZ))
146                 can_init_stats();
147
148         /* matches overflow - very improbable */
149         if (can_stats.matches > (ULONG_MAX / 100))
150                 can_init_stats();
151
152         /* calc total values */
153         if (can_stats.rx_frames)
154                 can_stats.total_rx_match_ratio = (can_stats.matches * 100) /
155                         can_stats.rx_frames;
156
157         can_stats.total_tx_rate = calc_rate(can_stats.jiffies_init, j,
158                                             can_stats.tx_frames);
159         can_stats.total_rx_rate = calc_rate(can_stats.jiffies_init, j,
160                                             can_stats.rx_frames);
161
162         /* calc current values */
163         if (can_stats.rx_frames_delta)
164                 can_stats.current_rx_match_ratio =
165                         (can_stats.matches_delta * 100) /
166                         can_stats.rx_frames_delta;
167
168         can_stats.current_tx_rate = calc_rate(0, HZ, can_stats.tx_frames_delta);
169         can_stats.current_rx_rate = calc_rate(0, HZ, can_stats.rx_frames_delta);
170
171         /* check / update maximum values */
172         if (can_stats.max_tx_rate < can_stats.current_tx_rate)
173                 can_stats.max_tx_rate = can_stats.current_tx_rate;
174
175         if (can_stats.max_rx_rate < can_stats.current_rx_rate)
176                 can_stats.max_rx_rate = can_stats.current_rx_rate;
177
178         if (can_stats.max_rx_match_ratio < can_stats.current_rx_match_ratio)
179                 can_stats.max_rx_match_ratio = can_stats.current_rx_match_ratio;
180
181         /* clear values for 'current rate' calculation */
182         can_stats.tx_frames_delta = 0;
183         can_stats.rx_frames_delta = 0;
184         can_stats.matches_delta   = 0;
185
186         /* restart timer (one second) */
187         mod_timer(&can_stattimer, round_jiffies(jiffies + HZ));
188 }
189
190 /*
191  * proc read functions
192  */
193
194 static void can_print_rcvlist(struct seq_file *m, struct hlist_head *rx_list,
195                               struct net_device *dev)
196 {
197         struct receiver *r;
198
199         hlist_for_each_entry_rcu(r, rx_list, list) {
200                 char *fmt = (r->can_id & CAN_EFF_FLAG)?
201                         "   %-5s  %08x  %08x  %pK  %pK  %8ld  %s\n" :
202                         "   %-5s     %03x    %08x  %pK  %pK  %8ld  %s\n";
203
204                 seq_printf(m, fmt, DNAME(dev), r->can_id, r->mask,
205                                 r->func, r->data, r->matches, r->ident);
206         }
207 }
208
209 static void can_print_recv_banner(struct seq_file *m)
210 {
211         /*
212          *                  can1.  00000000  00000000  00000000
213          *                 .......          0  tp20
214          */
215         seq_puts(m, "  device   can_id   can_mask  function"
216                         "  userdata   matches  ident\n");
217 }
218
219 static int can_stats_proc_show(struct seq_file *m, void *v)
220 {
221         seq_putc(m, '\n');
222         seq_printf(m, " %8ld transmitted frames (TXF)\n", can_stats.tx_frames);
223         seq_printf(m, " %8ld received frames (RXF)\n", can_stats.rx_frames);
224         seq_printf(m, " %8ld matched frames (RXMF)\n", can_stats.matches);
225
226         seq_putc(m, '\n');
227
228         if (can_stattimer.function == can_stat_update) {
229                 seq_printf(m, " %8ld %% total match ratio (RXMR)\n",
230                                 can_stats.total_rx_match_ratio);
231
232                 seq_printf(m, " %8ld frames/s total tx rate (TXR)\n",
233                                 can_stats.total_tx_rate);
234                 seq_printf(m, " %8ld frames/s total rx rate (RXR)\n",
235                                 can_stats.total_rx_rate);
236
237                 seq_putc(m, '\n');
238
239                 seq_printf(m, " %8ld %% current match ratio (CRXMR)\n",
240                                 can_stats.current_rx_match_ratio);
241
242                 seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n",
243                                 can_stats.current_tx_rate);
244                 seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n",
245                                 can_stats.current_rx_rate);
246
247                 seq_putc(m, '\n');
248
249                 seq_printf(m, " %8ld %% max match ratio (MRXMR)\n",
250                                 can_stats.max_rx_match_ratio);
251
252                 seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n",
253                                 can_stats.max_tx_rate);
254                 seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n",
255                                 can_stats.max_rx_rate);
256
257                 seq_putc(m, '\n');
258         }
259
260         seq_printf(m, " %8ld current receive list entries (CRCV)\n",
261                         can_pstats.rcv_entries);
262         seq_printf(m, " %8ld maximum receive list entries (MRCV)\n",
263                         can_pstats.rcv_entries_max);
264
265         if (can_pstats.stats_reset)
266                 seq_printf(m, "\n %8ld statistic resets (STR)\n",
267                                 can_pstats.stats_reset);
268
269         if (can_pstats.user_reset)
270                 seq_printf(m, " %8ld user statistic resets (USTR)\n",
271                                 can_pstats.user_reset);
272
273         seq_putc(m, '\n');
274         return 0;
275 }
276
277 static int can_stats_proc_open(struct inode *inode, struct file *file)
278 {
279         return single_open(file, can_stats_proc_show, NULL);
280 }
281
282 static const struct file_operations can_stats_proc_fops = {
283         .owner          = THIS_MODULE,
284         .open           = can_stats_proc_open,
285         .read           = seq_read,
286         .llseek         = seq_lseek,
287         .release        = single_release,
288 };
289
290 static int can_reset_stats_proc_show(struct seq_file *m, void *v)
291 {
292         user_reset = 1;
293
294         if (can_stattimer.function == can_stat_update) {
295                 seq_printf(m, "Scheduled statistic reset #%ld.\n",
296                                 can_pstats.stats_reset + 1);
297
298         } else {
299                 if (can_stats.jiffies_init != jiffies)
300                         can_init_stats();
301
302                 seq_printf(m, "Performed statistic reset #%ld.\n",
303                                 can_pstats.stats_reset);
304         }
305         return 0;
306 }
307
308 static int can_reset_stats_proc_open(struct inode *inode, struct file *file)
309 {
310         return single_open(file, can_reset_stats_proc_show, NULL);
311 }
312
313 static const struct file_operations can_reset_stats_proc_fops = {
314         .owner          = THIS_MODULE,
315         .open           = can_reset_stats_proc_open,
316         .read           = seq_read,
317         .llseek         = seq_lseek,
318         .release        = single_release,
319 };
320
321 static int can_version_proc_show(struct seq_file *m, void *v)
322 {
323         seq_printf(m, "%s\n", CAN_VERSION_STRING);
324         return 0;
325 }
326
327 static int can_version_proc_open(struct inode *inode, struct file *file)
328 {
329         return single_open(file, can_version_proc_show, NULL);
330 }
331
332 static const struct file_operations can_version_proc_fops = {
333         .owner          = THIS_MODULE,
334         .open           = can_version_proc_open,
335         .read           = seq_read,
336         .llseek         = seq_lseek,
337         .release        = single_release,
338 };
339
340 static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
341                                              struct net_device *dev,
342                                              struct dev_rcv_lists *d)
343 {
344         if (!hlist_empty(&d->rx[idx])) {
345                 can_print_recv_banner(m);
346                 can_print_rcvlist(m, &d->rx[idx], dev);
347         } else
348                 seq_printf(m, "  (%s: no entry)\n", DNAME(dev));
349
350 }
351
352 static int can_rcvlist_proc_show(struct seq_file *m, void *v)
353 {
354         /* double cast to prevent GCC warning */
355         int idx = (int)(long)m->private;
356         struct net_device *dev;
357         struct dev_rcv_lists *d;
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 = &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(&init_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(file, can_rcvlist_proc_show, PDE_DATA(inode));
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_sff_proc_show_one(struct seq_file *m,
393                                                  struct net_device *dev,
394                                                  struct dev_rcv_lists *d)
395 {
396         int i;
397         int all_empty = 1;
398
399         /* check whether at least one list is non-empty */
400         for (i = 0; i < 0x800; i++)
401                 if (!hlist_empty(&d->rx_sff[i])) {
402                         all_empty = 0;
403                         break;
404                 }
405
406         if (!all_empty) {
407                 can_print_recv_banner(m);
408                 for (i = 0; i < 0x800; i++) {
409                         if (!hlist_empty(&d->rx_sff[i]))
410                                 can_print_rcvlist(m, &d->rx_sff[i], dev);
411                 }
412         } else
413                 seq_printf(m, "  (%s: no entry)\n", DNAME(dev));
414 }
415
416 static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
417 {
418         struct net_device *dev;
419         struct dev_rcv_lists *d;
420
421         /* RX_SFF */
422         seq_puts(m, "\nreceive list 'rx_sff':\n");
423
424         rcu_read_lock();
425
426         /* sff receive list for 'all' CAN devices (dev == NULL) */
427         d = &can_rx_alldev_list;
428         can_rcvlist_sff_proc_show_one(m, NULL, d);
429
430         /* sff receive list for registered CAN devices */
431         for_each_netdev_rcu(&init_net, dev) {
432                 if (dev->type == ARPHRD_CAN && dev->ml_priv)
433                         can_rcvlist_sff_proc_show_one(m, dev, dev->ml_priv);
434         }
435
436         rcu_read_unlock();
437
438         seq_putc(m, '\n');
439         return 0;
440 }
441
442 static int can_rcvlist_sff_proc_open(struct inode *inode, struct file *file)
443 {
444         return single_open(file, can_rcvlist_sff_proc_show, NULL);
445 }
446
447 static const struct file_operations can_rcvlist_sff_proc_fops = {
448         .owner          = THIS_MODULE,
449         .open           = can_rcvlist_sff_proc_open,
450         .read           = seq_read,
451         .llseek         = seq_lseek,
452         .release        = single_release,
453 };
454
455 /*
456  * proc utility functions
457  */
458
459 static void can_remove_proc_readentry(const char *name)
460 {
461         if (can_dir)
462                 remove_proc_entry(name, can_dir);
463 }
464
465 /*
466  * can_init_proc - create main CAN proc directory and procfs entries
467  */
468 void can_init_proc(void)
469 {
470         /* create /proc/net/can directory */
471         can_dir = proc_mkdir("can", init_net.proc_net);
472
473         if (!can_dir) {
474                 printk(KERN_INFO "can: failed to create /proc/net/can . "
475                        "CONFIG_PROC_FS missing?\n");
476                 return;
477         }
478
479         /* own procfs entries from the AF_CAN core */
480         pde_version     = proc_create(CAN_PROC_VERSION, 0644, can_dir,
481                                       &can_version_proc_fops);
482         pde_stats       = proc_create(CAN_PROC_STATS, 0644, can_dir,
483                                       &can_stats_proc_fops);
484         pde_reset_stats = proc_create(CAN_PROC_RESET_STATS, 0644, can_dir,
485                                       &can_reset_stats_proc_fops);
486         pde_rcvlist_err = proc_create_data(CAN_PROC_RCVLIST_ERR, 0644, can_dir,
487                                            &can_rcvlist_proc_fops, (void *)RX_ERR);
488         pde_rcvlist_all = proc_create_data(CAN_PROC_RCVLIST_ALL, 0644, can_dir,
489                                            &can_rcvlist_proc_fops, (void *)RX_ALL);
490         pde_rcvlist_fil = proc_create_data(CAN_PROC_RCVLIST_FIL, 0644, can_dir,
491                                            &can_rcvlist_proc_fops, (void *)RX_FIL);
492         pde_rcvlist_inv = proc_create_data(CAN_PROC_RCVLIST_INV, 0644, can_dir,
493                                            &can_rcvlist_proc_fops, (void *)RX_INV);
494         pde_rcvlist_eff = proc_create_data(CAN_PROC_RCVLIST_EFF, 0644, can_dir,
495                                            &can_rcvlist_proc_fops, (void *)RX_EFF);
496         pde_rcvlist_sff = proc_create(CAN_PROC_RCVLIST_SFF, 0644, can_dir,
497                                       &can_rcvlist_sff_proc_fops);
498 }
499
500 /*
501  * can_remove_proc - remove procfs entries and main CAN proc directory
502  */
503 void can_remove_proc(void)
504 {
505         if (pde_version)
506                 can_remove_proc_readentry(CAN_PROC_VERSION);
507
508         if (pde_stats)
509                 can_remove_proc_readentry(CAN_PROC_STATS);
510
511         if (pde_reset_stats)
512                 can_remove_proc_readentry(CAN_PROC_RESET_STATS);
513
514         if (pde_rcvlist_err)
515                 can_remove_proc_readentry(CAN_PROC_RCVLIST_ERR);
516
517         if (pde_rcvlist_all)
518                 can_remove_proc_readentry(CAN_PROC_RCVLIST_ALL);
519
520         if (pde_rcvlist_fil)
521                 can_remove_proc_readentry(CAN_PROC_RCVLIST_FIL);
522
523         if (pde_rcvlist_inv)
524                 can_remove_proc_readentry(CAN_PROC_RCVLIST_INV);
525
526         if (pde_rcvlist_eff)
527                 can_remove_proc_readentry(CAN_PROC_RCVLIST_EFF);
528
529         if (pde_rcvlist_sff)
530                 can_remove_proc_readentry(CAN_PROC_RCVLIST_SFF);
531
532         if (can_dir)
533                 remove_proc_entry("can", init_net.proc_net);
534 }