From: Takashi Yano <takashi.yano@nifty.ne.jp>
To: cygwin-developers@cygwin.com
Subject: Re: cygrunsrv + sshd + rsync = 20 times too slow -- throttled?
Date: Mon, 6 Sep 2021 20:16:43 +0900 [thread overview]
Message-ID: <20210906201643.2e84c0d3a7ac7c8878548408@nifty.ne.jp> (raw)
In-Reply-To: <YTXNlorVXX5GIPy0@calimero.vinschen.de>
[-- Attachment #1: Type: text/plain, Size: 4027 bytes --]
Hi Corinna,
On Mon, 6 Sep 2021 10:13:10 +0200
Corinna Vinschen wrote:
> On Sep 6 05:09, Takashi Yano wrote:
> > On Sun, 5 Sep 2021 14:47:26 -0400
> > Ken Brown wrote:
> > > On 9/5/2021 9:50 AM, Takashi Yano wrote:
> > > > On Sun, 5 Sep 2021 22:40:59 +0900
> > > > Takashi Yano wrote:
> > > >> On Sun, 5 Sep 2021 08:15:23 +0900
> > > >> Takashi Yano wrote:
> > > >>> On Sat, 4 Sep 2021 10:04:12 -0400
> > > >>> Ken Brown wrote:
> > > >>>> On 9/4/2021 8:37 AM, Takashi Yano wrote:
> > > >>>>> On Sat, 4 Sep 2021 21:02:58 +0900
> > > >>>>> Takashi Yano wrote:
> > > >>>>>> On Fri, 3 Sep 2021 09:27:37 -0400
> > > >>>>>> Ken Brown wrote:
> > > >>>>>>> On 9/3/2021 8:22 AM, Takashi Yano wrote:
> > > >>>>>>>> POSIX says:
> > > >>>>>>>> The value returned may be less than nbyte if the number of bytes left
> > > >>>>>>>> in the file is less than nbyte, if the read() request was interrupted
> > > >>>>>>>> by a signal, or if the file is a pipe or FIFO or special file and has
> > > >>>>>>>> ~~~
> > > >>>>>>>> fewer than nbyte bytes immediately available for reading.
> > > >>>>>>>> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > > >>>>>>>>
> > > >>>>>>>> https://pubs.opengroup.org/onlinepubs/009604599/functions/read.html
> > > >>>>>>>>
> > > >>>>>>>> If it is turned over, read() should read all data immediately available,
> > > >>>>>>>> I think.
> > > >>>>>>> [...]
> > > >>>>>> Corinna Vinschen wrote:
> > > >>>>>>> We can't keep the mutex while waiting on the pending read, and there
> > > >>>>>>> could be more than one pending read running at the time. if so,
> > > >>>>>>> chances are extremly high, that the data written to the buffer gets
> > > >>>>>>> split like this:
> > > >>>>>>> [...]
> > > >>>>> Takashi Yano wrote:
> > > >>>>>> Why can't we keep the mutex while waiting on the pending read?
> > > >>>>>> If we can keep the mutex, the issue above mentioned does not
> > > >>>>>> happen, right?
> > [...]
> > @@ -239,43 +237,51 @@ fhandler_pipe::raw_read (void *ptr, size_t& len)
> > return;
> > }
> >
> > - do
> > + DWORD timeout = is_nonblocking () ? 0 : INFINITE;
> > + if (WAIT_TIMEOUT == WaitForSingleObject (read_mtx, timeout))
>
> My code was originally not supposed to serialise the readers. The
> mutex block should be short lived and only create an atomic block
> for the two calls NtQueryInformationFile and NtReadFile.
>
> If you have multiple readers, all but one of them will hang in this
> WFSO. They will block here without a chance to kill or Ctrl-C them
> and thread cancellation won't work.
>
> To fix that you have to use cygwait and handle signals and thread
> cancellation the same way as in the below code following the NtReadFile.
OK. Thanks for the advice. Then what about the patch attached?
> > /* If the pipe is empty, don't request more bytes than half the
> > - pipe buffer size. Every pending read lowers WriteQuotaAvailable
> > - on the write side and thus affects select's ability to return
> > - more or less reliable info whether a write succeeds or not.
> > -
> > - Let the size of the request depend on the number of readers
> > - at the time. */
> > + pipe buffer size. Pending read lowers WriteQuotaAvailable on
> > + the write side and thus affects select's ability to return
> > + more or less reliable info whether a write succeeds or not. */
> > + ULONG chunk = max_atomic_write / 2;
> > status = NtQueryInformationFile (get_handle (), &io,
> > &fpli, sizeof (fpli),
> > FilePipeLocalInformation);
> > - if (NT_SUCCESS (status) && fpli.ReadDataAvailable == 0)
>
> If the readers are serialized anyway, why fetch only half the remaining
> buffer size? In that case fetching fpli.InboundQuota - 1 is as good
> as fetching just the half of it, isn't it?
It sounds reasonable. Adopted in the attached patch.
--
Takashi Yano <takashi.yano@nifty.ne.jp>
[-- Attachment #2: 0001-Cygwin-pipe-Stop-counting-reader-and-read-all-availa.patch --]
[-- Type: application/octet-stream, Size: 5370 bytes --]
From 0bb2ea9e552f8cb788c097519174145cd368b45b Mon Sep 17 00:00:00 2001
From: Takashi Yano <takashi.yano@nifty.ne.jp>
Date: Mon, 6 Sep 2021 20:12:16 +0900
Subject: [PATCH] Cygwin: pipe: Stop counting reader and read all available
data.
- By guarding read with read_mtx, no more than one ReadFile can
be called simultaneously. So couting read handles is no longer
necessary.
- Make raw_read code as similar as possible to raw_write code.
---
winsup/cygwin/fhandler_pipe.cc | 100 ++++++++++++++++++++-------------
1 file changed, 60 insertions(+), 40 deletions(-)
diff --git a/winsup/cygwin/fhandler_pipe.cc b/winsup/cygwin/fhandler_pipe.cc
index 68974eb80..fe0bf0ca2 100644
--- a/winsup/cygwin/fhandler_pipe.cc
+++ b/winsup/cygwin/fhandler_pipe.cc
@@ -221,12 +221,10 @@ fhandler_pipe::get_proc_fd_name (char *buf)
void __reg3
fhandler_pipe::raw_read (void *ptr, size_t& len)
{
- NTSTATUS status;
+ size_t nbytes = 0;
+ NTSTATUS status = STATUS_SUCCESS;
IO_STATUS_BLOCK io;
HANDLE evt = NULL;
- DWORD waitret = WAIT_OBJECT_0;
- bool keep_looping = false;
- size_t orig_len = len;
if (!len)
return;
@@ -239,43 +237,59 @@ fhandler_pipe::raw_read (void *ptr, size_t& len)
return;
}
- do
+ DWORD timeout = is_nonblocking () ? 0 : INFINITE;
+ DWORD waitret = cygwait (read_mtx, timeout);
+ switch (waitret)
{
- len = orig_len;
- keep_looping = false;
+ case WAIT_OBJECT_0:
+ break;
+ case WAIT_TIMEOUT:
+ set_errno (EAGAIN);
+ len = (size_t) -1;
+ return;
+ default:
+ set_errno (EINTR);
+ len = (size_t) -1;
+ return;
+ }
+ while (nbytes < len)
+ {
+ ULONG_PTR nbytes_now = 0;
+ size_t left = len - nbytes;
+ ULONG len1 = (ULONG) left;
+ waitret = WAIT_OBJECT_0;
+
if (evt)
ResetEvent (evt);
if (!is_nonblocking ())
{
FILE_PIPE_LOCAL_INFORMATION fpli;
- ULONG reader_count;
- ULONG max_len = 64;
-
- WaitForSingleObject (read_mtx, INFINITE);
- /* If the pipe is empty, don't request more bytes than half the
- pipe buffer size. Every pending read lowers WriteQuotaAvailable
- on the write side and thus affects select's ability to return
- more or less reliable info whether a write succeeds or not.
-
- Let the size of the request depend on the number of readers
- at the time. */
+ /* If the pipe is empty, don't request more bytes than pipe
+ buffer size - 1. Pending read lowers WriteQuotaAvailable on
+ the write side and thus affects select's ability to return
+ more or less reliable info whether a write succeeds or not. */
+ ULONG chunk = max_atomic_write - 1;
status = NtQueryInformationFile (get_handle (), &io,
&fpli, sizeof (fpli),
FilePipeLocalInformation);
- if (NT_SUCCESS (status) && fpli.ReadDataAvailable == 0)
+ if (NT_SUCCESS (status))
{
- reader_count = get_obj_handle_count (get_handle ());
- if (reader_count < 10)
- max_len = fpli.InboundQuota / (2 * reader_count);
- if (len > max_len)
- len = max_len;
+ if (fpli.ReadDataAvailable > 0)
+ chunk = left;
+ else if (nbytes != 0)
+ break;
+ else
+ chunk = fpli.InboundQuota - 1;
}
+ else if (nbytes != 0)
+ break;
+
+ if (len1 > chunk)
+ len1 = chunk;
}
status = NtReadFile (get_handle (), evt, NULL, NULL, &io, ptr,
- len, NULL, NULL);
- if (!is_nonblocking ())
- ReleaseMutex (read_mtx);
+ len1, NULL, NULL);
if (evt && status == STATUS_PENDING)
{
waitret = cygwait (evt);
@@ -292,13 +306,13 @@ fhandler_pipe::raw_read (void *ptr, size_t& len)
set_errno (EBADF);
else
__seterrno ();
- len = (size_t) -1;
+ nbytes = (size_t) -1;
}
else if (NT_SUCCESS (status))
{
- len = io.Information;
- if (len == 0)
- keep_looping = true;
+ nbytes_now = io.Information;
+ ptr = ((char *) ptr) + nbytes_now;
+ nbytes += nbytes_now;
}
else
{
@@ -308,40 +322,46 @@ fhandler_pipe::raw_read (void *ptr, size_t& len)
case STATUS_END_OF_FILE:
case STATUS_PIPE_BROKEN:
/* This is really EOF. */
- len = 0;
break;
case STATUS_MORE_ENTRIES:
case STATUS_BUFFER_OVERFLOW:
/* `io.Information' is supposedly valid. */
- len = io.Information;
- if (len == 0)
- keep_looping = true;
+ nbytes_now = io.Information;
+ ptr = ((char *) ptr) + nbytes_now;
+ nbytes += nbytes_now;
break;
case STATUS_PIPE_LISTENING:
case STATUS_PIPE_EMPTY:
+ if (nbytes != 0)
+ break;
if (is_nonblocking ())
{
set_errno (EAGAIN);
- len = (size_t) -1;
+ nbytes = (size_t) -1;
break;
}
fallthrough;
default:
__seterrno_from_nt_status (status);
- len = (size_t) -1;
+ nbytes = (size_t) -1;
break;
}
}
- } while (keep_looping);
+
+ if (nbytes_now == 0)
+ break;
+ }
+ ReleaseMutex (read_mtx);
if (evt)
CloseHandle (evt);
- if (status == STATUS_THREAD_SIGNALED)
+ if (status == STATUS_THREAD_SIGNALED && nbytes == 0)
{
set_errno (EINTR);
- len = (size_t) -1;
+ nbytes = (size_t) -1;
}
else if (status == STATUS_THREAD_CANCELED)
pthread::static_cancel_self ();
+ len = nbytes;
}
ssize_t __reg3
--
2.33.0
next prev parent reply other threads:[~2021-09-06 11:16 UTC|newest]
Thread overview: 250+ messages / expand[flat|nested] mbox.gz Atom feed top
[not found] <41A583E1-C8E7-42AB-9F24-EEC33A41EC60@house.org>
[not found] ` <20210825201845.07b6400b79dc5558a7761efe@nifty.ne.jp>
[not found] ` <f8106fe7-a2b8-d106-3061-4d888124f4b0@cornell.edu>
[not found] ` <20210826062934.54f2f2216021c095bb7ba13b@nifty.ne.jp>
[not found] ` <d0a8c57d-1ed1-6b4f-c6e7-cbe0e2ec8a1c@cornell.edu>
[not found] ` <3b560051-ab27-f392-ca4b-d1fd9b5733b0@cornell.edu>
[not found] ` <20210827202440.47706fc2fc07c5e9a1bc0047@nifty.ne.jp>
[not found] ` <4f2cb5f3-ce9c-c617-f65f-841a5eca096e@cornell.edu>
[not found] ` <20210828022111.91ef5b4ff24f6da9fadb489e@nifty.ne.jp>
[not found] ` <YSn3L0W1M527utK0@calimero.vinschen.de>
[not found] ` <20210828184102.f2206a8a9e5fe5cf24bf5e45@nifty.ne.jp>
[not found] ` <YSok0PoCQn2TPPrn@calimero.vinschen.de>
[not found] ` <20210829004346.c2f80469abc3a07fd4b2918d@nifty.ne.jp>
[not found] ` <e8caa02f-be85-33bc-3f09-347c1cdb0923@cornell.edu>
[not found] ` <20210829174124.0c1ae6c16a3e8da1f490abc7@nifty.ne.jp>
[not found] ` <6e9bb35e-6f4f-cf78-e515-549da487b5ef@cornell.edu>
2021-08-30 7:57 ` Corinna Vinschen
[not found] ` <20210829180729.48b4e877f773cb3980c5766d@nifty.ne.jp>
[not found] ` <789f056a-f164-d71d-1dc9-230f5a41846d@cornell.edu>
2021-08-30 8:27 ` Corinna Vinschen
2021-08-30 13:00 ` Corinna Vinschen
2021-08-30 13:20 ` Corinna Vinschen
2021-08-30 13:41 ` Ken Brown
2021-08-30 14:12 ` Corinna Vinschen
2021-08-30 14:52 ` Ken Brown
2021-08-30 15:15 ` Corinna Vinschen
[not found] ` <20210830043756.8aa0ada77db0bfbbe3889f62@nifty.ne.jp>
[not found] ` <47e5dd74-b940-f305-fd5a-c6c9d8f41305@cornell.edu>
2021-08-30 8:48 ` Corinna Vinschen
[not found] ` <c62d18df-ab7a-7233-62ee-29a8eced5353@cornell.edu>
[not found] ` <20210830091314.f9a2cb71794d0f68cdb5eba7@nifty.ne.jp>
[not found] ` <20210830092259.52f7d54fc3fa340738373af4@nifty.ne.jp>
[not found] ` <d217ef03-7858-5e22-0aa6-f0507eedd9da@cornell.edu>
[not found] ` <20210830170204.fa91eaf110f310f13b67abc3@nifty.ne.jp>
2021-08-30 10:20 ` Corinna Vinschen
2021-08-30 10:38 ` Corinna Vinschen
2021-08-30 12:04 ` Takashi Yano
2021-08-30 12:55 ` Corinna Vinschen
2021-08-30 13:31 ` Corinna Vinschen
2021-08-31 8:50 ` Takashi Yano
2021-08-30 13:51 ` Ken Brown
2021-08-30 15:00 ` Ken Brown
2021-08-30 15:19 ` Corinna Vinschen
2021-08-30 15:43 ` Ken Brown
2021-08-31 9:43 ` Corinna Vinschen
2021-08-31 8:52 ` Takashi Yano
2021-08-31 9:04 ` Corinna Vinschen
2021-08-31 11:05 ` Takashi Yano
2021-08-31 15:20 ` Corinna Vinschen
2021-09-01 2:39 ` Takashi Yano
2021-09-01 8:03 ` Corinna Vinschen
2021-09-01 8:13 ` Corinna Vinschen
2021-08-30 13:36 ` Ken Brown
2021-08-30 14:05 ` Corinna Vinschen
2021-08-30 15:53 ` Corinna Vinschen
2021-08-30 17:00 ` Corinna Vinschen
2021-08-30 17:11 ` Corinna Vinschen
2021-08-30 18:59 ` Ken Brown
2021-08-30 19:12 ` Ken Brown
2021-08-30 20:21 ` Corinna Vinschen
2021-08-30 20:14 ` Corinna Vinschen
2021-08-30 20:47 ` Ken Brown
2021-08-31 8:55 ` Takashi Yano
2021-08-31 9:08 ` Corinna Vinschen
2021-08-31 9:25 ` Takashi Yano
2021-08-31 10:05 ` Corinna Vinschen
2021-08-31 10:18 ` Corinna Vinschen
2021-08-31 11:45 ` Takashi Yano
2021-08-31 12:31 ` Takashi Yano
2021-08-31 15:08 ` Corinna Vinschen
2021-08-31 12:33 ` Ken Brown
2021-08-31 15:18 ` Corinna Vinschen
2021-08-31 15:27 ` Corinna Vinschen
2021-08-31 15:50 ` Corinna Vinschen
2021-08-31 16:19 ` Ken Brown
2021-08-31 16:38 ` Ken Brown
2021-08-31 17:30 ` Corinna Vinschen
2021-08-31 18:54 ` Ken Brown
2021-08-31 19:51 ` Corinna Vinschen
2021-08-31 23:02 ` Takashi Yano
2021-09-01 0:16 ` Takashi Yano
2021-09-01 8:07 ` Corinna Vinschen
2021-09-01 8:23 ` Takashi Yano
2021-09-01 8:46 ` Corinna Vinschen
2021-09-01 12:56 ` Ken Brown
2021-09-01 13:52 ` Corinna Vinschen
2021-09-01 23:02 ` Ken Brown
2021-09-02 8:17 ` Corinna Vinschen
2021-09-02 13:01 ` Ken Brown
2021-09-02 19:00 ` Corinna Vinschen
2021-09-02 19:34 ` Ken Brown
2021-09-02 19:35 ` Corinna Vinschen
2021-09-02 20:19 ` Ken Brown
2021-09-03 9:12 ` Corinna Vinschen
2021-09-03 19:00 ` Ken Brown
2021-09-03 19:53 ` Ken Brown
2021-09-03 19:54 ` Corinna Vinschen
2021-09-03 20:05 ` Ken Brown
2021-09-03 10:00 ` Takashi Yano
2021-09-03 10:13 ` Takashi Yano
2021-09-03 11:31 ` Corinna Vinschen
2021-09-03 11:41 ` Corinna Vinschen
2021-09-03 12:13 ` Ken Brown
2021-09-03 15:00 ` Corinna Vinschen
2021-09-03 15:14 ` Ken Brown
2021-09-03 15:17 ` Corinna Vinschen
2021-09-03 12:22 ` Takashi Yano
2021-09-03 13:27 ` Ken Brown
2021-09-03 15:37 ` Corinna Vinschen
2021-09-04 12:02 ` Takashi Yano
2021-09-04 12:37 ` Takashi Yano
2021-09-04 14:04 ` Ken Brown
2021-09-04 23:15 ` Takashi Yano
2021-09-05 13:40 ` Takashi Yano
2021-09-05 13:50 ` Takashi Yano
2021-09-05 18:47 ` Ken Brown
2021-09-05 19:42 ` Takashi Yano
2021-09-05 20:09 ` Takashi Yano
2021-09-05 20:27 ` Ken Brown
2021-09-06 8:13 ` Corinna Vinschen
2021-09-06 11:16 ` Takashi Yano [this message]
2021-09-06 12:49 ` Corinna Vinschen
2021-09-06 13:16 ` Takashi Yano
2021-09-06 16:08 ` Corinna Vinschen
2021-09-06 23:39 ` Takashi Yano
2021-09-07 9:14 ` Corinna Vinschen
2021-09-07 11:03 ` Takashi Yano
2021-09-07 16:14 ` Ken Brown
2021-09-07 18:26 ` Corinna Vinschen
2021-09-03 10:38 ` Takashi Yano
2021-09-08 11:32 ` Takashi Yano
2021-09-08 11:55 ` Corinna Vinschen
2021-09-08 12:33 ` Takashi Yano
2021-09-08 17:43 ` Ken Brown
2021-09-08 18:28 ` Corinna Vinschen
2021-09-02 8:15 ` Takashi Yano
2021-09-02 18:54 ` Corinna Vinschen
2021-09-07 3:26 ` Takashi Yano
2021-09-07 10:50 ` Takashi Yano
2021-09-08 0:07 ` Takashi Yano
2021-09-08 4:11 ` Takashi Yano
2021-09-08 9:01 ` Takashi Yano
2021-09-08 9:01 ` Corinna Vinschen
2021-09-08 9:26 ` Corinna Vinschen
2021-09-08 9:45 ` Takashi Yano
2021-09-08 10:04 ` Corinna Vinschen
2021-09-08 10:45 ` Takashi Yano
2021-09-08 10:51 ` Corinna Vinschen
2021-09-09 3:21 ` Takashi Yano
2021-09-09 9:37 ` Corinna Vinschen
2021-09-09 10:55 ` Takashi Yano
2021-09-09 11:41 ` Corinna Vinschen
2021-09-08 9:37 ` Takashi Yano
2021-09-09 3:41 ` Takashi Yano
2021-09-09 8:05 ` Takashi Yano
2021-09-09 12:19 ` Takashi Yano
2021-09-09 12:42 ` Takashi Yano
2021-09-09 21:53 ` Takashi Yano
2021-09-10 3:41 ` Takashi Yano
2021-09-10 10:57 ` Ken Brown
2021-09-10 15:17 ` Ken Brown
2021-09-10 15:26 ` Corinna Vinschen
2021-09-10 22:57 ` Takashi Yano
2021-09-11 2:17 ` Ken Brown
2021-09-11 2:35 ` Takashi Yano
2021-09-11 13:12 ` Ken Brown
2021-09-12 6:23 ` Takashi Yano
2021-09-12 14:39 ` Ken Brown
2021-09-13 9:11 ` Corinna Vinschen
2021-09-13 12:30 ` Ken Brown
2021-09-12 8:48 ` Takashi Yano
2021-09-12 11:04 ` Takashi Yano
2021-09-12 15:10 ` Ken Brown
2021-09-12 21:46 ` Ken Brown
2021-09-12 23:54 ` Takashi Yano
2021-09-13 2:19 ` Ken Brown
2021-09-13 8:40 ` Takashi Yano
2021-09-13 12:51 ` Ken Brown
2021-09-13 17:05 ` Ken Brown
2021-09-13 9:42 ` Corinna Vinschen
2021-09-13 13:03 ` Ken Brown
2021-09-13 18:39 ` Takashi Yano
2021-09-12 23:41 ` Takashi Yano
2021-09-13 17:42 ` Ken Brown
2021-09-13 18:54 ` Takashi Yano
2021-09-13 18:32 ` Corinna Vinschen
2021-09-13 19:37 ` Takashi Yano
2021-09-13 20:15 ` Corinna Vinschen
2021-09-14 8:07 ` Takashi Yano
2021-09-14 8:47 ` Corinna Vinschen
2021-09-14 12:38 ` Ken Brown
2021-09-14 14:15 ` Corinna Vinschen
2021-09-14 8:08 ` Takashi Yano
2021-09-14 9:03 ` Corinna Vinschen
2021-09-14 9:56 ` Takashi Yano
2021-09-14 10:19 ` Takashi Yano
2021-09-14 11:03 ` Corinna Vinschen
2021-09-14 12:05 ` Takashi Yano
2021-09-14 14:17 ` Corinna Vinschen
2021-09-14 22:14 ` Ken Brown
2021-09-15 0:21 ` Takashi Yano
2021-09-15 0:44 ` Takashi Yano
2021-09-15 0:59 ` Takashi Yano
2021-09-15 9:57 ` Corinna Vinschen
2021-09-15 10:48 ` Takashi Yano
2021-09-15 10:58 ` Takashi Yano
2021-09-15 11:34 ` Corinna Vinschen
2021-09-15 11:40 ` Corinna Vinschen
2021-09-15 11:13 ` Corinna Vinschen
2021-09-15 11:41 ` Ken Brown
2021-09-15 11:49 ` Corinna Vinschen
2021-09-15 11:54 ` Takashi Yano
2021-09-15 12:20 ` Corinna Vinschen
2021-09-15 13:04 ` Takashi Yano
2021-09-15 13:42 ` Corinna Vinschen
2021-09-15 16:22 ` Ken Brown
2021-09-15 17:09 ` Ken Brown
2021-09-16 0:22 ` Takashi Yano
2021-09-16 2:28 ` Ken Brown
2021-09-16 9:09 ` Takashi Yano
2021-09-16 13:02 ` Takashi Yano
2021-09-16 13:25 ` Corinna Vinschen
2021-09-16 14:27 ` Takashi Yano
2021-09-16 15:01 ` Corinna Vinschen
2021-09-16 15:46 ` Ken Brown
2021-09-16 16:02 ` Ken Brown
2021-09-16 19:42 ` Takashi Yano
2021-09-16 20:28 ` Ken Brown
2021-09-16 19:48 ` Ken Brown
2021-09-16 20:01 ` Takashi Yano
2021-09-17 2:25 ` Ken Brown
2021-09-17 8:31 ` Takashi Yano
2021-09-17 11:16 ` Ken Brown
2021-09-17 16:23 ` Takashi Yano
2021-09-17 17:08 ` Ken Brown
2021-09-17 17:39 ` Jon Turney
2021-09-17 17:43 ` Takashi Yano
2021-09-17 19:53 ` Ken Brown
2021-09-18 1:30 ` Takashi Yano
2021-09-18 2:07 ` Ken Brown
2021-09-18 2:10 ` Ken Brown
2021-09-18 8:03 ` Takashi Yano
2021-09-18 11:12 ` Ken Brown
2021-09-18 11:35 ` Takashi Yano
2021-09-18 14:11 ` Jon Turney
2021-09-18 13:44 ` Ken Brown
2021-09-19 1:31 ` Takashi Yano
2021-09-19 14:35 ` Ken Brown
2021-09-20 9:29 ` Takashi Yano
2021-09-16 0:13 ` Takashi Yano
2021-09-16 2:26 ` Ken Brown
2021-09-13 9:07 ` Corinna Vinschen
2021-09-20 12:52 ` Takashi Yano
2021-09-20 19:14 ` Ken Brown
2021-09-20 21:09 ` Ken Brown
2021-09-20 21:21 ` Ken Brown
2021-09-20 21:27 ` Takashi Yano
2021-09-20 21:39 ` Ken Brown
2021-09-20 22:16 ` Takashi Yano
2021-09-20 22:46 ` Ken Brown
2021-09-20 22:50 ` Ken Brown
2021-09-20 23:22 ` Takashi Yano
2021-09-21 8:30 ` Takashi Yano
2021-09-21 9:26 ` Mark Geisert
2021-09-21 10:10 ` Takashi Yano
2021-09-21 21:10 ` Mark Geisert
2021-09-21 13:31 ` Ken Brown
2021-09-21 15:36 ` Takashi Yano
2021-09-21 18:51 ` Ken Brown
2021-09-23 8:26 ` Takashi Yano
2021-09-23 13:03 ` Ken Brown
2021-09-23 15:03 ` Takashi Yano
2021-09-23 16:29 ` Ken Brown
2021-10-18 10:51 ` Corinna Vinschen
2021-10-18 12:02 ` Takashi Yano
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20210906201643.2e84c0d3a7ac7c8878548408@nifty.ne.jp \
--to=takashi.yano@nifty.ne.jp \
--cc=cygwin-developers@cygwin.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).