d->rxbuf_min_shift = 1;
memset(&d->tx, 0, sizeof d->tx);
- d->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ d->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
e1000_receive, e1000_can_receive, d);
qemu_format_nic_info_str(d->vc, d->nd->macaddr);
nic_reset(s);
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
nic_receive, nic_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
eth->ethregs = cpu_register_io_memory(0, eth_read, eth_write, eth);
cpu_register_physical_memory (base, 0x5c, eth->ethregs);
- eth->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ eth->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
eth_receive, eth_can_receive, eth);
return dma;
mcf_fec_writefn, s);
cpu_register_physical_memory(base, 0x400, iomemtype);
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
mcf_fec_receive, mcf_fec_can_receive, s);
memcpy(s->macaddr, nd->macaddr, 6);
qemu_format_nic_info_str(n->vc, s->macaddr);
s->irq = irq;
s->nd = nd;
if (nd && nd->vlan) {
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
mipsnet_receive, mipsnet_can_receive, s);
} else {
s->vc = NULL;
if (!s)
return;
s->irq = irq;
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
eth_receive, eth_can_receive, s);
iomemtype = cpu_register_io_memory(0, mv88w8618_eth_readfn,
mv88w8618_eth_writefn, s);
ne2000_reset(s);
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
ne2000_receive, ne2000_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
s->pci_dev = (PCIDevice *)d;
memcpy(s->macaddr, nd->macaddr, 6);
ne2000_reset(s);
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
ne2000_receive, ne2000_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
d->nd = nd;
if (nd && nd->vlan) {
- d->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ d->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
pcnet_receive, pcnet_can_receive, d);
qemu_format_nic_info_str(d->vc, d->nd->macaddr);
s->pci_dev = (PCIDevice *)d;
memcpy(s->macaddr, nd->macaddr, 6);
rtl8139_reset(s);
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
rtl8139_receive, rtl8139_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
smc91c111_reset(s);
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
smc91c111_receive, smc91c111_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
/* ??? Save/restore. */
memcpy(s->macaddr, nd->macaddr, 6);
if (nd->vlan) {
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
stellaris_enet_receive, stellaris_enet_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
}
pstrcpy(s->dev.devname, sizeof(s->dev.devname),
"QEMU USB Network Interface");
- s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
usbnet_receive, usbnet_can_receive, s);
qemu_format_nic_info_str(s->vc, s->mac);
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);
memcpy(n->mac, nd->macaddr, 6);
- n->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+ n->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
virtio_net_receive, virtio_net_can_receive, n);
qemu_format_nic_info_str(n->vc, n->mac);
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
const char *model,
+ const char *name,
IOReadHandler *fd_read,
IOCanRWHandler *fd_can_read,
void *opaque)
if (!vc)
return NULL;
vc->model = strdup(model);
- vc->name = assign_name(vc, model);
+ if (name)
+ vc->name = strdup(name);
+ else
+ vc->name = assign_name(vc, model);
vc->fd_read = fd_read;
vc->fd_can_read = fd_can_read;
vc->opaque = opaque;
slirp_input(buf, size);
}
-static int net_slirp_init(VLANState *vlan, const char *model)
+static int net_slirp_init(VLANState *vlan, const char *model, const char *name)
{
if (!slirp_inited) {
slirp_inited = 1;
slirp_init();
}
- slirp_vc = qemu_new_vlan_client(vlan, model,
+ slirp_vc = qemu_new_vlan_client(vlan, model, name,
slirp_receive, NULL, NULL);
slirp_vc->info_str[0] = '\0';
return 0;
/* fd support */
-static TAPState *net_tap_fd_init(VLANState *vlan, const char *model, int fd)
+static TAPState *net_tap_fd_init(VLANState *vlan,
+ const char *model,
+ const char *name,
+ int fd)
{
TAPState *s;
if (!s)
return NULL;
s->fd = fd;
- s->vc = qemu_new_vlan_client(vlan, model, tap_receive, NULL, s);
+ s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive, NULL, s);
#ifdef HAVE_IOVEC
s->vc->fd_readv = tap_receive_iov;
#endif
return 0;
}
-static int net_tap_init(VLANState *vlan, const char *model, const char *ifname1,
+static int net_tap_init(VLANState *vlan, const char *model,
+ const char *name, const char *ifname1,
const char *setup_script, const char *down_script)
{
TAPState *s;
if (launch_script(setup_script, ifname, fd))
return -1;
}
- s = net_tap_fd_init(vlan, model, fd);
+ s = net_tap_fd_init(vlan, model, name, fd);
if (!s)
return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
}
}
-static int net_vde_init(VLANState *vlan, const char *model, const char *sock,
+static int net_vde_init(VLANState *vlan, const char *model,
+ const char *name, const char *sock,
int port, const char *group, int mode)
{
VDEState *s;
free(s);
return -1;
}
- s->vc = qemu_new_vlan_client(vlan, model, vde_from_qemu, NULL, s);
+ s->vc = qemu_new_vlan_client(vlan, model, name, vde_from_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), "sock=%s,fd=%d",
sock, vde_datafd(s->vde));
typedef struct NetSocketListenState {
VLANState *vlan;
char *model;
+ char *name;
int fd;
} NetSocketListenState;
return -1;
}
-static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, const char *model,
+static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
+ const char *model,
+ const char *name,
int fd, int is_connected)
{
struct sockaddr_in saddr;
return NULL;
s->fd = fd;
- s->vc = qemu_new_vlan_client(vlan, model, net_socket_receive_dgram, NULL, s);
+ s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive_dgram, NULL, s);
qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
/* mcast: save bound address as dst */
qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
}
-static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, const char *model,
+static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
+ const char *model,
+ const char *name,
int fd, int is_connected)
{
NetSocketState *s;
if (!s)
return NULL;
s->fd = fd;
- s->vc = qemu_new_vlan_client(vlan, model,
+ s->vc = qemu_new_vlan_client(vlan, model, name,
net_socket_receive, NULL, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"socket: fd=%d", fd);
return s;
}
-static NetSocketState *net_socket_fd_init(VLANState *vlan, const char *model,
+static NetSocketState *net_socket_fd_init(VLANState *vlan,
+ const char *model, const char *name,
int fd, int is_connected)
{
int so_type=-1, optlen=sizeof(so_type);
}
switch(so_type) {
case SOCK_DGRAM:
- return net_socket_fd_init_dgram(vlan, model, fd, is_connected);
+ return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
case SOCK_STREAM:
- return net_socket_fd_init_stream(vlan, model, fd, is_connected);
+ return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
default:
/* 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);
- return net_socket_fd_init_stream(vlan, model, fd, is_connected);
+ return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
}
return NULL;
}
break;
}
}
- s1 = net_socket_fd_init(s->vlan, s->model, fd, 1);
+ s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
if (!s1) {
closesocket(fd);
} else {
}
}
-static int net_socket_listen_init(VLANState *vlan, const char *model,
+static int net_socket_listen_init(VLANState *vlan,
+ const char *model,
+ const char *name,
const char *host_str)
{
NetSocketListenState *s;
}
s->vlan = vlan;
s->model = strdup(model);
+ s->name = strdup(name);
s->fd = fd;
qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
return 0;
}
-static int net_socket_connect_init(VLANState *vlan, const char *model,
+static int net_socket_connect_init(VLANState *vlan,
+ const char *model,
+ const char *name,
const char *host_str)
{
NetSocketState *s;
break;
}
}
- s = net_socket_fd_init(vlan, model, fd, connected);
+ s = net_socket_fd_init(vlan, model, name, fd, connected);
if (!s)
return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
return 0;
}
-static int net_socket_mcast_init(VLANState *vlan, const char *model,
+static int net_socket_mcast_init(VLANState *vlan,
+ const char *model,
+ const char *name,
const char *host_str)
{
NetSocketState *s;
if (fd < 0)
return -1;
- s = net_socket_fd_init(vlan, model, fd, 0);
+ s = net_socket_fd_init(vlan, model, name, fd, 0);
if (!s)
return -1;
char buf[1024];
int vlan_id, ret;
VLANState *vlan;
+ char *name = NULL;
vlan_id = 0;
if (get_param_value(buf, sizeof(buf), "vlan", p)) {
fprintf(stderr, "Could not create vlan %d\n", vlan_id);
return -1;
}
+ if (get_param_value(buf, sizeof(buf), "name", p)) {
+ name = strdup(buf);
+ }
if (!strcmp(device, "nic")) {
NICInfo *nd;
uint8_t *macaddr;
nd->model = strdup(buf);
}
nd->vlan = vlan;
+ nd->name = name;
+ name = NULL;
nb_nics++;
vlan->nb_guest_devs++;
ret = 0;
pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
}
vlan->nb_host_devs++;
- ret = net_slirp_init(vlan, device);
+ ret = net_slirp_init(vlan, device, name);
} else
#endif
#ifdef _WIN32
return -1;
}
vlan->nb_host_devs++;
- ret = tap_win32_init(vlan, device, ifname);
+ ret = tap_win32_init(vlan, device, name, ifname);
} else
#elif defined (_AIX)
#else
fd = strtol(buf, NULL, 0);
fcntl(fd, F_SETFL, O_NONBLOCK);
ret = -1;
- if (net_tap_fd_init(vlan, device, fd))
+ if (net_tap_fd_init(vlan, device, name, fd))
ret = 0;
} else {
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
}
- ret = net_tap_init(vlan, device, ifname, setup_script, down_script);
+ ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
}
} else
#endif
int fd;
fd = strtol(buf, NULL, 0);
ret = -1;
- if (net_socket_fd_init(vlan, device, fd, 1))
+ if (net_socket_fd_init(vlan, device, name, fd, 1))
ret = 0;
} else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
- ret = net_socket_listen_init(vlan, device, buf);
+ ret = net_socket_listen_init(vlan, device, name, buf);
} else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
- ret = net_socket_connect_init(vlan, device, buf);
+ ret = net_socket_connect_init(vlan, device, name, buf);
} else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
- ret = net_socket_mcast_init(vlan, device, buf);
+ ret = net_socket_mcast_init(vlan, device, name, buf);
} else {
fprintf(stderr, "Unknown socket options: %s\n", p);
return -1;
} else {
vde_mode = 0700;
}
- ret = net_vde_init(vlan, device, vde_sock, vde_port, vde_group, vde_mode);
+ ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode);
} else
#endif
{
fprintf(stderr, "Unknown network device: %s\n", device);
+ if (name)
+ free(name);
return -1;
}
if (ret < 0) {
fprintf(stderr, "Could not initialize device '%s'\n", device);
}
-
+ if (name)
+ free(name);
return ret;
}
VLANState *qemu_find_vlan(int id);
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
const char *model,
+ const char *name,
IOReadHandler *fd_read,
IOCanRWHandler *fd_can_read,
void *opaque);
struct NICInfo {
uint8_t macaddr[6];
const char *model;
+ const char *name;
VLANState *vlan;
};
@table @option
-@item -net nic[,vlan=@var{n}][,macaddr=@var{addr}][,model=@var{type}]
+@item -net nic[,vlan=@var{n}][,macaddr=@var{addr}][,model=@var{type}][,name=@var{name}]
Create a new Network Interface Card and connect it to VLAN @var{n} (@var{n}
= 0 is the default). The NIC is an ne2k_pci by default on the PC
-target. Optionally, the MAC address can be changed. If no
+target. Optionally, the MAC address can be changed to @var{addr}
+and a @var{name} can be assigned for use in monitor commands. If no
@option{-net} option is specified, a single NIC is created.
Qemu can emulate several different models of network card.
Valid values for @var{type} are
Not all devices are supported on all targets. Use -net nic,model=?
for a list of available devices for your target.
-@item -net user[,vlan=@var{n}][,hostname=@var{name}]
+@item -net user[,vlan=@var{n}][,hostname=@var{name}][,name=@var{name}]
Use the user mode network stack which requires no administrator
privilege to run. @option{hostname=name} can be used to specify the client
hostname reported by the builtin DHCP server.
-@item -net tap[,vlan=@var{n}][,fd=@var{h}][,ifname=@var{name}][,script=@var{file}][,downscript=@var{dfile}]
+@item -net tap[,vlan=@var{n}][,name=@var{name}][,fd=@var{h}][,ifname=@var{name}][,script=@var{file}][,downscript=@var{dfile}]
Connect the host TAP network interface @var{name} to VLAN @var{n}, use
the network script @var{file} to configure it and the network script
@var{dfile} to deconfigure it. If @var{name} is not provided, the OS
@end example
-@item -net socket[,vlan=@var{n}][,fd=@var{h}][,listen=[@var{host}]:@var{port}][,connect=@var{host}:@var{port}]
+@item -net socket[,vlan=@var{n}][,name=@var{name}][,fd=@var{h}][,listen=[@var{host}]:@var{port}][,connect=@var{host}:@var{port}]
Connect the VLAN @var{n} to a remote VLAN in another QEMU virtual
machine using a TCP socket connection. If @option{listen} is
-net socket,connect=127.0.0.1:1234
@end example
-@item -net socket[,vlan=@var{n}][,fd=@var{h}][,mcast=@var{maddr}:@var{port}]
+@item -net socket[,vlan=@var{n}][,name=@var{name}][,fd=@var{h}][,mcast=@var{maddr}:@var{port}]
Create a VLAN @var{n} shared with another QEMU virtual
machines using a UDP multicast socket, effectively making a bus for
/path/to/linux ubd0=/path/to/root_fs eth0=mcast
@end example
-@item -net vde[,vlan=@var{n}][,sock=@var{socketpath}][,port=@var{n}][,group=@var{groupname}][,mode=@var{octalmode}]
+@item -net vde[,vlan=@var{n}][,name=@var{name}][,sock=@var{socketpath}][,port=@var{n}][,group=@var{groupname}][,mode=@var{octalmode}]
Connect VLAN @var{n} to PORT @var{n} of a vde switch running on host and
listening for incoming connections on @var{socketpath}. Use GROUP @var{groupname}
and MODE @var{octalmode} to change default ownership and permissions for
#endif
/* TAP win32 */
-int tap_win32_init(VLANState *vlan, const char *model, const char *ifname);
+int tap_win32_init(VLANState *vlan, const char *model,
+ const char *name, const char *ifname);
/* SLIRP */
void do_info_slirp(void);
}
}
-int tap_win32_init(VLANState *vlan, const char *model, const char *ifname)
+int tap_win32_init(VLANState *vlan, const char *model,
+ const char *name, const char *ifname)
{
TAPState *s;
return -1;
}
- s->vc = qemu_new_vlan_client(vlan, model, tap_receive, NULL, s);
+ s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive, NULL, s);
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"tap: ifname=%s", ifname);
"-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
"\n"
"Network options:\n"
- "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
+ "-net nic[,vlan=n][,macaddr=addr][,model=type][,name=str]\n"
" create a new Network Interface Card and connect it to VLAN 'n'\n"
#ifdef CONFIG_SLIRP
- "-net user[,vlan=n][,hostname=host]\n"
+ "-net user[,vlan=n][,name=str][,hostname=host]\n"
" connect the user mode network stack to VLAN 'n' and send\n"
" hostname 'host' to DHCP clients\n"
#endif
#ifdef _WIN32
- "-net tap[,vlan=n],ifname=name\n"
+ "-net tap[,vlan=n][,name=str],ifname=name\n"
" connect the host TAP network interface to VLAN 'n'\n"
#else
- "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
+ "-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
" connect the host TAP network interface to VLAN 'n' and use the\n"
" network scripts 'file' (default=%s)\n"
" and 'dfile' (default=%s);\n"
" use '[down]script=no' to disable script execution;\n"
" use 'fd=h' to connect to an already opened TAP interface\n"
#endif
- "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
+ "-net socket[,vlan=n][,name=str][,fd=h][,listen=[host]:port][,connect=host:port]\n"
" connect the vlan 'n' to another VLAN using a socket connection\n"
- "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
+ "-net socket[,vlan=n][,name=str][,fd=h][,mcast=maddr:port]\n"
" connect the vlan 'n' to multicast maddr and port\n"
#ifdef CONFIG_VDE
- "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
+ "-net vde[,vlan=n][,name=str][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
" connect the vlan 'n' to port 'n' of a vde switch running\n"
" on host and listening for incoming connections on 'socketpath'.\n"
" Use group 'groupname' and mode 'octalmode' to change default\n"