2008-10-31 22:10:00 +03:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2009-03-07 19:52:02 +03:00
|
|
|
#include "config-host.h"
|
|
|
|
|
2012-10-24 10:43:34 +04:00
|
|
|
#include "net/net.h"
|
2012-10-24 13:27:28 +04:00
|
|
|
#include "clients.h"
|
|
|
|
#include "hub.h"
|
2012-10-24 10:43:34 +04:00
|
|
|
#include "net/slirp.h"
|
2012-10-24 13:27:28 +04:00
|
|
|
#include "util.h"
|
2012-09-17 20:43:51 +04:00
|
|
|
|
2012-12-17 21:19:49 +04:00
|
|
|
#include "monitor/monitor.h"
|
2009-11-25 21:48:58 +03:00
|
|
|
#include "qemu-common.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/sockets.h"
|
|
|
|
#include "qemu/config-file.h"
|
2011-11-23 19:11:55 +04:00
|
|
|
#include "qmp-commands.h"
|
2010-02-25 14:54:43 +03:00
|
|
|
#include "hw/qdev.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/iov.h"
|
2012-07-17 18:17:13 +04:00
|
|
|
#include "qapi-visit.h"
|
|
|
|
#include "qapi/opts-visitor.h"
|
2012-12-17 21:19:43 +04:00
|
|
|
#include "qapi/dealloc-visitor.h"
|
2009-03-07 18:32:56 +03:00
|
|
|
|
2012-02-04 12:24:46 +04:00
|
|
|
/* Net bridge is currently not supported for W32. */
|
|
|
|
#if !defined(_WIN32)
|
|
|
|
# define CONFIG_NET_BRIDGE
|
|
|
|
#endif
|
|
|
|
|
2012-07-24 19:35:13 +04:00
|
|
|
static QTAILQ_HEAD(, NetClientState) net_clients;
|
2008-10-31 22:10:00 +03:00
|
|
|
|
2009-12-08 15:11:47 +03:00
|
|
|
int default_net = 1;
|
|
|
|
|
2008-10-31 22:10:00 +03:00
|
|
|
/***********************************************************/
|
|
|
|
/* network device redirectors */
|
|
|
|
|
2009-11-25 21:48:54 +03:00
|
|
|
#if defined(DEBUG_NET)
|
2008-10-31 22:10:00 +03:00
|
|
|
static void hex_dump(FILE *f, const uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
int len, i, j, c;
|
|
|
|
|
|
|
|
for(i=0;i<size;i+=16) {
|
|
|
|
len = size - i;
|
|
|
|
if (len > 16)
|
|
|
|
len = 16;
|
|
|
|
fprintf(f, "%08x ", i);
|
|
|
|
for(j=0;j<16;j++) {
|
|
|
|
if (j < len)
|
|
|
|
fprintf(f, " %02x", buf[i+j]);
|
|
|
|
else
|
|
|
|
fprintf(f, " ");
|
|
|
|
}
|
|
|
|
fprintf(f, " ");
|
|
|
|
for(j=0;j<len;j++) {
|
|
|
|
c = buf[i+j];
|
|
|
|
if (c < ' ' || c > '~')
|
|
|
|
c = '.';
|
|
|
|
fprintf(f, "%c", c);
|
|
|
|
}
|
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
|
|
|
|
{
|
|
|
|
const char *p, *p1;
|
|
|
|
int len;
|
|
|
|
p = *pp;
|
|
|
|
p1 = strchr(p, sep);
|
|
|
|
if (!p1)
|
|
|
|
return -1;
|
|
|
|
len = p1 - p;
|
|
|
|
p1++;
|
|
|
|
if (buf_size > 0) {
|
|
|
|
if (len > buf_size - 1)
|
|
|
|
len = buf_size - 1;
|
|
|
|
memcpy(buf, p, len);
|
|
|
|
buf[len] = '\0';
|
|
|
|
}
|
|
|
|
*pp = p1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int parse_host_port(struct sockaddr_in *saddr, const char *str)
|
|
|
|
{
|
|
|
|
char buf[512];
|
|
|
|
struct hostent *he;
|
|
|
|
const char *p, *r;
|
|
|
|
int port;
|
|
|
|
|
|
|
|
p = str;
|
|
|
|
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
|
|
|
|
return -1;
|
|
|
|
saddr->sin_family = AF_INET;
|
|
|
|
if (buf[0] == '\0') {
|
|
|
|
saddr->sin_addr.s_addr = 0;
|
|
|
|
} else {
|
2008-11-16 16:53:32 +03:00
|
|
|
if (qemu_isdigit(buf[0])) {
|
2008-10-31 22:10:00 +03:00
|
|
|
if (!inet_aton(buf, &saddr->sin_addr))
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
if ((he = gethostbyname(buf)) == NULL)
|
|
|
|
return - 1;
|
|
|
|
saddr->sin_addr = *(struct in_addr *)he->h_addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
port = strtol(p, (char **)&r, 0);
|
|
|
|
if (r == p)
|
|
|
|
return -1;
|
|
|
|
saddr->sin_port = htons(port);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
|
2009-01-07 20:46:21 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
snprintf(nc->info_str, sizeof(nc->info_str),
|
2009-01-08 22:01:37 +03:00
|
|
|
"model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->model,
|
2009-01-07 20:46:21 +03:00
|
|
|
macaddr[0], macaddr[1], macaddr[2],
|
|
|
|
macaddr[3], macaddr[4], macaddr[5]);
|
|
|
|
}
|
|
|
|
|
2009-10-21 17:25:22 +04:00
|
|
|
void qemu_macaddr_default_if_unset(MACAddr *macaddr)
|
|
|
|
{
|
|
|
|
static int index = 0;
|
|
|
|
static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
|
|
|
|
|
|
|
|
if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
|
|
|
|
return;
|
|
|
|
macaddr->a[0] = 0x52;
|
|
|
|
macaddr->a[1] = 0x54;
|
|
|
|
macaddr->a[2] = 0x00;
|
|
|
|
macaddr->a[3] = 0x12;
|
|
|
|
macaddr->a[4] = 0x34;
|
|
|
|
macaddr->a[5] = 0x56 + index++;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:05 +04:00
|
|
|
/**
|
|
|
|
* Generate a name for net client
|
|
|
|
*
|
|
|
|
* Only net clients created with the legacy -net option need this. Naming is
|
|
|
|
* mandatory for net clients created with -netdev.
|
|
|
|
*/
|
2012-07-24 19:35:14 +04:00
|
|
|
static char *assign_name(NetClientState *nc1, const char *model)
|
2009-01-07 20:43:44 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc;
|
2009-01-07 20:43:44 +03:00
|
|
|
char buf[256];
|
|
|
|
int id = 0;
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
QTAILQ_FOREACH(nc, &net_clients, next) {
|
|
|
|
if (nc == nc1) {
|
2012-07-24 19:35:05 +04:00
|
|
|
continue;
|
2009-10-08 22:58:23 +04:00
|
|
|
}
|
2012-07-24 19:35:05 +04:00
|
|
|
/* For compatibility only bump id for net clients on a vlan */
|
2012-07-24 19:35:14 +04:00
|
|
|
if (strcmp(nc->model, model) == 0 &&
|
|
|
|
net_hub_id_for_client(nc, NULL) == 0) {
|
Fix automatically assigned network names for netdev
If a network client doesn't have a name, we make one up, with
assign_name(). assign_name() creates a name MODEL.NUM, where MODEL is
the client's model, and NUM is the number of MODELs that already
exist.
Bug: it misses clients that are not on a VLAN, i.e. netdevs and the
NICs using them:
$ qemu-system-x86_64 -nodefaults -vnc :0 -S -monitor stdio -netdev user,id=hostnet0 -net nic,netdev=hostnet0 -netdev user,id=hostnet1 -net nic,netdev=hostnet1
QEMU 0.14.50 monitor - type 'help' for more information
(qemu) info network
Devices not on any VLAN:
hostnet0: net=10.0.2.0, restricted=n peer=e1000.0
hostnet1: net=10.0.2.0, restricted=n peer=e1000.0
e1000.0: model=e1000,macaddr=52:54:00:12:34:56 peer=hostnet0
e1000.0: model=e1000,macaddr=52:54:00:12:34:57 peer=hostnet1
Fix that.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2011-06-16 20:45:36 +04:00
|
|
|
id++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-07 20:43:44 +03:00
|
|
|
snprintf(buf, sizeof(buf), "%s.%d", model, id);
|
|
|
|
|
2011-08-21 07:09:37 +04:00
|
|
|
return g_strdup(buf);
|
2009-01-07 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:27 +04:00
|
|
|
static void qemu_net_client_destructor(NetClientState *nc)
|
|
|
|
{
|
|
|
|
g_free(nc);
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:26 +04:00
|
|
|
static void qemu_net_client_setup(NetClientState *nc,
|
|
|
|
NetClientInfo *info,
|
|
|
|
NetClientState *peer,
|
|
|
|
const char *model,
|
2013-01-30 15:12:27 +04:00
|
|
|
const char *name,
|
|
|
|
NetClientDestructor *destructor)
|
2008-10-31 22:10:00 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->info = info;
|
|
|
|
nc->model = g_strdup(model);
|
2009-11-25 21:49:02 +03:00
|
|
|
if (name) {
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->name = g_strdup(name);
|
2009-11-25 21:49:02 +03:00
|
|
|
} else {
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->name = assign_name(nc, model);
|
2009-11-25 21:49:02 +03:00
|
|
|
}
|
2009-10-08 22:58:23 +04:00
|
|
|
|
2012-07-24 19:35:08 +04:00
|
|
|
if (peer) {
|
|
|
|
assert(!peer->peer);
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->peer = peer;
|
|
|
|
peer->peer = nc;
|
2009-10-08 22:58:24 +04:00
|
|
|
}
|
2012-07-24 19:35:14 +04:00
|
|
|
QTAILQ_INSERT_TAIL(&net_clients, nc, next);
|
2008-10-31 22:10:00 +03:00
|
|
|
|
2012-07-24 19:35:17 +04:00
|
|
|
nc->send_queue = qemu_new_net_queue(nc);
|
2013-01-30 15:12:27 +04:00
|
|
|
nc->destructor = destructor;
|
2013-01-30 15:12:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
NetClientState *qemu_new_net_client(NetClientInfo *info,
|
|
|
|
NetClientState *peer,
|
|
|
|
const char *model,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
NetClientState *nc;
|
|
|
|
|
|
|
|
assert(info->size >= sizeof(NetClientState));
|
|
|
|
|
|
|
|
nc = g_malloc0(info->size);
|
2013-01-30 15:12:27 +04:00
|
|
|
qemu_net_client_setup(nc, info, peer, model, name,
|
|
|
|
qemu_net_client_destructor);
|
2013-01-30 15:12:26 +04:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
return nc;
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2009-11-25 21:49:10 +03:00
|
|
|
NICState *qemu_new_nic(NetClientInfo *info,
|
|
|
|
NICConf *conf,
|
|
|
|
const char *model,
|
|
|
|
const char *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
2012-07-24 19:35:13 +04:00
|
|
|
NetClientState *nc;
|
2013-01-30 15:12:28 +04:00
|
|
|
NetClientState **peers = conf->peers.ncs;
|
2009-11-25 21:49:10 +03:00
|
|
|
NICState *nic;
|
2013-01-30 15:12:28 +04:00
|
|
|
int i;
|
2009-11-25 21:49:10 +03:00
|
|
|
|
2012-07-17 18:17:12 +04:00
|
|
|
assert(info->type == NET_CLIENT_OPTIONS_KIND_NIC);
|
2009-11-25 21:49:10 +03:00
|
|
|
assert(info->size >= sizeof(NICState));
|
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
nc = qemu_new_net_client(info, peers[0], model, name);
|
|
|
|
nc->queue_index = 0;
|
2009-11-25 21:49:10 +03:00
|
|
|
|
2013-01-30 15:12:23 +04:00
|
|
|
nic = qemu_get_nic(nc);
|
2009-11-25 21:49:10 +03:00
|
|
|
nic->conf = conf;
|
|
|
|
nic->opaque = opaque;
|
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
for (i = 1; i < conf->queues; i++) {
|
|
|
|
qemu_net_client_setup(&nic->ncs[i], info, peers[i], model, nc->name,
|
|
|
|
NULL);
|
|
|
|
nic->ncs[i].queue_index = i;
|
|
|
|
}
|
|
|
|
|
2009-11-25 21:49:10 +03:00
|
|
|
return nic;
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
NetClientState *qemu_get_subqueue(NICState *nic, int queue_index)
|
|
|
|
{
|
|
|
|
return &nic->ncs[queue_index];
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:22 +04:00
|
|
|
NetClientState *qemu_get_queue(NICState *nic)
|
|
|
|
{
|
2013-01-30 15:12:28 +04:00
|
|
|
return qemu_get_subqueue(nic, 0);
|
2013-01-30 15:12:22 +04:00
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:23 +04:00
|
|
|
NICState *qemu_get_nic(NetClientState *nc)
|
|
|
|
{
|
2013-01-30 15:12:28 +04:00
|
|
|
NetClientState *nc0 = nc - nc->queue_index;
|
|
|
|
|
|
|
|
return DO_UPCAST(NICState, ncs[0], nc0);
|
2013-01-30 15:12:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void *qemu_get_nic_opaque(NetClientState *nc)
|
|
|
|
{
|
|
|
|
NICState *nic = qemu_get_nic(nc);
|
|
|
|
|
|
|
|
return nic->opaque;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:15 +04:00
|
|
|
static void qemu_cleanup_net_client(NetClientState *nc)
|
2008-10-31 22:10:00 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
QTAILQ_REMOVE(&net_clients, nc, next);
|
2008-10-31 22:10:00 +03:00
|
|
|
|
2013-02-13 02:16:06 +04:00
|
|
|
if (nc->info->cleanup) {
|
|
|
|
nc->info->cleanup(nc);
|
|
|
|
}
|
2010-09-20 20:08:41 +04:00
|
|
|
}
|
2009-10-08 22:58:23 +04:00
|
|
|
|
2012-07-24 19:35:15 +04:00
|
|
|
static void qemu_free_net_client(NetClientState *nc)
|
2010-09-20 20:08:41 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->send_queue) {
|
|
|
|
qemu_del_net_queue(nc->send_queue);
|
2012-07-24 19:35:11 +04:00
|
|
|
}
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->peer) {
|
|
|
|
nc->peer->peer = NULL;
|
2010-09-20 20:08:41 +04:00
|
|
|
}
|
2012-07-24 19:35:14 +04:00
|
|
|
g_free(nc->name);
|
|
|
|
g_free(nc->model);
|
2013-01-30 15:12:27 +04:00
|
|
|
if (nc->destructor) {
|
|
|
|
nc->destructor(nc);
|
|
|
|
}
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:15 +04:00
|
|
|
void qemu_del_net_client(NetClientState *nc)
|
2010-09-20 20:08:41 +04:00
|
|
|
{
|
2013-01-30 15:12:28 +04:00
|
|
|
NetClientState *ncs[MAX_QUEUE_NUM];
|
|
|
|
int queues, i;
|
|
|
|
|
|
|
|
/* If the NetClientState belongs to a multiqueue backend, we will change all
|
|
|
|
* other NetClientStates also.
|
|
|
|
*/
|
|
|
|
queues = qemu_find_net_clients_except(nc->name, ncs,
|
|
|
|
NET_CLIENT_OPTIONS_KIND_NIC,
|
|
|
|
MAX_QUEUE_NUM);
|
|
|
|
assert(queues != 0);
|
|
|
|
|
2010-09-20 20:08:41 +04:00
|
|
|
/* If there is a peer NIC, delete and cleanup client, but do not free. */
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
|
2013-01-30 15:12:23 +04:00
|
|
|
NICState *nic = qemu_get_nic(nc->peer);
|
2010-09-20 20:08:41 +04:00
|
|
|
if (nic->peer_deleted) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
nic->peer_deleted = true;
|
2013-01-30 15:12:28 +04:00
|
|
|
|
|
|
|
for (i = 0; i < queues; i++) {
|
|
|
|
ncs[i]->peer->link_down = true;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->peer->info->link_status_changed) {
|
|
|
|
nc->peer->info->link_status_changed(nc->peer);
|
2010-09-20 20:08:41 +04:00
|
|
|
}
|
2013-01-30 15:12:28 +04:00
|
|
|
|
|
|
|
for (i = 0; i < queues; i++) {
|
|
|
|
qemu_cleanup_net_client(ncs[i]);
|
|
|
|
}
|
|
|
|
|
2010-09-20 20:08:41 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:24 +04:00
|
|
|
assert(nc->info->type != NET_CLIENT_OPTIONS_KIND_NIC);
|
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
for (i = 0; i < queues; i++) {
|
|
|
|
qemu_cleanup_net_client(ncs[i]);
|
|
|
|
qemu_free_net_client(ncs[i]);
|
|
|
|
}
|
2013-01-30 15:12:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_del_nic(NICState *nic)
|
|
|
|
{
|
2013-02-07 04:25:48 +04:00
|
|
|
int i, queues = MAX(nic->conf->queues, 1);
|
2013-01-30 15:12:28 +04:00
|
|
|
|
2010-09-20 20:08:41 +04:00
|
|
|
/* If this is a peer NIC and peer has already been deleted, free it now. */
|
2013-01-30 15:12:28 +04:00
|
|
|
if (nic->peer_deleted) {
|
|
|
|
for (i = 0; i < queues; i++) {
|
|
|
|
qemu_free_net_client(qemu_get_subqueue(nic, i)->peer);
|
2009-06-24 16:42:31 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
for (i = queues - 1; i >= 0; i--) {
|
|
|
|
NetClientState *nc = qemu_get_subqueue(nic, i);
|
|
|
|
|
|
|
|
qemu_cleanup_net_client(nc);
|
|
|
|
qemu_free_net_client(nc);
|
|
|
|
}
|
2009-06-24 16:42:31 +04:00
|
|
|
}
|
|
|
|
|
2009-11-25 21:49:31 +03:00
|
|
|
void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
|
|
|
|
{
|
2012-07-24 19:35:13 +04:00
|
|
|
NetClientState *nc;
|
2009-11-25 21:49:31 +03:00
|
|
|
|
2012-07-24 19:35:12 +04:00
|
|
|
QTAILQ_FOREACH(nc, &net_clients, next) {
|
2012-07-17 18:17:12 +04:00
|
|
|
if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
|
2013-01-30 15:12:28 +04:00
|
|
|
if (nc->queue_index == 0) {
|
|
|
|
func(qemu_get_nic(nc), opaque);
|
|
|
|
}
|
2009-11-25 21:49:31 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:13 +04:00
|
|
|
int qemu_can_send_packet(NetClientState *sender)
|
2008-10-31 22:10:00 +03:00
|
|
|
{
|
2012-07-24 19:35:11 +04:00
|
|
|
if (!sender->peer) {
|
2009-10-08 22:58:24 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:11 +04:00
|
|
|
if (sender->peer->receive_disabled) {
|
|
|
|
return 0;
|
|
|
|
} else if (sender->peer->info->can_receive &&
|
|
|
|
!sender->peer->info->can_receive(sender->peer)) {
|
|
|
|
return 0;
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
net: fix qemu_can_send_packet logic
If any of the clients is not ready to receive (ie it has a can_receive
callback and can_receive() returns false), we don't want to start
sending, else this client may miss/discard the packet.
I got this behaviour with the following setup :
the emulated machine is using an USB-ethernet adapter, it is connected
to the network using SLIRP and I'm dumping the traffic in a .pcap file.
As per the following command line :
-net nic,model=usb,vlan=1 -net user,vlan=1 -net dump,vlan=1,file=/tmp/pkt.pcap
Every time that two packets are coming in a row from the host, the
usb-net code will receive the first one, then returns 0 to can_receive
call since it has a 1 packet long queue. But as the dump code is always
ready to receive, qemu_can_send_packet will return true and the next
packet will discard the previous one in the usb-net code.
Signed-off-by: Vincent Palatin <vpalatin@chromium.org>
Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
2011-03-03 01:25:02 +03:00
|
|
|
return 1;
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:17 +04:00
|
|
|
ssize_t qemu_deliver_packet(NetClientState *sender,
|
|
|
|
unsigned flags,
|
|
|
|
const uint8_t *data,
|
|
|
|
size_t size,
|
|
|
|
void *opaque)
|
2009-10-08 22:58:32 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc = opaque;
|
2009-10-27 21:16:36 +03:00
|
|
|
ssize_t ret;
|
2009-10-08 22:58:32 +04:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->link_down) {
|
2009-10-08 22:58:32 +04:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->receive_disabled) {
|
2009-10-27 21:16:36 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (flags & QEMU_NET_PACKET_FLAG_RAW && nc->info->receive_raw) {
|
|
|
|
ret = nc->info->receive_raw(nc, data, size);
|
2009-10-27 21:16:36 +03:00
|
|
|
} else {
|
2012-07-24 19:35:14 +04:00
|
|
|
ret = nc->info->receive(nc, data, size);
|
2009-10-27 21:16:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0) {
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->receive_disabled = 1;
|
2009-10-27 21:16:36 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
return ret;
|
2009-10-08 22:58:32 +04:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
void qemu_purge_queued_packets(NetClientState *nc)
|
2009-06-18 21:21:29 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
if (!nc->peer) {
|
2009-10-08 22:58:24 +04:00
|
|
|
return;
|
2009-10-08 22:58:32 +04:00
|
|
|
}
|
2009-10-08 22:58:24 +04:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
qemu_net_queue_purge(nc->peer->send_queue, nc);
|
2009-06-18 21:21:29 +04:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
void qemu_flush_queued_packets(NetClientState *nc)
|
2009-04-29 14:48:12 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->receive_disabled = 0;
|
2009-10-08 22:58:32 +04:00
|
|
|
|
2013-02-05 20:53:31 +04:00
|
|
|
if (nc->peer && nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_HUBPORT) {
|
|
|
|
if (net_hub_flush(nc->peer)) {
|
|
|
|
qemu_notify_event();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2012-08-09 18:45:55 +04:00
|
|
|
if (qemu_net_queue_flush(nc->send_queue)) {
|
|
|
|
/* We emptied the queue successfully, signal to the IO thread to repoll
|
|
|
|
* the file descriptor (for tap, for example).
|
|
|
|
*/
|
|
|
|
qemu_notify_event();
|
|
|
|
}
|
2009-04-29 14:48:12 +04:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:13 +04:00
|
|
|
static ssize_t qemu_send_packet_async_with_flags(NetClientState *sender,
|
2009-10-22 20:43:41 +04:00
|
|
|
unsigned flags,
|
|
|
|
const uint8_t *buf, int size,
|
|
|
|
NetPacketSent *sent_cb)
|
2009-04-21 23:56:41 +04:00
|
|
|
{
|
2009-10-08 22:58:32 +04:00
|
|
|
NetQueue *queue;
|
2009-01-08 22:44:06 +03:00
|
|
|
|
2008-10-31 22:10:00 +03:00
|
|
|
#ifdef DEBUG_NET
|
2009-10-08 22:58:24 +04:00
|
|
|
printf("qemu_send_packet_async:\n");
|
2008-10-31 22:10:00 +03:00
|
|
|
hex_dump(stdout, buf, size);
|
|
|
|
#endif
|
2009-04-29 15:15:26 +04:00
|
|
|
|
2012-07-24 19:35:11 +04:00
|
|
|
if (sender->link_down || !sender->peer) {
|
2009-10-08 22:58:32 +04:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:11 +04:00
|
|
|
queue = sender->peer->send_queue;
|
2009-10-08 22:58:32 +04:00
|
|
|
|
2009-10-22 20:43:41 +04:00
|
|
|
return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:13 +04:00
|
|
|
ssize_t qemu_send_packet_async(NetClientState *sender,
|
2009-10-22 20:43:41 +04:00
|
|
|
const uint8_t *buf, int size,
|
|
|
|
NetPacketSent *sent_cb)
|
|
|
|
{
|
|
|
|
return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
|
|
|
|
buf, size, sent_cb);
|
2009-04-29 15:15:26 +04:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
void qemu_send_packet(NetClientState *nc, const uint8_t *buf, int size)
|
2009-04-29 15:15:26 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
qemu_send_packet_async(nc, buf, size, NULL);
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
ssize_t qemu_send_packet_raw(NetClientState *nc, const uint8_t *buf, int size)
|
2009-10-22 20:43:41 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
return qemu_send_packet_async_with_flags(nc, QEMU_NET_PACKET_FLAG_RAW,
|
2009-10-22 20:43:41 +04:00
|
|
|
buf, size, NULL);
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
|
2008-12-17 22:13:11 +03:00
|
|
|
int iovcnt)
|
|
|
|
{
|
|
|
|
uint8_t buffer[4096];
|
2011-02-24 03:57:21 +03:00
|
|
|
size_t offset;
|
2008-12-17 22:13:11 +03:00
|
|
|
|
change iov_* function prototypes to be more appropriate
Reorder arguments to be more natural, readable and
consistent with other iov_* functions, and change
argument names, from:
iov_from_buf(iov, iov_cnt, buf, iov_off, size)
to
iov_from_buf(iov, iov_cnt, offset, buf, bytes)
The result becomes natural English:
copy data to this `iov' vector with `iov_cnt'
elements starting at byte offset `offset'
from memory buffer `buf', processing `bytes'
bytes max.
(Try to read the original prototype this way).
Also change iov_clear() to more general iov_memset()
(it uses memset() internally anyway).
While at it, add comments to the header file
describing what the routines actually does.
The patch only renames argumens in the header, but
keeps old names in the implementation. The next
patch will touch actual code to match.
Now, it might look wrong to pay so much attention
to so small things. But we've so many badly designed
interfaces already so the whole thing becomes rather
confusing or error prone. One example of this is
previous commit and small discussion which emerged
from it, with an outcome that the utility functions
like these aren't well-understdandable, leading to
strange usage cases. That's why I paid quite some
attention to this set of functions and a few
others in subsequent patches.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-11 18:05:12 +04:00
|
|
|
offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
|
2008-12-17 22:13:11 +03:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
return nc->info->receive(nc, buffer, offset);
|
2008-12-17 22:13:11 +03:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:17 +04:00
|
|
|
ssize_t qemu_deliver_packet_iov(NetClientState *sender,
|
|
|
|
unsigned flags,
|
|
|
|
const struct iovec *iov,
|
|
|
|
int iovcnt,
|
|
|
|
void *opaque)
|
2009-10-08 22:58:32 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc = opaque;
|
2012-08-18 00:16:42 +04:00
|
|
|
int ret;
|
2009-10-08 22:58:32 +04:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->link_down) {
|
2011-02-24 03:57:21 +03:00
|
|
|
return iov_size(iov, iovcnt);
|
2009-10-08 22:58:32 +04:00
|
|
|
}
|
|
|
|
|
2012-08-18 00:16:42 +04:00
|
|
|
if (nc->receive_disabled) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->info->receive_iov) {
|
2012-08-18 00:16:42 +04:00
|
|
|
ret = nc->info->receive_iov(nc, iov, iovcnt);
|
2009-10-08 22:58:32 +04:00
|
|
|
} else {
|
2012-08-18 00:16:42 +04:00
|
|
|
ret = nc_sendv_compat(nc, iov, iovcnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
nc->receive_disabled = 1;
|
2009-04-29 14:48:12 +04:00
|
|
|
}
|
2012-08-18 00:16:42 +04:00
|
|
|
|
|
|
|
return ret;
|
2009-04-29 14:48:12 +04:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:13 +04:00
|
|
|
ssize_t qemu_sendv_packet_async(NetClientState *sender,
|
2009-04-29 15:15:26 +04:00
|
|
|
const struct iovec *iov, int iovcnt,
|
|
|
|
NetPacketSent *sent_cb)
|
2009-04-29 14:48:12 +04:00
|
|
|
{
|
2009-10-08 22:58:32 +04:00
|
|
|
NetQueue *queue;
|
|
|
|
|
2012-07-24 19:35:11 +04:00
|
|
|
if (sender->link_down || !sender->peer) {
|
2011-02-24 03:57:21 +03:00
|
|
|
return iov_size(iov, iovcnt);
|
2009-04-29 14:48:12 +04:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:11 +04:00
|
|
|
queue = sender->peer->send_queue;
|
2009-10-08 22:58:32 +04:00
|
|
|
|
2009-10-22 20:43:40 +04:00
|
|
|
return qemu_net_queue_send_iov(queue, sender,
|
|
|
|
QEMU_NET_PACKET_FLAG_NONE,
|
|
|
|
iov, iovcnt, sent_cb);
|
2008-12-17 22:13:11 +03:00
|
|
|
}
|
|
|
|
|
2009-04-29 15:15:26 +04:00
|
|
|
ssize_t
|
2012-07-24 19:35:14 +04:00
|
|
|
qemu_sendv_packet(NetClientState *nc, const struct iovec *iov, int iovcnt)
|
2009-04-29 15:15:26 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
return qemu_sendv_packet_async(nc, iov, iovcnt, NULL);
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:13 +04:00
|
|
|
NetClientState *qemu_find_netdev(const char *id)
|
2009-10-08 22:58:29 +04:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc;
|
2009-10-08 22:58:29 +04:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
QTAILQ_FOREACH(nc, &net_clients, next) {
|
|
|
|
if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC)
|
Fix netdev name lookup in -device, device_add, netdev_del
qemu_find_netdev() looks up members of non_vlan_clients by name. It
happily returns the first match. Trouble is the names need not be
unique.
non_vlan_clients contains host parts (netdevs) and guest parts (NICs).
Netdevs have unique names: a netdev's name is a (mandatory)
qemu_netdev_opts ID, and these are unique.
NIC names are not unique. If a NIC has a qdev ID (which is unique),
that's its name. Else, we make up a name. The made-up names are
unique, but they can clash with qdev IDs. Even if NICs had unique
names, they could still clash with netdev names.
Callers of qemu_find_netdev():
* net_init_nic() wants a netdev. It happens to work because it runs
before NICs get added to non_vlan_clients.
* do_netdev_del() wants a netdev. If it gets a NIC, it complains and
fails. Bug: a netdev with the same name that comes later in
non_vlan_clients can't be deleted:
$ qemu-system-x86_64 -nodefaults -vnc :0 -S -monitor stdio -netdev user,id=hostnet0 -device virtio-net-pci,netdev=hostnet0,id=virtio1
[...]
(qemu) netdev_add user,id=virtio1
(qemu) info network
Devices not on any VLAN:
hostnet0: net=10.0.2.0, restricted=n peer=virtio1
virtio1: model=virtio-net-pci,macaddr=52:54:00:12:34:56 peer=hostnet0
virtio1: net=10.0.2.0, restricted=n
(qemu) netdev_del virtio1
Device 'virtio1' not found
* parse_netdev() wants a netdev. If it gets a NIC, it gets confused.
With the test setup above:
(qemu) device_add virtio-net-pci,netdev=virtio1
Property 'virtio-net-pci.netdev' can't take value 'virtio1', it's in use
You can even connect two NICs to each other:
$ qemu-system-x86_64 -nodefaults -vnc :0 -S -monitor stdio -device virtio-net-pci,id=virtio1 -device e1000,netdev=virtio1
[...]
Devices not on any VLAN:
virtio1: model=virtio-net-pci,macaddr=52:54:00:12:34:56 peer=e1000.0
e1000.0: model=e1000,macaddr=52:54:00:12:34:57 peer=virtio1
(qemu) q
Segmentation fault (core dumped)
* do_set_link() works fine for both netdevs and NICs. Whether it
really makes sense for netdevs is debatable, but that's outside this
patch's scope.
Change qemu_find_netdev() to return only netdevs. This fixes the
netdev_del and device_add/-device bugs demonstrated above.
To avoid changing set_link, make do_set_link() search non_vlan_clients
by hand instead of calling qemu_find_netdev().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2011-06-16 20:45:37 +04:00
|
|
|
continue;
|
2012-07-24 19:35:14 +04:00
|
|
|
if (!strcmp(nc->name, id)) {
|
|
|
|
return nc;
|
2009-10-08 22:58:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:12:25 +04:00
|
|
|
int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
|
|
|
|
NetClientOptionsKind type, int max)
|
|
|
|
{
|
|
|
|
NetClientState *nc;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(nc, &net_clients, next) {
|
|
|
|
if (nc->info->type == type) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(nc->name, id)) {
|
|
|
|
if (ret < max) {
|
|
|
|
ncs[ret] = nc;
|
|
|
|
}
|
|
|
|
ret++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-02-11 18:20:03 +03:00
|
|
|
static int nic_get_free_idx(void)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
for (index = 0; index < MAX_NICS; index++)
|
|
|
|
if (!nd_table[index].used)
|
|
|
|
return index;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-09-25 05:53:51 +04:00
|
|
|
int qemu_show_nic_models(const char *arg, const char *const *models)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-08-02 16:45:54 +04:00
|
|
|
if (!arg || !is_help_option(arg)) {
|
2009-09-25 05:53:51 +04:00
|
|
|
return 0;
|
2012-08-02 16:45:54 +04:00
|
|
|
}
|
2009-09-25 05:53:51 +04:00
|
|
|
|
|
|
|
fprintf(stderr, "qemu: Supported NIC models: ");
|
|
|
|
for (i = 0 ; models[i]; i++)
|
|
|
|
fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-01-13 22:03:57 +03:00
|
|
|
void qemu_check_nic_model(NICInfo *nd, const char *model)
|
|
|
|
{
|
|
|
|
const char *models[2];
|
|
|
|
|
|
|
|
models[0] = model;
|
|
|
|
models[1] = NULL;
|
|
|
|
|
2009-09-25 05:53:51 +04:00
|
|
|
if (qemu_show_nic_models(nd->model, models))
|
|
|
|
exit(0);
|
|
|
|
if (qemu_find_nic_model(nd, models, model) < 0)
|
|
|
|
exit(1);
|
2009-01-13 22:03:57 +03:00
|
|
|
}
|
|
|
|
|
2009-09-25 05:53:51 +04:00
|
|
|
int qemu_find_nic_model(NICInfo *nd, const char * const *models,
|
|
|
|
const char *default_model)
|
2009-01-13 22:03:57 +03:00
|
|
|
{
|
2009-09-25 05:53:51 +04:00
|
|
|
int i;
|
2009-01-13 22:03:57 +03:00
|
|
|
|
|
|
|
if (!nd->model)
|
2011-08-21 07:09:37 +04:00
|
|
|
nd->model = g_strdup(default_model);
|
2009-01-13 22:03:57 +03:00
|
|
|
|
2009-09-25 05:53:51 +04:00
|
|
|
for (i = 0 ; models[i]; i++) {
|
|
|
|
if (strcmp(nd->model, models[i]) == 0)
|
|
|
|
return i;
|
2009-01-13 22:03:57 +03:00
|
|
|
}
|
|
|
|
|
2011-06-22 16:03:54 +04:00
|
|
|
error_report("Unsupported NIC model: %s", nd->model);
|
2009-09-25 05:53:51 +04:00
|
|
|
return -1;
|
2009-01-13 22:03:57 +03:00
|
|
|
}
|
|
|
|
|
2012-07-17 18:17:21 +04:00
|
|
|
static int net_init_nic(const NetClientOptions *opts, const char *name,
|
2012-07-24 19:35:13 +04:00
|
|
|
NetClientState *peer)
|
2009-10-06 15:17:06 +04:00
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
NICInfo *nd;
|
2012-07-17 18:17:14 +04:00
|
|
|
const NetLegacyNicOptions *nic;
|
|
|
|
|
|
|
|
assert(opts->kind == NET_CLIENT_OPTIONS_KIND_NIC);
|
|
|
|
nic = opts->nic;
|
2009-10-06 15:17:06 +04:00
|
|
|
|
|
|
|
idx = nic_get_free_idx();
|
|
|
|
if (idx == -1 || nb_nics >= MAX_NICS) {
|
2010-02-18 19:25:24 +03:00
|
|
|
error_report("Too Many NICs");
|
2009-10-06 15:17:06 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
nd = &nd_table[idx];
|
|
|
|
|
|
|
|
memset(nd, 0, sizeof(*nd));
|
|
|
|
|
2012-07-17 18:17:14 +04:00
|
|
|
if (nic->has_netdev) {
|
|
|
|
nd->netdev = qemu_find_netdev(nic->netdev);
|
2009-10-08 22:58:29 +04:00
|
|
|
if (!nd->netdev) {
|
2012-07-17 18:17:14 +04:00
|
|
|
error_report("netdev '%s' not found", nic->netdev);
|
2009-10-08 22:58:29 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
2012-07-24 19:35:05 +04:00
|
|
|
assert(peer);
|
|
|
|
nd->netdev = peer;
|
2009-10-08 22:58:29 +04:00
|
|
|
}
|
2013-01-22 14:07:57 +04:00
|
|
|
nd->name = g_strdup(name);
|
2012-07-17 18:17:14 +04:00
|
|
|
if (nic->has_model) {
|
|
|
|
nd->model = g_strdup(nic->model);
|
2009-10-06 15:17:06 +04:00
|
|
|
}
|
2012-07-17 18:17:14 +04:00
|
|
|
if (nic->has_addr) {
|
|
|
|
nd->devaddr = g_strdup(nic->addr);
|
2009-10-06 15:17:06 +04:00
|
|
|
}
|
|
|
|
|
2012-07-17 18:17:14 +04:00
|
|
|
if (nic->has_macaddr &&
|
|
|
|
net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
|
2010-02-18 19:25:24 +03:00
|
|
|
error_report("invalid syntax for ethernet address");
|
2009-10-06 15:17:06 +04:00
|
|
|
return -1;
|
|
|
|
}
|
2011-07-20 14:20:22 +04:00
|
|
|
qemu_macaddr_default_if_unset(&nd->macaddr);
|
2009-10-06 15:17:06 +04:00
|
|
|
|
2012-07-17 18:17:14 +04:00
|
|
|
if (nic->has_vectors) {
|
|
|
|
if (nic->vectors > 0x7ffffff) {
|
|
|
|
error_report("invalid # of vectors: %"PRIu32, nic->vectors);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
nd->nvectors = nic->vectors;
|
|
|
|
} else {
|
|
|
|
nd->nvectors = DEV_NVECTORS_UNSPECIFIED;
|
2009-10-06 15:17:06 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nd->used = 1;
|
|
|
|
nb_nics++;
|
|
|
|
|
|
|
|
return idx;
|
|
|
|
}
|
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
|
|
|
|
static int (* const net_client_init_fun[NET_CLIENT_OPTIONS_KIND_MAX])(
|
2012-07-17 18:17:21 +04:00
|
|
|
const NetClientOptions *opts,
|
2012-07-17 18:17:13 +04:00
|
|
|
const char *name,
|
2012-07-24 19:35:13 +04:00
|
|
|
NetClientState *peer) = {
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_NIC] = net_init_nic,
|
2009-10-06 15:17:07 +04:00
|
|
|
#ifdef CONFIG_SLIRP
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_USER] = net_init_slirp,
|
2012-02-04 12:24:46 +04:00
|
|
|
#endif
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_TAP] = net_init_tap,
|
|
|
|
[NET_CLIENT_OPTIONS_KIND_SOCKET] = net_init_socket,
|
2009-10-06 15:17:10 +04:00
|
|
|
#ifdef CONFIG_VDE
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_VDE] = net_init_vde,
|
2009-10-06 15:17:10 +04:00
|
|
|
#endif
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_DUMP] = net_init_dump,
|
2012-02-04 12:24:46 +04:00
|
|
|
#ifdef CONFIG_NET_BRIDGE
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_BRIDGE] = net_init_bridge,
|
2012-07-17 18:17:13 +04:00
|
|
|
#endif
|
2012-07-24 19:35:04 +04:00
|
|
|
[NET_CLIENT_OPTIONS_KIND_HUBPORT] = net_init_hubport,
|
2009-10-06 15:17:06 +04:00
|
|
|
};
|
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
|
2012-07-17 18:17:21 +04:00
|
|
|
static int net_client_init1(const void *object, int is_netdev, Error **errp)
|
2009-10-06 15:17:06 +04:00
|
|
|
{
|
2012-07-17 18:17:13 +04:00
|
|
|
union {
|
|
|
|
const Netdev *netdev;
|
|
|
|
const NetLegacy *net;
|
|
|
|
} u;
|
|
|
|
const NetClientOptions *opts;
|
2009-10-08 22:58:21 +04:00
|
|
|
const char *name;
|
2009-10-06 15:17:06 +04:00
|
|
|
|
2010-03-25 19:22:38 +03:00
|
|
|
if (is_netdev) {
|
2012-07-17 18:17:13 +04:00
|
|
|
u.netdev = object;
|
|
|
|
opts = u.netdev->opts;
|
|
|
|
name = u.netdev->id;
|
|
|
|
|
|
|
|
switch (opts->kind) {
|
2009-10-08 22:58:27 +04:00
|
|
|
#ifdef CONFIG_SLIRP
|
2012-07-17 18:17:13 +04:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_USER:
|
2009-10-08 22:58:27 +04:00
|
|
|
#endif
|
2012-07-17 18:17:13 +04:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_TAP:
|
|
|
|
case NET_CLIENT_OPTIONS_KIND_SOCKET:
|
2009-10-08 22:58:27 +04:00
|
|
|
#ifdef CONFIG_VDE
|
2012-07-17 18:17:13 +04:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_VDE:
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_NET_BRIDGE
|
|
|
|
case NET_CLIENT_OPTIONS_KIND_BRIDGE:
|
2009-10-08 22:58:27 +04:00
|
|
|
#endif
|
2012-07-24 19:35:04 +04:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_HUBPORT:
|
2012-07-17 18:17:13 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2012-04-20 23:50:25 +04:00
|
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
|
|
|
|
"a netdev backend type");
|
2009-10-08 22:58:27 +04:00
|
|
|
return -1;
|
|
|
|
}
|
2012-07-17 18:17:13 +04:00
|
|
|
} else {
|
|
|
|
u.net = object;
|
|
|
|
opts = u.net->opts;
|
|
|
|
/* missing optional values have been initialized to "all bits zero" */
|
|
|
|
name = u.net->has_id ? u.net->id : u.net->name;
|
|
|
|
}
|
2009-10-08 22:58:27 +04:00
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
if (net_client_init_fun[opts->kind]) {
|
2012-07-24 19:35:13 +04:00
|
|
|
NetClientState *peer = NULL;
|
2012-07-17 18:17:13 +04:00
|
|
|
|
|
|
|
/* Do not add to a vlan if it's a -netdev or a nic with a netdev=
|
|
|
|
* parameter. */
|
|
|
|
if (!is_netdev &&
|
|
|
|
(opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
|
|
|
|
!opts->nic->has_netdev)) {
|
2012-07-24 19:35:05 +04:00
|
|
|
peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
|
2009-10-08 22:58:27 +04:00
|
|
|
}
|
2012-07-17 18:17:13 +04:00
|
|
|
|
2012-07-24 19:35:05 +04:00
|
|
|
if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
|
2012-07-17 18:17:13 +04:00
|
|
|
/* TODO push error reporting into init() methods */
|
|
|
|
error_set(errp, QERR_DEVICE_INIT_FAILED,
|
|
|
|
NetClientOptionsKind_lookup[opts->kind]);
|
2009-10-08 22:58:27 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2012-07-17 18:17:13 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-08 22:58:27 +04:00
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
static void net_visit(Visitor *v, int is_netdev, void **object, Error **errp)
|
|
|
|
{
|
|
|
|
if (is_netdev) {
|
|
|
|
visit_type_Netdev(v, (Netdev **)object, NULL, errp);
|
|
|
|
} else {
|
|
|
|
visit_type_NetLegacy(v, (NetLegacy **)object, NULL, errp);
|
2009-10-08 22:58:21 +04:00
|
|
|
}
|
2012-07-17 18:17:13 +04:00
|
|
|
}
|
2009-10-08 22:58:21 +04:00
|
|
|
|
2009-10-08 22:58:27 +04:00
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
int net_client_init(QemuOpts *opts, int is_netdev, Error **errp)
|
|
|
|
{
|
|
|
|
void *object = NULL;
|
|
|
|
Error *err = NULL;
|
|
|
|
int ret = -1;
|
2009-10-06 15:17:06 +04:00
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
{
|
|
|
|
OptsVisitor *ov = opts_visitor_new(opts);
|
2009-10-08 22:58:27 +04:00
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
net_visit(opts_get_visitor(ov), is_netdev, &object, &err);
|
|
|
|
opts_visitor_cleanup(ov);
|
2009-10-06 15:17:06 +04:00
|
|
|
}
|
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
if (!err) {
|
2012-07-17 18:17:21 +04:00
|
|
|
ret = net_client_init1(object, is_netdev, &err);
|
2012-07-17 18:17:13 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (object) {
|
|
|
|
QapiDeallocVisitor *dv = qapi_dealloc_visitor_new();
|
|
|
|
|
|
|
|
net_visit(qapi_dealloc_get_visitor(dv), is_netdev, &object, NULL);
|
|
|
|
qapi_dealloc_visitor_cleanup(dv);
|
|
|
|
}
|
|
|
|
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return ret;
|
2009-10-06 15:17:06 +04:00
|
|
|
}
|
|
|
|
|
2012-07-17 18:17:13 +04:00
|
|
|
|
2009-02-11 18:21:54 +03:00
|
|
|
static int net_host_check_device(const char *device)
|
|
|
|
{
|
|
|
|
int i;
|
2009-04-21 23:56:28 +04:00
|
|
|
const char *valid_param_list[] = { "tap", "socket", "dump"
|
2012-02-04 12:24:46 +04:00
|
|
|
#ifdef CONFIG_NET_BRIDGE
|
|
|
|
, "bridge"
|
|
|
|
#endif
|
2009-02-11 18:21:54 +03:00
|
|
|
#ifdef CONFIG_SLIRP
|
|
|
|
,"user"
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_VDE
|
|
|
|
,"vde"
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
|
|
|
|
if (!strncmp(valid_param_list[i], device,
|
|
|
|
strlen(valid_param_list[i])))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-28 22:27:14 +04:00
|
|
|
void net_host_device_add(Monitor *mon, const QDict *qdict)
|
2009-02-11 18:21:54 +03:00
|
|
|
{
|
2009-08-28 22:27:14 +04:00
|
|
|
const char *device = qdict_get_str(qdict, "device");
|
2009-10-06 15:17:13 +04:00
|
|
|
const char *opts_str = qdict_get_try_str(qdict, "opts");
|
2012-04-20 23:50:25 +04:00
|
|
|
Error *local_err = NULL;
|
2009-10-06 15:17:13 +04:00
|
|
|
QemuOpts *opts;
|
2009-08-28 22:27:14 +04:00
|
|
|
|
2009-02-11 18:21:54 +03:00
|
|
|
if (!net_host_check_device(device)) {
|
2009-03-06 02:01:23 +03:00
|
|
|
monitor_printf(mon, "invalid host network device %s\n", device);
|
2009-02-11 18:21:54 +03:00
|
|
|
return;
|
|
|
|
}
|
2009-10-06 15:17:13 +04:00
|
|
|
|
2010-08-20 15:52:01 +04:00
|
|
|
opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
|
2009-10-06 15:17:13 +04:00
|
|
|
if (!opts) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_opt_set(opts, "type", device);
|
|
|
|
|
2012-04-20 23:50:25 +04:00
|
|
|
net_client_init(opts, 0, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
2009-04-21 23:56:32 +04:00
|
|
|
monitor_printf(mon, "adding host network device %s failed\n", device);
|
|
|
|
}
|
2009-02-11 18:21:54 +03:00
|
|
|
}
|
|
|
|
|
2009-08-28 22:27:14 +04:00
|
|
|
void net_host_device_remove(Monitor *mon, const QDict *qdict)
|
2009-02-11 18:21:54 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc;
|
2009-08-28 22:27:14 +04:00
|
|
|
int vlan_id = qdict_get_int(qdict, "vlan_id");
|
|
|
|
const char *device = qdict_get_str(qdict, "device");
|
2009-02-11 18:21:54 +03:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
nc = net_hub_find_client_by_name(vlan_id, device);
|
|
|
|
if (!nc) {
|
2009-02-11 18:21:54 +03:00
|
|
|
return;
|
|
|
|
}
|
2012-07-24 19:35:14 +04:00
|
|
|
if (!net_host_check_device(nc->model)) {
|
2009-04-21 23:56:08 +04:00
|
|
|
monitor_printf(mon, "invalid host network device %s\n", device);
|
|
|
|
return;
|
|
|
|
}
|
2012-07-24 19:35:15 +04:00
|
|
|
qemu_del_net_client(nc);
|
2009-02-11 18:21:54 +03:00
|
|
|
}
|
|
|
|
|
2012-04-19 00:34:15 +04:00
|
|
|
void netdev_add(QemuOpts *opts, Error **errp)
|
|
|
|
{
|
|
|
|
net_client_init(opts, 1, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
int qmp_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret)
|
2010-03-25 19:22:40 +03:00
|
|
|
{
|
2012-04-19 00:24:01 +04:00
|
|
|
Error *local_err = NULL;
|
2012-04-19 00:34:15 +04:00
|
|
|
QemuOptsList *opts_list;
|
2010-03-25 19:22:40 +03:00
|
|
|
QemuOpts *opts;
|
|
|
|
|
2012-04-19 00:34:15 +04:00
|
|
|
opts_list = qemu_find_opts_err("netdev", &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
goto exit_err;
|
2010-03-25 19:22:40 +03:00
|
|
|
}
|
|
|
|
|
2012-04-19 00:34:15 +04:00
|
|
|
opts = qemu_opts_from_qdict(opts_list, qdict, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
goto exit_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
netdev_add(opts, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
2010-06-21 05:41:36 +04:00
|
|
|
qemu_opts_del(opts);
|
2012-04-19 00:34:15 +04:00
|
|
|
goto exit_err;
|
2010-06-21 05:41:36 +04:00
|
|
|
}
|
|
|
|
|
2012-04-19 00:34:15 +04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
exit_err:
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
|
|
|
return -1;
|
2010-03-25 19:22:40 +03:00
|
|
|
}
|
|
|
|
|
2012-04-16 21:36:32 +04:00
|
|
|
void qmp_netdev_del(const char *id, Error **errp)
|
2010-03-25 19:22:40 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc;
|
2012-10-24 16:34:12 +04:00
|
|
|
QemuOpts *opts;
|
2010-03-25 19:22:40 +03:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
nc = qemu_find_netdev(id);
|
|
|
|
if (!nc) {
|
2012-04-16 21:36:32 +04:00
|
|
|
error_set(errp, QERR_DEVICE_NOT_FOUND, id);
|
|
|
|
return;
|
2010-03-25 19:22:40 +03:00
|
|
|
}
|
2012-04-16 21:36:32 +04:00
|
|
|
|
2012-10-24 16:34:12 +04:00
|
|
|
opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), id);
|
|
|
|
if (!opts) {
|
|
|
|
error_setg(errp, "Device '%s' is not a netdev", id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:15 +04:00
|
|
|
qemu_del_net_client(nc);
|
2012-10-24 16:34:12 +04:00
|
|
|
qemu_opts_del(opts);
|
2010-03-25 19:22:40 +03:00
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:16 +04:00
|
|
|
void print_net_client(Monitor *mon, NetClientState *nc)
|
2011-07-20 14:20:21 +04:00
|
|
|
{
|
2013-01-30 15:12:28 +04:00
|
|
|
monitor_printf(mon, "%s: index=%d,type=%s,%s\n", nc->name,
|
|
|
|
nc->queue_index,
|
|
|
|
NetClientOptionsKind_lookup[nc->info->type],
|
|
|
|
nc->info_str);
|
2011-07-20 14:20:21 +04:00
|
|
|
}
|
|
|
|
|
2013-01-14 10:06:25 +04:00
|
|
|
void do_info_network(Monitor *mon, const QDict *qdict)
|
2008-10-31 22:10:00 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc, *peer;
|
2012-07-17 18:17:12 +04:00
|
|
|
NetClientOptionsKind type;
|
2008-10-31 22:10:00 +03:00
|
|
|
|
2012-07-24 19:35:16 +04:00
|
|
|
net_hub_info(mon);
|
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
QTAILQ_FOREACH(nc, &net_clients, next) {
|
|
|
|
peer = nc->peer;
|
|
|
|
type = nc->info->type;
|
2009-10-08 22:58:23 +04:00
|
|
|
|
2012-07-24 19:35:16 +04:00
|
|
|
/* Skip if already printed in hub info */
|
|
|
|
if (net_hub_id_for_client(nc, NULL) == 0) {
|
|
|
|
continue;
|
2009-10-08 22:58:23 +04:00
|
|
|
}
|
2012-07-24 19:35:16 +04:00
|
|
|
|
2012-07-17 18:17:12 +04:00
|
|
|
if (!peer || type == NET_CLIENT_OPTIONS_KIND_NIC) {
|
2012-07-24 19:35:14 +04:00
|
|
|
print_net_client(mon, nc);
|
2011-07-20 14:20:19 +04:00
|
|
|
} /* else it's a netdev connected to a NIC, printed with the NIC */
|
2012-07-17 18:17:12 +04:00
|
|
|
if (peer && type == NET_CLIENT_OPTIONS_KIND_NIC) {
|
2012-07-24 19:35:16 +04:00
|
|
|
monitor_printf(mon, " \\ ");
|
2011-07-20 14:20:21 +04:00
|
|
|
print_net_client(mon, peer);
|
2010-02-11 16:45:01 +03:00
|
|
|
}
|
|
|
|
}
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2011-11-23 19:11:55 +04:00
|
|
|
void qmp_set_link(const char *name, bool up, Error **errp)
|
2009-01-08 22:44:06 +03:00
|
|
|
{
|
2013-01-30 15:12:28 +04:00
|
|
|
NetClientState *ncs[MAX_QUEUE_NUM];
|
|
|
|
NetClientState *nc;
|
|
|
|
int queues, i;
|
2009-01-08 22:44:06 +03:00
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
queues = qemu_find_net_clients_except(name, ncs,
|
|
|
|
NET_CLIENT_OPTIONS_KIND_MAX,
|
|
|
|
MAX_QUEUE_NUM);
|
|
|
|
|
|
|
|
if (queues == 0) {
|
2011-11-23 19:11:55 +04:00
|
|
|
error_set(errp, QERR_DEVICE_NOT_FOUND, name);
|
|
|
|
return;
|
2009-01-08 22:44:06 +03:00
|
|
|
}
|
2013-01-30 15:12:28 +04:00
|
|
|
nc = ncs[0];
|
2009-01-08 22:44:06 +03:00
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
for (i = 0; i < queues; i++) {
|
|
|
|
ncs[i]->link_down = !up;
|
|
|
|
}
|
2009-01-08 22:44:06 +03:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->info->link_status_changed) {
|
|
|
|
nc->info->link_status_changed(nc);
|
2009-11-25 21:49:30 +03:00
|
|
|
}
|
2011-02-09 19:45:04 +03:00
|
|
|
|
|
|
|
/* Notify peer. Don't update peer link status: this makes it possible to
|
|
|
|
* disconnect from host network without notifying the guest.
|
|
|
|
* FIXME: is disconnected link status change operation useful?
|
|
|
|
*
|
|
|
|
* Current behaviour is compatible with qemu vlans where there could be
|
|
|
|
* multiple clients that can still communicate with each other in
|
|
|
|
* disconnected mode. For now maintain this compatibility. */
|
2012-07-24 19:35:14 +04:00
|
|
|
if (nc->peer && nc->peer->info->link_status_changed) {
|
|
|
|
nc->peer->info->link_status_changed(nc->peer);
|
2011-02-09 19:45:04 +03:00
|
|
|
}
|
2009-01-08 22:44:06 +03:00
|
|
|
}
|
|
|
|
|
2008-10-31 22:10:00 +03:00
|
|
|
void net_cleanup(void)
|
|
|
|
{
|
2013-01-30 15:12:28 +04:00
|
|
|
NetClientState *nc;
|
2009-10-08 22:58:28 +04:00
|
|
|
|
2013-01-30 15:12:28 +04:00
|
|
|
/* We may del multiple entries during qemu_del_net_client(),
|
|
|
|
* so QTAILQ_FOREACH_SAFE() is also not safe here.
|
|
|
|
*/
|
|
|
|
while (!QTAILQ_EMPTY(&net_clients)) {
|
|
|
|
nc = QTAILQ_FIRST(&net_clients);
|
2013-01-30 15:12:24 +04:00
|
|
|
if (nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC) {
|
|
|
|
qemu_del_nic(qemu_get_nic(nc));
|
|
|
|
} else {
|
|
|
|
qemu_del_net_client(nc);
|
|
|
|
}
|
2009-10-08 22:58:28 +04:00
|
|
|
}
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
|
|
|
|
2010-02-11 16:44:58 +03:00
|
|
|
void net_check_clients(void)
|
2008-10-31 22:10:00 +03:00
|
|
|
{
|
2012-07-24 19:35:14 +04:00
|
|
|
NetClientState *nc;
|
2011-05-20 19:50:01 +04:00
|
|
|
int i;
|
2008-10-31 22:10:00 +03:00
|
|
|
|
2011-05-20 19:50:00 +04:00
|
|
|
/* Don't warn about the default network setup that you get if
|
|
|
|
* no command line -net or -netdev options are specified. There
|
|
|
|
* are two cases that we would otherwise complain about:
|
|
|
|
* (1) board doesn't support a NIC but the implicit "-net nic"
|
|
|
|
* requested one
|
|
|
|
* (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
|
|
|
|
* sets up a nic that isn't connected to anything.
|
|
|
|
*/
|
|
|
|
if (default_net) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:07 +04:00
|
|
|
net_hub_check_clients();
|
2011-03-15 16:20:54 +03:00
|
|
|
|
2012-07-24 19:35:14 +04:00
|
|
|
QTAILQ_FOREACH(nc, &net_clients, next) {
|
|
|
|
if (!nc->peer) {
|
2010-02-11 16:45:00 +03:00
|
|
|
fprintf(stderr, "Warning: %s %s has no peer\n",
|
2012-07-24 19:35:14 +04:00
|
|
|
nc->info->type == NET_CLIENT_OPTIONS_KIND_NIC ?
|
|
|
|
"nic" : "netdev", nc->name);
|
2010-02-11 16:45:00 +03:00
|
|
|
}
|
|
|
|
}
|
2011-05-20 19:50:01 +04:00
|
|
|
|
|
|
|
/* Check that all NICs requested via -net nic actually got created.
|
|
|
|
* NICs created via -device don't need to be checked here because
|
|
|
|
* they are always instantiated.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < MAX_NICS; i++) {
|
|
|
|
NICInfo *nd = &nd_table[i];
|
|
|
|
if (nd->used && !nd->instantiated) {
|
|
|
|
fprintf(stderr, "Warning: requested NIC (%s, model %s) "
|
|
|
|
"was not created (not supported by this machine?)\n",
|
|
|
|
nd->name ? nd->name : "anonymous",
|
|
|
|
nd->model ? nd->model : "unspecified");
|
|
|
|
}
|
|
|
|
}
|
2008-10-31 22:10:00 +03:00
|
|
|
}
|
2009-10-06 15:17:16 +04:00
|
|
|
|
|
|
|
static int net_init_client(QemuOpts *opts, void *dummy)
|
|
|
|
{
|
2012-04-20 23:50:25 +04:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
net_client_init(opts, 0, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
2009-10-12 12:52:00 +04:00
|
|
|
return -1;
|
2012-04-20 23:50:25 +04:00
|
|
|
}
|
|
|
|
|
2009-10-12 12:52:00 +04:00
|
|
|
return 0;
|
2009-10-08 22:58:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int net_init_netdev(QemuOpts *opts, void *dummy)
|
|
|
|
{
|
2012-04-20 23:50:25 +04:00
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = net_client_init(opts, 1, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2009-10-06 15:17:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int net_init_clients(void)
|
|
|
|
{
|
2010-08-20 15:52:01 +04:00
|
|
|
QemuOptsList *net = qemu_find_opts("net");
|
|
|
|
|
2009-12-08 15:11:47 +03:00
|
|
|
if (default_net) {
|
2009-10-06 15:17:16 +04:00
|
|
|
/* if no clients, we use a default config */
|
2010-08-20 15:52:01 +04:00
|
|
|
qemu_opts_set(net, NULL, "type", "nic");
|
2009-10-06 15:17:16 +04:00
|
|
|
#ifdef CONFIG_SLIRP
|
2010-08-20 15:52:01 +04:00
|
|
|
qemu_opts_set(net, NULL, "type", "user");
|
2009-10-06 15:17:16 +04:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-07-24 19:35:12 +04:00
|
|
|
QTAILQ_INIT(&net_clients);
|
2009-10-08 22:58:23 +04:00
|
|
|
|
2010-08-20 15:52:01 +04:00
|
|
|
if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
|
2009-10-08 22:58:27 +04:00
|
|
|
return -1;
|
|
|
|
|
2010-08-20 15:52:01 +04:00
|
|
|
if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
|
2009-10-06 15:17:16 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-08 22:58:25 +04:00
|
|
|
int net_client_parse(QemuOptsList *opts_list, const char *optarg)
|
2009-10-06 15:17:16 +04:00
|
|
|
{
|
2009-10-08 01:44:15 +04:00
|
|
|
#if defined(CONFIG_SLIRP)
|
2009-11-25 21:48:54 +03:00
|
|
|
int ret;
|
|
|
|
if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
|
2009-10-06 15:17:16 +04:00
|
|
|
return ret;
|
|
|
|
}
|
2009-10-08 01:44:15 +04:00
|
|
|
#endif
|
2009-11-25 21:48:54 +03:00
|
|
|
|
2010-02-10 21:52:18 +03:00
|
|
|
if (!qemu_opts_parse(opts_list, optarg, 1)) {
|
2009-10-06 15:17:16 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-12-08 15:11:47 +03:00
|
|
|
default_net = 0;
|
2009-10-06 15:17:16 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2012-03-05 07:08:50 +04:00
|
|
|
|
|
|
|
/* From FreeBSD */
|
|
|
|
/* XXX: optimize */
|
|
|
|
unsigned compute_mcast_idx(const uint8_t *ep)
|
|
|
|
{
|
|
|
|
uint32_t crc;
|
|
|
|
int carry, i, j;
|
|
|
|
uint8_t b;
|
|
|
|
|
|
|
|
crc = 0xffffffff;
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
|
b = *ep++;
|
|
|
|
for (j = 0; j < 8; j++) {
|
|
|
|
carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
|
|
|
|
crc <<= 1;
|
|
|
|
b >>= 1;
|
|
|
|
if (carry) {
|
|
|
|
crc = ((crc ^ POLYNOMIAL) | carry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return crc >> 26;
|
|
|
|
}
|
2012-11-26 19:03:42 +04:00
|
|
|
|
|
|
|
QemuOptsList qemu_netdev_opts = {
|
|
|
|
.name = "netdev",
|
|
|
|
.implied_opt_name = "type",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
|
|
|
|
.desc = {
|
|
|
|
/*
|
|
|
|
* no elements => accept any params
|
|
|
|
* validation will happen later
|
|
|
|
*/
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
QemuOptsList qemu_net_opts = {
|
|
|
|
.name = "net",
|
|
|
|
.implied_opt_name = "type",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
|
|
|
|
.desc = {
|
|
|
|
/*
|
|
|
|
* no elements => accept any params
|
|
|
|
* validation will happen later
|
|
|
|
*/
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|