vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Red Bear OS — microkernel OS in Rust, based on Redox

Browse Source 
Derivative of Redox OS (https://www.redox-os.org) adding:
- AMD GPU driver (amdgpu) via LinuxKPI compat layer
- ext4 filesystem support (ext4d scheme daemon)
- ACPI fixes for AMD bare metal (x2APIC, DMAR, IVRS, MCFG)
- Custom branding (hostname, os-release, boot identity)

Build system is full upstream Redox with RBOS overlay in local/.
Patches for kernel, base, and relibc are symlinked from local/patches/
and protected from make clean/distclean. Custom recipes live in
local/recipes/ with symlinks into the recipes/ search path.

Build:  make all CONFIG_NAME=redbear-full
Sync:   ./local/scripts/sync-upstream.sh
This commit is contained in:
Vasilito
2026-04-12 19:05:00 +01:00
commit 50b731f1b7
3392 changed files with 98327 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
recipes/wip/x11/xserver-xorg-video-orbital/recipe.toml
+22
View File
@@ -0,0 +1,22 @@
# x11 video driver for running inside of orbital
[source]
tar = "https://www.x.org/releases/individual/driver/xf86-video-dummy-0.4.1.tar.xz"
blake3 = "9b49296f62bf4d22345d87fc01f2a5571f941457c19d21c8800f8f6d2e64ae67"
patches = ["redox.patch"]
script = """
autotools_recursive_regenerate
"""
[build]
dependencies = [
"liborbital",
"pixman",
"x11proto",
"xserver-xorg",
]
template = "custom"
script = """
DYNAMIC_INIT
export LIBS="-lorbital"
cookbook_configure
"""
recipes/wip/x11/xserver-xorg-video-orbital/redox.patch
+301
View File
@@ -0,0 +1,301 @@
diff -ruwN source-old/src/dummy_driver.c source/src/dummy_driver.c
--- source-old/src/dummy_driver.c 2023-05-07 14:27:44.000000000 -0600
+++ source/src/dummy_driver.c 2025-10-29 11:13:11.863430241 -0600
@@ -39,6 +39,7 @@
/* These need to be checked */
#include <X11/X.h>
#include <X11/Xproto.h>
+#include <X11/keysym.h>
#include "scrnintstr.h"
#include "servermd.h"
@@ -51,6 +52,7 @@
static Bool DUMMYEnterVT(VT_FUNC_ARGS_DECL);
static void DUMMYLeaveVT(VT_FUNC_ARGS_DECL);
static Bool DUMMYCloseScreen(CLOSE_SCREEN_ARGS_DECL);
+static void DUMMYBlockHandler(ScreenPtr pScreen, void *timeout);
static Bool DUMMYCreateWindow(WindowPtr pWin);
static void DUMMYFreeScreen(FREE_SCREEN_ARGS_DECL);
static ModeStatus DUMMYValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
@@ -768,6 +770,97 @@
static ScrnInfoPtr DUMMYScrn; /* static-globalize it */
+static void DUMMYOrbitalEvent(int fd, int ready, void *data) {
+ DUMMYPtr dPtr = (DUMMYPtr)data;
+ if (!dPtr->orb_window) {
+ return;
+ }
+
+ void *event_iter = orb_window_events(dPtr->orb_window);
+ if (!event_iter) {
+ return;
+ }
+
+ bool running = true;
+ while (running) {
+ OrbEventOption event = orb_events_next(event_iter);
+ if (event.tag == OrbEventOption_None) {
+ break;
+ }
+ //TODO: handle more events
+ switch (event.tag) {
+ case OrbEventOption_Key:
+ if (inputInfo.keyboard) {
+ if (event.key.scancode > 0) {
+ //TODO: more advanced key mapping?
+ xf86PostKeyEvent(inputInfo.keyboard, event.key.scancode + 8, event.key.pressed);
+ }
+ }
+ break;
+ case OrbEventOption_Mouse:
+ if (inputInfo.pointer) {
+ xf86PostMotionEvent(inputInfo.pointer, 1, 0, 2, event.mouse.x, event.mouse.y);
+ }
+ break;
+ case OrbEventOption_MouseRelative:
+ if (inputInfo.pointer) {
+ if (event.mouse_relative.dx || event.mouse_relative.dy) {
+ xf86PostMotionEvent(inputInfo.pointer, 0, 0, 2, event.mouse_relative.dx, event.mouse_relative.dy);
+ }
+ }
+ break;
+ case OrbEventOption_Button:
+ if (inputInfo.pointer) {
+ xf86PostButtonEvent(inputInfo.pointer, 0, 1, event.button.left, 0, 0);
+ xf86PostButtonEvent(inputInfo.pointer, 0, 2, event.button.middle, 0, 0);
+ xf86PostButtonEvent(inputInfo.pointer, 0, 3, event.button.right, 0, 0);
+ }
+ break;
+ case OrbEventOption_None:
+ running = false;
+ break;
+ default:
+ //printf("unknown orbital event %d: %d, %d\n", event.unknown.code, event.unknown.a, event.unknown.b);
+ break;
+ }
+ }
+
+ orb_events_destroy(event_iter);
+}
+
+static Bool
+CreateScreenResources(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+ DUMMYPtr dPtr = DUMMYPTR(pScrn);
+ PixmapPtr rootPixmap;
+ Bool ret;
+
+ pScreen->CreateScreenResources = dPtr->CreateScreenResources;
+ ret = pScreen->CreateScreenResources(pScreen);
+ pScreen->CreateScreenResources = CreateScreenResources;
+
+ if (!ret) {
+ return FALSE;
+ }
+
+ rootPixmap = pScreen->GetScreenPixmap(pScreen);
+
+ dPtr->damage = DamageCreate(NULL, NULL, DamageReportNone, TRUE,
+ pScreen, rootPixmap);
+ if (dPtr->damage) {
+ DamageRegister(&rootPixmap->drawable, dPtr->damage);
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
+ }
+ else {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Failed to create screen damage record\n");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
/* Mandatory */
static Bool
DUMMYScreenInit(SCREEN_INIT_ARGS_DECL)
@@ -776,7 +869,6 @@
DUMMYPtr dPtr;
int ret;
VisualPtr visual;
- void *pixels;
/*
* we need to get the ScrnInfoRec for this screen, so let's allocate
@@ -786,9 +878,22 @@
dPtr = DUMMYPTR(pScrn);
DUMMYScrn = pScrn;
+ if (pScrn->bitsPerPixel != 32) {
+ printf("unsupported BPP %d\n", pScrn->bitsPerPixel);
+ return FALSE;
+ }
- if (!(pixels = malloc(pScrn->videoRam * 1024)))
+ printf(
+ "orb_window_new %d, %d\n",
+ pScrn->virtualX, pScrn->virtualY
+ );
+ dPtr->orb_window = orb_window_new_flags(-1, -1, pScrn->virtualX, pScrn->virtualY, "X11", ORB_WINDOW_ASYNC | ORB_WINDOW_BORDERLESS);
+ if (!dPtr->orb_window) {
+ printf("failed to open orbital window\n");
return FALSE;
+ }
+
+ SetNotifyFd(orb_window_fd(dPtr->orb_window), DUMMYOrbitalEvent, X_NOTIFY_READ, dPtr);
/*
* Reset visual list.
@@ -800,12 +905,10 @@
if (!miSetVisualTypes(pScrn->depth,
miGetDefaultVisualMask(pScrn->depth),
pScrn->rgbBits, pScrn->defaultVisual)) {
- free(pixels);
return FALSE;
}
if (!miSetPixmapDepths ()) {
- free(pixels);
return FALSE;
}
@@ -813,7 +916,7 @@
* Call the framebuffer layer's ScreenInit function, and fill in other
* pScreen fields.
*/
- ret = fbScreenInit(pScreen, pixels,
+ ret = fbScreenInit(pScreen, orb_window_data(dPtr->orb_window),
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
pScrn->displayWidth, pScrn->bitsPerPixel);
@@ -838,6 +941,10 @@
/* must be after RGB ordering fixed */
fbPictureInit(pScreen, 0, 0);
+ /* Wrap the current CreateScreenResources function */
+ dPtr->CreateScreenResources = pScreen->CreateScreenResources;
+ pScreen->CreateScreenResources = CreateScreenResources;
+
xf86SetBlackWhitePixels(pScreen);
/* initialize XRANDR */
@@ -943,6 +1050,10 @@
dPtr->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = DUMMYCloseScreen;
+ /* Wrap the current BlockHandler function */
+ dPtr->BlockHandler = pScreen->BlockHandler;
+ pScreen->BlockHandler = DUMMYBlockHandler;
+
/* Wrap the current CreateWindow function */
dPtr->CreateWindow = pScreen->CreateWindow;
pScreen->CreateWindow = DUMMYCreateWindow;
@@ -975,11 +1086,26 @@
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
DUMMYPtr dPtr = DUMMYPTR(pScrn);
- free(pScreen->GetScreenPixmap(pScreen)->devPrivate.ptr);
+ if (dPtr->damage) {
+ DamageUnregister(dPtr->damage);
+ DamageDestroy(dPtr->damage);
+ dPtr->damage = NULL;
+ }
+
+ if (dPtr->orb_window) {
+ RemoveNotifyFd(orb_window_fd(dPtr->orb_window));
+
+ printf("orb_window_destroy %p\n", dPtr->orb_window);
+ orb_window_destroy(dPtr->orb_window);
+ dPtr->orb_window = NULL;
+ }
if (dPtr->CursorInfo)
xf86DestroyCursorInfoRec(dPtr->CursorInfo);
+ pScreen->CreateScreenResources = dPtr->CreateScreenResources;
+ pScreen->BlockHandler = dPtr->BlockHandler;
+
pScrn->vtSema = FALSE;
pScreen->CloseScreen = dPtr->CloseScreen;
return (*pScreen->CloseScreen)(CLOSE_SCREEN_ARGS);
@@ -1009,6 +1135,31 @@
Atom VFB_PROP = 0;
#define VFB_PROP_NAME "VFB_IDENT"
+static void DUMMYBlockHandler(ScreenPtr pScreen, void *timeout) {
+ DUMMYPtr dPtr = DUMMYPTR(DUMMYScrn);
+
+ //printf("BlockHandler %p %p\n", pScreen, timeout);
+ pScreen->BlockHandler = dPtr->BlockHandler;
+ pScreen->BlockHandler(pScreen, timeout);
+ dPtr->BlockHandler = pScreen->BlockHandler;
+ pScreen->BlockHandler = DUMMYBlockHandler;
+
+ if (dPtr->damage) {
+ RegionPtr dirty = DamageRegion(dPtr->damage);
+ if (RegionNil(dirty)) {
+ // Do not sync if damage empty
+ return;
+ }
+ DamageEmpty(dPtr->damage);
+ }
+
+ if (dPtr->orb_window) {
+ //TODO: use damage region?
+ //printf("orb_window_sync %p\n", dPtr->orb_window);
+ orb_window_sync(dPtr->orb_window);
+ }
+}
+
static Bool
DUMMYCreateWindow(WindowPtr pWin)
{
diff -ruwN source-old/src/dummy.h source/src/dummy.h
--- source-old/src/dummy.h 2023-05-07 14:27:44.000000000 -0600
+++ source/src/dummy.h 2025-10-29 10:11:23.172517830 -0600
@@ -4,6 +4,7 @@
#include "xf86_OSproc.h"
#include "xf86Cursor.h"
+#include "xf86Xinput.h"
#ifdef XvExtension
#include "xf86xv.h"
@@ -13,7 +14,9 @@
#include "compat-api.h"
-#define DUMMY_MAX_SCREENS 16
+#include <orbital.h>
+
+#define DUMMY_MAX_SCREENS 1
/* Supported chipsets */
typedef enum {
@@ -44,6 +47,7 @@
OptionInfoPtr Options;
Bool swCursor;
/* proc pointer */
+ CreateScreenResourcesProcPtr CreateScreenResources;
CloseScreenProcPtr CloseScreen;
xf86CursorInfoPtr CursorInfo;
@@ -52,6 +56,7 @@
int cursorFG, cursorBG;
dummy_colors colors[1024];
+ void (*BlockHandler)(ScreenPtr, void*) ; /* wrapped BlockHandler */
Bool (*CreateWindow)(WindowPtr) ; /* wrapped CreateWindow */
Bool prop;
/* XRANDR support begin */
@@ -60,6 +65,9 @@
struct _xf86Output *paOutputs[DUMMY_MAX_SCREENS];
int connected_outputs;
/* XRANDR support end */
+
+ DamagePtr damage;
+ void *orb_window;
} DUMMYRec, *DUMMYPtr;
/* The privates of the DUMMY driver */