Entire file rewritten to use libc signal preemption facility.

1 files changed, 93 insertions, 54 deletions

diff --git a/libdiskfs/=exc.c b/libdiskfs/=exc.c
index 76cb1bcc..d272a08d 100644
--- a/libdiskfs/=exc.c
+++ b/libdiskfs/=exc.c
@@ -1,5 +1,5 @@
 /* 
-   Copyright (C) 1994 Free Software Foundation
+   Copyright (C) 1994, 1995 Free Software Foundation
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
@@ -17,46 +17,93 @@
 
 #include "priv.h"
 
-#define EXC_TABLE_SIZE 1024	/* Ack!XXX -- should be dynamically sized!  */
-/* This is the table of addresses for which we should report faults
-   back to the faulting thread. */
-static struct 
+/* List of preempters that are around. */
+struct preempt_record
 {
+  struct preempt_record *next;
+  struct hurd_signal_preempt preempter1, preempter2;
   struct pager *p;
-  vm_offset_t pager_offset;
-  void *offset;
-  long length;
-} memory_fault_table[EXC_TABLE_SIZE];
+  vm_address_t off;
+  void *addr;
+  long len;
+};
+
+static struct preempt_record *preempt_list;
+static spin_lock_t preempt_list_lock = SPIN_LOCK_INITIALIZER;
+
+/* This special signal handler is run anytime we have taken a fault on
+   a page that we map (registered through
+   diskfs_register_memory_fault_area).  What we do is just longjmp to the
+   context saved on the stack by diskfs_catch_exception.  */
+static void
+special_segv_handler (int code, int subcode, int error)
+{
+  struct preempt_record *rec;
+  struct thread_stuff *stack_record;
+
+  /* SUBCODE is the address and ERROR is the error returned by the
+     pager through the kernel.  But because there is an annoying
+     kernel bug (or rather unimplemented feature) the errors are not
+     actually passed back.  So we have to scan the list of preempt
+     records and find the one that got us here, and then query the
+     pager to find out what error it gave the kernel. */
+  spin_lock (&preempt_list_lock);
+  for (rec = preempt_list; rec; rec = rec->next)
+    if ((void *)subcode >= rec->addr
+	&& (void *)subcode < rec->addr + rec->len)
+      break;
+  assert (rec);
+  spin_unlock (&preempt_list_lock);
+  error = pager_get_error (rec->p, rec->off + (void *)subcode - rec->addr);
+  
+  /* Now look up the stack record left by diskfs_catch_exception, consuming it
+     on the way */
+  stack_record = (struct thread_stuff *) cthread_data (cthread_self ());
+  assert (stack_record);
+  cthread_set_data (cthread_self (), (any_t)stack_record->link);
+  
+  /* And return to it... */
+  longjmp (&stack_record->buf, error);
 
-static spin_lock_t memory_fault_lock;
+  abort ();
+}
+
+/* Return a signal handler for a thread which has faulted inside a
+   region registered as expecting such faults.  This routine runs
+   inside the library's signal thread, and accordingly must be
+   careful.  */
+static sighandler_t
+segv_preempter (thread_t thread, int signo,
+		long int sigcode, int sigerror)
+{
+  /* Just assume that everything is cool (how could it not be?)
+     and return our special handler above. */
+  return special_segv_handler;
+}
 
 /* Mark the memory at ADDR continuing for LEN bytes as mapped from pager P
-   at offset OFF.  Call when vm_map-ing part of the disk. 
-   CAVEAT: addr must not be zero. */
+   at offset OFF.  Call when vm_map-ing part of the disk.  */
 void
 diskfs_register_memory_fault_area (struct pager *p,
 				   vm_address_t off,
 				   void *addr, 
 				   long len)
 {
-  int i;
-
-  assert (addr);
-
-  spin_lock (&memory_fault_lock);
-  
-  for (i = 0; i < EXC_TABLE_SIZE; i++)
-    if (!memory_fault_table[i].offset)
-      {
-	memory_fault_table[i].p = p;
-	memory_fault_table[i].pager_offset = off;
-	memory_fault_table[i].offset = addr;
-	memory_fault_table[i].length = len;
-	spin_unlock (&memory_fault_lock);
-	return;
-      }
-
-  assert (0);
+  struct preempt_record *rec = malloc (sizeof (struct preempt_record));
+
+  hurd_preempt_signals (&rec->preempter1, SIGSEGV, addr, addr + len,
+			segv_preempter);
+  hurd_preempt_signals (&rec->preempter1, SIGBUS, addr, addr + len,
+			segv_preempter);
+  rec->p = p;
+  rec->off = off;
+  rec->addr = addr;
+  rec->len = len;
+
+  spin_lock (&preempt_list_lock);
+  rec->next = preempt_list;
+  preempt_list = rec;
+  spin_unlock (&preempt_list_lock);
 }
 
 /* Mark the memory at ADDR continuing for LEN bytes as no longer
@@ -65,19 +112,25 @@ void
 diskfs_unregister_memory_fault_area (void *addr,
 				     long len)
 {
-  int i;
-
-  assert (addr);
-
-  spin_lock (&memory_fault_lock);
-  for (i = 0; i < EXC_TABLE_SIZE; i++)
-    if (memory_fault_table[i].offset == addr
-	&& memory_fault_table[i].length == len)
+  struct preempt_record *rec, **prevp;
+  
+  spin_lock (&preempt_list_lock);
+  for (rec = preempt_list, prevp = &preempt_list; 
+       rec; 
+       rec = rec->next, prevp = &rec->next)
+    if (rec->addr == addr && rec->len == len)
       {
-	memory_fault_table[i].offset = 0;
-	spin_unlock (&memory_fault_lock);
+	/* This is it, make it go away. */
+	*prevp = rec->next;
+	spin_unlock (&preempt_list_lock);
+	hurd_unpreempt_signals (&rec->preempter1, SIGSEGV);
+	hurd_unpreempt_signals (&rec->preempter2, SIGBUS);
+	free (rec);
 	return;
       }
+  spin_unlock (&preempt_list_lock);
+  
+  /* Not found */
   assert (0);
 }
 
@@ -85,18 +138,4 @@ diskfs_unregister_memory_fault_area (void *addr,
 void
 init_exceptions ()
 {
-  int i;
-
-  for (i = 0; i < EXC_TABLE_SIZE; i++)
-    memory_fault_table[i].offset = 0;
-  spin_lock_init (&memory_fault_lock);
-
-#if notdebugging
-  mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &excport);
-  mach_port_insert_right (mach_task_self (), excport, excport, 
-			  MACH_MSG_TYPE_MAKE_SEND);
-  task_get_special_port (mach_task_self (), TASK_EXCEPTION_PORT, &oldexcport);
-  task_set_special_port (mach_task_self (), TASK_EXCEPTION_PORT, excport);
-  mach_port_deallocate (mach_task_self (), excport);
-#endif
 }