Finished adding untested bare functionality vfs

Finished adding untested shm syscalls.
Finished adding untested l4 send/recv helpers

Everything compiles. Now going to fix lots of bugs ;-)

tasks/blkdev0/include/blkdev.h

@@ -1,19 +1,27 @@
 #ifndef __BLKDEV_H__
 #define __BLKDEV_H__
 
+#include <l4lib/types.h>
+
 struct block_device;
 
 struct block_device_ops {
-	void (*open)(struct block_device *bdev);
-	void (*read)(unsigned long offset, int size, void *buf);
-	void (*write)(unsigned long offset, int size, void *buf);
-	void (*read_page)(unsigned long pfn, void *buf);
-	void (*write_page)(unsigned long pfn, void *buf);
+	int (*init)(struct block_device *bdev);
+	int (*open)(struct block_device *bdev);
+	int (*read)(struct block_device *bdev, unsigned long offset,
+		    int size, void *buf);
+	int (*write)(struct block_device *bdev, unsigned long offset,
+		     int size, void *buf);
+	int (*read_page)(struct block_device *bdev,
+			 unsigned long pfn, void *buf);
+	int (*write_page)(struct block_device *bdev,
+			  unsigned long pfn, void *buf);
 };
 
 struct block_device {
 	char *name;
-	unsigned long size;
+	void *private;	/* Low-level device specific data */
+	u64 size;
 	struct block_device_ops ops;
 };
 

tasks/blkdev0/include/ramdisk.h

@@ -1,6 +1,7 @@
 #ifndef __RAMDISK_H__
 #define __RAMDISK_H__
 
+extern struct block_device ramdisk[];
 extern struct block_device ramdisk[];
 
 #endif

tasks/blkdev0/main.c

@@ -1,10 +1,59 @@
-
+/*
+ * High-level block device handling.
+ *
+ * Copyright (C) 2007, 2008 Bahadir Balban
+ */
 #include <stdio.h>
 #include <blkdev.h>
 
+/*
+ * Handles block device requests from fs0 using a combination of
+ * server-specific and posix shm semantics
+ */
+void handle_block_device_request()
+{
+	u32 mr[MR_UNUSED_TOTAL];
+	l4id_t sender;
+	int err;
+	u32 tag;
+
+	printf("%s: Listening requests.\n", __TASKNAME__);
+
+	if ((err = l4_receive(L4_ANYTHREAD)) < 0) {
+		printf("%s: %s: IPC Error: %d. Quitting...\n", __TASKNAME__,
+		       __FUNCTION__, err);
+		BUG();
+	}
+
+	/* Read conventional ipc data */
+	tag = l4_get_tag();
+	sender = l4_get_sender();
+
+	/* Read mrs not used by syslib */
+	for (int i = 0; i < MR_UNUSED_TOTAL; i++)
+		mr[i] = read_mr(i);
+
+	switch(tag) {
+	case L4_IPC_TAG_WAIT:
+		printf("%s: Synced with waiting thread.\n", __TASKNAME__);
+		break;
+	case L4_IPC_TAG_BLOCK_OPEN:
+		sys_open(sender, (void *)mr[0], (int)mr[1], (u32)mr[2]);
+		break;
+	default:
+		printf("%s: Unrecognised ipc tag (%d)"
+		       "received. Ignoring.\n", __TASKNAME__, mr[MR_TAG]);
+	}
+}
+
 int main(void)
 {
+	/* Initialise the block devices */
 	init_blkdev();
+
+	while (1) {
+		handle_block_device_request();
+	}
 	return 0;
 }
 

tasks/blkdev0/src/init.c

@@ -6,5 +6,6 @@
 
 void init_blkdev(void)
 {
-	ramdisk.ops.open(&ramdisk);
+	ramdisk[0].ops.init(&ramdisk[0]);
+	ramdisk[1].ops.init(&ramdisk[1]);
 }

tasks/blkdev0/src/ramdisk.c

@@ -1,7 +1,7 @@
 /*
  * A basic ramdisk implementation.
  *
- * Copyright (C) 2007 Bahadir Balban
+ * Copyright (C) 2007, 2008 Bahadir Balban
  *
  * The ramdisk binary is embedded in the data section of the ramdisk device
  * executable. Read/writes simply occur to this area. The disk area could
@@ -22,45 +22,77 @@ extern char _end_ramdisk0[];
 extern char _start_ramdisk1[];
 extern char _end_ramdisk1[];
 
+struct ramdisk_data {
+	u64 base;
+	u64 end;
+};
+
+struct ramdisk_data rddata[2];
+
 __attribute__((section(".data.sfs"))) char sfsdisk[SZ_16MB];
 
-static unsigned long ramdisk_base[2];
-
-void ramdisk_open(struct block_device *ramdisk)
+int ramdisk_init(struct block_device *ramdisk)
 {
-	ramdisk_base = (unsigned long)_start_ramdisk;
-	ramdisk->size = (unsigned long)_end_ramdisk -
-			(unsigned long)_start_ramdisk;
+	struct ramdisk_data *rddata = ramdisk->private;
+
+	if (!strcmp("ramdisk0", ramdisk->name)) {
+		rddata->base = (u64)(unsigned long)_start_ramdisk0;
+		rddata->end = (u64)(unsigned long)_end_ramdisk0;
+		ramdisk->size = (u64)((unsigned long)_end_ramdisk0 -
+				      (unsigned long)_start_ramdisk0);
+	} else if (!strcmp("ramdisk1", ramdisk->name)) {
+		rddata->base = (u64)(unsigned long)_start_ramdisk1;
+		rddata->end = (u64)(unsigned long)_end_ramdisk1;
+		ramdisk->size = (u64)((unsigned long)_end_ramdisk1 -
+				      (unsigned long)_start_ramdisk1);
+	} else
+		return -1;
+
+	return 0;
 }
 
-void ramdisk_read(unsigned long offset, int size, void *buf)
+int ramdisk_open(struct block_device *ramdisk)
 {
-	void *src = (void *)(ramdisk_base + offset);
+	return 0;
+}
+
+int ramdisk_read(struct block_device *b, unsigned long offset, int size, void *buf)
+{
+	struct ramdisk_data *data = b->private;
+	void *src = (void *)(unsigned long)(data->base + offset);
 
 	memcpy(buf, src, size);
+	return 0;
 }
 
-void ramdisk_write(unsigned long offset, int size, void *buf)
+int ramdisk_write(struct block_device *b, unsigned long offset,
+		  int size, void *buf)
 {
-	void *dst = (void *)(ramdisk_base + offset);
+	struct ramdisk_data *data = b->private;
+	void *dst = (void *)(unsigned long)(data->base + offset);
 
 	memcpy(dst, buf, size);
+	return 0;
 }
 
-void ramdisk_readpage(unsigned long pfn, void *buf)
+int ramdisk_readpage(struct block_device *b, unsigned long pfn, void *buf)
 {
-	ramdisk_read(__pfn_to_addr(pfn), PAGE_SIZE, buf);
+	ramdisk_read(b, __pfn_to_addr(pfn), PAGE_SIZE, buf);
+	return 0;
 }
 
-void ramdisk_writepage(unsigned long pfn, void *buf)
+int ramdisk_writepage(struct block_device *b, unsigned long pfn, void *buf)
 {
-	ramdisk_write(__pfn_to_addr(pfn), PAGE_SIZE, buf);
+	ramdisk_write(b, __pfn_to_addr(pfn), PAGE_SIZE, buf);
+	return 0;
 }
 
 struct block_device ramdisk[2] = {
 	[0] = {
 		.name = "ramdisk0",
+		.private = &rddata[0],
 		.ops = {
+			.init = ramdisk_init,
 			.open = ramdisk_open,
 			.read = ramdisk_read,
 			.write = ramdisk_write,
@@ -70,7 +102,9 @@ struct block_device ramdisk[2] = {
 	},
 	[1] = {
 		.name = "ramdisk1",
+		.private = &rddata[1],
 		.ops = {
+			.init = ramdisk_init,
 			.open = ramdisk_open,
 			.read = ramdisk_read,
 			.write = ramdisk_write,