Inter Process Communication should be fast and effective. The performance of IPC is vital for modern operating systems. Here is an overview of how we can accomplish this in Aero:

1. Each task will have its own message queue that contains pending messages.
2. The message will contain the sender's PID and TID with data (&[u8]). It will aswell contain a message ID (usize) used to identify the message without needing to parse the message itself.
3. Using the sys_ipc_send and sys_ipc_get system calls the tasks can communicate with each other efficiently.

Drawbacks

This would require the kernel to clone the message 2 times (when you send the message the kernel keeps a copy of the message and for the task that we are sending to has to clone it again)

Some people may be sussed out by the amount of links to rick astley's wikipedia page and think its a rick roll. I removed a couple links so no one gets confused.

When running lua or tcc with a full sysroot it returns:

  ERROR        cpu '0' panicked at 'pmm: frame allocator not initialized'
  ERROR        aero_kernel/src/mem/paging/frame.rs:159:14
  ERROR        
  TRACE        ---------------------------------- BACKTRACE -----------------------------------
  TRACE         0: 0xffffffff8023e464 - rust_begin_unwind
  TRACE         1: 0xffffffff8025f5af - core::panicking::panic_fmt::h86713eebd88b31bf
  TRACE         2: 0xffffffff8026013b - core::panicking::panic_display::h705ec34ecff6e0dc
  TRACE         3: 0xffffffff802600ec - core::panicking::panic_str::hcce4f9aa570a143f
  TRACE         4: 0xffffffff802600c9 - core::option::expect_failed::h923bd113315aae1c
  TRACE         5: 0xffffffff80224102 - aero_kernel::mem::paging::frame::pmm_alloc::hd1efec97d53fb599
  TRACE         6: 0xffffffff8020ac7b - aero_kernel::userland::vm::Vm::handle_page_fault::habab6a5757c2c843
  TRACE         7: 0xffffffff8022dcb4 - __interrupt_page_fault
  TRACE         8: 0xffffffff80228d12 - page_fault
  TRACE         9: 0x0000750000001f75 - <unknown>
  TRACE        10: 0x0000750000001836 - <unknown>
  TRACE        11: 0x0000750000001250 - <unknown>
  TRACE        12: 0x000075000000ae8d - <unknown>
  TRACE        13: 0x0000750000008c4c - <unknown>
  TRACE        14: 0x00007500000140df - <unknown>
  TRACE        15: 0x0000000000000019 - <unknown>
  TRACE        16: <guard page>

Is there a fix for this issue?

The script automatically detects package manager, reads aero's sysroot dependency list from a file for said package manager, and installs said dependencies from the list.

When trying to run bash(and other programs but I cant reproduce them consistently) it returns: ERROR EXCEPTION: Page Fault ERROR ERROR Accessed Address: 0x0 ERROR Error: USER_MODE | INSTRUCTION_FETCH ERROR ERROR Task Info: TID=6, PID=6 ERROR Stack: InterruptErrorStack { code: 0x14, stack: InterruptStack { preserved: PreservedRegisters { r15: 0x1, r14: 0x1, r13: 0x2d, r12: 0x7fffffffdffb, rbp: 0x7fffffffdcd0, rbx: 0x0, }, scratch: ScratchRegisters { r11: 0x216, r10: 0x9, r9: 0x0, r8: 0x1, rsi: 0x4ccc75, rdi: 0x4cd05c, rdx: 0x62, rcx: 0x469c50, rax: 0x0, }, iret: IretRegisters { rip: 0x0, cs: 0x33, rflags: 0x246, rsp: 0x7fffffffdc58, ss: 0x2b, }, }, } TRACE ---------------------------------- BACKTRACE ----------------------------------- TRACE 0: 0xffffffff8022e07e - __interrupt_page_fault TRACE 1: 0xffffffff80228d12 - page_fault TRACE 2: 0x000000000040643f - <unknown> TRACE 3: 0x0000000000404e69 - <unknown> TRACE 4: 0x0000000041430d67 - <unknown> TRACE 5: 0x0000000000405cc7 - <unknown> Also maybe a userland process shouldn't cause a kernel panic by accessing kernel memory....

This pull request aims to bring an easy way for processes to communicate with each other using dedicated system calls. There is still a lot of work to do, but it's something we can work upon.

The current system works in following way, there are 2 system calls available:

• sys_ipc_send(target_pid, *buffer, flags);
• sys_ipc_recv(*buffer, *sender, *length, flags);

The sys_ipc_send system call should always succeed, there aren't any planned error paths (for now at least). It will return the message ID assigned to the sent message.

The sys_ipc_recv system call will return the received message ID, the sender's PID will be written to the *sender argument and the message payload length will be written to the *length argument. Possible flags include NO_WAIT which makes the system call return with an error code ENOMSG if there aren't any messages in the message queue instead of waiting, and TRUNCATE which will truncate the payload if it's too big to fit in the buffer. By default the system call will return E2BIG and put the message back into the queue if it won't fit in provided buffer.

In the case of a program or library that checks for the simpledrm driver from linux change the name of rawfb to simpledrm to accommodate it.

Signed-off-by: Yusuf Khan [email protected]

https://github.com/YusufKhan-gamedev/uwux/commit/602904b5a602985db608753b4bd1364cc3895612

HERE! I spent an hour finding how to pr in github and here it is! Also, maybe create gitlab mirror? Sorry for my crass language im extremely angry.

This patch introduces a procedural macro that takes care of validating input buffers and paths automagically for us :^) There is still a bit of clean up to do, but for the most part it does what it's supposed to be doing.

This pull request reimplements the existing build system, but as a Python script. This will allow us for more flexibility and faster clean builds, because we no longer have to compile dozen of Rust crates. This PR also changes the distribution format of aero to ISO images, rather than raw disk images. That allows a single image to be used for both legacy and UEFI targets, as well as support for all major storage medium: optical disks, hard disks and removable media.

• [x] Build the kernel and userland
• [x] Create an initramfs image (CPIO)
• [x] Package the kernel and userland in an ISO image
• [x] Run the OS in an emulator
• [x] Support for running tests
• [x] Continuous integration support

My OS is Debian 11, when i run ./aero.py --sysroot, I encountered the error:

xbstrap: fetch xf86-input-keyboard [59/71]
Initialized empty Git repository in /home/szx/Code/os/aero/bundled/xf86-input-keyboard/.git/
remote: Enumerating objects: 28, done.
remote: Counting objects: 100% (28/28), done.
remote: Compressing objects: 100% (28/28), done.
remote: Total 28 (delta 3), reused 9 (delta 0), pack-reused 0
Unpacking objects: 100% (28/28), 51.90 KiB | 208.00 KiB/s, done.
From https://gitlab.freedesktop.org/xorg/driver/xf86-input-keyboard
 * [new tag]         xf86-input-keyboard-1.9.0 -> xf86-input-keyboard-1.9.0
xbstrap: checkout xf86-input-keyboard [60/71]
HEAD is now at 0c7f512 keyboard 1.9.0
xbstrap: patch xf86-input-keyboard [61/71]
Applying: keydev: aero specific changes
Applying: keydev: aero specific changes
Using index info to reconstruct a base tree...
M       .gitignore
M       configure.ac
M       src/Makefile.am
.git/rebase-apply/patch:100: trailing whitespace.
static int KbdOn(InputInfoPtr pInfo, int what) { 
.git/rebase-apply/patch:101: trailing whitespace.
    return Success;  
.git/rebase-apply/patch:105: trailing whitespace.
    printf("aero::kbdOff: is a stub!\n"); 
.git/rebase-apply/patch:167: trailing whitespace.
Bool xf86OSKbdPreInit(InputInfoPtr pInfo) { 
warning: 4 lines add whitespace errors.
Falling back to patching base and 3-way merge...
CONFLICT (add/add): Merge conflict in src/aero_kbd.c
Auto-merging src/aero_kbd.c
error: Failed to merge in the changes.
Patch failed at 0001 keydev: aero specific changes
hint: Use 'git am --show-current-patch=diff' to see the failed patch
When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".
xbstrap: Action patch of source xf86-input-keyboard failed

My OS is Debian 11, when I run ./aero.py ， I encountered the following error：

error: host-cargo not built as a part of the sysroot, skipping compilation of `userland/`

Hello! There's a bit of an issue with the build process, and the way the bundled cargo is called from aero.py seems to disagree with subprocess on my system for some reason.

Results of ./aero.py --test:

Traceback (most recent call last):
  File "/Users/<name>/Documents/Programming/aero/./aero.py", line 665, in <module>
    main()
  File "/Users/<name>/Documents/Programming/aero/./aero.py", line 644, in main
    user_bins = build_userland(args)
  File "/Users/<name>/Documents/Programming/aero/./aero.py", line 371, in build_userland
    return build_cargo_workspace('userland', 'build', ['--package', 'utest', *cmd_args], get_cargo())
  File "/Users/<name>/Documents/Programming/aero/./aero.py", line 261, in build_cargo_workspace
    code, _, _ = run_command([cargo, command, *args], cwd=cwd)
  File "/Users/cat/Documents/Programming/aero/./aero.py", line 223, in run_command
    output = subprocess.run(args, **kwargs)
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 505, in run
    with Popen(*popenargs, **kwargs) as process:
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 951, in __init__
    self._execute_child(args, executable, preexec_fn, close_fds,
  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/lib/python3.9/subprocess.py", line 1821, in _execute_child
    raise child_exception_type(errno_num, err_msg, err_filename)
OSError: [Errno 8] Exec format error: '../bundled/host-rust-prebuilt/aero/host-cargo/bin/cargo'

• python3 --version: Python 3.9.6
• Host Operating System: macOS Ventura 13.0
• Host Architecture: aarch64-darwin

note: I'm well aware aarch64-darwin isn't officially supported, but it's one of the few (if not the only) mainstream consumer platform using the aarch64 architecture, and at least the only aarch64-based device I have access to for testing.

this implementation will hopefully be faster and more maintainable

important things:

• [ ] building aero
• [ ] running qemu
• [ ] updating ci commands
• [ ] updating env commands (gitpod & codespaces)
• [ ] optimisation
• [ ] rust documentation
• [ ] implementing latest features in aero_build from aero.py

note to self: don't forget to add a comment referencing this gist to the logging functions.

This PR aims to implement support for SMAP, SMEP and UMIP, and is provided as a draft so that my non existent rust skills can be reviewed already. It also enables bit 16 in CR0 for more write protection. As this is a draft, not everything is implemented or working yet, but on SMAP capable systems, aero_shell runs with SMAP and ls is working.