1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * mac80211 debugfs for wireless PHYs |
4 | * |
5 | * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> |
6 | * Copyright 2013-2014 Intel Mobile Communications GmbH |
7 | * Copyright (C) 2018 - 2019, 2021-2023 Intel Corporation |
8 | */ |
9 | |
10 | #include <linux/debugfs.h> |
11 | #include <linux/rtnetlink.h> |
12 | #include <linux/vmalloc.h> |
13 | #include "ieee80211_i.h" |
14 | #include "driver-ops.h" |
15 | #include "rate.h" |
16 | #include "debugfs.h" |
17 | |
18 | #define DEBUGFS_FORMAT_BUFFER_SIZE 100 |
19 | |
20 | int mac80211_format_buffer(char __user *userbuf, size_t count, |
21 | loff_t *ppos, char *fmt, ...) |
22 | { |
23 | va_list args; |
24 | char buf[DEBUGFS_FORMAT_BUFFER_SIZE]; |
25 | int res; |
26 | |
27 | va_start(args, fmt); |
28 | res = vscnprintf(buf, size: sizeof(buf), fmt, args); |
29 | va_end(args); |
30 | |
31 | return simple_read_from_buffer(to: userbuf, count, ppos, from: buf, available: res); |
32 | } |
33 | |
34 | #define DEBUGFS_READONLY_FILE_FN(name, fmt, value...) \ |
35 | static ssize_t name## _read(struct file *file, char __user *userbuf, \ |
36 | size_t count, loff_t *ppos) \ |
37 | { \ |
38 | struct ieee80211_local *local = file->private_data; \ |
39 | \ |
40 | return mac80211_format_buffer(userbuf, count, ppos, \ |
41 | fmt "\n", ##value); \ |
42 | } |
43 | |
44 | #define DEBUGFS_READONLY_FILE_OPS(name) \ |
45 | static const struct file_operations name## _ops = { \ |
46 | .read = name## _read, \ |
47 | .open = simple_open, \ |
48 | .llseek = generic_file_llseek, \ |
49 | }; |
50 | |
51 | #define DEBUGFS_READONLY_FILE(name, fmt, value...) \ |
52 | DEBUGFS_READONLY_FILE_FN(name, fmt, value) \ |
53 | DEBUGFS_READONLY_FILE_OPS(name) |
54 | |
55 | #define DEBUGFS_ADD(name) \ |
56 | debugfs_create_file(#name, 0400, phyd, local, &name## _ops) |
57 | |
58 | #define DEBUGFS_ADD_MODE(name, mode) \ |
59 | debugfs_create_file(#name, mode, phyd, local, &name## _ops); |
60 | |
61 | |
62 | DEBUGFS_READONLY_FILE(hw_conf, "%x" , |
63 | local->hw.conf.flags); |
64 | DEBUGFS_READONLY_FILE(user_power, "%d" , |
65 | local->user_power_level); |
66 | DEBUGFS_READONLY_FILE(power, "%d" , |
67 | local->hw.conf.power_level); |
68 | DEBUGFS_READONLY_FILE(total_ps_buffered, "%d" , |
69 | local->total_ps_buffered); |
70 | DEBUGFS_READONLY_FILE(wep_iv, "%#08x" , |
71 | local->wep_iv & 0xffffff); |
72 | DEBUGFS_READONLY_FILE(rate_ctrl_alg, "%s" , |
73 | local->rate_ctrl ? local->rate_ctrl->ops->name : "hw/driver" ); |
74 | |
75 | static ssize_t aqm_read(struct file *file, |
76 | char __user *user_buf, |
77 | size_t count, |
78 | loff_t *ppos) |
79 | { |
80 | struct ieee80211_local *local = file->private_data; |
81 | struct fq *fq = &local->fq; |
82 | char buf[200]; |
83 | int len = 0; |
84 | |
85 | spin_lock_bh(lock: &local->fq.lock); |
86 | rcu_read_lock(); |
87 | |
88 | len = scnprintf(buf, size: sizeof(buf), |
89 | fmt: "access name value\n" |
90 | "R fq_flows_cnt %u\n" |
91 | "R fq_backlog %u\n" |
92 | "R fq_overlimit %u\n" |
93 | "R fq_overmemory %u\n" |
94 | "R fq_collisions %u\n" |
95 | "R fq_memory_usage %u\n" |
96 | "RW fq_memory_limit %u\n" |
97 | "RW fq_limit %u\n" |
98 | "RW fq_quantum %u\n" , |
99 | fq->flows_cnt, |
100 | fq->backlog, |
101 | fq->overmemory, |
102 | fq->overlimit, |
103 | fq->collisions, |
104 | fq->memory_usage, |
105 | fq->memory_limit, |
106 | fq->limit, |
107 | fq->quantum); |
108 | |
109 | rcu_read_unlock(); |
110 | spin_unlock_bh(lock: &local->fq.lock); |
111 | |
112 | return simple_read_from_buffer(to: user_buf, count, ppos, |
113 | from: buf, available: len); |
114 | } |
115 | |
116 | static ssize_t aqm_write(struct file *file, |
117 | const char __user *user_buf, |
118 | size_t count, |
119 | loff_t *ppos) |
120 | { |
121 | struct ieee80211_local *local = file->private_data; |
122 | char buf[100]; |
123 | |
124 | if (count >= sizeof(buf)) |
125 | return -EINVAL; |
126 | |
127 | if (copy_from_user(to: buf, from: user_buf, n: count)) |
128 | return -EFAULT; |
129 | |
130 | if (count && buf[count - 1] == '\n') |
131 | buf[count - 1] = '\0'; |
132 | else |
133 | buf[count] = '\0'; |
134 | |
135 | if (sscanf(buf, "fq_limit %u" , &local->fq.limit) == 1) |
136 | return count; |
137 | else if (sscanf(buf, "fq_memory_limit %u" , &local->fq.memory_limit) == 1) |
138 | return count; |
139 | else if (sscanf(buf, "fq_quantum %u" , &local->fq.quantum) == 1) |
140 | return count; |
141 | |
142 | return -EINVAL; |
143 | } |
144 | |
145 | static const struct file_operations aqm_ops = { |
146 | .write = aqm_write, |
147 | .read = aqm_read, |
148 | .open = simple_open, |
149 | .llseek = default_llseek, |
150 | }; |
151 | |
152 | static ssize_t airtime_flags_read(struct file *file, |
153 | char __user *user_buf, |
154 | size_t count, loff_t *ppos) |
155 | { |
156 | struct ieee80211_local *local = file->private_data; |
157 | char buf[128] = {}, *pos, *end; |
158 | |
159 | pos = buf; |
160 | end = pos + sizeof(buf) - 1; |
161 | |
162 | if (local->airtime_flags & AIRTIME_USE_TX) |
163 | pos += scnprintf(buf: pos, size: end - pos, fmt: "AIRTIME_TX\t(%lx)\n" , |
164 | AIRTIME_USE_TX); |
165 | if (local->airtime_flags & AIRTIME_USE_RX) |
166 | pos += scnprintf(buf: pos, size: end - pos, fmt: "AIRTIME_RX\t(%lx)\n" , |
167 | AIRTIME_USE_RX); |
168 | |
169 | return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, |
170 | strlen(buf)); |
171 | } |
172 | |
173 | static ssize_t airtime_flags_write(struct file *file, |
174 | const char __user *user_buf, |
175 | size_t count, loff_t *ppos) |
176 | { |
177 | struct ieee80211_local *local = file->private_data; |
178 | char buf[16]; |
179 | |
180 | if (count >= sizeof(buf)) |
181 | return -EINVAL; |
182 | |
183 | if (copy_from_user(to: buf, from: user_buf, n: count)) |
184 | return -EFAULT; |
185 | |
186 | if (count && buf[count - 1] == '\n') |
187 | buf[count - 1] = '\0'; |
188 | else |
189 | buf[count] = '\0'; |
190 | |
191 | if (kstrtou16(s: buf, base: 0, res: &local->airtime_flags)) |
192 | return -EINVAL; |
193 | |
194 | return count; |
195 | } |
196 | |
197 | static const struct file_operations airtime_flags_ops = { |
198 | .write = airtime_flags_write, |
199 | .read = airtime_flags_read, |
200 | .open = simple_open, |
201 | .llseek = default_llseek, |
202 | }; |
203 | |
204 | static ssize_t aql_pending_read(struct file *file, |
205 | char __user *user_buf, |
206 | size_t count, loff_t *ppos) |
207 | { |
208 | struct ieee80211_local *local = file->private_data; |
209 | char buf[400]; |
210 | int len = 0; |
211 | |
212 | len = scnprintf(buf, size: sizeof(buf), |
213 | fmt: "AC AQL pending\n" |
214 | "VO %u us\n" |
215 | "VI %u us\n" |
216 | "BE %u us\n" |
217 | "BK %u us\n" |
218 | "total %u us\n" , |
219 | atomic_read(v: &local->aql_ac_pending_airtime[IEEE80211_AC_VO]), |
220 | atomic_read(v: &local->aql_ac_pending_airtime[IEEE80211_AC_VI]), |
221 | atomic_read(v: &local->aql_ac_pending_airtime[IEEE80211_AC_BE]), |
222 | atomic_read(v: &local->aql_ac_pending_airtime[IEEE80211_AC_BK]), |
223 | atomic_read(v: &local->aql_total_pending_airtime)); |
224 | return simple_read_from_buffer(to: user_buf, count, ppos, |
225 | from: buf, available: len); |
226 | } |
227 | |
228 | static const struct file_operations aql_pending_ops = { |
229 | .read = aql_pending_read, |
230 | .open = simple_open, |
231 | .llseek = default_llseek, |
232 | }; |
233 | |
234 | static ssize_t aql_txq_limit_read(struct file *file, |
235 | char __user *user_buf, |
236 | size_t count, |
237 | loff_t *ppos) |
238 | { |
239 | struct ieee80211_local *local = file->private_data; |
240 | char buf[400]; |
241 | int len = 0; |
242 | |
243 | len = scnprintf(buf, size: sizeof(buf), |
244 | fmt: "AC AQL limit low AQL limit high\n" |
245 | "VO %u %u\n" |
246 | "VI %u %u\n" |
247 | "BE %u %u\n" |
248 | "BK %u %u\n" , |
249 | local->aql_txq_limit_low[IEEE80211_AC_VO], |
250 | local->aql_txq_limit_high[IEEE80211_AC_VO], |
251 | local->aql_txq_limit_low[IEEE80211_AC_VI], |
252 | local->aql_txq_limit_high[IEEE80211_AC_VI], |
253 | local->aql_txq_limit_low[IEEE80211_AC_BE], |
254 | local->aql_txq_limit_high[IEEE80211_AC_BE], |
255 | local->aql_txq_limit_low[IEEE80211_AC_BK], |
256 | local->aql_txq_limit_high[IEEE80211_AC_BK]); |
257 | return simple_read_from_buffer(to: user_buf, count, ppos, |
258 | from: buf, available: len); |
259 | } |
260 | |
261 | static ssize_t aql_txq_limit_write(struct file *file, |
262 | const char __user *user_buf, |
263 | size_t count, |
264 | loff_t *ppos) |
265 | { |
266 | struct ieee80211_local *local = file->private_data; |
267 | char buf[100]; |
268 | u32 ac, q_limit_low, q_limit_high, q_limit_low_old, q_limit_high_old; |
269 | struct sta_info *sta; |
270 | |
271 | if (count >= sizeof(buf)) |
272 | return -EINVAL; |
273 | |
274 | if (copy_from_user(to: buf, from: user_buf, n: count)) |
275 | return -EFAULT; |
276 | |
277 | if (count && buf[count - 1] == '\n') |
278 | buf[count - 1] = '\0'; |
279 | else |
280 | buf[count] = '\0'; |
281 | |
282 | if (sscanf(buf, "%u %u %u" , &ac, &q_limit_low, &q_limit_high) != 3) |
283 | return -EINVAL; |
284 | |
285 | if (ac >= IEEE80211_NUM_ACS) |
286 | return -EINVAL; |
287 | |
288 | q_limit_low_old = local->aql_txq_limit_low[ac]; |
289 | q_limit_high_old = local->aql_txq_limit_high[ac]; |
290 | |
291 | wiphy_lock(wiphy: local->hw.wiphy); |
292 | local->aql_txq_limit_low[ac] = q_limit_low; |
293 | local->aql_txq_limit_high[ac] = q_limit_high; |
294 | |
295 | list_for_each_entry(sta, &local->sta_list, list) { |
296 | /* If a sta has customized queue limits, keep it */ |
297 | if (sta->airtime[ac].aql_limit_low == q_limit_low_old && |
298 | sta->airtime[ac].aql_limit_high == q_limit_high_old) { |
299 | sta->airtime[ac].aql_limit_low = q_limit_low; |
300 | sta->airtime[ac].aql_limit_high = q_limit_high; |
301 | } |
302 | } |
303 | wiphy_unlock(wiphy: local->hw.wiphy); |
304 | |
305 | return count; |
306 | } |
307 | |
308 | static const struct file_operations aql_txq_limit_ops = { |
309 | .write = aql_txq_limit_write, |
310 | .read = aql_txq_limit_read, |
311 | .open = simple_open, |
312 | .llseek = default_llseek, |
313 | }; |
314 | |
315 | static ssize_t aql_enable_read(struct file *file, char __user *user_buf, |
316 | size_t count, loff_t *ppos) |
317 | { |
318 | char buf[3]; |
319 | int len; |
320 | |
321 | len = scnprintf(buf, size: sizeof(buf), fmt: "%d\n" , |
322 | !static_key_false(key: &aql_disable.key)); |
323 | |
324 | return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len); |
325 | } |
326 | |
327 | static ssize_t aql_enable_write(struct file *file, const char __user *user_buf, |
328 | size_t count, loff_t *ppos) |
329 | { |
330 | bool aql_disabled = static_key_false(key: &aql_disable.key); |
331 | char buf[3]; |
332 | size_t len; |
333 | |
334 | if (count > sizeof(buf)) |
335 | return -EINVAL; |
336 | |
337 | if (copy_from_user(to: buf, from: user_buf, n: count)) |
338 | return -EFAULT; |
339 | |
340 | buf[sizeof(buf) - 1] = '\0'; |
341 | len = strlen(buf); |
342 | if (len > 0 && buf[len - 1] == '\n') |
343 | buf[len - 1] = 0; |
344 | |
345 | if (buf[0] == '0' && buf[1] == '\0') { |
346 | if (!aql_disabled) |
347 | static_branch_inc(&aql_disable); |
348 | } else if (buf[0] == '1' && buf[1] == '\0') { |
349 | if (aql_disabled) |
350 | static_branch_dec(&aql_disable); |
351 | } else { |
352 | return -EINVAL; |
353 | } |
354 | |
355 | return count; |
356 | } |
357 | |
358 | static const struct file_operations aql_enable_ops = { |
359 | .write = aql_enable_write, |
360 | .read = aql_enable_read, |
361 | .open = simple_open, |
362 | .llseek = default_llseek, |
363 | }; |
364 | |
365 | static ssize_t force_tx_status_read(struct file *file, |
366 | char __user *user_buf, |
367 | size_t count, |
368 | loff_t *ppos) |
369 | { |
370 | struct ieee80211_local *local = file->private_data; |
371 | char buf[3]; |
372 | int len = 0; |
373 | |
374 | len = scnprintf(buf, size: sizeof(buf), fmt: "%d\n" , (int)local->force_tx_status); |
375 | |
376 | return simple_read_from_buffer(to: user_buf, count, ppos, |
377 | from: buf, available: len); |
378 | } |
379 | |
380 | static ssize_t force_tx_status_write(struct file *file, |
381 | const char __user *user_buf, |
382 | size_t count, |
383 | loff_t *ppos) |
384 | { |
385 | struct ieee80211_local *local = file->private_data; |
386 | char buf[3]; |
387 | |
388 | if (count >= sizeof(buf)) |
389 | return -EINVAL; |
390 | |
391 | if (copy_from_user(to: buf, from: user_buf, n: count)) |
392 | return -EFAULT; |
393 | |
394 | if (count && buf[count - 1] == '\n') |
395 | buf[count - 1] = '\0'; |
396 | else |
397 | buf[count] = '\0'; |
398 | |
399 | if (buf[0] == '0' && buf[1] == '\0') |
400 | local->force_tx_status = 0; |
401 | else if (buf[0] == '1' && buf[1] == '\0') |
402 | local->force_tx_status = 1; |
403 | else |
404 | return -EINVAL; |
405 | |
406 | return count; |
407 | } |
408 | |
409 | static const struct file_operations force_tx_status_ops = { |
410 | .write = force_tx_status_write, |
411 | .read = force_tx_status_read, |
412 | .open = simple_open, |
413 | .llseek = default_llseek, |
414 | }; |
415 | |
416 | #ifdef CONFIG_PM |
417 | static ssize_t reset_write(struct file *file, const char __user *user_buf, |
418 | size_t count, loff_t *ppos) |
419 | { |
420 | struct ieee80211_local *local = file->private_data; |
421 | int ret; |
422 | |
423 | rtnl_lock(); |
424 | wiphy_lock(wiphy: local->hw.wiphy); |
425 | __ieee80211_suspend(hw: &local->hw, NULL); |
426 | ret = __ieee80211_resume(hw: &local->hw); |
427 | wiphy_unlock(wiphy: local->hw.wiphy); |
428 | |
429 | if (ret) |
430 | cfg80211_shutdown_all_interfaces(wiphy: local->hw.wiphy); |
431 | |
432 | rtnl_unlock(); |
433 | |
434 | return count; |
435 | } |
436 | |
437 | static const struct file_operations reset_ops = { |
438 | .write = reset_write, |
439 | .open = simple_open, |
440 | .llseek = noop_llseek, |
441 | }; |
442 | #endif |
443 | |
444 | static const char *hw_flag_names[] = { |
445 | #define FLAG(F) [IEEE80211_HW_##F] = #F |
446 | FLAG(HAS_RATE_CONTROL), |
447 | FLAG(RX_INCLUDES_FCS), |
448 | FLAG(HOST_BROADCAST_PS_BUFFERING), |
449 | FLAG(SIGNAL_UNSPEC), |
450 | FLAG(SIGNAL_DBM), |
451 | FLAG(NEED_DTIM_BEFORE_ASSOC), |
452 | FLAG(SPECTRUM_MGMT), |
453 | FLAG(AMPDU_AGGREGATION), |
454 | FLAG(SUPPORTS_PS), |
455 | FLAG(PS_NULLFUNC_STACK), |
456 | FLAG(SUPPORTS_DYNAMIC_PS), |
457 | FLAG(MFP_CAPABLE), |
458 | FLAG(WANT_MONITOR_VIF), |
459 | FLAG(NO_AUTO_VIF), |
460 | FLAG(SW_CRYPTO_CONTROL), |
461 | FLAG(SUPPORT_FAST_XMIT), |
462 | FLAG(REPORTS_TX_ACK_STATUS), |
463 | FLAG(CONNECTION_MONITOR), |
464 | FLAG(QUEUE_CONTROL), |
465 | FLAG(SUPPORTS_PER_STA_GTK), |
466 | FLAG(AP_LINK_PS), |
467 | FLAG(TX_AMPDU_SETUP_IN_HW), |
468 | FLAG(SUPPORTS_RC_TABLE), |
469 | FLAG(P2P_DEV_ADDR_FOR_INTF), |
470 | FLAG(TIMING_BEACON_ONLY), |
471 | FLAG(SUPPORTS_HT_CCK_RATES), |
472 | FLAG(CHANCTX_STA_CSA), |
473 | FLAG(SUPPORTS_CLONED_SKBS), |
474 | FLAG(SINGLE_SCAN_ON_ALL_BANDS), |
475 | FLAG(TDLS_WIDER_BW), |
476 | FLAG(SUPPORTS_AMSDU_IN_AMPDU), |
477 | FLAG(BEACON_TX_STATUS), |
478 | FLAG(NEEDS_UNIQUE_STA_ADDR), |
479 | FLAG(SUPPORTS_REORDERING_BUFFER), |
480 | FLAG(USES_RSS), |
481 | FLAG(TX_AMSDU), |
482 | FLAG(TX_FRAG_LIST), |
483 | FLAG(REPORTS_LOW_ACK), |
484 | FLAG(SUPPORTS_TX_FRAG), |
485 | FLAG(SUPPORTS_TDLS_BUFFER_STA), |
486 | FLAG(DEAUTH_NEED_MGD_TX_PREP), |
487 | FLAG(DOESNT_SUPPORT_QOS_NDP), |
488 | FLAG(BUFF_MMPDU_TXQ), |
489 | FLAG(SUPPORTS_VHT_EXT_NSS_BW), |
490 | FLAG(STA_MMPDU_TXQ), |
491 | FLAG(TX_STATUS_NO_AMPDU_LEN), |
492 | FLAG(SUPPORTS_MULTI_BSSID), |
493 | FLAG(SUPPORTS_ONLY_HE_MULTI_BSSID), |
494 | FLAG(AMPDU_KEYBORDER_SUPPORT), |
495 | FLAG(SUPPORTS_TX_ENCAP_OFFLOAD), |
496 | FLAG(SUPPORTS_RX_DECAP_OFFLOAD), |
497 | FLAG(SUPPORTS_CONC_MON_RX_DECAP), |
498 | FLAG(DETECTS_COLOR_COLLISION), |
499 | FLAG(MLO_MCAST_MULTI_LINK_TX), |
500 | #undef FLAG |
501 | }; |
502 | |
503 | static ssize_t hwflags_read(struct file *file, char __user *user_buf, |
504 | size_t count, loff_t *ppos) |
505 | { |
506 | struct ieee80211_local *local = file->private_data; |
507 | size_t bufsz = 30 * NUM_IEEE80211_HW_FLAGS; |
508 | char *buf = kzalloc(size: bufsz, GFP_KERNEL); |
509 | char *pos = buf, *end = buf + bufsz - 1; |
510 | ssize_t rv; |
511 | int i; |
512 | |
513 | if (!buf) |
514 | return -ENOMEM; |
515 | |
516 | /* fail compilation if somebody adds or removes |
517 | * a flag without updating the name array above |
518 | */ |
519 | BUILD_BUG_ON(ARRAY_SIZE(hw_flag_names) != NUM_IEEE80211_HW_FLAGS); |
520 | |
521 | for (i = 0; i < NUM_IEEE80211_HW_FLAGS; i++) { |
522 | if (test_bit(i, local->hw.flags)) |
523 | pos += scnprintf(buf: pos, size: end - pos, fmt: "%s\n" , |
524 | hw_flag_names[i]); |
525 | } |
526 | |
527 | rv = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, strlen(buf)); |
528 | kfree(objp: buf); |
529 | return rv; |
530 | } |
531 | |
532 | static ssize_t misc_read(struct file *file, char __user *user_buf, |
533 | size_t count, loff_t *ppos) |
534 | { |
535 | struct ieee80211_local *local = file->private_data; |
536 | /* Max len of each line is 16 characters, plus 9 for 'pending:\n' */ |
537 | size_t bufsz = IEEE80211_MAX_QUEUES * 16 + 9; |
538 | char *buf; |
539 | char *pos, *end; |
540 | ssize_t rv; |
541 | int i; |
542 | int ln; |
543 | |
544 | buf = kzalloc(size: bufsz, GFP_KERNEL); |
545 | if (!buf) |
546 | return -ENOMEM; |
547 | |
548 | pos = buf; |
549 | end = buf + bufsz - 1; |
550 | |
551 | pos += scnprintf(buf: pos, size: end - pos, fmt: "pending:\n" ); |
552 | |
553 | for (i = 0; i < IEEE80211_MAX_QUEUES; i++) { |
554 | ln = skb_queue_len(list_: &local->pending[i]); |
555 | pos += scnprintf(buf: pos, size: end - pos, fmt: "[%i] %d\n" , |
556 | i, ln); |
557 | } |
558 | |
559 | rv = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, strlen(buf)); |
560 | kfree(objp: buf); |
561 | return rv; |
562 | } |
563 | |
564 | static ssize_t queues_read(struct file *file, char __user *user_buf, |
565 | size_t count, loff_t *ppos) |
566 | { |
567 | struct ieee80211_local *local = file->private_data; |
568 | unsigned long flags; |
569 | char buf[IEEE80211_MAX_QUEUES * 20]; |
570 | int q, res = 0; |
571 | |
572 | spin_lock_irqsave(&local->queue_stop_reason_lock, flags); |
573 | for (q = 0; q < local->hw.queues; q++) |
574 | res += sprintf(buf: buf + res, fmt: "%02d: %#.8lx/%d\n" , q, |
575 | local->queue_stop_reasons[q], |
576 | skb_queue_len(list_: &local->pending[q])); |
577 | spin_unlock_irqrestore(lock: &local->queue_stop_reason_lock, flags); |
578 | |
579 | return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: res); |
580 | } |
581 | |
582 | DEBUGFS_READONLY_FILE_OPS(hwflags); |
583 | DEBUGFS_READONLY_FILE_OPS(queues); |
584 | DEBUGFS_READONLY_FILE_OPS(misc); |
585 | |
586 | /* statistics stuff */ |
587 | |
588 | static ssize_t format_devstat_counter(struct ieee80211_local *local, |
589 | char __user *userbuf, |
590 | size_t count, loff_t *ppos, |
591 | int (*printvalue)(struct ieee80211_low_level_stats *stats, char *buf, |
592 | int buflen)) |
593 | { |
594 | struct ieee80211_low_level_stats stats; |
595 | char buf[20]; |
596 | int res; |
597 | |
598 | wiphy_lock(wiphy: local->hw.wiphy); |
599 | res = drv_get_stats(local, stats: &stats); |
600 | wiphy_unlock(wiphy: local->hw.wiphy); |
601 | if (res) |
602 | return res; |
603 | res = printvalue(&stats, buf, sizeof(buf)); |
604 | return simple_read_from_buffer(to: userbuf, count, ppos, from: buf, available: res); |
605 | } |
606 | |
607 | #define DEBUGFS_DEVSTATS_FILE(name) \ |
608 | static int print_devstats_##name(struct ieee80211_low_level_stats *stats,\ |
609 | char *buf, int buflen) \ |
610 | { \ |
611 | return scnprintf(buf, buflen, "%u\n", stats->name); \ |
612 | } \ |
613 | static ssize_t stats_ ##name## _read(struct file *file, \ |
614 | char __user *userbuf, \ |
615 | size_t count, loff_t *ppos) \ |
616 | { \ |
617 | return format_devstat_counter(file->private_data, \ |
618 | userbuf, \ |
619 | count, \ |
620 | ppos, \ |
621 | print_devstats_##name); \ |
622 | } \ |
623 | \ |
624 | static const struct file_operations stats_ ##name## _ops = { \ |
625 | .read = stats_ ##name## _read, \ |
626 | .open = simple_open, \ |
627 | .llseek = generic_file_llseek, \ |
628 | }; |
629 | |
630 | #ifdef CONFIG_MAC80211_DEBUG_COUNTERS |
631 | #define DEBUGFS_STATS_ADD(name) \ |
632 | debugfs_create_u32(#name, 0400, statsd, &local->name); |
633 | #endif |
634 | #define DEBUGFS_DEVSTATS_ADD(name) \ |
635 | debugfs_create_file(#name, 0400, statsd, local, &stats_ ##name## _ops); |
636 | |
637 | DEBUGFS_DEVSTATS_FILE(dot11ACKFailureCount); |
638 | DEBUGFS_DEVSTATS_FILE(dot11RTSFailureCount); |
639 | DEBUGFS_DEVSTATS_FILE(dot11FCSErrorCount); |
640 | DEBUGFS_DEVSTATS_FILE(dot11RTSSuccessCount); |
641 | |
642 | void debugfs_hw_add(struct ieee80211_local *local) |
643 | { |
644 | struct dentry *phyd = local->hw.wiphy->debugfsdir; |
645 | struct dentry *statsd; |
646 | |
647 | if (!phyd) |
648 | return; |
649 | |
650 | local->debugfs.keys = debugfs_create_dir(name: "keys" , parent: phyd); |
651 | |
652 | DEBUGFS_ADD(total_ps_buffered); |
653 | DEBUGFS_ADD(wep_iv); |
654 | DEBUGFS_ADD(rate_ctrl_alg); |
655 | DEBUGFS_ADD(queues); |
656 | DEBUGFS_ADD(misc); |
657 | #ifdef CONFIG_PM |
658 | DEBUGFS_ADD_MODE(reset, 0200); |
659 | #endif |
660 | DEBUGFS_ADD(hwflags); |
661 | DEBUGFS_ADD(user_power); |
662 | DEBUGFS_ADD(power); |
663 | DEBUGFS_ADD(hw_conf); |
664 | DEBUGFS_ADD_MODE(force_tx_status, 0600); |
665 | DEBUGFS_ADD_MODE(aql_enable, 0600); |
666 | DEBUGFS_ADD(aql_pending); |
667 | DEBUGFS_ADD_MODE(aqm, 0600); |
668 | |
669 | DEBUGFS_ADD_MODE(airtime_flags, 0600); |
670 | |
671 | DEBUGFS_ADD(aql_txq_limit); |
672 | debugfs_create_u32(name: "aql_threshold" , mode: 0600, |
673 | parent: phyd, value: &local->aql_threshold); |
674 | |
675 | statsd = debugfs_create_dir(name: "statistics" , parent: phyd); |
676 | |
677 | #ifdef CONFIG_MAC80211_DEBUG_COUNTERS |
678 | DEBUGFS_STATS_ADD(dot11TransmittedFragmentCount); |
679 | DEBUGFS_STATS_ADD(dot11MulticastTransmittedFrameCount); |
680 | DEBUGFS_STATS_ADD(dot11FailedCount); |
681 | DEBUGFS_STATS_ADD(dot11RetryCount); |
682 | DEBUGFS_STATS_ADD(dot11MultipleRetryCount); |
683 | DEBUGFS_STATS_ADD(dot11FrameDuplicateCount); |
684 | DEBUGFS_STATS_ADD(dot11ReceivedFragmentCount); |
685 | DEBUGFS_STATS_ADD(dot11MulticastReceivedFrameCount); |
686 | DEBUGFS_STATS_ADD(dot11TransmittedFrameCount); |
687 | DEBUGFS_STATS_ADD(tx_handlers_drop); |
688 | DEBUGFS_STATS_ADD(tx_handlers_queued); |
689 | DEBUGFS_STATS_ADD(tx_handlers_drop_wep); |
690 | DEBUGFS_STATS_ADD(tx_handlers_drop_not_assoc); |
691 | DEBUGFS_STATS_ADD(tx_handlers_drop_unauth_port); |
692 | DEBUGFS_STATS_ADD(rx_handlers_drop); |
693 | DEBUGFS_STATS_ADD(rx_handlers_queued); |
694 | DEBUGFS_STATS_ADD(rx_handlers_drop_nullfunc); |
695 | DEBUGFS_STATS_ADD(rx_handlers_drop_defrag); |
696 | DEBUGFS_STATS_ADD(tx_expand_skb_head); |
697 | DEBUGFS_STATS_ADD(tx_expand_skb_head_cloned); |
698 | DEBUGFS_STATS_ADD(rx_expand_skb_head_defrag); |
699 | DEBUGFS_STATS_ADD(rx_handlers_fragments); |
700 | DEBUGFS_STATS_ADD(tx_status_drop); |
701 | #endif |
702 | DEBUGFS_DEVSTATS_ADD(dot11ACKFailureCount); |
703 | DEBUGFS_DEVSTATS_ADD(dot11RTSFailureCount); |
704 | DEBUGFS_DEVSTATS_ADD(dot11FCSErrorCount); |
705 | DEBUGFS_DEVSTATS_ADD(dot11RTSSuccessCount); |
706 | } |
707 | |