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