Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

* Interface handling (except master interface)

2

* Interface handling (except master interface)

3

*

3

*

4

5

6

7

8

*

8

*

9

* This program is free software; you can redistribute it and/or modify

9

* This program is free software; you can redistribute it and/or modify

10

* it under the terms of the GNU General Public License version 2 as

10

* it under the terms of the GNU General Public License version 2 as

11

* published by the Free Software Foundation.

11

* published by the Free Software Foundation.

12

*/

12

*/

13

#include <linux/slab.h>

13

#include <linux/slab.h>

14

#include <linux/kernel.h>

14

#include <linux/kernel.h>

15

#include <linux/if_arp.h>

15

#include <linux/if_arp.h>

16

#include <linux/netdevice.h>

16

#include <linux/netdevice.h>

17

#include <linux/rtnetlink.h>

17

#include <linux/rtnetlink.h>

18

#include <net/mac80211.h>

18

#include <net/mac80211.h>

19

#include <net/ieee80211_radiotap.h>

19

#include <net/ieee80211_radiotap.h>

20

#include "ieee80211_i.h"

20

#include "ieee80211_i.h"

21

#include "sta_info.h"

21

#include "sta_info.h"

22

#include "debugfs_netdev.h"

22

#include "debugfs_netdev.h"

23

#include "mesh.h"

23

#include "mesh.h"

24

#include "led.h"

24

#include "led.h"

25

#include "driver-ops.h"

25

#include "driver-ops.h"

26

#include "wme.h"

26

#include "wme.h"

27

#include "rate.h"

27

#include "rate.h"

28

29

/**

29

/**

30

* DOC: Interface list locking

30

* DOC: Interface list locking

31

*

31

*

32

* The interface list in each struct ieee80211_local is protected

32

* The interface list in each struct ieee80211_local is protected

33

* three-fold:

33

* three-fold:

34

*

34

*

35

* (1) modifications may only be done under the RTNL

35

* (1) modifications may only be done under the RTNL

36

* (2) modifications and readers are protected against each other by

36

* (2) modifications and readers are protected against each other by

37

* the iflist_mtx.

37

* the iflist_mtx.

38

* (3) modifications are done in an RCU manner so atomic readers

38

* (3) modifications are done in an RCU manner so atomic readers

39

* can traverse the list in RCU-safe blocks.

39

* can traverse the list in RCU-safe blocks.

40

*

40

*

41

* As a consequence, reads (traversals) of the list can be protected

41

* As a consequence, reads (traversals) of the list can be protected

42

* by either the RTNL, the iflist_mtx or RCU.

42

* by either the RTNL, the iflist_mtx or RCU.

43

*/

43

*/

44

45

46

static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)

46

static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)

47

{

47

{

48

int meshhdrlen;

48

int meshhdrlen;

49

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

49

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

50

51

meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;

51

meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;

52

53

/* FIX: what would be proper limits for MTU?

53

/* FIX: what would be proper limits for MTU?

54

* This interface uses 802.3 frames. */

54

* This interface uses 802.3 frames. */

55

if (new_mtu < 256 ||

55

if (new_mtu < 256 ||

56

new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {

56

new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {

57

return -EINVAL;

57

return -EINVAL;

58

}

58

}

59

60

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

60

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

61

printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);

61

printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);

62

#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */

62

#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */

63

dev->mtu = new_mtu;

63

dev->mtu = new_mtu;

64

return 0;

64

return 0;

65

}

65

}

66

67

static int ieee80211_change_mac(struct net_device *dev, void *addr)

67

static int ieee80211_change_mac(struct net_device *dev, void *addr)

68

{

68

{

69

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

69

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

70

struct sockaddr *sa = addr;

70

struct sockaddr *sa = addr;

71

int ret;

71

int ret;

72

73

if (ieee80211_sdata_running(sdata))

73

if (ieee80211_sdata_running(sdata))

74

return -EBUSY;

74

return -EBUSY;

75

76

ret = eth_mac_addr(dev, sa);

76

ret = eth_mac_addr(dev, sa);

77

78

if (ret == 0)

78

if (ret == 0)

79

memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);

79

memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);

80

81

return ret;

81

return ret;

82

}

82

}

83

84

static inline int identical_mac_addr_allowed(int type1, int type2)

84

static inline int identical_mac_addr_allowed(int type1, int type2)

85

{

85

{

86

return type1 == NL80211_IFTYPE_MONITOR ||

86

return type1 == NL80211_IFTYPE_MONITOR ||

87

type2 == NL80211_IFTYPE_MONITOR ||

87

type2 == NL80211_IFTYPE_MONITOR ||

88

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||

88

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||

89

(type1 == NL80211_IFTYPE_WDS &&

89

(type1 == NL80211_IFTYPE_WDS &&

90

(type2 == NL80211_IFTYPE_WDS ||

90

(type2 == NL80211_IFTYPE_WDS ||

91

type2 == NL80211_IFTYPE_AP)) ||

91

type2 == NL80211_IFTYPE_AP)) ||

92

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||

92

(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||

93

(type1 == NL80211_IFTYPE_AP_VLAN &&

93

(type1 == NL80211_IFTYPE_AP_VLAN &&

94

(type2 == NL80211_IFTYPE_AP ||

94

(type2 == NL80211_IFTYPE_AP ||

95

type2 == NL80211_IFTYPE_AP_VLAN));

95

type2 == NL80211_IFTYPE_AP_VLAN));

96

}

96

}

97

98

static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,

98

static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,

99

enum nl80211_iftype iftype)

99

enum nl80211_iftype iftype)

100

{

100

{

101

struct ieee80211_local *local = sdata->local;

101

struct ieee80211_local *local = sdata->local;

102

struct ieee80211_sub_if_data *nsdata;

102

struct ieee80211_sub_if_data *nsdata;

103

struct net_device *dev = sdata->dev;

103

struct net_device *dev = sdata->dev;

104

105

ASSERT_RTNL();

105

ASSERT_RTNL();

106

107

/* we hold the RTNL here so can safely walk the list */

107

/* we hold the RTNL here so can safely walk the list */

108

list_for_each_entry(nsdata, &local->interfaces, list) {

108

list_for_each_entry(nsdata, &local->interfaces, list) {

109

struct net_device *ndev = nsdata->dev;

109

struct net_device *ndev = nsdata->dev;

110

111

if (ndev != dev && ieee80211_sdata_running(nsdata)) {

111

if (ndev != dev && ieee80211_sdata_running(nsdata)) {

112

/*

112

/*

113

* Allow only a single IBSS interface to be up at any

113

* Allow only a single IBSS interface to be up at any

114

* time. This is restricted because beacon distribution

114

* time. This is restricted because beacon distribution

115

* cannot work properly if both are in the same IBSS.

115

* cannot work properly if both are in the same IBSS.

116

*

116

*

117

* To remove this restriction we'd have to disallow them

117

* To remove this restriction we'd have to disallow them

118

* from setting the same SSID on different IBSS interfaces

118

* from setting the same SSID on different IBSS interfaces

119

* belonging to the same hardware. Then, however, we're

119

* belonging to the same hardware. Then, however, we're

120

* faced with having to adopt two different TSF timers...

120

* faced with having to adopt two different TSF timers...

121

*/

121

*/

122

if (iftype == NL80211_IFTYPE_ADHOC &&

122

if (iftype == NL80211_IFTYPE_ADHOC &&

123

nsdata->vif.type == NL80211_IFTYPE_ADHOC)

123

nsdata->vif.type == NL80211_IFTYPE_ADHOC)

124

return -EBUSY;

124

return -EBUSY;

125

126

/*

126

/*

127

* The remaining checks are only performed for interfaces

127

* The remaining checks are only performed for interfaces

128

* with the same MAC address.

128

* with the same MAC address.

129

*/

129

*/

130

if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))

130

if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))

131

continue;

131

continue;

132

133

/*

133

/*

134

* check whether it may have the same address

134

* check whether it may have the same address

135

*/

135

*/

136

if (!identical_mac_addr_allowed(iftype,

136

if (!identical_mac_addr_allowed(iftype,

137

nsdata->vif.type))

137

nsdata->vif.type))

138

return -ENOTUNIQ;

138

return -ENOTUNIQ;

139

140

/*

140

/*

141

* can only add VLANs to enabled APs

141

* can only add VLANs to enabled APs

142

*/

142

*/

143

if (iftype == NL80211_IFTYPE_AP_VLAN &&

143

if (iftype == NL80211_IFTYPE_AP_VLAN &&

144

nsdata->vif.type == NL80211_IFTYPE_AP)

144

nsdata->vif.type == NL80211_IFTYPE_AP)

145

sdata->bss = &nsdata->u.ap;

145

sdata->bss = &nsdata->u.ap;

146

}

146

}

147

}

147

}

148

149

return 0;

149

return 0;

150

}

150

}

151

152

void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,

152

void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,

153

const int offset)

153

const int offset)

154

{

154

{

155

struct ieee80211_local *local = sdata->local;

155

struct ieee80211_local *local = sdata->local;

156

u32 flags = sdata->u.mntr_flags;

156

u32 flags = sdata->u.mntr_flags;

157

158

#define ADJUST(_f, _s) do { \

158

#define ADJUST(_f, _s) do { \

159

if (flags & MONITOR_FLAG_##_f) \

159

if (flags & MONITOR_FLAG_##_f) \

160

local->fif_##_s += offset; \

160

local->fif_##_s += offset; \

161

} while (0)

161

} while (0)

162

163

ADJUST(FCSFAIL, fcsfail);

163

ADJUST(FCSFAIL, fcsfail);

164

ADJUST(PLCPFAIL, plcpfail);

164

ADJUST(PLCPFAIL, plcpfail);

165

ADJUST(CONTROL, control);

165

ADJUST(CONTROL, control);

166

ADJUST(CONTROL, pspoll);

166

ADJUST(CONTROL, pspoll);

167

ADJUST(OTHER_BSS, other_bss);

167

ADJUST(OTHER_BSS, other_bss);

168

169

#undef ADJUST

169

#undef ADJUST

170

}

170

}

171

172

/*

172

/*

173

* NOTE: Be very careful when changing this function, it must NOT return

173

* NOTE: Be very careful when changing this function, it must NOT return

174

* an error on interface type changes that have been pre-checked, so most

174

* an error on interface type changes that have been pre-checked, so most

175

* checks should be in ieee80211_check_concurrent_iface.

175

* checks should be in ieee80211_check_concurrent_iface.

176

*/

176

*/

177

static int ieee80211_do_open(struct net_device *dev, bool coming_up)

177

static int ieee80211_do_open(struct net_device *dev, bool coming_up)

178

{

178

{

179

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

179

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

180

struct ieee80211_local *local = sdata->local;

180

struct ieee80211_local *local = sdata->local;

181

struct sta_info *sta;

181

struct sta_info *sta;

182

u32 changed = 0;

182

u32 changed = 0;

183

int res;

183

int res;

184

u32 hw_reconf_flags = 0;

184

u32 hw_reconf_flags = 0;

185

186

switch (sdata->vif.type) {

186

switch (sdata->vif.type) {

187

case NL80211_IFTYPE_WDS:

187

case NL80211_IFTYPE_WDS:

188

if (!is_valid_ether_addr(sdata->u.wds.remote_addr))

188

if (!is_valid_ether_addr(sdata->u.wds.remote_addr))

189

return -ENOLINK;

189

return -ENOLINK;

190

break;

190

break;

191

case NL80211_IFTYPE_AP_VLAN:

191

case NL80211_IFTYPE_AP_VLAN:

192

if (!sdata->bss)

192

if (!sdata->bss)

193

return -ENOLINK;

193

return -ENOLINK;

194

list_add(&sdata->u.vlan.list, &sdata->bss->vlans);

194

list_add(&sdata->u.vlan.list, &sdata->bss->vlans);

195

break;

195

break;

196

case NL80211_IFTYPE_AP:

196

case NL80211_IFTYPE_AP:

197

sdata->bss = &sdata->u.ap;

197

sdata->bss = &sdata->u.ap;

198

break;

198

break;

199

case NL80211_IFTYPE_MESH_POINT:

199

case NL80211_IFTYPE_MESH_POINT:

200

case NL80211_IFTYPE_STATION:

200

case NL80211_IFTYPE_STATION:

201

case NL80211_IFTYPE_MONITOR:

201

case NL80211_IFTYPE_MONITOR:

202

case NL80211_IFTYPE_ADHOC:

202

case NL80211_IFTYPE_ADHOC:

203

/* no special treatment */

203

/* no special treatment */

204

break;

204

break;

205

case NL80211_IFTYPE_UNSPECIFIED:

205

case NL80211_IFTYPE_UNSPECIFIED:

206

case NUM_NL80211_IFTYPES:

206

case NUM_NL80211_IFTYPES:

207

case NL80211_IFTYPE_P2P_CLIENT:

207

case NL80211_IFTYPE_P2P_CLIENT:

208

case NL80211_IFTYPE_P2P_GO:

208

case NL80211_IFTYPE_P2P_GO:

209

/* cannot happen */

209

/* cannot happen */

210

WARN_ON(1);

210

WARN_ON(1);

211

break;

211

break;

212

}

212

}

213

214

if (local->open_count == 0) {

214

if (local->open_count == 0) {

215

res = drv_start(local);

215

res = drv_start(local);

216

if (res)

216

if (res)

217

goto err_del_bss;

217

goto err_del_bss;

218

if (local->ops->napi_poll)

218

if (local->ops->napi_poll)

219

napi_enable(&local->napi);

219

napi_enable(&local->napi);

220

/* we're brought up, everything changes */

220

/* we're brought up, everything changes */

221

hw_reconf_flags = ~0;

221

hw_reconf_flags = ~0;

222

ieee80211_led_radio(local, true);

222

ieee80211_led_radio(local, true);

223

ieee80211_mod_tpt_led_trig(local,

223

ieee80211_mod_tpt_led_trig(local,

224

IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);

224

IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);

225

}

225

}

226

227

/*

227

/*

228

* Copy the hopefully now-present MAC address to

228

* Copy the hopefully now-present MAC address to

229

* this interface, if it has the special null one.

229

* this interface, if it has the special null one.

230

*/

230

*/

231

if (is_zero_ether_addr(dev->dev_addr)) {

231

if (is_zero_ether_addr(dev->dev_addr)) {

232

memcpy(dev->dev_addr,

232

memcpy(dev->dev_addr,

233

local->hw.wiphy->perm_addr,

233

local->hw.wiphy->perm_addr,

234

ETH_ALEN);

234

ETH_ALEN);

235

memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);

235

memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);

236

237

if (!is_valid_ether_addr(dev->dev_addr)) {

237

if (!is_valid_ether_addr(dev->dev_addr)) {

238

if (!local->open_count)

238

if (!local->open_count)

239

drv_stop(local);

239

drv_stop(local);

240

return -EADDRNOTAVAIL;

240

return -EADDRNOTAVAIL;

241

}

241

}

242

}

242

}

243

244

switch (sdata->vif.type) {

244

switch (sdata->vif.type) {

245

case NL80211_IFTYPE_AP_VLAN:

245

case NL80211_IFTYPE_AP_VLAN:

246

/* no need to tell driver */

246

/* no need to tell driver */

247

break;

247

break;

248

case NL80211_IFTYPE_MONITOR:

248

case NL80211_IFTYPE_MONITOR:

249

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

249

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

250

local->cooked_mntrs++;

250

local->cooked_mntrs++;

251

break;

251

break;

252

}

252

}

253

254

/* must be before the call to ieee80211_configure_filter */

254

/* must be before the call to ieee80211_configure_filter */

255

local->monitors++;

255

local->monitors++;

256

if (local->monitors == 1) {

256

if (local->monitors == 1) {

257

local->hw.conf.flags |= IEEE80211_CONF_MONITOR;

257

local->hw.conf.flags |= IEEE80211_CONF_MONITOR;

258

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

258

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

259

}

259

}

260

261

ieee80211_adjust_monitor_flags(sdata, 1);

261

ieee80211_adjust_monitor_flags(sdata, 1);

262

ieee80211_configure_filter(local);

262

ieee80211_configure_filter(local);

263

264

netif_carrier_on(dev);

264

netif_carrier_on(dev);

265

break;

265

break;

266

default:

266

default:

267

if (coming_up) {

267

if (coming_up) {

268

res = drv_add_interface(local, &sdata->vif);

268

res = drv_add_interface(local, &sdata->vif);

269

if (res)

269

if (res)

270

goto err_stop;

270

goto err_stop;

271

}

271

}

272

273

if (sdata->vif.type == NL80211_IFTYPE_AP) {

273

if (sdata->vif.type == NL80211_IFTYPE_AP) {

274

local->fif_pspoll++;

274

local->fif_pspoll++;

275

local->fif_probe_req++;

275

local->fif_probe_req++;

276

277

ieee80211_configure_filter(local);

277

ieee80211_configure_filter(local);

278

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

278

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

279

local->fif_probe_req++;

279

local->fif_probe_req++;

280

}

280

}

281

282

changed |= ieee80211_reset_erp_info(sdata);

282

changed |= ieee80211_reset_erp_info(sdata);

283

ieee80211_bss_info_change_notify(sdata, changed);

283

ieee80211_bss_info_change_notify(sdata, changed);

284

285

if (sdata->vif.type == NL80211_IFTYPE_STATION)

285

if (sdata->vif.type == NL80211_IFTYPE_STATION)

286

netif_carrier_off(dev);

286

netif_carrier_off(dev);

287

else

287

else

288

netif_carrier_on(dev);

288

netif_carrier_on(dev);

289

}

289

}

290

291

set_bit(SDATA_STATE_RUNNING, &sdata->state);

291

set_bit(SDATA_STATE_RUNNING, &sdata->state);

292

293

if (sdata->vif.type == NL80211_IFTYPE_WDS) {

293

if (sdata->vif.type == NL80211_IFTYPE_WDS) {

294

/* Create STA entry for the WDS peer */

294

/* Create STA entry for the WDS peer */

295

sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,

295

sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,

296

GFP_KERNEL);

296

GFP_KERNEL);

297

if (!sta) {

297

if (!sta) {

298

res = -ENOMEM;

298

res = -ENOMEM;

299

goto err_del_interface;

299

goto err_del_interface;

300

}

300

}

301

302

/* no locking required since STA is not live yet */

302

/* no locking required since STA is not live yet */

303

sta->flags |= WLAN_STA_AUTHORIZED;

303

sta->flags |= WLAN_STA_AUTHORIZED;

304

305

res = sta_info_insert(sta);

305

res = sta_info_insert(sta);

306

if (res) {

306

if (res) {

307

/* STA has been freed */

307

/* STA has been freed */

308

goto err_del_interface;

308

goto err_del_interface;

309

}

309

}

310

311

rate_control_rate_init(sta);

311

rate_control_rate_init(sta);

312

}

312

}

313

314

/*

314

/*

315

* set_multicast_list will be invoked by the networking core

315

* set_multicast_list will be invoked by the networking core

316

* which will check whether any increments here were done in

316

* which will check whether any increments here were done in

317

* error and sync them down to the hardware as filter flags.

317

* error and sync them down to the hardware as filter flags.

318

*/

318

*/

319

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

319

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

320

atomic_inc(&local->iff_allmultis);

320

atomic_inc(&local->iff_allmultis);

321

322

if (sdata->flags & IEEE80211_SDATA_PROMISC)

322

if (sdata->flags & IEEE80211_SDATA_PROMISC)

323

atomic_inc(&local->iff_promiscs);

323

atomic_inc(&local->iff_promiscs);

324

325

mutex_lock(&local->mtx);

325

mutex_lock(&local->mtx);

326

hw_reconf_flags |= __ieee80211_recalc_idle(local);

326

hw_reconf_flags |= __ieee80211_recalc_idle(local);

327

mutex_unlock(&local->mtx);

327

mutex_unlock(&local->mtx);

328

329

if (coming_up)

329

if (coming_up)

330

local->open_count++;

330

local->open_count++;

331

332

if (hw_reconf_flags) {

332

if (hw_reconf_flags) {

333

ieee80211_hw_config(local, hw_reconf_flags);

333

ieee80211_hw_config(local, hw_reconf_flags);

334

/*

334

/*

335

* set default queue parameters so drivers don't

335

* set default queue parameters so drivers don't

336

* need to initialise the hardware if the hardware

336

* need to initialise the hardware if the hardware

337

* doesn't start up with sane defaults

337

* doesn't start up with sane defaults

338

*/

338

*/

339

ieee80211_set_wmm_default(sdata);

339

ieee80211_set_wmm_default(sdata);

340

}

340

}

341

342

ieee80211_recalc_ps(local, -1);

342

ieee80211_recalc_ps(local, -1);

343

344

netif_tx_start_all_queues(dev);

344

netif_tx_start_all_queues(dev);

345

346

return 0;

346

return 0;

347

err_del_interface:

347

err_del_interface:

348

drv_remove_interface(local, &sdata->vif);

348

drv_remove_interface(local, &sdata->vif);

349

err_stop:

349

err_stop:

350

if (!local->open_count)

350

if (!local->open_count)

351

drv_stop(local);

351

drv_stop(local);

352

err_del_bss:

352

err_del_bss:

353

sdata->bss = NULL;

353

sdata->bss = NULL;

354

if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)

354

if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)

355

list_del(&sdata->u.vlan.list);

355

list_del(&sdata->u.vlan.list);

356

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

356

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

357

return res;

357

return res;

358

}

358

}

359

360

static int ieee80211_open(struct net_device *dev)

360

static int ieee80211_open(struct net_device *dev)

361

{

361

{

362

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

362

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

363

int err;

363

int err;

364

365

/* fail early if user set an invalid address */

365

/* fail early if user set an invalid address */

366

if (!is_zero_ether_addr(dev->dev_addr) &&

366

if (!is_zero_ether_addr(dev->dev_addr) &&

367

!is_valid_ether_addr(dev->dev_addr))

367

!is_valid_ether_addr(dev->dev_addr))

368

return -EADDRNOTAVAIL;

368

return -EADDRNOTAVAIL;

369

370

err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);

370

err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);

371

if (err)

371

if (err)

372

return err;

372

return err;

373

374

return ieee80211_do_open(dev, true);

374

return ieee80211_do_open(dev, true);

375

}

375

}

376

377

static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,

377

static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,

378

bool going_down)

378

bool going_down)

379

{

379

{

380

struct ieee80211_local *local = sdata->local;

380

struct ieee80211_local *local = sdata->local;

381

unsigned long flags;

381

unsigned long flags;

382

struct sk_buff *skb, *tmp;

382

struct sk_buff *skb, *tmp;

383

u32 hw_reconf_flags = 0;

383

u32 hw_reconf_flags = 0;

384

int i;

384

int i;

385

386

if (local->scan_sdata == sdata)

386

if (local->scan_sdata == sdata)

387

ieee80211_scan_cancel(local);

387

ieee80211_scan_cancel(local);

388

389

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

389

clear_bit(SDATA_STATE_RUNNING, &sdata->state);

390

391

/*

391

/*

392

* Stop TX on this interface first.

392

* Stop TX on this interface first.

393

*/

393

*/

394

netif_tx_stop_all_queues(sdata->dev);

394

netif_tx_stop_all_queues(sdata->dev);

395

396

/*

396

/*

397

* Purge work for this interface.

397

* Purge work for this interface.

398

*/

398

*/

399

ieee80211_work_purge(sdata);

399

ieee80211_work_purge(sdata);

400

401

/*

401

/*

402

* Remove all stations associated with this interface.

402

* Remove all stations associated with this interface.

403

*

403

*

404

* This must be done before calling ops->remove_interface()

404

* This must be done before calling ops->remove_interface()

405

* because otherwise we can later invoke ops->sta_notify()

405

* because otherwise we can later invoke ops->sta_notify()

406

* whenever the STAs are removed, and that invalidates driver

406

* whenever the STAs are removed, and that invalidates driver

407

* assumptions about always getting a vif pointer that is valid

407

* assumptions about always getting a vif pointer that is valid

408

* (because if we remove a STA after ops->remove_interface()

408

* (because if we remove a STA after ops->remove_interface()

409

* the driver will have removed the vif info already!)

409

* the driver will have removed the vif info already!)

410

*

410

*

411

* This is relevant only in AP, WDS and mesh modes, since in

411

* This is relevant only in AP, WDS and mesh modes, since in

412

* all other modes we've already removed all stations when

412

* all other modes we've already removed all stations when

413

* disconnecting etc.

413

* disconnecting etc.

414

*/

414

*/

415

sta_info_flush(local, sdata);

415

sta_info_flush(local, sdata);

416

417

/*

417

/*

418

* Don't count this interface for promisc/allmulti while it

418

* Don't count this interface for promisc/allmulti while it

419

* is down. dev_mc_unsync() will invoke set_multicast_list

419

* is down. dev_mc_unsync() will invoke set_multicast_list

420

* on the master interface which will sync these down to the

420

* on the master interface which will sync these down to the

421

* hardware as filter flags.

421

* hardware as filter flags.

422

*/

422

*/

423

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

423

if (sdata->flags & IEEE80211_SDATA_ALLMULTI)

424

atomic_dec(&local->iff_allmultis);

424

atomic_dec(&local->iff_allmultis);

425

426

if (sdata->flags & IEEE80211_SDATA_PROMISC)

426

if (sdata->flags & IEEE80211_SDATA_PROMISC)

427

atomic_dec(&local->iff_promiscs);

427

atomic_dec(&local->iff_promiscs);

428

429

if (sdata->vif.type == NL80211_IFTYPE_AP) {

429

if (sdata->vif.type == NL80211_IFTYPE_AP) {

430

local->fif_pspoll--;

430

local->fif_pspoll--;

431

local->fif_probe_req--;

431

local->fif_probe_req--;

432

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

432

} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {

433

local->fif_probe_req--;

433

local->fif_probe_req--;

434

}

434

}

435

436

netif_addr_lock_bh(sdata->dev);

436

netif_addr_lock_bh(sdata->dev);

437

spin_lock_bh(&local->filter_lock);

437

spin_lock_bh(&local->filter_lock);

438

__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,

438

__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,

439

sdata->dev->addr_len);

439

sdata->dev->addr_len);

440

spin_unlock_bh(&local->filter_lock);

440

spin_unlock_bh(&local->filter_lock);

441

netif_addr_unlock_bh(sdata->dev);

441

netif_addr_unlock_bh(sdata->dev);

442

443

ieee80211_configure_filter(local);

443

ieee80211_configure_filter(local);

444

445

del_timer_sync(&local->dynamic_ps_timer);

445

del_timer_sync(&local->dynamic_ps_timer);

446

cancel_work_sync(&local->dynamic_ps_enable_work);

446

cancel_work_sync(&local->dynamic_ps_enable_work);

447

448

/* APs need special treatment */

448

/* APs need special treatment */

449

if (sdata->vif.type == NL80211_IFTYPE_AP) {

449

if (sdata->vif.type == NL80211_IFTYPE_AP) {

450

struct ieee80211_sub_if_data *vlan, *tmpsdata;

450

struct ieee80211_sub_if_data *vlan, *tmpsdata;

451

struct beacon_data *old_beacon = sdata->u.ap.beacon;

451

struct beacon_data *old_beacon = sdata->u.ap.beacon;

452

453

/* sdata_running will return false, so this will disable */

453

/* sdata_running will return false, so this will disable */

454

ieee80211_bss_info_change_notify(sdata,

454

ieee80211_bss_info_change_notify(sdata,

455

BSS_CHANGED_BEACON_ENABLED);

455

BSS_CHANGED_BEACON_ENABLED);

456

457

/* remove beacon */

457

/* remove beacon */

458

rcu_assign_pointer(sdata->u.ap.beacon, NULL);

458

rcu_assign_pointer(sdata->u.ap.beacon, NULL);

459

synchronize_rcu();

459

synchronize_rcu();

460

kfree(old_beacon);

460

kfree(old_beacon);

461

462

/* free all potentially still buffered bcast frames */

462

/* free all potentially still buffered bcast frames */

463

while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {

463

while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {

464

local->total_ps_buffered--;

464

local->total_ps_buffered--;

465

dev_kfree_skb(skb);

465

dev_kfree_skb(skb);

466

}

466

}

467

468

/* down all dependent devices, that is VLANs */

468

/* down all dependent devices, that is VLANs */

469

list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,

469

list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,

470

u.vlan.list)

470

u.vlan.list)

471

dev_close(vlan->dev);

471

dev_close(vlan->dev);

472

WARN_ON(!list_empty(&sdata->u.ap.vlans));

472

WARN_ON(!list_empty(&sdata->u.ap.vlans));

473

}

473

}

474

475

if (going_down)

475

if (going_down)

476

local->open_count--;

476

local->open_count--;

477

478

switch (sdata->vif.type) {

478

switch (sdata->vif.type) {

479

case NL80211_IFTYPE_AP_VLAN:

479

case NL80211_IFTYPE_AP_VLAN:

480

list_del(&sdata->u.vlan.list);

480

list_del(&sdata->u.vlan.list);

481

/* no need to tell driver */

481

/* no need to tell driver */

482

break;

482

break;

483

case NL80211_IFTYPE_MONITOR:

483

case NL80211_IFTYPE_MONITOR:

484

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

484

if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {

485

local->cooked_mntrs--;

485

local->cooked_mntrs--;

486

break;

486

break;

487

}

487

}

488

489

local->monitors--;

489

local->monitors--;

490

if (local->monitors == 0) {

490

if (local->monitors == 0) {

491

local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;

491

local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;

492

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

492

hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;

493

}

493

}

494

495

ieee80211_adjust_monitor_flags(sdata, -1);

495

ieee80211_adjust_monitor_flags(sdata, -1);

496

ieee80211_configure_filter(local);

496

ieee80211_configure_filter(local);

497

break;

497

break;

498

default:

498

default:

499

flush_work(&sdata->work);

499

flush_work(&sdata->work);

500

/*

500

/*

501

* When we get here, the interface is marked down.

501

* When we get here, the interface is marked down.

502

* Call synchronize_rcu() to wait for the RX path

502

* Call synchronize_rcu() to wait for the RX path

503

* should it be using the interface and enqueuing

503

* should it be using the interface and enqueuing

504

* frames at this very time on another CPU.

504

* frames at this very time on another CPU.

505

*/

505

*/

506

synchronize_rcu();

506

synchronize_rcu();

507

skb_queue_purge(&sdata->skb_queue);

507

skb_queue_purge(&sdata->skb_queue);

508

509

/*

509

/*

510

* Disable beaconing here for mesh only, AP and IBSS

510

* Disable beaconing here for mesh only, AP and IBSS

511

* are already taken care of.

511

* are already taken care of.

512

*/

512

*/

513

if (sdata->vif.type == NL80211_IFTYPE_MESH_POINT)

513

if (sdata->vif.type == NL80211_IFTYPE_MESH_POINT)

514

ieee80211_bss_info_change_notify(sdata,

514

ieee80211_bss_info_change_notify(sdata,

515

BSS_CHANGED_BEACON_ENABLED);

515

BSS_CHANGED_BEACON_ENABLED);

516

517

/*

517

/*

518

* Free all remaining keys, there shouldn't be any,

518

* Free all remaining keys, there shouldn't be any,

519

* except maybe group keys in AP more or WDS?

519

* except maybe group keys in AP more or WDS?

520

*/

520

*/

521

ieee80211_free_keys(sdata);

521

ieee80211_free_keys(sdata);

522

523

if (going_down)

523

if (going_down)

524

drv_remove_interface(local, &sdata->vif);

524

drv_remove_interface(local, &sdata->vif);

525

}

525

}

526

527

sdata->bss = NULL;

527

sdata->bss = NULL;

528

529

mutex_lock(&local->mtx);

529

mutex_lock(&local->mtx);

530

hw_reconf_flags |= __ieee80211_recalc_idle(local);

530

hw_reconf_flags |= __ieee80211_recalc_idle(local);

531

mutex_unlock(&local->mtx);

531

mutex_unlock(&local->mtx);

532

533

ieee80211_recalc_ps(local, -1);

533

ieee80211_recalc_ps(local, -1);

534

535

if (local->open_count == 0) {

535

if (local->open_count == 0) {

536

if (local->ops->napi_poll)

536

if (local->ops->napi_poll)

537

napi_disable(&local->napi);

537

napi_disable(&local->napi);

538

ieee80211_clear_tx_pending(local);

538

ieee80211_clear_tx_pending(local);

539

ieee80211_stop_device(local);

539

ieee80211_stop_device(local);

540

541

/* no reconfiguring after stop! */

541

/* no reconfiguring after stop! */

542

hw_reconf_flags = 0;

542

hw_reconf_flags = 0;

543

}

543

}

544

545

/* do after stop to avoid reconfiguring when we stop anyway */

545

/* do after stop to avoid reconfiguring when we stop anyway */

546

if (hw_reconf_flags)

546

if (hw_reconf_flags)

547

ieee80211_hw_config(local, hw_reconf_flags);

547

ieee80211_hw_config(local, hw_reconf_flags);

548

549

spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

549

spin_lock_irqsave(&local->queue_stop_reason_lock, flags);

550

for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {

550

for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {

551

skb_queue_walk_safe(&local->pending[i], skb, tmp) {

551

skb_queue_walk_safe(&local->pending[i], skb, tmp) {

552

struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

552

struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

553

if (info->control.vif == &sdata->vif) {

553

if (info->control.vif == &sdata->vif) {

554

__skb_unlink(skb, &local->pending[i]);

554

__skb_unlink(skb, &local->pending[i]);

555

dev_kfree_skb_irq(skb);

555

dev_kfree_skb_irq(skb);

556

}

556

}

557

}

557

}

558

}

558

}

559

spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);

559

spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);

560

}

560

}

561

562

static int ieee80211_stop(struct net_device *dev)

562

static int ieee80211_stop(struct net_device *dev)

563

{

563

{

564

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

564

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

565

566

ieee80211_do_stop(sdata, true);

566

ieee80211_do_stop(sdata, true);

567

568

return 0;

568

return 0;

569

}

569

}

570

571

static void ieee80211_set_multicast_list(struct net_device *dev)

571

static void ieee80211_set_multicast_list(struct net_device *dev)

572

{

572

{

573

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

573

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

574

struct ieee80211_local *local = sdata->local;

574

struct ieee80211_local *local = sdata->local;

575

int allmulti, promisc, sdata_allmulti, sdata_promisc;

575

int allmulti, promisc, sdata_allmulti, sdata_promisc;

576

577

allmulti = !!(dev->flags & IFF_ALLMULTI);

577

allmulti = !!(dev->flags & IFF_ALLMULTI);

578

promisc = !!(dev->flags & IFF_PROMISC);

578

promisc = !!(dev->flags & IFF_PROMISC);

579

sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);

579

sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);

580

sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);

580

sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);

581

582

if (allmulti != sdata_allmulti) {

582

if (allmulti != sdata_allmulti) {

583

if (dev->flags & IFF_ALLMULTI)

583

if (dev->flags & IFF_ALLMULTI)

584

atomic_inc(&local->iff_allmultis);

584

atomic_inc(&local->iff_allmultis);

585

else

585

else

586

atomic_dec(&local->iff_allmultis);

586

atomic_dec(&local->iff_allmultis);

587

sdata->flags ^= IEEE80211_SDATA_ALLMULTI;

587

sdata->flags ^= IEEE80211_SDATA_ALLMULTI;

588

}

588

}

589

590

if (promisc != sdata_promisc) {

590

if (promisc != sdata_promisc) {

591

if (dev->flags & IFF_PROMISC)

591

if (dev->flags & IFF_PROMISC)

592

atomic_inc(&local->iff_promiscs);

592

atomic_inc(&local->iff_promiscs);

593

else

593

else

594

atomic_dec(&local->iff_promiscs);

594

atomic_dec(&local->iff_promiscs);

595

sdata->flags ^= IEEE80211_SDATA_PROMISC;

595

sdata->flags ^= IEEE80211_SDATA_PROMISC;

596

}

596

}

597

spin_lock_bh(&local->filter_lock);

597

spin_lock_bh(&local->filter_lock);

598

__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);

598

__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);

599

spin_unlock_bh(&local->filter_lock);

599

spin_unlock_bh(&local->filter_lock);

600

ieee80211_queue_work(&local->hw, &local->reconfig_filter);

600

ieee80211_queue_work(&local->hw, &local->reconfig_filter);

601

}

601

}

602

603

/*

603

/*

604

* Called when the netdev is removed or, by the code below, before

604

* Called when the netdev is removed or, by the code below, before

605

* the interface type changes.

605

* the interface type changes.

606

*/

606

*/

607

static void ieee80211_teardown_sdata(struct net_device *dev)

607

static void ieee80211_teardown_sdata(struct net_device *dev)

608

{

608

{

609

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

609

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

610

struct ieee80211_local *local = sdata->local;

610

struct ieee80211_local *local = sdata->local;

611

int flushed;

611

int flushed;

612

int i;

612

int i;

613

614

/* free extra data */

614

/* free extra data */

615

ieee80211_free_keys(sdata);

615

ieee80211_free_keys(sdata);

616

617

ieee80211_debugfs_remove_netdev(sdata);

617

ieee80211_debugfs_remove_netdev(sdata);

618

619

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

619

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

620

__skb_queue_purge(&sdata->fragments[i].skb_list);

620

__skb_queue_purge(&sdata->fragments[i].skb_list);

621

sdata->fragment_next = 0;

621

sdata->fragment_next = 0;

622

623

if (ieee80211_vif_is_mesh(&sdata->vif))

623

if (ieee80211_vif_is_mesh(&sdata->vif))

624

mesh_rmc_free(sdata);

624

mesh_rmc_free(sdata);

625

626

flushed = sta_info_flush(local, sdata);

626

flushed = sta_info_flush(local, sdata);

627

WARN_ON(flushed);

627

WARN_ON(flushed);

628

}

628

}

629

630

static u16 ieee80211_netdev_select_queue(struct net_device *dev,

630

static u16 ieee80211_netdev_select_queue(struct net_device *dev,

631

struct sk_buff *skb)

631

struct sk_buff *skb)

632

{

632

{

633

return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);

633

return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);

634

}

634

}

635

636

static const struct net_device_ops ieee80211_dataif_ops = {

636

static const struct net_device_ops ieee80211_dataif_ops = {

637

.ndo_open = ieee80211_open,

637

.ndo_open = ieee80211_open,

638

.ndo_stop = ieee80211_stop,

638

.ndo_stop = ieee80211_stop,

639

.ndo_uninit = ieee80211_teardown_sdata,

639

.ndo_uninit = ieee80211_teardown_sdata,

640

.ndo_start_xmit = ieee80211_subif_start_xmit,

640

.ndo_start_xmit = ieee80211_subif_start_xmit,

641

.ndo_set_multicast_list = ieee80211_set_multicast_list,

641

.ndo_set_multicast_list = ieee80211_set_multicast_list,

642

.ndo_change_mtu = ieee80211_change_mtu,

642

.ndo_change_mtu = ieee80211_change_mtu,

643

.ndo_set_mac_address = ieee80211_change_mac,

643

.ndo_set_mac_address = ieee80211_change_mac,

644

.ndo_select_queue = ieee80211_netdev_select_queue,

644

.ndo_select_queue = ieee80211_netdev_select_queue,

645

};

645

};

646

647

static u16 ieee80211_monitor_select_queue(struct net_device *dev,

647

static u16 ieee80211_monitor_select_queue(struct net_device *dev,

648

struct sk_buff *skb)

648

struct sk_buff *skb)

649

{

649

{

650

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

650

struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

651

struct ieee80211_local *local = sdata->local;

651

struct ieee80211_local *local = sdata->local;

652

struct ieee80211_hdr *hdr;

652

struct ieee80211_hdr *hdr;

653

struct ieee80211_radiotap_header *rtap = (void *)skb->data;

653

struct ieee80211_radiotap_header *rtap = (void *)skb->data;

654

u8 *p;

654

u8 *p;

655

656

if (local->hw.queues < 4)

656

if (local->hw.queues < 4)

657

return 0;

657

return 0;

658

659

if (skb->len < 4 ||

659

if (skb->len < 4 ||

660

skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)

660

skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)

661

return 0; /* doesn't matter, frame will be dropped */

661

return 0; /* doesn't matter, frame will be dropped */

662

663

hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));

663

hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));

664

665

if (!ieee80211_is_data(hdr->frame_control)) {

665

if (!ieee80211_is_data(hdr->frame_control)) {

666

skb->priority = 7;

666

skb->priority = 7;

667

return ieee802_1d_to_ac[skb->priority];

667

return ieee802_1d_to_ac[skb->priority];

668

}

668

}

669

if (!ieee80211_is_data_qos(hdr->frame_control)) {

669

if (!ieee80211_is_data_qos(hdr->frame_control)) {

670

skb->priority = 0;

670

skb->priority = 0;

671

return ieee802_1d_to_ac[skb->priority];

671

return ieee802_1d_to_ac[skb->priority];

672

}

672

}

673

674

p = ieee80211_get_qos_ctl(hdr);

674

p = ieee80211_get_qos_ctl(hdr);

675

skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;

675

skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;

676

677

return ieee80211_downgrade_queue(local, skb);

677

return ieee80211_downgrade_queue(local, skb);

678

}

678

}

679

680

static const struct net_device_ops ieee80211_monitorif_ops = {

680

static const struct net_device_ops ieee80211_monitorif_ops = {

681

.ndo_open = ieee80211_open,

681

.ndo_open = ieee80211_open,

682

.ndo_stop = ieee80211_stop,

682

.ndo_stop = ieee80211_stop,

683

.ndo_uninit = ieee80211_teardown_sdata,

683

.ndo_uninit = ieee80211_teardown_sdata,

684

.ndo_start_xmit = ieee80211_monitor_start_xmit,

684

.ndo_start_xmit = ieee80211_monitor_start_xmit,

685

.ndo_set_multicast_list = ieee80211_set_multicast_list,

685

.ndo_set_multicast_list = ieee80211_set_multicast_list,

686

.ndo_change_mtu = ieee80211_change_mtu,

686

.ndo_change_mtu = ieee80211_change_mtu,

687

.ndo_set_mac_address = eth_mac_addr,

687

.ndo_set_mac_address = eth_mac_addr,

688

.ndo_select_queue = ieee80211_monitor_select_queue,

688

.ndo_select_queue = ieee80211_monitor_select_queue,

689

};

689

};

690

691

static void ieee80211_if_setup(struct net_device *dev)

691

static void ieee80211_if_setup(struct net_device *dev)

692

{

692

{

693

ether_setup(dev);

693

ether_setup(dev);

694

dev->netdev_ops = &ieee80211_dataif_ops;

694

dev->netdev_ops = &ieee80211_dataif_ops;

695

dev->destructor = free_netdev;

695

dev->destructor = free_netdev;

696

}

696

}

697

698

static void ieee80211_iface_work(struct work_struct *work)

698

static void ieee80211_iface_work(struct work_struct *work)

699

{

699

{

700

struct ieee80211_sub_if_data *sdata =

700

struct ieee80211_sub_if_data *sdata =

701

container_of(work, struct ieee80211_sub_if_data, work);

701

container_of(work, struct ieee80211_sub_if_data, work);

702

struct ieee80211_local *local = sdata->local;

702

struct ieee80211_local *local = sdata->local;

703

struct sk_buff *skb;

703

struct sk_buff *skb;

704

struct sta_info *sta;

704

struct sta_info *sta;

705

struct ieee80211_ra_tid *ra_tid;

705

struct ieee80211_ra_tid *ra_tid;

706

707

if (!ieee80211_sdata_running(sdata))

707

if (!ieee80211_sdata_running(sdata))

708

return;

708

return;

709

710

if (local->scanning)

710

if (local->scanning)

711

return;

711

return;

712

713

/*

713

/*

714

* ieee80211_queue_work() should have picked up most cases,

714

* ieee80211_queue_work() should have picked up most cases,

715

* here we'll pick the rest.

715

* here we'll pick the rest.

716

*/

716

*/

717

if (WARN(local->suspended,

717

if (WARN(local->suspended,

718

"interface work scheduled while going to suspend\n"))

718

"interface work scheduled while going to suspend\n"))

719

return;

719

return;

720

721

/* first process frames */

721

/* first process frames */

722

while ((skb = skb_dequeue(&sdata->skb_queue))) {

722

while ((skb = skb_dequeue(&sdata->skb_queue))) {

723

struct ieee80211_mgmt *mgmt = (void *)skb->data;

723

struct ieee80211_mgmt *mgmt = (void *)skb->data;

724

725

if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {

725

if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {

726

ra_tid = (void *)&skb->cb;

726

ra_tid = (void *)&skb->cb;

727

ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,

727

ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,

728

ra_tid->tid);

728

ra_tid->tid);

729

} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {

729

} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {

730

ra_tid = (void *)&skb->cb;

730

ra_tid = (void *)&skb->cb;

731

ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,

731

ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,

732

ra_tid->tid);

732

ra_tid->tid);

733

} else if (ieee80211_is_action(mgmt->frame_control) &&

733

} else if (ieee80211_is_action(mgmt->frame_control) &&

734

mgmt->u.action.category == WLAN_CATEGORY_BACK) {

734

mgmt->u.action.category == WLAN_CATEGORY_BACK) {

735

int len = skb->len;

735

int len = skb->len;

736

737

mutex_lock(&local->sta_mtx);

737

mutex_lock(&local->sta_mtx);

738

sta = sta_info_get_bss(sdata, mgmt->sa);

738

sta = sta_info_get_bss(sdata, mgmt->sa);

739

if (sta) {

739

if (sta) {

740

switch (mgmt->u.action.u.addba_req.action_code) {

740

switch (mgmt->u.action.u.addba_req.action_code) {

741

case WLAN_ACTION_ADDBA_REQ:

741

case WLAN_ACTION_ADDBA_REQ:

742

ieee80211_process_addba_request(

742

ieee80211_process_addba_request(

743

local, sta, mgmt, len);

743

local, sta, mgmt, len);

744

break;

744

break;

745

case WLAN_ACTION_ADDBA_RESP:

745

case WLAN_ACTION_ADDBA_RESP:

746

ieee80211_process_addba_resp(local, sta,

746

ieee80211_process_addba_resp(local, sta,

747

mgmt, len);

747

mgmt, len);

748

break;

748

break;

749

case WLAN_ACTION_DELBA:

749

case WLAN_ACTION_DELBA:

750

ieee80211_process_delba(sdata, sta,

750

ieee80211_process_delba(sdata, sta,

751

mgmt, len);

751

mgmt, len);

752

break;

752

break;

753

default:

753

default:

754

WARN_ON(1);

754

WARN_ON(1);

755

break;

755

break;

756

}

756

}

757

}

757

}

758

mutex_unlock(&local->sta_mtx);

758

mutex_unlock(&local->sta_mtx);

759

} else if (ieee80211_is_data_qos(mgmt->frame_control)) {

759

} else if (ieee80211_is_data_qos(mgmt->frame_control)) {

760

struct ieee80211_hdr *hdr = (void *)mgmt;

760

struct ieee80211_hdr *hdr = (void *)mgmt;

761

/*

761

/*

762

* So the frame isn't mgmt, but frame_control

762

* So the frame isn't mgmt, but frame_control

763

* is at the right place anyway, of course, so

763

* is at the right place anyway, of course, so

764

* the if statement is correct.

764

* the if statement is correct.

765

*

765

*

766

* Warn if we have other data frame types here,

766

* Warn if we have other data frame types here,

767

* they must not get here.

767

* they must not get here.

768

*/

768

*/

769

WARN_ON(hdr->frame_control &

769

WARN_ON(hdr->frame_control &

770

cpu_to_le16(IEEE80211_STYPE_NULLFUNC));

770

cpu_to_le16(IEEE80211_STYPE_NULLFUNC));

771

WARN_ON(!(hdr->seq_ctrl &

771

WARN_ON(!(hdr->seq_ctrl &

772

cpu_to_le16(IEEE80211_SCTL_FRAG)));

772

cpu_to_le16(IEEE80211_SCTL_FRAG)));

773

/*

773

/*

774

* This was a fragment of a frame, received while

774

* This was a fragment of a frame, received while

775

* a block-ack session was active. That cannot be

775

* a block-ack session was active. That cannot be

776

* right, so terminate the session.

776

* right, so terminate the session.

777

*/

777

*/

778

mutex_lock(&local->sta_mtx);

778

mutex_lock(&local->sta_mtx);

779

sta = sta_info_get_bss(sdata, mgmt->sa);

779

sta = sta_info_get_bss(sdata, mgmt->sa);

780

if (sta) {

780

if (sta) {

781

u16 tid = *ieee80211_get_qos_ctl(hdr) &

781

u16 tid = *ieee80211_get_qos_ctl(hdr) &

782

IEEE80211_QOS_CTL_TID_MASK;

782

IEEE80211_QOS_CTL_TID_MASK;

783

784

__ieee80211_stop_rx_ba_session(

784

__ieee80211_stop_rx_ba_session(

785

sta, tid, WLAN_BACK_RECIPIENT,

785

sta, tid, WLAN_BACK_RECIPIENT,

786

WLAN_REASON_QSTA_REQUIRE_SETUP,

786

WLAN_REASON_QSTA_REQUIRE_SETUP,

787

true);

787

true);

788

}

788

}

789

mutex_unlock(&local->sta_mtx);

789

mutex_unlock(&local->sta_mtx);

790

} else switch (sdata->vif.type) {

790

} else switch (sdata->vif.type) {

791

case NL80211_IFTYPE_STATION:

791

case NL80211_IFTYPE_STATION:

792

ieee80211_sta_rx_queued_mgmt(sdata, skb);

792

ieee80211_sta_rx_queued_mgmt(sdata, skb);

793

break;

793

break;

794

case NL80211_IFTYPE_ADHOC:

794

case NL80211_IFTYPE_ADHOC:

795

ieee80211_ibss_rx_queued_mgmt(sdata, skb);

795

ieee80211_ibss_rx_queued_mgmt(sdata, skb);

796

break;

796

break;

797

case NL80211_IFTYPE_MESH_POINT:

797

case NL80211_IFTYPE_MESH_POINT:

798

if (!ieee80211_vif_is_mesh(&sdata->vif))

798

if (!ieee80211_vif_is_mesh(&sdata->vif))

799

break;

799

break;

800

ieee80211_mesh_rx_queued_mgmt(sdata, skb);

800

ieee80211_mesh_rx_queued_mgmt(sdata, skb);

801

break;

801

break;

802

default:

802

default:

803

WARN(1, "frame for unexpected interface type");

803

WARN(1, "frame for unexpected interface type");

804

break;

804

break;

805

}

805

}

806

807

kfree_skb(skb);

807

kfree_skb(skb);

808

}

808

}

809

810

/* then other type-dependent work */

810

/* then other type-dependent work */

811

switch (sdata->vif.type) {

811

switch (sdata->vif.type) {

812

case NL80211_IFTYPE_STATION:

812

case NL80211_IFTYPE_STATION:

813

ieee80211_sta_work(sdata);

813

ieee80211_sta_work(sdata);

814

break;

814

break;

815

case NL80211_IFTYPE_ADHOC:

815

case NL80211_IFTYPE_ADHOC:

816

ieee80211_ibss_work(sdata);

816

ieee80211_ibss_work(sdata);

817

break;

817

break;

818

case NL80211_IFTYPE_MESH_POINT:

818

case NL80211_IFTYPE_MESH_POINT:

819

if (!ieee80211_vif_is_mesh(&sdata->vif))

819

if (!ieee80211_vif_is_mesh(&sdata->vif))

820

break;

820

break;

821

ieee80211_mesh_work(sdata);

821

ieee80211_mesh_work(sdata);

822

break;

822

break;

823

default:

823

default:

824

break;

824

break;

825

}

825

}

826

}

826

}

827

828

829

/*

829

/*

830

* Helper function to initialise an interface to a specific type.

830

* Helper function to initialise an interface to a specific type.

831

*/

831

*/

832

static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,

832

static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,

833

enum nl80211_iftype type)

833

enum nl80211_iftype type)

834

{

834

{

835

/* clear type-dependent union */

835

/* clear type-dependent union */

836

memset(&sdata->u, 0, sizeof(sdata->u));

836

memset(&sdata->u, 0, sizeof(sdata->u));

837

838

/* and set some type-dependent values */

838

/* and set some type-dependent values */

839

sdata->vif.type = type;

839

sdata->vif.type = type;

840

sdata->vif.p2p = false;

840

sdata->vif.p2p = false;

841

sdata->dev->netdev_ops = &ieee80211_dataif_ops;

841

sdata->dev->netdev_ops = &ieee80211_dataif_ops;

842

sdata->wdev.iftype = type;

842

sdata->wdev.iftype = type;

843

844

sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);

844

sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);

845

sdata->control_port_no_encrypt = false;

845

sdata->control_port_no_encrypt = false;

846

847

/* only monitor differs */

847

/* only monitor differs */

848

sdata->dev->type = ARPHRD_ETHER;

848

sdata->dev->type = ARPHRD_ETHER;

849

850

skb_queue_head_init(&sdata->skb_queue);

850

skb_queue_head_init(&sdata->skb_queue);

851

INIT_WORK(&sdata->work, ieee80211_iface_work);

851

INIT_WORK(&sdata->work, ieee80211_iface_work);

852

853

switch (type) {

853

switch (type) {

854

case NL80211_IFTYPE_P2P_GO:

854

case NL80211_IFTYPE_P2P_GO:

855

type = NL80211_IFTYPE_AP;

855

type = NL80211_IFTYPE_AP;

856

sdata->vif.type = type;

856

sdata->vif.type = type;

857

sdata->vif.p2p = true;

857

sdata->vif.p2p = true;

858

/* fall through */

858

/* fall through */

859

case NL80211_IFTYPE_AP:

859

case NL80211_IFTYPE_AP:

860

skb_queue_head_init(&sdata->u.ap.ps_bc_buf);

860

skb_queue_head_init(&sdata->u.ap.ps_bc_buf);

861

INIT_LIST_HEAD(&sdata->u.ap.vlans);

861

INIT_LIST_HEAD(&sdata->u.ap.vlans);

862

break;

862

break;

863

case NL80211_IFTYPE_P2P_CLIENT:

863

case NL80211_IFTYPE_P2P_CLIENT:

864

type = NL80211_IFTYPE_STATION;

864

type = NL80211_IFTYPE_STATION;

865

sdata->vif.type = type;

865

sdata->vif.type = type;

866

sdata->vif.p2p = true;

866

sdata->vif.p2p = true;

867

/* fall through */

867

/* fall through */

868

case NL80211_IFTYPE_STATION:

868

case NL80211_IFTYPE_STATION:

869

ieee80211_sta_setup_sdata(sdata);

869

ieee80211_sta_setup_sdata(sdata);

870

break;

870

break;

871

case NL80211_IFTYPE_ADHOC:

871

case NL80211_IFTYPE_ADHOC:

872

ieee80211_ibss_setup_sdata(sdata);

872

ieee80211_ibss_setup_sdata(sdata);

873

break;

873

break;

874

case NL80211_IFTYPE_MESH_POINT:

874

case NL80211_IFTYPE_MESH_POINT:

875

if (ieee80211_vif_is_mesh(&sdata->vif))

875

if (ieee80211_vif_is_mesh(&sdata->vif))

876

ieee80211_mesh_init_sdata(sdata);

876

ieee80211_mesh_init_sdata(sdata);

877

break;

877

break;

878

case NL80211_IFTYPE_MONITOR:

878

case NL80211_IFTYPE_MONITOR:

879

sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;

879

sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;

880

sdata->dev->netdev_ops = &ieee80211_monitorif_ops;

880

sdata->dev->netdev_ops = &ieee80211_monitorif_ops;

881

sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |

881

sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |

882

MONITOR_FLAG_OTHER_BSS;

882

MONITOR_FLAG_OTHER_BSS;

883

break;

883

break;

884

case NL80211_IFTYPE_WDS:

884

case NL80211_IFTYPE_WDS:

885

case NL80211_IFTYPE_AP_VLAN:

885

case NL80211_IFTYPE_AP_VLAN:

886

break;

886

break;

887

case NL80211_IFTYPE_UNSPECIFIED:

887

case NL80211_IFTYPE_UNSPECIFIED:

888

case NUM_NL80211_IFTYPES:

888

case NUM_NL80211_IFTYPES:

889

BUG();

889

BUG();

890

break;

890

break;

891

}

891

}

892

893

ieee80211_debugfs_add_netdev(sdata);

893

ieee80211_debugfs_add_netdev(sdata);

894

}

894

}

895

896

static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,

896

static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,

897

enum nl80211_iftype type)

897

enum nl80211_iftype type)

898

{

898

{

899

struct ieee80211_local *local = sdata->local;

899

struct ieee80211_local *local = sdata->local;

900

int ret, err;

900

int ret, err;

901

enum nl80211_iftype internal_type = type;

901

enum nl80211_iftype internal_type = type;

902

bool p2p = false;

902

bool p2p = false;

903

904

ASSERT_RTNL();

904

ASSERT_RTNL();

905

906

if (!local->ops->change_interface)

906

if (!local->ops->change_interface)

907

return -EBUSY;

907

return -EBUSY;

908

909

switch (sdata->vif.type) {

909

switch (sdata->vif.type) {

910

case NL80211_IFTYPE_AP:

910

case NL80211_IFTYPE_AP:

911

case NL80211_IFTYPE_STATION:

911

case NL80211_IFTYPE_STATION:

912

case NL80211_IFTYPE_ADHOC:

912

case NL80211_IFTYPE_ADHOC:

913

/*

913

/*

914

* Could maybe also all others here?

914

* Could maybe also all others here?

915

* Just not sure how that interacts

915

* Just not sure how that interacts

916

* with the RX/config path e.g. for

916

* with the RX/config path e.g. for

917

* mesh.

917

* mesh.

918

*/

918

*/

919

break;

919

break;

920

default:

920

default:

921

return -EBUSY;

921

return -EBUSY;

922

}

922

}

923

924

switch (type) {

924

switch (type) {

925

case NL80211_IFTYPE_AP:

925

case NL80211_IFTYPE_AP:

926

case NL80211_IFTYPE_STATION:

926

case NL80211_IFTYPE_STATION:

927

case NL80211_IFTYPE_ADHOC:

927

case NL80211_IFTYPE_ADHOC:

928

/*

928

/*

929

* Could probably support everything

929

* Could probably support everything

930

* but WDS here (WDS do_open can fail

930

* but WDS here (WDS do_open can fail

931

* under memory pressure, which this

931

* under memory pressure, which this

932

* code isn't prepared to handle).

932

* code isn't prepared to handle).

933

*/

933

*/

934

break;

934

break;

935

case NL80211_IFTYPE_P2P_CLIENT:

935

case NL80211_IFTYPE_P2P_CLIENT:

936

p2p = true;

936

p2p = true;

937

internal_type = NL80211_IFTYPE_STATION;

937

internal_type = NL80211_IFTYPE_STATION;

938

break;

938

break;

939

case NL80211_IFTYPE_P2P_GO:

939

case NL80211_IFTYPE_P2P_GO:

940

p2p = true;

940

p2p = true;

941

internal_type = NL80211_IFTYPE_AP;

941

internal_type = NL80211_IFTYPE_AP;

942

break;

942

break;

943

default:

943

default:

944

return -EBUSY;

944

return -EBUSY;

945

}

945

}

946

947

ret = ieee80211_check_concurrent_iface(sdata, internal_type);

947

ret = ieee80211_check_concurrent_iface(sdata, internal_type);

948

if (ret)

948

if (ret)

949

return ret;

949

return ret;

950

951

ieee80211_do_stop(sdata, false);

951

ieee80211_do_stop(sdata, false);

952

953

ieee80211_teardown_sdata(sdata->dev);

953

ieee80211_teardown_sdata(sdata->dev);

954

955

ret = drv_change_interface(local, sdata, internal_type, p2p);

955

ret = drv_change_interface(local, sdata, internal_type, p2p);

956

if (ret)

956

if (ret)

957

type = sdata->vif.type;

957

type = sdata->vif.type;

958

959

ieee80211_setup_sdata(sdata, type);

959

ieee80211_setup_sdata(sdata, type);

960

961

err = ieee80211_do_open(sdata->dev, false);

961

err = ieee80211_do_open(sdata->dev, false);

962

WARN(err, "type change: do_open returned %d", err);

962

WARN(err, "type change: do_open returned %d", err);

963

964

return ret;

964

return ret;

965

}

965

}

966

967

int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,

967

int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,

968

enum nl80211_iftype type)

968

enum nl80211_iftype type)

969

{

969

{

970

int ret;

970

int ret;

971

972

ASSERT_RTNL();

972

ASSERT_RTNL();

973

974

if (type == ieee80211_vif_type_p2p(&sdata->vif))

974

if (type == ieee80211_vif_type_p2p(&sdata->vif))

975

return 0;

975

return 0;

976

977

/* Setting ad-hoc mode on non-IBSS channel is not supported. */

977

/* Setting ad-hoc mode on non-IBSS channel is not supported. */

978

if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&

978

if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&

979

type == NL80211_IFTYPE_ADHOC)

979

type == NL80211_IFTYPE_ADHOC)

980

return -EOPNOTSUPP;

980

return -EOPNOTSUPP;

981

982

if (ieee80211_sdata_running(sdata)) {

982

if (ieee80211_sdata_running(sdata)) {

983

ret = ieee80211_runtime_change_iftype(sdata, type);

983

ret = ieee80211_runtime_change_iftype(sdata, type);

984

if (ret)

984

if (ret)

985

return ret;

985

return ret;

986

} else {

986

} else {

987

/* Purge and reset type-dependent state. */

987

/* Purge and reset type-dependent state. */

988

ieee80211_teardown_sdata(sdata->dev);

988

ieee80211_teardown_sdata(sdata->dev);

989

ieee80211_setup_sdata(sdata, type);

989

ieee80211_setup_sdata(sdata, type);

990

}

990

}

991

992

/* reset some values that shouldn't be kept across type changes */

992

/* reset some values that shouldn't be kept across type changes */

993

sdata->vif.bss_conf.basic_rates =

993

sdata->vif.bss_conf.basic_rates =

994

ieee80211_mandatory_rates(sdata->local,

994

ieee80211_mandatory_rates(sdata->local,

995

sdata->local->hw.conf.channel->band);

995

sdata->local->hw.conf.channel->band);

996

sdata->drop_unencrypted = 0;

996

sdata->drop_unencrypted = 0;

997

if (type == NL80211_IFTYPE_STATION)

997

if (type == NL80211_IFTYPE_STATION)

998

sdata->u.mgd.use_4addr = false;

998

sdata->u.mgd.use_4addr = false;

999

1000

return 0;

1000

return 0;

1001

}

1001

}

1002

1003

static void ieee80211_assign_perm_addr(struct ieee80211_local *local,

1003

static void ieee80211_assign_perm_addr(struct ieee80211_local *local,

1004

struct net_device *dev,

1004

struct net_device *dev,

1005

enum nl80211_iftype type)

1005

enum nl80211_iftype type)

1006

{

1006

{

1007

struct ieee80211_sub_if_data *sdata;

1007

struct ieee80211_sub_if_data *sdata;

1008

u64 mask, start, addr, val, inc;

1008

u64 mask, start, addr, val, inc;

1009

u8 *m;

1009

u8 *m;

1010

u8 tmp_addr[ETH_ALEN];

1010

u8 tmp_addr[ETH_ALEN];

1011

int i;

1011

int i;

1012

1013

/* default ... something at least */

1013

/* default ... something at least */

1014

memcpy(dev->perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);

1014

memcpy(dev->perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);

1015

1016

if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&

1016

if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&

1017

local->hw.wiphy->n_addresses <= 1)

1017

local->hw.wiphy->n_addresses <= 1)

1018

return;

1018

return;

1019

1020

1021

mutex_lock(&local->iflist_mtx);

1021

mutex_lock(&local->iflist_mtx);

1022

1023

switch (type) {

1023

switch (type) {

1024

case NL80211_IFTYPE_MONITOR:

1024

case NL80211_IFTYPE_MONITOR:

1025

/* doesn't matter */

1025

/* doesn't matter */

1026

break;

1026

break;

1027

case NL80211_IFTYPE_WDS:

1027

case NL80211_IFTYPE_WDS:

1028

case NL80211_IFTYPE_AP_VLAN:

1028

case NL80211_IFTYPE_AP_VLAN:

1029

/* match up with an AP interface */

1029

/* match up with an AP interface */

1030

list_for_each_entry(sdata, &local->interfaces, list) {

1030

list_for_each_entry(sdata, &local->interfaces, list) {

1031

if (sdata->vif.type != NL80211_IFTYPE_AP)

1031

if (sdata->vif.type != NL80211_IFTYPE_AP)

1032

continue;

1032

continue;

1033

memcpy(dev->perm_addr, sdata->vif.addr, ETH_ALEN);

1033

memcpy(dev->perm_addr, sdata->vif.addr, ETH_ALEN);

1034

break;

1034

break;

1035

}

1035

}

1036

/* keep default if no AP interface present */

1036

/* keep default if no AP interface present */

1037

break;

1037

break;

1038

default:

1038

default:

1039

/* assign a new address if possible -- try n_addresses first */

1039

/* assign a new address if possible -- try n_addresses first */

1040

for (i = 0; i < local->hw.wiphy->n_addresses; i++) {

1040

for (i = 0; i < local->hw.wiphy->n_addresses; i++) {

1041

bool used = false;

1041

bool used = false;

1042

1043

list_for_each_entry(sdata, &local->interfaces, list) {

1043

list_for_each_entry(sdata, &local->interfaces, list) {

1044

if (memcmp(local->hw.wiphy->addresses[i].addr,

1044

if (memcmp(local->hw.wiphy->addresses[i].addr,

1045

sdata->vif.addr, ETH_ALEN) == 0) {

1045

sdata->vif.addr, ETH_ALEN) == 0) {

1046

used = true;

1046

used = true;

1047

break;

1047

break;

1048

}

1048

}

1049

}

1049

}

1050

1051

if (!used) {

1051

if (!used) {

1052

memcpy(dev->perm_addr,

1052

memcpy(dev->perm_addr,

1053

local->hw.wiphy->addresses[i].addr,

1053

local->hw.wiphy->addresses[i].addr,

1054

ETH_ALEN);

1054

ETH_ALEN);

1055

break;

1055

break;

1056

}

1056

}

1057

}

1057

}

1058

1059

/* try mask if available */

1059

/* try mask if available */

1060

if (is_zero_ether_addr(local->hw.wiphy->addr_mask))

1060

if (is_zero_ether_addr(local->hw.wiphy->addr_mask))

1061

break;

1061

break;

1062

1063

m = local->hw.wiphy->addr_mask;

1063

m = local->hw.wiphy->addr_mask;

1064

mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1064

mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1065

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1065

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1066

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1066

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1067

1068

if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {

1068

if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {

1069

/* not a contiguous mask ... not handled now! */

1069

/* not a contiguous mask ... not handled now! */

1070

printk(KERN_DEBUG "not contiguous\n");

1070

printk(KERN_DEBUG "not contiguous\n");

1071

break;

1071

break;

1072

}

1072

}

1073

1074

m = local->hw.wiphy->perm_addr;

1074

m = local->hw.wiphy->perm_addr;

1075

start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1075

start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |

1076

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1076

((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |

1077

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1077

((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

1078

1079

inc = 1ULL<<__ffs64(mask);

1079

inc = 1ULL<<__ffs64(mask);

1080

val = (start & mask);

1080

val = (start & mask);

1081

addr = (start & ~mask) | (val & mask);

1081

addr = (start & ~mask) | (val & mask);

1082

do {

1082

do {

1083

bool used = false;

1083

bool used = false;

1084

1085

tmp_addr[5] = addr >> 0*8;

1085

tmp_addr[5] = addr >> 0*8;

1086

tmp_addr[4] = addr >> 1*8;

1086

tmp_addr[4] = addr >> 1*8;

1087

tmp_addr[3] = addr >> 2*8;

1087

tmp_addr[3] = addr >> 2*8;

1088

tmp_addr[2] = addr >> 3*8;

1088

tmp_addr[2] = addr >> 3*8;

1089

tmp_addr[1] = addr >> 4*8;

1089

tmp_addr[1] = addr >> 4*8;

1090

tmp_addr[0] = addr >> 5*8;

1090

tmp_addr[0] = addr >> 5*8;

1091

1092

val += inc;

1092

val += inc;

1093

1094

list_for_each_entry(sdata, &local->interfaces, list) {

1094

list_for_each_entry(sdata, &local->interfaces, list) {

1095

if (memcmp(tmp_addr, sdata->vif.addr,

1095

if (memcmp(tmp_addr, sdata->vif.addr,

1096

ETH_ALEN) == 0) {

1096

ETH_ALEN) == 0) {

1097

used = true;

1097

used = true;

1098

break;

1098

break;

1099

}

1099

}

1100

}

1100

}

1101

1102

if (!used) {

1102

if (!used) {

1103

memcpy(dev->perm_addr, tmp_addr, ETH_ALEN);

1103

memcpy(dev->perm_addr, tmp_addr, ETH_ALEN);

1104

break;

1104

break;

1105

}

1105

}

1106

addr = (start & ~mask) | (val & mask);

1106

addr = (start & ~mask) | (val & mask);

1107

} while (addr != start);

1107

} while (addr != start);

1108

1109

break;

1109

break;

1110

}

1110

}

1111

1112

mutex_unlock(&local->iflist_mtx);

1112

mutex_unlock(&local->iflist_mtx);

1113

}

1113

}

1114

1115

int ieee80211_if_add(struct ieee80211_local *local, const char *name,

1115

int ieee80211_if_add(struct ieee80211_local *local, const char *name,

1116

struct net_device **new_dev, enum nl80211_iftype type,

1116

struct net_device **new_dev, enum nl80211_iftype type,

1117

struct vif_params *params)

1117

struct vif_params *params)

1118

{

1118

{

1119

struct net_device *ndev;

1119

struct net_device *ndev;

1120

struct ieee80211_sub_if_data *sdata = NULL;

1120

struct ieee80211_sub_if_data *sdata = NULL;

1121

int ret, i;

1121

int ret, i;

1122

1123

ASSERT_RTNL();

1123

ASSERT_RTNL();

1124

1125

ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,

1125

ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,

1126

name, ieee80211_if_setup, local->hw.queues);

1126

name, ieee80211_if_setup, local->hw.queues);

1127

if (!ndev)

1127

if (!ndev)

1128

return -ENOMEM;

1128

return -ENOMEM;

1129

dev_net_set(ndev, wiphy_net(local->hw.wiphy));

1129

dev_net_set(ndev, wiphy_net(local->hw.wiphy));

1130

1131

ndev->needed_headroom = local->tx_headroom +

1131

ndev->needed_headroom = local->tx_headroom +

1132

4*6 /* four MAC addresses */

1132

4*6 /* four MAC addresses */

1133

+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */

1133

+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */

1134

+ 6 /* mesh */

1134

+ 6 /* mesh */

1135

+ 8 /* rfc1042/bridge tunnel */

1135

+ 8 /* rfc1042/bridge tunnel */

1136

- ETH_HLEN /* ethernet hard_header_len */

1136

- ETH_HLEN /* ethernet hard_header_len */

1137

+ IEEE80211_ENCRYPT_HEADROOM;

1137

+ IEEE80211_ENCRYPT_HEADROOM;

1138

ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;

1138

ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;

1139

1140

ret = dev_alloc_name(ndev, ndev->name);

1140

ret = dev_alloc_name(ndev, ndev->name);

1141

if (ret < 0)

1141

if (ret < 0)

1142

goto fail;

1142

goto fail;

1143

1144

ieee80211_assign_perm_addr(local, ndev, type);

1144

ieee80211_assign_perm_addr(local, ndev, type);

1145

memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);

1145

memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);

1146

SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));

1146

SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));

1147

1148

/* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */

1148

/* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */

1149

sdata = netdev_priv(ndev);

1149

sdata = netdev_priv(ndev);

1150

ndev->ieee80211_ptr = &sdata->wdev;

1150

ndev->ieee80211_ptr = &sdata->wdev;

1151

memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);

1151

memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);

1152

memcpy(sdata->name, ndev->name, IFNAMSIZ);

1152

memcpy(sdata->name, ndev->name, IFNAMSIZ);

1153

1154

/* initialise type-independent data */

1154

/* initialise type-independent data */

1155

sdata->wdev.wiphy = local->hw.wiphy;

1155

sdata->wdev.wiphy = local->hw.wiphy;

1156

sdata->local = local;

1156

sdata->local = local;

1157

sdata->dev = ndev;

1157

sdata->dev = ndev;

1158

#ifdef CONFIG_INET

1158

#ifdef CONFIG_INET

1159

sdata->arp_filter_state = true;

1159

sdata->arp_filter_state = true;

1160

#endif

1160

#endif

1161

1162

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

1162

for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)

1163

skb_queue_head_init(&sdata->fragments[i].skb_list);

1163

skb_queue_head_init(&sdata->fragments[i].skb_list);

1164

1165

INIT_LIST_HEAD(&sdata->key_list);

1165

INIT_LIST_HEAD(&sdata->key_list);

1166

1167

for (i = 0; i < IEEE80211_NUM_BANDS; i++) {

1167

for (i = 0; i < IEEE80211_NUM_BANDS; i++) {

1168

struct ieee80211_supported_band *sband;

1168

struct ieee80211_supported_band *sband;

1169

sband = local->hw.wiphy->bands[i];

1169

sband = local->hw.wiphy->bands[i];

1170

sdata->rc_rateidx_mask[i] =

1170

sdata->rc_rateidx_mask[i] =

1171

sband ? (1 << sband->n_bitrates) - 1 : 0;

1171

sband ? (1 << sband->n_bitrates) - 1 : 0;

1172

}

1172

}

1173

1174

/* setup type-dependent data */

1174

/* setup type-dependent data */

1175

ieee80211_setup_sdata(sdata, type);

1175

ieee80211_setup_sdata(sdata, type);

1176

1177

if (params) {

1177

if (params) {

1178

ndev->ieee80211_ptr->use_4addr = params->use_4addr;

1178

ndev->ieee80211_ptr->use_4addr = params->use_4addr;

1179

if (type == NL80211_IFTYPE_STATION)

1179

if (type == NL80211_IFTYPE_STATION)

1180

sdata->u.mgd.use_4addr = params->use_4addr;

1180

sdata->u.mgd.use_4addr = params->use_4addr;

1181

}

1181

}

1182

1183

ret = register_netdevice(ndev);

1183

ret = register_netdevice(ndev);

1184

if (ret)

1184

if (ret)

1185

goto fail;

1185

goto fail;

1186

1187

mutex_lock(&local->iflist_mtx);

1187

mutex_lock(&local->iflist_mtx);

1188

list_add_tail_rcu(&sdata->list, &local->interfaces);

1188

list_add_tail_rcu(&sdata->list, &local->interfaces);

1189

mutex_unlock(&local->iflist_mtx);

1189

mutex_unlock(&local->iflist_mtx);

1190

1191

if (new_dev)

1191

if (new_dev)

1192

*new_dev = ndev;

1192

*new_dev = ndev;

1193

1194

return 0;

1194

return 0;

1195

1196

fail:

1196

fail:

1197

free_netdev(ndev);

1197

free_netdev(ndev);

1198

return ret;

1198

return ret;

1199

}

1199

}

1200

1201

void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)

1201

void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)

1202

{

1202

{

1203

ASSERT_RTNL();

1203

ASSERT_RTNL();

1204

1205

mutex_lock(&sdata->local->iflist_mtx);

1205

mutex_lock(&sdata->local->iflist_mtx);

1206

list_del_rcu(&sdata->list);

1206

list_del_rcu(&sdata->list);

1207

mutex_unlock(&sdata->local->iflist_mtx);

1207

mutex_unlock(&sdata->local->iflist_mtx);

1208

1209

synchronize_rcu();

1209

synchronize_rcu();

1210

unregister_netdevice(sdata->dev);

1210

unregister_netdevice(sdata->dev);

1211

}

1211

}

1212

1213

/*

1213

/*

1214

* Remove all interfaces, may only be called at hardware unregistration

1214

* Remove all interfaces, may only be called at hardware unregistration

1215

* time because it doesn't do RCU-safe list removals.

1215

* time because it doesn't do RCU-safe list removals.

1216

*/

1216

*/

1217

void ieee80211_remove_interfaces(struct ieee80211_local *local)

1217

void ieee80211_remove_interfaces(struct ieee80211_local *local)

1218

{

1218

{

1219

struct ieee80211_sub_if_data *sdata, *tmp;

1219

struct ieee80211_sub_if_data *sdata, *tmp;

1220

LIST_HEAD(unreg_list);

1220

LIST_HEAD(unreg_list);

1221

1222

ASSERT_RTNL();

1222

ASSERT_RTNL();

1223

1224

mutex_lock(&local->iflist_mtx);

1224

mutex_lock(&local->iflist_mtx);

1225

list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {

1225

list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {

1226

list_del(&sdata->list);

1226

list_del(&sdata->list);

1227

1228

unregister_netdevice_queue(sdata->dev, &unreg_list);

1228

unregister_netdevice_queue(sdata->dev, &unreg_list);

1229

}

1229

}

1230

mutex_unlock(&local->iflist_mtx);

1230

mutex_unlock(&local->iflist_mtx);

1231

unregister_netdevice_many(&unreg_list);

1231

unregister_netdevice_many(&unreg_list);

1232

list_del(&unreg_list);

1232

}

1233

}

1233

1234

static u32 ieee80211_idle_off(struct ieee80211_local *local,

1235

static u32 ieee80211_idle_off(struct ieee80211_local *local,

1235

const char *reason)

1236

const char *reason)

1236

{

1237

{

1237

if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))

1238

if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))

1238

return 0;

1239

return 0;

1239

1240

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1241

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1241

wiphy_debug(local->hw.wiphy, "device no longer idle - %s\n", reason);

1242

wiphy_debug(local->hw.wiphy, "device no longer idle - %s\n", reason);

1242

#endif

1243

#endif

1243

1244

local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;

1245

local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;

1245

return IEEE80211_CONF_CHANGE_IDLE;

1246

return IEEE80211_CONF_CHANGE_IDLE;

1246

}

1247

}

1247

1248

static u32 ieee80211_idle_on(struct ieee80211_local *local)

1249

static u32 ieee80211_idle_on(struct ieee80211_local *local)

1249

{

1250

{

1250

if (local->hw.conf.flags & IEEE80211_CONF_IDLE)

1251

if (local->hw.conf.flags & IEEE80211_CONF_IDLE)

1251

return 0;

1252

return 0;

1252

1253

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1254

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG

1254

wiphy_debug(local->hw.wiphy, "device now idle\n");

1255

wiphy_debug(local->hw.wiphy, "device now idle\n");

1255

#endif

1256

#endif

1256

1257

drv_flush(local, false);

1258

drv_flush(local, false);

1258

1259

local->hw.conf.flags |= IEEE80211_CONF_IDLE;

1260

local->hw.conf.flags |= IEEE80211_CONF_IDLE;

1260

return IEEE80211_CONF_CHANGE_IDLE;

1261

return IEEE80211_CONF_CHANGE_IDLE;

1261

}

1262

}

1262

1263

u32 __ieee80211_recalc_idle(struct ieee80211_local *local)

1264

u32 __ieee80211_recalc_idle(struct ieee80211_local *local)

1264

{

1265

{

1265

struct ieee80211_sub_if_data *sdata;

1266

struct ieee80211_sub_if_data *sdata;

1266

int count = 0;

1267

int count = 0;

1267

bool working = false, scanning = false, hw_roc = false;

1268

bool working = false, scanning = false, hw_roc = false;

1268

struct ieee80211_work *wk;

1269

struct ieee80211_work *wk;

1269

unsigned int led_trig_start = 0, led_trig_stop = 0;

1270

unsigned int led_trig_start = 0, led_trig_stop = 0;

1270

1271

#ifdef CONFIG_PROVE_LOCKING

1272

#ifdef CONFIG_PROVE_LOCKING

1272

WARN_ON(debug_locks && !lockdep_rtnl_is_held() &&

1273

WARN_ON(debug_locks && !lockdep_rtnl_is_held() &&

1273

!lockdep_is_held(&local->iflist_mtx));

1274

!lockdep_is_held(&local->iflist_mtx));

1274

#endif

1275

#endif

1275

lockdep_assert_held(&local->mtx);

1276

lockdep_assert_held(&local->mtx);

1276

1277

list_for_each_entry(sdata, &local->interfaces, list) {

1278

list_for_each_entry(sdata, &local->interfaces, list) {

1278

if (!ieee80211_sdata_running(sdata)) {

1279

if (!ieee80211_sdata_running(sdata)) {

1279

sdata->vif.bss_conf.idle = true;

1280

sdata->vif.bss_conf.idle = true;

1280

continue;

1281

continue;

1281

}

1282

}

1282

1283

sdata->old_idle = sdata->vif.bss_conf.idle;

1284

sdata->old_idle = sdata->vif.bss_conf.idle;

1284

1285

/* do not count disabled managed interfaces */

1286

/* do not count disabled managed interfaces */

1286

if (sdata->vif.type == NL80211_IFTYPE_STATION &&

1287

if (sdata->vif.type == NL80211_IFTYPE_STATION &&

1287

!sdata->u.mgd.associated) {

1288

!sdata->u.mgd.associated) {

1288

sdata->vif.bss_conf.idle = true;

1289

sdata->vif.bss_conf.idle = true;

1289

continue;

1290

continue;

1290

}

1291

}

1291

/* do not count unused IBSS interfaces */

1292

/* do not count unused IBSS interfaces */

1292

if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&

1293

if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&

1293

!sdata->u.ibss.ssid_len) {

1294

!sdata->u.ibss.ssid_len) {

1294

sdata->vif.bss_conf.idle = true;

1295

sdata->vif.bss_conf.idle = true;

1295

continue;

1296

continue;

1296

}

1297

}

1297

/* count everything else */

1298

/* count everything else */

1298

count++;

1299

count++;

1299

}

1300

}

1300

1301

list_for_each_entry(wk, &local->work_list, list) {

1302

list_for_each_entry(wk, &local->work_list, list) {

1302

working = true;

1303

working = true;

1303

wk->sdata->vif.bss_conf.idle = false;

1304

wk->sdata->vif.bss_conf.idle = false;

1304

}

1305

}

1305

1306

if (local->scan_sdata) {

1307

if (local->scan_sdata) {

1307

scanning = true;

1308

scanning = true;

1308

local->scan_sdata->vif.bss_conf.idle = false;

1309

local->scan_sdata->vif.bss_conf.idle = false;

1309

}

1310

}

1310

1311

if (local->hw_roc_channel)

1312

if (local->hw_roc_channel)

1312

hw_roc = true;

1313

hw_roc = true;

1313

1314

list_for_each_entry(sdata, &local->interfaces, list) {

1315

list_for_each_entry(sdata, &local->interfaces, list) {

1315

if (sdata->old_idle == sdata->vif.bss_conf.idle)

1316

if (sdata->old_idle == sdata->vif.bss_conf.idle)

1316

continue;

1317

continue;

1317

if (!ieee80211_sdata_running(sdata))

1318

if (!ieee80211_sdata_running(sdata))

1318

continue;

1319

continue;

1319

ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IDLE);

1320

ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IDLE);

1320

}

1321

}

1321

1322

if (working || scanning || hw_roc)

1323

if (working || scanning || hw_roc)

1323

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;

1324

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;

1324

else

1325

else

1325

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;

1326

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;

1326

1327

if (count)

1328

if (count)

1328

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

1329

led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

1329

else

1330

else

1330

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

1331

led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;

1331

1332

ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);

1333

ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);

1333

1334

if (hw_roc)

1335

if (hw_roc)

1335

return ieee80211_idle_off(local, "hw remain-on-channel");

1336

return ieee80211_idle_off(local, "hw remain-on-channel");

1336

if (working)

1337

if (working)

1337

return ieee80211_idle_off(local, "working");

1338

return ieee80211_idle_off(local, "working");

1338

if (scanning)

1339

if (scanning)

1339

return ieee80211_idle_off(local, "scanning");

1340

return ieee80211_idle_off(local, "scanning");

1340

if (!count)

1341

if (!count)

1341

return ieee80211_idle_on(local);

1342

return ieee80211_idle_on(local);

1342

else

1343

else

1343

return ieee80211_idle_off(local, "in use");

1344

return ieee80211_idle_off(local, "in use");

1344

1345

return 0;

1346

return 0;

1346

}

1347

}

1347

1348

void ieee80211_recalc_idle(struct ieee80211_local *local)

1349

void ieee80211_recalc_idle(struct ieee80211_local *local)

1349

{

1350

{

1350

u32 chg;

1351

u32 chg;

1351

1352

mutex_lock(&local->iflist_mtx);

1353

mutex_lock(&local->iflist_mtx);

1353

chg = __ieee80211_recalc_idle(local);

1354

chg = __ieee80211_recalc_idle(local);

1354

mutex_unlock(&local->iflist_mtx);

1355

mutex_unlock(&local->iflist_mtx);

1355

if (chg)

1356

if (chg)

1356

ieee80211_hw_config(local, chg);

1357

ieee80211_hw_config(local, chg);

1357

}

1358

}

1358

1359

static int netdev_notify(struct notifier_block *nb,

1360

static int netdev_notify(struct notifier_block *nb,

1360

unsigned long state,

1361

unsigned long state,

1361

void *ndev)

1362

void *ndev)

1362

{

1363

{

1363

struct net_device *dev = ndev;

1364

struct net_device *dev = ndev;

1364

struct ieee80211_sub_if_data *sdata;

1365

struct ieee80211_sub_if_data *sdata;

1365

1366

if (state != NETDEV_CHANGENAME)

1367

if (state != NETDEV_CHANGENAME)

1367

return 0;

1368

return 0;

1368

1369

if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)

1370

if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)

1370

return 0;

1371

return 0;

1371

1372

if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)

1373

if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)

1373

return 0;

1374

return 0;

1374

1375

sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1376

sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1376

1377

memcpy(sdata->name, dev->name, IFNAMSIZ);

1378

memcpy(sdata->name, dev->name, IFNAMSIZ);

1378

1379

ieee80211_debugfs_rename_netdev(sdata);

1380

ieee80211_debugfs_rename_netdev(sdata);

1380

return 0;

1381

return 0;

1381

}

1382

}

1382

1383

static struct notifier_block mac80211_netdev_notifier = {

1384

static struct notifier_block mac80211_netdev_notifier = {

1384

.notifier_call = netdev_notify,

1385

.notifier_call = netdev_notify,

1385

};

1386

};

1386

1387

int ieee80211_iface_init(void)

1388

int ieee80211_iface_init(void)

1388

{

1389

{

1389

return register_netdevice_notifier(&mac80211_netdev_notifier);

1390

return register_netdevice_notifier(&mac80211_netdev_notifier);

1390

}

1391

}

1391

1392

void ieee80211_iface_exit(void)

1393

void ieee80211_iface_exit(void)

1393

{

1394

{

1394

unregister_netdevice_notifier(&mac80211_netdev_notifier);

1395

unregister_netdevice_notifier(&mac80211_netdev_notifier);

1395

}

1396

}

1396

1397

GITLAB

net: Fix more stale on-stack list_head objects.

 /*
  * Interface handling (except master interface)
  *
  * Copyright 2002-2005, Instant802 Networks, Inc.
  * Copyright 2005-2006, Devicescape Software, Inc.
  * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
  * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/if_arp.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
 #include <net/mac80211.h>
 #include <net/ieee80211_radiotap.h>
 #include "ieee80211_i.h"
 #include "sta_info.h"
 #include "debugfs_netdev.h"
 #include "mesh.h"
 #include "led.h"
 #include "driver-ops.h"
 #include "wme.h"
 #include "rate.h"
 /**
  * DOC: Interface list locking
  *
  * The interface list in each struct ieee80211_local is protected
  * three-fold:
  *
  * (1) modifications may only be done under the RTNL
  * (2) modifications and readers are protected against each other by
  *     the iflist_mtx.
  * (3) modifications are done in an RCU manner so atomic readers
  *     can traverse the list in RCU-safe blocks.
  *
  * As a consequence, reads (traversals) of the list can be protected
  * by either the RTNL, the iflist_mtx or RCU.
  */
 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
 {
 	int meshhdrlen;
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;
 	/* FIX: what would be proper limits for MTU?
 	 * This interface uses 802.3 frames. */
 	if (new_mtu < 256 ||
 	    new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
 		return -EINVAL;
 	}
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);
 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
 	dev->mtu = new_mtu;
 	return 0;
 }
 static int ieee80211_change_mac(struct net_device *dev, void *addr)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct sockaddr *sa = addr;
 	int ret;
 	if (ieee80211_sdata_running(sdata))
 		return -EBUSY;
 	ret = eth_mac_addr(dev, sa);
 	if (ret == 0)
 		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
 	return ret;
 }
 static inline int identical_mac_addr_allowed(int type1, int type2)
 {
 	return type1 == NL80211_IFTYPE_MONITOR ||
 		type2 == NL80211_IFTYPE_MONITOR ||
 		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
 		(type1 == NL80211_IFTYPE_WDS &&
 			(type2 == NL80211_IFTYPE_WDS ||
 			 type2 == NL80211_IFTYPE_AP)) ||
 		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
 		(type1 == NL80211_IFTYPE_AP_VLAN &&
 			(type2 == NL80211_IFTYPE_AP ||
 			 type2 == NL80211_IFTYPE_AP_VLAN));
 }
 static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
 					    enum nl80211_iftype iftype)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_sub_if_data *nsdata;
 	struct net_device *dev = sdata->dev;
 	ASSERT_RTNL();
 	/* we hold the RTNL here so can safely walk the list */
 	list_for_each_entry(nsdata, &local->interfaces, list) {
 		struct net_device *ndev = nsdata->dev;
 		if (ndev != dev && ieee80211_sdata_running(nsdata)) {
 			/*
 			 * Allow only a single IBSS interface to be up at any
 			 * time. This is restricted because beacon distribution
 			 * cannot work properly if both are in the same IBSS.
 			 *
 			 * To remove this restriction we'd have to disallow them
 			 * from setting the same SSID on different IBSS interfaces
 			 * belonging to the same hardware. Then, however, we're
 			 * faced with having to adopt two different TSF timers...
 			 */
 			if (iftype == NL80211_IFTYPE_ADHOC &&
 			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
 				return -EBUSY;
 			/*
 			 * The remaining checks are only performed for interfaces
 			 * with the same MAC address.
 			 */
 			if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))
 				continue;
 			/*
 			 * check whether it may have the same address
 			 */
 			if (!identical_mac_addr_allowed(iftype,
 							nsdata->vif.type))
 				return -ENOTUNIQ;
 			/*
 			 * can only add VLANs to enabled APs
 			 */
 			if (iftype == NL80211_IFTYPE_AP_VLAN &&
 			    nsdata->vif.type == NL80211_IFTYPE_AP)
 				sdata->bss = &nsdata->u.ap;
 		}
 	}
 	return 0;
 }
 void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
 				    const int offset)
 {
 	struct ieee80211_local *local = sdata->local;
 	u32 flags = sdata->u.mntr_flags;
 #define ADJUST(_f, _s)	do {					\
 	if (flags & MONITOR_FLAG_##_f)				\
 		local->fif_##_s += offset;			\
 	} while (0)
 	ADJUST(FCSFAIL, fcsfail);
 	ADJUST(PLCPFAIL, plcpfail);
 	ADJUST(CONTROL, control);
 	ADJUST(CONTROL, pspoll);
 	ADJUST(OTHER_BSS, other_bss);
 #undef ADJUST
 }
 /*
  * NOTE: Be very careful when changing this function, it must NOT return
  * an error on interface type changes that have been pre-checked, so most
  * checks should be in ieee80211_check_concurrent_iface.
  */
 static int ieee80211_do_open(struct net_device *dev, bool coming_up)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct ieee80211_local *local = sdata->local;
 	struct sta_info *sta;
 	u32 changed = 0;
 	int res;
 	u32 hw_reconf_flags = 0;
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_WDS:
 		if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
 			return -ENOLINK;
 		break;
 	case NL80211_IFTYPE_AP_VLAN:
 		if (!sdata->bss)
 			return -ENOLINK;
 		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
 		break;
 	case NL80211_IFTYPE_AP:
 		sdata->bss = &sdata->u.ap;
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_MONITOR:
 	case NL80211_IFTYPE_ADHOC:
 		/* no special treatment */
 		break;
 	case NL80211_IFTYPE_UNSPECIFIED:
 	case NUM_NL80211_IFTYPES:
 	case NL80211_IFTYPE_P2P_CLIENT:
 	case NL80211_IFTYPE_P2P_GO:
 		/* cannot happen */
 		WARN_ON(1);
 		break;
 	}
 	if (local->open_count == 0) {
 		res = drv_start(local);
 		if (res)
 			goto err_del_bss;
 		if (local->ops->napi_poll)
 			napi_enable(&local->napi);
 		/* we're brought up, everything changes */
 		hw_reconf_flags = ~0;
 		ieee80211_led_radio(local, true);
 		ieee80211_mod_tpt_led_trig(local,
 					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
 	}
 	/*
 	 * Copy the hopefully now-present MAC address to
 	 * this interface, if it has the special null one.
 	 */
 	if (is_zero_ether_addr(dev->dev_addr)) {
 		memcpy(dev->dev_addr,
 		       local->hw.wiphy->perm_addr,
 		       ETH_ALEN);
 		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
 		if (!is_valid_ether_addr(dev->dev_addr)) {
 			if (!local->open_count)
 				drv_stop(local);
 			return -EADDRNOTAVAIL;
 		}
 	}
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_AP_VLAN:
 		/* no need to tell driver */
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
 			local->cooked_mntrs++;
 			break;
 		}
 		/* must be before the call to ieee80211_configure_filter */
 		local->monitors++;
 		if (local->monitors == 1) {
 			local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
 			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
 		}
 		ieee80211_adjust_monitor_flags(sdata, 1);
 		ieee80211_configure_filter(local);
 		netif_carrier_on(dev);
 		break;
 	default:
 		if (coming_up) {
 			res = drv_add_interface(local, &sdata->vif);
 			if (res)
 				goto err_stop;
 		}
 		if (sdata->vif.type == NL80211_IFTYPE_AP) {
 			local->fif_pspoll++;
 			local->fif_probe_req++;
 			ieee80211_configure_filter(local);
 		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 			local->fif_probe_req++;
 		}
 		changed |= ieee80211_reset_erp_info(sdata);
 		ieee80211_bss_info_change_notify(sdata, changed);
 		if (sdata->vif.type == NL80211_IFTYPE_STATION)
 			netif_carrier_off(dev);
 		else
 			netif_carrier_on(dev);
 	}
 	set_bit(SDATA_STATE_RUNNING, &sdata->state);
 	if (sdata->vif.type == NL80211_IFTYPE_WDS) {
 		/* Create STA entry for the WDS peer */
 		sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
 				     GFP_KERNEL);
 		if (!sta) {
 			res = -ENOMEM;
 			goto err_del_interface;
 		}
 		/* no locking required since STA is not live yet */
 		sta->flags |= WLAN_STA_AUTHORIZED;
 		res = sta_info_insert(sta);
 		if (res) {
 			/* STA has been freed */
 			goto err_del_interface;
 		}
 		rate_control_rate_init(sta);
 	}
 	/*
 	 * set_multicast_list will be invoked by the networking core
 	 * which will check whether any increments here were done in
 	 * error and sync them down to the hardware as filter flags.
 	 */
 	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
 		atomic_inc(&local->iff_allmultis);
 	if (sdata->flags & IEEE80211_SDATA_PROMISC)
 		atomic_inc(&local->iff_promiscs);
 	mutex_lock(&local->mtx);
 	hw_reconf_flags |= __ieee80211_recalc_idle(local);
 	mutex_unlock(&local->mtx);
 	if (coming_up)
 		local->open_count++;
 	if (hw_reconf_flags) {
 		ieee80211_hw_config(local, hw_reconf_flags);
 		/*
 		 * set default queue parameters so drivers don't
 		 * need to initialise the hardware if the hardware
 		 * doesn't start up with sane defaults
 		 */
 		ieee80211_set_wmm_default(sdata);
 	}
 	ieee80211_recalc_ps(local, -1);
 	netif_tx_start_all_queues(dev);
 	return 0;
  err_del_interface:
 	drv_remove_interface(local, &sdata->vif);
  err_stop:
 	if (!local->open_count)
 		drv_stop(local);
  err_del_bss:
 	sdata->bss = NULL;
 	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 		list_del(&sdata->u.vlan.list);
 	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 	return res;
 }
 static int ieee80211_open(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	int err;
 	/* fail early if user set an invalid address */
 	if (!is_zero_ether_addr(dev->dev_addr) &&
 	    !is_valid_ether_addr(dev->dev_addr))
 		return -EADDRNOTAVAIL;
 	err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
 	if (err)
 		return err;
 	return ieee80211_do_open(dev, true);
 }
 static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
 			      bool going_down)
 {
 	struct ieee80211_local *local = sdata->local;
 	unsigned long flags;
 	struct sk_buff *skb, *tmp;
 	u32 hw_reconf_flags = 0;
 	int i;
 	if (local->scan_sdata == sdata)
 		ieee80211_scan_cancel(local);
 	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 	/*
 	 * Stop TX on this interface first.
 	 */
 	netif_tx_stop_all_queues(sdata->dev);
 	/*
 	 * Purge work for this interface.
 	 */
 	ieee80211_work_purge(sdata);
 	/*
 	 * Remove all stations associated with this interface.
 	 *
 	 * This must be done before calling ops->remove_interface()
 	 * because otherwise we can later invoke ops->sta_notify()
 	 * whenever the STAs are removed, and that invalidates driver
 	 * assumptions about always getting a vif pointer that is valid
 	 * (because if we remove a STA after ops->remove_interface()
 	 * the driver will have removed the vif info already!)
 	 *
 	 * This is relevant only in AP, WDS and mesh modes, since in
 	 * all other modes we've already removed all stations when
 	 * disconnecting etc.
 	 */
 	sta_info_flush(local, sdata);
 	/*
 	 * Don't count this interface for promisc/allmulti while it
 	 * is down. dev_mc_unsync() will invoke set_multicast_list
 	 * on the master interface which will sync these down to the
 	 * hardware as filter flags.
 	 */
 	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
 		atomic_dec(&local->iff_allmultis);
 	if (sdata->flags & IEEE80211_SDATA_PROMISC)
 		atomic_dec(&local->iff_promiscs);
 	if (sdata->vif.type == NL80211_IFTYPE_AP) {
 		local->fif_pspoll--;
 		local->fif_probe_req--;
 	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 		local->fif_probe_req--;
 	}
 	netif_addr_lock_bh(sdata->dev);
 	spin_lock_bh(&local->filter_lock);
 	__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
 			 sdata->dev->addr_len);
 	spin_unlock_bh(&local->filter_lock);
 	netif_addr_unlock_bh(sdata->dev);
 	ieee80211_configure_filter(local);
 	del_timer_sync(&local->dynamic_ps_timer);
 	cancel_work_sync(&local->dynamic_ps_enable_work);
 	/* APs need special treatment */
 	if (sdata->vif.type == NL80211_IFTYPE_AP) {
 		struct ieee80211_sub_if_data *vlan, *tmpsdata;
 		struct beacon_data *old_beacon = sdata->u.ap.beacon;
 		/* sdata_running will return false, so this will disable */
 		ieee80211_bss_info_change_notify(sdata,
 						 BSS_CHANGED_BEACON_ENABLED);
 		/* remove beacon */
 		rcu_assign_pointer(sdata->u.ap.beacon, NULL);
 		synchronize_rcu();
 		kfree(old_beacon);
 		/* free all potentially still buffered bcast frames */
 		while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
 			local->total_ps_buffered--;
 			dev_kfree_skb(skb);
 		}
 		/* down all dependent devices, that is VLANs */
 		list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
 					 u.vlan.list)
 			dev_close(vlan->dev);
 		WARN_ON(!list_empty(&sdata->u.ap.vlans));
 	}
 	if (going_down)
 		local->open_count--;
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_AP_VLAN:
 		list_del(&sdata->u.vlan.list);
 		/* no need to tell driver */
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
 			local->cooked_mntrs--;
 			break;
 		}
 		local->monitors--;
 		if (local->monitors == 0) {
 			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
 			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
 		}
 		ieee80211_adjust_monitor_flags(sdata, -1);
 		ieee80211_configure_filter(local);
 		break;
 	default:
 		flush_work(&sdata->work);
 		/*
 		 * When we get here, the interface is marked down.
 		 * Call synchronize_rcu() to wait for the RX path
 		 * should it be using the interface and enqueuing
 		 * frames at this very time on another CPU.
 		 */
 		synchronize_rcu();
 		skb_queue_purge(&sdata->skb_queue);
 		/*
 		 * Disable beaconing here for mesh only, AP and IBSS
 		 * are already taken care of.
 		 */
 		if (sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
 			ieee80211_bss_info_change_notify(sdata,
 				BSS_CHANGED_BEACON_ENABLED);
 		/*
 		 * Free all remaining keys, there shouldn't be any,
 		 * except maybe group keys in AP more or WDS?
 		 */
 		ieee80211_free_keys(sdata);
 		if (going_down)
 			drv_remove_interface(local, &sdata->vif);
 	}
 	sdata->bss = NULL;
 	mutex_lock(&local->mtx);
 	hw_reconf_flags |= __ieee80211_recalc_idle(local);
 	mutex_unlock(&local->mtx);
 	ieee80211_recalc_ps(local, -1);
 	if (local->open_count == 0) {
 		if (local->ops->napi_poll)
 			napi_disable(&local->napi);
 		ieee80211_clear_tx_pending(local);
 		ieee80211_stop_device(local);
 		/* no reconfiguring after stop! */
 		hw_reconf_flags = 0;
 	}
 	/* do after stop to avoid reconfiguring when we stop anyway */
 	if (hw_reconf_flags)
 		ieee80211_hw_config(local, hw_reconf_flags);
 	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 	for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
 		skb_queue_walk_safe(&local->pending[i], skb, tmp) {
 			struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 			if (info->control.vif == &sdata->vif) {
 				__skb_unlink(skb, &local->pending[i]);
 				dev_kfree_skb_irq(skb);
 			}
 		}
 	}
 	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 }
 static int ieee80211_stop(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	ieee80211_do_stop(sdata, true);
 	return 0;
 }
 static void ieee80211_set_multicast_list(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct ieee80211_local *local = sdata->local;
 	int allmulti, promisc, sdata_allmulti, sdata_promisc;
 	allmulti = !!(dev->flags & IFF_ALLMULTI);
 	promisc = !!(dev->flags & IFF_PROMISC);
 	sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
 	sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
 	if (allmulti != sdata_allmulti) {
 		if (dev->flags & IFF_ALLMULTI)
 			atomic_inc(&local->iff_allmultis);
 		else
 			atomic_dec(&local->iff_allmultis);
 		sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
 	}
 	if (promisc != sdata_promisc) {
 		if (dev->flags & IFF_PROMISC)
 			atomic_inc(&local->iff_promiscs);
 		else
 			atomic_dec(&local->iff_promiscs);
 		sdata->flags ^= IEEE80211_SDATA_PROMISC;
 	}
 	spin_lock_bh(&local->filter_lock);
 	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
 	spin_unlock_bh(&local->filter_lock);
 	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
 }
 /*
  * Called when the netdev is removed or, by the code below, before
  * the interface type changes.
  */
 static void ieee80211_teardown_sdata(struct net_device *dev)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct ieee80211_local *local = sdata->local;
 	int flushed;
 	int i;
 	/* free extra data */
 	ieee80211_free_keys(sdata);
 	ieee80211_debugfs_remove_netdev(sdata);
 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
 		__skb_queue_purge(&sdata->fragments[i].skb_list);
 	sdata->fragment_next = 0;
 	if (ieee80211_vif_is_mesh(&sdata->vif))
 		mesh_rmc_free(sdata);
 	flushed = sta_info_flush(local, sdata);
 	WARN_ON(flushed);
 }
 static u16 ieee80211_netdev_select_queue(struct net_device *dev,
 					 struct sk_buff *skb)
 {
 	return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
 }
 static const struct net_device_ops ieee80211_dataif_ops = {
 	.ndo_open		= ieee80211_open,
 	.ndo_stop		= ieee80211_stop,
 	.ndo_uninit		= ieee80211_teardown_sdata,
 	.ndo_start_xmit		= ieee80211_subif_start_xmit,
 	.ndo_set_multicast_list = ieee80211_set_multicast_list,
 	.ndo_change_mtu 	= ieee80211_change_mtu,
 	.ndo_set_mac_address 	= ieee80211_change_mac,
 	.ndo_select_queue	= ieee80211_netdev_select_queue,
 };
 static u16 ieee80211_monitor_select_queue(struct net_device *dev,
 					  struct sk_buff *skb)
 {
 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_hdr *hdr;
 	struct ieee80211_radiotap_header *rtap = (void *)skb->data;
 	u8 *p;
 	if (local->hw.queues < 4)
 		return 0;
 	if (skb->len < 4 ||
 	    skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
 		return 0; /* doesn't matter, frame will be dropped */
 	hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
 	if (!ieee80211_is_data(hdr->frame_control)) {
 		skb->priority = 7;
 		return ieee802_1d_to_ac[skb->priority];
 	}
 	if (!ieee80211_is_data_qos(hdr->frame_control)) {
 		skb->priority = 0;
 		return ieee802_1d_to_ac[skb->priority];
 	}
 	p = ieee80211_get_qos_ctl(hdr);
 	skb->priority = *p & IEEE80211_QOS_CTL_TAG1D_MASK;
 	return ieee80211_downgrade_queue(local, skb);
 }
 static const struct net_device_ops ieee80211_monitorif_ops = {
 	.ndo_open		= ieee80211_open,
 	.ndo_stop		= ieee80211_stop,
 	.ndo_uninit		= ieee80211_teardown_sdata,
 	.ndo_start_xmit		= ieee80211_monitor_start_xmit,
 	.ndo_set_multicast_list = ieee80211_set_multicast_list,
 	.ndo_change_mtu 	= ieee80211_change_mtu,
 	.ndo_set_mac_address 	= eth_mac_addr,
 	.ndo_select_queue	= ieee80211_monitor_select_queue,
 };
 static void ieee80211_if_setup(struct net_device *dev)
 {
 	ether_setup(dev);
 	dev->netdev_ops = &ieee80211_dataif_ops;
 	dev->destructor = free_netdev;
 }
 static void ieee80211_iface_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data, work);
 	struct ieee80211_local *local = sdata->local;
 	struct sk_buff *skb;
 	struct sta_info *sta;
 	struct ieee80211_ra_tid *ra_tid;
 	if (!ieee80211_sdata_running(sdata))
 		return;
 	if (local->scanning)
 		return;
 	/*
 	 * ieee80211_queue_work() should have picked up most cases,
 	 * here we'll pick the rest.
 	 */
 	if (WARN(local->suspended,
 		 "interface work scheduled while going to suspend\n"))
 		return;
 	/* first process frames */
 	while ((skb = skb_dequeue(&sdata->skb_queue))) {
 		struct ieee80211_mgmt *mgmt = (void *)skb->data;
 		if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
 			ra_tid = (void *)&skb->cb;
 			ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
 						 ra_tid->tid);
 		} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
 			ra_tid = (void *)&skb->cb;
 			ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
 						ra_tid->tid);
 		} else if (ieee80211_is_action(mgmt->frame_control) &&
 			   mgmt->u.action.category == WLAN_CATEGORY_BACK) {
 			int len = skb->len;
 			mutex_lock(&local->sta_mtx);
 			sta = sta_info_get_bss(sdata, mgmt->sa);
 			if (sta) {
 				switch (mgmt->u.action.u.addba_req.action_code) {
 				case WLAN_ACTION_ADDBA_REQ:
 					ieee80211_process_addba_request(
 							local, sta, mgmt, len);
 					break;
 				case WLAN_ACTION_ADDBA_RESP:
 					ieee80211_process_addba_resp(local, sta,
 								     mgmt, len);
 					break;
 				case WLAN_ACTION_DELBA:
 					ieee80211_process_delba(sdata, sta,
 								mgmt, len);
 					break;
 				default:
 					WARN_ON(1);
 					break;
 				}
 			}
 			mutex_unlock(&local->sta_mtx);
 		} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
 			struct ieee80211_hdr *hdr = (void *)mgmt;
 			/*
 			 * So the frame isn't mgmt, but frame_control
 			 * is at the right place anyway, of course, so
 			 * the if statement is correct.
 			 *
 			 * Warn if we have other data frame types here,
 			 * they must not get here.
 			 */
 			WARN_ON(hdr->frame_control &
 					cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
 			WARN_ON(!(hdr->seq_ctrl &
 					cpu_to_le16(IEEE80211_SCTL_FRAG)));
 			/*
 			 * This was a fragment of a frame, received while
 			 * a block-ack session was active. That cannot be
 			 * right, so terminate the session.
 			 */
 			mutex_lock(&local->sta_mtx);
 			sta = sta_info_get_bss(sdata, mgmt->sa);
 			if (sta) {
 				u16 tid = *ieee80211_get_qos_ctl(hdr) &
 						IEEE80211_QOS_CTL_TID_MASK;
 				__ieee80211_stop_rx_ba_session(
 					sta, tid, WLAN_BACK_RECIPIENT,
 					WLAN_REASON_QSTA_REQUIRE_SETUP,
 					true);
 			}
 			mutex_unlock(&local->sta_mtx);
 		} else switch (sdata->vif.type) {
 		case NL80211_IFTYPE_STATION:
 			ieee80211_sta_rx_queued_mgmt(sdata, skb);
 			break;
 		case NL80211_IFTYPE_ADHOC:
 			ieee80211_ibss_rx_queued_mgmt(sdata, skb);
 			break;
 		case NL80211_IFTYPE_MESH_POINT:
 			if (!ieee80211_vif_is_mesh(&sdata->vif))
 				break;
 			ieee80211_mesh_rx_queued_mgmt(sdata, skb);
 			break;
 		default:
 			WARN(1, "frame for unexpected interface type");
 			break;
 		}
 		kfree_skb(skb);
 	}
 	/* then other type-dependent work */
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_STATION:
 		ieee80211_sta_work(sdata);
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		ieee80211_ibss_work(sdata);
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 		if (!ieee80211_vif_is_mesh(&sdata->vif))
 			break;
 		ieee80211_mesh_work(sdata);
 		break;
 	default:
 		break;
 	}
 }
 /*
  * Helper function to initialise an interface to a specific type.
  */
 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
 				  enum nl80211_iftype type)
 {
 	/* clear type-dependent union */
 	memset(&sdata->u, 0, sizeof(sdata->u));
 	/* and set some type-dependent values */
 	sdata->vif.type = type;
 	sdata->vif.p2p = false;
 	sdata->dev->netdev_ops = &ieee80211_dataif_ops;
 	sdata->wdev.iftype = type;
 	sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
 	sdata->control_port_no_encrypt = false;
 	/* only monitor differs */
 	sdata->dev->type = ARPHRD_ETHER;
 	skb_queue_head_init(&sdata->skb_queue);
 	INIT_WORK(&sdata->work, ieee80211_iface_work);
 	switch (type) {
 	case NL80211_IFTYPE_P2P_GO:
 		type = NL80211_IFTYPE_AP;
 		sdata->vif.type = type;
 		sdata->vif.p2p = true;
 		/* fall through */
 	case NL80211_IFTYPE_AP:
 		skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
 		INIT_LIST_HEAD(&sdata->u.ap.vlans);
 		break;
 	case NL80211_IFTYPE_P2P_CLIENT:
 		type = NL80211_IFTYPE_STATION;
 		sdata->vif.type = type;
 		sdata->vif.p2p = true;
 		/* fall through */
 	case NL80211_IFTYPE_STATION:
 		ieee80211_sta_setup_sdata(sdata);
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		ieee80211_ibss_setup_sdata(sdata);
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 		if (ieee80211_vif_is_mesh(&sdata->vif))
 			ieee80211_mesh_init_sdata(sdata);
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
 		sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
 		sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
 				      MONITOR_FLAG_OTHER_BSS;
 		break;
 	case NL80211_IFTYPE_WDS:
 	case NL80211_IFTYPE_AP_VLAN:
 		break;
 	case NL80211_IFTYPE_UNSPECIFIED:
 	case NUM_NL80211_IFTYPES:
 		BUG();
 		break;
 	}
 	ieee80211_debugfs_add_netdev(sdata);
 }
 static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
 					   enum nl80211_iftype type)
 {
 	struct ieee80211_local *local = sdata->local;
 	int ret, err;
 	enum nl80211_iftype internal_type = type;
 	bool p2p = false;
 	ASSERT_RTNL();
 	if (!local->ops->change_interface)
 		return -EBUSY;
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_AP:
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_ADHOC:
 		/*
 		 * Could maybe also all others here?
 		 * Just not sure how that interacts
 		 * with the RX/config path e.g. for
 		 * mesh.
 		 */
 		break;
 	default:
 		return -EBUSY;
 	}
 	switch (type) {
 	case NL80211_IFTYPE_AP:
 	case NL80211_IFTYPE_STATION:
 	case NL80211_IFTYPE_ADHOC:
 		/*
 		 * Could probably support everything
 		 * but WDS here (WDS do_open can fail
 		 * under memory pressure, which this
 		 * code isn't prepared to handle).
 		 */
 		break;
 	case NL80211_IFTYPE_P2P_CLIENT:
 		p2p = true;
 		internal_type = NL80211_IFTYPE_STATION;
 		break;
 	case NL80211_IFTYPE_P2P_GO:
 		p2p = true;
 		internal_type = NL80211_IFTYPE_AP;
 		break;
 	default:
 		return -EBUSY;
 	}
 	ret = ieee80211_check_concurrent_iface(sdata, internal_type);
 	if (ret)
 		return ret;
 	ieee80211_do_stop(sdata, false);
 	ieee80211_teardown_sdata(sdata->dev);
 	ret = drv_change_interface(local, sdata, internal_type, p2p);
 	if (ret)
 		type = sdata->vif.type;
 	ieee80211_setup_sdata(sdata, type);
 	err = ieee80211_do_open(sdata->dev, false);
 	WARN(err, "type change: do_open returned %d", err);
 	return ret;
 }
 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
 			     enum nl80211_iftype type)
 {
 	int ret;
 	ASSERT_RTNL();
 	if (type == ieee80211_vif_type_p2p(&sdata->vif))
 		return 0;
 	/* Setting ad-hoc mode on non-IBSS channel is not supported. */
 	if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS &&
 	    type == NL80211_IFTYPE_ADHOC)
 		return -EOPNOTSUPP;
 	if (ieee80211_sdata_running(sdata)) {
 		ret = ieee80211_runtime_change_iftype(sdata, type);
 		if (ret)
 			return ret;
 	} else {
 		/* Purge and reset type-dependent state. */
 		ieee80211_teardown_sdata(sdata->dev);
 		ieee80211_setup_sdata(sdata, type);
 	}
 	/* reset some values that shouldn't be kept across type changes */
 	sdata->vif.bss_conf.basic_rates =
 		ieee80211_mandatory_rates(sdata->local,
 			sdata->local->hw.conf.channel->band);
 	sdata->drop_unencrypted = 0;
 	if (type == NL80211_IFTYPE_STATION)
 		sdata->u.mgd.use_4addr = false;
 	return 0;
 }
 static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
 				       struct net_device *dev,
 				       enum nl80211_iftype type)
 {
 	struct ieee80211_sub_if_data *sdata;
 	u64 mask, start, addr, val, inc;
 	u8 *m;
 	u8 tmp_addr[ETH_ALEN];
 	int i;
 	/* default ... something at least */
 	memcpy(dev->perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
 	if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
 	    local->hw.wiphy->n_addresses <= 1)
 		return;
 	mutex_lock(&local->iflist_mtx);
 	switch (type) {
 	case NL80211_IFTYPE_MONITOR:
 		/* doesn't matter */
 		break;
 	case NL80211_IFTYPE_WDS:
 	case NL80211_IFTYPE_AP_VLAN:
 		/* match up with an AP interface */
 		list_for_each_entry(sdata, &local->interfaces, list) {
 			if (sdata->vif.type != NL80211_IFTYPE_AP)
 				continue;
 			memcpy(dev->perm_addr, sdata->vif.addr, ETH_ALEN);
 			break;
 		}
 		/* keep default if no AP interface present */
 		break;
 	default:
 		/* assign a new address if possible -- try n_addresses first */
 		for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
 			bool used = false;
 			list_for_each_entry(sdata, &local->interfaces, list) {
 				if (memcmp(local->hw.wiphy->addresses[i].addr,
 					   sdata->vif.addr, ETH_ALEN) == 0) {
 					used = true;
 					break;
 				}
 			}
 			if (!used) {
 				memcpy(dev->perm_addr,
 				       local->hw.wiphy->addresses[i].addr,
 				       ETH_ALEN);
 				break;
 			}
 		}
 		/* try mask if available */
 		if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
 			break;
 		m = local->hw.wiphy->addr_mask;
 		mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 		if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
 			/* not a contiguous mask ... not handled now! */
 			printk(KERN_DEBUG "not contiguous\n");
 			break;
 		}
 		m = local->hw.wiphy->perm_addr;
 		start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
 			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
 			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
 		inc = 1ULL<<__ffs64(mask);
 		val = (start & mask);
 		addr = (start & ~mask) | (val & mask);
 		do {
 			bool used = false;
 			tmp_addr[5] = addr >> 0*8;
 			tmp_addr[4] = addr >> 1*8;
 			tmp_addr[3] = addr >> 2*8;
 			tmp_addr[2] = addr >> 3*8;
 			tmp_addr[1] = addr >> 4*8;
 			tmp_addr[0] = addr >> 5*8;
 			val += inc;
 			list_for_each_entry(sdata, &local->interfaces, list) {
 				if (memcmp(tmp_addr, sdata->vif.addr,
 							ETH_ALEN) == 0) {
 					used = true;
 					break;
 				}
 			}
 			if (!used) {
 				memcpy(dev->perm_addr, tmp_addr, ETH_ALEN);
 				break;
 			}
 			addr = (start & ~mask) | (val & mask);
 		} while (addr != start);
 		break;
 	}
 	mutex_unlock(&local->iflist_mtx);
 }
 int ieee80211_if_add(struct ieee80211_local *local, const char *name,
 		     struct net_device **new_dev, enum nl80211_iftype type,
 		     struct vif_params *params)
 {
 	struct net_device *ndev;
 	struct ieee80211_sub_if_data *sdata = NULL;
 	int ret, i;
 	ASSERT_RTNL();
 	ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,
 			       name, ieee80211_if_setup, local->hw.queues);
 	if (!ndev)
 		return -ENOMEM;
 	dev_net_set(ndev, wiphy_net(local->hw.wiphy));
 	ndev->needed_headroom = local->tx_headroom +
 				4*6 /* four MAC addresses */
 				+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
 				+ 6 /* mesh */
 				+ 8 /* rfc1042/bridge tunnel */
 				- ETH_HLEN /* ethernet hard_header_len */
 				+ IEEE80211_ENCRYPT_HEADROOM;
 	ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
 	ret = dev_alloc_name(ndev, ndev->name);
 	if (ret < 0)
 		goto fail;
 	ieee80211_assign_perm_addr(local, ndev, type);
 	memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
 	SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
 	/* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
 	sdata = netdev_priv(ndev);
 	ndev->ieee80211_ptr = &sdata->wdev;
 	memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
 	memcpy(sdata->name, ndev->name, IFNAMSIZ);
 	/* initialise type-independent data */
 	sdata->wdev.wiphy = local->hw.wiphy;
 	sdata->local = local;
 	sdata->dev = ndev;
 #ifdef CONFIG_INET
 	sdata->arp_filter_state = true;
 #endif
 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
 		skb_queue_head_init(&sdata->fragments[i].skb_list);
 	INIT_LIST_HEAD(&sdata->key_list);
 	for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
 		struct ieee80211_supported_band *sband;
 		sband = local->hw.wiphy->bands[i];
 		sdata->rc_rateidx_mask[i] =
 			sband ? (1 << sband->n_bitrates) - 1 : 0;
 	}
 	/* setup type-dependent data */
 	ieee80211_setup_sdata(sdata, type);
 	if (params) {
 		ndev->ieee80211_ptr->use_4addr = params->use_4addr;
 		if (type == NL80211_IFTYPE_STATION)
 			sdata->u.mgd.use_4addr = params->use_4addr;
 	}
 	ret = register_netdevice(ndev);
 	if (ret)
 		goto fail;
 	mutex_lock(&local->iflist_mtx);
 	list_add_tail_rcu(&sdata->list, &local->interfaces);
 	mutex_unlock(&local->iflist_mtx);
 	if (new_dev)
 		*new_dev = ndev;
 	return 0;
  fail:
 	free_netdev(ndev);
 	return ret;
 }
 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
 {
 	ASSERT_RTNL();
 	mutex_lock(&sdata->local->iflist_mtx);
 	list_del_rcu(&sdata->list);
 	mutex_unlock(&sdata->local->iflist_mtx);
 	synchronize_rcu();
 	unregister_netdevice(sdata->dev);
 }
 /*
  * Remove all interfaces, may only be called at hardware unregistration
  * time because it doesn't do RCU-safe list removals.
  */
 void ieee80211_remove_interfaces(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata, *tmp;
 	LIST_HEAD(unreg_list);
 	ASSERT_RTNL();
 	mutex_lock(&local->iflist_mtx);
 	list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
 		list_del(&sdata->list);
 		unregister_netdevice_queue(sdata->dev, &unreg_list);
 	}
 	mutex_unlock(&local->iflist_mtx);
 	unregister_netdevice_many(&unreg_list);
+	list_del(&unreg_list);
 }
 static u32 ieee80211_idle_off(struct ieee80211_local *local,
 			      const char *reason)
 {
 	if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
 		return 0;
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	wiphy_debug(local->hw.wiphy, "device no longer idle - %s\n", reason);
 #endif
 	local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
 	return IEEE80211_CONF_CHANGE_IDLE;
 }
 static u32 ieee80211_idle_on(struct ieee80211_local *local)
 {
 	if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
 		return 0;
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	wiphy_debug(local->hw.wiphy, "device now idle\n");
 #endif
 	drv_flush(local, false);
 	local->hw.conf.flags |= IEEE80211_CONF_IDLE;
 	return IEEE80211_CONF_CHANGE_IDLE;
 }
 u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata;
 	int count = 0;
 	bool working = false, scanning = false, hw_roc = false;
 	struct ieee80211_work *wk;
 	unsigned int led_trig_start = 0, led_trig_stop = 0;
 #ifdef CONFIG_PROVE_LOCKING
 	WARN_ON(debug_locks && !lockdep_rtnl_is_held() &&
 		!lockdep_is_held(&local->iflist_mtx));
 #endif
 	lockdep_assert_held(&local->mtx);
 	list_for_each_entry(sdata, &local->interfaces, list) {
 		if (!ieee80211_sdata_running(sdata)) {
 			sdata->vif.bss_conf.idle = true;
 			continue;
 		}
 		sdata->old_idle = sdata->vif.bss_conf.idle;
 		/* do not count disabled managed interfaces */
 		if (sdata->vif.type == NL80211_IFTYPE_STATION &&
 		    !sdata->u.mgd.associated) {
 			sdata->vif.bss_conf.idle = true;
 			continue;
 		}
 		/* do not count unused IBSS interfaces */
 		if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
 		    !sdata->u.ibss.ssid_len) {
 			sdata->vif.bss_conf.idle = true;
 			continue;
 		}
 		/* count everything else */
 		count++;
 	}
 	list_for_each_entry(wk, &local->work_list, list) {
 		working = true;
 		wk->sdata->vif.bss_conf.idle = false;
 	}
 	if (local->scan_sdata) {
 		scanning = true;
 		local->scan_sdata->vif.bss_conf.idle = false;
 	}
 	if (local->hw_roc_channel)
 		hw_roc = true;
 	list_for_each_entry(sdata, &local->interfaces, list) {
 		if (sdata->old_idle == sdata->vif.bss_conf.idle)
 			continue;
 		if (!ieee80211_sdata_running(sdata))
 			continue;
 		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IDLE);
 	}
 	if (working || scanning || hw_roc)
 		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
 	else
 		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
 	if (count)
 		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
 	else
 		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
 	ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
 	if (hw_roc)
 		return ieee80211_idle_off(local, "hw remain-on-channel");
 	if (working)
 		return ieee80211_idle_off(local, "working");
 	if (scanning)
 		return ieee80211_idle_off(local, "scanning");
 	if (!count)
 		return ieee80211_idle_on(local);
 	else
 		return ieee80211_idle_off(local, "in use");
 	return 0;
 }
 void ieee80211_recalc_idle(struct ieee80211_local *local)
 {
 	u32 chg;
 	mutex_lock(&local->iflist_mtx);
 	chg = __ieee80211_recalc_idle(local);
 	mutex_unlock(&local->iflist_mtx);
 	if (chg)
 		ieee80211_hw_config(local, chg);
 }
 static int netdev_notify(struct notifier_block *nb,
 			 unsigned long state,
 			 void *ndev)
 {
 	struct net_device *dev = ndev;
 	struct ieee80211_sub_if_data *sdata;
 	if (state != NETDEV_CHANGENAME)
 		return 0;
 	if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
 		return 0;
 	if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
 		return 0;
 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 	memcpy(sdata->name, dev->name, IFNAMSIZ);
 	ieee80211_debugfs_rename_netdev(sdata);
 	return 0;
 }
 static struct notifier_block mac80211_netdev_notifier = {
 	.notifier_call = netdev_notify,
 };
 int ieee80211_iface_init(void)
 {
 	return register_netdevice_notifier(&mac80211_netdev_notifier);
 }
 void ieee80211_iface_exit(void)
 {
 	unregister_netdevice_notifier(&mac80211_netdev_notifier);
 }

 /*
  * net/sched/sch_generic.c	Generic packet scheduler routines.
  *
  *		This program is free software; you can redistribute it and/or
  *		modify it under the terms of the GNU General Public License
  *		as published by the Free Software Foundation; either version
  *		2 of the License, or (at your option) any later version.
  *
  * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *              Jamal Hadi Salim, <hadi@cyberus.ca> 990601
  *              - Ingress support
  */
 #include <linux/bitops.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/init.h>
 #include <linux/rcupdate.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <net/pkt_sched.h>
 #include <net/dst.h>
 /* Main transmission queue. */
 /* Modifications to data participating in scheduling must be protected with
  * qdisc_lock(qdisc) spinlock.
  *
  * The idea is the following:
  * - enqueue, dequeue are serialized via qdisc root lock
  * - ingress filtering is also serialized via qdisc root lock
  * - updates to tree and tree walking are only done under the rtnl mutex.
  */
 static inline int dev_requeue_skb(struct sk_buff *skb, struct Qdisc *q)
 {
 	skb_dst_force(skb);
 	q->gso_skb = skb;
 	q->qstats.requeues++;
 	q->q.qlen++;	/* it's still part of the queue */
 	__netif_schedule(q);
 	return 0;
 }
 static inline struct sk_buff *dequeue_skb(struct Qdisc *q)
 {
 	struct sk_buff *skb = q->gso_skb;
 	if (unlikely(skb)) {
 		struct net_device *dev = qdisc_dev(q);
 		struct netdev_queue *txq;
 		/* check the reason of requeuing without tx lock first */
 		txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
 		if (!netif_tx_queue_frozen_or_stopped(txq)) {
 			q->gso_skb = NULL;
 			q->q.qlen--;
 		} else
 			skb = NULL;
 	} else {
 		skb = q->dequeue(q);
 	}
 	return skb;
 }
 static inline int handle_dev_cpu_collision(struct sk_buff *skb,
 					   struct netdev_queue *dev_queue,
 					   struct Qdisc *q)
 {
 	int ret;
 	if (unlikely(dev_queue->xmit_lock_owner == smp_processor_id())) {
 		/*
 		 * Same CPU holding the lock. It may be a transient
 		 * configuration error, when hard_start_xmit() recurses. We
 		 * detect it by checking xmit owner and drop the packet when
 		 * deadloop is detected. Return OK to try the next skb.
 		 */
 		kfree_skb(skb);
 		if (net_ratelimit())
 			printk(KERN_WARNING "Dead loop on netdevice %s, "
 			       "fix it urgently!\n", dev_queue->dev->name);
 		ret = qdisc_qlen(q);
 	} else {
 		/*
 		 * Another cpu is holding lock, requeue & delay xmits for
 		 * some time.
 		 */
 		__this_cpu_inc(softnet_data.cpu_collision);
 		ret = dev_requeue_skb(skb, q);
 	}
 	return ret;
 }
 /*
  * Transmit one skb, and handle the return status as required. Holding the
  * __QDISC_STATE_RUNNING bit guarantees that only one CPU can execute this
  * function.
  *
  * Returns to the caller:
  *				0  - queue is empty or throttled.
  *				>0 - queue is not empty.
  */
 int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
 		    struct net_device *dev, struct netdev_queue *txq,
 		    spinlock_t *root_lock)
 {
 	int ret = NETDEV_TX_BUSY;
 	/* And release qdisc */
 	spin_unlock(root_lock);
 	HARD_TX_LOCK(dev, txq, smp_processor_id());
 	if (!netif_tx_queue_frozen_or_stopped(txq))
 		ret = dev_hard_start_xmit(skb, dev, txq);
 	HARD_TX_UNLOCK(dev, txq);
 	spin_lock(root_lock);
 	if (dev_xmit_complete(ret)) {
 		/* Driver sent out skb successfully or skb was consumed */
 		ret = qdisc_qlen(q);
 	} else if (ret == NETDEV_TX_LOCKED) {
 		/* Driver try lock failed */
 		ret = handle_dev_cpu_collision(skb, txq, q);
 	} else {
 		/* Driver returned NETDEV_TX_BUSY - requeue skb */
 		if (unlikely (ret != NETDEV_TX_BUSY && net_ratelimit()))
 			printk(KERN_WARNING "BUG %s code %d qlen %d\n",
 			       dev->name, ret, q->q.qlen);
 		ret = dev_requeue_skb(skb, q);
 	}
 	if (ret && netif_tx_queue_frozen_or_stopped(txq))
 		ret = 0;
 	return ret;
 }
 /*
  * NOTE: Called under qdisc_lock(q) with locally disabled BH.
  *
  * __QDISC_STATE_RUNNING guarantees only one CPU can process
  * this qdisc at a time. qdisc_lock(q) serializes queue accesses for
  * this queue.
  *
  *  netif_tx_lock serializes accesses to device driver.
  *
  *  qdisc_lock(q) and netif_tx_lock are mutually exclusive,
  *  if one is grabbed, another must be free.
  *
  * Note, that this procedure can be called by a watchdog timer
  *
  * Returns to the caller:
  *				0  - queue is empty or throttled.
  *				>0 - queue is not empty.
  *
  */
 static inline int qdisc_restart(struct Qdisc *q)
 {
 	struct netdev_queue *txq;
 	struct net_device *dev;
 	spinlock_t *root_lock;
 	struct sk_buff *skb;
 	/* Dequeue packet */
 	skb = dequeue_skb(q);
 	if (unlikely(!skb))
 		return 0;
 	WARN_ON_ONCE(skb_dst_is_noref(skb));
 	root_lock = qdisc_lock(q);
 	dev = qdisc_dev(q);
 	txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
 	return sch_direct_xmit(skb, q, dev, txq, root_lock);
 }
 void __qdisc_run(struct Qdisc *q)
 {
 	unsigned long start_time = jiffies;
 	while (qdisc_restart(q)) {
 		/*
 		 * Postpone processing if
 		 * 1. another process needs the CPU;
 		 * 2. we've been doing it for too long.
 		 */
 		if (need_resched() || jiffies != start_time) {
 			__netif_schedule(q);
 			break;
 		}
 	}
 	qdisc_run_end(q);
 }
 unsigned long dev_trans_start(struct net_device *dev)
 {
 	unsigned long val, res = dev->trans_start;
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		val = netdev_get_tx_queue(dev, i)->trans_start;
 		if (val && time_after(val, res))
 			res = val;
 	}
 	dev->trans_start = res;
 	return res;
 }
 EXPORT_SYMBOL(dev_trans_start);
 static void dev_watchdog(unsigned long arg)
 {
 	struct net_device *dev = (struct net_device *)arg;
 	netif_tx_lock(dev);
 	if (!qdisc_tx_is_noop(dev)) {
 		if (netif_device_present(dev) &&
 		    netif_running(dev) &&
 		    netif_carrier_ok(dev)) {
 			int some_queue_timedout = 0;
 			unsigned int i;
 			unsigned long trans_start;
 			for (i = 0; i < dev->num_tx_queues; i++) {
 				struct netdev_queue *txq;
 				txq = netdev_get_tx_queue(dev, i);
 				/*
 				 * old device drivers set dev->trans_start
 				 */
 				trans_start = txq->trans_start ? : dev->trans_start;
 				if (netif_tx_queue_stopped(txq) &&
 				    time_after(jiffies, (trans_start +
 							 dev->watchdog_timeo))) {
 					some_queue_timedout = 1;
 					break;
 				}
 			}
 			if (some_queue_timedout) {
 				char drivername[64];
 				WARN_ONCE(1, KERN_INFO "NETDEV WATCHDOG: %s (%s): transmit queue %u timed out\n",
 				       dev->name, netdev_drivername(dev, drivername, 64), i);
 				dev->netdev_ops->ndo_tx_timeout(dev);
 			}
 			if (!mod_timer(&dev->watchdog_timer,
 				       round_jiffies(jiffies +
 						     dev->watchdog_timeo)))
 				dev_hold(dev);
 		}
 	}
 	netif_tx_unlock(dev);
 	dev_put(dev);
 }
 void __netdev_watchdog_up(struct net_device *dev)
 {
 	if (dev->netdev_ops->ndo_tx_timeout) {
 		if (dev->watchdog_timeo <= 0)
 			dev->watchdog_timeo = 5*HZ;
 		if (!mod_timer(&dev->watchdog_timer,
 			       round_jiffies(jiffies + dev->watchdog_timeo)))
 			dev_hold(dev);
 	}
 }
 static void dev_watchdog_up(struct net_device *dev)
 {
 	__netdev_watchdog_up(dev);
 }
 static void dev_watchdog_down(struct net_device *dev)
 {
 	netif_tx_lock_bh(dev);
 	if (del_timer(&dev->watchdog_timer))
 		dev_put(dev);
 	netif_tx_unlock_bh(dev);
 }
 /**
  *	netif_carrier_on - set carrier
  *	@dev: network device
  *
  * Device has detected that carrier.
  */
 void netif_carrier_on(struct net_device *dev)
 {
 	if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
 		if (dev->reg_state == NETREG_UNINITIALIZED)
 			return;
 		linkwatch_fire_event(dev);
 		if (netif_running(dev))
 			__netdev_watchdog_up(dev);
 	}
 }
 EXPORT_SYMBOL(netif_carrier_on);
 /**
  *	netif_carrier_off - clear carrier
  *	@dev: network device
  *
  * Device has detected loss of carrier.
  */
 void netif_carrier_off(struct net_device *dev)
 {
 	if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
 		if (dev->reg_state == NETREG_UNINITIALIZED)
 			return;
 		linkwatch_fire_event(dev);
 	}
 }
 EXPORT_SYMBOL(netif_carrier_off);
 /**
  * 	netif_notify_peers - notify network peers about existence of @dev
  * 	@dev: network device
  *
  * Generate traffic such that interested network peers are aware of
  * @dev, such as by generating a gratuitous ARP. This may be used when
  * a device wants to inform the rest of the network about some sort of
  * reconfiguration such as a failover event or virtual machine
  * migration.
  */
 void netif_notify_peers(struct net_device *dev)
 {
 	rtnl_lock();
 	call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, dev);
 	rtnl_unlock();
 }
 EXPORT_SYMBOL(netif_notify_peers);
 /* "NOOP" scheduler: the best scheduler, recommended for all interfaces
    under all circumstances. It is difficult to invent anything faster or
    cheaper.
  */
 static int noop_enqueue(struct sk_buff *skb, struct Qdisc * qdisc)
 {
 	kfree_skb(skb);
 	return NET_XMIT_CN;
 }
 static struct sk_buff *noop_dequeue(struct Qdisc * qdisc)
 {
 	return NULL;
 }
 struct Qdisc_ops noop_qdisc_ops __read_mostly = {
 	.id		=	"noop",
 	.priv_size	=	0,
 	.enqueue	=	noop_enqueue,
 	.dequeue	=	noop_dequeue,
 	.peek		=	noop_dequeue,
 	.owner		=	THIS_MODULE,
 };
 static struct netdev_queue noop_netdev_queue = {
 	.qdisc		=	&noop_qdisc,
 	.qdisc_sleeping	=	&noop_qdisc,
 };
 struct Qdisc noop_qdisc = {
 	.enqueue	=	noop_enqueue,
 	.dequeue	=	noop_dequeue,
 	.flags		=	TCQ_F_BUILTIN,
 	.ops		=	&noop_qdisc_ops,
 	.list		=	LIST_HEAD_INIT(noop_qdisc.list),
 	.q.lock		=	__SPIN_LOCK_UNLOCKED(noop_qdisc.q.lock),
 	.dev_queue	=	&noop_netdev_queue,
 	.busylock	=	__SPIN_LOCK_UNLOCKED(noop_qdisc.busylock),
 };
 EXPORT_SYMBOL(noop_qdisc);
 static struct Qdisc_ops noqueue_qdisc_ops __read_mostly = {
 	.id		=	"noqueue",
 	.priv_size	=	0,
 	.enqueue	=	noop_enqueue,
 	.dequeue	=	noop_dequeue,
 	.peek		=	noop_dequeue,
 	.owner		=	THIS_MODULE,
 };
 static struct Qdisc noqueue_qdisc;
 static struct netdev_queue noqueue_netdev_queue = {
 	.qdisc		=	&noqueue_qdisc,
 	.qdisc_sleeping	=	&noqueue_qdisc,
 };
 static struct Qdisc noqueue_qdisc = {
 	.enqueue	=	NULL,
 	.dequeue	=	noop_dequeue,
 	.flags		=	TCQ_F_BUILTIN,
 	.ops		=	&noqueue_qdisc_ops,
 	.list		=	LIST_HEAD_INIT(noqueue_qdisc.list),
 	.q.lock		=	__SPIN_LOCK_UNLOCKED(noqueue_qdisc.q.lock),
 	.dev_queue	=	&noqueue_netdev_queue,
 	.busylock	=	__SPIN_LOCK_UNLOCKED(noqueue_qdisc.busylock),
 };
 static const u8 prio2band[TC_PRIO_MAX+1] =
 	{ 1, 2, 2, 2, 1, 2, 0, 0 , 1, 1, 1, 1, 1, 1, 1, 1 };
 /* 3-band FIFO queue: old style, but should be a bit faster than
    generic prio+fifo combination.
  */
 #define PFIFO_FAST_BANDS 3
 /*
  * Private data for a pfifo_fast scheduler containing:
  * 	- queues for the three band
  * 	- bitmap indicating which of the bands contain skbs
  */
 struct pfifo_fast_priv {
 	u32 bitmap;
 	struct sk_buff_head q[PFIFO_FAST_BANDS];
 };
 /*
  * Convert a bitmap to the first band number where an skb is queued, where:
  * 	bitmap=0 means there are no skbs on any band.
  * 	bitmap=1 means there is an skb on band 0.
  *	bitmap=7 means there are skbs on all 3 bands, etc.
  */
 static const int bitmap2band[] = {-1, 0, 1, 0, 2, 0, 1, 0};
 static inline struct sk_buff_head *band2list(struct pfifo_fast_priv *priv,
 					     int band)
 {
 	return priv->q + band;
 }
 static int pfifo_fast_enqueue(struct sk_buff *skb, struct Qdisc* qdisc)
 {
 	if (skb_queue_len(&qdisc->q) < qdisc_dev(qdisc)->tx_queue_len) {
 		int band = prio2band[skb->priority & TC_PRIO_MAX];
 		struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
 		struct sk_buff_head *list = band2list(priv, band);
 		priv->bitmap |= (1 << band);
 		qdisc->q.qlen++;
 		return __qdisc_enqueue_tail(skb, qdisc, list);
 	}
 	return qdisc_drop(skb, qdisc);
 }
 static struct sk_buff *pfifo_fast_dequeue(struct Qdisc* qdisc)
 {
 	struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
 	int band = bitmap2band[priv->bitmap];
 	if (likely(band >= 0)) {
 		struct sk_buff_head *list = band2list(priv, band);
 		struct sk_buff *skb = __qdisc_dequeue_head(qdisc, list);
 		qdisc->q.qlen--;
 		if (skb_queue_empty(list))
 			priv->bitmap &= ~(1 << band);
 		return skb;
 	}
 	return NULL;
 }
 static struct sk_buff *pfifo_fast_peek(struct Qdisc* qdisc)
 {
 	struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
 	int band = bitmap2band[priv->bitmap];
 	if (band >= 0) {
 		struct sk_buff_head *list = band2list(priv, band);
 		return skb_peek(list);
 	}
 	return NULL;
 }
 static void pfifo_fast_reset(struct Qdisc* qdisc)
 {
 	int prio;
 	struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
 	for (prio = 0; prio < PFIFO_FAST_BANDS; prio++)
 		__qdisc_reset_queue(qdisc, band2list(priv, prio));
 	priv->bitmap = 0;
 	qdisc->qstats.backlog = 0;
 	qdisc->q.qlen = 0;
 }
 static int pfifo_fast_dump(struct Qdisc *qdisc, struct sk_buff *skb)
 {
 	struct tc_prio_qopt opt = { .bands = PFIFO_FAST_BANDS };
 	memcpy(&opt.priomap, prio2band, TC_PRIO_MAX+1);
 	NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
 	return skb->len;
 nla_put_failure:
 	return -1;
 }
 static int pfifo_fast_init(struct Qdisc *qdisc, struct nlattr *opt)
 {
 	int prio;
 	struct pfifo_fast_priv *priv = qdisc_priv(qdisc);
 	for (prio = 0; prio < PFIFO_FAST_BANDS; prio++)
 		skb_queue_head_init(band2list(priv, prio));
 	return 0;
 }
 struct Qdisc_ops pfifo_fast_ops __read_mostly = {
 	.id		=	"pfifo_fast",
 	.priv_size	=	sizeof(struct pfifo_fast_priv),
 	.enqueue	=	pfifo_fast_enqueue,
 	.dequeue	=	pfifo_fast_dequeue,
 	.peek		=	pfifo_fast_peek,
 	.init		=	pfifo_fast_init,
 	.reset		=	pfifo_fast_reset,
 	.dump		=	pfifo_fast_dump,
 	.owner		=	THIS_MODULE,
 };
 struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
 			  struct Qdisc_ops *ops)
 {
 	void *p;
 	struct Qdisc *sch;
 	unsigned int size;
 	int err = -ENOBUFS;
 	/* ensure that the Qdisc and the private data are 64-byte aligned */
 	size = QDISC_ALIGN(sizeof(*sch));
 	size += ops->priv_size + (QDISC_ALIGNTO - 1);
 	p = kzalloc_node(size, GFP_KERNEL,
 			 netdev_queue_numa_node_read(dev_queue));
 	if (!p)
 		goto errout;
 	sch = (struct Qdisc *) QDISC_ALIGN((unsigned long) p);
 	sch->padded = (char *) sch - (char *) p;
 	INIT_LIST_HEAD(&sch->list);
 	skb_queue_head_init(&sch->q);
 	spin_lock_init(&sch->busylock);
 	sch->ops = ops;
 	sch->enqueue = ops->enqueue;
 	sch->dequeue = ops->dequeue;
 	sch->dev_queue = dev_queue;
 	dev_hold(qdisc_dev(sch));
 	atomic_set(&sch->refcnt, 1);
 	return sch;
 errout:
 	return ERR_PTR(err);
 }
 struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
 				struct Qdisc_ops *ops, unsigned int parentid)
 {
 	struct Qdisc *sch;
 	sch = qdisc_alloc(dev_queue, ops);
 	if (IS_ERR(sch))
 		goto errout;
 	sch->parent = parentid;
 	if (!ops->init || ops->init(sch, NULL) == 0)
 		return sch;
 	qdisc_destroy(sch);
 errout:
 	return NULL;
 }
 EXPORT_SYMBOL(qdisc_create_dflt);
 /* Under qdisc_lock(qdisc) and BH! */
 void qdisc_reset(struct Qdisc *qdisc)
 {
 	const struct Qdisc_ops *ops = qdisc->ops;
 	if (ops->reset)
 		ops->reset(qdisc);
 	if (qdisc->gso_skb) {
 		kfree_skb(qdisc->gso_skb);
 		qdisc->gso_skb = NULL;
 		qdisc->q.qlen = 0;
 	}
 }
 EXPORT_SYMBOL(qdisc_reset);
 static void qdisc_rcu_free(struct rcu_head *head)
 {
 	struct Qdisc *qdisc = container_of(head, struct Qdisc, rcu_head);
 	kfree((char *) qdisc - qdisc->padded);
 }
 void qdisc_destroy(struct Qdisc *qdisc)
 {
 	const struct Qdisc_ops  *ops = qdisc->ops;
 	if (qdisc->flags & TCQ_F_BUILTIN ||
 	    !atomic_dec_and_test(&qdisc->refcnt))
 		return;
 #ifdef CONFIG_NET_SCHED
 	qdisc_list_del(qdisc);
 	qdisc_put_stab(qdisc->stab);
 #endif
 	gen_kill_estimator(&qdisc->bstats, &qdisc->rate_est);
 	if (ops->reset)
 		ops->reset(qdisc);
 	if (ops->destroy)
 		ops->destroy(qdisc);
 	module_put(ops->owner);
 	dev_put(qdisc_dev(qdisc));
 	kfree_skb(qdisc->gso_skb);
 	/*
 	 * gen_estimator est_timer() might access qdisc->q.lock,
 	 * wait a RCU grace period before freeing qdisc.
 	 */
 	call_rcu(&qdisc->rcu_head, qdisc_rcu_free);
 }
 EXPORT_SYMBOL(qdisc_destroy);
 /* Attach toplevel qdisc to device queue. */
 struct Qdisc *dev_graft_qdisc(struct netdev_queue *dev_queue,
 			      struct Qdisc *qdisc)
 {
 	struct Qdisc *oqdisc = dev_queue->qdisc_sleeping;
 	spinlock_t *root_lock;
 	root_lock = qdisc_lock(oqdisc);
 	spin_lock_bh(root_lock);
 	/* Prune old scheduler */
 	if (oqdisc && atomic_read(&oqdisc->refcnt) <= 1)
 		qdisc_reset(oqdisc);
 	/* ... and graft new one */
 	if (qdisc == NULL)
 		qdisc = &noop_qdisc;
 	dev_queue->qdisc_sleeping = qdisc;
 	rcu_assign_pointer(dev_queue->qdisc, &noop_qdisc);
 	spin_unlock_bh(root_lock);
 	return oqdisc;
 }
 static void attach_one_default_qdisc(struct net_device *dev,
 				     struct netdev_queue *dev_queue,
 				     void *_unused)
 {
 	struct Qdisc *qdisc;
 	if (dev->tx_queue_len) {
 		qdisc = qdisc_create_dflt(dev_queue,
 					  &pfifo_fast_ops, TC_H_ROOT);
 		if (!qdisc) {
 			printk(KERN_INFO "%s: activation failed\n", dev->name);
 			return;
 		}
 		/* Can by-pass the queue discipline for default qdisc */
 		qdisc->flags |= TCQ_F_CAN_BYPASS;
 	} else {
 		qdisc =  &noqueue_qdisc;
 	}
 	dev_queue->qdisc_sleeping = qdisc;
 }
 static void attach_default_qdiscs(struct net_device *dev)
 {
 	struct netdev_queue *txq;
 	struct Qdisc *qdisc;
 	txq = netdev_get_tx_queue(dev, 0);
 	if (!netif_is_multiqueue(dev) || dev->tx_queue_len == 0) {
 		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
 		dev->qdisc = txq->qdisc_sleeping;
 		atomic_inc(&dev->qdisc->refcnt);
 	} else {
 		qdisc = qdisc_create_dflt(txq, &mq_qdisc_ops, TC_H_ROOT);
 		if (qdisc) {
 			qdisc->ops->attach(qdisc);
 			dev->qdisc = qdisc;
 		}
 	}
 }
 static void transition_one_qdisc(struct net_device *dev,
 				 struct netdev_queue *dev_queue,
 				 void *_need_watchdog)
 {
 	struct Qdisc *new_qdisc = dev_queue->qdisc_sleeping;
 	int *need_watchdog_p = _need_watchdog;
 	if (!(new_qdisc->flags & TCQ_F_BUILTIN))
 		clear_bit(__QDISC_STATE_DEACTIVATED, &new_qdisc->state);
 	rcu_assign_pointer(dev_queue->qdisc, new_qdisc);
 	if (need_watchdog_p && new_qdisc != &noqueue_qdisc) {
 		dev_queue->trans_start = 0;
 		*need_watchdog_p = 1;
 	}
 }
 void dev_activate(struct net_device *dev)
 {
 	int need_watchdog;
 	/* No queueing discipline is attached to device;
 	   create default one i.e. pfifo_fast for devices,
 	   which need queueing and noqueue_qdisc for
 	   virtual interfaces
 	 */
 	if (dev->qdisc == &noop_qdisc)
 		attach_default_qdiscs(dev);
 	if (!netif_carrier_ok(dev))
 		/* Delay activation until next carrier-on event */
 		return;
 	need_watchdog = 0;
 	netdev_for_each_tx_queue(dev, transition_one_qdisc, &need_watchdog);
 	if (dev_ingress_queue(dev))
 		transition_one_qdisc(dev, dev_ingress_queue(dev), NULL);
 	if (need_watchdog) {
 		dev->trans_start = jiffies;
 		dev_watchdog_up(dev);
 	}
 }
 static void dev_deactivate_queue(struct net_device *dev,
 				 struct netdev_queue *dev_queue,
 				 void *_qdisc_default)
 {
 	struct Qdisc *qdisc_default = _qdisc_default;
 	struct Qdisc *qdisc;
 	qdisc = dev_queue->qdisc;
 	if (qdisc) {
 		spin_lock_bh(qdisc_lock(qdisc));
 		if (!(qdisc->flags & TCQ_F_BUILTIN))
 			set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
 		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
 		qdisc_reset(qdisc);
 		spin_unlock_bh(qdisc_lock(qdisc));
 	}
 }
 static bool some_qdisc_is_busy(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *dev_queue;
 		spinlock_t *root_lock;
 		struct Qdisc *q;
 		int val;
 		dev_queue = netdev_get_tx_queue(dev, i);
 		q = dev_queue->qdisc_sleeping;
 		root_lock = qdisc_lock(q);
 		spin_lock_bh(root_lock);
 		val = (qdisc_is_running(q) ||
 		       test_bit(__QDISC_STATE_SCHED, &q->state));
 		spin_unlock_bh(root_lock);
 		if (val)
 			return true;
 	}
 	return false;
 }
 void dev_deactivate_many(struct list_head *head)
 {
 	struct net_device *dev;
 	list_for_each_entry(dev, head, unreg_list) {
 		netdev_for_each_tx_queue(dev, dev_deactivate_queue,
 					 &noop_qdisc);
 		if (dev_ingress_queue(dev))
 			dev_deactivate_queue(dev, dev_ingress_queue(dev),
 					     &noop_qdisc);
 		dev_watchdog_down(dev);
 	}
 	/* Wait for outstanding qdisc-less dev_queue_xmit calls. */
 	synchronize_rcu();
 	/* Wait for outstanding qdisc_run calls. */
 	list_for_each_entry(dev, head, unreg_list)
 		while (some_qdisc_is_busy(dev))
 			yield();
 }
 void dev_deactivate(struct net_device *dev)
 {
 	LIST_HEAD(single);
 	list_add(&dev->unreg_list, &single);
 	dev_deactivate_many(&single);
+	list_del(&single);
 }
 static void dev_init_scheduler_queue(struct net_device *dev,
 				     struct netdev_queue *dev_queue,
 				     void *_qdisc)
 {
 	struct Qdisc *qdisc = _qdisc;
 	dev_queue->qdisc = qdisc;
 	dev_queue->qdisc_sleeping = qdisc;
 }
 void dev_init_scheduler(struct net_device *dev)
 {
 	dev->qdisc = &noop_qdisc;
 	netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc);
 	if (dev_ingress_queue(dev))
 		dev_init_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
 	setup_timer(&dev->watchdog_timer, dev_watchdog, (unsigned long)dev);
 }
 static void shutdown_scheduler_queue(struct net_device *dev,
 				     struct netdev_queue *dev_queue,
 				     void *_qdisc_default)
 {
 	struct Qdisc *qdisc = dev_queue->qdisc_sleeping;
 	struct Qdisc *qdisc_default = _qdisc_default;
 	if (qdisc) {
 		rcu_assign_pointer(dev_queue->qdisc, qdisc_default);
 		dev_queue->qdisc_sleeping = qdisc_default;
 		qdisc_destroy(qdisc);
 	}
 }
 void dev_shutdown(struct net_device *dev)
 {
 	netdev_for_each_tx_queue(dev, shutdown_scheduler_queue, &noop_qdisc);
 	if (dev_ingress_queue(dev))
 		shutdown_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);
 	qdisc_destroy(dev->qdisc);
 	dev->qdisc = &noop_qdisc;
 	WARN_ON(timer_pending(&dev->watchdog_timer));
 }