fix: comprehensive boot warnings and exceptions — fixable silenced, unfixable diagnosed

Build system (5 gaps hardened):
- COOKBOOK_OFFLINE defaults to true (fork-mode)
- normalize_patch handles diff -ruN format
- New 'repo validate-patches' command (25/25 relibc patches)
- 14 patched Qt/Wayland/display recipes added to protected list
- relibc archive regenerated with current patch chain

Boot fixes (fixable):
- Full ISO EFI partition: 16 MiB → 1 MiB (matches mini, BIOS hardcoded 2 MiB offset)
- D-Bus system bus: absolute /usr/bin/dbus-daemon path (was skipped)
- redbear-sessiond: absolute /usr/bin/redbear-sessiond path (was skipped)
- daemon framework: silenced spurious INIT_NOTIFY warnings for oneshot_async services (P0-daemon-silence-init-notify.patch)
- udev-shim: demoted INIT_NOTIFY warning to INFO (expected for oneshot_async)
- relibc: comprehensive named semaphores (sem_open/close/unlink) replacing upstream todo!() stubs
- greeterd: Wayland socket timeout 15s → 30s (compositor DRM wait)
- greeter-ui: built and linked (header guard unification, sem_compat stubs removed)
- mc: un-ignored in both configs, fixed glib/libiconv/pcre2 transitive deps
- greeter config: removed stale keymapd dependency from display/greeter services
- prefix toolchain: relibc headers synced, _RELIBC_STDLIB_H guard unified

Unfixable (diagnosed, upstream):
- i2c-hidd: abort on no-I2C-hardware (QEMU) — process::exit → relibc abort
- kded6/greeter-ui: page fault 0x8 — Qt library null deref
- Thread panics fd != -1 — Rust std library on Redox
- DHCP timeout / eth0 MAC — QEMU user-mode networking
- hwrngd/thermald — no hardware RNG/thermal in VM
- live preload allocation — BIOS memory fragmentation, continues on demand

local/recipes/qt/qtdeclarative/source/examples/quick/quickwidgets/quickwidget/CMakeLists.txt

@@ -0,0 +1,46 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.16)
+project(quickwidget LANGUAGES CXX)
+
+find_package(Qt6 REQUIRED COMPONENTS Core Gui Quick QuickWidgets Widgets)
+
+qt_standard_project_setup(REQUIRES 6.8)
+
+qt_add_executable(quickwidget
+    WIN32
+    MACOSX_BUNDLE
+    main.cpp
+)
+
+target_link_libraries(quickwidget PRIVATE
+    Qt6::Core
+    Qt6::Gui
+    Qt6::Quick
+    Qt6::QuickWidgets
+    Qt6::Widgets
+)
+
+qt_add_qml_module(quickwidget
+    URI QuickWidgetExample
+    QML_FILES
+        rotatingsquare.qml
+    RESOURCE_PREFIX /quickwidget
+    NO_RESOURCE_TARGET_PATH
+)
+
+install(TARGETS quickwidget
+    BUNDLE  DESTINATION .
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+
+qt_generate_deploy_qml_app_script(
+    TARGET quickwidget
+    OUTPUT_SCRIPT deploy_script
+    MACOS_BUNDLE_POST_BUILD
+    NO_UNSUPPORTED_PLATFORM_ERROR
+    DEPLOY_USER_QML_MODULES_ON_UNSUPPORTED_PLATFORM
+)
+install(SCRIPT ${deploy_script})

local/recipes/qt/qtdeclarative/source/examples/quick/quickwidgets/quickwidget/doc/src/quickwidget.qdoc

@@ -0,0 +1,57 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
+
+/*!
+    \title Qt Quick Widgets Example
+    \example quickwidgets/quickwidget
+    \brief Demonstrates how to mix Qt Quick with a Qt Widgets application using the QQuickWidget class.
+    \examplecategory {User Interface Components}
+
+    \image qtquickwidgets-example.webp {Digital clock and rotating rectangle in MDI subwindows}
+
+    The example demonstrates how you can embed Qt Quick scenes inside a Qt
+    Widgets application, and how different UI aspects integrate between Qt
+    Widgets and Qt Quick. This includes:
+
+    \list
+        \li Tab focusing between Qt Widgets and Qt Quick
+        \li Embedding a QQuickView inside a QLayout
+    \endlist
+
+    \include examples-run.qdocinc
+
+    \section1 Qt Quick view integration
+
+    To demonstrate seamless integration of Qt Quick view, the example
+    implements several approaches of taking a screenshot of the Qt Quick view.
+
+    In the main menu, select \uicontrol {File}, then select any of these
+    options to grab a screenshot of the Qt Quick view:
+
+    \list
+        \li \uicontrol {Grab framebuffer} - grabs the screenshot using the
+            \l QQuickWidget::grabFramebuffer function.
+        \li \uicontrol {Render to pixmap} - grabs the screenshot using the
+            \l QWidget::render function and a \l QPixmap instance as a
+            parameter. This approach is common for Qt Widgets.
+        \li \uicontrol {Grab via grabToImage} - calls the
+            \c performLayerBasedGrab function declared in the QML file.
+            The \c performLayerBasedGrab function calls
+            QML Item's \l Item::grabToImage function to grab the screenshot.
+            This approach demonstrates how to call nested view's QML APIs from
+            C++.
+    \endlist
+
+    \image qquickwidget_grab_screenshot.webp {File menu with three screenshot capture options}
+
+    \section1 QQuickWidget in MDI
+
+    The example also demonstrates how you can use QQuickWidget to seamlessly
+    integrate hardware accelerated Qt Quick scenes in a Qt Widget Multiple
+    Document Interface (MDI) application.
+
+    To open a new MDI subwindow, in the main menu, select
+    \uicontrol {Window} > \uicontrol {Add tab widget}.
+
+    \image qquickwidget_mdi_example.webp {MDI window with multiple tabbed subwindows}
+*/

local/recipes/qt/qtdeclarative/source/examples/quick/quickwidgets/quickwidget/main.cpp

@@ -0,0 +1,213 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include <QApplication>
+#include <QCommandLineParser>
+#include <QQuickWidget>
+#include <QQuickItem>
+#include <QQmlError>
+#include <QMdiArea>
+#include <QLCDNumber>
+#include <QFileDialog>
+#include <QStatusBar>
+#include <QMainWindow>
+#include <QMenuBar>
+#include <QPushButton>
+
+class MainWindow : public QMainWindow {
+    Q_OBJECT
+public:
+    MainWindow();
+
+private slots:
+    void quickWidgetStatusChanged(QQuickWidget::Status);
+    void sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message);
+    void grabFramebuffer();
+    void renderToPixmap();
+    void grabToImage();
+    void createQuickWidgetsInTabs(QMdiArea *mdiArea);
+
+private:
+    QQuickWidget *m_quickWidget;
+};
+
+static bool optMultipleSample = false;
+
+MainWindow::MainWindow()
+   : m_quickWidget(new QQuickWidget)
+{
+    QSurfaceFormat format;
+    if (optMultipleSample)
+        format.setSamples(4);
+    m_quickWidget->setFormat(format);
+
+    QMdiArea *centralWidget = new QMdiArea;
+
+    QLCDNumber *lcd = new QLCDNumber;
+    lcd->display(1337);
+    lcd->setMinimumSize(250,100);
+    centralWidget->addSubWindow(lcd);
+
+    QUrl source("qrc:quickwidget/rotatingsquare.qml");
+
+    connect(m_quickWidget, &QQuickWidget::statusChanged,
+            this, &MainWindow::quickWidgetStatusChanged);
+    connect(m_quickWidget, &QQuickWidget::sceneGraphError,
+            this, &MainWindow::sceneGraphError);
+    m_quickWidget->resize(300,300);
+    m_quickWidget->setResizeMode(QQuickWidget::SizeRootObjectToView );
+    m_quickWidget->setSource(source);
+
+    centralWidget->addSubWindow(m_quickWidget);
+
+    setCentralWidget(centralWidget);
+
+    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
+    auto grabAction = fileMenu->addAction(tr("Grab framebuffer"), this, &MainWindow::grabFramebuffer);
+    auto renderAction = fileMenu->addAction(tr("Render to pixmap"), this, &MainWindow::renderToPixmap);
+    auto grabToImageAction = fileMenu->addAction(tr("Grab via grabToImage"), this, &MainWindow::grabToImage);
+    fileMenu->addAction(tr("Quit"), qApp, &QCoreApplication::quit);
+
+    QMenu *windowMenu = menuBar()->addMenu(tr("&Window"));
+    windowMenu->addAction(tr("Add tab widget"), this,
+                          [this, centralWidget] { createQuickWidgetsInTabs(centralWidget); });
+
+    connect(m_quickWidget, &QObject::destroyed, this,
+            [this, grabAction, renderAction, grabToImageAction] {
+                m_quickWidget = nullptr;
+                grabAction->setEnabled(false);
+                renderAction->setEnabled(false);
+                grabToImageAction->setEnabled(false);
+            });
+}
+
+void MainWindow::createQuickWidgetsInTabs(QMdiArea *mdiArea)
+{
+    // A QQuickWidget should work like any other widget when it comes to being
+    // in layouts, in tab widgets, MDI areas, etc. It can also be freely
+    // reparented and made top-level.
+
+    QTabWidget *tabWidget = new QTabWidget;
+    const QSize size(400, 400);
+    const QString msgToTopLevel = QLatin1String("Break out to top-level window");
+    const QString msgFromTopLevel = QLatin1String("Move back under tab widget");
+
+    static const int N = 4;
+    static const QColor colorTab[N] = { Qt::green, Qt::blue, Qt::yellow, Qt::magenta };
+    for (int i = 0; i < N; ++i) {
+        QQuickWidget *widget = new QQuickWidget;
+        widget->resize(size);
+        widget->setResizeMode(QQuickWidget::SizeRootObjectToView);
+        QObject::connect(widget, &QQuickWidget::statusChanged, widget, [widget, i] {
+            if (widget->status() == QQuickWidget::Ready) {
+                if (QQuickItem *rootItem = widget->rootObject()) {
+                    rootItem->setProperty("rectColor", colorTab[i]);
+                }
+            }
+        });
+        widget->setSource(QUrl("qrc:quickwidget/rotatingsquare.qml"));
+        widget->setWindowTitle(QString::asprintf("Tab %d", i + 1));
+        QPushButton *btn = new QPushButton(msgToTopLevel, widget);
+        connect(btn, &QPushButton::clicked, widget, [=] {
+            if (widget->parent()) {
+                widget->setAttribute(Qt::WA_DeleteOnClose, true);
+                widget->setParent(nullptr);
+                connect(this, &QObject::destroyed, widget, &QWidget::close);
+                widget->show();
+                btn->setText(msgFromTopLevel);
+            } else {
+                widget->setAttribute(Qt::WA_DeleteOnClose, false);
+                disconnect(this, &QObject::destroyed, widget, &QWidget::close);
+                tabWidget->addTab(widget, widget->windowTitle());
+                btn->setText(msgToTopLevel);
+            }
+        });
+        tabWidget->addTab(widget, QString::asprintf("Tab %d", i + 1));
+    }
+
+    mdiArea->addSubWindow(tabWidget);
+    tabWidget->show();
+}
+
+void MainWindow::quickWidgetStatusChanged(QQuickWidget::Status status)
+{
+    if (status == QQuickWidget::Error) {
+        QStringList errors;
+        Q_ASSERT(m_quickWidget);
+        const auto widgetErrors = m_quickWidget->errors();
+        for (const QQmlError &error : widgetErrors)
+            errors.append(error.toString());
+        statusBar()->showMessage(errors.join(QStringLiteral(", ")));
+    }
+}
+
+void MainWindow::sceneGraphError(QQuickWindow::SceneGraphError, const QString &message)
+{
+     statusBar()->showMessage(message);
+}
+
+template<class T> void saveToFile(QWidget *parent, T *saveable)
+{
+    QFileDialog fd(parent);
+    fd.setAcceptMode(QFileDialog::AcceptSave);
+    fd.setDefaultSuffix("png");
+    fd.selectFile("test.png");
+    if (fd.exec() == QDialog::Accepted)
+        saveable->save(fd.selectedFiles().first());
+}
+
+void MainWindow::grabFramebuffer()
+{
+    Q_ASSERT(m_quickWidget);
+    QImage image = m_quickWidget->grabFramebuffer();
+    saveToFile(this, &image);
+}
+
+void MainWindow::renderToPixmap()
+{
+    Q_ASSERT(m_quickWidget);
+    QPixmap pixmap(m_quickWidget->size());
+    m_quickWidget->render(&pixmap);
+    saveToFile(this, &pixmap);
+}
+
+void MainWindow::grabToImage()
+{
+    QFileDialog fd(this);
+    fd.setAcceptMode(QFileDialog::AcceptSave);
+    fd.setDefaultSuffix("png");
+    fd.selectFile("test_grabToImage.png");
+    if (fd.exec() == QDialog::Accepted) {
+        Q_ASSERT(m_quickWidget);
+        QMetaObject::invokeMethod(m_quickWidget->rootObject(), "performLayerBasedGrab",
+                                  Q_ARG(QVariant, fd.selectedFiles().first()));
+    }
+}
+
+int main(int argc, char **argv)
+{
+    QApplication app(argc, argv);
+
+    QCoreApplication::setApplicationName("Qt QQuickWidget Example");
+    QCoreApplication::setOrganizationName("QtProject");
+    QCoreApplication::setApplicationVersion(QT_VERSION_STR);
+
+    QCommandLineParser parser;
+    parser.setApplicationDescription(QCoreApplication::applicationName());
+    parser.addHelpOption();
+    parser.addVersionOption();
+    QCommandLineOption multipleSampleOption("multisample", "Multisampling");
+    parser.addOption(multipleSampleOption);
+
+    parser.process(app);
+
+    optMultipleSample = parser.isSet(multipleSampleOption);
+
+    MainWindow *mainWindow = new MainWindow;
+    mainWindow->setAttribute(Qt::WA_DeleteOnClose, true);
+    mainWindow->show();
+
+    return app.exec();
+}
+
+#include "main.moc"

local/recipes/qt/qtdeclarative/source/examples/quick/quickwidgets/quickwidget/quickwidget.pro

@@ -0,0 +1,15 @@
+QT       += core gui quick widgets quickwidgets
+
+TARGET = quickwidget
+TEMPLATE = app
+
+CONFIG += qmltypes
+QML_IMPORT_NAME = QuickWidgetExample
+QML_IMPORT_MAJOR_VERSION = 1
+
+SOURCES += main.cpp
+
+RESOURCES += quickwidget.qrc
+
+target.path = $$[QT_INSTALL_EXAMPLES]/quick/quickwidgets/quickwidget
+INSTALLS += target

local/recipes/qt/qtdeclarative/source/examples/quick/quickwidgets/quickwidget/quickwidget.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/quickwidget">
+        <file>rotatingsquare.qml</file>
+    </qresource>
+</RCC>

local/recipes/qt/qtdeclarative/source/examples/quick/quickwidgets/quickwidget/rotatingsquare.qml

@@ -0,0 +1,54 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+
+Rectangle {
+    id: root
+    property color rectColor: "red"
+
+    Rectangle {
+        property int d: 100
+        id: square
+        width: d
+        height: d
+        anchors.centerIn: parent
+        color: root.rectColor
+        NumberAnimation on rotation { from: 0; to: 360; duration: 2000; loops: Animation.Infinite; }
+    }
+
+    Text {
+        id: text
+        anchors.centerIn: parent
+        property string api
+        Connections {
+            target: text.GraphicsInfo
+            function onApiChanged() {
+                var api = text.GraphicsInfo.api;
+                if (api === GraphicsInfo.Software)
+                    text.api = "Software";
+                else if (api === GraphicsInfo.OpenGL)
+                    text.api = "OpenGL on QRhi";
+                else if (api === GraphicsInfo.Direct3D11)
+                    text.api = "D3D11 on QRhi";
+                else if (api === GraphicsInfo.Direct3D12)
+                    text.api = "D3D12 on QRhi";
+                else if (api === GraphicsInfo.Vulkan)
+                    text.api = "Vulkan on QRhi";
+                else if (api === GraphicsInfo.Metal)
+                    text.api = "Metal on QRhi";
+                else if (api === GraphicsInfo.Null)
+                    text.api = "Null on QRhi";
+                else
+                    text.api = "Unknown API";
+            }
+        }
+        text: "Qt Quick running in a widget\nGraphicsInfo.api says: " + api
+    }
+
+    function performLayerBasedGrab(fn) {
+        root.grabToImage(function(result) {
+            result.saveToFile(fn);
+        });
+    }
+}