/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/* Protects 'netdev_classes' against insertions or deletions.
*
- * This is not an rwlock for performance reasons but to allow recursive
- * acquisition when calling into providers. For example, netdev_run() calls
- * into provider 'run' functions, which might reasonably want to call one of
- * the netdev functions that takes netdev_class_rwlock read-only. */
-static struct ovs_rwlock netdev_class_rwlock OVS_ACQ_BEFORE(netdev_mutex)
- = OVS_RWLOCK_INITIALIZER;
+ * This is a recursive mutex to allow recursive acquisition when calling into
+ * providers. For example, netdev_run() calls into provider 'run' functions,
+ * which might reasonably want to call one of the netdev functions that takes
+ * netdev_class_mutex. */
+static struct ovs_mutex netdev_class_mutex OVS_ACQ_BEFORE(netdev_mutex);
/* Contains 'struct netdev_registered_class'es. */
-static struct hmap netdev_classes OVS_GUARDED_BY(netdev_class_rwlock)
+static struct hmap netdev_classes OVS_GUARDED_BY(netdev_class_mutex)
= HMAP_INITIALIZER(&netdev_classes);
struct netdev_registered_class {
static void restore_all_flags(void *aux OVS_UNUSED);
void update_device_args(struct netdev *, const struct shash *args);
+bool
+netdev_is_pmd(const struct netdev *netdev)
+{
+ return !strcmp(netdev->netdev_class->type, "dpdk");
+}
+
static void
netdev_initialize(void)
- OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
+ OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
{
static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
if (ovsthread_once_start(&once)) {
+ ovs_mutex_init_recursive(&netdev_class_mutex);
+
fatal_signal_add_hook(restore_all_flags, NULL, NULL, true);
netdev_vport_patch_register();
-#ifdef LINUX_DATAPATH
+#ifdef __linux__
netdev_register_provider(&netdev_linux_class);
netdev_register_provider(&netdev_internal_class);
netdev_register_provider(&netdev_tap_class);
* main poll loop. */
void
netdev_run(void)
- OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
+ OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
{
struct netdev_registered_class *rc;
- ovs_rwlock_rdlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
if (rc->class->run) {
rc->class->run();
}
}
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
}
/* Arranges for poll_block() to wake up when netdev_run() needs to be called.
* main poll loop. */
void
netdev_wait(void)
- OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
+ OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
{
struct netdev_registered_class *rc;
- ovs_rwlock_rdlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
if (rc->class->wait) {
rc->class->wait();
}
}
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
}
static struct netdev_registered_class *
netdev_lookup_class(const char *type)
- OVS_REQ_RDLOCK(netdev_class_rwlock)
+ OVS_REQ_RDLOCK(netdev_class_mutex)
{
struct netdev_registered_class *rc;
* registration, new netdevs of that type can be opened using netdev_open(). */
int
netdev_register_provider(const struct netdev_class *new_class)
- OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
+ OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
{
int error;
- ovs_rwlock_wrlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
if (netdev_lookup_class(new_class->type)) {
VLOG_WARN("attempted to register duplicate netdev provider: %s",
new_class->type);
new_class->type, ovs_strerror(error));
}
}
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
return error;
}
* new netdevs of that type cannot be opened using netdev_open(). */
int
netdev_unregister_provider(const char *type)
- OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
+ OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
{
struct netdev_registered_class *rc;
int error;
- ovs_rwlock_wrlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
rc = netdev_lookup_class(type);
if (!rc) {
VLOG_WARN("attempted to unregister a netdev provider that is not "
atomic_read(&rc->ref_cnt, &ref_cnt);
if (!ref_cnt) {
hmap_remove(&netdev_classes, &rc->hmap_node);
- atomic_destroy(&rc->ref_cnt);
free(rc);
error = 0;
} else {
error = EBUSY;
}
}
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
return error;
}
netdev_initialize();
sset_clear(types);
- ovs_rwlock_rdlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
sset_add(types, rc->class->type);
}
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
}
/* Check that the network device name is not the same as any of the registered
netdev_initialize();
- ovs_rwlock_rdlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
const char *dpif_port = netdev_vport_class_get_dpif_port(rc->class);
if (dpif_port && !strcmp(dpif_port, name)) {
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
return true;
}
}
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
if (!strncmp(name, "ovs-", 4)) {
struct sset types;
netdev_initialize();
- ovs_rwlock_rdlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
ovs_mutex_lock(&netdev_mutex);
netdev = shash_find_data(&netdev_shash, name);
if (!netdev) {
}
ovs_mutex_unlock(&netdev_mutex);
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
if (!error) {
netdev->ref_cnt++;
dev->netdev_class->dealloc(dev);
ovs_mutex_unlock(&netdev_mutex);
- ovs_rwlock_rdlock(&netdev_class_rwlock);
+ ovs_mutex_lock(&netdev_class_mutex);
rc = netdev_lookup_class(class->type);
atomic_sub(&rc->ref_cnt, 1, &old_ref_cnt);
ovs_assert(old_ref_cnt > 0);
- ovs_rwlock_unlock(&netdev_class_rwlock);
+ ovs_mutex_unlock(&netdev_class_mutex);
} else {
ovs_mutex_unlock(&netdev_mutex);
}
}
}
-/* Attempts to receive a packet from 'rx' into the tailroom of 'buffer', which
- * must initially be empty. If successful, returns 0 and increments
- * 'buffer->size' by the number of bytes in the received packet, otherwise a
- * positive errno value.
+/* Attempts to receive batch of packets from 'rx'.
*
* Returns EAGAIN immediately if no packet is ready to be received.
*
* Returns EMSGSIZE, and discards the packet, if the received packet is longer
* than 'ofpbuf_tailroom(buffer)'.
*
- * Implementations may make use of VLAN_HEADER_LEN bytes of tailroom to
- * add a VLAN header which is obtained out-of-band to the packet. If
- * this occurs then VLAN_HEADER_LEN bytes of tailroom will no longer be
- * available for the packet, otherwise it may be used for the packet
- * itself.
- *
* It is advised that the tailroom of 'buffer' should be
* VLAN_HEADER_LEN bytes longer than the MTU to allow space for an
* out-of-band VLAN header to be added to the packet. At the very least,
* This function may be set to null if it would always return EOPNOTSUPP
* anyhow. */
int
-netdev_rx_recv(struct netdev_rx *rx, struct ofpbuf *buffer)
+netdev_rx_recv(struct netdev_rx *rx, struct ofpbuf **buffers, int *cnt)
{
int retval;
- ovs_assert(buffer->size == 0);
- ovs_assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
-
- retval = rx->netdev->netdev_class->rx_recv(rx, buffer);
+ retval = rx->netdev->netdev_class->rx_recv(rx, buffers, cnt);
if (!retval) {
COVERAGE_INC(netdev_received);
- if (buffer->size < ETH_TOTAL_MIN) {
- ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
- }
- return 0;
- } else {
- return retval;
}
+ return retval;
}
/* Arranges for poll_block() to wake up when a packet is ready to be received
* immediately. Returns EMSGSIZE if a partial packet was transmitted or if
* the packet is too big or too small to transmit on the device.
*
- * The caller retains ownership of 'buffer' in all cases.
+ * To retain ownership of 'buffer' caller can set may_steal to false.
*
* The kernel maintains a packet transmission queue, so the caller is not
* expected to do additional queuing of packets.
* Some network devices may not implement support for this function. In such
* cases this function will always return EOPNOTSUPP. */
int
-netdev_send(struct netdev *netdev, const struct ofpbuf *buffer)
+netdev_send(struct netdev *netdev, struct ofpbuf *buffer, bool may_steal)
{
int error;
error = (netdev->netdev_class->send
- ? netdev->netdev_class->send(netdev, buffer->data, buffer->size)
+ ? netdev->netdev_class->send(netdev, buffer, may_steal)
: EOPNOTSUPP);
if (!error) {
COVERAGE_INC(netdev_sent);