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  */
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)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 		pos += copylen;
140 	}
141 
142 	*offset = pos;
143 	return len;
144 }
145