1 files changed, 33 insertions, 33 deletions

diff --git a/libhurd-mm/capalloc.c b/libhurd-mm/capalloc.c
index 998b123..56715e4 100644
--- a/libhurd-mm/capalloc.c
+++ b/libhurd-mm/capalloc.c
@@ -36,10 +36,10 @@
 
 struct cappage_desc
 {
-  addr_t cappage;
-  struct cap *cap;
+  vg_addr_t cappage;
+  struct vg_cap *cap;
 
-  unsigned char alloced[CAPPAGE_SLOTS / 8];
+  unsigned char alloced[VG_CAPPAGE_SLOTS / 8];
   unsigned short free;
 
   pthread_mutex_t lock;
@@ -71,15 +71,15 @@ list_unlink (struct cappage_desc *e)
 }
 
 static int
-addr_compare (const addr_t *a, const addr_t *b)
+addr_compare (const vg_addr_t *a, const vg_addr_t *b)
 {
-  if (addr_prefix (*a) < addr_prefix (*b))
+  if (vg_addr_prefix (*a) < vg_addr_prefix (*b))
     return -1;
-  return addr_prefix (*a) != addr_prefix (*b);
+  return vg_addr_prefix (*a) != vg_addr_prefix (*b);
 }
 
 BTREE_CLASS (cappage_desc, struct cappage_desc,
-	     addr_t, cappage, node, addr_compare, false)
+	     vg_addr_t, cappage, node, addr_compare, false)
 
 static pthread_mutex_t cappage_descs_lock = PTHREAD_MUTEX_INITIALIZER;
 static hurd_btree_cappage_desc_t cappage_descs;
@@ -91,11 +91,11 @@ cappage_desc_slab_alloc (void *hook, size_t size, void **ptr)
   assert (size == PAGESIZE);
 
   struct storage storage = storage_alloc (meta_data_activity,
-					  cap_page, STORAGE_LONG_LIVED,
-					  OBJECT_POLICY_DEFAULT, ADDR_VOID);
-  if (ADDR_IS_VOID (storage.addr))
+					  vg_cap_page, STORAGE_LONG_LIVED,
+					  VG_OBJECT_POLICY_DEFAULT, VG_ADDR_VOID);
+  if (VG_ADDR_IS_VOID (storage.addr))
     panic ("Out of storage");
-  *ptr = ADDR_TO_PTR (addr_extend (storage.addr, 0, PAGESIZE_LOG2));
+  *ptr = VG_ADDR_TO_PTR (vg_addr_extend (storage.addr, 0, PAGESIZE_LOG2));
 
   return 0;
 }
@@ -105,7 +105,7 @@ cappage_desc_slab_dealloc (void *hook, void *buffer, size_t size)
 {
   assert (size == PAGESIZE);
 
-  addr_t addr = addr_chop (PTR_TO_ADDR (buffer), PAGESIZE_LOG2);
+  vg_addr_t addr = vg_addr_chop (VG_PTR_TO_ADDR (buffer), PAGESIZE_LOG2);
   storage_free (addr, false);
 
   return 0;
@@ -135,7 +135,7 @@ cappage_desc_free (struct cappage_desc *storage)
 
 struct cappage_desc *nonempty;
 
-addr_t
+vg_addr_t
 capalloc (void)
 {
   /* Find an appropriate storage area.  */
@@ -170,12 +170,12 @@ capalloc (void)
       /* As there is such a large number of caps per cappage, we
 	 expect that the page will be long lived.  */
       struct storage storage = storage_alloc (meta_data_activity,
-					      cap_cappage, STORAGE_LONG_LIVED,
-					      OBJECT_POLICY_DEFAULT, ADDR_VOID);
-      if (ADDR_IS_VOID (storage.addr))
+					      vg_cap_cappage, STORAGE_LONG_LIVED,
+					      VG_OBJECT_POLICY_DEFAULT, VG_ADDR_VOID);
+      if (VG_ADDR_IS_VOID (storage.addr))
 	{
 	  cappage_desc_free (area);
-	  return ADDR_VOID;
+	  return VG_ADDR_VOID;
 	}
 
       area->lock = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
@@ -186,29 +186,29 @@ capalloc (void)
 
       /* Then, allocate the shadow object.  */
       struct storage shadow_storage
-	= storage_alloc (meta_data_activity, cap_page,
-			 STORAGE_LONG_LIVED, OBJECT_POLICY_DEFAULT, ADDR_VOID);
-      if (ADDR_IS_VOID (shadow_storage.addr))
+	= storage_alloc (meta_data_activity, vg_cap_page,
+			 STORAGE_LONG_LIVED, VG_OBJECT_POLICY_DEFAULT, VG_ADDR_VOID);
+      if (VG_ADDR_IS_VOID (shadow_storage.addr))
 	{
 	  /* No memory.  */
 	  storage_free (area->cappage, false);
 	  cappage_desc_free (area);
-	  return ADDR_VOID;
+	  return VG_ADDR_VOID;
 	}
 
-      struct object *shadow = ADDR_TO_PTR (addr_extend (shadow_storage.addr,
+      struct object *shadow = VG_ADDR_TO_PTR (vg_addr_extend (shadow_storage.addr,
 							0, PAGESIZE_LOG2));
       memset (shadow, 0, PAGESIZE);
-      cap_set_shadow (area->cap, shadow);
+      vg_cap_set_shadow (area->cap, shadow);
 
       memset (&area->alloced, 0, sizeof (area->alloced));
-      area->free = CAPPAGE_SLOTS;
+      area->free = VG_CAPPAGE_SLOTS;
     }
 
   int idx = bit_alloc (area->alloced, sizeof (area->alloced), 0);
   assert (idx != -1);
 
-  addr_t addr = addr_extend (area->cappage, idx, CAPPAGE_SLOTS_LOG2);
+  vg_addr_t addr = vg_addr_extend (area->cappage, idx, VG_CAPPAGE_SLOTS_LOG2);
 
   area->free --;
   if (area->free == 0)
@@ -241,9 +241,9 @@ capalloc (void)
 }
 
 void
-capfree (addr_t cap)
+capfree (vg_addr_t cap)
 {
-  addr_t cappage = addr_chop (cap, CAPPAGE_SLOTS_LOG2);
+  vg_addr_t cappage = vg_addr_chop (cap, VG_CAPPAGE_SLOTS_LOG2);
 
   struct cappage_desc *desc;
 
@@ -252,14 +252,14 @@ capfree (addr_t cap)
   assert (desc);
   pthread_mutex_lock (&desc->lock);
 
-  bit_dealloc (desc->alloced, addr_extract (cap, CAPPAGE_SLOTS_LOG2));
+  bit_dealloc (desc->alloced, vg_addr_extract (cap, VG_CAPPAGE_SLOTS_LOG2));
   desc->free ++;
 
   if (desc->free == 1)
     /* The cappage is no longer full.  Add it back to the list of
        nonempty cappages.  */
     list_link (&nonempty, desc);
-  else if (desc->free == CAPPAGE_SLOTS)
+  else if (desc->free == VG_CAPPAGE_SLOTS)
     /* No slots in the cappage are allocated.  Free it if there is at
        least one cappage on NONEMPTY.  */
     {
@@ -270,12 +270,12 @@ capfree (addr_t cap)
 	  list_unlink (desc);
 	  pthread_mutex_unlock (&cappage_descs_lock);
 
-	  struct object *shadow = cap_get_shadow (desc->cap);
-	  storage_free (addr_chop (PTR_TO_ADDR (shadow), PAGESIZE_LOG2),
+	  struct object *shadow = vg_cap_get_shadow (desc->cap);
+	  storage_free (vg_addr_chop (VG_PTR_TO_ADDR (shadow), PAGESIZE_LOG2),
 			false);
-	  cap_set_shadow (desc->cap, NULL);
+	  vg_cap_set_shadow (desc->cap, NULL);
 
-	  desc->cap->type = cap_void;
+	  desc->cap->type = vg_cap_void;
 
 	  cappage_desc_free (desc);