Method consecutive_frames

kernel/src/memory/frame_allocator.rs:302–368

Allocate a consecutive set of frames num_frames The number of frames required max_address The maximum physical address in the set e.g. for 32-bit addresses 0xFFFF_FFFF Returns the number of the first frame, or None if a set could not be found. Brute force search of lowest level bitmap. This is not very efficient, and is not intended to be called in performance-critical code.

(
        &mut self,
        needed_frames: u64,
        max_address: u64
    )

    /// very efficient, and is not intended to be called in
    /// performance-critical code.
    fn consecutive_frames(
        &mut self,
        needed_frames: u64,
        max_address: u64
    ) -> Option<u64> {
        // Ensure that there is at least one frame in range
        if max_address < (self.frame_phys_addr.as_u64() + 4095) {
            return None;
        }

        // Restrict the number of frames to those under the address limit
        let max_frames = (max_address + 1 - self.frame_phys_addr.as_u64()) >> 12;
        let nframes = if max_frames < self.nframes {max_frames} else {self.nframes};

        // Number of 32-bit chunks to search
        let nchunks = (nframes >> 5) + if nframes & 31 != 0 {1} else {0};

        // Pointer to lowest level frame bitmap
        let ptr = self.bitmap_virt_addr[0].as_mut_ptr() as *mut u32;

        let mut count = 0; // How many consecutive frames found so far?
        for chunk in 0..nchunks {
            let bitmap = unsafe{*ptr.offset(chunk as isize)};

            for pos in 0..32 {
                if bitmap & (1 << pos) == 0 {
                    // Not available
                    count = 0;
                } else {
                    // Available frame
                    count += 1;
                    if count == needed_frames {
                        // Found a consecutive set of frames
                        let start_frame = (chunk << 5) + pos + 1 - count;

                        // Mark each frame as taken
                        for frame in start_frame..(start_frame + needed_frames) {
                            let mut chunk_number = frame;

                            // Clear higher bitmaps if the chunk is empty
                            for level in 0..self.nlevels {
                                // Low 5 bits of the chunk at the lower level are the index at this level
                                let index = chunk_number & 31;
                                // High bits are the chunk at this level
                                chunk_number = chunk_number >> 5;

                                let ptr = unsafe{(self.bitmap_virt_addr[level].as_mut_ptr() as *mut u32)
                                                 .offset(chunk_number as isize)};
                                let mut bitmap = unsafe{*ptr};

                                bitmap &= !(1 << index); // clear bit
                                unsafe {core::ptr::write(ptr, bitmap)};

                                if bitmap != 0 {
                                    // This chunk still has frames => stop clearing
                                    break;
                                }
                            }