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 <[email protected]> 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 <linux/types.h> 42 #include <linux/virtio_types.h> 43 #include <linux/virtio_ids.h> 44 #include <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 }; 107 108 struct virtio_mem_req_unplug { 109 __virtio64 addr; 110 __virtio16 nb_blocks; 111 }; 112 113 struct virtio_mem_req_state { 114 __virtio64 addr; 115 __virtio16 nb_blocks; 116 }; 117 118 struct virtio_mem_req { 119 __virtio16 type; 120 __virtio16 padding[3]; 121 122 union { 123 struct virtio_mem_req_plug plug; 124 struct virtio_mem_req_unplug unplug; 125 struct virtio_mem_req_state state; 126 } u; 127 }; 128 129 130 /* --- virtio-mem: host -> guest response --- */ 131 132 /* 133 * Request processed successfully, applicable for 134 * - VIRTIO_MEM_REQ_PLUG 135 * - VIRTIO_MEM_REQ_UNPLUG 136 * - VIRTIO_MEM_REQ_UNPLUG_ALL 137 * - VIRTIO_MEM_REQ_STATE 138 */ 139 #define VIRTIO_MEM_RESP_ACK 0 140 /* 141 * Request denied - e.g. trying to plug more than requested, applicable for 142 * - VIRTIO_MEM_REQ_PLUG 143 */ 144 #define VIRTIO_MEM_RESP_NACK 1 145 /* 146 * Request cannot be processed right now, try again later, applicable for 147 * - VIRTIO_MEM_REQ_PLUG 148 * - VIRTIO_MEM_REQ_UNPLUG 149 * - VIRTIO_MEM_REQ_UNPLUG_ALL 150 */ 151 #define VIRTIO_MEM_RESP_BUSY 2 152 /* 153 * Error in request (e.g. addresses/alignment), applicable for 154 * - VIRTIO_MEM_REQ_PLUG 155 * - VIRTIO_MEM_REQ_UNPLUG 156 * - VIRTIO_MEM_REQ_STATE 157 */ 158 #define VIRTIO_MEM_RESP_ERROR 3 159 160 161 /* State of memory blocks is "plugged" */ 162 #define VIRTIO_MEM_STATE_PLUGGED 0 163 /* State of memory blocks is "unplugged" */ 164 #define VIRTIO_MEM_STATE_UNPLUGGED 1 165 /* State of memory blocks is "mixed" */ 166 #define VIRTIO_MEM_STATE_MIXED 2 167 168 struct virtio_mem_resp_state { 169 __virtio16 state; 170 }; 171 172 struct virtio_mem_resp { 173 __virtio16 type; 174 __virtio16 padding[3]; 175 176 union { 177 struct virtio_mem_resp_state state; 178 } u; 179 }; 180 181 /* --- virtio-mem: configuration --- */ 182 183 struct virtio_mem_config { 184 /* Block size and alignment. Cannot change. */ 185 __u32 block_size; 186 /* Valid with VIRTIO_MEM_F_ACPI_PXM. Cannot change. */ 187 __u16 node_id; 188 __u16 padding; 189 /* Start address of the memory region. Cannot change. */ 190 __u64 addr; 191 /* Region size (maximum). Cannot change. */ 192 __u64 region_size; 193 /* 194 * Currently usable region size. Can grow up to region_size. Can 195 * shrink due to VIRTIO_MEM_REQ_UNPLUG_ALL (in which case no config 196 * update will be sent). 197 */ 198 __u64 usable_region_size; 199 /* 200 * Currently used size. Changes due to plug/unplug requests, but no 201 * config updates will be sent. 202 */ 203 __u64 plugged_size; 204 /* Requested size. New plug requests cannot exceed it. Can change. */ 205 __u64 requested_size; 206 }; 207 208 #endif /* _LINUX_VIRTIO_MEM_H */ 209