It seems cairo_ps_surface_begin_* functions never existed, they were
always named cairo_ps_surface_dsc_begin_*.
Conflicts:
mcs/class/Mono.Cairo/Mono.Cairo/PSSurface.cs
The third and fourth parameters of the Rectangle constructor are width
and height, but cairo_stroke_extents and cairo_fill_extents give right
and bottom coordinates.
Signed-off-by: Bertrand Lorentz <[email protected]>
Conflicts:
mcs/class/Mono.Cairo/Mono.Cairo/Context.cs
Also:
* improving naming consistency
* obsolete old/broken stuff
* clean up tabs/space mix
NOTE: this removes the wrapper caches for Pattern and Surface as
there was no reliable way to clear them.
Conflicts:
mcs/class/Mono.Cairo/Mono.Cairo/Context.cs
* debugger-agent.c (frame_commands): When a thread is suspended in native code its top frame
will be missing a context, so it's not possible to inspect it. Instead of reporting an invalid
frame, it makes more sense to report unavailable data as this is the right clue for clients.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=12686
Mono.Unix.UnixFileSystemInfo.LastWriteTime & co. were hilariously
wrong. Just...hilariously wrong.
$ ls -l bxc12686.exe
-rwxr-xr-x 1 jon staff 4096 Jun 14 15:43 bxc12686.exe
$ csharp -r:Mono.Posix
csharp> new Mono.Unix.UnixFileInfo("bxc12686.exe").LastWriteTime;
6/14/2013 7:43:12 PM
Note: I'm currently in EDT (US Eastern Daylight Time). LastWriteTime
is supposed to be in the local time; it's 4 hours off (which also
happens to be the EDT UTF offset: -4:00).
The fundamental problem was that NativeConvert.FromTimeT() was written
for pre-.NET 2.0 environments, which precluded use (or knowledge of!)
DateTimeKind. Now that .NET 1.1 is no longer supported, and 2.0 is on
the its deathbead (bring on 4.5!), we can be smarter and let DateTime
sanely handle the conversion logic for us.
After the fix:
$ csharp -r:Mono.Posix
csharp> new Mono.Unix.UnixFileInfo("bxc12686.exe").LastWriteTime;
6/14/2013 3:43:12 PM
TLS initialization must be done as early as possible since runtime initialization
might be intermingled with 3rd party code running that sometimes create additional
slots. Those extra TLS slots do interfere with AOT compilation that might see a
different set of offsets when compiling than when running.
The current piece of problem is AOT image loading. If the AOT image is not found,
the dynamic linker in 10.9 will create a TLS slot to hold error data. AOT image
loading is triggered in between the creation of the runtime TLS slots.
Since AOT image loading never happens during compilation, the dynamic linker
would never create the slot and things would otherwise remain working.
The solution is to move all TLS initialization to before any assembly is loaded
and, transitively, AOT image loading.
This change doesn't affect any of the cats that default to 8Mb.
We need a significantly big main stack because mcs is implemented
in a recursive fashion and, right now, parts of the corlib test suite
require in excess of 1Mb of stack space to compile.
According to the docs and matching the behavior in .Net, BigInteger's
GreatestCommonDivisor must return the absolute value of the non-zero
parameter if one of the parameters is zero.
Contains a fix and extended unit tests to cover the case.
* mono-suppport-x86.c (mono_mach_init): Probe TLS slots using an
unlikely canary. Right now only two offsets are known.
* mono-threads.c (mono_threads_init): Initialize mach from here
as remote TLS reads are required for mono-threads to work.
The unload thread stores TRUE to the done field when unloading
ends so the initiator can break out of the wait loop in case its
thread doesn't belong to the domain been unloaded but was still
aborted.
This means that the initiator could be gone when the unload
thread stores into the done field. This is now a random write
to the thread stack, which has a high chance of causing crashes.
The solution is to move the unload_data to the heap and refcount
it so we can release it safely.
Type: System.Numerics.Complex
IFormattable format strings and string.Format formats are different
and incompatible. For example, `x.ToString("G")` and `x.ToString(null)`
must be equivalent to `x.ToString()`, but they behave very differently
with string.Format, where the former just returns "G" and the latter
throws an ArgumentNullException.
Changes System.Numerics.Complex.ToString to pass the format string to
double.ToString instead of string.Format.
Adds UnitTests for the changes in new ComplexTest.cs file
When a regular runtime shutdown and a domain unload starts mostly in parallel
it might happen that the unload initiator will deadlock waiting on the unload thread
for two reasons:
The unload thread will block when attaching as the runtime believe it's better
to not finish it as it's going down. To fix this we now use mono_thread_attach_full
and force it to be attached.
The unload initiator might deadlock on the wait loop if the shutdown initiator aborts
it instead of the unload thread. This happens if the unload was done from outside of
the domain been teared down.
The fix here is to add a variable that the initiation test on every loop, which is the
right thing to do when using wait loops on handles. This might degrade into a busy
loop when the above race condition happens. It's rare enough that it's not worth
fixing it now.
If threadpool_clear_queue is called while the runtime is been shutdown
it might crash since the queue will have been cleaned.
So now we guard against null queues and bail out from appending
the existing jobs if shutdown was initiated.
This fixes a race condition where two threads could perform runtime shutdown
at the same time and either crash or hang. Now each initiation checks if they
won and take the proper action in such case.
A recurring problem was with the debugger, that would hang on shutdown if the
main thread started shutdown earlier. In this case the agent thread would
call into mono_threads_set_shutting_down, which in turn would do an ExitThread
since shutdown was in progress.
The agent thread would exit without signaling that it did complete, causing
the main thread to block waiting for it to do so.
* runtime.c (mono_runtime_shutdown): Rename it to mono_runtime_try_shutdown
and move threadpool cleanup to here. Some cleanup of the rest of the sequence
still left to do.
* icall.c (Environment.Exit): If we fail to start shutdown, just exit
the thread as someone else will finish the job. We can't suspend because if
this is called by regular shutdown we would be resumed and return to user code.
An alternative would be to detach and then suspend. Not sure on the merits.
* threads.c (mono_thread_manage): If we fail to start shutdown, suspend
as this is what the winner initiator wants us to do as it must be for
forced exit.
* debugger-agent.c (vm_commands): If we fail to start shutdown, return
from the function and let the agent thread finish and clean up.
* debugger-agent.c (debugger_thread): VM_EXIT commands now can return
if shutdown was externaly initiated and in such case we should break
the main loop and let the agent thread finish.
* sgen-gc.c (mono_gc_pthread_exit): Given the current thread is doomed, explicitly
detach before calling pthread_exit and thus reducing the chance of TLS cleanup issues.
Previously the code expected to stop at upper level node using the fact that their element starts with `root:/'. This element is attributed by RootNode when loading a complete tree. However tool like mdoc also loads tree unattached which doesn't create a standard `root:/` top-level root node hence causing the issue.
Context: System.Security.Cryptography/AesCryptoServiceProvider.cs
Add System.Security.Cryptography.AesCryptoServiceProvider to the
MONODROID profile.
This is needed so that Aes.Create() can work.
The problem is sporadic mdoc test failures on Wrench/OS X:
Updating: Mono.DocTest.Widget/NestedClass/Double/Triple/Quadruple
mdoc: System.UnauthorizedAccessException: Access to the path '/var/folders/_g/y9v720_90l914yylrk7m903c0000gn/T/tmp20f71445.tmp' is denied.
at System.IO.FileStream..ctor (System.String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, Boolean anonymous, FileOptions options) [0x00000] in <filename unknown>:0
at (wrapper remoting-invoke-with-check) System.IO.FileStream:.ctor (string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,int,bool,System.IO.FileOptions)
at System.IO.Path.GetTempFileName () [0x00000] in <filename unknown>:0
at Mono.Documentation.MdocFile.UpdateFile (System.String file, System.Action`1 creator) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDocUpdater.WriteFile (System.String filename, FileMode mode, System.Action`1 action) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDocUpdater.DoUpdateType2 (System.String message, System.Xml.XmlDocument basefile, Mono.Cecil.TypeDefinition type, System.String output, Boolean insertSince) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDocUpdater.DoUpdateType (Mono.Cecil.TypeDefinition type, System.String basepath, System.String dest) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDocUpdater.DoUpdateAssembly (Mono.Cecil.AssemblyDefinition assembly, System.Xml.XmlElement index_types, System.String source, System.String dest, System.Collections.Generic.HashSet`1 goodfiles) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDocUpdater.DoUpdateAssemblies (System.String source, System.String dest) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDocUpdater.Run (IEnumerable`1 args) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDoc.Run (System.String[] args) [0x00000] in <filename unknown>:0
at Mono.Documentation.MDoc.Main (System.String[] args) [0x00000] in <filename unknown>:0
I'm not sure why we're getting UnauthorizedAccessException exceptions,
nor do I particularly care; Path.GetTempFileName() should not be
throwing UnauthorizedAccessException; only IOException is documented:
http://msdn.microsoft.com/en-us/library/system.io.path.gettempfilename.aspx
Update behavior to skip files that generate
UnauthorizedAccessException, and if we swallow short.MaxValue
exceptions wrap the UnauthorizedAccessException in an IOException so
that we conform to documented exceptional behavior.
TimeSpan.TryParseExact would previously throw a NullReferenceException constructing the Parser when it accesses the Length property of the input string. Microsoft's implementation returns false when null is passed as the input string to parse.
This is generally preferable because it works in QEMU chroots and
the information is significantly easier to process.
We still need to keep the /proc/cpuinfo code around, however, as
Android does not always allow access to /proc/self/auxv...
This patch also enhances the MONO_CPU_ARCH environment variable
to support the various new features we support.
MonoTouch may use a shared libmono with AOT-compiled assemblies,
and the AOT-compiled assemblies need to access internal symbols
from libmono. The monotouch runtime also uses a few internal
API.
So the easiest way to fix both these cases is to make everything
public for MonoTouch. The libmono used will always be in sync
with the AOT-compiled code, so ABI-breakage is not a concern.
3d3fe6af (among other commits...) "broke" the `mdoc` unit tests, as it
did two things:
1. It added a new codepath calling string.Format(), thus introducing
a new set of exceptions.
2. Due to an `mdoc` bug, (1) resulted in a stack overflow on OS X.
(1) demonstrates that the mdoc unit tests might be too brittle.
(2) was fixed in 04bf9ad.
The problem with 04bf9ad, though, is that it resulted in a gigantic
~212MB diff, because while the recursion was "fixed", we could still
process the same method multiple times, resulting in _lots_ of
duplication, e.g. System.String.get_Chars() would be repeated hundreds
of times for a given exception.
Improve the source reporting mechanism so that instead of a
List<MemberReference> we use a HashSet<MemberReference>, listing each
source location _once_ instead of repeating them.
The _formatting_ of the <exception/> element is also changed so that
each source location is on its own line, making it easier to read and
review the locations.
Commit 44b2b4a8 completely broke `mdoc export-msxdoc` because
EcmaDoc.GetCref() was removed. Expected:
<member name="C:Mono.DocTest.DocAttribute(System.String)">
Actual:
<member name="Mono.DocTest.DocAttribute..ctor">
i.e. useless.
The fix: bring back GetCref(), this time within monodocs2slashdoc.cs.
Commit 0ad6ffde changed the HTML-generating stylesheet and moved some
@id attributes around, thus breaking the mdoc unit tests (expected
output likewise changed). Fix the monodoc XSLTs so that we don't emit
id="" attributes (id's with no value).
Update mdoc's expected output so that tests pass[*].
[*]: tests will NOT actually pass, as 04bf9add -- attempted fix for
an OS X stackoverflow caused by 3d3fe6af -- results in a gigantic
216MB diff because String.get_Chars() is repeated over and over and
over... The updated expected output in this commit is the "ideal"
update needed after locally reverting 3d3fe6af and 04bf9add.)
As suggested by Marek Habersack, instead of catching
SynchronizationLockException in the case that the lock wasn't
acquired, we now have a boolean that indicates if it was
acquired or not, so we can act on it on the finally{} block.
This fixes #12355/#12395/#5904.
When EndRead() is called with a null "inner" IAsyncResult, then
we should not consider this as an end-of-stream condition.
This happens sometimes when using SSL and chunked encoding.
* GetReferenceAssemblyPaths: return the reference assemblies for the
requested PCL profile.
* ResolveAssemblyReference: always include System.Runtime as a
dependency; the .targets check for this to determine whether
we're a PCL2 library.
[Sys.Web.Routing] Refactor of Route's GetVirtualPath implementation based on System.Web.Http.Routing code in order to fix a few incompatibilities between our implementation and the one at ms.net
The ConnectionStrings property of System.Configuration.ConfigurationManager
works perfectly, so this MonoTODO is not needed.
A unit test is also added to demonstrate that it's fully working and to
prevent it failing in the future.
Fixes Bug 327 - Mono.Data.Sqlite doesn't work without SQLITE_ENABLE_COLUMN_METADATA
Essentially, if sqlite3_column_origin_name is not found, omit the metadata, instead of
exploding. This is the fallback that's already used on MonoTouch.
A better fix would be load the column metadata from other sources, as proposed in
https://bugzilla.xamarin.com/show_bug.cgi?id=2128
* object.c (mono_field_get_value_object): If the field belongs to a class with a broken
vtable, lets raise an exception instead of printing a message and returning NULL.
Fixes#11362
Revert "add System.Net.Http.Formatting to monodroid build"
Revert "added System.Configuration and System.Security to monodroid build to fix it"
This reverts commit 85cb9e3176 and
commit 6566273367.
Prior to 38348361da, the mono/X.X folders
were created when "gacutil /i foo.dll /package X.X" was called. However,
The above commit caused a call to $(INSTALL_DATA) to be executed *before*
gacutil, which caused a copy of Microsoft.Common.targets to be installed
as a file named mono/3.5 instead of into the mono/3.5 folder, on fresh
installs (not a problem installing into an existing prefix).
This commit forces creation of the folder which could potentially not
have been created yet by gacutil.
* sgen-os-posix.c (sgen_thread_handshake): Never never never never never
use pthread_kill on Android as it doesn't work with the main thread.
This resulted in all sorts of fringe crashes in #12112.
4.0/Microsoft.Common.* was not installed anywhere, so it could safely
be deleted, and 4.5/M.C.* was previously being installed into
$(prefix)/lib/mono/4.0. It's now in 4.0/M.C.* to match xbuild's
tool version.
This patch does not affect how things are installed, it simply cleans
up the source layout.
* exception.c: Add mono_exception_get_managed_backtrace so the code that
deals with unhandled exceptions can produce some stacktrace in case
Exception::ToString itself produces another exception.
This can happen under multiple situations, be it OOM, heap corruption or
bugs in ToString ().
System.Web.ConfigurationManager had a cache which didn't have any max limit,
therefore when using Restful URIs in ASP.NET (like having some variable
parameter in the virtual path, i.e. /user/{userId}/tracks, where {userId}
is a variable Integer) this was very likely to cause a leak which would
end up causing troubles, like an InvalidCastException thrown by
HttpApplication::PreStart()
(Read operations in the cache now cause a write operation on the cache
object, so all sectionCache lock-read usages are converted to lock-write.)
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=5598
MCS used to emit code that would merge two stacks only by one of the interfaces
that two concrete types have.
This is not the behavior on either the SPEC or the MS implementation. It's not
a great one as the selected interface is non-deterministic, while the a parent is.
Refactor System.Net.NetworkingInformation in order
to support multiple "providers"; previously only
Linux was ever supported for this API.
This patch provides basic support for Mac OS X
via the SystemConfiguration framework's
SCNetworkReachability API.
bxc#12038
Followup to:
http://forums.xamarin.com/discussion/comment/11823/#Comment_11823
These are Switches with a labotomy: the MOBILE profile does not
support System.Configuration.dll, so there is no support for
.exe.config files or
System.Diagnostics.DiagnosticsConfigurationHandler.
Consequently these Switches are largely a compatibility/portability
aid: they DO NOT have the full functionality that the desktop
profile affords. Specifically, there is no way to provide an XML
config file that contains the Switch values to use. If you need to set
the Switch values, this MUST be done manually, e.g. through a Switch
constructor's `defaultSwitchValue` parameter or through a property,
e.g. for SourceSwitch:
http://msdn.microsoft.com/en-us/library/w65awck1.aspxhttp://msdn.microsoft.com/en-us/library/system.diagnostics.sourceswitch.level.aspx
* mono-threads.h: Add new field to MonoThreadInfo.
* threads.c: New API function mono_thread_is_foreign that allows one to query if a given thread
is foreign or not.
* driver.c: Don't auto attach all threads, this is the same behavior of
posix and mach. We still auto-detach so we can catch foreign threads that
forgot to do it.
* mono-threads-windows.c: Detach the thread after the thread fun has run to
completion, this ensures we cleanup runtime-managed threads in a saner fashion.
* mono-threads.c:
* mono-threads-posix.c: Explicitly detach a thread from the wrapper
instead of relying on the TLS destructor. This gives a good environment
most of the time for other parts of the runtime to work with.
In the previous commit, ExitCode was implemented, so we can query it now.
This is useful because many Windows Services nowadays use this variable
to notify about a problem at stop time.
Stop() wasn't calling OnStop, so a unit test was added, its basic
functionality was implemented, and MonoTODO is removed.
ExitCode now also stops throwing NIE. A unit test is added to confirm
that ServiceBase class doesn't modify it across runs. This property will
be useful for my next commit in mono-service.cs.
* sgen-bridge.c: Split the registration and dfs1 steps so we avoid issues
where an earlier entry that points to a later one would not have a xref
created between them.
First we insert all bridges into the hash table and then we do dfs1.
It must be done in 2 steps since the bridge arrays doesn't come in reverse topological order,
which means that we can have entry N pointing to entry N + 1.
If we dfs1 entry N before N + 1 is registered we'll not consider N + 1 for this bridge
pass and not create the required xref between the two.
System.Web.ConfigurationManager had a cache which didn't have any max limit,
therefore when using Restful URIs in ASP.NET (like having some variable
parameter in the virtual path, i.e. /user/{userId}/tracks, where {userId}
is a variable Integer) this was very likely to cause a leak which would
end up causing troubles, like an InvalidCastException thrown by
HttpApplication::PreStart()
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=5598
This should aid in tracking down bugs such as #11871 (or possibly even
fixing them) - if the problem still exists the process will run into
an infinite loop, which is a lot easier to debug (at least on iOS, and
likely other platforms too) than a stackoverflow.
* mono-mutex.c: Add mono_mutex_init_suspend_safe so special targets
like OSX that have broken implementations of suspend for pthread mutex
will hang less.
A suspension safe mutex means one that can handle this scenario:
mutex M
thread 1:
1)lock M
2)suspend thread 2
3)unlock M
4)lock M
thread 2:
5)lock M
Say (1) happens before (5) and (5) happens before (2).
This means that thread 2 was suspended by the kernel because
it's waiting on mutext M.
Thread 1 then proceed to suspend thread 2 and unlock/lock the
mutex.
If the kernel implements mutexes with FIFO wait lists, this means
that thread 1 will be blocked waiting for thread 2 acquire the lock.
Since thread 2 is suspended, we have a deadlock.
A suspend safe mutex is an unfair lock but will schedule any runable
thread that is waiting for a the lock.
This problem was witnessed on OSX in mono/tests/thread-exit.cs.
* mono-mutex.h: mono_mutex_init no longer takes a mutexattr,
it's always non-recursive and returns zero on success.
* mono-mutex.h: Add mono_mutex_init_recursive for those that need
one. This makes the API much much nicer for win32 consumers. Caching
the mutexattr on posix is really a waste of time. Mutexes are heavyweight
objects such that their creating will never be on the fast path.
* configure.in: Don't define USE_MONO_MUTEX. No sane posix system from this
millennium lacks recursive mutexes. Given that, let's just fail mono on them
and drop a bunch of dead code.
Setting this on an architecture makes Mini call
mono_arch_tls_init () on thread attach.
This is primarily useful for architectures that have not
had their LMF code ported to the new infrastructure due to
a general lack of maintenance or hardware to do it on.
This is needed for a number of reasons:
1. Runtime detection of the target FPU is very hostile towards
cross-compiling. We'd previously only pick up an FPU if we're
compiling directly on the target device.
2. The runtime detection logic would attempt to use FP instructions
regardless of whether the toolchain is actually configured for
it. That means we could end up detecting an and using an FPU
when the entire system is actually soft float, i.e. P/Invoke
blows up.
3. The previous detection logic is never what distro packagers
want because one build server could just happen to have an FPU
even though the package is being built for soft float (armel).
4. We previously invoked 'gcc' explicitly, which is of course wrong
when a non-GCC compiler is being used, or the compiler has a
completely different executable name.
We now check preprocessor definitions to detect the FPU in use. This
works with cross-compilation, respects the toolchain's configuration,
and works when non-GCC compilers are being used. It also means distro
packagers can eliminate some downstream patches they previously used
to sanitize the FPU detection logic.
writing Assembly information but Mono does not. This means that
serialized objects created on one platform are not able to be
deserialized on the other, thus preventing interoperability between .NET
and mono applications. Fixes the ObservableCollection part of bugzilla
11294.
Removed the #ifdefs which used a different value for 'ss_flags' on Linux.
According to the POSIX standard, the SS_ONSTACK flag can never be used as input to the 'sigaltstack' function -- it can only be set by the 'sigaltstack' function itself, and tested after the function returns.
Loaded 100 of 903 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.