I figured out how to RESUME execution after handling SIGSEGV.  Here is an example:
(defpackage mmap-hacks (:use common-lisp ))

(in-package :mmap-hacks)

(sb-alien:define-alien-routine ("mprotect" linux_mprotect)
      sb-alien:int (addr (* t))
      (len sb-alien:unsigned-long)
      (prot sb-alien:int))

(defvar map-anonymous #x20)
(defvar *fd-null* (sb-unix::unix-open "/dev/zero"sb-unix::o_rdonly #o666))

(defun mmap-anonymous-region (size prot)
  (sb-posix::mmap nil size prot (logior map-anonymous  sb-posix::map-private) *fd-null* 0))

(defparameter *mmap-sap* (mmap-anonymous-region (* 4 (sb-sys:get-page-size )) sb-posix::prot-none))

(defvar *testing-sigsegv* nil)

;;; This redefines MEMORY-FAULT-ERROR in sbcl/src/code/interr.lisp
;;; for the specific purpose of this test
(defun sb-kernel::memory-fault-error ()
  (if *testing-sigsegv*
      (progn
    (format t "sb-kernel::memory-fault-error setting write access to #X~x~%"
        sb-kernel::current-memory-fault-address)
    ;; set write access to region and return to resume execution
    (linux_mprotect *mmap-sap* (* 4 (sb-sys:get-page-size )) sb-posix::prot-write))
      
      ;; normal handling of SIGSEGV
      (error 'sb-kernel::memory-fault-error
         :address sb-kernel::current-memory-fault-address)))


(let ((*testing-sigsegv* t))
  ;; set READ-ONLY access on region
  (linux_mprotect *mmap-sap* (* 4 (sb-sys:get-page-size )) sb-posix::prot-read)
  ;;; attempt to write to page
  (setf (sb-sys::sap-ref-32 *mmap-sap* 0) 1))

(let ((*testing-sigsegv* t))
  ;; set no access on region
  (linux_mprotect *mmap-sap* (* 4 (sb-sys:get-page-size )) sb-posix::prot-none)
  ;;; attempt to read from page
  (sb-sys::sap-ref-32 *mmap-sap* 0))




Gábor Melis wrote:
On Lunes 20 Abril 2009, Lynn Quam wrote:
  
It appears that in CMUCL it possible to handle SIGSEGV conditions.

    
(defun mmap-anonymous-region (size prot)
  (unix::unix-mmap nil size prot (logior UNIX:MAP_ANONYMOUS
unix::MAP_PRIVATE) nil 0))

(defparameter *mmap-sap* (mmap-anonymous-region (* 4
(SYS:GET-PAGE-SIZE )) unix::PROT_NONE))

(handler-case (progn (unix:unix-mprotect *mmap-sap* (* 4
(sys:get-page-size )) unix::prot_read)
             (setf (sys::sap-ref-32 *mmap-sap* 0) 1))
  (error ()
    (unix:unix-mprotect *mmap-sap* (* 4 (sys:get-page-size ))
unix::prot_write)
    (setf (sys::sap-ref-32 *mmap-sap* 0) 1)
    ))
      
Has SBCL diverged from CMUCL in this regard?
    

This does not _resume_ the code that caused the fault. I probably took 
your original question too literally and even then the answer was quite 
wrong. Similar code should work on sbcl too, at least after adding 
mprotect to sb-posix, but that does not allow you to actually resume 
the code.

Signalling memory-fault-error with cerror in interr.lisp would allow you 
to unprotect the page, do whatever is needed, and continue. However, 
the reported fault address is not reliable on multithreaded builds as 
it's passed via a global variable.