initial commit

2 files changed, 600 insertions, 0 deletions

diff --git a/patches/gnumach/50_initrd.patch b/patches/gnumach/50_initrd.patch
new file mode 100644
index 0000000..4b0226e
--- /dev/null
+++ b/patches/gnumach/50_initrd.patch
@@ -0,0 +1,326 @@
+Jérémie Koenig <jk@jk.fr.eu.org>
+Add ramdisk support for d-i.
+
+Index: gnumach/Makefrag.am
+===================================================================
+--- gnumach.orig/Makefrag.am
++++ gnumach/Makefrag.am
+@@ -324,6 +324,8 @@ libkernel_a_SOURCES += \
+ 	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
++++ gnumach/i386/i386at/conf.c
+@@ -31,6 +31,7 @@
+ #include <device/conf.h>
+ #include <kern/mach_clock.h>
+ #include <i386at/model_dep.h>
++#include <device/ramdisk.h>
+ 
+ #define	timename		"time"
+ 
+@@ -138,6 +139,8 @@ struct dev_ops	dev_name_list[] =
+ 	  nodev_info },
+ #endif	/* MACH_HYP */
+ 
++	RAMDISK_DEV_OPS,
++
+ #ifdef	MACH_KMSG
+         { kmsgname,     kmsgopen,       kmsgclose,       kmsgread,
+           nulldev_write,        kmsggetstat,    nulldev_setstat,           nomap,
+Index: gnumach/kern/boot_script.c
+===================================================================
+--- gnumach.orig/kern/boot_script.c
++++ gnumach/kern/boot_script.c
+@@ -90,12 +90,20 @@ prompt_resume_task (struct cmd *cmd, con
+   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
++++ gnumach/kern/bootstrap.c
+@@ -51,6 +51,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>
+@@ -849,6 +850,23 @@ boot_script_free (void *ptr, unsigned in
+ }
+ 
+ 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_kernel(TASK_NULL, FALSE, &cmd->task);
+Index: gnumach/device/ramdisk.c
+===================================================================
+--- /dev/null
++++ gnumach/device/ramdisk.c
+@@ -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(dev_t 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(dev_t 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(dev_t 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(dev_t 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(dev_t 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
++++ gnumach/device/ramdisk.h
+@@ -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(dev_t, int, io_req_t);
++int ramdisk_getstat(dev_t, dev_flavor_t, dev_status_t, mach_msg_type_number_t *);
++int ramdisk_read(dev_t, io_req_t);
++int ramdisk_write(dev_t, io_req_t);
++vm_offset_t ramdisk_mmap(dev_t, 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_close, \
++		.d_read = ramdisk_read, \
++		.d_write = ramdisk_write, \
++		.d_getstat = ramdisk_getstat, \
++		.d_setstat = nulldev_setstat, \
++		.d_mmap = ramdisk_mmap, \
++		.d_async_in = nodev_async_in, \
++		.d_reset = nulldev_reset, \
++		.d_port_death = nulldev_portdeath, \
++		.d_subdev = 0, \
++		.d_dev_info = nodev_info, \
++	}
++
++#endif
+Index: gnumach/kern/bootstrap.h
+===================================================================
+--- gnumach.orig/kern/bootstrap.h
++++ gnumach/kern/bootstrap.h
+@@ -22,5 +22,6 @@
+ #include <kern/boot_script.h>
+ 
+ void bootstrap_create(void);
++int boot_script_ramdisk_create(struct cmd *cmd, char **name);
+ 
+ #endif /* _KERN_BOOTSTRAP_H_ */
diff --git a/patches/gnumach/79_dde-debian.patch b/patches/gnumach/79_dde-debian.patch
new file mode 100644
index 0000000..b6a0f17
--- /dev/null
+++ b/patches/gnumach/79_dde-debian.patch
@@ -0,0 +1,274 @@
+This contains a compatibility layer for netdde and rump still using the experimental irq/alloc_contig support. It is the output of
+
+git diff master master-user_level_drivers-debian
+
+(master was 6054cda4de2341b9a77ec4421411725f3684006b and
+master-user_level_drivers-debian was 19283fdffa782b2e485ef39e0de1574006ec4a1a at
+the time)
+
+When dropping this, break netdde (<< 0.0.20200330-5),
+hurd-libs0.3 (<< hurd_1:0.9.git20200718-1+b1)
+
+---
+ Makefrag.am                     |    1 
+ device/ds_routines.c            |   64 +++++++++++++++++++++++++++++++++++++++-
+ device/intr.c                   |   16 ++++++----
+ device/intr.h                   |    3 +
+ include/mach/experimental.defs  |   38 +++++++++++++++++++++++
+ linux/dev/drivers/block/genhd.c |    4 +-
+ vm/vm_user.c                    |   14 ++++++++
+ 7 files changed, 130 insertions(+), 10 deletions(-)
+
+--- a/Makefrag.am
++++ b/Makefrag.am
+@@ -362,7 +362,6 @@ include_device_HEADERS = \
+ 	include/device/disk_status.h \
+ 	include/device/input.h \
+ 	include/device/net_status.h \
+-	include/device/notify.defs \
+ 	include/device/notify.h \
+ 	include/device/tape_status.h \
+ 	include/device/tty_status.h
+--- a/device/ds_routines.c
++++ b/device/ds_routines.c
+@@ -354,7 +354,7 @@ ds_device_intr_register (device_t dev, i
+   if (! name_equal(mdev->dev_ops->d_name, 3, "irq"))
+     return D_INVALID_OPERATION;
+ 
+-  user_intr_t *e = insert_intr_entry (&irqtab, id, receive_port);
++  user_intr_t *e = insert_intr_entry (&irqtab, id, receive_port, 0);
+   if (!e)
+     return D_NO_MEMORY;
+ 
+@@ -371,6 +371,52 @@ ds_device_intr_register (device_t dev, i
+ #endif /* MACH_XEN */
+ }
+ 
++static ipc_port_t intr_receive_ports[16];
++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 */
++  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;
++
++  if (flags != 0x04000000)
++    return D_INVALID_OPERATION;
++
++  user_intr_t *user_intr = insert_intr_entry (&irqtab, line, receive_port, 1);
++  if (!user_intr)
++    return D_NO_MEMORY;
++
++  // 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 (&irqtab, line, 0, user_intr);
++
++  if (ret == 0)
++  {
++    /* If the port is installed successfully, increase its reference by 1.
++     * Thus, the port won't be destroyed after its task is terminated. */
++    ip_reference (receive_port);
++
++    intr_receive_ports[line] = receive_port;
++    /* For now netdde calls device_intr_enable once after registration. Assume
++     * it does so for now. When we move to IRQ acknowledgment convention we will
++     * change this. */
++    __disable_irq (line);
++  }
++
++  return ret;
++#endif /* MACH_XEN */
++}
++
+ kern_return_t
+ ds_device_intr_ack (device_t dev, ipc_port_t receive_port)
+ {
+@@ -399,6 +445,22 @@ ds_device_intr_ack (device_t dev, ipc_po
+ #endif /* MACH_XEN */
+ }
+ 
++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 != 1)
++    return D_INVALID_OPERATION;
++
++  return irq_acknowledge(intr_receive_ports[line]);
++#endif /* MACH_XEN */
++}
++
+ boolean_t
+ ds_notify (mach_msg_header_t *msg)
+ {
+--- a/device/intr.c
++++ b/device/intr.c
+@@ -25,7 +25,7 @@
+ #ifndef MACH_XEN
+ 
+ queue_head_t main_intr_queue;
+-static boolean_t deliver_intr (int id, ipc_port_t dst_port);
++static boolean_t deliver_intr (int id, mach_msg_id_t msgh_id, ipc_port_t dst_port);
+ 
+ #ifndef LINUX_DEV
+ #define SA_SHIRQ 0x04000000
+@@ -122,7 +122,7 @@ deliver_user_intr (struct irqdev *dev, i
+  * This entry exists in the queue until
+  * the corresponding interrupt port is removed.*/
+ user_intr_t *
+-insert_intr_entry (struct irqdev *dev, int id, ipc_port_t dst_port)
++insert_intr_entry (struct irqdev *dev, int id, ipc_port_t dst_port, int compat)
+ {
+   user_intr_t *e, *new, *ret;
+   int free = 0;
+@@ -146,7 +146,11 @@ insert_intr_entry (struct irqdev *dev, i
+   new->id = id;
+   new->dst_port = dst_port;
+   new->interrupts = 0;
+-  new->n_unacked = 0;
++  new->compat = compat;
++  if (compat)
++    new->n_unacked = 1;
++  else
++    new->n_unacked = 0;
+ 
+   queue_enter (dev->intr_queue, new, user_intr_t *, chain);
+ out:
+@@ -268,7 +272,7 @@ intr_thread (void)
+ 		  irqtab.tot_num_intr--;
+ 
+ 		  splx (s);
+-		  deliver_intr (id, dst_port);
++		  deliver_intr (id, e->compat ? 424242 : DEVICE_INTR_NOTIFY, dst_port);
+ 		  s = splhigh ();
+ 		}
+ 	    }
+@@ -307,7 +311,7 @@ intr_thread (void)
+ }
+ 
+ static boolean_t
+-deliver_intr (int id, ipc_port_t dst_port)
++deliver_intr (int id, mach_msg_id_t msgh_id, ipc_port_t dst_port)
+ {
+   ipc_kmsg_t kmsg;
+   device_intr_notification_t *n;
+@@ -331,7 +335,7 @@ deliver_intr (int id, ipc_port_t dst_por
+   m->msgh_seqno = DEVICE_NOTIFY_MSGH_SEQNO;
+   m->msgh_local_port = MACH_PORT_NULL;
+   m->msgh_remote_port = MACH_PORT_NULL;
+-  m->msgh_id = DEVICE_INTR_NOTIFY;
++  m->msgh_id = msgh_id;
+ 
+   t->msgt_name = MACH_MSG_TYPE_INTEGER_32;
+   t->msgt_size = 32;
+--- a/device/intr.h
++++ b/device/intr.h
+@@ -36,6 +36,7 @@ typedef struct {
+   int n_unacked;  /* Number of times irqs were disabled for this */
+   ipc_port_t dst_port; /* Notification port */
+   int id; /* Mapping to machine dependent irq_t array elem */
++  int compat;
+ } user_intr_t;
+ 
+ struct irqdev {
+@@ -52,7 +53,7 @@ struct irqdev {
+ extern queue_head_t main_intr_queue;
+ extern int install_user_intr_handler (struct irqdev *dev, int id, unsigned long flags, user_intr_t *e);
+ extern int deliver_user_intr (struct irqdev *dev, int id, user_intr_t *e);
+-extern user_intr_t *insert_intr_entry (struct irqdev *dev, int id, ipc_port_t receive_port);
++extern user_intr_t *insert_intr_entry (struct irqdev *dev, int id, ipc_port_t receive_port, int compat);
+ 
+ void intr_thread (void);
+ kern_return_t irq_acknowledge (ipc_port_t receive_port);
+--- a/include/mach/experimental.defs
++++ b/include/mach/experimental.defs
+@@ -13,3 +13,41 @@ subsystem
+ serverprefix experimental_;
+ 
+ /* This is free for experimenting RPCs, with no backward compatibility guarantees.  */
++
++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 for compatibility with old userland drivers.
++ */
++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);
+--- a/linux/dev/drivers/block/genhd.c
++++ b/linux/dev/drivers/block/genhd.c
+@@ -1060,7 +1060,9 @@ void device_setup(void)
+ 	scsi_dev_init();
+ #endif
+ #ifdef CONFIG_INET
+-	net_dev_init();
++	extern char *kernel_cmdline;
++	if (!strstr(kernel_cmdline, " nonetdev"))
++		net_dev_init();
+ #endif
+ #ifndef MACH
+ 	console_map_init();
+--- a/vm/vm_user.c
++++ b/vm/vm_user.c
+@@ -688,3 +688,17 @@ kern_return_t vm_allocate_contiguous(
+ 
+ 	return KERN_SUCCESS;
+ }
++
++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;
++{
++	rpc_phys_addr_t paddr;
++	kern_return_t ret;
++	ret = vm_allocate_contiguous(host_priv, map, result_vaddr, &paddr, size, 0, ~0ULL, 0);
++	*result_paddr = paddr;
++	return ret;
++}