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