anchor.diff:      (return-from grab-mutex t))
     (when wait-p
       (let ((process (current-process)))
  -      (process-wait-with-timeout (mutex-name mutex)
  -                                 timeout
  -                                 (lambda ()
  -                                   (when (not (mutex-owner mutex))
  -                                     (setf (mutex-owner mutex) process)
  -                                     t))))))
  +      (when (process-wait-with-timeout (mutex-name mutex)
  +                                       timeout
  +                                       (lambda ()
  +                                         (when (not (mutex-owner mutex))
  +                                           (setf (mutex-owner mutex) process)
  +                                           t)))
  +        (assert (mutex-held-p mutex))
  +        t))))
   
   (defun release-mutex (mutex &key (if-not-owner :error))
     (assert (not (%interrupt-state)))
  
positive.code:            (with-interrupts-disabled ()
               (setf got-it (grab-mutex mutex :wait-p wait-p :timeout timeout)))
             (when got-it
               (funcall fn)))
        (with-interrupts-disabled ()
          (when got-it
            (release-mutex mutex))))))
  
negative.code: 
  (defun %maybe-preempt-from-interrupt-frame ()
    "Return a process to switch to, or NIL if the current process should keep running."
    ;; Must not preempt the GC.
    (when (and *preemption-enabled*
               (not *gc-in-progress*))
      (let ((next-process (or (get-next-process)
                              *idle-process*)))
        ;; Must not try to switch to current process.
        (when (not (eql next-process *current-process*))
          (setf *current-process* next-process)
          (process-stack-group next-process)))))
  
  (defun idle-process ()
    (loop
       (%cli)
       (let ((next-process (get-next-process)))
         (cond (next-process
                (setf *current-process* next-process)
  