1 /* 2 * Copyright (c) 2007-2011 Nicira Networks. 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/dcache.h> 20 #include <linux/etherdevice.h> 21 #include <linux/if.h> 22 #include <linux/if_vlan.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 32 #include "vport.h" 33 #include "vport-internal_dev.h" 34 35 /* List of statically compiled vport implementations. Don't forget to also 36 * add yours to the list at the bottom of vport.h. */ 37 static const struct vport_ops *vport_ops_list[] = { 38 &ovs_netdev_vport_ops, 39 &ovs_internal_vport_ops, 40 }; 41 42 /* Protected by RCU read lock for reading, RTNL lock for writing. */ 43 static struct hlist_head *dev_table; 44 #define VPORT_HASH_BUCKETS 1024 45 46 /** 47 * ovs_vport_init - initialize vport subsystem 48 * 49 * Called at module load time to initialize the vport subsystem. 50 */ 51 int ovs_vport_init(void) 52 { 53 dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head), 54 GFP_KERNEL); 55 if (!dev_table) 56 return -ENOMEM; 57 58 return 0; 59 } 60 61 /** 62 * ovs_vport_exit - shutdown vport subsystem 63 * 64 * Called at module exit time to shutdown the vport subsystem. 65 */ 66 void ovs_vport_exit(void) 67 { 68 kfree(dev_table); 69 } 70 71 static struct hlist_head *hash_bucket(const char *name) 72 { 73 unsigned int hash = full_name_hash(name, strlen(name)); 74 return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)]; 75 } 76 77 /** 78 * ovs_vport_locate - find a port that has already been created 79 * 80 * @name: name of port to find 81 * 82 * Must be called with RTNL or RCU read lock. 83 */ 84 struct vport *ovs_vport_locate(const char *name) 85 { 86 struct hlist_head *bucket = hash_bucket(name); 87 struct vport *vport; 88 struct hlist_node *node; 89 90 hlist_for_each_entry_rcu(vport, node, bucket, hash_node) 91 if (!strcmp(name, vport->ops->get_name(vport))) 92 return vport; 93 94 return NULL; 95 } 96 97 /** 98 * ovs_vport_alloc - allocate and initialize new vport 99 * 100 * @priv_size: Size of private data area to allocate. 101 * @ops: vport device ops 102 * 103 * Allocate and initialize a new vport defined by @ops. The vport will contain 104 * a private data area of size @priv_size that can be accessed using 105 * vport_priv(). vports that are no longer needed should be released with 106 * vport_free(). 107 */ 108 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops, 109 const struct vport_parms *parms) 110 { 111 struct vport *vport; 112 size_t alloc_size; 113 114 alloc_size = sizeof(struct vport); 115 if (priv_size) { 116 alloc_size = ALIGN(alloc_size, VPORT_ALIGN); 117 alloc_size += priv_size; 118 } 119 120 vport = kzalloc(alloc_size, GFP_KERNEL); 121 if (!vport) 122 return ERR_PTR(-ENOMEM); 123 124 vport->dp = parms->dp; 125 vport->port_no = parms->port_no; 126 vport->upcall_pid = parms->upcall_pid; 127 vport->ops = ops; 128 129 vport->percpu_stats = alloc_percpu(struct vport_percpu_stats); 130 if (!vport->percpu_stats) { 131 kfree(vport); 132 return ERR_PTR(-ENOMEM); 133 } 134 135 spin_lock_init(&vport->stats_lock); 136 137 return vport; 138 } 139 140 /** 141 * ovs_vport_free - uninitialize and free vport 142 * 143 * @vport: vport to free 144 * 145 * Frees a vport allocated with vport_alloc() when it is no longer needed. 146 * 147 * The caller must ensure that an RCU grace period has passed since the last 148 * time @vport was in a datapath. 149 */ 150 void ovs_vport_free(struct vport *vport) 151 { 152 free_percpu(vport->percpu_stats); 153 kfree(vport); 154 } 155 156 /** 157 * ovs_vport_add - add vport device (for kernel callers) 158 * 159 * @parms: Information about new vport. 160 * 161 * Creates a new vport with the specified configuration (which is dependent on 162 * device type). RTNL lock must be held. 163 */ 164 struct vport *ovs_vport_add(const struct vport_parms *parms) 165 { 166 struct vport *vport; 167 int err = 0; 168 int i; 169 170 ASSERT_RTNL(); 171 172 for (i = 0; i < ARRAY_SIZE(vport_ops_list); i++) { 173 if (vport_ops_list[i]->type == parms->type) { 174 vport = vport_ops_list[i]->create(parms); 175 if (IS_ERR(vport)) { 176 err = PTR_ERR(vport); 177 goto out; 178 } 179 180 hlist_add_head_rcu(&vport->hash_node, 181 hash_bucket(vport->ops->get_name(vport))); 182 return vport; 183 } 184 } 185 186 err = -EAFNOSUPPORT; 187 188 out: 189 return ERR_PTR(err); 190 } 191 192 /** 193 * ovs_vport_set_options - modify existing vport device (for kernel callers) 194 * 195 * @vport: vport to modify. 196 * @port: New configuration. 197 * 198 * Modifies an existing device with the specified configuration (which is 199 * dependent on device type). RTNL lock must be held. 200 */ 201 int ovs_vport_set_options(struct vport *vport, struct nlattr *options) 202 { 203 ASSERT_RTNL(); 204 205 if (!vport->ops->set_options) 206 return -EOPNOTSUPP; 207 return vport->ops->set_options(vport, options); 208 } 209 210 /** 211 * ovs_vport_del - delete existing vport device 212 * 213 * @vport: vport to delete. 214 * 215 * Detaches @vport from its datapath and destroys it. It is possible to fail 216 * for reasons such as lack of memory. RTNL lock must be held. 217 */ 218 void ovs_vport_del(struct vport *vport) 219 { 220 ASSERT_RTNL(); 221 222 hlist_del_rcu(&vport->hash_node); 223 224 vport->ops->destroy(vport); 225 } 226 227 /** 228 * ovs_vport_get_stats - retrieve device stats 229 * 230 * @vport: vport from which to retrieve the stats 231 * @stats: location to store stats 232 * 233 * Retrieves transmit, receive, and error stats for the given device. 234 * 235 * Must be called with RTNL lock or rcu_read_lock. 236 */ 237 void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats) 238 { 239 int i; 240 241 memset(stats, 0, sizeof(*stats)); 242 243 /* We potentially have 2 sources of stats that need to be combined: 244 * those we have collected (split into err_stats and percpu_stats) from 245 * set_stats() and device error stats from netdev->get_stats() (for 246 * errors that happen downstream and therefore aren't reported through 247 * our vport_record_error() function). 248 * Stats from first source are reported by ovs (OVS_VPORT_ATTR_STATS). 249 * netdev-stats can be directly read over netlink-ioctl. 250 */ 251 252 spin_lock_bh(&vport->stats_lock); 253 254 stats->rx_errors = vport->err_stats.rx_errors; 255 stats->tx_errors = vport->err_stats.tx_errors; 256 stats->tx_dropped = vport->err_stats.tx_dropped; 257 stats->rx_dropped = vport->err_stats.rx_dropped; 258 259 spin_unlock_bh(&vport->stats_lock); 260 261 for_each_possible_cpu(i) { 262 const struct vport_percpu_stats *percpu_stats; 263 struct vport_percpu_stats local_stats; 264 unsigned int start; 265 266 percpu_stats = per_cpu_ptr(vport->percpu_stats, i); 267 268 do { 269 start = u64_stats_fetch_begin_bh(&percpu_stats->sync); 270 local_stats = *percpu_stats; 271 } while (u64_stats_fetch_retry_bh(&percpu_stats->sync, start)); 272 273 stats->rx_bytes += local_stats.rx_bytes; 274 stats->rx_packets += local_stats.rx_packets; 275 stats->tx_bytes += local_stats.tx_bytes; 276 stats->tx_packets += local_stats.tx_packets; 277 } 278 } 279 280 /** 281 * ovs_vport_get_options - retrieve device options 282 * 283 * @vport: vport from which to retrieve the options. 284 * @skb: sk_buff where options should be appended. 285 * 286 * Retrieves the configuration of the given device, appending an 287 * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested 288 * vport-specific attributes to @skb. 289 * 290 * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another 291 * negative error code if a real error occurred. If an error occurs, @skb is 292 * left unmodified. 293 * 294 * Must be called with RTNL lock or rcu_read_lock. 295 */ 296 int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb) 297 { 298 struct nlattr *nla; 299 300 nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS); 301 if (!nla) 302 return -EMSGSIZE; 303 304 if (vport->ops->get_options) { 305 int err = vport->ops->get_options(vport, skb); 306 if (err) { 307 nla_nest_cancel(skb, nla); 308 return err; 309 } 310 } 311 312 nla_nest_end(skb, nla); 313 return 0; 314 } 315 316 /** 317 * ovs_vport_receive - pass up received packet to the datapath for processing 318 * 319 * @vport: vport that received the packet 320 * @skb: skb that was received 321 * 322 * Must be called with rcu_read_lock. The packet cannot be shared and 323 * skb->data should point to the Ethernet header. The caller must have already 324 * called compute_ip_summed() to initialize the checksumming fields. 325 */ 326 void ovs_vport_receive(struct vport *vport, struct sk_buff *skb) 327 { 328 struct vport_percpu_stats *stats; 329 330 stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id()); 331 332 u64_stats_update_begin(&stats->sync); 333 stats->rx_packets++; 334 stats->rx_bytes += skb->len; 335 u64_stats_update_end(&stats->sync); 336 337 ovs_dp_process_received_packet(vport, skb); 338 } 339 340 /** 341 * ovs_vport_send - send a packet on a device 342 * 343 * @vport: vport on which to send the packet 344 * @skb: skb to send 345 * 346 * Sends the given packet and returns the length of data sent. Either RTNL 347 * lock or rcu_read_lock must be held. 348 */ 349 int ovs_vport_send(struct vport *vport, struct sk_buff *skb) 350 { 351 int sent = vport->ops->send(vport, skb); 352 353 if (likely(sent)) { 354 struct vport_percpu_stats *stats; 355 356 stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id()); 357 358 u64_stats_update_begin(&stats->sync); 359 stats->tx_packets++; 360 stats->tx_bytes += sent; 361 u64_stats_update_end(&stats->sync); 362 } 363 return sent; 364 } 365 366 /** 367 * ovs_vport_record_error - indicate device error to generic stats layer 368 * 369 * @vport: vport that encountered the error 370 * @err_type: one of enum vport_err_type types to indicate the error type 371 * 372 * If using the vport generic stats layer indicate that an error of the given 373 * type has occured. 374 */ 375 void ovs_vport_record_error(struct vport *vport, enum vport_err_type err_type) 376 { 377 spin_lock(&vport->stats_lock); 378 379 switch (err_type) { 380 case VPORT_E_RX_DROPPED: 381 vport->err_stats.rx_dropped++; 382 break; 383 384 case VPORT_E_RX_ERROR: 385 vport->err_stats.rx_errors++; 386 break; 387 388 case VPORT_E_TX_DROPPED: 389 vport->err_stats.tx_dropped++; 390 break; 391 392 case VPORT_E_TX_ERROR: 393 vport->err_stats.tx_errors++; 394 break; 395 }; 396 397 spin_unlock(&vport->stats_lock); 398 } 399