Merge branch 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-1 into master-integration

* 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-1:
  trivial: fix typo in comment
  changelog
  docu update for QNX 6.5
  get rid of anacronysm
  massive improvements for the QNX screen driver
  massive improvements for the QNX mouse driver
  massive improvements for the QNX keyboard driver
  disable the Embedded Linux data directory permissions check for QNX
  skip two subtests that are known to fail on QNX
  implement POSIX IPC based QLock, QWSLock and QWSSharedMemory backends
  implement POSIX IPC based QSystemSemaphore and QSharedMemory backends
  add a configure-time check for an IPC support
  make QProcess really work on QNX
  make the kernel attempt to emulate an instruction with a misaligned access
  use RoundRobin scheduler by default on QNX
  a major refactoring of the mkspecs tree for QNX
  buildfix for qmake

12 files changed, 497 insertions, 35 deletions

diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 32b3e6b..1f5f537 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -173,7 +173,6 @@ namespace QT_NAMESPACE {}
      RELIANT  - Reliant UNIX
      DYNIX    - DYNIX/ptx
      QNX      - QNX
-     QNX6     - QNX RTP 6.1
      LYNX     - LynxOS
      BSD4     - Any BSD 4.4 system
      UNIX     - Any UNIX BSD/SYSV system
@@ -2746,17 +2745,6 @@ QT_LICENSED_MODULE(DBus)
 #  define QT_NO_CONCURRENT_FILTER
 #endif
 
-#ifdef Q_OS_QNX
-// QNX doesn't have SYSV style shared memory. Multiprocess QWS apps,
-// shared fonts and QSystemSemaphore + QSharedMemory are not available
-#  define QT_NO_QWS_MULTIPROCESS
-#  define QT_NO_QWS_SHARE_FONTS
-#  define QT_NO_SYSTEMSEMAPHORE
-#  define QT_NO_SHAREDMEMORY
-// QNX currently doesn't support forking in a thread, so disable QProcess
-#  define QT_NO_PROCESS
-#endif
-
 #if defined (__ELF__)
 #  if defined (Q_OS_LINUX) || defined (Q_OS_SOLARIS) || defined (Q_OS_FREEBSD) || defined (Q_OS_OPENBSD) || defined (Q_OS_IRIX)
 #    define Q_OF_ELF
diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp
index 70a70c2..4b689c5 100644
--- a/src/corelib/io/qprocess.cpp
+++ b/src/corelib/io/qprocess.cpp
@@ -751,12 +751,16 @@ QProcessPrivate::QProcessPrivate()
     sequenceNumber = 0;
     exitCode = 0;
     exitStatus = QProcess::NormalExit;
+#ifndef Q_OS_QNX
     startupSocketNotifier = 0;
+#endif
     deathNotifier = 0;
     notifier = 0;
     pipeWriter = 0;
+#ifndef Q_OS_QNX
     childStartedPipe[0] = INVALID_Q_PIPE;
     childStartedPipe[1] = INVALID_Q_PIPE;
+#endif
     deathPipe[0] = INVALID_Q_PIPE;
     deathPipe[1] = INVALID_Q_PIPE;
     exitCode = 0;
@@ -825,11 +829,13 @@ void QProcessPrivate::cleanup()
         qDeleteInEventHandler(stdinChannel.notifier);
         stdinChannel.notifier = 0;
     }
+#ifndef Q_OS_QNX
     if (startupSocketNotifier) {
         startupSocketNotifier->setEnabled(false);
         qDeleteInEventHandler(startupSocketNotifier);
         startupSocketNotifier = 0;
     }
+#endif
     if (deathNotifier) {
         deathNotifier->setEnabled(false);
         qDeleteInEventHandler(deathNotifier);
@@ -842,7 +848,9 @@ void QProcessPrivate::cleanup()
     destroyPipe(stdoutChannel.pipe);
     destroyPipe(stderrChannel.pipe);
     destroyPipe(stdinChannel.pipe);
+#ifndef Q_OS_QNX
     destroyPipe(childStartedPipe);
+#endif
     destroyPipe(deathPipe);
 #ifdef Q_OS_UNIX
     serial = 0;
@@ -1077,8 +1085,10 @@ bool QProcessPrivate::_q_startupNotification()
     qDebug("QProcessPrivate::startupNotification()");
 #endif
 
+#ifndef Q_OS_QNX
     if (startupSocketNotifier)
         startupSocketNotifier->setEnabled(false);
+#endif
     if (processStarted()) {
         q->setProcessState(QProcess::Running);
         emit q->started();
diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h
index 9adb331..f24a7bc 100644
--- a/src/corelib/io/qprocess_p.h
+++ b/src/corelib/io/qprocess_p.h
@@ -288,11 +288,15 @@ public:
     QRingBuffer errorReadBuffer;
     QRingBuffer writeBuffer;
 
+#ifndef Q_OS_QNX
     Q_PIPE childStartedPipe[2];
+#endif
     Q_PIPE deathPipe[2];
     void destroyPipe(Q_PIPE pipe[2]);
 
+#ifndef Q_OS_QNX
     QSocketNotifier *startupSocketNotifier;
+#endif
     QSocketNotifier *deathNotifier;
 
     // the wonderful windows notifier
@@ -301,8 +305,10 @@ public:
     QWinEventNotifier *processFinishedNotifier;
 
     void startProcess();
-#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
+#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN) && !defined(Q_OS_QNX)
     void execChild(const char *workingDirectory, char **path, char **argv, char **envp);
+#elif defined(Q_OS_QNX)
+    pid_t spawnChild(const char *workingDirectory, char **argv, char **envp);
 #endif
     bool processStarted();
     void terminateProcess();
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
index 07e3087..725e4c5 100644
--- a/src/corelib/io/qprocess_unix.cpp
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -105,6 +105,10 @@ QT_END_NAMESPACE
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef Q_OS_QNX
+#  include <spawn.h>
+#endif
+
 
 QT_BEGIN_NAMESPACE
 
@@ -521,16 +525,6 @@ static char **_q_dupEnvironment(const QProcessEnvironmentPrivate::Hash &environm
     return envp;
 }
 
-// under QNX RTOS we have to use vfork() when multithreading
-inline pid_t qt_fork()
-{
-#if defined(Q_OS_QNX)
-    return vfork();
-#else
-    return fork();
-#endif
-}
-
 #ifdef Q_OS_MAC
 Q_GLOBAL_STATIC(QMutex, cfbundleMutex);
 #endif
@@ -550,15 +544,18 @@ void QProcessPrivate::startProcess()
         !createChannel(stdoutChannel) ||
         !createChannel(stderrChannel))
         return;
+#if !defined(Q_OS_QNX)
     qt_create_pipe(childStartedPipe);
+#endif
     qt_create_pipe(deathPipe);
 
     if (threadData->eventDispatcher) {
+#if !defined(Q_OS_QNX)
         startupSocketNotifier = new QSocketNotifier(childStartedPipe[0],
                                                     QSocketNotifier::Read, q);
         QObject::connect(startupSocketNotifier, SIGNAL(activated(int)),
                          q, SLOT(_q_startupNotification()));
-
+#endif
         deathNotifier = new QSocketNotifier(deathPipe[0],
                                             QSocketNotifier::Read, q);
         QObject::connect(deathNotifier, SIGNAL(activated(int)),
@@ -650,7 +647,11 @@ void QProcessPrivate::startProcess()
 
     // Start the process manager, and fork off the child process.
     processManager()->lock();
-    pid_t childPid = qt_fork();
+#if defined(Q_OS_QNX)
+    pid_t childPid = spawnChild(workingDirPtr, argv, envp);
+#else
+    pid_t childPid = fork();
+#endif
     int lastForkErrno = errno;
     if (childPid != 0) {
         // Clean up duplicated memory.
@@ -668,7 +669,7 @@ void QProcessPrivate::startProcess()
     if (childPid < 0) {
         // Cleanup, report error and return
 #if defined (QPROCESS_DEBUG)
-        qDebug("qt_fork failed: %s", qPrintable(qt_error_string(lastForkErrno)));
+        qDebug("fork() failed: %s", qPrintable(qt_error_string(lastForkErrno)));
 #endif
         processManager()->unlock();
         q->setProcessState(QProcess::NotRunning);
@@ -679,11 +680,13 @@ void QProcessPrivate::startProcess()
         return;
     }
 
+#if !defined(Q_OS_QNX)
     // Start the child.
     if (childPid == 0) {
         execChild(workingDirPtr, path, argv, envp);
         ::_exit(-1);
     }
+#endif
 
     // Register the child. In the mean time, we can get a SIGCHLD, so we need
     // to keep the lock held to avoid a race to catch the child.
@@ -694,14 +697,15 @@ void QProcessPrivate::startProcess()
     // parent
     // close the ends we don't use and make all pipes non-blocking
     ::fcntl(deathPipe[0], F_SETFL, ::fcntl(deathPipe[0], F_GETFL) | O_NONBLOCK);
+#if !defined(Q_OS_QNX)
     qt_safe_close(childStartedPipe[1]);
     childStartedPipe[1] = -1;
+#endif
 
     if (stdinChannel.pipe[0] != -1) {
         qt_safe_close(stdinChannel.pipe[0]);
         stdinChannel.pipe[0] = -1;
     }
-
     if (stdinChannel.pipe[1] != -1)
         ::fcntl(stdinChannel.pipe[1], F_SETFL, ::fcntl(stdinChannel.pipe[1], F_GETFL) | O_NONBLOCK);
 
@@ -709,7 +713,6 @@ void QProcessPrivate::startProcess()
         qt_safe_close(stdoutChannel.pipe[1]);
         stdoutChannel.pipe[1] = -1;
     }
-
     if (stdoutChannel.pipe[0] != -1)
         ::fcntl(stdoutChannel.pipe[0], F_SETFL, ::fcntl(stdoutChannel.pipe[0], F_GETFL) | O_NONBLOCK);
 
@@ -721,6 +724,7 @@ void QProcessPrivate::startProcess()
         ::fcntl(stderrChannel.pipe[0], F_SETFL, ::fcntl(stderrChannel.pipe[0], F_GETFL) | O_NONBLOCK);
 }
 
+#if !defined(Q_OS_QNX)
 void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv, char **envp)
 {
     ::signal(SIGPIPE, SIG_DFL);         // reset the signal that we ignored
@@ -728,17 +732,17 @@ void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv
     Q_Q(QProcess);
 
     // copy the stdin socket (without closing on exec)
-    qt_safe_dup2(stdinChannel.pipe[0], fileno(stdin), 0);
+    qt_safe_dup2(stdinChannel.pipe[0], QT_FILENO(stdin), 0);
 
     // copy the stdout and stderr if asked to
     if (processChannelMode != QProcess::ForwardedChannels) {
-        qt_safe_dup2(stdoutChannel.pipe[1], fileno(stdout), 0);
+        qt_safe_dup2(stdoutChannel.pipe[1], QT_FILENO(stdout), 0);
 
         // merge stdout and stderr if asked to
         if (processChannelMode == QProcess::MergedChannels) {
-            qt_safe_dup2(fileno(stdout), fileno(stderr), 0);
+            qt_safe_dup2(QT_FILENO(stdout), QT_FILENO(stderr), 0);
         } else {
-            qt_safe_dup2(stderrChannel.pipe[1], fileno(stderr), 0);
+            qt_safe_dup2(stderrChannel.pipe[1], QT_FILENO(stderr), 0);
         }
     }
 
@@ -807,6 +811,87 @@ bool QProcessPrivate::processStarted()
     return i <= 0;
 }
 
+#else // Q_OS_QNX
+
+static pid_t doSpawn(int fd_count, int fd_map[], char **argv, char **envp, bool spawn_detached)
+{
+    // A multi threaded QNX Process can't fork so we call spawn() instead.
+
+    struct inheritance inherit;
+    memset(&inherit, 0, sizeof(inherit));
+    inherit.flags |= SPAWN_SETSID;
+    inherit.flags |= SPAWN_CHECK_SCRIPT;
+    if (spawn_detached)
+        inherit.flags |= SPAWN_NOZOMBIE;
+    inherit.flags |= SPAWN_SETSIGDEF;
+    sigaddset(&inherit.sigdefault, SIGPIPE); // reset the signal that we ignored
+
+    pid_t childPid;
+    EINTR_LOOP(childPid, ::spawn(argv[0], fd_count, fd_map, &inherit, argv, envp));
+    if (childPid == -1) {
+        inherit.flags |= SPAWN_SEARCH_PATH;
+        EINTR_LOOP(childPid, ::spawn(argv[0], fd_count, fd_map, &inherit, argv, envp));
+    }
+
+    return childPid;
+}
+
+pid_t QProcessPrivate::spawnChild(const char *workingDir, char **argv, char **envp)
+{
+    Q_Q(QProcess);
+
+    const int fd_count = 3;
+    int fd_map[fd_count];
+    switch (processChannelMode) {
+    case QProcess::ForwardedChannels:
+        fd_map[0] = stdinChannel.pipe[0];
+        fd_map[1] = QT_FILENO(stdout);
+        fd_map[2] = QT_FILENO(stderr);
+        break;
+    case QProcess::MergedChannels:
+        fd_map[0] = stdinChannel.pipe[0];
+        fd_map[1] = stdoutChannel.pipe[1];
+        fd_map[2] = stdoutChannel.pipe[1];
+        break;
+    case QProcess::SeparateChannels:
+        fd_map[0] = stdinChannel.pipe[0];
+        fd_map[1] = stdoutChannel.pipe[1];
+        fd_map[2] = stderrChannel.pipe[1];
+        break;
+    }
+
+    // enter the working directory
+    char *oldWorkingDir = 0;
+    char buff[PATH_MAX + 1];
+    if (workingDir) {
+        oldWorkingDir = QT_GETCWD(buff, PATH_MAX + 1);
+        QT_CHDIR(workingDir);
+    }
+
+    pid_t childPid = doSpawn(fd_count, fd_map, argv, envp, false);
+
+    if (oldWorkingDir)
+        QT_CHDIR(oldWorkingDir);
+
+    if (childPid != -1) {
+        q->setProcessState(QProcess::Running);
+        QMetaObject::invokeMethod(q, "_q_startupNotification", Qt::QueuedConnection);
+    }
+
+    return childPid;
+}
+
+bool QProcessPrivate::processStarted()
+{
+    return processState == QProcess::Running;
+}
+
+bool QProcessPrivate::waitForStarted(int /*msecs*/)
+{
+    return processStarted();
+}
+#endif // Q_OS_QNX
+
 qint64 QProcessPrivate::bytesAvailableFromStdout() const
 {
     int nbytes = 0;
@@ -924,6 +1009,7 @@ static int qt_timeout_value(int msecs, int elapsed)
     return timeout < 0 ? 0 : timeout;
 }
 
+#if !defined(Q_OS_QNX)
 bool QProcessPrivate::waitForStarted(int msecs)
 {
     Q_Q(QProcess);
@@ -951,6 +1037,7 @@ bool QProcessPrivate::waitForStarted(int msecs)
 #endif
     return startedEmitted;
 }
+#endif // Q_OS_QNX
 
 bool QProcessPrivate::waitForReadyRead(int msecs)
 {
@@ -972,8 +1059,10 @@ bool QProcessPrivate::waitForReadyRead(int msecs)
         int nfds = deathPipe[0];
         FD_SET(deathPipe[0], &fdread);
 
+#if !defined(Q_OS_QNX)
         if (processState == QProcess::Starting)
             add_fd(nfds, childStartedPipe[0], &fdread);
+#endif
 
         if (stdoutChannel.pipe[0] != -1)
             add_fd(nfds, stdoutChannel.pipe[0], &fdread);
@@ -994,10 +1083,12 @@ bool QProcessPrivate::waitForReadyRead(int msecs)
 	    return false;
 	}
 
+#if !defined(Q_OS_QNX)
 	if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
             if (!_q_startupNotification())
                 return false;
 	}
+#endif
 
         bool readyReadEmitted = false;
 	if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread)) {
@@ -1044,8 +1135,10 @@ bool QProcessPrivate::waitForBytesWritten(int msecs)
         int nfds = deathPipe[0];
         FD_SET(deathPipe[0], &fdread);
 
+#if !defined(Q_OS_QNX)
         if (processState == QProcess::Starting)
             add_fd(nfds, childStartedPipe[0], &fdread);
+#endif
 
         if (stdoutChannel.pipe[0] != -1)
             add_fd(nfds, stdoutChannel.pipe[0], &fdread);
@@ -1068,10 +1161,12 @@ bool QProcessPrivate::waitForBytesWritten(int msecs)
 	    return false;
 	}
 
+#if !defined(Q_OS_QNX)
 	if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
 	    if (!_q_startupNotification())
 		return false;
 	}
+#endif
 
 	if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
 	    return _q_canWrite();
@@ -1109,8 +1204,10 @@ bool QProcessPrivate::waitForFinished(int msecs)
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
 
+#if !defined(Q_OS_QNX)
         if (processState == QProcess::Starting)
             add_fd(nfds, childStartedPipe[0], &fdread);
+#endif
 
         if (stdoutChannel.pipe[0] != -1)
             add_fd(nfds, stdoutChannel.pipe[0], &fdread);
@@ -1134,10 +1231,12 @@ bool QProcessPrivate::waitForFinished(int msecs)
 	    return false;
 	}
 
+#if !defined(Q_OS_QNX)
 	if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
 	    if (!_q_startupNotification())
 		return false;
 	}
+#endif
 	if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
 	    _q_canWrite();
 
@@ -1199,6 +1298,47 @@ void QProcessPrivate::_q_notified()
 {
 }
 
+#if defined(Q_OS_QNX)
+bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid)
+{
+    QByteArray encodedWorkingDirectory = QFile::encodeName(workingDirectory);
+
+    // enter the working directory
+    char *oldWorkingDir = 0;
+    char buff[PATH_MAX + 1];
+    if (!encodedWorkingDirectory.isEmpty()) {
+        oldWorkingDir = QT_GETCWD(buff, PATH_MAX + 1);
+        QT_CHDIR(encodedWorkingDirectory.constData());
+    }
+
+    const int fd_count = 3;
+    int fd_map[fd_count] = { QT_FILENO(stdin), QT_FILENO(stdout), QT_FILENO(stderr) };
+
+    QList<QByteArray> enc_args;
+    enc_args.append(QFile::encodeName(program));
+    for (int i = 0; i < arguments.size(); ++i)
+        enc_args.append(arguments.at(i).toLocal8Bit());
+
+    const int argc = enc_args.size();
+    QScopedArrayPointer<char*> raw_argv(new char*[argc + 1]);
+    for (int i = 0; i < argc; ++i)
+        raw_argv[i] = const_cast<char *>(enc_args.at(i).data());
+    raw_argv[argc] = 0;
+
+    char **envp = 0; // inherit environment
+
+    pid_t childPid = doSpawn(fd_count, fd_map, raw_argv.data(), envp, true);
+    if (pid && childPid != -1)
+        *pid = childPid;
+
+    if (oldWorkingDir)
+        QT_CHDIR(oldWorkingDir);
+
+    return childPid != -1;
+}
+
+#else
+
 bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid)
 {
     processManager()->start();
@@ -1212,7 +1352,7 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
     int pidPipe[2];
     qt_safe_pipe(pidPipe);
 
-    pid_t childPid = qt_fork();
+    pid_t childPid = fork();
     if (childPid == 0) {
         struct sigaction noaction;
         memset(&noaction, 0, sizeof(noaction));
@@ -1224,7 +1364,7 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
         qt_safe_close(startedPipe[0]);
         qt_safe_close(pidPipe[0]);
 
-        pid_t doubleForkPid = qt_fork();
+        pid_t doubleForkPid = fork();
         if (doubleForkPid == 0) {
             qt_safe_close(pidPipe[1]);
 
@@ -1312,6 +1452,7 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
     qt_safe_close(pidPipe[0]);
     return success;
 }
+#endif // Q_OS_QNX
 
 void QProcessPrivate::initializeProcessManager()
 {
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index 7694a0f..dd46bc5 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -98,6 +98,12 @@
 #  include <taskLib.h>
 #endif
 
+#ifdef Q_OS_QNX
+#  include <sys/neutrino.h>
+#  include <pthread.h>
+#  include <sched.h>
+#endif
+
 QT_BEGIN_NAMESPACE
 
 class QMutexUnlocker
@@ -353,6 +359,22 @@ QCoreApplicationPrivate::QCoreApplicationPrivate(int &aargc, char **aargv, uint
     qt_application_thread_id = QThread::currentThreadId();
 #endif
 
+#ifdef Q_OS_QNX
+    // make the kernel attempt to emulate an instruction with a misaligned access
+    // if the attempt fails, it faults with a SIGBUS
+    int tv = -1;
+    ThreadCtl(_NTO_TCTL_ALIGN_FAULT, &tv);
+
+    // without Round Robin drawn intensive apps will hog the cpu
+    // and make the system appear frozen
+    int sched_policy;
+    sched_param param;
+    if (pthread_getschedparam(0, &sched_policy, &param) == 0 && sched_policy != SCHED_RR) {
+        sched_policy = SCHED_RR;
+        pthread_setschedparam(0, sched_policy, &param);
+    }
+#endif
+
     // note: this call to QThread::currentThread() may end up setting theMainThread!
     if (QThread::currentThread() != theMainThread)
         qWarning("WARNING: QApplication was not created in the main() thread.");
diff --git a/src/corelib/kernel/qsharedmemory.cpp b/src/corelib/kernel/qsharedmemory.cpp
index 2882279..371974c 100644
--- a/src/corelib/kernel/qsharedmemory.cpp
+++ b/src/corelib/kernel/qsharedmemory.cpp
@@ -80,6 +80,8 @@ QSharedMemoryPrivate::makePlatformSafeKey(const QString &key,
     return result;
 #elif defined(Q_OS_SYMBIAN)
     return result.left(KMaxKernelName);
+#elif defined(QT_POSIX_IPC)
+    return QLatin1Char('/') + result;
 #else
     return QDir::tempPath() + QLatin1Char('/') + result;
 #endif
@@ -117,6 +119,9 @@ QSharedMemoryPrivate::makePlatformSafeKey(const QString &key,
   process crashes without running the QSharedMemory destructor, the
   shared memory segment survives the crash.
 
+  \o QNX: Due to possible race conditions in the POSIX IPC implementation, create()
+  should be called prior to any attach() calls (even across multiple threads).
+
   \o HP-UX: Only one attach to a shared memory segment is allowed per
   process. This means that QSharedMemory should not be used across
   multiple threads in the same process in HP-UX.
diff --git a/src/corelib/kernel/qsharedmemory_p.h b/src/corelib/kernel/qsharedmemory_p.h
index 21b8612..780e52e 100644
--- a/src/corelib/kernel/qsharedmemory_p.h
+++ b/src/corelib/kernel/qsharedmemory_p.h
@@ -135,6 +135,8 @@ public:
             const QString &prefix = QLatin1String("qipc_sharedmemory_"));
 #ifdef Q_OS_WIN
     HANDLE handle();
+#elif defined(QT_POSIX_IPC)
+    int handle();
 #else
     key_t handle();
 #endif
@@ -166,6 +168,8 @@ private:
     HANDLE hand;
 #elif defined(Q_OS_SYMBIAN)
     RChunk chunk;
+#elif defined(QT_POSIX_IPC)
+    int hand;
 #else
     key_t unix_key;
 #endif
diff --git a/src/corelib/kernel/qsharedmemory_unix.cpp b/src/corelib/kernel/qsharedmemory_unix.cpp
index e991ce9..a086acd 100644
--- a/src/corelib/kernel/qsharedmemory_unix.cpp
+++ b/src/corelib/kernel/qsharedmemory_unix.cpp
@@ -50,8 +50,12 @@
 #ifndef QT_NO_SHAREDMEMORY
 #include <sys/types.h>
 #include <sys/ipc.h>
+#ifndef QT_POSIX_IPC
 #include <sys/shm.h>
+#else
+#include <sys/mman.h>
 #include <sys/stat.h>
+#endif
 #include <fcntl.h>
 #include <unistd.h>
 #endif // QT_NO_SHAREDMEMORY
@@ -70,7 +74,11 @@ QSharedMemoryPrivate::QSharedMemoryPrivate()
 #ifndef QT_NO_SYSTEMSEMAPHORE
       systemSemaphore(QString()), lockedByMe(false),
 #endif
+#ifndef QT_POSIX_IPC
       unix_key(0)
+#else
+      hand(0)
+#endif
 {
 }
 
@@ -91,12 +99,18 @@ void QSharedMemoryPrivate::setErrorString(const QString &function)
         errorString = QSharedMemory::tr("%1: doesn't exist").arg(function);
         error = QSharedMemory::NotFound;
         break;
+    case EAGAIN:
     case EMFILE:
+    case ENFILE:
     case ENOMEM:
     case ENOSPC:
         errorString = QSharedMemory::tr("%1: out of resources").arg(function);
         error = QSharedMemory::OutOfResources;
         break;
+    case EOVERFLOW:
+        errorString = QSharedMemory::tr("%1: invalid size").arg(function);
+        error = QSharedMemory::InvalidSize;
+        break;
     default:
         errorString = QSharedMemory::tr("%1: unknown error %2").arg(function).arg(errno);
         error = QSharedMemory::UnknownError;
@@ -112,6 +126,7 @@ void QSharedMemoryPrivate::setErrorString(const QString &function)
 
     If not already made create the handle used for accessing the shared memory.
 */
+#ifndef QT_POSIX_IPC
 key_t QSharedMemoryPrivate::handle()
 {
     // already made
@@ -140,6 +155,20 @@ key_t QSharedMemoryPrivate::handle()
     }
     return unix_key;
 }
+#else
+int QSharedMemoryPrivate::handle()
+{
+    // don't allow making handles on empty keys
+    QString safeKey = makePlatformSafeKey(key);
+    if (safeKey.isEmpty()) {
+        errorString = QSharedMemory::tr("%1: key is empty").arg(QLatin1String("QSharedMemory::handle"));
+        error = QSharedMemory::KeyError;
+        return 0;
+    }
+
+    return 1;
+}
+#endif // QT_POSIX_IPC
 
 #endif // QT_NO_SHAREDMEMORY
 
@@ -155,6 +184,7 @@ key_t QSharedMemoryPrivate::handle()
 */
 int QSharedMemoryPrivate::createUnixKeyFile(const QString &fileName)
 {
+#ifndef QT_POSIX_IPC
     if (QFile::exists(fileName))
         return 0;
 
@@ -168,6 +198,11 @@ int QSharedMemoryPrivate::createUnixKeyFile(const QString &fileName)
         qt_safe_close(fd);
     }
     return 1;
+#else
+    Q_UNUSED(fileName);
+    // nothing to do
+    return -1;
+#endif
 }
 #endif // QT_NO_SHAREDMEMORY && QT_NO_SYSTEMSEMAPHORE
 
@@ -175,11 +210,17 @@ int QSharedMemoryPrivate::createUnixKeyFile(const QString &fileName)
 
 void QSharedMemoryPrivate::cleanHandle()
 {
+#ifndef QT_POSIX_IPC
     unix_key = 0;
+#else
+    qt_safe_close(hand);
+    hand = 0;
+#endif
 }
 
 bool QSharedMemoryPrivate::create(int size)
 {
+#ifndef QT_POSIX_IPC
     // build file if needed
     int built = createUnixKeyFile(nativeKey);
     if (built == -1) {
@@ -211,12 +252,46 @@ bool QSharedMemoryPrivate::create(int size)
             QFile::remove(nativeKey);
         return false;
     }
+#else
+    if (!handle())
+        return false;
+
+    QByteArray shmName = QFile::encodeName(makePlatformSafeKey(key));
+
+    int fd;
+    EINTR_LOOP(fd, shm_open(shmName.constData(), O_RDWR | O_CREAT | O_EXCL, 0666));
+    if (fd == -1) {
+        QString function = QLatin1String("QSharedMemory::create");
+        switch (errno) {
+        case ENAMETOOLONG:
+        case EINVAL:
+            errorString = QSharedMemory::tr("%1: bad name").arg(function);
+            error = QSharedMemory::KeyError;
+            break;
+        default:
+            setErrorString(function);
+        }
+        return false;
+    }
+
+    // the size may only be set once; ignore errors
+    int ret;
+    EINTR_LOOP(ret, ftruncate(fd, size));
+    if (ret == -1) {
+        setErrorString(QLatin1String("QSharedMemory::create (ftruncate)"));
+        qt_safe_close(fd);
+        return false;
+    }
+
+    qt_safe_close(fd);
+#endif // QT_POSIX_IPC
 
     return true;
 }
 
 bool QSharedMemoryPrivate::attach(QSharedMemory::AccessMode mode)
 {
+#ifndef QT_POSIX_IPC
     // grab the shared memory segment id
     int id = shmget(unix_key, 0, (mode == QSharedMemory::ReadOnly ? 0444 : 0660));
     if (-1 == id) {
@@ -240,12 +315,55 @@ bool QSharedMemoryPrivate::attach(QSharedMemory::AccessMode mode)
         setErrorString(QLatin1String("QSharedMemory::attach (shmctl)"));
         return false;
     }
+#else
+    QByteArray shmName = QFile::encodeName(makePlatformSafeKey(key));
+
+    int oflag = (mode == QSharedMemory::ReadOnly ? O_RDONLY : O_RDWR);
+    mode_t omode = (mode == QSharedMemory::ReadOnly ? 0444 : 0660);
+
+    EINTR_LOOP(hand, shm_open(shmName.constData(), oflag, omode));
+    if (hand == -1) {
+        QString function = QLatin1String("QSharedMemory::attach (shm_open)");
+        switch (errno) {
+        case ENAMETOOLONG:
+        case EINVAL:
+            errorString = QSharedMemory::tr("%1: bad name").arg(function);
+            error = QSharedMemory::KeyError;
+            break;
+        default:
+            setErrorString(function);
+        }
+        hand = 0;
+        return false;
+    }
+
+    // grab the size
+    QT_STATBUF st;
+    if (QT_FSTAT(hand, &st) == -1) {
+        setErrorString(QLatin1String("QSharedMemory::attach (fstat)"));
+        cleanHandle();
+        return false;
+    }
+    size = st.st_size;
+
+    // grab the memory
+    int mprot = (mode == QSharedMemory::ReadOnly ? PROT_READ : PROT_READ | PROT_WRITE);
+    memory = mmap(0, size, mprot, MAP_SHARED, hand, 0);
+    if (memory == MAP_FAILED || !memory) {
+        setErrorString(QLatin1String("QSharedMemory::attach (mmap)"));
+        cleanHandle();
+        memory = 0;
+        size = 0;
+        return false;
+    }
+#endif // QT_POSIX_IPC
 
     return true;
 }
 
 bool QSharedMemoryPrivate::detach()
 {
+#ifndef QT_POSIX_IPC
     // detach from the memory segment
     if (-1 == shmdt(memory)) {
         QString function = QLatin1String("QSharedMemory::detach");
@@ -292,6 +410,31 @@ bool QSharedMemoryPrivate::detach()
         if (!QFile::remove(nativeKey))
             return false;
     }
+#else
+    // detach from the memory segment
+    if (munmap(memory, size) == -1) {
+        setErrorString(QLatin1String("QSharedMemory::detach (munmap)"));
+        return false;
+    }
+    memory = 0;
+    size = 0;
+
+    // get the number of current attachments
+    int shm_nattch = 0;
+    QT_STATBUF st;
+    if (QT_FSTAT(hand, &st) == 0) {
+        // subtract 2 from linkcount: one for our own open and one for the dir entry
+        shm_nattch = st.st_nlink - 2;
+    }
+    cleanHandle();
+    // if there are no attachments then unlink the shared memory
+    if (shm_nattch == 0) {
+        QByteArray shmName = QFile::encodeName(makePlatformSafeKey(key));
+        if (shm_unlink(shmName.constData()) == -1 && errno != ENOENT)
+            setErrorString(QLatin1String("QSharedMemory::detach (shm_unlink)"));
+    }
+#endif // QT_POSIX_IPC
+
     return true;
 }
 
diff --git a/src/corelib/kernel/qsystemsemaphore.cpp b/src/corelib/kernel/qsystemsemaphore.cpp
index 98ee6f4..ae30348 100644
--- a/src/corelib/kernel/qsystemsemaphore.cpp
+++ b/src/corelib/kernel/qsystemsemaphore.cpp
@@ -151,6 +151,11 @@ QT_BEGIN_NAMESPACE
   creates a new semaphore for that key and sets its resource count to
   \a initialValue.
 
+  In QNX, if the \a mode is \l {QSystemSemaphore::} {Create} and the
+  system already has a semaphore identified by \a key, that semaphore
+  will be deleted and the new one will be created for that key with
+  a resource count set to \a initialValue.
+
   In Windows and in Symbian, \a mode is ignored, and the system always tries to
   create a semaphore for the specified \a key. If the system does not
   already have a semaphore identified as \a key, it creates the
@@ -234,7 +239,7 @@ void QSystemSemaphore::setKey(const QString &key, int initialValue, AccessMode m
         return;
     d->error = NoError;
     d->errorString = QString();
-#if !defined(Q_OS_WIN) && !defined(Q_OS_SYMBIAN)
+#if !defined(Q_OS_WIN) && !defined(Q_OS_SYMBIAN) && !defined(QT_POSIX_IPC)
     // optimization to not destroy/create the file & semaphore
     if (key == d->key && mode == Create && d->createdSemaphore && d->createdFile) {
         d->initialValue = initialValue;
diff --git a/src/corelib/kernel/qsystemsemaphore_p.h b/src/corelib/kernel/qsystemsemaphore_p.h
index 3e5f737..d84d416 100644
--- a/src/corelib/kernel/qsystemsemaphore_p.h
+++ b/src/corelib/kernel/qsystemsemaphore_p.h
@@ -61,6 +61,9 @@
 #ifndef Q_OS_WINCE
 #  include <sys/types.h>
 #endif
+#ifdef QT_POSIX_IPC
+#  include <semaphore.h>
+#endif
 
 #ifdef Q_OS_SYMBIAN
 class RSemaphore;
@@ -84,6 +87,9 @@ public:
 #elif defined(Q_OS_SYMBIAN)
     int handle(QSystemSemaphore::AccessMode mode = QSystemSemaphore::Open);
     void setErrorString(const QString &function,int err = 0);
+#elif defined(QT_POSIX_IPC)
+    bool handle(QSystemSemaphore::AccessMode mode = QSystemSemaphore::Open);
+    void setErrorString(const QString &function);
 #else
     key_t handle(QSystemSemaphore::AccessMode mode = QSystemSemaphore::Open);
     void setErrorString(const QString &function);
@@ -99,6 +105,9 @@ public:
     HANDLE semaphoreLock;
 #elif defined(Q_OS_SYMBIAN)
     RSemaphore semaphore;
+#elif defined(QT_POSIX_IPC)
+    sem_t *semaphore;
+    bool createdSemaphore;
 #else
     key_t unix_key;
     int semaphore;
diff --git a/src/corelib/kernel/qsystemsemaphore_unix.cpp b/src/corelib/kernel/qsystemsemaphore_unix.cpp
index 704afaf..e060eb2 100644
--- a/src/corelib/kernel/qsystemsemaphore_unix.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_unix.cpp
@@ -50,7 +50,9 @@
 
 #include <sys/types.h>
 #include <sys/ipc.h>
+#ifndef QT_POSIX_IPC
 #include <sys/sem.h>
+#endif
 #include <fcntl.h>
 #include <errno.h>
 
@@ -67,7 +69,11 @@
 QT_BEGIN_NAMESPACE
 
 QSystemSemaphorePrivate::QSystemSemaphorePrivate() :
+#ifndef QT_POSIX_IPC
     unix_key(-1), semaphore(-1), createdFile(false),
+#else
+    semaphore(SEM_FAILED),
+#endif
     createdSemaphore(false), error(QSystemSemaphore::NoError)
 {
 }
@@ -90,10 +96,18 @@ void QSystemSemaphorePrivate::setErrorString(const QString &function)
         error = QSystemSemaphore::NotFound;
         break;
     case ERANGE:
+    case ENOMEM:
     case ENOSPC:
+    case EMFILE:
+    case ENFILE:
+    case EOVERFLOW:
         errorString = QCoreApplication::translate("QSystemSemaphore", "%1: out of resources").arg(function);
         error = QSystemSemaphore::OutOfResources;
         break;
+    case ENAMETOOLONG:
+        errorString = QCoreApplication::translate("QSystemSemaphore", "%1: name error").arg(function);
+        error = QSystemSemaphore::KeyError;
+        break;
     default:
         errorString = QCoreApplication::translate("QSystemSemaphore", "%1: unknown error %2").arg(function).arg(errno);
         error = QSystemSemaphore::UnknownError;
@@ -109,6 +123,7 @@ void QSystemSemaphorePrivate::setErrorString(const QString &function)
 
     Initialise the semaphore
 */
+#ifndef QT_POSIX_IPC
 key_t QSystemSemaphorePrivate::handle(QSystemSemaphore::AccessMode mode)
 {
     if (-1 != unix_key)
@@ -170,6 +185,54 @@ key_t QSystemSemaphorePrivate::handle(QSystemSemaphore::AccessMode mode)
 
     return unix_key;
 }
+#else
+bool QSystemSemaphorePrivate::handle(QSystemSemaphore::AccessMode mode)
+{
+    if (semaphore != SEM_FAILED)
+        return true;  // we already have a semaphore
+
+    if (fileName.isEmpty()) {
+        errorString = QCoreApplication::tr("%1: key is empty", "QSystemSemaphore").arg(QLatin1String("QSystemSemaphore::handle"));
+        error = QSystemSemaphore::KeyError;
+        return false;
+    }
+
+    QByteArray semName = QFile::encodeName(fileName);
+
+    // Always try with O_EXCL so we know whether we created the semaphore.
+    int oflag = O_CREAT | O_EXCL;
+    for (int tryNum = 0, maxTries = 1; tryNum < maxTries; ++tryNum) {
+        do {
+            semaphore = sem_open(semName.constData(), oflag, 0666, initialValue);
+        } while (semaphore == SEM_FAILED && errno == EINTR);
+        if (semaphore == SEM_FAILED && errno == EEXIST) {
+            if (mode == QSystemSemaphore::Create) {
+                if (sem_unlink(semName.constData()) == -1 && errno != ENOENT) {
+                    setErrorString(QLatin1String("QSystemSemaphore::handle (sem_unlink)"));
+                    return false;
+                }
+                // Race condition: the semaphore might be recreated before
+                // we call sem_open again, so we'll retry several times.
+                maxTries = 3;
+            } else {
+                // Race condition: if it no longer exists at the next sem_open
+                // call, we won't realize we created it, so we'll leak it later.
+                oflag &= ~O_EXCL;
+                maxTries = 2;
+            }
+        } else {
+            break;
+        }
+    }
+    if (semaphore == SEM_FAILED) {
+        setErrorString(QLatin1String("QSystemSemaphore::handle"));
+        return false;
+    }
+
+    createdSemaphore = (oflag & O_EXCL) != 0;
+    return true;
+}
+#endif // QT_POSIX_IPC
 
 /*!
     \internal
@@ -178,6 +241,7 @@ key_t QSystemSemaphorePrivate::handle(QSystemSemaphore::AccessMode mode)
 */
 void QSystemSemaphorePrivate::cleanHandle()
 {
+#ifndef QT_POSIX_IPC
     unix_key = -1;
 
     // remove the file if we made it
@@ -198,6 +262,27 @@ void QSystemSemaphorePrivate::cleanHandle()
         }
         createdSemaphore = false;
     }
+#else
+    if (semaphore != SEM_FAILED) {
+        if (sem_close(semaphore) == -1) {
+            setErrorString(QLatin1String("QSystemSemaphore::cleanHandle (sem_close)"));
+#ifdef QSYSTEMSEMAPHORE_DEBUG
+            qDebug() << QLatin1String("QSystemSemaphore::cleanHandle sem_close failed.");
+#endif
+        }
+        semaphore = SEM_FAILED;
+    }
+
+    if (createdSemaphore) {
+        if (sem_unlink(QFile::encodeName(fileName).constData()) == -1 && errno != ENOENT) {
+            setErrorString(QLatin1String("QSystemSemaphore::cleanHandle (sem_unlink)"));
+#ifdef QSYSTEMSEMAPHORE_DEBUG
+            qDebug() << QLatin1String("QSystemSemaphore::cleanHandle sem_unlink failed.");
+#endif
+        }
+        createdSemaphore = false;
+    }
+#endif // QT_POSIX_IPC
 }
 
 /*!
@@ -205,6 +290,7 @@ void QSystemSemaphorePrivate::cleanHandle()
 */
 bool QSystemSemaphorePrivate::modifySemaphore(int count)
 {
+#ifndef QT_POSIX_IPC
     if (-1 == handle())
         return false;
 
@@ -229,6 +315,44 @@ bool QSystemSemaphorePrivate::modifySemaphore(int count)
 #endif
         return false;
     }
+#else
+    if (!handle())
+        return false;
+
+    if (count > 0) {
+        int cnt = count;
+        do {
+            if (sem_post(semaphore) == -1) {
+                setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore (sem_post)"));
+#ifdef QSYSTEMSEMAPHORE_DEBUG
+                qDebug() << QLatin1String("QSystemSemaphore::modify sem_post failed") << count << errno;
+#endif
+                // rollback changes to preserve the SysV semaphore behavior
+                for ( ; cnt < count; ++cnt) {
+                    register int res;
+                    EINTR_LOOP(res, sem_wait(semaphore));
+                }
+                return false;
+            }
+            --cnt;
+        } while (cnt > 0);
+    } else {
+        register int res;
+        EINTR_LOOP(res, sem_wait(semaphore));
+        if (res == -1) {
+            // If the semaphore was removed be nice and create it and then modifySemaphore again
+            if (errno == EINVAL || errno == EIDRM) {
+                semaphore = SEM_FAILED;
+                return modifySemaphore(count);
+            }
+            setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore (sem_wait)"));
+#ifdef QSYSTEMSEMAPHORE_DEBUG
+            qDebug() << QLatin1String("QSystemSemaphore::modify sem_wait failed") << count << errno;
+#endif
+            return false;
+        }
+    }
+#endif // QT_POSIX_IPC
 
     return true;
 }
diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp
index 839a396..765969e 100644
--- a/src/corelib/thread/qthread_unix.cpp
+++ b/src/corelib/thread/qthread_unix.cpp
@@ -479,6 +479,11 @@ void QThread::usleep(unsigned long usecs)
 // sched_priority is OUT only
 static bool calculateUnixPriority(int priority, int *sched_policy, int *sched_priority)
 {
+#ifdef Q_OS_QNX
+    // without Round Robin drawn intensive apps will hog the cpu
+    // and make the system appear frozen
+   *sched_policy = SCHED_RR;
+#endif
 #ifdef SCHED_IDLE
     if (priority == QThread::IdlePriority) {
         *sched_policy = SCHED_IDLE;