1 files changed, 95 insertions, 0 deletions

diff --git a/findutils/xargs.c b/findutils/xargs.c
index 35a06f723..d014669bd 100644
--- a/findutils/xargs.c
+++ b/findutils/xargs.c
@@ -74,6 +74,9 @@
 
 //kbuild:lib-$(CONFIG_XARGS) += xargs.o
 
+#if ENABLE_PLATFORM_MINGW32
+#include <conio.h>
+#endif
 #include "libbb.h"
 #include "common_bufsiz.h"
 
@@ -112,6 +115,9 @@ struct globals {
 #if ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL
         int running_procs;
         int max_procs;
+#if ENABLE_PLATFORM_MINGW32
+        HANDLE *procs;
+#endif
 #endif
         smalluint xargs_exitcode;
 } FIX_ALIASING;
@@ -122,12 +128,61 @@ struct globals {
         G.idx = 0; \
         IF_FEATURE_XARGS_SUPPORT_PARALLEL(G.running_procs = 0;) \
         IF_FEATURE_XARGS_SUPPORT_PARALLEL(G.max_procs = 1;) \
+        IF_FEATURE_XARGS_SUPPORT_PARALLEL(IF_PLATFORM_MINGW32(G.procs = NULL;)) \
         G.xargs_exitcode = 0; \
         IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.repl_str = "{}";) \
         IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.eol_ch = '\n';) \
 } while (0)
 
 
+#if ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL && ENABLE_PLATFORM_MINGW32
+static int wait_for_slot(int *idx)
+{
+        int i;
+
+        /* if less than max_procs running, set status to 0, return next free slot */
+        if (G.running_procs < G.max_procs) {
+                *idx = G.running_procs++;
+                return 0;
+        }
+
+check_exit_codes:
+        for (i = G.running_procs - 1; i >= 0; i--) {
+                DWORD status = 0;
+                if (!GetExitCodeProcess(G.procs[i], &status) ||
+                                status != STILL_ACTIVE) {
+                        CloseHandle(G.procs[i]);
+                        if (i + 1 < G.running_procs)
+                                G.procs[i] = G.procs[G.running_procs - 1];
+                        *idx = G.running_procs - 1;
+                        if (!G.max_procs)
+                                G.running_procs--;
+                        return status;
+                }
+        }
+
+        if (G.running_procs < MAXIMUM_WAIT_OBJECTS)
+                WaitForMultipleObjects((DWORD)G.running_procs, G.procs, FALSE,
+                                INFINITE);
+        else {
+                /* Fall back to polling */
+                for (;;) {
+                        DWORD nr = i + MAXIMUM_WAIT_OBJECTS > G.running_procs ?
+                                MAXIMUM_WAIT_OBJECTS : (DWORD)(G.running_procs - i);
+                        DWORD ret = WaitForMultipleObjects(nr, G.procs + i, FALSE, 100);
+
+                        if (ret != WAIT_TIMEOUT)
+                                break;
+                        i += MAXIMUM_WAIT_OBJECTS;
+                        if (i > G.running_procs)
+                                i = 0;
+                }
+        }
+
+        goto check_exit_codes;
+}
+#endif /* SUPPORT_PARALLEL && PLATFORM_MINGW32 */
+
 /*
  * Returns 0 if xargs should continue (but may set G.xargs_exitcode to 123).
  * Else sets G.xargs_exitcode to error code and returns nonzero.
@@ -144,6 +199,23 @@ static int xargs_exec(void)
         if (G.max_procs == 1) {
                 status = spawn_and_wait(G.args);
         } else {
+#if ENABLE_PLATFORM_MINGW32
+                int idx;
+                status = !G.running_procs && !G.max_procs ? 0 : wait_for_slot(&idx);
+                if (G.max_procs) {
+                        HANDLE p = (HANDLE)mingw_spawn_proc((const char **)G.args);
+                        if (p < 0)
+                                status = -1;
+                        else
+                                G.procs[idx] = p;
+                } else {
+                        while (G.running_procs) {
+                                int status2 = wait_for_slot(&idx);
+                                if (status2 && !status)
+                                        status = status2;
+                        }
+                }
+#else
                 pid_t pid;
                 int wstat;
  again:
@@ -184,6 +256,7 @@ static int xargs_exec(void)
                         /* final waitpid() loop: must be ECHILD "no more children" */
                         status = 0;
                 }
+#endif
         }
 #endif
         /* Manpage:
@@ -496,6 +569,7 @@ static char* FAST_FUNC process_stdin_with_replace(int n_max_chars, int n_max_arg
  */
 static int xargs_ask_confirmation(void)
 {
+#if !ENABLE_PLATFORM_MINGW32
         FILE *tty_stream;
         int r;
 
@@ -505,6 +579,18 @@ static int xargs_ask_confirmation(void)
         r = bb_ask_y_confirmation_FILE(tty_stream);
 
         fclose(tty_stream);
+#else
+        int r, c, savec;
+
+        fputs(" ?...", stderr);
+        fflush_all();
+        c = savec = getche();
+        while (c != EOF && c != '\r')
+                c = getche();
+        fputs("\n", stderr);
+        fflush_all();
+        r = (savec == 'y' || savec == 'Y');
+#endif
 
         return r;
 }
@@ -608,7 +694,12 @@ int xargs_main(int argc UNUSED_PARAM, char **argv)
 
 #if ENABLE_FEATURE_XARGS_SUPPORT_PARALLEL
         if (G.max_procs <= 0) /* -P0 means "run lots of them" */
+#if !ENABLE_PLATFORM_MINGW32
                 G.max_procs = 100; /* let's not go crazy high */
+#else
+                G.max_procs = MAXIMUM_WAIT_OBJECTS;
+        G.procs = xmalloc(sizeof(G.procs[0]) * G.max_procs);
+#endif
 #endif
 
 #if ENABLE_FEATURE_XARGS_SUPPORT_ARGS_FILE
@@ -730,7 +821,11 @@ int xargs_main(int argc UNUSED_PARAM, char **argv)
                                 fmt = " %s";
                         }
                         if (!(opt & OPT_INTERACTIVE))
+#if !ENABLE_PLATFORM_MINGW32
                                 bb_putchar_stderr('\n');
+#else
+                                fprintf(stderr, "\n");
+#endif
                 }
 
                 if (!(opt & OPT_INTERACTIVE) || xargs_ask_confirmation()) {