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