1 /* 2 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> 3 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/device.h> 12 #include <linux/if.h> 13 #include <linux/interrupt.h> 14 #include <linux/netdevice.h> 15 #include <linux/rtnetlink.h> 16 #include <linux/slab.h> 17 #include <linux/notifier.h> 18 #include <net/mac80211.h> 19 #include <net/cfg80211.h> 20 #include "ieee80211_i.h" 21 #include "rate.h" 22 #include "debugfs.h" 23 #include "debugfs_netdev.h" 24 #include "driver-ops.h" 25 26 static ssize_t ieee80211_if_read( 27 struct ieee80211_sub_if_data *sdata, 28 char __user *userbuf, 29 size_t count, loff_t *ppos, 30 ssize_t (*format)(const struct ieee80211_sub_if_data *, char *, int)) 31 { 32 char buf[70]; 33 ssize_t ret = -EINVAL; 34 35 read_lock(&dev_base_lock); 36 if (sdata->dev->reg_state == NETREG_REGISTERED) 37 ret = (*format)(sdata, buf, sizeof(buf)); 38 read_unlock(&dev_base_lock); 39 40 if (ret >= 0) 41 ret = simple_read_from_buffer(userbuf, count, ppos, buf, ret); 42 43 return ret; 44 } 45 46 static ssize_t ieee80211_if_write( 47 struct ieee80211_sub_if_data *sdata, 48 const char __user *userbuf, 49 size_t count, loff_t *ppos, 50 ssize_t (*write)(struct ieee80211_sub_if_data *, const char *, int)) 51 { 52 u8 *buf; 53 ssize_t ret; 54 55 buf = kmalloc(count, GFP_KERNEL); 56 if (!buf) 57 return -ENOMEM; 58 59 ret = -EFAULT; 60 if (copy_from_user(buf, userbuf, count)) 61 goto freebuf; 62 63 ret = -ENODEV; 64 rtnl_lock(); 65 if (sdata->dev->reg_state == NETREG_REGISTERED) 66 ret = (*write)(sdata, buf, count); 67 rtnl_unlock(); 68 69 freebuf: 70 kfree(buf); 71 return ret; 72 } 73 74 #define IEEE80211_IF_FMT(name, field, format_string) \ 75 static ssize_t ieee80211_if_fmt_##name( \ 76 const struct ieee80211_sub_if_data *sdata, char *buf, \ 77 int buflen) \ 78 { \ 79 return scnprintf(buf, buflen, format_string, sdata->field); \ 80 } 81 #define IEEE80211_IF_FMT_DEC(name, field) \ 82 IEEE80211_IF_FMT(name, field, "%d\n") 83 #define IEEE80211_IF_FMT_HEX(name, field) \ 84 IEEE80211_IF_FMT(name, field, "%#x\n") 85 #define IEEE80211_IF_FMT_LHEX(name, field) \ 86 IEEE80211_IF_FMT(name, field, "%#lx\n") 87 #define IEEE80211_IF_FMT_SIZE(name, field) \ 88 IEEE80211_IF_FMT(name, field, "%zd\n") 89 90 #define IEEE80211_IF_FMT_HEXARRAY(name, field) \ 91 static ssize_t ieee80211_if_fmt_##name( \ 92 const struct ieee80211_sub_if_data *sdata, \ 93 char *buf, int buflen) \ 94 { \ 95 char *p = buf; \ 96 int i; \ 97 for (i = 0; i < sizeof(sdata->field); i++) { \ 98 p += scnprintf(p, buflen + buf - p, "%.2x ", \ 99 sdata->field[i]); \ 100 } \ 101 p += scnprintf(p, buflen + buf - p, "\n"); \ 102 return p - buf; \ 103 } 104 105 #define IEEE80211_IF_FMT_ATOMIC(name, field) \ 106 static ssize_t ieee80211_if_fmt_##name( \ 107 const struct ieee80211_sub_if_data *sdata, \ 108 char *buf, int buflen) \ 109 { \ 110 return scnprintf(buf, buflen, "%d\n", atomic_read(&sdata->field));\ 111 } 112 113 #define IEEE80211_IF_FMT_MAC(name, field) \ 114 static ssize_t ieee80211_if_fmt_##name( \ 115 const struct ieee80211_sub_if_data *sdata, char *buf, \ 116 int buflen) \ 117 { \ 118 return scnprintf(buf, buflen, "%pM\n", sdata->field); \ 119 } 120 121 #define IEEE80211_IF_FMT_DEC_DIV_16(name, field) \ 122 static ssize_t ieee80211_if_fmt_##name( \ 123 const struct ieee80211_sub_if_data *sdata, \ 124 char *buf, int buflen) \ 125 { \ 126 return scnprintf(buf, buflen, "%d\n", sdata->field / 16); \ 127 } 128 129 #define __IEEE80211_IF_FILE(name, _write) \ 130 static ssize_t ieee80211_if_read_##name(struct file *file, \ 131 char __user *userbuf, \ 132 size_t count, loff_t *ppos) \ 133 { \ 134 return ieee80211_if_read(file->private_data, \ 135 userbuf, count, ppos, \ 136 ieee80211_if_fmt_##name); \ 137 } \ 138 static const struct file_operations name##_ops = { \ 139 .read = ieee80211_if_read_##name, \ 140 .write = (_write), \ 141 .open = mac80211_open_file_generic, \ 142 .llseek = generic_file_llseek, \ 143 } 144 145 #define __IEEE80211_IF_FILE_W(name) \ 146 static ssize_t ieee80211_if_write_##name(struct file *file, \ 147 const char __user *userbuf, \ 148 size_t count, loff_t *ppos) \ 149 { \ 150 return ieee80211_if_write(file->private_data, userbuf, count, \ 151 ppos, ieee80211_if_parse_##name); \ 152 } \ 153 __IEEE80211_IF_FILE(name, ieee80211_if_write_##name) 154 155 156 #define IEEE80211_IF_FILE(name, field, format) \ 157 IEEE80211_IF_FMT_##format(name, field) \ 158 __IEEE80211_IF_FILE(name, NULL) 159 160 /* common attributes */ 161 IEEE80211_IF_FILE(drop_unencrypted, drop_unencrypted, DEC); 162 IEEE80211_IF_FILE(rc_rateidx_mask_2ghz, rc_rateidx_mask[IEEE80211_BAND_2GHZ], 163 HEX); 164 IEEE80211_IF_FILE(rc_rateidx_mask_5ghz, rc_rateidx_mask[IEEE80211_BAND_5GHZ], 165 HEX); 166 IEEE80211_IF_FILE(rc_rateidx_mcs_mask_2ghz, 167 rc_rateidx_mcs_mask[IEEE80211_BAND_2GHZ], HEXARRAY); 168 IEEE80211_IF_FILE(rc_rateidx_mcs_mask_5ghz, 169 rc_rateidx_mcs_mask[IEEE80211_BAND_5GHZ], HEXARRAY); 170 171 IEEE80211_IF_FILE(flags, flags, HEX); 172 IEEE80211_IF_FILE(state, state, LHEX); 173 IEEE80211_IF_FILE(channel_type, vif.bss_conf.channel_type, DEC); 174 175 /* STA attributes */ 176 IEEE80211_IF_FILE(bssid, u.mgd.bssid, MAC); 177 IEEE80211_IF_FILE(aid, u.mgd.aid, DEC); 178 IEEE80211_IF_FILE(last_beacon, u.mgd.last_beacon_signal, DEC); 179 IEEE80211_IF_FILE(ave_beacon, u.mgd.ave_beacon_signal, DEC_DIV_16); 180 181 static int ieee80211_set_smps(struct ieee80211_sub_if_data *sdata, 182 enum ieee80211_smps_mode smps_mode) 183 { 184 struct ieee80211_local *local = sdata->local; 185 int err; 186 187 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_STATIC_SMPS) && 188 smps_mode == IEEE80211_SMPS_STATIC) 189 return -EINVAL; 190 191 /* auto should be dynamic if in PS mode */ 192 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS) && 193 (smps_mode == IEEE80211_SMPS_DYNAMIC || 194 smps_mode == IEEE80211_SMPS_AUTOMATIC)) 195 return -EINVAL; 196 197 /* supported only on managed interfaces for now */ 198 if (sdata->vif.type != NL80211_IFTYPE_STATION) 199 return -EOPNOTSUPP; 200 201 mutex_lock(&sdata->u.mgd.mtx); 202 err = __ieee80211_request_smps(sdata, smps_mode); 203 mutex_unlock(&sdata->u.mgd.mtx); 204 205 return err; 206 } 207 208 static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = { 209 [IEEE80211_SMPS_AUTOMATIC] = "auto", 210 [IEEE80211_SMPS_OFF] = "off", 211 [IEEE80211_SMPS_STATIC] = "static", 212 [IEEE80211_SMPS_DYNAMIC] = "dynamic", 213 }; 214 215 static ssize_t ieee80211_if_fmt_smps(const struct ieee80211_sub_if_data *sdata, 216 char *buf, int buflen) 217 { 218 if (sdata->vif.type != NL80211_IFTYPE_STATION) 219 return -EOPNOTSUPP; 220 221 return snprintf(buf, buflen, "request: %s\nused: %s\n", 222 smps_modes[sdata->u.mgd.req_smps], 223 smps_modes[sdata->u.mgd.ap_smps]); 224 } 225 226 static ssize_t ieee80211_if_parse_smps(struct ieee80211_sub_if_data *sdata, 227 const char *buf, int buflen) 228 { 229 enum ieee80211_smps_mode mode; 230 231 for (mode = 0; mode < IEEE80211_SMPS_NUM_MODES; mode++) { 232 if (strncmp(buf, smps_modes[mode], buflen) == 0) { 233 int err = ieee80211_set_smps(sdata, mode); 234 if (!err) 235 return buflen; 236 return err; 237 } 238 } 239 240 return -EINVAL; 241 } 242 243 __IEEE80211_IF_FILE_W(smps); 244 245 static ssize_t ieee80211_if_fmt_tkip_mic_test( 246 const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) 247 { 248 return -EOPNOTSUPP; 249 } 250 251 static int hwaddr_aton(const char *txt, u8 *addr) 252 { 253 int i; 254 255 for (i = 0; i < ETH_ALEN; i++) { 256 int a, b; 257 258 a = hex_to_bin(*txt++); 259 if (a < 0) 260 return -1; 261 b = hex_to_bin(*txt++); 262 if (b < 0) 263 return -1; 264 *addr++ = (a << 4) | b; 265 if (i < 5 && *txt++ != ':') 266 return -1; 267 } 268 269 return 0; 270 } 271 272 static ssize_t ieee80211_if_parse_tkip_mic_test( 273 struct ieee80211_sub_if_data *sdata, const char *buf, int buflen) 274 { 275 struct ieee80211_local *local = sdata->local; 276 u8 addr[ETH_ALEN]; 277 struct sk_buff *skb; 278 struct ieee80211_hdr *hdr; 279 __le16 fc; 280 281 /* 282 * Assume colon-delimited MAC address with possible white space 283 * following. 284 */ 285 if (buflen < 3 * ETH_ALEN - 1) 286 return -EINVAL; 287 if (hwaddr_aton(buf, addr) < 0) 288 return -EINVAL; 289 290 if (!ieee80211_sdata_running(sdata)) 291 return -ENOTCONN; 292 293 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24 + 100); 294 if (!skb) 295 return -ENOMEM; 296 skb_reserve(skb, local->hw.extra_tx_headroom); 297 298 hdr = (struct ieee80211_hdr *) skb_put(skb, 24); 299 memset(hdr, 0, 24); 300 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA); 301 302 switch (sdata->vif.type) { 303 case NL80211_IFTYPE_AP: 304 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); 305 /* DA BSSID SA */ 306 memcpy(hdr->addr1, addr, ETH_ALEN); 307 memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN); 308 memcpy(hdr->addr3, sdata->vif.addr, ETH_ALEN); 309 break; 310 case NL80211_IFTYPE_STATION: 311 fc |= cpu_to_le16(IEEE80211_FCTL_TODS); 312 /* BSSID SA DA */ 313 if (sdata->vif.bss_conf.bssid == NULL) { 314 dev_kfree_skb(skb); 315 return -ENOTCONN; 316 } 317 memcpy(hdr->addr1, sdata->vif.bss_conf.bssid, ETH_ALEN); 318 memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN); 319 memcpy(hdr->addr3, addr, ETH_ALEN); 320 break; 321 default: 322 dev_kfree_skb(skb); 323 return -EOPNOTSUPP; 324 } 325 hdr->frame_control = fc; 326 327 /* 328 * Add some length to the test frame to make it look bit more valid. 329 * The exact contents does not matter since the recipient is required 330 * to drop this because of the Michael MIC failure. 331 */ 332 memset(skb_put(skb, 50), 0, 50); 333 334 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_TKIP_MIC_FAILURE; 335 336 ieee80211_tx_skb(sdata, skb); 337 338 return buflen; 339 } 340 341 __IEEE80211_IF_FILE_W(tkip_mic_test); 342 343 /* AP attributes */ 344 IEEE80211_IF_FILE(num_sta_authorized, u.ap.num_sta_authorized, ATOMIC); 345 IEEE80211_IF_FILE(num_sta_ps, u.ap.num_sta_ps, ATOMIC); 346 IEEE80211_IF_FILE(dtim_count, u.ap.dtim_count, DEC); 347 348 static ssize_t ieee80211_if_fmt_num_buffered_multicast( 349 const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) 350 { 351 return scnprintf(buf, buflen, "%u\n", 352 skb_queue_len(&sdata->u.ap.ps_bc_buf)); 353 } 354 __IEEE80211_IF_FILE(num_buffered_multicast, NULL); 355 356 /* IBSS attributes */ 357 static ssize_t ieee80211_if_fmt_tsf( 358 const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) 359 { 360 struct ieee80211_local *local = sdata->local; 361 u64 tsf; 362 363 tsf = drv_get_tsf(local, (struct ieee80211_sub_if_data *)sdata); 364 365 return scnprintf(buf, buflen, "0x%016llx\n", (unsigned long long) tsf); 366 } 367 368 static ssize_t ieee80211_if_parse_tsf( 369 struct ieee80211_sub_if_data *sdata, const char *buf, int buflen) 370 { 371 struct ieee80211_local *local = sdata->local; 372 unsigned long long tsf; 373 int ret; 374 375 if (strncmp(buf, "reset", 5) == 0) { 376 if (local->ops->reset_tsf) { 377 drv_reset_tsf(local, sdata); 378 wiphy_info(local->hw.wiphy, "debugfs reset TSF\n"); 379 } 380 } else { 381 ret = kstrtoull(buf, 10, &tsf); 382 if (ret < 0) 383 return -EINVAL; 384 if (local->ops->set_tsf) { 385 drv_set_tsf(local, sdata, tsf); 386 wiphy_info(local->hw.wiphy, 387 "debugfs set TSF to %#018llx\n", tsf); 388 } 389 } 390 391 return buflen; 392 } 393 __IEEE80211_IF_FILE_W(tsf); 394 395 396 /* WDS attributes */ 397 IEEE80211_IF_FILE(peer, u.wds.remote_addr, MAC); 398 399 #ifdef CONFIG_MAC80211_MESH 400 /* Mesh stats attributes */ 401 IEEE80211_IF_FILE(fwded_mcast, u.mesh.mshstats.fwded_mcast, DEC); 402 IEEE80211_IF_FILE(fwded_unicast, u.mesh.mshstats.fwded_unicast, DEC); 403 IEEE80211_IF_FILE(fwded_frames, u.mesh.mshstats.fwded_frames, DEC); 404 IEEE80211_IF_FILE(dropped_frames_ttl, u.mesh.mshstats.dropped_frames_ttl, DEC); 405 IEEE80211_IF_FILE(dropped_frames_congestion, 406 u.mesh.mshstats.dropped_frames_congestion, DEC); 407 IEEE80211_IF_FILE(dropped_frames_no_route, 408 u.mesh.mshstats.dropped_frames_no_route, DEC); 409 IEEE80211_IF_FILE(estab_plinks, u.mesh.mshstats.estab_plinks, ATOMIC); 410 411 /* Mesh parameters */ 412 IEEE80211_IF_FILE(dot11MeshMaxRetries, 413 u.mesh.mshcfg.dot11MeshMaxRetries, DEC); 414 IEEE80211_IF_FILE(dot11MeshRetryTimeout, 415 u.mesh.mshcfg.dot11MeshRetryTimeout, DEC); 416 IEEE80211_IF_FILE(dot11MeshConfirmTimeout, 417 u.mesh.mshcfg.dot11MeshConfirmTimeout, DEC); 418 IEEE80211_IF_FILE(dot11MeshHoldingTimeout, 419 u.mesh.mshcfg.dot11MeshHoldingTimeout, DEC); 420 IEEE80211_IF_FILE(dot11MeshTTL, u.mesh.mshcfg.dot11MeshTTL, DEC); 421 IEEE80211_IF_FILE(element_ttl, u.mesh.mshcfg.element_ttl, DEC); 422 IEEE80211_IF_FILE(auto_open_plinks, u.mesh.mshcfg.auto_open_plinks, DEC); 423 IEEE80211_IF_FILE(dot11MeshMaxPeerLinks, 424 u.mesh.mshcfg.dot11MeshMaxPeerLinks, DEC); 425 IEEE80211_IF_FILE(dot11MeshHWMPactivePathTimeout, 426 u.mesh.mshcfg.dot11MeshHWMPactivePathTimeout, DEC); 427 IEEE80211_IF_FILE(dot11MeshHWMPpreqMinInterval, 428 u.mesh.mshcfg.dot11MeshHWMPpreqMinInterval, DEC); 429 IEEE80211_IF_FILE(dot11MeshHWMPperrMinInterval, 430 u.mesh.mshcfg.dot11MeshHWMPperrMinInterval, DEC); 431 IEEE80211_IF_FILE(dot11MeshHWMPnetDiameterTraversalTime, 432 u.mesh.mshcfg.dot11MeshHWMPnetDiameterTraversalTime, DEC); 433 IEEE80211_IF_FILE(dot11MeshHWMPmaxPREQretries, 434 u.mesh.mshcfg.dot11MeshHWMPmaxPREQretries, DEC); 435 IEEE80211_IF_FILE(path_refresh_time, 436 u.mesh.mshcfg.path_refresh_time, DEC); 437 IEEE80211_IF_FILE(min_discovery_timeout, 438 u.mesh.mshcfg.min_discovery_timeout, DEC); 439 IEEE80211_IF_FILE(dot11MeshHWMPRootMode, 440 u.mesh.mshcfg.dot11MeshHWMPRootMode, DEC); 441 IEEE80211_IF_FILE(dot11MeshGateAnnouncementProtocol, 442 u.mesh.mshcfg.dot11MeshGateAnnouncementProtocol, DEC); 443 IEEE80211_IF_FILE(dot11MeshHWMPRannInterval, 444 u.mesh.mshcfg.dot11MeshHWMPRannInterval, DEC); 445 IEEE80211_IF_FILE(dot11MeshForwarding, u.mesh.mshcfg.dot11MeshForwarding, DEC); 446 #endif 447 448 449 #define DEBUGFS_ADD(name) \ 450 debugfs_create_file(#name, 0400, sdata->debugfs.dir, \ 451 sdata, &name##_ops); 452 453 #define DEBUGFS_ADD_MODE(name, mode) \ 454 debugfs_create_file(#name, mode, sdata->debugfs.dir, \ 455 sdata, &name##_ops); 456 457 static void add_sta_files(struct ieee80211_sub_if_data *sdata) 458 { 459 DEBUGFS_ADD(drop_unencrypted); 460 DEBUGFS_ADD(flags); 461 DEBUGFS_ADD(state); 462 DEBUGFS_ADD(channel_type); 463 DEBUGFS_ADD(rc_rateidx_mask_2ghz); 464 DEBUGFS_ADD(rc_rateidx_mask_5ghz); 465 DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz); 466 DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz); 467 468 DEBUGFS_ADD(bssid); 469 DEBUGFS_ADD(aid); 470 DEBUGFS_ADD(last_beacon); 471 DEBUGFS_ADD(ave_beacon); 472 DEBUGFS_ADD_MODE(smps, 0600); 473 DEBUGFS_ADD_MODE(tkip_mic_test, 0200); 474 } 475 476 static void add_ap_files(struct ieee80211_sub_if_data *sdata) 477 { 478 DEBUGFS_ADD(drop_unencrypted); 479 DEBUGFS_ADD(flags); 480 DEBUGFS_ADD(state); 481 DEBUGFS_ADD(channel_type); 482 DEBUGFS_ADD(rc_rateidx_mask_2ghz); 483 DEBUGFS_ADD(rc_rateidx_mask_5ghz); 484 DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz); 485 DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz); 486 487 DEBUGFS_ADD(num_sta_authorized); 488 DEBUGFS_ADD(num_sta_ps); 489 DEBUGFS_ADD(dtim_count); 490 DEBUGFS_ADD(num_buffered_multicast); 491 DEBUGFS_ADD_MODE(tkip_mic_test, 0200); 492 } 493 494 static void add_ibss_files(struct ieee80211_sub_if_data *sdata) 495 { 496 DEBUGFS_ADD(channel_type); 497 DEBUGFS_ADD(rc_rateidx_mask_2ghz); 498 DEBUGFS_ADD(rc_rateidx_mask_5ghz); 499 DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz); 500 DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz); 501 502 DEBUGFS_ADD_MODE(tsf, 0600); 503 } 504 505 static void add_wds_files(struct ieee80211_sub_if_data *sdata) 506 { 507 DEBUGFS_ADD(drop_unencrypted); 508 DEBUGFS_ADD(flags); 509 DEBUGFS_ADD(state); 510 DEBUGFS_ADD(channel_type); 511 DEBUGFS_ADD(rc_rateidx_mask_2ghz); 512 DEBUGFS_ADD(rc_rateidx_mask_5ghz); 513 DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz); 514 DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz); 515 516 DEBUGFS_ADD(peer); 517 } 518 519 static void add_vlan_files(struct ieee80211_sub_if_data *sdata) 520 { 521 DEBUGFS_ADD(drop_unencrypted); 522 DEBUGFS_ADD(flags); 523 DEBUGFS_ADD(state); 524 DEBUGFS_ADD(channel_type); 525 DEBUGFS_ADD(rc_rateidx_mask_2ghz); 526 DEBUGFS_ADD(rc_rateidx_mask_5ghz); 527 DEBUGFS_ADD(rc_rateidx_mcs_mask_2ghz); 528 DEBUGFS_ADD(rc_rateidx_mcs_mask_5ghz); 529 } 530 531 static void add_monitor_files(struct ieee80211_sub_if_data *sdata) 532 { 533 DEBUGFS_ADD(flags); 534 DEBUGFS_ADD(state); 535 DEBUGFS_ADD(channel_type); 536 } 537 538 #ifdef CONFIG_MAC80211_MESH 539 540 static void add_mesh_stats(struct ieee80211_sub_if_data *sdata) 541 { 542 struct dentry *dir = debugfs_create_dir("mesh_stats", 543 sdata->debugfs.dir); 544 545 #define MESHSTATS_ADD(name)\ 546 debugfs_create_file(#name, 0400, dir, sdata, &name##_ops); 547 548 MESHSTATS_ADD(fwded_mcast); 549 MESHSTATS_ADD(fwded_unicast); 550 MESHSTATS_ADD(fwded_frames); 551 MESHSTATS_ADD(dropped_frames_ttl); 552 MESHSTATS_ADD(dropped_frames_no_route); 553 MESHSTATS_ADD(dropped_frames_congestion); 554 MESHSTATS_ADD(estab_plinks); 555 #undef MESHSTATS_ADD 556 } 557 558 static void add_mesh_config(struct ieee80211_sub_if_data *sdata) 559 { 560 struct dentry *dir = debugfs_create_dir("mesh_config", 561 sdata->debugfs.dir); 562 563 #define MESHPARAMS_ADD(name) \ 564 debugfs_create_file(#name, 0600, dir, sdata, &name##_ops); 565 566 MESHPARAMS_ADD(dot11MeshMaxRetries); 567 MESHPARAMS_ADD(dot11MeshRetryTimeout); 568 MESHPARAMS_ADD(dot11MeshConfirmTimeout); 569 MESHPARAMS_ADD(dot11MeshHoldingTimeout); 570 MESHPARAMS_ADD(dot11MeshTTL); 571 MESHPARAMS_ADD(element_ttl); 572 MESHPARAMS_ADD(auto_open_plinks); 573 MESHPARAMS_ADD(dot11MeshMaxPeerLinks); 574 MESHPARAMS_ADD(dot11MeshHWMPactivePathTimeout); 575 MESHPARAMS_ADD(dot11MeshHWMPpreqMinInterval); 576 MESHPARAMS_ADD(dot11MeshHWMPperrMinInterval); 577 MESHPARAMS_ADD(dot11MeshHWMPnetDiameterTraversalTime); 578 MESHPARAMS_ADD(dot11MeshHWMPmaxPREQretries); 579 MESHPARAMS_ADD(path_refresh_time); 580 MESHPARAMS_ADD(min_discovery_timeout); 581 MESHPARAMS_ADD(dot11MeshHWMPRootMode); 582 MESHPARAMS_ADD(dot11MeshHWMPRannInterval); 583 MESHPARAMS_ADD(dot11MeshGateAnnouncementProtocol); 584 #undef MESHPARAMS_ADD 585 } 586 #endif 587 588 static void add_files(struct ieee80211_sub_if_data *sdata) 589 { 590 if (!sdata->debugfs.dir) 591 return; 592 593 switch (sdata->vif.type) { 594 case NL80211_IFTYPE_MESH_POINT: 595 #ifdef CONFIG_MAC80211_MESH 596 add_mesh_stats(sdata); 597 add_mesh_config(sdata); 598 #endif 599 break; 600 case NL80211_IFTYPE_STATION: 601 add_sta_files(sdata); 602 break; 603 case NL80211_IFTYPE_ADHOC: 604 add_ibss_files(sdata); 605 break; 606 case NL80211_IFTYPE_AP: 607 add_ap_files(sdata); 608 break; 609 case NL80211_IFTYPE_WDS: 610 add_wds_files(sdata); 611 break; 612 case NL80211_IFTYPE_MONITOR: 613 add_monitor_files(sdata); 614 break; 615 case NL80211_IFTYPE_AP_VLAN: 616 add_vlan_files(sdata); 617 break; 618 default: 619 break; 620 } 621 } 622 623 void ieee80211_debugfs_add_netdev(struct ieee80211_sub_if_data *sdata) 624 { 625 char buf[10+IFNAMSIZ]; 626 627 sprintf(buf, "netdev:%s", sdata->name); 628 sdata->debugfs.dir = debugfs_create_dir(buf, 629 sdata->local->hw.wiphy->debugfsdir); 630 if (sdata->debugfs.dir) 631 sdata->debugfs.subdir_stations = debugfs_create_dir("stations", 632 sdata->debugfs.dir); 633 add_files(sdata); 634 } 635 636 void ieee80211_debugfs_remove_netdev(struct ieee80211_sub_if_data *sdata) 637 { 638 if (!sdata->debugfs.dir) 639 return; 640 641 debugfs_remove_recursive(sdata->debugfs.dir); 642 sdata->debugfs.dir = NULL; 643 } 644 645 void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata) 646 { 647 struct dentry *dir; 648 char buf[10 + IFNAMSIZ]; 649 650 dir = sdata->debugfs.dir; 651 652 if (!dir) 653 return; 654 655 sprintf(buf, "netdev:%s", sdata->name); 656 if (!debugfs_rename(dir->d_parent, dir, dir->d_parent, buf)) 657 printk(KERN_ERR "mac80211: debugfs: failed to rename debugfs " 658 "dir to %s\n", buf); 659 } 660