2 * Copyright (c) 2007-2014 Nicira, Inc.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of version 2 of the GNU General Public
6 * License as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/if_arp.h>
24 #include <linux/if_vlan.h>
27 #include <linux/jhash.h>
28 #include <linux/delay.h>
29 #include <linux/time.h>
30 #include <linux/etherdevice.h>
31 #include <linux/genetlink.h>
32 #include <linux/kernel.h>
33 #include <linux/kthread.h>
34 #include <linux/mutex.h>
35 #include <linux/percpu.h>
36 #include <linux/rcupdate.h>
37 #include <linux/tcp.h>
38 #include <linux/udp.h>
39 #include <linux/ethtool.h>
40 #include <linux/wait.h>
41 #include <asm/div64.h>
42 #include <linux/highmem.h>
43 #include <linux/netfilter_bridge.h>
44 #include <linux/netfilter_ipv4.h>
45 #include <linux/inetdevice.h>
46 #include <linux/list.h>
47 #include <linux/openvswitch.h>
48 #include <linux/rculist.h>
49 #include <linux/dmi.h>
50 #include <net/genetlink.h>
51 #include <net/net_namespace.h>
52 #include <net/netns/generic.h>
56 #include "flow_table.h"
57 #include "flow_netlink.h"
58 #include "vport-internal_dev.h"
59 #include "vport-netdev.h"
61 int ovs_net_id __read_mostly
;
63 static struct genl_family dp_packet_genl_family
;
64 static struct genl_family dp_flow_genl_family
;
65 static struct genl_family dp_datapath_genl_family
;
67 static const struct genl_multicast_group ovs_dp_flow_multicast_group
= {
68 .name
= OVS_FLOW_MCGROUP
,
71 static const struct genl_multicast_group ovs_dp_datapath_multicast_group
= {
72 .name
= OVS_DATAPATH_MCGROUP
,
75 static const struct genl_multicast_group ovs_dp_vport_multicast_group
= {
76 .name
= OVS_VPORT_MCGROUP
,
79 /* Check if need to build a reply message.
80 * OVS userspace sets the NLM_F_ECHO flag if it needs the reply. */
81 static bool ovs_must_notify(struct genl_family
*family
, struct genl_info
*info
,
84 return info
->nlhdr
->nlmsg_flags
& NLM_F_ECHO
||
85 genl_has_listeners(family
, genl_info_net(info
)->genl_sock
,
89 static void ovs_notify(struct genl_family
*family
,
90 struct sk_buff
*skb
, struct genl_info
*info
)
92 genl_notify(family
, skb
, genl_info_net(info
), info
->snd_portid
,
93 0, info
->nlhdr
, GFP_KERNEL
);
99 * All writes e.g. Writes to device state (add/remove datapath, port, set
100 * operations on vports, etc.), Writes to other state (flow table
101 * modifications, set miscellaneous datapath parameters, etc.) are protected
104 * Reads are protected by RCU.
106 * There are a few special cases (mostly stats) that have their own
107 * synchronization but they nest under all of above and don't interact with
110 * The RTNL lock nests inside ovs_mutex.
113 static DEFINE_MUTEX(ovs_mutex
);
117 mutex_lock(&ovs_mutex
);
120 void ovs_unlock(void)
122 mutex_unlock(&ovs_mutex
);
125 #ifdef CONFIG_LOCKDEP
126 int lockdep_ovsl_is_held(void)
129 return lockdep_is_held(&ovs_mutex
);
135 static struct vport
*new_vport(const struct vport_parms
*);
136 static int queue_gso_packets(struct datapath
*dp
, struct sk_buff
*,
137 const struct dp_upcall_info
*);
138 static int queue_userspace_packet(struct datapath
*dp
, struct sk_buff
*,
139 const struct dp_upcall_info
*);
141 /* Must be called with rcu_read_lock or ovs_mutex. */
142 static struct datapath
*get_dp(struct net
*net
, int dp_ifindex
)
144 struct datapath
*dp
= NULL
;
145 struct net_device
*dev
;
148 dev
= dev_get_by_index_rcu(net
, dp_ifindex
);
150 struct vport
*vport
= ovs_internal_dev_get_vport(dev
);
159 /* Must be called with rcu_read_lock or ovs_mutex. */
160 const char *ovs_dp_name(const struct datapath
*dp
)
162 struct vport
*vport
= ovs_vport_ovsl_rcu(dp
, OVSP_LOCAL
);
163 return vport
->ops
->get_name(vport
);
166 static int get_dpifindex(struct datapath
*dp
)
173 local
= ovs_vport_rcu(dp
, OVSP_LOCAL
);
175 ifindex
= netdev_vport_priv(local
)->dev
->ifindex
;
184 static void destroy_dp_rcu(struct rcu_head
*rcu
)
186 struct datapath
*dp
= container_of(rcu
, struct datapath
, rcu
);
188 free_percpu(dp
->stats_percpu
);
189 release_net(ovs_dp_get_net(dp
));
194 static struct hlist_head
*vport_hash_bucket(const struct datapath
*dp
,
197 return &dp
->ports
[port_no
& (DP_VPORT_HASH_BUCKETS
- 1)];
200 /* Called with ovs_mutex or RCU read lock. */
201 struct vport
*ovs_lookup_vport(const struct datapath
*dp
, u16 port_no
)
204 struct hlist_head
*head
;
206 head
= vport_hash_bucket(dp
, port_no
);
207 hlist_for_each_entry_rcu(vport
, head
, dp_hash_node
) {
208 if (vport
->port_no
== port_no
)
214 /* Called with ovs_mutex. */
215 static struct vport
*new_vport(const struct vport_parms
*parms
)
219 vport
= ovs_vport_add(parms
);
220 if (!IS_ERR(vport
)) {
221 struct datapath
*dp
= parms
->dp
;
222 struct hlist_head
*head
= vport_hash_bucket(dp
, vport
->port_no
);
224 hlist_add_head_rcu(&vport
->dp_hash_node
, head
);
229 void ovs_dp_detach_port(struct vport
*p
)
233 /* First drop references to device. */
234 hlist_del_rcu(&p
->dp_hash_node
);
236 /* Then destroy it. */
240 /* Must be called with rcu_read_lock. */
241 void ovs_dp_process_packet(struct sk_buff
*skb
, struct sw_flow_key
*key
)
243 const struct vport
*p
= OVS_CB(skb
)->input_vport
;
244 struct datapath
*dp
= p
->dp
;
245 struct sw_flow
*flow
;
246 struct dp_stats_percpu
*stats
;
250 stats
= this_cpu_ptr(dp
->stats_percpu
);
253 flow
= ovs_flow_tbl_lookup_stats(&dp
->table
, key
, &n_mask_hit
);
254 if (unlikely(!flow
)) {
255 struct dp_upcall_info upcall
;
258 upcall
.cmd
= OVS_PACKET_CMD_MISS
;
260 upcall
.userdata
= NULL
;
261 upcall
.portid
= ovs_vport_find_upcall_portid(p
, skb
);
262 error
= ovs_dp_upcall(dp
, skb
, &upcall
);
267 stats_counter
= &stats
->n_missed
;
271 OVS_CB(skb
)->flow
= flow
;
273 ovs_flow_stats_update(OVS_CB(skb
)->flow
, key
->tp
.flags
, skb
);
274 ovs_execute_actions(dp
, skb
, key
);
275 stats_counter
= &stats
->n_hit
;
278 /* Update datapath statistics. */
279 u64_stats_update_begin(&stats
->syncp
);
281 stats
->n_mask_hit
+= n_mask_hit
;
282 u64_stats_update_end(&stats
->syncp
);
285 int ovs_dp_upcall(struct datapath
*dp
, struct sk_buff
*skb
,
286 const struct dp_upcall_info
*upcall_info
)
288 struct dp_stats_percpu
*stats
;
291 if (upcall_info
->portid
== 0) {
296 if (!skb_is_gso(skb
))
297 err
= queue_userspace_packet(dp
, skb
, upcall_info
);
299 err
= queue_gso_packets(dp
, skb
, upcall_info
);
306 stats
= this_cpu_ptr(dp
->stats_percpu
);
308 u64_stats_update_begin(&stats
->syncp
);
310 u64_stats_update_end(&stats
->syncp
);
315 static int queue_gso_packets(struct datapath
*dp
, struct sk_buff
*skb
,
316 const struct dp_upcall_info
*upcall_info
)
318 unsigned short gso_type
= skb_shinfo(skb
)->gso_type
;
319 struct dp_upcall_info later_info
;
320 struct sw_flow_key later_key
;
321 struct sk_buff
*segs
, *nskb
;
324 segs
= __skb_gso_segment(skb
, NETIF_F_SG
, false);
326 return PTR_ERR(segs
);
330 /* Queue all of the segments. */
333 err
= queue_userspace_packet(dp
, skb
, upcall_info
);
337 if (skb
== segs
&& gso_type
& SKB_GSO_UDP
) {
338 /* The initial flow key extracted by ovs_flow_extract()
339 * in this case is for a first fragment, so we need to
340 * properly mark later fragments.
342 later_key
= *upcall_info
->key
;
343 later_key
.ip
.frag
= OVS_FRAG_TYPE_LATER
;
345 later_info
= *upcall_info
;
346 later_info
.key
= &later_key
;
347 upcall_info
= &later_info
;
349 } while ((skb
= skb
->next
));
351 /* Free all of the segments. */
359 } while ((skb
= nskb
));
363 static size_t key_attr_size(void)
365 return nla_total_size(4) /* OVS_KEY_ATTR_PRIORITY */
366 + nla_total_size(0) /* OVS_KEY_ATTR_TUNNEL */
367 + nla_total_size(8) /* OVS_TUNNEL_KEY_ATTR_ID */
368 + nla_total_size(4) /* OVS_TUNNEL_KEY_ATTR_IPV4_SRC */
369 + nla_total_size(4) /* OVS_TUNNEL_KEY_ATTR_IPV4_DST */
370 + nla_total_size(1) /* OVS_TUNNEL_KEY_ATTR_TOS */
371 + nla_total_size(1) /* OVS_TUNNEL_KEY_ATTR_TTL */
372 + nla_total_size(0) /* OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT */
373 + nla_total_size(0) /* OVS_TUNNEL_KEY_ATTR_CSUM */
374 + nla_total_size(0) /* OVS_TUNNEL_KEY_ATTR_OAM */
375 + nla_total_size(256) /* OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS */
376 + nla_total_size(4) /* OVS_KEY_ATTR_IN_PORT */
377 + nla_total_size(4) /* OVS_KEY_ATTR_SKB_MARK */
378 + nla_total_size(12) /* OVS_KEY_ATTR_ETHERNET */
379 + nla_total_size(2) /* OVS_KEY_ATTR_ETHERTYPE */
380 + nla_total_size(4) /* OVS_KEY_ATTR_8021Q */
381 + nla_total_size(0) /* OVS_KEY_ATTR_ENCAP */
382 + nla_total_size(2) /* OVS_KEY_ATTR_ETHERTYPE */
383 + nla_total_size(40) /* OVS_KEY_ATTR_IPV6 */
384 + nla_total_size(2) /* OVS_KEY_ATTR_ICMPV6 */
385 + nla_total_size(28); /* OVS_KEY_ATTR_ND */
388 static size_t upcall_msg_size(const struct nlattr
*userdata
,
391 size_t size
= NLMSG_ALIGN(sizeof(struct ovs_header
))
392 + nla_total_size(hdrlen
) /* OVS_PACKET_ATTR_PACKET */
393 + nla_total_size(key_attr_size()); /* OVS_PACKET_ATTR_KEY */
395 /* OVS_PACKET_ATTR_USERDATA */
397 size
+= NLA_ALIGN(userdata
->nla_len
);
402 static int queue_userspace_packet(struct datapath
*dp
, struct sk_buff
*skb
,
403 const struct dp_upcall_info
*upcall_info
)
405 struct ovs_header
*upcall
;
406 struct sk_buff
*nskb
= NULL
;
407 struct sk_buff
*user_skb
= NULL
; /* to be queued to userspace */
409 struct genl_info info
= {
410 .dst_sk
= ovs_dp_get_net(dp
)->genl_sock
,
411 .snd_portid
= upcall_info
->portid
,
417 dp_ifindex
= get_dpifindex(dp
);
421 if (vlan_tx_tag_present(skb
)) {
422 nskb
= skb_clone(skb
, GFP_ATOMIC
);
426 nskb
= __vlan_put_tag(nskb
, nskb
->vlan_proto
, vlan_tx_tag_get(nskb
));
434 if (nla_attr_size(skb
->len
) > USHRT_MAX
) {
439 /* Complete checksum if needed */
440 if (skb
->ip_summed
== CHECKSUM_PARTIAL
&&
441 (err
= skb_checksum_help(skb
)))
444 /* Older versions of OVS user space enforce alignment of the last
445 * Netlink attribute to NLA_ALIGNTO which would require extensive
446 * padding logic. Only perform zerocopy if padding is not required.
448 if (dp
->user_features
& OVS_DP_F_UNALIGNED
)
449 hlen
= skb_zerocopy_headlen(skb
);
453 len
= upcall_msg_size(upcall_info
->userdata
, hlen
);
454 user_skb
= genlmsg_new_unicast(len
, &info
, GFP_ATOMIC
);
460 upcall
= genlmsg_put(user_skb
, 0, 0, &dp_packet_genl_family
,
461 0, upcall_info
->cmd
);
462 upcall
->dp_ifindex
= dp_ifindex
;
464 nla
= nla_nest_start(user_skb
, OVS_PACKET_ATTR_KEY
);
465 err
= ovs_nla_put_flow(upcall_info
->key
, upcall_info
->key
, user_skb
);
467 nla_nest_end(user_skb
, nla
);
469 if (upcall_info
->userdata
)
470 __nla_put(user_skb
, OVS_PACKET_ATTR_USERDATA
,
471 nla_len(upcall_info
->userdata
),
472 nla_data(upcall_info
->userdata
));
474 /* Only reserve room for attribute header, packet data is added
475 * in skb_zerocopy() */
476 if (!(nla
= nla_reserve(user_skb
, OVS_PACKET_ATTR_PACKET
, 0))) {
480 nla
->nla_len
= nla_attr_size(skb
->len
);
482 err
= skb_zerocopy(user_skb
, skb
, skb
->len
, hlen
);
486 /* Pad OVS_PACKET_ATTR_PACKET if linear copy was performed */
487 if (!(dp
->user_features
& OVS_DP_F_UNALIGNED
)) {
488 size_t plen
= NLA_ALIGN(user_skb
->len
) - user_skb
->len
;
491 memset(skb_put(user_skb
, plen
), 0, plen
);
494 ((struct nlmsghdr
*) user_skb
->data
)->nlmsg_len
= user_skb
->len
;
496 err
= genlmsg_unicast(ovs_dp_get_net(dp
), user_skb
, upcall_info
->portid
);
506 static int ovs_packet_cmd_execute(struct sk_buff
*skb
, struct genl_info
*info
)
508 struct ovs_header
*ovs_header
= info
->userhdr
;
509 struct nlattr
**a
= info
->attrs
;
510 struct sw_flow_actions
*acts
;
511 struct sk_buff
*packet
;
512 struct sw_flow
*flow
;
515 struct vport
*input_vport
;
520 if (!a
[OVS_PACKET_ATTR_PACKET
] || !a
[OVS_PACKET_ATTR_KEY
] ||
521 !a
[OVS_PACKET_ATTR_ACTIONS
])
524 len
= nla_len(a
[OVS_PACKET_ATTR_PACKET
]);
525 packet
= __dev_alloc_skb(NET_IP_ALIGN
+ len
, GFP_KERNEL
);
529 skb_reserve(packet
, NET_IP_ALIGN
);
531 nla_memcpy(__skb_put(packet
, len
), a
[OVS_PACKET_ATTR_PACKET
], len
);
533 skb_reset_mac_header(packet
);
534 eth
= eth_hdr(packet
);
536 /* Normally, setting the skb 'protocol' field would be handled by a
537 * call to eth_type_trans(), but it assumes there's a sending
538 * device, which we may not have. */
539 if (ntohs(eth
->h_proto
) >= ETH_P_802_3_MIN
)
540 packet
->protocol
= eth
->h_proto
;
542 packet
->protocol
= htons(ETH_P_802_2
);
544 /* Build an sw_flow for sending this packet. */
545 flow
= ovs_flow_alloc();
550 err
= ovs_flow_key_extract_userspace(a
[OVS_PACKET_ATTR_KEY
], packet
,
555 acts
= ovs_nla_alloc_flow_actions(nla_len(a
[OVS_PACKET_ATTR_ACTIONS
]));
560 err
= ovs_nla_copy_actions(a
[OVS_PACKET_ATTR_ACTIONS
],
561 &flow
->key
, 0, &acts
);
565 rcu_assign_pointer(flow
->sf_acts
, acts
);
567 OVS_CB(packet
)->egress_tun_info
= NULL
;
568 OVS_CB(packet
)->flow
= flow
;
569 packet
->priority
= flow
->key
.phy
.priority
;
570 packet
->mark
= flow
->key
.phy
.skb_mark
;
573 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
578 input_vport
= ovs_vport_rcu(dp
, flow
->key
.phy
.in_port
);
580 input_vport
= ovs_vport_rcu(dp
, OVSP_LOCAL
);
585 OVS_CB(packet
)->input_vport
= input_vport
;
588 err
= ovs_execute_actions(dp
, packet
, &flow
->key
);
592 ovs_flow_free(flow
, false);
598 ovs_flow_free(flow
, false);
605 static const struct nla_policy packet_policy
[OVS_PACKET_ATTR_MAX
+ 1] = {
606 [OVS_PACKET_ATTR_PACKET
] = { .len
= ETH_HLEN
},
607 [OVS_PACKET_ATTR_KEY
] = { .type
= NLA_NESTED
},
608 [OVS_PACKET_ATTR_ACTIONS
] = { .type
= NLA_NESTED
},
611 static const struct genl_ops dp_packet_genl_ops
[] = {
612 { .cmd
= OVS_PACKET_CMD_EXECUTE
,
613 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
614 .policy
= packet_policy
,
615 .doit
= ovs_packet_cmd_execute
619 static struct genl_family dp_packet_genl_family
= {
620 .id
= GENL_ID_GENERATE
,
621 .hdrsize
= sizeof(struct ovs_header
),
622 .name
= OVS_PACKET_FAMILY
,
623 .version
= OVS_PACKET_VERSION
,
624 .maxattr
= OVS_PACKET_ATTR_MAX
,
626 .parallel_ops
= true,
627 .ops
= dp_packet_genl_ops
,
628 .n_ops
= ARRAY_SIZE(dp_packet_genl_ops
),
631 static void get_dp_stats(struct datapath
*dp
, struct ovs_dp_stats
*stats
,
632 struct ovs_dp_megaflow_stats
*mega_stats
)
636 memset(mega_stats
, 0, sizeof(*mega_stats
));
638 stats
->n_flows
= ovs_flow_tbl_count(&dp
->table
);
639 mega_stats
->n_masks
= ovs_flow_tbl_num_masks(&dp
->table
);
641 stats
->n_hit
= stats
->n_missed
= stats
->n_lost
= 0;
643 for_each_possible_cpu(i
) {
644 const struct dp_stats_percpu
*percpu_stats
;
645 struct dp_stats_percpu local_stats
;
648 percpu_stats
= per_cpu_ptr(dp
->stats_percpu
, i
);
651 start
= u64_stats_fetch_begin_irq(&percpu_stats
->syncp
);
652 local_stats
= *percpu_stats
;
653 } while (u64_stats_fetch_retry_irq(&percpu_stats
->syncp
, start
));
655 stats
->n_hit
+= local_stats
.n_hit
;
656 stats
->n_missed
+= local_stats
.n_missed
;
657 stats
->n_lost
+= local_stats
.n_lost
;
658 mega_stats
->n_mask_hit
+= local_stats
.n_mask_hit
;
662 static size_t ovs_flow_cmd_msg_size(const struct sw_flow_actions
*acts
)
664 return NLMSG_ALIGN(sizeof(struct ovs_header
))
665 + nla_total_size(key_attr_size()) /* OVS_FLOW_ATTR_KEY */
666 + nla_total_size(key_attr_size()) /* OVS_FLOW_ATTR_MASK */
667 + nla_total_size(sizeof(struct ovs_flow_stats
)) /* OVS_FLOW_ATTR_STATS */
668 + nla_total_size(1) /* OVS_FLOW_ATTR_TCP_FLAGS */
669 + nla_total_size(8) /* OVS_FLOW_ATTR_USED */
670 + nla_total_size(acts
->actions_len
); /* OVS_FLOW_ATTR_ACTIONS */
673 /* Called with ovs_mutex or RCU read lock. */
674 static int ovs_flow_cmd_fill_info(const struct sw_flow
*flow
, int dp_ifindex
,
675 struct sk_buff
*skb
, u32 portid
,
676 u32 seq
, u32 flags
, u8 cmd
)
678 const int skb_orig_len
= skb
->len
;
679 struct nlattr
*start
;
680 struct ovs_flow_stats stats
;
683 struct ovs_header
*ovs_header
;
687 ovs_header
= genlmsg_put(skb
, portid
, seq
, &dp_flow_genl_family
, flags
, cmd
);
691 ovs_header
->dp_ifindex
= dp_ifindex
;
694 nla
= nla_nest_start(skb
, OVS_FLOW_ATTR_KEY
);
696 goto nla_put_failure
;
698 err
= ovs_nla_put_flow(&flow
->unmasked_key
, &flow
->unmasked_key
, skb
);
701 nla_nest_end(skb
, nla
);
703 nla
= nla_nest_start(skb
, OVS_FLOW_ATTR_MASK
);
705 goto nla_put_failure
;
707 err
= ovs_nla_put_flow(&flow
->key
, &flow
->mask
->key
, skb
);
711 nla_nest_end(skb
, nla
);
713 ovs_flow_stats_get(flow
, &stats
, &used
, &tcp_flags
);
716 nla_put_u64(skb
, OVS_FLOW_ATTR_USED
, ovs_flow_used_time(used
)))
717 goto nla_put_failure
;
719 if (stats
.n_packets
&&
720 nla_put(skb
, OVS_FLOW_ATTR_STATS
, sizeof(struct ovs_flow_stats
), &stats
))
721 goto nla_put_failure
;
723 if ((u8
)ntohs(tcp_flags
) &&
724 nla_put_u8(skb
, OVS_FLOW_ATTR_TCP_FLAGS
, (u8
)ntohs(tcp_flags
)))
725 goto nla_put_failure
;
727 /* If OVS_FLOW_ATTR_ACTIONS doesn't fit, skip dumping the actions if
728 * this is the first flow to be dumped into 'skb'. This is unusual for
729 * Netlink but individual action lists can be longer than
730 * NLMSG_GOODSIZE and thus entirely undumpable if we didn't do this.
731 * The userspace caller can always fetch the actions separately if it
732 * really wants them. (Most userspace callers in fact don't care.)
734 * This can only fail for dump operations because the skb is always
735 * properly sized for single flows.
737 start
= nla_nest_start(skb
, OVS_FLOW_ATTR_ACTIONS
);
739 const struct sw_flow_actions
*sf_acts
;
741 sf_acts
= rcu_dereference_ovsl(flow
->sf_acts
);
742 err
= ovs_nla_put_actions(sf_acts
->actions
,
743 sf_acts
->actions_len
, skb
);
746 nla_nest_end(skb
, start
);
751 nla_nest_cancel(skb
, start
);
753 } else if (skb_orig_len
)
754 goto nla_put_failure
;
756 return genlmsg_end(skb
, ovs_header
);
761 genlmsg_cancel(skb
, ovs_header
);
765 /* May not be called with RCU read lock. */
766 static struct sk_buff
*ovs_flow_cmd_alloc_info(const struct sw_flow_actions
*acts
,
767 struct genl_info
*info
,
772 if (!always
&& !ovs_must_notify(&dp_flow_genl_family
, info
, 0))
775 skb
= genlmsg_new_unicast(ovs_flow_cmd_msg_size(acts
), info
, GFP_KERNEL
);
777 return ERR_PTR(-ENOMEM
);
782 /* Called with ovs_mutex. */
783 static struct sk_buff
*ovs_flow_cmd_build_info(const struct sw_flow
*flow
,
785 struct genl_info
*info
, u8 cmd
,
791 skb
= ovs_flow_cmd_alloc_info(ovsl_dereference(flow
->sf_acts
), info
,
793 if (IS_ERR_OR_NULL(skb
))
796 retval
= ovs_flow_cmd_fill_info(flow
, dp_ifindex
, skb
,
797 info
->snd_portid
, info
->snd_seq
, 0,
803 static int ovs_flow_cmd_new(struct sk_buff
*skb
, struct genl_info
*info
)
805 struct nlattr
**a
= info
->attrs
;
806 struct ovs_header
*ovs_header
= info
->userhdr
;
807 struct sw_flow
*flow
, *new_flow
;
808 struct sw_flow_mask mask
;
809 struct sk_buff
*reply
;
811 struct sw_flow_actions
*acts
;
812 struct sw_flow_match match
;
815 /* Must have key and actions. */
817 if (!a
[OVS_FLOW_ATTR_KEY
])
819 if (!a
[OVS_FLOW_ATTR_ACTIONS
])
822 /* Most of the time we need to allocate a new flow, do it before
825 new_flow
= ovs_flow_alloc();
826 if (IS_ERR(new_flow
)) {
827 error
= PTR_ERR(new_flow
);
832 ovs_match_init(&match
, &new_flow
->unmasked_key
, &mask
);
833 error
= ovs_nla_get_match(&match
,
834 a
[OVS_FLOW_ATTR_KEY
], a
[OVS_FLOW_ATTR_MASK
]);
838 ovs_flow_mask_key(&new_flow
->key
, &new_flow
->unmasked_key
, &mask
);
840 /* Validate actions. */
841 acts
= ovs_nla_alloc_flow_actions(nla_len(a
[OVS_FLOW_ATTR_ACTIONS
]));
842 error
= PTR_ERR(acts
);
846 error
= ovs_nla_copy_actions(a
[OVS_FLOW_ATTR_ACTIONS
], &new_flow
->key
,
849 OVS_NLERR("Flow actions may not be safe on all matching packets.\n");
853 reply
= ovs_flow_cmd_alloc_info(acts
, info
, false);
855 error
= PTR_ERR(reply
);
860 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
865 /* Check if this is a duplicate flow */
866 flow
= ovs_flow_tbl_lookup(&dp
->table
, &new_flow
->unmasked_key
);
868 rcu_assign_pointer(new_flow
->sf_acts
, acts
);
870 /* Put flow in bucket. */
871 error
= ovs_flow_tbl_insert(&dp
->table
, new_flow
, &mask
);
872 if (unlikely(error
)) {
877 if (unlikely(reply
)) {
878 error
= ovs_flow_cmd_fill_info(new_flow
,
879 ovs_header
->dp_ifindex
,
880 reply
, info
->snd_portid
,
887 struct sw_flow_actions
*old_acts
;
889 /* Bail out if we're not allowed to modify an existing flow.
890 * We accept NLM_F_CREATE in place of the intended NLM_F_EXCL
891 * because Generic Netlink treats the latter as a dump
892 * request. We also accept NLM_F_EXCL in case that bug ever
895 if (unlikely(info
->nlhdr
->nlmsg_flags
& (NLM_F_CREATE
900 /* The unmasked key has to be the same for flow updates. */
901 if (unlikely(!ovs_flow_cmp_unmasked_key(flow
, &match
))) {
902 flow
= ovs_flow_tbl_lookup_exact(&dp
->table
, &match
);
908 /* Update actions. */
909 old_acts
= ovsl_dereference(flow
->sf_acts
);
910 rcu_assign_pointer(flow
->sf_acts
, acts
);
912 if (unlikely(reply
)) {
913 error
= ovs_flow_cmd_fill_info(flow
,
914 ovs_header
->dp_ifindex
,
915 reply
, info
->snd_portid
,
922 ovs_nla_free_flow_actions(old_acts
);
923 ovs_flow_free(new_flow
, false);
927 ovs_notify(&dp_flow_genl_family
, reply
, info
);
936 ovs_flow_free(new_flow
, false);
941 static struct sw_flow_actions
*get_flow_actions(const struct nlattr
*a
,
942 const struct sw_flow_key
*key
,
943 const struct sw_flow_mask
*mask
)
945 struct sw_flow_actions
*acts
;
946 struct sw_flow_key masked_key
;
949 acts
= ovs_nla_alloc_flow_actions(nla_len(a
));
953 ovs_flow_mask_key(&masked_key
, key
, mask
);
954 error
= ovs_nla_copy_actions(a
, &masked_key
, 0, &acts
);
956 OVS_NLERR("Flow actions may not be safe on all matching packets.\n");
958 return ERR_PTR(error
);
964 static int ovs_flow_cmd_set(struct sk_buff
*skb
, struct genl_info
*info
)
966 struct nlattr
**a
= info
->attrs
;
967 struct ovs_header
*ovs_header
= info
->userhdr
;
968 struct sw_flow_key key
;
969 struct sw_flow
*flow
;
970 struct sw_flow_mask mask
;
971 struct sk_buff
*reply
= NULL
;
973 struct sw_flow_actions
*old_acts
= NULL
, *acts
= NULL
;
974 struct sw_flow_match match
;
979 if (!a
[OVS_FLOW_ATTR_KEY
])
982 ovs_match_init(&match
, &key
, &mask
);
983 error
= ovs_nla_get_match(&match
,
984 a
[OVS_FLOW_ATTR_KEY
], a
[OVS_FLOW_ATTR_MASK
]);
988 /* Validate actions. */
989 if (a
[OVS_FLOW_ATTR_ACTIONS
]) {
990 acts
= get_flow_actions(a
[OVS_FLOW_ATTR_ACTIONS
], &key
, &mask
);
992 error
= PTR_ERR(acts
);
997 /* Can allocate before locking if have acts. */
999 reply
= ovs_flow_cmd_alloc_info(acts
, info
, false);
1000 if (IS_ERR(reply
)) {
1001 error
= PTR_ERR(reply
);
1002 goto err_kfree_acts
;
1007 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
1008 if (unlikely(!dp
)) {
1010 goto err_unlock_ovs
;
1012 /* Check that the flow exists. */
1013 flow
= ovs_flow_tbl_lookup_exact(&dp
->table
, &match
);
1014 if (unlikely(!flow
)) {
1016 goto err_unlock_ovs
;
1019 /* Update actions, if present. */
1021 old_acts
= ovsl_dereference(flow
->sf_acts
);
1022 rcu_assign_pointer(flow
->sf_acts
, acts
);
1024 if (unlikely(reply
)) {
1025 error
= ovs_flow_cmd_fill_info(flow
,
1026 ovs_header
->dp_ifindex
,
1027 reply
, info
->snd_portid
,
1033 /* Could not alloc without acts before locking. */
1034 reply
= ovs_flow_cmd_build_info(flow
, ovs_header
->dp_ifindex
,
1035 info
, OVS_FLOW_CMD_NEW
, false);
1036 if (unlikely(IS_ERR(reply
))) {
1037 error
= PTR_ERR(reply
);
1038 goto err_unlock_ovs
;
1043 if (a
[OVS_FLOW_ATTR_CLEAR
])
1044 ovs_flow_stats_clear(flow
);
1048 ovs_notify(&dp_flow_genl_family
, reply
, info
);
1050 ovs_nla_free_flow_actions(old_acts
);
1063 static int ovs_flow_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
1065 struct nlattr
**a
= info
->attrs
;
1066 struct ovs_header
*ovs_header
= info
->userhdr
;
1067 struct sw_flow_key key
;
1068 struct sk_buff
*reply
;
1069 struct sw_flow
*flow
;
1070 struct datapath
*dp
;
1071 struct sw_flow_match match
;
1074 if (!a
[OVS_FLOW_ATTR_KEY
]) {
1075 OVS_NLERR("Flow get message rejected, Key attribute missing.\n");
1079 ovs_match_init(&match
, &key
, NULL
);
1080 err
= ovs_nla_get_match(&match
, a
[OVS_FLOW_ATTR_KEY
], NULL
);
1085 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
1091 flow
= ovs_flow_tbl_lookup_exact(&dp
->table
, &match
);
1097 reply
= ovs_flow_cmd_build_info(flow
, ovs_header
->dp_ifindex
, info
,
1098 OVS_FLOW_CMD_NEW
, true);
1099 if (IS_ERR(reply
)) {
1100 err
= PTR_ERR(reply
);
1105 return genlmsg_reply(reply
, info
);
1111 static int ovs_flow_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
1113 struct nlattr
**a
= info
->attrs
;
1114 struct ovs_header
*ovs_header
= info
->userhdr
;
1115 struct sw_flow_key key
;
1116 struct sk_buff
*reply
;
1117 struct sw_flow
*flow
;
1118 struct datapath
*dp
;
1119 struct sw_flow_match match
;
1122 if (likely(a
[OVS_FLOW_ATTR_KEY
])) {
1123 ovs_match_init(&match
, &key
, NULL
);
1124 err
= ovs_nla_get_match(&match
, a
[OVS_FLOW_ATTR_KEY
], NULL
);
1130 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
1131 if (unlikely(!dp
)) {
1136 if (unlikely(!a
[OVS_FLOW_ATTR_KEY
])) {
1137 err
= ovs_flow_tbl_flush(&dp
->table
);
1141 flow
= ovs_flow_tbl_lookup_exact(&dp
->table
, &match
);
1142 if (unlikely(!flow
)) {
1147 ovs_flow_tbl_remove(&dp
->table
, flow
);
1150 reply
= ovs_flow_cmd_alloc_info((const struct sw_flow_actions __force
*) flow
->sf_acts
,
1152 if (likely(reply
)) {
1153 if (likely(!IS_ERR(reply
))) {
1154 rcu_read_lock(); /*To keep RCU checker happy. */
1155 err
= ovs_flow_cmd_fill_info(flow
, ovs_header
->dp_ifindex
,
1156 reply
, info
->snd_portid
,
1162 ovs_notify(&dp_flow_genl_family
, reply
, info
);
1164 netlink_set_err(sock_net(skb
->sk
)->genl_sock
, 0, 0, PTR_ERR(reply
));
1168 ovs_flow_free(flow
, true);
1175 static int ovs_flow_cmd_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1177 struct ovs_header
*ovs_header
= genlmsg_data(nlmsg_data(cb
->nlh
));
1178 struct table_instance
*ti
;
1179 struct datapath
*dp
;
1182 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
1188 ti
= rcu_dereference(dp
->table
.ti
);
1190 struct sw_flow
*flow
;
1193 bucket
= cb
->args
[0];
1195 flow
= ovs_flow_tbl_dump_next(ti
, &bucket
, &obj
);
1199 if (ovs_flow_cmd_fill_info(flow
, ovs_header
->dp_ifindex
, skb
,
1200 NETLINK_CB(cb
->skb
).portid
,
1201 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1202 OVS_FLOW_CMD_NEW
) < 0)
1205 cb
->args
[0] = bucket
;
1212 static const struct nla_policy flow_policy
[OVS_FLOW_ATTR_MAX
+ 1] = {
1213 [OVS_FLOW_ATTR_KEY
] = { .type
= NLA_NESTED
},
1214 [OVS_FLOW_ATTR_ACTIONS
] = { .type
= NLA_NESTED
},
1215 [OVS_FLOW_ATTR_CLEAR
] = { .type
= NLA_FLAG
},
1218 static const struct genl_ops dp_flow_genl_ops
[] = {
1219 { .cmd
= OVS_FLOW_CMD_NEW
,
1220 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1221 .policy
= flow_policy
,
1222 .doit
= ovs_flow_cmd_new
1224 { .cmd
= OVS_FLOW_CMD_DEL
,
1225 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1226 .policy
= flow_policy
,
1227 .doit
= ovs_flow_cmd_del
1229 { .cmd
= OVS_FLOW_CMD_GET
,
1230 .flags
= 0, /* OK for unprivileged users. */
1231 .policy
= flow_policy
,
1232 .doit
= ovs_flow_cmd_get
,
1233 .dumpit
= ovs_flow_cmd_dump
1235 { .cmd
= OVS_FLOW_CMD_SET
,
1236 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1237 .policy
= flow_policy
,
1238 .doit
= ovs_flow_cmd_set
,
1242 static struct genl_family dp_flow_genl_family
= {
1243 .id
= GENL_ID_GENERATE
,
1244 .hdrsize
= sizeof(struct ovs_header
),
1245 .name
= OVS_FLOW_FAMILY
,
1246 .version
= OVS_FLOW_VERSION
,
1247 .maxattr
= OVS_FLOW_ATTR_MAX
,
1249 .parallel_ops
= true,
1250 .ops
= dp_flow_genl_ops
,
1251 .n_ops
= ARRAY_SIZE(dp_flow_genl_ops
),
1252 .mcgrps
= &ovs_dp_flow_multicast_group
,
1256 static size_t ovs_dp_cmd_msg_size(void)
1258 size_t msgsize
= NLMSG_ALIGN(sizeof(struct ovs_header
));
1260 msgsize
+= nla_total_size(IFNAMSIZ
);
1261 msgsize
+= nla_total_size(sizeof(struct ovs_dp_stats
));
1262 msgsize
+= nla_total_size(sizeof(struct ovs_dp_megaflow_stats
));
1263 msgsize
+= nla_total_size(sizeof(u32
)); /* OVS_DP_ATTR_USER_FEATURES */
1268 /* Called with ovs_mutex or RCU read lock. */
1269 static int ovs_dp_cmd_fill_info(struct datapath
*dp
, struct sk_buff
*skb
,
1270 u32 portid
, u32 seq
, u32 flags
, u8 cmd
)
1272 struct ovs_header
*ovs_header
;
1273 struct ovs_dp_stats dp_stats
;
1274 struct ovs_dp_megaflow_stats dp_megaflow_stats
;
1277 ovs_header
= genlmsg_put(skb
, portid
, seq
, &dp_datapath_genl_family
,
1282 ovs_header
->dp_ifindex
= get_dpifindex(dp
);
1284 err
= nla_put_string(skb
, OVS_DP_ATTR_NAME
, ovs_dp_name(dp
));
1286 goto nla_put_failure
;
1288 get_dp_stats(dp
, &dp_stats
, &dp_megaflow_stats
);
1289 if (nla_put(skb
, OVS_DP_ATTR_STATS
, sizeof(struct ovs_dp_stats
),
1291 goto nla_put_failure
;
1293 if (nla_put(skb
, OVS_DP_ATTR_MEGAFLOW_STATS
,
1294 sizeof(struct ovs_dp_megaflow_stats
),
1295 &dp_megaflow_stats
))
1296 goto nla_put_failure
;
1298 if (nla_put_u32(skb
, OVS_DP_ATTR_USER_FEATURES
, dp
->user_features
))
1299 goto nla_put_failure
;
1301 return genlmsg_end(skb
, ovs_header
);
1304 genlmsg_cancel(skb
, ovs_header
);
1309 static struct sk_buff
*ovs_dp_cmd_alloc_info(struct genl_info
*info
)
1311 return genlmsg_new_unicast(ovs_dp_cmd_msg_size(), info
, GFP_KERNEL
);
1314 /* Called with rcu_read_lock or ovs_mutex. */
1315 static struct datapath
*lookup_datapath(struct net
*net
,
1316 struct ovs_header
*ovs_header
,
1317 struct nlattr
*a
[OVS_DP_ATTR_MAX
+ 1])
1319 struct datapath
*dp
;
1321 if (!a
[OVS_DP_ATTR_NAME
])
1322 dp
= get_dp(net
, ovs_header
->dp_ifindex
);
1324 struct vport
*vport
;
1326 vport
= ovs_vport_locate(net
, nla_data(a
[OVS_DP_ATTR_NAME
]));
1327 dp
= vport
&& vport
->port_no
== OVSP_LOCAL
? vport
->dp
: NULL
;
1329 return dp
? dp
: ERR_PTR(-ENODEV
);
1332 static void ovs_dp_reset_user_features(struct sk_buff
*skb
, struct genl_info
*info
)
1334 struct datapath
*dp
;
1336 dp
= lookup_datapath(sock_net(skb
->sk
), info
->userhdr
, info
->attrs
);
1340 WARN(dp
->user_features
, "Dropping previously announced user features\n");
1341 dp
->user_features
= 0;
1344 static void ovs_dp_change(struct datapath
*dp
, struct nlattr
**a
)
1346 if (a
[OVS_DP_ATTR_USER_FEATURES
])
1347 dp
->user_features
= nla_get_u32(a
[OVS_DP_ATTR_USER_FEATURES
]);
1350 static int ovs_dp_cmd_new(struct sk_buff
*skb
, struct genl_info
*info
)
1352 struct nlattr
**a
= info
->attrs
;
1353 struct vport_parms parms
;
1354 struct sk_buff
*reply
;
1355 struct datapath
*dp
;
1356 struct vport
*vport
;
1357 struct ovs_net
*ovs_net
;
1361 if (!a
[OVS_DP_ATTR_NAME
] || !a
[OVS_DP_ATTR_UPCALL_PID
])
1364 reply
= ovs_dp_cmd_alloc_info(info
);
1369 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
1371 goto err_free_reply
;
1373 ovs_dp_set_net(dp
, hold_net(sock_net(skb
->sk
)));
1375 /* Allocate table. */
1376 err
= ovs_flow_tbl_init(&dp
->table
);
1380 dp
->stats_percpu
= netdev_alloc_pcpu_stats(struct dp_stats_percpu
);
1381 if (!dp
->stats_percpu
) {
1383 goto err_destroy_table
;
1386 dp
->ports
= kmalloc(DP_VPORT_HASH_BUCKETS
* sizeof(struct hlist_head
),
1390 goto err_destroy_percpu
;
1393 for (i
= 0; i
< DP_VPORT_HASH_BUCKETS
; i
++)
1394 INIT_HLIST_HEAD(&dp
->ports
[i
]);
1396 /* Set up our datapath device. */
1397 parms
.name
= nla_data(a
[OVS_DP_ATTR_NAME
]);
1398 parms
.type
= OVS_VPORT_TYPE_INTERNAL
;
1399 parms
.options
= NULL
;
1401 parms
.port_no
= OVSP_LOCAL
;
1402 parms
.upcall_portids
= a
[OVS_DP_ATTR_UPCALL_PID
];
1404 ovs_dp_change(dp
, a
);
1406 /* So far only local changes have been made, now need the lock. */
1409 vport
= new_vport(&parms
);
1410 if (IS_ERR(vport
)) {
1411 err
= PTR_ERR(vport
);
1415 if (err
== -EEXIST
) {
1416 /* An outdated user space instance that does not understand
1417 * the concept of user_features has attempted to create a new
1418 * datapath and is likely to reuse it. Drop all user features.
1420 if (info
->genlhdr
->version
< OVS_DP_VER_FEATURES
)
1421 ovs_dp_reset_user_features(skb
, info
);
1424 goto err_destroy_ports_array
;
1427 err
= ovs_dp_cmd_fill_info(dp
, reply
, info
->snd_portid
,
1428 info
->snd_seq
, 0, OVS_DP_CMD_NEW
);
1431 ovs_net
= net_generic(ovs_dp_get_net(dp
), ovs_net_id
);
1432 list_add_tail_rcu(&dp
->list_node
, &ovs_net
->dps
);
1436 ovs_notify(&dp_datapath_genl_family
, reply
, info
);
1439 err_destroy_ports_array
:
1443 free_percpu(dp
->stats_percpu
);
1445 ovs_flow_tbl_destroy(&dp
->table
, false);
1447 release_net(ovs_dp_get_net(dp
));
1455 /* Called with ovs_mutex. */
1456 static void __dp_destroy(struct datapath
*dp
)
1460 for (i
= 0; i
< DP_VPORT_HASH_BUCKETS
; i
++) {
1461 struct vport
*vport
;
1462 struct hlist_node
*n
;
1464 hlist_for_each_entry_safe(vport
, n
, &dp
->ports
[i
], dp_hash_node
)
1465 if (vport
->port_no
!= OVSP_LOCAL
)
1466 ovs_dp_detach_port(vport
);
1469 list_del_rcu(&dp
->list_node
);
1471 /* OVSP_LOCAL is datapath internal port. We need to make sure that
1472 * all ports in datapath are destroyed first before freeing datapath.
1474 ovs_dp_detach_port(ovs_vport_ovsl(dp
, OVSP_LOCAL
));
1476 /* RCU destroy the flow table */
1477 ovs_flow_tbl_destroy(&dp
->table
, true);
1479 call_rcu(&dp
->rcu
, destroy_dp_rcu
);
1482 static int ovs_dp_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
1484 struct sk_buff
*reply
;
1485 struct datapath
*dp
;
1488 reply
= ovs_dp_cmd_alloc_info(info
);
1493 dp
= lookup_datapath(sock_net(skb
->sk
), info
->userhdr
, info
->attrs
);
1496 goto err_unlock_free
;
1498 err
= ovs_dp_cmd_fill_info(dp
, reply
, info
->snd_portid
,
1499 info
->snd_seq
, 0, OVS_DP_CMD_DEL
);
1505 ovs_notify(&dp_datapath_genl_family
, reply
, info
);
1515 static int ovs_dp_cmd_set(struct sk_buff
*skb
, struct genl_info
*info
)
1517 struct sk_buff
*reply
;
1518 struct datapath
*dp
;
1521 reply
= ovs_dp_cmd_alloc_info(info
);
1526 dp
= lookup_datapath(sock_net(skb
->sk
), info
->userhdr
, info
->attrs
);
1529 goto err_unlock_free
;
1531 ovs_dp_change(dp
, info
->attrs
);
1533 err
= ovs_dp_cmd_fill_info(dp
, reply
, info
->snd_portid
,
1534 info
->snd_seq
, 0, OVS_DP_CMD_NEW
);
1538 ovs_notify(&dp_datapath_genl_family
, reply
, info
);
1548 static int ovs_dp_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
1550 struct sk_buff
*reply
;
1551 struct datapath
*dp
;
1554 reply
= ovs_dp_cmd_alloc_info(info
);
1559 dp
= lookup_datapath(sock_net(skb
->sk
), info
->userhdr
, info
->attrs
);
1562 goto err_unlock_free
;
1564 err
= ovs_dp_cmd_fill_info(dp
, reply
, info
->snd_portid
,
1565 info
->snd_seq
, 0, OVS_DP_CMD_NEW
);
1569 return genlmsg_reply(reply
, info
);
1577 static int ovs_dp_cmd_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1579 struct ovs_net
*ovs_net
= net_generic(sock_net(skb
->sk
), ovs_net_id
);
1580 struct datapath
*dp
;
1581 int skip
= cb
->args
[0];
1585 list_for_each_entry_rcu(dp
, &ovs_net
->dps
, list_node
) {
1587 ovs_dp_cmd_fill_info(dp
, skb
, NETLINK_CB(cb
->skb
).portid
,
1588 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1589 OVS_DP_CMD_NEW
) < 0)
1600 static const struct nla_policy datapath_policy
[OVS_DP_ATTR_MAX
+ 1] = {
1601 [OVS_DP_ATTR_NAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
- 1 },
1602 [OVS_DP_ATTR_UPCALL_PID
] = { .type
= NLA_U32
},
1603 [OVS_DP_ATTR_USER_FEATURES
] = { .type
= NLA_U32
},
1606 static const struct genl_ops dp_datapath_genl_ops
[] = {
1607 { .cmd
= OVS_DP_CMD_NEW
,
1608 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1609 .policy
= datapath_policy
,
1610 .doit
= ovs_dp_cmd_new
1612 { .cmd
= OVS_DP_CMD_DEL
,
1613 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1614 .policy
= datapath_policy
,
1615 .doit
= ovs_dp_cmd_del
1617 { .cmd
= OVS_DP_CMD_GET
,
1618 .flags
= 0, /* OK for unprivileged users. */
1619 .policy
= datapath_policy
,
1620 .doit
= ovs_dp_cmd_get
,
1621 .dumpit
= ovs_dp_cmd_dump
1623 { .cmd
= OVS_DP_CMD_SET
,
1624 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1625 .policy
= datapath_policy
,
1626 .doit
= ovs_dp_cmd_set
,
1630 static struct genl_family dp_datapath_genl_family
= {
1631 .id
= GENL_ID_GENERATE
,
1632 .hdrsize
= sizeof(struct ovs_header
),
1633 .name
= OVS_DATAPATH_FAMILY
,
1634 .version
= OVS_DATAPATH_VERSION
,
1635 .maxattr
= OVS_DP_ATTR_MAX
,
1637 .parallel_ops
= true,
1638 .ops
= dp_datapath_genl_ops
,
1639 .n_ops
= ARRAY_SIZE(dp_datapath_genl_ops
),
1640 .mcgrps
= &ovs_dp_datapath_multicast_group
,
1644 /* Called with ovs_mutex or RCU read lock. */
1645 static int ovs_vport_cmd_fill_info(struct vport
*vport
, struct sk_buff
*skb
,
1646 u32 portid
, u32 seq
, u32 flags
, u8 cmd
)
1648 struct ovs_header
*ovs_header
;
1649 struct ovs_vport_stats vport_stats
;
1652 ovs_header
= genlmsg_put(skb
, portid
, seq
, &dp_vport_genl_family
,
1657 ovs_header
->dp_ifindex
= get_dpifindex(vport
->dp
);
1659 if (nla_put_u32(skb
, OVS_VPORT_ATTR_PORT_NO
, vport
->port_no
) ||
1660 nla_put_u32(skb
, OVS_VPORT_ATTR_TYPE
, vport
->ops
->type
) ||
1661 nla_put_string(skb
, OVS_VPORT_ATTR_NAME
,
1662 vport
->ops
->get_name(vport
)))
1663 goto nla_put_failure
;
1665 ovs_vport_get_stats(vport
, &vport_stats
);
1666 if (nla_put(skb
, OVS_VPORT_ATTR_STATS
, sizeof(struct ovs_vport_stats
),
1668 goto nla_put_failure
;
1670 if (ovs_vport_get_upcall_portids(vport
, skb
))
1671 goto nla_put_failure
;
1673 err
= ovs_vport_get_options(vport
, skb
);
1674 if (err
== -EMSGSIZE
)
1677 return genlmsg_end(skb
, ovs_header
);
1682 genlmsg_cancel(skb
, ovs_header
);
1686 static struct sk_buff
*ovs_vport_cmd_alloc_info(void)
1688 return nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1691 /* Called with ovs_mutex, only via ovs_dp_notify_wq(). */
1692 struct sk_buff
*ovs_vport_cmd_build_info(struct vport
*vport
, u32 portid
,
1695 struct sk_buff
*skb
;
1698 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
1700 return ERR_PTR(-ENOMEM
);
1702 retval
= ovs_vport_cmd_fill_info(vport
, skb
, portid
, seq
, 0, cmd
);
1708 /* Called with ovs_mutex or RCU read lock. */
1709 static struct vport
*lookup_vport(struct net
*net
,
1710 struct ovs_header
*ovs_header
,
1711 struct nlattr
*a
[OVS_VPORT_ATTR_MAX
+ 1])
1713 struct datapath
*dp
;
1714 struct vport
*vport
;
1716 if (a
[OVS_VPORT_ATTR_NAME
]) {
1717 vport
= ovs_vport_locate(net
, nla_data(a
[OVS_VPORT_ATTR_NAME
]));
1719 return ERR_PTR(-ENODEV
);
1720 if (ovs_header
->dp_ifindex
&&
1721 ovs_header
->dp_ifindex
!= get_dpifindex(vport
->dp
))
1722 return ERR_PTR(-ENODEV
);
1724 } else if (a
[OVS_VPORT_ATTR_PORT_NO
]) {
1725 u32 port_no
= nla_get_u32(a
[OVS_VPORT_ATTR_PORT_NO
]);
1727 if (port_no
>= DP_MAX_PORTS
)
1728 return ERR_PTR(-EFBIG
);
1730 dp
= get_dp(net
, ovs_header
->dp_ifindex
);
1732 return ERR_PTR(-ENODEV
);
1734 vport
= ovs_vport_ovsl_rcu(dp
, port_no
);
1736 return ERR_PTR(-ENODEV
);
1739 return ERR_PTR(-EINVAL
);
1742 static int ovs_vport_cmd_new(struct sk_buff
*skb
, struct genl_info
*info
)
1744 struct nlattr
**a
= info
->attrs
;
1745 struct ovs_header
*ovs_header
= info
->userhdr
;
1746 struct vport_parms parms
;
1747 struct sk_buff
*reply
;
1748 struct vport
*vport
;
1749 struct datapath
*dp
;
1753 if (!a
[OVS_VPORT_ATTR_NAME
] || !a
[OVS_VPORT_ATTR_TYPE
] ||
1754 !a
[OVS_VPORT_ATTR_UPCALL_PID
])
1757 port_no
= a
[OVS_VPORT_ATTR_PORT_NO
]
1758 ? nla_get_u32(a
[OVS_VPORT_ATTR_PORT_NO
]) : 0;
1759 if (port_no
>= DP_MAX_PORTS
)
1762 reply
= ovs_vport_cmd_alloc_info();
1767 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
1770 goto exit_unlock_free
;
1773 vport
= ovs_vport_ovsl(dp
, port_no
);
1776 goto exit_unlock_free
;
1778 for (port_no
= 1; ; port_no
++) {
1779 if (port_no
>= DP_MAX_PORTS
) {
1781 goto exit_unlock_free
;
1783 vport
= ovs_vport_ovsl(dp
, port_no
);
1789 parms
.name
= nla_data(a
[OVS_VPORT_ATTR_NAME
]);
1790 parms
.type
= nla_get_u32(a
[OVS_VPORT_ATTR_TYPE
]);
1791 parms
.options
= a
[OVS_VPORT_ATTR_OPTIONS
];
1793 parms
.port_no
= port_no
;
1794 parms
.upcall_portids
= a
[OVS_VPORT_ATTR_UPCALL_PID
];
1796 vport
= new_vport(&parms
);
1797 err
= PTR_ERR(vport
);
1799 goto exit_unlock_free
;
1801 err
= ovs_vport_cmd_fill_info(vport
, reply
, info
->snd_portid
,
1802 info
->snd_seq
, 0, OVS_VPORT_CMD_NEW
);
1806 ovs_notify(&dp_vport_genl_family
, reply
, info
);
1815 static int ovs_vport_cmd_set(struct sk_buff
*skb
, struct genl_info
*info
)
1817 struct nlattr
**a
= info
->attrs
;
1818 struct sk_buff
*reply
;
1819 struct vport
*vport
;
1822 reply
= ovs_vport_cmd_alloc_info();
1827 vport
= lookup_vport(sock_net(skb
->sk
), info
->userhdr
, a
);
1828 err
= PTR_ERR(vport
);
1830 goto exit_unlock_free
;
1832 if (a
[OVS_VPORT_ATTR_TYPE
] &&
1833 nla_get_u32(a
[OVS_VPORT_ATTR_TYPE
]) != vport
->ops
->type
) {
1835 goto exit_unlock_free
;
1838 if (a
[OVS_VPORT_ATTR_OPTIONS
]) {
1839 err
= ovs_vport_set_options(vport
, a
[OVS_VPORT_ATTR_OPTIONS
]);
1841 goto exit_unlock_free
;
1845 if (a
[OVS_VPORT_ATTR_UPCALL_PID
]) {
1846 struct nlattr
*ids
= a
[OVS_VPORT_ATTR_UPCALL_PID
];
1848 err
= ovs_vport_set_upcall_portids(vport
, ids
);
1850 goto exit_unlock_free
;
1853 err
= ovs_vport_cmd_fill_info(vport
, reply
, info
->snd_portid
,
1854 info
->snd_seq
, 0, OVS_VPORT_CMD_NEW
);
1858 ovs_notify(&dp_vport_genl_family
, reply
, info
);
1867 static int ovs_vport_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
1869 struct nlattr
**a
= info
->attrs
;
1870 struct sk_buff
*reply
;
1871 struct vport
*vport
;
1874 reply
= ovs_vport_cmd_alloc_info();
1879 vport
= lookup_vport(sock_net(skb
->sk
), info
->userhdr
, a
);
1880 err
= PTR_ERR(vport
);
1882 goto exit_unlock_free
;
1884 if (vport
->port_no
== OVSP_LOCAL
) {
1886 goto exit_unlock_free
;
1889 err
= ovs_vport_cmd_fill_info(vport
, reply
, info
->snd_portid
,
1890 info
->snd_seq
, 0, OVS_VPORT_CMD_DEL
);
1892 ovs_dp_detach_port(vport
);
1895 ovs_notify(&dp_vport_genl_family
, reply
, info
);
1904 static int ovs_vport_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
1906 struct nlattr
**a
= info
->attrs
;
1907 struct ovs_header
*ovs_header
= info
->userhdr
;
1908 struct sk_buff
*reply
;
1909 struct vport
*vport
;
1912 reply
= ovs_vport_cmd_alloc_info();
1917 vport
= lookup_vport(sock_net(skb
->sk
), ovs_header
, a
);
1918 err
= PTR_ERR(vport
);
1920 goto exit_unlock_free
;
1921 err
= ovs_vport_cmd_fill_info(vport
, reply
, info
->snd_portid
,
1922 info
->snd_seq
, 0, OVS_VPORT_CMD_NEW
);
1926 return genlmsg_reply(reply
, info
);
1934 static int ovs_vport_cmd_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1936 struct ovs_header
*ovs_header
= genlmsg_data(nlmsg_data(cb
->nlh
));
1937 struct datapath
*dp
;
1938 int bucket
= cb
->args
[0], skip
= cb
->args
[1];
1942 dp
= get_dp(sock_net(skb
->sk
), ovs_header
->dp_ifindex
);
1947 for (i
= bucket
; i
< DP_VPORT_HASH_BUCKETS
; i
++) {
1948 struct vport
*vport
;
1951 hlist_for_each_entry_rcu(vport
, &dp
->ports
[i
], dp_hash_node
) {
1953 ovs_vport_cmd_fill_info(vport
, skb
,
1954 NETLINK_CB(cb
->skb
).portid
,
1957 OVS_VPORT_CMD_NEW
) < 0)
1973 static const struct nla_policy vport_policy
[OVS_VPORT_ATTR_MAX
+ 1] = {
1974 [OVS_VPORT_ATTR_NAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
- 1 },
1975 [OVS_VPORT_ATTR_STATS
] = { .len
= sizeof(struct ovs_vport_stats
) },
1976 [OVS_VPORT_ATTR_PORT_NO
] = { .type
= NLA_U32
},
1977 [OVS_VPORT_ATTR_TYPE
] = { .type
= NLA_U32
},
1978 [OVS_VPORT_ATTR_UPCALL_PID
] = { .type
= NLA_U32
},
1979 [OVS_VPORT_ATTR_OPTIONS
] = { .type
= NLA_NESTED
},
1982 static const struct genl_ops dp_vport_genl_ops
[] = {
1983 { .cmd
= OVS_VPORT_CMD_NEW
,
1984 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1985 .policy
= vport_policy
,
1986 .doit
= ovs_vport_cmd_new
1988 { .cmd
= OVS_VPORT_CMD_DEL
,
1989 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1990 .policy
= vport_policy
,
1991 .doit
= ovs_vport_cmd_del
1993 { .cmd
= OVS_VPORT_CMD_GET
,
1994 .flags
= 0, /* OK for unprivileged users. */
1995 .policy
= vport_policy
,
1996 .doit
= ovs_vport_cmd_get
,
1997 .dumpit
= ovs_vport_cmd_dump
1999 { .cmd
= OVS_VPORT_CMD_SET
,
2000 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
2001 .policy
= vport_policy
,
2002 .doit
= ovs_vport_cmd_set
,
2006 struct genl_family dp_vport_genl_family
= {
2007 .id
= GENL_ID_GENERATE
,
2008 .hdrsize
= sizeof(struct ovs_header
),
2009 .name
= OVS_VPORT_FAMILY
,
2010 .version
= OVS_VPORT_VERSION
,
2011 .maxattr
= OVS_VPORT_ATTR_MAX
,
2013 .parallel_ops
= true,
2014 .ops
= dp_vport_genl_ops
,
2015 .n_ops
= ARRAY_SIZE(dp_vport_genl_ops
),
2016 .mcgrps
= &ovs_dp_vport_multicast_group
,
2020 static struct genl_family
* const dp_genl_families
[] = {
2021 &dp_datapath_genl_family
,
2022 &dp_vport_genl_family
,
2023 &dp_flow_genl_family
,
2024 &dp_packet_genl_family
,
2027 static void dp_unregister_genl(int n_families
)
2031 for (i
= 0; i
< n_families
; i
++)
2032 genl_unregister_family(dp_genl_families
[i
]);
2035 static int dp_register_genl(void)
2040 for (i
= 0; i
< ARRAY_SIZE(dp_genl_families
); i
++) {
2042 err
= genl_register_family(dp_genl_families
[i
]);
2050 dp_unregister_genl(i
);
2054 static int __net_init
ovs_init_net(struct net
*net
)
2056 struct ovs_net
*ovs_net
= net_generic(net
, ovs_net_id
);
2058 INIT_LIST_HEAD(&ovs_net
->dps
);
2059 INIT_WORK(&ovs_net
->dp_notify_work
, ovs_dp_notify_wq
);
2063 static void __net_exit
ovs_exit_net(struct net
*net
)
2065 struct datapath
*dp
, *dp_next
;
2066 struct ovs_net
*ovs_net
= net_generic(net
, ovs_net_id
);
2069 list_for_each_entry_safe(dp
, dp_next
, &ovs_net
->dps
, list_node
)
2073 cancel_work_sync(&ovs_net
->dp_notify_work
);
2076 static struct pernet_operations ovs_net_ops
= {
2077 .init
= ovs_init_net
,
2078 .exit
= ovs_exit_net
,
2080 .size
= sizeof(struct ovs_net
),
2083 static int __init
dp_init(void)
2087 BUILD_BUG_ON(sizeof(struct ovs_skb_cb
) > FIELD_SIZEOF(struct sk_buff
, cb
));
2089 pr_info("Open vSwitch switching datapath\n");
2091 err
= action_fifos_init();
2095 err
= ovs_internal_dev_rtnl_link_register();
2097 goto error_action_fifos_exit
;
2099 err
= ovs_flow_init();
2101 goto error_unreg_rtnl_link
;
2103 err
= ovs_vport_init();
2105 goto error_flow_exit
;
2107 err
= register_pernet_device(&ovs_net_ops
);
2109 goto error_vport_exit
;
2111 err
= register_netdevice_notifier(&ovs_dp_device_notifier
);
2113 goto error_netns_exit
;
2115 err
= dp_register_genl();
2117 goto error_unreg_notifier
;
2121 error_unreg_notifier
:
2122 unregister_netdevice_notifier(&ovs_dp_device_notifier
);
2124 unregister_pernet_device(&ovs_net_ops
);
2129 error_unreg_rtnl_link
:
2130 ovs_internal_dev_rtnl_link_unregister();
2131 error_action_fifos_exit
:
2132 action_fifos_exit();
2137 static void dp_cleanup(void)
2139 dp_unregister_genl(ARRAY_SIZE(dp_genl_families
));
2140 unregister_netdevice_notifier(&ovs_dp_device_notifier
);
2141 unregister_pernet_device(&ovs_net_ops
);
2145 ovs_internal_dev_rtnl_link_unregister();
2146 action_fifos_exit();
2149 module_init(dp_init
);
2150 module_exit(dp_cleanup
);
2152 MODULE_DESCRIPTION("Open vSwitch switching datapath");
2153 MODULE_LICENSE("GPL");