vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add a model string to VLANClientState (Mark McLoughlin) 

Don't lose track of what type/model a vlan client is so that we can
e.g. assign a global per-model id to clients.

The entire patch is basically a tedious excercise in making sure the
type/model string gets propagated down to qemu_new_vlan_client().

Signed-off-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>



git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6216 c046a42c-6fe2-441c-8c8c-71466251a162
master
aliguori 2009-01-07 17:42:25 +00:00
parent f7b4a940a4
commit bf38c1a0e1
17 changed files with 74 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hw/e1000.c
View File

@ -1071,8 +1071,8 @@ pci_e1000_init(PCIBus *bus, NICInfo *nd, int devfn)
d->rxbuf_min_shift = 1; d->rxbuf_min_shift = 1;
memset(&d->tx, 0, sizeof d->tx); memset(&d->tx, 0, sizeof d->tx);
d->vc = qemu_new_vlan_client(nd->vlan, e1000_receive, d->vc = qemu_new_vlan_client(nd->vlan, nd->model,
e1000_can_receive, d); e1000_receive, e1000_can_receive, d);
snprintf(d->vc->info_str, sizeof(d->vc->info_str), snprintf(d->vc->info_str, sizeof(d->vc->info_str),
"%s macaddr=%02x:%02x:%02x:%02x:%02x:%02x", info_str, "%s macaddr=%02x:%02x:%02x:%02x:%02x:%02x", info_str,

3
hw/eepro100.c
View File

@ -1776,7 +1776,8 @@ static void nic_init(PCIBus * bus, NICInfo * nd,
nic_reset(s); nic_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, nic_receive, nic_can_receive, s); s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
nic_receive, nic_can_receive, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"eepro100 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x", "eepro100 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

2
hw/etraxfs_eth.c
View File

@ -572,7 +572,7 @@ void *etraxfs_eth_init(NICInfo *nd, CPUState *env,
eth->ethregs = cpu_register_io_memory(0, eth_read, eth_write, eth); eth->ethregs = cpu_register_io_memory(0, eth_read, eth_write, eth);
cpu_register_physical_memory (base, 0x5c, eth->ethregs); cpu_register_physical_memory (base, 0x5c, eth->ethregs);
eth->vc = qemu_new_vlan_client(nd->vlan, eth->vc = qemu_new_vlan_client(nd->vlan, nd->model,
eth_receive, eth_can_receive, eth); eth_receive, eth_can_receive, eth);
return dma; return dma;

4
hw/mcf_fec.c
View File

@ -452,7 +452,7 @@ void mcf_fec_init(NICInfo *nd, target_phys_addr_t base, qemu_irq *irq)
mcf_fec_writefn, s); mcf_fec_writefn, s);
cpu_register_physical_memory(base, 0x400, iomemtype); cpu_register_physical_memory(base, 0x400, iomemtype);
s->vc = qemu_new_vlan_client(nd->vlan, mcf_fec_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
mcf_fec_can_receive, s); mcf_fec_receive, mcf_fec_can_receive, s);
memcpy(s->macaddr, nd->macaddr, 6); memcpy(s->macaddr, nd->macaddr, 6);
} }

4
hw/mipsnet.c
View File

@ -250,8 +250,8 @@ void mipsnet_init (int base, qemu_irq irq, NICInfo *nd)
s->irq = irq; s->irq = irq;
s->nd = nd; s->nd = nd;
if (nd && nd->vlan) { if (nd && nd->vlan) {
s->vc = qemu_new_vlan_client(nd->vlan, mipsnet_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
mipsnet_can_receive, s); mipsnet_receive, mipsnet_can_receive, s);
} else { } else {
s->vc = NULL; s->vc = NULL;
} }

3
hw/musicpal.c
View File

@ -718,7 +718,8 @@ static void mv88w8618_eth_init(NICInfo *nd, uint32_t base, qemu_irq irq)
if (!s) if (!s)
return; return;
s->irq = irq; s->irq = irq;
s->vc = qemu_new_vlan_client(nd->vlan, eth_receive, eth_can_receive, s); s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
eth_receive, eth_can_receive, s);
iomemtype = cpu_register_io_memory(0, mv88w8618_eth_readfn, iomemtype = cpu_register_io_memory(0, mv88w8618_eth_readfn,
mv88w8618_eth_writefn, s); mv88w8618_eth_writefn, s);
cpu_register_physical_memory(base, MP_ETH_SIZE, iomemtype); cpu_register_physical_memory(base, MP_ETH_SIZE, iomemtype);

8
hw/ne2000.c
View File

@ -741,8 +741,8 @@ void isa_ne2000_init(int base, qemu_irq irq, NICInfo *nd)
ne2000_reset(s); ne2000_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, ne2000_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
ne2000_can_receive, s); ne2000_receive, ne2000_can_receive, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"ne2000 macaddr=%02x:%02x:%02x:%02x:%02x:%02x", "ne2000 macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
@ -811,8 +811,8 @@ void pci_ne2000_init(PCIBus *bus, NICInfo *nd, int devfn)
s->pci_dev = (PCIDevice *)d; s->pci_dev = (PCIDevice *)d;
memcpy(s->macaddr, nd->macaddr, 6); memcpy(s->macaddr, nd->macaddr, 6);
ne2000_reset(s); ne2000_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, ne2000_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
ne2000_can_receive, s); ne2000_receive, ne2000_can_receive, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"ne2000 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x", "ne2000 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

4
hw/pcnet.c
View File

@ -1936,8 +1936,8 @@ static void pcnet_common_init(PCNetState *d, NICInfo *nd, const char *info_str)
d->nd = nd; d->nd = nd;
if (nd && nd->vlan) { if (nd && nd->vlan) {
d->vc = qemu_new_vlan_client(nd->vlan, pcnet_receive, d->vc = qemu_new_vlan_client(nd->vlan, nd->model,
pcnet_can_receive, d); pcnet_receive, pcnet_can_receive, d);
snprintf(d->vc->info_str, sizeof(d->vc->info_str), snprintf(d->vc->info_str, sizeof(d->vc->info_str),
"pcnet macaddr=%02x:%02x:%02x:%02x:%02x:%02x", "pcnet macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

4
hw/rtl8139.c
View File

@ -3438,8 +3438,8 @@ void pci_rtl8139_init(PCIBus *bus, NICInfo *nd, int devfn)
s->pci_dev = (PCIDevice *)d; s->pci_dev = (PCIDevice *)d;
memcpy(s->macaddr, nd->macaddr, 6); memcpy(s->macaddr, nd->macaddr, 6);
rtl8139_reset(s); rtl8139_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, rtl8139_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
rtl8139_can_receive, s); rtl8139_receive, rtl8139_can_receive, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"rtl8139 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x", "rtl8139 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

4
hw/smc91c111.c
View File

@ -704,7 +704,7 @@ void smc91c111_init(NICInfo *nd, uint32_t base, qemu_irq irq)
smc91c111_reset(s); smc91c111_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, smc91c111_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
smc91c111_can_receive, s); smc91c111_receive, smc91c111_can_receive, s);
/* ??? Save/restore. */ /* ??? Save/restore. */
} }

4
hw/stellaris_enet.c
View File

@ -397,8 +397,8 @@ void stellaris_enet_init(NICInfo *nd, uint32_t base, qemu_irq irq)
memcpy(s->macaddr, nd->macaddr, 6); memcpy(s->macaddr, nd->macaddr, 6);
if (nd->vlan) if (nd->vlan)
s->vc = qemu_new_vlan_client(nd->vlan, stellaris_enet_receive, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
stellaris_enet_can_receive, s); stellaris_enet_receive, stellaris_enet_can_receive, s);
stellaris_enet_reset(s); stellaris_enet_reset(s);
register_savevm("stellaris_enet", -1, 1, register_savevm("stellaris_enet", -1, 1,

2
hw/usb-net.c
View File

@ -1453,7 +1453,7 @@ USBDevice *usb_net_init(NICInfo *nd)
pstrcpy(s->dev.devname, sizeof(s->dev.devname), pstrcpy(s->dev.devname, sizeof(s->dev.devname),
"QEMU USB Network Interface"); "QEMU USB Network Interface");
s->vc = qemu_new_vlan_client(nd->vlan, s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
usbnet_receive, usbnet_can_receive, s); usbnet_receive, usbnet_can_receive, s);
snprintf(s->usbstring_mac, sizeof(s->usbstring_mac), snprintf(s->usbstring_mac, sizeof(s->usbstring_mac),

4
hw/virtio-net.c
View File

@ -315,8 +315,8 @@ PCIDevice *virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn)
n->rx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_rx); n->rx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_rx);
n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx); n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx);
memcpy(n->mac, nd->macaddr, 6); memcpy(n->mac, nd->macaddr, 6);
n->vc = qemu_new_vlan_client(nd->vlan, virtio_net_receive, n->vc = qemu_new_vlan_client(nd->vlan, nd->model,
virtio_net_can_receive, n); virtio_net_receive, virtio_net_can_receive, n);
n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n); n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);
n->tx_timer_active = 0; n->tx_timer_active = 0;

78
net.c
View File

@ -297,6 +297,7 @@ static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
#endif #endif
VLANClientState *qemu_new_vlan_client(VLANState *vlan, VLANClientState *qemu_new_vlan_client(VLANState *vlan,
const char *model,
IOReadHandler *fd_read, IOReadHandler *fd_read,
IOCanRWHandler *fd_can_read, IOCanRWHandler *fd_can_read,
void *opaque) void *opaque)
@ -305,6 +306,7 @@ VLANClientState *qemu_new_vlan_client(VLANState *vlan,
vc = qemu_mallocz(sizeof(VLANClientState)); vc = qemu_mallocz(sizeof(VLANClientState));
if (!vc) if (!vc)
return NULL; return NULL;
vc->model = strdup(model);
vc->fd_read = fd_read; vc->fd_read = fd_read;
vc->fd_can_read = fd_can_read; vc->fd_can_read = fd_can_read;
vc->opaque = opaque; vc->opaque = opaque;
@ -325,6 +327,7 @@ void qemu_del_vlan_client(VLANClientState *vc)
while (*pvc != NULL) while (*pvc != NULL)
if (*pvc == vc) { if (*pvc == vc) {
*pvc = vc->next; *pvc = vc->next;
free(vc->model);
free(vc); free(vc);
break; break;
} else } else
@ -442,13 +445,13 @@ static void slirp_receive(void *opaque, const uint8_t *buf, int size)
slirp_input(buf, size); slirp_input(buf, size);
} }
static int net_slirp_init(VLANState *vlan) static int net_slirp_init(VLANState *vlan, const char *model)
{ {
if (!slirp_inited) { if (!slirp_inited) {
slirp_inited = 1; slirp_inited = 1;
slirp_init(); slirp_init();
} }
slirp_vc = qemu_new_vlan_client(vlan, slirp_vc = qemu_new_vlan_client(vlan, model,
slirp_receive, NULL, NULL); slirp_receive, NULL, NULL);
snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector"); snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
return 0; return 0;
@ -662,7 +665,7 @@ static void tap_send(void *opaque)
/* fd support */ /* fd support */
static TAPState *net_tap_fd_init(VLANState *vlan, int fd) static TAPState *net_tap_fd_init(VLANState *vlan, const char *model, int fd)
{ {
TAPState *s; TAPState *s;
@ -670,7 +673,7 @@ static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
if (!s) if (!s)
return NULL; return NULL;
s->fd = fd; s->fd = fd;
s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s); s->vc = qemu_new_vlan_client(vlan, model, tap_receive, NULL, s);
#ifdef HAVE_IOVEC #ifdef HAVE_IOVEC
s->vc->fd_readv = tap_receive_iov; s->vc->fd_readv = tap_receive_iov;
#endif #endif
@ -905,7 +908,7 @@ static int launch_script(const char *setup_script, const char *ifname, int fd)
return 0; return 0;
} }
static int net_tap_init(VLANState *vlan, const char *ifname1, static int net_tap_init(VLANState *vlan, const char *model, const char *ifname1,
const char *setup_script, const char *down_script) const char *setup_script, const char *down_script)
{ {
TAPState *s; TAPState *s;
@ -926,7 +929,7 @@ static int net_tap_init(VLANState *vlan, const char *ifname1,
if (launch_script(setup_script, ifname, fd)) if (launch_script(setup_script, ifname, fd))
return -1; return -1;
} }
s = net_tap_fd_init(vlan, fd); s = net_tap_fd_init(vlan, model, fd);
if (!s) if (!s)
return -1; return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
@ -969,8 +972,8 @@ static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
} }
} }
static int net_vde_init(VLANState *vlan, const char *sock, int port, static int net_vde_init(VLANState *vlan, const char *model, const char *sock,
const char *group, int mode) int port, const char *group, int mode)
{ {
VDEState *s; VDEState *s;
char *init_group = strlen(group) ? (char *)group : NULL; char *init_group = strlen(group) ? (char *)group : NULL;
@ -990,7 +993,7 @@ static int net_vde_init(VLANState *vlan, const char *sock, int port,
free(s); free(s);
return -1; return -1;
} }
s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s); s->vc = qemu_new_vlan_client(vlan, model, vde_from_qemu, NULL, s);
qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s); qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d", snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
sock, vde_datafd(s->vde)); sock, vde_datafd(s->vde));
@ -1011,6 +1014,7 @@ typedef struct NetSocketState {
typedef struct NetSocketListenState { typedef struct NetSocketListenState {
VLANState *vlan; VLANState *vlan;
char *model;
int fd; int fd;
} NetSocketListenState; } NetSocketListenState;
@ -1164,8 +1168,8 @@ fail:
return -1; return -1;
} }
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd, static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, const char *model,
int is_connected) int fd, int is_connected)
{ {
struct sockaddr_in saddr; struct sockaddr_in saddr;
int newfd; int newfd;
@ -1208,7 +1212,7 @@ static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
return NULL; return NULL;
s->fd = fd; s->fd = fd;
s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s); s->vc = qemu_new_vlan_client(vlan, model, net_socket_receive_dgram, NULL, s);
qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s); qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
/* mcast: save bound address as dst */ /* mcast: save bound address as dst */
@ -1227,15 +1231,15 @@ static void net_socket_connect(void *opaque)
qemu_set_fd_handler(s->fd, net_socket_send, NULL, s); qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
} }
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd, static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, const char *model,
int is_connected) int fd, int is_connected)
{ {
NetSocketState *s; NetSocketState *s;
s = qemu_mallocz(sizeof(NetSocketState)); s = qemu_mallocz(sizeof(NetSocketState));
if (!s) if (!s)
return NULL; return NULL;
s->fd = fd; s->fd = fd;
s->vc = qemu_new_vlan_client(vlan, s->vc = qemu_new_vlan_client(vlan, model,
net_socket_receive, NULL, s); net_socket_receive, NULL, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"socket: fd=%d", fd); "socket: fd=%d", fd);
@ -1247,8 +1251,8 @@ static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
return s; return s;
} }
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd, static NetSocketState *net_socket_fd_init(VLANState *vlan, const char *model,
int is_connected) int fd, int is_connected)
{ {
int so_type=-1, optlen=sizeof(so_type); int so_type=-1, optlen=sizeof(so_type);
@ -1259,13 +1263,13 @@ static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
} }
switch(so_type) { switch(so_type) {
case SOCK_DGRAM: case SOCK_DGRAM:
return net_socket_fd_init_dgram(vlan, fd, is_connected); return net_socket_fd_init_dgram(vlan, model, fd, is_connected);
case SOCK_STREAM: case SOCK_STREAM:
return net_socket_fd_init_stream(vlan, fd, is_connected); return net_socket_fd_init_stream(vlan, model, fd, is_connected);
default: default:
/* who knows ... this could be a eg. a pty, do warn and continue as stream */ /* who knows ... this could be a eg. a pty, do warn and continue as stream */
fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd); fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
return net_socket_fd_init_stream(vlan, fd, is_connected); return net_socket_fd_init_stream(vlan, model, fd, is_connected);
} }
return NULL; return NULL;
} }
@ -1287,7 +1291,7 @@ static void net_socket_accept(void *opaque)
break; break;
} }
} }
s1 = net_socket_fd_init(s->vlan, fd, 1); s1 = net_socket_fd_init(s->vlan, s->model, fd, 1);
if (!s1) { if (!s1) {
closesocket(fd); closesocket(fd);
} else { } else {
@ -1297,7 +1301,8 @@ static void net_socket_accept(void *opaque)
} }
} }
static int net_socket_listen_init(VLANState *vlan, const char *host_str) static int net_socket_listen_init(VLANState *vlan, const char *model,
const char *host_str)
{ {
NetSocketListenState *s; NetSocketListenState *s;
int fd, val, ret; int fd, val, ret;
@ -1332,12 +1337,14 @@ static int net_socket_listen_init(VLANState *vlan, const char *host_str)
return -1; return -1;
} }
s->vlan = vlan; s->vlan = vlan;
s->model = strdup(model);
s->fd = fd; s->fd = fd;
qemu_set_fd_handler(fd, net_socket_accept, NULL, s); qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
return 0; return 0;
} }
static int net_socket_connect_init(VLANState *vlan, const char *host_str) static int net_socket_connect_init(VLANState *vlan, const char *model,
const char *host_str)
{ {
NetSocketState *s; NetSocketState *s;
int fd, connected, ret, err; int fd, connected, ret, err;
@ -1375,7 +1382,7 @@ static int net_socket_connect_init(VLANState *vlan, const char *host_str)
break; break;
} }
} }
s = net_socket_fd_init(vlan, fd, connected); s = net_socket_fd_init(vlan, model, fd, connected);
if (!s) if (!s)
return -1; return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
@ -1384,7 +1391,8 @@ static int net_socket_connect_init(VLANState *vlan, const char *host_str)
return 0; return 0;
} }
static int net_socket_mcast_init(VLANState *vlan, const char *host_str) static int net_socket_mcast_init(VLANState *vlan, const char *model,
const char *host_str)
{ {
NetSocketState *s; NetSocketState *s;
int fd; int fd;
@ -1398,7 +1406,7 @@ static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
if (fd < 0) if (fd < 0)
return -1; return -1;
s = net_socket_fd_init(vlan, fd, 0); s = net_socket_fd_init(vlan, model, fd, 0);
if (!s) if (!s)
return -1; return -1;
@ -1488,7 +1496,7 @@ int net_client_init(const char *device, const char *p)
pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf); pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
} }
vlan->nb_host_devs++; vlan->nb_host_devs++;
ret = net_slirp_init(vlan); ret = net_slirp_init(vlan, device);
} else } else
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
@ -1499,7 +1507,7 @@ int net_client_init(const char *device, const char *p)
return -1; return -1;
} }
vlan->nb_host_devs++; vlan->nb_host_devs++;
ret = tap_win32_init(vlan, ifname); ret = tap_win32_init(vlan, device, ifname);
} else } else
#elif defined (_AIX) #elif defined (_AIX)
#else #else
@ -1512,7 +1520,7 @@ int net_client_init(const char *device, const char *p)
fd = strtol(buf, NULL, 0); fd = strtol(buf, NULL, 0);
fcntl(fd, F_SETFL, O_NONBLOCK); fcntl(fd, F_SETFL, O_NONBLOCK);
ret = -1; ret = -1;
if (net_tap_fd_init(vlan, fd)) if (net_tap_fd_init(vlan, device, fd))
ret = 0; ret = 0;
} else { } else {
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) { if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
@ -1524,7 +1532,7 @@ int net_client_init(const char *device, const char *p)
if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) { if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT); pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
} }
ret = net_tap_init(vlan, ifname, setup_script, down_script); ret = net_tap_init(vlan, device, ifname, setup_script, down_script);
} }
} else } else
#endif #endif
@ -1533,14 +1541,14 @@ int net_client_init(const char *device, const char *p)
int fd; int fd;
fd = strtol(buf, NULL, 0); fd = strtol(buf, NULL, 0);
ret = -1; ret = -1;
if (net_socket_fd_init(vlan, fd, 1)) if (net_socket_fd_init(vlan, device, fd, 1))
ret = 0; ret = 0;
} else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) { } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
ret = net_socket_listen_init(vlan, buf); ret = net_socket_listen_init(vlan, device, buf);
} else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) { } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
ret = net_socket_connect_init(vlan, buf); ret = net_socket_connect_init(vlan, device, buf);
} else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) { } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
ret = net_socket_mcast_init(vlan, buf); ret = net_socket_mcast_init(vlan, device, buf);
} else { } else {
fprintf(stderr, "Unknown socket options: %s\n", p); fprintf(stderr, "Unknown socket options: %s\n", p);
return -1; return -1;
@ -1568,7 +1576,7 @@ int net_client_init(const char *device, const char *p)
} else { } else {
vde_mode = 0700; vde_mode = 0700;
} }
ret = net_vde_init(vlan, vde_sock, vde_port, vde_group, vde_mode); ret = net_vde_init(vlan, device, vde_sock, vde_port, vde_group, vde_mode);
} else } else
#endif #endif
{ {

2
net.h
View File

@ -18,6 +18,7 @@ struct VLANClientState {
void *opaque; void *opaque;
struct VLANClientState *next; struct VLANClientState *next;
struct VLANState *vlan; struct VLANState *vlan;
char *model;
char info_str[256]; char info_str[256];
}; };
@ -30,6 +31,7 @@ struct VLANState {
VLANState *qemu_find_vlan(int id); VLANState *qemu_find_vlan(int id);
VLANClientState *qemu_new_vlan_client(VLANState *vlan, VLANClientState *qemu_new_vlan_client(VLANState *vlan,
const char *model,
IOReadHandler *fd_read, IOReadHandler *fd_read,
IOCanRWHandler *fd_can_read, IOCanRWHandler *fd_can_read,
void *opaque); void *opaque);

2
sysemu.h
View File

@ -75,7 +75,7 @@ void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
#endif #endif
/* TAP win32 */ /* TAP win32 */
int tap_win32_init(VLANState *vlan, const char *ifname); int tap_win32_init(VLANState *vlan, const char *model, const char *ifname);
/* SLIRP */ /* SLIRP */
void do_info_slirp(void); void do_info_slirp(void);

4
tap-win32.c
View File

@ -660,7 +660,7 @@ static void tap_win32_send(void *opaque)
} }
} }
int tap_win32_init(VLANState *vlan, const char *ifname) int tap_win32_init(VLANState *vlan, const char *model, const char *ifname)
{ {
TAPState *s; TAPState *s;
@ -672,7 +672,7 @@ int tap_win32_init(VLANState *vlan, const char *ifname)
return -1; return -1;
} }
s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s); s->vc = qemu_new_vlan_client(vlan, model, tap_receive, NULL, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str), snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"tap: ifname=%s", ifname); "tap: ifname=%s", ifname);