br_netlink.c 21.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
 *	Bridge netlink control interface
 *
 *	Authors:
 *	Stephen Hemminger		<shemminger@osdl.org>
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 */

#include <linux/kernel.h>
14
#include <linux/slab.h>
15
#include <linux/etherdevice.h>
16
#include <net/rtnetlink.h>
17
#include <net/net_namespace.h>
18
#include <net/sock.h>
19
#include <net/switchdev.h>
20
#include <uapi/linux/if_bridge.h>
21

22
#include "br_private.h"
23
#include "br_private_stp.h"
24

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
static int br_get_num_vlan_infos(const struct net_port_vlans *pv,
				 u32 filter_mask)
{
	u16 vid_range_start = 0, vid_range_end = 0;
	u16 vid_range_flags = 0;
	u16 pvid, vid, flags;
	int num_vlans = 0;

	if (filter_mask & RTEXT_FILTER_BRVLAN)
		return pv->num_vlans;

	if (!(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
		return 0;

	/* Count number of vlan info's
	 */
	pvid = br_get_pvid(pv);
	for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
		flags = 0;
		if (vid == pvid)
			flags |= BRIDGE_VLAN_INFO_PVID;

		if (test_bit(vid, pv->untagged_bitmap))
			flags |= BRIDGE_VLAN_INFO_UNTAGGED;

		if (vid_range_start == 0) {
			goto initvars;
		} else if ((vid - vid_range_end) == 1 &&
			flags == vid_range_flags) {
			vid_range_end = vid;
			continue;
		} else {
			if ((vid_range_end - vid_range_start) > 0)
				num_vlans += 2;
			else
				num_vlans += 1;
		}
initvars:
		vid_range_start = vid;
		vid_range_end = vid;
		vid_range_flags = flags;
	}

	if (vid_range_start != 0) {
		if ((vid_range_end - vid_range_start) > 0)
			num_vlans += 2;
		else
			num_vlans += 1;
	}

	return num_vlans;
}

static size_t br_get_link_af_size_filtered(const struct net_device *dev,
					   u32 filter_mask)
80
81
{
	struct net_port_vlans *pv;
82
	int num_vlan_infos;
83

84
	rcu_read_lock();
85
	if (br_port_exists(dev))
86
		pv = nbp_get_vlan_info(br_port_get_rcu(dev));
87
88
89
	else if (dev->priv_flags & IFF_EBRIDGE)
		pv = br_get_vlan_info((struct net_bridge *)netdev_priv(dev));
	else
90
91
92
93
94
95
		pv = NULL;
	if (pv)
		num_vlan_infos = br_get_num_vlan_infos(pv, filter_mask);
	else
		num_vlan_infos = 0;
	rcu_read_unlock();
96

97
98
99
	if (!num_vlan_infos)
		return 0;

100
	/* Each VLAN is returned in bridge_vlan_info along with flags */
101
	return num_vlan_infos * nla_total_size(sizeof(struct bridge_vlan_info));
102
103
}

104
105
106
107
108
109
static inline size_t br_port_info_size(void)
{
	return nla_total_size(1)	/* IFLA_BRPORT_STATE  */
		+ nla_total_size(2)	/* IFLA_BRPORT_PRIORITY */
		+ nla_total_size(4)	/* IFLA_BRPORT_COST */
		+ nla_total_size(1)	/* IFLA_BRPORT_MODE */
110
		+ nla_total_size(1)	/* IFLA_BRPORT_GUARD */
111
		+ nla_total_size(1)	/* IFLA_BRPORT_PROTECT */
112
		+ nla_total_size(1)	/* IFLA_BRPORT_FAST_LEAVE */
113
		+ nla_total_size(1)	/* IFLA_BRPORT_LEARNING */
114
		+ nla_total_size(1)	/* IFLA_BRPORT_UNICAST_FLOOD */
115
116
117
		+ 0;
}

118
static inline size_t br_nlmsg_size(struct net_device *dev, u32 filter_mask)
119
120
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
121
122
123
124
125
126
		+ nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
		+ nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
		+ nla_total_size(4) /* IFLA_MASTER */
		+ nla_total_size(4) /* IFLA_MTU */
		+ nla_total_size(4) /* IFLA_LINK */
		+ nla_total_size(1) /* IFLA_OPERSTATE */
127
		+ nla_total_size(br_port_info_size()) /* IFLA_PROTINFO */
128
129
		+ nla_total_size(br_get_link_af_size_filtered(dev,
				 filter_mask)); /* IFLA_AF_SPEC */
130
131
132
133
134
135
136
137
138
139
}

static int br_port_fill_attrs(struct sk_buff *skb,
			      const struct net_bridge_port *p)
{
	u8 mode = !!(p->flags & BR_HAIRPIN_MODE);

	if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
	    nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
	    nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
140
	    nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
141
	    nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
142
	    nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
143
	    nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
144
	    nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
145
	    nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD, !!(p->flags & BR_FLOOD)) ||
146
147
148
	    nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)) ||
	    nla_put_u8(skb, IFLA_BRPORT_PROXYARP_WIFI,
		       !!(p->flags & BR_PROXYARP_WIFI)))
149
150
151
		return -EMSGSIZE;

	return 0;
152
153
}

154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
static int br_fill_ifvlaninfo_range(struct sk_buff *skb, u16 vid_start,
				    u16 vid_end, u16 flags)
{
	struct  bridge_vlan_info vinfo;

	if ((vid_end - vid_start) > 0) {
		/* add range to skb */
		vinfo.vid = vid_start;
		vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_BEGIN;
		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
			    sizeof(vinfo), &vinfo))
			goto nla_put_failure;

		vinfo.flags &= ~BRIDGE_VLAN_INFO_RANGE_BEGIN;

		vinfo.vid = vid_end;
		vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_END;
		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
			    sizeof(vinfo), &vinfo))
			goto nla_put_failure;
	} else {
		vinfo.vid = vid_start;
		vinfo.flags = flags;
		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
			    sizeof(vinfo), &vinfo))
			goto nla_put_failure;
	}

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static int br_fill_ifvlaninfo_compressed(struct sk_buff *skb,
					 const struct net_port_vlans *pv)
{
	u16 vid_range_start = 0, vid_range_end = 0;
192
	u16 vid_range_flags = 0;
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
	u16 pvid, vid, flags;
	int err = 0;

	/* Pack IFLA_BRIDGE_VLAN_INFO's for every vlan
	 * and mark vlan info with begin and end flags
	 * if vlaninfo represents a range
	 */
	pvid = br_get_pvid(pv);
	for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
		flags = 0;
		if (vid == pvid)
			flags |= BRIDGE_VLAN_INFO_PVID;

		if (test_bit(vid, pv->untagged_bitmap))
			flags |= BRIDGE_VLAN_INFO_UNTAGGED;

		if (vid_range_start == 0) {
			goto initvars;
		} else if ((vid - vid_range_end) == 1 &&
			flags == vid_range_flags) {
			vid_range_end = vid;
			continue;
		} else {
			err = br_fill_ifvlaninfo_range(skb, vid_range_start,
						       vid_range_end,
						       vid_range_flags);
			if (err)
				return err;
		}

initvars:
		vid_range_start = vid;
		vid_range_end = vid;
		vid_range_flags = flags;
	}

229
230
231
232
233
234
235
236
	if (vid_range_start != 0) {
		/* Call it once more to send any left over vlans */
		err = br_fill_ifvlaninfo_range(skb, vid_range_start,
					       vid_range_end,
					       vid_range_flags);
		if (err)
			return err;
	}
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267

	return 0;
}

static int br_fill_ifvlaninfo(struct sk_buff *skb,
			      const struct net_port_vlans *pv)
{
	struct bridge_vlan_info vinfo;
	u16 pvid, vid;

	pvid = br_get_pvid(pv);
	for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) {
		vinfo.vid = vid;
		vinfo.flags = 0;
		if (vid == pvid)
			vinfo.flags |= BRIDGE_VLAN_INFO_PVID;

		if (test_bit(vid, pv->untagged_bitmap))
			vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;

		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
			    sizeof(vinfo), &vinfo))
			goto nla_put_failure;
	}

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

268
269
270
271
/*
 * Create one netlink message for one interface
 * Contains port and master info as well as carrier and bridge state.
 */
272
273
274
275
static int br_fill_ifinfo(struct sk_buff *skb,
			  const struct net_bridge_port *port,
			  u32 pid, u32 seq, int event, unsigned int flags,
			  u32 filter_mask, const struct net_device *dev)
276
{
277
	const struct net_bridge *br;
278
	struct ifinfomsg *hdr;
279
280
281
	struct nlmsghdr *nlh;
	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;

282
283
284
285
286
	if (port)
		br = port->br;
	else
		br = netdev_priv(dev);

287
288
	br_debug(br, "br_fill_info event %d port %s master %s\n",
		     event, dev->name, br->dev->name);
289

290
291
	nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
	if (nlh == NULL)
292
		return -EMSGSIZE;
293

294
295
296
297
298
299
300
	hdr = nlmsg_data(nlh);
	hdr->ifi_family = AF_BRIDGE;
	hdr->__ifi_pad = 0;
	hdr->ifi_type = dev->type;
	hdr->ifi_index = dev->ifindex;
	hdr->ifi_flags = dev_get_flags(dev);
	hdr->ifi_change = 0;
301

302
303
304
305
306
307
	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
	    nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
	    nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
	    (dev->addr_len &&
	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
308
309
	    (dev->ifindex != dev_get_iflink(dev) &&
	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
310
		goto nla_put_failure;
311

312
	if (event == RTM_NEWLINK && port) {
313
314
315
316
317
318
319
320
		struct nlattr *nest
			= nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);

		if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
			goto nla_put_failure;
		nla_nest_end(skb, nest);
	}

321
	/* Check if  the VID information is requested */
322
323
	if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
	    (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
324
		const struct net_port_vlans *pv;
325
326
		struct nlattr *af;
		int err;
327
328
329
330
331
332

		if (port)
			pv = nbp_get_vlan_info(port);
		else
			pv = br_get_vlan_info(br);

333
		if (!pv || bitmap_empty(pv->vlan_bitmap, VLAN_N_VID))
334
335
336
337
338
339
			goto done;

		af = nla_nest_start(skb, IFLA_AF_SPEC);
		if (!af)
			goto nla_put_failure;

340
341
342
343
344
345
		if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
			err = br_fill_ifvlaninfo_compressed(skb, pv);
		else
			err = br_fill_ifvlaninfo(skb, pv);
		if (err)
			goto nla_put_failure;
346
347
348
349
		nla_nest_end(skb, af);
	}

done:
350
351
	nlmsg_end(skb, nlh);
	return 0;
352

353
nla_put_failure:
354
355
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
356
357
358
359
360
361
362
}

/*
 * Notify listeners of a change in port information
 */
void br_ifinfo_notify(int event, struct net_bridge_port *port)
{
363
	struct net *net;
364
	struct sk_buff *skb;
365
	int err = -ENOBUFS;
366
	u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;
367

368
369
370
371
	if (!port)
		return;

	net = dev_net(port->dev);
372
	br_debug(port->br, "port %u(%s) event %d\n",
373
		 (unsigned int)port->port_no, port->dev->name, event);
374

375
	skb = nlmsg_new(br_nlmsg_size(port->dev, filter), GFP_ATOMIC);
376
377
378
	if (skb == NULL)
		goto errout;

379
	err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, port->dev);
380
381
382
383
384
385
	if (err < 0) {
		/* -EMSGSIZE implies BUG in br_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
386
387
	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
	return;
388
errout:
389
	rtnl_set_sk_err(net, RTNLGRP_LINK, err);
390
391
}

392

393
394
395
/*
 * Dump information about all ports, in response to GETLINK
 */
396
int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
397
	       struct net_device *dev, u32 filter_mask, int nlflags)
398
{
399
	struct net_bridge_port *port = br_port_get_rtnl(dev);
400

401
402
	if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
	    !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
403
		return 0;
404

405
	return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, nlflags,
406
			      filter_mask, dev);
407
408
}

409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
			int cmd, struct bridge_vlan_info *vinfo)
{
	int err = 0;

	switch (cmd) {
	case RTM_SETLINK:
		if (p) {
			err = nbp_vlan_add(p, vinfo->vid, vinfo->flags);
			if (err)
				break;

			if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
				err = br_vlan_add(p->br, vinfo->vid,
						  vinfo->flags);
		} else {
			err = br_vlan_add(br, vinfo->vid, vinfo->flags);
		}
		break;

	case RTM_DELLINK:
		if (p) {
			nbp_vlan_delete(p, vinfo->vid);
			if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
				br_vlan_delete(p->br, vinfo->vid);
		} else {
			br_vlan_delete(br, vinfo->vid);
		}
		break;
	}

	return err;
}
442
443
444
445
446
447

static int br_afspec(struct net_bridge *br,
		     struct net_bridge_port *p,
		     struct nlattr *af_spec,
		     int cmd)
{
448
449
450
	struct bridge_vlan_info *vinfo_start = NULL;
	struct bridge_vlan_info *vinfo = NULL;
	struct nlattr *attr;
451
	int err = 0;
452
	int rem;
453

454
455
456
457
458
459
	nla_for_each_nested(attr, af_spec, rem) {
		if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
			continue;
		if (nla_len(attr) != sizeof(struct bridge_vlan_info))
			return -EINVAL;
		vinfo = nla_data(attr);
460
461
		if (!vinfo->vid || vinfo->vid >= VLAN_VID_MASK)
			return -EINVAL;
462
463
464
465
466
467
		if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
			if (vinfo_start)
				return -EINVAL;
			vinfo_start = vinfo;
			continue;
		}
468

469
470
471
		if (vinfo_start) {
			struct bridge_vlan_info tmp_vinfo;
			int v;
472

473
474
			if (!(vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END))
				return -EINVAL;
475

476
477
478
479
480
			if (vinfo->vid <= vinfo_start->vid)
				return -EINVAL;

			memcpy(&tmp_vinfo, vinfo_start,
			       sizeof(struct bridge_vlan_info));
481

482
483
484
			for (v = vinfo_start->vid; v <= vinfo->vid; v++) {
				tmp_vinfo.vid = v;
				err = br_vlan_info(br, p, cmd, &tmp_vinfo);
485
486
				if (err)
					break;
487
488
489
490
			}
			vinfo_start = NULL;
		} else {
			err = br_vlan_info(br, p, cmd, vinfo);
491
		}
492
493
		if (err)
			break;
494
495
496
497
498
	}

	return err;
}

499
static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
500
501
502
503
	[IFLA_BRPORT_STATE]	= { .type = NLA_U8 },
	[IFLA_BRPORT_COST]	= { .type = NLA_U32 },
	[IFLA_BRPORT_PRIORITY]	= { .type = NLA_U16 },
	[IFLA_BRPORT_MODE]	= { .type = NLA_U8 },
504
	[IFLA_BRPORT_GUARD]	= { .type = NLA_U8 },
505
	[IFLA_BRPORT_PROTECT]	= { .type = NLA_U8 },
506
	[IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
507
	[IFLA_BRPORT_LEARNING]	= { .type = NLA_U8 },
508
	[IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
509
510
511
512
513
514
515
516
517
518
519
520
};

/* Change the state of the port and notify spanning tree */
static int br_set_port_state(struct net_bridge_port *p, u8 state)
{
	if (state > BR_STATE_BLOCKING)
		return -EINVAL;

	/* if kernel STP is running, don't allow changes */
	if (p->br->stp_enabled == BR_KERNEL_STP)
		return -EBUSY;

521
522
523
	/* if device is not up, change is not allowed
	 * if link is not present, only allowable state is disabled
	 */
524
	if (!netif_running(p->dev) ||
525
	    (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
526
527
		return -ENETDOWN;

528
	br_set_state(p, state);
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
	br_log_state(p);
	br_port_state_selection(p->br);
	return 0;
}

/* Set/clear or port flags based on attribute */
static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
			   int attrtype, unsigned long mask)
{
	if (tb[attrtype]) {
		u8 flag = nla_get_u8(tb[attrtype]);
		if (flag)
			p->flags |= mask;
		else
			p->flags &= ~mask;
	}
}

/* Process bridge protocol info on port */
static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
{
	int err;
551
	unsigned long old_flags = p->flags;
552
553

	br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
554
	br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
555
	br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
556
	br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
557
	br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
558
	br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
559
	br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
560
	br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578

	if (tb[IFLA_BRPORT_COST]) {
		err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
		if (err)
			return err;
	}

	if (tb[IFLA_BRPORT_PRIORITY]) {
		err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
		if (err)
			return err;
	}

	if (tb[IFLA_BRPORT_STATE]) {
		err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
		if (err)
			return err;
	}
579
580

	br_port_flags_change(p, old_flags ^ p->flags);
581
582
583
584
	return 0;
}

/* Change state and parameters on port. */
585
int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
586
{
587
	struct nlattr *protinfo;
588
	struct nlattr *afspec;
589
	struct net_bridge_port *p;
590
	struct nlattr *tb[IFLA_BRPORT_MAX + 1];
591
	int err = 0;
592

593
594
	protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
	afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
595
	if (!protinfo && !afspec)
596
		return 0;
597

598
	p = br_port_get_rtnl(dev);
599
	/* We want to accept dev as bridge itself if the AF_SPEC
stephen hemminger's avatar
stephen hemminger committed
600
	 * is set to see if someone is setting vlan info on the bridge
601
	 */
602
	if (!p && !afspec)
603
		return -EINVAL;
604

605
606
607
	if (p && protinfo) {
		if (protinfo->nla_type & NLA_F_NESTED) {
			err = nla_parse_nested(tb, IFLA_BRPORT_MAX,
608
					       protinfo, br_port_policy);
609
610
611
612
613
614
615
			if (err)
				return err;

			spin_lock_bh(&p->br->lock);
			err = br_setport(p, tb);
			spin_unlock_bh(&p->br->lock);
		} else {
stephen hemminger's avatar
stephen hemminger committed
616
			/* Binary compatibility with old RSTP */
617
618
619
620
621
622
623
			if (nla_len(protinfo) < sizeof(u8))
				return -EINVAL;

			spin_lock_bh(&p->br->lock);
			err = br_set_port_state(p, nla_get_u8(protinfo));
			spin_unlock_bh(&p->br->lock);
		}
624
		if (err)
625
626
			goto out;
	}
627

628
629
630
	if (afspec) {
		err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
				afspec, RTM_SETLINK);
631
	}
632

633
634
	if (err == 0)
		br_ifinfo_notify(RTM_NEWLINK, p);
635
out:
636
	return err;
637
638
}

639
/* Delete port information */
640
int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
641
642
643
{
	struct nlattr *afspec;
	struct net_bridge_port *p;
644
	int err = 0;
645

646
	afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
647
648
649
650
651
652
653
654
655
656
	if (!afspec)
		return 0;

	p = br_port_get_rtnl(dev);
	/* We want to accept dev as bridge itself as well */
	if (!p && !(dev->priv_flags & IFF_EBRIDGE))
		return -EINVAL;

	err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
			afspec, RTM_DELLINK);
657
658
659
660
661
	if (err == 0)
		/* Send RTM_NEWLINK because userspace
		 * expects RTM_NEWLINK for vlan dels
		 */
		br_ifinfo_notify(RTM_NEWLINK, p);
662
663
664

	return err;
}
665
666
667
668
669
670
671
672
673
674
675
676
static int br_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}

	return 0;
}

677
678
679
680
681
682
683
684
685
686
687
688
689
690
static int br_dev_newlink(struct net *src_net, struct net_device *dev,
			  struct nlattr *tb[], struct nlattr *data[])
{
	struct net_bridge *br = netdev_priv(dev);

	if (tb[IFLA_ADDRESS]) {
		spin_lock_bh(&br->lock);
		br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
		spin_unlock_bh(&br->lock);
	}

	return register_netdevice(dev);
}

691
692
693
694
695
static int br_port_slave_changelink(struct net_device *brdev,
				    struct net_device *dev,
				    struct nlattr *tb[],
				    struct nlattr *data[])
{
696
697
698
	struct net_bridge *br = netdev_priv(brdev);
	int ret;

699
700
	if (!data)
		return 0;
701
702
703
704
705
706

	spin_lock_bh(&br->lock);
	ret = br_setport(br_port_get_rtnl(dev), data);
	spin_unlock_bh(&br->lock);

	return ret;
707
708
}

709
710
711
712
713
714
715
716
717
718
719
720
721
static int br_port_fill_slave_info(struct sk_buff *skb,
				   const struct net_device *brdev,
				   const struct net_device *dev)
{
	return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
}

static size_t br_port_get_slave_size(const struct net_device *brdev,
				     const struct net_device *dev)
{
	return br_port_info_size();
}

722
723
724
725
static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
	[IFLA_BR_FORWARD_DELAY]	= { .type = NLA_U32 },
	[IFLA_BR_HELLO_TIME]	= { .type = NLA_U32 },
	[IFLA_BR_MAX_AGE]	= { .type = NLA_U32 },
726
727
728
	[IFLA_BR_AGEING_TIME] = { .type = NLA_U32 },
	[IFLA_BR_STP_STATE] = { .type = NLA_U32 },
	[IFLA_BR_PRIORITY] = { .type = NLA_U16 },
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
};

static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
			 struct nlattr *data[])
{
	struct net_bridge *br = netdev_priv(brdev);
	int err;

	if (!data)
		return 0;

	if (data[IFLA_BR_FORWARD_DELAY]) {
		err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
		if (err)
			return err;
	}

	if (data[IFLA_BR_HELLO_TIME]) {
		err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
		if (err)
			return err;
	}

	if (data[IFLA_BR_MAX_AGE]) {
		err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
		if (err)
			return err;
	}

758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
	if (data[IFLA_BR_AGEING_TIME]) {
		u32 ageing_time = nla_get_u32(data[IFLA_BR_AGEING_TIME]);

		br->ageing_time = clock_t_to_jiffies(ageing_time);
	}

	if (data[IFLA_BR_STP_STATE]) {
		u32 stp_enabled = nla_get_u32(data[IFLA_BR_STP_STATE]);

		br_stp_set_enabled(br, stp_enabled);
	}

	if (data[IFLA_BR_PRIORITY]) {
		u32 priority = nla_get_u16(data[IFLA_BR_PRIORITY]);

		br_stp_set_bridge_priority(br, priority);
	}

776
777
778
	return 0;
}

779
780
781
782
783
static size_t br_get_size(const struct net_device *brdev)
{
	return nla_total_size(sizeof(u32)) +	/* IFLA_BR_FORWARD_DELAY  */
	       nla_total_size(sizeof(u32)) +	/* IFLA_BR_HELLO_TIME */
	       nla_total_size(sizeof(u32)) +	/* IFLA_BR_MAX_AGE */
784
785
786
	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_AGEING_TIME */
	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_STP_STATE */
	       nla_total_size(sizeof(u16)) +    /* IFLA_BR_PRIORITY */
787
788
789
790
791
792
793
794
795
	       0;
}

static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
{
	struct net_bridge *br = netdev_priv(brdev);
	u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
	u32 hello_time = jiffies_to_clock_t(br->hello_time);
	u32 age_time = jiffies_to_clock_t(br->max_age);
796
797
798
	u32 ageing_time = jiffies_to_clock_t(br->ageing_time);
	u32 stp_enabled = br->stp_enabled;
	u16 priority = (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1];
799
800
801

	if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
	    nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
802
803
804
805
	    nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time) ||
	    nla_put_u32(skb, IFLA_BR_AGEING_TIME, ageing_time) ||
	    nla_put_u32(skb, IFLA_BR_STP_STATE, stp_enabled) ||
	    nla_put_u16(skb, IFLA_BR_PRIORITY, priority))
806
807
808
809
810
		return -EMSGSIZE;

	return 0;
}

811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
static size_t br_get_link_af_size(const struct net_device *dev)
{
	struct net_port_vlans *pv;

	if (br_port_exists(dev))
		pv = nbp_get_vlan_info(br_port_get_rtnl(dev));
	else if (dev->priv_flags & IFF_EBRIDGE)
		pv = br_get_vlan_info((struct net_bridge *)netdev_priv(dev));
	else
		return 0;

	if (!pv)
		return 0;

	/* Each VLAN is returned in bridge_vlan_info along with flags */
	return pv->num_vlans * nla_total_size(sizeof(struct bridge_vlan_info));
}

829
static struct rtnl_af_ops br_af_ops __read_mostly = {
830
831
832
833
	.family			= AF_BRIDGE,
	.get_link_af_size	= br_get_link_af_size,
};

834
struct rtnl_link_ops br_link_ops __read_mostly = {
835
836
837
	.kind			= "bridge",
	.priv_size		= sizeof(struct net_bridge),
	.setup			= br_dev_setup,
838
839
	.maxtype		= IFLA_BRPORT_MAX,
	.policy			= br_policy,
840
841
	.validate		= br_validate,
	.newlink		= br_dev_newlink,
842
	.changelink		= br_changelink,
843
	.dellink		= br_dev_delete,
844
845
	.get_size		= br_get_size,
	.fill_info		= br_fill_info,
846
847
848
849

	.slave_maxtype		= IFLA_BRPORT_MAX,
	.slave_policy		= br_port_policy,
	.slave_changelink	= br_port_slave_changelink,
850
851
	.get_slave_size		= br_port_get_slave_size,
	.fill_slave_info	= br_port_fill_slave_info,
852
};
853

854
int __init br_netlink_init(void)
855
{
856
857
858
	int err;

	br_mdb_init();
859
	rtnl_af_register(&br_af_ops);
860

861
862
863
864
	err = rtnl_link_register(&br_link_ops);
	if (err)
		goto out_af;

865
	return 0;
866
867
868

out_af:
	rtnl_af_unregister(&br_af_ops);
869
870
	br_mdb_uninit();
	return err;
871
872
}

873
void br_netlink_fini(void)
874
{
875
	br_mdb_uninit();
876
	rtnl_af_unregister(&br_af_ops);
877
	rtnl_link_unregister(&br_link_ops);
878
}