1#!/usr/bin/env python 2# 3# Tests for IO throttling 4# 5# Copyright (C) 2015 Red Hat, Inc. 6# Copyright (C) 2015-2016 Igalia, S.L. 7# 8# This program is free software; you can redistribute it and/or modify 9# it under the terms of the GNU General Public License as published by 10# the Free Software Foundation; either version 2 of the License, or 11# (at your option) any later version. 12# 13# This program is distributed in the hope that it will be useful, 14# but WITHOUT ANY WARRANTY; without even the implied warranty of 15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16# GNU General Public License for more details. 17# 18# You should have received a copy of the GNU General Public License 19# along with this program. If not, see <http://www.gnu.org/licenses/>. 20# 21 22import iotests 23 24nsec_per_sec = 1000000000 25 26class ThrottleTestCase(iotests.QMPTestCase): 27 test_img = "null-aio://" 28 max_drives = 3 29 30 def blockstats(self, device): 31 result = self.vm.qmp("query-blockstats") 32 for r in result['return']: 33 if r['device'] == device: 34 stat = r['stats'] 35 return stat['rd_bytes'], stat['rd_operations'], stat['wr_bytes'], stat['wr_operations'] 36 raise Exception("Device not found for blockstats: %s" % device) 37 38 def setUp(self): 39 self.vm = iotests.VM() 40 for i in range(0, self.max_drives): 41 self.vm.add_drive(self.test_img, "file.read-zeroes=on") 42 self.vm.launch() 43 44 def tearDown(self): 45 self.vm.shutdown() 46 47 def configure_throttle(self, ndrives, params): 48 params['group'] = 'test' 49 50 # Set the I/O throttling parameters to all drives 51 for i in range(0, ndrives): 52 params['device'] = 'drive%d' % i 53 result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **params) 54 self.assert_qmp(result, 'return', {}) 55 56 def do_test_throttle(self, ndrives, seconds, params, first_drive = 0): 57 def check_limit(limit, num): 58 # IO throttling algorithm is discrete, allow 10% error so the test 59 # is more robust 60 return limit == 0 or \ 61 (num < seconds * limit * 1.1 / ndrives 62 and num > seconds * limit * 0.9 / ndrives) 63 64 # Set vm clock to a known value 65 ns = seconds * nsec_per_sec 66 self.vm.qtest("clock_step %d" % ns) 67 68 # Submit enough requests so the throttling mechanism kicks 69 # in. The throttled requests won't be executed until we 70 # advance the virtual clock. 71 rq_size = 512 72 rd_nr = max(params['bps'] // rq_size // 2, 73 params['bps_rd'] // rq_size, 74 params['iops'] // 2, 75 params['iops_rd']) 76 rd_nr *= seconds * 2 77 rd_nr //= ndrives 78 wr_nr = max(params['bps'] // rq_size // 2, 79 params['bps_wr'] // rq_size, 80 params['iops'] // 2, 81 params['iops_wr']) 82 wr_nr *= seconds * 2 83 wr_nr //= ndrives 84 85 # Send I/O requests to all drives 86 for i in range(rd_nr): 87 for drive in range(0, ndrives): 88 idx = first_drive + drive 89 self.vm.hmp_qemu_io("drive%d" % idx, "aio_read %d %d" % 90 (i * rq_size, rq_size)) 91 92 for i in range(wr_nr): 93 for drive in range(0, ndrives): 94 idx = first_drive + drive 95 self.vm.hmp_qemu_io("drive%d" % idx, "aio_write %d %d" % 96 (i * rq_size, rq_size)) 97 98 # We'll store the I/O stats for each drive in these arrays 99 start_rd_bytes = [0] * ndrives 100 start_rd_iops = [0] * ndrives 101 start_wr_bytes = [0] * ndrives 102 start_wr_iops = [0] * ndrives 103 end_rd_bytes = [0] * ndrives 104 end_rd_iops = [0] * ndrives 105 end_wr_bytes = [0] * ndrives 106 end_wr_iops = [0] * ndrives 107 108 # Read the stats before advancing the clock 109 for i in range(0, ndrives): 110 idx = first_drive + i 111 start_rd_bytes[i], start_rd_iops[i], start_wr_bytes[i], \ 112 start_wr_iops[i] = self.blockstats('drive%d' % idx) 113 114 self.vm.qtest("clock_step %d" % ns) 115 116 # Read the stats after advancing the clock 117 for i in range(0, ndrives): 118 idx = first_drive + i 119 end_rd_bytes[i], end_rd_iops[i], end_wr_bytes[i], \ 120 end_wr_iops[i] = self.blockstats('drive%d' % idx) 121 122 # Check that the I/O is within the limits and evenly distributed 123 for i in range(0, ndrives): 124 rd_bytes = end_rd_bytes[i] - start_rd_bytes[i] 125 rd_iops = end_rd_iops[i] - start_rd_iops[i] 126 wr_bytes = end_wr_bytes[i] - start_wr_bytes[i] 127 wr_iops = end_wr_iops[i] - start_wr_iops[i] 128 129 self.assertTrue(check_limit(params['bps'], rd_bytes + wr_bytes)) 130 self.assertTrue(check_limit(params['bps_rd'], rd_bytes)) 131 self.assertTrue(check_limit(params['bps_wr'], wr_bytes)) 132 self.assertTrue(check_limit(params['iops'], rd_iops + wr_iops)) 133 self.assertTrue(check_limit(params['iops_rd'], rd_iops)) 134 self.assertTrue(check_limit(params['iops_wr'], wr_iops)) 135 136 # Allow remaining requests to finish. We submitted twice as many to 137 # ensure the throttle limit is reached. 138 self.vm.qtest("clock_step %d" % ns) 139 140 # Connect N drives to a VM and test I/O in all of them 141 def test_all(self): 142 params = {"bps": 4096, 143 "bps_rd": 4096, 144 "bps_wr": 4096, 145 "iops": 10, 146 "iops_rd": 10, 147 "iops_wr": 10, 148 } 149 # Repeat the test with different numbers of drives 150 for ndrives in range(1, self.max_drives + 1): 151 # Pick each out of all possible params and test 152 for tk in params: 153 limits = dict([(k, 0) for k in params]) 154 limits[tk] = params[tk] * ndrives 155 self.configure_throttle(ndrives, limits) 156 self.do_test_throttle(ndrives, 5, limits) 157 158 # Connect N drives to a VM and test I/O in just one of them a time 159 def test_one(self): 160 params = {"bps": 4096, 161 "bps_rd": 4096, 162 "bps_wr": 4096, 163 "iops": 10, 164 "iops_rd": 10, 165 "iops_wr": 10, 166 } 167 # Repeat the test for each one of the drives 168 for drive in range(0, self.max_drives): 169 # Pick each out of all possible params and test 170 for tk in params: 171 limits = dict([(k, 0) for k in params]) 172 limits[tk] = params[tk] * self.max_drives 173 self.configure_throttle(self.max_drives, limits) 174 self.do_test_throttle(1, 5, limits, drive) 175 176 def test_burst(self): 177 params = {"bps": 4096, 178 "bps_rd": 4096, 179 "bps_wr": 4096, 180 "iops": 10, 181 "iops_rd": 10, 182 "iops_wr": 10, 183 } 184 ndrives = 1 185 # Pick each out of all possible params and test 186 for tk in params: 187 rate = params[tk] * ndrives 188 burst_rate = rate * 7 189 burst_length = 4 190 191 # Configure the throttling settings 192 settings = dict([(k, 0) for k in params]) 193 settings[tk] = rate 194 settings['%s_max' % tk] = burst_rate 195 settings['%s_max_length' % tk] = burst_length 196 self.configure_throttle(ndrives, settings) 197 198 # Wait for the bucket to empty so we can do bursts 199 wait_ns = nsec_per_sec * burst_length * burst_rate // rate 200 self.vm.qtest("clock_step %d" % wait_ns) 201 202 # Test I/O at the max burst rate 203 limits = dict([(k, 0) for k in params]) 204 limits[tk] = burst_rate 205 self.do_test_throttle(ndrives, burst_length, limits) 206 207 # Now test I/O at the normal rate 208 limits[tk] = rate 209 self.do_test_throttle(ndrives, 5, limits) 210 211 # Test that removing a drive from a throttle group should not 212 # affect the remaining members of the group. 213 # https://bugzilla.redhat.com/show_bug.cgi?id=1535914 214 def test_remove_group_member(self): 215 # Create a throttle group with two drives 216 # and set a 4 KB/s read limit. 217 params = {"bps": 0, 218 "bps_rd": 4096, 219 "bps_wr": 0, 220 "iops": 0, 221 "iops_rd": 0, 222 "iops_wr": 0 } 223 self.configure_throttle(2, params) 224 225 # Read 4KB from drive0. This is performed immediately. 226 self.vm.hmp_qemu_io("drive0", "aio_read 0 4096") 227 228 # Read 2KB. The I/O limit has been exceeded so this 229 # request is throttled and a timer is set to wake it up. 230 self.vm.hmp_qemu_io("drive0", "aio_read 0 2048") 231 232 # Read 2KB again. We're still over the I/O limit so this is 233 # request is also throttled, but no new timer is set since 234 # there's already one. 235 self.vm.hmp_qemu_io("drive0", "aio_read 0 2048") 236 237 # Read from drive1. This request is also throttled, and no 238 # timer is set in drive1 because there's already one in 239 # drive0. 240 self.vm.hmp_qemu_io("drive1", "aio_read 0 4096") 241 242 # At this point only the first 4KB have been read from drive0. 243 # The other requests are throttled. 244 self.assertEqual(self.blockstats('drive0')[0], 4096) 245 self.assertEqual(self.blockstats('drive1')[0], 0) 246 247 # Remove drive0 from the throttle group and disable its I/O limits. 248 # drive1 remains in the group with a throttled request. 249 params['bps_rd'] = 0 250 params['device'] = 'drive0' 251 result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **params) 252 self.assert_qmp(result, 'return', {}) 253 254 # Removing the I/O limits from drive0 drains its two pending requests. 255 # The read request in drive1 is still throttled. 256 self.assertEqual(self.blockstats('drive0')[0], 8192) 257 self.assertEqual(self.blockstats('drive1')[0], 0) 258 259 # Advance the clock 5 seconds. This completes the request in drive1 260 self.vm.qtest("clock_step %d" % (5 * nsec_per_sec)) 261 262 # Now all requests have been processed. 263 self.assertEqual(self.blockstats('drive0')[0], 8192) 264 self.assertEqual(self.blockstats('drive1')[0], 4096) 265 266class ThrottleTestCoroutine(ThrottleTestCase): 267 test_img = "null-co://" 268 269class ThrottleTestGroupNames(iotests.QMPTestCase): 270 test_img = "null-aio://" 271 max_drives = 3 272 273 def setUp(self): 274 self.vm = iotests.VM() 275 for i in range(0, self.max_drives): 276 self.vm.add_drive(self.test_img, 277 "throttling.iops-total=100,file.read-zeroes=on") 278 self.vm.launch() 279 280 def tearDown(self): 281 self.vm.shutdown() 282 283 def set_io_throttle(self, device, params): 284 params["device"] = device 285 result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **params) 286 self.assert_qmp(result, 'return', {}) 287 288 def verify_name(self, device, name): 289 result = self.vm.qmp("query-block") 290 for r in result["return"]: 291 if r["device"] == device: 292 info = r["inserted"] 293 if name: 294 self.assertEqual(info["group"], name) 295 else: 296 self.assertFalse('group' in info) 297 return 298 299 raise Exception("No group information found for '%s'" % device) 300 301 def test_group_naming(self): 302 params = {"bps": 0, 303 "bps_rd": 0, 304 "bps_wr": 0, 305 "iops": 0, 306 "iops_rd": 0, 307 "iops_wr": 0} 308 309 # Check the drives added using the command line. 310 # The default throttling group name is the device name. 311 for i in range(self.max_drives): 312 devname = "drive%d" % i 313 self.verify_name(devname, devname) 314 315 # Clear throttling settings => the group name is gone. 316 for i in range(self.max_drives): 317 devname = "drive%d" % i 318 self.set_io_throttle(devname, params) 319 self.verify_name(devname, None) 320 321 # Set throttling settings using block_set_io_throttle and 322 # check the default group names. 323 params["iops"] = 10 324 for i in range(self.max_drives): 325 devname = "drive%d" % i 326 self.set_io_throttle(devname, params) 327 self.verify_name(devname, devname) 328 329 # Set a custom group name for each device 330 for i in range(3): 331 devname = "drive%d" % i 332 groupname = "group%d" % i 333 params['group'] = groupname 334 self.set_io_throttle(devname, params) 335 self.verify_name(devname, groupname) 336 337 # Put drive0 in group1 and check that all other devices remain 338 # unchanged 339 params['group'] = 'group1' 340 self.set_io_throttle('drive0', params) 341 self.verify_name('drive0', 'group1') 342 for i in range(1, self.max_drives): 343 devname = "drive%d" % i 344 groupname = "group%d" % i 345 self.verify_name(devname, groupname) 346 347 # Put drive0 in group2 and check that all other devices remain 348 # unchanged 349 params['group'] = 'group2' 350 self.set_io_throttle('drive0', params) 351 self.verify_name('drive0', 'group2') 352 for i in range(1, self.max_drives): 353 devname = "drive%d" % i 354 groupname = "group%d" % i 355 self.verify_name(devname, groupname) 356 357 # Clear throttling settings from drive0 check that all other 358 # devices remain unchanged 359 params["iops"] = 0 360 self.set_io_throttle('drive0', params) 361 self.verify_name('drive0', None) 362 for i in range(1, self.max_drives): 363 devname = "drive%d" % i 364 groupname = "group%d" % i 365 self.verify_name(devname, groupname) 366 367class ThrottleTestRemovableMedia(iotests.QMPTestCase): 368 def setUp(self): 369 self.vm = iotests.VM() 370 if iotests.qemu_default_machine == 's390-ccw-virtio': 371 self.vm.add_device("virtio-scsi-ccw,id=virtio-scsi") 372 else: 373 self.vm.add_device("virtio-scsi-pci,id=virtio-scsi") 374 self.vm.launch() 375 376 def tearDown(self): 377 self.vm.shutdown() 378 379 def test_removable_media(self): 380 # Add a couple of dummy nodes named cd0 and cd1 381 result = self.vm.qmp("blockdev-add", driver="null-aio", 382 read_zeroes=True, node_name="cd0") 383 self.assert_qmp(result, 'return', {}) 384 result = self.vm.qmp("blockdev-add", driver="null-aio", 385 read_zeroes=True, node_name="cd1") 386 self.assert_qmp(result, 'return', {}) 387 388 # Attach a CD drive with cd0 inserted 389 result = self.vm.qmp("device_add", driver="scsi-cd", 390 id="dev0", drive="cd0") 391 self.assert_qmp(result, 'return', {}) 392 393 # Set I/O limits 394 args = { "id": "dev0", "iops": 100, "iops_rd": 0, "iops_wr": 0, 395 "bps": 50, "bps_rd": 0, "bps_wr": 0 } 396 result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **args) 397 self.assert_qmp(result, 'return', {}) 398 399 # Check that the I/O limits have been set 400 result = self.vm.qmp("query-block") 401 self.assert_qmp(result, 'return[0]/inserted/iops', 100) 402 self.assert_qmp(result, 'return[0]/inserted/bps', 50) 403 404 # Now eject cd0 and insert cd1 405 result = self.vm.qmp("blockdev-open-tray", id='dev0') 406 self.assert_qmp(result, 'return', {}) 407 result = self.vm.qmp("blockdev-remove-medium", id='dev0') 408 self.assert_qmp(result, 'return', {}) 409 result = self.vm.qmp("blockdev-insert-medium", id='dev0', node_name='cd1') 410 self.assert_qmp(result, 'return', {}) 411 412 # Check that the I/O limits are still the same 413 result = self.vm.qmp("query-block") 414 self.assert_qmp(result, 'return[0]/inserted/iops', 100) 415 self.assert_qmp(result, 'return[0]/inserted/bps', 50) 416 417 # Eject cd1 418 result = self.vm.qmp("blockdev-remove-medium", id='dev0') 419 self.assert_qmp(result, 'return', {}) 420 421 # Check that we can't set limits if the device has no medium 422 result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **args) 423 self.assert_qmp(result, 'error/class', 'GenericError') 424 425 # Remove the CD drive 426 result = self.vm.qmp("device_del", id='dev0') 427 self.assert_qmp(result, 'return', {}) 428 429 430if __name__ == '__main__': 431 iotests.main(supported_fmts=["raw"]) 432