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