vm: replace vm-region with address-space

address-space is a non-recursive data structure, which contains a flat list of vm_areas representing
mapped vm-objects.

userspace programs can no longer create sub-address-spaces. instead, they can reserve portions of
the address space, and use that reserved space to create mappings.

syscall/address-space.c

@@ -0,0 +1,313 @@
+#include <kernel/address-space.h>
+#include <kernel/printk.h>
+#include <kernel/sched.h>
+#include <kernel/syscall.h>
+#include <kernel/vm-object.h>
+
+kern_status_t sys_address_space_read(
+	kern_handle_t region_handle,
+	void *dst,
+	virt_addr_t base,
+	size_t count,
+	size_t *nr_read)
+{
+	struct task *self = current_task();
+
+	if (!validate_access_w(self, dst, count)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	if (nr_read && !validate_access_w(self, nr_read, sizeof *nr_read)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	unsigned long flags;
+	task_lock_irqsave(self, &flags);
+
+	struct object *obj = NULL;
+	handle_flags_t handle_flags = 0;
+	kern_status_t status
+		= task_resolve_handle(self, region_handle, &obj, &handle_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	struct address_space *region = address_space_cast(obj);
+	if (!region) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	task_unlock_irqrestore(self, flags);
+
+	address_space_lock_irqsave(region, &flags);
+	status = address_space_memmove(
+		self->t_address_space,
+		(virt_addr_t)dst,
+		region,
+		base,
+		count,
+		nr_read);
+	address_space_unlock_irqrestore(region, flags);
+
+	object_unref(obj);
+
+	return status;
+}
+
+kern_status_t sys_address_space_write(
+	kern_handle_t region_handle,
+	const void *src,
+	virt_addr_t base,
+	size_t count,
+	size_t *nr_written)
+{
+	struct task *self = current_task();
+
+	if (!validate_access_r(self, src, count)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	if (nr_written
+	    && !validate_access_w(self, nr_written, sizeof *nr_written)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	unsigned long flags;
+	task_lock_irqsave(self, &flags);
+
+	struct object *obj = NULL;
+	handle_flags_t handle_flags = 0;
+	kern_status_t status
+		= task_resolve_handle(self, region_handle, &obj, &handle_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	struct address_space *region = address_space_cast(obj);
+	if (!region) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	task_unlock_irqrestore(self, flags);
+
+	address_space_lock_irqsave(region, &flags);
+	status = address_space_memmove(
+		region,
+		base,
+		self->t_address_space,
+		(virt_addr_t)src,
+		count,
+		nr_written);
+	address_space_unlock_irqrestore(region, flags);
+
+	object_unref(obj);
+
+	return status;
+}
+
+kern_status_t sys_address_space_map(
+	kern_handle_t region_handle,
+	virt_addr_t map_address,
+	kern_handle_t object_handle,
+	off_t object_offset,
+	size_t length,
+	vm_prot_t prot,
+	virt_addr_t *out_base_address)
+{
+	struct task *self = current_task();
+
+	if (out_base_address
+	    && !validate_access_r(
+		    self,
+		    out_base_address,
+		    sizeof *out_base_address)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	kern_status_t status = KERN_OK;
+	unsigned long flags;
+	task_lock_irqsave(self, &flags);
+
+	struct object *region_obj = NULL, *vmo_obj = NULL;
+	handle_flags_t region_flags = 0, vmo_flags = 0;
+	status = task_resolve_handle(
+		self,
+		region_handle,
+		&region_obj,
+		&region_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	status = task_resolve_handle(self, object_handle, &vmo_obj, &vmo_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	struct address_space *region = address_space_cast(region_obj);
+	if (!region) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	struct vm_object *vmo = vm_object_cast(vmo_obj);
+	if (!vmo) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	task_unlock_irqrestore(self, flags);
+	address_space_lock_irqsave(region, &flags);
+	/* address_space_map will take care of locking `vmo` */
+	status = address_space_map(
+		region,
+		map_address,
+		vmo,
+		object_offset,
+		length,
+		prot,
+		out_base_address);
+	address_space_unlock_irqrestore(region, flags);
+
+	object_unref(vmo_obj);
+	object_unref(region_obj);
+
+	return status;
+}
+
+kern_status_t sys_address_space_unmap(
+	kern_handle_t region_handle,
+	virt_addr_t base,
+	size_t length)
+{
+	struct task *self = current_task();
+
+	kern_status_t status = KERN_OK;
+	unsigned long flags;
+	task_lock_irqsave(self, &flags);
+
+	struct object *region_obj = NULL;
+	handle_flags_t region_flags = 0;
+	status = task_resolve_handle(
+		self,
+		region_handle,
+		&region_obj,
+		&region_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	struct address_space *region = address_space_cast(region_obj);
+	if (!region) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	task_unlock_irqrestore(self, flags);
+
+	status = address_space_unmap(region, base, length);
+
+	object_unref(region_obj);
+
+	return status;
+}
+
+kern_status_t sys_address_space_reserve(
+	kern_handle_t region_handle,
+	virt_addr_t map_address,
+	size_t length,
+	virt_addr_t *out_base_address)
+{
+	struct task *self = current_task();
+
+	if (out_base_address
+	    && !validate_access_r(
+		    self,
+		    out_base_address,
+		    sizeof *out_base_address)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	kern_status_t status = KERN_OK;
+	unsigned long flags;
+	task_lock_irqsave(self, &flags);
+
+	struct object *region_obj = NULL;
+	handle_flags_t region_flags = 0;
+	status = task_resolve_handle(
+		self,
+		region_handle,
+		&region_obj,
+		&region_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	struct address_space *region = address_space_cast(region_obj);
+	if (!region) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	task_unlock_irqrestore(self, flags);
+
+	address_space_lock_irqsave(region, &flags);
+	status = address_space_reserve(
+		region,
+		map_address,
+		length,
+		out_base_address);
+	address_space_unlock_irqrestore(region, flags);
+
+	object_unref(region_obj);
+
+	return status;
+}
+
+kern_status_t sys_address_space_release(
+	kern_handle_t region_handle,
+	virt_addr_t base,
+	size_t length)
+{
+	struct task *self = current_task();
+
+	kern_status_t status = KERN_OK;
+	unsigned long flags;
+	task_lock_irqsave(self, &flags);
+
+	struct object *region_obj = NULL;
+	handle_flags_t region_flags = 0;
+	status = task_resolve_handle(
+		self,
+		region_handle,
+		&region_obj,
+		&region_flags);
+	if (status != KERN_OK) {
+		task_unlock_irqrestore(self, flags);
+		return status;
+	}
+
+	struct address_space *region = address_space_cast(region_obj);
+	if (!region) {
+		task_unlock_irqrestore(self, flags);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	task_unlock_irqrestore(self, flags);
+
+	address_space_lock_irqsave(region, &flags);
+	status = address_space_unmap(region, base, length);
+	address_space_unlock_irqrestore(region, flags);
+
+	object_unref(region_obj);
+
+	return status;
+}