Description

   This routine locks the Threads Library global mutex. If the
   global mutex is currently held by another thread when a thread
   calls this routine, the calling thread waits for the global mutex
   to become available and then locks it.

   The thread that has locked the global mutex becomes its current
   owner and remains the owner until the same thread has unlocked
   it. This routine returns with the global mutex in the locked
   state and with the current thread as the global mutex's current
   owner.

   Use the global mutex when calling a library package that is
   not designed to run in a multithreaded environment. Unless the
   documentation for a library function specifically states that it
   is thread-safe, assume that it is not compatible; in other words,
   assume it is nonreentrant.

   The global mutex is one lock. Any code that calls any function
   that is not known to be reentrant should use the same lock.
   This prevents problems resulting from dependencies among threads
   that call library functions and those functions' calling other
   functions, and so on.

   The global mutex is a recursive mutex. A thread that has locked
   the global mutex can relock it without deadlocking. The locking
   thread must call pthread_unlock_global_np() as many times as it
   called this routine, to allow another thread to lock the global
   mutex.