[SCM] Debian GNU Mach packaging branch, master, updated. debian/2%1.3.99.dfsg.git20111010-1-5-gaccdec3

[Samuel Thibault]

The following commit has been merged in the master branch:
commit accdec3fbfc12878f1e4668130651dd1f4a51906
Author: Samuel Thibault <address@hidden>
Date:   Wed Feb 15 01:10:42 2012 +0000

    Add DDE experimental support
    
      * debian/patches/70_dde.patch: Add experimental support for irq passing 
and
        physical memory allocation for DDE. Also adds nonetdev boot parameter to
        disable network device drivers.

diff --git a/debian/changelog b/debian/changelog
index 8304ae4..cccbb95 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -7,8 +7,11 @@ gnumach (2:1.3.99.dfsg.git20111010-2) UNRELEASED; urgency=low
     - Add stamp files, and build-indep and build-arch targets.
     - Pass -fno-omit-frame-pointer for -dbg builds, to fix kernel debugger
       traces & co.
+  * debian/patches/70_dde.patch: Add experimental support for irq passing and
+    physical memory allocation for DDE. Also adds nonetdev boot parameter to
+    disable network device drivers.
 
- -- Samuel Thibault <address@hidden>  Tue, 11 Oct 2011 20:59:21 +0200
+ -- Samuel Thibault <address@hidden>  Wed, 15 Feb 2012 01:09:54 +0000
 
 gnumach (2:1.3.99.dfsg.git20111010-1) unstable; urgency=low
 
diff --git a/debian/patches/70_dde.patch b/debian/patches/70_dde.patch
new file mode 100644
index 0000000..cea9dd0
--- /dev/null
+++ b/debian/patches/70_dde.patch
@@ -0,0 +1,706 @@
+diff --git a/Makefrag.am b/Makefrag.am
+index 7180093..26558e7 100644
+--- a/Makefrag.am
++++ b/Makefrag.am
+@@ -285,6 +285,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 \
+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
++ds_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
++ds_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);
+ 
+ void          iowait (io_req_t ior);
+ 
++/* 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 */
+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,90 @@
++/* 
++ * 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  address@hidden
++ *  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 experimental 424242;
++
++#include <mach/std_types.defs>
++
++serverprefix do_;
++serverdemux intr_notify_server;
++
++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 100
++
++#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 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/debian/patches/series b/debian/patches/series
index 6b728b7..a1dfc66 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -6,3 +6,4 @@
 40_iopl_mem.patch
 50_initrd.patch
 60_bigmem.patch
+70_dde.patch

-- 
Debian GNU Mach packaging