1 /* SPDX-License-Identifier: BSD-3-Clause */ 2 /* 3 * Virtio Mem Device 4 * 5 * Copyright Red Hat, Inc. 2020 6 * 7 * Authors: 8 * David Hildenbrand <david@redhat.com> 9 * 10 * This header is BSD licensed so anyone can use the definitions 11 * to implement compatible drivers/servers: 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of IBM nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 25 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 27 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR 28 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 31 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 32 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 33 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 34 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 */ 37 38 #ifndef _LINUX_VIRTIO_MEM_H 39 #define _LINUX_VIRTIO_MEM_H 40 41 #include "standard-headers/linux/types.h" 42 #include "standard-headers/linux/virtio_types.h" 43 #include "standard-headers/linux/virtio_ids.h" 44 #include "standard-headers/linux/virtio_config.h" 45 46 /* 47 * Each virtio-mem device manages a dedicated region in physical address 48 * space. Each device can belong to a single NUMA node, multiple devices 49 * for a single NUMA node are possible. A virtio-mem device is like a 50 * "resizable DIMM" consisting of small memory blocks that can be plugged 51 * or unplugged. The device driver is responsible for (un)plugging memory 52 * blocks on demand. 53 * 54 * Virtio-mem devices can only operate on their assigned memory region in 55 * order to (un)plug memory. A device cannot (un)plug memory belonging to 56 * other devices. 57 * 58 * The "region_size" corresponds to the maximum amount of memory that can 59 * be provided by a device. The "size" corresponds to the amount of memory 60 * that is currently plugged. "requested_size" corresponds to a request 61 * from the device to the device driver to (un)plug blocks. The 62 * device driver should try to (un)plug blocks in order to reach the 63 * "requested_size". It is impossible to plug more memory than requested. 64 * 65 * The "usable_region_size" represents the memory region that can actually 66 * be used to (un)plug memory. It is always at least as big as the 67 * "requested_size" and will grow dynamically. It will only shrink when 68 * explicitly triggered (VIRTIO_MEM_REQ_UNPLUG). 69 * 70 * There are no guarantees what will happen if unplugged memory is 71 * read/written. Such memory should, in general, not be touched. E.g., 72 * even writing might succeed, but the values will simply be discarded at 73 * random points in time. 74 * 75 * It can happen that the device cannot process a request, because it is 76 * busy. The device driver has to retry later. 77 * 78 * Usually, during system resets all memory will get unplugged, so the 79 * device driver can start with a clean state. However, in specific 80 * scenarios (if the device is busy) it can happen that the device still 81 * has memory plugged. The device driver can request to unplug all memory 82 * (VIRTIO_MEM_REQ_UNPLUG) - which might take a while to succeed if the 83 * device is busy. 84 */ 85 86 /* --- virtio-mem: feature bits --- */ 87 88 /* node_id is an ACPI PXM and is valid */ 89 #define VIRTIO_MEM_F_ACPI_PXM 0 90 91 92 /* --- virtio-mem: guest -> host requests --- */ 93 94 /* request to plug memory blocks */ 95 #define VIRTIO_MEM_REQ_PLUG 0 96 /* request to unplug memory blocks */ 97 #define VIRTIO_MEM_REQ_UNPLUG 1 98 /* request to unplug all blocks and shrink the usable size */ 99 #define VIRTIO_MEM_REQ_UNPLUG_ALL 2 100 /* request information about the plugged state of memory blocks */ 101 #define VIRTIO_MEM_REQ_STATE 3 102 103 struct virtio_mem_req_plug { 104 __virtio64 addr; 105 __virtio16 nb_blocks; 106 __virtio16 padding[3]; 107 }; 108 109 struct virtio_mem_req_unplug { 110 __virtio64 addr; 111 __virtio16 nb_blocks; 112 __virtio16 padding[3]; 113 }; 114 115 struct virtio_mem_req_state { 116 __virtio64 addr; 117 __virtio16 nb_blocks; 118 __virtio16 padding[3]; 119 }; 120 121 struct virtio_mem_req { 122 __virtio16 type; 123 __virtio16 padding[3]; 124 125 union { 126 struct virtio_mem_req_plug plug; 127 struct virtio_mem_req_unplug unplug; 128 struct virtio_mem_req_state state; 129 } u; 130 }; 131 132 133 /* --- virtio-mem: host -> guest response --- */ 134 135 /* 136 * Request processed successfully, applicable for 137 * - VIRTIO_MEM_REQ_PLUG 138 * - VIRTIO_MEM_REQ_UNPLUG 139 * - VIRTIO_MEM_REQ_UNPLUG_ALL 140 * - VIRTIO_MEM_REQ_STATE 141 */ 142 #define VIRTIO_MEM_RESP_ACK 0 143 /* 144 * Request denied - e.g. trying to plug more than requested, applicable for 145 * - VIRTIO_MEM_REQ_PLUG 146 */ 147 #define VIRTIO_MEM_RESP_NACK 1 148 /* 149 * Request cannot be processed right now, try again later, applicable for 150 * - VIRTIO_MEM_REQ_PLUG 151 * - VIRTIO_MEM_REQ_UNPLUG 152 * - VIRTIO_MEM_REQ_UNPLUG_ALL 153 */ 154 #define VIRTIO_MEM_RESP_BUSY 2 155 /* 156 * Error in request (e.g. addresses/alignment), applicable for 157 * - VIRTIO_MEM_REQ_PLUG 158 * - VIRTIO_MEM_REQ_UNPLUG 159 * - VIRTIO_MEM_REQ_STATE 160 */ 161 #define VIRTIO_MEM_RESP_ERROR 3 162 163 164 /* State of memory blocks is "plugged" */ 165 #define VIRTIO_MEM_STATE_PLUGGED 0 166 /* State of memory blocks is "unplugged" */ 167 #define VIRTIO_MEM_STATE_UNPLUGGED 1 168 /* State of memory blocks is "mixed" */ 169 #define VIRTIO_MEM_STATE_MIXED 2 170 171 struct virtio_mem_resp_state { 172 __virtio16 state; 173 }; 174 175 struct virtio_mem_resp { 176 __virtio16 type; 177 __virtio16 padding[3]; 178 179 union { 180 struct virtio_mem_resp_state state; 181 } u; 182 }; 183 184 /* --- virtio-mem: configuration --- */ 185 186 struct virtio_mem_config { 187 /* Block size and alignment. Cannot change. */ 188 uint64_t block_size; 189 /* Valid with VIRTIO_MEM_F_ACPI_PXM. Cannot change. */ 190 uint16_t node_id; 191 uint8_t padding[6]; 192 /* Start address of the memory region. Cannot change. */ 193 uint64_t addr; 194 /* Region size (maximum). Cannot change. */ 195 uint64_t region_size; 196 /* 197 * Currently usable region size. Can grow up to region_size. Can 198 * shrink due to VIRTIO_MEM_REQ_UNPLUG_ALL (in which case no config 199 * update will be sent). 200 */ 201 uint64_t usable_region_size; 202 /* 203 * Currently used size. Changes due to plug/unplug requests, but no 204 * config updates will be sent. 205 */ 206 uint64_t plugged_size; 207 /* Requested size. New plug requests cannot exceed it. Can change. */ 208 uint64_t requested_size; 209 }; 210 211 #endif /* _LINUX_VIRTIO_MEM_H */ 212