--- a/Makefile	Tue Dec 29 20:04:16 2009 -0500
+++ b/Makefile	Fri Jun 18 20:41:48 2010 -0400
@@ -8,7 +8,7 @@
 
 all:
 	make -C lib
-	make -C sys
+	make -C cp
 	make -C nss/8ball
 	make -C loader
 
@@ -17,7 +17,7 @@
 
 clean:
 	make -C lib clean
-	make -C sys clean
+	make -C cp clean
 	make -C nss/8ball clean
 	make -C loader clean
 	make -C doc/manual clean

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/.gitignore	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,9 @@
+*.o
+*.rto
+ipl/ipl_rdr_ccws.S
+ipl/ipl_tape.S
+shell/directory_structs.c
+hvf
+loader_rdr.bin
+loader_tape.bin
+cscope.out

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/Makefile	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,75 @@
+#
+# HVF: Hobbyist Virtualization Facility
+#
+# (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+#
+# This file is released under the GPLv2.  See the COPYING file for more
+# details.
+#
+
+VERSION=0.16-rc2
+
+AS=$(CROSS_COMPILE)as
+CC=$(CROSS_COMPILE)gcc
+LD=$(CROSS_COMPILE)ld
+OBJCOPY=$(CROSS_COMPILE)objcopy
+
+# By default, be terse
+V=0
+
+DISPLAYVERSION=$(shell ./scripts/extract-version.sh)
+
+MAKEFLAGS += -rR --no-print-directory
+CFLAGS=-DVERSION=\"$(DISPLAYVERSION)\" -g -fno-strict-aliasing -fno-builtin -nostdlib -Wall -m64 -I include/ -I ../include/ -O2 -include ../include/types.h
+NUCLEUSCFLAGS=-include include/nucleus.h
+LDFLAGS=-m elf64_s390
+
+LIBS=clock digest string
+
+export AS CC LD OBJCOPY
+export MAKEFLAGS CFLAGS NUCLEUSCFLAGS LDFLAGS
+
+TOP_DIRS=nucleus/ mm/ fs/ drivers/ shell/
+
+.PHONY: all build clean mrproper cleanup hvfclean tags
+.PHONY: $(TOP_DIRS)
+
+include scripts/Makefile.commands
+
+all: build hvf
+	@echo "Image is `stat -c %s hvf` bytes"
+
+hvf: $(patsubst %/,%/built-in.o,$(TOP_DIRS))
+	$(call link-hvf,$^ $(patsubst %,../lib/%.a,$(LIBS)),$@)
+
+docs:
+	./scripts/gen-docs.sh
+
+clean:
+	@$(MAKE) DIR=nucleus/ cleanup V=$V
+	@$(MAKE) DIR=mm/ cleanup V=$V
+	@$(MAKE) DIR=fs/ cleanup V=$V
+	@$(MAKE) DIR=drivers/ cleanup V=$V
+	@$(MAKE) DIR=shell/ cleanup V=$V
+	$(call clean,hvf)
+	$(call clean,shell/directory_structs.c)
+	$(call rclean,doc/commands)
+
+mrproper: clean
+	$(call clean,cscope.out ctags)
+
+cleanup:
+	$(call clean,$(DIR)*.o)
+
+build: $(TOP_DIRS)
+
+$(TOP_DIRS): %/:
+	@$(MAKE) -f scripts/Makefile.build DIR=$@ V=$V
+
+tags:
+	$(call cscope)
+
+#
+# Include Makefiles from all the top level directories
+#
+include $(patsubst %/,%/Makefile,$(TOP_DIRS))

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/doc/.gitignore	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,1 @@
+commands

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/doc/PSA.txt	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,8 @@
+Aside from the architecture defined storage locations in the PSA, HVF uses
+the following addresses for special reasons:
+
+hex	dec	length	reason
+
+ 200	 512	128	interrupt handler GPR storage
+ 280	 640	16	PSW temporary storage
+ 290	 656	8	current pointer

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/doc/ipl.txt	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,94 @@
+This file attempts to describe what happens during IPL.
+
+NOTE: At the time, only IPL from tape and card reader is supported.
+
+1) system reads 24 bytes from the device 
+
+   a) bytes   0-7: new PSW, no interrupts, start address 0x800000 (8MB)
+
+   IPL from tape:
+
+      b) bytes  8-15: CCW to rewind the tape to previous TM
+
+      c) bytes 16-23: CCW to read the entire loader to 0x800000 (8 MB)
+
+   IPL from card reader:
+
+      b) bytes  8-15: CCW to read 80 bytes (containing up to 10 CCWs) to
+         0x18
+
+      c) bytes 16-23: CCW to read 24 bytes (containing up to 3 CCWs) to 0x68
+
+      Command chaining starts reading CCWs from addres 0x18 on. These read
+      the loader to 0x800000 (8 MB)
+
+2) arch mode is changed to z/Arch (see ipl/setmode.S)
+
+3) temporary stack is set up (R15 being the pointer) (see ipl/setmode.S)
+
+4) loader begins to execute: function load_nucleus (see ipl/loader.c)
+
+   NOTE: loader.c use static inlines extensively, and thefore stack usage is
+   minimal
+
+   a) If the IPL was from a tape, a CCW is issues to seek to the next TM
+
+   b) nucleus is read from tape to 0x400000 (4 MB)
+
+      NOTE: the data at 4MB just read is a 64-bit s390 ELF binary with Linux
+      ABI bits
+
+      i)   addition CCW address is set in the ORB
+
+      ii)  __readnucleus() is called; this function is implemented in
+           assembly (see ipl/loader_asm.S)
+
+      iii) IO interrupt handler is set up (implemented in asm, see
+           ipl/loader_asm.S)
+
+      iv)  ORB is sent to the subchannel
+
+      v)   interrupts are enabled
+
+      vi)  a new PSW with wait state bit set is loaded
+
+      vii) on IO interrupt
+
+           1) TSCH is issued to fill in a IRB
+
+           2) magic value (ORB int param) is checked
+
+	   3) Device End flag is checked in the IRB
+
+	      NOTE: more checks should be performed here
+
+	   4) If the device end flag is set, return to code that set up the
+              interrupt handler
+
+	   5) otherwise, load up the old IO PSW (the one with the wait
+              state)
+
+      viii)return to caller (back to ipl/loader.c)
+
+   c) verify ELF header magic number, machine, type, etc. values
+
+   d) traverse the section headers & copy data to final destination
+
+      i)   if the section type is PROGBITS (data stored in the ELF), copy
+           the data from it's temporary location to the desired location
+	   (destination, offset within file, and length are all stored in
+	   the section header) - this takes care of .text, .data, and
+	   .rodata sections
+
+      ii)  if the section type is NOBITS (uninitialized storage, e.g.,
+           .bss), do nothing, just assume that the location is a valid
+	   location in memory
+
+      iii) skip any other section types
+
+      NOTE: SYMTAB and STRTAB section types should be copied to a useful
+      location to allow for symbols to be looked up during nucleus execution
+
+   e) jump to the entry point as indicated by the ELF header
+
+At this point, the nucleus is executing.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/doc/memory.txt	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,62 @@
+Physical locations:
+
+-------------------  (2^64)-1  --
+|                 |              \
+|                 |               |
+         .                        |
+         .                        \
+         .                         >    Generic pages
+         .                        /
+         .                        |
+|                 |               |
+|                 |              /
+|-----------------|  f(memsize)--
+|                 |              \
+|                 |               |
+         .                        \
+         .                         >    struct page array (see below)
+         .                        /
+|                 |               |
+|                 |              /
+|-----------------|  4M        --
+|                 |              \
+|                 |               |
+         .                        \
+         .                         >    OS .text, .data, .rodata, .bss
+         .                        /
+|                 |               |
+|                 |              /
+|-----------------|  1M        --
+|                 |              \
+|                 |               |
+         .                        |
+         .                        |
+         .                        \
+|                 |                >    PSA for each CPU
+|                 |               /
+|-----------------|  8k           |
+|                 |               |
+|       PSA       |               |
+|                 |              /
+-------------------  0         --
+
+
+0 - 1MB:
+	Divided into up to 128 8KB chunks; nth chunk is nth CPU's PSA
+	(mapping done via the prefix register).
+
+1MB - 4MB:
+	OS .text
+	OS .data
+	OS .rodata
+	OS .bss
+
+4MB - (4MB + roundup((memsize >> PAGE_SIZE) * sizeof(struct page))):
+	This is an array of struct page entries for each page in the system.
+	The size varies based on the amount of memory installed.
+
+?? - (2^64)-1:
+	Generic pages; used for nucleus & process data
+
+	These pages are managed by the buddy allocator.
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/drivers/3215.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,28 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <device.h>
+#include <console.h>
+#include <list.h>
+#include <sched.h>
+#include <directory.h>
+
+static struct device_type d3215 = {
+	.types		= LIST_HEAD_INIT(d3215.types),
+	.reg		= NULL,
+	.interrupt	= NULL,
+	.enable		= console_enable,
+	.snprintf	= NULL,
+	.type		= 0x3215,
+	.model		= 0,
+};
+
+int register_driver_3215(void)
+{
+	return register_device_type(&d3215);
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/drivers/Makefile	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,1 @@
+objs-drivers := device.o console.o 3215.o dasd.o vdevice.o

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/drivers/console.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,394 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <console.h>
+#include <slab.h>
+#include <sched.h>
+#include <directory.h>
+#include <splash.h>
+#include <vsprintf.h>
+
+/*
+ * List of all consoles on the system
+ */
+static LIST_HEAD(consoles);
+static spinlock_t consoles_lock = SPIN_LOCK_UNLOCKED;
+
+static int read_io_int_handler(struct device *dev, struct io_op *ioop, struct irb *irb)
+{
+	struct console_line *cline;
+	struct ccw *ccw;
+	void *ptr;
+
+	/* Device End is set, we're done */
+	if (!(irb->scsw.dev_status & 0x04)) {
+		ioop->err = -EAGAIN;
+		return 0;
+	}
+
+	ccw = (struct ccw*) (u64) ioop->orb.addr;
+	ptr = (void*) (u64) ccw->addr;
+	cline = container_of(ptr, struct console_line, buf);
+
+	cline->len = strnlen((char*) cline->buf, CON_MAX_LINE_LEN-1);
+	cline->state = CON_STATE_IO;
+
+	ioop->err = 0;
+	return 0;
+}
+
+static void do_issue_read(struct console *con, struct io_op *ioop, struct ccw *ccws)
+{
+	struct console_line *cline;
+	int found;
+
+	found = 0;
+
+	atomic_dec(&con->dev->attention);
+
+	spin_lock(&con->lock);
+	list_for_each_entry(cline, &con->read_lines, lines) {
+		if (cline->state != CON_STATE_FREE)
+			continue;
+
+		cline->state = CON_STATE_PENDING;
+		found = 1;
+		break;
+	}
+
+	if (!found) {
+		/*
+		 * No unused console lines, time to allocate a new one
+		 */
+		cline = malloc(CON_LINE_ALLOC_SIZE, ZONE_NORMAL);
+		BUG_ON(!cline);
+
+		cline->state = CON_STATE_PENDING;
+		list_add_tail(&cline->lines, &con->read_lines);
+	}
+	spin_unlock(&con->lock);
+
+	/* clear the buffer to allow strlen on the result */
+	memset(cline->buf, 0, CON_MAX_LINE_LEN);
+
+	memset(ccws, 0, sizeof(struct ccw));
+
+	ccws[0].addr  = ADDR31(cline->buf);
+	ccws[0].count = CON_MAX_LINE_LEN - 1;
+	ccws[0].cmd   = 0x0a;
+	ccws[0].flags = CCW_FLAG_SLI;
+
+	memset(&ioop->orb, 0, sizeof(struct orb));
+	ioop->orb.lpm  = 0xff;
+	ioop->orb.addr = ADDR31(ccws);
+	ioop->orb.f    = 1;
+
+	ioop->handler = read_io_int_handler;
+	ioop->dtor = NULL;
+
+	submit_io(con->dev, ioop, CAN_SLEEP);
+}
+
+/**
+ * console_flusher - iterates over a console's buffers and initiates the IO
+ */
+static int console_flusher(void *data)
+{
+	struct console *con = data;
+	struct console_line *cline;
+	int free_count;
+	int ccw_count;
+
+	/* needed for the IO */
+	struct io_op ioop;
+	struct ccw ccws[CON_MAX_FLUSH_LINES];
+
+	for(;;) {
+		if (atomic_read(&con->dev->attention))
+			do_issue_read(con, &ioop, ccws);
+
+		spin_lock(&con->lock);
+
+		/*
+		 * free all the lines we just finished the IO for
+		 */
+		free_count = 0;
+		list_for_each_entry(cline, &con->write_lines, lines) {
+			if (cline->state != CON_STATE_IO)
+				continue;
+
+			cline->state = CON_STATE_FREE;
+			free_count++;
+
+			if (free_count > CON_MAX_FREE_LINES) {
+				list_del(&cline->lines);
+				free(cline);
+			}
+		}
+
+		/*
+		 * find at most CON_MAX_FLUSH_LINES of CON_STATE_PENDING
+		 * lines and shove necessary information into the right
+		 * CCW
+		 */
+		ccw_count = 0;
+		list_for_each_entry(cline, &con->write_lines, lines) {
+			if (ccw_count >= CON_MAX_FLUSH_LINES)
+				break;
+
+			if (cline->state != CON_STATE_PENDING)
+				continue;
+
+			cline->state = CON_STATE_IO;
+
+			ccws[ccw_count].addr = ADDR31(cline->buf);
+			ccws[ccw_count].count = cline->len;
+			ccws[ccw_count].cmd   = 0x01; /* write */
+			ccws[ccw_count].flags = CCW_FLAG_CC | CCW_FLAG_SLI;
+
+			ccw_count++;
+		}
+
+		/*
+		 * We don't need the lock anymore
+		 */
+		spin_unlock(&con->lock);
+
+		/*
+		 * Anything to do?
+		 */
+		if (!ccw_count) {
+			schedule();
+			continue;
+		}
+
+		/*
+		 * Clear Command-Chaining on the last CCW
+		 */
+		ccws[ccw_count-1].flags &= ~CCW_FLAG_CC;
+
+		/*
+		 * Now, set up the ORB and CCW
+		 */
+		memset(&ioop.orb, 0, sizeof(struct orb));
+		ioop.orb.lpm = 0xff;
+		ioop.orb.addr = ADDR31(ccws);
+		ioop.orb.f = 1;		/* format 1 CCW */
+
+		/*
+		 * Set up the operation handler pointers, and start the IO
+		 */
+		ioop.handler = NULL;
+		ioop.dtor = NULL;
+
+		submit_io(con->dev, &ioop, CAN_SLEEP);
+	}
+
+	return 0;
+}
+
+/**
+ * register_console - generic device registration callback
+ * @dev:	console device to register
+ */
+static int register_console(struct device *dev)
+{
+	struct console *con;
+	struct console_line *cline;
+
+	dev_get(dev);
+
+	con = malloc(sizeof(struct console), ZONE_NORMAL);
+	BUG_ON(!con);
+
+	con->sys    = NULL;
+	con->dev    = dev;
+	con->lock   = SPIN_LOCK_UNLOCKED;
+	INIT_LIST_HEAD(&con->write_lines);
+	INIT_LIST_HEAD(&con->read_lines);
+
+	/*
+	 * alloc one read-line
+	 */
+	cline = malloc(CON_LINE_ALLOC_SIZE, ZONE_NORMAL);
+	BUG_ON(!cline);
+	cline->state = CON_STATE_FREE;
+	list_add(&cline->lines, &con->read_lines);
+
+	spin_lock(&consoles_lock);
+	list_add_tail(&con->consoles, &consoles);
+	spin_unlock(&consoles_lock);
+
+	return 0;
+}
+
+static void print_splash(struct console *con)
+{
+	int i;
+
+	for(i = 0; splash[i]; i++)
+		con_printf(con, splash[i]);
+
+	con_printf(con, "HVF VERSION " VERSION "\n\n");
+}
+
+struct console* start_oper_console(void)
+{
+	struct device *dev;
+
+	/*
+	 * We only start the operator console
+	 */
+
+	dev = find_device_by_ccuu(OPER_CONSOLE_CCUU);
+	BUG_ON(IS_ERR(dev));
+
+	return console_enable(dev);
+}
+
+void* console_enable(struct device *dev)
+{
+	char name[TASK_NAME_LEN+1];
+	struct console *con;
+
+	con = find_console(dev);
+	if (!IS_ERR(con))
+		return con;
+
+	if (register_console(dev))
+		return ERR_PTR(-ENOMEM);
+
+	/* try again, this time, we should always find it! */
+	con = find_console(dev);
+	if (IS_ERR(con))
+		return con;
+
+	atomic_inc(&con->dev->in_use);
+
+	snprintf(name, TASK_NAME_LEN, "%05X-conflsh", con->dev->sch);
+
+	create_task(name, console_flusher, con);
+
+	print_splash(con);
+
+	return con;
+}
+
+int con_read_pending(struct console *con)
+{
+	struct console_line *cline;
+	int ret = 0;
+
+	spin_lock(&con->lock);
+
+	list_for_each_entry(cline, &con->read_lines, lines) {
+		if (cline->state == CON_STATE_IO) {
+			ret = 1;
+			break;
+		}
+	}
+
+	spin_unlock(&con->lock);
+
+	return ret;
+}
+
+int con_read(struct console *con, u8 *buf, int size)
+{
+	struct console_line *cline;
+	int len;
+
+	spin_lock(&con->lock);
+
+	list_for_each_entry(cline, &con->read_lines, lines) {
+		if (cline->state == CON_STATE_IO)
+			goto found;
+	}
+
+	spin_unlock(&con->lock);
+
+	return -1;
+
+found:
+	len = (size-1 < cline->len) ? size-1 : cline->len;
+
+	memcpy(buf, cline->buf, len);
+	buf[len] = '\0';
+
+	cline->state = CON_STATE_FREE;
+
+	spin_unlock(&con->lock);
+
+	return len;
+}
+
+int con_write(struct console *con, u8 *buf, int len)
+{
+	int bytes = 0;
+	struct console_line *cline;
+
+	spin_lock(&con->lock);
+
+	list_for_each_entry(cline, &con->write_lines, lines) {
+		if (cline->state == CON_STATE_FREE)
+			goto found;
+	}
+
+	/* None found, can we allocate a new one? */
+	cline = malloc(CON_LINE_ALLOC_SIZE, ZONE_NORMAL);
+	if (!cline)
+		goto abort;
+
+	list_add_tail(&cline->lines, &con->write_lines);
+
+found:
+	cline->state = CON_STATE_PENDING;
+
+	cline->len = (len < CON_MAX_LINE_LEN) ?  len : CON_MAX_LINE_LEN;
+	memcpy(cline->buf, buf, cline->len);
+
+	/*
+	 * All done here. The async thread will pick up the line of text,
+	 * and issue the IO.
+	 */
+
+abort:
+	spin_unlock(&con->lock);
+
+	return bytes;
+}
+
+void for_each_console(void (*f)(struct console *con))
+{
+	struct console *con;
+
+	if (!f)
+		return;
+
+	spin_lock(&consoles_lock);
+	list_for_each_entry(con, &consoles, consoles)
+		f(con);
+	spin_unlock(&consoles_lock);
+}
+
+struct console* find_console(struct device *dev)
+{
+	struct console *con;
+
+	if (!dev)
+		return ERR_PTR(-ENOENT);
+
+	spin_lock(&consoles_lock);
+	list_for_each_entry(con, &consoles, consoles) {
+		if (con->dev == dev)
+			goto found;
+	}
+	con = ERR_PTR(-ENOENT);
+found:
+	spin_unlock(&consoles_lock);
+	return con;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/drivers/dasd.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,283 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <device.h>
+#include <console.h>
+#include <list.h>
+#include <io.h>
+#include <sched.h>
+#include <vsprintf.h>
+
+static int d3390_snprintf(struct device *dev, char* buf, int len)
+{
+	return snprintf(buf, len, "%10d CYL ", dev->eckd.cyls);
+}
+
+static inline unsigned int ceil_quot(unsigned int d1, unsigned int d2)
+{
+        return (d1 + (d2 - 1)) / d2;
+}
+
+static inline int d3390_recs_per_track(int kl, int dl)
+{
+	int dn, kn;
+
+	dn = ceil_quot(dl + 6, 232) + 1;
+	if (kl) {
+		kn = ceil_quot(kl + 6, 232) + 1;
+		return 1729 / (10 + 9 + ceil_quot(kl + 6 * kn, 34) +
+			       9 + ceil_quot(dl + 6 * dn, 34));
+	} else
+		return 1729 / (10 + 9 + ceil_quot(dl + 6 * dn, 34));
+}
+
+static int d3390_reg(struct device *dev)
+{
+	struct io_op ioop;
+	struct ccw ccw;
+	int ret;
+	u8 buf[64];
+
+	switch(dev->model) {
+		case 0x02: /* 3390, 3390-1 */
+		case 0x06: /* 3390-2 */
+		case 0x0a: /* 3390-3 */
+		case 0x0c: /* 3390-9, 3390-27, 3390-J, 3390-54, 3390-JJ */
+			break;
+		default:
+			return -ENOENT;
+	}
+
+	/*
+	 * Set up IO op for Read Device Characteristics
+	 */
+	ioop.handler = NULL;
+	ioop.dtor = NULL;
+
+	memset(&ioop.orb, 0, sizeof(struct orb));
+	ioop.orb.lpm = 0xff;
+	ioop.orb.addr = ADDR31(&ccw);
+	ioop.orb.f = 1;
+
+	memset(&ccw, 0, sizeof(struct ccw));
+	ccw.cmd = 0x64; /* RDC */
+	ccw.flags = CCW_FLAG_SLI;
+	ccw.count = 64;
+	ccw.addr = ADDR31(buf);
+
+	/*
+	 * issue RDC
+	 */
+	ret = submit_io(dev, &ioop, CAN_LOOP);
+	if (ret)
+		return ret;
+
+	dev->eckd.cyls    = (buf[12] << 8) |
+		buf[13];
+	dev->eckd.tracks  = (buf[14] << 8) |
+		buf[15];
+	dev->eckd.recs    = d3390_recs_per_track(0, 4096);
+	dev->eckd.sectors = buf[16];
+	dev->eckd.len     = (buf[18] << 8) |
+		buf[19];
+
+	dev->eckd.formula = buf[22];
+	if (dev->eckd.formula == 1) {
+		dev->eckd.f1 = buf[23];
+		dev->eckd.f2 = (buf[24] << 8) |
+			buf[25];
+		dev->eckd.f3 = (buf[26] << 8) |
+			buf[27];
+		dev->eckd.f4 = 0;
+		dev->eckd.f5 = 0;
+	} else if (dev->eckd.formula == 2) {
+		dev->eckd.f1 = buf[23];
+		dev->eckd.f2 = buf[24];
+		dev->eckd.f3 = buf[25];
+		dev->eckd.f4 = buf[26];
+		dev->eckd.f5 = buf[27];
+	} else
+		return -EINVAL;
+
+	return 0;
+}
+
+static int d3390_read(struct device *dev, u8 *buf, int lba)
+{
+	struct io_op ioop;
+	struct ccw ccw[4];
+	u8 seek_data[6];
+	u8 search_data[5];
+	int ret;
+
+	u16 cc, hh, r;
+	int rpt = dev->eckd.recs;
+	int rpc = dev->eckd.tracks * rpt;
+
+	if (lba < 1)
+		return -EINVAL;
+
+	lba--;
+	cc = lba / rpc;
+	hh = (lba % rpc) / rpt;
+	r = (lba % rpc) % rpt;
+	r++;
+
+	/*
+	 * Set up IO op
+	 */
+	ioop.handler = NULL;
+	ioop.dtor = NULL;
+
+	memset(&ioop.orb, 0, sizeof(struct orb));
+	ioop.orb.lpm = 0xff;
+	ioop.orb.addr = ADDR31(ccw);
+	ioop.orb.f = 1;
+
+	memset(ccw, 0, sizeof(ccw));
+
+	/* SEEK */
+	ccw[0].cmd = 0x07;
+	ccw[0].flags = CCW_FLAG_CC | CCW_FLAG_SLI;
+	ccw[0].count = 6;
+	ccw[0].addr = ADDR31(seek_data);
+
+	seek_data[0] = 0;		/* zero */
+	seek_data[1] = 0;		/* zero */
+	seek_data[2] = cc >> 8;		/* Cc */
+	seek_data[3] = cc & 0xff;	/* cC */
+	seek_data[4] = hh >> 8;		/* Hh */
+	seek_data[5] = hh & 0xff;	/* hH */
+
+	/* SEARCH */
+	ccw[1].cmd = 0x31;
+	ccw[1].flags = CCW_FLAG_CC | CCW_FLAG_SLI;
+	ccw[1].count = 5;
+	ccw[1].addr = ADDR31(search_data);
+
+	search_data[0] = cc >> 8;
+	search_data[1] = cc & 0xff;
+	search_data[2] = hh >> 8;
+	search_data[3] = hh & 0xff;
+	search_data[4] = r;
+
+	/* TIC */
+	ccw[2].cmd = 0x08;
+	ccw[2].flags = 0;
+	ccw[2].count = 0;
+	ccw[2].addr = ADDR31(&ccw[1]);
+
+	/* READ DATA */
+	ccw[3].cmd = 0x86;
+	ccw[3].flags = 0;
+	ccw[3].count = 4096;
+	ccw[3].addr = ADDR31(buf);
+
+	/*
+	 * issue IO
+	 */
+	ret = submit_io(dev, &ioop, CAN_SLEEP);
+	return ret;
+}
+
+static struct device_type d3390 = {
+	.types		= LIST_HEAD_INIT(d3390.types),
+	.reg		= d3390_reg,
+	.interrupt	= NULL,
+	.enable		= NULL,
+	.snprintf	= d3390_snprintf,
+
+	.read		= d3390_read,
+
+	.type		= 0x3390,
+	.all_models	= 1,
+};
+
+/******************************************************************************/
+
+static int d9336_snprintf(struct device *dev, char* buf, int len)
+{
+	return snprintf(buf, len, "%10d BLK ", dev->fba.blks);
+}
+
+static int d9336_reg(struct device *dev)
+{
+	struct io_op ioop;
+	struct ccw ccw;
+	int ret;
+	u8 buf[64];
+
+	switch(dev->model) {
+		case 0x00: /* 9336-10 */
+		case 0x10: /* 9336-20 */
+			break;
+		default:
+			return -ENOENT;
+	}
+
+	/*
+	 * Set up IO op for Read Device Characteristics
+	 */
+	ioop.handler = NULL;
+	ioop.dtor = NULL;
+
+	memset(&ioop.orb, 0, sizeof(struct orb));
+	ioop.orb.lpm = 0xff;
+	ioop.orb.addr = ADDR31(&ccw);
+	ioop.orb.f = 1;
+
+	memset(&ccw, 0, sizeof(struct ccw));
+	ccw.cmd = 0x64; /* RDC */
+	ccw.flags = CCW_FLAG_SLI;
+	ccw.count = 64;
+	ccw.addr = ADDR31(buf);
+
+	/*
+	 * issue RDC
+	 */
+	ret = submit_io(dev, &ioop, CAN_LOOP);
+	if (ret)
+		return ret;
+
+	dev->fba.blk_size = (buf[4] << 8) | buf[5];
+	dev->fba.bpg = (buf[6] << 24)  |
+		(buf[7] << 16)  |
+		(buf[8] << 8)   |
+		buf[9];
+	dev->fba.bpp = (buf[10] << 24) |
+		(buf[11] << 16) |
+		(buf[12] << 8)  |
+		buf[13];
+	dev->fba.blks= (buf[14] << 24) |
+		(buf[15] << 16) |
+		(buf[16] << 8)  |
+		buf[17];
+
+	return 0;
+}
+
+static struct device_type d9336 = {
+	.types		= LIST_HEAD_INIT(d9336.types),
+	.reg		= d9336_reg,
+	.interrupt	= NULL,
+	.enable		= NULL,
+	.snprintf	= d9336_snprintf,
+	.type		= 0x9336,
+	.all_models	= 1,
+};
+
+int register_driver_dasd(void)
+{
+	int ret;
+
+	ret = register_device_type(&d3390);
+	if (ret)
+		return ret;
+
+	return register_device_type(&d9336);
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/drivers/device.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,372 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <list.h>
+#include <channel.h>
+#include <io.h>
+#include <slab.h>
+#include <device.h>
+#include <spinlock.h>
+#include <sched.h>
+
+struct senseid_struct {
+	u8 __reserved;
+	u16 cu_type;
+	u8 cu_model;
+	u16 dev_type;
+	u8 dev_model;
+} __attribute__((packed));
+
+struct static_device {
+	u16 dev_num;
+	struct senseid_struct sense;
+};
+
+#define END_OF_STATIC_DEV_LIST	0xffff
+
+/*
+ * This defines staticly-configured devices - ugly but necessary for devices
+ * that fail to identify themseleves via Sense-ID
+ */
+static struct static_device static_device_list[] = {
+	{ .dev_num = 0x0009, .sense = { .dev_type = 0x3215, .dev_model = 0 } },
+	{ .dev_num = END_OF_STATIC_DEV_LIST },
+};
+
+/*
+ * We need this device temporarily because submit_io & friends assume that
+ * the device that's doing IO is on the device list. Unfortunately, that
+ * isn't the case during IO device scanning. We register this device type,
+ * and each device temporarily during the scan to make submit_io & friends
+ * happy. When we're done scanning, we unregister this type.
+ */
+static struct device_type __fake_dev_type = {
+	.types		= LIST_HEAD_INIT(__fake_dev_type.types),
+	.reg		= NULL,
+	.interrupt	= NULL,
+	.snprintf	= NULL,
+	.type		= 0,
+	.model		= 0,
+};
+
+static LIST_HEAD(device_types);
+static spinlock_t dev_types_lock;
+
+static LIST_HEAD(devices);
+static spinlock_t devs_lock;
+
+static void unregister_device_type(struct device_type *type)
+{
+	spin_lock(&dev_types_lock);
+	list_del(&type->types);
+	spin_unlock(&dev_types_lock);
+}
+
+/**
+ * register_device_type - register a new device type/model
+ * @dev:	device type to register
+ */
+int register_device_type(struct device_type *dev)
+{
+	struct device_type *entry;
+
+	spin_lock(&dev_types_lock);
+
+	list_for_each_entry(entry, &device_types, types) {
+		if (dev == entry ||
+		    (dev->type == entry->type && dev->model == entry->model)) {
+			spin_unlock(&dev_types_lock);
+			return -EEXIST;
+		}
+	}
+
+	list_add_tail(&dev->types, &device_types);
+
+	spin_unlock(&dev_types_lock);
+
+	return 0;
+}
+
+/**
+ * find_device_by_ccuu - find device struct by ccuu
+ * @ccuu:	device ccuu to find
+ */
+struct device *find_device_by_ccuu(u16 ccuu)
+{
+	struct device *dev;
+
+	spin_lock(&devs_lock);
+
+	list_for_each_entry(dev, &devices, devices) {
+		if (dev->ccuu == ccuu) {
+			dev_get(dev);
+			spin_unlock(&devs_lock);
+			return dev;
+		}
+	}
+
+	spin_unlock(&devs_lock);
+
+	return ERR_PTR(-ENOENT);
+}
+
+/**
+ * find_device_by_sch - find device struct by subchannel number
+ * @sch:	device subchannel
+ */
+struct device *find_device_by_sch(u32 sch)
+{
+	struct device *dev;
+
+	spin_lock(&devs_lock);
+
+	list_for_each_entry(dev, &devices, devices) {
+		if (dev->sch == sch) {
+			dev_get(dev);
+			spin_unlock(&devs_lock);
+			return dev;
+		}
+	}
+
+	spin_unlock(&devs_lock);
+
+	return ERR_PTR(-ENOENT);
+}
+
+/**
+ * find_device_by_type - find device struct by type/model
+ * @type:	device type to find
+ * @model:	device model to find
+ */
+struct device *find_device_by_type(u16 type, u8 model)
+{
+	struct device *dev;
+
+	spin_lock(&devs_lock);
+
+	list_for_each_entry(dev, &devices, devices) {
+		if (dev->type == type &&
+		    dev->model == model) {
+			dev_get(dev);
+			spin_unlock(&devs_lock);
+			return dev;
+		}
+	}
+
+	spin_unlock(&devs_lock);
+
+	return ERR_PTR(-ENOENT);
+}
+
+/**
+ * __register_device - helper to register a device
+ * @dev:	device to register
+ * @remove:	remove the device from the list first
+ */
+static int __register_device(struct device *dev, int remove)
+{
+	struct device_type *type;
+	int err = 0;
+
+	spin_double_lock(&devs_lock, &dev_types_lock);
+
+	list_for_each_entry(type, &device_types, types) {
+		if (type->type == dev->type &&
+		    (type->all_models ||
+		     type->model == dev->model))
+			goto found;
+	}
+
+	err = -ENOENT;
+	type = NULL;
+
+found:
+	spin_double_unlock(&devs_lock, &dev_types_lock);
+
+	atomic_set(&dev->refcnt, 1);
+	atomic_set(&dev->in_use, 0);
+
+	dev->dev = type;
+
+	if (type && type->reg) {
+		err = type->reg(dev);
+
+		if (err)
+			dev->dev = NULL;
+	}
+
+	spin_double_lock(&devs_lock, &dev_types_lock);
+	if (remove)
+		list_del(&dev->devices);
+	list_add_tail(&dev->devices, &devices);
+	spin_double_unlock(&devs_lock, &dev_types_lock);
+
+	return err;
+}
+
+static int do_sense_id(struct device *dev, u16 dev_num, struct senseid_struct *buf)
+{
+	struct io_op ioop;
+	struct ccw ccw;
+	int ret;
+	int idx;
+	struct static_device *sdev;
+
+	/*
+	 * Check static configuration; if device is found (by device
+	 * number), use that information instead of issuing sense-id
+	 */
+	for(idx = 0; sdev = &static_device_list[idx],
+	    sdev->dev_num != END_OF_STATIC_DEV_LIST; idx++) {
+		if (sdev->dev_num == dev_num) {
+			memcpy(buf, &sdev->sense, sizeof(struct senseid_struct));
+			return 0;
+		}
+	}
+
+	/*
+	 * Set up IO op for Sense-ID
+	 */
+	ioop.handler = NULL;
+	ioop.dtor = NULL;
+
+	memset(&ioop.orb, 0, sizeof(struct orb));
+	ioop.orb.lpm = 0xff;
+	ioop.orb.addr = ADDR31(&ccw);
+	ioop.orb.f = 1;
+
+	memset(&ccw, 0, sizeof(struct ccw));
+	ccw.cmd = 0xe4; /* Sense-ID */
+	ccw.flags = CCW_FLAG_SLI;
+	ccw.count = sizeof(struct senseid_struct);
+	ccw.addr = ADDR31(buf);
+
+	/*
+	 * issue SENSE-ID
+	 */
+	ret = submit_io(dev, &ioop, CAN_LOOP);
+	BUG_ON(ret);
+
+	return ioop.err;
+}
+
+/*
+ * Scan all subchannel ids, and register each device
+ */
+void scan_devices(void)
+{
+	struct schib schib;
+	struct device *dev = NULL;
+	struct senseid_struct buf;
+	u32 sch;
+	int ret;
+
+	BUG_ON(register_device_type(&__fake_dev_type));
+
+	memset(&schib, 0, sizeof(struct schib));
+
+	/*
+	 * For each possible subchannel id...
+	 */
+	for(sch = 0x10000; sch <= 0x1ffff; sch++) {
+		/*
+		 * ...call store subchannel, to find out whether or not
+		 * there is a device
+		 */
+		if (store_sch(sch, &schib))
+			continue;
+
+		if (!schib.pmcw.v)
+			continue;
+
+		/*
+		 * The following code tries to take the following steps:
+		 *   - alloc device struct
+		 *   - enable the subchannel
+		 *   - MSCH
+		 *   - issue SENSE-ID IO op & wait for completion
+		 *   - register device with apropriate subsystem
+		 */
+
+		if (!dev) {
+			dev = malloc(sizeof(struct device), ZONE_NORMAL);
+
+			/*
+			 * if we failed to allocate memory, there's not much we can
+			 * do
+			 */
+			BUG_ON(!dev);
+
+			atomic_set(&dev->attention, 0);
+			INIT_LIST_HEAD(&dev->q_out);
+			dev->dev = &__fake_dev_type;
+		}
+
+		schib.pmcw.e = 1;
+
+		if (modify_sch(sch, &schib))
+			continue;
+
+		dev->sch   = sch;
+		BUG_ON(__register_device(dev, 0));
+		BUG_ON(dev->dev != &__fake_dev_type);
+
+		/*
+		 * Find out what the device is - whichever way is necessary
+		 */
+		ret = do_sense_id(dev, schib.pmcw.dev_num, &buf);
+
+		if (ret)
+			continue;
+
+		dev->type  = buf.dev_type;
+		dev->model = buf.dev_model;
+		dev->ccuu  = schib.pmcw.dev_num;
+
+		/* __register_device will remove the fake entry! */
+		if (__register_device(dev, 1)) {
+			/*
+			 * error registering ... the device struct MUST NOT
+			 * be freed as it has been added onto the devices
+			 * list. All that needs to be done is to reset the
+			 * enabled bit.
+			 */
+			schib.pmcw.e = 0;
+
+			/* msch could fail, but it shouldn't be fatal */
+			modify_sch(sch, &schib);
+		}
+
+		/* to prevent a valid device struct from being free'd */
+		dev = NULL;
+	}
+
+	unregister_device_type(&__fake_dev_type);
+
+	free(dev);
+}
+
+void list_devices(struct console *con, void (*f)(struct console*, struct device*))
+{
+	struct device *dev;
+
+	spin_lock(&devs_lock);
+
+	list_for_each_entry(dev, &devices, devices) {
+		dev_get(dev);
+		f(con, dev);
+		dev_put(dev);
+	}
+
+	spin_unlock(&devs_lock);
+}
+
+void register_drivers(void)
+{
+	register_driver_3215();
+	register_driver_dasd();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/drivers/vdevice.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,85 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <slab.h>
+#include <list.h>
+#include <vdevice.h>
+
+static int __setup_vdev_ded(struct virt_sys *sys,
+			    struct directory_vdev *dirdev,
+			    struct virt_device *vdev)
+{
+	struct device *rdev;
+
+	rdev = find_device_by_ccuu(dirdev->u.dedicate.rdev);
+	if (IS_ERR(rdev))
+		return PTR_ERR(rdev);
+
+	atomic_inc(&rdev->in_use);
+
+	vdev->u.dedicate.rdev = rdev;
+	vdev->type = rdev->type;
+	vdev->model = rdev->model;
+
+	return 0;
+}
+
+int alloc_virt_dev(struct virt_sys *sys, struct directory_vdev *dirdev,
+		   u32 sch)
+{
+	struct virt_device *vdev;
+	int ret = 0;
+
+	vdev = malloc(sizeof(struct virt_device), ZONE_NORMAL);
+	if (!vdev)
+		return -ENOMEM;
+
+	vdev->vtype = dirdev->type;
+	vdev->sch = sch;
+	vdev->pmcw.v = 1;
+	vdev->pmcw.dev_num = dirdev->vdev;
+	vdev->pmcw.lpm = 0x80;
+	vdev->pmcw.pim = 0x80;
+	vdev->pmcw.pom = 0xff;
+	vdev->pmcw.pam = 0x80;
+
+	switch(dirdev->type) {
+		case VDEV_CONS:
+			vdev->type = 0x3215;
+			vdev->model = 0;
+			break;
+		case VDEV_DED:
+			ret = __setup_vdev_ded(sys, dirdev, vdev);
+			break;
+		case VDEV_SPOOL:
+			vdev->type = dirdev->u.spool.type;
+			vdev->model = dirdev->u.spool.model;
+			// FIXME: hook it up to the spooler
+			break;
+		case VDEV_MDISK:
+			vdev->type = 0x3390;
+			vdev->model = 3;
+			// FIXME: hook it up to mdisk driver
+			break;
+		case VDEV_LINK:
+			goto free;
+		case VDEV_INVAL:
+			goto out;
+	}
+
+	list_add_tail(&vdev->devices, &sys->virt_devs);
+
+	return ret;
+
+free:
+	free(vdev);
+	return 0;
+
+out:
+	free(vdev);
+	return -EINVAL;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/fs/Makefile	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,1 @@
+objs-fs := bdev.o edf.o

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/fs/bdev.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,17 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <device.h>
+#include <bdev.h>
+
+int bdev_read_block(struct device *dev, void *buf, int lba)
+{
+	if (!dev->dev->read)
+		return -EINVAL;
+
+	return dev->dev->read(dev, buf, lba);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/fs/edf.c	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,178 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#include <mutex.h>
+#include <buddy.h>
+#include <slab.h>
+#include <device.h>
+#include <bdev.h>
+#include <ebcdic.h>
+#include <edf.h>
+
+struct fs *edf_mount(struct device *dev)
+{
+	struct page *page;
+	void *tmp;
+	struct fs *fs;
+	long ret;
+
+	page = alloc_pages(0, ZONE_NORMAL);
+	if (!page)
+		return ERR_PTR(-ENOMEM);
+	tmp = page_to_addr(page);
+
+	ret = -ENOMEM;
+	fs = malloc(sizeof(struct fs), ZONE_NORMAL);
+	if (!fs)
+		goto out_free;
+
+	/* First, read & verify the label */
+	ret = bdev_read_block(dev, tmp, EDF_LABEL_BLOCK_NO);
+	if (ret)
+		goto out_free;
+
+	mutex_init(&fs->lock);
+	INIT_LIST_HEAD(&fs->files);
+	fs->dev = dev;
+	fs->tmp_buf = tmp;
+
+	memcpy(&fs->ADT, tmp, sizeof(struct ADT));
+
+	ret = -EINVAL;
+	if ((fs->ADT.ADTIDENT != __ADTIDENT) ||
+	    (fs->ADT.ADTDBSIZ != EDF_SUPPORTED_BLOCK_SIZE) ||
+	    (fs->ADT.ADTOFFST != 0) ||
+	    (fs->ADT.ADTFSTSZ != sizeof(struct FST)))
+		goto out_free;
+
+	return fs;
+
+out_free:
+	free(fs);
+	free_pages(tmp, 0);
+	return ERR_PTR(ret);
+}
+
+extern struct console *oper_con;
+struct file *edf_lookup(struct fs *fs, char *fn, char *ft)
+{
+	char __fn[8];
+	char __ft[8];
+	struct page *page;
+	struct file *file;
+	struct file *tmpf;
+	struct FST *fst;
+	long ret;
+	int found;
+	int i;
+
+	file = malloc(sizeof(struct file), ZONE_NORMAL);
+	if (!file)
+		return ERR_PTR(-ENOMEM);
+
+	file->fs = fs;
+	file->buf = NULL;
+
+	memcpy(__fn, fn, 8);
+	memcpy(__ft, ft, 8);
+	ascii2ebcdic((u8 *) __fn, 8);
+	ascii2ebcdic((u8 *) __ft, 8);
+
+	mutex_lock(&fs->lock);
+
+	/* first, check the cache */
+	list_for_each_entry(tmpf, &fs->files, files) {
+		if (!memcmp((char*) tmpf->FST.FSTFNAME, __fn, 8) &&
+		    !memcmp((char*) tmpf->FST.FSTFTYPE, __ft, 8)) {
+			mutex_unlock(&fs->lock);
+			free(file);
+			return tmpf;
+		}
+	}
+
+	page = alloc_pages(0, ZONE_NORMAL);
+	if (!page) {
+		ret = -ENOMEM;
+		goto out_unlock;
+	}
+	file->buf = page_to_addr(page);
+
+	/* oh well, must do it the hard way ... read from disk */
+	ret = bdev_read_block(fs->dev, fs->tmp_buf, fs->ADT.ADTDOP);
+	if (ret)
+		goto out_unlock;
+
+	fst = fs->tmp_buf;
+
+	for(i=0,found=0; i<fs->ADT.ADTNFST; i++) {
+		if ((!memcmp(fst[i].FSTFNAME, __fn, 8)) &&
+		    (!memcmp(fst[i].FSTFTYPE, __ft, 8))) {
+			memcpy(&file->FST, &fst[i], sizeof(struct FST));
+			found = 1;
+			break;
+		}
+	}
+
+	if (!found) {
+		ret = -ENOENT;
+		goto out_unlock;
+	}
+
+	mutex_init(&file->lock);
+	list_add_tail(&file->files, &fs->files);
+
+	mutex_unlock(&fs->lock);
+
+	return file;
+
+out_unlock:
+	if (file && file->buf)
+		free_pages(file->buf, 0);
+	mutex_unlock(&fs->lock);
+	free(file);
+	return ERR_PTR(ret);
+}
+
+int edf_read_rec(struct file *file, char *buf, u32 recno)
+{
+	struct fs *fs = file->fs;
+	u32 fop, lrecl;
+	int ret;
+
+	if (file->FST.FSTNLVL != 0 ||
+	    file->FST.FSTPTRSZ != 4 ||
+	    file->FST.FSTLRECL > fs->ADT.ADTDBSIZ ||
+	    file->FST.FSTRECFM != FSTDFIX)
+		return -EINVAL;
+
+	mutex_lock(&file->lock);
+
+	fop = file->FST.FSTFOP;
+	lrecl = file->FST.FSTLRECL;
+
+	ret = bdev_read_block(fs->dev, file->buf, fop);
+	if (ret)
+		goto out;
+
+	memcpy(buf, file->buf + (recno * lrecl), lrecl);
+
+out:
+	mutex_unlock(&file->lock);
+
+	return ret;
+}
+
+void edf_file_free(struct file *file)
+{
+	struct fs *fs = file->fs;
+
+	mutex_lock(&fs->lock);
+	list_del(&file->files);
+	mutex_unlock(&fs->lock);
+
+	free(file);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/hvf.directory	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,26 @@
+USER OPERATOR A
+    MACHINE ESA 1
+    STORAGE 17M
+    CONSOLE 0009 3215
+    SPOOL 000C 3505 READER
+    SPOOL 000D 3525 PUNCH
+    SPOOL 000E 1403 PRINT
+    MDISK 0191 3390 15 100 0192
+
+USER JEFFPC A
+    MACHINE ESA 1
+    STORAGE 64M
+    CONSOLE 0009 3215
+    SPOOL 000C 3505 READER
+    SPOOL 000D 3525 PUNCH
+    SPOOL 000E 1403 PRINT
+    MDISK 0190 3390 15 100 0192
+
+USER OBIWAN G
+    MACHINE ESA 1
+    STORAGE 2M
+    CONSOLE 0009 3215
+    SPOOL 000C 3505 READER
+    SPOOL 000D 3525 PUNCH
+    SPOOL 000E 1403 PRINT
+    MDISK 0193 3390 15 100 0192

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/atomic.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,203 @@
+/*
+ * Based on atomic.h from Linux Kernel
+ */
+
+#ifndef __ARCH_S390_ATOMIC__
+#define __ARCH_S390_ATOMIC__
+
+/*
+ *  include/asm-s390/atomic.h
+ *
+ *  S390 version
+ *    Copyright (C) 1999-2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
+ *               Denis Joseph Barrow,
+ *		 Arnd Bergmann (arndb@de.ibm.com)
+ *
+ *  Derived from "include/asm-i386/bitops.h"
+ *    Copyright (C) 1992, Linus Torvalds
+ *
+ */
+
+/*
+ * Atomic operations that C can't guarantee us.  Useful for
+ * resource counting etc..
+ * S390 uses 'Compare And Swap' for atomicity in SMP enviroment
+ */
+
+typedef struct {
+	volatile int counter;
+} __attribute__ ((aligned (4))) atomic_t;
+#define ATOMIC_INIT(i)  { (i) }
+
+#define __CS_LOOP(ptr, op_val, op_string) ({				\
+	typeof(ptr->counter) old_val, new_val;				\
+	asm volatile(							\
+		"	l	%0,%2\n"				\
+		"0:	lr	%1,%0\n"				\
+		op_string "	%1,%3\n"				\
+		"	cs	%0,%1,%2\n"				\
+		"	jl	0b"					\
+		: "=&d" (old_val), "=&d" (new_val),			\
+		  "=Q" (((atomic_t *)(ptr))->counter)			\
+		: "d" (op_val),	 "Q" (((atomic_t *)(ptr))->counter)	\
+		: "cc", "memory");					\
+	new_val;							\
+})
+
+#define atomic_read(v)          ((v)->counter)
+#define atomic_set(v,i)         (((v)->counter) = (i))
+
+static __inline__ int atomic_add_return(int i, atomic_t * v)
+{
+	return __CS_LOOP(v, i, "ar");
+}
+#define atomic_add(_i, _v)		atomic_add_return(_i, _v)
+#define atomic_add_negative(_i, _v)	(atomic_add_return(_i, _v) < 0)
+#define atomic_inc(_v)			atomic_add_return(1, _v)
+#define atomic_inc_return(_v)		atomic_add_return(1, _v)
+#define atomic_inc_and_test(_v)		(atomic_add_return(1, _v) == 0)
+
+static __inline__ int atomic_sub_return(int i, atomic_t * v)
+{
+	return __CS_LOOP(v, i, "sr");
+}
+#define atomic_sub(_i, _v)		atomic_sub_return(_i, _v)
+#define atomic_sub_and_test(_i, _v)	(atomic_sub_return(_i, _v) == 0)
+#define atomic_dec(_v)			atomic_sub_return(1, _v)
+#define atomic_dec_return(_v)		atomic_sub_return(1, _v)
+#define atomic_dec_and_test(_v)		(atomic_sub_return(1, _v) == 0)
+
+static __inline__ void atomic_clear_mask(unsigned long mask, atomic_t * v)
+{
+	       __CS_LOOP(v, ~mask, "nr");
+}
+
+static __inline__ void atomic_set_mask(unsigned long mask, atomic_t * v)
+{
+	       __CS_LOOP(v, mask, "or");
+}
+
+#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
+
+static __inline__ int atomic_cmpxchg(atomic_t *v, int old, int new)
+{
+	asm volatile(
+		"	cs	%0,%2,%1"
+		: "+d" (old), "=Q" (v->counter)
+		: "d" (new), "Q" (v->counter)
+		: "cc", "memory");
+	return old;
+}
+
+static __inline__ int atomic_add_unless(atomic_t *v, int a, int u)
+{
+	int c, old;
+	c = atomic_read(v);
+	for (;;) {
+		if (unlikely(c == u))
+			break;
+		old = atomic_cmpxchg(v, c, c + a);
+		if (likely(old == c))
+			break;
+		c = old;
+	}
+	return c != u;
+}
+
+#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
+
+#undef __CS_LOOP
+
+typedef struct {
+	volatile long long counter;
+} __attribute__ ((aligned (8))) atomic64_t;
+#define ATOMIC64_INIT(i)  { (i) }
+
+#define __CSG_LOOP(ptr, op_val, op_string) ({				\
+	typeof(ptr->counter) old_val, new_val;				\
+	asm volatile(							\
+		"	lg	%0,%2\n"				\
+		"0:	lgr	%1,%0\n"				\
+		op_string "	%1,%3\n"				\
+		"	csg	%0,%1,%2\n"				\
+		"	jl	0b"					\
+		: "=&d" (old_val), "=&d" (new_val),			\
+		  "=Q" (((atomic_t *)(ptr))->counter)			\
+		: "d" (op_val),	"Q" (((atomic_t *)(ptr))->counter)	\
+		: "cc", "memory" );					\
+	new_val;							\
+})
+
+#define atomic64_read(v)          ((v)->counter)
+#define atomic64_set(v,i)         (((v)->counter) = (i))
+
+static __inline__ long long atomic64_add_return(long long i, atomic64_t * v)
+{
+	return __CSG_LOOP(v, i, "agr");
+}
+#define atomic64_add(_i, _v)		atomic64_add_return(_i, _v)
+#define atomic64_add_negative(_i, _v)	(atomic64_add_return(_i, _v) < 0)
+#define atomic64_inc(_v)		atomic64_add_return(1, _v)
+#define atomic64_inc_return(_v)		atomic64_add_return(1, _v)
+#define atomic64_inc_and_test(_v)	(atomic64_add_return(1, _v) == 0)
+
+static __inline__ long long atomic64_sub_return(long long i, atomic64_t * v)
+{
+	return __CSG_LOOP(v, i, "sgr");
+}
+#define atomic64_sub(_i, _v)		atomic64_sub_return(_i, _v)
+#define atomic64_sub_and_test(_i, _v)	(atomic64_sub_return(_i, _v) == 0)
+#define atomic64_dec(_v)		atomic64_sub_return(1, _v)
+#define atomic64_dec_return(_v)		atomic64_sub_return(1, _v)
+#define atomic64_dec_and_test(_v)	(atomic64_sub_return(1, _v) == 0)
+
+static __inline__ void atomic64_clear_mask(unsigned long mask, atomic64_t * v)
+{
+	       __CSG_LOOP(v, ~mask, "ngr");
+}
+
+static __inline__ void atomic64_set_mask(unsigned long mask, atomic64_t * v)
+{
+	       __CSG_LOOP(v, mask, "ogr");
+}
+
+#define atomic64_xchg(v, new) (xchg(&((v)->counter), new))
+
+static __inline__ long long atomic64_cmpxchg(atomic64_t *v,
+					     long long old, long long new)
+{
+	asm volatile(
+		"	csg	%0,%2,%1"
+		: "+d" (old), "=Q" (v->counter)
+		: "d" (new), "Q" (v->counter)
+		: "cc", "memory");
+	return old;
+}
+
+static __inline__ int atomic64_add_unless(atomic64_t *v,
+					  long long a, long long u)
+{
+	long long c, old;
+	c = atomic64_read(v);
+	for (;;) {
+		if (unlikely(c == u))
+			break;
+		old = atomic64_cmpxchg(v, c, c + a);
+		if (likely(old == c))
+			break;
+		c = old;
+	}
+	return c != u;
+}
+
+#define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1, 0)
+
+#undef __CSG_LOOP
+
+#define smp_mb__before_atomic_dec()	smp_mb()
+#define smp_mb__after_atomic_dec()	smp_mb()
+#define smp_mb__before_atomic_inc()	smp_mb()
+#define smp_mb__after_atomic_inc()	smp_mb()
+
+#endif /* __ARCH_S390_ATOMIC__  */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/bdev.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,13 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __BDEV_H
+#define __BDEV_H
+
+extern int bdev_read_block(struct device *dev, void *buf, int lba);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/buddy.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,17 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __BUDDY_H
+#define __BUDDY_H
+
+#include <page.h>
+
+extern void init_buddy_alloc(u64 start);
+extern struct page *alloc_pages(int order, int type);
+extern void free_pages(void *ptr, int order);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/channel.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,309 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __CHANNEL_H
+#define __CHANNEL_H
+
+/*
+ * We only care about format-1 CCWs
+ */
+struct ccw {
+	u8 cmd;			/* Command code */
+	u8 flags;		/* Flags */
+	u16 count;		/* Count */
+	u32 addr;		/* Data Address */
+} __attribute__((packed,aligned(8)));
+
+struct ccw0 {
+	u8 cmd;			/* Command code */
+	u8 addr_hi;		/* Data Address (bits 8-15) */
+	u16 addr_lo;		/* Data Address (bits 16-31) */
+	u8 flags;		/* Flags */
+	u8 _res0;
+	u16 count;		/* Count */
+} __attribute__((packed,aligned(8)));
+
+#define CCW_CMD_IPL_READ	0x02
+#define CCW_CMD_NOP		0x03
+#define CCW_CMD_BASIC_SENSE	0x04
+#define CCW_CMD_SENSE_ID	0xe4
+#define CCW_CMD_TIC		0x08
+
+#define CCW_FLAG_CD		0x80	/* Chain-Data */
+#define CCW_FLAG_CC		0x40	/* Chain-Command */
+#define CCW_FLAG_SLI		0x20	/* Suppress-Length-Indication */
+#define CCW_FLAG_SKP		0x10	/* Skip */
+#define CCW_FLAG_PCI		0x08	/* Program-Controlled-Interruption */
+#define CCW_FLAG_IDA		0x04	/* Indirect-Data-Address */
+#define CCW_FLAG_S		0x02	/* Suspend */
+#define CCW_FLAG_MIDA		0x01	/* Modified-Indirect-Data-Address */
+
+/*
+ * ORB
+ */
+struct orb {
+	/* word 0 */
+	u32 param;		/* Interruption Parameter */
+
+	/* word 1 */
+	u8 key:4,		/* Subchannel Key */
+	   s:1,			/* Suspend */
+	   c:1,			/* Streaming-Mode Control */
+	   m:1,			/* Modification Control */
+	   y:1;			/* Synchronization Control */
+	u8 f:1,			/* Format Control */
+	   p:1,			/* Prefetch Control */
+	   i:1,			/* Initial-Status-Interruption Control */
+	   a:1,			/* Address-Limit-Checking control */
+	   u:1,			/* Suppress-Suspend-Interruption Control */
+	   __zero1:1,
+	   h:1,			/* Format-2-IDAW Control */
+	   t:1;			/* 2K-IDAW Control */
+	u8 lpm;			/* Logical-Path Mask */
+	u8 l:1,			/* Incorrect-Length-Suppression Mode */
+	   d:1,			/* Modified-CCW-Indirect-Data-Addressing Control */
+	   __zero2:5,
+	   x:1;			/* ORB-Extension Control */
+
+	/* word 2 */
+	u32 addr;		/* Channel-Program Address */
+
+	/* word 3 */
+	u8 css_prio;		/* Channel-Subsystem Priority */
+	u8 __reserved1;
+	u8 cu_prio;		/* Control-Unit Priority */
+	u8 __reserved2;
+
+	/* word 4 - 7 */
+	u32 __reserved3;
+	u32 __reserved4;
+	u32 __reserved5;
+	u32 __reserved6;
+} __attribute__((packed,aligned(4)));
+
+enum SCSW_FC {
+	FC_CLEAR	= 0x10,
+	FC_HALT		= 0x20,
+	FC_START	= 0x40,
+};
+
+enum SCSW_SC {
+	SC_STATUS	= 0x01,
+	SC_SECONDARY	= 0x02,
+	SC_PRIMARY	= 0x04,
+	SC_INTERMED	= 0x08,
+	SC_ALERT	= 0x10,
+};
+
+struct scsw {
+	/* word 0 */
+	u16 key:4,		/* Subchannel key */
+	    s:1,		/* Suspend control */
+	    l:1,		/* ESW format */
+	    cc:2,		/* Deferred condition code */
+	    f:1,		/* Format */
+	    p:1,		/* Prefetch */
+	    i:1,		/* Initial-status interruption control */
+	    a:1,		/* Address-limit-checking control */
+	    u:1,		/* Supress-suspended interruption */
+	    z:1,		/* Zero condition code */
+	    e:1,		/* Extended control */
+	    n:1;		/* Path no operational */
+	u16 __zero:1,
+	    fc:3,		/* Function control */
+	    ac:8,		/* Activity control */
+	    sc:4;		/* Status control */
+
+	/* word 1 */
+	u32 addr;		/* CCW Address */
+
+	/* word 2 */
+	u8 dev_status;		/* Device status */
+	u8 sch_status;		/* Subchannel status */
+	u16 count;		/* Count */
+} __attribute__((packed));
+
+/* needed by IRB */
+struct irb_ext_status {
+	/* TODO: not implemented */
+	u32 w0, w1, w2, w3, w4;
+} __attribute__((packed));
+
+/* needed by IRB */
+struct irb_ext_control {
+	/* TODO: not implemented */
+	u32 w0, w1, w2, w3, w4, w5, w6, w7;
+} __attribute__((packed));
+
+/* needed by IRB */
+struct irb_ext_measurement {
+	/* TODO: not implemented */
+	u32 w0, w1, w2, w3, w4, w5, w6, w7;
+} __attribute__((packed));
+
+struct irb {
+	struct scsw scsw;			/* Subchannel-Status */
+	struct irb_ext_status ext_status;	/* Extended-Status */
+	struct irb_ext_control ext_control;	/* Extended-Control */
+	struct irb_ext_measurement ext_measure;	/* Extended-Measurement */
+} __attribute__((packed,aligned(4)));
+
+/* Path Management Control Word */
+struct pmcw {
+	/* word 0 */
+	u32 interrupt_param;	/* Interruption Parameter */
+
+	/* word 1*/
+	u8 __zero1:2,
+	   isc:3,		/* I/O-Interruption-Subclass Code */
+	   __zero2:3;
+	u8 e:1,			/* Enabled */
+	   lm:2,		/* Limit Mode */
+	   mm:2,		/* Measurement-Mode Enable */
+	   d:1,			/* Multipath Mode */
+	   t:1,			/* Timing Facility */
+	   v:1;			/* Device Number Valid */
+	u16 dev_num;		/* Device Number */
+
+	/* word 2 */
+	u8 lpm;			/* Logical-Path Mask */
+	u8 pnom;		/* Path-Not-Operational Mask */
+	u8 lpum;		/* Last-Path-Used Mask */
+	u8 pim;			/* Path-Installed Mask */
+
+	/* word 3 */
+	u16 mbi;		/* Measurement-Block Index */
+	u8 pom;			/* Path-Operational Mask */
+	u8 pam;			/* Path-Available Mask */
+
+	/* word 4 & 5 */
+	u8 chpid[8];		/* Channel-Path Identifiers */
+
+	/* word 6 */
+	u16 __zero3;
+	u16 __zero4:13,
+	    f:1,		/* Measurement Block Format Control */
+	    x:1,		/* Extended Measurement Word Mode Enable */
+	    s:1;		/* Concurrent Sense */
+};
+
+/* needed by schib */
+struct schib_measurement_block {
+	/* TODO: not implemented */
+	u32 w0, w1;
+};
+
+struct schib {
+	struct pmcw pmcw;		/* Path Management Control Word */
+	struct scsw scsw;		/* Subchannel Status Word */
+	union {
+		struct schib_measurement_block measure_block;
+	};
+	u32 model_dep_area;
+} __attribute__((packed,aligned(4)));
+
+static inline int store_sch(u32 sch, struct schib *schib)
+{
+	int cc;
+
+	asm volatile(
+		"lr	%%r1,%2\n"
+		"stsch	%1\n"
+		"ipm	%0\n"
+		"srl	%0,28\n"
+		: /* output */
+		  "=d" (cc),
+		  "=Q" (*schib)
+		: /* input */
+		  "d" (sch)
+		: /* clobbered */
+		  "cc", "r1", "memory"
+	);
+
+	if (cc == 3)
+		return -EINVAL;
+	return 0;
+}
+
+static inline int modify_sch(u32 sch, struct schib *schib)
+{
+	int cc;
+
+	asm volatile(
+		"lr	%%r1,%1\n"
+		"msch	0(%2)\n"
+		"ipm	%0\n"
+		"srl	%0,28\n"
+		: /* output */
+		  "=d" (cc)
+		: /* input */
+		  "d" (sch),
+		  "a" (schib)
+		: /* clobbered */
+		  "cc", "r1"
+	);
+
+	if (cc == 1 || cc == 2)
+		return -EBUSY;
+	if (cc == 3)
+		return -EINVAL;
+	return 0;
+}
+
+static inline int start_sch(u32 sch, struct orb *orb)
+{
+	int cc;
+
+	asm volatile(
+		"	lr	%%r1,%1\n"
+		"	ssch	0(%2)\n"
+		"	ipm	%0\n"
+		"	srl	%0,28\n"
+		: /* output */
+		  "=d" (cc)
+		: /* input */
+		  "d" (sch),
+		  "a" (orb)
+		: /* clobbered */
+		  "cc", "r1"
+	);
+
+	if (cc == 1 || cc == 2)
+		return -EBUSY;
+	if (cc == 3)
+		return -EINVAL;
+
+	return 0;
+}
+
+static inline int test_sch(u32 sch, struct irb *irb)
+{
+	int cc;
+
+	asm volatile(
+		"	lr	%%r1,%1\n"
+		"	tsch	0(%2)\n"
+		"	ipm	%0\n"
+		"	srl	%0,28\n"
+	: /* output */
+	  "=d" (cc)
+	: /* input */
+	  "d" (sch),
+	  "a" (irb)
+	: /* clobbered */
+	  "cc", "r1"
+	);
+
+	if (cc == 3)
+		return -EINVAL;
+
+	return 0;
+}
+
+extern void scan_devices(void);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/compiler.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,17 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __COMPILER_H
+#define __COMPILER_H
+
+/*
+ * For compatibility with some Linux kernel code
+ */
+#define likely(x) (x)
+#define unlikely(x) (x)
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/config.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,21 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+/*
+ * Base address within a guest's address space; used as the base address for
+ * the IPL helper code.
+ *
+ * NOTE: It must be >= 16M, but <2G
+ */
+#define GUEST_IPL_BASE		(16ULL * 1024ULL * 1024ULL)
+
+#define OPER_CONSOLE_CCUU	0x0009
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/console.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,57 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __CONSOLE_H
+#define __CONSOLE_H
+
+#include <device.h>
+#include <io.h>
+#include <spinlock.h>
+
+/* line allocation size */
+#define CON_LINE_ALLOC_SIZE	256
+
+/* maximum line length */
+#define CON_MAX_LINE_LEN	(CON_LINE_ALLOC_SIZE - sizeof(struct console_line))
+
+/* maximum number of free lines to keep around */
+#define CON_MAX_FREE_LINES	32
+
+/* number of lines of console text to flush at a time */
+#define CON_MAX_FLUSH_LINES	32
+
+/* line state */
+#define CON_STATE_FREE		0
+#define CON_STATE_PENDING	1
+#define CON_STATE_IO		2
+
+struct console_line {
+	struct list_head lines;
+	u16 len;
+	u16 state;
+	u8 buf[0];
+};
+
+struct console {
+	struct list_head consoles;
+	struct virt_sys *sys;
+	struct device *dev;
+	spinlock_t lock;
+	struct list_head write_lines;
+	struct list_head read_lines;
+};
+
+extern int console_interrupt(struct device *dev, struct irb *irb);
+extern struct console* start_oper_console(void);
+extern void* console_enable(struct device *dev);
+extern int con_read_pending(struct console *con);
+extern int con_read(struct console *con, u8 *buf, int size);
+extern int con_write(struct console *con, u8 *buf, int len);
+extern void for_each_console(void (*f)(struct console *con));
+extern struct console* find_console(struct device *dev);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/cpu.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,39 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __CPU_H
+#define __CPU_H
+
+static inline u64 getcpuid()
+{
+	u64 cpuid = ~0;
+
+	asm("stidp	0(%1)\n"
+	: /* output */
+	  "=m" (cpuid)
+	: /* input */
+	  "a" (&cpuid)
+	);
+
+	return cpuid;
+}
+
+static inline u16 getcpuaddr()
+{
+	u16 cpuaddr = ~0;
+
+	asm("stap	0(%1)\n"
+	: /* output */
+	  "=m" (cpuaddr)
+	: /* input */
+	  "a" (&cpuaddr)
+	);
+
+	return cpuaddr;
+}
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/dat.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,143 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __DAT_H
+#define __DAT_H
+
+struct address_space {
+	struct dat_rte *region_table;
+	struct dat_ste *segment_table;
+};
+
+/* region/segment-table destination */
+struct dat_td {
+	u64 origin:52,		/* region/segment table origin */
+	    __reserved0:2,
+	    g:1,		/* subspace-group control */
+	    p:1,		/* private-space control */
+	    s:1,		/* storage-alteration-event ctl */
+	    x:1,		/* space-switch-event control */
+	    r:1,		/* real-space control */
+	    __reserved1:1,
+	    dt:2,		/* designation-type control */
+	    tl:2;		/* table length */
+} __attribute__((packed));
+
+#define DAT_TD_DT_RFT		3	/* region-first */
+#define DAT_TD_DT_RST		2	/* region-second */
+#define DAT_TD_DT_RTT		1	/* region-third */
+#define DAT_TD_DT_ST		0	/* segment */
+
+/* region-table entries (first, second, and third) */
+struct dat_rte {
+	u64 origin:52,		/* next-level-table origin */
+	    __reserved0:4,
+	    tf:2,		/* table offset (next lower tbl) */
+	    i:1,		/* region invalid */
+	    __reserved1:1,
+	    tt:2,		/* table-type bits (current tbl) */
+	    tl:2;		/* table length (next lower tbl) */
+} __attribute__((packed));
+
+/*
+ * Constants for struct rte
+ */
+#define DAT_RTE_TT_RFT		3	/* region-first */
+#define DAT_RTE_TT_RST		2	/* region-second */
+#define DAT_RTE_TT_RTT		1	/* region-third */
+
+#define ADDR_TO_RTE_ORIGIN(a)	((a) >> 12)
+#define RTE_ORIGIN_TO_ADDR(o)	((void*)(((u64)(o)) << 12))
+
+/* segment-table entries */
+struct dat_ste {
+	u64 origin:53,		/* page-table origin */
+	    __reserved0:1,
+	    p:1,		/* page-protection bit */
+	    __reserved1:3,
+	    i:1,		/* segment-invalid bit */
+	    c:1,		/* common-segment bit */
+	    tt:2,		/* table-type bits */
+	    __reserved2:2;
+} __attribute__((packed));
+
+#define DAT_STE_TT_ST		0	/* segment-table */
+
+#define ADDR_TO_STE_ORIGIN(a)	((a) >> 11)
+#define STE_ORIGIN_TO_ADDR(o)	((void*)(((u64)(o)) << 11))
+
+/* page-table entries */
+struct dat_pte {
+	u64 pfra:52,		/* page-frame real address */
+	    __zero0:1,
+	    i:1,		/* page-invalid bit */
+	    p:1,		/* page-protection bit */
+	    __zero1:1,
+	    __reserved:8;
+} __attribute__((packed));
+
+#define DAT_RX(addr)	(((u64)(addr)) >> 31)
+#define DAT_SX(addr)	((((u64)(addr)) >> 20) & 0x7ff)
+#define DAT_PX(addr)	((((u64)(addr)) >> 12) & 0xff)
+#define DAT_BX(addr)	(((u64)(addr))& 0xfff)
+
+extern int dat_insert_page(struct address_space *as, u64 phy, u64 virt);
+extern void setup_dat(void);
+extern void load_as(struct address_space *as);
+
+extern int virt2phy(struct address_space *as, u64 virt, u64 *phy);
+
+static inline void store_pasce(u64 *pasce)
+{
+	asm volatile(
+		"	stctg	1,1,0(%0)\n"
+	: /* output */
+	: /* input */
+	  "a" (pasce)
+	);
+}
+
+static inline void load_pasce(u64 pasce)
+{
+	if (!pasce)
+		return;
+
+	asm volatile(
+		"	lctlg	1,1,%0\n"
+	: /* output */
+	: /* input */
+	  "m" (pasce)
+	);
+}
+
+/* get host real address from guest real, using the currently loaded ASCE */
+static inline int virt2phy_current(u64 virt, u64 *phy)
+{
+	u64 result;
+	int cc;
+
+	asm volatile(
+		"	lrag	%0,0(%%r0,%2)\n"
+		"	ipm	%1\n"
+		"	srl	%1,28\n"
+	: /* output */
+	  "=d" (result),
+	  "=d" (cc)
+	: /* input */
+	  "a" (virt)
+	: /* clobber */
+	  "cc"
+	);
+
+	if (cc != 0)
+		return -EFAULT;
+
+	*phy = result;
+	return 0;
+}
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/device.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,98 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __DEVICE_H
+#define __DEVICE_H
+
+#include <atomic.h>
+#include <spinlock.h>
+#include <list.h>
+
+struct device;
+struct irb;
+
+struct device_type {
+	struct list_head types;
+	int (*reg)(struct device *dev);
+	int (*interrupt)(struct device *dev, struct irb *irb);
+	void* (*enable)(struct device *dev);
+	int (*snprintf)(struct device *dev, char *buf, int len);
+
+	/* the following ops are for the bdev wrapper layer */
+	int (*read)(struct device *dev, u8 *buf, int len);
+
+	u16 type;
+	u8 model;
+	u8 all_models;
+};
+
+struct device {
+	struct list_head devices;
+	u32 sch;			/* subchannel id */
+	u16 type;			/* 3330, 3215, ... */
+	u8 model;
+	u16 ccuu;			/* device number */
+	struct device_type *dev;
+
+	spinlock_t q_lock;
+	struct io_op *q_cur;
+	struct list_head q_out;
+	atomic_t attention;
+
+	atomic_t in_use;		/* is the device in use by someone? */
+
+	atomic_t refcnt;		/* internal reference counter */
+
+	union {
+		struct {
+			u16 cyls;	/* cylinders */
+			u16 tracks;	/* tracks per cylinder */
+			u16 len;	/* track length */
+			u16 recs;	/* number of records */
+			u8  sectors;	/* # sectors per track */
+			u8  formula;	/* capacity formula */
+			u16 f1,		/* factor f1 */
+			    f2,		/* factor f2 */
+			    f3,		/* factor f3 */
+			    f4,		/* factor f4 */
+			    f5;		/* factor f5 */
+		} eckd;
+		struct {
+			u16 blk_size;	/* block size */
+			u32 bpg;	/* blocks per cyclical group */
+			u32 bpp;	/* blocks per access possition */
+			u32 blks;	/* blocks */
+		} fba;
+	};
+};
+
+extern struct device *find_device_by_type(u16 type, u8 model);
+extern struct device *find_device_by_ccuu(u16 ccuu);
+extern struct device *find_device_by_sch(u32 sch);
+extern int register_device_type(struct device_type *dev);
+extern void scan_devices(void);
+extern void list_devices(struct console *con,
+			 void (*f)(struct console*, struct device*));
+extern void register_drivers(void);
+
+static inline void dev_get(struct device *dev)
+{
+	BUG_ON(atomic_read(&dev->refcnt) < 1);
+	atomic_inc(&dev->refcnt);
+}
+
+static inline void dev_put(struct device *dev)
+{
+	atomic_dec(&dev->refcnt);
+	BUG_ON(atomic_read(&dev->refcnt) < 1);
+}
+
+/* device specific register functions */
+extern int register_driver_3215(void);
+extern int register_driver_dasd(void);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/directory.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,69 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __DIRECTORY_H
+#define __DIRECTORY_H
+
+#include <console.h>
+
+enum directory_vdevtype {
+	VDEV_INVAL = 0,			/* invalid */
+	VDEV_CONS,			/* a console */
+	VDEV_DED,			/* dedicated real device */
+	VDEV_SPOOL,			/* backed by the spool */
+	VDEV_MDISK,			/* a minidisk */
+	VDEV_LINK,			/* a link to another user's device */
+};
+
+struct directory_vdev {
+	enum directory_vdevtype type;	/* device type */
+	u16 vdev;			/* virtual dev # */
+
+	union {
+		/* VDEV_CONS */
+		struct {
+		} console;
+
+		/* VDEV_DED */
+		struct {
+			u16 rdev;	/* real device # */
+		} dedicate;
+
+		/* VDEV_SPOOL */
+		struct {
+			u16 type;
+			u8 model;
+		} spool;
+
+		/* VDEV_MDISK */
+		struct {
+			u16 cyloff;	/* first cylinder # */
+			u16 cylcnt;	/* cylinder count */
+			u16 rdev;	/* real DASD containing the mdisk */
+		} mdisk;
+
+		/* VDEV_LINK */
+		struct {
+		} link;
+	} u;
+};
+
+struct user {
+	char *userid;
+	struct task *task;
+
+	/* VM configuration */
+	u64 storage_size;
+
+	struct directory_vdev *devices;
+
+	u8 auth;
+};
+
+extern struct user *find_user_by_id(char *userid);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/disassm.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,76 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __DISASSM_H
+#define __DISASSM_H
+
+enum inst_fmt {
+	IF_INV = 0,
+	IF_VAR,
+	IF_E,
+	IF_I,
+	IF_RI1,
+	IF_RI2,
+	IF_RIE,
+	IF_RIL1,
+	IF_RIL2,
+	IF_RIS,
+	IF_RR,
+	IF_RR_MASK,
+	IF_RRE,
+	IF_RRF1,
+	IF_RRF2,
+	IF_RRF3,
+	IF_RRR,
+	IF_RRS,
+	IF_RS1,
+	IF_RS2,
+	IF_RSI,
+	IF_RSL,
+	IF_RSY1,
+	IF_RSY2,
+	IF_RX,
+	IF_RX_MASK,
+	IF_RXE,
+	IF_RXF,
+	IF_RXY,
+	IF_S,
+	IF_SI,
+	IF_SIL,
+	IF_SIY,
+	IF_SS1,
+	IF_SS2,
+	IF_SS3,
+	IF_SS4,
+	IF_SS5,
+	IF_SSE,
+	IF_SSF,
+	IF_DIAG,
+};
+
+struct disassm_instruction {
+	union {
+		char *name;	/* instruction name; inst only */
+
+		void *ptr;	/* next level table; table only */
+	} u;
+
+	/* all */
+	char fmt;		/* instruction format */
+
+	/* table only */
+	char len;		/* table len */
+	char loc;		/* sub-opcode location offset in bits */
+};
+
+#define DA_INST(idx,ifmt,iname)		[idx] = { .fmt = IF_##ifmt,	.u.name = #iname, }
+#define DA_INST_TBL(idx,itbl,ilen,iloc)	[idx] = { .fmt = IF_VAR,	.u.ptr = (itbl), \
+						  .len = (ilen),	.loc = (iloc), }
+
+extern int disassm(u8 *bytes, char *buf, int buflen);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/ebcdic.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,41 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __EBCDIC_H
+#define __EBCDIC_H
+
+extern u8 ascii2ebcdic_table[256];
+extern u8 ebcdic2ascii_table[256];
+
+/*
+ * Generic translate buffer function.
+ */
+static inline void __translate(u8 *buf, int len, const u8 *table)
+{
+	asm volatile(
+		"	sgr	%%r0,%%r0\n"		/* test byte = 0 */
+		"	la	%%r2,0(%0)\n"		/* buffer */
+		"	lgr	%%r3,%2\n"		/* length */
+		"	la	%%r4,0(%1)\n"		/* table */
+		"0:	tre	%%r2,%%r4\n"
+		"	brc	1,0b\n"
+		: /* output */
+		: /* input */
+		  "a" (buf),
+		  "a" (table),
+		  "d" (len)
+		: /* clobbered */
+		  "cc", "r0", "r2", "r3", "r4"
+	);
+}
+
+#define ascii2ebcdic(buf, len)	\
+			__translate((buf), (len), ascii2ebcdic_table)
+#define ebcdic2ascii(buf, len)  \
+			__translate((buf), (len), ebcdic2ascii_table)
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/edf.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,107 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __EDF_H
+#define __EDF_H
+
+#include <mutex.h>
+#include <device.h>
+
+struct ADT {
+	u32     ADTIDENT;       /* VOL START / LABEL IDENTIFIER */
+#define __ADTIDENT 0xC3D4E2F1   /* 'CMS1' in EBCDIC */
+	u8      ADTID[6];       /* VOL START / VOL IDENTIFIER */
+	u8      ADTVER[2];      /* VERSION LEVEL */
+	u32     ADTDBSIZ;       /* DISK BLOCK SIZE */
+	u32     ADTDOP;         /* DISK ORIGIN POINTER */
+	u32     ADTCYL;         /* NUM OF FORMATTED CYL ON DISK */
+	u32     ADTMCYL;        /* MAX NUM FORMATTED CYL ON DISK */
+	u32     ADTNUM;         /* Number of Blocks on disk */
+	u32     ADTUSED;        /* Number of Blocks used */
+	u32     ADTFSTSZ;       /* SIZE OF FST */
+	u32     ADTNFST;        /* NUMBER OF FST'S PER BLOCK */
+	u8      ADTDCRED[6];    /* DISK CREATION DATE (YYMMDDHHMMSS) */
+	u8      ADTFLGL;        /* LABEL FLAG BYTE (ADTFLGL) */
+#define ADTCNTRY        0x01    /* Century for disk creation date (0=19, 1=20),
+	                         * corresponds to ADTDCRED. */
+	u8      reserved[1];
+	u32     ADTOFFST;       /* DISK OFFSET WHEN RESERVED */
+	u32     ADTAMNB;        /* ALLOC MAP BLOCK WITH NEXT HOLE */
+	u32     ADTAMND;        /* DISP INTO HBLK DATA OF NEXT HOLE */
+	u32     ADTAMUP;        /* DISP INTO USER PART OF ALLOC MAP */
+	u32     ADTOFCNT;       /* Count of SFS open files for this ADT */
+	u8      ADTSFNAM[8];    /* NAME OF SHARED SEGMENT */
+};
+
+struct FST {
+	u8    FSTFNAME[8];       /* filename */
+	u8    FSTFTYPE[8];       /* filetype */
+	u8    FSTDATEW[2];       /* DATE LAST WRITTEN - MMDD */
+	u8    FSTTIMEW[2];       /* TIME LAST WRITTEN - HHMM */
+	u16   FSTWRPNT;          /* WRITE POINTER - ITEM NUMBER */
+	u16   FSTRDPNT;          /* READ POINTER - ITEM NUMBER */
+	u8    FSTFMODE[2];       /* FILE MODE - LETTER AND NUMBER */
+	u16   FSTRECCT;          /* NUMBER OF LOGICAL RECORDS */
+	u16   FSTFCLPT;          /* FIRST CHAIN LINK POINTER */
+	u8    FSTRECFM;          /* F*1 - RECORD FORMAT - F OR V */
+#define FSTDFIX        0xC6 /* Fixed record format (EBCDIC 'F') */
+#define FSTDVAR        0xE5 /* Variable record format (EBCDIC 'V') */
+	u8    FSTFLAGS;          /* F*2 - FST FLAG BYTE */
+#define FSTRWDSK       0x80 /* READ/WRITE DISK */
+#define FSTRODSK       0x00 /* READ/ONLY DISK */
+#define FSTDSFS        0x10 /* Shared File FST */
+#define FSTXRDSK       0x40 /* EXTENSION OF R/O DISK */
+#define FSTXWDSK       0xC0 /* EXTENSION OF R/W DISK */
+#define FSTEPL         0x20 /* EXTENDED PLIST */
+#define FSTDIA         0x40 /* ITEM AVAILABLE */
+#define FSTDRA         0x01 /* PREVIOUS RECORD NULL */
+#define FSTCNTRY       0x08 /* Century for date last written (0=19, 1=20),\\
+			       corresponds to FSTYEARW, FSTADATI. */
+#define FSTACTRD       0x04 /* ACTIVE FOR READING */
+#define FSTACTWR       0x02 /* ACTIVE FOR WRITING */
+#define FSTACTPT       0x01 /* ACTIVE FROM A POINT */
+#define FSTFILEA       0x07 /* THE FILE IS ACTIVE */
+	u32   FSTLRECL;          /* LOGICAL RECORD LENGTH */
+	u16   FSTBLKCT;          /* NUMBER OF 800 BYTE BLOCKS */
+	u16   FSTYEARW;          /* YEAR LAST WRITTEN */
+	u32   FSTFOP;            /* ALT. FILE ORIGIN POINTER */
+	u32   FSTADBC;           /* ALT. NUMBER OF DATA BLOCKS */
+	u32   FSTAIC;            /* ALT. ITEM COUNT */
+	u8    FSTNLVL;           /* NUMBER OF POINTER BLOCK LEVELS */
+	u8    FSTPTRSZ;          /* LENGTH OF A POINTER ELEMENT */
+	u8    FSTADATI[6];       /* ALT. DATE/TIME(YY MM DD HH MM SS) */
+	u8    FSTREALM;          /* Real filemode */
+	u8    FSTFLAG2;          /* F*3 - FST FLAG BYTE 2 FSTFLAG2 */
+#define FSTPIPEU       0x10 /* Reserved for CMS PIPELINES usage */
+	u8    reserved[2];
+};
+
+#define EDF_LABEL_BLOCK_NO		3
+
+#define EDF_SUPPORTED_BLOCK_SIZE	4096
+
+struct fs {
+	struct ADT ADT;
+	struct list_head files;
+	mutex_t lock;
+	struct device *dev;
+	void *tmp_buf;
+};
+
+struct file {
+	struct FST FST;
+	struct list_head files;
+	mutex_t lock;
+	struct fs *fs;
+	char *buf;
+};
+
+extern struct fs *edf_mount(struct device *dev);
+extern struct file *edf_lookup(struct fs *fs, char *fn, char *ft);
+extern int edf_read_rec(struct file *file, char *buf, u32 recno);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/interrupt.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,103 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __INTERRUPT_H
+#define __INTERRUPT_H
+
+/*
+ * I/O interruptions specific constants & structures
+ */
+struct io_int_code {
+	u32 ssid;
+	u32 param;
+} __attribute__((packed));
+
+#define PSA_INT_GPR	((u64*) 0x200)
+#define PSA_TMP_PSW	((struct psw*) 0x280)
+
+#define IO_INT_OLD_PSW	((void*) 0x170)
+#define IO_INT_NEW_PSW	((void*) 0x1f0)
+#define IO_INT_CODE	((struct io_int_code*) 0xb8)
+
+#define EXT_INT_OLD_PSW	((void*) 0x130)
+#define EXT_INT_NEW_PSW	((void*) 0x1b0)
+#define EXT_INT_CODE	((u16*) 0x86)
+
+#define SVC_INT_OLD_PSW ((void*) 0x140)
+#define SVC_INT_NEW_PSW ((void*) 0x1c0)
+#define SVC_INT_CODE	((u16*) 0x8a)
+
+#define PGM_INT_OLD_PSW	((void*) 0x150)
+#define PGM_INT_NEW_PSW ((void*) 0x1d0)
+#define PGM_INT_ILC	((u8*) 0x8d)
+#define PGM_INT_CODE	((u16*) 0x8e)
+
+/*
+ * Assembly stubs to call the C-handlers
+ */
+extern void IO_INT(void);
+extern void EXT_INT(void);
+extern void SVC_INT(void);
+extern void PGM_INT(void);
+
+/**
+ * local_int_disable - disable interruptions & return old mask
+ */
+#define local_int_disable() ({ \
+	unsigned long __flags; \
+	__asm__ __volatile__ ( \
+		"stnsm 0(%1),0xfc" : "=m" (__flags) : "a" (&__flags) ); \
+	__flags; \
+	})
+
+/**
+ * local_int_restore - restore interrupt mask
+ * x:	mask to restore
+ */
+#define local_int_restore(x) \
+	__asm__ __volatile__("ssm   0(%0)" : : "a" (&x), "m" (x) : "memory")
+
+/**
+ * local_int_restore - restore interrupt mask
+ * x:	mask to restore
+ */
+static inline int interruptable()
+{
+	u8 x;
+
+	__asm__ __volatile__(
+		"stosm   0(%0),0x00"
+		: /* out */
+		: /* in */
+		 "a" (&x),
+		 "m" (x)
+		: /* clobber */
+		 "memory"
+	);
+
+	return (x & 0x43) != 0;
+}
+
+extern void set_timer(void);
+
+/*
+ * The Supervisor-Service call table
+ */
+#define SVC_SCHEDULE		0
+#define SVC_SCHEDULE_BLOCKED	1
+#define NR_SVC			2
+extern u64 svc_table[NR_SVC];
+
+/* Interrupt handlers */
+extern void __pgm_int_handler(void);
+extern void __ext_int_handler(void);
+extern void __io_int_handler(void);
+
+/* Interrupt handler stack pointer */
+extern u8 *int_stack_ptr;
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/io.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,40 @@
+/*
+ * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
+ *
+ * This file is released under the GPLv2.  See the COPYING file for more
+ * details.
+ */
+
+#ifndef __IO_H
+#define __IO_H
+
+#include <channel.h>
+#include <atomic.h>
+#include <list.h>
+
+struct device;
+
+/*
+ * Defines an I/O operation
+ *
+ * This structure contains any and all state one should need to service any
+ * I/O interruption.
+ */
+struct io_op {
+	struct orb orb;		/* Operation Request Block */
+
+	struct list_head list;	/* list of in-flight operations */
+
+	int (*handler)(struct device *dev, struct io_op *ioop, struct irb *irb);
+				/* I/O specific callback */
+	void (*dtor)(struct device *dev, struct io_op *ioop);
+				/* I/O specific destructor */
+
+	int err;		/* return code */
+	atomic_t done;		/* has the operation completed */
+};
+
+extern void init_io(void);
+extern int submit_io(struct device *dev, struct io_op *oop, int flags);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cp/include/list.h	Fri Jun 18 20:41:48 2010 -0400
@@ -0,0 +1,421 @@
+/*
+ * Based on list.h from Linux Kernel
+ */
+
+#ifndef _LINUX_LIST_H
+#define _LINUX_LIST_H
+
+#define LIST_POISON1	((void*) 0x8585858585858585ULL)
+#define LIST_POISON2	((void*) 0x8686868686868686ULL)
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+	struct list_head name = LIST_HEAD_INIT(name)
+
+static inline void INIT_LIST_HEAD(struct list_head *list)
+{
+	list->next = list;
+	list->prev = list;
+}
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head *new,
+			      struct list_head *prev,
+			      struct list_head *next)
+{
+	next->prev = new;
+	new->next = next;
+	new->prev = prev;
+	prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head, head->next);
+}
+
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static inline void list_add_tail(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+	next->prev = prev;
+	prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty() on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	entry->next = LIST_POISON1;
+	entry->prev = LIST_POISON2;
+}
+
+/**
+ * list_replace - replace old entry by new one
+ * @old : the element to be replaced
+ * @new : the new element to insert
+ *
+ * If @old was empty, it will be overwritten.
+ */
+static inline void list_replace(struct list_head *old,
+				struct list_head *new)
+{
+	new->next = old->next;
+	new->next->prev = new;
+	new->prev = old->prev;
+	new->prev->next = new;
+}
+
+static inline void list_replace_init(struct list_head *old,
+					struct list_head *new)
+{
+	list_replace(old, new);
+	INIT_LIST_HEAD(old);
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static inline void list_del_init(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_move - delete from one list and add as another's head
+ * @list: the entry to move
+ * @head: the head that will precede our entry
+ */
+static inline void list_move(struct list_head *list, struct list_head *head)
+{
+	__list_del(list->prev, list->next);
+	list_add(list, head);
+}
+
+/**
+ * list_move_tail - delete from one list and add as another's tail
+ * @list: the entry to move
+ * @head: the head that will follow our entry
+ */
+static inline void list_move_tail(struct list_head *list,
+				  struct list_head *head)
+{
+	__list_del(list->prev, list->next);
+	list_add_tail(list, head);
+}
+
+/**
+ * list_is_last - tests whether @list is the last entry in list @head
+ * @list: the entry to test
+ * @head: the head of the list
+ */
+static inline int list_is_last(const struct list_head *list,
+				const struct list_head *head)
+{
+	return list->next == head;
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(const struct list_head *head)
+{
+	return head->next == head;
+}
+
+/**
+ * list_empty_careful - tests whether a list is empty and not being modified
+ * @head: the list to test
+ *
+ * Description:
+ * tests whether a list is empty _and_ checks that no other CPU might be
+ * in the process of modifying either member (next or prev)
+ *
+ * NOTE: using list_empty_careful() without synchronization
+ * can only be safe if the only activity that can happen
+ * to the list entry is list_del_init(). Eg. it cannot be used
+ * if another CPU could re-list_add() it.
+ */
+static inline int list_empty_careful(const struct list_head *head)
+{
+	struct list_head *next = head->next;
+	return (next == head) && (next == head->prev);
+}
+
+static inline void __list_splice(struct list_head *list,
+				 struct list_head *head)
+{
+	struct list_head *first = list->next;
+	struct list_head *last = list->prev;
+	struct list_head *at = head->next;
+
+	first->prev = head;
+	head->next = first;
+
+	last->next = at;
+	at->prev = last;
+}
+
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static inline void list_splice(struct list_head *list, struct list_head *head)
+{
+	if (!list_empty(list))
+		__list_splice(list, head);
+}
+
+/**
+ * list_splice_init - join two lists and reinitialise the emptied list.
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ *
+ * The list at @list is reinitialised
+ */
+static inline void list_splice_init(struct list_head *list,
+				    struct list_head *head)
+{
+	if (!list_empty(list)) {
+		__list_splice(list, head);
+		INIT_LIST_HEAD(list);
+	}
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr:	the &struct list_head pointer.
+ * @type:	the type of the struct this is embedded in.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+	container_of(ptr, type, member)
+
+/**
+ * list_first_entry - get the first element from a list
+ * @ptr:	the list head to take the element from.
+ * @type:	the type of the struct this is embedded in.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Note, that list is expected to be not empty.
+ */
+#define list_first_entry(ptr, type, member) \
+	list_entry((ptr)->next, type, member)
+
+/**
+ * list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop cursor.
+ * @head:	the head for your list.
+ */
+#define list_for_each(pos, head) \
+	for (pos = (head)->next; prefetch(pos->next), pos != (head); \
+		pos = pos->next)
+
+/**
+ * __list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop cursor.
+ * @head:	the head for your list.
+ *
+ * This variant differs from list_for_each() in that it's the
+ * simplest possible list iteration code, no prefetching is done.
+ * Use this for code that knows the list to be very short (empty
+ * or 1 entry) most of the time.
+ */
+#define __list_for_each(pos, head) \
+	for (pos = (head)->next; pos != (head); pos = pos->next)
+
+/**
+ * list_for_each_prev	-	iterate over a list backwards
+ * @pos:	the &struct list_head to use as a loop cursor.
+ * @head:	the head for your list.
+ */
+#define list_for_each_prev(pos, head) \
+	for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
+		pos = pos->prev)
+
+/**
+ * list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos:	the &struct list_head to use as a loop cursor.
+ * @n:		another &struct list_head to use as temporary storage
+ * @head:	the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+	for (pos = (head)->next, n = pos->next; pos != (head); \
+		pos = n, n = pos->next)
+
+/**
+ * list_for_each_entry	-	iterate over list of given type
+ * @pos:	the type * to use as a loop cursor.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry(pos, head, member)				\
+	for (pos = list_entry((head)->next, typeof(*pos), member);	\
+	     &pos->member != (head);					\
+	     pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * @pos:	the type * to use as a loop cursor.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_reverse(pos, head, member)			\
+	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
+	     prefetch(pos->member.prev), &pos->member != (head);	\
+	     pos = list_entry(pos->member.prev, typeof(*pos), member))
+
+/**
+ * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
+ * @pos:	the type * to use as a start point
+ * @head:	the head of the list
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
+ */
+#define list_prepare_entry(pos, head, member) \
+	((pos) ? : list_entry(head, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_continue - continue iteration over list of given type
+ * @pos:	the type * to use as a loop cursor.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Continue to iterate over list of given type, continuing after
+ * the current position.
+ */
+#define list_for_each_entry_continue(pos, head, member)			\
+	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
+	     prefetch(pos->member.next), &pos->member != (head);	\
+	     pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_from - iterate over list of given type from the current point
+ * @pos:	the type * to use as a loop cursor.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Iterate over list of given type, continuing from current position.
+ */
+#define list_for_each_entry_from(pos, head, member)			\
+	for (; prefetch(pos->member.next), &pos->member != (head);	\
+	     pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @pos:	the type * to use as a loop cursor.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe(pos, n, head, member)			\
+	for (pos = list_entry((head)->next, typeof(*pos), member),	\
+		n = list_entry(pos->member.next, typeof(*pos), member);	\
+	     &pos->member != (head);					\
+	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+/**
+ * list_for_each_entry_safe_continue
+ * @pos:	the type * to use as a loop cursor.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Iterate over list of given type, continuing after current point,
+ * safe against removal of list entry.
+ */
+#define list_for_each_entry_safe_continue(pos, n, head, member)			\
+	for (pos = list_entry(pos->member.next, typeof(*pos), member),		\
+		n = list_entry(pos->member.next, typeof(*pos), member);		\
+	     &pos->member != (head);						\
+	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+/**
+ * list_for_each_entry_safe_from
+ * @pos:	the type * to use as a loop cursor.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Iterate over list of given type from current point, safe against
+ * removal of list entry.
+ */
+#define list_for_each_entry_safe_from(pos, n, head, member)			\
+	for (n = list_entry(pos->member.next, typeof(*pos), member);		\
+	     &pos->member != (head);						\
+	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+/**
+ * list_for_each_entry_safe_reverse
+ * @pos:	the type * to use as a loop cursor.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ *
+ * Iterate backwards over list of given type, safe against removal
+ * of list entry.
+ */
+#define list_for_each_entry_safe_reverse(pos, n, head, member)		\
+	for (pos = list_entry((head)->prev, typeof(*pos), member),	\
+		n = list_entry(pos->member.prev, typeof(*pos), member);	\
+	     &pos->member != (head);					\
+	     pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+
+#endif