Use our own variant of 'assert' and 'assert_perror'.

Our variants print stack traces on failures.  This will make locating
errors much easier.

4 files changed, 23 insertions, 23 deletions

diff --git a/libpager/data-return.c b/libpager/data-return.c
index 01f3db2d..c0f5aaf7 100644
--- a/libpager/data-return.c
+++ b/libpager/data-return.c
@@ -19,7 +19,7 @@
 #include "memory_object_S.h"
 #include <stdio.h>
 #include <string.h>
-#include <assert.h>
+#include <assert-backtrace.h>
 
 /* Worker function used by _pager_S_memory_object_data_return
    and _pager_S_memory_object_data_initialize.  All args are
@@ -125,7 +125,7 @@ _pager_do_write_request (struct pager *p,
   /* Mark these pages as being paged out.  */
   if (initializing)
     {
-      assert (npages <= 32);
+      assert_backtrace (npages <= 32);
       for (i = 0; i < npages; i++)
 	{
 	  if (pm_entries[i] & PM_INIT)
@@ -228,7 +228,7 @@ _pager_do_write_request (struct pager *p,
 
   for (i = 0; i < npages; i++)
     {
-      assert (notified[i] == 0 || notified[i] == 1);
+      assert_backtrace (notified[i] == 0 || notified[i] == 1);
       if (notified[i])
 	{
 	  short *pm_entry = &pm_entries[i];
diff --git a/libpager/demuxer.c b/libpager/demuxer.c
index 3fd0516a..fcea629d 100644
--- a/libpager/demuxer.c
+++ b/libpager/demuxer.c
@@ -15,7 +15,7 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
-#include <assert.h>
+#include <assert-backtrace.h>
 #include <error.h>
 #include <mach/mig_errors.h>
 #include <pthread.h>
@@ -315,7 +315,7 @@ pager_start_workers (struct port_bucket *pager_bucket,
   pthread_t t;
   struct pager_requests *requests;
 
-  assert (out_requests != NULL);
+  assert_backtrace (out_requests != NULL);
 
   requests = malloc (sizeof *requests);
   if (requests == NULL)
@@ -376,7 +376,7 @@ pager_inhibit_workers (struct pager_requests *requests)
   pthread_mutex_lock (&requests->lock);
 
   /* Check the workers are not already inhibited.  */
-  assert (requests->queue_out == requests->queue_in);
+  assert_backtrace (requests->queue_out == requests->queue_in);
 
   /* Any new paging requests will go into a new queue.  */
   struct queue *new_queue = malloc (sizeof *new_queue);
@@ -409,9 +409,9 @@ pager_resume_workers (struct pager_requests *requests)
   pthread_mutex_lock (&requests->lock);
 
   /* Check the workers are inhibited.  */
-  assert (requests->queue_out != requests->queue_in);
-  assert (requests->asleep == WORKER_COUNT);
-  assert (queue_empty(requests->queue_out));
+  assert_backtrace (requests->queue_out != requests->queue_in);
+  assert_backtrace (requests->asleep == WORKER_COUNT);
+  assert_backtrace (queue_empty(requests->queue_out));
 
   /* The queue has been drained and will no longer be used.  */
   free (requests->queue_out);
diff --git a/libpager/pager-attr.c b/libpager/pager-attr.c
index cf16d9db..4280e26d 100644
--- a/libpager/pager-attr.c
+++ b/libpager/pager-attr.c
@@ -16,7 +16,7 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 #include "priv.h"
-#include <assert.h>
+#include <assert-backtrace.h>
 
 /* Change the attributes of the memory object underlying pager P.
    Arguments MAY_CACHE and COPY_STRATEGY are as for
diff --git a/libpager/pager-memcpy.c b/libpager/pager-memcpy.c
index f98b0497..12515933 100644
--- a/libpager/pager-memcpy.c
+++ b/libpager/pager-memcpy.c
@@ -20,7 +20,7 @@
 #include "pager.h"
 #include <sys/mman.h>
 #include <hurd/sigpreempt.h>
-#include <assert.h>
+#include <assert-backtrace.h>
 #include <string.h>
 
 /* Start using vm_copy over memcpy when we have that many page. This is
@@ -50,9 +50,9 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
 
   error_t do_vm_copy (void)
     {
-      assert ((offset & (vm_page_size - 1)) == 0);
-      assert (((vm_address_t) other & (vm_page_size - 1)) == 0);
-      assert (n >= vm_page_size);
+      assert_backtrace ((offset & (vm_page_size - 1)) == 0);
+      assert_backtrace (((vm_address_t) other & (vm_page_size - 1)) == 0);
+      assert_backtrace (n >= vm_page_size);
 
       do
 	{
@@ -61,8 +61,8 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
 	    ? (n - (n & (vm_page_size - 1)))
 	    : VMCOPY_WINDOW_DEFAULT_SIZE;
 
-	  assert (window_size >= VMCOPY_BETTER_THAN_MEMCPY);
-	  assert ((window_size & (vm_page_size - 1)) == 0);
+	  assert_backtrace (window_size >= VMCOPY_BETTER_THAN_MEMCPY);
+	  assert_backtrace ((window_size & (vm_page_size - 1)) == 0);
 	  
 	  window = 0;
 	  err = vm_map (mach_task_self (), &window, window_size, 0, 1,
@@ -135,8 +135,8 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
 	      to_copy -= copy_count;
 	      n -= copy_count;
 
-	      assert (n >= 0);
-	      assert (to_copy >= 0);
+	      assert_backtrace (n >= 0);
+	      assert_backtrace (to_copy >= 0);
 	    }
 	  while (to_copy > 0);
 	  
@@ -157,14 +157,14 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
 	  if (err)
 	    return err;
    
-	  assert (n >= VMCOPY_BETTER_THAN_MEMCPY);
+	  assert_backtrace (n >= VMCOPY_BETTER_THAN_MEMCPY);
 
 	  err = do_vm_copy ();
 	  if (err || n == 0)
 	    /* We failed or we finished.  */
 	    return err;
 
-	  assert (n < VMCOPY_BETTER_THAN_MEMCPY);
+	  assert_backtrace (n < VMCOPY_BETTER_THAN_MEMCPY);
 	}
 
       return do_memcpy (n);
@@ -173,7 +173,7 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
   jmp_buf buf;
   void fault (int signo, long int sigcode, struct sigcontext *scp)
     {
-      assert (scp->sc_error == EKERN_MEMORY_ERROR);
+      assert_backtrace (scp->sc_error == EKERN_MEMORY_ERROR);
       err = pager_get_error (pager, sigcode - window + offset);
       n -= sigcode - window;
       vm_deallocate (mach_task_self (), window, window_size);
@@ -199,7 +199,7 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
 	  return err;
 	}
 
-      assert (n < VMCOPY_BETTER_THAN_MEMCPY);
+      assert_backtrace (n < VMCOPY_BETTER_THAN_MEMCPY);
     }
 
   /* Need to do it the hard way.  */
@@ -213,7 +213,7 @@ pager_memcpy (struct pager *pager, memory_object_t memobj,
 		       &do_copy, (sighandler_t) &fault);
 
   if (! err)
-    assert (n == 0);
+    assert_backtrace (n == 0);
 
   *size -= n;