datapath/datapath.c

   1 /*
   2  * Copyright (c) 2007, 2008, 2009, 2010, 2011 Nicira Networks.
   3  * Distributed under the terms of the GNU GPL version 2.
   4  *
   5  * Significant portions of this file may be copied from parts of the Linux
   6  * kernel, by Linus Torvalds and others.
   7  */
   8
   9 /* Functions for managing the dp interface/device. */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/if_arp.h>
  16 #include <linux/if_vlan.h>
  17 #include <linux/in.h>
  18 #include <linux/ip.h>
  19 #include <linux/jhash.h>
  20 #include <linux/delay.h>
  21 #include <linux/time.h>
  22 #include <linux/etherdevice.h>
  23 #include <linux/genetlink.h>
  24 #include <linux/kernel.h>
  25 #include <linux/kthread.h>
  26 #include <linux/mutex.h>
  27 #include <linux/percpu.h>
  28 #include <linux/rcupdate.h>
  29 #include <linux/tcp.h>
  30 #include <linux/udp.h>
  31 #include <linux/version.h>
  32 #include <linux/ethtool.h>
  33 #include <linux/wait.h>
  34 #include <asm/system.h>
  35 #include <asm/div64.h>
  36 #include <asm/bug.h>
  37 #include <linux/highmem.h>
  38 #include <linux/netfilter_bridge.h>
  39 #include <linux/netfilter_ipv4.h>
  40 #include <linux/inetdevice.h>
  41 #include <linux/list.h>
  42 #include <linux/rculist.h>
  43 #include <linux/dmi.h>
  44 #include <net/inet_ecn.h>
  45 #include <net/genetlink.h>
  46
  47 #include "openvswitch/datapath-protocol.h"
  48 #include "checksum.h"
  49 #include "datapath.h"
  50 #include "actions.h"
  51 #include "flow.h"
  52 #include "vlan.h"
  53 #include "tunnel.h"
  54 #include "vport-internal_dev.h"
  55
  56 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) || \
  57     LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)
  58 #error Kernels before 2.6.18 or after 3.0 are not supported by this version of Open vSwitch.
  59 #endif
  60
  61 int (*dp_ioctl_hook)(struct net_device *dev, struct ifreq *rq, int cmd);
  62 EXPORT_SYMBOL(dp_ioctl_hook);
  63
  64 /**
  65  * DOC: Locking:
  66  *
  67  * Writes to device state (add/remove datapath, port, set operations on vports,
  68  * etc.) are protected by RTNL.
  69  *
  70  * Writes to other state (flow table modifications, set miscellaneous datapath
  71  * parameters such as drop frags, etc.) are protected by genl_mutex.  The RTNL
  72  * lock nests inside genl_mutex.
  73  *
  74  * Reads are protected by RCU.
  75  *
  76  * There are a few special cases (mostly stats) that have their own
  77  * synchronization but they nest under all of above and don't interact with
  78  * each other.
  79  */
  80
  81 /* Global list of datapaths to enable dumping them all out.
  82  * Protected by genl_mutex.
  83  */
  84 static LIST_HEAD(dps);
  85
  86 static struct vport *new_vport(const struct vport_parms *);
  87 static int queue_userspace_packets(struct datapath *, struct sk_buff *,
  88                                  const struct dp_upcall_info *);
  89
  90 /* Must be called with rcu_read_lock, genl_mutex, or RTNL lock. */
  91 struct datapath *get_dp(int dp_ifindex)
  92 {
  93         struct datapath *dp = NULL;
  94         struct net_device *dev;
  95
  96         rcu_read_lock();
  97         dev = dev_get_by_index_rcu(&init_net, dp_ifindex);
  98         if (dev) {
  99                 struct vport *vport = internal_dev_get_vport(dev);
 100                 if (vport)
 101                         dp = vport->dp;
 102         }
 103         rcu_read_unlock();
 104
 105         return dp;
 106 }
 107 EXPORT_SYMBOL_GPL(get_dp);
 108
 109 /* Must be called with genl_mutex. */
 110 static struct flow_table *get_table_protected(struct datapath *dp)
 111 {
 112         return rcu_dereference_protected(dp->table, lockdep_genl_is_held());
 113 }
 114
 115 /* Must be called with rcu_read_lock or RTNL lock. */
 116 static struct vport *get_vport_protected(struct datapath *dp, u16 port_no)
 117 {
 118         return rcu_dereference_rtnl(dp->ports[port_no]);
 119 }
 120
 121 /* Must be called with rcu_read_lock or RTNL lock. */
 122 const char *dp_name(const struct datapath *dp)
 123 {
 124         return vport_get_name(rcu_dereference_rtnl(dp->ports[OVSP_LOCAL]));
 125 }
 126
 127 static int get_dpifindex(struct datapath *dp)
 128 {
 129         struct vport *local;
 130         int ifindex;
 131
 132         rcu_read_lock();
 133
 134         local = get_vport_protected(dp, OVSP_LOCAL);
 135         if (local)
 136                 ifindex = vport_get_ifindex(local);
 137         else
 138                 ifindex = 0;
 139
 140         rcu_read_unlock();
 141
 142         return ifindex;
 143 }
 144
 145 static inline size_t br_nlmsg_size(void)
 146 {
 147         return NLMSG_ALIGN(sizeof(struct ifinfomsg))
 148                + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
 149                + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
 150                + nla_total_size(4) /* IFLA_MASTER */
 151                + nla_total_size(4) /* IFLA_MTU */
 152                + nla_total_size(1); /* IFLA_OPERSTATE */
 153 }
 154
 155 /* Caller must hold RTNL lock. */
 156 static int dp_fill_ifinfo(struct sk_buff *skb,
 157                           const struct vport *port,
 158                           int event, unsigned int flags)
 159 {
 160         struct datapath *dp = port->dp;
 161         int ifindex = vport_get_ifindex(port);
 162         struct ifinfomsg *hdr;
 163         struct nlmsghdr *nlh;
 164
 165         if (ifindex < 0)
 166                 return ifindex;
 167
 168         nlh = nlmsg_put(skb, 0, 0, event, sizeof(*hdr), flags);
 169         if (nlh == NULL)
 170                 return -EMSGSIZE;
 171
 172         hdr = nlmsg_data(nlh);
 173         hdr->ifi_family = AF_BRIDGE;
 174         hdr->__ifi_pad = 0;
 175         hdr->ifi_type = ARPHRD_ETHER;
 176         hdr->ifi_index = ifindex;
 177         hdr->ifi_flags = vport_get_flags(port);
 178         hdr->ifi_change = 0;
 179
 180         NLA_PUT_STRING(skb, IFLA_IFNAME, vport_get_name(port));
 181         NLA_PUT_U32(skb, IFLA_MASTER, get_dpifindex(dp));
 182         NLA_PUT_U32(skb, IFLA_MTU, vport_get_mtu(port));
 183 #ifdef IFLA_OPERSTATE
 184         NLA_PUT_U8(skb, IFLA_OPERSTATE,
 185                    vport_is_running(port)
 186                         ? vport_get_operstate(port)
 187                         : IF_OPER_DOWN);
 188 #endif
 189
 190         NLA_PUT(skb, IFLA_ADDRESS, ETH_ALEN, vport_get_addr(port));
 191
 192         return nlmsg_end(skb, nlh);
 193
 194 nla_put_failure:
 195         nlmsg_cancel(skb, nlh);
 196         return -EMSGSIZE;
 197 }
 198
 199 /* Caller must hold RTNL lock. */
 200 static void dp_ifinfo_notify(int event, struct vport *port)
 201 {
 202         struct sk_buff *skb;
 203         int err = -ENOBUFS;
 204
 205         skb = nlmsg_new(br_nlmsg_size(), GFP_KERNEL);
 206         if (skb == NULL)
 207                 goto errout;
 208
 209         err = dp_fill_ifinfo(skb, port, event, 0);
 210         if (err < 0) {
 211                 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
 212                 WARN_ON(err == -EMSGSIZE);
 213                 kfree_skb(skb);
 214                 goto errout;
 215         }
 216         rtnl_notify(skb, &init_net, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
 217         return;
 218 errout:
 219         if (err < 0)
 220                 rtnl_set_sk_err(&init_net, RTNLGRP_LINK, err);
 221 }
 222
 223 static void release_dp(struct kobject *kobj)
 224 {
 225         struct datapath *dp = container_of(kobj, struct datapath, ifobj);
 226         kfree(dp);
 227 }
 228
 229 static struct kobj_type dp_ktype = {
 230         .release = release_dp
 231 };
 232
 233 static void destroy_dp_rcu(struct rcu_head *rcu)
 234 {
 235         struct datapath *dp = container_of(rcu, struct datapath, rcu);
 236
 237         flow_tbl_destroy(dp->table);
 238         free_percpu(dp->stats_percpu);
 239         kobject_put(&dp->ifobj);
 240 }
 241
 242 /* Called with RTNL lock and genl_lock. */
 243 static struct vport *new_vport(const struct vport_parms *parms)
 244 {
 245         struct vport *vport;
 246
 247         vport = vport_add(parms);
 248         if (!IS_ERR(vport)) {
 249                 struct datapath *dp = parms->dp;
 250
 251                 rcu_assign_pointer(dp->ports[parms->port_no], vport);
 252                 list_add(&vport->node, &dp->port_list);
 253
 254                 dp_ifinfo_notify(RTM_NEWLINK, vport);
 255         }
 256
 257         return vport;
 258 }
 259
 260 /* Called with RTNL lock. */
 261 void dp_detach_port(struct vport *p)
 262 {
 263         ASSERT_RTNL();
 264
 265         if (p->port_no != OVSP_LOCAL)
 266                 dp_sysfs_del_if(p);
 267         dp_ifinfo_notify(RTM_DELLINK, p);
 268
 269         /* First drop references to device. */
 270         list_del(&p->node);
 271         rcu_assign_pointer(p->dp->ports[p->port_no], NULL);
 272
 273         /* Then destroy it. */
 274         vport_del(p);
 275 }
 276
 277 /* Must be called with rcu_read_lock. */
 278 void dp_process_received_packet(struct vport *p, struct sk_buff *skb)
 279 {
 280         struct datapath *dp = p->dp;
 281         struct sw_flow *flow;
 282         struct dp_stats_percpu *stats;
 283         int stats_counter_off;
 284         int error;
 285
 286         OVS_CB(skb)->vport = p;
 287
 288         if (!OVS_CB(skb)->flow) {
 289                 struct sw_flow_key key;
 290                 int key_len;
 291                 bool is_frag;
 292
 293                 /* Extract flow from 'skb' into 'key'. */
 294                 error = flow_extract(skb, p->port_no, &key, &key_len, &is_frag);
 295                 if (unlikely(error)) {
 296                         kfree_skb(skb);
 297                         return;
 298                 }
 299
 300                 if (is_frag && dp->drop_frags) {
 301                         consume_skb(skb);
 302                         stats_counter_off = offsetof(struct dp_stats_percpu, n_frags);
 303                         goto out;
 304                 }
 305
 306                 /* Look up flow. */
 307                 flow = flow_tbl_lookup(rcu_dereference(dp->table), &key, key_len);
 308                 if (unlikely(!flow)) {
 309                         struct dp_upcall_info upcall;
 310
 311                         upcall.cmd = OVS_PACKET_CMD_MISS;
 312                         upcall.key = &key;
 313                         upcall.userdata = 0;
 314                         upcall.sample_pool = 0;
 315                         upcall.actions = NULL;
 316                         upcall.actions_len = 0;
 317                         dp_upcall(dp, skb, &upcall);
 318                         stats_counter_off = offsetof(struct dp_stats_percpu, n_missed);
 319                         goto out;
 320                 }
 321
 322                 OVS_CB(skb)->flow = flow;
 323         }
 324
 325         stats_counter_off = offsetof(struct dp_stats_percpu, n_hit);
 326         flow_used(OVS_CB(skb)->flow, skb);
 327         execute_actions(dp, skb);
 328
 329 out:
 330         /* Update datapath statistics. */
 331         local_bh_disable();
 332         stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 333
 334         write_seqcount_begin(&stats->seqlock);
 335         (*(u64 *)((u8 *)stats + stats_counter_off))++;
 336         write_seqcount_end(&stats->seqlock);
 337
 338         local_bh_enable();
 339 }
 340
 341 static void copy_and_csum_skb(struct sk_buff *skb, void *to)
 342 {
 343         u16 csum_start, csum_offset;
 344         __wsum csum;
 345
 346         get_skb_csum_pointers(skb, &csum_start, &csum_offset);
 347         csum_start -= skb_headroom(skb);
 348
 349         skb_copy_bits(skb, 0, to, csum_start);
 350
 351         csum = skb_copy_and_csum_bits(skb, csum_start, to + csum_start,
 352                                       skb->len - csum_start, 0);
 353         *(__sum16 *)(to + csum_start + csum_offset) = csum_fold(csum);
 354 }
 355
 356 static struct genl_family dp_packet_genl_family = {
 357         .id = GENL_ID_GENERATE,
 358         .hdrsize = sizeof(struct ovs_header),
 359         .name = OVS_PACKET_FAMILY,
 360         .version = 1,
 361         .maxattr = OVS_PACKET_ATTR_MAX
 362 };
 363
 364 /* Generic Netlink multicast groups for upcalls.
 365  *
 366  * We really want three unique multicast groups per datapath, but we can't even
 367  * get one, because genl_register_mc_group() takes genl_lock, which is also
 368  * held during Generic Netlink message processing, so trying to acquire
 369  * multicast groups during OVS_DP_NEW processing deadlocks.  Instead, we
 370  * preallocate a few groups and use them round-robin for datapaths.  Collision
 371  * isn't fatal--multicast listeners should check that the family is the one
 372  * that they want and discard others--but it wastes time and memory to receive
 373  * unwanted messages.
 374  */
 375 #define PACKET_N_MC_GROUPS 16
 376 static struct genl_multicast_group packet_mc_groups[PACKET_N_MC_GROUPS];
 377
 378 static u32 packet_mc_group(int dp_ifindex, u8 cmd)
 379 {
 380         u32 idx;
 381         BUILD_BUG_ON_NOT_POWER_OF_2(PACKET_N_MC_GROUPS);
 382
 383         idx = jhash_2words(dp_ifindex, cmd, 0) & (PACKET_N_MC_GROUPS - 1);
 384         return packet_mc_groups[idx].id;
 385 }
 386
 387 static int packet_register_mc_groups(void)
 388 {
 389         int i;
 390
 391         for (i = 0; i < PACKET_N_MC_GROUPS; i++) {
 392                 struct genl_multicast_group *group = &packet_mc_groups[i];
 393                 int error;
 394
 395                 sprintf(group->name, "packet%d", i);
 396                 error = genl_register_mc_group(&dp_packet_genl_family, group);
 397                 if (error)
 398                         return error;
 399         }
 400         return 0;
 401 }
 402
 403 int dp_upcall(struct datapath *dp, struct sk_buff *skb, const struct dp_upcall_info *upcall_info)
 404 {
 405         struct dp_stats_percpu *stats;
 406         int err;
 407
 408         WARN_ON_ONCE(skb_shared(skb));
 409
 410         forward_ip_summed(skb, true);
 411
 412         /* Break apart GSO packets into their component pieces.  Otherwise
 413          * userspace may try to stuff a 64kB packet into a 1500-byte MTU. */
 414         if (skb_is_gso(skb)) {
 415                 struct sk_buff *nskb = skb_gso_segment(skb, NETIF_F_SG | NETIF_F_HW_CSUM);
 416
 417                 if (IS_ERR(nskb)) {
 418                         kfree_skb(skb);
 419                         err = PTR_ERR(nskb);
 420                         goto err;
 421                 }
 422                 consume_skb(skb);
 423                 skb = nskb;
 424         }
 425
 426         err = queue_userspace_packets(dp, skb, upcall_info);
 427         if (err)
 428                 goto err;
 429
 430         return 0;
 431
 432 err:
 433         local_bh_disable();
 434         stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 435
 436         write_seqcount_begin(&stats->seqlock);
 437         stats->n_lost++;
 438         write_seqcount_end(&stats->seqlock);
 439
 440         local_bh_enable();
 441
 442         return err;
 443 }
 444
 445 /* Send each packet in the 'skb' list to userspace for 'dp' as directed by
 446  * 'upcall_info'.  There will be only one packet unless we broke up a GSO
 447  * packet.
 448  */
 449 static int queue_userspace_packets(struct datapath *dp, struct sk_buff *skb,
 450                                  const struct dp_upcall_info *upcall_info)
 451 {
 452         int dp_ifindex;
 453         u32 group;
 454         struct sk_buff *nskb;
 455         int err;
 456
 457         dp_ifindex = get_dpifindex(dp);
 458         if (!dp_ifindex) {
 459                 err = -ENODEV;
 460                 nskb = skb->next;
 461                 goto err_kfree_skbs;
 462         }
 463
 464         group = packet_mc_group(dp_ifindex, upcall_info->cmd);
 465
 466         do {
 467                 struct ovs_header *upcall;
 468                 struct sk_buff *user_skb; /* to be queued to userspace */
 469                 struct nlattr *nla;
 470                 unsigned int len;
 471
 472                 nskb = skb->next;
 473                 skb->next = NULL;
 474
 475                 err = vlan_deaccel_tag(skb);
 476                 if (unlikely(err))
 477                         goto err_kfree_skbs;
 478
 479                 if (nla_attr_size(skb->len) > USHRT_MAX) {
 480                         err = -EFBIG;
 481                         goto err_kfree_skbs;
 482                 }
 483
 484                 len = sizeof(struct ovs_header);
 485                 len += nla_total_size(skb->len);
 486                 len += nla_total_size(FLOW_BUFSIZE);
 487                 if (upcall_info->userdata)
 488                         len += nla_total_size(8);
 489                 if (upcall_info->sample_pool)
 490                         len += nla_total_size(4);
 491                 if (upcall_info->actions_len)
 492                         len += nla_total_size(upcall_info->actions_len);
 493
 494                 user_skb = genlmsg_new(len, GFP_ATOMIC);
 495                 if (!user_skb) {
 496                         netlink_set_err(INIT_NET_GENL_SOCK, 0, group, -ENOBUFS);
 497                         err = -ENOMEM;
 498                         goto err_kfree_skbs;
 499                 }
 500
 501                 upcall = genlmsg_put(user_skb, 0, 0, &dp_packet_genl_family, 0, upcall_info->cmd);
 502                 upcall->dp_ifindex = dp_ifindex;
 503
 504                 nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_KEY);
 505                 flow_to_nlattrs(upcall_info->key, user_skb);
 506                 nla_nest_end(user_skb, nla);
 507
 508                 if (upcall_info->userdata)
 509                         nla_put_u64(user_skb, OVS_PACKET_ATTR_USERDATA, upcall_info->userdata);
 510                 if (upcall_info->sample_pool)
 511                         nla_put_u32(user_skb, OVS_PACKET_ATTR_SAMPLE_POOL, upcall_info->sample_pool);
 512                 if (upcall_info->actions_len) {
 513                         const struct nlattr *actions = upcall_info->actions;
 514                         u32 actions_len = upcall_info->actions_len;
 515
 516                         nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_ACTIONS);
 517                         memcpy(__skb_put(user_skb, actions_len), actions, actions_len);
 518                         nla_nest_end(user_skb, nla);
 519                 }
 520
 521                 nla = __nla_reserve(user_skb, OVS_PACKET_ATTR_PACKET, skb->len);
 522                 if (skb->ip_summed == CHECKSUM_PARTIAL)
 523                         copy_and_csum_skb(skb, nla_data(nla));
 524                 else
 525                         skb_copy_bits(skb, 0, nla_data(nla), skb->len);
 526
 527                 err = genlmsg_multicast(user_skb, 0, group, GFP_ATOMIC);
 528                 if (err)
 529                         goto err_kfree_skbs;
 530
 531                 consume_skb(skb);
 532                 skb = nskb;
 533         } while (skb);
 534         return 0;
 535
 536 err_kfree_skbs:
 537         kfree_skb(skb);
 538         while ((skb = nskb) != NULL) {
 539                 nskb = skb->next;
 540                 kfree_skb(skb);
 541         }
 542         return err;
 543 }
 544
 545 /* Called with genl_mutex. */
 546 static int flush_flows(int dp_ifindex)
 547 {
 548         struct flow_table *old_table;
 549         struct flow_table *new_table;
 550         struct datapath *dp;
 551
 552         dp = get_dp(dp_ifindex);
 553         if (!dp)
 554                 return -ENODEV;
 555
 556         old_table = get_table_protected(dp);
 557         new_table = flow_tbl_alloc(TBL_MIN_BUCKETS);
 558         if (!new_table)
 559                 return -ENOMEM;
 560
 561         rcu_assign_pointer(dp->table, new_table);
 562
 563         flow_tbl_deferred_destroy(old_table);
 564         return 0;
 565 }
 566
 567 static int validate_actions(const struct nlattr *attr)
 568 {
 569         const struct nlattr *a;
 570         int rem;
 571
 572         nla_for_each_nested(a, attr, rem) {
 573                 static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
 574                         [OVS_ACTION_ATTR_OUTPUT] = 4,
 575                         [OVS_ACTION_ATTR_USERSPACE] = 8,
 576                         [OVS_ACTION_ATTR_PUSH_VLAN] = 2,
 577                         [OVS_ACTION_ATTR_POP_VLAN] = 0,
 578                         [OVS_ACTION_ATTR_SET_DL_SRC] = ETH_ALEN,
 579                         [OVS_ACTION_ATTR_SET_DL_DST] = ETH_ALEN,
 580                         [OVS_ACTION_ATTR_SET_NW_SRC] = 4,
 581                         [OVS_ACTION_ATTR_SET_NW_DST] = 4,
 582                         [OVS_ACTION_ATTR_SET_NW_TOS] = 1,
 583                         [OVS_ACTION_ATTR_SET_TP_SRC] = 2,
 584                         [OVS_ACTION_ATTR_SET_TP_DST] = 2,
 585                         [OVS_ACTION_ATTR_SET_TUNNEL] = 8,
 586                         [OVS_ACTION_ATTR_SET_PRIORITY] = 4,
 587                         [OVS_ACTION_ATTR_POP_PRIORITY] = 0,
 588                 };
 589                 int type = nla_type(a);
 590
 591                 if (type > OVS_ACTION_ATTR_MAX || nla_len(a) != action_lens[type])
 592                         return -EINVAL;
 593
 594                 switch (type) {
 595                 case OVS_ACTION_ATTR_UNSPEC:
 596                         return -EINVAL;
 597
 598                 case OVS_ACTION_ATTR_USERSPACE:
 599                 case OVS_ACTION_ATTR_POP_VLAN:
 600                 case OVS_ACTION_ATTR_SET_DL_SRC:
 601                 case OVS_ACTION_ATTR_SET_DL_DST:
 602                 case OVS_ACTION_ATTR_SET_NW_SRC:
 603                 case OVS_ACTION_ATTR_SET_NW_DST:
 604                 case OVS_ACTION_ATTR_SET_TP_SRC:
 605                 case OVS_ACTION_ATTR_SET_TP_DST:
 606                 case OVS_ACTION_ATTR_SET_TUNNEL:
 607                 case OVS_ACTION_ATTR_SET_PRIORITY:
 608                 case OVS_ACTION_ATTR_POP_PRIORITY:
 609                         /* No validation needed. */
 610                         break;
 611
 612                 case OVS_ACTION_ATTR_OUTPUT:
 613                         if (nla_get_u32(a) >= DP_MAX_PORTS)
 614                                 return -EINVAL;
 615                         break;
 616
 617                 case OVS_ACTION_ATTR_PUSH_VLAN:
 618                         if (nla_get_be16(a) & htons(VLAN_CFI_MASK))
 619                                 return -EINVAL;
 620                         break;
 621
 622                 case OVS_ACTION_ATTR_SET_NW_TOS:
 623                         if (nla_get_u8(a) & INET_ECN_MASK)
 624                                 return -EINVAL;
 625                         break;
 626
 627                 default:
 628                         return -EOPNOTSUPP;
 629                 }
 630         }
 631
 632         if (rem > 0)
 633                 return -EINVAL;
 634
 635         return 0;
 636 }
 637 static void clear_stats(struct sw_flow *flow)
 638 {
 639         flow->used = 0;
 640         flow->tcp_flags = 0;
 641         flow->packet_count = 0;
 642         flow->byte_count = 0;
 643 }
 644
 645 static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
 646 {
 647         struct ovs_header *ovs_header = info->userhdr;
 648         struct nlattr **a = info->attrs;
 649         struct sw_flow_actions *acts;
 650         struct sk_buff *packet;
 651         struct sw_flow *flow;
 652         struct datapath *dp;
 653         struct ethhdr *eth;
 654         bool is_frag;
 655         int len;
 656         int err;
 657         int key_len;
 658
 659         err = -EINVAL;
 660         if (!a[OVS_PACKET_ATTR_PACKET] || !a[OVS_PACKET_ATTR_KEY] ||
 661             !a[OVS_PACKET_ATTR_ACTIONS] ||
 662             nla_len(a[OVS_PACKET_ATTR_PACKET]) < ETH_HLEN)
 663                 goto err;
 664
 665         err = validate_actions(a[OVS_PACKET_ATTR_ACTIONS]);
 666         if (err)
 667                 goto err;
 668
 669         len = nla_len(a[OVS_PACKET_ATTR_PACKET]);
 670         packet = __dev_alloc_skb(NET_IP_ALIGN + len, GFP_KERNEL);
 671         err = -ENOMEM;
 672         if (!packet)
 673                 goto err;
 674         skb_reserve(packet, NET_IP_ALIGN);
 675
 676         memcpy(__skb_put(packet, len), nla_data(a[OVS_PACKET_ATTR_PACKET]), len);
 677
 678         skb_reset_mac_header(packet);
 679         eth = eth_hdr(packet);
 680
 681         /* Normally, setting the skb 'protocol' field would be handled by a
 682          * call to eth_type_trans(), but it assumes there's a sending
 683          * device, which we may not have. */
 684         if (ntohs(eth->h_proto) >= 1536)
 685                 packet->protocol = eth->h_proto;
 686         else
 687                 packet->protocol = htons(ETH_P_802_2);
 688
 689         /* Build an sw_flow for sending this packet. */
 690         flow = flow_alloc();
 691         err = PTR_ERR(flow);
 692         if (IS_ERR(flow))
 693                 goto err_kfree_skb;
 694
 695         err = flow_extract(packet, -1, &flow->key, &key_len, &is_frag);
 696         if (err)
 697                 goto err_flow_put;
 698
 699         err = flow_metadata_from_nlattrs(&flow->key.eth.in_port,
 700                                          &flow->key.eth.tun_id,
 701                                          a[OVS_PACKET_ATTR_KEY]);
 702         if (err)
 703                 goto err_flow_put;
 704
 705         flow->hash = flow_hash(&flow->key, key_len);
 706
 707         acts = flow_actions_alloc(a[OVS_PACKET_ATTR_ACTIONS]);
 708         err = PTR_ERR(acts);
 709         if (IS_ERR(acts))
 710                 goto err_flow_put;
 711         rcu_assign_pointer(flow->sf_acts, acts);
 712
 713         OVS_CB(packet)->flow = flow;
 714
 715         rcu_read_lock();
 716         dp = get_dp(ovs_header->dp_ifindex);
 717         err = -ENODEV;
 718         if (!dp)
 719                 goto err_unlock;
 720
 721         if (flow->key.eth.in_port < DP_MAX_PORTS)
 722                 OVS_CB(packet)->vport = get_vport_protected(dp,
 723                                                         flow->key.eth.in_port);
 724
 725         err = execute_actions(dp, packet);
 726         rcu_read_unlock();
 727
 728         flow_put(flow);
 729         return err;
 730
 731 err_unlock:
 732         rcu_read_unlock();
 733 err_flow_put:
 734         flow_put(flow);
 735 err_kfree_skb:
 736         kfree_skb(packet);
 737 err:
 738         return err;
 739 }
 740
 741 static const struct nla_policy packet_policy[OVS_PACKET_ATTR_MAX + 1] = {
 742         [OVS_PACKET_ATTR_PACKET] = { .type = NLA_UNSPEC },
 743         [OVS_PACKET_ATTR_KEY] = { .type = NLA_NESTED },
 744         [OVS_PACKET_ATTR_ACTIONS] = { .type = NLA_NESTED },
 745 };
 746
 747 static struct genl_ops dp_packet_genl_ops[] = {
 748         { .cmd = OVS_PACKET_CMD_EXECUTE,
 749           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
 750           .policy = packet_policy,
 751           .doit = ovs_packet_cmd_execute
 752         }
 753 };
 754
 755 static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats)
 756 {
 757         int i;
 758         struct flow_table *table = get_table_protected(dp);
 759
 760         stats->n_flows = flow_tbl_count(table);
 761
 762         stats->n_frags = stats->n_hit = stats->n_missed = stats->n_lost = 0;
 763         for_each_possible_cpu(i) {
 764                 const struct dp_stats_percpu *percpu_stats;
 765                 struct dp_stats_percpu local_stats;
 766                 unsigned seqcount;
 767
 768                 percpu_stats = per_cpu_ptr(dp->stats_percpu, i);
 769
 770                 do {
 771                         seqcount = read_seqcount_begin(&percpu_stats->seqlock);
 772                         local_stats = *percpu_stats;
 773                 } while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
 774
 775                 stats->n_frags += local_stats.n_frags;
 776                 stats->n_hit += local_stats.n_hit;
 777                 stats->n_missed += local_stats.n_missed;
 778                 stats->n_lost += local_stats.n_lost;
 779         }
 780 }
 781
 782 static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = {
 783         [OVS_FLOW_ATTR_KEY] = { .type = NLA_NESTED },
 784         [OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED },
 785         [OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG },
 786 };
 787
 788 static struct genl_family dp_flow_genl_family = {
 789         .id = GENL_ID_GENERATE,
 790         .hdrsize = sizeof(struct ovs_header),
 791         .name = OVS_FLOW_FAMILY,
 792         .version = 1,
 793         .maxattr = OVS_FLOW_ATTR_MAX
 794 };
 795
 796 static struct genl_multicast_group dp_flow_multicast_group = {
 797         .name = OVS_FLOW_MCGROUP
 798 };
 799
 800 /* Called with genl_lock. */
 801 static int ovs_flow_cmd_fill_info(struct sw_flow *flow, struct datapath *dp,
 802                                   struct sk_buff *skb, u32 pid, u32 seq, u32 flags, u8 cmd)
 803 {
 804         const int skb_orig_len = skb->len;
 805         const struct sw_flow_actions *sf_acts;
 806         struct ovs_flow_stats stats;
 807         struct ovs_header *ovs_header;
 808         struct nlattr *nla;
 809         unsigned long used;
 810         u8 tcp_flags;
 811         int err;
 812
 813         sf_acts = rcu_dereference_protected(flow->sf_acts,
 814                                             lockdep_genl_is_held());
 815
 816         ovs_header = genlmsg_put(skb, pid, seq, &dp_flow_genl_family, flags, cmd);
 817         if (!ovs_header)
 818                 return -EMSGSIZE;
 819
 820         ovs_header->dp_ifindex = get_dpifindex(dp);
 821
 822         nla = nla_nest_start(skb, OVS_FLOW_ATTR_KEY);
 823         if (!nla)
 824                 goto nla_put_failure;
 825         err = flow_to_nlattrs(&flow->key, skb);
 826         if (err)
 827                 goto error;
 828         nla_nest_end(skb, nla);
 829
 830         spin_lock_bh(&flow->lock);
 831         used = flow->used;
 832         stats.n_packets = flow->packet_count;
 833         stats.n_bytes = flow->byte_count;
 834         tcp_flags = flow->tcp_flags;
 835         spin_unlock_bh(&flow->lock);
 836
 837         if (used)
 838                 NLA_PUT_U64(skb, OVS_FLOW_ATTR_USED, flow_used_time(used));
 839
 840         if (stats.n_packets)
 841                 NLA_PUT(skb, OVS_FLOW_ATTR_STATS, sizeof(struct ovs_flow_stats), &stats);
 842
 843         if (tcp_flags)
 844                 NLA_PUT_U8(skb, OVS_FLOW_ATTR_TCP_FLAGS, tcp_flags);
 845
 846         /* If OVS_FLOW_ATTR_ACTIONS doesn't fit, skip dumping the actions if
 847          * this is the first flow to be dumped into 'skb'.  This is unusual for
 848          * Netlink but individual action lists can be longer than
 849          * NLMSG_GOODSIZE and thus entirely undumpable if we didn't do this.
 850          * The userspace caller can always fetch the actions separately if it
 851          * really wants them.  (Most userspace callers in fact don't care.)
 852          *
 853          * This can only fail for dump operations because the skb is always
 854          * properly sized for single flows.
 855          */
 856         err = nla_put(skb, OVS_FLOW_ATTR_ACTIONS, sf_acts->actions_len,
 857                       sf_acts->actions);
 858         if (err < 0 && skb_orig_len)
 859                 goto error;
 860
 861         return genlmsg_end(skb, ovs_header);
 862
 863 nla_put_failure:
 864         err = -EMSGSIZE;
 865 error:
 866         genlmsg_cancel(skb, ovs_header);
 867         return err;
 868 }
 869
 870 static struct sk_buff *ovs_flow_cmd_alloc_info(struct sw_flow *flow)
 871 {
 872         const struct sw_flow_actions *sf_acts;
 873         int len;
 874
 875         sf_acts = rcu_dereference_protected(flow->sf_acts,
 876                                             lockdep_genl_is_held());
 877
 878         len = nla_total_size(FLOW_BUFSIZE); /* OVS_FLOW_ATTR_KEY */
 879         len += nla_total_size(sf_acts->actions_len); /* OVS_FLOW_ATTR_ACTIONS */
 880         len += nla_total_size(sizeof(struct ovs_flow_stats)); /* OVS_FLOW_ATTR_STATS */
 881         len += nla_total_size(1); /* OVS_FLOW_ATTR_TCP_FLAGS */
 882         len += nla_total_size(8); /* OVS_FLOW_ATTR_USED */
 883         return genlmsg_new(NLMSG_ALIGN(sizeof(struct ovs_header)) + len, GFP_KERNEL);
 884 }
 885
 886 static struct sk_buff *ovs_flow_cmd_build_info(struct sw_flow *flow, struct datapath *dp,
 887                                                u32 pid, u32 seq, u8 cmd)
 888 {
 889         struct sk_buff *skb;
 890         int retval;
 891
 892         skb = ovs_flow_cmd_alloc_info(flow);
 893         if (!skb)
 894                 return ERR_PTR(-ENOMEM);
 895
 896         retval = ovs_flow_cmd_fill_info(flow, dp, skb, pid, seq, 0, cmd);
 897         BUG_ON(retval < 0);
 898         return skb;
 899 }
 900
 901 static int ovs_flow_cmd_new_or_set(struct sk_buff *skb, struct genl_info *info)
 902 {
 903         struct nlattr **a = info->attrs;
 904         struct ovs_header *ovs_header = info->userhdr;
 905         struct sw_flow_key key;
 906         struct sw_flow *flow;
 907         struct sk_buff *reply;
 908         struct datapath *dp;
 909         struct flow_table *table;
 910         int error;
 911         int key_len;
 912
 913         /* Extract key. */
 914         error = -EINVAL;
 915         if (!a[OVS_FLOW_ATTR_KEY])
 916                 goto error;
 917         error = flow_from_nlattrs(&key, &key_len, a[OVS_FLOW_ATTR_KEY]);
 918         if (error)
 919                 goto error;
 920
 921         /* Validate actions. */
 922         if (a[OVS_FLOW_ATTR_ACTIONS]) {
 923                 error = validate_actions(a[OVS_FLOW_ATTR_ACTIONS]);
 924                 if (error)
 925                         goto error;
 926         } else if (info->genlhdr->cmd == OVS_FLOW_CMD_NEW) {
 927                 error = -EINVAL;
 928                 goto error;
 929         }
 930
 931         dp = get_dp(ovs_header->dp_ifindex);
 932         error = -ENODEV;
 933         if (!dp)
 934                 goto error;
 935
 936         table = get_table_protected(dp);
 937         flow = flow_tbl_lookup(table, &key, key_len);
 938         if (!flow) {
 939                 struct sw_flow_actions *acts;
 940
 941                 /* Bail out if we're not allowed to create a new flow. */
 942                 error = -ENOENT;
 943                 if (info->genlhdr->cmd == OVS_FLOW_CMD_SET)
 944                         goto error;
 945
 946                 /* Expand table, if necessary, to make room. */
 947                 if (flow_tbl_need_to_expand(table)) {
 948                         struct flow_table *new_table;
 949
 950                         new_table = flow_tbl_expand(table);
 951                         if (!IS_ERR(new_table)) {
 952                                 rcu_assign_pointer(dp->table, new_table);
 953                                 flow_tbl_deferred_destroy(table);
 954                                 table = get_table_protected(dp);
 955                         }
 956                 }
 957
 958                 /* Allocate flow. */
 959                 flow = flow_alloc();
 960                 if (IS_ERR(flow)) {
 961                         error = PTR_ERR(flow);
 962                         goto error;
 963                 }
 964                 flow->key = key;
 965                 clear_stats(flow);
 966
 967                 /* Obtain actions. */
 968                 acts = flow_actions_alloc(a[OVS_FLOW_ATTR_ACTIONS]);
 969                 error = PTR_ERR(acts);
 970                 if (IS_ERR(acts))
 971                         goto error_free_flow;
 972                 rcu_assign_pointer(flow->sf_acts, acts);
 973
 974                 /* Put flow in bucket. */
 975                 flow->hash = flow_hash(&key, key_len);
 976                 flow_tbl_insert(table, flow);
 977
 978                 reply = ovs_flow_cmd_build_info(flow, dp, info->snd_pid,
 979                                                 info->snd_seq, OVS_FLOW_CMD_NEW);
 980         } else {
 981                 /* We found a matching flow. */
 982                 struct sw_flow_actions *old_acts;
 983
 984                 /* Bail out if we're not allowed to modify an existing flow.
 985                  * We accept NLM_F_CREATE in place of the intended NLM_F_EXCL
 986                  * because Generic Netlink treats the latter as a dump
 987                  * request.  We also accept NLM_F_EXCL in case that bug ever
 988                  * gets fixed.
 989                  */
 990                 error = -EEXIST;
 991                 if (info->genlhdr->cmd == OVS_FLOW_CMD_NEW &&
 992                     info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL))
 993                         goto error;
 994
 995                 /* Update actions. */
 996                 old_acts = rcu_dereference_protected(flow->sf_acts,
 997                                                      lockdep_genl_is_held());
 998                 if (a[OVS_FLOW_ATTR_ACTIONS] &&
 999                     (old_acts->actions_len != nla_len(a[OVS_FLOW_ATTR_ACTIONS]) ||
1000                      memcmp(old_acts->actions, nla_data(a[OVS_FLOW_ATTR_ACTIONS]),
1001                             old_acts->actions_len))) {
1002                         struct sw_flow_actions *new_acts;
1003
1004                         new_acts = flow_actions_alloc(a[OVS_FLOW_ATTR_ACTIONS]);
1005                         error = PTR_ERR(new_acts);
1006                         if (IS_ERR(new_acts))
1007                                 goto error;
1008
1009                         rcu_assign_pointer(flow->sf_acts, new_acts);
1010                         flow_deferred_free_acts(old_acts);
1011                 }
1012
1013                 reply = ovs_flow_cmd_build_info(flow, dp, info->snd_pid,
1014                                                 info->snd_seq, OVS_FLOW_CMD_NEW);
1015
1016                 /* Clear stats. */
1017                 if (a[OVS_FLOW_ATTR_CLEAR]) {
1018                         spin_lock_bh(&flow->lock);
1019                         clear_stats(flow);
1020                         spin_unlock_bh(&flow->lock);
1021                 }
1022         }
1023
1024         if (!IS_ERR(reply))
1025                 genl_notify(reply, genl_info_net(info), info->snd_pid,
1026                             dp_flow_multicast_group.id, info->nlhdr, GFP_KERNEL);
1027         else
1028                 netlink_set_err(INIT_NET_GENL_SOCK, 0,
1029                                 dp_flow_multicast_group.id, PTR_ERR(reply));
1030         return 0;
1031
1032 error_free_flow:
1033         flow_put(flow);
1034 error:
1035         return error;
1036 }
1037
1038 static int ovs_flow_cmd_get(struct sk_buff *skb, struct genl_info *info)
1039 {
1040         struct nlattr **a = info->attrs;
1041         struct ovs_header *ovs_header = info->userhdr;
1042         struct sw_flow_key key;
1043         struct sk_buff *reply;
1044         struct sw_flow *flow;
1045         struct datapath *dp;
1046         struct flow_table *table;
1047         int err;
1048         int key_len;
1049
1050         if (!a[OVS_FLOW_ATTR_KEY])
1051                 return -EINVAL;
1052         err = flow_from_nlattrs(&key, &key_len, a[OVS_FLOW_ATTR_KEY]);
1053         if (err)
1054                 return err;
1055
1056         dp = get_dp(ovs_header->dp_ifindex);
1057         if (!dp)
1058                 return -ENODEV;
1059
1060         table = get_table_protected(dp);
1061         flow = flow_tbl_lookup(table, &key, key_len);
1062         if (!flow)
1063                 return -ENOENT;
1064
1065         reply = ovs_flow_cmd_build_info(flow, dp, info->snd_pid, info->snd_seq, OVS_FLOW_CMD_NEW);
1066         if (IS_ERR(reply))
1067                 return PTR_ERR(reply);
1068
1069         return genlmsg_reply(reply, info);
1070 }
1071
1072 static int ovs_flow_cmd_del(struct sk_buff *skb, struct genl_info *info)
1073 {
1074         struct nlattr **a = info->attrs;
1075         struct ovs_header *ovs_header = info->userhdr;
1076         struct sw_flow_key key;
1077         struct sk_buff *reply;
1078         struct sw_flow *flow;
1079         struct datapath *dp;
1080         struct flow_table *table;
1081         int err;
1082         int key_len;
1083
1084         if (!a[OVS_FLOW_ATTR_KEY])
1085                 return flush_flows(ovs_header->dp_ifindex);
1086         err = flow_from_nlattrs(&key, &key_len, a[OVS_FLOW_ATTR_KEY]);
1087         if (err)
1088                 return err;
1089
1090         dp = get_dp(ovs_header->dp_ifindex);
1091         if (!dp)
1092                 return -ENODEV;
1093
1094         table = get_table_protected(dp);
1095         flow = flow_tbl_lookup(table, &key, key_len);
1096         if (!flow)
1097                 return -ENOENT;
1098
1099         reply = ovs_flow_cmd_alloc_info(flow);
1100         if (!reply)
1101                 return -ENOMEM;
1102
1103         flow_tbl_remove(table, flow);
1104
1105         err = ovs_flow_cmd_fill_info(flow, dp, reply, info->snd_pid,
1106                                      info->snd_seq, 0, OVS_FLOW_CMD_DEL);
1107         BUG_ON(err < 0);
1108
1109         flow_deferred_free(flow);
1110
1111         genl_notify(reply, genl_info_net(info), info->snd_pid,
1112                     dp_flow_multicast_group.id, info->nlhdr, GFP_KERNEL);
1113         return 0;
1114 }
1115
1116 static int ovs_flow_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb)
1117 {
1118         struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh));
1119         struct datapath *dp;
1120
1121         dp = get_dp(ovs_header->dp_ifindex);
1122         if (!dp)
1123                 return -ENODEV;
1124
1125         for (;;) {
1126                 struct sw_flow *flow;
1127                 u32 bucket, obj;
1128
1129                 bucket = cb->args[0];
1130                 obj = cb->args[1];
1131                 flow = flow_tbl_next(get_table_protected(dp), &bucket, &obj);
1132                 if (!flow)
1133                         break;
1134
1135                 if (ovs_flow_cmd_fill_info(flow, dp, skb, NETLINK_CB(cb->skb).pid,
1136                                            cb->nlh->nlmsg_seq, NLM_F_MULTI,
1137                                            OVS_FLOW_CMD_NEW) < 0)
1138                         break;
1139
1140                 cb->args[0] = bucket;
1141                 cb->args[1] = obj;
1142         }
1143         return skb->len;
1144 }
1145
1146 static struct genl_ops dp_flow_genl_ops[] = {
1147         { .cmd = OVS_FLOW_CMD_NEW,
1148           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1149           .policy = flow_policy,
1150           .doit = ovs_flow_cmd_new_or_set
1151         },
1152         { .cmd = OVS_FLOW_CMD_DEL,
1153           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1154           .policy = flow_policy,
1155           .doit = ovs_flow_cmd_del
1156         },
1157         { .cmd = OVS_FLOW_CMD_GET,
1158           .flags = 0,               /* OK for unprivileged users. */
1159           .policy = flow_policy,
1160           .doit = ovs_flow_cmd_get,
1161           .dumpit = ovs_flow_cmd_dump
1162         },
1163         { .cmd = OVS_FLOW_CMD_SET,
1164           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1165           .policy = flow_policy,
1166           .doit = ovs_flow_cmd_new_or_set,
1167         },
1168 };
1169
1170 static const struct nla_policy datapath_policy[OVS_DP_ATTR_MAX + 1] = {
1171 #ifdef HAVE_NLA_NUL_STRING
1172         [OVS_DP_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 },
1173 #endif
1174         [OVS_DP_ATTR_IPV4_FRAGS] = { .type = NLA_U32 },
1175         [OVS_DP_ATTR_SAMPLING] = { .type = NLA_U32 },
1176 };
1177
1178 static struct genl_family dp_datapath_genl_family = {
1179         .id = GENL_ID_GENERATE,
1180         .hdrsize = sizeof(struct ovs_header),
1181         .name = OVS_DATAPATH_FAMILY,
1182         .version = 1,
1183         .maxattr = OVS_DP_ATTR_MAX
1184 };
1185
1186 static struct genl_multicast_group dp_datapath_multicast_group = {
1187         .name = OVS_DATAPATH_MCGROUP
1188 };
1189
1190 static int ovs_dp_cmd_fill_info(struct datapath *dp, struct sk_buff *skb,
1191                                 u32 pid, u32 seq, u32 flags, u8 cmd)
1192 {
1193         struct ovs_header *ovs_header;
1194         struct nlattr *nla;
1195         int err;
1196         int dp_ifindex = get_dpifindex(dp);
1197
1198         ovs_header = genlmsg_put(skb, pid, seq, &dp_datapath_genl_family,
1199                                    flags, cmd);
1200         if (!ovs_header)
1201                 goto error;
1202
1203         ovs_header->dp_ifindex = dp_ifindex;
1204
1205         rcu_read_lock();
1206         err = nla_put_string(skb, OVS_DP_ATTR_NAME, dp_name(dp));
1207         rcu_read_unlock();
1208         if (err)
1209                 goto nla_put_failure;
1210
1211         nla = nla_reserve(skb, OVS_DP_ATTR_STATS, sizeof(struct ovs_dp_stats));
1212         if (!nla)
1213                 goto nla_put_failure;
1214         get_dp_stats(dp, nla_data(nla));
1215
1216         NLA_PUT_U32(skb, OVS_DP_ATTR_IPV4_FRAGS,
1217                     dp->drop_frags ? OVS_DP_FRAG_DROP : OVS_DP_FRAG_ZERO);
1218
1219         if (dp->sflow_probability)
1220                 NLA_PUT_U32(skb, OVS_DP_ATTR_SAMPLING, dp->sflow_probability);
1221
1222         nla = nla_nest_start(skb, OVS_DP_ATTR_MCGROUPS);
1223         if (!nla)
1224                 goto nla_put_failure;
1225         NLA_PUT_U32(skb, OVS_PACKET_CMD_MISS,
1226                         packet_mc_group(dp_ifindex, OVS_PACKET_CMD_MISS));
1227         NLA_PUT_U32(skb, OVS_PACKET_CMD_ACTION,
1228                         packet_mc_group(dp_ifindex, OVS_PACKET_CMD_ACTION));
1229         NLA_PUT_U32(skb, OVS_PACKET_CMD_SAMPLE,
1230                         packet_mc_group(dp_ifindex, OVS_PACKET_CMD_SAMPLE));
1231         nla_nest_end(skb, nla);
1232
1233         return genlmsg_end(skb, ovs_header);
1234
1235 nla_put_failure:
1236         genlmsg_cancel(skb, ovs_header);
1237 error:
1238         return -EMSGSIZE;
1239 }
1240
1241 static struct sk_buff *ovs_dp_cmd_build_info(struct datapath *dp, u32 pid,
1242                                              u32 seq, u8 cmd)
1243 {
1244         struct sk_buff *skb;
1245         int retval;
1246
1247         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1248         if (!skb)
1249                 return ERR_PTR(-ENOMEM);
1250
1251         retval = ovs_dp_cmd_fill_info(dp, skb, pid, seq, 0, cmd);
1252         if (retval < 0) {
1253                 kfree_skb(skb);
1254                 return ERR_PTR(retval);
1255         }
1256         return skb;
1257 }
1258
1259 static int ovs_dp_cmd_validate(struct nlattr *a[OVS_DP_ATTR_MAX + 1])
1260 {
1261         if (a[OVS_DP_ATTR_IPV4_FRAGS]) {
1262                 u32 frags = nla_get_u32(a[OVS_DP_ATTR_IPV4_FRAGS]);
1263
1264                 if (frags != OVS_DP_FRAG_ZERO && frags != OVS_DP_FRAG_DROP)
1265                         return -EINVAL;
1266         }
1267
1268         return CHECK_NUL_STRING(a[OVS_DP_ATTR_NAME], IFNAMSIZ - 1);
1269 }
1270
1271 /* Called with genl_mutex and optionally with RTNL lock also. */
1272 static struct datapath *lookup_datapath(struct ovs_header *ovs_header, struct nlattr *a[OVS_DP_ATTR_MAX + 1])
1273 {
1274         struct datapath *dp;
1275
1276         if (!a[OVS_DP_ATTR_NAME])
1277                 dp = get_dp(ovs_header->dp_ifindex);
1278         else {
1279                 struct vport *vport;
1280
1281                 rcu_read_lock();
1282                 vport = vport_locate(nla_data(a[OVS_DP_ATTR_NAME]));
1283                 dp = vport && vport->port_no == OVSP_LOCAL ? vport->dp : NULL;
1284                 rcu_read_unlock();
1285         }
1286         return dp ? dp : ERR_PTR(-ENODEV);
1287 }
1288
1289 /* Called with genl_mutex. */
1290 static void change_datapath(struct datapath *dp, struct nlattr *a[OVS_DP_ATTR_MAX + 1])
1291 {
1292         if (a[OVS_DP_ATTR_IPV4_FRAGS])
1293                 dp->drop_frags = nla_get_u32(a[OVS_DP_ATTR_IPV4_FRAGS]) == OVS_DP_FRAG_DROP;
1294         if (a[OVS_DP_ATTR_SAMPLING])
1295                 dp->sflow_probability = nla_get_u32(a[OVS_DP_ATTR_SAMPLING]);
1296 }
1297
1298 static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
1299 {
1300         struct nlattr **a = info->attrs;
1301         struct vport_parms parms;
1302         struct sk_buff *reply;
1303         struct datapath *dp;
1304         struct vport *vport;
1305         int err;
1306
1307         err = -EINVAL;
1308         if (!a[OVS_DP_ATTR_NAME])
1309                 goto err;
1310
1311         err = ovs_dp_cmd_validate(a);
1312         if (err)
1313                 goto err;
1314
1315         rtnl_lock();
1316         err = -ENODEV;
1317         if (!try_module_get(THIS_MODULE))
1318                 goto err_unlock_rtnl;
1319
1320         err = -ENOMEM;
1321         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1322         if (dp == NULL)
1323                 goto err_put_module;
1324         INIT_LIST_HEAD(&dp->port_list);
1325
1326         /* Initialize kobject for bridge.  This will be added as
1327          * /sys/class/net/<devname>/brif later, if sysfs is enabled. */
1328         dp->ifobj.kset = NULL;
1329         kobject_init(&dp->ifobj, &dp_ktype);
1330
1331         /* Allocate table. */
1332         err = -ENOMEM;
1333         rcu_assign_pointer(dp->table, flow_tbl_alloc(TBL_MIN_BUCKETS));
1334         if (!dp->table)
1335                 goto err_free_dp;
1336
1337         dp->drop_frags = 0;
1338         dp->stats_percpu = alloc_percpu(struct dp_stats_percpu);
1339         if (!dp->stats_percpu) {
1340                 err = -ENOMEM;
1341                 goto err_destroy_table;
1342         }
1343
1344         change_datapath(dp, a);
1345
1346         /* Set up our datapath device. */
1347         parms.name = nla_data(a[OVS_DP_ATTR_NAME]);
1348         parms.type = OVS_VPORT_TYPE_INTERNAL;
1349         parms.options = NULL;
1350         parms.dp = dp;
1351         parms.port_no = OVSP_LOCAL;
1352         vport = new_vport(&parms);
1353         if (IS_ERR(vport)) {
1354                 err = PTR_ERR(vport);
1355                 if (err == -EBUSY)
1356                         err = -EEXIST;
1357
1358                 goto err_destroy_percpu;
1359         }
1360
1361         reply = ovs_dp_cmd_build_info(dp, info->snd_pid, info->snd_seq, OVS_DP_CMD_NEW);
1362         err = PTR_ERR(reply);
1363         if (IS_ERR(reply))
1364                 goto err_destroy_local_port;
1365
1366         list_add_tail(&dp->list_node, &dps);
1367         dp_sysfs_add_dp(dp);
1368
1369         rtnl_unlock();
1370
1371         genl_notify(reply, genl_info_net(info), info->snd_pid,
1372                     dp_datapath_multicast_group.id, info->nlhdr, GFP_KERNEL);
1373         return 0;
1374
1375 err_destroy_local_port:
1376         dp_detach_port(get_vport_protected(dp, OVSP_LOCAL));
1377 err_destroy_percpu:
1378         free_percpu(dp->stats_percpu);
1379 err_destroy_table:
1380         flow_tbl_destroy(get_table_protected(dp));
1381 err_free_dp:
1382         kfree(dp);
1383 err_put_module:
1384         module_put(THIS_MODULE);
1385 err_unlock_rtnl:
1386         rtnl_unlock();
1387 err:
1388         return err;
1389 }
1390
1391 static int ovs_dp_cmd_del(struct sk_buff *skb, struct genl_info *info)
1392 {
1393         struct vport *vport, *next_vport;
1394         struct sk_buff *reply;
1395         struct datapath *dp;
1396         int err;
1397
1398         err = ovs_dp_cmd_validate(info->attrs);
1399         if (err)
1400                 goto exit;
1401
1402         rtnl_lock();
1403         dp = lookup_datapath(info->userhdr, info->attrs);
1404         err = PTR_ERR(dp);
1405         if (IS_ERR(dp))
1406                 goto exit_unlock;
1407
1408         reply = ovs_dp_cmd_build_info(dp, info->snd_pid, info->snd_seq, OVS_DP_CMD_DEL);
1409         err = PTR_ERR(reply);
1410         if (IS_ERR(reply))
1411                 goto exit_unlock;
1412
1413         list_for_each_entry_safe (vport, next_vport, &dp->port_list, node)
1414                 if (vport->port_no != OVSP_LOCAL)
1415                         dp_detach_port(vport);
1416
1417         dp_sysfs_del_dp(dp);
1418         list_del(&dp->list_node);
1419         dp_detach_port(get_vport_protected(dp, OVSP_LOCAL));
1420
1421         /* rtnl_unlock() will wait until all the references to devices that
1422          * are pending unregistration have been dropped.  We do it here to
1423          * ensure that any internal devices (which contain DP pointers) are
1424          * fully destroyed before freeing the datapath.
1425          */
1426         rtnl_unlock();
1427
1428         call_rcu(&dp->rcu, destroy_dp_rcu);
1429         module_put(THIS_MODULE);
1430
1431         genl_notify(reply, genl_info_net(info), info->snd_pid,
1432                     dp_datapath_multicast_group.id, info->nlhdr, GFP_KERNEL);
1433
1434         return 0;
1435
1436 exit_unlock:
1437         rtnl_unlock();
1438 exit:
1439         return err;
1440 }
1441
1442 static int ovs_dp_cmd_set(struct sk_buff *skb, struct genl_info *info)
1443 {
1444         struct sk_buff *reply;
1445         struct datapath *dp;
1446         int err;
1447
1448         err = ovs_dp_cmd_validate(info->attrs);
1449         if (err)
1450                 return err;
1451
1452         dp = lookup_datapath(info->userhdr, info->attrs);
1453         if (IS_ERR(dp))
1454                 return PTR_ERR(dp);
1455
1456         change_datapath(dp, info->attrs);
1457
1458         reply = ovs_dp_cmd_build_info(dp, info->snd_pid, info->snd_seq, OVS_DP_CMD_NEW);
1459         if (IS_ERR(reply)) {
1460                 err = PTR_ERR(reply);
1461                 netlink_set_err(INIT_NET_GENL_SOCK, 0,
1462                                 dp_datapath_multicast_group.id, err);
1463                 return 0;
1464         }
1465
1466         genl_notify(reply, genl_info_net(info), info->snd_pid,
1467                     dp_datapath_multicast_group.id, info->nlhdr, GFP_KERNEL);
1468         return 0;
1469 }
1470
1471 static int ovs_dp_cmd_get(struct sk_buff *skb, struct genl_info *info)
1472 {
1473         struct sk_buff *reply;
1474         struct datapath *dp;
1475         int err;
1476
1477         err = ovs_dp_cmd_validate(info->attrs);
1478         if (err)
1479                 return err;
1480
1481         dp = lookup_datapath(info->userhdr, info->attrs);
1482         if (IS_ERR(dp))
1483                 return PTR_ERR(dp);
1484
1485         reply = ovs_dp_cmd_build_info(dp, info->snd_pid, info->snd_seq, OVS_DP_CMD_NEW);
1486         if (IS_ERR(reply))
1487                 return PTR_ERR(reply);
1488
1489         return genlmsg_reply(reply, info);
1490 }
1491
1492 static int ovs_dp_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb)
1493 {
1494         struct datapath *dp;
1495         int skip = cb->args[0];
1496         int i = 0;
1497
1498         list_for_each_entry (dp, &dps, list_node) {
1499                 if (i < skip)
1500                         continue;
1501                 if (ovs_dp_cmd_fill_info(dp, skb, NETLINK_CB(cb->skb).pid,
1502                                          cb->nlh->nlmsg_seq, NLM_F_MULTI,
1503                                          OVS_DP_CMD_NEW) < 0)
1504                         break;
1505                 i++;
1506         }
1507
1508         cb->args[0] = i;
1509
1510         return skb->len;
1511 }
1512
1513 static struct genl_ops dp_datapath_genl_ops[] = {
1514         { .cmd = OVS_DP_CMD_NEW,
1515           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1516           .policy = datapath_policy,
1517           .doit = ovs_dp_cmd_new
1518         },
1519         { .cmd = OVS_DP_CMD_DEL,
1520           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1521           .policy = datapath_policy,
1522           .doit = ovs_dp_cmd_del
1523         },
1524         { .cmd = OVS_DP_CMD_GET,
1525           .flags = 0,               /* OK for unprivileged users. */
1526           .policy = datapath_policy,
1527           .doit = ovs_dp_cmd_get,
1528           .dumpit = ovs_dp_cmd_dump
1529         },
1530         { .cmd = OVS_DP_CMD_SET,
1531           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1532           .policy = datapath_policy,
1533           .doit = ovs_dp_cmd_set,
1534         },
1535 };
1536
1537 static const struct nla_policy vport_policy[OVS_VPORT_ATTR_MAX + 1] = {
1538 #ifdef HAVE_NLA_NUL_STRING
1539         [OVS_VPORT_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 },
1540         [OVS_VPORT_ATTR_PORT_NO] = { .type = NLA_U32 },
1541         [OVS_VPORT_ATTR_TYPE] = { .type = NLA_U32 },
1542         [OVS_VPORT_ATTR_STATS] = { .len = sizeof(struct ovs_vport_stats) },
1543         [OVS_VPORT_ATTR_ADDRESS] = { .len = ETH_ALEN },
1544 #else
1545         [OVS_VPORT_ATTR_STATS] = { .minlen = sizeof(struct ovs_vport_stats) },
1546         [OVS_VPORT_ATTR_ADDRESS] = { .minlen = ETH_ALEN },
1547 #endif
1548         [OVS_VPORT_ATTR_OPTIONS] = { .type = NLA_NESTED },
1549 };
1550
1551 static struct genl_family dp_vport_genl_family = {
1552         .id = GENL_ID_GENERATE,
1553         .hdrsize = sizeof(struct ovs_header),
1554         .name = OVS_VPORT_FAMILY,
1555         .version = 1,
1556         .maxattr = OVS_VPORT_ATTR_MAX
1557 };
1558
1559 struct genl_multicast_group dp_vport_multicast_group = {
1560         .name = OVS_VPORT_MCGROUP
1561 };
1562
1563 /* Called with RTNL lock or RCU read lock. */
1564 static int ovs_vport_cmd_fill_info(struct vport *vport, struct sk_buff *skb,
1565                                    u32 pid, u32 seq, u32 flags, u8 cmd)
1566 {
1567         struct ovs_header *ovs_header;
1568         struct nlattr *nla;
1569         int ifindex;
1570         int err;
1571
1572         ovs_header = genlmsg_put(skb, pid, seq, &dp_vport_genl_family,
1573                                  flags, cmd);
1574         if (!ovs_header)
1575                 return -EMSGSIZE;
1576
1577         ovs_header->dp_ifindex = get_dpifindex(vport->dp);
1578
1579         NLA_PUT_U32(skb, OVS_VPORT_ATTR_PORT_NO, vport->port_no);
1580         NLA_PUT_U32(skb, OVS_VPORT_ATTR_TYPE, vport_get_type(vport));
1581         NLA_PUT_STRING(skb, OVS_VPORT_ATTR_NAME, vport_get_name(vport));
1582
1583         nla = nla_reserve(skb, OVS_VPORT_ATTR_STATS, sizeof(struct ovs_vport_stats));
1584         if (!nla)
1585                 goto nla_put_failure;
1586
1587         vport_get_stats(vport, nla_data(nla));
1588
1589         NLA_PUT(skb, OVS_VPORT_ATTR_ADDRESS, ETH_ALEN, vport_get_addr(vport));
1590
1591         err = vport_get_options(vport, skb);
1592         if (err == -EMSGSIZE)
1593                 goto error;
1594
1595         ifindex = vport_get_ifindex(vport);
1596         if (ifindex > 0)
1597                 NLA_PUT_U32(skb, OVS_VPORT_ATTR_IFINDEX, ifindex);
1598
1599         return genlmsg_end(skb, ovs_header);
1600
1601 nla_put_failure:
1602         err = -EMSGSIZE;
1603 error:
1604         genlmsg_cancel(skb, ovs_header);
1605         return err;
1606 }
1607
1608 /* Called with RTNL lock or RCU read lock. */
1609 struct sk_buff *ovs_vport_cmd_build_info(struct vport *vport, u32 pid,
1610                                          u32 seq, u8 cmd)
1611 {
1612         struct sk_buff *skb;
1613         int retval;
1614
1615         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1616         if (!skb)
1617                 return ERR_PTR(-ENOMEM);
1618
1619         retval = ovs_vport_cmd_fill_info(vport, skb, pid, seq, 0, cmd);
1620         if (retval < 0) {
1621                 kfree_skb(skb);
1622                 return ERR_PTR(retval);
1623         }
1624         return skb;
1625 }
1626
1627 static int ovs_vport_cmd_validate(struct nlattr *a[OVS_VPORT_ATTR_MAX + 1])
1628 {
1629         return CHECK_NUL_STRING(a[OVS_VPORT_ATTR_NAME], IFNAMSIZ - 1);
1630 }
1631
1632 /* Called with RTNL lock or RCU read lock. */
1633 static struct vport *lookup_vport(struct ovs_header *ovs_header,
1634                                   struct nlattr *a[OVS_VPORT_ATTR_MAX + 1])
1635 {
1636         struct datapath *dp;
1637         struct vport *vport;
1638
1639         if (a[OVS_VPORT_ATTR_NAME]) {
1640                 vport = vport_locate(nla_data(a[OVS_VPORT_ATTR_NAME]));
1641                 if (!vport)
1642                         return ERR_PTR(-ENODEV);
1643                 return vport;
1644         } else if (a[OVS_VPORT_ATTR_PORT_NO]) {
1645                 u32 port_no = nla_get_u32(a[OVS_VPORT_ATTR_PORT_NO]);
1646
1647                 if (port_no >= DP_MAX_PORTS)
1648                         return ERR_PTR(-EFBIG);
1649
1650                 dp = get_dp(ovs_header->dp_ifindex);
1651                 if (!dp)
1652                         return ERR_PTR(-ENODEV);
1653
1654                 vport = get_vport_protected(dp, port_no);
1655                 if (!vport)
1656                         return ERR_PTR(-ENOENT);
1657                 return vport;
1658         } else
1659                 return ERR_PTR(-EINVAL);
1660 }
1661
1662 /* Called with RTNL lock. */
1663 static int change_vport(struct vport *vport, struct nlattr *a[OVS_VPORT_ATTR_MAX + 1])
1664 {
1665         int err = 0;
1666
1667         if (a[OVS_VPORT_ATTR_STATS])
1668                 vport_set_stats(vport, nla_data(a[OVS_VPORT_ATTR_STATS]));
1669
1670         if (a[OVS_VPORT_ATTR_ADDRESS])
1671                 err = vport_set_addr(vport, nla_data(a[OVS_VPORT_ATTR_ADDRESS]));
1672
1673         return err;
1674 }
1675
1676 static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
1677 {
1678         struct nlattr **a = info->attrs;
1679         struct ovs_header *ovs_header = info->userhdr;
1680         struct vport_parms parms;
1681         struct sk_buff *reply;
1682         struct vport *vport;
1683         struct datapath *dp;
1684         u32 port_no;
1685         int err;
1686
1687         err = -EINVAL;
1688         if (!a[OVS_VPORT_ATTR_NAME] || !a[OVS_VPORT_ATTR_TYPE])
1689                 goto exit;
1690
1691         err = ovs_vport_cmd_validate(a);
1692         if (err)
1693                 goto exit;
1694
1695         rtnl_lock();
1696         dp = get_dp(ovs_header->dp_ifindex);
1697         err = -ENODEV;
1698         if (!dp)
1699                 goto exit_unlock;
1700
1701         if (a[OVS_VPORT_ATTR_PORT_NO]) {
1702                 port_no = nla_get_u32(a[OVS_VPORT_ATTR_PORT_NO]);
1703
1704                 err = -EFBIG;
1705                 if (port_no >= DP_MAX_PORTS)
1706                         goto exit_unlock;
1707
1708                 vport = get_vport_protected(dp, port_no);
1709                 err = -EBUSY;
1710                 if (vport)
1711                         goto exit_unlock;
1712         } else {
1713                 for (port_no = 1; ; port_no++) {
1714                         if (port_no >= DP_MAX_PORTS) {
1715                                 err = -EFBIG;
1716                                 goto exit_unlock;
1717                         }
1718                         vport = get_vport_protected(dp, port_no);
1719                         if (!vport)
1720                                 break;
1721                 }
1722         }
1723
1724         parms.name = nla_data(a[OVS_VPORT_ATTR_NAME]);
1725         parms.type = nla_get_u32(a[OVS_VPORT_ATTR_TYPE]);
1726         parms.options = a[OVS_VPORT_ATTR_OPTIONS];
1727         parms.dp = dp;
1728         parms.port_no = port_no;
1729
1730         vport = new_vport(&parms);
1731         err = PTR_ERR(vport);
1732         if (IS_ERR(vport))
1733                 goto exit_unlock;
1734
1735         dp_sysfs_add_if(vport);
1736
1737         err = change_vport(vport, a);
1738         if (!err) {
1739                 reply = ovs_vport_cmd_build_info(vport, info->snd_pid,
1740                                                  info->snd_seq, OVS_VPORT_CMD_NEW);
1741                 if (IS_ERR(reply))
1742                         err = PTR_ERR(reply);
1743         }
1744         if (err) {
1745                 dp_detach_port(vport);
1746                 goto exit_unlock;
1747         }
1748         genl_notify(reply, genl_info_net(info), info->snd_pid,
1749                     dp_vport_multicast_group.id, info->nlhdr, GFP_KERNEL);
1750
1751
1752 exit_unlock:
1753         rtnl_unlock();
1754 exit:
1755         return err;
1756 }
1757
1758 static int ovs_vport_cmd_set(struct sk_buff *skb, struct genl_info *info)
1759 {
1760         struct nlattr **a = info->attrs;
1761         struct sk_buff *reply;
1762         struct vport *vport;
1763         int err;
1764
1765         err = ovs_vport_cmd_validate(a);
1766         if (err)
1767                 goto exit;
1768
1769         rtnl_lock();
1770         vport = lookup_vport(info->userhdr, a);
1771         err = PTR_ERR(vport);
1772         if (IS_ERR(vport))
1773                 goto exit_unlock;
1774
1775         err = 0;
1776         if (a[OVS_VPORT_ATTR_OPTIONS])
1777                 err = vport_set_options(vport, a[OVS_VPORT_ATTR_OPTIONS]);
1778         if (!err)
1779                 err = change_vport(vport, a);
1780
1781         reply = ovs_vport_cmd_build_info(vport, info->snd_pid, info->snd_seq,
1782                                          OVS_VPORT_CMD_NEW);
1783         if (IS_ERR(reply)) {
1784                 err = PTR_ERR(reply);
1785                 netlink_set_err(INIT_NET_GENL_SOCK, 0,
1786                                 dp_vport_multicast_group.id, err);
1787                 return 0;
1788         }
1789
1790         genl_notify(reply, genl_info_net(info), info->snd_pid,
1791                     dp_vport_multicast_group.id, info->nlhdr, GFP_KERNEL);
1792
1793 exit_unlock:
1794         rtnl_unlock();
1795 exit:
1796         return err;
1797 }
1798
1799 static int ovs_vport_cmd_del(struct sk_buff *skb, struct genl_info *info)
1800 {
1801         struct nlattr **a = info->attrs;
1802         struct sk_buff *reply;
1803         struct vport *vport;
1804         int err;
1805
1806         err = ovs_vport_cmd_validate(a);
1807         if (err)
1808                 goto exit;
1809
1810         rtnl_lock();
1811         vport = lookup_vport(info->userhdr, a);
1812         err = PTR_ERR(vport);
1813         if (IS_ERR(vport))
1814                 goto exit_unlock;
1815
1816         if (vport->port_no == OVSP_LOCAL) {
1817                 err = -EINVAL;
1818                 goto exit_unlock;
1819         }
1820
1821         reply = ovs_vport_cmd_build_info(vport, info->snd_pid, info->snd_seq,
1822                                          OVS_VPORT_CMD_DEL);
1823         err = PTR_ERR(reply);
1824         if (IS_ERR(reply))
1825                 goto exit_unlock;
1826
1827         dp_detach_port(vport);
1828
1829         genl_notify(reply, genl_info_net(info), info->snd_pid,
1830                     dp_vport_multicast_group.id, info->nlhdr, GFP_KERNEL);
1831
1832 exit_unlock:
1833         rtnl_unlock();
1834 exit:
1835         return err;
1836 }
1837
1838 static int ovs_vport_cmd_get(struct sk_buff *skb, struct genl_info *info)
1839 {
1840         struct nlattr **a = info->attrs;
1841         struct ovs_header *ovs_header = info->userhdr;
1842         struct sk_buff *reply;
1843         struct vport *vport;
1844         int err;
1845
1846         err = ovs_vport_cmd_validate(a);
1847         if (err)
1848                 goto exit;
1849
1850         rcu_read_lock();
1851         vport = lookup_vport(ovs_header, a);
1852         err = PTR_ERR(vport);
1853         if (IS_ERR(vport))
1854                 goto exit_unlock;
1855
1856         reply = ovs_vport_cmd_build_info(vport, info->snd_pid, info->snd_seq,
1857                                          OVS_VPORT_CMD_NEW);
1858         err = PTR_ERR(reply);
1859         if (IS_ERR(reply))
1860                 goto exit_unlock;
1861
1862         rcu_read_unlock();
1863
1864         return genlmsg_reply(reply, info);
1865
1866 exit_unlock:
1867         rcu_read_unlock();
1868 exit:
1869         return err;
1870 }
1871
1872 static int ovs_vport_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb)
1873 {
1874         struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh));
1875         struct datapath *dp;
1876         u32 port_no;
1877         int retval;
1878
1879         dp = get_dp(ovs_header->dp_ifindex);
1880         if (!dp)
1881                 return -ENODEV;
1882
1883         rcu_read_lock();
1884         for (port_no = cb->args[0]; port_no < DP_MAX_PORTS; port_no++) {
1885                 struct vport *vport;
1886
1887                 vport = get_vport_protected(dp, port_no);
1888                 if (!vport)
1889                         continue;
1890
1891                 if (ovs_vport_cmd_fill_info(vport, skb, NETLINK_CB(cb->skb).pid,
1892                                             cb->nlh->nlmsg_seq, NLM_F_MULTI,
1893                                             OVS_VPORT_CMD_NEW) < 0)
1894                         break;
1895         }
1896         rcu_read_unlock();
1897
1898         cb->args[0] = port_no;
1899         retval = skb->len;
1900
1901         return retval;
1902 }
1903
1904 static struct genl_ops dp_vport_genl_ops[] = {
1905         { .cmd = OVS_VPORT_CMD_NEW,
1906           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1907           .policy = vport_policy,
1908           .doit = ovs_vport_cmd_new
1909         },
1910         { .cmd = OVS_VPORT_CMD_DEL,
1911           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1912           .policy = vport_policy,
1913           .doit = ovs_vport_cmd_del
1914         },
1915         { .cmd = OVS_VPORT_CMD_GET,
1916           .flags = 0,               /* OK for unprivileged users. */
1917           .policy = vport_policy,
1918           .doit = ovs_vport_cmd_get,
1919           .dumpit = ovs_vport_cmd_dump
1920         },
1921         { .cmd = OVS_VPORT_CMD_SET,
1922           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
1923           .policy = vport_policy,
1924           .doit = ovs_vport_cmd_set,
1925         },
1926 };
1927
1928 struct genl_family_and_ops {
1929         struct genl_family *family;
1930         struct genl_ops *ops;
1931         int n_ops;
1932         struct genl_multicast_group *group;
1933 };
1934
1935 static const struct genl_family_and_ops dp_genl_families[] = {
1936         { &dp_datapath_genl_family,
1937           dp_datapath_genl_ops, ARRAY_SIZE(dp_datapath_genl_ops),
1938           &dp_datapath_multicast_group },
1939         { &dp_vport_genl_family,
1940           dp_vport_genl_ops, ARRAY_SIZE(dp_vport_genl_ops),
1941           &dp_vport_multicast_group },
1942         { &dp_flow_genl_family,
1943           dp_flow_genl_ops, ARRAY_SIZE(dp_flow_genl_ops),
1944           &dp_flow_multicast_group },
1945         { &dp_packet_genl_family,
1946           dp_packet_genl_ops, ARRAY_SIZE(dp_packet_genl_ops),
1947           NULL },
1948 };
1949
1950 static void dp_unregister_genl(int n_families)
1951 {
1952         int i;
1953
1954         for (i = 0; i < n_families; i++)
1955                 genl_unregister_family(dp_genl_families[i].family);
1956 }
1957
1958 static int dp_register_genl(void)
1959 {
1960         int n_registered;
1961         int err;
1962         int i;
1963
1964         n_registered = 0;
1965         for (i = 0; i < ARRAY_SIZE(dp_genl_families); i++) {
1966                 const struct genl_family_and_ops *f = &dp_genl_families[i];
1967
1968                 err = genl_register_family_with_ops(f->family, f->ops,
1969                                                     f->n_ops);
1970                 if (err)
1971                         goto error;
1972                 n_registered++;
1973
1974                 if (f->group) {
1975                         err = genl_register_mc_group(f->family, f->group);
1976                         if (err)
1977                                 goto error;
1978                 }
1979         }
1980
1981         err = packet_register_mc_groups();
1982         if (err)
1983                 goto error;
1984         return 0;
1985
1986 error:
1987         dp_unregister_genl(n_registered);
1988         return err;
1989 }
1990
1991 static int __init dp_init(void)
1992 {
1993         struct sk_buff *dummy_skb;
1994         int err;
1995
1996         BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > sizeof(dummy_skb->cb));
1997
1998         printk("Open vSwitch %s, built "__DATE__" "__TIME__"\n", VERSION BUILDNR);
1999
2000         err = tnl_init();
2001         if (err)
2002                 goto error;
2003
2004         err = flow_init();
2005         if (err)
2006                 goto error_tnl_exit;
2007
2008         err = vport_init();
2009         if (err)
2010                 goto error_flow_exit;
2011
2012         err = register_netdevice_notifier(&dp_device_notifier);
2013         if (err)
2014                 goto error_vport_exit;
2015
2016         err = dp_register_genl();
2017         if (err < 0)
2018                 goto error_unreg_notifier;
2019
2020         return 0;
2021
2022 error_unreg_notifier:
2023         unregister_netdevice_notifier(&dp_device_notifier);
2024 error_vport_exit:
2025         vport_exit();
2026 error_flow_exit:
2027         flow_exit();
2028 error_tnl_exit:
2029         tnl_exit();
2030 error:
2031         return err;
2032 }
2033
2034 static void dp_cleanup(void)
2035 {
2036         rcu_barrier();
2037         dp_unregister_genl(ARRAY_SIZE(dp_genl_families));
2038         unregister_netdevice_notifier(&dp_device_notifier);
2039         vport_exit();
2040         flow_exit();
2041         tnl_exit();
2042 }
2043
2044 module_init(dp_init);
2045 module_exit(dp_cleanup);
2046
2047 MODULE_DESCRIPTION("Open vSwitch switching datapath");
2048 MODULE_LICENSE("GPL");