mac80211_hwsim.c 94.4 KB
Newer Older
1 2 3
/*
 * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211
 * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
4
 * Copyright (c) 2011, Javier Lopez <jlopex@gmail.com>
5 6 7 8 9 10 11 12
 *
 * 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.
 */

/*
 * TODO:
13 14
 * - Add TSF sync and fix IBSS beacon transmission by adding
 *   competition for "air time" at TBTT
15 16 17
 * - RX filtering based on filter configuration (data->rx_filter)
 */

18
#include <linux/list.h>
19
#include <linux/slab.h>
20
#include <linux/spinlock.h>
21 22
#include <net/dst.h>
#include <net/xfrm.h>
23 24 25 26 27
#include <net/mac80211.h>
#include <net/ieee80211_radiotap.h>
#include <linux/if_arp.h>
#include <linux/rtnetlink.h>
#include <linux/etherdevice.h>
28
#include <linux/platform_device.h>
29
#include <linux/debugfs.h>
30
#include <linux/module.h>
31
#include <linux/ktime.h>
32
#include <net/genetlink.h>
33 34
#include <net/net_namespace.h>
#include <net/netns/generic.h>
35 36 37 38
#include "mac80211_hwsim.h"

#define WARN_QUEUE 100
#define MAX_QUEUE 200
39 40 41 42 43 44 45 46 47

MODULE_AUTHOR("Jouni Malinen");
MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
MODULE_LICENSE("GPL");

static int radios = 2;
module_param(radios, int, 0444);
MODULE_PARM_DESC(radios, "Number of simulated radios");

48 49 50
static int channels = 1;
module_param(channels, int, 0444);
MODULE_PARM_DESC(channels, "Number of concurrent channels");
51

52 53 54 55
static bool paged_rx = false;
module_param(paged_rx, bool, 0644);
MODULE_PARM_DESC(paged_rx, "Use paged SKBs for RX instead of linear ones");

56 57 58 59
static bool rctbl = false;
module_param(rctbl, bool, 0444);
MODULE_PARM_DESC(rctbl, "Handle rate control table");

60 61 62 63
static bool support_p2p_device = true;
module_param(support_p2p_device, bool, 0444);
MODULE_PARM_DESC(support_p2p_device, "Support P2P-Device interface type");

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
/**
 * enum hwsim_regtest - the type of regulatory tests we offer
 *
 * These are the different values you can use for the regtest
 * module parameter. This is useful to help test world roaming
 * and the driver regulatory_hint() call and combinations of these.
 * If you want to do specific alpha2 regulatory domain tests simply
 * use the userspace regulatory request as that will be respected as
 * well without the need of this module parameter. This is designed
 * only for testing the driver regulatory request, world roaming
 * and all possible combinations.
 *
 * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed,
 * 	this is the default value.
 * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory
 *	hint, only one driver regulatory hint will be sent as such the
 * 	secondary radios are expected to follow.
 * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory
 * 	request with all radios reporting the same regulatory domain.
 * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling
 * 	different regulatory domains requests. Expected behaviour is for
 * 	an intersection to occur but each device will still use their
 * 	respective regulatory requested domains. Subsequent radios will
 * 	use the resulting intersection.
L
Lucas De Marchi 已提交
88
 * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
 *	this by using a custom beacon-capable regulatory domain for the first
 *	radio. All other device world roam.
 * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
 * 	domain requests. All radios will adhere to this custom world regulatory
 * 	domain.
 * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
 * 	domain requests. The first radio will adhere to the first custom world
 * 	regulatory domain, the second one to the second custom world regulatory
 * 	domain. All other devices will world roam.
 * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
 *	settings, only the first radio will send a regulatory domain request
 *	and use strict settings. The rest of the radios are expected to follow.
 * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
 *	settings. All radios will adhere to this.
 * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
 *	domain settings, combined with secondary driver regulatory domain
 *	settings. The first radio will get a strict regulatory domain setting
 *	using the first driver regulatory request and the second radio will use
 *	non-strict settings using the second driver regulatory request. All
 *	other devices should follow the intersection created between the
 *	first two.
 * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
 * 	at least 6 radios for a complete test. We will test in this order:
 * 	1 - driver custom world regulatory domain
 * 	2 - second custom world regulatory domain
 * 	3 - first driver regulatory domain request
 * 	4 - second driver regulatory domain request
 * 	5 - strict regulatory domain settings using the third driver regulatory
 * 	    domain request
 * 	6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
 * 	           regulatory requests.
 */
enum hwsim_regtest {
	HWSIM_REGTEST_DISABLED = 0,
	HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
	HWSIM_REGTEST_DRIVER_REG_ALL = 2,
	HWSIM_REGTEST_DIFF_COUNTRY = 3,
	HWSIM_REGTEST_WORLD_ROAM = 4,
	HWSIM_REGTEST_CUSTOM_WORLD = 5,
	HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
	HWSIM_REGTEST_STRICT_FOLLOW = 7,
	HWSIM_REGTEST_STRICT_ALL = 8,
	HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
	HWSIM_REGTEST_ALL = 10,
};

/* Set to one of the HWSIM_REGTEST_* values above */
static int regtest = HWSIM_REGTEST_DISABLED;
module_param(regtest, int, 0444);
MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");

static const char *hwsim_alpha2s[] = {
	"FI",
	"AL",
	"US",
	"DE",
	"JP",
	"AL",
};

static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
	.n_reg_rules = 4,
	.alpha2 =  "99",
	.reg_rules = {
		REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
		REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
		REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
		REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
	}
};

static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
	.n_reg_rules = 2,
	.alpha2 =  "99",
	.reg_rules = {
		REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
		REG_RULE(5725-10, 5850+10, 40, 0, 30,
166
			 NL80211_RRF_NO_IR),
167 168 169
	}
};

170 171 172 173 174
static const struct ieee80211_regdomain *hwsim_world_regdom_custom[] = {
	&hwsim_world_regdom_custom_01,
	&hwsim_world_regdom_custom_02,
};

175 176
struct hwsim_vif_priv {
	u32 magic;
177 178
	u8 bssid[ETH_ALEN];
	bool assoc;
179
	bool bcn_en;
180
	u16 aid;
181 182 183 184 185 186 187
};

#define HWSIM_VIF_MAGIC	0x69537748

static inline void hwsim_check_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
188 189 190
	WARN(vp->magic != HWSIM_VIF_MAGIC,
	     "Invalid VIF (%p) magic %#x, %pM, %d/%d\n",
	     vif, vp->magic, vif->addr, vif->type, vif->p2p);
191 192 193 194 195 196 197 198 199 200 201 202 203
}

static inline void hwsim_set_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	vp->magic = HWSIM_VIF_MAGIC;
}

static inline void hwsim_clear_magic(struct ieee80211_vif *vif)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	vp->magic = 0;
}
204

205 206 207 208
struct hwsim_sta_priv {
	u32 magic;
};

209
#define HWSIM_STA_MAGIC	0x6d537749
210 211 212 213

static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
214
	WARN_ON(sp->magic != HWSIM_STA_MAGIC);
215 216 217 218 219
}

static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
220
	sp->magic = HWSIM_STA_MAGIC;
221 222 223 224 225 226 227 228
}

static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
	sp->magic = 0;
}

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
struct hwsim_chanctx_priv {
	u32 magic;
};

#define HWSIM_CHANCTX_MAGIC 0x6d53774a

static inline void hwsim_check_chanctx_magic(struct ieee80211_chanctx_conf *c)
{
	struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
	WARN_ON(cp->magic != HWSIM_CHANCTX_MAGIC);
}

static inline void hwsim_set_chanctx_magic(struct ieee80211_chanctx_conf *c)
{
	struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
	cp->magic = HWSIM_CHANCTX_MAGIC;
}

static inline void hwsim_clear_chanctx_magic(struct ieee80211_chanctx_conf *c)
{
	struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
	cp->magic = 0;
}

253
static unsigned int hwsim_net_id;
254 255 256 257 258

static int hwsim_netgroup;

struct hwsim_net {
	int netgroup;
259
	u32 wmediumd;
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
};

static inline int hwsim_net_get_netgroup(struct net *net)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	return hwsim_net->netgroup;
}

static inline void hwsim_net_set_netgroup(struct net *net)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	hwsim_net->netgroup = hwsim_netgroup++;
}

276 277 278 279 280 281 282 283 284 285 286 287 288 289
static inline u32 hwsim_net_get_wmediumd(struct net *net)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	return hwsim_net->wmediumd;
}

static inline void hwsim_net_set_wmediumd(struct net *net, u32 portid)
{
	struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);

	hwsim_net->wmediumd = portid;
}

290 291 292 293
static struct class *hwsim_class;

static struct net_device *hwsim_mon; /* global monitor netdev */

294
#define CHAN2G(_freq)  { \
295
	.band = NL80211_BAND_2GHZ, \
296 297 298 299 300 301
	.center_freq = (_freq), \
	.hw_value = (_freq), \
	.max_power = 20, \
}

#define CHAN5G(_freq) { \
302
	.band = NL80211_BAND_5GHZ, \
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
	.center_freq = (_freq), \
	.hw_value = (_freq), \
	.max_power = 20, \
}

static const struct ieee80211_channel hwsim_channels_2ghz[] = {
	CHAN2G(2412), /* Channel 1 */
	CHAN2G(2417), /* Channel 2 */
	CHAN2G(2422), /* Channel 3 */
	CHAN2G(2427), /* Channel 4 */
	CHAN2G(2432), /* Channel 5 */
	CHAN2G(2437), /* Channel 6 */
	CHAN2G(2442), /* Channel 7 */
	CHAN2G(2447), /* Channel 8 */
	CHAN2G(2452), /* Channel 9 */
	CHAN2G(2457), /* Channel 10 */
	CHAN2G(2462), /* Channel 11 */
	CHAN2G(2467), /* Channel 12 */
	CHAN2G(2472), /* Channel 13 */
	CHAN2G(2484), /* Channel 14 */
};
324

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
static const struct ieee80211_channel hwsim_channels_5ghz[] = {
	CHAN5G(5180), /* Channel 36 */
	CHAN5G(5200), /* Channel 40 */
	CHAN5G(5220), /* Channel 44 */
	CHAN5G(5240), /* Channel 48 */

	CHAN5G(5260), /* Channel 52 */
	CHAN5G(5280), /* Channel 56 */
	CHAN5G(5300), /* Channel 60 */
	CHAN5G(5320), /* Channel 64 */

	CHAN5G(5500), /* Channel 100 */
	CHAN5G(5520), /* Channel 104 */
	CHAN5G(5540), /* Channel 108 */
	CHAN5G(5560), /* Channel 112 */
	CHAN5G(5580), /* Channel 116 */
	CHAN5G(5600), /* Channel 120 */
	CHAN5G(5620), /* Channel 124 */
	CHAN5G(5640), /* Channel 128 */
	CHAN5G(5660), /* Channel 132 */
	CHAN5G(5680), /* Channel 136 */
	CHAN5G(5700), /* Channel 140 */

	CHAN5G(5745), /* Channel 149 */
	CHAN5G(5765), /* Channel 153 */
	CHAN5G(5785), /* Channel 157 */
	CHAN5G(5805), /* Channel 161 */
	CHAN5G(5825), /* Channel 165 */
353
	CHAN5G(5845), /* Channel 169 */
354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
};

static const struct ieee80211_rate hwsim_rates[] = {
	{ .bitrate = 10 },
	{ .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 60 },
	{ .bitrate = 90 },
	{ .bitrate = 120 },
	{ .bitrate = 180 },
	{ .bitrate = 240 },
	{ .bitrate = 360 },
	{ .bitrate = 480 },
	{ .bitrate = 540 }
};

371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
#define OUI_QCA 0x001374
#define QCA_NL80211_SUBCMD_TEST 1
enum qca_nl80211_vendor_subcmds {
	QCA_WLAN_VENDOR_ATTR_TEST = 8,
	QCA_WLAN_VENDOR_ATTR_MAX = QCA_WLAN_VENDOR_ATTR_TEST
};

static const struct nla_policy
hwsim_vendor_test_policy[QCA_WLAN_VENDOR_ATTR_MAX + 1] = {
	[QCA_WLAN_VENDOR_ATTR_MAX] = { .type = NLA_U32 },
};

static int mac80211_hwsim_vendor_cmd_test(struct wiphy *wiphy,
					  struct wireless_dev *wdev,
					  const void *data, int data_len)
{
	struct sk_buff *skb;
	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_MAX + 1];
	int err;
	u32 val;

	err = nla_parse(tb, QCA_WLAN_VENDOR_ATTR_MAX, data, data_len,
393
			hwsim_vendor_test_policy, NULL);
394 395 396 397 398
	if (err)
		return err;
	if (!tb[QCA_WLAN_VENDOR_ATTR_TEST])
		return -EINVAL;
	val = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_TEST]);
399
	wiphy_dbg(wiphy, "%s: test=%u\n", __func__, val);
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447

	/* Send a vendor event as a test. Note that this would not normally be
	 * done within a command handler, but rather, based on some other
	 * trigger. For simplicity, this command is used to trigger the event
	 * here.
	 *
	 * event_idx = 0 (index in mac80211_hwsim_vendor_commands)
	 */
	skb = cfg80211_vendor_event_alloc(wiphy, wdev, 100, 0, GFP_KERNEL);
	if (skb) {
		/* skb_put() or nla_put() will fill up data within
		 * NL80211_ATTR_VENDOR_DATA.
		 */

		/* Add vendor data */
		nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 1);

		/* Send the event - this will call nla_nest_end() */
		cfg80211_vendor_event(skb, GFP_KERNEL);
	}

	/* Send a response to the command */
	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 10);
	if (!skb)
		return -ENOMEM;

	/* skb_put() or nla_put() will fill up data within
	 * NL80211_ATTR_VENDOR_DATA
	 */
	nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 2);

	return cfg80211_vendor_cmd_reply(skb);
}

static struct wiphy_vendor_command mac80211_hwsim_vendor_commands[] = {
	{
		.info = { .vendor_id = OUI_QCA,
			  .subcmd = QCA_NL80211_SUBCMD_TEST },
		.flags = WIPHY_VENDOR_CMD_NEED_NETDEV,
		.doit = mac80211_hwsim_vendor_cmd_test,
	}
};

/* Advertise support vendor specific events */
static const struct nl80211_vendor_cmd_info mac80211_hwsim_vendor_events[] = {
	{ .vendor_id = OUI_QCA, .subcmd = 1 },
};

448 449 450 451 452 453 454 455 456
static const struct ieee80211_iface_limit hwsim_if_limits[] = {
	{ .max = 1, .types = BIT(NL80211_IFTYPE_ADHOC) },
	{ .max = 2048,  .types = BIT(NL80211_IFTYPE_STATION) |
				 BIT(NL80211_IFTYPE_P2P_CLIENT) |
#ifdef CONFIG_MAC80211_MESH
				 BIT(NL80211_IFTYPE_MESH_POINT) |
#endif
				 BIT(NL80211_IFTYPE_AP) |
				 BIT(NL80211_IFTYPE_P2P_GO) },
457 458
	/* must be last, see hwsim_if_comb */
	{ .max = 1, .types = BIT(NL80211_IFTYPE_P2P_DEVICE) }
459 460 461
};

static const struct ieee80211_iface_combination hwsim_if_comb[] = {
462 463 464 465 466 467 468 469 470 471 472
	{
		.limits = hwsim_if_limits,
		/* remove the last entry which is P2P_DEVICE */
		.n_limits = ARRAY_SIZE(hwsim_if_limits) - 1,
		.max_interfaces = 2048,
		.num_different_channels = 1,
		.radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
				       BIT(NL80211_CHAN_WIDTH_20) |
				       BIT(NL80211_CHAN_WIDTH_40) |
				       BIT(NL80211_CHAN_WIDTH_80) |
				       BIT(NL80211_CHAN_WIDTH_160),
473
	},
474 475 476
};

static const struct ieee80211_iface_combination hwsim_if_comb_p2p_dev[] = {
477 478 479 480 481 482 483 484 485 486
	{
		.limits = hwsim_if_limits,
		.n_limits = ARRAY_SIZE(hwsim_if_limits),
		.max_interfaces = 2048,
		.num_different_channels = 1,
		.radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
				       BIT(NL80211_CHAN_WIDTH_20) |
				       BIT(NL80211_CHAN_WIDTH_40) |
				       BIT(NL80211_CHAN_WIDTH_80) |
				       BIT(NL80211_CHAN_WIDTH_160),
487
	},
488 489
};

490
static spinlock_t hwsim_radio_lock;
491
static LIST_HEAD(hwsim_radios);
492
static struct workqueue_struct *hwsim_wq;
493
static int hwsim_radio_idx;
494

495 496 497 498 499
static struct platform_driver mac80211_hwsim_driver = {
	.driver = {
		.name = "mac80211_hwsim",
	},
};
500

501
struct mac80211_hwsim_data {
502 503
	struct list_head list;
	struct ieee80211_hw *hw;
504
	struct device *dev;
505
	struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
506 507
	struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
	struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
508
	struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
509
	struct ieee80211_iface_combination if_combination;
510

511
	struct mac_address addresses[2];
512
	int channels, idx;
513
	bool use_chanctx;
514 515 516
	bool destroy_on_close;
	struct work_struct destroy_work;
	u32 portid;
517 518
	char alpha2[2];
	const struct ieee80211_regdomain *regd;
519

520
	struct ieee80211_channel *tmp_chan;
521 522 523
	struct ieee80211_channel *roc_chan;
	u32 roc_duration;
	struct delayed_work roc_start;
524 525 526 527 528
	struct delayed_work roc_done;
	struct delayed_work hw_scan;
	struct cfg80211_scan_request *hw_scan_request;
	struct ieee80211_vif *hw_scan_vif;
	int scan_chan_idx;
529
	u8 scan_addr[ETH_ALEN];
530 531 532 533 534
	struct {
		struct ieee80211_channel *channel;
		unsigned long next_start, start, end;
	} survey_data[ARRAY_SIZE(hwsim_channels_2ghz) +
		      ARRAY_SIZE(hwsim_channels_5ghz)];
535

536
	struct ieee80211_channel *channel;
T
Thomas Pedersen 已提交
537
	u64 beacon_int	/* beacon interval in us */;
538
	unsigned int rx_filter;
539 540
	bool started, idle, scanning;
	struct mutex mutex;
T
Thomas Pedersen 已提交
541
	struct tasklet_hrtimer beacon_timer;
542 543 544 545 546
	enum ps_mode {
		PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
	} ps;
	bool ps_poll_pending;
	struct dentry *debugfs;
D
Daniel Wagner 已提交
547

548
	uintptr_t pending_cookie;
549
	struct sk_buff_head pending;	/* packets pending */
D
Daniel Wagner 已提交
550 551 552
	/*
	 * Only radios in the same group can communicate together (the
	 * channel has to match too). Each bit represents a group. A
553
	 * radio can be in more than one group.
D
Daniel Wagner 已提交
554 555
	 */
	u64 group;
556

557 558
	/* group shared by radios created in the same netns */
	int netgroup;
559 560
	/* wmediumd portid responsible for netgroup of this radio */
	u32 wmediumd;
561

562
	/* difference between this hw's clock and the real clock, in usecs */
563
	s64 tsf_offset;
564
	s64 bcn_delta;
565 566
	/* absolute beacon transmission time. Used to cover up "tx" delay. */
	u64 abs_bcn_ts;
567 568 569 570 571 572 573 574

	/* Stats */
	u64 tx_pkts;
	u64 rx_pkts;
	u64 tx_bytes;
	u64 rx_bytes;
	u64 tx_dropped;
	u64 tx_failed;
575 576 577 578 579
};


struct hwsim_radiotap_hdr {
	struct ieee80211_radiotap_header hdr;
580
	__le64 rt_tsft;
581 582 583 584
	u8 rt_flags;
	u8 rt_rate;
	__le16 rt_channel;
	__le16 rt_chbitmask;
585
} __packed;
586

587 588 589 590 591 592 593 594
struct hwsim_radiotap_ack_hdr {
	struct ieee80211_radiotap_header hdr;
	u8 rt_flags;
	u8 pad;
	__le16 rt_channel;
	__le16 rt_chbitmask;
} __packed;

595 596
/* MAC80211_HWSIM netlink family */
static struct genl_family hwsim_genl_family;
597

598 599 600 601 602 603 604 605
enum hwsim_multicast_groups {
	HWSIM_MCGRP_CONFIG,
};

static const struct genl_multicast_group hwsim_mcgrps[] = {
	[HWSIM_MCGRP_CONFIG] = { .name = "config", },
};

606 607
/* MAC80211_HWSIM netlink policy */

608
static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
609 610
	[HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
	[HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
611 612 613 614 615 616
	[HWSIM_ATTR_FRAME] = { .type = NLA_BINARY,
			       .len = IEEE80211_MAX_DATA_LEN },
	[HWSIM_ATTR_FLAGS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 },
	[HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 },
	[HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC,
617 618
				 .len = IEEE80211_TX_MAX_RATES *
					sizeof(struct hwsim_tx_rate)},
619
	[HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
620 621
	[HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
	[HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
622 623 624
	[HWSIM_ATTR_REG_HINT_ALPHA2] = { .type = NLA_STRING, .len = 2 },
	[HWSIM_ATTR_REG_CUSTOM_REG] = { .type = NLA_U32 },
	[HWSIM_ATTR_REG_STRICT_REG] = { .type = NLA_FLAG },
625
	[HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
626
	[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE] = { .type = NLA_FLAG },
627 628 629
	[HWSIM_ATTR_RADIO_NAME] = { .type = NLA_STRING },
	[HWSIM_ATTR_NO_VIF] = { .type = NLA_FLAG },
	[HWSIM_ATTR_FREQ] = { .type = NLA_U32 },
630
};
631

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan);

/* sysfs attributes */
static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = dat;
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	struct sk_buff *skb;
	struct ieee80211_pspoll *pspoll;

	if (!vp->assoc)
		return;

647 648 649
	wiphy_dbg(data->hw->wiphy,
		  "%s: send PS-Poll to %pM for aid %d\n",
		  __func__, vp->bssid, vp->aid);
650 651 652 653

	skb = dev_alloc_skb(sizeof(*pspoll));
	if (!skb)
		return;
654
	pspoll = skb_put(skb, sizeof(*pspoll));
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
	pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
					    IEEE80211_STYPE_PSPOLL |
					    IEEE80211_FCTL_PM);
	pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
	memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
	memcpy(pspoll->ta, mac, ETH_ALEN);

	rcu_read_lock();
	mac80211_hwsim_tx_frame(data->hw, skb,
				rcu_dereference(vif->chanctx_conf)->def.chan);
	rcu_read_unlock();
}

static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
				struct ieee80211_vif *vif, int ps)
{
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
	struct sk_buff *skb;
	struct ieee80211_hdr *hdr;

	if (!vp->assoc)
		return;

678 679 680
	wiphy_dbg(data->hw->wiphy,
		  "%s: send data::nullfunc to %pM ps=%d\n",
		  __func__, vp->bssid, ps);
681 682 683 684

	skb = dev_alloc_skb(sizeof(*hdr));
	if (!skb)
		return;
685
	hdr = skb_put(skb, sizeof(*hdr) - ETH_ALEN);
686 687
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
					 IEEE80211_STYPE_NULLFUNC |
688
					 IEEE80211_FCTL_TODS |
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
					 (ps ? IEEE80211_FCTL_PM : 0));
	hdr->duration_id = cpu_to_le16(0);
	memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
	memcpy(hdr->addr2, mac, ETH_ALEN);
	memcpy(hdr->addr3, vp->bssid, ETH_ALEN);

	rcu_read_lock();
	mac80211_hwsim_tx_frame(data->hw, skb,
				rcu_dereference(vif->chanctx_conf)->def.chan);
	rcu_read_unlock();
}


static void hwsim_send_nullfunc_ps(void *dat, u8 *mac,
				   struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = dat;
	hwsim_send_nullfunc(data, mac, vif, 1);
}

static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac,
				      struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = dat;
	hwsim_send_nullfunc(data, mac, vif, 0);
}

static int hwsim_fops_ps_read(void *dat, u64 *val)
{
	struct mac80211_hwsim_data *data = dat;
	*val = data->ps;
	return 0;
}

static int hwsim_fops_ps_write(void *dat, u64 val)
{
	struct mac80211_hwsim_data *data = dat;
	enum ps_mode old_ps;

	if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL &&
	    val != PS_MANUAL_POLL)
		return -EINVAL;

	old_ps = data->ps;
	data->ps = val;

735
	local_bh_disable();
736
	if (val == PS_MANUAL_POLL) {
737 738 739
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_ps_poll, data);
740 741
		data->ps_poll_pending = true;
	} else if (old_ps == PS_DISABLED && val != PS_DISABLED) {
742 743 744
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_nullfunc_ps, data);
745
	} else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
746 747 748
		ieee80211_iterate_active_interfaces_atomic(
			data->hw, IEEE80211_IFACE_ITER_NORMAL,
			hwsim_send_nullfunc_no_ps, data);
749
	}
750
	local_bh_enable();
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787

	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
			"%llu\n");

static int hwsim_write_simulate_radar(void *dat, u64 val)
{
	struct mac80211_hwsim_data *data = dat;

	ieee80211_radar_detected(data->hw);

	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(hwsim_simulate_radar, NULL,
			hwsim_write_simulate_radar, "%llu\n");

static int hwsim_fops_group_read(void *dat, u64 *val)
{
	struct mac80211_hwsim_data *data = dat;
	*val = data->group;
	return 0;
}

static int hwsim_fops_group_write(void *dat, u64 val)
{
	struct mac80211_hwsim_data *data = dat;
	data->group = val;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_group,
			hwsim_fops_group_read, hwsim_fops_group_write,
			"%llx\n");

788 789
static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
					struct net_device *dev)
790 791 792
{
	/* TODO: allow packet injection */
	dev_kfree_skb(skb);
793
	return NETDEV_TX_OK;
794 795
}

796 797 798 799 800
static inline u64 mac80211_hwsim_get_tsf_raw(void)
{
	return ktime_to_us(ktime_get_real());
}

801 802
static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
{
803
	u64 now = mac80211_hwsim_get_tsf_raw();
804 805
	return cpu_to_le64(now + data->tsf_offset);
}
806

807
static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
808
				  struct ieee80211_vif *vif)
809 810 811 812 813 814 815 816 817
{
	struct mac80211_hwsim_data *data = hw->priv;
	return le64_to_cpu(__mac80211_hwsim_get_tsf(data));
}

static void mac80211_hwsim_set_tsf(struct ieee80211_hw *hw,
		struct ieee80211_vif *vif, u64 tsf)
{
	struct mac80211_hwsim_data *data = hw->priv;
818
	u64 now = mac80211_hwsim_get_tsf(hw, vif);
819
	u32 bcn_int = data->beacon_int;
A
Andrew Morton 已提交
820
	u64 delta = abs(tsf - now);
821

822
	/* adjust after beaconing with new timestamp at old TBTT */
823 824 825 826 827
	if (tsf > now) {
		data->tsf_offset += delta;
		data->bcn_delta = do_div(delta, bcn_int);
	} else {
		data->tsf_offset -= delta;
828
		data->bcn_delta = -(s64)do_div(delta, bcn_int);
829
	}
830 831
}

832
static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
833 834
				      struct sk_buff *tx_skb,
				      struct ieee80211_channel *chan)
835 836 837 838 839 840 841 842
{
	struct mac80211_hwsim_data *data = hw->priv;
	struct sk_buff *skb;
	struct hwsim_radiotap_hdr *hdr;
	u16 flags;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
	struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);

843 844 845
	if (WARN_ON(!txrate))
		return;

846 847 848 849 850 851 852
	if (!netif_running(hwsim_mon))
		return;

	skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC);
	if (skb == NULL)
		return;

853
	hdr = skb_push(skb, sizeof(*hdr));
854 855 856
	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	hdr->hdr.it_pad = 0;
	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
J
Jouni Malinen 已提交
857 858
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_RATE) |
859
					  (1 << IEEE80211_RADIOTAP_TSFT) |
J
Jouni Malinen 已提交
860
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
861
	hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
862 863
	hdr->rt_flags = 0;
	hdr->rt_rate = txrate->bitrate / 5;
864
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
865 866 867 868 869 870 871 872
	flags = IEEE80211_CHAN_2GHZ;
	if (txrate->flags & IEEE80211_RATE_ERP_G)
		flags |= IEEE80211_CHAN_OFDM;
	else
		flags |= IEEE80211_CHAN_CCK;
	hdr->rt_chbitmask = cpu_to_le16(flags);

	skb->dev = hwsim_mon;
873
	skb_reset_mac_header(skb);
874 875
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
J
Jouni Malinen 已提交
876
	skb->protocol = htons(ETH_P_802_2);
877 878 879 880 881
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}


882 883
static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
				       const u8 *addr)
884 885
{
	struct sk_buff *skb;
886
	struct hwsim_radiotap_ack_hdr *hdr;
887 888 889 890 891 892 893 894 895 896
	u16 flags;
	struct ieee80211_hdr *hdr11;

	if (!netif_running(hwsim_mon))
		return;

	skb = dev_alloc_skb(100);
	if (skb == NULL)
		return;

897
	hdr = skb_put(skb, sizeof(*hdr));
898 899 900 901 902 903
	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	hdr->hdr.it_pad = 0;
	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
					  (1 << IEEE80211_RADIOTAP_CHANNEL));
	hdr->rt_flags = 0;
904
	hdr->pad = 0;
905
	hdr->rt_channel = cpu_to_le16(chan->center_freq);
906 907 908
	flags = IEEE80211_CHAN_2GHZ;
	hdr->rt_chbitmask = cpu_to_le16(flags);

909
	hdr11 = skb_put(skb, 10);
910 911 912 913 914 915
	hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
					   IEEE80211_STYPE_ACK);
	hdr11->duration_id = cpu_to_le16(0);
	memcpy(hdr11->addr1, addr, ETH_ALEN);

	skb->dev = hwsim_mon;
916
	skb_reset_mac_header(skb);
917 918 919 920 921 922 923
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
	skb->protocol = htons(ETH_P_802_2);
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}

924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
struct mac80211_hwsim_addr_match_data {
	u8 addr[ETH_ALEN];
	bool ret;
};

static void mac80211_hwsim_addr_iter(void *data, u8 *mac,
				     struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_addr_match_data *md = data;

	if (memcmp(mac, md->addr, ETH_ALEN) == 0)
		md->ret = true;
}

static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data,
				      const u8 *addr)
{
	struct mac80211_hwsim_addr_match_data md = {
		.ret = false,
	};

945 946 947
	if (data->scanning && memcmp(addr, data->scan_addr, ETH_ALEN) == 0)
		return true;

948 949 950 951 952 953 954 955 956
	memcpy(md.addr, addr, ETH_ALEN);

	ieee80211_iterate_active_interfaces_atomic(data->hw,
						   IEEE80211_IFACE_ITER_NORMAL,
						   mac80211_hwsim_addr_iter,
						   &md);

	return md.ret;
}
957

958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
			   struct sk_buff *skb)
{
	switch (data->ps) {
	case PS_DISABLED:
		return true;
	case PS_ENABLED:
		return false;
	case PS_AUTO_POLL:
		/* TODO: accept (some) Beacons by default and other frames only
		 * if pending PS-Poll has been sent */
		return true;
	case PS_MANUAL_POLL:
		/* Allow unicast frames to own address if there is a pending
		 * PS-Poll */
		if (data->ps_poll_pending &&
974
		    mac80211_hwsim_addr_match(data, skb->data + 4)) {
975 976 977 978 979 980 981 982 983
			data->ps_poll_pending = false;
			return true;
		}
		return false;
	}

	return true;
}

984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
static int hwsim_unicast_netgroup(struct mac80211_hwsim_data *data,
				  struct sk_buff *skb, int portid)
{
	struct net *net;
	bool found = false;
	int res = -ENOENT;

	rcu_read_lock();
	for_each_net_rcu(net) {
		if (data->netgroup == hwsim_net_get_netgroup(net)) {
			res = genlmsg_unicast(net, skb, portid);
			found = true;
			break;
		}
	}
	rcu_read_unlock();

	if (!found)
		nlmsg_free(skb);

	return res;
}

1007 1008
static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
				       struct sk_buff *my_skb,
1009
				       int dst_portid)
1010 1011 1012 1013 1014 1015 1016 1017 1018
{
	struct sk_buff *skb;
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
	void *msg_head;
	unsigned int hwsim_flags = 0;
	int i;
	struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];
1019
	uintptr_t cookie;
1020 1021 1022 1023 1024 1025

	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
	/* If the queue contains MAX_QUEUE skb's drop some */
	if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
		/* Droping until WARN_QUEUE level */
1026
		while (skb_queue_len(&data->pending) >= WARN_QUEUE) {
1027
			ieee80211_free_txskb(hw, skb_dequeue(&data->pending));
1028 1029
			data->tx_dropped++;
		}
1030 1031
	}

1032
	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1033 1034 1035 1036 1037 1038
	if (skb == NULL)
		goto nla_put_failure;

	msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
			       HWSIM_CMD_FRAME);
	if (msg_head == NULL) {
1039
		pr_debug("mac80211_hwsim: problem with msg_head\n");
1040 1041 1042
		goto nla_put_failure;
	}

1043 1044
	if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
		    ETH_ALEN, data->addresses[1].addr))
1045
		goto nla_put_failure;
1046

1047
	/* We get the skb->data */
1048 1049
	if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
		goto nla_put_failure;
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059

	/* We get the flags for this transmission, and we translate them to
	   wmediumd flags  */

	if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
		hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS;

	if (info->flags & IEEE80211_TX_CTL_NO_ACK)
		hwsim_flags |= HWSIM_TX_CTL_NO_ACK;

1060 1061
	if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
		goto nla_put_failure;
1062

1063 1064 1065
	if (nla_put_u32(skb, HWSIM_ATTR_FREQ, data->channel->center_freq))
		goto nla_put_failure;

1066 1067 1068 1069 1070 1071 1072
	/* We get the tx control (rate and retries) info*/

	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
		tx_attempts[i].idx = info->status.rates[i].idx;
		tx_attempts[i].count = info->status.rates[i].count;
	}

1073 1074 1075 1076
	if (nla_put(skb, HWSIM_ATTR_TX_INFO,
		    sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
		    tx_attempts))
		goto nla_put_failure;
1077 1078

	/* We create a cookie to identify this skb */
1079 1080 1081
	data->pending_cookie++;
	cookie = data->pending_cookie;
	info->rate_driver_data[0] = (void *)cookie;
1082
	if (nla_put_u64_64bit(skb, HWSIM_ATTR_COOKIE, cookie, HWSIM_ATTR_PAD))
1083
		goto nla_put_failure;
1084 1085

	genlmsg_end(skb, msg_head);
1086
	if (hwsim_unicast_netgroup(data, skb, dst_portid))
1087
		goto err_free_txskb;
1088 1089 1090

	/* Enqueue the packet */
	skb_queue_tail(&data->pending, my_skb);
1091 1092
	data->tx_pkts++;
	data->tx_bytes += my_skb->len;
1093 1094 1095
	return;

nla_put_failure:
1096 1097
	nlmsg_free(skb);
err_free_txskb:
1098
	pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
1099
	ieee80211_free_txskb(hw, my_skb);
1100
	data->tx_failed++;
1101 1102
}

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
static bool hwsim_chans_compat(struct ieee80211_channel *c1,
			       struct ieee80211_channel *c2)
{
	if (!c1 || !c2)
		return false;

	return c1->center_freq == c2->center_freq;
}

struct tx_iter_data {
	struct ieee80211_channel *channel;
	bool receive;
};

static void mac80211_hwsim_tx_iter(void *_data, u8 *addr,
				   struct ieee80211_vif *vif)
{
	struct tx_iter_data *data = _data;

	if (!vif->chanctx_conf)
		return;

	if (!hwsim_chans_compat(data->channel,
1126
				rcu_dereference(vif->chanctx_conf)->def.chan))
1127 1128 1129 1130 1131
		return;

	data->receive = true;
}

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
static void mac80211_hwsim_add_vendor_rtap(struct sk_buff *skb)
{
	/*
	 * To enable this code, #define the HWSIM_RADIOTAP_OUI,
	 * e.g. like this:
	 * #define HWSIM_RADIOTAP_OUI "\x02\x00\x00"
	 * (but you should use a valid OUI, not that)
	 *
	 * If anyone wants to 'donate' a radiotap OUI/subns code
	 * please send a patch removing this #ifdef and changing
	 * the values accordingly.
	 */
#ifdef HWSIM_RADIOTAP_OUI
	struct ieee80211_vendor_radiotap *rtap;

	/*
	 * Note that this code requires the headroom in the SKB
	 * that was allocated earlier.
	 */
1151
	rtap = skb_push(skb, sizeof(*rtap) + 8 + 4);
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
	rtap->oui[0] = HWSIM_RADIOTAP_OUI[0];
	rtap->oui[1] = HWSIM_RADIOTAP_OUI[1];
	rtap->oui[2] = HWSIM_RADIOTAP_OUI[2];
	rtap->subns = 127;

	/*
	 * Radiotap vendor namespaces can (and should) also be
	 * split into fields by using the standard radiotap
	 * presence bitmap mechanism. Use just BIT(0) here for
	 * the presence bitmap.
	 */
	rtap->present = BIT(0);
	/* We have 8 bytes of (dummy) data */
	rtap->len = 8;
	/* For testing, also require it to be aligned */
	rtap->align = 8;
	/* And also test that padding works, 4 bytes */
	rtap->pad = 4;
	/* push the data */
	memcpy(rtap->data, "ABCDEFGH", 8);
	/* make sure to clear padding, mac80211 doesn't */
	memset(rtap->data + 8, 0, 4);

	IEEE80211_SKB_RXCB(skb)->flag |= RX_FLAG_RADIOTAP_VENDOR_DATA;
#endif
}

1179
static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
1180 1181
					  struct sk_buff *skb,
					  struct ieee80211_channel *chan)
1182
{
1183 1184
	struct mac80211_hwsim_data *data = hw->priv, *data2;
	bool ack = false;
1185
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1186
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1187
	struct ieee80211_rx_status rx_status;
1188
	u64 now;
1189 1190

	memset(&rx_status, 0, sizeof(rx_status));
1191
	rx_status.flag |= RX_FLAG_MACTIME_START;
1192 1193
	rx_status.freq = chan->center_freq;
	rx_status.band = chan->band;
1194 1195 1196
	if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
		rx_status.rate_idx =
			ieee80211_rate_get_vht_mcs(&info->control.rates[0]);
1197
		rx_status.nss =
1198
			ieee80211_rate_get_vht_nss(&info->control.rates[0]);
1199
		rx_status.encoding = RX_ENC_VHT;
1200 1201 1202
	} else {
		rx_status.rate_idx = info->control.rates[0].idx;
		if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
1203
			rx_status.encoding = RX_ENC_HT;
1204
	}
1205
	if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
1206 1207 1208 1209 1210 1211 1212
		rx_status.bw = RATE_INFO_BW_40;
	else if (info->control.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
		rx_status.bw = RATE_INFO_BW_80;
	else if (info->control.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
		rx_status.bw = RATE_INFO_BW_160;
	else
		rx_status.bw = RATE_INFO_BW_20;
1213
	if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
1214
		rx_status.enc_flags |= RX_ENC_FLAG_SHORT_GI;
1215
	/* TODO: simulate real signal strength (and optional packet loss) */
1216 1217 1218
	rx_status.signal = -50;
	if (info->control.vif)
		rx_status.signal += info->control.vif->bss_conf.txpower;
1219

1220 1221 1222
	if (data->ps != PS_DISABLED)
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);

1223 1224
	/* release the skb's source info */
	skb_orphan(skb);
1225
	skb_dst_drop(skb);
1226 1227 1228 1229
	skb->mark = 0;
	secpath_reset(skb);
	nf_reset(skb);

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
	/*
	 * Get absolute mactime here so all HWs RX at the "same time", and
	 * absolute TX time for beacon mactime so the timestamp matches.
	 * Giving beacons a different mactime than non-beacons looks messy, but
	 * it helps the Toffset be exact and a ~10us mactime discrepancy
	 * probably doesn't really matter.
	 */
	if (ieee80211_is_beacon(hdr->frame_control) ||
	    ieee80211_is_probe_resp(hdr->frame_control))
		now = data->abs_bcn_ts;
	else
		now = mac80211_hwsim_get_tsf_raw();

1243
	/* Copy skb to all enabled radios that are on the current frequency */
1244 1245
	spin_lock(&hwsim_radio_lock);
	list_for_each_entry(data2, &hwsim_radios, list) {
1246
		struct sk_buff *nskb;
1247 1248 1249 1250
		struct tx_iter_data tx_iter_data = {
			.receive = false,
			.channel = chan,
		};
1251

1252
		if (data == data2)
1253
			continue;
1254

1255 1256
		if (!data2->started || (data2->idle && !data2->tmp_chan) ||
		    !hwsim_ps_rx_ok(data2, skb))
1257 1258
			continue;

1259 1260 1261
		if (!(data->group & data2->group))
			continue;

1262 1263 1264
		if (data->netgroup != data2->netgroup)
			continue;

1265 1266 1267
		if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
		    !hwsim_chans_compat(chan, data2->channel)) {
			ieee80211_iterate_active_interfaces_atomic(
1268 1269
				data2->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_tx_iter, &tx_iter_data);
1270 1271 1272 1273
			if (!tx_iter_data.receive)
				continue;
		}

1274 1275 1276 1277
		/*
		 * reserve some space for our vendor and the normal
		 * radiotap header, since we're copying anyway
		 */
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		if (skb->len < PAGE_SIZE && paged_rx) {
			struct page *page = alloc_page(GFP_ATOMIC);

			if (!page)
				continue;

			nskb = dev_alloc_skb(128);
			if (!nskb) {
				__free_page(page);
				continue;
			}

			memcpy(page_address(page), skb->data, skb->len);
			skb_add_rx_frag(nskb, 0, page, 0, skb->len, skb->len);
		} else {
			nskb = skb_copy(skb, GFP_ATOMIC);
			if (!nskb)
				continue;
		}
1297

1298
		if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1299
			ack = true;
1300

1301
		rx_status.mactime = now + data2->tsf_offset;
1302

1303
		memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
1304 1305 1306

		mac80211_hwsim_add_vendor_rtap(nskb);

1307 1308
		data2->rx_pkts++;
		data2->rx_bytes += nskb->len;
1309
		ieee80211_rx_irqsafe(data2->hw, nskb);
1310
	}
1311
	spin_unlock(&hwsim_radio_lock);
1312

1313 1314 1315
	return ack;
}

1316 1317 1318
static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
			      struct ieee80211_tx_control *control,
			      struct sk_buff *skb)
1319
{
1320 1321
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
1322
	struct ieee80211_hdr *hdr = (void *)skb->data;
1323 1324
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_channel *channel;
1325
	bool ack;
1326
	u32 _portid;
1327

1328
	if (WARN_ON(skb->len < 10)) {
1329
		/* Should not happen; just a sanity check for addr1 use */
1330
		ieee80211_free_txskb(hw, skb);
1331
		return;
1332 1333
	}

1334
	if (!data->use_chanctx) {
1335 1336 1337 1338 1339 1340
		channel = data->channel;
	} else if (txi->hw_queue == 4) {
		channel = data->tmp_chan;
	} else {
		chanctx_conf = rcu_dereference(txi->control.vif->chanctx_conf);
		if (chanctx_conf)
1341
			channel = chanctx_conf->def.chan;
1342 1343 1344 1345 1346
		else
			channel = NULL;
	}

	if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1347
		ieee80211_free_txskb(hw, skb);
1348 1349 1350 1351
		return;
	}

	if (data->idle && !data->tmp_chan) {
1352
		wiphy_dbg(hw->wiphy, "Trying to TX when idle - reject\n");
1353
		ieee80211_free_txskb(hw, skb);
1354 1355 1356 1357 1358 1359 1360 1361
		return;
	}

	if (txi->control.vif)
		hwsim_check_magic(txi->control.vif);
	if (control->sta)
		hwsim_check_sta_magic(control->sta);

1362
	if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1363 1364 1365
		ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
1366

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	if (skb->len >= 24 + 8 &&
	    ieee80211_is_probe_resp(hdr->frame_control)) {
		/* fake header transmission time */
		struct ieee80211_mgmt *mgmt;
		struct ieee80211_rate *txrate;
		u64 ts;

		mgmt = (struct ieee80211_mgmt *)skb->data;
		txrate = ieee80211_get_tx_rate(hw, txi);
		ts = mac80211_hwsim_get_tsf_raw();
		mgmt->u.probe_resp.timestamp =
			cpu_to_le64(ts + data->tsf_offset +
				    24 * 8 * 10 / txrate->bitrate);
	}

1382 1383
	mac80211_hwsim_monitor_rx(hw, skb, channel);

1384
	/* wmediumd mode check */
1385
	_portid = READ_ONCE(data->wmediumd);
1386

1387 1388
	if (_portid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1389 1390

	/* NO wmediumd detected, perfect medium simulation */
1391 1392
	data->tx_pkts++;
	data->tx_bytes += skb->len;
1393
	ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1394

1395
	if (ack && skb->len >= 16)
1396
		mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1397

1398
	ieee80211_tx_info_clear_status(txi);
1399 1400 1401 1402 1403

	/* frame was transmitted at most favorable rate at first attempt */
	txi->control.rates[0].count = 1;
	txi->control.rates[1].idx = -1;

1404 1405
	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
		txi->flags |= IEEE80211_TX_STAT_ACK;
1406 1407 1408 1409 1410 1411 1412
	ieee80211_tx_status_irqsafe(hw, skb);
}


static int mac80211_hwsim_start(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1413
	wiphy_dbg(hw->wiphy, "%s\n", __func__);
1414
	data->started = true;
1415 1416 1417 1418 1419 1420 1421
	return 0;
}


static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *data = hw->priv;
1422
	data->started = false;
T
Thomas Pedersen 已提交
1423
	tasklet_hrtimer_cancel(&data->beacon_timer);
1424
	wiphy_dbg(hw->wiphy, "%s\n", __func__);
1425 1426 1427 1428
}


static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1429
					struct ieee80211_vif *vif)
1430
{
1431 1432 1433
	wiphy_dbg(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
		  __func__, ieee80211_vif_type_p2p(vif),
		  vif->addr);
1434
	hwsim_set_magic(vif);
1435 1436 1437 1438 1439 1440 1441

	vif->cab_queue = 0;
	vif->hw_queue[IEEE80211_AC_VO] = 0;
	vif->hw_queue[IEEE80211_AC_VI] = 1;
	vif->hw_queue[IEEE80211_AC_BE] = 2;
	vif->hw_queue[IEEE80211_AC_BK] = 3;

1442 1443 1444 1445
	return 0;
}


1446 1447
static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
1448 1449
					   enum nl80211_iftype newtype,
					   bool newp2p)
1450
{
1451
	newtype = ieee80211_iftype_p2p(newtype, newp2p);
1452 1453 1454
	wiphy_dbg(hw->wiphy,
		  "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
		  __func__, ieee80211_vif_type_p2p(vif),
1455
		    newtype, vif->addr);
1456 1457
	hwsim_check_magic(vif);

1458 1459 1460 1461 1462 1463
	/*
	 * interface may change from non-AP to AP in
	 * which case this needs to be set up again
	 */
	vif->cab_queue = 0;

1464 1465 1466
	return 0;
}

1467
static void mac80211_hwsim_remove_interface(
1468
	struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1469
{
1470 1471 1472
	wiphy_dbg(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
		  __func__, ieee80211_vif_type_p2p(vif),
		  vif->addr);
1473 1474
	hwsim_check_magic(vif);
	hwsim_clear_magic(vif);
1475 1476
}

1477 1478 1479 1480
static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
				    struct sk_buff *skb,
				    struct ieee80211_channel *chan)
{
1481
	struct mac80211_hwsim_data *data = hw->priv;
1482
	u32 _pid = READ_ONCE(data->wmediumd);
1483

1484
	if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE)) {
1485 1486 1487 1488 1489 1490
		struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
		ieee80211_get_tx_rates(txi->control.vif, NULL, skb,
				       txi->control.rates,
				       ARRAY_SIZE(txi->control.rates));
	}

1491 1492 1493 1494 1495 1496 1497 1498
	mac80211_hwsim_monitor_rx(hw, skb, chan);

	if (_pid)
		return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);

	mac80211_hwsim_tx_frame_no_nl(hw, skb, chan);
	dev_kfree_skb(skb);
}
1499 1500 1501 1502

static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
				     struct ieee80211_vif *vif)
{
1503 1504 1505 1506 1507
	struct mac80211_hwsim_data *data = arg;
	struct ieee80211_hw *hw = data->hw;
	struct ieee80211_tx_info *info;
	struct ieee80211_rate *txrate;
	struct ieee80211_mgmt *mgmt;
1508 1509
	struct sk_buff *skb;

1510 1511
	hwsim_check_magic(vif);

1512
	if (vif->type != NL80211_IFTYPE_AP &&
1513 1514
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_ADHOC)
1515 1516 1517 1518 1519
		return;

	skb = ieee80211_beacon_get(hw, vif);
	if (skb == NULL)
		return;
1520
	info = IEEE80211_SKB_CB(skb);
1521
	if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1522 1523 1524 1525
		ieee80211_get_tx_rates(vif, NULL, skb,
				       info->control.rates,
				       ARRAY_SIZE(info->control.rates));

1526 1527 1528 1529 1530 1531 1532 1533
	txrate = ieee80211_get_tx_rate(hw, info);

	mgmt = (struct ieee80211_mgmt *) skb->data;
	/* fake header transmission time */
	data->abs_bcn_ts = mac80211_hwsim_get_tsf_raw();
	mgmt->u.beacon.timestamp = cpu_to_le64(data->abs_bcn_ts +
					       data->tsf_offset +
					       24 * 8 * 10 / txrate->bitrate);
1534

1535
	mac80211_hwsim_tx_frame(hw, skb,
1536
				rcu_dereference(vif->chanctx_conf)->def.chan);
1537 1538 1539

	if (vif->csa_active && ieee80211_csa_is_complete(vif))
		ieee80211_csa_finish(vif);
1540 1541
}

T
Thomas Pedersen 已提交
1542 1543
static enum hrtimer_restart
mac80211_hwsim_beacon(struct hrtimer *timer)
1544
{
T
Thomas Pedersen 已提交
1545 1546 1547 1548 1549 1550
	struct mac80211_hwsim_data *data =
		container_of(timer, struct mac80211_hwsim_data,
			     beacon_timer.timer);
	struct ieee80211_hw *hw = data->hw;
	u64 bcn_int = data->beacon_int;
	ktime_t next_bcn;
1551

1552
	if (!data->started)
T
Thomas Pedersen 已提交
1553
		goto out;
1554

J
Jouni Malinen 已提交
1555
	ieee80211_iterate_active_interfaces_atomic(
1556
		hw, IEEE80211_IFACE_ITER_NORMAL,
1557
		mac80211_hwsim_beacon_tx, data);
1558

1559 1560 1561 1562 1563 1564
	/* beacon at new TBTT + beacon interval */
	if (data->bcn_delta) {
		bcn_int -= data->bcn_delta;
		data->bcn_delta = 0;
	}

T
Thomas Pedersen 已提交
1565 1566 1567 1568 1569
	next_bcn = ktime_add(hrtimer_get_expires(timer),
			     ns_to_ktime(bcn_int * 1000));
	tasklet_hrtimer_start(&data->beacon_timer, next_bcn, HRTIMER_MODE_ABS);
out:
	return HRTIMER_NORESTART;
1570 1571
}

1572 1573 1574 1575 1576 1577 1578
static const char * const hwsim_chanwidths[] = {
	[NL80211_CHAN_WIDTH_20_NOHT] = "noht",
	[NL80211_CHAN_WIDTH_20] = "ht20",
	[NL80211_CHAN_WIDTH_40] = "ht40",
	[NL80211_CHAN_WIDTH_80] = "vht80",
	[NL80211_CHAN_WIDTH_80P80] = "vht80p80",
	[NL80211_CHAN_WIDTH_160] = "vht160",
1579
};
1580

1581
static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1582 1583
{
	struct mac80211_hwsim_data *data = hw->priv;
1584
	struct ieee80211_conf *conf = &hw->conf;
1585 1586 1587 1588 1589 1590
	static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
		[IEEE80211_SMPS_AUTOMATIC] = "auto",
		[IEEE80211_SMPS_OFF] = "off",
		[IEEE80211_SMPS_STATIC] = "static",
		[IEEE80211_SMPS_DYNAMIC] = "dynamic",
	};
1591
	int idx;
1592

1593
	if (conf->chandef.chan)
1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
		wiphy_dbg(hw->wiphy,
			  "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n",
			  __func__,
			  conf->chandef.chan->center_freq,
			  conf->chandef.center_freq1,
			  conf->chandef.center_freq2,
			  hwsim_chanwidths[conf->chandef.width],
			  !!(conf->flags & IEEE80211_CONF_IDLE),
			  !!(conf->flags & IEEE80211_CONF_PS),
			  smps_modes[conf->smps_mode]);
1604
	else
1605 1606 1607 1608 1609 1610
		wiphy_dbg(hw->wiphy,
			  "%s (freq=0 idle=%d ps=%d smps=%s)\n",
			  __func__,
			  !!(conf->flags & IEEE80211_CONF_IDLE),
			  !!(conf->flags & IEEE80211_CONF_PS),
			  smps_modes[conf->smps_mode]);
1611

1612 1613
	data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);

1614
	WARN_ON(conf->chandef.chan && data->use_chanctx);
1615

1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
	mutex_lock(&data->mutex);
	if (data->scanning && conf->chandef.chan) {
		for (idx = 0; idx < ARRAY_SIZE(data->survey_data); idx++) {
			if (data->survey_data[idx].channel == data->channel) {
				data->survey_data[idx].start =
					data->survey_data[idx].next_start;
				data->survey_data[idx].end = jiffies;
				break;
			}
		}

		data->channel = conf->chandef.chan;
1628

1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
		for (idx = 0; idx < ARRAY_SIZE(data->survey_data); idx++) {
			if (data->survey_data[idx].channel &&
			    data->survey_data[idx].channel != data->channel)
				continue;
			data->survey_data[idx].channel = data->channel;
			data->survey_data[idx].next_start = jiffies;
			break;
		}
	} else {
		data->channel = conf->chandef.chan;
	}
	mutex_unlock(&data->mutex);
1641

1642
	if (!data->started || !data->beacon_int)
T
Thomas Pedersen 已提交
1643 1644
		tasklet_hrtimer_cancel(&data->beacon_timer);
	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {
1645 1646 1647 1648
		u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);
		u32 bcn_int = data->beacon_int;
		u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);

T
Thomas Pedersen 已提交
1649
		tasklet_hrtimer_start(&data->beacon_timer,
1650
				      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1651 1652
				      HRTIMER_MODE_REL);
	}
1653 1654 1655 1656 1657 1658 1659

	return 0;
}


static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
					    unsigned int changed_flags,
1660
					    unsigned int *total_flags,u64 multicast)
1661 1662 1663
{
	struct mac80211_hwsim_data *data = hw->priv;

1664
	wiphy_dbg(hw->wiphy, "%s\n", __func__);
1665 1666 1667 1668 1669 1670 1671 1672

	data->rx_filter = 0;
	if (*total_flags & FIF_ALLMULTI)
		data->rx_filter |= FIF_ALLMULTI;

	*total_flags = data->rx_filter;
}

1673 1674 1675 1676 1677 1678 1679 1680 1681 1682
static void mac80211_hwsim_bcn_en_iter(void *data, u8 *mac,
				       struct ieee80211_vif *vif)
{
	unsigned int *count = data;
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;

	if (vp->bcn_en)
		(*count)++;
}

1683 1684 1685 1686 1687
static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct ieee80211_bss_conf *info,
					    u32 changed)
{
1688
	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1689
	struct mac80211_hwsim_data *data = hw->priv;
1690

1691
	hwsim_check_magic(vif);
1692

1693 1694
	wiphy_dbg(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
		  __func__, changed, vif->addr);
1695

1696
	if (changed & BSS_CHANGED_BSSID) {
1697 1698
		wiphy_dbg(hw->wiphy, "%s: BSSID changed: %pM\n",
			  __func__, info->bssid);
1699 1700 1701
		memcpy(vp->bssid, info->bssid, ETH_ALEN);
	}

1702
	if (changed & BSS_CHANGED_ASSOC) {
1703 1704
		wiphy_dbg(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
			  info->assoc, info->aid);
1705 1706
		vp->assoc = info->assoc;
		vp->aid = info->aid;
1707 1708
	}

T
Thomas Pedersen 已提交
1709
	if (changed & BSS_CHANGED_BEACON_ENABLED) {
1710 1711
		wiphy_dbg(hw->wiphy, "  BCN EN: %d (BI=%u)\n",
			  info->enable_beacon, info->beacon_int);
1712
		vp->bcn_en = info->enable_beacon;
T
Thomas Pedersen 已提交
1713 1714 1715
		if (data->started &&
		    !hrtimer_is_queued(&data->beacon_timer.timer) &&
		    info->enable_beacon) {
1716 1717
			u64 tsf, until_tbtt;
			u32 bcn_int;
1718
			data->beacon_int = info->beacon_int * 1024;
1719 1720 1721
			tsf = mac80211_hwsim_get_tsf(hw, vif);
			bcn_int = data->beacon_int;
			until_tbtt = bcn_int - do_div(tsf, bcn_int);
T
Thomas Pedersen 已提交
1722
			tasklet_hrtimer_start(&data->beacon_timer,
1723
					      ns_to_ktime(until_tbtt * 1000),
T
Thomas Pedersen 已提交
1724
					      HRTIMER_MODE_REL);
1725 1726
		} else if (!info->enable_beacon) {
			unsigned int count = 0;
1727
			ieee80211_iterate_active_interfaces_atomic(
1728 1729
				data->hw, IEEE80211_IFACE_ITER_NORMAL,
				mac80211_hwsim_bcn_en_iter, &count);
1730 1731
			wiphy_dbg(hw->wiphy, "  beaconing vifs remaining: %u",
				  count);
1732
			if (count == 0) {
1733
				tasklet_hrtimer_cancel(&data->beacon_timer);
1734 1735
				data->beacon_int = 0;
			}
1736
		}
1737 1738
	}

1739
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1740 1741
		wiphy_dbg(hw->wiphy, "  ERP_CTS_PROT: %d\n",
			  info->use_cts_prot);
1742 1743 1744
	}

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1745 1746
		wiphy_dbg(hw->wiphy, "  ERP_PREAMBLE: %d\n",
			  info->use_short_preamble);
1747 1748 1749
	}

	if (changed & BSS_CHANGED_ERP_SLOT) {
1750
		wiphy_dbg(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1751 1752 1753
	}

	if (changed & BSS_CHANGED_HT) {
1754 1755
		wiphy_dbg(hw->wiphy, "  HT: op_mode=0x%x\n",
			  info->ht_operation_mode);
1756 1757 1758
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
1759 1760
		wiphy_dbg(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
			  (unsigned long long) info->basic_rates);
1761
	}
1762 1763

	if (changed & BSS_CHANGED_TXPOWER)
1764
		wiphy_dbg(hw->wiphy, "  TX Power: %d dBm\n", info->txpower);
1765 1766
}

1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
				  struct ieee80211_sta *sta)
{
	hwsim_check_magic(vif);
	hwsim_set_sta_magic(sta);

	return 0;
}

static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_sta *sta)
{
	hwsim_check_magic(vif);
	hwsim_clear_sta_magic(sta);

	return 0;
}

1787 1788
static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
1789 1790
				      enum sta_notify_cmd cmd,
				      struct ieee80211_sta *sta)
1791 1792
{
	hwsim_check_magic(vif);
1793

1794
	switch (cmd) {
1795 1796 1797 1798
	case STA_NOTIFY_SLEEP:
	case STA_NOTIFY_AWAKE:
		/* TODO: make good use of these flags */
		break;
1799 1800 1801
	default:
		WARN(1, "Invalid sta notify: %d\n", cmd);
		break;
1802 1803 1804 1805 1806 1807 1808 1809 1810
	}
}

static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
				  struct ieee80211_sta *sta,
				  bool set)
{
	hwsim_check_sta_magic(sta);
	return 0;
1811
}
1812

1813
static int mac80211_hwsim_conf_tx(
1814 1815
	struct ieee80211_hw *hw,
	struct ieee80211_vif *vif, u16 queue,
1816 1817
	const struct ieee80211_tx_queue_params *params)
{
1818 1819 1820 1821 1822
	wiphy_dbg(hw->wiphy,
		  "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n",
		  __func__, queue,
		  params->txop, params->cw_min,
		  params->cw_max, params->aifs);
1823 1824 1825
	return 0;
}

1826 1827
static int mac80211_hwsim_get_survey(struct ieee80211_hw *hw, int idx,
				     struct survey_info *survey)
1828
{
1829
	struct mac80211_hwsim_data *hwsim = hw->priv;
1830

1831
	if (idx < 0 || idx >= ARRAY_SIZE(hwsim->survey_data))
1832 1833
		return -ENOENT;

1834 1835 1836 1837 1838 1839
	mutex_lock(&hwsim->mutex);
	survey->channel = hwsim->survey_data[idx].channel;
	if (!survey->channel) {
		mutex_unlock(&hwsim->mutex);
		return -ENOENT;
	}
1840 1841

	/*
1842
	 * Magically conjured dummy values --- this is only ok for simulated hardware.
1843
	 *
1844 1845
	 * A real driver which cannot determine real values noise MUST NOT
	 * report any, especially not a magically conjured ones :-)
1846
	 */
1847 1848 1849
	survey->filled = SURVEY_INFO_NOISE_DBM |
			 SURVEY_INFO_TIME |
			 SURVEY_INFO_TIME_BUSY;
1850
	survey->noise = -92;
1851 1852 1853 1854 1855 1856
	survey->time =
		jiffies_to_msecs(hwsim->survey_data[idx].end -
				 hwsim->survey_data[idx].start);
	/* report 12.5% of channel time is used */
	survey->time_busy = survey->time/8;
	mutex_unlock(&hwsim->mutex);
1857 1858 1859 1860

	return 0;
}

1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
#ifdef CONFIG_NL80211_TESTMODE
/*
 * This section contains example code for using netlink
 * attributes with the testmode command in nl80211.
 */

/* These enums need to be kept in sync with userspace */
enum hwsim_testmode_attr {
	__HWSIM_TM_ATTR_INVALID	= 0,
	HWSIM_TM_ATTR_CMD	= 1,
	HWSIM_TM_ATTR_PS	= 2,

	/* keep last */
	__HWSIM_TM_ATTR_AFTER_LAST,
	HWSIM_TM_ATTR_MAX	= __HWSIM_TM_ATTR_AFTER_LAST - 1
};

enum hwsim_testmode_cmd {
	HWSIM_TM_CMD_SET_PS		= 0,
	HWSIM_TM_CMD_GET_PS		= 1,
1881 1882
	HWSIM_TM_CMD_STOP_QUEUES	= 2,
	HWSIM_TM_CMD_WAKE_QUEUES	= 3,
1883 1884 1885 1886 1887 1888 1889
};

static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = {
	[HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 },
	[HWSIM_TM_ATTR_PS] = { .type = NLA_U32 },
};

J
Johannes Berg 已提交
1890
static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1891
				       struct ieee80211_vif *vif,
J
Johannes Berg 已提交
1892
				       void *data, int len)
1893 1894 1895 1896 1897 1898 1899
{
	struct mac80211_hwsim_data *hwsim = hw->priv;
	struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1];
	struct sk_buff *skb;
	int err, ps;

	err = nla_parse(tb, HWSIM_TM_ATTR_MAX, data, len,
1900
			hwsim_testmode_policy, NULL);
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
	if (err)
		return err;

	if (!tb[HWSIM_TM_ATTR_CMD])
		return -EINVAL;

	switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) {
	case HWSIM_TM_CMD_SET_PS:
		if (!tb[HWSIM_TM_ATTR_PS])
			return -EINVAL;
		ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]);
		return hwsim_fops_ps_write(hwsim, ps);
	case HWSIM_TM_CMD_GET_PS:
		skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
						nla_total_size(sizeof(u32)));
		if (!skb)
			return -ENOMEM;
1918 1919
		if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
			goto nla_put_failure;
1920
		return cfg80211_testmode_reply(skb);
1921 1922 1923 1924 1925 1926
	case HWSIM_TM_CMD_STOP_QUEUES:
		ieee80211_stop_queues(hw);
		return 0;
	case HWSIM_TM_CMD_WAKE_QUEUES:
		ieee80211_wake_queues(hw);
		return 0;
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
	default:
		return -EOPNOTSUPP;
	}

 nla_put_failure:
	kfree_skb(skb);
	return -ENOBUFS;
}
#endif

1937 1938
static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
1939
				       struct ieee80211_ampdu_params *params)
1940
{
1941 1942 1943 1944
	struct ieee80211_sta *sta = params->sta;
	enum ieee80211_ampdu_mlme_action action = params->action;
	u16 tid = params->tid;

1945 1946 1947 1948
	switch (action) {
	case IEEE80211_AMPDU_TX_START:
		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
1949 1950 1951
	case IEEE80211_AMPDU_TX_STOP_CONT:
	case IEEE80211_AMPDU_TX_STOP_FLUSH:
	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
		break;
	case IEEE80211_AMPDU_TX_OPERATIONAL:
		break;
	case IEEE80211_AMPDU_RX_START:
	case IEEE80211_AMPDU_RX_STOP:
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

1966 1967 1968
static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 u32 queues, bool drop)
1969
{
1970
	/* Not implemented, queues only on kernel side */
1971 1972
}

1973
static void hw_scan_work(struct work_struct *work)
1974
{
1975 1976 1977 1978
	struct mac80211_hwsim_data *hwsim =
		container_of(work, struct mac80211_hwsim_data, hw_scan.work);
	struct cfg80211_scan_request *req = hwsim->hw_scan_request;
	int dwell, i;
1979

1980 1981
	mutex_lock(&hwsim->mutex);
	if (hwsim->scan_chan_idx >= req->n_channels) {
1982 1983 1984 1985
		struct cfg80211_scan_info info = {
			.aborted = false,
		};

1986
		wiphy_dbg(hwsim->hw->wiphy, "hw scan complete\n");
1987
		ieee80211_scan_completed(hwsim->hw, &info);
1988 1989 1990 1991 1992 1993 1994
		hwsim->hw_scan_request = NULL;
		hwsim->hw_scan_vif = NULL;
		hwsim->tmp_chan = NULL;
		mutex_unlock(&hwsim->mutex);
		return;
	}

1995 1996
	wiphy_dbg(hwsim->hw->wiphy, "hw scan %d MHz\n",
		  req->channels[hwsim->scan_chan_idx]->center_freq);
1997 1998

	hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
1999 2000
	if (hwsim->tmp_chan->flags & (IEEE80211_CHAN_NO_IR |
				      IEEE80211_CHAN_RADAR) ||
2001 2002 2003 2004 2005 2006 2007
	    !req->n_ssids) {
		dwell = 120;
	} else {
		dwell = 30;
		/* send probes */
		for (i = 0; i < req->n_ssids; i++) {
			struct sk_buff *probe;
2008
			struct ieee80211_mgmt *mgmt;
2009 2010

			probe = ieee80211_probereq_get(hwsim->hw,
2011
						       hwsim->scan_addr,
2012 2013
						       req->ssids[i].ssid,
						       req->ssids[i].ssid_len,
2014
						       req->ie_len);
2015 2016
			if (!probe)
				continue;
2017

2018 2019 2020 2021
			mgmt = (struct ieee80211_mgmt *) probe->data;
			memcpy(mgmt->da, req->bssid, ETH_ALEN);
			memcpy(mgmt->bssid, req->bssid, ETH_ALEN);

2022
			if (req->ie_len)
2023
				skb_put_data(probe, req->ie, req->ie_len);
2024

2025 2026 2027 2028 2029 2030 2031 2032
			local_bh_disable();
			mac80211_hwsim_tx_frame(hwsim->hw, probe,
						hwsim->tmp_chan);
			local_bh_enable();
		}
	}
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan,
				     msecs_to_jiffies(dwell));
2033 2034 2035 2036
	hwsim->survey_data[hwsim->scan_chan_idx].channel = hwsim->tmp_chan;
	hwsim->survey_data[hwsim->scan_chan_idx].start = jiffies;
	hwsim->survey_data[hwsim->scan_chan_idx].end =
		jiffies + msecs_to_jiffies(dwell);
2037 2038
	hwsim->scan_chan_idx++;
	mutex_unlock(&hwsim->mutex);
2039 2040 2041
}

static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
2042
				  struct ieee80211_vif *vif,
2043
				  struct ieee80211_scan_request *hw_req)
2044
{
2045
	struct mac80211_hwsim_data *hwsim = hw->priv;
2046
	struct cfg80211_scan_request *req = &hw_req->req;
2047

2048 2049 2050 2051 2052 2053 2054 2055
	mutex_lock(&hwsim->mutex);
	if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
		mutex_unlock(&hwsim->mutex);
		return -EBUSY;
	}
	hwsim->hw_scan_request = req;
	hwsim->hw_scan_vif = vif;
	hwsim->scan_chan_idx = 0;
2056 2057 2058 2059 2060 2061
	if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
		get_random_mask_addr(hwsim->scan_addr,
				     hw_req->req.mac_addr,
				     hw_req->req.mac_addr_mask);
	else
		memcpy(hwsim->scan_addr, vif->addr, ETH_ALEN);
2062
	memset(hwsim->survey_data, 0, sizeof(hwsim->survey_data));
2063
	mutex_unlock(&hwsim->mutex);
2064

2065
	wiphy_dbg(hw->wiphy, "hwsim hw_scan request\n");
2066

2067
	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
2068 2069 2070 2071

	return 0;
}

2072 2073 2074 2075
static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;
2076 2077 2078
	struct cfg80211_scan_info info = {
		.aborted = true,
	};
2079

2080
	wiphy_dbg(hw->wiphy, "hwsim cancel_hw_scan\n");
2081 2082 2083 2084

	cancel_delayed_work_sync(&hwsim->hw_scan);

	mutex_lock(&hwsim->mutex);
2085
	ieee80211_scan_completed(hwsim->hw, &info);
2086 2087 2088 2089 2090 2091
	hwsim->tmp_chan = NULL;
	hwsim->hw_scan_request = NULL;
	hwsim->hw_scan_vif = NULL;
	mutex_unlock(&hwsim->mutex);
}

2092 2093 2094
static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   const u8 *mac_addr)
2095 2096 2097 2098 2099 2100
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

	if (hwsim->scanning) {
2101
		pr_debug("two hwsim sw_scans detected!\n");
2102 2103 2104
		goto out;
	}

2105
	pr_debug("hwsim sw_scan request, prepping stuff\n");
2106 2107

	memcpy(hwsim->scan_addr, mac_addr, ETH_ALEN);
2108
	hwsim->scanning = true;
2109
	memset(hwsim->survey_data, 0, sizeof(hwsim->survey_data));
2110 2111 2112 2113 2114

out:
	mutex_unlock(&hwsim->mutex);
}

2115 2116
static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif)
2117 2118 2119 2120 2121
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);

2122
	pr_debug("hwsim sw_scan_complete\n");
2123
	hwsim->scanning = false;
2124
	eth_zero_addr(hwsim->scan_addr);
2125 2126 2127 2128

	mutex_unlock(&hwsim->mutex);
}

2129 2130 2131 2132 2133 2134 2135
static void hw_roc_start(struct work_struct *work)
{
	struct mac80211_hwsim_data *hwsim =
		container_of(work, struct mac80211_hwsim_data, roc_start.work);

	mutex_lock(&hwsim->mutex);

2136
	wiphy_dbg(hwsim->hw->wiphy, "hwsim ROC begins\n");
2137 2138 2139 2140 2141 2142 2143 2144 2145
	hwsim->tmp_chan = hwsim->roc_chan;
	ieee80211_ready_on_channel(hwsim->hw);

	ieee80211_queue_delayed_work(hwsim->hw, &hwsim->roc_done,
				     msecs_to_jiffies(hwsim->roc_duration));

	mutex_unlock(&hwsim->mutex);
}

2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
static void hw_roc_done(struct work_struct *work)
{
	struct mac80211_hwsim_data *hwsim =
		container_of(work, struct mac80211_hwsim_data, roc_done.work);

	mutex_lock(&hwsim->mutex);
	ieee80211_remain_on_channel_expired(hwsim->hw);
	hwsim->tmp_chan = NULL;
	mutex_unlock(&hwsim->mutex);

2156
	wiphy_dbg(hwsim->hw->wiphy, "hwsim ROC expired\n");
2157 2158 2159
}

static int mac80211_hwsim_roc(struct ieee80211_hw *hw,
2160
			      struct ieee80211_vif *vif,
2161
			      struct ieee80211_channel *chan,
2162 2163
			      int duration,
			      enum ieee80211_roc_type type)
2164 2165 2166 2167 2168 2169 2170 2171 2172
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

	mutex_lock(&hwsim->mutex);
	if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
		mutex_unlock(&hwsim->mutex);
		return -EBUSY;
	}

2173 2174
	hwsim->roc_chan = chan;
	hwsim->roc_duration = duration;
2175 2176
	mutex_unlock(&hwsim->mutex);

2177 2178
	wiphy_dbg(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n",
		  chan->center_freq, duration);
2179
	ieee80211_queue_delayed_work(hw, &hwsim->roc_start, HZ/50);
2180 2181 2182 2183 2184 2185 2186 2187

	return 0;
}

static int mac80211_hwsim_croc(struct ieee80211_hw *hw)
{
	struct mac80211_hwsim_data *hwsim = hw->priv;

2188
	cancel_delayed_work_sync(&hwsim->roc_start);
2189 2190 2191 2192 2193 2194
	cancel_delayed_work_sync(&hwsim->roc_done);

	mutex_lock(&hwsim->mutex);
	hwsim->tmp_chan = NULL;
	mutex_unlock(&hwsim->mutex);

2195
	wiphy_dbg(hw->wiphy, "hwsim ROC canceled\n");
2196 2197 2198 2199 2200 2201 2202 2203

	return 0;
}

static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw,
				      struct ieee80211_chanctx_conf *ctx)
{
	hwsim_set_chanctx_magic(ctx);
2204 2205 2206 2207
	wiphy_dbg(hw->wiphy,
		  "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
		  ctx->def.chan->center_freq, ctx->def.width,
		  ctx->def.center_freq1, ctx->def.center_freq2);
2208 2209 2210 2211 2212 2213
	return 0;
}

static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx)
{
2214 2215 2216 2217
	wiphy_dbg(hw->wiphy,
		  "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
		  ctx->def.chan->center_freq, ctx->def.width,
		  ctx->def.center_freq1, ctx->def.center_freq2);
2218 2219 2220 2221 2222 2223 2224 2225 2226
	hwsim_check_chanctx_magic(ctx);
	hwsim_clear_chanctx_magic(ctx);
}

static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw,
					  struct ieee80211_chanctx_conf *ctx,
					  u32 changed)
{
	hwsim_check_chanctx_magic(ctx);
2227 2228 2229 2230
	wiphy_dbg(hw->wiphy,
		  "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
		  ctx->def.chan->center_freq, ctx->def.width,
		  ctx->def.center_freq1, ctx->def.center_freq2);
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250
}

static int mac80211_hwsim_assign_vif_chanctx(struct ieee80211_hw *hw,
					     struct ieee80211_vif *vif,
					     struct ieee80211_chanctx_conf *ctx)
{
	hwsim_check_magic(vif);
	hwsim_check_chanctx_magic(ctx);

	return 0;
}

static void mac80211_hwsim_unassign_vif_chanctx(struct ieee80211_hw *hw,
						struct ieee80211_vif *vif,
						struct ieee80211_chanctx_conf *ctx)
{
	hwsim_check_magic(vif);
	hwsim_check_chanctx_magic(ctx);
}

2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
static const char mac80211_hwsim_gstrings_stats[][ETH_GSTRING_LEN] = {
	"tx_pkts_nic",
	"tx_bytes_nic",
	"rx_pkts_nic",
	"rx_bytes_nic",
	"d_tx_dropped",
	"d_tx_failed",
	"d_ps_mode",
	"d_group",
};

#define MAC80211_HWSIM_SSTATS_LEN ARRAY_SIZE(mac80211_hwsim_gstrings_stats)

static void mac80211_hwsim_get_et_strings(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif,
					  u32 sset, u8 *data)
{
	if (sset == ETH_SS_STATS)
		memcpy(data, *mac80211_hwsim_gstrings_stats,
		       sizeof(mac80211_hwsim_gstrings_stats));
}

static int mac80211_hwsim_get_et_sset_count(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif, int sset)
{
	if (sset == ETH_SS_STATS)
		return MAC80211_HWSIM_SSTATS_LEN;
	return 0;
}

static void mac80211_hwsim_get_et_stats(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
					struct ethtool_stats *stats, u64 *data)
{
	struct mac80211_hwsim_data *ar = hw->priv;
	int i = 0;

	data[i++] = ar->tx_pkts;
	data[i++] = ar->tx_bytes;
	data[i++] = ar->rx_pkts;
	data[i++] = ar->rx_bytes;
	data[i++] = ar->tx_dropped;
	data[i++] = ar->tx_failed;
	data[i++] = ar->ps;
	data[i++] = ar->group;

	WARN_ON(i != MAC80211_HWSIM_SSTATS_LEN);
}

2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
#define HWSIM_COMMON_OPS					\
	.tx = mac80211_hwsim_tx,				\
	.start = mac80211_hwsim_start,				\
	.stop = mac80211_hwsim_stop,				\
	.add_interface = mac80211_hwsim_add_interface,		\
	.change_interface = mac80211_hwsim_change_interface,	\
	.remove_interface = mac80211_hwsim_remove_interface,	\
	.config = mac80211_hwsim_config,			\
	.configure_filter = mac80211_hwsim_configure_filter,	\
	.bss_info_changed = mac80211_hwsim_bss_info_changed,	\
	.sta_add = mac80211_hwsim_sta_add,			\
	.sta_remove = mac80211_hwsim_sta_remove,		\
	.sta_notify = mac80211_hwsim_sta_notify,		\
	.set_tim = mac80211_hwsim_set_tim,			\
	.conf_tx = mac80211_hwsim_conf_tx,			\
	.get_survey = mac80211_hwsim_get_survey,		\
	CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)	\
	.ampdu_action = mac80211_hwsim_ampdu_action,		\
	.flush = mac80211_hwsim_flush,				\
	.get_tsf = mac80211_hwsim_get_tsf,			\
	.set_tsf = mac80211_hwsim_set_tsf,			\
	.get_et_sset_count = mac80211_hwsim_get_et_sset_count,	\
	.get_et_stats = mac80211_hwsim_get_et_stats,		\
	.get_et_strings = mac80211_hwsim_get_et_strings,

2325
static const struct ieee80211_ops mac80211_hwsim_ops = {
2326
	HWSIM_COMMON_OPS
2327 2328
	.sw_scan_start = mac80211_hwsim_sw_scan,
	.sw_scan_complete = mac80211_hwsim_sw_scan_complete,
2329 2330
};

2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
static const struct ieee80211_ops mac80211_hwsim_mchan_ops = {
	HWSIM_COMMON_OPS
	.hw_scan = mac80211_hwsim_hw_scan,
	.cancel_hw_scan = mac80211_hwsim_cancel_hw_scan,
	.sw_scan_start = NULL,
	.sw_scan_complete = NULL,
	.remain_on_channel = mac80211_hwsim_roc,
	.cancel_remain_on_channel = mac80211_hwsim_croc,
	.add_chanctx = mac80211_hwsim_add_chanctx,
	.remove_chanctx = mac80211_hwsim_remove_chanctx,
	.change_chanctx = mac80211_hwsim_change_chanctx,
	.assign_vif_chanctx = mac80211_hwsim_assign_vif_chanctx,
	.unassign_vif_chanctx = mac80211_hwsim_unassign_vif_chanctx,
};
2345

2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361
struct hwsim_new_radio_params {
	unsigned int channels;
	const char *reg_alpha2;
	const struct ieee80211_regdomain *regd;
	bool reg_strict;
	bool p2p_device;
	bool use_chanctx;
	bool destroy_on_close;
	const char *hwname;
	bool no_vif;
};

static void hwsim_mcast_config_msg(struct sk_buff *mcast_skb,
				   struct genl_info *info)
{
	if (info)
J
Jiri Benc 已提交
2362 2363
		genl_notify(&hwsim_genl_family, mcast_skb, info,
			    HWSIM_MCGRP_CONFIG, GFP_KERNEL);
2364 2365 2366 2367 2368
	else
		genlmsg_multicast(&hwsim_genl_family, mcast_skb, 0,
				  HWSIM_MCGRP_CONFIG, GFP_KERNEL);
}

2369 2370
static int append_radio_msg(struct sk_buff *skb, int id,
			    struct hwsim_new_radio_params *param)
2371 2372 2373 2374 2375
{
	int ret;

	ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
	if (ret < 0)
2376
		return ret;
2377 2378 2379 2380

	if (param->channels) {
		ret = nla_put_u32(skb, HWSIM_ATTR_CHANNELS, param->channels);
		if (ret < 0)
2381
			return ret;
2382 2383 2384 2385 2386 2387
	}

	if (param->reg_alpha2) {
		ret = nla_put(skb, HWSIM_ATTR_REG_HINT_ALPHA2, 2,
			      param->reg_alpha2);
		if (ret < 0)
2388
			return ret;
2389 2390 2391 2392 2393
	}

	if (param->regd) {
		int i;

2394 2395 2396
		for (i = 0; i < ARRAY_SIZE(hwsim_world_regdom_custom); i++) {
			if (hwsim_world_regdom_custom[i] != param->regd)
				continue;
2397 2398 2399

			ret = nla_put_u32(skb, HWSIM_ATTR_REG_CUSTOM_REG, i);
			if (ret < 0)
2400
				return ret;
2401
			break;
2402 2403 2404 2405 2406 2407
		}
	}

	if (param->reg_strict) {
		ret = nla_put_flag(skb, HWSIM_ATTR_REG_STRICT_REG);
		if (ret < 0)
2408
			return ret;
2409 2410 2411 2412 2413
	}

	if (param->p2p_device) {
		ret = nla_put_flag(skb, HWSIM_ATTR_SUPPORT_P2P_DEVICE);
		if (ret < 0)
2414
			return ret;
2415 2416 2417 2418 2419
	}

	if (param->use_chanctx) {
		ret = nla_put_flag(skb, HWSIM_ATTR_USE_CHANCTX);
		if (ret < 0)
2420
			return ret;
2421 2422 2423 2424 2425 2426
	}

	if (param->hwname) {
		ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME,
			      strlen(param->hwname), param->hwname);
		if (ret < 0)
2427
			return ret;
2428 2429
	}

2430
	return 0;
2431 2432
}

2433
static void hwsim_mcast_new_radio(int id, struct genl_info *info,
2434 2435 2436
				  struct hwsim_new_radio_params *param)
{
	struct sk_buff *mcast_skb;
2437
	void *data;
2438

2439
	mcast_skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2440 2441 2442
	if (!mcast_skb)
		return;

2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
	data = genlmsg_put(mcast_skb, 0, 0, &hwsim_genl_family, 0,
			   HWSIM_CMD_NEW_RADIO);
	if (!data)
		goto out_err;

	if (append_radio_msg(mcast_skb, id, param) < 0)
		goto out_err;

	genlmsg_end(mcast_skb, data);

2453
	hwsim_mcast_config_msg(mcast_skb, info);
2454 2455 2456 2457 2458
	return;

out_err:
	genlmsg_cancel(mcast_skb, data);
	nlmsg_free(mcast_skb);
2459 2460 2461 2462
}

static int mac80211_hwsim_new_radio(struct genl_info *info,
				    struct hwsim_new_radio_params *param)
2463
{
2464 2465
	int err;
	u8 addr[ETH_ALEN];
2466
	struct mac80211_hwsim_data *data;
2467
	struct ieee80211_hw *hw;
2468
	enum nl80211_band band;
2469
	const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
2470
	struct net *net;
2471
	int idx;
2472

2473
	if (WARN_ON(param->channels > 1 && !param->use_chanctx))
2474 2475
		return -EINVAL;

2476
	spin_lock_bh(&hwsim_radio_lock);
2477
	idx = hwsim_radio_idx++;
2478 2479
	spin_unlock_bh(&hwsim_radio_lock);

2480
	if (param->use_chanctx)
2481
		ops = &mac80211_hwsim_mchan_ops;
2482
	hw = ieee80211_alloc_hw_nm(sizeof(*data), ops, param->hwname);
2483
	if (!hw) {
2484
		pr_debug("mac80211_hwsim: ieee80211_alloc_hw failed\n");
2485 2486 2487
		err = -ENOMEM;
		goto failed;
	}
2488

2489 2490 2491
	/* ieee80211_alloc_hw_nm may have used a default name */
	param->hwname = wiphy_name(hw->wiphy);

2492 2493 2494 2495 2496 2497
	if (info)
		net = genl_info_net(info);
	else
		net = &init_net;
	wiphy_net_set(hw->wiphy, net);

2498 2499
	data = hw->priv;
	data->hw = hw;
2500

2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
	data->dev = device_create(hwsim_class, NULL, 0, hw, "hwsim%d", idx);
	if (IS_ERR(data->dev)) {
		printk(KERN_DEBUG
		       "mac80211_hwsim: device_create failed (%ld)\n",
		       PTR_ERR(data->dev));
		err = -ENOMEM;
		goto failed_drvdata;
	}
	data->dev->driver = &mac80211_hwsim_driver.driver;
	err = device_bind_driver(data->dev);
	if (err != 0) {
2512
		pr_debug("mac80211_hwsim: device_bind_driver failed (%d)\n",
2513
		       err);
2514
		goto failed_bind;
2515 2516
	}

2517
	skb_queue_head_init(&data->pending);
2518

2519
	SET_IEEE80211_DEV(hw, data->dev);
2520
	eth_zero_addr(addr);
2521 2522 2523 2524 2525 2526 2527 2528
	addr[0] = 0x02;
	addr[3] = idx >> 8;
	addr[4] = idx;
	memcpy(data->addresses[0].addr, addr, ETH_ALEN);
	memcpy(data->addresses[1].addr, addr, ETH_ALEN);
	data->addresses[1].addr[0] |= 0x40;
	hw->wiphy->n_addresses = 2;
	hw->wiphy->addresses = data->addresses;
2529

2530 2531
	data->channels = param->channels;
	data->use_chanctx = param->use_chanctx;
2532
	data->idx = idx;
2533 2534 2535
	data->destroy_on_close = param->destroy_on_close;
	if (info)
		data->portid = info->snd_portid;
2536

2537
	if (data->use_chanctx) {
2538 2539 2540 2541
		hw->wiphy->max_scan_ssids = 255;
		hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
		hw->wiphy->max_remain_on_channel_duration = 1000;
		hw->wiphy->iface_combinations = &data->if_combination;
2542
		if (param->p2p_device)
2543 2544 2545
			data->if_combination = hwsim_if_comb_p2p_dev[0];
		else
			data->if_combination = hwsim_if_comb[0];
2546 2547 2548
		hw->wiphy->n_iface_combinations = 1;
		/* For channels > 1 DFS is not allowed */
		data->if_combination.radar_detect_widths = 0;
2549
		data->if_combination.num_different_channels = data->channels;
2550
	} else if (param->p2p_device) {
2551 2552 2553
		hw->wiphy->iface_combinations = hwsim_if_comb_p2p_dev;
		hw->wiphy->n_iface_combinations =
			ARRAY_SIZE(hwsim_if_comb_p2p_dev);
2554 2555 2556 2557
	} else {
		hw->wiphy->iface_combinations = hwsim_if_comb;
		hw->wiphy->n_iface_combinations = ARRAY_SIZE(hwsim_if_comb);
	}
2558

2559
	INIT_DELAYED_WORK(&data->roc_start, hw_roc_start);
2560 2561
	INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
	INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2562

2563 2564 2565 2566 2567 2568 2569
	hw->queues = 5;
	hw->offchannel_tx_hw_queue = 4;
	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
				     BIT(NL80211_IFTYPE_AP) |
				     BIT(NL80211_IFTYPE_P2P_CLIENT) |
				     BIT(NL80211_IFTYPE_P2P_GO) |
				     BIT(NL80211_IFTYPE_ADHOC) |
2570 2571
				     BIT(NL80211_IFTYPE_MESH_POINT);

2572
	if (param->p2p_device)
2573
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
2574

2575 2576 2577 2578 2579 2580 2581 2582
	ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
	ieee80211_hw_set(hw, CHANCTX_STA_CSA);
	ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
	ieee80211_hw_set(hw, QUEUE_CONTROL);
	ieee80211_hw_set(hw, WANT_MONITOR_VIF);
	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
	ieee80211_hw_set(hw, MFP_CAPABLE);
	ieee80211_hw_set(hw, SIGNAL_DBM);
2583
	ieee80211_hw_set(hw, TDLS_WIDER_BW);
2584
	if (rctbl)
2585
		ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
2586

2587 2588
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
			    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2589 2590
			    WIPHY_FLAG_AP_UAPSD |
			    WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2591 2592 2593
	hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR |
			       NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
			       NL80211_FEATURE_STATIC_SMPS |
2594 2595
			       NL80211_FEATURE_DYNAMIC_SMPS |
			       NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
2596
	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
2597

2598 2599 2600 2601
	/* ask mac80211 to reserve space for magic */
	hw->vif_data_size = sizeof(struct hwsim_vif_priv);
	hw->sta_data_size = sizeof(struct hwsim_sta_priv);
	hw->chanctx_data_size = sizeof(struct hwsim_chanctx_priv);
2602

2603 2604 2605 2606 2607
	memcpy(data->channels_2ghz, hwsim_channels_2ghz,
		sizeof(hwsim_channels_2ghz));
	memcpy(data->channels_5ghz, hwsim_channels_5ghz,
		sizeof(hwsim_channels_5ghz));
	memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
2608

2609
	for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
2610 2611
		struct ieee80211_supported_band *sband = &data->bands[band];
		switch (band) {
2612
		case NL80211_BAND_2GHZ:
2613 2614 2615 2616 2617
			sband->channels = data->channels_2ghz;
			sband->n_channels = ARRAY_SIZE(hwsim_channels_2ghz);
			sband->bitrates = data->rates;
			sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
			break;
2618
		case NL80211_BAND_5GHZ:
2619 2620 2621 2622
			sband->channels = data->channels_5ghz;
			sband->n_channels = ARRAY_SIZE(hwsim_channels_5ghz);
			sband->bitrates = data->rates + 4;
			sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4;
2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637

			sband->vht_cap.vht_supported = true;
			sband->vht_cap.cap =
				IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
				IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ |
				IEEE80211_VHT_CAP_RXLDPC |
				IEEE80211_VHT_CAP_SHORT_GI_80 |
				IEEE80211_VHT_CAP_SHORT_GI_160 |
				IEEE80211_VHT_CAP_TXSTBC |
				IEEE80211_VHT_CAP_RXSTBC_1 |
				IEEE80211_VHT_CAP_RXSTBC_2 |
				IEEE80211_VHT_CAP_RXSTBC_3 |
				IEEE80211_VHT_CAP_RXSTBC_4 |
				IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
			sband->vht_cap.vht_mcs.rx_mcs_map =
2638 2639
				cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
2640
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
2641 2642
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 |
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 |
2643 2644
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 |
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 |
2645
					    IEEE80211_VHT_MCS_SUPPORT_0_9 << 14);
2646 2647
			sband->vht_cap.vht_mcs.tx_mcs_map =
				sband->vht_cap.vht_mcs.rx_mcs_map;
2648 2649 2650 2651
			break;
		default:
			continue;
		}
2652

2653 2654 2655
		sband->ht_cap.ht_supported = true;
		sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
				    IEEE80211_HT_CAP_GRN_FLD |
B
Ben Greear 已提交
2656
				    IEEE80211_HT_CAP_SGI_20 |
2657 2658 2659 2660 2661 2662 2663 2664 2665
				    IEEE80211_HT_CAP_SGI_40 |
				    IEEE80211_HT_CAP_DSSSCCK40;
		sband->ht_cap.ampdu_factor = 0x3;
		sband->ht_cap.ampdu_density = 0x6;
		memset(&sband->ht_cap.mcs, 0,
		       sizeof(sband->ht_cap.mcs));
		sband->ht_cap.mcs.rx_mask[0] = 0xff;
		sband->ht_cap.mcs.rx_mask[1] = 0xff;
		sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2666

2667 2668
		hw->wiphy->bands[band] = sband;
	}
2669

2670 2671 2672
	/* By default all radios belong to the first group */
	data->group = 1;
	mutex_init(&data->mutex);
2673

2674 2675
	data->netgroup = hwsim_net_get_netgroup(net);

2676 2677 2678
	/* Enable frame retransmissions for lossy channels */
	hw->max_rates = 4;
	hw->max_rate_tries = 11;
2679

2680 2681 2682 2683 2684 2685
	hw->wiphy->vendor_commands = mac80211_hwsim_vendor_commands;
	hw->wiphy->n_vendor_commands =
		ARRAY_SIZE(mac80211_hwsim_vendor_commands);
	hw->wiphy->vendor_events = mac80211_hwsim_vendor_events;
	hw->wiphy->n_vendor_events = ARRAY_SIZE(mac80211_hwsim_vendor_events);

2686
	if (param->reg_strict)
2687
		hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
2688
	if (param->regd) {
2689
		data->regd = param->regd;
2690
		hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2691
		wiphy_apply_custom_regulatory(hw->wiphy, param->regd);
2692 2693 2694
		/* give the regulatory workqueue a chance to run */
		schedule_timeout_interruptible(1);
	}
2695

2696
	if (param->no_vif)
2697
		ieee80211_hw_set(hw, NO_AUTO_VIF);
2698

2699 2700
	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);

2701 2702
	err = ieee80211_register_hw(hw);
	if (err < 0) {
2703
		pr_debug("mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
2704 2705 2706
		       err);
		goto failed_hw;
	}
2707

2708
	wiphy_dbg(hw->wiphy, "hwaddr %pM registered\n", hw->wiphy->perm_addr);
2709

2710 2711 2712
	if (param->reg_alpha2) {
		data->alpha2[0] = param->reg_alpha2[0];
		data->alpha2[1] = param->reg_alpha2[1];
2713
		regulatory_hint(hw->wiphy, param->reg_alpha2);
2714
	}
2715

2716 2717 2718 2719
	data->debugfs = debugfs_create_dir("hwsim", hw->wiphy->debugfsdir);
	debugfs_create_file("ps", 0666, data->debugfs, data, &hwsim_fops_ps);
	debugfs_create_file("group", 0666, data->debugfs, data,
			    &hwsim_fops_group);
2720
	if (!data->use_chanctx)
2721 2722 2723
		debugfs_create_file("dfs_simulate_radar", 0222,
				    data->debugfs,
				    data, &hwsim_simulate_radar);
2724

2725 2726
	tasklet_hrtimer_init(&data->beacon_timer,
			     mac80211_hwsim_beacon,
2727
			     CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
2728

2729 2730 2731
	spin_lock_bh(&hwsim_radio_lock);
	list_add_tail(&data->list, &hwsim_radios);
	spin_unlock_bh(&hwsim_radio_lock);
2732

2733
	if (idx > 0)
2734
		hwsim_mcast_new_radio(idx, info, param);
2735

2736
	return idx;
2737

2738
failed_hw:
2739 2740
	device_release_driver(data->dev);
failed_bind:
2741 2742 2743 2744 2745
	device_unregister(data->dev);
failed_drvdata:
	ieee80211_free_hw(hw);
failed:
	return err;
2746 2747
}

2748 2749
static void hwsim_mcast_del_radio(int id, const char *hwname,
				  struct genl_info *info)
2750
{
2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
	struct sk_buff *skb;
	void *data;
	int ret;

	skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (!skb)
		return;

	data = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
			   HWSIM_CMD_DEL_RADIO);
	if (!data)
		goto error;

	ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
	if (ret < 0)
		goto error;

2768 2769 2770 2771
	ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME, strlen(hwname),
		      hwname);
	if (ret < 0)
		goto error;
2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787

	genlmsg_end(skb, data);

	hwsim_mcast_config_msg(skb, info);

	return;

error:
	nlmsg_free(skb);
}

static void mac80211_hwsim_del_radio(struct mac80211_hwsim_data *data,
				     const char *hwname,
				     struct genl_info *info)
{
	hwsim_mcast_del_radio(data->idx, hwname, info);
2788 2789 2790 2791 2792
	debugfs_remove_recursive(data->debugfs);
	ieee80211_unregister_hw(data->hw);
	device_release_driver(data->dev);
	device_unregister(data->dev);
	ieee80211_free_hw(data->hw);
2793 2794
}

2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
static int mac80211_hwsim_get_radio(struct sk_buff *skb,
				    struct mac80211_hwsim_data *data,
				    u32 portid, u32 seq,
				    struct netlink_callback *cb, int flags)
{
	void *hdr;
	struct hwsim_new_radio_params param = { };
	int res = -EMSGSIZE;

	hdr = genlmsg_put(skb, portid, seq, &hwsim_genl_family, flags,
			  HWSIM_CMD_GET_RADIO);
	if (!hdr)
		return -EMSGSIZE;

	if (cb)
M
Michal Kubecek 已提交
2810
		genl_dump_check_consistent(cb, hdr);
2811

2812 2813 2814
	if (data->alpha2[0] && data->alpha2[1])
		param.reg_alpha2 = data->alpha2;

2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827
	param.reg_strict = !!(data->hw->wiphy->regulatory_flags &
					REGULATORY_STRICT_REG);
	param.p2p_device = !!(data->hw->wiphy->interface_modes &
					BIT(NL80211_IFTYPE_P2P_DEVICE));
	param.use_chanctx = data->use_chanctx;
	param.regd = data->regd;
	param.channels = data->channels;
	param.hwname = wiphy_name(data->hw->wiphy);

	res = append_radio_msg(skb, data->idx, &param);
	if (res < 0)
		goto out_err;

2828 2829
	genlmsg_end(skb, hdr);
	return 0;
2830 2831 2832 2833 2834 2835

out_err:
	genlmsg_cancel(skb, hdr);
	return res;
}

2836
static void mac80211_hwsim_free(void)
2837
{
2838
	struct mac80211_hwsim_data *data;
2839

2840 2841 2842 2843 2844 2845
	spin_lock_bh(&hwsim_radio_lock);
	while ((data = list_first_entry_or_null(&hwsim_radios,
						struct mac80211_hwsim_data,
						list))) {
		list_del(&data->list);
		spin_unlock_bh(&hwsim_radio_lock);
2846 2847
		mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
					 NULL);
2848
		spin_lock_bh(&hwsim_radio_lock);
2849
	}
2850 2851
	spin_unlock_bh(&hwsim_radio_lock);
	class_destroy(hwsim_class);
2852 2853
}

2854 2855 2856 2857 2858
static const struct net_device_ops hwsim_netdev_ops = {
	.ndo_start_xmit 	= hwsim_mon_xmit,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
};
D
Daniel Wagner 已提交
2859

2860
static void hwsim_mon_setup(struct net_device *dev)
D
Daniel Wagner 已提交
2861
{
2862
	dev->netdev_ops = &hwsim_netdev_ops;
2863
	dev->needs_free_netdev = true;
2864
	ether_setup(dev);
2865
	dev->priv_flags |= IFF_NO_QUEUE;
2866
	dev->type = ARPHRD_IEEE80211_RADIOTAP;
2867
	eth_zero_addr(dev->dev_addr);
2868
	dev->dev_addr[0] = 0x12;
D
Daniel Wagner 已提交
2869 2870
}

2871
static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
2872 2873 2874 2875 2876 2877
{
	struct mac80211_hwsim_data *data;
	bool _found = false;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
2878
		if (memcmp(data->addresses[1].addr, addr, ETH_ALEN) == 0) {
2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
			_found = true;
			break;
		}
	}
	spin_unlock_bh(&hwsim_radio_lock);

	if (!_found)
		return NULL;

	return data;
}

2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904
static void hwsim_register_wmediumd(struct net *net, u32 portid)
{
	struct mac80211_hwsim_data *data;

	hwsim_net_set_wmediumd(net, portid);

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
		if (data->netgroup == hwsim_net_get_netgroup(net))
			data->wmediumd = portid;
	}
	spin_unlock_bh(&hwsim_radio_lock);
}

2905 2906 2907 2908 2909 2910 2911 2912
static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2,
					   struct genl_info *info)
{

	struct ieee80211_hdr *hdr;
	struct mac80211_hwsim_data *data2;
	struct ieee80211_tx_info *txi;
	struct hwsim_tx_rate *tx_attempts;
2913
	u64 ret_skb_cookie;
2914
	struct sk_buff *skb, *tmp;
2915
	const u8 *src;
2916 2917 2918 2919 2920
	unsigned int hwsim_flags;
	int i;
	bool found = false;

	if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
2921 2922
	    !info->attrs[HWSIM_ATTR_FLAGS] ||
	    !info->attrs[HWSIM_ATTR_COOKIE] ||
2923
	    !info->attrs[HWSIM_ATTR_SIGNAL] ||
2924
	    !info->attrs[HWSIM_ATTR_TX_INFO])
2925 2926
		goto out;

2927
	src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
2928
	hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
2929
	ret_skb_cookie = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
2930 2931

	data2 = get_hwsim_data_ref_from_addr(src);
2932
	if (!data2)
2933 2934
		goto out;

2935 2936 2937 2938 2939 2940
	if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
		goto out;

	if (info->snd_portid != data2->wmediumd)
		goto out;

2941 2942
	/* look for the skb matching the cookie passed back from user */
	skb_queue_walk_safe(&data2->pending, skb, tmp) {
2943 2944 2945 2946 2947 2948
		u64 skb_cookie;

		txi = IEEE80211_SKB_CB(skb);
		skb_cookie = (u64)(uintptr_t)txi->rate_driver_data[0];

		if (skb_cookie == ret_skb_cookie) {
2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981
			skb_unlink(skb, &data2->pending);
			found = true;
			break;
		}
	}

	/* not found */
	if (!found)
		goto out;

	/* Tx info received because the frame was broadcasted on user space,
	 so we get all the necessary info: tx attempts and skb control buff */

	tx_attempts = (struct hwsim_tx_rate *)nla_data(
		       info->attrs[HWSIM_ATTR_TX_INFO]);

	/* now send back TX status */
	txi = IEEE80211_SKB_CB(skb);

	ieee80211_tx_info_clear_status(txi);

	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
		txi->status.rates[i].idx = tx_attempts[i].idx;
		txi->status.rates[i].count = tx_attempts[i].count;
		/*txi->status.rates[i].flags = 0;*/
	}

	txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);

	if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) &&
	   (hwsim_flags & HWSIM_TX_STAT_ACK)) {
		if (skb->len >= 16) {
			hdr = (struct ieee80211_hdr *) skb->data;
2982
			mac80211_hwsim_monitor_ack(data2->channel,
2983
						   hdr->addr2);
2984
		}
2985
		txi->flags |= IEEE80211_TX_STAT_ACK;
2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996
	}
	ieee80211_tx_status_irqsafe(data2->hw, skb);
	return 0;
out:
	return -EINVAL;

}

static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2,
					  struct genl_info *info)
{
2997
	struct mac80211_hwsim_data *data2;
2998
	struct ieee80211_rx_status rx_status;
2999
	const u8 *dst;
3000
	int frame_data_len;
3001
	void *frame_data;
3002 3003 3004
	struct sk_buff *skb = NULL;

	if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
3005 3006 3007
	    !info->attrs[HWSIM_ATTR_FRAME] ||
	    !info->attrs[HWSIM_ATTR_RX_RATE] ||
	    !info->attrs[HWSIM_ATTR_SIGNAL])
3008 3009
		goto out;

3010
	dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
3011
	frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
3012
	frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
3013 3014 3015 3016 3017 3018

	/* Allocate new skb here */
	skb = alloc_skb(frame_data_len, GFP_KERNEL);
	if (skb == NULL)
		goto err;

3019
	if (frame_data_len > IEEE80211_MAX_DATA_LEN)
3020 3021
		goto err;

3022
	/* Copy the data */
3023
	skb_put_data(skb, frame_data, frame_data_len);
3024

3025 3026
	data2 = get_hwsim_data_ref_from_addr(dst);
	if (!data2)
3027 3028
		goto out;

3029 3030 3031 3032 3033 3034
	if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
		goto out;

	if (info->snd_portid != data2->wmediumd)
		goto out;

3035 3036
	/* check if radio is configured properly */

3037
	if (data2->idle || !data2->started)
3038 3039
		goto out;

3040
	/* A frame is received from user space */
3041
	memset(&rx_status, 0, sizeof(rx_status));
3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
	if (info->attrs[HWSIM_ATTR_FREQ]) {
		/* throw away off-channel packets, but allow both the temporary
		 * ("hw" scan/remain-on-channel) and regular channel, since the
		 * internal datapath also allows this
		 */
		mutex_lock(&data2->mutex);
		rx_status.freq = nla_get_u32(info->attrs[HWSIM_ATTR_FREQ]);

		if (rx_status.freq != data2->channel->center_freq &&
		    (!data2->tmp_chan ||
		     rx_status.freq != data2->tmp_chan->center_freq)) {
			mutex_unlock(&data2->mutex);
			goto out;
		}
		mutex_unlock(&data2->mutex);
	} else {
		rx_status.freq = data2->channel->center_freq;
	}

3061 3062 3063 3064 3065
	rx_status.band = data2->channel->band;
	rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]);
	rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);

	memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
3066 3067
	data2->rx_pkts++;
	data2->rx_bytes += skb->len;
3068 3069 3070 3071
	ieee80211_rx_irqsafe(data2->hw, skb);

	return 0;
err:
3072
	pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
3073 3074 3075 3076 3077 3078 3079 3080
out:
	dev_kfree_skb(skb);
	return -EINVAL;
}

static int hwsim_register_received_nl(struct sk_buff *skb_2,
				      struct genl_info *info)
{
3081
	struct net *net = genl_info_net(info);
3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097
	struct mac80211_hwsim_data *data;
	int chans = 1;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list)
		chans = max(chans, data->channels);
	spin_unlock_bh(&hwsim_radio_lock);

	/* In the future we should revise the userspace API and allow it
	 * to set a flag that it does support multi-channel, then we can
	 * let this pass conditionally on the flag.
	 * For current userspace, prohibit it since it won't work right.
	 */
	if (chans > 1)
		return -EOPNOTSUPP;

3098
	if (hwsim_net_get_wmediumd(net))
3099
		return -EBUSY;
3100

3101
	hwsim_register_wmediumd(net, info->snd_portid);
3102

3103
	pr_debug("mac80211_hwsim: received a REGISTER, "
3104
	       "switching to wmediumd mode with pid %d\n", info->snd_portid);
3105 3106 3107 3108

	return 0;
}

3109
static int hwsim_new_radio_nl(struct sk_buff *msg, struct genl_info *info)
3110
{
3111
	struct hwsim_new_radio_params param = { 0 };
3112
	const char *hwname = NULL;
3113
	int ret;
3114 3115 3116 3117 3118 3119

	param.reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG];
	param.p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE];
	param.channels = channels;
	param.destroy_on_close =
		info->attrs[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE];
3120 3121

	if (info->attrs[HWSIM_ATTR_CHANNELS])
3122
		param.channels = nla_get_u32(info->attrs[HWSIM_ATTR_CHANNELS]);
3123

3124
	if (info->attrs[HWSIM_ATTR_NO_VIF])
3125
		param.no_vif = true;
3126

3127 3128 3129 3130 3131 3132 3133 3134
	if (info->attrs[HWSIM_ATTR_RADIO_NAME]) {
		hwname = kasprintf(GFP_KERNEL, "%.*s",
				   nla_len(info->attrs[HWSIM_ATTR_RADIO_NAME]),
				   (char *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]));
		if (!hwname)
			return -ENOMEM;
		param.hwname = hwname;
	}
3135

3136
	if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
3137
		param.use_chanctx = true;
3138
	else
3139
		param.use_chanctx = (param.channels > 1);
3140

3141
	if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2])
3142 3143
		param.reg_alpha2 =
			nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]);
3144 3145 3146 3147 3148 3149

	if (info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]) {
		u32 idx = nla_get_u32(info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]);

		if (idx >= ARRAY_SIZE(hwsim_world_regdom_custom))
			return -EINVAL;
3150
		param.regd = hwsim_world_regdom_custom[idx];
3151 3152
	}

3153 3154 3155
	ret = mac80211_hwsim_new_radio(info, &param);
	kfree(hwname);
	return ret;
3156 3157
}

3158
static int hwsim_del_radio_nl(struct sk_buff *msg, struct genl_info *info)
3159 3160
{
	struct mac80211_hwsim_data *data;
3161 3162
	s64 idx = -1;
	const char *hwname = NULL;
3163

3164
	if (info->attrs[HWSIM_ATTR_RADIO_ID]) {
3165
		idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
3166 3167 3168 3169 3170 3171 3172
	} else if (info->attrs[HWSIM_ATTR_RADIO_NAME]) {
		hwname = kasprintf(GFP_KERNEL, "%.*s",
				   nla_len(info->attrs[HWSIM_ATTR_RADIO_NAME]),
				   (char *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]));
		if (!hwname)
			return -ENOMEM;
	} else
3173 3174 3175 3176
		return -EINVAL;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
3177 3178 3179 3180
		if (idx >= 0) {
			if (data->idx != idx)
				continue;
		} else {
3181 3182
			if (!hwname ||
			    strcmp(hwname, wiphy_name(data->hw->wiphy)))
3183 3184 3185
				continue;
		}

3186 3187 3188
		if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
			continue;

3189 3190
		list_del(&data->list);
		spin_unlock_bh(&hwsim_radio_lock);
3191 3192
		mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
					 info);
3193
		kfree(hwname);
3194 3195 3196 3197
		return 0;
	}
	spin_unlock_bh(&hwsim_radio_lock);

3198
	kfree(hwname);
3199
	return -ENODEV;
3200 3201
}

3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216
static int hwsim_get_radio_nl(struct sk_buff *msg, struct genl_info *info)
{
	struct mac80211_hwsim_data *data;
	struct sk_buff *skb;
	int idx, res = -ENODEV;

	if (!info->attrs[HWSIM_ATTR_RADIO_ID])
		return -EINVAL;
	idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry(data, &hwsim_radios, list) {
		if (data->idx != idx)
			continue;

3217 3218 3219
		if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
			continue;

3220
		skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
		if (!skb) {
			res = -ENOMEM;
			goto out_err;
		}

		res = mac80211_hwsim_get_radio(skb, data, info->snd_portid,
					       info->snd_seq, NULL, 0);
		if (res < 0) {
			nlmsg_free(skb);
			goto out_err;
		}

		genlmsg_reply(skb, info);
		break;
	}

out_err:
	spin_unlock_bh(&hwsim_radio_lock);

	return res;
}

static int hwsim_dump_radio_nl(struct sk_buff *skb,
			       struct netlink_callback *cb)
{
	int idx = cb->args[0];
	struct mac80211_hwsim_data *data = NULL;
	int res;

	spin_lock_bh(&hwsim_radio_lock);

	if (idx == hwsim_radio_idx)
		goto done;

	list_for_each_entry(data, &hwsim_radios, list) {
		if (data->idx < idx)
			continue;

3259 3260 3261
		if (!net_eq(wiphy_net(data->hw->wiphy), sock_net(skb->sk)))
			continue;

3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278
		res = mac80211_hwsim_get_radio(skb, data,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq, cb,
					       NLM_F_MULTI);
		if (res < 0)
			break;

		idx = data->idx + 1;
	}

	cb->args[0] = idx;

done:
	spin_unlock_bh(&hwsim_radio_lock);
	return skb->len;
}

3279
/* Generic Netlink operations array */
3280
static const struct genl_ops hwsim_ops[] = {
3281 3282 3283 3284
	{
		.cmd = HWSIM_CMD_REGISTER,
		.policy = hwsim_genl_policy,
		.doit = hwsim_register_received_nl,
3285
		.flags = GENL_UNS_ADMIN_PERM,
3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296
	},
	{
		.cmd = HWSIM_CMD_FRAME,
		.policy = hwsim_genl_policy,
		.doit = hwsim_cloned_frame_received_nl,
	},
	{
		.cmd = HWSIM_CMD_TX_INFO_FRAME,
		.policy = hwsim_genl_policy,
		.doit = hwsim_tx_info_frame_received_nl,
	},
3297
	{
3298
		.cmd = HWSIM_CMD_NEW_RADIO,
3299
		.policy = hwsim_genl_policy,
3300
		.doit = hwsim_new_radio_nl,
3301
		.flags = GENL_UNS_ADMIN_PERM,
3302 3303
	},
	{
3304
		.cmd = HWSIM_CMD_DEL_RADIO,
3305
		.policy = hwsim_genl_policy,
3306
		.doit = hwsim_del_radio_nl,
3307
		.flags = GENL_UNS_ADMIN_PERM,
3308
	},
3309 3310 3311 3312 3313 3314
	{
		.cmd = HWSIM_CMD_GET_RADIO,
		.policy = hwsim_genl_policy,
		.doit = hwsim_get_radio_nl,
		.dumpit = hwsim_dump_radio_nl,
	},
3315 3316
};

3317
static struct genl_family hwsim_genl_family __ro_after_init = {
3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
	.name = "MAC80211_HWSIM",
	.version = 1,
	.maxattr = HWSIM_ATTR_MAX,
	.netnsok = true,
	.module = THIS_MODULE,
	.ops = hwsim_ops,
	.n_ops = ARRAY_SIZE(hwsim_ops),
	.mcgrps = hwsim_mcgrps,
	.n_mcgrps = ARRAY_SIZE(hwsim_mcgrps),
};

3329 3330 3331 3332 3333
static void destroy_radio(struct work_struct *work)
{
	struct mac80211_hwsim_data *data =
		container_of(work, struct mac80211_hwsim_data, destroy_work);

3334
	mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy), NULL);
3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345
}

static void remove_user_radios(u32 portid)
{
	struct mac80211_hwsim_data *entry, *tmp;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry_safe(entry, tmp, &hwsim_radios, list) {
		if (entry->destroy_on_close && entry->portid == portid) {
			list_del(&entry->list);
			INIT_WORK(&entry->destroy_work, destroy_radio);
3346
			queue_work(hwsim_wq, &entry->destroy_work);
3347 3348 3349 3350 3351
		}
	}
	spin_unlock_bh(&hwsim_radio_lock);
}

3352 3353 3354 3355 3356 3357 3358 3359 3360
static int mac80211_hwsim_netlink_notify(struct notifier_block *nb,
					 unsigned long state,
					 void *_notify)
{
	struct netlink_notify *notify = _notify;

	if (state != NETLINK_URELEASE)
		return NOTIFY_DONE;

3361 3362
	remove_user_radios(notify->portid);

3363
	if (notify->portid == hwsim_net_get_wmediumd(notify->net)) {
3364 3365
		printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
		       " socket, switching to perfect channel medium\n");
3366
		hwsim_register_wmediumd(notify->net, 0);
3367 3368 3369 3370 3371 3372 3373 3374 3375
	}
	return NOTIFY_DONE;

}

static struct notifier_block hwsim_netlink_notifier = {
	.notifier_call = mac80211_hwsim_netlink_notify,
};

3376
static int __init hwsim_init_netlink(void)
3377 3378
{
	int rc;
3379

3380 3381
	printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");

3382
	rc = genl_register_family(&hwsim_genl_family);
3383 3384 3385 3386
	if (rc)
		goto failure;

	rc = netlink_register_notifier(&hwsim_netlink_notifier);
3387 3388
	if (rc) {
		genl_unregister_family(&hwsim_genl_family);
3389
		goto failure;
3390
	}
3391 3392 3393 3394

	return 0;

failure:
3395
	pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
3396 3397 3398
	return -EINVAL;
}

3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420
static __net_init int hwsim_init_net(struct net *net)
{
	hwsim_net_set_netgroup(net);

	return 0;
}

static void __net_exit hwsim_exit_net(struct net *net)
{
	struct mac80211_hwsim_data *data, *tmp;

	spin_lock_bh(&hwsim_radio_lock);
	list_for_each_entry_safe(data, tmp, &hwsim_radios, list) {
		if (!net_eq(wiphy_net(data->hw->wiphy), net))
			continue;

		/* Radios created in init_net are returned to init_net. */
		if (data->netgroup == hwsim_net_get_netgroup(&init_net))
			continue;

		list_del(&data->list);
		INIT_WORK(&data->destroy_work, destroy_radio);
3421
		queue_work(hwsim_wq, &data->destroy_work);
3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432
	}
	spin_unlock_bh(&hwsim_radio_lock);
}

static struct pernet_operations hwsim_net_ops = {
	.init = hwsim_init_net,
	.exit = hwsim_exit_net,
	.id   = &hwsim_net_id,
	.size = sizeof(struct hwsim_net),
};

3433 3434 3435 3436 3437
static void hwsim_exit_netlink(void)
{
	/* unregister the notifier */
	netlink_unregister_notifier(&hwsim_netlink_notifier);
	/* unregister the family */
3438
	genl_unregister_family(&hwsim_genl_family);
3439 3440
}

3441 3442
static int __init init_mac80211_hwsim(void)
{
3443
	int i, err;
3444

3445
	if (radios < 0 || radios > 100)
3446 3447
		return -EINVAL;

3448 3449 3450
	if (channels < 1)
		return -EINVAL;

3451
	spin_lock_init(&hwsim_radio_lock);
3452

3453 3454 3455 3456
	hwsim_wq = alloc_workqueue("hwsim_wq",WQ_MEM_RECLAIM,0);
	if (!hwsim_wq)
		return -ENOMEM;

3457
	err = register_pernet_device(&hwsim_net_ops);
3458 3459 3460
	if (err)
		return err;

3461 3462 3463 3464
	err = platform_driver_register(&mac80211_hwsim_driver);
	if (err)
		goto out_unregister_pernet;

3465
	hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
3466 3467
	if (IS_ERR(hwsim_class)) {
		err = PTR_ERR(hwsim_class);
3468
		goto out_unregister_driver;
3469
	}
3470

3471 3472 3473 3474
	err = hwsim_init_netlink();
	if (err < 0)
		goto out_unregister_driver;

3475
	for (i = 0; i < radios; i++) {
3476 3477 3478
		struct hwsim_new_radio_params param = { 0 };

		param.channels = channels;
3479

3480 3481
		switch (regtest) {
		case HWSIM_REGTEST_DIFF_COUNTRY:
3482
			if (i < ARRAY_SIZE(hwsim_alpha2s))
3483
				param.reg_alpha2 = hwsim_alpha2s[i];
3484 3485 3486
			break;
		case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
			if (!i)
3487
				param.reg_alpha2 = hwsim_alpha2s[0];
3488 3489
			break;
		case HWSIM_REGTEST_STRICT_ALL:
3490
			param.reg_strict = true;
3491
		case HWSIM_REGTEST_DRIVER_REG_ALL:
3492
			param.reg_alpha2 = hwsim_alpha2s[0];
3493
			break;
3494 3495
		case HWSIM_REGTEST_WORLD_ROAM:
			if (i == 0)
3496
				param.regd = &hwsim_world_regdom_custom_01;
3497 3498
			break;
		case HWSIM_REGTEST_CUSTOM_WORLD:
3499
			param.regd = &hwsim_world_regdom_custom_01;
3500
			break;
3501
		case HWSIM_REGTEST_CUSTOM_WORLD_2:
3502
			if (i == 0)
3503
				param.regd = &hwsim_world_regdom_custom_01;
3504
			else if (i == 1)
3505
				param.regd = &hwsim_world_regdom_custom_02;
3506 3507
			break;
		case HWSIM_REGTEST_STRICT_FOLLOW:
3508
			if (i == 0) {
3509 3510
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[0];
3511
			}
3512 3513
			break;
		case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
3514
			if (i == 0) {
3515 3516
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[0];
3517
			} else if (i == 1) {
3518
				param.reg_alpha2 = hwsim_alpha2s[1];
3519
			}
3520 3521
			break;
		case HWSIM_REGTEST_ALL:
3522 3523
			switch (i) {
			case 0:
3524
				param.regd = &hwsim_world_regdom_custom_01;
3525 3526
				break;
			case 1:
3527
				param.regd = &hwsim_world_regdom_custom_02;
3528 3529
				break;
			case 2:
3530
				param.reg_alpha2 = hwsim_alpha2s[0];
3531 3532
				break;
			case 3:
3533
				param.reg_alpha2 = hwsim_alpha2s[1];
3534 3535
				break;
			case 4:
3536 3537
				param.reg_strict = true;
				param.reg_alpha2 = hwsim_alpha2s[2];
3538 3539
				break;
			}
3540 3541 3542 3543 3544
			break;
		default:
			break;
		}

3545 3546 3547 3548
		param.p2p_device = support_p2p_device;
		param.use_chanctx = channels > 1;

		err = mac80211_hwsim_new_radio(NULL, &param);
3549
		if (err < 0)
3550
			goto out_free_radios;
3551 3552
	}

3553 3554
	hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN,
				 hwsim_mon_setup);
3555 3556
	if (hwsim_mon == NULL) {
		err = -ENOMEM;
3557
		goto out_free_radios;
3558
	}
3559

3560 3561
	rtnl_lock();
	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
3562 3563 3564 3565
	if (err < 0) {
		rtnl_unlock();
		goto out_free_radios;
	}
3566 3567

	err = register_netdevice(hwsim_mon);
3568 3569 3570 3571
	if (err < 0) {
		rtnl_unlock();
		goto out_free_mon;
	}
3572 3573
	rtnl_unlock();

3574 3575
	return 0;

3576
out_free_mon:
3577
	free_netdev(hwsim_mon);
3578
out_free_radios:
3579
	mac80211_hwsim_free();
3580
out_unregister_driver:
3581
	platform_driver_unregister(&mac80211_hwsim_driver);
3582 3583
out_unregister_pernet:
	unregister_pernet_device(&hwsim_net_ops);
3584 3585
	return err;
}
3586
module_init(init_mac80211_hwsim);
3587 3588 3589

static void __exit exit_mac80211_hwsim(void)
{
3590
	pr_debug("mac80211_hwsim: unregister radios\n");
3591

3592 3593
	hwsim_exit_netlink();

3594
	mac80211_hwsim_free();
3595 3596
	flush_workqueue(hwsim_wq);

3597
	unregister_netdev(hwsim_mon);
3598
	platform_driver_unregister(&mac80211_hwsim_driver);
3599
	unregister_pernet_device(&hwsim_net_ops);
3600
	destroy_workqueue(hwsim_wq);
3601 3602
}
module_exit(exit_mac80211_hwsim);