vm: implement demand-paging via userspace services with vm-controller

vm/vm-object.c

@@ -1,6 +1,7 @@
 #include <kernel/printk.h>
 #include <kernel/sched.h>
 #include <kernel/util.h>
+#include <kernel/vm-controller.h>
 #include <kernel/vm-object.h>
 
 #define VM_OBJECT_CAST(p)                                                      \
@@ -40,15 +41,16 @@ static kern_status_t object_iterator_begin(
 
 	it->it_obj = obj;
 	it->it_alloc = alloc;
+	enum vm_object_flags flags = 0;
 
 	if (alloc) {
-		it->it_pg = vm_object_alloc_page(obj, 0, VM_PAGE_4K);
+		flags |= VMO_ALLOCATE_MISSING_PAGE;
+	}
 
-		if (!it->it_pg) {
-			return KERN_NO_MEMORY;
-		}
-	} else {
-		it->it_pg = vm_object_get_page(obj, 0);
+	it->it_pg = vm_object_get_page(obj, 0, flags, NULL);
+
+	if (alloc && !it->it_pg) {
+		return KERN_NO_MEMORY;
 	}
 
 	if (it->it_pg) {
@@ -83,17 +85,16 @@ static kern_status_t object_iterator_seek(
 		return KERN_OK;
 	}
 
-	if (it->it_alloc) {
-		it->it_pg = vm_object_alloc_page(
-			it->it_obj,
-			it->it_offset,
-			VM_PAGE_4K);
+	enum vm_object_flags flags = 0;
 
-		if (!it->it_pg) {
-			return KERN_NO_MEMORY;
-		}
-	} else {
-		it->it_pg = vm_object_get_page(it->it_obj, it->it_offset);
+	if (it->it_alloc) {
+		flags |= VMO_ALLOCATE_MISSING_PAGE;
+	}
+
+	it->it_pg = vm_object_get_page(it->it_obj, it->it_offset, flags, NULL);
+
+	if (it->it_alloc && !it->it_pg) {
+		return KERN_NO_MEMORY;
 	}
 
 	if (it->it_pg) {
@@ -248,36 +249,7 @@ extern struct vm_object *vm_object_create_in_place(
 	return vmo;
 }
 
-extern struct vm_page *vm_object_get_page(
-	const struct vm_object *vo,
-	off_t offset)
-{
-	struct btree_node *cur = vo->vo_pages.b_root;
-	while (cur) {
-		struct vm_page *page
-			= BTREE_CONTAINER(struct vm_page, p_bnode, cur);
-		struct btree_node *next = NULL;
-
-		off_t base = page->p_vmo_offset;
-		off_t limit = base + vm_page_get_size_bytes(page);
-		if (offset < base) {
-			next = btree_left(cur);
-		} else if (offset >= limit) {
-			next = btree_right(cur);
-		} else {
-			return page;
-		}
-
-		cur = next;
-	}
-
-	return NULL;
-}
-
-extern struct vm_page *vm_object_alloc_page(
-	struct vm_object *vo,
-	off_t offset,
-	enum vm_page_order size)
+static struct vm_page *alloc_page(struct vm_object *vo, off_t offset)
 {
 	struct vm_page *page = NULL;
 	struct btree_node *cur = vo->vo_pages.b_root;
@@ -340,6 +312,87 @@ extern struct vm_page *vm_object_alloc_page(
 	return NULL;
 }
 
+static struct vm_page *get_page(struct vm_object *vo, off_t offset)
+{
+	struct btree_node *cur = vo->vo_pages.b_root;
+	while (cur) {
+		struct vm_page *page
+			= BTREE_CONTAINER(struct vm_page, p_bnode, cur);
+		struct btree_node *next = NULL;
+
+		off_t base = page->p_vmo_offset;
+		off_t limit = base + vm_page_get_size_bytes(page);
+		if (offset < base) {
+			next = btree_left(cur);
+		} else if (offset >= limit) {
+			next = btree_right(cur);
+		} else {
+			return page;
+		}
+
+		cur = next;
+	}
+
+	return NULL;
+}
+
+static kern_status_t request_page(
+	struct vm_object *vo,
+	off_t offset,
+	unsigned long *irq_flags)
+{
+	struct vm_controller *ctrl = vo->vo_ctrl;
+	struct page_request req = {0};
+	req.req_status = PAGE_REQUEST_PENDING;
+	req.req_offset = offset;
+	req.req_length = vm_page_order_to_bytes(VM_PAGE_4K);
+	req.req_sender = current_thread();
+
+	object_ref(&vo->vo_base);
+	req.req_object = vo;
+
+	vm_object_unlock_irqrestore(vo, *irq_flags);
+	vm_controller_lock_irqsave(ctrl, irq_flags);
+	spin_lock(&req.req_lock);
+
+	kern_status_t status
+		= vm_controller_send_request(ctrl, &req, irq_flags);
+
+	spin_unlock(&req.req_lock);
+	vm_controller_unlock_irqrestore(ctrl, *irq_flags);
+	object_unref(&vo->vo_base);
+	vm_object_lock_irqsave(vo, irq_flags);
+
+	return status;
+}
+
+struct vm_page *vm_object_get_page(
+	struct vm_object *vo,
+	off_t offset,
+	enum vm_object_flags flags,
+	unsigned long *irq_flags)
+{
+	if (!vo->vo_ctrl && (flags & VMO_ALLOCATE_MISSING_PAGE)) {
+		return alloc_page(vo, offset);
+	}
+
+	struct vm_page *pg = get_page(vo, offset);
+	if (pg) {
+		return pg;
+	}
+
+	if (!vo->vo_ctrl) {
+		return NULL;
+	}
+
+	kern_status_t status = request_page(vo, offset, irq_flags);
+	if (status != KERN_OK) {
+		return NULL;
+	}
+
+	return get_page(vo, offset);
+}
+
 #if 0
 /* read data from a vm-object, where [offset, offset+count] is confined to
  * a single page */
@@ -800,7 +853,7 @@ kern_status_t vm_object_transfer(
 	size_t moved = 0;
 	for (size_t i = 0; i < count; i += VM_PAGE_SIZE) {
 		struct vm_page *src_pg
-			= vm_object_get_page(src, src_offset + i);
+			= vm_object_get_page(src, src_offset + i, 0, NULL);
 		if (!src_pg) {
 			continue;
 		}
@@ -808,7 +861,7 @@ kern_status_t vm_object_transfer(
 		btree_delete(&src->vo_pages, &src_pg->p_bnode);
 
 		struct vm_page *dst_pg
-			= vm_object_get_page(src, dst_offset + i);
+			= vm_object_get_page(src, dst_offset + i, 0, NULL);
 		if (dst_pg) {
 			vm_page_free(src_pg);
 			continue;