summaryrefslogtreecommitdiff
path: root/debian/patches
diff options
context:
space:
mode:
Diffstat (limited to 'debian/patches')
-rw-r--r--debian/patches/00_clean_gfdl.patch15
-rw-r--r--debian/patches/11_ignore_CSIn.patch15
-rw-r--r--debian/patches/12_version_suffix.patch20
-rw-r--r--debian/patches/50_initrd.patch315
-rw-r--r--debian/patches/60_bigmem.patch70
-rw-r--r--debian/patches/70_dde.patch786
-rw-r--r--debian/patches/series5
7 files changed, 1226 insertions, 0 deletions
diff --git a/debian/patches/00_clean_gfdl.patch b/debian/patches/00_clean_gfdl.patch
new file mode 100644
index 0000000..05e2a87
--- /dev/null
+++ b/debian/patches/00_clean_gfdl.patch
@@ -0,0 +1,15 @@
+Mach's GFDL documentation is not DFSG-free, we need to drop the build rules.
+
+Index: b/Makefile.am
+===================================================================
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -117,7 +117,7 @@ include Makefrag.am
+ include tests/Makefrag.am
+
+ # Documentation.
+-include doc/Makefrag.am
++#include doc/Makefrag.am
+
+ #
+ # Kernel Image
diff --git a/debian/patches/11_ignore_CSIn.patch b/debian/patches/11_ignore_CSIn.patch
new file mode 100644
index 0000000..4536672
--- /dev/null
+++ b/debian/patches/11_ignore_CSIn.patch
@@ -0,0 +1,15 @@
+diff --git a/i386/i386at/kd.c b/i386/i386at/kd.c
+index eaeea1b..03c1e06 100644
+--- a/i386/i386at/kd.c
++++ b/i386/i386at/kd.c
+@@ -1754,6 +1754,10 @@ u_char *cp;
+ kd_erase(number[0]);
+ esc_spt = esc_seq;
+ break;
++ case 'n':
++ /* Ignore status/cursor report request */
++ esc_spt = esc_seq;
++ break;
+ case '\0':
+ break; /* not enough yet */
+ default:
diff --git a/debian/patches/12_version_suffix.patch b/debian/patches/12_version_suffix.patch
new file mode 100644
index 0000000..acbdf9f
--- /dev/null
+++ b/debian/patches/12_version_suffix.patch
@@ -0,0 +1,20 @@
+Index: gnumach/configure.ac
+===================================================================
+--- gnumach.orig/configure.ac 2012-06-11 00:49:00.000000000 +0000
++++ gnumach/configure.ac 2012-06-11 00:54:31.000000000 +0000
+@@ -19,6 +19,7 @@
+ m4_include([version.m4])
+ AC_INIT([AC_PACKAGE_NAME], [AC_PACKAGE_VERSION], [AC_PACKAGE_BUGREPORT],
+ [AC_PACKAGE_TARNAME])
++AC_SUBST([PACKAGE_VERSION_SUFFIX])
+ AC_CONFIG_SRCDIR([kern/ipc_kobject.c])
+
+ AC_CONFIG_AUX_DIR([build-aux])
+Index: gnumach/version.c.in
+===================================================================
+--- gnumach.orig/version.c.in 2012-06-11 00:49:00.000000000 +0000
++++ gnumach/version.c.in 2012-06-11 00:49:22.000000000 +0000
+@@ -1,2 +1,2 @@
+ /* @configure_input@ */
+-const char version[] = "@PACKAGE_NAME@ @PACKAGE_VERSION@";
++const char version[] = "@PACKAGE_NAME@ @PACKAGE_VERSION@@PACKAGE_VERSION_SUFFIX@";
diff --git a/debian/patches/50_initrd.patch b/debian/patches/50_initrd.patch
new file mode 100644
index 0000000..3091996
--- /dev/null
+++ b/debian/patches/50_initrd.patch
@@ -0,0 +1,315 @@
+Jérémie Koenig <jk@jk.fr.eu.org>
+Add ramdisk support for d-i.
+
+Index: gnumach/Makefrag.am
+===================================================================
+--- gnumach.orig/Makefrag.am 2010-06-12 03:44:45.000000000 +0200
++++ gnumach/Makefrag.am 2010-06-12 03:45:00.000000000 +0200
+@@ -275,6 +275,8 @@
+ device/net_io.c \
+ device/net_io.h \
+ device/param.h \
++ device/ramdisk.c \
++ device/ramdisk.h \
+ device/subrs.c \
+ device/subrs.h \
+ device/tty.h
+Index: gnumach/i386/i386at/conf.c
+===================================================================
+--- gnumach.orig/i386/i386at/conf.c 2010-06-12 03:44:45.000000000 +0200
++++ gnumach/i386/i386at/conf.c 2010-06-12 03:45:00.000000000 +0200
+@@ -29,6 +29,7 @@
+
+ #include <mach/machine/vm_types.h>
+ #include <device/conf.h>
++#include <device/ramdisk.h>
+
+ extern int timeopen(), timeclose();
+ extern vm_offset_t timemmap();
+@@ -127,6 +128,8 @@
+ nodev },
+ #endif /* MACH_HYP */
+
++ RAMDISK_DEV_OPS,
++
+ #ifdef MACH_KMSG
+ { kmsgname, kmsgopen, kmsgclose, kmsgread,
+ nodev, kmsggetstat, nodev, nomap,
+Index: gnumach/kern/boot_script.c
+===================================================================
+--- gnumach.orig/kern/boot_script.c 2010-06-12 03:44:45.000000000 +0200
++++ gnumach/kern/boot_script.c 2010-06-12 03:45:00.000000000 +0200
+@@ -88,12 +88,20 @@
+ return boot_script_prompt_task_resume (cmd);
+ }
+
++/* Create an initial ramdisk */
++static int
++ramdisk_create (struct cmd *cmd, long *val)
++{
++ return boot_script_ramdisk_create (cmd, (char **) val);
++}
++
+ /* List of builtin symbols. */
+ static struct sym builtin_symbols[] =
+ {
+ { "task-create", VAL_FUNC, (long) create_task, VAL_TASK, 0 },
+ { "task-resume", VAL_FUNC, (long) resume_task, VAL_NONE, 1 },
+ { "prompt-task-resume", VAL_FUNC, (long) prompt_resume_task, VAL_NONE, 1 },
++ { "ramdisk-create", VAL_FUNC, (long) ramdisk_create, VAL_STR, 0 },
+ };
+ #define NUM_BUILTIN (sizeof (builtin_symbols) / sizeof (builtin_symbols[0]))
+
+Index: gnumach/kern/bootstrap.c
+===================================================================
+--- gnumach.orig/kern/bootstrap.c 2010-06-12 03:44:44.000000000 +0200
++++ gnumach/kern/bootstrap.c 2010-06-12 03:45:00.000000000 +0200
+@@ -48,6 +48,7 @@
+ #include <vm/vm_user.h>
+ #include <vm/pmap.h>
+ #include <device/device_port.h>
++#include <device/ramdisk.h>
+
+ #if MACH_KDB
+ #include <machine/db_machdep.h>
+@@ -776,6 +773,23 @@
+ }
+
+ int
++boot_script_ramdisk_create (struct cmd *cmd, char **name)
++{
++ struct multiboot_module *mod = cmd->hook;
++ vm_size_t size = mod->mod_end - mod->mod_start;
++ kern_return_t rc;
++ int no;
++
++ rc = ramdisk_create (size, (void *) phystokv (mod->mod_start), &no);
++ if (rc != KERN_SUCCESS)
++ return BOOT_SCRIPT_MACH_ERROR;
++
++ *name = boot_script_malloc (RAMDISK_NAMESZ);
++ sprintf(*name, RAMDISK_NAME "%d", no);
++ return 0;
++}
++
++int
+ boot_script_task_create (struct cmd *cmd)
+ {
+ kern_return_t rc = task_create(TASK_NULL, FALSE, &cmd->task);
+Index: gnumach/device/ramdisk.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ gnumach/device/ramdisk.c 2010-06-12 05:02:54.000000000 +0200
+@@ -0,0 +1,160 @@
++#include <mach/vm_param.h>
++#include <machine/vm_param.h>
++#include <vm/vm_kern.h>
++#include <vm/vm_user.h>
++#include <device/device_types.h>
++#include <device/ds_routines.h>
++#include <device/conf.h>
++#include <device/ramdisk.h>
++#include <kern/printf.h>
++#include <string.h>
++
++static struct ramdisk {
++ void *data;
++ vm_size_t size;
++} ramdisk[RAMDISK_MAX];
++
++static int ramdisk_num = 0;
++
++/* Initial ramdisks are created from the boot scripts */
++int ramdisk_create(vm_size_t size, const void *initdata, int *out_no)
++{
++ struct ramdisk *rd = &ramdisk[ramdisk_num];
++ int err;
++
++ if(ramdisk_num >= RAMDISK_MAX)
++ return -1;
++
++ /* allocate the memory */
++ rd->size = round_page(size);
++ err = kmem_alloc(kernel_map, (vm_offset_t *) &rd->data, rd->size);
++ if(err != KERN_SUCCESS)
++ return err;
++
++ /* initialize */
++ if(initdata)
++ memcpy(rd->data, initdata, rd->size);
++ else
++ memset(rd->data, 0, rd->size);
++
++ /* report */
++ if(out_no) *out_no = ramdisk_num;
++ printf("%s%d: %lu bytes @%p\n", RAMDISK_NAME, ramdisk_num,
++ (unsigned long) rd->size, rd->data);
++
++ ramdisk_num++;
++ return KERN_SUCCESS;
++}
++
++/* On d_open() we just check whether the ramdisk exists */
++int ramdisk_open(int dev, int mode, io_req_t ior)
++{
++ return (dev < ramdisk_num) ? D_SUCCESS : D_NO_SUCH_DEVICE;
++}
++
++/* d_getstat() is used to query the device characteristics */
++int ramdisk_getstat(int dev, dev_flavor_t flavor, dev_status_t status,
++ mach_msg_type_number_t *status_count)
++{
++ switch(flavor) {
++ case DEV_GET_SIZE:
++ status[DEV_GET_SIZE_DEVICE_SIZE] = ramdisk[dev].size;
++ status[DEV_GET_SIZE_RECORD_SIZE] = RAMDISK_BLOCKSZ;
++ *status_count = DEV_GET_SIZE_COUNT;
++ return D_SUCCESS;
++
++ case DEV_GET_RECORDS:
++ status[DEV_GET_RECORDS_DEVICE_RECORDS]
++ = ramdisk[dev].size / RAMDISK_BLOCKSZ;
++ status[DEV_GET_RECORDS_RECORD_SIZE] = RAMDISK_BLOCKSZ;
++ *status_count = DEV_GET_RECORDS_COUNT;
++ return D_SUCCESS;
++ }
++ return D_INVALID_OPERATION;
++}
++
++/* TODO: implement freeramdisk with setstat() ? */
++
++/* Check the given io request and compute a pointer to the ramdisk data and the
++ * amount to be handled. */
++static int ramdisk_ioreq(int dev, io_req_t ior, void **data, int *amt)
++{
++ vm_offset_t ofs = ior->io_recnum * RAMDISK_BLOCKSZ;
++ if(ofs >= ramdisk[dev].size)
++ return D_INVALID_RECNUM;
++
++ *data = (char*) ramdisk[dev].data + ofs;
++ *amt = ior->io_count;
++ if(ofs + *amt > ramdisk[dev].size)
++ *amt = ramdisk[dev].size - ofs;
++
++ return KERN_SUCCESS;
++}
++
++/* Copy data from a vm_map_copy by mapping it temporarily. */
++static int mem_map_cpy(void *dst, vm_map_copy_t src, int amt)
++{
++ vm_offset_t srcaddr;
++ int err;
++
++ err = vm_map_copyout(device_io_map, &srcaddr, src);
++ if (err != KERN_SUCCESS)
++ return err;
++
++ memcpy(dst, (void *) srcaddr, amt);
++ vm_deallocate(device_io_map, srcaddr, amt);
++ return KERN_SUCCESS;
++}
++
++int ramdisk_read(int dev, io_req_t ior)
++{
++ void *data;
++ int amt, err;
++
++ err = ramdisk_ioreq(dev, ior, &data, &amt);
++ if(err != KERN_SUCCESS)
++ return err;
++
++ err = device_read_alloc (ior, ior->io_count);
++ if (err != KERN_SUCCESS)
++ return err;
++
++ memcpy(ior->io_data, data, amt);
++ ior->io_residual = ior->io_count - amt;
++
++ return D_SUCCESS;
++}
++
++int ramdisk_write(int dev, io_req_t ior)
++{
++ void *data;
++ int amt, err;
++
++ err = ramdisk_ioreq(dev, ior, &data, &amt);
++ if(err != KERN_SUCCESS)
++ return err;
++
++ if (!(ior->io_op & IO_INBAND)) {
++ /* Out-of-band data is transmitted as a vm_map_copy */
++ err = mem_map_cpy(data, (vm_map_copy_t) ior->io_data, amt);
++ if(err != KERN_SUCCESS)
++ return err;
++ } else {
++ /* In-band data can be accessed directly */
++ memcpy(data, ior->io_data, amt);
++ }
++
++ ior->io_residual = ior->io_count - amt;
++ return D_SUCCESS;
++}
++
++vm_offset_t ramdisk_mmap(int dev, vm_offset_t off, vm_prot_t prot)
++{
++ if(dev >= ramdisk_num)
++ return -1;
++ if(off >= ramdisk[dev].size)
++ return -1;
++
++ return pmap_phys_to_frame(kvtophys((vm_offset_t) ramdisk[dev].data + off));
++}
++
+Index: gnumach/device/ramdisk.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ gnumach/device/ramdisk.h 2010-06-12 03:45:00.000000000 +0200
+@@ -0,0 +1,47 @@
++#ifndef _KERN_RAMDISK_H_
++#define _KERN_RAMDISK_H_
++
++#include <vm/pmap.h>
++#include <device/io_req.h>
++#include <device/conf.h>
++
++/* Maximum number of ramdisk devices */
++#define RAMDISK_MAX 4
++
++/* The block size used (userspace requires 512) */
++#define RAMDISK_BLOCKSZ 512
++
++/* Name associated to the ramdisk major */
++#define RAMDISK_NAME "rd"
++#define RAMDISK_NAMESZ (sizeof RAMDISK_NAME + sizeof (int) * 3 + 1)
++
++/* Create a new ramdisk of the given size. On success, if out_no and/or out_ptr
++ * are not NULL, the device number and pointer to the ramdisk's data are stored
++ * there. Returns D_SUCCESS or D_NO_MEMORY. */
++int ramdisk_create(vm_size_t size, const void *initdata, int *out_no);
++
++/* Device operations */
++int ramdisk_open(int, int, io_req_t);
++int ramdisk_getstat(int, dev_flavor_t, dev_status_t, mach_msg_type_number_t *);
++int ramdisk_read(int, io_req_t);
++int ramdisk_write(int, io_req_t);
++vm_offset_t ramdisk_mmap(int, vm_offset_t, vm_prot_t);
++
++/* dev_ops initializer to be used from <machine>/conf.c */
++#define RAMDISK_DEV_OPS { \
++ .d_name = RAMDISK_NAME, \
++ .d_open = ramdisk_open, \
++ .d_close = nulldev, \
++ .d_read = ramdisk_read, \
++ .d_write = ramdisk_write, \
++ .d_getstat = ramdisk_getstat, \
++ .d_setstat = nodev, \
++ .d_mmap = ramdisk_mmap, \
++ .d_async_in = nodev, \
++ .d_reset = nulldev, \
++ .d_port_death = nulldev, \
++ .d_subdev = 0, \
++ .d_dev_info = nodev, \
++ }
++
++#endif
diff --git a/debian/patches/60_bigmem.patch b/debian/patches/60_bigmem.patch
new file mode 100644
index 0000000..737a178
--- /dev/null
+++ b/debian/patches/60_bigmem.patch
@@ -0,0 +1,70 @@
+Push kernel/user limit to 2GiB, so Mach can address up to close to 2GiB memory.
+This makes glibc's local-bigmem.diff patch mandatory.
+
+Index: gnumach/i386/include/mach/i386/vm_param.h
+===================================================================
+--- gnumach.orig/i386/include/mach/i386/vm_param.h 2012-06-10 23:45:02.000000000 +0200
++++ gnumach/i386/include/mach/i386/vm_param.h 2012-07-14 15:57:26.423861314 +0200
+@@ -73,6 +73,6 @@
+ with that.
+ */
+ #define VM_MIN_ADDRESS (0)
+-#define VM_MAX_ADDRESS (0xc0000000UL)
++#define VM_MAX_ADDRESS (0x80000000UL)
+
+ #endif /* _MACH_I386_VM_PARAM_H_ */
+Index: gnumach/i386/Makefrag.am
+===================================================================
+--- gnumach.orig/i386/Makefrag.am 2012-06-10 23:45:02.000000000 +0200
++++ gnumach/i386/Makefrag.am 2012-07-14 15:57:26.427861233 +0200
+@@ -199,7 +199,7 @@ EXTRA_DIST += \
+ i386/ldscript
+ if PLATFORM_at
+ gnumach_LINKFLAGS += \
+- --defsym _START=0xC0100000 \
++ --defsym _START=0x80100000 \
+ --defsym _START_MAP=0x100000 \
+ -T '$(srcdir)'/i386/ldscript
+ endif
+Index: gnumach/i386/i386/vm_param.h
+===================================================================
+--- gnumach.orig/i386/i386/vm_param.h 2012-06-10 23:45:02.000000000 +0200
++++ gnumach/i386/i386/vm_param.h 2012-07-14 15:57:44.559495669 +0200
+@@ -31,7 +31,7 @@
+ /* This can be changed freely to separate kernel addresses from user addresses
+ * for better trace support in kdb; the _START symbol has to be offset by the
+ * same amount. */
+-#define VM_MIN_KERNEL_ADDRESS 0xC0000000UL
++#define VM_MIN_KERNEL_ADDRESS 0x80000000UL
+
+ #ifdef MACH_XEN
+ /* PV kernels can be loaded directly to the target virtual address */
+Index: gnumach/i386/xen/Makefrag.am
+===================================================================
+--- gnumach.orig/i386/xen/Makefrag.am 2012-07-14 15:58:19.998781083 +0200
++++ gnumach/i386/xen/Makefrag.am 2012-07-14 15:58:30.254574271 +0200
+@@ -28,7 +28,7 @@ libkernel_a_SOURCES += \
+
+ if PLATFORM_xen
+ gnumach_LINKFLAGS += \
+- --defsym _START=0xC0000000 \
+- --defsym _START_MAP=0xC0000000 \
++ --defsym _START=0x80000000 \
++ --defsym _START_MAP=0x80000000 \
+ -T '$(srcdir)'/i386/ldscript
+ endif
+Index: gnumach/i386/xen/xen_boothdr.S
+===================================================================
+--- gnumach.orig/i386/xen/xen_boothdr.S 2012-07-14 15:58:13.358914976 +0200
++++ gnumach/i386/xen/xen_boothdr.S 2012-07-14 15:58:39.790381972 +0200
+@@ -22,8 +22,8 @@
+ .ascii "GUEST_OS=GNU Mach"
+ .ascii ",GUEST_VERSION=1.3"
+ .ascii ",XEN_VER=xen-3.0"
+- .ascii ",VIRT_BASE=0xC0000000"
+- .ascii ",ELF_PADDR_OFFSET=0xC0000000"
++ .ascii ",VIRT_BASE=0x80000000"
++ .ascii ",ELF_PADDR_OFFSET=0x80000000"
+ .ascii ",HYPERCALL_PAGE=0x2"
+ #if PAE
+ .ascii ",PAE=yes[extended-cr3]"
diff --git a/debian/patches/70_dde.patch b/debian/patches/70_dde.patch
new file mode 100644
index 0000000..69a5e2e
--- /dev/null
+++ b/debian/patches/70_dde.patch
@@ -0,0 +1,786 @@
+diff --git a/Makefrag.am b/Makefrag.am
+index 5d22504..64abbe9 100644
+--- a/Makefrag.am
++++ b/Makefrag.am
+@@ -204,6 +204,7 @@ libkernel_a_SOURCES += \
+ kern/mach.srv \
+ kern/mach4.srv \
+ kern/gnumach.srv \
++ kern/experimental.srv \
+ kern/mach_debug.srv \
+ kern/mach_host.srv
+
+@@ -280,6 +281,7 @@ libkernel_a_SOURCES += \
+ device/device_types_kernel.h \
+ device/ds_routines.c \
+ device/ds_routines.h \
++ device/intr.c \
+ device/if_ether.h \
+ device/if_hdr.h \
+ device/io_req.h \
+@@ -348,6 +352,7 @@ include_mach_HEADERS = \
+ include/mach/memory_object_default.defs \
+ include/mach/notify.defs \
+ include/mach/std_types.defs \
++ include/mach/experimental.defs \
+ include/mach/alert.h \
+ include/mach/boolean.h \
+ include/mach/boot.h \
+@@ -478,6 +483,7 @@ nodist_libkernel_a_SOURCES += \
+ kern/mach.server.defs.c \
+ kern/mach4.server.defs.c \
+ kern/gnumach.server.defs.c \
++ kern/experimental.server.defs.c \
+ kern/mach_debug.server.defs.c \
+ kern/mach_host.server.defs.c
+ nodist_libkernel_a_SOURCES += \
+@@ -487,6 +493,9 @@ nodist_libkernel_a_SOURCES += \
+ kern/gnumach.server.h \
+ kern/gnumach.server.c \
+ kern/gnumach.server.msgids \
++ kern/experimental.server.h \
++ kern/experimental.server.c \
++ kern/experimental.server.msgids \
+ kern/mach_debug.server.h \
+ kern/mach_debug.server.c \
+ kern/mach_debug.server.msgids \
+@@ -495,6 +504,7 @@ nodist_libkernel_a_SOURCES += \
+ # kern/mach.server.defs
+ # kern/mach4.server.defs
+ # kern/gnumach.server.defs
++# kern/experimental.server.defs
+ # kern/mach_debug.server.defs
+ # kern/mach_host.server.defs
+
+diff --git a/device/ds_routines.c b/device/ds_routines.c
+index 5a6fdd2..b89d70f 100644
+--- a/device/ds_routines.c
++++ b/device/ds_routines.c
+@@ -318,6 +318,43 @@ ds_device_map (device_t dev, vm_prot_t prot, vm_offset_t offset,
+ offset, size, pager, unmap);
+ }
+
++io_return_t
++experimental_device_intr_register (ipc_port_t master_port, int line,
++ int id, int flags, ipc_port_t receive_port)
++{
++#ifdef MACH_XEN
++ return D_INVALID_OPERATION;
++#else /* MACH_XEN */
++ extern int install_user_intr_handler (unsigned int line,
++ unsigned long flags,
++ ipc_port_t dest);
++ io_return_t ret;
++
++ /* Open must be called on the master device port. */
++ if (master_port != master_device_port)
++ return D_INVALID_OPERATION;
++
++ /* XXX: move to arch-specific */
++ if (line < 0 || line >= 16)
++ return D_INVALID_OPERATION;
++
++ ret = insert_intr_entry (line, receive_port);
++ if (ret)
++ return ret;
++ // TODO The original port should be replaced
++ // when the same device driver calls it again,
++ // in order to handle the case that the device driver crashes and restarts.
++ ret = install_user_intr_handler (line, flags, receive_port);
++
++ /* If the port is installed successfully, increase its reference by 1.
++ * Thus, the port won't be destroyed after its task is terminated. */
++ if (ret == 0)
++ ip_reference (receive_port);
++
++ return ret;
++#endif /* MACH_XEN */
++}
++
+ boolean_t
+ ds_notify (mach_msg_header_t *msg)
+ {
+@@ -1820,6 +1857,24 @@ device_writev_trap (mach_device_t device, dev_mode_t mode,
+ return (result);
+ }
+
++kern_return_t
++experimental_device_intr_enable(ipc_port_t master_port, int line, char status)
++{
++#ifdef MACH_XEN
++ return D_INVALID_OPERATION;
++#else /* MACH_XEN */
++ if (master_port != master_device_port)
++ return D_INVALID_OPERATION;
++
++ if (status)
++ /* TODO: better name for generic-to-arch-specific call */
++ enable_irq (line);
++ else
++ disable_irq (line);
++ return 0;
++#endif /* MACH_XEN */
++}
++
+ struct device_emulation_ops mach_device_emulation_ops =
+ {
+ (void*) mach_device_reference,
+diff --git a/device/ds_routines.h b/device/ds_routines.h
+index a00a12d..9d635cf 100644
+--- a/device/ds_routines.h
++++ b/device/ds_routines.h
+@@ -58,4 +58,7 @@ boolean_t ds_write_done(io_req_t);
+ vm_size_t size,
+ mach_port_t *pager);
+
++/* XXX arch-specific */
++extern ipc_port_t intr_rcv_ports[16];
++
+ #endif /* DS_ROUTINES_H */
+diff --git a/device/intr.c b/device/intr.c
+new file mode 100644
+index 0000000..6fca328
+--- /dev/null
++++ b/device/intr.c
+@@ -0,0 +1,198 @@
++#include <device/intr.h>
++#include <device/ds_routines.h>
++#include <kern/queue.h>
++#include <kern/printf.h>
++
++#ifndef MACH_XEN
++// TODO this is only for x86 system
++#define sti() __asm__ __volatile__ ("sti": : :"memory")
++#define cli() __asm__ __volatile__ ("cli": : :"memory")
++
++static boolean_t deliver_intr (int line, ipc_port_t dest_port);
++
++struct intr_entry
++{
++ queue_chain_t chain;
++ ipc_port_t dest;
++ int line;
++ /* The number of interrupts occur since last run of intr_thread. */
++ int interrupts;
++};
++
++static queue_head_t intr_queue;
++/* The total number of unprocessed interrupts. */
++static int tot_num_intr;
++
++static struct intr_entry *
++search_intr (int line, ipc_port_t dest)
++{
++ struct intr_entry *e;
++ queue_iterate (&intr_queue, e, struct intr_entry *, chain)
++ {
++ if (e->dest == dest && e->line == line)
++ return e;
++ }
++ return NULL;
++}
++
++/* This function can only be used in the interrupt handler. */
++void
++queue_intr (int line, ipc_port_t dest)
++{
++ extern void intr_thread ();
++ struct intr_entry *e;
++
++ cli ();
++ e = search_intr (line, dest);
++ assert (e);
++ e->interrupts++;
++ tot_num_intr++;
++ sti ();
++
++ thread_wakeup ((event_t) &intr_thread);
++}
++
++/* insert an interrupt entry in the queue.
++ * This entry exists in the queue until
++ * the corresponding interrupt port is removed.*/
++int
++insert_intr_entry (int line, ipc_port_t dest)
++{
++ int err = 0;
++ struct intr_entry *e, *new;
++ int free = 0;
++
++ new = (struct intr_entry *) kalloc (sizeof (*new));
++ if (new == NULL)
++ return D_NO_MEMORY;
++
++ /* check whether the intr entry has been in the queue. */
++ cli ();
++ e = search_intr (line, dest);
++ if (e)
++ {
++ printf ("the interrupt entry for line %d and port %p has been inserted\n",
++ line, dest);
++ free = 1;
++ err = D_ALREADY_OPEN;
++ goto out;
++ }
++ new->line = line;
++ new->dest = dest;
++ new->interrupts = 0;
++ queue_enter (&intr_queue, new, struct intr_entry *, chain);
++out:
++ sti ();
++ if (free)
++ kfree ((vm_offset_t) new, sizeof (*new));
++ return err;
++}
++
++/* this function should be called when line is disabled. */
++void mark_intr_removed (int line, ipc_port_t dest)
++{
++ struct intr_entry *e;
++
++ e = search_intr (line, dest);
++ if (e)
++ e->dest = NULL;
++}
++
++void
++intr_thread ()
++{
++ struct intr_entry *e;
++ int line;
++ ipc_port_t dest;
++ queue_init (&intr_queue);
++
++ for (;;)
++ {
++ assert_wait ((event_t) &intr_thread, FALSE);
++ cli ();
++ while (tot_num_intr)
++ {
++ int del = 0;
++
++ queue_iterate (&intr_queue, e, struct intr_entry *, chain)
++ {
++ /* if an entry doesn't have dest port,
++ * we should remove it. */
++ if (e->dest == NULL)
++ {
++ del = 1;
++ break;
++ }
++
++ if (e->interrupts)
++ {
++ line = e->line;
++ dest = e->dest;
++ e->interrupts--;
++ tot_num_intr--;
++
++ sti ();
++ deliver_intr (line, dest);
++ cli ();
++ }
++ }
++
++ /* remove the entry without dest port from the queue and free it. */
++ if (del)
++ {
++ assert (!queue_empty (&intr_queue));
++ queue_remove (&intr_queue, e, struct intr_entry *, chain);
++ sti ();
++ kfree ((vm_offset_t) e, sizeof (*e));
++ cli ();
++ }
++ }
++ sti ();
++ thread_block (NULL);
++ }
++}
++
++static boolean_t
++deliver_intr (int line, ipc_port_t dest_port)
++{
++ ipc_kmsg_t kmsg;
++ mach_intr_notification_t *n;
++ mach_port_t dest = (mach_port_t) dest_port;
++
++ if (dest == MACH_PORT_NULL)
++ return FALSE;
++
++ kmsg = ikm_alloc(sizeof *n);
++ if (kmsg == IKM_NULL)
++ return FALSE;
++
++ ikm_init(kmsg, sizeof *n);
++ n = (mach_intr_notification_t *) &kmsg->ikm_header;
++
++ mach_msg_header_t *m = &n->intr_header;
++ mach_msg_type_t *t = &n->intr_type;
++
++ m->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND, 0);
++ m->msgh_size = sizeof *n;
++ m->msgh_seqno = INTR_NOTIFY_MSGH_SEQNO;
++ m->msgh_local_port = MACH_PORT_NULL;
++ m->msgh_remote_port = MACH_PORT_NULL;
++ m->msgh_id = MACH_INTR_NOTIFY;
++
++ t->msgt_name = MACH_MSG_TYPE_INTEGER_32;
++ t->msgt_size = 32;
++ t->msgt_number = 1;
++ t->msgt_inline = TRUE;
++ t->msgt_longform = FALSE;
++ t->msgt_deallocate = FALSE;
++ t->msgt_unused = 0;
++
++ n->intr_header.msgh_remote_port = dest;
++ n->line = line;
++
++ ipc_port_copy_send (dest_port);
++ ipc_mqueue_send_always(kmsg);
++
++ return TRUE;
++}
++#endif /* MACH_XEN */
+--- /dev/null 2012-02-17 19:11:40.849680975 +0100
++++ b/kern/experimental.srv 2012-02-18 22:56:48.192291483 +0100
+@@ -0,0 +1,3 @@
++#define KERNEL_SERVER 1
++
++#include <mach/experimental.defs>
+diff --git a/include/device/intr.defs b/include/device/intr.defs
+new file mode 100644
+index 0000000..368b96c
+--- /dev/null
++++ b/include/mach/experimental.defs
+@@ -0,0 +1,100 @@
++/*
++ * Mach Operating System
++ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
++ * All Rights Reserved.
++ *
++ * Permission to use, copy, modify and distribute this software and its
++ * documentation is hereby granted, provided that both the copyright
++ * notice and this permission notice appear in all copies of the
++ * software, derivative works or modified versions, and any portions
++ * thereof, and that both notices appear in supporting documentation.
++ *
++ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
++ * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
++ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
++ *
++ * Carnegie Mellon requests users of this software to return to
++ *
++ * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
++ * School of Computer Science
++ * Carnegie Mellon University
++ * Pittsburgh PA 15213-3890
++ *
++ * any improvements or extensions that they make and grant Carnegie Mellon
++ * the rights to redistribute these changes.
++ */
++
++subsystem
++#if KERNEL_USER
++ KernelUser
++#endif /* KERNEL_USER */
++#if KERNEL_SERVER
++ KernelServer
++#endif /* KERNEL_SERVER */
++ experimental 424242;
++
++#include <mach/std_types.defs>
++#include <mach/mach_types.defs>
++
++serverprefix experimental_;
++
++type notify_port_t = MACH_MSG_TYPE_MOVE_SEND_ONCE
++ ctype: mach_port_t;
++
++skip; /*simpleroutine mach_intr_notify(
++ notify : notify_port_t;
++ name : int);*/
++
++routine device_intr_register(
++ master_port : mach_port_t;
++ in line : int;
++ in id : int;
++ in flags : int;
++ in receive_port : mach_port_send_t
++ );
++
++/*
++ * enable/disable the specified line.
++ */
++/* XXX: Naming a function taht can disable something "xxx_enable" is confusing. */
++/* Is the disable part actually used at all? AIUI, the kernel IRQ handler
++should always disable the line; and the userspace driver only has to
++reenable it, after acknowledging and handling the interrupt...
++*/
++routine device_intr_enable(
++ master_port : mach_port_t;
++ line : int;
++ status : char);
++
++/*
++ * This routine is created for allocating DMA buffers.
++ * We are going to get a contiguous physical memory
++ * and its physical address in addition to the virtual address.
++ */
++
++ /* XXX
++ This RPC lacks a few additional constraints like boundaries, alignment
++and maybe phase. We may not use them now, but they're important for
++portability (e.g. if GNU Mach supports PAE, drivers that can't use
++physical memory beyond the 4 GiB limit must be able to express it).
++
++> What do you mean by "phase"?
++
++Offset from the alignment. But I don't think it's useful at all in this
++case. Minimum and maximum addresses and alignment should do. Maybe
++boundary crossing but usually, specifying the right alignment and size
++is enough.
++
++For upstream
++inclusion, we need to do it properly: the RPC should return a special
++memory object (similar to device_map() ), which can then be mapped into
++the process address space with vm_map() like any other memory object.
++
++phys_address_t?
++ */
++routine vm_allocate_contiguous(
++ host_priv : host_priv_t;
++ target_task : vm_task_t;
++ out vaddr : vm_address_t;
++ out paddr : vm_address_t;
++ size : vm_size_t);
+diff --git a/include/device/intr.h b/include/device/intr.h
+new file mode 100644
+index 0000000..3c0e1b8
+--- /dev/null
++++ b/include/device/intr.h
+@@ -0,0 +1,17 @@
++#ifndef __INTR_H__
++
++#define __INTR_H__
++
++#include <device/device_types.h>
++
++typedef struct
++{
++ mach_msg_header_t intr_header;
++ mach_msg_type_t intr_type;
++ int line;
++} mach_intr_notification_t;
++
++#define INTR_NOTIFY_MSGH_SEQNO 0
++#define MACH_INTR_NOTIFY 424242
++
++#endif
+diff --git a/kern/startup.c b/kern/startup.c
+index 3bdda16..9f0e692 100644
+--- a/kern/startup.c
++++ b/kern/startup.c
+@@ -70,6 +70,7 @@ extern void vm_pageout();
+ extern void reaper_thread();
+ extern void swapin_thread();
+ extern void sched_thread();
++extern void intr_thread();
+
+ extern void bootstrap_create();
+ extern void device_service_create();
+@@ -231,6 +232,9 @@ void start_kernel_threads()
+ (void) kernel_thread(kernel_task, reaper_thread, (char *) 0);
+ (void) kernel_thread(kernel_task, swapin_thread, (char *) 0);
+ (void) kernel_thread(kernel_task, sched_thread, (char *) 0);
++#ifndef MACH_XEN
++ (void) kernel_thread(kernel_task, intr_thread, (char *)0);
++#endif /* MACH_XEN */
+
+ #if NCPUS > 1
+ /*
+diff --git a/linux/dev/arch/i386/kernel/irq.c b/linux/dev/arch/i386/kernel/irq.c
+index 41bdaa3..974eaf8 100644
+--- a/linux/dev/arch/i386/kernel/irq.c
++++ b/linux/dev/arch/i386/kernel/irq.c
+@@ -83,6 +83,7 @@ struct linux_action
+ void *dev_id;
+ struct linux_action *next;
+ unsigned long flags;
++ volatile ipc_port_t delivery_port;
+ };
+
+ static struct linux_action *irq_action[16] =
+@@ -102,6 +103,7 @@ linux_intr (int irq)
+ {
+ struct pt_regs regs;
+ struct linux_action *action = *(irq_action + irq);
++ struct linux_action **prev = &irq_action[irq];
+ unsigned long flags;
+
+ kstat.interrupts[irq]++;
+@@ -113,7 +115,37 @@ linux_intr (int irq)
+
+ while (action)
+ {
+- action->handler (irq, action->dev_id, &regs);
++ // TODO I might need to check whether the interrupt belongs to
++ // the current device. But I don't do it for now.
++ if (action->delivery_port)
++ {
++ /* The reference of the port was increased
++ * when the port was installed.
++ * If the reference is 1, it means the port should
++ * have been destroyed and I destroy it now. */
++ if (action->delivery_port
++ && action->delivery_port->ip_references == 1)
++ {
++ mark_intr_removed (irq, action->delivery_port);
++ ipc_port_release (action->delivery_port);
++ *prev = action->next;
++ printk ("irq handler %d: release an dead delivery port\n", irq);
++ linux_kfree(action);
++ action = *prev;
++ continue;
++ }
++ else
++ {
++ /* We disable the irq here and it will be enabled
++ * after the interrupt is handled by the user space driver. */
++ disable_irq (irq);
++ queue_intr (irq, action->delivery_port);
++ }
++
++ }
++ else if (action->handler)
++ action->handler (irq, action->dev_id, &regs);
++ prev = &action->next;
+ action = action->next;
+ }
+
+@@ -233,6 +265,7 @@ setup_x86_irq (int irq, struct linux_action *new)
+ }
+ while (old);
+ shared = 1;
++ printk("store a new irq %d", irq);
+ }
+
+ save_flags (flags);
+@@ -250,6 +283,51 @@ setup_x86_irq (int irq, struct linux_action *new)
+ return 0;
+ }
+
++int
++install_user_intr_handler (unsigned int irq, unsigned long flags,
++ ipc_port_t dest)
++{
++ struct linux_action *action;
++ struct linux_action *old;
++ int retval;
++
++ assert (irq < 16);
++
++ /* Test whether the irq handler has been set */
++ // TODO I need to protect the array when iterating it.
++ old = irq_action[irq];
++ while (old)
++ {
++ if (old->delivery_port == dest)
++ {
++ printk ("The interrupt handler has been installed on line %d", irq);
++ return linux_to_mach_error (-EAGAIN);
++ }
++ old = old->next;
++ }
++
++ /*
++ * Hmm... Should I use `kalloc()' ?
++ * By OKUJI Yoshinori.
++ */
++ action = (struct linux_action *)
++ linux_kmalloc (sizeof (struct linux_action), GFP_KERNEL);
++ if (action == NULL)
++ return linux_to_mach_error (-ENOMEM);
++
++ action->handler = NULL;
++ action->next = NULL;
++ action->dev_id = NULL;
++ action->flags = flags;
++ action->delivery_port = dest;
++
++ retval = setup_x86_irq (irq, action);
++ if (retval)
++ linux_kfree (action);
++
++ return linux_to_mach_error (retval);
++}
++
+ /*
+ * Attach a handler to an IRQ.
+ */
+@@ -278,6 +356,7 @@ request_irq (unsigned int irq, void (*handler) (int, void *, struct pt_regs *),
+ action->next = NULL;
+ action->dev_id = dev_id;
+ action->flags = flags;
++ action->delivery_port = NULL;
+
+ retval = setup_x86_irq (irq, action);
+ if (retval)
+diff --git a/vm/vm_user.c b/vm/vm_user.c
+index 59c2a36..6cd9d77 100644
+--- a/vm/vm_user.c
++++ b/vm/vm_user.c
+@@ -413,3 +413,117 @@ kern_return_t vm_wire(host, map, start, size, access)
+ round_page(start+size),
+ access);
+ }
++
++void vm_pages_release(npages, pages, external)
++ int npages;
++ vm_page_t *pages;
++ boolean_t external;
++{
++ int i;
++
++ for (i = 0; i < npages; i++)
++ {
++ vm_page_release (pages[i], external);
++ }
++}
++
++kern_return_t experimental_vm_allocate_contiguous(host_priv, map, result_vaddr, result_paddr, size)
++ host_t host_priv;
++ vm_map_t map;
++ vm_address_t *result_vaddr;
++ vm_address_t *result_paddr;
++ vm_size_t size;
++{
++ extern vm_size_t vm_page_big_pagenum;
++ extern vm_offset_t phys_first_addr;
++ extern vm_offset_t phys_last_addr;
++
++ int npages;
++ int i;
++ vm_page_t *pages;
++ vm_object_t object;
++ vm_map_entry_t entry;
++ kern_return_t kr;
++ vm_address_t vaddr;
++ vm_offset_t offset = 0;
++
++ if (host_priv == HOST_NULL)
++ return KERN_INVALID_HOST;
++
++ if (map == VM_MAP_NULL)
++ return KERN_INVALID_TASK;
++
++ size = round_page(size);
++
++ /* We allocate the contiguous physical pages for the buffer. */
++
++ npages = size / PAGE_SIZE;
++ pages = (vm_page_t) kalloc (npages * sizeof (vm_page_t));
++ if (pages == NULL)
++ {
++ return KERN_RESOURCE_SHORTAGE;
++ }
++
++ if (vm_page_big_pagenum == 0)
++ vm_page_big_pagenum = atop(phys_last_addr - phys_first_addr);
++
++ kr = vm_page_grab_contiguous_pages(npages, pages, NULL, TRUE);
++ if (kr)
++ {
++ kfree (pages, npages * sizeof (vm_page_t));
++ return kr;
++ }
++
++ /* Allocate the object
++ * and find the virtual address for the DMA buffer */
++
++ object = vm_object_allocate(size);
++ vm_map_lock(map);
++ /* TODO user_wired_count might need to be set as 1 */
++ kr = vm_map_find_entry(map, &vaddr, size, (vm_offset_t) 0,
++ VM_OBJECT_NULL, &entry);
++ if (kr != KERN_SUCCESS)
++ {
++ vm_map_unlock(map);
++ vm_object_deallocate(object);
++ kfree (pages, npages * sizeof (vm_page_t));
++ vm_pages_release (npages, pages, TRUE);
++ return kr;
++ }
++
++ entry->object.vm_object = object;
++ entry->offset = 0;
++
++ /* We can unlock map now. */
++ vm_map_unlock(map);
++
++ /* We have physical pages we need and now we need to do the mapping. */
++
++ pmap_pageable (map->pmap, vaddr, vaddr + size, FALSE);
++
++ *result_vaddr = vaddr;
++ *result_paddr = pages[0]->phys_addr;
++
++ for (i = 0; i < npages; i++)
++ {
++ vm_object_lock(object);
++ vm_page_lock_queues();
++ vm_page_insert(pages[i], object, offset);
++ vm_page_wire(pages[i]);
++ vm_page_unlock_queues();
++ vm_object_unlock(object);
++
++ /* Enter it in the kernel pmap */
++ PMAP_ENTER(map->pmap, vaddr, pages[i], VM_PROT_DEFAULT, TRUE);
++
++ vm_object_lock(object);
++ PAGE_WAKEUP_DONE(pages[i]);
++ vm_object_unlock(object);
++
++ vaddr += PAGE_SIZE;
++ offset += PAGE_SIZE;
++ }
++
++ kfree ((vm_offset_t) pages, npages * sizeof (vm_page_t));
++ return KERN_SUCCESS;
++}
+diff --git a/linux/dev/drivers/block/genhd.c b/linux/dev/drivers/block/genhd.c
+index 95b499b..c360af6 100644
+--- a/linux/dev/drivers/block/genhd.c
++++ b/linux/dev/drivers/block/genhd.c
+@@ -786,7 +786,9 @@ void device_setup(void)
+ #ifdef MACH
+ linux_intr_pri = SPL6;
+ #endif
+- net_dev_init();
++ extern char *kernel_cmdline;
++ if (!strstr(kernel_cmdline, " nonetdev"))
++ net_dev_init();
+ #endif
+ #ifndef MACH
+ console_map_init();
+diff --git a/kern/ipc_kobject.c b/kern/ipc_kobject.c
+index c922d7f..078b1d0 100644
+--- a/kern/ipc_kobject.c
++++ b/kern/ipc_kobject.c
+@@ -151,7 +151,8 @@ ipc_kobject_server(request)
+ device_server_routine(),
+ device_pager_server_routine(),
+ mach4_server_routine(),
+- gnumach_server_routine();
++ gnumach_server_routine(),
++ experimental_server_routine();
+ #if MACH_DEBUG
+ extern mig_routine_t mach_debug_server_routine();
+ #endif
+@@ -170,6 +171,7 @@ ipc_kobject_server(request)
+ #endif /* MACH_DEBUG */
+ || (routine = mach4_server_routine(&request->ikm_header)) != 0
+ || (routine = gnumach_server_routine(&request->ikm_header)) != 0
++ || (routine = experimental_server_routine(&request->ikm_header)) != 0
+ #if MACH_MACHINE_ROUTINES
+ || (routine = MACHINE_SERVER_ROUTINE(&request->ikm_header)) != 0
+ #endif /* MACH_MACHINE_ROUTINES */
diff --git a/debian/patches/series b/debian/patches/series
new file mode 100644
index 0000000..a95f927
--- /dev/null
+++ b/debian/patches/series
@@ -0,0 +1,5 @@
+11_ignore_CSIn.patch
+12_version_suffix.patch
+50_initrd.patch
+60_bigmem.patch
+70_dde.patch
generated by cgit v1.2.3 (git 2.51.0) at 2026-01-04 00:07:24 +0000