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