lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1 | #!/usr/bin/python |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 2 | """ |
| 3 | Utility classes and functions to handle Virtual Machine creation using qemu. |
| 4 | |
| 5 | @copyright: 2008-2009 Red Hat Inc. |
| 6 | """ |
| 7 | |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 8 | import time, socket, os, logging, fcntl, re, commands, shelve, glob |
lmr | cbc86ef | 2010-07-07 20:50:08 +0000 | [diff] [blame] | 9 | import kvm_utils, kvm_subprocess, kvm_monitor, rss_file_transfer |
lmr | 47a853b | 2010-02-04 13:56:48 +0000 | [diff] [blame] | 10 | from autotest_lib.client.common_lib import error |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 11 | from autotest_lib.client.bin import utils |
lmr | b635b86 | 2009-09-10 14:53:21 +0000 | [diff] [blame] | 12 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 13 | |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 14 | def get_image_filename(params, root_dir): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 15 | """ |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 16 | Generate an image path from params and root_dir. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 17 | |
| 18 | @param params: Dictionary containing the test parameters. |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 19 | @param root_dir: Base directory for relative filenames. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 20 | |
| 21 | @note: params should contain: |
| 22 | image_name -- the name of the image file, without extension |
| 23 | image_format -- the format of the image (qcow2, raw etc) |
| 24 | """ |
| 25 | image_name = params.get("image_name", "image") |
| 26 | image_format = params.get("image_format", "qcow2") |
| 27 | image_filename = "%s.%s" % (image_name, image_format) |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 28 | image_filename = kvm_utils.get_path(root_dir, image_filename) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 29 | return image_filename |
| 30 | |
| 31 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 32 | def create_image(params, root_dir): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 33 | """ |
| 34 | Create an image using qemu_image. |
| 35 | |
| 36 | @param params: Dictionary containing the test parameters. |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 37 | @param root_dir: Base directory for relative filenames. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 38 | |
| 39 | @note: params should contain: |
| 40 | image_name -- the name of the image file, without extension |
| 41 | image_format -- the format of the image (qcow2, raw etc) |
| 42 | image_size -- the requested size of the image (a string |
| 43 | qemu-img can understand, such as '10G') |
| 44 | """ |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 45 | qemu_img_cmd = kvm_utils.get_path(root_dir, params.get("qemu_img_binary", |
| 46 | "qemu-img")) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 47 | qemu_img_cmd += " create" |
| 48 | |
| 49 | format = params.get("image_format", "qcow2") |
| 50 | qemu_img_cmd += " -f %s" % format |
| 51 | |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 52 | image_filename = get_image_filename(params, root_dir) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 53 | qemu_img_cmd += " %s" % image_filename |
| 54 | |
| 55 | size = params.get("image_size", "10G") |
| 56 | qemu_img_cmd += " %s" % size |
| 57 | |
lmr | 47a853b | 2010-02-04 13:56:48 +0000 | [diff] [blame] | 58 | try: |
| 59 | utils.system(qemu_img_cmd) |
| 60 | except error.CmdError, e: |
| 61 | logging.error("Could not create image; qemu-img command failed:\n%s", |
| 62 | str(e)) |
| 63 | return None |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 64 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 65 | if not os.path.exists(image_filename): |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 66 | logging.error("Image could not be created for some reason; " |
| 67 | "qemu-img command:\n%s" % qemu_img_cmd) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 68 | return None |
| 69 | |
| 70 | logging.info("Image created in %s" % image_filename) |
| 71 | return image_filename |
| 72 | |
| 73 | |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 74 | def remove_image(params, root_dir): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 75 | """ |
| 76 | Remove an image file. |
| 77 | |
| 78 | @param params: A dict |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 79 | @param root_dir: Base directory for relative filenames. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 80 | |
| 81 | @note: params should contain: |
| 82 | image_name -- the name of the image file, without extension |
| 83 | image_format -- the format of the image (qcow2, raw etc) |
| 84 | """ |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 85 | image_filename = get_image_filename(params, root_dir) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 86 | logging.debug("Removing image file %s..." % image_filename) |
| 87 | if os.path.exists(image_filename): |
| 88 | os.unlink(image_filename) |
| 89 | else: |
| 90 | logging.debug("Image file %s not found") |
| 91 | |
| 92 | |
| 93 | class VM: |
| 94 | """ |
| 95 | This class handles all basic VM operations. |
| 96 | """ |
| 97 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 98 | def __init__(self, name, params, root_dir, address_cache): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 99 | """ |
| 100 | Initialize the object and set a few attributes. |
| 101 | |
| 102 | @param name: The name of the object |
| 103 | @param params: A dict containing VM params |
| 104 | (see method make_qemu_command for a full description) |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 105 | @param root_dir: Base directory for relative filenames |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 106 | @param address_cache: A dict that maps MAC addresses to IP addresses |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 107 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 108 | self.process = None |
lmr | aa380a2 | 2010-06-22 02:05:29 +0000 | [diff] [blame] | 109 | self.serial_console = None |
lmr | 953ffba | 2009-07-27 13:20:10 +0000 | [diff] [blame] | 110 | self.redirs = {} |
| 111 | self.vnc_port = 5900 |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 112 | self.monitors = [] |
| 113 | self.pci_assignable = None |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 114 | self.netdev_id = [] |
| 115 | self.uuid = None |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 116 | |
| 117 | self.name = name |
| 118 | self.params = params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 119 | self.root_dir = root_dir |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 120 | self.address_cache = address_cache |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 121 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 122 | # Find a unique identifier for this VM |
lmr | 8b134f9 | 2009-06-08 14:47:31 +0000 | [diff] [blame] | 123 | while True: |
lmr | d16a67d | 2009-06-10 19:52:59 +0000 | [diff] [blame] | 124 | self.instance = (time.strftime("%Y%m%d-%H%M%S-") + |
| 125 | kvm_utils.generate_random_string(4)) |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 126 | if not glob.glob("/tmp/*%s" % self.instance): |
lmr | 8b134f9 | 2009-06-08 14:47:31 +0000 | [diff] [blame] | 127 | break |
| 128 | |
| 129 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 130 | def clone(self, name=None, params=None, root_dir=None, address_cache=None): |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 131 | """ |
| 132 | Return a clone of the VM object with optionally modified parameters. |
| 133 | The clone is initially not alive and needs to be started using create(). |
| 134 | Any parameters not passed to this function are copied from the source |
| 135 | VM. |
| 136 | |
| 137 | @param name: Optional new VM name |
| 138 | @param params: Optional new VM creation parameters |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 139 | @param root_dir: Optional new base directory for relative filenames |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 140 | @param address_cache: A dict that maps MAC addresses to IP addresses |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 141 | """ |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 142 | if name is None: |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 143 | name = self.name |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 144 | if params is None: |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 145 | params = self.params.copy() |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 146 | if root_dir is None: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 147 | root_dir = self.root_dir |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 148 | if address_cache is None: |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 149 | address_cache = self.address_cache |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 150 | return VM(name, params, root_dir, address_cache) |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 151 | |
| 152 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 153 | def make_qemu_command(self, name=None, params=None, root_dir=None): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 154 | """ |
| 155 | Generate a qemu command line. All parameters are optional. If a |
| 156 | parameter is not supplied, the corresponding value stored in the |
| 157 | class attributes is used. |
| 158 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 159 | @param name: The name of the object |
| 160 | @param params: A dict containing VM params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 161 | @param root_dir: Base directory for relative filenames |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 162 | |
| 163 | @note: The params dict should contain: |
| 164 | mem -- memory size in MBs |
| 165 | cdrom -- ISO filename to use with the qemu -cdrom parameter |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 166 | extra_params -- a string to append to the qemu command |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 167 | shell_port -- port of the remote shell daemon on the guest |
| 168 | (SSH, Telnet or the home-made Remote Shell Server) |
| 169 | shell_client -- client program to use for connecting to the |
| 170 | remote shell daemon on the guest (ssh, telnet or nc) |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 171 | x11_display -- if specified, the DISPLAY environment variable |
| 172 | will be be set to this value for the qemu process (useful for |
| 173 | SDL rendering) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 174 | images -- a list of image object names, separated by spaces |
| 175 | nics -- a list of NIC object names, separated by spaces |
| 176 | |
| 177 | For each image in images: |
| 178 | drive_format -- string to pass as 'if' parameter for this |
| 179 | image (e.g. ide, scsi) |
| 180 | image_snapshot -- if yes, pass 'snapshot=on' to qemu for |
| 181 | this image |
| 182 | image_boot -- if yes, pass 'boot=on' to qemu for this image |
| 183 | In addition, all parameters required by get_image_filename. |
| 184 | |
| 185 | For each NIC in nics: |
| 186 | nic_model -- string to pass as 'model' parameter for this |
| 187 | NIC (e.g. e1000) |
| 188 | """ |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 189 | # Helper function for command line option wrappers |
| 190 | def has_option(help, option): |
| 191 | return bool(re.search(r"^-%s(\s|$)" % option, help, re.MULTILINE)) |
| 192 | |
| 193 | # Wrappers for all supported qemu command line parameters. |
| 194 | # This is meant to allow support for multiple qemu versions. |
| 195 | # Each of these functions receives the output of 'qemu -help' as a |
| 196 | # parameter, and should add the requested command line option |
| 197 | # accordingly. |
| 198 | |
| 199 | def add_name(help, name): |
| 200 | return " -name '%s'" % name |
| 201 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 202 | def add_human_monitor(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 203 | return " -monitor unix:'%s',server,nowait" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 204 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 205 | def add_qmp_monitor(help, filename): |
| 206 | return " -qmp unix:'%s',server,nowait" % filename |
| 207 | |
lmr | 2b06f33 | 2010-06-22 02:03:41 +0000 | [diff] [blame] | 208 | def add_serial(help, filename): |
| 209 | return " -serial unix:'%s',server,nowait" % filename |
| 210 | |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 211 | def add_mem(help, mem): |
| 212 | return " -m %s" % mem |
| 213 | |
| 214 | def add_smp(help, smp): |
| 215 | return " -smp %s" % smp |
| 216 | |
lmr | af70970 | 2010-07-20 00:56:33 +0000 | [diff] [blame] | 217 | def add_cdrom(help, filename, index=None): |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 218 | if has_option(help, "drive"): |
lmr | af70970 | 2010-07-20 00:56:33 +0000 | [diff] [blame] | 219 | cmd = " -drive file='%s',media=cdrom" % filename |
| 220 | if index is not None: cmd += ",index=%s" % index |
| 221 | return cmd |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 222 | else: |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 223 | return " -cdrom '%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 224 | |
lmr | af70970 | 2010-07-20 00:56:33 +0000 | [diff] [blame] | 225 | def add_drive(help, filename, index=None, format=None, cache=None, |
| 226 | werror=None, serial=None, snapshot=False, boot=False): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 227 | cmd = " -drive file='%s'" % filename |
lmr | af70970 | 2010-07-20 00:56:33 +0000 | [diff] [blame] | 228 | if index is not None: cmd += ",index=%s" % index |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 229 | if format: cmd += ",if=%s" % format |
| 230 | if cache: cmd += ",cache=%s" % cache |
| 231 | if werror: cmd += ",werror=%s" % werror |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 232 | if serial: cmd += ",serial='%s'" % serial |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 233 | if snapshot: cmd += ",snapshot=on" |
| 234 | if boot: cmd += ",boot=on" |
| 235 | return cmd |
| 236 | |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 237 | def add_nic(help, vlan, model=None, mac=None, netdev_id=None, |
| 238 | nic_extra_params=None): |
| 239 | if has_option(help, "device"): |
| 240 | if model == "virtio": |
| 241 | model="virtio-net-pci" |
| 242 | if not model: |
| 243 | model= "rtl8139" |
| 244 | cmd = " -device %s" % model |
| 245 | if mac: |
| 246 | cmd += ",mac=%s" % mac |
| 247 | if has_option(help, "netdev"): |
| 248 | cmd += ",netdev=%s" % netdev_id |
| 249 | else: |
| 250 | cmd += "vlan=%d," % vlan |
| 251 | if nic_extra_params: |
| 252 | cmd += ",%s" % nic_extra_params |
Eric Li | 6f27d4f | 2010-09-29 10:55:17 -0700 | [diff] [blame] | 253 | else: |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 254 | if has_option(help, "netdev"): |
| 255 | cmd = " -net nic,netdev=%s" % netdev_id |
| 256 | else: |
| 257 | cmd = " -net nic,vlan=%d" % vlan |
| 258 | if model: |
| 259 | cmd += ",model=%s" % model |
| 260 | if mac: |
| 261 | cmd += ",macaddr='%s'" % mac |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 262 | return cmd |
| 263 | |
| 264 | def add_net(help, vlan, mode, ifname=None, script=None, |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 265 | downscript=None, tftp=None, bootfile=None, hostfwd=[], |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 266 | netdev_id=None, vhost=False): |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame] | 267 | if has_option(help, "netdev"): |
| 268 | cmd = " -netdev %s,id=%s" % (mode, netdev_id) |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 269 | if vhost: |
| 270 | cmd +=",vhost=on" |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame] | 271 | else: |
| 272 | cmd = " -net %s,vlan=%d" % (mode, vlan) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 273 | if mode == "tap": |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 274 | if ifname: cmd += ",ifname='%s'" % ifname |
| 275 | if script: cmd += ",script='%s'" % script |
| 276 | cmd += ",downscript='%s'" % (downscript or "no") |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 277 | elif mode == "user": |
| 278 | if tftp and "[,tftp=" in help: |
| 279 | cmd += ",tftp='%s'" % tftp |
| 280 | if bootfile and "[,bootfile=" in help: |
| 281 | cmd += ",bootfile='%s'" % bootfile |
| 282 | if "[,hostfwd=" in help: |
| 283 | for host_port, guest_port in hostfwd: |
| 284 | cmd += ",hostfwd=tcp::%s-:%s" % (host_port, guest_port) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 285 | return cmd |
| 286 | |
| 287 | def add_floppy(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 288 | return " -fda '%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 289 | |
| 290 | def add_tftp(help, filename): |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 291 | # If the new syntax is supported, don't add -tftp |
| 292 | if "[,tftp=" in help: |
| 293 | return "" |
| 294 | else: |
| 295 | return " -tftp '%s'" % filename |
| 296 | |
| 297 | def add_bootp(help, filename): |
| 298 | # If the new syntax is supported, don't add -bootp |
| 299 | if "[,bootfile=" in help: |
| 300 | return "" |
| 301 | else: |
| 302 | return " -bootp '%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 303 | |
| 304 | def add_tcp_redir(help, host_port, guest_port): |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 305 | # If the new syntax is supported, don't add -redir |
| 306 | if "[,hostfwd=" in help: |
| 307 | return "" |
| 308 | else: |
| 309 | return " -redir tcp:%s::%s" % (host_port, guest_port) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 310 | |
| 311 | def add_vnc(help, vnc_port): |
| 312 | return " -vnc :%d" % (vnc_port - 5900) |
| 313 | |
| 314 | def add_sdl(help): |
| 315 | if has_option(help, "sdl"): |
| 316 | return " -sdl" |
| 317 | else: |
| 318 | return "" |
| 319 | |
| 320 | def add_nographic(help): |
| 321 | return " -nographic" |
| 322 | |
| 323 | def add_uuid(help, uuid): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 324 | return " -uuid '%s'" % uuid |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 325 | |
| 326 | def add_pcidevice(help, host): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 327 | return " -pcidevice host='%s'" % host |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 328 | |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 329 | def add_kernel(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 330 | return " -kernel '%s'" % filename |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 331 | |
| 332 | def add_initrd(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 333 | return " -initrd '%s'" % filename |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 334 | |
lmr | e0474e3 | 2010-06-29 14:10:09 +0000 | [diff] [blame] | 335 | def add_kernel_cmdline(help, cmdline): |
| 336 | return " -append %s" % cmdline |
| 337 | |
lmr | 7102455 | 2010-06-29 14:12:35 +0000 | [diff] [blame] | 338 | def add_testdev(help, filename): |
| 339 | return (" -chardev file,id=testlog,path=%s" |
| 340 | " -device testdev,chardev=testlog" % filename) |
| 341 | |
lmr | ce5c925 | 2010-06-30 17:41:00 +0000 | [diff] [blame] | 342 | def add_no_hpet(help): |
| 343 | if has_option(help, "no-hpet"): |
| 344 | return " -no-hpet" |
| 345 | else: |
| 346 | return "" |
| 347 | |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 348 | # End of command line option wrappers |
| 349 | |
| 350 | if name is None: name = self.name |
| 351 | if params is None: params = self.params |
| 352 | if root_dir is None: root_dir = self.root_dir |
| 353 | |
| 354 | qemu_binary = kvm_utils.get_path(root_dir, params.get("qemu_binary", |
| 355 | "qemu")) |
| 356 | # Get the output of 'qemu -help' (log a message in case this call never |
| 357 | # returns or causes some other kind of trouble) |
| 358 | logging.debug("Getting output of 'qemu -help'") |
| 359 | help = commands.getoutput("%s -help" % qemu_binary) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 360 | |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 361 | # Start constructing the qemu command |
| 362 | qemu_cmd = "" |
| 363 | # Set the X11 display parameter if requested |
| 364 | if params.get("x11_display"): |
| 365 | qemu_cmd += "DISPLAY=%s " % params.get("x11_display") |
| 366 | # Add the qemu binary |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 367 | qemu_cmd += qemu_binary |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 368 | # Add the VM's name |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 369 | qemu_cmd += add_name(help, name) |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 370 | # Add monitors |
| 371 | for monitor_name in kvm_utils.get_sub_dict_names(params, "monitors"): |
| 372 | monitor_params = kvm_utils.get_sub_dict(params, monitor_name) |
| 373 | monitor_filename = self.get_monitor_filename(monitor_name) |
| 374 | if monitor_params.get("monitor_type") == "qmp": |
| 375 | qemu_cmd += add_qmp_monitor(help, monitor_filename) |
| 376 | else: |
| 377 | qemu_cmd += add_human_monitor(help, monitor_filename) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 378 | |
lmr | 2b06f33 | 2010-06-22 02:03:41 +0000 | [diff] [blame] | 379 | # Add serial console redirection |
| 380 | qemu_cmd += add_serial(help, self.get_serial_console_filename()) |
| 381 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 382 | for image_name in kvm_utils.get_sub_dict_names(params, "images"): |
| 383 | image_params = kvm_utils.get_sub_dict(params, image_name) |
lmr | 9d75ee3 | 2009-09-29 13:14:13 +0000 | [diff] [blame] | 384 | if image_params.get("boot_drive") == "no": |
| 385 | continue |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 386 | qemu_cmd += add_drive(help, |
| 387 | get_image_filename(image_params, root_dir), |
lmr | af70970 | 2010-07-20 00:56:33 +0000 | [diff] [blame] | 388 | image_params.get("drive_index"), |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 389 | image_params.get("drive_format"), |
| 390 | image_params.get("drive_cache"), |
| 391 | image_params.get("drive_werror"), |
| 392 | image_params.get("drive_serial"), |
| 393 | image_params.get("image_snapshot") == "yes", |
| 394 | image_params.get("image_boot") == "yes") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 395 | |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 396 | redirs = [] |
| 397 | for redir_name in kvm_utils.get_sub_dict_names(params, "redirs"): |
| 398 | redir_params = kvm_utils.get_sub_dict(params, redir_name) |
| 399 | guest_port = int(redir_params.get("guest_port")) |
| 400 | host_port = self.redirs.get(guest_port) |
| 401 | redirs += [(host_port, guest_port)] |
| 402 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 403 | vlan = 0 |
| 404 | for nic_name in kvm_utils.get_sub_dict_names(params, "nics"): |
| 405 | nic_params = kvm_utils.get_sub_dict(params, nic_name) |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 406 | # Handle the '-net nic' part |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 407 | mac = self.get_mac_address(vlan) |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame] | 408 | qemu_cmd += add_nic(help, vlan, nic_params.get("nic_model"), mac, |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 409 | self.netdev_id[vlan], |
| 410 | nic_params.get("nic_extra_params")) |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 411 | # Handle the '-net tap' or '-net user' part |
lmr | e4eaa86 | 2010-06-01 19:15:14 +0000 | [diff] [blame] | 412 | script = nic_params.get("nic_script") |
| 413 | downscript = nic_params.get("nic_downscript") |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 414 | tftp = nic_params.get("tftp") |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 415 | if script: |
| 416 | script = kvm_utils.get_path(root_dir, script) |
| 417 | if downscript: |
| 418 | downscript = kvm_utils.get_path(root_dir, downscript) |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 419 | if tftp: |
| 420 | tftp = kvm_utils.get_path(root_dir, tftp) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 421 | qemu_cmd += add_net(help, vlan, nic_params.get("nic_mode", "user"), |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 422 | self.get_ifname(vlan), |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 423 | script, downscript, tftp, |
| 424 | nic_params.get("bootp"), redirs, |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 425 | self.netdev_id[vlan], |
| 426 | nic_params.get("vhost")=="yes") |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 427 | # Proceed to next NIC |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 428 | vlan += 1 |
| 429 | |
| 430 | mem = params.get("mem") |
| 431 | if mem: |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 432 | qemu_cmd += add_mem(help, mem) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 433 | |
lmr | c43bf37 | 2009-11-10 13:19:00 +0000 | [diff] [blame] | 434 | smp = params.get("smp") |
| 435 | if smp: |
lmr | db3fe61 | 2010-06-14 16:19:28 +0000 | [diff] [blame] | 436 | qemu_cmd += add_smp(help, smp) |
lmr | c43bf37 | 2009-11-10 13:19:00 +0000 | [diff] [blame] | 437 | |
lmr | ac5dce7 | 2010-07-20 00:58:25 +0000 | [diff] [blame] | 438 | cdroms = kvm_utils.get_sub_dict_names(params, "cdroms") |
| 439 | for cdrom in cdroms: |
| 440 | cdrom_params = kvm_utils.get_sub_dict(params, cdrom) |
| 441 | iso = cdrom_params.get("cdrom") |
| 442 | if iso: |
| 443 | qemu_cmd += add_cdrom(help, kvm_utils.get_path(root_dir, iso), |
| 444 | cdrom_params.get("drive_index")) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 445 | |
lmr | b0a9b76 | 2009-10-09 20:43:30 +0000 | [diff] [blame] | 446 | # We may want to add {floppy_otps} parameter for -fda |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 447 | # {fat:floppy:}/path/. However vvfat is not usually recommended. |
lmr | b0a9b76 | 2009-10-09 20:43:30 +0000 | [diff] [blame] | 448 | floppy = params.get("floppy") |
| 449 | if floppy: |
lmr | f69f6b1 | 2009-11-10 16:33:44 +0000 | [diff] [blame] | 450 | floppy = kvm_utils.get_path(root_dir, floppy) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 451 | qemu_cmd += add_floppy(help, floppy) |
lmr | b0a9b76 | 2009-10-09 20:43:30 +0000 | [diff] [blame] | 452 | |
| 453 | tftp = params.get("tftp") |
lmr | 62fc2bb | 2010-07-08 23:45:11 +0000 | [diff] [blame] | 454 | if tftp: |
lmr | f69f6b1 | 2009-11-10 16:33:44 +0000 | [diff] [blame] | 455 | tftp = kvm_utils.get_path(root_dir, tftp) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 456 | qemu_cmd += add_tftp(help, tftp) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 457 | |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 458 | bootp = params.get("bootp") |
| 459 | if bootp: |
| 460 | qemu_cmd += add_bootp(help, bootp) |
| 461 | |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 462 | kernel = params.get("kernel") |
| 463 | if kernel: |
| 464 | kernel = kvm_utils.get_path(root_dir, kernel) |
| 465 | qemu_cmd += add_kernel(help, kernel) |
| 466 | |
lmr | e0474e3 | 2010-06-29 14:10:09 +0000 | [diff] [blame] | 467 | kernel_cmdline = params.get("kernel_cmdline") |
| 468 | if kernel_cmdline: |
| 469 | qemu_cmd += add_kernel_cmdline(help, kernel_cmdline) |
| 470 | |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 471 | initrd = params.get("initrd") |
| 472 | if initrd: |
| 473 | initrd = kvm_utils.get_path(root_dir, initrd) |
| 474 | qemu_cmd += add_initrd(help, initrd) |
| 475 | |
lmr | 6976faa | 2010-07-09 21:11:06 +0000 | [diff] [blame] | 476 | for host_port, guest_port in redirs: |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 477 | qemu_cmd += add_tcp_redir(help, host_port, guest_port) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 478 | |
| 479 | if params.get("display") == "vnc": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 480 | qemu_cmd += add_vnc(help, self.vnc_port) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 481 | elif params.get("display") == "sdl": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 482 | qemu_cmd += add_sdl(help) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 483 | elif params.get("display") == "nographic": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 484 | qemu_cmd += add_nographic(help) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 485 | |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 486 | if params.get("uuid") == "random": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 487 | qemu_cmd += add_uuid(help, self.uuid) |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 488 | elif params.get("uuid"): |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 489 | qemu_cmd += add_uuid(help, params.get("uuid")) |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 490 | |
lmr | 7102455 | 2010-06-29 14:12:35 +0000 | [diff] [blame] | 491 | if params.get("testdev") == "yes": |
| 492 | qemu_cmd += add_testdev(help, self.get_testlog_filename()) |
| 493 | |
lmr | ce5c925 | 2010-06-30 17:41:00 +0000 | [diff] [blame] | 494 | if params.get("disable_hpet") == "yes": |
| 495 | qemu_cmd += add_no_hpet(help) |
| 496 | |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 497 | # If the PCI assignment step went OK, add each one of the PCI assigned |
| 498 | # devices to the qemu command line. |
| 499 | if self.pci_assignable: |
| 500 | for pci_id in self.pa_pci_ids: |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 501 | qemu_cmd += add_pcidevice(help, pci_id) |
| 502 | |
| 503 | extra_params = params.get("extra_params") |
| 504 | if extra_params: |
| 505 | qemu_cmd += " %s" % extra_params |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 506 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 507 | return qemu_cmd |
| 508 | |
| 509 | |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 510 | def create(self, name=None, params=None, root_dir=None, timeout=5.0, |
| 511 | migration_mode=None, migration_exec_cmd=None, mac_source=None): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 512 | """ |
| 513 | Start the VM by running a qemu command. |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 514 | All parameters are optional. If name, params or root_dir are not |
| 515 | supplied, the respective values stored as class attributes are used. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 516 | |
| 517 | @param name: The name of the object |
| 518 | @param params: A dict containing VM params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 519 | @param root_dir: Base directory for relative filenames |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 520 | @param migration_mode: If supplied, start VM for incoming migration |
| 521 | using this protocol (either 'tcp', 'unix' or 'exec') |
| 522 | @param migration_exec_cmd: Command to embed in '-incoming "exec: ..."' |
| 523 | (e.g. 'gzip -c -d filename') if migration_mode is 'exec' |
| 524 | @param mac_source: A VM object from which to copy MAC addresses. If not |
| 525 | specified, new addresses will be generated. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 526 | """ |
lmr | 135b5e6 | 2009-06-10 19:22:31 +0000 | [diff] [blame] | 527 | self.destroy() |
| 528 | |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 529 | if name is not None: |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 530 | self.name = name |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 531 | if params is not None: |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 532 | self.params = params |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 533 | if root_dir is not None: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 534 | self.root_dir = root_dir |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 535 | name = self.name |
| 536 | params = self.params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 537 | root_dir = self.root_dir |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 538 | |
| 539 | # Verify the md5sum of the ISO image |
| 540 | iso = params.get("cdrom") |
| 541 | if iso: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 542 | iso = kvm_utils.get_path(root_dir, iso) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 543 | if not os.path.exists(iso): |
| 544 | logging.error("ISO file not found: %s" % iso) |
| 545 | return False |
| 546 | compare = False |
| 547 | if params.get("md5sum_1m"): |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 548 | logging.debug("Comparing expected MD5 sum with MD5 sum of " |
| 549 | "first MB of ISO file...") |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 550 | actual_hash = utils.hash_file(iso, 1048576, method="md5") |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 551 | expected_hash = params.get("md5sum_1m") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 552 | compare = True |
| 553 | elif params.get("md5sum"): |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 554 | logging.debug("Comparing expected MD5 sum with MD5 sum of ISO " |
| 555 | "file...") |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 556 | actual_hash = utils.hash_file(iso, method="md5") |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 557 | expected_hash = params.get("md5sum") |
| 558 | compare = True |
| 559 | elif params.get("sha1sum"): |
| 560 | logging.debug("Comparing expected SHA1 sum with SHA1 sum of " |
| 561 | "ISO file...") |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 562 | actual_hash = utils.hash_file(iso, method="sha1") |
lmr | ea1266e | 2009-11-10 16:41:08 +0000 | [diff] [blame] | 563 | expected_hash = params.get("sha1sum") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 564 | compare = True |
| 565 | if compare: |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 566 | if actual_hash == expected_hash: |
| 567 | logging.debug("Hashes match") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 568 | else: |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 569 | logging.error("Actual hash differs from expected one") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 570 | return False |
| 571 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 572 | # Make sure the following code is not executed by more than one thread |
| 573 | # at the same time |
| 574 | lockfile = open("/tmp/kvm-autotest-vm-create.lock", "w+") |
| 575 | fcntl.lockf(lockfile, fcntl.LOCK_EX) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 576 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 577 | try: |
| 578 | # Handle port redirections |
| 579 | redir_names = kvm_utils.get_sub_dict_names(params, "redirs") |
| 580 | host_ports = kvm_utils.find_free_ports(5000, 6000, len(redir_names)) |
| 581 | self.redirs = {} |
| 582 | for i in range(len(redir_names)): |
| 583 | redir_params = kvm_utils.get_sub_dict(params, redir_names[i]) |
| 584 | guest_port = int(redir_params.get("guest_port")) |
| 585 | self.redirs[guest_port] = host_ports[i] |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 586 | |
lmr | 4834907 | 2010-06-29 14:14:55 +0000 | [diff] [blame] | 587 | for nic in kvm_utils.get_sub_dict_names(params, "nics"): |
| 588 | self.netdev_id.append(kvm_utils.generate_random_id()) |
| 589 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 590 | # Find available VNC port, if needed |
| 591 | if params.get("display") == "vnc": |
lmr | c0da890 | 2010-05-17 20:31:36 +0000 | [diff] [blame] | 592 | self.vnc_port = kvm_utils.find_free_port(5900, 6100) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 593 | |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 594 | # Find random UUID if specified 'uuid = random' in config file |
| 595 | if params.get("uuid") == "random": |
| 596 | f = open("/proc/sys/kernel/random/uuid") |
| 597 | self.uuid = f.read().strip() |
| 598 | f.close() |
| 599 | |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 600 | # Generate or copy MAC addresses for all NICs |
| 601 | num_nics = len(kvm_utils.get_sub_dict_names(params, "nics")) |
| 602 | for vlan in range(num_nics): |
| 603 | mac = mac_source and mac_source.get_mac_address(vlan) |
| 604 | if mac: |
| 605 | kvm_utils.set_mac_address(self.instance, vlan, mac) |
| 606 | else: |
| 607 | kvm_utils.generate_mac_address(self.instance, vlan) |
| 608 | |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 609 | # Assign a PCI assignable device |
| 610 | self.pci_assignable = None |
| 611 | pa_type = params.get("pci_assignable") |
| 612 | if pa_type in ["vf", "pf", "mixed"]: |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 613 | pa_devices_requested = params.get("devices_requested") |
| 614 | |
| 615 | # Virtual Functions (VF) assignable devices |
| 616 | if pa_type == "vf": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 617 | self.pci_assignable = kvm_utils.PciAssignable( |
| 618 | type=pa_type, |
| 619 | driver=params.get("driver"), |
| 620 | driver_option=params.get("driver_option"), |
| 621 | devices_requested=pa_devices_requested) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 622 | # Physical NIC (PF) assignable devices |
| 623 | elif pa_type == "pf": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 624 | self.pci_assignable = kvm_utils.PciAssignable( |
| 625 | type=pa_type, |
| 626 | names=params.get("device_names"), |
| 627 | devices_requested=pa_devices_requested) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 628 | # Working with both VF and PF |
| 629 | elif pa_type == "mixed": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 630 | self.pci_assignable = kvm_utils.PciAssignable( |
| 631 | type=pa_type, |
| 632 | driver=params.get("driver"), |
| 633 | driver_option=params.get("driver_option"), |
| 634 | names=params.get("device_names"), |
| 635 | devices_requested=pa_devices_requested) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 636 | |
| 637 | self.pa_pci_ids = self.pci_assignable.request_devs() |
| 638 | |
| 639 | if self.pa_pci_ids: |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 640 | logging.debug("Successfuly assigned devices: %s", |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 641 | self.pa_pci_ids) |
| 642 | else: |
| 643 | logging.error("No PCI assignable devices were assigned " |
| 644 | "and 'pci_assignable' is defined to %s " |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 645 | "on your config file. Aborting VM creation.", |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 646 | pa_type) |
| 647 | return False |
| 648 | |
lmr | 856d58c | 2010-06-08 18:29:31 +0000 | [diff] [blame] | 649 | elif pa_type and pa_type != "no": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 650 | logging.warn("Unsupported pci_assignable type: %s", pa_type) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 651 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 652 | # Make qemu command |
| 653 | qemu_command = self.make_qemu_command() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 654 | |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 655 | # Add migration parameters if required |
| 656 | if migration_mode == "tcp": |
| 657 | self.migration_port = kvm_utils.find_free_port(5200, 6000) |
| 658 | qemu_command += " -incoming tcp:0:%d" % self.migration_port |
| 659 | elif migration_mode == "unix": |
| 660 | self.migration_file = "/tmp/migration-unix-%s" % self.instance |
| 661 | qemu_command += " -incoming unix:%s" % self.migration_file |
| 662 | elif migration_mode == "exec": |
| 663 | qemu_command += ' -incoming "exec:%s"' % migration_exec_cmd |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 664 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 665 | logging.debug("Running qemu command:\n%s", qemu_command) |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 666 | self.process = kvm_subprocess.run_bg(qemu_command, None, |
| 667 | logging.debug, "(qemu) ") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 668 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 669 | # Make sure the process was started successfully |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 670 | if not self.process.is_alive(): |
| 671 | logging.error("VM could not be created; " |
| 672 | "qemu command failed:\n%s" % qemu_command) |
| 673 | logging.error("Status: %s" % self.process.get_status()) |
| 674 | logging.error("Output:" + kvm_utils.format_str_for_message( |
| 675 | self.process.get_output())) |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 676 | self.destroy() |
| 677 | return False |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 678 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 679 | # Establish monitor connections |
| 680 | self.monitors = [] |
| 681 | for monitor_name in kvm_utils.get_sub_dict_names(params, |
| 682 | "monitors"): |
| 683 | monitor_params = kvm_utils.get_sub_dict(params, monitor_name) |
| 684 | # Wait for monitor connection to succeed |
| 685 | end_time = time.time() + timeout |
| 686 | while time.time() < end_time: |
| 687 | try: |
| 688 | if monitor_params.get("monitor_type") == "qmp": |
lmr | 449d225 | 2010-06-18 03:48:23 +0000 | [diff] [blame] | 689 | # Add a QMP monitor |
| 690 | monitor = kvm_monitor.QMPMonitor( |
| 691 | monitor_name, |
| 692 | self.get_monitor_filename(monitor_name)) |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 693 | else: |
| 694 | # Add a "human" monitor |
| 695 | monitor = kvm_monitor.HumanMonitor( |
| 696 | monitor_name, |
| 697 | self.get_monitor_filename(monitor_name)) |
| 698 | except kvm_monitor.MonitorError, e: |
| 699 | logging.warn(e) |
| 700 | else: |
lmr | 449d225 | 2010-06-18 03:48:23 +0000 | [diff] [blame] | 701 | if monitor.is_responsive(): |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 702 | break |
| 703 | time.sleep(1) |
| 704 | else: |
| 705 | logging.error("Could not connect to monitor '%s'" % |
| 706 | monitor_name) |
| 707 | self.destroy() |
| 708 | return False |
| 709 | # Add this monitor to the list |
| 710 | self.monitors += [monitor] |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 711 | |
lmr | fe6515e | 2009-07-29 13:01:17 +0000 | [diff] [blame] | 712 | # Get the output so far, to see if we have any problems with |
lmr | b306bf8 | 2010-07-08 23:47:00 +0000 | [diff] [blame] | 713 | # KVM modules or with hugepage setup. |
lmr | fe6515e | 2009-07-29 13:01:17 +0000 | [diff] [blame] | 714 | output = self.process.get_output() |
| 715 | |
lmr | b306bf8 | 2010-07-08 23:47:00 +0000 | [diff] [blame] | 716 | if re.search("Could not initialize KVM", output, re.IGNORECASE): |
| 717 | logging.error("Could not initialize KVM; " |
| 718 | "qemu command:\n%s" % qemu_command) |
| 719 | logging.error("Output:" + kvm_utils.format_str_for_message( |
| 720 | self.process.get_output())) |
| 721 | self.destroy() |
| 722 | return False |
| 723 | |
lmr | fe6515e | 2009-07-29 13:01:17 +0000 | [diff] [blame] | 724 | if "alloc_mem_area" in output: |
| 725 | logging.error("Could not allocate hugepage memory; " |
| 726 | "qemu command:\n%s" % qemu_command) |
| 727 | logging.error("Output:" + kvm_utils.format_str_for_message( |
| 728 | self.process.get_output())) |
lmr | 090cd7a | 2010-04-01 02:18:52 +0000 | [diff] [blame] | 729 | self.destroy() |
lmr | fe6515e | 2009-07-29 13:01:17 +0000 | [diff] [blame] | 730 | return False |
| 731 | |
lmr | 71fa4de | 2010-06-14 15:54:55 +0000 | [diff] [blame] | 732 | logging.debug("VM appears to be alive with PID %s", self.get_pid()) |
lmr | aa380a2 | 2010-06-22 02:05:29 +0000 | [diff] [blame] | 733 | |
| 734 | # Establish a session with the serial console -- requires a version |
| 735 | # of netcat that supports -U |
| 736 | self.serial_console = kvm_subprocess.kvm_shell_session( |
| 737 | "nc -U %s" % self.get_serial_console_filename(), |
| 738 | auto_close=False, |
| 739 | output_func=kvm_utils.log_line, |
| 740 | output_params=("serial-%s.log" % name,)) |
| 741 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 742 | return True |
| 743 | |
| 744 | finally: |
| 745 | fcntl.lockf(lockfile, fcntl.LOCK_UN) |
| 746 | lockfile.close() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 747 | |
| 748 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 749 | def destroy(self, gracefully=True): |
| 750 | """ |
| 751 | Destroy the VM. |
| 752 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 753 | If gracefully is True, first attempt to shutdown the VM with a shell |
| 754 | command. Then, attempt to destroy the VM via the monitor with a 'quit' |
| 755 | command. If that fails, send SIGKILL to the qemu process. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 756 | |
| 757 | @param gracefully: Whether an attempt will be made to end the VM |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 758 | using a shell command before trying to end the qemu process |
| 759 | with a 'quit' or a kill signal. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 760 | """ |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 761 | try: |
| 762 | # Is it already dead? |
| 763 | if self.is_dead(): |
| 764 | logging.debug("VM is already down") |
| 765 | return |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 766 | |
lmr | 71fa4de | 2010-06-14 15:54:55 +0000 | [diff] [blame] | 767 | logging.debug("Destroying VM with PID %s...", self.get_pid()) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 768 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 769 | if gracefully and self.params.get("shutdown_command"): |
| 770 | # Try to destroy with shell command |
| 771 | logging.debug("Trying to shutdown VM with shell command...") |
| 772 | session = self.remote_login() |
| 773 | if session: |
| 774 | try: |
| 775 | # Send the shutdown command |
| 776 | session.sendline(self.params.get("shutdown_command")) |
| 777 | logging.debug("Shutdown command sent; waiting for VM " |
| 778 | "to go down...") |
| 779 | if kvm_utils.wait_for(self.is_dead, 60, 1, 1): |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 780 | logging.debug("VM is down, freeing mac address.") |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 781 | return |
| 782 | finally: |
| 783 | session.close() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 784 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 785 | if self.monitor: |
| 786 | # Try to destroy with a monitor command |
| 787 | logging.debug("Trying to kill VM with monitor command...") |
| 788 | try: |
| 789 | self.monitor.quit() |
| 790 | except kvm_monitor.MonitorError, e: |
| 791 | logging.warn(e) |
| 792 | else: |
| 793 | # Wait for the VM to be really dead |
| 794 | if kvm_utils.wait_for(self.is_dead, 5, 0.5, 0.5): |
| 795 | logging.debug("VM is down") |
| 796 | return |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 797 | |
| 798 | # If the VM isn't dead yet... |
| 799 | logging.debug("Cannot quit normally; sending a kill to close the " |
| 800 | "deal...") |
| 801 | kvm_utils.kill_process_tree(self.process.get_pid(), 9) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 802 | # Wait for the VM to be really dead |
| 803 | if kvm_utils.wait_for(self.is_dead, 5, 0.5, 0.5): |
| 804 | logging.debug("VM is down") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 805 | return |
| 806 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 807 | logging.error("Process %s is a zombie!" % self.process.get_pid()) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 808 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 809 | finally: |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 810 | self.monitors = [] |
lmr | 4513c43 | 2010-02-03 11:59:03 +0000 | [diff] [blame] | 811 | if self.pci_assignable: |
| 812 | self.pci_assignable.release_devs() |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 813 | if self.process: |
| 814 | self.process.close() |
lmr | aa380a2 | 2010-06-22 02:05:29 +0000 | [diff] [blame] | 815 | if self.serial_console: |
| 816 | self.serial_console.close() |
lmr | 84546f2 | 2010-06-29 23:03:34 +0000 | [diff] [blame] | 817 | for f in ([self.get_testlog_filename(), |
| 818 | self.get_serial_console_filename()] + |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 819 | self.get_monitor_filenames()): |
| 820 | try: |
| 821 | os.unlink(f) |
| 822 | except OSError: |
| 823 | pass |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 824 | if hasattr(self, "migration_file"): |
| 825 | try: |
| 826 | os.unlink(self.migration_file) |
| 827 | except OSError: |
| 828 | pass |
| 829 | num_nics = len(kvm_utils.get_sub_dict_names(self.params, "nics")) |
| 830 | for vlan in range(num_nics): |
| 831 | self.free_mac_address(vlan) |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 832 | |
| 833 | |
| 834 | @property |
| 835 | def monitor(self): |
| 836 | """ |
| 837 | Return the main monitor object, selected by the parameter main_monitor. |
| 838 | If main_monitor isn't defined, return the first monitor. |
| 839 | If no monitors exist, or if main_monitor refers to a nonexistent |
| 840 | monitor, return None. |
| 841 | """ |
| 842 | for m in self.monitors: |
| 843 | if m.name == self.params.get("main_monitor"): |
| 844 | return m |
| 845 | if self.monitors and not self.params.get("main_monitor"): |
| 846 | return self.monitors[0] |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 847 | |
| 848 | |
| 849 | def is_alive(self): |
| 850 | """ |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 851 | Return True if the VM is alive and its monitor is responsive. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 852 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 853 | # Check if the process is running |
| 854 | if self.is_dead(): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 855 | return False |
| 856 | # Try sending a monitor command |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 857 | return bool(self.monitor) and self.monitor.is_responsive() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 858 | |
| 859 | |
| 860 | def is_dead(self): |
| 861 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 862 | Return True if the qemu process is dead. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 863 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 864 | return not self.process or not self.process.is_alive() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 865 | |
| 866 | |
| 867 | def get_params(self): |
| 868 | """ |
| 869 | Return the VM's params dict. Most modified params take effect only |
| 870 | upon VM.create(). |
| 871 | """ |
| 872 | return self.params |
| 873 | |
| 874 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 875 | def get_monitor_filename(self, monitor_name): |
| 876 | """ |
| 877 | Return the filename corresponding to a given monitor name. |
| 878 | """ |
| 879 | return "/tmp/monitor-%s-%s" % (monitor_name, self.instance) |
| 880 | |
| 881 | |
| 882 | def get_monitor_filenames(self): |
| 883 | """ |
| 884 | Return a list of all monitor filenames (as specified in the VM's |
| 885 | params). |
| 886 | """ |
| 887 | return [self.get_monitor_filename(m) for m in |
| 888 | kvm_utils.get_sub_dict_names(self.params, "monitors")] |
| 889 | |
| 890 | |
lmr | 2b06f33 | 2010-06-22 02:03:41 +0000 | [diff] [blame] | 891 | def get_serial_console_filename(self): |
| 892 | """ |
| 893 | Return the serial console filename. |
| 894 | """ |
| 895 | return "/tmp/serial-%s" % self.instance |
| 896 | |
| 897 | |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 898 | def get_testlog_filename(self): |
| 899 | """ |
| 900 | Return the testlog filename. |
| 901 | """ |
| 902 | return "/tmp/testlog-%s" % self.instance |
| 903 | |
| 904 | |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 905 | def get_address(self, index=0): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 906 | """ |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 907 | Return the address of a NIC of the guest, in host space. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 908 | |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 909 | If port redirection is used, return 'localhost' (the NIC has no IP |
| 910 | address of its own). Otherwise return the NIC's IP address. |
| 911 | |
| 912 | @param index: Index of the NIC whose address is requested. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 913 | """ |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 914 | nics = kvm_utils.get_sub_dict_names(self.params, "nics") |
| 915 | nic_name = nics[index] |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 916 | nic_params = kvm_utils.get_sub_dict(self.params, nic_name) |
| 917 | if nic_params.get("nic_mode") == "tap": |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 918 | mac = self.get_mac_address(index) |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 919 | if not mac: |
| 920 | logging.debug("MAC address unavailable") |
| 921 | return None |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 922 | mac = mac.lower() |
| 923 | # Get the IP address from the cache |
| 924 | ip = self.address_cache.get(mac) |
| 925 | if not ip: |
| 926 | logging.debug("Could not find IP address for MAC address: %s" % |
| 927 | mac) |
| 928 | return None |
| 929 | # Make sure the IP address is assigned to this guest |
| 930 | macs = [self.get_mac_address(i) for i in range(len(nics))] |
| 931 | if not kvm_utils.verify_ip_address_ownership(ip, macs): |
| 932 | logging.debug("Could not verify MAC-IP address mapping: " |
| 933 | "%s ---> %s" % (mac, ip)) |
| 934 | return None |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 935 | return ip |
| 936 | else: |
| 937 | return "localhost" |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 938 | |
| 939 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 940 | def get_port(self, port, nic_index=0): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 941 | """ |
| 942 | Return the port in host space corresponding to port in guest space. |
| 943 | |
| 944 | @param port: Port number in host space. |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 945 | @param nic_index: Index of the NIC. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 946 | @return: If port redirection is used, return the host port redirected |
| 947 | to guest port port. Otherwise return port. |
| 948 | """ |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 949 | nic_name = kvm_utils.get_sub_dict_names(self.params, "nics")[nic_index] |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 950 | nic_params = kvm_utils.get_sub_dict(self.params, nic_name) |
| 951 | if nic_params.get("nic_mode") == "tap": |
| 952 | return port |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 953 | else: |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 954 | if not self.redirs.has_key(port): |
| 955 | logging.warn("Warning: guest port %s requested but not " |
| 956 | "redirected" % port) |
| 957 | return self.redirs.get(port) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 958 | |
| 959 | |
Eric Li | e0493a4 | 2010-11-15 13:05:43 -0800 | [diff] [blame] | 960 | def get_ifname(self, nic_index=0): |
| 961 | """ |
| 962 | Return the ifname of a tap device associated with a NIC. |
| 963 | |
| 964 | @param nic_index: Index of the NIC |
| 965 | """ |
| 966 | nics = kvm_utils.get_sub_dict_names(self.params, "nics") |
| 967 | nic_name = nics[nic_index] |
| 968 | nic_params = kvm_utils.get_sub_dict(self.params, nic_name) |
| 969 | if nic_params.get("nic_ifname"): |
| 970 | return nic_params.get("nic_ifname") |
| 971 | else: |
| 972 | return "t%d-%s" % (nic_index, self.instance[-11:]) |
| 973 | |
| 974 | |
| 975 | def get_mac_address(self, nic_index=0): |
| 976 | """ |
| 977 | Return the MAC address of a NIC. |
| 978 | |
| 979 | @param nic_index: Index of the NIC |
| 980 | """ |
| 981 | return kvm_utils.get_mac_address(self.instance, nic_index) |
| 982 | |
| 983 | |
| 984 | def free_mac_address(self, nic_index=0): |
| 985 | """ |
| 986 | Free a NIC's MAC address. |
| 987 | |
| 988 | @param nic_index: Index of the NIC |
| 989 | """ |
| 990 | kvm_utils.free_mac_address(self.instance, nic_index) |
| 991 | |
| 992 | |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 993 | def get_pid(self): |
| 994 | """ |
lmr | 71fa4de | 2010-06-14 15:54:55 +0000 | [diff] [blame] | 995 | Return the VM's PID. If the VM is dead return None. |
| 996 | |
| 997 | @note: This works under the assumption that self.process.get_pid() |
| 998 | returns the PID of the parent shell process. |
| 999 | """ |
| 1000 | try: |
| 1001 | children = commands.getoutput("ps --ppid=%d -o pid=" % |
| 1002 | self.process.get_pid()).split() |
| 1003 | return int(children[0]) |
| 1004 | except (TypeError, IndexError, ValueError): |
| 1005 | return None |
| 1006 | |
| 1007 | |
| 1008 | def get_shell_pid(self): |
| 1009 | """ |
| 1010 | Return the PID of the parent shell process. |
| 1011 | |
| 1012 | @note: This works under the assumption that self.process.get_pid() |
| 1013 | returns the PID of the parent shell process. |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 1014 | """ |
| 1015 | return self.process.get_pid() |
| 1016 | |
| 1017 | |
lmr | 0bee234 | 2010-02-24 00:01:37 +0000 | [diff] [blame] | 1018 | def get_shared_meminfo(self): |
| 1019 | """ |
| 1020 | Returns the VM's shared memory information. |
| 1021 | |
| 1022 | @return: Shared memory used by VM (MB) |
| 1023 | """ |
| 1024 | if self.is_dead(): |
| 1025 | logging.error("Could not get shared memory info from dead VM.") |
| 1026 | return None |
| 1027 | |
lmr | 983ecdf | 2010-06-14 15:57:12 +0000 | [diff] [blame] | 1028 | filename = "/proc/%d/statm" % self.get_pid() |
| 1029 | shm = int(open(filename).read().split()[2]) |
lmr | 0bee234 | 2010-02-24 00:01:37 +0000 | [diff] [blame] | 1030 | # statm stores informations in pages, translate it to MB |
lmr | 983ecdf | 2010-06-14 15:57:12 +0000 | [diff] [blame] | 1031 | return shm * 4.0 / 1024 |
lmr | 0bee234 | 2010-02-24 00:01:37 +0000 | [diff] [blame] | 1032 | |
| 1033 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1034 | def remote_login(self, nic_index=0, timeout=10): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1035 | """ |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1036 | Log into the guest via SSH/Telnet/Netcat. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1037 | If timeout expires while waiting for output from the guest (e.g. a |
| 1038 | password prompt or a shell prompt) -- fail. |
| 1039 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1040 | @param nic_index: The index of the NIC to connect to. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1041 | @param timeout: Time (seconds) before giving up logging into the |
| 1042 | guest. |
| 1043 | @return: kvm_spawn object on success and None on failure. |
| 1044 | """ |
| 1045 | username = self.params.get("username", "") |
| 1046 | password = self.params.get("password", "") |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1047 | prompt = self.params.get("shell_prompt", "[\#\$]") |
lmr | 59f9e2d | 2009-10-05 18:47:16 +0000 | [diff] [blame] | 1048 | linesep = eval("'%s'" % self.params.get("shell_linesep", r"\n")) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1049 | client = self.params.get("shell_client") |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1050 | address = self.get_address(nic_index) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1051 | port = self.get_port(int(self.params.get("shell_port"))) |
lmr | e56903f | 2010-06-22 02:09:35 +0000 | [diff] [blame] | 1052 | log_filename = ("session-%s-%s.log" % |
| 1053 | (self.name, kvm_utils.generate_random_string(4))) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1054 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1055 | if not address or not port: |
| 1056 | logging.debug("IP address or port unavailable") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1057 | return None |
| 1058 | |
lmr | 158604f | 2010-06-22 01:57:34 +0000 | [diff] [blame] | 1059 | session = kvm_utils.remote_login(client, address, port, username, |
lmr | e56903f | 2010-06-22 02:09:35 +0000 | [diff] [blame] | 1060 | password, prompt, linesep, |
| 1061 | log_filename, timeout) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1062 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1063 | if session: |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1064 | session.set_status_test_command(self.params.get("status_test_" |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1065 | "command", "")) |
| 1066 | return session |
| 1067 | |
| 1068 | |
lmr | c196d49 | 2010-05-07 14:14:26 +0000 | [diff] [blame] | 1069 | def copy_files_to(self, local_path, remote_path, nic_index=0, timeout=600): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1070 | """ |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1071 | Transfer files to the guest. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1072 | |
| 1073 | @param local_path: Host path |
| 1074 | @param remote_path: Guest path |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1075 | @param nic_index: The index of the NIC to connect to. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1076 | @param timeout: Time (seconds) before giving up on doing the remote |
| 1077 | copy. |
| 1078 | """ |
| 1079 | username = self.params.get("username", "") |
| 1080 | password = self.params.get("password", "") |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1081 | client = self.params.get("file_transfer_client") |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1082 | address = self.get_address(nic_index) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1083 | port = self.get_port(int(self.params.get("file_transfer_port"))) |
| 1084 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1085 | if not address or not port: |
| 1086 | logging.debug("IP address or port unavailable") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1087 | return None |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1088 | |
| 1089 | if client == "scp": |
lmr | cbc86ef | 2010-07-07 20:50:08 +0000 | [diff] [blame] | 1090 | log_filename = ("scp-%s-%s.log" % |
| 1091 | (self.name, kvm_utils.generate_random_string(4))) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1092 | return kvm_utils.scp_to_remote(address, port, username, password, |
lmr | e56903f | 2010-06-22 02:09:35 +0000 | [diff] [blame] | 1093 | local_path, remote_path, |
| 1094 | log_filename, timeout) |
lmr | cbc86ef | 2010-07-07 20:50:08 +0000 | [diff] [blame] | 1095 | elif client == "rss": |
| 1096 | c = rss_file_transfer.FileUploadClient(address, port) |
| 1097 | c.upload(local_path, remote_path, timeout) |
| 1098 | c.close() |
| 1099 | return True |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1100 | |
| 1101 | |
lmr | c196d49 | 2010-05-07 14:14:26 +0000 | [diff] [blame] | 1102 | def copy_files_from(self, remote_path, local_path, nic_index=0, timeout=600): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1103 | """ |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1104 | Transfer files from the guest. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1105 | |
| 1106 | @param local_path: Guest path |
| 1107 | @param remote_path: Host path |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1108 | @param nic_index: The index of the NIC to connect to. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1109 | @param timeout: Time (seconds) before giving up on doing the remote |
| 1110 | copy. |
| 1111 | """ |
| 1112 | username = self.params.get("username", "") |
| 1113 | password = self.params.get("password", "") |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1114 | client = self.params.get("file_transfer_client") |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1115 | address = self.get_address(nic_index) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1116 | port = self.get_port(int(self.params.get("file_transfer_port"))) |
| 1117 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 1118 | if not address or not port: |
| 1119 | logging.debug("IP address or port unavailable") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1120 | return None |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1121 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1122 | if client == "scp": |
lmr | cbc86ef | 2010-07-07 20:50:08 +0000 | [diff] [blame] | 1123 | log_filename = ("scp-%s-%s.log" % |
| 1124 | (self.name, kvm_utils.generate_random_string(4))) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 1125 | return kvm_utils.scp_from_remote(address, port, username, password, |
lmr | e56903f | 2010-06-22 02:09:35 +0000 | [diff] [blame] | 1126 | remote_path, local_path, |
| 1127 | log_filename, timeout) |
lmr | cbc86ef | 2010-07-07 20:50:08 +0000 | [diff] [blame] | 1128 | elif client == "rss": |
| 1129 | c = rss_file_transfer.FileDownloadClient(address, port) |
| 1130 | c.download(remote_path, local_path, timeout) |
| 1131 | c.close() |
| 1132 | return True |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1133 | |
| 1134 | |
lmr | aa380a2 | 2010-06-22 02:05:29 +0000 | [diff] [blame] | 1135 | def serial_login(self, timeout=10): |
| 1136 | """ |
| 1137 | Log into the guest via the serial console. |
| 1138 | If timeout expires while waiting for output from the guest (e.g. a |
| 1139 | password prompt or a shell prompt) -- fail. |
| 1140 | |
| 1141 | @param timeout: Time (seconds) before giving up logging into the guest. |
| 1142 | @return: kvm_spawn object on success and None on failure. |
| 1143 | """ |
| 1144 | username = self.params.get("username", "") |
| 1145 | password = self.params.get("password", "") |
| 1146 | prompt = self.params.get("shell_prompt", "[\#\$]") |
| 1147 | linesep = eval("'%s'" % self.params.get("shell_linesep", r"\n")) |
| 1148 | status_test_command = self.params.get("status_test_command", "") |
| 1149 | |
| 1150 | if self.serial_console: |
| 1151 | self.serial_console.set_linesep(linesep) |
| 1152 | self.serial_console.set_status_test_command(status_test_command) |
| 1153 | else: |
| 1154 | return None |
| 1155 | |
| 1156 | # Make sure we get a login prompt |
| 1157 | self.serial_console.sendline() |
| 1158 | |
| 1159 | if kvm_utils._remote_login(self.serial_console, username, password, |
| 1160 | prompt, timeout): |
| 1161 | return self.serial_console |
| 1162 | |
| 1163 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1164 | def send_key(self, keystr): |
| 1165 | """ |
| 1166 | Send a key event to the VM. |
| 1167 | |
| 1168 | @param: keystr: A key event string (e.g. "ctrl-alt-delete") |
| 1169 | """ |
| 1170 | # For compatibility with versions of QEMU that do not recognize all |
| 1171 | # key names: replace keyname with the hex value from the dict, which |
| 1172 | # QEMU will definitely accept |
lmr | 9e964a0 | 2010-06-18 03:46:21 +0000 | [diff] [blame] | 1173 | dict = {"comma": "0x33", |
| 1174 | "dot": "0x34", |
| 1175 | "slash": "0x35"} |
| 1176 | for key, value in dict.items(): |
| 1177 | keystr = keystr.replace(key, value) |
| 1178 | self.monitor.sendkey(keystr) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1179 | time.sleep(0.2) |
| 1180 | |
| 1181 | |
| 1182 | def send_string(self, str): |
| 1183 | """ |
| 1184 | Send a string to the VM. |
| 1185 | |
| 1186 | @param str: String, that must consist of alphanumeric characters only. |
| 1187 | Capital letters are allowed. |
| 1188 | """ |
| 1189 | for char in str: |
| 1190 | if char.isupper(): |
| 1191 | self.send_key("shift-%s" % char.lower()) |
| 1192 | else: |
| 1193 | self.send_key(char) |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 1194 | |
mbligh | 1ef218d | 2009-08-03 16:57:56 +0000 | [diff] [blame] | 1195 | |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 1196 | def get_uuid(self): |
| 1197 | """ |
| 1198 | Catch UUID of the VM. |
| 1199 | |
| 1200 | @return: None,if not specified in config file |
| 1201 | """ |
| 1202 | if self.params.get("uuid") == "random": |
| 1203 | return self.uuid |
| 1204 | else: |
| 1205 | return self.params.get("uuid", None) |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1206 | |
| 1207 | |
| 1208 | def get_cpu_count(self): |
| 1209 | """ |
| 1210 | Get the cpu count of the VM. |
| 1211 | """ |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1212 | session = self.remote_login() |
| 1213 | if not session: |
| 1214 | return None |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1215 | try: |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1216 | cmd = self.params.get("cpu_chk_cmd") |
| 1217 | s, count = session.get_command_status_output(cmd) |
| 1218 | if s == 0: |
| 1219 | return int(count) |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1220 | return None |
| 1221 | finally: |
| 1222 | session.close() |
| 1223 | |
| 1224 | |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1225 | def get_memory_size(self, cmd=None): |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1226 | """ |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1227 | Get bootup memory size of the VM. |
| 1228 | |
| 1229 | @param check_cmd: Command used to check memory. If not provided, |
| 1230 | self.params.get("mem_chk_cmd") will be used. |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1231 | """ |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1232 | session = self.remote_login() |
| 1233 | if not session: |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1234 | return None |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1235 | try: |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1236 | if not cmd: |
| 1237 | cmd = self.params.get("mem_chk_cmd") |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1238 | s, mem_str = session.get_command_status_output(cmd) |
| 1239 | if s != 0: |
| 1240 | return None |
lmr | 6d69f4d | 2010-02-12 11:35:55 +0000 | [diff] [blame] | 1241 | mem = re.findall("([0-9]+)", mem_str) |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1242 | mem_size = 0 |
| 1243 | for m in mem: |
| 1244 | mem_size += int(m) |
| 1245 | if "GB" in mem_str: |
| 1246 | mem_size *= 1024 |
| 1247 | elif "MB" in mem_str: |
| 1248 | pass |
| 1249 | else: |
| 1250 | mem_size /= 1024 |
| 1251 | return int(mem_size) |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1252 | finally: |
| 1253 | session.close() |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1254 | |
| 1255 | |
| 1256 | def get_current_memory_size(self): |
| 1257 | """ |
| 1258 | Get current memory size of the VM, rather than bootup memory. |
| 1259 | """ |
| 1260 | cmd = self.params.get("mem_chk_cur_cmd") |
| 1261 | return self.get_memory_size(cmd) |