Fri Jan 21 05:47:49 UTC 202220220121054749

a/aaa_libraries-15.0-x86_64-15.txz:  Rebuilt.
  Upgraded: libzstd.so.1.5.2.
a/kernel-firmware-20220119_0c6a7b3-noarch-1.txz:  Upgraded.
a/kernel-generic-5.15.16-x86_64-1.txz:  Upgraded.
a/kernel-huge-5.15.16-x86_64-1.txz:  Upgraded.
a/kernel-modules-5.15.16-x86_64-1.txz:  Upgraded.
ap/vim-8.2.4166-x86_64-1.txz:  Upgraded.
d/kernel-headers-5.15.16-x86-1.txz:  Upgraded.
d/rust-1.58.1-x86_64-1.txz:  Upgraded.
k/kernel-source-5.15.16-noarch-1.txz:  Upgraded.
l/qt5-5.15.3_20211130_014c375b-x86_64-2.txz:  Rebuilt.
  Applied upstream patch:
  [PATCH] Move the wayland socket polling to a separate event thread.
  Thanks to LuckyCyborg.
l/svgalib-1.9.25-x86_64-7.txz:  Rebuilt.
  Don't try to use the (broken) assembly. Thanks to nobodino.
l/zstd-1.5.2-x86_64-1.txz:  Upgraded.
x/ibus-m17n-1.4.9-x86_64-1.txz:  Upgraded.
xap/vim-gvim-8.2.4166-x86_64-1.txz:  Upgraded.
extra/php80/php80-8.0.15-x86_64-1.txz:  Upgraded.
extra/php81/php81-8.1.2-x86_64-1.txz:  Upgraded.
isolinux/initrd.img:  Rebuilt.
kernels/*:  Upgraded.
usb-and-pxe-installers/usbboot.img:  Rebuilt.

5 files changed, 1042 insertions, 6 deletions

diff --git a/source/l/qt5/patches/24.diff b/source/l/qt5/patches/24.diff
new file mode 100644
index 000000000..5921881b7
--- /dev/null
+++ b/source/l/qt5/patches/24.diff
@@ -0,0 +1,585 @@
+diff --git a/src/client/qwaylanddisplay.cpp b/src/client/qwaylanddisplay.cpp
+index ea344c61c3a4643f7c725a6287f20d742b210d24..a7ce280a5df538917758e50ba8d2ee117378d546 100644
+--- a/src/client/qwaylanddisplay.cpp
++++ b/src/client/qwaylanddisplay.cpp
+@@ -85,10 +85,203 @@
+ 
+ #include <errno.h>
+ 
++#include <tuple> // for std::tie
++
++static void checkWaylandError(struct wl_display *display)
++{
++    int ecode = wl_display_get_error(display);
++    if ((ecode == EPIPE || ecode == ECONNRESET)) {
++        // special case this to provide a nicer error
++        qWarning("The Wayland connection broke. Did the Wayland compositor die?");
++    } else {
++        qWarning("The Wayland connection experienced a fatal error: %s", strerror(ecode));
++    }
++    _exit(1);
++}
++
+ QT_BEGIN_NAMESPACE
+ 
+ namespace QtWaylandClient {
+ 
++class EventThread : public QThread
++{
++    Q_OBJECT
++public:
++    enum OperatingMode {
++        EmitToDispatch, // Emit the signal, allow dispatching in a differnt thread.
++        SelfDispatch, // Dispatch the events inside this thread.
++    };
++
++    EventThread(struct wl_display * wl, struct wl_event_queue * ev_queue,
++                OperatingMode mode)
++        : m_fd(wl_display_get_fd(wl))
++        , m_pipefd{ -1, -1 }
++        , m_wldisplay(wl)
++        , m_wlevqueue(ev_queue)
++        , m_mode(mode)
++        , m_reading(true)
++        , m_quitting(false)
++    {
++        setObjectName(QStringLiteral("WaylandEventThread"));
++    }
++
++    void readAndDispatchEvents()
++    {
++        /*
++         * Dispatch pending events and flush the requests at least once. If the event thread
++         * is not reading, try to call _prepare_read() to allow the event thread to poll().
++         * If that fails, re-try dispatch & flush again until _prepare_read() is successful.
++         *
++         * This allow any call to readAndDispatchEvents() to start event thread's polling,
++         * not only the one issued from event thread's waitForReading(), which means functions
++         * called from dispatch_pending() can safely spin an event loop.
++         */
++        for (;;) {
++            if (dispatchQueuePending() < 0) {
++                checkWaylandError(m_wldisplay);
++                return;
++            }
++
++            wl_display_flush(m_wldisplay);
++
++            // We have to check if event thread is reading every time we dispatch
++            // something, as that may recursively call this function.
++            if (m_reading.loadAcquire())
++                break;
++
++            if (prepareReadQueue() == 0) {
++                QMutexLocker l(&m_mutex);
++                m_reading.storeRelease(true);
++                m_cond.wakeOne();
++                break;
++            }
++        }
++    }
++
++    void stop()
++    {
++        // We have to both write to the pipe and set the flag, as the thread may be
++        // either in the poll() or waiting for _prepare_read().
++        if (m_pipefd[1] != -1 && write(m_pipefd[1], "\0", 1) == -1)
++            qWarning("Failed to write to the pipe: %s.", strerror(errno));
++
++        {
++            QMutexLocker l(&m_mutex);
++            m_quitting = true;
++            m_cond.wakeOne();
++        }
++
++        wait();
++    }
++
++Q_SIGNALS:
++    void needReadAndDispatch();
++
++protected:
++    void run() override
++    {
++        // we use this pipe to make the loop exit otherwise if we simply used a flag on the loop condition, if stop() gets
++        // called while poll() is blocking the thread will never quit since there are no wayland messages coming anymore.
++        struct Pipe
++        {
++            Pipe(int *fds)
++                : fds(fds)
++            {
++                if (qt_safe_pipe(fds) != 0)
++                    qWarning("Pipe creation failed. Quitting may hang.");
++            }
++            ~Pipe()
++            {
++                if (fds[0] != -1) {
++                    close(fds[0]);
++                    close(fds[1]);
++                }
++            }
++
++            int *fds;
++        } pipe(m_pipefd);
++
++        // Make the main thread call wl_prepare_read(), dispatch the pending messages and flush the
++        // outbound ones. Wait until it's done before proceeding, unless we're told to quit.
++        while (waitForReading()) {
++            pollfd fds[2] = { { m_fd, POLLIN, 0 }, { m_pipefd[0], POLLIN, 0 } };
++            poll(fds, 2, -1);
++
++            if (fds[1].revents & POLLIN) {
++                // we don't really care to read the byte that was written here since we're closing down
++                wl_display_cancel_read(m_wldisplay);
++                break;
++            }
++
++            if (fds[0].revents & POLLIN)
++                wl_display_read_events(m_wldisplay);
++                // The polll was succesfull and the event thread did the wl_display_read_events(). On the next iteration of the loop
++                // the event sent to the main thread will cause it to dispatch the messages just read, unless the loop exits in which
++                // case we don't care anymore about them.
++            else
++                wl_display_cancel_read(m_wldisplay);
++        }
++    }
++
++private:
++    bool waitForReading()
++    {
++        Q_ASSERT(QThread::currentThread() == this);
++
++        m_reading.storeRelease(false);
++
++        if (m_mode == SelfDispatch) {
++            readAndDispatchEvents();
++        } else {
++            Q_EMIT needReadAndDispatch();
++
++            QMutexLocker lock(&m_mutex);
++            // m_reading might be set from our emit or some other invocation of
++            // readAndDispatchEvents().
++            while (!m_reading.loadRelaxed() && !m_quitting)
++                m_cond.wait(&m_mutex);
++        }
++
++        return !m_quitting;
++    }
++
++    int dispatchQueuePending()
++    {
++        if (m_wlevqueue)
++            return wl_display_dispatch_queue_pending(m_wldisplay, m_wlevqueue);
++        else
++            return wl_display_dispatch_pending(m_wldisplay);
++    }
++
++    int prepareReadQueue()
++    {
++        if (m_wlevqueue)
++            return wl_display_prepare_read_queue(m_wldisplay, m_wlevqueue);
++        else
++            return wl_display_prepare_read(m_wldisplay);
++    }
++
++    int m_fd;
++    int m_pipefd[2];
++    wl_display *m_wldisplay;
++    wl_event_queue *m_wlevqueue;
++    OperatingMode m_mode;
++
++    /* Concurrency note when operating in EmitToDispatch mode:
++     * m_reading is set to false inside event thread's waitForReading(), and is
++     * set to true inside main thread's readAndDispatchEvents().
++     * The lock is not taken when setting m_reading to false, as the main thread
++     * is not actively waiting for it to turn false. However, the lock is taken
++     * inside readAndDispatchEvents() before setting m_reading to true,
++     * as the event thread is actively waiting for it under the wait condition.
++     */
++
++    QAtomicInteger<bool> m_reading;
++    bool m_quitting;
++    QMutex m_mutex;
++    QWaitCondition m_cond;
++};
++
+ Q_LOGGING_CATEGORY(lcQpaWayland, "qt.qpa.wayland"); // for general (uncategorized) Wayland platform logging
+ 
+ struct wl_surface *QWaylandDisplay::createSurface(void *handle)
+@@ -158,17 +351,16 @@ QWaylandDisplay::QWaylandDisplay(QWaylandIntegration *waylandIntegration)
+     if (!mXkbContext)
+         qCWarning(lcQpaWayland, "failed to create xkb context");
+ #endif
+-
+-    forceRoundTrip();
+-
+-    if (!mWaitingScreens.isEmpty()) {
+-        // Give wl_output.done and zxdg_output_v1.done events a chance to arrive
+-        forceRoundTrip();
+-    }
+ }
+ 
+ QWaylandDisplay::~QWaylandDisplay(void)
+ {
++    if (m_eventThread)
++        m_eventThread->stop();
++
++    if (m_frameEventQueueThread)
++        m_frameEventQueueThread->stop();
++
+     if (mSyncCallback)
+         wl_callback_destroy(mSyncCallback);
+ 
+@@ -189,6 +381,18 @@ QWaylandDisplay::~QWaylandDisplay(void)
+         wl_display_disconnect(mDisplay);
+ }
+ 
++// Steps which is called just after constructor. This separates registry_global() out of the constructor
++// so that factory functions in integration can be overridden.
++void QWaylandDisplay::initialize()
++{
++    forceRoundTrip();
++
++    if (!mWaitingScreens.isEmpty()) {
++        // Give wl_output.done and zxdg_output_v1.done events a chance to arrive
++        forceRoundTrip();
++    }
++}
++
+ void QWaylandDisplay::ensureScreen()
+ {
+     if (!mScreens.empty() || mPlaceholderScreen)
+@@ -203,98 +407,37 @@ void QWaylandDisplay::ensureScreen()
+ 
+ void QWaylandDisplay::checkError() const
+ {
+-    int ecode = wl_display_get_error(mDisplay);
+-    if ((ecode == EPIPE || ecode == ECONNRESET)) {
+-        // special case this to provide a nicer error
+-        qWarning("The Wayland connection broke. Did the Wayland compositor die?");
+-    } else {
+-        qWarning("The Wayland connection experienced a fatal error: %s", strerror(ecode));
+-    }
+-    _exit(1);
++    checkWaylandError(mDisplay);
+ }
+ 
++// Called in main thread, either from queued signal or directly.
+ void QWaylandDisplay::flushRequests()
+ {
+-    if (wl_display_prepare_read(mDisplay) == 0) {
+-        wl_display_read_events(mDisplay);
+-    }
+-
+-    if (wl_display_dispatch_pending(mDisplay) < 0)
+-        checkError();
+-
+-    {
+-        QReadLocker locker(&m_frameQueueLock);
+-        for (const FrameQueue &q : mExternalQueues) {
+-            QMutexLocker locker(q.mutex);
+-            while (wl_display_prepare_read_queue(mDisplay, q.queue) != 0)
+-                wl_display_dispatch_queue_pending(mDisplay, q.queue);
+-            wl_display_read_events(mDisplay);
+-            wl_display_dispatch_queue_pending(mDisplay, q.queue);
+-        }
+-    }
+-
+-    wl_display_flush(mDisplay);
+-}
+-
+-void QWaylandDisplay::blockingReadEvents()
+-{
+-    if (wl_display_dispatch(mDisplay) < 0)
+-        checkError();
+-}
+-
+-void QWaylandDisplay::destroyFrameQueue(const QWaylandDisplay::FrameQueue &q)
+-{
+-    QWriteLocker locker(&m_frameQueueLock);
+-    auto it = std::find_if(mExternalQueues.begin(),
+-                           mExternalQueues.end(),
+-                           [&q] (const QWaylandDisplay::FrameQueue &other){ return other.queue == q.queue; });
+-    Q_ASSERT(it != mExternalQueues.end());
+-    mExternalQueues.erase(it);
+-    if (q.queue != nullptr)
+-        wl_event_queue_destroy(q.queue);
+-    delete q.mutex;
++    m_eventThread->readAndDispatchEvents();
+ }
+ 
+-QWaylandDisplay::FrameQueue QWaylandDisplay::createFrameQueue()
++// We have to wait until we have an eventDispatcher before creating the eventThread,
++// otherwise forceRoundTrip() may block inside _events_read() because eventThread is
++// polling.
++void QWaylandDisplay::initEventThread()
+ {
+-    QWriteLocker locker(&m_frameQueueLock);
+-    FrameQueue q{createEventQueue()};
+-    mExternalQueues.append(q);
+-    return q;
+-}
++    m_eventThread.reset(
++            new EventThread(mDisplay, /* default queue */ nullptr, EventThread::EmitToDispatch));
++    connect(m_eventThread.get(), &EventThread::needReadAndDispatch, this,
++            &QWaylandDisplay::flushRequests, Qt::QueuedConnection);
++    m_eventThread->start();
+ 
+-wl_event_queue *QWaylandDisplay::createEventQueue()
+-{
+-    return wl_display_create_queue(mDisplay);
++    // wl_display_disconnect() free this.
++    m_frameEventQueue = wl_display_create_queue(mDisplay);
++    m_frameEventQueueThread.reset(
++            new EventThread(mDisplay, m_frameEventQueue, EventThread::SelfDispatch));
++    m_frameEventQueueThread->start();
+ }
+ 
+-void QWaylandDisplay::dispatchQueueWhile(wl_event_queue *queue, std::function<bool ()> condition, int timeout)
++void QWaylandDisplay::blockingReadEvents()
+ {
+-    if (!condition())
+-        return;
+-
+-    QElapsedTimer timer;
+-    timer.start();
+-    struct pollfd pFd = qt_make_pollfd(wl_display_get_fd(mDisplay), POLLIN);
+-    while (timeout == -1 || timer.elapsed() < timeout) {
+-        while (wl_display_prepare_read_queue(mDisplay, queue) != 0)
+-            wl_display_dispatch_queue_pending(mDisplay, queue);
+-
+-        wl_display_flush(mDisplay);
+-
+-        const int remaining = qMax(timeout - timer.elapsed(), 0ll);
+-        const int pollTimeout = timeout == -1 ? -1 : remaining;
+-        if (qt_poll_msecs(&pFd, 1, pollTimeout) > 0)
+-            wl_display_read_events(mDisplay);
+-        else
+-            wl_display_cancel_read(mDisplay);
+-
+-        if (wl_display_dispatch_queue_pending(mDisplay, queue) < 0)
+-            checkError();
+-
+-        if (!condition())
+-            break;
+-    }
++    if (wl_display_dispatch(mDisplay) < 0)
++        checkWaylandError(mDisplay);
+ }
+ 
+ QWaylandScreen *QWaylandDisplay::screenForOutput(struct wl_output *output) const
+@@ -669,4 +812,6 @@ QWaylandCursorTheme *QWaylandDisplay::loadCursorTheme(const QString &name, int p
+ 
+ } // namespace QtWaylandClient
+ 
++#include "qwaylanddisplay.moc"
++
+ QT_END_NAMESPACE
+diff --git a/src/client/qwaylanddisplay_p.h b/src/client/qwaylanddisplay_p.h
+index 09a1736a267d2816873667e9f1ecb4f4892f0ed0..42bc661d3064d770aa9fde8bd62ecdbbc89732a2 100644
+--- a/src/client/qwaylanddisplay_p.h
++++ b/src/client/qwaylanddisplay_p.h
+@@ -109,6 +109,7 @@ class QWaylandSurface;
+ class QWaylandShellIntegration;
+ class QWaylandCursor;
+ class QWaylandCursorTheme;
++class EventThread;
+ 
+ typedef void (*RegistryListener)(void *data,
+                                  struct wl_registry *registry,
+@@ -120,15 +121,11 @@ class Q_WAYLAND_CLIENT_EXPORT QWaylandDisplay : public QObject, public QtWayland
+     Q_OBJECT
+ 
+ public:
+-    struct FrameQueue {
+-        FrameQueue(wl_event_queue *q = nullptr) : queue(q), mutex(new QMutex) {}
+-        wl_event_queue *queue;
+-        QMutex *mutex;
+-    };
+-
+     QWaylandDisplay(QWaylandIntegration *waylandIntegration);
+     ~QWaylandDisplay(void) override;
+ 
++    void initialize();
++
+ #if QT_CONFIG(xkbcommon)
+     struct xkb_context *xkbContext() const { return mXkbContext.get(); }
+ #endif
+@@ -210,12 +207,11 @@ public:
+     void handleKeyboardFocusChanged(QWaylandInputDevice *inputDevice);
+     void handleWindowDestroyed(QWaylandWindow *window);
+ 
+-    wl_event_queue *createEventQueue();
+-    FrameQueue createFrameQueue();
+-    void destroyFrameQueue(const FrameQueue &q);
+-    void dispatchQueueWhile(wl_event_queue *queue, std::function<bool()> condition, int timeout = -1);
++    wl_event_queue *frameEventQueue() { return m_frameEventQueue; };
+ 
+     bool isKeyboardAvailable() const;
++
++    void initEventThread();
+ public slots:
+     void blockingReadEvents();
+     void flushRequests();
+@@ -238,6 +234,9 @@ private:
+     };
+ 
+     struct wl_display *mDisplay = nullptr;
++    QScopedPointer<EventThread> m_eventThread;
++    wl_event_queue *m_frameEventQueue = nullptr;
++    QScopedPointer<EventThread> m_frameEventQueueThread;
+     QtWayland::wl_compositor mCompositor;
+     QScopedPointer<QWaylandShm> mShm;
+     QList<QWaylandScreen *> mWaitingScreens;
+@@ -274,11 +273,9 @@ private:
+     QWaylandInputDevice *mLastInputDevice = nullptr;
+     QPointer<QWaylandWindow> mLastInputWindow;
+     QPointer<QWaylandWindow> mLastKeyboardFocus;
+-    QVector<QWaylandWindow *> mActiveWindows;
+-    QVector<FrameQueue> mExternalQueues;
++    QList<QWaylandWindow *> mActiveWindows;
+     struct wl_callback *mSyncCallback = nullptr;
+     static const wl_callback_listener syncCallbackListener;
+-    QReadWriteLock m_frameQueueLock;
+ 
+     bool mClientSideInputContextRequested = !QPlatformInputContextFactory::requested().isNull();
+ 
+diff --git a/src/client/qwaylandintegration.cpp b/src/client/qwaylandintegration.cpp
+index e5e7dd42c9b0145f4c9852f7e15dcc83106c321d..3b876047293887d17eeb28819c7386ded9e1f131 100644
+--- a/src/client/qwaylandintegration.cpp
++++ b/src/client/qwaylandintegration.cpp
+@@ -192,14 +192,18 @@ QAbstractEventDispatcher *QWaylandIntegration::createEventDispatcher() const
+ 
+ void QWaylandIntegration::initialize()
+ {
++    mDisplay->initEventThread();
++
++    // Call after eventDispatcher is fully connected, for QWaylandDisplay::forceRoundTrip()
++    mDisplay->initialize();
++
++    // But the aboutToBlock() and awake() should be connected after initializePlatform().
++    // Otherwise the connected flushRequests() may consumes up all events before processEvents starts to wait,
++    // so that processEvents(QEventLoop::WaitForMoreEvents) may be blocked in the forceRoundTrip().
+     QAbstractEventDispatcher *dispatcher = QGuiApplicationPrivate::eventDispatcher;
+     QObject::connect(dispatcher, SIGNAL(aboutToBlock()), mDisplay.data(), SLOT(flushRequests()));
+     QObject::connect(dispatcher, SIGNAL(awake()), mDisplay.data(), SLOT(flushRequests()));
+ 
+-    int fd = wl_display_get_fd(mDisplay->wl_display());
+-    QSocketNotifier *sn = new QSocketNotifier(fd, QSocketNotifier::Read, mDisplay.data());
+-    QObject::connect(sn, SIGNAL(activated(QSocketDescriptor)), mDisplay.data(), SLOT(flushRequests()));
+-
+     // Qt does not support running with no screens
+     mDisplay->ensureScreen();
+ }
+diff --git a/src/client/qwaylandwindow.cpp b/src/client/qwaylandwindow.cpp
+index 1597f67e63ae7834ded50e25b0acf86b71abcd73..7de19a742b6d3f6a3ce0955f59a5bf2879d29c9e 100644
+--- a/src/client/qwaylandwindow.cpp
++++ b/src/client/qwaylandwindow.cpp
+@@ -76,7 +76,6 @@ QWaylandWindow *QWaylandWindow::mMouseGrab = nullptr;
+ QWaylandWindow::QWaylandWindow(QWindow *window, QWaylandDisplay *display)
+     : QPlatformWindow(window)
+     , mDisplay(display)
+-    , mFrameQueue(mDisplay->createFrameQueue())
+     , mResizeAfterSwap(qEnvironmentVariableIsSet("QT_WAYLAND_RESIZE_AFTER_SWAP"))
+ {
+     {
+@@ -95,8 +94,6 @@ QWaylandWindow::QWaylandWindow(QWindow *window, QWaylandDisplay *display)
+ 
+ QWaylandWindow::~QWaylandWindow()
+ {
+-    mDisplay->destroyFrameQueue(mFrameQueue);
+-
+     delete mWindowDecoration;
+ 
+     if (mSurface)
+@@ -635,6 +632,8 @@ const wl_callback_listener QWaylandWindow::callbackListener = {
+ 
+ void QWaylandWindow::handleFrameCallback()
+ {
++    QMutexLocker locker(&mFrameSyncMutex);
++
+     mWaitingForFrameCallback = false;
+     mFrameCallbackElapsedTimer.invalidate();
+ 
+@@ -656,12 +655,16 @@ void QWaylandWindow::handleFrameCallback()
+         mWaitingForUpdateDelivery = true;
+         QMetaObject::invokeMethod(this, doHandleExpose, Qt::QueuedConnection);
+     }
++
++    mFrameSyncWait.notify_all();
+ }
+ 
+ bool QWaylandWindow::waitForFrameSync(int timeout)
+ {
+-    QMutexLocker locker(mFrameQueue.mutex);
+-    mDisplay->dispatchQueueWhile(mFrameQueue.queue, [&]() { return mWaitingForFrameCallback; }, timeout);
++    QMutexLocker locker(&mFrameSyncMutex);
++
++    QDeadlineTimer deadline(timeout);
++    while (mWaitingForFrameCallback && mFrameSyncWait.wait(&mFrameSyncMutex, deadline)) { }
+ 
+     if (mWaitingForFrameCallback) {
+         qCDebug(lcWaylandBackingstore) << "Didn't receive frame callback in time, window should now be inexposed";
+@@ -1157,8 +1160,11 @@ void QWaylandWindow::requestUpdate()
+     Q_ASSERT(hasPendingUpdateRequest()); // should be set by QPA
+ 
+     // If we have a frame callback all is good and will be taken care of there
+-    if (mWaitingForFrameCallback)
+-        return;
++    {
++        QMutexLocker locker(&mFrameSyncMutex);
++        if (mWaitingForFrameCallback)
++            return;
++    }
+ 
+     // If we've already called deliverUpdateRequest(), but haven't seen any attach+commit/swap yet
+     // This is a somewhat redundant behavior and might indicate a bug in the calling code, so log
+@@ -1171,7 +1177,12 @@ void QWaylandWindow::requestUpdate()
+     // so use invokeMethod to delay the delivery a bit.
+     QMetaObject::invokeMethod(this, [this] {
+         // Things might have changed in the meantime
+-        if (hasPendingUpdateRequest() && !mWaitingForFrameCallback)
++        {
++            QMutexLocker locker(&mFrameSyncMutex);
++            if (mWaitingForFrameCallback)
++                return;
++        }
++        if (hasPendingUpdateRequest())
+             deliverUpdateRequest();
+     }, Qt::QueuedConnection);
+ }
+@@ -1191,9 +1202,10 @@ void QWaylandWindow::handleUpdate()
+     if (!mSurface)
+         return;
+ 
+-    QMutexLocker locker(mFrameQueue.mutex);
++    QMutexLocker locker(&mFrameSyncMutex);
++
+     struct ::wl_surface *wrappedSurface = reinterpret_cast<struct ::wl_surface *>(wl_proxy_create_wrapper(mSurface->object()));
+-    wl_proxy_set_queue(reinterpret_cast<wl_proxy *>(wrappedSurface), mFrameQueue.queue);
++    wl_proxy_set_queue(reinterpret_cast<wl_proxy *>(wrappedSurface), mDisplay->frameEventQueue());
+     mFrameCallback = wl_surface_frame(wrappedSurface);
+     wl_proxy_wrapper_destroy(wrappedSurface);
+     wl_callback_add_listener(mFrameCallback, &QWaylandWindow::callbackListener, this);
+@@ -1203,6 +1215,8 @@ void QWaylandWindow::handleUpdate()
+     // Start a timer for handling the case when the compositor stops sending frame callbacks.
+     if (mFrameCallbackTimeout > 0) {
+         QMetaObject::invokeMethod(this, [this] {
++            QMutexLocker locker(&mFrameSyncMutex);
++
+             if (mWaitingForFrameCallback) {
+                 if (mFrameCallbackCheckIntervalTimerId < 0)
+                     mFrameCallbackCheckIntervalTimerId = startTimer(mFrameCallbackTimeout);
+diff --git a/src/client/qwaylandwindow_p.h b/src/client/qwaylandwindow_p.h
+index e06879620c3d033f093b0866f018ec80a72a97c3..d45980a80e9ecc9c5003fa2144de63e6337bda8a 100644
+--- a/src/client/qwaylandwindow_p.h
++++ b/src/client/qwaylandwindow_p.h
+@@ -232,7 +232,7 @@ protected:
+     int mFrameCallbackCheckIntervalTimerId = -1;
+     QElapsedTimer mFrameCallbackElapsedTimer;
+     struct ::wl_callback *mFrameCallback = nullptr;
+-    QWaylandDisplay::FrameQueue mFrameQueue;
++    QMutex mFrameSyncMutex;
+     QWaitCondition mFrameSyncWait;
+ 
+     // True when we have called deliverRequestUpdate, but the client has not yet attached a new buffer
diff --git a/source/l/qt5/qt5.SlackBuild b/source/l/qt5/qt5.SlackBuild
index b17df2fd5..d9b2b3942 100755
--- a/source/l/qt5/qt5.SlackBuild
+++ b/source/l/qt5/qt5.SlackBuild
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-# Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021  Patrick J. Volkerding, Sebeka, MN, USA
+# Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022  Patrick J. Volkerding, Sebeka, MN, USA
 # All rights reserved.
 #
 # Redistribution and use of this script, with or without modification, is
@@ -31,7 +31,7 @@ cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=qt5
 VERSION=$(ls qt-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)
-BUILD=${BUILD:-1}
+BUILD=${BUILD:-2}
 PKGSRC=$(echo $VERSION | cut -d - -f 1)
 PKGVER=$(echo $VERSION | tr - _)
 
@@ -148,6 +148,13 @@ cd qtwebengine
   zcat $CWD/patches/qtwebengine-everywhere-src-5.15.2-%231904652.patch.gz | patch -p1 --verbose || exit 1
 cd - 1>/dev/null
 
+# Apply upstream patch to move the wayland socket polling to a separate event
+# thread. This greatly improves the behavior of Plasma Wayland sessions, fixing
+# (for example) stuttering that was occuring on multimedia applications.
+cd qtwayland
+  zcat $CWD/patches/24.diff.gz | patch -p1 --verbose || exit 1
+cd - 1>/dev/null
+
 # If PulseAudio is not found, use the _alsa $TAG and disable it in the build:
 if ! pkg-config --exists libpulse 2>/dev/null ; then
   PULSEAUDIO_OPTION="-no-pulseaudio -no-webengine-pulseaudio"
diff --git a/source/l/svgalib/svgalib-1.9.21-demos.patch b/source/l/svgalib/svgalib-1.9.21-demos.patch
new file mode 100644
index 000000000..7da772edb
--- /dev/null
+++ b/source/l/svgalib/svgalib-1.9.21-demos.patch
@@ -0,0 +1,431 @@
+--- svgalib-1.9.21/demos/testgl.c.demos	2002-04-03 09:31:14.000000000 +0200
++++ svgalib-1.9.21/demos/testgl.c	2005-07-01 20:51:55.000000000 +0200
+@@ -184,7 +184,7 @@
+ 
+     if (!vga_hasmode(VGAMODE)) {
+ 	printf("Mode not available.\n");
+-	exit(-1);
++	return -1;
+     }
+     VIRTUAL = 0;		/* No virtual screen. */
+     if (vga_getmodeinfo(VGAMODE)->colors == 16 ||
+@@ -224,5 +224,5 @@
+     if (VIRTUAL)
+ 	gl_freecontext(backscreen);
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/vgatweak.c.demos	2000-08-06 12:20:02.000000000 +0200
++++ svgalib-1.9.21/demos/vgatweak.c	2005-07-01 20:51:55.000000000 +0200
+@@ -124,7 +124,7 @@
+ 	testmode(mode);
+     else {
+ 	printf("Error: Video mode not supported by driver\n");
+-	exit(-1);
++	return -1;
+     }
+     
+     return 0;
+--- svgalib-1.9.21/demos/linearfork.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/linearfork.c	2005-07-01 20:51:55.000000000 +0200
+@@ -82,7 +82,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(1);
++	return 1;
+     }
+     vga_setmode(vgamode);
+     vga_setlinearaddressing();
+@@ -95,7 +95,7 @@
+     /* purposes. */
+     if (keyboard_init()) {
+ 	printf("Could not initialize keyboard.\n");
+-	exit(1);
++	return 1;
+     }
+     /* Translate to 4 keypad cursor keys, and unify enter key. */
+     keyboard_translatekeys(TRANSLATE_CURSORKEYS | TRANSLATE_KEYPADENTER |
+@@ -161,5 +161,5 @@
+     keyboard_close();		/* Don't forget this! */
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/bg_test.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/bg_test.c	2005-07-01 20:51:55.000000000 +0200
+@@ -9,6 +9,7 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <unistd.h>
++#include <string.h>
+ #include <strings.h>
+ #include <vga.h>
+ #include <vgagl.h>
+--- svgalib-1.9.21/demos/accel.c.demos	2002-04-03 09:30:23.000000000 +0200
++++ svgalib-1.9.21/demos/accel.c	2005-07-01 20:51:55.000000000 +0200
+@@ -97,7 +97,7 @@
+ 
+     if (accelfuncs == 0) {
+ 	printf("No acceleration supported.\n");
+-	exit(0);
++	return 1;
+     }
+     printf("Accelflags: 0x%08X\n", accelfuncs);
+ 
+@@ -292,7 +292,7 @@
+ 	    );
+     }
+     vga_setmode(TEXT);
+-    exit(-1);
++    return 0;
+ }
+ 
+ 
+--- svgalib-1.9.21/demos/vgatest.c.demos	2005-01-27 11:34:16.000000000 +0100
++++ svgalib-1.9.21/demos/vgatest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -275,7 +275,7 @@
+ 
+ 	if (mode < 1 || mode > GLASTMODE) {
+ 	    printf("Error: Mode number out of range \n");
+-	    exit(-1);
++	    return -1;
+ 	}
+     }
+     if (vga_hasmode(mode)) {
+@@ -285,7 +285,7 @@
+ 		}
+ 	} else {
+ 		printf("Error: Video mode not supported by driver\n");
+-		exit(-1);
++		return -1;
+     }
+     
+ 	vga_setmode(TEXT);
+--- svgalib-1.9.21/demos/printftest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/printftest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -44,7 +44,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(1);
++	return 1;
+     }
+ 
+     vga_setmode(vgamode);
+@@ -68,5 +68,5 @@
+ 
+     vga_setmode(TEXT);
+ 
+-    exit(retval);
++    return retval;
+ }
+--- svgalib-1.9.21/demos/fun.c.demos	2002-07-20 18:33:54.000000000 +0200
++++ svgalib-1.9.21/demos/fun.c	2005-07-01 20:51:55.000000000 +0200
+@@ -13,6 +13,7 @@
+ #include <unistd.h>
+ #include <string.h>
+ #include <time.h>
++#include <string.h>
+ #include <vga.h>
+ #include <vgagl.h>
+ 
+--- svgalib-1.9.21/demos/bankspeed.c.demos	2002-04-03 09:31:22.000000000 +0200
++++ svgalib-1.9.21/demos/bankspeed.c	2005-07-01 20:51:55.000000000 +0200
+@@ -125,7 +125,7 @@
+ 
+     if (!vga_hasmode(VGAMODE)) {
+ 	printf("Mode not available.\n");
+-	exit(-1);
++	return -1;
+     }
+     VIRTUAL = 0;		/* No virtual screen. */
+     if (vga_getmodeinfo(VGAMODE)->colors == 16 ||
+@@ -165,5 +165,5 @@
+     t2=clock();
+     printf("total:%1.2f sec\n",(1.0*t2-t1)/CLOCKS_PER_SEC); 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/eventtest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/eventtest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -3,6 +3,7 @@
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <unistd.h>
++#include <time.h>
+ #include <sys/time.h>
+ #include <sys/types.h>
+ #include <vga.h>
+@@ -254,5 +255,5 @@
+     keyboard_close();		/* Don't forget this! */
+ #endif
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/svidtune.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/svidtune.c	2005-07-01 20:51:55.000000000 +0200
+@@ -48,7 +48,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(1);
++	return 1;
+     }
+ 
+     vga_setmode(vgamode);
+@@ -176,5 +176,5 @@
+ 
+     vga_setmode(TEXT);
+ 
+-    exit(retval);
++    return retval;
+ }
+--- svgalib-1.9.21/demos/keytest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/keytest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -38,7 +38,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(1);
++	return 1;
+     }
+     printf("\nWARNING: This program will set the keyboard to RAW mode.\n"
+ 	   "The keyboard routines in svgalib have not been tested\n"
+@@ -61,7 +61,7 @@
+     /* purposes. */
+     if (keyboard_init()) {
+ 	printf("Could not initialize keyboard.\n");
+-	exit(1);
++	return 1;
+     }
+     /* Translate to 4 keypad cursor keys, and unify enter key. */
+     keyboard_translatekeys(TRANSLATE_CURSORKEYS | TRANSLATE_KEYPADENTER |
+@@ -126,5 +126,5 @@
+ 
+     keyboard_close();		/* Don't forget this! */
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/scrolltest.c.demos	2000-01-12 21:03:39.000000000 +0100
++++ svgalib-1.9.21/demos/scrolltest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -304,5 +304,5 @@
+     demo3();
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/forktest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/forktest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -82,7 +82,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(1);
++	return 1;
+     }
+     vga_setmode(vgamode);
+     gl_setcontextvga(vgamode);
+@@ -94,7 +94,7 @@
+     /* purposes. */
+     if (keyboard_init()) {
+ 	printf("Could not initialize keyboard.\n");
+-	exit(1);
++	return 1;
+     }
+     /* Translate to 4 keypad cursor keys, and unify enter key. */
+     keyboard_translatekeys(TRANSLATE_CURSORKEYS | TRANSLATE_KEYPADENTER |
+@@ -160,5 +160,5 @@
+     keyboard_close();		/* Don't forget this! */
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/mjoytest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/mjoytest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -196,7 +196,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(-1);
++	return -1;
+     }
+ 
+     puts("In the demo, press\n"
+@@ -286,6 +286,6 @@
+     printf("Shutting down.\n");
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+ 
+--- svgalib-1.9.21/demos/speedtest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/speedtest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -1,4 +1,3 @@
+-
+ #include <unistd.h>
+ #include <stdlib.h>
+ #include <stdio.h>
+@@ -308,5 +307,5 @@
+     speed();
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/linearspeed.c.demos	2003-11-07 10:26:02.000000000 +0100
++++ svgalib-1.9.21/demos/linearspeed.c	2005-07-01 20:51:55.000000000 +0200
+@@ -418,5 +418,5 @@
+     if(!fast)sysmem_speed();
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
+--- svgalib-1.9.21/demos/testlinear.c.demos	2004-09-16 19:56:12.000000000 +0200
++++ svgalib-1.9.21/demos/testlinear.c	2005-07-01 20:51:55.000000000 +0200
+@@ -11,7 +11,7 @@
+ #include <string.h>
+ #include <vga.h>
+ #include <time.h>
+-#include "../src/libvga.h"
++#include "libvga.h"
+ 
+ 
+ #define USE_LINEAR_ADDRESSING
+@@ -66,7 +66,7 @@
+     if (!(argc == 2 && strcmp(argv[1], "--force") == 0))
+ 	if (!(vga_getmodeinfo(vga_getdefaultmode())->flags & CAPABLE_LINEAR)) {
+ 	    printf("Linear addressing not supported for this chipset.\n");
+-	    exit(1);
++	    return 1;
+ 	}
+     vga_init();
+     vga_setmode(vga_getdefaultmode());
+@@ -75,7 +75,7 @@
+     if (vga_setlinearaddressing() == -1) {
+ 	vga_setmode(TEXT);
+ 	printf("Could not set linear addressing.\n");
+-	exit(-1);
++	return -1;
+     }
+ #endif
+ 
+--- svgalib-1.9.21/demos/Makefile.demos	2004-11-16 08:59:52.000000000 +0100
++++ svgalib-1.9.21/demos/Makefile	2005-07-01 20:59:09.000000000 +0200
+@@ -4,19 +4,15 @@
+ # This file is a part of SVGAlib.
+ #----------------------------------------------------------------------
+ 
+-include ../Makefile.cfg
+-
+-srcdir    = ..
+-VPATH     = $(srcdir)/demos
+-
+ #----------------------------------------------------------------------
+-# Compiler Section (overrides Makefile.cfg)
++# Compiler Section
+ #----------------------------------------------------------------------
+ 
+-CFLAGS = $(WARN) $(OPTIMIZE) -I$(srcdir)/include -I$(srcdir)/gl $(DEBFLAGS)
+-ifeq (a.out, $(TARGET_FORMAT))
+-  CFLAGS += -DSVGA_AOUT
+-endif
++CC      = gcc
++CFLAGS  = -Wall -Wstrict-prototypes
++CFLAGS += -fomit-frame-pointer -O2 -fno-strength-reduce -pipe -g
++LDFLAGS = -s
++LIBS    = -lvgagl -lvga -lm
+ 
+ #----------------------------------------------------------------------
+ # Rules Section
+@@ -25,51 +21,12 @@
+ PROGS    = fun testgl speedtest mousetest vgatest scrolltest testlinear \
+ 	   keytest testaccel accel forktest eventtest spin bg_test printftest \
+ 	   joytest mjoytest bankspeed lineart linearspeed addmodetest \
+-	   svidtune linearfork cursor vgatweak buildcsr
+-
+-# Determine what library (static or shared) we will be linking programs with
+-ifdef INSTALLSHAREDLIB
+-  LIBS = -lvgagl -lvga
+-endif
+-ifndef LIBS
+-  LIBS    = ../staticlib/libvgagl.a ../staticlib/libvga.a -lm
+-  LVGADEP = $(LIBS)
+-endif
++	   svidtune linearfork cursor vgatweak
+ 
+ all:	$(PROGS)
+ 
+-.PHONY: all clean cleanbin dep
+-
+-$(PROGS): $(LVGADEP)
+-
+ .c:
+ 	$(CC) $(CFLAGS) $(LDFLAGS) -o $* $*.c $(LIBS)
+ 
+-rwpage: rwpage.pp
+-	$(PC) -Rintel rwpage.pp
+-
+-testaccel: testaccel.c
+-	$(CC) $(CFLAGS) $(LDFLAGS) -o testaccel testaccel.c $(LIBS) -lm
+-
+-accel: accel.c
+-	$(CC) $(CFLAGS) $(LDFLAGS) -o accel accel.c $(LIBS) -lm
+-
+-linearspeed: linearspeed.c memset.o
+-	$(CC) $(CFLAGS) $(LDFLAGS) -o linearspeed linearspeed.c memset.o $(LIBS)
+-
+-buildcsr: mkcur.o
+-	$(CC) -o buildcsr $(LDFLAGS) mkcur.o -lvgagl -lvga
+-
+-clean:	cleanbin
+-	rm -f .depend *.o *~ *.bak core
+-
+-cleanbin:
+-	rm -f $(PROGS) rwpage
+-
+-#
+-# No dependencies required here.
+-#
+-
+-dep:
+-.depend:
+-
++clean:
++	rm -f $(PROGS)
+--- svgalib-1.9.21/demos/mousetest.c.demos	2000-01-06 13:12:36.000000000 +0100
++++ svgalib-1.9.21/demos/mousetest.c	2005-07-01 20:51:55.000000000 +0200
+@@ -34,7 +34,7 @@
+ 
+     if (!vga_hasmode(vgamode)) {
+ 	printf("Mode not available.\n");
+-	exit(-1);
++	return -1;
+     }
+ #ifndef MANUALLY_SETUP_MOUSE
+     /* Enable automatic mouse setup at mode set. */
+@@ -72,7 +72,7 @@
+     /* To be able to test fake mouse events... */
+     if (keyboard_init()) {
+ 	printf("Could not initialize keyboard.\n");
+-	exit(1);
++	return 1;
+     }
+ 
+     /* Set the range for the wheel */
+@@ -136,5 +136,5 @@
+ #endif
+ 
+     vga_setmode(TEXT);
+-    exit(0);
++    return 0;
+ }
diff --git a/source/l/svgalib/svgalib-1.9.25.no_asm.patch b/source/l/svgalib/svgalib-1.9.25.no_asm.patch
new file mode 100644
index 000000000..8e489774b
--- /dev/null
+++ b/source/l/svgalib/svgalib-1.9.25.no_asm.patch
@@ -0,0 +1,11 @@
+--- ./Makefile.cfg.orig	2022-01-19 16:04:36.833030933 -0600
++++ ./Makefile.cfg	2022-01-19 16:05:13.758031759 -0600
+@@ -79,7 +79,7 @@
+ 
+ # uncomment this if your compiler fails on compiling the assembler in
+ # src/vgaconvplanar.c, gl/inlstring.h, gl/line.c or gl/scale.c
+-# NO_ASM = y
++NO_ASM = y
+ 
+ # uncomment if you want to set attribute controller and dac without delay
+ # This breaks original VGA, but seems to work on new cards.
diff --git a/source/l/svgalib/svgalib.SlackBuild b/source/l/svgalib/svgalib.SlackBuild
index 76e9868a4..880c7c6bd 100755
--- a/source/l/svgalib/svgalib.SlackBuild
+++ b/source/l/svgalib/svgalib.SlackBuild
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-# Copyright 2006, 2007, 2008, 2009, 2010, 2015, 2018  Patrick J. Volkerding, Sebeka, MN, USA
+# Copyright 2006, 2007, 2008, 2009, 2010, 2015, 2018, 2021  Patrick J. Volkerding, Sebeka, MN, USA
 # All rights reserved.
 #
 # Redistribution and use of this script, with or without modification, is
@@ -23,8 +23,8 @@
 cd $(dirname $0) ; CWD=$(pwd)
 
 PKGNAM=svgalib
-VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z* | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
-BUILD=${BUILD:-6}
+VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
+BUILD=${BUILD:-7}
 
 # Automatically determine the architecture we're building on:
 if [ -z "$ARCH" ]; then
@@ -65,7 +65,7 @@ mkdir -p $TMP $PKG
 
 cd $TMP
 rm -rf ${PKGNAM}-${VERSION}
-tar xvf $CWD/${PKGNAM}-$VERSION.tar.?z* || exit 1
+tar xvf $CWD/${PKGNAM}-$VERSION.tar.?z || exit 1
 cd ${PKGNAM}-$VERSION || exit 1
 
 # Make sure ownerships and permissions are sane:
@@ -89,6 +89,8 @@ zcat $CWD/svgalib.nohelper.diff.gz | patch -p1 --verbose || exit 1
 zcat $CWD/svgalib-1.9.25-round_gtf_gtfcalc_c.patch.gz | patch -p1 --verbose || exit 1
 zcat $CWD/svgalib-1.9.25-vga_getmodenumber.patch.gz | patch -p1 --verbose || exit 1
 zcat $CWD/svgalib-1.9.25-quickmath-h-redefinitions.patch.gz | patch -p1 --verbose || exit 1
+zcat $CWD/svgalib-1.9.21-demos.patch.gz | patch -p1 --verbose || exit 1
+zcat $CWD/svgalib-1.9.25.no_asm.patch.gz | patch -p1 --verbose || exit 1
 
 # Build and install - spamming your partition first...:
 make install NO_HELPER=y || exit 1