Trying to make a random address picker in my kernel

[ethindp]

I'm trying to make a function that returns a random available address for memory-mapped IO buffers. However, Rust needs type anotations and I'm not really sure what to do to make them work. I'm using similar code to that of the memory allocator and using an atomic u64 to track the allocator's progress, then using that position to pick the next available frame position, along with an RNG to mix it up a little:

pub fn get_free_addr(size: u64) -> u64 {
let mut rng = ADDRRNG.lock();
        let regions = MMAP.read().iter();
        let usable_regions = regions.filter(|r| r.region_type == MemoryRegionType::Usable);
        let addr_ranges = usable_regions.map(|r| r.start..r.end);
        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
let fcount =         frame_addresses.clone().map::<dyn Fn(u64)->PhysFrame<Size4KiB>>(|addr| PhysFrame::containing_address(PhysAddr::new(addr))).count();
let mut pos = rng.next_u64();
loop {
if pos >= FPOS.load(Ordering::SeqCst)+1 && pos <= (fcount as u64) - (size / 4096) {
break;
}
pos = rng.next_u64();
}
let mut addr = frame_addresses.map(|addr| PhysFrame::containing_address(PhysAddr::new(addr))).nth(pos as usize).unwrap().start_address().as_u64();
if addr.get_bits(47 .. 64) != 0 {
addr.set_bits(47 .. 64, 0);
}
addr
}

I'm not really sure what I'm doing wrong (and maybe I'm overcomplicating things). I wish I could cash all the frames that I can allocate, but I'm not going to allocate a stack or a heap capable of holding billions of frames, if not more, and I also don't know a way of actually doing that properly anyway, so I'm stuck with iterating on every memory allocation for the time being. Thoughts?