1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * KVM binary statistics interface implementation 4 * 5 * Copyright 2021 Google LLC 6 */ 7 8 #include <linux/kvm_host.h> 9 #include <linux/kvm.h> 10 #include <linux/errno.h> 11 #include <linux/uaccess.h> 12 13 /** 14 * kvm_stats_read() - Common function to read from the binary statistics 15 * file descriptor. 16 * 17 * @id: identification string of the stats 18 * @header: stats header for a vm or a vcpu 19 * @desc: start address of an array of stats descriptors for a vm or a vcpu 20 * @stats: start address of stats data block for a vm or a vcpu 21 * @size_stats: the size of stats data block pointed by @stats 22 * @user_buffer: start address of userspace buffer 23 * @size: requested read size from userspace 24 * @offset: the start position from which the content will be read for the 25 * corresponding vm or vcp file descriptor 26 * 27 * The file content of a vm/vcpu file descriptor is now defined as below: 28 * +-------------+ 29 * | Header | 30 * +-------------+ 31 * | id string | 32 * +-------------+ 33 * | Descriptors | 34 * +-------------+ 35 * | Stats Data | 36 * +-------------+ 37 * Although this function allows userspace to read any amount of data (as long 38 * as in the limit) from any position, the typical usage would follow below 39 * steps: 40 * 1. Read header from offset 0. Get the offset of descriptors and stats data 41 * and some other necessary information. This is a one-time work for the 42 * lifecycle of the corresponding vm/vcpu stats fd. 43 * 2. Read id string from its offset. This is a one-time work for the lifecycle 44 * of the corresponding vm/vcpu stats fd. 45 * 3. Read descriptors from its offset and discover all the stats by parsing 46 * descriptors. This is a one-time work for the lifecycle of the 47 * corresponding vm/vcpu stats fd. 48 * 4. Periodically read stats data from its offset using pread. 49 * 50 * Return: the number of bytes that has been successfully read 51 */ 52 ssize_t kvm_stats_read(char *id, const struct kvm_stats_header *header, 53 const struct _kvm_stats_desc *desc, 54 void *stats, size_t size_stats, 55 char __user *user_buffer, size_t size, loff_t *offset) 56 { 57 ssize_t len; 58 ssize_t copylen; 59 ssize_t remain = size; 60 size_t size_desc; 61 size_t size_header; 62 void *src; 63 loff_t pos = *offset; 64 char __user *dest = user_buffer; 65 66 size_header = sizeof(*header); 67 size_desc = header->num_desc * sizeof(*desc); 68 69 len = KVM_STATS_NAME_SIZE + size_header + size_desc + size_stats - pos; 70 len = min(len, remain); 71 if (len <= 0) 72 return 0; 73 remain = len; 74 75 /* 76 * Copy kvm stats header. 77 * The header is the first block of content userspace usually read out. 78 * The pos is 0 and the copylen and remain would be the size of header. 79 * The copy of the header would be skipped if offset is larger than the 80 * size of header. That usually happens when userspace reads stats 81 * descriptors and stats data. 82 */ 83 copylen = size_header - pos; 84 copylen = min(copylen, remain); 85 if (copylen > 0) { 86 src = (void *)header + pos; 87 if (copy_to_user(dest, src, copylen)) 88 return -EFAULT; 89 remain -= copylen; 90 pos += copylen; 91 dest += copylen; 92 } 93 94 /* 95 * Copy kvm stats header id string. 96 * The id string is unique for every vm/vcpu, which is stored in kvm 97 * and kvm_vcpu structure. 98 * The id string is part of the stat header from the perspective of 99 * userspace, it is usually read out together with previous constant 100 * header part and could be skipped for later descriptors and stats 101 * data readings. 102 */ 103 copylen = header->id_offset + KVM_STATS_NAME_SIZE - pos; 104 copylen = min(copylen, remain); 105 if (copylen > 0) { 106 src = id + pos - header->id_offset; 107 if (copy_to_user(dest, src, copylen)) 108 return -EFAULT; 109 remain -= copylen; 110 pos += copylen; 111 dest += copylen; 112 } 113 114 /* 115 * Copy kvm stats descriptors. 116 * The descriptors copy would be skipped in the typical case that 117 * userspace periodically read stats data, since the pos would be 118 * greater than the end address of descriptors 119 * (header->header.desc_offset + size_desc) causing copylen <= 0. 120 */ 121 copylen = header->desc_offset + size_desc - pos; 122 copylen = min(copylen, remain); 123 if (copylen > 0) { 124 src = (void *)desc + pos - header->desc_offset; 125 if (copy_to_user(dest, src, copylen)) 126 return -EFAULT; 127 remain -= copylen; 128 pos += copylen; 129 dest += copylen; 130 } 131 132 /* Copy kvm stats values */ 133 copylen = header->data_offset + size_stats - pos; 134 copylen = min(copylen, remain); 135 if (copylen > 0) { 136 src = stats + pos - header->data_offset; 137 if (copy_to_user(dest, src, copylen)) 138 return -EFAULT; 139 remain -= copylen; 140 pos += copylen; 141 dest += copylen; 142 } 143 144 *offset = pos; 145 return len; 146 } 147