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.

1 files changed, 94 insertions, 94 deletions

diff --git a/viengoos/t-as.c b/viengoos/t-as.c
index 75fbfaa..ffb061f 100644
--- a/viengoos/t-as.c
+++ b/viengoos/t-as.c
@@ -17,28 +17,28 @@ static struct folio *folio;
 static int object;
 
 static struct as_allocate_pt_ret
-allocate_object (enum cap_type type, addr_t addr)
+allocate_object (enum vg_cap_type type, vg_addr_t addr)
 {
-  if (! folio || object == FOLIO_OBJECTS)
+  if (! folio || object == VG_FOLIO_OBJECTS)
     {
-      folio = folio_alloc (root_activity, FOLIO_POLICY_DEFAULT);
+      folio = folio_alloc (root_activity, VG_FOLIO_POLICY_DEFAULT);
       object = 0;
     }
 
   struct as_allocate_pt_ret rt;
   rt.cap = folio_object_alloc (root_activity, folio, object ++,
-			       type, OBJECT_POLICY_DEFAULT, 0);
+			       type, VG_OBJECT_POLICY_DEFAULT, 0);
 
   /* We don't need to set RT.STORAGE as as_insert doesn't require it
      for the internal interface implementations.  */
-  rt.storage = ADDR (0, 0);
+  rt.storage = VG_ADDR (0, 0);
   return rt;
 }
 
 static struct as_allocate_pt_ret
-allocate_page_table (addr_t addr)
+allocate_page_table (vg_addr_t addr)
 {
-  return allocate_object (cap_cappage, addr);
+  return allocate_object (vg_cap_cappage, addr);
 }
 
 extern char _start;
@@ -46,17 +46,17 @@ extern char _end;
 
 struct alloc
 {
-  addr_t addr;
+  vg_addr_t addr;
   int type;
 };
 
 static void
 try (struct alloc *allocs, int count, bool dump)
 {
-  struct cap aspace = { .type = cap_void };
-  struct cap caps[count];
+  struct vg_cap aspace = { .type = vg_cap_void };
+  struct vg_cap caps[count];
 
-  void do_check (struct cap *cap, bool writable, int i, bool present)
+  void do_check (struct vg_cap *cap, bool writable, int i, bool present)
     {
       if (present)
 	{
@@ -64,24 +64,24 @@ try (struct alloc *allocs, int count, bool dump)
 
 	  assert (cap->type == caps[i].type);
 
-	  struct object *object = cap_to_object (root_activity, cap);
+	  struct object *object = vg_cap_to_object (root_activity, cap);
 	  struct object_desc *odesc = object_to_object_desc (object);
-	  if (caps[i].type != cap_void)
+	  if (caps[i].type != vg_cap_void)
 	    assert (odesc->oid == caps[i].oid);
 
-	  if (cap->type == cap_page)
+	  if (cap->type == vg_cap_page)
 	    assert (* (unsigned char *) object == i);
 	}
       else
 	{
 	  if (cap)
 	    {
-	      struct object *object = cap_to_object (root_activity, cap);
+	      struct object *object = vg_cap_to_object (root_activity, cap);
 	      assert (! object);
 	      /* This assertion relies on the fact that the
 		 implementation will clear the type field on a failed
 		 lookup.  */
-	      assert (cap->type == cap_void);
+	      assert (cap->type == vg_cap_void);
 	    }
 	}
     }
@@ -91,43 +91,43 @@ try (struct alloc *allocs, int count, bool dump)
     {
       switch (allocs[i].type)
 	{
-	case cap_folio:
+	case vg_cap_folio:
 	  caps[i] = object_to_cap ((struct object *)
 				   folio_alloc (root_activity,
-						FOLIO_POLICY_DEFAULT));
+						VG_FOLIO_POLICY_DEFAULT));
 	  break;
-	case cap_void:
-	  caps[i].type = cap_void;
+	case vg_cap_void:
+	  caps[i].type = vg_cap_void;
 	  break;
-	case cap_page:
-	case cap_rpage:
-	case cap_cappage:
-	case cap_rcappage:
+	case vg_cap_page:
+	case vg_cap_rpage:
+	case vg_cap_cappage:
+	case vg_cap_rcappage:
 	  caps[i] = allocate_object (allocs[i].type, allocs[i].addr).cap;
 	  break;
 	default:
 	  assert (! " Bad type");
 	}
 
-      struct object *object = cap_to_object (root_activity, &caps[i]);
-      if (caps[i].type == cap_page)
+      struct object *object = vg_cap_to_object (root_activity, &caps[i]);
+      if (caps[i].type == vg_cap_page)
 	memset (object, i, PAGESIZE);
 
-      as_insert_full (root_activity, ADDR_VOID, &aspace, allocs[i].addr,
-		      ADDR_VOID, ADDR_VOID, object_to_cap (object),
+      as_insert_full (root_activity, VG_ADDR_VOID, &aspace, allocs[i].addr,
+		      VG_ADDR_VOID, VG_ADDR_VOID, object_to_cap (object),
 		      allocate_page_table);
 
       if (dump)
 	{
-	  printf ("After inserting: " ADDR_FMT "\n",
-		  ADDR_PRINTF (allocs[i].addr));
+	  printf ("After inserting: " VG_ADDR_FMT "\n",
+		  VG_ADDR_PRINTF (allocs[i].addr));
 	  as_dump_from (root_activity, &aspace, NULL);
 	}
 
       int j;
       for (j = 0; j < count; j ++)
 	{
-	  struct cap *cap = NULL;
+	  struct vg_cap *cap = NULL;
 	  bool w;
 
 	  as_slot_lookup_rel_use
@@ -138,7 +138,7 @@ try (struct alloc *allocs, int count, bool dump)
 	     }));
 	  do_check (cap, w, j, j <= i);
 
-	  struct cap c;
+	  struct vg_cap c;
 	  c = as_object_lookup_rel (root_activity,
 				    &aspace, allocs[j].addr, -1,
 				    &w);
@@ -150,7 +150,7 @@ try (struct alloc *allocs, int count, bool dump)
   for (i = 0; i < count; i ++)
     {
       /* Make sure allocs[i].addr maps to PAGES[i].  */
-      struct cap *cap = NULL;
+      struct vg_cap *cap = NULL;
       bool w;
 
       as_slot_lookup_rel_use (root_activity, &aspace, allocs[i].addr,
@@ -160,7 +160,7 @@ try (struct alloc *allocs, int count, bool dump)
 			      }));
       do_check (cap, w, i, true);
 
-      struct cap c;
+      struct vg_cap c;
       c = as_object_lookup_rel (root_activity,
 				&aspace, allocs[i].addr, -1,
 				&w);
@@ -169,13 +169,13 @@ try (struct alloc *allocs, int count, bool dump)
       /* Void the capability in the returned capability slot.  */
       as_slot_lookup_rel_use (root_activity, &aspace, allocs[i].addr,
 			      ({
-				slot->type = cap_void;
+				slot->type = vg_cap_void;
 			      }));
 
       /* The page should no longer be found.  */
       c = as_object_lookup_rel (root_activity, &aspace, allocs[i].addr, -1,
 				NULL);
-      assert (c.type == cap_void);
+      assert (c.type == vg_cap_void);
 
       /* Restore the capability slot.  */
       as_slot_lookup_rel_use (root_activity, &aspace, allocs[i].addr,
@@ -201,15 +201,15 @@ try (struct alloc *allocs, int count, bool dump)
       /* Finally, free the object.  */
       switch (caps[i].type)
 	{
-	case cap_folio:
+	case vg_cap_folio:
 	  folio_free (root_activity,
-		      (struct folio *) cap_to_object (root_activity,
+		      (struct folio *) vg_cap_to_object (root_activity,
 						      &caps[i]));
 	  break;
-	case cap_void:
+	case vg_cap_void:
 	  break;
 	default:
-	  object_free (root_activity, cap_to_object (root_activity, &caps[i]));
+	  object_free (root_activity, vg_cap_to_object (root_activity, &caps[i]));
 	  break;
 	}
 
@@ -225,7 +225,7 @@ try (struct alloc *allocs, int count, bool dump)
 	     }));
 	  assert (ret);
 
-	  struct cap c;
+	  struct vg_cap c;
 	  bool writable;
 	  c = as_object_lookup_rel (root_activity,
 				    &aspace, allocs[j].addr, -1, &writable);
@@ -245,12 +245,12 @@ test (void)
   object_init ();
 
   /* Create the root activity.  */
-  folio = folio_alloc (NULL, FOLIO_POLICY_DEFAULT);
+  folio = folio_alloc (NULL, VG_FOLIO_POLICY_DEFAULT);
   if (! folio)
     panic ("Failed to allocate storage for the initial task!");
 
-  struct cap c = allocate_object (cap_activity_control, ADDR_VOID).cap;
-  root_activity = (struct activity *) cap_to_object (root_activity, &c);
+  struct vg_cap c = allocate_object (vg_cap_activity_control, VG_ADDR_VOID).cap;
+  root_activity = (struct activity *) vg_cap_to_object (root_activity, &c);
     
   folio_parent (root_activity, folio);
 
@@ -260,20 +260,20 @@ test (void)
     /* We have an empty address space.  When we use slot_lookup_rel
        and specify that we don't care what type of capability we get,
        we should get the capability slot--if the guard is right.  */
-    struct cap aspace = { type: cap_void };
+    struct vg_cap aspace = { type: vg_cap_void };
 
     l4_word_t addr = 0xFA000;
     bool ret = as_slot_lookup_rel_use (root_activity,
-				       &aspace, ADDR (addr, ADDR_BITS),
+				       &aspace, VG_ADDR (addr, VG_ADDR_BITS),
 				       ({ }));
     assert (! ret);
 
-    /* Set the root to designate ADDR.  */
-    bool r = CAP_SET_GUARD (&aspace, addr, ADDR_BITS);
+    /* Set the root to designate VG_ADDR.  */
+    bool r = VG_CAP_SET_GUARD (&aspace, addr, VG_ADDR_BITS);
     assert (r);
     
     ret = as_slot_lookup_rel_use (root_activity,
-				  &aspace, ADDR (addr, ADDR_BITS),
+				  &aspace, VG_ADDR (addr, VG_ADDR_BITS),
 				  ({
 				    assert (slot == &aspace);
 				    assert (writable);
@@ -286,30 +286,30 @@ test (void)
   printf ("Checking as_insert... ");
   {
     struct alloc allocs[] =
-      { { ADDR (1 << (FOLIO_OBJECTS_LOG2 + PAGESIZE_LOG2),
-		ADDR_BITS - FOLIO_OBJECTS_LOG2 - PAGESIZE_LOG2), cap_folio },
-	{ ADDR (0x100000003, 63), cap_page },
-	{ ADDR (0x100000004, 63), cap_page },
-	{ ADDR (0x1000 /* 4k.  */, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x00100000 /* 1MB */, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x01000000 /* 16MB */, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x10000000 /* 256MB */, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40000000 /* 1000MB */, ADDR_BITS - PAGESIZE_LOG2),
-	  cap_page },
-	{ ADDR (0x40000000 - 0x2000 /* 1000MB - 4k */,
-		ADDR_BITS - PAGESIZE_LOG2),
-	  cap_page },
-	{ ADDR (0x40001000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40003000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40002000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40009000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40008000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40007000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x40006000, ADDR_BITS - PAGESIZE_LOG2), cap_page },
-	{ ADDR (0x00101000 /* 1MB + 4k.  */, ADDR_BITS - PAGESIZE_LOG2),
-	  cap_page },
-	{ ADDR (0x00FF0000 /* 1MB - 4k.  */, ADDR_BITS - PAGESIZE_LOG2),
-	  cap_page },
+      { { VG_ADDR (1 << (VG_FOLIO_OBJECTS_LOG2 + PAGESIZE_LOG2),
+		VG_ADDR_BITS - VG_FOLIO_OBJECTS_LOG2 - PAGESIZE_LOG2), vg_cap_folio },
+	{ VG_ADDR (0x100000003, 63), vg_cap_page },
+	{ VG_ADDR (0x100000004, 63), vg_cap_page },
+	{ VG_ADDR (0x1000 /* 4k.  */, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x00100000 /* 1MB */, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x01000000 /* 16MB */, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x10000000 /* 256MB */, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40000000 /* 1000MB */, VG_ADDR_BITS - PAGESIZE_LOG2),
+	  vg_cap_page },
+	{ VG_ADDR (0x40000000 - 0x2000 /* 1000MB - 4k */,
+		VG_ADDR_BITS - PAGESIZE_LOG2),
+	  vg_cap_page },
+	{ VG_ADDR (0x40001000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40003000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40002000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40009000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40008000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40007000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x40006000, VG_ADDR_BITS - PAGESIZE_LOG2), vg_cap_page },
+	{ VG_ADDR (0x00101000 /* 1MB + 4k.  */, VG_ADDR_BITS - PAGESIZE_LOG2),
+	  vg_cap_page },
+	{ VG_ADDR (0x00FF0000 /* 1MB - 4k.  */, VG_ADDR_BITS - PAGESIZE_LOG2),
+	  vg_cap_page },
       };
 
     try (allocs, sizeof (allocs) / sizeof (allocs[0]), false);
@@ -317,14 +317,14 @@ test (void)
 
   {
     struct alloc allocs[] =
-      { { ADDR (1, ADDR_BITS), cap_page },
-	{ ADDR (2, ADDR_BITS), cap_page },
-	{ ADDR (3, ADDR_BITS), cap_page },
-	{ ADDR (4, ADDR_BITS), cap_page },
-	{ ADDR (5, ADDR_BITS), cap_page },
-	{ ADDR (6, ADDR_BITS), cap_page },
-	{ ADDR (7, ADDR_BITS), cap_page },
-	{ ADDR (8, ADDR_BITS), cap_page }
+      { { VG_ADDR (1, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (2, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (3, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (4, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (5, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (6, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (7, VG_ADDR_BITS), vg_cap_page },
+	{ VG_ADDR (8, VG_ADDR_BITS), vg_cap_page }
       };
 
     try (allocs, sizeof (allocs) / sizeof (allocs[0]), false);
@@ -333,8 +333,8 @@ test (void)
   {
     /* Induce a long different guard.  */
     struct alloc allocs[] =
-      { { ADDR (0x100000000, 51), cap_cappage },
-	{ ADDR (0x80000, 44), cap_folio }
+      { { VG_ADDR (0x100000000, 51), vg_cap_cappage },
+	{ VG_ADDR (0x80000, 44), vg_cap_folio }
       };
 
     try (allocs, sizeof (allocs) / sizeof (allocs[0]), false);
@@ -343,10 +343,10 @@ test (void)
   {
     /* Induce subpage allocation.  */
     struct alloc allocs[] =
-      { { ADDR (0x80000, 44), cap_folio },
-	{ ADDR (0x1000, 51), cap_page },
-	{ ADDR (0x10000, 51), cap_page },
-	{ ADDR (0x2000, 51), cap_page }
+      { { VG_ADDR (0x80000, 44), vg_cap_folio },
+	{ VG_ADDR (0x1000, 51), vg_cap_page },
+	{ VG_ADDR (0x10000, 51), vg_cap_page },
+	{ VG_ADDR (0x2000, 51), vg_cap_page }
       };
 
     try (allocs, sizeof (allocs) / sizeof (allocs[0]), false);
@@ -371,13 +371,13 @@ test (void)
        would be used to point to the folio and the second to the
        smaller cappage.  */
     struct alloc allocs[] =
-      { { ADDR (0x80000, 51), cap_page },
-	{ ADDR (0x81000, 51), cap_page },
-	{ ADDR (0x82000, 51), cap_page },
-	{ ADDR (0x83000, 51), cap_page },
-	{ ADDR (0x84000, 51), cap_page },
-	{ ADDR (0x85000, 51), cap_page },
-	{ ADDR (0x0, 44), cap_folio }
+      { { VG_ADDR (0x80000, 51), vg_cap_page },
+	{ VG_ADDR (0x81000, 51), vg_cap_page },
+	{ VG_ADDR (0x82000, 51), vg_cap_page },
+	{ VG_ADDR (0x83000, 51), vg_cap_page },
+	{ VG_ADDR (0x84000, 51), vg_cap_page },
+	{ VG_ADDR (0x85000, 51), vg_cap_page },
+	{ VG_ADDR (0x0, 44), vg_cap_folio }
       };
 
     try (allocs, sizeof (allocs) / sizeof (allocs[0]), false);