Add a "vg_" to public viengoos identifiers.

2008-12-17  Neal H. Walfield  <neal@gnu.org>

	* viengoos/activity.h: Add a "vg_" to public viengoos identifiers.
	Update users.
	* viengoos/addr-trans.h: Likewise.
	* viengoos/addr.h: Likewise.
	* viengoos/cap.h: Likewise.
	* viengoos/folio.h: Likewise.
	* viengoos/futex.h: Likewise.
	* viengoos/rpc.h: Likewise.
	* viengoos/thread.h: Likewise.

14 files changed, 611 insertions, 610 deletions

diff --git a/libviengoos/t-addr-trans.c b/libviengoos/t-addr-trans.c
index c3607ad..7ce57eb 100644
--- a/libviengoos/t-addr-trans.c
+++ b/libviengoos/t-addr-trans.c
@@ -1,4 +1,4 @@
-/* t-cap.c - Test the implementation of the various cap functions.
+/* t-cap.c - Test the implementation of the various vg_cap functions.
    Copyright (C) 2007, 2008 Free Software Foundation, Inc.
    Written by Neal H. Walfield <neal@gnu.org>.
 
@@ -31,9 +31,9 @@ char *program_name = "t-addr-trans";
 int
 main (int argc, char *argv[])
 {
-  printf ("Checking CAP_ADDR_TRANS_SET_GUARD_SUBPAGE... ");
+  printf ("Checking VG_CAP_ADDR_TRANS_SET_GUARD_SUBPAGE... ");
 
-  struct cap_addr_trans cap_addr_trans;
+  struct vg_cap_addr_trans cap_addr_trans;
 
   bool r;
   int subpage_bits;
@@ -45,14 +45,14 @@ main (int argc, char *argv[])
 
       memset (&cap_addr_trans, 0, sizeof (cap_addr_trans));
 
-      r = CAP_ADDR_TRANS_SET_SUBPAGE (&cap_addr_trans, 0, subpages);
+      r = VG_CAP_ADDR_TRANS_SET_SUBPAGE (&cap_addr_trans, 0, subpages);
       assert (r == (subpage_bits <= 8));
       if (subpage_bits >= 8)
 	continue;
 
-      assert (CAP_ADDR_TRANS_SUBPAGES (cap_addr_trans) == subpages);
-      assert (CAP_ADDR_TRANS_SUBPAGE_SIZE (cap_addr_trans) == subpage_size);
-      assert (CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2 (cap_addr_trans)
+      assert (VG_CAP_ADDR_TRANS_SUBPAGES (cap_addr_trans) == subpages);
+      assert (VG_CAP_ADDR_TRANS_SUBPAGE_SIZE (cap_addr_trans) == subpage_size);
+      assert (VG_CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2 (cap_addr_trans)
 	      == subpage_size_log2);
 
       int gdepth;
@@ -62,15 +62,15 @@ main (int argc, char *argv[])
 	  for (guard_bits = 0; guard_bits < sizeof (uintptr_t) * 8; guard_bits ++)
 	    {
 	      int guard = (1 << guard_bits) - 1;
-	      r = CAP_ADDR_TRANS_SET_GUARD (&cap_addr_trans, guard, gdepth);
+	      r = VG_CAP_ADDR_TRANS_SET_GUARD (&cap_addr_trans, guard, gdepth);
 	      if (guard_bits <= gdepth
 		  && (guard_bits + subpage_bits
-		      <= CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS))
+		      <= VG_CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS))
 		{
 		  assert (r);
-		  assert (CAP_ADDR_TRANS_GUARD_BITS (cap_addr_trans)
+		  assert (VG_CAP_ADDR_TRANS_GUARD_BITS (cap_addr_trans)
 			  == gdepth);
-		  assert (CAP_ADDR_TRANS_GUARD (cap_addr_trans) == guard);
+		  assert (VG_CAP_ADDR_TRANS_GUARD (cap_addr_trans) == guard);
 		}
 	      else
 		assert (! r);
diff --git a/libviengoos/t-addr.c b/libviengoos/t-addr.c
index a69eb83..2a58887 100644
--- a/libviengoos/t-addr.c
+++ b/libviengoos/t-addr.c
@@ -30,41 +30,41 @@ int output_debug = 0;
 int
 main (int argc, char *argv[])
 {
-  addr_t addr;
+  vg_addr_t addr;
   int i, j;
 
-  printf ("Checking ADDR... ");
-  for (i = 0; i < ADDR_BITS; i ++)
+  printf ("Checking VG_ADDR... ");
+  for (i = 0; i < VG_ADDR_BITS; i ++)
     {
-      addr = ADDR (1ULL << i, ADDR_BITS - i);
+      addr = VG_ADDR (1ULL << i, VG_ADDR_BITS - i);
       debug (1, "%llx/%d =? %llx/%d\n",
-	     1ULL << i, ADDR_BITS - i,
-	     addr_prefix (addr), addr_depth (addr));
-      assert (addr_depth (addr) == ADDR_BITS - i);
-      assert (addr_prefix (addr) == 1ull << i);
+	     1ULL << i, VG_ADDR_BITS - i,
+	     vg_addr_prefix (addr), vg_addr_depth (addr));
+      assert (vg_addr_depth (addr) == VG_ADDR_BITS - i);
+      assert (vg_addr_prefix (addr) == 1ull << i);
     }
   printf ("ok.\n");
 
-  printf ("Checking addr_extend... ");
-  addr = ADDR (0, 0);
-  for (i = 1; i < ADDR_BITS; i ++)
+  printf ("Checking vg_addr_extend... ");
+  addr = VG_ADDR (0, 0);
+  for (i = 1; i < VG_ADDR_BITS; i ++)
     {
-      addr = addr_extend (addr, 1, 1);
-      assert (addr_depth (addr) == i);
-      assert (vg_msb64 (addr_prefix (addr)) == ADDR_BITS);
-      assert (vg_lsb64 (addr_prefix (addr)) == ADDR_BITS - i + 1);
+      addr = vg_addr_extend (addr, 1, 1);
+      assert (vg_addr_depth (addr) == i);
+      assert (vg_msb64 (vg_addr_prefix (addr)) == VG_ADDR_BITS);
+      assert (vg_lsb64 (vg_addr_prefix (addr)) == VG_ADDR_BITS - i + 1);
     }
   printf ("ok.\n");
 
-  printf ("Checking addr_extract... ");
-  addr = ADDR (0, 0);
-  for (i = 0; i < ADDR_BITS; i ++)
+  printf ("Checking vg_addr_extract... ");
+  addr = VG_ADDR (0, 0);
+  for (i = 0; i < VG_ADDR_BITS; i ++)
     {
-      addr = ADDR (((1ULL << i) - 1) << (ADDR_BITS - i), i);
+      addr = VG_ADDR (((1ULL << i) - 1) << (VG_ADDR_BITS - i), i);
 
       for (j = 0; j <= i; j ++)
 	{
-	  l4_uint64_t idx = addr_extract (addr, j);
+	  l4_uint64_t idx = vg_addr_extract (addr, j);
 	  assert (idx == (1ULL << j) - 1);
 	}
     }
diff --git a/libviengoos/t-rpc.c b/libviengoos/t-rpc.c
index 0f40fe9..c2d9614 100644
--- a/libviengoos/t-rpc.c
+++ b/libviengoos/t-rpc.c
@@ -53,14 +53,14 @@ main (int argc, char *argv[])
   struct vg_message *msg;
 
 
-#define REPLY ADDR (0x1000, ADDR_BITS - 12)
-  addr_t reply = REPLY;
+#define REPLY VG_ADDR (0x1000, VG_ADDR_BITS - 12)
+  vg_addr_t reply = REPLY;
 
   msg = malloc (sizeof (*msg));
   rpc_noargs_send_marshal (msg, REPLY);
   err = rpc_noargs_send_unmarshal (msg, &reply);
   assert (! err);
-  assert (ADDR_EQ (reply, REPLY));
+  assert (VG_ADDR_EQ (reply, REPLY));
   free (msg);
 
   msg = malloc (sizeof (*msg));
@@ -79,7 +79,7 @@ main (int argc, char *argv[])
   err = rpc_onein_send_unmarshal (msg, &arg_out, &reply);
   assert (! err);
   assert (arg_out == VALUE);
-  assert (ADDR_EQ (reply, REPLY));
+  assert (VG_ADDR_EQ (reply, REPLY));
   free (msg);
 
   msg = malloc (sizeof (*msg));
@@ -92,7 +92,7 @@ main (int argc, char *argv[])
   rpc_oneout_send_marshal (msg, REPLY);
   err = rpc_oneout_send_unmarshal (msg, &reply);
   assert (! err);
-  assert (ADDR_EQ (reply, REPLY));
+  assert (VG_ADDR_EQ (reply, REPLY));
   free (msg);
 
   msg = malloc (sizeof (*msg));
@@ -120,7 +120,7 @@ main (int argc, char *argv[])
   assert (foo_out.a == foo.a);
   assert (foo_out.b == foo.b);
   assert (p_out == true);
-  assert (ADDR_EQ (reply, REPLY));
+  assert (VG_ADDR_EQ (reply, REPLY));
   free (msg);
 
   msg = malloc (sizeof (*msg));
@@ -133,7 +133,7 @@ main (int argc, char *argv[])
   rpc_onlyout_send_marshal (msg, REPLY);
   err = rpc_onlyout_send_unmarshal (msg, &reply);
   assert (! err);
-  assert (ADDR_EQ (reply, REPLY));
+  assert (VG_ADDR_EQ (reply, REPLY));
   free (msg);
 
   msg = malloc (sizeof (*msg));
@@ -155,7 +155,7 @@ main (int argc, char *argv[])
   assert (! err);
   assert (arg_out == arg);
   assert (idx_out == 456789);
-  assert (ADDR_EQ (reply, REPLY));
+  assert (VG_ADDR_EQ (reply, REPLY));
   free (msg);
 
   msg = malloc (sizeof (*msg));
@@ -170,12 +170,12 @@ main (int argc, char *argv[])
   free (msg);
 
   msg = malloc (sizeof (*msg));
-  rpc_caps_send_marshal (msg, 54, ADDR (1, ADDR_BITS), foo, REPLY);
-  addr_t addr;
+  rpc_caps_send_marshal (msg, 54, VG_ADDR (1, VG_ADDR_BITS), foo, REPLY);
+  vg_addr_t addr;
   err = rpc_caps_send_unmarshal (msg, &i_out, &addr, &foo_out, &reply);
   assert (! err);
   assert (i_out == 54);
-  assert (ADDR_EQ (addr, ADDR (1, ADDR_BITS)));
+  assert (VG_ADDR_EQ (addr, VG_ADDR (1, VG_ADDR_BITS)));
   assert (foo_out.a == foo.a);
   assert (foo_out.b == foo.b);
   free (msg);
diff --git a/libviengoos/viengoos/activity.h b/libviengoos/viengoos/activity.h
index a180527..8f5375b 100644
--- a/libviengoos/viengoos/activity.h
+++ b/libviengoos/viengoos/activity.h
@@ -35,9 +35,9 @@ struct activity_memory_policy
   uint16_t weight;
 };
 
-#define ACTIVITY_MEMORY_POLICY(__amp_priority, __amp_weight)		\
+#define VG_ACTIVITY_MEMORY_POLICY(__amp_priority, __amp_weight)		\
   (struct activity_memory_policy) { __amp_priority, __amp_weight }
-#define ACTIVITY_MEMORY_POLICY_VOID ACTIVITY_MEMORY_POLICY(0, 0)
+#define VG_ACTIVITY_MEMORY_POLICY_VOID VG_ACTIVITY_MEMORY_POLICY(0, 0)
 
 struct activity_policy
 {
@@ -158,11 +158,11 @@ struct activity_stats
   uint32_t saved;
 };
 
-#define ACTIVITY_POLICY(__ap_sibling_rel, __ap_child_rel, __ap_storage) \
+#define VG_ACTIVITY_POLICY(__ap_sibling_rel, __ap_child_rel, __ap_storage) \
   (struct activity_policy) { __ap_sibling_rel, __ap_child_rel, __ap_storage }
-#define ACTIVITY_POLICY_VOID			\
-  ACTIVITY_POLICY(ACTIVITY_MEMORY_POLICY_VOID,	\
-		  ACTIVITY_MEMORY_POLICY_VOID,	\
+#define VG_ACTIVITY_POLICY_VOID			\
+  VG_ACTIVITY_POLICY(VG_ACTIVITY_MEMORY_POLICY_VOID,	\
+		  VG_ACTIVITY_MEMORY_POLICY_VOID,	\
 		  0)
 
 #define RPC_STUB_PREFIX rm
@@ -172,17 +172,17 @@ struct activity_stats
 
 enum
 {
-  ACTIVITY_POLICY_CHILD_REL_PRIORITY_SET = 1 << 0,
-  ACTIVITY_POLICY_CHILD_REL_WEIGHT_SET = 1 << 1,
-  ACTIVITY_POLICY_SIBLING_REL_PRIORITY_SET = 1 << 2,
-  ACTIVITY_POLICY_SIBLING_REL_WEIGHT_SET = 1 << 3,
-  ACTIVITY_POLICY_STORAGE_SET = 1 << 4,
+  VG_ACTIVITY_POLICY_CHILD_REL_PRIORITY_SET = 1 << 0,
+  VG_ACTIVITY_POLICY_CHILD_REL_WEIGHT_SET = 1 << 1,
+  VG_ACTIVITY_POLICY_SIBLING_REL_PRIORITY_SET = 1 << 2,
+  VG_ACTIVITY_POLICY_SIBLING_REL_WEIGHT_SET = 1 << 3,
+  VG_ACTIVITY_POLICY_STORAGE_SET = 1 << 4,
 
-  ACTIVITY_POLICY_CHILD_REL_SET = (ACTIVITY_POLICY_CHILD_REL_PRIORITY_SET
-				   | ACTIVITY_POLICY_CHILD_REL_WEIGHT_SET),
+  VG_ACTIVITY_POLICY_CHILD_REL_SET = (VG_ACTIVITY_POLICY_CHILD_REL_PRIORITY_SET
+				   | VG_ACTIVITY_POLICY_CHILD_REL_WEIGHT_SET),
 
-  ACTIVITY_POLICY_SIBLING_REL_SET = (ACTIVITY_POLICY_SIBLING_REL_PRIORITY_SET
-				     | ACTIVITY_POLICY_SIBLING_REL_WEIGHT_SET),
+  VG_ACTIVITY_POLICY_SIBLING_REL_SET = (VG_ACTIVITY_POLICY_SIBLING_REL_PRIORITY_SET
+				     | VG_ACTIVITY_POLICY_SIBLING_REL_WEIGHT_SET),
 };
 
 /* Get ACTIVITY's policy and set according to FLAGS and IN.  */
diff --git a/libviengoos/viengoos/addr-trans.h b/libviengoos/viengoos/addr-trans.h
index b48f132..e7ca995 100644
--- a/libviengoos/viengoos/addr-trans.h
+++ b/libviengoos/viengoos/addr-trans.h
@@ -30,11 +30,11 @@
    how the page table walker translates bits when passing through this
    capability.  */
 
-#define CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS 22
-#define CAP_ADDR_TRANS_SUBPAGES_BITS 4
-#define CAP_ADDR_TRANS_GDEPTH_BITS 6
+#define VG_CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS 22
+#define VG_CAP_ADDR_TRANS_SUBPAGES_BITS 4
+#define VG_CAP_ADDR_TRANS_GDEPTH_BITS 6
 
-struct cap_addr_trans
+struct vg_cap_addr_trans
 {
   union
   {
@@ -53,61 +53,61 @@ struct cap_addr_trans
       only valid offset is 0) and 21 possible guard bits.  If
       SUBPAGES_LOG2 is 0, there are 256 subpages, 8 subpage bits and a
       maximum of 21-8=15 guard bits.  */
-      uint32_t guard_subpage: CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS;
+      uint32_t guard_subpage: VG_CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS;
       /* The log2 of the subpages.  The size of a subpage is thus 2^(8 -
 	 SUBPAGES_LOG2).  Values of SUBPAGES_LOG2 other than 0 are only
-	 allowed for cap pages.  */
-      uint32_t subpages_log2: CAP_ADDR_TRANS_SUBPAGES_BITS;
+	 allowed for vg_cap pages.  */
+      uint32_t subpages_log2: VG_CAP_ADDR_TRANS_SUBPAGES_BITS;
       /* Number of significant guard bits.  The value of the GUARD is zero
 	 extended if GDEPTH is greater than the number of available guard
 	 bits.  */
-      uint32_t gdepth: CAP_ADDR_TRANS_GDEPTH_BITS;
+      uint32_t gdepth: VG_CAP_ADDR_TRANS_GDEPTH_BITS;
     };
     uint32_t raw;
   };
 };
 
-#define CAP_ADDR_TRANS_INIT { { .raw = 0 } }
-#define CAP_ADDR_TRANS_VOID (struct cap_addr_trans) { { .raw = 0 } }
+#define VG_CAP_ADDR_TRANS_INIT { { .raw = 0 } }
+#define VG_CAP_ADDR_TRANS_VOID (struct vg_cap_addr_trans) { { .raw = 0 } }
 
 /* The log2 number of subpages.  */
-#define CAP_ADDR_TRANS_SUBPAGES_LOG2(cap_addr_trans_) \
+#define VG_CAP_ADDR_TRANS_SUBPAGES_LOG2(cap_addr_trans_) \
   ((cap_addr_trans_).subpages_log2)
 
 /* The number of subpages.  */
-#define CAP_ADDR_TRANS_SUBPAGES(cap_addr_trans_) \
-  (1 << CAP_ADDR_TRANS_SUBPAGES_LOG2((cap_addr_trans_)))
+#define VG_CAP_ADDR_TRANS_SUBPAGES(cap_addr_trans_) \
+  (1 << VG_CAP_ADDR_TRANS_SUBPAGES_LOG2((cap_addr_trans_)))
 
 /* The designated subpage.  */
-#define CAP_ADDR_TRANS_SUBPAGE(cap_addr_trans_) \
+#define VG_CAP_ADDR_TRANS_SUBPAGE(cap_addr_trans_) \
   ((cap_addr_trans_).guard_subpage \
-   & (CAP_ADDR_TRANS_SUBPAGES ((cap_addr_trans_)) - 1))
+   & (VG_CAP_ADDR_TRANS_SUBPAGES ((cap_addr_trans_)) - 1))
 
 /* The log2 of the size of the named subpage (in capability
    units).  */
-#define CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2(cap_addr_trans_) \
+#define VG_CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2(cap_addr_trans_) \
   (8 - (cap_addr_trans_).subpages_log2)
 
 /* The number of caps addressed by this capability.  */
-#define CAP_ADDR_TRANS_SUBPAGE_SIZE(cap_addr_trans_) \
-  (1 << CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2 ((cap_addr_trans_)))
+#define VG_CAP_ADDR_TRANS_SUBPAGE_SIZE(cap_addr_trans_) \
+  (1 << VG_CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2 ((cap_addr_trans_)))
 
 /* The offset in capability units (with respect to the start of the
    capability page) of the first capability in the designated
    sub-page.  */
-#define CAP_ADDR_TRANS_SUBPAGE_OFFSET(cap_addr_trans_) \
-  (CAP_ADDR_TRANS_SUBPAGE ((cap_addr_trans_)) \
-   * CAP_ADDR_TRANS_SUBPAGE_SIZE ((cap_addr_trans_)))
+#define VG_CAP_ADDR_TRANS_SUBPAGE_OFFSET(cap_addr_trans_) \
+  (VG_CAP_ADDR_TRANS_SUBPAGE ((cap_addr_trans_)) \
+   * VG_CAP_ADDR_TRANS_SUBPAGE_SIZE ((cap_addr_trans_)))
 
 /* The number of guard bits.  */
-#define CAP_ADDR_TRANS_GUARD_BITS(cap_addr_trans_) ((cap_addr_trans_).gdepth)
+#define VG_CAP_ADDR_TRANS_GUARD_BITS(cap_addr_trans_) ((cap_addr_trans_).gdepth)
 
 /* The value of the guard.  */
-#define CAP_ADDR_TRANS_GUARD(cap_addr_trans_) \
+#define VG_CAP_ADDR_TRANS_GUARD(cap_addr_trans_) \
   ((uint64_t) ((cap_addr_trans_).guard_subpage \
 	       >> (cap_addr_trans_).subpages_log2))
 
-#define CATSGST_(test_, format, args...) \
+#define VG_CATSGST_(test_, format, args...) \
   if (! (test_)) \
     { \
       r_ = false; \
@@ -116,29 +116,29 @@ struct cap_addr_trans
 
 /* Set CAP_ADDR_TRANS_P_'s guard and the subpage.  Returns true on success
    (parameters valid), false otherwise.  */
-#define CAP_ADDR_TRANS_SET_GUARD_SUBPAGE(cap_addr_trans_p_, guard_, gdepth_, \
+#define VG_CAP_ADDR_TRANS_SET_GUARD_SUBPAGE(cap_addr_trans_p_, guard_, gdepth_, \
 					 subpage_, subpages_) \
   ({ bool r_ = true; \
      /* There must be at least 1 subpage.  */ \
-     CATSGST_ (((subpages_) > 0), \
+     VG_CATSGST_ (((subpages_) > 0), \
 	       "subpages_ (%d) must be at least 1\n", (subpages_)); \
-     CATSGST_ (((subpages_) & ((subpages_) - 1)) == 0, \
+     VG_CATSGST_ (((subpages_) & ((subpages_) - 1)) == 0, \
                "SUBPAGES_ (%d) must be a power of 2\n", (subpages_)); \
      int subpages_log2_ = vg_msb ((subpages_)) - 1; \
-     CATSGST_ (subpages_log2_ <= 8, \
+     VG_CATSGST_ (subpages_log2_ <= 8, \
                "maximum subpages is 256 (%d)\n", (subpages_)); \
-     CATSGST_ (0 <= (subpage_) && (subpage_) < (subpages_), \
+     VG_CATSGST_ (0 <= (subpage_) && (subpage_) < (subpages_), \
                "subpage (%d) must be between 0 and SUBPAGES_ (%d) - 1\n", \
                (subpage_), (subpages_)); \
      \
      /* The number of required guard bits.  */ \
      int gbits_ = vg_msb64 ((guard_)); \
-     CATSGST_ (gbits_ <= (gdepth_), \
+     VG_CATSGST_ (gbits_ <= (gdepth_), \
                "Significant guard bits (%d) must be less than depth (%d)\n", \
                gbits_, (gdepth_)); \
-     CATSGST_ (gbits_ + subpages_log2_ <= CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS, \
+     VG_CATSGST_ (gbits_ + subpages_log2_ <= VG_CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS, \
                "Significant guard bits (%d) plus subpage bits (%d) > %d\n", \
-               gbits_, subpages_log2_, CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS); \
+               gbits_, subpages_log2_, VG_CAP_ADDR_TRANS_GUARD_SUBPAGE_BITS); \
      \
      if (r_) \
        { \
@@ -152,38 +152,38 @@ struct cap_addr_trans
 
 /* Set *CAP_ADDR_TRANS_P_'s guard.  Returns true on success (parameters
    valid), false otherwise.  */
-#define CAP_ADDR_TRANS_SET_GUARD(cap_addr_trans_p_, guard_, gdepth_) \
-  ({ int subpage_ = CAP_ADDR_TRANS_SUBPAGE (*(cap_addr_trans_p_)); \
-     int subpages_ = CAP_ADDR_TRANS_SUBPAGES (*(cap_addr_trans_p_)); \
-     CAP_ADDR_TRANS_SET_GUARD_SUBPAGE ((cap_addr_trans_p_), \
+#define VG_CAP_ADDR_TRANS_SET_GUARD(cap_addr_trans_p_, guard_, gdepth_) \
+  ({ int subpage_ = VG_CAP_ADDR_TRANS_SUBPAGE (*(cap_addr_trans_p_)); \
+     int subpages_ = VG_CAP_ADDR_TRANS_SUBPAGES (*(cap_addr_trans_p_)); \
+     VG_CAP_ADDR_TRANS_SET_GUARD_SUBPAGE ((cap_addr_trans_p_), \
 				       (guard_), (gdepth_), \
 				       (subpage_), (subpages_)); \
   })
 
 /* Set *CAP_ADDR_TRANS_P_'s subpage.  Returns true on success (parameters
    valid), false otherwise.  */
-#define CAP_ADDR_TRANS_SET_SUBPAGE(cap_addr_trans_p_, subpage_, subpages_) \
-  ({ int gdepth_ = CAP_ADDR_TRANS_GUARD_BITS (*(cap_addr_trans_p_)); \
-     int guard_ = CAP_ADDR_TRANS_GUARD (*(cap_addr_trans_p_)); \
-     CAP_ADDR_TRANS_SET_GUARD_SUBPAGE ((cap_addr_trans_p_), \
+#define VG_CAP_ADDR_TRANS_SET_SUBPAGE(cap_addr_trans_p_, subpage_, subpages_) \
+  ({ int gdepth_ = VG_CAP_ADDR_TRANS_GUARD_BITS (*(cap_addr_trans_p_)); \
+     int guard_ = VG_CAP_ADDR_TRANS_GUARD (*(cap_addr_trans_p_)); \
+     VG_CAP_ADDR_TRANS_SET_GUARD_SUBPAGE ((cap_addr_trans_p_), \
 				       (guard_), (gdepth_), \
 				       (subpage_), (subpages_)); \
   })
 
 /* Returns whether the capability address CAP_ADDR_TRANS is well-formed.  */
-#define CAP_ADDR_TRANS_VALID(cap_addr_trans) \
+#define VG_CAP_ADDR_TRANS_VALID(vg_cap_addr_trans) \
   ({ bool r_ = true; \
-     CATSGST_ (CAP_ADDR_TRANS_GUARD_BITS (cap_addr_trans) <= WORDSIZE, \
+     VG_CATSGST_ (VG_CAP_ADDR_TRANS_GUARD_BITS (vg_cap_addr_trans) <= WORDSIZE, \
 	       "Invalid guard depth (%d)", \
-	       CAP_ADDR_TRANS_GUARD_BITS (cap_addr_trans)); \
-     CATSGST_ (CAP_ADDR_TRANS_SUBPAGES_LOG2 (cap_addr_trans) <= 8, \
+	       VG_CAP_ADDR_TRANS_GUARD_BITS (vg_cap_addr_trans)); \
+     VG_CATSGST_ (VG_CAP_ADDR_TRANS_SUBPAGES_LOG2 (vg_cap_addr_trans) <= 8, \
                "Invalid number of subpages (%d)", \
-               CAP_ADDR_TRANS_SUBPAGES (cap_addr_trans)); \
-     CATSGST_ (vg_msb (CAP_ADDR_TRANS_GUARD (cap_addr_trans)) \
-	       <= CAP_ADDR_TRANS_GUARD_BITS (cap_addr_trans), \
+               VG_CAP_ADDR_TRANS_SUBPAGES (vg_cap_addr_trans)); \
+     VG_CATSGST_ (vg_msb (VG_CAP_ADDR_TRANS_GUARD (vg_cap_addr_trans)) \
+	       <= VG_CAP_ADDR_TRANS_GUARD_BITS (vg_cap_addr_trans), \
                "Significant guard bits (%d) exceeds guard depth (%d)", \
-               vg_msb (CAP_ADDR_TRANS_GUARD (cap_addr_trans)), \
-	       CAP_ADDR_TRANS_GUARD_BITS (cap_addr_trans)); \
+               vg_msb (VG_CAP_ADDR_TRANS_GUARD (vg_cap_addr_trans)), \
+	       VG_CAP_ADDR_TRANS_GUARD_BITS (vg_cap_addr_trans)); \
      r_; \
   })
 
diff --git a/libviengoos/viengoos/addr.h b/libviengoos/viengoos/addr.h
index 8fa59be..d3c9009 100644
--- a/libviengoos/viengoos/addr.h
+++ b/libviengoos/viengoos/addr.h
@@ -49,131 +49,131 @@ struct addr
 {
   uint64_t raw;
 };
-#define ADDR_BITS 63
+#define VG_ADDR_BITS 63
 /* Client-side capability handle.  */
-typedef struct addr addr_t;
+typedef struct addr vg_addr_t;
 
-#define ADDR_FMT "%llx/%d"
-#define ADDR_PRINTF(addr_) addr_prefix ((addr_)), addr_depth ((addr_))
+#define VG_ADDR_FMT "%llx/%d"
+#define VG_ADDR_PRINTF(addr_) vg_addr_prefix ((addr_)), vg_addr_depth ((addr_))
 
 /* Create an address given a prefix and a depth.  */
-#define ADDR(prefix_, depth_) \
+#define VG_ADDR(prefix_, depth_) \
   ({ \
     uint64_t p_ = (prefix_); \
     uint64_t d_ = (depth_); \
-    assert (0 <= d_ && d_ <= ADDR_BITS); \
-    assert ((p_ & ((1 << (ADDR_BITS - d_)) - 1)) == 0); \
-    assert (p_ < (1ULL << ADDR_BITS)); \
-    (struct addr) { (p_ << 1ULL) | (1ULL << (ADDR_BITS - d_)) }; \
+    assert (0 <= d_ && d_ <= VG_ADDR_BITS); \
+    assert ((p_ & ((1 << (VG_ADDR_BITS - d_)) - 1)) == 0); \
+    assert (p_ < (1ULL << VG_ADDR_BITS)); \
+    (struct addr) { (p_ << 1ULL) | (1ULL << (VG_ADDR_BITS - d_)) }; \
   })
 
 /* Create an address given a prefix and a depth.  Appropriate for use
    as an initializer.  */
-#define ADDR_INIT(prefix_, depth_) \
-  { .raw = ((((prefix_) << 1) | 1) << (ADDR_BITS - (depth_))) }
+#define VG_ADDR_INIT(prefix_, depth_) \
+  { .raw = ((((prefix_) << 1) | 1) << (VG_ADDR_BITS - (depth_))) }
 
-#define ADDR_VOID ((struct addr) { 0ULL })
-#define ADDR_EQ(a, b) (a.raw == b.raw)
-#define ADDR_IS_VOID(a) (ADDR_EQ (a, ADDR_VOID))
+#define VG_ADDR_VOID ((struct addr) { 0ULL })
+#define VG_ADDR_EQ(a, b) (a.raw == b.raw)
+#define VG_ADDR_IS_VOID(a) (VG_ADDR_EQ (a, VG_ADDR_VOID))
 
 /* Return ADDR_'s depth.  */
 static inline int
-addr_depth (addr_t addr)
+vg_addr_depth (vg_addr_t addr)
 {
-  return ADDR_BITS - (vg_lsb64 (addr.raw) - 1);
+  return VG_ADDR_BITS - (vg_lsb64 (addr.raw) - 1);
 }
 
-/* Return ADDR's prefix.  */
+/* Return VG_ADDR's prefix.  */
 static inline uint64_t
-addr_prefix (addr_t addr)
+vg_addr_prefix (vg_addr_t addr)
 {
   /* (Clear the boundary bit and shift right 1.)  */
-  return (addr.raw & ~(1ULL << (ADDR_BITS - addr_depth (addr)))) >> 1;
+  return (addr.raw & ~(1ULL << (VG_ADDR_BITS - vg_addr_depth (addr)))) >> 1;
 }
 
-/* Extend the address ADDR by concatenating the lowest DEPTH bits of
+/* Extend the address VG_ADDR by concatenating the lowest DEPTH bits of
    PREFIX.  */
 #if 0
-static inline addr_t
-addr_extend (addr_t addr, uint64_t prefix, int depth)
+static inline vg_addr_t
+vg_addr_extend (vg_addr_t addr, uint64_t prefix, int depth)
 {
   assertx (depth >= 0, "depth: %d", depth);
-  assertx (addr_depth (addr) + depth <= ADDR_BITS,
-	   "addr: " ADDR_FMT "; depth: %d", ADDR_PRINTF (addr), depth);
+  assertx (vg_addr_depth (addr) + depth <= VG_ADDR_BITS,
+	   "addr: " VG_ADDR_FMT "; depth: %d", VG_ADDR_PRINTF (addr), depth);
   assertx (prefix < (1ULL << depth),
 	   "prefix: %llx; depth: %lld", prefix, 1ULL << depth);
-  return ADDR (addr_prefix (addr)
-	       | (prefix << (ADDR_BITS - addr_depth (addr) - depth)),
-	       addr_depth (addr) + depth);
+  return VG_ADDR (vg_addr_prefix (addr)
+	       | (prefix << (VG_ADDR_BITS - vg_addr_depth (addr) - depth)),
+	       vg_addr_depth (addr) + depth);
 }
 #else
-#define addr_extend(addr_, prefix_, depth_)				\
+#define vg_addr_extend(addr_, prefix_, depth_)				\
   ({									\
-    addr_t a__ = (addr_);						\
+    vg_addr_t a__ = (addr_);						\
     uint64_t p__ = (prefix_);					\
     int d__ = (depth_);							\
     assertx (d__ >= 0, "depth: %d", d__);				\
-    assertx (addr_depth ((a__)) + (d__) <= ADDR_BITS,			\
-	     "addr: " ADDR_FMT "; depth: %d", ADDR_PRINTF (a__), d__);	\
+    assertx (vg_addr_depth ((a__)) + (d__) <= VG_ADDR_BITS,			\
+	     "addr: " VG_ADDR_FMT "; depth: %d", VG_ADDR_PRINTF (a__), d__);	\
     assertx (p__ < (1ULL << d__),					\
 	     "prefix: %llx; depth: %lld", p__, 1ULL << d__);		\
-    ADDR (addr_prefix ((a__))						\
-	  | ((p__) << (ADDR_BITS - addr_depth ((a__)) - (d__))),	\
-	  addr_depth ((a__)) + (d__));					\
+    VG_ADDR (vg_addr_prefix ((a__))						\
+	  | ((p__) << (VG_ADDR_BITS - vg_addr_depth ((a__)) - (d__))),	\
+	  vg_addr_depth ((a__)) + (d__));					\
   })
 #endif
 
-/* Decrease the depth of ADDR by DEPTH.  */
-static inline addr_t
-addr_chop (addr_t addr, int depth)
+/* Decrease the depth of VG_ADDR by DEPTH.  */
+static inline vg_addr_t
+vg_addr_chop (vg_addr_t addr, int depth)
 {
-  int d = addr_depth (addr) - depth;
+  int d = vg_addr_depth (addr) - depth;
   assert (d >= 0);
 
-  return ADDR (addr_prefix (addr) & ~((1ULL << (ADDR_BITS - d)) - 1), d);
+  return VG_ADDR (vg_addr_prefix (addr) & ~((1ULL << (VG_ADDR_BITS - d)) - 1), d);
 }
 
-/* Return the last WIDTH bits of address's ADDR prefix.  */
+/* Return the last WIDTH bits of address's VG_ADDR prefix.  */
 static inline uint64_t
-addr_extract (addr_t addr, int width)
+vg_addr_extract (vg_addr_t addr, int width)
 {
-  assert (width <= addr_depth (addr));
+  assert (width <= vg_addr_depth (addr));
 
-  return (addr_prefix (addr) >> (ADDR_BITS - addr_depth (addr)))
+  return (vg_addr_prefix (addr) >> (VG_ADDR_BITS - vg_addr_depth (addr)))
     & ((1ULL << width) - 1);
 }
 
 /* Convert an address to a pointer.  The address must name an object
    mapped in the machine data instruction accessible part of the
    address space.  */
-#define ADDR_TO_PTR(addr_) \
+#define VG_ADDR_TO_PTR(addr_) \
   ({ \
-    assert (addr_prefix ((addr_)) < ((uintptr_t) -1)); \
-    assert (addr_depth ((addr_)) == ADDR_BITS); \
-    (void *) (uintptr_t) addr_prefix ((addr_)); \
+    assert (vg_addr_prefix ((addr_)) < ((uintptr_t) -1)); \
+    assert (vg_addr_depth ((addr_)) == VG_ADDR_BITS); \
+    (void *) (uintptr_t) vg_addr_prefix ((addr_)); \
   })
 
 /* Convert a pointer to an address.  */
-#define PTR_TO_ADDR(ptr_) \
-  (ADDR ((uintptr_t) (ptr_), ADDR_BITS))
+#define VG_PTR_TO_ADDR(ptr_) \
+  (VG_ADDR ((uintptr_t) (ptr_), VG_ADDR_BITS))
 
 /* Return the address of the page that would contain pointer PTR_.  */
-#define PTR_TO_PAGE(ptr_) \
-  addr_chop (ADDR ((uintptr_t) (ptr_), ADDR_BITS), PAGESIZE_LOG2)
+#define VG_PTR_TO_PAGE(ptr_) \
+  vg_addr_chop (VG_ADDR ((uintptr_t) (ptr_), VG_ADDR_BITS), PAGESIZE_LOG2)
 
-static inline addr_t
-addr_add (addr_t addr, uint64_t count)
+static inline vg_addr_t
+vg_addr_add (vg_addr_t addr, uint64_t count)
 {
-  int w = ADDR_BITS - addr_depth (addr);
+  int w = VG_ADDR_BITS - vg_addr_depth (addr);
 
-  return ADDR (addr_prefix (addr) + (count << w),
-	       addr_depth (addr));
+  return VG_ADDR (vg_addr_prefix (addr) + (count << w),
+	       vg_addr_depth (addr));
 }
 
-static inline addr_t
-addr_sub (addr_t addr, uint64_t count)
+static inline vg_addr_t
+vg_addr_sub (vg_addr_t addr, uint64_t count)
 {
-  return addr_add (addr, - count);
+  return vg_addr_add (addr, - count);
 }
 
 #endif
diff --git a/libviengoos/viengoos/cap.h b/libviengoos/viengoos/cap.h
index c15d66f..32e475a 100644
--- a/libviengoos/viengoos/cap.h
+++ b/libviengoos/viengoos/cap.h
@@ -1,4 +1,4 @@
-/* cap.h - Capability definitions.
+/* vg_cap.h - Capability definitions.
    Copyright (C) 2007, 2008 Free Software Foundation, Inc.
    Written by Neal H. Walfield <neal@gnu.org>.
 
@@ -37,82 +37,82 @@
    used to control how the designated object should be managed.  */
 
 /* The types of objects designated by capabilities.  */
-enum cap_type
+enum vg_cap_type
   {
-#define CAP_TYPE_MIN cap_void
-    cap_void,
-    cap_page,
-    cap_rpage,
-    cap_cappage,
-    cap_rcappage,
-    cap_folio,
-    cap_activity,
-    cap_activity_control,
-    cap_thread,
-    cap_messenger,
-    cap_rmessenger,
-    cap_type_count,
-#define CAP_TYPE_MAX (cap_type_count - 1)
+#define VG_CAP_TYPE_MIN vg_cap_void
+    vg_cap_void,
+    vg_cap_page,
+    vg_cap_rpage,
+    vg_cap_cappage,
+    vg_cap_rcappage,
+    vg_cap_folio,
+    vg_cap_activity,
+    vg_cap_activity_control,
+    vg_cap_thread,
+    vg_cap_messenger,
+    vg_cap_rmessenger,
+    vg_cap_type_count,
+#define VG_CAP_TYPE_MAX (vg_cap_type_count - 1)
   };
 
 static inline const char *
-cap_type_string (enum cap_type type)
+vg_cap_type_string (enum vg_cap_type type)
 {
   switch (type)
     {
-    case cap_void:
+    case vg_cap_void:
       return "void";
-    case cap_page:
+    case vg_cap_page:
       return "page";
-    case cap_rpage:
+    case vg_cap_rpage:
       return "rpage";
-    case cap_cappage:
+    case vg_cap_cappage:
       return "cappage";
-    case cap_rcappage:
+    case vg_cap_rcappage:
       return "rcappage";
-    case cap_folio:
+    case vg_cap_folio:
       return "folio";
-    case cap_activity:
+    case vg_cap_activity:
       return "activity";
-    case cap_activity_control:
+    case vg_cap_activity_control:
       return "activity_control";
-    case cap_thread:
+    case vg_cap_thread:
       return "thread";
-    case cap_messenger:
+    case vg_cap_messenger:
       return "messenger";
-    case cap_rmessenger:
+    case vg_cap_rmessenger:
       return "rmessenger";
     default:
-      return "unknown cap type";
+      return "unknown vg_cap type";
   };
 }
 
 /* Return whether two types are compatible in the sense that two caps
    with the given types can designate the same object.  */
 static inline bool
-cap_types_compatible (enum cap_type a, enum cap_type b)
+vg_cap_types_compatible (enum vg_cap_type a, enum vg_cap_type b)
 {
   if (a == b)
     return true;
 
-  if (a == cap_page && b == cap_rpage)
+  if (a == vg_cap_page && b == vg_cap_rpage)
     return true;
-  if (a == cap_rpage && b == cap_page)
+  if (a == vg_cap_rpage && b == vg_cap_page)
     return true;
 
-  if (a == cap_cappage && b == cap_rcappage)
+  if (a == vg_cap_cappage && b == vg_cap_rcappage)
     return true;
-  if (a == cap_rcappage && b == cap_cappage)
+  if (a == vg_cap_rcappage && b == vg_cap_cappage)
     return true;
 
-  if (a == cap_activity && b == cap_activity_control)
+  if (a == vg_cap_activity && b == vg_cap_activity_control)
     return true;
-  if (a == cap_activity_control && b == cap_activity)
+  if (a == vg_cap_activity_control && b == vg_cap_activity)
     return true;
 
-  if (a == cap_messenger && b == cap_rmessenger)
+  if (a == vg_cap_messenger && b == vg_cap_rmessenger)
     return true;
-  if (a == cap_rmessenger && b == cap_messenger)
+  if (a == vg_cap_rmessenger && b == vg_cap_messenger)
     return true;
 
   return false;
@@ -120,14 +120,14 @@ cap_types_compatible (enum cap_type a, enum cap_type b)
 
 /* Returns weather TYPE corresponds to a weak type.  */
 static inline bool
-cap_type_weak_p (enum cap_type type)
+vg_cap_type_weak_p (enum vg_cap_type type)
 {
   switch (type)
     {
-    case cap_rpage:
-    case cap_rcappage:
-    case cap_activity:
-    case cap_rmessenger:
+    case vg_cap_rpage:
+    case vg_cap_rcappage:
+    case vg_cap_activity:
+    case vg_cap_rmessenger:
       return true;
 
     default:
@@ -137,54 +137,54 @@ cap_type_weak_p (enum cap_type type)
 
 /* Returns the weakened type corresponding to TYPE.  If type is
    already a weak type, returns TYPE.  */
-static inline enum cap_type
-cap_type_weaken (enum cap_type type)
+static inline enum vg_cap_type
+vg_cap_type_weaken (enum vg_cap_type type)
 {
   switch (type)
     {
-    case cap_page:
-    case cap_rpage:
-      return cap_rpage;
+    case vg_cap_page:
+    case vg_cap_rpage:
+      return vg_cap_rpage;
 
-    case cap_cappage:
-    case cap_rcappage:
-      return cap_rcappage;
+    case vg_cap_cappage:
+    case vg_cap_rcappage:
+      return vg_cap_rcappage;
 
-    case cap_activity_control:
-    case cap_activity:
-      return cap_activity;
+    case vg_cap_activity_control:
+    case vg_cap_activity:
+      return vg_cap_activity;
 
-    case cap_messenger:
-    case cap_rmessenger:
-      return cap_rmessenger;
+    case vg_cap_messenger:
+    case vg_cap_rmessenger:
+      return vg_cap_rmessenger;
 
     default:
-      return cap_void;
+      return vg_cap_void;
     }
 }
 
 /* Returns the strong type corresponding to TYPE.  If type is already
    a strong type, returns TYPE.  */
-static inline enum cap_type
-cap_type_strengthen (enum cap_type type)
+static inline enum vg_cap_type
+vg_cap_type_strengthen (enum vg_cap_type type)
 {
   switch (type)
     {
-    case cap_page:
-    case cap_rpage:
-      return cap_page;
+    case vg_cap_page:
+    case vg_cap_rpage:
+      return vg_cap_page;
 
-    case cap_cappage:
-    case cap_rcappage:
-      return cap_cappage;
+    case vg_cap_cappage:
+    case vg_cap_rcappage:
+      return vg_cap_cappage;
 
-    case cap_activity_control:
-    case cap_activity:
-      return cap_activity_control;
+    case vg_cap_activity_control:
+    case vg_cap_activity:
+      return vg_cap_activity_control;
 
-    case cap_messenger:
-    case cap_rmessenger:
-      return cap_messenger;
+    case vg_cap_messenger:
+    case vg_cap_rmessenger:
+      return vg_cap_messenger;
 
     default:
       return type;
@@ -195,11 +195,11 @@ cap_type_strengthen (enum cap_type type)
 
 /* The object priority is a signed 7-bit number (-64 -> 63).  A lower
    numeric value corresponds to a lower priority.  */
-#define OBJECT_PRIORITY_BITS 7
-#define OBJECT_PRIORITY_LEVELS (1 << OBJECT_PRIORITY_BITS)
-#define OBJECT_PRIORITY_MIN (-(1 << (OBJECT_PRIORITY_BITS - 1)))
-#define OBJECT_PRIORITY_DEFAULT (0)
-#define OBJECT_PRIORITY_MAX ((1 << (OBJECT_PRIORITY_BITS - 1)) - 1)
+#define VG_OBJECT_PRIORITY_BITS 7
+#define VG_OBJECT_PRIORITY_LEVELS (1 << VG_OBJECT_PRIORITY_BITS)
+#define VG_OBJECT_PRIORITY_MIN (-(1 << (VG_OBJECT_PRIORITY_BITS - 1)))
+#define VG_OBJECT_PRIORITY_DEFAULT (0)
+#define VG_OBJECT_PRIORITY_MAX ((1 << (VG_OBJECT_PRIORITY_BITS - 1)) - 1)
 
 struct object_policy
 {
@@ -216,93 +216,93 @@ struct object_policy
 	 eviction.  When a memory object is to be evicted, we select
 	 the object with the lowest priority (higher value = lower
 	 priority).  */
-      int8_t priority : OBJECT_PRIORITY_BITS;
+      int8_t priority : VG_OBJECT_PRIORITY_BITS;
     };
     uint8_t raw;
   };
 };
 
-#define OBJECT_POLICY_INIT { { raw: 0 } }
-#define OBJECT_POLICY(__op_discardable, __op_priority) \
+#define VG_OBJECT_POLICY_INIT { { raw: 0 } }
+#define VG_OBJECT_POLICY(__op_discardable, __op_priority) \
   (struct object_policy) { { { (__op_discardable), (__op_priority) } } }
 /* The default object policy: not discardable, managed by LRU.  */
-#define OBJECT_POLICY_VOID \
-  OBJECT_POLICY (false,  OBJECT_PRIORITY_DEFAULT)
-/* Synonym for OBJECT_POLICY_VOID.  */
-#define OBJECT_POLICY_DEFAULT OBJECT_POLICY_VOID
+#define VG_OBJECT_POLICY_VOID \
+  VG_OBJECT_POLICY (false,  VG_OBJECT_PRIORITY_DEFAULT)
+/* Synonym for VG_OBJECT_POLICY_VOID.  */
+#define VG_OBJECT_POLICY_DEFAULT VG_OBJECT_POLICY_VOID
 
 /* Capability properties.  */
 
-struct cap_properties
+struct vg_cap_properties
 {
   struct object_policy policy;
-  struct cap_addr_trans addr_trans;
+  struct vg_cap_addr_trans addr_trans;
 };
 
-#define CAP_PROPERTIES_INIT \
-  { OBJECT_POLICY_INIT, CAP_ADDR_TRANS_INIT }
-#define CAP_PROPERTIES(__op_object_policy, __op_addr_trans) \
-  (struct cap_properties) { __op_object_policy, __op_addr_trans }
-#define CAP_PROPERTIES_VOID \
-  CAP_PROPERTIES (OBJECT_POLICY_INIT, CAP_ADDR_TRANS_INIT)
-#define CAP_PROPERTIES_DEFAULT CAP_PROPERTIES_VOID
+#define VG_CAP_PROPERTIES_INIT \
+  { VG_OBJECT_POLICY_INIT, VG_CAP_ADDR_TRANS_INIT }
+#define VG_CAP_PROPERTIES(__op_object_policy, __op_addr_trans) \
+  (struct vg_cap_properties) { __op_object_policy, __op_addr_trans }
+#define VG_CAP_PROPERTIES_VOID \
+  VG_CAP_PROPERTIES (VG_OBJECT_POLICY_INIT, VG_CAP_ADDR_TRANS_INIT)
+#define VG_CAP_PROPERTIES_DEFAULT VG_CAP_PROPERTIES_VOID
 
 /* Capability representation.  */
 
 #ifdef RM_INTERN
 /* An OID corresponds to a page on a volume.  Only the least 54 bits
    are significant.  */
-typedef uint64_t oid_t;
-#define OID_FMT "0x%llx"
-#define OID_PRINTF(__op_oid) ((oid_t) (__op_oid))
+typedef uint64_t vg_oid_t;
+#define VG_OID_FMT "0x%llx"
+#define VG_OID_PRINTF(__op_oid) ((vg_oid_t) (__op_oid))
 #endif
 
-#define CAP_VERSION_BITS 20
-#define CAP_TYPE_BITS 6
+#define VG_CAP_VERSION_BITS 20
+#define VG_CAP_TYPE_BITS 6
 
-struct cap
+struct vg_cap
 {
 #ifdef RM_INTERN
   /* For a description of how versioning works, refer to the comment
      titled "Object versioning" in object.h.  */
-  uint32_t version : CAP_VERSION_BITS;
+  uint32_t version : VG_CAP_VERSION_BITS;
   /* Whether the capability is weak.  */
   uint32_t weak_p : 1;
 
   /* Whether the designated object may be discarded.  */
   uint32_t discardable : 1;
   /* The designated object's priority.  */
-  int32_t priority : OBJECT_PRIORITY_BITS;
+  int32_t priority : VG_OBJECT_PRIORITY_BITS;
 
-  struct cap_addr_trans addr_trans;
+  struct vg_cap_addr_trans addr_trans;
 
-  uint64_t type : CAP_TYPE_BITS;
+  uint64_t type : VG_CAP_TYPE_BITS;
 
   /* If the capability designates an object, the object id.  */
-  uint64_t oid : 64 - CAP_TYPE_BITS;
+  uint64_t oid : 64 - VG_CAP_TYPE_BITS;
 #else
   /* The shadow object (only for cappages and folios).  */
   struct object *shadow;
 
   uint32_t discardable : 1;
-  int32_t priority : OBJECT_PRIORITY_BITS;
+  int32_t priority : VG_OBJECT_PRIORITY_BITS;
 
-  uint32_t type : CAP_TYPE_BITS;
+  uint32_t type : VG_CAP_TYPE_BITS;
 
-  uint32_t pad0 : 32 - 1 - OBJECT_PRIORITY_BITS - CAP_TYPE_BITS;
+  uint32_t pad0 : 32 - 1 - VG_OBJECT_PRIORITY_BITS - VG_CAP_TYPE_BITS;
 
   /* This capability's address description.  */
-  struct cap_addr_trans addr_trans;
+  struct vg_cap_addr_trans addr_trans;
 #endif
 };
 
-#define CAP_VOID ((struct cap) { .type = cap_void })
+#define VG_CAP_VOID ((struct vg_cap) { .type = vg_cap_void })
 
 /* Return CAP's policy.  */
-#define CAP_POLICY_GET(__cpg_cap)				\
-  OBJECT_POLICY ((__cpg_cap).discardable, (__cpg_cap).priority)
+#define VG_CAP_POLICY_GET(__cpg_cap)				\
+  VG_OBJECT_POLICY ((__cpg_cap).discardable, (__cpg_cap).priority)
 /* Set CAP's policy to POLICY.  */
-#define CAP_POLICY_SET(__cps_cap, __cps_policy)			\
+#define VG_CAP_POLICY_SET(__cps_cap, __cps_policy)			\
   do								\
     {								\
       (__cps_cap)->discardable = (__cps_policy).discardable;	\
@@ -311,14 +311,14 @@ struct cap
   while (0)
 
 /* Return CAP's properties.  */
-#define CAP_PROPERTIES_GET(__cpg_cap)				\
-  CAP_PROPERTIES (CAP_POLICY_GET (__cpg_cap),			\
+#define VG_CAP_PROPERTIES_GET(__cpg_cap)				\
+  VG_CAP_PROPERTIES (VG_CAP_POLICY_GET (__cpg_cap),			\
 		  (__cpg_cap).addr_trans)
 /* Set *CAP's properties to PROPERTIES.  */
-#define CAP_PROPERTIES_SET(__cps_cap, __cps_properties)			\
+#define VG_CAP_PROPERTIES_SET(__cps_cap, __cps_properties)			\
   do									\
     {									\
-      CAP_POLICY_SET (__cps_cap, (__cps_properties).policy);		\
+      VG_CAP_POLICY_SET (__cps_cap, (__cps_properties).policy);		\
       (__cps_cap)->addr_trans = (__cps_properties).addr_trans;		\
     }									\
   while (0)
@@ -326,55 +326,55 @@ struct cap
 /* Convenience macros for printing capabilities.  */
 
 #ifdef RM_INTERN
-#define CAP_FMT "{ " OID_FMT ".%d:%s %llx/%d; %d/%d }"
-#define CAP_PRINTF(cap) \
-  OID_PRINTF ((cap)->oid), (cap)->version, cap_type_string ((cap)->type), \
-  CAP_GUARD ((cap)), CAP_GUARD_BITS ((cap)), \
-  CAP_SUBPAGE ((cap)), CAP_SUBPAGES ((cap))
+#define VG_CAP_FMT "{ " VG_OID_FMT ".%d:%s %llx/%d; %d/%d }"
+#define VG_CAP_PRINTF(vg_cap) \
+  VG_OID_PRINTF ((vg_cap)->oid), (vg_cap)->version, vg_cap_type_string ((vg_cap)->type), \
+  VG_CAP_GUARD ((vg_cap)), VG_CAP_GUARD_BITS ((vg_cap)), \
+  VG_CAP_SUBPAGE ((vg_cap)), VG_CAP_SUBPAGES ((vg_cap))
 #else
-#define CAP_FMT "{ %s %llx/%d; %d/%d }"
-#define CAP_PRINTF(cap) \
-  cap_type_string ((cap)->type), \
-  CAP_GUARD ((cap)), CAP_GUARD_BITS ((cap)), \
-  CAP_SUBPAGE ((cap)), CAP_SUBPAGES ((cap))
+#define VG_CAP_FMT "{ %s %llx/%d; %d/%d }"
+#define VG_CAP_PRINTF(vg_cap) \
+  vg_cap_type_string ((vg_cap)->type), \
+  VG_CAP_GUARD ((vg_cap)), VG_CAP_GUARD_BITS ((vg_cap)), \
+  VG_CAP_SUBPAGE ((vg_cap)), VG_CAP_SUBPAGES ((vg_cap))
 #endif
 
 /* Accessors corresponding to the CAP_ADDR_TRANS macros.  */
-#define CAP_SUBPAGES_LOG2(cap_) \
-  CAP_ADDR_TRANS_SUBPAGES_LOG2((cap_)->addr_trans)
-#define CAP_SUBPAGES(cap_) CAP_ADDR_TRANS_SUBPAGES ((cap_)->addr_trans)
-#define CAP_SUBPAGE(cap_) CAP_ADDR_TRANS_SUBPAGE((cap_)->addr_trans)
-#define CAP_SUBPAGE_SIZE_LOG2(cap_) \
-  CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2 ((cap_)->addr_trans)
-#define CAP_SUBPAGE_SIZE(cap_) \
-  CAP_ADDR_TRANS_SUBPAGE_SIZE ((cap_)->addr_trans)
-#define CAP_SUBPAGE_OFFSET(cap_) \
-  CAP_ADDR_TRANS_SUBPAGE_OFFSET((cap_)->addr_trans)
-#define CAP_GUARD_BITS(cap_) CAP_ADDR_TRANS_GUARD_BITS((cap_)->addr_trans)
-#define CAP_GUARD(cap_) CAP_ADDR_TRANS_GUARD((cap_)->addr_trans)
+#define VG_CAP_SUBPAGES_LOG2(cap_) \
+  VG_CAP_ADDR_TRANS_SUBPAGES_LOG2((cap_)->addr_trans)
+#define VG_CAP_SUBPAGES(cap_) VG_CAP_ADDR_TRANS_SUBPAGES ((cap_)->addr_trans)
+#define VG_CAP_SUBPAGE(cap_) VG_CAP_ADDR_TRANS_SUBPAGE((cap_)->addr_trans)
+#define VG_CAP_SUBPAGE_SIZE_LOG2(cap_) \
+  VG_CAP_ADDR_TRANS_SUBPAGE_SIZE_LOG2 ((cap_)->addr_trans)
+#define VG_CAP_SUBPAGE_SIZE(cap_) \
+  VG_CAP_ADDR_TRANS_SUBPAGE_SIZE ((cap_)->addr_trans)
+#define VG_CAP_SUBPAGE_OFFSET(cap_) \
+  VG_CAP_ADDR_TRANS_SUBPAGE_OFFSET((cap_)->addr_trans)
+#define VG_CAP_GUARD_BITS(cap_) VG_CAP_ADDR_TRANS_GUARD_BITS((cap_)->addr_trans)
+#define VG_CAP_GUARD(cap_) VG_CAP_ADDR_TRANS_GUARD((cap_)->addr_trans)
 
 /* NB: Only updates the shadow guard; NOT the capability.  If the
-   latter behavior is desired, use cap_copy_x instead.  */
-#define CAP_SET_GUARD_SUBPAGE(cap_, guard_, gdepth_, subpage_, subpages_) \
+   latter behavior is desired, use vg_cap_copy_x instead.  */
+#define VG_CAP_SET_GUARD_SUBPAGE(cap_, guard_, gdepth_, subpage_, subpages_) \
   ({ bool r_ = true; \
      if ((subpages_) != 1 \
-	 && ! ((cap_)->type == cap_cappage || (cap_)->type == cap_rcappage)) \
+	 && ! ((cap_)->type == vg_cap_cappage || (cap_)->type == vg_cap_rcappage)) \
        { \
          debug (1, "Subpages are only allow for cappages."); \
          r_ = false; \
        } \
      if (r_) \
-       r_ = CAP_ADDR_TRANS_SET_GUARD_SUBPAGE (&(cap_)->addr_trans, \
+       r_ = VG_CAP_ADDR_TRANS_SET_GUARD_SUBPAGE (&(cap_)->addr_trans, \
 					      (guard_), (gdepth_), \
 					      (subpage_), (subpages_)); \
      r_; \
   })
 
-#define CAP_SET_GUARD(cap_, guard_, gdepth_) \
-  CAP_SET_GUARD_SUBPAGE ((cap_), (guard_), (gdepth_), \
-			 CAP_SUBPAGE ((cap_)), CAP_SUBPAGES ((cap_)))
-#define CAP_SET_SUBPAGE(cap_, subpage_, subpages_) \
-  CAP_SET_GUARD_SUBPAGE ((cap_), CAP_GUARD (cap_), CAP_GUARD_BITS (cap_), \
+#define VG_CAP_SET_GUARD(cap_, guard_, gdepth_) \
+  VG_CAP_SET_GUARD_SUBPAGE ((cap_), (guard_), (gdepth_), \
+			 VG_CAP_SUBPAGE ((cap_)), VG_CAP_SUBPAGES ((cap_)))
+#define VG_CAP_SET_SUBPAGE(cap_, subpage_, subpages_) \
+  VG_CAP_SET_GUARD_SUBPAGE ((cap_), VG_CAP_GUARD (cap_), VG_CAP_GUARD_BITS (cap_), \
 			 (subpage_), (subpages_))
 
 /* Capability-related methods.  */
@@ -401,65 +401,65 @@ enum
 {
   /* Use subpage in CAP_ADDR_TRANS (must be a subset of subpage in
      SOURCE).  */
-  CAP_COPY_COPY_ADDR_TRANS_SUBPAGE = 1 << 0,
+  VG_CAP_COPY_COPY_ADDR_TRANS_SUBPAGE = 1 << 0,
   /* Use guard in TARGET, not the guard in CAP_ADDR_TRANS.  */
-  CAP_COPY_COPY_ADDR_TRANS_GUARD = 1 << 1,
+  VG_CAP_COPY_COPY_ADDR_TRANS_GUARD = 1 << 1,
   /* Use guard in SOURCE.  */
-  CAP_COPY_COPY_SOURCE_GUARD = 1 << 2,
+  VG_CAP_COPY_COPY_SOURCE_GUARD = 1 << 2,
 
   /* When copying the capability copies a weakened reference.  */
-  CAP_COPY_WEAKEN = 1 << 3,
+  VG_CAP_COPY_WEAKEN = 1 << 3,
 
   /* Set the discardable bit on the capability.  */
-  CAP_COPY_DISCARDABLE_SET = 1 << 4,
+  VG_CAP_COPY_DISCARDABLE_SET = 1 << 4,
 
   /* Set the priority of the object.  */
-  CAP_COPY_PRIORITY_SET = 1 << 5,
+  VG_CAP_COPY_PRIORITY_SET = 1 << 5,
 };
 
-/* Copy the capability in capability slot SOURCE to the slot at ADDR
-   in the object OBJECT.  If OBJECT is ADDR_VOID, then the calling
+/* Copy the capability in capability slot SOURCE to the slot at VG_ADDR
+   in the object OBJECT.  If OBJECT is VG_ADDR_VOID, then the calling
    thread's address space root is used.
 
    By default, preserves SOURCE's subpage specification and copies
    TARGET's guard and policy.
 
    If CAP_COPY_COPY_SUBPAGE is set, then uses the subpage
-   specification in CAP_PROPERTIES.  If CAP_COPY_COPY_ADDR_TRANS_GUARD
-   is set, uses the guard description in CAP_PROPERTIES.
+   specification in VG_CAP_PROPERTIES.  If VG_CAP_COPY_COPY_ADDR_TRANS_GUARD
+   is set, uses the guard description in VG_CAP_PROPERTIES.
 
-   If CAP_COPY_COPY_SOURCE_GUARD is set, uses the guard description in
+   If VG_CAP_COPY_COPY_SOURCE_GUARD is set, uses the guard description in
    source.  Otherwise, preserves the guard in TARGET.
 
-   If CAP_COPY_WEAKEN is set, saves a weakened version of SOURCE
-   (e.g., if SOURCE's type is cap_page, a cap_rpage is saved).
+   If VG_CAP_COPY_WEAKEN is set, saves a weakened version of SOURCE
+   (e.g., if SOURCE's type is vg_cap_page, a vg_cap_rpage is saved).
 
-   If CAP_COPY_DISCARDABLE_SET is set, then sets the discardable bit
+   If VG_CAP_COPY_DISCARDABLE_SET is set, then sets the discardable bit
    based on the value in PROPERTIES.  Otherwise, copies SOURCE's
    value.
 
-   If CAP_COPY_PRIORITY_SET is set, then sets the priority based on
+   If VG_CAP_COPY_PRIORITY_SET is set, then sets the priority based on
    the value in properties.  Otherwise, copies SOURCE's value.  */
 RPC(cap_copy, 5, 0, 0,
-    /* cap_t activity, cap_t object, */ addr_t, addr,
-    cap_t, source_object, addr_t, source_addr,
-    uintptr_t, flags, struct cap_properties, properties)
+    /* cap_t activity, cap_t object, */ vg_addr_t, addr,
+    cap_t, source_object, vg_addr_t, source_addr,
+    uintptr_t, flags, struct vg_cap_properties, properties)
 
-/* Overwrite the capability slot at ADDR in the object OBJECT with a
+/* Overwrite the capability slot at VG_ADDR in the object OBJECT with a
    void capability.  */
 RPC(cap_rubout, 1, 0, 0,
-    /* cap_t activity, cap_t object, */ addr_t, addr)
+    /* cap_t activity, cap_t object, */ vg_addr_t, addr)
 
-/* Returns the public bits of the capability at address ADDR in OBJECT
-   in TYPE and CAP_PROPERTIES.  */
+/* Returns the public bits of the capability at address VG_ADDR in OBJECT
+   in TYPE and VG_CAP_PROPERTIES.  */
 RPC(cap_read, 1, 2, 0,
-    /* cap_t activity, cap_t object, */ addr_t, addr,
+    /* cap_t activity, cap_t object, */ vg_addr_t, addr,
     /* Out: */
-    uintptr_t, type, struct cap_properties, properties)
+    uintptr_t, type, struct vg_cap_properties, properties)
 
-/* Clear the discarded bit of the object at ADDR in object OBJECT.  */
+/* Clear the discarded bit of the object at VG_ADDR in object OBJECT.  */
 RPC(object_discarded_clear, 1, 0, 0,
-    /* cap_t activity, cap_t object, */ addr_t, addr)
+    /* cap_t activity, cap_t object, */ vg_addr_t, addr)
 
 /* If the object designated by OBJECT is in memory, discard it.
    OBJECT must have write authority.  This does not set the object's
@@ -480,7 +480,7 @@ enum
    whether the object has been modified since the last time it the
    dirty bit was cleared.)  */
 RPC (object_status, 1, 1, 0,
-     /* addr_t activity, addr_t object, */ bool, clear,
+     /* vg_addr_t activity, vg_addr_t object, */ bool, clear,
      uintptr_t, status)
 
 /* Returns the object's return code in RETURN_CODE on object
@@ -510,12 +510,12 @@ RPC (object_name, 1, 0, 0,
 /* The number of capabilities per page.  */
 enum
   {
-    CAPPAGE_SLOTS = PAGESIZE / 16,
+    VG_CAPPAGE_SLOTS = PAGESIZE / 16,
   };
 /* The log2 of the number of capabilities per page.  */
 enum
   {
-    CAPPAGE_SLOTS_LOG2 = PAGESIZE_LOG2 - 4,
+    VG_CAPPAGE_SLOTS_LOG2 = PAGESIZE_LOG2 - 4,
   };
 
 struct object
@@ -523,69 +523,69 @@ struct object
   union
   {
     char data[PAGESIZE];
-    struct cap caps[CAPPAGE_SLOTS];
+    struct vg_cap caps[VG_CAPPAGE_SLOTS];
   };
 };
 
 #ifdef RM_INTERN
 typedef struct activity *activity_t;
 #else
-typedef addr_t activity_t;
+typedef vg_addr_t activity_t;
 #endif
 
 #ifndef RM_INTERN
-/* Return the address of cap CAP's shadow object.  */
+/* Return the address of vg_cap CAP's shadow object.  */
 static inline void *
-cap_get_shadow (const struct cap *cap)
+vg_cap_get_shadow (const struct vg_cap *vg_cap)
 {
-  return cap->shadow;
+  return vg_cap->shadow;
 }
 
 /* Set CAP's shadow object to SHADOW.  */
 static inline void
-cap_set_shadow (struct cap *cap, void *shadow)
+vg_cap_set_shadow (struct vg_cap *vg_cap, void *shadow)
 {
-  cap->shadow = shadow;
+  vg_cap->shadow = shadow;
 }
 #endif
 
-/* Given cap CAP, return the corresponding object, or NULL, if there
+/* Given vg_cap CAP, return the corresponding object, or NULL, if there
    is none.  */
 #ifdef RM_INTERN
-extern struct object *cap_to_object (activity_t activity, struct cap *cap);
+extern struct object *vg_cap_to_object (activity_t activity, struct vg_cap *vg_cap);
 #else
 static inline struct object *
-cap_to_object (activity_t activity, struct cap *cap)
+vg_cap_to_object (activity_t activity, struct vg_cap *vg_cap)
 {
-  return cap_get_shadow (cap);
+  return vg_cap_get_shadow (vg_cap);
 }
 #endif
 
-/* Wrapper for the cap_copy method.  Also updates shadow
+/* Wrapper for the vg_cap_copy method.  Also updates shadow
    capabilities.  */
 static inline bool
-cap_copy_x (activity_t activity,
-	    addr_t target_address_space, struct cap *target, addr_t target_addr,
-	    addr_t source_address_space, struct cap source, addr_t source_addr,
-	    int flags, struct cap_properties properties)
+vg_cap_copy_x (activity_t activity,
+	    vg_addr_t target_address_space, struct vg_cap *target, vg_addr_t target_addr,
+	    vg_addr_t source_address_space, struct vg_cap source, vg_addr_t source_addr,
+	    int flags, struct vg_cap_properties properties)
 {
   /* By default, we preserve SOURCE's subpage specification.  */
-  int subpage = CAP_SUBPAGE (&source);
-  int subpages = CAP_SUBPAGES (&source);
+  int subpage = VG_CAP_SUBPAGE (&source);
+  int subpages = VG_CAP_SUBPAGES (&source);
 
-  if ((flags & CAP_COPY_COPY_ADDR_TRANS_SUBPAGE))
+  if ((flags & VG_CAP_COPY_COPY_ADDR_TRANS_SUBPAGE))
     /* Copy the subpage descriptor from PROPERTIES.ADDR_TRANS.  */
     {
-      if (CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans) != 1
-	  && (source.type != cap_cappage
-	      && source.type != cap_rcappage))
+      if (VG_CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans) != 1
+	  && (source.type != vg_cap_cappage
+	      && source.type != vg_cap_rcappage))
 	/* A subpage descriptor is only valid for
 	   cappages.  */
 	{
 	  debug (1, "subpages (%d) specified for non-cappage "
-		 "cap " CAP_FMT,
-		 CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans),
-		 CAP_PRINTF (&source));
+		 "vg_cap " VG_CAP_FMT,
+		 VG_CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans),
+		 VG_CAP_PRINTF (&source));
 	  return false;
 	}
 
@@ -593,48 +593,48 @@ cap_copy_x (activity_t activity,
 	  (/* Start of PROPERTIES.ADDR_TRANS must be at or after start of
 	      SOURCE.  */
 	   subpage * (256 / subpages)
-	   <= (CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans) *
-	       (256 / CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans)))
+	   <= (VG_CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans) *
+	       (256 / VG_CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans)))
 	   /* End of PROPERTIES.ADDR_TRANS must be before or at end of
 	      SOURCE.  */
-	   && (((CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans) + 1) *
-		(256 / CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans)))
+	   && (((VG_CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans) + 1) *
+		(256 / VG_CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans)))
 	       <= (subpage + 1) * (256 / subpages))))
 	/* The subpage descriptor does not narrow the
 	   rights.  */
 	{
 	  debug (1, "specified subpage (%d/%d) not a subset "
-		 " of source " CAP_FMT,
-		 CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans),
-		 CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans),
-		 CAP_PRINTF (&source));
+		 " of source " VG_CAP_FMT,
+		 VG_CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans),
+		 VG_CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans),
+		 VG_CAP_PRINTF (&source));
 	  return false;
 	}
 
-      subpage = CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans);
-      subpages = CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans);
+      subpage = VG_CAP_ADDR_TRANS_SUBPAGE (properties.addr_trans);
+      subpages = VG_CAP_ADDR_TRANS_SUBPAGES (properties.addr_trans);
     }
 
   /* By default, we preserve the guard in TARGET.  */
-  int guard = CAP_GUARD (target);
-  int gbits = CAP_GUARD_BITS (target);
+  int guard = VG_CAP_GUARD (target);
+  int gbits = VG_CAP_GUARD_BITS (target);
 
-  if ((flags & CAP_COPY_COPY_ADDR_TRANS_GUARD))
+  if ((flags & VG_CAP_COPY_COPY_ADDR_TRANS_GUARD))
     /* Copy guard from PROPERTIES.ADDR_TRANS.  */
     {
-      guard = CAP_ADDR_TRANS_GUARD (properties.addr_trans);
-      gbits = CAP_ADDR_TRANS_GUARD_BITS (properties.addr_trans);
+      guard = VG_CAP_ADDR_TRANS_GUARD (properties.addr_trans);
+      gbits = VG_CAP_ADDR_TRANS_GUARD_BITS (properties.addr_trans);
     }
-  else if ((flags & CAP_COPY_COPY_SOURCE_GUARD))
+  else if ((flags & VG_CAP_COPY_COPY_SOURCE_GUARD))
     /* Copy guard from SOURCE.  */
     {
-      guard = CAP_GUARD (&source);
-      gbits = CAP_GUARD_BITS (&source);
+      guard = VG_CAP_GUARD (&source);
+      gbits = VG_CAP_GUARD_BITS (&source);
     }
 
   int type = source.type;
-  if ((flags & CAP_COPY_WEAKEN))
-    type = cap_type_weaken (type);
+  if ((flags & VG_CAP_COPY_WEAKEN))
+    type = vg_cap_type_weaken (type);
 
 #ifdef RM_INTERN
   /* Changing a capability can change how addresses are translated.
@@ -652,19 +652,19 @@ cap_copy_x (activity_t activity,
       changes_translation = true;
     }
 
-  if (subpage != CAP_SUBPAGE (target) || subpages != CAP_SUBPAGES (target))
+  if (subpage != VG_CAP_SUBPAGE (target) || subpages != VG_CAP_SUBPAGES (target))
     {
       debug (5, "Subpage specification differs %d/%d -> %d/%d.",
-	     subpage, subpages, CAP_SUBPAGE (target), CAP_SUBPAGES (target));
+	     subpage, subpages, VG_CAP_SUBPAGE (target), VG_CAP_SUBPAGES (target));
       changes_translation = true;
     }
 
-  if (guard != CAP_GUARD (target)
-      || gbits != CAP_GUARD_BITS (target))
+  if (guard != VG_CAP_GUARD (target)
+      || gbits != VG_CAP_GUARD_BITS (target))
     {
       debug (5, "Guard changed invalidating translation "
 	     "0x%x/%d -> %llx/%d",
-	     guard, gbits, CAP_GUARD (target), CAP_GUARD_BITS (target));
+	     guard, gbits, VG_CAP_GUARD (target), VG_CAP_GUARD_BITS (target));
       changes_translation = true;
     }
 
@@ -676,23 +676,23 @@ cap_copy_x (activity_t activity,
 
   if (changes_translation)
     {
-      extern void cap_shootdown (struct activity *activity, struct cap *cap);
+      extern void cap_shootdown (struct activity *activity, struct vg_cap *vg_cap);
 
-      debug (5, "Translation changed: " CAP_FMT " -> " CAP_FMT,
-	     CAP_PRINTF (target), CAP_PRINTF (&source));
+      debug (5, "Translation changed: " VG_CAP_FMT " -> " VG_CAP_FMT,
+	     VG_CAP_PRINTF (target), VG_CAP_PRINTF (&source));
 
       cap_shootdown (activity, target);
     }
 #endif
 
-  if (! CAP_ADDR_TRANS_SET_GUARD_SUBPAGE (&properties.addr_trans,
+  if (! VG_CAP_ADDR_TRANS_SET_GUARD_SUBPAGE (&properties.addr_trans,
 					  guard, gbits,
 					  subpage, subpages))
     return false;
 
 #ifndef RM_INTERN
-  assert (! ADDR_IS_VOID (target_addr));
-  assert (! ADDR_IS_VOID (source_addr));
+  assert (! VG_ADDR_IS_VOID (target_addr));
+  assert (! VG_ADDR_IS_VOID (source_addr));
 
   error_t err = rm_cap_copy (activity, target_address_space, target_addr,
 			     source_address_space, source_addr,
@@ -704,10 +704,10 @@ cap_copy_x (activity_t activity,
   target->addr_trans = properties.addr_trans;
   target->type = type;
 
-  if ((flags & CAP_COPY_DISCARDABLE_SET))
+  if ((flags & VG_CAP_COPY_DISCARDABLE_SET))
     target->discardable = properties.policy.discardable;
 
-  if ((flags & CAP_COPY_PRIORITY_SET))
+  if ((flags & VG_CAP_COPY_PRIORITY_SET))
     target->priority = properties.policy.priority;
 
   return true;
@@ -717,14 +717,14 @@ cap_copy_x (activity_t activity,
    SOURCE's subpage specification and TARGET's guard.  Copies SOURCE's
    policy.  */
 static inline bool
-cap_copy (activity_t activity,
-	  addr_t target_as, struct cap *target, addr_t target_addr,
-	  addr_t source_as, struct cap source, addr_t source_addr)
+vg_cap_copy (activity_t activity,
+	  vg_addr_t target_as, struct vg_cap *target, vg_addr_t target_addr,
+	  vg_addr_t source_as, struct vg_cap source, vg_addr_t source_addr)
 {
-  return cap_copy_x (activity, target_as, target, target_addr,
+  return vg_cap_copy_x (activity, target_as, target, target_addr,
 		     source_as, source, source_addr,
-		     CAP_COPY_DISCARDABLE_SET | CAP_COPY_PRIORITY_SET,
-		     CAP_PROPERTIES_GET (source));
+		     VG_CAP_COPY_DISCARDABLE_SET | VG_CAP_COPY_PRIORITY_SET,
+		     VG_CAP_PROPERTIES_GET (source));
 }
 
 #endif
diff --git a/libviengoos/viengoos/folio.h b/libviengoos/viengoos/folio.h
index 4172e5d..d135e02 100644
--- a/libviengoos/viengoos/folio.h
+++ b/libviengoos/viengoos/folio.h
@@ -29,27 +29,27 @@
 /* Number of user objects per folio.  */
 enum
   {
-    FOLIO_OBJECTS = 128,
+    VG_FOLIO_OBJECTS = 128,
   };
 enum
   {
-    FOLIO_OBJECTS_LOG2 = 7,
+    VG_FOLIO_OBJECTS_LOG2 = 7,
   };
 
 /* User settable folio policy.  */
 
 /* The range of valid folio priorities.  A lower numerical value
    corresponds to a lower priority.  */
-#define FOLIO_PRIORITY_BITS 15
-#define FOLIO_PRIORITY_MIN (-(1 << (FOLIO_PRIORITY_BITS - 1)))
-#define FOLIO_PRIORITY_LRU (0)
-#define FOLIO_PRIORITY_MAX ((1 << (FOLIO_PRIORITY_BITS - 1)) - 1)
+#define VG_FOLIO_PRIORITY_BITS 15
+#define VG_FOLIO_PRIORITY_MIN (-(1 << (VG_FOLIO_PRIORITY_BITS - 1)))
+#define VG_FOLIO_PRIORITY_LRU (0)
+#define VG_FOLIO_PRIORITY_MAX ((1 << (VG_FOLIO_PRIORITY_BITS - 1)) - 1)
 
 /* The folio group range.  */
-#define FOLIO_GROUP_BITS 15
-#define FOLIO_GROUP_NONE 0
-#define FOLIO_GROUP_MIN 0
-#define FOLIO_GROUP_MAX ((1 << FOLIO_BITS) - 1)
+#define VG_FOLIO_GROUP_BITS 15
+#define VG_FOLIO_GROUP_NONE 0
+#define VG_FOLIO_GROUP_MIN 0
+#define VG_FOLIO_GROUP_MAX ((1 << FOLIO_BITS) - 1)
 
 struct folio_policy
 {
@@ -68,26 +68,26 @@ struct folio_policy
 
       /* Folios can belong to a group.  When one folio is discarded,
 	 all folios in that group are discarded, unless GROUP is
-	 FOLIO_GROUP_NONE.  */
-      uint32_t group : FOLIO_GROUP_BITS;
+	 VG_FOLIO_GROUP_NONE.  */
+      uint32_t group : VG_FOLIO_GROUP_BITS;
 
       /* By default, the system tries to discard folios according to
 	 an LRU policy.  This can be overridden using this field.  In
 	 this case, folios from the lowest priority group are
 	 discarded.  */
-      int32_t priority : FOLIO_PRIORITY_BITS;
+      int32_t priority : VG_FOLIO_PRIORITY_BITS;
     };
     uint32_t raw;
   };
 };
 
-#define FOLIO_POLICY_INIT { { raw: 0 } }
-#define FOLIO_POLICY_VOID (struct folio_policy) FOLIO_POLICY_INIT
+#define VG_FOLIO_POLICY_INIT { { raw: 0 } }
+#define VG_FOLIO_POLICY_VOID (struct folio_policy) VG_FOLIO_POLICY_INIT
 /* The default policy is not discardable.  */
-#define FOLIO_POLICY_DEFAULT FOLIO_POLICY_VOID
+#define VG_FOLIO_POLICY_DEFAULT VG_FOLIO_POLICY_VOID
 
 /* The format of the first page of a folio.  This page is followed (on
-   disk) by FOLIO_OBJECTS pages.  */
+   disk) by VG_FOLIO_OBJECTS pages.  */
 struct folio
 {
 #ifdef RM_INTERN
@@ -95,9 +95,9 @@ struct folio
      to exactly one activity.  To track what folios belong to a
      particular activity, each folio is attached to a doubly-linked
      list originating at its owner activity.  */
-  struct cap activity;
-  struct cap next;
-  struct cap prev;
+  struct vg_cap activity;
+  struct vg_cap next;
+  struct vg_cap prev;
 
   /* The storage policy.  */
   struct folio_policy policy;
@@ -105,7 +105,7 @@ struct folio
   struct
   {
     /* Each object in the folio Disk version of each object.  */
-    uint32_t version : CAP_VERSION_BITS;
+    uint32_t version : VG_CAP_VERSION_BITS;
 
     /* Whether a page has any content (i.e., if it is not
        uninitialized).  */
@@ -113,64 +113,65 @@ struct folio
 
     /* The object's memory policy when accessed via the folio.  */
     uint32_t discardable : 1;
-    int32_t priority : OBJECT_PRIORITY_BITS;
-  } misc[1 + FOLIO_OBJECTS];
+    int32_t priority : VG_OBJECT_PRIORITY_BITS;
+  } misc[1 + VG_FOLIO_OBJECTS];
 
   /* The type.  */
-  uint8_t types[FOLIO_OBJECTS];
+  uint8_t types[VG_FOLIO_OBJECTS];
 
   /* Bit array indicating whether the an object has a non-empty wait
      queue.  */
-  uint8_t wait_queues_p[(1 + FOLIO_OBJECTS + (8 - 1)) / 8];
+  uint8_t wait_queues_p[(1 + VG_FOLIO_OBJECTS + (8 - 1)) / 8];
 
-  uint8_t discarded[(FOLIO_OBJECTS + (8 - 1)) / 8];
+  uint8_t discarded[(VG_FOLIO_OBJECTS + (8 - 1)) / 8];
 
   /* User reference and dirty bits.  Optionally reset on read.  Set
      respectively when an object is referenced or modified.  Flushing
      the object to disk does not clear this.  */
-  uint8_t dirty[(1 + FOLIO_OBJECTS + (8 - 1)) / 8];
-  uint8_t referenced[(1 + FOLIO_OBJECTS + (8 - 1)) / 8];
+  uint8_t dirty[(1 + VG_FOLIO_OBJECTS + (8 - 1)) / 8];
+  uint8_t referenced[(1 + VG_FOLIO_OBJECTS + (8 - 1)) / 8];
 
   /* Head of the list of objects waiting for some event on this
      object.  An element of this array is only valid if the
      corresponding element of WAIT_QUEUES_P is true.  The list is a
      circular list.  HEAD->PREV points to the tail.  TAIL->NEXT points
      to the OBJECT (NOT HEAD).  */
-  oid_t wait_queues[1 + FOLIO_OBJECTS];
+  vg_oid_t wait_queues[1 + VG_FOLIO_OBJECTS];
 
-  uint64_t checksums[1 + FOLIO_OBJECTS][2];
+  uint64_t checksums[1 + VG_FOLIO_OBJECTS][2];
 #else
   /* User-space folio.  */
-  struct cap objects[FOLIO_OBJECTS];
+  struct vg_cap objects[VG_FOLIO_OBJECTS];
 #endif
 };
 
 #ifdef RM_INTERN
-typedef struct folio *folio_t;
+typedef struct folio *vg_folio_t;
 #else
-typedef addr_t folio_t;
+typedef vg_addr_t vg_folio_t;
 #endif
 
-/* OBJECT is from -1 to FOLIO_OBJECTS.  */
-static inline enum cap_type
-folio_object_type (struct folio *folio, int object)
+/* OBJECT is from -1 to VG_FOLIO_OBJECTS.  */
+static inline enum vg_cap_type
+vg_folio_object_type (struct folio *folio, int object)
 {
 #ifdef RM_INTERN
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   if (object == -1)
-    return cap_folio;
+    return vg_cap_folio;
   return folio->types[object];
 #else
-  assert (object >= 0 && object < FOLIO_OBJECTS);
+  assert (object >= 0 && object < VG_FOLIO_OBJECTS);
   return folio->objects[object].type;
 #endif
 }
 
 static inline void
-folio_object_type_set (struct folio *folio, int object, enum cap_type type)
+vg_folio_object_type_set (struct folio *folio, int object,
+			  enum vg_cap_type type)
 {
-  assert (object >= 0 && object < FOLIO_OBJECTS);
+  assert (object >= 0 && object < VG_FOLIO_OBJECTS);
 
 #ifdef RM_INTERN
   folio->types[object] = type;
@@ -180,17 +181,17 @@ folio_object_type_set (struct folio *folio, int object, enum cap_type type)
 }
 
 static inline struct object_policy
-folio_object_policy (struct folio *folio, int object)
+vg_folio_object_policy (struct folio *folio, int object)
 {
   struct object_policy policy;
 
 #ifdef RM_INTERN
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   policy.discardable = folio->misc[object + 1].discardable;
   policy.priority = folio->misc[object + 1].priority;
 #else
-  assert (object >= 0 && object < FOLIO_OBJECTS);
+  assert (object >= 0 && object < VG_FOLIO_OBJECTS);
 
   policy.discardable = folio->objects[object].discardable;
   policy.priority = folio->objects[object].priority;
@@ -200,16 +201,16 @@ folio_object_policy (struct folio *folio, int object)
 }
 
 static inline void
-folio_object_policy_set (struct folio *folio, int object,
-			 struct object_policy policy)
+vg_folio_object_policy_set (struct folio *folio, int object,
+			    struct object_policy policy)
 {
 #ifdef RM_INTERN
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   folio->misc[object + 1].discardable = policy.discardable;
   folio->misc[object + 1].priority = policy.priority;
 #else
-  assert (object >= 0 && object < FOLIO_OBJECTS);
+  assert (object >= 0 && object < VG_FOLIO_OBJECTS);
 
   folio->objects[object].discardable = policy.discardable;
   folio->objects[object].priority = policy.priority;
@@ -222,7 +223,7 @@ folio_object_policy_set (struct folio *folio, int object,
 static inline bool
 folio_object_wait_queue_p (struct folio *folio, int object)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   return bit_test (folio->wait_queues_p, object + 1);
 }
@@ -231,25 +232,25 @@ static inline void
 folio_object_wait_queue_p_set (struct folio *folio, int object,
 			       bool valid)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   bit_set_to (folio->wait_queues_p, sizeof (folio->wait_queues_p),
 	      object + 1, valid);
 }
 
-static inline oid_t
+static inline vg_oid_t
 folio_object_wait_queue (struct folio *folio, int object)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   return folio->wait_queues[object + 1];
 }
 
 static inline void
 folio_object_wait_queue_set (struct folio *folio, int object,
-			     oid_t head)
+			     vg_oid_t head)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   folio->wait_queues[object + 1] = head;
 }
@@ -257,7 +258,7 @@ folio_object_wait_queue_set (struct folio *folio, int object,
 static inline uint32_t
 folio_object_version (struct folio *folio, int object)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   return folio->misc[object + 1].version;
 }
@@ -266,7 +267,7 @@ static inline void
 folio_object_version_set (struct folio *folio, int object,
 			  uint32_t version)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   folio->misc[object + 1].version = version;
 }
@@ -274,7 +275,7 @@ folio_object_version_set (struct folio *folio, int object,
 static inline bool
 folio_object_content (struct folio *folio, int object)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   return folio->misc[object + 1].content;
 }
@@ -283,7 +284,7 @@ static inline void
 folio_object_content_set (struct folio *folio, int object,
 			  bool content)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   folio->misc[object + 1].content = content;
 }
@@ -291,7 +292,7 @@ folio_object_content_set (struct folio *folio, int object,
 static inline bool
 folio_object_discarded (struct folio *folio, int object)
 {
-  assert (object >= 0 && object < FOLIO_OBJECTS);
+  assert (object >= 0 && object < VG_FOLIO_OBJECTS);
 
   return bit_test (folio->discarded, object);
 }
@@ -299,7 +300,7 @@ folio_object_discarded (struct folio *folio, int object)
 static inline void
 folio_object_discarded_set (struct folio *folio, int object, bool valid)
 {
-  assert (object >= 0 && object < FOLIO_OBJECTS);
+  assert (object >= 0 && object < VG_FOLIO_OBJECTS);
 
   bit_set_to (folio->discarded, sizeof (folio->discarded),
 	      object, valid);
@@ -308,7 +309,7 @@ folio_object_discarded_set (struct folio *folio, int object, bool valid)
 static inline bool
 folio_object_referenced (struct folio *folio, int object)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   return bit_test (folio->referenced, object + 1);
 }
@@ -316,7 +317,7 @@ folio_object_referenced (struct folio *folio, int object)
 static inline void
 folio_object_referenced_set (struct folio *folio, int object, bool p)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   bit_set_to (folio->referenced, sizeof (folio->referenced), object + 1, p);
 }
@@ -324,7 +325,7 @@ folio_object_referenced_set (struct folio *folio, int object, bool p)
 static inline bool
 folio_object_dirty (struct folio *folio, int object)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   return bit_test (folio->dirty, object + 1);
 }
@@ -332,28 +333,28 @@ folio_object_dirty (struct folio *folio, int object)
 static inline void
 folio_object_dirty_set (struct folio *folio, int object, bool p)
 {
-  assert (object >= -1 && object < FOLIO_OBJECTS);
+  assert (object >= -1 && object < VG_FOLIO_OBJECTS);
 
   bit_set_to (folio->dirty, sizeof (folio->dirty), object + 1, p);
 }
 #endif /* RM_INTERN  */
 
-/* Return a cap designating folio FOLIO's OBJECT'th object.  */
+/* Return a vg_cap designating folio FOLIO's OBJECT'th object.  */
 #ifdef RM_INTERN
 /* This needs to be a macro as we use object_to_object_desc which is
    made available by object.h but object.h includes this file.  */
-#define folio_object_cap(__foc_folio, __foc_object)			\
+#define vg_folio_object_cap(__foc_folio, __foc_object)			\
   ({									\
-    struct cap __foc_cap;						\
+    struct vg_cap __foc_cap;						\
 									\
-    __foc_cap.type = folio_object_type (__foc_folio, __foc_object);	\
+    __foc_cap.type = vg_folio_object_type (__foc_folio, __foc_object);	\
     __foc_cap.version = folio_object_version (__foc_folio,		\
-					      __foc_object);		\
+						 __foc_object);		\
     									\
-    struct cap_properties __foc_cap_properties				\
-      = CAP_PROPERTIES (folio_object_policy (__foc_folio, __foc_object), \
-			CAP_ADDR_TRANS_VOID);				\
-    CAP_PROPERTIES_SET (&__foc_cap, __foc_cap_properties);		\
+    struct vg_cap_properties __foc_cap_properties				\
+      = VG_CAP_PROPERTIES (vg_folio_object_policy (__foc_folio, __foc_object), \
+			   VG_CAP_ADDR_TRANS_VOID);			\
+    VG_CAP_PROPERTIES_SET (&__foc_cap, __foc_cap_properties);		\
 									\
     __foc_cap.oid							\
       = object_to_object_desc ((struct object *) __foc_folio)->oid	\
@@ -362,10 +363,10 @@ folio_object_dirty_set (struct folio *folio, int object, bool p)
     __foc_cap;								\
   })
 #else
-static inline struct cap
-folio_object_cap (struct folio *folio, int object)
+static inline struct vg_cap
+vg_folio_object_cap (struct folio *folio, int object)
 {
-  assert (0 <= object && object < FOLIO_OBJECTS);
+  assert (0 <= object && object < VG_FOLIO_OBJECTS);
   return folio->objects[object];
 }
 #endif
@@ -395,7 +396,7 @@ RPC(folio_free, 0, 0, 0
     /* cap_t, principal, cap_t, folio */)
 
 /* Destroys the INDEXth object in folio FOLIO and allocate in its
-   place an object of tye TYPE.  If TYPE is CAP_VOID, any existing
+   place an object of tye TYPE.  If TYPE is VG_CAP_VOID, any existing
    object is destroyed, however, no object is instantiated in its
    place.  POLICY specifies the object's policy when accessed via the
    folio.  If an object is destroyed and there are waiters, they are
@@ -413,20 +414,20 @@ RPC(folio_object_alloc, 4, 0, 2,
 /* Flags for folio_policy.  */
 enum
 {
-  FOLIO_POLICY_DELIVER = 1 << 0,
+  VG_FOLIO_POLICY_DELIVER = 1 << 0,
 
-  FOLIO_POLICY_DISCARDABLE_SET = 1 << 1,
-  FOLIO_POLICY_GROUP_SET = 1 << 2,
-  FOLIO_POLICY_PRIORITY_SET = 1 << 3,
+  VG_FOLIO_POLICY_DISCARDABLE_SET = 1 << 1,
+  VG_FOLIO_POLICY_GROUP_SET = 1 << 2,
+  VG_FOLIO_POLICY_PRIORITY_SET = 1 << 3,
 
-  FOLIO_POLICY_SET = (FOLIO_POLICY_DISCARDABLE_SET
-		      | FOLIO_POLICY_GROUP_SET
-		      | FOLIO_POLICY_PRIORITY_SET)
+  VG_FOLIO_POLICY_SET = (VG_FOLIO_POLICY_DISCARDABLE_SET
+		      | VG_FOLIO_POLICY_GROUP_SET
+		      | VG_FOLIO_POLICY_PRIORITY_SET)
 };
 
 /* Get and set the management policy for folio FOLIO.
 
-   If FOLIO_POLICY_DELIVER is set in FLAGS, then return FOLIO's
+   If VG_FOLIO_POLICY_DELIVER is set in FLAGS, then return FOLIO's
    current paging policy in OLD.  Then, if any of the set flags are
    set, set the corresponding values based on the value of POLICY.  */
 RPC(folio_policy, 2, 1, 0,
diff --git a/libviengoos/viengoos/futex.h b/libviengoos/viengoos/futex.h
index 3f77b6d..49cb4a2 100644
--- a/libviengoos/viengoos/futex.h
+++ b/libviengoos/viengoos/futex.h
@@ -1,4 +1,4 @@
-/* futex.h - Futex definitions.
+/* vg_futex.h - Futex definitions.
    Copyright (C) 2008 Free Software Foundation, Inc.
    Written by Neal H. Walfield <neal@gnu.org>.
 
@@ -111,17 +111,17 @@ RPC (futex, 7, 1, 0,
 #ifndef RM_INTERN
 #include <errno.h>
 
-struct futex_return
+struct vg_futex_return
 {
   error_t err;
   long ret;
 };
 
-static inline struct futex_return
+static inline struct vg_futex_return
 __attribute__((always_inline))
-futex_using (struct hurd_message_buffer *mb,
-	     void *addr1, int op, int val1, struct timespec *timespec,
-	     void *addr2, int val3)
+vg_futex_using (struct hurd_message_buffer *mb,
+		void *addr1, int op, int val1, struct timespec *timespec,
+		void *addr2, int val3)
 {
   union futex_val2 val2;
   if (timespec)
@@ -133,34 +133,34 @@ futex_using (struct hurd_message_buffer *mb,
   long ret = 0; /* Elide gcc warning.  */
   if (mb)
     err = rm_futex_using (mb,
-			  ADDR_VOID, ADDR_VOID,
+			  VG_ADDR_VOID, VG_ADDR_VOID,
 			  addr1, op, val1, !! timespec, val2, addr2,
 			  (union futex_val3) val3, &ret);
   else
-    err = rm_futex (ADDR_VOID, ADDR_VOID,
+    err = rm_futex (VG_ADDR_VOID, VG_ADDR_VOID,
 		    addr1, op, val1, !! timespec, val2, addr2,
 		    (union futex_val3) val3, &ret);
-  return (struct futex_return) { err, ret };
+  return (struct vg_futex_return) { err, ret };
 }
 
-/* Standard futex signatures.  See futex documentation, e.g., Futexes
+/* Standard vg_futex signatures.  See vg_futex documentation, e.g., Futexes
    are Tricky by Ulrich Drepper.  */
-static inline struct futex_return
+static inline struct vg_futex_return
 __attribute__((always_inline))
-futex (void *addr1, int op, int val1, struct timespec *timespec,
+vg_futex (void *addr1, int op, int val1, struct timespec *timespec,
        void *addr2, int val3)
 {
-  return futex_using (NULL, addr1, op, val1, timespec, addr2, val3);
+  return vg_futex_using (NULL, addr1, op, val1, timespec, addr2, val3);
 }
 
 
 /* If *F is VAL, wait until woken.  */
 static inline long
 __attribute__((always_inline))
-futex_wait_using (struct hurd_message_buffer *mb, int *f, int val)
+vg_futex_wait_using (struct hurd_message_buffer *mb, int *f, int val)
 {
-  struct futex_return ret;
-  ret = futex_using (mb, f, FUTEX_WAIT, val, NULL, 0, 0);
+  struct vg_futex_return ret;
+  ret = vg_futex_using (mb, f, FUTEX_WAIT, val, NULL, 0, 0);
   if (ret.err)
     {
       errno = ret.err;
@@ -173,7 +173,7 @@ static inline long
 __attribute__((always_inline))
 futex_wait (int *f, int val)
 {
-  return futex_wait_using (NULL, f, val);
+  return vg_futex_wait_using (NULL, f, val);
 }
 
 
@@ -182,8 +182,8 @@ static inline long
 __attribute__((always_inline))
 futex_timed_wait (int *f, int val, struct timespec *timespec)
 {
-  struct futex_return ret;
-  ret = futex (f, FUTEX_WAIT, val, timespec, 0, 0);
+  struct vg_futex_return ret;
+  ret = vg_futex (f, FUTEX_WAIT, val, timespec, 0, 0);
   if (ret.err)
     {
       errno = ret.err;
@@ -193,13 +193,13 @@ futex_timed_wait (int *f, int val, struct timespec *timespec)
 }
 
 
-/* Signal NWAKE waiters waiting on futex F.  */
+/* Signal NWAKE waiters waiting on vg_futex F.  */
 static inline long
 __attribute__((always_inline))
-futex_wake_using (struct hurd_message_buffer *mb, int *f, int nwake)
+vg_futex_wake_using (struct hurd_message_buffer *mb, int *f, int nwake)
 {
-  struct futex_return ret;
-  ret = futex_using (mb, f, FUTEX_WAKE, nwake, NULL, 0, 0);
+  struct vg_futex_return ret;
+  ret = vg_futex_using (mb, f, FUTEX_WAKE, nwake, NULL, 0, 0);
   if (ret.err)
     {
       errno = ret.err;
@@ -212,7 +212,7 @@ static inline long
 __attribute__((always_inline))
 futex_wake (int *f, int nwake)
 {
-  return futex_wake_using (NULL, f, nwake);
+  return vg_futex_wake_using (NULL, f, nwake);
 }
 #endif /* !RM_INTERN */
 
diff --git a/libviengoos/viengoos/ipc.h b/libviengoos/viengoos/ipc.h
index 67c2bad..ae00ec4 100644
--- a/libviengoos/viengoos/ipc.h
+++ b/libviengoos/viengoos/ipc.h
@@ -69,7 +69,7 @@ enum
     VG_IPC_SEND_INLINE = 1 << 12,
 
     /* Which inline data to transfer when sending a message.  Inline
-       data is ignored if the send buffer is not ADDR_VOID.  */
+       data is ignored if the send buffer is not VG_ADDR_VOID.  */
     VG_IPC_SEND_INLINE_WORD1 = 1 << 13,
     VG_IPC_SEND_INLINE_WORD2 = 1 << 14,
     VG_IPC_SEND_INLINE_CAP1 = 1 << 15,
@@ -92,7 +92,7 @@ enum
 
    If FLAGS contains VG_IPC_RECEIVE, the IPC includes a receive phase.
 
-   If RECV_BUF is not ADDR_VOID, associates RECV_BUF with
+   If RECV_BUF is not VG_ADDR_VOID, associates RECV_BUF with
    RECV_MESSENGER.
 
    If FLAGS contains VG_IPC_RECEIVE_NONBLOCKING:
@@ -115,10 +115,10 @@ enum
 
    If FLAGS contains VG_IPC_SEND, the IPC includes a send phase.
 
-   If SEND_MESSENGER is ADDR_VOID, an implicit messenger is allocated
+   If SEND_MESSENGER is VG_ADDR_VOID, an implicit messenger is allocated
    and VG_IPC_SEND_NONBLOCKING is assumed to be on.
 
-   If SEND_BUF is not ADDR_VOID, assocaiates SEND_BUF with
+   If SEND_BUF is not VG_ADDR_VOID, assocaiates SEND_BUF with
    SEND_MESSENGER.  Otherwise, associates inline data (INLINE_WORD1,
    INLINE_WORD2 and INLINE_CAP) according to the inline flags with
    SEND_MESSENGER.
@@ -148,12 +148,12 @@ enum
    calling thread is suspended until it is next activated.  */
 static inline error_t
 vg_ipc_full (uintptr_t flags,
-	     addr_t recv_activity, addr_t recv_messenger, addr_t recv_buf,
-	     addr_t recv_inline_cap,
-	     addr_t send_activity, addr_t target_messenger,
-	     addr_t send_messenger, addr_t send_buf,
+	     vg_addr_t recv_activity, vg_addr_t recv_messenger, vg_addr_t recv_buf,
+	     vg_addr_t recv_inline_cap,
+	     vg_addr_t send_activity, vg_addr_t target_messenger,
+	     vg_addr_t send_messenger, vg_addr_t send_buf,
 	     uintptr_t send_inline_word1, uintptr_t send_inline_word2,
-	     addr_t send_inline_cap)
+	     vg_addr_t send_inline_cap)
 {
   error_t err = 0;
 
@@ -165,10 +165,10 @@ vg_ipc_full (uintptr_t flags,
   l4_msg_clear (msg);
   l4_msg_set_msg_tag (msg, tag);
 
-  void msg_append_addr (addr_t addr)
+  void msg_append_addr (vg_addr_t addr)
   {
     int i;
-    for (i = 0; i < sizeof (addr_t) / sizeof (uintptr_t); i ++)
+    for (i = 0; i < sizeof (vg_addr_t) / sizeof (uintptr_t); i ++)
       l4_msg_append_word (msg, ((uintptr_t *) &addr)[i]);
   }
 
@@ -235,51 +235,51 @@ vg_ipc_full (uintptr_t flags,
 
 static inline error_t
 vg_ipc (uintptr_t flags,
-	addr_t recv_activity, addr_t recv_messenger, addr_t recv_buf,
-	addr_t send_activity, addr_t target_messenger,
-	addr_t send_messenger, addr_t send_buf)
+	vg_addr_t recv_activity, vg_addr_t recv_messenger, vg_addr_t recv_buf,
+	vg_addr_t send_activity, vg_addr_t target_messenger,
+	vg_addr_t send_messenger, vg_addr_t send_buf)
 {
   return vg_ipc_full (flags,
-		      recv_activity, recv_messenger, recv_buf, ADDR_VOID,
+		      recv_activity, recv_messenger, recv_buf, VG_ADDR_VOID,
 		      send_activity, target_messenger,
 		      send_messenger, send_buf,
-		      0, 0, ADDR_VOID);
+		      0, 0, VG_ADDR_VOID);
 }
 
 static inline error_t
 vg_ipc_short (uintptr_t flags,
-	      addr_t recv_activity, addr_t recv_messenger, addr_t recv_cap,
-	      addr_t send_activity, addr_t target_messenger,
-	      addr_t send_messenger,
+	      vg_addr_t recv_activity, vg_addr_t recv_messenger, vg_addr_t recv_cap,
+	      vg_addr_t send_activity, vg_addr_t target_messenger,
+	      vg_addr_t send_messenger,
 	      uintptr_t inline_word1, uintptr_t inline_word2,
-	      addr_t inline_cap)
+	      vg_addr_t inline_cap)
 {
   return vg_ipc_full (flags, 
-		      recv_activity, recv_messenger, ADDR_VOID, recv_cap,
+		      recv_activity, recv_messenger, VG_ADDR_VOID, recv_cap,
 		      send_activity, target_messenger,
-		      send_messenger, ADDR_VOID,
+		      send_messenger, VG_ADDR_VOID,
 		      inline_word1, inline_word2, inline_cap);
 }
 
 static inline error_t
-vg_send (uintptr_t flags, addr_t send_activity, addr_t target_messenger,
-	 addr_t send_messenger, addr_t send_buf)
+vg_send (uintptr_t flags, vg_addr_t send_activity, vg_addr_t target_messenger,
+	 vg_addr_t send_messenger, vg_addr_t send_buf)
 {
   return vg_ipc_full (flags | VG_IPC_SEND | VG_IPC_SEND_ACTIVATE,
-		      ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
+		      VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
 		      send_activity, target_messenger,
 		      send_messenger, send_buf,
-		      0, 0, ADDR_VOID);
+		      0, 0, VG_ADDR_VOID);
 }
 
 static inline error_t
-vg_reply (uintptr_t flags, addr_t send_activity, addr_t target_messenger,
-	  addr_t send_messenger, addr_t send_buf)
+vg_reply (uintptr_t flags, vg_addr_t send_activity, vg_addr_t target_messenger,
+	  vg_addr_t send_messenger, vg_addr_t send_buf)
 {
   return vg_ipc_full (flags | VG_IPC_SEND | VG_IPC_SEND_NONBLOCKING,
-		      ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
+		      VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
 		      send_activity, target_messenger, send_messenger, send_buf,
-		      0, 0, ADDR_VOID);
+		      0, 0, VG_ADDR_VOID);
 }
 
 /* Suspend the caller until the next activation.  */
@@ -287,9 +287,9 @@ static inline error_t
 vg_suspend (void)
 {
   return vg_ipc_full (0,
-		      ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
-		      ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
-		      0, 0, ADDR_VOID);
+		      VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
+		      VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
+		      0, 0, VG_ADDR_VOID);
 }
 
 #endif
diff --git a/libviengoos/viengoos/message.h b/libviengoos/viengoos/message.h
index bff1e9a..514248e 100644
--- a/libviengoos/viengoos/message.h
+++ b/libviengoos/viengoos/message.h
@@ -42,7 +42,7 @@ struct vg_message
       /* The number of bytes of data transferred in this message.  */
       uint16_t data_count;
 
-      addr_t caps[/* cap_count */];
+      vg_addr_t caps[/* cap_count */];
       // char data[data_count];
     };
 
@@ -66,7 +66,7 @@ static inline int
 vg_message_cap_count (struct vg_message *msg)
 {
   int max = (PAGESIZE - __builtin_offsetof (struct vg_message, caps))
-    / sizeof (addr_t);
+    / sizeof (vg_addr_t);
 
   int count = msg->cap_count;
   if (count > max)
@@ -80,7 +80,7 @@ static inline int
 vg_message_data_count (struct vg_message *msg)
 {
   int max = PAGESIZE
-    - vg_message_cap_count (msg) * sizeof (addr_t)
+    - vg_message_cap_count (msg) * sizeof (vg_addr_t)
     - __builtin_offsetof (struct vg_message, caps);
 
   int count = msg->data_count;
@@ -92,14 +92,14 @@ vg_message_data_count (struct vg_message *msg)
 
 
 /* Return the start of the capability address array in msg MSG.  */
-static inline addr_t *
+static inline vg_addr_t *
 vg_message_caps (struct vg_message *msg)
 {
   return msg->caps;
 }
 
 /* Return capability IDX in msg MSG.  */
-static inline addr_t
+static inline vg_addr_t
 vg_message_cap (struct vg_message *msg, int idx)
 {
   assert (idx < msg->cap_count);
@@ -114,7 +114,7 @@ vg_message_data (struct vg_message *msg)
 {
   return (void *) msg
     + __builtin_offsetof (struct vg_message, caps)
-    + msg->cap_count * sizeof (addr_t);
+    + msg->cap_count * sizeof (vg_addr_t);
 }
 
 /* Return data word WORD in msg MSG.  */
@@ -130,7 +130,7 @@ vg_message_word (struct vg_message *msg, int word)
 /* Append the array of capability addresses CAPS to the msg MSG.
    There must be sufficient room in the message buffer.  */
 static inline void
-vg_message_append_caps (struct vg_message *msg, int cap_count, addr_t *caps)
+vg_message_append_caps (struct vg_message *msg, int cap_count, vg_addr_t *caps)
 {
   assert ((void *) vg_message_data (msg) - (void *) msg
 	  + vg_message_data_count (msg) + cap_count * sizeof (*caps)
@@ -142,7 +142,7 @@ vg_message_append_caps (struct vg_message *msg, int cap_count, addr_t *caps)
 
   __builtin_memcpy (&msg->caps[msg->cap_count],
 		    caps,
-		    cap_count * sizeof (addr_t));
+		    cap_count * sizeof (vg_addr_t));
 
   msg->cap_count += cap_count;
 }
@@ -150,9 +150,9 @@ vg_message_append_caps (struct vg_message *msg, int cap_count, addr_t *caps)
 /* Append the capability address CAP to the msg MSG.  There must be
    sufficient room in the message buffer.  */
 static inline void
-vg_message_append_cap (struct vg_message *msg, addr_t cap)
+vg_message_append_cap (struct vg_message *msg, vg_addr_t vg_cap)
 {
-  vg_message_append_caps (msg, 1, &cap);
+  vg_message_append_caps (msg, 1, &vg_cap);
 }
 
 
@@ -162,7 +162,7 @@ static inline void
 vg_message_append_data (struct vg_message *msg, int bytes, char *data)
 {
   int dstart = __builtin_offsetof (struct vg_message, caps)
-    + msg->cap_count * sizeof (addr_t);
+    + msg->cap_count * sizeof (vg_addr_t);
   int dend = dstart + msg->data_count;
 
   int new_dend = dend + bytes;
@@ -221,8 +221,8 @@ vg_message_dump (struct vg_message *message)
     }
 
   for (i = 0; i < vg_message_cap_count (message); i ++)
-    s_printf ("cap %d: " ADDR_FMT "\n",
-	      i, ADDR_PRINTF (vg_message_cap (message, i)));
+    s_printf ("cap %d: " VG_ADDR_FMT "\n",
+	      i, VG_ADDR_PRINTF (vg_message_cap (message, i)));
 }
 
 
diff --git a/libviengoos/viengoos/messenger.h b/libviengoos/viengoos/messenger.h
index fbdc5ff..79f3d8a 100644
--- a/libviengoos/viengoos/messenger.h
+++ b/libviengoos/viengoos/messenger.h
@@ -42,7 +42,7 @@
 struct messenger;
 typedef struct messenger *vg_messenger_t;
 #else
-typedef addr_t vg_messenger_t;
+typedef vg_addr_t vg_messenger_t;
 #endif
 
 #define VG_MESSENGER_INLINE_WORDS 2
diff --git a/libviengoos/viengoos/rpc.h b/libviengoos/viengoos/rpc.h
index 14feddd..7ede9ce 100644
--- a/libviengoos/viengoos/rpc.h
+++ b/libviengoos/viengoos/rpc.h
@@ -62,7 +62,7 @@ extern bool messenger_message_load (struct activity *activity,
 #else
 # include <hurd/message-buffer.h>
 #endif
-typedef addr_t cap_t;
+typedef vg_addr_t cap_t;
 
 /* First we define some cpp help macros.  */
 #define CPP_IFELSE_0(when, whennot) whennot
@@ -224,7 +224,7 @@ typedef addr_t cap_t;
 	union								\
 	{								\
 	  __rla_type __rla_a;						\
-	  RPC_GRAB2 (, 1, RPC_TYPE_SHIFT (1, struct cap *, cap_t, __rla_foo)); \
+	  RPC_GRAB2 (, 1, RPC_TYPE_SHIFT (1, struct vg_cap *, cap_t, __rla_foo)); \
 	  cap_t __rla_cap;						\
 	} __rla_arg2 = { (__rla_arg) };					\
 	vg_message_append_cap (msg, __rla_arg2.__rla_cap);		\
@@ -461,7 +461,7 @@ typedef addr_t cap_t;
      RPC_GRAB2 (, out_count, ##__VA_ARGS__)				\
      RPC_IF_COMMA (ret_cap_count) ()					\
      RPC_GRAB2 (, ret_cap_count,					\
-		RPC_TYPE_SHIFT (ret_cap_count, struct cap *,		\
+		RPC_TYPE_SHIFT (ret_cap_count, struct vg_cap *,		\
 				RPC_CHOP2 (out_count, __VA_ARGS__))))	\
   {									\
     vg_message_clear (msg);						\
@@ -736,7 +736,7 @@ typedef addr_t cap_t;
     error_t err = vg_send (VG_IPC_SEND_SET_THREAD_TO_CALLER		\
 			   | VG_IPC_SEND_SET_ASROOT_TO_CALLERS,		\
 			   __rpc_activity, __rpc_object,		\
-			   mb->sender, ADDR_VOID);			\
+			   mb->sender, VG_ADDR_VOID);			\
 									\
     return err;								\
   }
@@ -765,7 +765,7 @@ typedef addr_t cap_t;
     error_t err = vg_reply (VG_IPC_SEND_SET_THREAD_TO_CALLER		\
 			    | VG_IPC_SEND_SET_ASROOT_TO_CALLERS,	\
 			    __rpc_activity, __rpc_object,		\
-			    mb->sender, ADDR_VOID);			\
+			    mb->sender, VG_ADDR_VOID);			\
 									\
     hurd_message_buffer_free (mb);					\
 									\
@@ -782,8 +782,8 @@ typedef addr_t cap_t;
   __attribute__((always_inline))					\
   RPC_CONCAT (RPC_CONCAT (RPC_STUB_PREFIX_(id), _using), postfix)	\
     (struct hurd_message_buffer *mb,					\
-     addr_t __rpc_activity,						\
-     addr_t __rpc_object						\
+     vg_addr_t __rpc_activity,						\
+     vg_addr_t __rpc_object						\
      /* In arguments.  */						\
      RPC_IF_COMMA (in_count) ()						\
      RPC_GRAB2 (, in_count, __VA_ARGS__)				\
@@ -796,7 +796,7 @@ typedef addr_t cap_t;
     RPC_CONCAT (RPC_STUB_PREFIX_(id), _receive_marshal)			\
       (mb->reply							\
        RPC_IF_COMMA (ret_cap_count) ()					\
-       CPP_FOREACH(ret_cap_count, CPP_SAFE_DEREF, ADDR_VOID,		\
+       CPP_FOREACH(ret_cap_count, CPP_SAFE_DEREF, VG_ADDR_VOID,		\
 		   RPC_ARGUMENTS (ret_cap_count, ,			\
 				  RPC_CHOP2 (CPP_ADD (in_count, out_count), \
 					     __VA_ARGS__))));		\
@@ -818,9 +818,9 @@ typedef addr_t cap_t;
 			  | VG_IPC_RECEIVE_SET_THREAD_TO_CALLER		\
 			  | VG_IPC_RECEIVE_SET_ASROOT_TO_CALLERS,	\
 			  __rpc_activity,				\
-			  mb->receiver_strong, ADDR_VOID,		\
+			  mb->receiver_strong, VG_ADDR_VOID,		\
 			  __rpc_activity, __rpc_object,			\
-			  mb->sender, ADDR_VOID);			\
+			  mb->sender, VG_ADDR_VOID);			\
     if (err)								\
       /* Error sending the IPC.  */					\
       hurd_activation_message_unregister (mb);				\
@@ -837,8 +837,8 @@ typedef addr_t cap_t;
   static inline error_t							\
   __attribute__((always_inline))					\
   RPC_CONCAT (RPC_STUB_PREFIX_(id), postfix)				\
-    (addr_t __rpc_activity,						\
-     addr_t __rpc_object						\
+    (vg_addr_t __rpc_activity,						\
+     vg_addr_t __rpc_object						\
      /* In arguments.  */						\
      RPC_IF_COMMA (in_count) ()						\
      RPC_GRAB2 (, in_count, __VA_ARGS__)				\
@@ -871,8 +871,8 @@ typedef addr_t cap_t;
 #define RPC_REPLY_(id, in_count, out_count, ret_cap_count, ...)		\
   static inline error_t							\
   RPC_CONCAT (RPC_STUB_PREFIX_(id), _reply)				\
-    (addr_t __rpc_activity,						\
-     addr_t __rpc_target						\
+    (vg_addr_t __rpc_activity,						\
+     vg_addr_t __rpc_target						\
      /* Out data.  */							\
      RPC_IF_COMMA (out_count) ()					\
      RPC_GRAB2 (, out_count, RPC_CHOP2 (in_count, ##__VA_ARGS__))	\
@@ -898,7 +898,7 @@ typedef addr_t cap_t;
     error_t err = vg_reply (VG_IPC_SEND_SET_THREAD_TO_CALLER		\
 			    | VG_IPC_SEND_SET_ASROOT_TO_CALLERS,	\
 			    __rpc_activity, __rpc_target,		\
-			    mb->sender, ADDR_VOID);			\
+			    mb->sender, VG_ADDR_VOID);			\
 									\
     hurd_message_buffer_free (mb);					\
 									\
@@ -917,7 +917,7 @@ typedef addr_t cap_t;
      /* Return capabilities.  */					\
      RPC_IF_COMMA (ret_cap_count) ()					\
      RPC_GRAB2 (, ret_cap_count,					\
-		RPC_TYPE_SHIFT (ret_cap_count, struct cap,		\
+		RPC_TYPE_SHIFT (ret_cap_count, struct vg_cap,		\
 				RPC_CHOP2 (CPP_ADD (in_count, out_count), \
 					   ##__VA_ARGS__))))		\
   {									\
@@ -991,7 +991,7 @@ typedef addr_t cap_t;
 
    Note that *XYZZY must be initialize with the location of a
    capability slot to store the returned capability.  *XYZZY is set to
-   ADDR_VOID if the sender did not provide a capability.
+   VG_ADDR_VOID if the sender did not provide a capability.
 
    To send a message and not wait for a reply, a function with the
    following prototype is generated:
@@ -1045,9 +1045,9 @@ rpc_error_reply (cap_t activity, cap_t target, error_t err)
 {
   return vg_ipc_short (VG_IPC_SEND_NONBLOCKING | VG_IPC_SEND_INLINE
 		       | VG_IPC_SEND_INLINE_WORD1,
-		       ADDR_VOID, ADDR_VOID, ADDR_VOID,
-		       ADDR_VOID, target,
-		       ADDR_VOID, err, 0, ADDR_VOID);
+		       VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
+		       VG_ADDR_VOID, target,
+		       VG_ADDR_VOID, err, 0, VG_ADDR_VOID);
 }
 #endif
 
diff --git a/libviengoos/viengoos/thread.h b/libviengoos/viengoos/thread.h
index 3789475..f076687 100644
--- a/libviengoos/viengoos/thread.h
+++ b/libviengoos/viengoos/thread.h
@@ -88,7 +88,7 @@ struct vg_utcb
 	uint64_t messenger_id;
 
 	uintptr_t inline_words[VG_MESSENGER_INLINE_WORDS];
-	addr_t inline_caps[VG_MESSENGER_INLINE_CAPS];
+	vg_addr_t inline_caps[VG_MESSENGER_INLINE_CAPS];
 
 	union
 	{
@@ -123,19 +123,19 @@ struct vg_utcb
 enum
   {
     /* Root of the address space.  */
-    THREAD_ASPACE_SLOT = 0,
+    VG_THREAD_ASPACE_SLOT = 0,
     /* The activity the thread is bound to.  */
-    THREAD_ACTIVITY_SLOT = 1,
+    VG_THREAD_ACTIVITY_SLOT = 1,
     /* The messenger to post exceptions to.  */
-    THREAD_EXCEPTION_MESSENGER = 2,
-    /* The user thread control block.  Must be a cap_page.  */
-    THREAD_UTCB = 3,
+    VG_THREAD_EXCEPTION_MESSENGER = 2,
+    /* The user thread control block.  Must be a vg_cap_page.  */
+    VG_THREAD_UTCB = 3,
 
     /* Total number of capability slots in a thread object.  This must
        be a power of 2.  */
-    THREAD_SLOTS = 4,
+    VG_THREAD_SLOTS = 4,
   };
-#define THREAD_SLOTS_LOG2 2
+#define VG_THREAD_SLOTS_LOG2 2
 
 enum
 {
@@ -176,9 +176,9 @@ enum
 
 #ifdef RM_INTERN
 struct thread;
-typedef struct thread *thread_t;
+typedef struct thread *vg_thread_t;
 #else
-typedef addr_t thread_t;
+typedef vg_addr_t vg_thread_t;
 #endif
 
 #define RPC_STUB_PREFIX rm
@@ -189,7 +189,7 @@ typedef addr_t thread_t;
 struct hurd_thread_exregs_in
 {
   uintptr_t aspace_cap_properties_flags;
-  struct cap_properties aspace_cap_properties;
+  struct vg_cap_properties aspace_cap_properties;
 
   uintptr_t sp;
   uintptr_t ip;
@@ -216,19 +216,19 @@ RPC (thread_exregs, 6, 1, 4,
      cap_t, exception_messenger_out)
 
 static inline error_t
-thread_start (addr_t thread)
+vg_thread_start (vg_addr_t thread)
 {
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
 
-  return rm_thread_exregs (ADDR_VOID, thread,
+  return rm_thread_exregs (VG_ADDR_VOID, thread,
 			   HURD_EXREGS_START | HURD_EXREGS_ABORT_IPC,
-			   in, ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
+			   in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
 			   &out, NULL, NULL, NULL, NULL);
 }
 
 static inline error_t
-thread_start_sp_ip (addr_t thread, uintptr_t sp, uintptr_t ip)
+vg_thread_start_sp_ip (vg_addr_t thread, uintptr_t sp, uintptr_t ip)
 {
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
@@ -236,22 +236,22 @@ thread_start_sp_ip (addr_t thread, uintptr_t sp, uintptr_t ip)
   in.sp = sp;
   in.ip = ip;
 
-  return rm_thread_exregs (ADDR_VOID, thread,
+  return rm_thread_exregs (VG_ADDR_VOID, thread,
 			   HURD_EXREGS_START | HURD_EXREGS_ABORT_IPC
 			   | HURD_EXREGS_SET_SP_IP,
-			   in, ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
+			   in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
 			   &out, NULL, NULL, NULL, NULL);
 }
 
 static inline error_t
-thread_stop (addr_t thread)
+vg_thread_stop (vg_addr_t thread)
 {
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
 
-  return rm_thread_exregs (ADDR_VOID, thread,
+  return rm_thread_exregs (VG_ADDR_VOID, thread,
 			   HURD_EXREGS_STOP | HURD_EXREGS_ABORT_IPC,
-			   in, ADDR_VOID, ADDR_VOID, ADDR_VOID, ADDR_VOID,
+			   in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
 			   &out, NULL, NULL, NULL, NULL);
 }
 
@@ -271,7 +271,7 @@ static inline vg_thread_id_t
 vg_myself (void)
 {
   vg_thread_id_t tid;
-  error_t err = rm_thread_id (ADDR_VOID, ADDR_VOID, &tid);
+  error_t err = rm_thread_id (VG_ADDR_VOID, VG_ADDR_VOID, &tid);
   if (err)
     return vg_niltid;
   return tid;
@@ -289,7 +289,7 @@ enum
 
 /* Return a string corresponding to a message id.  */
 static inline const char *
-activation_method_id_string (uintptr_t id)
+vg_activation_method_id_string (uintptr_t id)
 {
   switch (id)
     {
@@ -300,7 +300,7 @@ activation_method_id_string (uintptr_t id)
     }
 }
 
-struct activation_fault_info
+struct vg_activation_fault_info
 {
   union
   {
@@ -309,7 +309,7 @@ struct activation_fault_info
       /* Type of access.  */
       uintptr_t access: 3;
       /* Type of object that was attempting to be accessed.  */
-      uintptr_t type : CAP_TYPE_BITS;
+      uintptr_t type : VG_CAP_TYPE_BITS;
       /* Whether the page was discarded.  */
       uintptr_t discarded : 1;
     };
@@ -317,20 +317,20 @@ struct activation_fault_info
   };
 };
 
-#define ACTIVATION_FAULT_INFO_FMT "%c%c%c %s%s"
-#define ACTIVATION_FAULT_INFO_PRINTF(info)		\
+#define VG_ACTIVATION_FAULT_INFO_FMT "%c%c%c %s%s"
+#define VG_ACTIVATION_FAULT_INFO_PRINTF(info)		\
   ((info).access & L4_FPAGE_READABLE ? 'r' : '~'),	\
   ((info).access & L4_FPAGE_WRITABLE ? 'w' : '~'),	\
   ((info).access & L4_FPAGE_EXECUTABLE ? 'x' : '~'),	\
-  cap_type_string ((info).type),			\
+  vg_cap_type_string ((info).type),			\
   (info.discarded) ? " discarded" : ""
 
 /* Raise a fault at address FAULT_ADDRESS.  If IP is not 0, then IP is
    the value of the IP of the faulting thread at the time of the fault
    and SP the value of the stack pointer at the time of the fault.  */
 RPC (fault, 4, 0, 0,
-     addr_t, fault_address, uintptr_t, sp, uintptr_t, ip,
-     struct activation_fault_info, activation_fault_info)
+     vg_addr_t, fault_address, uintptr_t, sp, uintptr_t, ip,
+     struct vg_activation_fault_info, vg_activation_fault_info)
 
 #undef RPC_STUB_PREFIX
 #undef RPC_ID_PREFIX