kernel: implement sending, receiving, and replying to message via port/channel

syscall/msg.c

@@ -62,14 +62,13 @@ kern_status_t sys_port_create(kern_handle_t *out)
 	kern_handle_t handle;
 	kern_status_t status
 		= task_open_handle(self, &port->p_base, 0, &handle);
+	task_unlock_irqrestore(self, irq_flags);
+
 	if (status != KERN_OK) {
-		task_unlock_irqrestore(self, irq_flags);
 		object_unref(&port->p_base);
 		return status;
 	}
 
-	task_unlock_irqrestore(self, irq_flags);
-
 	*out = handle;
 	return KERN_OK;
 }
@@ -98,6 +97,7 @@ kern_status_t sys_port_connect(
 	/* add a reference to the port object to make sure it isn't deleted
 	 * while we're using it */
 	object_ref(port_obj);
+	struct port *port = port_cast(port_obj);
 	task_unlock_irqrestore(self, flags);
 
 	struct task *remote_task = task_from_tid(task_id);
@@ -116,43 +116,255 @@ kern_status_t sys_port_connect(
 	object_ref(&remote->c_base);
 	task_unlock_irqrestore(remote_task, flags);
 
-	status = port_connect(port_cast(port_obj), remote);
+	port_lock_irqsave(port, &flags);
+	status = port_connect(port, remote);
+	port_unlock_irqrestore(port, flags);
 	object_unref(port_obj);
 	object_unref(&remote->c_base);
 
 	return KERN_OK;
 }
 
-kern_status_t sys_port_disconnect(kern_handle_t port)
+kern_status_t sys_port_disconnect(kern_handle_t port_handle)
 {
-	return KERN_UNIMPLEMENTED;
+	unsigned long flags;
+
+	struct task *self = current_task();
+	task_lock_irqsave(self, &flags);
+
+	struct object *port_obj = NULL;
+	handle_flags_t port_handle_flags = 0;
+	kern_status_t status = task_resolve_handle(
+		self,
+		port_handle,
+		&port_obj,
+		&port_handle_flags);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	/* add a reference to the port object to make sure it isn't deleted
+	 * while we're using it */
+	object_ref(port_obj);
+	task_unlock_irqrestore(self, flags);
+
+	struct port *port = port_cast(port_obj);
+	if (!port) {
+		object_unref(port_obj);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	object_unref(port_obj);
+	port_lock_irqsave(port, &flags);
+	status = port_disconnect(port);
+	port_unlock_irqrestore(port, flags);
+
+	return status;
+}
+
+static bool validate_msg(struct task *task, const struct msg *msg, bool rw)
+{
+	if (!validate_access_r(task, msg, sizeof *msg)) {
+		return false;
+	}
+
+	if (msg->msg_data_count
+	    && !validate_access_r(
+		    task,
+		    msg->msg_data,
+		    sizeof(struct iovec) * msg->msg_data_count)) {
+		return false;
+	}
+
+	if (msg->msg_handles_count
+	    && !validate_access_r(
+		    task,
+		    msg->msg_handles,
+		    sizeof(struct handle_list) * msg->msg_handles_count)) {
+		return false;
+	}
+
+	for (size_t i = 0; i < msg->msg_data_count; i++) {
+		bool ok = false;
+		const struct iovec *iov = &msg->msg_data[i];
+		if (rw) {
+			ok = validate_access_w(task, iov->io_base, iov->io_len);
+		} else {
+			ok = validate_access_r(task, iov->io_base, iov->io_len);
+		}
+
+		if (!ok) {
+			return false;
+		}
+	}
+
+	for (size_t i = 0; i < msg->msg_handles_count; i++) {
+		bool ok = false;
+		const struct handle_list *list = &msg->msg_handles[i];
+		if (rw) {
+			ok = validate_access_w(
+				task,
+				list->l_handles,
+				list->l_nr_handles * sizeof(kern_handle_t));
+		} else {
+			ok = validate_access_r(
+				task,
+				list->l_handles,
+				list->l_nr_handles * sizeof(kern_handle_t));
+		}
+
+		if (!ok) {
+			return false;
+		}
+	}
+
+	return true;
 }
 
 kern_status_t sys_msg_send(
-	kern_handle_t port,
-	msg_flags_t flags,
+	kern_handle_t port_handle,
+	msg_flags_t msg_flags,
 	const struct msg *req,
 	struct msg *resp)
 {
-	return KERN_UNIMPLEMENTED;
+	struct task *self = current_task();
+
+	if (!validate_msg(self, req, false)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	if (!validate_msg(self, resp, true)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	unsigned long flags;
+
+	task_lock_irqsave(self, &flags);
+
+	struct object *port_obj = NULL;
+	handle_flags_t port_handle_flags = 0;
+	kern_status_t status = task_resolve_handle(
+		self,
+		port_handle,
+		&port_obj,
+		&port_handle_flags);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	/* add a reference to the port object to make sure it isn't deleted
+	 * while we're using it */
+	object_ref(port_obj);
+	task_unlock_irqrestore(self, flags);
+
+	struct port *port = port_cast(port_obj);
+	if (!port) {
+		object_unref(port_obj);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	port_lock_irqsave(port, &flags);
+	status = port_send_msg(port, req, resp, &flags);
+	port_unlock_irqrestore(port, flags);
+	object_unref(port_obj);
+
+	return status;
 }
 
 kern_status_t sys_msg_recv(
-	kern_handle_t channel,
-	msg_flags_t flags,
+	kern_handle_t channel_handle,
+	msg_flags_t msg_flags,
 	msgid_t *out_id,
 	struct msg *out_msg)
 {
-	return KERN_UNIMPLEMENTED;
+	struct task *self = current_task();
+
+	if (!validate_access_w(self, out_id, sizeof *out_id)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	if (!validate_msg(self, out_msg, true)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	unsigned long flags;
+
+	task_lock_irqsave(self, &flags);
+
+	struct object *channel_obj = NULL;
+	handle_flags_t channel_handle_flags = 0;
+	kern_status_t status = task_resolve_handle(
+		self,
+		channel_handle,
+		&channel_obj,
+		&channel_handle_flags);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	/* add a reference to the port object to make sure it isn't deleted
+	 * while we're using it */
+	object_ref(channel_obj);
+	task_unlock_irqrestore(self, flags);
+
+	struct channel *channel = channel_cast(channel_obj);
+	if (!channel) {
+		object_unref(channel_obj);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	channel_lock_irqsave(channel, &flags);
+	status = channel_recv_msg(channel, out_msg, out_id, &flags);
+	channel_unlock_irqrestore(channel, flags);
+	object_unref(channel_obj);
+
+	return status;
 }
 
 kern_status_t sys_msg_reply(
-	kern_handle_t channel,
-	msg_flags_t flags,
+	kern_handle_t channel_handle,
+	msg_flags_t msg_flags,
 	msgid_t id,
 	const struct msg *reply)
 {
-	return KERN_UNIMPLEMENTED;
+	struct task *self = current_task();
+
+	if (!validate_msg(self, reply, false)) {
+		return KERN_MEMORY_FAULT;
+	}
+
+	unsigned long flags;
+
+	task_lock_irqsave(self, &flags);
+
+	struct object *channel_obj = NULL;
+	handle_flags_t channel_handle_flags = 0;
+	kern_status_t status = task_resolve_handle(
+		self,
+		channel_handle,
+		&channel_obj,
+		&channel_handle_flags);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	/* add a reference to the port object to make sure it isn't deleted
+	 * while we're using it */
+	object_ref(channel_obj);
+	task_unlock_irqrestore(self, flags);
+
+	struct channel *channel = channel_cast(channel_obj);
+	if (!channel) {
+		object_unref(channel_obj);
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	channel_lock_irqsave(channel, &flags);
+	status = channel_reply_msg(channel, id, reply, &flags);
+	channel_unlock_irqrestore(channel, flags);
+	object_unref(channel_obj);
+
+	return status;
 }
 
 kern_status_t sys_msg_read(