net/mac80211/mesh_pathtbl.c

   1 /*
   2  * Copyright (c) 2008, 2009 open80211s Ltd.
   3  * Author:     Luis Carlos Cobo <luisca@cozybit.com>
   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/etherdevice.h>
  11 #include <linux/list.h>
  12 #include <linux/random.h>
  13 #include <linux/slab.h>
  14 #include <linux/spinlock.h>
  15 #include <linux/string.h>
  16 #include <net/mac80211.h>
  17 #include "wme.h"
  18 #include "ieee80211_i.h"
  19 #include "mesh.h"
  20
  21 static void mesh_path_free_rcu(struct mesh_table *tbl, struct mesh_path *mpath);
  22
  23 static u32 mesh_table_hash(const void *addr, u32 len, u32 seed)
  24 {
  25         /* Use last four bytes of hw addr as hash index */
  26         return jhash_1word(__get_unaligned_cpu32((u8 *)addr + 2), seed);
  27 }
  28
  29 static const struct rhashtable_params mesh_rht_params = {
  30         .nelem_hint = 2,
  31         .automatic_shrinking = true,
  32         .key_len = ETH_ALEN,
  33         .key_offset = offsetof(struct mesh_path, dst),
  34         .head_offset = offsetof(struct mesh_path, rhash),
  35         .hashfn = mesh_table_hash,
  36 };
  37
  38 static inline bool mpath_expired(struct mesh_path *mpath)
  39 {
  40         return (mpath->flags & MESH_PATH_ACTIVE) &&
  41                time_after(jiffies, mpath->exp_time) &&
  42                !(mpath->flags & MESH_PATH_FIXED);
  43 }
  44
  45 static void mesh_path_rht_free(void *ptr, void *tblptr)
  46 {
  47         struct mesh_path *mpath = ptr;
  48         struct mesh_table *tbl = tblptr;
  49
  50         mesh_path_free_rcu(tbl, mpath);
  51 }
  52
  53 static struct mesh_table *mesh_table_alloc(void)
  54 {
  55         struct mesh_table *newtbl;
  56
  57         newtbl = kmalloc(sizeof(struct mesh_table), GFP_ATOMIC);
  58         if (!newtbl)
  59                 return NULL;
  60
  61         INIT_HLIST_HEAD(&newtbl->known_gates);
  62         atomic_set(&newtbl->entries,  0);
  63         spin_lock_init(&newtbl->gates_lock);
  64         rhashtable_init(&newtbl->rhead, &mesh_rht_params);
  65
  66         return newtbl;
  67 }
  68
  69 static void mesh_table_free(struct mesh_table *tbl)
  70 {
  71         rhashtable_free_and_destroy(&tbl->rhead,
  72                                     mesh_path_rht_free, tbl);
  73         kfree(tbl);
  74 }
  75
  76 /**
  77  *
  78  * mesh_path_assign_nexthop - update mesh path next hop
  79  *
  80  * @mpath: mesh path to update
  81  * @sta: next hop to assign
  82  *
  83  * Locking: mpath->state_lock must be held when calling this function
  84  */
  85 void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta)
  86 {
  87         struct sk_buff *skb;
  88         struct ieee80211_hdr *hdr;
  89         unsigned long flags;
  90
  91         rcu_assign_pointer(mpath->next_hop, sta);
  92
  93         spin_lock_irqsave(&mpath->frame_queue.lock, flags);
  94         skb_queue_walk(&mpath->frame_queue, skb) {
  95                 hdr = (struct ieee80211_hdr *) skb->data;
  96                 memcpy(hdr->addr1, sta->sta.addr, ETH_ALEN);
  97                 memcpy(hdr->addr2, mpath->sdata->vif.addr, ETH_ALEN);
  98                 ieee80211_mps_set_frame_flags(sta->sdata, sta, hdr);
  99         }
 100
 101         spin_unlock_irqrestore(&mpath->frame_queue.lock, flags);
 102 }
 103
 104 static void prepare_for_gate(struct sk_buff *skb, char *dst_addr,
 105                              struct mesh_path *gate_mpath)
 106 {
 107         struct ieee80211_hdr *hdr;
 108         struct ieee80211s_hdr *mshdr;
 109         int mesh_hdrlen, hdrlen;
 110         char *next_hop;
 111
 112         hdr = (struct ieee80211_hdr *) skb->data;
 113         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 114         mshdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
 115
 116         if (!(mshdr->flags & MESH_FLAGS_AE)) {
 117                 /* size of the fixed part of the mesh header */
 118                 mesh_hdrlen = 6;
 119
 120                 /* make room for the two extended addresses */
 121                 skb_push(skb, 2 * ETH_ALEN);
 122                 memmove(skb->data, hdr, hdrlen + mesh_hdrlen);
 123
 124                 hdr = (struct ieee80211_hdr *) skb->data;
 125
 126                 /* we preserve the previous mesh header and only add
 127                  * the new addreses */
 128                 mshdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
 129                 mshdr->flags = MESH_FLAGS_AE_A5_A6;
 130                 memcpy(mshdr->eaddr1, hdr->addr3, ETH_ALEN);
 131                 memcpy(mshdr->eaddr2, hdr->addr4, ETH_ALEN);
 132         }
 133
 134         /* update next hop */
 135         hdr = (struct ieee80211_hdr *) skb->data;
 136         rcu_read_lock();
 137         next_hop = rcu_dereference(gate_mpath->next_hop)->sta.addr;
 138         memcpy(hdr->addr1, next_hop, ETH_ALEN);
 139         rcu_read_unlock();
 140         memcpy(hdr->addr2, gate_mpath->sdata->vif.addr, ETH_ALEN);
 141         memcpy(hdr->addr3, dst_addr, ETH_ALEN);
 142 }
 143
 144 /**
 145  *
 146  * mesh_path_move_to_queue - Move or copy frames from one mpath queue to another
 147  *
 148  * This function is used to transfer or copy frames from an unresolved mpath to
 149  * a gate mpath.  The function also adds the Address Extension field and
 150  * updates the next hop.
 151  *
 152  * If a frame already has an Address Extension field, only the next hop and
 153  * destination addresses are updated.
 154  *
 155  * The gate mpath must be an active mpath with a valid mpath->next_hop.
 156  *
 157  * @mpath: An active mpath the frames will be sent to (i.e. the gate)
 158  * @from_mpath: The failed mpath
 159  * @copy: When true, copy all the frames to the new mpath queue.  When false,
 160  * move them.
 161  */
 162 static void mesh_path_move_to_queue(struct mesh_path *gate_mpath,
 163                                     struct mesh_path *from_mpath,
 164                                     bool copy)
 165 {
 166         struct sk_buff *skb, *fskb, *tmp;
 167         struct sk_buff_head failq;
 168         unsigned long flags;
 169
 170         if (WARN_ON(gate_mpath == from_mpath))
 171                 return;
 172         if (WARN_ON(!gate_mpath->next_hop))
 173                 return;
 174
 175         __skb_queue_head_init(&failq);
 176
 177         spin_lock_irqsave(&from_mpath->frame_queue.lock, flags);
 178         skb_queue_splice_init(&from_mpath->frame_queue, &failq);
 179         spin_unlock_irqrestore(&from_mpath->frame_queue.lock, flags);
 180
 181         skb_queue_walk_safe(&failq, fskb, tmp) {
 182                 if (skb_queue_len(&gate_mpath->frame_queue) >=
 183                                   MESH_FRAME_QUEUE_LEN) {
 184                         mpath_dbg(gate_mpath->sdata, "mpath queue full!\n");
 185                         break;
 186                 }
 187
 188                 skb = skb_copy(fskb, GFP_ATOMIC);
 189                 if (WARN_ON(!skb))
 190                         break;
 191
 192                 prepare_for_gate(skb, gate_mpath->dst, gate_mpath);
 193                 skb_queue_tail(&gate_mpath->frame_queue, skb);
 194
 195                 if (copy)
 196                         continue;
 197
 198                 __skb_unlink(fskb, &failq);
 199                 kfree_skb(fskb);
 200         }
 201
 202         mpath_dbg(gate_mpath->sdata, "Mpath queue for gate %pM has %d frames\n",
 203                   gate_mpath->dst, skb_queue_len(&gate_mpath->frame_queue));
 204
 205         if (!copy)
 206                 return;
 207
 208         spin_lock_irqsave(&from_mpath->frame_queue.lock, flags);
 209         skb_queue_splice(&failq, &from_mpath->frame_queue);
 210         spin_unlock_irqrestore(&from_mpath->frame_queue.lock, flags);
 211 }
 212
 213
 214 static struct mesh_path *mpath_lookup(struct mesh_table *tbl, const u8 *dst,
 215                                       struct ieee80211_sub_if_data *sdata)
 216 {
 217         struct mesh_path *mpath;
 218
 219         mpath = rhashtable_lookup_fast(&tbl->rhead, dst, mesh_rht_params);
 220
 221         if (mpath && mpath_expired(mpath)) {
 222                 spin_lock_bh(&mpath->state_lock);
 223                 mpath->flags &= ~MESH_PATH_ACTIVE;
 224                 spin_unlock_bh(&mpath->state_lock);
 225         }
 226         return mpath;
 227 }
 228
 229 /**
 230  * mesh_path_lookup - look up a path in the mesh path table
 231  * @sdata: local subif
 232  * @dst: hardware address (ETH_ALEN length) of destination
 233  *
 234  * Returns: pointer to the mesh path structure, or NULL if not found
 235  *
 236  * Locking: must be called within a read rcu section.
 237  */
 238 struct mesh_path *
 239 mesh_path_lookup(struct ieee80211_sub_if_data *sdata, const u8 *dst)
 240 {
 241         return mpath_lookup(sdata->u.mesh.mesh_paths, dst, sdata);
 242 }
 243
 244 struct mesh_path *
 245 mpp_path_lookup(struct ieee80211_sub_if_data *sdata, const u8 *dst)
 246 {
 247         return mpath_lookup(sdata->u.mesh.mpp_paths, dst, sdata);
 248 }
 249
 250 static struct mesh_path *
 251 __mesh_path_lookup_by_idx(struct mesh_table *tbl, int idx)
 252 {
 253         int i = 0, ret;
 254         struct mesh_path *mpath = NULL;
 255         struct rhashtable_iter iter;
 256
 257         ret = rhashtable_walk_init(&tbl->rhead, &iter, GFP_ATOMIC);
 258         if (ret)
 259                 return NULL;
 260
 261         ret = rhashtable_walk_start(&iter);
 262         if (ret && ret != -EAGAIN)
 263                 goto err;
 264
 265         while ((mpath = rhashtable_walk_next(&iter))) {
 266                 if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
 267                         continue;
 268                 if (IS_ERR(mpath))
 269                         break;
 270                 if (i++ == idx)
 271                         break;
 272         }
 273 err:
 274         rhashtable_walk_stop(&iter);
 275         rhashtable_walk_exit(&iter);
 276
 277         if (IS_ERR(mpath) || !mpath)
 278                 return NULL;
 279
 280         if (mpath_expired(mpath)) {
 281                 spin_lock_bh(&mpath->state_lock);
 282                 mpath->flags &= ~MESH_PATH_ACTIVE;
 283                 spin_unlock_bh(&mpath->state_lock);
 284         }
 285         return mpath;
 286 }
 287
 288 /**
 289  * mesh_path_lookup_by_idx - look up a path in the mesh path table by its index
 290  * @idx: index
 291  * @sdata: local subif, or NULL for all entries
 292  *
 293  * Returns: pointer to the mesh path structure, or NULL if not found.
 294  *
 295  * Locking: must be called within a read rcu section.
 296  */
 297 struct mesh_path *
 298 mesh_path_lookup_by_idx(struct ieee80211_sub_if_data *sdata, int idx)
 299 {
 300         return __mesh_path_lookup_by_idx(sdata->u.mesh.mesh_paths, idx);
 301 }
 302
 303 /**
 304  * mpp_path_lookup_by_idx - look up a path in the proxy path table by its index
 305  * @idx: index
 306  * @sdata: local subif, or NULL for all entries
 307  *
 308  * Returns: pointer to the proxy path structure, or NULL if not found.
 309  *
 310  * Locking: must be called within a read rcu section.
 311  */
 312 struct mesh_path *
 313 mpp_path_lookup_by_idx(struct ieee80211_sub_if_data *sdata, int idx)
 314 {
 315         return __mesh_path_lookup_by_idx(sdata->u.mesh.mpp_paths, idx);
 316 }
 317
 318 /**
 319  * mesh_path_add_gate - add the given mpath to a mesh gate to our path table
 320  * @mpath: gate path to add to table
 321  */
 322 int mesh_path_add_gate(struct mesh_path *mpath)
 323 {
 324         struct mesh_table *tbl;
 325         int err;
 326
 327         rcu_read_lock();
 328         tbl = mpath->sdata->u.mesh.mesh_paths;
 329
 330         spin_lock_bh(&mpath->state_lock);
 331         if (mpath->is_gate) {
 332                 err = -EEXIST;
 333                 spin_unlock_bh(&mpath->state_lock);
 334                 goto err_rcu;
 335         }
 336         mpath->is_gate = true;
 337         mpath->sdata->u.mesh.num_gates++;
 338
 339         spin_lock(&tbl->gates_lock);
 340         hlist_add_head_rcu(&mpath->gate_list, &tbl->known_gates);
 341         spin_unlock(&tbl->gates_lock);
 342
 343         spin_unlock_bh(&mpath->state_lock);
 344
 345         mpath_dbg(mpath->sdata,
 346                   "Mesh path: Recorded new gate: %pM. %d known gates\n",
 347                   mpath->dst, mpath->sdata->u.mesh.num_gates);
 348         err = 0;
 349 err_rcu:
 350         rcu_read_unlock();
 351         return err;
 352 }
 353
 354 /**
 355  * mesh_gate_del - remove a mesh gate from the list of known gates
 356  * @tbl: table which holds our list of known gates
 357  * @mpath: gate mpath
 358  */
 359 static void mesh_gate_del(struct mesh_table *tbl, struct mesh_path *mpath)
 360 {
 361         lockdep_assert_held(&mpath->state_lock);
 362         if (!mpath->is_gate)
 363                 return;
 364
 365         mpath->is_gate = false;
 366         spin_lock_bh(&tbl->gates_lock);
 367         hlist_del_rcu(&mpath->gate_list);
 368         mpath->sdata->u.mesh.num_gates--;
 369         spin_unlock_bh(&tbl->gates_lock);
 370
 371         mpath_dbg(mpath->sdata,
 372                   "Mesh path: Deleted gate: %pM. %d known gates\n",
 373                   mpath->dst, mpath->sdata->u.mesh.num_gates);
 374 }
 375
 376 /**
 377  * mesh_gate_num - number of gates known to this interface
 378  * @sdata: subif data
 379  */
 380 int mesh_gate_num(struct ieee80211_sub_if_data *sdata)
 381 {
 382         return sdata->u.mesh.num_gates;
 383 }
 384
 385 static
 386 struct mesh_path *mesh_path_new(struct ieee80211_sub_if_data *sdata,
 387                                 const u8 *dst, gfp_t gfp_flags)
 388 {
 389         struct mesh_path *new_mpath;
 390
 391         new_mpath = kzalloc(sizeof(struct mesh_path), gfp_flags);
 392         if (!new_mpath)
 393                 return NULL;
 394
 395         memcpy(new_mpath->dst, dst, ETH_ALEN);
 396         eth_broadcast_addr(new_mpath->rann_snd_addr);
 397         new_mpath->is_root = false;
 398         new_mpath->sdata = sdata;
 399         new_mpath->flags = 0;
 400         skb_queue_head_init(&new_mpath->frame_queue);
 401         new_mpath->timer.data = (unsigned long) new_mpath;
 402         new_mpath->timer.function = mesh_path_timer;
 403         new_mpath->exp_time = jiffies;
 404         spin_lock_init(&new_mpath->state_lock);
 405         init_timer(&new_mpath->timer);
 406
 407         return new_mpath;
 408 }
 409
 410 /**
 411  * mesh_path_add - allocate and add a new path to the mesh path table
 412  * @dst: destination address of the path (ETH_ALEN length)
 413  * @sdata: local subif
 414  *
 415  * Returns: 0 on success
 416  *
 417  * State: the initial state of the new path is set to 0
 418  */
 419 struct mesh_path *mesh_path_add(struct ieee80211_sub_if_data *sdata,
 420                                 const u8 *dst)
 421 {
 422         struct mesh_table *tbl;
 423         struct mesh_path *mpath, *new_mpath;
 424         int ret;
 425
 426         if (ether_addr_equal(dst, sdata->vif.addr))
 427                 /* never add ourselves as neighbours */
 428                 return ERR_PTR(-ENOTSUPP);
 429
 430         if (is_multicast_ether_addr(dst))
 431                 return ERR_PTR(-ENOTSUPP);
 432
 433         if (atomic_add_unless(&sdata->u.mesh.mpaths, 1, MESH_MAX_MPATHS) == 0)
 434                 return ERR_PTR(-ENOSPC);
 435
 436         new_mpath = mesh_path_new(sdata, dst, GFP_ATOMIC);
 437         if (!new_mpath)
 438                 return ERR_PTR(-ENOMEM);
 439
 440         tbl = sdata->u.mesh.mesh_paths;
 441         do {
 442                 ret = rhashtable_lookup_insert_fast(&tbl->rhead,
 443                                                     &new_mpath->rhash,
 444                                                     mesh_rht_params);
 445
 446                 if (ret == -EEXIST)
 447                         mpath = rhashtable_lookup_fast(&tbl->rhead,
 448                                                        dst,
 449                                                        mesh_rht_params);
 450
 451         } while (unlikely(ret == -EEXIST && !mpath));
 452
 453         if (ret) {
 454                 kfree(new_mpath);
 455
 456                 if (ret != -EEXIST)
 457                         return ERR_PTR(ret);
 458
 459                 new_mpath = mpath;
 460         }
 461
 462         sdata->u.mesh.mesh_paths_generation++;
 463         return new_mpath;
 464 }
 465
 466 int mpp_path_add(struct ieee80211_sub_if_data *sdata,
 467                  const u8 *dst, const u8 *mpp)
 468 {
 469         struct mesh_table *tbl;
 470         struct mesh_path *new_mpath;
 471         int ret;
 472
 473         if (ether_addr_equal(dst, sdata->vif.addr))
 474                 /* never add ourselves as neighbours */
 475                 return -ENOTSUPP;
 476
 477         if (is_multicast_ether_addr(dst))
 478                 return -ENOTSUPP;
 479
 480         new_mpath = mesh_path_new(sdata, dst, GFP_ATOMIC);
 481
 482         if (!new_mpath)
 483                 return -ENOMEM;
 484
 485         memcpy(new_mpath->mpp, mpp, ETH_ALEN);
 486         tbl = sdata->u.mesh.mpp_paths;
 487         ret = rhashtable_lookup_insert_fast(&tbl->rhead,
 488                                             &new_mpath->rhash,
 489                                             mesh_rht_params);
 490
 491         if (ret)
 492                 kfree(new_mpath);
 493
 494         sdata->u.mesh.mpp_paths_generation++;
 495         return ret;
 496 }
 497
 498
 499 /**
 500  * mesh_plink_broken - deactivates paths and sends perr when a link breaks
 501  *
 502  * @sta: broken peer link
 503  *
 504  * This function must be called from the rate control algorithm if enough
 505  * delivery errors suggest that a peer link is no longer usable.
 506  */
 507 void mesh_plink_broken(struct sta_info *sta)
 508 {
 509         struct ieee80211_sub_if_data *sdata = sta->sdata;
 510         struct mesh_table *tbl = sdata->u.mesh.mesh_paths;
 511         static const u8 bcast[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 512         struct mesh_path *mpath;
 513         struct rhashtable_iter iter;
 514         int ret;
 515
 516         ret = rhashtable_walk_init(&tbl->rhead, &iter, GFP_ATOMIC);
 517         if (ret)
 518                 return;
 519
 520         ret = rhashtable_walk_start(&iter);
 521         if (ret && ret != -EAGAIN)
 522                 goto out;
 523
 524         while ((mpath = rhashtable_walk_next(&iter))) {
 525                 if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
 526                         continue;
 527                 if (IS_ERR(mpath))
 528                         break;
 529                 if (rcu_access_pointer(mpath->next_hop) == sta &&
 530                     mpath->flags & MESH_PATH_ACTIVE &&
 531                     !(mpath->flags & MESH_PATH_FIXED)) {
 532                         spin_lock_bh(&mpath->state_lock);
 533                         mpath->flags &= ~MESH_PATH_ACTIVE;
 534                         ++mpath->sn;
 535                         spin_unlock_bh(&mpath->state_lock);
 536                         mesh_path_error_tx(sdata,
 537                                 sdata->u.mesh.mshcfg.element_ttl,
 538                                 mpath->dst, mpath->sn,
 539                                 WLAN_REASON_MESH_PATH_DEST_UNREACHABLE, bcast);
 540                 }
 541         }
 542 out:
 543         rhashtable_walk_stop(&iter);
 544         rhashtable_walk_exit(&iter);
 545 }
 546
 547 static void mesh_path_free_rcu(struct mesh_table *tbl,
 548                                struct mesh_path *mpath)
 549 {
 550         struct ieee80211_sub_if_data *sdata = mpath->sdata;
 551
 552         spin_lock_bh(&mpath->state_lock);
 553         mpath->flags |= MESH_PATH_RESOLVING | MESH_PATH_DELETED;
 554         mesh_gate_del(tbl, mpath);
 555         spin_unlock_bh(&mpath->state_lock);
 556         del_timer_sync(&mpath->timer);
 557         atomic_dec(&sdata->u.mesh.mpaths);
 558         atomic_dec(&tbl->entries);
 559         mesh_path_flush_pending(mpath);
 560         kfree_rcu(mpath, rcu);
 561 }
 562
 563 static void __mesh_path_del(struct mesh_table *tbl, struct mesh_path *mpath)
 564 {
 565         rhashtable_remove_fast(&tbl->rhead, &mpath->rhash, mesh_rht_params);
 566         mesh_path_free_rcu(tbl, mpath);
 567 }
 568
 569 /**
 570  * mesh_path_flush_by_nexthop - Deletes mesh paths if their next hop matches
 571  *
 572  * @sta: mesh peer to match
 573  *
 574  * RCU notes: this function is called when a mesh plink transitions from
 575  * PLINK_ESTAB to any other state, since PLINK_ESTAB state is the only one that
 576  * allows path creation. This will happen before the sta can be freed (because
 577  * sta_info_destroy() calls this) so any reader in a rcu read block will be
 578  * protected against the plink disappearing.
 579  */
 580 void mesh_path_flush_by_nexthop(struct sta_info *sta)
 581 {
 582         struct ieee80211_sub_if_data *sdata = sta->sdata;
 583         struct mesh_table *tbl = sdata->u.mesh.mesh_paths;
 584         struct mesh_path *mpath;
 585         struct rhashtable_iter iter;
 586         int ret;
 587
 588         ret = rhashtable_walk_init(&tbl->rhead, &iter, GFP_ATOMIC);
 589         if (ret)
 590                 return;
 591
 592         ret = rhashtable_walk_start(&iter);
 593         if (ret && ret != -EAGAIN)
 594                 goto out;
 595
 596         while ((mpath = rhashtable_walk_next(&iter))) {
 597                 if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
 598                         continue;
 599                 if (IS_ERR(mpath))
 600                         break;
 601
 602                 if (rcu_access_pointer(mpath->next_hop) == sta)
 603                         __mesh_path_del(tbl, mpath);
 604         }
 605 out:
 606         rhashtable_walk_stop(&iter);
 607         rhashtable_walk_exit(&iter);
 608 }
 609
 610 static void mpp_flush_by_proxy(struct ieee80211_sub_if_data *sdata,
 611                                const u8 *proxy)
 612 {
 613         struct mesh_table *tbl = sdata->u.mesh.mpp_paths;
 614         struct mesh_path *mpath;
 615         struct rhashtable_iter iter;
 616         int ret;
 617
 618         ret = rhashtable_walk_init(&tbl->rhead, &iter, GFP_ATOMIC);
 619         if (ret)
 620                 return;
 621
 622         ret = rhashtable_walk_start(&iter);
 623         if (ret && ret != -EAGAIN)
 624                 goto out;
 625
 626         while ((mpath = rhashtable_walk_next(&iter))) {
 627                 if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
 628                         continue;
 629                 if (IS_ERR(mpath))
 630                         break;
 631
 632                 if (ether_addr_equal(mpath->mpp, proxy))
 633                         __mesh_path_del(tbl, mpath);
 634         }
 635 out:
 636         rhashtable_walk_stop(&iter);
 637         rhashtable_walk_exit(&iter);
 638 }
 639
 640 static void table_flush_by_iface(struct mesh_table *tbl)
 641 {
 642         struct mesh_path *mpath;
 643         struct rhashtable_iter iter;
 644         int ret;
 645
 646         ret = rhashtable_walk_init(&tbl->rhead, &iter, GFP_ATOMIC);
 647         if (ret)
 648                 return;
 649
 650         ret = rhashtable_walk_start(&iter);
 651         if (ret && ret != -EAGAIN)
 652                 goto out;
 653
 654         while ((mpath = rhashtable_walk_next(&iter))) {
 655                 if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
 656                         continue;
 657                 if (IS_ERR(mpath))
 658                         break;
 659                 __mesh_path_del(tbl, mpath);
 660         }
 661 out:
 662         rhashtable_walk_stop(&iter);
 663         rhashtable_walk_exit(&iter);
 664 }
 665
 666 /**
 667  * mesh_path_flush_by_iface - Deletes all mesh paths associated with a given iface
 668  *
 669  * This function deletes both mesh paths as well as mesh portal paths.
 670  *
 671  * @sdata: interface data to match
 672  *
 673  */
 674 void mesh_path_flush_by_iface(struct ieee80211_sub_if_data *sdata)
 675 {
 676         table_flush_by_iface(sdata->u.mesh.mesh_paths);
 677         table_flush_by_iface(sdata->u.mesh.mpp_paths);
 678 }
 679
 680 /**
 681  * table_path_del - delete a path from the mesh or mpp table
 682  *
 683  * @tbl: mesh or mpp path table
 684  * @sdata: local subif
 685  * @addr: dst address (ETH_ALEN length)
 686  *
 687  * Returns: 0 if successful
 688  */
 689 static int table_path_del(struct mesh_table *tbl,
 690                           struct ieee80211_sub_if_data *sdata,
 691                           const u8 *addr)
 692 {
 693         struct mesh_path *mpath;
 694
 695         rcu_read_lock();
 696         mpath = rhashtable_lookup_fast(&tbl->rhead, addr, mesh_rht_params);
 697         if (!mpath) {
 698                 rcu_read_unlock();
 699                 return -ENXIO;
 700         }
 701
 702         __mesh_path_del(tbl, mpath);
 703         rcu_read_unlock();
 704         return 0;
 705 }
 706
 707
 708 /**
 709  * mesh_path_del - delete a mesh path from the table
 710  *
 711  * @addr: dst address (ETH_ALEN length)
 712  * @sdata: local subif
 713  *
 714  * Returns: 0 if successful
 715  */
 716 int mesh_path_del(struct ieee80211_sub_if_data *sdata, const u8 *addr)
 717 {
 718         int err;
 719
 720         /* flush relevant mpp entries first */
 721         mpp_flush_by_proxy(sdata, addr);
 722
 723         err = table_path_del(sdata->u.mesh.mesh_paths, sdata, addr);
 724         sdata->u.mesh.mesh_paths_generation++;
 725         return err;
 726 }
 727
 728 /**
 729  * mesh_path_tx_pending - sends pending frames in a mesh path queue
 730  *
 731  * @mpath: mesh path to activate
 732  *
 733  * Locking: the state_lock of the mpath structure must NOT be held when calling
 734  * this function.
 735  */
 736 void mesh_path_tx_pending(struct mesh_path *mpath)
 737 {
 738         if (mpath->flags & MESH_PATH_ACTIVE)
 739                 ieee80211_add_pending_skbs(mpath->sdata->local,
 740                                 &mpath->frame_queue);
 741 }
 742
 743 /**
 744  * mesh_path_send_to_gates - sends pending frames to all known mesh gates
 745  *
 746  * @mpath: mesh path whose queue will be emptied
 747  *
 748  * If there is only one gate, the frames are transferred from the failed mpath
 749  * queue to that gate's queue.  If there are more than one gates, the frames
 750  * are copied from each gate to the next.  After frames are copied, the
 751  * mpath queues are emptied onto the transmission queue.
 752  */
 753 int mesh_path_send_to_gates(struct mesh_path *mpath)
 754 {
 755         struct ieee80211_sub_if_data *sdata = mpath->sdata;
 756         struct mesh_table *tbl;
 757         struct mesh_path *from_mpath = mpath;
 758         struct mesh_path *gate;
 759         bool copy = false;
 760
 761         tbl = sdata->u.mesh.mesh_paths;
 762
 763         rcu_read_lock();
 764         hlist_for_each_entry_rcu(gate, &tbl->known_gates, gate_list) {
 765                 if (gate->flags & MESH_PATH_ACTIVE) {
 766                         mpath_dbg(sdata, "Forwarding to %pM\n", gate->dst);
 767                         mesh_path_move_to_queue(gate, from_mpath, copy);
 768                         from_mpath = gate;
 769                         copy = true;
 770                 } else {
 771                         mpath_dbg(sdata,
 772                                   "Not forwarding to %pM (flags %#x)\n",
 773                                   gate->dst, gate->flags);
 774                 }
 775         }
 776
 777         hlist_for_each_entry_rcu(gate, &tbl->known_gates, gate_list) {
 778                 mpath_dbg(sdata, "Sending to %pM\n", gate->dst);
 779                 mesh_path_tx_pending(gate);
 780         }
 781         rcu_read_unlock();
 782
 783         return (from_mpath == mpath) ? -EHOSTUNREACH : 0;
 784 }
 785
 786 /**
 787  * mesh_path_discard_frame - discard a frame whose path could not be resolved
 788  *
 789  * @skb: frame to discard
 790  * @sdata: network subif the frame was to be sent through
 791  *
 792  * Locking: the function must me called within a rcu_read_lock region
 793  */
 794 void mesh_path_discard_frame(struct ieee80211_sub_if_data *sdata,
 795                              struct sk_buff *skb)
 796 {
 797         ieee80211_free_txskb(&sdata->local->hw, skb);
 798         sdata->u.mesh.mshstats.dropped_frames_no_route++;
 799 }
 800
 801 /**
 802  * mesh_path_flush_pending - free the pending queue of a mesh path
 803  *
 804  * @mpath: mesh path whose queue has to be freed
 805  *
 806  * Locking: the function must me called within a rcu_read_lock region
 807  */
 808 void mesh_path_flush_pending(struct mesh_path *mpath)
 809 {
 810         struct sk_buff *skb;
 811
 812         while ((skb = skb_dequeue(&mpath->frame_queue)) != NULL)
 813                 mesh_path_discard_frame(mpath->sdata, skb);
 814 }
 815
 816 /**
 817  * mesh_path_fix_nexthop - force a specific next hop for a mesh path
 818  *
 819  * @mpath: the mesh path to modify
 820  * @next_hop: the next hop to force
 821  *
 822  * Locking: this function must be called holding mpath->state_lock
 823  */
 824 void mesh_path_fix_nexthop(struct mesh_path *mpath, struct sta_info *next_hop)
 825 {
 826         spin_lock_bh(&mpath->state_lock);
 827         mesh_path_assign_nexthop(mpath, next_hop);
 828         mpath->sn = 0xffff;
 829         mpath->metric = 0;
 830         mpath->hop_count = 0;
 831         mpath->exp_time = 0;
 832         mpath->flags = MESH_PATH_FIXED | MESH_PATH_SN_VALID;
 833         mesh_path_activate(mpath);
 834         spin_unlock_bh(&mpath->state_lock);
 835         mesh_path_tx_pending(mpath);
 836 }
 837
 838 int mesh_pathtbl_init(struct ieee80211_sub_if_data *sdata)
 839 {
 840         struct mesh_table *tbl_path, *tbl_mpp;
 841         int ret;
 842
 843         tbl_path = mesh_table_alloc();
 844         if (!tbl_path)
 845                 return -ENOMEM;
 846
 847         tbl_mpp = mesh_table_alloc();
 848         if (!tbl_mpp) {
 849                 ret = -ENOMEM;
 850                 goto free_path;
 851         }
 852
 853         sdata->u.mesh.mesh_paths = tbl_path;
 854         sdata->u.mesh.mpp_paths = tbl_mpp;
 855
 856         return 0;
 857
 858 free_path:
 859         mesh_table_free(tbl_path);
 860         return ret;
 861 }
 862
 863 static
 864 void mesh_path_tbl_expire(struct ieee80211_sub_if_data *sdata,
 865                           struct mesh_table *tbl)
 866 {
 867         struct mesh_path *mpath;
 868         struct rhashtable_iter iter;
 869         int ret;
 870
 871         ret = rhashtable_walk_init(&tbl->rhead, &iter, GFP_KERNEL);
 872         if (ret)
 873                 return;
 874
 875         ret = rhashtable_walk_start(&iter);
 876         if (ret && ret != -EAGAIN)
 877                 goto out;
 878
 879         while ((mpath = rhashtable_walk_next(&iter))) {
 880                 if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
 881                         continue;
 882                 if (IS_ERR(mpath))
 883                         break;
 884                 if ((!(mpath->flags & MESH_PATH_RESOLVING)) &&
 885                     (!(mpath->flags & MESH_PATH_FIXED)) &&
 886                      time_after(jiffies, mpath->exp_time + MESH_PATH_EXPIRE))
 887                         __mesh_path_del(tbl, mpath);
 888         }
 889 out:
 890         rhashtable_walk_stop(&iter);
 891         rhashtable_walk_exit(&iter);
 892 }
 893
 894 void mesh_path_expire(struct ieee80211_sub_if_data *sdata)
 895 {
 896         mesh_path_tbl_expire(sdata, sdata->u.mesh.mesh_paths);
 897         mesh_path_tbl_expire(sdata, sdata->u.mesh.mpp_paths);
 898 }
 899
 900 void mesh_pathtbl_unregister(struct ieee80211_sub_if_data *sdata)
 901 {
 902         mesh_table_free(sdata->u.mesh.mesh_paths);
 903         mesh_table_free(sdata->u.mesh.mpp_paths);
 904 }