tools/testing/selftests/kvm/kvm_binary_stats_test.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * kvm_binary_stats_test
   4  *
   5  * Copyright (C) 2021, Google LLC.
   6  *
   7  * Test the fd-based interface for KVM statistics.
   8  */
   9 #include <fcntl.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <errno.h>
  14
  15 #include "test_util.h"
  16
  17 #include "kvm_util.h"
  18 #include "asm/kvm.h"
  19 #include "linux/kvm.h"
  20 #include "kselftest.h"
  21
  22 static void stats_test(int stats_fd)
  23 {
  24         ssize_t ret;
  25         int i;
  26         size_t size_desc;
  27         size_t size_data = 0;
  28         struct kvm_stats_header header;
  29         char *id;
  30         struct kvm_stats_desc *stats_desc;
  31         u64 *stats_data;
  32         struct kvm_stats_desc *pdesc;
  33         u32 type, unit, base;
  34
  35         /* Read kvm stats header */
  36         read_stats_header(stats_fd, &header);
  37
  38         size_desc = get_stats_descriptor_size(&header);
  39
  40         /* Read kvm stats id string */
  41         id = malloc(header.name_size);
  42         TEST_ASSERT(id, "Allocate memory for id string");
  43
  44         ret = pread(stats_fd, id, header.name_size, sizeof(header));
  45         TEST_ASSERT(ret == header.name_size,
  46                     "Expected header size '%u', read '%lu' bytes",
  47                     header.name_size, ret);
  48
  49         /* Check id string, that should start with "kvm" */
  50         TEST_ASSERT(!strncmp(id, "kvm", 3) && strlen(id) < header.name_size,
  51                     "Invalid KVM stats type, id: %s", id);
  52
  53         /* Sanity check for other fields in header */
  54         if (header.num_desc == 0) {
  55                 ksft_print_msg("No KVM stats defined!\n");
  56                 return;
  57         }
  58         /*
  59          * The descriptor and data offsets must be valid, they must not overlap
  60          * the header, and the descriptor and data blocks must not overlap each
  61          * other.  Note, the data block is rechecked after its size is known.
  62          */
  63         TEST_ASSERT(header.desc_offset && header.desc_offset >= sizeof(header) &&
  64                     header.data_offset && header.data_offset >= sizeof(header),
  65                     "Invalid offset fields in header");
  66
  67         TEST_ASSERT(header.desc_offset > header.data_offset ||
  68                     (header.desc_offset + size_desc * header.num_desc <= header.data_offset),
  69                     "Descriptor block is overlapped with data block");
  70
  71         /* Read kvm stats descriptors */
  72         stats_desc = read_stats_descriptors(stats_fd, &header);
  73
  74         /* Sanity check for fields in descriptors */
  75         for (i = 0; i < header.num_desc; ++i) {
  76                 pdesc = get_stats_descriptor(stats_desc, i, &header);
  77                 type = pdesc->flags & KVM_STATS_TYPE_MASK;
  78                 unit = pdesc->flags & KVM_STATS_UNIT_MASK;
  79                 base = pdesc->flags & KVM_STATS_BASE_MASK;
  80
  81                 /* Check name string */
  82                 TEST_ASSERT(strlen(pdesc->name) < header.name_size,
  83                             "KVM stats name (index: %d) too long", i);
  84
  85                 /* Check type,unit,base boundaries */
  86                 TEST_ASSERT(type <= KVM_STATS_TYPE_MAX,
  87                             "Unknown KVM stats (%s) type: %u", pdesc->name, type);
  88                 TEST_ASSERT(unit <= KVM_STATS_UNIT_MAX,
  89                             "Unknown KVM stats (%s) unit: %u", pdesc->name, unit);
  90                 TEST_ASSERT(base <= KVM_STATS_BASE_MAX,
  91                             "Unknown KVM stats (%s) base: %u", pdesc->name, base);
  92
  93                 /*
  94                  * Check exponent for stats unit
  95                  * Exponent for counter should be greater than or equal to 0
  96                  * Exponent for unit bytes should be greater than or equal to 0
  97                  * Exponent for unit seconds should be less than or equal to 0
  98                  * Exponent for unit clock cycles should be greater than or
  99                  * equal to 0
 100                  * Exponent for unit boolean should be 0
 101                  */
 102                 switch (pdesc->flags & KVM_STATS_UNIT_MASK) {
 103                 case KVM_STATS_UNIT_NONE:
 104                 case KVM_STATS_UNIT_BYTES:
 105                 case KVM_STATS_UNIT_CYCLES:
 106                         TEST_ASSERT(pdesc->exponent >= 0,
 107                                     "Unsupported KVM stats (%s) exponent: %i",
 108                                     pdesc->name, pdesc->exponent);
 109                         break;
 110                 case KVM_STATS_UNIT_SECONDS:
 111                         TEST_ASSERT(pdesc->exponent <= 0,
 112                                     "Unsupported KVM stats (%s) exponent: %i",
 113                                     pdesc->name, pdesc->exponent);
 114                         break;
 115                 case KVM_STATS_UNIT_BOOLEAN:
 116                         TEST_ASSERT(pdesc->exponent == 0,
 117                                     "Unsupported KVM stats (%s) exponent: %d",
 118                                     pdesc->name, pdesc->exponent);
 119                         break;
 120                 }
 121
 122                 /* Check size field, which should not be zero */
 123                 TEST_ASSERT(pdesc->size,
 124                             "KVM descriptor(%s) with size of 0", pdesc->name);
 125                 /* Check bucket_size field */
 126                 switch (pdesc->flags & KVM_STATS_TYPE_MASK) {
 127                 case KVM_STATS_TYPE_LINEAR_HIST:
 128                         TEST_ASSERT(pdesc->bucket_size,
 129                                     "Bucket size of Linear Histogram stats (%s) is zero",
 130                                     pdesc->name);
 131                         break;
 132                 default:
 133                         TEST_ASSERT(!pdesc->bucket_size,
 134                                     "Bucket size of stats (%s) is not zero",
 135                                     pdesc->name);
 136                 }
 137                 size_data = max(size_data, pdesc->offset + pdesc->size * sizeof(*stats_data));
 138         }
 139
 140         /*
 141          * Now that the size of the data block is known, verify the data block
 142          * doesn't overlap the descriptor block.
 143          */
 144         TEST_ASSERT(header.data_offset >= header.desc_offset ||
 145                     header.data_offset + size_data <= header.desc_offset,
 146                     "Data block is overlapped with Descriptor block");
 147
 148         /* Check validity of all stats data size */
 149         TEST_ASSERT(size_data >= header.num_desc * sizeof(*stats_data),
 150                     "Data size is not correct");
 151
 152         /* Allocate memory for stats data */
 153         stats_data = malloc(size_data);
 154         TEST_ASSERT(stats_data, "Allocate memory for stats data");
 155         /* Read kvm stats data as a bulk */
 156         ret = pread(stats_fd, stats_data, size_data, header.data_offset);
 157         TEST_ASSERT(ret == size_data, "Read KVM stats data");
 158         /* Read kvm stats data one by one */
 159         for (i = 0; i < header.num_desc; ++i) {
 160                 pdesc = get_stats_descriptor(stats_desc, i, &header);
 161                 read_stat_data(stats_fd, &header, pdesc, stats_data,
 162                                pdesc->size);
 163         }
 164
 165         free(stats_data);
 166         free(stats_desc);
 167         free(id);
 168
 169         close(stats_fd);
 170         TEST_ASSERT(fcntl(stats_fd, F_GETFD) == -1, "Stats fd not freed");
 171 }
 172
 173 #define DEFAULT_NUM_VM          4
 174 #define DEFAULT_NUM_VCPU        4
 175
 176 /*
 177  * Usage: kvm_bin_form_stats [#vm] [#vcpu]
 178  * The first parameter #vm set the number of VMs being created.
 179  * The second parameter #vcpu set the number of VCPUs being created.
 180  * By default, DEFAULT_NUM_VM VM and DEFAULT_NUM_VCPU VCPU for the VM would be
 181  * created for testing.
 182  */
 183
 184 int main(int argc, char *argv[])
 185 {
 186         int vm_stats_fds, *vcpu_stats_fds;
 187         int i, j;
 188         struct kvm_vcpu **vcpus;
 189         struct kvm_vm **vms;
 190         int max_vm = DEFAULT_NUM_VM;
 191         int max_vcpu = DEFAULT_NUM_VCPU;
 192
 193         /* Get the number of VMs and VCPUs that would be created for testing. */
 194         if (argc > 1) {
 195                 max_vm = strtol(argv[1], NULL, 0);
 196                 if (max_vm <= 0)
 197                         max_vm = DEFAULT_NUM_VM;
 198         }
 199         if (argc > 2) {
 200                 max_vcpu = strtol(argv[2], NULL, 0);
 201                 if (max_vcpu <= 0)
 202                         max_vcpu = DEFAULT_NUM_VCPU;
 203         }
 204
 205         ksft_print_header();
 206
 207         /* Check the extension for binary stats */
 208         TEST_REQUIRE(kvm_has_cap(KVM_CAP_BINARY_STATS_FD));
 209
 210         ksft_set_plan(max_vm);
 211
 212         /* Create VMs and VCPUs */
 213         vms = malloc(sizeof(vms[0]) * max_vm);
 214         TEST_ASSERT(vms, "Allocate memory for storing VM pointers");
 215
 216         vcpus = malloc(sizeof(struct kvm_vcpu *) * max_vm * max_vcpu);
 217         TEST_ASSERT(vcpus, "Allocate memory for storing vCPU pointers");
 218
 219         /*
 220          * Not per-VM as the array is populated, used, and invalidated within a
 221          * single for-loop iteration.
 222          */
 223         vcpu_stats_fds = calloc(max_vm, sizeof(*vcpu_stats_fds));
 224         TEST_ASSERT(vcpu_stats_fds, "Allocate memory for VM stats fds");
 225
 226         for (i = 0; i < max_vm; ++i) {
 227                 vms[i] = vm_create_barebones();
 228                 for (j = 0; j < max_vcpu; ++j)
 229                         vcpus[i * max_vcpu + j] = __vm_vcpu_add(vms[i], j);
 230         }
 231
 232         /*
 233          * Check stats read for every VM and vCPU, with a variety of flavors.
 234          * Note, stats_test() closes the passed in stats fd.
 235          */
 236         for (i = 0; i < max_vm; ++i) {
 237                 /*
 238                  * Verify that creating multiple userspace references to a
 239                  * single stats file works and doesn't cause explosions.
 240                  */
 241                 vm_stats_fds = vm_get_stats_fd(vms[i]);
 242                 stats_test(dup(vm_stats_fds));
 243
 244                 /* Verify userspace can instantiate multiple stats files. */
 245                 stats_test(vm_get_stats_fd(vms[i]));
 246
 247                 for (j = 0; j < max_vcpu; ++j) {
 248                         vcpu_stats_fds[j] = vcpu_get_stats_fd(vcpus[i * max_vcpu + j]);
 249                         stats_test(dup(vcpu_stats_fds[j]));
 250                         stats_test(vcpu_get_stats_fd(vcpus[i * max_vcpu + j]));
 251                 }
 252
 253                 /*
 254                  * Close the VM fd and redo the stats tests.  KVM should gift a
 255                  * reference (to the VM) to each stats fd, i.e. stats should
 256                  * still be accessible even after userspace has put its last
 257                  * _direct_ reference to the VM.
 258                  */
 259                 kvm_vm_free(vms[i]);
 260
 261                 stats_test(vm_stats_fds);
 262                 for (j = 0; j < max_vcpu; ++j)
 263                         stats_test(vcpu_stats_fds[j]);
 264
 265                 ksft_test_result_pass("vm%i\n", i);
 266         }
 267
 268         free(vms);
 269         free(vcpus);
 270         free(vcpu_stats_fds);
 271
 272         ksft_finished();        /* Print results and exit() accordingly */
 273 }