named constants for buddy init

Author: braindigitalis

include/basic/tokenizer.h

@@ -268,7 +268,7 @@ void tokenizer_next(struct basic_ctx* ctx);
  * @param ctx context
  * @return int token
  */
-enum token_t tokenizer_token(struct basic_ctx* ctx);
+#define tokenizer_token(ctx) ((enum token_t)ctx->current_token)
 
 /**
  * @brief Get integer number as next token
@@ -307,7 +307,7 @@ const char* tokenizer_variable_name(struct basic_ctx* ctx, size_t* count);
  * @param ctx context
  * @return int true if the program has finished
  */
-bool tokenizer_finished(struct basic_ctx* ctx);
+#define tokenizer_finished(ctx) (*ctx->ptr == 0 || ctx->current_token == ENDOFINPUT)
 
 /**
  * @brief display an error to the terminal and end the program

include/buddy_allocator.h

@@ -31,6 +31,36 @@
 #include <stddef.h>
 #include <stdint.h>
 
+typedef enum buddy_order {
+	buddy_32b   = 5,
+	buddy_64b   = 6,
+	buddy_128b  = 7,
+	buddy_256b  = 8,
+	buddy_512b  = 9,
+	buddy_1kb   = 10,
+	buddy_2kb   = 11,
+	buddy_4kb   = 12,
+	buddy_8kb   = 13,
+	buddy_16kb  = 14,
+	buddy_32kb  = 15,
+	buddy_64kb  = 16,
+	buddy_128kb = 17,
+	buddy_256kb = 18,
+	buddy_512kb = 19,
+	buddy_1mb   = 20,
+	buddy_2mb   = 21,
+	buddy_4mb   = 22,
+	buddy_8mb   = 23,
+	buddy_16mb  = 24,
+	buddy_32mb  = 25,
+	buddy_64mb  = 26,
+	buddy_128mb = 27,
+	buddy_256mb = 28,
+	buddy_512mb = 29
+} buddy_order_t;
+
+#define BUDDY_MAX_ORDER buddy_512mb
+#define BUDDY_MIN_ORDER buddy_32b
 
 /**
  * @brief Block header used for both free list nodes and allocated blocks.
@@ -127,6 +157,45 @@ void* buddy_malloc(buddy_allocator_t* alloc, size_t size);
  */
 void buddy_free(buddy_allocator_t* alloc, const void *ptr);
 
+/**
+ * @brief Allocate an aligned block of memory from the buddy allocator.
+ *
+ * @param alloc  Allocator instance to allocate from.
+ * @param size   Requested size in bytes.
+ * @param align  Required alignment in bytes (power of two).
+ * @return Pointer to aligned memory, or NULL if out of memory.
+ *
+ * @note If align <= 8, this function behaves identically to buddy_malloc()
+ *       and returns a pointer aligned to at least 8 bytes.
+ *
+ * @note For align > 8, additional space is allocated and the returned pointer
+ *       is adjusted to satisfy the requested alignment. The original allocation
+ *       pointer is stored internally and must be released using
+ *       buddy_free_aligned().
+ *
+ * @note The minimum guaranteed alignment of all allocations from the buddy
+ *       allocator is 8 bytes, determined by sizeof(buddy_header_t).
+ */
+void* buddy_malloc_aligned(buddy_allocator_t* alloc, size_t size, size_t align);
+
+/**
+ * @brief Free memory allocated by buddy_malloc_aligned().
+ *
+ * @param alloc  Allocator instance.
+ * @param ptr    Pointer previously returned by buddy_malloc_aligned().
+ * @param align  Alignment value originally passed to buddy_malloc_aligned().
+ *
+ * @note The align argument must match the value used for allocation.
+ *
+ * @note If align <= 8, this function behaves identically to buddy_free(),
+ *       because buddy_malloc_aligned() does not adjust the returned pointer
+ *       for alignments already guaranteed by the allocator.
+ *
+ * @note Passing a different alignment value from the one used at allocation
+ *       time results in undefined behaviour.
+ */
+void buddy_free_aligned(buddy_allocator_t* alloc, void* ptr, size_t align);
+
 /**
  * @brief Destroy a buddy allocator and free all regions.
  *

modules/virtio_net/virtio_net.c

@@ -291,7 +291,7 @@ bool virtio_send_packet(void *data, uint16_t len) {
 
 	memset(hdr, 0, VNET_HDR_SIZE);
 
-	void *pay = buddy_malloc(&tx_buffer_allocator, len);
+	void *pay = buddy_malloc_aligned(&tx_buffer_allocator, len, 16);
 	if (!pay) {
 		virtq_free_desc(tq, (uint16_t) h);
 		virtq_free_desc(tq, (uint16_t) p);
@@ -326,7 +326,7 @@ static void vnet_tx_complete(void) {
 
 		void* paybuf = (void *) (uintptr_t) tq->desc[pay].addr;
 		if (paybuf) {
-			buddy_free(&tx_buffer_allocator, paybuf);
+			buddy_free_aligned(&tx_buffer_allocator, paybuf, 16);
 		}
 
 		virtq_free_desc(tq, pay);
@@ -443,7 +443,7 @@ bool EXPORTED MOD_INIT_SYM(KMOD_ABI)(void) {
 		return false;
 	}
 	/* We use a buddy allocator for TX buffer as it is faster and aligned as standard */
-	buddy_init(&tx_buffer_allocator, 6, 22, 22);
+	buddy_init(&tx_buffer_allocator, buddy_64b, buddy_4mb, buddy_4mb);
 	if (!virtio_net_start(&dev)) {
 		return false;
 	}

src/acpi.c

@@ -93,7 +93,7 @@ void init_uacpi(void) {
 	mhz = tsc_per_sec / 1000000;
 	dprintf("mhz = %lu, tsc_per_sec = %lu\n", mhz, tsc_per_sec);
 
-	buddy_init(&acpi_pool, 6, 22, 22);
+	buddy_init(&acpi_pool, buddy_64b, buddy_4mb, buddy_4mb);
 
 	uacpi_context_set_log_level(UACPI_LOG_INFO);
 	st = uacpi_initialize(0);

src/basic/flow_control.c

@@ -97,23 +97,18 @@ void error_statement(struct basic_ctx* ctx)
 
 void if_statement(struct basic_ctx* ctx)
 {
-	basic_debug("line %ld if_statement\n", ctx->current_linenum);
-
 	accept_or_return(IF, ctx);
 	bool r = conditional(ctx);
 	accept_or_return(THEN, ctx);
 
 	if (r) {
-		basic_debug("conditional is true\n");
 		if (tokenizer_token(ctx) == NEWLINE) {
 			/* Multi-statement block IF */
 			accept_or_return(NEWLINE, ctx);
 			return;
 		}
 		statement(ctx);
 	} else {
-		basic_debug("conditional is false\n");
-
 		if (tokenizer_token(ctx) == NEWLINE) {
 			/* --- multiline false-branch with nesting --- */
 			/* Enter the block and scan forward once, respecting nested multiline IFs */

src/basic/main.c

@@ -941,7 +941,7 @@ void basic_run(struct basic_ctx *ctx) {
 		return;
 	}
 	/* TODO Make sure this only runs for foreground processes! */
-	if (basic_esc() && !ctx->errored) {
+	if (!ctx->errored && basic_esc()) {
 		kgetc();
 		tokenizer_error_print(ctx, "Escape");
 		return;

src/basic/statement.c

@@ -9,15 +9,16 @@ void statement(struct basic_ctx* ctx)
 	GENERATE_ENUM_STRING_NAMES(TOKEN, token_names)
 	GENERATE_ENUM_STRING_LENGTHS(TOKEN, token_name_lengths)
 	enum token_t token = tokenizer_token(ctx);
-	if (token < DISPATCH_TABLE_COUNT(dispatch_by_token)) {
-		if (dispatch_by_token[token] != NULL) {
-			if (is_restricted_len(ctx, token_names[token], token_name_lengths[token])) {
-				tokenizer_error_printf(ctx, "Keyword '%s' is restricted by parent program", token_names[token]);
-				return;
-			}
-			dispatch_by_token[token](ctx);
+	if (dispatch_by_token[token] != NULL) {
+		if (is_restricted_len(ctx, token_names[token], token_name_lengths[token])) {
+			tokenizer_error_printf(ctx, "Keyword '%s' is restricted by parent program", token_names[token]);
 			return;
 		}
+		dispatch_by_token[token](ctx);
+		return;
+	} else if (token != NO_TOKEN) {
+		tokenizer_error_printf(ctx, "Keyword %s can't be used here", token_names[token]);
+		return;
 	}
 
 	dprintf("Unknown keyword: %d\n", token);
@@ -26,14 +27,12 @@ void statement(struct basic_ctx* ctx)
 
 void line_statement(struct basic_ctx* ctx)
 {
-	basic_debug("line_statement\n");
 	if (tokenizer_token(ctx) == NEWLINE) {
 		/* Empty line! */
 		accept(NEWLINE, ctx);
 		return;
 	}
 	int64_t line = tokenizer_num(ctx, NUMBER);
-	basic_debug("line_statement parsed line %ld\n", line);
 	if (line == 0) {
 		return tokenizer_error_printf(ctx, "Missing line number after line %lu: %s", ctx->current_linenum, ctx->ptr);
 	}

src/basic/tokenizer.c

@@ -110,7 +110,7 @@ static int interned_name_compare(const void *a, const void *b, void *udata)
 static bool ensure_interned_variable_names(void)
 {
 	if (!interned_variable_name_allocator_ready) {
-		buddy_init(&interned_variable_name_allocator, 6, 22, 22);
+		buddy_init(&interned_variable_name_allocator, buddy_64b, buddy_4mb, buddy_4mb);
 		interned_variable_name_allocator_ready = true;
 	}
 
@@ -379,12 +379,11 @@ int get_next_token(struct basic_ctx* ctx)
 		}
 	}
 
-	if ((*ctx->ptr >= 'a' && *ctx->ptr <= 'z') || (*ctx->ptr >= 'A' && *ctx->ptr <= 'Z') || *ctx->ptr == '_') {
+	if (isalpha(*ctx->ptr) || *ctx->ptr == '_') {
 		ctx->nextptr = ctx->ptr;
 		int varl = 0;
 		while (
-			(*ctx->nextptr >= 'a' && *ctx->nextptr <= 'z') ||
-			(*ctx->nextptr >= 'A' && *ctx->nextptr <= 'Z') ||
+			isalpha(*ctx->nextptr) ||
 			(*ctx->nextptr == '_') ||
 			(varl > 0 && *ctx->nextptr == '$') ||
 			(varl > 0 && *ctx->nextptr == '#') ||
@@ -425,11 +424,6 @@ void tokenizer_init(const char *program, struct basic_ctx* ctx)
 	ctx->current_token = get_next_token(ctx);
 }
 
-enum token_t tokenizer_token(struct basic_ctx* ctx)
-{
-	return ctx->current_token;
-}
-
 void tokenizer_next(struct basic_ctx* ctx)
 {
 	if (tokenizer_finished(ctx)) {
@@ -557,11 +551,6 @@ void tokenizer_error_print(struct basic_ctx* ctx, const char* error)
 	}
 }
 
-bool tokenizer_finished(struct basic_ctx* ctx)
-{
-	return *ctx->ptr == 0 || ctx->current_token == ENDOFINPUT;
-}
-
 const char* tokenizer_variable_name(struct basic_ctx* ctx, size_t* count)
 {
 	char varname[MAX_VARNAME];

src/buddy_allocator.c

@@ -2,9 +2,6 @@
 #include <stddef.h>
 #include <kernel.h>
 
-#define BUDDY_MAX_ORDER 29
-#define BUDDY_MIN_ORDER 6
-
 static inline size_t order_size(int order) {
 	return (size_t)1 << order;
 }
@@ -87,14 +84,15 @@ static buddy_region_t *buddy_grow(buddy_allocator_t *alloc) {
 	}
 
 	size_t size = 1UL << grow;
-	void *pool = kmalloc(size);
+	void *pool = kmalloc_aligned(size, 8);
 	if (!pool) {
 		return NULL;
 	}
 
-	buddy_region_t *region = (buddy_region_t *)kmalloc(sizeof(buddy_region_t));
+	buddy_region_t *region = (buddy_region_t *)kmalloc_aligned(sizeof(buddy_region_t), 8);
 	if (!region) {
-		kfree_null(&pool);
+		kfree_aligned(pool);
+		pool = NULL;
 		return NULL;
 	}
 
@@ -200,6 +198,62 @@ void *buddy_malloc(buddy_allocator_t *alloc, size_t size) {
 	return NULL; // completely out of memory
 }
 
+void* buddy_malloc_aligned(buddy_allocator_t* alloc, size_t size, size_t align)
+{
+	if (!alloc || size == 0) {
+		return NULL;
+	}
+
+	if (align <= 8) {
+		return buddy_malloc(alloc, size);
+	}
+
+	if ((align & (align - 1)) != 0) {
+		dprintf("buddy_malloc_aligned: alignment must be power of two (got %lu)\n", align);
+		return NULL;
+	}
+
+	/* allocate extra space for alignment slack + pointer storage */
+	size_t total = size + align - 1 + sizeof(void*);
+	uint8_t* raw = (uint8_t*)buddy_malloc(alloc, total);
+	if (!raw) {
+		return NULL;
+	}
+
+	uintptr_t aligned = ((uintptr_t)(raw + sizeof(void*) + (align - 1))) & ~(uintptr_t)(align - 1);
+
+	/* store original pointer just before aligned block */
+	void** save = (void**)aligned;
+	save[-1] = raw;
+
+	return (void*)aligned;
+}
+
+void buddy_free_aligned(buddy_allocator_t* alloc, void* ptr, size_t align)
+{
+	if (!alloc || !ptr) {
+		return;
+	}
+
+	if (align <= 8) {
+		buddy_free(alloc, ptr);
+		return;
+	}
+
+	if ((align & (align - 1)) != 0) {
+		dprintf("buddy_free_aligned: alignment must be power of two (got %lu)\n", align);
+		return;
+	}
+
+	void** save = (void**)ptr;
+	if (!save[-1]) {
+		dprintf("buddy_free_aligned: missing backing pointer\n");
+		return;
+	}
+
+	buddy_free(alloc, save[-1]);
+}
+
 void buddy_free(buddy_allocator_t *alloc, const void *ptr) {
 	if (!ptr || !alloc) {
 		return;
@@ -270,8 +324,10 @@ void buddy_destroy(buddy_allocator_t *alloc) {
 	while (r) {
 		buddy_region_t *next = r->next;
 
-		kfree_null(&r->pool);  // free the pool and null it
-		kfree_null(&r);        // free the region struct itself and null that pointer
+		kfree_aligned(r->pool);  // free the pool and null it
+		kfree_aligned(r);        // free the region struct itself and null that pointer
+		r->pool = NULL;
+		r = NULL;
 
 		r = next;              // use the saved "next" to continue traversal
 	}

src/devicename.c

@@ -3,8 +3,7 @@
 
 struct hashmap* prefix_hash = NULL;
 
-int string_compare(const void *a, const void *b, [[maybe_unused]]
-__attribute__((unused)) void *udata) {
+int string_compare(const void *a, const void *b, [[maybe_unused]] __attribute__((unused)) void *udata) {
 	const devname_prefix_t* ua = a;
 	const devname_prefix_t* ub = b;
 	return strcmp(ua->prefix, ub->prefix);