Cygwin: fix declaration of __small_{v}sprintf

Both functions are declared as extern "C" functions in
sys/smallprint.h, but as C++ funcs in winsup.h and in the
source itself.

Add extern "C to definitions, remove declarations in winsup.h
and include sys/smallprint.h instead.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: pty: Stop counting number of slaves attached to pseudo console.

- The number of slaves attached to pseudo console is used only for
  triggering redraw screen. Counting was not only needless, but also
  did not work as expected. This patch removes the code for counting.

Cygwin: pty: Revise code to make system_printf() work after close.

- After commit 0365031ce1347600d854a23f30f1355745a1765c, the issue
  https://cygwin.com/pipermail/cygwin-patches/2020q2/010259.html
  occurs. This patch fixes the issue.

Cygwin: FIFO: add missing unlock

There was a missing call to reader_opening_unlock on one of the error
exits in fhandler_fifo::open.

Cygwin: FIFO: Revert "take ownership on exec"

This reverts commit 39a9cd94651d306117c47ea1ac3eab45f6098d0e.

There is no need to explicitly take ownership in fixup_after_exec; if
ownership transfer is needed, it will be taken care of by
fhandler_fifo::close when the parent closes.  Moreover, closing the
parent's fifo_reader_thread can cause problems, such as the one
reported here:

  https://cygwin.com/pipermail/cygwin-patches/2020q2/010235.html

Cygwin: pty: Make system_printf() work after closing pty slave.

- Current pty cannot show system_printf() output after closing pty
  slave. This patch fixes the issue.

Cygwin: pty: Call FreeConsole() only if attached to current pty.

- After commit 071b8e0cbd4be33449c12bb0d58f514ed8ef893c, the problem
  reported in https://cygwin.com/pipermail/cygwin/2020-May/244873.html
  occurs. This is due to freeing console device accidentally rather
  than pseudo console. This patch makes sure to call FreeConsole()
  only if the process is attached to the pseudo console of the current
  pty.

Reimplement aligned_alloc

The original implementation had multiple issues:

- Only worked when posix_memalign was available (Linux, RTEMS).
- Violated C11 link namespace rules by calling posix_memalign.
- Failed to set errno on error.

These can be fixed by essentially using the same implementation
for aligned_alloc as for memalign, i.e. simply calling _memalign_r
(which is always available and a "more reserved name" although
technically still not in the reserved link namespace, at least
code written in c cannot define a colliding symbol, newlib has
plenty such namespace issues so this is fine).

It is not clear what the right policy is when MALLOC_PROVIDED is set,
currently that does not cover aligned_alloc so it is kept that way.

Tested on aarch64-none-elf

Cygwin: termios: Set ECHOE, ECHOK, ECHOCTL and ECHOKE by default.

- Backspace key does not work correctly in linux session opend by
  ssh from cygwin console if the shell is bash. This is due to lack
  of these flags.

  Addresses: https://cygwin.com/pipermail/cygwin/2020-May/244837.html.

cygwin: doc: Add keywords for ACE order issues

Windows Explorer shows a warning with Cygwin-created DACLs, but putting
the text of the warning into Google doesn't lead to the relevant Cygwin
docs.  Let's copy the warning text into the docs in the hopes of helping
confused users.  Most of the credit for the wording belongs to Yaakov
Selkowitz.

Latest inquiry: <https://cygwin.com/pipermail/cygwin/2020-May/244814.html>

Signed-off-by: David Macek <david.macek.0@gmail.com>

Cygwin: FIFO: improve the interruptibility of raw_read

During a blocking read, we sleep for 1 ms after each iteration through
the connected writers.  Currently we do this by calling Sleep (1).
Remove this call to Sleep and instead change the timeout in the
cygwait call from 0 to 1, so that raw_read can be interrupted while
sleeping.

Cygwin: FIFO: code simplification

There are currently three functions that call NtQueryInformationFile
to determine the state of a pipe instance.  Do this only once, in a
new fifo_client_handler::set_state () function, and call that when
state information is needed.

Remove the fifo_client_handler methods pipe_state and get_state, which
are no longer needed.

Make fhandler_fifo::get_fc_handler return a reference, for use in
select.cc:peek_fifo.

Make other small changes to ensure that this commit doesn't change any
decisions based on the state of a fifo_client_handler.

The tricky part is interpreting FILE_PIPE_CLOSING_STATE, which we
translate to fc_closing.  Our current interpretation, which is not
changing as a result of this commit, is that the writer at the other
end of the pipe instance is viewed as still connected from the point
of view of raw_read and determining EOF.

But it is not viewed as still connected if we are deciding whether to
unblock a new reader that is trying to open.

Cygwin: fifo: fix type of fifo_reader_id_t operators

fifo_reader_id_t::operator == and != have been defined without type
accidentally.  For some weird reason, only x86 gcc complains about
this problem, not x86_64 gcc.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: add pseudo console patch to release text

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Document recent FIFO changes

Cygwin: FIFO: update commentary

The beginning of fhandler_fifo.cc contains a long comment giving an
overview of the FIFO implementation.  This is now updated to describe
the support for multiple readers.

Cygwin: FIFO: support opening multiple readers

Although we can have multiple readers open because of dup/fork/exec,
the current code does not support multiple readers opening a FIFO by
explicitly calling 'open'.

The main complication in supporting this is that when a blocking
reader tries to open and there's already one open, it has to check
whether there any writers open.  It can't rely on the write_ready
event, whose state hasn't changed since the first writer opened.

To fix this, add two new named events, check_write_ready_evt and
write_ready_ok_evt, and a new method, check_write_ready().

The first event signals the owner's reader thread to call
check_write_ready(), which polls the fc_handler list to check for
connected writers.  If it finds none, it checks to see if there's a
writer in the process and then sets/resets write_ready appropriately.

When check_write_ready() finishes it sets write_ready_ok_evt to signal
the reader that write_ready has been updated.

The polling is done via fifo_client_handler::pipe_state().  As long as
it's calling that function anyway, check_write_ready() updates the
state of each handler.

Also add a new lock to prevent a race if two readers are trying to
open simultaneously.

Cygwin: FIFO: allow any reader to take ownership

Add a take_ownership method, used by raw_read and select.cc:peek_fifo.
It wakes up all fifo_reader_threads and allows the caller to become
owner.  The work is done by the fifo_reader_threads.

For synchronization we introduce several new fhandler_fifo data
members and methods:

- update_needed_evt signals the current owner to stop listening for
  writer connections and update its fc_handler list.

- shared_fc_handler() gets and sets the status of the fc_handler
  update process.

- get_pending_owner() and set_pending_owner() get and set the reader
  that is requesting ownership.

Finally, a new 'reading_lock' prevents two readers from trying to take
ownership simultaneously.

Cygwin: FIFO: find a new owner when closing

If the owning reader is closing, wait for another reader (if there is
one) to take ownership before closing the owner's pipe handles.

To synchronize the ownership transfer, add events owner_needed_evt and
owner_found_evt, and add methods owner_needed and owner_found to
set/reset them.

Modify the fifo_reader_thread function to wake up all non-owners when
a new owner is needed.

Make a cosmetic change in close so that fhandler_base::close is called
only if we have a write handle.  This prevents strace output from
being littered with statements that the null handle is being closed.

Cygwin: FIFO: take ownership on exec

If fixup_after_exec is called on a non-close-on-exec reader whose
parent is the owner, transfer ownership to the child.  Otherwise the
parent's pipe handles will be closed before any other reader can
duplicate them.

To help with this, make the cancel_evt and thr_sync_evt handles
inheritable, so that the child can terminate the parent's
fifo_reader_thread (and the parent will update the shared fc_handler
list).

Add an optional argument 'from_exec' to update_my_handlers to simplify
its use in this case; no handle duplication is required.

Cygwin: FIFO: add a shared fifo_client_handler list

This is in a new shared memory section.  We will use it for temporary
storage of the owner's fc_handler list when we need to change owner.
The new owner can then duplicate the pipe handles from that list
before taking ownership.

Add several shared data members and methods that are needed for the
duplication process

Add methods update_my_handlers and update_shared_handlers that carry
out the duplication.

Allow the shared list to grow dynamically, up to a point.  Do this by
initially reserving a block of memory (currently 100 pages) and only
committing pages as needed.

Add methods create_shared_fc_handler, reopen_shared_fc_handler, and
remap_shared_fc_handler to create the new shared memory section,
reopen it, and commit new pages.  The first is called in open, the
second is called in dup/fork/exec, and the third is called in
update_shared_handlers if more shared memory is needed.

Modify the fifo_reader_thread function to call update_my_handlers when
it finds that there is no owner.  Also make it call
update_shared_handlers when the owner's thread terminates, so that the
new owner will have an accurate shared fc_handler list from which to
duplicate.

For convenience, add new methods cleanup_handlers and
close_all_handlers.  And add an optional arg to add_client_handler
that allows it to create a new fifo_client_handler without creating a
new pipe instance.

Cygwin: FIFO: allow fc_handler list to grow dynamically

Make fc_handler a pointer to malloc'd memory instead of a fixed-size
array.  The size is now a new data member 'shandlers'.  Call realloc
in add_client_handler if we need to grow the array.

free fc_handler in close.  As long as we're touching that code, also
remove an unneeded lock.

Cygwin: FIFO: designate one reader as owner

Among all the open readers of a FIFO, one is declared to be the owner.
This is the only reader that listens for client connections, and it is
the only one that has an accurate fc_handler list.

Add shared data and methods for getting and setting the owner, as well
as a lock to prevent more than one reader from accessing these data
simultaneously.

Modify the fifo_reader_thread so that it checks the owner at the
beginning of its loop.  If there is no owner, it takes ownership.  If
there is an owner but it is a different reader, the thread just waits
to be canceled.  Otherwise, it listens for client connections as
before.

Remove the 'first' argument from create_pipe_instance.  It is not
needed, and it may be confusing in the future since only the owner
knows whether a pipe instance is the first.

When opening a reader, don't return until the fifo_reader_thread has
time to set an owner.

If the owner closes, indicate that there is no longer an owner.

Clear the child's fc_handler list in dup, and don't bother duplicating
the handles.  The child never starts out as owner, so it can't use
those handles.

Do the same thing in fixup_after_fork in the close-on-exec case.  In
the non-close-on-exec case, the child inherits an fc_handler list that
it can't use, but we can just leave it alone; the handles will be
closed when the child is closed.

Cygwin: FIFO: introduce a new type, fifo_reader_id_t

This uniquely identifies an fhandler_fifo open for reading in any
process.

Add a new data member 'me' of this type, which is set in open, dup,
fork, and exec.

Cygwin: FIFO: keep track of the number of readers

Add data and methods to the shared memory that keep track of the
number of open readers.

Increment this number in open, dup, fork, and exec.  Decrement it in
close.  Reset read_ready if there are no readers left.

Cygwin: FIFO: add shared memory

Even though we currently allow a FIFO to be opened for reading only
once, we can still have more than one reader open because of dup and
fork.  Add a named shared memory section accessible to all readers of
a given FIFO.  In future commits we will add information needed by all
readers to this section

Add a class fifo_shmem_t that lets us access this information.

Add a method create_shmem that is called when a reader opens, and add
a method reopen_shmem that is called by dup, fork, and exec.  (Each
new reader needs its own view of the shared memory.)

Cygwin: FIFO: use a cygthread instead of a homemade thread

This will simplify future work.

Rename the thread from "listen_client_thread" to "fifo_reader_thread"
because it will be used for more than just listening.

Remove the fixup_before stuff, which won't be needed after future
changes to fixup_after_fork and fixup_after_exec.

Cygwin: FIFO: make opening a writer more robust

- Make read_ready a manual-reset event.

- Signal read_ready in open instead of in the listen_client_thread.

- Don't reset read_ready when the listen_client thread terminates;
  instead do it in close().

- Rearrange open and change its error handling.

- Add a wait_open_pipe method that waits for a pipe instance to be
  available and then calls open_pipe.  Use it when opening a writer if
  we can't connect immediately.  This can happen if the system is
  heavily loaded and/or if many writers are trying to open
  simultaneously.

Cygwin: FIFO: fix hit_eof

According to Posix, a FIFO open for reading is at EOF if it is empty
and there are no writers open.

The only way to test this is to poll the fifo_client_handlers as in
raw_read and select.cc:peek_fifo.  The current hit_eof instead relies
on the value of nconnected, which can be out of date.  On the one
hand, it doesn't take into account writers that were connected but
have since closed.  On the other hand, it doesn't take into account
writers that are in the process of opening but haven't yet connected.

Fix this by introducing a maybe_eof method that tentatively assumes
EOF if there are no connected writers after polling.  Then check for
writers currently opening (via a new 'writer_opening' event), and wait
for the fifo_reader_thread to record any new connection that was made
while we were polling.

To handle the needs of peek_fifo, replace the get_fc_handle method
by a get_fc_handler method, and add a fifo_client_handler::get_state
method.

Remove the is_connected method, which was used only in peek_fifo and
is no longer needed.

Remove the nconnected data member, which was used only for the flawed
hit_eof.

Add some comments about events to fhandler.h.

Cygwin: FIFO: dup/fork/exec: make sure child starts unlocked

There can be deadlocks if the child starts with its fifo_client_lock
in the locked state.

Cygwin: FIFO: honor the flags argument in dup

Also improve the error handling.

Cygwin: FIFO: remove the arm method

There's no reason to check for errors when we set read_ready or
write_ready.  We don't do that for other events.

Cygwin: FIFO: simplify the listen_client_thread code

Always return 0; no one is doing anything with the return value
anyway.

Remove the return value from stop_listen_client.

Make the connection event auto-reset, so that we don't have to reset
it later.

Simplify the process of connecting a bogus client when thread
termination is signaled.

Make some failures fatal.

Remove the unnecessary extra check for thread termination near the end
of listen_client_thread.

Cygwin: FIFO: change the fifo_client_connect_state enum

Make the values correspond to the possible return values of
fifo_client_handler::pipe_state().

When cleaning up the fc_handler list in listen_client_thread(), don't
delete handlers in the fc_closing state.  I think the pipe might still
have input to be read in that case.

Set the state to fc_closing later in the same function if a connection
is made and the status returned by NtFsControlFile is
STATUS_PIPE_CLOSING.

In raw_read, don't error out if NtReadFile returns an unexpected
status; just set the state of that handler to fc_error.  One writer in
a bad state doesn't justify giving up on reading.

Cygwin: FIFO: simplify the fifo_client_handler structure

Replace the 'fhandler_base *' member by a HANDLE to the server side of
the Windows named pipe instance.  Make the corresponding
simplifications throughout.

Cygwin: FIFO: minor change - use NtClose

Replace CloseHandle by NtClose since all handles are created by NT
functions.

Revert "localtime define _DIAGASSERT" and followups affecting localtime.cc

This reverts commits 453b6d17bf0581e55258c5eb6dc7afbad1927cab,
                     489a47d6036660a6cbab1addfb2b7678c0de8bf2,
                     3003c3dacd157c11f5e035bc18bdd30631800720,
                     9e29639ca01208a4a8bac5b9d0f6491b34b1017e,
                     a40701c7dc9970457a19728e371c71e7501057e7,
                     0a41de2725dbf2f325e55016d85d76560845ff8d,
                     b8aa5f7a0fe70a9a53fe4019227271a78758ae67,
                     0f4bda879283eaf013f86dd80e5588721a811ea0,
                     65bf580752db7ac01ecae19dc56aa26ea34f5e47,
                     3f0c2ac96e7c493bbfc2bc1b0c1274445b756a9d,
                     76d4d40b8b23d046473a5946cf6b83faa36ae7be,
                     f2e06d8af5f390d81b64375a69ca834ca19d6029.

setup_pseudoconsole(): handle missing/incorrect helper gracefully

When `cygwin-console-helper.exe` is either missing, or corresponds to a
different Cygwin runtime, we currently wait forever while setting up
access to the pseudo console, even long after the process is gone that
was supposed to signal that it set up access to the pseudo console.

Let's handle that more gracefully: if the process exited without
signaling, we cannot use the pseudo console. In that case, let's just
fall back to not using it.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>

localtime define _DIAGASSERT

localtime 1.82

localtime 1.81

localtime 1.80

localtime 1.79

localtime 1.78

localtime 1.77

localtime 1.76

localtime 1.75

localtime 1.74

localtime 1.73

Cygwin: localtime.cc: reformat for easier patching

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: add release message for fixed floppy bugs

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: raw disk I/O: lock floppys as well

The workaround to access the full disk required since Vista
and described in http://support.microsoft.com/kb/942448
(NOT ACCESSIBLE at the time of writing this commit message)
is required on floppy drives as well.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: raw disk I/O: Fix return value in error case

The cast to generate the return value uses a DWORD variable
as test and set value.  The error case is the constant -1.
Given the type of the other half of the conditioal expression,
-1 is cast to DWORD as well.

On 64 bit, this results in the error case returning a 32 bit
-1 value which is equivalent to (ssize_t) 4294967295 rather
than (ssize_t) -1.

Add a fixing cast.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: file I/O: make sure to treat write return value as ssize_t

The return type of fhandler write methods is ssize_t.  Don't
use an int to store the return value, use ssize_t.  Use ptrdiff_t
for the buffer size.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: accounts: Report unrecognized db_* nsswitch.conf keywords

Signed-off-by: David Macek <david.macek.0@gmail.com>

Cygwin: accounts: Don't keep old schemes when parsing nsswitch.conf

The implicit assumption seemed to be that any subsequent occurence of
the same setting in nsswitch.conf is supposed to rewrite the previous
ones completely.  This was not the case if the third or any further
schema was previously defined and the last line defined less than that
(but at least 2), for example:

```
db_home: windows cygwin /myhome/%U
db_home: cygwin desc
```

Let's document this behavior as well.

Signed-off-by: David Macek <david.macek.0@gmail.com>

Cygwin: accounts: Unify nsswitch.conf db_* defaults

Signed-off-by: David Macek <david.macek.0@gmail.com>

Cygwin: Add David Macek to CONTRIBUTORS

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: symlinks: fix WSL symlink creation if cygdrive prefix is /

If the cygdrive prefix is /, then the following happens right now:

  $ ln -s /tmp/foo .
  $ ls -l foo
  lrwxrwxrwx 1 user group 12 Apr 15 23:44 foo -> /mnt/tmp/foo

Fix this by skipping cygdrive prefix conversion to WSL drive
prefix "/mnt", if the cygdrive prefix is just "/".  There's no
satisfying way to do the right thing all the time in this case
anyway.  For a description and the alternatives, see
https://cygwin.com/pipermail/cygwin-developers/2020-April/011859.html

Also, fix a typo in a comment.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

cygheap_pwdgrp: Handle invalid db_* entries correctly

If the first scheme in db_* was invalid, the code would think there
were no schemes specified and replace the second scheme with
NSS_SCHEME_DESC.

Signed-off-by: David Macek <david.macek.0@gmail.com>

Cygwin: faq: disable outdated "sshd in domain" faq

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

proc_cpuinfo: Add PPIN support for AMD

Newer AMD CPUs support a feature called protected processor
identification number (PPIN). This feature can be detected via
CPUID_Fn80000008_EBX[23].

Cygwin: utils: override definition of PMEM_EXTENDED_PARAMETER

PMEM_EXTENDED_PARAMETER is defined in the local winlean.h as long
as mingw-w64 doesn't define it (in winnt.h).  ntdll.h needs the
definition for declaring NtMapViewOfSectionEx.  cygpath.cc and ps.cc
both include ntdll.h but not winlean.h, so they complain about the
missing definition.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: mmap_alloc: fix comment to document using the extended memory API

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: threads: use extended memory API if available

So far Cygwin was jumping through hoops to restrict memory
allocation to specific regions.  With the advent of VirtualAlloc2
and MapViewOfFile3 (and it's NT counterpart NtMapViewOfSectionEx),
we can skip searching for free space in the specific regions
and just call these functions and let the OS do the job more
efficiently and less racy.

Use VirtualAlloc2 on W10 1803 and later in thread stack allocation.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: mmap: use extended memory API if available

So far Cygwin was jumping through hoops to restrict memory
allocation to specific regions.  With the advent of VirtualAlloc2
and MapViewOfFile3 (and it's NT counterpart NtMapViewOfSectionEx),
we can skip searching for free space in the specific regions
and just call these functions and let the OS do the job more
efficiently and less racy.

Use the new functions on W10 1803 and later in mmap.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: memory: declare extended memory API

Windows 10 1803 introduced an extended memory API allowing
to specify memory regions allocations are to be taken off.

In preparation of using this API, define the struct
MEM_EXTENDED_PARAMETER and friends.  Declare and allow to
autoload the functions VirtualAlloc2 and NtMapViewOfSectionEx.

Introduce a wincap flag has_extended_mem_api.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: threads: add missing include of mmap_alloc.h

This is needed for using mmap_alloc.alloc()

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: threads: lower thread size from pool to 256 Megs

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: threads: use mmap area to fulfill requests for big stacks

Otherwise big stacks have a higher probability to collide with
randomized PEBs and TEBs after fork.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: symlinks: Allow traversing WSL symlinks

Unfortunately Windows doesn't understand WSL symlinks,
despite being a really easy job.  NT functions trying
to access paths traversing WSL symlinks return the status
code STATUS_IO_REPARSE_TAG_NOT_HANDLED.  Handle this
status code same as STATUS_OBJECT_PATH_NOT_FOUND in
symlink_info::check to align behaviour to traversing
paths with other non-NTFS type symlinks.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: docs: revamp docs explaining symlinks

The descriptions of symlink handling are a bit dated, so
revamp them and add the new WSL symlink type.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: symlinks: create WSL symlinks on supporting filesystems

WSL symlinks are reparse points containing a POSIX path in UTF-8.
On filesystems supporting reparse points, use this symlink type.
On other filesystems, or in case of error, fall back to the good
old plain SYSTEM file.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: symlinks: fix WSL symlinks pointing to /mnt

Commit 4a36897af392 allowed to convert /mnt/<drive> path
prefixes to Cygwin cygdrive prefixes on the fly.  However,
the patch neglected WSL symlinks pointing to the /mnt
directory.  Rearrange path conversion so /mnt is converted
to the cygdrive prefix path itself.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

winsup/cygwin: remove defines added in mingw-w64 v7.0.0

Signed-off-by: Biswapriyo Nath <nathbappai@gmail.com>

Cygwin: symlinks: support WSL symlinks

Treat WSL symlinks just like other symlinks.  Convert
absolute paths pointing to Windows drives via
/mnt/<driveletter> to Windows-style paths <driveletter>:

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: fix GCC warning

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

newlib/libm/math: Make pow/powf return qnan for snan arg

The IEEE spec for pow only has special case for x**0 and 1**y when x/y
are quiet NaN. For signaling NaN, the general case applies and these functions
should signal the invalid exception and return a quiet NaN.

Signed-off-by: Keith Packard <keithp@keithp.com>

newlib/libm/common: Don't re-convert float to bits in modf/modff

These functions shared a pattern of re-converting the argument to bits
when returning +/-0. Skip that as the initial conversion still has the
sign bit.

Signed-off-by: Keith Packard <keithp@keithp.com>

newlib/libm/common: Fix modf/modff returning snan

Recent GCC appears to elide multiplication by 1, which causes snan
parameters to be returned unchanged through *iptr. Use the existing
conversion of snan to qnan to also set the correct result in *iptr
instead.

Signed-off-by: Keith Packard <keithp@keithp.com>

Fix spurious underflow exceptions for Bessel functions for double(from glibc bug 14155)

This fix comes from glibc, from files which originated from
the same place as the newlib files. Those files in glibc carry
the same license as the newlib files.

Bug 14155 is spurious underflow exceptions from Bessel functions for
large arguments.  (The correct results for large x are roughly
constant * sin or cos (x + constant) / sqrt (x), so no underflow
exceptions should occur based on the final result.)

There are various places underflows may occur in the intermediate
calculations that cause the failures listed in that bug.  This patch
fixes problems for the double version where underflows occur in
calculating the intermediate functions P and Q (in particular, x**-12
gets computed while calculating Q).  Appropriate approximations are
used for P and Q for arguments at least 0x1p28 and above to avoid the
underflows.

For sufficiently large x - 0x1p129 and above - the code already has a
cut-off to avoid calculating P and Q at all, which means the
approximations -0.125 / x and 0.375 / x can't themselves cause
underflows calculating Q.  This cut-off is heuristically reasonable
for the point beyond which Q can be neglected (based on expecting
around 0x1p-64 to be the least absolute value of sin or cos for large
arguments representable in double).

The float versions use a cut-off 0x1p17, which is less heuristically
justifiable but should still only affect values near zeroes of the
Bessel functions where these implementations are intrinsically
inaccurate anyway (bugs 14469-14472), and should serve to avoid
underflows (the float underflow for jn in bug 14155 probably comes
from the recurrence to compute jn).  ldbl-96 uses 0x1p129, which may
not really be enough heuristically (0x1p143 or so might be safer - 143
= 64 + 79, number of mantissa bits plus total number of significant
bits in representation) but again should avoid underflows and only
affect values where the code is substantially inaccurate anyway.
ldbl-128 and ldbl-128ibm share a completely different implementation
with no such cut-off, which I propose to fix separately.

Signed-off-by: Keith Packard <keithp@keithp.com>

Revert "Cygwin: serial: read: if VMIN > 0, wait for VMIN chars in inbound queue"

This reverts commit 082f2513c721e942d0fd563c4dc9117eee3513ab.

Turns out, Linux as well as BSD really only wait for the smaller
number, MIN or # of requested bytes.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

fhandler_serial: fix comments

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: read: if VMIN > 0, wait for VMIN chars in inbound queue

Per termios, read waits for MIN chars even if the number of requested
bytes is less.  This requires to add WaitCommEvent to wait non-busily
for MIN chars prior to calling ReadFile, so, reintroduce it.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: use per call OVERLAPPED structs

Sharing the OVERLAPPED struct and event object in there between
read and select calls in the fhandler might have been a nice
optimization way back when, but it is a dangerous, not thread-safe
approach.  Fix this by creating per-fhandler, per-call OVERLAPPED
structs and event objects on demand.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: select: call ClearCommError prior to calling WaitCommEvent

This (hopefully) eliminates a race condition

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: select: fix WaitCommEvent request

- make sure event object is reset
- set read_ready to true if WaitCommEvent returns success
- improve debugging

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: tcsetattr: set timeouts unconditionally

tcsetattr checks if the VTIME and VMIN values changed and only
calls SetCommTimeouts if so.  That's a problem if tcsetattr
is supposed to set VTIME and VIMN to 0, because these are the
start values anyway.  But this requires to set ReadIntervalTimeout
to MAXDWORD, which just doesn't happen.

Fix this by dropping the over-optimization of checking the old
values before calling SetCommTimeouts,

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: avoid overrun of vtime

After changing the type of fhandler_serial::vtime_ to cc_t, vtime_
must be stored in 10s of seconds, not in milliseconds.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: select: fix previous revamp patch

- We need a verify function.
- The event object referenced in WaitCommEvent must not be a local var,
  move it into fhandler_serial.

Cygwin: serial: revamp overlapped IO in read and select

Get rid of WaitCommEvent and using overlapped_armed to share the
same overlapped operation between read and select.  Rather, make
sure to cancel the overlapped IO before leaving any of these functions.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: read: revamp raw_read, change vmin_ and vtime_ to cc_t

- Datatypes were incorrect, especially vmin_ and vtime_.
  Change them to cc_t, as in user space.

- Error checking had a gap or two.  Debug output used the
  wrong formatting.

- Don't use ev member for ClearCommError and WaitCommEvent.
  Both returned values are different (error value vs. event
  code).  The values are not used elsewhere so it doesn't make
  sense to store them in the object.  Therefore, drop ev member.

- Some variable names were not very helpful.  Especially using
  n as lpNumberOfBytesTransferred from GetOverlappedResult and
  then actually printing it as if it makes sense was quite
  puzzeling.

- Rework the loop and the definition of minchars so that it
  still makes sense when looping.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: serial: select: simplify peek_serial

- Don't use ev member for ClearCommError and WaitCommEvent.
  Both returned values are different (error value vs. event
  code).  The values are not used elsewhere so it doesn't make
  sense to store them in the object.

- Drop local variable ready which is used inconsequentially.

- Since WFSO already waits 10 ms, don't wait again if no char
  is in the inbound queue.

- Avoid else if chains.

- Only print one line of debug output on error.

- Drop overlapped_armed < 0 check.  This value is only set in
  fhandler_serial::raw_read if VTIME > 0, and even then it's only
  set to be immediately reset to 0 before calling ReadFile.  So
  overlapped_armed is never actually < 0 when calling select.

- Fix a screwed up statement order.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

Cygwin: Use a separate Start Menu folder for WoW64 installs

This aligns the shortcuts to documentation with the setup changes in
https://sourceware.org/pipermail/cygwin-apps/2020-March/039873.html

v2:
Create/remove the Start Menu directory as needed/possible
Correctly use that directory when making shortcuts

Fix hypotf missing mask in hi+lo decomposition

Add the missing mask for the decomposition of hi+lo which caused some
errors of 1-2 ULP.

This change is taken over from FreeBSD:
https://github.com/freebsd/freebsd/commit/95436ce20dab5a34ba46373410b96411b1734578

Additionally I've removed some variable assignments which were never
read before being overwritten again in the next 2 lines.

Fix modf/f for NaN input

For NaN input the modf/f procedures should return NaN instead of zero
with the sign of the input.

Fix for k_tan.c specific inputs

This fix for k_tan.c is a copy from fdlibm version 5.3 (see also
http://www.netlib.org/fdlibm/readme), adjusted to use the macros
available in newlib (SET_LOW_WORD).

This fix reduces the ULP error of the value shown in the fdlibm readme
(tan(1.7765241907548024E+269)) to 0.45 (thereby reducing the error by
1).

This issue only happens for large numbers that get reduced by the range
reduction to a value smaller in magnitude than 2^-28, that is also
reduced an uneven number of times. This seems rather unlikely given that
one ULP is (much) larger than 2^-28 for the values that may cause an
issue.  Although given the sheer number of values a double can
represent, it is still possible that there are more affected values,
finding them however will be quite hard, if not impossible.

We also took a look at how another library (libm in FreeBSD) handles the
issue: In FreeBSD the complete if branch which checks for values smaller
than 2^-28 (or rather 2^-27, another change done by FreeBSD) is moved
out of the kernel function and into the external function. This means
that the value that gets checked for this condition is the unreduced
value. Therefore the input value which caused a problem in the
fdlibm/newlib kernel tan will run through the full polynomial, including
the careful calculation of -1/(x+r). So the difference is really whether
r or y is used. r = y + p with p being the result of the polynomial with
1/3*x^3 being the largest (and magnitude defining) value. With x being
<2^-27 we therefore know that p is smaller than y (y has to be at least
the size of the value of x last mantissa bit divided by 2, which is at
least x*2^-51 for doubles) by enough to warrant saying that r ~ y.  So
we can conclude that the general implementation of this special case is
the same, FreeBSD simply has a different philosophy on when to handle
especially small numbers.

Cygwin: serial: wait for CancelIo completion

Per https://devblogs.microsoft.com/oldnewthing/20110202-00/?p=11613
GetOverlappedResult must be called blocking, waiting for the overlapped
operation to complete.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

RTEMS: Include missing header and fix stub

Signed-off-by: Sebastian Huber <sebastian.huber@embedded-brains.de>

Cygwin: pty: Add FreeConsole to destructor of pty slave.

- When pseudo console is closed, all the processes attched to the
  pseudo console are terminated. This causes the problem reported
  in https://sourceware.org/pipermail/cygwin/2020-March/244046.html.
  This patch fixes the issue.