Example with x86_64 crate?

[Qubasa]

Hello!

I tried to use this library but miserably failed to do so while battling with the rust compiler.
Could you add a little example while using the x86_64 crates FrameAllocator & OffsetPageTable?
I would deeply appreciate it :)
I tried using a struct like this:

#[derive(Clone)]
pub struct MyAcpiHandler<'a> {
    mapper: Rc<RefCell<&'a mut OffsetPageTable<'a>>>,
    frame_allocator: Rc<RefCell<&'a mut dyn FrameAllocator<Size4KiB>>>,
}

but this failed with the error:

.map_to(page, frame, flags, self.frame_allocator.get_mut())
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `FrameAllocator<Size4KiB>` is not implemented for `&mut dyn FrameAllocator<Size4KiB>`

[Restioson]

This seems like an x86_64 issue since acpi has no FrameAllocator trait.

In any case, which map_to fn are you using? This one needs A: FrameAllocator with an implicit Sized bound which would prevent one from passing A: dyn FrameAllocator<Size4KiB>. Maybe this could be relaxed though.

[phil-opp]

Maybe this could be relaxed though.

Yeah, I think we can relax this. I opened rust-osdev/x86_64#204 for this.

[IsaacWoods]

Hi, always nice to hear of people using the library! I'm afraid I don't have much experience with the x86_64 crate as my kernel doesn't use it. Those types are pretty complicated though, it might be worth making MyAcpiHandler generic over the type of FrameAllocator instead of using a trait object (you'll probably only be monomorphising one copy of the code anyway).

EDIT: ah looks like Phil's on it :) hope you get this working @luis-hebendanz!

[Qubasa]

Damn you guys are fast! Thanks for the help :D

[phil-opp]

Try using borrow_mut instead of get_mut. The latter requires a &mut reference to the RefCell which is not possible for Rc<RefCell<_>>.

[Qubasa]

Wow it worked. I have no idea why but it worked! Now I have to sit down and find out why and how :)

[phil-opp]

Let me try to explain this in a bit more detail:

The last error had nothing to do with the x86_64 crate (it was just masked by the earlier error). The error also occurs when you try self.frame_allocator.get_mut() independently.

When you use the borrow_mut() method you get a mutable reference to the type wrapped in RefCell, which is &mut dyn FrameAllocator<Size4KiB> in your case. So the resulting type is &mut &mut dyn FrameAllocator<Size4KiB>. To remove the double reference, you need to dereference once.

All generic parameters in Rust have an implicit Sized bound by default. This means that the size of the parameter needs to be known at compile time. Since the map_to method takes only references to the FrameAllocator as argument, this implicit bound isn't needed, so we can opt-out using the ?Sized bound (that's what the linked PR does). This way, the dynamically-sized dyn FrameAllocator type is now usable with the method.

I hope this makes things clearer!

[Qubasa]

You are awesome!