Added buffers to the best of my ability & improvements

Author: Kamilosok

include/drivers/dt/dt.h

@@ -1,6 +1,7 @@
 #ifndef DT_H
 #define DT_H
 
+#include <stdbigos/buffer.h>
 #include <stdbigos/types.h>
 
 struct dt_node;
@@ -9,7 +10,7 @@ struct dt_prop;
 // Initializes the device tree driver
 // TODO: Currently parses the entire FDT at init, maybe change to lazy parsing later
 // Builds the actual tree structure handleable by the driver, 0 if success, <0 if error
-int dt_init(const void* fdt_blob, u32 blob_size);
+int dt_init(buffer_t fdt_buf);
 
 // Frees all memory used by the arena
 void dt_cleanup(void);

include/stdbigos/bitutils.h

@@ -3,37 +3,10 @@
 
 #include <stdbigos/types.h>
 
-// Reads a single 32-bit unsigned integer value from the specified address
-static inline u32 read_be32(const void* addr) {
-	const u8* bytes = (const u8*)addr;
-	return ((u32)bytes[0] << 24) | ((u32)bytes[1] << 16) | ((u32)bytes[2] << 8) | ((u32)bytes[3] << 0);
-};
+u32 read_be32(const void* addr);
 
-// Reads a single 64-bit unsigned integer value from the specified address
-static inline u64 read_be64(const void* addr) {
-	const u8* bytes = (const u8*)addr;
-	return ((u64)bytes[0] << 56) | ((u64)bytes[1] << 48) | ((u64)bytes[2] << 40) | ((u64)bytes[3] << 32) |
-	       ((u64)bytes[4] << 24) | ((u64)bytes[5] << 16) | ((u64)bytes[6] << 8) | ((u64)bytes[7] << 0);
-};
+u64 read_be64(const void* addr);
 
-// Helper for aligning to 4 bytes
-static inline u32 align4(u32 off) {
-	return (off + 3) & ~3u;
-}
-
-// Helper for aligning to 8 bytes
-static inline u32 align8(u32 off) {
-	return (off + 7) & ~7u;
-}
-
-// Helper for aligning to 16 bytes
-static inline u32 align16(u32 off) {
-	return (off + 15) & ~15u;
-}
-
-// Helper for aligning to 32 bytes
-static inline u32 align32(u32 off) {
-	return (off + 31) & ~31u;
-}
+u32 alignN(u32 num, u32 align);
 
 #endif

include/stdbigos/buffer.h

@@ -0,0 +1,36 @@
+#ifndef DRIVERS_DT_BUFFER_H
+#define DRIVERS_DT_BUFFER_H
+
+#include <stdbigos/types.h>
+
+// Error codes
+#define BUFFER_OK            0
+#define BUFFER_OUT_OF_BOUNDS -1
+
+typedef struct buffer_t {
+	const void* data;
+	size_t size;
+} buffer_t;
+
+// Helper to create a buffer
+static inline buffer_t make_buffer(const void* data, size_t size) {
+	buffer_t buf = {data, size};
+	return buf;
+}
+
+// Read big-endian 32-bit from buffer at given offset
+int buffer_read_u32_be(const buffer_t* buf, size_t offset, u32* out);
+
+// Read big-endian 64-bit from buffer at given offset
+int buffer_read_u64_be(const buffer_t* buf, size_t offset, u64* out);
+
+// Read little-endian 32-bit from buffer at given offset
+int buffer_read_u32_le(const buffer_t* buf, size_t offset, u32* out);
+
+// Read little-endian 64-bit from buffer at given offset
+int buffer_read_u64_le(const buffer_t* buf, size_t offset, u64* out);
+
+// Read a zero-terminated C-string from buf at offset
+int buffer_read_cstring(const buffer_t* buf, size_t offset, const char** out_str);
+
+#endif

src/drivers/dt/dt_access.c

@@ -11,6 +11,24 @@ static void sbi_puts(const char* str) {
 	while (*str) sbi_debug_console_write_byte(*str++);
 }
 
+static void sbi_put_u32(u32 num) {
+	char buf[11];
+	int i = 10;
+	buf[i] = '\0';
+	i--;
+	if (num == 0) {
+		sbi_puts("0");
+		return;
+	}
+
+	while (num && i >= 0) {
+		buf[i] = (num % 10 + '0');
+		i--;
+		num /= 10;
+	}
+	sbi_puts(&buf[i + 1]);
+}
+
 // There has to be a better way to do this
 static void gap(u8 size) {
 	for (u8 i = 0; i < size; i++) sbi_puts("\t");

src/drivers/dt/dt_alloc.c

@@ -1,6 +1,7 @@
 #include "dt_alloc.h"
 
 #include <stdbigos/bitutils.h>
+#include <stdbigos/buffer.h>
 #include <stdbigos/types.h>
 
 // Arena
@@ -32,7 +33,7 @@ void* dt_alloc(u32 size) {
 		return nullptr;
 
 	// Align to 4 bytes
-	u32 align = align4(size);
+	u32 align = alignN(size, 4);
 
 	if (arena_offset + align > arena_size)
 		return nullptr;

src/drivers/dt/dt_init.c

@@ -1,5 +1,5 @@
 #include <drivers/dt/dt.h>
-#include <stdbigos/bitutils.h>
+#include <stdbigos/buffer.h>
 #include <stdbigos/types.h>
 
 #include "dt_alloc.h"
@@ -19,30 +19,38 @@ struct dt_node* root_node = nullptr;
 #define FDT_OFF_SIZE_DT_STRINGS   0x20
 #define FDT_OFF_SIZE_DT_STRUCT    0x24
 
-int dt_init(const void* fdt_blob, u32 blob_size) {
-	if (!fdt_blob || blob_size < (FDT_OFF_OFF_DT_STRINGS + 4))
+int dt_init(buffer_t fdt_buf) {
+	if (!fdt_buf.data || fdt_buf.size < (FDT_OFF_OFF_DT_STRINGS + 4))
 		return -1;
 
-	const u8* fdt_u8 = (const u8*)fdt_blob;
-	u32 magic = read_be32(fdt_u8 + FDT_OFF_MAGIC);
-	if (magic != FDT_MAGIC)
+	u32 magic;
+	if (buffer_read_u32_be(&fdt_buf, 0, &magic) != BUFFER_OK || magic != FDT_MAGIC)
 		return -2;
 
-	u32 total_size = read_be32(fdt_u8 + FDT_OFF_TOTAL_SIZE);
-	u32 struct_off = read_be32(fdt_u8 + FDT_OFF_OFF_DT_STRUCT);
-	u32 strings_off = read_be32(fdt_u8 + FDT_OFF_OFF_DT_STRINGS);
+	u32 total_size;
+	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_TOTAL_SIZE, &total_size) != BUFFER_OK)
+		return -2;
+
+	u32 struct_off;
+	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_OFF_DT_STRUCT, &struct_off) != BUFFER_OK)
+		return -2;
 
-	u32 struct_size = read_be32(fdt_u8 + FDT_OFF_SIZE_DT_STRUCT);
+	u32 strings_off;
+	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_OFF_DT_STRINGS, &strings_off) != BUFFER_OK)
+		return -2;
 
-	if (total_size > blob_size || struct_off + struct_size > blob_size)
+	u32 struct_size;
+	if (buffer_read_u32_be(&fdt_buf, FDT_OFF_SIZE_DT_STRUCT, &struct_size) != BUFFER_OK)
+		return -2;
+
+	if (struct_off + struct_size > total_size)
 		return -3;
 
 	if (dt_arena_init(dt_arena_buffer, DT_ARENA_SIZE) < 0)
 		return -4;
 
 	u32 offset = struct_off + 4;
-
-	root_node = parse_subtree(fdt_blob, &offset, struct_off + struct_size, strings_off, nullptr);
+	root_node = parse_subtree(&fdt_buf, &offset, struct_off + struct_size, strings_off, nullptr);
 	if (!root_node)
 		return -5;
 

src/drivers/dt/dt_node.h

@@ -4,20 +4,20 @@
 #include <stdbigos/types.h>
 
 // Both prop and node structures are lists with outside pointers only to the first element
-struct dt_prop {
+typedef struct dt_prop {
 	const char* name;
 	const void* value;
 	u32 data_length;
 	struct dt_prop* next_prop;
-};
+} dt_prop;
 
-struct dt_node {
+typedef struct dt_node {
 	const char* name;
 	u32 phandle;
 	struct dt_prop* props;
 	struct dt_node* parent;
 	struct dt_node* first_child;
 	struct dt_node* next_sibling;
-};
+} dt_node;
 
 #endif

src/drivers/dt/dt_parser.c

@@ -1,6 +1,7 @@
 #include "dt_parser.h"
 
 #include <stdbigos/bitutils.h>
+#include <stdbigos/buffer.h>
 #include <stdbigos/string.h>
 #include <stdbigos/types.h>
 
@@ -16,47 +17,50 @@
 
 // Function to parse a block of properties starting at props_offset with props_size size in the FDT with fdt
 // being a ptr to the start of the flattened device tree blob
-struct dt_prop* parse_props(const void* fdt, u32 props_offset, u32 props_size, u32 str_offset) {
+struct dt_prop* parse_props(buffer_t* fdt_buf, u32 props_offset, u32 props_size, u32 str_offset) {
 	u32 curr_offset = props_offset;
-	const u8* fdt_u8 = (const u8*)fdt;
+
 	struct dt_prop* head = nullptr;
 	struct dt_prop** pp = &head;
 
 	while (curr_offset < props_offset + props_size) {
-		u32 tag = read_be32(fdt_u8 + curr_offset);
+		u32 tag;
+		buffer_read_u32_be(fdt_buf, curr_offset, &tag);
 
 		// Because of the separation of parsing properties and nodes, we don't want to parse non-properties
 		if (tag != FDT_PROP)
 			break;
 
 		curr_offset += 4;
-		u32 len = read_be32(fdt_u8 + curr_offset);
+		u32 len;
+		buffer_read_u32_be(fdt_buf, curr_offset, &len);
 		curr_offset += 4;
-		u32 name_offset = read_be32(fdt_u8 + curr_offset);
+		u32 name_offset;
+		buffer_read_u32_be(fdt_buf, curr_offset, &name_offset);
 		curr_offset += 4;
 		struct dt_prop* new_prop = dt_alloc(sizeof(*new_prop));
 		new_prop->data_length = len;
 		new_prop->next_prop = nullptr;
 
-		new_prop->name = (const char*)(fdt_u8 + str_offset + name_offset);
+		buffer_read_cstring(fdt_buf, str_offset + name_offset, &new_prop->name);
 		// sbi_puts(new_prop->name);
 		// sbi_puts("\n");
 
-		new_prop->value = fdt_u8 + curr_offset;
+		// Forced
+		new_prop->value = (const u8*)fdt_buf->data + curr_offset;
 
 		// At first it sets the head in the right place, then it sets the next_prop of the previous property to point to
 		// the current property
 		*pp = new_prop;
 		pp = &new_prop->next_prop;
 
-		curr_offset = align4(curr_offset + len);
+		curr_offset = alignN(curr_offset + len, 4);
 	}
 	return head;
 }
 
 // Function to recursively parse a subtree at the given offset
-struct dt_node* parse_subtree(const void* fdt, u32* offset, u32 max_offset, u32 str_offset, struct dt_node* parent) {
-	const u8* fdt_u8 = (const u8*)fdt;
+struct dt_node* parse_subtree(buffer_t* fdt_buf, u32* offset, u32 max_offset, u32 str_offset, struct dt_node* parent) {
 	struct dt_node* node = dt_alloc(sizeof(*node));
 
 	if (!node)
@@ -70,44 +74,50 @@ struct dt_node* parse_subtree(const void* fdt, u32* offset, u32 max_offset, u32
 
 	u32 curr_offset = *offset;
 
-	if (read_be32(fdt_u8 + curr_offset - 4) != FDT_BEGIN_NODE) {
-		return nullptr;
-	}
+	u32 tag;
 
-	const char* name = (const char*)(fdt_u8 + curr_offset);
+	if (buffer_read_u32_be(fdt_buf, curr_offset - 4, &tag) != BUFFER_OK || tag != FDT_BEGIN_NODE)
+		return nullptr;
 
-	if (!name)
+	const char* name;
+	if (buffer_read_cstring(fdt_buf, curr_offset, &name) != BUFFER_OK)
 		return nullptr;
 
+	// After this point all reads from the buffer should be correct
+
 	u32 name_len = strlen(name) + 1;
 
 	node->name = name;
 
-	curr_offset = align4(curr_offset + name_len);
+	curr_offset = alignN(curr_offset + name_len, 4);
 
 	u32 props_off = curr_offset;
 	while (curr_offset < max_offset) {
-		u32 tag = read_be32(fdt_u8 + curr_offset);
+		u32 tag;
+		buffer_read_u32_be(fdt_buf, curr_offset, &tag);
 		if (tag != FDT_PROP)
 			break;
-		u32 p_len = read_be32(fdt_u8 + curr_offset + 4);
+
+		u32 p_len;
+		buffer_read_u32_be(fdt_buf, curr_offset + 4, &p_len);
 
 		curr_offset += 12; // Skip tag, length, name_offset
-		curr_offset = align4(curr_offset + p_len);
+		curr_offset = alignN(curr_offset + p_len, 4);
 	}
-
 	u32 props_len = curr_offset - props_off;
 
-	node->props = parse_props(fdt, props_off, props_len, str_offset);
+	node->props = parse_props(fdt_buf, props_off, props_len, str_offset);
 
-	curr_offset = align4(props_off + props_len);
+	curr_offset = alignN(props_off + props_len, 4);
 
 	while (curr_offset < max_offset) {
-		u32 tag = read_be32(fdt_u8 + curr_offset);
+		u32 tag;
+		buffer_read_u32_be(fdt_buf, curr_offset, &tag);
+
 		curr_offset += 4;
 		switch (tag) {
 		case FDT_BEGIN_NODE:
-			struct dt_node* child = parse_subtree(fdt, &curr_offset, max_offset, str_offset, node);
+			struct dt_node* child = parse_subtree(fdt_buf, &curr_offset, max_offset, str_offset, node);
 
 			if (child) {
 				if (!node->first_child)

src/drivers/dt/dt_parser.h

@@ -1,10 +1,11 @@
 #ifndef DT_PARSER_H
 #define DT_PARSER_H
 
+#include <stdbigos/buffer.h>
 #include <stdbigos/types.h>
 
-struct dt_prop* parse_props(const void* fdt, u32 props_offset, u32 props_size, u32 str_offset);
+struct dt_prop* parse_props(buffer_t* fdt_buf, u32 props_offset, u32 props_size, u32 str_offset);
 
-struct dt_node* parse_subtree(const void* fdt, u32* offset, u32 max_offset, u32 str_offset, struct dt_node* parent);
+struct dt_node* parse_subtree(buffer_t* fdt_buf, u32* offset, u32 max_offset, u32 str_offset, struct dt_node* parent);
 
 #endif

src/example_dtree/entry.c

@@ -3,6 +3,7 @@
 #include <drivers/dt/dt_props.h>
 #include <drivers/uart.h>
 #include <stdbigos/bitutils.h>
+#include <stdbigos/buffer.h>
 #include <stdbigos/sbi.h>
 #include <stdbigos/types.h>
 
@@ -48,8 +49,9 @@
 
 void main([[maybe_unused]] u32 hartid, const void* fdt) {
 	u32 blob_size = read_be32((const u8*)fdt + 4);
+	buffer_t buf = make_buffer(fdt, blob_size);
 
-	if (dt_init(fdt, blob_size) < 0) {
+	if (dt_init(buf) < 0) {
 		sbi_puts("DT_INIT FAILED\n");
 		return;
 	}