datapath/brcompat.c

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