[linux-2.6-block.git] / net / mac80211 / ocb.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * OCB mode implementation
 *
 * Copyright: (c) 2014 Czech Technical University in Prague
 *            (c) 2014 Volkswagen Group Research
 * Author:    Rostislav Lisovy <rostislav.lisovy@fel.cvut.cz>
 * Funded by: Volkswagen Group Research
 */

#include <linux/delay.h>
#include <linux/if_ether.h>
#include <linux/skbuff.h>
#include <linux/if_arp.h>
#include <linux/etherdevice.h>
#include <linux/rtnetlink.h>
#include <net/mac80211.h>
#include <asm/unaligned.h>

#include "ieee80211_i.h"
#include "driver-ops.h"
#include "rate.h"

#define IEEE80211_OCB_HOUSEKEEPING_INTERVAL		(60 * HZ)
#define IEEE80211_OCB_PEER_INACTIVITY_LIMIT		(240 * HZ)
#define IEEE80211_OCB_MAX_STA_ENTRIES			128

/**
 * enum ocb_deferred_task_flags - mac80211 OCB deferred tasks
 * @OCB_WORK_HOUSEKEEPING: run the periodic OCB housekeeping tasks
 *
 * These flags are used in @wrkq_flags field of &struct ieee80211_if_ocb
 */
enum ocb_deferred_task_flags {
	OCB_WORK_HOUSEKEEPING,
};

void ieee80211_ocb_rx_no_sta(struct ieee80211_sub_if_data *sdata,
			     const u8 *bssid, const u8 *addr,
			     u32 supp_rates)
{
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_supported_band *sband;
	enum nl80211_bss_scan_width scan_width;
	struct sta_info *sta;
	int band;

	/* XXX: Consider removing the least recently used entry and
	 *      allow new one to be added.
	 */
	if (local->num_sta >= IEEE80211_OCB_MAX_STA_ENTRIES) {
		net_info_ratelimited("%s: No room for a new OCB STA entry %pM\n",
				     sdata->name, addr);
		return;
	}

	ocb_dbg(sdata, "Adding new OCB station %pM\n", addr);

	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (WARN_ON_ONCE(!chanctx_conf)) {
		rcu_read_unlock();
		return;
	}
	band = chanctx_conf->def.chan->band;
	scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
	rcu_read_unlock();

	sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
	if (!sta)
		return;

	/* Add only mandatory rates for now */
	sband = local->hw.wiphy->bands[band];
	sta->sta.supp_rates[band] =
		ieee80211_mandatory_rates(sband, scan_width);

	spin_lock(&ifocb->incomplete_lock);
	list_add(&sta->list, &ifocb->incomplete_stations);
	spin_unlock(&ifocb->incomplete_lock);
	ieee80211_queue_work(&local->hw, &sdata->work);
}

static struct sta_info *ieee80211_ocb_finish_sta(struct sta_info *sta)
	__acquires(RCU)
{
	struct ieee80211_sub_if_data *sdata = sta->sdata;
	u8 addr[ETH_ALEN];

	memcpy(addr, sta->sta.addr, ETH_ALEN);

	ocb_dbg(sdata, "Adding new IBSS station %pM (dev=%s)\n",
		addr, sdata->name);

	sta_info_move_state(sta, IEEE80211_STA_AUTH);
	sta_info_move_state(sta, IEEE80211_STA_ASSOC);
	sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);

	rate_control_rate_init(sta);

	/* If it fails, maybe we raced another insertion? */
	if (sta_info_insert_rcu(sta))
		return sta_info_get(sdata, addr);
	return sta;
}

static void ieee80211_ocb_housekeeping(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;

	ocb_dbg(sdata, "Running ocb housekeeping\n");

	ieee80211_sta_expire(sdata, IEEE80211_OCB_PEER_INACTIVITY_LIMIT);

	mod_timer(&ifocb->housekeeping_timer,
		  round_jiffies(jiffies + IEEE80211_OCB_HOUSEKEEPING_INTERVAL));
}

void ieee80211_ocb_work(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	struct sta_info *sta;

	if (ifocb->joined != true)
		return;

	sdata_lock(sdata);

	spin_lock_bh(&ifocb->incomplete_lock);
	while (!list_empty(&ifocb->incomplete_stations)) {
		sta = list_first_entry(&ifocb->incomplete_stations,
				       struct sta_info, list);
		list_del(&sta->list);
		spin_unlock_bh(&ifocb->incomplete_lock);

		ieee80211_ocb_finish_sta(sta);
		rcu_read_unlock();
		spin_lock_bh(&ifocb->incomplete_lock);
	}
	spin_unlock_bh(&ifocb->incomplete_lock);

	if (test_and_clear_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags))
		ieee80211_ocb_housekeeping(sdata);

	sdata_unlock(sdata);
}

static void ieee80211_ocb_housekeeping_timer(struct timer_list *t)
{
	struct ieee80211_sub_if_data *sdata =
		from_timer(sdata, t, u.ocb.housekeeping_timer);
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;

	set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);

	ieee80211_queue_work(&local->hw, &sdata->work);
}

void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;

	timer_setup(&ifocb->housekeeping_timer,
		    ieee80211_ocb_housekeeping_timer, 0);
	INIT_LIST_HEAD(&ifocb->incomplete_stations);
	spin_lock_init(&ifocb->incomplete_lock);
}

int ieee80211_ocb_join(struct ieee80211_sub_if_data *sdata,
		       struct ocb_setup *setup)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	u32 changed = BSS_CHANGED_OCB | BSS_CHANGED_BSSID;
	int err;

	if (ifocb->joined == true)
		return -EINVAL;

	sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = sdata->local->rx_chains;

	mutex_lock(&sdata->local->mtx);
	err = ieee80211_vif_use_channel(sdata, &setup->chandef,
					IEEE80211_CHANCTX_SHARED);
	mutex_unlock(&sdata->local->mtx);
	if (err)
		return err;

	ieee80211_bss_info_change_notify(sdata, changed);

	ifocb->joined = true;

	set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
	ieee80211_queue_work(&local->hw, &sdata->work);

	netif_carrier_on(sdata->dev);
	return 0;
}

int ieee80211_ocb_leave(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	struct ieee80211_local *local = sdata->local;
	struct sta_info *sta;

	ifocb->joined = false;
	sta_info_flush(sdata);

	spin_lock_bh(&ifocb->incomplete_lock);
	while (!list_empty(&ifocb->incomplete_stations)) {
		sta = list_first_entry(&ifocb->incomplete_stations,
				       struct sta_info, list);
		list_del(&sta->list);
		spin_unlock_bh(&ifocb->incomplete_lock);

		sta_info_free(local, sta);
		spin_lock_bh(&ifocb->incomplete_lock);
	}
	spin_unlock_bh(&ifocb->incomplete_lock);

	netif_carrier_off(sdata->dev);
	clear_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_OCB);

	mutex_lock(&sdata->local->mtx);
	ieee80211_vif_release_channel(sdata);
	mutex_unlock(&sdata->local->mtx);

	skb_queue_purge(&sdata->skb_queue);

	del_timer_sync(&sdata->u.ocb.housekeeping_timer);
	/* If the timer fired while we waited for it, it will have
	 * requeued the work. Now the work will be running again
	 * but will not rearm the timer again because it checks
	 * whether we are connected to the network or not -- at this
	 * point we shouldn't be anymore.
	 */

	return 0;
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
239281f8 RL	2	/*
	3	* OCB mode implementation
	4	*
	5	* Copyright: (c) 2014 Czech Technical University in Prague
	6	* (c) 2014 Volkswagen Group Research
	7	* Author: Rostislav Lisovy <rostislav.lisovy@fel.cvut.cz>
	8	* Funded by: Volkswagen Group Research
239281f8 RL	9	*/
	10
	11	#include <linux/delay.h>
	12	#include <linux/if_ether.h>
	13	#include <linux/skbuff.h>
	14	#include <linux/if_arp.h>
	15	#include <linux/etherdevice.h>
	16	#include <linux/rtnetlink.h>
	17	#include <net/mac80211.h>
	18	#include <asm/unaligned.h>
	19
	20	#include "ieee80211_i.h"
	21	#include "driver-ops.h"
	22	#include "rate.h"
	23
	24	#define IEEE80211_OCB_HOUSEKEEPING_INTERVAL (60 * HZ)
	25	#define IEEE80211_OCB_PEER_INACTIVITY_LIMIT (240 * HZ)
	26	#define IEEE80211_OCB_MAX_STA_ENTRIES 128
	27
	28	/**
	29	* enum ocb_deferred_task_flags - mac80211 OCB deferred tasks
	30	* @OCB_WORK_HOUSEKEEPING: run the periodic OCB housekeeping tasks
	31	*
	32	* These flags are used in @wrkq_flags field of &struct ieee80211_if_ocb
	33	*/
	34	enum ocb_deferred_task_flags {
	35	OCB_WORK_HOUSEKEEPING,
	36	};
	37
	38	void ieee80211_ocb_rx_no_sta(struct ieee80211_sub_if_data *sdata,
	39	const u8 bssid, const u8 addr,
	40	u32 supp_rates)
	41	{
	42	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	43	struct ieee80211_local *local = sdata->local;
	44	struct ieee80211_chanctx_conf *chanctx_conf;
	45	struct ieee80211_supported_band *sband;
	46	enum nl80211_bss_scan_width scan_width;
	47	struct sta_info *sta;
	48	int band;
	49
	50	/* XXX: Consider removing the least recently used entry and
	51	* allow new one to be added.
	52	*/
	53	if (local->num_sta >= IEEE80211_OCB_MAX_STA_ENTRIES) {
	54	net_info_ratelimited("%s: No room for a new OCB STA entry %pM\n",
	55	sdata->name, addr);
	56	return;
	57	}
	58
	59	ocb_dbg(sdata, "Adding new OCB station %pM\n", addr);
	60
	61	rcu_read_lock();
	62	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	63	if (WARN_ON_ONCE(!chanctx_conf)) {
	64	rcu_read_unlock();
	65	return;
	66	}
	67	band = chanctx_conf->def.chan->band;
	68	scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
	69	rcu_read_unlock();
	70
	71	sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
	72	if (!sta)
73	return;
74
239281f8 RL	75	/* Add only mandatory rates for now */
	76	sband = local->hw.wiphy->bands[band];
	77	sta->sta.supp_rates[band] =
	78	ieee80211_mandatory_rates(sband, scan_width);
	79
	80	spin_lock(&ifocb->incomplete_lock);
	81	list_add(&sta->list, &ifocb->incomplete_stations);
	82	spin_unlock(&ifocb->incomplete_lock);
	83	ieee80211_queue_work(&local->hw, &sdata->work);
	84	}
	85
	86	static struct sta_info ieee80211_ocb_finish_sta(struct sta_info sta)
	87	__acquires(RCU)
	88	{
	89	struct ieee80211_sub_if_data *sdata = sta->sdata;
	90	u8 addr[ETH_ALEN];
	91
	92	memcpy(addr, sta->sta.addr, ETH_ALEN);
	93
	94	ocb_dbg(sdata, "Adding new IBSS station %pM (dev=%s)\n",
	95	addr, sdata->name);
	96
	97	sta_info_move_state(sta, IEEE80211_STA_AUTH);
	98	sta_info_move_state(sta, IEEE80211_STA_ASSOC);
	99	sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
	100
	101	rate_control_rate_init(sta);
	102
	103	/* If it fails, maybe we raced another insertion? */
	104	if (sta_info_insert_rcu(sta))
	105	return sta_info_get(sdata, addr);
	106	return sta;
	107	}
	108
	109	static void ieee80211_ocb_housekeeping(struct ieee80211_sub_if_data *sdata)
	110	{
	111	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	112
	113	ocb_dbg(sdata, "Running ocb housekeeping\n");
	114
	115	ieee80211_sta_expire(sdata, IEEE80211_OCB_PEER_INACTIVITY_LIMIT);
	116
	117	mod_timer(&ifocb->housekeeping_timer,
	118	round_jiffies(jiffies + IEEE80211_OCB_HOUSEKEEPING_INTERVAL));
	119	}
	120
	121	void ieee80211_ocb_work(struct ieee80211_sub_if_data *sdata)
	122	{
	123	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	124	struct sta_info *sta;
	125
	126	if (ifocb->joined != true)
	127	return;
	128
	129	sdata_lock(sdata);
	130
	131	spin_lock_bh(&ifocb->incomplete_lock);
	132	while (!list_empty(&ifocb->incomplete_stations)) {
	133	sta = list_first_entry(&ifocb->incomplete_stations,
	134	struct sta_info, list);
	135	list_del(&sta->list);
	136	spin_unlock_bh(&ifocb->incomplete_lock);
	137
	138	ieee80211_ocb_finish_sta(sta);
139	rcu_read_unlock();
140	spin_lock_bh(&ifocb->incomplete_lock);
141	}
142	spin_unlock_bh(&ifocb->incomplete_lock);
143
144	if (test_and_clear_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags))
145	ieee80211_ocb_housekeeping(sdata);
146
147	sdata_unlock(sdata);
148	}
149
34f11cd3	150	static void ieee80211_ocb_housekeeping_timer(struct timer_list *t)
239281f8	151	{
34f11cd3 KC	152	struct ieee80211_sub_if_data *sdata =
34f11cd3 KC	153	from_timer(sdata, t, u.ocb.housekeeping_timer);
239281f8 RL	154	struct ieee80211_local *local = sdata->local;
	155	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	156
	157	set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
	158
	159	ieee80211_queue_work(&local->hw, &sdata->work);
	160	}
	161
	162	void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata)
	163	{
	164	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	165
34f11cd3 KC	166	timer_setup(&ifocb->housekeeping_timer,
34f11cd3 KC	167	ieee80211_ocb_housekeeping_timer, 0);
239281f8 RL	168	INIT_LIST_HEAD(&ifocb->incomplete_stations);
	169	spin_lock_init(&ifocb->incomplete_lock);
	170	}
	171
	172	int ieee80211_ocb_join(struct ieee80211_sub_if_data *sdata,
	173	struct ocb_setup *setup)
	174	{
	175	struct ieee80211_local *local = sdata->local;
	176	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
4b819f6c	177	u32 changed = BSS_CHANGED_OCB \| BSS_CHANGED_BSSID;
239281f8 RL	178	int err;
	179
	180	if (ifocb->joined == true)
	181	return -EINVAL;
	182
	183	sdata->flags \|= IEEE80211_SDATA_OPERATING_GMODE;
	184	sdata->smps_mode = IEEE80211_SMPS_OFF;
	185	sdata->needed_rx_chains = sdata->local->rx_chains;
	186
	187	mutex_lock(&sdata->local->mtx);
	188	err = ieee80211_vif_use_channel(sdata, &setup->chandef,
	189	IEEE80211_CHANCTX_SHARED);
	190	mutex_unlock(&sdata->local->mtx);
	191	if (err)
	192	return err;
	193
	194	ieee80211_bss_info_change_notify(sdata, changed);
	195
	196	ifocb->joined = true;
	197
	198	set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
	199	ieee80211_queue_work(&local->hw, &sdata->work);
	200
	201	netif_carrier_on(sdata->dev);
	202	return 0;
	203	}
	204
	205	int ieee80211_ocb_leave(struct ieee80211_sub_if_data *sdata)
	206	{
	207	struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
	208	struct ieee80211_local *local = sdata->local;
	209	struct sta_info *sta;
	210
	211	ifocb->joined = false;
	212	sta_info_flush(sdata);
	213
	214	spin_lock_bh(&ifocb->incomplete_lock);
	215	while (!list_empty(&ifocb->incomplete_stations)) {
	216	sta = list_first_entry(&ifocb->incomplete_stations,
	217	struct sta_info, list);
	218	list_del(&sta->list);
	219	spin_unlock_bh(&ifocb->incomplete_lock);
	220
	221	sta_info_free(local, sta);
	222	spin_lock_bh(&ifocb->incomplete_lock);
	223	}
	224	spin_unlock_bh(&ifocb->incomplete_lock);
	225
	226	netif_carrier_off(sdata->dev);
	227	clear_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
	228	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_OCB);
	229
	230	mutex_lock(&sdata->local->mtx);
	231	ieee80211_vif_release_channel(sdata);
	232	mutex_unlock(&sdata->local->mtx);
	233
	234	skb_queue_purge(&sdata->skb_queue);
	235
	236	del_timer_sync(&sdata->u.ocb.housekeeping_timer);
	237	/* If the timer fired while we waited for it, it will have
	238	* requeued the work. Now the work will be running again
	239	* but will not rearm the timer again because it checks
	240	* whether we are connected to the network or not -- at this
	241	* point we shouldn't be anymore.
242	*/
243
244	return 0;
245	}