From eab5611a383faf58728657252751f075c511072e Mon Sep 17 00:00:00 2001 From: Ben Pfaff Date: Thu, 25 Oct 2012 16:54:23 -0700 Subject: [PATCH] netdev-dummy: Add "pstream" option for connecting a dummy to a process. Signed-off-by: Ben Pfaff --- lib/netdev-dummy.c | 244 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 232 insertions(+), 12 deletions(-) diff --git a/lib/netdev-dummy.c b/lib/netdev-dummy.c index 58a4535ed..3e2187e3f 100644 --- a/lib/netdev-dummy.c +++ b/lib/netdev-dummy.c @@ -31,11 +31,19 @@ #include "poll-loop.h" #include "shash.h" #include "sset.h" +#include "stream.h" +#include "unaligned.h" #include "unixctl.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(netdev_dummy); +struct dummy_stream { + struct stream *stream; + struct ofpbuf rxbuf; + struct list txq; +}; + struct netdev_dummy { struct netdev up; uint8_t hwaddr[ETH_ADDR_LEN]; @@ -45,6 +53,10 @@ struct netdev_dummy { unsigned int change_seq; int ifindex; + struct pstream *pstream; + struct dummy_stream *streams; + size_t n_streams; + struct list rxes; /* List of child "netdev_rx_dummy"s. */ }; @@ -67,6 +79,9 @@ 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 void netdev_dummy_queue_packet(struct netdev_dummy *, struct ofpbuf *); + +static void dummy_stream_close(struct dummy_stream *); static bool is_dummy_class(const struct netdev_class *class) @@ -88,6 +103,140 @@ netdev_rx_dummy_cast(const struct netdev_rx *rx) return CONTAINER_OF(rx, struct netdev_rx_dummy, up); } +static void +netdev_dummy_run(void) +{ + struct shash_node *node; + + SHASH_FOR_EACH (node, &dummy_netdevs) { + struct netdev_dummy *dev = node->data; + size_t i; + + if (dev->pstream) { + struct stream *new_stream; + int error; + + 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), strerror(error)); + pstream_close(dev->pstream); + dev->pstream = NULL; + } + } + + 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; + } + } + + 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); + } + } + + 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]; + } + } + } +} + +static void +dummy_stream_close(struct dummy_stream *s) +{ + stream_close(s->stream); + ofpbuf_uninit(&s->rxbuf); + ofpbuf_list_delete(&s->txq); +} + +static void +netdev_dummy_wait(void) +{ + struct shash_node *node; + + SHASH_FOR_EACH (node, &dummy_netdevs) { + struct netdev_dummy *dev = node->data; + size_t i; + + if (dev->pstream) { + pstream_wait(dev->pstream); + } + 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); + } + stream_recv_wait(s->stream); + } + } +} + static int netdev_dummy_create(const struct netdev_class *class, const char *name, struct netdev **netdevp) @@ -107,6 +256,11 @@ netdev_dummy_create(const struct netdev_class *class, const char *name, netdev->flags = 0; netdev->change_seq = 1; netdev->ifindex = -EOPNOTSUPP; + + netdev->pstream = NULL; + netdev->streams = NULL; + netdev->n_streams = 0; + list_init(&netdev->rxes); shash_add(&dummy_netdevs, name, netdev); @@ -122,9 +276,15 @@ static void netdev_dummy_destroy(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); } @@ -136,6 +296,9 @@ netdev_dummy_get_config(const struct netdev *netdev_, struct smap *args) if (netdev->ifindex >= 0) { smap_add_format(args, "ifindex", "%d", netdev->ifindex); } + if (netdev->pstream) { + smap_add(args, "pstream", pstream_get_name(netdev->pstream)); + } return 0; } @@ -143,8 +306,26 @@ static int netdev_dummy_set_config(struct netdev *netdev_, const struct smap *args) { struct netdev_dummy *netdev = netdev_dummy_cast(netdev_); + const char *pstream; 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; + + if (pstream) { + int error; + + error = pstream_open(pstream, &netdev->pstream, DSCP_DEFAULT); + if (error) { + VLOG_WARN("%s: open failed (%s)", pstream, strerror(error)); + } + } + } return 0; } @@ -216,14 +397,41 @@ netdev_rx_dummy_drain(struct netdev_rx *rx_) } static int -netdev_dummy_send(struct netdev *netdev, const void *buffer OVS_UNUSED, - size_t size) +netdev_dummy_send(struct netdev *netdev, const void *buffer, size_t size) { struct netdev_dummy *dev = netdev_dummy_cast(netdev); + size_t i; + + if (size < ETH_HEADER_LEN) { + return EMSGSIZE; + } else { + const struct eth_header *eth = buffer; + int max_size; + + max_size = dev->mtu + ETH_HEADER_LEN; + if (eth->eth_type == htons(ETH_TYPE_VLAN)) { + max_size += VLAN_HEADER_LEN; + } + if (size > max_size) { + return EMSGSIZE; + } + } dev->stats.tx_packets++; dev->stats.tx_bytes += size; + for (i = 0; i < dev->n_streams; i++) { + struct dummy_stream *s = &dev->streams[i]; + + 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); + } + } + return 0; } @@ -335,8 +543,8 @@ netdev_dummy_poll_notify(struct netdev_dummy *dev) static const struct netdev_class dummy_class = { "dummy", NULL, /* init */ - NULL, /* run */ - NULL, /* wait */ + netdev_dummy_run, + netdev_dummy_wait, netdev_dummy_create, netdev_dummy_destroy, @@ -436,18 +644,31 @@ eth_from_packet_or_flow(const char *s) } static void -netdev_dummy_queue_packet(struct netdev_dummy *dummy, - const void *data, size_t size) +netdev_dummy_queue_packet__(struct netdev_rx_dummy *rx, struct ofpbuf *packet) { - struct netdev_rx_dummy *rx; + list_push_back(&rx->recv_queue, &packet->list_node); + rx->recv_queue_len++; +} +static void +netdev_dummy_queue_packet(struct netdev_dummy *dummy, struct ofpbuf *packet) +{ + struct netdev_rx_dummy *rx, *prev; + + prev = NULL; LIST_FOR_EACH (rx, node, &dummy->rxes) { if (rx->recv_queue_len < NETDEV_DUMMY_MAX_QUEUE) { - struct ofpbuf *copy = ofpbuf_clone_data(data, size); - list_push_back(&rx->recv_queue, ©->list_node); - rx->recv_queue_len++; + if (prev) { + netdev_dummy_queue_packet__(prev, ofpbuf_clone(packet)); + } + prev = rx; } } + if (prev) { + netdev_dummy_queue_packet__(prev, packet); + } else { + ofpbuf_delete(packet); + } } static void @@ -475,8 +696,7 @@ netdev_dummy_receive(struct unixctl_conn *conn, dummy_dev->stats.rx_packets++; dummy_dev->stats.rx_bytes += packet->size; - netdev_dummy_queue_packet(dummy_dev, packet->data, packet->size); - ofpbuf_delete(packet); + netdev_dummy_queue_packet(dummy_dev, packet); } unixctl_command_reply(conn, NULL); -- 2.43.0