Merge pull request #13 from achilleasa/boot-allocator-tweaks

Boot allocator tweaks

Makefile

@@ -52,7 +52,7 @@ go.o:
 	@# with slashes we create a global symbol alias for kernel.Kmain
 	@echo "[objcopy] creating global symbol alias 'kernel.Kmain' for 'github.com/achilleasa/gopher-os/kernel.Kmain' in go.o"
 	@objcopy \
-		--add-symbol kernel.Kmain=.text:0x`nm $(BUILD_DIR)/go.o | grep "kernel.Kmain$$" | cut -d' ' -f1` \
+		--add-symbol kernel.Kmain=.text:0x`nm $(BUILD_DIR)/go.o | grep "kmain.Kmain$$" | cut -d' ' -f1` \
 		 $(BUILD_DIR)/go.o $(BUILD_DIR)/go.o
 
 binutils_version_check:

kernel/error.go

@@ -0,0 +1,18 @@
+package kernel
+
+// Error describes a kernel kerror. All kernel errors must be defined as global
+// variables that are pointers to the Error structure. This requirement stems
+// from the fact that the Go allocator is not available to us so we cannot use
+// errors.New.
+type Error struct {
+	// The module where the error occurred.
+	Module string
+
+	// The error message
+	Message string
+}
+
+// Error implements the error interface.
+func (e *Error) Error() string {
+	return e.Message
+}

kernel/error_test.go

@@ -0,0 +1,14 @@
+package kernel
+
+import "testing"
+
+func TestKernelError(t *testing.T) {
+	err := &Error{
+		Module:  "foo",
+		Message: "error message",
+	}
+
+	if err.Error() != err.Message {
+		t.Fatalf("expected to err.Error() to return %q; got %q", err.Message, err.Error())
+	}
+}

kernel/kmain/kmain.go

@@ -1,4 +1,4 @@
-package kernel
+package kmain
 
 import (
 	"github.com/achilleasa/gopher-os/kernel/hal"

kernel/mem/constants_amd64.go

@@ -3,6 +3,10 @@
 package mem
 
 const (
+	// PointerShift is equal to log2(unsafe.Sizeof(uintptr)). The pointer
+	// size for this architecture is defined as (1 << PointerShift).
+	PointerShift = 3
+
 	// PageShift is equal to log2(PageSize). This constant is used when
 	// we need to convert a physical address to a page number (shift right by PageShift)
 	// and vice-versa.

kernel/mem/pmm/bootmem_allocator.go

@@ -1,6 +1,7 @@
 package pmm
 
 import (
+	"github.com/achilleasa/gopher-os/kernel"
 	"github.com/achilleasa/gopher-os/kernel/hal/multiboot"
 	"github.com/achilleasa/gopher-os/kernel/kfmt/early"
 	"github.com/achilleasa/gopher-os/kernel/mem"
@@ -11,6 +12,9 @@ var (
 	// which is used to bootstrap the kernel before initializing a more
 	// advanced memory allocator.
 	EarlyAllocator BootMemAllocator
+
+	errBootAllocUnsupportedPageSize = &kernel.Error{Module: "pmm.BootMemAllocator", Message: "allocator only support allocation requests of order(0)"}
+	errBootAllocOutOfMemory         = &kernel.Error{Module: "pmm.BootMemAllocator", Message: "out of memory"}
 )
 
 // BootMemAllocator implements a rudimentary physical memory allocator which is used
@@ -56,18 +60,13 @@ func (alloc *BootMemAllocator) Init() {
 }
 
 // AllocFrame scans the system memory regions reported by the bootloader and
-// reseves the next available free frame. AllocFrame returns false if no more
-// memory can be allocated.
+// reserves the next available free frame.
 //
-// The allocator only supports allocating blocks equal to the page size.
-// Requests for a page order > 0 will cause the allocator to return false.
-//
-// The use of a bool return value is intentional; if this method returned an
-// error then the compiler would call runtime.convT2I which in turn invokes the
-// yet uninitialized Go allocator.
-func (alloc *BootMemAllocator) AllocFrame(order mem.PageOrder) (Frame, bool) {
+// AllocFrame returns an error if no more memory can be allocated or when the
+// requested page order is > 0.
+func (alloc *BootMemAllocator) AllocFrame(order mem.PageOrder) (Frame, *kernel.Error) {
 	if order > 0 {
-		return InvalidFrame, false
+		return InvalidFrame, errBootAllocUnsupportedPageSize
 	}
 
 	var (
@@ -103,11 +102,11 @@ func (alloc *BootMemAllocator) AllocFrame(order mem.PageOrder) (Frame, bool) {
 	})
 
 	if foundPageIndex == -1 {
-		return InvalidFrame, false
+		return InvalidFrame, errBootAllocOutOfMemory
 	}
 
 	alloc.allocCount++
 	alloc.lastAllocIndex = foundPageIndex
 
-	return Frame(foundPageIndex), true
+	return Frame(foundPageIndex), nil
 }

kernel/mem/pmm/bootmem_allocator_test.go

@@ -36,9 +36,12 @@ func TestBootMemoryAllocator(t *testing.T) {
 		allocFrameCount uint64
 	)
 	for alloc.Init(); ; allocFrameCount++ {
-		frame, ok := alloc.AllocFrame(mem.PageOrder(0))
-		if !ok {
-			break
+		frame, err := alloc.AllocFrame(mem.PageOrder(0))
+		if err != nil {
+			if err == errBootAllocOutOfMemory {
+				break
+			}
+			t.Fatalf("[frame %d] unexpected allocator error: %v", allocFrameCount, err)
 		}
 
 		expAddress := uintptr(uint64(alloc.lastAllocIndex) * uint64(mem.PageSize))
@@ -49,14 +52,6 @@ func TestBootMemoryAllocator(t *testing.T) {
 		if !frame.IsValid() {
 			t.Errorf("[frame %d] expected IsValid() to return true", allocFrameCount)
 		}
-
-		if got := frame.PageOrder(); got != mem.PageOrder(0) {
-			t.Errorf("[frame %d] expected allocated frame page order to be 0; got %d", allocFrameCount, got)
-		}
-
-		if got := frame.Size(); got != mem.PageSize {
-			t.Errorf("[frame %d] expected allocated frame size to be %d; got %d", allocFrameCount, mem.PageSize, got)
-		}
 	}
 
 	if allocFrameCount != totalFreeFrames {
@@ -64,8 +59,8 @@ func TestBootMemoryAllocator(t *testing.T) {
 	}
 
 	// This allocator only works with order(0) blocks
-	if frame, ok := alloc.AllocFrame(mem.PageOrder(1)); ok || frame.IsValid() {
-		t.Fatalf("expected allocator to return false and an invalid frame when requested to allocate a block with order > 0; got %t, %v", ok, frame)
+	if frame, err := alloc.AllocFrame(mem.PageOrder(1)); err != errBootAllocUnsupportedPageSize || frame.IsValid() {
+		t.Fatalf("expected allocator to return errBootAllocUnsupportedPageSize and an invalid frame when requested to allocate a block with order > 0; got %v, %v", err, frame)
 	}
 }
 

kernel/mem/pmm/frame.go

@@ -8,7 +8,7 @@ import (
 )
 
 // Frame describes a physical memory page index.
-type Frame uint64
+type Frame uintptr
 
 const (
 	// InvalidFrame is returned by page allocators when
@@ -25,14 +25,3 @@ func (f Frame) IsValid() bool {
 func (f Frame) Address() uintptr {
 	return uintptr(f << mem.PageShift)
 }
-
-// PageOrder returns the page order of this frame. The page order is encoded in the
-// 8 MSB of the frame number.
-func (f Frame) PageOrder() mem.PageOrder {
-	return mem.PageOrder((f >> 56) & 0xFF)
-}
-
-// Size returns the size of this frame.
-func (f Frame) Size() mem.Size {
-	return mem.PageSize << ((f >> 56) & 0xFF)
-}

kernel/mem/pmm/frame_test.go

@@ -15,17 +15,9 @@ func TestFrameMethods(t *testing.T) {
 				t.Errorf("[order %d] expected frame %d to be valid", order, frameIndex)
 			}
 
-			if got := frame.PageOrder(); got != order {
-				t.Errorf("[order %d] expected frame (%d, index: %d) call to PageOrder() to return %d; got %d", order, frame, frameIndex, order, got)
-			}
-
 			if exp, got := uintptr(frameIndex<<mem.PageShift), frame.Address(); got != exp {
 				t.Errorf("[order %d] expected frame (%d, index: %d) call to Address() to return %x; got %x", order, frame, frameIndex, exp, got)
 			}
-
-			if exp, got := mem.Size(mem.PageSize<<order), frame.Size(); got != exp {
-				t.Errorf("[order %d] expected frame (%d, index: %d) call to Size() to return %d; got %d", order, frame, frameIndex, exp, got)
-			}
 		}
 	}
 }

stub.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/achilleasa/gopher-os/kernel"
+import "github.com/achilleasa/gopher-os/kernel/kmain"
 
 var multibootInfoPtr uintptr
 
@@ -11,5 +11,5 @@ var multibootInfoPtr uintptr
 // A global variable is passed as an argument to Kmain to prevent the compiler
 // from inlining the actual call and removing Kmain from the generated .o file.
 func main() {
-	kernel.Kmain(multibootInfoPtr)
+	kmain.Kmain(multibootInfoPtr)
 }