Crate polyhal

This is a crate to help you supporting multiple platforms.

If you want to use this crate, you should implement the following trait in your code.

/// impl
pub struct PageAllocImpl;

impl PageAlloc for PageAllocImpl {
    fn alloc(&self) -> PhysPage {
        frame_alloc()
    }

    fn dealloc(&self, ppn: PhysPage) {
        frame::frame_dealloc(ppn)
    }
}

/// kernel interrupt
#[polyhal::arch_interrupt]
fn kernel_interrupt(ctx: &mut TrapFrame, trap_type: TrapType) {
    // println!("trap_type @ {:x?} {:#x?}", trap_type, ctx);
    match trap_type {
        Breakpoint => return,
        UserEnvCall => {
            // jump to next instruction anyway
            ctx.syscall_ok();
            log::info!("Handle a syscall");
        }
        StorePageFault(_paddr) | LoadPageFault(_paddr) | InstructionPageFault(_paddr) => {
            log::info!("page fault");
        }
        IllegalInstruction(_) => {
            log::info!("illegal instruction");
        }
        Time => {
            log::info!("Timer");
        }
        _ => {
            log::warn!("unsuspended trap type: {:?}", trap_type);
        }
    }
}

#[polyhal::arch_entry]
/// kernel main function, entry point.
fn main(hartid: usize) {
    if hartid != 0 {
        return;
    }

    println!("[kernel] Hello, world!");
    allocator::init_allocator();
    logging::init(Some("trace"));
    println!("init logging");

    // Init page alloc for polyhal
    polyhal::init(&PageAllocImpl);

    get_mem_areas().into_iter().for_each(|(start, size)| {
        println!("init memory region {:#x} - {:#x}", start, start + size);
        frame::add_frame_range(start, start + size);
    });
    panic!("end of rust_main!");
}

The main(hardid: usize) is the entry point.

You can find details in the example.

In this crate you can find some interfaces to use. These interfaces are classified into some structures.

PhysPage: PhysicalPage And its associated functions.

PhysAddr: PhysicalAddr And its associated functions.

VirtPage: VirtualPage And its associated functions.

VirtAddr: VirtualAddr And its associated functions.

IRQ: Interrupt ReQuest management, includes enable and disable.

Barrier: Memory barrier operations.

MultiCore: MultiCore operations. Now only [multicore::MultiCore::boot_all] is available.

PageTable: PageTable and its associated functions.

MappingFlags: MappingFlags, This is an abstraction of pagetable flags.

TLB: TLB operations.

PageTableWrapper: PageTableWrapper. It will dealloc all pagetable leaf when it was dropping.

Time: Time and its associated functions.

Instruction: Some platform instruction.

There also provides a debugging console(recommanded only for debugging).

DebugConsole: A console for debugging.

This crate provides a [TrapFrame], you can operate it through index with [TrapFrameArgs].

If you are using kernel task. You should to enable feature kcontext. Then you can use kernel task context structure [KContext], and manipulate it with [KContextArgs].

You can switch kcontext through [context_switch_pt] or [context_switch]

There are also some consts.

[VIRT_ADDR_START]: This is a higher half kernel offset address. [USER_VADDR_END]: End of the user address range. [PAGE_SIZE]: The size of the page.

You can get some device information using the functions below. [get_mem_areas]: Get the avaliable memorys. [get_fdt]: Get the Fdt structure(fdt is a rust dtb operation crate). [get_cpu_num]: Get the number of cpus.

TIPS: You should have finished [init] before using [get_mem_areas] and [get_fdt].

Re-exports

• pub use addr::PhysAddr;
• pub use addr::PhysPage;
• pub use addr::VirtAddr;
• pub use addr::VirtPage;
• pub use time::Time;

Modules

• addr
• boot
  Boot Components.
• common
• consts
  Consts components
• debug_console
  This is a console for debugging, If you want to use this logging You need to use like this:
• instruction
  Instruction Module.
• irq
  IRQ(Interrupt requests queue) module.
• kcontext
  Kernel Context module.
• mem
• pagetable
• percpu
  Per-cpu module.
• time
• timer
  Timer module.
• trapframe
  Trapframe module.
• utils

Structs

• MappingFlags
  Mapping flags for page table.
• PageTable
  Page Table
• PageTableWrapper
  Page Table Wrapper

Enums

• MappingSize
  This structure indicates size of the page that will be mapped.

Attribute Macros

• arch_entry