To get a small taste of it in action run the following program with it:
sing System;
using System.Net;
using System.Runtime.InteropServices;
using System.Linq;
public class Test
{
[DllImport ("__Internal")]
public static extern void mono_memprof_dump ();
static int MethodThatDoesLinq () {
int[] x = new[] { 1,2,3,4};
var k = x.Where (_ => _ <= 100).Select (_ => _ + 1);
int r = 0;
foreach (var v in k)
r += v;
return r;
}
public static void Main ()
{
mono_memprof_dump ();
MethodThatDoesLinq ();
Console.WriteLine ("----------------------");
mono_memprof_dump ();
}
}
This split a single chunk of intractable ifdef hell into a beautiful set of per-target
files.
This will allow us to actually figure out what's going on on each target.
Removed unnecessary parameters ref byte [] bufferArg.
This changes are required by UTF8EncodingTest.EncodingFallback that in some cases is expecting multibyte values..
In theory, this test is used to verify that no unknown glib symbols exist
in eglib. However, it's tripping on g_Ctoc which is not a glib (or eglib)
symbol, instead it comes from the IO layer - and glib symbols never use
uppercase characters anyway
A change in Uri.Compare was making IsBaseOf to return false when arguments were null.
NullReferenceException is thrown by .NET, nonetheless the correct behavior is to throw a ArgumentNullException..
PR #1229 added a test that relies on the GAC and fails when it isn't available, like when building on a clean machine with monolite.
Skip the test in that case.
asl_vlog last parameter is a va_list and giving it a char* leads to crash
which calls our native unhandled exception handler, which also tries to
log what happens making the watchdog unhappy about the food quality
0x000000008badf00d
Context: https://bugzilla.xamarin.com/show_bug.cgi?id=18763#c12
Context: https://bugzilla.xamarin.com/show_bug.cgi?id=18763#c14
Context: http://stackoverflow.com/a/1789879/83444
mono_set_crash_chaining() was added in 8ffc4070 in order to better
support Android crash logs.
Crash logging in Android is "weird" (something we didn't know at the
time of 8ffc4070); when a process crashes on Android, ideally:
1. The Android signal handler is executed,
2. Bionic will attempt to connect to /system/bin/debuggerd.
3. debuggerd will try to connect to the crashing process, then
retrieve "useful" information from the crashing process (stack
trace, register values, etc.)
The problem with 8ffc4070 was that there is a "window" between steps
(1) and (3) during which the crashing process continues to execute but
debuggerd hasn't attached to the process. It is possible that the
crashing process can thus exit before debuggerd has had a chance to
attach, killing the purpose of the crash logs.
Case in point: consider mono_sigsegv_signal_handler(). In 8ffc4070,
if mono_do_crash_chaining is TRUE, then Mono will execute:
mono_handle_native_sigsegv (SIGSEGV, ctx);
mono_chain_signal (SIG_HANDLER_PARAMS);
mono_arch_handle_exception (ctx, NULL);
Because mono_chain_signal() doesn't block, abort the process, or
otherwise do anything to prevent execution from continuing, execution
will hit mono_arch_handle_exception(), which will exit the process.
If you're unlucky, this will happen before debuggerd has had a chance
to attach to the process.
The obvious fix is to prevent mono_arch_handle_exception() from being
invoked. The question is, *how*? jonp suggested [0] that after
mono_chain_signal() returns then _exit(2) or a busy loop could be
invoked. Unfortunately, _exit(2) makes the process exit explicit, and
~reliably prevents debuggerd from doing anything.
A busy loop doesn't work because it just causes the process to hang
within signal handler context, and debuggerd is never able to log
anything about the crashed process.
It would seem that the signal handler itself must exit without causing
the process to exit so that debuggerd has a chance to do ANYTHING,
otherwise nothing will happen reliably.
Thanks to T.J. Purtell for investigating and providing the patch.
[0]: https://github.com/mono/mono/pull/1206#issuecomment-52357802
--- Original commit message [formatted] ---
re #18763: After the chained handler executes, it may return to allow
the crashed instruction to be restarted or it may have taken
corrective action so the instruction can be resumed successfully.
For example, bionic resets the signal handler for SIGSEGV to default
expecting that the kernel will restart the offending instruction and
cause the kernel to abort the process. Don't do mono exception
handling after chaining to support these types of signal management.
Compilation of eglib/src/goutput.c was broken in commit 989165e1:
mono/eglib/src/goutput.c: In function 'monoeg_log_default_handler':
mono/eglib/src/goutput.c:159:75: error: 'args' undeclared (first use in this function)
__android_log_vprint (to_android_priority (log_level), log_domain, "%s", args);
^
mono/eglib/src/goutput.c:159:75: note: each undeclared identifier is reported only once for each function it appears in
mono/eglib/src/goutput.c: In function 'default_stdout_handler':
mono/eglib/src/goutput.c:168:2: error: incompatible type for argument 4 of '__android_log_vprint'
__android_log_vprint (ANDROID_LOG_ERROR, "mono", "%s", message);
^
mono/eglib/src/goutput.c:139:0:
$ANDROID_NDK_PATH/platforms/android-4/arch-arm/usr/include/android/log.h:109:5: note: expected 'va_list' but argument is of type 'const gchar *'
int __android_log_vprint(int prio, const char *tag,
^
mono/eglib/src/goutput.c: In function 'default_stderr_handler':
mono/eglib/src/goutput.c:175:2: error: incompatible type for argument 4 of '__android_log_vprint'
__android_log_vprint (ANDROID_LOG_ERROR, "mono", "%s", message);
^
(The cause of the breakage is that __android_log_vprint() takes a
va_args parameter, which is no longer present in 989165e1.)
Use __android_log_write() instead of __android_log_vprint().
Note: __android_log_write() writes a "simple string" to `adb logcat`,
meaning there is no printf(3)-style formatting applied.
When the stream returned by WebClient.OpenWrite() / OpenWriteAsync() /
OpenWriteTaskAsync(), we need to call GetResponse() and read the full
response.
Unfortunately, there is no async API available for this, so this API should
not be used in async applications.
XmlSerializerTests was mostly testing XmlSerializationReaderInterpreter and XmlSerializationWriterInterpreter.
XmlSerializerGeneratorTests forces the usage of SerializationCodeGenerator while running XmlSerializerTests.
This test requires a simple single mapping for Hostname<->IP with one IP and reverse DNS. Using EC2-hosted sites doesn't work as they don't have valid reverse DNS. Use the Jenkins subdomain, since that fits the criteria.
In the case where more than one pointer pointed to the same empty region within
the nursery we would search through that empty region for each pointer instead of
just once.
Assume we have an object at address 0x1000, with size 0xf0, then
a hole of size 0x10, and the next object starting at 0x1100, of
size 0x20. In the pin queue we have the addresses 0x10f8 and
0x1100.
When we process the first pin queue entry, 0x10f8, we jump over
the object at 0x1000, to 0x10f0. Then we skip the hole and end
up at 0x1100. We set last_obj to that address. Then we check
against the pin queue entry we're looking for and find that we've
overshot it, so we end our search and go to the next pin queue
entry, 0x1100. There's an object at that address, but because of
this check we don't pin it:
if (addr >= last_obj && (char*)addr < (char*)last_obj + last_obj_size) {
addr == 0x1100, last_obj == 0x1100, last_obj_size == 0x20
This commit changed the gray stack to support work items. When a big
array of objects is marked, Sgen now create several work items. Every
work item rappresents a pieces of the array that must be scanned.
Since they are different pieces, the workers can now parallel scan
and mark the array, resulting in a better work distribution between
the workers.
I release this change under the MIT license.
This commit transport the scan macro from sgen-descritor.h to
sgen-scan-object.h. This is useful for modify at compile time
the scan macro according to the scan function.
I release this change under the MIT license.
The latter is now hosted on a different IP behind a CDN and the IP may change depending on location.
Using xamarin.com instead fixes the tests for now.
This makes difference when the build has started from a solution especially
via command line with /p option. Those command-line-passed properties need
to be inherited to each project, but they weren't.
xbuild worked fine here.
This optimization is activated in the ldvirtftn + delegate case, and is deactivated in the case where the architecture does not support it (mono_arch_get_delegate_virtual_invoke_impl return NULL)
Since NET_4_0 and NET_4_5 share the same ToolsVersion (4.0) there seems no
way to distinguish the appropriate framework .targets file, so I ended up
to add the missing members as internal for 4.0.
CompareInvalidTest is still not working because .NET PackUriHelper.ComparePackUri is doing something that uses Uri and throws an exception whereas Mono is not.
- the dropns flag now lets you define a namespace that is dropped in a new version of the assembly during update.
- the ntypes flag lets you tell the update command that certain methods are now using native types, and as such will attempt to match with old types in order to preserve documentation.
- the preserve flag will avoid removing members. This is to avoid dropping documentation for members that changed from one version of the framework to another new-style version (ie. iOS).
- Fixed bug in creating CREF strings.
- Refactored XML file processing for customization during new style iOS assembly. This was done through the new file source interface, which lets you use dependency injection to customize the process.
- Added the ability to rewrite CREF references when assembling docs that use native types. Also, the ability to handle dropped namespaces.
If we encounter such a device we assign it an empty name followed by index number, so that we can
put any number of such devices in the dictionary and report them to the user.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=21741
We can now pass a file size limit to the `binary-protocol` option. It will
create numbered binary protocol files, and only keep the last two around.
This is useful for cases where the only way to reproduce a bug is through
a long run that would otherwise create a protocol that's much too big.
With the debug policy, we do clear at TLAB creation, but at GC time, whenever
we would clear with `clear-at-gc`, instead of not clearing, we fill with 0xff.
This define covers kFreeBSD, not just Linux. This is required because
the error which 120d194d10 works around is
a GNU problem, not a Linux problem, so causes FTBFS on kFreeBSD.
Xinerama has only ever had a soname of 1.
Checking for 1, 2, and 3 is just weird and pointless. And by not using a
default value, we duplicate the bug which add24aaa1 fixed.
We complain that we can't find "X development files", but the reverse
is true - if we had X development files, we'd find libX11.so (which
we aren't looking for). What we look for (and find) are the runtime files.
GNU/kFreeBSD is an experimental OS provided by the Debian project, consisting
of a FreeBSD kernel and GNU userland/libc. For a small number of cases, this
offers advantages over a more common GNU/Linux combination, such as fast
in-kernel support for ZFS storage.
This patch changes various ifdefs, either using __FreeBSD_kernel__ where a
trait from the kernel is what matters, or __GLIBC__ where a trait from the
C library matters.
This patch set has been carried downstream, in one form or another, since
1.2.3.1-1.
https://bugzilla.novell.com/show_bug.cgi?id=321634
Added code to call Xamarin.Android internal implementation of getifaddrs/freeifaddrs to provide us
with the required information to fulfill the request.
Added a handful of Linux ARP hardware IDs which are considered to be tunnel devices and which may occur
on Android devices.
Part of fix for https://bugzilla.xamarin.com/show_bug.cgi?id=1969
As @marek-safar noted in mono@cf4f10e#commitcomment-7128403, the IL code for the 4.0 profile is never used
for running (the assemblies are just built for having metadata), so it makes no sense to execute 4.0 tests during "make check"
In some cases, usually when dealing with IntPtr <> void* conversions, 2nd order aliases arises.
To handle them, first we consider the lowered load/stores for alias information, second
we iterate over handle globals/dce while aliases can still be eliminated.
We need to pass the right generic context to the method parsing so local variables with
generic argument types get the owner properly set.
In addition to that, harden the icall in case the owner is not set.
claims must be added regardless of identity parameter
Since constructors are chained in that class, this wrong behaviour causes chained trouble of claims to be never added
The previous fix to handle curried delegates with DynamicInvoke did not correctly handle
those create with IL (in contrast to Delegate.CreateDelegate), as they don't hit any managed code.
The solution is to always require DelegateData to be filled for InvokeDynamic, if not, lazily
calculate it.
DataRow's RowError is supposed to be String.Empty to indicate
no errors, but is sometimes wrongly set to null, falsely indicating
errors. Fixed to be String.Empty.
UriKind was added so Relative Uri can be parsed by UriParseComponent.ParseComponents.
String error was added so a error can be returned when an invalid Uri is provided.
The method is only public in .NET 4+, previously it was protected. Wrapping the access modifier in a #if NET_4_0 ensures that when building .NET 2, it is protected but when building 4+ it is public.
If the backing file doesn't exist, it will be ignored.
The previous message made it sound like this is a serious problem, which confused people as it is the last message that is
printed when building Mono (because of a reference to 'DoesNotExist' in docs/toc.xml) while in reality everything is fine.
The Microsoft version is public, so should this be.
NuGet.MSBuild.Tools.CommandLineBuilderExtensions:AppendTextUnquotedIfNotNullOrEmpty attempts to call this method in NuGet for MSBuild NuGet package.
The WebSocketMessageType values were being used to send data over the
wire. This is likely the reason why WebSocketMessageType had values
that were not compatible with .NET.
With this patch, we see a 3x execution speed improvement in the following micro-benchmark :
using System;
class Foo {
public int Test () { return 10; }
}
class Program {
public static int Main (String[] args) {
long n = 50000000;
if (args.Length > 0)
n = Math.Max (n, Int64.Parse (args [0]));
var a = new Foo ();
for (long i = 0; i < n; i++) {
var f = new Func<int> (a.Test);
if (f () != 10)
return 1;
}
return 0;
}
}
The TestTimeoutPropertyWithServerThatDoesntExist test sometimes failed with a 'ConnectFailure' instead of a 'Timeout'.
As per the discussion in PR #1145, the test should actually check that a ConnectFailure is thrown before the timeout is reached.
This proved unreliable with the 10.128.200.100 IP address, as it was up to the networking stack to decide whether the endpoint can be reached,
which can take quite a long time (sometimes >100secs).
Instead, we now use the loopback address with a port where no service listens, which should be equivalent.
Additionally, the assert which checks for the correct exception switched the 'expected' and 'actual' parameter, which resulted in the wrong output, this is fixed as well.
Socket.ConnectAsync uses BeginConnect, and ends here in
ConnectCallback. It needs to call EndConnect so any error can be
propagated up.
See Xamarin bug: https://bugzilla.xamarin.com/show_bug.cgi?id=21017
- Fix detection of extra characters in JSON input
- Fix detection of invalid negative numeric literals
- Disallow leading zeros
- Use "round-trip" format for floating point numbers
- Serialize NaN and Infinity as strings
- Use NumberFormatInfo.InvariantInfo for Convert.To*()
- Use standard number parsing methods in ReadNumericLiteral()
- Add test cases
* Implement DW_CFA_remember_state/restore_state opcodes.
* Add a DW_CFA_mono_advance_loc opcode to advance to a location stored outside
of the unwind info. Use this to allow the sharing of unwind info between
methods.
This is need to prevent crashes during unwinding when the ip of the last frame is in the epilog. This can be reproduced by
running sgen-new-threads-dont-join-stw.exe in a loop.
With GetComponentsHelper components with format UriHelper.ToStringUnescape can be retrieve without the ArgumentOutOfRangeException thrown by GetComponents.
Reduce tests now test sequences of 1 to 3 encoded or decoded dots inside paths with or without trailing character and encoded fowardslash and backslash.
This reverts commit 265060cc22.
The test is still failing:
2) MonoTests.System.Threading.Tasks.TaskTests.TaskContinuationChainLeak : Expected: False
But was: True
at MonoTests.System.Threading.Tasks.TaskTests+TaskContinuationChainLeakTester.Verify () [0x00000] in /var/lib/jenkins/workspace/Mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:1991
at MonoTests.System.Threading.Tasks.TaskTests.TaskContinuationChainLeak () [0x00022] in /var/lib/jenkins/workspace/Mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:1948
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 /var/lib/jenkins/workspace/Mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
These tests occasionally time out:
Test Case Failures:
1) MonoTests.System.ServiceModel.PeerResolvers.CustomPeerResolverServiceTest.CloseTest : System.TimeoutException : The operation has timed-out.
at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.WaitEnd () [0x00000] in <filename unknown>:0
at System.ServiceModel.Channels.HttpRequestChannel.EndRequest (IAsyncResult result) [0x00000] in <filename unknown>:0
at System.ServiceModel.Channels.HttpRequestChannel.Request (System.ServiceModel.Channels.Message message, TimeSpan timeout) [0x00000] in <filename unknown>:0
at System.ServiceModel.MonoInternal.ClientRuntimeChannel.Request (System.ServiceModel.Channels.Message msg, TimeSpan timeout) [0x00000] in <filename unknown>:0
at System.ServiceModel.MonoInternal.ClientRuntimeChannel.Request (System.ServiceModel.Description.OperationDescription od, System.Object[] parameters) [0x00000] in <filename unknown>:0
at System.ServiceModel.MonoInternal.ClientRuntimeChannel.DoProcess (System.Reflection.MethodBase method, System.String operationName, System.Object[] parameters) [0x00000] in <filename unknown>:0
at System.ServiceModel.MonoInternal.ClientRuntimeChannel.Process (System.Reflection.MethodBase method, System.String operationName, System.Object[] parameters) [0x00000] in <filename unknown>:0
I.e. we're timing out waiting for the async wait handle here: https://github.com/mono/mono/blob/master/mcs/class/System.ServiceModel/System.ServiceModel.Channels/HttpRequestChannel.cs#L495
Since we have no current WCF maintainer and this is deep, deep within
WCF land and causes unstable builds on Jenkins, disable these tests
for now.
Bug: https://bugzilla.xamarin.com/show_bug.cgi?id=21069
The WaitOne () call has a tendency to time out on the Jenkins
VMs. However, reproducing the problem outside of Jenkins has
proven futile.
This makes the WaitOne () call block for as long as needed and
still fails the test if the elapsed time was longer than 30s.
We print the actual elapsed time to the console.
Hopefully this'll help us find out if it's just taking quite a
long time to run or if it's a hang.
With IriParsing the presencee of encoded alpha numeric, non ASCII, '-', '.', '_' and '~' characters trigger the decoding of some other characters.
Tested permutations now include tests with and tests without those characters.
Changed Format methods to receive FormatFlags.
Added FormatFlag.HasCharactersToNormalize, which improves character decoding.
The flag is set when Iriparsing is true and the Uri contains an encoded alpha numeric, non ASCII, '-', '.' , '_' and '~'.
When the flag is set some other encoded charcaters need also to be decoded.
* MONO_ARCH_HAVE_ATOMIC_* macros have been removed.
* Backends now report whether they support atomic opcodes via
the mono_arch_opcode_supported () function.
* The default implementation of mono_arch_opcode_supported ()
has been removed as almost all backends need to define one
anyway.
* All old atomic_add_* opcodes have been removed. These were no
longer being used but some backends still had code for them.
* atomic_add_new_* opcodes have been renamed to atomic_add_* as
they are now the only atomic add opcodes.
* Itanium-specific atomic_add_imm_* opcodes have been moved to
the __ia64__ section of mini-ops.h.
* Comments have been added to mini-ops.h explaining the precise
semantics of the atomic opcodes.
The net result of this change is a simpler backend interface at
the cost of a slightly bigger binary.
MONO_PATH was missing when running the tests.
Use "libMonoPosixHelper.so" in local directory when checking if DllImport of a development library generates a warning (libglib2.0-dev might not be installed, but libMonoPosixHelper is always built with mono)
Since libgdiplus is not installed together with Mono, it should not be
assumed to be in the same prefix.
The new policy for the --with-libgdiplus configure option is the
following:
- --with-libgdiplus=/absolute/path/to/libgdiplus.{so,dylib}
both during build/check and after installation Mono will try to use
the specified libgdiplus library; the rationale is that when an
absolute path is given, it can be assumed to be the full path to
the library that is already installed (possibly in a non-default
path).
- default, --with-libgdiplus=no, --with-libgdiplus=installed
both during build/check and after installation Mono will try to use
a system-wide libgdiplus library, that is assumed to reside in the
paths that are automatically searched by the dynamic linker; the
library is supposed to be already installed in the default path and
to be useable both during the build and afterwards.
- --with-libgdiplus=sibling, --with-libgdiplus=yes
during build/check Mono will try to use the libgdiplus library that
is assumed to be in the sibling folder (../libgdiplus), but after
the installation it will try to use a system-wide libgdiplus
library, that should be in the paths that are automatically
searched by the dynamic linker; the assumption is that the library
is not yet installed, but it will go to the default prefix after
installing it.
- --with-libgdiplus=../some/relative/path/to/libgdiplus.{so,dylib,la}
during build/check Mono will try to use the specified libgdiplus
library, but after the installation it will try to use a
system-wide libgdiplus library, that should be in the paths that
are automatically searched by the dynamic linker; the assumption is
that the library is not yet installed, but it will go to the
default prefix after installing it.
The libMonoPosixHelper is installed together with Mono, hence its path
in the configuration should be relative to the Mono prefix.
It was previously assumed to reside in a system path, so the the
dynamic linker would find it anyway.
This patch is based on the one included in bug #18555 (by Gaëtan
Lehmann <[email protected]>), but it also updates
runtime/Makefile.am to keep runtime/etc/mono/config consistent.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=18555
Created a new set of tests that create&store or that load&assert uri permutations.
Uris are created with permutations of schemes, components, characters then methods and properties output is asserted against expected values obtained on .NET.
Recent versions of Git co-host submodule GIT_DIRs in <root-project>/.git/
by default, and write their relative path into <subproject>/.git,
which is a regular file:
$ ls -l external/cecil/.git
-rw-r--r-- 1 foo bar 42 Jun 16 12:50 external/cecil/.git
$ cat external/cecil/.git
gitdir: ../../.git/modules/external/cecil
Relax the expression in Makefile.am to also delete these (broken)
"symlinks" when preparing a distribution tarball.
This reverts commit ed11296c51.
When a ThreadAbortException is thrown during request processing in AsyncRun () the _done.Set () call is not executed.
This then results in a deadlock because _done.WaitOne () doesn't get signaled and waits forever.
One solution would be enclosing the _done.Set () in a finally clause, but even then we'd need to relaunch the AsyncRun () loop to be in a usable state.
A simpler solution is to revert the commit that introduced the AsyncRun () in the first place, as it doesn't seem necessary now (the tests pass just fine without it).
The test that was disabled in 429cdf17cf is reenabled too, as it wasn't the culprit of the problem.
When a % was found HexUnescapeMultiByte output was always considered escaped.
Now a % that is not a percentage encoded character will be processed has a not escaped character.
The property IriParsing will be used to change between .NET 4.5 and .NET 4.0 default percentage encoding/decoding behavior.
A private field named s_IriParsing same as .NET was also added so it can be changed the same way through reflection in .NET and Mono.
The idea is simply to make a worker tries to steal work from the workers that are next to him firs, before trying back at the beginning.
This reduce lock contention on the first workers and distribute more evenly work between workers by not starving the first ones.
We would previously run this everywhere, but it only works on
x86 and amd64 at the moment (similar to finally_guard.exe).
This meant that it would always fail on e.g. ARM and PPC. We
still disable it under NaCl (because it uses Thread.Abort ())
and Win32.
Bug: https://bugzilla.xamarin.com/show_bug.cgi?id=20961
These tests fail under this particular profile only with the following:
1) MonoTests.Microsoft.Build.Evaluation.ProjectCollectionTest.GlobalProperties : #2
Expected: True
But was: False
at MonoTests.Microsoft.Build.Evaluation.ProjectCollectionTest.GlobalProperties () [0x00000] in <filename unknown>:0
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) [0x00000] in <filename unknown>:0
2) MonoTests.Microsoft.Build.Evaluation.ProjectTest.BuildCSharpTargetBuild : Microsoft.Build.Exceptions.InvalidProjectFileException : Attribute "KeepDuplicates" is not known on node "_TargetFrameworkDirectories" [type Microsoft.Build.Construction.ProjectItemElement]. at: /home/alexrp/Projects/mono/mcs/class/lib/net_4_5/Microsoft.Common.targets (182,5)
at Microsoft.Build.Construction.ProjectElement.LoadAttribute (System.String name, System.String value) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectItemElement.LoadAttribute (System.String name, System.String value) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectRootElement.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectRootElement.Create (System.Xml.XmlReader xmlReader, Microsoft.Build.Evaluation.ProjectCollection projectCollection) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Import (Microsoft.Build.Construction.ProjectImportElement import) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project+<EvaluatePropertiesAndImportsAndChooses>c__Iterator0.MoveNext () [0x00000] in <filename unknown>:0
at System.Linq.Enumerable.ToArray[ProjectElement] (IEnumerable`1 source) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Import (Microsoft.Build.Construction.ProjectImportElement import) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project+<EvaluatePropertiesAndImportsAndChooses>c__Iterator0.MoveNext () [0x00000] in <filename unknown>:0
at System.Linq.Enumerable.ToArray[ProjectElement] (IEnumerable`1 source) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.ProcessXml () [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Initialize () [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion, Microsoft.Build.Evaluation.ProjectCollection projectCollection, ProjectLoadSettings loadSettings) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion, Microsoft.Build.Evaluation.ProjectCollection projectCollection) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion) [0x00000] in <filename unknown>:0
at MonoTests.Microsoft.Build.Evaluation.ProjectTest.BuildCSharpTargetBuild () [0x00000] in <filename unknown>:0
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) [0x00000] in <filename unknown>:0
3) MonoTests.Microsoft.Build.Evaluation.ProjectTest.CreateProjectInstance : Microsoft.Build.Exceptions.InvalidProjectFileException : Attribute "KeepDuplicates" is not known on node "_TargetFrameworkDirectories" [type Microsoft.Build.Construction.ProjectItemElement]. at: /home/alexrp/Projects/mono/mcs/class/lib/net_4_5/Microsoft.Common.targets (182,5)
at Microsoft.Build.Construction.ProjectElement.LoadAttribute (System.String name, System.String value) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectItemElement.LoadAttribute (System.String name, System.String value) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectRootElement.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectRootElement.Create (System.Xml.XmlReader xmlReader, Microsoft.Build.Evaluation.ProjectCollection projectCollection) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Import (Microsoft.Build.Construction.ProjectImportElement import) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project+<EvaluatePropertiesAndImportsAndChooses>c__Iterator0.MoveNext () [0x00000] in <filename unknown>:0
at System.Linq.Enumerable.ToArray[ProjectElement] (IEnumerable`1 source) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Import (Microsoft.Build.Construction.ProjectImportElement import) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project+<EvaluatePropertiesAndImportsAndChooses>c__Iterator0.MoveNext () [0x00000] in <filename unknown>:0
at System.Linq.Enumerable.ToArray[ProjectElement] (IEnumerable`1 source) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.ProcessXml () [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Initialize () [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion, Microsoft.Build.Evaluation.ProjectCollection projectCollection, ProjectLoadSettings loadSettings) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion, Microsoft.Build.Evaluation.ProjectCollection projectCollection) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion) [0x00000] in <filename unknown>:0
at MonoTests.Microsoft.Build.Evaluation.ProjectTest.CreateProjectInstance () [0x00000] in <filename unknown>:0
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) [0x00000] in <filename unknown>:0
4) MonoTests.Microsoft.Build.Evaluation.ProjectTest.LoadCaseInsensitive : Microsoft.Build.Exceptions.InvalidProjectFileException : Attribute "KeepDuplicates" is not known on node "_TargetFrameworkDirectories" [type Microsoft.Build.Construction.ProjectItemElement]. at: /home/alexrp/Projects/mono/mcs/class/lib/net_4_5/Microsoft.Common.targets (182,5)
at Microsoft.Build.Construction.ProjectElement.LoadAttribute (System.String name, System.String value) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectItemElement.LoadAttribute (System.String name, System.String value) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.LoadValue (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectElementContainer.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectRootElement.Load (System.Xml.XmlReader reader) [0x00000] in <filename unknown>:0
at Microsoft.Build.Construction.ProjectRootElement.Create (System.Xml.XmlReader xmlReader, Microsoft.Build.Evaluation.ProjectCollection projectCollection) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Import (Microsoft.Build.Construction.ProjectImportElement import) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project+<EvaluatePropertiesAndImportsAndChooses>c__Iterator0.MoveNext () [0x00000] in <filename unknown>:0
at System.Linq.Enumerable.ToArray[ProjectElement] (IEnumerable`1 source) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Import (Microsoft.Build.Construction.ProjectImportElement import) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project+<EvaluatePropertiesAndImportsAndChooses>c__Iterator0.MoveNext () [0x00000] in <filename unknown>:0
at System.Linq.Enumerable.ToArray[ProjectElement] (IEnumerable`1 source) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.ProcessXml () [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project.Initialize () [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion, Microsoft.Build.Evaluation.ProjectCollection projectCollection, ProjectLoadSettings loadSettings) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion, Microsoft.Build.Evaluation.ProjectCollection projectCollection) [0x00000] in <filename unknown>:0
at Microsoft.Build.Evaluation.Project..ctor (Microsoft.Build.Construction.ProjectRootElement xml, IDictionary`2 globalProperties, System.String toolsVersion) [0x00000] in <filename unknown>:0
at MonoTests.Microsoft.Build.Evaluation.ProjectTest.LoadCaseInsensitive () [0x00000] in <filename unknown>:0
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) [0x00000] in <filename unknown>:0
- Whitespace Espressions:
-- if a column expression is a pure whitespace, use an empty string instead
-- if a column expression is surrounded by whitespace, preserve whitespace
-- if a column expression is null/empty, use an empty string
- Get a row's column value:
-- make sure we throw exceptions if the column we are looking at is null
-- make sure we throw exceptions if we can't find the column with the provided name
When building sln files, they are first converted to sln.proj
files, then the project file is built.
The engine unloaded and reloaded the sln.proj file itself, but
not the projects implicitly loaded while parsing the sln file.
This meant that some state was kept around that prevented
AfterTargets from being handled correctly
BXC18761 - AfterTargets and AfterBuild ignored by xbuild
This reverts commit dd412cfb2e.
We need to know what target was broken by this and verify that this won't break the platitude of libc's around.
This is currently a non-trivial job, so let's just revert this for now.
The former used to miscompile back in 2005, but this no
longer appears to be the case. Further, using strtod ()
is problematic on Linux/ARM systems with many non-US
locales that use a comma as the decimal separator.
In particular, this breaks almost all compilation with
MCS because it can't parse floating point literals.
Based on investigation by Damien Diederen <[email protected]>.
- bugzilla.xamarin.com issue 20925
- if an expression column was added ayer there were rows, and then IsNull is called, the result is incorrect (it will always be true)
sgen-domain-unload.exe test would crash because of a bug involving queue->alloc_prepare_func => workers_gray_queue_share_redirect => sgen_gray_object_dequeue_section on queue => set queue->first->size depending on queue->cursor. The solution is simply to make sure that the cursor is set on the queue, before allocating a new section, even if it is does not seems necessary in the first place.
Instead of generating a sequence of AMD64 instructions for
power-of-two OP_[IL]REM_IMM, portably decompose them to intermediate
code.
OP_IREM_IMM is decomposed on 32 and 64 bit archs, OP_LREM_IMM only on
64 bit archs.
By using StringAssert we get a more descriptive error message when the test fails, i.e. the expected vs. the actual string value instead of just true/false.
The pid_t type is required by POSIX to be a signed integer type (and that it
isn't wider than long in at least one programming environment). Mono has a
bunch of issues with 64-bit pids at the present, this is a start. Cast the
pid to the largest available signed type before printing it.
This change is released under the MIT/X11 license.
The u_char, u_short and u_int types are non-standard and no system headers
are required to provide them. There are no particular use for them and the
builtin standard types will do just as well.
This change is released under the MIT/X11 license.
I had to use the null garbage collector due to boehm being troublesome. The
code appears unmaintained but I can see a recent git commit enabled support
again. However, I had to do more than that to get it working. I'm really not
sure how semantically correct this is and it needs review from an expert in
how threads and garbage collection interplay in Mono. It seems very odd that
various attributes (such as its short id) about the main thread is
initialized as a side effect of initializing the garbage collection. The
mono_thread_info_attach was needed to prevent a crash.
This change is released under the MIT/X11 license.
Welcome to the world of tomorrow! It's been almost a decade since this was
made obsolete in 2005. Nothing uses this function any longer. Additionally
it is completely broken as utimes takes a pointer to an array with two
timevals, but the code passes only a pointer to a single timeval.
This change is released under the MIT/X11 license.
This test was added in 2004 to work around buggy Linux distributions and is
not needed today. The test caused problems as it also ran on non-Linux
operating systems and assumed dynamic linking was available. This caused it
to mistakenly decide thread-local storage was unavailable on operating
systems with no dynamic linking (but perfectly usable thread-local storage).
This change is released under the MIT/X11 license.
The __USE_GNU macro is an internal macro used by glibc to enable the GNU
extensions. Programs are instead meant to use the _GNU_SOURCE macro before
including any system header.
This change is released under the MIT/X11 license.
The SIGPROF signal is an XSI option and obsolescent in XSI. POSIX systems
are not required to have it.
This change is released under the MIT/X11 license.
There is no standard bzero function, only the standard memset function, and
Mono does not declare its own bzero function.
This change is released under the MIT/X11 license.
The configure script determines the size of the sun_path member in struct
sockaddr_un. However the test is broken during cross-compilation (with a
comment that there is no macro to determine the size of struct members at
configure time) and MONO_SIZEOF_SUNPATH defaults to 0 (leading to buffer
underflows and overflows). There is no reason to determine this at configure
time when a simple traditional sizeof will do the job at compile time.
This change is released under the MIT/X11 license.
The MAP_FAILED macro is the standard return value of mmap() upon failure and
it is allowed to have other values than (void*)-1.
This change is released under the MIT/X11 license.
The dump_ubin function is only used by the elf_dl_callback function. It
should be wrapped in the same #if conditional to avoid a warning if the
preprocessor conditional isn't true.
This change is released under the MIT/X11 license.
The get_fstypename function is only used by the GetVolumeInformation
function. It should be wrapped in the same #if conditional to avoid a
warning if the preprocessor conditional isn't true.
This change is released under the MIT/X11 license.
The S_IWRITE macro is a non-standard macro provided by some operating
systems for compatibility with BSD. POSIX specifics a standard macro with
identical semantics with the name S_IWUSR.
This change is released under the MIT/X11 license.
POSIX defines struct timespec in time.h and struct timeval in sys/time.h.
Some operating systems have merged these headers, but this isn't required or
encouraged by POSIX.
This change is released under the MIT/X11 license.
Only mono/metadata/icall.c and mono/metadata/filewatcher.c include the
mono/metadata/filewatcher.h header and none of them depend on the contents
of the non-standard header <sys/syscall.h>.
This change is released under the MIT/X11 license.
POSIX specifies <poll.h> as the standard header that declares the poll
function. Many systems provide <sys/poll.h> to be compatible with historical
practice. Prefer the <poll.h> header over <sys/poll.h> if it is available.
This change is released under the MIT/X11 license.
POSIX mandates that select is declared in <sys/select.h> (and in the header
<sys/time.h> for compatibility). It would be best to include the new header
if it is available. This is already done throughout the source tree, though
not in all instances.
This change is released under the MIT/X11 license.
This patch consist in changing the way we access the current element value in the gray queue. Before, we would save the index of the last element in the queue, then to access to the current value, we would have to make 2 memory access + 1 array offset access. Now we store a pointer to the current element, so we only need 1 memory access, thus reducing the number of memory indirection. We see ~25% speed improvement in major gc collection time on gc-graystack-stress test.
This is a stopgap measure: This test hangs a *lot* on Jenkins
and it's only being disabled to get stable-ish builds. It's
being actively investigated still.
Without this, three of the tests fail on Linux kernels without IPv6
support.
This is a minimal fix, copy'n'pasting a conditional which was used in
other tests. It might be nicer to factor out the SupportsIPv6 to its
own utility function.
When DataMember is already set before DataSource we need to verify that it refers to a valid property in the DataSource setter, otherwise we'd get an exception in ResetList ().
This fixes the following failing tests: BindingSourceTest.DataMemberBeforeDataSource and BindingSourceTest.DataSourceAssignToDefaultType.
Commit licensed under MIT/X11.
Instead of using mono_valloc we create a temp file and unlink it. With this we can have the right
mmap semantics regarding CoW and access rights.
This does simplify the code too by completely removing the mapping kind.
This patch is from Brendan Zagaeski and fixes bug 11307
The description of the problem was:
In Mono 2.10.12, the BasicHttpBinding property no longer supports
EnableHttpCookieContainer because it is Depreciated. The replacement
is AllowCookies, but this property does not work. Upon inspection of
the source source, we find that the HttpCookieContainerBindingElement
is added in accordance with EnableHttpCookieContainer, but not
AllowCookies.
The conditional compile logic at [1] is no longer needed for
Xamarin.iOS or Xamarin.Android.
Apparently on slow systems the items with 1sec expiration time are already removed from the cache by the time the #CS3 Assert() is hit, which caused the test to fail.
Increasing the expiration time by +2sec should hopefully fix this.
Commit licensed under MIT/X11.
BindingList subscribes to PropertyChanged events of eligible contained objects. Iff the PropertyName provided is valid,
the list event's ListChangedEventArgs will also contain a PropertyDescriptor.
This is to match MS behavior.
Now the user has access to all struct elements in EpollEvent when
using epoll_ctl. This is in particular very intersting when the
user wants to access the ptr field.
The user can use GCHandle.ToIntPtr to give the struct a GCHandle
and then handle the pointer later on when using epoll_wait.
The 'minimum' default value of NumericUpDown was set to 0.0M, which caused the ToString() to format it as "0.0" instead of "0" as it does on .NET.
A similar change was done for the 'maximum' default value already in f6c8d48a3a.
Commit licensed under MIT/X11.
Several System.Resources tests rely on a DummyAssembly.dll, which was removed in 016b0b5170 (possibly by accident?).
This commit adds the assembly back.
Commit licensed under MIT/X11.
The .NET AddCacheDependency method signature is `public void AddCacheDependency(params CacheDependency[] dependencies);` Mono should mirror the signature (even if it isn't implemented) to prevent build errors. Conditional code, of course, will need to be used for an alternative mono path.
Removed code that stripped CDATA statements (but not blocks) from input when showing a namespace page:
The function Ecma2Html.WrapStream(TextReader,Dictionary<String,String>) very explicitly returns a new `AvoidCDataTextReader` when the system is showing a namespace. The `AvoidCDataTextReader` strips the CDATA statement, but not it's internal contents. The intent, according to AvoidCDataTextReaderTests, is to allow class summaries of this form:
"<elements><summary>Addressbook APIs.</summary><remarks /><class name=""ABAddressBook"" fullname=""MonoTouch.AddressBook.ABAddressBook"" assembly=""monotouch""><summary><![CDATA[
Provides access to the system Address Book.]]>
</summary></class></elements>"
But that form is not desired.
The bug arose because the input to `WrapStream` is very large (it actually includes the entire *description* for each class and member in the namespace!). If any CDATA-block contained entities such as, e.g., < or >, the resulting XML would (obviously) be ill-formed:
"<xml>This should be valid <![CDATA[<T>]]> </xml>"
would throw because the <T> would be attempted to be parsed as XML. Obviously, samples that contain generics or lambda or XAML would cause this problem.
Although an XMLException was thrown, Macdoc swallows the exception in DocTools.GetHTML(). That is why this caused a silent failure on macdoc and was visible on Webdoc.
Remove the "ConnectionState" from the connection list before closing the connection,
this should avoid ServicePoint.SendRequest() ever crashing with a NullReferenceException
due to getting a null return value from WebConnectionGroup.GetConnection().
The fragment list has one invariant, the next pointer is tagged if the current fragment is been deleted,
which means the list head can never point to a tagged pointer.
If this invariant is broken, the code in find_previous_pointer_fragment will end up in an infinite loop.
The infinite loop happens in this simplified fragment:
try_again:
prev = &allocator->alloc_head;
1) cur = unmask (*prev);
while (1) {
2) if (*prev != cur)
goto try_again;
So assume allocator->alloc_head points to 0x121, which is tagged.
So execution goes like this:
1) cur is set to 0x120
2) *prev (value 0x121) is different than cur (value 0x120) so retry.
The above will loop forever as the fixup code never touches allocator->alloc_head.
Now that we understand the infinite loop, let's see how the remove code can trigger it.
Use use the following notation in the event sequence:
-> a non tagged pointer
-*> a tagged pointer
first CAS: InterlockedCompareExchangePointer ((volatile gpointer*)&frag->next, mask (next, 1), next)
second CAS: InterlockedCompareExchangePointer ((volatile gpointer*)prev_ptr, next, frag)
Assuming the following initial fragment list and two threads removing two separate fragments:
fragment list; -> A -> B -> C
thread 1 removes A
thread 2 removes B
thread 2 succeed the first CAS
-> A -> B -*> C
thread 1 succeed the first CAS
-> A -*> B -*> C
thread 2 fail the second CAS because of thread 1
-> A -*> B -*> C
thread 1 succeed the second CAS
-> B -*> C
thread 2 succeed the second CAS and set prev_ptr to next,
which at this point is a tagged pointer. Leaving the fragment list like this:
-*> C
After the last CAS, we end up with alloc_head with a tagged pointer, which will cause
the infinite loop we previously explained.
The fix is to unmask the value we store in the second CAS, as the objective is to link
two live fragments and not flag the previous fragment for deletion.
The exact same bug exists in mono-linked-list-set and was fixed there.
The is no reason to ever invoke the callback on the ThreadPool,
it would in fact only cause trouble.
Marek's commit db92449f was correct, I removed the commented out
code and the no longer used method.
Thanks a lot for Martin Potter to find and report the race condition
which was causing the problem.
ServicePointManager.RecycleServicePoints() was a left-over from the
old times when we didn't have an idle-timer based approach.
Here's the scenario that causes the crash:
Exception is fired, which invokes mono's vectored exception handler. It
is not an exception mono recognizes, so falls through to the default:
case in the exception handler. The problem is the return value has been
initialized to EXCEPTION_CONTINUE_EXECUTION. This causes SEH not to
process any other handlers, and just attempt to continue execution at
the point the exception was thrown.
The problem is much of windows internals will catch various exceptions
internally and handle them. So instead of the exception being handled,
we would just crash in the bowels of windows.
The solution is to set mono_win_chained_exception_needs_run to TRUE in
the default case - this is what the various exception handlers do if the
exception is not in JIT'd code. This causes the handler to return
EXCEPTION_CONTINUE_SEARCH, which causes SEH to search for the next
handler, and no crash is produced.
Both x86 and x64 had this bug, so I fixed it in both places.
Fix contributed by Steve Anichini.
The problem is that on some platforms we call the function
without having provided a prototype for it. This breaks when
building with `-Werror`.
Now we declare it in the private `vasprintf.h` header when
the platform doesn't have a declaration in `stdio.h`. This
should also let us remove the hack in `glib.h` for MSVC.
This may or may not break the build on some platforms; I've
tried on those that I have access to with success. Let me
know if this breaks anything.
We now use generic atomics which work on all platforms, so there's
no reason to keep this constraint here. This allows the `perf`-backed
profiler to be used on mips, ppc, s390x, etc.
This reverts commit 8e35b7d01e.
The fallback implementation (as used on other platforms) appears to hang
the runtime. Having a maybe-working `perf`-backed sample profiler is better
than a not-working sample profiler.
This reverts commit 1fdc8789a7.
This breaks the ios build:
../../../../../mono/mono/utils/atomic.c: In function ‘InterlockedCompareExchange64’:
../../../../../mono/mono/utils/atomic.c:572: error: ‘spin’ undeclared (first use in this function)
../../../../../mono/mono/utils/atomic.c:572: error: (Each undeclared identifier is reported only once
../../../../../mono/mono/utils/atomic.c:572: error: for each function it appears in.)
When using "HTTP CONNECT" to create a tunnel to a proxy server,
check the proxy server's response for the HTTP Version and close
the connection if it's HTTP/1.0.
- ADDED: Implemented NetworkInterface property "OperationalStatus" to be UP, in case the IFF_UP flag is set
- ADDED: Implemented NetworkInterface property "SupportsMulticast" to be true, in case the IFF_MULTICAST flag is set
This change is released under the MIT license.
I cannot explain why, but this affects building solution that has more than
one projects for MS.Build.dll. <MSBuild/> task returns false for successful
builds without this change.
Most likely codegen or runtime issue, but a bit too high level to drill down.
UploadString call UploadData that encapsulates all exceptions in a WebException. ThreadInterruptedException were encapsulated into a WebException, so UploadStringAsync now uses e.InnerException is ThreadInterruptedException instead of trying to catch it.
Tests that UploadStringAsync triggers UploadStringCompleted with Cancelled == true.
Tests that UploadDataAsync triggers UploadDataCompleted with Cancelled == true.
Tests that UploadValuesAsync triggers UploadValuesCompleted with Cancelled == true.
Tests that UploadFileAsync triggers UploadFileCompleted with Cancelled == true.
This is enabled only with Microsoft.Build.dll because property function
support is not fully implemented in MS.Build.Engine.dll and simply fails.
Since the targets files are shared between xbuild and msbuild, I added
some well-known property for msbuild and used it in the targets file.
This behavioral difference between ProjectRootElement, Project and
ProjectInstance was discovered while trying to get F# project working
(where item order significantly matters).
If the base_stream was a NetworkStream UnmanagedRead loop would call base_stream.Read a second time and block until one byte was available to return. Without the loop UnmanagedRead will only read the base_stream once.
This fixed a runtime exception when trying to get a ClaimsPrincipal from an IIdentity.
Noticed this work working with aspnet Identity in a Web Api 2 controller.
Exception fired when running User.Identity.IsAuthenticated.
Exception detail:
http://falk.pw:7777/tocehuhemo.xml
Previously if --with-gc=none --with-sgen=yes was specified the sgen runtime
would include the null GC and the sgen GC which would confuse the linker.
This change released uner the MIT license.
This patch includes a few fixes:
* CreateNew will actually create a memory map file, the previous logic
in MemoryMapImpl.Open was wrong, and would fail if the file did not
exist. We now cope with this (bug #20052 was caused by this).
* Some exceptions were wrong, so this patch updates the
exceptions being thrown to be the right ones
* On Mobile, we inverted the logic to ensure that capacity must be
bigger or equal than the file size (which is what the API needs to do),
previously it performed the opposite test.
Added tests that match the behavior on .NET for this.
Dequeue sets the head.Value to its default. When TryPeek is interrupted in the process of retrieving the value some times Dequeue sets the value to its default. TryPeek now checks the head has not been changed before returning the value.
The Color property was obsoleted, but the suggested replacement
SetSourceRGBA has 4 double parameters, which can be unconvenient.
Add a SetSourceColor that takes a Cairo.Color parameter, make the Color
property use it, and update the message on the Obsolete attribute.
The new finalizer API allows an embedder to be notified during a collector
when an object is queued for finalization.
This is a VERY low level interface, as this is called with the world stopped, so the
code MUST be async safe. If you don't precisely know what that means, don't use it.
* libzlib - This library and the development headers are required for compression
file support in the 2.0 profile.
4. Mono is required to build Mono. Use a system package or monolite (explained further below)
5. If you have a system Mono (not monolite), you will need to read this: http://mono-project.com/Parallel_Mono_Environments#Setting_up_a_Build_Environment
/*) # absolute path, assume it is an install location
libgdiplus_loc=$with_libgdiplus
libgdiplus_install_loc=$with_libgdiplus
;;
*)
libgdiplus_loc=`pwd`/$with_libgdiplus
;;
esac
AC_SUBST([libgdiplus_loc])
AC_SUBST([libgdiplus_install_loc])
AC_ARG_ENABLE(icall-symbol-map,[ --enable-icall-symbol-map Generate tables which map icall functions to their C symbols], icall_symbol_map=$enableval, icall_symbol_map=no)
if test "x$icall_symbol_map" = "xyes"; then
@@ -3200,7 +3205,7 @@ if test ${ACCESS_UNALIGNED} = no; then
CPPFLAGS="$CPPFLAGS -DNO_UNALIGNED_ACCESS"
fi
case "x$gc" in
case "x$libgc" in
xincluded)
# Pass CPPFLAGS to libgc configure
# We should use a separate variable for this to avoid passing useless and
#define g_assert(x) G_STMT_START { if (G_UNLIKELY (!(x))) g_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", __FILE__, __LINE__, #x); } G_STMT_END
#define g_assert_not_reached() G_STMT_START { g_assertion_message ("* Assertion: should not be reached at %s:%d\n", __FILE__, __LINE__); } G_STMT_END
#define g_assert_not_reached() G_STMT_START { g_assertion_message ("* Assertion: should not be reached at %s:%d\n", __FILE__, __LINE__); eg_unreachable(); } G_STMT_END
Loaded 100 of 1764 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.