forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
144 lines
4.5 KiB
144 lines
4.5 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* KVM binary statistics interface implementation |
|
* |
|
* Copyright 2021 Google LLC |
|
*/ |
|
|
|
#include <linux/kvm_host.h> |
|
#include <linux/kvm.h> |
|
#include <linux/errno.h> |
|
#include <linux/uaccess.h> |
|
|
|
/** |
|
* kvm_stats_read() - Common function to read from the binary statistics |
|
* file descriptor. |
|
* |
|
* @id: identification string of the stats |
|
* @header: stats header for a vm or a vcpu |
|
* @desc: start address of an array of stats descriptors for a vm or a vcpu |
|
* @stats: start address of stats data block for a vm or a vcpu |
|
* @size_stats: the size of stats data block pointed by @stats |
|
* @user_buffer: start address of userspace buffer |
|
* @size: requested read size from userspace |
|
* @offset: the start position from which the content will be read for the |
|
* corresponding vm or vcp file descriptor |
|
* |
|
* The file content of a vm/vcpu file descriptor is now defined as below: |
|
* +-------------+ |
|
* | Header | |
|
* +-------------+ |
|
* | id string | |
|
* +-------------+ |
|
* | Descriptors | |
|
* +-------------+ |
|
* | Stats Data | |
|
* +-------------+ |
|
* Although this function allows userspace to read any amount of data (as long |
|
* as in the limit) from any position, the typical usage would follow below |
|
* steps: |
|
* 1. Read header from offset 0. Get the offset of descriptors and stats data |
|
* and some other necessary information. This is a one-time work for the |
|
* lifecycle of the corresponding vm/vcpu stats fd. |
|
* 2. Read id string from its offset. This is a one-time work for the lifecycle |
|
* of the corresponding vm/vcpu stats fd. |
|
* 3. Read descriptors from its offset and discover all the stats by parsing |
|
* descriptors. This is a one-time work for the lifecycle of the |
|
* corresponding vm/vcpu stats fd. |
|
* 4. Periodically read stats data from its offset using pread. |
|
* |
|
* Return: the number of bytes that has been successfully read |
|
*/ |
|
ssize_t kvm_stats_read(char *id, const struct kvm_stats_header *header, |
|
const struct _kvm_stats_desc *desc, |
|
void *stats, size_t size_stats, |
|
char __user *user_buffer, size_t size, loff_t *offset) |
|
{ |
|
ssize_t len; |
|
ssize_t copylen; |
|
ssize_t remain = size; |
|
size_t size_desc; |
|
size_t size_header; |
|
void *src; |
|
loff_t pos = *offset; |
|
char __user *dest = user_buffer; |
|
|
|
size_header = sizeof(*header); |
|
size_desc = header->num_desc * sizeof(*desc); |
|
|
|
len = KVM_STATS_NAME_SIZE + size_header + size_desc + size_stats - pos; |
|
len = min(len, remain); |
|
if (len <= 0) |
|
return 0; |
|
remain = len; |
|
|
|
/* |
|
* Copy kvm stats header. |
|
* The header is the first block of content userspace usually read out. |
|
* The pos is 0 and the copylen and remain would be the size of header. |
|
* The copy of the header would be skipped if offset is larger than the |
|
* size of header. That usually happens when userspace reads stats |
|
* descriptors and stats data. |
|
*/ |
|
copylen = size_header - pos; |
|
copylen = min(copylen, remain); |
|
if (copylen > 0) { |
|
src = (void *)header + pos; |
|
if (copy_to_user(dest, src, copylen)) |
|
return -EFAULT; |
|
remain -= copylen; |
|
pos += copylen; |
|
dest += copylen; |
|
} |
|
|
|
/* |
|
* Copy kvm stats header id string. |
|
* The id string is unique for every vm/vcpu, which is stored in kvm |
|
* and kvm_vcpu structure. |
|
* The id string is part of the stat header from the perspective of |
|
* userspace, it is usually read out together with previous constant |
|
* header part and could be skipped for later descriptors and stats |
|
* data readings. |
|
*/ |
|
copylen = header->id_offset + KVM_STATS_NAME_SIZE - pos; |
|
copylen = min(copylen, remain); |
|
if (copylen > 0) { |
|
src = id + pos - header->id_offset; |
|
if (copy_to_user(dest, src, copylen)) |
|
return -EFAULT; |
|
remain -= copylen; |
|
pos += copylen; |
|
dest += copylen; |
|
} |
|
|
|
/* |
|
* Copy kvm stats descriptors. |
|
* The descriptors copy would be skipped in the typical case that |
|
* userspace periodically read stats data, since the pos would be |
|
* greater than the end address of descriptors |
|
* (header->header.desc_offset + size_desc) causing copylen <= 0. |
|
*/ |
|
copylen = header->desc_offset + size_desc - pos; |
|
copylen = min(copylen, remain); |
|
if (copylen > 0) { |
|
src = (void *)desc + pos - header->desc_offset; |
|
if (copy_to_user(dest, src, copylen)) |
|
return -EFAULT; |
|
remain -= copylen; |
|
pos += copylen; |
|
dest += copylen; |
|
} |
|
|
|
/* Copy kvm stats values */ |
|
copylen = header->data_offset + size_stats - pos; |
|
copylen = min(copylen, remain); |
|
if (copylen > 0) { |
|
src = stats + pos - header->data_offset; |
|
if (copy_to_user(dest, src, copylen)) |
|
return -EFAULT; |
|
pos += copylen; |
|
} |
|
|
|
*offset = pos; |
|
return len; |
|
}
|
|
|