mac80211: simplify key locking (ad0e2b5a) · Commits · e / devices / android_kernel_oneplus_sm7250

net/mac80211/cfg.c

+8 −10

Original line number	Original line	Diff line number	Diff line
	@@ -120,6 +120,9 @@ static int ieee80211_add_key(struct wiphy wiphy, struct net_device dev,
	struct ieee80211_key *key;		struct ieee80211_key *key;
	int err;		int err;

			if (!netif_running(dev))
			return -ENETDOWN;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	switch (params->cipher) {		switch (params->cipher) {
	@@ -145,7 +148,7 @@ static int ieee80211_add_key(struct wiphy wiphy, struct net_device dev,
	if (!key)		if (!key)
	return -ENOMEM;		return -ENOMEM;

	rcu_read_lock();		mutex_lock(&sdata->local->sta_mtx);

	if (mac_addr) {		if (mac_addr) {
	sta = sta_info_get_bss(sdata, mac_addr);		sta = sta_info_get_bss(sdata, mac_addr);
	@@ -160,7 +163,7 @@ static int ieee80211_add_key(struct wiphy wiphy, struct net_device dev,

	err = 0;		err = 0;
	out_unlock:		out_unlock:
	rcu_read_unlock();		mutex_unlock(&sdata->local->sta_mtx);

	return err;		return err;
	}		}
	@@ -174,7 +177,7 @@ static int ieee80211_del_key(struct wiphy wiphy, struct net_device dev,

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	rcu_read_lock();		mutex_lock(&sdata->local->sta_mtx);

	if (mac_addr) {		if (mac_addr) {
	ret = -ENOENT;		ret = -ENOENT;
	@@ -202,7 +205,7 @@ static int ieee80211_del_key(struct wiphy wiphy, struct net_device dev,

	ret = 0;		ret = 0;
	out_unlock:		out_unlock:
	rcu_read_unlock();		mutex_unlock(&sdata->local->sta_mtx);

	return ret;		return ret;
	}		}
	@@ -305,15 +308,10 @@ static int ieee80211_config_default_key(struct wiphy *wiphy,
	struct net_device *dev,		struct net_device *dev,
	u8 key_idx)		u8 key_idx)
	{		{
	struct ieee80211_sub_if_data *sdata;		struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	rcu_read_lock();

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	ieee80211_set_default_key(sdata, key_idx);		ieee80211_set_default_key(sdata, key_idx);

	rcu_read_unlock();

	return 0;		return 0;
	}		}

net/mac80211/ieee80211_i.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -746,10 +746,10 @@ struct ieee80211_local {
	struct mutex iflist_mtx;		struct mutex iflist_mtx;

	/*		/*
	* Key lock, protects sdata's key_list and sta_info's		* Key mutex, protects sdata's key_list and sta_info's
	* key pointers (write access, they're RCU.)		* key pointers (write access, they're RCU.)
	*/		*/
	spinlock_t key_lock;		struct mutex key_mtx;


	/* Scanning and BSS list */		/* Scanning and BSS list */

net/mac80211/iface.c

+2 −3

Original line number	Original line	Diff line number	Diff line
	@@ -268,7 +268,6 @@ static int ieee80211_open(struct net_device *dev)

	changed \|= ieee80211_reset_erp_info(sdata);		changed \|= ieee80211_reset_erp_info(sdata);
	ieee80211_bss_info_change_notify(sdata, changed);		ieee80211_bss_info_change_notify(sdata, changed);
	ieee80211_enable_keys(sdata);

	if (sdata->vif.type == NL80211_IFTYPE_STATION)		if (sdata->vif.type == NL80211_IFTYPE_STATION)
	netif_carrier_off(dev);		netif_carrier_off(dev);
	@@ -522,8 +521,8 @@ static int ieee80211_stop(struct net_device *dev)
	BSS_CHANGED_BEACON_ENABLED);		BSS_CHANGED_BEACON_ENABLED);
	}		}

	/* disable all keys for as long as this netdev is down */		/* free all remaining keys, there shouldn't be any */
	ieee80211_disable_keys(sdata);		ieee80211_free_keys(sdata);
	drv_remove_interface(local, &sdata->vif);		drv_remove_interface(local, &sdata->vif);
	}		}

net/mac80211/key.c

+66 −222

Original line number	Original line	Diff line number	Diff line
	@@ -36,80 +36,20 @@
	* There is currently no way of knowing this except by looking into		* There is currently no way of knowing this except by looking into
	* debugfs.		* debugfs.
	*		*
	* All key operations are protected internally so you can call them at		* All key operations are protected internally.
	* any time.
	*		*
	* Within mac80211, key references are, just as STA structure references,		* Within mac80211, key references are, just as STA structure references,
	* protected by RCU. Note, however, that some things are unprotected,		* protected by RCU. Note, however, that some things are unprotected,
	* namely the key->sta dereferences within the hardware acceleration		* namely the key->sta dereferences within the hardware acceleration
	* functions. This means that sta_info_destroy() must flush the key todo		* functions. This means that sta_info_destroy() must remove the key
	* list.		* which waits for an RCU grace period.
	*
	* All the direct key list manipulation functions must not sleep because
	* they can operate on STA info structs that are protected by RCU.
	*/		*/

	static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };		static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

	/* key mutex: used to synchronise todo runners */		static void assert_key_lock(struct ieee80211_local *local)
	static DEFINE_MUTEX(key_mutex);
	static DEFINE_SPINLOCK(todo_lock);
	static LIST_HEAD(todo_list);

	static void key_todo(struct work_struct *work)
	{
	ieee80211_key_todo();
	}

	static DECLARE_WORK(todo_work, key_todo);

	/**
	* add_todo - add todo item for a key
	*
	* @key: key to add to do item for
	* @flag: todo flag(s)
	*
	* Must be called with IRQs or softirqs disabled.
	*/
	static void add_todo(struct ieee80211_key *key, u32 flag)
	{
	if (!key)
	return;

	spin_lock(&todo_lock);
	key->flags \|= flag;
	/*
	* Remove again if already on the list so that we move it to the end.
	*/
	if (!list_empty(&key->todo))
	list_del(&key->todo);
	list_add_tail(&key->todo, &todo_list);
	schedule_work(&todo_work);
	spin_unlock(&todo_lock);
	}

	/**
	* ieee80211_key_lock - lock the mac80211 key operation lock
	*
	* This locks the (global) mac80211 key operation lock, all
	* key operations must be done under this lock.
	*/
	static void ieee80211_key_lock(void)
	{
	mutex_lock(&key_mutex);
	}

	/**
	* ieee80211_key_unlock - unlock the mac80211 key operation lock
	*/
	static void ieee80211_key_unlock(void)
	{
	mutex_unlock(&key_mutex);
	}

	static void assert_key_lock(void)
	{		{
	WARN_ON(!mutex_is_locked(&key_mutex));		WARN_ON(!mutex_is_locked(&local->key_mtx));
	}		}

	static struct ieee80211_sta get_sta_for_key(struct ieee80211_key key)		static struct ieee80211_sta get_sta_for_key(struct ieee80211_key key)
	@@ -126,12 +66,13 @@ static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
	struct ieee80211_sta *sta;		struct ieee80211_sta *sta;
	int ret;		int ret;

	assert_key_lock();
	might_sleep();		might_sleep();

	if (!key->local->ops->set_key)		if (!key->local->ops->set_key)
	return;		return;

			assert_key_lock(key->local);

	sta = get_sta_for_key(key);		sta = get_sta_for_key(key);

	sdata = key->sdata;		sdata = key->sdata;
	@@ -142,11 +83,8 @@ static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)

	ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);		ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);

	if (!ret) {		if (!ret)
	spin_lock_bh(&todo_lock);
	key->flags \|= KEY_FLAG_UPLOADED_TO_HARDWARE;		key->flags \|= KEY_FLAG_UPLOADED_TO_HARDWARE;
	spin_unlock_bh(&todo_lock);
	}

	if (ret && ret != -ENOSPC && ret != -EOPNOTSUPP)		if (ret && ret != -ENOSPC && ret != -EOPNOTSUPP)
	printk(KERN_ERR "mac80211-%s: failed to set key "		printk(KERN_ERR "mac80211-%s: failed to set key "
	@@ -161,18 +99,15 @@ static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
	struct ieee80211_sta *sta;		struct ieee80211_sta *sta;
	int ret;		int ret;

	assert_key_lock();
	might_sleep();		might_sleep();

	if (!key \|\| !key->local->ops->set_key)		if (!key \|\| !key->local->ops->set_key)
	return;		return;

	spin_lock_bh(&todo_lock);		assert_key_lock(key->local);
	if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) {
	spin_unlock_bh(&todo_lock);		if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
	return;		return;
	}
	spin_unlock_bh(&todo_lock);

	sta = get_sta_for_key(key);		sta = get_sta_for_key(key);
	sdata = key->sdata;		sdata = key->sdata;
	@@ -191,9 +126,7 @@ static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
	wiphy_name(key->local->hw.wiphy),		wiphy_name(key->local->hw.wiphy),
	key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);		key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);

	spin_lock_bh(&todo_lock);
	key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;		key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
	spin_unlock_bh(&todo_lock);
	}		}

	static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,		static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
	@@ -201,22 +134,24 @@ static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
	{		{
	struct ieee80211_key *key = NULL;		struct ieee80211_key *key = NULL;

			assert_key_lock(sdata->local);

	if (idx >= 0 && idx < NUM_DEFAULT_KEYS)		if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
	key = sdata->keys[idx];		key = sdata->keys[idx];

	rcu_assign_pointer(sdata->default_key, key);		rcu_assign_pointer(sdata->default_key, key);

	if (key)		if (key) {
	add_todo(key, KEY_FLAG_TODO_DEFKEY);		ieee80211_debugfs_key_remove_default(key->sdata);
			ieee80211_debugfs_key_add_default(key->sdata);
			}
	}		}

	void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx)		void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx)
	{		{
	unsigned long flags;		mutex_lock(&sdata->local->key_mtx);

	spin_lock_irqsave(&sdata->local->key_lock, flags);
	__ieee80211_set_default_key(sdata, idx);		__ieee80211_set_default_key(sdata, idx);
	spin_unlock_irqrestore(&sdata->local->key_lock, flags);		mutex_unlock(&sdata->local->key_mtx);
	}		}

	static void		static void
	@@ -224,24 +159,26 @@ __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
	{		{
	struct ieee80211_key *key = NULL;		struct ieee80211_key *key = NULL;

			assert_key_lock(sdata->local);

	if (idx >= NUM_DEFAULT_KEYS &&		if (idx >= NUM_DEFAULT_KEYS &&
	idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)		idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
	key = sdata->keys[idx];		key = sdata->keys[idx];

	rcu_assign_pointer(sdata->default_mgmt_key, key);		rcu_assign_pointer(sdata->default_mgmt_key, key);

	if (key)		if (key) {
	add_todo(key, KEY_FLAG_TODO_DEFMGMTKEY);		ieee80211_debugfs_key_remove_mgmt_default(key->sdata);
			ieee80211_debugfs_key_add_mgmt_default(key->sdata);
			}
	}		}

	void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,		void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
	int idx)		int idx)
	{		{
	unsigned long flags;		mutex_lock(&sdata->local->key_mtx);

	spin_lock_irqsave(&sdata->local->key_lock, flags);
	__ieee80211_set_default_mgmt_key(sdata, idx);		__ieee80211_set_default_mgmt_key(sdata, idx);
	spin_unlock_irqrestore(&sdata->local->key_lock, flags);		mutex_unlock(&sdata->local->key_mtx);
	}		}


	@@ -352,7 +289,6 @@ struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
	}		}
	memcpy(key->conf.key, key_data, key_len);		memcpy(key->conf.key, key_data, key_len);
	INIT_LIST_HEAD(&key->list);		INIT_LIST_HEAD(&key->list);
	INIT_LIST_HEAD(&key->todo);

	if (alg == ALG_CCMP) {		if (alg == ALG_CCMP) {
	/*		/*
	@@ -382,12 +318,27 @@ struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
	return key;		return key;
	}		}

			static void __ieee80211_key_destroy(struct ieee80211_key *key)
			{
			if (!key)
			return;

			ieee80211_key_disable_hw_accel(key);

			if (key->conf.alg == ALG_CCMP)
			ieee80211_aes_key_free(key->u.ccmp.tfm);
			if (key->conf.alg == ALG_AES_CMAC)
			ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
			ieee80211_debugfs_key_remove(key);

			kfree(key);
			}

	void ieee80211_key_link(struct ieee80211_key *key,		void ieee80211_key_link(struct ieee80211_key *key,
	struct ieee80211_sub_if_data *sdata,		struct ieee80211_sub_if_data *sdata,
	struct sta_info *sta)		struct sta_info *sta)
	{		{
	struct ieee80211_key *old_key;		struct ieee80211_key *old_key;
	unsigned long flags;
	int idx;		int idx;

	BUG_ON(!sdata);		BUG_ON(!sdata);
	@@ -431,7 +382,7 @@ void ieee80211_key_link(struct ieee80211_key *key,
	}		}
	}		}

	spin_lock_irqsave(&sdata->local->key_lock, flags);		mutex_lock(&sdata->local->key_mtx);

	if (sta)		if (sta)
	old_key = sta->key;		old_key = sta->key;
	@@ -439,15 +390,13 @@ void ieee80211_key_link(struct ieee80211_key *key,
	old_key = sdata->keys[idx];		old_key = sdata->keys[idx];

	__ieee80211_key_replace(sdata, sta, old_key, key);		__ieee80211_key_replace(sdata, sta, old_key, key);
			__ieee80211_key_destroy(old_key);

	/* free old key later */		ieee80211_debugfs_key_add(key);
	add_todo(old_key, KEY_FLAG_TODO_DELETE);

	add_todo(key, KEY_FLAG_TODO_ADD_DEBUGFS);		ieee80211_key_enable_hw_accel(key);
	if (ieee80211_sdata_running(sdata))
	add_todo(key, KEY_FLAG_TODO_HWACCEL_ADD);

	spin_unlock_irqrestore(&sdata->local->key_lock, flags);		mutex_unlock(&sdata->local->key_mtx);
	}		}

	static void __ieee80211_key_free(struct ieee80211_key *key)		static void __ieee80211_key_free(struct ieee80211_key *key)
	@@ -458,170 +407,65 @@ static void __ieee80211_key_free(struct ieee80211_key *key)
	if (key->sdata)		if (key->sdata)
	__ieee80211_key_replace(key->sdata, key->sta,		__ieee80211_key_replace(key->sdata, key->sta,
	key, NULL);		key, NULL);
			__ieee80211_key_destroy(key);
	add_todo(key, KEY_FLAG_TODO_DELETE);
	}		}

	void ieee80211_key_free(struct ieee80211_key *key)		void ieee80211_key_free(struct ieee80211_key *key)
	{		{
	unsigned long flags;		struct ieee80211_local *local;

	if (!key)		if (!key)
	return;		return;

	if (!key->sdata) {		local = key->sdata->local;
	/* The key has not been linked yet, simply free it
	* and don't Oops */
	if (key->conf.alg == ALG_CCMP)
	ieee80211_aes_key_free(key->u.ccmp.tfm);
	kfree(key);
	return;
	}

	spin_lock_irqsave(&key->sdata->local->key_lock, flags);		mutex_lock(&local->key_mtx);
	__ieee80211_key_free(key);		__ieee80211_key_free(key);
	spin_unlock_irqrestore(&key->sdata->local->key_lock, flags);		mutex_unlock(&local->key_mtx);
	}		}

	/*		void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
	* To be safe against concurrent manipulations of the list (which shouldn't
	* actually happen) we need to hold the spinlock. But under the spinlock we
	* can't actually do much, so we defer processing to the todo list. Then run
	* the todo list to be sure the operation and possibly previously pending
	* operations are completed.
	*/
	static void ieee80211_todo_for_each_key(struct ieee80211_sub_if_data *sdata,
	u32 todo_flags)
	{		{
	struct ieee80211_key *key;		struct ieee80211_key *key;
	unsigned long flags;

	might_sleep();

	spin_lock_irqsave(&sdata->local->key_lock, flags);
	list_for_each_entry(key, &sdata->key_list, list)
	add_todo(key, todo_flags);
	spin_unlock_irqrestore(&sdata->local->key_lock, flags);

	ieee80211_key_todo();
	}

	void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
	{
	ASSERT_RTNL();		ASSERT_RTNL();

	if (WARN_ON(!ieee80211_sdata_running(sdata)))		if (WARN_ON(!ieee80211_sdata_running(sdata)))
	return;		return;

	ieee80211_todo_for_each_key(sdata, KEY_FLAG_TODO_HWACCEL_ADD);		mutex_lock(&sdata->local->key_mtx);
	}

	void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
	{
	ASSERT_RTNL();

	ieee80211_todo_for_each_key(sdata, KEY_FLAG_TODO_HWACCEL_REMOVE);
	}

	static void __ieee80211_key_destroy(struct ieee80211_key *key)		list_for_each_entry(key, &sdata->key_list, list)
	{		ieee80211_key_enable_hw_accel(key);
	if (!key)
	return;

	ieee80211_key_disable_hw_accel(key);

	if (key->conf.alg == ALG_CCMP)
	ieee80211_aes_key_free(key->u.ccmp.tfm);
	if (key->conf.alg == ALG_AES_CMAC)
	ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
	ieee80211_debugfs_key_remove(key);

	kfree(key);		mutex_unlock(&sdata->local->key_mtx);
	}		}

	static void __ieee80211_key_todo(void)		void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
	{		{
	struct ieee80211_key *key;		struct ieee80211_key *key;
	bool work_done;
	u32 todoflags;

	/*		ASSERT_RTNL();
	* NB: sta_info_destroy relies on this!
	*/
	synchronize_rcu();

	spin_lock_bh(&todo_lock);
	while (!list_empty(&todo_list)) {
	key = list_first_entry(&todo_list, struct ieee80211_key, todo);
	list_del_init(&key->todo);
	todoflags = key->flags & (KEY_FLAG_TODO_ADD_DEBUGFS \|
	KEY_FLAG_TODO_DEFKEY \|
	KEY_FLAG_TODO_DEFMGMTKEY \|
	KEY_FLAG_TODO_HWACCEL_ADD \|
	KEY_FLAG_TODO_HWACCEL_REMOVE \|
	KEY_FLAG_TODO_DELETE);
	key->flags &= ~todoflags;
	spin_unlock_bh(&todo_lock);

	work_done = false;

	if (todoflags & KEY_FLAG_TODO_ADD_DEBUGFS) {
	ieee80211_debugfs_key_add(key);
	work_done = true;
	}
	if (todoflags & KEY_FLAG_TODO_DEFKEY) {
	ieee80211_debugfs_key_remove_default(key->sdata);
	ieee80211_debugfs_key_add_default(key->sdata);
	work_done = true;
	}
	if (todoflags & KEY_FLAG_TODO_DEFMGMTKEY) {
	ieee80211_debugfs_key_remove_mgmt_default(key->sdata);
	ieee80211_debugfs_key_add_mgmt_default(key->sdata);
	work_done = true;
	}
	if (todoflags & KEY_FLAG_TODO_HWACCEL_ADD) {
	ieee80211_key_enable_hw_accel(key);
	work_done = true;
	}
	if (todoflags & KEY_FLAG_TODO_HWACCEL_REMOVE) {
	ieee80211_key_disable_hw_accel(key);
	work_done = true;
	}
	if (todoflags & KEY_FLAG_TODO_DELETE) {
	__ieee80211_key_destroy(key);
	work_done = true;
	}

	WARN_ON(!work_done);		mutex_lock(&sdata->local->key_mtx);

	spin_lock_bh(&todo_lock);		list_for_each_entry(key, &sdata->key_list, list)
	}		ieee80211_key_disable_hw_accel(key);
	spin_unlock_bh(&todo_lock);
	}

	void ieee80211_key_todo(void)		mutex_unlock(&sdata->local->key_mtx);
	{
	ieee80211_key_lock();
	__ieee80211_key_todo();
	ieee80211_key_unlock();
	}		}

	void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)		void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
	{		{
	struct ieee80211_key key, tmp;		struct ieee80211_key key, tmp;
	unsigned long flags;

	ieee80211_key_lock();		mutex_lock(&sdata->local->key_mtx);

	ieee80211_debugfs_key_remove_default(sdata);		ieee80211_debugfs_key_remove_default(sdata);
	ieee80211_debugfs_key_remove_mgmt_default(sdata);		ieee80211_debugfs_key_remove_mgmt_default(sdata);

	spin_lock_irqsave(&sdata->local->key_lock, flags);
	list_for_each_entry_safe(key, tmp, &sdata->key_list, list)		list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
	__ieee80211_key_free(key);		__ieee80211_key_free(key);
	spin_unlock_irqrestore(&sdata->local->key_lock, flags);

	__ieee80211_key_todo();

	ieee80211_key_unlock();		mutex_unlock(&sdata->local->key_mtx);
	}		}

net/mac80211/key.h

+1 −21

Original line number	Original line	Diff line number	Diff line
	@@ -38,25 +38,9 @@ struct sta_info;
	*		*
	* @KEY_FLAG_UPLOADED_TO_HARDWARE: Indicates that this key is present		* @KEY_FLAG_UPLOADED_TO_HARDWARE: Indicates that this key is present
	* in the hardware for TX crypto hardware acceleration.		* in the hardware for TX crypto hardware acceleration.
	* @KEY_FLAG_TODO_DELETE: Key is marked for deletion and will, after an
	* RCU grace period, no longer be reachable other than from the
	* todo list.
	* @KEY_FLAG_TODO_HWACCEL_ADD: Key needs to be added to hardware acceleration.
	* @KEY_FLAG_TODO_HWACCEL_REMOVE: Key needs to be removed from hardware
	* acceleration.
	* @KEY_FLAG_TODO_DEFKEY: Key is default key and debugfs needs to be updated.
	* @KEY_FLAG_TODO_ADD_DEBUGFS: Key needs to be added to debugfs.
	* @KEY_FLAG_TODO_DEFMGMTKEY: Key is default management key and debugfs needs
	* to be updated.
	*/		*/
	enum ieee80211_internal_key_flags {		enum ieee80211_internal_key_flags {
	KEY_FLAG_UPLOADED_TO_HARDWARE = BIT(0),		KEY_FLAG_UPLOADED_TO_HARDWARE = BIT(0),
	KEY_FLAG_TODO_DELETE = BIT(1),
	KEY_FLAG_TODO_HWACCEL_ADD = BIT(2),
	KEY_FLAG_TODO_HWACCEL_REMOVE = BIT(3),
	KEY_FLAG_TODO_DEFKEY = BIT(4),
	KEY_FLAG_TODO_ADD_DEBUGFS = BIT(5),
	KEY_FLAG_TODO_DEFMGMTKEY = BIT(6),
	};		};

	enum ieee80211_internal_tkip_state {		enum ieee80211_internal_tkip_state {
	@@ -79,10 +63,8 @@ struct ieee80211_key {

	/* for sdata list */		/* for sdata list */
	struct list_head list;		struct list_head list;
	/* for todo list */
	struct list_head todo;

	/* protected by todo lock! */		/* protected by key mutex */
	unsigned int flags;		unsigned int flags;

	union {		union {
	@@ -155,6 +137,4 @@ void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata);
	void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata);		void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata);
	void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata);		void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata);

	void ieee80211_key_todo(void);

	#endif /* IEEE80211_KEY_H */		#endif /* IEEE80211_KEY_H */