mesh_pathtbl.c 21 KB

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