write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/net/can/proc.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
1
2
 /*
2
3
  * proc.c - procfs support for Protocol family CAN core module
3
4
  *
..
..
@@ -44,6 +45,7 @@
44
45
 #include <linux/list.h>
45
46
 #include <linux/rcupdate.h>
46
47
 #include <linux/if_arp.h>
48
+#include <linux/can/can-ml.h>
47
49
 #include <linux/can/core.h>
48
50
 
49
51
 #include "af_can.h"
..
..
@@ -52,7 +54,6 @@
52
54
  * proc filenames for the PF_CAN core
53
55
  */
54
56
 
55
-#define CAN_PROC_VERSION     "version"
56
57
 #define CAN_PROC_STATS       "stats"
57
58
 #define CAN_PROC_RESET_STATS "reset_stats"
58
59
 #define CAN_PROC_RCVLIST_ALL "rcvlist_all"
..
..
@@ -77,21 +78,21 @@
77
78
 
78
79
 static void can_init_stats(struct net *net)
79
80
 {
80
-	struct s_stats *can_stats = net->can.can_stats;
81
-	struct s_pstats *can_pstats = net->can.can_pstats;
81
+	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
82
+	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
82
83
 	/*
83
84
 	 * This memset function is called from a timer context (when
84
85
 	 * can_stattimer is active which is the default) OR in a process
85
86
 	 * context (reading the proc_fs when can_stattimer is disabled).
86
87
 	 */
87
-	memset(can_stats, 0, sizeof(struct s_stats));
88
-	can_stats->jiffies_init = jiffies;
88
+	memset(pkg_stats, 0, sizeof(struct can_pkg_stats));
89
+	pkg_stats->jiffies_init = jiffies;
89
90
 
90
-	can_pstats->stats_reset++;
91
+	rcv_lists_stats->stats_reset++;
91
92
 
92
93
 	if (user_reset) {
93
94
 		user_reset = 0;
94
-		can_pstats->user_reset++;
95
+		rcv_lists_stats->user_reset++;
95
96
 	}
96
97
 }
97
98
 
..
..
@@ -117,8 +118,8 @@
117
118
 
118
119
 void can_stat_update(struct timer_list *t)
119
120
 {
120
-	struct net *net = from_timer(net, t, can.can_stattimer);
121
-	struct s_stats *can_stats = net->can.can_stats;
121
+	struct net *net = from_timer(net, t, can.stattimer);
122
+	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
122
123
 	unsigned long j = jiffies; /* snapshot */
123
124
 
124
125
 	/* restart counting in timer context on user request */
..
..
@@ -126,57 +127,57 @@
126
127
 		can_init_stats(net);
127
128
 
128
129
 	/* restart counting on jiffies overflow */
129
-	if (j < can_stats->jiffies_init)
130
+	if (j < pkg_stats->jiffies_init)
130
131
 		can_init_stats(net);
131
132
 
132
133
 	/* prevent overflow in calc_rate() */
133
-	if (can_stats->rx_frames > (ULONG_MAX / HZ))
134
+	if (pkg_stats->rx_frames > (ULONG_MAX / HZ))
134
135
 		can_init_stats(net);
135
136
 
136
137
 	/* prevent overflow in calc_rate() */
137
-	if (can_stats->tx_frames > (ULONG_MAX / HZ))
138
+	if (pkg_stats->tx_frames > (ULONG_MAX / HZ))
138
139
 		can_init_stats(net);
139
140
 
140
141
 	/* matches overflow - very improbable */
141
-	if (can_stats->matches > (ULONG_MAX / 100))
142
+	if (pkg_stats->matches > (ULONG_MAX / 100))
142
143
 		can_init_stats(net);
143
144
 
144
145
 	/* 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;
146
+	if (pkg_stats->rx_frames)
147
+		pkg_stats->total_rx_match_ratio = (pkg_stats->matches * 100) /
148
+			pkg_stats->rx_frames;
148
149
 
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);
150
+	pkg_stats->total_tx_rate = calc_rate(pkg_stats->jiffies_init, j,
151
+					    pkg_stats->tx_frames);
152
+	pkg_stats->total_rx_rate = calc_rate(pkg_stats->jiffies_init, j,
153
+					    pkg_stats->rx_frames);
153
154
 
154
155
 	/* 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;
156
+	if (pkg_stats->rx_frames_delta)
157
+		pkg_stats->current_rx_match_ratio =
158
+			(pkg_stats->matches_delta * 100) /
159
+			pkg_stats->rx_frames_delta;
159
160
 
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);
161
+	pkg_stats->current_tx_rate = calc_rate(0, HZ, pkg_stats->tx_frames_delta);
162
+	pkg_stats->current_rx_rate = calc_rate(0, HZ, pkg_stats->rx_frames_delta);
162
163
 
163
164
 	/* 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;
165
+	if (pkg_stats->max_tx_rate < pkg_stats->current_tx_rate)
166
+		pkg_stats->max_tx_rate = pkg_stats->current_tx_rate;
166
167
 
167
-	if (can_stats->max_rx_rate < can_stats->current_rx_rate)
168
-		can_stats->max_rx_rate = can_stats->current_rx_rate;
168
+	if (pkg_stats->max_rx_rate < pkg_stats->current_rx_rate)
169
+		pkg_stats->max_rx_rate = pkg_stats->current_rx_rate;
169
170
 
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;
171
+	if (pkg_stats->max_rx_match_ratio < pkg_stats->current_rx_match_ratio)
172
+		pkg_stats->max_rx_match_ratio = pkg_stats->current_rx_match_ratio;
172
173
 
173
174
 	/* 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;
175
+	pkg_stats->tx_frames_delta = 0;
176
+	pkg_stats->rx_frames_delta = 0;
177
+	pkg_stats->matches_delta   = 0;
177
178
 
178
179
 	/* restart timer (one second) */
179
-	mod_timer(&net->can.can_stattimer, round_jiffies(jiffies + HZ));
180
+	mod_timer(&net->can.stattimer, round_jiffies(jiffies + HZ));
180
181
 }
181
182
 
182
183
 /*
..
..
@@ -211,60 +212,60 @@
211
212
 static int can_stats_proc_show(struct seq_file *m, void *v)
212
213
 {
213
214
 	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;
215
+	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
216
+	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
216
217
 
217
218
 	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);
219
+	seq_printf(m, " %8ld transmitted frames (TXF)\n", pkg_stats->tx_frames);
220
+	seq_printf(m, " %8ld received frames (RXF)\n", pkg_stats->rx_frames);
221
+	seq_printf(m, " %8ld matched frames (RXMF)\n", pkg_stats->matches);
221
222
 
222
223
 	seq_putc(m, '\n');
223
224
 
224
-	if (net->can.can_stattimer.function == can_stat_update) {
225
+	if (net->can.stattimer.function == can_stat_update) {
225
226
 		seq_printf(m, " %8ld %% total match ratio (RXMR)\n",
226
-				can_stats->total_rx_match_ratio);
227
+				pkg_stats->total_rx_match_ratio);
227
228
 
228
229
 		seq_printf(m, " %8ld frames/s total tx rate (TXR)\n",
229
-				can_stats->total_tx_rate);
230
+				pkg_stats->total_tx_rate);
230
231
 		seq_printf(m, " %8ld frames/s total rx rate (RXR)\n",
231
-				can_stats->total_rx_rate);
232
+				pkg_stats->total_rx_rate);
232
233
 
233
234
 		seq_putc(m, '\n');
234
235
 
235
236
 		seq_printf(m, " %8ld %% current match ratio (CRXMR)\n",
236
-				can_stats->current_rx_match_ratio);
237
+				pkg_stats->current_rx_match_ratio);
237
238
 
238
239
 		seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n",
239
-				can_stats->current_tx_rate);
240
+				pkg_stats->current_tx_rate);
240
241
 		seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n",
241
-				can_stats->current_rx_rate);
242
+				pkg_stats->current_rx_rate);
242
243
 
243
244
 		seq_putc(m, '\n');
244
245
 
245
246
 		seq_printf(m, " %8ld %% max match ratio (MRXMR)\n",
246
-				can_stats->max_rx_match_ratio);
247
+				pkg_stats->max_rx_match_ratio);
247
248
 
248
249
 		seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n",
249
-				can_stats->max_tx_rate);
250
+				pkg_stats->max_tx_rate);
250
251
 		seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n",
251
-				can_stats->max_rx_rate);
252
+				pkg_stats->max_rx_rate);
252
253
 
253
254
 		seq_putc(m, '\n');
254
255
 	}
255
256
 
256
257
 	seq_printf(m, " %8ld current receive list entries (CRCV)\n",
257
-			can_pstats->rcv_entries);
258
+			rcv_lists_stats->rcv_entries);
258
259
 	seq_printf(m, " %8ld maximum receive list entries (MRCV)\n",
259
-			can_pstats->rcv_entries_max);
260
+			rcv_lists_stats->rcv_entries_max);
260
261
 
261
-	if (can_pstats->stats_reset)
262
+	if (rcv_lists_stats->stats_reset)
262
263
 		seq_printf(m, "\n %8ld statistic resets (STR)\n",
263
-				can_pstats->stats_reset);
264
+				rcv_lists_stats->stats_reset);
264
265
 
265
-	if (can_pstats->user_reset)
266
+	if (rcv_lists_stats->user_reset)
266
267
 		seq_printf(m, " %8ld user statistic resets (USTR)\n",
267
-				can_pstats->user_reset);
268
+				rcv_lists_stats->user_reset);
268
269
 
269
270
 	seq_putc(m, '\n');
270
271
 	return 0;
..
..
@@ -273,37 +274,31 @@
273
274
 static int can_reset_stats_proc_show(struct seq_file *m, void *v)
274
275
 {
275
276
 	struct net *net = m->private;
276
-	struct s_pstats *can_pstats = net->can.can_pstats;
277
-	struct s_stats *can_stats = net->can.can_stats;
277
+	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
278
+	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
278
279
 
279
280
 	user_reset = 1;
280
281
 
281
-	if (net->can.can_stattimer.function == can_stat_update) {
282
+	if (net->can.stattimer.function == can_stat_update) {
282
283
 		seq_printf(m, "Scheduled statistic reset #%ld.\n",
283
-				can_pstats->stats_reset + 1);
284
+				rcv_lists_stats->stats_reset + 1);
284
285
 	} else {
285
-		if (can_stats->jiffies_init != jiffies)
286
+		if (pkg_stats->jiffies_init != jiffies)
286
287
 			can_init_stats(net);
287
288
 
288
289
 		seq_printf(m, "Performed statistic reset #%ld.\n",
289
-				can_pstats->stats_reset);
290
+				rcv_lists_stats->stats_reset);
290
291
 	}
291
-	return 0;
292
-}
293
-
294
-static int can_version_proc_show(struct seq_file *m, void *v)
295
-{
296
-	seq_printf(m, "%s\n", CAN_VERSION_STRING);
297
292
 	return 0;
298
293
 }
299
294
 
300
295
 static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
301
296
 					     struct net_device *dev,
302
-					     struct can_dev_rcv_lists *d)
297
+					     struct can_dev_rcv_lists *dev_rcv_lists)
303
298
 {
304
-	if (!hlist_empty(&d->rx[idx])) {
299
+	if (!hlist_empty(&dev_rcv_lists->rx[idx])) {
305
300
 		can_print_recv_banner(m);
306
-		can_print_rcvlist(m, &d->rx[idx], dev);
301
+		can_print_rcvlist(m, &dev_rcv_lists->rx[idx], dev);
307
302
 	} else
308
303
 		seq_printf(m, "  (%s: no entry)\n", DNAME(dev));
309
304
 
..
..
@@ -314,7 +309,7 @@
314
309
 	/* double cast to prevent GCC warning */
315
310
 	int idx = (int)(long)PDE_DATA(m->file->f_inode);
316
311
 	struct net_device *dev;
317
-	struct can_dev_rcv_lists *d;
312
+	struct can_dev_rcv_lists *dev_rcv_lists;
318
313
 	struct net *net = m->private;
319
314
 
320
315
 	seq_printf(m, "\nreceive list '%s':\n", rx_list_name[idx]);
..
..
@@ -322,13 +317,16 @@
322
317
 	rcu_read_lock();
323
318
 
324
319
 	/* receive list for 'all' CAN devices (dev == NULL) */
325
-	d = net->can.can_rx_alldev_list;
326
-	can_rcvlist_proc_show_one(m, idx, NULL, d);
320
+	dev_rcv_lists = net->can.rx_alldev_list;
321
+	can_rcvlist_proc_show_one(m, idx, NULL, dev_rcv_lists);
327
322
 
328
323
 	/* receive list for registered CAN devices */
329
324
 	for_each_netdev_rcu(net, dev) {
330
-		if (dev->type == ARPHRD_CAN && dev->ml_priv)
331
-			can_rcvlist_proc_show_one(m, idx, dev, dev->ml_priv);
325
+		struct can_ml_priv *can_ml = can_get_ml_priv(dev);
326
+
327
+		if (can_ml)
328
+			can_rcvlist_proc_show_one(m, idx, dev,
329
+						  &can_ml->dev_rcv_lists);
332
330
 	}
333
331
 
334
332
 	rcu_read_unlock();
..
..
@@ -365,7 +363,7 @@
365
363
 static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
366
364
 {
367
365
 	struct net_device *dev;
368
-	struct can_dev_rcv_lists *d;
366
+	struct can_dev_rcv_lists *dev_rcv_lists;
369
367
 	struct net *net = m->private;
370
368
 
371
369
 	/* RX_SFF */
..
..
@@ -374,15 +372,18 @@
374
372
 	rcu_read_lock();
375
373
 
376
374
 	/* sff receive list for 'all' CAN devices (dev == NULL) */
377
-	d = net->can.can_rx_alldev_list;
378
-	can_rcvlist_proc_show_array(m, NULL, d->rx_sff, ARRAY_SIZE(d->rx_sff));
375
+	dev_rcv_lists = net->can.rx_alldev_list;
376
+	can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_sff,
377
+				    ARRAY_SIZE(dev_rcv_lists->rx_sff));
379
378
 
380
379
 	/* sff receive list for registered CAN devices */
381
380
 	for_each_netdev_rcu(net, dev) {
382
-		if (dev->type == ARPHRD_CAN && dev->ml_priv) {
383
-			d = dev->ml_priv;
384
-			can_rcvlist_proc_show_array(m, dev, d->rx_sff,
385
-						    ARRAY_SIZE(d->rx_sff));
381
+		struct can_ml_priv *can_ml = can_get_ml_priv(dev);
382
+
383
+		if (can_ml) {
384
+			dev_rcv_lists = &can_ml->dev_rcv_lists;
385
+			can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_sff,
386
+						    ARRAY_SIZE(dev_rcv_lists->rx_sff));
386
387
 		}
387
388
 	}
388
389
 
..
..
@@ -395,7 +396,7 @@
395
396
 static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
396
397
 {
397
398
 	struct net_device *dev;
398
-	struct can_dev_rcv_lists *d;
399
+	struct can_dev_rcv_lists *dev_rcv_lists;
399
400
 	struct net *net = m->private;
400
401
 
401
402
 	/* RX_EFF */
..
..
@@ -404,15 +405,18 @@
404
405
 	rcu_read_lock();
405
406
 
406
407
 	/* eff receive list for 'all' CAN devices (dev == NULL) */
407
-	d = net->can.can_rx_alldev_list;
408
-	can_rcvlist_proc_show_array(m, NULL, d->rx_eff, ARRAY_SIZE(d->rx_eff));
408
+	dev_rcv_lists = net->can.rx_alldev_list;
409
+	can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_eff,
410
+				    ARRAY_SIZE(dev_rcv_lists->rx_eff));
409
411
 
410
412
 	/* eff receive list for registered CAN devices */
411
413
 	for_each_netdev_rcu(net, dev) {
412
-		if (dev->type == ARPHRD_CAN && dev->ml_priv) {
413
-			d = dev->ml_priv;
414
-			can_rcvlist_proc_show_array(m, dev, d->rx_eff,
415
-						    ARRAY_SIZE(d->rx_eff));
414
+		struct can_ml_priv *can_ml = can_get_ml_priv(dev);
415
+
416
+		if (can_ml) {
417
+			dev_rcv_lists = &can_ml->dev_rcv_lists;
418
+			can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_eff,
419
+						    ARRAY_SIZE(dev_rcv_lists->rx_eff));
416
420
 		}
417
421
 	}
418
422
 
..
..
@@ -437,8 +441,6 @@
437
441
 	}
438
442
 
439
443
 	/* own procfs entries from the AF_CAN core */
440
-	net->can.pde_version = proc_create_net_single(CAN_PROC_VERSION, 0644,
441
-			net->can.proc_dir, can_version_proc_show, NULL);
442
444
 	net->can.pde_stats = proc_create_net_single(CAN_PROC_STATS, 0644,
443
445
 			net->can.proc_dir, can_stats_proc_show, NULL);
444
446
 	net->can.pde_reset_stats = proc_create_net_single(CAN_PROC_RESET_STATS,
..
..
@@ -469,9 +471,6 @@
469
471
 {
470
472
 	if (!net->can.proc_dir)
471
473
 		return;
472
-
473
-	if (net->can.pde_version)
474
-		remove_proc_entry(CAN_PROC_VERSION, net->can.proc_dir);
475
474
 
476
475
 	if (net->can.pde_stats)
477
476
 		remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir);