1 /* 2 * Copyright (c) 2008, 2009 open80211s Ltd. 3 * Authors: Luis Carlos Cobo <luisca@cozybit.com> 4 * Javier Cardona <javier@cozybit.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/slab.h> 12 #include <asm/unaligned.h> 13 #include "ieee80211_i.h" 14 #include "mesh.h" 15 16 #define IEEE80211_MESH_PEER_INACTIVITY_LIMIT (1800 * HZ) 17 #define IEEE80211_MESH_HOUSEKEEPING_INTERVAL (60 * HZ) 18 #define IEEE80211_MESH_RANN_INTERVAL (1 * HZ) 19 20 #define MESHCONF_CAPAB_ACCEPT_PLINKS 0x01 21 #define MESHCONF_CAPAB_FORWARDING 0x08 22 23 #define TMR_RUNNING_HK 0 24 #define TMR_RUNNING_MP 1 25 #define TMR_RUNNING_MPR 2 26 27 int mesh_allocated; 28 static struct kmem_cache *rm_cache; 29 30 void ieee80211s_init(void) 31 { 32 mesh_pathtbl_init(); 33 mesh_allocated = 1; 34 rm_cache = kmem_cache_create("mesh_rmc", sizeof(struct rmc_entry), 35 0, 0, NULL); 36 } 37 38 void ieee80211s_stop(void) 39 { 40 mesh_pathtbl_unregister(); 41 kmem_cache_destroy(rm_cache); 42 } 43 44 static void ieee80211_mesh_housekeeping_timer(unsigned long data) 45 { 46 struct ieee80211_sub_if_data *sdata = (void *) data; 47 struct ieee80211_local *local = sdata->local; 48 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 49 50 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags); 51 52 if (local->quiescing) { 53 set_bit(TMR_RUNNING_HK, &ifmsh->timers_running); 54 return; 55 } 56 57 ieee80211_queue_work(&local->hw, &sdata->work); 58 } 59 60 /** 61 * mesh_matches_local - check if the config of a mesh point matches ours 62 * 63 * @ie: information elements of a management frame from the mesh peer 64 * @sdata: local mesh subif 65 * 66 * This function checks if the mesh configuration of a mesh point matches the 67 * local mesh configuration, i.e. if both nodes belong to the same mesh network. 68 */ 69 bool mesh_matches_local(struct ieee802_11_elems *ie, struct ieee80211_sub_if_data *sdata) 70 { 71 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 72 73 /* 74 * As support for each feature is added, check for matching 75 * - On mesh config capabilities 76 * - Power Save Support En 77 * - Sync support enabled 78 * - Sync support active 79 * - Sync support required from peer 80 * - MDA enabled 81 * - Power management control on fc 82 */ 83 if (ifmsh->mesh_id_len == ie->mesh_id_len && 84 memcmp(ifmsh->mesh_id, ie->mesh_id, ie->mesh_id_len) == 0 && 85 (ifmsh->mesh_pp_id == ie->mesh_config->meshconf_psel) && 86 (ifmsh->mesh_pm_id == ie->mesh_config->meshconf_pmetric) && 87 (ifmsh->mesh_cc_id == ie->mesh_config->meshconf_congest) && 88 (ifmsh->mesh_sp_id == ie->mesh_config->meshconf_synch) && 89 (ifmsh->mesh_auth_id == ie->mesh_config->meshconf_auth)) 90 return true; 91 92 return false; 93 } 94 95 /** 96 * mesh_peer_accepts_plinks - check if an mp is willing to establish peer links 97 * 98 * @ie: information elements of a management frame from the mesh peer 99 */ 100 bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie) 101 { 102 return (ie->mesh_config->meshconf_cap & 103 MESHCONF_CAPAB_ACCEPT_PLINKS) != 0; 104 } 105 106 /** 107 * mesh_accept_plinks_update: update accepting_plink in local mesh beacons 108 * 109 * @sdata: mesh interface in which mesh beacons are going to be updated 110 */ 111 void mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata) 112 { 113 bool free_plinks; 114 115 /* In case mesh_plink_free_count > 0 and mesh_plinktbl_capacity == 0, 116 * the mesh interface might be able to establish plinks with peers that 117 * are already on the table but are not on PLINK_ESTAB state. However, 118 * in general the mesh interface is not accepting peer link requests 119 * from new peers, and that must be reflected in the beacon 120 */ 121 free_plinks = mesh_plink_availables(sdata); 122 123 if (free_plinks != sdata->u.mesh.accepting_plinks) 124 ieee80211_mesh_housekeeping_timer((unsigned long) sdata); 125 } 126 127 int mesh_rmc_init(struct ieee80211_sub_if_data *sdata) 128 { 129 int i; 130 131 sdata->u.mesh.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL); 132 if (!sdata->u.mesh.rmc) 133 return -ENOMEM; 134 sdata->u.mesh.rmc->idx_mask = RMC_BUCKETS - 1; 135 for (i = 0; i < RMC_BUCKETS; i++) 136 INIT_LIST_HEAD(&sdata->u.mesh.rmc->bucket[i].list); 137 return 0; 138 } 139 140 void mesh_rmc_free(struct ieee80211_sub_if_data *sdata) 141 { 142 struct mesh_rmc *rmc = sdata->u.mesh.rmc; 143 struct rmc_entry *p, *n; 144 int i; 145 146 if (!sdata->u.mesh.rmc) 147 return; 148 149 for (i = 0; i < RMC_BUCKETS; i++) 150 list_for_each_entry_safe(p, n, &rmc->bucket[i].list, list) { 151 list_del(&p->list); 152 kmem_cache_free(rm_cache, p); 153 } 154 155 kfree(rmc); 156 sdata->u.mesh.rmc = NULL; 157 } 158 159 /** 160 * mesh_rmc_check - Check frame in recent multicast cache and add if absent. 161 * 162 * @sa: source address 163 * @mesh_hdr: mesh_header 164 * 165 * Returns: 0 if the frame is not in the cache, nonzero otherwise. 166 * 167 * Checks using the source address and the mesh sequence number if we have 168 * received this frame lately. If the frame is not in the cache, it is added to 169 * it. 170 */ 171 int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr, 172 struct ieee80211_sub_if_data *sdata) 173 { 174 struct mesh_rmc *rmc = sdata->u.mesh.rmc; 175 u32 seqnum = 0; 176 int entries = 0; 177 u8 idx; 178 struct rmc_entry *p, *n; 179 180 /* Don't care about endianness since only match matters */ 181 memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum)); 182 idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask; 183 list_for_each_entry_safe(p, n, &rmc->bucket[idx].list, list) { 184 ++entries; 185 if (time_after(jiffies, p->exp_time) || 186 (entries == RMC_QUEUE_MAX_LEN)) { 187 list_del(&p->list); 188 kmem_cache_free(rm_cache, p); 189 --entries; 190 } else if ((seqnum == p->seqnum) && 191 (memcmp(sa, p->sa, ETH_ALEN) == 0)) 192 return -1; 193 } 194 195 p = kmem_cache_alloc(rm_cache, GFP_ATOMIC); 196 if (!p) { 197 printk(KERN_DEBUG "o11s: could not allocate RMC entry\n"); 198 return 0; 199 } 200 p->seqnum = seqnum; 201 p->exp_time = jiffies + RMC_TIMEOUT; 202 memcpy(p->sa, sa, ETH_ALEN); 203 list_add(&p->list, &rmc->bucket[idx].list); 204 return 0; 205 } 206 207 void mesh_mgmt_ies_add(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata) 208 { 209 struct ieee80211_local *local = sdata->local; 210 struct ieee80211_supported_band *sband; 211 u8 *pos; 212 int len, i, rate; 213 u8 neighbors; 214 215 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 216 len = sband->n_bitrates; 217 if (len > 8) 218 len = 8; 219 pos = skb_put(skb, len + 2); 220 *pos++ = WLAN_EID_SUPP_RATES; 221 *pos++ = len; 222 for (i = 0; i < len; i++) { 223 rate = sband->bitrates[i].bitrate; 224 *pos++ = (u8) (rate / 5); 225 } 226 227 if (sband->n_bitrates > len) { 228 pos = skb_put(skb, sband->n_bitrates - len + 2); 229 *pos++ = WLAN_EID_EXT_SUPP_RATES; 230 *pos++ = sband->n_bitrates - len; 231 for (i = len; i < sband->n_bitrates; i++) { 232 rate = sband->bitrates[i].bitrate; 233 *pos++ = (u8) (rate / 5); 234 } 235 } 236 237 if (sband->band == IEEE80211_BAND_2GHZ) { 238 pos = skb_put(skb, 2 + 1); 239 *pos++ = WLAN_EID_DS_PARAMS; 240 *pos++ = 1; 241 *pos++ = ieee80211_frequency_to_channel(local->hw.conf.channel->center_freq); 242 } 243 244 pos = skb_put(skb, 2 + sdata->u.mesh.mesh_id_len); 245 *pos++ = WLAN_EID_MESH_ID; 246 *pos++ = sdata->u.mesh.mesh_id_len; 247 if (sdata->u.mesh.mesh_id_len) 248 memcpy(pos, sdata->u.mesh.mesh_id, sdata->u.mesh.mesh_id_len); 249 250 pos = skb_put(skb, 2 + sizeof(struct ieee80211_meshconf_ie)); 251 *pos++ = WLAN_EID_MESH_CONFIG; 252 *pos++ = sizeof(struct ieee80211_meshconf_ie); 253 254 /* Active path selection protocol ID */ 255 *pos++ = sdata->u.mesh.mesh_pp_id; 256 257 /* Active path selection metric ID */ 258 *pos++ = sdata->u.mesh.mesh_pm_id; 259 260 /* Congestion control mode identifier */ 261 *pos++ = sdata->u.mesh.mesh_cc_id; 262 263 /* Synchronization protocol identifier */ 264 *pos++ = sdata->u.mesh.mesh_sp_id; 265 266 /* Authentication Protocol identifier */ 267 *pos++ = sdata->u.mesh.mesh_auth_id; 268 269 /* Mesh Formation Info - number of neighbors */ 270 neighbors = atomic_read(&sdata->u.mesh.mshstats.estab_plinks); 271 /* Number of neighbor mesh STAs or 15 whichever is smaller */ 272 neighbors = (neighbors > 15) ? 15 : neighbors; 273 *pos++ = neighbors << 1; 274 275 /* Mesh capability */ 276 sdata->u.mesh.accepting_plinks = mesh_plink_availables(sdata); 277 *pos = MESHCONF_CAPAB_FORWARDING; 278 *pos++ |= sdata->u.mesh.accepting_plinks ? 279 MESHCONF_CAPAB_ACCEPT_PLINKS : 0x00; 280 *pos++ = 0x00; 281 282 if (sdata->u.mesh.ie) { 283 int len = sdata->u.mesh.ie_len; 284 const u8 *data = sdata->u.mesh.ie; 285 if (skb_tailroom(skb) > len) 286 memcpy(skb_put(skb, len), data, len); 287 } 288 } 289 290 291 static void ieee80211_mesh_path_timer(unsigned long data) 292 { 293 struct ieee80211_sub_if_data *sdata = 294 (struct ieee80211_sub_if_data *) data; 295 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 296 struct ieee80211_local *local = sdata->local; 297 298 if (local->quiescing) { 299 set_bit(TMR_RUNNING_MP, &ifmsh->timers_running); 300 return; 301 } 302 303 ieee80211_queue_work(&local->hw, &sdata->work); 304 } 305 306 static void ieee80211_mesh_path_root_timer(unsigned long data) 307 { 308 struct ieee80211_sub_if_data *sdata = 309 (struct ieee80211_sub_if_data *) data; 310 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 311 struct ieee80211_local *local = sdata->local; 312 313 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 314 315 if (local->quiescing) { 316 set_bit(TMR_RUNNING_MPR, &ifmsh->timers_running); 317 return; 318 } 319 320 ieee80211_queue_work(&local->hw, &sdata->work); 321 } 322 323 void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh) 324 { 325 if (ifmsh->mshcfg.dot11MeshHWMPRootMode) 326 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 327 else { 328 clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 329 /* stop running timer */ 330 del_timer_sync(&ifmsh->mesh_path_root_timer); 331 } 332 } 333 334 /** 335 * ieee80211_fill_mesh_addresses - fill addresses of a locally originated mesh frame 336 * @hdr: 802.11 frame header 337 * @fc: frame control field 338 * @meshda: destination address in the mesh 339 * @meshsa: source address address in the mesh. Same as TA, as frame is 340 * locally originated. 341 * 342 * Return the length of the 802.11 (does not include a mesh control header) 343 */ 344 int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc, 345 const u8 *meshda, const u8 *meshsa) 346 { 347 if (is_multicast_ether_addr(meshda)) { 348 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); 349 /* DA TA SA */ 350 memcpy(hdr->addr1, meshda, ETH_ALEN); 351 memcpy(hdr->addr2, meshsa, ETH_ALEN); 352 memcpy(hdr->addr3, meshsa, ETH_ALEN); 353 return 24; 354 } else { 355 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | 356 IEEE80211_FCTL_TODS); 357 /* RA TA DA SA */ 358 memset(hdr->addr1, 0, ETH_ALEN); /* RA is resolved later */ 359 memcpy(hdr->addr2, meshsa, ETH_ALEN); 360 memcpy(hdr->addr3, meshda, ETH_ALEN); 361 memcpy(hdr->addr4, meshsa, ETH_ALEN); 362 return 30; 363 } 364 } 365 366 /** 367 * ieee80211_new_mesh_header - create a new mesh header 368 * @meshhdr: uninitialized mesh header 369 * @sdata: mesh interface to be used 370 * @addr4or5: 1st address in the ae header, which may correspond to address 4 371 * (if addr6 is NULL) or address 5 (if addr6 is present). It may 372 * be NULL. 373 * @addr6: 2nd address in the ae header, which corresponds to addr6 of the 374 * mesh frame 375 * 376 * Return the header length. 377 */ 378 int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr, 379 struct ieee80211_sub_if_data *sdata, char *addr4or5, 380 char *addr6) 381 { 382 int aelen = 0; 383 BUG_ON(!addr4or5 && addr6); 384 memset(meshhdr, 0, sizeof(*meshhdr)); 385 meshhdr->ttl = sdata->u.mesh.mshcfg.dot11MeshTTL; 386 put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &meshhdr->seqnum); 387 sdata->u.mesh.mesh_seqnum++; 388 if (addr4or5 && !addr6) { 389 meshhdr->flags |= MESH_FLAGS_AE_A4; 390 aelen += ETH_ALEN; 391 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN); 392 } else if (addr4or5 && addr6) { 393 meshhdr->flags |= MESH_FLAGS_AE_A5_A6; 394 aelen += 2 * ETH_ALEN; 395 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN); 396 memcpy(meshhdr->eaddr2, addr6, ETH_ALEN); 397 } 398 return 6 + aelen; 399 } 400 401 static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata, 402 struct ieee80211_if_mesh *ifmsh) 403 { 404 bool free_plinks; 405 406 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 407 printk(KERN_DEBUG "%s: running mesh housekeeping\n", 408 sdata->name); 409 #endif 410 411 ieee80211_sta_expire(sdata, IEEE80211_MESH_PEER_INACTIVITY_LIMIT); 412 mesh_path_expire(sdata); 413 414 free_plinks = mesh_plink_availables(sdata); 415 if (free_plinks != sdata->u.mesh.accepting_plinks) 416 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON); 417 418 mod_timer(&ifmsh->housekeeping_timer, 419 round_jiffies(jiffies + IEEE80211_MESH_HOUSEKEEPING_INTERVAL)); 420 } 421 422 static void ieee80211_mesh_rootpath(struct ieee80211_sub_if_data *sdata) 423 { 424 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 425 426 mesh_path_tx_root_frame(sdata); 427 mod_timer(&ifmsh->mesh_path_root_timer, 428 round_jiffies(jiffies + IEEE80211_MESH_RANN_INTERVAL)); 429 } 430 431 #ifdef CONFIG_PM 432 void ieee80211_mesh_quiesce(struct ieee80211_sub_if_data *sdata) 433 { 434 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 435 436 /* use atomic bitops in case both timers fire at the same time */ 437 438 if (del_timer_sync(&ifmsh->housekeeping_timer)) 439 set_bit(TMR_RUNNING_HK, &ifmsh->timers_running); 440 if (del_timer_sync(&ifmsh->mesh_path_timer)) 441 set_bit(TMR_RUNNING_MP, &ifmsh->timers_running); 442 if (del_timer_sync(&ifmsh->mesh_path_root_timer)) 443 set_bit(TMR_RUNNING_MPR, &ifmsh->timers_running); 444 } 445 446 void ieee80211_mesh_restart(struct ieee80211_sub_if_data *sdata) 447 { 448 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 449 450 if (test_and_clear_bit(TMR_RUNNING_HK, &ifmsh->timers_running)) 451 add_timer(&ifmsh->housekeeping_timer); 452 if (test_and_clear_bit(TMR_RUNNING_MP, &ifmsh->timers_running)) 453 add_timer(&ifmsh->mesh_path_timer); 454 if (test_and_clear_bit(TMR_RUNNING_MPR, &ifmsh->timers_running)) 455 add_timer(&ifmsh->mesh_path_root_timer); 456 ieee80211_mesh_root_setup(ifmsh); 457 } 458 #endif 459 460 void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata) 461 { 462 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 463 struct ieee80211_local *local = sdata->local; 464 465 local->fif_other_bss++; 466 /* mesh ifaces must set allmulti to forward mcast traffic */ 467 atomic_inc(&local->iff_allmultis); 468 ieee80211_configure_filter(local); 469 470 ifmsh->mesh_cc_id = 0; /* Disabled */ 471 ifmsh->mesh_sp_id = 0; /* Neighbor Offset */ 472 ifmsh->mesh_auth_id = 0; /* Disabled */ 473 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags); 474 ieee80211_mesh_root_setup(ifmsh); 475 ieee80211_queue_work(&local->hw, &sdata->work); 476 sdata->vif.bss_conf.beacon_int = MESH_DEFAULT_BEACON_INTERVAL; 477 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON | 478 BSS_CHANGED_BEACON_ENABLED | 479 BSS_CHANGED_BEACON_INT); 480 } 481 482 void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata) 483 { 484 struct ieee80211_local *local = sdata->local; 485 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 486 487 ifmsh->mesh_id_len = 0; 488 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 489 sta_info_flush(local, NULL); 490 491 del_timer_sync(&sdata->u.mesh.housekeeping_timer); 492 del_timer_sync(&sdata->u.mesh.mesh_path_root_timer); 493 /* 494 * If the timer fired while we waited for it, it will have 495 * requeued the work. Now the work will be running again 496 * but will not rearm the timer again because it checks 497 * whether the interface is running, which, at this point, 498 * it no longer is. 499 */ 500 cancel_work_sync(&sdata->work); 501 502 local->fif_other_bss--; 503 atomic_dec(&local->iff_allmultis); 504 ieee80211_configure_filter(local); 505 } 506 507 static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata, 508 u16 stype, 509 struct ieee80211_mgmt *mgmt, 510 size_t len, 511 struct ieee80211_rx_status *rx_status) 512 { 513 struct ieee80211_local *local = sdata->local; 514 struct ieee802_11_elems elems; 515 struct ieee80211_channel *channel; 516 u32 supp_rates = 0; 517 size_t baselen; 518 int freq; 519 enum ieee80211_band band = rx_status->band; 520 521 /* ignore ProbeResp to foreign address */ 522 if (stype == IEEE80211_STYPE_PROBE_RESP && 523 compare_ether_addr(mgmt->da, sdata->vif.addr)) 524 return; 525 526 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 527 if (baselen > len) 528 return; 529 530 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 531 &elems); 532 533 /* ignore beacons from secure mesh peers if our security is off */ 534 if (elems.rsn_len && sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) 535 return; 536 537 if (elems.ds_params && elems.ds_params_len == 1) 538 freq = ieee80211_channel_to_frequency(elems.ds_params[0], band); 539 else 540 freq = rx_status->freq; 541 542 channel = ieee80211_get_channel(local->hw.wiphy, freq); 543 544 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 545 return; 546 547 if (elems.mesh_id && elems.mesh_config && 548 mesh_matches_local(&elems, sdata)) { 549 supp_rates = ieee80211_sta_get_rates(local, &elems, band); 550 mesh_neighbour_update(mgmt->sa, supp_rates, sdata, &elems); 551 } 552 } 553 554 static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata, 555 struct ieee80211_mgmt *mgmt, 556 size_t len, 557 struct ieee80211_rx_status *rx_status) 558 { 559 switch (mgmt->u.action.category) { 560 case WLAN_CATEGORY_MESH_ACTION: 561 mesh_rx_plink_frame(sdata, mgmt, len, rx_status); 562 break; 563 case WLAN_CATEGORY_MESH_PATH_SEL: 564 mesh_rx_path_sel_frame(sdata, mgmt, len); 565 break; 566 } 567 } 568 569 void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 570 struct sk_buff *skb) 571 { 572 struct ieee80211_rx_status *rx_status; 573 struct ieee80211_mgmt *mgmt; 574 u16 stype; 575 576 rx_status = IEEE80211_SKB_RXCB(skb); 577 mgmt = (struct ieee80211_mgmt *) skb->data; 578 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE; 579 580 switch (stype) { 581 case IEEE80211_STYPE_PROBE_RESP: 582 case IEEE80211_STYPE_BEACON: 583 ieee80211_mesh_rx_bcn_presp(sdata, stype, mgmt, skb->len, 584 rx_status); 585 break; 586 case IEEE80211_STYPE_ACTION: 587 ieee80211_mesh_rx_mgmt_action(sdata, mgmt, skb->len, rx_status); 588 break; 589 } 590 } 591 592 void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata) 593 { 594 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 595 596 if (ifmsh->preq_queue_len && 597 time_after(jiffies, 598 ifmsh->last_preq + msecs_to_jiffies(ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval))) 599 mesh_path_start_discovery(sdata); 600 601 if (test_and_clear_bit(MESH_WORK_GROW_MPATH_TABLE, &ifmsh->wrkq_flags)) 602 mesh_mpath_table_grow(); 603 604 if (test_and_clear_bit(MESH_WORK_GROW_MPP_TABLE, &ifmsh->wrkq_flags)) 605 mesh_mpp_table_grow(); 606 607 if (test_and_clear_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags)) 608 ieee80211_mesh_housekeeping(sdata, ifmsh); 609 610 if (test_and_clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags)) 611 ieee80211_mesh_rootpath(sdata); 612 } 613 614 void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local) 615 { 616 struct ieee80211_sub_if_data *sdata; 617 618 rcu_read_lock(); 619 list_for_each_entry_rcu(sdata, &local->interfaces, list) 620 if (ieee80211_vif_is_mesh(&sdata->vif)) 621 ieee80211_queue_work(&local->hw, &sdata->work); 622 rcu_read_unlock(); 623 } 624 625 void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata) 626 { 627 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 628 629 setup_timer(&ifmsh->housekeeping_timer, 630 ieee80211_mesh_housekeeping_timer, 631 (unsigned long) sdata); 632 633 ifmsh->accepting_plinks = true; 634 ifmsh->preq_id = 0; 635 ifmsh->sn = 0; 636 atomic_set(&ifmsh->mpaths, 0); 637 mesh_rmc_init(sdata); 638 ifmsh->last_preq = jiffies; 639 /* Allocate all mesh structures when creating the first mesh interface. */ 640 if (!mesh_allocated) 641 ieee80211s_init(); 642 setup_timer(&ifmsh->mesh_path_timer, 643 ieee80211_mesh_path_timer, 644 (unsigned long) sdata); 645 setup_timer(&ifmsh->mesh_path_root_timer, 646 ieee80211_mesh_path_root_timer, 647 (unsigned long) sdata); 648 INIT_LIST_HEAD(&ifmsh->preq_queue.list); 649 spin_lock_init(&ifmsh->mesh_preq_queue_lock); 650 } 651