diff --git a/msys2-runtime/0042-Cygwin-pipe-Fix-SSH-hang-with-non-cygwin-pipe-reader.patch b/msys2-runtime/0042-Cygwin-pipe-Fix-SSH-hang-with-non-cygwin-pipe-reader.patch new file mode 100644 index 00000000..a166cea5 --- /dev/null +++ b/msys2-runtime/0042-Cygwin-pipe-Fix-SSH-hang-with-non-cygwin-pipe-reader.patch @@ -0,0 +1,111 @@ +From 8bd097a5cddf67a38ce1917623c645846c815f20 Mon Sep 17 00:00:00 2001 +From: Takashi Yano +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 +Reviewed-by: Johannes Schindelin +Signed-off-by: Takashi Yano +(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; diff --git a/msys2-runtime/0043-Cygwin-pipe-Update-source-comment-align-with-previou.patch b/msys2-runtime/0043-Cygwin-pipe-Update-source-comment-align-with-previou.patch new file mode 100644 index 00000000..649001c3 --- /dev/null +++ b/msys2-runtime/0043-Cygwin-pipe-Update-source-comment-align-with-previou.patch @@ -0,0 +1,109 @@ +From a06fc04a9fe265f2b5bbfca879f901f2c3a9744e Mon Sep 17 00:00:00 2001 +From: Takashi Yano +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 +Signed-off-by: Takashi Yano +(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) + { diff --git a/msys2-runtime/0044-Cygwin-pipe-Make-pipe_data_available-return-PDA_UNKN.patch b/msys2-runtime/0044-Cygwin-pipe-Make-pipe_data_available-return-PDA_UNKN.patch new file mode 100644 index 00000000..7feab63f --- /dev/null +++ b/msys2-runtime/0044-Cygwin-pipe-Make-pipe_data_available-return-PDA_UNKN.patch @@ -0,0 +1,138 @@ +From d68858bf3ab1969e2b1f22a3fe0dad2789fdd55f Mon Sep 17 00:00:00 2001 +From: Takashi Yano +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 +Signed-off-by: Takashi Yano +(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; diff --git a/msys2-runtime/0045-Cygwin-console-Set-ENABLE_PROCESSED_INPUT-when-disab.patch b/msys2-runtime/0045-Cygwin-console-Set-ENABLE_PROCESSED_INPUT-when-disab.patch new file mode 100644 index 00000000..b67d0d4d --- /dev/null +++ b/msys2-runtime/0045-Cygwin-console-Set-ENABLE_PROCESSED_INPUT-when-disab.patch @@ -0,0 +1,47 @@ +From ab81aae6d3dd729bda9fde8e3ada9538f7cfbc08 Mon Sep 17 00:00:00 2001 +From: Takashi Yano +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 +Signed-off-by: Takashi Yano +(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 +--- + 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; diff --git a/msys2-runtime/PKGBUILD b/msys2-runtime/PKGBUILD index 462c1958..79e06aaa 100644 --- a/msys2-runtime/PKGBUILD +++ b/msys2-runtime/PKGBUILD @@ -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() { diff --git a/msys2-runtime/msys2-runtime.commit b/msys2-runtime/msys2-runtime.commit index eeccbeae..7d6b7614 100644 --- a/msys2-runtime/msys2-runtime.commit +++ b/msys2-runtime/msys2-runtime.commit @@ -1 +1 @@ -bc3e285ac0a2c91080ac68279f0c9fd697a2d9b6 +ab81aae6d3dd729bda9fde8e3ada9538f7cfbc08