Merge remote branch 'autotest-upstream/master' into try-box1

client/tests/kvm/kvm_vm.py

 #!/usr/bin/python
 """
 Utility classes and functions to handle Virtual Machine creation using qemu.
 
 @copyright: 2008-2009 Red Hat Inc.
 """
 
 import time, os, logging, fcntl, re, commands, glob
 import kvm_utils, kvm_subprocess, kvm_monitor
 from autotest_lib.client.common_lib import error
@@ skipping 307 matching lines @@
         if state:
             self.__dict__ = state
         else:
             self.process = None
             self.serial_console = None
             self.redirs = {}
             self.vnc_port = 5900
             self.monitors = []
             self.pci_assignable = None
             self.netdev_id = []
+            self.device_id = []
             self.uuid = None
 
             # Find a unique identifier for this VM
             while True:
                 self.instance = (time.strftime("%Y%m%d-%H%M%S-") +
                                  kvm_utils.generate_random_string(4))
                 if not glob.glob("/tmp/*%s" % self.instance):
                     break
 
         self.name = name
@@ skipping 116 matching lines @@
             if werror:
                 cmd += ",werror=%s" % werror
             if serial:
                 cmd += ",serial='%s'" % serial
             if snapshot:
                 cmd += ",snapshot=on"
             if boot:
                 cmd += ",boot=on"
             return cmd
 
-        def add_nic(help, vlan, model=None, mac=None, netdev_id=None,
+        def add_nic(help, vlan, model=None, mac=None, device_id=None, netdev_id=None,
                     nic_extra_params=None):
             if has_option(help, "netdev"):
                 netdev_vlan_str = ",netdev=%s" % netdev_id
             else:
                 netdev_vlan_str = ",vlan=%d" % vlan
             if has_option(help, "device"):
                 if not model:
                     model = "rtl8139"
                 elif model == "virtio":
                     model = "virtio-net-pci"
                 cmd = " -device %s" % model + netdev_vlan_str
                 if mac:
                     cmd += ",mac='%s'" % mac
                 if nic_extra_params:
                     cmd += ",%s" % nic_extra_params
             else:
                 cmd = " -net nic" + netdev_vlan_str
                 if model:
                     cmd += ",model=%s" % model
                 if mac:
                     cmd += ",macaddr='%s'" % mac
+            if device_id:
+                cmd += ",id='%s'" % device_id
             return cmd
 
         def add_net(help, vlan, mode, ifname=None, script=None,
                     downscript=None, tftp=None, bootfile=None, hostfwd=[],
                     netdev_id=None, netdev_extra_params=None):
             if has_option(help, "netdev"):
                 cmd = " -netdev %s,id=%s" % (mode, netdev_id)
                 if netdev_extra_params:
                     cmd += ",%s" % netdev_extra_params
             else:
@@ skipping 132 matching lines @@
             redir_params = params.object_params(redir_name)
             guest_port = int(redir_params.get("guest_port"))
             host_port = vm.redirs.get(guest_port)
             redirs += [(host_port, guest_port)]
 
         vlan = 0
         for nic_name in params.objects("nics"):
             nic_params = params.object_params(nic_name)
             try:
                 netdev_id = vm.netdev_id[vlan]
+                device_id = vm.device_id[vlan]
             except IndexError:
                 netdev_id = None
             # Handle the '-net nic' part
-            mac = vm.get_mac_address(vlan)
+            try:
+                mac = vm.get_mac_address(vlan)
+            except VMAddressError:
+                mac = None
             qemu_cmd += add_nic(help, vlan, nic_params.get("nic_model"), mac,
-                                netdev_id, nic_params.get("nic_extra_params"))
-            # Handle the '-net tap' or '-net user' part
+                                device_id, netdev_id, nic_params.get("nic_extra_params"))
+            # Handle the '-net tap' or '-net user' or '-netdev' part
             script = nic_params.get("nic_script")
             downscript = nic_params.get("nic_downscript")
             tftp = nic_params.get("tftp")
             if script:
                 script = kvm_utils.get_path(root_dir, script)
             if downscript:
                 downscript = kvm_utils.get_path(root_dir, downscript)
             if tftp:
                 tftp = kvm_utils.get_path(root_dir, tftp)
             qemu_cmd += add_net(help, vlan, nic_params.get("nic_mode", "user"),
@@ skipping 165 matching lines @@
         try:
             # Handle port redirections
             redir_names = params.objects("redirs")
             host_ports = kvm_utils.find_free_ports(5000, 6000, len(redir_names))
             self.redirs = {}
             for i in range(len(redir_names)):
                 redir_params = params.object_params(redir_names[i])
                 guest_port = int(redir_params.get("guest_port"))
                 self.redirs[guest_port] = host_ports[i]
 
-            # Generate netdev IDs for all NICs
+            # Generate netdev/device IDs for all NICs
             self.netdev_id = []
+            self.device_id = []
             for nic in params.objects("nics"):
                 self.netdev_id.append(kvm_utils.generate_random_id())
+                self.device_id.append(kvm_utils.generate_random_id())
 
             # Find available VNC port, if needed
             if params.get("display") == "vnc":
                 self.vnc_port = kvm_utils.find_free_port(5900, 6100)
 
             # Find random UUID if specified 'uuid = random' in config file
             if params.get("uuid") == "random":
                 f = open("/proc/sys/kernel/random/uuid")
                 self.uuid = f.read().strip()
                 f.close()
 
             # Generate or copy MAC addresses for all NICs
             num_nics = len(params.objects("nics"))
             for vlan in range(num_nics):
                 nic_name = params.objects("nics")[vlan]
                 nic_params = params.object_params(nic_name)
-                if nic_params.get("nic_mac", None):
-                    mac = nic_params.get("nic_mac")
+                mac = (nic_params.get("nic_mac") or
+                       mac_source and mac_source.get_mac_address(vlan))
+                if mac:
                     kvm_utils.set_mac_address(self.instance, vlan, mac)
                 else:
-                    mac = mac_source and mac_source.get_mac_address(vlan)
-                    if mac:
-                        kvm_utils.set_mac_address(self.instance, vlan, mac)
-                    else:
-                        kvm_utils.generate_mac_address(self.instance, vlan)
+                    kvm_utils.generate_mac_address(self.instance, vlan)
 
             # Assign a PCI assignable device
             self.pci_assignable = None
             pa_type = params.get("pci_assignable")
             if pa_type and pa_type != "no":
                 pa_devices_requested = params.get("devices_requested")
 
                 # Virtual Functions (VF) assignable devices
                 if pa_type == "vf":
                     self.pci_assignable = kvm_utils.PciAssignable(
@@ skipping 331 matching lines @@
         nic_params = self.params.object_params(nic_name)
         if nic_params.get("nic_mode") == "tap":
             return port
         else:
             try:
                 return self.redirs[port]
             except KeyError:
                 raise VMPortNotRedirectedError(port)
 
 
+    def get_peer(self, netid):
+        """
+        Return the peer of netdev or network deivce.
+
+        @param netid: id of netdev or device
+        @return: id of the peer device otherwise None
+        """
+        network_info = self.monitor.info("network")
+        try:
+            return re.findall("%s:.*peer=(.*)" % netid, network_info)[0]
+        except IndexError:
+            return None
+
+
     def get_ifname(self, nic_index=0):
         """
         Return the ifname of a tap device associated with a NIC.
 
         @param nic_index: Index of the NIC
         """
         nics = self.params.objects("nics")
         nic_name = nics[nic_index]
         nic_params = self.params.object_params(nic_name)
         if nic_params.get("nic_ifname"):
             return nic_params.get("nic_ifname")
         else:
             return "t%d-%s" % (nic_index, self.instance[-11:])
 
 
     def get_mac_address(self, nic_index=0):
         """
         Return the MAC address of a NIC.
 
         @param nic_index: Index of the NIC
         @raise VMMACAddressMissingError: If no MAC address is defined for the
                 requested NIC
         """
-        mac = kvm_utils.get_mac_address(self.instance, nic_index)
+        nic_name = self.params.objects("nics")[nic_index]
+        nic_params = self.params.object_params(nic_name)
+        mac = (nic_params.get("nic_mac") or
+               kvm_utils.get_mac_address(self.instance, nic_index))
         if not mac:
             raise VMMACAddressMissingError(nic_index)
         return mac
 
 
     def free_mac_address(self, nic_index=0):
         """
         Free a NIC's MAC address.
 
         @param nic_index: Index of the NIC
@@ skipping 501 matching lines @@
         Save the state of virtual machine to a file through migrate to
         exec
         """
         # Make sure we only get one iteration
         self.monitor.cmd("migrate_set_speed 1000g")
         self.monitor.cmd("migrate_set_downtime 100000000")
         self.monitor.migrate('"exec:cat>%s"' % path)
         # Restore the speed and downtime of migration
         self.monitor.cmd("migrate_set_speed %d" % (32<<20))
         self.monitor.cmd("migrate_set_downtime 0.03")