Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* INET An implementation of the TCP/IP protocol suite for the LINUX

2

* INET An implementation of the TCP/IP protocol suite for the LINUX

3

* operating system. INET is implemented using the BSD Socket

3

* operating system. INET is implemented using the BSD Socket

4

* interface as the means of communication with the user level.

4

* interface as the means of communication with the user level.

5

*

5

*

6

* Definitions for the Interfaces handler.

6

* Definitions for the Interfaces handler.

7

*

7

*

8

* Version: @(#)dev.h 1.0.10 08/12/93

8

* Version: @(#)dev.h 1.0.10 08/12/93

9

*

9

*

10

* Authors: Ross Biro

10

* Authors: Ross Biro

11

* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>

11

* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>

12

* Corey Minyard <wf-rch!minyard@relay.EU.net>

12

* Corey Minyard <wf-rch!minyard@relay.EU.net>

13

* Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>

13

* Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>

14

* Alan Cox, <alan@lxorguk.ukuu.org.uk>

14

* Alan Cox, <alan@lxorguk.ukuu.org.uk>

15

* Bjorn Ekwall. <bj0rn@blox.se>

15

* Bjorn Ekwall. <bj0rn@blox.se>

16

* Pekka Riikonen <priikone@poseidon.pspt.fi>

16

* Pekka Riikonen <priikone@poseidon.pspt.fi>

17

*

17

*

18

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

18

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

19

* modify it under the terms of the GNU General Public License

19

* modify it under the terms of the GNU General Public License

20

* as published by the Free Software Foundation; either version

20

* as published by the Free Software Foundation; either version

21

* 2 of the License, or (at your option) any later version.

21

* 2 of the License, or (at your option) any later version.

22

*

22

*

23

* Moved to /usr/include/linux for NET3

23

* Moved to /usr/include/linux for NET3

24

*/

24

*/

25

#ifndef _LINUX_NETDEVICE_H

25

#ifndef _LINUX_NETDEVICE_H

26

#define _LINUX_NETDEVICE_H

26

#define _LINUX_NETDEVICE_H

27

28

#include <linux/if.h>

28

#include <linux/if.h>

29

#include <linux/if_ether.h>

29

#include <linux/if_ether.h>

30

#include <linux/if_packet.h>

30

#include <linux/if_packet.h>

31

32

#ifdef __KERNEL__

32

#ifdef __KERNEL__

33

#include <linux/timer.h>

33

#include <linux/timer.h>

34

#include <linux/delay.h>

34

#include <linux/delay.h>

35

#include <linux/mm.h>

35

#include <linux/mm.h>

36

#include <asm/atomic.h>

36

#include <asm/atomic.h>

37

#include <asm/cache.h>

37

#include <asm/cache.h>

38

#include <asm/byteorder.h>

38

#include <asm/byteorder.h>

39

40

#include <linux/device.h>

40

#include <linux/device.h>

41

#include <linux/percpu.h>

41

#include <linux/percpu.h>

42

#include <linux/rculist.h>

42

#include <linux/rculist.h>

43

#include <linux/dmaengine.h>

43

#include <linux/dmaengine.h>

44

#include <linux/workqueue.h>

44

#include <linux/workqueue.h>

45

46

#include <linux/ethtool.h>

46

#include <linux/ethtool.h>

47

#include <net/net_namespace.h>

47

#include <net/net_namespace.h>

48

#include <net/dsa.h>

48

#include <net/dsa.h>

49

#ifdef CONFIG_DCB

49

#ifdef CONFIG_DCB

50

#include <net/dcbnl.h>

50

#include <net/dcbnl.h>

51

#endif

51

#endif

52

53

struct vlan_group;

53

struct vlan_group;

54

struct netpoll_info;

54

struct netpoll_info;

55

/* 802.11 specific */

55

/* 802.11 specific */

56

struct wireless_dev;

56

struct wireless_dev;

57

/* source back-compat hooks */

57

/* source back-compat hooks */

58

#define SET_ETHTOOL_OPS(netdev,ops) \

58

#define SET_ETHTOOL_OPS(netdev,ops) \

59

( (netdev)->ethtool_ops = (ops) )

59

( (netdev)->ethtool_ops = (ops) )

60

61

#define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev

61

#define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev

62

functions are available. */

62

functions are available. */

63

#define HAVE_FREE_NETDEV /* free_netdev() */

63

#define HAVE_FREE_NETDEV /* free_netdev() */

64

#define HAVE_NETDEV_PRIV /* netdev_priv() */

64

#define HAVE_NETDEV_PRIV /* netdev_priv() */

65

66

#define NET_XMIT_SUCCESS 0

66

#define NET_XMIT_SUCCESS 0

67

#define NET_XMIT_DROP 1 /* skb dropped */

67

#define NET_XMIT_DROP 1 /* skb dropped */

68

#define NET_XMIT_CN 2 /* congestion notification */

68

#define NET_XMIT_CN 2 /* congestion notification */

69

#define NET_XMIT_POLICED 3 /* skb is shot by police */

69

#define NET_XMIT_POLICED 3 /* skb is shot by police */

70

#define NET_XMIT_MASK 0xFFFF /* qdisc flags in net/sch_generic.h */

70

#define NET_XMIT_MASK 0xFFFF /* qdisc flags in net/sch_generic.h */

71

72

/* Backlog congestion levels */

72

/* Backlog congestion levels */

73

#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */

73

#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */

74

#define NET_RX_DROP 1 /* packet dropped */

74

#define NET_RX_DROP 1 /* packet dropped */

75

76

/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It

76

/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It

77

* indicates that the device will soon be dropping packets, or already drops

77

* indicates that the device will soon be dropping packets, or already drops

78

* some packets of the same priority; prompting us to send less aggressively. */

78

* some packets of the same priority; prompting us to send less aggressively. */

79

#define net_xmit_eval(e) ((e) == NET_XMIT_CN? 0 : (e))

79

#define net_xmit_eval(e) ((e) == NET_XMIT_CN? 0 : (e))

80

#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)

80

#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)

81

82

/* Driver transmit return codes */

82

/* Driver transmit return codes */

83

enum netdev_tx {

83

enum netdev_tx {

84

NETDEV_TX_OK = 0, /* driver took care of packet */

84

NETDEV_TX_OK = 0, /* driver took care of packet */

85

NETDEV_TX_BUSY, /* driver tx path was busy*/

85

NETDEV_TX_BUSY, /* driver tx path was busy*/

86

NETDEV_TX_LOCKED = -1, /* driver tx lock was already taken */

86

NETDEV_TX_LOCKED = -1, /* driver tx lock was already taken */

87

};

87

};

88

typedef enum netdev_tx netdev_tx_t;

88

typedef enum netdev_tx netdev_tx_t;

89

90

#endif

90

#endif

91

92

#define MAX_ADDR_LEN 32 /* Largest hardware address length */

92

#define MAX_ADDR_LEN 32 /* Largest hardware address length */

93

94

#ifdef __KERNEL__

94

#ifdef __KERNEL__

95

/*

95

/*

96

* Compute the worst case header length according to the protocols

96

* Compute the worst case header length according to the protocols

97

* used.

97

* used.

98

*/

98

*/

99

100

#if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)

100

#if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)

101

# if defined(CONFIG_MAC80211_MESH)

101

# if defined(CONFIG_MAC80211_MESH)

102

# define LL_MAX_HEADER 128

102

# define LL_MAX_HEADER 128

103

# else

103

# else

104

# define LL_MAX_HEADER 96

104

# define LL_MAX_HEADER 96

105

# endif

105

# endif

106

#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)

106

#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)

107

# define LL_MAX_HEADER 48

107

# define LL_MAX_HEADER 48

108

#else

108

#else

109

# define LL_MAX_HEADER 32

109

# define LL_MAX_HEADER 32

110

#endif

110

#endif

111

112

#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \

112

#if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \

113

!defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \

113

!defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \

114

!defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \

114

!defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \

115

!defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)

115

!defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)

116

#define MAX_HEADER LL_MAX_HEADER

116

#define MAX_HEADER LL_MAX_HEADER

117

#else

117

#else

118

#define MAX_HEADER (LL_MAX_HEADER + 48)

118

#define MAX_HEADER (LL_MAX_HEADER + 48)

119

#endif

119

#endif

120

121

#endif /* __KERNEL__ */

121

#endif /* __KERNEL__ */

122

123

/*

123

/*

124

* Network device statistics. Akin to the 2.0 ether stats but

124

* Network device statistics. Akin to the 2.0 ether stats but

125

* with byte counters.

125

* with byte counters.

126

*/

126

*/

127

128

struct net_device_stats {

128

struct net_device_stats {

129

unsigned long rx_packets; /* total packets received */

129

unsigned long rx_packets; /* total packets received */

130

unsigned long tx_packets; /* total packets transmitted */

130

unsigned long tx_packets; /* total packets transmitted */

131

unsigned long rx_bytes; /* total bytes received */

131

unsigned long rx_bytes; /* total bytes received */

132

unsigned long tx_bytes; /* total bytes transmitted */

132

unsigned long tx_bytes; /* total bytes transmitted */

133

unsigned long rx_errors; /* bad packets received */

133

unsigned long rx_errors; /* bad packets received */

134

unsigned long tx_errors; /* packet transmit problems */

134

unsigned long tx_errors; /* packet transmit problems */

135

unsigned long rx_dropped; /* no space in linux buffers */

135

unsigned long rx_dropped; /* no space in linux buffers */

136

unsigned long tx_dropped; /* no space available in linux */

136

unsigned long tx_dropped; /* no space available in linux */

137

unsigned long multicast; /* multicast packets received */

137

unsigned long multicast; /* multicast packets received */

138

unsigned long collisions;

138

unsigned long collisions;

139

140

/* detailed rx_errors: */

140

/* detailed rx_errors: */

141

unsigned long rx_length_errors;

141

unsigned long rx_length_errors;

142

unsigned long rx_over_errors; /* receiver ring buff overflow */

142

unsigned long rx_over_errors; /* receiver ring buff overflow */

143

unsigned long rx_crc_errors; /* recved pkt with crc error */

143

unsigned long rx_crc_errors; /* recved pkt with crc error */

144

unsigned long rx_frame_errors; /* recv'd frame alignment error */

144

unsigned long rx_frame_errors; /* recv'd frame alignment error */

145

unsigned long rx_fifo_errors; /* recv'r fifo overrun */

145

unsigned long rx_fifo_errors; /* recv'r fifo overrun */

146

unsigned long rx_missed_errors; /* receiver missed packet */

146

unsigned long rx_missed_errors; /* receiver missed packet */

147

148

/* detailed tx_errors */

148

/* detailed tx_errors */

149

unsigned long tx_aborted_errors;

149

unsigned long tx_aborted_errors;

150

unsigned long tx_carrier_errors;

150

unsigned long tx_carrier_errors;

151

unsigned long tx_fifo_errors;

151

unsigned long tx_fifo_errors;

152

unsigned long tx_heartbeat_errors;

152

unsigned long tx_heartbeat_errors;

153

unsigned long tx_window_errors;

153

unsigned long tx_window_errors;

154

155

/* for cslip etc */

155

/* for cslip etc */

156

unsigned long rx_compressed;

156

unsigned long rx_compressed;

157

unsigned long tx_compressed;

157

unsigned long tx_compressed;

158

};

158

};

159

160

161

/* Media selection options. */

161

/* Media selection options. */

162

enum {

162

enum {

163

IF_PORT_UNKNOWN = 0,

163

IF_PORT_UNKNOWN = 0,

164

IF_PORT_10BASE2,

164

IF_PORT_10BASE2,

165

IF_PORT_10BASET,

165

IF_PORT_10BASET,

166

IF_PORT_AUI,

166

IF_PORT_AUI,

167

IF_PORT_100BASET,

167

IF_PORT_100BASET,

168

IF_PORT_100BASETX,

168

IF_PORT_100BASETX,

169

IF_PORT_100BASEFX

169

IF_PORT_100BASEFX

170

};

170

};

171

172

#ifdef __KERNEL__

172

#ifdef __KERNEL__

173

174

#include <linux/cache.h>

174

#include <linux/cache.h>

175

#include <linux/skbuff.h>

175

#include <linux/skbuff.h>

176

177

struct neighbour;

177

struct neighbour;

178

struct neigh_parms;

178

struct neigh_parms;

179

struct sk_buff;

179

struct sk_buff;

180

181

struct netif_rx_stats {

181

struct netif_rx_stats {

182

unsigned total;

182

unsigned total;

183

unsigned dropped;

183

unsigned dropped;

184

unsigned time_squeeze;

184

unsigned time_squeeze;

185

unsigned cpu_collision;

185

unsigned cpu_collision;

186

};

186

};

187

188

DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);

188

DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);

189

190

struct dev_addr_list {

190

struct dev_addr_list {

191

struct dev_addr_list *next;

191

struct dev_addr_list *next;

192

u8 da_addr[MAX_ADDR_LEN];

192

u8 da_addr[MAX_ADDR_LEN];

193

u8 da_addrlen;

193

u8 da_addrlen;

194

u8 da_synced;

194

u8 da_synced;

195

int da_users;

195

int da_users;

196

int da_gusers;

196

int da_gusers;

197

};

197

};

198

199

/*

199

/*

200

* We tag multicasts with these structures.

200

* We tag multicasts with these structures.

201

*/

201

*/

202

203

#define dev_mc_list dev_addr_list

203

#define dev_mc_list dev_addr_list

204

#define dmi_addr da_addr

204

#define dmi_addr da_addr

205

#define dmi_addrlen da_addrlen

205

#define dmi_addrlen da_addrlen

206

#define dmi_users da_users

206

#define dmi_users da_users

207

#define dmi_gusers da_gusers

207

#define dmi_gusers da_gusers

208

209

struct netdev_hw_addr {

209

struct netdev_hw_addr {

210

struct list_head list;

210

struct list_head list;

211

unsigned char addr[MAX_ADDR_LEN];

211

unsigned char addr[MAX_ADDR_LEN];

212

unsigned char type;

212

unsigned char type;

213

#define NETDEV_HW_ADDR_T_LAN 1

213

#define NETDEV_HW_ADDR_T_LAN 1

214

#define NETDEV_HW_ADDR_T_SAN 2

214

#define NETDEV_HW_ADDR_T_SAN 2

215

#define NETDEV_HW_ADDR_T_SLAVE 3

215

#define NETDEV_HW_ADDR_T_SLAVE 3

216

#define NETDEV_HW_ADDR_T_UNICAST 4

216

#define NETDEV_HW_ADDR_T_UNICAST 4

217

int refcount;

217

int refcount;

218

bool synced;

218

bool synced;

219

struct rcu_head rcu_head;

219

struct rcu_head rcu_head;

220

};

220

};

221

222

struct netdev_hw_addr_list {

222

struct netdev_hw_addr_list {

223

struct list_head list;

223

struct list_head list;

224

int count;

224

int count;

225

};

225

};

226

227

struct hh_cache {

227

struct hh_cache {

228

struct hh_cache *hh_next; /* Next entry */

228

struct hh_cache *hh_next; /* Next entry */

229

atomic_t hh_refcnt; /* number of users */

229

atomic_t hh_refcnt; /* number of users */

230

/*

230

/*

231

* We want hh_output, hh_len, hh_lock and hh_data be a in a separate

231

* We want hh_output, hh_len, hh_lock and hh_data be a in a separate

232

* cache line on SMP.

232

* cache line on SMP.

233

* They are mostly read, but hh_refcnt may be changed quite frequently,

233

* They are mostly read, but hh_refcnt may be changed quite frequently,

234

* incurring cache line ping pongs.

234

* incurring cache line ping pongs.

235

*/

235

*/

236

__be16 hh_type ____cacheline_aligned_in_smp;

236

__be16 hh_type ____cacheline_aligned_in_smp;

237

/* protocol identifier, f.e ETH_P_IP

237

/* protocol identifier, f.e ETH_P_IP

238

* NOTE: For VLANs, this will be the

238

* NOTE: For VLANs, this will be the

239

* encapuslated type. --BLG

239

* encapuslated type. --BLG

240

*/

240

*/

241

u16 hh_len; /* length of header */

241

u16 hh_len; /* length of header */

242

int (*hh_output)(struct sk_buff *skb);

242

int (*hh_output)(struct sk_buff *skb);

243

seqlock_t hh_lock;

243

seqlock_t hh_lock;

244

245

/* cached hardware header; allow for machine alignment needs. */

245

/* cached hardware header; allow for machine alignment needs. */

246

#define HH_DATA_MOD 16

246

#define HH_DATA_MOD 16

247

#define HH_DATA_OFF(__len) \

247

#define HH_DATA_OFF(__len) \

248

(HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))

248

(HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))

249

#define HH_DATA_ALIGN(__len) \

249

#define HH_DATA_ALIGN(__len) \

250

(((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))

250

(((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))

251

unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];

251

unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];

252

};

252

};

253

254

/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.

254

/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.

255

* Alternative is:

255

* Alternative is:

256

* dev->hard_header_len ? (dev->hard_header_len +

256

* dev->hard_header_len ? (dev->hard_header_len +

257

* (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0

257

* (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0

258

*

258

*

259

* We could use other alignment values, but we must maintain the

259

* We could use other alignment values, but we must maintain the

260

* relationship HH alignment <= LL alignment.

260

* relationship HH alignment <= LL alignment.

261

*

261

*

262

* LL_ALLOCATED_SPACE also takes into account the tailroom the device

262

* LL_ALLOCATED_SPACE also takes into account the tailroom the device

263

* may need.

263

* may need.

264

*/

264

*/

265

#define LL_RESERVED_SPACE(dev) \

265

#define LL_RESERVED_SPACE(dev) \

266

((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

266

((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

267

#define LL_RESERVED_SPACE_EXTRA(dev,extra) \

267

#define LL_RESERVED_SPACE_EXTRA(dev,extra) \

268

((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

268

((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

269

#define LL_ALLOCATED_SPACE(dev) \

269

#define LL_ALLOCATED_SPACE(dev) \

270

((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

270

((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

271

272

struct header_ops {

272

struct header_ops {

273

int (*create) (struct sk_buff *skb, struct net_device *dev,

273

int (*create) (struct sk_buff *skb, struct net_device *dev,

274

unsigned short type, const void *daddr,

274

unsigned short type, const void *daddr,

275

const void *saddr, unsigned len);

275

const void *saddr, unsigned len);

276

int (*parse)(const struct sk_buff *skb, unsigned char *haddr);

276

int (*parse)(const struct sk_buff *skb, unsigned char *haddr);

277

int (*rebuild)(struct sk_buff *skb);

277

int (*rebuild)(struct sk_buff *skb);

278

#define HAVE_HEADER_CACHE

278

#define HAVE_HEADER_CACHE

279

int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);

279

int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);

280

void (*cache_update)(struct hh_cache *hh,

280

void (*cache_update)(struct hh_cache *hh,

281

const struct net_device *dev,

281

const struct net_device *dev,

282

const unsigned char *haddr);

282

const unsigned char *haddr);

283

};

283

};

284

285

/* These flag bits are private to the generic network queueing

285

/* These flag bits are private to the generic network queueing

286

* layer, they may not be explicitly referenced by any other

286

* layer, they may not be explicitly referenced by any other

287

* code.

287

* code.

288

*/

288

*/

289

290

enum netdev_state_t {

290

enum netdev_state_t {

291

__LINK_STATE_START,

291

__LINK_STATE_START,

292

__LINK_STATE_PRESENT,

292

__LINK_STATE_PRESENT,

293

__LINK_STATE_NOCARRIER,

293

__LINK_STATE_NOCARRIER,

294

__LINK_STATE_LINKWATCH_PENDING,

294

__LINK_STATE_LINKWATCH_PENDING,

295

__LINK_STATE_DORMANT,

295

__LINK_STATE_DORMANT,

296

};

296

};

297

298

299

/*

299

/*

300

* This structure holds at boot time configured netdevice settings. They

300

* This structure holds at boot time configured netdevice settings. They

301

* are then used in the device probing.

301

* are then used in the device probing.

302

*/

302

*/

303

struct netdev_boot_setup {

303

struct netdev_boot_setup {

304

char name[IFNAMSIZ];

304

char name[IFNAMSIZ];

305

struct ifmap map;

305

struct ifmap map;

306

};

306

};

307

#define NETDEV_BOOT_SETUP_MAX 8

307

#define NETDEV_BOOT_SETUP_MAX 8

308

309

extern int __init netdev_boot_setup(char *str);

309

extern int __init netdev_boot_setup(char *str);

310

311

/*

311

/*

312

* Structure for NAPI scheduling similar to tasklet but with weighting

312

* Structure for NAPI scheduling similar to tasklet but with weighting

313

*/

313

*/

314

struct napi_struct {

314

struct napi_struct {

315

/* The poll_list must only be managed by the entity which

315

/* The poll_list must only be managed by the entity which

316

* changes the state of the NAPI_STATE_SCHED bit. This means

316

* changes the state of the NAPI_STATE_SCHED bit. This means

317

* whoever atomically sets that bit can add this napi_struct

317

* whoever atomically sets that bit can add this napi_struct

318

* to the per-cpu poll_list, and whoever clears that bit

318

* to the per-cpu poll_list, and whoever clears that bit

319

* can remove from the list right before clearing the bit.

319

* can remove from the list right before clearing the bit.

320

*/

320

*/

321

struct list_head poll_list;

321

struct list_head poll_list;

322

323

unsigned long state;

323

unsigned long state;

324

int weight;

324

int weight;

325

int (*poll)(struct napi_struct *, int);

325

int (*poll)(struct napi_struct *, int);

326

#ifdef CONFIG_NETPOLL

326

#ifdef CONFIG_NETPOLL

327

spinlock_t poll_lock;

327

spinlock_t poll_lock;

328

int poll_owner;

328

int poll_owner;

329

#endif

329

#endif

330

331

unsigned int gro_count;

331

unsigned int gro_count;

332

333

struct net_device *dev;

333

struct net_device *dev;

334

struct list_head dev_list;

334

struct list_head dev_list;

335

struct sk_buff *gro_list;

335

struct sk_buff *gro_list;

336

struct sk_buff *skb;

336

struct sk_buff *skb;

337

};

337

};

338

339

enum {

339

enum {

340

NAPI_STATE_SCHED, /* Poll is scheduled */

340

NAPI_STATE_SCHED, /* Poll is scheduled */

341

NAPI_STATE_DISABLE, /* Disable pending */

341

NAPI_STATE_DISABLE, /* Disable pending */

342

NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */

342

NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */

343

};

343

};

344

345

enum gro_result {

345

enum gro_result {

346

GRO_MERGED,

346

GRO_MERGED,

347

GRO_MERGED_FREE,

347

GRO_MERGED_FREE,

348

GRO_HELD,

348

GRO_HELD,

349

GRO_NORMAL,

349

GRO_NORMAL,

350

GRO_DROP,

350

GRO_DROP,

351

};

351

};

352

typedef enum gro_result gro_result_t;

352

typedef enum gro_result gro_result_t;

353

354

extern void __napi_schedule(struct napi_struct *n);

354

extern void __napi_schedule(struct napi_struct *n);

355

356

static inline int napi_disable_pending(struct napi_struct *n)

356

static inline int napi_disable_pending(struct napi_struct *n)

357

{

357

{

358

return test_bit(NAPI_STATE_DISABLE, &n->state);

358

return test_bit(NAPI_STATE_DISABLE, &n->state);

359

}

359

}

360

361

/**

361

/**

362

* napi_schedule_prep - check if napi can be scheduled

362

* napi_schedule_prep - check if napi can be scheduled

363

* @n: napi context

363

* @n: napi context

364

*

364

*

365

* Test if NAPI routine is already running, and if not mark

365

* Test if NAPI routine is already running, and if not mark

366

* it as running. This is used as a condition variable

366

* it as running. This is used as a condition variable

367

* insure only one NAPI poll instance runs. We also make

367

* insure only one NAPI poll instance runs. We also make

368

* sure there is no pending NAPI disable.

368

* sure there is no pending NAPI disable.

369

*/

369

*/

370

static inline int napi_schedule_prep(struct napi_struct *n)

370

static inline int napi_schedule_prep(struct napi_struct *n)

371

{

371

{

372

return !napi_disable_pending(n) &&

372

return !napi_disable_pending(n) &&

373

!test_and_set_bit(NAPI_STATE_SCHED, &n->state);

373

!test_and_set_bit(NAPI_STATE_SCHED, &n->state);

374

}

374

}

375

376

/**

376

/**

377

* napi_schedule - schedule NAPI poll

377

* napi_schedule - schedule NAPI poll

378

* @n: napi context

378

* @n: napi context

379

*

379

*

380

* Schedule NAPI poll routine to be called if it is not already

380

* Schedule NAPI poll routine to be called if it is not already

381

* running.

381

* running.

382

*/

382

*/

383

static inline void napi_schedule(struct napi_struct *n)

383

static inline void napi_schedule(struct napi_struct *n)

384

{

384

{

385

if (napi_schedule_prep(n))

385

if (napi_schedule_prep(n))

386

__napi_schedule(n);

386

__napi_schedule(n);

387

}

387

}

388

389

/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */

389

/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */

390

static inline int napi_reschedule(struct napi_struct *napi)

390

static inline int napi_reschedule(struct napi_struct *napi)

391

{

391

{

392

if (napi_schedule_prep(napi)) {

392

if (napi_schedule_prep(napi)) {

393

__napi_schedule(napi);

393

__napi_schedule(napi);

394

return 1;

394

return 1;

395

}

395

}

396

return 0;

396

return 0;

397

}

397

}

398

399

/**

399

/**

400

* napi_complete - NAPI processing complete

400

* napi_complete - NAPI processing complete

401

* @n: napi context

401

* @n: napi context

402

*

402

*

403

* Mark NAPI processing as complete.

403

* Mark NAPI processing as complete.

404

*/

404

*/

405

extern void __napi_complete(struct napi_struct *n);

405

extern void __napi_complete(struct napi_struct *n);

406

extern void napi_complete(struct napi_struct *n);

406

extern void napi_complete(struct napi_struct *n);

407

408

/**

408

/**

409

* napi_disable - prevent NAPI from scheduling

409

* napi_disable - prevent NAPI from scheduling

410

* @n: napi context

410

* @n: napi context

411

*

411

*

412

* Stop NAPI from being scheduled on this context.

412

* Stop NAPI from being scheduled on this context.

413

* Waits till any outstanding processing completes.

413

* Waits till any outstanding processing completes.

414

*/

414

*/

415

static inline void napi_disable(struct napi_struct *n)

415

static inline void napi_disable(struct napi_struct *n)

416

{

416

{

417

set_bit(NAPI_STATE_DISABLE, &n->state);

417

set_bit(NAPI_STATE_DISABLE, &n->state);

418

while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))

418

while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))

419

msleep(1);

419

msleep(1);

420

clear_bit(NAPI_STATE_DISABLE, &n->state);

420

clear_bit(NAPI_STATE_DISABLE, &n->state);

421

}

421

}

422

423

/**

423

/**

424

* napi_enable - enable NAPI scheduling

424

* napi_enable - enable NAPI scheduling

425

* @n: napi context

425

* @n: napi context

426

*

426

*

427

* Resume NAPI from being scheduled on this context.

427

* Resume NAPI from being scheduled on this context.

428

* Must be paired with napi_disable.

428

* Must be paired with napi_disable.

429

*/

429

*/

430

static inline void napi_enable(struct napi_struct *n)

430

static inline void napi_enable(struct napi_struct *n)

431

{

431

{

432

BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));

432

BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));

433

smp_mb__before_clear_bit();

433

smp_mb__before_clear_bit();

434

clear_bit(NAPI_STATE_SCHED, &n->state);

434

clear_bit(NAPI_STATE_SCHED, &n->state);

435

}

435

}

436

437

#ifdef CONFIG_SMP

437

#ifdef CONFIG_SMP

438

/**

438

/**

439

* napi_synchronize - wait until NAPI is not running

439

* napi_synchronize - wait until NAPI is not running

440

* @n: napi context

440

* @n: napi context

441

*

441

*

442

* Wait until NAPI is done being scheduled on this context.

442

* Wait until NAPI is done being scheduled on this context.

443

* Waits till any outstanding processing completes but

443

* Waits till any outstanding processing completes but

444

* does not disable future activations.

444

* does not disable future activations.

445

*/

445

*/

446

static inline void napi_synchronize(const struct napi_struct *n)

446

static inline void napi_synchronize(const struct napi_struct *n)

447

{

447

{

448

while (test_bit(NAPI_STATE_SCHED, &n->state))

448

while (test_bit(NAPI_STATE_SCHED, &n->state))

449

msleep(1);

449

msleep(1);

450

}

450

}

451

#else

451

#else

452

# define napi_synchronize(n) barrier()

452

# define napi_synchronize(n) barrier()

453

#endif

453

#endif

454

455

enum netdev_queue_state_t {

455

enum netdev_queue_state_t {

456

__QUEUE_STATE_XOFF,

456

__QUEUE_STATE_XOFF,

457

__QUEUE_STATE_FROZEN,

457

__QUEUE_STATE_FROZEN,

458

};

458

};

459

460

struct netdev_queue {

460

struct netdev_queue {

461

/*

461

/*

462

* read mostly part

462

* read mostly part

463

*/

463

*/

464

struct net_device *dev;

464

struct net_device *dev;

465

struct Qdisc *qdisc;

465

struct Qdisc *qdisc;

466

unsigned long state;

466

unsigned long state;

467

struct Qdisc *qdisc_sleeping;

467

struct Qdisc *qdisc_sleeping;

468

/*

468

/*

469

* write mostly part

469

* write mostly part

470

*/

470

*/

471

spinlock_t _xmit_lock ____cacheline_aligned_in_smp;

471

spinlock_t _xmit_lock ____cacheline_aligned_in_smp;

472

int xmit_lock_owner;

472

int xmit_lock_owner;

473

/*

473

/*

474

* please use this field instead of dev->trans_start

474

* please use this field instead of dev->trans_start

475

*/

475

*/

476

unsigned long trans_start;

476

unsigned long trans_start;

477

unsigned long tx_bytes;

477

unsigned long tx_bytes;

478

unsigned long tx_packets;

478

unsigned long tx_packets;

479

unsigned long tx_dropped;

479

unsigned long tx_dropped;

480

} ____cacheline_aligned_in_smp;

480

} ____cacheline_aligned_in_smp;

481

482

483

/*

483

/*

484

* This structure defines the management hooks for network devices.

484

* This structure defines the management hooks for network devices.

485

* The following hooks can be defined; unless noted otherwise, they are

485

* The following hooks can be defined; unless noted otherwise, they are

486

* optional and can be filled with a null pointer.

486

* optional and can be filled with a null pointer.

487

*

487

*

488

* int (*ndo_init)(struct net_device *dev);

488

* int (*ndo_init)(struct net_device *dev);

489

* This function is called once when network device is registered.

489

* This function is called once when network device is registered.

490

* The network device can use this to any late stage initializaton

490

* The network device can use this to any late stage initializaton

491

* or semantic validattion. It can fail with an error code which will

491

* or semantic validattion. It can fail with an error code which will

492

* be propogated back to register_netdev

492

* be propogated back to register_netdev

493

*

493

*

494

* void (*ndo_uninit)(struct net_device *dev);

494

* void (*ndo_uninit)(struct net_device *dev);

495

* This function is called when device is unregistered or when registration

495

* This function is called when device is unregistered or when registration

496

* fails. It is not called if init fails.

496

* fails. It is not called if init fails.

497

*

497

*

498

* int (*ndo_open)(struct net_device *dev);

498

* int (*ndo_open)(struct net_device *dev);

499

* This function is called when network device transistions to the up

499

* This function is called when network device transistions to the up

500

* state.

500

* state.

501

*

501

*

502

* int (*ndo_stop)(struct net_device *dev);

502

* int (*ndo_stop)(struct net_device *dev);

503

* This function is called when network device transistions to the down

503

* This function is called when network device transistions to the down

504

* state.

504

* state.

505

*

505

*

506

* netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,

506

* netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,

507

* struct net_device *dev);

507

* struct net_device *dev);

508

* Called when a packet needs to be transmitted.

508

* Called when a packet needs to be transmitted.

509

* Must return NETDEV_TX_OK , NETDEV_TX_BUSY.

509

* Must return NETDEV_TX_OK , NETDEV_TX_BUSY.

510

* (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)

510

* (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)

511

* Required can not be NULL.

511

* Required can not be NULL.

512

*

512

*

513

* u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);

513

* u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);

514

* Called to decide which queue to when device supports multiple

514

* Called to decide which queue to when device supports multiple

515

* transmit queues.

515

* transmit queues.

516

*

516

*

517

* void (*ndo_change_rx_flags)(struct net_device *dev, int flags);

517

* void (*ndo_change_rx_flags)(struct net_device *dev, int flags);

518

* This function is called to allow device receiver to make

518

* This function is called to allow device receiver to make

519

* changes to configuration when multicast or promiscious is enabled.

519

* changes to configuration when multicast or promiscious is enabled.

520

*

520

*

521

* void (*ndo_set_rx_mode)(struct net_device *dev);

521

* void (*ndo_set_rx_mode)(struct net_device *dev);

522

* This function is called device changes address list filtering.

522

* This function is called device changes address list filtering.

523

*

523

*

524

* void (*ndo_set_multicast_list)(struct net_device *dev);

524

* void (*ndo_set_multicast_list)(struct net_device *dev);

525

* This function is called when the multicast address list changes.

525

* This function is called when the multicast address list changes.

526

*

526

*

527

* int (*ndo_set_mac_address)(struct net_device *dev, void *addr);

527

* int (*ndo_set_mac_address)(struct net_device *dev, void *addr);

528

* This function is called when the Media Access Control address

528

* This function is called when the Media Access Control address

529

* needs to be changed. If this interface is not defined, the

529

* needs to be changed. If this interface is not defined, the

530

* mac address can not be changed.

530

* mac address can not be changed.

531

*

531

*

532

* int (*ndo_validate_addr)(struct net_device *dev);

532

* int (*ndo_validate_addr)(struct net_device *dev);

533

* Test if Media Access Control address is valid for the device.

533

* Test if Media Access Control address is valid for the device.

534

*

534

*

535

* int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);

535

* int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);

536

* Called when a user request an ioctl which can't be handled by

536

* Called when a user request an ioctl which can't be handled by

537

* the generic interface code. If not defined ioctl's return

537

* the generic interface code. If not defined ioctl's return

538

* not supported error code.

538

* not supported error code.

539

*

539

*

540

* int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);

540

* int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);

541

* Used to set network devices bus interface parameters. This interface

541

* Used to set network devices bus interface parameters. This interface

542

* is retained for legacy reason, new devices should use the bus

542

* is retained for legacy reason, new devices should use the bus

543

* interface (PCI) for low level management.

543

* interface (PCI) for low level management.

544

*

544

*

545

* int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);

545

* int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);

546

* Called when a user wants to change the Maximum Transfer Unit

546

* Called when a user wants to change the Maximum Transfer Unit

547

* of a device. If not defined, any request to change MTU will

547

* of a device. If not defined, any request to change MTU will

548

* will return an error.

548

* will return an error.

549

*

549

*

550

* void (*ndo_tx_timeout)(struct net_device *dev);

550

* void (*ndo_tx_timeout)(struct net_device *dev);

551

* Callback uses when the transmitter has not made any progress

551

* Callback uses when the transmitter has not made any progress

552

* for dev->watchdog ticks.

552

* for dev->watchdog ticks.

553

*

553

*

554

* struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);

554

* struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);

555

* Called when a user wants to get the network device usage

555

* Called when a user wants to get the network device usage

556

* statistics. If not defined, the counters in dev->stats will

556

* statistics. If not defined, the counters in dev->stats will

557

* be used.

557

* be used.

558

*

558

*

559

* void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);

559

* void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);

560

* If device support VLAN receive accleration

560

* If device support VLAN receive accleration

561

* (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called

561

* (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called

562

* when vlan groups for the device changes. Note: grp is NULL

562

* when vlan groups for the device changes. Note: grp is NULL

563

* if no vlan's groups are being used.

563

* if no vlan's groups are being used.

564

*

564

*

565

* void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);

565

* void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);

566

* If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)

566

* If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)

567

* this function is called when a VLAN id is registered.

567

* this function is called when a VLAN id is registered.

568

*

568

*

569

* void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);

569

* void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);

570

* If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)

570

* If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)

571

* this function is called when a VLAN id is unregistered.

571

* this function is called when a VLAN id is unregistered.

572

*

572

*

573

* void (*ndo_poll_controller)(struct net_device *dev);

573

* void (*ndo_poll_controller)(struct net_device *dev);

574

*/

574

*/

575

#define HAVE_NET_DEVICE_OPS

575

#define HAVE_NET_DEVICE_OPS

576

struct net_device_ops {

576

struct net_device_ops {

577

int (*ndo_init)(struct net_device *dev);

577

int (*ndo_init)(struct net_device *dev);

578

void (*ndo_uninit)(struct net_device *dev);

578

void (*ndo_uninit)(struct net_device *dev);

579

int (*ndo_open)(struct net_device *dev);

579

int (*ndo_open)(struct net_device *dev);

580

int (*ndo_stop)(struct net_device *dev);

580

int (*ndo_stop)(struct net_device *dev);

581

netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,

581

netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,

582

struct net_device *dev);

582

struct net_device *dev);

583

u16 (*ndo_select_queue)(struct net_device *dev,

583

u16 (*ndo_select_queue)(struct net_device *dev,

584

struct sk_buff *skb);

584

struct sk_buff *skb);

585

#define HAVE_CHANGE_RX_FLAGS

585

#define HAVE_CHANGE_RX_FLAGS

586

void (*ndo_change_rx_flags)(struct net_device *dev,

586

void (*ndo_change_rx_flags)(struct net_device *dev,

587

int flags);

587

int flags);

588

#define HAVE_SET_RX_MODE

588

#define HAVE_SET_RX_MODE

589

void (*ndo_set_rx_mode)(struct net_device *dev);

589

void (*ndo_set_rx_mode)(struct net_device *dev);

590

#define HAVE_MULTICAST

590

#define HAVE_MULTICAST

591

void (*ndo_set_multicast_list)(struct net_device *dev);

591

void (*ndo_set_multicast_list)(struct net_device *dev);

592

#define HAVE_SET_MAC_ADDR

592

#define HAVE_SET_MAC_ADDR

593

int (*ndo_set_mac_address)(struct net_device *dev,

593

int (*ndo_set_mac_address)(struct net_device *dev,

594

void *addr);

594

void *addr);

595

#define HAVE_VALIDATE_ADDR

595

#define HAVE_VALIDATE_ADDR

596

int (*ndo_validate_addr)(struct net_device *dev);

596

int (*ndo_validate_addr)(struct net_device *dev);

597

#define HAVE_PRIVATE_IOCTL

597

#define HAVE_PRIVATE_IOCTL

598

int (*ndo_do_ioctl)(struct net_device *dev,

598

int (*ndo_do_ioctl)(struct net_device *dev,

599

struct ifreq *ifr, int cmd);

599

struct ifreq *ifr, int cmd);

600

#define HAVE_SET_CONFIG

600

#define HAVE_SET_CONFIG

601

int (*ndo_set_config)(struct net_device *dev,

601

int (*ndo_set_config)(struct net_device *dev,

602

struct ifmap *map);

602

struct ifmap *map);

603

#define HAVE_CHANGE_MTU

603

#define HAVE_CHANGE_MTU

604

int (*ndo_change_mtu)(struct net_device *dev,

604

int (*ndo_change_mtu)(struct net_device *dev,

605

int new_mtu);

605

int new_mtu);

606

int (*ndo_neigh_setup)(struct net_device *dev,

606

int (*ndo_neigh_setup)(struct net_device *dev,

607

struct neigh_parms *);

607

struct neigh_parms *);

608

#define HAVE_TX_TIMEOUT

608

#define HAVE_TX_TIMEOUT

609

void (*ndo_tx_timeout) (struct net_device *dev);

609

void (*ndo_tx_timeout) (struct net_device *dev);

610

611

struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);

611

struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);

612

613

void (*ndo_vlan_rx_register)(struct net_device *dev,

613

void (*ndo_vlan_rx_register)(struct net_device *dev,

614

struct vlan_group *grp);

614

struct vlan_group *grp);

615

void (*ndo_vlan_rx_add_vid)(struct net_device *dev,

615

void (*ndo_vlan_rx_add_vid)(struct net_device *dev,

616

unsigned short vid);

616

unsigned short vid);

617

void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,

617

void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,

618

unsigned short vid);

618

unsigned short vid);

619

#ifdef CONFIG_NET_POLL_CONTROLLER

619

#ifdef CONFIG_NET_POLL_CONTROLLER

620

#define HAVE_NETDEV_POLL

620

#define HAVE_NETDEV_POLL

621

void (*ndo_poll_controller)(struct net_device *dev);

621

void (*ndo_poll_controller)(struct net_device *dev);

622

#endif

622

#endif

623

#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)

623

#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)

624

int (*ndo_fcoe_enable)(struct net_device *dev);

624

int (*ndo_fcoe_enable)(struct net_device *dev);

625

int (*ndo_fcoe_disable)(struct net_device *dev);

625

int (*ndo_fcoe_disable)(struct net_device *dev);

626

int (*ndo_fcoe_ddp_setup)(struct net_device *dev,

626

int (*ndo_fcoe_ddp_setup)(struct net_device *dev,

627

u16 xid,

627

u16 xid,

628

struct scatterlist *sgl,

628

struct scatterlist *sgl,

629

unsigned int sgc);

629

unsigned int sgc);

630

int (*ndo_fcoe_ddp_done)(struct net_device *dev,

630

int (*ndo_fcoe_ddp_done)(struct net_device *dev,

631

u16 xid);

631

u16 xid);

632

#define NETDEV_FCOE_WWNN 0

632

#define NETDEV_FCOE_WWNN 0

633

#define NETDEV_FCOE_WWPN 1

633

#define NETDEV_FCOE_WWPN 1

634

int (*ndo_fcoe_get_wwn)(struct net_device *dev,

634

int (*ndo_fcoe_get_wwn)(struct net_device *dev,

635

u64 *wwn, int type);

635

u64 *wwn, int type);

636

#endif

636

#endif

637

};

637

};

638

639

/*

639

/*

640

* The DEVICE structure.

640

* The DEVICE structure.

641

* Actually, this whole structure is a big mistake. It mixes I/O

641

* Actually, this whole structure is a big mistake. It mixes I/O

642

* data with strictly "high-level" data, and it has to know about

642

* data with strictly "high-level" data, and it has to know about

643

* almost every data structure used in the INET module.

643

* almost every data structure used in the INET module.

644

*

644

*

645

* FIXME: cleanup struct net_device such that network protocol info

645

* FIXME: cleanup struct net_device such that network protocol info

646

* moves out.

646

* moves out.

647

*/

647

*/

648

649

struct net_device {

649

struct net_device {

650

651

/*

651

/*

652

* This is the first field of the "visible" part of this structure

652

* This is the first field of the "visible" part of this structure

653

* (i.e. as seen by users in the "Space.c" file). It is the name

653

* (i.e. as seen by users in the "Space.c" file). It is the name

654

* the interface.

654

* the interface.

655

*/

655

*/

656

char name[IFNAMSIZ];

656

char name[IFNAMSIZ];

657

/* device name hash chain */

657

/* device name hash chain */

658

struct hlist_node name_hlist;

658

struct hlist_node name_hlist;

659

/* snmp alias */

659

/* snmp alias */

660

char *ifalias;

660

char *ifalias;

661

662

/*

662

/*

663

* I/O specific fields

663

* I/O specific fields

664

* FIXME: Merge these and struct ifmap into one

664

* FIXME: Merge these and struct ifmap into one

665

*/

665

*/

666

unsigned long mem_end; /* shared mem end */

666

unsigned long mem_end; /* shared mem end */

667

unsigned long mem_start; /* shared mem start */

667

unsigned long mem_start; /* shared mem start */

668

unsigned long base_addr; /* device I/O address */

668

unsigned long base_addr; /* device I/O address */

669

unsigned int irq; /* device IRQ number */

669

unsigned int irq; /* device IRQ number */

670

671

/*

671

/*

672

* Some hardware also needs these fields, but they are not

672

* Some hardware also needs these fields, but they are not

673

* part of the usual set specified in Space.c.

673

* part of the usual set specified in Space.c.

674

*/

674

*/

675

676

unsigned char if_port; /* Selectable AUI, TP,..*/

676

unsigned char if_port; /* Selectable AUI, TP,..*/

677

unsigned char dma; /* DMA channel */

677

unsigned char dma; /* DMA channel */

678

679

unsigned long state;

679

unsigned long state;

680

681

struct list_head dev_list;

681

struct list_head dev_list;

682

struct list_head napi_list;

682

struct list_head napi_list;

683

struct list_head unreg_list;

683

struct list_head unreg_list;

684

685

/* Net device features */

685

/* Net device features */

686

unsigned long features;

686

unsigned long features;

687

#define NETIF_F_SG 1 /* Scatter/gather IO. */

687

#define NETIF_F_SG 1 /* Scatter/gather IO. */

688

#define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */

688

#define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */

689

#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */

689

#define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */

690

#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */

690

#define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */

691

#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */

691

#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */

692

#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */

692

#define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */

693

#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */

693

#define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */

694

#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */

694

#define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */

695

#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */

695

#define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */

696

#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */

696

#define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */

697

#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */

697

#define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */

698

#define NETIF_F_GSO 2048 /* Enable software GSO. */

698

#define NETIF_F_GSO 2048 /* Enable software GSO. */

699

#define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */

699

#define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */

700

/* do not use LLTX in new drivers */

700

/* do not use LLTX in new drivers */

701

#define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */

701

#define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */

702

#define NETIF_F_GRO 16384 /* Generic receive offload */

702

#define NETIF_F_GRO 16384 /* Generic receive offload */

703

#define NETIF_F_LRO 32768 /* large receive offload */

703

#define NETIF_F_LRO 32768 /* large receive offload */

704

705

/* the GSO_MASK reserves bits 16 through 23 */

705

/* the GSO_MASK reserves bits 16 through 23 */

706

#define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */

706

#define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */

707

#define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */

707

#define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */

708

#define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/

708

#define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/

709

710

/* Segmentation offload features */

710

/* Segmentation offload features */

711

#define NETIF_F_GSO_SHIFT 16

711

#define NETIF_F_GSO_SHIFT 16

712

#define NETIF_F_GSO_MASK 0x00ff0000

712

#define NETIF_F_GSO_MASK 0x00ff0000

713

#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)

713

#define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)

714

#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)

714

#define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)

715

#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)

715

#define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)

716

#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)

716

#define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)

717

#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)

717

#define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)

718

#define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)

718

#define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)

719

720

/* List of features with software fallbacks. */

720

/* List of features with software fallbacks. */

721

#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)

721

#define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)

722

723

724

#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)

724

#define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)

725

#define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)

725

#define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)

726

#define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)

726

#define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)

727

#define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)

727

#define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)

728

729

/*

729

/*

730

* If one device supports one of these features, then enable them

730

* If one device supports one of these features, then enable them

731

* for all in netdev_increment_features.

731

* for all in netdev_increment_features.

732

*/

732

*/

733

#define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \

733

#define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \

734

NETIF_F_SG | NETIF_F_HIGHDMA | \

734

NETIF_F_SG | NETIF_F_HIGHDMA | \

735

NETIF_F_FRAGLIST)

735

NETIF_F_FRAGLIST)

736

737

/* Interface index. Unique device identifier */

737

/* Interface index. Unique device identifier */

738

int ifindex;

738

int ifindex;

739

int iflink;

739

int iflink;

740

741

struct net_device_stats stats;

741

struct net_device_stats stats;

742

743

#ifdef CONFIG_WIRELESS_EXT

743

#ifdef CONFIG_WIRELESS_EXT

744

/* List of functions to handle Wireless Extensions (instead of ioctl).

744

/* List of functions to handle Wireless Extensions (instead of ioctl).

745

* See <net/iw_handler.h> for details. Jean II */

745

* See <net/iw_handler.h> for details. Jean II */

746

const struct iw_handler_def * wireless_handlers;

746

const struct iw_handler_def * wireless_handlers;

747

/* Instance data managed by the core of Wireless Extensions. */

747

/* Instance data managed by the core of Wireless Extensions. */

748

struct iw_public_data * wireless_data;

748

struct iw_public_data * wireless_data;

749

#endif

749

#endif

750

/* Management operations */

750

/* Management operations */

751

const struct net_device_ops *netdev_ops;

751

const struct net_device_ops *netdev_ops;

752

const struct ethtool_ops *ethtool_ops;

752

const struct ethtool_ops *ethtool_ops;

753

754

/* Hardware header description */

754

/* Hardware header description */

755

const struct header_ops *header_ops;

755

const struct header_ops *header_ops;

756

757

unsigned int flags; /* interface flags (a la BSD) */

757

unsigned int flags; /* interface flags (a la BSD) */

758

unsigned short gflags;

758

unsigned short gflags;

759

unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */

759

unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */

760

unsigned short padded; /* How much padding added by alloc_netdev() */

760

unsigned short padded; /* How much padding added by alloc_netdev() */

761

762

unsigned char operstate; /* RFC2863 operstate */

762

unsigned char operstate; /* RFC2863 operstate */

763

unsigned char link_mode; /* mapping policy to operstate */

763

unsigned char link_mode; /* mapping policy to operstate */

764

765

unsigned mtu; /* interface MTU value */

765

unsigned mtu; /* interface MTU value */

766

unsigned short type; /* interface hardware type */

766

unsigned short type; /* interface hardware type */

767

unsigned short hard_header_len; /* hardware hdr length */

767

unsigned short hard_header_len; /* hardware hdr length */

768

769

/* extra head- and tailroom the hardware may need, but not in all cases

769

/* extra head- and tailroom the hardware may need, but not in all cases

770

* can this be guaranteed, especially tailroom. Some cases also use

770

* can this be guaranteed, especially tailroom. Some cases also use

771

* LL_MAX_HEADER instead to allocate the skb.

771

* LL_MAX_HEADER instead to allocate the skb.

772

*/

772

*/

773

unsigned short needed_headroom;

773

unsigned short needed_headroom;

774

unsigned short needed_tailroom;

774

unsigned short needed_tailroom;

775

776

struct net_device *master; /* Pointer to master device of a group,

776

struct net_device *master; /* Pointer to master device of a group,

777

* which this device is member of.

777

* which this device is member of.

778

*/

778

*/

779

780

/* Interface address info. */

780

/* Interface address info. */

781

unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */

781

unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */

782

unsigned char addr_len; /* hardware address length */

782

unsigned char addr_len; /* hardware address length */

783

unsigned short dev_id; /* for shared network cards */

783

unsigned short dev_id; /* for shared network cards */

784

785

struct netdev_hw_addr_list uc; /* Secondary unicast

785

struct netdev_hw_addr_list uc; /* Secondary unicast

786

mac addresses */

786

mac addresses */

787

int uc_promisc;

787

int uc_promisc;

788

spinlock_t addr_list_lock;

788

spinlock_t addr_list_lock;

789

struct dev_addr_list *mc_list; /* Multicast mac addresses */

789

struct dev_addr_list *mc_list; /* Multicast mac addresses */

790

int mc_count; /* Number of installed mcasts */

790

int mc_count; /* Number of installed mcasts */

791

unsigned int promiscuity;

791

unsigned int promiscuity;

792

unsigned int allmulti;

792

unsigned int allmulti;

793

794

795

/* Protocol specific pointers */

795

/* Protocol specific pointers */

796

797

#ifdef CONFIG_NET_DSA

797

#ifdef CONFIG_NET_DSA

798

void *dsa_ptr; /* dsa specific data */

798

void *dsa_ptr; /* dsa specific data */

799

#endif

799

#endif

800

void *atalk_ptr; /* AppleTalk link */

800

void *atalk_ptr; /* AppleTalk link */

801

void *ip_ptr; /* IPv4 specific data */

801

void *ip_ptr; /* IPv4 specific data */

802

void *dn_ptr; /* DECnet specific data */

802

void *dn_ptr; /* DECnet specific data */

803

void *ip6_ptr; /* IPv6 specific data */

803

void *ip6_ptr; /* IPv6 specific data */

804

void *ec_ptr; /* Econet specific data */

804

void *ec_ptr; /* Econet specific data */

805

void *ax25_ptr; /* AX.25 specific data */

805

void *ax25_ptr; /* AX.25 specific data */

806

struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,

806

struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,

807

assign before registering */

807

assign before registering */

808

809

/*

809

/*

810

* Cache line mostly used on receive path (including eth_type_trans())

810

* Cache line mostly used on receive path (including eth_type_trans())

811

*/

811

*/

812

unsigned long last_rx; /* Time of last Rx */

812

unsigned long last_rx; /* Time of last Rx */

813

/* Interface address info used in eth_type_trans() */

813

/* Interface address info used in eth_type_trans() */

814

unsigned char *dev_addr; /* hw address, (before bcast

814

unsigned char *dev_addr; /* hw address, (before bcast

815

because most packets are

815

because most packets are

816

unicast) */

816

unicast) */

817

818

struct netdev_hw_addr_list dev_addrs; /* list of device

818

struct netdev_hw_addr_list dev_addrs; /* list of device

819

hw addresses */

819

hw addresses */

820

821

unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */

821

unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */

822

823

struct netdev_queue rx_queue;

823

struct netdev_queue rx_queue;

824

825

struct netdev_queue *_tx ____cacheline_aligned_in_smp;

825

struct netdev_queue *_tx ____cacheline_aligned_in_smp;

826

827

/* Number of TX queues allocated at alloc_netdev_mq() time */

827

/* Number of TX queues allocated at alloc_netdev_mq() time */

828

unsigned int num_tx_queues;

828

unsigned int num_tx_queues;

829

830

/* Number of TX queues currently active in device */

830

/* Number of TX queues currently active in device */

831

unsigned int real_num_tx_queues;

831

unsigned int real_num_tx_queues;

832

833

/* root qdisc from userspace point of view */

833

/* root qdisc from userspace point of view */

834

struct Qdisc *qdisc;

834

struct Qdisc *qdisc;

835

836

unsigned long tx_queue_len; /* Max frames per queue allowed */

836

unsigned long tx_queue_len; /* Max frames per queue allowed */

837

spinlock_t tx_global_lock;

837

spinlock_t tx_global_lock;

838

/*

838

/*

839

* One part is mostly used on xmit path (device)

839

* One part is mostly used on xmit path (device)

840

*/

840

*/

841

/* These may be needed for future network-power-down code. */

841

/* These may be needed for future network-power-down code. */

842

843

/*

843

/*

844

* trans_start here is expensive for high speed devices on SMP,

844

* trans_start here is expensive for high speed devices on SMP,

845

* please use netdev_queue->trans_start instead.

845

* please use netdev_queue->trans_start instead.

846

*/

846

*/

847

unsigned long trans_start; /* Time (in jiffies) of last Tx */

847

unsigned long trans_start; /* Time (in jiffies) of last Tx */

848

849

int watchdog_timeo; /* used by dev_watchdog() */

849

int watchdog_timeo; /* used by dev_watchdog() */

850

struct timer_list watchdog_timer;

850

struct timer_list watchdog_timer;

851

852

/* Number of references to this device */

852

/* Number of references to this device */

853

atomic_t refcnt ____cacheline_aligned_in_smp;

853

atomic_t refcnt ____cacheline_aligned_in_smp;

854

855

/* delayed register/unregister */

855

/* delayed register/unregister */

856

struct list_head todo_list;

856

struct list_head todo_list;

857

/* device index hash chain */

857

/* device index hash chain */

858

struct hlist_node index_hlist;

858

struct hlist_node index_hlist;

859

860

struct net_device *link_watch_next;

860

struct net_device *link_watch_next;

861

862

/* register/unregister state machine */

862

/* register/unregister state machine */

863

enum { NETREG_UNINITIALIZED=0,

863

enum { NETREG_UNINITIALIZED=0,

864

NETREG_REGISTERED, /* completed register_netdevice */

864

NETREG_REGISTERED, /* completed register_netdevice */

865

NETREG_UNREGISTERING, /* called unregister_netdevice */

865

NETREG_UNREGISTERING, /* called unregister_netdevice */

866

NETREG_UNREGISTERED, /* completed unregister todo */

866

NETREG_UNREGISTERED, /* completed unregister todo */

867

NETREG_RELEASED, /* called free_netdev */

867

NETREG_RELEASED, /* called free_netdev */

868

NETREG_DUMMY, /* dummy device for NAPI poll */

868

NETREG_DUMMY, /* dummy device for NAPI poll */

869

} reg_state;

869

} reg_state;

870

871

/* Called from unregister, can be used to call free_netdev */

871

/* Called from unregister, can be used to call free_netdev */

872

void (*destructor)(struct net_device *dev);

872

void (*destructor)(struct net_device *dev);

873

874

#ifdef CONFIG_NETPOLL

874

#ifdef CONFIG_NETPOLL

875

struct netpoll_info *npinfo;

875

struct netpoll_info *npinfo;

876

#endif

876

#endif

877

878

#ifdef CONFIG_NET_NS

878

#ifdef CONFIG_NET_NS

879

/* Network namespace this network device is inside */

879

/* Network namespace this network device is inside */

880

struct net *nd_net;

880

struct net *nd_net;

881

#endif

881

#endif

882

883

/* mid-layer private */

883

/* mid-layer private */

884

void *ml_priv;

884

void *ml_priv;

885

886

/* bridge stuff */

886

/* bridge stuff */

887

struct net_bridge_port *br_port;

887

struct net_bridge_port *br_port;

888

/* macvlan */

888

/* macvlan */

889

struct macvlan_port *macvlan_port;

889

struct macvlan_port *macvlan_port;

890

/* GARP */

890

/* GARP */

891

struct garp_port *garp_port;

891

struct garp_port *garp_port;

892

893

/* class/net/name entry */

893

/* class/net/name entry */

894

struct device dev;

894

struct device dev;

895

/* space for optional device, statistics, and wireless sysfs groups */

895

/* space for optional device, statistics, and wireless sysfs groups */

896

const struct attribute_group *sysfs_groups[4];

896

const struct attribute_group *sysfs_groups[4];

897

898

/* rtnetlink link ops */

898

/* rtnetlink link ops */

899

const struct rtnl_link_ops *rtnl_link_ops;

899

const struct rtnl_link_ops *rtnl_link_ops;

900

901

/* VLAN feature mask */

901

/* VLAN feature mask */

902

unsigned long vlan_features;

902

unsigned long vlan_features;

903

904

/* for setting kernel sock attribute on TCP connection setup */

904

/* for setting kernel sock attribute on TCP connection setup */

905

#define GSO_MAX_SIZE 65536

905

#define GSO_MAX_SIZE 65536

906

unsigned int gso_max_size;

906

unsigned int gso_max_size;

907

908

#ifdef CONFIG_DCB

908

#ifdef CONFIG_DCB

909

/* Data Center Bridging netlink ops */

909

/* Data Center Bridging netlink ops */

910

const struct dcbnl_rtnl_ops *dcbnl_ops;

910

const struct dcbnl_rtnl_ops *dcbnl_ops;

911

#endif

911

#endif

912

913

#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)

913

#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)

914

/* max exchange id for FCoE LRO by ddp */

914

/* max exchange id for FCoE LRO by ddp */

915

unsigned int fcoe_ddp_xid;

915

unsigned int fcoe_ddp_xid;

916

#endif

916

#endif

917

};

917

};

918

#define to_net_dev(d) container_of(d, struct net_device, dev)

918

#define to_net_dev(d) container_of(d, struct net_device, dev)

919

920

#define NETDEV_ALIGN 32

920

#define NETDEV_ALIGN 32

921

922

static inline

922

static inline

923

struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,

923

struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,

924

unsigned int index)

924

unsigned int index)

925

{

925

{

926

return &dev->_tx[index];

926

return &dev->_tx[index];

927

}

927

}

928

929

static inline void netdev_for_each_tx_queue(struct net_device *dev,

929

static inline void netdev_for_each_tx_queue(struct net_device *dev,

930

void (*f)(struct net_device *,

930

void (*f)(struct net_device *,

931

struct netdev_queue *,

931

struct netdev_queue *,

932

void *),

932

void *),

933

void *arg)

933

void *arg)

934

{

934

{

935

unsigned int i;

935

unsigned int i;

936

937

for (i = 0; i < dev->num_tx_queues; i++)

937

for (i = 0; i < dev->num_tx_queues; i++)

938

f(dev, &dev->_tx[i], arg);

938

f(dev, &dev->_tx[i], arg);

939

}

939

}

940

941

/*

941

/*

942

* Net namespace inlines

942

* Net namespace inlines

943

*/

943

*/

944

static inline

944

static inline

945

struct net *dev_net(const struct net_device *dev)

945

struct net *dev_net(const struct net_device *dev)

946

{

946

{

947

#ifdef CONFIG_NET_NS

947

#ifdef CONFIG_NET_NS

948

return dev->nd_net;

948

return dev->nd_net;

949

#else

949

#else

950

return &init_net;

950

return &init_net;

951

#endif

951

#endif

952

}

952

}

953

954

static inline

954

static inline

955

void dev_net_set(struct net_device *dev, struct net *net)

955

void dev_net_set(struct net_device *dev, struct net *net)

956

{

956

{

957

#ifdef CONFIG_NET_NS

957

#ifdef CONFIG_NET_NS

958

release_net(dev->nd_net);

958

release_net(dev->nd_net);

959

dev->nd_net = hold_net(net);

959

dev->nd_net = hold_net(net);

960

#endif

960

#endif

961

}

961

}

962

963

static inline bool netdev_uses_dsa_tags(struct net_device *dev)

963

static inline bool netdev_uses_dsa_tags(struct net_device *dev)

964

{

964

{

965

#ifdef CONFIG_NET_DSA_TAG_DSA

965

#ifdef CONFIG_NET_DSA_TAG_DSA

966

if (dev->dsa_ptr != NULL)

966

if (dev->dsa_ptr != NULL)

967

return dsa_uses_dsa_tags(dev->dsa_ptr);

967

return dsa_uses_dsa_tags(dev->dsa_ptr);

968

#endif

968

#endif

969

970

return 0;

970

return 0;

971

}

971

}

972

973

static inline bool netdev_uses_trailer_tags(struct net_device *dev)

973

static inline bool netdev_uses_trailer_tags(struct net_device *dev)

974

{

974

{

975

#ifdef CONFIG_NET_DSA_TAG_TRAILER

975

#ifdef CONFIG_NET_DSA_TAG_TRAILER

976

if (dev->dsa_ptr != NULL)

976

if (dev->dsa_ptr != NULL)

977

return dsa_uses_trailer_tags(dev->dsa_ptr);

977

return dsa_uses_trailer_tags(dev->dsa_ptr);

978

#endif

978

#endif

979

980

return 0;

980

return 0;

981

}

981

}

982

983

/**

983

/**

984

* netdev_priv - access network device private data

984

* netdev_priv - access network device private data

985

* @dev: network device

985

* @dev: network device

986

*

986

*

987

* Get network device private data

987

* Get network device private data

988

*/

988

*/

989

static inline void *netdev_priv(const struct net_device *dev)

989

static inline void *netdev_priv(const struct net_device *dev)

990

{

990

{

991

return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);

991

return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);

992

}

992

}

993

994

/* Set the sysfs physical device reference for the network logical device

994

/* Set the sysfs physical device reference for the network logical device

995

* if set prior to registration will cause a symlink during initialization.

995

* if set prior to registration will cause a symlink during initialization.

996

*/

996

*/

997

#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))

997

#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))

998

999

/* Set the sysfs device type for the network logical device to allow

999

/* Set the sysfs device type for the network logical device to allow

1000

* fin grained indentification of different network device types. For

1000

* fin grained indentification of different network device types. For

1001

* example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.

1001

* example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.

1002

*/

1002

*/

1003

#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))

1003

#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))

1004

1005

/**

1005

/**

1006

* netif_napi_add - initialize a napi context

1006

* netif_napi_add - initialize a napi context

1007

* @dev: network device

1007

* @dev: network device

1008

* @napi: napi context

1008

* @napi: napi context

1009

* @poll: polling function

1009

* @poll: polling function

1010

* @weight: default weight

1010

* @weight: default weight

1011

*

1011

*

1012

* netif_napi_add() must be used to initialize a napi context prior to calling

1012

* netif_napi_add() must be used to initialize a napi context prior to calling

1013

* *any* of the other napi related functions.

1013

* *any* of the other napi related functions.

1014

*/

1014

*/

1015

void netif_napi_add(struct net_device *dev, struct napi_struct *napi,

1015

void netif_napi_add(struct net_device *dev, struct napi_struct *napi,

1016

int (*poll)(struct napi_struct *, int), int weight);

1016

int (*poll)(struct napi_struct *, int), int weight);

1017

1018

/**

1018

/**

1019

* netif_napi_del - remove a napi context

1019

* netif_napi_del - remove a napi context

1020

* @napi: napi context

1020

* @napi: napi context

1021

*

1021

*

1022

* netif_napi_del() removes a napi context from the network device napi list

1022

* netif_napi_del() removes a napi context from the network device napi list

1023

*/

1023

*/

1024

void netif_napi_del(struct napi_struct *napi);

1024

void netif_napi_del(struct napi_struct *napi);

1025

1026

struct napi_gro_cb {

1026

struct napi_gro_cb {

1027

/* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */

1027

/* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */

1028

void *frag0;

1028

void *frag0;

1029

1030

/* Length of frag0. */

1030

/* Length of frag0. */

1031

unsigned int frag0_len;

1031

unsigned int frag0_len;

1032

1033

/* This indicates where we are processing relative to skb->data. */

1033

/* This indicates where we are processing relative to skb->data. */

1034

int data_offset;

1034

int data_offset;

1035

1036

/* This is non-zero if the packet may be of the same flow. */

1036

/* This is non-zero if the packet may be of the same flow. */

1037

int same_flow;

1037

int same_flow;

1038

1039

/* This is non-zero if the packet cannot be merged with the new skb. */

1039

/* This is non-zero if the packet cannot be merged with the new skb. */

1040

int flush;

1040

int flush;

1041

1042

/* Number of segments aggregated. */

1042

/* Number of segments aggregated. */

1043

int count;

1043

int count;

1044

1045

/* Free the skb? */

1045

/* Free the skb? */

1046

int free;

1046

int free;

1047

};

1047

};

1048

1049

#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)

1049

#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)

1050

1051

struct packet_type {

1051

struct packet_type {

1052

__be16 type; /* This is really htons(ether_type). */

1052

__be16 type; /* This is really htons(ether_type). */

1053

struct net_device *dev; /* NULL is wildcarded here */

1053

struct net_device *dev; /* NULL is wildcarded here */

1054

int (*func) (struct sk_buff *,

1054

int (*func) (struct sk_buff *,

1055

struct net_device *,

1055

struct net_device *,

1056

struct packet_type *,

1056

struct packet_type *,

1057

struct net_device *);

1057

struct net_device *);

1058

struct sk_buff *(*gso_segment)(struct sk_buff *skb,

1058

struct sk_buff *(*gso_segment)(struct sk_buff *skb,

1059

int features);

1059

int features);

1060

int (*gso_send_check)(struct sk_buff *skb);

1060

int (*gso_send_check)(struct sk_buff *skb);

1061

struct sk_buff **(*gro_receive)(struct sk_buff **head,

1061

struct sk_buff **(*gro_receive)(struct sk_buff **head,

1062

struct sk_buff *skb);

1062

struct sk_buff *skb);

1063

int (*gro_complete)(struct sk_buff *skb);

1063

int (*gro_complete)(struct sk_buff *skb);

1064

void *af_packet_priv;

1064

void *af_packet_priv;

1065

struct list_head list;

1065

struct list_head list;

1066

};

1066

};

1067

1068

#include <linux/interrupt.h>

1068

#include <linux/interrupt.h>

1069

#include <linux/notifier.h>

1069

#include <linux/notifier.h>

1070

1071

extern rwlock_t dev_base_lock; /* Device list lock */

1071

extern rwlock_t dev_base_lock; /* Device list lock */

1072

1073

1074

#define for_each_netdev(net, d) \

1074

#define for_each_netdev(net, d) \

1075

list_for_each_entry(d, &(net)->dev_base_head, dev_list)

1075

list_for_each_entry(d, &(net)->dev_base_head, dev_list)

1076

#define for_each_netdev_rcu(net, d) \

1076

#define for_each_netdev_rcu(net, d) \

1077

list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)

1077

list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)

1078

#define for_each_netdev_safe(net, d, n) \

1078

#define for_each_netdev_safe(net, d, n) \

1079

list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)

1079

list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)

1080

#define for_each_netdev_continue(net, d) \

1080

#define for_each_netdev_continue(net, d) \

1081

list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)

1081

list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)

1082

#define for_each_netdev_continue_rcu(net, d) \

1083

list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)

1082

#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)

1084

#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)

1083

1085

1084

static inline struct net_device *next_net_device(struct net_device *dev)

1086

static inline struct net_device *next_net_device(struct net_device *dev)

1085

{

1087

{

1086

struct list_head *lh;

1088

struct list_head *lh;

1087

struct net *net;

1089

struct net *net;

1088

1090

1089

net = dev_net(dev);

1091

net = dev_net(dev);

1090

lh = dev->dev_list.next;

1092

lh = dev->dev_list.next;

1091

return lh == &net->dev_base_head ? NULL : net_device_entry(lh);

1093

return lh == &net->dev_base_head ? NULL : net_device_entry(lh);

1092

}

1094

}

1093

1095

1094

static inline struct net_device *first_net_device(struct net *net)

1096

static inline struct net_device *first_net_device(struct net *net)

1095

{

1097

{

1096

return list_empty(&net->dev_base_head) ? NULL :

1098

return list_empty(&net->dev_base_head) ? NULL :

1097

net_device_entry(net->dev_base_head.next);

1099

net_device_entry(net->dev_base_head.next);

1098

}

1100

}

1099

1101

1100

extern int netdev_boot_setup_check(struct net_device *dev);

1102

extern int netdev_boot_setup_check(struct net_device *dev);

1101

extern unsigned long netdev_boot_base(const char *prefix, int unit);

1103

extern unsigned long netdev_boot_base(const char *prefix, int unit);

1102

extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);

1104

extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);

1103

extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);

1105

extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);

1104

extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);

1106

extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);

1105

extern void dev_add_pack(struct packet_type *pt);

1107

extern void dev_add_pack(struct packet_type *pt);

1106

extern void dev_remove_pack(struct packet_type *pt);

1108

extern void dev_remove_pack(struct packet_type *pt);

1107

extern void __dev_remove_pack(struct packet_type *pt);

1109

extern void __dev_remove_pack(struct packet_type *pt);

1108

1110

1109

extern struct net_device *dev_get_by_flags(struct net *net, unsigned short flags,

1111

extern struct net_device *dev_get_by_flags(struct net *net, unsigned short flags,

1110

unsigned short mask);

1112

unsigned short mask);

1111

extern struct net_device *dev_get_by_name(struct net *net, const char *name);

1113

extern struct net_device *dev_get_by_name(struct net *net, const char *name);

1112

extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);

1114

extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);

1113

extern struct net_device *__dev_get_by_name(struct net *net, const char *name);

1115

extern struct net_device *__dev_get_by_name(struct net *net, const char *name);

1114

extern int dev_alloc_name(struct net_device *dev, const char *name);

1116

extern int dev_alloc_name(struct net_device *dev, const char *name);

1115

extern int dev_open(struct net_device *dev);

1117

extern int dev_open(struct net_device *dev);

1116

extern int dev_close(struct net_device *dev);

1118

extern int dev_close(struct net_device *dev);

1117

extern void dev_disable_lro(struct net_device *dev);

1119

extern void dev_disable_lro(struct net_device *dev);

1118

extern int dev_queue_xmit(struct sk_buff *skb);

1120

extern int dev_queue_xmit(struct sk_buff *skb);

1119

extern int register_netdevice(struct net_device *dev);

1121

extern int register_netdevice(struct net_device *dev);

1120

extern void unregister_netdevice_queue(struct net_device *dev,

1122

extern void unregister_netdevice_queue(struct net_device *dev,

1121

struct list_head *head);

1123

struct list_head *head);

1122

extern void unregister_netdevice_many(struct list_head *head);

1124

extern void unregister_netdevice_many(struct list_head *head);

1123

static inline void unregister_netdevice(struct net_device *dev)

1125

static inline void unregister_netdevice(struct net_device *dev)

1124

{

1126

{

1125

unregister_netdevice_queue(dev, NULL);

1127

unregister_netdevice_queue(dev, NULL);

1126

}

1128

}

1127

1129

1128

extern void free_netdev(struct net_device *dev);

1130

extern void free_netdev(struct net_device *dev);

1129

extern void synchronize_net(void);

1131

extern void synchronize_net(void);

1130

extern int register_netdevice_notifier(struct notifier_block *nb);

1132

extern int register_netdevice_notifier(struct notifier_block *nb);

1131

extern int unregister_netdevice_notifier(struct notifier_block *nb);

1133

extern int unregister_netdevice_notifier(struct notifier_block *nb);

1132

extern int init_dummy_netdev(struct net_device *dev);

1134

extern int init_dummy_netdev(struct net_device *dev);

1133

extern void netdev_resync_ops(struct net_device *dev);

1135

extern void netdev_resync_ops(struct net_device *dev);

1134

1136

1135

extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);

1137

extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);

1136

extern struct net_device *dev_get_by_index(struct net *net, int ifindex);

1138

extern struct net_device *dev_get_by_index(struct net *net, int ifindex);

1137

extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);

1139

extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);

1138

extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);

1140

extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);

1139

extern int dev_restart(struct net_device *dev);

1141

extern int dev_restart(struct net_device *dev);

1140

#ifdef CONFIG_NETPOLL_TRAP

1142

#ifdef CONFIG_NETPOLL_TRAP

1141

extern int netpoll_trap(void);

1143

extern int netpoll_trap(void);

1142

#endif

1144

#endif

1143

extern int skb_gro_receive(struct sk_buff **head,

1145

extern int skb_gro_receive(struct sk_buff **head,

1144

struct sk_buff *skb);

1146

struct sk_buff *skb);

1145

extern void skb_gro_reset_offset(struct sk_buff *skb);

1147

extern void skb_gro_reset_offset(struct sk_buff *skb);

1146

1148

1147

static inline unsigned int skb_gro_offset(const struct sk_buff *skb)

1149

static inline unsigned int skb_gro_offset(const struct sk_buff *skb)

1148

{

1150

{

1149

return NAPI_GRO_CB(skb)->data_offset;

1151

return NAPI_GRO_CB(skb)->data_offset;

1150

}

1152

}

1151

1153

1152

static inline unsigned int skb_gro_len(const struct sk_buff *skb)

1154

static inline unsigned int skb_gro_len(const struct sk_buff *skb)

1153

{

1155

{

1154

return skb->len - NAPI_GRO_CB(skb)->data_offset;

1156

return skb->len - NAPI_GRO_CB(skb)->data_offset;

1155

}

1157

}

1156

1158

1157

static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)

1159

static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)

1158

{

1160

{

1159

NAPI_GRO_CB(skb)->data_offset += len;

1161

NAPI_GRO_CB(skb)->data_offset += len;

1160

}

1162

}

1161

1163

1162

static inline void *skb_gro_header_fast(struct sk_buff *skb,

1164

static inline void *skb_gro_header_fast(struct sk_buff *skb,

1163

unsigned int offset)

1165

unsigned int offset)

1164

{

1166

{

1165

return NAPI_GRO_CB(skb)->frag0 + offset;

1167

return NAPI_GRO_CB(skb)->frag0 + offset;

1166

}

1168

}

1167

1169

1168

static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)

1170

static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)

1169

{

1171

{

1170

return NAPI_GRO_CB(skb)->frag0_len < hlen;

1172

return NAPI_GRO_CB(skb)->frag0_len < hlen;

1171

}

1173

}

1172

1174

1173

static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,

1175

static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,

1174

unsigned int offset)

1176

unsigned int offset)

1175

{

1177

{

1176

NAPI_GRO_CB(skb)->frag0 = NULL;

1178

NAPI_GRO_CB(skb)->frag0 = NULL;

1177

NAPI_GRO_CB(skb)->frag0_len = 0;

1179

NAPI_GRO_CB(skb)->frag0_len = 0;

1178

return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;

1180

return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;

1179

}

1181

}

1180

1182

1181

static inline void *skb_gro_mac_header(struct sk_buff *skb)

1183

static inline void *skb_gro_mac_header(struct sk_buff *skb)

1182

{

1184

{

1183

return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);

1185

return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);

1184

}

1186

}

1185

1187

1186

static inline void *skb_gro_network_header(struct sk_buff *skb)

1188

static inline void *skb_gro_network_header(struct sk_buff *skb)

1187

{

1189

{

1188

return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +

1190

return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +

1189

skb_network_offset(skb);

1191

skb_network_offset(skb);

1190

}

1192

}

1191

1193

1192

static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,

1194

static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,

1193

unsigned short type,

1195

unsigned short type,

1194

const void *daddr, const void *saddr,

1196

const void *daddr, const void *saddr,

1195

unsigned len)

1197

unsigned len)

1196

{

1198

{

1197

if (!dev->header_ops || !dev->header_ops->create)

1199

if (!dev->header_ops || !dev->header_ops->create)

1198

return 0;

1200

return 0;

1199

1201

1200

return dev->header_ops->create(skb, dev, type, daddr, saddr, len);

1202

return dev->header_ops->create(skb, dev, type, daddr, saddr, len);

1201

}

1203

}

1202

1204

1203

static inline int dev_parse_header(const struct sk_buff *skb,

1205

static inline int dev_parse_header(const struct sk_buff *skb,

1204

unsigned char *haddr)

1206

unsigned char *haddr)

1205

{

1207

{

1206

const struct net_device *dev = skb->dev;

1208

const struct net_device *dev = skb->dev;

1207

1209

1208

if (!dev->header_ops || !dev->header_ops->parse)

1210

if (!dev->header_ops || !dev->header_ops->parse)

1209

return 0;

1211

return 0;

1210

return dev->header_ops->parse(skb, haddr);

1212

return dev->header_ops->parse(skb, haddr);

1211

}

1213

}

1212

1214

1213

typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);

1215

typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);

1214

extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);

1216

extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);

1215

static inline int unregister_gifconf(unsigned int family)

1217

static inline int unregister_gifconf(unsigned int family)

1216

{

1218

{

1217

return register_gifconf(family, NULL);

1219

return register_gifconf(family, NULL);

1218

}

1220

}

1219

1221

1220

/*

1222

/*

1221

* Incoming packets are placed on per-cpu queues so that

1223

* Incoming packets are placed on per-cpu queues so that

1222

* no locking is needed.

1224

* no locking is needed.

1223

*/

1225

*/

1224

struct softnet_data {

1226

struct softnet_data {

1225

struct Qdisc *output_queue;

1227

struct Qdisc *output_queue;

1226

struct sk_buff_head input_pkt_queue;

1228

struct sk_buff_head input_pkt_queue;

1227

struct list_head poll_list;

1229

struct list_head poll_list;

1228

struct sk_buff *completion_queue;

1230

struct sk_buff *completion_queue;

1229

1231

1230

struct napi_struct backlog;

1232

struct napi_struct backlog;

1231

};

1233

};

1232

1234

1233

DECLARE_PER_CPU(struct softnet_data,softnet_data);

1235

DECLARE_PER_CPU(struct softnet_data,softnet_data);

1234

1236

1235

#define HAVE_NETIF_QUEUE

1237

#define HAVE_NETIF_QUEUE

1236

1238

1237

extern void __netif_schedule(struct Qdisc *q);

1239

extern void __netif_schedule(struct Qdisc *q);

1238

1240

1239

static inline void netif_schedule_queue(struct netdev_queue *txq)

1241

static inline void netif_schedule_queue(struct netdev_queue *txq)

1240

{

1242

{

1241

if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))

1243

if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))

1242

__netif_schedule(txq->qdisc);

1244

__netif_schedule(txq->qdisc);

1243

}

1245

}

1244

1246

1245

static inline void netif_tx_schedule_all(struct net_device *dev)

1247

static inline void netif_tx_schedule_all(struct net_device *dev)

1246

{

1248

{

1247

unsigned int i;

1249

unsigned int i;

1248

1250

1249

for (i = 0; i < dev->num_tx_queues; i++)

1251

for (i = 0; i < dev->num_tx_queues; i++)

1250

netif_schedule_queue(netdev_get_tx_queue(dev, i));

1252

netif_schedule_queue(netdev_get_tx_queue(dev, i));

1251

}

1253

}

1252

1254

1253

static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)

1255

static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)

1254

{

1256

{

1255

clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);

1257

clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);

1256

}

1258

}

1257

1259

1258

/**

1260

/**

1259

* netif_start_queue - allow transmit

1261

* netif_start_queue - allow transmit

1260

* @dev: network device

1262

* @dev: network device

1261

*

1263

*

1262

* Allow upper layers to call the device hard_start_xmit routine.

1264

* Allow upper layers to call the device hard_start_xmit routine.

1263

*/

1265

*/

1264

static inline void netif_start_queue(struct net_device *dev)

1266

static inline void netif_start_queue(struct net_device *dev)

1265

{

1267

{

1266

netif_tx_start_queue(netdev_get_tx_queue(dev, 0));

1268

netif_tx_start_queue(netdev_get_tx_queue(dev, 0));

1267

}

1269

}

1268

1270

1269

static inline void netif_tx_start_all_queues(struct net_device *dev)

1271

static inline void netif_tx_start_all_queues(struct net_device *dev)

1270

{

1272

{

1271

unsigned int i;

1273

unsigned int i;

1272

1274

1273

for (i = 0; i < dev->num_tx_queues; i++) {

1275

for (i = 0; i < dev->num_tx_queues; i++) {

1274

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1276

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1275

netif_tx_start_queue(txq);

1277

netif_tx_start_queue(txq);

1276

}

1278

}

1277

}

1279

}

1278

1280

1279

static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)

1281

static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)

1280

{

1282

{

1281

#ifdef CONFIG_NETPOLL_TRAP

1283

#ifdef CONFIG_NETPOLL_TRAP

1282

if (netpoll_trap()) {

1284

if (netpoll_trap()) {

1283

netif_tx_start_queue(dev_queue);

1285

netif_tx_start_queue(dev_queue);

1284

return;

1286

return;

1285

}

1287

}

1286

#endif

1288

#endif

1287

if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))

1289

if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))

1288

__netif_schedule(dev_queue->qdisc);

1290

__netif_schedule(dev_queue->qdisc);

1289

}

1291

}

1290

1292

1291

/**

1293

/**

1292

* netif_wake_queue - restart transmit

1294

* netif_wake_queue - restart transmit

1293

* @dev: network device

1295

* @dev: network device

1294

*

1296

*

1295

* Allow upper layers to call the device hard_start_xmit routine.

1297

* Allow upper layers to call the device hard_start_xmit routine.

1296

* Used for flow control when transmit resources are available.

1298

* Used for flow control when transmit resources are available.

1297

*/

1299

*/

1298

static inline void netif_wake_queue(struct net_device *dev)

1300

static inline void netif_wake_queue(struct net_device *dev)

1299

{

1301

{

1300

netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));

1302

netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));

1301

}

1303

}

1302

1304

1303

static inline void netif_tx_wake_all_queues(struct net_device *dev)

1305

static inline void netif_tx_wake_all_queues(struct net_device *dev)

1304

{

1306

{

1305

unsigned int i;

1307

unsigned int i;

1306

1308

1307

for (i = 0; i < dev->num_tx_queues; i++) {

1309

for (i = 0; i < dev->num_tx_queues; i++) {

1308

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1310

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1309

netif_tx_wake_queue(txq);

1311

netif_tx_wake_queue(txq);

1310

}

1312

}

1311

}

1313

}

1312

1314

1313

static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)

1315

static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)

1314

{

1316

{

1315

set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);

1317

set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);

1316

}

1318

}

1317

1319

1318

/**

1320

/**

1319

* netif_stop_queue - stop transmitted packets

1321

* netif_stop_queue - stop transmitted packets

1320

* @dev: network device

1322

* @dev: network device

1321

*

1323

*

1322

* Stop upper layers calling the device hard_start_xmit routine.

1324

* Stop upper layers calling the device hard_start_xmit routine.

1323

* Used for flow control when transmit resources are unavailable.

1325

* Used for flow control when transmit resources are unavailable.

1324

*/

1326

*/

1325

static inline void netif_stop_queue(struct net_device *dev)

1327

static inline void netif_stop_queue(struct net_device *dev)

1326

{

1328

{

1327

netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));

1329

netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));

1328

}

1330

}

1329

1331

1330

static inline void netif_tx_stop_all_queues(struct net_device *dev)

1332

static inline void netif_tx_stop_all_queues(struct net_device *dev)

1331

{

1333

{

1332

unsigned int i;

1334

unsigned int i;

1333

1335

1334

for (i = 0; i < dev->num_tx_queues; i++) {

1336

for (i = 0; i < dev->num_tx_queues; i++) {

1335

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1337

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1336

netif_tx_stop_queue(txq);

1338

netif_tx_stop_queue(txq);

1337

}

1339

}

1338

}

1340

}

1339

1341

1340

static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)

1342

static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)

1341

{

1343

{

1342

return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);

1344

return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);

1343

}

1345

}

1344

1346

1345

/**

1347

/**

1346

* netif_queue_stopped - test if transmit queue is flowblocked

1348

* netif_queue_stopped - test if transmit queue is flowblocked

1347

* @dev: network device

1349

* @dev: network device

1348

*

1350

*

1349

* Test if transmit queue on device is currently unable to send.

1351

* Test if transmit queue on device is currently unable to send.

1350

*/

1352

*/

1351

static inline int netif_queue_stopped(const struct net_device *dev)

1353

static inline int netif_queue_stopped(const struct net_device *dev)

1352

{

1354

{

1353

return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));

1355

return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));

1354

}

1356

}

1355

1357

1356

static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)

1358

static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)

1357

{

1359

{

1358

return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);

1360

return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);

1359

}

1361

}

1360

1362

1361

/**

1363

/**

1362

* netif_running - test if up

1364

* netif_running - test if up

1363

* @dev: network device

1365

* @dev: network device

1364

*

1366

*

1365

* Test if the device has been brought up.

1367

* Test if the device has been brought up.

1366

*/

1368

*/

1367

static inline int netif_running(const struct net_device *dev)

1369

static inline int netif_running(const struct net_device *dev)

1368

{

1370

{

1369

return test_bit(__LINK_STATE_START, &dev->state);

1371

return test_bit(__LINK_STATE_START, &dev->state);

1370

}

1372

}

1371

1373

1372

/*

1374

/*

1373

* Routines to manage the subqueues on a device. We only need start

1375

* Routines to manage the subqueues on a device. We only need start

1374

* stop, and a check if it's stopped. All other device management is

1376

* stop, and a check if it's stopped. All other device management is

1375

* done at the overall netdevice level.

1377

* done at the overall netdevice level.

1376

* Also test the device if we're multiqueue.

1378

* Also test the device if we're multiqueue.

1377

*/

1379

*/

1378

1380

1379

/**

1381

/**

1380

* netif_start_subqueue - allow sending packets on subqueue

1382

* netif_start_subqueue - allow sending packets on subqueue

1381

* @dev: network device

1383

* @dev: network device

1382

* @queue_index: sub queue index

1384

* @queue_index: sub queue index

1383

*

1385

*

1384

* Start individual transmit queue of a device with multiple transmit queues.

1386

* Start individual transmit queue of a device with multiple transmit queues.

1385

*/

1387

*/

1386

static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)

1388

static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)

1387

{

1389

{

1388

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1390

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1389

1391

1390

netif_tx_start_queue(txq);

1392

netif_tx_start_queue(txq);

1391

}

1393

}

1392

1394

1393

/**

1395

/**

1394

* netif_stop_subqueue - stop sending packets on subqueue

1396

* netif_stop_subqueue - stop sending packets on subqueue

1395

* @dev: network device

1397

* @dev: network device

1396

* @queue_index: sub queue index

1398

* @queue_index: sub queue index

1397

*

1399

*

1398

* Stop individual transmit queue of a device with multiple transmit queues.

1400

* Stop individual transmit queue of a device with multiple transmit queues.

1399

*/

1401

*/

1400

static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)

1402

static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)

1401

{

1403

{

1402

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1404

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1403

#ifdef CONFIG_NETPOLL_TRAP

1405

#ifdef CONFIG_NETPOLL_TRAP

1404

if (netpoll_trap())

1406

if (netpoll_trap())

1405

return;

1407

return;

1406

#endif

1408

#endif

1407

netif_tx_stop_queue(txq);

1409

netif_tx_stop_queue(txq);

1408

}

1410

}

1409

1411

1410

/**

1412

/**

1411

* netif_subqueue_stopped - test status of subqueue

1413

* netif_subqueue_stopped - test status of subqueue

1412

* @dev: network device

1414

* @dev: network device

1413

* @queue_index: sub queue index

1415

* @queue_index: sub queue index

1414

*

1416

*

1415

* Check individual transmit queue of a device with multiple transmit queues.

1417

* Check individual transmit queue of a device with multiple transmit queues.

1416

*/

1418

*/

1417

static inline int __netif_subqueue_stopped(const struct net_device *dev,

1419

static inline int __netif_subqueue_stopped(const struct net_device *dev,

1418

u16 queue_index)

1420

u16 queue_index)

1419

{

1421

{

1420

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1422

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1421

1423

1422

return netif_tx_queue_stopped(txq);

1424

return netif_tx_queue_stopped(txq);

1423

}

1425

}

1424

1426

1425

static inline int netif_subqueue_stopped(const struct net_device *dev,

1427

static inline int netif_subqueue_stopped(const struct net_device *dev,

1426

struct sk_buff *skb)

1428

struct sk_buff *skb)

1427

{

1429

{

1428

return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));

1430

return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));

1429

}

1431

}

1430

1432

1431

/**

1433

/**

1432

* netif_wake_subqueue - allow sending packets on subqueue

1434

* netif_wake_subqueue - allow sending packets on subqueue

1433

* @dev: network device

1435

* @dev: network device

1434

* @queue_index: sub queue index

1436

* @queue_index: sub queue index

1435

*

1437

*

1436

* Resume individual transmit queue of a device with multiple transmit queues.

1438

* Resume individual transmit queue of a device with multiple transmit queues.

1437

*/

1439

*/

1438

static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)

1440

static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)

1439

{

1441

{

1440

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1442

struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);

1441

#ifdef CONFIG_NETPOLL_TRAP

1443

#ifdef CONFIG_NETPOLL_TRAP

1442

if (netpoll_trap())

1444

if (netpoll_trap())

1443

return;

1445

return;

1444

#endif

1446

#endif

1445

if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))

1447

if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))

1446

__netif_schedule(txq->qdisc);

1448

__netif_schedule(txq->qdisc);

1447

}

1449

}

1448

1450

1449

/**

1451

/**

1450

* netif_is_multiqueue - test if device has multiple transmit queues

1452

* netif_is_multiqueue - test if device has multiple transmit queues

1451

* @dev: network device

1453

* @dev: network device

1452

*

1454

*

1453

* Check if device has multiple transmit queues

1455

* Check if device has multiple transmit queues

1454

*/

1456

*/

1455

static inline int netif_is_multiqueue(const struct net_device *dev)

1457

static inline int netif_is_multiqueue(const struct net_device *dev)

1456

{

1458

{

1457

return (dev->num_tx_queues > 1);

1459

return (dev->num_tx_queues > 1);

1458

}

1460

}

1459

1461

1460

/* Use this variant when it is known for sure that it

1462

/* Use this variant when it is known for sure that it

1461

* is executing from hardware interrupt context or with hardware interrupts

1463

* is executing from hardware interrupt context or with hardware interrupts

1462

* disabled.

1464

* disabled.

1463

*/

1465

*/

1464

extern void dev_kfree_skb_irq(struct sk_buff *skb);

1466

extern void dev_kfree_skb_irq(struct sk_buff *skb);

1465

1467

1466

/* Use this variant in places where it could be invoked

1468

/* Use this variant in places where it could be invoked

1467

* from either hardware interrupt or other context, with hardware interrupts

1469

* from either hardware interrupt or other context, with hardware interrupts

1468

* either disabled or enabled.

1470

* either disabled or enabled.

1469

*/

1471

*/

1470

extern void dev_kfree_skb_any(struct sk_buff *skb);

1472

extern void dev_kfree_skb_any(struct sk_buff *skb);

1471

1473

1472

#define HAVE_NETIF_RX 1

1474

#define HAVE_NETIF_RX 1

1473

extern int netif_rx(struct sk_buff *skb);

1475

extern int netif_rx(struct sk_buff *skb);

1474

extern int netif_rx_ni(struct sk_buff *skb);

1476

extern int netif_rx_ni(struct sk_buff *skb);

1475

#define HAVE_NETIF_RECEIVE_SKB 1

1477

#define HAVE_NETIF_RECEIVE_SKB 1

1476

extern int netif_receive_skb(struct sk_buff *skb);

1478

extern int netif_receive_skb(struct sk_buff *skb);

1477

extern void napi_gro_flush(struct napi_struct *napi);

1479

extern void napi_gro_flush(struct napi_struct *napi);

1478

extern gro_result_t dev_gro_receive(struct napi_struct *napi,

1480

extern gro_result_t dev_gro_receive(struct napi_struct *napi,

1479

struct sk_buff *skb);

1481

struct sk_buff *skb);

1480

extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);

1482

extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);

1481

extern gro_result_t napi_gro_receive(struct napi_struct *napi,

1483

extern gro_result_t napi_gro_receive(struct napi_struct *napi,

1482

struct sk_buff *skb);

1484

struct sk_buff *skb);

1483

extern void napi_reuse_skb(struct napi_struct *napi,

1485

extern void napi_reuse_skb(struct napi_struct *napi,

1484

struct sk_buff *skb);

1486

struct sk_buff *skb);

1485

extern struct sk_buff * napi_get_frags(struct napi_struct *napi);

1487

extern struct sk_buff * napi_get_frags(struct napi_struct *napi);

1486

extern gro_result_t napi_frags_finish(struct napi_struct *napi,

1488

extern gro_result_t napi_frags_finish(struct napi_struct *napi,

1487

struct sk_buff *skb,

1489

struct sk_buff *skb,

1488

gro_result_t ret);

1490

gro_result_t ret);

1489

extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);

1491

extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);

1490

extern gro_result_t napi_gro_frags(struct napi_struct *napi);

1492

extern gro_result_t napi_gro_frags(struct napi_struct *napi);

1491

1493

1492

static inline void napi_free_frags(struct napi_struct *napi)

1494

static inline void napi_free_frags(struct napi_struct *napi)

1493

{

1495

{

1494

kfree_skb(napi->skb);

1496

kfree_skb(napi->skb);

1495

napi->skb = NULL;

1497

napi->skb = NULL;

1496

}

1498

}

1497

1499

1498

extern void netif_nit_deliver(struct sk_buff *skb);

1500

extern void netif_nit_deliver(struct sk_buff *skb);

1499

extern int dev_valid_name(const char *name);

1501

extern int dev_valid_name(const char *name);

1500

extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);

1502

extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);

1501

extern int dev_ethtool(struct net *net, struct ifreq *);

1503

extern int dev_ethtool(struct net *net, struct ifreq *);

1502

extern unsigned dev_get_flags(const struct net_device *);

1504

extern unsigned dev_get_flags(const struct net_device *);

1503

extern int dev_change_flags(struct net_device *, unsigned);

1505

extern int dev_change_flags(struct net_device *, unsigned);

1504

extern int dev_change_name(struct net_device *, const char *);

1506

extern int dev_change_name(struct net_device *, const char *);

1505

extern int dev_set_alias(struct net_device *, const char *, size_t);

1507

extern int dev_set_alias(struct net_device *, const char *, size_t);

1506

extern int dev_change_net_namespace(struct net_device *,

1508

extern int dev_change_net_namespace(struct net_device *,

1507

struct net *, const char *);

1509

struct net *, const char *);

1508

extern int dev_set_mtu(struct net_device *, int);

1510

extern int dev_set_mtu(struct net_device *, int);

1509

extern int dev_set_mac_address(struct net_device *,

1511

extern int dev_set_mac_address(struct net_device *,

1510

struct sockaddr *);

1512

struct sockaddr *);

1511

extern int dev_hard_start_xmit(struct sk_buff *skb,

1513

extern int dev_hard_start_xmit(struct sk_buff *skb,

1512

struct net_device *dev,

1514

struct net_device *dev,

1513

struct netdev_queue *txq);

1515

struct netdev_queue *txq);

1514

1516

1515

extern int netdev_budget;

1517

extern int netdev_budget;

1516

1518

1517

/* Called by rtnetlink.c:rtnl_unlock() */

1519

/* Called by rtnetlink.c:rtnl_unlock() */

1518

extern void netdev_run_todo(void);

1520

extern void netdev_run_todo(void);

1519

1521

1520

/**

1522

/**

1521

* dev_put - release reference to device

1523

* dev_put - release reference to device

1522

* @dev: network device

1524

* @dev: network device

1523

*

1525

*

1524

* Release reference to device to allow it to be freed.

1526

* Release reference to device to allow it to be freed.

1525

*/

1527

*/

1526

static inline void dev_put(struct net_device *dev)

1528

static inline void dev_put(struct net_device *dev)

1527

{

1529

{

1528

atomic_dec(&dev->refcnt);

1530

atomic_dec(&dev->refcnt);

1529

}

1531

}

1530

1532

1531

/**

1533

/**

1532

* dev_hold - get reference to device

1534

* dev_hold - get reference to device

1533

* @dev: network device

1535

* @dev: network device

1534

*

1536

*

1535

* Hold reference to device to keep it from being freed.

1537

* Hold reference to device to keep it from being freed.

1536

*/

1538

*/

1537

static inline void dev_hold(struct net_device *dev)

1539

static inline void dev_hold(struct net_device *dev)

1538

{

1540

{

1539

atomic_inc(&dev->refcnt);

1541

atomic_inc(&dev->refcnt);

1540

}

1542

}

1541

1543

1542

/* Carrier loss detection, dial on demand. The functions netif_carrier_on

1544

/* Carrier loss detection, dial on demand. The functions netif_carrier_on

1543

* and _off may be called from IRQ context, but it is caller

1545

* and _off may be called from IRQ context, but it is caller

1544

* who is responsible for serialization of these calls.

1546

* who is responsible for serialization of these calls.

1545

*

1547

*

1546

* The name carrier is inappropriate, these functions should really be

1548

* The name carrier is inappropriate, these functions should really be

1547

* called netif_lowerlayer_*() because they represent the state of any

1549

* called netif_lowerlayer_*() because they represent the state of any

1548

* kind of lower layer not just hardware media.

1550

* kind of lower layer not just hardware media.

1549

*/

1551

*/

1550

1552

1551

extern void linkwatch_fire_event(struct net_device *dev);

1553

extern void linkwatch_fire_event(struct net_device *dev);

1552

1554

1553

/**

1555

/**

1554

* netif_carrier_ok - test if carrier present

1556

* netif_carrier_ok - test if carrier present

1555

* @dev: network device

1557

* @dev: network device

1556

*

1558

*

1557

* Check if carrier is present on device

1559

* Check if carrier is present on device

1558

*/

1560

*/

1559

static inline int netif_carrier_ok(const struct net_device *dev)

1561

static inline int netif_carrier_ok(const struct net_device *dev)

1560

{

1562

{

1561

return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);

1563

return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);

1562

}

1564

}

1563

1565

1564

extern unsigned long dev_trans_start(struct net_device *dev);

1566

extern unsigned long dev_trans_start(struct net_device *dev);

1565

1567

1566

extern void __netdev_watchdog_up(struct net_device *dev);

1568

extern void __netdev_watchdog_up(struct net_device *dev);

1567

1569

1568

extern void netif_carrier_on(struct net_device *dev);

1570

extern void netif_carrier_on(struct net_device *dev);

1569

1571

1570

extern void netif_carrier_off(struct net_device *dev);

1572

extern void netif_carrier_off(struct net_device *dev);

1571

1573

1572

/**

1574

/**

1573

* netif_dormant_on - mark device as dormant.

1575

* netif_dormant_on - mark device as dormant.

1574

* @dev: network device

1576

* @dev: network device

1575

*

1577

*

1576

* Mark device as dormant (as per RFC2863).

1578

* Mark device as dormant (as per RFC2863).

1577

*

1579

*

1578

* The dormant state indicates that the relevant interface is not

1580

* The dormant state indicates that the relevant interface is not

1579

* actually in a condition to pass packets (i.e., it is not 'up') but is

1581

* actually in a condition to pass packets (i.e., it is not 'up') but is

1580

* in a "pending" state, waiting for some external event. For "on-

1582

* in a "pending" state, waiting for some external event. For "on-

1581

* demand" interfaces, this new state identifies the situation where the

1583

* demand" interfaces, this new state identifies the situation where the

1582

* interface is waiting for events to place it in the up state.

1584

* interface is waiting for events to place it in the up state.

1583

*

1585

*

1584

*/

1586

*/

1585

static inline void netif_dormant_on(struct net_device *dev)

1587

static inline void netif_dormant_on(struct net_device *dev)

1586

{

1588

{

1587

if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))

1589

if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))

1588

linkwatch_fire_event(dev);

1590

linkwatch_fire_event(dev);

1589

}

1591

}

1590

1592

1591

/**

1593

/**

1592

* netif_dormant_off - set device as not dormant.

1594

* netif_dormant_off - set device as not dormant.

1593

* @dev: network device

1595

* @dev: network device

1594

*

1596

*

1595

* Device is not in dormant state.

1597

* Device is not in dormant state.

1596

*/

1598

*/

1597

static inline void netif_dormant_off(struct net_device *dev)

1599

static inline void netif_dormant_off(struct net_device *dev)

1598

{

1600

{

1599

if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))

1601

if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))

1600

linkwatch_fire_event(dev);

1602

linkwatch_fire_event(dev);

1601

}

1603

}

1602

1604

1603

/**

1605

/**

1604

* netif_dormant - test if carrier present

1606

* netif_dormant - test if carrier present

1605

* @dev: network device

1607

* @dev: network device

1606

*

1608

*

1607

* Check if carrier is present on device

1609

* Check if carrier is present on device

1608

*/

1610

*/

1609

static inline int netif_dormant(const struct net_device *dev)

1611

static inline int netif_dormant(const struct net_device *dev)

1610

{

1612

{

1611

return test_bit(__LINK_STATE_DORMANT, &dev->state);

1613

return test_bit(__LINK_STATE_DORMANT, &dev->state);

1612

}

1614

}

1613

1615

1614

1616

1615

/**

1617

/**

1616

* netif_oper_up - test if device is operational

1618

* netif_oper_up - test if device is operational

1617

* @dev: network device

1619

* @dev: network device

1618

*

1620

*

1619

* Check if carrier is operational

1621

* Check if carrier is operational

1620

*/

1622

*/

1621

static inline int netif_oper_up(const struct net_device *dev)

1623

static inline int netif_oper_up(const struct net_device *dev)

1622

{

1624

{

1623

return (dev->operstate == IF_OPER_UP ||

1625

return (dev->operstate == IF_OPER_UP ||

1624

dev->operstate == IF_OPER_UNKNOWN /* backward compat */);

1626

dev->operstate == IF_OPER_UNKNOWN /* backward compat */);

1625

}

1627

}

1626

1628

1627

/**

1629

/**

1628

* netif_device_present - is device available or removed

1630

* netif_device_present - is device available or removed

1629

* @dev: network device

1631

* @dev: network device

1630

*

1632

*

1631

* Check if device has not been removed from system.

1633

* Check if device has not been removed from system.

1632

*/

1634

*/

1633

static inline int netif_device_present(struct net_device *dev)

1635

static inline int netif_device_present(struct net_device *dev)

1634

{

1636

{

1635

return test_bit(__LINK_STATE_PRESENT, &dev->state);

1637

return test_bit(__LINK_STATE_PRESENT, &dev->state);

1636

}

1638

}

1637

1639

1638

extern void netif_device_detach(struct net_device *dev);

1640

extern void netif_device_detach(struct net_device *dev);

1639

1641

1640

extern void netif_device_attach(struct net_device *dev);

1642

extern void netif_device_attach(struct net_device *dev);

1641

1643

1642

/*

1644

/*

1643

* Network interface message level settings

1645

* Network interface message level settings

1644

*/

1646

*/

1645

#define HAVE_NETIF_MSG 1

1647

#define HAVE_NETIF_MSG 1

1646

1648

1647

enum {

1649

enum {

1648

NETIF_MSG_DRV = 0x0001,

1650

NETIF_MSG_DRV = 0x0001,

1649

NETIF_MSG_PROBE = 0x0002,

1651

NETIF_MSG_PROBE = 0x0002,

1650

NETIF_MSG_LINK = 0x0004,

1652

NETIF_MSG_LINK = 0x0004,

1651

NETIF_MSG_TIMER = 0x0008,

1653

NETIF_MSG_TIMER = 0x0008,

1652

NETIF_MSG_IFDOWN = 0x0010,

1654

NETIF_MSG_IFDOWN = 0x0010,

1653

NETIF_MSG_IFUP = 0x0020,

1655

NETIF_MSG_IFUP = 0x0020,

1654

NETIF_MSG_RX_ERR = 0x0040,

1656

NETIF_MSG_RX_ERR = 0x0040,

1655

NETIF_MSG_TX_ERR = 0x0080,

1657

NETIF_MSG_TX_ERR = 0x0080,

1656

NETIF_MSG_TX_QUEUED = 0x0100,

1658

NETIF_MSG_TX_QUEUED = 0x0100,

1657

NETIF_MSG_INTR = 0x0200,

1659

NETIF_MSG_INTR = 0x0200,

1658

NETIF_MSG_TX_DONE = 0x0400,

1660

NETIF_MSG_TX_DONE = 0x0400,

1659

NETIF_MSG_RX_STATUS = 0x0800,

1661

NETIF_MSG_RX_STATUS = 0x0800,

1660

NETIF_MSG_PKTDATA = 0x1000,

1662

NETIF_MSG_PKTDATA = 0x1000,

1661

NETIF_MSG_HW = 0x2000,

1663

NETIF_MSG_HW = 0x2000,

1662

NETIF_MSG_WOL = 0x4000,

1664

NETIF_MSG_WOL = 0x4000,

1663

};

1665

};

1664

1666

1665

#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)

1667

#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)

1666

#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)

1668

#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)

1667

#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)

1669

#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)

1668

#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)

1670

#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)

1669

#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)

1671

#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)

1670

#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)

1672

#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)

1671

#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)

1673

#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)

1672

#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)

1674

#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)

1673

#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)

1675

#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)

1674

#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)

1676

#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)

1675

#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)

1677

#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)

1676

#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)

1678

#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)

1677

#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)

1679

#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)

1678

#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)

1680

#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)

1679

#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)

1681

#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)

1680

1682

1681

static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)

1683

static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)

1682

{

1684

{

1683

/* use default */

1685

/* use default */

1684

if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))

1686

if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))

1685

return default_msg_enable_bits;

1687

return default_msg_enable_bits;

1686

if (debug_value == 0) /* no output */

1688

if (debug_value == 0) /* no output */

1687

return 0;

1689

return 0;

1688

/* set low N bits */

1690

/* set low N bits */

1689

return (1 << debug_value) - 1;

1691

return (1 << debug_value) - 1;

1690

}

1692

}

1691

1693

1692

static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)

1694

static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)

1693

{

1695

{

1694

spin_lock(&txq->_xmit_lock);

1696

spin_lock(&txq->_xmit_lock);

1695

txq->xmit_lock_owner = cpu;

1697

txq->xmit_lock_owner = cpu;

1696

}

1698

}

1697

1699

1698

static inline void __netif_tx_lock_bh(struct netdev_queue *txq)

1700

static inline void __netif_tx_lock_bh(struct netdev_queue *txq)

1699

{

1701

{

1700

spin_lock_bh(&txq->_xmit_lock);

1702

spin_lock_bh(&txq->_xmit_lock);

1701

txq->xmit_lock_owner = smp_processor_id();

1703

txq->xmit_lock_owner = smp_processor_id();

1702

}

1704

}

1703

1705

1704

static inline int __netif_tx_trylock(struct netdev_queue *txq)

1706

static inline int __netif_tx_trylock(struct netdev_queue *txq)

1705

{

1707

{

1706

int ok = spin_trylock(&txq->_xmit_lock);

1708

int ok = spin_trylock(&txq->_xmit_lock);

1707

if (likely(ok))

1709

if (likely(ok))

1708

txq->xmit_lock_owner = smp_processor_id();

1710

txq->xmit_lock_owner = smp_processor_id();

1709

return ok;

1711

return ok;

1710

}

1712

}

1711

1713

1712

static inline void __netif_tx_unlock(struct netdev_queue *txq)

1714

static inline void __netif_tx_unlock(struct netdev_queue *txq)

1713

{

1715

{

1714

txq->xmit_lock_owner = -1;

1716

txq->xmit_lock_owner = -1;

1715

spin_unlock(&txq->_xmit_lock);

1717

spin_unlock(&txq->_xmit_lock);

1716

}

1718

}

1717

1719

1718

static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)

1720

static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)

1719

{

1721

{

1720

txq->xmit_lock_owner = -1;

1722

txq->xmit_lock_owner = -1;

1721

spin_unlock_bh(&txq->_xmit_lock);

1723

spin_unlock_bh(&txq->_xmit_lock);

1722

}

1724

}

1723

1725

1724

static inline void txq_trans_update(struct netdev_queue *txq)

1726

static inline void txq_trans_update(struct netdev_queue *txq)

1725

{

1727

{

1726

if (txq->xmit_lock_owner != -1)

1728

if (txq->xmit_lock_owner != -1)

1727

txq->trans_start = jiffies;

1729

txq->trans_start = jiffies;

1728

}

1730

}

1729

1731

1730

/**

1732

/**

1731

* netif_tx_lock - grab network device transmit lock

1733

* netif_tx_lock - grab network device transmit lock

1732

* @dev: network device

1734

* @dev: network device

1733

*

1735

*

1734

* Get network device transmit lock

1736

* Get network device transmit lock

1735

*/

1737

*/

1736

static inline void netif_tx_lock(struct net_device *dev)

1738

static inline void netif_tx_lock(struct net_device *dev)

1737

{

1739

{

1738

unsigned int i;

1740

unsigned int i;

1739

int cpu;

1741

int cpu;

1740

1742

1741

spin_lock(&dev->tx_global_lock);

1743

spin_lock(&dev->tx_global_lock);

1742

cpu = smp_processor_id();

1744

cpu = smp_processor_id();

1743

for (i = 0; i < dev->num_tx_queues; i++) {

1745

for (i = 0; i < dev->num_tx_queues; i++) {

1744

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1746

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1745

1747

1746

/* We are the only thread of execution doing a

1748

/* We are the only thread of execution doing a

1747

* freeze, but we have to grab the _xmit_lock in

1749

* freeze, but we have to grab the _xmit_lock in

1748

* order to synchronize with threads which are in

1750

* order to synchronize with threads which are in

1749

* the ->hard_start_xmit() handler and already

1751

* the ->hard_start_xmit() handler and already

1750

* checked the frozen bit.

1752

* checked the frozen bit.

1751

*/

1753

*/

1752

__netif_tx_lock(txq, cpu);

1754

__netif_tx_lock(txq, cpu);

1753

set_bit(__QUEUE_STATE_FROZEN, &txq->state);

1755

set_bit(__QUEUE_STATE_FROZEN, &txq->state);

1754

__netif_tx_unlock(txq);

1756

__netif_tx_unlock(txq);

1755

}

1757

}

1756

}

1758

}

1757

1759

1758

static inline void netif_tx_lock_bh(struct net_device *dev)

1760

static inline void netif_tx_lock_bh(struct net_device *dev)

1759

{

1761

{

1760

local_bh_disable();

1762

local_bh_disable();

1761

netif_tx_lock(dev);

1763

netif_tx_lock(dev);

1762

}

1764

}

1763

1765

1764

static inline void netif_tx_unlock(struct net_device *dev)

1766

static inline void netif_tx_unlock(struct net_device *dev)

1765

{

1767

{

1766

unsigned int i;

1768

unsigned int i;

1767

1769

1768

for (i = 0; i < dev->num_tx_queues; i++) {

1770

for (i = 0; i < dev->num_tx_queues; i++) {

1769

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1771

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1770

1772

1771

/* No need to grab the _xmit_lock here. If the

1773

/* No need to grab the _xmit_lock here. If the

1772

* queue is not stopped for another reason, we

1774

* queue is not stopped for another reason, we

1773

* force a schedule.

1775

* force a schedule.

1774

*/

1776

*/

1775

clear_bit(__QUEUE_STATE_FROZEN, &txq->state);

1777

clear_bit(__QUEUE_STATE_FROZEN, &txq->state);

1776

netif_schedule_queue(txq);

1778

netif_schedule_queue(txq);

1777

}

1779

}

1778

spin_unlock(&dev->tx_global_lock);

1780

spin_unlock(&dev->tx_global_lock);

1779

}

1781

}

1780

1782

1781

static inline void netif_tx_unlock_bh(struct net_device *dev)

1783

static inline void netif_tx_unlock_bh(struct net_device *dev)

1782

{

1784

{

1783

netif_tx_unlock(dev);

1785

netif_tx_unlock(dev);

1784

local_bh_enable();

1786

local_bh_enable();

1785

}

1787

}

1786

1788

1787

#define HARD_TX_LOCK(dev, txq, cpu) { \

1789

#define HARD_TX_LOCK(dev, txq, cpu) { \

1788

if ((dev->features & NETIF_F_LLTX) == 0) { \

1790

if ((dev->features & NETIF_F_LLTX) == 0) { \

1789

__netif_tx_lock(txq, cpu); \

1791

__netif_tx_lock(txq, cpu); \

1790

} \

1792

} \

1791

}

1793

}

1792

1794

1793

#define HARD_TX_UNLOCK(dev, txq) { \

1795

#define HARD_TX_UNLOCK(dev, txq) { \

1794

if ((dev->features & NETIF_F_LLTX) == 0) { \

1796

if ((dev->features & NETIF_F_LLTX) == 0) { \

1795

__netif_tx_unlock(txq); \

1797

__netif_tx_unlock(txq); \

1796

} \

1798

} \

1797

}

1799

}

1798

1800

1799

static inline void netif_tx_disable(struct net_device *dev)

1801

static inline void netif_tx_disable(struct net_device *dev)

1800

{

1802

{

1801

unsigned int i;

1803

unsigned int i;

1802

int cpu;

1804

int cpu;

1803

1805

1804

local_bh_disable();

1806

local_bh_disable();

1805

cpu = smp_processor_id();

1807

cpu = smp_processor_id();

1806

for (i = 0; i < dev->num_tx_queues; i++) {

1808

for (i = 0; i < dev->num_tx_queues; i++) {

1807

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1809

struct netdev_queue *txq = netdev_get_tx_queue(dev, i);

1808

1810

1809

__netif_tx_lock(txq, cpu);

1811

__netif_tx_lock(txq, cpu);

1810

netif_tx_stop_queue(txq);

1812

netif_tx_stop_queue(txq);

1811

__netif_tx_unlock(txq);

1813

__netif_tx_unlock(txq);

1812

}

1814

}

1813

local_bh_enable();

1815

local_bh_enable();

1814

}

1816

}

1815

1817

1816

static inline void netif_addr_lock(struct net_device *dev)

1818

static inline void netif_addr_lock(struct net_device *dev)

1817

{

1819

{

1818

spin_lock(&dev->addr_list_lock);

1820

spin_lock(&dev->addr_list_lock);

1819

}

1821

}

1820

1822

1821

static inline void netif_addr_lock_bh(struct net_device *dev)

1823

static inline void netif_addr_lock_bh(struct net_device *dev)

1822

{

1824

{

1823

spin_lock_bh(&dev->addr_list_lock);

1825

spin_lock_bh(&dev->addr_list_lock);

1824

}

1826

}

1825

1827

1826

static inline void netif_addr_unlock(struct net_device *dev)

1828

static inline void netif_addr_unlock(struct net_device *dev)

1827

{

1829

{

1828

spin_unlock(&dev->addr_list_lock);

1830

spin_unlock(&dev->addr_list_lock);

1829

}

1831

}

1830

1832

1831

static inline void netif_addr_unlock_bh(struct net_device *dev)

1833

static inline void netif_addr_unlock_bh(struct net_device *dev)

1832

{

1834

{

1833

spin_unlock_bh(&dev->addr_list_lock);

1835

spin_unlock_bh(&dev->addr_list_lock);

1834

}

1836

}

1835

1837

1836

/*

1838

/*

1837

* dev_addrs walker. Should be used only for read access. Call with

1839

* dev_addrs walker. Should be used only for read access. Call with

1838

* rcu_read_lock held.

1840

* rcu_read_lock held.

1839

*/

1841

*/

1840

#define for_each_dev_addr(dev, ha) \

1842

#define for_each_dev_addr(dev, ha) \

1841

list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)

1843

list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)

1842

1844

1843

/* These functions live elsewhere (drivers/net/net_init.c, but related) */

1845

/* These functions live elsewhere (drivers/net/net_init.c, but related) */

1844

1846

1845

extern void ether_setup(struct net_device *dev);

1847

extern void ether_setup(struct net_device *dev);

1846

1848

1847

/* Support for loadable net-drivers */

1849

/* Support for loadable net-drivers */

1848

extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,

1850

extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,

1849

void (*setup)(struct net_device *),

1851

void (*setup)(struct net_device *),

1850

unsigned int queue_count);

1852

unsigned int queue_count);

1851

#define alloc_netdev(sizeof_priv, name, setup) \

1853

#define alloc_netdev(sizeof_priv, name, setup) \

1852

alloc_netdev_mq(sizeof_priv, name, setup, 1)

1854

alloc_netdev_mq(sizeof_priv, name, setup, 1)

1853

extern int register_netdev(struct net_device *dev);

1855

extern int register_netdev(struct net_device *dev);

1854

extern void unregister_netdev(struct net_device *dev);

1856

extern void unregister_netdev(struct net_device *dev);

1855

1857

1856

/* Functions used for device addresses handling */

1858

/* Functions used for device addresses handling */

1857

extern int dev_addr_add(struct net_device *dev, unsigned char *addr,

1859

extern int dev_addr_add(struct net_device *dev, unsigned char *addr,

1858

unsigned char addr_type);

1860

unsigned char addr_type);

1859

extern int dev_addr_del(struct net_device *dev, unsigned char *addr,

1861

extern int dev_addr_del(struct net_device *dev, unsigned char *addr,

1860

unsigned char addr_type);

1862

unsigned char addr_type);

1861

extern int dev_addr_add_multiple(struct net_device *to_dev,

1863

extern int dev_addr_add_multiple(struct net_device *to_dev,

1862

struct net_device *from_dev,

1864

struct net_device *from_dev,

1863

unsigned char addr_type);

1865

unsigned char addr_type);

1864

extern int dev_addr_del_multiple(struct net_device *to_dev,

1866

extern int dev_addr_del_multiple(struct net_device *to_dev,

1865

struct net_device *from_dev,

1867

struct net_device *from_dev,

1866

unsigned char addr_type);

1868

unsigned char addr_type);

1867

1869

1868

/* Functions used for secondary unicast and multicast support */

1870

/* Functions used for secondary unicast and multicast support */

1869

extern void dev_set_rx_mode(struct net_device *dev);

1871

extern void dev_set_rx_mode(struct net_device *dev);

1870

extern void __dev_set_rx_mode(struct net_device *dev);

1872

extern void __dev_set_rx_mode(struct net_device *dev);

1871

extern int dev_unicast_delete(struct net_device *dev, void *addr);

1873

extern int dev_unicast_delete(struct net_device *dev, void *addr);

1872

extern int dev_unicast_add(struct net_device *dev, void *addr);

1874

extern int dev_unicast_add(struct net_device *dev, void *addr);

1873

extern int dev_unicast_sync(struct net_device *to, struct net_device *from);

1875

extern int dev_unicast_sync(struct net_device *to, struct net_device *from);

1874

extern void dev_unicast_unsync(struct net_device *to, struct net_device *from);

1876

extern void dev_unicast_unsync(struct net_device *to, struct net_device *from);

1875

extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);

1877

extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);

1876

extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);

1878

extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);

1877

extern int dev_mc_sync(struct net_device *to, struct net_device *from);

1879

extern int dev_mc_sync(struct net_device *to, struct net_device *from);

1878

extern void dev_mc_unsync(struct net_device *to, struct net_device *from);

1880

extern void dev_mc_unsync(struct net_device *to, struct net_device *from);

1879

extern int __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);

1881

extern int __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);

1880

extern int __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);

1882

extern int __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);

1881

extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);

1883

extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);

1882

extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);

1884

extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);

1883

extern int dev_set_promiscuity(struct net_device *dev, int inc);

1885

extern int dev_set_promiscuity(struct net_device *dev, int inc);

1884

extern int dev_set_allmulti(struct net_device *dev, int inc);

1886

extern int dev_set_allmulti(struct net_device *dev, int inc);

1885

extern void netdev_state_change(struct net_device *dev);

1887

extern void netdev_state_change(struct net_device *dev);

1886

extern void netdev_bonding_change(struct net_device *dev,

1888

extern void netdev_bonding_change(struct net_device *dev,

1887

unsigned long event);

1889

unsigned long event);

1888

extern void netdev_features_change(struct net_device *dev);

1890

extern void netdev_features_change(struct net_device *dev);

1889

/* Load a device via the kmod */

1891

/* Load a device via the kmod */

1890

extern void dev_load(struct net *net, const char *name);

1892

extern void dev_load(struct net *net, const char *name);

1891

extern void dev_mcast_init(void);

1893

extern void dev_mcast_init(void);

1892

extern const struct net_device_stats *dev_get_stats(struct net_device *dev);

1894

extern const struct net_device_stats *dev_get_stats(struct net_device *dev);

1893

1895

1894

extern int netdev_max_backlog;

1896

extern int netdev_max_backlog;

1895

extern int weight_p;

1897

extern int weight_p;

1896

extern int netdev_set_master(struct net_device *dev, struct net_device *master);

1898

extern int netdev_set_master(struct net_device *dev, struct net_device *master);

1897

extern int skb_checksum_help(struct sk_buff *skb);

1899

extern int skb_checksum_help(struct sk_buff *skb);

1898

extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);

1900

extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);

1899

#ifdef CONFIG_BUG

1901

#ifdef CONFIG_BUG

1900

extern void netdev_rx_csum_fault(struct net_device *dev);

1902

extern void netdev_rx_csum_fault(struct net_device *dev);

1901

#else

1903

#else

1902

static inline void netdev_rx_csum_fault(struct net_device *dev)

1904

static inline void netdev_rx_csum_fault(struct net_device *dev)

1903

{

1905

{

1904

}

1906

}

1905

#endif

1907

#endif

1906

/* rx skb timestamps */

1908

/* rx skb timestamps */

1907

extern void net_enable_timestamp(void);

1909

extern void net_enable_timestamp(void);

1908

extern void net_disable_timestamp(void);

1910

extern void net_disable_timestamp(void);

1909

1911

1910

#ifdef CONFIG_PROC_FS

1912

#ifdef CONFIG_PROC_FS

1911

extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);

1913

extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);

1912

extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);

1914

extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);

1913

extern void dev_seq_stop(struct seq_file *seq, void *v);

1915

extern void dev_seq_stop(struct seq_file *seq, void *v);

1914

#endif

1916

#endif

1915

1917

1916

extern int netdev_class_create_file(struct class_attribute *class_attr);

1918

extern int netdev_class_create_file(struct class_attribute *class_attr);

1917

extern void netdev_class_remove_file(struct class_attribute *class_attr);

1919

extern void netdev_class_remove_file(struct class_attribute *class_attr);

1918

1920

1919

extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);

1921

extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);

1920

1922

1921

extern void linkwatch_run_queue(void);

1923

extern void linkwatch_run_queue(void);

1922

1924

1923

unsigned long netdev_increment_features(unsigned long all, unsigned long one,

1925

unsigned long netdev_increment_features(unsigned long all, unsigned long one,

1924

unsigned long mask);

1926

unsigned long mask);

1925

unsigned long netdev_fix_features(unsigned long features, const char *name);

1927

unsigned long netdev_fix_features(unsigned long features, const char *name);

1926

1928

1927

static inline int net_gso_ok(int features, int gso_type)

1929

static inline int net_gso_ok(int features, int gso_type)

1928

{

1930

{

1929

int feature = gso_type << NETIF_F_GSO_SHIFT;

1931

int feature = gso_type << NETIF_F_GSO_SHIFT;

1930

return (features & feature) == feature;

1932

return (features & feature) == feature;

1931

}

1933

}

1932

1934

1933

static inline int skb_gso_ok(struct sk_buff *skb, int features)

1935

static inline int skb_gso_ok(struct sk_buff *skb, int features)

1934

{

1936

{

1935

return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&

1937

return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&

1936

(!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));

1938

(!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));

1937

}

1939

}

1938

1940

1939

static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)

1941

static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)

1940

{

1942

{

1941

return skb_is_gso(skb) &&

1943

return skb_is_gso(skb) &&

1942

(!skb_gso_ok(skb, dev->features) ||

1944

(!skb_gso_ok(skb, dev->features) ||

1943

unlikely(skb->ip_summed != CHECKSUM_PARTIAL));

1945

unlikely(skb->ip_summed != CHECKSUM_PARTIAL));

1944

}

1946

}

1945

1947

1946

static inline void netif_set_gso_max_size(struct net_device *dev,

1948

static inline void netif_set_gso_max_size(struct net_device *dev,

1947

unsigned int size)

1949

unsigned int size)

1948

{

1950

{

1949

dev->gso_max_size = size;

1951

dev->gso_max_size = size;

1950

}

1952

}

1951

1953

1952

static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,

1954

static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,

1953

struct net_device *master)

1955

struct net_device *master)

1954

{

1956

{

1955

if (skb->pkt_type == PACKET_HOST) {

1957

if (skb->pkt_type == PACKET_HOST) {

1956

u16 *dest = (u16 *) eth_hdr(skb)->h_dest;

1958

u16 *dest = (u16 *) eth_hdr(skb)->h_dest;

1957

1959

1958

memcpy(dest, master->dev_addr, ETH_ALEN);

1960

memcpy(dest, master->dev_addr, ETH_ALEN);

1959

}

1961

}

1960

}

1962

}

1961

1963

1962

/* On bonding slaves other than the currently active slave, suppress

1964

/* On bonding slaves other than the currently active slave, suppress

1963

* duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and

1965

* duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and

1964

* ARP on active-backup slaves with arp_validate enabled.

1966

* ARP on active-backup slaves with arp_validate enabled.

1965

*/

1967

*/

1966

static inline int skb_bond_should_drop(struct sk_buff *skb)

1968

static inline int skb_bond_should_drop(struct sk_buff *skb)

1967

{

1969

{

1968

struct net_device *dev = skb->dev;

1970

struct net_device *dev = skb->dev;

1969

struct net_device *master = dev->master;

1971

struct net_device *master = dev->master;

1970

1972

1971

if (master) {

1973

if (master) {

1972

if (master->priv_flags & IFF_MASTER_ARPMON)

1974

if (master->priv_flags & IFF_MASTER_ARPMON)

1973

dev->last_rx = jiffies;

1975

dev->last_rx = jiffies;

1974

1976

1975

if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {

1977

if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {

1976

/* Do address unmangle. The local destination address

1978

/* Do address unmangle. The local destination address

1977

* will be always the one master has. Provides the right

1979

* will be always the one master has. Provides the right

1978

* functionality in a bridge.

1980

* functionality in a bridge.

1979

*/

1981

*/

1980

skb_bond_set_mac_by_master(skb, master);

1982

skb_bond_set_mac_by_master(skb, master);

1981

}

1983

}

1982

1984

1983

if (dev->priv_flags & IFF_SLAVE_INACTIVE) {

1985

if (dev->priv_flags & IFF_SLAVE_INACTIVE) {

1984

if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&

1986

if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&

1985

skb->protocol == __cpu_to_be16(ETH_P_ARP))

1987

skb->protocol == __cpu_to_be16(ETH_P_ARP))

1986

return 0;

1988

return 0;

1987

1989

1988

if (master->priv_flags & IFF_MASTER_ALB) {

1990

if (master->priv_flags & IFF_MASTER_ALB) {

1989

if (skb->pkt_type != PACKET_BROADCAST &&

1991

if (skb->pkt_type != PACKET_BROADCAST &&

1990

skb->pkt_type != PACKET_MULTICAST)

1992

skb->pkt_type != PACKET_MULTICAST)

1991

return 0;

1993

return 0;

1992

}

1994

}

1993

if (master->priv_flags & IFF_MASTER_8023AD &&

1995

if (master->priv_flags & IFF_MASTER_8023AD &&

1994

skb->protocol == __cpu_to_be16(ETH_P_SLOW))

1996

skb->protocol == __cpu_to_be16(ETH_P_SLOW))

1995

return 0;

1997

return 0;

1996

1998

1997

return 1;

1999

return 1;

1998

}

2000

}

1999

}

2001

}

2000

return 0;

2002

return 0;

2001

}

2003

}

2002

2004

2003

extern struct pernet_operations __net_initdata loopback_net_ops;

2005

extern struct pernet_operations __net_initdata loopback_net_ops;

2004

2006

2005

static inline int dev_ethtool_get_settings(struct net_device *dev,

2007

static inline int dev_ethtool_get_settings(struct net_device *dev,

2006

struct ethtool_cmd *cmd)

2008

struct ethtool_cmd *cmd)

2007

{

2009

{

2008

if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)

2010

if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)

2009

return -EOPNOTSUPP;

2011

return -EOPNOTSUPP;

2010

return dev->ethtool_ops->get_settings(dev, cmd);

2012

return dev->ethtool_ops->get_settings(dev, cmd);

2011

}

2013

}

2012

2014

2013

static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)

2015

static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)

2014

{

2016

{

2015

if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)

2017

if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)

2016

return 0;

2018

return 0;

2017

return dev->ethtool_ops->get_rx_csum(dev);

2019

return dev->ethtool_ops->get_rx_csum(dev);

2018

}

2020

}

2019

2021

2020

static inline u32 dev_ethtool_get_flags(struct net_device *dev)

2022

static inline u32 dev_ethtool_get_flags(struct net_device *dev)

2021

{

2023

{

2022

if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)

2024

if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)

2023

return 0;

2025

return 0;

2024

return dev->ethtool_ops->get_flags(dev);

2026

return dev->ethtool_ops->get_flags(dev);

2025

}

2027

}

2026

#endif /* __KERNEL__ */

2028

#endif /* __KERNEL__ */

2027

2029

2028

#endif /* _LINUX_NETDEVICE_H */

2030

#endif /* _LINUX_NETDEVICE_H */

2029

2031

GITLAB

netdev: add netdev_continue_rcu

 /*
  * INET		An implementation of the TCP/IP protocol suite for the LINUX
  *		operating system.  INET is implemented using the  BSD Socket
  *		interface as the means of communication with the user level.
  *
  *		Definitions for the Interfaces handler.
  *
  * Version:	@(#)dev.h	1.0.10	08/12/93
  *
  * Authors:	Ross Biro
  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  *		Corey Minyard <wf-rch!minyard@relay.EU.net>
  *		Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  *		Alan Cox, <alan@lxorguk.ukuu.org.uk>
  *		Bjorn Ekwall. <bj0rn@blox.se>
  *              Pekka Riikonen <priikone@poseidon.pspt.fi>
  *
  *		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.
  *
  *		Moved to /usr/include/linux for NET3
  */
 #ifndef _LINUX_NETDEVICE_H
 #define _LINUX_NETDEVICE_H
 #include <linux/if.h>
 #include <linux/if_ether.h>
 #include <linux/if_packet.h>
 #ifdef __KERNEL__
 #include <linux/timer.h>
 #include <linux/delay.h>
 #include <linux/mm.h>
 #include <asm/atomic.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 #include <linux/device.h>
 #include <linux/percpu.h>
 #include <linux/rculist.h>
 #include <linux/dmaengine.h>
 #include <linux/workqueue.h>
 #include <linux/ethtool.h>
 #include <net/net_namespace.h>
 #include <net/dsa.h>
 #ifdef CONFIG_DCB
 #include <net/dcbnl.h>
 #endif
 struct vlan_group;
 struct netpoll_info;
 /* 802.11 specific */
 struct wireless_dev;
 					/* source back-compat hooks */
 #define SET_ETHTOOL_OPS(netdev,ops) \
 	( (netdev)->ethtool_ops = (ops) )
 #define HAVE_ALLOC_NETDEV		/* feature macro: alloc_xxxdev
 					   functions are available. */
 #define HAVE_FREE_NETDEV		/* free_netdev() */
 #define HAVE_NETDEV_PRIV		/* netdev_priv() */
 #define NET_XMIT_SUCCESS	0
 #define NET_XMIT_DROP		1	/* skb dropped			*/
 #define NET_XMIT_CN		2	/* congestion notification	*/
 #define NET_XMIT_POLICED	3	/* skb is shot by police	*/
 #define NET_XMIT_MASK		0xFFFF	/* qdisc flags in net/sch_generic.h */
 /* Backlog congestion levels */
 #define NET_RX_SUCCESS		0   /* keep 'em coming, baby */
 #define NET_RX_DROP		1  /* packet dropped */
 /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  * indicates that the device will soon be dropping packets, or already drops
  * some packets of the same priority; prompting us to send less aggressively. */
 #define net_xmit_eval(e)	((e) == NET_XMIT_CN? 0 : (e))
 #define net_xmit_errno(e)	((e) != NET_XMIT_CN ? -ENOBUFS : 0)
 /* Driver transmit return codes */
 enum netdev_tx {
 	NETDEV_TX_OK = 0,	/* driver took care of packet */
 	NETDEV_TX_BUSY,		/* driver tx path was busy*/
 	NETDEV_TX_LOCKED = -1,	/* driver tx lock was already taken */
 };
 typedef enum netdev_tx netdev_tx_t;
 #endif
 #define MAX_ADDR_LEN	32		/* Largest hardware address length */
 #ifdef  __KERNEL__
 /*
  *	Compute the worst case header length according to the protocols
  *	used.
  */
 #if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 # if defined(CONFIG_MAC80211_MESH)
 #  define LL_MAX_HEADER 128
 # else
 #  define LL_MAX_HEADER 96
 # endif
 #elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
 # define LL_MAX_HEADER 48
 #else
 # define LL_MAX_HEADER 32
 #endif
 #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
     !defined(CONFIG_NET_IPGRE) &&  !defined(CONFIG_NET_IPGRE_MODULE) && \
     !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
     !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
 #define MAX_HEADER LL_MAX_HEADER
 #else
 #define MAX_HEADER (LL_MAX_HEADER + 48)
 #endif
 #endif  /*  __KERNEL__  */
 /*
  *	Network device statistics. Akin to the 2.0 ether stats but
  *	with byte counters.
  */
 struct net_device_stats {
 	unsigned long	rx_packets;		/* total packets received	*/
 	unsigned long	tx_packets;		/* total packets transmitted	*/
 	unsigned long	rx_bytes;		/* total bytes received 	*/
 	unsigned long	tx_bytes;		/* total bytes transmitted	*/
 	unsigned long	rx_errors;		/* bad packets received		*/
 	unsigned long	tx_errors;		/* packet transmit problems	*/
 	unsigned long	rx_dropped;		/* no space in linux buffers	*/
 	unsigned long	tx_dropped;		/* no space available in linux	*/
 	unsigned long	multicast;		/* multicast packets received	*/
 	unsigned long	collisions;
 	/* detailed rx_errors: */
 	unsigned long	rx_length_errors;
 	unsigned long	rx_over_errors;		/* receiver ring buff overflow	*/
 	unsigned long	rx_crc_errors;		/* recved pkt with crc error	*/
 	unsigned long	rx_frame_errors;	/* recv'd frame alignment error */
 	unsigned long	rx_fifo_errors;		/* recv'r fifo overrun		*/
 	unsigned long	rx_missed_errors;	/* receiver missed packet	*/
 	/* detailed tx_errors */
 	unsigned long	tx_aborted_errors;
 	unsigned long	tx_carrier_errors;
 	unsigned long	tx_fifo_errors;
 	unsigned long	tx_heartbeat_errors;
 	unsigned long	tx_window_errors;
 	/* for cslip etc */
 	unsigned long	rx_compressed;
 	unsigned long	tx_compressed;
 };
 /* Media selection options. */
 enum {
         IF_PORT_UNKNOWN = 0,
         IF_PORT_10BASE2,
         IF_PORT_10BASET,
         IF_PORT_AUI,
         IF_PORT_100BASET,
         IF_PORT_100BASETX,
         IF_PORT_100BASEFX
 };
 #ifdef __KERNEL__
 #include <linux/cache.h>
 #include <linux/skbuff.h>
 struct neighbour;
 struct neigh_parms;
 struct sk_buff;
 struct netif_rx_stats {
 	unsigned total;
 	unsigned dropped;
 	unsigned time_squeeze;
 	unsigned cpu_collision;
 };
 DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
 struct dev_addr_list {
 	struct dev_addr_list	*next;
 	u8			da_addr[MAX_ADDR_LEN];
 	u8			da_addrlen;
 	u8			da_synced;
 	int			da_users;
 	int			da_gusers;
 };
 /*
  *	We tag multicasts with these structures.
  */
 #define dev_mc_list	dev_addr_list
 #define dmi_addr	da_addr
 #define dmi_addrlen	da_addrlen
 #define dmi_users	da_users
 #define dmi_gusers	da_gusers
 struct netdev_hw_addr {
 	struct list_head	list;
 	unsigned char		addr[MAX_ADDR_LEN];
 	unsigned char		type;
 #define NETDEV_HW_ADDR_T_LAN		1
 #define NETDEV_HW_ADDR_T_SAN		2
 #define NETDEV_HW_ADDR_T_SLAVE		3
 #define NETDEV_HW_ADDR_T_UNICAST	4
 	int			refcount;
 	bool			synced;
 	struct rcu_head		rcu_head;
 };
 struct netdev_hw_addr_list {
 	struct list_head	list;
 	int			count;
 };
 struct hh_cache {
 	struct hh_cache *hh_next;	/* Next entry			     */
 	atomic_t	hh_refcnt;	/* number of users                   */
 /*
  * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
  * cache line on SMP.
  * They are mostly read, but hh_refcnt may be changed quite frequently,
  * incurring cache line ping pongs.
  */
 	__be16		hh_type ____cacheline_aligned_in_smp;
 					/* protocol identifier, f.e ETH_P_IP
                                          *  NOTE:  For VLANs, this will be the
                                          *  encapuslated type. --BLG
                                          */
 	u16		hh_len;		/* length of header */
 	int		(*hh_output)(struct sk_buff *skb);
 	seqlock_t	hh_lock;
 	/* cached hardware header; allow for machine alignment needs.        */
 #define HH_DATA_MOD	16
 #define HH_DATA_OFF(__len) \
 	(HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
 #define HH_DATA_ALIGN(__len) \
 	(((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
 	unsigned long	hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
 };
 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  * Alternative is:
  *   dev->hard_header_len ? (dev->hard_header_len +
  *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  *
  * We could use other alignment values, but we must maintain the
  * relationship HH alignment <= LL alignment.
  *
  * LL_ALLOCATED_SPACE also takes into account the tailroom the device
  * may need.
  */
 #define LL_RESERVED_SPACE(dev) \
 	((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
 	((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 #define LL_ALLOCATED_SPACE(dev) \
 	((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 struct header_ops {
 	int	(*create) (struct sk_buff *skb, struct net_device *dev,
 			   unsigned short type, const void *daddr,
 			   const void *saddr, unsigned len);
 	int	(*parse)(const struct sk_buff *skb, unsigned char *haddr);
 	int	(*rebuild)(struct sk_buff *skb);
 #define HAVE_HEADER_CACHE
 	int	(*cache)(const struct neighbour *neigh, struct hh_cache *hh);
 	void	(*cache_update)(struct hh_cache *hh,
 				const struct net_device *dev,
 				const unsigned char *haddr);
 };
 /* These flag bits are private to the generic network queueing
  * layer, they may not be explicitly referenced by any other
  * code.
  */
 enum netdev_state_t {
 	__LINK_STATE_START,
 	__LINK_STATE_PRESENT,
 	__LINK_STATE_NOCARRIER,
 	__LINK_STATE_LINKWATCH_PENDING,
 	__LINK_STATE_DORMANT,
 };
 /*
  * This structure holds at boot time configured netdevice settings. They
  * are then used in the device probing.
  */
 struct netdev_boot_setup {
 	char name[IFNAMSIZ];
 	struct ifmap map;
 };
 #define NETDEV_BOOT_SETUP_MAX 8
 extern int __init netdev_boot_setup(char *str);
 /*
  * Structure for NAPI scheduling similar to tasklet but with weighting
  */
 struct napi_struct {
 	/* The poll_list must only be managed by the entity which
 	 * changes the state of the NAPI_STATE_SCHED bit.  This means
 	 * whoever atomically sets that bit can add this napi_struct
 	 * to the per-cpu poll_list, and whoever clears that bit
 	 * can remove from the list right before clearing the bit.
 	 */
 	struct list_head	poll_list;
 	unsigned long		state;
 	int			weight;
 	int			(*poll)(struct napi_struct *, int);
 #ifdef CONFIG_NETPOLL
 	spinlock_t		poll_lock;
 	int			poll_owner;
 #endif
 	unsigned int		gro_count;
 	struct net_device	*dev;
 	struct list_head	dev_list;
 	struct sk_buff		*gro_list;
 	struct sk_buff		*skb;
 };
 enum {
 	NAPI_STATE_SCHED,	/* Poll is scheduled */
 	NAPI_STATE_DISABLE,	/* Disable pending */
 	NAPI_STATE_NPSVC,	/* Netpoll - don't dequeue from poll_list */
 };
 enum gro_result {
 	GRO_MERGED,
 	GRO_MERGED_FREE,
 	GRO_HELD,
 	GRO_NORMAL,
 	GRO_DROP,
 };
 typedef enum gro_result gro_result_t;
 extern void __napi_schedule(struct napi_struct *n);
 static inline int napi_disable_pending(struct napi_struct *n)
 {
 	return test_bit(NAPI_STATE_DISABLE, &n->state);
 }
 /**
  *	napi_schedule_prep - check if napi can be scheduled
  *	@n: napi context
  *
  * Test if NAPI routine is already running, and if not mark
  * it as running.  This is used as a condition variable
  * insure only one NAPI poll instance runs.  We also make
  * sure there is no pending NAPI disable.
  */
 static inline int napi_schedule_prep(struct napi_struct *n)
 {
 	return !napi_disable_pending(n) &&
 		!test_and_set_bit(NAPI_STATE_SCHED, &n->state);
 }
 /**
  *	napi_schedule - schedule NAPI poll
  *	@n: napi context
  *
  * Schedule NAPI poll routine to be called if it is not already
  * running.
  */
 static inline void napi_schedule(struct napi_struct *n)
 {
 	if (napi_schedule_prep(n))
 		__napi_schedule(n);
 }
 /* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
 static inline int napi_reschedule(struct napi_struct *napi)
 {
 	if (napi_schedule_prep(napi)) {
 		__napi_schedule(napi);
 		return 1;
 	}
 	return 0;
 }
 /**
  *	napi_complete - NAPI processing complete
  *	@n: napi context
  *
  * Mark NAPI processing as complete.
  */
 extern void __napi_complete(struct napi_struct *n);
 extern void napi_complete(struct napi_struct *n);
 /**
  *	napi_disable - prevent NAPI from scheduling
  *	@n: napi context
  *
  * Stop NAPI from being scheduled on this context.
  * Waits till any outstanding processing completes.
  */
 static inline void napi_disable(struct napi_struct *n)
 {
 	set_bit(NAPI_STATE_DISABLE, &n->state);
 	while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
 		msleep(1);
 	clear_bit(NAPI_STATE_DISABLE, &n->state);
 }
 /**
  *	napi_enable - enable NAPI scheduling
  *	@n: napi context
  *
  * Resume NAPI from being scheduled on this context.
  * Must be paired with napi_disable.
  */
 static inline void napi_enable(struct napi_struct *n)
 {
 	BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
 	smp_mb__before_clear_bit();
 	clear_bit(NAPI_STATE_SCHED, &n->state);
 }
 #ifdef CONFIG_SMP
 /**
  *	napi_synchronize - wait until NAPI is not running
  *	@n: napi context
  *
  * Wait until NAPI is done being scheduled on this context.
  * Waits till any outstanding processing completes but
  * does not disable future activations.
  */
 static inline void napi_synchronize(const struct napi_struct *n)
 {
 	while (test_bit(NAPI_STATE_SCHED, &n->state))
 		msleep(1);
 }
 #else
 # define napi_synchronize(n)	barrier()
 #endif
 enum netdev_queue_state_t {
 	__QUEUE_STATE_XOFF,
 	__QUEUE_STATE_FROZEN,
 };
 struct netdev_queue {
 /*
  * read mostly part
  */
 	struct net_device	*dev;
 	struct Qdisc		*qdisc;
 	unsigned long		state;
 	struct Qdisc		*qdisc_sleeping;
 /*
  * write mostly part
  */
 	spinlock_t		_xmit_lock ____cacheline_aligned_in_smp;
 	int			xmit_lock_owner;
 	/*
 	 * please use this field instead of dev->trans_start
 	 */
 	unsigned long		trans_start;
 	unsigned long		tx_bytes;
 	unsigned long		tx_packets;
 	unsigned long		tx_dropped;
 } ____cacheline_aligned_in_smp;
 /*
  * This structure defines the management hooks for network devices.
  * The following hooks can be defined; unless noted otherwise, they are
  * optional and can be filled with a null pointer.
  *
  * int (*ndo_init)(struct net_device *dev);
  *     This function is called once when network device is registered.
  *     The network device can use this to any late stage initializaton
  *     or semantic validattion. It can fail with an error code which will
  *     be propogated back to register_netdev
  *
  * void (*ndo_uninit)(struct net_device *dev);
  *     This function is called when device is unregistered or when registration
  *     fails. It is not called if init fails.
  *
  * int (*ndo_open)(struct net_device *dev);
  *     This function is called when network device transistions to the up
  *     state.
  *
  * int (*ndo_stop)(struct net_device *dev);
  *     This function is called when network device transistions to the down
  *     state.
  *
  * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  *                               struct net_device *dev);
  *	Called when a packet needs to be transmitted.
  *	Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
  *        (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
  *	Required can not be NULL.
  *
  * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
  *	Called to decide which queue to when device supports multiple
  *	transmit queues.
  *
  * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
  *	This function is called to allow device receiver to make
  *	changes to configuration when multicast or promiscious is enabled.
  *
  * void (*ndo_set_rx_mode)(struct net_device *dev);
  *	This function is called device changes address list filtering.
  *
  * void (*ndo_set_multicast_list)(struct net_device *dev);
  *	This function is called when the multicast address list changes.
  *
  * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
  *	This function  is called when the Media Access Control address
  *	needs to be changed. If this interface is not defined, the
  *	mac address can not be changed.
  *
  * int (*ndo_validate_addr)(struct net_device *dev);
  *	Test if Media Access Control address is valid for the device.
  *
  * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
  *	Called when a user request an ioctl which can't be handled by
  *	the generic interface code. If not defined ioctl's return
  *	not supported error code.
  *
  * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
  *	Used to set network devices bus interface parameters. This interface
  *	is retained for legacy reason, new devices should use the bus
  *	interface (PCI) for low level management.
  *
  * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
  *	Called when a user wants to change the Maximum Transfer Unit
  *	of a device. If not defined, any request to change MTU will
  *	will return an error.
  *
  * void (*ndo_tx_timeout)(struct net_device *dev);
  *	Callback uses when the transmitter has not made any progress
  *	for dev->watchdog ticks.
  *
  * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  *	Called when a user wants to get the network device usage
  *	statistics. If not defined, the counters in dev->stats will
  *	be used.
  *
  * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
  *	If device support VLAN receive accleration
  *	(ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
  *	when vlan groups for the device changes.  Note: grp is NULL
  *	if no vlan's groups are being used.
  *
  * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
  *	If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  *	this function is called when a VLAN id is registered.
  *
  * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
  *	If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  *	this function is called when a VLAN id is unregistered.
  *
  * void (*ndo_poll_controller)(struct net_device *dev);
  */
 #define HAVE_NET_DEVICE_OPS
 struct net_device_ops {
 	int			(*ndo_init)(struct net_device *dev);
 	void			(*ndo_uninit)(struct net_device *dev);
 	int			(*ndo_open)(struct net_device *dev);
 	int			(*ndo_stop)(struct net_device *dev);
 	netdev_tx_t		(*ndo_start_xmit) (struct sk_buff *skb,
 						   struct net_device *dev);
 	u16			(*ndo_select_queue)(struct net_device *dev,
 						    struct sk_buff *skb);
 #define HAVE_CHANGE_RX_FLAGS
 	void			(*ndo_change_rx_flags)(struct net_device *dev,
 						       int flags);
 #define HAVE_SET_RX_MODE
 	void			(*ndo_set_rx_mode)(struct net_device *dev);
 #define HAVE_MULTICAST
 	void			(*ndo_set_multicast_list)(struct net_device *dev);
 #define HAVE_SET_MAC_ADDR
 	int			(*ndo_set_mac_address)(struct net_device *dev,
 						       void *addr);
 #define HAVE_VALIDATE_ADDR
 	int			(*ndo_validate_addr)(struct net_device *dev);
 #define HAVE_PRIVATE_IOCTL
 	int			(*ndo_do_ioctl)(struct net_device *dev,
 					        struct ifreq *ifr, int cmd);
 #define HAVE_SET_CONFIG
 	int			(*ndo_set_config)(struct net_device *dev,
 					          struct ifmap *map);
 #define HAVE_CHANGE_MTU
 	int			(*ndo_change_mtu)(struct net_device *dev,
 						  int new_mtu);
 	int			(*ndo_neigh_setup)(struct net_device *dev,
 						   struct neigh_parms *);
 #define HAVE_TX_TIMEOUT
 	void			(*ndo_tx_timeout) (struct net_device *dev);
 	struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
 	void			(*ndo_vlan_rx_register)(struct net_device *dev,
 						        struct vlan_group *grp);
 	void			(*ndo_vlan_rx_add_vid)(struct net_device *dev,
 						       unsigned short vid);
 	void			(*ndo_vlan_rx_kill_vid)(struct net_device *dev,
 						        unsigned short vid);
 #ifdef CONFIG_NET_POLL_CONTROLLER
 #define HAVE_NETDEV_POLL
 	void                    (*ndo_poll_controller)(struct net_device *dev);
 #endif
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
 	int			(*ndo_fcoe_enable)(struct net_device *dev);
 	int			(*ndo_fcoe_disable)(struct net_device *dev);
 	int			(*ndo_fcoe_ddp_setup)(struct net_device *dev,
 						      u16 xid,
 						      struct scatterlist *sgl,
 						      unsigned int sgc);
 	int			(*ndo_fcoe_ddp_done)(struct net_device *dev,
 						     u16 xid);
 #define NETDEV_FCOE_WWNN 0
 #define NETDEV_FCOE_WWPN 1
 	int			(*ndo_fcoe_get_wwn)(struct net_device *dev,
 						    u64 *wwn, int type);
 #endif
 };
 /*
  *	The DEVICE structure.
  *	Actually, this whole structure is a big mistake.  It mixes I/O
  *	data with strictly "high-level" data, and it has to know about
  *	almost every data structure used in the INET module.
  *
  *	FIXME: cleanup struct net_device such that network protocol info
  *	moves out.
  */
 struct net_device {
 	/*
 	 * This is the first field of the "visible" part of this structure
 	 * (i.e. as seen by users in the "Space.c" file).  It is the name
 	 * the interface.
 	 */
 	char			name[IFNAMSIZ];
 	/* device name hash chain */
 	struct hlist_node	name_hlist;
 	/* snmp alias */
 	char 			*ifalias;
 	/*
 	 *	I/O specific fields
 	 *	FIXME: Merge these and struct ifmap into one
 	 */
 	unsigned long		mem_end;	/* shared mem end	*/
 	unsigned long		mem_start;	/* shared mem start	*/
 	unsigned long		base_addr;	/* device I/O address	*/
 	unsigned int		irq;		/* device IRQ number	*/
 	/*
 	 *	Some hardware also needs these fields, but they are not
 	 *	part of the usual set specified in Space.c.
 	 */
 	unsigned char		if_port;	/* Selectable AUI, TP,..*/
 	unsigned char		dma;		/* DMA channel		*/
 	unsigned long		state;
 	struct list_head	dev_list;
 	struct list_head	napi_list;
 	struct list_head	unreg_list;
 	/* Net device features */
 	unsigned long		features;
 #define NETIF_F_SG		1	/* Scatter/gather IO. */
 #define NETIF_F_IP_CSUM		2	/* Can checksum TCP/UDP over IPv4. */
 #define NETIF_F_NO_CSUM		4	/* Does not require checksum. F.e. loopack. */
 #define NETIF_F_HW_CSUM		8	/* Can checksum all the packets. */
 #define NETIF_F_IPV6_CSUM	16	/* Can checksum TCP/UDP over IPV6 */
 #define NETIF_F_HIGHDMA		32	/* Can DMA to high memory. */
 #define NETIF_F_FRAGLIST	64	/* Scatter/gather IO. */
 #define NETIF_F_HW_VLAN_TX	128	/* Transmit VLAN hw acceleration */
 #define NETIF_F_HW_VLAN_RX	256	/* Receive VLAN hw acceleration */
 #define NETIF_F_HW_VLAN_FILTER	512	/* Receive filtering on VLAN */
 #define NETIF_F_VLAN_CHALLENGED	1024	/* Device cannot handle VLAN packets */
 #define NETIF_F_GSO		2048	/* Enable software GSO. */
 #define NETIF_F_LLTX		4096	/* LockLess TX - deprecated. Please */
 					/* do not use LLTX in new drivers */
 #define NETIF_F_NETNS_LOCAL	8192	/* Does not change network namespaces */
 #define NETIF_F_GRO		16384	/* Generic receive offload */
 #define NETIF_F_LRO		32768	/* large receive offload */
 /* the GSO_MASK reserves bits 16 through 23 */
 #define NETIF_F_FCOE_CRC	(1 << 24) /* FCoE CRC32 */
 #define NETIF_F_SCTP_CSUM	(1 << 25) /* SCTP checksum offload */
 #define NETIF_F_FCOE_MTU	(1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
 	/* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT	16
 #define NETIF_F_GSO_MASK	0x00ff0000
 #define NETIF_F_TSO		(SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
 #define NETIF_F_UFO		(SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
 #define NETIF_F_GSO_ROBUST	(SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
 #define NETIF_F_TSO_ECN		(SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
 #define NETIF_F_TSO6		(SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
 #define NETIF_F_FSO		(SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
 	/* List of features with software fallbacks. */
 #define NETIF_F_GSO_SOFTWARE	(NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
 #define NETIF_F_GEN_CSUM	(NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
 #define NETIF_F_V4_CSUM		(NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
 #define NETIF_F_V6_CSUM		(NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
 #define NETIF_F_ALL_CSUM	(NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
 	/*
 	 * If one device supports one of these features, then enable them
 	 * for all in netdev_increment_features.
 	 */
 #define NETIF_F_ONE_FOR_ALL	(NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
 				 NETIF_F_SG | NETIF_F_HIGHDMA |		\
 				 NETIF_F_FRAGLIST)
 	/* Interface index. Unique device identifier	*/
 	int			ifindex;
 	int			iflink;
 	struct net_device_stats	stats;
 #ifdef CONFIG_WIRELESS_EXT
 	/* List of functions to handle Wireless Extensions (instead of ioctl).
 	 * See <net/iw_handler.h> for details. Jean II */
 	const struct iw_handler_def *	wireless_handlers;
 	/* Instance data managed by the core of Wireless Extensions. */
 	struct iw_public_data *	wireless_data;
 #endif
 	/* Management operations */
 	const struct net_device_ops *netdev_ops;
 	const struct ethtool_ops *ethtool_ops;
 	/* Hardware header description */
 	const struct header_ops *header_ops;
 	unsigned int		flags;	/* interface flags (a la BSD)	*/
 	unsigned short		gflags;
         unsigned short          priv_flags; /* Like 'flags' but invisible to userspace. */
 	unsigned short		padded;	/* How much padding added by alloc_netdev() */
 	unsigned char		operstate; /* RFC2863 operstate */
 	unsigned char		link_mode; /* mapping policy to operstate */
 	unsigned		mtu;	/* interface MTU value		*/
 	unsigned short		type;	/* interface hardware type	*/
 	unsigned short		hard_header_len;	/* hardware hdr length	*/
 	/* extra head- and tailroom the hardware may need, but not in all cases
 	 * can this be guaranteed, especially tailroom. Some cases also use
 	 * LL_MAX_HEADER instead to allocate the skb.
 	 */
 	unsigned short		needed_headroom;
 	unsigned short		needed_tailroom;
 	struct net_device	*master; /* Pointer to master device of a group,
 					  * which this device is member of.
 					  */
 	/* Interface address info. */
 	unsigned char		perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
 	unsigned char		addr_len;	/* hardware address length	*/
 	unsigned short          dev_id;		/* for shared network cards */
 	struct netdev_hw_addr_list	uc;	/* Secondary unicast
 						   mac addresses */
 	int			uc_promisc;
 	spinlock_t		addr_list_lock;
 	struct dev_addr_list	*mc_list;	/* Multicast mac addresses	*/
 	int			mc_count;	/* Number of installed mcasts	*/
 	unsigned int		promiscuity;
 	unsigned int		allmulti;
 	/* Protocol specific pointers */
 #ifdef CONFIG_NET_DSA
 	void			*dsa_ptr;	/* dsa specific data */
 #endif
 	void 			*atalk_ptr;	/* AppleTalk link 	*/
 	void			*ip_ptr;	/* IPv4 specific data	*/
 	void                    *dn_ptr;        /* DECnet specific data */
 	void                    *ip6_ptr;       /* IPv6 specific data */
 	void			*ec_ptr;	/* Econet specific data	*/
 	void			*ax25_ptr;	/* AX.25 specific data */
 	struct wireless_dev	*ieee80211_ptr;	/* IEEE 802.11 specific data,
 						   assign before registering */
 /*
  * Cache line mostly used on receive path (including eth_type_trans())
  */
 	unsigned long		last_rx;	/* Time of last Rx	*/
 	/* Interface address info used in eth_type_trans() */
 	unsigned char		*dev_addr;	/* hw address, (before bcast
 						   because most packets are
 						   unicast) */
 	struct netdev_hw_addr_list	dev_addrs; /* list of device
 						      hw addresses */
 	unsigned char		broadcast[MAX_ADDR_LEN];	/* hw bcast add	*/
 	struct netdev_queue	rx_queue;
 	struct netdev_queue	*_tx ____cacheline_aligned_in_smp;
 	/* Number of TX queues allocated at alloc_netdev_mq() time  */
 	unsigned int		num_tx_queues;
 	/* Number of TX queues currently active in device  */
 	unsigned int		real_num_tx_queues;
 	/* root qdisc from userspace point of view */
 	struct Qdisc		*qdisc;
 	unsigned long		tx_queue_len;	/* Max frames per queue allowed */
 	spinlock_t		tx_global_lock;
 /*
  * One part is mostly used on xmit path (device)
  */
 	/* These may be needed for future network-power-down code. */
 	/*
 	 * trans_start here is expensive for high speed devices on SMP,
 	 * please use netdev_queue->trans_start instead.
 	 */
 	unsigned long		trans_start;	/* Time (in jiffies) of last Tx	*/
 	int			watchdog_timeo; /* used by dev_watchdog() */
 	struct timer_list	watchdog_timer;
 	/* Number of references to this device */
 	atomic_t		refcnt ____cacheline_aligned_in_smp;
 	/* delayed register/unregister */
 	struct list_head	todo_list;
 	/* device index hash chain */
 	struct hlist_node	index_hlist;
 	struct net_device	*link_watch_next;
 	/* register/unregister state machine */
 	enum { NETREG_UNINITIALIZED=0,
 	       NETREG_REGISTERED,	/* completed register_netdevice */
 	       NETREG_UNREGISTERING,	/* called unregister_netdevice */
 	       NETREG_UNREGISTERED,	/* completed unregister todo */
 	       NETREG_RELEASED,		/* called free_netdev */
 	       NETREG_DUMMY,		/* dummy device for NAPI poll */
 	} reg_state;
 	/* Called from unregister, can be used to call free_netdev */
 	void (*destructor)(struct net_device *dev);
 #ifdef CONFIG_NETPOLL
 	struct netpoll_info	*npinfo;
 #endif
 #ifdef CONFIG_NET_NS
 	/* Network namespace this network device is inside */
 	struct net		*nd_net;
 #endif
 	/* mid-layer private */
 	void			*ml_priv;
 	/* bridge stuff */
 	struct net_bridge_port	*br_port;
 	/* macvlan */
 	struct macvlan_port	*macvlan_port;
 	/* GARP */
 	struct garp_port	*garp_port;
 	/* class/net/name entry */
 	struct device		dev;
 	/* space for optional device, statistics, and wireless sysfs groups */
 	const struct attribute_group *sysfs_groups[4];
 	/* rtnetlink link ops */
 	const struct rtnl_link_ops *rtnl_link_ops;
 	/* VLAN feature mask */
 	unsigned long vlan_features;
 	/* for setting kernel sock attribute on TCP connection setup */
 #define GSO_MAX_SIZE		65536
 	unsigned int		gso_max_size;
 #ifdef CONFIG_DCB
 	/* Data Center Bridging netlink ops */
 	const struct dcbnl_rtnl_ops *dcbnl_ops;
 #endif
 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
 	/* max exchange id for FCoE LRO by ddp */
 	unsigned int		fcoe_ddp_xid;
 #endif
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 #define	NETDEV_ALIGN		32
 static inline
 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
 					 unsigned int index)
 {
 	return &dev->_tx[index];
 }
 static inline void netdev_for_each_tx_queue(struct net_device *dev,
 					    void (*f)(struct net_device *,
 						      struct netdev_queue *,
 						      void *),
 					    void *arg)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++)
 		f(dev, &dev->_tx[i], arg);
 }
 /*
  * Net namespace inlines
  */
 static inline
 struct net *dev_net(const struct net_device *dev)
 {
 #ifdef CONFIG_NET_NS
 	return dev->nd_net;
 #else
 	return &init_net;
 #endif
 }
 static inline
 void dev_net_set(struct net_device *dev, struct net *net)
 {
 #ifdef CONFIG_NET_NS
 	release_net(dev->nd_net);
 	dev->nd_net = hold_net(net);
 #endif
 }
 static inline bool netdev_uses_dsa_tags(struct net_device *dev)
 {
 #ifdef CONFIG_NET_DSA_TAG_DSA
 	if (dev->dsa_ptr != NULL)
 		return dsa_uses_dsa_tags(dev->dsa_ptr);
 #endif
 	return 0;
 }
 static inline bool netdev_uses_trailer_tags(struct net_device *dev)
 {
 #ifdef CONFIG_NET_DSA_TAG_TRAILER
 	if (dev->dsa_ptr != NULL)
 		return dsa_uses_trailer_tags(dev->dsa_ptr);
 #endif
 	return 0;
 }
 /**
  *	netdev_priv - access network device private data
  *	@dev: network device
  *
  * Get network device private data
  */
 static inline void *netdev_priv(const struct net_device *dev)
 {
 	return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
 }
 /* Set the sysfs physical device reference for the network logical device
  * if set prior to registration will cause a symlink during initialization.
  */
 #define SET_NETDEV_DEV(net, pdev)	((net)->dev.parent = (pdev))
 /* Set the sysfs device type for the network logical device to allow
  * fin grained indentification of different network device types. For
  * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
  */
 #define SET_NETDEV_DEVTYPE(net, devtype)	((net)->dev.type = (devtype))
 /**
  *	netif_napi_add - initialize a napi context
  *	@dev:  network device
  *	@napi: napi context
  *	@poll: polling function
  *	@weight: default weight
  *
  * netif_napi_add() must be used to initialize a napi context prior to calling
  * *any* of the other napi related functions.
  */
 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
 		    int (*poll)(struct napi_struct *, int), int weight);
 /**
  *  netif_napi_del - remove a napi context
  *  @napi: napi context
  *
  *  netif_napi_del() removes a napi context from the network device napi list
  */
 void netif_napi_del(struct napi_struct *napi);
 struct napi_gro_cb {
 	/* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
 	void *frag0;
 	/* Length of frag0. */
 	unsigned int frag0_len;
 	/* This indicates where we are processing relative to skb->data. */
 	int data_offset;
 	/* This is non-zero if the packet may be of the same flow. */
 	int same_flow;
 	/* This is non-zero if the packet cannot be merged with the new skb. */
 	int flush;
 	/* Number of segments aggregated. */
 	int count;
 	/* Free the skb? */
 	int free;
 };
 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
 struct packet_type {
 	__be16			type;	/* This is really htons(ether_type). */
 	struct net_device	*dev;	/* NULL is wildcarded here	     */
 	int			(*func) (struct sk_buff *,
 					 struct net_device *,
 					 struct packet_type *,
 					 struct net_device *);
 	struct sk_buff		*(*gso_segment)(struct sk_buff *skb,
 						int features);
 	int			(*gso_send_check)(struct sk_buff *skb);
 	struct sk_buff		**(*gro_receive)(struct sk_buff **head,
 					       struct sk_buff *skb);
 	int			(*gro_complete)(struct sk_buff *skb);
 	void			*af_packet_priv;
 	struct list_head	list;
 };
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 extern rwlock_t				dev_base_lock;		/* Device list lock */
 #define for_each_netdev(net, d)		\
 		list_for_each_entry(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_rcu(net, d)		\
 		list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_safe(net, d, n)	\
 		list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_continue(net, d)		\
 		list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
+#define for_each_netdev_continue_rcu(net, d)		\
+	list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
 #define net_device_entry(lh)	list_entry(lh, struct net_device, dev_list)
 static inline struct net_device *next_net_device(struct net_device *dev)
 {
 	struct list_head *lh;
 	struct net *net;
 	net = dev_net(dev);
 	lh = dev->dev_list.next;
 	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
 }
 static inline struct net_device *first_net_device(struct net *net)
 {
 	return list_empty(&net->dev_base_head) ? NULL :
 		net_device_entry(net->dev_base_head.next);
 }
 extern int 			netdev_boot_setup_check(struct net_device *dev);
 extern unsigned long		netdev_boot_base(const char *prefix, int unit);
 extern struct net_device    *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
 extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
 extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
 extern void		dev_add_pack(struct packet_type *pt);
 extern void		dev_remove_pack(struct packet_type *pt);
 extern void		__dev_remove_pack(struct packet_type *pt);
 extern struct net_device	*dev_get_by_flags(struct net *net, unsigned short flags,
 						  unsigned short mask);
 extern struct net_device	*dev_get_by_name(struct net *net, const char *name);
 extern struct net_device	*dev_get_by_name_rcu(struct net *net, const char *name);
 extern struct net_device	*__dev_get_by_name(struct net *net, const char *name);
 extern int		dev_alloc_name(struct net_device *dev, const char *name);
 extern int		dev_open(struct net_device *dev);
 extern int		dev_close(struct net_device *dev);
 extern void		dev_disable_lro(struct net_device *dev);
 extern int		dev_queue_xmit(struct sk_buff *skb);
 extern int		register_netdevice(struct net_device *dev);
 extern void		unregister_netdevice_queue(struct net_device *dev,
 						   struct list_head *head);
 extern void		unregister_netdevice_many(struct list_head *head);
 static inline void unregister_netdevice(struct net_device *dev)
 {
 	unregister_netdevice_queue(dev, NULL);
 }
 extern void		free_netdev(struct net_device *dev);
 extern void		synchronize_net(void);
 extern int 		register_netdevice_notifier(struct notifier_block *nb);
 extern int		unregister_netdevice_notifier(struct notifier_block *nb);
 extern int		init_dummy_netdev(struct net_device *dev);
 extern void		netdev_resync_ops(struct net_device *dev);
 extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
 extern struct net_device	*dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device	*__dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device	*dev_get_by_index_rcu(struct net *net, int ifindex);
 extern int		dev_restart(struct net_device *dev);
 #ifdef CONFIG_NETPOLL_TRAP
 extern int		netpoll_trap(void);
 #endif
 extern int	       skb_gro_receive(struct sk_buff **head,
 				       struct sk_buff *skb);
 extern void	       skb_gro_reset_offset(struct sk_buff *skb);
 static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
 {
 	return NAPI_GRO_CB(skb)->data_offset;
 }
 static inline unsigned int skb_gro_len(const struct sk_buff *skb)
 {
 	return skb->len - NAPI_GRO_CB(skb)->data_offset;
 }
 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
 {
 	NAPI_GRO_CB(skb)->data_offset += len;
 }
 static inline void *skb_gro_header_fast(struct sk_buff *skb,
 					unsigned int offset)
 {
 	return NAPI_GRO_CB(skb)->frag0 + offset;
 }
 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
 {
 	return NAPI_GRO_CB(skb)->frag0_len < hlen;
 }
 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
 					unsigned int offset)
 {
 	NAPI_GRO_CB(skb)->frag0 = NULL;
 	NAPI_GRO_CB(skb)->frag0_len = 0;
 	return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
 }
 static inline void *skb_gro_mac_header(struct sk_buff *skb)
 {
 	return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
 }
 static inline void *skb_gro_network_header(struct sk_buff *skb)
 {
 	return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
 	       skb_network_offset(skb);
 }
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
 				  unsigned short type,
 				  const void *daddr, const void *saddr,
 				  unsigned len)
 {
 	if (!dev->header_ops || !dev->header_ops->create)
 		return 0;
 	return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
 }
 static inline int dev_parse_header(const struct sk_buff *skb,
 				   unsigned char *haddr)
 {
 	const struct net_device *dev = skb->dev;
 	if (!dev->header_ops || !dev->header_ops->parse)
 		return 0;
 	return dev->header_ops->parse(skb, haddr);
 }
 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
 extern int		register_gifconf(unsigned int family, gifconf_func_t * gifconf);
 static inline int unregister_gifconf(unsigned int family)
 {
 	return register_gifconf(family, NULL);
 }
 /*
  * Incoming packets are placed on per-cpu queues so that
  * no locking is needed.
  */
 struct softnet_data {
 	struct Qdisc		*output_queue;
 	struct sk_buff_head	input_pkt_queue;
 	struct list_head	poll_list;
 	struct sk_buff		*completion_queue;
 	struct napi_struct	backlog;
 };
 DECLARE_PER_CPU(struct softnet_data,softnet_data);
 #define HAVE_NETIF_QUEUE
 extern void __netif_schedule(struct Qdisc *q);
 static inline void netif_schedule_queue(struct netdev_queue *txq)
 {
 	if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
 		__netif_schedule(txq->qdisc);
 }
 static inline void netif_tx_schedule_all(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++)
 		netif_schedule_queue(netdev_get_tx_queue(dev, i));
 }
 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
 {
 	clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
 }
 /**
  *	netif_start_queue - allow transmit
  *	@dev: network device
  *
  *	Allow upper layers to call the device hard_start_xmit routine.
  */
 static inline void netif_start_queue(struct net_device *dev)
 {
 	netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
 }
 static inline void netif_tx_start_all_queues(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		netif_tx_start_queue(txq);
 	}
 }
 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
 {
 #ifdef CONFIG_NETPOLL_TRAP
 	if (netpoll_trap()) {
 		netif_tx_start_queue(dev_queue);
 		return;
 	}
 #endif
 	if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
 		__netif_schedule(dev_queue->qdisc);
 }
 /**
  *	netif_wake_queue - restart transmit
  *	@dev: network device
  *
  *	Allow upper layers to call the device hard_start_xmit routine.
  *	Used for flow control when transmit resources are available.
  */
 static inline void netif_wake_queue(struct net_device *dev)
 {
 	netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
 }
 static inline void netif_tx_wake_all_queues(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		netif_tx_wake_queue(txq);
 	}
 }
 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
 {
 	set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
 }
 /**
  *	netif_stop_queue - stop transmitted packets
  *	@dev: network device
  *
  *	Stop upper layers calling the device hard_start_xmit routine.
  *	Used for flow control when transmit resources are unavailable.
  */
 static inline void netif_stop_queue(struct net_device *dev)
 {
 	netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
 }
 static inline void netif_tx_stop_all_queues(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		netif_tx_stop_queue(txq);
 	}
 }
 static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 {
 	return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
 }
 /**
  *	netif_queue_stopped - test if transmit queue is flowblocked
  *	@dev: network device
  *
  *	Test if transmit queue on device is currently unable to send.
  */
 static inline int netif_queue_stopped(const struct net_device *dev)
 {
 	return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
 }
 static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)
 {
 	return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);
 }
 /**
  *	netif_running - test if up
  *	@dev: network device
  *
  *	Test if the device has been brought up.
  */
 static inline int netif_running(const struct net_device *dev)
 {
 	return test_bit(__LINK_STATE_START, &dev->state);
 }
 /*
  * Routines to manage the subqueues on a device.  We only need start
  * stop, and a check if it's stopped.  All other device management is
  * done at the overall netdevice level.
  * Also test the device if we're multiqueue.
  */
 /**
  *	netif_start_subqueue - allow sending packets on subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Start individual transmit queue of a device with multiple transmit queues.
  */
 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 	netif_tx_start_queue(txq);
 }
 /**
  *	netif_stop_subqueue - stop sending packets on subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Stop individual transmit queue of a device with multiple transmit queues.
  */
 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 #ifdef CONFIG_NETPOLL_TRAP
 	if (netpoll_trap())
 		return;
 #endif
 	netif_tx_stop_queue(txq);
 }
 /**
  *	netif_subqueue_stopped - test status of subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Check individual transmit queue of a device with multiple transmit queues.
  */
 static inline int __netif_subqueue_stopped(const struct net_device *dev,
 					 u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 	return netif_tx_queue_stopped(txq);
 }
 static inline int netif_subqueue_stopped(const struct net_device *dev,
 					 struct sk_buff *skb)
 {
 	return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
 }
 /**
  *	netif_wake_subqueue - allow sending packets on subqueue
  *	@dev: network device
  *	@queue_index: sub queue index
  *
  * Resume individual transmit queue of a device with multiple transmit queues.
  */
 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
 {
 	struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 #ifdef CONFIG_NETPOLL_TRAP
 	if (netpoll_trap())
 		return;
 #endif
 	if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
 		__netif_schedule(txq->qdisc);
 }
 /**
  *	netif_is_multiqueue - test if device has multiple transmit queues
  *	@dev: network device
  *
  * Check if device has multiple transmit queues
  */
 static inline int netif_is_multiqueue(const struct net_device *dev)
 {
 	return (dev->num_tx_queues > 1);
 }
 /* Use this variant when it is known for sure that it
  * is executing from hardware interrupt context or with hardware interrupts
  * disabled.
  */
 extern void dev_kfree_skb_irq(struct sk_buff *skb);
 /* Use this variant in places where it could be invoked
  * from either hardware interrupt or other context, with hardware interrupts
  * either disabled or enabled.
  */
 extern void dev_kfree_skb_any(struct sk_buff *skb);
 #define HAVE_NETIF_RX 1
 extern int		netif_rx(struct sk_buff *skb);
 extern int		netif_rx_ni(struct sk_buff *skb);
 #define HAVE_NETIF_RECEIVE_SKB 1
 extern int		netif_receive_skb(struct sk_buff *skb);
 extern void		napi_gro_flush(struct napi_struct *napi);
 extern gro_result_t	dev_gro_receive(struct napi_struct *napi,
 					struct sk_buff *skb);
 extern gro_result_t	napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
 extern gro_result_t	napi_gro_receive(struct napi_struct *napi,
 					 struct sk_buff *skb);
 extern void		napi_reuse_skb(struct napi_struct *napi,
 				       struct sk_buff *skb);
 extern struct sk_buff *	napi_get_frags(struct napi_struct *napi);
 extern gro_result_t	napi_frags_finish(struct napi_struct *napi,
 					  struct sk_buff *skb,
 					  gro_result_t ret);
 extern struct sk_buff *	napi_frags_skb(struct napi_struct *napi);
 extern gro_result_t	napi_gro_frags(struct napi_struct *napi);
 static inline void napi_free_frags(struct napi_struct *napi)
 {
 	kfree_skb(napi->skb);
 	napi->skb = NULL;
 }
 extern void		netif_nit_deliver(struct sk_buff *skb);
 extern int		dev_valid_name(const char *name);
 extern int		dev_ioctl(struct net *net, unsigned int cmd, void __user *);
 extern int		dev_ethtool(struct net *net, struct ifreq *);
 extern unsigned		dev_get_flags(const struct net_device *);
 extern int		dev_change_flags(struct net_device *, unsigned);
 extern int		dev_change_name(struct net_device *, const char *);
 extern int		dev_set_alias(struct net_device *, const char *, size_t);
 extern int		dev_change_net_namespace(struct net_device *,
 						 struct net *, const char *);
 extern int		dev_set_mtu(struct net_device *, int);
 extern int		dev_set_mac_address(struct net_device *,
 					    struct sockaddr *);
 extern int		dev_hard_start_xmit(struct sk_buff *skb,
 					    struct net_device *dev,
 					    struct netdev_queue *txq);
 extern int		netdev_budget;
 /* Called by rtnetlink.c:rtnl_unlock() */
 extern void netdev_run_todo(void);
 /**
  *	dev_put - release reference to device
  *	@dev: network device
  *
  * Release reference to device to allow it to be freed.
  */
 static inline void dev_put(struct net_device *dev)
 {
 	atomic_dec(&dev->refcnt);
 }
 /**
  *	dev_hold - get reference to device
  *	@dev: network device
  *
  * Hold reference to device to keep it from being freed.
  */
 static inline void dev_hold(struct net_device *dev)
 {
 	atomic_inc(&dev->refcnt);
 }
 /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  * and _off may be called from IRQ context, but it is caller
  * who is responsible for serialization of these calls.
  *
  * The name carrier is inappropriate, these functions should really be
  * called netif_lowerlayer_*() because they represent the state of any
  * kind of lower layer not just hardware media.
  */
 extern void linkwatch_fire_event(struct net_device *dev);
 /**
  *	netif_carrier_ok - test if carrier present
  *	@dev: network device
  *
  * Check if carrier is present on device
  */
 static inline int netif_carrier_ok(const struct net_device *dev)
 {
 	return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
 }
 extern unsigned long dev_trans_start(struct net_device *dev);
 extern void __netdev_watchdog_up(struct net_device *dev);
 extern void netif_carrier_on(struct net_device *dev);
 extern void netif_carrier_off(struct net_device *dev);
 /**
  *	netif_dormant_on - mark device as dormant.
  *	@dev: network device
  *
  * Mark device as dormant (as per RFC2863).
  *
  * The dormant state indicates that the relevant interface is not
  * actually in a condition to pass packets (i.e., it is not 'up') but is
  * in a "pending" state, waiting for some external event.  For "on-
  * demand" interfaces, this new state identifies the situation where the
  * interface is waiting for events to place it in the up state.
  *
  */
 static inline void netif_dormant_on(struct net_device *dev)
 {
 	if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
 		linkwatch_fire_event(dev);
 }
 /**
  *	netif_dormant_off - set device as not dormant.
  *	@dev: network device
  *
  * Device is not in dormant state.
  */
 static inline void netif_dormant_off(struct net_device *dev)
 {
 	if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
 		linkwatch_fire_event(dev);
 }
 /**
  *	netif_dormant - test if carrier present
  *	@dev: network device
  *
  * Check if carrier is present on device
  */
 static inline int netif_dormant(const struct net_device *dev)
 {
 	return test_bit(__LINK_STATE_DORMANT, &dev->state);
 }
 /**
  *	netif_oper_up - test if device is operational
  *	@dev: network device
  *
  * Check if carrier is operational
  */
 static inline int netif_oper_up(const struct net_device *dev)
 {
 	return (dev->operstate == IF_OPER_UP ||
 		dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
 }
 /**
  *	netif_device_present - is device available or removed
  *	@dev: network device
  *
  * Check if device has not been removed from system.
  */
 static inline int netif_device_present(struct net_device *dev)
 {
 	return test_bit(__LINK_STATE_PRESENT, &dev->state);
 }
 extern void netif_device_detach(struct net_device *dev);
 extern void netif_device_attach(struct net_device *dev);
 /*
  * Network interface message level settings
  */
 #define HAVE_NETIF_MSG 1
 enum {
 	NETIF_MSG_DRV		= 0x0001,
 	NETIF_MSG_PROBE		= 0x0002,
 	NETIF_MSG_LINK		= 0x0004,
 	NETIF_MSG_TIMER		= 0x0008,
 	NETIF_MSG_IFDOWN	= 0x0010,
 	NETIF_MSG_IFUP		= 0x0020,
 	NETIF_MSG_RX_ERR	= 0x0040,
 	NETIF_MSG_TX_ERR	= 0x0080,
 	NETIF_MSG_TX_QUEUED	= 0x0100,
 	NETIF_MSG_INTR		= 0x0200,
 	NETIF_MSG_TX_DONE	= 0x0400,
 	NETIF_MSG_RX_STATUS	= 0x0800,
 	NETIF_MSG_PKTDATA	= 0x1000,
 	NETIF_MSG_HW		= 0x2000,
 	NETIF_MSG_WOL		= 0x4000,
 };
 #define netif_msg_drv(p)	((p)->msg_enable & NETIF_MSG_DRV)
 #define netif_msg_probe(p)	((p)->msg_enable & NETIF_MSG_PROBE)
 #define netif_msg_link(p)	((p)->msg_enable & NETIF_MSG_LINK)
 #define netif_msg_timer(p)	((p)->msg_enable & NETIF_MSG_TIMER)
 #define netif_msg_ifdown(p)	((p)->msg_enable & NETIF_MSG_IFDOWN)
 #define netif_msg_ifup(p)	((p)->msg_enable & NETIF_MSG_IFUP)
 #define netif_msg_rx_err(p)	((p)->msg_enable & NETIF_MSG_RX_ERR)
 #define netif_msg_tx_err(p)	((p)->msg_enable & NETIF_MSG_TX_ERR)
 #define netif_msg_tx_queued(p)	((p)->msg_enable & NETIF_MSG_TX_QUEUED)
 #define netif_msg_intr(p)	((p)->msg_enable & NETIF_MSG_INTR)
 #define netif_msg_tx_done(p)	((p)->msg_enable & NETIF_MSG_TX_DONE)
 #define netif_msg_rx_status(p)	((p)->msg_enable & NETIF_MSG_RX_STATUS)
 #define netif_msg_pktdata(p)	((p)->msg_enable & NETIF_MSG_PKTDATA)
 #define netif_msg_hw(p)		((p)->msg_enable & NETIF_MSG_HW)
 #define netif_msg_wol(p)	((p)->msg_enable & NETIF_MSG_WOL)
 static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
 {
 	/* use default */
 	if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
 		return default_msg_enable_bits;
 	if (debug_value == 0)	/* no output */
 		return 0;
 	/* set low N bits */
 	return (1 << debug_value) - 1;
 }
 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
 {
 	spin_lock(&txq->_xmit_lock);
 	txq->xmit_lock_owner = cpu;
 }
 static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
 {
 	spin_lock_bh(&txq->_xmit_lock);
 	txq->xmit_lock_owner = smp_processor_id();
 }
 static inline int __netif_tx_trylock(struct netdev_queue *txq)
 {
 	int ok = spin_trylock(&txq->_xmit_lock);
 	if (likely(ok))
 		txq->xmit_lock_owner = smp_processor_id();
 	return ok;
 }
 static inline void __netif_tx_unlock(struct netdev_queue *txq)
 {
 	txq->xmit_lock_owner = -1;
 	spin_unlock(&txq->_xmit_lock);
 }
 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
 {
 	txq->xmit_lock_owner = -1;
 	spin_unlock_bh(&txq->_xmit_lock);
 }
 static inline void txq_trans_update(struct netdev_queue *txq)
 {
 	if (txq->xmit_lock_owner != -1)
 		txq->trans_start = jiffies;
 }
 /**
  *	netif_tx_lock - grab network device transmit lock
  *	@dev: network device
  *
  * Get network device transmit lock
  */
 static inline void netif_tx_lock(struct net_device *dev)
 {
 	unsigned int i;
 	int cpu;
 	spin_lock(&dev->tx_global_lock);
 	cpu = smp_processor_id();
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		/* We are the only thread of execution doing a
 		 * freeze, but we have to grab the _xmit_lock in
 		 * order to synchronize with threads which are in
 		 * the ->hard_start_xmit() handler and already
 		 * checked the frozen bit.
 		 */
 		__netif_tx_lock(txq, cpu);
 		set_bit(__QUEUE_STATE_FROZEN, &txq->state);
 		__netif_tx_unlock(txq);
 	}
 }
 static inline void netif_tx_lock_bh(struct net_device *dev)
 {
 	local_bh_disable();
 	netif_tx_lock(dev);
 }
 static inline void netif_tx_unlock(struct net_device *dev)
 {
 	unsigned int i;
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		/* No need to grab the _xmit_lock here.  If the
 		 * queue is not stopped for another reason, we
 		 * force a schedule.
 		 */
 		clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
 		netif_schedule_queue(txq);
 	}
 	spin_unlock(&dev->tx_global_lock);
 }
 static inline void netif_tx_unlock_bh(struct net_device *dev)
 {
 	netif_tx_unlock(dev);
 	local_bh_enable();
 }
 #define HARD_TX_LOCK(dev, txq, cpu) {			\
 	if ((dev->features & NETIF_F_LLTX) == 0) {	\
 		__netif_tx_lock(txq, cpu);		\
 	}						\
 }
 #define HARD_TX_UNLOCK(dev, txq) {			\
 	if ((dev->features & NETIF_F_LLTX) == 0) {	\
 		__netif_tx_unlock(txq);			\
 	}						\
 }
 static inline void netif_tx_disable(struct net_device *dev)
 {
 	unsigned int i;
 	int cpu;
 	local_bh_disable();
 	cpu = smp_processor_id();
 	for (i = 0; i < dev->num_tx_queues; i++) {
 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
 		__netif_tx_lock(txq, cpu);
 		netif_tx_stop_queue(txq);
 		__netif_tx_unlock(txq);
 	}
 	local_bh_enable();
 }
 static inline void netif_addr_lock(struct net_device *dev)
 {
 	spin_lock(&dev->addr_list_lock);
 }
 static inline void netif_addr_lock_bh(struct net_device *dev)
 {
 	spin_lock_bh(&dev->addr_list_lock);
 }
 static inline void netif_addr_unlock(struct net_device *dev)
 {
 	spin_unlock(&dev->addr_list_lock);
 }
 static inline void netif_addr_unlock_bh(struct net_device *dev)
 {
 	spin_unlock_bh(&dev->addr_list_lock);
 }
 /*
  * dev_addrs walker. Should be used only for read access. Call with
  * rcu_read_lock held.
  */
 #define for_each_dev_addr(dev, ha) \
 		list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
 extern void		ether_setup(struct net_device *dev);
 /* Support for loadable net-drivers */
 extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
 				       void (*setup)(struct net_device *),
 				       unsigned int queue_count);
 #define alloc_netdev(sizeof_priv, name, setup) \
 	alloc_netdev_mq(sizeof_priv, name, setup, 1)
 extern int		register_netdev(struct net_device *dev);
 extern void		unregister_netdev(struct net_device *dev);
 /* Functions used for device addresses handling */
 extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
 			unsigned char addr_type);
 extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
 			unsigned char addr_type);
 extern int dev_addr_add_multiple(struct net_device *to_dev,
 				 struct net_device *from_dev,
 				 unsigned char addr_type);
 extern int dev_addr_del_multiple(struct net_device *to_dev,
 				 struct net_device *from_dev,
 				 unsigned char addr_type);
 /* Functions used for secondary unicast and multicast support */
 extern void		dev_set_rx_mode(struct net_device *dev);
 extern void		__dev_set_rx_mode(struct net_device *dev);
 extern int		dev_unicast_delete(struct net_device *dev, void *addr);
 extern int		dev_unicast_add(struct net_device *dev, void *addr);
 extern int		dev_unicast_sync(struct net_device *to, struct net_device *from);
 extern void		dev_unicast_unsync(struct net_device *to, struct net_device *from);
 extern int 		dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
 extern int		dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
 extern int		dev_mc_sync(struct net_device *to, struct net_device *from);
 extern void		dev_mc_unsync(struct net_device *to, struct net_device *from);
 extern int 		__dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
 extern int		__dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
 extern int		__dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
 extern void		__dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
 extern int		dev_set_promiscuity(struct net_device *dev, int inc);
 extern int		dev_set_allmulti(struct net_device *dev, int inc);
 extern void		netdev_state_change(struct net_device *dev);
 extern void		netdev_bonding_change(struct net_device *dev,
 					      unsigned long event);
 extern void		netdev_features_change(struct net_device *dev);
 /* Load a device via the kmod */
 extern void		dev_load(struct net *net, const char *name);
 extern void		dev_mcast_init(void);
 extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
 extern int		netdev_max_backlog;
 extern int		weight_p;
 extern int		netdev_set_master(struct net_device *dev, struct net_device *master);
 extern int skb_checksum_help(struct sk_buff *skb);
 extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
 #ifdef CONFIG_BUG
 extern void netdev_rx_csum_fault(struct net_device *dev);
 #else
 static inline void netdev_rx_csum_fault(struct net_device *dev)
 {
 }
 #endif
 /* rx skb timestamps */
 extern void		net_enable_timestamp(void);
 extern void		net_disable_timestamp(void);
 #ifdef CONFIG_PROC_FS
 extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
 extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
 extern void dev_seq_stop(struct seq_file *seq, void *v);
 #endif
 extern int netdev_class_create_file(struct class_attribute *class_attr);
 extern void netdev_class_remove_file(struct class_attribute *class_attr);
 extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
 extern void linkwatch_run_queue(void);
 unsigned long netdev_increment_features(unsigned long all, unsigned long one,
 					unsigned long mask);
 unsigned long netdev_fix_features(unsigned long features, const char *name);
 static inline int net_gso_ok(int features, int gso_type)
 {
 	int feature = gso_type << NETIF_F_GSO_SHIFT;
 	return (features & feature) == feature;
 }
 static inline int skb_gso_ok(struct sk_buff *skb, int features)
 {
 	return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
 	       (!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));
 }
 static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
 {
 	return skb_is_gso(skb) &&
 	       (!skb_gso_ok(skb, dev->features) ||
 		unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
 }
 static inline void netif_set_gso_max_size(struct net_device *dev,
 					  unsigned int size)
 {
 	dev->gso_max_size = size;
 }
 static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
 					      struct net_device *master)
 {
 	if (skb->pkt_type == PACKET_HOST) {
 		u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
 		memcpy(dest, master->dev_addr, ETH_ALEN);
 	}
 }
 /* On bonding slaves other than the currently active slave, suppress
  * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
  * ARP on active-backup slaves with arp_validate enabled.
  */
 static inline int skb_bond_should_drop(struct sk_buff *skb)
 {
 	struct net_device *dev = skb->dev;
 	struct net_device *master = dev->master;
 	if (master) {
 		if (master->priv_flags & IFF_MASTER_ARPMON)
 			dev->last_rx = jiffies;
 		if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
 			/* Do address unmangle. The local destination address
 			 * will be always the one master has. Provides the right
 			 * functionality in a bridge.
 			 */
 			skb_bond_set_mac_by_master(skb, master);
 		}
 		if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
 			if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
 			    skb->protocol == __cpu_to_be16(ETH_P_ARP))
 				return 0;
 			if (master->priv_flags & IFF_MASTER_ALB) {
 				if (skb->pkt_type != PACKET_BROADCAST &&
 				    skb->pkt_type != PACKET_MULTICAST)
 					return 0;
 			}
 			if (master->priv_flags & IFF_MASTER_8023AD &&
 			    skb->protocol == __cpu_to_be16(ETH_P_SLOW))
 				return 0;
 			return 1;
 		}
 	}
 	return 0;
 }
 extern struct pernet_operations __net_initdata loopback_net_ops;
 static inline int dev_ethtool_get_settings(struct net_device *dev,
 					   struct ethtool_cmd *cmd)
 {
 	if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
 		return -EOPNOTSUPP;
 	return dev->ethtool_ops->get_settings(dev, cmd);
 }
 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
 {
 	if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
 		return 0;
 	return dev->ethtool_ops->get_rx_csum(dev);
 }
 static inline u32 dev_ethtool_get_flags(struct net_device *dev)
 {
 	if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
 		return 0;
 	return dev->ethtool_ops->get_flags(dev);
 }
 #endif /* __KERNEL__ */
 #endif	/* _LINUX_NETDEVICE_H */

 #ifndef _LINUX_RCULIST_H
 #define _LINUX_RCULIST_H
 #ifdef __KERNEL__
 /*
  * RCU-protected list version
  */
 #include <linux/list.h>
 #include <linux/rcupdate.h>
 /*
  * Insert a new entry between two known consecutive entries.
  *
  * This is only for internal list manipulation where we know
  * the prev/next entries already!
  */
 static inline void __list_add_rcu(struct list_head *new,
 		struct list_head *prev, struct list_head *next)
 {
 	new->next = next;
 	new->prev = prev;
 	rcu_assign_pointer(prev->next, new);
 	next->prev = new;
 }
 /**
  * list_add_rcu - add a new entry to rcu-protected list
  * @new: new entry to be added
  * @head: list head to add it after
  *
  * Insert a new entry after the specified head.
  * This is good for implementing stacks.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as list_add_rcu()
  * or list_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * list_for_each_entry_rcu().
  */
 static inline void list_add_rcu(struct list_head *new, struct list_head *head)
 {
 	__list_add_rcu(new, head, head->next);
 }
 /**
  * list_add_tail_rcu - add a new entry to rcu-protected list
  * @new: new entry to be added
  * @head: list head to add it before
  *
  * Insert a new entry before the specified head.
  * This is useful for implementing queues.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as list_add_tail_rcu()
  * or list_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * list_for_each_entry_rcu().
  */
 static inline void list_add_tail_rcu(struct list_head *new,
 					struct list_head *head)
 {
 	__list_add_rcu(new, head->prev, head);
 }
 /**
  * list_del_rcu - deletes entry from list without re-initialization
  * @entry: the element to delete from the list.
  *
  * Note: list_empty() on entry does not return true after this,
  * the entry is in an undefined state. It is useful for RCU based
  * lockfree traversal.
  *
  * In particular, it means that we can not poison the forward
  * pointers that may still be used for walking the list.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as list_del_rcu()
  * or list_add_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * list_for_each_entry_rcu().
  *
  * Note that the caller is not permitted to immediately free
  * the newly deleted entry.  Instead, either synchronize_rcu()
  * or call_rcu() must be used to defer freeing until an RCU
  * grace period has elapsed.
  */
 static inline void list_del_rcu(struct list_head *entry)
 {
 	__list_del(entry->prev, entry->next);
 	entry->prev = LIST_POISON2;
 }
 /**
  * hlist_del_init_rcu - deletes entry from hash list with re-initialization
  * @n: the element to delete from the hash list.
  *
  * Note: list_unhashed() on the node return true after this. It is
  * useful for RCU based read lockfree traversal if the writer side
  * must know if the list entry is still hashed or already unhashed.
  *
  * In particular, it means that we can not poison the forward pointers
  * that may still be used for walking the hash list and we can only
  * zero the pprev pointer so list_unhashed() will return true after
  * this.
  *
  * The caller must take whatever precautions are necessary (such as
  * holding appropriate locks) to avoid racing with another
  * list-mutation primitive, such as hlist_add_head_rcu() or
  * hlist_del_rcu(), running on this same list.  However, it is
  * perfectly legal to run concurrently with the _rcu list-traversal
  * primitives, such as hlist_for_each_entry_rcu().
  */
 static inline void hlist_del_init_rcu(struct hlist_node *n)
 {
 	if (!hlist_unhashed(n)) {
 		__hlist_del(n);
 		n->pprev = NULL;
 	}
 }
 /**
  * list_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
  *
  * The @old entry will be replaced with the @new entry atomically.
  * Note: @old should not be empty.
  */
 static inline void list_replace_rcu(struct list_head *old,
 				struct list_head *new)
 {
 	new->next = old->next;
 	new->prev = old->prev;
 	rcu_assign_pointer(new->prev->next, new);
 	new->next->prev = new;
 	old->prev = LIST_POISON2;
 }
 /**
  * list_splice_init_rcu - splice an RCU-protected list into an existing list.
  * @list:	the RCU-protected list to splice
  * @head:	the place in the list to splice the first list into
  * @sync:	function to sync: synchronize_rcu(), synchronize_sched(), ...
  *
  * @head can be RCU-read traversed concurrently with this function.
  *
  * Note that this function blocks.
  *
  * Important note: the caller must take whatever action is necessary to
  *	prevent any other updates to @head.  In principle, it is possible
  *	to modify the list as soon as sync() begins execution.
  *	If this sort of thing becomes necessary, an alternative version
  *	based on call_rcu() could be created.  But only if -really-
  *	needed -- there is no shortage of RCU API members.
  */
 static inline void list_splice_init_rcu(struct list_head *list,
 					struct list_head *head,
 					void (*sync)(void))
 {
 	struct list_head *first = list->next;
 	struct list_head *last = list->prev;
 	struct list_head *at = head->next;
 	if (list_empty(head))
 		return;
 	/* "first" and "last" tracking list, so initialize it. */
 	INIT_LIST_HEAD(list);
 	/*
 	 * At this point, the list body still points to the source list.
 	 * Wait for any readers to finish using the list before splicing
 	 * the list body into the new list.  Any new readers will see
 	 * an empty list.
 	 */
 	sync();
 	/*
 	 * Readers are finished with the source list, so perform splice.
 	 * The order is important if the new list is global and accessible
 	 * to concurrent RCU readers.  Note that RCU readers are not
 	 * permitted to traverse the prev pointers without excluding
 	 * this function.
 	 */
 	last->next = at;
 	rcu_assign_pointer(head->next, first);
 	first->prev = head;
 	at->prev = last;
 }
 /**
  * list_entry_rcu - get the struct for this entry
  * @ptr:        the &struct list_head pointer.
  * @type:       the type of the struct this is embedded in.
  * @member:     the name of the list_struct within the struct.
  *
  * This primitive may safely run concurrently with the _rcu list-mutation
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
  */
 #define list_entry_rcu(ptr, type, member) \
 	container_of(rcu_dereference(ptr), type, member)
 /**
  * list_first_entry_rcu - get the first element from a list
  * @ptr:        the list head to take the element from.
  * @type:       the type of the struct this is embedded in.
  * @member:     the name of the list_struct within the struct.
  *
  * Note, that list is expected to be not empty.
  *
  * This primitive may safely run concurrently with the _rcu list-mutation
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
  */
 #define list_first_entry_rcu(ptr, type, member) \
 	list_entry_rcu((ptr)->next, type, member)
 #define __list_for_each_rcu(pos, head) \
 	for (pos = rcu_dereference((head)->next); \
 		pos != (head); \
 		pos = rcu_dereference(pos->next))
 /**
  * list_for_each_entry_rcu	-	iterate over rcu list of given type
  * @pos:	the type * to use as a loop cursor.
  * @head:	the head for your list.
  * @member:	the name of the list_struct within the struct.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_entry_rcu(pos, head, member) \
 	for (pos = list_entry_rcu((head)->next, typeof(*pos), member); \
 		prefetch(pos->member.next), &pos->member != (head); \
 		pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 /**
  * list_for_each_continue_rcu
  * @pos:	the &struct list_head to use as a loop cursor.
  * @head:	the head for your list.
  *
  * Iterate over an rcu-protected list, continuing after current point.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_continue_rcu(pos, head) \
 	for ((pos) = rcu_dereference((pos)->next); \
 		prefetch((pos)->next), (pos) != (head); \
 		(pos) = rcu_dereference((pos)->next))
 /**
+ * list_for_each_entry_continue_rcu - continue iteration over list of given type
+ * @pos:	the type * to use as a loop cursor.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Continue to iterate over list of given type, continuing after
+ * the current position.
+ */
+#define list_for_each_entry_continue_rcu(pos, head, member) 		\
+	for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \
+	     prefetch(pos->member.next), &pos->member != (head);	\
+	     pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
+/**
  * hlist_del_rcu - deletes entry from hash list without re-initialization
  * @n: the element to delete from the hash list.
  *
  * Note: list_unhashed() on entry does not return true after this,
  * the entry is in an undefined state. It is useful for RCU based
  * lockfree traversal.
  *
  * In particular, it means that we can not poison the forward
  * pointers that may still be used for walking the hash list.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry().
  */
 static inline void hlist_del_rcu(struct hlist_node *n)
 {
 	__hlist_del(n);
 	n->pprev = LIST_POISON2;
 }
 /**
  * hlist_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
  *
  * The @old entry will be replaced with the @new entry atomically.
  */
 static inline void hlist_replace_rcu(struct hlist_node *old,
 					struct hlist_node *new)
 {
 	struct hlist_node *next = old->next;
 	new->next = next;
 	new->pprev = old->pprev;
 	rcu_assign_pointer(*new->pprev, new);
 	if (next)
 		new->next->pprev = &new->next;
 	old->pprev = LIST_POISON2;
 }
 /**
  * hlist_add_head_rcu
  * @n: the element to add to the hash list.
  * @h: the list to add to.
  *
  * Description:
  * Adds the specified element to the specified hlist,
  * while permitting racing traversals.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.  Regardless of the type of CPU, the
  * list-traversal primitive must be guarded by rcu_read_lock().
  */
 static inline void hlist_add_head_rcu(struct hlist_node *n,
 					struct hlist_head *h)
 {
 	struct hlist_node *first = h->first;
 	n->next = first;
 	n->pprev = &h->first;
 	rcu_assign_pointer(h->first, n);
 	if (first)
 		first->pprev = &n->next;
 }
 /**
  * hlist_add_before_rcu
  * @n: the new element to add to the hash list.
  * @next: the existing element to add the new element before.
  *
  * Description:
  * Adds the specified element to the specified hlist
  * before the specified node while permitting racing traversals.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
 static inline void hlist_add_before_rcu(struct hlist_node *n,
 					struct hlist_node *next)
 {
 	n->pprev = next->pprev;
 	n->next = next;
 	rcu_assign_pointer(*(n->pprev), n);
 	next->pprev = &n->next;
 }
 /**
  * hlist_add_after_rcu
  * @prev: the existing element to add the new element after.
  * @n: the new element to add to the hash list.
  *
  * Description:
  * Adds the specified element to the specified hlist
  * after the specified node while permitting racing traversals.
  *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
  * or hlist_del_rcu(), running on this same list.
  * However, it is perfectly legal to run concurrently with
  * the _rcu list-traversal primitives, such as
  * hlist_for_each_entry_rcu(), used to prevent memory-consistency
  * problems on Alpha CPUs.
  */
 static inline void hlist_add_after_rcu(struct hlist_node *prev,
 				       struct hlist_node *n)
 {
 	n->next = prev->next;
 	n->pprev = &prev->next;
 	rcu_assign_pointer(prev->next, n);
 	if (n->next)
 		n->next->pprev = &n->next;
 }
 /**
  * hlist_for_each_entry_rcu - iterate over rcu list of given type
  * @tpos:	the type * to use as a loop cursor.
  * @pos:	the &struct hlist_node to use as a loop cursor.
  * @head:	the head for your list.
  * @member:	the name of the hlist_node within the struct.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define hlist_for_each_entry_rcu(tpos, pos, head, member)		 \
 	for (pos = rcu_dereference((head)->first);			 \
 		pos && ({ prefetch(pos->next); 1; }) &&			 \
 		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
 		pos = rcu_dereference(pos->next))
 #endif	/* __KERNEL__ */
 #endif