Context: https://bugzilla.xamarin.com/show_bug.cgi?id=24947
When an Android user changes the timezone, those TimeZone changes
aren't reflected in Xamarin.Android apps. Part of this is a
Xamarin.Android bug, in which it needs to listen for TimeZone change
notifications and in turn let Mono know that the TimeZone changed.
Xamarin.Android can/will call Thread.CurrentCulture.ClearCachedData()
and Thread.CurrentUICulture.ClearCachedData() when the TimeZone has
changed. This will allow Mono to lookup the TimeZone info again.
At which point we hit two problems within Mono:
1. TimeZoneInfo.AndroidTimeZones.Local is unnecessarily cached.
2. DateTime itself caches the UTC offset for use by DateTime.Now.
TimeZoneInfo.Local is *already* cached, and TimeZoneInfo.Local is
properly cleared by TimeZoneInfo.ClearCachedData() while
TimeZoneInfo.AndroidTimeZones.Local wasn't. Removing the extra
cache allows the TimeZoneInfo to be looked up again.
Which brings us to DateTime.Now: for my simple test case, after
calling CultureInfo.ClearCachedData() the result of
DateTime.Now.ToString() didn't reflect the newly current TimeZone. The
cause for this was DateTime.to_local_time_span_object and
DateTime.last_now, which DateTime.Now uses as a cache for the
TimeZone's UTC offset.
Since these DateTime fields weren't cleared, subsequent DateTime.Now
invocations reported the *previous* TimeZone instead of the current
timezone.
To fix this, add an `internal` DateTime.ClearCachedData() method, and
call DateTime.ClearCachedData() from CultureInfo.ClearCachedData().
We can't dereference an object's VTable before we know that it's not
tagged. In this case, forwarded. The access would be unaligned and
might even fault.
We call `mono_thread_pool_cleanup` twice from `mono_runtime_try_shutdown` and later `mono_domain_finalize`, which meant we tried to destroy the semaphore twice and that caused a crasher.
Fix this by clearing out the semaphore pointer. That way when we try to destroy it again it's already null and execution continues just fine.
There's an unlikely case that Roslyn triggers quite often on Linux: A
thread tries to allocate from the nursery, but it's full. It triggers
a nursery collection, then tries allocating again. Between the
collection and the allocation retry, another thread fills the nursery
so that the retry also fails.
We failed an assertion in this case. Now we always go to the major
heap if it happens.
This bug is not hit when doing managed allocations with SGen because the
managed allocator catches it. It can be triggered with the embedding API, as
well as when the heavy binary protocol is enabled, in which case `bug-17590`
fails.
Previous code subtracted 4 pixels of the height of the text of a
toolstrip button, presumably to leave a margin. However, margins
are handled elsewhere, so we ended up with truncated text.
The intention is to make build failures easy to spot instead of silently upgrading
target framework from 2 to 4 and then fail down the road on e.g type ambiguity
caused by new 4.0 framework types or methods
This is the fix for https://bugzilla.xamarin.com/show_bug.cgi?id=25158
Current implementation does not contain the DateTimeOffsetConverter
in the list of default converters. This cause NotSupportedException
to be thrown when trying to serialize/deserialize DateTimeOffset
values to/from strings.
In .NET Framework implementation this class is added to such a list.
This fixes bug #25086 (Xamarin.Android). Details described there.
To fix the issue, we use #if XAMARIN_ANDROID to avoid that old cygwin-only
code path. (We are not sure if simply removing the old code still works,
so we don't remove that for now.)
In the Windows implementation of the TabControl, Ctrl+PageUp
navigates to the previous tab and Ctrl+PageDown navigates to the
next tab (with both wrapping around). This change implements this
feature in the Mono implementation.
Change-Id: Ib940bd08d5ba641f05ed91c0e789e356e68f72bb
ToKey() ignores the setting parameter when calling RegistryKey.OpenSubKey() and
thus always asks for write permission. If you try to read read-only keys (say
HKLM without admin rights) it will fail with a SecurityException.
* Fixed the FileSystemEventArgs.Name property for all events
* Fixed regression of bug #5747 (and related path normalizing issues) https://bugzilla.xamarin.com/show_bug.cgi?id=5747
* Improved error handling, set hard limit on file descriptors to 200 for now to help isolate issues
* Fixed issues with rapid event Changed+Renamed firing
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=24742
Context: Commit f7fd52ad
Context: https://bugzilla.xamarin.com/show_bug.cgi?id=24958
The logic of Commit f7fd52ad was 'Desktop Mono returns "Local" from
TimeZoneInfo.Local.Id, so surely Xamarin.Android should', predicated
in part on the assumption that whatever Desktop Mono does should be
the same as what Desktop .NET does.
This assumption wasn't verified, and is in fact wrong; Desktop .NET
doesn't return "Local" from TimeZoneInfo.Local.Id, it returns an
actual identifier.
The reason why Desktop Mono returns "Local" is due to implementation
sanity, particularly on OS X: /etc/localtime may be a symlink OR a
copy of the timezone data, and when it's a copy there's no way to
determine the Olson ID for the timezone. Consequently, it may not be
possible to determine the TimeZone ID.
Xamarin.Android doesn't have that problem; it uses the Android
persist.sys.timezone system property value,
falling back to java.util.TimeZone.getDefault().getID() if necessary,
and thus always has access to an Olson ID.
Change TimeZoneInfo.Local.Id on Xamarin.Android to return the Olson ID
instead of "Local", partially reverting Commit f7fd52ad.
When we draw a button with ImageAboveText.ImageAboveText and the
text is too big to fit below the image we have to draw the text over
the image. This should happen from the bottom, not from the top as
the previous implementation did. With the previous code we ended up
having the text at the top of the button under certain conditions.
UriParseComponents.ParseUser was unescaping all escaped chars and when a non valid user info char was encountered it was assuming that those chars were not part of the user info. The chars were not consumed thus the problems while parsing the rest of the input.
UriParseComponents.ParseUser now keeps non valid user info chars escaped.
Due to an incompatibility in the project files and DLL API setup code, we were importing locally defined symbols as DLL. This manifested as a debug heap dialog in VS caused by allocating and freeing memory between two Windows modules (which have their own memory heap).
Fix this by simplifying the DLL defines in MSVC, we are relying on .def files to manually specify the exports anyway.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=24741
Xamarin.Android didn't previously support
TimeZoneInfo.FindSystemTimeZoneById("Local") because of oversight (and
overly nested #if conditionals).
Compare `id` against "Local" *before* doing platform-specific
codepaths so that finding the "Local" TimeZone works as expected on
Xamarin.Android, and merge the `#if MONODROID` with the existing code.
7d1b878fbf altered the behavior of removing rows, breaking
the DataGridViewRowCollectionTest.ClearRows () test
Before the change, this is what happened when the list was cleared
(the number in brackets is the value of the Index property of the DataGridViewRow):
[0] Remove [1] ReIndex [0] Remove [1] ReIndex [0]
[1] --------> [2] --------> [1] ------> [2] -------> [1] ...
[2] [3] [2]
[3]
After the offending commit, ReIndex is only called after the list is cleared, which means
the Index property of the rows is never updated (as there are no items in the list).
The fix is to explicitly set the Index of each row to 0.
This was the end result before the commit anyway, so we can omit the ReIndex call entirely.
Before, the first thing the user saw were instructions for niche platforms like Itanium or Solaris.
Instead, we now just link to the "Compiling Mono" guides for OSX, Linux and Windows on the Mono website.
Additionally, a bunch of instructions were outdated / no longer relevant, updated those.
The "Configuration options" section was moved to the bottom of the readme, it was pretty long and pushed
the other sections into oblivion.
We can't actually use the trick of setting both the pinned and forwarded
bits to indicate cemented objects because the Tarjan bridge requires those
two bits never be set at the same time.
The factor we used previously gave us object sizes in increments that made
some benchmarks use quite a lot more memory than necessary. In particular,
we didn't have a size for 24 byte objects (on 64 bits), just for 16 and 32.
The card scanning code assumed that the size of the block header is less
than the size of a card. If we put the block info into the header and increase
the block size enough, that assumption isn't true anymore, because the
mark bits take up space in proportion to the block size.
The idea here is to first extract all the references within an object
and then to process them, pre-fetching the objects they point to a few
steps ahead.
When the runtime shuts down the last thing the GC usually hears about it
is that the root domain is unloaded. If we don't flush the binary protocol
buffers at that point, we lose entries.
We still have two separate implementations of the scanning code: The optimized
one and the old one. The old one is still needed because it supports the concurrent
collector. For the non-concurrent collector we can now use the optimized
implementation, however.
Fasten is a small tool for optimizing compile-time options:
https://github.com/evincarofautumn/fasten
It does that by parsing source files for numbers that have been marked
as "fastenable", and fiddling around with them. We do this for all
the new optimizations.
We actually implement two separate mark/scan loops: One that doesn't
support evacuation and one that does. We dynamically choose which one
to use. The evacuation-less loop is faster, so we use it whenever we can.
The reason for having a small bitmap was that we could encode the object
size in the descriptor. The main attraction for having object size handy is that
we can quickly check whether an object is in the small object major heap or
in the LOS. We solve this problem by always using complex descriptor types
for large objects, so now we can tell whether an object is small just by looking
at the descriptor type.
To identify more small objects quicker.
Since we now use the runl-length descriptor types to indicate object
size as well, and strings can have any size, we can't use that type
for strings anymore, so we use the complex type which forces us to
look up its size to determine whether it's a small or large object.
We can do the cemented check faster by using the third vtable bit to
tag cemented objects (in addition to the pinned bit). In workloads
that are heavy on cementing (like `lcscbench` or `perimeter`) this
significantly increases performance.
Another experiment: What if we put the whole block info into the block
itself, not just a pointer to it. There's one less indirection we
need to do. On the other hand, many of them will share the same cache
lines. So do the pointers to the block infos, though.
When we scan a small object in the major heap we have to read the
block header of its block. It makes sense to prefetch that as well,
in addition to the object itself.
This is another experiment.
When marking on enqueue, what we need to do is look at the object
we're about to enqueue, to check whether it's a small or large object.
Then, when we dequeue to scan, we look at the object again, so we
essentially fetch each live object header twice.
With mark on dequeue, when we encounter a pointer we always enqueue
it, without even looking at the object. Only when we dequeue do we
figure out whether it's marked yet, and thus whether we need to scan
it.
The basic idea here is to make a loop that combines dequeuing from the
gray queue, scanning and marking/copying/enqueuing, with redundancies
removed and special-casing of the common case.
We make the small bitmap type descriptor only apply to small (as
opposed to LOS) objects so that we can quickly check in that case
whether an object is in the LOS or not without actually looking up its
size.
We disable evacuation and the split nursery because the code doesn't
support them yet.
Without heavy statistics it counts almost no objects, and even with
heavy statistics turned on, it doesn't count everything. SGen has an
accurate counter when heavy statistics are turned on.
In case the test runner returns null we will no longer suffer a NullArgumentException and the collector exceptions will be printed.
The test runner was returning null because of an IOException "Too many open files" on NUnit side.
* Add support for colorizing the HTML output. This can be turned off if desired.
* Some changes are now reported inline (using colors/underline/strikeout)
instead of generating an removed/added pair. This makes the diff
a lot easier to read.
As-is, winsetup.bat replaces config.h with winconfig.h, which is needed for the MSVC compilation - but breaks all further use of cygwin's make (e.g. to build the class library, or run "make install").
This patch introduces a new cygconfig.h as a backup prior to squashing config.h (if it exists, so the runtime can still be built without cygwin ever being used), and makes winconfig.h use it on non-MSVC compilers (i.e. cygwin)
This patch brings .NET's implementation of the RegularExpressions
stack and brings some of the supporting infrastructure required to
build without resource files.
The build commands have been updated with two new defines to assist in
bringing .NET code: MONO (to indicate that the code is being compiled
as part of Mono) and a more granular DISABLE_CAS_USE that is used to
mark regions where Code Access Security is being used in the source
code, as Mono does not actually ship with a working CAS implementation.
A tools thread is one that can access core runtime structures but not touch anything managed (code or heap).
It's intended to enable the profiler to resolve missing backtraces from its helper thread.
THIS IS A HACK.
The right solution would be to not perform this on the profiler at all and simply log IPs and let the decoder
resolve them. But then there's reality and we can't simply break the current format without consequences.
We're taking this hack for now until we can fix the profiler to do something sensible.
Unhelpfully, winconfig.h is used for building eglib, and it includes a hardcoded VERSION definition which needs to match configure.ac - otherwise msvc builds identify themselves as 2.11
MonoPosixHelper fails to build in my testing, due to config.h bailing the
build out if it doesn't think the build platform is XP SP2 or higher.
Adding this define forces that minimum Windows version, allowing mono.sln
to build fully.
For the opcodes sizeof, mkrefany and refanyval the jit
was resolving the operand tokens directly from the image.
In dynamic scenarios where the tokens are stored in the
wrapper data, this triggered TypeLoadExceptions.
This patch uses mini_get_class, as used everywhere else,
to resolve the operand tokens of those opcodes.
Consider spans and absolute sizes in computing PreferredSize for
TableLayoutPanel.
Also fix bug in allocating unused width to SizeType.Absolute columns.
Change-Id: Ic5065b83ced8195d1c5be39087f33b0d632fc9a6
A previous change (885b065e) accidentally calculated the text size
in some places without padding. This resulted in a slightly to small
text rectangle, causing the text to be truncated.
This property uses the new CMD_STACK_FRAME_GET_DOMAIN command
to retrieve and cache the domain in which the stack frame
is executing.
Bump the protocol version to match the runtime.
When cross compiling with gcc, LIBC is defined and
thus never checks the registry for the timezone information.
This change is released under the MIT license.
The underlying problem for bug 7716 [1] was that the Mono C14N XML
canonicalizer was not sorting the XML attributes in the same order as
Microsoft .NET's canonicalizer.
The C14N specification [2] states: "the attributes are sorted
lexicographically by attribute name (based on Unicode character code
points)." This wording suggests that the order of attributes should be
strictly ascending based on Unicode byte value. This commit changes the
attribute sort order to match the specification.
The new tests pass on Windows, fail on Mono before this change, and
succeed on Mono after this change.
[1] https://bugzilla.xamarin.com/show_bug.cgi?id=7716
[2] http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html
When the VirtualListSize changes, the focus_item_index should
be reset (similar to how it currently resets the selected indices).
If the last item in a ListView has focus and it is removed by
an another action on the form (i.e. push a button to remove the
current item), then the focused_item_index is not updated when
the VirtualListSize changes, even though that item doesn't exist
anymore. When the ListView receives focus again, it tries to
invalidate the current focused item which causes an
ArgumentOutOfRangeException.
The previous value was -2, that could introduce comparison issues.
Added flag MONO_SEQ_POINT_FLAG_EXIT_IL that is used to encode the exit IL, this avoids a 4 byte IL offset delta.
This fixes ~30 ppc-specific failures in mono/tests (e.g., appdomain), like this:
wrong maximal instruction length of instruction atomic_add_i4 (expected 20, got 28)
* Assertion: should not be reached at mini-ppc.c:5235
The commit 51c454f6b0 introduced 2 ppc_sync
instructions in OP_ATOMIC_CAS_I4/8 *and* OP_ATOMIC_ADD_NEW_I4/8 (mini-ppc64.c).
Accordingly, commit 83a34c40c6 updated the maxlength
(+8 bytes) of atomic_cas_i4/8 - *but not* atomic_add_new_i4/8 (cpu-ppc64.md).
Recently, commit b784b866da made atomic_add_new_i4/8
exercised (as 'atomic_add_i4/8') - with an incorrect/non-updated 20-byte maxlength,
which should actually be 28.
Thus:
wrong maximal instruction length of instruction atomic_add_i4 (expected 20, got 28)
Signed-off-by: Mauricio Faria de Oliveira <[email protected]>
The ELFv2 ABI specifies some particular cases for in-register parameter
passing, return values, float/double structs; e.g.,
- small struct returned via registers (2 doublewords)
- homogeneous float struct returned via registers (8 members)
- small float struct passed/returned via FR registers
- return via multiple registers
Author: Bill Seurer <[email protected]>
Origin: https://launchpad.net/ubuntu/+source/mono/3.2.8+dfsg-4ubuntu2
Changes: Mauricio Faria de Oliveira <[email protected]>
Signed-off-by: Mauricio Faria de Oliveira <[email protected]>
After the mechanical exchange of ppc_r11 and ppc_r12 we now can use
ppc_r12 for global calls to hold the callees address without clobbering
r11 (which potentially contains IMT_REG, VTABLE_REG and RGCTX_REG).
We don't need to change all indirect calls, only those potentially reaching
functions containing a TOC setup based on r12 (in particular functions
in shared libs). As the instruction sequence patcher can only deal
with one destination register we also need to make some additional
calls use r12. We probably should convert all calls that currently
use r0 to use r12 if no other conflicts arise but this is enough to build.
Author: Michael Matz <[email protected]>
Origin: https://build.opensuse.org/request/show/225490
Changes: Mauricio Faria de Oliveira <[email protected]>
Signed-off-by: Mauricio Faria de Oliveira <[email protected]>
This is a preliminary patch for ppc64le ELFv2 support. That one requires
r12 to hold a functions address at calls to normal (global) C functions.
As is r12 is also used by mini for its IMT_REG, VTABLE_REG and RGCTX_REG
to pass around values to functions outside the normal argument registers
(ugh!), so there's a conflict. This mechanical (by sed) patch simply switches
ppc_r11 and ppc_r12 everywhere, r11 doesn't have any special use in the ABI.
Author: Michael Matz <[email protected]>
Origin: https://build.opensuse.org/request/show/225490
Changes: Mauricio Faria de Oliveira <[email protected]>
Signed-off-by: Mauricio Faria de Oliveira <[email protected]>
This adds initial support for ppc64le to the ppc64 port. That is:
* little endian aware (also in strtod),
* and ELFv2 aware (not using function descriptors)
* adjust various block sizes to be multiple of 64k, the default
pagesize on ppc64le. The sources should have used the system function
to ensure alignment on pagesize, so this is just a stop-gap
It also corrects the list of registers for the precise GC, but that isn't
used in mini at all on any architecture currently.
Author: Michael Matz <[email protected]>
Origin: https://build.opensuse.org/request/show/225490
Changes: Mauricio Faria de Oliveira <[email protected]>
Signed-off-by: Mauricio Faria de Oliveira <[email protected]>
MonoSeqPointInfo has now a pointer to a buffer containing encoded sequence points, and to a buffer containing next values.
As there is no longer an array of SeqPoint ready to be read, SeqPointIterator was added.
This line enable the ASP Javascript validators in IE9 and upper. the user agent the IE10 is "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)".
We don't update mark bits atomically, so we can't have two threads
marking at the same time, which means we have to stop the concurrent
collector worker thread while we do work in the main GC thread. That
includes nursery collections, because they also touch mark bits.
Also problematic are mod-union updates. The worker threads can add
global remsets, which they do in the main cardtable. This will conflict
with updating the mod-union table, so having the workers stopped also
applies there.
Before we do all the major heap work in the finish mark pause of a
concurrent collection, we perform a nursery collection, for simplicity's
sake.
The nursery collection left pinned objects in the nursery, without
following their references into the major heap, so the major heap work
had to scan those objects again. There was no special provisioning
for this—major mark would do the pinning again, and we would
automatically end up scanning the objects again.
The way we determine the stack end for the GC thread, however,
had the effect of making pinning non-deterministic. We would
conservatively scan part of the GC thread's stack, which was
subject to change, to pinning again might result in less or more
objects pinned.
The proper solution would be to determine the stack end correctly,
but for now we will just the whole nursery.
As mentioned in commit 789517f8, I'm trying to compare inter-API level
differences in Mono.Android.dll, and want to reduce as much
"meaningless noise" as possible -- changes which don't meaningfully
break API or ABI.
Among those "meaningless" changes are the addition of property setters
to properties. Adding a setter doesn't break API or ABI.
Add a `mono-api-html --ignore-changes-property-setters` option.
--ignore-changes-property-setters:
Ignore the addition of property setters.
If a source property contains a getter and the target property
contains both a getter and a setter, do not flag this as a
change.
As mentioned in commit 789517f8, the intentino of
`mono-api-html --ignore-changes-virtual` is so that when a method is
changed from non-virtual to virtual or override, or from virtual to
override, a "Removed member" message isn't triggered.
However, the previous implementation was too lenient. While *adding*
virtual to the method is fine, *removing* is NOT fine, as that would
be an API breaking change (e.g. all classes which attempt to override
a previously virtual method could no longer do so).
Make the virtual check stricter so that virtual/override to
non-virtual changes are not ignored.
I've been trying to review API diffs in Xamarin.Android between API
levels, but the diffs are "noisy" because Google will change parameter
names at-will, or will change a non-virtual method into a virtual
method, or a virtual method into an override, all of which are
acceptable changes but individually generate a Removed line in
mono-api-html output, and manually removing the *hundreds* of changes
is error-prone.
Add two new option flags to mono-api-html:
--ignore-changes-parameter-names:
Ignore changes in constructor and method parameter names.
If parameter names change between <reference.xml> and
<assembly.xml>, don't report a change for the constructor or
method.
--ignore-changes-virtual:
Ignore changes in "virtual-ness".
If a method or property changes from non-virtual to virtual,
non-virtual to override, or virtual to override, don't report a
change for the member.
We change the function to use the lock/validate pattern. This is both
more scalable and enables us to use the image lock, since the amount of
work done with it held is now trivial.
The function mono_method_inflated_lookup no longer needs the loader lock to be held
as the hashtable is now protected by the imageset lock.
This means that mono_class_inflate_generic_method_full_checked doesn't need to take the
loader lock.
The function mono_method_set_generic_container uses mono_image_property_insert which takes
the image lock and not the loader lock. Adjust the locking comment.
This is used for counters that are defined after runtime initialization. It implies that TYPE_SAMPLE_COUNTERS_DESC can now be emitted at any time, and not only once.
The same counter instance would be returned if we use the "instance" parameter instead of the "counter"
parameter. Also it is the name of the counter that is stored in mono_perfcounter_create (mono-perfcounters.c:1488).
Fix the following bug : shared_data_find_room return twice the same memory region because it was not marked as "in use" by setting the header.ftype value.
This bug is triggered when we want to create a new shared area (for example a new FTYPE_INSTANCE area) while creating another area (for example a new FTYPE_CATEGORY).
The structure of the encoded SharedCounter is as follow :
- compressed data type : 1 byte
- index in the category : 1 byte
- name of the counter : null terminated string
- help of the counter : null terminated string
DataGridView keeps track of the first visible row in first_row_index.
DataGridViewRowCollection will notify DataGridView its about to delete 1 or
more rows via OnRowsPreRemovedInternal(). When this happens, we need to
ensure first_row_index will still fall within the number of rows that
will remain after the row removal.
This fixes https://bugzilla.xamarin.com/show_bug.cgi?id=24372 which I
reported.
This is a jumbo commit that addresses multiple issues with statistical backtrace collection:
1) It's not possible to reliably collect MonoMethod* so we check that they exist before
serializing to the .mlpd file and retrieve in sync context.
2) It was reporting the generic instance MonoMethod* under gsharing. Those methods are
not reported to the profiler since they are never compiled. They would turn out as unknowns.
3) Collecting IL offsets from async context is currently impossible to be done safely, so it's
now disabled. The way we'll do it in the future is by serializing the sequence point table when
JIT'ing.
4) The way we used to collect frames in statistical ignored all frames until the first LMF, which
discards a lot of them under statistical mode. We now properly pass sigcontext and have it been consumed.
In the future we should simply use the callchain mode.
When issuing a Clear() to remove all rows, a ReIndex() was being called for
each row that was being removed. This is extremely inefficient, instead
do a single ReIndex() after all rows have been removed.
Before doing a Clear() of 30k rows was taking 5.8 seconds. With this patch
it now takes 670ms.
This is useful in the case of the benchmarking suite because we are only interested in the counters, and they represent a minimal part of the output file size.
+ Fix NRE when source_file or source_file.Usings is null. This will now return back an empty string or empty List
+ **Note** that we are returning the ToString() value of NamespaceExpression which is the full resolved namespace of "System.Drawing" instead of "Drawing".
+ Add ToString override for NamespaceExpression to return the full resolved name of the namespace.
Before this change, those Last*Time properties returned only based on
seconds (truncated), which could cause inaccurate time comparison.
Consider code like this:
var fileUpdated = DateTime.Now;
...
File.WriteAllText (path, "foobar");
...
if (fileUpdated > new UnixFileInfo (path).LastWriteTime)
OnUpdatedFile (path);
This could always result in raising update event, even if there was
no update after writing.
Last*Time With milliseconds makes it very unlikely to happen.
The XML work in 661430fd1f and bf39f5aec0 changed the whitespace handling, so the mdoc test suite failed.
Refreshing the files makes them identical to what MS.NET produces and fixes the mdoc tests.
If we run out of memory during the nursery collection in the finishing collection pause,
there will be late-pinned objects in the nursery: pinned objects that were not pinned
from conservative roots (or cementing). We need to scan those, too, so in that case
we just walk the nursery and scan all objects.
The two collectors stepped on each other's toes. Specifically, updating the mod union
card table while the worker thread might mark cards in the card table will not work.
The simplest solution for now is to stop the worker thread during concurrent updates
and nursery collections. In the future we can have the thread help with the nursery
collection.
Cementing can happen during a concurrent collection when processing
the cardtable. We use a separate cementing hash during concurrent
collections but we didn't pin objects from there.
Reset of adjustment rules is mandatory when the base offset is changed because the rules are relative to the base offset.
Adjustment rules are now kept until the base offset changes.
- merge fix for https://bugzilla.xamarin.com/show_bug.cgi?id=21578
the MulticastOption's 'private IPAddress local' field was
removed by linker and the app crashed later at runtime.
- when System.Net.Sockets.MulticastOption object
is passed to System.Net.Sockets.Socket.SetSocketOption
and thru it to System.Net.Sockets.Socket.SetSocketOption_internal
it accesses passed object fields
(thru few more native calls).
The current signal profiling code depended on invalid linux behavior of setitimer
allowing multiple threads to register for the same timer. Linux kernel 2.6.12 fixed
this and only the main thread gets the signal. Always.
The correct POSIX behavior happens on OSX/iOS.
On Linux we could use timer_create and SIGEV_THREAD_ID but that would not work on iOS/OSX
since it's specific to it. Given that little detail, I'll leave implementing it as an
exercise to the reader.
The solution, which aims to be as portable as possible, is to use a pair of signals and
have the first one fire the second one against all other threads.
We use a pair of signals since it's not well defined which thread will receive the signal
so detecting this from the signal is non-trivial.
Parameter names are part of the ABI because of C#4 named parameter.
Consequently, they *must* be consistent with .NET, and .NET a
parameter name of "errorInfo", *not* "errorInfoPtr" [0]:
public static Exception GetExceptionForHR(
int errorCode,
IntPtr errorInfo
)
Change the parameter name from `errorCodeInfo` to `errorCode` so that
the parameter name is consistent with .NET.
[0]: http://msdn.microsoft.com/en-us/library/3xade62s(v=vs.100).aspx
Extend functionality of SgenPointerQueue.
The purpose of this commit is to avoid dependency between GC code and the obtaining of the hash from the object's synchronisation field, which might require additional processing.
for reading the input stream.
According to the MSDN docs, if ReadEntityBodyMode returns "Classic" the code should use
the old method to read the input stream (HttpRequestBase.InputStream) which is fully
implemented in mono.
Manually applied patch from martinjt
Add Makefile rules to automagically download the TimeZone database
from the Android target $(ADB_TARGET), and build the tzi.exe app.
$ make android-dump-tzdata ADB_TARGET=-d
# downloads timezone data into ./android/tzdb.
# dumps timezone data into ./android/tzdata
# builds ./tzi.exe
# Show adjustment rules for a given timezone dump
$ mono tzi.exe -i=tzdata/Asia/Amman
Add `tzi.exe -R` option to show the TimeZoneInfo.GetAdjustmentRules()
output for all encountered timezones.
Add `tzi.exe -o=PATH` option to dump the TimeZone data to disk for
interrogation.
Add `tzi.exe -i=PATH` option to read in the specified TimeZone data
file and dump the rules contained therein.
Update usage comments.
Makefile defines GC_WIN32_THREADS as 1 but gc_config_macros was
redefining as defined but with no value.
Signed-off-by: Alex J Lennon <[email protected]>
FileSystemWatcher.cs: Fixed multicast events.
SearchPattern.cs : Fixed issue where case insensitivity was not being honored.
KeventWatcher.cs:
* Fixed several race conditions
* Fixed file descriptor duplication & leaks
* thread-safe/cleaner state transitions for watcher, and much cleaner stopping
* Now uses fsw.Filter parameter and respects IncludeSubdirectories = false. Use fsw.Filter to watch very large trees
* Added more error handling + OnError event
* Lots of behavior/reliability fixes and optimizations for Monitor() loop
* Fixed kevent/timespec struct definitions (for 64-bit build)
Reworked a lot of the internals of the kqueue FileSystemWatcher. There
is now a separate thread and a separate kqueue for each FileSystemWatcher
object.
https://bugzilla.xamarin.com/show_bug.cgi?id=16259
Adds a configuration file to facilitate build of Mono with Cygwin
on Appveyor Windows-based build workers.
Dependencies are installed on a clean Appveyor build image for
each build and the result of the 'make install' step is stored
as a build output 'artifact' for further testing or deployment.
Signed-off-by: Alex J Lennon <[email protected]>
Error generated by socket-io.c was:
/usr/i686-pc-mingw32/sys-root/mingw/include/ws2tcpip.h:38:2:
error: #error "ws2tcpip.h is not compatible with winsock.h.
Include winsock2.h instead."
Signed-off-by: Alex J Lennon <[email protected]>
- Ref: https://bugzilla.xamarin.com/show_bug.cgi?id=20048
- Mono currently doesn't support 2-args Socket ctor added in .NET 4.5
- Absence of this ctor prevents KestrelHttpServer (web server for
ASP.NET vNext: https://github.com/aspnet/KestrelHttpServer ) test
code from working
- I hesitated to put IPv4 only implementation, but full dual stack
(IPv4/v6) support would need bunch of works to be done. So, I pinned
supported protocol of new ctor to IPv4. Also, I filed v4/v6 support
issue as a MonoTODO entry inside the source code.
- Don't subtract room for ellipsis. Ellipsis should be
handled by the renderer so we shouldn't reserve space for it.
Otherwise we end up not getting ellipsis (because the renderer
thinks there is enough space available), or we don't use up the
available space.
- Don't allow text to go below button if we want to show ellipsis.
When a button is pressed the image and the text needs to be rendered one
pixel to the right and to the bottom so that there is some visual
feedback of the button press. Previously this was only the case if
TextImageRelation was set to Overlay.
On Mono/.NET, TimeZoneInfo.Local has a TimeZoneInfo.Id value of
"Local" and a TimeZoneInfo.DisplayName value of "Local":
$ csharp
csharp> TimeZoneInfo.Local.Id;
"Local"
csharp> TimeZoneInfo.Local.DisplayName;
"Local"
That isn't the case on Xamarin.Android, which returns the timezoneinfo
ID value from both DisplayName and Id, e.g. TimeZoneInfo.Local could
have Id and DisplayName values of "Australia/Sydney".
Rework things so that the TimeZoneInfo.Id and TimeZoneInfo.DisplayName
properties return "Local" on Xamarin.Android for the instance returned
from TimeZoneInfo.Local, just like normal Mono/.NET does.
NUnit breaks when these URI's are treated as UNC paths, so I have no way of
running the tests on Windows without this change to see if it broke anything.
Not all URI tests pass, but the ones that fail seem unrelated to my change.
On Unix, the tests all work, but of course on Unix this is a no-op.
This commit licensed as MIT/X11.
The issue was with the new heuristic of the thread pool which would not create new threads, leading to deadlock between dependent tasks.
The fix is to check if every worker threads are sleeping, waiting or joining, and if that's the case, then we create a new thread because we might be in the case where the tasks being currently run depends on one still being enqueued in the cq or one of the wsq.
The following tests would previously fail :
1) MonoTests.System.Threading.Tasks.TaskTests.DoubleWaitTest : #1
Expected: True
But was: False
at MonoTests.System.Threading.Tasks.TaskTests.<DoubleWaitTest>m__27 () [0x00077] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:800
at MonoTests.System.Threading.Tasks.ParallelTestHelper.Repeat (System.Action action, Int32 numRun) [0x00007] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/ParallelTestHelper.cs:48
at MonoTests.System.Threading.Tasks.TaskTests.DoubleWaitTest () [0x00000] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:790
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
2) MonoTests.System.Threading.Tasks.TaskTests.HideSchedulerTest : #1
Expected: True
But was: False
at MonoTests.System.Threading.Tasks.TaskTests.HideSchedulerTest () [0x0003d] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:1914
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
3) MonoTests.System.Threading.Tasks.TaskTests.WaitAll_TimeoutWithExceptionsAfter : #1
Expected: True
But was: False
at MonoTests.System.Threading.Tasks.TaskTests.WaitAll_TimeoutWithExceptionsAfter () [0x00070] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:317
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
4) MonoTests.System.Threading.Tasks.TaskTests.WaitAll_TimeoutWithExceptionsBefore : #1
Expected: True
But was: False
at MonoTests.System.Threading.Tasks.TaskTests.WaitAll_TimeoutWithExceptionsBefore () [0x00070] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:341
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
5) MonoTests.System.Threading.Tasks.TaskTests.WaitAnyTest : #3
Expected: not -1
But was: -1
at MonoTests.System.Threading.Tasks.TaskTests.<WaitAnyTest>m__0 () [0x00026] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:142
at MonoTests.System.Threading.Tasks.ParallelTestHelper.Repeat (System.Action action, Int32 numRun) [0x00007] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/ParallelTestHelper.cs:48
at MonoTests.System.Threading.Tasks.ParallelTestHelper.Repeat (System.Action action) [0x00000] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/ParallelTestHelper.cs:42
at MonoTests.System.Threading.Tasks.TaskTests.WaitAnyTest () [0x00000] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:128
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
6) MonoTests.System.Threading.Tasks.TaskTests.WaitChildTestCase : #0b
Expected: True
But was: False
at MonoTests.System.Threading.Tasks.TaskTests.<WaitChildTestCase>m__25 () [0x0006d] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:705
at MonoTests.System.Threading.Tasks.ParallelTestHelper.Repeat (System.Action action, Int32 numRun) [0x00007] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/ParallelTestHelper.cs:48
at MonoTests.System.Threading.Tasks.TaskTests.WaitChildTestCase () [0x00000] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:684
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
7) MonoTests.System.Threading.Tasks.TaskTests.WaitingForChildrenToComplete : #3
Expected: True
But was: False
at MonoTests.System.Threading.Tasks.TaskTests.WaitingForChildrenToComplete () [0x00048] in /Users/ludovic/Xamarin/mono/mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs:734
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 /Users/ludovic/Xamarin/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:230
The internal allocator used size segregated blocks which were always
16k large. Since we have quite a few different size classes this led
to a lot of allocation even for very small programs.
We now use block sizes that are determined by the slot size and are as
small as possible. They're power-of-two multiples of the page size,
so we end up with blocks of 4k, 8k and 16k.
The formula for calculating allowance was not only overly complicated
but completely broken, which resulted in the allowance always being the
minimum (4 times the nursery size). That resulted in too frequent garbage
collections when the heap grew larger.
Now we do something very similar to what Boehm does: Allow the heap
to grow by a third before the next major collection happens.
This is especially relevant if we have to shrink the width because of
padding. In this case it is possible that MeasureString calculated that
the string would fit in one line, but because of padding we reduce the
width. If the button is large enough we want to display additional lines
even if MeasureString told us we only need one line.
pid_t (used at line 216) is available on Linux in `unistd.h` and so on on FreeBSD (`sys/types.h` to be precise, included in `unistd.h`), yet on FreeBSD this header is not automatically included.
Unless running in on-demand AOT mode, the AOT runtime will look for an AOT cache alongside the assembly (e.g. /usr/lib/mono/4.5/mscorlib.dll.so).
This patch adds a second search path to the non-on-demand AOT loader, /usr/lib/mono/aot-cache/ARCHITECTURE/path/to/assembly.dll.so
This new structure makes it possible to have more than one Mono architecture on a system, sharing assemblies but not sharing AOT caches (for example, i386 and amd64 Mono on the same system, for different needs)
Because the monitor thread was not marked as background thread, remove_and_abort_threads (threads.c:2807) would mark it as needed to be waited to shutdown the runtime, and wait_for_tids (threads.c:2652) would then wait indefinitely for it to finish. The issue was that the monitor was waiting on the semaphore monitor_sem, and thus would never exit.
Thread 7 (Thread 0x1c13 of process 99776):
#0 0x00007fff86590a56 in ?? () from /usr/lib/system/libsystem_kernel.dylib
#1 0x00000001003cc03a in mono_sem_wait (sem=0x1004f7f50, alertable=0) at mono-semaphore.c:103
#2 0x00000001002cef41 in monitor_thread (unused=0x0) at threadpool.c:898
#3 0x00000001002cb78f in start_wrapper_internal (data=0x10500abf0) at threads.c:657
#4 0x00000001002cb4a1 in start_wrapper (data=0x10500abf0) at threads.c:704
#5 0x00000001003d61d4 in inner_start_thread (arg=0x7fff5fbfe500) at mono-threads-posix.c:84
#6 0x00007fff8e7c9899 in _pthread_body () from /usr/lib/system/libsystem_pthread.dylib
#7 0x00007fff8e7c972a in _pthread_start () from /usr/lib/system/libsystem_pthread.dylib
#8 0x00007fff8e7cdfc9 in thread_start () from /usr/lib/system/libsystem_pthread.dylib
#9 0x0000000000000000 in ?? ()
Thread 1 (Thread 0x1503 of process 99776):
#0 0x00007fff86594716 in ?? () from /usr/lib/system/libsystem_kernel.dylib
#1 0x00007fff8e7cbc3b in _pthread_cond_wait () from /usr/lib/system/libsystem_pthread.dylib
#2 0x000000010039cfaa in _wapi_handle_timedwait_signal_handle (handle=0xa55, timeout=0x0, alertable=1, poll=0) at handles.c:1595
#3 0x000000010039d03d in _wapi_handle_wait_signal_handle (handle=0xa55, alertable=1) at handles.c:1540
#4 0x00000001003b7ba3 in WaitForSingleObjectEx (handle=0xa55, timeout=4294967295, alertable=1) at wait.c:194
#5 0x00000001003b865d in WaitForMultipleObjectsEx (numobjects=1, handles=0x7fff5fbff1f8, waitall=1, timeout=4294967295, alertable=1) at wait.c:516
#6 0x00000001002c75df in wait_for_tids (wait=0x7fff5fbff1f8, timeout=4294967295) at threads.c:2658
#7 0x00000001002c70e5 in mono_thread_manage () at threads.c:2951
#8 0x00000001000d551b in mono_main (argc=6, argv=0x7fff5fbff9e8) at driver.c:2021
#9 0x0000000100001bd1 in mono_main_with_options (argc=6, argv=0x7fff5fbff9e8) at ./main.c:91
#10 0x00000001000017d3 in main (argc=6, argv=0x7fff5fbff9e8) at ./main.c:122
Thanks @akoeplinger for the help debugging
Because the monitor thread was not marked as background thread, remove_and_abort_threads (threads.c:2807) would mark it as needed to be waited to shutdown the runtime, and wait_for_tids (threads.c:2652) would then wait indefinitely for it to finish. The issue was that the monitor was waiting on the semaphore monitor_sem, and thus would never exit.
Thread 7 (Thread 0x1c13 of process 99776):
#0 0x00007fff86590a56 in ?? () from /usr/lib/system/libsystem_kernel.dylib
#1 0x00000001003cc03a in mono_sem_wait (sem=0x1004f7f50, alertable=0) at mono-semaphore.c:103
#2 0x00000001002cef41 in monitor_thread (unused=0x0) at threadpool.c:898
#3 0x00000001002cb78f in start_wrapper_internal (data=0x10500abf0) at threads.c:657
#4 0x00000001002cb4a1 in start_wrapper (data=0x10500abf0) at threads.c:704
#5 0x00000001003d61d4 in inner_start_thread (arg=0x7fff5fbfe500) at mono-threads-posix.c:84
#6 0x00007fff8e7c9899 in _pthread_body () from /usr/lib/system/libsystem_pthread.dylib
#7 0x00007fff8e7c972a in _pthread_start () from /usr/lib/system/libsystem_pthread.dylib
#8 0x00007fff8e7cdfc9 in thread_start () from /usr/lib/system/libsystem_pthread.dylib
#9 0x0000000000000000 in ?? ()
Thread 1 (Thread 0x1503 of process 99776):
#0 0x00007fff86594716 in ?? () from /usr/lib/system/libsystem_kernel.dylib
#1 0x00007fff8e7cbc3b in _pthread_cond_wait () from /usr/lib/system/libsystem_pthread.dylib
#2 0x000000010039cfaa in _wapi_handle_timedwait_signal_handle (handle=0xa55, timeout=0x0, alertable=1, poll=0) at handles.c:1595
#3 0x000000010039d03d in _wapi_handle_wait_signal_handle (handle=0xa55, alertable=1) at handles.c:1540
#4 0x00000001003b7ba3 in WaitForSingleObjectEx (handle=0xa55, timeout=4294967295, alertable=1) at wait.c:194
#5 0x00000001003b865d in WaitForMultipleObjectsEx (numobjects=1, handles=0x7fff5fbff1f8, waitall=1, timeout=4294967295, alertable=1) at wait.c:516
#6 0x00000001002c75df in wait_for_tids (wait=0x7fff5fbff1f8, timeout=4294967295) at threads.c:2658
#7 0x00000001002c70e5 in mono_thread_manage () at threads.c:2951
#8 0x00000001000d551b in mono_main (argc=6, argv=0x7fff5fbff9e8) at driver.c:2021
#9 0x0000000100001bd1 in mono_main_with_options (argc=6, argv=0x7fff5fbff9e8) at ./main.c:91
#10 0x00000001000017d3 in main (argc=6, argv=0x7fff5fbff9e8) at ./main.c:122
Commit 5564dad1 broke the self-test (for testing on the developer
machine, not an Android target). Fixup the comment so that appropriate
data is grabbed and used for testing, and improve
AndroidTimeZones.GetDefaultTimeZoneName() so that the default timezone
ID can be specified via the __XA_OVERRIDE_TIMEZONE_ID__ environment
variable for testing.
Finally, demonstrate TimeZoneInfo.GetUtcOffset(DateTime) use so that I
can get better insight into the timezone data stored within the
database:
$ __XA_OVERRIDE_TIMEZONE_ID__=America/New_York ANDROID_ROOT=`pwd` ANDROID_DATA=`pwd` mono --debug tzi.exe --offset=1969-01-01
Using DateTime Offset: 1/1/1969 12:00:00 AM
DB type: System.AndroidTzData
name=Africa/Abidjan Africa/Abidjan From Offset: 00:00:00
name=Africa/Accra Africa/Accra From Offset: 00:00:00
name=Africa/Addis_Ababa Africa/Addis_Ababa From Offset: 03:00:00
...
This fixes a problem with calculating the text width of a button
which caused the text to get truncated under certain circumstances
instead of being wrapped. This fixes Xamarin-23168.
Change-Id: Iac0d8a2720a99cf5433e05d5123a04c4b019e493
The test changes TZ environment variable and compares DateTime.Now with system date.
The test checks all the timezones installed in /usr/share/zoneinfo/.
The change does not have a negative impact on StringBuilder performance; under variable-string-length microbenchmarks it seems to perform ~15-20% faster than the managed implementation.
Use the new MONO_GC_DEBUG option "nursery-canaries" to suffix each nursery object with a canary (guard) word, which is checked on each minor collection. Can be used to detect/debug
heap corruption issues.
Adding canaries to LOS is also easy if wanted - not sure about major heap.
In some cases the timezone transitions provided by iOS are not convertible to AdjustmentRules because of changes on the base offset.
Now we store the transitions so they can be used instead of an incomplete list of AdjustmentRules.
Depending on alignment and packing, part of the string might be inside the MonoString struct boundaries. This e.g. shows up on 64-bit builds of mono where we were allocating 4 extra bytes per string.
We were spending a lot of time in major_iterate_live_block_ranges() on
the lcscbench benchmark, mainly from following the linked block list.
This change makes it much faster.
We trim the free list of the gray queue to a maximum number of
sections, but we did it at each collection start, so the extraneous
sections were kept around between collections.
At the point where we enqueue objects we have already fetched their
descriptors, and when we later scan them (after dequeuing) we need the
descriptor again, so we avoid cache misses by enqueuing them together.
Later on, when we enqueue objects with their GC descriptors, we won't
load the vtable before scanning (because we'll already have the
descriptor), so the scanning macros shouldn't take them as arguments.
It's not well-tested, not widely used, we can surpass its speed with
upcoming improvements and we won't put those into the fixed
configuration because it's too much of a diversion.
Before the change when the property default value was not null or empty the deserialized value would be the concatenation of the default value and the serialized value.
The correct behavior is to use the serialized value only.
Fixes 18908.
To resolve casting we make all relevant interfaces to use the generic variance casting code.
This only affected ICollection`1 and IList`1, which are not terribly popular.
To fix dispatch we augment vtable resolution to treat those interfaces as variant and use
the already in place machinery.
Memory reduction numbers for the corlib test suite:
Initialized classes 8004 -> 7470 (7% reduction)
Corlib mempool size: 2719832 -> 2678872 (1.5% reduction)
Inflated classes 4500: 3.972 (12% reduction)
Inflated signatures size: 166128 -> 139812 (16% reduction)
Inflated methods size: 565152 -> 485664 (15$ reduction)
https://bugzilla.xamarin.com/show_bug.cgi?id=18411
If a class explicitly implements an internal interface, those members will no
longer be documented, nor will the interface show up in the class' signature.
This allows for a library to hide internal implementation details that an end
user would not be able to take advantage of (ie. can't cast to internal
interface to call methods).
Includes test (check-monodocer-internal-interface) added to makefile.
This should fix c30a3e46d2 failing to link properly with ld 2.22 and GCC 4.9.1, on Linux, with non-LLVM builds.
./.libs/libmini.a(libmini_la-mini.o): In function `llvm_init_inner':
mini.c:(.text+0x1182b): undefined reference to `mono_llvm_init'
/usr/bin/ld: .libs/libmonoboehm-2.0.so.1.0.0: hidden symbol `mono_llvm_init' isn't defined
/usr/bin/ld: final link failed: Bad value
- Tds.cs: Use SecureString objects for passwords; Add method to retrieve string from SecureString
- Tds42.cs: Use SecureString for passwords
- Tds50.cs: Use SecureString for passwords
- Tds70.cs: Use SecureString for passwords
- TdsConnectionParameters.cs: Use SecureString for passwords; Initialize Password parameter as cleared string; Add indicator for when password is set
- SqlConnection.cs: Use SecureString for passwords; Add SqlConnect method that accepts an SqlCredential along with the Connection string; Perform checking of parameters to ensure user/password not specified in connection string if credentials have been specified or using credentials when domain login is specified.
- SqlCredential.cs: Add new class with support for credentials
- System.Data.dll.sources: Add SqlCredential.cs to the build list
[02131] CC libmonoruntimesgen_la-sgen-marksweep.lo
[02131] In file included from sgen-major-copy-object.h:35:0,
[02131] from sgen-marksweep.c:1128:
[02131] sgen-copy-object.h:38:1: warning: always_inline function might not be inlinable [-Wattributes]
[02131] par_copy_object_no_checks (char *destination, MonoVTable *vt, void *obj, mword objsize, SgenGrayQueue *queue)
[02131] ^
[02131] sgen-marksweep.c: In function 'par_copy_object_no_checks':
[02131] sgen-copy-object.h:38:1: error: function 'par_copy_object_no_checks' can never be copied because it saves address of local label in a static variable
[02131] make[3]: *** [libmonoruntimesgen_la-sgen-marksweep.lo] Error 1
[02131] make[3]: Leaving directory `/root/rpmbuild/BUILD/mono-3.10.1/mono/metadata'
[02131] make[2]: *** [all-recursive] Error 1
[02131] make[2]: Leaving directory `/root/rpmbuild/BUILD/mono-3.10.1/mono'
[02131] make[1]: *** [all-recursive] Error 1
[02131] make[1]: Leaving directory `/root/rpmbuild/BUILD/mono-3.10.1'
[02131] make: *** [all] Error 2
[02131] error: Bad exit status from /var/tmp/rpm-tmp.YxcUOE (%build)
Kpp.Load() will throw an unhandled exception if _filename (a folder to use as the key store) does not exist and it cannot be created.
This is an entirely valid thing to have happen - cert importing into the machine store (mozroots --import --machine --sync) as root will create a /usr/share/.mono/certs/ folder, but will not create /usr/share/.mono/keypairs - and since the root user owns /usr/share/.mono/, if the user tries to enumerate the certificates in /usr/share/.mono/certs/, they get 0 certificates returned due to the unhandled exception dropping each loaded certificate on the floor.
Closes: Xamarin bug 23015
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=23077
Reverts commit 53ce92470.
Commit 53ce92470 disabled use of statfs(2) on Android, for unspecified
reasons. (My *suspicion* is that the Android version mono was
originally ported to didn't have statfs(2), but I can neither confirm
nor deny that guess.)
Android has supported statfs(2) since API-4 Android v1.6 (in that
statfs(2) is in the header files); what's missing is MNT_RDONLY. What
IS present is MS_RDONLY, which appears to serve the same purpose.
Re-enable use of statfs(2) and use MS_RDONLY when building against the
Android NDK.
This fixes the command to check for dos2unix and makes mkbundle usable again with mingw.
We need first to redirect the standard input, otherwise the check always fails with an InvalidOperationException and set CreateNoWindow=false to avoid spawning a new window.
The problem already starts when creating the OperationDescription; we need
to also look at the End* method here to correctly parse the reply parameters.
Then ClientRuntimeChannel.Process needs to distinguish between sync/async
and copy the out/byref parameters when needed.
SerializationCodeGenerator and XmlSerializationWriterInterpreter will no longer serialize an attribute named {V} if its object has a method named ShouldSerialize{V}() that returns false.
{V}Specified now is also checked to be true before serializating the attribute even if it is a property that is not settable.
Fixes#1852.
{V}Specified is a property or field and ShouldSerialize{V} is a method that can be set to false if we do not want to serialize an attribute with name {V}.
Based on pull request feedback, this is a simpler usage, and meets our required use-case. A sample version of this parameter would be: `--dropns MyUnifiedAssembly=MyDroppedPrefix`
We take the loader and the root domain locks before doing a thread dump. This reduces the odds
of us suspending a thread that holds either of them and deadlocking, for example, while decoding
AOT JIs.
Users have been complaining about strange errors arising when using the OracleClient classes.
I have tracked it down to the OciDefineHandle and OciDefineByPos calls, and OracleParameter
handling of amanged objects by unmanaged code. Currently two of the parameters passed to the
above OCI call are short variables. They are passed as "ref" fields as Oracle uses their
address to put size and indicator data once the data is fetched. However, being defined as
short means that they are eligible for being moved during garbage collection. Thus if that
field is moved between the OciDefineByPos call and the fetch of the data then what Oracle is
pointing to may no longer be variable. I'm thinking it may be better to define these fields as
IntPtr and allocate them and retrieve their values via Marshal.ReadInt16. As for OracleParameter,
it uses a managed object "indicator" that is also used in a similar way. This reference is replaced
by a IntPtr and a get/set method to access the contents.
iOS 8 GM lists "Asia/Chita" among its time zones, but when requesting
the time zone data for that time zone, no data is returned.
With this change we ignore time zones without any data when fetching
all the timezones on the system.
In some cases fixed_from_dmy is used with the month parameter greater than the number of months of that year.
Year is now incremented until month parameter is valid.
The changes from 3408b8e5f1 cause
regressions in distros which do not use lib as folder for
arch-specific libraries, like Fedora x86_64.
Instead, reloc_libdir should be used (as in data/mono.pc.in).
This change is released under the MIT/X11 license.
We observed on multiples benchmarks that most internal allocations are for 8, 16, 296 (32bits), 328 (64bits), 504 (32bits) and 1016 (64bits) bytes of memory. To minimize waste, we added these memory sizes to the default allocator sizes.
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.
When loading assemblies, we must ensure that a basedir is provided otherwise
things like custom attributes and Type.GetType won't be able to load sibling
assemblies when basedir is not the same of the domain.
The compiler seems to ignore reference assemblies with a full path when the
-lib: directive is passed, so things like:
-lib:FOO -r:BAR/bar.dll
Would resolve bar.dll to FOO/bar.dll, instead of BAR/bar.dll.
This is a problem with the test suite as it needs to reference the
final build of System.Configuration from $(the_libdir_base) and not
the intermediate step.
To work around this issue, we introduce "test_remove" variable that is
a piece of text that will be removed from the TEST_COMPILE variable
when this is evaluated.
This means that it gets CSCOMPILE and then it removes the bits that we
are not interested in.
Now a solution turns into a project with "BuildingSolutionFile" property
which is assigned by SolutionParser and subsequently gets _ExplicitReference
that is to store path to mscorlib.dll and thence projects build.
Issue: The previous code, with new tests [1], failed when the linker was
enabled.
That was caused because the code looks for the Keys and Item properties
getter using reflection. The linker handled that imperfectly (it left
some holes), in part because:
* System.Collections.Generic.IDictionary`2 does not implement
System.Collections.IDictionary; and
* It preserved the explicit methods - not the implicit one that were
used the the reflection-based code;
That later fact is also a bug (without the linker involvment) and solved
by this commit. A unit test was added to show the issue (NRE).
The patch also avoid the use of reflection for IDictionary since we can
simply typecast to get the same result (without the additional cost).
Also simplify the code a little bit, there's no need to have separate
code paths for ARM64, since using the correct objc_msgSend signature
works on all architectures.
MonoJenkins repeatedly complains about:
mono-counters.c:xxx:1: warning: function declaration isn't a prototype
[-Wstrict-prototypes]
This is caused by the missing declaration of the function arguments.
This change is released under the MIT license.
This silences the following gcc/clang warnings from MonoJenkins:
sgen-tarjan-bridge.c:395:2: warning: ISO C90 forbids mixed declarations and code
proflog.c:1942:2: warning: ISO C90 forbids mixed declarations and code
proflog.c:1999:3: warning: ISO C90 forbids mixed declarations and code
decode.c:2409:6: warning: ISO C90 forbids mixed declarations and code
decode.c:2433:6: warning: ISO C90 forbids mixed declarations and code
Moving the declarations to the beginning of the blocks is sufficient
to silence the warnings.
This change is released under the MIT license.
Visual C++ does not support intermixed declarations and code and
errors out with:
error C2275: 'guint' : illegal use of this type as an expression
This also silences gcc/clang warnings such as:
mono-counters.c:xxx:3: warning: ISO C90 forbids mixing declarations
and code
In this case this can be fixed easily by skipping the intermediate
variable.
Based on pull request #1043 by J-M <[email protected]>
This change is released under the MIT license.
Currently the flag is passed on the command line, but this is
problematic for us since our xbuild implementation does not seem to support
the attribute that generates the /keyfile: argument
The use case for this function compared to the one that take MonoClass/MonoImage is for lookups
and the failed names are usually freshly alloc'd.
Fix a leak in class.c usage of mono_error_set_type_load_name.
Remove all internal usages of mono_custom_attrs_construct and replace with mono_custom_attrs_construct_by_type
that takes a MonoError.
Introduce mono_custom_attrs_get_attr_checked and replace usage of the old one where it's needed.
The LOCAL_MCS_FLAGS are passed to the compiler before the standard
directory for the profile. This is important both for correctness,
and also assists the solution generator, since we can now precisely
determine which intermediate project must be referenced.
Fixes: https://bugzilla.xamarin.com/show_bug.cgi?id=19991
The original Mono.Unix.Native.Errno design used the Linux <errno.h>
constants and values...largely because it was easy.
As it turns out, this is also incomplete. The getxattr(2) defines
ENOATTR as a possible error code. On Linux, ENOATTR is an alias for
ENODATA [0]. On OS X, ENOATTR is _not_ an alias. Furthermore, since
ENOATTR is not a Linux errno value (it's an alias!),
Mono_Posix_ToErrno() couldn't check for the native ENOATTR value, so a
Syscall.GetLastError() call after a failing Syscall.getxattr() would
fail with a System.ArgumentOutOfRangeException:
$ csharp -r:Mono.Posix.dll
Mono C# Shell, type "help;" for help
Enter statements below.
csharp> using Mono.Unix.Native;
csharp> byte[] value;
csharp> Syscall.getxattr(".", "test", out value);
-1
csharp> Syscall.GetLastError();
System.ArgumentOutOfRangeException: Current platform doesn't support this value.
Parameter name: value
93
at Mono.Unix.Native.NativeConvert.ThrowArgumentException (System.Object value) [0x00000] in <filename unknown>:0
at Mono.Unix.Native.NativeConvert.ToErrno (Int32 value) [0x00000] in <filename unknown>:0
at Mono.Unix.Native.Stdlib.GetLastError () [0x00000] in <filename unknown>:0
The fix is to add an Errno.ENOATTR field [1].
The complication is one of what enum value to use: at present, the
Errno values are based on the Linux values. In the case of ENOATTR
(and others), there is no Linux value. Meanwhile, there is the
possibility of additional Linux error values; how do we future proof
ourselves?
This isn't a perfect solution, but it should punt the problem down the
road a bit: Errno is an `int` enum, and thus has large range. To
support the OS X values, we add 1000 to the OS X error value.
/* OS X: <errno.h> */
#define ENOATTR 93 /* Attribute not found */
// C# Errno enum:
public enum Errno : int {
// ...
ENOATTR = 1093,
}
This gives us 0..1000 for POSIX+Linux error codes, 1000..2000 for OS X
specific error codes, and as new platforms require additional support
they can all start at multiples of 1000.
Hopefully no single *nix platform will add more than 1000 error codes...
[0]: http://linux.die.net/man/2/getxattr
[1]: Related part of the fix: add all the OTHER <errno.h> values that
OS X includes but weren't included in the Errno enum.
From Dick Porter:
The IPv6 address parser misses some syntax errors, and can become confused by
addresses that at first glance look IPv4 compatible. The attach patch contains
the following fixes:
Don't fail to parse an address if we mistakenly thought it was IPv4 compatible
or mapped, just treat it as IPv6.
Fix IPv4-compatible and mapped address formatting in ToString().
Fix parsing of colons - specifically occurrences of ':::'.
Make sure blocks of digits are no longer than 4 characters.
Add some more parsing tests to Mono's NUnit test suite.
Add a NUnit test for bogus IPv6 addresses.
- ITaskFactory could return null, so check the return value.
- UsingTask descendants could have property references, so use ExpandString.
- TaskBody was not appropriately passed to internal structure.
And since the code is almost the same as existing ProjectInstance one, just
make it identical. (Should be unified, but depends on members, hence TODO.)
This reverts commit 3f7ad8f457.
WebProxy.BypassProxyOnLocal is really broken! There seems to be no
way of actually bypassing a proxy on local connections.
When libgdiplus is configured as sibling, it is available in the
libgdiplus_loc path. This path was added to runtime/mono/config, but
it was later overridden by the prefix-based path.
Using the same approach as for libMonoPosixHelper fixed the lookup of
the library (performed, for example, when testing
MonoTests.System.Drawing without installing libgdiplus).
This change is released under the MIT license.
When compiling mono with icc (ICC) 14.0.0 20130728 the build fails on
CC libmonoruntimesgen_la-sgen-stw.lo
with the following error:
Assembler messages:
Error: suffix or operands invalid for `lea'
Apparently icc (or the assembler) dislikes the rip-based LEA
operation. This can be worked around by manually assembling the
instruction and replacing it with the corresponding byte sequence.
This change is released under the MIT license.
So, it seems that where MSBuildExtensionsPath* is evaluated should be likely
evaluated multiple times, and find actually matching files in one of those.
F# build .targets file expects that.
Since it is almost impossible to assume in which usage scenario it is going
to be evaluated multiple times (those properties can be used anywhere by
simple $(...) syntax), it limits the attempts only for Import() so far.
Old xbuild actually does so too. That way, the particular F# issue is fixed.
Added local targets (csproj-local) to all the assemblies that have
staged builds to dump their build information for the underlying
dependencies.
This information is needed to create the new Visual Studio csproj
files.
This commit also updates the collected build metadata from running:
make update-csproj
make package-inputs
As described in msvc/scripts/README
To be precise, now the implementation returns ItemSpec for ToString().
WriteLinesIntoFile task writes ITaskItem[] lines into a file, without calling
ItemSpec.
Maybe it is better to fix Tasks.dll but I'm unsure about xbuild compatibility.
This missing ToString() override caused target framework monikor output
to become invalid source file (i.e. it used to write ItemSpec as code(!) but
this ITaskItem impl. in BuildEngine4 just wrote its type name as .ToString()
result).
We must use the secxml library directory to reference System, not
bare.
The bare build does not contain a full signature for some interfaces
(there is a using XmlNode = object in a few interfaces that
System.Configuration depends on).
So System.Configuration must reference the System that has been
compiled with XML support.
The parallelization is done by overriding the default "all" target
and instead of using the serial subdirectory processing that goes
over the SUBDIR and xx_SUBDIR rules, we turn the list of
subdirectories into the name of the target, for example:
System.Collections.Concurrent
becomes:
../../class/lib/net_4_5/Facades/System.Collections.Concurrent.dll
Then a pattern is added to handle that rule:
$(target_dir)/%.dll:
This allows the build to be parallized.
This patch introduces an infrastructure to stage the builds for the core
assemblies that have cyclic dependencies. This deals directly with
the following cycle:
System.dll requires:
System.Configuration.dll
Mono.Security.dll
System.Xml.dll
They all require System.dll to be built
System.Xml requires:
System.dll
System.Configuration.dll
System.Security.dll requires:
System.dll
Mono.Security.dll
System.Xml.dll
Principle
=========
The patch works by directing the build infrastructure to place
intermediate build steps on their own directory. For example the
first System.dll build that only takes a dependency in mscorlib.dll is
placed not under the final directory but on a subdirectory called
"bare".
The second time that System.dll is built (after Mono.Security and
System.Xml have been built) is placed on the "secxml" directory.
The third time is the final build, and that one ends in the profile
directory.
The same principle is applied to System.Xml.
Better Dependency Tracking
==========================
To handle the multiple stages, the new Makefiles for the various
parties involved in this loop are now able to build their
dependencies. This means that typing "make" on System.Security or
System.Xml or System will build all of the intermediate steps as
required, without needing the toplevel Makefile to perform multiple
build shots to incrementally build the result.
Bug fixes
=========
We must have regressed at some point the build of System.Xml as we
were only doing one build of it, one without System.Configuration
support. This patch introduces back the changes to build System.Xml
in two steps.
This patch fixes the setup where we end up rebuilding System.dll and
overwriting it two times as the build progresses as a side effect
(this is what required LIBRARY_USE_INTERMEDIATE_FILE).
Details
=======
library.make:
Introduces a new "the_libdir_base" which is the raw directory
where the final output will go. This points to the same location
that libdir_base previously pointed to.
The existing libdir_base is modified to contain an optional
"intermediate" directory, where intermediate builds can be
placed.
The Screen.FromRectangle method was too simple minded. It did not try to
find the best match for a screen when the system has more than one screen.
The new implementation makes at least some effort to find the closest
screen with the most overlap with the rectangle.
The number of displays and sizes can be retrieved with the help of
libXinerama. The implementation was done in a way that is backwards
compatible, so on non-Linux systems or when libXinerama is not
available the behavior will be the same as before.
Also fixed the implementation of FormStartPosition.CenterScreen to
bring up the form centered on the current display (with the current
display being either the screen the top left corner of the owner
form is on, or if there is no owner the screen that has the mouse
pointer). This fixes Novell bug #325669 on Linux
(https://bugzilla.novell.com/show_bug.cgi?id=325669).
We now have a pair of functions to match mono_thread_info_safe_suspend_sync.
They should be used instead of mono_thread_resume as they do the right thing
WRT to hazard pointers.
mono_thread_info_lookup leaves the current value on hazard pointer 1,
so all callers must clean it afterwards. This was not done in all cases
by mono_thread_info_resume.
This function was called from code that uses hazard pointers, so their values could get overridden.
Besides that, we did not clean up the hazard pointer table afterwards, which is wrong too.
Right now all the input parameters are computed based on string, and any
metadata items are simply chopped out when it is passed to a Task.
To fix this, we need to replace ExpandString() use with more complicated
evaluator that takes ITaskItem into consideration.
(It is not complete as of now; evaluation method needs to be replaced and
any regressions need to be fixed.)
(Reported by directhex on #mono 2014-05-14 at 14:28 EDT.)
When importing Microsoft XML Documentation, if a //altmember/@name,
//exception/@name, or //permission/@name attribute is encountered then
mdoc will die with a NullReferenceException:
mdoc: System.NullReferenceException: Object reference not set to an instance of an object
at Mono.Documentation.MsxdocDocumentationImporter.ImportDocumentation (Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.MakeDocNode (Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.UpdateMember (Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.MakeMember (System.Xml.XmlDocument doc, Mono.Documentation.DocsNodeInfo info)
at Mono.Documentation.MDocUpdater.DoUpdateType2 (System.String message, System.Xml.XmlDocument basefile, Mono.Cecil.TypeDefinition type, System.String output, Boolean insertSince)
at Mono.Documentation.MDocUpdater.StubType (Mono.Cecil.TypeDefinition type, System.String output)
at Mono.Documentation.MDocUpdater.DoUpdateType (Mono.Cecil.TypeDefinition type, System.String basepath, System.String dest)
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)
at Mono.Documentation.MDocUpdater.DoUpdateAssemblies (System.String source, System.String dest)
at Mono.Documentation.MDocUpdater.Run (IEnumerable`1 args)
at Mono.Documentation.MDoc.Run (System.String[] args)
at Mono.Documentation.MDoc.Main (System.String[] args)
The cause of the NullReferenceException is due to inconsistent
checking: we check that _either_ `child.Attributes["cref"]` OR
`child.Attributes["name"]` is not null, and if one of them IS non-null
then we just grab `child.Attributes["cref"].Value`, which will throw a
NullReferenceException if the @name attribute was present but not the
@cref attribute.
The fix is to be consistent: once we grab an XmlAttribute, use the
already looked up XmlAttribute, don't re-look it up.
For a variety of reasons, we need to bump the assembly version of
System.Net.Http.dll to "4.0.0.0" (from 2.0.5.0) on our MOBILE
profiles, lest much pain and suffering occur, e.g.:
http://motzcod.es/post/78863496592/portable-class-libraries-httpclient-so-happy
> For some reason at compile time the facades don’t kick in
> properly and it tries to use the NuGet version of
> System.Net.Http which has some specific functionality for
> older platforms. ...
> All you need to do is create a new app.config file in your
> Android and iOS project.
The need to create a custom app.config is ugly and something
to be avoided. Setting our System.Net.Http.dll version to
v4.0.0.0 removes the need for the custom app.config.
The two races in question are:
In signal_thread_state_change we need to block the target from
further waiting before we signal it or otherwise it might miss the
broadcast asking it to wakeup.
In mono_thread_request_interruption we need to ensure we self interrupt
before returning from the signal handler.
Unblock the GC suspend/restart signals and SIGCHLD. Those are required to make the GC
and process watching work.
The SIGCHLD issue was found on mod_mono that fork a process with that signal blocked.
The GC signals are been preemptively unblocked as we can never know what sort of sig mask
we'll start with.
This merely introduces a more readable version of some of the constants that
were hardcoded on the source code.
There is a suspect value "20" that was on the original source code, that
stands for VNodeLink and VNodeExtend, but perhaps the original author
meant to say VNodeRename. In any case, it seems like we should catch all
of them (except for Revoke).
The section mapping system wasn't being initialized and used properly since some ifdefs had
been left in the source code. This caused a null reference exception while trying to perform
some HTTP requests and, as the result, broke Xamarin Studio activation.
Two main way to dump :
- per Time : equivalent to a --stats but every seconds, useful to see the overall evolution of all counters
- per Category : print sample values grouped per category and counters, useful to see the evolution of a specific counter over time
This variables are respectively :
- the list of all counters
- the list of all counters grouped by sections
- the list of all counters groupes by sample value timestamps and sections
Counter : contains metadata concerning a counter. There is one in memory per counter index (right now ~100).
CounterValue : represent a sample value of a counter.
CounterList : it is a utility struct that contains a list of counters.
CounterSection : represent all the counters that are in this sections. Used only when we sort counters per category.
CounterTimestamp : represent all the counters that have a sample value at this timestamp. Used only when we sort counters per time.
It's now also much more compatible with the subtleties of
the MS .NET parser and includes a substantial test suite.
Fixes BXC19542 - Broken F# Error Reports
Since we are invoking make recursively to satisfy the dependencies
for any of the cyclic components, we need to inform make to not try
to parallelize any work on any of the cyclic dependencies, otherwise
multiple builds will execute building the same binary, and the result
will be truncated outputs.
For example, System's Makefile would launch all the parallel builds for
the dependencies:
$(secxml_libdir)/System.dll \
$(the_libdir_base)System.Xml.dll \
$(the_libdir_base)Mono.Security.dll \
$(bare_libdir)/System.dll
They could be launched in parallel, and in turn the makefiles on those
directories might try simultaneously to invoke recursively a component
that has not been built yet.
So we use .NOTPARALLEL to flag all the cyclic dependencies on a given
directory to instruct make to not run those in parallel.
This patch is a continuation of the previous work on System to remove
the multi-stage build configuration in Mono's class libraries and avoid
the overwriting of assemblies in a multi-stage build setup.
This patch introduces an infrastructure to stage the builds for the core
assemblies that have cyclic dependencies. This deals directly with
the following cycle:
System.dll requires:
System.Configuration.dll
Mono.Security.dll
System.Xml.dll
They all require System.dll to be built
System.Xml requires:
System.dll
System.Configuration.dll
System.Security.dll requires:
System.dll
Mono.Security.dll
System.Xml.dll
Principle
=========
The patch works by directing the build infrastructure to place
intermediate build steps on their own directory. For example the
first System.dll build that only takes a dependency in mscorlib.dll is
placed not under the final directory but on a subdirectory called
"bare".
The second time that System.dll is built (after Mono.Security and
System.Xml have been built) is placed on the "secxml" directory.
The third time is the final build, and that one ends in the profile
directory.
The same principle is applied to System.Xml.
Better Dependency Tracking
==========================
To handle the multiple stages, the new Makefiles for the various
parties involved in this loop are now able to build their
dependencies. This means that typing "make" on System.Security or
System.Xml or System will build all of the intermediate steps as
required, without needing the toplevel Makefile to perform multiple
build shots to incrementally build the result.
Bug fixes
=========
We must have regressed at some point the build of System.Xml as we
were only doing one build of it, one without System.Configuration
support. This patch introduces back the changes to build System.Xml
in two steps.
This patch fixes the setup where we end up rebuilding System.dll and
overwriting it two times as the build progresses as a side effect
(this is what required LIBRARY_USE_INTERMEDIATE_FILE).
Details
=======
library.make:
Introduces a new "the_libdir_base" which is the raw directory
where the final output will go. This points to the same location
that libdir_base previously pointed to.
The existing libdir_base is modified to contain an optional
"intermediate" directory, where intermediate builds can be
placed.
Other cycles
============
The System.Design assembly was listed as having cycles, but while this
cycle exists in theory, in practice we have not implemented any of the
code that brings the cycle in System.Windows.Forms.Design's
ImageListImageEditor and chances are, we wont any time soon.
Less common case - unless the API difference has a large delta.
Some additional spacing is added to ease readability: if an entry takes two line then it needs a empty line.
All uses of the mono_dont_free_global_codeman variable (including its
definition) have been removed in
4a1ae4694a.
Its declaration should be removed as well to keep the codebase clean.
* The existing regex was not always used (e.g. new sections);
* It's now possible to use a regex on 'removed' (not just added) elements;
* It's possible to use the same regex for both (or have different ones);
counters_init is called at the end of runtime initialization, on runtime_initialized hook
counters_sample is called in the helper_thread at least once per second
Add new function mono_counters_register_with_size which let the counters API now what is going to be the max size of the string.
The type of the value passed when MONO_COUNTER_STRING is passed must be char* (instead of char** previously). This is to guarantee that, if we want to change the value of the counter, we do not reallocate and free the old value, but we change the value in place. Thus to avoir race condition and access to freed memory.
This is useful when the files needs to be pre-processed (e.g. a major change between the assemblies internals) and where some duplicate entries might be created (e.g. merged types/namespaces).
Note: normally the mono-api* tools should not produce such files (so it's better not used unless required)
After discussion with Kumpera, it was decided to load them lazily when calling mono_counters_foreach for the first time. It has to be inside the mono runtime, and not in a profiler because it accesses proclib API which is all MONO_INTERNAL functions.
The tarjan-coloring bridge is significant departure from the old bridge. It's design is based
on the Tarjan Strongly Connected Component algorithm.
SCC links are calculated as part of the Tarjan dfs on the second scan to calculate the low index and
form the components.
The algorithm does inspect all children after they have been processed, which enables us to do backward
propagation of the reachable SCCs.
In order to avoid the xref mess of the old algorithm, we color each component based on the sum of all
reachable components (colors). This means no matter how many non-bridge objects are in between two bridges,
they will all receive the same color and be represented in the final output as a single node in the SCC
graph.
This allows for a reasonably compact output graph as it will only include colors with no bridges when
a single object has multiple bridges reachable.
Said that, the basic algorithm received a series of optimizations:
1)Flag based merging, great idea from Mark, it bounds color and xref merging to be linear on the number of
colors found.
2)Objects and Colors bucket allocation. Instead of using expansible arrays we use fixed size buckets that
form a linked list. This allow us to use direct pointers instead of indexes. It avoid the expensive expansions.
Another benefit is that it reduces the work by sgen's malloc, which can be really slow.
3)Replace the object hash table with header patching. We tag objects with both pinning and forwarded bits and
store a pointer in the lock word. This eliminates the hashtable, a big source of perf issues. Patching objects
back at the end of bridge processing is much much cheaper than free'ing all the hashtable entries.
4)Color deduplication. It's possible to produce duplicated colors due to mutually unreachable paths that
both points to the same set of bridges. A cache is introduced to reduce it for colors points to 2 or 3 others.
The way we build colors allow us in the future to fix the hub object problem (SetupDoubleFan).
Experimental results with sgen-bridge-pathologies shows this implementation been 2-3x faster than the new one.
If currentCell still has a value when we call Columns.Clear() we
might try to end the editing. Because the columns got disposed
before calling Columns.Clear() we get a crash. This patch fixes
the problem by setting currentCell to null.
The tests require that the debug file is available, however in the net_4_0 profile this file isn't generated by default.
We now ensure the debug file is always generated for the test assembly.
This was previously used to not store counters that were not going to be dumped, but because we can now sample them, we have to make sure that they are stored, even if we do not plan to dump or sample them.
We can't forward to HashEntry's because they are volatile - the
hash table will resize, and the entries move. We need to point to
the objects, and then look them up via the hash. Also, we have
to forward chains of forwards.
Instead of merging the two lists by keeping them sorted, use the flag on
the SCCs the indicate whether an SCC has already been merged in, and
just append it if not. This makes it as fast as the new algorithm on one
test case where it was pathologically slow, while not exhibiting another
pathology that the new algorithm has.
Tha previous behaviour of MONO_PATH for relative paths (that implied
using the paths as relative to the current directory when loading
assemblies) was not yet documented and led to some failures when
executing tests.
In order to fix the failures, a new behaviour has been introduced:
relative paths are resolved at launch time, so that the folders which
are examined when loading assemblies do not depend on the current path
of the program.
This patchset is released under the MIT license.
When MONO_PATH contains relative folders, they are meant as relative
from where the application is launched, not from the current directory
of each assembly load.
Fixes#19380.
metadata/threads.c: fix regression from the 695b17f8d5 change and
avoid useless memory allocation. Report thread name to the profiler at
thread startup if it was set before that.
profiler/decode.c: fix typo.
profiler/proflog.c: ensure we get a consistent first buffer header at runtime
initialization.
We now try and trigger assembly resolve events for referenced assemblies
in a way that is more compatible with the MS runtime behaviour. If that still
fails we continue falling back and looking in the same directory as the referencing
image as before to keep compatibility with code that relies on the previous mono
behaviour.
The assemblyresolve_event3.cs test that used to fail on the MS runtime has been fixed
so it works now with both engines.
bugzilla.xamarin.com bug reference: Bug 19304
ComboBox reverts to original selection when it loses focus.
The LostFocus handler for the internal ComboTextBox class
was being called after it had been disposed. The dispose
was correctly called when the ComboBoxStyle changed from
it's initial default value to DropDownList. However, when
the ComboBox control lost focus later on, the LostFocus event handler
was called, which resulted in the Text value for the ComboBox
being overwritten by the value in the disposed object.
Could not see how to write a unit test within the ComboBoxTest.cs
that would simulate losing focus so only providing fix.
Change-Id: I9ca4cc75da5711a7d7c1dd166d5f52d580f44df1
The previous behavior when using mono_counters_dump was to pass -1 as the section and get all
counters dumped. This commit restore this behavior.
In addition to that, we want to enable callers to filter by variance as non monotonic counters are not useful
to be dumped at shutdown. To do so you just OR the variance with the sections you want. So what the runtime wants is:
mono_counters_dump (MONO_COUNTER_SECTION_MASK | MONO_COUNTER_MONOTONIC, stdout);
Dump all counters that are monotonic. Perfect.
Finally, to make the above neat, a reorg of the type bitfield was needed. Variance is now using a bit per kind.
Variance and unit where shrunk to 4 bits each, to open space for more sections.
This is more portable than using the mono_arch_instrument_* functions and
thus isn't prone to nasty arch-specific bugs. In particular, the old way
of instrumenting function prologues/epilogues resulted in a somewhat elusive
stack corruption bug on Android (ARM). Eventually, we should get rid of these
functions entirely and only use icalls, with JIT opcodes for special cases
(such as saving arguments for --trace).
This new way of doing things also makes profiler instrumentation AOT-safe,
since we're now going through the proper channels to emit references to the
runtime functions (mono_profiler_method_enter/leave) and to embed MonoMethod
pointers.
Since we're using icalls without wrappers to do this, there should be no
visible performance impact from this commit.
- Expanded monodoc-ecma schema to support the 'preserve-mono' attribute, and the attribution tag.
- Added preserve-mono to several pieces of documentation that we would like to preserve across future automated documentation imports: CipherSuitesCallback, ServicePointManager, CultureInfo, Environment+SpecialFolder.xml
- XSL template changes for monodoc HTML generation to support <attribution>
This patch builds upon commit 96a8500795 which placed parts of Mono.Security
responsible for dealing with SSL/TLS certificates for the purpose of certificate verification. The code enables
validation of the certifcates even if the user does not provide their own validation callback. The changes as related to
the original commit are few, basically consisting of enabling the same code used by MonoTouch in the MonoDroid context with
the only actual code change being the certificate validation bit mentioned above.
Since the change involves adding a subset of Mono.Security files to the monodroid version of System.dll, it is
also necessary to remove Mono.Android's dependence on Mono.Security.dll. The reason is that the code in AndroidPlatform
which looks up TLS support methods in Mono.Android.dll would use a type (X509CertificateCollection) that is now part of
System.dll but is *also* in Mono.Security.dll referenced by Mono.Android.dll and therefore the lookup would fail since
we'd have two distinct types from the reflection point of view.
Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=18962
This reverts commit 8f09dad435.
8f09dad435 is reverting a merge commit,
which will not do what you think it does. It will revert much more,
so revert the revert to get back the unintentionally reverted commits.
It looks like the next commit (1a15d4ec54)
is doing the original intention (reverting 164f9cbec4),
so this revert will leave the tree in a good state, with no pending
reverts.
Some types are statically known to never lead to a bridge. Objects like
string or int[]. By filtering them out very early in dfs1 we save memory by
not inserting them into the hashtable and reduce work done by all further steps.
The bridge implementation can be picked by having bridge-implementation=old|new in
MONO_GC_PARAMS.
This commit just prepared the ground to land experimental improvements to the bridge
while retaining an working implementation by default.
When the xbuild_12 profile is verified, the corlib from the net_4_5
profile should be in the MONO_PATH, otherwise the verification will
fail with:
The assembly mscorlib.dll was not found or could not be loaded.
It should have been installed in the `.../mono/4.5/mscorlib.dll' directory.
The adjustment rule must take into account that DST can start in the previous year and extend to some initial period
of the DateTime's year. This patch makes the code take that into account and correctly applies the DST offset to the
date being converted to some target timezone.
Fixes xambug https://bugzilla.xamarin.com/show_bug.cgi?id=17155
* ConvertTime (DateTime, TimeZoneInfo) now correctly takes the date kind from the DateTime parameter
and uses it to select the source time zone according to this criteria:
if DateTime kind is Utc, use TimeZoneInfo.Utc as source, in all other cases use TimeZoneInfo.Local
* Move argument checks in ConvertTime (DateTime, TimeZoneInfo, TimeZoneInfo) so that there's no risk of a NREX
should sourceTimeZone be null.
Added relevant tests for all of the above changes.
Otherwise this happens:
MCS [monotouch] Mono.CSharp.dll
../../mcs/codegen.cs(294,7): error CS1061: Type `System.Reflection.Emit.ILGenerator' does not contain
a definition for `BeginExceptFilterBlock' and no extension method `BeginExceptFilterBlock' of
type `System.Reflection.Emit.ILGenerator' could be found. Are you missing an assembly reference?
The runtime category is for high level counters on runtime operations.
Things like number of threads, threadpool status, total memory consumption
and so on.
The system category is for synthetic counters that report system values
such as RSS, user time and load.
This fixes the TableLayoutPanel implementation to check for control names
as well as the the controls themselves in looking up the row and column
values.
Marshal.GetHRForException had a MonoTODO because it needs to set
the errorinfo object so that exceptions get properly passed to
unmanaged code. Since not all managed exceptions have a corresponding
HR value but we might need to get to the original thrown exception
we implement a ManagedErrorInfo helper class that implements the
IErrorInfo interface but also stores the exception.
In GetExceptionForHR we check if the errorinfo we get is a
ManagedErrorInfo. If it is we return the exception stored in there
(if it converts to the same error code), otherwise we construct a new
exception.
Also use additional information provided by IErrorInfo to fill in
exception details.
To make use of IErrorInfo on Linux a suitable implementation has to be
provided, e.g. by including libcom plus adding a mapping from
oleauth32.dll to the shared library that provides the implementation.
This completes mono bug 496138
(https://bugzilla.novell.com/show_bug.cgi?id=496138)
The height we calculate is the inner height, so we need to add the top
and bottom borders when setting the height of the listbox. The width
however is the outer width so we need to subtract the left and right
borders when setting the client width.
Vertically centered text on buttons didn't show up centered. The
referenced bug reports it on Windows. Matters were worse on Linux.
This patch tries to fix the problem on both Windows and Linux. On Linux
the positioning is improved although probably still not perfect.
This fixes Novell bug #463149
(https://bugzilla.novell.com/show_bug.cgi?id=463149).
When setting both Row.Height and MinimumHeight we need to set the
MinimumHeight first otherwise we will get a crash if the new Height
value is less than the old MinimumHeight value.
This change adds unit tests that demonstrate the bug #2394
where setting Row.Height below MinumumHeight in a DataGridView
doesn't work as expected. The unit tests also document the
behavior of .NET which isn't documented in MSDN.
When the MinimumHeight gets changed to a value less than Height
we set height to the new minimum height (and fire the
DataGridView.RowMinimumHeightChanged event). This matches the
behavior on .NET.
When the user tries to set Height to a value less than MinimumHeight
we silently set the height to the minimum height (instead of
throwing an exception). This matches also the behavior on .NET.
- fix the tests (tests made partially wrong assumptions which didn't
match the behavior of .NET).
- split MinimumHeight test in multiple smaller tests that test only
one thing.
- add a few more tests for MinimumHeight and Row.
Previously some characters might have been concatenated on a message
box that displayed an icon because the size of the text area was
calculated wrong. This fixes bug #2090
(https://bugzilla.xamarin.com/show_bug.cgi?id=2090).
The test tried to resolve an assembly from the GAC, which doesn't work on a
clean machine without an existing Mono installation.
We now check if the GAC directory is missing and ignore the test in that case.
2014-02-25 21:21:10 +01:00
11457 changed files with 957428 additions and 619883 deletions
* Currently this is used with Mono's AOT engine as
Native Client does not support JIT engines yet.
Using Mono
==========
Once you have installed the software, you can run a few programs:
*`mono program.exe` runtime engine
*`mcs program.cs` C# compiler
*`monodis program.exe` CIL Disassembler
See the man pages for mono(1), mint(1), monodis(1) and mcs(2)
for further details.
Directory Roadmap
=================
*`docs/` - Technical documents about the Mono runtime.
*`data/` - Configuration files installed as part of the Mono runtime.
*`mono/` - The core of the Mono Runtime.
*`metadata/` - The object system and metadata reader.
*`mini/` - The Just in Time Compiler.
*`dis/` - CIL executable Disassembler
*`cli/` - Common code for the JIT and the interpreter.
*`io-layer/` - The I/O layer and system abstraction for
emulating the .NET IO model.
*`cil/` - Common Intermediate Representation, XML
definition of the CIL bytecodes.
*`interp/` - Interpreter for CLI executables (obsolete).
*`arch/` - Architecture specific portions.
*`man/` - Manual pages for the various Mono commands and programs.
*`samples/` -Some simple sample programs on uses of the Mono
runtime as an embedded library.
*`scripts/` - Scripts used to invoke Mono and the corresponding program.
*`runtime/` - A directory that contains the Makefiles that link the
mono/ and mcs/ build systems.
*`../olive/`
* If the directory ../olive is present (as an
independent checkout) from the Mono module, that
directory is automatically configured to share the
same prefix than this module gets.
Contributing to Mono
====================
Before submitting changes to Mono, please review the contribution guidelines at http://mono-project.com/Contributing. Please pay particular attention to the [Important Rules](http://mono-project.com/Contributing#Important_Rules) section.
Git submodules maintenance
==========================
Read documentation at http://mono-project.com/Git_Submodule_Maintenance
Maintainer
==========
Mono is maintained by miguel@xamarin.com
Reporting bugs
==============
To submit bug reports, please use Xamarin's Bugzilla:
https://bugzilla.xamarin.com/
Please use the search facility to ensure the same bug hasn't already
been submitted and follow our guidelines on how to make a good bug
#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
for counter in 1 2 3 4 5 ; do if test -f $(topdir)/../msvc/scripts/inputs/$$config_file ; then config_file=`basename $(LIBRARY) .dll`-$(PROFILE)-$$counter.input; fi ; done ;\
Loaded 100 of 11457 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.