1 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 * 8 * GPLv2 9 * 10 */ 11 12 #include <linux/debugfs.h> 13 #include <linux/rtnetlink.h> 14 #include "ieee80211_i.h" 15 #include "driver-ops.h" 16 #include "rate.h" 17 #include "debugfs.h" 18 19 #define DEBUGFS_FORMAT_BUFFER_SIZE 100 20 21 #define TX_LATENCY_BIN_DELIMTER_C ',' 22 #define TX_LATENCY_BIN_DELIMTER_S "," 23 #define TX_LATENCY_BINS_DISABLED "enable(bins disabled)\n" 24 #define TX_LATENCY_DISABLED "disable\n" 25 26 27 /* 28 * Display if Tx latency statistics & bins are enabled/disabled 29 */ 30 static ssize_t sta_tx_latency_stat_read(struct file *file, 31 char __user *userbuf, 32 size_t count, loff_t *ppos) 33 { 34 struct ieee80211_local *local = file->private_data; 35 struct ieee80211_tx_latency_bin_ranges *tx_latency; 36 char *buf; 37 int bufsz, i, ret; 38 int pos = 0; 39 40 rcu_read_lock(); 41 42 tx_latency = rcu_dereference(local->tx_latency); 43 44 if (tx_latency && tx_latency->n_ranges) { 45 bufsz = tx_latency->n_ranges * 15; 46 buf = kzalloc(bufsz, GFP_ATOMIC); 47 if (!buf) 48 goto err; 49 50 for (i = 0; i < tx_latency->n_ranges; i++) 51 pos += scnprintf(buf + pos, bufsz - pos, "%d,", 52 tx_latency->ranges[i]); 53 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 54 } else if (tx_latency) { 55 bufsz = sizeof(TX_LATENCY_BINS_DISABLED) + 1; 56 buf = kzalloc(bufsz, GFP_ATOMIC); 57 if (!buf) 58 goto err; 59 60 pos += scnprintf(buf + pos, bufsz - pos, "%s\n", 61 TX_LATENCY_BINS_DISABLED); 62 } else { 63 bufsz = sizeof(TX_LATENCY_DISABLED) + 1; 64 buf = kzalloc(bufsz, GFP_ATOMIC); 65 if (!buf) 66 goto err; 67 68 pos += scnprintf(buf + pos, bufsz - pos, "%s\n", 69 TX_LATENCY_DISABLED); 70 } 71 72 rcu_read_unlock(); 73 74 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos); 75 kfree(buf); 76 77 return ret; 78 err: 79 rcu_read_unlock(); 80 return -ENOMEM; 81 } 82 83 /* 84 * Receive input from user regarding Tx latency statistics 85 * The input should indicate if Tx latency statistics and bins are 86 * enabled/disabled. 87 * If bins are enabled input should indicate the amount of different bins and 88 * their ranges. Each bin will count how many Tx frames transmitted within the 89 * appropriate latency. 90 * Legal input is: 91 * a) "enable(bins disabled)" - to enable only general statistics 92 * b) "a,b,c,d,...z" - to enable general statistics and bins, where all are 93 * numbers and a < b < c < d.. < z 94 * c) "disable" - disable all statistics 95 * NOTE: must configure Tx latency statistics bins before stations connected. 96 */ 97 98 static ssize_t sta_tx_latency_stat_write(struct file *file, 99 const char __user *userbuf, 100 size_t count, loff_t *ppos) 101 { 102 struct ieee80211_local *local = file->private_data; 103 char buf[128] = {}; 104 char *bins = buf; 105 char *token; 106 int buf_size, i, alloc_size; 107 int prev_bin = 0; 108 int n_ranges = 0; 109 int ret = count; 110 struct ieee80211_tx_latency_bin_ranges *tx_latency; 111 112 if (sizeof(buf) <= count) 113 return -EINVAL; 114 buf_size = count; 115 if (copy_from_user(buf, userbuf, buf_size)) 116 return -EFAULT; 117 118 mutex_lock(&local->sta_mtx); 119 120 /* cannot change config once we have stations */ 121 if (local->num_sta) 122 goto unlock; 123 124 tx_latency = 125 rcu_dereference_protected(local->tx_latency, 126 lockdep_is_held(&local->sta_mtx)); 127 128 /* disable Tx statistics */ 129 if (!strcmp(buf, TX_LATENCY_DISABLED)) { 130 if (!tx_latency) 131 goto unlock; 132 RCU_INIT_POINTER(local->tx_latency, NULL); 133 synchronize_rcu(); 134 kfree(tx_latency); 135 goto unlock; 136 } 137 138 /* Tx latency already enabled */ 139 if (tx_latency) 140 goto unlock; 141 142 if (strcmp(TX_LATENCY_BINS_DISABLED, buf)) { 143 /* check how many bins and between what ranges user requested */ 144 token = buf; 145 while (*token != '\0') { 146 if (*token == TX_LATENCY_BIN_DELIMTER_C) 147 n_ranges++; 148 token++; 149 } 150 n_ranges++; 151 } 152 153 alloc_size = sizeof(struct ieee80211_tx_latency_bin_ranges) + 154 n_ranges * sizeof(u32); 155 tx_latency = kzalloc(alloc_size, GFP_ATOMIC); 156 if (!tx_latency) { 157 ret = -ENOMEM; 158 goto unlock; 159 } 160 tx_latency->n_ranges = n_ranges; 161 for (i = 0; i < n_ranges; i++) { /* setting bin ranges */ 162 token = strsep(&bins, TX_LATENCY_BIN_DELIMTER_S); 163 sscanf(token, "%d", &tx_latency->ranges[i]); 164 /* bins values should be in ascending order */ 165 if (prev_bin >= tx_latency->ranges[i]) { 166 ret = -EINVAL; 167 kfree(tx_latency); 168 goto unlock; 169 } 170 prev_bin = tx_latency->ranges[i]; 171 } 172 rcu_assign_pointer(local->tx_latency, tx_latency); 173 174 unlock: 175 mutex_unlock(&local->sta_mtx); 176 177 return ret; 178 } 179 180 static const struct file_operations stats_tx_latency_ops = { 181 .write = sta_tx_latency_stat_write, 182 .read = sta_tx_latency_stat_read, 183 .open = simple_open, 184 .llseek = generic_file_llseek, 185 }; 186 187 int mac80211_format_buffer(char __user *userbuf, size_t count, 188 loff_t *ppos, char *fmt, ...) 189 { 190 va_list args; 191 char buf[DEBUGFS_FORMAT_BUFFER_SIZE]; 192 int res; 193 194 va_start(args, fmt); 195 res = vscnprintf(buf, sizeof(buf), fmt, args); 196 va_end(args); 197 198 return simple_read_from_buffer(userbuf, count, ppos, buf, res); 199 } 200 201 #define DEBUGFS_READONLY_FILE_FN(name, fmt, value...) \ 202 static ssize_t name## _read(struct file *file, char __user *userbuf, \ 203 size_t count, loff_t *ppos) \ 204 { \ 205 struct ieee80211_local *local = file->private_data; \ 206 \ 207 return mac80211_format_buffer(userbuf, count, ppos, \ 208 fmt "\n", ##value); \ 209 } 210 211 #define DEBUGFS_READONLY_FILE_OPS(name) \ 212 static const struct file_operations name## _ops = { \ 213 .read = name## _read, \ 214 .open = simple_open, \ 215 .llseek = generic_file_llseek, \ 216 }; 217 218 #define DEBUGFS_READONLY_FILE(name, fmt, value...) \ 219 DEBUGFS_READONLY_FILE_FN(name, fmt, value) \ 220 DEBUGFS_READONLY_FILE_OPS(name) 221 222 #define DEBUGFS_ADD(name) \ 223 debugfs_create_file(#name, 0400, phyd, local, &name## _ops); 224 225 #define DEBUGFS_ADD_MODE(name, mode) \ 226 debugfs_create_file(#name, mode, phyd, local, &name## _ops); 227 228 229 DEBUGFS_READONLY_FILE(user_power, "%d", 230 local->user_power_level); 231 DEBUGFS_READONLY_FILE(power, "%d", 232 local->hw.conf.power_level); 233 DEBUGFS_READONLY_FILE(total_ps_buffered, "%d", 234 local->total_ps_buffered); 235 DEBUGFS_READONLY_FILE(wep_iv, "%#08x", 236 local->wep_iv & 0xffffff); 237 DEBUGFS_READONLY_FILE(rate_ctrl_alg, "%s", 238 local->rate_ctrl ? local->rate_ctrl->ops->name : "hw/driver"); 239 240 #ifdef CONFIG_PM 241 static ssize_t reset_write(struct file *file, const char __user *user_buf, 242 size_t count, loff_t *ppos) 243 { 244 struct ieee80211_local *local = file->private_data; 245 246 rtnl_lock(); 247 __ieee80211_suspend(&local->hw, NULL); 248 __ieee80211_resume(&local->hw); 249 rtnl_unlock(); 250 251 return count; 252 } 253 254 static const struct file_operations reset_ops = { 255 .write = reset_write, 256 .open = simple_open, 257 .llseek = noop_llseek, 258 }; 259 #endif 260 261 static ssize_t hwflags_read(struct file *file, char __user *user_buf, 262 size_t count, loff_t *ppos) 263 { 264 struct ieee80211_local *local = file->private_data; 265 int mxln = 500; 266 ssize_t rv; 267 char *buf = kzalloc(mxln, GFP_KERNEL); 268 int sf = 0; /* how many written so far */ 269 270 if (!buf) 271 return 0; 272 273 sf += scnprintf(buf, mxln - sf, "0x%x\n", local->hw.flags); 274 if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) 275 sf += scnprintf(buf + sf, mxln - sf, "HAS_RATE_CONTROL\n"); 276 if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS) 277 sf += scnprintf(buf + sf, mxln - sf, "RX_INCLUDES_FCS\n"); 278 if (local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING) 279 sf += scnprintf(buf + sf, mxln - sf, 280 "HOST_BCAST_PS_BUFFERING\n"); 281 if (local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE) 282 sf += scnprintf(buf + sf, mxln - sf, 283 "2GHZ_SHORT_SLOT_INCAPABLE\n"); 284 if (local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE) 285 sf += scnprintf(buf + sf, mxln - sf, 286 "2GHZ_SHORT_PREAMBLE_INCAPABLE\n"); 287 if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC) 288 sf += scnprintf(buf + sf, mxln - sf, "SIGNAL_UNSPEC\n"); 289 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 290 sf += scnprintf(buf + sf, mxln - sf, "SIGNAL_DBM\n"); 291 if (local->hw.flags & IEEE80211_HW_NEED_DTIM_BEFORE_ASSOC) 292 sf += scnprintf(buf + sf, mxln - sf, 293 "NEED_DTIM_BEFORE_ASSOC\n"); 294 if (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT) 295 sf += scnprintf(buf + sf, mxln - sf, "SPECTRUM_MGMT\n"); 296 if (local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION) 297 sf += scnprintf(buf + sf, mxln - sf, "AMPDU_AGGREGATION\n"); 298 if (local->hw.flags & IEEE80211_HW_SUPPORTS_PS) 299 sf += scnprintf(buf + sf, mxln - sf, "SUPPORTS_PS\n"); 300 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) 301 sf += scnprintf(buf + sf, mxln - sf, "PS_NULLFUNC_STACK\n"); 302 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) 303 sf += scnprintf(buf + sf, mxln - sf, "SUPPORTS_DYNAMIC_PS\n"); 304 if (local->hw.flags & IEEE80211_HW_MFP_CAPABLE) 305 sf += scnprintf(buf + sf, mxln - sf, "MFP_CAPABLE\n"); 306 if (local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD) 307 sf += scnprintf(buf + sf, mxln - sf, "SUPPORTS_UAPSD\n"); 308 if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) 309 sf += scnprintf(buf + sf, mxln - sf, 310 "REPORTS_TX_ACK_STATUS\n"); 311 if (local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR) 312 sf += scnprintf(buf + sf, mxln - sf, "CONNECTION_MONITOR\n"); 313 if (local->hw.flags & IEEE80211_HW_SUPPORTS_PER_STA_GTK) 314 sf += scnprintf(buf + sf, mxln - sf, "SUPPORTS_PER_STA_GTK\n"); 315 if (local->hw.flags & IEEE80211_HW_AP_LINK_PS) 316 sf += scnprintf(buf + sf, mxln - sf, "AP_LINK_PS\n"); 317 if (local->hw.flags & IEEE80211_HW_TX_AMPDU_SETUP_IN_HW) 318 sf += scnprintf(buf + sf, mxln - sf, "TX_AMPDU_SETUP_IN_HW\n"); 319 320 rv = simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf)); 321 kfree(buf); 322 return rv; 323 } 324 325 static ssize_t queues_read(struct file *file, char __user *user_buf, 326 size_t count, loff_t *ppos) 327 { 328 struct ieee80211_local *local = file->private_data; 329 unsigned long flags; 330 char buf[IEEE80211_MAX_QUEUES * 20]; 331 int q, res = 0; 332 333 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 334 for (q = 0; q < local->hw.queues; q++) 335 res += sprintf(buf + res, "%02d: %#.8lx/%d\n", q, 336 local->queue_stop_reasons[q], 337 skb_queue_len(&local->pending[q])); 338 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 339 340 return simple_read_from_buffer(user_buf, count, ppos, buf, res); 341 } 342 343 DEBUGFS_READONLY_FILE_OPS(hwflags); 344 DEBUGFS_READONLY_FILE_OPS(queues); 345 346 /* statistics stuff */ 347 348 static ssize_t format_devstat_counter(struct ieee80211_local *local, 349 char __user *userbuf, 350 size_t count, loff_t *ppos, 351 int (*printvalue)(struct ieee80211_low_level_stats *stats, char *buf, 352 int buflen)) 353 { 354 struct ieee80211_low_level_stats stats; 355 char buf[20]; 356 int res; 357 358 rtnl_lock(); 359 res = drv_get_stats(local, &stats); 360 rtnl_unlock(); 361 if (res) 362 return res; 363 res = printvalue(&stats, buf, sizeof(buf)); 364 return simple_read_from_buffer(userbuf, count, ppos, buf, res); 365 } 366 367 #define DEBUGFS_DEVSTATS_FILE(name) \ 368 static int print_devstats_##name(struct ieee80211_low_level_stats *stats,\ 369 char *buf, int buflen) \ 370 { \ 371 return scnprintf(buf, buflen, "%u\n", stats->name); \ 372 } \ 373 static ssize_t stats_ ##name## _read(struct file *file, \ 374 char __user *userbuf, \ 375 size_t count, loff_t *ppos) \ 376 { \ 377 return format_devstat_counter(file->private_data, \ 378 userbuf, \ 379 count, \ 380 ppos, \ 381 print_devstats_##name); \ 382 } \ 383 \ 384 static const struct file_operations stats_ ##name## _ops = { \ 385 .read = stats_ ##name## _read, \ 386 .open = simple_open, \ 387 .llseek = generic_file_llseek, \ 388 }; 389 390 #define DEBUGFS_STATS_ADD(name, field) \ 391 debugfs_create_u32(#name, 0400, statsd, (u32 *) &field); 392 #define DEBUGFS_DEVSTATS_ADD(name) \ 393 debugfs_create_file(#name, 0400, statsd, local, &stats_ ##name## _ops); 394 395 DEBUGFS_DEVSTATS_FILE(dot11ACKFailureCount); 396 DEBUGFS_DEVSTATS_FILE(dot11RTSFailureCount); 397 DEBUGFS_DEVSTATS_FILE(dot11FCSErrorCount); 398 DEBUGFS_DEVSTATS_FILE(dot11RTSSuccessCount); 399 400 void debugfs_hw_add(struct ieee80211_local *local) 401 { 402 struct dentry *phyd = local->hw.wiphy->debugfsdir; 403 struct dentry *statsd; 404 405 if (!phyd) 406 return; 407 408 local->debugfs.keys = debugfs_create_dir("keys", phyd); 409 410 DEBUGFS_ADD(total_ps_buffered); 411 DEBUGFS_ADD(wep_iv); 412 DEBUGFS_ADD(queues); 413 #ifdef CONFIG_PM 414 DEBUGFS_ADD_MODE(reset, 0200); 415 #endif 416 DEBUGFS_ADD(hwflags); 417 DEBUGFS_ADD(user_power); 418 DEBUGFS_ADD(power); 419 420 statsd = debugfs_create_dir("statistics", phyd); 421 422 /* if the dir failed, don't put all the other things into the root! */ 423 if (!statsd) 424 return; 425 426 DEBUGFS_STATS_ADD(transmitted_fragment_count, 427 local->dot11TransmittedFragmentCount); 428 DEBUGFS_STATS_ADD(multicast_transmitted_frame_count, 429 local->dot11MulticastTransmittedFrameCount); 430 DEBUGFS_STATS_ADD(failed_count, local->dot11FailedCount); 431 DEBUGFS_STATS_ADD(retry_count, local->dot11RetryCount); 432 DEBUGFS_STATS_ADD(multiple_retry_count, 433 local->dot11MultipleRetryCount); 434 DEBUGFS_STATS_ADD(frame_duplicate_count, 435 local->dot11FrameDuplicateCount); 436 DEBUGFS_STATS_ADD(received_fragment_count, 437 local->dot11ReceivedFragmentCount); 438 DEBUGFS_STATS_ADD(multicast_received_frame_count, 439 local->dot11MulticastReceivedFrameCount); 440 DEBUGFS_STATS_ADD(transmitted_frame_count, 441 local->dot11TransmittedFrameCount); 442 #ifdef CONFIG_MAC80211_DEBUG_COUNTERS 443 DEBUGFS_STATS_ADD(tx_handlers_drop, local->tx_handlers_drop); 444 DEBUGFS_STATS_ADD(tx_handlers_queued, local->tx_handlers_queued); 445 DEBUGFS_STATS_ADD(tx_handlers_drop_unencrypted, 446 local->tx_handlers_drop_unencrypted); 447 DEBUGFS_STATS_ADD(tx_handlers_drop_fragment, 448 local->tx_handlers_drop_fragment); 449 DEBUGFS_STATS_ADD(tx_handlers_drop_wep, 450 local->tx_handlers_drop_wep); 451 DEBUGFS_STATS_ADD(tx_handlers_drop_not_assoc, 452 local->tx_handlers_drop_not_assoc); 453 DEBUGFS_STATS_ADD(tx_handlers_drop_unauth_port, 454 local->tx_handlers_drop_unauth_port); 455 DEBUGFS_STATS_ADD(rx_handlers_drop, local->rx_handlers_drop); 456 DEBUGFS_STATS_ADD(rx_handlers_queued, local->rx_handlers_queued); 457 DEBUGFS_STATS_ADD(rx_handlers_drop_nullfunc, 458 local->rx_handlers_drop_nullfunc); 459 DEBUGFS_STATS_ADD(rx_handlers_drop_defrag, 460 local->rx_handlers_drop_defrag); 461 DEBUGFS_STATS_ADD(rx_handlers_drop_short, 462 local->rx_handlers_drop_short); 463 DEBUGFS_STATS_ADD(tx_expand_skb_head, 464 local->tx_expand_skb_head); 465 DEBUGFS_STATS_ADD(tx_expand_skb_head_cloned, 466 local->tx_expand_skb_head_cloned); 467 DEBUGFS_STATS_ADD(rx_expand_skb_head, 468 local->rx_expand_skb_head); 469 DEBUGFS_STATS_ADD(rx_expand_skb_head2, 470 local->rx_expand_skb_head2); 471 DEBUGFS_STATS_ADD(rx_handlers_fragments, 472 local->rx_handlers_fragments); 473 DEBUGFS_STATS_ADD(tx_status_drop, 474 local->tx_status_drop); 475 #endif 476 DEBUGFS_DEVSTATS_ADD(dot11ACKFailureCount); 477 DEBUGFS_DEVSTATS_ADD(dot11RTSFailureCount); 478 DEBUGFS_DEVSTATS_ADD(dot11FCSErrorCount); 479 DEBUGFS_DEVSTATS_ADD(dot11RTSSuccessCount); 480 481 DEBUGFS_DEVSTATS_ADD(tx_latency); 482 } 483