servers/vm/mem_shared.c

   1
   2 /* This file implements the methods of shared memory.  */
   3
   4 #include <assert.h>
   5
   6 #include "proto.h"
   7 #include "vm.h"
   8 #include "region.h"
   9 #include "glo.h"
  10
  11 /* These functions are static so as to not pollute the
  12  * global namespace, and are accessed through their function
  13  * pointers.
  14  */
  15
  16 static int shared_reference(struct phys_region *pr);
  17 static int shared_unreference(struct phys_region *pr);
  18 static int shared_pagefault(struct vmproc *vmp, struct vir_region *region,
  19         struct phys_region *ph, int write);
  20 static int shared_sanitycheck(struct phys_region *pr, char *file, int line);
  21 static int shared_writable(struct phys_region *pr);
  22 static void shared_delete(struct vir_region *region);
  23 static u32_t shared_regionid(struct vir_region *region);
  24 static int shared_copy(struct vir_region *vr, struct vir_region *newvr);
  25 static int shared_refcount(struct vir_region *vr);
  26
  27 struct mem_type mem_type_shared = {
  28         .name = "shared memory",
  29         .ev_reference = shared_reference,
  30         .ev_copy = shared_copy,
  31         .ev_unreference = shared_unreference,
  32         .ev_pagefault = shared_pagefault,
  33         .ev_sanitycheck = shared_sanitycheck,
  34         .ev_delete = shared_delete,
  35         .regionid = shared_regionid,
  36         .refcount = shared_refcount,
  37         .writable = shared_writable
  38 };
  39
  40 static int shared_reference(struct phys_region *pr)
  41 {
  42         return OK;
  43 }
  44
  45 static int shared_unreference(struct phys_region *pr)
  46 {
  47         return mem_type_anon.ev_unreference(pr);
  48 }
  49
  50 static int getsrc(struct vir_region *region,
  51         struct vmproc **vmp, struct vir_region **r)
  52 {
  53         int srcproc;
  54
  55         if(region->memtype != &mem_type_shared) {
  56                 printf("shared region hasn't shared type but %s.\n",
  57                         region->memtype->name);
  58                 return EINVAL;
  59         }
  60
  61         if(!region->param.shared.ep || !region->param.shared.vaddr) {
  62                 printf("shared region has not defined source region.\n");
  63                 util_stacktrace();
  64                 return EINVAL;
  65         }
  66
  67         if(vm_isokendpt((endpoint_t) region->param.shared.ep, &srcproc) != OK) {
  68                 printf("VM: shared memory with missing source process.\n");
  69                 util_stacktrace();
  70                 return EINVAL;
  71         }
  72
  73         *vmp = &vmproc[srcproc];
  74
  75         if(!(*r=map_lookup(*vmp, region->param.shared.vaddr, NULL))) {
  76                 printf("VM: shared memory with missing vaddr 0x%lx.\n",
  77                         region->param.shared.vaddr);
  78                 return EINVAL;
  79         }
  80
  81         if((*r)->memtype != &mem_type_anon) {
  82                 printf("source region hasn't anon type but %s.\n",
  83                         (*r)->memtype->name);
  84                 return EINVAL;
  85         }
  86
  87         if(region->param.shared.id != (*r)->id) {
  88                 printf("source region has no matching id\n");
  89                 return EINVAL;
  90         }
  91
  92         return OK;
  93 }
  94
  95 static u32_t shared_regionid(struct vir_region *vr)
  96 {
  97         struct vir_region *src_region;
  98         struct vmproc *src_vmp;
  99
 100         if(getsrc(vr, &src_vmp, &src_region) != OK)
 101                 return 0;
 102
 103         return src_region->id;
 104 }
 105
 106 static void shared_delete(struct vir_region *region)
 107 {
 108         struct vir_region *src_region;
 109         struct vmproc *src_vmp;
 110
 111         if(getsrc(region, &src_vmp, &src_region) != OK)
 112                 return;
 113
 114         assert(src_region->remaps > 0);
 115         src_region->remaps--;
 116 }
 117
 118 static int shared_pagefault(struct vmproc *vmp, struct vir_region *region,
 119         struct phys_region *ph, int write)
 120 {
 121         struct vir_region *src_region;
 122         struct vmproc *src_vmp;
 123         struct phys_region *pr;
 124
 125         if(getsrc(region, &src_vmp, &src_region) != OK) {
 126                 return EINVAL;
 127         }
 128
 129         assert(ph->ph->phys == MAP_NONE);
 130         pb_free(ph->ph);
 131
 132         if(!(pr = physblock_get(src_region, ph->offset))) {
 133                 int r;
 134                 if((r=map_pf(src_vmp, src_region, ph->offset, write)) != OK)
 135                         return r;
 136                 if(!(pr = physblock_get(src_region, ph->offset))) {
 137                         panic("missing region after pagefault handling");
 138                 }
 139         }
 140
 141         pb_link(ph, pr->ph, ph->offset, region);
 142
 143         return OK;
 144 }
 145
 146 static int shared_sanitycheck(struct phys_region *pr, char *file, int line)
 147 {
 148         return OK;
 149 }
 150
 151 static int shared_writable(struct phys_region *pr)
 152 {
 153         assert(pr->ph->refcount > 0);
 154         return pr->ph->phys != MAP_NONE;
 155 }
 156
 157 void shared_setsource(struct vir_region *vr, endpoint_t ep,
 158         struct vir_region *src_vr)
 159 {
 160         struct vmproc *vmp;
 161         struct vir_region *srcvr;
 162         int id = src_vr->id;
 163         vir_bytes vaddr = src_vr->vaddr;
 164
 165         assert(vr->memtype == &mem_type_shared);
 166
 167         if(!ep || !vaddr || !id) {
 168                 printf("VM: shared_setsource: zero ep/vaddr/id - ignoring\n");
 169                 return;
 170         }
 171
 172         vr->param.shared.ep = ep;
 173         vr->param.shared.vaddr = vaddr;
 174         vr->param.shared.id = id;
 175
 176         if(getsrc(vr, &vmp, &srcvr) != OK)
 177                 panic("initial getsrc failed");
 178
 179         assert(srcvr == src_vr);
 180
 181         srcvr->remaps++;
 182 }
 183
 184 static int shared_copy(struct vir_region *vr, struct vir_region *newvr)
 185 {
 186         struct vmproc *vmp;
 187         struct vir_region *srcvr;
 188
 189         if(getsrc(vr, &vmp, &srcvr) != OK)
 190                 panic("copy: original getsrc failed");
 191
 192         shared_setsource(newvr, vr->param.shared.ep, srcvr);
 193
 194         return OK;
 195 }
 196
 197 static int shared_refcount(struct vir_region *vr)
 198 {
 199         return 1 + vr->remaps;
 200 }
 201