datapath/brcompat_main.c

   1 /*
   2  * Copyright (c) 2007-2012 Nicira, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of version 2 of the GNU General Public
   6  * License as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  16  * 02110-1301, USA
  17  */
  18
  19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20
  21 #include <linux/module.h>
  22 #include <linux/kernel.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/completion.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/if_bridge.h>
  27 #include <linux/netdevice.h>
  28 #include <linux/rtnetlink.h>
  29 #include <net/genetlink.h>
  30
  31 #include "openvswitch/brcompat-netlink.h"
  32 #include "datapath.h"
  33
  34 static struct genl_family brc_genl_family;
  35 static struct genl_multicast_group brc_mc_group;
  36
  37 /* Time to wait for ovs-vswitchd to respond to a datapath action, in
  38  * jiffies. */
  39 #define BRC_TIMEOUT (HZ * 5)
  40
  41 /* Mutex to serialize ovs-brcompatd callbacks.  (Some callbacks naturally hold
  42  * br_ioctl_mutex, others hold rtnl_lock, but we can't take the former
  43  * ourselves and we don't want to hold the latter over a potentially long
  44  * period of time.) */
  45 static DEFINE_MUTEX(brc_serial);
  46
  47 /* Userspace communication. */
  48 static DEFINE_SPINLOCK(brc_lock);    /* Ensure atomic access to these vars. */
  49 static DECLARE_COMPLETION(brc_done); /* Userspace signaled operation done? */
  50 static struct sk_buff *brc_reply;    /* Reply from userspace. */
  51 static u32 brc_seq;                  /* Sequence number for current op. */
  52
  53 static struct sk_buff *brc_send_command(struct net *,
  54                                         struct sk_buff *,
  55                                         struct nlattr **attrs);
  56 static int brc_send_simple_command(struct net *, struct sk_buff *);
  57
  58 static struct sk_buff *brc_make_request(int op, const char *bridge,
  59                                         const char *port)
  60 {
  61         struct sk_buff *skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  62         if (!skb)
  63                 goto error;
  64
  65         genlmsg_put(skb, 0, 0, &brc_genl_family, 0, op);
  66
  67         if (bridge && nla_put_string(skb, BRC_GENL_A_DP_NAME, bridge))
  68                 goto nla_put_failure;
  69         if (port && nla_put_string(skb, BRC_GENL_A_PORT_NAME, port))
  70                 goto nla_put_failure;
  71
  72         return skb;
  73
  74 nla_put_failure:
  75         kfree_skb(skb);
  76 error:
  77         return NULL;
  78 }
  79
  80 static int brc_send_simple_command(struct net *net, struct sk_buff *request)
  81 {
  82         struct nlattr *attrs[BRC_GENL_A_MAX + 1];
  83         struct sk_buff *reply;
  84         int error;
  85
  86         reply = brc_send_command(net, request, attrs);
  87         if (IS_ERR(reply))
  88                 return PTR_ERR(reply);
  89
  90         error = nla_get_u32(attrs[BRC_GENL_A_ERR_CODE]);
  91         kfree_skb(reply);
  92         return -error;
  93 }
  94
  95 static int brc_add_del_bridge(struct net *net, char __user *uname, int add)
  96 {
  97         struct sk_buff *request;
  98         char name[IFNAMSIZ];
  99
 100         if (!capable(CAP_NET_ADMIN))
 101                 return -EPERM;
 102
 103         if (copy_from_user(name, uname, IFNAMSIZ))
 104                 return -EFAULT;
 105
 106         name[IFNAMSIZ - 1] = 0;
 107         request = brc_make_request(add ? BRC_GENL_C_DP_ADD : BRC_GENL_C_DP_DEL,
 108                                    name, NULL);
 109         if (!request)
 110                 return -ENOMEM;
 111
 112         return brc_send_simple_command(net, request);
 113 }
 114
 115 static int brc_get_indices(struct net *net,
 116                            int op, const char *br_name,
 117                            int __user *uindices, int n)
 118 {
 119         struct nlattr *attrs[BRC_GENL_A_MAX + 1];
 120         struct sk_buff *request, *reply;
 121         int *indices;
 122         int ret;
 123         int len;
 124
 125         if (n < 0)
 126                 return -EINVAL;
 127         if (n >= 2048)
 128                 return -ENOMEM;
 129
 130         request = brc_make_request(op, br_name, NULL);
 131         if (!request)
 132                 return -ENOMEM;
 133
 134         reply = brc_send_command(net, request, attrs);
 135         ret = PTR_ERR(reply);
 136         if (IS_ERR(reply))
 137                 goto exit;
 138
 139         ret = -nla_get_u32(attrs[BRC_GENL_A_ERR_CODE]);
 140         if (ret < 0)
 141                 goto exit_free_skb;
 142
 143         ret = -EINVAL;
 144         if (!attrs[BRC_GENL_A_IFINDEXES])
 145                 goto exit_free_skb;
 146
 147         len = nla_len(attrs[BRC_GENL_A_IFINDEXES]);
 148         indices = nla_data(attrs[BRC_GENL_A_IFINDEXES]);
 149         if (len % sizeof(int))
 150                 goto exit_free_skb;
 151
 152         n = min_t(int, n, len / sizeof(int));
 153         ret = copy_to_user(uindices, indices, n * sizeof(int)) ? -EFAULT : n;
 154
 155 exit_free_skb:
 156         kfree_skb(reply);
 157 exit:
 158         return ret;
 159 }
 160
 161 /* Called with br_ioctl_mutex. */
 162 static int brc_get_bridges(struct net *net, int __user *uindices, int n)
 163 {
 164         return brc_get_indices(net, BRC_GENL_C_GET_BRIDGES, NULL, uindices, n);
 165 }
 166
 167 /* Legacy deviceless bridge ioctl's.  Called with br_ioctl_mutex. */
 168 static int old_deviceless(struct net *net, void __user *uarg)
 169 {
 170         unsigned long args[3];
 171
 172         if (copy_from_user(args, uarg, sizeof(args)))
 173                 return -EFAULT;
 174
 175         switch (args[0]) {
 176         case BRCTL_GET_BRIDGES:
 177                 return brc_get_bridges(net, (int __user *)args[1], args[2]);
 178
 179         case BRCTL_ADD_BRIDGE:
 180                 return brc_add_del_bridge(net, (void __user *)args[1], 1);
 181         case BRCTL_DEL_BRIDGE:
 182                 return brc_add_del_bridge(net, (void __user *)args[1], 0);
 183         }
 184
 185         return -EOPNOTSUPP;
 186 }
 187
 188 /* Called with the br_ioctl_mutex. */
 189 static int
 190 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
 191 brc_ioctl_deviceless_stub(unsigned int cmd, void __user *uarg)
 192 {
 193         struct net *net = NULL;
 194 #else
 195 brc_ioctl_deviceless_stub(struct net *net, unsigned int cmd, void __user *uarg)
 196 {
 197 #endif
 198         switch (cmd) {
 199         case SIOCGIFBR:
 200         case SIOCSIFBR:
 201                 return old_deviceless(net, uarg);
 202
 203         case SIOCBRADDBR:
 204                 return brc_add_del_bridge(net, uarg, 1);
 205         case SIOCBRDELBR:
 206                 return brc_add_del_bridge(net, uarg, 0);
 207         }
 208
 209         return -EOPNOTSUPP;
 210 }
 211
 212 static int brc_add_del_port(struct net_device *dev, int port_ifindex, int add)
 213 {
 214         struct sk_buff *request;
 215         struct net_device *port;
 216         int err;
 217
 218         if (!capable(CAP_NET_ADMIN))
 219                 return -EPERM;
 220
 221         port = __dev_get_by_index(dev_net(dev), port_ifindex);
 222         if (!port)
 223                 return -EINVAL;
 224
 225         /* Save name of dev and port because there's a race between the
 226          * rtnl_unlock() and the brc_send_simple_command(). */
 227         request = brc_make_request(add ? BRC_GENL_C_PORT_ADD : BRC_GENL_C_PORT_DEL,
 228                                    dev->name, port->name);
 229         if (!request)
 230                 return -ENOMEM;
 231
 232         rtnl_unlock();
 233         err = brc_send_simple_command(dev_net(dev), request);
 234         rtnl_lock();
 235
 236         return err;
 237 }
 238
 239 static int brc_get_bridge_info(struct net_device *dev,
 240                                struct __bridge_info __user *ub)
 241 {
 242         struct __bridge_info b;
 243
 244         memset(&b, 0, sizeof(struct __bridge_info));
 245
 246         /* First two bytes are the priority, which we should skip.  This comes
 247          * from struct bridge_id in br_private.h, which is unavailable to us.
 248          */
 249         memcpy((u8 *)&b.bridge_id + 2, dev->dev_addr, ETH_ALEN);
 250         b.stp_enabled = 0;
 251
 252         if (copy_to_user(ub, &b, sizeof(struct __bridge_info)))
 253                 return -EFAULT;
 254
 255         return 0;
 256 }
 257
 258 static int brc_get_port_list(struct net_device *dev, int __user *uindices,
 259                              int num)
 260 {
 261         int retval;
 262
 263         rtnl_unlock();
 264         retval = brc_get_indices(dev_net(dev), BRC_GENL_C_GET_PORTS, dev->name,
 265                                  uindices, num);
 266         rtnl_lock();
 267
 268         return retval;
 269 }
 270
 271 /*
 272  * Format up to a page worth of forwarding table entries
 273  * userbuf -- where to copy result
 274  * maxnum  -- maximum number of entries desired
 275  *            (limited to a page for sanity)
 276  * offset  -- number of records to skip
 277  */
 278 static int brc_get_fdb_entries(struct net_device *dev, void __user *userbuf,
 279                                unsigned long maxnum, unsigned long offset)
 280 {
 281         struct nlattr *attrs[BRC_GENL_A_MAX + 1];
 282         struct sk_buff *request, *reply;
 283         int retval;
 284         int len;
 285
 286         /* Clamp size to PAGE_SIZE, test maxnum to avoid overflow */
 287         if (maxnum > PAGE_SIZE/sizeof(struct __fdb_entry))
 288                 maxnum = PAGE_SIZE/sizeof(struct __fdb_entry);
 289
 290         request = brc_make_request(BRC_GENL_C_FDB_QUERY, dev->name, NULL);
 291         if (!request)
 292                 return -ENOMEM;
 293         if (nla_put_u64(request, BRC_GENL_A_FDB_COUNT, maxnum) ||
 294             nla_put_u64(request, BRC_GENL_A_FDB_SKIP, offset))
 295                 goto nla_put_failure;
 296
 297         rtnl_unlock();
 298         reply = brc_send_command(dev_net(dev), request, attrs);
 299         retval = PTR_ERR(reply);
 300         if (IS_ERR(reply))
 301                 goto exit;
 302
 303         retval = -nla_get_u32(attrs[BRC_GENL_A_ERR_CODE]);
 304         if (retval < 0)
 305                 goto exit_free_skb;
 306
 307         retval = -EINVAL;
 308         if (!attrs[BRC_GENL_A_FDB_DATA])
 309                 goto exit_free_skb;
 310         len = nla_len(attrs[BRC_GENL_A_FDB_DATA]);
 311         if (len % sizeof(struct __fdb_entry) ||
 312             len / sizeof(struct __fdb_entry) > maxnum)
 313                 goto exit_free_skb;
 314
 315         retval = len / sizeof(struct __fdb_entry);
 316         if (copy_to_user(userbuf, nla_data(attrs[BRC_GENL_A_FDB_DATA]), len))
 317                 retval = -EFAULT;
 318
 319 exit_free_skb:
 320         kfree_skb(reply);
 321 exit:
 322         rtnl_lock();
 323         return retval;
 324
 325 nla_put_failure:
 326         kfree_skb(request);
 327         return -ENOMEM;
 328 }
 329
 330 /* Legacy ioctl's through SIOCDEVPRIVATE.  Called with rtnl_lock. */
 331 static int old_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 332 {
 333         unsigned long args[4];
 334
 335         if (copy_from_user(args, rq->ifr_data, sizeof(args)))
 336                 return -EFAULT;
 337
 338         switch (args[0]) {
 339         case BRCTL_ADD_IF:
 340                 return brc_add_del_port(dev, args[1], 1);
 341         case BRCTL_DEL_IF:
 342                 return brc_add_del_port(dev, args[1], 0);
 343
 344         case BRCTL_GET_BRIDGE_INFO:
 345                 return brc_get_bridge_info(dev, (struct __bridge_info __user *)args[1]);
 346
 347         case BRCTL_GET_PORT_LIST:
 348                 return brc_get_port_list(dev, (int __user *)args[1], args[2]);
 349
 350         case BRCTL_GET_FDB_ENTRIES:
 351                 return brc_get_fdb_entries(dev, (void __user *)args[1],
 352                                            args[2], args[3]);
 353         }
 354
 355         return -EOPNOTSUPP;
 356 }
 357
 358 /* Called with the rtnl_lock. */
 359 static int brc_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 360 {
 361         int err;
 362
 363         switch (cmd) {
 364         case SIOCDEVPRIVATE:
 365                 err = old_dev_ioctl(dev, rq, cmd);
 366                 break;
 367
 368         case SIOCBRADDIF:
 369                 return brc_add_del_port(dev, rq->ifr_ifindex, 1);
 370         case SIOCBRDELIF:
 371                 return brc_add_del_port(dev, rq->ifr_ifindex, 0);
 372
 373         default:
 374                 err = -EOPNOTSUPP;
 375                 break;
 376         }
 377
 378         return err;
 379 }
 380
 381
 382 static struct genl_family brc_genl_family = {
 383         .id = GENL_ID_GENERATE,
 384         .hdrsize = 0,
 385         .name = BRC_GENL_FAMILY_NAME,
 386         .version = 1,
 387         .maxattr = BRC_GENL_A_MAX,
 388          SET_NETNSOK
 389 };
 390
 391 static int brc_genl_query(struct sk_buff *skb, struct genl_info *info)
 392 {
 393         int err = -EINVAL;
 394         struct sk_buff *ans_skb;
 395         void *data;
 396
 397         ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 398         if (!ans_skb)
 399                 return -ENOMEM;
 400
 401         data = genlmsg_put_reply(ans_skb, info, &brc_genl_family,
 402                                  0, BRC_GENL_C_QUERY_MC);
 403         if (data == NULL) {
 404                 err = -ENOMEM;
 405                 goto err;
 406         }
 407         if (nla_put_u32(ans_skb, BRC_GENL_A_MC_GROUP, brc_mc_group.id))
 408                 goto nla_put_failure;
 409
 410         genlmsg_end(ans_skb, data);
 411         return genlmsg_reply(ans_skb, info);
 412
 413 err:
 414 nla_put_failure:
 415         kfree_skb(ans_skb);
 416         return err;
 417 }
 418
 419 /* Attribute policy: what each attribute may contain.  */
 420 static struct nla_policy brc_genl_policy[BRC_GENL_A_MAX + 1] = {
 421         [BRC_GENL_A_ERR_CODE] = { .type = NLA_U32 },
 422         [BRC_GENL_A_FDB_DATA] = { .type = NLA_UNSPEC },
 423 };
 424
 425 static int brc_genl_dp_result(struct sk_buff *skb, struct genl_info *info)
 426 {
 427         unsigned long int flags;
 428         int err;
 429
 430         if (!info->attrs[BRC_GENL_A_ERR_CODE])
 431                 return -EINVAL;
 432
 433         skb = skb_clone(skb, GFP_KERNEL);
 434         if (!skb)
 435                 return -ENOMEM;
 436
 437         spin_lock_irqsave(&brc_lock, flags);
 438         if (brc_seq == info->snd_seq) {
 439                 brc_seq++;
 440
 441                 kfree_skb(brc_reply);
 442                 brc_reply = skb;
 443
 444                 complete(&brc_done);
 445                 err = 0;
 446         } else {
 447                 kfree_skb(skb);
 448                 err = -ESTALE;
 449         }
 450         spin_unlock_irqrestore(&brc_lock, flags);
 451
 452         return err;
 453 }
 454
 455 static struct genl_ops brc_genl_ops[] = {
 456         { .cmd = BRC_GENL_C_QUERY_MC,
 457           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privelege. */
 458           .policy = NULL,
 459           .doit = brc_genl_query,
 460         },
 461         { .cmd = BRC_GENL_C_DP_RESULT,
 462           .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privelege. */
 463           .policy = brc_genl_policy,
 464           .doit = brc_genl_dp_result,
 465         },
 466 };
 467
 468 static struct sk_buff *brc_send_command(struct net *net,
 469                                         struct sk_buff *request,
 470                                         struct nlattr **attrs)
 471 {
 472         unsigned long int flags;
 473         struct sk_buff *reply;
 474         int error;
 475
 476         mutex_lock(&brc_serial);
 477
 478         /* Increment sequence number first, so that we ignore any replies
 479          * to stale requests. */
 480         spin_lock_irqsave(&brc_lock, flags);
 481         nlmsg_hdr(request)->nlmsg_seq = ++brc_seq;
 482         INIT_COMPLETION(brc_done);
 483         spin_unlock_irqrestore(&brc_lock, flags);
 484
 485         nlmsg_end(request, nlmsg_hdr(request));
 486
 487         /* Send message. */
 488         error = genlmsg_multicast_netns(net, request, 0,
 489                                         brc_mc_group.id, GFP_KERNEL);
 490         if (error < 0)
 491                 goto error;
 492
 493         /* Wait for reply. */
 494         error = -ETIMEDOUT;
 495         if (!wait_for_completion_timeout(&brc_done, BRC_TIMEOUT)) {
 496                 pr_warn("timed out waiting for userspace\n");
 497                 goto error;
 498         }
 499
 500         /* Grab reply. */
 501         spin_lock_irqsave(&brc_lock, flags);
 502         reply = brc_reply;
 503         brc_reply = NULL;
 504         spin_unlock_irqrestore(&brc_lock, flags);
 505
 506         mutex_unlock(&brc_serial);
 507
 508         /* Re-parse message.  Can't fail, since it parsed correctly once
 509          * already. */
 510         error = nlmsg_parse(nlmsg_hdr(reply), GENL_HDRLEN,
 511                             attrs, BRC_GENL_A_MAX, brc_genl_policy);
 512         WARN_ON(error);
 513
 514         return reply;
 515
 516 error:
 517         mutex_unlock(&brc_serial);
 518         return ERR_PTR(error);
 519 }
 520
 521 static int __init brc_init(void)
 522 {
 523         int err;
 524
 525         pr_info("Open vSwitch Bridge Compatibility, built "__DATE__" "__TIME__"\n");
 526
 527         /* Set the bridge ioctl handler */
 528         brioctl_set(brc_ioctl_deviceless_stub);
 529
 530         /* Set the openvswitch device ioctl handler */
 531         ovs_dp_ioctl_hook = brc_dev_ioctl;
 532
 533         /* Randomize the initial sequence number.  This is not a security
 534          * feature; it only helps avoid crossed wires between userspace and
 535          * the kernel when the module is unloaded and reloaded. */
 536         brc_seq = net_random();
 537
 538         /* Register generic netlink family to communicate changes to
 539          * userspace. */
 540         err = genl_register_family_with_ops(&brc_genl_family,
 541                                             brc_genl_ops, ARRAY_SIZE(brc_genl_ops));
 542         if (err)
 543                 goto error;
 544
 545         strcpy(brc_mc_group.name, "brcompat");
 546         err = genl_register_mc_group(&brc_genl_family, &brc_mc_group);
 547         if (err < 0)
 548                 goto err_unregister;
 549
 550         return 0;
 551
 552 err_unregister:
 553         genl_unregister_family(&brc_genl_family);
 554 error:
 555         pr_emerg("failed to install!\n");
 556         return err;
 557 }
 558
 559 static void brc_cleanup(void)
 560 {
 561         /* Unregister ioctl hooks */
 562         ovs_dp_ioctl_hook = NULL;
 563         brioctl_set(NULL);
 564
 565         genl_unregister_family(&brc_genl_family);
 566 }
 567
 568 module_init(brc_init);
 569 module_exit(brc_cleanup);
 570
 571 MODULE_DESCRIPTION("Open vSwitch bridge compatibility");
 572 MODULE_AUTHOR("Nicira, Inc.");
 573 MODULE_LICENSE("GPL");
 574
 575 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
 576 /*
 577  * In kernels 2.6.36 and later, Open vSwitch can safely coexist with
 578  * the Linux bridge module, but it does not make sense to load both bridge and
 579  * brcompat, so this prevents it.
 580  */
 581 BRIDGE_MUTUAL_EXCLUSION;
 582 #endif