cg-tg-rcore-tutorial-ch8 0.0.1

A reproducible Rust learning crate for the tg-rcore-tutorial chapter 8 kernel experiment, including threading, synchronization, framebuffer I/O, and a user-mode Doom demo path.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! VirtIO GPU framebuffer driver.

use crate::{KERNEL_SPACE, Sv39, build_flags};
use alloc::{
    alloc::{alloc_zeroed, dealloc},
    sync::Arc,
};
use core::{alloc::Layout, ptr::NonNull, slice};
use spin::{Lazy, Mutex};
use tg_kernel_vm::page_table::{MmuMeta, VAddr, VmFlags};
use virtio_drivers::{Hal, MmioTransport, VirtIOGpu, VirtIOHeader};

/// VirtIO GPU MMIO base.
const VIRTIO_GPU0: usize = 0x1000_2000;

/// Kernel-managed framebuffer instance.
pub static GPU_DEVICE: Lazy<Arc<Mutex<GpuDevice>>> = Lazy::new(|| {
    Arc::new(Mutex::new(unsafe {
        let transport = MmioTransport::new(NonNull::new(VIRTIO_GPU0 as *mut VirtIOHeader).unwrap())
            .expect("failed to create GPU transport");
        let mut gpu =
            VirtIOGpu::<VirtioHal, MmioTransport>::new(transport).expect("failed to init GPU");
        let (width, height) = gpu.resolution().expect("failed to query GPU resolution");
        let (framebuffer, framebuffer_len) = {
            let framebuffer = gpu
                .setup_framebuffer()
                .expect("failed to setup GPU framebuffer");
            framebuffer.fill(0);
            (framebuffer.as_mut_ptr(), framebuffer.len())
        };
        gpu.flush().expect("failed to flush initial framebuffer");
        GpuDevice {
            gpu,
            framebuffer,
            framebuffer_len,
            width: width as usize,
            height: height as usize,
            stride: width as usize * 4,
        }
    }))
});

/// GPU state shared by framebuffer syscalls.
pub struct GpuDevice {
    gpu: VirtIOGpu<'static, VirtioHal, MmioTransport>,
    framebuffer: *mut u8,
    framebuffer_len: usize,
    /// Screen width in pixels.
    pub width: usize,
    /// Screen height in pixels.
    pub height: usize,
    /// Bytes per scanline.
    pub stride: usize,
}

unsafe impl Send for GpuDevice {}
unsafe impl Sync for GpuDevice {}

impl GpuDevice {
    #[inline]
    pub fn framebuffer(&mut self) -> &mut [u8] {
        unsafe { slice::from_raw_parts_mut(self.framebuffer, self.framebuffer_len) }
    }

    #[inline]
    pub fn flush(&mut self) {
        self.gpu.flush().expect("failed to flush GPU framebuffer");
    }
}

struct VirtioHal;

impl Hal for VirtioHal {
    fn dma_alloc(pages: usize) -> usize {
        unsafe {
            alloc_zeroed(Layout::from_size_align_unchecked(
                pages << Sv39::PAGE_BITS,
                1 << Sv39::PAGE_BITS,
            )) as _
        }
    }

    fn dma_dealloc(paddr: usize, pages: usize) -> i32 {
        unsafe {
            dealloc(
                paddr as _,
                Layout::from_size_align_unchecked(pages << Sv39::PAGE_BITS, 1 << Sv39::PAGE_BITS),
            )
        }
        0
    }

    #[inline]
    fn phys_to_virt(paddr: usize) -> usize {
        paddr
    }

    fn virt_to_phys(vaddr: usize) -> usize {
        const VALID: VmFlags<Sv39> = build_flags("__V");
        let ptr: NonNull<u8> = unsafe {
            KERNEL_SPACE
                .assume_init_ref()
                .translate(VAddr::new(vaddr), VALID)
                .unwrap()
        };
        ptr.as_ptr() as usize
    }
}