X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnetdev-dummy.c;h=501fb82b83819e563dfdaa92d0871686107b9693;hb=28c5588e8e1a8d091c5d2275232c35f2968a97fa;hp=c4f58b7a2226d6e2840d57c4235a21e43efed918;hpb=97be153858b4cd175cbe7862b8e1624bf22ab98a;p=sliver-openvswitch.git diff --git a/lib/netdev-dummy.c b/lib/netdev-dummy.c index c4f58b7a2..501fb82b8 100644 --- a/lib/netdev-dummy.c +++ b/lib/netdev-dummy.c @@ -20,6 +20,7 @@ #include +#include "dpif-netdev.h" #include "flow.h" #include "list.h" #include "netdev-provider.h" @@ -28,65 +29,102 @@ #include "ofp-print.h" #include "ofpbuf.h" #include "packets.h" +#include "pcap-file.h" #include "poll-loop.h" #include "shash.h" #include "sset.h" #include "stream.h" #include "unaligned.h" +#include "timeval.h" #include "unixctl.h" +#include "reconnect.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(netdev_dummy); -struct dummy_stream { +struct reconnect; + +struct dummy_packet_stream { struct stream *stream; struct ofpbuf rxbuf; struct list txq; }; -struct netdev_dummy { - struct netdev up; - uint8_t hwaddr[ETH_ADDR_LEN]; - int mtu; - struct netdev_stats stats; - enum netdev_flags flags; - unsigned int change_seq; - int ifindex; +enum dummy_packet_conn_type { + NONE, /* No connection is configured. */ + PASSIVE, /* Listener. */ + ACTIVE /* Connect to listener. */ +}; +struct dummy_packet_pconn { struct pstream *pstream; - struct dummy_stream *streams; + struct dummy_packet_stream *streams; size_t n_streams; +}; + +struct dummy_packet_rconn { + struct dummy_packet_stream *rstream; + struct reconnect *reconnect; +}; - struct list rxes; /* List of child "netdev_rx_dummy"s. */ +struct dummy_packet_conn { + enum dummy_packet_conn_type type; + union { + struct dummy_packet_pconn pconn; + struct dummy_packet_rconn rconn; + } u; +}; + +/* Protects 'dummy_list'. */ +static struct ovs_mutex dummy_list_mutex = OVS_MUTEX_INITIALIZER; + +/* Contains all 'struct dummy_dev's. */ +static struct list dummy_list OVS_GUARDED_BY(dummy_list_mutex) + = LIST_INITIALIZER(&dummy_list); + +struct netdev_dummy { + struct netdev up; + + /* In dummy_list. */ + struct list list_node OVS_GUARDED_BY(dummy_list_mutex); + + /* Protects all members below. */ + struct ovs_mutex mutex OVS_ACQ_AFTER(dummy_list_mutex); + + uint8_t hwaddr[ETH_ADDR_LEN] OVS_GUARDED; + int mtu OVS_GUARDED; + struct netdev_stats stats OVS_GUARDED; + enum netdev_flags flags OVS_GUARDED; + int ifindex OVS_GUARDED; + + struct dummy_packet_conn conn OVS_GUARDED; + + FILE *tx_pcap, *rxq_pcap OVS_GUARDED; + + struct list rxes OVS_GUARDED; /* List of child "netdev_rxq_dummy"s. */ }; /* Max 'recv_queue_len' in struct netdev_dummy. */ #define NETDEV_DUMMY_MAX_QUEUE 100 -struct netdev_rx_dummy { - struct netdev_rx up; +struct netdev_rxq_dummy { + struct netdev_rxq up; struct list node; /* In netdev_dummy's "rxes" list. */ struct list recv_queue; int recv_queue_len; /* list_size(&recv_queue). */ - bool listening; + struct seq *seq; /* Reports newly queued packets. */ }; -static struct shash dummy_netdevs = SHASH_INITIALIZER(&dummy_netdevs); - -static const struct netdev_rx_class netdev_rx_dummy_class; - static unixctl_cb_func netdev_dummy_set_admin_state; -static int netdev_dummy_create(const struct netdev_class *, const char *, - struct netdev **); -static void netdev_dummy_poll_notify(struct netdev_dummy *); +static int netdev_dummy_construct(struct netdev *); static void netdev_dummy_queue_packet(struct netdev_dummy *, struct ofpbuf *); -static void dummy_stream_close(struct dummy_stream *); +static void dummy_packet_stream_close(struct dummy_packet_stream *); static bool is_dummy_class(const struct netdev_class *class) { - return class->create == netdev_dummy_create; + return class->construct == netdev_dummy_construct; } static struct netdev_dummy * @@ -96,117 +134,122 @@ netdev_dummy_cast(const struct netdev *netdev) return CONTAINER_OF(netdev, struct netdev_dummy, up); } -static struct netdev_rx_dummy * -netdev_rx_dummy_cast(const struct netdev_rx *rx) +static struct netdev_rxq_dummy * +netdev_rxq_dummy_cast(const struct netdev_rxq *rx) { - netdev_rx_assert_class(rx, &netdev_rx_dummy_class); - return CONTAINER_OF(rx, struct netdev_rx_dummy, up); + ovs_assert(is_dummy_class(netdev_get_class(rx->netdev))); + return CONTAINER_OF(rx, struct netdev_rxq_dummy, up); } static void -netdev_dummy_run(void) +dummy_packet_stream_init(struct dummy_packet_stream *s, struct stream *stream) { - struct shash_node *node; + int rxbuf_size = stream ? 2048 : 0; + s->stream = stream; + ofpbuf_init(&s->rxbuf, rxbuf_size); + list_init(&s->txq); +} - SHASH_FOR_EACH (node, &dummy_netdevs) { - struct netdev_dummy *dev = node->data; - size_t i; +static struct dummy_packet_stream * +dummy_packet_stream_create(struct stream *stream) +{ + struct dummy_packet_stream *s; - if (dev->pstream) { - struct stream *new_stream; - int error; + s = xzalloc(sizeof *s); + dummy_packet_stream_init(s, stream); - error = pstream_accept(dev->pstream, &new_stream); - if (!error) { - struct dummy_stream *s; - - dev->streams = xrealloc(dev->streams, - ((dev->n_streams + 1) - * sizeof *dev->streams)); - s = &dev->streams[dev->n_streams++]; - s->stream = new_stream; - ofpbuf_init(&s->rxbuf, 2048); - list_init(&s->txq); - } else if (error != EAGAIN) { - VLOG_WARN("%s: accept failed (%s)", - pstream_get_name(dev->pstream), ovs_strerror(error)); - pstream_close(dev->pstream); - dev->pstream = NULL; - } - } + return s; +} - for (i = 0; i < dev->n_streams; i++) { - struct dummy_stream *s = &dev->streams[i]; - int error = 0; - size_t n; - - stream_run(s->stream); - - if (!list_is_empty(&s->txq)) { - struct ofpbuf *txbuf; - int retval; - - txbuf = ofpbuf_from_list(list_front(&s->txq)); - retval = stream_send(s->stream, txbuf->data, txbuf->size); - if (retval > 0) { - ofpbuf_pull(txbuf, retval); - if (!txbuf->size) { - list_remove(&txbuf->list_node); - ofpbuf_delete(txbuf); - } - } else if (retval != -EAGAIN) { - error = -retval; - } - } +static void +dummy_packet_stream_wait(struct dummy_packet_stream *s) +{ + stream_run_wait(s->stream); + if (!list_is_empty(&s->txq)) { + stream_send_wait(s->stream); + } + stream_recv_wait(s->stream); +} - if (!error) { - if (s->rxbuf.size < 2) { - n = 2 - s->rxbuf.size; - } else { - uint16_t frame_len; - - frame_len = ntohs(get_unaligned_be16(s->rxbuf.data)); - if (frame_len < ETH_HEADER_LEN) { - error = EPROTO; - n = 0; - } else { - n = (2 + frame_len) - s->rxbuf.size; - } - } - } - if (!error) { - int retval; - - ofpbuf_prealloc_tailroom(&s->rxbuf, n); - retval = stream_recv(s->stream, ofpbuf_tail(&s->rxbuf), n); - if (retval > 0) { - s->rxbuf.size += retval; - if (retval == n && s->rxbuf.size > 2) { - ofpbuf_pull(&s->rxbuf, 2); - netdev_dummy_queue_packet(dev, - ofpbuf_clone(&s->rxbuf)); - ofpbuf_clear(&s->rxbuf); - } - } else if (retval != -EAGAIN) { - error = (retval < 0 ? -retval - : s->rxbuf.size ? EPROTO - : EOF); - } +static void +dummy_packet_stream_send(struct dummy_packet_stream *s, const void *buffer, size_t size) +{ + if (list_size(&s->txq) < NETDEV_DUMMY_MAX_QUEUE) { + struct ofpbuf *b; + + b = ofpbuf_clone_data_with_headroom(buffer, size, 2); + put_unaligned_be16(ofpbuf_push_uninit(b, 2), htons(size)); + list_push_back(&s->txq, &b->list_node); + } +} + +static int +dummy_packet_stream_run(struct netdev_dummy *dev, struct dummy_packet_stream *s) +{ + int error = 0; + size_t n; + + stream_run(s->stream); + + if (!list_is_empty(&s->txq)) { + struct ofpbuf *txbuf; + int retval; + + txbuf = ofpbuf_from_list(list_front(&s->txq)); + retval = stream_send(s->stream, ofpbuf_data(txbuf), ofpbuf_size(txbuf)); + + if (retval > 0) { + ofpbuf_pull(txbuf, retval); + if (!ofpbuf_size(txbuf)) { + list_remove(&txbuf->list_node); + ofpbuf_delete(txbuf); } + } else if (retval != -EAGAIN) { + error = -retval; + } + } - if (error) { - VLOG_DBG("%s: closing connection (%s)", - stream_get_name(s->stream), - ovs_retval_to_string(error)); - dummy_stream_close(&dev->streams[i]); - dev->streams[i] = dev->streams[--dev->n_streams]; + if (!error) { + if (ofpbuf_size(&s->rxbuf) < 2) { + n = 2 - ofpbuf_size(&s->rxbuf); + } else { + uint16_t frame_len; + + frame_len = ntohs(get_unaligned_be16(ofpbuf_data(&s->rxbuf))); + if (frame_len < ETH_HEADER_LEN) { + error = EPROTO; + n = 0; + } else { + n = (2 + frame_len) - ofpbuf_size(&s->rxbuf); + } + } + } + if (!error) { + int retval; + + ofpbuf_prealloc_tailroom(&s->rxbuf, n); + retval = stream_recv(s->stream, ofpbuf_tail(&s->rxbuf), n); + + if (retval > 0) { + ofpbuf_set_size(&s->rxbuf, ofpbuf_size(&s->rxbuf) + retval); + if (retval == n && ofpbuf_size(&s->rxbuf) > 2) { + ofpbuf_pull(&s->rxbuf, 2); + netdev_dummy_queue_packet(dev, + ofpbuf_clone(&s->rxbuf)); + ofpbuf_clear(&s->rxbuf); } + } else if (retval != -EAGAIN) { + error = (retval < 0 ? -retval + : ofpbuf_size(&s->rxbuf) ? EPROTO + : EOF); } } + + return error; } static void -dummy_stream_close(struct dummy_stream *s) +dummy_packet_stream_close(struct dummy_packet_stream *s) { stream_close(s->stream); ofpbuf_uninit(&s->rxbuf); @@ -214,40 +257,356 @@ dummy_stream_close(struct dummy_stream *s) } static void -netdev_dummy_wait(void) +dummy_packet_conn_init(struct dummy_packet_conn *conn) +{ + memset(conn, 0, sizeof *conn); + conn->type = NONE; +} + +static void +dummy_packet_conn_get_config(struct dummy_packet_conn *conn, struct smap *args) +{ + + switch (conn->type) { + case PASSIVE: + smap_add(args, "pstream", pstream_get_name(conn->u.pconn.pstream)); + break; + + case ACTIVE: + smap_add(args, "stream", stream_get_name(conn->u.rconn.rstream->stream)); + break; + + case NONE: + default: + break; + } +} + +static void +dummy_packet_conn_close(struct dummy_packet_conn *conn) { - struct shash_node *node; + int i; + struct dummy_packet_pconn *pconn = &conn->u.pconn; + struct dummy_packet_rconn *rconn = &conn->u.rconn; + + switch (conn->type) { + case PASSIVE: + pstream_close(pconn->pstream); + for (i = 0; i < pconn->n_streams; i++) { + dummy_packet_stream_close(&pconn->streams[i]); + } + free(pconn->streams); + pconn->pstream = NULL; + pconn->streams = NULL; + break; + + case ACTIVE: + dummy_packet_stream_close(rconn->rstream); + free(rconn->rstream); + rconn->rstream = NULL; + reconnect_destroy(rconn->reconnect); + rconn->reconnect = NULL; + break; + + case NONE: + default: + break; + } + + conn->type = NONE; + memset(conn, 0, sizeof *conn); +} + +static void +dummy_packet_conn_set_config(struct dummy_packet_conn *conn, + const struct smap *args) +{ + const char *pstream = smap_get(args, "pstream"); + const char *stream = smap_get(args, "stream"); + + if (pstream && stream) { + VLOG_WARN("Open failed: both %s and %s are configured", + pstream, stream); + return; + } + + switch (conn->type) { + case PASSIVE: + if (!strcmp(pstream_get_name(conn->u.pconn.pstream), pstream)) { + return; + } + dummy_packet_conn_close(conn); + break; + case ACTIVE: + if (!strcmp(stream_get_name(conn->u.rconn.rstream->stream), stream)) { + return; + } + dummy_packet_conn_close(conn); + break; + case NONE: + default: + break; + } + + if (pstream) { + int error; + + error = pstream_open(pstream, &conn->u.pconn.pstream, DSCP_DEFAULT); + if (error) { + VLOG_WARN("%s: open failed (%s)", pstream, ovs_strerror(error)); + } else { + conn->type = PASSIVE; + } + } + + if (stream) { + int error; + struct stream *active_stream; + struct reconnect *reconnect;; + + reconnect = reconnect_create(time_msec()); + reconnect_set_name(reconnect, stream); + reconnect_set_passive(reconnect, false, time_msec()); + reconnect_enable(reconnect, time_msec()); + reconnect_set_backoff(reconnect, 100, INT_MAX); + reconnect_set_probe_interval(reconnect, 0); + conn->u.rconn.reconnect = reconnect; + conn->type = ACTIVE; + + error = stream_open(stream, &active_stream, DSCP_DEFAULT); + conn->u.rconn.rstream = dummy_packet_stream_create(active_stream); + + switch (error) { + case 0: + reconnect_connected(reconnect, time_msec()); + break; + + case EAGAIN: + reconnect_connecting(reconnect, time_msec()); + break; + + default: + reconnect_connect_failed(reconnect, time_msec(), error); + stream_close(active_stream); + conn->u.rconn.rstream->stream = NULL; + break; + } + } +} + +static void +dummy_pconn_run(struct netdev_dummy *dev) + OVS_REQUIRES(dev->mutex) +{ + struct stream *new_stream; + struct dummy_packet_pconn *pconn = &dev->conn.u.pconn; + int error; + size_t i; + + error = pstream_accept(pconn->pstream, &new_stream); + if (!error) { + struct dummy_packet_stream *s; + + pconn->streams = xrealloc(pconn->streams, + ((pconn->n_streams + 1) + * sizeof *s)); + s = &pconn->streams[pconn->n_streams++]; + dummy_packet_stream_init(s, new_stream); + } else if (error != EAGAIN) { + VLOG_WARN("%s: accept failed (%s)", + pstream_get_name(pconn->pstream), ovs_strerror(error)); + pstream_close(pconn->pstream); + pconn->pstream = NULL; + dev->conn.type = NONE; + } - SHASH_FOR_EACH (node, &dummy_netdevs) { - struct netdev_dummy *dev = node->data; - size_t i; + for (i = 0; i < pconn->n_streams; i++) { + struct dummy_packet_stream *s = &pconn->streams[i]; - if (dev->pstream) { - pstream_wait(dev->pstream); + error = dummy_packet_stream_run(dev, s); + if (error) { + VLOG_DBG("%s: closing connection (%s)", + stream_get_name(s->stream), + ovs_retval_to_string(error)); + dummy_packet_stream_close(s); + pconn->streams[i] = pconn->streams[--pconn->n_streams]; } - for (i = 0; i < dev->n_streams; i++) { - struct dummy_stream *s = &dev->streams[i]; + } +} - stream_run_wait(s->stream); - if (!list_is_empty(&s->txq)) { - stream_send_wait(s->stream); +static void +dummy_rconn_run(struct netdev_dummy *dev) +OVS_REQUIRES(dev->mutex) +{ + struct dummy_packet_rconn *rconn = &dev->conn.u.rconn; + + switch (reconnect_run(rconn->reconnect, time_msec())) { + case RECONNECT_CONNECT: + { + int error; + + if (rconn->rstream->stream) { + error = stream_connect(rconn->rstream->stream); + } else { + error = stream_open(reconnect_get_name(rconn->reconnect), + &rconn->rstream->stream, DSCP_DEFAULT); + } + + switch (error) { + case 0: + reconnect_connected(rconn->reconnect, time_msec()); + break; + + case EAGAIN: + reconnect_connecting(rconn->reconnect, time_msec()); + break; + + default: + reconnect_connect_failed(rconn->reconnect, time_msec(), error); + stream_close(rconn->rstream->stream); + rconn->rstream->stream = NULL; + break; } - stream_recv_wait(s->stream); } + break; + + case RECONNECT_DISCONNECT: + case RECONNECT_PROBE: + default: + break; + } + + if (reconnect_is_connected(rconn->reconnect)) { + int err; + + err = dummy_packet_stream_run(dev, rconn->rstream); + + if (err) { + reconnect_disconnected(rconn->reconnect, time_msec(), err); + stream_close(rconn->rstream->stream); + rconn->rstream->stream = NULL; + } + } +} + +static void +dummy_packet_conn_run(struct netdev_dummy *dev) + OVS_REQUIRES(dev->mutex) +{ + switch (dev->conn.type) { + case PASSIVE: + dummy_pconn_run(dev); + break; + + case ACTIVE: + dummy_rconn_run(dev); + break; + + case NONE: + default: + break; + } +} + +static void +dummy_packet_conn_wait(struct dummy_packet_conn *conn) +{ + int i; + switch (conn->type) { + case PASSIVE: + pstream_wait(conn->u.pconn.pstream); + for (i = 0; i < conn->u.pconn.n_streams; i++) { + struct dummy_packet_stream *s = &conn->u.pconn.streams[i]; + dummy_packet_stream_wait(s); + } + break; + case ACTIVE: + if (reconnect_is_connected(conn->u.rconn.reconnect)) { + dummy_packet_stream_wait(conn->u.rconn.rstream); + } + break; + + case NONE: + default: + break; } } +static void +dummy_packet_conn_send(struct dummy_packet_conn *conn, + const void *buffer, size_t size) +{ + int i; + + switch (conn->type) { + case PASSIVE: + for (i = 0; i < conn->u.pconn.n_streams; i++) { + struct dummy_packet_stream *s = &conn->u.pconn.streams[i]; + + dummy_packet_stream_send(s, buffer, size); + pstream_wait(conn->u.pconn.pstream); + } + break; + + case ACTIVE: + if (reconnect_is_connected(conn->u.rconn.reconnect)) { + dummy_packet_stream_send(conn->u.rconn.rstream, buffer, size); + dummy_packet_stream_wait(conn->u.rconn.rstream); + } + break; + + case NONE: + default: + break; + } +} + +static void +netdev_dummy_run(void) +{ + struct netdev_dummy *dev; + + ovs_mutex_lock(&dummy_list_mutex); + LIST_FOR_EACH (dev, list_node, &dummy_list) { + ovs_mutex_lock(&dev->mutex); + dummy_packet_conn_run(dev); + ovs_mutex_unlock(&dev->mutex); + } + ovs_mutex_unlock(&dummy_list_mutex); +} + +static void +netdev_dummy_wait(void) +{ + struct netdev_dummy *dev; + + ovs_mutex_lock(&dummy_list_mutex); + LIST_FOR_EACH (dev, list_node, &dummy_list) { + ovs_mutex_lock(&dev->mutex); + dummy_packet_conn_wait(&dev->conn); + ovs_mutex_unlock(&dev->mutex); + } + ovs_mutex_unlock(&dummy_list_mutex); +} + +static struct netdev * +netdev_dummy_alloc(void) +{ + struct netdev_dummy *netdev = xzalloc(sizeof *netdev); + return &netdev->up; +} + static int -netdev_dummy_create(const struct netdev_class *class, const char *name, - struct netdev **netdevp) +netdev_dummy_construct(struct netdev *netdev_) { static atomic_uint next_n = ATOMIC_VAR_INIT(0xaa550000); - struct netdev_dummy *netdev; + struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); unsigned int n; atomic_add(&next_n, 1, &n); - netdev = xzalloc(sizeof *netdev); - netdev_init(&netdev->up, name, class); + + ovs_mutex_init(&netdev->mutex); + ovs_mutex_lock(&netdev->mutex); netdev->hwaddr[0] = 0xaa; netdev->hwaddr[1] = 0x55; netdev->hwaddr[2] = n >> 24; @@ -256,35 +615,42 @@ netdev_dummy_create(const struct netdev_class *class, const char *name, netdev->hwaddr[5] = n; netdev->mtu = 1500; netdev->flags = 0; - netdev->change_seq = 1; netdev->ifindex = -EOPNOTSUPP; - netdev->pstream = NULL; - netdev->streams = NULL; - netdev->n_streams = 0; + dummy_packet_conn_init(&netdev->conn); list_init(&netdev->rxes); + ovs_mutex_unlock(&netdev->mutex); - shash_add(&dummy_netdevs, name, netdev); - - *netdevp = &netdev->up; + ovs_mutex_lock(&dummy_list_mutex); + list_push_back(&dummy_list, &netdev->list_node); + ovs_mutex_unlock(&dummy_list_mutex); return 0; } static void -netdev_dummy_destroy(struct netdev *netdev_) +netdev_dummy_destruct(struct netdev *netdev_) +{ + struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); + + ovs_mutex_lock(&dummy_list_mutex); + list_remove(&netdev->list_node); + ovs_mutex_unlock(&dummy_list_mutex); + + ovs_mutex_lock(&netdev->mutex); + dummy_packet_conn_close(&netdev->conn); + netdev->conn.type = NONE; + + ovs_mutex_unlock(&netdev->mutex); + ovs_mutex_destroy(&netdev->mutex); +} + +static void +netdev_dummy_dealloc(struct netdev *netdev_) { struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); - size_t i; - shash_find_and_delete(&dummy_netdevs, - netdev_get_name(netdev_)); - pstream_close(netdev->pstream); - for (i = 0; i < netdev->n_streams; i++) { - dummy_stream_close(&netdev->streams[i]); - } - free(netdev->streams); free(netdev); } @@ -293,12 +659,15 @@ netdev_dummy_get_config(const struct netdev *netdev_, struct smap *args) { struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); + ovs_mutex_lock(&netdev->mutex); + if (netdev->ifindex >= 0) { smap_add_format(args, "ifindex", "%d", netdev->ifindex); } - if (netdev->pstream) { - smap_add(args, "pstream", pstream_get_name(netdev->pstream)); - } + + dummy_packet_conn_get_config(&netdev->conn, args); + + ovs_mutex_unlock(&netdev->mutex); return 0; } @@ -306,102 +675,152 @@ static int netdev_dummy_set_config(struct netdev *netdev_, const struct smap *args) { struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); - const char *pstream; + const char *pcap; + ovs_mutex_lock(&netdev->mutex); netdev->ifindex = smap_get_int(args, "ifindex", -EOPNOTSUPP); - pstream = smap_get(args, "pstream"); - if (!pstream - || !netdev->pstream - || strcmp(pstream_get_name(netdev->pstream), pstream)) { - pstream_close(netdev->pstream); - netdev->pstream = NULL; + dummy_packet_conn_set_config(&netdev->conn, args); - if (pstream) { - int error; + if (netdev->rxq_pcap) { + fclose(netdev->rxq_pcap); + } + if (netdev->tx_pcap && netdev->tx_pcap != netdev->rxq_pcap) { + fclose(netdev->tx_pcap); + } + netdev->rxq_pcap = netdev->tx_pcap = NULL; + pcap = smap_get(args, "pcap"); + if (pcap) { + netdev->rxq_pcap = netdev->tx_pcap = ovs_pcap_open(pcap, "ab"); + } else { + const char *rxq_pcap = smap_get(args, "rxq_pcap"); + const char *tx_pcap = smap_get(args, "tx_pcap"); - error = pstream_open(pstream, &netdev->pstream, DSCP_DEFAULT); - if (error) { - VLOG_WARN("%s: open failed (%s)", - pstream, ovs_strerror(error)); - } + if (rxq_pcap) { + netdev->rxq_pcap = ovs_pcap_open(rxq_pcap, "ab"); + } + if (tx_pcap) { + netdev->tx_pcap = ovs_pcap_open(tx_pcap, "ab"); } } + + ovs_mutex_unlock(&netdev->mutex); + return 0; } +static struct netdev_rxq * +netdev_dummy_rxq_alloc(void) +{ + struct netdev_rxq_dummy *rx = xzalloc(sizeof *rx); + return &rx->up; +} + static int -netdev_dummy_rx_open(struct netdev *netdev_, struct netdev_rx **rxp) +netdev_dummy_rxq_construct(struct netdev_rxq *rxq_) { - struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); - struct netdev_rx_dummy *rx; + struct netdev_rxq_dummy *rx = netdev_rxq_dummy_cast(rxq_); + struct netdev_dummy *netdev = netdev_dummy_cast(rx->up.netdev); - rx = xmalloc(sizeof *rx); - netdev_rx_init(&rx->up, &netdev->up, &netdev_rx_dummy_class); + ovs_mutex_lock(&netdev->mutex); list_push_back(&netdev->rxes, &rx->node); list_init(&rx->recv_queue); rx->recv_queue_len = 0; + rx->seq = seq_create(); + ovs_mutex_unlock(&netdev->mutex); - *rxp = &rx->up; return 0; } +static void +netdev_dummy_rxq_destruct(struct netdev_rxq *rxq_) +{ + struct netdev_rxq_dummy *rx = netdev_rxq_dummy_cast(rxq_); + struct netdev_dummy *netdev = netdev_dummy_cast(rx->up.netdev); + + ovs_mutex_lock(&netdev->mutex); + list_remove(&rx->node); + ofpbuf_list_delete(&rx->recv_queue); + ovs_mutex_unlock(&netdev->mutex); + seq_destroy(rx->seq); +} + +static void +netdev_dummy_rxq_dealloc(struct netdev_rxq *rxq_) +{ + struct netdev_rxq_dummy *rx = netdev_rxq_dummy_cast(rxq_); + + free(rx); +} + static int -netdev_rx_dummy_recv(struct netdev_rx *rx_, void *buffer, size_t size) +netdev_dummy_rxq_recv(struct netdev_rxq *rxq_, struct ofpbuf **arr, int *c) { - struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_); + struct netdev_rxq_dummy *rx = netdev_rxq_dummy_cast(rxq_); + struct netdev_dummy *netdev = netdev_dummy_cast(rx->up.netdev); struct ofpbuf *packet; - size_t packet_size; - if (list_is_empty(&rx->recv_queue)) { - return -EAGAIN; + ovs_mutex_lock(&netdev->mutex); + if (!list_is_empty(&rx->recv_queue)) { + packet = ofpbuf_from_list(list_pop_front(&rx->recv_queue)); + rx->recv_queue_len--; + } else { + packet = NULL; } + ovs_mutex_unlock(&netdev->mutex); - packet = ofpbuf_from_list(list_pop_front(&rx->recv_queue)); - rx->recv_queue_len--; - if (packet->size > size) { - return -EMSGSIZE; + if (!packet) { + return EAGAIN; } - packet_size = packet->size; - - memcpy(buffer, packet->data, packet->size); - ofpbuf_delete(packet); - - return packet_size; + ovs_mutex_lock(&netdev->mutex); + netdev->stats.rx_packets++; + netdev->stats.rx_bytes += ofpbuf_size(packet); + ovs_mutex_unlock(&netdev->mutex); + + dp_packet_pad(packet); + arr[0] = packet; + *c = 1; + return 0; } static void -netdev_rx_dummy_destroy(struct netdev_rx *rx_) +netdev_dummy_rxq_wait(struct netdev_rxq *rxq_) { - struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_); - list_remove(&rx->node); - ofpbuf_list_delete(&rx->recv_queue); - free(rx); -} + struct netdev_rxq_dummy *rx = netdev_rxq_dummy_cast(rxq_); + struct netdev_dummy *netdev = netdev_dummy_cast(rx->up.netdev); + uint64_t seq = seq_read(rx->seq); -static void -netdev_rx_dummy_wait(struct netdev_rx *rx_) -{ - struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_); + ovs_mutex_lock(&netdev->mutex); if (!list_is_empty(&rx->recv_queue)) { poll_immediate_wake(); + } else { + seq_wait(rx->seq, seq); } + ovs_mutex_unlock(&netdev->mutex); } static int -netdev_rx_dummy_drain(struct netdev_rx *rx_) +netdev_dummy_rxq_drain(struct netdev_rxq *rxq_) { - struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_); + struct netdev_rxq_dummy *rx = netdev_rxq_dummy_cast(rxq_); + struct netdev_dummy *netdev = netdev_dummy_cast(rx->up.netdev); + + ovs_mutex_lock(&netdev->mutex); ofpbuf_list_delete(&rx->recv_queue); rx->recv_queue_len = 0; + ovs_mutex_unlock(&netdev->mutex); + + seq_change(rx->seq); + return 0; } static int -netdev_dummy_send(struct netdev *netdev, const void *buffer, size_t size) +netdev_dummy_send(struct netdev *netdev, struct ofpbuf *pkt, bool may_steal) { struct netdev_dummy *dev = netdev_dummy_cast(netdev); - size_t i; + const void *buffer = ofpbuf_data(pkt); + size_t size = ofpbuf_size(pkt); if (size < ETH_HEADER_LEN) { return EMSGSIZE; @@ -409,7 +828,10 @@ netdev_dummy_send(struct netdev *netdev, const void *buffer, size_t size) const struct eth_header *eth = buffer; int max_size; + ovs_mutex_lock(&dev->mutex); max_size = dev->mtu + ETH_HEADER_LEN; + ovs_mutex_unlock(&dev->mutex); + if (eth->eth_type == htons(ETH_TYPE_VLAN)) { max_size += VLAN_HEADER_LEN; } @@ -418,19 +840,23 @@ netdev_dummy_send(struct netdev *netdev, const void *buffer, size_t size) } } + ovs_mutex_lock(&dev->mutex); dev->stats.tx_packets++; dev->stats.tx_bytes += size; - for (i = 0; i < dev->n_streams; i++) { - struct dummy_stream *s = &dev->streams[i]; + dummy_packet_conn_send(&dev->conn, buffer, size); - if (list_size(&s->txq) < NETDEV_DUMMY_MAX_QUEUE) { - struct ofpbuf *b; + if (dev->tx_pcap) { + struct ofpbuf packet; - b = ofpbuf_clone_data_with_headroom(buffer, size, 2); - put_unaligned_be16(ofpbuf_push_uninit(b, 2), htons(size)); - list_push_back(&s->txq, &b->list_node); - } + ofpbuf_use_const(&packet, buffer, size); + ovs_pcap_write(dev->tx_pcap, &packet); + fflush(dev->tx_pcap); + } + + ovs_mutex_unlock(&dev->mutex); + if (may_steal) { + ofpbuf_delete(pkt); } return 0; @@ -442,10 +868,12 @@ netdev_dummy_set_etheraddr(struct netdev *netdev, { struct netdev_dummy *dev = netdev_dummy_cast(netdev); + ovs_mutex_lock(&dev->mutex); if (!eth_addr_equals(dev->hwaddr, mac)) { memcpy(dev->hwaddr, mac, ETH_ADDR_LEN); - netdev_dummy_poll_notify(dev); + netdev_change_seq_changed(netdev); } + ovs_mutex_unlock(&dev->mutex); return 0; } @@ -454,18 +882,24 @@ static int netdev_dummy_get_etheraddr(const struct netdev *netdev, uint8_t mac[ETH_ADDR_LEN]) { - const struct netdev_dummy *dev = netdev_dummy_cast(netdev); + struct netdev_dummy *dev = netdev_dummy_cast(netdev); + ovs_mutex_lock(&dev->mutex); memcpy(mac, dev->hwaddr, ETH_ADDR_LEN); + ovs_mutex_unlock(&dev->mutex); + return 0; } static int netdev_dummy_get_mtu(const struct netdev *netdev, int *mtup) { - const struct netdev_dummy *dev = netdev_dummy_cast(netdev); + struct netdev_dummy *dev = netdev_dummy_cast(netdev); + ovs_mutex_lock(&dev->mutex); *mtup = dev->mtu; + ovs_mutex_unlock(&dev->mutex); + return 0; } @@ -474,16 +908,22 @@ netdev_dummy_set_mtu(const struct netdev *netdev, int mtu) { struct netdev_dummy *dev = netdev_dummy_cast(netdev); + ovs_mutex_lock(&dev->mutex); dev->mtu = mtu; + ovs_mutex_unlock(&dev->mutex); + return 0; } static int netdev_dummy_get_stats(const struct netdev *netdev, struct netdev_stats *stats) { - const struct netdev_dummy *dev = netdev_dummy_cast(netdev); + struct netdev_dummy *dev = netdev_dummy_cast(netdev); + ovs_mutex_lock(&dev->mutex); *stats = dev->stats; + ovs_mutex_unlock(&dev->mutex); + return 0; } @@ -492,7 +932,10 @@ netdev_dummy_set_stats(struct netdev *netdev, const struct netdev_stats *stats) { struct netdev_dummy *dev = netdev_dummy_cast(netdev); + ovs_mutex_lock(&dev->mutex); dev->stats = *stats; + ovs_mutex_unlock(&dev->mutex); + return 0; } @@ -500,17 +943,21 @@ static int netdev_dummy_get_ifindex(const struct netdev *netdev) { struct netdev_dummy *dev = netdev_dummy_cast(netdev); + int ifindex; + + ovs_mutex_lock(&dev->mutex); + ifindex = dev->ifindex; + ovs_mutex_unlock(&dev->mutex); - return dev->ifindex; + return ifindex; } static int -netdev_dummy_update_flags(struct netdev *netdev_, - enum netdev_flags off, enum netdev_flags on, - enum netdev_flags *old_flagsp) +netdev_dummy_update_flags__(struct netdev_dummy *netdev, + enum netdev_flags off, enum netdev_flags on, + enum netdev_flags *old_flagsp) + OVS_REQUIRES(netdev->mutex) { - struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); - if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) { return EINVAL; } @@ -519,42 +966,43 @@ netdev_dummy_update_flags(struct netdev *netdev_, netdev->flags |= on; netdev->flags &= ~off; if (*old_flagsp != netdev->flags) { - netdev_dummy_poll_notify(netdev); + netdev_change_seq_changed(&netdev->up); } + return 0; } -static unsigned int -netdev_dummy_change_seq(const struct netdev *netdev) +static int +netdev_dummy_update_flags(struct netdev *netdev_, + enum netdev_flags off, enum netdev_flags on, + enum netdev_flags *old_flagsp) { - return netdev_dummy_cast(netdev)->change_seq; + struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); + int error; + + ovs_mutex_lock(&netdev->mutex); + error = netdev_dummy_update_flags__(netdev, off, on, old_flagsp); + ovs_mutex_unlock(&netdev->mutex); + + return error; } /* Helper functions. */ -static void -netdev_dummy_poll_notify(struct netdev_dummy *dev) -{ - dev->change_seq++; - if (!dev->change_seq) { - dev->change_seq++; - } -} - static const struct netdev_class dummy_class = { "dummy", NULL, /* init */ netdev_dummy_run, netdev_dummy_wait, - netdev_dummy_create, - netdev_dummy_destroy, + netdev_dummy_alloc, + netdev_dummy_construct, + netdev_dummy_destruct, + netdev_dummy_dealloc, netdev_dummy_get_config, netdev_dummy_set_config, NULL, /* get_tunnel_config */ - netdev_dummy_rx_open, - netdev_dummy_send, /* send */ NULL, /* send_wait */ @@ -581,7 +1029,9 @@ static const struct netdev_class dummy_class = { NULL, /* set_queue */ NULL, /* delete_queue */ NULL, /* get_queue_stats */ - NULL, /* dump_queues */ + NULL, /* queue_dump_start */ + NULL, /* queue_dump_next */ + NULL, /* queue_dump_done */ NULL, /* dump_queue_stats */ NULL, /* get_in4 */ @@ -594,14 +1044,13 @@ static const struct netdev_class dummy_class = { netdev_dummy_update_flags, - netdev_dummy_change_seq -}; - -static const struct netdev_rx_class netdev_rx_dummy_class = { - netdev_rx_dummy_destroy, - netdev_rx_dummy_recv, - netdev_rx_dummy_wait, - netdev_rx_dummy_drain, + netdev_dummy_rxq_alloc, + netdev_dummy_rxq_construct, + netdev_dummy_rxq_destruct, + netdev_dummy_rxq_dealloc, + netdev_dummy_rxq_recv, + netdev_dummy_rxq_wait, + netdev_dummy_rxq_drain, }; static struct ofpbuf * @@ -631,7 +1080,7 @@ eth_from_packet_or_flow(const char *s) } /* Convert odp_key to flow. */ - fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow); + fitness = odp_flow_key_to_flow(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key), &flow); if (fitness == ODP_FIT_ERROR) { ofpbuf_uninit(&odp_key); return NULL; @@ -645,17 +1094,23 @@ eth_from_packet_or_flow(const char *s) } static void -netdev_dummy_queue_packet__(struct netdev_rx_dummy *rx, struct ofpbuf *packet) +netdev_dummy_queue_packet__(struct netdev_rxq_dummy *rx, struct ofpbuf *packet) { list_push_back(&rx->recv_queue, &packet->list_node); rx->recv_queue_len++; + seq_change(rx->seq); } static void netdev_dummy_queue_packet(struct netdev_dummy *dummy, struct ofpbuf *packet) + OVS_REQUIRES(dummy->mutex) { - struct netdev_rx_dummy *rx, *prev; + struct netdev_rxq_dummy *rx, *prev; + if (dummy->rxq_pcap) { + ovs_pcap_write(dummy->rxq_pcap, packet); + fflush(dummy->rxq_pcap); + } prev = NULL; LIST_FOR_EACH (rx, node, &dummy->rxes) { if (rx->recv_queue_len < NETDEV_DUMMY_MAX_QUEUE) { @@ -677,13 +1132,15 @@ netdev_dummy_receive(struct unixctl_conn *conn, int argc, const char *argv[], void *aux OVS_UNUSED) { struct netdev_dummy *dummy_dev; + struct netdev *netdev; int i; - dummy_dev = shash_find_data(&dummy_netdevs, argv[1]); - if (!dummy_dev) { + netdev = netdev_from_name(argv[1]); + if (!netdev || !is_dummy_class(netdev->netdev_class)) { unixctl_command_reply_error(conn, "no such dummy netdev"); - return; + goto exit; } + dummy_dev = netdev_dummy_cast(netdev); for (i = 2; i < argc; i++) { struct ofpbuf *packet; @@ -691,27 +1148,30 @@ netdev_dummy_receive(struct unixctl_conn *conn, packet = eth_from_packet_or_flow(argv[i]); if (!packet) { unixctl_command_reply_error(conn, "bad packet syntax"); - return; + goto exit; } - dummy_dev->stats.rx_packets++; - dummy_dev->stats.rx_bytes += packet->size; - + ovs_mutex_lock(&dummy_dev->mutex); netdev_dummy_queue_packet(dummy_dev, packet); + ovs_mutex_unlock(&dummy_dev->mutex); } unixctl_command_reply(conn, NULL); + +exit: + netdev_close(netdev); } static void netdev_dummy_set_admin_state__(struct netdev_dummy *dev, bool admin_state) + OVS_REQUIRES(dev->mutex) { enum netdev_flags old_flags; if (admin_state) { - netdev_dummy_update_flags(&dev->up, 0, NETDEV_UP, &old_flags); + netdev_dummy_update_flags__(dev, 0, NETDEV_UP, &old_flags); } else { - netdev_dummy_update_flags(&dev->up, NETDEV_UP, 0, &old_flags); + netdev_dummy_update_flags__(dev, NETDEV_UP, 0, &old_flags); } } @@ -731,21 +1191,30 @@ netdev_dummy_set_admin_state(struct unixctl_conn *conn, int argc, } if (argc > 2) { - struct netdev_dummy *dummy_dev; + struct netdev *netdev = netdev_from_name(argv[1]); + if (netdev && is_dummy_class(netdev->netdev_class)) { + struct netdev_dummy *dummy_dev = netdev_dummy_cast(netdev); - dummy_dev = shash_find_data(&dummy_netdevs, argv[1]); - if (dummy_dev) { + ovs_mutex_lock(&dummy_dev->mutex); netdev_dummy_set_admin_state__(dummy_dev, up); + ovs_mutex_unlock(&dummy_dev->mutex); + + netdev_close(netdev); } else { unixctl_command_reply_error(conn, "Unknown Dummy Interface"); + netdev_close(netdev); return; } } else { - struct shash_node *node; + struct netdev_dummy *netdev; - SHASH_FOR_EACH (node, &dummy_netdevs) { - netdev_dummy_set_admin_state__(node->data, up); + ovs_mutex_lock(&dummy_list_mutex); + LIST_FOR_EACH (netdev, list_node, &dummy_list) { + ovs_mutex_lock(&netdev->mutex); + netdev_dummy_set_admin_state__(netdev, up); + ovs_mutex_unlock(&netdev->mutex); } + ovs_mutex_unlock(&dummy_list_mutex); } unixctl_command_reply(conn, "OK"); } @@ -766,13 +1235,22 @@ netdev_dummy_register(bool override) sset_init(&types); netdev_enumerate_types(&types); SSET_FOR_EACH (type, &types) { + if (!strcmp(type, "patch")) { + continue; + } if (!netdev_unregister_provider(type)) { struct netdev_class *class; + int error; - class = xmalloc(sizeof *class); - *class = dummy_class; + class = xmemdup(&dummy_class, sizeof dummy_class); class->type = xstrdup(type); - netdev_register_provider(class); + error = netdev_register_provider(class); + if (error) { + VLOG_ERR("%s: failed to register netdev provider (%s)", + type, ovs_strerror(error)); + free(CONST_CAST(char *, class->type)); + free(class); + } } } sset_destroy(&types);