ofproto-dpif: Keep track of exact-match flow info
[sliver-openvswitch.git] / datapath / vport.c
1 /*
2  * Copyright (c) 2007-2012 Nicira, Inc.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of version 2 of the GNU General Public
6  * License as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16  * 02110-1301, USA
17  */
18
19 #include <linux/etherdevice.h>
20 #include <linux/if.h>
21 #include <linux/if_vlan.h>
22 #include <linux/jhash.h>
23 #include <linux/kernel.h>
24 #include <linux/list.h>
25 #include <linux/mutex.h>
26 #include <linux/percpu.h>
27 #include <linux/rcupdate.h>
28 #include <linux/rtnetlink.h>
29 #include <linux/compat.h>
30 #include <linux/version.h>
31 #include <net/net_namespace.h>
32
33 #include "datapath.h"
34 #include "vport.h"
35 #include "vport-internal_dev.h"
36
37 /* List of statically compiled vport implementations.  Don't forget to also
38  * add yours to the list at the bottom of vport.h. */
39 static const struct vport_ops *base_vport_ops_list[] = {
40         &ovs_netdev_vport_ops,
41         &ovs_internal_vport_ops,
42         &ovs_gre_vport_ops,
43         &ovs_gre64_vport_ops,
44 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
45         &ovs_vxlan_vport_ops,
46         &ovs_lisp_vport_ops,
47 #endif
48 };
49
50 static const struct vport_ops **vport_ops_list;
51 static int n_vport_types;
52
53 /* Protected by RCU read lock for reading, RTNL lock for writing. */
54 static struct hlist_head *dev_table;
55 #define VPORT_HASH_BUCKETS 1024
56
57 /**
58  *      ovs_vport_init - initialize vport subsystem
59  *
60  * Called at module load time to initialize the vport subsystem and any
61  * compiled in vport types.
62  */
63 int ovs_vport_init(void)
64 {
65         int err;
66         int i;
67
68         dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
69                             GFP_KERNEL);
70         if (!dev_table) {
71                 err = -ENOMEM;
72                 goto error;
73         }
74
75         vport_ops_list = kmalloc(ARRAY_SIZE(base_vport_ops_list) *
76                                  sizeof(struct vport_ops *), GFP_KERNEL);
77         if (!vport_ops_list) {
78                 err = -ENOMEM;
79                 goto error_dev_table;
80         }
81
82         for (i = 0; i < ARRAY_SIZE(base_vport_ops_list); i++) {
83                 const struct vport_ops *new_ops = base_vport_ops_list[i];
84
85                 if (new_ops->init)
86                         err = new_ops->init();
87                 else
88                         err = 0;
89
90                 if (!err)
91                         vport_ops_list[n_vport_types++] = new_ops;
92                 else if (new_ops->flags & VPORT_F_REQUIRED) {
93                         ovs_vport_exit();
94                         goto error;
95                 }
96         }
97
98         return 0;
99
100 error_dev_table:
101         kfree(dev_table);
102 error:
103         return err;
104 }
105
106 /**
107  *      ovs_vport_exit - shutdown vport subsystem
108  *
109  * Called at module exit time to shutdown the vport subsystem and any
110  * initialized vport types.
111  */
112 void ovs_vport_exit(void)
113 {
114         int i;
115
116         for (i = 0; i < n_vport_types; i++) {
117                 if (vport_ops_list[i]->exit)
118                         vport_ops_list[i]->exit();
119         }
120
121         kfree(vport_ops_list);
122         kfree(dev_table);
123 }
124
125 static struct hlist_head *hash_bucket(struct net *net, const char *name)
126 {
127         unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
128         return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
129 }
130
131 /**
132  *      ovs_vport_locate - find a port that has already been created
133  *
134  * @name: name of port to find
135  *
136  * Must be called with RTNL or RCU read lock.
137  */
138 struct vport *ovs_vport_locate(struct net *net, const char *name)
139 {
140         struct hlist_head *bucket = hash_bucket(net, name);
141         struct vport *vport;
142
143         hlist_for_each_entry_rcu(vport, bucket, hash_node)
144                 if (!strcmp(name, vport->ops->get_name(vport)) &&
145                     net_eq(ovs_dp_get_net(vport->dp), net))
146                         return vport;
147
148         return NULL;
149 }
150
151 /**
152  *      ovs_vport_alloc - allocate and initialize new vport
153  *
154  * @priv_size: Size of private data area to allocate.
155  * @ops: vport device ops
156  *
157  * Allocate and initialize a new vport defined by @ops.  The vport will contain
158  * a private data area of size @priv_size that can be accessed using
159  * vport_priv().  vports that are no longer needed should be released with
160  * ovs_vport_free().
161  */
162 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
163                               const struct vport_parms *parms)
164 {
165         struct vport *vport;
166         size_t alloc_size;
167
168         alloc_size = sizeof(struct vport);
169         if (priv_size) {
170                 alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
171                 alloc_size += priv_size;
172         }
173
174         vport = kzalloc(alloc_size, GFP_KERNEL);
175         if (!vport)
176                 return ERR_PTR(-ENOMEM);
177
178         vport->dp = parms->dp;
179         vport->port_no = parms->port_no;
180         vport->upcall_portid = parms->upcall_portid;
181         vport->ops = ops;
182         INIT_HLIST_NODE(&vport->dp_hash_node);
183
184         vport->percpu_stats = alloc_percpu(struct vport_percpu_stats);
185         if (!vport->percpu_stats) {
186                 kfree(vport);
187                 return ERR_PTR(-ENOMEM);
188         }
189
190         spin_lock_init(&vport->stats_lock);
191
192         return vport;
193 }
194
195 /**
196  *      ovs_vport_free - uninitialize and free vport
197  *
198  * @vport: vport to free
199  *
200  * Frees a vport allocated with ovs_vport_alloc() when it is no longer needed.
201  *
202  * The caller must ensure that an RCU grace period has passed since the last
203  * time @vport was in a datapath.
204  */
205 void ovs_vport_free(struct vport *vport)
206 {
207         free_percpu(vport->percpu_stats);
208         kfree(vport);
209 }
210
211 /**
212  *      ovs_vport_add - add vport device (for kernel callers)
213  *
214  * @parms: Information about new vport.
215  *
216  * Creates a new vport with the specified configuration (which is dependent on
217  * device type).  RTNL lock must be held.
218  */
219 struct vport *ovs_vport_add(const struct vport_parms *parms)
220 {
221         struct vport *vport;
222         int err = 0;
223         int i;
224
225         ASSERT_RTNL();
226
227         for (i = 0; i < n_vport_types; i++) {
228                 if (vport_ops_list[i]->type == parms->type) {
229                         struct hlist_head *bucket;
230
231                         vport = vport_ops_list[i]->create(parms);
232                         if (IS_ERR(vport)) {
233                                 err = PTR_ERR(vport);
234                                 goto out;
235                         }
236
237                         bucket = hash_bucket(ovs_dp_get_net(vport->dp),
238                                              vport->ops->get_name(vport));
239                         hlist_add_head_rcu(&vport->hash_node, bucket);
240                         return vport;
241                 }
242         }
243
244         err = -EAFNOSUPPORT;
245
246 out:
247         return ERR_PTR(err);
248 }
249
250 /**
251  *      ovs_vport_set_options - modify existing vport device (for kernel callers)
252  *
253  * @vport: vport to modify.
254  * @port: New configuration.
255  *
256  * Modifies an existing device with the specified configuration (which is
257  * dependent on device type).  RTNL lock must be held.
258  */
259 int ovs_vport_set_options(struct vport *vport, struct nlattr *options)
260 {
261         ASSERT_RTNL();
262
263         if (!vport->ops->set_options)
264                 return -EOPNOTSUPP;
265         return vport->ops->set_options(vport, options);
266 }
267
268 /**
269  *      ovs_vport_del - delete existing vport device
270  *
271  * @vport: vport to delete.
272  *
273  * Detaches @vport from its datapath and destroys it.  It is possible to fail
274  * for reasons such as lack of memory.  RTNL lock must be held.
275  */
276 void ovs_vport_del(struct vport *vport)
277 {
278         ASSERT_RTNL();
279
280         hlist_del_rcu(&vport->hash_node);
281
282         vport->ops->destroy(vport);
283 }
284
285 /**
286  *      ovs_vport_set_stats - sets offset device stats
287  *
288  * @vport: vport on which to set stats
289  * @stats: stats to set
290  *
291  * Provides a set of transmit, receive, and error stats to be added as an
292  * offset to the collect data when stats are retreived.  Some devices may not
293  * support setting the stats, in which case the result will always be
294  * -EOPNOTSUPP.
295  *
296  * Must be called with RTNL lock.
297  */
298 void ovs_vport_set_stats(struct vport *vport, struct ovs_vport_stats *stats)
299 {
300         ASSERT_RTNL();
301
302         spin_lock_bh(&vport->stats_lock);
303         vport->offset_stats = *stats;
304         spin_unlock_bh(&vport->stats_lock);
305 }
306
307 /**
308  *      ovs_vport_get_stats - retrieve device stats
309  *
310  * @vport: vport from which to retrieve the stats
311  * @stats: location to store stats
312  *
313  * Retrieves transmit, receive, and error stats for the given device.
314  *
315  * Must be called with RTNL lock or rcu_read_lock.
316  */
317 void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats)
318 {
319         int i;
320
321         /* We potentially have 3 sources of stats that need to be
322          * combined: those we have collected (split into err_stats and
323          * percpu_stats), offset_stats from set_stats(), and device
324          * error stats from netdev->get_stats() (for errors that happen
325          * downstream and therefore aren't reported through our
326          * vport_record_error() function).
327          * Stats from first two sources are merged and reported by ovs over
328          * OVS_VPORT_ATTR_STATS.
329          * netdev-stats can be directly read over netlink-ioctl.
330          */
331
332         spin_lock_bh(&vport->stats_lock);
333
334         *stats = vport->offset_stats;
335
336         stats->rx_errors        += vport->err_stats.rx_errors;
337         stats->tx_errors        += vport->err_stats.tx_errors;
338         stats->tx_dropped       += vport->err_stats.tx_dropped;
339         stats->rx_dropped       += vport->err_stats.rx_dropped;
340
341         spin_unlock_bh(&vport->stats_lock);
342
343         for_each_possible_cpu(i) {
344                 const struct vport_percpu_stats *percpu_stats;
345                 struct vport_percpu_stats local_stats;
346                 unsigned int start;
347
348                 percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
349
350                 do {
351                         start = u64_stats_fetch_begin_bh(&percpu_stats->sync);
352                         local_stats = *percpu_stats;
353                 } while (u64_stats_fetch_retry_bh(&percpu_stats->sync, start));
354
355                 stats->rx_bytes         += local_stats.rx_bytes;
356                 stats->rx_packets       += local_stats.rx_packets;
357                 stats->tx_bytes         += local_stats.tx_bytes;
358                 stats->tx_packets       += local_stats.tx_packets;
359         }
360 }
361
362 /**
363  *      ovs_vport_get_options - retrieve device options
364  *
365  * @vport: vport from which to retrieve the options.
366  * @skb: sk_buff where options should be appended.
367  *
368  * Retrieves the configuration of the given device, appending an
369  * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested
370  * vport-specific attributes to @skb.
371  *
372  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another
373  * negative error code if a real error occurred.  If an error occurs, @skb is
374  * left unmodified.
375  *
376  * Must be called with RTNL lock or rcu_read_lock.
377  */
378 int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb)
379 {
380         struct nlattr *nla;
381
382         nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS);
383         if (!nla)
384                 return -EMSGSIZE;
385
386         if (vport->ops->get_options) {
387                 int err = vport->ops->get_options(vport, skb);
388                 if (err) {
389                         nla_nest_cancel(skb, nla);
390                         return err;
391                 }
392         }
393
394         nla_nest_end(skb, nla);
395         return 0;
396 }
397
398 /**
399  *      ovs_vport_receive - pass up received packet to the datapath for processing
400  *
401  * @vport: vport that received the packet
402  * @skb: skb that was received
403  *
404  * Must be called with rcu_read_lock.  The packet cannot be shared and
405  * skb->data should point to the Ethernet header.  The caller must have already
406  * called compute_ip_summed() to initialize the checksumming fields.
407  */
408 void ovs_vport_receive(struct vport *vport, struct sk_buff *skb)
409 {
410         struct vport_percpu_stats *stats;
411
412         stats = this_cpu_ptr(vport->percpu_stats);
413         u64_stats_update_begin(&stats->sync);
414         stats->rx_packets++;
415         stats->rx_bytes += skb->len;
416         u64_stats_update_end(&stats->sync);
417
418         if (!(vport->ops->flags & VPORT_F_TUN_ID))
419                 OVS_CB(skb)->tun_key = NULL;
420
421         ovs_dp_process_received_packet(vport, skb);
422 }
423
424 /**
425  *      ovs_vport_send - send a packet on a device
426  *
427  * @vport: vport on which to send the packet
428  * @skb: skb to send
429  *
430  * Sends the given packet and returns the length of data sent.  Either RTNL
431  * lock or rcu_read_lock must be held.
432  */
433 int ovs_vport_send(struct vport *vport, struct sk_buff *skb)
434 {
435         int sent = vport->ops->send(vport, skb);
436
437         if (likely(sent)) {
438                 struct vport_percpu_stats *stats;
439
440                 stats = this_cpu_ptr(vport->percpu_stats);
441
442                 u64_stats_update_begin(&stats->sync);
443                 stats->tx_packets++;
444                 stats->tx_bytes += sent;
445                 u64_stats_update_end(&stats->sync);
446         }
447         return sent;
448 }
449
450 /**
451  *      ovs_vport_record_error - indicate device error to generic stats layer
452  *
453  * @vport: vport that encountered the error
454  * @err_type: one of enum vport_err_type types to indicate the error type
455  *
456  * If using the vport generic stats layer indicate that an error of the given
457  * type has occured.
458  */
459 void ovs_vport_record_error(struct vport *vport, enum vport_err_type err_type)
460 {
461         spin_lock(&vport->stats_lock);
462
463         switch (err_type) {
464         case VPORT_E_RX_DROPPED:
465                 vport->err_stats.rx_dropped++;
466                 break;
467
468         case VPORT_E_RX_ERROR:
469                 vport->err_stats.rx_errors++;
470                 break;
471
472         case VPORT_E_TX_DROPPED:
473                 vport->err_stats.tx_dropped++;
474                 break;
475
476         case VPORT_E_TX_ERROR:
477                 vport->err_stats.tx_errors++;
478                 break;
479         }
480
481         spin_unlock(&vport->stats_lock);
482 }