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/fs.h>
  16 #include <linux/if_arp.h>
  17 #include <linux/if_vlan.h>
  18 #include <linux/in.h>
  19 #include <linux/ip.h>
  20 #include <linux/delay.h>
  21 #include <linux/time.h>
  22 #include <linux/etherdevice.h>
  23 #include <linux/kernel.h>
  24 #include <linux/kthread.h>
  25 #include <linux/mutex.h>
  26 #include <linux/percpu.h>
  27 #include <linux/rcupdate.h>
  28 #include <linux/tcp.h>
  29 #include <linux/udp.h>
  30 #include <linux/version.h>
  31 #include <linux/ethtool.h>
  32 #include <linux/wait.h>
  33 #include <asm/system.h>
  34 #include <asm/div64.h>
  35 #include <asm/bug.h>
  36 #include <linux/highmem.h>
  37 #include <linux/netfilter_bridge.h>
  38 #include <linux/netfilter_ipv4.h>
  39 #include <linux/inetdevice.h>
  40 #include <linux/list.h>
  41 #include <linux/rculist.h>
  42 #include <linux/dmi.h>
  43 #include <net/inet_ecn.h>
  44 #include <net/genetlink.h>
  45 #include <linux/compat.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 "loop_counter.h"
  53 #include "odp-compat.h"
  54 #include "table.h"
  55 #include "vport-internal_dev.h"
  56
  57 int (*dp_ioctl_hook)(struct net_device *dev, struct ifreq *rq, int cmd);
  58 EXPORT_SYMBOL(dp_ioctl_hook);
  59
  60 /* Datapaths.  Protected on the read side by rcu_read_lock, on the write side
  61  * by dp_mutex.
  62  *
  63  * dp_mutex nests inside the RTNL lock: if you need both you must take the RTNL
  64  * lock first.
  65  *
  66  * It is safe to access the datapath and vport structures with just
  67  * dp_mutex.
  68  */
  69 static struct datapath __rcu *dps[ODP_MAX];
  70 static DEFINE_MUTEX(dp_mutex);
  71
  72 static int new_vport(struct datapath *, struct odp_port *, int port_no);
  73
  74 /* Must be called with rcu_read_lock or dp_mutex. */
  75 struct datapath *get_dp(int dp_idx)
  76 {
  77         if (dp_idx < 0 || dp_idx >= ODP_MAX)
  78                 return NULL;
  79         return rcu_dereference_check(dps[dp_idx], rcu_read_lock_held() ||
  80                                          lockdep_is_held(&dp_mutex));
  81 }
  82 EXPORT_SYMBOL_GPL(get_dp);
  83
  84 static struct datapath *get_dp_locked(int dp_idx)
  85 {
  86         struct datapath *dp;
  87
  88         mutex_lock(&dp_mutex);
  89         dp = get_dp(dp_idx);
  90         if (dp)
  91                 mutex_lock(&dp->mutex);
  92         mutex_unlock(&dp_mutex);
  93         return dp;
  94 }
  95
  96 static struct tbl *get_table_protected(struct datapath *dp)
  97 {
  98         return rcu_dereference_protected(dp->table,
  99                                          lockdep_is_held(&dp->mutex));
 100 }
 101
 102 static struct vport *get_vport_protected(struct datapath *dp, u16 port_no)
 103 {
 104         return rcu_dereference_protected(dp->ports[port_no],
 105                                          lockdep_is_held(&dp->mutex));
 106 }
 107
 108 /* Must be called with rcu_read_lock or RTNL lock. */
 109 const char *dp_name(const struct datapath *dp)
 110 {
 111         return vport_get_name(rcu_dereference_rtnl(dp->ports[ODPP_LOCAL]));
 112 }
 113
 114 static inline size_t br_nlmsg_size(void)
 115 {
 116         return NLMSG_ALIGN(sizeof(struct ifinfomsg))
 117                + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
 118                + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
 119                + nla_total_size(4) /* IFLA_MASTER */
 120                + nla_total_size(4) /* IFLA_MTU */
 121                + nla_total_size(4) /* IFLA_LINK */
 122                + nla_total_size(1); /* IFLA_OPERSTATE */
 123 }
 124
 125 static int dp_fill_ifinfo(struct sk_buff *skb,
 126                           const struct vport *port,
 127                           int event, unsigned int flags)
 128 {
 129         struct datapath *dp = port->dp;
 130         int ifindex = vport_get_ifindex(port);
 131         int iflink = vport_get_iflink(port);
 132         struct ifinfomsg *hdr;
 133         struct nlmsghdr *nlh;
 134
 135         if (ifindex < 0)
 136                 return ifindex;
 137
 138         if (iflink < 0)
 139                 return iflink;
 140
 141         nlh = nlmsg_put(skb, 0, 0, event, sizeof(*hdr), flags);
 142         if (nlh == NULL)
 143                 return -EMSGSIZE;
 144
 145         hdr = nlmsg_data(nlh);
 146         hdr->ifi_family = AF_BRIDGE;
 147         hdr->__ifi_pad = 0;
 148         hdr->ifi_type = ARPHRD_ETHER;
 149         hdr->ifi_index = ifindex;
 150         hdr->ifi_flags = vport_get_flags(port);
 151         hdr->ifi_change = 0;
 152
 153         NLA_PUT_STRING(skb, IFLA_IFNAME, vport_get_name(port));
 154         NLA_PUT_U32(skb, IFLA_MASTER,
 155                 vport_get_ifindex(get_vport_protected(dp, ODPP_LOCAL)));
 156         NLA_PUT_U32(skb, IFLA_MTU, vport_get_mtu(port));
 157 #ifdef IFLA_OPERSTATE
 158         NLA_PUT_U8(skb, IFLA_OPERSTATE,
 159                    vport_is_running(port)
 160                         ? vport_get_operstate(port)
 161                         : IF_OPER_DOWN);
 162 #endif
 163
 164         NLA_PUT(skb, IFLA_ADDRESS, ETH_ALEN, vport_get_addr(port));
 165
 166         if (ifindex != iflink)
 167                 NLA_PUT_U32(skb, IFLA_LINK,iflink);
 168
 169         return nlmsg_end(skb, nlh);
 170
 171 nla_put_failure:
 172         nlmsg_cancel(skb, nlh);
 173         return -EMSGSIZE;
 174 }
 175
 176 static void dp_ifinfo_notify(int event, struct vport *port)
 177 {
 178         struct sk_buff *skb;
 179         int err = -ENOBUFS;
 180
 181         skb = nlmsg_new(br_nlmsg_size(), GFP_KERNEL);
 182         if (skb == NULL)
 183                 goto errout;
 184
 185         err = dp_fill_ifinfo(skb, port, event, 0);
 186         if (err < 0) {
 187                 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
 188                 WARN_ON(err == -EMSGSIZE);
 189                 kfree_skb(skb);
 190                 goto errout;
 191         }
 192         rtnl_notify(skb, &init_net, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
 193         return;
 194 errout:
 195         if (err < 0)
 196                 rtnl_set_sk_err(&init_net, RTNLGRP_LINK, err);
 197 }
 198
 199 static void release_dp(struct kobject *kobj)
 200 {
 201         struct datapath *dp = container_of(kobj, struct datapath, ifobj);
 202         kfree(dp);
 203 }
 204
 205 static struct kobj_type dp_ktype = {
 206         .release = release_dp
 207 };
 208
 209 static int create_dp(int dp_idx, const char __user *devnamep)
 210 {
 211         struct odp_port internal_dev_port;
 212         char devname[IFNAMSIZ];
 213         struct datapath *dp;
 214         int err;
 215         int i;
 216
 217         if (devnamep) {
 218                 int retval = strncpy_from_user(devname, devnamep, IFNAMSIZ);
 219                 if (retval < 0) {
 220                         err = -EFAULT;
 221                         goto err;
 222                 } else if (retval >= IFNAMSIZ) {
 223                         err = -ENAMETOOLONG;
 224                         goto err;
 225                 }
 226         } else {
 227                 snprintf(devname, sizeof(devname), "of%d", dp_idx);
 228         }
 229
 230         rtnl_lock();
 231         mutex_lock(&dp_mutex);
 232         err = -ENODEV;
 233         if (!try_module_get(THIS_MODULE))
 234                 goto err_unlock;
 235
 236         /* Exit early if a datapath with that number already exists.
 237          * (We don't use -EEXIST because that's ambiguous with 'devname'
 238          * conflicting with an existing network device name.) */
 239         err = -EBUSY;
 240         if (get_dp(dp_idx))
 241                 goto err_put_module;
 242
 243         err = -ENOMEM;
 244         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
 245         if (dp == NULL)
 246                 goto err_put_module;
 247         INIT_LIST_HEAD(&dp->port_list);
 248         mutex_init(&dp->mutex);
 249         mutex_lock(&dp->mutex);
 250         dp->dp_idx = dp_idx;
 251         for (i = 0; i < DP_N_QUEUES; i++)
 252                 skb_queue_head_init(&dp->queues[i]);
 253         init_waitqueue_head(&dp->waitqueue);
 254
 255         /* Initialize kobject for bridge.  This will be added as
 256          * /sys/class/net/<devname>/brif later, if sysfs is enabled. */
 257         dp->ifobj.kset = NULL;
 258         kobject_init(&dp->ifobj, &dp_ktype);
 259
 260         /* Allocate table. */
 261         err = -ENOMEM;
 262         rcu_assign_pointer(dp->table, tbl_create(TBL_MIN_BUCKETS));
 263         if (!dp->table)
 264                 goto err_free_dp;
 265
 266         /* Set up our datapath device. */
 267         BUILD_BUG_ON(sizeof(internal_dev_port.devname) != sizeof(devname));
 268         strcpy(internal_dev_port.devname, devname);
 269         internal_dev_port.type = ODP_VPORT_TYPE_INTERNAL;
 270         err = new_vport(dp, &internal_dev_port, ODPP_LOCAL);
 271         if (err) {
 272                 if (err == -EBUSY)
 273                         err = -EEXIST;
 274
 275                 goto err_destroy_table;
 276         }
 277
 278         dp->drop_frags = 0;
 279         dp->stats_percpu = alloc_percpu(struct dp_stats_percpu);
 280         if (!dp->stats_percpu) {
 281                 err = -ENOMEM;
 282                 goto err_destroy_local_port;
 283         }
 284
 285         rcu_assign_pointer(dps[dp_idx], dp);
 286         dp_sysfs_add_dp(dp);
 287
 288         mutex_unlock(&dp->mutex);
 289         mutex_unlock(&dp_mutex);
 290         rtnl_unlock();
 291
 292         return 0;
 293
 294 err_destroy_local_port:
 295         dp_detach_port(get_vport_protected(dp, ODPP_LOCAL));
 296 err_destroy_table:
 297         tbl_destroy(get_table_protected(dp), NULL);
 298 err_free_dp:
 299         mutex_unlock(&dp->mutex);
 300         kfree(dp);
 301 err_put_module:
 302         module_put(THIS_MODULE);
 303 err_unlock:
 304         mutex_unlock(&dp_mutex);
 305         rtnl_unlock();
 306 err:
 307         return err;
 308 }
 309
 310 static void destroy_dp_rcu(struct rcu_head *rcu)
 311 {
 312         struct datapath *dp = container_of(rcu, struct datapath, rcu);
 313         int i;
 314
 315         for (i = 0; i < DP_N_QUEUES; i++)
 316                 skb_queue_purge(&dp->queues[i]);
 317
 318         tbl_destroy((struct tbl __force *)dp->table, flow_free_tbl);
 319         free_percpu(dp->stats_percpu);
 320         kobject_put(&dp->ifobj);
 321 }
 322
 323 static int destroy_dp(int dp_idx)
 324 {
 325         struct datapath *dp;
 326         int err = 0;
 327         struct vport *p, *n;
 328
 329         rtnl_lock();
 330         mutex_lock(&dp_mutex);
 331         dp = get_dp(dp_idx);
 332         if (!dp) {
 333                 err = -ENODEV;
 334                 goto out;
 335         }
 336
 337         mutex_lock(&dp->mutex);
 338
 339         list_for_each_entry_safe (p, n, &dp->port_list, node)
 340                 if (p->port_no != ODPP_LOCAL)
 341                         dp_detach_port(p);
 342
 343         dp_sysfs_del_dp(dp);
 344         rcu_assign_pointer(dps[dp->dp_idx], NULL);
 345         dp_detach_port(get_vport_protected(dp, ODPP_LOCAL));
 346
 347         mutex_unlock(&dp->mutex);
 348         call_rcu(&dp->rcu, destroy_dp_rcu);
 349         module_put(THIS_MODULE);
 350
 351 out:
 352         mutex_unlock(&dp_mutex);
 353         rtnl_unlock();
 354         return err;
 355 }
 356
 357 /* Called with RTNL lock and dp->mutex. */
 358 static int new_vport(struct datapath *dp, struct odp_port *odp_port, int port_no)
 359 {
 360         struct vport_parms parms;
 361         struct vport *vport;
 362
 363         parms.name = odp_port->devname;
 364         parms.type = odp_port->type;
 365         parms.config = odp_port->config;
 366         parms.dp = dp;
 367         parms.port_no = port_no;
 368
 369         vport_lock();
 370         vport = vport_add(&parms);
 371         vport_unlock();
 372
 373         if (IS_ERR(vport))
 374                 return PTR_ERR(vport);
 375
 376         rcu_assign_pointer(dp->ports[port_no], vport);
 377         list_add_rcu(&vport->node, &dp->port_list);
 378         dp->n_ports++;
 379
 380         dp_ifinfo_notify(RTM_NEWLINK, vport);
 381
 382         return 0;
 383 }
 384
 385 static int attach_port(int dp_idx, struct odp_port __user *portp)
 386 {
 387         struct datapath *dp;
 388         struct odp_port port;
 389         int port_no;
 390         int err;
 391
 392         err = -EFAULT;
 393         if (copy_from_user(&port, portp, sizeof(port)))
 394                 goto out;
 395         port.devname[IFNAMSIZ - 1] = '\0';
 396
 397         rtnl_lock();
 398         dp = get_dp_locked(dp_idx);
 399         err = -ENODEV;
 400         if (!dp)
 401                 goto out_unlock_rtnl;
 402
 403         for (port_no = 1; port_no < DP_MAX_PORTS; port_no++)
 404                 if (!dp->ports[port_no])
 405                         goto got_port_no;
 406         err = -EFBIG;
 407         goto out_unlock_dp;
 408
 409 got_port_no:
 410         err = new_vport(dp, &port, port_no);
 411         if (err)
 412                 goto out_unlock_dp;
 413
 414         set_internal_devs_mtu(dp);
 415         dp_sysfs_add_if(get_vport_protected(dp, port_no));
 416
 417         err = put_user(port_no, &portp->port);
 418
 419 out_unlock_dp:
 420         mutex_unlock(&dp->mutex);
 421 out_unlock_rtnl:
 422         rtnl_unlock();
 423 out:
 424         return err;
 425 }
 426
 427 int dp_detach_port(struct vport *p)
 428 {
 429         int err;
 430
 431         ASSERT_RTNL();
 432
 433         if (p->port_no != ODPP_LOCAL)
 434                 dp_sysfs_del_if(p);
 435         dp_ifinfo_notify(RTM_DELLINK, p);
 436
 437         /* First drop references to device. */
 438         p->dp->n_ports--;
 439         list_del_rcu(&p->node);
 440         rcu_assign_pointer(p->dp->ports[p->port_no], NULL);
 441
 442         /* Then destroy it. */
 443         vport_lock();
 444         err = vport_del(p);
 445         vport_unlock();
 446
 447         return err;
 448 }
 449
 450 static int detach_port(int dp_idx, int port_no)
 451 {
 452         struct vport *p;
 453         struct datapath *dp;
 454         int err;
 455
 456         err = -EINVAL;
 457         if (port_no < 0 || port_no >= DP_MAX_PORTS || port_no == ODPP_LOCAL)
 458                 goto out;
 459
 460         rtnl_lock();
 461         dp = get_dp_locked(dp_idx);
 462         err = -ENODEV;
 463         if (!dp)
 464                 goto out_unlock_rtnl;
 465
 466         p = get_vport_protected(dp, port_no);
 467         err = -ENOENT;
 468         if (!p)
 469                 goto out_unlock_dp;
 470
 471         err = dp_detach_port(p);
 472
 473 out_unlock_dp:
 474         mutex_unlock(&dp->mutex);
 475 out_unlock_rtnl:
 476         rtnl_unlock();
 477 out:
 478         return err;
 479 }
 480
 481 /* Must be called with rcu_read_lock. */
 482 void dp_process_received_packet(struct vport *p, struct sk_buff *skb)
 483 {
 484         struct datapath *dp = p->dp;
 485         struct dp_stats_percpu *stats;
 486         int stats_counter_off;
 487         struct sw_flow_actions *acts;
 488         struct loop_counter *loop;
 489         int error;
 490
 491         OVS_CB(skb)->vport = p;
 492
 493         if (!OVS_CB(skb)->flow) {
 494                 struct sw_flow_key key;
 495                 struct tbl_node *flow_node;
 496                 bool is_frag;
 497
 498                 /* Extract flow from 'skb' into 'key'. */
 499                 error = flow_extract(skb, p ? p->port_no : ODPP_NONE, &key, &is_frag);
 500                 if (unlikely(error)) {
 501                         kfree_skb(skb);
 502                         return;
 503                 }
 504
 505                 if (is_frag && dp->drop_frags) {
 506                         kfree_skb(skb);
 507                         stats_counter_off = offsetof(struct dp_stats_percpu, n_frags);
 508                         goto out;
 509                 }
 510
 511                 /* Look up flow. */
 512                 flow_node = tbl_lookup(rcu_dereference(dp->table), &key,
 513                                         flow_hash(&key), flow_cmp);
 514                 if (unlikely(!flow_node)) {
 515                         struct dp_upcall_info upcall;
 516
 517                         upcall.type = _ODPL_MISS_NR;
 518                         upcall.key = &key;
 519                         upcall.userdata = 0;
 520                         upcall.sample_pool = 0;
 521                         upcall.actions = NULL;
 522                         upcall.actions_len = 0;
 523                         dp_upcall(dp, skb, &upcall);
 524                         stats_counter_off = offsetof(struct dp_stats_percpu, n_missed);
 525                         goto out;
 526                 }
 527
 528                 OVS_CB(skb)->flow = flow_cast(flow_node);
 529         }
 530
 531         stats_counter_off = offsetof(struct dp_stats_percpu, n_hit);
 532         flow_used(OVS_CB(skb)->flow, skb);
 533
 534         acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);
 535
 536         /* Check whether we've looped too much. */
 537         loop = loop_get_counter();
 538         if (unlikely(++loop->count > MAX_LOOPS))
 539                 loop->looping = true;
 540         if (unlikely(loop->looping)) {
 541                 loop_suppress(dp, acts);
 542                 kfree_skb(skb);
 543                 goto out_loop;
 544         }
 545
 546         /* Execute actions. */
 547         execute_actions(dp, skb, &OVS_CB(skb)->flow->key, acts->actions,
 548                         acts->actions_len);
 549
 550         /* Check whether sub-actions looped too much. */
 551         if (unlikely(loop->looping))
 552                 loop_suppress(dp, acts);
 553
 554 out_loop:
 555         /* Decrement loop counter. */
 556         if (!--loop->count)
 557                 loop->looping = false;
 558         loop_put_counter();
 559
 560 out:
 561         /* Update datapath statistics. */
 562         local_bh_disable();
 563         stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 564
 565         write_seqcount_begin(&stats->seqlock);
 566         (*(u64 *)((u8 *)stats + stats_counter_off))++;
 567         write_seqcount_end(&stats->seqlock);
 568
 569         local_bh_enable();
 570 }
 571
 572 static void copy_and_csum_skb(struct sk_buff *skb, void *to)
 573 {
 574         u16 csum_start, csum_offset;
 575         __wsum csum;
 576
 577         get_skb_csum_pointers(skb, &csum_start, &csum_offset);
 578         csum_start -= skb_headroom(skb);
 579         BUG_ON(csum_start >= skb_headlen(skb));
 580
 581         skb_copy_bits(skb, 0, to, csum_start);
 582
 583         csum = skb_copy_and_csum_bits(skb, csum_start, to + csum_start,
 584                                       skb->len - csum_start, 0);
 585         *(__sum16 *)(to + csum_start + csum_offset) = csum_fold(csum);
 586 }
 587
 588 /* Append each packet in 'skb' list to 'queue'.  There will be only one packet
 589  * unless we broke up a GSO packet. */
 590 static int queue_control_packets(struct datapath *dp, struct sk_buff *skb,
 591                                  const struct dp_upcall_info *upcall_info)
 592 {
 593         struct sk_buff *nskb;
 594         int port_no;
 595         int err;
 596
 597         if (OVS_CB(skb)->vport)
 598                 port_no = OVS_CB(skb)->vport->port_no;
 599         else
 600                 port_no = ODPP_LOCAL;
 601
 602         do {
 603                 struct odp_packet *upcall;
 604                 struct sk_buff *user_skb; /* to be queued to userspace */
 605                 struct nlattr *nla;
 606                 unsigned int len;
 607
 608                 nskb = skb->next;
 609                 skb->next = NULL;
 610
 611                 len = sizeof(struct odp_packet);
 612                 len += nla_total_size(4); /* ODP_PACKET_ATTR_TYPE. */
 613                 len += nla_total_size(skb->len);
 614                 len += nla_total_size(FLOW_BUFSIZE);
 615                 if (upcall_info->userdata)
 616                         len += nla_total_size(8);
 617                 if (upcall_info->sample_pool)
 618                         len += nla_total_size(4);
 619                 if (upcall_info->actions_len)
 620                         len += nla_total_size(upcall_info->actions_len);
 621
 622                 user_skb = alloc_skb(len, GFP_ATOMIC);
 623                 if (!user_skb)
 624                         goto err_kfree_skbs;
 625
 626                 upcall = (struct odp_packet *)__skb_put(user_skb, sizeof(*upcall));
 627                 upcall->dp_idx = dp->dp_idx;
 628
 629                 nla_put_u32(user_skb, ODP_PACKET_ATTR_TYPE, upcall_info->type);
 630
 631                 nla = nla_nest_start(user_skb, ODP_PACKET_ATTR_KEY);
 632                 flow_to_nlattrs(upcall_info->key, user_skb);
 633                 nla_nest_end(user_skb, nla);
 634
 635                 if (upcall_info->userdata)
 636                         nla_put_u64(user_skb, ODP_PACKET_ATTR_USERDATA, upcall_info->userdata);
 637                 if (upcall_info->sample_pool)
 638                         nla_put_u32(user_skb, ODP_PACKET_ATTR_SAMPLE_POOL, upcall_info->sample_pool);
 639                 if (upcall_info->actions_len) {
 640                         const struct nlattr *actions = upcall_info->actions;
 641                         u32 actions_len = upcall_info->actions_len;
 642
 643                         nla = nla_nest_start(user_skb, ODP_PACKET_ATTR_ACTIONS);
 644                         memcpy(__skb_put(user_skb, actions_len), actions, actions_len);
 645                         nla_nest_end(user_skb, nla);
 646                 }
 647
 648                 nla = __nla_reserve(user_skb, ODP_PACKET_ATTR_PACKET, skb->len);
 649                 if (skb->ip_summed == CHECKSUM_PARTIAL)
 650                         copy_and_csum_skb(skb, nla_data(nla));
 651                 else
 652                         skb_copy_bits(skb, 0, nla_data(nla), skb->len);
 653
 654                 upcall->len = user_skb->len;
 655                 skb_queue_tail(&dp->queues[upcall_info->type], user_skb);
 656
 657                 kfree_skb(skb);
 658                 skb = nskb;
 659         } while (skb);
 660         return 0;
 661
 662 err_kfree_skbs:
 663         kfree_skb(skb);
 664         while ((skb = nskb) != NULL) {
 665                 nskb = skb->next;
 666                 kfree_skb(skb);
 667         }
 668         return err;
 669 }
 670
 671 int dp_upcall(struct datapath *dp, struct sk_buff *skb, const struct dp_upcall_info *upcall_info)
 672 {
 673         struct dp_stats_percpu *stats;
 674         struct sk_buff_head *queue;
 675         int err;
 676
 677         WARN_ON_ONCE(skb_shared(skb));
 678         BUG_ON(upcall_info->type >= DP_N_QUEUES);
 679
 680         queue = &dp->queues[upcall_info->type];
 681         err = -ENOBUFS;
 682         if (skb_queue_len(queue) >= DP_MAX_QUEUE_LEN)
 683                 goto err_kfree_skb;
 684
 685         forward_ip_summed(skb);
 686
 687         err = vswitch_skb_checksum_setup(skb);
 688         if (err)
 689                 goto err_kfree_skb;
 690
 691         /* Break apart GSO packets into their component pieces.  Otherwise
 692          * userspace may try to stuff a 64kB packet into a 1500-byte MTU. */
 693         if (skb_is_gso(skb)) {
 694                 struct sk_buff *nskb = skb_gso_segment(skb, NETIF_F_SG | NETIF_F_HW_CSUM);
 695
 696                 kfree_skb(skb);
 697                 skb = nskb;
 698                 if (IS_ERR(skb)) {
 699                         err = PTR_ERR(skb);
 700                         goto err;
 701                 }
 702         }
 703
 704         err = queue_control_packets(dp, skb, upcall_info);
 705         wake_up_interruptible(&dp->waitqueue);
 706         return err;
 707
 708 err_kfree_skb:
 709         kfree_skb(skb);
 710 err:
 711         local_bh_disable();
 712         stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 713
 714         write_seqcount_begin(&stats->seqlock);
 715         stats->n_lost++;
 716         write_seqcount_end(&stats->seqlock);
 717
 718         local_bh_enable();
 719
 720         return err;
 721 }
 722
 723 static int flush_flows(struct datapath *dp)
 724 {
 725         struct tbl *old_table = get_table_protected(dp);
 726         struct tbl *new_table;
 727
 728         new_table = tbl_create(TBL_MIN_BUCKETS);
 729         if (!new_table)
 730                 return -ENOMEM;
 731
 732         rcu_assign_pointer(dp->table, new_table);
 733
 734         tbl_deferred_destroy(old_table, flow_free_tbl);
 735
 736         return 0;
 737 }
 738
 739 static int validate_actions(const struct nlattr *actions, u32 actions_len)
 740 {
 741         const struct nlattr *a;
 742         int rem;
 743
 744         nla_for_each_attr(a, actions, actions_len, rem) {
 745                 static const u32 action_lens[ODPAT_MAX + 1] = {
 746                         [ODPAT_OUTPUT] = 4,
 747                         [ODPAT_CONTROLLER] = 8,
 748                         [ODPAT_SET_DL_TCI] = 2,
 749                         [ODPAT_STRIP_VLAN] = 0,
 750                         [ODPAT_SET_DL_SRC] = ETH_ALEN,
 751                         [ODPAT_SET_DL_DST] = ETH_ALEN,
 752                         [ODPAT_SET_NW_SRC] = 4,
 753                         [ODPAT_SET_NW_DST] = 4,
 754                         [ODPAT_SET_NW_TOS] = 1,
 755                         [ODPAT_SET_TP_SRC] = 2,
 756                         [ODPAT_SET_TP_DST] = 2,
 757                         [ODPAT_SET_TUNNEL] = 8,
 758                         [ODPAT_SET_PRIORITY] = 4,
 759                         [ODPAT_POP_PRIORITY] = 0,
 760                         [ODPAT_DROP_SPOOFED_ARP] = 0,
 761                 };
 762                 int type = nla_type(a);
 763
 764                 if (type > ODPAT_MAX || nla_len(a) != action_lens[type])
 765                         return -EINVAL;
 766
 767                 switch (type) {
 768                 case ODPAT_UNSPEC:
 769                         return -EINVAL;
 770
 771                 case ODPAT_CONTROLLER:
 772                 case ODPAT_STRIP_VLAN:
 773                 case ODPAT_SET_DL_SRC:
 774                 case ODPAT_SET_DL_DST:
 775                 case ODPAT_SET_NW_SRC:
 776                 case ODPAT_SET_NW_DST:
 777                 case ODPAT_SET_TP_SRC:
 778                 case ODPAT_SET_TP_DST:
 779                 case ODPAT_SET_TUNNEL:
 780                 case ODPAT_SET_PRIORITY:
 781                 case ODPAT_POP_PRIORITY:
 782                 case ODPAT_DROP_SPOOFED_ARP:
 783                         /* No validation needed. */
 784                         break;
 785
 786                 case ODPAT_OUTPUT:
 787                         if (nla_get_u32(a) >= DP_MAX_PORTS)
 788                                 return -EINVAL;
 789                         break;
 790
 791                 case ODPAT_SET_DL_TCI:
 792                         if (nla_get_be16(a) & htons(VLAN_CFI_MASK))
 793                                 return -EINVAL;
 794                         break;
 795
 796                 case ODPAT_SET_NW_TOS:
 797                         if (nla_get_u8(a) & INET_ECN_MASK)
 798                                 return -EINVAL;
 799                         break;
 800
 801                 default:
 802                         return -EOPNOTSUPP;
 803                 }
 804         }
 805
 806         if (rem > 0)
 807                 return -EINVAL;
 808
 809         return 0;
 810 }
 811
 812 static struct sw_flow_actions *get_actions(const struct odp_flow *flow)
 813 {
 814         struct sw_flow_actions *actions;
 815         int error;
 816
 817         actions = flow_actions_alloc(flow->actions_len);
 818         error = PTR_ERR(actions);
 819         if (IS_ERR(actions))
 820                 goto error;
 821
 822         error = -EFAULT;
 823         if (copy_from_user(actions->actions,
 824                            (struct nlattr __user __force *)flow->actions,
 825                            flow->actions_len))
 826                 goto error_free_actions;
 827         error = validate_actions(actions->actions, actions->actions_len);
 828         if (error)
 829                 goto error_free_actions;
 830
 831         return actions;
 832
 833 error_free_actions:
 834         kfree(actions);
 835 error:
 836         return ERR_PTR(error);
 837 }
 838
 839 static void get_stats(struct sw_flow *flow, struct odp_flow_stats *stats)
 840 {
 841         if (flow->used) {
 842                 struct timespec offset_ts, used, now_mono;
 843
 844                 ktime_get_ts(&now_mono);
 845                 jiffies_to_timespec(jiffies - flow->used, &offset_ts);
 846                 set_normalized_timespec(&used, now_mono.tv_sec - offset_ts.tv_sec,
 847                                         now_mono.tv_nsec - offset_ts.tv_nsec);
 848
 849                 stats->used_sec = used.tv_sec;
 850                 stats->used_nsec = used.tv_nsec;
 851         } else {
 852                 stats->used_sec = 0;
 853                 stats->used_nsec = 0;
 854         }
 855
 856         stats->n_packets = flow->packet_count;
 857         stats->n_bytes = flow->byte_count;
 858         stats->reserved = 0;
 859         stats->tcp_flags = flow->tcp_flags;
 860         stats->error = 0;
 861 }
 862
 863 static void clear_stats(struct sw_flow *flow)
 864 {
 865         flow->used = 0;
 866         flow->tcp_flags = 0;
 867         flow->packet_count = 0;
 868         flow->byte_count = 0;
 869 }
 870
 871 static int expand_table(struct datapath *dp)
 872 {
 873         struct tbl *old_table = get_table_protected(dp);
 874         struct tbl *new_table;
 875
 876         new_table = tbl_expand(old_table);
 877         if (IS_ERR(new_table))
 878                 return PTR_ERR(new_table);
 879
 880         rcu_assign_pointer(dp->table, new_table);
 881         tbl_deferred_destroy(old_table, NULL);
 882
 883         return 0;
 884 }
 885
 886 static int do_put_flow(struct datapath *dp, struct odp_flow_put *uf,
 887                        struct odp_flow_stats *stats)
 888 {
 889         struct tbl_node *flow_node;
 890         struct sw_flow_key key;
 891         struct sw_flow *flow;
 892         struct tbl *table;
 893         struct sw_flow_actions *acts = NULL;
 894         int error;
 895         u32 hash;
 896
 897         error = flow_copy_from_user(&key, (const struct nlattr __force __user *)uf->flow.key,
 898                                     uf->flow.key_len);
 899         if (error)
 900                 return error;
 901
 902         hash = flow_hash(&key);
 903         table = get_table_protected(dp);
 904         flow_node = tbl_lookup(table, &key, hash, flow_cmp);
 905         if (!flow_node) {
 906                 /* No such flow. */
 907                 error = -ENOENT;
 908                 if (!(uf->flags & ODPPF_CREATE))
 909                         goto error;
 910
 911                 /* Expand table, if necessary, to make room. */
 912                 if (tbl_count(table) >= tbl_n_buckets(table)) {
 913                         error = expand_table(dp);
 914                         if (error)
 915                                 goto error;
 916                         table = get_table_protected(dp);
 917                 }
 918
 919                 /* Allocate flow. */
 920                 flow = flow_alloc();
 921                 if (IS_ERR(flow)) {
 922                         error = PTR_ERR(flow);
 923                         goto error;
 924                 }
 925                 flow->key = key;
 926                 clear_stats(flow);
 927
 928                 /* Obtain actions. */
 929                 acts = get_actions(&uf->flow);
 930                 error = PTR_ERR(acts);
 931                 if (IS_ERR(acts))
 932                         goto error_free_flow;
 933                 rcu_assign_pointer(flow->sf_acts, acts);
 934
 935                 /* Put flow in bucket. */
 936                 error = tbl_insert(table, &flow->tbl_node, hash);
 937                 if (error)
 938                         goto error_free_flow_acts;
 939
 940                 memset(stats, 0, sizeof(struct odp_flow_stats));
 941         } else {
 942                 /* We found a matching flow. */
 943                 struct sw_flow_actions *old_acts, *new_acts;
 944
 945                 flow = flow_cast(flow_node);
 946
 947                 /* Bail out if we're not allowed to modify an existing flow. */
 948                 error = -EEXIST;
 949                 if (!(uf->flags & ODPPF_MODIFY))
 950                         goto error;
 951
 952                 /* Swap actions. */
 953                 new_acts = get_actions(&uf->flow);
 954                 error = PTR_ERR(new_acts);
 955                 if (IS_ERR(new_acts))
 956                         goto error;
 957
 958                 old_acts = rcu_dereference_protected(flow->sf_acts,
 959                                                      lockdep_is_held(&dp->mutex));
 960                 if (old_acts->actions_len != new_acts->actions_len ||
 961                     memcmp(old_acts->actions, new_acts->actions,
 962                            old_acts->actions_len)) {
 963                         rcu_assign_pointer(flow->sf_acts, new_acts);
 964                         flow_deferred_free_acts(old_acts);
 965                 } else {
 966                         kfree(new_acts);
 967                 }
 968
 969                 /* Fetch stats, then clear them if necessary. */
 970                 spin_lock_bh(&flow->lock);
 971                 get_stats(flow, stats);
 972                 if (uf->flags & ODPPF_ZERO_STATS)
 973                         clear_stats(flow);
 974                 spin_unlock_bh(&flow->lock);
 975         }
 976
 977         return 0;
 978
 979 error_free_flow_acts:
 980         kfree(acts);
 981 error_free_flow:
 982         flow->sf_acts = NULL;
 983         flow_put(flow);
 984 error:
 985         return error;
 986 }
 987
 988 static int put_flow(struct datapath *dp, struct odp_flow_put __user *ufp)
 989 {
 990         struct odp_flow_stats stats;
 991         struct odp_flow_put uf;
 992         int error;
 993
 994         if (copy_from_user(&uf, ufp, sizeof(struct odp_flow_put)))
 995                 return -EFAULT;
 996
 997         error = do_put_flow(dp, &uf, &stats);
 998         if (error)
 999                 return error;
1000
1001         if (copy_to_user(&ufp->flow.stats, &stats,
1002                          sizeof(struct odp_flow_stats)))
1003                 return -EFAULT;
1004
1005         return 0;
1006 }
1007
1008 static int do_answer_query(struct datapath *dp, struct sw_flow *flow,
1009                            u32 query_flags,
1010                            struct odp_flow_stats __user *ustats,
1011                            struct nlattr __user *actions,
1012                            u32 __user *actions_lenp)
1013 {
1014         struct sw_flow_actions *sf_acts;
1015         struct odp_flow_stats stats;
1016         u32 actions_len;
1017
1018         spin_lock_bh(&flow->lock);
1019         get_stats(flow, &stats);
1020         if (query_flags & ODPFF_ZERO_TCP_FLAGS)
1021                 flow->tcp_flags = 0;
1022
1023         spin_unlock_bh(&flow->lock);
1024
1025         if (copy_to_user(ustats, &stats, sizeof(struct odp_flow_stats)) ||
1026             get_user(actions_len, actions_lenp))
1027                 return -EFAULT;
1028
1029         if (!actions_len)
1030                 return 0;
1031
1032         sf_acts = rcu_dereference_protected(flow->sf_acts,
1033                                             lockdep_is_held(&dp->mutex));
1034         if (put_user(sf_acts->actions_len, actions_lenp) ||
1035             (actions && copy_to_user(actions, sf_acts->actions,
1036                                      min(sf_acts->actions_len, actions_len))))
1037                 return -EFAULT;
1038
1039         return 0;
1040 }
1041
1042 static int answer_query(struct datapath *dp, struct sw_flow *flow,
1043                         u32 query_flags, struct odp_flow __user *ufp)
1044 {
1045         struct nlattr __user *actions;
1046
1047         if (get_user(actions, (struct nlattr __user * __user *)&ufp->actions))
1048                 return -EFAULT;
1049
1050         return do_answer_query(dp, flow, query_flags,
1051                                &ufp->stats, actions, &ufp->actions_len);
1052 }
1053
1054 static struct sw_flow *do_del_flow(struct datapath *dp, const struct nlattr __user *key, u32 key_len)
1055 {
1056         struct tbl *table = get_table_protected(dp);
1057         struct tbl_node *flow_node;
1058         struct sw_flow_key swkey;
1059         int error;
1060
1061         error = flow_copy_from_user(&swkey, key, key_len);
1062         if (error)
1063                 return ERR_PTR(error);
1064
1065         flow_node = tbl_lookup(table, &swkey, flow_hash(&swkey), flow_cmp);
1066         if (!flow_node)
1067                 return ERR_PTR(-ENOENT);
1068
1069         error = tbl_remove(table, flow_node);
1070         if (error)
1071                 return ERR_PTR(error);
1072
1073         /* XXX Returned flow_node's statistics might lose a few packets, since
1074          * other CPUs can be using this flow.  We used to synchronize_rcu() to
1075          * make sure that we get completely accurate stats, but that blows our
1076          * performance, badly. */
1077         return flow_cast(flow_node);
1078 }
1079
1080 static int del_flow(struct datapath *dp, struct odp_flow __user *ufp)
1081 {
1082         struct sw_flow *flow;
1083         struct odp_flow uf;
1084         int error;
1085
1086         if (copy_from_user(&uf, ufp, sizeof(uf)))
1087                 return -EFAULT;
1088
1089         flow = do_del_flow(dp, (const struct nlattr __force __user *)uf.key, uf.key_len);
1090         if (IS_ERR(flow))
1091                 return PTR_ERR(flow);
1092
1093         error = answer_query(dp, flow, 0, ufp);
1094         flow_deferred_free(flow);
1095         return error;
1096 }
1097
1098 static int do_query_flows(struct datapath *dp, const struct odp_flowvec *flowvec)
1099 {
1100         struct tbl *table = get_table_protected(dp);
1101         u32 i;
1102
1103         for (i = 0; i < flowvec->n_flows; i++) {
1104                 struct odp_flow __user *ufp = (struct odp_flow __user __force *)&flowvec->flows[i];
1105                 struct sw_flow_key key;
1106                 struct odp_flow uf;
1107                 struct tbl_node *flow_node;
1108                 int error;
1109
1110                 if (copy_from_user(&uf, ufp, sizeof(uf)))
1111                         return -EFAULT;
1112
1113                 error = flow_copy_from_user(&key, (const struct nlattr __force __user *)uf.key, uf.key_len);
1114                 if (error)
1115                         return error;
1116
1117                 flow_node = tbl_lookup(table, &uf.key, flow_hash(&key), flow_cmp);
1118                 if (!flow_node)
1119                         error = put_user(ENOENT, &ufp->stats.error);
1120                 else
1121                         error = answer_query(dp, flow_cast(flow_node), uf.flags, ufp);
1122                 if (error)
1123                         return -EFAULT;
1124         }
1125         return flowvec->n_flows;
1126 }
1127
1128 static int do_flowvec_ioctl(struct datapath *dp, unsigned long argp,
1129                             int (*function)(struct datapath *,
1130                                             const struct odp_flowvec *))
1131 {
1132         struct odp_flowvec __user *uflowvec;
1133         struct odp_flowvec flowvec;
1134         int retval;
1135
1136         uflowvec = (struct odp_flowvec __user *)argp;
1137         if (copy_from_user(&flowvec, uflowvec, sizeof(flowvec)))
1138                 return -EFAULT;
1139
1140         if (flowvec.n_flows > INT_MAX / sizeof(struct odp_flow))
1141                 return -EINVAL;
1142
1143         retval = function(dp, &flowvec);
1144         return (retval < 0 ? retval
1145                 : retval == flowvec.n_flows ? 0
1146                 : put_user(retval, &uflowvec->n_flows));
1147 }
1148
1149 static struct sw_flow *do_dump_flow(struct datapath *dp, u32 __user *state)
1150 {
1151         struct tbl *table = get_table_protected(dp);
1152         struct tbl_node *tbl_node;
1153         u32 bucket, obj;
1154
1155         if (get_user(bucket, &state[0]) || get_user(obj, &state[1]))
1156                 return ERR_PTR(-EFAULT);
1157
1158         tbl_node = tbl_next(table, &bucket, &obj);
1159
1160         if (put_user(bucket, &state[0]) || put_user(obj, &state[1]))
1161                 return ERR_PTR(-EFAULT);
1162
1163         return tbl_node ? flow_cast(tbl_node) : NULL;
1164 }
1165
1166 static int dump_flow(struct datapath *dp, struct odp_flow_dump __user *udumpp)
1167 {
1168         struct odp_flow __user *uflowp;
1169         struct nlattr __user *ukey;
1170         struct sw_flow *flow;
1171         u32 key_len;
1172
1173         flow = do_dump_flow(dp, udumpp->state);
1174         if (IS_ERR(flow))
1175                 return PTR_ERR(flow);
1176
1177         if (get_user(uflowp, (struct odp_flow __user *__user*)&udumpp->flow))
1178                 return -EFAULT;
1179
1180         if (!flow)
1181                 return put_user(ODPFF_EOF, &uflowp->flags);
1182
1183         if (put_user(0, &uflowp->flags) ||
1184             get_user(ukey, (struct nlattr __user * __user*)&uflowp->key) ||
1185             get_user(key_len, &uflowp->key_len))
1186                 return -EFAULT;
1187
1188         key_len = flow_copy_to_user(ukey, &flow->key, key_len);
1189         if (key_len < 0)
1190                 return key_len;
1191         if (put_user(key_len, &uflowp->key_len))
1192                 return -EFAULT;
1193
1194         return answer_query(dp, flow, 0, uflowp);
1195 }
1196
1197 static int do_execute(struct datapath *dp, const struct odp_execute *execute)
1198 {
1199         struct sw_flow_key key;
1200         struct sk_buff *skb;
1201         struct sw_flow_actions *actions;
1202         struct ethhdr *eth;
1203         bool is_frag;
1204         int err;
1205
1206         err = -EINVAL;
1207         if (execute->length < ETH_HLEN || execute->length > 65535)
1208                 goto error;
1209
1210         actions = flow_actions_alloc(execute->actions_len);
1211         if (IS_ERR(actions)) {
1212                 err = PTR_ERR(actions);
1213                 goto error;
1214         }
1215
1216         err = -EFAULT;
1217         if (copy_from_user(actions->actions,
1218             (struct nlattr __user __force *)execute->actions, execute->actions_len))
1219                 goto error_free_actions;
1220
1221         err = validate_actions(actions->actions, execute->actions_len);
1222         if (err)
1223                 goto error_free_actions;
1224
1225         err = -ENOMEM;
1226         skb = alloc_skb(execute->length, GFP_KERNEL);
1227         if (!skb)
1228                 goto error_free_actions;
1229
1230         err = -EFAULT;
1231         if (copy_from_user(skb_put(skb, execute->length),
1232                            (const void __user __force *)execute->data,
1233                            execute->length))
1234                 goto error_free_skb;
1235
1236         skb_reset_mac_header(skb);
1237         eth = eth_hdr(skb);
1238
1239         /* Normally, setting the skb 'protocol' field would be handled by a
1240          * call to eth_type_trans(), but it assumes there's a sending
1241          * device, which we may not have. */
1242         if (ntohs(eth->h_proto) >= 1536)
1243                 skb->protocol = eth->h_proto;
1244         else
1245                 skb->protocol = htons(ETH_P_802_2);
1246
1247         err = flow_extract(skb, -1, &key, &is_frag);
1248         if (err)
1249                 goto error_free_skb;
1250
1251         rcu_read_lock();
1252         err = execute_actions(dp, skb, &key, actions->actions, actions->actions_len);
1253         rcu_read_unlock();
1254
1255         kfree(actions);
1256         return err;
1257
1258 error_free_skb:
1259         kfree_skb(skb);
1260 error_free_actions:
1261         kfree(actions);
1262 error:
1263         return err;
1264 }
1265
1266 static int execute_packet(struct datapath *dp, const struct odp_execute __user *executep)
1267 {
1268         struct odp_execute execute;
1269
1270         if (copy_from_user(&execute, executep, sizeof(execute)))
1271                 return -EFAULT;
1272
1273         return do_execute(dp, &execute);
1274 }
1275
1276 static int get_dp_stats(struct datapath *dp, struct odp_stats __user *statsp)
1277 {
1278         struct tbl *table = get_table_protected(dp);
1279         struct odp_stats stats;
1280         int i;
1281
1282         stats.n_flows = tbl_count(table);
1283         stats.cur_capacity = tbl_n_buckets(table);
1284         stats.max_capacity = TBL_MAX_BUCKETS;
1285         stats.n_ports = dp->n_ports;
1286         stats.max_ports = DP_MAX_PORTS;
1287         stats.n_frags = stats.n_hit = stats.n_missed = stats.n_lost = 0;
1288         for_each_possible_cpu(i) {
1289                 const struct dp_stats_percpu *percpu_stats;
1290                 struct dp_stats_percpu local_stats;
1291                 unsigned seqcount;
1292
1293                 percpu_stats = per_cpu_ptr(dp->stats_percpu, i);
1294
1295                 do {
1296                         seqcount = read_seqcount_begin(&percpu_stats->seqlock);
1297                         local_stats = *percpu_stats;
1298                 } while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
1299
1300                 stats.n_frags += local_stats.n_frags;
1301                 stats.n_hit += local_stats.n_hit;
1302                 stats.n_missed += local_stats.n_missed;
1303                 stats.n_lost += local_stats.n_lost;
1304         }
1305         stats.max_miss_queue = DP_MAX_QUEUE_LEN;
1306         stats.max_action_queue = DP_MAX_QUEUE_LEN;
1307         return copy_to_user(statsp, &stats, sizeof(stats)) ? -EFAULT : 0;
1308 }
1309
1310 /* MTU of the dp pseudo-device: ETH_DATA_LEN or the minimum of the ports */
1311 int dp_min_mtu(const struct datapath *dp)
1312 {
1313         struct vport *p;
1314         int mtu = 0;
1315
1316         ASSERT_RTNL();
1317
1318         list_for_each_entry_rcu (p, &dp->port_list, node) {
1319                 int dev_mtu;
1320
1321                 /* Skip any internal ports, since that's what we're trying to
1322                  * set. */
1323                 if (is_internal_vport(p))
1324                         continue;
1325
1326                 dev_mtu = vport_get_mtu(p);
1327                 if (!mtu || dev_mtu < mtu)
1328                         mtu = dev_mtu;
1329         }
1330
1331         return mtu ? mtu : ETH_DATA_LEN;
1332 }
1333
1334 /* Sets the MTU of all datapath devices to the minimum of the ports.  Must
1335  * be called with RTNL lock. */
1336 void set_internal_devs_mtu(const struct datapath *dp)
1337 {
1338         struct vport *p;
1339         int mtu;
1340
1341         ASSERT_RTNL();
1342
1343         mtu = dp_min_mtu(dp);
1344
1345         list_for_each_entry_rcu (p, &dp->port_list, node) {
1346                 if (is_internal_vport(p))
1347                         vport_set_mtu(p, mtu);
1348         }
1349 }
1350
1351 static void compose_odp_port(const struct vport *vport, struct odp_port *odp_port)
1352 {
1353         rcu_read_lock();
1354         strncpy(odp_port->devname, vport_get_name(vport), sizeof(odp_port->devname));
1355         odp_port->type = vport_get_type(vport);
1356         vport_get_config(vport, odp_port->config);
1357         odp_port->port = vport->port_no;
1358         odp_port->dp_idx = vport->dp->dp_idx;
1359         rcu_read_unlock();
1360 }
1361
1362 static int query_port(int dp_idx, struct odp_port __user *uport)
1363 {
1364         struct odp_port port;
1365
1366         if (copy_from_user(&port, uport, sizeof(port)))
1367                 return -EFAULT;
1368
1369         if (port.devname[0]) {
1370                 struct vport *vport;
1371
1372                 port.devname[IFNAMSIZ - 1] = '\0';
1373
1374                 vport_lock();
1375                 vport = vport_locate(port.devname);
1376                 if (vport)
1377                         compose_odp_port(vport, &port);
1378                 vport_unlock();
1379
1380                 if (!vport)
1381                         return -ENODEV;
1382         } else {
1383                 struct vport *vport;
1384                 struct datapath *dp;
1385
1386                 if (port.port >= DP_MAX_PORTS)
1387                         return -EINVAL;
1388
1389                 dp = get_dp_locked(dp_idx);
1390                 if (!dp)
1391                         return -ENODEV;
1392
1393                 vport = get_vport_protected(dp, port.port);
1394                 if (vport)
1395                         compose_odp_port(vport, &port);
1396                 mutex_unlock(&dp->mutex);
1397
1398                 if (!vport)
1399                         return -ENOENT;
1400         }
1401
1402         return copy_to_user(uport, &port, sizeof(struct odp_port));
1403 }
1404
1405 static int do_dump_port(struct datapath *dp, struct odp_vport_dump *dump)
1406 {
1407         u32 port_no;
1408
1409         for (port_no = dump->port_no; port_no < DP_MAX_PORTS; port_no++) {
1410                 struct vport *vport = get_vport_protected(dp, port_no);
1411                 if (vport) {
1412                         struct odp_port odp_port;
1413
1414                         compose_odp_port(vport, &odp_port);
1415                         return copy_to_user((struct odp_port __force __user*)dump->port, &odp_port, sizeof(struct odp_port));
1416                 }
1417         }
1418
1419         return put_user('\0', (char __force __user*)&dump->port->devname[0]);
1420 }
1421
1422 static int dump_port(struct datapath *dp, struct odp_vport_dump __user *udump)
1423 {
1424         struct odp_vport_dump dump;
1425
1426         if (copy_from_user(&dump, udump, sizeof(dump)))
1427                 return -EFAULT;
1428
1429         return do_dump_port(dp, &dump);
1430 }
1431
1432 static int get_listen_mask(const struct file *f)
1433 {
1434         return (long)f->private_data;
1435 }
1436
1437 static void set_listen_mask(struct file *f, int listen_mask)
1438 {
1439         f->private_data = (void*)(long)listen_mask;
1440 }
1441
1442 static long openvswitch_ioctl(struct file *f, unsigned int cmd,
1443                            unsigned long argp)
1444 {
1445         int dp_idx = iminor(f->f_dentry->d_inode);
1446         struct datapath *dp;
1447         int drop_frags, listeners, port_no;
1448         unsigned int sflow_probability;
1449         int err;
1450
1451         /* Handle commands with special locking requirements up front. */
1452         switch (cmd) {
1453         case ODP_DP_CREATE:
1454                 err = create_dp(dp_idx, (char __user *)argp);
1455                 goto exit;
1456
1457         case ODP_DP_DESTROY:
1458                 err = destroy_dp(dp_idx);
1459                 goto exit;
1460
1461         case ODP_VPORT_ATTACH:
1462                 err = attach_port(dp_idx, (struct odp_port __user *)argp);
1463                 goto exit;
1464
1465         case ODP_VPORT_DETACH:
1466                 err = get_user(port_no, (int __user *)argp);
1467                 if (!err)
1468                         err = detach_port(dp_idx, port_no);
1469                 goto exit;
1470
1471         case ODP_VPORT_QUERY:
1472                 err = query_port(dp_idx, (struct odp_port __user *)argp);
1473                 goto exit;
1474
1475         case ODP_VPORT_MOD:
1476                 err = vport_user_mod((struct odp_port __user *)argp);
1477                 goto exit;
1478
1479         case ODP_VPORT_STATS_GET:
1480                 err = vport_user_stats_get((struct odp_vport_stats_req __user *)argp);
1481                 goto exit;
1482
1483         case ODP_VPORT_STATS_SET:
1484                 err = vport_user_stats_set((struct odp_vport_stats_req __user *)argp);
1485                 goto exit;
1486
1487         case ODP_VPORT_ETHER_GET:
1488                 err = vport_user_ether_get((struct odp_vport_ether __user *)argp);
1489                 goto exit;
1490
1491         case ODP_VPORT_ETHER_SET:
1492                 err = vport_user_ether_set((struct odp_vport_ether __user *)argp);
1493                 goto exit;
1494
1495         case ODP_VPORT_MTU_GET:
1496                 err = vport_user_mtu_get((struct odp_vport_mtu __user *)argp);
1497                 goto exit;
1498
1499         case ODP_VPORT_MTU_SET:
1500                 err = vport_user_mtu_set((struct odp_vport_mtu __user *)argp);
1501                 goto exit;
1502         }
1503
1504         dp = get_dp_locked(dp_idx);
1505         err = -ENODEV;
1506         if (!dp)
1507                 goto exit;
1508
1509         switch (cmd) {
1510         case ODP_DP_STATS:
1511                 err = get_dp_stats(dp, (struct odp_stats __user *)argp);
1512                 break;
1513
1514         case ODP_GET_DROP_FRAGS:
1515                 err = put_user(dp->drop_frags, (int __user *)argp);
1516                 break;
1517
1518         case ODP_SET_DROP_FRAGS:
1519                 err = get_user(drop_frags, (int __user *)argp);
1520                 if (err)
1521                         break;
1522                 err = -EINVAL;
1523                 if (drop_frags != 0 && drop_frags != 1)
1524                         break;
1525                 dp->drop_frags = drop_frags;
1526                 err = 0;
1527                 break;
1528
1529         case ODP_GET_LISTEN_MASK:
1530                 err = put_user(get_listen_mask(f), (int __user *)argp);
1531                 break;
1532
1533         case ODP_SET_LISTEN_MASK:
1534                 err = get_user(listeners, (int __user *)argp);
1535                 if (err)
1536                         break;
1537                 err = -EINVAL;
1538                 if (listeners & ~ODPL_ALL)
1539                         break;
1540                 err = 0;
1541                 set_listen_mask(f, listeners);
1542                 break;
1543
1544         case ODP_GET_SFLOW_PROBABILITY:
1545                 err = put_user(dp->sflow_probability, (unsigned int __user *)argp);
1546                 break;
1547
1548         case ODP_SET_SFLOW_PROBABILITY:
1549                 err = get_user(sflow_probability, (unsigned int __user *)argp);
1550                 if (!err)
1551                         dp->sflow_probability = sflow_probability;
1552                 break;
1553
1554         case ODP_VPORT_DUMP:
1555                 err = dump_port(dp, (struct odp_vport_dump __user *)argp);
1556                 break;
1557
1558         case ODP_FLOW_FLUSH:
1559                 err = flush_flows(dp);
1560                 break;
1561
1562         case ODP_FLOW_PUT:
1563                 err = put_flow(dp, (struct odp_flow_put __user *)argp);
1564                 break;
1565
1566         case ODP_FLOW_DEL:
1567                 err = del_flow(dp, (struct odp_flow __user *)argp);
1568                 break;
1569
1570         case ODP_FLOW_GET:
1571                 err = do_flowvec_ioctl(dp, argp, do_query_flows);
1572                 break;
1573
1574         case ODP_FLOW_DUMP:
1575                 err = dump_flow(dp, (struct odp_flow_dump __user *)argp);
1576                 break;
1577
1578         case ODP_EXECUTE:
1579                 err = execute_packet(dp, (struct odp_execute __user *)argp);
1580                 break;
1581
1582         default:
1583                 err = -ENOIOCTLCMD;
1584                 break;
1585         }
1586         mutex_unlock(&dp->mutex);
1587 exit:
1588         return err;
1589 }
1590
1591 static int dp_has_packet_of_interest(struct datapath *dp, int listeners)
1592 {
1593         int i;
1594         for (i = 0; i < DP_N_QUEUES; i++) {
1595                 if (listeners & (1 << i) && !skb_queue_empty(&dp->queues[i]))
1596                         return 1;
1597         }
1598         return 0;
1599 }
1600
1601 #ifdef CONFIG_COMPAT
1602 static int compat_dump_port(struct datapath *dp, struct compat_odp_vport_dump __user *compat)
1603 {
1604         struct odp_vport_dump dump;
1605         compat_uptr_t port;
1606
1607         if (!access_ok(VERIFY_READ, compat, sizeof(struct compat_odp_vport_dump)) ||
1608             __get_user(port, &compat->port) ||
1609             __get_user(dump.port_no, &compat->port_no))
1610                 return -EFAULT;
1611
1612         dump.port = (struct odp_port __force *)compat_ptr(port);
1613         return do_dump_port(dp, &dump);
1614 }
1615
1616 static int compat_get_flow(struct odp_flow *flow, const struct compat_odp_flow __user *compat)
1617 {
1618         compat_uptr_t key, actions;
1619
1620         if (!access_ok(VERIFY_READ, compat, sizeof(struct compat_odp_flow)) ||
1621             __copy_from_user(&flow->stats, &compat->stats, sizeof(struct odp_flow_stats)) ||
1622             __get_user(key, &compat->key) ||
1623             __get_user(flow->key_len, &compat->key_len) ||
1624             __get_user(actions, &compat->actions) ||
1625             __get_user(flow->actions_len, &compat->actions_len) ||
1626             __get_user(flow->flags, &compat->flags))
1627                 return -EFAULT;
1628
1629         flow->key = (struct nlattr __force *)compat_ptr(key);
1630         flow->actions = (struct nlattr __force *)compat_ptr(actions);
1631         return 0;
1632 }
1633
1634 static int compat_put_flow(struct datapath *dp, struct compat_odp_flow_put __user *ufp)
1635 {
1636         struct odp_flow_stats stats;
1637         struct odp_flow_put fp;
1638         int error;
1639
1640         if (compat_get_flow(&fp.flow, &ufp->flow) ||
1641             get_user(fp.flags, &ufp->flags))
1642                 return -EFAULT;
1643
1644         error = do_put_flow(dp, &fp, &stats);
1645         if (error)
1646                 return error;
1647
1648         if (copy_to_user(&ufp->flow.stats, &stats,
1649                          sizeof(struct odp_flow_stats)))
1650                 return -EFAULT;
1651
1652         return 0;
1653 }
1654
1655 static int compat_answer_query(struct datapath *dp, struct sw_flow *flow,
1656                                u32 query_flags,
1657                                struct compat_odp_flow __user *ufp)
1658 {
1659         compat_uptr_t actions;
1660
1661         if (get_user(actions, &ufp->actions))
1662                 return -EFAULT;
1663
1664         return do_answer_query(dp, flow, query_flags, &ufp->stats,
1665                                compat_ptr(actions), &ufp->actions_len);
1666 }
1667
1668 static int compat_del_flow(struct datapath *dp, struct compat_odp_flow __user *ufp)
1669 {
1670         struct sw_flow *flow;
1671         struct odp_flow uf;
1672         int error;
1673
1674         if (compat_get_flow(&uf, ufp))
1675                 return -EFAULT;
1676
1677         flow = do_del_flow(dp, (const struct nlattr __force __user *)uf.key, uf.key_len);
1678         if (IS_ERR(flow))
1679                 return PTR_ERR(flow);
1680
1681         error = compat_answer_query(dp, flow, 0, ufp);
1682         flow_deferred_free(flow);
1683         return error;
1684 }
1685
1686 static int compat_query_flows(struct datapath *dp,
1687                               struct compat_odp_flow __user *flows,
1688                               u32 n_flows)
1689 {
1690         struct tbl *table = get_table_protected(dp);
1691         u32 i;
1692
1693         for (i = 0; i < n_flows; i++) {
1694                 struct compat_odp_flow __user *ufp = &flows[i];
1695                 struct odp_flow uf;
1696                 struct tbl_node *flow_node;
1697                 struct sw_flow_key key;
1698                 int error;
1699
1700                 if (compat_get_flow(&uf, ufp))
1701                         return -EFAULT;
1702
1703                 error = flow_copy_from_user(&key, (const struct nlattr __force __user *) uf.key, uf.key_len);
1704                 if (error)
1705                         return error;
1706
1707                 flow_node = tbl_lookup(table, &key, flow_hash(&key), flow_cmp);
1708                 if (!flow_node)
1709                         error = put_user(ENOENT, &ufp->stats.error);
1710                 else
1711                         error = compat_answer_query(dp, flow_cast(flow_node),
1712                                                     uf.flags, ufp);
1713                 if (error)
1714                         return -EFAULT;
1715         }
1716         return n_flows;
1717 }
1718
1719 static int compat_dump_flow(struct datapath *dp, struct compat_odp_flow_dump __user *udumpp)
1720 {
1721         struct compat_odp_flow __user *uflowp;
1722         compat_uptr_t compat_ufp;
1723         struct sw_flow *flow;
1724         compat_uptr_t ukey;
1725         u32 key_len;
1726
1727         flow = do_dump_flow(dp, udumpp->state);
1728         if (IS_ERR(flow))
1729                 return PTR_ERR(flow);
1730
1731         if (get_user(compat_ufp, &udumpp->flow))
1732                 return -EFAULT;
1733         uflowp = compat_ptr(compat_ufp);
1734
1735         if (!flow)
1736                 return put_user(ODPFF_EOF, &uflowp->flags);
1737
1738         if (put_user(0, &uflowp->flags) ||
1739             get_user(ukey, &uflowp->key) ||
1740             get_user(key_len, &uflowp->key_len))
1741                 return -EFAULT;
1742
1743         key_len = flow_copy_to_user(compat_ptr(ukey), &flow->key, key_len);
1744         if (key_len < 0)
1745                 return key_len;
1746         if (put_user(key_len, &uflowp->key_len))
1747                 return -EFAULT;
1748
1749         return compat_answer_query(dp, flow, 0, uflowp);
1750 }
1751
1752 static int compat_flowvec_ioctl(struct datapath *dp, unsigned long argp,
1753                                 int (*function)(struct datapath *,
1754                                                 struct compat_odp_flow __user *,
1755                                                 u32 n_flows))
1756 {
1757         struct compat_odp_flowvec __user *uflowvec;
1758         struct compat_odp_flow __user *flows;
1759         struct compat_odp_flowvec flowvec;
1760         int retval;
1761
1762         uflowvec = compat_ptr(argp);
1763         if (!access_ok(VERIFY_WRITE, uflowvec, sizeof(*uflowvec)) ||
1764             copy_from_user(&flowvec, uflowvec, sizeof(flowvec)))
1765                 return -EFAULT;
1766
1767         if (flowvec.n_flows > INT_MAX / sizeof(struct compat_odp_flow))
1768                 return -EINVAL;
1769
1770         flows = compat_ptr(flowvec.flows);
1771         if (!access_ok(VERIFY_WRITE, flows,
1772                        flowvec.n_flows * sizeof(struct compat_odp_flow)))
1773                 return -EFAULT;
1774
1775         retval = function(dp, flows, flowvec.n_flows);
1776         return (retval < 0 ? retval
1777                 : retval == flowvec.n_flows ? 0
1778                 : put_user(retval, &uflowvec->n_flows));
1779 }
1780
1781 static int compat_execute(struct datapath *dp, const struct compat_odp_execute __user *uexecute)
1782 {
1783         struct odp_execute execute;
1784         compat_uptr_t actions;
1785         compat_uptr_t data;
1786
1787         if (!access_ok(VERIFY_READ, uexecute, sizeof(struct compat_odp_execute)) ||
1788             __get_user(actions, &uexecute->actions) ||
1789             __get_user(execute.actions_len, &uexecute->actions_len) ||
1790             __get_user(data, &uexecute->data) ||
1791             __get_user(execute.length, &uexecute->length))
1792                 return -EFAULT;
1793
1794         execute.actions = (struct nlattr __force *)compat_ptr(actions);
1795         execute.data = (const void __force *)compat_ptr(data);
1796
1797         return do_execute(dp, &execute);
1798 }
1799
1800 static long openvswitch_compat_ioctl(struct file *f, unsigned int cmd, unsigned long argp)
1801 {
1802         int dp_idx = iminor(f->f_dentry->d_inode);
1803         struct datapath *dp;
1804         int err;
1805
1806         switch (cmd) {
1807         case ODP_DP_DESTROY:
1808         case ODP_FLOW_FLUSH:
1809                 /* Ioctls that don't need any translation at all. */
1810                 return openvswitch_ioctl(f, cmd, argp);
1811
1812         case ODP_DP_CREATE:
1813         case ODP_VPORT_ATTACH:
1814         case ODP_VPORT_DETACH:
1815         case ODP_VPORT_MOD:
1816         case ODP_VPORT_MTU_SET:
1817         case ODP_VPORT_MTU_GET:
1818         case ODP_VPORT_ETHER_SET:
1819         case ODP_VPORT_ETHER_GET:
1820         case ODP_VPORT_STATS_SET:
1821         case ODP_VPORT_STATS_GET:
1822         case ODP_DP_STATS:
1823         case ODP_GET_DROP_FRAGS:
1824         case ODP_SET_DROP_FRAGS:
1825         case ODP_SET_LISTEN_MASK:
1826         case ODP_GET_LISTEN_MASK:
1827         case ODP_SET_SFLOW_PROBABILITY:
1828         case ODP_GET_SFLOW_PROBABILITY:
1829         case ODP_VPORT_QUERY:
1830                 /* Ioctls that just need their pointer argument extended. */
1831                 return openvswitch_ioctl(f, cmd, (unsigned long)compat_ptr(argp));
1832         }
1833
1834         dp = get_dp_locked(dp_idx);
1835         err = -ENODEV;
1836         if (!dp)
1837                 goto exit;
1838
1839         switch (cmd) {
1840         case ODP_VPORT_DUMP32:
1841                 err = compat_dump_port(dp, compat_ptr(argp));
1842                 break;
1843
1844         case ODP_FLOW_PUT32:
1845                 err = compat_put_flow(dp, compat_ptr(argp));
1846                 break;
1847
1848         case ODP_FLOW_DEL32:
1849                 err = compat_del_flow(dp, compat_ptr(argp));
1850                 break;
1851
1852         case ODP_FLOW_GET32:
1853                 err = compat_flowvec_ioctl(dp, argp, compat_query_flows);
1854                 break;
1855
1856         case ODP_FLOW_DUMP32:
1857                 err = compat_dump_flow(dp, compat_ptr(argp));
1858                 break;
1859
1860         case ODP_EXECUTE32:
1861                 err = compat_execute(dp, compat_ptr(argp));
1862                 break;
1863
1864         default:
1865                 err = -ENOIOCTLCMD;
1866                 break;
1867         }
1868         mutex_unlock(&dp->mutex);
1869 exit:
1870         return err;
1871 }
1872 #endif
1873
1874 static ssize_t openvswitch_read(struct file *f, char __user *buf,
1875                                 size_t nbytes, loff_t *ppos)
1876 {
1877         int listeners = get_listen_mask(f);
1878         int dp_idx = iminor(f->f_dentry->d_inode);
1879         struct datapath *dp = get_dp_locked(dp_idx);
1880         struct sk_buff *skb;
1881         struct iovec iov;
1882         int retval;
1883
1884         if (!dp)
1885                 return -ENODEV;
1886
1887         if (nbytes == 0 || !listeners)
1888                 return 0;
1889
1890         for (;;) {
1891                 int i;
1892
1893                 for (i = 0; i < DP_N_QUEUES; i++) {
1894                         if (listeners & (1 << i)) {
1895                                 skb = skb_dequeue(&dp->queues[i]);
1896                                 if (skb)
1897                                         goto success;
1898                         }
1899                 }
1900
1901                 if (f->f_flags & O_NONBLOCK) {
1902                         retval = -EAGAIN;
1903                         goto error;
1904                 }
1905
1906                 wait_event_interruptible(dp->waitqueue,
1907                                          dp_has_packet_of_interest(dp,
1908                                                                    listeners));
1909
1910                 if (signal_pending(current)) {
1911                         retval = -ERESTARTSYS;
1912                         goto error;
1913                 }
1914         }
1915 success:
1916         mutex_unlock(&dp->mutex);
1917
1918         iov.iov_base = buf;
1919         iov.iov_len = min_t(size_t, skb->len, nbytes);
1920         retval = skb_copy_datagram_iovec(skb, 0, &iov, iov.iov_len);
1921         if (!retval)
1922                 retval = skb->len;
1923
1924         kfree_skb(skb);
1925         return retval;
1926
1927 error:
1928         mutex_unlock(&dp->mutex);
1929         return retval;
1930 }
1931
1932 static unsigned int openvswitch_poll(struct file *file, poll_table *wait)
1933 {
1934         int dp_idx = iminor(file->f_dentry->d_inode);
1935         struct datapath *dp = get_dp_locked(dp_idx);
1936         unsigned int mask;
1937
1938         if (dp) {
1939                 mask = 0;
1940                 poll_wait(file, &dp->waitqueue, wait);
1941                 if (dp_has_packet_of_interest(dp, get_listen_mask(file)))
1942                         mask |= POLLIN | POLLRDNORM;
1943                 mutex_unlock(&dp->mutex);
1944         } else {
1945                 mask = POLLIN | POLLRDNORM | POLLHUP;
1946         }
1947         return mask;
1948 }
1949
1950 static struct file_operations openvswitch_fops = {
1951         .owner = THIS_MODULE,
1952         .read  = openvswitch_read,
1953         .poll  = openvswitch_poll,
1954         .unlocked_ioctl = openvswitch_ioctl,
1955 #ifdef CONFIG_COMPAT
1956         .compat_ioctl = openvswitch_compat_ioctl,
1957 #endif
1958 };
1959
1960 static int major;
1961
1962 static int __init dp_init(void)
1963 {
1964         struct sk_buff *dummy_skb;
1965         int err;
1966
1967         BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > sizeof(dummy_skb->cb));
1968
1969         printk("Open vSwitch %s, built "__DATE__" "__TIME__"\n", VERSION BUILDNR);
1970
1971         err = flow_init();
1972         if (err)
1973                 goto error;
1974
1975         err = vport_init();
1976         if (err)
1977                 goto error_flow_exit;
1978
1979         err = register_netdevice_notifier(&dp_device_notifier);
1980         if (err)
1981                 goto error_vport_exit;
1982
1983         major = register_chrdev(0, "openvswitch", &openvswitch_fops);
1984         if (err < 0)
1985                 goto error_unreg_notifier;
1986
1987         return 0;
1988
1989 error_unreg_notifier:
1990         unregister_netdevice_notifier(&dp_device_notifier);
1991 error_vport_exit:
1992         vport_exit();
1993 error_flow_exit:
1994         flow_exit();
1995 error:
1996         return err;
1997 }
1998
1999 static void dp_cleanup(void)
2000 {
2001         rcu_barrier();
2002         unregister_chrdev(major, "openvswitch");
2003         unregister_netdevice_notifier(&dp_device_notifier);
2004         vport_exit();
2005         flow_exit();
2006 }
2007
2008 module_init(dp_init);
2009 module_exit(dp_cleanup);
2010
2011 MODULE_DESCRIPTION("Open vSwitch switching datapath");
2012 MODULE_LICENSE("GPL");