include/: No dependency to lib/ukalloc for thread contexts

Changes the platform API in a way so that there is no dependency to
`ukalloc` for context creation. An API function is added to query the
allocation size for a thread context. Another API function is added to
call the platform-specific thread context initialization.

Signed-off-by: Simon Kuenzer <[email protected]>
Reviewed-by: Daniel Dinca <[email protected]>
Tested-by: Unikraft CI <[email protected]>
GitHub-Pull-Request: unikraft#138

Author: skuenzer

include/uk/plat/thread.h

@@ -46,19 +46,19 @@ enum ukplat_ctx_type {
 	ukplat_ctx_sw,
 };
 
-struct uk_alloc;
-
-typedef void *(*ukplat_ctx_create_func_t)
-		(struct uk_alloc *allocator, unsigned long sp,
-		 unsigned long tlsp);
+typedef __sz (*ukplat_ctx_size_func_t)(void);
+typedef void  (*ukplat_ctx_init_func_t)
+		(void *ctx, unsigned long sp, unsigned long tlsp);
 typedef void  (*ukplat_ctx_start_func_t)
 		(void *ctx);
 typedef void  (*ukplat_ctx_switch_func_t)
 		(void *prevctx, void *nextctx);
 
 struct ukplat_ctx_callbacks {
-	/* callback for creating thread context */
-	ukplat_ctx_create_func_t create_cb;
+	/* callback for returning the needed size for a thread context */
+	ukplat_ctx_size_func_t size_cb;
+	/* callback for initializing a new thread context */
+	ukplat_ctx_init_func_t init_cb;
 	/* callback for starting thread context */
 	ukplat_ctx_start_func_t start_cb __noreturn;
 	/* callback for switching contexts */
@@ -70,17 +70,23 @@ int ukplat_ctx_callbacks_init(struct ukplat_ctx_callbacks *ctx_cbs,
 
 
 static inline
-void *ukplat_thread_ctx_create(struct ukplat_ctx_callbacks *cbs,
-		struct uk_alloc *allocator, unsigned long sp,
-		unsigned long tlsp)
+__sz ukplat_thread_ctx_size(struct ukplat_ctx_callbacks *cbs)
 {
 	UK_ASSERT(cbs != __NULL);
-	UK_ASSERT(allocator != __NULL);
 
-	return cbs->create_cb(allocator, sp, tlsp);
+	return cbs->size_cb();
 }
 
-void ukplat_thread_ctx_destroy(struct uk_alloc *allocator, void *ctx);
+static inline
+void ukplat_thread_ctx_init(struct ukplat_ctx_callbacks *cbs,
+			    void *ctx,
+			    unsigned long sp, unsigned long tlsp)
+{
+	UK_ASSERT(cbs != __NULL);
+	UK_ASSERT(ctx != __NULL);
+
+	return cbs->init_cb(ctx, sp, tlsp);
+}
 
 static inline
 void ukplat_thread_ctx_start(struct ukplat_ctx_callbacks *cbs,

lib/uksched/include/uk/thread.h

@@ -33,6 +33,7 @@
 #ifdef CONFIG_LIBNEWLIBC
 #include <sys/reent.h>
 #endif
+#include <uk/alloc.h>
 #include <uk/arch/lcpu.h>
 #include <uk/arch/time.h>
 #include <uk/plat/thread.h>

lib/uksched/thread.c

@@ -94,6 +94,8 @@ int uk_thread_init(struct uk_thread *thread,
 		void (*function)(void *), void *arg)
 {
 	unsigned long sp;
+	void *ctx;
+	int ret = 0;
 
 	UK_ASSERT(thread != NULL);
 	UK_ASSERT(stack != NULL);
@@ -104,12 +106,15 @@ int uk_thread_init(struct uk_thread *thread,
 
 	init_sp(&sp, stack, function, arg);
 
-	/* Call platform specific setup. */
-	thread->ctx = ukplat_thread_ctx_create(cbs, allocator, sp,
-			(uintptr_t)ukarch_tls_pointer(tls));
-	if (thread->ctx == NULL)
-		return -1;
+	/* Allocate thread context */
+	ctx = uk_zalloc(allocator, ukplat_thread_ctx_size(cbs));
+	if (!ctx) {
+		ret = -1;
+		goto err_out;
+	}
 
+	memset(thread, 0, sizeof(*thread));
+	thread->ctx = ctx;
 	thread->name = name;
 	thread->stack = stack;
 	thread->tls = tls;
@@ -129,10 +134,17 @@ int uk_thread_init(struct uk_thread *thread,
 	uk_thread_sig_init(&thread->signals_container);
 #endif
 
+	/* Platform specific context initialization */
+	ukplat_thread_ctx_init(cbs, thread->ctx, sp,
+			       (uintptr_t) ukarch_tls_pointer(tls));
+
 	uk_pr_info("Thread \"%s\": pointer: %p, stack: %p, tls: %p\n",
 		   name, thread, thread->stack, thread->tls);
 
 	return 0;
+
+err_out:
+	return ret;
 }
 
 void uk_thread_fini(struct uk_thread *thread, struct uk_alloc *allocator)
@@ -141,7 +153,9 @@ void uk_thread_fini(struct uk_thread *thread, struct uk_alloc *allocator)
 #if CONFIG_LIBUKSIGNAL
 	uk_thread_sig_uninit(&thread->signals_container);
 #endif
-	ukplat_thread_ctx_destroy(allocator, thread->ctx);
+
+	uk_free(allocator, thread->ctx);
+	thread->ctx = NULL;
 }
 
 static void uk_thread_block_until(struct uk_thread *thread, __snsec until)

plat/common/include/uk/plat/common/sw_ctx.h

@@ -43,6 +43,9 @@ struct sw_ctx {
 	uintptr_t extregs;	/* Pointer to an area to which extended
 				 * registers are saved on context switch.
 				 */
+	uint8_t _extregs[];     /* Reserved memory area for extended
+				 * registers state
+				 */
 };
 
 void sw_ctx_callbacks_init(struct ukplat_ctx_callbacks *ctx_cbs);
@@ -51,8 +54,6 @@ void sw_ctx_callbacks_init(struct ukplat_ctx_callbacks *ctx_cbs);
 #define OFFSETOF_SW_CTX_SP      0
 #define OFFSETOF_SW_CTX_IP      8
 
-#define SIZEOF_SW_CTX           8
-
 /* TODO This should be better defined in the thread header */
 #define OFFSETOF_UKTHREAD_SW_CTX  16
 

plat/common/include/x86/cpu.h

@@ -110,22 +110,17 @@ static inline void restore_extregs(struct sw_ctx *ctx)
 	}
 }
 
-static inline struct sw_ctx *arch_alloc_sw_ctx(struct uk_alloc *allocator)
+static inline __sz arch_extregs_size(void)
 {
-	struct sw_ctx *ctx;
-	size_t sz;
+	/* Make sure that _init_cpufeatures() was called before */
+	UK_ASSERT(x86_cpu_features.extregs_size > 0);
 
-	sz = ALIGN_UP(sizeof(struct sw_ctx), x86_cpu_features.extregs_align)
-		+ x86_cpu_features.extregs_size;
-	ctx = uk_malloc(allocator, sz);
-	uk_pr_debug("Allocating %lu bytes for sw ctx at %p\n", sz, ctx);
-
-	return ctx;
+	return x86_cpu_features.extregs_align + x86_cpu_features.extregs_size;
 }
 
 static inline void arch_init_extregs(struct sw_ctx *ctx)
 {
-	ctx->extregs = ALIGN_UP(((uintptr_t)ctx + sizeof(struct sw_ctx)),
+	ctx->extregs = ALIGN_UP((uintptr_t)ctx->_extregs,
 				x86_cpu_features.extregs_align);
 	// Initialize extregs area: zero out, then save a valid layout to it.
 	memset((void *)ctx->extregs, 0, x86_cpu_features.extregs_size);

plat/common/sw_ctx.c

@@ -38,8 +38,8 @@
 #include <uk/plat/common/tls.h>
 #include <uk/plat/common/cpu.h>
 
-static void *sw_ctx_create(struct uk_alloc *allocator, unsigned long sp,
-				unsigned long tlsp);
+static size_t sw_ctx_size(void);
+static void  sw_ctx_init(void *ctx, unsigned long sp, unsigned long tlsp);
 static void  sw_ctx_start(void *ctx) __noreturn;
 static void  sw_ctx_switch(void *prevctx, void *nextctx);
 
@@ -49,27 +49,24 @@ static void  sw_ctx_switch(void *prevctx, void *nextctx);
  */
 extern void asm_thread_starter(void);
 
-static void *sw_ctx_create(struct uk_alloc *allocator, unsigned long sp,
-				unsigned long tlsp)
+static size_t sw_ctx_size(void)
 {
-	struct sw_ctx *ctx;
-
-	UK_ASSERT(allocator != NULL);
+	return sizeof(struct ukplat_ctx) + arch_extregs_size();
+}
 
-	ctx = arch_alloc_sw_ctx(allocator);
-	if (ctx == NULL) {
-		uk_pr_warn("Error allocating software context.");
-		return NULL;
-	}
+static void sw_ctx_init(void *ctx,
+			unsigned long sp, unsigned long tlsp)
+{
+	struct sw_ctx *sw_ctx = ctx;
 
-	ctx->sp = sp;
-	ctx->tlsp = tlsp;
-	ctx->ip = (unsigned long) asm_thread_starter;
-	arch_init_extregs(ctx);
+	UK_ASSERT(sw_ctx != NULL);
 
-	save_extregs(ctx);
+	sw_ctx->sp   = sp;
+	sw_ctx->tlsp = tlsp;
+	sw_ctx->ip   = (unsigned long) asm_thread_starter;
+	arch_init_extregs(sw_ctx);
 
-	return ctx;
+	save_extregs(sw_ctx);
 }
 
 extern void asm_ctx_start(unsigned long sp, unsigned long ip) __noreturn;
@@ -103,7 +100,8 @@ static void sw_ctx_switch(void *prevctx, void *nextctx)
 void sw_ctx_callbacks_init(struct ukplat_ctx_callbacks *ctx_cbs)
 {
 	UK_ASSERT(ctx_cbs != NULL);
-	ctx_cbs->create_cb = sw_ctx_create;
+	ctx_cbs->size_cb = sw_ctx_size;
+	ctx_cbs->init_cb = sw_ctx_init;
 	ctx_cbs->start_cb = sw_ctx_start;
 	ctx_cbs->switch_cb = sw_ctx_switch;
 }