Initial Mangos Three Commit

2025-12-12 01:37:00 +00:00 · 2020-02-16 01:55:18 +00:00 · 2020-02-16 01:55:18 +00:00 · 7665a09232
commit 7665a09232
parent bb91aa5933
2444 changed files with 625144 additions and 0 deletions
--- a/dep/acelite/ace/Mutex.cpp
+++ b/dep/acelite/ace/Mutex.cpp
@ -0,0 +1,152 @@
+#include "ace/Mutex.h"
+
+#if !defined (__ACE_INLINE__)
+#include "ace/Mutex.inl"
+#endif /* __ACE_INLINE__ */
+
+#include "ace/Log_Category.h"
+#include "ace/OS_NS_string.h"
+#include "ace/os_include/sys/os_mman.h"
+#if defined (ACE_HAS_ALLOC_HOOKS)
+# include "ace/Malloc_Base.h"
+#endif /* ACE_HAS_ALLOC_HOOKS */
+
+ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ACE_ALLOC_HOOK_DEFINE (ACE_Mutex)
+
+void
+ACE_Mutex::dump (void) const
+{
+#if defined (ACE_HAS_DUMP)
+// ACE_TRACE ("ACE_Mutex::dump");
+
+  ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+# ifdef ACE_MUTEX_USE_PROCESS_LOCK
+  ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("lockname_ = %s\n"), this->lockname_));
+  ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("process_lock_ = %x\n"), this->process_lock_));
+# endif /* ACE_MUTEX_USE_PROCESS_LOCK */
+  ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
+  ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+#endif /* ACE_HAS_DUMP */
+}
+
+int
+ACE_Mutex::unlink (const ACE_TCHAR *name)
+{
+#ifdef ACE_MUTEX_PROCESS_LOCK_IS_SEMA
+  return ACE_OS::sema_unlink (ACE_TEXT_ALWAYS_CHAR (name));
+#else
+  ACE_UNUSED_ARG (name);
+  return 0;
+#endif
+}
+
+ACE_Mutex::ACE_Mutex (int type, const ACE_TCHAR *name,
+                      ACE_mutexattr_t *arg, mode_t mode)
+  :
+#ifdef ACE_MUTEX_USE_PROCESS_LOCK
+    process_lock_ (0),
+    lockname_ (0),
+#endif /* ACE_MUTEX_USE_PROCESS_LOCK */
+    removed_ (false)
+{
+  // ACE_TRACE ("ACE_Mutex::ACE_Mutex");
+
+  // These platforms need process-wide mutex to be in shared memory.
+#ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX
+  if (type == USYNC_PROCESS)
+    {
+      // Let's see if the shared memory entity already exists.
+      ACE_HANDLE fd = ACE_OS::shm_open (name, O_RDWR | O_CREAT | O_EXCL, mode);
+      if (fd == ACE_INVALID_HANDLE)
+        {
+          if (errno == EEXIST)
+            fd = ACE_OS::shm_open (name, O_RDWR | O_CREAT, mode);
+          else
+            return;
+        }
+      else
+        {
+          // We own this shared memory object!  Let's set its size.
+          if (ACE_OS::ftruncate (fd,
+                                 sizeof (ACE_mutex_t)) == -1)
+            {
+              ACE_OS::close (fd);
+              return;
+            }
+          this->lockname_ = ACE_OS::strdup (name);
+          if (this->lockname_ == 0)
+            {
+              ACE_OS::close (fd);
+              return;
+            }
+        }
+
+      this->process_lock_ =
+        (ACE_mutex_t *) ACE_OS::mmap (0,
+                                      sizeof (ACE_mutex_t),
+                                      PROT_RDWR,
+                                      MAP_SHARED,
+                                      fd,
+                                      0);
+      ACE_OS::close (fd);
+      if (this->process_lock_ == MAP_FAILED)
+        return;
+
+      if (this->lockname_
+          && ACE_OS::mutex_init (this->process_lock_,
+                                 type,
+                                 name,
+                                 arg) != 0)
+        {
+          ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
+                         ACE_TEXT ("ACE_Mutex::ACE_Mutex")));
+        }
+      return;
+    }
+
+#elif defined ACE_MUTEX_PROCESS_LOCK_IS_SEMA
+  ACE_UNUSED_ARG (mode);
+  if (type == USYNC_PROCESS)
+    {
+      if (name)
+        this->lockname_ = ACE_OS::strdup (name);
+      else
+        {
+          const size_t un_len = (ACE_UNIQUE_NAME_LEN + 1) * sizeof (ACE_TCHAR);
+          ACE_TCHAR *const un =
+# ifdef ACE_HAS_ALLOC_HOOKS
+            (ACE_TCHAR *) ACE_Allocator::instance ()->malloc (un_len);
+# else
+            (ACE_TCHAR *) ACE_OS::malloc (un_len);
+# endif /* ACE_HAS_ALLOC_HOOKS */
+          un[0] = ACE_TEXT ('/');
+          ACE_OS::unique_name (this, un + 1, ACE_UNIQUE_NAME_LEN);
+          this->lockname_ = un;
+        }
+
+      this->process_lock_ = &this->process_sema_;
+      if (ACE_OS::sema_init (&this->process_sema_, 1 /*mutex unlocked*/,
+                             USYNC_PROCESS, this->lockname_) != 0)
+        ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
+                       ACE_TEXT ("ACE_Mutex::ACE_Mutex")));
+      ACE_OS::sema_avoid_unlink (&this->process_sema_, true);
+      return;
+    }
+#else
+  ACE_UNUSED_ARG (mode);
+#endif /* ACE_MUTEX_PROCESS_LOCK_IS_MUTEX */
+
+  if (ACE_OS::mutex_init (&this->lock_, type, name, arg) != 0)
+    ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"),
+                   ACE_TEXT ("ACE_Mutex::ACE_Mutex")));
+}
+
+ACE_Mutex::~ACE_Mutex (void)
+{
+// ACE_TRACE ("ACE_Mutex::~ACE_Mutex");
+  this->remove ();
+}
+
+ACE_END_VERSIONED_NAMESPACE_DECL