This bug would trigger a use after sweep in System.Threading.Tasks.Task.FinishContinuations:3621.
The issue would arise on ARM, as `MonoContext` and `ARCH_NUM_REGS` are defined as followed :
```
typedef struct {
mgreg_t pc;
mgreg_t regs [16];
double fregs [16];
mgreg_t cpsr;
} MonoContext;
\#define ARCH_NUM_REGS 14
```
As you can see, the MonoContext structure is bigger than 14 words, and it does not even covers the last 3 values of `regs`. By using pointer arithmetic, we ensure that we do not miss some parts of the `MonoContext` structure.
The observed behaviour in System.Threading.Tasks.Task.FinishContinuations would be that `continuationObject` would not be marked, and thus freed; `continuationObject` would still contains the pointer to the old location, meaning it wouldn't be null. We would then try to check its type via a call to the `as` operator. This would call the `isinst` IL opcode which would load `continuationObject->vtable->klass->supertypes [...]`, which would trigger a segfault, as `supertypes` would be null.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=38012
Adding a new block to the allocated_blocks array is racy with the removal of nulls when sweeping. We wait for sweep to finish to avoid that.
This also handles the problem of allocating degraded objects while sweeping.
The shim/bridge between Mono and the RS implementation of
XmlObjectSerializer, DataContractSerializer, etc. did not properly
invoke the constructor required by ISerializable, as it completely
omitted passing the populated SerializationInfo object.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=37171
Roslyn used byref vars whenever possible to store fixed statements. This leads to confusion in
both the full verifier and the JIT built-in one.
Now we skip it in the JIT one and allow it when not in strict mode for the full verifier.
With C6 we introduced a regression
https://bugzilla.xamarin.com/show_bug.cgi?id=36100, which is caused by
the new static serialization code that we wrote to reuse Microsoft's
serializer.
The code uses Invoke on a series of MethodInfos, and this obscures the
actual code that will be invoked at runtime to serialize certain
objects, causing the following exception:
Attempting to JIT compile method '(wrapper runtime-invoke) <Module>:runtime_invoke_bool_Nullable`1<Decimal> (object,intptr,intptr,intptr)' while running with --aot-only.
This patch makes the simple code work, but a more thorough review of
the code would allow us to remove many of the slow dynamic codepaths
in the serializer.
We opted for that approach to keep the code as similar as possible to the
original.
But the code basically does this:
* Use the XmlFormatGeneratorStatics property InternalSerializeMethod,
whose sole purpose is to delay computing the MethodInfo for the
XmlFormatWriterGenerator's InternalSerialize.
* Use the resulting method in a few places to call the MethodInfo.
The MethodInfo was used because the original code uses Reflection.Emit
to create fast serializers and it needs handles to internal methods,
but our static rewriter does not need it.
We should replace all of those uses, but for now, this patch at least
deals with the 36100 bug.
We just reverted a patch that prevented the FileSystemWatcher from
opening too many file descriptors (200). That was a band-aid at one
of the spots that opened too many file, as we would exhaust the number
of files, and later abort when some other operation needed files.
The problem is that OSX defaults to 256 file descriptors, and .NET
applications are file descriptor hungry, in fact, many applications
increase their file handled limit before starting.
This patch on OSX will attempt to increase the number of handles
available to 1024 if the number of handles avaialble is less than
that.
The commit that removed the limit was:
2af882232c
And it was closed to fix:
Conflicts:
mono/mini/driver.c
In case all threads would wait on a Sleep or a Wait, the monitor thread would simply increase the number of max working thread, up to the point it would overflow the number of max worker threads.
The .NET delegate removal semantic is a bit unpredictable. For example, the following (d1 + d2 + d3) - (d1 + d3) is going to return the d123 delegate, and not the d2 delegate as we could have guessed. This is because removal will remove the `list' of delegates as a whole, and not the elements in the list.
The previous implementation would then have a different behavior than the one observed on .NET.
Fixes bug #36646
It can be passed at runtime in the nursery-size option of MONO_GC_PARAMS environment variable.
Fixes#35414
Conflicts:
mono/mini/aot-compiler.c
mono/mini/aot-runtime.c
mono/mini/patch-info.h
- cherry-picked for C6 SR1
- this way the following xml will match all the types in the assembly
MyAssembly
<linker>
<assembly fullname="MyAssembly">
<type fullname="*" />
</assembly>
</linker>
before this change it will only match the types defined in main
module and none of the nested types
Context: https://bugzilla.xamarin.com/show_bug.cgi?id=31432
In a few android devices TimeZoneInfo.ParseTZBuffer was failing ito
parse Europe/Moscow with:
at System.ThrowHelper.ThrowKeyNotFoundException ()
at System.Collections.Generic.Dictionary`2[System.Int32,System.String].get_Item (Int32 key)mscorlib/system/collections/generic/dictionary.cs:176
at System.TimeZoneInfo.ParseTimesTypes (System.Byte[] buffer, Int32 index, Int32 count, System.Collections.Generic.Dictionary`2 abbreviations) [0x0002f] in mcs/class/corlib/System/TimeZoneInfo.cs:1293
at System.TimeZoneInfo.ParseTZBuffer (System.String id, System.Byte[] buffer, Int32 length)
It was failing while getting the third index [3] from] from abbrevs.
abbrevs added values were the following:
[0, MMT]
[1, MT]
[2, T]
[4, MST]
[5, ST]
[6, T]
[8, MDST]
[9, DST]
[10, ST]
[11, T]
[13, S]
[15, M]
[17, MSK]
[18, SK]
[19, K]
[21, EET]
[22, ET]
[23, T]
[25, MSD]
[26, SD]
[27, D]
[29, EEST]
[30, EST]
[31, ST]
[32, T]
Index 3 was not added because its values is an empty string, as indexes
with empty values are used in this case we are now adding them to the
abbrevs dictionary.
Fixes#31432
Context: https://bugzilla.xamarin.com/show_bug.cgi?id=31432
Tests TimeZoneInfo.ParseTZBuffer with Europe/Moscow data that thrown
at System.ThrowHelper.ThrowKeyNotFoundException ()
at System.Collections.Generic.Dictionary`2[System.Int32,System.String].get_Item (Int32 key)mscorlib/system/collections/generic/dictionary.cs:176
at System.TimeZoneInfo.ParseTimesTypes (System.Byte[] buffer, Int32 index, Int32 count, System.Collections.Generic.Dictionary`2 abbreviations) [0x0002f] in mcs/class/corlib/System/TimeZoneInfo.cs:1293
at System.TimeZoneInfo.ParseTZBuffer (System.String id, System.Byte[] buffer, Int32 length)
The project was removed from the solution in 735fc51cc0, but one instance was missed.
This should fix the Windows build on Jenkins.
(cherry picked from commit a353efb8bb)
In some more esoteric environments (say bash.exe spawned by
jenkins-slave.exe), the _MASM target's attempts to call ml.exe fail
due to ml.exe missing from $PATH (even when it appears to be fine).
The ClCompile target doesn't suffer this issue, since it uses the
full path to CL.exe rather than assuming CL.exe is in $PATH.
Bundle a lightly patched masm.props to duplicate the ClCompile
target behaviour.
This should have no impact on you unless for some reason you're
using a different MASM to the one provided with MSVC.
(cherry picked from commit 900552b7d3)
We have been running into this issue: https://bugzilla.xamarin.com/show_bug.cgi?id=30018 a lot recently, after digging into getaddrinfo a bit we saw that the linked list of addrinfo structs had 1 or more valid ones which can be used and 1 bad one which should just be discarded.
The timeout before exiting a worker thread is random to limit the worst
case scenario where, if the timeout is set to N seconds, the user would
launch a lot of work item simultaneously, at an interval of N + 1
seconds. In this case, we would have to kill all the threads at once,
and starts them all over again 1 second later. The randomization makes
the creation and destruction more linear in time, and avoid burst.
When comparing a string with null the other checks in the interpreter for type equality didn't catch this case
and this ultimately resulted in a NotImplementedException in EqualInstruction and NotEqualInstruction.
The fix is to handle the TypeCode.String case in those instructions.
We don't need to do it for CreateLifted() as that method only applies for Nullable<T> types which doesn't make sense for string.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=34334
StackTrace.ToString format was different from Exception.ToString.
StackTrace.ToString had an identation of 3 spaces instead of 2, outputed
"line " before the line number which Exception.ToString does not, and it
did not print offsets.
This change allows StackTrace.ToString output to be used by the mono-symbolicate tool.
Linux kernels before 3.9 did not support port reuse.
Added private method System.Net.Sockets.Socket.SupportsPortReuse,
which returns true when the runtime is able to bind to the same address
and port multiple times.
The problem happens because thread_interrupt runs in the debugger thread (suspend initiator).
thread_interrupt then calls mono_thread_state_init_from_monoctx which collects the state of the current thread
which is definitely not what we wanted.
There used to be some compensation code after calling mono_thread_state_init_from_monoctx to actually init the state properly.
This is why it worked, at all.
Thew problem is that the debugger thread now might not attach at all under some circumstances, which would trigger
mono_thread_state_init_from_monoctx to return FALSE and trip into the assert.
The fix is to simply not use mono_thread_state_init_from_monoctx at all, just copy the state from data. This fix has the
bonus of getting the domain correctly.
The `monotouch_runtime` profile is exclusively used for the monotouch
REPL assemblies used by Xamarin Sketches and Inspector. In those cases,
Console and Environment should behave just the same as in the
`monotouch` profile.
The only real difference between the two profiles should be the presence
of SRE in `monotouch_runtime`.
Linux kernels before 3.9 did not support port reuse.
Added private method System.Net.Sockets.Socket.SupportsPortReuse,
which returns true when the runtime is able to bind to the same address
and port multiple times.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=33558
Several of the Signal-related tests were disabled when running on OS X
because OS X doesn't provide reliable delivery: it will try to deliver
a signal, but if it's already been delivered it won't continue
delivering them. This results in failures such as:
1) MonoTests.Mono.Unix.UnixSignalTest.TestWaitAny : Expected: 23061
But was: 100000
(Note that "Expected" and "actual" are reversed. Oops.)
Thus, signals are delivered, just "not enough."
As It Happens™, Android is similar: running these tests on
Xamarin.Android results in test failures because not enough signals
are received. (It's not as bad as OS X -- only ~10% off -- but it's
not *all* of the signals either.)
Fix the tests so that they *don't* require that we receive as many
signals as we raise. Instead, assert that all of the UnixSignal
instances actually have a UnixSignal.Count value greater than 0, i.e.
that they've been signaled AT ALL.
Loosening up the tests in this manner allows the tests to pass on
OS X, and should allow things to work as expected on Android.
The race condition would manifest in the following code:
```
for (int i = 0, total = 100000; i < total; ++i) {
if (i % 50 == 0)
Console.WriteLine ("{0}/{1}", i, total);
var c1 = new CancellationTokenSource ();
var wh = c1.Token.WaitHandle;
c1.CancelAfter (1);
Thread.Sleep (1);
c1.Dispose ();
}
```
And we would observe the following exception:
```
Unhandled Exception: System.ObjectDisposedException: Cannot access a disposed object.
Object name: 'System.Threading.ManualResetEvent'.
at System.Threading.WaitHandle.CheckDisposed () [0x00016] in /Users/builder/data/lanes/1196/33e00ac6/source/mono/mcs/class/corlib/System.Threading/WaitHandle.cs:426
at System.Threading.EventWaitHandle.Set () [0x0000c] in /Users/builder/data/lanes/1196/33e00ac6/source/mono/mcs/class/corlib/System.Threading/EventWaitHandle.cs:205
at (wrapper remoting-invoke-with-check) System.Threading.EventWaitHandle:Set ()
at System.Threading.CancellationTokenSource.NotifyCancellation (Boolean throwOnFirstException) [0x00051] in /Users/builder/data/lanes/1196/33e00ac6/source/mono/external/referencesource/mscorlib/system/threading/CancellationTokenSource.cs:723
at System.Threading.CancellationTokenSource.Cancel (Boolean throwOnFirstException) [0x00006] in /Users/builder/data/lanes/1196/33e00ac6/source/mono/external/referencesource/mscorlib/system/threading/CancellationTokenSource.cs:409
at System.Threading.CancellationTokenSource.Cancel () <0x7d75ada8 + 0x00017> in <filename unknown>:0
at System.Threading.CancellationTokenSource.TimerCallbackLogic (System.Object obj) [0x00012] in /Users/builder/data/lanes/1196/33e00ac6/source/mono/external/referencesource/mscorlib/system/threading/CancellationTokenSource.cs:538
```
This would be a race condition between the TimerCallbackLogic call to Cancel and the call to Dispose on another thread. You could trigger it more reliably by putting a Thread.Sleep at CancellationTokenSource.cs:599.
Also fixes ConcurrentCancelLinkedTokenSourceWhileDisposing race condition between Cancel and Dispose, by applying the same pattern as CancellationTokenSource.TimerCallbackLogic.
A couple of tests for System.Reflection.MethodBody assumed the code generated
by the compiler will be the same as the one generated by Mono's MCS. However,
when the code is built by CSC in release mode (version that comes with VS2015
was tested) the optimizations remove locals required by the old version of the
tests. Also, CSC orders the locals differently to MCS and that breaks one of
the tests which relied on the declaration order.
Another difference is that CSC and MCS type a certain local variable differently.
The variable being a byte* in source code is output in IL as such by MCS, but CSC
outputs an int8& - a by-ref type.
The tests are built by VS but they are executed by Mono on Android and so the
differences come up as errors.
This commit fixes both issues by working around the differences.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=33370 when it is included in XA
Threadpool uses poll(2) to watch the file descriptors for activity but
it can sometimes miss that an fd went into error. When that happens the
poll call is interrupted with EAGAIN since the erroneous fd's events have
already been read and there's nothing left in the queue for it. That, in turn,
causes mono to run the loop so quickly that it uses 100% of the CPU. It happens,
for instance, with Xamarin Studio which can utilize two CPU cores to the full while
idling on the opening screen.
This commit makes sure to remove the descriptors with errors from the poll set and
thus preventing the syscall from being interrupted and returning EAGAIN.
This error was generated when iOS(or any other kind of project, that is referencing other project in solution via <ProjectReference>) wanted to get OutputPath of PCL(or any other referenced project) but it failed in case of IDE because wrong conditions(see .targets files changes). Reason this bug was never discovered before is because PCL project was already loaded before with correct configuration/platform so not having AssignProjectConfiguration target executed had no effect. Reason it appeared in this case(Bug 25480) was that .sln and .csproj<ProjectReference> had folder path defined as XamlSamples but actual file system had xamlsamples(notice different chars casing). So projects.TryGet(filePath, out project) failed, hence project had to be reloaded, and then bug from .targets files showed up...
A bit more details about fix: The AssignProjectConfiguration target assigns configurations to the various @(ProjectReference), and is used from targets like ResolveProjectReferences, which are enabled only while building solution files ( $(BuildingSolutionFile) ) or when invoked from the IDE ( $(BuildingInsideVisualStudio) ). But the AssignProjectConfiguration target ignores the IDE case, which breaks usage of ResolveProjectReferences from the same. Fix up to run for both the cases.
Multiple threads listening to the same address and port are not possible
before linux 3.9 kernel, where the socket option SO_REUSEPORT was
introduced.
This commit makes TcpDoubleBind sensible to this OS capability.
The comparison was failing because we were still using the method field (instead of the Method property), which would then return, in the case of a delegate to a virtual function, the method on the base class, instead of the method on the derived class. Updated the test cases to check that too.
Instruments uses library interposing to record calls to mmap and munmap. It does take lock within the interposers
which means the async suspend could suspend a thread holding such lock while sgen tries to mmap more memory in,
causing a deadlock.
The workaround is to protect our uses of mmap and munmap in the hopes that they are enough to reduce the likelihood
of those hangs happening.
In .NET an URI constructor from "/foo" and UriKind.RelativeOrAbsolute is
relative whereas in mono it is assumed as an absolute file path.
This adds another workaround that changes all Uri constructor calls to
behave like .NET when receiving UriKind.RelativeOrAbsolute.
The environment variable workaround consists in setting
MONO_URI_DOTNETRELATIVEORABSOLUTE=true before starting the application:
Reflection workaround:
```
if (Type.GetType ("Mono.Runtime") != null)
typeof (Uri).GetField ("useDotNetRelativeOrAbsolute",
BindingFlags.Static | BindingFlags.GetField | BindingFlags.NonPublic).
SetValue (null, true);
```
WARNING: The workarounds change the behavior of all Uri constructor calls.
Unexpected problems can occur if an used library relies on
UriKind.RelativeOrAbsolute to parse absolute file paths.
Linux code uses a netlink socket to be notified about network interface
changes. The code is a bit racy and for that reson it can happen that
the LinuxNetworkChange.OnDataAvailable handler is called after the
socket is destroyed (from a timer event) and socket stored in an
instance variable is already null. This is a race most probably
introduced by the new threadpool or TPL code as it started to happen in
several places (mostly BCL tests on Android, but it's *not* specific to
Android).
The workaround here serves as a quick band-aid to be able to move on,
but a more thorough review of the socket code will be required.
The sparse-array approach led to better insert/remove performance, by allowing a O(1) access, but led to memory consumption issue. The kernel would, for example, have to parse the whole array, even if it's mostly empty, and that can be an issue for large arrays.
The main change is the fd will not be removed from the backend when there is no event to poll, but only when we close the socket. This also reduce the number of functions of the backend.
Specifically, when updating classic and unified assemblies, members
that were completely removed from one or both assemblies were not
being removed from the XML. This patch updates mdoc's `DeleteMember`
method to properly handle deletion in all scenarios (normal, classic, unified).
Of course, deletion will still not happen if one of two things is true:
- `--delete` is *not* passed into the `mdoc update` call and the member node
contains existing documentation.
- `--preserve` *is* passed into the `mdoc update` invocation.
In both of those cases, the member will not be deleted, and a message stating
as such will be written as a warning to the output.
This product has been discontinued by AMD and we don't even have support for
building this profiler module in the build system anyway; chances are pretty
good that bitrot has set in.
We used to construct exception stack traces as string at throw site (for dynamic methods) but
that does not work correctly because exception stack trace can be decomposed via
new StackTrace (exception) or merged via ExceptionDispatchInfo both of them need the exception
stack in raw form and not as a string.
Further the format used by local stack builder was not same as format used by
System.Diagnostics.StackTrace.
The orignal reason for the specialization was that dynamic method can be collected
before stack is rendered which leads to stack frame to be reported as
at <unknown method> instead of
at (wrapper dynamic-method)
That should be addressed by gc-link between dynamic method and exception or
stack-frame.
We actually don't need the length check here. The only place where
the 'ref parameters' could possibly be replaced is at the end of the
private Request() method - to remove the 'IAsyncResult' argument from
and End*() method.
This fixes commit 0b1360c8e3 and bug #32886.
The test causes the runtime to silently crash in fashion similar to what
real-time signals do to the runtime (a segfault without a single trace
of a crash, causing the process to just hang)
Process names were trimmed to 15 characters. proc_name was used to
retrieve the process name, by looking at its implementation we can see
that it returns a buffer which the size is MAXCOMLEN defined as 16.
When the proc_name result length is equal to 15 (MAXCOMLEN - 1) we now check if
proc_pidpath is able to return a longer process name.
Fixes#32539.
Android's libc (bionic) defines the _GNU_SOURCE macro but fails to adhere
to the GNU sematics in (at least) one case - the strerror_r function.
The function follows XSI semantics instead of the GNU one which caused our
code to segfault on Android. This patch special-cases Android to use the XSI
semantics for strerror_r. This un-breaks some POSX real-time singals tests.
It also makes provisions for detecting whether the real-time signals are safe
to use on the current platform. They are safe for all platforms desktop Mono
runs on, but they're not safe on most Android platforms.
Neither is_socket_async_callback nor is_async_read_handler need to
actually successfully load the classes they're comparing against;
if the classes can't be loaded, then the input class is obviously
not of that class.
This occurs when mscorlib is linked, the classes to compare against
might be linked away.
https://bugzilla.xamarin.com/show_bug.cgi?id=32947
MONO_OBJECT_SETREF would use mono_gc_wbarrier_set_field which would write over 8 bytes ( *(void**)field = value ), while we want to write over 1 byte here.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=25086
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=31875
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=32171
Reverts and reworks commit bcfec743.
The problem is that when Xamarin.Android is running mkbundle, dos2unix
should NEVER be used, because the Android NDK NEVER wants Unix-like
paths, which is what dos2unix creates.
Commit bcfec743 attempted to fix this by removing dos2unix invocation
from the Xamarin.Android codepath.
The problem is that the logic was backwards: it removed dos2unix
invocation when XAMARIN_ANDROID was NOT defined, and PRESERVED
dos2unix invocation when XAMARIN_ANDROID WAS defined.
Meaning commit bcfec743 broke normal/default mkbundle.exe use on
Windows -- it would no longer probe for and use dos2unix if present --
and Xamarin.Android use of mkbundle continued to check for and use
dos2unix if it was present, continuing the buggy behavior.
Doh!
Thus, a reworking: Add a `mkbundle --dos2unix` parameter.
If `mkbundle --dos2unix=false` is specified, dos2unix will NOT be
probed for, and will NOT be used. If `mkbundle --dos2unix` or
`mkbundle --dos2unix=true` is used, then dos2unix WILL be used.
This allows the caller to consistently, ahead of time, control
mkbundle's behavior regarding dos2unix, which will e.g. allow
Xamarin.Android to *always* specify --dos2unix=false, allowing things
to build as desired there.
In .NET an URI constructor from "/foo" and UriKind.RelativeOrAbsolute is
relative whereas in mono it is assumed as an absolute file path.
This provides supports for an easy workaround to make mono behave as
.NET.
The workaround consists in defining DotNetRelativeOrAbsolute and using
it instead of UriKind.RelativeOrAbsolute.
DotNetRelativeOrAbsolute should be defined as follows:
static UriKind DotNetRelativeOrAbsolute = (Type.GetType ("Mono.Runtime")
== null)? UriKind.RelativeOrAbsolute : (UriKind) 300;
On Android application runs with its CWD set to / and so the path
test modified in this commit expects to find a path of the //one form
which is not what the combine operation returns.
bionic doesn't have the following entries:
setgrent
getgrnam_r
setpwent
API 21 in the NDK conditionally declares some of those but they are absent
from either libc.so or libc.a.
mono_get_seq_points takes the domain lock then calls mini_get_shared_method.
mini_get_shared_method then calls into general metadata code that eventually take
the loader lock.
The loader lock has precedence over the domain lock.
Starting with 62c86e2243 mono/mini/Makefile now includes mcs/build/config.make.
Both files define RUNTIME, but with different values. The mini one requires the usage of MONO_PATH while the one in
mcs don't.
To fix that we rename the mini var to MINI_RUNTIME.
To achieve this, we need to wait for the update to be applied to the backend.
This is mainly for the epoll backend, as we do not need to remove the fd from the backend when using kqueue.
With the previous commit, it fixes a range of bug that happens only with epoll. This is because, contrary to poll and kqueue, epoll keeps an internal state that has to be kept in sync with the threadpool_io->states hash table.
This threadpool_io->states hash table is keeping a list of file descriptor to watch, with the corresponding SocketAsyncResult to callback in case of event on the fd. But epoll also keeps its internal state that needs to me modified with EPOLL_CTL_ADD, EPOLL_CTL_MOD and EPOLL_CTL_DEL.
Contrary to kqueue, EPOLLONESHOT does not force epoll to remove the socket from its internal state once an event have been triggered; but it will just not fire this event again, until this event is reset. Also, epoll will remove a fd from its internal state when this fd is closed.
This will lead to a bunch of out-of-sync states like the following :
- the user start reading asynchronously the STDOUT of a child process, the child process quit (closing the STDOUT fd), this fd is reused by the OS for something else (like a socket), the IO threadpool call epoll_ctl with EPOLL_CTL_MOD (because the fd is still in the states hashtable), but the OS returns an error because the underlying file is different, even if the fd is the same.
- the user opens a socket, does some asynchronous operation on it, and close it; removing it from the table but not from epoll (as it does not call epoll_ctl with EPOLL_CTL_DEL). For another reason, the fd has not been closed in the OS (and thus in epoll), because it might, for example, still be open by another process. After that, we receive an event for this fd (as it is still in epoll), and between the time of the epoll_wait and the epoll_ctl with EPOLL_CTL_DEL, the fd is actually closed in the OS, leading to a EBADF error.
The g_warning have also been replaced by g_error, so we do not silently discard this kind of error in testing.
[merged from monodroid by rodo]
part of
commit 0b9c100b60fc2502a0d6347d50cac444bb82b285
Author: Jonathan Pobst <[email protected]>
Date: Wed Sep 28 15:50:39 2011 -0500
Instead of preserving every method with a [Register] attribute on it in Mono.Android.dll, only save the things that the user actually uses. Reduces HelloWorld release apk by ~1.3MB.
[merged from monodroid by rodo]
- part of
commit 216f75038afee2105182fc6af329f1fc83c4298f
Author: Radek Doulik <[email protected]>
Date: Sun Nov 23 11:40:42 2014 +0100
[linker] mark methods (from Register attr) in base type when needed
- fixes#10268
- methods from these Register attributes were not marked:
https://github.com/xamarin/monodroid/blob/master/src/Mono.Android/src/Android.Widget/AdapterView.cs#L132-135
because the app used class derived from BaseAdapter class and the methods
existed only in the base class and were not marked
[merged from monodroid by rodo]
commit 840487dd904a5552f77dcc7388b27c37ca09169f
Author: Radek Doulik <[email protected]>
Date: Thu Oct 16 20:03:58 2014 +0200
- sometime the assemblies with action set to Copy still might
contain type references to forwarders and thus point to
Delete assemblies, which are removed during linking, resulting
in unresolvable type references
- fixes https://bugzilla.xamarin.com/show_bug.cgi?id=23617
XA forms template now builds and works OK
XA app template builds and works OK
[merged from monodroid by rodo]
commit f51f044e30b822f191777a395563ef9d46f8b69d
Author: Radek Doulik <[email protected]>
Date: Wed Mar 4 18:28:59 2015 +0100
- fixes#27620
- in this case we were trying to process Application.java
as linker an assembly XML linker description, which led
to uncaught XmlException
[merged from monodroid by rodo]
commit 2edecdc39ca55c65de4f57557e5e31b5d432eaa4
Author: Alex Rønne Petersen <[email protected]>
Date: Mon Jul 1 15:35:59 2013 +0200
The BlacklistStep pass will feed the ResolveFromXmlStep pass XML files
that may not necessarily *be* linker descriptor files. This can happen
if an embedded file happens to be named "Foo.Bar.xml" and an assembly
called Foo.Bar is referenced in a project. The chances of this happening
are probably very low, but better safe than sorry.
[merged from monodroid by rodo]
commit 3001f693c52be0da673446179daf498265024867
Author: Alex Rønne Petersen <[email protected]>
Date: Tue Jul 30 20:06:21 2013 +0200
1. Catch XmlExceptions in case of broken XML files.
2. Only process files that actually end in ".xml".
[merged from monodroid by rodo]
commit 3e19b22eb24ff9faeebe1ace7461d8f91f807041
Author: Alex Rønne Petersen <[email protected]>
Date: Mon Jul 1 15:34:26 2013 +0200
This is in addition to those files that are already embedded in the linker assembly
itself (such as mscorlib.xml). People can use this feature to tell the linker that
certain methods/fields/types must be kept if a particular assembly is being referenced
by embedding a descriptor file in it.
OS/X, like Android, uses a symlink for the $TMP directory. The tests used to assume
that the link points to the /private/tmp directory (which is the case) but earlier
changes introduced here for Android employed a more generic mechanism to determine the
actual temporary directory.
This commit removes the '/private' prefix assumption from OS/X
This test depends on server behavior. I changed the server to xamarin.com
earlier on, but it stopped behaving as required recently. The test should
not rely on random servers, so until we have a server we can rely on I'm
disabling it.
The Dispose call in FakeSafeHandle causes the Mono runtime to segfault
when passing the call up the chain. As a consequence of disabling the
base class call, the other tests disabled by this commit fail.
It's not possible to save the assembly in the current directory on Android and AssemblyBuilder.DefineDynamicModule will not
allow a full path to the assembly to be passed to it. Trying to change the current directory before saving will not work either as
FileStream will then prepend / to the file name (perhaps it's another bug) and write access to the filesystem root is, obviously, denied
On Android (possibly on other systems too) it is possible that no gateway address is available and its lack is NOT an error
Here is a sample of /proc/net/route from Nexus 9 running Android 5.1.1 (IPInterfaceProperties parses that file on Linux)
Iface Destination Gateway Flags RefCnt Use Metric Mask MTU Window IRTT
wlan0 0001A8C0 00000000 0001 0 0 0 00FFFFFF 0 0 0
Gateway is set to any address and it is explicitly ignored by the route information parser
For comparison, here's route contents from an Android 4.4.4 device:
Iface Destination Gateway Flags RefCnt Use Metric Mask MTU Window IRTT
wlan0 00000000 0101A8C0 0003 0 0 0 00000000 0 0 0
wlan0 00000000 0101A8C0 0003 0 0 203 00000000 0 0 0
wlan0 0001A8C0 00000000 0001 0 0 0 00FFFFFF 0 0 0
wlan0 0001A8C0 00000000 0001 0 0 0 00FFFFFF 0 0 0
wlan0 0001A8C0 00000000 0001 0 0 203 00FFFFFF 0 0 0
wlan0 0101A8C0 00000000 0005 0 0 0 FFFFFFFF 0 0 0
Obviously, this test fails on the first device and succeeds on the second. For this reason the test is modified to succeed
in case of devices like the first one since it's not a real failure but a shortcoming of the .NET API
Android M (that's where I ran into it) makes the path returned by
Path.GetTempPath () a symlink to the real directory used for temporary
files. When the tests change the directory the symlink is followed and
subsequent reads of the current directory name will return the real dir
name which doesn't match what was constructed using the value returned by
GetTempPath ()
Assembly.Location will contain just the assembly file name without any path, which
is not what the test(s) expect. The reason is that the assemblies on Android live
in the APK, are embedded in the native code or don't exist at all (AOT)
While bionic reports it supports 64-bit offsets for locks and exposes the
necessary APIs, attempt to use offsets larger than 32 bits results in
an error.
Don't assume a specific charset in HTTP response from a server. Google
changes response charset based on the country of the client's
IP. There's no point in checking for the specific charset, it's enough
to check whether the response header has correct format.
Fix the test to compare the subtraction result to value more
conservative than Double.Epsilon, to account for differences in
different CPU floating point units on Android.
The test failures didn't really indicate which of the Fail statements
caused the test failure. Also, the 10k offset turned out to be not
enough for the XA test suite (it's much bigger than that)
Xamarin.Android stores assemblies inside apk (or bundled, or AOT-ed) and
so Assembly.Location will not point to a real path on the
filesystem. It merely contains assembly name.
The test case doesn't account for the situation when the tests are ran
at the root of the Unix filesystem. This is, admittedly, a rare case on
Desktop but it's precisely what CWD is for Android processes. The test
would fail because it would get a path of the //Form instead of the /Form
When using shared projects, the search path and/or framework paths may sometimes
contain empty elements.
This fixes commit 5b12d9ae37.
(cherry picked from commit 4efdd29f70)
Remote TLS reads is not a required feature for the runtime to work on
mach systems. We still want it available, but can leave the assertion
to happen when someone actually use it.
Usage won't happen today as part of regular code execution, so moving
the assert will make us more robust.
For a future Xamarin.Android release, we'd like to include
Mono.Posix.dll for simple Unix interop support.
That said, since Mono.Posix has never been included with
Xamarin.Andorid before, this makes a perfect opportunity to remove
some [Obsolete] cruft within Mono.Posix.dll, namely the types within
the Mono.Posix namespace.
Unfortunately, simply not compiling the types within the Mono.Posix
directory doesn't result in compilable code, due to references to
types within the Mono.Posix namespace by other types, e.g.
Mono.Unix.PeerCred using Mono.Posix.PeerCredData.
Fix things so that the Mono.Posix sources can be omitted, allowing
compilation of an assembly with fewer [Obsolete] types.
This change shrinks the size of Mono.Posix.dll by ~10.5KB.
Since UTF32Encoding returns 8 for GetMaxByteCount(1), PtrToString
expects 8 NUL bytes to stop scanning for the end of the string.
Since all the other UTF schemes are special-cased in
GetStringByteLength, do the same for UTF32Encoding.
The value isn't used for the managed crypto code and is still validfor CryptoAPI, but if it changes Mono can't find keypairs made with earlier versions. Fixes#31199
The check from [1] is fine when it's done once _or_ with an identical
target. However there's nothing to ensure (if done more than once) that
it's being used to represent the same thing every time.
That makes the code from [1] match methods like:
> System.IObservable`1<TResult> System.Reactive.Linq.IQueryLanguage::Repeat(TResult)
and
> System.IObservable`1<TSource> System.Reactive.Linq.QueryLanguage::Repeat(System.IObservable`1<TSource>)
where `TResult` is different in both checks.
This patch tracks what is used as the generic parameter (on first check)
and make sure it's identical if it's used again in the same signature.
Note: this is a very old bug (i.e. it's always been that way) but recent
changes to mono started to report such issues (a good thing) and, for AOT
compilation on XI, that resulted in MT3001 errors.
[1] https://github.com/mono/mono/blob/mono-3.10.0/mcs/tools/linker/Mono.Linker.Steps/TypeMapStep.cs#L250
xbuild was copying TargetFramework assemblies when the builded project
had dependencies in a TargetFramework.
Doing so is not the msbuild behaviour and was causing bugs while
resolving Types at load time.
Fixes#28592 and #31396
The socket would not be deleted with epoll_ctl (via epoll_reset_fd_at) when we would remove the state from threadpool_io.states. So when we would try to add it again, it would mark it as a new socket (as it wouldn't be present in threadpool_io.states), while it has not been deleted from epoll.
They are a very fragile part of the runtime, as they are not very well aken care of.
We simply disable it by default for now. If everything still works as expected, we will completely remove the code.
* It reduce memory allocations by avoiding the creation of empty
collections (only used to tell us there's a Count of 0);
* It also speed up execution, less object creation/GC time;
* Patch also remove some double-casts (is + as/cast)
The following race could occur and lead to a EBADF error with kevent and epoll :
1. mono_threadpool_ms_io_add is called with fd 1234
2. mono_threadpool_ms_io_remove_socket is called when closing fd 1234
3. selector_thread calls update_add with socket 1234, which will call kevent with this already closed socket
The solution is simply to remove all the SocketAsyncResult from states, as well as updates, for the given socket fd
We were failing MonoTests.DebuggerTests.Locals and
MonoTests.DebuggerTests.SingleStepping because we
stepped forward too far as a side effect of this missing
"padding" NOP.
We see a crash in LinuxNetworkChange.OnAvailabilityChanged when dereferencing the AvailabilityChanged delegate (NullReferenceException). There is a race here: the OnAvailabilityChanged is fired by deferring to the ThreadPool, which allows an unregister to come in between, removing the potential registration before we get called back.
Compiling VB projects was broken since a few releases but apparently went unnoticed.
The VbcToolExe path needs to be set to "vbnc.exe" because vbnc2 and vbnc shell scripts
don't work in this case and we only support building against the reference assemblies anyway
now for different targets.
We had a use-after-free bug in context freeing that creating and freeing AppDomains in parallel exposed.
We called g_hash_table_remove in a callback to g_hash_table_foreach,
which
resulted in freeing the Slot struct that the g_hash_table_foreach was
holding a local reference to.
When it tried to get the chained 'next' element in the table, if
other threads caused enough memory pressure to reuse that memory
between freeing and getting the 'next' pointer, then we try to
dereference a garbage value and get a SIGSEGV.
On mach, semaphore_timedwait returns KERN_ABORTED instead of setting the errno variable. The timeout argument is relative so it needs to be updated. We don't need to update the timeout argument on other platforms since it has an absolute value.
Me might be very unlucky and still have the object pinned in random stack memory. Allocate multiple objects so we are sure that at least one of them is finalized.
Fixes segmentation fault when mono_mmap_open_handle is called with a null mapName argument.
MemoryMappedFiles.CreateFromFile calls mono_mmap_open_handle, .NET implementation accepts a null mapName and CoreFX uses CreateFromFile with null mapName.
Fixes#30825 and #30741.
Changed MemoryMappedFile related code to use reference source
MemoryMappedViewAccessor and MemoryMappedViewStream.
This change was motivated by segmentations faults while dnmv code was
calling a CoreFX class that uses reflection to call MemoryMappedFile
code.
Now that we are using more code from reference sources there should be
no problem.
Fixes#30741 and #30825.
Few tests using networking seem to fail due to
"Address already in use"
error that may be caused by opening listening
port too fast - because of some tests running
in parallel or because 2MSL TIME_WAIT period.
Most modern Linux distributions limit the ptrace scope to allow
attaching only to the direct child processes for security reasons. The
user on such machine has to modify sysctl in order to allow non-root
processes to attach to arbitrary processes, which opens up a potential
security issue. The alternative is what's implemented here - when we
crash and ask gdb to dump the stack we can bless the gdb process and allow
it to attach to our process using prctl(2)
When you write to archive files and entryNameEncoding is set to a value other than null, the specified entryNameEncoding is used to encode the entry names into bytes. The language encoding flag (in the general-purpose bit flag of the local file header) is set only when the specified encoding is a UTF-8 encoding.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=30972.
I have added System.HttpApplication.RegisterModule(), the missing two properties of the System.Web.Routing.RouteCollection as well as the corresponding property in the HttpRuntimeSection to completely turn this off. Microsofts MIT-Licensed counterparts of the official System.Web assembly from github [0] were used as a reference. It is kind-of bolted on, but should be good enough until the whole open-sourced System.Web is incorporated. It should at least get the default MVC5 Template from Visual Studio 2013 up and running, once the async pipeline for the owin stuff is fixed.
[0]: http://github.com/Microsoft/referencesource/
Additionally, the MissingMethodException "get_InClientBuildManager" in System.Web.Hosting.HostingEnvironment was fixed.
In this commit, the following bugs were fixed:
https://bugzilla.xamarin.com/show_bug.cgi?id=21810https://bugzilla.xamarin.com/show_bug.cgi?id=16475
System.Diagnostics.Process.Modules now also returns managed assemblies.
With this change it is now possible to use Process.Modules to retrieve
the place in memory of any loaded assembly.
ProcessModules relative to a managed assembly have a FileName that
starts with "[In Memory]".
Any port that writes to Environment.SpecialFolder.Personal during build
or when running tests may end up with files outside of stage area that
aren't cleaned up by the ports framework. The issue lies with Mono
looking in /etc/passwd first and only if no entry found there in HOME.
Patch based on discussion in
https://github.com/mono/mono/pull/371
Obtained from: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=193426
In order to resolve interdependencies between
static libraries we should create a temporary
throw-away ("convenience") library via libtool.
Should unbreak unit tests on Linux
The problem is that those two ops are required to be one after the other as there's an implicit register dependency between them.
OP_SAFEPOINT would clobber that register (RAX on amd64) and cause all sorts of issues.
The ResolveAssemblyReference task class keeps a reference to an
instance of AssemblyResolver, and AssemblyResolver keeps a cache
of assembly names, indexed by file name. The problem is that
the cache doesn't take into account that files can change between
builds.
For example, if a referenced assembly doesn't exist, the cache
will store that the file doesn't have an assembly name. If after
the build the file is created and a new build operation is started,
the cache will still return that the file doesn't have a name.
This is not a problem when running xbuild from the command line,
since every build starts a new process, but MonoDevelop uses
the MSBuild API to load and build projects, and doesn't start
a new process every time, so the cache is never cleared.
The solution is to keep the last write timestamp in the cache,
so that it can check if the file changed before returning the
cached name. It also needs to do a better handling of non existant
files.
This causes strange crashes on some Linux systems. We don't particularly need
the additional information to get useful backtraces (we can just fall back to
`dladdr`) so disable it for now.
If a file or directory are moved out of the watcher's path they are removed from the index, but they might still have events in the kevent() changelist. This would sometimes cause an exception.
We were observing dtest-006.exe test failing on armhf. This test
checks that a right shift with a negative shift amount and a
dynamic base is shifted by the right amount.
We were failing it because we were excluding the step that we
do in regular code generation, which is to do a binary and of the shift
amount so it behaves like we are shifting by the original shift
amount modulo 32. The C# spec defines left shift like so.
This commit adds that to the LambdaCompiler.
Implemented MonoAssembly.LoadWithPartialNameInternal.
Implementation is not 100% correct without handling stackMark properly.
Improving this would require the generous amount of work of adding
StackCrawlMark support to the runtime.
Fixes#27103.
XM 2.0 was the first version to ship the mobile (w/unified) and it used
the OS default codepage.
The previous, system mono, profile was already using the OS default
codepage so it make sense for XM to be consistent across profiles (
including the 4.5 subset)
AssemblyName.CultureName was returning "neutral" for invariant culture
info whereas .NET returns "".
This was causing problems in Roslyn while comparing assemblies with
an empty culture name against references that would have culture name
set to "neutral".
Fixes#30502.
605192528d used UTF8Unmarked for MONOTOUCH
and XAMMAC. However it's initialized differently (than the old UTF8) and
caused unit test regressions in System and System.Net.Http unit tests
This new logic moves the default encoding creation into the products
themselves.
These tests would tend to leave non disposed SafeHandle which would later be finalized, then throwing ObjectDisposedException. They would also crash on .NET.
Otherwise parallel invocations might end up stomping on eachother
(these two files are processed in parallel):
Processing /work/maccore/master/maccore/builds/install/mac/xammac/bcl/mscorlib.dll.mdb
Processing /work/maccore/master/maccore/builds/install/mac/net_4_5/bcl/mscorlib.dll.mdb
Unhandled Exception:
System.IO.FileNotFoundException: /var/folders/g9/k5kx4z211ld_lwlbfxv5rq040000gn/T/mscorlib.dll.mdb does not exist
File name: '/var/folders/g9/k5kx4z211ld_lwlbfxv5rq040000gn/T/mscorlib.dll.mdb'
at System.IO.File.Move (System.String sourceFileName, System.String destFileName) [0x00000] in <filename unknown>:0
at Mono.MdbRebase.MdbRebase.RewriteMdbFile (System.String inputFile) [0x00000] in <filename unknown>:0
at Mono.MdbRebase.Driver.Main (System.String[] args) [0x00000] in <filename unknown>:0
[ERROR] FATAL UNHANDLED EXCEPTION: System.IO.FileNotFoundException: /var/folders/g9/k5kx4z211ld_lwlbfxv5rq040000gn/T/mscorlib.dll.mdb does not exist
File name: '/var/folders/g9/k5kx4z211ld_lwlbfxv5rq040000gn/T/mscorlib.dll.mdb'
at System.IO.File.Move (System.String sourceFileName, System.String destFileName) [0x00000] in <filename unknown>:0
at Mono.MdbRebase.MdbRebase.RewriteMdbFile (System.String inputFile) [0x00000] in <filename unknown>:0
at Mono.MdbRebase.Driver.Main (System.String[] args) [0x00000] in <filename unknown>:0
When running MONO_LOG_LEVEL=debug xbuild with previous versions, it showed
that Microsoft.Build.Tasks.v4.0.dll was loaded, while the expected one was
Microsoft.Build.Tasks.v12.0.dll (as current xbuild script loads the one
from xbuild_12 profile). It was because Microsoft.Build.Tasks*.dll was
not referenced by xbuild.exe and thus it was loaded differently.
This hack adds strong reference to some class in Microsoft.Build.Tasks*.dll
of the corresponding version for each profile to resolve that issue.
1. Preserve ChannelFactory so that it can retrieve its ServiceEndpoint's
Binding's Timeout values.
2. Use DefaultCommunicationTimeouts.SendTimeout instead of ReceiveTimeout.
It was either written when I don't understand the API well or might be
different in duplex channel (who cares? nothing supports it now and
we will be switching to referencesource).
It is going to be my final contribution to WCF old codebase. Bye bye forever.
Instead of importing the source from referencesource, the algorithm has been reimplemented in our version. This is because their implementation uses multiple internal calls that do not need to be.
Place an upper limit on files loaded in the coverage profiler to 128k. If the
system suppression file exceeds that (it is currently only 3k), then there's
some problem and the profiler will exit. For other user files passed on the
commandline, we print a warning message and ignore them.
What happens here is the following:
When using chunked encoding, the ChunkStream sometimes mixes async and sync requests
on the underlying stream. The async calls work great - just the sync ones create
problems.
In this particular bug, the server returns two ApplicationData records - one big one
and then a smaller one. The chunk parser requests a sync read of 1024 bytes which
then result in a series of sync reads on the underlying network stream. The first
two or three network reads don't return enough data to fill the huge ApplicationData
record - the last one then returns so much data that it fills both the remainder of
the first record and the entire second one.
If the caller issued a second sync read, then the implementation would catch this -
but the async code path does not.
Instead of importing the source from referencesource, the algorithm has been reimplemented in our version. This is because their implementation uses multiple internal calls that do not need to be, and they are simple enough to just be reimplemented in managed code.
Changed GetDaylightChanges to match .NET behaviour.
GetDaylightChanges now only returns DaylightTime.Start and
DaylightTime.End in the given year.
DaylightTime.Start and DaylightTime.End may not belong to the same DST
period.
In mcs/ the install of xbuild_12 and xbuild_14 will end-up installing
the same files:
${NETFRAMEWORK_DIR}/v2.0/RedistList/FrameworkList.xml
${NETFRAMEWORK_DIR}/v3.0/RedistList/FrameworkList.xml
${NETFRAMEWORK_DIR}/v3.5/RedistList/FrameworkList.xml
${NETFRAMEWORK_DIR}/v4.0/Profile/Client/RedistList/FrameworkList.xml
${NETFRAMEWORK_DIR}/v4.0/RedistList/FrameworkList.xml
${NETFRAMEWORK_DIR}/v4.5.1/RedistList/FrameworkList.xml
${NETFRAMEWORK_DIR}/v4.5/RedistList/FrameworkList.xml
This is because there is no atomicity when installing each file, and
xbuild_12 and xbuild_14 may well run in parallel, each trying to install
each of those files; but the 'install' utility will first check if the
target file exists or not, and there is a race in doing so, thus leading
to build failures like so:
http://autobuild.buildroot.org/results/c32/c3288c5d1fb94474f14a4a889e76135878d403bc/build-end.loghttp://autobuild.buildroot.org/results/3cb/3cb99e5c5672cbaa2a86020129a05dfde47cdb8f/build-end.log
and many more:
http://autobuild.buildroot.net/?reason=host-mono-4.0.0http://autobuild.buildroot.net/?reason=host-mono-4.0.1
So, ensure ordering of the install of xbuild_12 and xbuild_14 (the
ordering is completely arbitrary, either way gives the same installed
files).
Signed-off-by: "Yann E. MORIN" <[email protected]>
Cc: Angelo Compagnucci <[email protected]>
On big endian systems, this code would break because we reinterpret the
structure as a `guint32` via memory. Fix this by reversing the order of
the fields on big endian systems.
This is needed because the fast paths in managed allocators (by design) don't
report allocations to the profiler. In regular JIT/AOT mode, managed allocators
are simply disabled to work around this when profiling. However, in FullAOT
mode, an image may have been compiled with managed allocators enabled which
results in the managed allocator actually being emitted into the AOT image.
So, when we want to profile a FullAOT image, we need to replace the regular
managed allocator with one that always goes through the slow path (i.e. calls
straight into the runtime). To that end, when we decode a MONO_WRAPPER_ALLOC
method ref, we redirect it to the appropriate slow path allocator if allocation
profiling is enabled.
By reporting allocations in the GC implementations, we significantly reduce the
odds of someone forgetting to add a mono_profiler_allocation () call. These
previously had to be placed at all call sites of mono_gc_alloc_* () which was
in some cases forgotten, resulting in the profiler seeing objects in GC events
which appeared to not have been allocated.
This was already done for SGen, but Boehm and the null GC still had a bunch of
code in object.c to allocate and prepare objects. This has now been moved into
mono_gc_alloc_* () functions so that all 3 GC backends have the same interface
for allocation.
setup_interface_offsets will be called multiple times. The code was originally
designed to avoid setting up this multiple times but a change to avoid making it assert
when used from SRE made it so that the check to avoid multiple initialization would
effectively make it be initialized multiple times.
See 628e025476 for the original change.
When using a TransparentProxy, we run into the problem that the cache is
shared between all marshalbyrefobjects. The fix here is to not update
the cache when using a TransparentProxy, so that the correct slow path
is used.
It seems the base utc offset can also have a sub-minute resolution
in Unix, which means we need to apply the whole-minute rounding to
the final result (dstDelta) instead of the intermediate ttype.Offset
value.
We need to try to fetch the exact timezone id to expose this bug,
since fetching all system timezones will just not return any
problematic timezones (and there is thus no way to distinguish
inexistent timezones from timezones that failed to load).
This could lead to hangs because threadpool->counter._.active would not be decremented. It means we cannot cleanup memory as the threads may still try to access the threadpool global variable.
For the helper and writer thread to actually work, we need Mono's threading
subsystem to be initialized (so we can use TLS and hazard pointers). We now
wait with starting these threads until Mono gives us the go-ahead.
This means that a bit more data will be buffered up in the thread-local log
buffers during startup, but it shouldn't really matter in practice.
Due to asynchronous abortion a crash is being seen on
posix systems where the abort signal handler is having a
data race and not exiting the suspend signal handler early.
When it tries to make a state transition because of this, it
cannot and it crashes.
This fixes it by making it synchronous.
The context-specific code now mirrors the thread-specific code and uses the
internal NamedDataSlot class. The runtime code now correctly frees context
static data allocated via this class.
This reverts commit 05ce4f6ee1.
It's giving some problems on Monodroid build:
/Users/builder/data/lanes/1196/012ff355/source/mono/mono/mini/cpu-arm.md
Invalid specifier len:4 at line 51 at /Users/builder/data/lanes/1196/012ff355/source/mono/mono/mini/genmdesc.pl line 153, <DESC> line 51.
I was induced in error because of the following comment in the machine read specs:
`# len:number describe the maximun length in bytes of the instruction
# number is a positive integer`
During thread shutdown, it gets to a point where the thread can no longer server suspend requests. To fix that
we ensure the thread gets one last suspend opportunity before going down.
Special static offsets now have a less magical format:
[0] 6-bit index into the array of chunks.
[6] 25-bit offset into the array.
[31] Bit indicating thread or context static.
Also wrapped accesses to these fields in macros and a bitfield struct.
Context static data is now scanned precisely in the same way as thread static
data. To facilitate this, the memory management of context static data has been
fixed to work similarly to thread static data. This further required that all
contexts be available for iteration, so contexts are now added to a global hash
table (by GC handle) when they are created.
Make sure we do not accidentally to encode an object by breaking out for
unknown TypeCode.Object instances (this is where the zero bytes used to
silently come from).
This commit adds the missing mapping from DateTimeOffset to its SqlDbType,
and makes sure they are converted to string 1. in a locale-insensitive
manner, and 2. with maximum precision.
Mono's implementation of DataTableMappingCollection used not to care,
but MS', merged from the .NET reference sources, throws an exception
if the source table name is empty.
Without this, variant output parameters are left unconsumed in the
input stream, and null is returned.
The new code skips the max length uint, and decodes a subset of the
variant types. What is not recognized is skipped, and we return null
as the previous code used to do.
(Ideally, the subset of GetColumnValue which decodes types which can
be embedded in a variant should be factored out to a different method,
and reused from GetVariantValue.)
On the wire, Variants are preceded by uint-encoded max length and
actual length (not bytes like smaller types). Without this patch,
SQL Server 2008 SP2 rejects our requests as truncated.
Without this, the TdsMetaParameter.TypeName ends up being null, which
crashes TdsMetaParameter.GetMetaType () when the variant value is
about to be serialized on the wire.
DateTime2 and DateTimeOffset are not directly supported by the TDS 7.1
wire protocol, which is the version implemented by Mono's current TDS
driver. (Tds80.cs does in fact advertise version 0x00000071.)
Bumping the protocol version to 0x03000a73 or 0x03000b73, for TDS
7.3.A/7.3.B, is not sufficient; the stream generated by the driver
causes SQL Server to kill the connection right after the login packet.
More investigation is needed on that front.
SQL Server is fine, however, with us sending timestamps in
literal (ISO 8601) format down the wire, packed within ASCII char(n)
strings. Which is what this patch does, which allows client code
perform inserts using, e.g.:
var param = new SqlParameter("@Value", SqlDbType.DateTime2);
param.Value = DateTime.Now;
command.Parameters.Add(param);
The cleanup code would wait for all worker threads to finish, but that could lead to some workload that would block. By disabling the cleanup code, we do not wait on anything to happen, we count on the OS to clean everything up.
Replace the reversed linked implementation by an array based implementation. This will improve Combine performance, as well as ease delegate to virtual function optimization.
Fixes IsDaylightSavingTime returning false when
SupportsDaylightSavingTime was set to false because TimeZoneInfo was
create with no AdjustmentRules.
Now if TimeZoneInfo uses transitions SupportsDaylightSavingTime will be
set to true regardless of AdjustmentRules.
The pointer the function would have to return would be to a chunk of managed
memory, for the object to be allocated. It can't do that because it is not in charge
of the managed heap. The best it could do would be to free some unmanaged
memory and tell the allocator try again.
This should always be inlined. We also need this there because we'll put the
profiler calls there.
This introduces fickle dependencies in the order of which things are declared
and inlined. It would be nice to have a cleaner solution.
We use client callbacks from the binary protocol functions. There are some DTrace probes
which we don't have binary protocol entries for. Since DTrace isn't properly supported
anyway (and doesn't even work as it should on OSX), we just remove those probes instead
of making new binary protocol entries.
StackStrace.ToString logic was duplicated in System.Exception and
System.Diagnostics.StackTrace.
Exception.StackTrace output was not changed.
StackTrace.ToString's method signature was changed, it is now the same
as Exception.StackTrace, which is more similar to the .NET one. This
affects generics and ref parameters representation.
Fixes random/strange hangs/crashes (many native API starts returning
out-of-memory errors when there is plenty of memory available, other
just hang inexplicably) when profiling.
When copying value types (like via Array.Copy) it was possible to
encounter a memory region going over the end of the card table array.
In that case we would overwrite data after the card table and fail
to mark cards at the start of the array.
It's hard to do a test case for this because we allocate the shadow card
table directly after the regular one, so the overwrite is benign. It would
also require allocating very large arrays (>2Gb) and run very slowly.
We're adding this new API call to replace the `g_assert (mono_error_ok (&error));` code pattern so that when there's an error we can print the error message from the MonoError.
The reference sources do not support sub-minute DST offsets as the exception below
shows, while Europe/Dublin has a DST offset of 34:39 in 1916.
There is no equivalent TimeZoneInfo for Europe/Dublin in .NET, so the problem
doesn't show up there.
System.ArgumentException: The TimeSpan parameter cannot be specified more precisely than whole minutes.
Parameter name: daylightDelta
at System.TimeZoneInfo/AdjustmentRule.ValidateAdjustmentRule (System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo/TransitionTime,System.TimeZoneInfo/TransitionTime) [0x0012c] in /work/mono/master/external/referencesource/mscorlib/system/timezoneinfo.cs:3907
at System.TimeZoneInfo/AdjustmentRule.CreateAdjustmentRule (System.DateTime,System.DateTime,System.TimeSpan,System.TimeZoneInfo/TransitionTime,System.TimeZoneInfo/TransitionTime) [0x00000] in /work/mono/master/external/referencesource/mscorlib/system/timezoneinfo.cs:3836
at System.TimeZoneInfo.ParseTZBuffer (string,byte[],int) [0x002ca] in /work/mono/master/mcs/class/corlib/System/TimeZoneInfo.cs:1230
at System.TimeZoneInfo.BuildFromStream (string,System.IO.Stream) [0x00030] in /work/mono/master/mcs/class/corlib/System/TimeZoneInfo.cs:479
at System.TimeZoneInfo.FindSystemTimeZoneByFileName (string,string) [0x00018] in /work/mono/master/mcs/class/corlib/System/TimeZoneInfo.cs:463
at System.TimeZoneInfo.FindSystemTimeZoneById (string) [0x00075] in /work/mono/master/mcs/class/corlib/System/TimeZoneInfo.cs:450
at MonoTests.System.TimeZoneInfoTest/FindSystemTimeZoneByIdTests.Dublin () [0x00015] in /work/mono/master/mcs/class/corlib/Test/System/TimeZoneInfoTest.cs:812
The profiler API needs to evolve with the runtime. By versioning the API we can
at least to some degree let developers know when their modules are out of date
and how to update them.
Just like BinaryMessageFormatter needed to use another CreateBinaryWriter()
overload to NOT close the input stream, use CreateTextWriter() overload that
does not close the stream.
I wonder why, but when switched to referencesource, it turned out that
ResourceCollectionInfo calls SyndicationElementExtensionCollection.Add()
which targets a private overload, but (of course) failed and resolved to
another overload that takes object, and thus resulting in invalid code path.
With this fix the call to Add() resolves to the expected one and does not
regress with referencesource import.
Those tests were added without considering TimeZone difference. They cause
several kind of errors (SerializationException etc.) in JST (+09:00) or any
timezone that is earlier than UTC.
We likely had some "working" implementation, but was incompatible with .NET.
The namespace declarations existed when the entire Message is read but not
in the partial body contents. They caused regressions when we use
serialization stack from referencesource.
It is possible that more namespaces may be requied, but we will be importing
System.ServiceModel later on and then the issue will go away.
So far we don't want regression as long as they show up in our NUnit tests.
Unlike our own XsdDataContractExporter, referencesource one generates
an extra schema that targets xs:* (XmlSchema.Namespace).
That should not be generated as part of WSDL, so exclude it.
WriteStartDocument() can be used with document and document does not accept
more than one element, which basically contradicts MTOM writer usage.
For EOL changes, MTOM writer should not alter content EOL chars.
The removed code caused unexpected omission of xsi:type by giving "false"
Type information that is from the actual value (when the expected type is
different, xsi:type should be written).
The original code is complicated enough that I misinterpreted the logic...
The reulting code should look like this:
DateTime? expr_94 = timeSubmitted;
DateTime dateTime;
bool arg_B5_0;
if (XmlObjectSerializerWriteContext.GetHasValue<DateTime> (expr_94)) {
dateTime = XmlObjectSerializerWriteContext.GetNullableValue<DateTime> (expr_94);
arg_B5_0 = false;
}
else {
dateTime = XmlObjectSerializerWriteContext.GetDefaultValue<DateTime> ();
arg_B5_0 = true;
}
The fixed code should be like this now.
Basically the primary cause of the problem was that invoked primitive array
reader methods via reflection had 'out' parameter, which needed special care.
The new code is to implement reflection (non-emit) based serialization
so that it works on iOS.
Actually I _totally_ switched to this new implementation because dynamic
method based implementation also doesn't work fine, even on desktop
(due to invocation failure on internal methods, it seems that our dynamic
method needs some bugfixes).
The new methods with NotImplementedException in new classes need to be
implemented.
When we moved to Vista as the minimum build target, the mingw build broke.
The reason is that mingw's mswsock.h has the following code:
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
int WSAAPI WSAPoll(WSAPOLLFD, ULONG, INT);
#endif
Unfortunately, due to a bug mingw 4.0 doesn't define WSAPOLLFD and the compiler
raises an error. See http://sourceforge.net/p/mingw/bugs/1980 for more details.
As a workaround, inline the typedef for WSAPOLLFD from the mentioned bug report.
Also removed an unecessary check for _WIN32_WINNT < 0x0502 from the file.
Security declarations looks very similar to custom attributes - but
they are not (e.g. a different metadata table).
They need to be marked, just like other metadata, by the linker because
they can encode types that won't show up in the type (or assembly)
references.
Ignoring this can create an invalid binary (the kind that even Cecil
can't load back for further processing).
The exact name (e.g. version) might differ between the original
AssemblyNameReference and the one being used (e.g. PCL).
To make sure we remove unused references we need to resolve
the AssemblyNameReference into AssemblyDefinition and then
continue the sweep based on the _new_ AssemblyNameReference.
The new suspend code works on all major targets, so it's time to remove old suspend.
This change removes all relevant native code, managed code could see some cleanup.
This fixes a couple of small issues with the Visual Basic build support:
- The VBC task now respects the $(NoStdLib) MSBuild option.
- The field @(ReferencePath) should be used for References in the VBC
target as it is for the CSC target.
- The CreateVisualBasicManifestResourceNames task is compiled and used
in the same manner as CreateCSharpManifestResourceNames hence it should
be loaded via UsingTask in the same manner as well.
- Include the VisualBasic Portable targets files.
The VB language requires that code files have statements in the
following order:
- Option
- Import
- Assembly level attributes
- Namespaces / other declarations
The VBCodeGenerator type when given both import and assembly level
attribute statements was generating the attributes first. This lead to
compilation errors in the generated file.
This change fixes the generator to emit assembly level attributes in
the proper location in the file (and adds the corresponding unit tests
as well).
The new socket constructor that only takes a SocketType and a
ProtocolType defaults to InterNetworkV6 (this was done on a previous patch).
In addition, we explicitly set "DualMode" to true, so that on Windows,
this gets set explicitly (it does not matter on Unix).
We surface the DualMode property to allow servers that want to just
bind to the IPv6 address to do so by creating the socket and then
changing DualMode to false.
This is *not* the same setting that Windows has, but it is the
semantics that Mono applications depend on. So a test has been added
to ensure that we do not regress.
This also switches to use SocketOptionName from the ReferenceSources.
Every once in a while, we run into a NullReferenceException attempting to dispose a null timer. It's very rare and we can't reproduce. However, reading this code, it seems possible that two timer callbacks could pile up, and if they did, the first one might dispose the timer, and then the second one would attempt to dispose null.
This change enables managed polling to work with both NaCL and coop as they are exactly the same except for the variables used.
We cleanup how safepoints are injects to be done on a separate pass instead of having in spread around the JIT.
We now inject safepoints at EH handler entry as those did not previously have them.
The generated AOT code was greatly optimized by having the polling variable checked before doing the icall. This more
than doubles the performance of the generated code.
This change adds support for the following MSBuild properties which are specific to VB compilation:
- OptionInfer: controls the /optioninfer switch
- VBRuntime: controls the /vbruntime switch
Concurrent mark modified the card table directly, which had two
drawbacks.
First, it meant that nursery collections would also have to scan the
cards marked by the concurrent collector, which was unnecessary work.
Second, because the nursery collector also modified the cardtable, it
meant that the two could not run concurrently, i.e., we had to suspend
concurrent marking work whenever a nursery collection occurred.
The issue was discovered when using monodoc in an asp.net application; while the code was developed and worked successfully in the local Visual Studio web server, it failed when deployed and executed in IIS. The reason it seems is because of the use of `.GetCallingAssembly()`, which was returning an unexpected assembly reference. This resulted in the `.GetManifestResourceStream` returning null for resources that are definitely a part of monodoc.dll.
Once the code was changed to get the assembly using a type reference of a type that's definitely in monodoc.dll ... the code resumed working as expected.
This does not import System.CodeDom.Compiler because some of them depends
on Windows specific stuff.
CodeGenerator is imported because ours depends on our own internal
Visitor implementation and could not build without making changes a lot.
This allows a piece of code to handle the cases where it's called in running and blocker context
and must always be in blocking context.
This probably makes code more modular at the expense of an easy to follow and debug execution model.
Since we don't currently annotate all icalls with blocking sections we do it with locks but they can
nest and recurse which requires this support for try block.
The commit removed the AC_DEFINE for TARGET_WIN32 from configure.ac,
but many parts of the build rely on it so the build broke.
Fixed this by defining TARGET_WIN32 when we detect it is the target
and do the same for HOST_WIN32.
ArgumentOutOfRangeException expects the parameter name first, then the message. ArgumentException is precisely the opposite, and expects the message first, and then the parameter name. They were swapped here.
In .NET regardless the current time zone, TimeZone.CurrentTimeZone.GetUtcOffset returns TimeSpan.Zero when called with an UTC DateTime.
Similarly IsDaylightSaveTime returns false when called with an UTC DateTime.
Eventually we want to add a better fix for this, like for instance adding this behaviour to the LLVM-specific code path
but until we can research more under exactly what conditions we need to do this then implement this simple workaround.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=27055.
We fully control the $target values here as we don't use canonicalization for
them. So we have no reason or excuse to be using wildcards in them.
E.g. any Linux $target in this case would previously be assumed to be Android.
The overflow check is only performed when the result is big enough.
The overflow check is done by decomposing 64 bit operations into 32 bit operations.
Fixes#17817.
- Fix handling of lo64 on big endian systems (fixes 28672)
mono-endian.h:
- Add optimization for s390x read64/read32/read16 operations
exceptions-s390x.c:
- Add profiling support for exception handler
We had a failing arm test which exposed that our caching of the
number of processors was leading to some inconsistencies when
the number of processors increased. TODO: Use the actual number of
online processors when rebalancing threadpool.
Rename the net_4_0 profile which is already only used to trigger copying of reference assemblies
to binary_reference_assemblies and include the 2.0/3.5 files there. This should make it easier
to add more profiles in the future and doesn't clutter the build system as much as making separate
net_2_0 and net_3_5 profiles that do the same.
This fixes a bug where we did not completely mimic .NET's exception handling.
We previously held onto the stacktrace when an exception was thrown if it already had one. This differs from how .NET behaves, which is to always set the stacktrace to the place that it was last thrown.
Ex:
using System;
class C
{
static Exception e;
static void Throw ()
{
try {
int.Parse (null);
} catch (Exception ex) {
e = ex;
}
}
public static void Main ()
{
Throw ();
try {
throw e;
} catch (Exception ex) {
Console.WriteLine (ex.StackTrace);
}
}
}
Would previously output:
at System.Int32.Parse (System.String s) [0x00000] in <filename unknown>:0
at C.Throw () [0x00000] in <filename unknown>:0
when
at C.Main()
is what .NET output. After this commit we output the same stacktrace as .NET.
They build in both desktop and mobile profiles, but the sources are
mostly unchanged i.e. they contain Windows dependent code (DllImports).
The plan here is to import everything essential in WCF as buildable
sources, then remove Windows dependencies, then implement (or bring back)
mobile-ready code. But this commit can be used for different strategies
(like, we import sources from working parts, step by step).
ConcurrentOrderedList isn't referenced in corlib's .sources file or anywhere else anymore,
so it was missing during "make distcheck".
Mono.Parallel still needs it though (and it is the only place), so move the file there.
We cannot start threads during stop-the-world pauses (some thread APIs,
including pthreads, can deadlock), and we want to do marking and sweeping
with the same threads. This new thread pool facility will allow that.
We tag pointers to blocks that are currently being processed. Those
must not even be dereferenced by other threads because the sweep
thread might free them at any point.
The nursery collector requires that sweeping has finished, and instead
of waiting it will cooperate with the sweep thread to finish more
quickly. The sweep thread will traverse the block array from high
indexes to low ones while the nursery collector will go from low to
high. They will contend only very briefly when they meet somewhere in
the middle.
Both the concurrent sweep thread as well as the nursery collector will
need access to the block array. Until we've made that lock-free,
we're simply using a lock.
AdjustmentRule specifies a DST period that starts and ends within a year.
When we have a DST period longer than a year, the generated AdjustmentRule may not be usable.
Thus we fallback to the transitions.
Fixes#24086.
Addresses an oversight in PR 1257 that caused {V}Specified fields to not be set during XML deserialization in some circumstances.
Adds test for optional value serialization round trip
WebConnectionGroup.Close() calls WebConnection.Close(), which takes connection lock and then takes the service point lock. Calling WebConnectionGroup.Close() leads to taking the service point lock *before* the connection lock, which leads to a deadlock.
Coop requires the following set of rules:
-blocking code must be wrapped with MONO_PREPARE_BLOCKING / MONO_FINISH_BLOCKING
Must not read managed refs read/writes inside the block
Managed memory (i.e. inside a byte[]) must be previously pinned[1]
-state escaping transitions (lazy thunks and others sneaky n2m transitions) must be wrapped with MONO_PREPARE_RESET_BLOCKING / MONO_FINISH_RESET_BLOCKING
This lands the thread in runnable state, so be careful to keep it suspendable by following the target environment rules.
The set of rules for what runtime code can/can't are still in flux, but here's the tentative list:
== On Wrapping syscall/waits
- Wrap it on the callee. We can't necessarily know in which context the syscall will be called. This will reduce reentrancy issues as blocking is not reentrant.
- Don't go blocking while holding locks as this will certainly deadlock.
- Avoid allocating memory while holding locks.
- Annotate blocking restrictions in the comments in the same way we do it for locking.
== On aborting blocking
- Avoid it as much as possible as it might lead to unbound pauses.
- Make sure you can always restore back to blocking.
[1] Since we conservatively scan the native stack, acquiring the ref outside of the block is enough for now.
Make sure all logging include the thread tid to ease correlation.
Add counters to check for proper balance of post/wait on the suspend semaphore.
Massive improvement in the coop suspend wait timeout crasher. It will now print
a cue card on the internal states. This makes finding the offending threads much easier.
Method index will be set if the method metadata token is shared by multiple generic specializations.
For StackFrame.GetILOffsetFromFile to work with generics methods a method index is required.
When creating a Mono.Security.Uri with the string "file:///var/lib/jenkins/workspace/test-mono-mainline@2/..."
(happens sometimes in System.Security.Policy.Zone-related unit tests on Jenkins) the current implementation
strips everything up until the @ sign.
Zone thinks the file doesn't exist locally as the Uri.LocalPath doesn't refer to a valid file on disk
anymore and this results in an incorrect zone value, making the tests fail.
Fixing this by treating the @ char differently when it is in an absolute path (as is done for other chars).
This splits the native backend from core functionality it needs to provide. For example,on posix, we want to
use the pthread_create code regardless of the backend enabled.
Native code should not normally be in runnable state. That's reserved only for managed code. In theory.
In practice any code that can witness the managed heap must be in the runnable state.
This in practice means all runtime code (icalls) and embeders. Right now lets focus on the runtime side.
The solution for this is to wrap all calls that could lead to unbound suspension in code that coordinates
with the GC - most syscalls that can block. This is realized with a pair of additional thread states.
1)Blocking: This the state where the runtime is doing something that can potentially block. The suspend count
will be > 0 if the current thread is suspended. In practice it won't suspend, just wait on resume.
2)Blocking and suspended: When leaving the blocking state, if the thread has a pending suspend, we transition
to this state while waiting for resume.
This move allows us to save the thread state much earlier on. In addition to the move, we now produce thread contexts without
the JIT TLS set. This might end up been an issue in some corner cases, just like with domain, so we'll address those when
they show up.
Other places are already logging tid so this makes correlation possible.
TID is a better pick than the MonoThreadInfo pointer as it's easier to find the thread on gdb.
Basically Microsoft SqlClient implementation is full of Windows dependencies
that doesn't work elsewhere. Our implementation has been fully managed
TDS implementation, so we want to bring it back.
This only builds and is not known to "work" yet.
Android does not provide complex.h in the API levels that we compile against so bundle our own header (based on the one from FreeBSD).
Turns out GCC already provides built-in handling for the complex functions used by the code so there's no need to provide our own implementations.
As it turns out, `perf` support crashes/hangs on a lot of Linux
kernels in the wild, and produces no output on some Android devices.
So, given that using a signal + helper thread is more reliable, use
it by default and make `perf` support optional.
The configure flag is now `--enable-perf-events`.
mono_aot_get_method () will not necessarily put methods into the
MonoDomain::jit_code_hash table. But it does return an IP that we
can use to look up the JIT info with mono_jit_info_table_find ().
src: https://bugzilla.xamarin.com/show_bug.cgi?id=27864
As of iOS 8.2 Apple updated Sqlite and broke queries that used to work
pre iOS 8.2 like the select command in this test, The pruppose of this
test is to know when apple fixes this. Expected test behaivour is as follows.
* If iOS 8.2+ Test will pass as long as apple does not fix the bug
* If iOS < 8.2 Test will pass as it does work as expected
* If iOS 8.2+ and apple fixed bug 27864 test will fail and we will need to
remove the fail check on lines 105 and 106
Filled with Apple. From bug report:
The problem appears to be caused by a bug in mmap on the arm64 ios.
In this test, we request a page and mmap returns successfully, but when trying
to access the mapped memory, the program crashes after the 4097th byte, meaning
that it only maps us 4kb(???). It should be mentioned that on arm64 ios the
page size is 16kb.
The way we calculated slot sizes was very brittle when it came to
small slots. Reducing the size of the block header could trigger it
skipping an important small size class, which would lead to increased
memory usage and slower execution times.
Now we always produce all possible small slot sizes, up to four times
the minimum object size.
The code just worked because it never reset cementing. It needs to be
completely rewritten.
With cementing enabled, at the start of a major concurrent
collection, we cannot reset it. That's because if we have
cemented objects, some remsets to them will be missing, and the
major collector does not scan the whole heap immediately, like
the non-concurrent one does.
The proper way to do it seems to be to reset cementing before
finishing a concurrent collection. All major objects that point
to formerly cemented objects must either be marked in the
mod-union table or the current card table. When we scan the card
tables, we should be able to just evict objects.
Currently, the finishing collection pause still does some
scanning via the worker thread. This might be a problem.
These two are consistently failing due to port re-use. Other hard-coded
ports exist, but let's target the *known* issues primarily, and can
handle the others ad-hoc if they demonstrate that they're problematic.
CreateLocal could fail in an unexpected manner. The change re-enables fall back to environment variable "TZ" and allows TimeZoneInfoNotFoundExceptions to be thrown instead of NullReferenceException.
The use case here is when you are documenting a managed wrapper on top of a native platform API. This related link can be used to link to the original platform documentation for that member. This lets the reader look up the semantics of the native call without you having to duplicate the documentation in the managed reference docs; leaving you to focus your energies on documenting any unique considerations when calling this managed API.
Example:
```xml
<related type="PlatformDocAPI" href="https://msdn.microsoft.com/en-us/library/system.console.writeline">Microsoft documentation for <c>System.Console.WriteLine</c></related>
```
If you have a URL of the form ``T:System.Collections.Generic.Dictionary`2``, it parses correctly, but the `EcmaDesc` instance returned by the parser will throw an exception if you try to call the `.ToEcmaCref ()` method. This patch resolves this issue and returns a correctly formatted URL in this instance. Unit test included.
The existing update was not doing a good job of matching members that have both generic and non-generic members. So for example, if you had a method, `Foo<T>`, and added a non-generic version in a future update (`Foo`); you could end up with a situation where one of the members was being duplicated.
at System.ThrowHelper.ThrowArgumentOutOfRangeException () [0x00014] in /Users/marek/git/mono/external/referencesource/mscorlib/system/throwhelper.cs:56
at System.Collections.Generic.List`1[System.Threading.Thread].get_Item (Int32 index) [0x0000e] in /Users/marek/git/mono/external/referencesource/mscorlib/system/collections/generic/list.cs:199
at System.Net.Sockets.SafeSocketHandle.ReleaseHandle () [0x00052] in /Users/marek/git/mono/mcs/class/System/System.Net.Sockets/SafeSocketHandle.cs:79
at System.Runtime.InteropServices.SafeHandle.RunRelease () [0x00091] in /Users/marek/git/mono/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs:203
at System.Runtime.InteropServices.SafeHandle.Dispose (Boolean disposing) [0x00019] in /Users/marek/git/mono/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs:171
at System.Runtime.InteropServices.SafeHandle.Dispose () [0x00003] in /Users/marek/git/mono/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs:150
at System.Net.Sockets.Socket.Dispose (Boolean disposing) [0x0004d] in /Users/marek/git/mono/mcs/class/System/System.Net.Sockets/Socket_2_1.cs:1168
at System.Net.Sockets.Socket.Dispose () [0x00003] in /Users/marek/git/mono/mcs/class/System/System.Net.Sockets/Socket_2_1.cs:1174
at System.Net.Sockets.Socket.Close () [0x00009] in /Users/marek/git/mono/mcs/class/System/System.Net.Sockets/Socket_2_1.cs:1185
at System.Net.Sockets.TcpListener.Stop () [0x0000d] in /Users/marek/git/mono/mcs/class/System/System.Net.Sockets/TcpListener.cs:296
at System.Runtime.Remoting.Channels.Tcp.TcpServerChannel.StopListening (System.Object data) [0x00022] in /Users/marek/git/mono/mcs/class/System.Runtime.Remoting/System.Runtime.Remoting.Channels.Tcp/TcpServerChannel.cs:257
at System.Runtime.Remoting.Channels.Tcp.TcpChannel.StopListening (System.Object data) [0x00013] in /Users/marek/git/mono/mcs/class/System.Runtime.Remoting/System.Runtime.Remoting.Channels.Tcp/TcpChannel.cs:105
at System.Runtime.Remoting.Channels.ChannelServices.UnregisterChannel (IChannel chnl) [0x00057] in /Users/marek/git/mono/mcs/class/corlib/System.Runtime.Remoting.Channels/ChannelServices.cs:463
at MonoTests.Remoting.CallsDomainServer.Stop () [0x00012] in /Users/marek/git/mono/mcs/class/System.Runtime.Remoting/Test/BaseCalls.cs:445
at (wrapper remoting-invoke-with-check) MonoTests.Remoting.CallsDomainServer:Stop ()
at (wrapper xdomain-dispatch) MonoTests.Remoting.CallsDomainServer:Stop (object,byte[]&,byte[]&)
CloseConnectionGroup can concurrently call RemoveConnectionGroup and remove a group that has added to removeList.
We now check that the group still exists before removing it.
Fixes#19823.
This will let us have both the Mono and the Microsoft ThreadPool at the same time.
To switch to the Microsoft one, set the MONO_THREADPOOL environment variable to "microsoft". It will default to the Mono one.
Support by the runtime is also implemented.
The main goal of this change is to ensure that all methods have a `TYPE_JIT`
event emitted in the stream before they are referenced in other events. Before
this change, `TYPE_JIT` events could arrive out of order or not be emitted at
all because of generic sharing.
We now use a separate thread for writing log buffers to the output file.
Whenever a method is referenced in a TLS log buffer, we add it to a TLS list of
methods. When we ship the TLS log buffer off to the writer thread, we also send
the TLS list of methods. The writer thread first goes over all the methods and,
if some of them haven't had a `TYPE_JIT` event emitted yet, emits them to a
temporary buffer which is flushed just before flushing the main log buffer.
This approach ensures that `TYPE_JIT` events will *always* come before the
events that reference them.
Bookkeeping of which methods have been emitted to the output stream is done in
a global, concurrent hash table. Before a thread adds a method to its TLS list
of methods, it checks if the method is in the hash table. If it is, we know
that the method has already been emitted to the output stream, so it isn't
added to the list. The writer thread is the only thread that updates the hash
table (which happens when it flushes the temporary method buffer). So,
eventually, all TLS method lists will end up being empty because all methods
have been emitted to the output stream.
When ReleaseHandle was called by RegisterForBlockingSyscall's DangerousRelease the current thread would be in blocking_threads but there would be no blocking system call to interrupt.
For some reason accept can only be interrupted by thread_abort.
We do not want to use thread_abort by default because it may abort non-atomic operations at an arbitrary point.
The problem was fixed by calling thread_abort_safely, and make sure the target thread was interrupted by calling thread_abort afterwards.
In this change thread_abort is only called if thread_abort_safely returns KERN_SUCCESS, which *should* mean that the target thread has already left the kernel code by the time thread_abort is called.
The problem was caused with the introduction of the pushless backend. We have to compensate for the arguments being popped by native stdcall callees, to keep param_area from shrinking. Fixes#27597
For the case of non-concurrent collector we don't want to mark stores from the heap to the heap, since it would add sgen overhead. When aot compilling we don't know whether the GC will be concurrent or not, so we fallback to the write barrier method.
We emit two write barriers, for the case of the concurrent and non-concurrent collector in the mscorlib image. All calls to the write barrier are made through the plt, calls which are resolved according to the GC configuration at runtime.
Move the ResumeThread () calls out of the assert and check for 0 (which means that the thread was resumed) instead of using the Mach-specific KERN_SUCCESS on Windows.
Fixes the Windows/MSVC build.
Related to https://github.com/mono/mono/commit/296347f.
With the new function it is possible to retrieve other processes start, user and kernel times.
In mach start time is available without special privileges but user and kernel times still require privileges.
This fixes an issue when building dotnet/corefx and all the SR.cs files are modified
because Mono used a HashTable internally in ResXResourceReader and it returned the
elements in a different order than MS.NET.
Even though this isn't explicitly mentioned in the docs, the MS.NET implementation returns
the elements in the same order as they appear in the resx and we should do the same.
We need an extra set of quotes around the whole command to properly handle commands
with spaces since internally the command is called through "cmd /c.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=27899.
All primitive types have a short encoding format that avoid using
a typeref token.
It's possible to encode them in another, longer, form with ELEMENT_TYPE_VALUETYPE + a typeref token.
Up to now, this was never seen in the wild so we never supported it.
This patch allows long form encoding of primitives.
STW and managed suspend share a lock to ensure there is only one active suspend initiator.
This originally caused a problem in the managed suspend path as it could be async suspended while it was
in the middle of the suspend protocol (check if top of stack is managed, install abort handlers, etc).
This was worked around by putting that inside a suspend critical section. The resulting code was horrible
as suspend boundaries became unstructured (yeah, pretty stupid idea on my end). Not only that but it had
a race condition.
If a thread doing managed suspend raced with a STW and lost, it would block on the global suspend lock to
finish. That thread would be blocked inside a critical section - the single thing you must not do inside one.
This could be reproduced by stressing mono/tests/sgen-new-threads-dont-join-stw.
The solution is to execute the managed suspend sequence in the same fashion as of a STW. IOW, take locks,
suspend, do stuff, maybe resume and drop locks.
The critical part is the "do stuff" one, which is different for abort and suspend, but everything else
is the same. So we wrap that into a callback and put the common parts in mono-threads. This gives
us structured locking and suspend boundaries.
This won't cause a GC to take longer to init as the critical section would block the STW from progressing
anyways.
While running tests if a socket is closed while blocking system calls are pending an exception is thrown.
A socket should not be closed when a blocking system call is pending.
The purpose of the exception is to inform us when AbortRegisteredThreads is not working.
Having a single unwind state means writes to it must be synchronized between sync and async suspend. We can't
have the state be broken as it could lead to bad unwinding or GC marking.
The original solution was to have an additional state in the self suspend path that signals it's writing to the
thread state and thus any async suspend must give up and let it finish. This ended up been overly complicated
as this requires two additional states instead.
By having a pair of unwind states both can write concurrently without the fear of clashing. This makes fetching the state
a little bit trickier but worth the trouble.
The simplified design has a much smaller state space, which is easier to reason about.
When begin async suspend lands in STATE_SUSPEND_IN_PROGRESS, the initiator don't need to perform an async suspend, it just needs to wait.
If a self suspend is promoted to an async suspend, it must be added to the pending ops set. This ensure that it will be waited otherwise
the suspend initiator might witness an unfinished self suspend and assert when fetching the thread state.
The alternative would be to change finish async suspend to account for the possibility of witnessing STATE_SUSPEND_PROMOTED_TO_ASYNC.
Solving this way requires less async suspends and doesn't increase the valid state space.
The new suspend machinery is based around a single word state machine that is manipulated using CAS.
This solves the first set of problems with the current approach, the lack of atomicity and the impossibility of
doing race free manipulation of protected state. This is specially acute when doing a self suspend.
Suspend data must be atomically protected while we prepare to self suspend so a resume request won't race with the current
thread putting itself to sleep. This is a classical problem that calls for a mutex/conditional variable pair. Except that all
locks in the suspend path must be suspend safe. Wait, WHAT?
A Suspend Safe Lock is a primitive that is obstruction free in the face of the kernel suspending a thread either performing a
lock operation or waiting on a lock to become available. This, unfortunately, is not possible with pthread_mutex on OSX. The
only safe primitive are kernel semaphores, for which doesn't exist conditional variables for.
So back to locking and self-suspend. We need a lock because the existing thread state is not atomic but we can't use a
mutex/condvar pair so we're left with racy code. Yay! The fix is using CAS over a single variable.
Another change was the hardening of the suspend/resume code on posix targets. First we replace a semaphore wait with
sigsuspend for async suspend. This is needed since sem_wait is not async-signal safe (yet sem_post is). Second, we now
respect interruption requests by having a pair of suspend signals, one with SA_RESTART and one without.
Onto the design of the suspension system, a few concepts that are useful looking around.
* Self suspend: This is when the thread decides to suspend itself.
* Async suspend: This is when a thread decides to suspend another thread.
* Suspend Initiator: This the name of a thread that decided to suspend one or more other threads. This is important
since all suspending threads will notify it when they are suspended. There can be only one initiator in the system
at a given time.
* Suspension count: Number of resume calls before a thread is back to running state.
There are 7 states that can happen while a thread is runnable:
* Running: just running...
* (Async|Self) Suspended: Suspended, the difference comes into play when resuming.
* (Async|Self) Suspend Requested: Suspend requested, but not completed. See more below for the discussion on why the request state is needed.
* Suspend In Progress: Self suspend started saving its state thus async suspend should not modify it.
* Suspend Promoted to Async: Async tried to suspend a thread in the middle of a self suspend, it wants to be notified.
Now to the suspension protocol and how it happens on a high level view.
Suspension starts with a suspend request, which bumps the suspend count by one. This suspend request can be fulfilled either
by an async or self suspend action. This is confusing as there's only one initiator but any number of threads can be self suspending.
Async suspend then performs a platform specific action such as posix signals that forces a transition on the target. In the case
of self suspend, it depends on the thread polling its state and trigger the transition.
This works fine except that the suspend state is one huge struct with tons of fields. To control concurrent access to it we use a
single initiator in the case of async suspend and we put the thread in a transitional "saving my state" in the case of self suspend.
In the case of async suspend, the initiator must wait for all 1+ threads to notify back that they have suspended. Only after that
it's possible to know if the async suspend request actually worked or not (we might have hit a dying thread).
Together with this, there's an optional implementation of STW in sgen that can use this new machinery. To enable it set the
MONO_ENABLE_UNIFIED_SUSPEND env var for now while it gets more testing.
They're basically the same thing, but v120 has DX10+ capabilities and v120_xp
is DX9 only. Since we're not building against DirectX, the difference is
purely academic - but changing the value to v120_xp means MSVC binaries run
on XP+, not Vista+
This change was made so StackFrame dumps now show a native offset when the IL offset is unknown.
The native offset can be used by mono-symbolicate tool to retrieve an IL offset from a .msym file.
With AOT sequence points are stored in a .msym file.
As the sequence point data is not avaible at run time, AOT stack traces display a native offset.
mono-symbolicate tool is now able to retrieve an IL offset from a method name, native offset, and the data stored on the .msym file.
The IL offset can then be use to retrieve a filename and line from a .mdb file.
Abstract classes can still have subclasses with KnownType attributes, which are allowed in deserialization.
This used to work as the '__type' hint was always honored no matter the type, and broke with https://github.com/mono/mono/commit/71e152accc727089faffa6b4fd6bf58cb62636cf which removed that behavior.
It fails randomly on Jenkins and my own CI. To reproduce, just wrap the body of the test in while(true) and run for a few minutes.
I tested on MS.NET as well and it fails the same way there, so it's not Mono's implementation of Dataflow.
Filed https://bugzilla.xamarin.com/show_bug.cgi?id=27757 for tracking.
There was a memory leak caused by not having a lookup mechanism for
the RegistryKey. In addition, the entire code to dispose code was
never used (due to the leak), and it was wrong.
In addition, added locking to the "values" field, which currently was
racy.
No test cases, the repro is to run the above code for about 5 minutes.
This is a bit of an hack but it works for now... ideally we should be processing the Unicode command line flags passed by the CRT at startup instead of trying to convert the MBCS string to a wide string.
That was still useful in 2003/2004 but the technical and legal landscape
changed a lot since then. Removing the old, limited key size, cipher
suites also allow removed additional parts of the code that deals with
them.
We used to swallow the error, which is unhelpful.
The reason for that might be because we probe multiple names before giving up but
even then, it's ok log all attempts. It will make troubleshooting easy, even if we
have to go through a lot more log entries.
When using stements with parameters, the OdbcCommand would throw an exception
on ExecSQL when no row was returned. The commit adapts the change done in
5264613b6d for the case of unprepared statements
without parameters.
After MemoryCache was imported from referencesources, some tests started
failing occasionally. Cross-testing on MS.NET showed that you need to
access the cached item to make MemoryCache.GetCount() reliably return the
correct number after an item was expired from the cache.
Also removed __MonoTimerPeriod and __MonoEmulateOneCPU configuration variables,
they were used in Mono code before and don't make sense with the new code.
* Find the type map element that is the most-specific to the
object in question, not the first type it is an instance of
Change-Id: I1867e790bf9f377ce0ae02871f4561b760e27624
Given the test data in this patch the wrong element name
is used when serializing TestSerializeSecondType
Change-Id: I8aff732dfd22f4f654fb42f2d3b987d7ce58d600
The unstable image seemed to cause problems recently.
We should just use the default image and fetch Cygwin ourselves.
Also added caching of the Cygwin files and simplified the script a bit.
There was a memory leak caused by not having a lookup mechanism for
the RegistryKey. In addition, the entire code to dispose code was
never used (due to the leak), and it was wrong.
In addition, added locking to the "values" field, which currently was
racy.
No test cases, the repro is to run the above code for about 5 minutes.
It should be using RESOURCE_STRINGS, but mcs doesn't support its special
option for string resources for multiple files.
The resource .cs files are generated by genresstringcs.sh, but System.Xml.txt
contains some bogus characters that prevents source generation, so after
the tool has generated the sources, I manually fixed them.
It won't matter once mcs supports the option for multiple files anyways.
Removed Configuration dependencies and codegenerator parts in XmlSerializer
as well as switching CodeIdentifier implementation to old mono stuff
as referencesource totally depends on CodeDom (mono doesn't).
The order of those namespaces are insignificant, and the latest
combination of mono corlib (partly referencesource-d) and sys.xml
(referencesource except for XmlSerializer) caused this implementation
glitch.
MS referencesource changed XmlTextWriter behavior regarding EOL so that
now it preserves CRLF as is, instead of replacing them with
XmlWriterSettings.NewLineChars (mono implementation behavior).
There are some tests that depend on old behavior. The entire points of
those XmlDataDocument tests are not about checking EOLs, so just replace
the test XML file to not contain CRLF.
There is implementation mismatch in XmlDocument event order regarding
Load(). Take this code:
string xml = "<root><child>1</child></root>";
var doc = new XmlDocument ();
doc.NodeInserted += (o, e) =>
Console.WriteLine (e.Node.NodeType + e.Node.LocalName);
doc.LoadXml (xml);
This is mono output before referencesource:
Text#text
Elementchild
Elementroot
This is with referencesource:
Elementchild
Text#text
Elementroot
So, there are event order differences in our two implementations.
Now, XmlDataDocument depends on those XmlDocument events to fill DataRow
values. It worked fine with pre-referencesource System.Xml model, but
with referencesource it skipped to fill data row values.
This change makes sure to fill data row values from text node which are
added _after_ the parent node is added to the document.
It is not simply replacement because we have to workaround dynamic codegen
for Xamarin.iOS.
Also there were several tests failing with MS implementation (e.g. for
W3C DOM conformance), so we had to disable them.
There is one regression that rather needs to be fixed in Reflection.Emit.
Also, some WCF tests fail with this implementation. They need to be
investigated, reviewed and appropriately fixed.
In certain cases, hovering over a ToolStripMenuItem
that has a tool tip defined will result in the tool
tip appearing behind, and hidden by, the context
menu containing the item. The change is to cause
the tool tip to be pushed to the front when it is
displayed.
If a profiler has not installed a coverage filter, or the coverage filter has returned FALSE, then calls to mono_profiler_coverage_get trigger a assertion failed warning in g_hash_table_lookup.
If a profiler had requested MONO_PROFILE_COVERAGE events and not installed a
coverage filter, then the coverage info is NULL and a crash quickly followed
false when given a null argument instead of throwing an exception.
According to the msdn here:
https://msdn.microsoft.com/en-us/library/b4e35dwy%28v=vs.110%29.aspx
this method should never throw an exception. This was also confirmed
with the official Microsoft runtime.
This change is released under the MIT license.
/Users/builder/data/lanes/monodroid-mavericks-master/7de6731a/source/mono/support/serial.c:25:26: fatal error: linux/serial.h: No such file or directory
#include <linux/serial.h>
The header is only available on Android NDK API level >= 21.
This changes all bridges to use the _safe variant of sgen_obj_get_descriptor. Bridge processing happens in
the post-scan world, before objects get untagged.
We currently ship a horribly outdated version of EF. This is unnecessary since EF is on NuGet and has an active set of users using it on Unix.
Miguel gave his +1 on the mailing list already.
When a socket has been closed as part of the negotiation, the
SendAlert method would crash when trying to reuse the socket.
Add try/catch around this to prevent this.
Fixes#19334
The new suspend machinery is based around a single word state machine that is manipulated using CAS.
This solves the first set of problems with the current approach, the lack of atomicity and the impossibility of
doing race free manipulation of protected state. This is specially acute when doing a self suspend.
Suspend data must be atomically protected while we prepare to self suspend so a resume request won't race with the current
thread putting itself to sleep. This is a classical problem that calls for a mutex/conditional variable pair. Except that all
locks in the suspend path must be suspend safe. Wait, WHAT?
A Suspend Safe Lock is a primitive that is obstruction free in the face of the kernel suspending a thread either performing a
lock operation or waiting on a lock to become available. This, unfortunately, is not possible with pthread_mutex on OSX. The
only safe primitive are kernel semaphores, for which doesn't exist conditional variables for.
So back to locking and self-suspend. We need a lock because the existing thread state is not atomic but we can't use a
mutex/condvar pair so we're left with racy code. Yay! The fix is using CAS over a single variable.
Another change was the hardening of the suspend/resume code on posix targets. First we replace a semaphore wait with
sigsuspend for async suspend. This is needed since sem_wait is not async-signal safe (yet sem_post is). Second, we now
respect interruption requests by having a pair of suspend signals, one with SA_RESTART and one without.
Onto the design of the suspension system, a few concepts that are useful looking around.
* Self suspend: This is when the thread decides to suspend itself.
* Async suspend: This is when a thread decides to suspend another thread.
* Suspend Initiator: This the name of a thread that decided to suspend one or more other threads. This is important
since all suspending threads will notify it when they are suspended. There can be only one initiator in the system
at a given time.
* Suspension count: Number of resume calls before a thread is back to running state.
There are 7 states that can happen while a thread is runnable:
* Running: just running...
* (Async|Self) Suspended: Suspended, the difference comes into play when resuming.
* (Async|Self) Suspend Requested: Suspend requested, but not completed. See more below for the discussion on why the request state is needed.
* Suspend In Progress: Self suspend started saving its state thus async suspend should not modify it.
* Suspend Promoted to Async: Async tried to suspend a thread in the middle of a self suspend, it wants to be notified.
Now to the suspension protocol and how it happens on a high level view.
Suspension starts with a suspend request, which bumps the suspend count by one. This suspend request can be fulfilled either
by an async or self suspend action. This is confusing as there's only one initiator but any number of threads can be self suspending.
Async suspend then performs a platform specific action such as posix signals that forces a transition on the target. In the case
of self suspend, it depends on the thread polling its state and trigger the transition.
This works fine except that the suspend state is one huge struct with tons of fields. To control concurrent access to it we use a
single initiator in the case of async suspend and we put the thread in a transitional "saving my state" in the case of self suspend.
In the case of async suspend, the initiator must wait for all 1+ threads to notify back that they have suspended. Only after that
it's possible to know if the async suspend request actually worked or not (we might have hit a dying thread).
Together with this, there's an optional implementation of STW in sgen that can use this new machinery. To enable it set the
MONO_ENABLE_UNIFIED_SUSPEND env var for now while it gets more testing.
This has been requested by the maintainers of Npgsql a few times already (https://bugzilla.xamarin.com/show_bug.cgi?id=23119) and we should do it for Mono 4.0.
Miguel gave his +1 on the mailing list already.
This variable must be set to all threads that have been properly suspended. This is
an initial step to simplify suspend state and use explicitly named variables instead
of hiding state in stopped_ip / stopped_domain.
MonoThreads was previously ignoring sgen's in_critical_region, which could lead
to a thread suspended inside a gc critical region leading to the GC not been able
to STW.
(some commits occurred while I have been cherry-picking a lot of "they are
in import-system-xml branch but it works with existing sys.xml" stuff.)
work in master
In referencesource, XmlReader.SchemaInfo does not return different instances
for each node at its state but just returns the XmlReader itself (which
implements IXmlSchemaInfo). Hence, if we just set the corresponding
IXmlScemaInfo to each XObject, it results in inconsistent state.
This fixes two regressions in ExtensionsTest (XAttributeFailValidate and
XAttributeThrowExceptionValidate).
With referencesource, XmlWriter for TextWriter buffers the output.
When closing XamlXmlWriter, it does not flush the output, causing
the buffered XmlWriter output discarded in the wild.
MTOM writer didn't expect multiple top-level elements are rejected at
ConformanceLevel.Auto, neiher do against Write[Start/End]Document() with
such elements.
Also Flush is often needed before directly writing to the Stream(Writer).
EOLs handling was also inconsistent between referencesource and old mono.
XML Schema compilation is done in referencesource.
XmlSchemaImporter is based on mono code. Hence this glitch happened.
The following regression is fixed:
1) MonoTests.System.Xml.Serialization.XmlSchemaImporterTests.DefaultTypeTopLevelElementImportsAllComplexTypes : System.InvalidOperationException : 'Root' is missing.
at System.Xml.Serialization.XmlSchemaImporter.ImportTypeMapping (System.Xml.XmlQualifiedName name) [0x0005a] in /svn/mono/mcs/class/System.XML/System.Xml.Serialization/XmlSchemaImporter.cs:453
at MonoTests.System.Xml.Serialization.XmlSchemaImporterTests.DefaultTypeTopLevelElementImportsAllComplexTypes () [0x00039] in /svn/mono/mcs/class/System.XML/Test/System.Xml.Serialization/XmlSchemaImporterTests.cs:1104
at (wrapper managed-to-native) System.Reflection.MonoMethod:InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&)
at System.Reflection.MonoMethod.Invoke (System.Object obj, BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x00054] in /svn/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
I initially discarded this change, because locking BaseSet (name, sec), didn't prevent the threads from trying to add the same key. That said, following the code, the point at which it actually fails is in NameObjectCollectionBase.BaseAdd, lines 331 and 332. The threads were arriving the second line at the same time:
if (_entriesTable[name] == null)
_entriesTable.Add(name, entry);
In brief, it's safe to call BaseSet twice with the same key, so it's safe to lock only the call to BaseSet
There was some glitch in CP932 encoding and referencesource Encoder
that caused error in Convert(), shown in System.XML tests.
To avoid this, bring back old Encoder as we used before and keep
compatible processing.
It might be buggier, but doesn't regress. We may be able to bring nlp-
based Encodings later too.
If two threads request the same section, which isn't yet cached, both try to insert it into the cache, causing a "Key duplication when adding...". It's neccesary to lock the getter. This solves bugs #5263, #7785, #18303
This generates an XML representation of the check-seq-points target,
as separate tests, which can be easily tracked by anything which
parses NUnit output (e.g. Jenkins or other CI systems). For example,
we are currently regressed on this on ARM.
Creating hardlinks in .NET doesn't have a nice API and using Mono.Unix/Pinvoke doesn't
seem worth the effort at this point since the feature is off by default on msbuild as well.
This is enabled by passing "aot=dump" to the Mono AOT driver and will create a JSON file in the working directory with the name of the assembly.
It's still a work-in-progress and will see improvements in the data dumped as it's needed.
CCLD monodis.exe
../../mono/metadata/.libs/libmonoruntimesgen-static.a(libmonoruntimesgen_static_la-opcodes.o): In function `mono_opcode_name':
/cygdrive/c/projects/mono-817/mono/metadata/opcodes.c:63: multiple definition of `mono_opcode_name'
../mini/.libs/libmonosgen-2.0.dll.a(d001720.o):(.text+0x0): first defined here
collect2: error: ld returned 1 exit status
This change does not involve Windows-specific NLS-based encodings.
We will be still using I18N assemblies until we make more grand design
changes (Xamarin products premise those assemblies).
This also fixes bug #23771 and probably more.
Right now (without this change), Debug.Assert **always** formats its string parameters, even if doing so wouldn't be necessary because the condition is true. This has a huge impact on code that asserts frequently because it assumes that calling Assert(true, ...) is cheap.
.NET implementation is able to get method tokens from other modules.
This was causing a regression on a System.Xml.Xsl.XslTransformTests.Bug487065 while using referencesource's System.Xml implementation.
Custom attributes encoding means it's possible to have a scope that will
point into a PCL facade even if we (just before saving) will resolve all
type references.
Since all other references can be made on the _real_ assembly and that
we do not want to include any facade assembly just for this we need to
resolve those type and update their scope.
This reverts commit c96e58280c.
Getting this to work right with regards to register allocation
is turning out to be more complicated than it seems. Going to
abandon this for now.
This HMAC cipher accepts any key size (1), took from RFC2104, which uses
the full 64 bytes of key since it has a block length of 64 bytes.
(1): https://www.ietf.org/rfc/rfc2104.txt - Chapter 2: Definition of HMAC
(add a reference to System.Web.Services)
Without this patch we get the following exception after multiple call
to a soap web services:
Error while compiling generated serializer
/tmp/24ee1170/4996ddb2.cs(2519,27) : warning CS1522: Empty switch block
/tmp/24ee1170/4996ddb2.cs(969,29) : error CS0012: The type `System.Web.Services.Protocols.SoapHeader' is defined in an assembly that is not referenced. Consider adding a reference to assembly `System.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
Signed-off-by: Frederic Mestayer <[email protected]>
Signed-off-by: Etienne CHAMPETIER <[email protected]>
On Microsoft's implementation of the Uri class, the contructors and TryCreate method both lower-case the host. This commit fixes the issue where the constructors lower-cased the host but the TryCreate method did not.
Currently JsonObject uses a Dictionary and JsonValue does not sort the keys
in SaveInternal(). As iterating over a Dictionary returns the values in
random order, this causes the JSON string to be non-deterministic.
Switching to SortedDictionary makes sure that the same object always will
produce the same JSON string.
The keys are sorted using StringComparer.Ordinal to produce the same order
in all locales.
AC_ARG_ENABLE(bcl-opt, [ --disable-bcl-opt BCL is compiled with no optimizations (allows accurate BCL debugging)], test_bcl_opt=$enableval, test_bcl_opt=yes)
AC_ARG_ENABLE(perf-events, [ --enable-perf-events Enable using `perf` for profiling on Linux], test_perf_events=$enableval, test_perf_events=no)
if test "x$test_perf_events" == "xyes"; then
AC_DEFINE(ENABLE_PERF_EVENTS, 1, [Enable using `perf` for profiling on Linux])
AC_SUBST(ENABLE_PERF_EVENTS)
fi
AC_MSG_CHECKING([if big-arrays are to be enabled])
AC_ARG_ENABLE(big-arrays, [ --enable-big-arrays Enable the allocation and indexing of arrays greater than Int32.MaxValue], enable_big_arrays=$enableval, enable_big_arrays=no)
if test "x$enable_big_arrays" = "xyes" ; then
@@ -2635,7 +2612,7 @@ AC_ARG_WITH(llvm, [ --with-llvm=<llvm prefix> Enable the LLVM back-end], ena
if test "x$enable_llvm" = "xyes"; then
if test "x$with_llvm" != "x"; then
LLVM_CONFIG=$with_llvm/bin/llvm-config
if test x$target_win32 = xyes; then
if test x$host_win32 = xyes; then
LLVM_CONFIG=$LLVM_CONFIG.exe
fi
if test ! -x $LLVM_CONFIG; then
@@ -2655,7 +2632,7 @@ if test "x$enable_llvm" = "xyes"; then
;;
esac
if test "x$target_win32" = "xno"; then
if test "x$host_win32" = "xno"; then
# The output of --cflags seems to include optimizations flags too
LLVM_CFLAGS=`$LLVM_CONFIG --cflags | sed -e 's/-O2//g' | sed -e 's/-O0//g' | sed -e 's/-fomit-frame-pointer//g' | sed -e 's/-fPIC//g'`
@@ -3051,6 +3028,19 @@ if test "x$host" != "x$target"; then
with_tls=pthread
target_mach=no
;;
x86_64-ps4-freebsd)
TARGET=AMD64;
arch_target=amd64;
AC_DEFINE(TARGET_AMD64, 1, [...])
AC_DEFINE(TARGET_PS4, 1, [...])
CPPFLAGS="$CPPFLAGS"
sgen_supported=true
# Can't use tls, since it depends on the runtime detection of tls offsets
# in mono-compiler.h
with_tls=pthread
target_mach=no
target_win32=no
;;
aarch64*-linux-*)
TARGET=ARM64;
arch_target=arm64;
@@ -3251,7 +3241,7 @@ case "$host" in
X11="libX11.so.6"
;;
*-*-*freebsd*)
LIBC="libc.so"
LIBC="libc.so.7"
INTL="libintl.so"
SQLITE="libsqlite.so"
SQLITE3="libsqlite3.so"
@@ -3501,10 +3491,11 @@ case "x$libgc" in
;;
esac
AC_ARG_WITH(profile4_5,[ --with-profile4_5=yes,no If you want to install the 4.5 FX (defaults to yes)], [], [with_profile4_5=yes])
AC_ARG_WITH(monodroid, [ --with-monodroid=yes,no If you want to build the MonoDroid assemblies (defaults to no)], [], [with_monodroid=no])
AC_ARG_WITH(monotouch, [ --with-monotouch=yes,no,only If you want to build the MonoTouch assemblies (defaults to no)], [], [with_monotouch=no])
AC_ARG_WITH(xammac, [ --with-xammac=yes,no,only If you want to build the Xamarin.Mac assemblies (defaults to no)],[], [with_xammac=no])
AC_ARG_WITH(profile4_5,[ --with-profile4_5=yes,no If you want to install the 4.5 FX (defaults to yes)], [], [with_profile4_5=yes])
AC_ARG_WITH(monodroid, [ --with-monodroid=yes,no If you want to build the MonoDroid assemblies (defaults to no)], [], [with_monodroid=no])
AC_ARG_WITH(monotouch, [ --with-monotouch=yes,no If you want to build the Xamarin.iOS assemblies (defaults to no)], [], [with_monotouch=no])
AC_ARG_WITH(monotouch_watch, [ --with-monotouch_watch=yes,no If you want to build the Xamarin.WatchOS assemblies (defaults to no)],[], [with_monotouch_watch=no])
AC_ARG_WITH(xammac, [ --with-xammac=yes,no If you want to build the Xamarin.Mac assemblies (defaults to no)], [], [with_xammac=no])
OPROFILE=no
AC_ARG_WITH(oprofile,[ --with-oprofile=no,<oprofile install dir> Enable oprofile support (defaults to no)],[
if [ ! -f "TestResult-$(PROFILE).xml" ]; then echo "<?xml version='1.0' encoding='utf-8'?><test-results failures='1' total='1' not-run='0' name='bcl-tests' date='$$(date +%F)' time='$$(date +%T)'><test-suite name='$(strip $(test_assemblies))' success='False' time='0'><results><test-case name='crash' executed='True' success='False' time='0'><failure><message>The test runner didn't produce a test result XML, probably due to a crash of the runtime. Check the log for more details.</message><stack-trace></stack-trace></failure></test-case></results></test-suite></test-results>" > TestResult-$(PROFILE).xml; fi; \
$(TEST_HARNESS_POSTPROC) ; $$ok
## Instructs compiler to compile to target .net execution, it can be usefull in rare cases when runtime detection is not possible
Loaded 100 of 6388 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.