Initial checkin

7 files changed, 1628 insertions, 0 deletions

diff --git a/storeio/dev.c b/storeio/dev.c
new file mode 100644
index 00000000..d9a4e083
--- /dev/null
+++ b/storeio/dev.c
@@ -0,0 +1,414 @@
+/* store `device' I/O
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <hurd.h>
+#include <assert.h>
+#include <string.h>
+#include <hurd/pager.h>
+#include <hurd/store.h>
+
+#include "dev.h"
+
+/* These functions deal with the buffer used for doing non-block-aligned I/O. */
+
+static inline int
+dev_buf_is_active (struct dev *dev)
+{
+  return dev->buf_offs >= 0;
+}
+
+/* Invalidate DEV's buffer, writing it to disk if necessary.  */
+static error_t
+dev_buf_discard (struct dev *dev)
+{
+  if (dev_buf_is_active (dev))
+    {
+      if (dev->buf_dirty)
+	{
+	  size_t amount;
+	  struct store *store = dev->store;
+	  error_t err =
+	    store_write (store, dev->buf_offs >> store->log2_block_size,
+			 dev->buf, store->block_size, &amount);
+	  if (amount < store->block_size)
+	    err = EIO;
+	  if (err)
+	    return err;
+	  dev->buf_dirty = 0;
+	}
+      dev->buf_offs = -1;
+    }
+  return 0;
+}
+
+/* Make DEV's buffer active, reading the block from DEV's store which
+   contains OFFS.  */
+static error_t
+dev_buf_fill (struct dev *dev, off_t offs)
+{
+  error_t err;
+  unsigned block_mask = dev->block_mask;
+  char *buf = dev->buf;
+  struct store *store = dev->store;
+  size_t buf_len = store->block_size;
+
+  if (dev_buf_is_active (dev))
+    if ((dev->buf_offs & ~block_mask) == (offs & ~block_mask))
+      return 0;			/* Correct block alredy in buffer.  */
+    else
+      {
+	err = dev_buf_discard (dev);
+	if (err)
+	  return err;
+      }
+
+  err = store_read (store, offs >> store->log2_block_size, store->block_size,
+		    &buf, &buf_len);
+  if (err)
+    return err;
+
+  if (buf != dev->buf)
+    {
+      vm_deallocate (mach_task_self (),
+		     (vm_address_t)dev->buf, store->block_size);
+      dev->buf = buf;
+    }
+
+  dev->buf_offs = offs & ~block_mask;
+
+  return 0;
+}
+
+/* Do an in-buffer partial-block I/O operation.  */
+static error_t
+dev_buf_rw (struct dev *dev, size_t buf_offs, size_t *io_offs, size_t *len,
+	    inline error_t (*const buf_rw) (size_t buf_offs,
+					    size_t io_offs, size_t len))
+{
+  size_t block_size = dev->store->block_size;
+
+  assert (dev_buf_is_active (dev));
+
+  if (buf_offs + *len >= block_size)
+    /* Only part of BUF lies within the buffer (or everything up
+       to the end of the block, in which case we want to flush
+       the buffer anyway).  */
+    {
+      size_t buf_len = block_size - buf_offs;
+      error_t err = (*buf_rw) (buf_offs, *io_offs, buf_len);
+      if (err)
+	return err;
+      *io_offs += buf_len;
+      *len -= buf_len;
+      return dev_buf_discard (dev);
+    }
+  else
+    /* All I/O is within the block.  */
+    {
+      error_t err = (*buf_rw) (buf_offs, *io_offs, *len);
+      if (err)
+	return err;
+      *io_offs += *len;
+      *len = 0;
+      return 0;
+    }
+}
+
+/* Returns a pointer to a new device structure in DEV for the kernel device
+   NAME, with the given FLAGS.  If BLOCK_SIZE is non-zero, it should be the
+   desired block size, and must be a multiple of the device block size.
+   If an error occurs, the error code is returned, otherwise 0.  */
+error_t
+dev_open (struct store_parsed *name, int flags, struct dev **dev)
+{
+  error_t err;
+  struct dev *new = malloc (sizeof (struct dev));
+
+  if (! new)
+    return ENOMEM;
+
+  err = store_parsed_open (name, flags, 0, &new->store);
+  if (err)
+    {
+      free (new);
+      return err;
+    }
+
+#if 0 /* valloc doesn't work */
+  new->buf = valloc (new->store->block_size);
+  if (new->buf == 0)
+#else
+  if (vm_allocate (mach_task_self (),
+		   (vm_address_t *)&new->buf, new->store->block_size, 1))
+#endif
+    {
+      store_free (new->store);
+      free (new);
+      return ENOMEM;
+    }
+
+  new->buf_offs = -1;
+  rwlock_init (&new->io_lock);
+  new->owner = 0;
+  new->block_mask = (1 << new->store->log2_block_size) - 1;
+  new->pager = 0;
+  mutex_init (&new->pager_lock);
+  *dev = new;
+
+  return 0;
+}
+
+/* Free DEV and any resources it consumes.  */
+void 
+dev_close (struct dev *dev)
+{
+  if (dev->pager != NULL)
+    pager_shutdown (dev->pager);
+
+  dev_buf_discard (dev);
+
+#if 0
+  free (dev->buf);
+#else
+  vm_deallocate (mach_task_self (),
+		 (vm_address_t)dev->buf, dev->store->block_size);
+#endif
+
+  store_free (dev->store);
+
+  free (dev);
+}
+
+/* Try and write out any pending writes to DEV.  If WAIT is true, will wait
+   for any paging activity to cease.  */
+error_t
+dev_sync(struct dev *dev, int wait)
+{
+  error_t err;
+
+  /* Sync any paged backing store.  */
+  if (dev->pager != NULL)
+    pager_sync (dev->pager, wait);
+
+  rwlock_writer_lock (&dev->io_lock);
+  err = dev_buf_discard (dev);
+  rwlock_writer_unlock (&dev->io_lock);
+
+  return err;
+}
+
+/* Takes care of buffering I/O to/from DEV for a transfer at position OFFS,
+   length LEN; the amount of I/O sucessfully done is returned in AMOUNT.
+   BUF_RW is called to do I/O that's entirely inside DEV's internal buffer,
+   and RAW_RW to do I/O directly to DEV's store.  */
+static inline error_t
+buffered_rw (struct dev *dev, off_t offs, size_t len, size_t *amount,
+	     inline error_t (* const buf_rw) (size_t buf_offs,
+					      size_t io_offs, size_t len),
+	     inline error_t (* const raw_rw) (off_t offs,
+					      size_t io_offs, size_t len,
+					      size_t *amount))
+{
+  error_t err = 0;
+  unsigned block_mask = dev->block_mask;
+  unsigned block_size = dev->store->block_size;
+  size_t io_offs = 0;		/* Offset within this I/O operation.  */
+  unsigned block_offs = offs & block_mask; /* Offset within a block.  */
+
+  rwlock_writer_lock (&dev->io_lock);
+
+  if (block_offs != 0)
+    /* The start of the I/O isn't block aligned.  */
+    {
+      err = dev_buf_fill (dev, offs);
+      if (! err)
+	err = dev_buf_rw (dev, block_offs, &io_offs, &len, buf_rw);
+    }
+
+  if (!err && len > 0)
+    /* Now the I/O should be block aligned.  */
+    {
+      if (len >= block_size)
+	{
+	  size_t amount;
+	  err = dev_buf_discard (dev);
+	  if (! err)
+	    err =
+	      (*raw_rw) (offs + io_offs, io_offs, len & ~block_mask, &amount);
+	  if (! err)
+	    {
+	      io_offs += amount;
+	      len -= amount;
+	    }
+	}
+      if (len > 0 && len < block_size)
+	/* All full blocks were written successfully, so write
+	   the tail end into the buffer.  */
+	{
+	  err = dev_buf_fill (dev, offs + io_offs);
+	  if (! err)
+	    err = dev_buf_rw (dev, 0, &io_offs, &len, buf_rw);
+	}
+    }
+
+  if (! err)
+    *amount = io_offs;
+
+  rwlock_writer_unlock (&dev->io_lock);
+
+  return err;
+}
+
+/* Takes care of buffering I/O to/from DEV for a transfer at position OFFS,
+   length LEN, and direction DIR.  BUF_RW is called to do I/O to/from data
+   buffered in DEV, and RAW_RW to do I/O directly to DEV's store.  */
+static inline error_t
+dev_rw (struct dev *dev, off_t offs, size_t len, size_t *amount,
+	inline error_t (* const buf_rw) (size_t buf_offs,
+					 size_t io_offs, size_t len),
+	inline error_t (* const raw_rw) (off_t offs,
+					 size_t io_offs, size_t len,
+					 size_t *amount))
+{
+  error_t err;
+  unsigned block_mask = dev->block_mask;
+
+  if (offs < 0)
+    return EINVAL;
+  else if (offs > dev->store->size)
+    return EIO;
+  else if (offs + len > dev->store->size)
+    len = dev->store->size - offs;
+
+  rwlock_reader_lock (&dev->io_lock);
+  if (dev_buf_is_active (dev)
+      || (offs & block_mask) != 0 || (len & block_mask) != 0)
+    /* Some non-aligned I/O has been done, or is needed, so we need to deal
+       with DEV's buffer, which means getting an exclusive lock.  */
+    {
+      /* Aquire a writer lock instead of a reader lock.  Note that other
+	 writers may have aquired the lock by the time we get it.  */
+      rwlock_reader_unlock (&dev->io_lock);
+      err = buffered_rw (dev, offs, len, amount, buf_rw, raw_rw);
+    }
+  else
+    /* Only block-aligned I/O is being done, so things are easy.  */
+    {
+      err = (*raw_rw) (offs, 0, len, amount);
+      rwlock_reader_unlock (&dev->io_lock);
+    }
+
+  return err;
+}
+
+/* Write LEN bytes from BUF to DEV, returning the amount actually written in
+   AMOUNT.  If successful, 0 is returned, otherwise an error code is
+   returned.  */
+error_t
+dev_write (struct dev *dev, off_t offs, char *buf, size_t len,
+	   size_t *amount)
+{
+  error_t buf_write (size_t buf_offs, size_t io_offs, size_t len)
+    {
+      bcopy (buf + io_offs, dev->buf + buf_offs, len);
+      dev->buf_dirty = 1;
+      return 0;
+    }
+  error_t raw_write (off_t offs, size_t io_offs, size_t len, size_t *amount)
+    {
+      struct store *store = dev->store;
+      return
+	store_write (store, offs >> store->log2_block_size,
+		     buf + io_offs, len, amount);
+    }
+
+  return dev_rw (dev, offs, len, amount, buf_write, raw_write);
+}
+
+/* Read up to WHOLE_AMOUNT bytes from DEV, returned in BUF and LEN in the
+   with the usual mach memory result semantics.  If successful, 0 is
+   returned, otherwise an error code is returned.  */
+error_t
+dev_read (struct dev *dev, off_t offs, size_t whole_amount,
+	  char **buf, size_t *len)
+{
+  error_t err;
+  int allocated_buf = 0;
+  error_t ensure_buf ()
+    {
+      error_t err;
+      if (*len < whole_amount)
+	{
+	  err = vm_allocate (mach_task_self (),
+			     (vm_address_t *)buf, whole_amount, 1);
+	  if (! err)
+	    allocated_buf = 1;
+	}
+      else
+	err = 0;
+      return err;
+    }
+  error_t buf_read (size_t buf_offs, size_t io_offs, size_t len)
+    {
+      error_t err = ensure_buf ();
+      if (! err)
+	bcopy (dev->buf + buf_offs, *buf + io_offs, len);
+      return err;
+    }
+  error_t raw_read (off_t offs, size_t io_offs, size_t len, size_t *amount)
+    {
+      struct store *store = dev->store;
+      off_t addr = offs >> store->log2_block_size;
+      if (len == whole_amount)
+	/* Just return whatever the device does.  */
+	return store_read (store, addr, len, buf, amount);
+      else
+	/* This read is returning less than the whole request, so we allocate
+	   a buffer big enough to hold everything, in case we have to
+	   coalesce multiple reads into a single return buffer.  */
+	{
+	  error_t err = ensure_buf ();
+	  if (! err)
+	    {
+	      char *_req_buf = *buf + io_offs, *req_buf = _req_buf;
+	      size_t req_len = len;
+	      err = store_read (store, addr, len, &req_buf, &req_len);
+	      if (! err)
+		{
+		  if (req_buf != _req_buf)
+		    /* Copy from wherever the read put it. */
+		    {
+		      bcopy (req_buf, _req_buf, req_len);
+		      vm_deallocate (mach_task_self (),
+				     (vm_address_t)req_buf, req_len);
+		    }
+		  *amount = req_len;
+		}
+	    }
+	  return err;
+	}
+    }
+
+  err = dev_rw (dev, offs, whole_amount, len, buf_read, raw_read);
+  if (err && allocated_buf)
+    vm_deallocate (mach_task_self (), (vm_address_t)*buf, whole_amount);
+
+  return err;
+}     
diff --git a/storeio/dev.h b/storeio/dev.h
new file mode 100644
index 00000000..8ef64090
--- /dev/null
+++ b/storeio/dev.h
@@ -0,0 +1,101 @@
+/* store `device' I/O
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef __DEV_H__
+#define __DEV_H__
+
+#include <mach.h>
+#include <device/device.h>
+#include <rwlock.h>
+#include <hurd/store.h>
+
+/* Information about a kernel device.  */
+struct dev
+{
+  /* The device to which we're doing io.  */
+  struct store *store;
+
+  /* A bitmask corresponding to the part of an offset that lies within a
+     device block.  */
+  unsigned block_mask;
+
+  /* Lock to arbitrate I/O through this device.  Block I/O can occur in
+     parallel, and requires only a reader-lock.
+     Non-block I/O is always serialized, and requires a writer-lock.  */
+  struct rwlock io_lock;
+
+  /* Non-block I/O is buffered through BUF.  BUF_OFFS is the device offset
+     corresponding to the start of BUF (which holds one block); if it is -1,
+     then BUF is inactive.  */
+  char *buf;
+  off_t buf_offs;
+  int buf_dirty;
+
+  struct pager *pager;
+  struct mutex pager_lock;
+
+  /* The current owner of the open device.  For terminals, this affects
+     controlling terminal behavior (see term_become_ctty).  For all objects
+     this affects old-style async IO.  Negative values represent pgrps.  This
+     has nothing to do with the owner of a file (as returned by io_stat, and
+     as used for various permission checks by filesystems).  An owner of 0
+     indicates that there is no owner.  */
+  pid_t owner;
+};
+
+/* Returns a pointer to a new device structure in DEV for the device
+   NAME, with the given FLAGS.  If BLOCK_SIZE is non-zero, it should be the
+   desired block size, and must be a multiple of the device block size.
+   If an error occurs, the error code is returned, otherwise 0.  */
+error_t dev_open (struct store_parsed *name, int flags, struct dev **dev);
+
+/* Free DEV and any resources it consumes.  */
+void dev_close (struct dev *dev);
+
+/* Returns in MEMOBJ the port for a memory object backed by the storage on
+   DEV.  Returns 0 or the error code if an error occurred.  */
+error_t dev_get_memory_object(struct dev *dev, memory_object_t *memobj);
+
+/* Try to stop all paging activity on DEV, returning true if we were
+   successful.  If NOSYNC is true, then we won't write back any (kernel)
+   cached pages to the device.  */
+int dev_stop_paging (struct dev *dev, int nosync);
+
+/* Try and write out any pending writes to DEV.  If WAIT is true, will wait
+   for any paging activity to cease.  */
+error_t dev_sync (struct dev *dev, int wait);
+
+#ifdef MSG
+char *brep(vm_address_t buf, vm_size_t len);
+#endif
+
+/* Write LEN bytes from BUF to DEV, returning the amount actually written in
+   AMOUNT.  If successful, 0 is returned, otherwise an error code is
+   returned.  */
+error_t dev_write (struct dev *dev, off_t offs, char *buf, size_t len,
+		   size_t *amount);
+
+/* Read up to AMOUNT bytes from DEV, returned in BUF and LEN in the with the
+   usual mach memory result semantics.  If successful, 0 is returned,
+   otherwise an error code is returned.  */
+error_t dev_read (struct dev *dev, off_t offs, size_t amount,
+		  char **buf, size_t *len);
+
+#endif /* !__DEV_H__ */
diff --git a/storeio/io.c b/storeio/io.c
new file mode 100644
index 00000000..f8067698
--- /dev/null
+++ b/storeio/io.c
@@ -0,0 +1,329 @@
+/* The hurd io interface to storeio
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <hurd/trivfs.h>
+#include <stdio.h>
+#include <fcntl.h>
+
+#include "open.h"
+#include "dev.h"
+
+/* Return objects mapping the data underlying this memory object.  If
+   the object can be read then memobjrd will be provided; if the
+   object can be written then memobjwr will be provided.  For objects
+   where read data and write data are the same, these objects will be
+   equal, otherwise they will be disjoint.  Servers are permitted to
+   implement io_map but not io_map_cntl.  Some objects do not provide
+   mapping; they will set none of the ports and return an error.  Such
+   objects can still be accessed by io_read and io_write.  */
+error_t
+trivfs_S_io_map (struct trivfs_protid *cred,
+		 memory_object_t *rd_obj, mach_msg_type_name_t *rd_type,
+		 memory_object_t *wr_obj, mach_msg_type_name_t *wr_type)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    {
+      mach_port_t memobj;
+      struct open *open = (struct open *)cred->po->hook;
+      error_t err = dev_get_memory_object (open->dev, &memobj);
+
+      if (!err)
+	{
+	  if (cred->po->openmodes & O_READ)
+	    {
+	      *rd_obj = memobj;
+	      *rd_type = MACH_MSG_TYPE_MOVE_SEND;
+	    }
+	  else
+	    *rd_obj = MACH_PORT_NULL;
+
+	  if (cred->po->openmodes & O_WRITE)
+	    {
+	      *wr_obj = memobj;
+	      *wr_type = MACH_MSG_TYPE_MOVE_SEND;
+	    }
+	  else
+	    *wr_obj = MACH_PORT_NULL;
+	}
+
+      return err;
+    }
+}
+
+/* Read data from an IO object.  If offset if -1, read from the object
+   maintained file pointer.  If the object is not seekable, offset is
+   ignored.  The amount desired to be read is in AMOUNT.  */
+error_t
+trivfs_S_io_read (struct trivfs_protid *cred,
+		  mach_port_t reply, mach_msg_type_name_t reply_type,
+		  vm_address_t *data, mach_msg_type_number_t *data_len,
+		  off_t offs, mach_msg_type_number_t amount)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else if (!(cred->po->openmodes & O_READ))
+    return EBADF;
+  else
+    return open_read ((struct open *)cred->po->hook,
+		      offs, amount, (char **)data, data_len);
+}
+
+/* Tell how much data can be read from the object without blocking for
+   a "long time" (this should be the same meaning of "long time" used
+   by the nonblocking flag.  */
+error_t
+trivfs_S_io_readable (struct trivfs_protid *cred,
+		      mach_port_t reply, mach_msg_type_name_t reply_type,
+		      mach_msg_type_number_t *amount)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else if (! (cred->po->openmodes & O_READ))
+    return EINVAL;
+  else
+    {
+      struct open *open = (struct open *)cred->po->hook;
+      *amount = open->dev->store->size - open->offs;
+      return 0;
+    }
+}
+
+/* Write data to an IO object.  If offset is -1, write at the object
+   maintained file pointer.  If the object is not seekable, offset is
+   ignored.  The amount successfully written is returned in amount.  A
+   given user should not have more than one outstanding io_write on an
+   object at a time; servers implement congestion control by delaying
+   responses to io_write.  Servers may drop data (returning ENOBUFS)
+   if they recevie more than one write when not prepared for it.  */
+error_t
+trivfs_S_io_write (struct trivfs_protid *cred,
+		   mach_port_t reply, mach_msg_type_name_t reply_type,
+		   vm_address_t data, mach_msg_type_number_t data_len,
+		   off_t offs, mach_msg_type_number_t *amount)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else if (!(cred->po->openmodes & O_WRITE))
+    return EBADF;
+  else
+    return open_write ((struct open *)cred->po->hook,
+		       offs, (char *)data, data_len, amount);
+}
+
+/* Change current read/write offset */
+error_t
+trivfs_S_io_seek (struct trivfs_protid *cred,
+		  mach_port_t reply, mach_msg_type_name_t reply_type,
+		  off_t offs, int whence, off_t *new_offs)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    return open_seek ((struct open *)cred->po->hook, offs, whence, new_offs);
+}
+
+/* SELECT_TYPE is the bitwise OR of SELECT_READ, SELECT_WRITE, and SELECT_URG.
+   Block until one of the indicated types of i/o can be done "quickly", and
+   return the types that are then available.  */
+error_t
+trivfs_S_io_select (struct trivfs_protid *cred,
+		    mach_port_t reply, mach_msg_type_name_t reply_type,
+		    int *type)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else if (((*type & SELECT_READ) && !(cred->po->openmodes & O_READ))
+	   || ((*type & SELECT_WRITE) && !(cred->po->openmodes & O_WRITE)))
+    return EBADF;
+  else
+    *type &= ~SELECT_URG;
+  return 0;
+}
+
+/* Truncate file.  */
+error_t
+trivfs_S_file_set_size (struct trivfs_protid *cred,
+			mach_port_t reply, mach_msg_type_name_t reply_type,
+			off_t size)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    return 0;
+}
+
+/* These four routines modify the O_APPEND, O_ASYNC, O_FSYNC, and
+   O_NONBLOCK bits for the IO object. In addition, io_get_openmodes
+   will tell you which of O_READ, O_WRITE, and O_EXEC the object can
+   be used for.  The O_ASYNC bit affects icky async I/O; good async 
+   I/O is done through io_async which is orthogonal to these calls. */
+
+error_t
+trivfs_S_io_get_openmodes (struct trivfs_protid *cred,
+			   mach_port_t reply, mach_msg_type_name_t reply_type,
+			   int *bits)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    {
+      *bits = cred->po->openmodes;
+      return 0;
+    }
+}
+
+error_t
+trivfs_S_io_set_all_openmodes (struct trivfs_protid *cred,
+			       mach_port_t reply,
+			       mach_msg_type_name_t reply_type,
+			       int mode)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    return 0;
+}
+
+error_t
+trivfs_S_io_set_some_openmodes (struct trivfs_protid *cred,
+				mach_port_t reply,
+				mach_msg_type_name_t reply_type,
+				int bits)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    return 0;
+}
+
+error_t
+trivfs_S_io_clear_some_openmodes (struct trivfs_protid *cred,
+				  mach_port_t reply,
+				  mach_msg_type_name_t reply_type,
+				  int bits)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    return 0;
+}
+
+/* Get/set the owner of the IO object.  For terminals, this affects
+   controlling terminal behavior (see term_become_ctty).  For all
+   objects this affects old-style async IO.  Negative values represent
+   pgrps.  This has nothing to do with the owner of a file (as
+   returned by io_stat, and as used for various permission checks by
+   filesystems).  An owner of 0 indicates that there is no owner.  */
+error_t
+trivfs_S_io_get_owner (struct trivfs_protid *cred,
+		       mach_port_t reply,
+		       mach_msg_type_name_t reply_type,
+		       pid_t *owner)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    {
+      struct open *open = (struct open *)cred->po->hook;
+      *owner = open->dev->owner;
+      return 0;
+    }
+}
+
+error_t
+trivfs_S_io_mod_owner (struct trivfs_protid *cred,
+		       mach_port_t reply, mach_msg_type_name_t reply_type,
+		       pid_t owner)
+{
+  if (! cred)
+    return EOPNOTSUPP;
+  else
+    {
+      struct open *open = (struct open *)cred->po->hook;
+      open->dev->owner = owner;
+      return 0;
+    }
+}
+
+/* File syncing operations; these all do the same thing, sync the underlying
+   device.  */
+
+error_t
+trivfs_S_file_sync (struct trivfs_protid *cred,
+		    mach_port_t reply, mach_msg_type_name_t reply_type,
+		    int wait)
+{
+  if (cred)
+    return dev_sync (((struct open *)cred->po->hook)->dev, wait);
+  else
+    return EOPNOTSUPP;
+}
+
+error_t
+trivfs_S_file_syncfs (struct trivfs_protid *cred,
+		      mach_port_t reply, mach_msg_type_name_t reply_type,
+		      int wait, int dochildren)
+{
+  if (! cred)
+    return dev_sync (((struct open *)cred->po->hook)->dev, wait);
+  else
+    return EOPNOTSUPP;
+}
+
+error_t
+trivfs_S_file_get_storage_info (struct trivfs_protid *cred,
+				mach_port_t reply,
+				mach_msg_type_name_t reply_type,
+				mach_port_t **ports,
+				mach_msg_type_name_t *ports_type,
+				mach_msg_type_number_t *num_ports,
+				int **ints, mach_msg_type_number_t *num_ints,
+				off_t **offsets,
+				mach_msg_type_number_t *num_offsets,
+				char **data, mach_msg_type_number_t *data_len)
+{
+  error_t err = 0;
+  struct store_enc enc;
+
+  if (! cred)
+    return EOPNOTSUPP;
+
+  store_enc_init (&enc, *ports, *num_ports, *ints, *num_ints,
+		  *offsets, *num_offsets, *data, *data_len);
+
+  err = store_encode (((struct open *)cred->po->hook)->dev->store, &enc);
+  if (! err)
+    {
+      *ports = enc.ports;
+      *num_ports = enc.num_ports;
+      *ints = enc.ints;
+      *num_ints = enc.num_ints;
+      *offsets = enc.offsets;
+      *num_offsets = enc.num_offsets;
+      *data = enc.data;
+      *data_len = enc.data_len;
+
+      *ports_type = MACH_MSG_TYPE_COPY_SEND;
+    }
+
+  return err;
+}
diff --git a/storeio/open.c b/storeio/open.c
new file mode 100644
index 00000000..f27dc3ab
--- /dev/null
+++ b/storeio/open.c
@@ -0,0 +1,124 @@
+/* Per-open information for storeio
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <hurd.h>
+#include <stdio.h>
+
+#include "open.h"
+#include "dev.h"
+
+/* Returns a new per-open structure for the device DEV in OPEN.  If an error
+   occurs, the error-code is returned, otherwise 0.  */
+error_t
+open_create (struct dev *dev, struct open **open)
+{
+  *open = malloc (sizeof (struct open));
+  if (*open == NULL)
+    return ENOMEM;
+
+  (*open)->dev = dev;
+  (*open)->offs = 0;
+  mutex_init (&(*open)->lock);
+
+  return 0;
+}
+
+/* Free OPEN and any resources it holds.  */
+void
+open_free (struct open *open)
+{
+  free (open);
+}
+
+/* Writes up to LEN bytes from BUF to OPEN's device at device offset OFFS
+   (which may be ignored if the device doesn't support random access),
+   and returns the number of bytes written in AMOUNT.  If no error occurs,
+   zero is returned, otherwise the error code is returned.  */
+error_t
+open_write (struct open *open, off_t offs, char *buf, size_t len,
+	    vm_size_t *amount)
+{
+  error_t err;
+  if (offs < 0)
+    /* Use OPEN's offset.  */
+    {
+      mutex_lock (&open->lock);
+      err = dev_write (open->dev, open->offs, buf, len, amount);
+      if (! err)
+	open->offs += *amount;
+      mutex_unlock (&open->lock);
+    }
+  else
+    err = dev_write (open->dev, offs, buf, len, amount);
+  return err;
+}    
+
+/* Reads up to AMOUNT bytes from the device into BUF and LEN using the
+   standard mach out-array convention.  If no error occurs, zero is returned,
+   otherwise the error code is returned.  */
+error_t
+open_read (struct open *open, off_t offs, size_t amount,
+	   char **buf, vm_size_t *len)
+{
+  error_t err;
+  if (offs < 0)
+    /* Use OPEN's offset.  */
+    {
+      mutex_lock (&open->lock);
+      err = dev_read (open->dev, open->offs, amount, buf, len);
+      if (! err)
+	open->offs += *len;
+      mutex_unlock (&open->lock);
+    }
+  else
+    err = dev_read (open->dev, offs, amount, buf, len);
+  return err;
+}   
+
+/* Set OPEN's location to OFFS, interpreted according to WHENCE as by seek.
+   The new absolute location is returned in NEW_OFFS (and may not be the same
+   as OFFS).  If no error occurs, zero is returned, otherwise the error code
+   is returned.  */
+error_t
+open_seek (struct open *open, off_t offs, int whence, off_t *new_offs)
+{
+  error_t err = 0;
+
+  mutex_lock (&open->lock);
+
+  switch (whence)
+    {
+    case SEEK_SET:
+      open->offs = offs; break;
+    case SEEK_CUR:
+      open->offs += offs; break;
+    case SEEK_END:
+      open->offs = open->dev->store->size - offs; break;
+    default:
+      err = EINVAL;
+    }
+
+  if (! err)
+    *new_offs = open->offs;
+
+  mutex_unlock (&open->lock);
+
+  return err;
+}
diff --git a/storeio/open.h b/storeio/open.h
new file mode 100644
index 00000000..efb2128d
--- /dev/null
+++ b/storeio/open.h
@@ -0,0 +1,68 @@
+/* Per-open information for storeio
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef __OPEN_H__
+#define __OPEN_H__
+
+#include "dev.h"
+
+/* ---------------------------------------------------------------- */
+
+/* A structure describing a particular i/o stream on this device.  */
+struct open
+{
+  /* The device that this an open on.  */
+  struct dev *dev;
+
+  /* The per-open offset used for I/O operations that don't specify an
+     explicit offset.  */
+  off_t offs;
+
+  /* A lock used to control write access to OFFS.  */
+  struct mutex lock;
+};
+
+/* Returns a new per-open structure for the device DEV in OPEN.  If an error
+   occurs, the error-code is returned, otherwise 0.  */
+error_t open_create (struct dev *dev, struct open **open);
+
+/* Free OPEN and any resources it holds.  */
+void open_free (struct open *open);
+
+/* Writes up to LEN bytes from BUF to OPEN's device at device offset OFFS
+   (which may be ignored if the device doesn't support random access),
+   and returns the number of bytes written in AMOUNT.  If no error occurs,
+   zero is returned, otherwise the error code is returned.  */
+error_t open_write (struct open *open, off_t offs, char *buf, size_t len,
+		    size_t *amount);
+
+/* Reads up to AMOUNT bytes from the device into BUF and BUF_LEN using the
+   standard mach out-array convention.  If no error occurs, zero is returned,
+   otherwise the error code is returned.  */
+error_t open_read (struct open *open, off_t offs, size_t amount,
+		   char **buf, size_t *buf_len);
+
+/* Set OPEN's location to OFFS, interpreted according to WHENCE as by seek.
+   The new absolute location is returned in NEW_OFFS (and may not be the same
+   as OFFS).  If no error occurs, zero is returned, otherwise the error code
+   is returned.  */
+error_t open_seek (struct open *open, off_t offs, int whence, off_t *new_offs);
+
+#endif /* !__OPEN_H__ */
diff --git a/storeio/pager.c b/storeio/pager.c
new file mode 100644
index 00000000..e723f602
--- /dev/null
+++ b/storeio/pager.c
@@ -0,0 +1,264 @@
+/* Paging interface for storeio devices
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <hurd.h>
+#include <hurd/pager.h>
+#include <assert.h>
+#include <strings.h>
+#include <unistd.h>
+
+#include "dev.h"
+
+/* ---------------------------------------------------------------- */
+/* Pager library callbacks; see <hurd/pager.h> for more info.  */
+
+/* For pager PAGER, read one page from offset PAGE.  Set *BUF to be the
+   address of the page, and set *WRITE_LOCK if the page must be provided
+   read-only.  The only permissable error returns are EIO, EDQUOT, and
+   ENOSPC. */
+error_t
+pager_read_page (struct user_pager_info *upi,
+		 vm_offset_t page, vm_address_t *buf, int *writelock)
+{
+  error_t err;
+  int read;			/* bytes actually read */
+  int want = vm_page_size;	/* bytes we want to read */
+  struct dev *dev = (struct dev *)upi;
+  struct store *store = dev->store;
+
+  if (page + want > store->size)
+    /* Read a partial page if necessary to avoid reading off the end.  */
+    want = store->size - page;
+
+  err = dev_read (dev, page, want, (char **)buf, &read);
+
+  if (!err && want < vm_page_size)
+    /* Zero anything we didn't read.  Allocation only happens in page-size
+       multiples, so we know we can write there.  */
+    bzero ((char *)*buf + want, vm_page_size - want);
+
+  *writelock = (store->flags & STORE_READONLY);
+
+  if (err || read < want)
+    return EIO;
+  else
+    return 0;
+}
+
+/* For pager PAGER, synchronously write one page from BUF to offset PAGE.  In
+   addition, vm_deallocate (or equivalent) BUF.  The only permissable error
+   returns are EIO, EDQUOT, and ENOSPC. */
+error_t
+pager_write_page (struct user_pager_info *upi,
+		  vm_offset_t page, vm_address_t buf)
+{
+  struct dev *dev = (struct dev *)upi;
+  struct store *store = dev->store;
+
+  if (store->flags & STORE_READONLY)
+    return EROFS;
+  else
+    {
+      error_t err;
+      int written;
+      int want = vm_page_size;
+
+      if (page + want > store->size)
+	/* Write a partial page if necessary to avoid reading off the end.  */
+	want = store->size - page;
+
+      err = dev_write (dev, page, (char *)buf, want, &written);
+
+      vm_deallocate (mach_task_self (), buf, vm_page_size);
+
+      if (err || written < want)
+	return EIO;
+      else
+	return 0;
+    }
+}
+
+/* A page should be made writable. */
+error_t
+pager_unlock_page (struct user_pager_info *upi, vm_offset_t address)
+{
+  struct dev *dev = (struct dev *)upi;
+
+  if (dev->store->flags & STORE_READONLY)
+    return EROFS;
+  else
+    return 0;
+}
+
+/* The user must define this function.  It should report back (in
+   *OFFSET and *SIZE the minimum valid address the pager will accept
+   and the size of the object.   */
+error_t
+pager_report_extent (struct user_pager_info *upi,
+		    vm_address_t *offset, vm_size_t *size)
+{
+  *offset = 0;
+  *size = ((struct dev *)upi)->store->size;
+  return 0;
+}
+
+/* This is called when a pager is being deallocated after all extant send
+   rights have been destroyed.  */
+void
+pager_clear_user_data (struct user_pager_info *upi)
+{
+}
+
+static struct port_bucket *pager_port_bucket = 0;
+
+/* A top-level function for the paging thread that just services paging
+   requests.  */
+static void
+service_paging_requests (any_t arg)
+{
+  for (;;)
+    ports_manage_port_operations_multithread (pager_port_bucket,
+					      pager_demuxer,
+					      1000 * 30, 1000 * 60 * 5,
+					      1, MACH_PORT_NULL);
+}
+
+/* Initialize paging for this device.  */
+static void
+init_dev_paging ()
+{
+  if (! pager_port_bucket)
+    {
+      static struct mutex pager_global_lock = MUTEX_INITIALIZER;
+
+      mutex_lock (&pager_global_lock);
+      if (pager_port_bucket == NULL)
+	{
+	  pager_port_bucket = ports_create_bucket ();
+
+	  /* Make a thread to service paging requests.  */
+	  cthread_detach (cthread_fork ((cthread_fn_t)service_paging_requests,
+					(any_t)0));
+	}
+      mutex_unlock (&pager_global_lock);
+    }
+}
+
+void
+pager_dropweak (struct user_pager_info *upi __attribute__ ((unused)))
+{
+}
+
+/* Try to stop all paging activity on DEV, returning true if we were
+   successful.  If NOSYNC is true, then we won't write back any (kernel)
+   cached pages to the device.  */
+int
+dev_stop_paging (struct dev *dev, int nosync)
+{
+  int success = 1;		/* Initially assume success.  */
+
+  mutex_lock (&dev->pager_lock);
+
+  if (dev->pager != NULL)
+    {
+      int num_pagers = ports_count_bucket (pager_port_bucket);
+      if (num_pagers > 0 && !nosync)
+	{
+	  error_t block_cache (void *arg)
+	    {
+	      struct pager *p = arg;
+	      pager_change_attributes (p, 0, MEMORY_OBJECT_COPY_DELAY, 1);
+	      return 0;
+	    }
+	  error_t enable_cache (void *arg)
+	    {
+	      struct pager *p = arg;
+	      pager_change_attributes (p, 1, MEMORY_OBJECT_COPY_DELAY, 0);
+	      return 0;
+	    }
+
+	  /* Loop through the pagers and turn off caching one by one,
+	     synchronously.  That should cause termination of each pager. */
+	  ports_bucket_iterate (pager_port_bucket, block_cache);
+      
+	  /* Give it a second; the kernel doesn't actually shutdown
+	     immediately.  XXX */
+	  sleep (1);
+      
+	  num_pagers = ports_count_bucket (pager_port_bucket);
+	  if (num_pagers > 0)
+	    /* Darn, there are actual honest users.  Turn caching back on,
+	       and return failure. */
+	    {
+	      ports_bucket_iterate (pager_port_bucket, enable_cache);
+	      success = 0;
+	    }
+	}
+
+      if (success && !nosync)
+	/* shutdown the pager on DEV.  If NOSYNC is set, we don't bother, for
+	   fear that this may result in I/O.  In this case we've disabled
+	   rpcs on the pager's ports, so this will result in hanging...  What
+	   do we do??? XXXX */
+	pager_shutdown (dev->pager);
+    }
+
+  if (success)
+    dev->pager = NULL;
+
+  mutex_unlock (&dev->pager_lock);
+
+  return success;
+}
+
+/* Returns in MEMOBJ the port for a memory object backed by the storage on
+   DEV.  Returns 0 or the error code if an error occurred.  */
+error_t
+dev_get_memory_object (struct dev *dev, memory_object_t *memobj)
+{
+  error_t err = 0;
+
+  init_dev_paging ();
+
+  mutex_lock (&dev->pager_lock);
+
+  if (dev->pager == NULL)
+    dev->pager =
+      pager_create ((struct user_pager_info *)dev, pager_port_bucket,
+		    1, MEMORY_OBJECT_COPY_DELAY);
+  else
+    ports_port_ref (dev->pager);
+
+  if (dev->pager == NULL)
+    err = ENODEV;		/* XXX ??? */
+  else
+    {
+      *memobj = pager_get_port (dev->pager);
+      if (*memobj != MACH_PORT_NULL)
+	err =
+	  mach_port_insert_right (mach_task_self (),
+				  *memobj, *memobj, MACH_MSG_TYPE_MAKE_SEND);
+      ports_port_deref (dev->pager); /* Drop our original ref on PAGER.  */
+    }
+
+  mutex_unlock (&dev->pager_lock);
+
+  return err;
+}
diff --git a/storeio/storeio.c b/storeio/storeio.c
new file mode 100644
index 00000000..8f189bf8
--- /dev/null
+++ b/storeio/storeio.c
@@ -0,0 +1,328 @@
+/* A translator for doing I/O to stores
+
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <hurd.h>
+#include <hurd/ports.h>
+#include <hurd/pager.h>
+#include <hurd/trivfs.h>
+#include <hurd/fsys.h>
+
+#include <stdio.h>
+#include <error.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <argp.h>
+
+#include "open.h"
+#include "dev.h"
+
+/* The port class of our file system control pointer.  */
+struct port_class *fsys_port_class;
+/* The port class of the (only) root file port for the opened device.  */
+struct port_class *root_port_class;
+
+/* A bucket to put all our ports in.  */
+struct port_bucket *port_bucket;
+
+/* Trivfs noise.  */
+struct port_class *trivfs_protid_portclasses[1];
+struct port_class *trivfs_cntl_portclasses[1];
+int trivfs_protid_nportclasses = 1;
+int trivfs_cntl_nportclasses = 1;
+
+static struct argp_option options[] =
+{
+  {"readonly", 'r', 0,	  0, "Disallow writing"},
+  {"writable", 'w', 0,	  0, "Allow writing"},
+  {"rdev",     'n', "ID", 0,
+   "The stat rdev number for this node; may be either a"
+   " single integer, or of the form MAJOR,MINOR"},
+  {0, 0, 0, 0}
+};
+static char *args_doc = 0;
+static char *doc = "Translator for devices and other stores";
+
+/* ---------------------------------------------------------------- */
+
+/* The open store.  */
+static struct dev *device = NULL;
+/* And a lock to arbitrate changes to it.  */
+static struct mutex device_lock;
+
+/* Desired store parameters specified by the user.  */
+struct store_parsed *store_name;
+static int readonly = 0;
+
+/* A unixy device number to return when the device is stat'd.  */
+static int rdev = 0;
+
+void main (int argc, char *argv[])
+{
+  error_t err;
+  mach_port_t bootstrap;
+  error_t parse_opt (int key, char *arg, struct argp_state *state)
+    {
+      switch (key)
+	{
+	case 'r': readonly = 1; break;
+	case 'w': readonly = 0; break;
+	case 'n':
+	  {
+	    char *start = arg, *end;
+
+	    rdev = strtoul (start, &end, 0);
+	    if (*end == ',')
+	      /* MAJOR,MINOR form */
+	      {
+		start = end;
+		rdev = (rdev << 8) + strtoul (start, &end, 0);
+	      }
+
+	    if (end == start || *end != '\0')
+	      {
+		argp_error (state, "%s: Invalid argument to --rdev", arg);
+		return EINVAL;
+	      }
+	  }
+	  break;
+	case ARGP_KEY_INIT:
+	  state->child_inputs[0] = &store_name; break;
+	default:
+	  return ARGP_ERR_UNKNOWN;
+	}
+      return 0;
+    }
+  const struct argp *kids[] = { &store_argp, 0 };
+  const struct argp argp = { options, parse_opt, args_doc, doc, kids };
+
+  argp_parse (&argp, argc, argv, 0, 0, 0);
+
+  if (readonly)
+    /* Catch illegal writes at the point of open.  */
+    trivfs_allow_open &= ~O_WRITE;
+
+  task_get_bootstrap_port (mach_task_self (), &bootstrap);
+  if (bootstrap == MACH_PORT_NULL)
+    error (2, 0, "Must be started as a translator");
+  
+  fsys_port_class = ports_create_class (trivfs_clean_cntl, 0);
+  root_port_class = ports_create_class (trivfs_clean_protid, 0);
+  port_bucket = ports_create_bucket ();
+  trivfs_protid_portclasses[0] = root_port_class;
+  trivfs_cntl_portclasses[0] = fsys_port_class;
+
+  /* Reply to our parent */
+  err =
+    trivfs_startup (bootstrap, 0,
+		   fsys_port_class, port_bucket,
+		   root_port_class, port_bucket,
+		   NULL);
+  if (err)
+    error (3, err, "trivfs_startup");
+
+  /* Open the device only when necessary.  */
+  device = NULL;
+  mutex_init (&device_lock);
+
+  /* Launch. */
+  ports_manage_port_operations_multithread (port_bucket, trivfs_demuxer,
+					    30*1000, 5*60*1000, 0, 0);
+
+  exit (0);
+}
+
+/* Called whenever someone tries to open our node (even for a stat).  We
+   delay opening the kernel device until this point, as we can usefully
+   return errors from here.  */
+static error_t
+check_open_hook (struct trivfs_control *trivfs_control,
+		 uid_t *uids, u_int nuids,
+		 gid_t *gids, u_int ngids,
+		 int flags)
+{
+  error_t err = 0;
+
+  mutex_lock (&device_lock);
+  if (device == NULL)
+    /* Try and open the device.  */
+    {
+      err = dev_open (store_name, readonly ? STORE_READONLY : 0, &device);
+      if (err)
+	device = NULL;
+      if (err && (flags & (O_READ|O_WRITE)) == 0)
+	/* If we're not opening for read or write, then just ignore the
+	   error, as this allows stat to word correctly.  XXX  */
+	err = 0;
+    }
+  mutex_unlock (&device_lock);
+
+  return err;
+}
+
+static error_t
+open_hook (struct trivfs_peropen *peropen)
+{
+  struct dev *dev = device;
+  if (dev)
+    return open_create (dev, (struct open **)&peropen->hook);
+  else
+    return 0;
+}
+
+static void
+close_hook (struct trivfs_peropen *peropen)
+{
+  if (peropen->hook)
+    open_free (peropen->hook);
+}
+
+/* ---------------------------------------------------------------- */
+/* Trivfs hooks  */
+
+int trivfs_fstype = FSTYPE_DEV;
+int trivfs_fsid = 0;
+
+int trivfs_support_read = 1;
+int trivfs_support_write = 1;
+int trivfs_support_exec = 0;
+
+int trivfs_allow_open = O_READ | O_WRITE;
+
+void
+trivfs_modify_stat (struct trivfs_protid *cred, struct stat *st)
+{
+  struct open *open = cred->po->hook;
+
+  if (open)
+    /* An open device.  */
+    {
+      struct store *store = open->dev->store;
+      vm_size_t size = store->size;
+
+      if (store->block_size > 1)
+	st->st_blksize = store->block_size;
+
+      st->st_size = size;
+      st->st_blocks = size / 512;
+    }
+  else
+    /* Try and do things without an open device...  */
+    {
+      st->st_blksize = 0;
+      st->st_size = 0;
+      st->st_blocks = 0;
+    }
+
+  st->st_mode &= ~S_IFMT;
+  st->st_mode |= S_IFCHR;
+  st->st_rdev = rdev;
+  if (readonly)
+    st->st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
+}
+
+error_t
+trivfs_goaway (struct trivfs_control *fsys, int flags)
+{
+  error_t err;
+  int force = (flags & FSYS_GOAWAY_FORCE);
+  int nosync = (flags & FSYS_GOAWAY_NOSYNC);
+
+  mutex_lock (&device_lock);
+
+  if (device == NULL)
+    exit (0);
+
+  /* Wait until all pending rpcs are done.  */
+  err = ports_inhibit_class_rpcs (root_port_class);
+  if (err == EINTR || (err && !force))
+    {
+      mutex_unlock (&device_lock);
+      return err;
+    }
+
+  if (force && nosync)
+    /* Exit with extreme prejudice.  */
+    exit (0);
+
+  if (!force && ports_count_class (root_port_class) > 0)
+    /* Still users, so don't exit.  */
+    goto busy;
+
+  if (! nosync)
+    /* Sync the device here, if necessary, so that closing it won't result in
+       any I/O (which could get hung up trying to use one of our pagers).  */
+    dev_sync (device, 1);
+
+  /* devpager_shutdown may sync the pagers as side-effect (if NOSYNC is 0),
+     so we put that first in this test.  */
+  if (dev_stop_paging (device, nosync) || force)
+    /* Bye-bye.  */
+    {
+      if (! nosync)
+	/* If NOSYNC is true, we don't close DEV, as that could cause data to
+	   be written back.  */
+	dev_close (device);
+      exit (0);
+    }
+
+ busy:
+  /* Allow normal operations to proceed.  */
+  ports_enable_class (root_port_class);
+  ports_resume_class_rpcs (root_port_class);
+  mutex_unlock (&device_lock);
+
+  /* Complain that there are still users.  */
+  return EBUSY;
+}
+
+/* If this variable is set, it is called every time an open happens.
+   UIDS, GIDS, and FLAGS are from the open; CNTL identifies the
+   node being opened.  This call need not check permissions on the underlying
+   node.  If the open call should block, then return EWOULDBLOCK.  Other
+   errors are immediately reflected to the user.  If O_NONBLOCK 
+   is not set in FLAGS and EWOULDBLOCK is returned, then call 
+   trivfs_complete_open when all pending open requests for this 
+   file can complete. */
+error_t (*trivfs_check_open_hook)(struct trivfs_control *trivfs_control,
+				  uid_t *uids, u_int nuids,
+				  gid_t *gids, u_int ngids,
+				  int flags)
+     = check_open_hook;
+
+/* If this variable is set, it is called every time a new peropen
+   structure is created and initialized. */
+error_t (*trivfs_peropen_create_hook)(struct trivfs_peropen *) = open_hook;
+
+/* If this variable is set, it is called every time a peropen structure
+   is about to be destroyed. */
+void (*trivfs_peropen_destroy_hook) (struct trivfs_peropen *) = close_hook;
+
+/* Sync this filesystem.  */
+kern_return_t
+trivfs_S_fsys_syncfs (struct trivfs_control *cntl,
+		      mach_port_t reply, mach_msg_type_name_t replytype,
+		      int wait, int dochildren)
+{
+  struct dev *dev = device;
+  if (dev)
+    return dev_sync (dev, wait);
+  else
+    return 0;
+}