Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* VXLAN: Virtual eXtensible Local Area Network

2

* VXLAN: Virtual eXtensible Local Area Network

3

*

3

*

4

5

*

5

*

6

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

6

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

7

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

7

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

8

* published by the Free Software Foundation.

8

* published by the Free Software Foundation.

9

*/

9

*/

10

11

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

11

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

12

13

#include <linux/kernel.h>

13

#include <linux/kernel.h>

14

#include <linux/types.h>

14

#include <linux/types.h>

15

#include <linux/module.h>

15

#include <linux/module.h>

16

#include <linux/errno.h>

16

#include <linux/errno.h>

17

#include <linux/slab.h>

17

#include <linux/slab.h>

18

#include <linux/skbuff.h>

18

#include <linux/skbuff.h>

19

#include <linux/rculist.h>

19

#include <linux/rculist.h>

20

#include <linux/netdevice.h>

20

#include <linux/netdevice.h>

21

#include <linux/in.h>

21

#include <linux/in.h>

22

#include <linux/ip.h>

22

#include <linux/ip.h>

23

#include <linux/udp.h>

23

#include <linux/udp.h>

24

#include <linux/igmp.h>

24

#include <linux/igmp.h>

25

#include <linux/etherdevice.h>

25

#include <linux/etherdevice.h>

26

#include <linux/if_ether.h>

26

#include <linux/if_ether.h>

27

#include <linux/if_vlan.h>

27

#include <linux/if_vlan.h>

28

#include <linux/hash.h>

28

#include <linux/hash.h>

29

#include <linux/ethtool.h>

29

#include <linux/ethtool.h>

30

#include <net/arp.h>

30

#include <net/arp.h>

31

#include <net/ndisc.h>

31

#include <net/ndisc.h>

32

#include <net/ip.h>

32

#include <net/ip.h>

33

#include <net/ip_tunnels.h>

33

#include <net/ip_tunnels.h>

34

#include <net/icmp.h>

34

#include <net/icmp.h>

35

#include <net/udp.h>

35

#include <net/udp.h>

36

#include <net/rtnetlink.h>

36

#include <net/rtnetlink.h>

37

#include <net/route.h>

37

#include <net/route.h>

38

#include <net/dsfield.h>

38

#include <net/dsfield.h>

39

#include <net/inet_ecn.h>

39

#include <net/inet_ecn.h>

40

#include <net/net_namespace.h>

40

#include <net/net_namespace.h>

41

#include <net/netns/generic.h>

41

#include <net/netns/generic.h>

42

#include <net/vxlan.h>

42

#include <net/vxlan.h>

43

#if IS_ENABLED(CONFIG_IPV6)

43

#if IS_ENABLED(CONFIG_IPV6)

44

#include <net/ipv6.h>

44

#include <net/ipv6.h>

45

#include <net/addrconf.h>

45

#include <net/addrconf.h>

46

#include <net/ip6_tunnel.h>

46

#include <net/ip6_tunnel.h>

47

#include <net/ip6_checksum.h>

47

#include <net/ip6_checksum.h>

48

#endif

48

#endif

49

50

#define VXLAN_VERSION "0.1"

50

#define VXLAN_VERSION "0.1"

51

52

#define PORT_HASH_BITS 8

52

#define PORT_HASH_BITS 8

53

#define PORT_HASH_SIZE (1<<PORT_HASH_BITS)

53

#define PORT_HASH_SIZE (1<<PORT_HASH_BITS)

54

#define VNI_HASH_BITS 10

54

#define VNI_HASH_BITS 10

55

#define VNI_HASH_SIZE (1<<VNI_HASH_BITS)

55

#define VNI_HASH_SIZE (1<<VNI_HASH_BITS)

56

#define FDB_HASH_BITS 8

56

#define FDB_HASH_BITS 8

57

#define FDB_HASH_SIZE (1<<FDB_HASH_BITS)

57

#define FDB_HASH_SIZE (1<<FDB_HASH_BITS)

58

#define FDB_AGE_DEFAULT 300 /* 5 min */

58

#define FDB_AGE_DEFAULT 300 /* 5 min */

59

#define FDB_AGE_INTERVAL (10 * HZ) /* rescan interval */

59

#define FDB_AGE_INTERVAL (10 * HZ) /* rescan interval */

60

61

#define VXLAN_N_VID (1u << 24)

61

#define VXLAN_N_VID (1u << 24)

62

#define VXLAN_VID_MASK (VXLAN_N_VID - 1)

62

#define VXLAN_VID_MASK (VXLAN_N_VID - 1)

63

#define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))

63

#define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))

64

65

#define VXLAN_FLAGS 0x08000000 /* struct vxlanhdr.vx_flags required value. */

65

#define VXLAN_FLAGS 0x08000000 /* struct vxlanhdr.vx_flags required value. */

66

67

/* VXLAN protocol header */

67

/* VXLAN protocol header */

68

struct vxlanhdr {

68

struct vxlanhdr {

69

__be32 vx_flags;

69

__be32 vx_flags;

70

__be32 vx_vni;

70

__be32 vx_vni;

71

};

71

};

72

73

/* UDP port for VXLAN traffic.

73

/* UDP port for VXLAN traffic.

74

* The IANA assigned port is 4789, but the Linux default is 8472

74

* The IANA assigned port is 4789, but the Linux default is 8472

75

* for compatibility with early adopters.

75

* for compatibility with early adopters.

76

*/

76

*/

77

static unsigned short vxlan_port __read_mostly = 8472;

77

static unsigned short vxlan_port __read_mostly = 8472;

78

module_param_named(udp_port, vxlan_port, ushort, 0444);

78

module_param_named(udp_port, vxlan_port, ushort, 0444);

79

MODULE_PARM_DESC(udp_port, "Destination UDP port");

79

MODULE_PARM_DESC(udp_port, "Destination UDP port");

80

81

static bool log_ecn_error = true;

81

static bool log_ecn_error = true;

82

module_param(log_ecn_error, bool, 0644);

82

module_param(log_ecn_error, bool, 0644);

83

MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");

83

MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");

84

85

static int vxlan_net_id;

85

static int vxlan_net_id;

86

87

static const u8 all_zeros_mac[ETH_ALEN];

87

static const u8 all_zeros_mac[ETH_ALEN];

88

89

/* per-network namespace private data for this module */

89

/* per-network namespace private data for this module */

90

struct vxlan_net {

90

struct vxlan_net {

91

struct list_head vxlan_list;

91

struct list_head vxlan_list;

92

struct hlist_head sock_list[PORT_HASH_SIZE];

92

struct hlist_head sock_list[PORT_HASH_SIZE];

93

spinlock_t sock_lock;

93

spinlock_t sock_lock;

94

};

94

};

95

96

union vxlan_addr {

96

union vxlan_addr {

97

struct sockaddr_in sin;

97

struct sockaddr_in sin;

98

struct sockaddr_in6 sin6;

98

struct sockaddr_in6 sin6;

99

struct sockaddr sa;

99

struct sockaddr sa;

100

};

100

};

101

102

struct vxlan_rdst {

102

struct vxlan_rdst {

103

union vxlan_addr remote_ip;

103

union vxlan_addr remote_ip;

104

__be16 remote_port;

104

__be16 remote_port;

105

u32 remote_vni;

105

u32 remote_vni;

106

u32 remote_ifindex;

106

u32 remote_ifindex;

107

struct list_head list;

107

struct list_head list;

108

struct rcu_head rcu;

108

struct rcu_head rcu;

109

};

109

};

110

111

/* Forwarding table entry */

111

/* Forwarding table entry */

112

struct vxlan_fdb {

112

struct vxlan_fdb {

113

struct hlist_node hlist; /* linked list of entries */

113

struct hlist_node hlist; /* linked list of entries */

114

struct rcu_head rcu;

114

struct rcu_head rcu;

115

unsigned long updated; /* jiffies */

115

unsigned long updated; /* jiffies */

116

unsigned long used;

116

unsigned long used;

117

struct list_head remotes;

117

struct list_head remotes;

118

u16 state; /* see ndm_state */

118

u16 state; /* see ndm_state */

119

u8 flags; /* see ndm_flags */

119

u8 flags; /* see ndm_flags */

120

u8 eth_addr[ETH_ALEN];

120

u8 eth_addr[ETH_ALEN];

121

};

121

};

122

123

/* Pseudo network device */

123

/* Pseudo network device */

124

struct vxlan_dev {

124

struct vxlan_dev {

125

struct hlist_node hlist; /* vni hash table */

125

struct hlist_node hlist; /* vni hash table */

126

struct list_head next; /* vxlan's per namespace list */

126

struct list_head next; /* vxlan's per namespace list */

127

struct vxlan_sock *vn_sock; /* listening socket */

127

struct vxlan_sock *vn_sock; /* listening socket */

128

struct net_device *dev;

128

struct net_device *dev;

129

struct vxlan_rdst default_dst; /* default destination */

129

struct vxlan_rdst default_dst; /* default destination */

130

union vxlan_addr saddr; /* source address */

130

union vxlan_addr saddr; /* source address */

131

__be16 dst_port;

131

__be16 dst_port;

132

__u16 port_min; /* source port range */

132

__u16 port_min; /* source port range */

133

__u16 port_max;

133

__u16 port_max;

134

__u8 tos; /* TOS override */

134

__u8 tos; /* TOS override */

135

__u8 ttl;

135

__u8 ttl;

136

u32 flags; /* VXLAN_F_* below */

136

u32 flags; /* VXLAN_F_* below */

137

138

struct work_struct sock_work;

138

struct work_struct sock_work;

139

struct work_struct igmp_join;

139

struct work_struct igmp_join;

140

struct work_struct igmp_leave;

140

struct work_struct igmp_leave;

141

142

unsigned long age_interval;

142

unsigned long age_interval;

143

struct timer_list age_timer;

143

struct timer_list age_timer;

144

spinlock_t hash_lock;

144

spinlock_t hash_lock;

145

unsigned int addrcnt;

145

unsigned int addrcnt;

146

unsigned int addrmax;

146

unsigned int addrmax;

147

148

struct hlist_head fdb_head[FDB_HASH_SIZE];

148

struct hlist_head fdb_head[FDB_HASH_SIZE];

149

};

149

};

150

151

#define VXLAN_F_LEARN 0x01

151

#define VXLAN_F_LEARN 0x01

152

#define VXLAN_F_PROXY 0x02

152

#define VXLAN_F_PROXY 0x02

153

#define VXLAN_F_RSC 0x04

153

#define VXLAN_F_RSC 0x04

154

#define VXLAN_F_L2MISS 0x08

154

#define VXLAN_F_L2MISS 0x08

155

#define VXLAN_F_L3MISS 0x10

155

#define VXLAN_F_L3MISS 0x10

156

#define VXLAN_F_IPV6 0x20 /* internal flag */

156

#define VXLAN_F_IPV6 0x20 /* internal flag */

157

158

/* salt for hash table */

158

/* salt for hash table */

159

static u32 vxlan_salt __read_mostly;

159

static u32 vxlan_salt __read_mostly;

160

static struct workqueue_struct *vxlan_wq;

160

static struct workqueue_struct *vxlan_wq;

161

162

static void vxlan_sock_work(struct work_struct *work);

162

static void vxlan_sock_work(struct work_struct *work);

163

164

#if IS_ENABLED(CONFIG_IPV6)

164

#if IS_ENABLED(CONFIG_IPV6)

165

static inline

165

static inline

166

bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)

166

bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)

167

{

167

{

168

if (a->sa.sa_family != b->sa.sa_family)

168

if (a->sa.sa_family != b->sa.sa_family)

169

return false;

169

return false;

170

if (a->sa.sa_family == AF_INET6)

170

if (a->sa.sa_family == AF_INET6)

171

return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);

171

return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);

172

else

172

else

173

return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;

173

return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;

174

}

174

}

175

176

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)

176

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)

177

{

177

{

178

if (ipa->sa.sa_family == AF_INET6)

178

if (ipa->sa.sa_family == AF_INET6)

179

return ipv6_addr_any(&ipa->sin6.sin6_addr);

179

return ipv6_addr_any(&ipa->sin6.sin6_addr);

180

else

180

else

181

return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);

181

return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);

182

}

182

}

183

184

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)

184

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)

185

{

185

{

186

if (ipa->sa.sa_family == AF_INET6)

186

if (ipa->sa.sa_family == AF_INET6)

187

return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);

187

return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);

188

else

188

else

189

return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));

189

return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));

190

}

190

}

191

192

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)

192

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)

193

{

193

{

194

if (nla_len(nla) >= sizeof(struct in6_addr)) {

194

if (nla_len(nla) >= sizeof(struct in6_addr)) {

195

nla_memcpy(&ip->sin6.sin6_addr, nla, sizeof(struct in6_addr));

195

nla_memcpy(&ip->sin6.sin6_addr, nla, sizeof(struct in6_addr));

196

ip->sa.sa_family = AF_INET6;

196

ip->sa.sa_family = AF_INET6;

197

return 0;

197

return 0;

198

} else if (nla_len(nla) >= sizeof(__be32)) {

198

} else if (nla_len(nla) >= sizeof(__be32)) {

199

ip->sin.sin_addr.s_addr = nla_get_be32(nla);

199

ip->sin.sin_addr.s_addr = nla_get_be32(nla);

200

ip->sa.sa_family = AF_INET;

200

ip->sa.sa_family = AF_INET;

201

return 0;

201

return 0;

202

} else {

202

} else {

203

return -EAFNOSUPPORT;

203

return -EAFNOSUPPORT;

204

}

204

}

205

}

205

}

206

207

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,

207

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,

208

const union vxlan_addr *ip)

208

const union vxlan_addr *ip)

209

{

209

{

210

if (ip->sa.sa_family == AF_INET6)

210

if (ip->sa.sa_family == AF_INET6)

211

return nla_put(skb, attr, sizeof(struct in6_addr), &ip->sin6.sin6_addr);

211

return nla_put(skb, attr, sizeof(struct in6_addr), &ip->sin6.sin6_addr);

212

else

212

else

213

return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);

213

return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);

214

}

214

}

215

216

#else /* !CONFIG_IPV6 */

216

#else /* !CONFIG_IPV6 */

217

218

static inline

218

static inline

219

bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)

219

bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)

220

{

220

{

221

return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;

221

return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;

222

}

222

}

223

224

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)

224

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)

225

{

225

{

226

return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);

226

return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);

227

}

227

}

228

229

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)

229

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)

230

{

230

{

231

return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));

231

return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));

232

}

232

}

233

234

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)

234

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)

235

{

235

{

236

if (nla_len(nla) >= sizeof(struct in6_addr)) {

236

if (nla_len(nla) >= sizeof(struct in6_addr)) {

237

return -EAFNOSUPPORT;

237

return -EAFNOSUPPORT;

238

} else if (nla_len(nla) >= sizeof(__be32)) {

238

} else if (nla_len(nla) >= sizeof(__be32)) {

239

ip->sin.sin_addr.s_addr = nla_get_be32(nla);

239

ip->sin.sin_addr.s_addr = nla_get_be32(nla);

240

ip->sa.sa_family = AF_INET;

240

ip->sa.sa_family = AF_INET;

241

return 0;

241

return 0;

242

} else {

242

} else {

243

return -EAFNOSUPPORT;

243

return -EAFNOSUPPORT;

244

}

244

}

245

}

245

}

246

247

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,

247

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,

248

const union vxlan_addr *ip)

248

const union vxlan_addr *ip)

249

{

249

{

250

return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);

250

return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);

251

}

251

}

252

#endif

252

#endif

253

254

/* Virtual Network hash table head */

254

/* Virtual Network hash table head */

255

static inline struct hlist_head *vni_head(struct vxlan_sock *vs, u32 id)

255

static inline struct hlist_head *vni_head(struct vxlan_sock *vs, u32 id)

256

{

256

{

257

return &vs->vni_list[hash_32(id, VNI_HASH_BITS)];

257

return &vs->vni_list[hash_32(id, VNI_HASH_BITS)];

258

}

258

}

259

260

/* Socket hash table head */

260

/* Socket hash table head */

261

static inline struct hlist_head *vs_head(struct net *net, __be16 port)

261

static inline struct hlist_head *vs_head(struct net *net, __be16 port)

262

{

262

{

263

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

263

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

264

265

return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];

265

return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];

266

}

266

}

267

268

/* First remote destination for a forwarding entry.

268

/* First remote destination for a forwarding entry.

269

* Guaranteed to be non-NULL because remotes are never deleted.

269

* Guaranteed to be non-NULL because remotes are never deleted.

270

*/

270

*/

271

static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)

271

static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)

272

{

272

{

273

return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);

273

return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);

274

}

274

}

275

276

static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)

276

static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)

277

{

277

{

278

return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);

278

return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);

279

}

279

}

280

281

/* Find VXLAN socket based on network namespace and UDP port */

281

/* Find VXLAN socket based on network namespace and UDP port */

282

static struct vxlan_sock *vxlan_find_sock(struct net *net, __be16 port)

282

static struct vxlan_sock *vxlan_find_sock(struct net *net, __be16 port)

283

{

283

{

284

struct vxlan_sock *vs;

284

struct vxlan_sock *vs;

285

286

hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {

286

hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {

287

if (inet_sk(vs->sock->sk)->inet_sport == port)

287

if (inet_sk(vs->sock->sk)->inet_sport == port)

288

return vs;

288

return vs;

289

}

289

}

290

return NULL;

290

return NULL;

291

}

291

}

292

293

static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, u32 id)

293

static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, u32 id)

294

{

294

{

295

struct vxlan_dev *vxlan;

295

struct vxlan_dev *vxlan;

296

297

hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {

297

hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {

298

if (vxlan->default_dst.remote_vni == id)

298

if (vxlan->default_dst.remote_vni == id)

299

return vxlan;

299

return vxlan;

300

}

300

}

301

302

return NULL;

302

return NULL;

303

}

303

}

304

305

/* Look up VNI in a per net namespace table */

305

/* Look up VNI in a per net namespace table */

306

static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)

306

static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)

307

{

307

{

308

struct vxlan_sock *vs;

308

struct vxlan_sock *vs;

309

310

vs = vxlan_find_sock(net, port);

310

vs = vxlan_find_sock(net, port);

311

if (!vs)

311

if (!vs)

312

return NULL;

312

return NULL;

313

314

return vxlan_vs_find_vni(vs, id);

314

return vxlan_vs_find_vni(vs, id);

315

}

315

}

316

317

/* Fill in neighbour message in skbuff. */

317

/* Fill in neighbour message in skbuff. */

318

static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,

318

static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,

319

const struct vxlan_fdb *fdb,

319

const struct vxlan_fdb *fdb,

320

u32 portid, u32 seq, int type, unsigned int flags,

320

u32 portid, u32 seq, int type, unsigned int flags,

321

const struct vxlan_rdst *rdst)

321

const struct vxlan_rdst *rdst)

322

{

322

{

323

unsigned long now = jiffies;

323

unsigned long now = jiffies;

324

struct nda_cacheinfo ci;

324

struct nda_cacheinfo ci;

325

struct nlmsghdr *nlh;

325

struct nlmsghdr *nlh;

326

struct ndmsg *ndm;

326

struct ndmsg *ndm;

327

bool send_ip, send_eth;

327

bool send_ip, send_eth;

328

329

nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);

329

nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);

330

if (nlh == NULL)

330

if (nlh == NULL)

331

return -EMSGSIZE;

331

return -EMSGSIZE;

332

333

ndm = nlmsg_data(nlh);

333

ndm = nlmsg_data(nlh);

334

memset(ndm, 0, sizeof(*ndm));

334

memset(ndm, 0, sizeof(*ndm));

335

336

send_eth = send_ip = true;

336

send_eth = send_ip = true;

337

338

if (type == RTM_GETNEIGH) {

338

if (type == RTM_GETNEIGH) {

339

ndm->ndm_family = AF_INET;

339

ndm->ndm_family = AF_INET;

340

send_ip = !vxlan_addr_any(&rdst->remote_ip);

340

send_ip = !vxlan_addr_any(&rdst->remote_ip);

341

send_eth = !is_zero_ether_addr(fdb->eth_addr);

341

send_eth = !is_zero_ether_addr(fdb->eth_addr);

342

} else

342

} else

343

ndm->ndm_family = AF_BRIDGE;

343

ndm->ndm_family = AF_BRIDGE;

344

ndm->ndm_state = fdb->state;

344

ndm->ndm_state = fdb->state;

345

ndm->ndm_ifindex = vxlan->dev->ifindex;

345

ndm->ndm_ifindex = vxlan->dev->ifindex;

346

ndm->ndm_flags = fdb->flags;

346

ndm->ndm_flags = fdb->flags;

347

ndm->ndm_type = NDA_DST;

347

ndm->ndm_type = NDA_DST;

348

349

if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))

349

if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))

350

goto nla_put_failure;

350

goto nla_put_failure;

351

352

if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))

352

if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))

353

goto nla_put_failure;

353

goto nla_put_failure;

354

355

if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&

355

if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&

356

nla_put_be16(skb, NDA_PORT, rdst->remote_port))

356

nla_put_be16(skb, NDA_PORT, rdst->remote_port))

357

goto nla_put_failure;

357

goto nla_put_failure;

358

if (rdst->remote_vni != vxlan->default_dst.remote_vni &&

358

if (rdst->remote_vni != vxlan->default_dst.remote_vni &&

359

nla_put_u32(skb, NDA_VNI, rdst->remote_vni))

359

nla_put_u32(skb, NDA_VNI, rdst->remote_vni))

360

goto nla_put_failure;

360

goto nla_put_failure;

361

if (rdst->remote_ifindex &&

361

if (rdst->remote_ifindex &&

362

nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))

362

nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))

363

goto nla_put_failure;

363

goto nla_put_failure;

364

365

ci.ndm_used = jiffies_to_clock_t(now - fdb->used);

365

ci.ndm_used = jiffies_to_clock_t(now - fdb->used);

366

ci.ndm_confirmed = 0;

366

ci.ndm_confirmed = 0;

367

ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);

367

ci.ndm_updated = jiffies_to_clock_t(now - fdb->updated);

368

ci.ndm_refcnt = 0;

368

ci.ndm_refcnt = 0;

369

370

if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))

370

if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))

371

goto nla_put_failure;

371

goto nla_put_failure;

372

373

return nlmsg_end(skb, nlh);

373

return nlmsg_end(skb, nlh);

374

375

nla_put_failure:

375

nla_put_failure:

376

nlmsg_cancel(skb, nlh);

376

nlmsg_cancel(skb, nlh);

377

return -EMSGSIZE;

377

return -EMSGSIZE;

378

}

378

}

379

380

static inline size_t vxlan_nlmsg_size(void)

380

static inline size_t vxlan_nlmsg_size(void)

381

{

381

{

382

return NLMSG_ALIGN(sizeof(struct ndmsg))

382

return NLMSG_ALIGN(sizeof(struct ndmsg))

383

+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */

383

+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */

384

+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */

384

+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */

385

+ nla_total_size(sizeof(__be16)) /* NDA_PORT */

385

+ nla_total_size(sizeof(__be16)) /* NDA_PORT */

386

+ nla_total_size(sizeof(__be32)) /* NDA_VNI */

386

+ nla_total_size(sizeof(__be32)) /* NDA_VNI */

387

+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */

387

+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */

388

+ nla_total_size(sizeof(struct nda_cacheinfo));

388

+ nla_total_size(sizeof(struct nda_cacheinfo));

389

}

389

}

390

391

static void vxlan_fdb_notify(struct vxlan_dev *vxlan,

391

static void vxlan_fdb_notify(struct vxlan_dev *vxlan,

392

struct vxlan_fdb *fdb, int type)

392

struct vxlan_fdb *fdb, int type)

393

{

393

{

394

struct net *net = dev_net(vxlan->dev);

394

struct net *net = dev_net(vxlan->dev);

395

struct sk_buff *skb;

395

struct sk_buff *skb;

396

int err = -ENOBUFS;

396

int err = -ENOBUFS;

397

398

skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);

398

skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);

399

if (skb == NULL)

399

if (skb == NULL)

400

goto errout;

400

goto errout;

401

402

err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0,

402

err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0,

403

first_remote_rtnl(fdb));

403

first_remote_rtnl(fdb));

404

if (err < 0) {

404

if (err < 0) {

405

/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */

405

/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */

406

WARN_ON(err == -EMSGSIZE);

406

WARN_ON(err == -EMSGSIZE);

407

kfree_skb(skb);

407

kfree_skb(skb);

408

goto errout;

408

goto errout;

409

}

409

}

410

411

rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);

411

rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);

412

return;

412

return;

413

errout:

413

errout:

414

if (err < 0)

414

if (err < 0)

415

rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);

415

rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);

416

}

416

}

417

418

static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)

418

static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)

419

{

419

{

420

struct vxlan_dev *vxlan = netdev_priv(dev);

420

struct vxlan_dev *vxlan = netdev_priv(dev);

421

struct vxlan_fdb f = {

421

struct vxlan_fdb f = {

422

.state = NUD_STALE,

422

.state = NUD_STALE,

423

};

423

};

424

struct vxlan_rdst remote = {

424

struct vxlan_rdst remote = {

425

.remote_ip = *ipa, /* goes to NDA_DST */

425

.remote_ip = *ipa, /* goes to NDA_DST */

426

.remote_vni = VXLAN_N_VID,

426

.remote_vni = VXLAN_N_VID,

427

};

427

};

428

429

INIT_LIST_HEAD(&f.remotes);

429

INIT_LIST_HEAD(&f.remotes);

430

list_add_rcu(&remote.list, &f.remotes);

430

list_add_rcu(&remote.list, &f.remotes);

431

432

vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);

432

vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);

433

}

433

}

434

435

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])

435

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])

436

{

436

{

437

struct vxlan_fdb f = {

437

struct vxlan_fdb f = {

438

.state = NUD_STALE,

438

.state = NUD_STALE,

439

};

439

};

440

441

INIT_LIST_HEAD(&f.remotes);

441

INIT_LIST_HEAD(&f.remotes);

442

memcpy(f.eth_addr, eth_addr, ETH_ALEN);

442

memcpy(f.eth_addr, eth_addr, ETH_ALEN);

443

444

vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);

444

vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);

445

}

445

}

446

447

/* Hash Ethernet address */

447

/* Hash Ethernet address */

448

static u32 eth_hash(const unsigned char *addr)

448

static u32 eth_hash(const unsigned char *addr)

449

{

449

{

450

u64 value = get_unaligned((u64 *)addr);

450

u64 value = get_unaligned((u64 *)addr);

451

452

/* only want 6 bytes */

452

/* only want 6 bytes */

453

#ifdef __BIG_ENDIAN

453

#ifdef __BIG_ENDIAN

454

value >>= 16;

454

value >>= 16;

455

#else

455

#else

456

value <<= 16;

456

value <<= 16;

457

#endif

457

#endif

458

return hash_64(value, FDB_HASH_BITS);

458

return hash_64(value, FDB_HASH_BITS);

459

}

459

}

460

461

/* Hash chain to use given mac address */

461

/* Hash chain to use given mac address */

462

static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,

462

static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,

463

const u8 *mac)

463

const u8 *mac)

464

{

464

{

465

return &vxlan->fdb_head[eth_hash(mac)];

465

return &vxlan->fdb_head[eth_hash(mac)];

466

}

466

}

467

468

/* Look up Ethernet address in forwarding table */

468

/* Look up Ethernet address in forwarding table */

469

static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,

469

static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,

470

const u8 *mac)

470

const u8 *mac)

471

472

{

472

{

473

struct hlist_head *head = vxlan_fdb_head(vxlan, mac);

473

struct hlist_head *head = vxlan_fdb_head(vxlan, mac);

474

struct vxlan_fdb *f;

474

struct vxlan_fdb *f;

475

476

hlist_for_each_entry_rcu(f, head, hlist) {

476

hlist_for_each_entry_rcu(f, head, hlist) {

477

if (ether_addr_equal(mac, f->eth_addr))

477

if (ether_addr_equal(mac, f->eth_addr))

478

return f;

478

return f;

479

}

479

}

480

481

return NULL;

481

return NULL;

482

}

482

}

483

484

static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,

484

static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,

485

const u8 *mac)

485

const u8 *mac)

486

{

486

{

487

struct vxlan_fdb *f;

487

struct vxlan_fdb *f;

488

489

f = __vxlan_find_mac(vxlan, mac);

489

f = __vxlan_find_mac(vxlan, mac);

490

if (f)

490

if (f)

491

f->used = jiffies;

491

f->used = jiffies;

492

493

return f;

493

return f;

494

}

494

}

495

496

/* caller should hold vxlan->hash_lock */

496

/* caller should hold vxlan->hash_lock */

497

static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,

497

static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,

498

union vxlan_addr *ip, __be16 port,

498

union vxlan_addr *ip, __be16 port,

499

__u32 vni, __u32 ifindex)

499

__u32 vni, __u32 ifindex)

500

{

500

{

501

struct vxlan_rdst *rd;

501

struct vxlan_rdst *rd;

502

503

list_for_each_entry(rd, &f->remotes, list) {

503

list_for_each_entry(rd, &f->remotes, list) {

504

if (vxlan_addr_equal(&rd->remote_ip, ip) &&

504

if (vxlan_addr_equal(&rd->remote_ip, ip) &&

505

rd->remote_port == port &&

505

rd->remote_port == port &&

506

rd->remote_vni == vni &&

506

rd->remote_vni == vni &&

507

rd->remote_ifindex == ifindex)

507

rd->remote_ifindex == ifindex)

508

return rd;

508

return rd;

509

}

509

}

510

511

return NULL;

511

return NULL;

512

}

512

}

513

514

/* Replace destination of unicast mac */

514

/* Replace destination of unicast mac */

515

static int vxlan_fdb_replace(struct vxlan_fdb *f,

515

static int vxlan_fdb_replace(struct vxlan_fdb *f,

516

union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)

516

union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)

517

{

517

{

518

struct vxlan_rdst *rd;

518

struct vxlan_rdst *rd;

519

520

rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);

520

rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);

521

if (rd)

521

if (rd)

522

return 0;

522

return 0;

523

524

rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);

524

rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);

525

if (!rd)

525

if (!rd)

526

return 0;

526

return 0;

527

rd->remote_ip = *ip;

527

rd->remote_ip = *ip;

528

rd->remote_port = port;

528

rd->remote_port = port;

529

rd->remote_vni = vni;

529

rd->remote_vni = vni;

530

rd->remote_ifindex = ifindex;

530

rd->remote_ifindex = ifindex;

531

return 1;

531

return 1;

532

}

532

}

533

534

/* Add/update destinations for multicast */

534

/* Add/update destinations for multicast */

535

static int vxlan_fdb_append(struct vxlan_fdb *f,

535

static int vxlan_fdb_append(struct vxlan_fdb *f,

536

union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)

536

union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)

537

{

537

{

538

struct vxlan_rdst *rd;

538

struct vxlan_rdst *rd;

539

540

rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);

540

rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);

541

if (rd)

541

if (rd)

542

return 0;

542

return 0;

543

544

rd = kmalloc(sizeof(*rd), GFP_ATOMIC);

544

rd = kmalloc(sizeof(*rd), GFP_ATOMIC);

545

if (rd == NULL)

545

if (rd == NULL)

546

return -ENOBUFS;

546

return -ENOBUFS;

547

rd->remote_ip = *ip;

547

rd->remote_ip = *ip;

548

rd->remote_port = port;

548

rd->remote_port = port;

549

rd->remote_vni = vni;

549

rd->remote_vni = vni;

550

rd->remote_ifindex = ifindex;

550

rd->remote_ifindex = ifindex;

551

552

list_add_tail_rcu(&rd->list, &f->remotes);

552

list_add_tail_rcu(&rd->list, &f->remotes);

553

554

return 1;

554

return 1;

555

}

555

}

556

557

/* Notify netdevs that UDP port started listening */

557

/* Notify netdevs that UDP port started listening */

558

static void vxlan_notify_add_rx_port(struct sock *sk)

558

static void vxlan_notify_add_rx_port(struct sock *sk)

559

{

559

{

560

struct net_device *dev;

560

struct net_device *dev;

561

struct net *net = sock_net(sk);

561

struct net *net = sock_net(sk);

562

sa_family_t sa_family = sk->sk_family;

562

sa_family_t sa_family = sk->sk_family;

563

__be16 port = inet_sk(sk)->inet_sport;

563

__be16 port = inet_sk(sk)->inet_sport;

564

565

rcu_read_lock();

565

rcu_read_lock();

566

for_each_netdev_rcu(net, dev) {

566

for_each_netdev_rcu(net, dev) {

567

if (dev->netdev_ops->ndo_add_vxlan_port)

567

if (dev->netdev_ops->ndo_add_vxlan_port)

568

dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,

568

dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,

569

port);

569

port);

570

}

570

}

571

rcu_read_unlock();

571

rcu_read_unlock();

572

}

572

}

573

574

/* Notify netdevs that UDP port is no more listening */

574

/* Notify netdevs that UDP port is no more listening */

575

static void vxlan_notify_del_rx_port(struct sock *sk)

575

static void vxlan_notify_del_rx_port(struct sock *sk)

576

{

576

{

577

struct net_device *dev;

577

struct net_device *dev;

578

struct net *net = sock_net(sk);

578

struct net *net = sock_net(sk);

579

sa_family_t sa_family = sk->sk_family;

579

sa_family_t sa_family = sk->sk_family;

580

__be16 port = inet_sk(sk)->inet_sport;

580

__be16 port = inet_sk(sk)->inet_sport;

581

582

rcu_read_lock();

582

rcu_read_lock();

583

for_each_netdev_rcu(net, dev) {

583

for_each_netdev_rcu(net, dev) {

584

if (dev->netdev_ops->ndo_del_vxlan_port)

584

if (dev->netdev_ops->ndo_del_vxlan_port)

585

dev->netdev_ops->ndo_del_vxlan_port(dev, sa_family,

585

dev->netdev_ops->ndo_del_vxlan_port(dev, sa_family,

586

port);

586

port);

587

}

587

}

588

rcu_read_unlock();

588

rcu_read_unlock();

589

}

589

}

590

591

/* Add new entry to forwarding table -- assumes lock held */

591

/* Add new entry to forwarding table -- assumes lock held */

592

static int vxlan_fdb_create(struct vxlan_dev *vxlan,

592

static int vxlan_fdb_create(struct vxlan_dev *vxlan,

593

const u8 *mac, union vxlan_addr *ip,

593

const u8 *mac, union vxlan_addr *ip,

594

__u16 state, __u16 flags,

594

__u16 state, __u16 flags,

595

__be16 port, __u32 vni, __u32 ifindex,

595

__be16 port, __u32 vni, __u32 ifindex,

596

__u8 ndm_flags)

596

__u8 ndm_flags)

597

{

597

{

598

struct vxlan_fdb *f;

598

struct vxlan_fdb *f;

599

int notify = 0;

599

int notify = 0;

600

601

f = __vxlan_find_mac(vxlan, mac);

601

f = __vxlan_find_mac(vxlan, mac);

602

if (f) {

602

if (f) {

603

if (flags & NLM_F_EXCL) {

603

if (flags & NLM_F_EXCL) {

604

netdev_dbg(vxlan->dev,

604

netdev_dbg(vxlan->dev,

605

"lost race to create %pM\n", mac);

605

"lost race to create %pM\n", mac);

606

return -EEXIST;

606

return -EEXIST;

607

}

607

}

608

if (f->state != state) {

608

if (f->state != state) {

609

f->state = state;

609

f->state = state;

610

f->updated = jiffies;

610

f->updated = jiffies;

611

notify = 1;

611

notify = 1;

612

}

612

}

613

if (f->flags != ndm_flags) {

613

if (f->flags != ndm_flags) {

614

f->flags = ndm_flags;

614

f->flags = ndm_flags;

615

f->updated = jiffies;

615

f->updated = jiffies;

616

notify = 1;

616

notify = 1;

617

}

617

}

618

if ((flags & NLM_F_REPLACE)) {

618

if ((flags & NLM_F_REPLACE)) {

619

/* Only change unicasts */

619

/* Only change unicasts */

620

if (!(is_multicast_ether_addr(f->eth_addr) ||

620

if (!(is_multicast_ether_addr(f->eth_addr) ||

621

is_zero_ether_addr(f->eth_addr))) {

621

is_zero_ether_addr(f->eth_addr))) {

622

int rc = vxlan_fdb_replace(f, ip, port, vni,

622

int rc = vxlan_fdb_replace(f, ip, port, vni,

623

ifindex);

623

ifindex);

624

625

if (rc < 0)

625

if (rc < 0)

626

return rc;

626

return rc;

627

notify |= rc;

627

notify |= rc;

628

} else

628

} else

629

return -EOPNOTSUPP;

629

return -EOPNOTSUPP;

630

}

630

}

631

if ((flags & NLM_F_APPEND) &&

631

if ((flags & NLM_F_APPEND) &&

632

(is_multicast_ether_addr(f->eth_addr) ||

632

(is_multicast_ether_addr(f->eth_addr) ||

633

is_zero_ether_addr(f->eth_addr))) {

633

is_zero_ether_addr(f->eth_addr))) {

634

int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);

634

int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);

635

636

if (rc < 0)

636

if (rc < 0)

637

return rc;

637

return rc;

638

notify |= rc;

638

notify |= rc;

639

}

639

}

640

} else {

640

} else {

641

if (!(flags & NLM_F_CREATE))

641

if (!(flags & NLM_F_CREATE))

642

return -ENOENT;

642

return -ENOENT;

643

644

if (vxlan->addrmax && vxlan->addrcnt >= vxlan->addrmax)

644

if (vxlan->addrmax && vxlan->addrcnt >= vxlan->addrmax)

645

return -ENOSPC;

645

return -ENOSPC;

646

647

/* Disallow replace to add a multicast entry */

647

/* Disallow replace to add a multicast entry */

648

if ((flags & NLM_F_REPLACE) &&

648

if ((flags & NLM_F_REPLACE) &&

649

(is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))

649

(is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))

650

return -EOPNOTSUPP;

650

return -EOPNOTSUPP;

651

652

netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);

652

netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);

653

f = kmalloc(sizeof(*f), GFP_ATOMIC);

653

f = kmalloc(sizeof(*f), GFP_ATOMIC);

654

if (!f)

654

if (!f)

655

return -ENOMEM;

655

return -ENOMEM;

656

657

notify = 1;

657

notify = 1;

658

f->state = state;

658

f->state = state;

659

f->flags = ndm_flags;

659

f->flags = ndm_flags;

660

f->updated = f->used = jiffies;

660

f->updated = f->used = jiffies;

661

INIT_LIST_HEAD(&f->remotes);

661

INIT_LIST_HEAD(&f->remotes);

662

memcpy(f->eth_addr, mac, ETH_ALEN);

662

memcpy(f->eth_addr, mac, ETH_ALEN);

663

664

vxlan_fdb_append(f, ip, port, vni, ifindex);

664

vxlan_fdb_append(f, ip, port, vni, ifindex);

665

666

++vxlan->addrcnt;

666

++vxlan->addrcnt;

667

hlist_add_head_rcu(&f->hlist,

667

hlist_add_head_rcu(&f->hlist,

668

vxlan_fdb_head(vxlan, mac));

668

vxlan_fdb_head(vxlan, mac));

669

}

669

}

670

671

if (notify)

671

if (notify)

672

vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);

672

vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);

673

674

return 0;

674

return 0;

675

}

675

}

676

677

static void vxlan_fdb_free(struct rcu_head *head)

677

static void vxlan_fdb_free(struct rcu_head *head)

678

{

678

{

679

struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);

679

struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);

680

struct vxlan_rdst *rd, *nd;

680

struct vxlan_rdst *rd, *nd;

681

682

list_for_each_entry_safe(rd, nd, &f->remotes, list)

682

list_for_each_entry_safe(rd, nd, &f->remotes, list)

683

kfree(rd);

683

kfree(rd);

684

kfree(f);

684

kfree(f);

685

}

685

}

686

687

static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f)

687

static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f)

688

{

688

{

689

netdev_dbg(vxlan->dev,

689

netdev_dbg(vxlan->dev,

690

"delete %pM\n", f->eth_addr);

690

"delete %pM\n", f->eth_addr);

691

692

--vxlan->addrcnt;

692

--vxlan->addrcnt;

693

vxlan_fdb_notify(vxlan, f, RTM_DELNEIGH);

693

vxlan_fdb_notify(vxlan, f, RTM_DELNEIGH);

694

695

hlist_del_rcu(&f->hlist);

695

hlist_del_rcu(&f->hlist);

696

call_rcu(&f->rcu, vxlan_fdb_free);

696

call_rcu(&f->rcu, vxlan_fdb_free);

697

}

697

}

698

699

static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,

699

static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,

700

union vxlan_addr *ip, __be16 *port, u32 *vni, u32 *ifindex)

700

union vxlan_addr *ip, __be16 *port, u32 *vni, u32 *ifindex)

701

{

701

{

702

struct net *net = dev_net(vxlan->dev);

702

struct net *net = dev_net(vxlan->dev);

703

int err;

703

int err;

704

705

if (tb[NDA_DST]) {

705

if (tb[NDA_DST]) {

706

err = vxlan_nla_get_addr(ip, tb[NDA_DST]);

706

err = vxlan_nla_get_addr(ip, tb[NDA_DST]);

707

if (err)

707

if (err)

708

return err;

708

return err;

709

} else {

709

} else {

710

union vxlan_addr *remote = &vxlan->default_dst.remote_ip;

710

union vxlan_addr *remote = &vxlan->default_dst.remote_ip;

711

if (remote->sa.sa_family == AF_INET) {

711

if (remote->sa.sa_family == AF_INET) {

712

ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);

712

ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);

713

ip->sa.sa_family = AF_INET;

713

ip->sa.sa_family = AF_INET;

714

#if IS_ENABLED(CONFIG_IPV6)

714

#if IS_ENABLED(CONFIG_IPV6)

715

} else {

715

} else {

716

ip->sin6.sin6_addr = in6addr_any;

716

ip->sin6.sin6_addr = in6addr_any;

717

ip->sa.sa_family = AF_INET6;

717

ip->sa.sa_family = AF_INET6;

718

#endif

718

#endif

719

}

719

}

720

}

720

}

721

722

if (tb[NDA_PORT]) {

722

if (tb[NDA_PORT]) {

723

if (nla_len(tb[NDA_PORT]) != sizeof(__be16))

723

if (nla_len(tb[NDA_PORT]) != sizeof(__be16))

724

return -EINVAL;

724

return -EINVAL;

725

*port = nla_get_be16(tb[NDA_PORT]);

725

*port = nla_get_be16(tb[NDA_PORT]);

726

} else {

726

} else {

727

*port = vxlan->dst_port;

727

*port = vxlan->dst_port;

728

}

728

}

729

730

if (tb[NDA_VNI]) {

730

if (tb[NDA_VNI]) {

731

if (nla_len(tb[NDA_VNI]) != sizeof(u32))

731

if (nla_len(tb[NDA_VNI]) != sizeof(u32))

732

return -EINVAL;

732

return -EINVAL;

733

*vni = nla_get_u32(tb[NDA_VNI]);

733

*vni = nla_get_u32(tb[NDA_VNI]);

734

} else {

734

} else {

735

*vni = vxlan->default_dst.remote_vni;

735

*vni = vxlan->default_dst.remote_vni;

736

}

736

}

737

738

if (tb[NDA_IFINDEX]) {

738

if (tb[NDA_IFINDEX]) {

739

struct net_device *tdev;

739

struct net_device *tdev;

740

741

if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))

741

if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))

742

return -EINVAL;

742

return -EINVAL;

743

*ifindex = nla_get_u32(tb[NDA_IFINDEX]);

743

*ifindex = nla_get_u32(tb[NDA_IFINDEX]);

744

tdev = dev_get_by_index(net, *ifindex);

744

tdev = dev_get_by_index(net, *ifindex);

745

if (!tdev)

745

if (!tdev)

746

return -EADDRNOTAVAIL;

746

return -EADDRNOTAVAIL;

747

dev_put(tdev);

747

dev_put(tdev);

748

} else {

748

} else {

749

*ifindex = 0;

749

*ifindex = 0;

750

}

750

}

751

752

return 0;

752

return 0;

753

}

753

}

754

755

/* Add static entry (via netlink) */

755

/* Add static entry (via netlink) */

756

static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],

756

static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],

757

struct net_device *dev,

757

struct net_device *dev,

758

const unsigned char *addr, u16 flags)

758

const unsigned char *addr, u16 flags)

759

{

759

{

760

struct vxlan_dev *vxlan = netdev_priv(dev);

760

struct vxlan_dev *vxlan = netdev_priv(dev);

761

/* struct net *net = dev_net(vxlan->dev); */

761

/* struct net *net = dev_net(vxlan->dev); */

762

union vxlan_addr ip;

762

union vxlan_addr ip;

763

__be16 port;

763

__be16 port;

764

u32 vni, ifindex;

764

u32 vni, ifindex;

765

int err;

765

int err;

766

767

if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {

767

if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {

768

pr_info("RTM_NEWNEIGH with invalid state %#x\n",

768

pr_info("RTM_NEWNEIGH with invalid state %#x\n",

769

ndm->ndm_state);

769

ndm->ndm_state);

770

return -EINVAL;

770

return -EINVAL;

771

}

771

}

772

773

if (tb[NDA_DST] == NULL)

773

if (tb[NDA_DST] == NULL)

774

return -EINVAL;

774

return -EINVAL;

775

776

err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);

776

err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);

777

if (err)

777

if (err)

778

return err;

778

return err;

779

780

spin_lock_bh(&vxlan->hash_lock);

780

spin_lock_bh(&vxlan->hash_lock);

781

err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,

781

err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,

782

port, vni, ifindex, ndm->ndm_flags);

782

port, vni, ifindex, ndm->ndm_flags);

783

spin_unlock_bh(&vxlan->hash_lock);

783

spin_unlock_bh(&vxlan->hash_lock);

784

785

return err;

785

return err;

786

}

786

}

787

788

/* Delete entry (via netlink) */

788

/* Delete entry (via netlink) */

789

static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],

789

static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],

790

struct net_device *dev,

790

struct net_device *dev,

791

const unsigned char *addr)

791

const unsigned char *addr)

792

{

792

{

793

struct vxlan_dev *vxlan = netdev_priv(dev);

793

struct vxlan_dev *vxlan = netdev_priv(dev);

794

struct vxlan_fdb *f;

794

struct vxlan_fdb *f;

795

struct vxlan_rdst *rd = NULL;

795

struct vxlan_rdst *rd = NULL;

796

union vxlan_addr ip;

796

union vxlan_addr ip;

797

__be16 port;

797

__be16 port;

798

u32 vni, ifindex;

798

u32 vni, ifindex;

799

int err;

799

int err;

800

801

err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);

801

err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);

802

if (err)

802

if (err)

803

return err;

803

return err;

804

805

err = -ENOENT;

805

err = -ENOENT;

806

807

spin_lock_bh(&vxlan->hash_lock);

807

spin_lock_bh(&vxlan->hash_lock);

808

f = vxlan_find_mac(vxlan, addr);

808

f = vxlan_find_mac(vxlan, addr);

809

if (!f)

809

if (!f)

810

goto out;

810

goto out;

811

812

if (!vxlan_addr_any(&ip)) {

812

if (!vxlan_addr_any(&ip)) {

813

rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);

813

rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);

814

if (!rd)

814

if (!rd)

815

goto out;

815

goto out;

816

}

816

}

817

818

err = 0;

818

err = 0;

819

820

/* remove a destination if it's not the only one on the list,

820

/* remove a destination if it's not the only one on the list,

821

* otherwise destroy the fdb entry

821

* otherwise destroy the fdb entry

822

*/

822

*/

823

if (rd && !list_is_singular(&f->remotes)) {

823

if (rd && !list_is_singular(&f->remotes)) {

824

list_del_rcu(&rd->list);

824

list_del_rcu(&rd->list);

825

kfree_rcu(rd, rcu);

825

kfree_rcu(rd, rcu);

826

goto out;

826

goto out;

827

}

827

}

828

829

vxlan_fdb_destroy(vxlan, f);

829

vxlan_fdb_destroy(vxlan, f);

830

831

out:

831

out:

832

spin_unlock_bh(&vxlan->hash_lock);

832

spin_unlock_bh(&vxlan->hash_lock);

833

834

return err;

834

return err;

835

}

835

}

836

837

/* Dump forwarding table */

837

/* Dump forwarding table */

838

static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,

838

static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,

839

struct net_device *dev, int idx)

839

struct net_device *dev, int idx)

840

{

840

{

841

struct vxlan_dev *vxlan = netdev_priv(dev);

841

struct vxlan_dev *vxlan = netdev_priv(dev);

842

unsigned int h;

842

unsigned int h;

843

844

for (h = 0; h < FDB_HASH_SIZE; ++h) {

844

for (h = 0; h < FDB_HASH_SIZE; ++h) {

845

struct vxlan_fdb *f;

845

struct vxlan_fdb *f;

846

int err;

846

int err;

847

848

hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {

848

hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {

849

struct vxlan_rdst *rd;

849

struct vxlan_rdst *rd;

850

851

if (idx < cb->args[0])

851

if (idx < cb->args[0])

852

goto skip;

852

goto skip;

853

854

list_for_each_entry_rcu(rd, &f->remotes, list) {

854

list_for_each_entry_rcu(rd, &f->remotes, list) {

855

err = vxlan_fdb_info(skb, vxlan, f,

855

err = vxlan_fdb_info(skb, vxlan, f,

856

NETLINK_CB(cb->skb).portid,

856

NETLINK_CB(cb->skb).portid,

857

cb->nlh->nlmsg_seq,

857

cb->nlh->nlmsg_seq,

858

RTM_NEWNEIGH,

858

RTM_NEWNEIGH,

859

NLM_F_MULTI, rd);

859

NLM_F_MULTI, rd);

860

if (err < 0)

860

if (err < 0)

861

goto out;

861

goto out;

862

}

862

}

863

skip:

863

skip:

864

++idx;

864

++idx;

865

}

865

}

866

}

866

}

867

out:

867

out:

868

return idx;

868

return idx;

869

}

869

}

870

871

/* Watch incoming packets to learn mapping between Ethernet address

871

/* Watch incoming packets to learn mapping between Ethernet address

872

* and Tunnel endpoint.

872

* and Tunnel endpoint.

873

* Return true if packet is bogus and should be droppped.

873

* Return true if packet is bogus and should be droppped.

874

*/

874

*/

875

static bool vxlan_snoop(struct net_device *dev,

875

static bool vxlan_snoop(struct net_device *dev,

876

union vxlan_addr *src_ip, const u8 *src_mac)

876

union vxlan_addr *src_ip, const u8 *src_mac)

877

{

877

{

878

struct vxlan_dev *vxlan = netdev_priv(dev);

878

struct vxlan_dev *vxlan = netdev_priv(dev);

879

struct vxlan_fdb *f;

879

struct vxlan_fdb *f;

880

881

f = vxlan_find_mac(vxlan, src_mac);

881

f = vxlan_find_mac(vxlan, src_mac);

882

if (likely(f)) {

882

if (likely(f)) {

883

struct vxlan_rdst *rdst = first_remote_rcu(f);

883

struct vxlan_rdst *rdst = first_remote_rcu(f);

884

885

if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))

885

if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))

886

return false;

886

return false;

887

888

/* Don't migrate static entries, drop packets */

888

/* Don't migrate static entries, drop packets */

889

if (f->state & NUD_NOARP)

889

if (f->state & NUD_NOARP)

890

return true;

890

return true;

891

892

if (net_ratelimit())

892

if (net_ratelimit())

893

netdev_info(dev,

893

netdev_info(dev,

894

"%pM migrated from %pIS to %pIS\n",

894

"%pM migrated from %pIS to %pIS\n",

895

src_mac, &rdst->remote_ip, &src_ip);

895

src_mac, &rdst->remote_ip, &src_ip);

896

897

rdst->remote_ip = *src_ip;

897

rdst->remote_ip = *src_ip;

898

f->updated = jiffies;

898

f->updated = jiffies;

899

vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);

899

vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);

900

} else {

900

} else {

901

/* learned new entry */

901

/* learned new entry */

902

spin_lock(&vxlan->hash_lock);

902

spin_lock(&vxlan->hash_lock);

903

904

/* close off race between vxlan_flush and incoming packets */

904

/* close off race between vxlan_flush and incoming packets */

905

if (netif_running(dev))

905

if (netif_running(dev))

906

vxlan_fdb_create(vxlan, src_mac, src_ip,

906

vxlan_fdb_create(vxlan, src_mac, src_ip,

907

NUD_REACHABLE,

907

NUD_REACHABLE,

908

NLM_F_EXCL|NLM_F_CREATE,

908

NLM_F_EXCL|NLM_F_CREATE,

909

vxlan->dst_port,

909

vxlan->dst_port,

910

vxlan->default_dst.remote_vni,

910

vxlan->default_dst.remote_vni,

911

0, NTF_SELF);

911

0, NTF_SELF);

912

spin_unlock(&vxlan->hash_lock);

912

spin_unlock(&vxlan->hash_lock);

913

}

913

}

914

915

return false;

915

return false;

916

}

916

}

917

918

/* See if multicast group is already in use by other ID */

918

/* See if multicast group is already in use by other ID */

919

static bool vxlan_group_used(struct vxlan_net *vn, union vxlan_addr *remote_ip)

919

static bool vxlan_group_used(struct vxlan_net *vn, union vxlan_addr *remote_ip)

920

{

920

{

921

struct vxlan_dev *vxlan;

921

struct vxlan_dev *vxlan;

922

923

list_for_each_entry(vxlan, &vn->vxlan_list, next) {

923

list_for_each_entry(vxlan, &vn->vxlan_list, next) {

924

if (!netif_running(vxlan->dev))

924

if (!netif_running(vxlan->dev))

925

continue;

925

continue;

926

927

if (vxlan_addr_equal(&vxlan->default_dst.remote_ip,

927

if (vxlan_addr_equal(&vxlan->default_dst.remote_ip,

928

remote_ip))

928

remote_ip))

929

return true;

929

return true;

930

}

930

}

931

932

return false;

932

return false;

933

}

933

}

934

935

static void vxlan_sock_hold(struct vxlan_sock *vs)

935

static void vxlan_sock_hold(struct vxlan_sock *vs)

936

{

936

{

937

atomic_inc(&vs->refcnt);

937

atomic_inc(&vs->refcnt);

938

}

938

}

939

940

void vxlan_sock_release(struct vxlan_sock *vs)

940

void vxlan_sock_release(struct vxlan_sock *vs)

941

{

941

{

942

struct sock *sk = vs->sock->sk;

942

struct sock *sk = vs->sock->sk;

943

struct net *net = sock_net(sk);

943

struct net *net = sock_net(sk);

944

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

944

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

945

946

if (!atomic_dec_and_test(&vs->refcnt))

946

if (!atomic_dec_and_test(&vs->refcnt))

947

return;

947

return;

948

949

spin_lock(&vn->sock_lock);

949

spin_lock(&vn->sock_lock);

950

hlist_del_rcu(&vs->hlist);

950

hlist_del_rcu(&vs->hlist);

951

rcu_assign_sk_user_data(vs->sock->sk, NULL);

951

rcu_assign_sk_user_data(vs->sock->sk, NULL);

952

vxlan_notify_del_rx_port(sk);

952

vxlan_notify_del_rx_port(sk);

953

spin_unlock(&vn->sock_lock);

953

spin_unlock(&vn->sock_lock);

954

955

queue_work(vxlan_wq, &vs->del_work);

955

queue_work(vxlan_wq, &vs->del_work);

956

}

956

}

957

EXPORT_SYMBOL_GPL(vxlan_sock_release);

957

EXPORT_SYMBOL_GPL(vxlan_sock_release);

958

959

/* Callback to update multicast group membership when first VNI on

959

/* Callback to update multicast group membership when first VNI on

960

* multicast asddress is brought up

960

* multicast asddress is brought up

961

* Done as workqueue because ip_mc_join_group acquires RTNL.

961

* Done as workqueue because ip_mc_join_group acquires RTNL.

962

*/

962

*/

963

static void vxlan_igmp_join(struct work_struct *work)

963

static void vxlan_igmp_join(struct work_struct *work)

964

{

964

{

965

struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_join);

965

struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_join);

966

struct vxlan_sock *vs = vxlan->vn_sock;

966

struct vxlan_sock *vs = vxlan->vn_sock;

967

struct sock *sk = vs->sock->sk;

967

struct sock *sk = vs->sock->sk;

968

union vxlan_addr *ip = &vxlan->default_dst.remote_ip;

968

union vxlan_addr *ip = &vxlan->default_dst.remote_ip;

969

int ifindex = vxlan->default_dst.remote_ifindex;

969

int ifindex = vxlan->default_dst.remote_ifindex;

970

971

lock_sock(sk);

971

lock_sock(sk);

972

if (ip->sa.sa_family == AF_INET) {

972

if (ip->sa.sa_family == AF_INET) {

973

struct ip_mreqn mreq = {

973

struct ip_mreqn mreq = {

974

.imr_multiaddr.s_addr = ip->sin.sin_addr.s_addr,

974

.imr_multiaddr.s_addr = ip->sin.sin_addr.s_addr,

975

.imr_ifindex = ifindex,

975

.imr_ifindex = ifindex,

976

};

976

};

977

978

ip_mc_join_group(sk, &mreq);

978

ip_mc_join_group(sk, &mreq);

979

#if IS_ENABLED(CONFIG_IPV6)

979

#if IS_ENABLED(CONFIG_IPV6)

980

} else {

980

} else {

981

ipv6_stub->ipv6_sock_mc_join(sk, ifindex,

981

ipv6_stub->ipv6_sock_mc_join(sk, ifindex,

982

&ip->sin6.sin6_addr);

982

&ip->sin6.sin6_addr);

983

#endif

983

#endif

984

}

984

}

985

release_sock(sk);

985

release_sock(sk);

986

987

vxlan_sock_release(vs);

987

vxlan_sock_release(vs);

988

dev_put(vxlan->dev);

988

dev_put(vxlan->dev);

989

}

989

}

990

991

/* Inverse of vxlan_igmp_join when last VNI is brought down */

991

/* Inverse of vxlan_igmp_join when last VNI is brought down */

992

static void vxlan_igmp_leave(struct work_struct *work)

992

static void vxlan_igmp_leave(struct work_struct *work)

993

{

993

{

994

struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_leave);

994

struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_leave);

995

struct vxlan_sock *vs = vxlan->vn_sock;

995

struct vxlan_sock *vs = vxlan->vn_sock;

996

struct sock *sk = vs->sock->sk;

996

struct sock *sk = vs->sock->sk;

997

union vxlan_addr *ip = &vxlan->default_dst.remote_ip;

997

union vxlan_addr *ip = &vxlan->default_dst.remote_ip;

998

int ifindex = vxlan->default_dst.remote_ifindex;

998

int ifindex = vxlan->default_dst.remote_ifindex;

999

1000

lock_sock(sk);

1000

lock_sock(sk);

1001

if (ip->sa.sa_family == AF_INET) {

1001

if (ip->sa.sa_family == AF_INET) {

1002

struct ip_mreqn mreq = {

1002

struct ip_mreqn mreq = {

1003

.imr_multiaddr.s_addr = ip->sin.sin_addr.s_addr,

1003

.imr_multiaddr.s_addr = ip->sin.sin_addr.s_addr,

1004

.imr_ifindex = ifindex,

1004

.imr_ifindex = ifindex,

1005

};

1005

};

1006

1007

ip_mc_leave_group(sk, &mreq);

1007

ip_mc_leave_group(sk, &mreq);

1008

#if IS_ENABLED(CONFIG_IPV6)

1008

#if IS_ENABLED(CONFIG_IPV6)

1009

} else {

1009

} else {

1010

ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,

1010

ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,

1011

&ip->sin6.sin6_addr);

1011

&ip->sin6.sin6_addr);

1012

#endif

1012

#endif

1013

}

1013

}

1014

1015

release_sock(sk);

1015

release_sock(sk);

1016

1017

vxlan_sock_release(vs);

1017

vxlan_sock_release(vs);

1018

dev_put(vxlan->dev);

1018

dev_put(vxlan->dev);

1019

}

1019

}

1020

1021

/* Callback from net/ipv4/udp.c to receive packets */

1021

/* Callback from net/ipv4/udp.c to receive packets */

1022

static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)

1022

static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)

1023

{

1023

{

1024

struct vxlan_sock *vs;

1024

struct vxlan_sock *vs;

1025

struct vxlanhdr *vxh;

1025

struct vxlanhdr *vxh;

1026

__be16 port;

1026

__be16 port;

1027

1028

/* Need Vxlan and inner Ethernet header to be present */

1028

/* Need Vxlan and inner Ethernet header to be present */

1029

if (!pskb_may_pull(skb, VXLAN_HLEN))

1029

if (!pskb_may_pull(skb, VXLAN_HLEN))

1030

goto error;

1030

goto error;

1031

1032

/* Return packets with reserved bits set */

1032

/* Return packets with reserved bits set */

1033

vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);

1033

vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);

1034

if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||

1034

if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||

1035

(vxh->vx_vni & htonl(0xff))) {

1035

(vxh->vx_vni & htonl(0xff))) {

1036

netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",

1036

netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",

1037

ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));

1037

ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));

1038

goto error;

1038

goto error;

1039

}

1039

}

1040

1041

if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))

1041

if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))

1042

goto drop;

1042

goto drop;

1043

1044

port = inet_sk(sk)->inet_sport;

1044

port = inet_sk(sk)->inet_sport;

1045

1046

vs = rcu_dereference_sk_user_data(sk);

1046

vs = rcu_dereference_sk_user_data(sk);

1047

if (!vs)

1047

if (!vs)

1048

goto drop;

1048

goto drop;

1049

1050

vs->rcv(vs, skb, vxh->vx_vni);

1050

vs->rcv(vs, skb, vxh->vx_vni);

1051

return 0;

1051

return 0;

1052

1053

drop:

1053

drop:

1054

/* Consume bad packet */

1054

/* Consume bad packet */

1055

kfree_skb(skb);

1055

kfree_skb(skb);

1056

return 0;

1056

return 0;

1057

1058

error:

1058

error:

1059

/* Return non vxlan pkt */

1059

/* Return non vxlan pkt */

1060

return 1;

1060

return 1;

1061

}

1061

}

1062

1063

static void vxlan_rcv(struct vxlan_sock *vs,

1063

static void vxlan_rcv(struct vxlan_sock *vs,

1064

struct sk_buff *skb, __be32 vx_vni)

1064

struct sk_buff *skb, __be32 vx_vni)

1065

{

1065

{

1066

struct iphdr *oip = NULL;

1066

struct iphdr *oip = NULL;

1067

struct ipv6hdr *oip6 = NULL;

1067

struct ipv6hdr *oip6 = NULL;

1068

struct vxlan_dev *vxlan;

1068

struct vxlan_dev *vxlan;

1069

struct pcpu_tstats *stats;

1069

struct pcpu_tstats *stats;

1070

union vxlan_addr saddr;

1070

union vxlan_addr saddr;

1071

__u32 vni;

1071

__u32 vni;

1072

int err = 0;

1072

int err = 0;

1073

union vxlan_addr *remote_ip;

1073

union vxlan_addr *remote_ip;

1074

1075

vni = ntohl(vx_vni) >> 8;

1075

vni = ntohl(vx_vni) >> 8;

1076

/* Is this VNI defined? */

1076

/* Is this VNI defined? */

1077

vxlan = vxlan_vs_find_vni(vs, vni);

1077

vxlan = vxlan_vs_find_vni(vs, vni);

1078

if (!vxlan)

1078

if (!vxlan)

1079

goto drop;

1079

goto drop;

1080

1081

remote_ip = &vxlan->default_dst.remote_ip;

1081

remote_ip = &vxlan->default_dst.remote_ip;

1082

skb_reset_mac_header(skb);

1082

skb_reset_mac_header(skb);

1083

skb->protocol = eth_type_trans(skb, vxlan->dev);

1083

skb->protocol = eth_type_trans(skb, vxlan->dev);

1084

1085

/* Ignore packet loops (and multicast echo) */

1085

/* Ignore packet loops (and multicast echo) */

1086

if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))

1086

if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))

1087

goto drop;

1087

goto drop;

1088

1089

/* Re-examine inner Ethernet packet */

1089

/* Re-examine inner Ethernet packet */

1090

if (remote_ip->sa.sa_family == AF_INET) {

1090

if (remote_ip->sa.sa_family == AF_INET) {

1091

oip = ip_hdr(skb);

1091

oip = ip_hdr(skb);

1092

saddr.sin.sin_addr.s_addr = oip->saddr;

1092

saddr.sin.sin_addr.s_addr = oip->saddr;

1093

saddr.sa.sa_family = AF_INET;

1093

saddr.sa.sa_family = AF_INET;

1094

#if IS_ENABLED(CONFIG_IPV6)

1094

#if IS_ENABLED(CONFIG_IPV6)

1095

} else {

1095

} else {

1096

oip6 = ipv6_hdr(skb);

1096

oip6 = ipv6_hdr(skb);

1097

saddr.sin6.sin6_addr = oip6->saddr;

1097

saddr.sin6.sin6_addr = oip6->saddr;

1098

saddr.sa.sa_family = AF_INET6;

1098

saddr.sa.sa_family = AF_INET6;

1099

#endif

1099

#endif

1100

}

1100

}

1101

1102

if ((vxlan->flags & VXLAN_F_LEARN) &&

1102

if ((vxlan->flags & VXLAN_F_LEARN) &&

1103

vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))

1103

vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))

1104

goto drop;

1104

goto drop;

1105

1106

skb_reset_network_header(skb);

1106

skb_reset_network_header(skb);

1107

1108

/* If the NIC driver gave us an encapsulated packet with

1108

/* If the NIC driver gave us an encapsulated packet with

1109

* CHECKSUM_UNNECESSARY and Rx checksum feature is enabled,

1109

* CHECKSUM_UNNECESSARY and Rx checksum feature is enabled,

1110

* leave the CHECKSUM_UNNECESSARY, the device checksummed it

1110

* leave the CHECKSUM_UNNECESSARY, the device checksummed it

1111

* for us. Otherwise force the upper layers to verify it.

1111

* for us. Otherwise force the upper layers to verify it.

1112

*/

1112

*/

1113

if (skb->ip_summed != CHECKSUM_UNNECESSARY || !skb->encapsulation ||

1113

if (skb->ip_summed != CHECKSUM_UNNECESSARY || !skb->encapsulation ||

1114

!(vxlan->dev->features & NETIF_F_RXCSUM))

1114

!(vxlan->dev->features & NETIF_F_RXCSUM))

1115

skb->ip_summed = CHECKSUM_NONE;

1115

skb->ip_summed = CHECKSUM_NONE;

1116

1117

skb->encapsulation = 0;

1117

skb->encapsulation = 0;

1118

1119

if (oip6)

1119

if (oip6)

1120

err = IP6_ECN_decapsulate(oip6, skb);

1120

err = IP6_ECN_decapsulate(oip6, skb);

1121

if (oip)

1121

if (oip)

1122

err = IP_ECN_decapsulate(oip, skb);

1122

err = IP_ECN_decapsulate(oip, skb);

1123

1124

if (unlikely(err)) {

1124

if (unlikely(err)) {

1125

if (log_ecn_error) {

1125

if (log_ecn_error) {

1126

if (oip6)

1126

if (oip6)

1127

net_info_ratelimited("non-ECT from %pI6\n",

1127

net_info_ratelimited("non-ECT from %pI6\n",

1128

&oip6->saddr);

1128

&oip6->saddr);

1129

if (oip)

1129

if (oip)

1130

net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",

1130

net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",

1131

&oip->saddr, oip->tos);

1131

&oip->saddr, oip->tos);

1132

}

1132

}

1133

if (err > 1) {

1133

if (err > 1) {

1134

++vxlan->dev->stats.rx_frame_errors;

1134

++vxlan->dev->stats.rx_frame_errors;

1135

++vxlan->dev->stats.rx_errors;

1135

++vxlan->dev->stats.rx_errors;

1136

goto drop;

1136

goto drop;

1137

}

1137

}

1138

}

1138

}

1139

1140

stats = this_cpu_ptr(vxlan->dev->tstats);

1140

stats = this_cpu_ptr(vxlan->dev->tstats);

1141

u64_stats_update_begin(&stats->syncp);

1141

u64_stats_update_begin(&stats->syncp);

1142

stats->rx_packets++;

1142

stats->rx_packets++;

1143

stats->rx_bytes += skb->len;

1143

stats->rx_bytes += skb->len;

1144

u64_stats_update_end(&stats->syncp);

1144

u64_stats_update_end(&stats->syncp);

1145

1146

netif_rx(skb);

1146

netif_rx(skb);

1147

1148

return;

1148

return;

1149

drop:

1149

drop:

1150

/* Consume bad packet */

1150

/* Consume bad packet */

1151

kfree_skb(skb);

1151

kfree_skb(skb);

1152

}

1152

}

1153

1154

static int arp_reduce(struct net_device *dev, struct sk_buff *skb)

1154

static int arp_reduce(struct net_device *dev, struct sk_buff *skb)

1155

{

1155

{

1156

struct vxlan_dev *vxlan = netdev_priv(dev);

1156

struct vxlan_dev *vxlan = netdev_priv(dev);

1157

struct arphdr *parp;

1157

struct arphdr *parp;

1158

u8 *arpptr, *sha;

1158

u8 *arpptr, *sha;

1159

__be32 sip, tip;

1159

__be32 sip, tip;

1160

struct neighbour *n;

1160

struct neighbour *n;

1161

1162

if (dev->flags & IFF_NOARP)

1162

if (dev->flags & IFF_NOARP)

1163

goto out;

1163

goto out;

1164

1165

if (!pskb_may_pull(skb, arp_hdr_len(dev))) {

1165

if (!pskb_may_pull(skb, arp_hdr_len(dev))) {

1166

dev->stats.tx_dropped++;

1166

dev->stats.tx_dropped++;

1167

goto out;

1167

goto out;

1168

}

1168

}

1169

parp = arp_hdr(skb);

1169

parp = arp_hdr(skb);

1170

1171

if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&

1171

if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&

1172

parp->ar_hrd != htons(ARPHRD_IEEE802)) ||

1172

parp->ar_hrd != htons(ARPHRD_IEEE802)) ||

1173

parp->ar_pro != htons(ETH_P_IP) ||

1173

parp->ar_pro != htons(ETH_P_IP) ||

1174

parp->ar_op != htons(ARPOP_REQUEST) ||

1174

parp->ar_op != htons(ARPOP_REQUEST) ||

1175

parp->ar_hln != dev->addr_len ||

1175

parp->ar_hln != dev->addr_len ||

1176

parp->ar_pln != 4)

1176

parp->ar_pln != 4)

1177

goto out;

1177

goto out;

1178

arpptr = (u8 *)parp + sizeof(struct arphdr);

1178

arpptr = (u8 *)parp + sizeof(struct arphdr);

1179

sha = arpptr;

1179

sha = arpptr;

1180

arpptr += dev->addr_len; /* sha */

1180

arpptr += dev->addr_len; /* sha */

1181

memcpy(&sip, arpptr, sizeof(sip));

1181

memcpy(&sip, arpptr, sizeof(sip));

1182

arpptr += sizeof(sip);

1182

arpptr += sizeof(sip);

1183

arpptr += dev->addr_len; /* tha */

1183

arpptr += dev->addr_len; /* tha */

1184

memcpy(&tip, arpptr, sizeof(tip));

1184

memcpy(&tip, arpptr, sizeof(tip));

1185

1186

if (ipv4_is_loopback(tip) ||

1186

if (ipv4_is_loopback(tip) ||

1187

ipv4_is_multicast(tip))

1187

ipv4_is_multicast(tip))

1188

goto out;

1188

goto out;

1189

1190

n = neigh_lookup(&arp_tbl, &tip, dev);

1190

n = neigh_lookup(&arp_tbl, &tip, dev);

1191

1192

if (n) {

1192

if (n) {

1193

struct vxlan_fdb *f;

1193

struct vxlan_fdb *f;

1194

struct sk_buff *reply;

1194

struct sk_buff *reply;

1195

1196

if (!(n->nud_state & NUD_CONNECTED)) {

1196

if (!(n->nud_state & NUD_CONNECTED)) {

1197

neigh_release(n);

1197

neigh_release(n);

1198

goto out;

1198

goto out;

1199

}

1199

}

1200

1201

f = vxlan_find_mac(vxlan, n->ha);

1201

f = vxlan_find_mac(vxlan, n->ha);

1202

if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {

1202

if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {

1203

/* bridge-local neighbor */

1203

/* bridge-local neighbor */

1204

neigh_release(n);

1204

neigh_release(n);

1205

goto out;

1205

goto out;

1206

}

1206

}

1207

1208

reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,

1208

reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,

1209

n->ha, sha);

1209

n->ha, sha);

1210

1211

neigh_release(n);

1211

neigh_release(n);

1212

1213

skb_reset_mac_header(reply);

1213

skb_reset_mac_header(reply);

1214

__skb_pull(reply, skb_network_offset(reply));

1214

__skb_pull(reply, skb_network_offset(reply));

1215

reply->ip_summed = CHECKSUM_UNNECESSARY;

1215

reply->ip_summed = CHECKSUM_UNNECESSARY;

1216

reply->pkt_type = PACKET_HOST;

1216

reply->pkt_type = PACKET_HOST;

1217

1218

if (netif_rx_ni(reply) == NET_RX_DROP)

1218

if (netif_rx_ni(reply) == NET_RX_DROP)

1219

dev->stats.rx_dropped++;

1219

dev->stats.rx_dropped++;

1220

} else if (vxlan->flags & VXLAN_F_L3MISS) {

1220

} else if (vxlan->flags & VXLAN_F_L3MISS) {

1221

union vxlan_addr ipa = {

1221

union vxlan_addr ipa = {

1222

.sin.sin_addr.s_addr = tip,

1222

.sin.sin_addr.s_addr = tip,

1223

.sa.sa_family = AF_INET,

1223

.sa.sa_family = AF_INET,

1224

};

1224

};

1225

1226

vxlan_ip_miss(dev, &ipa);

1226

vxlan_ip_miss(dev, &ipa);

1227

}

1227

}

1228

out:

1228

out:

1229

consume_skb(skb);

1229

consume_skb(skb);

1230

return NETDEV_TX_OK;

1230

return NETDEV_TX_OK;

1231

}

1231

}

1232

1233

#if IS_ENABLED(CONFIG_IPV6)

1233

#if IS_ENABLED(CONFIG_IPV6)

1234

static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)

1234

static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)

1235

{

1235

{

1236

struct vxlan_dev *vxlan = netdev_priv(dev);

1236

struct vxlan_dev *vxlan = netdev_priv(dev);

1237

struct neighbour *n;

1237

struct neighbour *n;

1238

union vxlan_addr ipa;

1238

union vxlan_addr ipa;

1239

const struct ipv6hdr *iphdr;

1239

const struct ipv6hdr *iphdr;

1240

const struct in6_addr *saddr, *daddr;

1240

const struct in6_addr *saddr, *daddr;

1241

struct nd_msg *msg;

1241

struct nd_msg *msg;

1242

struct inet6_dev *in6_dev = NULL;

1242

struct inet6_dev *in6_dev = NULL;

1243

1244

in6_dev = __in6_dev_get(dev);

1244

in6_dev = __in6_dev_get(dev);

1245

if (!in6_dev)

1245

if (!in6_dev)

1246

goto out;

1246

goto out;

1247

1248

if (!pskb_may_pull(skb, skb->len))

1248

if (!pskb_may_pull(skb, skb->len))

1249

goto out;

1249

goto out;

1250

1251

iphdr = ipv6_hdr(skb);

1251

iphdr = ipv6_hdr(skb);

1252

saddr = &iphdr->saddr;

1252

saddr = &iphdr->saddr;

1253

daddr = &iphdr->daddr;

1253

daddr = &iphdr->daddr;

1254

1255

if (ipv6_addr_loopback(daddr) ||

1255

if (ipv6_addr_loopback(daddr) ||

1256

ipv6_addr_is_multicast(daddr))

1256

ipv6_addr_is_multicast(daddr))

1257

goto out;

1257

goto out;

1258

1259

msg = (struct nd_msg *)skb_transport_header(skb);

1259

msg = (struct nd_msg *)skb_transport_header(skb);

1260

if (msg->icmph.icmp6_code != 0 ||

1260

if (msg->icmph.icmp6_code != 0 ||

1261

msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)

1261

msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)

1262

goto out;

1262

goto out;

1263

1264

n = neigh_lookup(ipv6_stub->nd_tbl, daddr, dev);

1264

n = neigh_lookup(ipv6_stub->nd_tbl, daddr, dev);

1265

1266

if (n) {

1266

if (n) {

1267

struct vxlan_fdb *f;

1267

struct vxlan_fdb *f;

1268

1269

if (!(n->nud_state & NUD_CONNECTED)) {

1269

if (!(n->nud_state & NUD_CONNECTED)) {

1270

neigh_release(n);

1270

neigh_release(n);

1271

goto out;

1271

goto out;

1272

}

1272

}

1273

1274

f = vxlan_find_mac(vxlan, n->ha);

1274

f = vxlan_find_mac(vxlan, n->ha);

1275

if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {

1275

if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {

1276

/* bridge-local neighbor */

1276

/* bridge-local neighbor */

1277

neigh_release(n);

1277

neigh_release(n);

1278

goto out;

1278

goto out;

1279

}

1279

}

1280

1281

ipv6_stub->ndisc_send_na(dev, n, saddr, &msg->target,

1281

ipv6_stub->ndisc_send_na(dev, n, saddr, &msg->target,

1282

!!in6_dev->cnf.forwarding,

1282

!!in6_dev->cnf.forwarding,

1283

true, false, false);

1283

true, false, false);

1284

neigh_release(n);

1284

neigh_release(n);

1285

} else if (vxlan->flags & VXLAN_F_L3MISS) {

1285

} else if (vxlan->flags & VXLAN_F_L3MISS) {

1286

ipa.sin6.sin6_addr = *daddr;

1286

ipa.sin6.sin6_addr = *daddr;

1287

ipa.sa.sa_family = AF_INET6;

1287

ipa.sa.sa_family = AF_INET6;

1288

vxlan_ip_miss(dev, &ipa);

1288

vxlan_ip_miss(dev, &ipa);

1289

}

1289

}

1290

1291

out:

1291

out:

1292

consume_skb(skb);

1292

consume_skb(skb);

1293

return NETDEV_TX_OK;

1293

return NETDEV_TX_OK;

1294

}

1294

}

1295

#endif

1295

#endif

1296

1297

static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)

1297

static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)

1298

{

1298

{

1299

struct vxlan_dev *vxlan = netdev_priv(dev);

1299

struct vxlan_dev *vxlan = netdev_priv(dev);

1300

struct neighbour *n;

1300

struct neighbour *n;

1301

1302

if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))

1302

if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))

1303

return false;

1303

return false;

1304

1305

n = NULL;

1305

n = NULL;

1306

switch (ntohs(eth_hdr(skb)->h_proto)) {

1306

switch (ntohs(eth_hdr(skb)->h_proto)) {

1307

case ETH_P_IP:

1307

case ETH_P_IP:

1308

{

1308

{

1309

struct iphdr *pip;

1309

struct iphdr *pip;

1310

1311

if (!pskb_may_pull(skb, sizeof(struct iphdr)))

1311

if (!pskb_may_pull(skb, sizeof(struct iphdr)))

1312

return false;

1312

return false;

1313

pip = ip_hdr(skb);

1313

pip = ip_hdr(skb);

1314

n = neigh_lookup(&arp_tbl, &pip->daddr, dev);

1314

n = neigh_lookup(&arp_tbl, &pip->daddr, dev);

1315

if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {

1315

if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {

1316

union vxlan_addr ipa = {

1316

union vxlan_addr ipa = {

1317

.sin.sin_addr.s_addr = pip->daddr,

1317

.sin.sin_addr.s_addr = pip->daddr,

1318

.sa.sa_family = AF_INET,

1318

.sa.sa_family = AF_INET,

1319

};

1319

};

1320

1321

vxlan_ip_miss(dev, &ipa);

1321

vxlan_ip_miss(dev, &ipa);

1322

return false;

1322

return false;

1323

}

1323

}

1324

1325

break;

1325

break;

1326

}

1326

}

1327

#if IS_ENABLED(CONFIG_IPV6)

1327

#if IS_ENABLED(CONFIG_IPV6)

1328

case ETH_P_IPV6:

1328

case ETH_P_IPV6:

1329

{

1329

{

1330

struct ipv6hdr *pip6;

1330

struct ipv6hdr *pip6;

1331

1332

if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))

1332

if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))

1333

return false;

1333

return false;

1334

pip6 = ipv6_hdr(skb);

1334

pip6 = ipv6_hdr(skb);

1335

n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);

1335

n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);

1336

if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {

1336

if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {

1337

union vxlan_addr ipa = {

1337

union vxlan_addr ipa = {

1338

.sin6.sin6_addr = pip6->daddr,

1338

.sin6.sin6_addr = pip6->daddr,

1339

.sa.sa_family = AF_INET6,

1339

.sa.sa_family = AF_INET6,

1340

};

1340

};

1341

1342

vxlan_ip_miss(dev, &ipa);

1342

vxlan_ip_miss(dev, &ipa);

1343

return false;

1343

return false;

1344

}

1344

}

1345

1346

break;

1346

break;

1347

}

1347

}

1348

#endif

1348

#endif

1349

default:

1349

default:

1350

return false;

1350

return false;

1351

}

1351

}

1352

1353

if (n) {

1353

if (n) {

1354

bool diff;

1354

bool diff;

1355

1356

diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);

1356

diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);

1357

if (diff) {

1357

if (diff) {

1358

memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,

1358

memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,

1359

dev->addr_len);

1359

dev->addr_len);

1360

memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);

1360

memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);

1361

}

1361

}

1362

neigh_release(n);

1362

neigh_release(n);

1363

return diff;

1363

return diff;

1364

}

1364

}

1365

1366

return false;

1366

return false;

1367

}

1367

}

1368

1369

static void vxlan_sock_put(struct sk_buff *skb)

1369

static void vxlan_sock_put(struct sk_buff *skb)

1370

{

1370

{

1371

sock_put(skb->sk);

1371

sock_put(skb->sk);

1372

}

1372

}

1373

1374

/* On transmit, associate with the tunnel socket */

1374

/* On transmit, associate with the tunnel socket */

1375

static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)

1375

static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)

1376

{

1376

{

1377

skb_orphan(skb);

1377

skb_orphan(skb);

1378

sock_hold(sk);

1378

sock_hold(sk);

1379

skb->sk = sk;

1379

skb->sk = sk;

1380

skb->destructor = vxlan_sock_put;

1380

skb->destructor = vxlan_sock_put;

1381

}

1381

}

1382

1383

/* Compute source port for outgoing packet

1383

/* Compute source port for outgoing packet

1384

* first choice to use L4 flow hash since it will spread

1384

* first choice to use L4 flow hash since it will spread

1385

* better and maybe available from hardware

1385

* better and maybe available from hardware

1386

* secondary choice is to use jhash on the Ethernet header

1386

* secondary choice is to use jhash on the Ethernet header

1387

*/

1387

*/

1388

__be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)

1388

__be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)

1389

{

1389

{

1390

unsigned int range = (port_max - port_min) + 1;

1390

unsigned int range = (port_max - port_min) + 1;

1391

u32 hash;

1391

u32 hash;

1392

1393

hash = skb_get_rxhash(skb);

1393

hash = skb_get_rxhash(skb);

1394

if (!hash)

1394

if (!hash)

1395

hash = jhash(skb->data, 2 * ETH_ALEN,

1395

hash = jhash(skb->data, 2 * ETH_ALEN,

1396

(__force u32) skb->protocol);

1396

(__force u32) skb->protocol);

1397

1398

return htons((((u64) hash * range) >> 32) + port_min);

1398

return htons((((u64) hash * range) >> 32) + port_min);

1399

}

1399

}

1400

EXPORT_SYMBOL_GPL(vxlan_src_port);

1400

EXPORT_SYMBOL_GPL(vxlan_src_port);

1401

1402

static int handle_offloads(struct sk_buff *skb)

1402

static int handle_offloads(struct sk_buff *skb)

1403

{

1403

{

1404

if (skb_is_gso(skb)) {

1404

if (skb_is_gso(skb)) {

1405

int err = skb_unclone(skb, GFP_ATOMIC);

1405

int err = skb_unclone(skb, GFP_ATOMIC);

1406

if (unlikely(err))

1406

if (unlikely(err))

1407

return err;

1407

return err;

1408

1409

skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;

1409

skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;

1410

} else if (skb->ip_summed != CHECKSUM_PARTIAL)

1410

} else if (skb->ip_summed != CHECKSUM_PARTIAL)

1411

skb->ip_summed = CHECKSUM_NONE;

1411

skb->ip_summed = CHECKSUM_NONE;

1412

1413

return 0;

1413

return 0;

1414

}

1414

}

1415

1416

#if IS_ENABLED(CONFIG_IPV6)

1416

#if IS_ENABLED(CONFIG_IPV6)

1417

static int vxlan6_xmit_skb(struct vxlan_sock *vs,

1417

static int vxlan6_xmit_skb(struct vxlan_sock *vs,

1418

struct dst_entry *dst, struct sk_buff *skb,

1418

struct dst_entry *dst, struct sk_buff *skb,

1419

struct net_device *dev, struct in6_addr *saddr,

1419

struct net_device *dev, struct in6_addr *saddr,

1420

struct in6_addr *daddr, __u8 prio, __u8 ttl,

1420

struct in6_addr *daddr, __u8 prio, __u8 ttl,

1421

__be16 src_port, __be16 dst_port, __be32 vni)

1421

__be16 src_port, __be16 dst_port, __be32 vni)

1422

{

1422

{

1423

struct ipv6hdr *ip6h;

1423

struct ipv6hdr *ip6h;

1424

struct vxlanhdr *vxh;

1424

struct vxlanhdr *vxh;

1425

struct udphdr *uh;

1425

struct udphdr *uh;

1426

int min_headroom;

1426

int min_headroom;

1427

int err;

1427

int err;

1428

1429

if (!skb->encapsulation) {

1429

if (!skb->encapsulation) {

1430

skb_reset_inner_headers(skb);

1430

skb_reset_inner_headers(skb);

1431

skb->encapsulation = 1;

1431

skb->encapsulation = 1;

1432

}

1432

}

1433

1434

skb_scrub_packet(skb, false);

1434

skb_scrub_packet(skb, false);

1435

1436

min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len

1436

min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len

1437

+ VXLAN_HLEN + sizeof(struct ipv6hdr)

1437

+ VXLAN_HLEN + sizeof(struct ipv6hdr)

1438

+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);

1438

+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);

1439

1440

/* Need space for new headers (invalidates iph ptr) */

1440

/* Need space for new headers (invalidates iph ptr) */

1441

err = skb_cow_head(skb, min_headroom);

1441

err = skb_cow_head(skb, min_headroom);

1442

if (unlikely(err))

1442

if (unlikely(err))

1443

return err;

1443

return err;

1444

1445

if (vlan_tx_tag_present(skb)) {

1445

if (vlan_tx_tag_present(skb)) {

1446

if (WARN_ON(!__vlan_put_tag(skb,

1446

if (WARN_ON(!__vlan_put_tag(skb,

1447

skb->vlan_proto,

1447

skb->vlan_proto,

1448

vlan_tx_tag_get(skb))))

1448

vlan_tx_tag_get(skb))))

1449

return -ENOMEM;

1449

return -ENOMEM;

1450

1451

skb->vlan_tci = 0;

1451

skb->vlan_tci = 0;

1452

}

1452

}

1453

1454

vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));

1454

vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));

1455

vxh->vx_flags = htonl(VXLAN_FLAGS);

1455

vxh->vx_flags = htonl(VXLAN_FLAGS);

1456

vxh->vx_vni = vni;

1456

vxh->vx_vni = vni;

1457

1458

__skb_push(skb, sizeof(*uh));

1458

__skb_push(skb, sizeof(*uh));

1459

skb_reset_transport_header(skb);

1459

skb_reset_transport_header(skb);

1460

uh = udp_hdr(skb);

1460

uh = udp_hdr(skb);

1461

1462

uh->dest = dst_port;

1462

uh->dest = dst_port;

1463

uh->source = src_port;

1463

uh->source = src_port;

1464

1465

uh->len = htons(skb->len);

1465

uh->len = htons(skb->len);

1466

uh->check = 0;

1466

uh->check = 0;

1467

1468

memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));

1468

memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));

1469

IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |

1469

IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |

1470

IPSKB_REROUTED);

1470

IPSKB_REROUTED);

1471

skb_dst_set(skb, dst);

1471

skb_dst_set(skb, dst);

1472

1473

if (!skb_is_gso(skb) && !(dst->dev->features & NETIF_F_IPV6_CSUM)) {

1473

if (!skb_is_gso(skb) && !(dst->dev->features & NETIF_F_IPV6_CSUM)) {

1474

__wsum csum = skb_checksum(skb, 0, skb->len, 0);

1474

__wsum csum = skb_checksum(skb, 0, skb->len, 0);

1475

skb->ip_summed = CHECKSUM_UNNECESSARY;

1475

skb->ip_summed = CHECKSUM_UNNECESSARY;

1476

uh->check = csum_ipv6_magic(saddr, daddr, skb->len,

1476

uh->check = csum_ipv6_magic(saddr, daddr, skb->len,

1477

IPPROTO_UDP, csum);

1477

IPPROTO_UDP, csum);

1478

if (uh->check == 0)

1478

if (uh->check == 0)

1479

uh->check = CSUM_MANGLED_0;

1479

uh->check = CSUM_MANGLED_0;

1480

} else {

1480

} else {

1481

skb->ip_summed = CHECKSUM_PARTIAL;

1481

skb->ip_summed = CHECKSUM_PARTIAL;

1482

skb->csum_start = skb_transport_header(skb) - skb->head;

1482

skb->csum_start = skb_transport_header(skb) - skb->head;

1483

skb->csum_offset = offsetof(struct udphdr, check);

1483

skb->csum_offset = offsetof(struct udphdr, check);

1484

uh->check = ~csum_ipv6_magic(saddr, daddr,

1484

uh->check = ~csum_ipv6_magic(saddr, daddr,

1485

skb->len, IPPROTO_UDP, 0);

1485

skb->len, IPPROTO_UDP, 0);

1486

}

1486

}

1487

1488

__skb_push(skb, sizeof(*ip6h));

1488

__skb_push(skb, sizeof(*ip6h));

1489

skb_reset_network_header(skb);

1489

skb_reset_network_header(skb);

1490

ip6h = ipv6_hdr(skb);

1490

ip6h = ipv6_hdr(skb);

1491

ip6h->version = 6;

1491

ip6h->version = 6;

1492

ip6h->priority = prio;

1492

ip6h->priority = prio;

1493

ip6h->flow_lbl[0] = 0;

1493

ip6h->flow_lbl[0] = 0;

1494

ip6h->flow_lbl[1] = 0;

1494

ip6h->flow_lbl[1] = 0;

1495

ip6h->flow_lbl[2] = 0;

1495

ip6h->flow_lbl[2] = 0;

1496

ip6h->payload_len = htons(skb->len);

1496

ip6h->payload_len = htons(skb->len);

1497

ip6h->nexthdr = IPPROTO_UDP;

1497

ip6h->nexthdr = IPPROTO_UDP;

1498

ip6h->hop_limit = ttl;

1498

ip6h->hop_limit = ttl;

1499

ip6h->daddr = *daddr;

1499

ip6h->daddr = *daddr;

1500

ip6h->saddr = *saddr;

1500

ip6h->saddr = *saddr;

1501

1502

vxlan_set_owner(vs->sock->sk, skb);

1502

vxlan_set_owner(vs->sock->sk, skb);

1503

1504

err = handle_offloads(skb);

1504

err = handle_offloads(skb);

1505

if (err)

1505

if (err)

1506

return err;

1506

return err;

1507

1508

ip6tunnel_xmit(skb, dev);

1508

ip6tunnel_xmit(skb, dev);

1509

return 0;

1509

return 0;

1510

}

1510

}

1511

#endif

1511

#endif

1512

1513

int vxlan_xmit_skb(struct vxlan_sock *vs,

1513

int vxlan_xmit_skb(struct vxlan_sock *vs,

1514

struct rtable *rt, struct sk_buff *skb,

1514

struct rtable *rt, struct sk_buff *skb,

1515

__be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,

1515

__be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,

1516

__be16 src_port, __be16 dst_port, __be32 vni)

1516

__be16 src_port, __be16 dst_port, __be32 vni)

1517

{

1517

{

1518

struct vxlanhdr *vxh;

1518

struct vxlanhdr *vxh;

1519

struct udphdr *uh;

1519

struct udphdr *uh;

1520

int min_headroom;

1520

int min_headroom;

1521

int err;

1521

int err;

1522

1523

if (!skb->encapsulation) {

1523

if (!skb->encapsulation) {

1524

skb_reset_inner_headers(skb);

1524

skb_reset_inner_headers(skb);

1525

skb->encapsulation = 1;

1525

skb->encapsulation = 1;

1526

}

1526

}

1527

1528

min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len

1528

min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len

1529

+ VXLAN_HLEN + sizeof(struct iphdr)

1529

+ VXLAN_HLEN + sizeof(struct iphdr)

1530

+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);

1530

+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);

1531

1532

/* Need space for new headers (invalidates iph ptr) */

1532

/* Need space for new headers (invalidates iph ptr) */

1533

err = skb_cow_head(skb, min_headroom);

1533

err = skb_cow_head(skb, min_headroom);

1534

if (unlikely(err))

1534

if (unlikely(err))

1535

return err;

1535

return err;

1536

1537

if (vlan_tx_tag_present(skb)) {

1537

if (vlan_tx_tag_present(skb)) {

1538

if (WARN_ON(!__vlan_put_tag(skb,

1538

if (WARN_ON(!__vlan_put_tag(skb,

1539

skb->vlan_proto,

1539

skb->vlan_proto,

1540

vlan_tx_tag_get(skb))))

1540

vlan_tx_tag_get(skb))))

1541

return -ENOMEM;

1541

return -ENOMEM;

1542

1543

skb->vlan_tci = 0;

1543

skb->vlan_tci = 0;

1544

}

1544

}

1545

1546

vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));

1546

vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));

1547

vxh->vx_flags = htonl(VXLAN_FLAGS);

1547

vxh->vx_flags = htonl(VXLAN_FLAGS);

1548

vxh->vx_vni = vni;

1548

vxh->vx_vni = vni;

1549

1550

__skb_push(skb, sizeof(*uh));

1550

__skb_push(skb, sizeof(*uh));

1551

skb_reset_transport_header(skb);

1551

skb_reset_transport_header(skb);

1552

uh = udp_hdr(skb);

1552

uh = udp_hdr(skb);

1553

1554

uh->dest = dst_port;

1554

uh->dest = dst_port;

1555

uh->source = src_port;

1555

uh->source = src_port;

1556

1557

uh->len = htons(skb->len);

1557

uh->len = htons(skb->len);

1558

uh->check = 0;

1558

uh->check = 0;

1559

1560

vxlan_set_owner(vs->sock->sk, skb);

1560

vxlan_set_owner(vs->sock->sk, skb);

1561

1562

err = handle_offloads(skb);

1562

err = handle_offloads(skb);

1563

if (err)

1563

if (err)

1564

return err;

1564

return err;

1565

1566

return iptunnel_xmit(rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df,

1566

return iptunnel_xmit(rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df,

1567

false);

1567

false);

1568

}

1568

}

1569

EXPORT_SYMBOL_GPL(vxlan_xmit_skb);

1569

EXPORT_SYMBOL_GPL(vxlan_xmit_skb);

1570

1571

/* Bypass encapsulation if the destination is local */

1571

/* Bypass encapsulation if the destination is local */

1572

static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,

1572

static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,

1573

struct vxlan_dev *dst_vxlan)

1573

struct vxlan_dev *dst_vxlan)

1574

{

1574

{

1575

struct pcpu_tstats *tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);

1575

struct pcpu_tstats *tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);

1576

struct pcpu_tstats *rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);

1576

struct pcpu_tstats *rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);

1577

union vxlan_addr loopback;

1577

union vxlan_addr loopback;

1578

union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;

1578

union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;

1579

1580

skb->pkt_type = PACKET_HOST;

1580

skb->pkt_type = PACKET_HOST;

1581

skb->encapsulation = 0;

1581

skb->encapsulation = 0;

1582

skb->dev = dst_vxlan->dev;

1582

skb->dev = dst_vxlan->dev;

1583

__skb_pull(skb, skb_network_offset(skb));

1583

__skb_pull(skb, skb_network_offset(skb));

1584

1585

if (remote_ip->sa.sa_family == AF_INET) {

1585

if (remote_ip->sa.sa_family == AF_INET) {

1586

loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

1586

loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

1587

loopback.sa.sa_family = AF_INET;

1587

loopback.sa.sa_family = AF_INET;

1588

#if IS_ENABLED(CONFIG_IPV6)

1588

#if IS_ENABLED(CONFIG_IPV6)

1589

} else {

1589

} else {

1590

loopback.sin6.sin6_addr = in6addr_loopback;

1590

loopback.sin6.sin6_addr = in6addr_loopback;

1591

loopback.sa.sa_family = AF_INET6;

1591

loopback.sa.sa_family = AF_INET6;

1592

#endif

1592

#endif

1593

}

1593

}

1594

1595

if (dst_vxlan->flags & VXLAN_F_LEARN)

1595

if (dst_vxlan->flags & VXLAN_F_LEARN)

1596

vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);

1596

vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);

1597

1598

u64_stats_update_begin(&tx_stats->syncp);

1598

u64_stats_update_begin(&tx_stats->syncp);

1599

tx_stats->tx_packets++;

1599

tx_stats->tx_packets++;

1600

tx_stats->tx_bytes += skb->len;

1600

tx_stats->tx_bytes += skb->len;

1601

u64_stats_update_end(&tx_stats->syncp);

1601

u64_stats_update_end(&tx_stats->syncp);

1602

1603

if (netif_rx(skb) == NET_RX_SUCCESS) {

1603

if (netif_rx(skb) == NET_RX_SUCCESS) {

1604

u64_stats_update_begin(&rx_stats->syncp);

1604

u64_stats_update_begin(&rx_stats->syncp);

1605

rx_stats->rx_packets++;

1605

rx_stats->rx_packets++;

1606

rx_stats->rx_bytes += skb->len;

1606

rx_stats->rx_bytes += skb->len;

1607

u64_stats_update_end(&rx_stats->syncp);

1607

u64_stats_update_end(&rx_stats->syncp);

1608

} else {

1608

} else {

1609

skb->dev->stats.rx_dropped++;

1609

skb->dev->stats.rx_dropped++;

1610

}

1610

}

1611

}

1611

}

1612

1613

static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,

1613

static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,

1614

struct vxlan_rdst *rdst, bool did_rsc)

1614

struct vxlan_rdst *rdst, bool did_rsc)

1615

{

1615

{

1616

struct vxlan_dev *vxlan = netdev_priv(dev);

1616

struct vxlan_dev *vxlan = netdev_priv(dev);

1617

struct rtable *rt = NULL;

1617

struct rtable *rt = NULL;

1618

const struct iphdr *old_iph;

1618

const struct iphdr *old_iph;

1619

struct flowi4 fl4;

1619

struct flowi4 fl4;

1620

union vxlan_addr *dst;

1620

union vxlan_addr *dst;

1621

__be16 src_port = 0, dst_port;

1621

__be16 src_port = 0, dst_port;

1622

u32 vni;

1622

u32 vni;

1623

__be16 df = 0;

1623

__be16 df = 0;

1624

__u8 tos, ttl;

1624

__u8 tos, ttl;

1625

int err;

1625

int err;

1626

1627

dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;

1627

dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;

1628

vni = rdst->remote_vni;

1628

vni = rdst->remote_vni;

1629

dst = &rdst->remote_ip;

1629

dst = &rdst->remote_ip;

1630

1631

if (vxlan_addr_any(dst)) {

1631

if (vxlan_addr_any(dst)) {

1632

if (did_rsc) {

1632

if (did_rsc) {

1633

/* short-circuited back to local bridge */

1633

/* short-circuited back to local bridge */

1634

vxlan_encap_bypass(skb, vxlan, vxlan);

1634

vxlan_encap_bypass(skb, vxlan, vxlan);

1635

return;

1635

return;

1636

}

1636

}

1637

goto drop;

1637

goto drop;

1638

}

1638

}

1639

1640

old_iph = ip_hdr(skb);

1640

old_iph = ip_hdr(skb);

1641

1642

ttl = vxlan->ttl;

1642

ttl = vxlan->ttl;

1643

if (!ttl && vxlan_addr_multicast(dst))

1643

if (!ttl && vxlan_addr_multicast(dst))

1644

ttl = 1;

1644

ttl = 1;

1645

1646

tos = vxlan->tos;

1646

tos = vxlan->tos;

1647

if (tos == 1)

1647

if (tos == 1)

1648

tos = ip_tunnel_get_dsfield(old_iph, skb);

1648

tos = ip_tunnel_get_dsfield(old_iph, skb);

1649

1650

src_port = vxlan_src_port(vxlan->port_min, vxlan->port_max, skb);

1650

src_port = vxlan_src_port(vxlan->port_min, vxlan->port_max, skb);

1651

1652

if (dst->sa.sa_family == AF_INET) {

1652

if (dst->sa.sa_family == AF_INET) {

1653

memset(&fl4, 0, sizeof(fl4));

1653

memset(&fl4, 0, sizeof(fl4));

1654

fl4.flowi4_oif = rdst->remote_ifindex;

1654

fl4.flowi4_oif = rdst->remote_ifindex;

1655

fl4.flowi4_tos = RT_TOS(tos);

1655

fl4.flowi4_tos = RT_TOS(tos);

1656

fl4.daddr = dst->sin.sin_addr.s_addr;

1656

fl4.daddr = dst->sin.sin_addr.s_addr;

1657

fl4.saddr = vxlan->saddr.sin.sin_addr.s_addr;

1657

fl4.saddr = vxlan->saddr.sin.sin_addr.s_addr;

1658

1659

rt = ip_route_output_key(dev_net(dev), &fl4);

1659

rt = ip_route_output_key(dev_net(dev), &fl4);

1660

if (IS_ERR(rt)) {

1660

if (IS_ERR(rt)) {

1661

netdev_dbg(dev, "no route to %pI4\n",

1661

netdev_dbg(dev, "no route to %pI4\n",

1662

&dst->sin.sin_addr.s_addr);

1662

&dst->sin.sin_addr.s_addr);

1663

dev->stats.tx_carrier_errors++;

1663

dev->stats.tx_carrier_errors++;

1664

goto tx_error;

1664

goto tx_error;

1665

}

1665

}

1666

1667

if (rt->dst.dev == dev) {

1667

if (rt->dst.dev == dev) {

1668

netdev_dbg(dev, "circular route to %pI4\n",

1668

netdev_dbg(dev, "circular route to %pI4\n",

1669

&dst->sin.sin_addr.s_addr);

1669

&dst->sin.sin_addr.s_addr);

1670

dev->stats.collisions++;

1670

dev->stats.collisions++;

1671

goto tx_error;

1671

goto tx_error;

1672

}

1672

}

1673

1674

/* Bypass encapsulation if the destination is local */

1674

/* Bypass encapsulation if the destination is local */

1675

if (rt->rt_flags & RTCF_LOCAL &&

1675

if (rt->rt_flags & RTCF_LOCAL &&

1676

!(rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {

1676

!(rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {

1677

struct vxlan_dev *dst_vxlan;

1677

struct vxlan_dev *dst_vxlan;

1678

1679

ip_rt_put(rt);

1679

ip_rt_put(rt);

1680

dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);

1680

dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);

1681

if (!dst_vxlan)

1681

if (!dst_vxlan)

1682

goto tx_error;

1682

goto tx_error;

1683

vxlan_encap_bypass(skb, vxlan, dst_vxlan);

1683

vxlan_encap_bypass(skb, vxlan, dst_vxlan);

1684

return;

1684

return;

1685

}

1685

}

1686

1687

tos = ip_tunnel_ecn_encap(tos, old_iph, skb);

1687

tos = ip_tunnel_ecn_encap(tos, old_iph, skb);

1688

ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);

1688

ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);

1689

1690

err = vxlan_xmit_skb(vxlan->vn_sock, rt, skb,

1690

err = vxlan_xmit_skb(vxlan->vn_sock, rt, skb,

1691

fl4.saddr, dst->sin.sin_addr.s_addr,

1691

fl4.saddr, dst->sin.sin_addr.s_addr,

1692

tos, ttl, df, src_port, dst_port,

1692

tos, ttl, df, src_port, dst_port,

1693

htonl(vni << 8));

1693

htonl(vni << 8));

1694

1695

if (err < 0)

1695

if (err < 0)

1696

goto rt_tx_error;

1696

goto rt_tx_error;

1697

iptunnel_xmit_stats(err, &dev->stats, dev->tstats);

1697

iptunnel_xmit_stats(err, &dev->stats, dev->tstats);

1698

#if IS_ENABLED(CONFIG_IPV6)

1698

#if IS_ENABLED(CONFIG_IPV6)

1699

} else {

1699

} else {

1700

struct sock *sk = vxlan->vn_sock->sock->sk;

1700

struct sock *sk = vxlan->vn_sock->sock->sk;

1701

struct dst_entry *ndst;

1701

struct dst_entry *ndst;

1702

struct flowi6 fl6;

1702

struct flowi6 fl6;

1703

u32 flags;

1703

u32 flags;

1704

1705

memset(&fl6, 0, sizeof(fl6));

1705

memset(&fl6, 0, sizeof(fl6));

1706

fl6.flowi6_oif = rdst->remote_ifindex;

1706

fl6.flowi6_oif = rdst->remote_ifindex;

1707

fl6.daddr = dst->sin6.sin6_addr;

1707

fl6.daddr = dst->sin6.sin6_addr;

1708

fl6.saddr = vxlan->saddr.sin6.sin6_addr;

1708

fl6.saddr = vxlan->saddr.sin6.sin6_addr;

1709

fl6.flowi6_proto = IPPROTO_UDP;

1709

fl6.flowi6_proto = IPPROTO_UDP;

1710

1711

if (ipv6_stub->ipv6_dst_lookup(sk, &ndst, &fl6)) {

1711

if (ipv6_stub->ipv6_dst_lookup(sk, &ndst, &fl6)) {

1712

netdev_dbg(dev, "no route to %pI6\n",

1712

netdev_dbg(dev, "no route to %pI6\n",

1713

&dst->sin6.sin6_addr);

1713

&dst->sin6.sin6_addr);

1714

dev->stats.tx_carrier_errors++;

1714

dev->stats.tx_carrier_errors++;

1715

goto tx_error;

1715

goto tx_error;

1716

}

1716

}

1717

1718

if (ndst->dev == dev) {

1718

if (ndst->dev == dev) {

1719

netdev_dbg(dev, "circular route to %pI6\n",

1719

netdev_dbg(dev, "circular route to %pI6\n",

1720

&dst->sin6.sin6_addr);

1720

&dst->sin6.sin6_addr);

1721

dst_release(ndst);

1721

dst_release(ndst);

1722

dev->stats.collisions++;

1722

dev->stats.collisions++;

1723

goto tx_error;

1723

goto tx_error;

1724

}

1724

}

1725

1726

/* Bypass encapsulation if the destination is local */

1726

/* Bypass encapsulation if the destination is local */

1727

flags = ((struct rt6_info *)ndst)->rt6i_flags;

1727

flags = ((struct rt6_info *)ndst)->rt6i_flags;

1728

if (flags & RTF_LOCAL &&

1728

if (flags & RTF_LOCAL &&

1729

!(flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {

1729

!(flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {

1730

struct vxlan_dev *dst_vxlan;

1730

struct vxlan_dev *dst_vxlan;

1731

1732

dst_release(ndst);

1732

dst_release(ndst);

1733

dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);

1733

dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);

1734

if (!dst_vxlan)

1734

if (!dst_vxlan)

1735

goto tx_error;

1735

goto tx_error;

1736

vxlan_encap_bypass(skb, vxlan, dst_vxlan);

1736

vxlan_encap_bypass(skb, vxlan, dst_vxlan);

1737

return;

1737

return;

1738

}

1738

}

1739

1740

ttl = ttl ? : ip6_dst_hoplimit(ndst);

1740

ttl = ttl ? : ip6_dst_hoplimit(ndst);

1741

1742

err = vxlan6_xmit_skb(vxlan->vn_sock, ndst, skb,

1742

err = vxlan6_xmit_skb(vxlan->vn_sock, ndst, skb,

1743

dev, &fl6.saddr, &fl6.daddr, 0, ttl,

1743

dev, &fl6.saddr, &fl6.daddr, 0, ttl,

1744

src_port, dst_port, htonl(vni << 8));

1744

src_port, dst_port, htonl(vni << 8));

1745

#endif

1745

#endif

1746

}

1746

}

1747

1748

return;

1748

return;

1749

1750

drop:

1750

drop:

1751

dev->stats.tx_dropped++;

1751

dev->stats.tx_dropped++;

1752

goto tx_free;

1752

goto tx_free;

1753

1754

rt_tx_error:

1754

rt_tx_error:

1755

ip_rt_put(rt);

1755

ip_rt_put(rt);

1756

tx_error:

1756

tx_error:

1757

dev->stats.tx_errors++;

1757

dev->stats.tx_errors++;

1758

tx_free:

1758

tx_free:

1759

dev_kfree_skb(skb);

1759

dev_kfree_skb(skb);

1760

}

1760

}

1761

1762

/* Transmit local packets over Vxlan

1762

/* Transmit local packets over Vxlan

1763

*

1763

*

1764

* Outer IP header inherits ECN and DF from inner header.

1764

* Outer IP header inherits ECN and DF from inner header.

1765

* Outer UDP destination is the VXLAN assigned port.

1765

* Outer UDP destination is the VXLAN assigned port.

1766

* source port is based on hash of flow

1766

* source port is based on hash of flow

1767

*/

1767

*/

1768

static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)

1768

static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)

1769

{

1769

{

1770

struct vxlan_dev *vxlan = netdev_priv(dev);

1770

struct vxlan_dev *vxlan = netdev_priv(dev);

1771

struct ethhdr *eth;

1771

struct ethhdr *eth;

1772

bool did_rsc = false;

1772

bool did_rsc = false;

1773

struct vxlan_rdst *rdst;

1773

struct vxlan_rdst *rdst;

1774

struct vxlan_fdb *f;

1774

struct vxlan_fdb *f;

1775

1776

skb_reset_mac_header(skb);

1776

skb_reset_mac_header(skb);

1777

eth = eth_hdr(skb);

1777

eth = eth_hdr(skb);

1778

1779

if ((vxlan->flags & VXLAN_F_PROXY)) {

1779

if ((vxlan->flags & VXLAN_F_PROXY)) {

1780

if (ntohs(eth->h_proto) == ETH_P_ARP)

1780

if (ntohs(eth->h_proto) == ETH_P_ARP)

1781

return arp_reduce(dev, skb);

1781

return arp_reduce(dev, skb);

1782

#if IS_ENABLED(CONFIG_IPV6)

1782

#if IS_ENABLED(CONFIG_IPV6)

1783

else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&

1783

else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&

1784

skb->len >= sizeof(struct ipv6hdr) + sizeof(struct nd_msg) &&

1784

skb->len >= sizeof(struct ipv6hdr) + sizeof(struct nd_msg) &&

1785

ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {

1785

ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {

1786

struct nd_msg *msg;

1786

struct nd_msg *msg;

1787

1788

msg = (struct nd_msg *)skb_transport_header(skb);

1788

msg = (struct nd_msg *)skb_transport_header(skb);

1789

if (msg->icmph.icmp6_code == 0 &&

1789

if (msg->icmph.icmp6_code == 0 &&

1790

msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)

1790

msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)

1791

return neigh_reduce(dev, skb);

1791

return neigh_reduce(dev, skb);

1792

}

1792

}

1793

#endif

1793

#endif

1794

}

1794

}

1795

1796

f = vxlan_find_mac(vxlan, eth->h_dest);

1796

f = vxlan_find_mac(vxlan, eth->h_dest);

1797

did_rsc = false;

1797

did_rsc = false;

1798

1799

if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&

1799

if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&

1800

(ntohs(eth->h_proto) == ETH_P_IP ||

1800

(ntohs(eth->h_proto) == ETH_P_IP ||

1801

ntohs(eth->h_proto) == ETH_P_IPV6)) {

1801

ntohs(eth->h_proto) == ETH_P_IPV6)) {

1802

did_rsc = route_shortcircuit(dev, skb);

1802

did_rsc = route_shortcircuit(dev, skb);

1803

if (did_rsc)

1803

if (did_rsc)

1804

f = vxlan_find_mac(vxlan, eth->h_dest);

1804

f = vxlan_find_mac(vxlan, eth->h_dest);

1805

}

1805

}

1806

1807

if (f == NULL) {

1807

if (f == NULL) {

1808

f = vxlan_find_mac(vxlan, all_zeros_mac);

1808

f = vxlan_find_mac(vxlan, all_zeros_mac);

1809

if (f == NULL) {

1809

if (f == NULL) {

1810

if ((vxlan->flags & VXLAN_F_L2MISS) &&

1810

if ((vxlan->flags & VXLAN_F_L2MISS) &&

1811

!is_multicast_ether_addr(eth->h_dest))

1811

!is_multicast_ether_addr(eth->h_dest))

1812

vxlan_fdb_miss(vxlan, eth->h_dest);

1812

vxlan_fdb_miss(vxlan, eth->h_dest);

1813

1814

dev->stats.tx_dropped++;

1814

dev->stats.tx_dropped++;

1815

dev_kfree_skb(skb);

1815

dev_kfree_skb(skb);

1816

return NETDEV_TX_OK;

1816

return NETDEV_TX_OK;

1817

}

1817

}

1818

}

1818

}

1819

1820

list_for_each_entry_rcu(rdst, &f->remotes, list) {

1820

list_for_each_entry_rcu(rdst, &f->remotes, list) {

1821

struct sk_buff *skb1;

1821

struct sk_buff *skb1;

1822

1823

skb1 = skb_clone(skb, GFP_ATOMIC);

1823

skb1 = skb_clone(skb, GFP_ATOMIC);

1824

if (skb1)

1824

if (skb1)

1825

vxlan_xmit_one(skb1, dev, rdst, did_rsc);

1825

vxlan_xmit_one(skb1, dev, rdst, did_rsc);

1826

}

1826

}

1827

1828

dev_kfree_skb(skb);

1828

dev_kfree_skb(skb);

1829

return NETDEV_TX_OK;

1829

return NETDEV_TX_OK;

1830

}

1830

}

1831

1832

/* Walk the forwarding table and purge stale entries */

1832

/* Walk the forwarding table and purge stale entries */

1833

static void vxlan_cleanup(unsigned long arg)

1833

static void vxlan_cleanup(unsigned long arg)

1834

{

1834

{

1835

struct vxlan_dev *vxlan = (struct vxlan_dev *) arg;

1835

struct vxlan_dev *vxlan = (struct vxlan_dev *) arg;

1836

unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;

1836

unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;

1837

unsigned int h;

1837

unsigned int h;

1838

1839

if (!netif_running(vxlan->dev))

1839

if (!netif_running(vxlan->dev))

1840

return;

1840

return;

1841

1842

spin_lock_bh(&vxlan->hash_lock);

1842

spin_lock_bh(&vxlan->hash_lock);

1843

for (h = 0; h < FDB_HASH_SIZE; ++h) {

1843

for (h = 0; h < FDB_HASH_SIZE; ++h) {

1844

struct hlist_node *p, *n;

1844

struct hlist_node *p, *n;

1845

hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {

1845

hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {

1846

struct vxlan_fdb *f

1846

struct vxlan_fdb *f

1847

= container_of(p, struct vxlan_fdb, hlist);

1847

= container_of(p, struct vxlan_fdb, hlist);

1848

unsigned long timeout;

1848

unsigned long timeout;

1849

1850

if (f->state & NUD_PERMANENT)

1850

if (f->state & NUD_PERMANENT)

1851

continue;

1851

continue;

1852

1853

timeout = f->used + vxlan->age_interval * HZ;

1853

timeout = f->used + vxlan->age_interval * HZ;

1854

if (time_before_eq(timeout, jiffies)) {

1854

if (time_before_eq(timeout, jiffies)) {

1855

netdev_dbg(vxlan->dev,

1855

netdev_dbg(vxlan->dev,

1856

"garbage collect %pM\n",

1856

"garbage collect %pM\n",

1857

f->eth_addr);

1857

f->eth_addr);

1858

f->state = NUD_STALE;

1858

f->state = NUD_STALE;

1859

vxlan_fdb_destroy(vxlan, f);

1859

vxlan_fdb_destroy(vxlan, f);

1860

} else if (time_before(timeout, next_timer))

1860

} else if (time_before(timeout, next_timer))

1861

next_timer = timeout;

1861

next_timer = timeout;

1862

}

1862

}

1863

}

1863

}

1864

spin_unlock_bh(&vxlan->hash_lock);

1864

spin_unlock_bh(&vxlan->hash_lock);

1865

1866

mod_timer(&vxlan->age_timer, next_timer);

1866

mod_timer(&vxlan->age_timer, next_timer);

1867

}

1867

}

1868

1869

static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)

1869

static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)

1870

{

1870

{

1871

__u32 vni = vxlan->default_dst.remote_vni;

1871

__u32 vni = vxlan->default_dst.remote_vni;

1872

1873

vxlan->vn_sock = vs;

1873

vxlan->vn_sock = vs;

1874

hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));

1874

hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));

1875

}

1875

}

1876

1877

/* Setup stats when device is created */

1877

/* Setup stats when device is created */

1878

static int vxlan_init(struct net_device *dev)

1878

static int vxlan_init(struct net_device *dev)

1879

{

1879

{

1880

struct vxlan_dev *vxlan = netdev_priv(dev);

1880

struct vxlan_dev *vxlan = netdev_priv(dev);

1881

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

1881

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

1882

struct vxlan_sock *vs;

1882

struct vxlan_sock *vs;

1883

int i;

1883

int i;

1884

1885

dev->tstats = alloc_percpu(struct pcpu_tstats);

1885

dev->tstats = alloc_percpu(struct pcpu_tstats);

1886

if (!dev->tstats)

1886

if (!dev->tstats)

1887

return -ENOMEM;

1887

return -ENOMEM;

1888

1889

for_each_possible_cpu(i) {

1889

for_each_possible_cpu(i) {

1890

struct pcpu_tstats *vxlan_stats;

1890

struct pcpu_tstats *vxlan_stats;

1891

vxlan_stats = per_cpu_ptr(dev->tstats, i);

1891

vxlan_stats = per_cpu_ptr(dev->tstats, i);

1892

u64_stats_init(&vxlan_stats->syncp);

1892

u64_stats_init(&vxlan_stats->syncp);

1893

}

1893

}

1894

1895

1896

spin_lock(&vn->sock_lock);

1896

spin_lock(&vn->sock_lock);

1897

vs = vxlan_find_sock(dev_net(dev), vxlan->dst_port);

1897

vs = vxlan_find_sock(dev_net(dev), vxlan->dst_port);

1898

if (vs) {

1898

if (vs) {

1899

/* If we have a socket with same port already, reuse it */

1899

/* If we have a socket with same port already, reuse it */

1900

atomic_inc(&vs->refcnt);

1900

atomic_inc(&vs->refcnt);

1901

vxlan_vs_add_dev(vs, vxlan);

1901

vxlan_vs_add_dev(vs, vxlan);

1902

} else {

1902

} else {

1903

/* otherwise make new socket outside of RTNL */

1903

/* otherwise make new socket outside of RTNL */

1904

dev_hold(dev);

1904

dev_hold(dev);

1905

queue_work(vxlan_wq, &vxlan->sock_work);

1905

queue_work(vxlan_wq, &vxlan->sock_work);

1906

}

1906

}

1907

spin_unlock(&vn->sock_lock);

1907

spin_unlock(&vn->sock_lock);

1908

1909

return 0;

1909

return 0;

1910

}

1910

}

1911

1912

static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)

1912

static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)

1913

{

1913

{

1914

struct vxlan_fdb *f;

1914

struct vxlan_fdb *f;

1915

1916

spin_lock_bh(&vxlan->hash_lock);

1916

spin_lock_bh(&vxlan->hash_lock);

1917

f = __vxlan_find_mac(vxlan, all_zeros_mac);

1917

f = __vxlan_find_mac(vxlan, all_zeros_mac);

1918

if (f)

1918

if (f)

1919

vxlan_fdb_destroy(vxlan, f);

1919

vxlan_fdb_destroy(vxlan, f);

1920

spin_unlock_bh(&vxlan->hash_lock);

1920

spin_unlock_bh(&vxlan->hash_lock);

1921

}

1921

}

1922

1923

static void vxlan_uninit(struct net_device *dev)

1923

static void vxlan_uninit(struct net_device *dev)

1924

{

1924

{

1925

struct vxlan_dev *vxlan = netdev_priv(dev);

1925

struct vxlan_dev *vxlan = netdev_priv(dev);

1926

struct vxlan_sock *vs = vxlan->vn_sock;

1926

struct vxlan_sock *vs = vxlan->vn_sock;

1927

1928

vxlan_fdb_delete_default(vxlan);

1928

vxlan_fdb_delete_default(vxlan);

1929

1930

if (vs)

1930

if (vs)

1931

vxlan_sock_release(vs);

1931

vxlan_sock_release(vs);

1932

free_percpu(dev->tstats);

1932

free_percpu(dev->tstats);

1933

}

1933

}

1934

1935

/* Start ageing timer and join group when device is brought up */

1935

/* Start ageing timer and join group when device is brought up */

1936

static int vxlan_open(struct net_device *dev)

1936

static int vxlan_open(struct net_device *dev)

1937

{

1937

{

1938

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

1939

struct vxlan_dev *vxlan = netdev_priv(dev);

1938

struct vxlan_dev *vxlan = netdev_priv(dev);

1940

struct vxlan_sock *vs = vxlan->vn_sock;

1939

struct vxlan_sock *vs = vxlan->vn_sock;

1941

1940

1942

/* socket hasn't been created */

1941

/* socket hasn't been created */

1943

if (!vs)

1942

if (!vs)

1944

return -ENOTCONN;

1943

return -ENOTCONN;

1945

1944

1946

if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&

1945

if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {

1947

vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {

1948

vxlan_sock_hold(vs);

1946

vxlan_sock_hold(vs);

1949

dev_hold(dev);

1947

dev_hold(dev);

1950

queue_work(vxlan_wq, &vxlan->igmp_join);

1948

queue_work(vxlan_wq, &vxlan->igmp_join);

1951

}

1949

}

1952

1950

1953

if (vxlan->age_interval)

1951

if (vxlan->age_interval)

1954

mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);

1952

mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);

1955

1953

1956

return 0;

1954

return 0;

1957

}

1955

}

1958

1956

1959

/* Purge the forwarding table */

1957

/* Purge the forwarding table */

1960

static void vxlan_flush(struct vxlan_dev *vxlan)

1958

static void vxlan_flush(struct vxlan_dev *vxlan)

1961

{

1959

{

1962

unsigned int h;

1960

unsigned int h;

1963

1961

1964

spin_lock_bh(&vxlan->hash_lock);

1962

spin_lock_bh(&vxlan->hash_lock);

1965

for (h = 0; h < FDB_HASH_SIZE; ++h) {

1963

for (h = 0; h < FDB_HASH_SIZE; ++h) {

1966

struct hlist_node *p, *n;

1964

struct hlist_node *p, *n;

1967

hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {

1965

hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {

1968

struct vxlan_fdb *f

1966

struct vxlan_fdb *f

1969

= container_of(p, struct vxlan_fdb, hlist);

1967

= container_of(p, struct vxlan_fdb, hlist);

1970

/* the all_zeros_mac entry is deleted at vxlan_uninit */

1968

/* the all_zeros_mac entry is deleted at vxlan_uninit */

1971

if (!is_zero_ether_addr(f->eth_addr))

1969

if (!is_zero_ether_addr(f->eth_addr))

1972

vxlan_fdb_destroy(vxlan, f);

1970

vxlan_fdb_destroy(vxlan, f);

1973

}

1971

}

1974

}

1972

}

1975

spin_unlock_bh(&vxlan->hash_lock);

1973

spin_unlock_bh(&vxlan->hash_lock);

1976

}

1974

}

1977

1975

1978

/* Cleanup timer and forwarding table on shutdown */

1976

/* Cleanup timer and forwarding table on shutdown */

1979

static int vxlan_stop(struct net_device *dev)

1977

static int vxlan_stop(struct net_device *dev)

1980

{

1978

{

1981

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

1979

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

1982

struct vxlan_dev *vxlan = netdev_priv(dev);

1980

struct vxlan_dev *vxlan = netdev_priv(dev);

1983

struct vxlan_sock *vs = vxlan->vn_sock;

1981

struct vxlan_sock *vs = vxlan->vn_sock;

1984

1982

1985

if (vs && vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&

1983

if (vs && vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&

1986

! vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {

1984

! vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {

1987

vxlan_sock_hold(vs);

1985

vxlan_sock_hold(vs);

1988

dev_hold(dev);

1986

dev_hold(dev);

1989

queue_work(vxlan_wq, &vxlan->igmp_leave);

1987

queue_work(vxlan_wq, &vxlan->igmp_leave);

1990

}

1988

}

1991

1989

1992

del_timer_sync(&vxlan->age_timer);

1990

del_timer_sync(&vxlan->age_timer);

1993

1991

1994

vxlan_flush(vxlan);

1992

vxlan_flush(vxlan);

1995

1993

1996

return 0;

1994

return 0;

1997

}

1995

}

1998

1996

1999

/* Stub, nothing needs to be done. */

1997

/* Stub, nothing needs to be done. */

2000

static void vxlan_set_multicast_list(struct net_device *dev)

1998

static void vxlan_set_multicast_list(struct net_device *dev)

2001

{

1999

{

2002

}

2000

}

2003

2001

2004

static const struct net_device_ops vxlan_netdev_ops = {

2002

static const struct net_device_ops vxlan_netdev_ops = {

2005

.ndo_init = vxlan_init,

2003

.ndo_init = vxlan_init,

2006

.ndo_uninit = vxlan_uninit,

2004

.ndo_uninit = vxlan_uninit,

2007

.ndo_open = vxlan_open,

2005

.ndo_open = vxlan_open,

2008

.ndo_stop = vxlan_stop,

2006

.ndo_stop = vxlan_stop,

2009

.ndo_start_xmit = vxlan_xmit,

2007

.ndo_start_xmit = vxlan_xmit,

2010

.ndo_get_stats64 = ip_tunnel_get_stats64,

2008

.ndo_get_stats64 = ip_tunnel_get_stats64,

2011

.ndo_set_rx_mode = vxlan_set_multicast_list,

2009

.ndo_set_rx_mode = vxlan_set_multicast_list,

2012

.ndo_change_mtu = eth_change_mtu,

2010

.ndo_change_mtu = eth_change_mtu,

2013

.ndo_validate_addr = eth_validate_addr,

2011

.ndo_validate_addr = eth_validate_addr,

2014

.ndo_set_mac_address = eth_mac_addr,

2012

.ndo_set_mac_address = eth_mac_addr,

2015

.ndo_fdb_add = vxlan_fdb_add,

2013

.ndo_fdb_add = vxlan_fdb_add,

2016

.ndo_fdb_del = vxlan_fdb_delete,

2014

.ndo_fdb_del = vxlan_fdb_delete,

2017

.ndo_fdb_dump = vxlan_fdb_dump,

2015

.ndo_fdb_dump = vxlan_fdb_dump,

2018

};

2016

};

2019

2017

2020

/* Info for udev, that this is a virtual tunnel endpoint */

2018

/* Info for udev, that this is a virtual tunnel endpoint */

2021

static struct device_type vxlan_type = {

2019

static struct device_type vxlan_type = {

2022

.name = "vxlan",

2020

.name = "vxlan",

2023

};

2021

};

2024

2022

2025

/* Calls the ndo_add_vxlan_port of the caller in order to

2023

/* Calls the ndo_add_vxlan_port of the caller in order to

2026

* supply the listening VXLAN udp ports. Callers are expected

2024

* supply the listening VXLAN udp ports. Callers are expected

2027

* to implement the ndo_add_vxlan_port.

2025

* to implement the ndo_add_vxlan_port.

2028

*/

2026

*/

2029

void vxlan_get_rx_port(struct net_device *dev)

2027

void vxlan_get_rx_port(struct net_device *dev)

2030

{

2028

{

2031

struct vxlan_sock *vs;

2029

struct vxlan_sock *vs;

2032

struct net *net = dev_net(dev);

2030

struct net *net = dev_net(dev);

2033

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2031

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2034

sa_family_t sa_family;

2032

sa_family_t sa_family;

2035

__be16 port;

2033

__be16 port;

2036

unsigned int i;

2034

unsigned int i;

2037

2035

2038

spin_lock(&vn->sock_lock);

2036

spin_lock(&vn->sock_lock);

2039

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

2037

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

2040

hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {

2038

hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {

2041

port = inet_sk(vs->sock->sk)->inet_sport;

2039

port = inet_sk(vs->sock->sk)->inet_sport;

2042

sa_family = vs->sock->sk->sk_family;

2040

sa_family = vs->sock->sk->sk_family;

2043

dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,

2041

dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,

2044

port);

2042

port);

2045

}

2043

}

2046

}

2044

}

2047

spin_unlock(&vn->sock_lock);

2045

spin_unlock(&vn->sock_lock);

2048

}

2046

}

2049

EXPORT_SYMBOL_GPL(vxlan_get_rx_port);

2047

EXPORT_SYMBOL_GPL(vxlan_get_rx_port);

2050

2048

2051

/* Initialize the device structure. */

2049

/* Initialize the device structure. */

2052

static void vxlan_setup(struct net_device *dev)

2050

static void vxlan_setup(struct net_device *dev)

2053

{

2051

{

2054

struct vxlan_dev *vxlan = netdev_priv(dev);

2052

struct vxlan_dev *vxlan = netdev_priv(dev);

2055

unsigned int h;

2053

unsigned int h;

2056

int low, high;

2054

int low, high;

2057

2055

2058

eth_hw_addr_random(dev);

2056

eth_hw_addr_random(dev);

2059

ether_setup(dev);

2057

ether_setup(dev);

2060

if (vxlan->default_dst.remote_ip.sa.sa_family == AF_INET6)

2058

if (vxlan->default_dst.remote_ip.sa.sa_family == AF_INET6)

2061

dev->hard_header_len = ETH_HLEN + VXLAN6_HEADROOM;

2059

dev->hard_header_len = ETH_HLEN + VXLAN6_HEADROOM;

2062

else

2060

else

2063

dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;

2061

dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;

2064

2062

2065

dev->netdev_ops = &vxlan_netdev_ops;

2063

dev->netdev_ops = &vxlan_netdev_ops;

2066

dev->destructor = free_netdev;

2064

dev->destructor = free_netdev;

2067

SET_NETDEV_DEVTYPE(dev, &vxlan_type);

2065

SET_NETDEV_DEVTYPE(dev, &vxlan_type);

2068

2066

2069

dev->tx_queue_len = 0;

2067

dev->tx_queue_len = 0;

2070

dev->features |= NETIF_F_LLTX;

2068

dev->features |= NETIF_F_LLTX;

2071

dev->features |= NETIF_F_NETNS_LOCAL;

2069

dev->features |= NETIF_F_NETNS_LOCAL;

2072

dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;

2070

dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;

2073

dev->features |= NETIF_F_RXCSUM;

2071

dev->features |= NETIF_F_RXCSUM;

2074

dev->features |= NETIF_F_GSO_SOFTWARE;

2072

dev->features |= NETIF_F_GSO_SOFTWARE;

2075

2073

2076

dev->vlan_features = dev->features;

2074

dev->vlan_features = dev->features;

2077

dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;

2075

dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;

2078

dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;

2076

dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;

2079

dev->hw_features |= NETIF_F_GSO_SOFTWARE;

2077

dev->hw_features |= NETIF_F_GSO_SOFTWARE;

2080

dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;

2078

dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;

2081

dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;

2079

dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;

2082

dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;

2080

dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;

2083

2081

2084

INIT_LIST_HEAD(&vxlan->next);

2082

INIT_LIST_HEAD(&vxlan->next);

2085

spin_lock_init(&vxlan->hash_lock);

2083

spin_lock_init(&vxlan->hash_lock);

2086

INIT_WORK(&vxlan->igmp_join, vxlan_igmp_join);

2084

INIT_WORK(&vxlan->igmp_join, vxlan_igmp_join);

2087

INIT_WORK(&vxlan->igmp_leave, vxlan_igmp_leave);

2085

INIT_WORK(&vxlan->igmp_leave, vxlan_igmp_leave);

2088

INIT_WORK(&vxlan->sock_work, vxlan_sock_work);

2086

INIT_WORK(&vxlan->sock_work, vxlan_sock_work);

2089

2087

2090

init_timer_deferrable(&vxlan->age_timer);

2088

init_timer_deferrable(&vxlan->age_timer);

2091

vxlan->age_timer.function = vxlan_cleanup;

2089

vxlan->age_timer.function = vxlan_cleanup;

2092

vxlan->age_timer.data = (unsigned long) vxlan;

2090

vxlan->age_timer.data = (unsigned long) vxlan;

2093

2091

2094

inet_get_local_port_range(dev_net(dev), &low, &high);

2092

inet_get_local_port_range(dev_net(dev), &low, &high);

2095

vxlan->port_min = low;

2093

vxlan->port_min = low;

2096

vxlan->port_max = high;

2094

vxlan->port_max = high;

2097

vxlan->dst_port = htons(vxlan_port);

2095

vxlan->dst_port = htons(vxlan_port);

2098

2096

2099

vxlan->dev = dev;

2097

vxlan->dev = dev;

2100

2098

2101

for (h = 0; h < FDB_HASH_SIZE; ++h)

2099

for (h = 0; h < FDB_HASH_SIZE; ++h)

2102

INIT_HLIST_HEAD(&vxlan->fdb_head[h]);

2100

INIT_HLIST_HEAD(&vxlan->fdb_head[h]);

2103

}

2101

}

2104

2102

2105

static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {

2103

static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {

2106

[IFLA_VXLAN_ID] = { .type = NLA_U32 },

2104

[IFLA_VXLAN_ID] = { .type = NLA_U32 },

2107

[IFLA_VXLAN_GROUP] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },

2105

[IFLA_VXLAN_GROUP] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },

2108

[IFLA_VXLAN_GROUP6] = { .len = sizeof(struct in6_addr) },

2106

[IFLA_VXLAN_GROUP6] = { .len = sizeof(struct in6_addr) },

2109

[IFLA_VXLAN_LINK] = { .type = NLA_U32 },

2107

[IFLA_VXLAN_LINK] = { .type = NLA_U32 },

2110

[IFLA_VXLAN_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },

2108

[IFLA_VXLAN_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },

2111

[IFLA_VXLAN_LOCAL6] = { .len = sizeof(struct in6_addr) },

2109

[IFLA_VXLAN_LOCAL6] = { .len = sizeof(struct in6_addr) },

2112

[IFLA_VXLAN_TOS] = { .type = NLA_U8 },

2110

[IFLA_VXLAN_TOS] = { .type = NLA_U8 },

2113

[IFLA_VXLAN_TTL] = { .type = NLA_U8 },

2111

[IFLA_VXLAN_TTL] = { .type = NLA_U8 },

2114

[IFLA_VXLAN_LEARNING] = { .type = NLA_U8 },

2112

[IFLA_VXLAN_LEARNING] = { .type = NLA_U8 },

2115

[IFLA_VXLAN_AGEING] = { .type = NLA_U32 },

2113

[IFLA_VXLAN_AGEING] = { .type = NLA_U32 },

2116

[IFLA_VXLAN_LIMIT] = { .type = NLA_U32 },

2114

[IFLA_VXLAN_LIMIT] = { .type = NLA_U32 },

2117

[IFLA_VXLAN_PORT_RANGE] = { .len = sizeof(struct ifla_vxlan_port_range) },

2115

[IFLA_VXLAN_PORT_RANGE] = { .len = sizeof(struct ifla_vxlan_port_range) },

2118

[IFLA_VXLAN_PROXY] = { .type = NLA_U8 },

2116

[IFLA_VXLAN_PROXY] = { .type = NLA_U8 },

2119

[IFLA_VXLAN_RSC] = { .type = NLA_U8 },

2117

[IFLA_VXLAN_RSC] = { .type = NLA_U8 },

2120

[IFLA_VXLAN_L2MISS] = { .type = NLA_U8 },

2118

[IFLA_VXLAN_L2MISS] = { .type = NLA_U8 },

2121

[IFLA_VXLAN_L3MISS] = { .type = NLA_U8 },

2119

[IFLA_VXLAN_L3MISS] = { .type = NLA_U8 },

2122

[IFLA_VXLAN_PORT] = { .type = NLA_U16 },

2120

[IFLA_VXLAN_PORT] = { .type = NLA_U16 },

2123

};

2121

};

2124

2122

2125

static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[])

2123

static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[])

2126

{

2124

{

2127

if (tb[IFLA_ADDRESS]) {

2125

if (tb[IFLA_ADDRESS]) {

2128

if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {

2126

if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {

2129

pr_debug("invalid link address (not ethernet)\n");

2127

pr_debug("invalid link address (not ethernet)\n");

2130

return -EINVAL;

2128

return -EINVAL;

2131

}

2129

}

2132

2130

2133

if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {

2131

if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {

2134

pr_debug("invalid all zero ethernet address\n");

2132

pr_debug("invalid all zero ethernet address\n");

2135

return -EADDRNOTAVAIL;

2133

return -EADDRNOTAVAIL;

2136

}

2134

}

2137

}

2135

}

2138

2136

2139

if (!data)

2137

if (!data)

2140

return -EINVAL;

2138

return -EINVAL;

2141

2139

2142

if (data[IFLA_VXLAN_ID]) {

2140

if (data[IFLA_VXLAN_ID]) {

2143

__u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);

2141

__u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);

2144

if (id >= VXLAN_VID_MASK)

2142

if (id >= VXLAN_VID_MASK)

2145

return -ERANGE;

2143

return -ERANGE;

2146

}

2144

}

2147

2145

2148

if (data[IFLA_VXLAN_PORT_RANGE]) {

2146

if (data[IFLA_VXLAN_PORT_RANGE]) {

2149

const struct ifla_vxlan_port_range *p

2147

const struct ifla_vxlan_port_range *p

2150

= nla_data(data[IFLA_VXLAN_PORT_RANGE]);

2148

= nla_data(data[IFLA_VXLAN_PORT_RANGE]);

2151

2149

2152

if (ntohs(p->high) < ntohs(p->low)) {

2150

if (ntohs(p->high) < ntohs(p->low)) {

2153

pr_debug("port range %u .. %u not valid\n",

2151

pr_debug("port range %u .. %u not valid\n",

2154

ntohs(p->low), ntohs(p->high));

2152

ntohs(p->low), ntohs(p->high));

2155

return -EINVAL;

2153

return -EINVAL;

2156

}

2154

}

2157

}

2155

}

2158

2156

2159

return 0;

2157

return 0;

2160

}

2158

}

2161

2159

2162

static void vxlan_get_drvinfo(struct net_device *netdev,

2160

static void vxlan_get_drvinfo(struct net_device *netdev,

2163

struct ethtool_drvinfo *drvinfo)

2161

struct ethtool_drvinfo *drvinfo)

2164

{

2162

{

2165

strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));

2163

strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));

2166

strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));

2164

strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));

2167

}

2165

}

2168

2166

2169

static const struct ethtool_ops vxlan_ethtool_ops = {

2167

static const struct ethtool_ops vxlan_ethtool_ops = {

2170

.get_drvinfo = vxlan_get_drvinfo,

2168

.get_drvinfo = vxlan_get_drvinfo,

2171

.get_link = ethtool_op_get_link,

2169

.get_link = ethtool_op_get_link,

2172

};

2170

};

2173

2171

2174

static void vxlan_del_work(struct work_struct *work)

2172

static void vxlan_del_work(struct work_struct *work)

2175

{

2173

{

2176

struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);

2174

struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);

2177

2175

2178

sk_release_kernel(vs->sock->sk);

2176

sk_release_kernel(vs->sock->sk);

2179

kfree_rcu(vs, rcu);

2177

kfree_rcu(vs, rcu);

2180

}

2178

}

2181

2179

2182

#if IS_ENABLED(CONFIG_IPV6)

2180

#if IS_ENABLED(CONFIG_IPV6)

2183

/* Create UDP socket for encapsulation receive. AF_INET6 socket

2181

/* Create UDP socket for encapsulation receive. AF_INET6 socket

2184

* could be used for both IPv4 and IPv6 communications, but

2182

* could be used for both IPv4 and IPv6 communications, but

2185

* users may set bindv6only=1.

2183

* users may set bindv6only=1.

2186

*/

2184

*/

2187

static struct socket *create_v6_sock(struct net *net, __be16 port)

2185

static struct socket *create_v6_sock(struct net *net, __be16 port)

2188

{

2186

{

2189

struct sock *sk;

2187

struct sock *sk;

2190

struct socket *sock;

2188

struct socket *sock;

2191

struct sockaddr_in6 vxlan_addr = {

2189

struct sockaddr_in6 vxlan_addr = {

2192

.sin6_family = AF_INET6,

2190

.sin6_family = AF_INET6,

2193

.sin6_port = port,

2191

.sin6_port = port,

2194

};

2192

};

2195

int rc, val = 1;

2193

int rc, val = 1;

2196

2194

2197

rc = sock_create_kern(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);

2195

rc = sock_create_kern(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);

2198

if (rc < 0) {

2196

if (rc < 0) {

2199

pr_debug("UDPv6 socket create failed\n");

2197

pr_debug("UDPv6 socket create failed\n");

2200

return ERR_PTR(rc);

2198

return ERR_PTR(rc);

2201

}

2199

}

2202

2200

2203

/* Put in proper namespace */

2201

/* Put in proper namespace */

2204

sk = sock->sk;

2202

sk = sock->sk;

2205

sk_change_net(sk, net);

2203

sk_change_net(sk, net);

2206

2204

2207

kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,

2205

kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,

2208

(char *)&val, sizeof(val));

2206

(char *)&val, sizeof(val));

2209

rc = kernel_bind(sock, (struct sockaddr *)&vxlan_addr,

2207

rc = kernel_bind(sock, (struct sockaddr *)&vxlan_addr,

2210

sizeof(struct sockaddr_in6));

2208

sizeof(struct sockaddr_in6));

2211

if (rc < 0) {

2209

if (rc < 0) {

2212

pr_debug("bind for UDPv6 socket %pI6:%u (%d)\n",

2210

pr_debug("bind for UDPv6 socket %pI6:%u (%d)\n",

2213

&vxlan_addr.sin6_addr, ntohs(vxlan_addr.sin6_port), rc);

2211

&vxlan_addr.sin6_addr, ntohs(vxlan_addr.sin6_port), rc);

2214

sk_release_kernel(sk);

2212

sk_release_kernel(sk);

2215

return ERR_PTR(rc);

2213

return ERR_PTR(rc);

2216

}

2214

}

2217

/* At this point, IPv6 module should have been loaded in

2215

/* At this point, IPv6 module should have been loaded in

2218

* sock_create_kern().

2216

* sock_create_kern().

2219

*/

2217

*/

2220

BUG_ON(!ipv6_stub);

2218

BUG_ON(!ipv6_stub);

2221

2219

2222

/* Disable multicast loopback */

2220

/* Disable multicast loopback */

2223

inet_sk(sk)->mc_loop = 0;

2221

inet_sk(sk)->mc_loop = 0;

2224

return sock;

2222

return sock;

2225

}

2223

}

2226

2224

2227

#else

2225

#else

2228

2226

2229

static struct socket *create_v6_sock(struct net *net, __be16 port)

2227

static struct socket *create_v6_sock(struct net *net, __be16 port)

2230

{

2228

{

2231

return ERR_PTR(-EPFNOSUPPORT);

2229

return ERR_PTR(-EPFNOSUPPORT);

2232

}

2230

}

2233

#endif

2231

#endif

2234

2232

2235

static struct socket *create_v4_sock(struct net *net, __be16 port)

2233

static struct socket *create_v4_sock(struct net *net, __be16 port)

2236

{

2234

{

2237

struct sock *sk;

2235

struct sock *sk;

2238

struct socket *sock;

2236

struct socket *sock;

2239

struct sockaddr_in vxlan_addr = {

2237

struct sockaddr_in vxlan_addr = {

2240

.sin_family = AF_INET,

2238

.sin_family = AF_INET,

2241

.sin_addr.s_addr = htonl(INADDR_ANY),

2239

.sin_addr.s_addr = htonl(INADDR_ANY),

2242

.sin_port = port,

2240

.sin_port = port,

2243

};

2241

};

2244

int rc;

2242

int rc;

2245

2243

2246

/* Create UDP socket for encapsulation receive. */

2244

/* Create UDP socket for encapsulation receive. */

2247

rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);

2245

rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);

2248

if (rc < 0) {

2246

if (rc < 0) {

2249

pr_debug("UDP socket create failed\n");

2247

pr_debug("UDP socket create failed\n");

2250

return ERR_PTR(rc);

2248

return ERR_PTR(rc);

2251

}

2249

}

2252

2250

2253

/* Put in proper namespace */

2251

/* Put in proper namespace */

2254

sk = sock->sk;

2252

sk = sock->sk;

2255

sk_change_net(sk, net);

2253

sk_change_net(sk, net);

2256

2254

2257

rc = kernel_bind(sock, (struct sockaddr *) &vxlan_addr,

2255

rc = kernel_bind(sock, (struct sockaddr *) &vxlan_addr,

2258

sizeof(vxlan_addr));

2256

sizeof(vxlan_addr));

2259

if (rc < 0) {

2257

if (rc < 0) {

2260

pr_debug("bind for UDP socket %pI4:%u (%d)\n",

2258

pr_debug("bind for UDP socket %pI4:%u (%d)\n",

2261

&vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);

2259

&vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);

2262

sk_release_kernel(sk);

2260

sk_release_kernel(sk);

2263

return ERR_PTR(rc);

2261

return ERR_PTR(rc);

2264

}

2262

}

2265

2263

2266

/* Disable multicast loopback */

2264

/* Disable multicast loopback */

2267

inet_sk(sk)->mc_loop = 0;

2265

inet_sk(sk)->mc_loop = 0;

2268

return sock;

2266

return sock;

2269

}

2267

}

2270

2268

2271

/* Create new listen socket if needed */

2269

/* Create new listen socket if needed */

2272

static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,

2270

static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,

2273

vxlan_rcv_t *rcv, void *data, bool ipv6)

2271

vxlan_rcv_t *rcv, void *data, bool ipv6)

2274

{

2272

{

2275

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2273

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2276

struct vxlan_sock *vs;

2274

struct vxlan_sock *vs;

2277

struct socket *sock;

2275

struct socket *sock;

2278

struct sock *sk;

2276

struct sock *sk;

2279

unsigned int h;

2277

unsigned int h;

2280

2278

2281

vs = kmalloc(sizeof(*vs), GFP_KERNEL);

2279

vs = kmalloc(sizeof(*vs), GFP_KERNEL);

2282

if (!vs)

2280

if (!vs)

2283

return ERR_PTR(-ENOMEM);

2281

return ERR_PTR(-ENOMEM);

2284

2282

2285

for (h = 0; h < VNI_HASH_SIZE; ++h)

2283

for (h = 0; h < VNI_HASH_SIZE; ++h)

2286

INIT_HLIST_HEAD(&vs->vni_list[h]);

2284

INIT_HLIST_HEAD(&vs->vni_list[h]);

2287

2285

2288

INIT_WORK(&vs->del_work, vxlan_del_work);

2286

INIT_WORK(&vs->del_work, vxlan_del_work);

2289

2287

2290

if (ipv6)

2288

if (ipv6)

2291

sock = create_v6_sock(net, port);

2289

sock = create_v6_sock(net, port);

2292

else

2290

else

2293

sock = create_v4_sock(net, port);

2291

sock = create_v4_sock(net, port);

2294

if (IS_ERR(sock)) {

2292

if (IS_ERR(sock)) {

2295

kfree(vs);

2293

kfree(vs);

2296

return ERR_CAST(sock);

2294

return ERR_CAST(sock);

2297

}

2295

}

2298

2296

2299

vs->sock = sock;

2297

vs->sock = sock;

2300

sk = sock->sk;

2298

sk = sock->sk;

2301

atomic_set(&vs->refcnt, 1);

2299

atomic_set(&vs->refcnt, 1);

2302

vs->rcv = rcv;

2300

vs->rcv = rcv;

2303

vs->data = data;

2301

vs->data = data;

2304

rcu_assign_sk_user_data(vs->sock->sk, vs);

2302

rcu_assign_sk_user_data(vs->sock->sk, vs);

2305

2303

2306

spin_lock(&vn->sock_lock);

2304

spin_lock(&vn->sock_lock);

2307

hlist_add_head_rcu(&vs->hlist, vs_head(net, port));

2305

hlist_add_head_rcu(&vs->hlist, vs_head(net, port));

2308

vxlan_notify_add_rx_port(sk);

2306

vxlan_notify_add_rx_port(sk);

2309

spin_unlock(&vn->sock_lock);

2307

spin_unlock(&vn->sock_lock);

2310

2308

2311

/* Mark socket as an encapsulation socket. */

2309

/* Mark socket as an encapsulation socket. */

2312

udp_sk(sk)->encap_type = 1;

2310

udp_sk(sk)->encap_type = 1;

2313

udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;

2311

udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;

2314

#if IS_ENABLED(CONFIG_IPV6)

2312

#if IS_ENABLED(CONFIG_IPV6)

2315

if (ipv6)

2313

if (ipv6)

2316

ipv6_stub->udpv6_encap_enable();

2314

ipv6_stub->udpv6_encap_enable();

2317

else

2315

else

2318

#endif

2316

#endif

2319

udp_encap_enable();

2317

udp_encap_enable();

2320

2318

2321

return vs;

2319

return vs;

2322

}

2320

}

2323

2321

2324

struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,

2322

struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,

2325

vxlan_rcv_t *rcv, void *data,

2323

vxlan_rcv_t *rcv, void *data,

2326

bool no_share, bool ipv6)

2324

bool no_share, bool ipv6)

2327

{

2325

{

2328

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2326

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2329

struct vxlan_sock *vs;

2327

struct vxlan_sock *vs;

2330

2328

2331

vs = vxlan_socket_create(net, port, rcv, data, ipv6);

2329

vs = vxlan_socket_create(net, port, rcv, data, ipv6);

2332

if (!IS_ERR(vs))

2330

if (!IS_ERR(vs))

2333

return vs;

2331

return vs;

2334

2332

2335

if (no_share) /* Return error if sharing is not allowed. */

2333

if (no_share) /* Return error if sharing is not allowed. */

2336

return vs;

2334

return vs;

2337

2335

2338

spin_lock(&vn->sock_lock);

2336

spin_lock(&vn->sock_lock);

2339

vs = vxlan_find_sock(net, port);

2337

vs = vxlan_find_sock(net, port);

2340

if (vs) {

2338

if (vs) {

2341

if (vs->rcv == rcv)

2339

if (vs->rcv == rcv)

2342

atomic_inc(&vs->refcnt);

2340

atomic_inc(&vs->refcnt);

2343

else

2341

else

2344

vs = ERR_PTR(-EBUSY);

2342

vs = ERR_PTR(-EBUSY);

2345

}

2343

}

2346

spin_unlock(&vn->sock_lock);

2344

spin_unlock(&vn->sock_lock);

2347

2345

2348

if (!vs)

2346

if (!vs)

2349

vs = ERR_PTR(-EINVAL);

2347

vs = ERR_PTR(-EINVAL);

2350

2348

2351

return vs;

2349

return vs;

2352

}

2350

}

2353

EXPORT_SYMBOL_GPL(vxlan_sock_add);

2351

EXPORT_SYMBOL_GPL(vxlan_sock_add);

2354

2352

2355

/* Scheduled at device creation to bind to a socket */

2353

/* Scheduled at device creation to bind to a socket */

2356

static void vxlan_sock_work(struct work_struct *work)

2354

static void vxlan_sock_work(struct work_struct *work)

2357

{

2355

{

2358

struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, sock_work);

2356

struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, sock_work);

2359

struct net *net = dev_net(vxlan->dev);

2357

struct net *net = dev_net(vxlan->dev);

2360

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2358

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2361

__be16 port = vxlan->dst_port;

2359

__be16 port = vxlan->dst_port;

2362

struct vxlan_sock *nvs;

2360

struct vxlan_sock *nvs;

2363

2361

2364

nvs = vxlan_sock_add(net, port, vxlan_rcv, NULL, false, vxlan->flags & VXLAN_F_IPV6);

2362

nvs = vxlan_sock_add(net, port, vxlan_rcv, NULL, false, vxlan->flags & VXLAN_F_IPV6);

2365

spin_lock(&vn->sock_lock);

2363

spin_lock(&vn->sock_lock);

2366

if (!IS_ERR(nvs))

2364

if (!IS_ERR(nvs))

2367

vxlan_vs_add_dev(nvs, vxlan);

2365

vxlan_vs_add_dev(nvs, vxlan);

2368

spin_unlock(&vn->sock_lock);

2366

spin_unlock(&vn->sock_lock);

2369

2367

2370

dev_put(vxlan->dev);

2368

dev_put(vxlan->dev);

2371

}

2369

}

2372

2370

2373

static int vxlan_newlink(struct net *net, struct net_device *dev,

2371

static int vxlan_newlink(struct net *net, struct net_device *dev,

2374

struct nlattr *tb[], struct nlattr *data[])

2372

struct nlattr *tb[], struct nlattr *data[])

2375

{

2373

{

2376

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2374

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2377

struct vxlan_dev *vxlan = netdev_priv(dev);

2375

struct vxlan_dev *vxlan = netdev_priv(dev);

2378

struct vxlan_rdst *dst = &vxlan->default_dst;

2376

struct vxlan_rdst *dst = &vxlan->default_dst;

2379

__u32 vni;

2377

__u32 vni;

2380

int err;

2378

int err;

2381

bool use_ipv6 = false;

2379

bool use_ipv6 = false;

2382

2380

2383

if (!data[IFLA_VXLAN_ID])

2381

if (!data[IFLA_VXLAN_ID])

2384

return -EINVAL;

2382

return -EINVAL;

2385

2383

2386

vni = nla_get_u32(data[IFLA_VXLAN_ID]);

2384

vni = nla_get_u32(data[IFLA_VXLAN_ID]);

2387

dst->remote_vni = vni;

2385

dst->remote_vni = vni;

2388

2386

2389

if (data[IFLA_VXLAN_GROUP]) {

2387

if (data[IFLA_VXLAN_GROUP]) {

2390

dst->remote_ip.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_GROUP]);

2388

dst->remote_ip.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_GROUP]);

2391

dst->remote_ip.sa.sa_family = AF_INET;

2389

dst->remote_ip.sa.sa_family = AF_INET;

2392

} else if (data[IFLA_VXLAN_GROUP6]) {

2390

} else if (data[IFLA_VXLAN_GROUP6]) {

2393

if (!IS_ENABLED(CONFIG_IPV6))

2391

if (!IS_ENABLED(CONFIG_IPV6))

2394

return -EPFNOSUPPORT;

2392

return -EPFNOSUPPORT;

2395

2393

2396

nla_memcpy(&dst->remote_ip.sin6.sin6_addr, data[IFLA_VXLAN_GROUP6],

2394

nla_memcpy(&dst->remote_ip.sin6.sin6_addr, data[IFLA_VXLAN_GROUP6],

2397

sizeof(struct in6_addr));

2395

sizeof(struct in6_addr));

2398

dst->remote_ip.sa.sa_family = AF_INET6;

2396

dst->remote_ip.sa.sa_family = AF_INET6;

2399

use_ipv6 = true;

2397

use_ipv6 = true;

2400

}

2398

}

2401

2399

2402

if (data[IFLA_VXLAN_LOCAL]) {

2400

if (data[IFLA_VXLAN_LOCAL]) {

2403

vxlan->saddr.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_LOCAL]);

2401

vxlan->saddr.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_LOCAL]);

2404

vxlan->saddr.sa.sa_family = AF_INET;

2402

vxlan->saddr.sa.sa_family = AF_INET;

2405

} else if (data[IFLA_VXLAN_LOCAL6]) {

2403

} else if (data[IFLA_VXLAN_LOCAL6]) {

2406

if (!IS_ENABLED(CONFIG_IPV6))

2404

if (!IS_ENABLED(CONFIG_IPV6))

2407

return -EPFNOSUPPORT;

2405

return -EPFNOSUPPORT;

2408

2406

2409

/* TODO: respect scope id */

2407

/* TODO: respect scope id */

2410

nla_memcpy(&vxlan->saddr.sin6.sin6_addr, data[IFLA_VXLAN_LOCAL6],

2408

nla_memcpy(&vxlan->saddr.sin6.sin6_addr, data[IFLA_VXLAN_LOCAL6],

2411

sizeof(struct in6_addr));

2409

sizeof(struct in6_addr));

2412

vxlan->saddr.sa.sa_family = AF_INET6;

2410

vxlan->saddr.sa.sa_family = AF_INET6;

2413

use_ipv6 = true;

2411

use_ipv6 = true;

2414

}

2412

}

2415

2413

2416

if (data[IFLA_VXLAN_LINK] &&

2414

if (data[IFLA_VXLAN_LINK] &&

2417

(dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {

2415

(dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {

2418

struct net_device *lowerdev

2416

struct net_device *lowerdev

2419

= __dev_get_by_index(net, dst->remote_ifindex);

2417

= __dev_get_by_index(net, dst->remote_ifindex);

2420

2418

2421

if (!lowerdev) {

2419

if (!lowerdev) {

2422

pr_info("ifindex %d does not exist\n", dst->remote_ifindex);

2420

pr_info("ifindex %d does not exist\n", dst->remote_ifindex);

2423

return -ENODEV;

2421

return -ENODEV;

2424

}

2422

}

2425

2423

2426

#if IS_ENABLED(CONFIG_IPV6)

2424

#if IS_ENABLED(CONFIG_IPV6)

2427

if (use_ipv6) {

2425

if (use_ipv6) {

2428

struct inet6_dev *idev = __in6_dev_get(lowerdev);

2426

struct inet6_dev *idev = __in6_dev_get(lowerdev);

2429

if (idev && idev->cnf.disable_ipv6) {

2427

if (idev && idev->cnf.disable_ipv6) {

2430

pr_info("IPv6 is disabled via sysctl\n");

2428

pr_info("IPv6 is disabled via sysctl\n");

2431

return -EPERM;

2429

return -EPERM;

2432

}

2430

}

2433

vxlan->flags |= VXLAN_F_IPV6;

2431

vxlan->flags |= VXLAN_F_IPV6;

2434

}

2432

}

2435

#endif

2433

#endif

2436

2434

2437

if (!tb[IFLA_MTU])

2435

if (!tb[IFLA_MTU])

2438

dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);

2436

dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);

2439

2437

2440

/* update header length based on lower device */

2438

/* update header length based on lower device */

2441

dev->hard_header_len = lowerdev->hard_header_len +

2439

dev->hard_header_len = lowerdev->hard_header_len +

2442

(use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);

2440

(use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);

2443

}

2441

}

2444

2442

2445

if (data[IFLA_VXLAN_TOS])

2443

if (data[IFLA_VXLAN_TOS])

2446

vxlan->tos = nla_get_u8(data[IFLA_VXLAN_TOS]);

2444

vxlan->tos = nla_get_u8(data[IFLA_VXLAN_TOS]);

2447

2445

2448

if (data[IFLA_VXLAN_TTL])

2446

if (data[IFLA_VXLAN_TTL])

2449

vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);

2447

vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);

2450

2448

2451

if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))

2449

if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))

2452

vxlan->flags |= VXLAN_F_LEARN;

2450

vxlan->flags |= VXLAN_F_LEARN;

2453

2451

2454

if (data[IFLA_VXLAN_AGEING])

2452

if (data[IFLA_VXLAN_AGEING])

2455

vxlan->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);

2453

vxlan->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);

2456

else

2454

else

2457

vxlan->age_interval = FDB_AGE_DEFAULT;

2455

vxlan->age_interval = FDB_AGE_DEFAULT;

2458

2456

2459

if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))

2457

if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))

2460

vxlan->flags |= VXLAN_F_PROXY;

2458

vxlan->flags |= VXLAN_F_PROXY;

2461

2459

2462

if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))

2460

if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))

2463

vxlan->flags |= VXLAN_F_RSC;

2461

vxlan->flags |= VXLAN_F_RSC;

2464

2462

2465

if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))

2463

if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))

2466

vxlan->flags |= VXLAN_F_L2MISS;

2464

vxlan->flags |= VXLAN_F_L2MISS;

2467

2465

2468

if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))

2466

if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))

2469

vxlan->flags |= VXLAN_F_L3MISS;

2467

vxlan->flags |= VXLAN_F_L3MISS;

2470

2468

2471

if (data[IFLA_VXLAN_LIMIT])

2469

if (data[IFLA_VXLAN_LIMIT])

2472

vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);

2470

vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);

2473

2471

2474

if (data[IFLA_VXLAN_PORT_RANGE]) {

2472

if (data[IFLA_VXLAN_PORT_RANGE]) {

2475

const struct ifla_vxlan_port_range *p

2473

const struct ifla_vxlan_port_range *p

2476

= nla_data(data[IFLA_VXLAN_PORT_RANGE]);

2474

= nla_data(data[IFLA_VXLAN_PORT_RANGE]);

2477

vxlan->port_min = ntohs(p->low);

2475

vxlan->port_min = ntohs(p->low);

2478

vxlan->port_max = ntohs(p->high);

2476

vxlan->port_max = ntohs(p->high);

2479

}

2477

}

2480

2478

2481

if (data[IFLA_VXLAN_PORT])

2479

if (data[IFLA_VXLAN_PORT])

2482

vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);

2480

vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);

2483

2481

2484

if (vxlan_find_vni(net, vni, vxlan->dst_port)) {

2482

if (vxlan_find_vni(net, vni, vxlan->dst_port)) {

2485

pr_info("duplicate VNI %u\n", vni);

2483

pr_info("duplicate VNI %u\n", vni);

2486

return -EEXIST;

2484

return -EEXIST;

2487

}

2485

}

2488

2486

2489

SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);

2487

SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);

2490

2488

2491

/* create an fdb entry for a valid default destination */

2489

/* create an fdb entry for a valid default destination */

2492

if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {

2490

if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {

2493

err = vxlan_fdb_create(vxlan, all_zeros_mac,

2491

err = vxlan_fdb_create(vxlan, all_zeros_mac,

2494

&vxlan->default_dst.remote_ip,

2492

&vxlan->default_dst.remote_ip,

2495

NUD_REACHABLE|NUD_PERMANENT,

2493

NUD_REACHABLE|NUD_PERMANENT,

2496

NLM_F_EXCL|NLM_F_CREATE,

2494

NLM_F_EXCL|NLM_F_CREATE,

2497

vxlan->dst_port,

2495

vxlan->dst_port,

2498

vxlan->default_dst.remote_vni,

2496

vxlan->default_dst.remote_vni,

2499

vxlan->default_dst.remote_ifindex,

2497

vxlan->default_dst.remote_ifindex,

2500

NTF_SELF);

2498

NTF_SELF);

2501

if (err)

2499

if (err)

2502

return err;

2500

return err;

2503

}

2501

}

2504

2502

2505

err = register_netdevice(dev);

2503

err = register_netdevice(dev);

2506

if (err) {

2504

if (err) {

2507

vxlan_fdb_delete_default(vxlan);

2505

vxlan_fdb_delete_default(vxlan);

2508

return err;

2506

return err;

2509

}

2507

}

2510

2508

2511

list_add(&vxlan->next, &vn->vxlan_list);

2509

list_add(&vxlan->next, &vn->vxlan_list);

2512

2510

2513

return 0;

2511

return 0;

2514

}

2512

}

2515

2513

2516

static void vxlan_dellink(struct net_device *dev, struct list_head *head)

2514

static void vxlan_dellink(struct net_device *dev, struct list_head *head)

2517

{

2515

{

2518

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

2516

struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);

2519

struct vxlan_dev *vxlan = netdev_priv(dev);

2517

struct vxlan_dev *vxlan = netdev_priv(dev);

2520

2518

2521

spin_lock(&vn->sock_lock);

2519

spin_lock(&vn->sock_lock);

2522

if (!hlist_unhashed(&vxlan->hlist))

2520

if (!hlist_unhashed(&vxlan->hlist))

2523

hlist_del_rcu(&vxlan->hlist);

2521

hlist_del_rcu(&vxlan->hlist);

2524

spin_unlock(&vn->sock_lock);

2522

spin_unlock(&vn->sock_lock);

2525

2523

2526

list_del(&vxlan->next);

2524

list_del(&vxlan->next);

2527

unregister_netdevice_queue(dev, head);

2525

unregister_netdevice_queue(dev, head);

2528

}

2526

}

2529

2527

2530

static size_t vxlan_get_size(const struct net_device *dev)

2528

static size_t vxlan_get_size(const struct net_device *dev)

2531

{

2529

{

2532

2530

2533

return nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_ID */

2531

return nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_ID */

2534

nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */

2532

nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */

2535

nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LINK */

2533

nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LINK */

2536

nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */

2534

nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */

2537

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TTL */

2535

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TTL */

2538

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TOS */

2536

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_TOS */

2539

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_LEARNING */

2537

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_LEARNING */

2540

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_PROXY */

2538

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_PROXY */

2541

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_RSC */

2539

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_RSC */

2542

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_L2MISS */

2540

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_L2MISS */

2543

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_L3MISS */

2541

nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_L3MISS */

2544

nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_AGEING */

2542

nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_AGEING */

2545

nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LIMIT */

2543

nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LIMIT */

2546

nla_total_size(sizeof(struct ifla_vxlan_port_range)) +

2544

nla_total_size(sizeof(struct ifla_vxlan_port_range)) +

2547

nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */

2545

nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */

2548

0;

2546

0;

2549

}

2547

}

2550

2548

2551

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)

2549

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)

2552

{

2550

{

2553

const struct vxlan_dev *vxlan = netdev_priv(dev);

2551

const struct vxlan_dev *vxlan = netdev_priv(dev);

2554

const struct vxlan_rdst *dst = &vxlan->default_dst;

2552

const struct vxlan_rdst *dst = &vxlan->default_dst;

2555

struct ifla_vxlan_port_range ports = {

2553

struct ifla_vxlan_port_range ports = {

2556

.low = htons(vxlan->port_min),

2554

.low = htons(vxlan->port_min),

2557

.high = htons(vxlan->port_max),

2555

.high = htons(vxlan->port_max),

2558

};

2556

};

2559

2557

2560

if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))

2558

if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))

2561

goto nla_put_failure;

2559

goto nla_put_failure;

2562

2560

2563

if (!vxlan_addr_any(&dst->remote_ip)) {

2561

if (!vxlan_addr_any(&dst->remote_ip)) {

2564

if (dst->remote_ip.sa.sa_family == AF_INET) {

2562

if (dst->remote_ip.sa.sa_family == AF_INET) {

2565

if (nla_put_be32(skb, IFLA_VXLAN_GROUP,

2563

if (nla_put_be32(skb, IFLA_VXLAN_GROUP,

2566

dst->remote_ip.sin.sin_addr.s_addr))

2564

dst->remote_ip.sin.sin_addr.s_addr))

2567

goto nla_put_failure;

2565

goto nla_put_failure;

2568

#if IS_ENABLED(CONFIG_IPV6)

2566

#if IS_ENABLED(CONFIG_IPV6)

2569

} else {

2567

} else {

2570

if (nla_put(skb, IFLA_VXLAN_GROUP6, sizeof(struct in6_addr),

2568

if (nla_put(skb, IFLA_VXLAN_GROUP6, sizeof(struct in6_addr),

2571

&dst->remote_ip.sin6.sin6_addr))

2569

&dst->remote_ip.sin6.sin6_addr))

2572

goto nla_put_failure;

2570

goto nla_put_failure;

2573

#endif

2571

#endif

2574

}

2572

}

2575

}

2573

}

2576

2574

2577

if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))

2575

if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))

2578

goto nla_put_failure;

2576

goto nla_put_failure;

2579

2577

2580

if (!vxlan_addr_any(&vxlan->saddr)) {

2578

if (!vxlan_addr_any(&vxlan->saddr)) {

2581

if (vxlan->saddr.sa.sa_family == AF_INET) {

2579

if (vxlan->saddr.sa.sa_family == AF_INET) {

2582

if (nla_put_be32(skb, IFLA_VXLAN_LOCAL,

2580

if (nla_put_be32(skb, IFLA_VXLAN_LOCAL,

2583

vxlan->saddr.sin.sin_addr.s_addr))

2581

vxlan->saddr.sin.sin_addr.s_addr))

2584

goto nla_put_failure;

2582

goto nla_put_failure;

2585

#if IS_ENABLED(CONFIG_IPV6)

2583

#if IS_ENABLED(CONFIG_IPV6)

2586

} else {

2584

} else {

2587

if (nla_put(skb, IFLA_VXLAN_LOCAL6, sizeof(struct in6_addr),

2585

if (nla_put(skb, IFLA_VXLAN_LOCAL6, sizeof(struct in6_addr),

2588

&vxlan->saddr.sin6.sin6_addr))

2586

&vxlan->saddr.sin6.sin6_addr))

2589

goto nla_put_failure;

2587

goto nla_put_failure;

2590

#endif

2588

#endif

2591

}

2589

}

2592

}

2590

}

2593

2591

2594

if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->ttl) ||

2592

if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->ttl) ||

2595

nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->tos) ||

2593

nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->tos) ||

2596

nla_put_u8(skb, IFLA_VXLAN_LEARNING,

2594

nla_put_u8(skb, IFLA_VXLAN_LEARNING,

2597

!!(vxlan->flags & VXLAN_F_LEARN)) ||

2595

!!(vxlan->flags & VXLAN_F_LEARN)) ||

2598

nla_put_u8(skb, IFLA_VXLAN_PROXY,

2596

nla_put_u8(skb, IFLA_VXLAN_PROXY,

2599

!!(vxlan->flags & VXLAN_F_PROXY)) ||

2597

!!(vxlan->flags & VXLAN_F_PROXY)) ||

2600

nla_put_u8(skb, IFLA_VXLAN_RSC, !!(vxlan->flags & VXLAN_F_RSC)) ||

2598

nla_put_u8(skb, IFLA_VXLAN_RSC, !!(vxlan->flags & VXLAN_F_RSC)) ||

2601

nla_put_u8(skb, IFLA_VXLAN_L2MISS,

2599

nla_put_u8(skb, IFLA_VXLAN_L2MISS,

2602

!!(vxlan->flags & VXLAN_F_L2MISS)) ||

2600

!!(vxlan->flags & VXLAN_F_L2MISS)) ||

2603

nla_put_u8(skb, IFLA_VXLAN_L3MISS,

2601

nla_put_u8(skb, IFLA_VXLAN_L3MISS,

2604

!!(vxlan->flags & VXLAN_F_L3MISS)) ||

2602

!!(vxlan->flags & VXLAN_F_L3MISS)) ||

2605

nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||

2603

nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||

2606

nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||

2604

nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||

2607

nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))

2605

nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))

2608

goto nla_put_failure;

2606

goto nla_put_failure;

2609

2607

2610

if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))

2608

if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))

2611

goto nla_put_failure;

2609

goto nla_put_failure;

2612

2610

2613

return 0;

2611

return 0;

2614

2612

2615

nla_put_failure:

2613

nla_put_failure:

2616

return -EMSGSIZE;

2614

return -EMSGSIZE;

2617

}

2615

}

2618

2616

2619

static struct rtnl_link_ops vxlan_link_ops __read_mostly = {

2617

static struct rtnl_link_ops vxlan_link_ops __read_mostly = {

2620

.kind = "vxlan",

2618

.kind = "vxlan",

2621

.maxtype = IFLA_VXLAN_MAX,

2619

.maxtype = IFLA_VXLAN_MAX,

2622

.policy = vxlan_policy,

2620

.policy = vxlan_policy,

2623

.priv_size = sizeof(struct vxlan_dev),

2621

.priv_size = sizeof(struct vxlan_dev),

2624

.setup = vxlan_setup,

2622

.setup = vxlan_setup,

2625

.validate = vxlan_validate,

2623

.validate = vxlan_validate,

2626

.newlink = vxlan_newlink,

2624

.newlink = vxlan_newlink,

2627

.dellink = vxlan_dellink,

2625

.dellink = vxlan_dellink,

2628

.get_size = vxlan_get_size,

2626

.get_size = vxlan_get_size,

2629

.fill_info = vxlan_fill_info,

2627

.fill_info = vxlan_fill_info,

2630

};

2628

};

2631

2629

2632

static __net_init int vxlan_init_net(struct net *net)

2630

static __net_init int vxlan_init_net(struct net *net)

2633

{

2631

{

2634

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2632

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2635

unsigned int h;

2633

unsigned int h;

2636

2634

2637

INIT_LIST_HEAD(&vn->vxlan_list);

2635

INIT_LIST_HEAD(&vn->vxlan_list);

2638

spin_lock_init(&vn->sock_lock);

2636

spin_lock_init(&vn->sock_lock);

2639

2637

2640

for (h = 0; h < PORT_HASH_SIZE; ++h)

2638

for (h = 0; h < PORT_HASH_SIZE; ++h)

2641

INIT_HLIST_HEAD(&vn->sock_list[h]);

2639

INIT_HLIST_HEAD(&vn->sock_list[h]);

2642

2640

2643

return 0;

2641

return 0;

2644

}

2642

}

2645

2643

2646

static __net_exit void vxlan_exit_net(struct net *net)

2644

static __net_exit void vxlan_exit_net(struct net *net)

2647

{

2645

{

2648

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2646

struct vxlan_net *vn = net_generic(net, vxlan_net_id);

2649

struct vxlan_dev *vxlan;

2647

struct vxlan_dev *vxlan;

2650

LIST_HEAD(list);

2648

LIST_HEAD(list);

2651

2649

2652

rtnl_lock();

2650

rtnl_lock();

2653

list_for_each_entry(vxlan, &vn->vxlan_list, next)

2651

list_for_each_entry(vxlan, &vn->vxlan_list, next)

2654

unregister_netdevice_queue(vxlan->dev, &list);

2652

unregister_netdevice_queue(vxlan->dev, &list);

2655

unregister_netdevice_many(&list);

2653

unregister_netdevice_many(&list);

2656

rtnl_unlock();

2654

rtnl_unlock();

2657

}

2655

}

2658

2656

2659

static struct pernet_operations vxlan_net_ops = {

2657

static struct pernet_operations vxlan_net_ops = {

2660

.init = vxlan_init_net,

2658

.init = vxlan_init_net,

2661

.exit = vxlan_exit_net,

2659

.exit = vxlan_exit_net,

2662

.id = &vxlan_net_id,

2660

.id = &vxlan_net_id,

2663

.size = sizeof(struct vxlan_net),

2661

.size = sizeof(struct vxlan_net),

2664

};

2662

};

2665

2663

2666

static int __init vxlan_init_module(void)

2664

static int __init vxlan_init_module(void)

2667

{

2665

{

2668

int rc;

2666

int rc;

2669

2667

2670

vxlan_wq = alloc_workqueue("vxlan", 0, 0);

2668

vxlan_wq = alloc_workqueue("vxlan", 0, 0);

2671

if (!vxlan_wq)

2669

if (!vxlan_wq)

2672

return -ENOMEM;

2670

return -ENOMEM;

2673

2671

2674

get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));

2672

get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));

2675

2673

2676

rc = register_pernet_device(&vxlan_net_ops);

2674

rc = register_pernet_device(&vxlan_net_ops);

2677

if (rc)

2675

if (rc)

2678

goto out1;

2676

goto out1;

2679

2677

2680

rc = rtnl_link_register(&vxlan_link_ops);

2678

rc = rtnl_link_register(&vxlan_link_ops);

2681

if (rc)

2679

if (rc)

2682

goto out2;

2680

goto out2;

2683

2681

2684

return 0;

2682

return 0;

2685

2683

2686

out2:

2684

out2:

2687

unregister_pernet_device(&vxlan_net_ops);

2685

unregister_pernet_device(&vxlan_net_ops);

2688

out1:

2686

out1:

2689

destroy_workqueue(vxlan_wq);

2687

destroy_workqueue(vxlan_wq);

2690

return rc;

2688

return rc;

2691

}

2689

}

2692

late_initcall(vxlan_init_module);

2690

late_initcall(vxlan_init_module);

2693

2691

2694

static void __exit vxlan_cleanup_module(void)

2692

static void __exit vxlan_cleanup_module(void)

2695

{

2693

{

2696

rtnl_link_unregister(&vxlan_link_ops);

2694

rtnl_link_unregister(&vxlan_link_ops);

2697

destroy_workqueue(vxlan_wq);

2695

destroy_workqueue(vxlan_wq);

2698

unregister_pernet_device(&vxlan_net_ops);

2696

unregister_pernet_device(&vxlan_net_ops);

2699

rcu_barrier();

2697

rcu_barrier();

2700

}

2698

}

2701

module_exit(vxlan_cleanup_module);

2699

module_exit(vxlan_cleanup_module);

2702

2700

2703

MODULE_LICENSE("GPL");

2701

MODULE_LICENSE("GPL");

2704

MODULE_VERSION(VXLAN_VERSION);

2702

MODULE_VERSION(VXLAN_VERSION);

2705

MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");

2703

MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");

2706

MODULE_ALIAS_RTNL_LINK("vxlan");

2704

MODULE_ALIAS_RTNL_LINK("vxlan");

2707

2705

GITLAB

vxlan: remove vxlan_group_used in vxlan_open

 /*
  * VXLAN: Virtual eXtensible Local Area Network
  *
  * Copyright (c) 2012-2013 Vyatta Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/rculist.h>
 #include <linux/netdevice.h>
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <linux/udp.h>
 #include <linux/igmp.h>
 #include <linux/etherdevice.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/hash.h>
 #include <linux/ethtool.h>
 #include <net/arp.h>
 #include <net/ndisc.h>
 #include <net/ip.h>
 #include <net/ip_tunnels.h>
 #include <net/icmp.h>
 #include <net/udp.h>
 #include <net/rtnetlink.h>
 #include <net/route.h>
 #include <net/dsfield.h>
 #include <net/inet_ecn.h>
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
 #include <net/vxlan.h>
 #if IS_ENABLED(CONFIG_IPV6)
 #include <net/ipv6.h>
 #include <net/addrconf.h>
 #include <net/ip6_tunnel.h>
 #include <net/ip6_checksum.h>
 #endif
 #define VXLAN_VERSION	"0.1"
 #define PORT_HASH_BITS	8
 #define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
 #define VNI_HASH_BITS	10
 #define VNI_HASH_SIZE	(1<<VNI_HASH_BITS)
 #define FDB_HASH_BITS	8
 #define FDB_HASH_SIZE	(1<<FDB_HASH_BITS)
 #define FDB_AGE_DEFAULT 300 /* 5 min */
 #define FDB_AGE_INTERVAL (10 * HZ)	/* rescan interval */
 #define VXLAN_N_VID	(1u << 24)
 #define VXLAN_VID_MASK	(VXLAN_N_VID - 1)
 #define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))
 #define VXLAN_FLAGS 0x08000000	/* struct vxlanhdr.vx_flags required value. */
 /* VXLAN protocol header */
 struct vxlanhdr {
 	__be32 vx_flags;
 	__be32 vx_vni;
 };
 /* UDP port for VXLAN traffic.
  * The IANA assigned port is 4789, but the Linux default is 8472
  * for compatibility with early adopters.
  */
 static unsigned short vxlan_port __read_mostly = 8472;
 module_param_named(udp_port, vxlan_port, ushort, 0444);
 MODULE_PARM_DESC(udp_port, "Destination UDP port");
 static bool log_ecn_error = true;
 module_param(log_ecn_error, bool, 0644);
 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 static int vxlan_net_id;
 static const u8 all_zeros_mac[ETH_ALEN];
 /* per-network namespace private data for this module */
 struct vxlan_net {
 	struct list_head  vxlan_list;
 	struct hlist_head sock_list[PORT_HASH_SIZE];
 	spinlock_t	  sock_lock;
 };
 union vxlan_addr {
 	struct sockaddr_in sin;
 	struct sockaddr_in6 sin6;
 	struct sockaddr sa;
 };
 struct vxlan_rdst {
 	union vxlan_addr	 remote_ip;
 	__be16			 remote_port;
 	u32			 remote_vni;
 	u32			 remote_ifindex;
 	struct list_head	 list;
 	struct rcu_head		 rcu;
 };
 /* Forwarding table entry */
 struct vxlan_fdb {
 	struct hlist_node hlist;	/* linked list of entries */
 	struct rcu_head	  rcu;
 	unsigned long	  updated;	/* jiffies */
 	unsigned long	  used;
 	struct list_head  remotes;
 	u16		  state;	/* see ndm_state */
 	u8		  flags;	/* see ndm_flags */
 	u8		  eth_addr[ETH_ALEN];
 };
 /* Pseudo network device */
 struct vxlan_dev {
 	struct hlist_node hlist;	/* vni hash table */
 	struct list_head  next;		/* vxlan's per namespace list */
 	struct vxlan_sock *vn_sock;	/* listening socket */
 	struct net_device *dev;
 	struct vxlan_rdst default_dst;	/* default destination */
 	union vxlan_addr  saddr;	/* source address */
 	__be16		  dst_port;
 	__u16		  port_min;	/* source port range */
 	__u16		  port_max;
 	__u8		  tos;		/* TOS override */
 	__u8		  ttl;
 	u32		  flags;	/* VXLAN_F_* below */
 	struct work_struct sock_work;
 	struct work_struct igmp_join;
 	struct work_struct igmp_leave;
 	unsigned long	  age_interval;
 	struct timer_list age_timer;
 	spinlock_t	  hash_lock;
 	unsigned int	  addrcnt;
 	unsigned int	  addrmax;
 	struct hlist_head fdb_head[FDB_HASH_SIZE];
 };
 #define VXLAN_F_LEARN	0x01
 #define VXLAN_F_PROXY	0x02
 #define VXLAN_F_RSC	0x04
 #define VXLAN_F_L2MISS	0x08
 #define VXLAN_F_L3MISS	0x10
 #define VXLAN_F_IPV6	0x20 /* internal flag */
 /* salt for hash table */
 static u32 vxlan_salt __read_mostly;
 static struct workqueue_struct *vxlan_wq;
 static void vxlan_sock_work(struct work_struct *work);
 #if IS_ENABLED(CONFIG_IPV6)
 static inline
 bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
 {
        if (a->sa.sa_family != b->sa.sa_family)
                return false;
        if (a->sa.sa_family == AF_INET6)
                return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);
        else
                return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
 }
 static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
 {
        if (ipa->sa.sa_family == AF_INET6)
                return ipv6_addr_any(&ipa->sin6.sin6_addr);
        else
                return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
 }
 static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
 {
        if (ipa->sa.sa_family == AF_INET6)
                return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);
        else
                return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
 }
 static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
 {
        if (nla_len(nla) >= sizeof(struct in6_addr)) {
                nla_memcpy(&ip->sin6.sin6_addr, nla, sizeof(struct in6_addr));
                ip->sa.sa_family = AF_INET6;
                return 0;
        } else if (nla_len(nla) >= sizeof(__be32)) {
                ip->sin.sin_addr.s_addr = nla_get_be32(nla);
                ip->sa.sa_family = AF_INET;
                return 0;
        } else {
                return -EAFNOSUPPORT;
        }
 }
 static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
                              const union vxlan_addr *ip)
 {
        if (ip->sa.sa_family == AF_INET6)
                return nla_put(skb, attr, sizeof(struct in6_addr), &ip->sin6.sin6_addr);
        else
                return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);
 }
 #else /* !CONFIG_IPV6 */
 static inline
 bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
 {
        return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
 }
 static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
 {
        return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
 }
 static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
 {
        return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
 }
 static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
 {
        if (nla_len(nla) >= sizeof(struct in6_addr)) {
                return -EAFNOSUPPORT;
        } else if (nla_len(nla) >= sizeof(__be32)) {
                ip->sin.sin_addr.s_addr = nla_get_be32(nla);
                ip->sa.sa_family = AF_INET;
                return 0;
        } else {
                return -EAFNOSUPPORT;
        }
 }
 static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
                              const union vxlan_addr *ip)
 {
        return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);
 }
 #endif
 /* Virtual Network hash table head */
 static inline struct hlist_head *vni_head(struct vxlan_sock *vs, u32 id)
 {
 	return &vs->vni_list[hash_32(id, VNI_HASH_BITS)];
 }
 /* Socket hash table head */
 static inline struct hlist_head *vs_head(struct net *net, __be16 port)
 {
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
 }
 /* First remote destination for a forwarding entry.
  * Guaranteed to be non-NULL because remotes are never deleted.
  */
 static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
 {
 	return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);
 }
 static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)
 {
 	return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);
 }
 /* Find VXLAN socket based on network namespace and UDP port */
 static struct vxlan_sock *vxlan_find_sock(struct net *net, __be16 port)
 {
 	struct vxlan_sock *vs;
 	hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
 		if (inet_sk(vs->sock->sk)->inet_sport == port)
 			return vs;
 	}
 	return NULL;
 }
 static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, u32 id)
 {
 	struct vxlan_dev *vxlan;
 	hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {
 		if (vxlan->default_dst.remote_vni == id)
 			return vxlan;
 	}
 	return NULL;
 }
 /* Look up VNI in a per net namespace table */
 static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)
 {
 	struct vxlan_sock *vs;
 	vs = vxlan_find_sock(net, port);
 	if (!vs)
 		return NULL;
 	return vxlan_vs_find_vni(vs, id);
 }
 /* Fill in neighbour message in skbuff. */
 static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
 			  const struct vxlan_fdb *fdb,
 			  u32 portid, u32 seq, int type, unsigned int flags,
 			  const struct vxlan_rdst *rdst)
 {
 	unsigned long now = jiffies;
 	struct nda_cacheinfo ci;
 	struct nlmsghdr *nlh;
 	struct ndmsg *ndm;
 	bool send_ip, send_eth;
 	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
 	if (nlh == NULL)
 		return -EMSGSIZE;
 	ndm = nlmsg_data(nlh);
 	memset(ndm, 0, sizeof(*ndm));
 	send_eth = send_ip = true;
 	if (type == RTM_GETNEIGH) {
 		ndm->ndm_family	= AF_INET;
 		send_ip = !vxlan_addr_any(&rdst->remote_ip);
 		send_eth = !is_zero_ether_addr(fdb->eth_addr);
 	} else
 		ndm->ndm_family	= AF_BRIDGE;
 	ndm->ndm_state = fdb->state;
 	ndm->ndm_ifindex = vxlan->dev->ifindex;
 	ndm->ndm_flags = fdb->flags;
 	ndm->ndm_type = NDA_DST;
 	if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
 		goto nla_put_failure;
 	if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
 		goto nla_put_failure;
 	if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&
 	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
 		goto nla_put_failure;
 	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
 	    nla_put_u32(skb, NDA_VNI, rdst->remote_vni))
 		goto nla_put_failure;
 	if (rdst->remote_ifindex &&
 	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
 		goto nla_put_failure;
 	ci.ndm_used	 = jiffies_to_clock_t(now - fdb->used);
 	ci.ndm_confirmed = 0;
 	ci.ndm_updated	 = jiffies_to_clock_t(now - fdb->updated);
 	ci.ndm_refcnt	 = 0;
 	if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
 		goto nla_put_failure;
 	return nlmsg_end(skb, nlh);
 nla_put_failure:
 	nlmsg_cancel(skb, nlh);
 	return -EMSGSIZE;
 }
 static inline size_t vxlan_nlmsg_size(void)
 {
 	return NLMSG_ALIGN(sizeof(struct ndmsg))
 		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */
 		+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
 		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
 		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
 		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
 		+ nla_total_size(sizeof(struct nda_cacheinfo));
 }
 static void vxlan_fdb_notify(struct vxlan_dev *vxlan,
 			     struct vxlan_fdb *fdb, int type)
 {
 	struct net *net = dev_net(vxlan->dev);
 	struct sk_buff *skb;
 	int err = -ENOBUFS;
 	skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);
 	if (skb == NULL)
 		goto errout;
 	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0,
 			     first_remote_rtnl(fdb));
 	if (err < 0) {
 		/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
 		WARN_ON(err == -EMSGSIZE);
 		kfree_skb(skb);
 		goto errout;
 	}
 	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
 	return;
 errout:
 	if (err < 0)
 		rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
 }
 static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_fdb f = {
 		.state = NUD_STALE,
 	};
 	struct vxlan_rdst remote = {
 		.remote_ip = *ipa, /* goes to NDA_DST */
 		.remote_vni = VXLAN_N_VID,
 	};
 	INIT_LIST_HEAD(&f.remotes);
 	list_add_rcu(&remote.list, &f.remotes);
 	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
 }
 static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
 {
 	struct vxlan_fdb f = {
 		.state = NUD_STALE,
 	};
 	INIT_LIST_HEAD(&f.remotes);
 	memcpy(f.eth_addr, eth_addr, ETH_ALEN);
 	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
 }
 /* Hash Ethernet address */
 static u32 eth_hash(const unsigned char *addr)
 {
 	u64 value = get_unaligned((u64 *)addr);
 	/* only want 6 bytes */
 #ifdef __BIG_ENDIAN
 	value >>= 16;
 #else
 	value <<= 16;
 #endif
 	return hash_64(value, FDB_HASH_BITS);
 }
 /* Hash chain to use given mac address */
 static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,
 						const u8 *mac)
 {
 	return &vxlan->fdb_head[eth_hash(mac)];
 }
 /* Look up Ethernet address in forwarding table */
 static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
 					const u8 *mac)
 {
 	struct hlist_head *head = vxlan_fdb_head(vxlan, mac);
 	struct vxlan_fdb *f;
 	hlist_for_each_entry_rcu(f, head, hlist) {
 		if (ether_addr_equal(mac, f->eth_addr))
 			return f;
 	}
 	return NULL;
 }
 static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,
 					const u8 *mac)
 {
 	struct vxlan_fdb *f;
 	f = __vxlan_find_mac(vxlan, mac);
 	if (f)
 		f->used = jiffies;
 	return f;
 }
 /* caller should hold vxlan->hash_lock */
 static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
 					      union vxlan_addr *ip, __be16 port,
 					      __u32 vni, __u32 ifindex)
 {
 	struct vxlan_rdst *rd;
 	list_for_each_entry(rd, &f->remotes, list) {
 		if (vxlan_addr_equal(&rd->remote_ip, ip) &&
 		    rd->remote_port == port &&
 		    rd->remote_vni == vni &&
 		    rd->remote_ifindex == ifindex)
 			return rd;
 	}
 	return NULL;
 }
 /* Replace destination of unicast mac */
 static int vxlan_fdb_replace(struct vxlan_fdb *f,
 			     union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)
 {
 	struct vxlan_rdst *rd;
 	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
 	if (rd)
 		return 0;
 	rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);
 	if (!rd)
 		return 0;
 	rd->remote_ip = *ip;
 	rd->remote_port = port;
 	rd->remote_vni = vni;
 	rd->remote_ifindex = ifindex;
 	return 1;
 }
 /* Add/update destinations for multicast */
 static int vxlan_fdb_append(struct vxlan_fdb *f,
 			    union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)
 {
 	struct vxlan_rdst *rd;
 	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
 	if (rd)
 		return 0;
 	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
 	if (rd == NULL)
 		return -ENOBUFS;
 	rd->remote_ip = *ip;
 	rd->remote_port = port;
 	rd->remote_vni = vni;
 	rd->remote_ifindex = ifindex;
 	list_add_tail_rcu(&rd->list, &f->remotes);
 	return 1;
 }
 /* Notify netdevs that UDP port started listening */
 static void vxlan_notify_add_rx_port(struct sock *sk)
 {
 	struct net_device *dev;
 	struct net *net = sock_net(sk);
 	sa_family_t sa_family = sk->sk_family;
 	__be16 port = inet_sk(sk)->inet_sport;
 	rcu_read_lock();
 	for_each_netdev_rcu(net, dev) {
 		if (dev->netdev_ops->ndo_add_vxlan_port)
 			dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
 							    port);
 	}
 	rcu_read_unlock();
 }
 /* Notify netdevs that UDP port is no more listening */
 static void vxlan_notify_del_rx_port(struct sock *sk)
 {
 	struct net_device *dev;
 	struct net *net = sock_net(sk);
 	sa_family_t sa_family = sk->sk_family;
 	__be16 port = inet_sk(sk)->inet_sport;
 	rcu_read_lock();
 	for_each_netdev_rcu(net, dev) {
 		if (dev->netdev_ops->ndo_del_vxlan_port)
 			dev->netdev_ops->ndo_del_vxlan_port(dev, sa_family,
 							    port);
 	}
 	rcu_read_unlock();
 }
 /* Add new entry to forwarding table -- assumes lock held */
 static int vxlan_fdb_create(struct vxlan_dev *vxlan,
 			    const u8 *mac, union vxlan_addr *ip,
 			    __u16 state, __u16 flags,
 			    __be16 port, __u32 vni, __u32 ifindex,
 			    __u8 ndm_flags)
 {
 	struct vxlan_fdb *f;
 	int notify = 0;
 	f = __vxlan_find_mac(vxlan, mac);
 	if (f) {
 		if (flags & NLM_F_EXCL) {
 			netdev_dbg(vxlan->dev,
 				   "lost race to create %pM\n", mac);
 			return -EEXIST;
 		}
 		if (f->state != state) {
 			f->state = state;
 			f->updated = jiffies;
 			notify = 1;
 		}
 		if (f->flags != ndm_flags) {
 			f->flags = ndm_flags;
 			f->updated = jiffies;
 			notify = 1;
 		}
 		if ((flags & NLM_F_REPLACE)) {
 			/* Only change unicasts */
 			if (!(is_multicast_ether_addr(f->eth_addr) ||
 			     is_zero_ether_addr(f->eth_addr))) {
 				int rc = vxlan_fdb_replace(f, ip, port, vni,
 							   ifindex);
 				if (rc < 0)
 					return rc;
 				notify |= rc;
 			} else
 				return -EOPNOTSUPP;
 		}
 		if ((flags & NLM_F_APPEND) &&
 		    (is_multicast_ether_addr(f->eth_addr) ||
 		     is_zero_ether_addr(f->eth_addr))) {
 			int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);
 			if (rc < 0)
 				return rc;
 			notify |= rc;
 		}
 	} else {
 		if (!(flags & NLM_F_CREATE))
 			return -ENOENT;
 		if (vxlan->addrmax && vxlan->addrcnt >= vxlan->addrmax)
 			return -ENOSPC;
 		/* Disallow replace to add a multicast entry */
 		if ((flags & NLM_F_REPLACE) &&
 		    (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))
 			return -EOPNOTSUPP;
 		netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
 		f = kmalloc(sizeof(*f), GFP_ATOMIC);
 		if (!f)
 			return -ENOMEM;
 		notify = 1;
 		f->state = state;
 		f->flags = ndm_flags;
 		f->updated = f->used = jiffies;
 		INIT_LIST_HEAD(&f->remotes);
 		memcpy(f->eth_addr, mac, ETH_ALEN);
 		vxlan_fdb_append(f, ip, port, vni, ifindex);
 		++vxlan->addrcnt;
 		hlist_add_head_rcu(&f->hlist,
 				   vxlan_fdb_head(vxlan, mac));
 	}
 	if (notify)
 		vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
 	return 0;
 }
 static void vxlan_fdb_free(struct rcu_head *head)
 {
 	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
 	struct vxlan_rdst *rd, *nd;
 	list_for_each_entry_safe(rd, nd, &f->remotes, list)
 		kfree(rd);
 	kfree(f);
 }
 static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f)
 {
 	netdev_dbg(vxlan->dev,
 		    "delete %pM\n", f->eth_addr);
 	--vxlan->addrcnt;
 	vxlan_fdb_notify(vxlan, f, RTM_DELNEIGH);
 	hlist_del_rcu(&f->hlist);
 	call_rcu(&f->rcu, vxlan_fdb_free);
 }
 static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
 			   union vxlan_addr *ip, __be16 *port, u32 *vni, u32 *ifindex)
 {
 	struct net *net = dev_net(vxlan->dev);
 	int err;
 	if (tb[NDA_DST]) {
 		err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
 		if (err)
 			return err;
 	} else {
 		union vxlan_addr *remote = &vxlan->default_dst.remote_ip;
 		if (remote->sa.sa_family == AF_INET) {
 			ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);
 			ip->sa.sa_family = AF_INET;
 #if IS_ENABLED(CONFIG_IPV6)
 		} else {
 			ip->sin6.sin6_addr = in6addr_any;
 			ip->sa.sa_family = AF_INET6;
 #endif
 		}
 	}
 	if (tb[NDA_PORT]) {
 		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
 			return -EINVAL;
 		*port = nla_get_be16(tb[NDA_PORT]);
 	} else {
 		*port = vxlan->dst_port;
 	}
 	if (tb[NDA_VNI]) {
 		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
 			return -EINVAL;
 		*vni = nla_get_u32(tb[NDA_VNI]);
 	} else {
 		*vni = vxlan->default_dst.remote_vni;
 	}
 	if (tb[NDA_IFINDEX]) {
 		struct net_device *tdev;
 		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
 			return -EINVAL;
 		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);
 		tdev = dev_get_by_index(net, *ifindex);
 		if (!tdev)
 			return -EADDRNOTAVAIL;
 		dev_put(tdev);
 	} else {
 		*ifindex = 0;
 	}
 	return 0;
 }
 /* Add static entry (via netlink) */
 static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 			 struct net_device *dev,
 			 const unsigned char *addr, u16 flags)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	/* struct net *net = dev_net(vxlan->dev); */
 	union vxlan_addr ip;
 	__be16 port;
 	u32 vni, ifindex;
 	int err;
 	if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {
 		pr_info("RTM_NEWNEIGH with invalid state %#x\n",
 			ndm->ndm_state);
 		return -EINVAL;
 	}
 	if (tb[NDA_DST] == NULL)
 		return -EINVAL;
 	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
 	if (err)
 		return err;
 	spin_lock_bh(&vxlan->hash_lock);
 	err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,
 			       port, vni, ifindex, ndm->ndm_flags);
 	spin_unlock_bh(&vxlan->hash_lock);
 	return err;
 }
 /* Delete entry (via netlink) */
 static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
 			    struct net_device *dev,
 			    const unsigned char *addr)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_fdb *f;
 	struct vxlan_rdst *rd = NULL;
 	union vxlan_addr ip;
 	__be16 port;
 	u32 vni, ifindex;
 	int err;
 	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
 	if (err)
 		return err;
 	err = -ENOENT;
 	spin_lock_bh(&vxlan->hash_lock);
 	f = vxlan_find_mac(vxlan, addr);
 	if (!f)
 		goto out;
 	if (!vxlan_addr_any(&ip)) {
 		rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
 		if (!rd)
 			goto out;
 	}
 	err = 0;
 	/* remove a destination if it's not the only one on the list,
 	 * otherwise destroy the fdb entry
 	 */
 	if (rd && !list_is_singular(&f->remotes)) {
 		list_del_rcu(&rd->list);
 		kfree_rcu(rd, rcu);
 		goto out;
 	}
 	vxlan_fdb_destroy(vxlan, f);
 out:
 	spin_unlock_bh(&vxlan->hash_lock);
 	return err;
 }
 /* Dump forwarding table */
 static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
 			  struct net_device *dev, int idx)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	unsigned int h;
 	for (h = 0; h < FDB_HASH_SIZE; ++h) {
 		struct vxlan_fdb *f;
 		int err;
 		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
 			struct vxlan_rdst *rd;
 			if (idx < cb->args[0])
 				goto skip;
 			list_for_each_entry_rcu(rd, &f->remotes, list) {
 				err = vxlan_fdb_info(skb, vxlan, f,
 						     NETLINK_CB(cb->skb).portid,
 						     cb->nlh->nlmsg_seq,
 						     RTM_NEWNEIGH,
 						     NLM_F_MULTI, rd);
 				if (err < 0)
 					goto out;
 			}
 skip:
 			++idx;
 		}
 	}
 out:
 	return idx;
 }
 /* Watch incoming packets to learn mapping between Ethernet address
  * and Tunnel endpoint.
  * Return true if packet is bogus and should be droppped.
  */
 static bool vxlan_snoop(struct net_device *dev,
 			union vxlan_addr *src_ip, const u8 *src_mac)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_fdb *f;
 	f = vxlan_find_mac(vxlan, src_mac);
 	if (likely(f)) {
 		struct vxlan_rdst *rdst = first_remote_rcu(f);
 		if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))
 			return false;
 		/* Don't migrate static entries, drop packets */
 		if (f->state & NUD_NOARP)
 			return true;
 		if (net_ratelimit())
 			netdev_info(dev,
 				    "%pM migrated from %pIS to %pIS\n",
 				    src_mac, &rdst->remote_ip, &src_ip);
 		rdst->remote_ip = *src_ip;
 		f->updated = jiffies;
 		vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
 	} else {
 		/* learned new entry */
 		spin_lock(&vxlan->hash_lock);
 		/* close off race between vxlan_flush and incoming packets */
 		if (netif_running(dev))
 			vxlan_fdb_create(vxlan, src_mac, src_ip,
 					 NUD_REACHABLE,
 					 NLM_F_EXCL|NLM_F_CREATE,
 					 vxlan->dst_port,
 					 vxlan->default_dst.remote_vni,
 					 0, NTF_SELF);
 		spin_unlock(&vxlan->hash_lock);
 	}
 	return false;
 }
 /* See if multicast group is already in use by other ID */
 static bool vxlan_group_used(struct vxlan_net *vn, union vxlan_addr *remote_ip)
 {
 	struct vxlan_dev *vxlan;
 	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
 		if (!netif_running(vxlan->dev))
 			continue;
 		if (vxlan_addr_equal(&vxlan->default_dst.remote_ip,
 				     remote_ip))
 			return true;
 	}
 	return false;
 }
 static void vxlan_sock_hold(struct vxlan_sock *vs)
 {
 	atomic_inc(&vs->refcnt);
 }
 void vxlan_sock_release(struct vxlan_sock *vs)
 {
 	struct sock *sk = vs->sock->sk;
 	struct net *net = sock_net(sk);
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	if (!atomic_dec_and_test(&vs->refcnt))
 		return;
 	spin_lock(&vn->sock_lock);
 	hlist_del_rcu(&vs->hlist);
 	rcu_assign_sk_user_data(vs->sock->sk, NULL);
 	vxlan_notify_del_rx_port(sk);
 	spin_unlock(&vn->sock_lock);
 	queue_work(vxlan_wq, &vs->del_work);
 }
 EXPORT_SYMBOL_GPL(vxlan_sock_release);
 /* Callback to update multicast group membership when first VNI on
  * multicast asddress is brought up
  * Done as workqueue because ip_mc_join_group acquires RTNL.
  */
 static void vxlan_igmp_join(struct work_struct *work)
 {
 	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_join);
 	struct vxlan_sock *vs = vxlan->vn_sock;
 	struct sock *sk = vs->sock->sk;
 	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
 	int ifindex = vxlan->default_dst.remote_ifindex;
 	lock_sock(sk);
 	if (ip->sa.sa_family == AF_INET) {
 		struct ip_mreqn mreq = {
 			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
 			.imr_ifindex		= ifindex,
 		};
 		ip_mc_join_group(sk, &mreq);
 #if IS_ENABLED(CONFIG_IPV6)
 	} else {
 		ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
 					     &ip->sin6.sin6_addr);
 #endif
 	}
 	release_sock(sk);
 	vxlan_sock_release(vs);
 	dev_put(vxlan->dev);
 }
 /* Inverse of vxlan_igmp_join when last VNI is brought down */
 static void vxlan_igmp_leave(struct work_struct *work)
 {
 	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_leave);
 	struct vxlan_sock *vs = vxlan->vn_sock;
 	struct sock *sk = vs->sock->sk;
 	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
 	int ifindex = vxlan->default_dst.remote_ifindex;
 	lock_sock(sk);
 	if (ip->sa.sa_family == AF_INET) {
 		struct ip_mreqn mreq = {
 			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
 			.imr_ifindex		= ifindex,
 		};
 		ip_mc_leave_group(sk, &mreq);
 #if IS_ENABLED(CONFIG_IPV6)
 	} else {
 		ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
 					     &ip->sin6.sin6_addr);
 #endif
 	}
 	release_sock(sk);
 	vxlan_sock_release(vs);
 	dev_put(vxlan->dev);
 }
 /* Callback from net/ipv4/udp.c to receive packets */
 static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
 {
 	struct vxlan_sock *vs;
 	struct vxlanhdr *vxh;
 	__be16 port;
 	/* Need Vxlan and inner Ethernet header to be present */
 	if (!pskb_may_pull(skb, VXLAN_HLEN))
 		goto error;
 	/* Return packets with reserved bits set */
 	vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);
 	if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||
 	    (vxh->vx_vni & htonl(0xff))) {
 		netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",
 			   ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));
 		goto error;
 	}
 	if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))
 		goto drop;
 	port = inet_sk(sk)->inet_sport;
 	vs = rcu_dereference_sk_user_data(sk);
 	if (!vs)
 		goto drop;
 	vs->rcv(vs, skb, vxh->vx_vni);
 	return 0;
 drop:
 	/* Consume bad packet */
 	kfree_skb(skb);
 	return 0;
 error:
 	/* Return non vxlan pkt */
 	return 1;
 }
 static void vxlan_rcv(struct vxlan_sock *vs,
 		      struct sk_buff *skb, __be32 vx_vni)
 {
 	struct iphdr *oip = NULL;
 	struct ipv6hdr *oip6 = NULL;
 	struct vxlan_dev *vxlan;
 	struct pcpu_tstats *stats;
 	union vxlan_addr saddr;
 	__u32 vni;
 	int err = 0;
 	union vxlan_addr *remote_ip;
 	vni = ntohl(vx_vni) >> 8;
 	/* Is this VNI defined? */
 	vxlan = vxlan_vs_find_vni(vs, vni);
 	if (!vxlan)
 		goto drop;
 	remote_ip = &vxlan->default_dst.remote_ip;
 	skb_reset_mac_header(skb);
 	skb->protocol = eth_type_trans(skb, vxlan->dev);
 	/* Ignore packet loops (and multicast echo) */
 	if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))
 		goto drop;
 	/* Re-examine inner Ethernet packet */
 	if (remote_ip->sa.sa_family == AF_INET) {
 		oip = ip_hdr(skb);
 		saddr.sin.sin_addr.s_addr = oip->saddr;
 		saddr.sa.sa_family = AF_INET;
 #if IS_ENABLED(CONFIG_IPV6)
 	} else {
 		oip6 = ipv6_hdr(skb);
 		saddr.sin6.sin6_addr = oip6->saddr;
 		saddr.sa.sa_family = AF_INET6;
 #endif
 	}
 	if ((vxlan->flags & VXLAN_F_LEARN) &&
 	    vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))
 		goto drop;
 	skb_reset_network_header(skb);
 	/* If the NIC driver gave us an encapsulated packet with
 	 * CHECKSUM_UNNECESSARY and Rx checksum feature is enabled,
 	 * leave the CHECKSUM_UNNECESSARY, the device checksummed it
 	 * for us. Otherwise force the upper layers to verify it.
 	 */
 	if (skb->ip_summed != CHECKSUM_UNNECESSARY || !skb->encapsulation ||
 	    !(vxlan->dev->features & NETIF_F_RXCSUM))
 		skb->ip_summed = CHECKSUM_NONE;
 	skb->encapsulation = 0;
 	if (oip6)
 		err = IP6_ECN_decapsulate(oip6, skb);
 	if (oip)
 		err = IP_ECN_decapsulate(oip, skb);
 	if (unlikely(err)) {
 		if (log_ecn_error) {
 			if (oip6)
 				net_info_ratelimited("non-ECT from %pI6\n",
 						     &oip6->saddr);
 			if (oip)
 				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
 						     &oip->saddr, oip->tos);
 		}
 		if (err > 1) {
 			++vxlan->dev->stats.rx_frame_errors;
 			++vxlan->dev->stats.rx_errors;
 			goto drop;
 		}
 	}
 	stats = this_cpu_ptr(vxlan->dev->tstats);
 	u64_stats_update_begin(&stats->syncp);
 	stats->rx_packets++;
 	stats->rx_bytes += skb->len;
 	u64_stats_update_end(&stats->syncp);
 	netif_rx(skb);
 	return;
 drop:
 	/* Consume bad packet */
 	kfree_skb(skb);
 }
 static int arp_reduce(struct net_device *dev, struct sk_buff *skb)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct arphdr *parp;
 	u8 *arpptr, *sha;
 	__be32 sip, tip;
 	struct neighbour *n;
 	if (dev->flags & IFF_NOARP)
 		goto out;
 	if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
 		dev->stats.tx_dropped++;
 		goto out;
 	}
 	parp = arp_hdr(skb);
 	if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&
 	     parp->ar_hrd != htons(ARPHRD_IEEE802)) ||
 	    parp->ar_pro != htons(ETH_P_IP) ||
 	    parp->ar_op != htons(ARPOP_REQUEST) ||
 	    parp->ar_hln != dev->addr_len ||
 	    parp->ar_pln != 4)
 		goto out;
 	arpptr = (u8 *)parp + sizeof(struct arphdr);
 	sha = arpptr;
 	arpptr += dev->addr_len;	/* sha */
 	memcpy(&sip, arpptr, sizeof(sip));
 	arpptr += sizeof(sip);
 	arpptr += dev->addr_len;	/* tha */
 	memcpy(&tip, arpptr, sizeof(tip));
 	if (ipv4_is_loopback(tip) ||
 	    ipv4_is_multicast(tip))
 		goto out;
 	n = neigh_lookup(&arp_tbl, &tip, dev);
 	if (n) {
 		struct vxlan_fdb *f;
 		struct sk_buff	*reply;
 		if (!(n->nud_state & NUD_CONNECTED)) {
 			neigh_release(n);
 			goto out;
 		}
 		f = vxlan_find_mac(vxlan, n->ha);
 		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
 			/* bridge-local neighbor */
 			neigh_release(n);
 			goto out;
 		}
 		reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
 				n->ha, sha);
 		neigh_release(n);
 		skb_reset_mac_header(reply);
 		__skb_pull(reply, skb_network_offset(reply));
 		reply->ip_summed = CHECKSUM_UNNECESSARY;
 		reply->pkt_type = PACKET_HOST;
 		if (netif_rx_ni(reply) == NET_RX_DROP)
 			dev->stats.rx_dropped++;
 	} else if (vxlan->flags & VXLAN_F_L3MISS) {
 		union vxlan_addr ipa = {
 			.sin.sin_addr.s_addr = tip,
 			.sa.sa_family = AF_INET,
 		};
 		vxlan_ip_miss(dev, &ipa);
 	}
 out:
 	consume_skb(skb);
 	return NETDEV_TX_OK;
 }
 #if IS_ENABLED(CONFIG_IPV6)
 static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct neighbour *n;
 	union vxlan_addr ipa;
 	const struct ipv6hdr *iphdr;
 	const struct in6_addr *saddr, *daddr;
 	struct nd_msg *msg;
 	struct inet6_dev *in6_dev = NULL;
 	in6_dev = __in6_dev_get(dev);
 	if (!in6_dev)
 		goto out;
 	if (!pskb_may_pull(skb, skb->len))
 		goto out;
 	iphdr = ipv6_hdr(skb);
 	saddr = &iphdr->saddr;
 	daddr = &iphdr->daddr;
 	if (ipv6_addr_loopback(daddr) ||
 	    ipv6_addr_is_multicast(daddr))
 		goto out;
 	msg = (struct nd_msg *)skb_transport_header(skb);
 	if (msg->icmph.icmp6_code != 0 ||
 	    msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)
 		goto out;
 	n = neigh_lookup(ipv6_stub->nd_tbl, daddr, dev);
 	if (n) {
 		struct vxlan_fdb *f;
 		if (!(n->nud_state & NUD_CONNECTED)) {
 			neigh_release(n);
 			goto out;
 		}
 		f = vxlan_find_mac(vxlan, n->ha);
 		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
 			/* bridge-local neighbor */
 			neigh_release(n);
 			goto out;
 		}
 		ipv6_stub->ndisc_send_na(dev, n, saddr, &msg->target,
 					 !!in6_dev->cnf.forwarding,
 					 true, false, false);
 		neigh_release(n);
 	} else if (vxlan->flags & VXLAN_F_L3MISS) {
 		ipa.sin6.sin6_addr = *daddr;
 		ipa.sa.sa_family = AF_INET6;
 		vxlan_ip_miss(dev, &ipa);
 	}
 out:
 	consume_skb(skb);
 	return NETDEV_TX_OK;
 }
 #endif
 static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct neighbour *n;
 	if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
 		return false;
 	n = NULL;
 	switch (ntohs(eth_hdr(skb)->h_proto)) {
 	case ETH_P_IP:
 	{
 		struct iphdr *pip;
 		if (!pskb_may_pull(skb, sizeof(struct iphdr)))
 			return false;
 		pip = ip_hdr(skb);
 		n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
 		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
 			union vxlan_addr ipa = {
 				.sin.sin_addr.s_addr = pip->daddr,
 				.sa.sa_family = AF_INET,
 			};
 			vxlan_ip_miss(dev, &ipa);
 			return false;
 		}
 		break;
 	}
 #if IS_ENABLED(CONFIG_IPV6)
 	case ETH_P_IPV6:
 	{
 		struct ipv6hdr *pip6;
 		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 			return false;
 		pip6 = ipv6_hdr(skb);
 		n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);
 		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
 			union vxlan_addr ipa = {
 				.sin6.sin6_addr = pip6->daddr,
 				.sa.sa_family = AF_INET6,
 			};
 			vxlan_ip_miss(dev, &ipa);
 			return false;
 		}
 		break;
 	}
 #endif
 	default:
 		return false;
 	}
 	if (n) {
 		bool diff;
 		diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);
 		if (diff) {
 			memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,
 				dev->addr_len);
 			memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);
 		}
 		neigh_release(n);
 		return diff;
 	}
 	return false;
 }
 static void vxlan_sock_put(struct sk_buff *skb)
 {
 	sock_put(skb->sk);
 }
 /* On transmit, associate with the tunnel socket */
 static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)
 {
 	skb_orphan(skb);
 	sock_hold(sk);
 	skb->sk = sk;
 	skb->destructor = vxlan_sock_put;
 }
 /* Compute source port for outgoing packet
  *   first choice to use L4 flow hash since it will spread
  *     better and maybe available from hardware
  *   secondary choice is to use jhash on the Ethernet header
  */
 __be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)
 {
 	unsigned int range = (port_max - port_min) + 1;
 	u32 hash;
 	hash = skb_get_rxhash(skb);
 	if (!hash)
 		hash = jhash(skb->data, 2 * ETH_ALEN,
 			     (__force u32) skb->protocol);
 	return htons((((u64) hash * range) >> 32) + port_min);
 }
 EXPORT_SYMBOL_GPL(vxlan_src_port);
 static int handle_offloads(struct sk_buff *skb)
 {
 	if (skb_is_gso(skb)) {
 		int err = skb_unclone(skb, GFP_ATOMIC);
 		if (unlikely(err))
 			return err;
 		skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
 	} else if (skb->ip_summed != CHECKSUM_PARTIAL)
 		skb->ip_summed = CHECKSUM_NONE;
 	return 0;
 }
 #if IS_ENABLED(CONFIG_IPV6)
 static int vxlan6_xmit_skb(struct vxlan_sock *vs,
 			   struct dst_entry *dst, struct sk_buff *skb,
 			   struct net_device *dev, struct in6_addr *saddr,
 			   struct in6_addr *daddr, __u8 prio, __u8 ttl,
 			   __be16 src_port, __be16 dst_port, __be32 vni)
 {
 	struct ipv6hdr *ip6h;
 	struct vxlanhdr *vxh;
 	struct udphdr *uh;
 	int min_headroom;
 	int err;
 	if (!skb->encapsulation) {
 		skb_reset_inner_headers(skb);
 		skb->encapsulation = 1;
 	}
 	skb_scrub_packet(skb, false);
 	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
 			+ VXLAN_HLEN + sizeof(struct ipv6hdr)
 			+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
 	/* Need space for new headers (invalidates iph ptr) */
 	err = skb_cow_head(skb, min_headroom);
 	if (unlikely(err))
 		return err;
 	if (vlan_tx_tag_present(skb)) {
 		if (WARN_ON(!__vlan_put_tag(skb,
 					    skb->vlan_proto,
 					    vlan_tx_tag_get(skb))))
 			return -ENOMEM;
 		skb->vlan_tci = 0;
 	}
 	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
 	vxh->vx_flags = htonl(VXLAN_FLAGS);
 	vxh->vx_vni = vni;
 	__skb_push(skb, sizeof(*uh));
 	skb_reset_transport_header(skb);
 	uh = udp_hdr(skb);
 	uh->dest = dst_port;
 	uh->source = src_port;
 	uh->len = htons(skb->len);
 	uh->check = 0;
 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 			      IPSKB_REROUTED);
 	skb_dst_set(skb, dst);
 	if (!skb_is_gso(skb) && !(dst->dev->features & NETIF_F_IPV6_CSUM)) {
 		__wsum csum = skb_checksum(skb, 0, skb->len, 0);
 		skb->ip_summed = CHECKSUM_UNNECESSARY;
 		uh->check = csum_ipv6_magic(saddr, daddr, skb->len,
 					    IPPROTO_UDP, csum);
 		if (uh->check == 0)
 			uh->check = CSUM_MANGLED_0;
 	} else {
 		skb->ip_summed = CHECKSUM_PARTIAL;
 		skb->csum_start = skb_transport_header(skb) - skb->head;
 		skb->csum_offset = offsetof(struct udphdr, check);
 		uh->check = ~csum_ipv6_magic(saddr, daddr,
 					     skb->len, IPPROTO_UDP, 0);
 	}
 	__skb_push(skb, sizeof(*ip6h));
 	skb_reset_network_header(skb);
 	ip6h		  = ipv6_hdr(skb);
 	ip6h->version	  = 6;
 	ip6h->priority	  = prio;
 	ip6h->flow_lbl[0] = 0;
 	ip6h->flow_lbl[1] = 0;
 	ip6h->flow_lbl[2] = 0;
 	ip6h->payload_len = htons(skb->len);
 	ip6h->nexthdr     = IPPROTO_UDP;
 	ip6h->hop_limit   = ttl;
 	ip6h->daddr	  = *daddr;
 	ip6h->saddr	  = *saddr;
 	vxlan_set_owner(vs->sock->sk, skb);
 	err = handle_offloads(skb);
 	if (err)
 		return err;
 	ip6tunnel_xmit(skb, dev);
 	return 0;
 }
 #endif
 int vxlan_xmit_skb(struct vxlan_sock *vs,
 		   struct rtable *rt, struct sk_buff *skb,
 		   __be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
 		   __be16 src_port, __be16 dst_port, __be32 vni)
 {
 	struct vxlanhdr *vxh;
 	struct udphdr *uh;
 	int min_headroom;
 	int err;
 	if (!skb->encapsulation) {
 		skb_reset_inner_headers(skb);
 		skb->encapsulation = 1;
 	}
 	min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
 			+ VXLAN_HLEN + sizeof(struct iphdr)
 			+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
 	/* Need space for new headers (invalidates iph ptr) */
 	err = skb_cow_head(skb, min_headroom);
 	if (unlikely(err))
 		return err;
 	if (vlan_tx_tag_present(skb)) {
 		if (WARN_ON(!__vlan_put_tag(skb,
 					    skb->vlan_proto,
 					    vlan_tx_tag_get(skb))))
 			return -ENOMEM;
 		skb->vlan_tci = 0;
 	}
 	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
 	vxh->vx_flags = htonl(VXLAN_FLAGS);
 	vxh->vx_vni = vni;
 	__skb_push(skb, sizeof(*uh));
 	skb_reset_transport_header(skb);
 	uh = udp_hdr(skb);
 	uh->dest = dst_port;
 	uh->source = src_port;
 	uh->len = htons(skb->len);
 	uh->check = 0;
 	vxlan_set_owner(vs->sock->sk, skb);
 	err = handle_offloads(skb);
 	if (err)
 		return err;
 	return iptunnel_xmit(rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df,
 			     false);
 }
 EXPORT_SYMBOL_GPL(vxlan_xmit_skb);
 /* Bypass encapsulation if the destination is local */
 static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,
 			       struct vxlan_dev *dst_vxlan)
 {
 	struct pcpu_tstats *tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
 	struct pcpu_tstats *rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);
 	union vxlan_addr loopback;
 	union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
 	skb->pkt_type = PACKET_HOST;
 	skb->encapsulation = 0;
 	skb->dev = dst_vxlan->dev;
 	__skb_pull(skb, skb_network_offset(skb));
 	if (remote_ip->sa.sa_family == AF_INET) {
 		loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 		loopback.sa.sa_family =  AF_INET;
 #if IS_ENABLED(CONFIG_IPV6)
 	} else {
 		loopback.sin6.sin6_addr = in6addr_loopback;
 		loopback.sa.sa_family =  AF_INET6;
 #endif
 	}
 	if (dst_vxlan->flags & VXLAN_F_LEARN)
 		vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);
 	u64_stats_update_begin(&tx_stats->syncp);
 	tx_stats->tx_packets++;
 	tx_stats->tx_bytes += skb->len;
 	u64_stats_update_end(&tx_stats->syncp);
 	if (netif_rx(skb) == NET_RX_SUCCESS) {
 		u64_stats_update_begin(&rx_stats->syncp);
 		rx_stats->rx_packets++;
 		rx_stats->rx_bytes += skb->len;
 		u64_stats_update_end(&rx_stats->syncp);
 	} else {
 		skb->dev->stats.rx_dropped++;
 	}
 }
 static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
 			   struct vxlan_rdst *rdst, bool did_rsc)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct rtable *rt = NULL;
 	const struct iphdr *old_iph;
 	struct flowi4 fl4;
 	union vxlan_addr *dst;
 	__be16 src_port = 0, dst_port;
 	u32 vni;
 	__be16 df = 0;
 	__u8 tos, ttl;
 	int err;
 	dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;
 	vni = rdst->remote_vni;
 	dst = &rdst->remote_ip;
 	if (vxlan_addr_any(dst)) {
 		if (did_rsc) {
 			/* short-circuited back to local bridge */
 			vxlan_encap_bypass(skb, vxlan, vxlan);
 			return;
 		}
 		goto drop;
 	}
 	old_iph = ip_hdr(skb);
 	ttl = vxlan->ttl;
 	if (!ttl && vxlan_addr_multicast(dst))
 		ttl = 1;
 	tos = vxlan->tos;
 	if (tos == 1)
 		tos = ip_tunnel_get_dsfield(old_iph, skb);
 	src_port = vxlan_src_port(vxlan->port_min, vxlan->port_max, skb);
 	if (dst->sa.sa_family == AF_INET) {
 		memset(&fl4, 0, sizeof(fl4));
 		fl4.flowi4_oif = rdst->remote_ifindex;
 		fl4.flowi4_tos = RT_TOS(tos);
 		fl4.daddr = dst->sin.sin_addr.s_addr;
 		fl4.saddr = vxlan->saddr.sin.sin_addr.s_addr;
 		rt = ip_route_output_key(dev_net(dev), &fl4);
 		if (IS_ERR(rt)) {
 			netdev_dbg(dev, "no route to %pI4\n",
 				   &dst->sin.sin_addr.s_addr);
 			dev->stats.tx_carrier_errors++;
 			goto tx_error;
 		}
 		if (rt->dst.dev == dev) {
 			netdev_dbg(dev, "circular route to %pI4\n",
 				   &dst->sin.sin_addr.s_addr);
 			dev->stats.collisions++;
 			goto tx_error;
 		}
 		/* Bypass encapsulation if the destination is local */
 		if (rt->rt_flags & RTCF_LOCAL &&
 		    !(rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
 			struct vxlan_dev *dst_vxlan;
 			ip_rt_put(rt);
 			dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
 			if (!dst_vxlan)
 				goto tx_error;
 			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
 			return;
 		}
 		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
 		ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
 		err = vxlan_xmit_skb(vxlan->vn_sock, rt, skb,
 				     fl4.saddr, dst->sin.sin_addr.s_addr,
 				     tos, ttl, df, src_port, dst_port,
 				     htonl(vni << 8));
 		if (err < 0)
 			goto rt_tx_error;
 		iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
 #if IS_ENABLED(CONFIG_IPV6)
 	} else {
 		struct sock *sk = vxlan->vn_sock->sock->sk;
 		struct dst_entry *ndst;
 		struct flowi6 fl6;
 		u32 flags;
 		memset(&fl6, 0, sizeof(fl6));
 		fl6.flowi6_oif = rdst->remote_ifindex;
 		fl6.daddr = dst->sin6.sin6_addr;
 		fl6.saddr = vxlan->saddr.sin6.sin6_addr;
 		fl6.flowi6_proto = IPPROTO_UDP;
 		if (ipv6_stub->ipv6_dst_lookup(sk, &ndst, &fl6)) {
 			netdev_dbg(dev, "no route to %pI6\n",
 				   &dst->sin6.sin6_addr);
 			dev->stats.tx_carrier_errors++;
 			goto tx_error;
 		}
 		if (ndst->dev == dev) {
 			netdev_dbg(dev, "circular route to %pI6\n",
 				   &dst->sin6.sin6_addr);
 			dst_release(ndst);
 			dev->stats.collisions++;
 			goto tx_error;
 		}
 		/* Bypass encapsulation if the destination is local */
 		flags = ((struct rt6_info *)ndst)->rt6i_flags;
 		if (flags & RTF_LOCAL &&
 		    !(flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
 			struct vxlan_dev *dst_vxlan;
 			dst_release(ndst);
 			dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
 			if (!dst_vxlan)
 				goto tx_error;
 			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
 			return;
 		}
 		ttl = ttl ? : ip6_dst_hoplimit(ndst);
 		err = vxlan6_xmit_skb(vxlan->vn_sock, ndst, skb,
 				      dev, &fl6.saddr, &fl6.daddr, 0, ttl,
 				      src_port, dst_port, htonl(vni << 8));
 #endif
 	}
 	return;
 drop:
 	dev->stats.tx_dropped++;
 	goto tx_free;
 rt_tx_error:
 	ip_rt_put(rt);
 tx_error:
 	dev->stats.tx_errors++;
 tx_free:
 	dev_kfree_skb(skb);
 }
 /* Transmit local packets over Vxlan
  *
  * Outer IP header inherits ECN and DF from inner header.
  * Outer UDP destination is the VXLAN assigned port.
  *           source port is based on hash of flow
  */
 static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct ethhdr *eth;
 	bool did_rsc = false;
 	struct vxlan_rdst *rdst;
 	struct vxlan_fdb *f;
 	skb_reset_mac_header(skb);
 	eth = eth_hdr(skb);
 	if ((vxlan->flags & VXLAN_F_PROXY)) {
 		if (ntohs(eth->h_proto) == ETH_P_ARP)
 			return arp_reduce(dev, skb);
 #if IS_ENABLED(CONFIG_IPV6)
 		else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&
 			 skb->len >= sizeof(struct ipv6hdr) + sizeof(struct nd_msg) &&
 			 ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
 				struct nd_msg *msg;
 				msg = (struct nd_msg *)skb_transport_header(skb);
 				if (msg->icmph.icmp6_code == 0 &&
 				    msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)
 					return neigh_reduce(dev, skb);
 		}
 #endif
 	}
 	f = vxlan_find_mac(vxlan, eth->h_dest);
 	did_rsc = false;
 	if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
 	    (ntohs(eth->h_proto) == ETH_P_IP ||
 	     ntohs(eth->h_proto) == ETH_P_IPV6)) {
 		did_rsc = route_shortcircuit(dev, skb);
 		if (did_rsc)
 			f = vxlan_find_mac(vxlan, eth->h_dest);
 	}
 	if (f == NULL) {
 		f = vxlan_find_mac(vxlan, all_zeros_mac);
 		if (f == NULL) {
 			if ((vxlan->flags & VXLAN_F_L2MISS) &&
 			    !is_multicast_ether_addr(eth->h_dest))
 				vxlan_fdb_miss(vxlan, eth->h_dest);
 			dev->stats.tx_dropped++;
 			dev_kfree_skb(skb);
 			return NETDEV_TX_OK;
 		}
 	}
 	list_for_each_entry_rcu(rdst, &f->remotes, list) {
 		struct sk_buff *skb1;
 		skb1 = skb_clone(skb, GFP_ATOMIC);
 		if (skb1)
 			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
 	}
 	dev_kfree_skb(skb);
 	return NETDEV_TX_OK;
 }
 /* Walk the forwarding table and purge stale entries */
 static void vxlan_cleanup(unsigned long arg)
 {
 	struct vxlan_dev *vxlan = (struct vxlan_dev *) arg;
 	unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;
 	unsigned int h;
 	if (!netif_running(vxlan->dev))
 		return;
 	spin_lock_bh(&vxlan->hash_lock);
 	for (h = 0; h < FDB_HASH_SIZE; ++h) {
 		struct hlist_node *p, *n;
 		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
 			struct vxlan_fdb *f
 				= container_of(p, struct vxlan_fdb, hlist);
 			unsigned long timeout;
 			if (f->state & NUD_PERMANENT)
 				continue;
 			timeout = f->used + vxlan->age_interval * HZ;
 			if (time_before_eq(timeout, jiffies)) {
 				netdev_dbg(vxlan->dev,
 					   "garbage collect %pM\n",
 					   f->eth_addr);
 				f->state = NUD_STALE;
 				vxlan_fdb_destroy(vxlan, f);
 			} else if (time_before(timeout, next_timer))
 				next_timer = timeout;
 		}
 	}
 	spin_unlock_bh(&vxlan->hash_lock);
 	mod_timer(&vxlan->age_timer, next_timer);
 }
 static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)
 {
 	__u32 vni = vxlan->default_dst.remote_vni;
 	vxlan->vn_sock = vs;
 	hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
 }
 /* Setup stats when device is created */
 static int vxlan_init(struct net_device *dev)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
 	struct vxlan_sock *vs;
 	int i;
 	dev->tstats = alloc_percpu(struct pcpu_tstats);
 	if (!dev->tstats)
 		return -ENOMEM;
 	for_each_possible_cpu(i) {
 		struct pcpu_tstats *vxlan_stats;
 		vxlan_stats = per_cpu_ptr(dev->tstats, i);
 		u64_stats_init(&vxlan_stats->syncp);
 	}
 	spin_lock(&vn->sock_lock);
 	vs = vxlan_find_sock(dev_net(dev), vxlan->dst_port);
 	if (vs) {
 		/* If we have a socket with same port already, reuse it */
 		atomic_inc(&vs->refcnt);
 		vxlan_vs_add_dev(vs, vxlan);
 	} else {
 		/* otherwise make new socket outside of RTNL */
 		dev_hold(dev);
 		queue_work(vxlan_wq, &vxlan->sock_work);
 	}
 	spin_unlock(&vn->sock_lock);
 	return 0;
 }
 static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)
 {
 	struct vxlan_fdb *f;
 	spin_lock_bh(&vxlan->hash_lock);
 	f = __vxlan_find_mac(vxlan, all_zeros_mac);
 	if (f)
 		vxlan_fdb_destroy(vxlan, f);
 	spin_unlock_bh(&vxlan->hash_lock);
 }
 static void vxlan_uninit(struct net_device *dev)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_sock *vs = vxlan->vn_sock;
 	vxlan_fdb_delete_default(vxlan);
 	if (vs)
 		vxlan_sock_release(vs);
 	free_percpu(dev->tstats);
 }
 /* Start ageing timer and join group when device is brought up */
 static int vxlan_open(struct net_device *dev)
 {
-	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_sock *vs = vxlan->vn_sock;
 	/* socket hasn't been created */
 	if (!vs)
 		return -ENOTCONN;
-	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
+	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {
-	    vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {
 		vxlan_sock_hold(vs);
 		dev_hold(dev);
 		queue_work(vxlan_wq, &vxlan->igmp_join);
 	}
 	if (vxlan->age_interval)
 		mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);
 	return 0;
 }
 /* Purge the forwarding table */
 static void vxlan_flush(struct vxlan_dev *vxlan)
 {
 	unsigned int h;
 	spin_lock_bh(&vxlan->hash_lock);
 	for (h = 0; h < FDB_HASH_SIZE; ++h) {
 		struct hlist_node *p, *n;
 		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
 			struct vxlan_fdb *f
 				= container_of(p, struct vxlan_fdb, hlist);
 			/* the all_zeros_mac entry is deleted at vxlan_uninit */
 			if (!is_zero_ether_addr(f->eth_addr))
 				vxlan_fdb_destroy(vxlan, f);
 		}
 	}
 	spin_unlock_bh(&vxlan->hash_lock);
 }
 /* Cleanup timer and forwarding table on shutdown */
 static int vxlan_stop(struct net_device *dev)
 {
 	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_sock *vs = vxlan->vn_sock;
 	if (vs && vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
 	    ! vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {
 		vxlan_sock_hold(vs);
 		dev_hold(dev);
 		queue_work(vxlan_wq, &vxlan->igmp_leave);
 	}
 	del_timer_sync(&vxlan->age_timer);
 	vxlan_flush(vxlan);
 	return 0;
 }
 /* Stub, nothing needs to be done. */
 static void vxlan_set_multicast_list(struct net_device *dev)
 {
 }
 static const struct net_device_ops vxlan_netdev_ops = {
 	.ndo_init		= vxlan_init,
 	.ndo_uninit		= vxlan_uninit,
 	.ndo_open		= vxlan_open,
 	.ndo_stop		= vxlan_stop,
 	.ndo_start_xmit		= vxlan_xmit,
 	.ndo_get_stats64	= ip_tunnel_get_stats64,
 	.ndo_set_rx_mode	= vxlan_set_multicast_list,
 	.ndo_change_mtu		= eth_change_mtu,
 	.ndo_validate_addr	= eth_validate_addr,
 	.ndo_set_mac_address	= eth_mac_addr,
 	.ndo_fdb_add		= vxlan_fdb_add,
 	.ndo_fdb_del		= vxlan_fdb_delete,
 	.ndo_fdb_dump		= vxlan_fdb_dump,
 };
 /* Info for udev, that this is a virtual tunnel endpoint */
 static struct device_type vxlan_type = {
 	.name = "vxlan",
 };
 /* Calls the ndo_add_vxlan_port of the caller in order to
  * supply the listening VXLAN udp ports. Callers are expected
  * to implement the ndo_add_vxlan_port.
  */
 void vxlan_get_rx_port(struct net_device *dev)
 {
 	struct vxlan_sock *vs;
 	struct net *net = dev_net(dev);
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	sa_family_t sa_family;
 	__be16 port;
 	unsigned int i;
 	spin_lock(&vn->sock_lock);
 	for (i = 0; i < PORT_HASH_SIZE; ++i) {
 		hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {
 			port = inet_sk(vs->sock->sk)->inet_sport;
 			sa_family = vs->sock->sk->sk_family;
 			dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
 							    port);
 		}
 	}
 	spin_unlock(&vn->sock_lock);
 }
 EXPORT_SYMBOL_GPL(vxlan_get_rx_port);
 /* Initialize the device structure. */
 static void vxlan_setup(struct net_device *dev)
 {
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	unsigned int h;
 	int low, high;
 	eth_hw_addr_random(dev);
 	ether_setup(dev);
 	if (vxlan->default_dst.remote_ip.sa.sa_family == AF_INET6)
 		dev->hard_header_len = ETH_HLEN + VXLAN6_HEADROOM;
 	else
 		dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;
 	dev->netdev_ops = &vxlan_netdev_ops;
 	dev->destructor = free_netdev;
 	SET_NETDEV_DEVTYPE(dev, &vxlan_type);
 	dev->tx_queue_len = 0;
 	dev->features	|= NETIF_F_LLTX;
 	dev->features	|= NETIF_F_NETNS_LOCAL;
 	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
 	dev->features   |= NETIF_F_RXCSUM;
 	dev->features   |= NETIF_F_GSO_SOFTWARE;
 	dev->vlan_features = dev->features;
 	dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
 	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
 	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
 	dev->priv_flags	&= ~IFF_XMIT_DST_RELEASE;
 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 	INIT_LIST_HEAD(&vxlan->next);
 	spin_lock_init(&vxlan->hash_lock);
 	INIT_WORK(&vxlan->igmp_join, vxlan_igmp_join);
 	INIT_WORK(&vxlan->igmp_leave, vxlan_igmp_leave);
 	INIT_WORK(&vxlan->sock_work, vxlan_sock_work);
 	init_timer_deferrable(&vxlan->age_timer);
 	vxlan->age_timer.function = vxlan_cleanup;
 	vxlan->age_timer.data = (unsigned long) vxlan;
 	inet_get_local_port_range(dev_net(dev), &low, &high);
 	vxlan->port_min = low;
 	vxlan->port_max = high;
 	vxlan->dst_port = htons(vxlan_port);
 	vxlan->dev = dev;
 	for (h = 0; h < FDB_HASH_SIZE; ++h)
 		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
 }
 static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
 	[IFLA_VXLAN_ID]		= { .type = NLA_U32 },
 	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
 	[IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },
 	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
 	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
 	[IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },
 	[IFLA_VXLAN_TOS]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_TTL]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_LEARNING]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_AGEING]	= { .type = NLA_U32 },
 	[IFLA_VXLAN_LIMIT]	= { .type = NLA_U32 },
 	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
 	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
 	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
 };
 static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[])
 {
 	if (tb[IFLA_ADDRESS]) {
 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
 			pr_debug("invalid link address (not ethernet)\n");
 			return -EINVAL;
 		}
 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
 			pr_debug("invalid all zero ethernet address\n");
 			return -EADDRNOTAVAIL;
 		}
 	}
 	if (!data)
 		return -EINVAL;
 	if (data[IFLA_VXLAN_ID]) {
 		__u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);
 		if (id >= VXLAN_VID_MASK)
 			return -ERANGE;
 	}
 	if (data[IFLA_VXLAN_PORT_RANGE]) {
 		const struct ifla_vxlan_port_range *p
 			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
 		if (ntohs(p->high) < ntohs(p->low)) {
 			pr_debug("port range %u .. %u not valid\n",
 				 ntohs(p->low), ntohs(p->high));
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 static void vxlan_get_drvinfo(struct net_device *netdev,
 			      struct ethtool_drvinfo *drvinfo)
 {
 	strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));
 	strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));
 }
 static const struct ethtool_ops vxlan_ethtool_ops = {
 	.get_drvinfo	= vxlan_get_drvinfo,
 	.get_link	= ethtool_op_get_link,
 };
 static void vxlan_del_work(struct work_struct *work)
 {
 	struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);
 	sk_release_kernel(vs->sock->sk);
 	kfree_rcu(vs, rcu);
 }
 #if IS_ENABLED(CONFIG_IPV6)
 /* Create UDP socket for encapsulation receive. AF_INET6 socket
  * could be used for both IPv4 and IPv6 communications, but
  * users may set bindv6only=1.
  */
 static struct socket *create_v6_sock(struct net *net, __be16 port)
 {
 	struct sock *sk;
 	struct socket *sock;
 	struct sockaddr_in6 vxlan_addr = {
 		.sin6_family = AF_INET6,
 		.sin6_port = port,
 	};
 	int rc, val = 1;
 	rc = sock_create_kern(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
 	if (rc < 0) {
 		pr_debug("UDPv6 socket create failed\n");
 		return ERR_PTR(rc);
 	}
 	/* Put in proper namespace */
 	sk = sock->sk;
 	sk_change_net(sk, net);
 	kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,
 			  (char *)&val, sizeof(val));
 	rc = kernel_bind(sock, (struct sockaddr *)&vxlan_addr,
 			 sizeof(struct sockaddr_in6));
 	if (rc < 0) {
 		pr_debug("bind for UDPv6 socket %pI6:%u (%d)\n",
 			 &vxlan_addr.sin6_addr, ntohs(vxlan_addr.sin6_port), rc);
 		sk_release_kernel(sk);
 		return ERR_PTR(rc);
 	}
 	/* At this point, IPv6 module should have been loaded in
 	 * sock_create_kern().
 	 */
 	BUG_ON(!ipv6_stub);
 	/* Disable multicast loopback */
 	inet_sk(sk)->mc_loop = 0;
 	return sock;
 }
 #else
 static struct socket *create_v6_sock(struct net *net, __be16 port)
 {
 		return ERR_PTR(-EPFNOSUPPORT);
 }
 #endif
 static struct socket *create_v4_sock(struct net *net, __be16 port)
 {
 	struct sock *sk;
 	struct socket *sock;
 	struct sockaddr_in vxlan_addr = {
 		.sin_family = AF_INET,
 		.sin_addr.s_addr = htonl(INADDR_ANY),
 		.sin_port = port,
 	};
 	int rc;
 	/* Create UDP socket for encapsulation receive. */
 	rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
 	if (rc < 0) {
 		pr_debug("UDP socket create failed\n");
 		return ERR_PTR(rc);
 	}
 	/* Put in proper namespace */
 	sk = sock->sk;
 	sk_change_net(sk, net);
 	rc = kernel_bind(sock, (struct sockaddr *) &vxlan_addr,
 			 sizeof(vxlan_addr));
 	if (rc < 0) {
 		pr_debug("bind for UDP socket %pI4:%u (%d)\n",
 			 &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
 		sk_release_kernel(sk);
 		return ERR_PTR(rc);
 	}
 	/* Disable multicast loopback */
 	inet_sk(sk)->mc_loop = 0;
 	return sock;
 }
 /* Create new listen socket if needed */
 static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,
 					      vxlan_rcv_t *rcv, void *data, bool ipv6)
 {
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	struct vxlan_sock *vs;
 	struct socket *sock;
 	struct sock *sk;
 	unsigned int h;
 	vs = kmalloc(sizeof(*vs), GFP_KERNEL);
 	if (!vs)
 		return ERR_PTR(-ENOMEM);
 	for (h = 0; h < VNI_HASH_SIZE; ++h)
 		INIT_HLIST_HEAD(&vs->vni_list[h]);
 	INIT_WORK(&vs->del_work, vxlan_del_work);
 	if (ipv6)
 		sock = create_v6_sock(net, port);
 	else
 		sock = create_v4_sock(net, port);
 	if (IS_ERR(sock)) {
 		kfree(vs);
 		return ERR_CAST(sock);
 	}
 	vs->sock = sock;
 	sk = sock->sk;
 	atomic_set(&vs->refcnt, 1);
 	vs->rcv = rcv;
 	vs->data = data;
 	rcu_assign_sk_user_data(vs->sock->sk, vs);
 	spin_lock(&vn->sock_lock);
 	hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
 	vxlan_notify_add_rx_port(sk);
 	spin_unlock(&vn->sock_lock);
 	/* Mark socket as an encapsulation socket. */
 	udp_sk(sk)->encap_type = 1;
 	udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
 #if IS_ENABLED(CONFIG_IPV6)
 	if (ipv6)
 		ipv6_stub->udpv6_encap_enable();
 	else
 #endif
 		udp_encap_enable();
 	return vs;
 }
 struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
 				  vxlan_rcv_t *rcv, void *data,
 				  bool no_share, bool ipv6)
 {
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	struct vxlan_sock *vs;
 	vs = vxlan_socket_create(net, port, rcv, data, ipv6);
 	if (!IS_ERR(vs))
 		return vs;
 	if (no_share)	/* Return error if sharing is not allowed. */
 		return vs;
 	spin_lock(&vn->sock_lock);
 	vs = vxlan_find_sock(net, port);
 	if (vs) {
 		if (vs->rcv == rcv)
 			atomic_inc(&vs->refcnt);
 		else
 			vs = ERR_PTR(-EBUSY);
 	}
 	spin_unlock(&vn->sock_lock);
 	if (!vs)
 		vs = ERR_PTR(-EINVAL);
 	return vs;
 }
 EXPORT_SYMBOL_GPL(vxlan_sock_add);
 /* Scheduled at device creation to bind to a socket */
 static void vxlan_sock_work(struct work_struct *work)
 {
 	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, sock_work);
 	struct net *net = dev_net(vxlan->dev);
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	__be16 port = vxlan->dst_port;
 	struct vxlan_sock *nvs;
 	nvs = vxlan_sock_add(net, port, vxlan_rcv, NULL, false, vxlan->flags & VXLAN_F_IPV6);
 	spin_lock(&vn->sock_lock);
 	if (!IS_ERR(nvs))
 		vxlan_vs_add_dev(nvs, vxlan);
 	spin_unlock(&vn->sock_lock);
 	dev_put(vxlan->dev);
 }
 static int vxlan_newlink(struct net *net, struct net_device *dev,
 			 struct nlattr *tb[], struct nlattr *data[])
 {
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	struct vxlan_rdst *dst = &vxlan->default_dst;
 	__u32 vni;
 	int err;
 	bool use_ipv6 = false;
 	if (!data[IFLA_VXLAN_ID])
 		return -EINVAL;
 	vni = nla_get_u32(data[IFLA_VXLAN_ID]);
 	dst->remote_vni = vni;
 	if (data[IFLA_VXLAN_GROUP]) {
 		dst->remote_ip.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_GROUP]);
 		dst->remote_ip.sa.sa_family = AF_INET;
 	} else if (data[IFLA_VXLAN_GROUP6]) {
 		if (!IS_ENABLED(CONFIG_IPV6))
 			return -EPFNOSUPPORT;
 		nla_memcpy(&dst->remote_ip.sin6.sin6_addr, data[IFLA_VXLAN_GROUP6],
 			   sizeof(struct in6_addr));
 		dst->remote_ip.sa.sa_family = AF_INET6;
 		use_ipv6 = true;
 	}
 	if (data[IFLA_VXLAN_LOCAL]) {
 		vxlan->saddr.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_LOCAL]);
 		vxlan->saddr.sa.sa_family = AF_INET;
 	} else if (data[IFLA_VXLAN_LOCAL6]) {
 		if (!IS_ENABLED(CONFIG_IPV6))
 			return -EPFNOSUPPORT;
 		/* TODO: respect scope id */
 		nla_memcpy(&vxlan->saddr.sin6.sin6_addr, data[IFLA_VXLAN_LOCAL6],
 			   sizeof(struct in6_addr));
 		vxlan->saddr.sa.sa_family = AF_INET6;
 		use_ipv6 = true;
 	}
 	if (data[IFLA_VXLAN_LINK] &&
 	    (dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {
 		struct net_device *lowerdev
 			 = __dev_get_by_index(net, dst->remote_ifindex);
 		if (!lowerdev) {
 			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
 			return -ENODEV;
 		}
 #if IS_ENABLED(CONFIG_IPV6)
 		if (use_ipv6) {
 			struct inet6_dev *idev = __in6_dev_get(lowerdev);
 			if (idev && idev->cnf.disable_ipv6) {
 				pr_info("IPv6 is disabled via sysctl\n");
 				return -EPERM;
 			}
 			vxlan->flags |= VXLAN_F_IPV6;
 		}
 #endif
 		if (!tb[IFLA_MTU])
 			dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
 		/* update header length based on lower device */
 		dev->hard_header_len = lowerdev->hard_header_len +
 				       (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
 	}
 	if (data[IFLA_VXLAN_TOS])
 		vxlan->tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);
 	if (data[IFLA_VXLAN_TTL])
 		vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);
 	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
 		vxlan->flags |= VXLAN_F_LEARN;
 	if (data[IFLA_VXLAN_AGEING])
 		vxlan->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);
 	else
 		vxlan->age_interval = FDB_AGE_DEFAULT;
 	if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))
 		vxlan->flags |= VXLAN_F_PROXY;
 	if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))
 		vxlan->flags |= VXLAN_F_RSC;
 	if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))
 		vxlan->flags |= VXLAN_F_L2MISS;
 	if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))
 		vxlan->flags |= VXLAN_F_L3MISS;
 	if (data[IFLA_VXLAN_LIMIT])
 		vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);
 	if (data[IFLA_VXLAN_PORT_RANGE]) {
 		const struct ifla_vxlan_port_range *p
 			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
 		vxlan->port_min = ntohs(p->low);
 		vxlan->port_max = ntohs(p->high);
 	}
 	if (data[IFLA_VXLAN_PORT])
 		vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
 	if (vxlan_find_vni(net, vni, vxlan->dst_port)) {
 		pr_info("duplicate VNI %u\n", vni);
 		return -EEXIST;
 	}
 	SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);
 	/* create an fdb entry for a valid default destination */
 	if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {
 		err = vxlan_fdb_create(vxlan, all_zeros_mac,
 				       &vxlan->default_dst.remote_ip,
 				       NUD_REACHABLE|NUD_PERMANENT,
 				       NLM_F_EXCL|NLM_F_CREATE,
 				       vxlan->dst_port,
 				       vxlan->default_dst.remote_vni,
 				       vxlan->default_dst.remote_ifindex,
 				       NTF_SELF);
 		if (err)
 			return err;
 	}
 	err = register_netdevice(dev);
 	if (err) {
 		vxlan_fdb_delete_default(vxlan);
 		return err;
 	}
 	list_add(&vxlan->next, &vn->vxlan_list);
 	return 0;
 }
 static void vxlan_dellink(struct net_device *dev, struct list_head *head)
 {
 	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
 	struct vxlan_dev *vxlan = netdev_priv(dev);
 	spin_lock(&vn->sock_lock);
 	if (!hlist_unhashed(&vxlan->hlist))
 		hlist_del_rcu(&vxlan->hlist);
 	spin_unlock(&vn->sock_lock);
 	list_del(&vxlan->next);
 	unregister_netdevice_queue(dev, head);
 }
 static size_t vxlan_get_size(const struct net_device *dev)
 {
 	return nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_ID */
 		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
 		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */
 		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TOS */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_LEARNING */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_PROXY */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_RSC */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L2MISS */
 		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L3MISS */
 		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
 		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
 		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
 		nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */
 		0;
 }
 static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
 {
 	const struct vxlan_dev *vxlan = netdev_priv(dev);
 	const struct vxlan_rdst *dst = &vxlan->default_dst;
 	struct ifla_vxlan_port_range ports = {
 		.low =  htons(vxlan->port_min),
 		.high = htons(vxlan->port_max),
 	};
 	if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))
 		goto nla_put_failure;
 	if (!vxlan_addr_any(&dst->remote_ip)) {
 		if (dst->remote_ip.sa.sa_family == AF_INET) {
 			if (nla_put_be32(skb, IFLA_VXLAN_GROUP,
 					 dst->remote_ip.sin.sin_addr.s_addr))
 				goto nla_put_failure;
 #if IS_ENABLED(CONFIG_IPV6)
 		} else {
 			if (nla_put(skb, IFLA_VXLAN_GROUP6, sizeof(struct in6_addr),
 				    &dst->remote_ip.sin6.sin6_addr))
 				goto nla_put_failure;
 #endif
 		}
 	}
 	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
 		goto nla_put_failure;
 	if (!vxlan_addr_any(&vxlan->saddr)) {
 		if (vxlan->saddr.sa.sa_family == AF_INET) {
 			if (nla_put_be32(skb, IFLA_VXLAN_LOCAL,
 					 vxlan->saddr.sin.sin_addr.s_addr))
 				goto nla_put_failure;
 #if IS_ENABLED(CONFIG_IPV6)
 		} else {
 			if (nla_put(skb, IFLA_VXLAN_LOCAL6, sizeof(struct in6_addr),
 				    &vxlan->saddr.sin6.sin6_addr))
 				goto nla_put_failure;
 #endif
 		}
 	}
 	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->ttl) ||
 	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->tos) ||
 	    nla_put_u8(skb, IFLA_VXLAN_LEARNING,
 			!!(vxlan->flags & VXLAN_F_LEARN)) ||
 	    nla_put_u8(skb, IFLA_VXLAN_PROXY,
 			!!(vxlan->flags & VXLAN_F_PROXY)) ||
 	    nla_put_u8(skb, IFLA_VXLAN_RSC, !!(vxlan->flags & VXLAN_F_RSC)) ||
 	    nla_put_u8(skb, IFLA_VXLAN_L2MISS,
 			!!(vxlan->flags & VXLAN_F_L2MISS)) ||
 	    nla_put_u8(skb, IFLA_VXLAN_L3MISS,
 			!!(vxlan->flags & VXLAN_F_L3MISS)) ||
 	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||
 	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||
 	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))
 		goto nla_put_failure;
 	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
 		goto nla_put_failure;
 	return 0;
 nla_put_failure:
 	return -EMSGSIZE;
 }
 static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
 	.kind		= "vxlan",
 	.maxtype	= IFLA_VXLAN_MAX,
 	.policy		= vxlan_policy,
 	.priv_size	= sizeof(struct vxlan_dev),
 	.setup		= vxlan_setup,
 	.validate	= vxlan_validate,
 	.newlink	= vxlan_newlink,
 	.dellink	= vxlan_dellink,
 	.get_size	= vxlan_get_size,
 	.fill_info	= vxlan_fill_info,
 };
 static __net_init int vxlan_init_net(struct net *net)
 {
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	unsigned int h;
 	INIT_LIST_HEAD(&vn->vxlan_list);
 	spin_lock_init(&vn->sock_lock);
 	for (h = 0; h < PORT_HASH_SIZE; ++h)
 		INIT_HLIST_HEAD(&vn->sock_list[h]);
 	return 0;
 }
 static __net_exit void vxlan_exit_net(struct net *net)
 {
 	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 	struct vxlan_dev *vxlan;
 	LIST_HEAD(list);
 	rtnl_lock();
 	list_for_each_entry(vxlan, &vn->vxlan_list, next)
 		unregister_netdevice_queue(vxlan->dev, &list);
 	unregister_netdevice_many(&list);
 	rtnl_unlock();
 }
 static struct pernet_operations vxlan_net_ops = {
 	.init = vxlan_init_net,
 	.exit = vxlan_exit_net,
 	.id   = &vxlan_net_id,
 	.size = sizeof(struct vxlan_net),
 };
 static int __init vxlan_init_module(void)
 {
 	int rc;
 	vxlan_wq = alloc_workqueue("vxlan", 0, 0);
 	if (!vxlan_wq)
 		return -ENOMEM;
 	get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));
 	rc = register_pernet_device(&vxlan_net_ops);
 	if (rc)
 		goto out1;
 	rc = rtnl_link_register(&vxlan_link_ops);
 	if (rc)
 		goto out2;
 	return 0;
 out2:
 	unregister_pernet_device(&vxlan_net_ops);
 out1:
 	destroy_workqueue(vxlan_wq);
 	return rc;
 }
 late_initcall(vxlan_init_module);
 static void __exit vxlan_cleanup_module(void)
 {
 	rtnl_link_unregister(&vxlan_link_ops);
 	destroy_workqueue(vxlan_wq);
 	unregister_pernet_device(&vxlan_net_ops);
 	rcu_barrier();
 }
 module_exit(vxlan_cleanup_module);
 MODULE_LICENSE("GPL");
 MODULE_VERSION(VXLAN_VERSION);
 MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");
 MODULE_ALIAS_RTNL_LINK("vxlan");