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: NMark McLoughlin <markmc@redhat.com>
Signed-off-by: NAnthony Liguori <aliguori@us.ibm.com>



git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6216 c046a42c-6fe2-441c-8c8c-71466251a162

hw/e1000.c

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

hw/eepro100.c

@@ -1776,7 +1776,8 @@ static void nic_init(PCIBus * bus, NICInfo * nd,
 
     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),
              "eepro100 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

hw/etraxfs_eth.c

@@ -572,7 +572,7 @@ void *etraxfs_eth_init(NICInfo *nd, CPUState *env,
 	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, 
+	eth->vc = qemu_new_vlan_client(nd->vlan, nd->model,
 				       eth_receive, eth_can_receive, eth);
 
 	return dma;

hw/mcf_fec.c

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

hw/mipsnet.c

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

hw/musicpal.c

@@ -718,7 +718,8 @@ static void mv88w8618_eth_init(NICInfo *nd, uint32_t base, qemu_irq irq)
     if (!s)
         return;
     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,
                                        mv88w8618_eth_writefn, s);
     cpu_register_physical_memory(base, MP_ETH_SIZE, iomemtype);

hw/ne2000.c

@@ -741,8 +741,8 @@ void isa_ne2000_init(int base, qemu_irq irq, NICInfo *nd)
 
     ne2000_reset(s);
 
-    s->vc = qemu_new_vlan_client(nd->vlan, ne2000_receive,
-                                 ne2000_can_receive, s);
+    s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+                                 ne2000_receive, ne2000_can_receive, s);
 
     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
              "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;
     memcpy(s->macaddr, nd->macaddr, 6);
     ne2000_reset(s);
-    s->vc = qemu_new_vlan_client(nd->vlan, ne2000_receive,
-                                 ne2000_can_receive, s);
+    s->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+                                 ne2000_receive, ne2000_can_receive, s);
 
     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
              "ne2000 pci macaddr=%02x:%02x:%02x:%02x:%02x:%02x",

hw/pcnet.c

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

hw/rtl8139.c

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

hw/smc91c111.c

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

hw/stellaris_enet.c

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

hw/usb-net.c

@@ -1453,7 +1453,7 @@ USBDevice *usb_net_init(NICInfo *nd)
 
     pstrcpy(s->dev.devname, sizeof(s->dev.devname),
                     "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);
 
     snprintf(s->usbstring_mac, sizeof(s->usbstring_mac),

hw/virtio-net.c

@@ -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->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, virtio_net_receive,
-                                 virtio_net_can_receive, n);
+    n->vc = qemu_new_vlan_client(nd->vlan, nd->model,
+                                 virtio_net_receive, virtio_net_can_receive, n);
 
     n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);
     n->tx_timer_active = 0;

net.c

@@ -297,6 +297,7 @@ static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
 #endif
 
 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
+                                      const char *model,
                                       IOReadHandler *fd_read,
                                       IOCanRWHandler *fd_can_read,
                                       void *opaque)
@@ -305,6 +306,7 @@ VLANClientState *qemu_new_vlan_client(VLANState *vlan,
     vc = qemu_mallocz(sizeof(VLANClientState));
     if (!vc)
         return NULL;
+    vc->model = strdup(model);
     vc->fd_read = fd_read;
     vc->fd_can_read = fd_can_read;
     vc->opaque = opaque;
@@ -325,6 +327,7 @@ void qemu_del_vlan_client(VLANClientState *vc)
     while (*pvc != NULL)
         if (*pvc == vc) {
             *pvc = vc->next;
+            free(vc->model);
             free(vc);
             break;
         } else
@@ -442,13 +445,13 @@ static void slirp_receive(void *opaque, const uint8_t *buf, int 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) {
         slirp_inited = 1;
         slirp_init();
     }
-    slirp_vc = qemu_new_vlan_client(vlan,
+    slirp_vc = qemu_new_vlan_client(vlan, model,
                                     slirp_receive, NULL, NULL);
     snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
     return 0;
@@ -662,7 +665,7 @@ static void tap_send(void *opaque)
 
 /* 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;
 
@@ -670,7 +673,7 @@ static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
     if (!s)
         return NULL;
     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
     s->vc->fd_readv = tap_receive_iov;
 #endif
@@ -905,7 +908,7 @@ static int launch_script(const char *setup_script, const char *ifname, int fd)
     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)
 {
     TAPState *s;
@@ -926,7 +929,7 @@ static int net_tap_init(VLANState *vlan, const char *ifname1,
 	if (launch_script(setup_script, ifname, fd))
 	    return -1;
     }
-    s = net_tap_fd_init(vlan, fd);
+    s = net_tap_fd_init(vlan, model, fd);
     if (!s)
         return -1;
     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,
-                        const char *group, int mode)
+static int net_vde_init(VLANState *vlan, const char *model, const char *sock,
+                        int port, const char *group, int mode)
 {
     VDEState *s;
     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);
         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);
     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
              sock, vde_datafd(s->vde));
@@ -1011,6 +1014,7 @@ typedef struct NetSocketState {
 
 typedef struct NetSocketListenState {
     VLANState *vlan;
+    char *model;
     int fd;
 } NetSocketListenState;
 
@@ -1164,8 +1168,8 @@ fail:
     return -1;
 }
 
-static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
-                                          int is_connected)
+static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, const char *model,
+                                                int fd, int is_connected)
 {
     struct sockaddr_in saddr;
     int newfd;
@@ -1208,7 +1212,7 @@ static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
         return NULL;
     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);
 
     /* 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);
 }
 
-static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
-                                          int is_connected)
+static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, const char *model,
+                                                 int fd, int is_connected)
 {
     NetSocketState *s;
     s = qemu_mallocz(sizeof(NetSocketState));
     if (!s)
         return NULL;
     s->fd = fd;
-    s->vc = qemu_new_vlan_client(vlan,
+    s->vc = qemu_new_vlan_client(vlan, model,
                                  net_socket_receive, NULL, s);
     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
              "socket: fd=%d", fd);
@@ -1247,8 +1251,8 @@ static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
     return s;
 }
 
-static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
-                                          int is_connected)
+static NetSocketState *net_socket_fd_init(VLANState *vlan, const char *model,
+                                          int fd, int is_connected)
 {
     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) {
     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:
-        return net_socket_fd_init_stream(vlan, fd, is_connected);
+        return net_socket_fd_init_stream(vlan, model, 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, fd, is_connected);
+        return net_socket_fd_init_stream(vlan, model, fd, is_connected);
     }
     return NULL;
 }
@@ -1287,7 +1291,7 @@ static void net_socket_accept(void *opaque)
             break;
         }
     }
-    s1 = net_socket_fd_init(s->vlan, fd, 1);
+    s1 = net_socket_fd_init(s->vlan, s->model, fd, 1);
     if (!s1) {
         closesocket(fd);
     } 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;
     int fd, val, ret;
@@ -1332,12 +1337,14 @@ static int net_socket_listen_init(VLANState *vlan, const char *host_str)
         return -1;
     }
     s->vlan = vlan;
+    s->model = strdup(model);
     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 *host_str)
+static int net_socket_connect_init(VLANState *vlan, const char *model,
+                                   const char *host_str)
 {
     NetSocketState *s;
     int fd, connected, ret, err;
@@ -1375,7 +1382,7 @@ static int net_socket_connect_init(VLANState *vlan, const char *host_str)
             break;
         }
     }
-    s = net_socket_fd_init(vlan, fd, connected);
+    s = net_socket_fd_init(vlan, model, fd, connected);
     if (!s)
         return -1;
     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;
 }
 
-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;
     int fd;
@@ -1398,7 +1406,7 @@ static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
     if (fd < 0)
 	return -1;
 
-    s = net_socket_fd_init(vlan, fd, 0);
+    s = net_socket_fd_init(vlan, model, fd, 0);
     if (!s)
         return -1;
 
@@ -1488,7 +1496,7 @@ int net_client_init(const char *device, const char *p)
             pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
         }
         vlan->nb_host_devs++;
-        ret = net_slirp_init(vlan);
+        ret = net_slirp_init(vlan, device);
     } else
 #endif
 #ifdef _WIN32
@@ -1499,7 +1507,7 @@ int net_client_init(const char *device, const char *p)
             return -1;
         }
         vlan->nb_host_devs++;
-        ret = tap_win32_init(vlan, ifname);
+        ret = tap_win32_init(vlan, device, ifname);
     } else
 #elif defined (_AIX)
 #else
@@ -1512,7 +1520,7 @@ int net_client_init(const char *device, const char *p)
             fd = strtol(buf, NULL, 0);
             fcntl(fd, F_SETFL, O_NONBLOCK);
             ret = -1;
-            if (net_tap_fd_init(vlan, fd))
+            if (net_tap_fd_init(vlan, device, fd))
                 ret = 0;
         } else {
             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) {
                 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
 #endif
@@ -1533,14 +1541,14 @@ int net_client_init(const char *device, const char *p)
             int fd;
             fd = strtol(buf, NULL, 0);
             ret = -1;
-            if (net_socket_fd_init(vlan, fd, 1))
+            if (net_socket_fd_init(vlan, device, fd, 1))
                 ret = 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) {
-            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) {
-            ret = net_socket_mcast_init(vlan, buf);
+            ret = net_socket_mcast_init(vlan, device, buf);
         } else {
             fprintf(stderr, "Unknown socket options: %s\n", p);
             return -1;
@@ -1568,7 +1576,7 @@ int net_client_init(const char *device, const char *p)
 	} else {
 	    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
 #endif
     {

net.h

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

sysemu.h

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

tap-win32.c

@@ -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;
 
@@ -672,7 +672,7 @@ int tap_win32_init(VLANState *vlan, const char *ifname)
         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),
              "tap: ifname=%s", ifname);