ofproto: Fix effective memory leak for uninstallable flows.
[sliver-openvswitch.git] / datapath / vport.c
1 /*
2  * Copyright (c) 2010 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/dcache.h>
12 #include <linux/etherdevice.h>
13 #include <linux/if.h>
14 #include <linux/if_vlan.h>
15 #include <linux/kernel.h>
16 #include <linux/list.h>
17 #include <linux/mutex.h>
18 #include <linux/percpu.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/compat.h>
21 #include <linux/version.h>
22
23 #include "vport.h"
24 #include "vport-internal_dev.h"
25
26 /* List of statically compiled vport implementations.  Don't forget to also
27  * add yours to the list at the bottom of vport.h. */
28 static struct vport_ops *base_vport_ops_list[] = {
29         &netdev_vport_ops,
30         &internal_vport_ops,
31         &patch_vport_ops,
32         &gre_vport_ops,
33 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
34         &capwap_vport_ops,
35 #endif
36 };
37
38 static const struct vport_ops **vport_ops_list;
39 static int n_vport_types;
40
41 static struct hlist_head *dev_table;
42 #define VPORT_HASH_BUCKETS 1024
43
44 /* Both RTNL lock and vport_mutex need to be held when updating dev_table.
45  *
46  * If you use vport_locate and then perform some operations, you need to hold
47  * one of these locks if you don't want the vport to be deleted out from under
48  * you.
49  *
50  * If you get a reference to a vport through a dp_port, it is protected
51  * by RCU and you need to hold rcu_read_lock instead when reading.
52  *
53  * If multiple locks are taken, the hierarchy is:
54  * 1. RTNL
55  * 2. DP
56  * 3. vport
57  */
58 static DEFINE_MUTEX(vport_mutex);
59
60 /**
61  *      vport_lock - acquire vport lock
62  *
63  * Acquire global vport lock.  See above comment about locking requirements
64  * and specific function definitions.  May sleep.
65  */
66 void vport_lock(void)
67 {
68         mutex_lock(&vport_mutex);
69 }
70
71 /**
72  *      vport_unlock - release vport lock
73  *
74  * Release lock acquired with vport_lock.
75  */
76 void vport_unlock(void)
77 {
78         mutex_unlock(&vport_mutex);
79 }
80
81 #define ASSERT_VPORT()                                          \
82 do {                                                            \
83         if (unlikely(!mutex_is_locked(&vport_mutex))) {         \
84                 pr_err("vport lock not held at %s (%d)\n",      \
85                        __FILE__, __LINE__);                     \
86                 dump_stack();                                   \
87         }                                                       \
88 } while (0)
89
90 /**
91  *      vport_init - initialize vport subsystem
92  *
93  * Called at module load time to initialize the vport subsystem and any
94  * compiled in vport types.
95  */
96 int vport_init(void)
97 {
98         int err;
99         int i;
100
101         dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
102                             GFP_KERNEL);
103         if (!dev_table) {
104                 err = -ENOMEM;
105                 goto error;
106         }
107
108         vport_ops_list = kmalloc(ARRAY_SIZE(base_vport_ops_list) *
109                                  sizeof(struct vport_ops *), GFP_KERNEL);
110         if (!vport_ops_list) {
111                 err = -ENOMEM;
112                 goto error_dev_table;
113         }
114
115         for (i = 0; i < ARRAY_SIZE(base_vport_ops_list); i++) {
116                 struct vport_ops *new_ops = base_vport_ops_list[i];
117
118                 if (new_ops->init)
119                         err = new_ops->init();
120                 else
121                         err = 0;
122
123                 if (!err)
124                         vport_ops_list[n_vport_types++] = new_ops;
125                 else if (new_ops->flags & VPORT_F_REQUIRED) {
126                         vport_exit();
127                         goto error;
128                 }
129         }
130
131         return 0;
132
133 error_dev_table:
134         kfree(dev_table);
135 error:
136         return err;
137 }
138
139 static void vport_del_all(void)
140 {
141         int i;
142
143         rtnl_lock();
144         vport_lock();
145
146         for (i = 0; i < VPORT_HASH_BUCKETS; i++) {
147                 struct hlist_head *bucket = &dev_table[i];
148                 struct vport *vport;
149                 struct hlist_node *node, *next;
150
151                 hlist_for_each_entry_safe(vport, node, next, bucket, hash_node)
152                         vport_del(vport);
153         }
154
155         vport_unlock();
156         rtnl_unlock();
157 }
158
159 /**
160  *      vport_exit - shutdown vport subsystem
161  *
162  * Called at module exit time to shutdown the vport subsystem and any
163  * initialized vport types.
164  */
165 void vport_exit(void)
166 {
167         int i;
168
169         vport_del_all();
170
171         for (i = 0; i < n_vport_types; i++) {
172                 if (vport_ops_list[i]->exit)
173                         vport_ops_list[i]->exit();
174         }
175
176         kfree(vport_ops_list);
177         kfree(dev_table);
178 }
179
180 static int do_vport_add(struct odp_vport_add *vport_config)
181 {
182         struct vport *vport;
183         int err = 0;
184
185         vport_config->port_type[VPORT_TYPE_SIZE - 1] = '\0';
186         vport_config->devname[IFNAMSIZ - 1] = '\0';
187
188         rtnl_lock();
189
190         vport = vport_locate(vport_config->devname);
191         if (vport) {
192                 err = -EBUSY;
193                 goto out;
194         }
195
196         vport_lock();
197         vport = vport_add(vport_config->devname, vport_config->port_type,
198                           vport_config->config);
199         vport_unlock();
200
201         if (IS_ERR(vport))
202                 err = PTR_ERR(vport);
203
204 out:
205         rtnl_unlock();
206         return err;
207 }
208
209 /**
210  *      vport_user_add - add vport device (for userspace callers)
211  *
212  * @uvport_config: New port configuration.
213  *
214  * Creates a new vport with the specified configuration (which is dependent
215  * on device type).  This function is for userspace callers and assumes no
216  * locks are held.
217  */
218 int vport_user_add(const struct odp_vport_add __user *uvport_config)
219 {
220         struct odp_vport_add vport_config;
221
222         if (copy_from_user(&vport_config, uvport_config, sizeof(struct odp_vport_add)))
223                 return -EFAULT;
224
225         return do_vport_add(&vport_config);
226 }
227
228 #ifdef CONFIG_COMPAT
229 int compat_vport_user_add(struct compat_odp_vport_add *ucompat)
230 {
231         struct compat_odp_vport_add compat;
232         struct odp_vport_add vport_config;
233
234         if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_add)))
235                 return -EFAULT;
236
237         memcpy(vport_config.port_type, compat.port_type, VPORT_TYPE_SIZE);
238         memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
239         vport_config.config = compat_ptr(compat.config);
240
241         return do_vport_add(&vport_config);
242 }
243 #endif
244
245 static int do_vport_mod(struct odp_vport_mod *vport_config)
246 {
247         struct vport *vport;
248         int err;
249
250         vport_config->devname[IFNAMSIZ - 1] = '\0';
251
252         rtnl_lock();
253
254         vport = vport_locate(vport_config->devname);
255         if (!vport) {
256                 err = -ENODEV;
257                 goto out;
258         }
259
260         vport_lock();
261         err = vport_mod(vport, vport_config->config);
262         vport_unlock();
263
264 out:
265         rtnl_unlock();
266         return err;
267 }
268
269 /**
270  *      vport_user_mod - modify existing vport device (for userspace callers)
271  *
272  * @uvport_config: New configuration for vport
273  *
274  * Modifies an existing device with the specified configuration (which is
275  * dependent on device type).  This function is for userspace callers and
276  * assumes no locks are held.
277  */
278 int vport_user_mod(const struct odp_vport_mod __user *uvport_config)
279 {
280         struct odp_vport_mod vport_config;
281
282         if (copy_from_user(&vport_config, uvport_config, sizeof(struct odp_vport_mod)))
283                 return -EFAULT;
284
285         return do_vport_mod(&vport_config);
286 }
287
288 #ifdef CONFIG_COMPAT
289 int compat_vport_user_mod(struct compat_odp_vport_mod *ucompat)
290 {
291         struct compat_odp_vport_mod compat;
292         struct odp_vport_mod vport_config;
293
294         if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_mod)))
295                 return -EFAULT;
296
297         memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
298         vport_config.config = compat_ptr(compat.config);
299
300         return do_vport_mod(&vport_config);
301 }
302 #endif
303
304 /**
305  *      vport_user_del - delete existing vport device (for userspace callers)
306  *
307  * @udevname: Name of device to delete
308  *
309  * Deletes the specified device.  Detaches the device from a datapath first
310  * if it is attached.  Deleting the device will fail if it does not exist or it
311  * is the datapath local port.  It is also possible to fail for less obvious
312  * reasons, such as lack of memory.  This function is for userspace callers and
313  * assumes no locks are held.
314  */
315 int vport_user_del(const char __user *udevname)
316 {
317         char devname[IFNAMSIZ];
318         struct vport *vport;
319         struct dp_port *dp_port;
320         int err = 0;
321         int retval;
322
323         retval = strncpy_from_user(devname, udevname, IFNAMSIZ);
324         if (retval < 0)
325                 return -EFAULT;
326         else if (retval >= IFNAMSIZ)
327                 return -ENAMETOOLONG;
328
329         rtnl_lock();
330
331         vport = vport_locate(devname);
332         if (!vport) {
333                 err = -ENODEV;
334                 goto out;
335         }
336
337         dp_port = vport_get_dp_port(vport);
338         if (dp_port) {
339                 struct datapath *dp = dp_port->dp;
340
341                 mutex_lock(&dp->mutex);
342
343                 if (!strcmp(dp_name(dp), devname)) {
344                         err = -EINVAL;
345                         goto dp_port_out;
346                 }
347
348                 err = dp_detach_port(dp_port, 0);
349
350 dp_port_out:
351                 mutex_unlock(&dp->mutex);
352
353                 if (err)
354                         goto out;
355         }
356
357         vport_lock();
358         err = vport_del(vport);
359         vport_unlock();
360
361 out:
362         rtnl_unlock();
363         return err;
364 }
365
366 /**
367  *      vport_user_stats_get - retrieve device stats (for userspace callers)
368  *
369  * @ustats_req: Stats request parameters.
370  *
371  * Retrieves transmit, receive, and error stats for the given device.  This
372  * function is for userspace callers and assumes no locks are held.
373  */
374 int vport_user_stats_get(struct odp_vport_stats_req __user *ustats_req)
375 {
376         struct odp_vport_stats_req stats_req;
377         struct vport *vport;
378         int err;
379
380         if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
381                 return -EFAULT;
382
383         stats_req.devname[IFNAMSIZ - 1] = '\0';
384
385         vport_lock();
386
387         vport = vport_locate(stats_req.devname);
388         if (!vport) {
389                 err = -ENODEV;
390                 goto out;
391         }
392
393         err = vport_get_stats(vport, &stats_req.stats);
394
395 out:
396         vport_unlock();
397
398         if (!err)
399                 if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
400                         err = -EFAULT;
401
402         return err;
403 }
404
405 /**
406  *      vport_user_stats_set - sets offset device stats (for userspace callers)
407  *
408  * @ustats_req: Stats set parameters.
409  *
410  * Provides a set of transmit, receive, and error stats to be added as an
411  * offset to the collect data when stats are retreived.  Some devices may not
412  * support setting the stats, in which case the result will always be
413  * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
414  * are held.
415  */
416 int vport_user_stats_set(struct odp_vport_stats_req __user *ustats_req)
417 {
418         struct odp_vport_stats_req stats_req;
419         struct vport *vport;
420         int err;
421
422         if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
423                 return -EFAULT;
424
425         stats_req.devname[IFNAMSIZ - 1] = '\0';
426
427         rtnl_lock();
428         vport_lock();
429
430         vport = vport_locate(stats_req.devname);
431         if (!vport) {
432                 err = -ENODEV;
433                 goto out;
434         }
435
436         err = vport_set_stats(vport, &stats_req.stats);
437
438 out:
439         vport_unlock();
440         rtnl_unlock();
441         return err;
442 }
443
444
445 /**
446  *      vport_user_ether_get - retrieve device Ethernet address (for userspace callers)
447  *
448  * @uvport_ether: Ethernet address request parameters.
449  *
450  * Retrieves the Ethernet address of the given device.  This function is for
451  * userspace callers and assumes no locks are held.
452  */
453 int vport_user_ether_get(struct odp_vport_ether __user *uvport_ether)
454 {
455         struct odp_vport_ether vport_ether;
456         struct vport *vport;
457         int err = 0;
458
459         if (copy_from_user(&vport_ether, uvport_ether, sizeof(struct odp_vport_ether)))
460                 return -EFAULT;
461
462         vport_ether.devname[IFNAMSIZ - 1] = '\0';
463
464         vport_lock();
465
466         vport = vport_locate(vport_ether.devname);
467         if (!vport) {
468                 err = -ENODEV;
469                 goto out;
470         }
471
472         rcu_read_lock();
473         memcpy(vport_ether.ether_addr, vport_get_addr(vport), ETH_ALEN);
474         rcu_read_unlock();
475
476 out:
477         vport_unlock();
478
479         if (!err)
480                 if (copy_to_user(uvport_ether, &vport_ether, sizeof(struct odp_vport_ether)))
481                         err = -EFAULT;
482
483         return err;
484 }
485
486 /**
487  *      vport_user_ether_set - set device Ethernet address (for userspace callers)
488  *
489  * @uvport_ether: Ethernet address request parameters.
490  *
491  * Sets the Ethernet address of the given device.  Some devices may not support
492  * setting the Ethernet address, in which case the result will always be
493  * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
494  * are held.
495  */
496 int vport_user_ether_set(struct odp_vport_ether __user *uvport_ether)
497 {
498         struct odp_vport_ether vport_ether;
499         struct vport *vport;
500         int err;
501
502         if (copy_from_user(&vport_ether, uvport_ether, sizeof(struct odp_vport_ether)))
503                 return -EFAULT;
504
505         vport_ether.devname[IFNAMSIZ - 1] = '\0';
506
507         rtnl_lock();
508         vport_lock();
509
510         vport = vport_locate(vport_ether.devname);
511         if (!vport) {
512                 err = -ENODEV;
513                 goto out;
514         }
515
516         err = vport_set_addr(vport, vport_ether.ether_addr);
517
518 out:
519         vport_unlock();
520         rtnl_unlock();
521         return err;
522 }
523
524 /**
525  *      vport_user_mtu_get - retrieve device MTU (for userspace callers)
526  *
527  * @uvport_mtu: MTU request parameters.
528  *
529  * Retrieves the MTU of the given device.  This function is for userspace
530  * callers and assumes no locks are held.
531  */
532 int vport_user_mtu_get(struct odp_vport_mtu __user *uvport_mtu)
533 {
534         struct odp_vport_mtu vport_mtu;
535         struct vport *vport;
536         int err = 0;
537
538         if (copy_from_user(&vport_mtu, uvport_mtu, sizeof(struct odp_vport_mtu)))
539                 return -EFAULT;
540
541         vport_mtu.devname[IFNAMSIZ - 1] = '\0';
542
543         vport_lock();
544
545         vport = vport_locate(vport_mtu.devname);
546         if (!vport) {
547                 err = -ENODEV;
548                 goto out;
549         }
550
551         vport_mtu.mtu = vport_get_mtu(vport);
552
553 out:
554         vport_unlock();
555
556         if (!err)
557                 if (copy_to_user(uvport_mtu, &vport_mtu, sizeof(struct odp_vport_mtu)))
558                         err = -EFAULT;
559
560         return err;
561 }
562
563 /**
564  *      vport_user_mtu_set - set device MTU (for userspace callers)
565  *
566  * @uvport_mtu: MTU request parameters.
567  *
568  * Sets the MTU of the given device.  Some devices may not support setting the
569  * MTU, in which case the result will always be -EOPNOTSUPP.  This function is
570  * for userspace callers and assumes no locks are held.
571  */
572 int vport_user_mtu_set(struct odp_vport_mtu __user *uvport_mtu)
573 {
574         struct odp_vport_mtu vport_mtu;
575         struct vport *vport;
576         int err;
577
578         if (copy_from_user(&vport_mtu, uvport_mtu, sizeof(struct odp_vport_mtu)))
579                 return -EFAULT;
580
581         vport_mtu.devname[IFNAMSIZ - 1] = '\0';
582
583         rtnl_lock();
584         vport_lock();
585
586         vport = vport_locate(vport_mtu.devname);
587         if (!vport) {
588                 err = -ENODEV;
589                 goto out;
590         }
591
592         err = vport_set_mtu(vport, vport_mtu.mtu);
593
594 out:
595         vport_unlock();
596         rtnl_unlock();
597         return err;
598 }
599
600 static struct hlist_head *hash_bucket(const char *name)
601 {
602         unsigned int hash = full_name_hash(name, strlen(name));
603         return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
604 }
605
606 /**
607  *      vport_locate - find a port that has already been created
608  *
609  * @name: name of port to find
610  *
611  * Either RTNL or vport lock must be acquired before calling this function
612  * and held while using the found port.  See the locking comments at the
613  * top of the file.
614  */
615 struct vport *vport_locate(const char *name)
616 {
617         struct hlist_head *bucket = hash_bucket(name);
618         struct vport *vport;
619         struct hlist_node *node;
620
621         if (unlikely(!mutex_is_locked(&vport_mutex) && !rtnl_is_locked())) {
622                 pr_err("neither RTNL nor vport lock held in vport_locate\n");
623                 dump_stack();
624         }
625
626         rcu_read_lock();
627
628         hlist_for_each_entry(vport, node, bucket, hash_node)
629                 if (!strcmp(name, vport_get_name(vport)))
630                         goto out;
631
632         vport = NULL;
633
634 out:
635         rcu_read_unlock();
636         return vport;
637 }
638
639 static void register_vport(struct vport *vport)
640 {
641         hlist_add_head(&vport->hash_node, hash_bucket(vport_get_name(vport)));
642 }
643
644 static void unregister_vport(struct vport *vport)
645 {
646         hlist_del(&vport->hash_node);
647 }
648
649 /**
650  *      vport_alloc - allocate and initialize new vport
651  *
652  * @priv_size: Size of private data area to allocate.
653  * @ops: vport device ops
654  *
655  * Allocate and initialize a new vport defined by @ops.  The vport will contain
656  * a private data area of size @priv_size that can be accessed using
657  * vport_priv().  vports that are no longer needed should be released with
658  * vport_free().
659  */
660 struct vport *vport_alloc(int priv_size, const struct vport_ops *ops)
661 {
662         struct vport *vport;
663         size_t alloc_size;
664
665         alloc_size = sizeof(struct vport);
666         if (priv_size) {
667                 alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
668                 alloc_size += priv_size;
669         }
670
671         vport = kzalloc(alloc_size, GFP_KERNEL);
672         if (!vport)
673                 return ERR_PTR(-ENOMEM);
674
675         vport->ops = ops;
676
677         if (vport->ops->flags & VPORT_F_GEN_STATS) {
678                 vport->percpu_stats = alloc_percpu(struct vport_percpu_stats);
679                 if (!vport->percpu_stats)
680                         return ERR_PTR(-ENOMEM);
681
682                 spin_lock_init(&vport->stats_lock);
683         }
684
685         return vport;
686 }
687
688 /**
689  *      vport_free - uninitialize and free vport
690  *
691  * @vport: vport to free
692  *
693  * Frees a vport allocated with vport_alloc() when it is no longer needed.
694  */
695 void vport_free(struct vport *vport)
696 {
697         if (vport->ops->flags & VPORT_F_GEN_STATS)
698                 free_percpu(vport->percpu_stats);
699
700         kfree(vport);
701 }
702
703 /**
704  *      vport_add - add vport device (for kernel callers)
705  *
706  * @name: Name of new device.
707  * @type: Type of new device (to be matched against types in registered vport
708  * ops).
709  * @config: Device type specific configuration.  Userspace pointer.
710  *
711  * Creates a new vport with the specified configuration (which is dependent
712  * on device type).  Both RTNL and vport locks must be held.
713  */
714 struct vport *vport_add(const char *name, const char *type, const void __user *config)
715 {
716         struct vport *vport;
717         int err = 0;
718         int i;
719
720         ASSERT_RTNL();
721         ASSERT_VPORT();
722
723         for (i = 0; i < n_vport_types; i++) {
724                 if (!strcmp(vport_ops_list[i]->type, type)) {
725                         vport = vport_ops_list[i]->create(name, config);
726                         if (IS_ERR(vport)) {
727                                 err = PTR_ERR(vport);
728                                 goto out;
729                         }
730
731                         register_vport(vport);
732                         return vport;
733                 }
734         }
735
736         err = -EAFNOSUPPORT;
737
738 out:
739         return ERR_PTR(err);
740 }
741
742 /**
743  *      vport_mod - modify existing vport device (for kernel callers)
744  *
745  * @vport: vport to modify.
746  * @config: Device type specific configuration.  Userspace pointer.
747  *
748  * Modifies an existing device with the specified configuration (which is
749  * dependent on device type).  Both RTNL and vport locks must be held.
750  */
751 int vport_mod(struct vport *vport, const void __user *config)
752 {
753         ASSERT_RTNL();
754         ASSERT_VPORT();
755
756         if (vport->ops->modify)
757                 return vport->ops->modify(vport, config);
758         else
759                 return -EOPNOTSUPP;
760 }
761
762 /**
763  *      vport_del - delete existing vport device (for kernel callers)
764  *
765  * @vport: vport to delete.
766  *
767  * Deletes the specified device.  The device must not be currently attached to
768  * a datapath.  It is possible to fail for reasons such as lack of memory.
769  * Both RTNL and vport locks must be held.
770  */
771 int vport_del(struct vport *vport)
772 {
773         ASSERT_RTNL();
774         ASSERT_VPORT();
775         BUG_ON(vport_get_dp_port(vport));
776
777         unregister_vport(vport);
778
779         return vport->ops->destroy(vport);
780 }
781
782 /**
783  *      vport_attach - attach a vport to a datapath
784  *
785  * @vport: vport to attach.
786  * @dp_port: Datapath port to attach the vport to.
787  *
788  * Attaches a vport to a specific datapath so that packets may be exchanged.
789  * Both ports must be currently unattached.  @dp_port must be successfully
790  * attached to a vport before it is connected to a datapath and must not be
791  * modified while connected.  RTNL lock and the appropriate DP mutex must be held.
792  */
793 int vport_attach(struct vport *vport, struct dp_port *dp_port)
794 {
795         ASSERT_RTNL();
796
797         if (vport_get_dp_port(vport))
798                 return -EBUSY;
799
800         if (vport->ops->attach) {
801                 int err;
802
803                 err = vport->ops->attach(vport);
804                 if (err)
805                         return err;
806         }
807
808         rcu_assign_pointer(vport->dp_port, dp_port);
809
810         return 0;
811 }
812
813 /**
814  *      vport_detach - detach a vport from a datapath
815  *
816  * @vport: vport to detach.
817  *
818  * Detaches a vport from a datapath.  May fail for a variety of reasons,
819  * including lack of memory.  RTNL lock and the appropriate DP mutex must be held.
820  */
821 int vport_detach(struct vport *vport)
822 {
823         struct dp_port *dp_port;
824
825         ASSERT_RTNL();
826
827         dp_port = vport_get_dp_port(vport);
828         if (!dp_port)
829                 return -EINVAL;
830
831         rcu_assign_pointer(vport->dp_port, NULL);
832
833         if (vport->ops->detach)
834                 return vport->ops->detach(vport);
835         else
836                 return 0;
837 }
838
839 /**
840  *      vport_set_mtu - set device MTU (for kernel callers)
841  *
842  * @vport: vport on which to set MTU.
843  * @mtu: New MTU.
844  *
845  * Sets the MTU of the given device.  Some devices may not support setting the
846  * MTU, in which case the result will always be -EOPNOTSUPP.  RTNL lock must
847  * be held.
848  */
849 int vport_set_mtu(struct vport *vport, int mtu)
850 {
851         ASSERT_RTNL();
852
853         if (mtu < 68)
854                 return -EINVAL;
855
856         if (vport->ops->set_mtu) {
857                 int ret;
858
859                 ret = vport->ops->set_mtu(vport, mtu);
860
861                 if (!ret && !is_internal_vport(vport)) {
862                         struct dp_port *dp_port = vport_get_dp_port(vport);
863
864                         if (dp_port)
865                                 set_internal_devs_mtu(dp_port->dp);
866                 }
867
868                 return ret;
869         } else
870                 return -EOPNOTSUPP;
871 }
872
873 /**
874  *      vport_set_addr - set device Ethernet address (for kernel callers)
875  *
876  * @vport: vport on which to set Ethernet address.
877  * @addr: New address.
878  *
879  * Sets the Ethernet address of the given device.  Some devices may not support
880  * setting the Ethernet address, in which case the result will always be
881  * -EOPNOTSUPP.  RTNL lock must be held.
882  */
883 int vport_set_addr(struct vport *vport, const unsigned char *addr)
884 {
885         ASSERT_RTNL();
886
887         if (!is_valid_ether_addr(addr))
888                 return -EADDRNOTAVAIL;
889
890         if (vport->ops->set_addr)
891                 return vport->ops->set_addr(vport, addr);
892         else
893                 return -EOPNOTSUPP;
894 }
895
896 /**
897  *      vport_set_stats - sets offset device stats (for kernel callers)
898  *
899  * @vport: vport on which to set stats
900  * @stats: stats to set
901  *
902  * Provides a set of transmit, receive, and error stats to be added as an
903  * offset to the collect data when stats are retreived.  Some devices may not
904  * support setting the stats, in which case the result will always be
905  * -EOPNOTSUPP.  RTNL lock must be held.
906  */
907 int vport_set_stats(struct vport *vport, struct odp_vport_stats *stats)
908 {
909         ASSERT_RTNL();
910
911         if (vport->ops->flags & VPORT_F_GEN_STATS) {
912                 spin_lock_bh(&vport->stats_lock);
913                 memcpy(&vport->offset_stats, stats, sizeof(struct odp_vport_stats));
914                 spin_unlock_bh(&vport->stats_lock);
915
916                 return 0;
917         } else if (vport->ops->set_stats)
918                 return vport->ops->set_stats(vport, stats);
919         else
920                 return -EOPNOTSUPP;
921 }
922
923 /**
924  *      vport_get_name - retrieve device name
925  *
926  * @vport: vport from which to retrieve the name.
927  *
928  * Retrieves the name of the given device.  Either RTNL lock or rcu_read_lock
929  * must be held for the entire duration that the name is in use.
930  */
931 const char *vport_get_name(const struct vport *vport)
932 {
933         return vport->ops->get_name(vport);
934 }
935
936 /**
937  *      vport_get_type - retrieve device type
938  *
939  * @vport: vport from which to retrieve the type.
940  *
941  * Retrieves the type of the given device.  Either RTNL lock or rcu_read_lock
942  * must be held for the entire duration that the type is in use.
943  */
944 const char *vport_get_type(const struct vport *vport)
945 {
946         return vport->ops->type;
947 }
948
949 /**
950  *      vport_get_addr - retrieve device Ethernet address (for kernel callers)
951  *
952  * @vport: vport from which to retrieve the Ethernet address.
953  *
954  * Retrieves the Ethernet address of the given device.  Either RTNL lock or
955  * rcu_read_lock must be held for the entire duration that the Ethernet address
956  * is in use.
957  */
958 const unsigned char *vport_get_addr(const struct vport *vport)
959 {
960         return vport->ops->get_addr(vport);
961 }
962
963 /**
964  *      vport_get_dp_port - retrieve attached datapath port
965  *
966  * @vport: vport from which to retrieve the datapath port.
967  *
968  * Retrieves the attached datapath port or null if not attached.  Either RTNL
969  * lock or rcu_read_lock must be held for the entire duration that the datapath
970  * port is being accessed.
971  */
972 struct dp_port *vport_get_dp_port(const struct vport *vport)
973 {
974         return rcu_dereference(vport->dp_port);
975 }
976
977 /**
978  *      vport_get_kobj - retrieve associated kobj
979  *
980  * @vport: vport from which to retrieve the associated kobj
981  *
982  * Retrieves the associated kobj or null if no kobj.  The returned kobj is
983  * valid for as long as the vport exists.
984  */
985 struct kobject *vport_get_kobj(const struct vport *vport)
986 {
987         if (vport->ops->get_kobj)
988                 return vport->ops->get_kobj(vport);
989         else
990                 return NULL;
991 }
992
993 /**
994  *      vport_get_stats - retrieve device stats (for kernel callers)
995  *
996  * @vport: vport from which to retrieve the stats
997  * @stats: location to store stats
998  *
999  * Retrieves transmit, receive, and error stats for the given device.
1000  */
1001 int vport_get_stats(struct vport *vport, struct odp_vport_stats *stats)
1002 {
1003         struct odp_vport_stats dev_stats;
1004         struct odp_vport_stats *dev_statsp = NULL;
1005         int err;
1006
1007         if (vport->ops->get_stats) {
1008                 if (vport->ops->flags & VPORT_F_GEN_STATS)
1009                         dev_statsp = &dev_stats;
1010                 else
1011                         dev_statsp = stats;
1012
1013                 rcu_read_lock();
1014                 err = vport->ops->get_stats(vport, dev_statsp);
1015                 rcu_read_unlock();
1016
1017                 if (err)
1018                         goto out;
1019         }
1020
1021         if (vport->ops->flags & VPORT_F_GEN_STATS) {
1022                 int i;
1023
1024                 /* We potentially have 3 sources of stats that need to be
1025                  * combined: those we have collected (split into err_stats and
1026                  * percpu_stats), offset_stats from set_stats(), and device
1027                  * error stats from get_stats() (for errors that happen
1028                  * downstream and therefore aren't reported through our
1029                  * vport_record_error() function). */
1030
1031                 spin_lock_bh(&vport->stats_lock);
1032
1033                 memcpy(stats, &vport->offset_stats, sizeof(struct odp_vport_stats));
1034
1035                 stats->rx_errors        += vport->err_stats.rx_errors
1036                                                 + vport->err_stats.rx_frame_err
1037                                                 + vport->err_stats.rx_over_err
1038                                                 + vport->err_stats.rx_crc_err;
1039                 stats->tx_errors        += vport->err_stats.tx_errors;
1040                 stats->tx_dropped       += vport->err_stats.tx_dropped;
1041                 stats->rx_dropped       += vport->err_stats.rx_dropped;
1042                 stats->rx_over_err      += vport->err_stats.rx_over_err;
1043                 stats->rx_crc_err       += vport->err_stats.rx_crc_err;
1044                 stats->rx_frame_err     += vport->err_stats.rx_frame_err;
1045                 stats->collisions       += vport->err_stats.collisions;
1046
1047                 spin_unlock_bh(&vport->stats_lock);
1048
1049                 if (dev_statsp) {
1050                         stats->rx_errors        += dev_statsp->rx_errors;
1051                         stats->tx_errors        += dev_statsp->tx_errors;
1052                         stats->rx_dropped       += dev_statsp->rx_dropped;
1053                         stats->tx_dropped       += dev_statsp->tx_dropped;
1054                         stats->rx_over_err      += dev_statsp->rx_over_err;
1055                         stats->rx_crc_err       += dev_statsp->rx_crc_err;
1056                         stats->rx_frame_err     += dev_statsp->rx_frame_err;
1057                         stats->collisions       += dev_statsp->collisions;
1058                 }
1059
1060                 for_each_possible_cpu(i) {
1061                         const struct vport_percpu_stats *percpu_stats;
1062                         struct vport_percpu_stats local_stats;
1063                         unsigned seqcount;
1064
1065                         percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
1066
1067                         do {
1068                                 seqcount = read_seqcount_begin(&percpu_stats->seqlock);
1069                                 local_stats = *percpu_stats;
1070                         } while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
1071
1072                         stats->rx_bytes         += local_stats.rx_bytes;
1073                         stats->rx_packets       += local_stats.rx_packets;
1074                         stats->tx_bytes         += local_stats.tx_bytes;
1075                         stats->tx_packets       += local_stats.tx_packets;
1076                 }
1077
1078                 err = 0;
1079         } else
1080                 err = -EOPNOTSUPP;
1081
1082 out:
1083         return err;
1084 }
1085
1086 /**
1087  *      vport_get_flags - retrieve device flags
1088  *
1089  * @vport: vport from which to retrieve the flags
1090  *
1091  * Retrieves the flags of the given device.  Either RTNL lock or rcu_read_lock
1092  * must be held.
1093  */
1094 unsigned vport_get_flags(const struct vport *vport)
1095 {
1096         return vport->ops->get_dev_flags(vport);
1097 }
1098
1099 /**
1100  *      vport_get_flags - check whether device is running
1101  *
1102  * @vport: vport on which to check status.
1103  *
1104  * Checks whether the given device is running.  Either RTNL lock or
1105  * rcu_read_lock must be held.
1106  */
1107 int vport_is_running(const struct vport *vport)
1108 {
1109         return vport->ops->is_running(vport);
1110 }
1111
1112 /**
1113  *      vport_get_flags - retrieve device operating state
1114  *
1115  * @vport: vport from which to check status
1116  *
1117  * Retrieves the RFC2863 operstate of the given device.  Either RTNL lock or
1118  * rcu_read_lock must be held.
1119  */
1120 unsigned char vport_get_operstate(const struct vport *vport)
1121 {
1122         return vport->ops->get_operstate(vport);
1123 }
1124
1125 /**
1126  *      vport_get_ifindex - retrieve device system interface index
1127  *
1128  * @vport: vport from which to retrieve index
1129  *
1130  * Retrieves the system interface index of the given device.  Not all devices
1131  * will have system indexes, in which case the index of the datapath local
1132  * port is returned.  Returns a negative index on error.  Either RTNL lock or
1133  * rcu_read_lock must be held.
1134  */
1135 int vport_get_ifindex(const struct vport *vport)
1136 {
1137         const struct dp_port *dp_port;
1138
1139         if (vport->ops->get_ifindex)
1140                 return vport->ops->get_ifindex(vport);
1141
1142         /* If we don't actually have an ifindex, use the local port's.
1143          * Userspace doesn't check it anyways. */
1144         dp_port = vport_get_dp_port(vport);
1145         if (!dp_port)
1146                 return -EAGAIN;
1147
1148         return vport_get_ifindex(dp_port->dp->ports[ODPP_LOCAL]->vport);
1149 }
1150
1151 /**
1152  *      vport_get_iflink - retrieve device system link index
1153  *
1154  * @vport: vport from which to retrieve index
1155  *
1156  * Retrieves the system link index of the given device.  The link is the index
1157  * of the interface on which the packet will actually be sent.  In most cases
1158  * this is the same as the ifindex but may be different for tunnel devices.
1159  * Returns a negative index on error.  Either RTNL lock or rcu_read_lock must
1160  * be held.
1161  */
1162 int vport_get_iflink(const struct vport *vport)
1163 {
1164         if (vport->ops->get_iflink)
1165                 return vport->ops->get_iflink(vport);
1166
1167         /* If we don't have an iflink, use the ifindex.  In most cases they
1168          * are the same. */
1169         return vport_get_ifindex(vport);
1170 }
1171
1172 /**
1173  *      vport_get_mtu - retrieve device MTU (for kernel callers)
1174  *
1175  * @vport: vport from which to retrieve MTU
1176  *
1177  * Retrieves the MTU of the given device.  Either RTNL lock or rcu_read_lock
1178  * must be held.
1179  */
1180 int vport_get_mtu(const struct vport *vport)
1181 {
1182         return vport->ops->get_mtu(vport);
1183 }
1184
1185 /**
1186  *      vport_receive - pass up received packet to the datapath for processing
1187  *
1188  * @vport: vport that received the packet
1189  * @skb: skb that was received
1190  *
1191  * Must be called with rcu_read_lock.  The packet cannot be shared and
1192  * skb->data should point to the Ethernet header.  The caller must have already
1193  * called compute_ip_summed() to initialize the checksumming fields.
1194  */
1195 void vport_receive(struct vport *vport, struct sk_buff *skb)
1196 {
1197         struct dp_port *dp_port = vport_get_dp_port(vport);
1198
1199         if (!dp_port) {
1200                 vport_record_error(vport, VPORT_E_RX_DROPPED);
1201                 kfree_skb(skb);
1202
1203                 return;
1204         }
1205
1206         if (vport->ops->flags & VPORT_F_GEN_STATS) {
1207                 struct vport_percpu_stats *stats;
1208
1209                 local_bh_disable();
1210                 stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
1211
1212                 write_seqcount_begin(&stats->seqlock);
1213                 stats->rx_packets++;
1214                 stats->rx_bytes += skb->len;
1215                 write_seqcount_end(&stats->seqlock);
1216
1217                 local_bh_enable();
1218         }
1219
1220         if (!(vport->ops->flags & VPORT_F_TUN_ID))
1221                 OVS_CB(skb)->tun_id = 0;
1222
1223         dp_process_received_packet(dp_port, skb);
1224 }
1225
1226 static inline unsigned packet_length(const struct sk_buff *skb)
1227 {
1228         unsigned length = skb->len - ETH_HLEN;
1229
1230         if (skb->protocol == htons(ETH_P_8021Q))
1231                 length -= VLAN_HLEN;
1232
1233         return length;
1234 }
1235
1236 /**
1237  *      vport_send - send a packet on a device
1238  *
1239  * @vport: vport on which to send the packet
1240  * @skb: skb to send
1241  *
1242  * Sends the given packet and returns the length of data sent.  Either RTNL
1243  * lock or rcu_read_lock must be held.
1244  */
1245 int vport_send(struct vport *vport, struct sk_buff *skb)
1246 {
1247         int mtu;
1248         int sent;
1249
1250         mtu = vport_get_mtu(vport);
1251         if (unlikely(packet_length(skb) > mtu && !skb_is_gso(skb))) {
1252                 if (net_ratelimit())
1253                         pr_warn("%s: dropped over-mtu packet: %d > %d\n",
1254                                 dp_name(vport_get_dp_port(vport)->dp),
1255                                 packet_length(skb), mtu);
1256                 goto error;
1257         }
1258
1259         sent = vport->ops->send(vport, skb);
1260
1261         if (vport->ops->flags & VPORT_F_GEN_STATS && sent > 0) {
1262                 struct vport_percpu_stats *stats;
1263
1264                 local_bh_disable();
1265                 stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
1266
1267                 write_seqcount_begin(&stats->seqlock);
1268                 stats->tx_packets++;
1269                 stats->tx_bytes += sent;
1270                 write_seqcount_end(&stats->seqlock);
1271
1272                 local_bh_enable();
1273         }
1274
1275         return sent;
1276
1277 error:
1278         kfree_skb(skb);
1279         vport_record_error(vport, VPORT_E_TX_DROPPED);
1280         return 0;
1281 }
1282
1283 /**
1284  *      vport_record_error - indicate device error to generic stats layer
1285  *
1286  * @vport: vport that encountered the error
1287  * @err_type: one of enum vport_err_type types to indicate the error type
1288  *
1289  * If using the vport generic stats layer indicate that an error of the given
1290  * type has occured.
1291  */
1292 void vport_record_error(struct vport *vport, enum vport_err_type err_type)
1293 {
1294         if (vport->ops->flags & VPORT_F_GEN_STATS) {
1295
1296                 spin_lock_bh(&vport->stats_lock);
1297
1298                 switch (err_type) {
1299                 case VPORT_E_RX_DROPPED:
1300                         vport->err_stats.rx_dropped++;
1301                         break;
1302
1303                 case VPORT_E_RX_ERROR:
1304                         vport->err_stats.rx_errors++;
1305                         break;
1306
1307                 case VPORT_E_RX_FRAME:
1308                         vport->err_stats.rx_frame_err++;
1309                         break;
1310
1311                 case VPORT_E_RX_OVER:
1312                         vport->err_stats.rx_over_err++;
1313                         break;
1314
1315                 case VPORT_E_RX_CRC:
1316                         vport->err_stats.rx_crc_err++;
1317                         break;
1318
1319                 case VPORT_E_TX_DROPPED:
1320                         vport->err_stats.tx_dropped++;
1321                         break;
1322
1323                 case VPORT_E_TX_ERROR:
1324                         vport->err_stats.tx_errors++;
1325                         break;
1326
1327                 case VPORT_E_COLLISION:
1328                         vport->err_stats.collisions++;
1329                         break;
1330                 };
1331
1332                 spin_unlock_bh(&vport->stats_lock);
1333         }
1334 }