Initial revision

1 files changed, 1224 insertions, 0 deletions

diff --git a/ace/OS.cpp b/ace/OS.cpp
new file mode 100644
index 00000000000..a55b8fa99c8
--- /dev/null
+++ b/ace/OS.cpp
@@ -0,0 +1,1224 @@
+// $Id$
+
+// OS.cpp
+#define ACE_BUILD_DLL
+#include "ace/OS.h"
+
+#include "ace/Log_Msg.h"
+#include "ace/ARGV.h"
+
+// Perhaps we should *always* include ace/OS.i in order to make sure
+// we can always link against the OS symbols?
+#if !defined (ACE_HAS_INLINED_OSCALLS)
+#include "ace/OS.i"
+#endif /* ACE_HAS_INLINED_OS_CALLS */
+
+void 
+ACE_OS::flock_t::dump (void) const
+{
+// ACE_TRACE ("ACE_OS::flock_t::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  ACE_DEBUG ((LM_DEBUG, "handle_ = %u", this->handle_));
+#if defined (ACE_WIN32)
+  ACE_DEBUG ((LM_DEBUG, "\nInternal = %d", this->overlapped_.Internal));
+  ACE_DEBUG ((LM_DEBUG, "\nInternalHigh = %d", this->overlapped_.InternalHigh));
+  ACE_DEBUG ((LM_DEBUG, "\nOffsetHigh = %d", this->overlapped_.OffsetHigh));
+  ACE_DEBUG ((LM_DEBUG, "\nhEvent = %d", this->overlapped_.hEvent));
+#else
+  ACE_DEBUG ((LM_DEBUG, "\nl_whence = %d", this->lock_.l_whence));
+  ACE_DEBUG ((LM_DEBUG, "\nl_start = %d", this->lock_.l_start));
+  ACE_DEBUG ((LM_DEBUG, "\nl_len = %d", this->lock_.l_len));
+  ACE_DEBUG ((LM_DEBUG, "\nl_type = %d", this->lock_.l_type));
+#endif /* ACE_WIN32 */
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
+
+void 
+ACE_OS::mutex_lock_cleanup (void *mutex)
+{
+// ACE_TRACE ("ACE_OS::mutex_lock_cleanup");
+#if defined (ACE_HAS_THREADS)
+#if defined (ACE_HAS_DCETHREADS) || defined (ACE_HAS_PTHREADS)
+  ACE_mutex_t *p_lock = (ACE_mutex_t *) mutex;
+  ACE_OS::mutex_unlock (p_lock);
+#endif /* ACE_HAS_DCETHREADS */
+#endif /* ACE_HAS_THREADS */
+}
+
+// = Static initialization.
+
+// This is necessary to deal with POSIX pthreads insanity.  This
+// guarantees that we've got a "zero'd" thread id even when ACE_thread_t
+// is implemented as a structure...
+ACE_thread_t ACE_OS::NULL_thread;
+
+ACE_OS::ACE_OS (void)
+{
+// ACE_TRACE ("ACE_OS::ACE_OS");
+}
+
+#if defined (ACE_WIN32)
+
+// = Static initialization.
+
+// Keeps track of whether we've initialized the WinSock DLL.
+int ACE_OS::socket_initialized_;
+
+// We need this to initialize the WinSock DLL.
+
+BOOL WINAPI
+DllMain (HINSTANCE, // DLL module handle
+	 DWORD fdwReason, // Reason called
+	 LPVOID) // Reserved
+{
+  switch (fdwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+      if (ACE_OS::socket_init (ACE_WSOCK_VERSION) != 0)
+	return FALSE;
+      break;
+
+    case DLL_PROCESS_DETACH:
+      if (ACE_OS::socket_fini () != 0)
+        return FALSE;
+      break;
+
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+      break;
+
+    default:
+      ACE_ERROR_RETURN ((LM_ERROR, 
+			 "Sock.DLL DllMain called with unknown fdwReason = %u\n.", 
+			 fdwReason), FALSE);
+      /* NOTREACHED */
+    }
+
+  return TRUE;
+}
+
+#include "ace/Synch.h"
+#include "ace/Set.h"
+
+class ACE_TSS_Ref
+  // = TITLE
+  //     "Reference count" for thread-specific storage keys.  
+  //
+  // = DESCRIPTION
+  //     Since the ACE_Unbounded_Set doesn't allow duplicates, the
+  //     "reference count" is the identify of the thread_id.
+{
+public:
+  ACE_TSS_Ref (ACE_thread_t id);
+  // Constructor
+
+  ACE_TSS_Ref (void);
+  // Default constructor
+
+  int operator== (const ACE_TSS_Ref &);
+  // Check for equality.
+
+// private:
+
+  ACE_thread_t tid_;
+  // ID of thread using a specific key.
+};
+
+ACE_TSS_Ref::ACE_TSS_Ref (ACE_thread_t id)
+  : tid_(id)
+{
+// ACE_TRACE ("ACE_TSS_Ref::ACE_TSS_Ref");
+}
+
+ACE_TSS_Ref::ACE_TSS_Ref (void)
+{
+// ACE_TRACE ("ACE_TSS_Ref::ACE_TSS_Ref");
+}
+
+// Check for equality.
+int
+ACE_TSS_Ref::operator== (const ACE_TSS_Ref &info)
+{
+// ACE_TRACE ("ACE_TSS_Ref::operator==");
+
+  return this->tid_ == info.tid_;
+}
+
+typedef ACE_Unbounded_Set<ACE_TSS_Ref> ACE_TSS_REF_TABLE;
+typedef ACE_Unbounded_Set_Iterator<ACE_TSS_Ref> ACE_TSS_REF_TABLE_ITERATOR;
+
+class ACE_TSS_Info
+  // = TITLE
+  //     Thread Specific Key management.
+  //
+  // = DESCRIPTION
+  //     This class maps a key to a "destructor."
+{
+public:
+  ACE_TSS_Info (ACE_thread_key_t key, 
+		void (*dest)(void *) = 0, 
+		void *tss_inst = 0);
+  // Constructor
+
+  ACE_TSS_Info (void);
+  // Default constructor
+
+  int operator== (const ACE_TSS_Info &);
+  // Check for equality.
+
+  void dump (void);
+  // Dump the state.
+
+// private:
+  ACE_thread_key_t key_;
+  // Key to the thread-specific storage item.
+
+  void (*destructor_)(void *);
+  // "Destructor" that gets called when the item is finally released.
+
+  void *tss_obj_;
+  // Pointer to ACE_TSS<xxx> instance that has/will allocate the key.
+ 
+  ACE_TSS_REF_TABLE ref_table_;
+  // Table of thread IDs that are using this key.
+};
+
+ACE_TSS_Info::ACE_TSS_Info (ACE_thread_key_t key, 
+			    void (*dest)(void *),
+			    void *tss_inst)
+  : key_ (key),
+    destructor_ (dest),
+    tss_obj_ (tss_inst)
+{
+// ACE_TRACE ("ACE_TSS_Info::ACE_TSS_Info");
+}
+
+ACE_TSS_Info::ACE_TSS_Info (void)
+{
+// ACE_TRACE ("ACE_TSS_Info::ACE_TSS_Info");
+}
+
+// Check for equality.
+int 
+ACE_TSS_Info::operator== (const ACE_TSS_Info &info)
+{
+// ACE_TRACE ("ACE_TSS_Info::operator==");
+
+  return this->key_ == info.key_;
+}
+
+void 
+ACE_TSS_Info::dump (void)
+{
+//  ACE_TRACE ("ACE_TSS_Info::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  ACE_DEBUG ((LM_DEBUG, "key_ = %u", this->key_));
+  ACE_DEBUG ((LM_DEBUG, "\ndestructor_ = %u", this->destructor_));
+  ACE_DEBUG ((LM_DEBUG, "\ntss_obj_ = %u", this->tss_obj_));
+  ACE_DEBUG ((LM_DEBUG, "\nref_table_.size_ = %u", this->ref_table_.size ()));
+
+  ACE_TSS_Ref *tid_info = 0;
+
+  ACE_DEBUG ((LM_DEBUG, "\nThread_usage_list\n[\n"));
+
+  for (ACE_TSS_REF_TABLE_ITERATOR iter (this->ref_table_);
+       iter.next (tid_info) != 0;
+       iter.advance ())
+    ACE_DEBUG ((LM_DEBUG, "\ntid_ = %d", tid_info->tid_));
+
+  ACE_DEBUG ((LM_DEBUG, "\n]\n"));
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
+
+// Create a set of <ACE_TSS_Info> objects that will reside
+// within thread-specific storage.
+typedef ACE_Unbounded_Set<ACE_TSS_Info> ACE_TSS_TABLE;
+typedef ACE_Unbounded_Set_Iterator<ACE_TSS_Info> ACE_TSS_TABLE_ITERATOR;
+
+class ACE_TSS_Cleanup
+  // = TITLE
+  //     Singleton that knows how to clean up all the thread-specific
+  //     resources for Win32.
+  // 
+  // = DESCRIPTION
+  //     All this nonsense is required since Win32 doesn't
+  //     automatically cleanup thread-specific storage on thread exit,
+  //     unlike real operating systems... ;-)
+{
+public:
+  static ACE_TSS_Cleanup *instance (void);
+
+  void exit (void *status);
+  // Cleanup the thread-specific objects and exit with <status>.
+
+  int insert (ACE_thread_key_t key, void (*destructor)(void *), void *inst);
+  // Insert a <key, destructor> tuple into the table.
+
+  int remove (ACE_thread_key_t key);
+  // Remove a <key, destructor> tuple from the table.
+
+  int detach (void *inst);
+  // Detaches a tss_instance from its key.
+ 
+  int detach (ACE_thread_key_t key, ACE_thread_t tid);
+  // Detaches a thread from the key.
+ 
+  int key_used (ACE_thread_key_t key);
+  // Mark a key as being used by this thread.
+
+protected:
+  void dump (void);
+
+  ACE_TSS_Cleanup (void);
+  // Ensure singleton.
+
+private:
+  ACE_TSS_TABLE table_;
+  // Table of <ACE_TSS_Info>'s.
+
+  // = Static data.
+  static ACE_TSS_Cleanup *instance_;
+  // Pointer to the singleton instance.
+
+public:
+  static ACE_Recursive_Thread_Mutex lock_;
+  // Serialize initialization of <key_>.
+};
+
+// = Static object initialization.
+
+// Pointer to the singleton instance.
+ACE_TSS_Cleanup *ACE_TSS_Cleanup::instance_ = 0;
+
+// Serialize initialization of <key_>.
+ACE_Recursive_Thread_Mutex ACE_TSS_Cleanup::lock_;
+
+void 
+ACE_TSS_Cleanup::exit (void *status)
+{
+// ACE_TRACE ("ACE_TSS_Cleanup::exit");
+
+  {
+    ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, ACE_TSS_Cleanup::lock_);
+
+    // Prevent recursive deletions (note that when a recursive mutex
+    // is first acquired it has a nesting level of 1...).
+    if (ACE_TSS_Cleanup::lock_.get_nesting_level () > 1)
+      return;
+
+    ACE_thread_key_t key_arr[TLS_MINIMUM_AVAILABLE];
+    int index = 0;
+
+    ACE_TSS_Info *key_info = 0;
+
+    // Iterate through all the thread-specific items and free them all
+    // up.
+
+    for (ACE_TSS_TABLE_ITERATOR iter (this->table_);
+	 iter.next (key_info) != 0;
+	 iter.advance ())
+      {
+	void *tss_info = 0;
+
+	int val = key_info->ref_table_.remove (ACE_TSS_Ref (ACE_OS::thr_self ()));
+
+	if ((ACE_OS::thr_getspecific (key_info->key_, &tss_info) == 0)
+	    && (key_info->destructor_) 
+	    && tss_info)
+	  // Probably need to have an exception handler here...
+	  (*key_info->destructor_) (tss_info);   
+
+ 	if (key_info->ref_table_.size () == 0 
+	    && key_info->tss_obj_ == 0)
+	  key_arr[index++] = key_info->key_;
+      }
+
+    for (int i = 0; i < index; i++)
+      {
+	::TlsFree (key_arr[i]);
+	this->table_.remove (ACE_TSS_Info (key_arr[i]));
+      }
+  }
+
+#if 0 
+  ::ExitThread ((DWORD) status);
+#endif 
+  ::_endthreadex ((DWORD) status);
+
+  /* NOTREACHED */
+}
+
+ACE_TSS_Cleanup::ACE_TSS_Cleanup (void)
+{
+// ACE_TRACE ("ACE_TSS_Cleanup::ACE_TSS_Cleanup");
+}
+
+ACE_TSS_Cleanup *
+ACE_TSS_Cleanup::instance (void)
+{
+// ACE_TRACE ("ACE_TSS_Cleanup::instance");
+
+  // Create and initialize thread-specific key.
+  if (ACE_TSS_Cleanup::instance_ == 0)
+    {
+      // Insure that we are serialized!
+      ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, ACE_TSS_Cleanup::lock_, 0);
+
+      // Now, use the Double-Checked Locking pattern to make sure we
+      // only create the key once.
+      if (instance_ == 0)
+	ACE_NEW_RETURN (ACE_TSS_Cleanup::instance_, ACE_TSS_Cleanup, 0);
+    }
+
+  return ACE_TSS_Cleanup::instance_;
+}
+
+int 
+ACE_TSS_Cleanup::insert (ACE_thread_key_t key, 
+			 void (*destructor)(void *),
+			 void *inst)
+{
+// ACE_TRACE ("ACE_TSS_Cleanup::insert");
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, ACE_TSS_Cleanup::lock_, -1);
+
+  return this->table_.insert (ACE_TSS_Info (key, destructor, inst));
+}
+
+int
+ACE_TSS_Cleanup::remove (ACE_thread_key_t key)
+{
+// ACE_TRACE ("ACE_TSS_Cleanup::remove");
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, ACE_TSS_Cleanup::lock_, -1);
+
+  return this->table_.remove (ACE_TSS_Info (key));
+}
+
+int 
+ACE_TSS_Cleanup::detach (void *inst)
+{ 
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, ACE_TSS_Cleanup::lock_, -1);
+  
+  ACE_TSS_Info *key_info = 0;
+  int success = 0;
+  int ref_cnt = 0;
+  
+  for (ACE_TSS_TABLE_ITERATOR iter (this->table_);
+       iter.next (key_info) != 0;
+       iter.advance ())
+    {
+      if (key_info->tss_obj_ == inst)
+	{
+	  key_info->tss_obj_ = 0;
+	  ref_cnt = key_info->ref_table_.size ();
+	  success = 1;
+	  break;
+	}
+    }
+  
+  if (success == 0)
+    return -1;
+  else if (ACE_TSS_Cleanup::lock_.get_nesting_level () > 1)
+    ACE_ERROR_RETURN ((LM_DEBUG, "Detach() invoked from ACE_TSS_Cleanup::exit()\n"), 0);
+  else if (ref_cnt == 0)
+    {
+      ::TlsFree (key_info->key_);
+      return this->table_.remove (ACE_TSS_Info (key_info->key_));
+    }
+
+  return 0;
+}
+  
+int 
+ACE_TSS_Cleanup::detach (ACE_thread_key_t key, ACE_thread_t tid)
+{
+  return -1;
+}
+  
+int 
+ACE_TSS_Cleanup::key_used (ACE_thread_key_t key)
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, ACE_TSS_Cleanup::lock_, -1);
+
+  ACE_TSS_Info *key_info = 0;
+
+  for (ACE_TSS_TABLE_ITERATOR iter (this->table_);
+       iter.next (key_info) != 0;
+       iter.advance ())
+    if (key_info->key_ == key)
+      return key_info->ref_table_.insert (ACE_TSS_Ref (ACE_OS::thr_self ()));
+
+  return -1;
+}
+  
+void 
+ACE_TSS_Cleanup::dump (void)
+{
+  ACE_TSS_Info *key_info = 0;
+
+  // Iterate through all the thread-specific items and dump them all.
+
+  for (ACE_TSS_TABLE_ITERATOR iter (this->table_);
+       iter.next (key_info) != 0;
+       iter.advance ())
+    key_info->dump ();
+}
+
+// Special thread startup argument (used below in <thr_create>).
+
+class ACE_Win32_Thread_Adapter
+{
+public:
+  ACE_Win32_Thread_Adapter (ACE_THR_FUNC f, void *a);
+  // Constructor
+
+  static void *svc_run (ACE_Win32_Thread_Adapter *);
+  // Run the thread exit point.
+
+private:
+  // = Arguments to thread startup.
+  ACE_THR_FUNC func_;
+  // Thread startup function.
+
+  void *arg_;
+  // Argument to thread startup function.
+};
+
+ACE_Win32_Thread_Adapter::ACE_Win32_Thread_Adapter (ACE_THR_FUNC f, void *a)
+  : func_(f), 
+    arg_(a) 
+{
+// ACE_TRACE ("ACE_Win32_Thread_Adapter::ACE_Win32_Thread_Adapter");
+}
+
+void *
+ACE_Win32_Thread_Adapter::svc_run (ACE_Win32_Thread_Adapter *thread_args)
+{
+// ACE_TRACE ("ACE_Win32_Thread_Adapter::svc_run");
+  ACE_THR_FUNC func = thread_args->func_;
+  void *arg = thread_args->arg_;
+  delete thread_args;
+  void *status;
+
+  ACE_SEH_TRY {
+    status = (*func) (arg);  // Call thread entry point.
+  }
+  ACE_SEH_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
+    // Here's where we might want to provide a hook to report this...
+    // As it stands now, we just catch all Win32 structured exceptions
+    // so that we can make sure to clean up correctly when the thread
+    // exits.
+  }
+
+  // If dropped off end, call destructors for thread-specific storage
+  // and exit.
+  ACE_TSS_Cleanup::instance ()->exit (status);
+
+  /* NOTREACHED */
+  return status;
+}
+
+#endif // WIN32
+
+int
+ACE_OS::thr_create (ACE_THR_FUNC func,
+		    void *args,
+		    long flags,
+		    ACE_thread_t *thr_id,
+		    ACE_hthread_t *thr_handle,
+                    u_int priority,
+		    void *stack,
+		    size_t stacksize)
+{
+// ACE_TRACE ("ACE_OS::thr_create");
+
+#if defined (ACE_HAS_THREADS)
+#if defined (ACE_HAS_DCETHREADS) || defined (ACE_HAS_PTHREADS)
+  int result;
+  pthread_attr_t attr;
+  ACE_thread_t tmp_thr;
+  ACE_thread_t *p_thr;
+
+#if defined (ACE_HAS_SETKIND_NP)
+  if (::pthread_attr_create (&attr) != 0)
+#else /* ACE_HAS_SETKIND_NP */
+  if (::pthread_attr_init (&attr) != 0)
+#endif /* ACE_HAS_SETKIND_NP */
+    return -1;
+  else if (priority != 0)
+    {
+      struct sched_param sparam;
+
+      ACE_OS::memset ((void *) &sparam, 0, sizeof sparam);
+
+#if defined (ACE_HAS_DCETHREADS) && !defined (ACE_HAS_SETKIND_NP)
+      sparam.sched_priority = priority > PRIORITY_MAX ? PRIORITY_MAX : priority;
+#elif defined(ACE_HAS_IRIX62_THREADS)
+      sparam.sched_priority = priority > PTHREAD_MAX_PRIORITY ? PTHREAD_MAX_PRIORITY : priority;
+#elif defined (PTHREAD_MAX_PRIORITY) // For MIT pthreads...
+      sparam.prio = priority > PTHREAD_MAX_PRIORITY ? PTHREAD_MAX_PRIORITY : priority;
+#endif /* ACE_HAS_DCETHREADS */
+
+#if !defined (ACE_HAS_FSU_PTHREADS)
+#if defined (ACE_HAS_SETKIND_NP)
+      if (::pthread_attr_setsched (&attr, SCHED_OTHER) != 0)
+#else /* ACE_HAS_SETKIND_NP */
+      if (::pthread_attr_setschedparam (&attr, &sparam) != 0)
+#endif /* ACE_HAS_SETKIND_NP */
+	{
+#if defined (ACE_HAS_SETKIND_NP)
+	  ::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+	  ::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+	  return -1;
+	}
+#else
+      if ((sparam.sched_priority >= PTHREAD_MIN_PRIORITY)
+	  && (sparam.sched_priority <= PTHREAD_MAX_PRIORITY))
+	attr.prio = sparam.sched_priority;
+      else
+	{
+	  pthread_attr_destroy (&attr);
+	  return -1;
+	}
+#endif	//  ACE_HAS_FSU_PTHREADS
+    }
+
+    if (stacksize != 0)
+      {
+	size_t size = stacksize;
+
+#if defined (PTHREAD_STACK_MIN)
+	if (size < PTHREAD_STACK_MIN)
+	  stacksize = PTHREAD_STACK_MIN;
+#endif /* PTHREAD_STACK_MIN */
+
+	if (::pthread_attr_setstacksize (&attr, size) != 0)
+	  {
+#if defined (ACE_HAS_SETKIND_NP)
+	    ::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+	    ::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+	    return -1;
+	  }
+      }
+
+#if !defined (ACE_LACKS_THREAD_STACK_ADDR)
+    if (stack != 0)
+      {
+	if (::pthread_attr_setstackaddr (&attr, stack) != 0)
+	  {
+#if defined (ACE_HAS_SETKIND_NP)
+	    ::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+	    ::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+	    return -1;
+	  }
+      }
+#endif /* !ACE_LACKS_THREAD_STACK_ADDR */
+    if (flags != 0)
+      {
+#if !defined (ACE_LACKS_SETDETACH)
+	if (ACE_BIT_ENABLED (flags, THR_DETACHED) 
+	    || ACE_BIT_ENABLED (flags, THR_JOINABLE))
+	  {
+	    int dstate = PTHREAD_CREATE_JOINABLE; 
+
+	    if (ACE_BIT_ENABLED (flags, THR_DETACHED))
+	      dstate = PTHREAD_CREATE_DETACHED;
+
+#if defined (ACE_HAS_SETKIND_NP)
+	    if (::pthread_attr_setdetach_np (&attr, dstate) != 0)
+#else /* ACE_HAS_SETKIND_NP */
+	    if (::pthread_attr_setdetachstate (&attr, dstate) != 0)
+#endif /* ACE_HAS_SETKIND_NP */
+	      {
+#if defined (ACE_HAS_SETKIND_NP)
+		::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+		::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+		return -1;
+	      }
+	  }
+#endif /* ACE_LACKS_SETDETACH */
+	if (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO)
+	    || ACE_BIT_ENABLED (flags, THR_SCHED_RR)
+	    || ACE_BIT_ENABLED (flags, THR_SCHED_DEFAULT))
+	  {
+	    int spolicy;
+
+	    if (ACE_BIT_ENABLED (flags, THR_SCHED_DEFAULT))
+	      spolicy = SCHED_OTHER;
+	    else if (ACE_BIT_ENABLED (flags, THR_SCHED_FIFO))
+	      spolicy = SCHED_FIFO;
+	    else
+	      spolicy = SCHED_RR;
+
+#if !defined (ACE_HAS_FSU_PTHREADS)
+#if defined (ACE_HAS_SETKIND_NP)
+	    if (::pthread_attr_setsched (&attr, spolicy) != 0)
+#else /* ACE_HAS_SETKIND_NP */
+	    if (::pthread_attr_setschedpolicy (&attr, spolicy) != 0)
+#endif /* ACE_HAS_SETKIND_NP */
+	      {
+#if defined (ACE_HAS_SETKIND_NP)
+		::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+		::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+		return -1;
+	      }
+#else
+	    int ret;
+	    switch (spolicy)
+	      {
+	      case SCHED_FIFO:
+	      case SCHED_RR:
+		ret = 0;
+		break;
+	      default:
+		ret = 22;
+		break;
+	      }
+	    if (ret != 0)
+	      {
+#if defined (ACE_HAS_SETKIND_NP)
+		::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+		::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+		return -1;
+	      }
+#endif	//  ACE_HAS_FSU_PTHREADS
+	  }
+
+	if (ACE_BIT_ENABLED (flags, THR_INHERIT_SCHED)
+	    || ACE_BIT_ENABLED (flags, THR_EXPLICIT_SCHED))
+	  {
+#if defined (ACE_HAS_SETKIND_NP)
+	    int sched = PTHREAD_DEFAULT_SCHED;
+#else /* ACE_HAS_SETKIND_NP */
+	    int sched = PTHREAD_EXPLICIT_SCHED;
+#endif /* ACE_HAS_SETKIND_NP */
+	    if (ACE_BIT_ENABLED (flags, THR_INHERIT_SCHED))
+	      sched = PTHREAD_INHERIT_SCHED;
+	    if (::pthread_attr_setinheritsched (&attr, sched) != 0)
+	      {
+#if defined (ACE_HAS_SETKIND_NP)
+		::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+		::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+		return -1;
+	      }
+	  }
+#if !defined (ACE_LACKS_THREAD_PROCESS_SCOPING)
+	if (ACE_BIT_ENABLED (flags, THR_SCOPE_SYSTEM)
+	    || ACE_BIT_ENABLED (flags, THR_SCOPE_PROCESS))
+	  {
+	    int scope = PTHREAD_SCOPE_PROCESS;
+	    if (ACE_BIT_ENABLED (flags, THR_SCOPE_SYSTEM))
+	      scope = PTHREAD_SCOPE_SYSTEM;
+
+	    if (::pthread_attr_setscope (&attr, scope) != 0)
+	      {
+#if defined (ACE_HAS_SETKIND_NP)
+		::pthread_attr_delete (&attr);
+#else /* ACE_HAS_SETKIND_NP */
+		::pthread_attr_destroy (&attr);
+#endif /* ACE_HAS_SETKIND_NP */
+		return -1;
+	      }
+	  }
+#endif /* !ACE_LACKS_THREAD_PROCESS_SCOPING */
+
+	if (ACE_BIT_ENABLED (flags, THR_NEW_LWP))
+	  {
+	    // Increment the number of LWPs by one to emulate the
+	    // Solaris semantics.
+	    int lwps = ACE_OS::thr_getconcurrency ();
+	    ACE_OS::thr_setconcurrency (lwps + 1);
+	  }
+      }
+
+      p_thr = (thr_id == 0 ? &tmp_thr : thr_id);
+
+#if defined (ACE_HAS_SETKIND_NP)
+      ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_create (p_thr, attr, func, args), 
+				    result),
+		  int, -1, result);
+      ::pthread_attr_delete (&attr);
+      if (thr_handle != 0)
+	thr_handle = (ACE_hthread_t *) 0;
+#else /* ACE_HAS_SETKIND_NP */
+      ACE_OSCALL (ACE_ADAPT_RETVAL (::pthread_create (p_thr, &attr, func, args), 
+				    result),
+		  int, -1, result);
+      ::pthread_attr_destroy (&attr);
+      if (thr_handle != 0)
+	*thr_handle = (ACE_hthread_t) 0;
+#endif /* ACE_HAS_SETKIND_NP */
+
+      return result;
+#elif defined (ACE_HAS_STHREADS)
+      int result;
+      ACE_OSCALL (ACE_ADAPT_RETVAL (::thr_create (stack, stacksize, func, args,
+						  flags, thr_id), result), 
+		  int, -1, result);
+      if (result == 0 && thr_handle != 0)
+	*thr_handle = *thr_id;
+      return result;
+#elif defined (ACE_HAS_WTHREADS)
+      ACE_thread_t t;
+      ACE_hthread_t handle;
+
+      if (thr_id == 0)
+	thr_id = &t;
+      if (thr_handle == 0)
+	thr_handle = &handle;
+
+      ACE_Win32_Thread_Adapter *thread_args;
+  
+      ACE_NEW_RETURN (thread_args, ACE_Win32_Thread_Adapter (func, args), -1);
+
+      typedef unsigned (__stdcall *ThreadFunc) (void*);
+
+#if defined (ACE_HAS_MFC)
+      if (ACE_BIT_ENABLED (flags, THR_USE_AFX))
+	{
+	  CWinThread *cwin_thread = 
+	    // These aren't the right arguments (yet).
+	    ::AfxBeginThread ((ThreadFunc) (ACE_Win32_Thread_Adapter::svc_run),
+			      thread_args, 0, 0, flags);
+	  *thr_handle = cwin_thread->m_hThread;
+	  *thr_id = cwin_thread->m_nThreadID;
+	  // Can we delete the memory of cwin_thread here?
+	}
+      else
+#endif /* ACE_HAS_MFC */
+	*thr_handle = (void *) ::_beginthreadex 
+	  (NULL,
+	   stacksize,
+	   (ThreadFunc) (ACE_Win32_Thread_Adapter::svc_run),
+	   thread_args,
+	   flags,
+	   (unsigned int *) thr_id);
+
+#if 0
+      *thr_handle = ::CreateThread 
+	 (NULL, stacksize,
+	  LPTHREAD_START_ROUTINE (ACE_Win32_Thread_Adapter::svc_run),
+	  thread_args, flags, thr_id);
+#endif /* 0 */
+
+      // Close down the handle if no one wants to use it.
+      if (thr_handle == &handle)
+	::CloseHandle (thr_handle);
+
+      if (*thr_handle != 0)
+	return 0;
+      else
+	ACE_FAIL_RETURN (-1);
+      /* NOTREACHED */
+#elif defined (VXWORKS)
+      // If thr_id points to NULL (or is 0), the call below causes VxWorks
+      // to assign a unique task name of the form:  "t" + an integer.
+
+      // args must be an array of _exactly_ 10 ints.
+
+      // stack arg is ignored:  if there's a need for it, we'd have to use
+      // taskInit ()/taskActivate () instead of taskSpawn ()
+
+      // The hard-coded arguments are what ::sp() would use.  ::taskInit()
+      // is used instead of ::sp() so that we can set the priority, flags,
+      // and stacksize.  (::sp() also hardcodes priority to 100, flags
+      // to VX_FP_TASK, and stacksize to 20,000.)  stacksize should be
+      // an even integer.
+
+      // if called with thr_create() defaults, use same default values as ::sp()
+      if ( stacksize == 0 ) stacksize = 20000;
+      if ( priority == 0 ) priority = 100;
+
+      ACE_hthread_t tid = ::taskSpawn (thr_id == 0 ? NULL : *thr_id, priority,
+                                       (int) flags, (int) stacksize, func,
+                                       ((int *) args)[0], ((int *) args)[1],
+                                       ((int *) args)[2], ((int *) args)[3],
+                                       ((int *) args)[4], ((int *) args)[5],
+                                       ((int *) args)[6], ((int *) args)[7],
+                                       ((int *) args)[8], ((int *) args)[9]);
+
+      if ( tid == ERROR )
+        return -1;
+      else
+        {
+          // return the thr_id and thr_handle, if addresses were provided for them
+          if ( thr_id != 0 )
+            // taskTcb (int tid) returns the address of the WIND_TCB
+            // (task control block).  According to the taskSpawn()
+            // documentation, the name of the new task is stored at
+            // pStackBase, but is that of the current task?  If so, it
+            // would be a bit quicker than this extraction of the tcb . . .
+            *thr_id = taskTcb (tid)->name;
+          if ( thr_handle != 0 )
+            *thr_handle = tid;
+          return 0;
+        }
+
+#endif /* ACE_HAS_STHREADS */
+#else
+      ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_THREADS */		
+}
+
+void 
+ACE_OS::thr_exit (void *status)
+{
+// ACE_TRACE ("ACE_OS::thr_exit");
+#if defined (ACE_HAS_THREADS)
+#if defined (ACE_HAS_DCETHREADS) || defined (ACE_HAS_PTHREADS)
+  ::pthread_exit (status);
+#elif defined (ACE_HAS_STHREADS)
+  ::thr_exit (status);
+#elif defined (ACE_HAS_WTHREADS)
+  // Cleanup the thread-specific resources and exit.
+  ACE_TSS_Cleanup::instance ()->exit (status);
+#elif defined (VXWORKS)
+  *((int *) status) = ::taskDelete (ACE_OS::thr_self ());
+#endif /* ACE_HAS_STHREADS */
+#else
+  ;
+#endif /* ACE_HAS_THREADS */		     
+}
+
+int 
+ACE_OS::thr_setspecific (ACE_thread_key_t key, void *data)
+{
+// ACE_TRACE ("ACE_OS::thr_setspecific");
+#if defined (ACE_HAS_THREADS)
+#if defined (ACE_HAS_DCETHREADS) || defined (ACE_HAS_PTHREADS)
+#if defined (ACE_HAS_FSU_PTHREADS)
+// Call pthread_init() here to initialize threads package.  FSU
+// threads need an initialization before the first thread constructor.
+// This seems to be the one; however, a segmentation fault may
+// indicate that another pthread_init() is necessary, perhaps in
+// Synch.cpp or Synch_T.cpp.  FSU threads will not reinit if called
+// more than once, so another call to pthread_init will not adversely
+// affect existing threads.
+  pthread_init ();
+#endif 	//  ACE_HAS_FSU_PTHREADS
+  ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_setspecific (key, data), _result), 
+		     int, -1);
+#elif defined (ACE_HAS_STHREADS)
+  ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setspecific (key, data), _result), int, -1);
+#elif defined (ACE_HAS_WTHREADS)
+  ::TlsSetValue (key, data);
+  ACE_TSS_Cleanup::instance ()->key_used (key);
+  return 0;
+#elif defined (VXWORKS)
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_STHREADS */
+#else
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_THREADS */
+}
+
+int 
+ACE_OS::thr_keyfree (ACE_thread_key_t key)
+{
+// ACE_TRACE ("ACE_OS::thr_keyfree");
+#if defined (ACE_HAS_THREADS)
+#if defined (ACE_LACKS_KEYDELETE)
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_HAS_PTHREADS) && !defined (ACE_HAS_FSU_PTHREADS)
+  return ::pthread_key_delete (key);
+#elif defined (ACE_HAS_DCETHREADS) 
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_HAS_STHREADS)
+  ACE_NOTSUP_RETURN (-1);
+#elif defined (ACE_HAS_WTHREADS)
+  // Extract out the thread-specific table instance and and free up
+  // the key and destructor.
+  ACE_TSS_Cleanup::instance ()->remove (key);
+  ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::TlsFree (key), _result), int, -1);
+#elif defined (VXWORKS)
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_STHREADS */
+#else
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_THREADS */
+}
+
+int 
+ACE_OS::thr_keycreate (ACE_thread_key_t *key, 
+		       void (*dest) (void *),
+		       void *inst)
+{
+// ACE_TRACE ("ACE_OS::thr_keycreate");
+#if defined (ACE_HAS_THREADS)
+#if defined (ACE_HAS_DCETHREADS) || defined (ACE_HAS_PTHREADS)
+#if defined (ACE_HAS_SETKIND_NP)
+  ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_keycreate (key, dest), 
+                                       _result), 
+                     int, -1);
+#else /* ACE_HAS_SETKIND_NP */
+  ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_key_create (key, dest), 
+                                       _result), 
+                     int, -1);
+#endif /* ACE_HAS_SETKIND_NP */
+#elif defined (ACE_HAS_STHREADS)
+  ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_keycreate (key, dest), 
+				       _result), 
+		     int, -1);
+#elif defined (ACE_HAS_WTHREADS)
+  *key = ::TlsAlloc ();
+
+  if (*key != ACE_SYSCALL_FAILED)
+    // Extract out the thread-specific table instance and stash away
+    // the key and destructor so that we can free it up later on...
+    return ACE_TSS_Cleanup::instance ()->insert (*key, dest, inst);
+  else
+    ACE_FAIL_RETURN (-1);
+    /* NOTREACHED */
+
+#elif defined (VXWORKS)
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_STHREADS */
+#else
+  ACE_NOTSUP_RETURN (-1);
+#endif /* ACE_HAS_THREADS */		     
+}
+
+int 
+ACE_OS::thr_key_used (ACE_thread_key_t key)
+{
+#if defined (ACE_WIN32)
+  return ACE_TSS_Cleanup::instance ()->key_used (key);
+#else
+  ACE_NOTSUP_RETURN (-1);  
+#endif /* ACE_WIN32 */
+}
+
+int 
+ACE_OS::thr_key_detach (void *inst)
+{
+#if defined (ACE_WIN32)
+  return ACE_TSS_Cleanup::instance()->detach (inst);
+#else
+  ACE_NOTSUP_RETURN (-1);  
+#endif /* ACE_WIN32 */
+}
+
+// Create a contiguous command-line argument buffer with each arg
+// separated by spaces.
+
+pid_t
+ACE_OS::fork_exec (char *argv[])
+{
+#if defined (ACE_WIN32)
+  ACE_ARGV argv_buf (argv);
+
+  char *buf = argv_buf.buf ();
+
+  if (buf != 0)
+    {
+      PROCESS_INFORMATION process_info;
+      STARTUPINFO startup_info;
+      ACE_OS::memset ((void *) &startup_info, 0, sizeof startup_info);
+      startup_info.cb = sizeof startup_info;
+
+      if (::CreateProcess (NULL,
+			   buf,
+			   NULL, // No process attributes.
+			   NULL,  // No thread attributes.
+			   TRUE, // Allow handle inheritance.
+			   CREATE_NEW_CONSOLE, // Create a new console window.
+			   NULL, // No environment.
+			   NULL, // No current directory.
+			   &startup_info,
+			   &process_info))
+	{
+	  // Free resources allocated in kernel.
+	  ACE_OS::close (process_info.hThread);
+	  ACE_OS::close (process_info.hProcess);
+	  // Return new process id.
+	  return process_info.dwProcessId;
+	}
+    }
+
+  // CreateProcess failed.
+  return -1; 
+#else
+      pid_t result = ACE_OS::fork ();
+
+      switch (result)
+	{
+	case -1:
+	  // Error.
+	  return -1;
+	case 0:
+	  // Child process.
+	  if (ACE_OS::execv (argv[0], argv) == -1)
+	    {
+	      ACE_ERROR ((LM_ERROR, "%p Exec failed\n"));
+
+	      // If the execv fails, this child needs to exit.
+	      ACE_OS::exit (errno);
+	    }
+	default:
+	  // Server process.  The fork succeeded.
+	  return result;
+	}
+#endif /* ACE_WIN32 */
+    }
+
+#if defined (ACE_NEEDS_WRITEV)
+
+// "Fake" writev for sites without it.  Note that this is totally
+// broken for multi-threaded applications since the <send_n> calls are
+// not atomic...
+
+extern "C" int
+writev (ACE_HANDLE handle, ACE_WRITEV_TYPE *vp, int vpcount)
+{
+// ACE_TRACE ("::writev");
+
+  int count;
+
+  for (count = 0; --vpcount >= 0; count += vp->iov_len, vp++)
+    if (ACE::send_n (handle, vp->iov_base, vp->iov_len) < 0)
+      return -1;
+
+  return count;
+}
+#endif /* ACE_NEEDS_WRITEV */
+
+#if defined (ACE_NEEDS_READV)
+
+// "Fake" readv for sites without it.  Note that this is totally
+// broken for multi-threaded applications since the <send_n> calls are
+// not atomic...
+
+extern "C" int
+readv (ACE_HANDLE handle, struct iovec *vp, int vpcount)
+{
+// ACE_TRACE ("::readv");
+
+  int count;
+
+  for (count = 0; --vpcount >= 0; count += vp->iov_len, vp++)
+    if (ACE::recv_n (handle, vp->iov_base, vp->iov_len) < 0)
+      return -1;
+
+  return count;
+}
+#endif /* ACE_NEEDS_READV */
+
+#if defined (ACE_NEEDS_FTRUNCATE)
+extern "C" int
+ftruncate (ACE_HANDLE handle, long len)
+{
+  struct flock fl;
+  fl.l_whence = 0;
+  fl.l_len = 0;
+  fl.l_start = len;
+  fl.l_type = F_WRLCK;
+
+  return ::fcntl (handle, F_FREESP, &fl);
+}
+#endif /* ACE_NEEDS_FTRUNCATE */
+
+char *
+ACE_OS::mktemp (char *s)
+{
+  // ACE_TRACE ("ACE_OS::mktemp");
+#if defined (ACE_LACKS_MKTEMP)
+  if (s == 0) 
+    // check for null template string failed!
+    return 0;
+  else
+    {
+      char *xxxxxx = ACE_OS::strstr (s, "XXXXXX");
+
+      if (xxxxxx == 0)
+        // the template string doesn't contain "XXXXXX"!
+        return s;
+      else
+        {
+          char unique_letter = 'a';
+          struct stat sb;
+
+          // Find an unused filename for this process.  It is assumed
+          // that the user will open the file immediately after
+          // getting this filename back (so, yes, there is a race
+          // condition if multiple threads in a process use the same
+          // template).  This appears to match the behavior of the
+          // Solaris 2.5 mktemp().
+          ::sprintf (xxxxxx, "%05d%c", getpid (), unique_letter);
+          while (::stat (s, &sb) >= 0)
+            {
+	      if (++unique_letter <= 'z')
+		::sprintf (xxxxxx, "%05d%c", getpid (), unique_letter);
+	      else
+		{
+		  // maximum of 26 unique files per template, per process
+		  ::sprintf (xxxxxx, "%s", "");
+		  return s;
+		}
+            }
+        }
+      return s;
+    }
+  
+#else
+  return ::mktemp (s);
+#endif /* ACE_LACKS_MKTEMP */
+}
+
+int
+ACE_OS::socket_init (int version_high, int version_low)
+{
+#if defined (ACE_WIN32)
+  if (ACE_OS::socket_initialized_ == 0)
+    {
+      WORD version_requested = MAKEWORD (version_high, version_low);
+      WSADATA wsa_data;
+      int error = ::WSAStartup (version_requested, &wsa_data);
+
+      if (error != 0)
+	ACE_ERROR_RETURN ((LM_ERROR, 
+			   "WSAStartup failed, WSAGetLastError returned %u.\n",
+			   error), -1);
+
+      ACE_OS::socket_initialized_ = 1;
+    }
+#endif /* ACE_WIN32 */
+  return 0;
+}
+
+int
+ACE_OS::socket_fini (void)
+{
+#if defined (ACE_WIN32)
+  if (ACE_OS::socket_initialized_ != 0)
+    {
+      if (::WSACleanup () != 0)
+	{
+	  int error = ::WSAGetLastError ();
+	  ACE_ERROR_RETURN ((LM_ERROR, 
+			     "WSACleanup failed, WSAGetLastError returned %u.\n", 
+			     error), -1);
+	}
+      ACE_OS::socket_initialized_ = 0;
+    }
+#endif /* ACE_WIN32 */
+  return 0;
+}
+
+#if defined (VXWORKS)
+int sys_nerr = ERRMAX + 1;
+#endif /* VXWORKS */