Changeset 197 for trunk/src/corelib

Timestamp:

Oct 3, 2009, 2:34:36 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: Reimplemented QProcess to use native pipes for redirection.

Location:

trunk/src/corelib/io

Files:

• qprocess.cpp (modified) (2 diffs)
• qprocess_os2.cpp (modified) (31 diffs)
• qprocess_p.h (modified) (5 diffs)

trunk/src/corelib/io/qprocess.cpp

@@ -421 +421 @@
     notifier = 0;
     pipeWriter = 0;
+
     childStartedPipe[0] = INVALID_Q_PIPE;
     childStartedPipe[1] = INVALID_Q_PIPE;
     deathPipe[0] = INVALID_Q_PIPE;
     deathPipe[1] = INVALID_Q_PIPE;
+
     exitCode = 0;
     crashed = false;
@@ -510 +512 @@
     destroyPipe(stderrChannel.pipe);
     destroyPipe(stdinChannel.pipe);
+
     destroyPipe(childStartedPipe);
     destroyPipe(deathPipe);
+
 #ifdef Q_OS_UNIX
     serial = 0;

trunk/src/corelib/io/qprocess_os2.cpp

@@ -97 +97 @@
 #include <qfile.h>
 #include <qfileinfo.h>
-#include <qlist.h>
-#include <qmap.h>
+#include <qhash.h>
 #include <qmutex.h>
-#include <qsemaphore.h>
-#include <qsocketnotifier.h>
 #include <qdir.h>
 
-#include <errno.h>
-#include <sys/filio.h>
-#include <sys/socket.h> // socketpair
+#
+#
+#
 
 QT_BEGIN_NAMESPACE
 
-static void qt_create_pipe(int *pipe)
-{
-    if (pipe[0] != -1)
-        ::close(pipe[0]);
-    if (pipe[1] != -1)
-        ::close(pipe[1]);
-    // Note: with kLIBC 0.6.3 and earlier (GCC 3.3.5 CSD3), fds created with
-    // pipe() cannot be used in select(), so use socketpair() instead
-    if (::socketpair(AF_OS2, SOCK_STREAM, 0, pipe) != 0) {
-        qWarning("QProcessPrivate::createPipe: ::socketpair() failed with '%s'",
-                 qPrintable(qt_error_string(errno)));
-    }
-    ::fcntl(pipe[0], F_SETFD, FD_CLOEXEC);
-    ::fcntl(pipe[1], F_SETFD, FD_CLOEXEC);
-}
-
+enum
+{
+    PIPE_SIZE_STDIN = 65520, // max
+    PIPE_SIZE_STDOUT = 65520, // max
+    PIPE_SIZE_STDERR = 4096,
+};
 
 class QProcessManager : public QThread
 {
 public:
+
+
 
     static void addRef();
     static void release();
 
-    static void addProcess(QProcess *process);
-    static void removeProcess(QProcess *process);
+    static USHORT addProcess(QProcess *process);
+    static void removeProcess(USHORT procKey);
+
+    static QMutex *mutex() { return &mtx; }
 
 private:
@@ -151 +142 @@
     HEV eventSem;
     QAtomicInt eventSemGuard;
-
-    typedef QList<QProcess *> ProcessList;
+    QAtomicInt deathFlag;
+
+    typedef QHash<USHORT, QProcess *> ProcessList;
     ProcessList processes;
+
 
     void (*sa_old_sigchld_handler)(int);
@@ -159 +152 @@
     static void sa_sigchld_handler(int signum);
 
+
+
+
+
+
+
+
+
+
     static QProcessManager *instance;
-    static QMutex mutex;
+    static QMutex mx;
 };
 
 // static
 QProcessManager *QProcessManager::instance = 0;
-QMutex QProcessManager::mutex;
+QMutex QProcessManager::mx;
 
 // static
@@ -184 +186 @@
         return;
 
-    APIRET rc = DosPostEventSem(instance->eventSem);
-    Q_ASSERT(rc == NO_ERROR);
+    // set deathEvent to 1 and post the semaphore if not already done so
+    if (instance->deathFlag.testAndSetRelaxed(0, 1)) {
+        APIRET rc = DosPostEventSem(instance->eventSem);
+        Q_ASSERT(rc == NO_ERROR || rc == ERROR_ALREADY_POSTED);
+    }
 
     instance->eventSemGuard.testAndSetRelease(2, 1);
@@ -197 +202 @@
 void QProcessManager::addRef()
 {
-    QMutexLocker locker(&mutex);
+    QMutexLocker locker();
 
     if (instance == 0) {
@@ -209 +214 @@
 void QProcessManager::release()
 {
-    QMutexLocker locker(&mutex);
+    QMutexLocker locker();
 
     Q_ASSERT(instance);
@@ -234 +239 @@
 
 // static
-void QProcessManager::addProcess(QProcess *process)
-{
-#if defined (QPROCESS_DEBUG)
-    qDebug() << "QProcessManager::addProcess()";
-#endif
-
-    QMutexLocker locker(&mutex);
+ QProcessManager::addProcess(QProcess *process)
+{
+#if defined (QPROCESS_DEBUG)
+    qDebug(;
+#endif
+
+    QMutexLocker locker();
     Q_ASSERT(instance);
 
@@ -249 +254 @@
     }
 
-    instance->processes.append(process);
+    USHORT procKey = instance->lastProcKey + 1;
+    if (procKey > MaxProcKey) {
+        // limit reached, find an unused number
+        procKey = 0;
+        while (++procKey <= MaxProcKey &&
+               instance->processes.contains(procKey));
+        Q_ASSERT(procKey <= MaxProcKey);
+        if (procKey > MaxProcKey) {
+            // oops, no more free keys!
+            process->setErrorString(QString("Internal error: Too many processes"));
+            return InvalidProcKey;
+        }
+    } else {
+        instance->lastProcKey = procKey;
+    }
+
+    // attach the semahpore to the pipes of the process
+    APIRET arc = NO_ERROR;
+    QProcessPrivate *d = process->d_func();
+    if (d->stdinChannel.pipe.server != HPIPE(~0)) {
+        arc = DosSetNPipeSem(d->stdinChannel.pipe.server, (HSEM)instance->eventSem,
+                             toPipeKey(procKey, QProcessPrivate::InPipe));
+    }
+    if (arc == NO_ERROR && d->stdoutChannel.pipe.server != HPIPE(~0)) {
+        arc = DosSetNPipeSem(d->stdoutChannel.pipe.server, (HSEM)instance->eventSem,
+                             toPipeKey(procKey, QProcessPrivate::OutPipe));
+    }
+    if (arc == NO_ERROR && d->stderrChannel.pipe.server != HPIPE(~0)) {
+        arc = DosSetNPipeSem(d->stderrChannel.pipe.server, (HSEM)instance->eventSem,
+                             toPipeKey(procKey, QProcessPrivate::ErrPipe));
+    }
+    if (arc != NO_ERROR) {
+        process->setErrorString(QProcess::tr("Internal error: DOS error %1")
+                                .arg(arc));
+        if (procKey == instance->lastProcKey)
+            --instance->lastProcKey;
+        return InvalidProcKey;
+    }
+
+    instance->processes[procKey] = process;
+
+    return procKey;
 }
 
 // static
-void QProcessManager::removeProcess(QProcess *process)
-{
-#if defined (QPROCESS_DEBUG)
-    qDebug() << "QProcessManager::removeProcess()";
-#endif
-
-    QMutexLocker locker(&mutex);
+void QProcessManager::removeProcess(USHORT procKey)
+{
+    QMutexLocker locker(mutex());
     Q_ASSERT(instance);
 
-    instance->processes.removeAll(process);
+    Q_ASSERT(instance->processes.contains(procKey));
+    QProcess *process = instance->processes[procKey];
+
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessManager::removeProcess(%p)", process);
+#endif
+
+    // to guarantee that the given procKey may be reused, we must close all
+    // pipes in order to ensure that we won't get late NPSS_CLOSE for the
+    // removed process that may be already associated with a different process
+    QProcessPrivate *d = process->d_func();
+    d->destroyPipe(d->stdinChannel.pipe);
+    d->destroyPipe(d->stdoutChannel.pipe);
+    d->destroyPipe(d->stderrChannel.pipe);
+
+    instance->processes.remove(procKey);
+
+    // small optimization: released the highest key
+    if (procKey == instance->lastProcKey)
+        --instance->lastProcKey;
 }
 
@@ -272 +333 @@
 #endif
 
-    APIRET rc = DosCreateEventSem(NULL, &eventSem, DCE_AUTORESET | DCE_POSTONE, FALSE);
+    APIRET rc = DosCreateEventSem(NULL, &eventSem,
+                                  DC_SEM_SHARED | DCE_AUTORESET | DCE_POSTONE,
+                                  FALSE);
     Q_ASSERT(rc == NO_ERROR);
+
+
 }
 
@@ -327 +392 @@
     // and all complex work is done here asynchronously.
 
-    QMutexLocker locker(&mutex);
+    QMutexLocker locker();
     APIRET arc;
+
+
+
 
     do {
@@ -334 +402 @@
         qDosNI(arc = DosWaitEventSem(eventSem, SEM_INDEFINITE_WAIT));
         locker.relock();
+
         if (finish)
             break;
 
-#if defined (QPROCESS_DEBUG)
-        qDebug() << "QProcessManager::run() signaled";
-#endif
-        foreach (QProcess *proc, processes) {
+        if (instance->deathFlag.testAndSetRelaxed(1, 0)) {
+#if defined (QPROCESS_DEBUG)
+            qDebug() << "QProcessManager::run(): child death signaled";
+#endif
+            foreach (QProcess *proc, processes) {
+                QProcessPrivate::WaitMode mode = (QProcessPrivate::WaitMode)
+                    proc->d_func()->waitMode.fetchAndStoreRelaxed(QProcessPrivate::SigChild);
+                switch (mode) {
+                case QProcessPrivate::Semaphore:
+                    DosPostEventSem(proc->d_func()->waitSem);
+                    break;
+                case QProcessPrivate::Async:
+                case QProcessPrivate::SigChild:
+                    QMetaObject::invokeMethod(proc, "_q_processDied", Qt::QueuedConnection);
+                    break;
+                }
+            }
+        }
+
+#if defined (QPROCESS_DEBUG)
+        qDebug() << "QProcessManager::run(): checking pipes";
+#endif
+
+        // make sure the state array is big enough. The best size for sz pipes
+        // is sz * 2 (to be able to store both NPSS_RDATA/NPSS_WSPACE and
+        // NPSS_CLOSE for every pipe) + one for NPSS_EOI
+        int bestSize = processes.size() * 3 * 2 + 1;
+        if (pipeStates.size() < bestSize)
+            pipeStates.resize(bestSize);
+
+        arc = DosQueryNPipeSemState((HSEM)eventSem, pipeStates.data(),
+                                    pipeStates.size() * sizeof(PIPESEMSTATE));
+        if (arc != NO_ERROR) {
+            qWarning("QProcessManager::run: DosQueryNPipeSemState returned %lu", arc);
+            continue;
+        }
+
+        // In the returned information array, CLOSE and READ records for the
+        // same pipe key may be mixed. We need CLOSE messages to be posted after
+        // READ messages, so we do two passes.
+
+        int pass = 0;
+        for (int i = 0; pass < 2; ++i) {
+            BYTE status = pipeStates[i].fStatus;
+            if (status == NPSS_EOI) {
+                ++ pass;
+                i = -1;
+                continue;
+            }
+            if (pass == 0 && status != NPSS_RDATA && status != NPSS_WSPACE)
+                continue;
+            if (pass == 1 && status != NPSS_CLOSE)
+                continue;
+#if defined(QPROCESS_DEBUG)
+            qDebug(" %d/%d: fStatus %u fFlag f%02X usKey %04hX usAvail %hu",
+                   pass, i, (uint) pipeStates[i].fStatus,
+                   (uint) pipeStates[i].fFlag, pipeStates[i].usKey,
+                   pipeStates[i].usAvail);
+#endif
+            int procKey = toProcKey(pipeStates[i].usKey);
+            QProcessPrivate::PipeType type = toPipeType(pipeStates[i].usKey);
+
+            QProcess *proc = processes[procKey];
+            Q_ASSERT(proc);
+#if defined(QPROCESS_DEBUG)
+            qDebug("  process %p", proc);
+#endif
+            QProcessPrivate *d = proc->d_func();
+
+            if (status == NPSS_CLOSE) {
+                // nothing to do but notify the object; it should close the
+                // pipe if it sees that it has been notified but there is no
+                // data to read, or if it fails to write to a (closed) pipe
+            } else {
+                d->pipeData[type].bytes = pipeStates[i].usAvail;
+            }
+
+            if (d->pipeData[type].isNew) {
+                // the object didn't process the previous notification yet;
+                // there is no point to send a new one
+                continue;
+            }
+
+            d->pipeData[type].isNew = true;
+
+            // signal the process object
             QProcessPrivate::WaitMode mode = (QProcessPrivate::WaitMode)
-                proc->d_func()->waitMode.fetchAndStoreAcquire(QProcessPrivate::SigChild);
+                proc->d_func()->waitMode.fetchAndStore(QProcessPrivate::SigChild);
             switch (mode) {
-            case QProcessPrivate::Select:
-                ::so_cancel(proc->d_func()->maxSelectFd);
-                break;
             case QProcessPrivate::Semaphore:
                 DosPostEventSem(proc->d_func()->waitSem);
@@ -352 +500 @@
             case QProcessPrivate::Async:
             case QProcessPrivate::SigChild:
-                QMetaObject::invokeMethod(proc, "_q_processDied", Qt::QueuedConnection);
+                const char *method;
+                switch(type) {
+                case QProcessPrivate::InPipe:
+                    Q_ASSERT(status == NPSS_CLOSE || status == NPSS_WSPACE);
+                    method = "_q_canWrite";
+                    break;
+                case QProcessPrivate::OutPipe:
+                    Q_ASSERT(status == NPSS_CLOSE || status == NPSS_RDATA);
+                    method = "_q_canReadStandardOutput";
+                    break;
+                case QProcessPrivate::ErrPipe:
+                    Q_ASSERT(status == NPSS_CLOSE || status == NPSS_RDATA);
+                    method = "_q_canReadStandardError";
+                    break;
+                }
+                QMetaObject::invokeMethod(proc, method, Qt::QueuedConnection);
                 break;
             }
@@ -367 +530 @@
 {
     waitMode = Async;
-    maxSelectFd = -1;
     waitSem = NULLHANDLE;
+
+
+
+
+
+
     QProcessManager::addRef();
 }
@@ -375 +543 @@
 {
     QProcessManager::release();
+
     if (waitSem != NULLHANDLE)
         DosCloseEventSem(waitSem);
@@ -387 +556 @@
 }
 
-void QProcessPrivate::destroyPipe(int *pipe)
-{
-    if (pipe[1] != -1) {
-        ::close(pipe[1]);
-        pipe[1] = -1;
-    }
-    if (pipe[0] != -1) {
-        ::close(pipe[0]);
-        pipe[0] = -1;
+bool QProcessPrivate::createPipe(PipeType type, Channel::Pipe &pipe)
+{
+    APIRET rc;
+    char pathBuf[CCHMAXPATH];
+
+    // we need the process identifier to guarantee pipe name unicity
+    PPIB ppib = NULL;
+    DosGetInfoBlocks(NULL, &ppib);
+
+    switch (type) {
+    case InPipe:
+        // create our end of the pipe
+        sprintf(pathBuf, "\\pipe\\Qt4\\%08lX\\QProcess\\%p\\Stdin",
+                ppib->pib_ulpid, this->q_func());
+        rc = DosCreateNPipe(pathBuf, &pipe.server,
+                            NP_ACCESS_OUTBOUND, NP_NOWAIT | NP_TYPE_BYTE | 1,
+                            PIPE_SIZE_STDIN, 0, 0);
+        if (rc == NO_ERROR) {
+            DosConnectNPipe(pipe.server);
+            // open the client end of the pipe
+            ULONG action = 0;
+            rc = DosOpen(pathBuf, &pipe.client, &action, 0, FILE_NORMAL, FILE_OPEN,
+                         OPEN_ACCESS_READONLY | OPEN_SHARE_DENYREADWRITE |
+                         OPEN_FLAGS_NOINHERIT, (PEAOP2)NULL);
+        }
+        break;
+    case OutPipe:
+    case ErrPipe:
+        // create our end of the pipe
+        sprintf(pathBuf, "\\pipe\\Qt4\\%08lX\\QProcess\\%p\\%s",
+                ppib->pib_ulpid, this->q_func(), type == OutPipe ? "Stdout" : "Stderr");
+        rc = DosCreateNPipe(pathBuf, &pipe.server,
+                            NP_ACCESS_INBOUND, NP_NOWAIT | NP_TYPE_BYTE | 1,
+                            0, type == OutPipe ? PIPE_SIZE_STDOUT : PIPE_SIZE_STDERR, 0);
+        if (rc == NO_ERROR) {
+            DosConnectNPipe(pipe.server);
+            // open the client end of the pipe
+            ULONG action = 0;
+            rc = DosOpen(pathBuf, &pipe.client, &action, 0, FILE_NORMAL, FILE_OPEN,
+                         OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYREADWRITE |
+                         OPEN_FLAGS_NOINHERIT, (PEAOP2)NULL);
+        }
+        break;
+    }
+
+    if (rc != NO_ERROR)
+        qWarning("QProcessPrivate::createPipe: DosCreateNPipe or DosOpen "
+                 "returned %lu for PipeType(%d)", rc, type);
+
+    return rc == NO_ERROR;
+}
+
+void QProcessPrivate::destroyPipe(Channel::Pipe &pipe)
+{
+    if (pipe.client != ~HFILE(~0)) {
+        DosClose(pipe.client);
+        pipe.client = HFILE(~0);
+    }
+    if (pipe.server != HPIPE(~0)) {
+        DosDisConnectNPipe(pipe.server);
+        DosClose(pipe.server);
+        pipe.server = HPIPE(~0);
     }
 }
@@ -408 +630 @@
     Q_Q(QProcess);
 
+
+
+
     if (&channel == &stderrChannel && processChannelMode == QProcess::MergedChannels) {
-        channel.pipe[0] = -1;
-        channel.pipe[1] = -1;
         return true;
     }
@@ -416 +639 @@
     if (channel.type == Channel::Normal) {
         // we're piping this channel to our own process
-        qt_create_pipe(channel.pipe);
-
-        // create the socket notifiers
-        if (threadData->eventDispatcher) {
-            if (&channel == &stdinChannel) {
-                channel.notifier = new QSocketNotifier(channel.pipe[1],
-                                                       QSocketNotifier::Write, q);
-                channel.notifier->setEnabled(false);
-                QObject::connect(channel.notifier, SIGNAL(activated(int)),
-                                 q, SLOT(_q_canWrite()));
-            } else {
-                channel.notifier = new QSocketNotifier(channel.pipe[0],
-                                                       QSocketNotifier::Read, q);
-                const char *receiver;
-                if (&channel == &stdoutChannel)
-                    receiver = SLOT(_q_canReadStandardOutput());
-                else
-                    receiver = SLOT(_q_canReadStandardError());
-                QObject::connect(channel.notifier, SIGNAL(activated(int)),
-                                 q, receiver);
-            }
-        }
-
-        return true;
+        PipeType type;
+        if (&channel == &stdinChannel)
+            type = InPipe;
+        else if (&channel == &stdoutChannel)
+            type = OutPipe;
+        else if (&channel == &stderrChannel)
+            type = ErrPipe;
+        else
+            Q_ASSERT(false);
+        return createPipe(type, channel.pipe);
     } else if (channel.type == Channel::Redirect) {
         // we're redirecting the channel to/from a file
         QByteArray fname = QFile::encodeName(channel.file);
 
+
         if (&channel == &stdinChannel) {
             // try to open in read-only mode
-            channel.pipe[1] = -1;
-            if ( (channel.pipe[0] = ::open(fname, O_RDONLY)) != -1)
-                return true;    // success
+            ULONG action = 0;
+            rc = DosOpen(fname, &channel.pipe.client, &action, 0, FILE_NORMAL, FILE_OPEN,
+                         OPEN_ACCESS_READONLY | OPEN_FLAGS_NOINHERIT, (PEAOP2)NULL);
+
+            if (rc == NO_ERROR)
+                return true; // success
 
             q->setErrorString(QProcess::tr("Could not open input redirection for reading"));
         } else {
-            int mode = O_WRONLY | O_CREAT;
+            int mode = ;
             if (channel.append)
-                mode |= O_APPEND;
+                mode |= ;
             else
-                mode |= O_TRUNC;
-
-            channel.pipe[0] = -1;
-            if ( (channel.pipe[1] = ::open(fname, mode, 0666)) != -1)
+                mode |= FILE_TRUNCATE;
+            ULONG action = 0;
+            rc = DosOpen(fname, &channel.pipe.client, &action, 0, FILE_NORMAL, mode,
+                         OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYWRITE |
+                         OPEN_FLAGS_NOINHERIT, (PEAOP2)NULL);
+
+            if (rc == NO_ERROR && channel.append) {
+                ULONG actual = 0;
+                rc = DosSetFilePtr(channel.pipe.client, 0, FILE_END, &actual);
+            }
+            if (rc == NO_ERROR)
                 return true; // success
 
@@ -492 +712 @@
         }
 
-        if (source->pipe[1] != INVALID_Q_PIPE || sink->pipe[0] != INVALID_Q_PIPE) {
+        if (source->pipe) {
             // already created, do nothing
+
+
             return true;
         } else {
-            Q_ASSERT(source->pipe[0] == INVALID_Q_PIPE && source->pipe[1] == INVALID_Q_PIPE);
-            Q_ASSERT(sink->pipe[0] == INVALID_Q_PIPE && sink->pipe[1] == INVALID_Q_PIPE);
-
-            Q_PIPE pipe[2] = { -1, -1 };
-            qt_create_pipe(pipe);
-            sink->pipe[0] = pipe[0];
-            source->pipe[1] = pipe[1];
+            Q_ASSERT(source->pipe);
+            Q_ASSERT(sink->pipe);
+
+            ;
+            pipe);
+            sink->pipe;
+            source->pipe;
 
             return true;
@@ -635 +857 @@
         return;
 
-    QProcessManager::addProcess(q);
+    procKey = QProcessManager::addProcess(q);
+
+    if (procKey == QProcessManager::InvalidProcKey) {
+        // setErrorString() is called inside addProcess()
+        Q_ASSERT(!q->errorString().isEmpty());
+        processError = QProcess::FailedToStart;
+        emit q->error(processError);
+        cleanup();
+        return;
+    }
 
     // Start the process (platform dependent)
+
     q->setProcessState(QProcess::Starting);
 
-    // save & copy the stdin socket
-    int stdin_copy = ::dup(fileno(stdin));
-    ::dup2(stdinChannel.pipe[0], fileno(stdin));
-
-    // save & copy the stdout and stderr if asked to
-    int stdout_copy = -1, stderr_copy = -1;
-    if (processChannelMode != QProcess::ForwardedChannels) {
-        stdout_copy = ::dup(fileno(stdout));
-        ::dup2(stdoutChannel.pipe[1], fileno(stdout));
-
-        // merge stdout and stderr if asked to
-        stderr_copy = ::dup(fileno(stderr));
-        if (processChannelMode == QProcess::MergedChannels) {
-            ::dup2(fileno(stdout), fileno(stderr));
-        } else {
+    APIRET arc;
+
+    QString error;
+    HFILE tmpStdin = HFILE(~0), tmpStdout = HFILE(~0), tmpStderr = HFILE(~0);
+    HFILE realStdin = HF_STDIN, realStdout = HF_STDOUT, realStderr = HF_STDERR;
+
+    do {
+        // save & copy the stdin handle
+        if ((arc = DosDupHandle(realStdin, &tmpStdin)) == NO_ERROR) {
+            arc = DosDupHandle(stdinChannel.pipe.client, &realStdin);
+        }
+        if (arc != NO_ERROR) {
+#if defined (QPROCESS_DEBUG)
+            qDebug("QProcessPrivate::startProcess: DosDupHandle for STDIN "
+                   "returned %lu", arc);
+#endif
+            break;
+        }
+        // save & copy the stdout and stderr handles if asked to
+        if (processChannelMode != QProcess::ForwardedChannels) {
+            // save & copy the stdout handle
+            if ((arc = DosDupHandle(realStdout, &tmpStdout)) == NO_ERROR) {
+                arc = DosDupHandle(stdoutChannel.pipe.client, &realStdout);
+            }
+            if (arc != NO_ERROR) {
+#if defined (QPROCESS_DEBUG)
+                qDebug("QProcessPrivate::startProcess: DosDupHandle for STDOUT "
+                       "returned %lu", arc);
+#endif
+                break;
+            }
+            // qDebug() uses STDERR so only redirect if !QPROCESS_DEBUG
 #if !defined (QPROCESS_DEBUG)
-            // don't redirect it as qDebug() uses it
-            ::dup2(stderrChannel.pipe[1], fileno(stderr));
-#endif
-        }
-    }
-
-    int pid = qt_startProcess(program, arguments, workingDirectory,
+            if ((arc = DosDupHandle(realStderr, &tmpStderr)) == NO_ERROR) {
+                // merge stdout and stderr if asked to
+                if (processChannelMode == QProcess::MergedChannels) {
+                    arc = DosDupHandle(stdoutChannel.pipe.client, &realStderr);
+                } else {
+                    arc = DosDupHandle(stderrChannel.pipe.client, &realStderr);
+                }
+            }
+            if (arc != NO_ERROR)
+                break;
+#endif
+        }
+
+    } while (false);
+
+    int pid = -1;
+    if (arc == NO_ERROR)
+        pid = qt_startProcess(program, arguments, workingDirectory,
                               &environment);
 
-    // restore stdin/stdout/stderr
-    if (stdin_copy != -1) {
-        ::dup2(stdin_copy, fileno(stdin));
-        ::close(stdin_copy);
-    }
-    if (stdout_copy != -1) {
-        ::dup2(stdout_copy, fileno(stdout));
-        ::close(stdout_copy);
-    }
-    if (stderr_copy != -1) {
-        ::dup2(stderr_copy, fileno(stderr));
-        ::close(stderr_copy);
-    }
-
-    if (pid == -1) {
+    // 
+    if () {
+        );
+        );
+    }
+    if () {
+        );
+        );
+    }
+    if () {
+        );
+        );
+    }
+
+    if (pid == -1) {
         // Cleanup, report error and return
-#if defined (QPROCESS_DEBUG)
-        qDebug("spawnvpe failed: %s", qPrintable(qt_error_string(errno)));
-#endif
         q->setProcessState(QProcess::NotRunning);
         processError = QProcess::FailedToStart;
-        q->setErrorString(QProcess::tr("Process failed to start: %1")
-                                       .arg(qPrintable(qt_error_string(errno))));
+        if (arc != NO_ERROR) {
+            // handle duplication failed
+            q->setErrorString(QProcess::tr("Process failed to start: %1")
+                                           .arg(QString("DOS error %1").arg(arc)));
+        } else {
+#if defined (QPROCESS_DEBUG)
+            qDebug("spawnvpe failed: %s", qPrintable(qt_error_string(errno)));
+#endif
+            q->setErrorString(QProcess::tr("Process failed to start: %1")
+                                           .arg(qPrintable(qt_error_string(errno))));
+        }
         emit q->error(processError);
-        QProcessManager::removeProcess(q);
+        QProcessManager::removeProcess(procKey);
+        procKey = QProcessManager::InvalidProcKey;
         cleanup();
         return;
@@ -696 +963 @@
     this->pid = Q_PID(pid);
 
-    unsigned long nonBlock = 1;
-
-    // close the ends we don't use and make all pipes non-blocking
-    if (stdinChannel.pipe[0] != -1) {
-        ::close(stdinChannel.pipe[0]);
-        stdinChannel.pipe[0] = -1;
-    }
-    if (stdinChannel.pipe[1] != -1)
-        ::ioctl(stdinChannel.pipe[1], FIONBIO, &nonBlock);
-
-    if (stdoutChannel.pipe[1] != -1) {
-        ::close(stdoutChannel.pipe[1]);
-        stdoutChannel.pipe[1] = -1;
-    }
-    if (stdoutChannel.pipe[0] != -1)
-        ::ioctl(stdoutChannel.pipe[0], FIONBIO, &nonBlock);
-
-    if (stderrChannel.pipe[1] != -1) {
-        ::close(stderrChannel.pipe[1]);
-        stderrChannel.pipe[1] = -1;
-    }
-    if (stderrChannel.pipe[0] != -1)
-        ::ioctl(stderrChannel.pipe[0], FIONBIO, &nonBlock);
+    // close the client ends (they are no more necessary)
+    if (stdinChannel.pipe.client != HFILE(~0)) {
+        DosClose(stdinChannel.pipe.client);
+        stdinChannel.pipe.client = HFILE(~0);
+    }
+    if (stdoutChannel.pipe.client != HFILE(~0)) {
+        DosClose(stdoutChannel.pipe.client);
+        stdoutChannel.pipe.client = HFILE(~0);
+    }
+    if (stderrChannel.pipe.client != HFILE(~0)) {
+        DosClose(stderrChannel.pipe.client);
+        stderrChannel.pipe.client = HFILE(~0);
+    }
 
     // give the process a chance to start ...
@@ -735 +992 @@
 qint64 QProcessPrivate::bytesAvailableFromStdout() const
 {
-    size_t nbytes = 0;
     qint64 available = 0;
-    if (::ioctl(stdoutChannel.pipe[0], FIONREAD, (char *) &nbytes) >= 0)
-        available = (qint64) *((int *) &nbytes);
+    {
+        QMutexLocker lock(QProcessManager::mutex());
+        available = pipeData[OutPipe].bytes;
+        // accept new messages from QProcessManager
+        const_cast<QProcessPrivate*>(this)->pipeData[OutPipe].isNew = false;
+    }
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::bytesAvailableFromStdout() == %lld", available);
@@ -747 +1007 @@
 qint64 QProcessPrivate::bytesAvailableFromStderr() const
 {
-    size_t nbytes = 0;
     qint64 available = 0;
-    if (::ioctl(stderrChannel.pipe[0], FIONREAD, (char *) &nbytes) >= 0)
-        available = (qint64) *((int *) &nbytes);
+    {
+        QMutexLocker lock(QProcessManager::mutex());
+        available = pipeData[ErrPipe].bytes;
+        // accept new messages from QProcessManager
+        const_cast<QProcessPrivate*>(this)->pipeData[ErrPipe].isNew = false;
+    }
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::bytesAvailableFromStderr() == %lld", available);
@@ -759 +1022 @@
 qint64 QProcessPrivate::readFromStdout(char *data, qint64 maxlen)
 {
-    qint64 bytesRead = ::read(stdoutChannel.pipe[0], data, maxlen);
+    ULONG actual = 0;
+    APIRET arc = DosRead(stdoutChannel.pipe.server, data, maxlen, &actual);
+
+    // decrement the counter to make sure bytesAvailableFromStdout() will return
+    // a correct number before QProcessManager::run() updates it
+    QMutexLocker lock(QProcessManager::mutex());
+    if (actual <= (ULONG) pipeData[OutPipe].bytes)
+        pipeData[OutPipe].bytes -= (USHORT) actual;
+    else
+        pipeData[OutPipe].bytes = 0;
+
+    qint64 bytesRead = arc == NO_ERROR ? (qint64)actual : -1;
+
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::readFromStdout(%p \"%s\", %lld) == %lld",
@@ -769 +1044 @@
 qint64 QProcessPrivate::readFromStderr(char *data, qint64 maxlen)
 {
-    qint64 bytesRead = ::read(stderrChannel.pipe[0], data, maxlen);
+    ULONG actual = 0;
+    APIRET arc = DosRead(stderrChannel.pipe.server, data, maxlen, &actual);
+
+    // decrement the counter to make sure bytesAvailableFromStderr() will return
+    // a correct number before QProcessManager::run() updates it
+    QMutexLocker lock(QProcessManager::mutex());
+    if (actual <= (ULONG) pipeData[ErrPipe].bytes)
+        pipeData[ErrPipe].bytes -= (USHORT) actual;
+    else
+        pipeData[ErrPipe].bytes = 0;
+
+    qint64 bytesRead = arc == NO_ERROR ? (qint64)actual : -1;
+
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::readFromStderr(%p \"%s\", %lld) == %lld",
@@ -779 +1066 @@
 qint64 QProcessPrivate::writeToStdin(const char *data, qint64 maxlen)
 {
-    qint64 written = ::write(stdinChannel.pipe[1], data, maxlen);
+    ULONG actual = 0;
+    APIRET arc = DosWrite(stdinChannel.pipe.server, data, maxlen, &actual);
+
+    qint64 written = arc == NO_ERROR ? (qint64)actual : -1;
+
+    // accept new messages from QProcessManager
+    QMutexLocker lock(QProcessManager::mutex());
+    const_cast<QProcessPrivate*>(this)->pipeData[InPipe].isNew = false;
+
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::writeToStdin(%p \"%s\", %lld) == %lld",
@@ -840 +1135 @@
 }
 
-static int qt_select(int maxfd, fd_set *fdread, fd_set *fdwrite, int timeout)
-{
-    struct timeval tv;
-    tv.tv_sec = timeout / 1000;
-    tv.tv_usec = (timeout % 1000) * 1000;
-
-    int ret = select(maxfd, fdread, fdwrite, 0, timeout < 0 ? 0 : &tv);
-    return ret;
-}
-
 bool QProcessPrivate::waitForStarted(int msecs)
 {
@@ -875 +1160 @@
     stopWatch.start();
 
+
+
+
     forever {
-        fd_set fdread;
-        fd_set fdwrite;
-
-        FD_ZERO(&fdread);
-        FD_ZERO(&fdwrite);
-
-        int maxFd = 0;
-        if (stdoutChannel.pipe[0] != -1) {
-            FD_SET(stdoutChannel.pipe[0], &fdread);
-            maxFd = qMax(maxFd, stdoutChannel.pipe[0]);
-        }
-        if (stderrChannel.pipe[0] != -1) {
-            FD_SET(stderrChannel.pipe[0], &fdread);
-            maxFd = qMax(maxFd, stderrChannel.pipe[0]);
-        }
-
-        if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1) {
-            FD_SET(stdinChannel.pipe[1], &fdwrite);
-            maxFd = qMax(maxFd, stdinChannel.pipe[1]);
-        }
-
-        WaitMode mode;
-        if (maxFd >= 0) {
-            mode = Select;
-            maxSelectFd = maxFd;
-        } else {
-            mode = Semaphore;
-            ensureWaitSem();
-        }
-
         bool timedOut = false, failed = false;
-
-        if (waitMode.testAndSetRelease(Async, mode)) {
+        if (waitMode.testAndSetRelaxed(Async, Semaphore)) {
             int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
-            if (maxFd >= 0) {
-                int ret = qt_select(maxFd + 1, &fdread, &fdwrite, timeout);
-                if (ret < 0 && errno != EINTR) {
-                    Q_ASSERT(errno == EINTR);
+            qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)timeout));
+            if (arc == ERROR_TIMEOUT) {
+                timedOut = true;
+            } else if (arc != NO_ERROR) {
+                Q_ASSERT(arc == NO_ERROR);
+                failed = true;
+            } else {
+                QMutexLocker lock(QProcessManager::mutex());
+
+                bool readyReadEmitted = false;
+                if (pipeData[OutPipe].bytes) {
+                    bool canRead = _q_canReadStandardOutput();
+                    if (processChannel == QProcess::StandardOutput && canRead)
+                        readyReadEmitted = true;
+                }
+                if (pipeData[ErrPipe].bytes) {
+                    bool canRead = _q_canReadStandardError();
+                    if (processChannel == QProcess::StandardError && canRead)
+                        readyReadEmitted = true;
+                }
+                if (readyReadEmitted) {
+                    waitMode.fetchAndStoreRelaxed(Async);
+                    return true;
+                }
+
+                if (pipeData[InPipe].bytes)
+                    _q_canWrite();
+
+                if (!pid)
                     failed = true;
-                } else if (ret == 0) {
-                    timedOut = true;
-                } else if (ret >= 0) {
-                    bool readyReadEmitted = false;
-                    if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread)) {
-                        bool canRead = _q_canReadStandardOutput();
-                        if (processChannel == QProcess::StandardOutput && canRead)
-                            readyReadEmitted = true;
-                    }
-                    if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread)) {
-                        bool canRead = _q_canReadStandardError();
-                        if (processChannel == QProcess::StandardError && canRead)
-                            readyReadEmitted = true;
-                    }
-                    if (readyReadEmitted) {
-                        waitMode.fetchAndStoreRelaxed(Async);
-                        return true;
-                    }
-
-                    if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
-                        _q_canWrite();
-
-                    if (!pid)
-                        failed = true;
-                }
-            } else {
-                APIRET arc;
-                qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)timeout));
-                if (arc == ERROR_TIMEOUT) {
-                    timedOut = true;
-                } else if (arc != NO_ERROR) {
-                    Q_ASSERT(arc == NO_ERROR);
-                    failed = true;
-                }
             }
         } else {
@@ -980 +1228 @@
     stopWatch.start();
 
+
+
+
     while (!writeBuffer.isEmpty()) {
-        fd_set fdread;
-        fd_set fdwrite;
-
-        FD_ZERO(&fdread);
-        FD_ZERO(&fdwrite);
-
-        int maxFd = 0;
-        if (stdoutChannel.pipe[0] != -1) {
-            FD_SET(stdoutChannel.pipe[0], &fdread);
-            maxFd = qMax(maxFd, stdoutChannel.pipe[0]);
-        }
-        if (stderrChannel.pipe[0] != -1) {
-            FD_SET(stderrChannel.pipe[0], &fdread);
-            maxFd = qMax(maxFd, stderrChannel.pipe[0]);
-        }
-
-        if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1) {
-            FD_SET(stdinChannel.pipe[1], &fdwrite);
-            maxFd = qMax(maxFd, stdinChannel.pipe[1]);
-        }
-
-        WaitMode mode;
-        if (maxFd >= 0) {
-            mode = Select;
-            maxSelectFd = maxFd;
-        } else {
-            mode = Semaphore;
-            ensureWaitSem();
-        }
-
         bool timedOut = false, failed = false;
-
-        if (waitMode.testAndSetRelease(Async, mode)) {
+        if (waitMode.testAndSetRelaxed(Async, Semaphore)) {
             int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
-            if (maxFd >= 0) {
-                int ret = qt_select(maxFd + 1, &fdread, &fdwrite, timeout);
-                if (ret < 0 && errno != EINTR) {
-                    Q_ASSERT(errno == EINTR);
+            qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)timeout));
+            if (arc == ERROR_TIMEOUT) {
+                timedOut = true;
+            } else if (arc != NO_ERROR) {
+                Q_ASSERT(arc == NO_ERROR);
+                failed = true;
+            } else {
+                QMutexLocker lock(QProcessManager::mutex());
+
+                if (pipeData[InPipe].bytes) {
+                    waitMode.fetchAndStoreRelaxed(Async);
+                    return _q_canWrite();
+                }
+
+                if (pipeData[OutPipe].bytes)
+                    _q_canReadStandardOutput();
+
+                if (pipeData[ErrPipe].bytes)
+                    _q_canReadStandardError();
+
+                if (!pid)
                     failed = true;
-                } else if (ret == 0) {
-                    timedOut = true;
-                } else if (ret >= 0) {
-                    if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
-                        return _q_canWrite();
-
-                    if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
-                        _q_canReadStandardOutput();
-
-                    if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
-                        _q_canReadStandardError();
-
-                    if (!pid)
-                        failed = true;
-                }
-            } else {
-                APIRET arc;
-                qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)timeout));
-                if (arc == ERROR_TIMEOUT) {
-                    timedOut = true;
-                } else if (arc != NO_ERROR) {
-                    Q_ASSERT(arc == NO_ERROR);
-                    failed = true;
-                }
             }
         } else {
@@ -1076 +1289 @@
     stopWatch.start();
 
+
+
+
     forever {
-        fd_set fdread;
-        fd_set fdwrite;
-
-        FD_ZERO(&fdread);
-        FD_ZERO(&fdwrite);
-
-        int maxFd = -1;
-        if (stdoutChannel.pipe[0] != -1) {
-            FD_SET(stdoutChannel.pipe[0], &fdread);
-            maxFd = qMax(maxFd, stdoutChannel.pipe[0]);
-        }
-        if (stderrChannel.pipe[0] != -1) {
-            FD_SET(stderrChannel.pipe[0], &fdread);
-            maxFd = qMax(maxFd, stderrChannel.pipe[0]);
-        }
-
-        if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1) {
-            FD_SET(stdinChannel.pipe[1], &fdwrite);
-            maxFd = qMax(maxFd, stdinChannel.pipe[1]);
-        }
-
-        WaitMode mode;
-        if (maxFd >= 0) {
-            mode = Select;
-            maxSelectFd = maxFd;
-        } else {
-            mode = Semaphore;
-            ensureWaitSem();
-        }
-
         bool timedOut = false, failed = false;
-
-        if (waitMode.testAndSetRelease(Async, mode)) {
+        if (waitMode.testAndSetRelaxed(Async, Semaphore)) {
             int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
-            if (maxFd >= 0) {
-                int ret = qt_select(maxFd + 1, &fdread, &fdwrite, timeout);
-                if (ret < 0 && errno != EINTR) {
-                    Q_ASSERT(errno == EINTR);
-                    failed = true;
-                } else if (ret == 0) {
-                    timedOut = true;
-                } else if (ret >= 0) {
-                    if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
-                        _q_canWrite();
-
-                    if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
-                        _q_canReadStandardOutput();
-
-                    if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
-                        _q_canReadStandardError();
-
-                    if (!pid) {
-                        waitMode.fetchAndStoreRelaxed(Async);
-                        return true;
-                    }
-                }
+            qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)timeout));
+            if (arc == ERROR_TIMEOUT) {
+                timedOut = true;
+            } else if (arc != NO_ERROR) {
+                Q_ASSERT(arc == NO_ERROR);
+                failed = true;
             } else {
-                APIRET arc;
-                qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)timeout));
-                if (arc == ERROR_TIMEOUT) {
-                    timedOut = true;
-                } else if (arc != NO_ERROR) {
-                    Q_ASSERT(arc == NO_ERROR);
-                    failed = true;
+                QMutexLocker lock(QProcessManager::mutex());
+
+                if (pipeData[InPipe].bytes)
+                    _q_canWrite();
+
+                if (pipeData[OutPipe].bytes)
+                    _q_canReadStandardOutput();
+
+                if (pipeData[ErrPipe].bytes)
+                    _q_canReadStandardError();
+
+                if (!pid) {
+                    waitMode.fetchAndStoreRelaxed(Async);
+                    return true;
                 }
             }
@@ -1165 +1341 @@
 bool QProcessPrivate::waitForWrite(int msecs)
 {
-    fd_set fdwrite;
-    FD_ZERO(&fdwrite);
-    FD_SET(stdinChannel.pipe[1], &fdwrite);
+    // ### this function isn't actually used in OS/2 and Unix code paths
+
+    APIRET arc;
+    ensureWaitSem();
 
     bool ret = false;
-    maxSelectFd = stdinChannel.pipe[1];
-    if (waitMode.testAndSetRelease(Async, Select)) {
-        ret = qt_select(stdinChannel.pipe[1] + 1, 0, &fdwrite,
-                        msecs < 0 ? 0 : msecs) == 1;
+    if (waitMode.testAndSetRelaxed(Async, Semaphore)) {
+        qDosNI(arc = DosWaitEventSem(waitSem, (ULONG)msecs));
+        if (arc == NO_ERROR) {
+            QMutexLocker lock(QProcessManager::mutex());
+            ret = pipeData[InPipe].bytes;
+        }
     }
     waitMode.fetchAndStoreRelaxed(Async);
@@ -1187 +1366 @@
     // normally calls findExitCode() won't be walked)
 
-    Q_Q(QProcess);
-    QProcessManager::removeProcess(q);
+    if (procKey != QProcessManager::InvalidProcKey) {
+        QProcessManager::removeProcess(procKey);
+        procKey = QProcessManager::InvalidProcKey;
+    }
 }
 

trunk/src/corelib/io/qprocess_p.h

@@ -59 +59 @@
 #include "private/qiodevice_p.h"
 
-#ifdef Q_OS_WIN
+#if
 #include "QtCore/qt_windows.h"
 typedef HANDLE Q_PIPE;
 #define INVALID_Q_PIPE INVALID_HANDLE_VALUE
+
+
 #else
 typedef int Q_PIPE;
 #define INVALID_Q_PIPE -1
-#endif
-
-#ifdef Q_OS_OS2
-#include "QtCore/qt_os2.h"
 #endif
 
@@ -97 +95 @@
         Channel() : process(0), notifier(0), type(Normal), closed(false), append(false)
         {
+
+
+
+
             pipe[0] = INVALID_Q_PIPE;
             pipe[1] = INVALID_Q_PIPE;
+
         }
 
@@ -128 +131 @@
         QProcessPrivate *process;
         QSocketNotifier *notifier;
+
+
+
+
+
+
+
         Q_PIPE pipe[2];
+
 
         unsigned type : 2;
@@ -172 +183 @@
     QRingBuffer writeBuffer;
 
+
+
+
+
+
     Q_PIPE childStartedPipe[2];
     Q_PIPE deathPipe[2];
     void destroyPipe(Q_PIPE pipe[2]);
+
 
     QSocketNotifier *startupSocketNotifier;
@@ -215 +232 @@
 #endif
 #ifdef Q_OS_OS2
-    enum WaitMode { Async, Select, Semaphore, SigChild };
+    enum WaitMode { Async, Semaphore, SigChild };
     QAtomicInt waitMode;
-    int maxSelectFd;
     HEV waitSem;
+
+
+
+
+
+
 #endif