// Dick Porter (dick@ximian.com)
//
// (C) Ximian, Inc. http://www.ximian.com
+// Copyright (C) 2004 Novell (http://www.novell.com)
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.Runtime.Remoting.Contexts;
+using System.Security.Permissions;
using System.Security.Principal;
using System.Globalization;
using System.Runtime.CompilerServices;
{
public sealed class Thread
{
+ #region Sync with object.h
// stores a thread handle
private IntPtr system_thread_handle;
private CultureInfo current_culture;
- private bool threadpool_thread = false;
+ private CultureInfo current_ui_culture;
+ private bool threadpool_thread;
+ /* accessed only from unmanaged code */
+ private IntPtr name;
+ private int name_len;
private ThreadState state = ThreadState.Unstarted;
private object abort_exc;
internal object abort_state;
* is ok to return
*/
private IntPtr start_notify;
+ private IntPtr stack_ptr;
+ private IntPtr static_data;
+ private IntPtr jit_data;
+ private IntPtr lock_data;
+ private IntPtr appdomain_refs;
+ private bool interruption_requested;
+ private IntPtr suspend_event;
+ private IntPtr resume_event;
+ private object synch_lock = new Object();
+ #endregion
+
+ private ThreadStart threadstart;
+ private string thread_name=null;
+
+ private IPrincipal _principal;
public static Context CurrentContext {
get {
}
}
- [MonoTODO]
public static IPrincipal CurrentPrincipal {
get {
- // FIXME -
- // System.Security.Principal.IPrincipal
- // not yet implemented
- return(null);
+ IPrincipal p = null;
+ Thread th = CurrentThread;
+ lock (th) {
+ p = th._principal;
+ if (p == null) {
+ p = GetDomain ().DefaultPrincipal;
+ th._principal = p;
+ }
+ }
+ return p;
}
-
set {
+ new SecurityPermission (SecurityPermissionFlag.ControlPrincipal).Demand ();
+ CurrentThread._principal = value;
}
}
return(slothash);
}
+
+ internal static object ResetDataStoreStatus () {
+ Hashtable slothash=SlotHash_lookup();
+ SlotHash_store(null);
+ return slothash;
+ }
+
+ internal static void RestoreDataStoreStatus (object data) {
+ SlotHash_store((Hashtable)data);
+ }
public static LocalDataStoreSlot AllocateDataSlot() {
LocalDataStoreSlot slot = new LocalDataStoreSlot();
// Stores a hash keyed by strings of LocalDataStoreSlot objects
static Hashtable datastorehash;
-
+ private static object datastore_lock = new object ();
+
private static void InitDataStoreHash () {
- lock (typeof (Thread)) {
+ lock (datastore_lock) {
if (datastorehash == null) {
datastorehash = Hashtable.Synchronized(new Hashtable());
}
}
public static LocalDataStoreSlot AllocateNamedDataSlot(string name) {
- if (datastorehash == null)
- InitDataStoreHash ();
- LocalDataStoreSlot slot = (LocalDataStoreSlot)datastorehash[name];
- if(slot!=null) {
- // This exception isnt documented (of
- // course) but .net throws it
- throw new ArgumentException("Named data slot already added");
- }
+ lock (datastore_lock) {
+ if (datastorehash == null)
+ InitDataStoreHash ();
+ LocalDataStoreSlot slot = (LocalDataStoreSlot)datastorehash[name];
+ if(slot!=null) {
+ // This exception isnt documented (of
+ // course) but .net throws it
+ throw new ArgumentException("Named data slot already added");
+ }
- slot = new LocalDataStoreSlot();
+ slot = new LocalDataStoreSlot();
- datastorehash.Add(name, slot);
-
- return(slot);
+ datastorehash.Add(name, slot);
+
+ return(slot);
+ }
}
public static void FreeNamedDataSlot(string name) {
- if (datastorehash == null)
- InitDataStoreHash ();
- LocalDataStoreSlot slot=(LocalDataStoreSlot)datastorehash[name];
+ lock (datastore_lock) {
+ if (datastorehash == null)
+ InitDataStoreHash ();
+ LocalDataStoreSlot slot=(LocalDataStoreSlot)datastorehash[name];
- if(slot!=null) {
- datastorehash.Remove(slot);
+ if(slot!=null) {
+ datastorehash.Remove(slot);
+ }
}
}
public extern static int GetDomainID();
public static LocalDataStoreSlot GetNamedDataSlot(string name) {
- if (datastorehash == null)
- InitDataStoreHash ();
- LocalDataStoreSlot slot=(LocalDataStoreSlot)datastorehash[name];
+ lock (datastore_lock) {
+ if (datastorehash == null)
+ InitDataStoreHash ();
+ LocalDataStoreSlot slot=(LocalDataStoreSlot)datastorehash[name];
- if(slot==null) {
- slot=AllocateNamedDataSlot(name);
- }
+ if(slot==null) {
+ slot=AllocateNamedDataSlot(name);
+ }
- return(slot);
+ return(slot);
+ }
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static void ResetAbort()
{
- Thread thread=CurrentThread;
-
- thread.clr_state(ThreadState.AbortRequested);
ResetAbort_internal();
}
object data) {
Hashtable slothash=GetTLSSlotHash();
- if(slothash[slot]!=null) {
+ if(slothash.Contains(slot)) {
slothash.Remove(slot);
}
throw new ArgumentException("Negative timeout");
}
Thread thread=CurrentThread;
-
- thread.set_state(ThreadState.WaitSleepJoin);
-
Sleep_internal(millisecondsTimeout);
- thread.clr_state(ThreadState.WaitSleepJoin);
}
public static void Sleep(TimeSpan timeout) {
}
Thread thread=CurrentThread;
-
- thread.set_state(ThreadState.WaitSleepJoin);
Sleep_internal(ms);
- thread.clr_state(ThreadState.WaitSleepJoin);
}
// Returns the system thread handle
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern IntPtr Thread_internal(ThreadStart start);
- private ThreadStart threadstart;
-
public Thread(ThreadStart start) {
if(start==null) {
throw new ArgumentNullException("Null ThreadStart");
}
threadstart=start;
-
- // This is a two-stage thread launch. Thread_internal
- // creates the new thread, but blocks it until
- // Start() is called later.
- system_thread_handle=Thread_internal(start);
-
- // Should throw an exception here if
- // Thread_internal returns NULL
}
[MonoTODO]
public ApartmentState ApartmentState {
get {
- // FIXME
return(ApartmentState.Unknown);
}
}
}
- [MonoTODO]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ private static extern int current_lcid ();
+
+ /* If the current_lcid() isn't known by CultureInfo,
+ * it will throw an exception which may cause
+ * String.Concat to try and recursively look up the
+ * CurrentCulture, which will throw an exception, etc.
+ * Use a boolean to short-circuit this scenario.
+ */
+ private static bool in_currentculture=false;
+
public CultureInfo CurrentCulture {
get {
- if (current_culture == null)
- current_culture = CultureInfo.InvariantCulture;
- return current_culture;
+ if (current_culture == null) {
+ lock (typeof (Thread)) {
+ if(current_culture==null) {
+ if(in_currentculture==true) {
+ /* Bail out */
+ current_culture = CultureInfo.InvariantCulture;
+ } else {
+ in_currentculture=true;
+
+ current_culture = CultureInfo.ConstructCurrentCulture ();
+ }
+ }
+
+ in_currentculture=false;
+ }
+ }
+
+ return(current_culture);
}
set {
}
}
- [MonoTODO]
public CultureInfo CurrentUICulture {
get {
- // FIXME
- return(CurrentCulture);
+ if (current_ui_culture == null) {
+ lock (synch_lock) {
+ if(current_ui_culture==null) {
+ /* We don't
+ * distinguish
+ * between
+ * System and
+ * UI cultures
+ */
+ current_ui_culture = CultureInfo.ConstructCurrentUICulture ();
+ }
+ }
+ }
+
+ return(current_ui_culture);
}
set {
- // FIXME
- CurrentCulture=value;
+ current_ui_culture = value;
}
}
}
}
- private string thread_name=null;
-
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ private extern string GetName_internal ();
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ private extern void SetName_internal (String name);
+
+ /*
+ * The thread name must be shared by appdomains, so it is stored in
+ * unmanaged code.
+ */
+
public string Name {
get {
- return(thread_name);
+ return GetName_internal ();
}
set {
- thread_name=value;
+ lock (synch_lock) {
+ if(Name!=null) {
+ throw new InvalidOperationException ("Thread.Name can only be set once.");
+ }
+
+ SetName_internal (value);
+ }
}
}
[MonoTODO]
public ThreadPriority Priority {
get {
- // FIXME
return(ThreadPriority.Lowest);
}
private extern void Abort_internal (object stateInfo);
public void Abort() {
- set_state(ThreadState.AbortRequested);
Abort_internal (null);
}
public void Abort(object stateInfo) {
- set_state(ThreadState.AbortRequested);
Abort_internal(stateInfo);
}
[MonoTODO]
public void Interrupt() {
- // FIXME
}
// The current thread joins with 'this'. Set ms to 0 to block
Thread thread=CurrentThread;
- thread.set_state(ThreadState.WaitSleepJoin);
Join_internal(Timeout.Infinite, system_thread_handle);
- thread.clr_state(ThreadState.WaitSleepJoin);
}
public bool Join(int millisecondsTimeout) {
}
Thread thread=CurrentThread;
-
- thread.set_state(ThreadState.WaitSleepJoin);
- bool ret=Join_internal(millisecondsTimeout,
- system_thread_handle);
- thread.clr_state(ThreadState.WaitSleepJoin);
-
- return(ret);
+ return Join_internal(millisecondsTimeout, system_thread_handle);
}
public bool Join(TimeSpan timeout) {
}
Thread thread=CurrentThread;
+ return Join_internal(ms, system_thread_handle);
+ }
- thread.set_state(ThreadState.WaitSleepJoin);
- bool ret=Join_internal(ms, system_thread_handle);
- thread.clr_state(ThreadState.WaitSleepJoin);
+#if NET_1_1
+ [MonoTODO ("seems required for multi-processors systems like Itanium")]
+ public static void MemoryBarrier ()
+ {
+ throw new NotImplementedException ();
+ }
+#endif
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ private extern void Resume_internal();
- return(ret);
+ public void Resume ()
+ {
+ if ((state & ThreadState.Unstarted) != 0 || !IsAlive ||
+ ((state & ThreadState.Suspended) == 0 && (state & ThreadState.SuspendRequested) == 0))
+ {
+ throw new ThreadStateException("Thread has not been started, or is dead");
+ }
+
+ Resume_internal ();
}
[MonoTODO]
- public void Resume() {
+ public static void SpinWait (int iterations)
+ {
throw new NotImplementedException ();
}
private extern void Start_internal(IntPtr handle);
public void Start() {
- lock(this) {
+ lock(synch_lock) {
if((state & ThreadState.Unstarted) == 0) {
throw new ThreadStateException("Thread has already been started");
}
+
+ // Thread_internal creates the new thread, but
+ // blocks it until Start() is called later.
+ system_thread_handle=Thread_internal(threadstart);
+
+ if (system_thread_handle == (IntPtr) 0) {
+ throw new SystemException ("Thread creation failed");
+ }
+
// Launch this thread
Start_internal(system_thread_handle);
}
}
- [MonoTODO]
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ private extern void Suspend_internal();
+
public void Suspend() {
if((state & ThreadState.Unstarted) != 0 || !IsAlive) {
throw new ThreadStateException("Thread has not been started, or is dead");
}
-
- set_state(ThreadState.SuspendRequested);
- // FIXME - somehow let the interpreter know that
- // this thread should now suspend
- Console.WriteLine ("WARNING: Thread.Suspend () partially implemented");
+ Suspend_internal ();
}
// Closes the system thread handle
~Thread() {
// Free up the handle
- Thread_free_internal(system_thread_handle);
+ if (system_thread_handle != (IntPtr) 0)
+ Thread_free_internal(system_thread_handle);
}
private void set_state(ThreadState set) {
- lock(this) {
+ lock(synch_lock) {
state |= set;
}
}
private void clr_state(ThreadState clr) {
- lock(this) {
+ lock(synch_lock) {
state &= ~clr;
}
}
+
+#if NET_1_1
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static byte VolatileRead (ref byte address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static double VolatileRead (ref double address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static short VolatileRead (ref short address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static int VolatileRead (ref int address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static long VolatileRead (ref long address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static IntPtr VolatileRead (ref IntPtr address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static object VolatileRead (ref object address);
+
+ [CLSCompliant(false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static sbyte VolatileRead (ref sbyte address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static float VolatileRead (ref float address);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static ushort VolatileRead (ref ushort address);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static uint VolatileRead (ref uint address);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static ulong VolatileRead (ref ulong address);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static UIntPtr VolatileRead (ref UIntPtr address);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref byte address, byte value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref double address, double value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref short address, short value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref int address, int value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref long address, long value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref IntPtr address, IntPtr value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref object address, object value);
+
+ [CLSCompliant(false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref sbyte address, sbyte value);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref float address, float value);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref ushort address, ushort value);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref uint address, uint value);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref ulong address, ulong value);
+
+ [CLSCompliant (false)]
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ extern public static void VolatileWrite (ref UIntPtr address, UIntPtr value);
+
+#endif
+
}
}
projects / mono.git / blobdiff