Commit | Line | Data |
---|---|---|
0d66548a OH |
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 | * | |
0d66548a OH |
40 | */ |
41 | ||
42 | #include <linux/module.h> | |
43 | #include <linux/proc_fs.h> | |
44 | #include <linux/list.h> | |
45 | #include <linux/rcupdate.h> | |
20dd3850 | 46 | #include <linux/if_arp.h> |
0d66548a OH |
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 | ||
0d66548a OH |
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", | |
0d66548a OH |
72 | }; |
73 | ||
74 | /* | |
75 | * af_can statistics stuff | |
76 | */ | |
77 | ||
cb5635a3 | 78 | static void can_init_stats(struct net *net) |
0d66548a | 79 | { |
cb5635a3 OH |
80 | struct s_stats *can_stats = net->can.can_stats; |
81 | struct s_pstats *can_pstats = net->can.can_pstats; | |
0d66548a OH |
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 | */ | |
cb5635a3 OH |
87 | memset(can_stats, 0, sizeof(struct s_stats)); |
88 | can_stats->jiffies_init = jiffies; | |
0d66548a | 89 | |
cb5635a3 | 90 | can_pstats->stats_reset++; |
0d66548a OH |
91 | |
92 | if (user_reset) { | |
93 | user_reset = 0; | |
cb5635a3 | 94 | can_pstats->user_reset++; |
0d66548a OH |
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 | ||
1fccb565 | 118 | void can_stat_update(struct timer_list *t) |
0d66548a | 119 | { |
1fccb565 | 120 | struct net *net = from_timer(net, t, can.can_stattimer); |
cb5635a3 | 121 | struct s_stats *can_stats = net->can.can_stats; |
0d66548a OH |
122 | unsigned long j = jiffies; /* snapshot */ |
123 | ||
124 | /* restart counting in timer context on user request */ | |
125 | if (user_reset) | |
cb5635a3 | 126 | can_init_stats(net); |
0d66548a OH |
127 | |
128 | /* restart counting on jiffies overflow */ | |
cb5635a3 OH |
129 | if (j < can_stats->jiffies_init) |
130 | can_init_stats(net); | |
0d66548a OH |
131 | |
132 | /* prevent overflow in calc_rate() */ | |
cb5635a3 OH |
133 | if (can_stats->rx_frames > (ULONG_MAX / HZ)) |
134 | can_init_stats(net); | |
0d66548a OH |
135 | |
136 | /* prevent overflow in calc_rate() */ | |
cb5635a3 OH |
137 | if (can_stats->tx_frames > (ULONG_MAX / HZ)) |
138 | can_init_stats(net); | |
0d66548a OH |
139 | |
140 | /* matches overflow - very improbable */ | |
cb5635a3 OH |
141 | if (can_stats->matches > (ULONG_MAX / 100)) |
142 | can_init_stats(net); | |
0d66548a OH |
143 | |
144 | /* calc total values */ | |
cb5635a3 OH |
145 | if (can_stats->rx_frames) |
146 | can_stats->total_rx_match_ratio = (can_stats->matches * 100) / | |
147 | can_stats->rx_frames; | |
0d66548a | 148 | |
cb5635a3 OH |
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); | |
0d66548a OH |
153 | |
154 | /* calc current values */ | |
cb5635a3 OH |
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; | |
0d66548a | 159 | |
cb5635a3 OH |
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); | |
0d66548a OH |
162 | |
163 | /* check / update maximum values */ | |
cb5635a3 OH |
164 | if (can_stats->max_tx_rate < can_stats->current_tx_rate) |
165 | can_stats->max_tx_rate = can_stats->current_tx_rate; | |
0d66548a | 166 | |
cb5635a3 OH |
167 | if (can_stats->max_rx_rate < can_stats->current_rx_rate) |
168 | can_stats->max_rx_rate = can_stats->current_rx_rate; | |
0d66548a | 169 | |
cb5635a3 OH |
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; | |
0d66548a OH |
172 | |
173 | /* clear values for 'current rate' calculation */ | |
cb5635a3 OH |
174 | can_stats->tx_frames_delta = 0; |
175 | can_stats->rx_frames_delta = 0; | |
176 | can_stats->matches_delta = 0; | |
0d66548a OH |
177 | |
178 | /* restart timer (one second) */ | |
cb5635a3 | 179 | mod_timer(&net->can.can_stattimer, round_jiffies(jiffies + HZ)); |
0d66548a OH |
180 | } |
181 | ||
182 | /* | |
183 | * proc read functions | |
0d66548a OH |
184 | */ |
185 | ||
ea00b8e2 AD |
186 | static void can_print_rcvlist(struct seq_file *m, struct hlist_head *rx_list, |
187 | struct net_device *dev) | |
0d66548a OH |
188 | { |
189 | struct receiver *r; | |
0d66548a | 190 | |
b67bfe0d | 191 | hlist_for_each_entry_rcu(r, rx_list, list) { |
0d66548a | 192 | char *fmt = (r->can_id & CAN_EFF_FLAG)? |
12e6c419 OH |
193 | " %-5s %08x %08x %pK %pK %8ld %s\n" : |
194 | " %-5s %03x %08x %pK %pK %8ld %s\n"; | |
0d66548a | 195 | |
ea00b8e2 | 196 | seq_printf(m, fmt, DNAME(dev), r->can_id, r->mask, |
12e6c419 | 197 | r->func, r->data, r->matches, r->ident); |
0d66548a | 198 | } |
0d66548a OH |
199 | } |
200 | ||
ea00b8e2 | 201 | static void can_print_recv_banner(struct seq_file *m) |
0d66548a OH |
202 | { |
203 | /* | |
204 | * can1. 00000000 00000000 00000000 | |
205 | * ....... 0 tp20 | |
206 | */ | |
ea00b8e2 | 207 | seq_puts(m, " device can_id can_mask function" |
0d66548a | 208 | " userdata matches ident\n"); |
0d66548a OH |
209 | } |
210 | ||
ea00b8e2 | 211 | static int can_stats_proc_show(struct seq_file *m, void *v) |
0d66548a | 212 | { |
cb5635a3 OH |
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 | ||
ea00b8e2 | 217 | seq_putc(m, '\n'); |
cb5635a3 OH |
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); | |
0d66548a | 221 | |
ea00b8e2 | 222 | seq_putc(m, '\n'); |
0d66548a | 223 | |
841b86f3 | 224 | if (net->can.can_stattimer.function == can_stat_update) { |
ea00b8e2 | 225 | seq_printf(m, " %8ld %% total match ratio (RXMR)\n", |
cb5635a3 | 226 | can_stats->total_rx_match_ratio); |
0d66548a | 227 | |
ea00b8e2 | 228 | seq_printf(m, " %8ld frames/s total tx rate (TXR)\n", |
cb5635a3 | 229 | can_stats->total_tx_rate); |
ea00b8e2 | 230 | seq_printf(m, " %8ld frames/s total rx rate (RXR)\n", |
cb5635a3 | 231 | can_stats->total_rx_rate); |
0d66548a | 232 | |
ea00b8e2 | 233 | seq_putc(m, '\n'); |
0d66548a | 234 | |
ea00b8e2 | 235 | seq_printf(m, " %8ld %% current match ratio (CRXMR)\n", |
cb5635a3 | 236 | can_stats->current_rx_match_ratio); |
0d66548a | 237 | |
ea00b8e2 | 238 | seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n", |
cb5635a3 | 239 | can_stats->current_tx_rate); |
ea00b8e2 | 240 | seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n", |
cb5635a3 | 241 | can_stats->current_rx_rate); |
0d66548a | 242 | |
ea00b8e2 | 243 | seq_putc(m, '\n'); |
0d66548a | 244 | |
ea00b8e2 | 245 | seq_printf(m, " %8ld %% max match ratio (MRXMR)\n", |
cb5635a3 | 246 | can_stats->max_rx_match_ratio); |
0d66548a | 247 | |
ea00b8e2 | 248 | seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n", |
cb5635a3 | 249 | can_stats->max_tx_rate); |
ea00b8e2 | 250 | seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n", |
cb5635a3 | 251 | can_stats->max_rx_rate); |
0d66548a | 252 | |
ea00b8e2 | 253 | seq_putc(m, '\n'); |
0d66548a OH |
254 | } |
255 | ||
ea00b8e2 | 256 | seq_printf(m, " %8ld current receive list entries (CRCV)\n", |
cb5635a3 | 257 | can_pstats->rcv_entries); |
ea00b8e2 | 258 | seq_printf(m, " %8ld maximum receive list entries (MRCV)\n", |
cb5635a3 | 259 | can_pstats->rcv_entries_max); |
0d66548a | 260 | |
cb5635a3 | 261 | if (can_pstats->stats_reset) |
ea00b8e2 | 262 | seq_printf(m, "\n %8ld statistic resets (STR)\n", |
cb5635a3 | 263 | can_pstats->stats_reset); |
0d66548a | 264 | |
cb5635a3 | 265 | if (can_pstats->user_reset) |
ea00b8e2 | 266 | seq_printf(m, " %8ld user statistic resets (USTR)\n", |
cb5635a3 | 267 | can_pstats->user_reset); |
0d66548a | 268 | |
ea00b8e2 AD |
269 | seq_putc(m, '\n'); |
270 | return 0; | |
0d66548a OH |
271 | } |
272 | ||
ea00b8e2 | 273 | static int can_stats_proc_open(struct inode *inode, struct file *file) |
0d66548a | 274 | { |
cb5635a3 | 275 | return single_open_net(inode, file, can_stats_proc_show); |
ea00b8e2 AD |
276 | } |
277 | ||
278 | static const struct file_operations can_stats_proc_fops = { | |
ea00b8e2 AD |
279 | .open = can_stats_proc_open, |
280 | .read = seq_read, | |
281 | .llseek = seq_lseek, | |
282 | .release = single_release, | |
283 | }; | |
0d66548a | 284 | |
ea00b8e2 AD |
285 | static int can_reset_stats_proc_show(struct seq_file *m, void *v) |
286 | { | |
cb5635a3 OH |
287 | struct net *net = m->private; |
288 | struct s_pstats *can_pstats = net->can.can_pstats; | |
289 | struct s_stats *can_stats = net->can.can_stats; | |
290 | ||
0d66548a OH |
291 | user_reset = 1; |
292 | ||
841b86f3 | 293 | if (net->can.can_stattimer.function == can_stat_update) { |
ea00b8e2 | 294 | seq_printf(m, "Scheduled statistic reset #%ld.\n", |
cb5635a3 | 295 | can_pstats->stats_reset + 1); |
0d66548a | 296 | } else { |
cb5635a3 OH |
297 | if (can_stats->jiffies_init != jiffies) |
298 | can_init_stats(net); | |
0d66548a | 299 | |
ea00b8e2 | 300 | seq_printf(m, "Performed statistic reset #%ld.\n", |
cb5635a3 | 301 | can_pstats->stats_reset); |
0d66548a | 302 | } |
ea00b8e2 AD |
303 | return 0; |
304 | } | |
0d66548a | 305 | |
ea00b8e2 AD |
306 | static int can_reset_stats_proc_open(struct inode *inode, struct file *file) |
307 | { | |
cb5635a3 | 308 | return single_open_net(inode, file, can_reset_stats_proc_show); |
0d66548a OH |
309 | } |
310 | ||
ea00b8e2 | 311 | static const struct file_operations can_reset_stats_proc_fops = { |
ea00b8e2 AD |
312 | .open = can_reset_stats_proc_open, |
313 | .read = seq_read, | |
314 | .llseek = seq_lseek, | |
315 | .release = single_release, | |
316 | }; | |
317 | ||
318 | static int can_version_proc_show(struct seq_file *m, void *v) | |
0d66548a | 319 | { |
ea00b8e2 AD |
320 | seq_printf(m, "%s\n", CAN_VERSION_STRING); |
321 | return 0; | |
322 | } | |
0d66548a | 323 | |
ea00b8e2 AD |
324 | static int can_version_proc_open(struct inode *inode, struct file *file) |
325 | { | |
cb5635a3 | 326 | return single_open_net(inode, file, can_version_proc_show); |
0d66548a OH |
327 | } |
328 | ||
ea00b8e2 | 329 | static const struct file_operations can_version_proc_fops = { |
ea00b8e2 AD |
330 | .open = can_version_proc_open, |
331 | .read = seq_read, | |
332 | .llseek = seq_lseek, | |
333 | .release = single_release, | |
334 | }; | |
335 | ||
20dd3850 OH |
336 | static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx, |
337 | struct net_device *dev, | |
ff847ee4 | 338 | struct can_dev_rcv_lists *d) |
20dd3850 OH |
339 | { |
340 | if (!hlist_empty(&d->rx[idx])) { | |
341 | can_print_recv_banner(m); | |
342 | can_print_rcvlist(m, &d->rx[idx], dev); | |
343 | } else | |
344 | seq_printf(m, " (%s: no entry)\n", DNAME(dev)); | |
345 | ||
346 | } | |
347 | ||
ea00b8e2 | 348 | static int can_rcvlist_proc_show(struct seq_file *m, void *v) |
0d66548a OH |
349 | { |
350 | /* double cast to prevent GCC warning */ | |
8e8cda6d | 351 | int idx = (int)(long)PDE_DATA(m->file->f_inode); |
20dd3850 | 352 | struct net_device *dev; |
ff847ee4 | 353 | struct can_dev_rcv_lists *d; |
8e8cda6d | 354 | struct net *net = m->private; |
0d66548a | 355 | |
ea00b8e2 | 356 | seq_printf(m, "\nreceive list '%s':\n", rx_list_name[idx]); |
0d66548a OH |
357 | |
358 | rcu_read_lock(); | |
0d66548a | 359 | |
20dd3850 | 360 | /* receive list for 'all' CAN devices (dev == NULL) */ |
8e8cda6d | 361 | d = net->can.can_rx_alldev_list; |
20dd3850 OH |
362 | can_rcvlist_proc_show_one(m, idx, NULL, d); |
363 | ||
364 | /* receive list for registered CAN devices */ | |
8e8cda6d | 365 | for_each_netdev_rcu(net, dev) { |
20dd3850 OH |
366 | if (dev->type == ARPHRD_CAN && dev->ml_priv) |
367 | can_rcvlist_proc_show_one(m, idx, dev, dev->ml_priv); | |
0d66548a | 368 | } |
20dd3850 | 369 | |
0d66548a OH |
370 | rcu_read_unlock(); |
371 | ||
ea00b8e2 AD |
372 | seq_putc(m, '\n'); |
373 | return 0; | |
374 | } | |
0d66548a | 375 | |
ea00b8e2 AD |
376 | static int can_rcvlist_proc_open(struct inode *inode, struct file *file) |
377 | { | |
8e8cda6d | 378 | return single_open_net(inode, file, can_rcvlist_proc_show); |
0d66548a OH |
379 | } |
380 | ||
ea00b8e2 | 381 | static const struct file_operations can_rcvlist_proc_fops = { |
ea00b8e2 AD |
382 | .open = can_rcvlist_proc_open, |
383 | .read = seq_read, | |
384 | .llseek = seq_lseek, | |
385 | .release = single_release, | |
386 | }; | |
387 | ||
e3d3917f OH |
388 | static inline void can_rcvlist_proc_show_array(struct seq_file *m, |
389 | struct net_device *dev, | |
390 | struct hlist_head *rcv_array, | |
391 | unsigned int rcv_array_sz) | |
20dd3850 | 392 | { |
e3d3917f | 393 | unsigned int i; |
20dd3850 OH |
394 | int all_empty = 1; |
395 | ||
48fc7f7e | 396 | /* check whether at least one list is non-empty */ |
e3d3917f OH |
397 | for (i = 0; i < rcv_array_sz; i++) |
398 | if (!hlist_empty(&rcv_array[i])) { | |
20dd3850 OH |
399 | all_empty = 0; |
400 | break; | |
401 | } | |
402 | ||
403 | if (!all_empty) { | |
404 | can_print_recv_banner(m); | |
e3d3917f OH |
405 | for (i = 0; i < rcv_array_sz; i++) { |
406 | if (!hlist_empty(&rcv_array[i])) | |
407 | can_print_rcvlist(m, &rcv_array[i], dev); | |
20dd3850 OH |
408 | } |
409 | } else | |
410 | seq_printf(m, " (%s: no entry)\n", DNAME(dev)); | |
411 | } | |
412 | ||
ea00b8e2 | 413 | static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v) |
0d66548a | 414 | { |
20dd3850 | 415 | struct net_device *dev; |
ff847ee4 | 416 | struct can_dev_rcv_lists *d; |
8e8cda6d | 417 | struct net *net = m->private; |
0d66548a OH |
418 | |
419 | /* RX_SFF */ | |
ea00b8e2 | 420 | seq_puts(m, "\nreceive list 'rx_sff':\n"); |
0d66548a OH |
421 | |
422 | rcu_read_lock(); | |
20dd3850 OH |
423 | |
424 | /* sff receive list for 'all' CAN devices (dev == NULL) */ | |
8e8cda6d | 425 | d = net->can.can_rx_alldev_list; |
e3d3917f | 426 | can_rcvlist_proc_show_array(m, NULL, d->rx_sff, ARRAY_SIZE(d->rx_sff)); |
20dd3850 OH |
427 | |
428 | /* sff receive list for registered CAN devices */ | |
8e8cda6d | 429 | for_each_netdev_rcu(net, dev) { |
e3d3917f OH |
430 | if (dev->type == ARPHRD_CAN && dev->ml_priv) { |
431 | d = dev->ml_priv; | |
432 | can_rcvlist_proc_show_array(m, dev, d->rx_sff, | |
433 | ARRAY_SIZE(d->rx_sff)); | |
434 | } | |
0d66548a | 435 | } |
20dd3850 | 436 | |
0d66548a OH |
437 | rcu_read_unlock(); |
438 | ||
ea00b8e2 AD |
439 | seq_putc(m, '\n'); |
440 | return 0; | |
441 | } | |
0d66548a | 442 | |
ea00b8e2 AD |
443 | static int can_rcvlist_sff_proc_open(struct inode *inode, struct file *file) |
444 | { | |
8e8cda6d | 445 | return single_open_net(inode, file, can_rcvlist_sff_proc_show); |
0d66548a OH |
446 | } |
447 | ||
ea00b8e2 | 448 | static const struct file_operations can_rcvlist_sff_proc_fops = { |
ea00b8e2 AD |
449 | .open = can_rcvlist_sff_proc_open, |
450 | .read = seq_read, | |
451 | .llseek = seq_lseek, | |
452 | .release = single_release, | |
453 | }; | |
454 | ||
45c70029 OH |
455 | |
456 | static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v) | |
457 | { | |
458 | struct net_device *dev; | |
ff847ee4 | 459 | struct can_dev_rcv_lists *d; |
8e8cda6d | 460 | struct net *net = m->private; |
45c70029 OH |
461 | |
462 | /* RX_EFF */ | |
463 | seq_puts(m, "\nreceive list 'rx_eff':\n"); | |
464 | ||
465 | rcu_read_lock(); | |
466 | ||
467 | /* eff receive list for 'all' CAN devices (dev == NULL) */ | |
8e8cda6d | 468 | d = net->can.can_rx_alldev_list; |
45c70029 OH |
469 | can_rcvlist_proc_show_array(m, NULL, d->rx_eff, ARRAY_SIZE(d->rx_eff)); |
470 | ||
471 | /* eff receive list for registered CAN devices */ | |
8e8cda6d | 472 | for_each_netdev_rcu(net, dev) { |
45c70029 OH |
473 | if (dev->type == ARPHRD_CAN && dev->ml_priv) { |
474 | d = dev->ml_priv; | |
475 | can_rcvlist_proc_show_array(m, dev, d->rx_eff, | |
476 | ARRAY_SIZE(d->rx_eff)); | |
477 | } | |
478 | } | |
479 | ||
480 | rcu_read_unlock(); | |
481 | ||
482 | seq_putc(m, '\n'); | |
483 | return 0; | |
484 | } | |
485 | ||
486 | static int can_rcvlist_eff_proc_open(struct inode *inode, struct file *file) | |
487 | { | |
8e8cda6d | 488 | return single_open_net(inode, file, can_rcvlist_eff_proc_show); |
45c70029 OH |
489 | } |
490 | ||
491 | static const struct file_operations can_rcvlist_eff_proc_fops = { | |
45c70029 OH |
492 | .open = can_rcvlist_eff_proc_open, |
493 | .read = seq_read, | |
494 | .llseek = seq_lseek, | |
495 | .release = single_release, | |
496 | }; | |
497 | ||
0d66548a OH |
498 | /* |
499 | * can_init_proc - create main CAN proc directory and procfs entries | |
500 | */ | |
8e8cda6d | 501 | void can_init_proc(struct net *net) |
0d66548a OH |
502 | { |
503 | /* create /proc/net/can directory */ | |
8e8cda6d | 504 | net->can.proc_dir = proc_net_mkdir(net, "can", net->proc_net); |
0d66548a | 505 | |
8e8cda6d MK |
506 | if (!net->can.proc_dir) { |
507 | printk(KERN_INFO "can: failed to create /proc/net/can . " | |
508 | "CONFIG_PROC_FS missing?\n"); | |
0d66548a OH |
509 | return; |
510 | } | |
511 | ||
0d66548a | 512 | /* own procfs entries from the AF_CAN core */ |
8e8cda6d MK |
513 | net->can.pde_version = proc_create(CAN_PROC_VERSION, 0644, |
514 | net->can.proc_dir, | |
515 | &can_version_proc_fops); | |
516 | net->can.pde_stats = proc_create(CAN_PROC_STATS, 0644, | |
517 | net->can.proc_dir, | |
518 | &can_stats_proc_fops); | |
519 | net->can.pde_reset_stats = proc_create(CAN_PROC_RESET_STATS, 0644, | |
520 | net->can.proc_dir, | |
521 | &can_reset_stats_proc_fops); | |
522 | net->can.pde_rcvlist_err = proc_create_data(CAN_PROC_RCVLIST_ERR, 0644, | |
523 | net->can.proc_dir, | |
524 | &can_rcvlist_proc_fops, | |
525 | (void *)RX_ERR); | |
526 | net->can.pde_rcvlist_all = proc_create_data(CAN_PROC_RCVLIST_ALL, 0644, | |
527 | net->can.proc_dir, | |
528 | &can_rcvlist_proc_fops, | |
529 | (void *)RX_ALL); | |
530 | net->can.pde_rcvlist_fil = proc_create_data(CAN_PROC_RCVLIST_FIL, 0644, | |
531 | net->can.proc_dir, | |
532 | &can_rcvlist_proc_fops, | |
533 | (void *)RX_FIL); | |
534 | net->can.pde_rcvlist_inv = proc_create_data(CAN_PROC_RCVLIST_INV, 0644, | |
535 | net->can.proc_dir, | |
536 | &can_rcvlist_proc_fops, | |
537 | (void *)RX_INV); | |
538 | net->can.pde_rcvlist_eff = proc_create(CAN_PROC_RCVLIST_EFF, 0644, | |
539 | net->can.proc_dir, | |
540 | &can_rcvlist_eff_proc_fops); | |
541 | net->can.pde_rcvlist_sff = proc_create(CAN_PROC_RCVLIST_SFF, 0644, | |
542 | net->can.proc_dir, | |
543 | &can_rcvlist_sff_proc_fops); | |
0d66548a OH |
544 | } |
545 | ||
546 | /* | |
547 | * can_remove_proc - remove procfs entries and main CAN proc directory | |
548 | */ | |
8e8cda6d | 549 | void can_remove_proc(struct net *net) |
0d66548a | 550 | { |
8e8cda6d MK |
551 | if (net->can.pde_version) |
552 | remove_proc_entry(CAN_PROC_VERSION, net->can.proc_dir); | |
0d66548a | 553 | |
8e8cda6d MK |
554 | if (net->can.pde_stats) |
555 | remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir); | |
0d66548a | 556 | |
8e8cda6d MK |
557 | if (net->can.pde_reset_stats) |
558 | remove_proc_entry(CAN_PROC_RESET_STATS, net->can.proc_dir); | |
0d66548a | 559 | |
8e8cda6d MK |
560 | if (net->can.pde_rcvlist_err) |
561 | remove_proc_entry(CAN_PROC_RCVLIST_ERR, net->can.proc_dir); | |
0d66548a | 562 | |
8e8cda6d MK |
563 | if (net->can.pde_rcvlist_all) |
564 | remove_proc_entry(CAN_PROC_RCVLIST_ALL, net->can.proc_dir); | |
0d66548a | 565 | |
8e8cda6d MK |
566 | if (net->can.pde_rcvlist_fil) |
567 | remove_proc_entry(CAN_PROC_RCVLIST_FIL, net->can.proc_dir); | |
0d66548a | 568 | |
8e8cda6d MK |
569 | if (net->can.pde_rcvlist_inv) |
570 | remove_proc_entry(CAN_PROC_RCVLIST_INV, net->can.proc_dir); | |
0d66548a | 571 | |
8e8cda6d MK |
572 | if (net->can.pde_rcvlist_eff) |
573 | remove_proc_entry(CAN_PROC_RCVLIST_EFF, net->can.proc_dir); | |
0d66548a | 574 | |
8e8cda6d MK |
575 | if (net->can.pde_rcvlist_sff) |
576 | remove_proc_entry(CAN_PROC_RCVLIST_SFF, net->can.proc_dir); | |
0d66548a | 577 | |
8e8cda6d MK |
578 | if (net->can.proc_dir) |
579 | remove_proc_entry("can", net->proc_net); | |
0d66548a | 580 | } |