anchor.diff:  
   (defun fd-managed-p (fd)
     "Returns t iff the given fd is being managed with retain/release."
  -  (with-recursive-lock-held (%fd-retain-count-table-lock%)
  +  (with-safe-fd-manipulation
       (%fd-managed-p fd)))
   
   (define-condition fd-already-managed (error)
  
positive.code: 
  Returns two values: the read-end of the pipe and the write end of the
  pipe."
    (with-recursive-lock-held (%fd-retain-count-table-lock%)
      (multiple-value-bind (read-end write-end) (shcl/core/posix:pipe)
        (debug-log status "PIPE ~A -> ~A" write-end read-end)
        (values (%manage-new-fd read-end) (%manage-new-fd write-end)))))
  
  (defmacro with-pipe ((read-end write-end) &body body)
    "Introduce a pipe into the retain table (as if with `pipe-retained')
  
negative.code: Since this locks the fd table, it is very important to minimize the
  amount of work done in the body of this macro.  Ideally, you would
  do nothing exept spawn a new process."
    `(with-safe-fd-manipulation
       (let ((,fd-list-sym (hash-table-keys %extant-fds%)))
         (declare (dynamic-extent ,fd-list-sym))
         ,@body)))
  
  (defun dup-retained (fd)
    (with-safe-fd-manipulation
      (let ((new-fd (track (dup fd))))
        (debug-log status "DUP ~A = ~A" new-fd fd)
        (manage-new-fd new-fd))))
  
  (defun open-retained (pathname flags &optional mode)
    "This is a wrapper around the posix open function which
  atomically adds the new fd to the fd table and gives it a +1 retain
  count."
    (with-safe-fd-manipulation
      (let ((fd (track (posix-open pathname flags mode))))
        (debug-log status "OPEN ~A = ~A" fd pathname)
        (manage-new-fd fd))))
  
  (defun openat-retained (dir-fd pathname flags &optional mode)
    (with-safe-fd-manipulation
      (let ((fd (track (openat dir-fd pathname flags mode))))
        (debug-log status "OPENAT ~A, ~A = ~A" dir-fd fd pathname)
        (manage-new-fd fd))))
  
  (defun pipe-retained ()
    "This is a wrapper around the posix pipe function which atomically
  