Real-World Rust Systems Programming

// rust/kernel/nvme.rs - Production Linux driver
use kernel::{
    block::mq::RequestQueue,
    dma_buf::Dmabuf,
    sync::Mutex,
};

struct NvmeDevice {
    queue: Mutex<RequestQueue>,
    dma_ring: Dmabuf,
}

impl Driver for NvmeDevice {
    fn probe(&mut self, pci_dev: &PciDevice) -> Result {
        self.dma_ring = pci_dev.alloc_dma(4096)?;
        self.queue.lock().init(64);
        pci_dev.map_bar(0)
    }
}

// Windows KMDF driver
use windows::{
    kernel::{IRP, IO_STATUS_BLOCK},
    sync::SpinLock,
};

#[repr(C)]
pub struct DriverObject {
    device: SpinLock<Device>,
}

unsafe extern "system" fn dispatch_read(
    device_object: *mut DEVICE_OBJECT,
    irp: *mut IRP,
) -> NTSTATUS {
    let device = (*device_object).device_extension()
        as *mut DriverObject;
    read_data(device, irp)
}

// Firecracker src/vmm/src/vcpu.rs
use hypervisor::kvm::KvmVcpu;

pub struct Vcpu {
    kvm_vcpu: KvmVcpu,
    state: Arc<AtomicU64>,
}

impl Vcpu {
    pub fn run(&self) -> Result<()> {
        // 5MB memory, 125ms cold start
        self.kvm_vcpu.run()?;
        self.state.fetch_or(VCpuState::RUNNING.bits())
    }
}

// Android frameworks/native/services/surfaceflinger/
pub struct SurfaceFlinger {
    hwc: Hwc2Device,
    displays: Vec<DisplayDevice>,
}

impl SurfaceFlinger {
    fn composite(&mut self, buffer: &mut [u8]) {
        // 25% GPU perf improvement
        self.hwc.set_active_config(0, 1)?;
        self.displays[0].render(buffer);
    }
}

// Discord presence service
use tokio::{
    sync::watch,
    time::{interval, Duration},
};

pub struct Presence {
    sender: watch::Sender<UserStatus>,
}

impl Presence {
    pub async fn heartbeat(&self, user_id: u64) {
        // 45% memory reduction
        let mut status = self.sender.subscribe();
        interval(Duration::from_secs(30)).tick().await;
    }
}

#![no_std]
#![no_main]

#[repr(align(4))]
pub struct SensorData {
    temp: f32,
    pressure: f32,
}

#[entry]
fn main() -> ! {
    loop {
        let data = read_i2c();
        process_safety_critical(data);
        cortex_m::asm::wfi();
    }
}

Linux Kernel: 100+ drivers, 0 memory bugs
Windows: 70% vuln reduction
AWS Firecracker: 40% serverless capacity
Android: 25% GPU perf gain
Discord: 45% memory savings