Hi and welcome to Metta hub!

Here we develop decentralised communication systems for the future, called Metta nodes or uvvies. You can join in by helping us develop, document, promote and use the software.

Check out the blog below for latest updates.

Learning JTAG

To understand how JTAG works I recommend a series of articles by Aliaksandr Kavalchuk. He describes details of the protocol and accompanies the text with amazing illustrations. Check it out:

• Part 1: Overview
• Part 2: Debugging
• Part 3: Boundary Scan
• Part 4: BSDL
• Part 5: Usage Scenarios
• Part 6: Security

Also, there are a few articles from other authors, describing JTAG in a more practical way:

• JTAG Hacking unknown SSD drive controller
• JTAG, SSDs and Firmware Extraction

Half-knowledge

Half-knowledge is very communicable; not so knowledge.

Mary Coleridge

OSdev tooling finished

January through May I was on and off on the project, fixing chainofcommand to work with the chain loading, in particular fighting the UNIX console and the TTY operations. Now the entire thing works, finished and merged into the main development branch. After that I started prodding the MMU setup and DTB (DeviceTree) parsing.

OSdev tooling continued

This month I spent honing the tooling story. Partially it was driven by the desire to Rewrite All the Things in Rust, and partially by my attempt to integrate all the tooling in a convenient for me way to do things.

Along the way I've done some refactoring and added support for Raspberry Pi 4-specific code.

OSdev tooling

Since my first attempt at OSdev in x86 assembly I've constantly strived to make my setup comfortable. With rust I finally achieved a nearly zero-configuration flow. There are still some tools to install but they are either a cargo install just away or entirely optional.

Developing an OS in Rust gives an opportunity to apply the benefits of the entire Rust ecosystem, so I've decided to maximally utilise what it has to offer.

Complex Systems

A simple system may or may not work. A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.

John Gall's Systemantics

Rust on Sipeed Longan Nano board

My Longan Nano board has arrived and I tried to run Rust on it. It's a great success and here's how.

Nano is a RISC-V microcontroller (GD32VF103) with impressive GPIO capabilities and connectivity - it has a serial, JTAG and USB Type-C ports plus numerous GPIO pins on breakout connectors. It is also very well documented: there are board schematics, CPU and Peripheral datasheets, and numerous programming examples.

Escaping from old ideas

The difficulty lies not so much in developing new ideas as in escaping from old ones.

John Maynard Keynes

Building WASM with Rust

There are several options to build Rust into WebAssembly. cargo-web was the preferred way for yew, but nowadays yew also supports wasm-bindgen and this opens up some possibilities for javascript interop.

Useful cargo commands

Some additional cargo commands exist to provide unprecedented level of support and extensibility to regular cargo. Here's a list of commands I use (will be updated over time, last update 2024-05-21):

Porting to Cobalt

Decision to port the blog to rust-based Cobalt.rs generator instead of hugo came rather easily, I'm quite fond of rust ecosystem now, and this porting excercise proved me right.

Reboot to Rust

Fast forward four years...

And the landscape is changed again. The idea to write a secure robust kernel and then build a secure robust operating system on it is still there. However, there are new tools, technologies as well as new hazards.

One of the new tools is Rust language. The tenets of Rust are speed, safety and fearless concurrency. This makes it nearly ideal language for writing new secure software, including kernels. Robigalia project is also looking towards semi-automatic assurance of Rust-based software by leveraging the MIR intermediate representation as containing the semantic information about the program, which we can reason about. Looking forward to seeing what this brings, meanwhile I set out to write an equivalent of seL4 kernel in Rust for 64-bit systems.

I've intentionally dropped support for 32-bit systems at the moment, it should be possible to retrofit 32-bit support into the kernel APIs - they will just become either slower or more limited. Just don't focus on these now.

So the primary targets are x86_64 and aarch64. And I'm going to start by collecting the Embedded Rust community knowledge and using it to build a baremetal Rust "kernel" that could speak to some UART device, starting with Raspberry Pi 3 board - since I have that one and have JTAG debugger for it.

Let's go.

Xargo Build with Sublime

How to build your xargo package in Sublime

Imagine you have a special OSdev project in Rust that you want to build from within Sublime Text. So you fire up the editor, choose the Tools>Build System>New Build System… and write a little simple configuration file:

{
    "shell_cmd": "xargo run --target aarch64-vesper-metta",
    "keyfiles": ["Xargo.toml"],
    "working_dir": "$project_path/vesper",
    "env": {
        "RUST_TARGET_PATH": "$project_path/vesper/targets/"
    },
    "quiet": false
}

You save it and hit Cmd+B.

Kotlin

Kotlin is the new Java with the announced Google support, and here is how it compares to other languages:

• Scala vs Kotlin
• Swift vs Kotlin
• Why you should totally switch to Kotlin - contains more comparisons and highlights