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