2 * Copyright (c) 2007-2012 Nicira Networks.
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 <linux/workqueue.h>
51 #include <net/genetlink.h>
55 #include "vport-internal_dev.h"
60 * Writes to device state (add/remove datapath, port, set operations on vports,
61 * etc.) are protected by RTNL.
63 * Writes to other state (flow table modifications, set miscellaneous datapath
64 * parameters, etc.) are protected by genl_mutex. The RTNL lock nests inside
67 * Reads are protected by RCU.
69 * There are a few special cases (mostly stats) that have their own
70 * synchronization but they nest under all of above and don't interact with
74 /* Global list of datapaths to enable dumping them all out.
75 * Protected by genl_mutex.
77 static LIST_HEAD(dps
);
79 #define REHASH_FLOW_INTERVAL (10 * 60 * HZ)
80 static void rehash_flow_table(struct work_struct
*work
);
81 static DECLARE_DELAYED_WORK(rehash_flow_wq
, rehash_flow_table
);
83 static struct vport
*new_vport(const struct vport_parms
*);
84 static int queue_gso_packets(int dp_ifindex
, struct sk_buff
*,
85 const struct dp_upcall_info
*);
86 static int queue_userspace_packet(int dp_ifindex
, struct sk_buff
*,
87 const struct dp_upcall_info
*);
89 /* Must be called with rcu_read_lock, genl_mutex, or RTNL lock. */
90 static struct datapath
*get_dp(int dp_ifindex
)
92 struct datapath
*dp
= NULL
;
93 struct net_device
*dev
;
96 dev
= dev_get_by_index_rcu(&init_net
, dp_ifindex
);
98 struct vport
*vport
= ovs_internal_dev_get_vport(dev
);
107 /* Must be called with rcu_read_lock or RTNL lock. */
108 const char *ovs_dp_name(const struct datapath
*dp
)
110 struct vport
*vport
= rcu_dereference_rtnl(dp
->ports
[OVSP_LOCAL
]);
111 return vport
->ops
->get_name(vport
);
114 static int get_dpifindex(struct datapath
*dp
)
121 local
= rcu_dereference(dp
->ports
[OVSP_LOCAL
]);
123 ifindex
= local
->ops
->get_ifindex(local
);
132 static void destroy_dp_rcu(struct rcu_head
*rcu
)
134 struct datapath
*dp
= container_of(rcu
, struct datapath
, rcu
);
136 ovs_flow_tbl_destroy((__force
struct flow_table
*)dp
->table
);
137 free_percpu(dp
->stats_percpu
);
141 /* Called with RTNL lock and genl_lock. */
142 static struct vport
*new_vport(const struct vport_parms
*parms
)
146 vport
= ovs_vport_add(parms
);
147 if (!IS_ERR(vport
)) {
148 struct datapath
*dp
= parms
->dp
;
150 rcu_assign_pointer(dp
->ports
[parms
->port_no
], vport
);
151 list_add(&vport
->node
, &dp
->port_list
);
157 /* Called with RTNL lock. */
158 void ovs_dp_detach_port(struct vport
*p
)
162 /* First drop references to device. */
164 rcu_assign_pointer(p
->dp
->ports
[p
->port_no
], NULL
);
166 /* Then destroy it. */
170 /* Must be called with rcu_read_lock. */
171 void ovs_dp_process_received_packet(struct vport
*p
, struct sk_buff
*skb
)
173 struct datapath
*dp
= p
->dp
;
174 struct sw_flow
*flow
;
175 struct dp_stats_percpu
*stats
;
176 struct sw_flow_key key
;
181 stats
= per_cpu_ptr(dp
->stats_percpu
, smp_processor_id());
183 /* Extract flow from 'skb' into 'key'. */
184 error
= ovs_flow_extract(skb
, p
->port_no
, &key
, &key_len
);
185 if (unlikely(error
)) {
191 flow
= ovs_flow_tbl_lookup(rcu_dereference(dp
->table
), &key
, key_len
);
192 if (unlikely(!flow
)) {
193 struct dp_upcall_info upcall
;
195 upcall
.cmd
= OVS_PACKET_CMD_MISS
;
197 upcall
.userdata
= NULL
;
198 upcall
.pid
= p
->upcall_pid
;
199 ovs_dp_upcall(dp
, skb
, &upcall
);
201 stats_counter
= &stats
->n_missed
;
205 OVS_CB(skb
)->flow
= flow
;
207 stats_counter
= &stats
->n_hit
;
208 ovs_flow_used(OVS_CB(skb
)->flow
, skb
);
209 ovs_execute_actions(dp
, skb
);
212 /* Update datapath statistics. */
213 u64_stats_update_begin(&stats
->sync
);
215 u64_stats_update_end(&stats
->sync
);
218 static struct genl_family dp_packet_genl_family
= {
219 .id
= GENL_ID_GENERATE
,
220 .hdrsize
= sizeof(struct ovs_header
),
221 .name
= OVS_PACKET_FAMILY
,
222 .version
= OVS_PACKET_VERSION
,
223 .maxattr
= OVS_PACKET_ATTR_MAX
226 int ovs_dp_upcall(struct datapath
*dp
, struct sk_buff
*skb
,
227 const struct dp_upcall_info
*upcall_info
)
229 struct dp_stats_percpu
*stats
;
233 if (upcall_info
->pid
== 0) {
238 dp_ifindex
= get_dpifindex(dp
);
244 if (!skb_is_gso(skb
))
245 err
= queue_userspace_packet(dp_ifindex
, skb
, upcall_info
);
247 err
= queue_gso_packets(dp_ifindex
, skb
, upcall_info
);
254 stats
= per_cpu_ptr(dp
->stats_percpu
, smp_processor_id());
256 u64_stats_update_begin(&stats
->sync
);
258 u64_stats_update_end(&stats
->sync
);
263 static int queue_gso_packets(int dp_ifindex
, struct sk_buff
*skb
,
264 const struct dp_upcall_info
*upcall_info
)
266 struct dp_upcall_info later_info
;
267 struct sw_flow_key later_key
;
268 struct sk_buff
*segs
, *nskb
;
271 segs
= skb_gso_segment(skb
, NETIF_F_SG
| NETIF_F_HW_CSUM
);
275 /* Queue all of the segments. */
278 err
= queue_userspace_packet(dp_ifindex
, skb
, upcall_info
);
282 if (skb
== segs
&& skb_shinfo(skb
)->gso_type
& SKB_GSO_UDP
) {
283 /* The initial flow key extracted by ovs_flow_extract()
284 * in this case is for a first fragment, so we need to
285 * properly mark later fragments.
287 later_key
= *upcall_info
->key
;
288 later_key
.ip
.frag
= OVS_FRAG_TYPE_LATER
;
290 later_info
= *upcall_info
;
291 later_info
.key
= &later_key
;
292 upcall_info
= &later_info
;
294 } while ((skb
= skb
->next
));
296 /* Free all of the segments. */
304 } while ((skb
= nskb
));
308 static int queue_userspace_packet(int dp_ifindex
, struct sk_buff
*skb
,
309 const struct dp_upcall_info
*upcall_info
)
311 struct ovs_header
*upcall
;
312 struct sk_buff
*nskb
= NULL
;
313 struct sk_buff
*user_skb
; /* to be queued to userspace */
318 if (vlan_tx_tag_present(skb
)) {
319 nskb
= skb_clone(skb
, GFP_ATOMIC
);
323 nskb
= __vlan_put_tag(nskb
, vlan_tx_tag_get(nskb
));
331 if (nla_attr_size(skb
->len
) > USHRT_MAX
) {
336 len
= sizeof(struct ovs_header
);
337 len
+= nla_total_size(skb
->len
);
338 len
+= nla_total_size(FLOW_BUFSIZE
);
339 if (upcall_info
->cmd
== OVS_PACKET_CMD_ACTION
)
340 len
+= nla_total_size(8);
342 user_skb
= genlmsg_new(len
, GFP_ATOMIC
);
348 upcall
= genlmsg_put(user_skb
, 0, 0, &dp_packet_genl_family
,
349 0, upcall_info
->cmd
);
350 upcall
->dp_ifindex
= dp_ifindex
;
352 nla
= nla_nest_start(user_skb
, OVS_PACKET_ATTR_KEY
);
353 ovs_flow_to_nlattrs(upcall_info
->key
, user_skb
);
354 nla_nest_end(user_skb
, nla
);
356 if (upcall_info
->userdata
)
357 nla_put_u64(user_skb
, OVS_PACKET_ATTR_USERDATA
,
358 nla_get_u64(upcall_info
->userdata
));
360 nla
= __nla_reserve(user_skb
, OVS_PACKET_ATTR_PACKET
, skb
->len
);
362 skb_copy_and_csum_dev(skb
, nla_data(nla
));
364 err
= genlmsg_unicast(&init_net
, user_skb
, upcall_info
->pid
);
371 /* Called with genl_mutex. */
372 static int flush_flows(int dp_ifindex
)
374 struct flow_table
*old_table
;
375 struct flow_table
*new_table
;
378 dp
= get_dp(dp_ifindex
);
382 old_table
= genl_dereference(dp
->table
);
383 new_table
= ovs_flow_tbl_alloc(TBL_MIN_BUCKETS
);
387 rcu_assign_pointer(dp
->table
, new_table
);
389 ovs_flow_tbl_deferred_destroy(old_table
);
393 static int validate_actions(const struct nlattr
*attr
,
394 const struct sw_flow_key
*key
, int depth
);
396 static int validate_sample(const struct nlattr
*attr
,
397 const struct sw_flow_key
*key
, int depth
)
399 const struct nlattr
*attrs
[OVS_SAMPLE_ATTR_MAX
+ 1];
400 const struct nlattr
*probability
, *actions
;
401 const struct nlattr
*a
;
404 memset(attrs
, 0, sizeof(attrs
));
405 nla_for_each_nested(a
, attr
, rem
) {
406 int type
= nla_type(a
);
407 if (!type
|| type
> OVS_SAMPLE_ATTR_MAX
|| attrs
[type
])
414 probability
= attrs
[OVS_SAMPLE_ATTR_PROBABILITY
];
415 if (!probability
|| nla_len(probability
) != sizeof(u32
))
418 actions
= attrs
[OVS_SAMPLE_ATTR_ACTIONS
];
419 if (!actions
|| (nla_len(actions
) && nla_len(actions
) < NLA_HDRLEN
))
421 return validate_actions(actions
, key
, depth
+ 1);
424 static int validate_set(const struct nlattr
*a
,
425 const struct sw_flow_key
*flow_key
)
427 const struct nlattr
*ovs_key
= nla_data(a
);
428 int key_type
= nla_type(ovs_key
);
430 /* There can be only one key in a action */
431 if (nla_total_size(nla_len(ovs_key
)) != nla_len(a
))
434 if (key_type
> OVS_KEY_ATTR_MAX
||
435 nla_len(ovs_key
) != ovs_key_lens
[key_type
])
439 const struct ovs_key_ipv4
*ipv4_key
;
441 case OVS_KEY_ATTR_PRIORITY
:
442 case OVS_KEY_ATTR_ETHERNET
:
445 case OVS_KEY_ATTR_IPV4
:
446 if (flow_key
->eth
.type
!= htons(ETH_P_IP
))
449 if (!flow_key
->ipv4
.addr
.src
|| !flow_key
->ipv4
.addr
.dst
)
452 ipv4_key
= nla_data(ovs_key
);
453 if (ipv4_key
->ipv4_proto
!= flow_key
->ip
.proto
)
456 if (ipv4_key
->ipv4_frag
!= flow_key
->ip
.frag
)
461 case OVS_KEY_ATTR_TCP
:
462 if (flow_key
->ip
.proto
!= IPPROTO_TCP
)
465 if (!flow_key
->ipv4
.tp
.src
|| !flow_key
->ipv4
.tp
.dst
)
470 case OVS_KEY_ATTR_UDP
:
471 if (flow_key
->ip
.proto
!= IPPROTO_UDP
)
474 if (!flow_key
->ipv4
.tp
.src
|| !flow_key
->ipv4
.tp
.dst
)
485 static int validate_userspace(const struct nlattr
*attr
)
487 static const struct nla_policy userspace_policy
[OVS_USERSPACE_ATTR_MAX
+ 1] = {
488 [OVS_USERSPACE_ATTR_PID
] = {.type
= NLA_U32
},
489 [OVS_USERSPACE_ATTR_USERDATA
] = {.type
= NLA_U64
},
491 struct nlattr
*a
[OVS_USERSPACE_ATTR_MAX
+ 1];
494 error
= nla_parse_nested(a
, OVS_USERSPACE_ATTR_MAX
,
495 attr
, userspace_policy
);
499 if (!a
[OVS_USERSPACE_ATTR_PID
] ||
500 !nla_get_u32(a
[OVS_USERSPACE_ATTR_PID
]))
506 static int validate_actions(const struct nlattr
*attr
,
507 const struct sw_flow_key
*key
, int depth
)
509 const struct nlattr
*a
;
512 if (depth
>= SAMPLE_ACTION_DEPTH
)
515 nla_for_each_nested(a
, attr
, rem
) {
516 /* Expected argument lengths, (u32)-1 for variable length. */
517 static const u32 action_lens
[OVS_ACTION_ATTR_MAX
+ 1] = {
518 [OVS_ACTION_ATTR_OUTPUT
] = sizeof(u32
),
519 [OVS_ACTION_ATTR_USERSPACE
] = (u32
)-1,
520 [OVS_ACTION_ATTR_PUSH_VLAN
] = sizeof(struct ovs_action_push_vlan
),
521 [OVS_ACTION_ATTR_POP_VLAN
] = 0,
522 [OVS_ACTION_ATTR_SET
] = (u32
)-1,
523 [OVS_ACTION_ATTR_SAMPLE
] = (u32
)-1
525 const struct ovs_action_push_vlan
*vlan
;
526 int type
= nla_type(a
);
528 if (type
> OVS_ACTION_ATTR_MAX
||
529 (action_lens
[type
] != nla_len(a
) &&
530 action_lens
[type
] != (u32
)-1))
534 case OVS_ACTION_ATTR_UNSPEC
:
537 case OVS_ACTION_ATTR_USERSPACE
:
538 err
= validate_userspace(a
);
543 case OVS_ACTION_ATTR_OUTPUT
:
544 if (nla_get_u32(a
) >= DP_MAX_PORTS
)
549 case OVS_ACTION_ATTR_POP_VLAN
:
552 case OVS_ACTION_ATTR_PUSH_VLAN
:
554 if (vlan
->vlan_tpid
!= htons(ETH_P_8021Q
))
556 if (!(vlan
->vlan_tci
& htons(VLAN_TAG_PRESENT
)))
560 case OVS_ACTION_ATTR_SET
:
561 err
= validate_set(a
, key
);
566 case OVS_ACTION_ATTR_SAMPLE
:
567 err
= validate_sample(a
, key
, depth
);
583 static void clear_stats(struct sw_flow
*flow
)
587 flow
->packet_count
= 0;
588 flow
->byte_count
= 0;
591 static int ovs_packet_cmd_execute(struct sk_buff
*skb
, struct genl_info
*info
)
593 struct ovs_header
*ovs_header
= info
->userhdr
;
594 struct nlattr
**a
= info
->attrs
;
595 struct sw_flow_actions
*acts
;
596 struct sk_buff
*packet
;
597 struct sw_flow
*flow
;
605 if (!a
[OVS_PACKET_ATTR_PACKET
] || !a
[OVS_PACKET_ATTR_KEY
] ||
606 !a
[OVS_PACKET_ATTR_ACTIONS
] ||
607 nla_len(a
[OVS_PACKET_ATTR_PACKET
]) < ETH_HLEN
)
610 len
= nla_len(a
[OVS_PACKET_ATTR_PACKET
]);
611 packet
= __dev_alloc_skb(NET_IP_ALIGN
+ len
, GFP_KERNEL
);
615 skb_reserve(packet
, NET_IP_ALIGN
);
617 memcpy(__skb_put(packet
, len
), nla_data(a
[OVS_PACKET_ATTR_PACKET
]), len
);
619 skb_reset_mac_header(packet
);
620 eth
= eth_hdr(packet
);
622 /* Normally, setting the skb 'protocol' field would be handled by a
623 * call to eth_type_trans(), but it assumes there's a sending
624 * device, which we may not have. */
625 if (ntohs(eth
->h_proto
) >= 1536)
626 packet
->protocol
= eth
->h_proto
;
628 packet
->protocol
= htons(ETH_P_802_2
);
630 /* Build an sw_flow for sending this packet. */
631 flow
= ovs_flow_alloc();
636 err
= ovs_flow_extract(packet
, -1, &flow
->key
, &key_len
);
640 err
= ovs_flow_metadata_from_nlattrs(&flow
->key
.phy
.priority
,
641 &flow
->key
.phy
.in_port
,
642 a
[OVS_PACKET_ATTR_KEY
]);
646 err
= validate_actions(a
[OVS_PACKET_ATTR_ACTIONS
], &flow
->key
, 0);
650 flow
->hash
= ovs_flow_hash(&flow
->key
, key_len
);
652 acts
= ovs_flow_actions_alloc(a
[OVS_PACKET_ATTR_ACTIONS
]);
656 rcu_assign_pointer(flow
->sf_acts
, acts
);
658 OVS_CB(packet
)->flow
= flow
;
659 packet
->priority
= flow
->key
.phy
.priority
;
662 dp
= get_dp(ovs_header
->dp_ifindex
);
668 err
= ovs_execute_actions(dp
, packet
);
685 static const struct nla_policy packet_policy
[OVS_PACKET_ATTR_MAX
+ 1] = {
686 [OVS_PACKET_ATTR_PACKET
] = { .type
= NLA_UNSPEC
},
687 [OVS_PACKET_ATTR_KEY
] = { .type
= NLA_NESTED
},
688 [OVS_PACKET_ATTR_ACTIONS
] = { .type
= NLA_NESTED
},
691 static struct genl_ops dp_packet_genl_ops
[] = {
692 { .cmd
= OVS_PACKET_CMD_EXECUTE
,
693 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
694 .policy
= packet_policy
,
695 .doit
= ovs_packet_cmd_execute
699 static void get_dp_stats(struct datapath
*dp
, struct ovs_dp_stats
*stats
)
702 struct flow_table
*table
= genl_dereference(dp
->table
);
704 stats
->n_flows
= ovs_flow_tbl_count(table
);
706 stats
->n_hit
= stats
->n_missed
= stats
->n_lost
= 0;
707 for_each_possible_cpu(i
) {
708 const struct dp_stats_percpu
*percpu_stats
;
709 struct dp_stats_percpu local_stats
;
712 percpu_stats
= per_cpu_ptr(dp
->stats_percpu
, i
);
715 start
= u64_stats_fetch_begin_bh(&percpu_stats
->sync
);
716 local_stats
= *percpu_stats
;
717 } while (u64_stats_fetch_retry_bh(&percpu_stats
->sync
, start
));
719 stats
->n_hit
+= local_stats
.n_hit
;
720 stats
->n_missed
+= local_stats
.n_missed
;
721 stats
->n_lost
+= local_stats
.n_lost
;
725 static const struct nla_policy flow_policy
[OVS_FLOW_ATTR_MAX
+ 1] = {
726 [OVS_FLOW_ATTR_KEY
] = { .type
= NLA_NESTED
},
727 [OVS_FLOW_ATTR_ACTIONS
] = { .type
= NLA_NESTED
},
728 [OVS_FLOW_ATTR_CLEAR
] = { .type
= NLA_FLAG
},
731 static struct genl_family dp_flow_genl_family
= {
732 .id
= GENL_ID_GENERATE
,
733 .hdrsize
= sizeof(struct ovs_header
),
734 .name
= OVS_FLOW_FAMILY
,
735 .version
= OVS_FLOW_VERSION
,
736 .maxattr
= OVS_FLOW_ATTR_MAX
739 static struct genl_multicast_group ovs_dp_flow_multicast_group
= {
740 .name
= OVS_FLOW_MCGROUP
743 /* Called with genl_lock. */
744 static int ovs_flow_cmd_fill_info(struct sw_flow
*flow
, struct datapath
*dp
,
745 struct sk_buff
*skb
, u32 pid
,
746 u32 seq
, u32 flags
, u8 cmd
)
748 const int skb_orig_len
= skb
->len
;
749 const struct sw_flow_actions
*sf_acts
;
750 struct ovs_flow_stats stats
;
751 struct ovs_header
*ovs_header
;
757 sf_acts
= rcu_dereference_protected(flow
->sf_acts
,
758 lockdep_genl_is_held());
760 ovs_header
= genlmsg_put(skb
, pid
, seq
, &dp_flow_genl_family
, flags
, cmd
);
764 ovs_header
->dp_ifindex
= get_dpifindex(dp
);
766 nla
= nla_nest_start(skb
, OVS_FLOW_ATTR_KEY
);
768 goto nla_put_failure
;
769 err
= ovs_flow_to_nlattrs(&flow
->key
, skb
);
772 nla_nest_end(skb
, nla
);
774 spin_lock_bh(&flow
->lock
);
776 stats
.n_packets
= flow
->packet_count
;
777 stats
.n_bytes
= flow
->byte_count
;
778 tcp_flags
= flow
->tcp_flags
;
779 spin_unlock_bh(&flow
->lock
);
782 NLA_PUT_U64(skb
, OVS_FLOW_ATTR_USED
, ovs_flow_used_time(used
));
785 NLA_PUT(skb
, OVS_FLOW_ATTR_STATS
,
786 sizeof(struct ovs_flow_stats
), &stats
);
789 NLA_PUT_U8(skb
, OVS_FLOW_ATTR_TCP_FLAGS
, tcp_flags
);
791 /* If OVS_FLOW_ATTR_ACTIONS doesn't fit, skip dumping the actions if
792 * this is the first flow to be dumped into 'skb'. This is unusual for
793 * Netlink but individual action lists can be longer than
794 * NLMSG_GOODSIZE and thus entirely undumpable if we didn't do this.
795 * The userspace caller can always fetch the actions separately if it
796 * really wants them. (Most userspace callers in fact don't care.)
798 * This can only fail for dump operations because the skb is always
799 * properly sized for single flows.
801 err
= nla_put(skb
, OVS_FLOW_ATTR_ACTIONS
, sf_acts
->actions_len
,
803 if (err
< 0 && skb_orig_len
)
806 return genlmsg_end(skb
, ovs_header
);
811 genlmsg_cancel(skb
, ovs_header
);
815 static struct sk_buff
*ovs_flow_cmd_alloc_info(struct sw_flow
*flow
)
817 const struct sw_flow_actions
*sf_acts
;
820 sf_acts
= rcu_dereference_protected(flow
->sf_acts
,
821 lockdep_genl_is_held());
823 /* OVS_FLOW_ATTR_KEY */
824 len
= nla_total_size(FLOW_BUFSIZE
);
825 /* OVS_FLOW_ATTR_ACTIONS */
826 len
+= nla_total_size(sf_acts
->actions_len
);
827 /* OVS_FLOW_ATTR_STATS */
828 len
+= nla_total_size(sizeof(struct ovs_flow_stats
));
829 /* OVS_FLOW_ATTR_TCP_FLAGS */
830 len
+= nla_total_size(1);
831 /* OVS_FLOW_ATTR_USED */
832 len
+= nla_total_size(8);
834 len
+= NLMSG_ALIGN(sizeof(struct ovs_header
));
836 return genlmsg_new(len
, GFP_KERNEL
);
839 static struct sk_buff
*ovs_flow_cmd_build_info(struct sw_flow
*flow
,
841 u32 pid
, u32 seq
, u8 cmd
)
846 skb
= ovs_flow_cmd_alloc_info(flow
);
848 return ERR_PTR(-ENOMEM
);
850 retval
= ovs_flow_cmd_fill_info(flow
, dp
, skb
, pid
, seq
, 0, cmd
);
855 static int ovs_flow_cmd_new_or_set(struct sk_buff
*skb
, struct genl_info
*info
)
857 struct nlattr
**a
= info
->attrs
;
858 struct ovs_header
*ovs_header
= info
->userhdr
;
859 struct sw_flow_key key
;
860 struct sw_flow
*flow
;
861 struct sk_buff
*reply
;
863 struct flow_table
*table
;
869 if (!a
[OVS_FLOW_ATTR_KEY
])
871 error
= ovs_flow_from_nlattrs(&key
, &key_len
, a
[OVS_FLOW_ATTR_KEY
]);
875 /* Validate actions. */
876 if (a
[OVS_FLOW_ATTR_ACTIONS
]) {
877 error
= validate_actions(a
[OVS_FLOW_ATTR_ACTIONS
], &key
, 0);
880 } else if (info
->genlhdr
->cmd
== OVS_FLOW_CMD_NEW
) {
885 dp
= get_dp(ovs_header
->dp_ifindex
);
890 table
= genl_dereference(dp
->table
);
891 flow
= ovs_flow_tbl_lookup(table
, &key
, key_len
);
893 struct sw_flow_actions
*acts
;
895 /* Bail out if we're not allowed to create a new flow. */
897 if (info
->genlhdr
->cmd
== OVS_FLOW_CMD_SET
)
900 /* Expand table, if necessary, to make room. */
901 if (ovs_flow_tbl_need_to_expand(table
)) {
902 struct flow_table
*new_table
;
904 new_table
= ovs_flow_tbl_expand(table
);
905 if (!IS_ERR(new_table
)) {
906 rcu_assign_pointer(dp
->table
, new_table
);
907 ovs_flow_tbl_deferred_destroy(table
);
908 table
= genl_dereference(dp
->table
);
913 flow
= ovs_flow_alloc();
915 error
= PTR_ERR(flow
);
921 /* Obtain actions. */
922 acts
= ovs_flow_actions_alloc(a
[OVS_FLOW_ATTR_ACTIONS
]);
923 error
= PTR_ERR(acts
);
925 goto error_free_flow
;
926 rcu_assign_pointer(flow
->sf_acts
, acts
);
928 /* Put flow in bucket. */
929 flow
->hash
= ovs_flow_hash(&key
, key_len
);
930 ovs_flow_tbl_insert(table
, flow
);
932 reply
= ovs_flow_cmd_build_info(flow
, dp
, info
->snd_pid
,
936 /* We found a matching flow. */
937 struct sw_flow_actions
*old_acts
;
938 struct nlattr
*acts_attrs
;
940 /* Bail out if we're not allowed to modify an existing flow.
941 * We accept NLM_F_CREATE in place of the intended NLM_F_EXCL
942 * because Generic Netlink treats the latter as a dump
943 * request. We also accept NLM_F_EXCL in case that bug ever
947 if (info
->genlhdr
->cmd
== OVS_FLOW_CMD_NEW
&&
948 info
->nlhdr
->nlmsg_flags
& (NLM_F_CREATE
| NLM_F_EXCL
))
951 /* Update actions. */
952 old_acts
= rcu_dereference_protected(flow
->sf_acts
,
953 lockdep_genl_is_held());
954 acts_attrs
= a
[OVS_FLOW_ATTR_ACTIONS
];
956 (old_acts
->actions_len
!= nla_len(acts_attrs
) ||
957 memcmp(old_acts
->actions
, nla_data(acts_attrs
),
958 old_acts
->actions_len
))) {
959 struct sw_flow_actions
*new_acts
;
961 new_acts
= ovs_flow_actions_alloc(acts_attrs
);
962 error
= PTR_ERR(new_acts
);
963 if (IS_ERR(new_acts
))
966 rcu_assign_pointer(flow
->sf_acts
, new_acts
);
967 ovs_flow_deferred_free_acts(old_acts
);
970 reply
= ovs_flow_cmd_build_info(flow
, dp
, info
->snd_pid
,
971 info
->snd_seq
, OVS_FLOW_CMD_NEW
);
974 if (a
[OVS_FLOW_ATTR_CLEAR
]) {
975 spin_lock_bh(&flow
->lock
);
977 spin_unlock_bh(&flow
->lock
);
982 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
983 ovs_dp_flow_multicast_group
.id
, info
->nlhdr
,
986 netlink_set_err(init_net
.genl_sock
, 0,
987 ovs_dp_flow_multicast_group
.id
, PTR_ERR(reply
));
996 static int ovs_flow_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
998 struct nlattr
**a
= info
->attrs
;
999 struct ovs_header
*ovs_header
= info
->userhdr
;
1000 struct sw_flow_key key
;
1001 struct sk_buff
*reply
;
1002 struct sw_flow
*flow
;
1003 struct datapath
*dp
;
1004 struct flow_table
*table
;
1008 if (!a
[OVS_FLOW_ATTR_KEY
])
1010 err
= ovs_flow_from_nlattrs(&key
, &key_len
, a
[OVS_FLOW_ATTR_KEY
]);
1014 dp
= get_dp(ovs_header
->dp_ifindex
);
1018 table
= genl_dereference(dp
->table
);
1019 flow
= ovs_flow_tbl_lookup(table
, &key
, key_len
);
1023 reply
= ovs_flow_cmd_build_info(flow
, dp
, info
->snd_pid
,
1024 info
->snd_seq
, OVS_FLOW_CMD_NEW
);
1026 return PTR_ERR(reply
);
1028 return genlmsg_reply(reply
, info
);
1031 static int ovs_flow_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
1033 struct nlattr
**a
= info
->attrs
;
1034 struct ovs_header
*ovs_header
= info
->userhdr
;
1035 struct sw_flow_key key
;
1036 struct sk_buff
*reply
;
1037 struct sw_flow
*flow
;
1038 struct datapath
*dp
;
1039 struct flow_table
*table
;
1043 if (!a
[OVS_FLOW_ATTR_KEY
])
1044 return flush_flows(ovs_header
->dp_ifindex
);
1045 err
= ovs_flow_from_nlattrs(&key
, &key_len
, a
[OVS_FLOW_ATTR_KEY
]);
1049 dp
= get_dp(ovs_header
->dp_ifindex
);
1053 table
= genl_dereference(dp
->table
);
1054 flow
= ovs_flow_tbl_lookup(table
, &key
, key_len
);
1058 reply
= ovs_flow_cmd_alloc_info(flow
);
1062 ovs_flow_tbl_remove(table
, flow
);
1064 err
= ovs_flow_cmd_fill_info(flow
, dp
, reply
, info
->snd_pid
,
1065 info
->snd_seq
, 0, OVS_FLOW_CMD_DEL
);
1068 ovs_flow_deferred_free(flow
);
1070 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1071 ovs_dp_flow_multicast_group
.id
, info
->nlhdr
, GFP_KERNEL
);
1075 static int ovs_flow_cmd_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1077 struct ovs_header
*ovs_header
= genlmsg_data(nlmsg_data(cb
->nlh
));
1078 struct datapath
*dp
;
1079 struct flow_table
*table
;
1081 dp
= get_dp(ovs_header
->dp_ifindex
);
1085 table
= genl_dereference(dp
->table
);
1088 struct sw_flow
*flow
;
1091 bucket
= cb
->args
[0];
1093 flow
= ovs_flow_tbl_next(table
, &bucket
, &obj
);
1097 if (ovs_flow_cmd_fill_info(flow
, dp
, skb
,
1098 NETLINK_CB(cb
->skb
).pid
,
1099 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1100 OVS_FLOW_CMD_NEW
) < 0)
1103 cb
->args
[0] = bucket
;
1109 static struct genl_ops dp_flow_genl_ops
[] = {
1110 { .cmd
= OVS_FLOW_CMD_NEW
,
1111 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1112 .policy
= flow_policy
,
1113 .doit
= ovs_flow_cmd_new_or_set
1115 { .cmd
= OVS_FLOW_CMD_DEL
,
1116 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1117 .policy
= flow_policy
,
1118 .doit
= ovs_flow_cmd_del
1120 { .cmd
= OVS_FLOW_CMD_GET
,
1121 .flags
= 0, /* OK for unprivileged users. */
1122 .policy
= flow_policy
,
1123 .doit
= ovs_flow_cmd_get
,
1124 .dumpit
= ovs_flow_cmd_dump
1126 { .cmd
= OVS_FLOW_CMD_SET
,
1127 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1128 .policy
= flow_policy
,
1129 .doit
= ovs_flow_cmd_new_or_set
,
1133 static const struct nla_policy datapath_policy
[OVS_DP_ATTR_MAX
+ 1] = {
1134 [OVS_DP_ATTR_NAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
- 1 },
1135 [OVS_DP_ATTR_UPCALL_PID
] = { .type
= NLA_U32
},
1138 static struct genl_family dp_datapath_genl_family
= {
1139 .id
= GENL_ID_GENERATE
,
1140 .hdrsize
= sizeof(struct ovs_header
),
1141 .name
= OVS_DATAPATH_FAMILY
,
1142 .version
= OVS_DATAPATH_VERSION
,
1143 .maxattr
= OVS_DP_ATTR_MAX
1146 static struct genl_multicast_group ovs_dp_datapath_multicast_group
= {
1147 .name
= OVS_DATAPATH_MCGROUP
1150 static int ovs_dp_cmd_fill_info(struct datapath
*dp
, struct sk_buff
*skb
,
1151 u32 pid
, u32 seq
, u32 flags
, u8 cmd
)
1153 struct ovs_header
*ovs_header
;
1154 struct ovs_dp_stats dp_stats
;
1157 ovs_header
= genlmsg_put(skb
, pid
, seq
, &dp_datapath_genl_family
,
1162 ovs_header
->dp_ifindex
= get_dpifindex(dp
);
1165 err
= nla_put_string(skb
, OVS_DP_ATTR_NAME
, ovs_dp_name(dp
));
1168 goto nla_put_failure
;
1170 get_dp_stats(dp
, &dp_stats
);
1171 NLA_PUT(skb
, OVS_DP_ATTR_STATS
, sizeof(struct ovs_dp_stats
), &dp_stats
);
1173 return genlmsg_end(skb
, ovs_header
);
1176 genlmsg_cancel(skb
, ovs_header
);
1181 static struct sk_buff
*ovs_dp_cmd_build_info(struct datapath
*dp
, u32 pid
,
1184 struct sk_buff
*skb
;
1187 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1189 return ERR_PTR(-ENOMEM
);
1191 retval
= ovs_dp_cmd_fill_info(dp
, skb
, pid
, seq
, 0, cmd
);
1194 return ERR_PTR(retval
);
1199 /* Called with genl_mutex and optionally with RTNL lock also. */
1200 static struct datapath
*lookup_datapath(struct ovs_header
*ovs_header
,
1201 struct nlattr
*a
[OVS_DP_ATTR_MAX
+ 1])
1203 struct datapath
*dp
;
1205 if (!a
[OVS_DP_ATTR_NAME
])
1206 dp
= get_dp(ovs_header
->dp_ifindex
);
1208 struct vport
*vport
;
1211 vport
= ovs_vport_locate(nla_data(a
[OVS_DP_ATTR_NAME
]));
1212 dp
= vport
&& vport
->port_no
== OVSP_LOCAL
? vport
->dp
: NULL
;
1215 return dp
? dp
: ERR_PTR(-ENODEV
);
1218 static int ovs_dp_cmd_new(struct sk_buff
*skb
, struct genl_info
*info
)
1220 struct nlattr
**a
= info
->attrs
;
1221 struct vport_parms parms
;
1222 struct sk_buff
*reply
;
1223 struct datapath
*dp
;
1224 struct vport
*vport
;
1228 if (!a
[OVS_DP_ATTR_NAME
] || !a
[OVS_DP_ATTR_UPCALL_PID
])
1233 if (!try_module_get(THIS_MODULE
))
1234 goto err_unlock_rtnl
;
1237 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
1239 goto err_put_module
;
1240 INIT_LIST_HEAD(&dp
->port_list
);
1242 /* Allocate table. */
1244 rcu_assign_pointer(dp
->table
, ovs_flow_tbl_alloc(TBL_MIN_BUCKETS
));
1248 dp
->stats_percpu
= alloc_percpu(struct dp_stats_percpu
);
1249 if (!dp
->stats_percpu
) {
1251 goto err_destroy_table
;
1254 /* Set up our datapath device. */
1255 parms
.name
= nla_data(a
[OVS_DP_ATTR_NAME
]);
1256 parms
.type
= OVS_VPORT_TYPE_INTERNAL
;
1257 parms
.options
= NULL
;
1259 parms
.port_no
= OVSP_LOCAL
;
1260 parms
.upcall_pid
= nla_get_u32(a
[OVS_DP_ATTR_UPCALL_PID
]);
1262 vport
= new_vport(&parms
);
1263 if (IS_ERR(vport
)) {
1264 err
= PTR_ERR(vport
);
1268 goto err_destroy_percpu
;
1271 reply
= ovs_dp_cmd_build_info(dp
, info
->snd_pid
,
1272 info
->snd_seq
, OVS_DP_CMD_NEW
);
1273 err
= PTR_ERR(reply
);
1275 goto err_destroy_local_port
;
1277 list_add_tail(&dp
->list_node
, &dps
);
1280 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1281 ovs_dp_datapath_multicast_group
.id
, info
->nlhdr
,
1285 err_destroy_local_port
:
1286 ovs_dp_detach_port(rtnl_dereference(dp
->ports
[OVSP_LOCAL
]));
1288 free_percpu(dp
->stats_percpu
);
1290 ovs_flow_tbl_destroy(genl_dereference(dp
->table
));
1294 module_put(THIS_MODULE
);
1301 static int ovs_dp_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
1303 struct vport
*vport
, *next_vport
;
1304 struct sk_buff
*reply
;
1305 struct datapath
*dp
;
1309 dp
= lookup_datapath(info
->userhdr
, info
->attrs
);
1314 reply
= ovs_dp_cmd_build_info(dp
, info
->snd_pid
,
1315 info
->snd_seq
, OVS_DP_CMD_DEL
);
1316 err
= PTR_ERR(reply
);
1320 list_for_each_entry_safe(vport
, next_vport
, &dp
->port_list
, node
)
1321 if (vport
->port_no
!= OVSP_LOCAL
)
1322 ovs_dp_detach_port(vport
);
1324 list_del(&dp
->list_node
);
1325 ovs_dp_detach_port(rtnl_dereference(dp
->ports
[OVSP_LOCAL
]));
1327 /* rtnl_unlock() will wait until all the references to devices that
1328 * are pending unregistration have been dropped. We do it here to
1329 * ensure that any internal devices (which contain DP pointers) are
1330 * fully destroyed before freeing the datapath.
1334 call_rcu(&dp
->rcu
, destroy_dp_rcu
);
1335 module_put(THIS_MODULE
);
1337 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1338 ovs_dp_datapath_multicast_group
.id
, info
->nlhdr
,
1348 static int ovs_dp_cmd_set(struct sk_buff
*skb
, struct genl_info
*info
)
1350 struct sk_buff
*reply
;
1351 struct datapath
*dp
;
1354 dp
= lookup_datapath(info
->userhdr
, info
->attrs
);
1358 reply
= ovs_dp_cmd_build_info(dp
, info
->snd_pid
,
1359 info
->snd_seq
, OVS_DP_CMD_NEW
);
1360 if (IS_ERR(reply
)) {
1361 err
= PTR_ERR(reply
);
1362 netlink_set_err(init_net
.genl_sock
, 0,
1363 ovs_dp_datapath_multicast_group
.id
, err
);
1367 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1368 ovs_dp_datapath_multicast_group
.id
, info
->nlhdr
,
1374 static int ovs_dp_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
1376 struct sk_buff
*reply
;
1377 struct datapath
*dp
;
1379 dp
= lookup_datapath(info
->userhdr
, info
->attrs
);
1383 reply
= ovs_dp_cmd_build_info(dp
, info
->snd_pid
,
1384 info
->snd_seq
, OVS_DP_CMD_NEW
);
1386 return PTR_ERR(reply
);
1388 return genlmsg_reply(reply
, info
);
1391 static int ovs_dp_cmd_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1393 struct datapath
*dp
;
1394 int skip
= cb
->args
[0];
1397 list_for_each_entry(dp
, &dps
, list_node
) {
1399 ovs_dp_cmd_fill_info(dp
, skb
, NETLINK_CB(cb
->skb
).pid
,
1400 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1401 OVS_DP_CMD_NEW
) < 0)
1411 static struct genl_ops dp_datapath_genl_ops
[] = {
1412 { .cmd
= OVS_DP_CMD_NEW
,
1413 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1414 .policy
= datapath_policy
,
1415 .doit
= ovs_dp_cmd_new
1417 { .cmd
= OVS_DP_CMD_DEL
,
1418 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1419 .policy
= datapath_policy
,
1420 .doit
= ovs_dp_cmd_del
1422 { .cmd
= OVS_DP_CMD_GET
,
1423 .flags
= 0, /* OK for unprivileged users. */
1424 .policy
= datapath_policy
,
1425 .doit
= ovs_dp_cmd_get
,
1426 .dumpit
= ovs_dp_cmd_dump
1428 { .cmd
= OVS_DP_CMD_SET
,
1429 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1430 .policy
= datapath_policy
,
1431 .doit
= ovs_dp_cmd_set
,
1435 static const struct nla_policy vport_policy
[OVS_VPORT_ATTR_MAX
+ 1] = {
1436 [OVS_VPORT_ATTR_NAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
- 1 },
1437 [OVS_VPORT_ATTR_STATS
] = { .len
= sizeof(struct ovs_vport_stats
) },
1438 [OVS_VPORT_ATTR_PORT_NO
] = { .type
= NLA_U32
},
1439 [OVS_VPORT_ATTR_TYPE
] = { .type
= NLA_U32
},
1440 [OVS_VPORT_ATTR_UPCALL_PID
] = { .type
= NLA_U32
},
1441 [OVS_VPORT_ATTR_OPTIONS
] = { .type
= NLA_NESTED
},
1444 static struct genl_family dp_vport_genl_family
= {
1445 .id
= GENL_ID_GENERATE
,
1446 .hdrsize
= sizeof(struct ovs_header
),
1447 .name
= OVS_VPORT_FAMILY
,
1448 .version
= OVS_VPORT_VERSION
,
1449 .maxattr
= OVS_VPORT_ATTR_MAX
1452 struct genl_multicast_group ovs_dp_vport_multicast_group
= {
1453 .name
= OVS_VPORT_MCGROUP
1456 /* Called with RTNL lock or RCU read lock. */
1457 static int ovs_vport_cmd_fill_info(struct vport
*vport
, struct sk_buff
*skb
,
1458 u32 pid
, u32 seq
, u32 flags
, u8 cmd
)
1460 struct ovs_header
*ovs_header
;
1461 struct ovs_vport_stats vport_stats
;
1464 ovs_header
= genlmsg_put(skb
, pid
, seq
, &dp_vport_genl_family
,
1469 ovs_header
->dp_ifindex
= get_dpifindex(vport
->dp
);
1471 NLA_PUT_U32(skb
, OVS_VPORT_ATTR_PORT_NO
, vport
->port_no
);
1472 NLA_PUT_U32(skb
, OVS_VPORT_ATTR_TYPE
, vport
->ops
->type
);
1473 NLA_PUT_STRING(skb
, OVS_VPORT_ATTR_NAME
, vport
->ops
->get_name(vport
));
1474 NLA_PUT_U32(skb
, OVS_VPORT_ATTR_UPCALL_PID
, vport
->upcall_pid
);
1476 ovs_vport_get_stats(vport
, &vport_stats
);
1477 NLA_PUT(skb
, OVS_VPORT_ATTR_STATS
, sizeof(struct ovs_vport_stats
),
1480 err
= ovs_vport_get_options(vport
, skb
);
1481 if (err
== -EMSGSIZE
)
1484 return genlmsg_end(skb
, ovs_header
);
1489 genlmsg_cancel(skb
, ovs_header
);
1493 /* Called with RTNL lock or RCU read lock. */
1494 struct sk_buff
*ovs_vport_cmd_build_info(struct vport
*vport
, u32 pid
,
1497 struct sk_buff
*skb
;
1500 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
1502 return ERR_PTR(-ENOMEM
);
1504 retval
= ovs_vport_cmd_fill_info(vport
, skb
, pid
, seq
, 0, cmd
);
1507 return ERR_PTR(retval
);
1512 /* Called with RTNL lock or RCU read lock. */
1513 static struct vport
*lookup_vport(struct ovs_header
*ovs_header
,
1514 struct nlattr
*a
[OVS_VPORT_ATTR_MAX
+ 1])
1516 struct datapath
*dp
;
1517 struct vport
*vport
;
1519 if (a
[OVS_VPORT_ATTR_NAME
]) {
1520 vport
= ovs_vport_locate(nla_data(a
[OVS_VPORT_ATTR_NAME
]));
1522 return ERR_PTR(-ENODEV
);
1523 if (ovs_header
->dp_ifindex
&&
1524 ovs_header
->dp_ifindex
!= get_dpifindex(vport
->dp
))
1525 return ERR_PTR(-ENODEV
);
1527 } else if (a
[OVS_VPORT_ATTR_PORT_NO
]) {
1528 u32 port_no
= nla_get_u32(a
[OVS_VPORT_ATTR_PORT_NO
]);
1530 if (port_no
>= DP_MAX_PORTS
)
1531 return ERR_PTR(-EFBIG
);
1533 dp
= get_dp(ovs_header
->dp_ifindex
);
1535 return ERR_PTR(-ENODEV
);
1537 vport
= rcu_dereference_rtnl(dp
->ports
[port_no
]);
1539 return ERR_PTR(-ENOENT
);
1542 return ERR_PTR(-EINVAL
);
1545 static int ovs_vport_cmd_new(struct sk_buff
*skb
, struct genl_info
*info
)
1547 struct nlattr
**a
= info
->attrs
;
1548 struct ovs_header
*ovs_header
= info
->userhdr
;
1549 struct vport_parms parms
;
1550 struct sk_buff
*reply
;
1551 struct vport
*vport
;
1552 struct datapath
*dp
;
1557 if (!a
[OVS_VPORT_ATTR_NAME
] || !a
[OVS_VPORT_ATTR_TYPE
] ||
1558 !a
[OVS_VPORT_ATTR_UPCALL_PID
])
1562 dp
= get_dp(ovs_header
->dp_ifindex
);
1567 if (a
[OVS_VPORT_ATTR_PORT_NO
]) {
1568 port_no
= nla_get_u32(a
[OVS_VPORT_ATTR_PORT_NO
]);
1571 if (port_no
>= DP_MAX_PORTS
)
1574 vport
= rtnl_dereference(dp
->ports
[port_no
]);
1579 for (port_no
= 1; ; port_no
++) {
1580 if (port_no
>= DP_MAX_PORTS
) {
1584 vport
= rtnl_dereference(dp
->ports
[port_no
]);
1590 parms
.name
= nla_data(a
[OVS_VPORT_ATTR_NAME
]);
1591 parms
.type
= nla_get_u32(a
[OVS_VPORT_ATTR_TYPE
]);
1592 parms
.options
= a
[OVS_VPORT_ATTR_OPTIONS
];
1594 parms
.port_no
= port_no
;
1595 parms
.upcall_pid
= nla_get_u32(a
[OVS_VPORT_ATTR_UPCALL_PID
]);
1597 vport
= new_vport(&parms
);
1598 err
= PTR_ERR(vport
);
1602 reply
= ovs_vport_cmd_build_info(vport
, info
->snd_pid
, info
->snd_seq
,
1604 if (IS_ERR(reply
)) {
1605 err
= PTR_ERR(reply
);
1606 ovs_dp_detach_port(vport
);
1609 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1610 ovs_dp_vport_multicast_group
.id
, info
->nlhdr
, GFP_KERNEL
);
1618 static int ovs_vport_cmd_set(struct sk_buff
*skb
, struct genl_info
*info
)
1620 struct nlattr
**a
= info
->attrs
;
1621 struct sk_buff
*reply
;
1622 struct vport
*vport
;
1626 vport
= lookup_vport(info
->userhdr
, a
);
1627 err
= PTR_ERR(vport
);
1632 if (a
[OVS_VPORT_ATTR_TYPE
] &&
1633 nla_get_u32(a
[OVS_VPORT_ATTR_TYPE
]) != vport
->ops
->type
)
1636 if (!err
&& a
[OVS_VPORT_ATTR_OPTIONS
])
1637 err
= ovs_vport_set_options(vport
, a
[OVS_VPORT_ATTR_OPTIONS
]);
1638 if (!err
&& a
[OVS_VPORT_ATTR_UPCALL_PID
])
1639 vport
->upcall_pid
= nla_get_u32(a
[OVS_VPORT_ATTR_UPCALL_PID
]);
1641 reply
= ovs_vport_cmd_build_info(vport
, info
->snd_pid
, info
->snd_seq
,
1643 if (IS_ERR(reply
)) {
1644 err
= PTR_ERR(reply
);
1645 netlink_set_err(init_net
.genl_sock
, 0,
1646 ovs_dp_vport_multicast_group
.id
, err
);
1650 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1651 ovs_dp_vport_multicast_group
.id
, info
->nlhdr
, GFP_KERNEL
);
1658 static int ovs_vport_cmd_del(struct sk_buff
*skb
, struct genl_info
*info
)
1660 struct nlattr
**a
= info
->attrs
;
1661 struct sk_buff
*reply
;
1662 struct vport
*vport
;
1666 vport
= lookup_vport(info
->userhdr
, a
);
1667 err
= PTR_ERR(vport
);
1671 if (vport
->port_no
== OVSP_LOCAL
) {
1676 reply
= ovs_vport_cmd_build_info(vport
, info
->snd_pid
, info
->snd_seq
,
1678 err
= PTR_ERR(reply
);
1682 ovs_dp_detach_port(vport
);
1684 genl_notify(reply
, genl_info_net(info
), info
->snd_pid
,
1685 ovs_dp_vport_multicast_group
.id
, info
->nlhdr
, GFP_KERNEL
);
1692 static int ovs_vport_cmd_get(struct sk_buff
*skb
, struct genl_info
*info
)
1694 struct nlattr
**a
= info
->attrs
;
1695 struct ovs_header
*ovs_header
= info
->userhdr
;
1696 struct sk_buff
*reply
;
1697 struct vport
*vport
;
1701 vport
= lookup_vport(ovs_header
, a
);
1702 err
= PTR_ERR(vport
);
1706 reply
= ovs_vport_cmd_build_info(vport
, info
->snd_pid
, info
->snd_seq
,
1708 err
= PTR_ERR(reply
);
1714 return genlmsg_reply(reply
, info
);
1721 static int ovs_vport_cmd_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1723 struct ovs_header
*ovs_header
= genlmsg_data(nlmsg_data(cb
->nlh
));
1724 struct datapath
*dp
;
1728 dp
= get_dp(ovs_header
->dp_ifindex
);
1733 for (port_no
= cb
->args
[0]; port_no
< DP_MAX_PORTS
; port_no
++) {
1734 struct vport
*vport
;
1736 vport
= rcu_dereference(dp
->ports
[port_no
]);
1740 if (ovs_vport_cmd_fill_info(vport
, skb
, NETLINK_CB(cb
->skb
).pid
,
1741 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1742 OVS_VPORT_CMD_NEW
) < 0)
1747 cb
->args
[0] = port_no
;
1753 static void rehash_flow_table(struct work_struct
*work
)
1755 struct datapath
*dp
;
1759 list_for_each_entry(dp
, &dps
, list_node
) {
1760 struct flow_table
*old_table
= genl_dereference(dp
->table
);
1761 struct flow_table
*new_table
;
1763 new_table
= ovs_flow_tbl_rehash(old_table
);
1764 if (!IS_ERR(new_table
)) {
1765 rcu_assign_pointer(dp
->table
, new_table
);
1766 ovs_flow_tbl_deferred_destroy(old_table
);
1772 schedule_delayed_work(&rehash_flow_wq
, REHASH_FLOW_INTERVAL
);
1775 static struct genl_ops dp_vport_genl_ops
[] = {
1776 { .cmd
= OVS_VPORT_CMD_NEW
,
1777 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1778 .policy
= vport_policy
,
1779 .doit
= ovs_vport_cmd_new
1781 { .cmd
= OVS_VPORT_CMD_DEL
,
1782 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1783 .policy
= vport_policy
,
1784 .doit
= ovs_vport_cmd_del
1786 { .cmd
= OVS_VPORT_CMD_GET
,
1787 .flags
= 0, /* OK for unprivileged users. */
1788 .policy
= vport_policy
,
1789 .doit
= ovs_vport_cmd_get
,
1790 .dumpit
= ovs_vport_cmd_dump
1792 { .cmd
= OVS_VPORT_CMD_SET
,
1793 .flags
= GENL_ADMIN_PERM
, /* Requires CAP_NET_ADMIN privilege. */
1794 .policy
= vport_policy
,
1795 .doit
= ovs_vport_cmd_set
,
1799 struct genl_family_and_ops
{
1800 struct genl_family
*family
;
1801 struct genl_ops
*ops
;
1803 struct genl_multicast_group
*group
;
1806 static const struct genl_family_and_ops dp_genl_families
[] = {
1807 { &dp_datapath_genl_family
,
1808 dp_datapath_genl_ops
, ARRAY_SIZE(dp_datapath_genl_ops
),
1809 &ovs_dp_datapath_multicast_group
},
1810 { &dp_vport_genl_family
,
1811 dp_vport_genl_ops
, ARRAY_SIZE(dp_vport_genl_ops
),
1812 &ovs_dp_vport_multicast_group
},
1813 { &dp_flow_genl_family
,
1814 dp_flow_genl_ops
, ARRAY_SIZE(dp_flow_genl_ops
),
1815 &ovs_dp_flow_multicast_group
},
1816 { &dp_packet_genl_family
,
1817 dp_packet_genl_ops
, ARRAY_SIZE(dp_packet_genl_ops
),
1821 static void dp_unregister_genl(int n_families
)
1825 for (i
= 0; i
< n_families
; i
++)
1826 genl_unregister_family(dp_genl_families
[i
].family
);
1829 static int dp_register_genl(void)
1836 for (i
= 0; i
< ARRAY_SIZE(dp_genl_families
); i
++) {
1837 const struct genl_family_and_ops
*f
= &dp_genl_families
[i
];
1839 err
= genl_register_family_with_ops(f
->family
, f
->ops
,
1846 err
= genl_register_mc_group(f
->family
, f
->group
);
1855 dp_unregister_genl(n_registered
);
1859 static int __init
dp_init(void)
1861 struct sk_buff
*dummy_skb
;
1864 BUILD_BUG_ON(sizeof(struct ovs_skb_cb
) > sizeof(dummy_skb
->cb
));
1866 pr_info("Open vSwitch switching datapath\n");
1868 err
= ovs_flow_init();
1872 err
= ovs_vport_init();
1874 goto error_flow_exit
;
1876 err
= register_netdevice_notifier(&ovs_dp_device_notifier
);
1878 goto error_vport_exit
;
1880 err
= dp_register_genl();
1882 goto error_unreg_notifier
;
1884 schedule_delayed_work(&rehash_flow_wq
, REHASH_FLOW_INTERVAL
);
1888 error_unreg_notifier
:
1889 unregister_netdevice_notifier(&ovs_dp_device_notifier
);
1898 static void dp_cleanup(void)
1900 cancel_delayed_work_sync(&rehash_flow_wq
);
1902 dp_unregister_genl(ARRAY_SIZE(dp_genl_families
));
1903 unregister_netdevice_notifier(&ovs_dp_device_notifier
);
1908 module_init(dp_init
);
1909 module_exit(dp_cleanup
);
1911 MODULE_DESCRIPTION("Open vSwitch switching datapath");
1912 MODULE_LICENSE("GPL");