[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / mac80211 / mesh_pathtbl.c

/*
 * Copyright (c) 2008 open80211s Ltd.
 * Author:     Luis Carlos Cobo <luisca@cozybit.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/etherdevice.h>
#include <linux/list.h>
#include <linux/random.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <net/mac80211.h>
#include "ieee80211_i.h"
#include "mesh.h"

/* There will be initially 2^INIT_PATHS_SIZE_ORDER buckets */
#define INIT_PATHS_SIZE_ORDER	2

/* Keep the mean chain length below this constant */
#define MEAN_CHAIN_LEN		2

#define MPATH_EXPIRED(mpath) ((mpath->flags & MESH_PATH_ACTIVE) && \
				time_after(jiffies, mpath->exp_time) && \
				!(mpath->flags & MESH_PATH_FIXED))

struct mpath_node {
	struct hlist_node list;
	struct rcu_head rcu;
	/* This indirection allows two different tables to point to the same
	 * mesh_path structure, useful when resizing
	 */
	struct mesh_path *mpath;
};

static struct mesh_table *mesh_paths;
static struct mesh_table *mpp_paths; /* Store paths for MPP&MAP */

/* This lock will have the grow table function as writer and add / delete nodes
 * as readers. When reading the table (i.e. doing lookups) we are well protected
 * by RCU
 */
static DEFINE_RWLOCK(pathtbl_resize_lock);

/**
 *
 * mesh_path_assign_nexthop - update mesh path next hop
 *
 * @mpath: mesh path to update
 * @sta: next hop to assign
 *
 * Locking: mpath->state_lock must be held when calling this function
 */
void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta)
{
	rcu_assign_pointer(mpath->next_hop, sta);
}


/**
 * mesh_path_lookup - look up a path in the mesh path table
 * @dst: hardware address (ETH_ALEN length) of destination
 * @sdata: local subif
 *
 * Returns: pointer to the mesh path structure, or NULL if not found
 *
 * Locking: must be called within a read rcu section.
 */
struct mesh_path *mesh_path_lookup(u8 *dst, struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath;
	struct hlist_node *n;
	struct hlist_head *bucket;
	struct mesh_table *tbl;
	struct mpath_node *node;

	tbl = rcu_dereference(mesh_paths);

	bucket = &tbl->hash_buckets[mesh_table_hash(dst, sdata, tbl)];
	hlist_for_each_entry_rcu(node, n, bucket, list) {
		mpath = node->mpath;
		if (mpath->sdata == sdata &&
				memcmp(dst, mpath->dst, ETH_ALEN) == 0) {
			if (MPATH_EXPIRED(mpath)) {
				spin_lock_bh(&mpath->state_lock);
				if (MPATH_EXPIRED(mpath))
					mpath->flags &= ~MESH_PATH_ACTIVE;
				spin_unlock_bh(&mpath->state_lock);
			}
			return mpath;
		}
	}
	return NULL;
}

struct mesh_path *mpp_path_lookup(u8 *dst, struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath;
	struct hlist_node *n;
	struct hlist_head *bucket;
	struct mesh_table *tbl;
	struct mpath_node *node;

	tbl = rcu_dereference(mpp_paths);

	bucket = &tbl->hash_buckets[mesh_table_hash(dst, sdata, tbl)];
	hlist_for_each_entry_rcu(node, n, bucket, list) {
		mpath = node->mpath;
		if (mpath->sdata == sdata &&
		    memcmp(dst, mpath->dst, ETH_ALEN) == 0) {
			if (MPATH_EXPIRED(mpath)) {
				spin_lock_bh(&mpath->state_lock);
				if (MPATH_EXPIRED(mpath))
					mpath->flags &= ~MESH_PATH_ACTIVE;
				spin_unlock_bh(&mpath->state_lock);
			}
			return mpath;
		}
	}
	return NULL;
}


/**
 * mesh_path_lookup_by_idx - look up a path in the mesh path table by its index
 * @idx: index
 * @sdata: local subif, or NULL for all entries
 *
 * Returns: pointer to the mesh path structure, or NULL if not found.
 *
 * Locking: must be called within a read rcu section.
 */
struct mesh_path *mesh_path_lookup_by_idx(int idx, struct ieee80211_sub_if_data *sdata)
{
	struct mpath_node *node;
	struct hlist_node *p;
	int i;
	int j = 0;

	for_each_mesh_entry(mesh_paths, p, node, i) {
		if (sdata && node->mpath->sdata != sdata)
			continue;
		if (j++ == idx) {
			if (MPATH_EXPIRED(node->mpath)) {
				spin_lock_bh(&node->mpath->state_lock);
				if (MPATH_EXPIRED(node->mpath))
					node->mpath->flags &= ~MESH_PATH_ACTIVE;
				spin_unlock_bh(&node->mpath->state_lock);
			}
			return node->mpath;
		}
	}

	return NULL;
}

/**
 * mesh_path_add - allocate and add a new path to the mesh path table
 * @addr: destination address of the path (ETH_ALEN length)
 * @sdata: local subif
 *
 * Returns: 0 on sucess
 *
 * State: the initial state of the new path is set to 0
 */
int mesh_path_add(u8 *dst, struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath, *new_mpath;
	struct mpath_node *node, *new_node;
	struct hlist_head *bucket;
	struct hlist_node *n;
	int grow = 0;
	int err = 0;
	u32 hash_idx;

	might_sleep();

	if (memcmp(dst, sdata->dev->dev_addr, ETH_ALEN) == 0)
		/* never add ourselves as neighbours */
		return -ENOTSUPP;

	if (is_multicast_ether_addr(dst))
		return -ENOTSUPP;

	if (atomic_add_unless(&sdata->u.mesh.mpaths, 1, MESH_MAX_MPATHS) == 0)
		return -ENOSPC;

	err = -ENOMEM;
	new_mpath = kzalloc(sizeof(struct mesh_path), GFP_KERNEL);
	if (!new_mpath)
		goto err_path_alloc;

	new_node = kmalloc(sizeof(struct mpath_node), GFP_KERNEL);
	if (!new_node)
		goto err_node_alloc;

	read_lock(&pathtbl_resize_lock);
	memcpy(new_mpath->dst, dst, ETH_ALEN);
	new_mpath->sdata = sdata;
	new_mpath->flags = 0;
	skb_queue_head_init(&new_mpath->frame_queue);
	new_node->mpath = new_mpath;
	new_mpath->timer.data = (unsigned long) new_mpath;
	new_mpath->timer.function = mesh_path_timer;
	new_mpath->exp_time = jiffies;
	spin_lock_init(&new_mpath->state_lock);
	init_timer(&new_mpath->timer);

	hash_idx = mesh_table_hash(dst, sdata, mesh_paths);
	bucket = &mesh_paths->hash_buckets[hash_idx];

	spin_lock(&mesh_paths->hashwlock[hash_idx]);

	err = -EEXIST;
	hlist_for_each_entry(node, n, bucket, list) {
		mpath = node->mpath;
		if (mpath->sdata == sdata && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
			goto err_exists;
	}

	hlist_add_head_rcu(&new_node->list, bucket);
	if (atomic_inc_return(&mesh_paths->entries) >=
		mesh_paths->mean_chain_len * (mesh_paths->hash_mask + 1))
		grow = 1;

	spin_unlock(&mesh_paths->hashwlock[hash_idx]);
	read_unlock(&pathtbl_resize_lock);
	if (grow) {
		struct mesh_table *oldtbl, *newtbl;

		write_lock(&pathtbl_resize_lock);
		oldtbl = mesh_paths;
		newtbl = mesh_table_grow(mesh_paths);
		if (!newtbl) {
			write_unlock(&pathtbl_resize_lock);
			return 0;
		}
		rcu_assign_pointer(mesh_paths, newtbl);
		write_unlock(&pathtbl_resize_lock);

		synchronize_rcu();
		mesh_table_free(oldtbl, false);
	}
	return 0;

err_exists:
	spin_unlock(&mesh_paths->hashwlock[hash_idx]);
	read_unlock(&pathtbl_resize_lock);
	kfree(new_node);
err_node_alloc:
	kfree(new_mpath);
err_path_alloc:
	atomic_dec(&sdata->u.mesh.mpaths);
	return err;
}


int mpp_path_add(u8 *dst, u8 *mpp, struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath, *new_mpath;
	struct mpath_node *node, *new_node;
	struct hlist_head *bucket;
	struct hlist_node *n;
	int grow = 0;
	int err = 0;
	u32 hash_idx;

	might_sleep();

	if (memcmp(dst, sdata->dev->dev_addr, ETH_ALEN) == 0)
		/* never add ourselves as neighbours */
		return -ENOTSUPP;

	if (is_multicast_ether_addr(dst))
		return -ENOTSUPP;

	err = -ENOMEM;
	new_mpath = kzalloc(sizeof(struct mesh_path), GFP_KERNEL);
	if (!new_mpath)
		goto err_path_alloc;

	new_node = kmalloc(sizeof(struct mpath_node), GFP_KERNEL);
	if (!new_node)
		goto err_node_alloc;

	read_lock(&pathtbl_resize_lock);
	memcpy(new_mpath->dst, dst, ETH_ALEN);
	memcpy(new_mpath->mpp, mpp, ETH_ALEN);
	new_mpath->sdata = sdata;
	new_mpath->flags = 0;
	skb_queue_head_init(&new_mpath->frame_queue);
	new_node->mpath = new_mpath;
	new_mpath->exp_time = jiffies;
	spin_lock_init(&new_mpath->state_lock);

	hash_idx = mesh_table_hash(dst, sdata, mpp_paths);
	bucket = &mpp_paths->hash_buckets[hash_idx];

	spin_lock(&mpp_paths->hashwlock[hash_idx]);

	err = -EEXIST;
	hlist_for_each_entry(node, n, bucket, list) {
		mpath = node->mpath;
		if (mpath->sdata == sdata && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
			goto err_exists;
	}

	hlist_add_head_rcu(&new_node->list, bucket);
	if (atomic_inc_return(&mpp_paths->entries) >=
		mpp_paths->mean_chain_len * (mpp_paths->hash_mask + 1))
		grow = 1;

	spin_unlock(&mpp_paths->hashwlock[hash_idx]);
	read_unlock(&pathtbl_resize_lock);
	if (grow) {
		struct mesh_table *oldtbl, *newtbl;

		write_lock(&pathtbl_resize_lock);
		oldtbl = mpp_paths;
		newtbl = mesh_table_grow(mpp_paths);
		if (!newtbl) {
			write_unlock(&pathtbl_resize_lock);
			return 0;
		}
		rcu_assign_pointer(mpp_paths, newtbl);
		write_unlock(&pathtbl_resize_lock);

		synchronize_rcu();
		mesh_table_free(oldtbl, false);
	}
	return 0;

err_exists:
	spin_unlock(&mpp_paths->hashwlock[hash_idx]);
	read_unlock(&pathtbl_resize_lock);
	kfree(new_node);
err_node_alloc:
	kfree(new_mpath);
err_path_alloc:
	return err;
}


/**
 * mesh_plink_broken - deactivates paths and sends perr when a link breaks
 *
 * @sta: broken peer link
 *
 * This function must be called from the rate control algorithm if enough
 * delivery errors suggest that a peer link is no longer usable.
 */
void mesh_plink_broken(struct sta_info *sta)
{
	struct mesh_path *mpath;
	struct mpath_node *node;
	struct hlist_node *p;
	struct ieee80211_sub_if_data *sdata = sta->sdata;
	int i;

	rcu_read_lock();
	for_each_mesh_entry(mesh_paths, p, node, i) {
		mpath = node->mpath;
		spin_lock_bh(&mpath->state_lock);
		if (mpath->next_hop == sta &&
		    mpath->flags & MESH_PATH_ACTIVE &&
		    !(mpath->flags & MESH_PATH_FIXED)) {
			mpath->flags &= ~MESH_PATH_ACTIVE;
			++mpath->dsn;
			spin_unlock_bh(&mpath->state_lock);
			mesh_path_error_tx(mpath->dst,
					cpu_to_le32(mpath->dsn),
					sdata->dev->broadcast, sdata);
		} else
		spin_unlock_bh(&mpath->state_lock);
	}
	rcu_read_unlock();
}

/**
 * mesh_path_flush_by_nexthop - Deletes mesh paths if their next hop matches
 *
 * @sta - mesh peer to match
 *
 * RCU notes: this function is called when a mesh plink transitions from
 * PLINK_ESTAB to any other state, since PLINK_ESTAB state is the only one that
 * allows path creation. This will happen before the sta can be freed (because
 * sta_info_destroy() calls this) so any reader in a rcu read block will be
 * protected against the plink disappearing.
 */
void mesh_path_flush_by_nexthop(struct sta_info *sta)
{
	struct mesh_path *mpath;
	struct mpath_node *node;
	struct hlist_node *p;
	int i;

	for_each_mesh_entry(mesh_paths, p, node, i) {
		mpath = node->mpath;
		if (mpath->next_hop == sta)
			mesh_path_del(mpath->dst, mpath->sdata);
	}
}

void mesh_path_flush(struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath;
	struct mpath_node *node;
	struct hlist_node *p;
	int i;

	for_each_mesh_entry(mesh_paths, p, node, i) {
		mpath = node->mpath;
		if (mpath->sdata == sdata)
			mesh_path_del(mpath->dst, mpath->sdata);
	}
}

static void mesh_path_node_reclaim(struct rcu_head *rp)
{
	struct mpath_node *node = container_of(rp, struct mpath_node, rcu);
	struct ieee80211_sub_if_data *sdata = node->mpath->sdata;

	del_timer_sync(&node->mpath->timer);
	atomic_dec(&sdata->u.mesh.mpaths);
	kfree(node->mpath);
	kfree(node);
}

/**
 * mesh_path_del - delete a mesh path from the table
 *
 * @addr: dst address (ETH_ALEN length)
 * @sdata: local subif
 *
 * Returns: 0 if succesful
 */
int mesh_path_del(u8 *addr, struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath;
	struct mpath_node *node;
	struct hlist_head *bucket;
	struct hlist_node *n;
	int hash_idx;
	int err = 0;

	read_lock(&pathtbl_resize_lock);
	hash_idx = mesh_table_hash(addr, sdata, mesh_paths);
	bucket = &mesh_paths->hash_buckets[hash_idx];

	spin_lock(&mesh_paths->hashwlock[hash_idx]);
	hlist_for_each_entry(node, n, bucket, list) {
		mpath = node->mpath;
		if (mpath->sdata == sdata &&
				memcmp(addr, mpath->dst, ETH_ALEN) == 0) {
			spin_lock_bh(&mpath->state_lock);
			mpath->flags |= MESH_PATH_RESOLVING;
			hlist_del_rcu(&node->list);
			call_rcu(&node->rcu, mesh_path_node_reclaim);
			atomic_dec(&mesh_paths->entries);
			spin_unlock_bh(&mpath->state_lock);
			goto enddel;
		}
	}

	err = -ENXIO;
enddel:
	spin_unlock(&mesh_paths->hashwlock[hash_idx]);
	read_unlock(&pathtbl_resize_lock);
	return err;
}

/**
 * mesh_path_tx_pending - sends pending frames in a mesh path queue
 *
 * @mpath: mesh path to activate
 *
 * Locking: the state_lock of the mpath structure must NOT be held when calling
 * this function.
 */
void mesh_path_tx_pending(struct mesh_path *mpath)
{
	struct sk_buff *skb;

	while ((skb = skb_dequeue(&mpath->frame_queue)) &&
			(mpath->flags & MESH_PATH_ACTIVE))
		dev_queue_xmit(skb);
}

/**
 * mesh_path_discard_frame - discard a frame whose path could not be resolved
 *
 * @skb: frame to discard
 * @sdata: network subif the frame was to be sent through
 *
 * If the frame was being forwarded from another MP, a PERR frame will be sent
 * to the precursor.  The precursor's address (i.e. the previous hop) was saved
 * in addr1 of the frame-to-be-forwarded, and would only be overwritten once
 * the destination is successfully resolved.
 *
 * Locking: the function must me called within a rcu_read_lock region
 */
void mesh_path_discard_frame(struct sk_buff *skb,
			     struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
	struct mesh_path *mpath;
	u32 dsn = 0;

	if (memcmp(hdr->addr4, sdata->dev->dev_addr, ETH_ALEN) != 0) {
		u8 *ra, *da;

		da = hdr->addr3;
		ra = hdr->addr1;
		mpath = mesh_path_lookup(da, sdata);
		if (mpath)
			dsn = ++mpath->dsn;
		mesh_path_error_tx(skb->data, cpu_to_le32(dsn), ra, sdata);
	}

	kfree_skb(skb);
	sdata->u.mesh.mshstats.dropped_frames_no_route++;
}

/**
 * mesh_path_flush_pending - free the pending queue of a mesh path
 *
 * @mpath: mesh path whose queue has to be freed
 *
 * Locking: the function must me called withing a rcu_read_lock region
 */
void mesh_path_flush_pending(struct mesh_path *mpath)
{
	struct sk_buff *skb;

	while ((skb = skb_dequeue(&mpath->frame_queue)) &&
			(mpath->flags & MESH_PATH_ACTIVE))
		mesh_path_discard_frame(skb, mpath->sdata);
}

/**
 * mesh_path_fix_nexthop - force a specific next hop for a mesh path
 *
 * @mpath: the mesh path to modify
 * @next_hop: the next hop to force
 *
 * Locking: this function must be called holding mpath->state_lock
 */
void mesh_path_fix_nexthop(struct mesh_path *mpath, struct sta_info *next_hop)
{
	spin_lock_bh(&mpath->state_lock);
	mesh_path_assign_nexthop(mpath, next_hop);
	mpath->dsn = 0xffff;
	mpath->metric = 0;
	mpath->hop_count = 0;
	mpath->exp_time = 0;
	mpath->flags |= MESH_PATH_FIXED;
	mesh_path_activate(mpath);
	spin_unlock_bh(&mpath->state_lock);
	mesh_path_tx_pending(mpath);
}

static void mesh_path_node_free(struct hlist_node *p, bool free_leafs)
{
	struct mesh_path *mpath;
	struct mpath_node *node = hlist_entry(p, struct mpath_node, list);
	mpath = node->mpath;
	hlist_del_rcu(p);
	if (free_leafs)
		kfree(mpath);
	kfree(node);
}

static int mesh_path_node_copy(struct hlist_node *p, struct mesh_table *newtbl)
{
	struct mesh_path *mpath;
	struct mpath_node *node, *new_node;
	u32 hash_idx;

	new_node = kmalloc(sizeof(struct mpath_node), GFP_ATOMIC);
	if (new_node == NULL)
		return -ENOMEM;

	node = hlist_entry(p, struct mpath_node, list);
	mpath = node->mpath;
	new_node->mpath = mpath;
	hash_idx = mesh_table_hash(mpath->dst, mpath->sdata, newtbl);
	hlist_add_head(&new_node->list,
			&newtbl->hash_buckets[hash_idx]);
	return 0;
}

int mesh_pathtbl_init(void)
{
	mesh_paths = mesh_table_alloc(INIT_PATHS_SIZE_ORDER);
	if (!mesh_paths)
		return -ENOMEM;
	mesh_paths->free_node = &mesh_path_node_free;
	mesh_paths->copy_node = &mesh_path_node_copy;
	mesh_paths->mean_chain_len = MEAN_CHAIN_LEN;

	mpp_paths = mesh_table_alloc(INIT_PATHS_SIZE_ORDER);
	if (!mpp_paths) {
		mesh_table_free(mesh_paths, true);
		return -ENOMEM;
	}
	mpp_paths->free_node = &mesh_path_node_free;
	mpp_paths->copy_node = &mesh_path_node_copy;
	mpp_paths->mean_chain_len = MEAN_CHAIN_LEN;

	return 0;
}

void mesh_path_expire(struct ieee80211_sub_if_data *sdata)
{
	struct mesh_path *mpath;
	struct mpath_node *node;
	struct hlist_node *p;
	int i;

	read_lock(&pathtbl_resize_lock);
	for_each_mesh_entry(mesh_paths, p, node, i) {
		if (node->mpath->sdata != sdata)
			continue;
		mpath = node->mpath;
		spin_lock_bh(&mpath->state_lock);
		if ((!(mpath->flags & MESH_PATH_RESOLVING)) &&
		    (!(mpath->flags & MESH_PATH_FIXED)) &&
			time_after(jiffies,
			 mpath->exp_time + MESH_PATH_EXPIRE)) {
			spin_unlock_bh(&mpath->state_lock);
			mesh_path_del(mpath->dst, mpath->sdata);
		} else
			spin_unlock_bh(&mpath->state_lock);
	}
	read_unlock(&pathtbl_resize_lock);
}

void mesh_pathtbl_unregister(void)
{
	mesh_table_free(mesh_paths, true);
	mesh_table_free(mpp_paths, true);
}
Commit	Line	Data
eb2b9311 LCC	1	/*
	2	* Copyright (c) 2008 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>
eb2b9311 LCC	12	#include <linux/random.h>
	13	#include <linux/spinlock.h>
	14	#include <linux/string.h>
	15	#include <net/mac80211.h>
	16	#include "ieee80211_i.h"
	17	#include "mesh.h"
	18
	19	/* There will be initially 2^INIT_PATHS_SIZE_ORDER buckets */
	20	#define INIT_PATHS_SIZE_ORDER 2
	21
	22	/* Keep the mean chain length below this constant */
	23	#define MEAN_CHAIN_LEN 2
	24
	25	#define MPATH_EXPIRED(mpath) ((mpath->flags & MESH_PATH_ACTIVE) && \
	26	time_after(jiffies, mpath->exp_time) && \
	27	!(mpath->flags & MESH_PATH_FIXED))
	28
	29	struct mpath_node {
	30	struct hlist_node list;
	31	struct rcu_head rcu;
	32	/* This indirection allows two different tables to point to the same
	33	* mesh_path structure, useful when resizing
	34	*/
	35	struct mesh_path *mpath;
	36	};
	37
	38	static struct mesh_table *mesh_paths;
79617dee	39	static struct mesh_table mpp_paths; / Store paths for MPP&MAP */
eb2b9311 LCC	40
	41	/* This lock will have the grow table function as writer and add / delete nodes
	42	* as readers. When reading the table (i.e. doing lookups) we are well protected
	43	* by RCU
	44	*/
	45	static DEFINE_RWLOCK(pathtbl_resize_lock);
	46
	47	/**
	48	*
	49	* mesh_path_assign_nexthop - update mesh path next hop
	50	*
	51	* @mpath: mesh path to update
	52	* @sta: next hop to assign
	53	*
	54	* Locking: mpath->state_lock must be held when calling this function
	55	*/
	56	void mesh_path_assign_nexthop(struct mesh_path mpath, struct sta_info sta)
	57	{
d0709a65	58	rcu_assign_pointer(mpath->next_hop, sta);
eb2b9311 LCC	59	}
	60
	61
	62	/**
	63	* mesh_path_lookup - look up a path in the mesh path table
	64	* @dst: hardware address (ETH_ALEN length) of destination
f698d856	65	* @sdata: local subif
eb2b9311 LCC	66	*
	67	* Returns: pointer to the mesh path structure, or NULL if not found
	68	*
	69	* Locking: must be called within a read rcu section.
	70	*/
f698d856	71	struct mesh_path mesh_path_lookup(u8 dst, struct ieee80211_sub_if_data *sdata)
eb2b9311 LCC	72	{
	73	struct mesh_path *mpath;
	74	struct hlist_node *n;
	75	struct hlist_head *bucket;
	76	struct mesh_table *tbl;
	77	struct mpath_node *node;
	78
	79	tbl = rcu_dereference(mesh_paths);
	80
f698d856	81	bucket = &tbl->hash_buckets[mesh_table_hash(dst, sdata, tbl)];
eb2b9311 LCC	82	hlist_for_each_entry_rcu(node, n, bucket, list) {
eb2b9311 LCC	83	mpath = node->mpath;
f698d856	84	if (mpath->sdata == sdata &&
eb2b9311 LCC	85	memcmp(dst, mpath->dst, ETH_ALEN) == 0) {
	86	if (MPATH_EXPIRED(mpath)) {
	87	spin_lock_bh(&mpath->state_lock);
	88	if (MPATH_EXPIRED(mpath))
	89	mpath->flags &= ~MESH_PATH_ACTIVE;
	90	spin_unlock_bh(&mpath->state_lock);
	91	}
	92	return mpath;
	93	}
	94	}
	95	return NULL;
	96	}
	97
79617dee Y	98	struct mesh_path mpp_path_lookup(u8 dst, struct ieee80211_sub_if_data *sdata)
	99	{
	100	struct mesh_path *mpath;
	101	struct hlist_node *n;
	102	struct hlist_head *bucket;
	103	struct mesh_table *tbl;
	104	struct mpath_node *node;
	105
	106	tbl = rcu_dereference(mpp_paths);
	107
	108	bucket = &tbl->hash_buckets[mesh_table_hash(dst, sdata, tbl)];
	109	hlist_for_each_entry_rcu(node, n, bucket, list) {
	110	mpath = node->mpath;
	111	if (mpath->sdata == sdata &&
	112	memcmp(dst, mpath->dst, ETH_ALEN) == 0) {
	113	if (MPATH_EXPIRED(mpath)) {
	114	spin_lock_bh(&mpath->state_lock);
	115	if (MPATH_EXPIRED(mpath))
	116	mpath->flags &= ~MESH_PATH_ACTIVE;
	117	spin_unlock_bh(&mpath->state_lock);
	118	}
	119	return mpath;
	120	}
	121	}
	122	return NULL;
	123	}
	124
	125
eb2b9311 LCC	126	/**
	127	* mesh_path_lookup_by_idx - look up a path in the mesh path table by its index
	128	* @idx: index
f698d856	129	* @sdata: local subif, or NULL for all entries
eb2b9311 LCC	130	*
	131	* Returns: pointer to the mesh path structure, or NULL if not found.
	132	*
	133	* Locking: must be called within a read rcu section.
	134	*/
f698d856	135	struct mesh_path mesh_path_lookup_by_idx(int idx, struct ieee80211_sub_if_data sdata)
eb2b9311 LCC	136	{
	137	struct mpath_node *node;
	138	struct hlist_node *p;
	139	int i;
	140	int j = 0;
	141
2a8ca29a	142	for_each_mesh_entry(mesh_paths, p, node, i) {
f698d856	143	if (sdata && node->mpath->sdata != sdata)
2a8ca29a	144	continue;
eb2b9311 LCC	145	if (j++ == idx) {
	146	if (MPATH_EXPIRED(node->mpath)) {
	147	spin_lock_bh(&node->mpath->state_lock);
	148	if (MPATH_EXPIRED(node->mpath))
	149	node->mpath->flags &= ~MESH_PATH_ACTIVE;
	150	spin_unlock_bh(&node->mpath->state_lock);
	151	}
	152	return node->mpath;
	153	}
2a8ca29a	154	}
eb2b9311 LCC	155
	156	return NULL;
	157	}
	158
	159	/**
	160	* mesh_path_add - allocate and add a new path to the mesh path table
	161	* @addr: destination address of the path (ETH_ALEN length)
f698d856	162	* @sdata: local subif
eb2b9311 LCC	163	*
	164	* Returns: 0 on sucess
	165	*
	166	* State: the initial state of the new path is set to 0
	167	*/
f698d856	168	int mesh_path_add(u8 dst, struct ieee80211_sub_if_data sdata)
eb2b9311	169	{
eb2b9311 LCC	170	struct mesh_path mpath, new_mpath;
	171	struct mpath_node node, new_node;
	172	struct hlist_head *bucket;
	173	struct hlist_node *n;
	174	int grow = 0;
	175	int err = 0;
	176	u32 hash_idx;
	177
e2e414d9 JB	178	might_sleep();
e2e414d9 JB	179
f698d856	180	if (memcmp(dst, sdata->dev->dev_addr, ETH_ALEN) == 0)
eb2b9311 LCC	181	/* never add ourselves as neighbours */
	182	return -ENOTSUPP;
	183
	184	if (is_multicast_ether_addr(dst))
	185	return -ENOTSUPP;
	186
472dbc45	187	if (atomic_add_unless(&sdata->u.mesh.mpaths, 1, MESH_MAX_MPATHS) == 0)
eb2b9311 LCC	188	return -ENOSPC;
eb2b9311 LCC	189
402d7752	190	err = -ENOMEM;
eb2b9311	191	new_mpath = kzalloc(sizeof(struct mesh_path), GFP_KERNEL);
402d7752 PE	192	if (!new_mpath)
	193	goto err_path_alloc;
	194
0eb03d5a	195	new_node = kmalloc(sizeof(struct mpath_node), GFP_KERNEL);
402d7752 PE	196	if (!new_node)
402d7752 PE	197	goto err_node_alloc;
f84e71a9 PE	198
f84e71a9 PE	199	read_lock(&pathtbl_resize_lock);
eb2b9311	200	memcpy(new_mpath->dst, dst, ETH_ALEN);
f698d856	201	new_mpath->sdata = sdata;
eb2b9311 LCC	202	new_mpath->flags = 0;
eb2b9311 LCC	203	skb_queue_head_init(&new_mpath->frame_queue);
eb2b9311 LCC	204	new_node->mpath = new_mpath;
	205	new_mpath->timer.data = (unsigned long) new_mpath;
	206	new_mpath->timer.function = mesh_path_timer;
	207	new_mpath->exp_time = jiffies;
	208	spin_lock_init(&new_mpath->state_lock);
	209	init_timer(&new_mpath->timer);
	210
f698d856	211	hash_idx = mesh_table_hash(dst, sdata, mesh_paths);
eb2b9311 LCC	212	bucket = &mesh_paths->hash_buckets[hash_idx];
	213
	214	spin_lock(&mesh_paths->hashwlock[hash_idx]);
	215
402d7752	216	err = -EEXIST;
eb2b9311 LCC	217	hlist_for_each_entry(node, n, bucket, list) {
eb2b9311 LCC	218	mpath = node->mpath;
f698d856	219	if (mpath->sdata == sdata && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
402d7752	220	goto err_exists;
eb2b9311 LCC	221	}
	222
	223	hlist_add_head_rcu(&new_node->list, bucket);
	224	if (atomic_inc_return(&mesh_paths->entries) >=
	225	mesh_paths->mean_chain_len * (mesh_paths->hash_mask + 1))
	226	grow = 1;
	227
eb2b9311	228	spin_unlock(&mesh_paths->hashwlock[hash_idx]);
eb2b9311	229	read_unlock(&pathtbl_resize_lock);
402d7752	230	if (grow) {
eb2b9311 LCC	231	struct mesh_table oldtbl, newtbl;
	232
	233	write_lock(&pathtbl_resize_lock);
	234	oldtbl = mesh_paths;
	235	newtbl = mesh_table_grow(mesh_paths);
	236	if (!newtbl) {
	237	write_unlock(&pathtbl_resize_lock);
3282aea9	238	return 0;
eb2b9311 LCC	239	}
eb2b9311 LCC	240	rcu_assign_pointer(mesh_paths, newtbl);
6d6936e2 PE	241	write_unlock(&pathtbl_resize_lock);
6d6936e2 PE	242
eb2b9311 LCC	243	synchronize_rcu();
eb2b9311 LCC	244	mesh_table_free(oldtbl, false);
eb2b9311	245	}
402d7752 PE	246	return 0;
	247
	248	err_exists:
	249	spin_unlock(&mesh_paths->hashwlock[hash_idx]);
	250	read_unlock(&pathtbl_resize_lock);
	251	kfree(new_node);
	252	err_node_alloc:
	253	kfree(new_mpath);
	254	err_path_alloc:
472dbc45	255	atomic_dec(&sdata->u.mesh.mpaths);
eb2b9311 LCC	256	return err;
	257	}
	258
	259
79617dee Y	260	int mpp_path_add(u8 dst, u8 mpp, struct ieee80211_sub_if_data *sdata)
	261	{
	262	struct mesh_path mpath, new_mpath;
	263	struct mpath_node node, new_node;
	264	struct hlist_head *bucket;
	265	struct hlist_node *n;
	266	int grow = 0;
	267	int err = 0;
	268	u32 hash_idx;
	269
e2e414d9	270	might_sleep();
79617dee Y	271
	272	if (memcmp(dst, sdata->dev->dev_addr, ETH_ALEN) == 0)
	273	/* never add ourselves as neighbours */
	274	return -ENOTSUPP;
	275
	276	if (is_multicast_ether_addr(dst))
	277	return -ENOTSUPP;
	278
	279	err = -ENOMEM;
	280	new_mpath = kzalloc(sizeof(struct mesh_path), GFP_KERNEL);
	281	if (!new_mpath)
	282	goto err_path_alloc;
	283
	284	new_node = kmalloc(sizeof(struct mpath_node), GFP_KERNEL);
	285	if (!new_node)
	286	goto err_node_alloc;
	287
	288	read_lock(&pathtbl_resize_lock);
	289	memcpy(new_mpath->dst, dst, ETH_ALEN);
	290	memcpy(new_mpath->mpp, mpp, ETH_ALEN);
	291	new_mpath->sdata = sdata;
	292	new_mpath->flags = 0;
	293	skb_queue_head_init(&new_mpath->frame_queue);
	294	new_node->mpath = new_mpath;
	295	new_mpath->exp_time = jiffies;
	296	spin_lock_init(&new_mpath->state_lock);
	297
	298	hash_idx = mesh_table_hash(dst, sdata, mpp_paths);
	299	bucket = &mpp_paths->hash_buckets[hash_idx];
	300
	301	spin_lock(&mpp_paths->hashwlock[hash_idx]);
	302
	303	err = -EEXIST;
	304	hlist_for_each_entry(node, n, bucket, list) {
	305	mpath = node->mpath;
	306	if (mpath->sdata == sdata && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
	307	goto err_exists;
	308	}
	309
	310	hlist_add_head_rcu(&new_node->list, bucket);
	311	if (atomic_inc_return(&mpp_paths->entries) >=
	312	mpp_paths->mean_chain_len * (mpp_paths->hash_mask + 1))
	313	grow = 1;
	314
	315	spin_unlock(&mpp_paths->hashwlock[hash_idx]);
	316	read_unlock(&pathtbl_resize_lock);
	317	if (grow) {
	318	struct mesh_table oldtbl, newtbl;
	319
	320	write_lock(&pathtbl_resize_lock);
	321	oldtbl = mpp_paths;
	322	newtbl = mesh_table_grow(mpp_paths);
	323	if (!newtbl) {
	324	write_unlock(&pathtbl_resize_lock);
	325	return 0;
	326	}
	327	rcu_assign_pointer(mpp_paths, newtbl);
	328	write_unlock(&pathtbl_resize_lock);
	329
	330	synchronize_rcu();
	331	mesh_table_free(oldtbl, false);
	332	}
	333	return 0;
	334
335	err_exists:
336	spin_unlock(&mpp_paths->hashwlock[hash_idx]);
337	read_unlock(&pathtbl_resize_lock);
338	kfree(new_node);
339	err_node_alloc:
340	kfree(new_mpath);
341	err_path_alloc:
342	return err;
343	}
344
345
eb2b9311 LCC	346	/**
	347	* mesh_plink_broken - deactivates paths and sends perr when a link breaks
	348	*
	349	* @sta: broken peer link
	350	*
	351	* This function must be called from the rate control algorithm if enough
	352	* delivery errors suggest that a peer link is no longer usable.
	353	*/
	354	void mesh_plink_broken(struct sta_info *sta)
	355	{
	356	struct mesh_path *mpath;
	357	struct mpath_node *node;
	358	struct hlist_node *p;
f698d856	359	struct ieee80211_sub_if_data *sdata = sta->sdata;
eb2b9311 LCC	360	int i;
	361
	362	rcu_read_lock();
	363	for_each_mesh_entry(mesh_paths, p, node, i) {
	364	mpath = node->mpath;
	365	spin_lock_bh(&mpath->state_lock);
	366	if (mpath->next_hop == sta &&
	367	mpath->flags & MESH_PATH_ACTIVE &&
	368	!(mpath->flags & MESH_PATH_FIXED)) {
	369	mpath->flags &= ~MESH_PATH_ACTIVE;
	370	++mpath->dsn;
	371	spin_unlock_bh(&mpath->state_lock);
	372	mesh_path_error_tx(mpath->dst,
	373	cpu_to_le32(mpath->dsn),
f698d856	374	sdata->dev->broadcast, sdata);
eb2b9311 LCC	375	} else
	376	spin_unlock_bh(&mpath->state_lock);
	377	}
	378	rcu_read_unlock();
	379	}
	380
	381	/**
	382	* mesh_path_flush_by_nexthop - Deletes mesh paths if their next hop matches
	383	*
	384	* @sta - mesh peer to match
	385	*
b4e08ea1 LCC	386	* RCU notes: this function is called when a mesh plink transitions from
	387	* PLINK_ESTAB to any other state, since PLINK_ESTAB state is the only one that
	388	* allows path creation. This will happen before the sta can be freed (because
d0709a65 JB	389	* sta_info_destroy() calls this) so any reader in a rcu read block will be
d0709a65 JB	390	* protected against the plink disappearing.
eb2b9311 LCC	391	*/
	392	void mesh_path_flush_by_nexthop(struct sta_info *sta)
	393	{
	394	struct mesh_path *mpath;
	395	struct mpath_node *node;
	396	struct hlist_node *p;
	397	int i;
	398
	399	for_each_mesh_entry(mesh_paths, p, node, i) {
	400	mpath = node->mpath;
	401	if (mpath->next_hop == sta)
f698d856	402	mesh_path_del(mpath->dst, mpath->sdata);
eb2b9311 LCC	403	}
	404	}
	405
f698d856	406	void mesh_path_flush(struct ieee80211_sub_if_data *sdata)
eb2b9311 LCC	407	{
	408	struct mesh_path *mpath;
	409	struct mpath_node *node;
	410	struct hlist_node *p;
	411	int i;
	412
	413	for_each_mesh_entry(mesh_paths, p, node, i) {
	414	mpath = node->mpath;
f698d856 JBG	415	if (mpath->sdata == sdata)
f698d856 JBG	416	mesh_path_del(mpath->dst, mpath->sdata);
eb2b9311 LCC	417	}
	418	}
	419
	420	static void mesh_path_node_reclaim(struct rcu_head *rp)
	421	{
	422	struct mpath_node *node = container_of(rp, struct mpath_node, rcu);
f698d856	423	struct ieee80211_sub_if_data *sdata = node->mpath->sdata;
d0709a65	424
89a1ad69	425	del_timer_sync(&node->mpath->timer);
472dbc45	426	atomic_dec(&sdata->u.mesh.mpaths);
eb2b9311 LCC	427	kfree(node->mpath);
	428	kfree(node);
	429	}
	430
	431	/**
	432	* mesh_path_del - delete a mesh path from the table
	433	*
	434	* @addr: dst address (ETH_ALEN length)
f698d856	435	* @sdata: local subif
eb2b9311 LCC	436	*
eb2b9311 LCC	437	* Returns: 0 if succesful
eb2b9311	438	*/
f698d856	439	int mesh_path_del(u8 addr, struct ieee80211_sub_if_data sdata)
eb2b9311 LCC	440	{
	441	struct mesh_path *mpath;
	442	struct mpath_node *node;
	443	struct hlist_head *bucket;
	444	struct hlist_node *n;
	445	int hash_idx;
	446	int err = 0;
	447
	448	read_lock(&pathtbl_resize_lock);
f698d856	449	hash_idx = mesh_table_hash(addr, sdata, mesh_paths);
eb2b9311 LCC	450	bucket = &mesh_paths->hash_buckets[hash_idx];
	451
	452	spin_lock(&mesh_paths->hashwlock[hash_idx]);
	453	hlist_for_each_entry(node, n, bucket, list) {
	454	mpath = node->mpath;
f698d856	455	if (mpath->sdata == sdata &&
eb2b9311 LCC	456	memcmp(addr, mpath->dst, ETH_ALEN) == 0) {
eb2b9311 LCC	457	spin_lock_bh(&mpath->state_lock);
cfa22c71 LCC	458	mpath->flags \|= MESH_PATH_RESOLVING;
	459	hlist_del_rcu(&node->list);
	460	call_rcu(&node->rcu, mesh_path_node_reclaim);
	461	atomic_dec(&mesh_paths->entries);
eb2b9311 LCC	462	spin_unlock_bh(&mpath->state_lock);
	463	goto enddel;
	464	}
	465	}
	466
	467	err = -ENXIO;
	468	enddel:
	469	spin_unlock(&mesh_paths->hashwlock[hash_idx]);
	470	read_unlock(&pathtbl_resize_lock);
	471	return err;
	472	}
	473
	474	/**
	475	* mesh_path_tx_pending - sends pending frames in a mesh path queue
	476	*
	477	* @mpath: mesh path to activate
	478	*
	479	* Locking: the state_lock of the mpath structure must NOT be held when calling
	480	* this function.
	481	*/
	482	void mesh_path_tx_pending(struct mesh_path *mpath)
	483	{
	484	struct sk_buff *skb;
	485
	486	while ((skb = skb_dequeue(&mpath->frame_queue)) &&
	487	(mpath->flags & MESH_PATH_ACTIVE))
	488	dev_queue_xmit(skb);
	489	}
	490
	491	/**
	492	* mesh_path_discard_frame - discard a frame whose path could not be resolved
	493	*
	494	* @skb: frame to discard
f698d856	495	* @sdata: network subif the frame was to be sent through
eb2b9311	496	*
35946a57 JC	497	* If the frame was being forwarded from another MP, a PERR frame will be sent
	498	* to the precursor. The precursor's address (i.e. the previous hop) was saved
	499	* in addr1 of the frame-to-be-forwarded, and would only be overwritten once
	500	* the destination is successfully resolved.
eb2b9311 LCC	501	*
	502	* Locking: the function must me called within a rcu_read_lock region
	503	*/
f698d856 JBG	504	void mesh_path_discard_frame(struct sk_buff *skb,
f698d856 JBG	505	struct ieee80211_sub_if_data *sdata)
eb2b9311	506	{
e32f85f7	507	struct ieee80211_hdr hdr = (struct ieee80211_hdr ) skb->data;
eb2b9311 LCC	508	struct mesh_path *mpath;
	509	u32 dsn = 0;
	510
f698d856	511	if (memcmp(hdr->addr4, sdata->dev->dev_addr, ETH_ALEN) != 0) {
eb2b9311 LCC	512	u8 ra, da;
eb2b9311 LCC	513
e32f85f7	514	da = hdr->addr3;
35946a57	515	ra = hdr->addr1;
f698d856	516	mpath = mesh_path_lookup(da, sdata);
eb2b9311 LCC	517	if (mpath)
eb2b9311 LCC	518	dsn = ++mpath->dsn;
f698d856	519	mesh_path_error_tx(skb->data, cpu_to_le32(dsn), ra, sdata);
eb2b9311 LCC	520	}
	521
	522	kfree_skb(skb);
472dbc45	523	sdata->u.mesh.mshstats.dropped_frames_no_route++;
eb2b9311 LCC	524	}
	525
	526	/**
	527	* mesh_path_flush_pending - free the pending queue of a mesh path
	528	*
	529	* @mpath: mesh path whose queue has to be freed
	530	*
	531	* Locking: the function must me called withing a rcu_read_lock region
	532	*/
	533	void mesh_path_flush_pending(struct mesh_path *mpath)
	534	{
eb2b9311 LCC	535	struct sk_buff *skb;
eb2b9311 LCC	536
eb2b9311 LCC	537	while ((skb = skb_dequeue(&mpath->frame_queue)) &&
eb2b9311 LCC	538	(mpath->flags & MESH_PATH_ACTIVE))
f698d856	539	mesh_path_discard_frame(skb, mpath->sdata);
eb2b9311 LCC	540	}
	541
	542	/**
	543	* mesh_path_fix_nexthop - force a specific next hop for a mesh path
	544	*
	545	* @mpath: the mesh path to modify
	546	* @next_hop: the next hop to force
	547	*
	548	* Locking: this function must be called holding mpath->state_lock
	549	*/
	550	void mesh_path_fix_nexthop(struct mesh_path mpath, struct sta_info next_hop)
	551	{
	552	spin_lock_bh(&mpath->state_lock);
	553	mesh_path_assign_nexthop(mpath, next_hop);
	554	mpath->dsn = 0xffff;
	555	mpath->metric = 0;
	556	mpath->hop_count = 0;
	557	mpath->exp_time = 0;
	558	mpath->flags \|= MESH_PATH_FIXED;
	559	mesh_path_activate(mpath);
	560	spin_unlock_bh(&mpath->state_lock);
	561	mesh_path_tx_pending(mpath);
	562	}
	563
	564	static void mesh_path_node_free(struct hlist_node *p, bool free_leafs)
	565	{
	566	struct mesh_path *mpath;
	567	struct mpath_node *node = hlist_entry(p, struct mpath_node, list);
	568	mpath = node->mpath;
	569	hlist_del_rcu(p);
eb2b9311 LCC	570	if (free_leafs)
	571	kfree(mpath);
	572	kfree(node);
	573	}
	574
4caf86c6	575	static int mesh_path_node_copy(struct hlist_node p, struct mesh_table newtbl)
eb2b9311 LCC	576	{
	577	struct mesh_path *mpath;
	578	struct mpath_node node, new_node;
	579	u32 hash_idx;
	580
8566dc3f	581	new_node = kmalloc(sizeof(struct mpath_node), GFP_ATOMIC);
00242c40 PE	582	if (new_node == NULL)
	583	return -ENOMEM;
	584
eb2b9311 LCC	585	node = hlist_entry(p, struct mpath_node, list);
eb2b9311 LCC	586	mpath = node->mpath;
eb2b9311	587	new_node->mpath = mpath;
f698d856	588	hash_idx = mesh_table_hash(mpath->dst, mpath->sdata, newtbl);
eb2b9311 LCC	589	hlist_add_head(&new_node->list,
eb2b9311 LCC	590	&newtbl->hash_buckets[hash_idx]);
4caf86c6	591	return 0;
eb2b9311 LCC	592	}
	593
	594	int mesh_pathtbl_init(void)
	595	{
	596	mesh_paths = mesh_table_alloc(INIT_PATHS_SIZE_ORDER);
79617dee Y	597	if (!mesh_paths)
79617dee Y	598	return -ENOMEM;
eb2b9311 LCC	599	mesh_paths->free_node = &mesh_path_node_free;
	600	mesh_paths->copy_node = &mesh_path_node_copy;
	601	mesh_paths->mean_chain_len = MEAN_CHAIN_LEN;
79617dee Y	602
	603	mpp_paths = mesh_table_alloc(INIT_PATHS_SIZE_ORDER);
	604	if (!mpp_paths) {
	605	mesh_table_free(mesh_paths, true);
eb2b9311	606	return -ENOMEM;
79617dee Y	607	}
	608	mpp_paths->free_node = &mesh_path_node_free;
	609	mpp_paths->copy_node = &mesh_path_node_copy;
	610	mpp_paths->mean_chain_len = MEAN_CHAIN_LEN;
	611
eb2b9311 LCC	612	return 0;
	613	}
	614
f698d856	615	void mesh_path_expire(struct ieee80211_sub_if_data *sdata)
eb2b9311 LCC	616	{
	617	struct mesh_path *mpath;
	618	struct mpath_node *node;
	619	struct hlist_node *p;
	620	int i;
	621
	622	read_lock(&pathtbl_resize_lock);
	623	for_each_mesh_entry(mesh_paths, p, node, i) {
f698d856	624	if (node->mpath->sdata != sdata)
eb2b9311 LCC	625	continue;
	626	mpath = node->mpath;
	627	spin_lock_bh(&mpath->state_lock);
	628	if ((!(mpath->flags & MESH_PATH_RESOLVING)) &&
	629	(!(mpath->flags & MESH_PATH_FIXED)) &&
	630	time_after(jiffies,
	631	mpath->exp_time + MESH_PATH_EXPIRE)) {
	632	spin_unlock_bh(&mpath->state_lock);
f698d856	633	mesh_path_del(mpath->dst, mpath->sdata);
eb2b9311 LCC	634	} else
	635	spin_unlock_bh(&mpath->state_lock);
	636	}
	637	read_unlock(&pathtbl_resize_lock);
	638	}
	639
	640	void mesh_pathtbl_unregister(void)
	641	{
	642	mesh_table_free(mesh_paths, true);
79617dee	643	mesh_table_free(mpp_paths, true);
eb2b9311	644	}