4 files changed, 127 insertions, 21 deletions

diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index 545e76c..6a3135e 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -247,7 +247,7 @@ namespace OpenSim.Framework.Servers
             string reportFormat = "{0,6}   {1,35}   {2,16}   {3,13}   {4,10}   {5,30}";
 
             StringBuilder sb = new StringBuilder();
-            Watchdog.ThreadWatchdogInfo[] threads = Watchdog.GetThreads();
+            Watchdog.ThreadWatchdogInfo[] threads = Watchdog.GetThreadsInfo();
 
             sb.Append(threads.Length + " threads are being tracked:" + Environment.NewLine);
 
@@ -308,7 +308,9 @@ namespace OpenSim.Framework.Servers
             // clr version potentially is more confusing than helpful, since it doesn't tell us if we're running under Mono/MS .NET and
             // the clr version number doesn't match the project version number under Mono.
             //m_log.Info("[STARTUP]: Virtual machine runtime version: " + Environment.Version + Environment.NewLine);
-            m_log.Info("[STARTUP]: Operating system version: " + Environment.OSVersion + Environment.NewLine);
+            m_log.InfoFormat(
+                "[STARTUP]: Operating system version: {0}, .NET platform {1}, {2}-bit\n",
+                Environment.OSVersion, Environment.OSVersion.Platform, Util.Is64BitProcess() ? "64" : "32");
             
             StartupSpecific();
             
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 2206feb..0062d4e 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -65,6 +65,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                         String.Format("PollServiceWorkerThread{0}", i),
                         ThreadPriority.Normal,
                         false,
+                        true,
                         int.MaxValue);
             }
 
@@ -73,6 +74,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 "PollServiceWatcherThread",
                 ThreadPriority.Normal,
                 false,
+                true,
                 1000 * 60 * 10);
         }
 
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 4b0b13c..efa4a7b 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -35,7 +35,8 @@ using System.IO;
 using System.IO.Compression;
 using System.Net;
 using System.Net.Sockets;
-using System.Reflection;
+using System.Reflection;

+using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
 using System.Security.Cryptography;
@@ -375,6 +376,50 @@ namespace OpenSim.Framework
             }
 
             return sb.ToString();
+        }

+

+        /// <summary>

+        /// Is the platform Windows?

+        /// </summary>

+        /// <returns>true if so, false otherwise</returns>

+        public static bool IsWindows()

+        {

+            PlatformID platformId = Environment.OSVersion.Platform;

+

+            return (platformId == PlatformID.Win32NT

+                || platformId == PlatformID.Win32S

+                || platformId == PlatformID.Win32Windows

+                || platformId == PlatformID.WinCE);

+        }
+
+        public static bool LoadArchSpecificWindowsDll(string libraryName)
+        {
+            // We do this so that OpenSimulator on Windows loads the correct native library depending on whether
+            // it's running as a 32-bit process or a 64-bit one.  By invoking LoadLibary here, later DLLImports
+            // will find it already loaded later on.
+            //
+            // This isn't necessary for other platforms (e.g. Mac OSX and Linux) since the DLL used can be
+            // controlled in config files.
+            string nativeLibraryPath;
+
+            if (Util.Is64BitProcess())
+                nativeLibraryPath = "lib64/" + libraryName;
+            else
+                nativeLibraryPath = "lib32/" + libraryName;
+
+            m_log.DebugFormat("[UTIL]: Loading native Windows library at {0}", nativeLibraryPath);
+
+            if (Util.LoadLibrary(nativeLibraryPath) == IntPtr.Zero)
+            {
+                m_log.ErrorFormat(
+                    "[UTIL]: Couldn't find native Windows library at {0}", nativeLibraryPath);
+
+                return false;
+            }
+            else
+            {
+                return true;
+            }
         }
 
         public static bool IsEnvironmentSupported(ref string reason)
@@ -1457,6 +1502,27 @@ namespace OpenSim.Framework
             }
 
             return data;
+        }

+

+        /// <summary>

+        /// Used to trigger an early library load on Windows systems.

+        /// </summary>

+        /// <remarks>

+        /// Required to get 32-bit and 64-bit processes to automatically use the

+        /// appropriate native library.

+        /// </remarks>

+        /// <param name="dllToLoad"></param>

+        /// <returns></returns>

+        [DllImport("kernel32.dll")]

+        public static extern IntPtr LoadLibrary(string dllToLoad);

+

+        /// <summary>

+        /// Determine whether the current process is 64 bit

+        /// </summary>

+        /// <returns>true if so, false if not</returns>

+        public static bool Is64BitProcess()

+        {

+            return IntPtr.Size == 8;

         }
 
         #region FireAndForget Threading Pattern
diff --git a/OpenSim/Framework/Watchdog.cs b/OpenSim/Framework/Watchdog.cs
index 2dd6ebe..e93e50e 100644
--- a/OpenSim/Framework/Watchdog.cs
+++ b/OpenSim/Framework/Watchdog.cs
@@ -72,6 +72,11 @@ namespace OpenSim.Framework
             /// </summary>
             public bool IsTimedOut { get; set; }
 
+            /// <summary>
+            /// Will this thread trigger the alarm function if it has timed out?
+            /// </summary>
+            public bool AlarmIfTimeout { get; set; }
+
             public ThreadWatchdogInfo(Thread thread, int timeout)
             {
                 Thread = thread;
@@ -112,12 +117,13 @@ namespace OpenSim.Framework
         /// <param name="start">The method that will be executed in a new thread</param>
         /// <param name="name">A name to give to the new thread</param>
         /// <param name="priority">Priority to run the thread at</param>
-        /// <param name="isBackground">True to run this thread as a background
-        /// thread, otherwise false</param>
+        /// <param name="isBackground">True to run this thread as a background thread, otherwise false</param>
+        /// <param name="alarmIfTimeout">Trigger an alarm function is we have timed out</param>
         /// <returns>The newly created Thread object</returns>
-        public static Thread StartThread(ThreadStart start, string name, ThreadPriority priority, bool isBackground)
+        public static Thread StartThread(
+            ThreadStart start, string name, ThreadPriority priority, bool isBackground, bool alarmIfTimeout)
         {
-            return StartThread(start, name, priority, isBackground, WATCHDOG_TIMEOUT_MS);
+            return StartThread(start, name, priority, isBackground, alarmIfTimeout, WATCHDOG_TIMEOUT_MS);
         }
 
         /// <summary>
@@ -128,21 +134,21 @@ namespace OpenSim.Framework
         /// <param name="priority">Priority to run the thread at</param>
         /// <param name="isBackground">True to run this thread as a background
         /// thread, otherwise false</param>
-        /// <param name="timeout">
-        /// Number of milliseconds to wait until we issue a warning about timeout.
-        /// </para>
+        /// <param name="alarmIfTimeout">Trigger an alarm function is we have timed out</param>
+        /// <param name="timeout">Number of milliseconds to wait until we issue a warning about timeout.</param>
         /// <returns>The newly created Thread object</returns>
         public static Thread StartThread(
-            ThreadStart start, string name, ThreadPriority priority, bool isBackground, int timeout)
+            ThreadStart start, string name, ThreadPriority priority, bool isBackground, bool alarmIfTimeout, int timeout)
         {
             Thread thread = new Thread(start);
             thread.Name = name;
             thread.Priority = priority;
             thread.IsBackground = isBackground;
             
-            ThreadWatchdogInfo twi = new ThreadWatchdogInfo(thread, timeout);
+            ThreadWatchdogInfo twi = new ThreadWatchdogInfo(thread, timeout) { AlarmIfTimeout = alarmIfTimeout };
 
-            m_log.Debug("[WATCHDOG]: Started tracking thread \"" + twi.Thread.Name + "\" (ID " + twi.Thread.ManagedThreadId + ")");
+            m_log.DebugFormat(
+                "[WATCHDOG]: Started tracking thread {0}, ID {1}", twi.Thread.Name, twi.Thread.ManagedThreadId);
 
             lock (m_threads)
                 m_threads.Add(twi.Thread.ManagedThreadId, twi);
@@ -224,19 +230,39 @@ namespace OpenSim.Framework
         /// Get currently watched threads for diagnostic purposes
         /// </summary>
         /// <returns></returns>
-        public static ThreadWatchdogInfo[] GetThreads()
+        public static ThreadWatchdogInfo[] GetThreadsInfo()
         {
             lock (m_threads)
                 return m_threads.Values.ToArray();
         }
 
+        /// <summary>
+        /// Return the current thread's watchdog info.
+        /// </summary>
+        /// <returns>The watchdog info.  null if the thread isn't being monitored.</returns>
+        public static ThreadWatchdogInfo GetCurrentThreadInfo()
+        {
+            lock (m_threads)
+            {
+                if (m_threads.ContainsKey(Thread.CurrentThread.ManagedThreadId))
+                    return m_threads[Thread.CurrentThread.ManagedThreadId];
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Check watched threads.  Fire alarm if appropriate.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private static void WatchdogTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
         {
             WatchdogTimeout callback = OnWatchdogTimeout;
 
             if (callback != null)
             {
-                ThreadWatchdogInfo timedOut = null;
+                List<ThreadWatchdogInfo> callbackInfos = null;
 
                 lock (m_threads)
                 {
@@ -246,21 +272,31 @@ namespace OpenSim.Framework
                     {
                         if (threadInfo.Thread.ThreadState == ThreadState.Stopped)
                         {
-                            timedOut = threadInfo;
                             RemoveThread(threadInfo.Thread.ManagedThreadId);
-                            break;
+
+                            if (callbackInfos == null)
+                                callbackInfos = new List<ThreadWatchdogInfo>();
+
+                            callbackInfos.Add(threadInfo);
                         }
                         else if (!threadInfo.IsTimedOut && now - threadInfo.LastTick >= threadInfo.Timeout)
                         {
                             threadInfo.IsTimedOut = true;
-                            timedOut = threadInfo;
-                            break;
+
+                            if (threadInfo.AlarmIfTimeout)
+                            {
+                                if (callbackInfos == null)
+                                    callbackInfos = new List<ThreadWatchdogInfo>();
+
+                                callbackInfos.Add(threadInfo);
+                            }
                         }
                     }
                 }
 
-                if (timedOut != null)
-                    callback(timedOut.Thread, timedOut.LastTick);
+                if (callbackInfos != null)
+                    foreach (ThreadWatchdogInfo callbackInfo in callbackInfos)
+                        callback(callbackInfo.Thread, callbackInfo.LastTick);
             }
 
             m_watchdogTimer.Start();