Replace RPC rm prefix with vg.

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

	* viengoos/activity.h (RM_activity_policy): Rename from this...
	(VG_activity_policy): ... to this.  Update users.
	(RM_activity_info): Rename from this...
	(VG_activity_info): ... to this.  Update users.
	(RPC_STUB_PREFIX): Define to vg.
	(RPC_ID_PREFIX): Define to VG.
	* viengoos/cap.h
	(RM_cap_copy): Rename from this...
	(VG_cap_copy): ... to this.  Update users.
	(RM_cap_rubout): Rename from this...
	(VG_cap_rubout): ... to this.  Update users.
	(RM_cap_read): Rename from this...
	(VG_cap_read): ... to this.  Update users.
	(RM_object_discarded_clear): Rename from this...
	(VG_object_discarded_clear): ... to this.  Update users.
	(RM_object_discard): Rename from this...
	(VG_object_discard): ... to this.  Update users.
	(RM_object_status): Rename from this...
	(VG_object_status): ... to this.  Update users.
	(RM_object_reply_on_destruction): Rename from this...
	(VG_object_reply_on_destruction): ... to this.  Update users.
	(RM_object_name): Rename from this...
	(VG_object_name): ... to this.  Update users.
	(RPC_STUB_PREFIX): Define to vg.
	(RPC_ID_PREFIX): Define to VG.
	* viengoos/folio.h (RM_folio_alloc): Rename from this...
	(VG_folio_alloc): ... to this.  Update users.
	(RM_folio_free): Rename from this...
	(Vg_folio_free): ... to this.  Update users.
	(RM_folio_object_alloc): Rename from this...
	(VG_folio_object_alloc): ... to this.  Update users.
	(RM_folio_policy): Rename from this...
	(VG_folio_policy): ... to this.  Update users.
	(RPC_STUB_PREFIX): Define to vg.
	(RPC_ID_PREFIX): Define to VG.
	* viengoos/futex.h (RM_futex): Rename from this...
	(VG_futex): ... to this.  Update users.
	(RPC_STUB_PREFIX): Define to vg.
	(RPC_ID_PREFIX): Define to VG.
	* viengoos/misc.h (RM_write): Rename from this...
	(VG_write): ... to this.  Update users.
	(RM_read): Rename from this...
	(VG_read): ... to this.  Update users.
	(RM_as_dump): Rename from this...
	(VG_as_dump): ... to this.  Update users.
	(RM_fault): Rename from this...
	(VG_fault): ... to this.  Update users.
	(RPC_STUB_PREFIX): Define to vg.
	(RPC_ID_PREFIX): Define to VG.
	* viengoos/thread.h (RM_thread_exregs): Rename from this...
	(RM_thread_exregs): ... to this.  Update users.
	(RM_thread_id): Rename from this...
	(RM_thread_id): ... to this.  Update users.
	(RM_thread_activation_collect): Rename from this...
	(RM_thread_activation_collect): ... to this.  Update users.
	(RPC_STUB_PREFIX): Define to vg.
	(RPC_ID_PREFIX): Define to VG.

29 files changed, 177 insertions, 177 deletions

diff --git a/benchmarks/GCbench.c b/benchmarks/GCbench.c
index a7a65d7..bafb3ec 100644
--- a/benchmarks/GCbench.c
+++ b/benchmarks/GCbench.c
@@ -113,7 +113,7 @@ helper (void *arg)
     /* First the main thread.  */
     error_t err;
 
-    err = rm_activity_info (gc_activity, activity_info_stats,
+    err = vg_activity_info (gc_activity, activity_info_stats,
 			    stat_count == 0
 			    ? 0 : stats[stat_count - 1].period + 1,
 			    &info);
@@ -132,7 +132,7 @@ helper (void *arg)
     stats[stat_count].iter = iter;
 
     /* Then, the hog.  */
-    err = rm_activity_info (hog_activity, activity_info_stats,
+    err = vg_activity_info (hog_activity, activity_info_stats,
 			    stat_count == 0
 			    ? 0 : stats[stat_count - 1].period + 1,
 			    &info);
@@ -246,7 +246,7 @@ helper_fork (void)
 
   struct object_name name;
   snprintf (&name.name[0], sizeof (name.name), "gc.%x", l4_myself ());
-  rm_object_name (VG_ADDR_VOID, gc_activity, name);
+  vg_object_name (VG_ADDR_VOID, gc_activity, name);
 
   hog_activity = storage_alloc (VG_ADDR_VOID,
 				vg_cap_activity_control, STORAGE_LONG_LIVED,
@@ -255,7 +255,7 @@ helper_fork (void)
     panic ("Failed to allocate hog activity");
 
   snprintf (&name.name[0], sizeof (name.name), "hog.%x", l4_myself ());
-  rm_object_name (VG_ADDR_VOID, hog_activity, name);
+  vg_object_name (VG_ADDR_VOID, hog_activity, name);
 
   /* We give the main thread and the hog the same priority and
      weight.  */  
@@ -267,15 +267,15 @@ helper_fork (void)
   in.child_rel.priority = 2;
   in.child_rel.weight = 20;
 
-  err = rm_activity_policy (VG_ADDR_VOID,
+  err = vg_activity_policy (VG_ADDR_VOID,
 			    VG_ACTIVITY_POLICY_CHILD_REL_SET, in, &out);
   assert (err == 0);
 
-  err = rm_activity_policy (hog_activity,
+  err = vg_activity_policy (hog_activity,
 			    VG_ACTIVITY_POLICY_SIBLING_REL_SET, in, &out);
   assert (err == 0);
 
-  err = rm_activity_policy (gc_activity,
+  err = vg_activity_policy (gc_activity,
 			    VG_ACTIVITY_POLICY_SIBLING_REL_SET, in, &out);
   assert (err == 0);
 
diff --git a/benchmarks/activity-distribution.c b/benchmarks/activity-distribution.c
index 4b822c3..63726f5 100644
--- a/benchmarks/activity-distribution.c
+++ b/benchmarks/activity-distribution.c
@@ -47,7 +47,7 @@ main (int argc, char *argv[])
       in.sibling_rel.priority = i == 0 ? 2 : 1;
       in.sibling_rel.weight = i + 1;
       struct activity_policy out;
-      err = rm_activity_policy (activity, activities[i],
+      err = vg_activity_policy (activity, activities[i],
 				VG_ACTIVITY_POLICY_SIBLING_REL_SET, in,
 				&out);
       assert (err == 0);
@@ -62,7 +62,7 @@ main (int argc, char *argv[])
   {
     struct activity_info info;
 
-    err = rm_activity_info (activity, activity, activity_info_stats, 1, &info);
+    err = vg_activity_info (activity, activity, activity_info_stats, 1, &info);
     assert (err == 0);
     assert (info.event == activity_info_stats);
     assert (info.stats.count >= 1);
@@ -159,7 +159,7 @@ main (int argc, char *argv[])
 
       struct activity_info info;
 
-      rm_activity_info (activity, activity, activity_info_stats,
+      vg_activity_info (activity, activity, activity_info_stats,
 			next_period, &info);
       assert (info.event == activity_info_stats);
       assert (info.stats.count > 0);
@@ -173,7 +173,7 @@ main (int argc, char *argv[])
       int j;
       for (j = 0; j < THREADS; j ++)
 	{
-	  rm_activity_info (activity, activity, activity_info_stats,
+	  vg_activity_info (activity, activity, activity_info_stats,
 			    next_period, &info);
 	  assert (info.event == activity_info_stats);
 	  assert (info.stats.count > 0);
diff --git a/benchmarks/boehm-gc/patches/05-viengoos-scheduler.patch b/benchmarks/boehm-gc/patches/05-viengoos-scheduler.patch
index db51fe2..6e48da8 100644
--- a/benchmarks/boehm-gc/patches/05-viengoos-scheduler.patch
+++ b/benchmarks/boehm-gc/patches/05-viengoos-scheduler.patch
@@ -275,7 +275,7 @@ diff -uprN -x '*.applied' -x config.guess -x '*~' -x autom4te.cache -x config.su
 +  for (;;)
 +    {
 +      struct activity_info info;
-+      error_t err = rm_activity_info (ACTIVITY,
++      error_t err = vg_activity_info (ACTIVITY,
 +				      activity_info_stats
 +				      | activity_info_pressure,
 +				      period, &info);
diff --git a/benchmarks/cache.c b/benchmarks/cache.c
index 7745a55..d6dbd51 100644
--- a/benchmarks/cache.c
+++ b/benchmarks/cache.c
@@ -211,7 +211,7 @@ helper (void *arg)
     /* First the main thread.  */
     error_t err;
 
-    err = rm_activity_info (VG_ADDR_VOID, main_activity, activity_info_stats,
+    err = vg_activity_info (VG_ADDR_VOID, main_activity, activity_info_stats,
 			    stat_count == 0
 			    ? 0 : stats[stat_count - 1].period + 1,
 			    &info);
@@ -227,7 +227,7 @@ helper (void *arg)
     stats[stat_count].period = info.stats.stats[0].period;
 
     /* Then, the hog.  */
-    err = rm_activity_info (VG_ADDR_VOID, hog_activity, activity_info_stats,
+    err = vg_activity_info (VG_ADDR_VOID, hog_activity, activity_info_stats,
 			    stat_count == 0
 			    ? 0 : stats[stat_count - 1].period + 1,
 			    &info);
@@ -398,7 +398,7 @@ helper_fork (void)
 
   struct object_name name;
   snprintf (&name.name[0], sizeof (name.name), "main.%x", l4_myself ());
-  rm_object_name (VG_ADDR_VOID, main_activity, name);
+  vg_object_name (VG_ADDR_VOID, main_activity, name);
 
   hog_activity = storage_alloc (VG_ADDR_VOID,
 				vg_cap_activity_control, STORAGE_LONG_LIVED,
@@ -407,7 +407,7 @@ helper_fork (void)
     panic ("Failed to allocate hog activity");
 
   snprintf (&name.name[0], sizeof (name.name), "hog.%x", l4_myself ());
-  rm_object_name (VG_ADDR_VOID, hog_activity, name);
+  vg_object_name (VG_ADDR_VOID, hog_activity, name);
 
   /* We give the main thread and the hog the same priority and
      weight.  */  
@@ -419,15 +419,15 @@ helper_fork (void)
   in.child_rel.priority = 2;
   in.child_rel.weight = 20;
 
-  err = rm_activity_policy (VG_ADDR_VOID, meta_data_activity,
+  err = vg_activity_policy (VG_ADDR_VOID, meta_data_activity,
 			    VG_ACTIVITY_POLICY_CHILD_REL_SET, in, &out);
   assert (err == 0);
 
-  err = rm_activity_policy (VG_ADDR_VOID, hog_activity,
+  err = vg_activity_policy (VG_ADDR_VOID, hog_activity,
 			    VG_ACTIVITY_POLICY_SIBLING_REL_SET, in, &out);
   assert (err == 0);
 
-  err = rm_activity_policy (VG_ADDR_VOID, main_activity,
+  err = vg_activity_policy (VG_ADDR_VOID, main_activity,
 			    VG_ACTIVITY_POLICY_SIBLING_REL_SET, in, &out);
   assert (err == 0);
 
diff --git a/benchmarks/shared-memory-distribution.c b/benchmarks/shared-memory-distribution.c
index 27e2d6e..a9ffabf 100644
--- a/benchmarks/shared-memory-distribution.c
+++ b/benchmarks/shared-memory-distribution.c
@@ -110,7 +110,7 @@ main (int argc, char *argv[])
 
       struct activity_info info;
 
-      rm_activity_info (activity, activity,
+      vg_activity_info (activity, activity,
 			activity_info_stats, next_period, &info);
       assert (info.event == activity_info_stats);
       assert (info.stats.count > 0);
@@ -124,7 +124,7 @@ main (int argc, char *argv[])
       int j;
       for (j = 0; j < THREADS; j ++)
 	{
-	  rm_activity_info (activity, activity,
+	  vg_activity_info (activity, activity,
 			    activity_info_stats, next_period, &info);
 	  assert (info.event == activity_info_stats);
 	  assert (info.stats.count > 0);
diff --git a/hieronymus/hieronymus.c b/hieronymus/hieronymus.c
index 06534a2..5a4a3f5 100644
--- a/hieronymus/hieronymus.c
+++ b/hieronymus/hieronymus.c
@@ -72,7 +72,7 @@ activity_alloc (struct activity_policy policy)
     panic ("Failed to allocate storage.");
 
   struct activity_policy out;
-  error_t err = rm_activity_policy (VG_ADDR_VOID, storage.addr,
+  error_t err = vg_activity_policy (VG_ADDR_VOID, storage.addr,
 				    VG_ACTIVITY_POLICY_STORAGE_SET
 				    | VG_ACTIVITY_POLICY_CHILD_REL_SET
 				    | VG_ACTIVITY_POLICY_SIBLING_REL_SET,
@@ -137,7 +137,7 @@ do_gather_stats (void *arg)
       for (i = 0; i < module_count; i ++, stat ++)
 	{
 	  error_t err;
-	  err = rm_activity_info (VG_ADDR_VOID, activities[i], activity_info_stats,
+	  err = vg_activity_info (VG_ADDR_VOID, activities[i], activity_info_stats,
 				  period, &info);
 	  assert_perror (err);
 	  assert (info.event == activity_info_stats);
@@ -192,7 +192,7 @@ main (int argc, char *argv[])
 
       struct object_name name;
       strncpy (&name.name[0], modules[i].name, sizeof (name.name));
-      rm_object_name (VG_ADDR_VOID, activities[i], name);
+      vg_object_name (VG_ADDR_VOID, activities[i], name);
     }
 
   bool gather_stats = false;
@@ -336,14 +336,14 @@ main (int argc, char *argv[])
   for (i = 0; i < module_count; i ++)
     {
       uintptr_t rt = -1;
-      rm_object_reply_on_destruction (root_activity,
+      vg_object_reply_on_destruction (root_activity,
 				      thread[i], &rt);
 
       vg_addr_t folio = vg_addr_chop (activities[i], VG_FOLIO_OBJECTS_LOG2);
       int index = vg_addr_extract (activities[i], VG_FOLIO_OBJECTS_LOG2);
 
       error_t err;
-      err = rm_folio_object_alloc (VG_ADDR_VOID, folio, index,
+      err = vg_folio_object_alloc (VG_ADDR_VOID, folio, index,
 				   vg_cap_void, VG_OBJECT_POLICY_VOID,
 				   (uintptr_t) rt,
 				   NULL, NULL);
diff --git a/libc-parts/_exit.c b/libc-parts/_exit.c
index bda719f..d2e6a8a 100644
--- a/libc-parts/_exit.c
+++ b/libc-parts/_exit.c
@@ -61,7 +61,7 @@ _exit (int ret)
 	      int index = vg_addr_extract (desc->storage, VG_FOLIO_OBJECTS_LOG2);
 
 	      error_t err;
-	      err = rm_folio_object_alloc (VG_ADDR_VOID, folio, index,
+	      err = vg_folio_object_alloc (VG_ADDR_VOID, folio, index,
 					   vg_cap_void, VG_OBJECT_POLICY_VOID,
 					   (uintptr_t) ret,
 					   NULL, NULL);
diff --git a/libc-parts/process-spawn.c b/libc-parts/process-spawn.c
index 23a44dc..68beb78 100644
--- a/libc-parts/process-spawn.c
+++ b/libc-parts/process-spawn.c
@@ -62,7 +62,7 @@
 #ifdef RM_INTERN
 # define AS_DUMP_ as_dump_from (root_activity, as_root_cap, __func__)
 #else
-# define AS_DUMP_ rm_as_dump (VG_ADDR_VOID, as_root)
+# define AS_DUMP_ vg_as_dump (VG_ADDR_VOID, as_root)
 #endif
 #define AS_DUMP						\
   do							\
@@ -367,7 +367,7 @@ process_spawn (vg_addr_t activity,
 
 	  as_ensure (folio_local_addr);
 
-	  error_t err = rm_folio_alloc (activity, activity,
+	  error_t err = vg_folio_alloc (activity, activity,
 					VG_FOLIO_POLICY_DEFAULT,
 					&folio_local_addr);
 	  if (err)
@@ -421,7 +421,7 @@ process_spawn (vg_addr_t activity,
 				   vg_cap_type_strengthen (type),
 				   VG_OBJECT_POLICY_VOID, 0);
 #else
-      rm_folio_object_alloc (VG_ADDR_VOID,
+      vg_folio_object_alloc (VG_ADDR_VOID,
 			     folio_local_addr, index,
 			     vg_cap_type_strengthen (type),
 			     VG_OBJECT_POLICY_VOID, 0, NULL, NULL);
@@ -768,7 +768,7 @@ process_spawn (vg_addr_t activity,
   error_t err;
   struct hurd_thread_exregs_out out;
   /* XXX: Use a weakened activity.  */
-  err = rm_thread_exregs (VG_ADDR_VOID, thread,
+  err = vg_thread_exregs (VG_ADDR_VOID, thread,
 			  HURD_EXREGS_SET_SP_IP
 			  | HURD_EXREGS_SET_ASPACE
 			  | HURD_EXREGS_SET_ACTIVITY
diff --git a/libc-parts/profile.c b/libc-parts/profile.c
index 58d8dec..46b34a4 100644
--- a/libc-parts/profile.c
+++ b/libc-parts/profile.c
@@ -318,7 +318,7 @@ profile_start (uintptr_t id, const char *name, const char *name2)
       else
 	{
 #ifdef __gnu_hurd_viengoos__
-	  site->name = rm_method_id_string (id);
+	  site->name = vg_method_id_string (id);
 #else
 	  site->name = "unknown";
 #endif
diff --git a/libhurd-mm/anonymous.c b/libhurd-mm/anonymous.c
index 8bb91d3..e90ad04 100644
--- a/libhurd-mm/anonymous.c
+++ b/libhurd-mm/anonymous.c
@@ -253,7 +253,7 @@ fault (struct pager *pager, uintptr_t offset, int count, bool read_only,
 		 storage address as object_discarded_clear also
 		 returns a mapping and we are likely to access the
 		 data at the fault address.  */
-	      err = rm_object_discarded_clear (VG_ADDR_VOID, VG_ADDR_VOID,
+	      err = vg_object_discarded_clear (VG_ADDR_VOID, VG_ADDR_VOID,
 					       storage_desc->storage);
 	      assertx (err == 0, "%d", err);
 
@@ -327,7 +327,7 @@ fault (struct pager *pager, uintptr_t offset, int count, bool read_only,
       int faulted;
       for (i = 0; i < count; i += faulted)
 	{
-	  error_t err = rm_fault (VG_ADDR_VOID, fault_addr + i * PAGESIZE,
+	  error_t err = vg_fault (VG_ADDR_VOID, fault_addr + i * PAGESIZE,
 				  count - i, &faulted);
 	  if (err || faulted == 0)
 	    break;
@@ -544,7 +544,7 @@ advise (struct pager *pager,
 		    break;
 
 		  error_t err;
-		  err = rm_object_discard (anon->activity,
+		  err = vg_object_discard (anon->activity,
 					   storage_desc->storage);
 		  if (err)
 		    panic ("err: %d", err);
diff --git a/libhurd-mm/as-build.c b/libhurd-mm/as-build.c
index c850713..73df82f 100644
--- a/libhurd-mm/as-build.c
+++ b/libhurd-mm/as-build.c
@@ -86,7 +86,7 @@ struct trace_buffer as_trace = TRACE_BUFFER_INIT ("as_trace", 0,
 #ifdef RM_INTERN
 # define AS_DUMP as_dump_from (activity, as_root, __func__)
 #else
-# define AS_DUMP rm_as_dump (VG_ADDR_VOID, as_root_addr)
+# define AS_DUMP vg_as_dump (VG_ADDR_VOID, as_root_addr)
 #endif
 
 /* The following macros allow providing specialized address-space
diff --git a/libhurd-mm/as.c b/libhurd-mm/as.c
index 7e47727..e179796 100644
--- a/libhurd-mm/as.c
+++ b/libhurd-mm/as.c
@@ -437,7 +437,7 @@ as_alloc_slow (int width)
 
   struct vg_cap_properties properties = VG_CAP_PROPERTIES_DEFAULT;
   VG_CAP_ADDR_TRANS_SET_GUARD (&properties.addr_trans, 0, gbits);
-  err = rm_cap_copy (meta_data_activity, VG_ADDR_VOID, slot, VG_ADDR_VOID, slot,
+  err = vg_cap_copy (meta_data_activity, VG_ADDR_VOID, slot, VG_ADDR_VOID, slot,
 		     VG_CAP_COPY_COPY_ADDR_TRANS_GUARD, properties);
   if (err)
     panic ("failed to copy capability: %d", err);
@@ -504,11 +504,11 @@ as_init (void)
 
       uintptr_t type;
       struct vg_cap_properties properties;
-      err = rm_cap_read (meta_data_activity, VG_ADDR_VOID, addr,
+      err = vg_cap_read (meta_data_activity, VG_ADDR_VOID, addr,
 			 &type, &properties);
       assert (! err);
       if (! vg_cap_types_compatible (type, desc->type))
-	rm_as_dump (VG_ADDR_VOID, VG_ADDR_VOID);
+	vg_as_dump (VG_ADDR_VOID, VG_ADDR_VOID);
       assertx (vg_cap_types_compatible (type, desc->type),
 	       "Object at " VG_ADDR_FMT ": %s != %s",
 	       VG_ADDR_PRINTF (addr),
@@ -757,7 +757,7 @@ as_walk (int (*visit) (vg_addr_t addr,
       struct vg_cap_properties root_properties;
       uintptr_t root_type;
 
-      err = rm_cap_read (meta_data_activity, VG_ADDR_VOID,
+      err = vg_cap_read (meta_data_activity, VG_ADDR_VOID,
 			 VG_ADDR (0, 0), &root_type, &root_properties);
       assert (err == 0);
 
@@ -779,7 +779,7 @@ as_walk (int (*visit) (vg_addr_t addr,
 	    }
 	  else
 	    {
-	      err = rm_cap_read (meta_data_activity, VG_ADDR_VOID,
+	      err = vg_cap_read (meta_data_activity, VG_ADDR_VOID,
 				 addr, &type, &properties);
 	      assert (err == 0);
 	    }
@@ -832,14 +832,14 @@ as_walk (int (*visit) (vg_addr_t addr,
 	    }
 
 	  addr = vg_addr_extend (addr, child[d], slots_log2);
-	  err = rm_cap_read (meta_data_activity, VG_ADDR_VOID,
+	  err = vg_cap_read (meta_data_activity, VG_ADDR_VOID,
 			     addr, &type, &properties);
 	  assert (err == 0);
 	}
 
       for (;;)
 	{
-	  err = rm_cap_read (meta_data_activity, VG_ADDR_VOID,
+	  err = vg_cap_read (meta_data_activity, VG_ADDR_VOID,
 			     addr, &type, &properties);
 	  if (err)
 	    /* Dangling pointer.  */
diff --git a/libhurd-mm/as.h b/libhurd-mm/as.h
index 7bc4cce..d3253f8 100644
--- a/libhurd-mm/as.h
+++ b/libhurd-mm/as.h
@@ -203,7 +203,7 @@ extern struct vg_cap shadow_root;
       struct vg_cap_properties __acs_p;					\
       error_t __acs_err;						\
 									\
-      __acs_err = rm_cap_read (meta_data_activity,			\
+      __acs_err = vg_cap_read (meta_data_activity,			\
 			       (__acs_root_addr), (__acs_addr),		\
 			       &__acs_type, &__acs_p);			\
 									\
diff --git a/libhurd-mm/exceptions.c b/libhurd-mm/exceptions.c
index c73bec6..13827f2 100644
--- a/libhurd-mm/exceptions.c
+++ b/libhurd-mm/exceptions.c
@@ -523,7 +523,7 @@ hurd_activation_handler_activated (struct hurd_utcb *utcb)
 	    err = vg_message_word (mb->reply, 0);
 
 	  debug (5, "Extant RPC: %s (%d) -> %d",
-		 rm_method_id_string (label), label, err);
+		 vg_method_id_string (label), label, err);
 	}
 #endif
 
@@ -857,7 +857,7 @@ hurd_activation_state_alloc (vg_addr_t thread, struct hurd_utcb **utcbp)
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
 
-  err = rm_thread_exregs (VG_ADDR_VOID, thread,
+  err = vg_thread_exregs (VG_ADDR_VOID, thread,
 			  HURD_EXREGS_SET_UTCB
 			  | HURD_EXREGS_SET_EXCEPTION_MESSENGER,
 			  in, VG_ADDR_VOID, VG_ADDR_VOID,
@@ -866,7 +866,7 @@ hurd_activation_state_alloc (vg_addr_t thread, struct hurd_utcb **utcbp)
   if (err)
     panic ("Failed to install utcb");
 
-  err = rm_cap_copy (VG_ADDR_VOID,
+  err = vg_cap_copy (VG_ADDR_VOID,
 		     utcb->exception_buffer->receiver,
 		     VG_ADDR (VG_MESSENGER_THREAD_SLOT, VG_MESSENGER_SLOTS_LOG2),
 		     VG_ADDR_VOID, thread,
diff --git a/libhurd-mm/mprotect.c b/libhurd-mm/mprotect.c
index 5c70427..59d25e9 100644
--- a/libhurd-mm/mprotect.c
+++ b/libhurd-mm/mprotect.c
@@ -138,7 +138,7 @@ mprotect (void *addr, size_t length, int prot)
 		     if (map->access == 0)
 		       {
 			 error_t err;
-			 err = rm_cap_rubout (meta_data_activity,
+			 err = vg_cap_rubout (meta_data_activity,
 					      VG_ADDR_VOID, addr);
 			 assert (! err);
 			 slot->type = vg_cap_void;
diff --git a/libhurd-mm/storage.c b/libhurd-mm/storage.c
index bdb6ce0..388603d 100644
--- a/libhurd-mm/storage.c
+++ b/libhurd-mm/storage.c
@@ -253,7 +253,7 @@ shadow_setup (struct vg_cap *cap, struct storage_desc *desc)
       desc->free --;
       atomic_decrement (&free_count);
 
-      error_t err = rm_folio_object_alloc (meta_data_activity,
+      error_t err = vg_folio_object_alloc (meta_data_activity,
 					   desc->folio, idx, vg_cap_page,
 					   VG_OBJECT_POLICY_DEFAULT, 0,
 					   NULL, NULL);
@@ -465,7 +465,7 @@ storage_check_reserve_internal (bool force_allocate,
 
   /* And then the folio.  */
   vg_addr_t a = addr;
-  error_t err = rm_folio_alloc (activity, activity, VG_FOLIO_POLICY_DEFAULT,
+  error_t err = vg_folio_alloc (activity, activity, VG_FOLIO_POLICY_DEFAULT,
 				&a);
   assert (! err);
   assert (VG_ADDR_EQ (addr, a));
@@ -645,7 +645,7 @@ storage_alloc (vg_addr_t activity,
     }
 
   vg_addr_t a = addr;
-  error_t err = rm_folio_object_alloc (activity, folio, idx, type, policy, 0,
+  error_t err = vg_folio_object_alloc (activity, folio, idx, type, policy, 0,
 				       &a, NULL);
   assertx (! err,
 	   "Allocating object %d from " VG_ADDR_FMT " at " VG_ADDR_FMT ": %d!",
@@ -752,7 +752,7 @@ storage_free_ (vg_addr_t object, bool unmap_now)
 	  ss_mutex_unlock (&storage_descs_lock);
 
 
-	  error_t err = rm_folio_free (meta_data_activity, folio);
+	  error_t err = vg_folio_free (meta_data_activity, folio);
 	  assert (err == 0);
 
 	  as_slot_lookup_use (folio,
@@ -806,7 +806,7 @@ storage_free_ (vg_addr_t object, bool unmap_now)
   int idx = vg_addr_extract (object, VG_FOLIO_OBJECTS_LOG2);
   bit_dealloc (storage->alloced, idx);
 
-  error_t err = rm_folio_object_alloc (meta_data_activity,
+  error_t err = vg_folio_object_alloc (meta_data_activity,
 				       folio, idx, vg_cap_void,
 				       VG_OBJECT_POLICY_DEFAULT, 0,
 				       NULL, NULL);
diff --git a/libpthread/sysdeps/viengoos/ia32/signal-dispatch-lowlevel.c b/libpthread/sysdeps/viengoos/ia32/signal-dispatch-lowlevel.c
index bbb4ae4..5777bb4 100644
--- a/libpthread/sysdeps/viengoos/ia32/signal-dispatch-lowlevel.c
+++ b/libpthread/sysdeps/viengoos/ia32/signal-dispatch-lowlevel.c
@@ -125,7 +125,7 @@ signal_dispatch_lowlevel (struct signal_state *ss, pthread_t tid,
       struct hurd_thread_exregs_out out;
 
       error_t err;
-      err = rm_thread_exregs (VG_ADDR_VOID, thread->object,
+      err = vg_thread_exregs (VG_ADDR_VOID, thread->object,
 			      HURD_EXREGS_STOP | HURD_EXREGS_ABORT_IPC
 			      | HURD_EXREGS_GET_REGS,
 			      in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
@@ -207,7 +207,7 @@ signal_dispatch_lowlevel (struct signal_state *ss, pthread_t tid,
       in.sp = sp;
       in.ip = (uintptr_t) &_signal_dispatch_entry;
 
-      rm_thread_exregs (VG_ADDR_VOID, thread->object,
+      vg_thread_exregs (VG_ADDR_VOID, thread->object,
 			HURD_EXREGS_SET_SP_IP
 			| HURD_EXREGS_START | HURD_EXREGS_ABORT_IPC,
 			in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
diff --git a/libpthread/sysdeps/viengoos/pt-setactivity-np.c b/libpthread/sysdeps/viengoos/pt-setactivity-np.c
index 5894ad7..f5ba400 100644
--- a/libpthread/sysdeps/viengoos/pt-setactivity-np.c
+++ b/libpthread/sysdeps/viengoos/pt-setactivity-np.c
@@ -29,7 +29,7 @@ pthread_setactivity_np (vg_addr_t activity)
 
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
-  int err = rm_thread_exregs (VG_ADDR_VOID, self->object,
+  int err = vg_thread_exregs (VG_ADDR_VOID, self->object,
 			      HURD_EXREGS_SET_ACTIVITY,
 			      in, VG_ADDR_VOID, activity, VG_ADDR_VOID, VG_ADDR_VOID,
 			      &out, NULL, NULL, NULL, NULL);
diff --git a/libpthread/sysdeps/viengoos/pt-thread-alloc.c b/libpthread/sysdeps/viengoos/pt-thread-alloc.c
index a65024f..8b46e97 100644
--- a/libpthread/sysdeps/viengoos/pt-thread-alloc.c
+++ b/libpthread/sysdeps/viengoos/pt-thread-alloc.c
@@ -75,7 +75,7 @@ __pthread_thread_alloc (struct __pthread *thread)
       if (unlikely (err))
 	panic ("Failed to initialize thread's activation state: %d", err);
 
-      err = rm_cap_copy (VG_ADDR_VOID,
+      err = vg_cap_copy (VG_ADDR_VOID,
 			 thread->lock_message_buffer->receiver,
 			 VG_ADDR (VG_MESSENGER_THREAD_SLOT,
 			       VG_MESSENGER_SLOTS_LOG2),
diff --git a/libpthread/sysdeps/viengoos/pt-thread-start.c b/libpthread/sysdeps/viengoos/pt-thread-start.c
index 1b341cb..59583b4 100644
--- a/libpthread/sysdeps/viengoos/pt-thread-start.c
+++ b/libpthread/sysdeps/viengoos/pt-thread-start.c
@@ -50,7 +50,7 @@ __pthread_thread_start (struct __pthread *thread)
       in.ip = (l4_word_t) thread->mcontext.pc;
 
       in.user_handle = (l4_word_t) thread;
-      err = rm_thread_exregs (VG_ADDR_VOID, thread->object,
+      err = vg_thread_exregs (VG_ADDR_VOID, thread->object,
 			      HURD_EXREGS_SET_ASPACE
 			      | HURD_EXREGS_SET_ACTIVITY
 			      | HURD_EXREGS_SET_SP_IP
diff --git a/libviengoos/viengoos/activity.h b/libviengoos/viengoos/activity.h
index 8f5375b..bc10f7d 100644
--- a/libviengoos/viengoos/activity.h
+++ b/libviengoos/viengoos/activity.h
@@ -25,8 +25,8 @@
 
 enum
   {
-    RM_activity_policy = 700,
-    RM_activity_info,
+    VG_activity_policy = 700,
+    VG_activity_info,
   };
 
 struct activity_memory_policy
@@ -165,8 +165,8 @@ struct activity_stats
 		  VG_ACTIVITY_MEMORY_POLICY_VOID,	\
 		  0)
 
-#define RPC_STUB_PREFIX rm
-#define RPC_ID_PREFIX RM
+#define RPC_STUB_PREFIX vg
+#define RPC_ID_PREFIX VG
 
 #include <viengoos/rpc.h>
 
diff --git a/libviengoos/viengoos/cap.h b/libviengoos/viengoos/cap.h
index 32e475a..e6cb1e4 100644
--- a/libviengoos/viengoos/cap.h
+++ b/libviengoos/viengoos/cap.h
@@ -379,22 +379,22 @@ struct vg_cap
 
 /* Capability-related methods.  */
 
-#define RPC_STUB_PREFIX rm
-#define RPC_ID_PREFIX RM
+#define RPC_STUB_PREFIX vg
+#define RPC_ID_PREFIX VG
 
 #include <viengoos/rpc.h>
 
 enum
   {
-    RM_cap_copy = 300,
-    RM_cap_rubout,
-    RM_cap_read,
-
-    RM_object_discarded_clear = 400,
-    RM_object_discard,
-    RM_object_status,
-    RM_object_reply_on_destruction,
-    RM_object_name,
+    VG_cap_copy = 300,
+    VG_cap_rubout,
+    VG_cap_read,
+
+    VG_object_discarded_clear = 400,
+    VG_object_discard,
+    VG_object_status,
+    VG_object_reply_on_destruction,
+    VG_object_name,
   };
 
 enum
@@ -694,7 +694,7 @@ vg_cap_copy_x (activity_t activity,
   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,
+  error_t err = vg_cap_copy (activity, target_address_space, target_addr,
 			     source_address_space, source_addr,
 			     flags, properties);
   assert (err == 0);
diff --git a/libviengoos/viengoos/folio.h b/libviengoos/viengoos/folio.h
index d135e02..728fe7f 100644
--- a/libviengoos/viengoos/folio.h
+++ b/libviengoos/viengoos/folio.h
@@ -371,17 +371,17 @@ vg_folio_object_cap (struct folio *folio, int object)
 }
 #endif
 
-#define RPC_STUB_PREFIX rm
-#define RPC_ID_PREFIX RM
+#define RPC_STUB_PREFIX vg
+#define RPC_ID_PREFIX VG
 
 #include <viengoos/rpc.h>
 
 enum
   {
-    RM_folio_alloc = 200,
-    RM_folio_free,
-    RM_folio_object_alloc,
-    RM_folio_policy
+    VG_folio_alloc = 200,
+    VG_folio_free,
+    VG_folio_object_alloc,
+    VG_folio_policy
   };
 
 /* Allocate a folio against ACTIVITY.  Return a capability in the
diff --git a/libviengoos/viengoos/futex.h b/libviengoos/viengoos/futex.h
index 49cb4a2..b9f23c9 100644
--- a/libviengoos/viengoos/futex.h
+++ b/libviengoos/viengoos/futex.h
@@ -33,11 +33,11 @@
 
 enum
   {
-    RM_futex = 800,
+    VG_futex = 800,
   };
 
-#define RPC_STUB_PREFIX rm
-#define RPC_ID_PREFIX RM
+#define RPC_STUB_PREFIX vg
+#define RPC_ID_PREFIX VG
 
 #include <viengoos/rpc.h>
 
@@ -137,7 +137,7 @@ vg_futex_using (struct hurd_message_buffer *mb,
 			  addr1, op, val1, !! timespec, val2, addr2,
 			  (union futex_val3) val3, &ret);
   else
-    err = rm_futex (VG_ADDR_VOID, VG_ADDR_VOID,
+    err = vg_futex (VG_ADDR_VOID, VG_ADDR_VOID,
 		    addr1, op, val1, !! timespec, val2, addr2,
 		    (union futex_val3) val3, &ret);
   return (struct vg_futex_return) { err, ret };
diff --git a/libviengoos/viengoos/misc.h b/libviengoos/viengoos/misc.h
index a793335..9fa7131 100644
--- a/libviengoos/viengoos/misc.h
+++ b/libviengoos/viengoos/misc.h
@@ -30,68 +30,68 @@
 
 enum rm_method_id
   {
-    RM_write = 100,
-    RM_read,
-    RM_as_dump,
-    RM_fault,
+    VG_write = 100,
+    VG_read,
+    VG_as_dump,
+    VG_fault,
   };
 
 static inline const char *
-rm_method_id_string (int id)
+vg_method_id_string (int id)
 {
   switch (id)
     {
-    case RM_write:
+    case VG_write:
       return "write";
-    case RM_read:
+    case VG_read:
       return "read";
-    case RM_as_dump:
+    case VG_as_dump:
       return "as_dump";
-    case RM_fault:
+    case VG_fault:
       return "fault";
-    case RM_folio_alloc:
+    case VG_folio_alloc:
       return "folio_alloc";
-    case RM_folio_free:
+    case VG_folio_free:
       return "folio_free";
-    case RM_folio_object_alloc:
+    case VG_folio_object_alloc:
       return "folio_object_alloc";
-    case RM_folio_policy:
+    case VG_folio_policy:
       return "folio_policy";
-    case RM_cap_copy:
+    case VG_cap_copy:
       return "cap_copy";
-    case RM_cap_rubout:
+    case VG_cap_rubout:
       return "cap_rubout";
-    case RM_cap_read:
+    case VG_cap_read:
       return "cap_read";
-    case RM_object_discarded_clear:
+    case VG_object_discarded_clear:
       return "object_discarded_clear";
-    case RM_object_discard:
+    case VG_object_discard:
       return "object_discard";
-    case RM_object_status:
+    case VG_object_status:
       return "object_status";
-    case RM_object_reply_on_destruction:
+    case VG_object_reply_on_destruction:
       return "object_reply_on_destruction";
-    case RM_object_name:
+    case VG_object_name:
       return "object_name";
-    case RM_thread_exregs:
+    case VG_thread_exregs:
       return "thread_exregs";
-    case RM_thread_id:
+    case VG_thread_id:
       return "thread_id";
-    case RM_thread_activation_collect:
+    case VG_thread_activation_collect:
       return "thread_activation_collect";
-    case RM_activity_policy:
+    case VG_activity_policy:
       return "activity_policy";
-    case RM_activity_info:
+    case VG_activity_info:
       return "activity_info";
-    case RM_futex:
+    case VG_futex:
       return "futex";
     default:
       return "unknown method id";
     }
 }
 
-#define RPC_STUB_PREFIX rm
-#define RPC_ID_PREFIX RM
+#define RPC_STUB_PREFIX vg
+#define RPC_ID_PREFIX VG
 
 #include <viengoos/rpc.h>
 
diff --git a/libviengoos/viengoos/thread.h b/libviengoos/viengoos/thread.h
index f076687..2c95f49 100644
--- a/libviengoos/viengoos/thread.h
+++ b/libviengoos/viengoos/thread.h
@@ -169,9 +169,9 @@ enum
 
 enum
   {
-    RM_thread_exregs = 600,
-    RM_thread_id,
-    RM_thread_activation_collect,
+    VG_thread_exregs = 600,
+    VG_thread_id,
+    VG_thread_activation_collect,
   };
 
 #ifdef RM_INTERN
@@ -181,8 +181,8 @@ typedef struct thread *vg_thread_t;
 typedef vg_addr_t vg_thread_t;
 #endif
 
-#define RPC_STUB_PREFIX rm
-#define RPC_ID_PREFIX RM
+#define RPC_STUB_PREFIX vg
+#define RPC_ID_PREFIX VG
 
 #include <viengoos/rpc.h>
 
@@ -221,7 +221,7 @@ vg_thread_start (vg_addr_t thread)
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
 
-  return rm_thread_exregs (VG_ADDR_VOID, thread,
+  return vg_thread_exregs (VG_ADDR_VOID, thread,
 			   HURD_EXREGS_START | HURD_EXREGS_ABORT_IPC,
 			   in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
 			   &out, NULL, NULL, NULL, NULL);
@@ -236,7 +236,7 @@ vg_thread_start_sp_ip (vg_addr_t thread, uintptr_t sp, uintptr_t ip)
   in.sp = sp;
   in.ip = ip;
 
-  return rm_thread_exregs (VG_ADDR_VOID, thread,
+  return vg_thread_exregs (VG_ADDR_VOID, thread,
 			   HURD_EXREGS_START | HURD_EXREGS_ABORT_IPC
 			   | HURD_EXREGS_SET_SP_IP,
 			   in, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID, VG_ADDR_VOID,
@@ -249,7 +249,7 @@ vg_thread_stop (vg_addr_t thread)
   struct hurd_thread_exregs_in in;
   struct hurd_thread_exregs_out out;
 
-  return rm_thread_exregs (VG_ADDR_VOID, thread,
+  return vg_thread_exregs (VG_ADDR_VOID, thread,
 			   HURD_EXREGS_STOP | HURD_EXREGS_ABORT_IPC,
 			   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 (VG_ADDR_VOID, VG_ADDR_VOID, &tid);
+  error_t err = vg_thread_id (VG_ADDR_VOID, VG_ADDR_VOID, &tid);
   if (err)
     return vg_niltid;
   return tid;
diff --git a/newlib/addon/newlib/libc/sys/hurd/pipefile.c b/newlib/addon/newlib/libc/sys/hurd/pipefile.c
index d6f0966..9696c92 100644
--- a/newlib/addon/newlib/libc/sys/hurd/pipefile.c
+++ b/newlib/addon/newlib/libc/sys/hurd/pipefile.c
@@ -15,7 +15,7 @@ static _ssize_t
 pipe_pread (struct _fd *fd, void *buf, size_t size, off_t offset)
 {
   struct io_buffer buffer;
-  rm_read (VG_ADDR_VOID, VG_ADDR_VOID, size, &buffer);
+  vg_read (VG_ADDR_VOID, VG_ADDR_VOID, size, &buffer);
 
   memcpy (buf, buffer.data, buffer.len);
   return buffer.len;
@@ -34,7 +34,7 @@ io_buffer_flush (struct io_buffer *buffer)
   if (buffer->len == 0)
     return;
 
-  rm_write (VG_ADDR_VOID, VG_ADDR_VOID, *buffer);
+  vg_write (VG_ADDR_VOID, VG_ADDR_VOID, *buffer);
   buffer->len = 0;
 }
 
diff --git a/ruth/ruth.c b/ruth/ruth.c
index b169cc6..c6b4d5d 100644
--- a/ruth/ruth.c
+++ b/ruth/ruth.c
@@ -118,7 +118,7 @@ main (int argc, char *argv[])
 
     vg_addr_t folio = capalloc ();
     assert (! VG_ADDR_IS_VOID (folio));
-    error_t err = rm_folio_alloc (activity, activity, VG_FOLIO_POLICY_DEFAULT,
+    error_t err = vg_folio_alloc (activity, activity, VG_FOLIO_POLICY_DEFAULT,
 				  &folio);
     assert (! err);
     assert (! VG_ADDR_IS_VOID (folio));
@@ -130,7 +130,7 @@ main (int argc, char *argv[])
 	if (VG_ADDR_IS_VOID (addr))
 	  panic ("capalloc");
 
-	err = rm_folio_object_alloc (activity, folio, i, vg_cap_page,
+	err = vg_folio_object_alloc (activity, folio, i, vg_cap_page,
 				     VG_OBJECT_POLICY_DEFAULT, 0,
 				     &addr, NULL);
 	assert ((err == 0) == (0 <= i && i < VG_FOLIO_OBJECTS));
@@ -140,14 +140,14 @@ main (int argc, char *argv[])
 	  {
 	    l4_word_t type;
 	    struct vg_cap_properties properties;
-	    err = rm_cap_read (activity, VG_ADDR_VOID, addr, &type, &properties);
+	    err = vg_cap_read (activity, VG_ADDR_VOID, addr, &type, &properties);
 	    assert (! err);
 	    assert (type == vg_cap_page);
 	  }
 	capfree (addr);
       }
 
-    err = rm_folio_free (activity, folio);
+    err = vg_folio_free (activity, folio);
     assert (! err);
     capfree (folio);
 
@@ -180,7 +180,7 @@ main (int argc, char *argv[])
 			 vg_cap_set_shadow (slot, shadow);
 		       }));
 
-	error_t err = rm_folio_alloc (activity, activity,
+	error_t err = vg_folio_alloc (activity, activity,
 				      VG_FOLIO_POLICY_DEFAULT, &f);
 	assert (! err);
 	assert (! VG_ADDR_IS_VOID (f));
@@ -191,7 +191,7 @@ main (int argc, char *argv[])
 	    l4_word_t type;
 	    struct vg_cap_properties properties;
 
-	    error_t err = rm_cap_read (activity, VG_ADDR_VOID,
+	    error_t err = vg_cap_read (activity, VG_ADDR_VOID,
 				       vg_addr_extend (root, j, bits),
 				       &type, &properties);
 	    assert (! err);
@@ -206,7 +206,7 @@ main (int argc, char *argv[])
       {
 	vg_addr_t f = vg_addr_extend (root, i, bits);
 
-	error_t err = rm_folio_free (activity, f);
+	error_t err = vg_folio_free (activity, f);
 	assert (! err);
 
 	void *shadow = NULL;
@@ -345,7 +345,7 @@ main (int argc, char *argv[])
 
     struct hurd_thread_exregs_out out;
 
-    rm_thread_exregs (activity, thread,
+    vg_thread_exregs (activity, thread,
 		      HURD_EXREGS_SET_ASPACE | HURD_EXREGS_SET_ACTIVITY
 		      | HURD_EXREGS_SET_SP_IP | HURD_EXREGS_START
 		      | HURD_EXREGS_ABORT_IPC,
@@ -657,7 +657,7 @@ main (int argc, char *argv[])
 	{
 	  /* Allocate a new activity.  */
 	  a[i].child = capalloc ();
-	  err = rm_folio_object_alloc (activity, folio, obj ++,
+	  err = vg_folio_object_alloc (activity, folio, obj ++,
 				       vg_cap_activity_control,
 				       VG_OBJECT_POLICY_DEFAULT, 0,
 				       &a[i].child, NULL);
@@ -666,13 +666,13 @@ main (int argc, char *argv[])
 
 	  /* Allocate a folio against the activity and use it.  */
 	  a[i].folio = capalloc ();
-	  err = rm_folio_alloc (activity, a[i].child, VG_FOLIO_POLICY_DEFAULT,
+	  err = vg_folio_alloc (activity, a[i].child, VG_FOLIO_POLICY_DEFAULT,
 				&a[i].folio);
 	  assert (err == 0);
 	  assert (! VG_ADDR_IS_VOID (a[i].folio));
 
 	  a[i].page = capalloc ();
-	  err = rm_folio_object_alloc (a[i].child, a[i].folio, 0, vg_cap_page,
+	  err = vg_folio_object_alloc (a[i].child, a[i].folio, 0, vg_cap_page,
 				       VG_OBJECT_POLICY_DEFAULT, 0,
 				       &a[i].page, NULL);
 	  assert (err == 0);
@@ -681,7 +681,7 @@ main (int argc, char *argv[])
 	  l4_word_t type;
 	  struct vg_cap_properties properties;
 
-	  err = rm_cap_read (a[i].child, VG_ADDR_VOID,
+	  err = vg_cap_read (a[i].child, VG_ADDR_VOID,
 			     a[i].page, &type, &properties);
 	  assert (err == 0);
 	  assert (type == vg_cap_page);
@@ -697,7 +697,7 @@ main (int argc, char *argv[])
       for (i = 0; i < N / 2; i ++)
 	{
 	  /* Destroy the activity.  */
-          err = rm_folio_free (activity, a[i].folio);
+          err = vg_folio_free (activity, a[i].folio);
 	  assert (! err);
 
 	  /* To determine if the folio has been destroyed, we cannot simply
@@ -706,7 +706,7 @@ main (int argc, char *argv[])
 	     the object does not destroy the capability.  Instead, we try to
 	     use the object.  If this fails, we assume that the folio was
 	     destroyed.  */
-	  err = rm_folio_object_alloc (a[i].child, a[i].folio, 1, vg_cap_page,
+	  err = vg_folio_object_alloc (a[i].child, a[i].folio, 1, vg_cap_page,
 				       VG_OBJECT_POLICY_DEFAULT, 0,
 				       &a[i].page, NULL);
 	  assert (err);
@@ -719,13 +719,13 @@ main (int argc, char *argv[])
 
     error_t err;
     vg_addr_t folio = capalloc ();
-    err = rm_folio_alloc (activity, activity, VG_FOLIO_POLICY_DEFAULT, &folio);
+    err = vg_folio_alloc (activity, activity, VG_FOLIO_POLICY_DEFAULT, &folio);
     assert (err == 0);
     assert (! VG_ADDR_IS_VOID (folio));
 
     test (activity, folio, 2);
 
-    err = rm_folio_free (activity, folio);
+    err = vg_folio_free (activity, folio);
     assert (err == 0);
 
     capfree (folio);
@@ -742,7 +742,7 @@ main (int argc, char *argv[])
 				    a).addr;
 
     vg_addr_t weak = capalloc ();
-    error_t err = rm_cap_copy (activity, VG_ADDR_VOID, weak, VG_ADDR_VOID, a,
+    error_t err = vg_cap_copy (activity, VG_ADDR_VOID, weak, VG_ADDR_VOID, a,
 			       VG_CAP_COPY_WEAKEN, VG_CAP_PROPERTIES_VOID);
     assert (! err);
 
@@ -752,14 +752,14 @@ main (int argc, char *argv[])
     in.child_rel = VG_ACTIVITY_MEMORY_POLICY_VOID;
     in.folios = 10000;
 
-    err = rm_activity_policy (a, a,
+    err = vg_activity_policy (a, a,
 			      VG_ACTIVITY_POLICY_SIBLING_REL_SET
 			      | VG_ACTIVITY_POLICY_STORAGE_SET,
 			      in,
 			      &out);
     assert (err == 0);
 			    
-    err = rm_activity_policy (a, a,
+    err = vg_activity_policy (a, a,
 			      0, VG_ACTIVITY_POLICY_VOID,
 			      &out);
     assert (err == 0);
@@ -771,7 +771,7 @@ main (int argc, char *argv[])
     in.sibling_rel.priority = 4;
     in.sibling_rel.weight = 5;
     in.folios = 10001;
-    err = rm_activity_policy (a, a,
+    err = vg_activity_policy (a, a,
 			      VG_ACTIVITY_POLICY_SIBLING_REL_SET
 			      | VG_ACTIVITY_POLICY_STORAGE_SET,
 			      in, &out);
@@ -782,13 +782,13 @@ main (int argc, char *argv[])
     assert (out.sibling_rel.weight == 3);
     assert (out.folios == 10000);
 
-    err = rm_activity_policy (a, weak,
+    err = vg_activity_policy (a, weak,
 			      VG_ACTIVITY_POLICY_SIBLING_REL_SET
 			      | VG_ACTIVITY_POLICY_STORAGE_SET,
 			      in, &out);
     assertx (err == EPERM, "%d", err);
 
-    err = rm_activity_policy (a, weak, 0, in, &out);
+    err = vg_activity_policy (a, weak, 0, in, &out);
     assert (err == 0);
 
     assert (out.sibling_rel.priority == 4);
@@ -891,7 +891,7 @@ main (int argc, char *argv[])
     {
       uintptr_t ret = 0;
       error_t err;
-      err = rm_object_reply_on_destruction (VG_ADDR_VOID, storage.addr, &ret);
+      err = vg_object_reply_on_destruction (VG_ADDR_VOID, storage.addr, &ret);
       debug (5, "object_reply_on_destruction: err: %d, ret: %d", err, ret);
       assert (err == 0);
       assert (ret == 10);
@@ -908,7 +908,7 @@ main (int argc, char *argv[])
 
     /* Deallocate the object.  */
     debug (5, "Destroying object");
-    rm_folio_object_alloc (VG_ADDR_VOID,
+    vg_folio_object_alloc (VG_ADDR_VOID,
 			   vg_addr_chop (storage.addr, VG_FOLIO_OBJECTS_LOG2),
 			   vg_addr_extract (storage.addr, VG_FOLIO_OBJECTS_LOG2),
 			   vg_cap_void,
@@ -981,7 +981,7 @@ main (int argc, char *argv[])
     do
       {
 	struct activity_info info;
-	error_t err = rm_activity_info (VG_ADDR_VOID, activity,
+	error_t err = vg_activity_info (VG_ADDR_VOID, activity,
 					activity_info_stats, 1, &info);
 	assert_perror (err);
 	assert (info.stats.count >= 1);
diff --git a/viengoos/server.c b/viengoos/server.c
index 5a6c4cc..c4bdef9 100644
--- a/viengoos/server.c
+++ b/viengoos/server.c
@@ -61,12 +61,12 @@ struct trace_buffer rpc_trace = TRACE_BUFFER_INIT ("rpcs", 0,
 			  thread->tid,					\
 			  l4_is_pagefault (msg_tag) ? "pagefault"	\
 			  : label == 8194 ? "IPC"			\
-			  : rm_method_id_string (label),		\
+			  : vg_method_id_string (label),		\
 			  label,					\
 			  ##args);					\
       debug (level, "(%x %s:%d %d) " format,				\
 	     thread->tid, l4_is_pagefault (msg_tag) ? "pagefault"	\
-	     : label == 8194 ? "IPC" : rm_method_id_string (label),	\
+	     : label == 8194 ? "IPC" : vg_method_id_string (label),	\
 	     __LINE__, label,						\
 	     ##args);							\
     }									\
@@ -76,7 +76,7 @@ struct trace_buffer rpc_trace = TRACE_BUFFER_INIT ("rpcs", 0,
 # define DEBUG(level, format, args...)					\
       debug (level, "(%x %s:%d %d) " format,				\
 	     thread->tid, l4_is_pagefault (msg_tag) ? "pagefault"	\
-	     : label == 8194 ? "IPC" : rm_method_id_string (label),	\
+	     : label == 8194 ? "IPC" : vg_method_id_string (label),	\
 	     __LINE__, label,						\
 	     ##args)
 #endif
@@ -182,7 +182,7 @@ server_loop (void)
       debug (5, "%x (p: %d, %x) sent %s (%x)",
 	     from, l4_ipc_propagated (msg_tag), l4_actual_sender (),
 	     (l4_is_pagefault (msg_tag) ? "fault handler"
-	      : rm_method_id_string (label)),
+	      : vg_method_id_string (label)),
 	     label);
 
       if (l4_version (l4_myself ()) == l4_version (from))
@@ -190,7 +190,7 @@ server_loop (void)
 	panic ("Kernel thread %x (propagated: %d, actual: %x) sent %s? (%x)!",
 	       from, l4_ipc_propagated (msg_tag), l4_actual_sender (),
 	       (l4_is_pagefault (msg_tag) ? "fault handler"
-		      : rm_method_id_string (label)),
+		      : vg_method_id_string (label)),
 	       label);
 
       ss_mutex_lock (&kernel_lock);
@@ -204,7 +204,7 @@ server_loop (void)
 	method = label;
       profile_start (method,
 		     method == PAGEFAULT_METHOD ? "fault handler"
-		     : rm_method_id_string (method), NULL);
+		     : vg_method_id_string (method), NULL);
 
       /* Find the sender.  */
       struct thread *thread = thread_lookup (from);
@@ -1005,7 +1005,7 @@ server_loop (void)
 
       switch (label)
 	{
-	case RM_write:
+	case VG_write:
 	  {
 	    struct io_buffer buffer;
 	    err = rm_write_send_unmarshal (message, &buffer, NULL);
@@ -1019,7 +1019,7 @@ server_loop (void)
 	    rm_write_reply (activity, reply);
 	    break;
 	  }
-	case RM_read:
+	case VG_read:
 	  {
 	    int max;
 	    err = rm_read_send_unmarshal (message, &max, NULL);
@@ -1042,7 +1042,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_fault:
+	case VG_fault:
 	  {
 	    uintptr_t start;
 	    int max;
@@ -1113,7 +1113,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_folio_alloc:
+	case VG_folio_alloc:
 	  {
 	    if (object_type (target) != vg_cap_activity_control)
 	      {
@@ -1141,7 +1141,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_folio_free:
+	case VG_folio_free:
 	  {
 	    if (object_type (target) != vg_cap_folio)
 	      REPLY (EINVAL);
@@ -1160,7 +1160,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_folio_object_alloc:
+	case VG_folio_object_alloc:
 	  {
 	    if (object_type (target) != vg_cap_folio)
 	      REPLY (EINVAL);
@@ -1207,7 +1207,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_folio_policy:
+	case VG_folio_policy:
 	  {
 	    if (object_type (target) != vg_cap_folio)
 	      REPLY (EINVAL);
@@ -1230,7 +1230,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_cap_copy:
+	case VG_cap_copy:
 	  {
 	    vg_addr_t source_as_addr;
 	    vg_addr_t source_addr;
@@ -1383,7 +1383,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_cap_rubout:
+	case VG_cap_rubout:
 	  {
 	    vg_addr_t addr;
 
@@ -1407,7 +1407,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_cap_read:
+	case VG_cap_read:
 	  {
 	    vg_addr_t cap_addr;
 
@@ -1430,7 +1430,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_object_discarded_clear:
+	case VG_object_discarded_clear:
 	  {
 	    vg_addr_t object_addr;
 
@@ -1510,7 +1510,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_object_discard:
+	case VG_object_discard:
 	  {
 	    err = rm_object_discard_send_unmarshal (message, NULL);
 	    if (err)
@@ -1527,7 +1527,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_object_status:
+	case VG_object_status:
 	  {
 	    bool clear;
 	    err = rm_object_status_send_unmarshal (message, &clear, NULL);
@@ -1551,7 +1551,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_object_name:
+	case VG_object_name:
 	  {
 	    struct object_name name;
 	    err = rm_object_name_send_unmarshal (message, &name, NULL);
@@ -1575,7 +1575,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_thread_exregs:
+	case VG_thread_exregs:
 	  {
 	    if (object_type (target) != vg_cap_thread)
 	      REPLY (EINVAL);
@@ -1684,7 +1684,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_thread_id:
+	case VG_thread_id:
 	  {
 	    if (object_type (target) != vg_cap_thread)
 	      REPLY (EINVAL);
@@ -1698,7 +1698,7 @@ server_loop (void)
 	    break;	    
 	  }
 
-	case RM_object_reply_on_destruction:
+	case VG_object_reply_on_destruction:
 	  {
 	    err = rm_object_reply_on_destruction_send_unmarshal (message,
 								 NULL);
@@ -1713,7 +1713,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_activity_policy:
+	case VG_activity_policy:
 	  {
 	    if (object_type (target) != vg_cap_activity_control)
 	      {
@@ -1786,7 +1786,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_activity_info:
+	case VG_activity_info:
 	  {
 	    if (object_type (target) != vg_cap_activity_control)
 	      REPLY (EINVAL);
@@ -1853,7 +1853,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_thread_activation_collect:
+	case VG_thread_activation_collect:
 	  {
 	    if (object_type (target) != vg_cap_thread)
 	      REPLY (EINVAL);
@@ -1868,7 +1868,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_as_dump:
+	case VG_as_dump:
 	  {
 	    err = rm_as_dump_send_unmarshal (message, NULL);
 	    if (err)
@@ -1881,7 +1881,7 @@ server_loop (void)
 	    break;
 	  }
 
-	case RM_futex:
+	case VG_futex:
 	  {
 	    /* Helper function to wake and requeue waiters.  */
 	    int wake (int to_wake, struct object *object1, int offset1,