--- /dev/null
+/*
+ * This file is part of the Palacios Virtual Machine Monitor developed
+ * by the V3VEE Project with funding from the United States National
+ * Science Foundation and the Department of Energy.
+ *
+ * The V3VEE Project is a joint project between Northwestern University
+ * and the University of New Mexico. You can find out more at
+ * http://www.v3vee.org
+ *
+ * Copyright (c) 2015, The V3VEE Project <http://www.v3vee.org>
+ * All rights reserved.
+ *
+ * Author: Peter Dinda <pdinda@northwestern.edu>
+ *
+ * This is free software. You are permitted to use,
+ * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
+ */
+
+#include <palacios/vmm.h>
+#include <palacios/vm_guest.h>
+#include <interfaces/vmm_cache_info.h>
+
+#ifndef V3_CONFIG_DEBUG_CACHEPART
+#undef PrintDebug
+#define PrintDebug(fmt, args...)
+#endif
+
+/*
+
+ <cachepart
+ block_size=BLOCK_SIZE
+ num_colors=NUM_COLORS
+ min_color=MIN_COLOR
+ max_color=MAX_COLOR />
+
+ Cache partitioning support
+
+ We are partioning the last level shared cache here.
+
+ Cache partitioning is applied to the guest physical memory allocation
+ and page allocations for nested and shadow paging. To the extent
+ possible, we also try to apply this paritioning to other allocations
+ and as early as possible during the creation of the VM
+
+ BLOCK_SIZE = required v3_mem_block_size needed for partitioning in bytes
+ this is typically one page (4096 bytes)
+ NUM_COLORS = the number of page colors the cache is expected to hold
+ this is used to make the min/max color fields sensible
+ [MIN_COLOR,MAX_COLOR]
+ = the range of allowed page colors allowed for this VM
+ with respect to the range [0,NUMCOLORS)
+*/
+
+static int inited=0;
+static struct v3_cache_info cache_info;
+
+#define CEIL_DIV(x,y) (((x)/(y)) + !!((x)%(y)))
+#define FLOOR_DIV(x,y) (((x)/(y)))
+#define DIVIDES(x,y) (!((x)%(y)))
+
+
+static inline int getcacheinfo()
+{
+ if (inited) {
+ return 0;
+ } else {
+ if (v3_get_cache_info(V3_CACHE_COMBINED,0xffffffff,&cache_info)) {
+ PrintError(VM_NONE,VCORE_NONE,"Unable to get information about cache\n");
+ return -1;
+ }
+ V3_Print(VM_NONE,VCORE_NONE,"cachepart: last level combined cache: 0x%x bytes, 0x%x blocksize, 0x%x associativity\n",cache_info.size,cache_info.blocksize,cache_info.associativity);
+ inited=1;
+ if (!(DIVIDES(cache_info.size,cache_info.blocksize) &&
+ DIVIDES(cache_info.size,cache_info.associativity) &&
+ DIVIDES(cache_info.size/cache_info.blocksize,cache_info.associativity))) {
+ PrintError(VM_NONE,VCORE_NONE,"cachepart: CACHE INFO IS NONSENSICAL\n");
+ return -1;
+ }
+ return 0;
+ }
+}
+
+int v3_init_cachepart()
+{
+ PrintDebug(VM_NONE,VCORE_NONE,"cachepart: init\n");
+ return 0;
+}
+
+int v3_deinit_cachepart()
+{
+ PrintDebug(VM_NONE,VCORE_NONE,"cachepart: deinit\n");
+ return 0;
+}
+
+/*
+static int bitcount(uint64_t x)
+{
+ int c=0;
+
+ while (x) {
+ c+=x&0x1;
+ x>>=1;
+ }
+ return c;
+}
+
+static int is_pow2(x)
+{
+ int c = bitcount(x);
+
+ return c==0 || c==1;
+}
+*/
+
+static uint64_t log2(uint64_t x)
+{
+ uint64_t i=-1;
+
+ while (x) {
+ i++;
+ x>>=1;
+ }
+
+ return i;
+}
+
+static uint64_t pow2(uint64_t n)
+{
+ uint64_t x = 1;
+ while (n) {
+ x*=2;
+ n--;
+ }
+ return x;
+}
+
+static uint64_t num_lines()
+{
+ return FLOOR_DIV(cache_info.size,cache_info.blocksize);
+}
+
+static uint64_t num_sets()
+{
+ return FLOOR_DIV(num_lines(),cache_info.associativity);
+}
+
+
+static void build_colors(v3_cachepart_t *c)
+{
+ uint64_t bo_bits, set_bits, bs_bits;
+
+ // number of bits in block offset
+ bo_bits = log2(cache_info.blocksize);
+ set_bits = log2(num_sets());
+ bs_bits = log2(c->mem_block_size);
+
+ if (bs_bits<bo_bits || bs_bits >= (bo_bits+set_bits)) {
+ c->actual_num_colors = 1;
+ c->color_mask=0;
+ c->color_shift=0;
+ c->min_color=0;
+ c->max_color=0;
+ } else {
+ c->actual_num_colors = pow2(bo_bits+set_bits-bs_bits);
+ c->color_mask = (c->actual_num_colors-1);
+ c->color_shift = bs_bits;
+ c->min_color = FLOOR_DIV(c->min_color,CEIL_DIV(c->expected_num_colors,c->actual_num_colors));
+ c->max_color = FLOOR_DIV(c->max_color,CEIL_DIV(c->expected_num_colors,c->actual_num_colors));
+ }
+}
+
+int v3_init_cachepart_vm(struct v3_vm_info *vm, struct v3_xml *config)
+{
+ extern uint64_t v3_mem_block_size;
+ v3_cfg_tree_t *cp;
+ char *block_size_s;
+ char *num_colors_s;
+ char *min_color_s;
+ char *max_color_s;
+ uint64_t req_block_size, req_num_colors, req_min_color, req_max_color;
+ v3_cachepart_t *c = &(vm->cachepart_state);
+
+ if (getcacheinfo()) {
+ PrintError(VM_NONE,VCORE_NONE,"cachepart: getcacheinfo failed!\n");
+ return -1;
+ }
+
+ if (!config || !(cp=v3_cfg_subtree(config,"cachepart"))) {
+ PrintDebug(vm,VCORE_NONE,"cachepart: no cachepart configuration found\n");
+ return 0;
+ }
+
+ if (!(block_size_s=v3_cfg_val(cp,"block_size"))) {
+ PrintError(vm,VCORE_NONE,"cachepart: missing block_size parameter\n");
+ return 0;
+ }
+
+ req_block_size = atoi(block_size_s);
+
+ if (!(num_colors_s=v3_cfg_val(cp,"num_colors"))) {
+ PrintError(vm,VCORE_NONE,"cachepart: missing num_colors parameter\n");
+ return -1;
+ }
+
+ req_num_colors=atoi(num_colors_s);
+
+ if (!(min_color_s=v3_cfg_val(cp,"min_color"))) {
+ PrintError(vm,VCORE_NONE,"cachepart: missing min_color parameter\n");
+ return -1;
+ }
+
+ req_min_color=atoi(min_color_s);
+
+ if (!(max_color_s=v3_cfg_val(cp,"max_color"))) {
+ PrintError(vm,VCORE_NONE,"cachepart: missing max_color parameter\n");
+ return -1;
+ }
+
+ req_max_color=atoi(max_color_s);
+
+ PrintDebug(vm,VCORE_NONE,"cachepart: request block_size=0x%llx, num_colors=0x%llx, min_color=0x%llx, max_color=0x%llx\n", req_block_size, req_num_colors, req_min_color, req_max_color);
+
+ if (req_block_size!=v3_mem_block_size) {
+ PrintError(vm,VCORE_NONE,"cachepart: requested block size is %llu, but palacios is configured with v3_mem_block_size=%llu\n",req_block_size,v3_mem_block_size);
+ return -1;
+ }
+
+ if (req_max_color>=req_num_colors || req_min_color>req_max_color) {
+ PrintError(vm,VCORE_NONE,"cachepart: min/max color request is nonsensical\n");
+ return -1;
+ }
+
+ memset(c,0,sizeof(*c));
+
+ c->mem_block_size=req_block_size;
+ c->expected_num_colors=req_num_colors;
+ c->min_color=req_min_color;
+ c->max_color=req_max_color;
+
+ // Now update the color structure to reflect the cache constraints
+ build_colors(c);
+
+
+ PrintDebug(vm,VCORE_NONE,"cachepart: cache has 0x%llx colors so finalized to block_size=0x%llx, num_colors=0x%llx, min_color=0x%llx, max_color=0x%llx, color_shift=0x%llx, color_mask=0x%llx\n", c->actual_num_colors, c->mem_block_size, c->actual_num_colors, c->min_color, c->max_color, c->color_shift, c->color_mask);
+
+ if (vm->resource_control.pg_filter_func || vm->resource_control.pg_filter_state) {
+ PrintError(vm,VCORE_NONE, "cachepart: paging filter functions and state are already installed...\n");
+ return -1;
+ }
+
+ vm->resource_control.pg_filter_func = (int (*)(void *,void*)) v3_cachepart_filter;
+ vm->resource_control.pg_filter_state = &vm->cachepart_state;
+
+
+ // V3_Sleep(50000000);
+
+ return 0;
+
+}
+
+int v3_deinit_cachepart_vm(struct v3_vm_info *vm)
+{
+ // nothing to do
+ return 0;
+}
+
+int v3_init_cachepart_core(struct guest_info *core)
+{
+ // nothing to do yet
+ return 0;
+}
+
+int v3_deinit_cachepart_core(struct guest_info *core)
+{
+ // nothing to do yet
+ return 0;
+}
+
+static unsigned count=0;
+
+int v3_cachepart_filter(void *paddr, v3_cachepart_t *c)
+{
+ uint64_t a = (uint64_t)paddr;
+ uint64_t color = (a >> c->color_shift) & c->color_mask;
+
+ PrintDebug(VM_NONE,VCORE_NONE,"cachepart: %p is color 0x%llx required colors: [0x%llx,0x%llx] %s\n",paddr,color,c->min_color,c->max_color, color>=c->min_color && color<=c->max_color ? "ACCEPT" : "REJECT");
+
+ /*
+ if (count<10) {
+ V3_Sleep(5000000);
+ count++;
+ }
+ */
+
+ return color>=c->min_color && color<=c->max_color;
+
+}
+
