datapath: Make adding and attaching a vport a single step.
[openvswitch] / datapath / vport-patch.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/kernel.h>
11 #include <linux/list.h>
12
13 #include "datapath.h"
14 #include "vport.h"
15 #include "vport-generic.h"
16
17 struct device_config {
18         struct rcu_head rcu;
19
20         unsigned char eth_addr[ETH_ALEN];
21         unsigned int mtu;
22 };
23
24 struct patch_vport {
25         char name[IFNAMSIZ];
26
27         /* Protected by RTNL lock. */
28         char peer_name[IFNAMSIZ];
29         struct hlist_node hash_node;
30
31         /* Protected by RCU. */
32         struct vport *peer;
33
34         /* Protected by RCU. */
35         struct device_config *devconf;
36 };
37
38 /* Protected by RTNL lock. */
39 static struct hlist_head *peer_table;
40 #define PEER_HASH_BUCKETS 256
41
42 static inline struct patch_vport *patch_vport_priv(const struct vport *vport)
43 {
44         return vport_priv(vport);
45 }
46
47 /* RCU callback. */
48 static void free_config(struct rcu_head *rcu)
49 {
50         struct device_config *c = container_of(rcu, struct device_config, rcu);
51         kfree(c);
52 }
53
54 static void assign_config_rcu(struct vport *vport,
55                               struct device_config *new_config)
56 {
57         struct patch_vport *patch_vport = patch_vport_priv(vport);
58         struct device_config *old_config;
59
60         old_config = rcu_dereference(patch_vport->devconf);
61         rcu_assign_pointer(patch_vport->devconf, new_config);
62         call_rcu(&old_config->rcu, free_config);
63 }
64
65 static struct hlist_head *hash_bucket(const char *name)
66 {
67         unsigned int hash = full_name_hash(name, strlen(name));
68         return &peer_table[hash & (PEER_HASH_BUCKETS - 1)];
69 }
70
71 static int patch_init(void)
72 {
73         peer_table = kzalloc(PEER_HASH_BUCKETS * sizeof(struct hlist_head),
74                             GFP_KERNEL);
75         if (!peer_table)
76                 return -ENOMEM;
77
78         return 0;
79 }
80
81 static void patch_exit(void)
82 {
83         kfree(peer_table);
84 }
85
86 static int set_config(struct vport *vport, const void *config)
87 {
88         struct patch_vport *patch_vport = patch_vport_priv(vport);
89         char peer_name[IFNAMSIZ];
90
91         strlcpy(peer_name, config, IFNAMSIZ);
92
93         if (!strcmp(patch_vport->name, peer_name))
94                 return -EINVAL;
95
96         strcpy(patch_vport->peer_name, peer_name);
97
98         if (vport_get_dp_port(vport)) {
99                 hlist_del(&patch_vport->hash_node);
100                 rcu_assign_pointer(patch_vport->peer, vport_locate(patch_vport->peer_name));
101                 hlist_add_head(&patch_vport->hash_node, hash_bucket(patch_vport->peer_name));
102         }
103
104         return 0;
105 }
106
107 static struct vport *patch_create(const struct vport_parms *parms)
108 {
109         struct vport *vport;
110         struct patch_vport *patch_vport;
111         int err;
112
113         vport = vport_alloc(sizeof(struct patch_vport), &patch_vport_ops);
114         if (IS_ERR(vport)) {
115                 err = PTR_ERR(vport);
116                 goto error;
117         }
118
119         patch_vport = patch_vport_priv(vport);
120
121         strcpy(patch_vport->name, parms->name);
122
123         err = set_config(vport, parms->config);
124         if (err)
125                 goto error_free_vport;
126
127         patch_vport->devconf = kmalloc(sizeof(struct device_config), GFP_KERNEL);
128         if (!patch_vport->devconf) {
129                 err = -ENOMEM;
130                 goto error_free_vport;
131         }
132
133         vport_gen_rand_ether_addr(patch_vport->devconf->eth_addr);
134
135     /* Make the default MTU fairly large so that it doesn't become the
136      * bottleneck on systems using jumbo frames. */
137         patch_vport->devconf->mtu = 65535;
138
139         return vport;
140
141 error_free_vport:
142         vport_free(vport);
143 error:
144         return ERR_PTR(err);
145 }
146
147 static int patch_modify(struct vport *vport, struct odp_port *port)
148 {
149         return set_config(vport, port->config);
150 }
151
152 static int patch_destroy(struct vport *vport)
153 {
154         struct patch_vport *patch_vport = patch_vport_priv(vport);
155
156         kfree(patch_vport->devconf);
157         vport_free(vport);
158
159         return 0;
160 }
161
162 static void update_peers(const char *name, struct vport *vport)
163 {
164         struct hlist_head *bucket = hash_bucket(name);
165         struct patch_vport *peer_vport;
166         struct hlist_node *node;
167
168         hlist_for_each_entry(peer_vport, node, bucket, hash_node)
169                 if (!strcmp(peer_vport->peer_name, name))
170                         rcu_assign_pointer(peer_vport->peer, vport);
171 }
172
173 static int patch_attach(struct vport *vport)
174 {
175         struct patch_vport *patch_vport = patch_vport_priv(vport);
176
177         hlist_add_head(&patch_vport->hash_node, hash_bucket(patch_vport->peer_name));
178
179         rcu_assign_pointer(patch_vport->peer, vport_locate(patch_vport->peer_name));
180         update_peers(patch_vport->name, vport);
181
182         return 0;
183 }
184
185 static int patch_detach(struct vport *vport)
186 {
187         struct patch_vport *patch_vport = patch_vport_priv(vport);
188
189         update_peers(patch_vport->name, NULL);
190         rcu_assign_pointer(patch_vport->peer, NULL);
191
192         hlist_del(&patch_vport->hash_node);
193
194         return 0;
195 }
196
197 static int patch_set_mtu(struct vport *vport, int mtu)
198 {
199         struct patch_vport *patch_vport = patch_vport_priv(vport);
200         struct device_config *devconf;
201
202         devconf = kmemdup(patch_vport->devconf, sizeof(struct device_config), GFP_KERNEL);
203         if (!devconf)
204                 return -ENOMEM;
205
206         devconf->mtu = mtu;
207         assign_config_rcu(vport, devconf);
208
209         return 0;
210 }
211
212 static int patch_set_addr(struct vport *vport, const unsigned char *addr)
213 {
214         struct patch_vport *patch_vport = patch_vport_priv(vport);
215         struct device_config *devconf;
216
217         devconf = kmemdup(patch_vport->devconf, sizeof(struct device_config), GFP_KERNEL);
218         if (!devconf)
219                 return -ENOMEM;
220
221         memcpy(devconf->eth_addr, addr, ETH_ALEN);
222         assign_config_rcu(vport, devconf);
223
224         return 0;
225 }
226
227
228 static const char *patch_get_name(const struct vport *vport)
229 {
230         const struct patch_vport *patch_vport = patch_vport_priv(vport);
231         return patch_vport->name;
232 }
233
234 static const unsigned char *patch_get_addr(const struct vport *vport)
235 {
236         const struct patch_vport *patch_vport = patch_vport_priv(vport);
237         return rcu_dereference(patch_vport->devconf)->eth_addr;
238 }
239
240 static int patch_get_mtu(const struct vport *vport)
241 {
242         const struct patch_vport *patch_vport = patch_vport_priv(vport);
243         return rcu_dereference(patch_vport->devconf)->mtu;
244 }
245
246 static int patch_send(struct vport *vport, struct sk_buff *skb)
247 {
248         struct patch_vport *patch_vport = patch_vport_priv(vport);
249         struct vport *peer = rcu_dereference(patch_vport->peer);
250         int skb_len = skb->len;
251
252         if (!peer) {
253                 kfree_skb(skb);
254                 vport_record_error(vport, VPORT_E_TX_DROPPED);
255
256                 return 0;
257         }
258
259         vport_receive(peer, skb);
260         return skb_len;
261 }
262
263 const struct vport_ops patch_vport_ops = {
264         .type           = "patch",
265         .flags          = VPORT_F_GEN_STATS,
266         .init           = patch_init,
267         .exit           = patch_exit,
268         .create         = patch_create,
269         .modify         = patch_modify,
270         .destroy        = patch_destroy,
271         .attach         = patch_attach,
272         .detach         = patch_detach,
273         .set_mtu        = patch_set_mtu,
274         .set_addr       = patch_set_addr,
275         .get_name       = patch_get_name,
276         .get_addr       = patch_get_addr,
277         .get_dev_flags  = vport_gen_get_dev_flags,
278         .is_running     = vport_gen_is_running,
279         .get_operstate  = vport_gen_get_operstate,
280         .get_mtu        = patch_get_mtu,
281         .send           = patch_send,
282 };