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
  24 /*
  25  * A hub broadcasts incoming packets to all its ports except the source port.
  26  * Hubs can be used to provide independent emulated network segments.
  27  */
  28
  29 typedef struct NetHub NetHub;
  30
  31 typedef struct NetHubPort {
  32     NetClientState nc;
  33     QLIST_ENTRY(NetHubPort) next;
  34     NetHub *hub;
  35     int id;
  36 } NetHubPort;
  37
  38 struct NetHub {
  39     int id;
  40     QLIST_ENTRY(NetHub) next;
  41     int num_ports;
  42     QLIST_HEAD(, NetHubPort) ports;
  43 };
  44
  45 static QLIST_HEAD(, NetHub) hubs = QLIST_HEAD_INITIALIZER(&hubs);
  46
  47 static 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
  62 static 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
  78 static 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
  92 static 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
 111 static 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
 119 static 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
 127 static void net_hub_port_cleanup(NetClientState *nc)
 128 {
 129     NetHubPort *port = DO_UPCAST(NetHubPort, nc, nc);
 130
 131     QLIST_REMOVE(port, next);
 132 }
 133
 134 static 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
 143 static NetHubPort *net_hub_port_new(NetHub *hub, const char *name,
 144                                     NetClientState *hubpeer)
 145 {
 146     NetClientState *nc;
 147     NetHubPort *port;
 148     int id = hub->num_ports++;
 149     char default_name[128];
 150
 151     if (!name) {
 152         snprintf(default_name, sizeof(default_name),
 153                  "hub%dport%d", hub->id, id);
 154         name = default_name;
 155     }
 156
 157     nc = qemu_new_net_client(&net_hub_port_info, hubpeer, "hub", name);
 158     port = DO_UPCAST(NetHubPort, nc, nc);
 159     port->id = id;
 160     port->hub = hub;
 161
 162     QLIST_INSERT_HEAD(&hub->ports, port, next);
 163
 164     return port;
 165 }
 166
 167 /**
 168  * Create a port on a given hub
 169  * @hub_id: Number of the hub
 170  * @name: Net client name or NULL for default name.
 171  * @hubpeer: Peer to use (if "netdev=id" has been specified)
 172  *
 173  * If there is no existing hub with the given id then a new hub is created.
 174  */
 175 NetClientState *net_hub_add_port(int hub_id, const char *name,
 176                                  NetClientState *hubpeer)
 177 {
 178     NetHub *hub;
 179     NetHubPort *port;
 180
 181     QLIST_FOREACH(hub, &hubs, next) {
 182         if (hub->id == hub_id) {
 183             break;
 184         }
 185     }
 186
 187     if (!hub) {
 188         hub = net_hub_new(hub_id);
 189     }
 190
 191     port = net_hub_port_new(hub, name, hubpeer);
 192     return &port->nc;
 193 }
 194
 195 /**
 196  * Find a specific client on a hub
 197  */
 198 NetClientState *net_hub_find_client_by_name(int hub_id, const char *name)
 199 {
 200     NetHub *hub;
 201     NetHubPort *port;
 202     NetClientState *peer;
 203
 204     QLIST_FOREACH(hub, &hubs, next) {
 205         if (hub->id == hub_id) {
 206             QLIST_FOREACH(port, &hub->ports, next) {
 207                 peer = port->nc.peer;
 208
 209                 if (peer && strcmp(peer->name, name) == 0) {
 210                     return peer;
 211                 }
 212             }
 213         }
 214     }
 215     return NULL;
 216 }
 217
 218 /**
 219  * Find a available port on a hub; otherwise create one new port
 220  */
 221 NetClientState *net_hub_port_find(int hub_id)
 222 {
 223     NetHub *hub;
 224     NetHubPort *port;
 225     NetClientState *nc;
 226
 227     QLIST_FOREACH(hub, &hubs, next) {
 228         if (hub->id == hub_id) {
 229             QLIST_FOREACH(port, &hub->ports, next) {
 230                 nc = port->nc.peer;
 231                 if (!nc) {
 232                     return &(port->nc);
 233                 }
 234             }
 235             break;
 236         }
 237     }
 238
 239     nc = net_hub_add_port(hub_id, NULL, NULL);
 240     return nc;
 241 }
 242
 243 /**
 244  * Print hub configuration
 245  */
 246 void net_hub_info(Monitor *mon)
 247 {
 248     NetHub *hub;
 249     NetHubPort *port;
 250
 251     QLIST_FOREACH(hub, &hubs, next) {
 252         monitor_printf(mon, "hub %d\n", hub->id);
 253         QLIST_FOREACH(port, &hub->ports, next) {
 254             monitor_printf(mon, " \\ %s", port->nc.name);
 255             if (port->nc.peer) {
 256                 monitor_printf(mon, ": ");
 257                 print_net_client(mon, port->nc.peer);
 258             } else {
 259                 monitor_printf(mon, "\n");
 260             }
 261         }
 262     }
 263 }
 264
 265 /**
 266  * Get the hub id that a client is connected to
 267  *
 268  * @id: Pointer for hub id output, may be NULL
 269  */
 270 int net_hub_id_for_client(NetClientState *nc, int *id)
 271 {
 272     NetHubPort *port;
 273
 274     if (nc->info->type == NET_CLIENT_DRIVER_HUBPORT) {
 275         port = DO_UPCAST(NetHubPort, nc, nc);
 276     } else if (nc->peer != NULL && nc->peer->info->type ==
 277             NET_CLIENT_DRIVER_HUBPORT) {
 278         port = DO_UPCAST(NetHubPort, nc, nc->peer);
 279     } else {
 280         return -ENOENT;
 281     }
 282
 283     if (id) {
 284         *id = port->hub->id;
 285     }
 286     return 0;
 287 }
 288
 289 int net_init_hubport(const Netdev *netdev, const char *name,
 290                      NetClientState *peer, Error **errp)
 291 {
 292     const NetdevHubPortOptions *hubport;
 293     NetClientState *hubpeer = NULL;
 294
 295     assert(netdev->type == NET_CLIENT_DRIVER_HUBPORT);
 296     assert(!peer);
 297     hubport = &netdev->u.hubport;
 298
 299     if (hubport->has_netdev) {
 300         hubpeer = qemu_find_netdev(hubport->netdev);
 301         if (!hubpeer) {
 302             error_setg(errp, "netdev '%s' not found", hubport->netdev);
 303             return -1;
 304         }
 305     }
 306
 307     net_hub_add_port(hubport->hubid, name, hubpeer);
 308
 309     return 0;
 310 }
 311
 312 /**
 313  * Warn if hub configurations are likely wrong
 314  */
 315 void net_hub_check_clients(void)
 316 {
 317     NetHub *hub;
 318     NetHubPort *port;
 319     NetClientState *peer;
 320
 321     QLIST_FOREACH(hub, &hubs, next) {
 322         int has_nic = 0, has_host_dev = 0;
 323
 324         QLIST_FOREACH(port, &hub->ports, next) {
 325             peer = port->nc.peer;
 326             if (!peer) {
 327                 warn_report("hub port %s has no peer", port->nc.name);
 328                 continue;
 329             }
 330
 331             switch (peer->info->type) {
 332             case NET_CLIENT_DRIVER_NIC:
 333                 has_nic = 1;
 334                 break;
 335             case NET_CLIENT_DRIVER_USER:
 336             case NET_CLIENT_DRIVER_TAP:
 337             case NET_CLIENT_DRIVER_SOCKET:
 338             case NET_CLIENT_DRIVER_VDE:
 339             case NET_CLIENT_DRIVER_VHOST_USER:
 340                 has_host_dev = 1;
 341                 break;
 342             default:
 343                 break;
 344             }
 345         }
 346         if (has_host_dev && !has_nic) {
 347             warn_report("hub %d with no nics", hub->id);
 348         }
 349         if (has_nic && !has_host_dev) {
 350             warn_report("hub %d is not connected to host network", hub->id);
 351         }
 352     }
 353 }
 354
 355 bool net_hub_flush(NetClientState *nc)
 356 {
 357     NetHubPort *port;
 358     NetHubPort *source_port = DO_UPCAST(NetHubPort, nc, nc);
 359     int ret = 0;
 360
 361     QLIST_FOREACH(port, &source_port->hub->ports, next) {
 362         if (port != source_port) {
 363             ret += qemu_net_queue_flush(port->nc.incoming_queue);
 364         }
 365     }
 366     return ret ? true : false;
 367 }