LXR qemu/net/hub.c

   1/*
   2 * Hub net client
   3 *
   4 * Copyright IBM, Corp. 2012
   5 *
   6 * Authors:
   7 *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
   8 *  Zhi Yong Wu       <wuzhy@linux.vnet.ibm.com>
   9 *
  10 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  11 * See the COPYING.LIB file in the top-level directory.
  12 *
  13 */
  14
  15#include "qemu/osdep.h"
  16#include "qapi/error.h"
  17#include "monitor/monitor.h"
  18#include "net/net.h"
  19#include "clients.h"
  20#include "hub.h"
  21#include "qemu/iov.h"
  22#include "qemu/error-report.h"
  23#include "sysemu/qtest.h"
  24
  25/*
  26 * A hub broadcasts incoming packets to all its ports except the source port.
  27 * Hubs can be used to provide independent emulated network segments.
  28 */
  29
  30typedef struct NetHub NetHub;
  31
  32typedef struct NetHubPort {
  33    NetClientState nc;
  34    QLIST_ENTRY(NetHubPort) next;
  35    NetHub *hub;
  36    int id;
  37} NetHubPort;
  38
  39struct NetHub {
  40    int id;
  41    QLIST_ENTRY(NetHub) next;
  42    int num_ports;
  43    QLIST_HEAD(, NetHubPort) ports;
  44};
  45
  46static QLIST_HEAD(, NetHub) hubs = QLIST_HEAD_INITIALIZER(&hubs);
  47
  48static ssize_t net_hub_receive(NetHub *hub, NetHubPort *source_port,
  49                               const uint8_t *buf, size_t len)
  50{
  51    NetHubPort *port;
  52
  53    QLIST_FOREACH(port, &hub->ports, next) {
  54        if (port == source_port) {
  55            continue;
  56        }
  57
  58        qemu_send_packet(&port->nc, buf, len);
  59    }
  60    return len;
  61}
  62
  63static ssize_t net_hub_receive_iov(NetHub *hub, NetHubPort *source_port,
  64                                   const struct iovec *iov, int iovcnt)
  65{
  66    NetHubPort *port;
  67    ssize_t len = iov_size(iov, iovcnt);
  68
  69    QLIST_FOREACH(port, &hub->ports, next) {
  70        if (port == source_port) {
  71            continue;
  72        }
  73
  74        qemu_sendv_packet(&port->nc, iov, iovcnt);
  75    }
  76    return len;
  77}
  78
  79static NetHub *net_hub_new(int id)
  80{
  81    NetHub *hub;
  82
  83    hub = g_malloc(sizeof(*hub));
  84    hub->id = id;
  85    hub->num_ports = 0;
  86    QLIST_INIT(&hub->ports);
  87
  88    QLIST_INSERT_HEAD(&hubs, hub, next);
  89
  90    return hub;
  91}
  92
  93static bool net_hub_port_can_receive(NetClientState *nc)
  94{
  95    NetHubPort *port;
  96    NetHubPort *src_port = DO_UPCAST(NetHubPort, nc, nc);
  97    NetHub *hub = src_port->hub;
  98
  99    QLIST_FOREACH(port, &hub->ports, next) {
 100        if (port == src_port) {
 101            continue;
 102        }
 103
 104        if (qemu_can_send_packet(&port->nc)) {
 105            return true;
 106        }
 107    }
 108
 109    return false;
 110}
 111
 112static ssize_t net_hub_port_receive(NetClientState *nc,
 113                                    const uint8_t *buf, size_t len)
 114{
 115    NetHubPort *port = DO_UPCAST(NetHubPort, nc, nc);
 116
 117    return net_hub_receive(port->hub, port, buf, len);
 118}
 119
 120static ssize_t net_hub_port_receive_iov(NetClientState *nc,
 121                                        const struct iovec *iov, int iovcnt)
 122{
 123    NetHubPort *port = DO_UPCAST(NetHubPort, nc, nc);
 124
 125    return net_hub_receive_iov(port->hub, port, iov, iovcnt);
 126}
 127
 128static void net_hub_port_cleanup(NetClientState *nc)
 129{
 130    NetHubPort *port = DO_UPCAST(NetHubPort, nc, nc);
 131
 132    QLIST_REMOVE(port, next);
 133}
 134
 135static NetClientInfo net_hub_port_info = {
 136    .type = NET_CLIENT_DRIVER_HUBPORT,
 137    .size = sizeof(NetHubPort),
 138    .can_receive = net_hub_port_can_receive,
 139    .receive = net_hub_port_receive,
 140    .receive_iov = net_hub_port_receive_iov,
 141    .cleanup = net_hub_port_cleanup,
 142};
 143
 144static NetHubPort *net_hub_port_new(NetHub *hub, const char *name,
 145                                    NetClientState *hubpeer)
 146{
 147    NetClientState *nc;
 148    NetHubPort *port;
 149    int id = hub->num_ports++;
 150    char default_name[128];
 151
 152    if (!name) {
 153        snprintf(default_name, sizeof(default_name),
 154                 "hub%dport%d", hub->id, id);
 155        name = default_name;
 156    }
 157
 158    nc = qemu_new_net_client(&net_hub_port_info, hubpeer, "hub", name);
 159    port = DO_UPCAST(NetHubPort, nc, nc);
 160    port->id = id;
 161    port->hub = hub;
 162
 163    QLIST_INSERT_HEAD(&hub->ports, port, next);
 164
 165    return port;
 166}
 167
 168/**
 169 * Create a port on a given hub
 170 * @hub_id: Number of the hub
 171 * @name: Net client name or NULL for default name.
 172 * @hubpeer: Peer to use (if "netdev=id" has been specified)
 173 *
 174 * If there is no existing hub with the given id then a new hub is created.
 175 */
 176NetClientState *net_hub_add_port(int hub_id, const char *name,
 177                                 NetClientState *hubpeer)
 178{
 179    NetHub *hub;
 180    NetHubPort *port;
 181
 182    QLIST_FOREACH(hub, &hubs, next) {
 183        if (hub->id == hub_id) {
 184            break;
 185        }
 186    }
 187
 188    if (!hub) {
 189        hub = net_hub_new(hub_id);
 190    }
 191
 192    port = net_hub_port_new(hub, name, hubpeer);
 193    return &port->nc;
 194}
 195
 196/**
 197 * Find a available port on a hub; otherwise create one new port
 198 */
 199NetClientState *net_hub_port_find(int hub_id)
 200{
 201    NetHub *hub;
 202    NetHubPort *port;
 203    NetClientState *nc;
 204
 205    QLIST_FOREACH(hub, &hubs, next) {
 206        if (hub->id == hub_id) {
 207            QLIST_FOREACH(port, &hub->ports, next) {
 208                nc = port->nc.peer;
 209                if (!nc) {
 210                    return &(port->nc);
 211                }
 212            }
 213            break;
 214        }
 215    }
 216
 217    nc = net_hub_add_port(hub_id, NULL, NULL);
 218    return nc;
 219}
 220
 221/**
 222 * Print hub configuration
 223 */
 224void net_hub_info(Monitor *mon)
 225{
 226    NetHub *hub;
 227    NetHubPort *port;
 228
 229    QLIST_FOREACH(hub, &hubs, next) {
 230        monitor_printf(mon, "hub %d\n", hub->id);
 231        QLIST_FOREACH(port, &hub->ports, next) {
 232            monitor_printf(mon, " \\ %s", port->nc.name);
 233            if (port->nc.peer) {
 234                monitor_printf(mon, ": ");
 235                print_net_client(mon, port->nc.peer);
 236            } else {
 237                monitor_printf(mon, "\n");
 238            }
 239        }
 240    }
 241}
 242
 243/**
 244 * Get the hub id that a client is connected to
 245 *
 246 * @id: Pointer for hub id output, may be NULL
 247 */
 248int net_hub_id_for_client(NetClientState *nc, int *id)
 249{
 250    NetHubPort *port;
 251
 252    if (nc->info->type == NET_CLIENT_DRIVER_HUBPORT) {
 253        port = DO_UPCAST(NetHubPort, nc, nc);
 254    } else if (nc->peer != NULL && nc->peer->info->type ==
 255            NET_CLIENT_DRIVER_HUBPORT) {
 256        port = DO_UPCAST(NetHubPort, nc, nc->peer);
 257    } else {
 258        return -ENOENT;
 259    }
 260
 261    if (id) {
 262        *id = port->hub->id;
 263    }
 264    return 0;
 265}
 266
 267int net_init_hubport(const Netdev *netdev, const char *name,
 268                     NetClientState *peer, Error **errp)
 269{
 270    const NetdevHubPortOptions *hubport;
 271    NetClientState *hubpeer = NULL;
 272
 273    assert(netdev->type == NET_CLIENT_DRIVER_HUBPORT);
 274    assert(!peer);
 275    hubport = &netdev->u.hubport;
 276
 277    if (hubport->has_netdev) {
 278        hubpeer = qemu_find_netdev(hubport->netdev);
 279        if (!hubpeer) {
 280            error_setg(errp, "netdev '%s' not found", hubport->netdev);
 281            return -1;
 282        }
 283    }
 284
 285    net_hub_add_port(hubport->hubid, name, hubpeer);
 286
 287    return 0;
 288}
 289
 290/**
 291 * Warn if hub configurations are likely wrong
 292 */
 293void net_hub_check_clients(void)
 294{
 295    NetHub *hub;
 296    NetHubPort *port;
 297    NetClientState *peer;
 298
 299    QLIST_FOREACH(hub, &hubs, next) {
 300        int has_nic = 0, has_host_dev = 0;
 301
 302        QLIST_FOREACH(port, &hub->ports, next) {
 303            peer = port->nc.peer;
 304            if (!peer) {
 305                warn_report("hub port %s has no peer", port->nc.name);
 306                continue;
 307            }
 308
 309            switch (peer->info->type) {
 310            case NET_CLIENT_DRIVER_NIC:
 311                has_nic = 1;
 312                break;
 313            case NET_CLIENT_DRIVER_USER:
 314            case NET_CLIENT_DRIVER_TAP:
 315            case NET_CLIENT_DRIVER_SOCKET:
 316            case NET_CLIENT_DRIVER_VDE:
 317            case NET_CLIENT_DRIVER_VHOST_USER:
 318                has_host_dev = 1;
 319                break;
 320            default:
 321                break;
 322            }
 323        }
 324        if (has_host_dev && !has_nic) {
 325            warn_report("hub %d with no nics", hub->id);
 326        }
 327        if (has_nic && !has_host_dev && !qtest_enabled()) {
 328            warn_report("hub %d is not connected to host network", hub->id);
 329        }
 330    }
 331}
 332
 333bool net_hub_flush(NetClientState *nc)
 334{
 335    NetHubPort *port;
 336    NetHubPort *source_port = DO_UPCAST(NetHubPort, nc, nc);
 337    int ret = 0;
 338
 339    QLIST_FOREACH(port, &source_port->hub->ports, next) {
 340        if (port != source_port) {
 341            ret += qemu_net_queue_flush(port->nc.incoming_queue);
 342        }
 343    }
 344    return ret ? true : false;
 345}
 346