datapath.c 51.0 KB
Newer Older
1
/*
2
 * Copyright (c) 2007-2013 Nicira, Inc.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/init.h>
#include <linux/module.h>
#include <linux/if_arp.h>
#include <linux/if_vlan.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/jhash.h>
#include <linux/delay.h>
#include <linux/time.h>
#include <linux/etherdevice.h>
#include <linux/genetlink.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/percpu.h>
#include <linux/rcupdate.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/ethtool.h>
#include <linux/wait.h>
#include <asm/div64.h>
#include <linux/highmem.h>
#include <linux/netfilter_bridge.h>
#include <linux/netfilter_ipv4.h>
#include <linux/inetdevice.h>
#include <linux/list.h>
47
#include <linux/lockdep.h>
48 49 50 51 52
#include <linux/openvswitch.h>
#include <linux/rculist.h>
#include <linux/dmi.h>
#include <linux/workqueue.h>
#include <net/genetlink.h>
53 54
#include <net/net_namespace.h>
#include <net/netns/generic.h>
55 56 57

#include "datapath.h"
#include "flow.h"
58
#include "flow_table.h"
59
#include "flow_netlink.h"
60
#include "vport-internal_dev.h"
61
#include "vport-netdev.h"
62

63 64
int ovs_net_id __read_mostly;

65 66 67 68 69 70 71 72 73
/* Check if need to build a reply message.
 * OVS userspace sets the NLM_F_ECHO flag if it needs the reply. */
static bool ovs_must_notify(struct genl_info *info,
			    const struct genl_multicast_group *grp)
{
	return info->nlhdr->nlmsg_flags & NLM_F_ECHO ||
		netlink_has_listeners(genl_info_net(info)->genl_sock, 0);
}

74
static void ovs_notify(struct genl_family *family,
75
		       struct sk_buff *skb, struct genl_info *info)
76
{
77
	genl_notify(family, skb, genl_info_net(info), info->snd_portid,
78
		    0, info->nlhdr, GFP_KERNEL);
79 80
}

81 82 83
/**
 * DOC: Locking:
 *
84 85 86 87
 * All writes e.g. Writes to device state (add/remove datapath, port, set
 * operations on vports, etc.), Writes to other state (flow table
 * modifications, set miscellaneous datapath parameters, etc.) are protected
 * by ovs_lock.
88 89 90 91 92 93
 *
 * Reads are protected by RCU.
 *
 * There are a few special cases (mostly stats) that have their own
 * synchronization but they nest under all of above and don't interact with
 * each other.
94 95
 *
 * The RTNL lock nests inside ovs_mutex.
96 97
 */

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
static DEFINE_MUTEX(ovs_mutex);

void ovs_lock(void)
{
	mutex_lock(&ovs_mutex);
}

void ovs_unlock(void)
{
	mutex_unlock(&ovs_mutex);
}

#ifdef CONFIG_LOCKDEP
int lockdep_ovsl_is_held(void)
{
	if (debug_locks)
		return lockdep_is_held(&ovs_mutex);
	else
		return 1;
}
#endif

120
static struct vport *new_vport(const struct vport_parms *);
121
static int queue_gso_packets(struct datapath *dp, struct sk_buff *,
122
			     const struct dp_upcall_info *);
123
static int queue_userspace_packet(struct datapath *dp, struct sk_buff *,
124 125
				  const struct dp_upcall_info *);

126
/* Must be called with rcu_read_lock or ovs_mutex. */
127
static struct datapath *get_dp(struct net *net, int dp_ifindex)
128 129 130 131 132
{
	struct datapath *dp = NULL;
	struct net_device *dev;

	rcu_read_lock();
133
	dev = dev_get_by_index_rcu(net, dp_ifindex);
134 135 136 137 138 139 140 141 142 143
	if (dev) {
		struct vport *vport = ovs_internal_dev_get_vport(dev);
		if (vport)
			dp = vport->dp;
	}
	rcu_read_unlock();

	return dp;
}

144
/* Must be called with rcu_read_lock or ovs_mutex. */
S
Stephen Hemminger 已提交
145
static const char *ovs_dp_name(const struct datapath *dp)
146
{
147
	struct vport *vport = ovs_vport_ovsl_rcu(dp, OVSP_LOCAL);
148 149 150 151 152 153 154 155 156 157
	return vport->ops->get_name(vport);
}

static int get_dpifindex(struct datapath *dp)
{
	struct vport *local;
	int ifindex;

	rcu_read_lock();

158
	local = ovs_vport_rcu(dp, OVSP_LOCAL);
159
	if (local)
160
		ifindex = netdev_vport_priv(local)->dev->ifindex;
161 162 163 164 165 166 167 168 169 170 171 172 173
	else
		ifindex = 0;

	rcu_read_unlock();

	return ifindex;
}

static void destroy_dp_rcu(struct rcu_head *rcu)
{
	struct datapath *dp = container_of(rcu, struct datapath, rcu);

	free_percpu(dp->stats_percpu);
174
	release_net(ovs_dp_get_net(dp));
175
	kfree(dp->ports);
176 177 178
	kfree(dp);
}

179 180 181 182 183 184
static struct hlist_head *vport_hash_bucket(const struct datapath *dp,
					    u16 port_no)
{
	return &dp->ports[port_no & (DP_VPORT_HASH_BUCKETS - 1)];
}

J
Jarno Rajahalme 已提交
185
/* Called with ovs_mutex or RCU read lock. */
186 187 188 189 190 191
struct vport *ovs_lookup_vport(const struct datapath *dp, u16 port_no)
{
	struct vport *vport;
	struct hlist_head *head;

	head = vport_hash_bucket(dp, port_no);
192
	hlist_for_each_entry_rcu(vport, head, dp_hash_node) {
193 194 195 196 197 198
		if (vport->port_no == port_no)
			return vport;
	}
	return NULL;
}

199
/* Called with ovs_mutex. */
200 201 202 203 204 205 206
static struct vport *new_vport(const struct vport_parms *parms)
{
	struct vport *vport;

	vport = ovs_vport_add(parms);
	if (!IS_ERR(vport)) {
		struct datapath *dp = parms->dp;
207
		struct hlist_head *head = vport_hash_bucket(dp, vport->port_no);
208

209
		hlist_add_head_rcu(&vport->dp_hash_node, head);
210 211 212 213 214 215
	}
	return vport;
}

void ovs_dp_detach_port(struct vport *p)
{
216
	ASSERT_OVSL();
217 218

	/* First drop references to device. */
219
	hlist_del_rcu(&p->dp_hash_node);
220 221 222 223 224 225 226 227 228 229 230 231 232

	/* Then destroy it. */
	ovs_vport_del(p);
}

/* Must be called with rcu_read_lock. */
void ovs_dp_process_received_packet(struct vport *p, struct sk_buff *skb)
{
	struct datapath *dp = p->dp;
	struct sw_flow *flow;
	struct dp_stats_percpu *stats;
	struct sw_flow_key key;
	u64 *stats_counter;
233
	u32 n_mask_hit;
234 235
	int error;

236
	stats = this_cpu_ptr(dp->stats_percpu);
237 238

	/* Extract flow from 'skb' into 'key'. */
239
	error = ovs_flow_extract(skb, p->port_no, &key);
240 241 242 243 244 245
	if (unlikely(error)) {
		kfree_skb(skb);
		return;
	}

	/* Look up flow. */
246
	flow = ovs_flow_tbl_lookup_stats(&dp->table, &key, &n_mask_hit);
247 248 249 250 251 252
	if (unlikely(!flow)) {
		struct dp_upcall_info upcall;

		upcall.cmd = OVS_PACKET_CMD_MISS;
		upcall.key = &key;
		upcall.userdata = NULL;
253
		upcall.portid = p->upcall_portid;
254 255 256 257 258 259 260
		ovs_dp_upcall(dp, skb, &upcall);
		consume_skb(skb);
		stats_counter = &stats->n_missed;
		goto out;
	}

	OVS_CB(skb)->flow = flow;
261
	OVS_CB(skb)->pkt_key = &key;
262

263
	ovs_flow_stats_update(OVS_CB(skb)->flow, skb);
264
	ovs_execute_actions(dp, skb);
265
	stats_counter = &stats->n_hit;
266 267 268

out:
	/* Update datapath statistics. */
269
	u64_stats_update_begin(&stats->syncp);
270
	(*stats_counter)++;
271
	stats->n_mask_hit += n_mask_hit;
272
	u64_stats_update_end(&stats->syncp);
273 274 275 276 277 278 279
}

static struct genl_family dp_packet_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = sizeof(struct ovs_header),
	.name = OVS_PACKET_FAMILY,
	.version = OVS_PACKET_VERSION,
280
	.maxattr = OVS_PACKET_ATTR_MAX,
281 282
	.netnsok = true,
	.parallel_ops = true,
283 284 285
};

int ovs_dp_upcall(struct datapath *dp, struct sk_buff *skb,
286
		  const struct dp_upcall_info *upcall_info)
287 288 289 290
{
	struct dp_stats_percpu *stats;
	int err;

291
	if (upcall_info->portid == 0) {
292 293 294 295 296
		err = -ENOTCONN;
		goto err;
	}

	if (!skb_is_gso(skb))
297
		err = queue_userspace_packet(dp, skb, upcall_info);
298
	else
299
		err = queue_gso_packets(dp, skb, upcall_info);
300 301 302 303 304 305
	if (err)
		goto err;

	return 0;

err:
306
	stats = this_cpu_ptr(dp->stats_percpu);
307

308
	u64_stats_update_begin(&stats->syncp);
309
	stats->n_lost++;
310
	u64_stats_update_end(&stats->syncp);
311 312 313 314

	return err;
}

315
static int queue_gso_packets(struct datapath *dp, struct sk_buff *skb,
316 317
			     const struct dp_upcall_info *upcall_info)
{
318
	unsigned short gso_type = skb_shinfo(skb)->gso_type;
319 320 321 322 323
	struct dp_upcall_info later_info;
	struct sw_flow_key later_key;
	struct sk_buff *segs, *nskb;
	int err;

324
	segs = __skb_gso_segment(skb, NETIF_F_SG, false);
325 326
	if (IS_ERR(segs))
		return PTR_ERR(segs);
327 328 329 330

	/* Queue all of the segments. */
	skb = segs;
	do {
331
		err = queue_userspace_packet(dp, skb, upcall_info);
332 333 334
		if (err)
			break;

335
		if (skb == segs && gso_type & SKB_GSO_UDP) {
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
			/* The initial flow key extracted by ovs_flow_extract()
			 * in this case is for a first fragment, so we need to
			 * properly mark later fragments.
			 */
			later_key = *upcall_info->key;
			later_key.ip.frag = OVS_FRAG_TYPE_LATER;

			later_info = *upcall_info;
			later_info.key = &later_key;
			upcall_info = &later_info;
		}
	} while ((skb = skb->next));

	/* Free all of the segments. */
	skb = segs;
	do {
		nskb = skb->next;
		if (err)
			kfree_skb(skb);
		else
			consume_skb(skb);
	} while ((skb = nskb));
	return err;
}

361 362 363
static size_t key_attr_size(void)
{
	return    nla_total_size(4)   /* OVS_KEY_ATTR_PRIORITY */
364 365 366 367 368 369 370 371
		+ nla_total_size(0)   /* OVS_KEY_ATTR_TUNNEL */
		  + nla_total_size(8)   /* OVS_TUNNEL_KEY_ATTR_ID */
		  + nla_total_size(4)   /* OVS_TUNNEL_KEY_ATTR_IPV4_SRC */
		  + nla_total_size(4)   /* OVS_TUNNEL_KEY_ATTR_IPV4_DST */
		  + nla_total_size(1)   /* OVS_TUNNEL_KEY_ATTR_TOS */
		  + nla_total_size(1)   /* OVS_TUNNEL_KEY_ATTR_TTL */
		  + nla_total_size(0)   /* OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT */
		  + nla_total_size(0)   /* OVS_TUNNEL_KEY_ATTR_CSUM */
372 373 374 375 376 377 378 379 380 381 382 383
		+ nla_total_size(4)   /* OVS_KEY_ATTR_IN_PORT */
		+ nla_total_size(4)   /* OVS_KEY_ATTR_SKB_MARK */
		+ nla_total_size(12)  /* OVS_KEY_ATTR_ETHERNET */
		+ nla_total_size(2)   /* OVS_KEY_ATTR_ETHERTYPE */
		+ nla_total_size(4)   /* OVS_KEY_ATTR_8021Q */
		+ nla_total_size(0)   /* OVS_KEY_ATTR_ENCAP */
		+ nla_total_size(2)   /* OVS_KEY_ATTR_ETHERTYPE */
		+ nla_total_size(40)  /* OVS_KEY_ATTR_IPV6 */
		+ nla_total_size(2)   /* OVS_KEY_ATTR_ICMPV6 */
		+ nla_total_size(28); /* OVS_KEY_ATTR_ND */
}

384 385
static size_t upcall_msg_size(const struct nlattr *userdata,
			      unsigned int hdrlen)
386 387
{
	size_t size = NLMSG_ALIGN(sizeof(struct ovs_header))
388
		+ nla_total_size(hdrlen) /* OVS_PACKET_ATTR_PACKET */
389 390 391 392 393 394 395 396 397
		+ nla_total_size(key_attr_size()); /* OVS_PACKET_ATTR_KEY */

	/* OVS_PACKET_ATTR_USERDATA */
	if (userdata)
		size += NLA_ALIGN(userdata->nla_len);

	return size;
}

398
static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb,
399 400 401 402 403 404
				  const struct dp_upcall_info *upcall_info)
{
	struct ovs_header *upcall;
	struct sk_buff *nskb = NULL;
	struct sk_buff *user_skb; /* to be queued to userspace */
	struct nlattr *nla;
405
	struct genl_info info = {
406
		.dst_sk = ovs_dp_get_net(dp)->genl_sock,
407 408 409
		.snd_portid = upcall_info->portid,
	};
	size_t len;
410
	unsigned int hlen;
411 412 413 414 415
	int err, dp_ifindex;

	dp_ifindex = get_dpifindex(dp);
	if (!dp_ifindex)
		return -ENODEV;
416 417 418 419 420 421

	if (vlan_tx_tag_present(skb)) {
		nskb = skb_clone(skb, GFP_ATOMIC);
		if (!nskb)
			return -ENOMEM;

422
		nskb = __vlan_put_tag(nskb, nskb->vlan_proto, vlan_tx_tag_get(nskb));
423
		if (!nskb)
424 425 426 427 428 429 430 431 432 433 434
			return -ENOMEM;

		nskb->vlan_tci = 0;
		skb = nskb;
	}

	if (nla_attr_size(skb->len) > USHRT_MAX) {
		err = -EFBIG;
		goto out;
	}

435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
	/* Complete checksum if needed */
	if (skb->ip_summed == CHECKSUM_PARTIAL &&
	    (err = skb_checksum_help(skb)))
		goto out;

	/* Older versions of OVS user space enforce alignment of the last
	 * Netlink attribute to NLA_ALIGNTO which would require extensive
	 * padding logic. Only perform zerocopy if padding is not required.
	 */
	if (dp->user_features & OVS_DP_F_UNALIGNED)
		hlen = skb_zerocopy_headlen(skb);
	else
		hlen = skb->len;

	len = upcall_msg_size(upcall_info->userdata, hlen);
450
	user_skb = genlmsg_new_unicast(len, &info, GFP_ATOMIC);
451 452 453 454 455 456 457 458 459 460
	if (!user_skb) {
		err = -ENOMEM;
		goto out;
	}

	upcall = genlmsg_put(user_skb, 0, 0, &dp_packet_genl_family,
			     0, upcall_info->cmd);
	upcall->dp_ifindex = dp_ifindex;

	nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_KEY);
461
	ovs_nla_put_flow(upcall_info->key, upcall_info->key, user_skb);
462 463 464
	nla_nest_end(user_skb, nla);

	if (upcall_info->userdata)
465 466 467
		__nla_put(user_skb, OVS_PACKET_ATTR_USERDATA,
			  nla_len(upcall_info->userdata),
			  nla_data(upcall_info->userdata));
468

469 470 471 472 473 474 475
	/* Only reserve room for attribute header, packet data is added
	 * in skb_zerocopy() */
	if (!(nla = nla_reserve(user_skb, OVS_PACKET_ATTR_PACKET, 0))) {
		err = -ENOBUFS;
		goto out;
	}
	nla->nla_len = nla_attr_size(skb->len);
476

477 478 479
	err = skb_zerocopy(user_skb, skb, skb->len, hlen);
	if (err)
		goto out;
480

481 482 483 484 485 486 487 488
	/* Pad OVS_PACKET_ATTR_PACKET if linear copy was performed */
	if (!(dp->user_features & OVS_DP_F_UNALIGNED)) {
		size_t plen = NLA_ALIGN(user_skb->len) - user_skb->len;

		if (plen > 0)
			memset(skb_put(user_skb, plen), 0, plen);
	}

489
	((struct nlmsghdr *) user_skb->data)->nlmsg_len = user_skb->len;
490

491
	err = genlmsg_unicast(ovs_dp_get_net(dp), user_skb, upcall_info->portid);
492
out:
493 494
	if (err)
		skb_tx_error(skb);
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
	kfree_skb(nskb);
	return err;
}

static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
{
	struct ovs_header *ovs_header = info->userhdr;
	struct nlattr **a = info->attrs;
	struct sw_flow_actions *acts;
	struct sk_buff *packet;
	struct sw_flow *flow;
	struct datapath *dp;
	struct ethhdr *eth;
	int len;
	int err;

	err = -EINVAL;
	if (!a[OVS_PACKET_ATTR_PACKET] || !a[OVS_PACKET_ATTR_KEY] ||
513
	    !a[OVS_PACKET_ATTR_ACTIONS])
514 515 516 517 518 519 520 521 522
		goto err;

	len = nla_len(a[OVS_PACKET_ATTR_PACKET]);
	packet = __dev_alloc_skb(NET_IP_ALIGN + len, GFP_KERNEL);
	err = -ENOMEM;
	if (!packet)
		goto err;
	skb_reserve(packet, NET_IP_ALIGN);

523
	nla_memcpy(__skb_put(packet, len), a[OVS_PACKET_ATTR_PACKET], len);
524 525 526 527 528 529 530

	skb_reset_mac_header(packet);
	eth = eth_hdr(packet);

	/* Normally, setting the skb 'protocol' field would be handled by a
	 * call to eth_type_trans(), but it assumes there's a sending
	 * device, which we may not have. */
S
Simon Horman 已提交
531
	if (ntohs(eth->h_proto) >= ETH_P_802_3_MIN)
532 533 534 535 536
		packet->protocol = eth->h_proto;
	else
		packet->protocol = htons(ETH_P_802_2);

	/* Build an sw_flow for sending this packet. */
537
	flow = ovs_flow_alloc();
538 539 540 541
	err = PTR_ERR(flow);
	if (IS_ERR(flow))
		goto err_kfree_skb;

542
	err = ovs_flow_extract(packet, -1, &flow->key);
543 544 545
	if (err)
		goto err_flow_free;

546
	err = ovs_nla_get_flow_metadata(flow, a[OVS_PACKET_ATTR_KEY]);
547 548
	if (err)
		goto err_flow_free;
549
	acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_PACKET_ATTR_ACTIONS]));
550 551 552
	err = PTR_ERR(acts);
	if (IS_ERR(acts))
		goto err_flow_free;
553

554 555
	err = ovs_nla_copy_actions(a[OVS_PACKET_ATTR_ACTIONS],
				   &flow->key, 0, &acts);
556
	rcu_assign_pointer(flow->sf_acts, acts);
557 558
	if (err)
		goto err_flow_free;
559 560

	OVS_CB(packet)->flow = flow;
561
	OVS_CB(packet)->pkt_key = &flow->key;
562
	packet->priority = flow->key.phy.priority;
563
	packet->mark = flow->key.phy.skb_mark;
564 565

	rcu_read_lock();
566
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
567 568 569 570 571 572 573 574 575
	err = -ENODEV;
	if (!dp)
		goto err_unlock;

	local_bh_disable();
	err = ovs_execute_actions(dp, packet);
	local_bh_enable();
	rcu_read_unlock();

576
	ovs_flow_free(flow, false);
577 578 579 580 581
	return err;

err_unlock:
	rcu_read_unlock();
err_flow_free:
582
	ovs_flow_free(flow, false);
583 584 585 586 587 588 589
err_kfree_skb:
	kfree_skb(packet);
err:
	return err;
}

static const struct nla_policy packet_policy[OVS_PACKET_ATTR_MAX + 1] = {
590
	[OVS_PACKET_ATTR_PACKET] = { .len = ETH_HLEN },
591 592 593 594
	[OVS_PACKET_ATTR_KEY] = { .type = NLA_NESTED },
	[OVS_PACKET_ATTR_ACTIONS] = { .type = NLA_NESTED },
};

595
static const struct genl_ops dp_packet_genl_ops[] = {
596 597 598 599 600 601 602
	{ .cmd = OVS_PACKET_CMD_EXECUTE,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = packet_policy,
	  .doit = ovs_packet_cmd_execute
	}
};

603 604
static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats,
			 struct ovs_dp_megaflow_stats *mega_stats)
605 606 607
{
	int i;

608 609
	memset(mega_stats, 0, sizeof(*mega_stats));

610
	stats->n_flows = ovs_flow_tbl_count(&dp->table);
611
	mega_stats->n_masks = ovs_flow_tbl_num_masks(&dp->table);
612 613

	stats->n_hit = stats->n_missed = stats->n_lost = 0;
614

615 616 617 618 619 620 621 622
	for_each_possible_cpu(i) {
		const struct dp_stats_percpu *percpu_stats;
		struct dp_stats_percpu local_stats;
		unsigned int start;

		percpu_stats = per_cpu_ptr(dp->stats_percpu, i);

		do {
623
			start = u64_stats_fetch_begin_irq(&percpu_stats->syncp);
624
			local_stats = *percpu_stats;
625
		} while (u64_stats_fetch_retry_irq(&percpu_stats->syncp, start));
626 627 628 629

		stats->n_hit += local_stats.n_hit;
		stats->n_missed += local_stats.n_missed;
		stats->n_lost += local_stats.n_lost;
630
		mega_stats->n_mask_hit += local_stats.n_mask_hit;
631 632 633 634 635 636 637 638 639 640 641 642 643 644
	}
}

static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = {
	[OVS_FLOW_ATTR_KEY] = { .type = NLA_NESTED },
	[OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED },
	[OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG },
};

static struct genl_family dp_flow_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = sizeof(struct ovs_header),
	.name = OVS_FLOW_FAMILY,
	.version = OVS_FLOW_VERSION,
645
	.maxattr = OVS_FLOW_ATTR_MAX,
646 647
	.netnsok = true,
	.parallel_ops = true,
648 649 650 651 652 653
};

static struct genl_multicast_group ovs_dp_flow_multicast_group = {
	.name = OVS_FLOW_MCGROUP
};

654 655 656 657
static size_t ovs_flow_cmd_msg_size(const struct sw_flow_actions *acts)
{
	return NLMSG_ALIGN(sizeof(struct ovs_header))
		+ nla_total_size(key_attr_size()) /* OVS_FLOW_ATTR_KEY */
658
		+ nla_total_size(key_attr_size()) /* OVS_FLOW_ATTR_MASK */
659 660 661 662 663 664
		+ nla_total_size(sizeof(struct ovs_flow_stats)) /* OVS_FLOW_ATTR_STATS */
		+ nla_total_size(1) /* OVS_FLOW_ATTR_TCP_FLAGS */
		+ nla_total_size(8) /* OVS_FLOW_ATTR_USED */
		+ nla_total_size(acts->actions_len); /* OVS_FLOW_ATTR_ACTIONS */
}

J
Jarno Rajahalme 已提交
665
/* Called with ovs_mutex or RCU read lock. */
666
static int ovs_flow_cmd_fill_info(const struct sw_flow *flow, int dp_ifindex,
667
				  struct sk_buff *skb, u32 portid,
668 669 670
				  u32 seq, u32 flags, u8 cmd)
{
	const int skb_orig_len = skb->len;
671
	struct nlattr *start;
672
	struct ovs_flow_stats stats;
673 674
	__be16 tcp_flags;
	unsigned long used;
675 676 677 678
	struct ovs_header *ovs_header;
	struct nlattr *nla;
	int err;

679
	ovs_header = genlmsg_put(skb, portid, seq, &dp_flow_genl_family, flags, cmd);
680 681 682
	if (!ovs_header)
		return -EMSGSIZE;

683
	ovs_header->dp_ifindex = dp_ifindex;
684

685
	/* Fill flow key. */
686 687 688
	nla = nla_nest_start(skb, OVS_FLOW_ATTR_KEY);
	if (!nla)
		goto nla_put_failure;
689

690
	err = ovs_nla_put_flow(&flow->unmasked_key, &flow->unmasked_key, skb);
691 692 693 694 695 696 697 698
	if (err)
		goto error;
	nla_nest_end(skb, nla);

	nla = nla_nest_start(skb, OVS_FLOW_ATTR_MASK);
	if (!nla)
		goto nla_put_failure;

699
	err = ovs_nla_put_flow(&flow->key, &flow->mask->key, skb);
700 701
	if (err)
		goto error;
702

703 704
	nla_nest_end(skb, nla);

705
	ovs_flow_stats_get(flow, &stats, &used, &tcp_flags);
706

707 708 709
	if (used &&
	    nla_put_u64(skb, OVS_FLOW_ATTR_USED, ovs_flow_used_time(used)))
		goto nla_put_failure;
710

711
	if (stats.n_packets &&
712
	    nla_put(skb, OVS_FLOW_ATTR_STATS, sizeof(struct ovs_flow_stats), &stats))
713
		goto nla_put_failure;
714

715 716
	if ((u8)ntohs(tcp_flags) &&
	     nla_put_u8(skb, OVS_FLOW_ATTR_TCP_FLAGS, (u8)ntohs(tcp_flags)))
717
		goto nla_put_failure;
718 719 720 721 722 723 724 725 726 727 728

	/* If OVS_FLOW_ATTR_ACTIONS doesn't fit, skip dumping the actions if
	 * this is the first flow to be dumped into 'skb'.  This is unusual for
	 * Netlink but individual action lists can be longer than
	 * NLMSG_GOODSIZE and thus entirely undumpable if we didn't do this.
	 * The userspace caller can always fetch the actions separately if it
	 * really wants them.  (Most userspace callers in fact don't care.)
	 *
	 * This can only fail for dump operations because the skb is always
	 * properly sized for single flows.
	 */
729 730
	start = nla_nest_start(skb, OVS_FLOW_ATTR_ACTIONS);
	if (start) {
731 732
		const struct sw_flow_actions *sf_acts;

733
		sf_acts = rcu_dereference_ovsl(flow->sf_acts);
734 735
		err = ovs_nla_put_actions(sf_acts->actions,
					  sf_acts->actions_len, skb);
736

737 738 739 740 741 742 743 744 745 746
		if (!err)
			nla_nest_end(skb, start);
		else {
			if (skb_orig_len)
				goto error;

			nla_nest_cancel(skb, start);
		}
	} else if (skb_orig_len)
		goto nla_put_failure;
747 748 749 750 751 752 753 754 755 756

	return genlmsg_end(skb, ovs_header);

nla_put_failure:
	err = -EMSGSIZE;
error:
	genlmsg_cancel(skb, ovs_header);
	return err;
}

757 758
/* May not be called with RCU read lock. */
static struct sk_buff *ovs_flow_cmd_alloc_info(const struct sw_flow_actions *acts,
759 760
					       struct genl_info *info,
					       bool always)
761
{
762
	struct sk_buff *skb;
763

764 765 766
	if (!always && !ovs_must_notify(info, &ovs_dp_flow_multicast_group))
		return NULL;

767
	skb = genlmsg_new_unicast(ovs_flow_cmd_msg_size(acts), info, GFP_KERNEL);
768 769 770 771
	if (!skb)
		return ERR_PTR(-ENOMEM);

	return skb;
772 773
}

774 775 776 777 778
/* Called with ovs_mutex. */
static struct sk_buff *ovs_flow_cmd_build_info(const struct sw_flow *flow,
					       int dp_ifindex,
					       struct genl_info *info, u8 cmd,
					       bool always)
779 780 781 782
{
	struct sk_buff *skb;
	int retval;

783 784
	skb = ovs_flow_cmd_alloc_info(ovsl_dereference(flow->sf_acts), info,
				      always);
785 786
	if (!skb || IS_ERR(skb))
		return skb;
787

788 789 790
	retval = ovs_flow_cmd_fill_info(flow, dp_ifindex, skb,
					info->snd_portid, info->snd_seq, 0,
					cmd);
791 792 793 794
	BUG_ON(retval < 0);
	return skb;
}

795
static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info)
796 797 798
{
	struct nlattr **a = info->attrs;
	struct ovs_header *ovs_header = info->userhdr;
799
	struct sw_flow *flow, *new_flow;
800
	struct sw_flow_mask mask;
801 802
	struct sk_buff *reply;
	struct datapath *dp;
803
	struct sw_flow_actions *acts;
804
	struct sw_flow_match match;
805 806
	int error;

807
	/* Must have key and actions. */
808 809 810
	error = -EINVAL;
	if (!a[OVS_FLOW_ATTR_KEY])
		goto error;
811 812
	if (!a[OVS_FLOW_ATTR_ACTIONS])
		goto error;
813

814 815 816 817 818 819 820 821 822 823 824
	/* Most of the time we need to allocate a new flow, do it before
	 * locking.
	 */
	new_flow = ovs_flow_alloc();
	if (IS_ERR(new_flow)) {
		error = PTR_ERR(new_flow);
		goto error;
	}

	/* Extract key. */
	ovs_match_init(&match, &new_flow->unmasked_key, &mask);
825
	error = ovs_nla_get_match(&match,
826
				  a[OVS_FLOW_ATTR_KEY], a[OVS_FLOW_ATTR_MASK]);
827
	if (error)
828
		goto err_kfree_flow;
829

830
	ovs_flow_mask_key(&new_flow->key, &new_flow->unmasked_key, &mask);
831

832
	/* Validate actions. */
833 834 835
	acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_FLOW_ATTR_ACTIONS]));
	error = PTR_ERR(acts);
	if (IS_ERR(acts))
836
		goto err_kfree_flow;
837

838 839
	error = ovs_nla_copy_actions(a[OVS_FLOW_ATTR_ACTIONS], &new_flow->key,
				     0, &acts);
840 841
	if (error) {
		OVS_NLERR("Flow actions may not be safe on all matching packets.\n");
842 843 844 845 846 847 848
		goto err_kfree_acts;
	}

	reply = ovs_flow_cmd_alloc_info(acts, info, false);
	if (IS_ERR(reply)) {
		error = PTR_ERR(reply);
		goto err_kfree_acts;
849 850
	}

851
	ovs_lock();
852
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
853 854
	if (unlikely(!dp)) {
		error = -ENODEV;
855
		goto err_unlock_ovs;
856
	}
857
	/* Check if this is a duplicate flow */
858 859 860
	flow = ovs_flow_tbl_lookup(&dp->table, &new_flow->unmasked_key);
	if (likely(!flow)) {
		rcu_assign_pointer(new_flow->sf_acts, acts);
861 862

		/* Put flow in bucket. */
863 864
		error = ovs_flow_tbl_insert(&dp->table, new_flow, &mask);
		if (unlikely(error)) {
865
			acts = NULL;
866 867 868 869 870 871 872 873 874 875
			goto err_unlock_ovs;
		}

		if (unlikely(reply)) {
			error = ovs_flow_cmd_fill_info(new_flow,
						       ovs_header->dp_ifindex,
						       reply, info->snd_portid,
						       info->snd_seq, 0,
						       OVS_FLOW_CMD_NEW);
			BUG_ON(error < 0);
876
		}
877
		ovs_unlock();
878
	} else {
879 880
		struct sw_flow_actions *old_acts;

881 882 883 884 885 886
		/* Bail out if we're not allowed to modify an existing flow.
		 * We accept NLM_F_CREATE in place of the intended NLM_F_EXCL
		 * because Generic Netlink treats the latter as a dump
		 * request.  We also accept NLM_F_EXCL in case that bug ever
		 * gets fixed.
		 */
887 888 889
		if (unlikely(info->nlhdr->nlmsg_flags & (NLM_F_CREATE
							 | NLM_F_EXCL))) {
			error = -EEXIST;
890
			goto err_unlock_ovs;
891
		}
892
		/* The unmasked key has to be the same for flow updates. */
893 894
		if (unlikely(!ovs_flow_cmp_unmasked_key(flow, &match))) {
			error = -EEXIST;
895
			goto err_unlock_ovs;
896
		}
897 898 899 900
		/* Update actions. */
		old_acts = ovsl_dereference(flow->sf_acts);
		rcu_assign_pointer(flow->sf_acts, acts);

901 902 903 904 905 906 907 908 909
		if (unlikely(reply)) {
			error = ovs_flow_cmd_fill_info(flow,
						       ovs_header->dp_ifindex,
						       reply, info->snd_portid,
						       info->snd_seq, 0,
						       OVS_FLOW_CMD_NEW);
			BUG_ON(error < 0);
		}
		ovs_unlock();
910

911 912
		ovs_nla_free_flow_actions(old_acts);
		ovs_flow_free(new_flow, false);
913
	}
914 915 916

	if (reply)
		ovs_notify(&dp_flow_genl_family, reply, info);
917 918 919 920
	return 0;

err_unlock_ovs:
	ovs_unlock();
921 922
	kfree_skb(reply);
err_kfree_acts:
923
	kfree(acts);
924 925
err_kfree_flow:
	ovs_flow_free(new_flow, false);
926 927 928
error:
	return error;
}
929

930 931 932 933 934 935 936 937 938
static int ovs_flow_cmd_set(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct ovs_header *ovs_header = info->userhdr;
	struct sw_flow_key key, masked_key;
	struct sw_flow *flow;
	struct sw_flow_mask mask;
	struct sk_buff *reply = NULL;
	struct datapath *dp;
939
	struct sw_flow_actions *old_acts = NULL, *acts = NULL;
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
	struct sw_flow_match match;
	int error;

	/* Extract key. */
	error = -EINVAL;
	if (!a[OVS_FLOW_ATTR_KEY])
		goto error;

	ovs_match_init(&match, &key, &mask);
	error = ovs_nla_get_match(&match,
				  a[OVS_FLOW_ATTR_KEY], a[OVS_FLOW_ATTR_MASK]);
	if (error)
		goto error;

	/* Validate actions. */
	if (a[OVS_FLOW_ATTR_ACTIONS]) {
		acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_FLOW_ATTR_ACTIONS]));
		error = PTR_ERR(acts);
		if (IS_ERR(acts))
			goto error;

		ovs_flow_mask_key(&masked_key, &key, &mask);
		error = ovs_nla_copy_actions(a[OVS_FLOW_ATTR_ACTIONS],
					     &masked_key, 0, &acts);
		if (error) {
			OVS_NLERR("Flow actions may not be safe on all matching packets.\n");
966 967 968 969 970 971 972 973 974 975
			goto err_kfree_acts;
		}
	}

	/* Can allocate before locking if have acts. */
	if (acts) {
		reply = ovs_flow_cmd_alloc_info(acts, info, false);
		if (IS_ERR(reply)) {
			error = PTR_ERR(reply);
			goto err_kfree_acts;
976
		}
977
	}
978

979 980
	ovs_lock();
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
981 982
	if (unlikely(!dp)) {
		error = -ENODEV;
983
		goto err_unlock_ovs;
984
	}
985 986
	/* Check that the flow exists. */
	flow = ovs_flow_tbl_lookup(&dp->table, &key);
987 988
	if (unlikely(!flow)) {
		error = -ENOENT;
989
		goto err_unlock_ovs;
990
	}
991
	/* The unmasked key has to be the same for flow updates. */
992 993
	if (unlikely(!ovs_flow_cmp_unmasked_key(flow, &match))) {
		error = -EEXIST;
994
		goto err_unlock_ovs;
995
	}
996
	/* Update actions, if present. */
997
	if (likely(acts)) {
998 999
		old_acts = ovsl_dereference(flow->sf_acts);
		rcu_assign_pointer(flow->sf_acts, acts);
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016

		if (unlikely(reply)) {
			error = ovs_flow_cmd_fill_info(flow,
						       ovs_header->dp_ifindex,
						       reply, info->snd_portid,
						       info->snd_seq, 0,
						       OVS_FLOW_CMD_NEW);
			BUG_ON(error < 0);
		}
	} else {
		/* Could not alloc without acts before locking. */
		reply = ovs_flow_cmd_build_info(flow, ovs_header->dp_ifindex,
						info, OVS_FLOW_CMD_NEW, false);
		if (unlikely(IS_ERR(reply))) {
			error = PTR_ERR(reply);
			goto err_unlock_ovs;
		}
1017
	}
1018 1019 1020 1021

	/* Clear stats. */
	if (a[OVS_FLOW_ATTR_CLEAR])
		ovs_flow_stats_clear(flow);
1022
	ovs_unlock();
1023

1024 1025 1026 1027
	if (reply)
		ovs_notify(&dp_flow_genl_family, reply, info);
	if (old_acts)
		ovs_nla_free_flow_actions(old_acts);
1028

1029 1030
	return 0;

1031 1032
err_unlock_ovs:
	ovs_unlock();
1033 1034
	kfree_skb(reply);
err_kfree_acts:
1035
	kfree(acts);
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
error:
	return error;
}

static int ovs_flow_cmd_get(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct ovs_header *ovs_header = info->userhdr;
	struct sw_flow_key key;
	struct sk_buff *reply;
	struct sw_flow *flow;
	struct datapath *dp;
1048
	struct sw_flow_match match;
1049 1050
	int err;

1051 1052
	if (!a[OVS_FLOW_ATTR_KEY]) {
		OVS_NLERR("Flow get message rejected, Key attribute missing.\n");
1053
		return -EINVAL;
1054 1055 1056
	}

	ovs_match_init(&match, &key, NULL);
1057
	err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL);
1058 1059 1060
	if (err)
		return err;

1061
	ovs_lock();
1062
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
1063 1064 1065 1066
	if (!dp) {
		err = -ENODEV;
		goto unlock;
	}
1067

1068
	flow = ovs_flow_tbl_lookup(&dp->table, &key);
1069
	if (!flow || !ovs_flow_cmp_unmasked_key(flow, &match)) {
1070 1071 1072
		err = -ENOENT;
		goto unlock;
	}
1073

1074 1075
	reply = ovs_flow_cmd_build_info(flow, ovs_header->dp_ifindex, info,
					OVS_FLOW_CMD_NEW, true);
1076 1077 1078 1079
	if (IS_ERR(reply)) {
		err = PTR_ERR(reply);
		goto unlock;
	}
1080

1081
	ovs_unlock();
1082
	return genlmsg_reply(reply, info);
1083 1084 1085
unlock:
	ovs_unlock();
	return err;
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
}

static int ovs_flow_cmd_del(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct ovs_header *ovs_header = info->userhdr;
	struct sw_flow_key key;
	struct sk_buff *reply;
	struct sw_flow *flow;
	struct datapath *dp;
1096
	struct sw_flow_match match;
1097 1098
	int err;

1099 1100 1101 1102 1103 1104 1105
	if (likely(a[OVS_FLOW_ATTR_KEY])) {
		ovs_match_init(&match, &key, NULL);
		err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL);
		if (unlikely(err))
			return err;
	}

1106
	ovs_lock();
1107
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
1108
	if (unlikely(!dp)) {
1109 1110 1111
		err = -ENODEV;
		goto unlock;
	}
1112

1113
	if (unlikely(!a[OVS_FLOW_ATTR_KEY])) {
1114
		err = ovs_flow_tbl_flush(&dp->table);
1115 1116
		goto unlock;
	}
1117

1118
	flow = ovs_flow_tbl_lookup(&dp->table, &key);
1119
	if (unlikely(!flow || !ovs_flow_cmp_unmasked_key(flow, &match))) {
1120 1121 1122
		err = -ENOENT;
		goto unlock;
	}
1123

1124
	ovs_flow_tbl_remove(&dp->table, flow);
1125
	ovs_unlock();
1126

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
	reply = ovs_flow_cmd_alloc_info((const struct sw_flow_actions __force *) flow->sf_acts,
					info, false);
	if (likely(reply)) {
		if (likely(!IS_ERR(reply))) {
			rcu_read_lock();	/*To keep RCU checker happy. */
			err = ovs_flow_cmd_fill_info(flow, ovs_header->dp_ifindex,
						     reply, info->snd_portid,
						     info->snd_seq, 0,
						     OVS_FLOW_CMD_DEL);
			rcu_read_unlock();
			BUG_ON(err < 0);

			ovs_notify(&dp_flow_genl_family, reply, info);
		} else {
			netlink_set_err(sock_net(skb->sk)->genl_sock, 0, 0, PTR_ERR(reply));
		}
1143
	}
1144

1145
	ovs_flow_free(flow, true);
1146
	return 0;
1147 1148 1149
unlock:
	ovs_unlock();
	return err;
1150 1151 1152 1153 1154
}

static int ovs_flow_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh));
1155
	struct table_instance *ti;
1156 1157
	struct datapath *dp;

1158
	rcu_read_lock();
1159
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
1160
	if (!dp) {
1161
		rcu_read_unlock();
1162
		return -ENODEV;
1163
	}
1164

1165
	ti = rcu_dereference(dp->table.ti);
1166 1167 1168 1169 1170 1171
	for (;;) {
		struct sw_flow *flow;
		u32 bucket, obj;

		bucket = cb->args[0];
		obj = cb->args[1];
1172
		flow = ovs_flow_tbl_dump_next(ti, &bucket, &obj);
1173 1174 1175
		if (!flow)
			break;

1176
		if (ovs_flow_cmd_fill_info(flow, ovs_header->dp_ifindex, skb,
1177
					   NETLINK_CB(cb->skb).portid,
1178 1179 1180 1181 1182 1183 1184
					   cb->nlh->nlmsg_seq, NLM_F_MULTI,
					   OVS_FLOW_CMD_NEW) < 0)
			break;

		cb->args[0] = bucket;
		cb->args[1] = obj;
	}
1185
	rcu_read_unlock();
1186 1187 1188
	return skb->len;
}

1189
static const struct genl_ops dp_flow_genl_ops[] = {
1190 1191 1192
	{ .cmd = OVS_FLOW_CMD_NEW,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = flow_policy,
1193
	  .doit = ovs_flow_cmd_new
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
	},
	{ .cmd = OVS_FLOW_CMD_DEL,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = flow_policy,
	  .doit = ovs_flow_cmd_del
	},
	{ .cmd = OVS_FLOW_CMD_GET,
	  .flags = 0,		    /* OK for unprivileged users. */
	  .policy = flow_policy,
	  .doit = ovs_flow_cmd_get,
	  .dumpit = ovs_flow_cmd_dump
	},
	{ .cmd = OVS_FLOW_CMD_SET,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = flow_policy,
1209
	  .doit = ovs_flow_cmd_set,
1210 1211 1212 1213 1214 1215
	},
};

static const struct nla_policy datapath_policy[OVS_DP_ATTR_MAX + 1] = {
	[OVS_DP_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 },
	[OVS_DP_ATTR_UPCALL_PID] = { .type = NLA_U32 },
1216
	[OVS_DP_ATTR_USER_FEATURES] = { .type = NLA_U32 },
1217 1218 1219 1220 1221 1222 1223
};

static struct genl_family dp_datapath_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = sizeof(struct ovs_header),
	.name = OVS_DATAPATH_FAMILY,
	.version = OVS_DATAPATH_VERSION,
1224
	.maxattr = OVS_DP_ATTR_MAX,
1225 1226
	.netnsok = true,
	.parallel_ops = true,
1227 1228 1229 1230 1231 1232
};

static struct genl_multicast_group ovs_dp_datapath_multicast_group = {
	.name = OVS_DATAPATH_MCGROUP
};

1233 1234 1235 1236 1237 1238
static size_t ovs_dp_cmd_msg_size(void)
{
	size_t msgsize = NLMSG_ALIGN(sizeof(struct ovs_header));

	msgsize += nla_total_size(IFNAMSIZ);
	msgsize += nla_total_size(sizeof(struct ovs_dp_stats));
1239
	msgsize += nla_total_size(sizeof(struct ovs_dp_megaflow_stats));
1240
	msgsize += nla_total_size(sizeof(u32)); /* OVS_DP_ATTR_USER_FEATURES */
1241 1242 1243 1244

	return msgsize;
}

J
Jarno Rajahalme 已提交
1245
/* Called with ovs_mutex or RCU read lock. */
1246
static int ovs_dp_cmd_fill_info(struct datapath *dp, struct sk_buff *skb,
1247
				u32 portid, u32 seq, u32 flags, u8 cmd)
1248 1249 1250
{
	struct ovs_header *ovs_header;
	struct ovs_dp_stats dp_stats;
1251
	struct ovs_dp_megaflow_stats dp_megaflow_stats;
1252 1253
	int err;

1254
	ovs_header = genlmsg_put(skb, portid, seq, &dp_datapath_genl_family,
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
				   flags, cmd);
	if (!ovs_header)
		goto error;

	ovs_header->dp_ifindex = get_dpifindex(dp);

	err = nla_put_string(skb, OVS_DP_ATTR_NAME, ovs_dp_name(dp));
	if (err)
		goto nla_put_failure;

1265 1266 1267 1268 1269 1270 1271 1272
	get_dp_stats(dp, &dp_stats, &dp_megaflow_stats);
	if (nla_put(skb, OVS_DP_ATTR_STATS, sizeof(struct ovs_dp_stats),
			&dp_stats))
		goto nla_put_failure;

	if (nla_put(skb, OVS_DP_ATTR_MEGAFLOW_STATS,
			sizeof(struct ovs_dp_megaflow_stats),
			&dp_megaflow_stats))
1273
		goto nla_put_failure;
1274

1275 1276 1277
	if (nla_put_u32(skb, OVS_DP_ATTR_USER_FEATURES, dp->user_features))
		goto nla_put_failure;

1278 1279 1280 1281 1282 1283 1284 1285
	return genlmsg_end(skb, ovs_header);

nla_put_failure:
	genlmsg_cancel(skb, ovs_header);
error:
	return -EMSGSIZE;
}

1286
static struct sk_buff *ovs_dp_cmd_alloc_info(struct genl_info *info)
1287
{
1288
	return genlmsg_new_unicast(ovs_dp_cmd_msg_size(), info, GFP_KERNEL);
1289 1290
}

J
Jarno Rajahalme 已提交
1291
/* Called with rcu_read_lock or ovs_mutex. */
1292 1293
static struct datapath *lookup_datapath(struct net *net,
					struct ovs_header *ovs_header,
1294 1295 1296 1297 1298
					struct nlattr *a[OVS_DP_ATTR_MAX + 1])
{
	struct datapath *dp;

	if (!a[OVS_DP_ATTR_NAME])
1299
		dp = get_dp(net, ovs_header->dp_ifindex);
1300 1301 1302
	else {
		struct vport *vport;

1303
		vport = ovs_vport_locate(net, nla_data(a[OVS_DP_ATTR_NAME]));
1304 1305 1306 1307 1308
		dp = vport && vport->port_no == OVSP_LOCAL ? vport->dp : NULL;
	}
	return dp ? dp : ERR_PTR(-ENODEV);
}

1309 1310 1311 1312 1313
static void ovs_dp_reset_user_features(struct sk_buff *skb, struct genl_info *info)
{
	struct datapath *dp;

	dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs);
1314
	if (IS_ERR(dp))
1315 1316 1317 1318 1319 1320
		return;

	WARN(dp->user_features, "Dropping previously announced user features\n");
	dp->user_features = 0;
}

1321 1322 1323 1324 1325 1326
static void ovs_dp_change(struct datapath *dp, struct nlattr **a)
{
	if (a[OVS_DP_ATTR_USER_FEATURES])
		dp->user_features = nla_get_u32(a[OVS_DP_ATTR_USER_FEATURES]);
}

1327 1328 1329 1330 1331 1332 1333
static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct vport_parms parms;
	struct sk_buff *reply;
	struct datapath *dp;
	struct vport *vport;
1334
	struct ovs_net *ovs_net;
1335
	int err, i;
1336 1337 1338 1339 1340

	err = -EINVAL;
	if (!a[OVS_DP_ATTR_NAME] || !a[OVS_DP_ATTR_UPCALL_PID])
		goto err;

1341 1342 1343
	reply = ovs_dp_cmd_alloc_info(info);
	if (!reply)
		return -ENOMEM;
1344 1345 1346 1347

	err = -ENOMEM;
	dp = kzalloc(sizeof(*dp), GFP_KERNEL);
	if (dp == NULL)
1348
		goto err_free_reply;
1349 1350

	ovs_dp_set_net(dp, hold_net(sock_net(skb->sk)));
1351 1352

	/* Allocate table. */
1353 1354
	err = ovs_flow_tbl_init(&dp->table);
	if (err)
1355 1356
		goto err_free_dp;

1357
	dp->stats_percpu = netdev_alloc_pcpu_stats(struct dp_stats_percpu);
1358 1359 1360 1361 1362
	if (!dp->stats_percpu) {
		err = -ENOMEM;
		goto err_destroy_table;
	}

1363
	dp->ports = kmalloc(DP_VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
1364
			    GFP_KERNEL);
1365 1366 1367 1368 1369 1370 1371 1372
	if (!dp->ports) {
		err = -ENOMEM;
		goto err_destroy_percpu;
	}

	for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++)
		INIT_HLIST_HEAD(&dp->ports[i]);

1373 1374 1375 1376 1377 1378
	/* Set up our datapath device. */
	parms.name = nla_data(a[OVS_DP_ATTR_NAME]);
	parms.type = OVS_VPORT_TYPE_INTERNAL;
	parms.options = NULL;
	parms.dp = dp;
	parms.port_no = OVSP_LOCAL;
1379
	parms.upcall_portid = nla_get_u32(a[OVS_DP_ATTR_UPCALL_PID]);
1380

1381 1382
	ovs_dp_change(dp, a);

1383 1384 1385
	/* So far only local changes have been made, now need the lock. */
	ovs_lock();

1386 1387 1388 1389 1390 1391
	vport = new_vport(&parms);
	if (IS_ERR(vport)) {
		err = PTR_ERR(vport);
		if (err == -EBUSY)
			err = -EEXIST;

1392 1393 1394 1395 1396 1397 1398 1399 1400
		if (err == -EEXIST) {
			/* An outdated user space instance that does not understand
			 * the concept of user_features has attempted to create a new
			 * datapath and is likely to reuse it. Drop all user features.
			 */
			if (info->genlhdr->version < OVS_DP_VER_FEATURES)
				ovs_dp_reset_user_features(skb, info);
		}

1401
		goto err_destroy_ports_array;
1402 1403
	}

1404 1405 1406
	err = ovs_dp_cmd_fill_info(dp, reply, info->snd_portid,
				   info->snd_seq, 0, OVS_DP_CMD_NEW);
	BUG_ON(err < 0);
1407

1408
	ovs_net = net_generic(ovs_dp_get_net(dp), ovs_net_id);
1409
	list_add_tail_rcu(&dp->list_node, &ovs_net->dps);
1410 1411

	ovs_unlock();
1412

1413
	ovs_notify(&dp_datapath_genl_family, reply, info);
1414 1415
	return 0;

1416
err_destroy_ports_array:
1417
	ovs_unlock();
1418
	kfree(dp->ports);
1419 1420 1421
err_destroy_percpu:
	free_percpu(dp->stats_percpu);
err_destroy_table:
1422
	ovs_flow_tbl_destroy(&dp->table, false);
1423
err_free_dp:
1424
	release_net(ovs_dp_get_net(dp));
1425
	kfree(dp);
1426 1427
err_free_reply:
	kfree_skb(reply);
1428 1429 1430 1431
err:
	return err;
}

1432
/* Called with ovs_mutex. */
1433
static void __dp_destroy(struct datapath *dp)
1434
{
1435
	int i;
1436

1437 1438
	for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++) {
		struct vport *vport;
1439
		struct hlist_node *n;
1440

1441
		hlist_for_each_entry_safe(vport, n, &dp->ports[i], dp_hash_node)
1442 1443 1444
			if (vport->port_no != OVSP_LOCAL)
				ovs_dp_detach_port(vport);
	}
1445

1446
	list_del_rcu(&dp->list_node);
1447

1448
	/* OVSP_LOCAL is datapath internal port. We need to make sure that
1449
	 * all ports in datapath are destroyed first before freeing datapath.
1450
	 */
1451
	ovs_dp_detach_port(ovs_vport_ovsl(dp, OVSP_LOCAL));
1452

1453 1454 1455
	/* RCU destroy the flow table */
	ovs_flow_tbl_destroy(&dp->table, true);

1456
	call_rcu(&dp->rcu, destroy_dp_rcu);
1457 1458 1459 1460 1461 1462 1463 1464
}

static int ovs_dp_cmd_del(struct sk_buff *skb, struct genl_info *info)
{
	struct sk_buff *reply;
	struct datapath *dp;
	int err;

1465 1466 1467 1468
	reply = ovs_dp_cmd_alloc_info(info);
	if (!reply)
		return -ENOMEM;

1469
	ovs_lock();
1470 1471 1472
	dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs);
	err = PTR_ERR(dp);
	if (IS_ERR(dp))
1473
		goto err_unlock_free;
1474

1475 1476 1477
	err = ovs_dp_cmd_fill_info(dp, reply, info->snd_portid,
				   info->snd_seq, 0, OVS_DP_CMD_DEL);
	BUG_ON(err < 0);
1478 1479

	__dp_destroy(dp);
1480
	ovs_unlock();
1481

1482
	ovs_notify(&dp_datapath_genl_family, reply, info);
1483 1484

	return 0;
1485 1486

err_unlock_free:
1487
	ovs_unlock();
1488
	kfree_skb(reply);
1489
	return err;
1490 1491 1492 1493 1494 1495 1496 1497
}

static int ovs_dp_cmd_set(struct sk_buff *skb, struct genl_info *info)
{
	struct sk_buff *reply;
	struct datapath *dp;
	int err;

1498 1499 1500 1501
	reply = ovs_dp_cmd_alloc_info(info);
	if (!reply)
		return -ENOMEM;

1502
	ovs_lock();
1503
	dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs);
1504
	err = PTR_ERR(dp);
1505
	if (IS_ERR(dp))
1506
		goto err_unlock_free;
1507

1508 1509
	ovs_dp_change(dp, info->attrs);

1510 1511 1512
	err = ovs_dp_cmd_fill_info(dp, reply, info->snd_portid,
				   info->snd_seq, 0, OVS_DP_CMD_NEW);
	BUG_ON(err < 0);
1513

1514
	ovs_unlock();
1515
	ovs_notify(&dp_datapath_genl_family, reply, info);
1516 1517

	return 0;
1518 1519

err_unlock_free:
1520
	ovs_unlock();
1521
	kfree_skb(reply);
1522
	return err;
1523 1524 1525 1526 1527 1528
}

static int ovs_dp_cmd_get(struct sk_buff *skb, struct genl_info *info)
{
	struct sk_buff *reply;
	struct datapath *dp;
1529
	int err;
1530

1531 1532 1533 1534 1535
	reply = ovs_dp_cmd_alloc_info(info);
	if (!reply)
		return -ENOMEM;

	rcu_read_lock();
1536
	dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs);
1537 1538
	if (IS_ERR(dp)) {
		err = PTR_ERR(dp);
1539
		goto err_unlock_free;
1540
	}
1541 1542 1543 1544
	err = ovs_dp_cmd_fill_info(dp, reply, info->snd_portid,
				   info->snd_seq, 0, OVS_DP_CMD_NEW);
	BUG_ON(err < 0);
	rcu_read_unlock();
1545 1546

	return genlmsg_reply(reply, info);
1547

1548 1549 1550
err_unlock_free:
	rcu_read_unlock();
	kfree_skb(reply);
1551
	return err;
1552 1553 1554 1555
}

static int ovs_dp_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
1556
	struct ovs_net *ovs_net = net_generic(sock_net(skb->sk), ovs_net_id);
1557 1558 1559 1560
	struct datapath *dp;
	int skip = cb->args[0];
	int i = 0;

1561 1562
	rcu_read_lock();
	list_for_each_entry_rcu(dp, &ovs_net->dps, list_node) {
1563
		if (i >= skip &&
1564
		    ovs_dp_cmd_fill_info(dp, skb, NETLINK_CB(cb->skb).portid,
1565 1566 1567 1568 1569
					 cb->nlh->nlmsg_seq, NLM_F_MULTI,
					 OVS_DP_CMD_NEW) < 0)
			break;
		i++;
	}
1570
	rcu_read_unlock();
1571 1572 1573 1574 1575 1576

	cb->args[0] = i;

	return skb->len;
}

1577
static const struct genl_ops dp_datapath_genl_ops[] = {
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
	{ .cmd = OVS_DP_CMD_NEW,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = datapath_policy,
	  .doit = ovs_dp_cmd_new
	},
	{ .cmd = OVS_DP_CMD_DEL,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = datapath_policy,
	  .doit = ovs_dp_cmd_del
	},
	{ .cmd = OVS_DP_CMD_GET,
	  .flags = 0,		    /* OK for unprivileged users. */
	  .policy = datapath_policy,
	  .doit = ovs_dp_cmd_get,
	  .dumpit = ovs_dp_cmd_dump
	},
	{ .cmd = OVS_DP_CMD_SET,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = datapath_policy,
	  .doit = ovs_dp_cmd_set,
	},
};

static const struct nla_policy vport_policy[OVS_VPORT_ATTR_MAX + 1] = {
	[OVS_VPORT_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 },
	[OVS_VPORT_ATTR_STATS] = { .len = sizeof(struct ovs_vport_stats) },
	[OVS_VPORT_ATTR_PORT_NO] = { .type = NLA_U32 },
	[OVS_VPORT_ATTR_TYPE] = { .type = NLA_U32 },
	[OVS_VPORT_ATTR_UPCALL_PID] = { .type = NLA_U32 },
	[OVS_VPORT_ATTR_OPTIONS] = { .type = NLA_NESTED },
};

1610
struct genl_family dp_vport_genl_family = {
1611 1612 1613 1614
	.id = GENL_ID_GENERATE,
	.hdrsize = sizeof(struct ovs_header),
	.name = OVS_VPORT_FAMILY,
	.version = OVS_VPORT_VERSION,
1615
	.maxattr = OVS_VPORT_ATTR_MAX,
1616 1617
	.netnsok = true,
	.parallel_ops = true,
1618 1619
};

S
Stephen Hemminger 已提交
1620
static struct genl_multicast_group ovs_dp_vport_multicast_group = {
1621 1622 1623
	.name = OVS_VPORT_MCGROUP
};

1624
/* Called with ovs_mutex or RCU read lock. */
1625
static int ovs_vport_cmd_fill_info(struct vport *vport, struct sk_buff *skb,
1626
				   u32 portid, u32 seq, u32 flags, u8 cmd)
1627 1628 1629 1630 1631
{
	struct ovs_header *ovs_header;
	struct ovs_vport_stats vport_stats;
	int err;

1632
	ovs_header = genlmsg_put(skb, portid, seq, &dp_vport_genl_family,
1633 1634 1635 1636 1637 1638
				 flags, cmd);
	if (!ovs_header)
		return -EMSGSIZE;

	ovs_header->dp_ifindex = get_dpifindex(vport->dp);

1639 1640 1641
	if (nla_put_u32(skb, OVS_VPORT_ATTR_PORT_NO, vport->port_no) ||
	    nla_put_u32(skb, OVS_VPORT_ATTR_TYPE, vport->ops->type) ||
	    nla_put_string(skb, OVS_VPORT_ATTR_NAME, vport->ops->get_name(vport)) ||
1642
	    nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, vport->upcall_portid))
1643
		goto nla_put_failure;
1644 1645

	ovs_vport_get_stats(vport, &vport_stats);
1646 1647 1648
	if (nla_put(skb, OVS_VPORT_ATTR_STATS, sizeof(struct ovs_vport_stats),
		    &vport_stats))
		goto nla_put_failure;
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662

	err = ovs_vport_get_options(vport, skb);
	if (err == -EMSGSIZE)
		goto error;

	return genlmsg_end(skb, ovs_header);

nla_put_failure:
	err = -EMSGSIZE;
error:
	genlmsg_cancel(skb, ovs_header);
	return err;
}

1663 1664 1665 1666 1667 1668
static struct sk_buff *ovs_vport_cmd_alloc_info(void)
{
	return nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
}

/* Called with ovs_mutex, only via ovs_dp_notify_wq(). */
1669
struct sk_buff *ovs_vport_cmd_build_info(struct vport *vport, u32 portid,
1670 1671 1672 1673 1674 1675 1676 1677 1678
					 u32 seq, u8 cmd)
{
	struct sk_buff *skb;
	int retval;

	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
	if (!skb)
		return ERR_PTR(-ENOMEM);

1679
	retval = ovs_vport_cmd_fill_info(vport, skb, portid, seq, 0, cmd);
1680 1681
	BUG_ON(retval < 0);

1682 1683 1684
	return skb;
}

1685
/* Called with ovs_mutex or RCU read lock. */
1686 1687
static struct vport *lookup_vport(struct net *net,
				  struct ovs_header *ovs_header,
1688 1689 1690 1691 1692 1693
				  struct nlattr *a[OVS_VPORT_ATTR_MAX + 1])
{
	struct datapath *dp;
	struct vport *vport;

	if (a[OVS_VPORT_ATTR_NAME]) {
1694
		vport = ovs_vport_locate(net, nla_data(a[OVS_VPORT_ATTR_NAME]));
1695 1696
		if (!vport)
			return ERR_PTR(-ENODEV);
1697 1698 1699
		if (ovs_header->dp_ifindex &&
		    ovs_header->dp_ifindex != get_dpifindex(vport->dp))
			return ERR_PTR(-ENODEV);
1700 1701 1702 1703 1704 1705 1706
		return vport;
	} else if (a[OVS_VPORT_ATTR_PORT_NO]) {
		u32 port_no = nla_get_u32(a[OVS_VPORT_ATTR_PORT_NO]);

		if (port_no >= DP_MAX_PORTS)
			return ERR_PTR(-EFBIG);

1707
		dp = get_dp(net, ovs_header->dp_ifindex);
1708 1709 1710
		if (!dp)
			return ERR_PTR(-ENODEV);

1711
		vport = ovs_vport_ovsl_rcu(dp, port_no);
1712
		if (!vport)
1713
			return ERR_PTR(-ENODEV);
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
		return vport;
	} else
		return ERR_PTR(-EINVAL);
}

static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct ovs_header *ovs_header = info->userhdr;
	struct vport_parms parms;
	struct sk_buff *reply;
	struct vport *vport;
	struct datapath *dp;
	u32 port_no;
	int err;

	if (!a[OVS_VPORT_ATTR_NAME] || !a[OVS_VPORT_ATTR_TYPE] ||
	    !a[OVS_VPORT_ATTR_UPCALL_PID])
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
		return -EINVAL;

	port_no = a[OVS_VPORT_ATTR_PORT_NO]
		? nla_get_u32(a[OVS_VPORT_ATTR_PORT_NO]) : 0;
	if (port_no >= DP_MAX_PORTS)
		return -EFBIG;

	reply = ovs_vport_cmd_alloc_info();
	if (!reply)
		return -ENOMEM;
1742

1743
	ovs_lock();
1744
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
1745 1746
	err = -ENODEV;
	if (!dp)
1747
		goto exit_unlock_free;
1748

1749
	if (port_no) {
1750
		vport = ovs_vport_ovsl(dp, port_no);
1751 1752
		err = -EBUSY;
		if (vport)
1753
			goto exit_unlock_free;
1754 1755 1756 1757
	} else {
		for (port_no = 1; ; port_no++) {
			if (port_no >= DP_MAX_PORTS) {
				err = -EFBIG;
1758
				goto exit_unlock_free;
1759
			}
1760
			vport = ovs_vport_ovsl(dp, port_no);
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
			if (!vport)
				break;
		}
	}

	parms.name = nla_data(a[OVS_VPORT_ATTR_NAME]);
	parms.type = nla_get_u32(a[OVS_VPORT_ATTR_TYPE]);
	parms.options = a[OVS_VPORT_ATTR_OPTIONS];
	parms.dp = dp;
	parms.port_no = port_no;
1771
	parms.upcall_portid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]);
1772 1773 1774 1775

	vport = new_vport(&parms);
	err = PTR_ERR(vport);
	if (IS_ERR(vport))
1776
		goto exit_unlock_free;
1777

1778 1779 1780 1781
	err = ovs_vport_cmd_fill_info(vport, reply, info->snd_portid,
				      info->snd_seq, 0, OVS_VPORT_CMD_NEW);
	BUG_ON(err < 0);
	ovs_unlock();
1782

1783
	ovs_notify(&dp_vport_genl_family, reply, info);
1784
	return 0;
1785

1786
exit_unlock_free:
1787
	ovs_unlock();
1788
	kfree_skb(reply);
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
	return err;
}

static int ovs_vport_cmd_set(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct sk_buff *reply;
	struct vport *vport;
	int err;

1799 1800 1801 1802
	reply = ovs_vport_cmd_alloc_info();
	if (!reply)
		return -ENOMEM;

1803
	ovs_lock();
1804
	vport = lookup_vport(sock_net(skb->sk), info->userhdr, a);
1805 1806
	err = PTR_ERR(vport);
	if (IS_ERR(vport))
1807
		goto exit_unlock_free;
1808 1809

	if (a[OVS_VPORT_ATTR_TYPE] &&
1810
	    nla_get_u32(a[OVS_VPORT_ATTR_TYPE]) != vport->ops->type) {
1811
		err = -EINVAL;
1812
		goto exit_unlock_free;
1813 1814
	}

1815
	if (a[OVS_VPORT_ATTR_OPTIONS]) {
1816
		err = ovs_vport_set_options(vport, a[OVS_VPORT_ATTR_OPTIONS]);
1817
		if (err)
1818
			goto exit_unlock_free;
1819
	}
1820

1821
	if (a[OVS_VPORT_ATTR_UPCALL_PID])
1822
		vport->upcall_portid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]);
1823

1824 1825 1826
	err = ovs_vport_cmd_fill_info(vport, reply, info->snd_portid,
				      info->snd_seq, 0, OVS_VPORT_CMD_NEW);
	BUG_ON(err < 0);
1827

1828
	ovs_unlock();
1829
	ovs_notify(&dp_vport_genl_family, reply, info);
1830
	return 0;
1831

1832
exit_unlock_free:
1833
	ovs_unlock();
1834
	kfree_skb(reply);
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844
	return err;
}

static int ovs_vport_cmd_del(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct sk_buff *reply;
	struct vport *vport;
	int err;

1845 1846 1847 1848
	reply = ovs_vport_cmd_alloc_info();
	if (!reply)
		return -ENOMEM;

1849
	ovs_lock();
1850
	vport = lookup_vport(sock_net(skb->sk), info->userhdr, a);
1851 1852
	err = PTR_ERR(vport);
	if (IS_ERR(vport))
1853
		goto exit_unlock_free;
1854 1855 1856

	if (vport->port_no == OVSP_LOCAL) {
		err = -EINVAL;
1857
		goto exit_unlock_free;
1858 1859
	}

1860 1861 1862
	err = ovs_vport_cmd_fill_info(vport, reply, info->snd_portid,
				      info->snd_seq, 0, OVS_VPORT_CMD_DEL);
	BUG_ON(err < 0);
1863
	ovs_dp_detach_port(vport);
1864
	ovs_unlock();
1865

1866
	ovs_notify(&dp_vport_genl_family, reply, info);
1867
	return 0;
1868

1869
exit_unlock_free:
1870
	ovs_unlock();
1871
	kfree_skb(reply);
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
	return err;
}

static int ovs_vport_cmd_get(struct sk_buff *skb, struct genl_info *info)
{
	struct nlattr **a = info->attrs;
	struct ovs_header *ovs_header = info->userhdr;
	struct sk_buff *reply;
	struct vport *vport;
	int err;

1883 1884 1885 1886
	reply = ovs_vport_cmd_alloc_info();
	if (!reply)
		return -ENOMEM;

1887
	rcu_read_lock();
1888
	vport = lookup_vport(sock_net(skb->sk), ovs_header, a);
1889 1890
	err = PTR_ERR(vport);
	if (IS_ERR(vport))
1891 1892 1893 1894
		goto exit_unlock_free;
	err = ovs_vport_cmd_fill_info(vport, reply, info->snd_portid,
				      info->snd_seq, 0, OVS_VPORT_CMD_NEW);
	BUG_ON(err < 0);
1895 1896 1897 1898
	rcu_read_unlock();

	return genlmsg_reply(reply, info);

1899
exit_unlock_free:
1900
	rcu_read_unlock();
1901
	kfree_skb(reply);
1902 1903 1904 1905 1906 1907 1908
	return err;
}

static int ovs_vport_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh));
	struct datapath *dp;
1909 1910
	int bucket = cb->args[0], skip = cb->args[1];
	int i, j = 0;
1911

J
Jarno Rajahalme 已提交
1912
	rcu_read_lock();
1913
	dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex);
J
Jarno Rajahalme 已提交
1914 1915
	if (!dp) {
		rcu_read_unlock();
1916
		return -ENODEV;
J
Jarno Rajahalme 已提交
1917
	}
1918
	for (i = bucket; i < DP_VPORT_HASH_BUCKETS; i++) {
1919
		struct vport *vport;
1920 1921

		j = 0;
1922
		hlist_for_each_entry_rcu(vport, &dp->ports[i], dp_hash_node) {
1923 1924
			if (j >= skip &&
			    ovs_vport_cmd_fill_info(vport, skb,
1925
						    NETLINK_CB(cb->skb).portid,
1926 1927 1928 1929 1930 1931 1932 1933
						    cb->nlh->nlmsg_seq,
						    NLM_F_MULTI,
						    OVS_VPORT_CMD_NEW) < 0)
				goto out;

			j++;
		}
		skip = 0;
1934
	}
1935
out:
1936 1937
	rcu_read_unlock();

1938 1939
	cb->args[0] = i;
	cb->args[1] = j;
1940

1941
	return skb->len;
1942 1943
}

1944
static const struct genl_ops dp_vport_genl_ops[] = {
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
	{ .cmd = OVS_VPORT_CMD_NEW,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = vport_policy,
	  .doit = ovs_vport_cmd_new
	},
	{ .cmd = OVS_VPORT_CMD_DEL,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = vport_policy,
	  .doit = ovs_vport_cmd_del
	},
	{ .cmd = OVS_VPORT_CMD_GET,
	  .flags = 0,		    /* OK for unprivileged users. */
	  .policy = vport_policy,
	  .doit = ovs_vport_cmd_get,
	  .dumpit = ovs_vport_cmd_dump
	},
	{ .cmd = OVS_VPORT_CMD_SET,
	  .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
	  .policy = vport_policy,
	  .doit = ovs_vport_cmd_set,
	},
};

struct genl_family_and_ops {
	struct genl_family *family;
1970
	const struct genl_ops *ops;
1971
	int n_ops;
1972
	const struct genl_multicast_group *group;
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
};

static const struct genl_family_and_ops dp_genl_families[] = {
	{ &dp_datapath_genl_family,
	  dp_datapath_genl_ops, ARRAY_SIZE(dp_datapath_genl_ops),
	  &ovs_dp_datapath_multicast_group },
	{ &dp_vport_genl_family,
	  dp_vport_genl_ops, ARRAY_SIZE(dp_vport_genl_ops),
	  &ovs_dp_vport_multicast_group },
	{ &dp_flow_genl_family,
	  dp_flow_genl_ops, ARRAY_SIZE(dp_flow_genl_ops),
	  &ovs_dp_flow_multicast_group },
	{ &dp_packet_genl_family,
	  dp_packet_genl_ops, ARRAY_SIZE(dp_packet_genl_ops),
	  NULL },
};

static void dp_unregister_genl(int n_families)
{
	int i;

	for (i = 0; i < n_families; i++)
		genl_unregister_family(dp_genl_families[i].family);
}

static int dp_register_genl(void)
{
	int n_registered;
	int err;
	int i;

	n_registered = 0;
	for (i = 0; i < ARRAY_SIZE(dp_genl_families); i++) {
		const struct genl_family_and_ops *f = &dp_genl_families[i];

2008 2009
		f->family->ops = f->ops;
		f->family->n_ops = f->n_ops;
2010 2011
		f->family->mcgrps = f->group;
		f->family->n_mcgrps = f->group ? 1 : 0;
2012
		err = genl_register_family(f->family);
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024
		if (err)
			goto error;
		n_registered++;
	}

	return 0;

error:
	dp_unregister_genl(n_registered);
	return err;
}

2025 2026 2027 2028 2029
static int __net_init ovs_init_net(struct net *net)
{
	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);

	INIT_LIST_HEAD(&ovs_net->dps);
2030
	INIT_WORK(&ovs_net->dp_notify_work, ovs_dp_notify_wq);
2031 2032 2033 2034 2035 2036
	return 0;
}

static void __net_exit ovs_exit_net(struct net *net)
{
	struct datapath *dp, *dp_next;
2037
	struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
2038

2039
	ovs_lock();
2040 2041
	list_for_each_entry_safe(dp, dp_next, &ovs_net->dps, list_node)
		__dp_destroy(dp);
2042 2043 2044
	ovs_unlock();

	cancel_work_sync(&ovs_net->dp_notify_work);
2045 2046 2047 2048 2049 2050 2051 2052 2053
}

static struct pernet_operations ovs_net_ops = {
	.init = ovs_init_net,
	.exit = ovs_exit_net,
	.id   = &ovs_net_id,
	.size = sizeof(struct ovs_net),
};

2054 2055 2056 2057
static int __init dp_init(void)
{
	int err;

2058
	BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb));
2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069

	pr_info("Open vSwitch switching datapath\n");

	err = ovs_flow_init();
	if (err)
		goto error;

	err = ovs_vport_init();
	if (err)
		goto error_flow_exit;

2070
	err = register_pernet_device(&ovs_net_ops);
2071 2072 2073
	if (err)
		goto error_vport_exit;

2074 2075 2076 2077
	err = register_netdevice_notifier(&ovs_dp_device_notifier);
	if (err)
		goto error_netns_exit;

2078 2079 2080 2081 2082 2083 2084 2085
	err = dp_register_genl();
	if (err < 0)
		goto error_unreg_notifier;

	return 0;

error_unreg_notifier:
	unregister_netdevice_notifier(&ovs_dp_device_notifier);
2086 2087
error_netns_exit:
	unregister_pernet_device(&ovs_net_ops);
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
error_vport_exit:
	ovs_vport_exit();
error_flow_exit:
	ovs_flow_exit();
error:
	return err;
}

static void dp_cleanup(void)
{
	dp_unregister_genl(ARRAY_SIZE(dp_genl_families));
	unregister_netdevice_notifier(&ovs_dp_device_notifier);
2100 2101
	unregister_pernet_device(&ovs_net_ops);
	rcu_barrier();
2102 2103 2104 2105 2106 2107 2108 2109 2110
	ovs_vport_exit();
	ovs_flow_exit();
}

module_init(dp_init);
module_exit(dp_cleanup);

MODULE_DESCRIPTION("Open vSwitch switching datapath");
MODULE_LICENSE("GPL");