1 /* 2 * Copyright (c) 2007-2014 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 <net/net_namespace.h> 31 #include <linux/module.h> 32 33 #include "datapath.h" 34 #include "vport.h" 35 #include "vport-internal_dev.h" 36 37 static LIST_HEAD(vport_ops_list); 38 39 /* Protected by RCU read lock for reading, ovs_mutex for writing. */ 40 static struct hlist_head *dev_table; 41 #define VPORT_HASH_BUCKETS 1024 42 43 /** 44 * ovs_vport_init - initialize vport subsystem 45 * 46 * Called at module load time to initialize the vport subsystem. 47 */ 48 int ovs_vport_init(void) 49 { 50 dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head), 51 GFP_KERNEL); 52 if (!dev_table) 53 return -ENOMEM; 54 55 return 0; 56 } 57 58 /** 59 * ovs_vport_exit - shutdown vport subsystem 60 * 61 * Called at module exit time to shutdown the vport subsystem. 62 */ 63 void ovs_vport_exit(void) 64 { 65 kfree(dev_table); 66 } 67 68 static struct hlist_head *hash_bucket(const struct net *net, const char *name) 69 { 70 unsigned int hash = jhash(name, strlen(name), (unsigned long) net); 71 return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)]; 72 } 73 74 int ovs_vport_ops_register(struct vport_ops *ops) 75 { 76 int err = -EEXIST; 77 struct vport_ops *o; 78 79 ovs_lock(); 80 list_for_each_entry(o, &vport_ops_list, list) 81 if (ops->type == o->type) 82 goto errout; 83 84 list_add_tail(&ops->list, &vport_ops_list); 85 err = 0; 86 errout: 87 ovs_unlock(); 88 return err; 89 } 90 EXPORT_SYMBOL_GPL(ovs_vport_ops_register); 91 92 void ovs_vport_ops_unregister(struct vport_ops *ops) 93 { 94 ovs_lock(); 95 list_del(&ops->list); 96 ovs_unlock(); 97 } 98 EXPORT_SYMBOL_GPL(ovs_vport_ops_unregister); 99 100 /** 101 * ovs_vport_locate - find a port that has already been created 102 * 103 * @name: name of port to find 104 * 105 * Must be called with ovs or RCU read lock. 106 */ 107 struct vport *ovs_vport_locate(const struct net *net, const char *name) 108 { 109 struct hlist_head *bucket = hash_bucket(net, name); 110 struct vport *vport; 111 112 hlist_for_each_entry_rcu(vport, bucket, hash_node) 113 if (!strcmp(name, ovs_vport_name(vport)) && 114 net_eq(ovs_dp_get_net(vport->dp), net)) 115 return vport; 116 117 return NULL; 118 } 119 120 /** 121 * ovs_vport_alloc - allocate and initialize new vport 122 * 123 * @priv_size: Size of private data area to allocate. 124 * @ops: vport device ops 125 * 126 * Allocate and initialize a new vport defined by @ops. The vport will contain 127 * a private data area of size @priv_size that can be accessed using 128 * vport_priv(). vports that are no longer needed should be released with 129 * vport_free(). 130 */ 131 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops, 132 const struct vport_parms *parms) 133 { 134 struct vport *vport; 135 size_t alloc_size; 136 137 alloc_size = sizeof(struct vport); 138 if (priv_size) { 139 alloc_size = ALIGN(alloc_size, VPORT_ALIGN); 140 alloc_size += priv_size; 141 } 142 143 vport = kzalloc(alloc_size, GFP_KERNEL); 144 if (!vport) 145 return ERR_PTR(-ENOMEM); 146 147 vport->dp = parms->dp; 148 vport->port_no = parms->port_no; 149 vport->ops = ops; 150 INIT_HLIST_NODE(&vport->dp_hash_node); 151 152 if (ovs_vport_set_upcall_portids(vport, parms->upcall_portids)) { 153 kfree(vport); 154 return ERR_PTR(-EINVAL); 155 } 156 157 return vport; 158 } 159 EXPORT_SYMBOL_GPL(ovs_vport_alloc); 160 161 /** 162 * ovs_vport_free - uninitialize and free vport 163 * 164 * @vport: vport to free 165 * 166 * Frees a vport allocated with vport_alloc() when it is no longer needed. 167 * 168 * The caller must ensure that an RCU grace period has passed since the last 169 * time @vport was in a datapath. 170 */ 171 void ovs_vport_free(struct vport *vport) 172 { 173 /* vport is freed from RCU callback or error path, Therefore 174 * it is safe to use raw dereference. 175 */ 176 kfree(rcu_dereference_raw(vport->upcall_portids)); 177 kfree(vport); 178 } 179 EXPORT_SYMBOL_GPL(ovs_vport_free); 180 181 static struct vport_ops *ovs_vport_lookup(const struct vport_parms *parms) 182 { 183 struct vport_ops *ops; 184 185 list_for_each_entry(ops, &vport_ops_list, list) 186 if (ops->type == parms->type) 187 return ops; 188 189 return NULL; 190 } 191 192 /** 193 * ovs_vport_add - add vport device (for kernel callers) 194 * 195 * @parms: Information about new vport. 196 * 197 * Creates a new vport with the specified configuration (which is dependent on 198 * device type). ovs_mutex must be held. 199 */ 200 struct vport *ovs_vport_add(const struct vport_parms *parms) 201 { 202 struct vport_ops *ops; 203 struct vport *vport; 204 205 ops = ovs_vport_lookup(parms); 206 if (ops) { 207 struct hlist_head *bucket; 208 209 if (!try_module_get(ops->owner)) 210 return ERR_PTR(-EAFNOSUPPORT); 211 212 vport = ops->create(parms); 213 if (IS_ERR(vport)) { 214 module_put(ops->owner); 215 return vport; 216 } 217 218 bucket = hash_bucket(ovs_dp_get_net(vport->dp), 219 ovs_vport_name(vport)); 220 hlist_add_head_rcu(&vport->hash_node, bucket); 221 return vport; 222 } 223 224 /* Unlock to attempt module load and return -EAGAIN if load 225 * was successful as we need to restart the port addition 226 * workflow. 227 */ 228 ovs_unlock(); 229 request_module("vport-type-%d", parms->type); 230 ovs_lock(); 231 232 if (!ovs_vport_lookup(parms)) 233 return ERR_PTR(-EAFNOSUPPORT); 234 else 235 return ERR_PTR(-EAGAIN); 236 } 237 238 /** 239 * ovs_vport_set_options - modify existing vport device (for kernel callers) 240 * 241 * @vport: vport to modify. 242 * @options: New configuration. 243 * 244 * Modifies an existing device with the specified configuration (which is 245 * dependent on device type). ovs_mutex must be held. 246 */ 247 int ovs_vport_set_options(struct vport *vport, struct nlattr *options) 248 { 249 if (!vport->ops->set_options) 250 return -EOPNOTSUPP; 251 return vport->ops->set_options(vport, options); 252 } 253 254 /** 255 * ovs_vport_del - delete existing vport device 256 * 257 * @vport: vport to delete. 258 * 259 * Detaches @vport from its datapath and destroys it. It is possible to fail 260 * for reasons such as lack of memory. ovs_mutex must be held. 261 */ 262 void ovs_vport_del(struct vport *vport) 263 { 264 ASSERT_OVSL(); 265 266 hlist_del_rcu(&vport->hash_node); 267 module_put(vport->ops->owner); 268 vport->ops->destroy(vport); 269 } 270 271 /** 272 * ovs_vport_get_stats - retrieve device stats 273 * 274 * @vport: vport from which to retrieve the stats 275 * @stats: location to store stats 276 * 277 * Retrieves transmit, receive, and error stats for the given device. 278 * 279 * Must be called with ovs_mutex or rcu_read_lock. 280 */ 281 void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats) 282 { 283 const struct rtnl_link_stats64 *dev_stats; 284 struct rtnl_link_stats64 temp; 285 286 dev_stats = dev_get_stats(vport->dev, &temp); 287 stats->rx_errors = dev_stats->rx_errors; 288 stats->tx_errors = dev_stats->tx_errors; 289 stats->tx_dropped = dev_stats->tx_dropped; 290 stats->rx_dropped = dev_stats->rx_dropped; 291 292 stats->rx_bytes = dev_stats->rx_bytes; 293 stats->rx_packets = dev_stats->rx_packets; 294 stats->tx_bytes = dev_stats->tx_bytes; 295 stats->tx_packets = dev_stats->tx_packets; 296 } 297 298 /** 299 * ovs_vport_get_options - retrieve device options 300 * 301 * @vport: vport from which to retrieve the options. 302 * @skb: sk_buff where options should be appended. 303 * 304 * Retrieves the configuration of the given device, appending an 305 * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested 306 * vport-specific attributes to @skb. 307 * 308 * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another 309 * negative error code if a real error occurred. If an error occurs, @skb is 310 * left unmodified. 311 * 312 * Must be called with ovs_mutex or rcu_read_lock. 313 */ 314 int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb) 315 { 316 struct nlattr *nla; 317 int err; 318 319 if (!vport->ops->get_options) 320 return 0; 321 322 nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS); 323 if (!nla) 324 return -EMSGSIZE; 325 326 err = vport->ops->get_options(vport, skb); 327 if (err) { 328 nla_nest_cancel(skb, nla); 329 return err; 330 } 331 332 nla_nest_end(skb, nla); 333 return 0; 334 } 335 336 /** 337 * ovs_vport_set_upcall_portids - set upcall portids of @vport. 338 * 339 * @vport: vport to modify. 340 * @ids: new configuration, an array of port ids. 341 * 342 * Sets the vport's upcall_portids to @ids. 343 * 344 * Returns 0 if successful, -EINVAL if @ids is zero length or cannot be parsed 345 * as an array of U32. 346 * 347 * Must be called with ovs_mutex. 348 */ 349 int ovs_vport_set_upcall_portids(struct vport *vport, const struct nlattr *ids) 350 { 351 struct vport_portids *old, *vport_portids; 352 353 if (!nla_len(ids) || nla_len(ids) % sizeof(u32)) 354 return -EINVAL; 355 356 old = ovsl_dereference(vport->upcall_portids); 357 358 vport_portids = kmalloc(sizeof(*vport_portids) + nla_len(ids), 359 GFP_KERNEL); 360 if (!vport_portids) 361 return -ENOMEM; 362 363 vport_portids->n_ids = nla_len(ids) / sizeof(u32); 364 vport_portids->rn_ids = reciprocal_value(vport_portids->n_ids); 365 nla_memcpy(vport_portids->ids, ids, nla_len(ids)); 366 367 rcu_assign_pointer(vport->upcall_portids, vport_portids); 368 369 if (old) 370 kfree_rcu(old, rcu); 371 return 0; 372 } 373 374 /** 375 * ovs_vport_get_upcall_portids - get the upcall_portids of @vport. 376 * 377 * @vport: vport from which to retrieve the portids. 378 * @skb: sk_buff where portids should be appended. 379 * 380 * Retrieves the configuration of the given vport, appending the 381 * %OVS_VPORT_ATTR_UPCALL_PID attribute which is the array of upcall 382 * portids to @skb. 383 * 384 * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room. 385 * If an error occurs, @skb is left unmodified. Must be called with 386 * ovs_mutex or rcu_read_lock. 387 */ 388 int ovs_vport_get_upcall_portids(const struct vport *vport, 389 struct sk_buff *skb) 390 { 391 struct vport_portids *ids; 392 393 ids = rcu_dereference_ovsl(vport->upcall_portids); 394 395 if (vport->dp->user_features & OVS_DP_F_VPORT_PIDS) 396 return nla_put(skb, OVS_VPORT_ATTR_UPCALL_PID, 397 ids->n_ids * sizeof(u32), (void *)ids->ids); 398 else 399 return nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, ids->ids[0]); 400 } 401 402 /** 403 * ovs_vport_find_upcall_portid - find the upcall portid to send upcall. 404 * 405 * @vport: vport from which the missed packet is received. 406 * @skb: skb that the missed packet was received. 407 * 408 * Uses the skb_get_hash() to select the upcall portid to send the 409 * upcall. 410 * 411 * Returns the portid of the target socket. Must be called with rcu_read_lock. 412 */ 413 u32 ovs_vport_find_upcall_portid(const struct vport *vport, struct sk_buff *skb) 414 { 415 struct vport_portids *ids; 416 u32 ids_index; 417 u32 hash; 418 419 ids = rcu_dereference(vport->upcall_portids); 420 421 if (ids->n_ids == 1 && ids->ids[0] == 0) 422 return 0; 423 424 hash = skb_get_hash(skb); 425 ids_index = hash - ids->n_ids * reciprocal_divide(hash, ids->rn_ids); 426 return ids->ids[ids_index]; 427 } 428 429 /** 430 * ovs_vport_receive - pass up received packet to the datapath for processing 431 * 432 * @vport: vport that received the packet 433 * @skb: skb that was received 434 * @tun_key: tunnel (if any) that carried packet 435 * 436 * Must be called with rcu_read_lock. The packet cannot be shared and 437 * skb->data should point to the Ethernet header. 438 */ 439 int ovs_vport_receive(struct vport *vport, struct sk_buff *skb, 440 const struct ip_tunnel_info *tun_info) 441 { 442 struct sw_flow_key key; 443 int error; 444 445 OVS_CB(skb)->input_vport = vport; 446 OVS_CB(skb)->mru = 0; 447 if (unlikely(dev_net(skb->dev) != ovs_dp_get_net(vport->dp))) { 448 u32 mark; 449 450 mark = skb->mark; 451 skb_scrub_packet(skb, true); 452 skb->mark = mark; 453 tun_info = NULL; 454 } 455 456 /* Extract flow from 'skb' into 'key'. */ 457 error = ovs_flow_key_extract(tun_info, skb, &key); 458 if (unlikely(error)) { 459 kfree_skb(skb); 460 return error; 461 } 462 ovs_dp_process_packet(skb, &key); 463 return 0; 464 } 465 EXPORT_SYMBOL_GPL(ovs_vport_receive); 466 467 static void free_vport_rcu(struct rcu_head *rcu) 468 { 469 struct vport *vport = container_of(rcu, struct vport, rcu); 470 471 ovs_vport_free(vport); 472 } 473 474 void ovs_vport_deferred_free(struct vport *vport) 475 { 476 if (!vport) 477 return; 478 479 call_rcu(&vport->rcu, free_vport_rcu); 480 } 481 EXPORT_SYMBOL_GPL(ovs_vport_deferred_free); 482 483 static unsigned int packet_length(const struct sk_buff *skb) 484 { 485 unsigned int length = skb->len - ETH_HLEN; 486 487 if (skb->protocol == htons(ETH_P_8021Q)) 488 length -= VLAN_HLEN; 489 490 return length; 491 } 492 493 void ovs_vport_send(struct vport *vport, struct sk_buff *skb) 494 { 495 int mtu = vport->dev->mtu; 496 497 if (unlikely(packet_length(skb) > mtu && !skb_is_gso(skb))) { 498 net_warn_ratelimited("%s: dropped over-mtu packet: %d > %d\n", 499 vport->dev->name, 500 packet_length(skb), mtu); 501 vport->dev->stats.tx_errors++; 502 goto drop; 503 } 504 505 skb->dev = vport->dev; 506 vport->ops->send(skb); 507 return; 508 509 drop: 510 kfree_skb(skb); 511 } 512