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