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