2 * This file is part of the Palacios Virtual Machine Monitor developed
3 * by the V3VEE Project with funding from the United States National
4 * Science Foundation and the Department of Energy.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
10 * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
11 * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
12 * All rights reserved.
14 * Author: Jack Lange <jarusl@cs.northwestern.edu>
16 * This is free software. You are permitted to use,
17 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
20 #include <palacios/vmm.h>
21 #include <palacios/vmm_dev_mgr.h>
22 #include <devices/lnx_virtio_blk.h>
23 #include <palacios/vmm_sym_swap.h>
25 #define SWAP_CAPACITY (150 * 1024 * 1024)
29 /* This is the first page that linux writes to the swap area */
30 /* Taken from Linux */
33 char reserved[PAGE_SIZE - 10];
34 char magic[10]; /* SWAP-SPACE or SWAPSPACE2 */
37 char bootbits[1024]; /* Space for disklabel etc. */
41 unsigned char sws_uuid[16];
42 unsigned char sws_volume[16];
43 uint32_t type; // The index into the swap_map
44 uint32_t padding[116];
45 // uint32_t padding[117];
55 struct vm_device * blk_dev;
58 uint_t unswapped_pages;
61 union swap_header * hdr;
65 addr_t swap_base_addr;
67 uint8_t usage_map[0]; // This must be the last structure member
73 static inline void set_index_usage(struct swap_state * swap, uint32_t index, int used) {
74 int major = index / 8;
75 int minor = index % 8;
78 swap->usage_map[major] |= (1 << minor);
80 swap->usage_map[major] &= ~(1 << minor);
84 static inline int get_index_usage(struct swap_state * swap, uint32_t index) {
85 int major = index / 8;
86 int minor = index % 8;
88 return (swap->usage_map[major] & (1 << minor));
92 static inline uint32_t get_swap_index_from_offset(uint32_t offset) {
93 // CAREFUL: The index might be offset by 1, because the first 4K is the header
94 return (offset / 4096);
99 static inline uint32_t get_swap_index(uint32_t offset) {
100 // CAREFUL: The index might be offset by 1, because the first 4K is the header
101 return (swap_addr - swap->swap_space) / 4096;
106 static inline void * get_swap_entry(uint32_t pg_index, void * private_data) {
107 struct vm_device * dev = (struct vm_device *)private_data;
108 struct swap_state * swap = (struct swap_state *)(dev->private_data);
109 void * pg_addr = NULL;
112 if ((ret = get_index_usage(swap, pg_index))) {
113 // CAREFUL: The index might be offset by 1, because the first 4K is the header
114 pg_addr = (void *)(swap->swap_space + (pg_index * 4096));
122 static uint64_t swap_get_capacity(void * private_data) {
123 struct vm_device * dev = (struct vm_device *)private_data;
124 struct swap_state * swap = (struct swap_state *)(dev->private_data);
126 PrintDebug("SymSwap: Getting Capacity %d\n", (uint32_t)(swap->capacity));
128 return swap->capacity / HD_SECTOR_SIZE;
132 static struct v3_swap_ops swap_ops = {
133 .get_swap_entry = get_swap_entry,
138 static int swap_read(uint8_t * buf, int sector_count, uint64_t lba, void * private_data) {
139 struct vm_device * dev = (struct vm_device *)private_data;
140 struct swap_state * swap = (struct swap_state *)(dev->private_data);
141 uint32_t offset = lba * HD_SECTOR_SIZE;
142 uint32_t length = sector_count * HD_SECTOR_SIZE;
146 PrintDebug("SymSwap: Reading %d bytes to %p from %p\n", length,
147 buf, (void *)(swap->swap_space + offset));
151 PrintError("Swapping in length that is not a page multiple\n");
154 memcpy(buf, swap->swap_space + offset, length);
156 swap->unswapped_pages += (length / 4096);
158 if ((swap->active == 1) && (offset != 0)) {
160 // Notify the shadow paging layer
161 PrintDebug("Swapped in %d pages\n", length / 4096);
162 for (i = 0; i < length; i += 4096) {
163 set_index_usage(swap, get_swap_index_from_offset(offset + i), 0);
164 v3_swap_in_notify(dev->vm, get_swap_index_from_offset(offset + i), swap->hdr->info.type);
174 static int swap_write(uint8_t * buf, int sector_count, uint64_t lba, void * private_data) {
175 struct vm_device * dev = (struct vm_device *)private_data;
176 struct swap_state * swap = (struct swap_state *)(dev->private_data);
177 uint32_t offset = lba * HD_SECTOR_SIZE;
178 uint32_t length = sector_count * HD_SECTOR_SIZE;
181 PrintDebug("SymSwap: Writing %d bytes to %p from %p\n", length,
182 (void *)(swap->swap_space + offset), buf);
186 PrintError("Swapping out length that is not a page multiple\n");
189 if ((swap->active == 0) && (offset == 0)) {
190 // This is the swap header page
192 if (length != 4096) {
193 PrintError("Initializing Swap space by not writing page multiples. This sucks...\n");
199 PrintDebug("Swap Type=%d (magic=%s)\n", swap->hdr->info.type, swap->hdr->magic.magic);
201 if (v3_register_swap_disk(dev->vm, swap->hdr->info.type, &swap_ops, dev) == -1) {
202 PrintError("Error registering symbiotic swap disk\n");
207 memcpy(swap->swap_space + offset, buf, length);
209 swap->swapped_pages += (length / 4096);
211 if ((swap->active == 1) && (offset != 0)) {
213 PrintDebug("Swapped out %d pages\n", length / 4096);
215 for (i = 0; i < length; i += 4096) {
216 set_index_usage(swap, get_swap_index_from_offset(offset + i), 1);
224 static int swap_free(struct vm_device * dev) {
229 static struct v3_hd_ops hd_ops = {
232 .get_capacity = swap_get_capacity,
237 static struct v3_device_ops dev_ops = {
249 static int swap_init(struct guest_info * vm, void * cfg_data) {
250 struct swap_state * swap = NULL;
251 struct vm_device * virtio_blk = v3_find_dev(vm, (char *)cfg_data);
254 PrintError("could not find Virtio backend\n");
258 PrintDebug("Creating Swap Device\n");
260 if (virtio_blk == NULL) {
261 PrintError("Swap device requires a virtio block device\n");
265 swap = (struct swap_state *)V3_Malloc(sizeof(struct swap_state) + ((SWAP_CAPACITY / 4096) / 8));
267 swap->blk_dev = virtio_blk;
268 swap->capacity = SWAP_CAPACITY;
270 swap->swapped_pages = 0;
271 swap->unswapped_pages = 0;
274 swap->hdr = (union swap_header *)swap;
277 swap->swap_base_addr = (addr_t)V3_AllocPages(swap->capacity / 4096);
278 swap->swap_space = (uint8_t *)V3_VAddr((void *)(swap->swap_base_addr));
279 memset(swap->swap_space, 0, SWAP_CAPACITY);
281 memset(swap->usage_map, 0, ((SWAP_CAPACITY / 4096) / 8));
283 struct vm_device * dev = v3_allocate_device("SYM_SWAP", &dev_ops, swap);
285 if (v3_attach_device(vm, dev) == -1) {
286 PrintError("Could not attach device %s\n", "SYM_SWAP");
291 v3_virtio_register_harddisk(virtio_blk, &hd_ops, dev);
296 device_register("SYM_SWAP", swap_init)