kernel: all string parameters now take a corresponding length parameter

init/main.c

@@ -104,7 +104,7 @@ void kernel_init(uintptr_t arg)
 	       bsp.bsp_trailer.bsp_exec_entry,
 	       bsp.bsp_vmo);
 
-	struct task *bootstrap_task = task_create(kernel_task(), "bootstrap");
+	struct task *bootstrap_task = task_create("bootstrap", 9);
 	tracek("created bootstrap task (pid=%u)", bootstrap_task->t_id);
 
 	bsp_launch_async(&bsp, bootstrap_task);

kernel/bsp.c

@@ -58,6 +58,7 @@ kern_status_t bsp_load(struct bsp *bsp, const struct boot_module *mod)
 
 	bsp->bsp_vmo = vm_object_create_in_place(
 		"bsp",
+		3,
 		mod->mod_base,
 		mod->mod_size,
 		VM_PROT_READ | VM_PROT_EXEC | VM_PROT_USER);
@@ -87,6 +88,7 @@ static kern_status_t map_executable(
 	status = vm_region_create(
 		task->t_address_space,
 		"exec",
+		4,
 		VM_REGION_ANY_OFFSET,
 		exec_size,
 		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXEC | VM_PROT_USER,
@@ -97,6 +99,7 @@ static kern_status_t map_executable(
 
 	struct vm_object *data = vm_object_create(
 		".data",
+		5,
 		bsp->bsp_trailer.bsp_data_size,
 		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER);
 	/* TODO copy .data from executable to memory */
@@ -160,6 +163,7 @@ kern_status_t bsp_launch_async(struct bsp *bsp, struct task *task)
 
 	struct vm_object *user_stack = vm_object_create(
 		"stack",
+		5,
 		BOOTSTRAP_STACK_SIZE,
 		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER);
 	if (!user_stack) {

sched/task.c

@@ -91,6 +91,7 @@ kern_status_t setup_kernel_task(void)
 	vm_region_create(
 		NULL,
 		"root",
+		4,
 		VM_KERNEL_BASE,
 		VM_KERNEL_LIMIT - VM_KERNEL_BASE,
 		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXEC | VM_PROT_SVR,
@@ -172,7 +173,7 @@ struct task *task_alloc(void)
 	return t;
 }
 
-struct task *task_create(struct task *parent, const char *name)
+struct task *task_create(const char *name, size_t name_len)
 {
 	struct task *task = task_alloc();
 	if (!task) {
@@ -190,25 +191,23 @@ struct task *task_create(struct task *parent, const char *name)
 	vm_region_create(
 		NULL,
 		"root",
+		4,
 		VM_USER_BASE,
 		VM_USER_LIMIT - VM_USER_BASE,
 		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXEC | VM_PROT_USER,
 		&task->t_address_space);
 
 	task->t_address_space->vr_pmap = pmap;
-	task->t_state = TASK_STOPPED;
+	task->t_state = TASK_RUNNING;
 	task->t_handles = handle_table_create();
 
 	if (name) {
-		strncpy(task->t_name, name, sizeof task->t_name);
+		name_len = MIN(name_len, sizeof task->t_name - 1);
-		task->t_name[sizeof task->t_name - 1] = '\0';
+		memcpy(task->t_name, name, name_len);
+		task->t_name[name_len] = '\0';
 	}
 
 	unsigned long flags;
-	task_lock_irqsave(parent, &flags);
-	queue_push_back(&parent->t_children, &task->t_child_entry);
-	task_unlock_irqrestore(parent, flags);
-
 	spin_lock_irqsave(&task_list_lock, &flags);
 	task_list_insert(&task_list, task);
 	spin_unlock_irqrestore(&task_list_lock, flags);

vm/vm-object.c

@@ -70,15 +70,16 @@ enum vm_page_order vm_object_global_page_order(void)
 
 struct vm_object *vm_object_create(
 	const char *name,
-	size_t len,
+	size_t name_len,
-	enum vm_prot prot)
+	size_t data_len,
+	vm_prot_t prot)
 {
 	size_t page_bytes = VM_PAGE_SIZE;
 	uintptr_t page_mask = page_bytes - 1;
 
-	if (len & page_mask) {
+	if (data_len & page_mask) {
-		len &= ~page_mask;
+		data_len &= ~page_mask;
-		len += page_bytes;
+		data_len += page_bytes;
 	}
 
 	struct object *obj = object_create(&vm_object_type);
@@ -88,12 +89,13 @@ struct vm_object *vm_object_create(
 
 	struct vm_object *out = VM_OBJECT_CAST(obj);
 
-	out->vo_size = len;
+	out->vo_size = data_len;
 	out->vo_prot = prot;
 
-	if (name) {
+	if (name && name_len) {
-		strncpy(out->vo_name, name, sizeof out->vo_name);
+		name_len = MIN(sizeof out->vo_name - 1, name_len);
-		out->vo_name[sizeof out->vo_name - 1] = '\0';
+		memcpy(out->vo_name, name, name_len);
+		out->vo_name[name_len] = '\0';
 	}
 
 	return out;
@@ -101,11 +103,13 @@ struct vm_object *vm_object_create(
 
 extern struct vm_object *vm_object_create_in_place(
 	const char *name,
+	size_t name_len,
 	phys_addr_t base,
-	size_t len,
+	size_t data_len,
-	enum vm_prot prot)
+	vm_prot_t prot)
 {
-	struct vm_object *vmo = vm_object_create(name, len, prot);
+	struct vm_object *vmo
+		= vm_object_create(name, name_len, data_len, prot);
 	if (!vmo) {
 		return NULL;
 	}

vm/vm-region.c

@@ -474,26 +474,36 @@ kern_status_t vm_region_type_init(void)
 	return object_type_register(&vm_region_type);
 }
 
+struct vm_region *vm_region_cast(struct object *obj)
+{
+	return VM_REGION_CAST(obj);
+}
+
 kern_status_t vm_region_create(
 	struct vm_region *parent,
 	const char *name,
+	size_t name_len,
 	off_t offset,
-	size_t len,
+	size_t region_len,
-	enum vm_prot prot,
+	vm_prot_t prot,
 	struct vm_region **out)
 {
-	if (!offset || !len) {
+	if (!offset || !region_len) {
 		return KERN_INVALID_ARGUMENT;
 	}
 
-	if (len & VM_PAGE_MASK) {
+	if (region_len & VM_PAGE_MASK) {
-		len &= ~VM_PAGE_MASK;
+		region_len &= ~VM_PAGE_MASK;
-		len += VM_PAGE_SIZE;
+		region_len += VM_PAGE_SIZE;
 	}
 
 	kern_status_t status = KERN_OK;
 	if (parent) {
-		status = region_validate_allocation(parent, prot, &offset, len);
+		status = region_validate_allocation(
+			parent,
+			prot,
+			&offset,
+			region_len);
 	}
 
 	if (status != KERN_OK) {
@@ -510,7 +520,13 @@ kern_status_t vm_region_create(
 	region->vr_prot = prot;
 	region->vr_entry.e_type = VM_REGION_ENTRY_REGION;
 	region->vr_entry.e_offset = offset;
-	region->vr_entry.e_size = len;
+	region->vr_entry.e_size = region_len;
+
+#ifdef TRACE
+	tracek("creating sub-region at [%llx-%llx]",
+	       offset,
+	       offset + region_len);
+#endif
 
 	if (parent) {
 		region->vr_entry.e_parent = &parent->vr_entry;
@@ -518,9 +534,10 @@ kern_status_t vm_region_create(
 		region_put_entry(parent, &region->vr_entry);
 	}
 
-	if (name) {
+	if (name && name_len) {
-		strncpy(region->vr_name, name, sizeof region->vr_name);
+		name_len = MIN(sizeof region->vr_name - 1, name_len);
-		region->vr_name[sizeof region->vr_name - 1] = '\0';
+		memcpy(region->vr_name, name, name_len);
+		region->vr_name[name_len] = '\0';
 	}
 
 	*out = region;