Befator-Inc-Firmen-Netzwerk/MSYS2-packages
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

msys2-runtime: backport recent fixes

Browse Source 
This corresponds to https://github.com/msys2/msys2-runtime/pull/296.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
This commit is contained in:
Johannes Schindelin
2025-07-01 18:21:30 +02:00
committed by Christoph Reiter
parent 2b2ad8b506
commit ae252e9401
6 changed files with 423 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
msys2-runtime/0042-Cygwin-pipe-Fix-SSH-hang-with-non-cygwin-pipe-reader.patch Normal file
View File

@@ -0,0 +1,111 @@
From 8bd097a5cddf67a38ce1917623c645846c815f20 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Fri, 27 Jun 2025 19:56:02 +0900
Subject: [PATCH 42/N] Cygwin: pipe: Fix SSH hang with non-cygwin pipe reader
If ssh is used with non-cygwin pipe reader, ssh some times hangs.
This happens when non-cygwin git (Git for Windows) starts cygwin
ssh. The background of the bug is as follows.
Before attempting to NtWriteFile() in raw_write() in non-blocking
mode, the amount of writable space in the pipe is checked by calling
NtQueryInformationFile with FilePipeLocalInformation parameter.
The same is also done by pipe_data_available() in select.cc.
However, if the read side of the pipe is simultaneously consuming
data, NtQueryInformationFile() returns less value than the amount
of writable space, i.e. the amount of writable space minus the size
of buffer to be read. This does not happen when the reader is a
cygwin app because cygwin read() for the pipe attempts to read
the amount of the data in the pipe at most. This means NtReadFile()
never enters a pending state. However, if the reader is non-cygwin
app, this cannot be expected. As a workaround for this problem,
the code checking the pipe space temporarily attempts to toggle
the pipe-mode. If the pipe contains data, this operation fails
with STATUS_PIPE_BUSY indicating that the pipe is not empty. If
it succeeds, the pipe is considered empty. The current code uses
this technic only when NtQueryInformationFile() retuns zero.
Therefore, if NtQueryInformationFile() returns 1, the amount of
writable space is assumed to be 1 even in the case that e.g. the
pipe size is 8192 bytes and reader is pending to read 8191 bytes.
Even worse, the current code fails to write more than 1 byte
to 1 byte pipe space due to the remnant of the past design.
Then the reader waits for data with 8191 bytes buffer while the
writer continues to fail to write to 1 byte space of the pipe.
This is the cause of the deadlock.
In practice, when using Git for Windows in combination with Cygwin
SSH, it has been observed that a read of 8191 bytes is occasionally
issued against a pipe with 8192 bytes of available space.
With this patch, the blocking-mode-toggling-check is performed
even if NtQueryInformationFile() returns non-zero value so that
the amount of the writable space in the pipe is always estimated
correctly.
Addresses: https://github.com/git-for-windows/git/issues/5682
Fixes: 7ed9adb356df ("Cygwin: pipe: Switch pipe mode to blocking mode by default")
Reported-by: Vincent-Liem (@github), Johannes Schindelin <johannes.schindelin@gmx.de>
Reviewed-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 5786a8ac4dd9dbc79559f00e3b37538610aec1ad)
---
winsup/cygwin/fhandler/pipe.cc | 15 ++++++++++-----
winsup/cygwin/select.cc | 5 +++--
2 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/winsup/cygwin/fhandler/pipe.cc b/winsup/cygwin/fhandler/pipe.cc
index 506dd09..219ae32 100644
--- a/winsup/cygwin/fhandler/pipe.cc
+++ b/winsup/cygwin/fhandler/pipe.cc
@@ -491,9 +491,9 @@ fhandler_pipe_fifo::raw_write (const void *ptr, size_t len)
FilePipeLocalInformation);
if (NT_SUCCESS (status))
{
- if (fpli.WriteQuotaAvailable != 0)
+ if (fpli.WriteQuotaAvailable == fpli.InboundQuota)
avail = fpli.WriteQuotaAvailable;
- else /* WriteQuotaAvailable == 0 */
+ else /* WriteQuotaAvailable != InboundQuota */
{ /* Refer to the comment in select.cc: pipe_data_available(). */
/* NtSetInformationFile() in set_pipe_non_blocking(true) seems
to fail with STATUS_PIPE_BUSY if the pipe is not empty.
@@ -506,9 +506,14 @@ fhandler_pipe_fifo::raw_write (const void *ptr, size_t len)
fh->set_pipe_non_blocking (false);
else if (status == STATUS_PIPE_BUSY)
{
- /* Full */
- set_errno (EAGAIN);
- goto err;
+ if (fpli.WriteQuotaAvailable == 0)
+ {
+ /* Full */
+ set_errno (EAGAIN);
+ goto err;
+ }
+ avail = fpli.WriteQuotaAvailable;
+ status = STATUS_SUCCESS;
}
}
}
diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc
index bb141b0..0b9afb3 100644
--- a/winsup/cygwin/select.cc
+++ b/winsup/cygwin/select.cc
@@ -649,12 +649,13 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
Therefore, we can distinguish these cases by calling set_pipe_non_
blocking(true). If it returns success, the pipe is empty, so we
return the pipe buffer size. Otherwise, we return 0. */
- if (fh->get_device () == FH_PIPEW && fpli.WriteQuotaAvailable == 0)
+ if (fh->get_device () == FH_PIPEW
+ && fpli.WriteQuotaAvailable < fpli.InboundQuota)
{
NTSTATUS status =
((fhandler_pipe *) fh)->set_pipe_non_blocking (true);
if (status == STATUS_PIPE_BUSY)
- return 0; /* Full */
+ return fpli.WriteQuotaAvailable; /* Not empty */
else if (!NT_SUCCESS (status))
/* We cannot know actual write pipe space. */
return 1;

109
msys2-runtime/0043-Cygwin-pipe-Update-source-comment-align-with-previou.patch Normal file
View File

@@ -0,0 +1,109 @@
From a06fc04a9fe265f2b5bbfca879f901f2c3a9744e Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Fri, 27 Jun 2025 20:02:31 +0900
Subject: [PATCH 43/N] Cygwin: pipe; Update source comment align with previous
commit
The commit "Cygwin: pipe: Fix SSH hang with non-cygwin pipe reader"
modifies how the amount of writable data is evaluated. This patch
updates the source comments to align with that change.
Reviewed-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 82d4ad1dfb28c72d5ce5fd3135ff4dde99e85fca)
---
winsup/cygwin/fhandler/pipe.cc | 8 ++---
winsup/cygwin/select.cc | 54 ++++++++++++++++++----------------
2 files changed, 31 insertions(+), 31 deletions(-)
diff --git a/winsup/cygwin/fhandler/pipe.cc b/winsup/cygwin/fhandler/pipe.cc
index 219ae32..4d5e685 100644
--- a/winsup/cygwin/fhandler/pipe.cc
+++ b/winsup/cygwin/fhandler/pipe.cc
@@ -497,8 +497,8 @@ fhandler_pipe_fifo::raw_write (const void *ptr, size_t len)
{ /* Refer to the comment in select.cc: pipe_data_available(). */
/* NtSetInformationFile() in set_pipe_non_blocking(true) seems
to fail with STATUS_PIPE_BUSY if the pipe is not empty.
- In this case, the pipe is really full if WriteQuotaAvailable
- is zero. Otherwise, the pipe is empty. */
+ In this case, WriteQuotaAvailable indicates real pipe space.
+ Otherwise, the pipe is empty. */
status = fh->set_pipe_non_blocking (true);
if (NT_SUCCESS (status))
/* Pipe should be empty because reader is waiting for data. */
@@ -655,9 +655,7 @@ fhandler_pipe_fifo::raw_write (const void *ptr, size_t len)
if (io.Information > 0 || len <= PIPE_BUF || short_write_once)
break;
/* Independent of being blocking or non-blocking, if we're here,
- the pipe has less space than requested. If the pipe is a
- non-Cygwin pipe, just try the old strategy of trying a half
- write. If the pipe has at
+ the pipe has less space than requested. If the pipe has at
least PIPE_BUF bytes available, try to write all matching
PIPE_BUF sized blocks. If it's less than PIPE_BUF, try
the next less power of 2 bytes. This is not really the Linux
diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc
index 0b9afb3..701f4d9 100644
--- a/winsup/cygwin/select.cc
+++ b/winsup/cygwin/select.cc
@@ -623,32 +623,34 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
if (mode == PDA_WRITE)
{
/* If there is anything available in the pipe buffer then signal
- that. This means that a pipe could still block since you could
- be trying to write more to the pipe than is available in the
- buffer but that is the hazard of select().
-
- Note that WriteQuotaAvailable is unreliable.
-
- Usually WriteQuotaAvailable on the write side reflects the space
- available in the inbound buffer on the read side. However, if a
- pipe read is currently pending, WriteQuotaAvailable on the write side
- is decremented by the number of bytes the read side is requesting.
- So it's possible (even likely) that WriteQuotaAvailable is 0, even
- if the inbound buffer on the read side is not full. This can lead to
- a deadlock situation: The reader is waiting for data, but select
- on the writer side assumes that no space is available in the read
- side inbound buffer.
-
- Consequentially, there are two possibilities when WriteQuotaAvailable
- is 0. One is that the buffer is really full. The other is that the
- reader is currently trying to read the pipe and it is pending.
- In the latter case, the fact that the reader cannot read the data
- immediately means that the pipe is empty. In the former case,
- NtSetInformationFile() in set_pipe_non_blocking(true) will fail
- with STATUS_PIPE_BUSY, while it succeeds in the latter case.
- Therefore, we can distinguish these cases by calling set_pipe_non_
- blocking(true). If it returns success, the pipe is empty, so we
- return the pipe buffer size. Otherwise, we return 0. */
+ that. This means that a pipe could still block since you could
+ be trying to write more to the pipe than is available in the
+ buffer but that is the hazard of select().
+
+ Note that WriteQuotaAvailable is unreliable.
+
+ Usually WriteQuotaAvailable on the write side reflects the space
+ available in the inbound buffer on the read side. However, if a
+ pipe read is currently pending, WriteQuotaAvailable on the write side
+ is decremented by the number of bytes the read side is requesting.
+ So it's possible (even likely) that WriteQuotaAvailable is less than
+ actual space available in the pipe, even if the inbound buffer is
+ empty. This can lead to a deadlock situation: The reader is waiting
+ for data, but select on the writer side assumes that no space is
+ available in the read side inbound buffer.
+
+ Consequentially, there are two possibilities when WriteQuotaAvailable
+ is less than pipe size. One is that the buffer is really not empty.
+ The other is that the reader is currently trying to read the pipe
+ and it is pending.
+ In the latter case, the fact that the reader cannot read the data
+ immediately means that the pipe is empty. In the former case,
+ NtSetInformationFile() in set_pipe_non_blocking(true) will fail
+ with STATUS_PIPE_BUSY, while it succeeds in the latter case.
+ Therefore, we can distinguish these cases by calling set_pipe_non_
+ blocking(true). If it returns success, the pipe is empty, so we
+ return the pipe buffer size. Otherwise, we return the value of
+ WriteQuotaAvailable as is. */
if (fh->get_device () == FH_PIPEW
&& fpli.WriteQuotaAvailable < fpli.InboundQuota)
{

138
msys2-runtime/0044-Cygwin-pipe-Make-pipe_data_available-return-PDA_UNKN.patch Normal file
View File

@@ -0,0 +1,138 @@
From d68858bf3ab1969e2b1f22a3fe0dad2789fdd55f Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Fri, 27 Jun 2025 20:23:11 +0900
Subject: [PATCH 44/N] Cygwin: pipe: Make pipe_data_available() return
PDA_UNKNOWN
... rather than 1 when the pipe space estimation fails, so that
select() and raw_wrie() can perform appropriate fallback handling.
In select(), even if pipe space is unknown, return writable to avoid
deadlock. Even with select() returns writable, write() can blocked
anyway, if data is larger than pipe space. In raw_write(), if the
pipe is real non-blocking mode, attempting to write larger data than
pipe space is safe. Otherwise, return error.
For other cases than FH_PIPEW, PDA_UNKNOWN never orrurs. Therefore,
it is not necessary to handle it in that cases.
Reviewed-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 6d6af651151d48796204d4a358db8ef3c121a501)
---
winsup/cygwin/fhandler/pipe.cc | 7 ++++---
winsup/cygwin/local_includes/select.h | 3 +++
winsup/cygwin/select.cc | 18 +++++++++---------
3 files changed, 16 insertions(+), 12 deletions(-)
diff --git a/winsup/cygwin/fhandler/pipe.cc b/winsup/cygwin/fhandler/pipe.cc
index 4d5e685..f1cfcfc 100644
--- a/winsup/cygwin/fhandler/pipe.cc
+++ b/winsup/cygwin/fhandler/pipe.cc
@@ -663,12 +663,13 @@ fhandler_pipe_fifo::raw_write (const void *ptr, size_t len)
in a very implementation-defined way we can't emulate, but it
resembles it closely enough to get useful results. */
avail = pipe_data_available (-1, this, get_handle (), PDA_WRITE);
- if (avail < 1) /* error or pipe closed */
+ if (avail == PDA_UNKNOWN && real_non_blocking_mode)
+ avail = len1;
+ else if (avail == 0 || !PDA_NOERROR (avail))
+ /* error or pipe closed */
break;
if (avail > len1) /* somebody read from the pipe */
avail = len1;
- if (avail == 1) /* 1 byte left or non-Cygwin pipe */
- len1 >>= 1;
else if (avail >= PIPE_BUF)
len1 = avail & ~(PIPE_BUF - 1);
else
diff --git a/winsup/cygwin/local_includes/select.h b/winsup/cygwin/local_includes/select.h
index 43ceb1d..afc05e1 100644
--- a/winsup/cygwin/local_includes/select.h
+++ b/winsup/cygwin/local_includes/select.h
@@ -143,5 +143,8 @@ ssize_t pipe_data_available (int, fhandler_base *, HANDLE, int);
#define PDA_READ 0x00
#define PDA_WRITE 0x01
+#define PDA_ERROR -1
+#define PDA_UNKNOWN -2
+#define PDA_NOERROR(x) (x >= 0)
#endif /* _SELECT_H_ */
diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc
index 701f4d9..050221a 100644
--- a/winsup/cygwin/select.cc
+++ b/winsup/cygwin/select.cc
@@ -601,7 +601,7 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
if (mode == PDA_READ
&& PeekNamedPipe (h, NULL, 0, NULL, &nbytes_in_pipe, NULL))
return nbytes_in_pipe;
- return -1;
+ return PDA_ERROR;
}
IO_STATUS_BLOCK iosb = {{0}, 0};
@@ -618,7 +618,7 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
access on the write end. */
select_printf ("fd %d, %s, NtQueryInformationFile failed, status %y",
fd, fh->get_name (), status);
- return (mode == PDA_WRITE) ? 1 : -1;
+ return (mode == PDA_WRITE) ? PDA_UNKNOWN : PDA_ERROR;
}
if (mode == PDA_WRITE)
{
@@ -660,7 +660,7 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
return fpli.WriteQuotaAvailable; /* Not empty */
else if (!NT_SUCCESS (status))
/* We cannot know actual write pipe space. */
- return 1;
+ return PDA_UNKNOWN;
/* Restore pipe mode to blocking mode */
((fhandler_pipe *) fh)->set_pipe_non_blocking (false);
/* Empty */
@@ -684,7 +684,7 @@ pipe_data_available (int fd, fhandler_base *fh, HANDLE h, int mode)
return fpli.ReadDataAvailable;
}
if (fpli.NamedPipeState & FILE_PIPE_CLOSING_STATE)
- return -1;
+ return PDA_ERROR;
return 0;
}
@@ -734,7 +734,7 @@ peek_pipe (select_record *s, bool from_select)
if (n == 0 && fh->get_echo_handle ())
n = pipe_data_available (s->fd, fh, fh->get_echo_handle (), PDA_READ);
- if (n < 0)
+ if (n == PDA_ERROR)
{
select_printf ("read: %s, n %d", fh->get_name (), n);
if (s->except_selected)
@@ -775,8 +775,8 @@ out:
}
ssize_t n = pipe_data_available (s->fd, fh, h, PDA_WRITE);
select_printf ("write: %s, n %d", fh->get_name (), n);
- gotone += s->write_ready = (n > 0);
- if (n < 0 && s->except_selected)
+ gotone += s->write_ready = (n > 0 || n == PDA_UNKNOWN);
+ if (n == PDA_ERROR && s->except_selected)
gotone += s->except_ready = true;
}
return gotone;
@@ -989,7 +989,7 @@ out:
ssize_t n = pipe_data_available (s->fd, fh, fh->get_handle (), PDA_WRITE);
select_printf ("write: %s, n %d", fh->get_name (), n);
gotone += s->write_ready = (n > 0);
- if (n < 0 && s->except_selected)
+ if (n == PDA_ERROR && s->except_selected)
gotone += s->except_ready = true;
}
return gotone;
@@ -1415,7 +1415,7 @@ out:
ssize_t n = pipe_data_available (s->fd, fh, h, PDA_WRITE);
select_printf ("write: %s, n %d", fh->get_name (), n);
gotone += s->write_ready = (n > 0);
- if (n < 0 && s->except_selected)
+ if (n == PDA_ERROR && s->except_selected)
gotone += s->except_ready = true;
}
return gotone;

47
msys2-runtime/0045-Cygwin-console-Set-ENABLE_PROCESSED_INPUT-when-disab.patch Normal file
View File

@@ -0,0 +1,47 @@
From ab81aae6d3dd729bda9fde8e3ada9538f7cfbc08 Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Tue, 1 Jul 2025 17:10:34 +0900
Subject: [PATCH 45/N] Cygwin: console: Set ENABLE_PROCESSED_INPUT when
disable_master_thread
Currently, ENABLE_PROCESSED_INPUT is set in set_input_mode() if
master_thread_suspended is true. This enables Ctrl-C handling when
cons_master_thread is suspended, since Ctrl-C is normally handled
by cons_master_thread.
However, when disable_master_thread is true, ENABLE_PROCESSED_INPUT
is not set, even though this also disables Ctrl-C handling in
cons_master_thread. Due to this bug, the command
C:\cygwin64\bin\sleep 10 < NUL
in the Command Prompt cannot be terminated with Ctrl-C.
This patch addresses the issue by setting ENABLE_PROCESSED_INPUT
when either disable_master_thread or master_thread_suspended is true.
This bug also affects cases where non-Cygwin Git (Git for Windows)
launches Cygwin SSH. In such cases, SSH also cannot be terminated
with Ctrl-C.
Addresses: https://github.com/git-for-windows/git/issues/5682#issuecomment-2995983695
Fixes: 746c8116dd4f ("Cygwin: console: Allow pasting very long text input.")
Reported-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Takashi Yano <takashi.yano@nifty.ne.jp>
(cherry picked from commit 476135a24506dd624eb46b50fd634fcd740008ba)
Cherry-picked-from: 61cc419b2b (Cygwin: console: Set ENABLE_PROCESSED_INPUT when disable_master_thread, 2025-07-01))
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
winsup/cygwin/fhandler/console.cc | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/winsup/cygwin/fhandler/console.cc b/winsup/cygwin/fhandler/console.cc
index 08ac045..48c9326 100644
--- a/winsup/cygwin/fhandler/console.cc
+++ b/winsup/cygwin/fhandler/console.cc
@@ -831,7 +831,7 @@ fhandler_console::set_input_mode (tty::cons_mode m, const termios *t,
break;
case tty::cygwin:
flags |= ENABLE_WINDOW_INPUT;
- if (con.master_thread_suspended)
+ if (con.master_thread_suspended || con.disable_master_thread)
flags |= ENABLE_PROCESSED_INPUT;
if (wincap.has_con_24bit_colors () && !con_is_legacy)
flags |= ENABLE_VIRTUAL_TERMINAL_INPUT;

22
msys2-runtime/PKGBUILD
View File

@@ -4,7 +4,7 @@
pkgbase=msys2-runtime
pkgname=('msys2-runtime' 'msys2-runtime-devel')
pkgver=3.6.3
pkgrel=4
pkgrel=5
pkgdesc="Cygwin POSIX emulation engine"
arch=('x86_64')
url="https://www.cygwin.com/"
@@ -70,9 +70,13 @@ source=('msys2-runtime'::git://sourceware.org/git/newlib-cygwin.git#tag=cygwin-$
0038-uname-report-msys2-runtime-commit-hash-too.patch
0039-Cygwin-Adjust-CWD-magic-to-accommodate-for-the-lates.patch
0040-Cygwin-Fix-compatibility-with-w32api-headers-v13.patch
0041-symlink_native-allow-linking-to.patch)
0041-symlink_native-allow-linking-to.patch
0042-Cygwin-pipe-Fix-SSH-hang-with-non-cygwin-pipe-reader.patch
0043-Cygwin-pipe-Update-source-comment-align-with-previou.patch
0044-Cygwin-pipe-Make-pipe_data_available-return-PDA_UNKN.patch
0045-Cygwin-console-Set-ENABLE_PROCESSED_INPUT-when-disab.patch)
sha256sums=('dd3cb54af2f8828d6857a3a595b02b09b23209570e0cc44342f4c9826845fb63'
'eea82d3aac8b57ab34acf1e7dbb6e916f1bdc5106199379517adf2cf5edfd2ab'
'd1cb5288415a08bf06b3bcfd132541ee99e86ddea7e256e82ae108ad9630f1df'
'5538db757661949423563bab5e4f383dfa4ef0cf3301cf43f23b482392554b3b'
'2fb9b2b297797d20cd901eaee2de735e8cdda1c1e5836e9ff77856c0d1216860'
'780977d71e35bbe4c0dcda5272895267d68d635f311e224f7981858f7192a85e'
@@ -113,7 +117,11 @@ sha256sums=('dd3cb54af2f8828d6857a3a595b02b09b23209570e0cc44342f4c9826845fb63'
'd8baf6e0e9c44a60d133f506fc91fa79043543266c6142918fad2c234cf4d0b5'
'c5a5dd5645ce86f83824a2fe50ab3cc9df1211d2983bc18bbd11c608249e31b1'
'519323947b0f80d9416fff31eb981ce2cd9c74a3b42c3cd2f74bca3c8a703aa5'
'2d477d5ebb89c5674686306454356a093765e69719102224c7ab59ac50a7a99e')
'2d477d5ebb89c5674686306454356a093765e69719102224c7ab59ac50a7a99e'
'b22fedf58aa2f3dd591eeb750b69e86c84f1bddc45eb2b22149a5457daded8e5'
'0e13eb36c550203351b9b67152f3655979f1364699ebb4a0ed86bb009f9e082e'
'0757cddac390593764115d01b426ca1248c01ff3a1b1e00d6a6eaf2bfd419b70'
'54b2107b757c686262716ca918377916e08fb4a00f5c19931ffa78fb746e61cc')
# Helper macros to help make tasks easier #
apply_patch_with_msg() {
@@ -192,7 +200,11 @@ prepare() {
0038-uname-report-msys2-runtime-commit-hash-too.patch \
0039-Cygwin-Adjust-CWD-magic-to-accommodate-for-the-lates.patch \
0040-Cygwin-Fix-compatibility-with-w32api-headers-v13.patch \
0041-symlink_native-allow-linking-to.patch
0041-symlink_native-allow-linking-to.patch \
0042-Cygwin-pipe-Fix-SSH-hang-with-non-cygwin-pipe-reader.patch \
0043-Cygwin-pipe-Update-source-comment-align-with-previou.patch \
0044-Cygwin-pipe-Make-pipe_data_available-return-PDA_UNKN.patch \
0045-Cygwin-console-Set-ENABLE_PROCESSED_INPUT-when-disab.patch
}
build() {

2
msys2-runtime/msys2-runtime.commit
View File

@@ -1 +1 @@
bc3e285ac0a2c91080ac68279f0c9fd697a2d9b6
ab81aae6d3dd729bda9fde8e3ada9538f7cfbc08