Initial versions.

11 files changed, 2632 insertions, 0 deletions

diff --git a/isofs/ChangeLog b/isofs/ChangeLog
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/isofs/ChangeLog
diff --git a/isofs/Makefile b/isofs/Makefile
new file mode 100644
index 00000000..5e9c9f24
--- /dev/null
+++ b/isofs/Makefile
@@ -0,0 +1,29 @@
+
+#   Copyright (C) 1997 Free Software Foundation
+#
+#   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.
+
+dir := ufs
+makemode := server
+
+target = isofs
+SRCS = inode.c main.c lookup.c pager.c rr.c
+LCLHDRS = iso9660.h isofs.h rr.h susp.h
+
+OBJS = $(SRCS:.c=.o)
+HURDLIBS = diskfs iohelp fshelp store pager ports threads ihash shouldbeinlibc
+
+include ../Makeconf
+
diff --git a/isofs/ext.c b/isofs/ext.c
new file mode 100644
index 00000000..80379b7b
--- /dev/null
+++ b/isofs/ext.c
@@ -0,0 +1,60 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+/* Extensions to ISO 9660 we support */
+
+#include "isofs.h"
+
+struct susp_field susp_extension[] =
+{
+  { 'C', 'E', 1, process_su_ce },
+  { 'P', 'D', 1, process_su_pd },
+  { 'S', 'P', 1, process_su_sp },
+  { 'E', 'R', 1, process_su_er },
+  { 'S', 'T', 1, process_su_st },
+  { 0, 0, 0, 0 },
+};
+
+struct susp_field rr_extension[] =
+{
+  { 'P', 'X', 1, process_rr_px },
+  { 'P', 'N', 1, process_rr_pn },
+  { 'S', 'L', 1, process_rr_sl },
+  { 'N', 'M', 1, process_rr_nm },
+  { 'C', 'L', 1, process_rr_cl },
+  { 'P', 'L', 1, process_rr_pl },
+  { 'R', 'E', 1, process_rr_re },
+  { 'T', 'F', 1, process_rr_tf },
+  { 'S', 'F', 1, process_rr_sf },
+  { 0, 0, 0, 0 },
+};
+
+struct susp_ext extensions[] =
+{
+  { "RRIP_1991A", 1,
+    "THE ROCK RIDGE INTERCHANGE PROTOCOL PROVIDES SUPPORT FOR POSIX FILE SYSTEM SEMANTICS",
+    "ROCK RIDGE SPECIFICATION VERSION 1 REVISION 1.10 JULY 13 1993",
+    rr_extensions
+  },
+  { 0, 0, 0, 0, susp_extensions },
+  { 0, 0, 0, 0, 0 },
+}
+
+
diff --git a/isofs/inode.c b/isofs/inode.c
new file mode 100644
index 00000000..48079caf
--- /dev/null
+++ b/isofs/inode.c
@@ -0,0 +1,550 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+#include <string.h>
+#include <stdio.h>
+#include "isofs.h"
+
+
+/* There is no such thing as an inode in this format, all such information
+   being recorded in the directory entry.  So we report inode numbers as
+   absolute offsets from DISK_IMAGE. */
+
+#define	INOHSZ	512
+#if	((INOHSZ&(INOHSZ-1)) == 0)
+#define	INOHASH(ino)	((ino>>8)&(INOHSZ-1))
+#else
+#define	INOHASH(ino)	(((unsigned)(ino>>8))%INOHSZ)
+#endif
+
+struct node_cache
+{
+  struct dirrect *dr;		/* somewhere in disk_image */
+
+  off_t file_start;		/* UNIQUE start of file */
+  
+  struct node *np;		/* if live */
+};
+
+static int node_cache_size = 0;
+static int node_cache_alloced = 0;
+struct node_cache *node_cache = 0;
+
+/* Forward */
+static error_t read_disknode (struct node *, 
+			      struct dirrect *, struct rrip_lookup *);
+ 
+
+/* See if node with file start FILE_START is in the cache.  If so,
+   return it, with one additional reference. diskfs_node_refcnt_lock must
+   be held on entry to the call, and will be released iff the node
+   was found in the cache. */
+void
+inode_cache_find (off_t file_start, struct node **npp)
+{
+  int i;
+
+  for (i = 0; i < node_cache_size; i++)
+    if (node_cache[i].file_start == file_start
+	&& node_cache[i].np)
+      {
+	*npp = node_cache[i].np;
+	(*npp)->references++;
+	spin_unlock (&diskfs_node_refcnt_lock);
+	mutex_lock (&(*npp)->lock);
+	return;
+      }
+  *npp = 0;
+}
+
+/* Enter NP into the cache.  The directory entry we used
+   DR. diskfs_node_refcnt_lock must be held. */
+void
+cache_inode (struct dirrect *dr, struct node *np)
+{
+  int i;
+  struct node_cache *c = 0;
+
+  /* First see if there's already an entry. */
+  for (i = 0; i < node_cache_size; i++)
+    if (node_cache[i].file_start == np->dn->file_start)
+      break;
+  
+  if (i == node_cache_size)
+    {
+      if (node_cache_size >= node_cache_alloced)
+	{
+	  if (!node_cache_alloced)
+	    {
+	      /* Initialize */
+	      node_cache_alloced = 10;
+	      node_cache = malloc (sizeof (struct node_cache) * 10);
+	    }
+	  else
+	    {
+	      node_cache_alloced *= 2;
+	      node_cache = realloc (node_cache, 
+				    sizeof (struct node_cache)
+				    * node_cache_alloced);
+	    }
+	  assert (node_cache);
+	}
+      node_cache_size++;
+    }
+  
+  c = &node_cache[i];
+  c->dr = dr;
+  c->file_start = np->dn->file_start;
+  c->np = np;
+
+  /* PLUS 1 so that we don't store zero cache ID's (not allowed by diskfs) */
+  np->cache_id = i + 1;
+}
+
+/* Fetch inode with cache id ID; set *NPP to the node structure;
+   gain one user reference and lock the node. */
+error_t
+diskfs_cached_lookup (int id, struct node **npp)
+{
+  struct node *np;
+  error_t err;
+
+  /* Cache ID's are incremented when presented to diskfs
+     to avoid presenting zero cache ID's. */
+  id--;
+
+  spin_lock (&diskfs_node_refcnt_lock);
+  assert (id < node_cache_size);
+
+  np = node_cache[id].np;
+  
+  if (!np)
+    {
+      struct node_cache *c = &node_cache[id];
+      struct rrip_lookup rr;
+      struct disknode *dn;
+
+      rrip_lookup (node_cache[id].dr, &rr, 1);
+      
+      /* We should never cache the wrong directory entry */
+      assert (!(rr.valid & VALID_CL));
+
+      dn = malloc (sizeof (struct disknode));
+      dn->fileinfo = 0;
+      dn->file_start = c->file_start;
+      np = diskfs_make_node (dn);
+      np->cache_id = id + 1;	/* see above for rationale for increment */
+      mutex_lock (&np->lock);
+      c->np = np;
+      spin_unlock (&diskfs_node_refcnt_lock);
+      
+      err = read_disknode (np, node_cache[id].dr, &rr);
+      if (!err)
+	*npp = np;
+
+      release_rrip (&rr);
+
+      return err;
+    }
+
+  
+  np->references++;
+  spin_unlock (&diskfs_node_refcnt_lock);
+  mutex_lock (&np->lock);
+  *npp = np;
+  return 0;
+}
+
+
+/* Return Epoch-based time from a seven byte according to 9.1.5 */
+char *
+isodate_915 (char *c, struct timespec *ts)
+{
+  struct tm tm;
+  signed char tz;
+
+  /* Copy into a struct TM. */
+  tm.tm_year = *c++;
+  tm.tm_mon = *c++ - 1;
+  tm.tm_mday = *c++;
+  tm.tm_hour = *c++;
+  tm.tm_min = *c++;
+  tm.tm_sec = *c++;
+  tz = *c++;
+
+  tm.tm_isdst = 0;
+  ts->tv_sec = timegm (&tm);
+  ts->tv_nsec = 0;
+  
+  /* Only honor TZ offset if it makes sense */
+  if (-48 <= tz && tz <= 52)
+    ts->tv_sec -= 15 * 60 * tz;	/* TZ is in fifteen minute chunks */
+
+  return c;
+}
+
+/* Return Epoch-based time from a seventeen byte according to 8.4.26.1 */
+char *
+isodate_84261 (char *c, struct timespec *ts)
+{
+  struct tm tm;
+  int hsec;
+  signed char tz;
+
+  sscanf (c, "%4d%2d%2d%2d%2d%2d%2d", 
+	  &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+	  &tm.tm_hour, &tm.tm_min, &tm.tm_sec,
+	  &hsec);
+
+  /* Convert to appropriate units */
+  ts->tv_nsec = hsec * 10000000;
+  tm.tm_year -= 1900;
+  tm.tm_mon--;
+  
+  tm.tm_isdst = 0;
+  ts->tv_sec = timegm (&tm);
+  
+  tz = c[16];
+
+  /* Only honor TZ offset if it makes sense */
+  if (-48 <= tz && tz <= 52)
+    ts->tv_sec -= 15 * 60 * tz;	/* TZ is in fifteen minute chunks */
+
+  return c + 17;
+}
+
+/* Calculate the file start (in store blocks) of the file at RECORD. */
+error_t
+calculate_file_start (struct dirrect *record, off_t *file_start,
+		      struct rrip_lookup *rr)
+{
+  error_t err;
+
+  if (rr && (rr->valid & VALID_CL))
+    {
+      *file_start = (void *) rr->realdirent - (void *)disk_image;
+      *file_start >>= store->log2_block_size;
+    }
+  else if (rr && (rr->valid & VALID_PL))
+    *file_start = rr->realfilestart;
+  else
+    {
+      err = diskfs_catch_exception ();
+      if (err)
+	return err;
+  
+      *file_start = ((isonum_733 (record->extent) + record->ext_attr_len)
+		     * (logical_block_size / store->block_size));
+
+      diskfs_end_catch_exception ();
+    }
+  return 0;
+}
+
+
+/* Load the inode with directory entry RECORD and cached Rock-Rodge info RR
+   into NP.  The directory entry is at OFFSET in BLOCK.  */
+error_t
+load_inode (struct node **npp, struct dirrect *record, 
+	    struct rrip_lookup *rr)
+{
+  error_t err;
+  off_t file_start;
+  struct disknode *dn;
+  struct node *np;
+  
+  err = calculate_file_start (record, &file_start, rr);
+  if (err)
+    return err;
+  if (rr->valid & VALID_CL)
+    record = rr->realdirent;
+
+  spin_lock (&diskfs_node_refcnt_lock);
+  
+  /* First check the cache */
+  inode_cache_find (file_start, npp);
+  if (*npp)
+    return 0;
+  
+  /* Create a new node */
+  dn = malloc (sizeof (struct disknode));
+  dn->fileinfo = 0;
+  dn->file_start = file_start;
+
+  np = diskfs_make_node (dn);
+
+  mutex_lock (&np->lock);
+
+  cache_inode (record, np);
+  spin_unlock (&diskfs_node_refcnt_lock);
+  
+  err = read_disknode (np, record, rr);
+  *npp = np;
+  return err;
+}
+
+
+/* Read stat information from the directory entry at DR and the
+   contents of RL. */
+static error_t
+read_disknode (struct node *np, struct dirrect *dr,
+	       struct rrip_lookup *rl)
+{
+  error_t err;
+  struct stat *st = &np->dn_stat;
+  
+  st->st_fstype = 9660;	/* xxx */
+  st->st_fsid = getpid ();
+  st->st_ino = np->dn->file_start;
+  st->st_gen = 0;
+  st->st_rdev = 0;
+  
+  err = diskfs_catch_exception ();
+  if (err)
+    return err;
+
+  if (rl->valid & VALID_PX)
+    {
+      st->st_mode = rl->mode;
+      st->st_nlink = rl->nlink;
+      st->st_uid = rl->uid;
+      st->st_gid = rl->gid;
+    }
+  else
+    {
+      /* If there are no periods, it's a directory. */
+      if (((rl->valid & VALID_NM) && !index (rl->name, '.'))
+	  || (!(rl->valid & VALID_NM) && !memchr (dr->name, '.', dr->namelen)))
+	st->st_mode = S_IFDIR | 0777;
+      else
+	st->st_mode = S_IFREG | 0666;
+
+      st->st_nlink = 1;
+      st->st_uid = 0;
+      st->st_gid = 0;
+    }
+  
+  st->st_author = st->st_gid;
+
+  st->st_size = isonum_733 (dr->size);
+
+  if ((rl->valid & VALID_PN)
+      && (S_ISCHR (st->st_mode) || S_ISBLK (st->st_mode)))
+    st->st_rdev = rl->rdev;
+  else 
+    st->st_rdev = 0;
+  
+  if (dr->ileave)
+    /* XXX ??? */
+    st->st_size = 0;
+  
+  /* Calculate these if we'll need them */
+  if (!(rl->valid & VALID_TF)
+      || ((rl->tfflags & (TF_CREATION|TF_ACCESS|TF_MODIFY))
+	  != (TF_CREATION|TF_ACCESS|TF_MODIFY)))
+    {
+      struct timespec ts;
+      isodate_915 (dr->date, &ts);
+      st->st_ctime = st->st_mtime = st->st_atime = ts.tv_sec;
+      st->st_ctime_usec = st->st_mtime_usec = st->st_atime_usec 
+	= ts.tv_nsec * 1000;
+    }
+  
+  /* Override what we have better info for */
+  if (rl->valid & VALID_TF)
+    {
+      if (rl->tfflags & TF_CREATION)
+	{
+	  st->st_ctime = rl->ctime.tv_sec;
+	  st->st_ctime_usec = rl->ctime.tv_nsec * 1000;
+	}
+      
+      if (rl->tfflags & TF_ACCESS)
+	{
+	  st->st_atime = rl->atime.tv_sec;
+	  st->st_atime_usec = rl->atime.tv_nsec * 1000;
+	}
+      
+      if (rl->tfflags & TF_MODIFY)
+	{
+	  st->st_mtime = rl->mtime.tv_sec;
+	  st->st_mtime_usec = rl->mtime.tv_nsec * 1000;
+	}
+    }
+  
+  st->st_blksize = logical_block_size;
+  st->st_blocks = (st->st_size - 1) / logical_block_size  + 1;
+  st->st_flags = 0;
+  
+  if (S_ISLNK (st->st_mode))
+    {
+      if (rl->valid & VALID_SL)
+	{
+	  np->dn->link_target = rl->name;
+	  rl->name = 0;
+	  st->st_size = strlen (np->dn->link_target);
+	}
+      else
+	{
+	  st->st_mode &= ~S_IFMT;
+	  st->st_mode |= S_IFREG;
+	}
+    }
+
+  diskfs_end_catch_exception ();
+  
+  return 0;
+}
+
+/* Symlink targets are never stored in files, so always use this. */
+static error_t
+read_symlink_hook (struct node *np, char *buf)
+{
+  bcopy (np->dn->link_target, buf, np->dn_stat.st_size);
+  return 0;
+}
+error_t (*diskfs_read_symlink_hook) (struct node *, char *) 
+     = read_symlink_hook;
+
+
+/* The last reference to NP has gone away; drop it from the cache
+   and clean all state in the dn structure. */
+void
+diskfs_node_norefs (struct node *np)
+{
+  assert (node_cache[np->cache_id - 1].np == np);
+  node_cache[np->cache_id - 1].np = 0;
+
+  assert (!np->dn->fileinfo);
+  free (np->dn);
+  free (np);
+}
+
+/* The last hard reference to a node has gone away; arrange to have
+   all the weak references dropped that can be.  */
+void
+diskfs_try_dropping_softrefs (struct node *np)
+{
+  drop_pager_softrefs (np);
+}
+
+void
+diskfs_lost_hardrefs (struct node *np)
+{
+}
+
+void
+diskfs_new_hardrefs (struct node *np)
+{
+  allow_pager_softrefs (np);
+}
+
+error_t
+diskfs_truncate (struct node *np, off_t length)
+{
+  return EROFS;
+}
+
+error_t
+diskfs_grow (struct node *np, off_t end, struct protid *cred)
+{
+  return EROFS;
+}
+
+error_t
+diskfs_set_translator (struct node *np, char *name, u_int namelen, 
+		       struct protid *cred)
+{
+  return EROFS;
+}
+
+error_t
+diskfs_get_translator (struct node *np, char **namep, u_int *namelen)
+{
+  return EOPNOTSUPP;
+}
+
+void
+diskfs_shutdown_soft_ports ()
+{
+    /* Should initiate termination of internally held pager ports
+     (the only things that should be soft) XXX */
+}
+
+error_t
+diskfs_node_reload (struct node *node)
+{
+  /* Never necessary on a read-only medium */
+  return 0;
+}
+
+error_t
+diskfs_validate_author_change (struct node *np, uid_t author)
+{
+  return EROFS;
+}
+
+error_t
+diskfs_node_iterate (error_t (*fun)(struct node *))
+{
+  /* We never actually have to do anything, because this function
+     is only used for things that have to do with read-write media. */
+  return 0;
+}
+
+void
+diskfs_write_disknode (struct node *np, int wait)
+{
+}
+
+error_t
+diskfs_set_statfs (struct statfs *st)
+{
+  /* XXX return something useful */
+  bzero (st, sizeof *st);
+  return 0;
+}
+
+error_t
+diskfs_S_file_get_storage_info (struct protid *cred,
+				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)
+{
+  /* XXX */
+  return EOPNOTSUPP;
+}
+
+void
+diskfs_free_node (struct node *no, mode_t mode)
+{
+  abort ();
+}
+
+error_t
+diskfs_alloc_node (struct node *dp, mode_t mode, struct node **np)
+{
+  return EROFS;
+}
+
diff --git a/isofs/iso9660.h b/isofs/iso9660.h
new file mode 100644
index 00000000..2fd8cc2b
--- /dev/null
+++ b/isofs/iso9660.h
@@ -0,0 +1,125 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+/* Specification of ISO 9660 format */
+
+/* Volume descriptor */
+
+struct voldesc 
+{
+  unsigned char type;
+  unsigned char id[5];
+  unsigned char version;
+  unsigned char data[0];
+};
+
+/* Volume descriptor types */
+#define VOLDESC_PRIMARY 1
+#define VOLDESC_END 255
+
+/* We don't support any other types */
+
+/* Expected ID */
+#define ISO_STANDARD_ID "CD001"
+
+/* Primary descriptor */
+struct sblock
+{
+  unsigned char type;
+  unsigned char id[5];
+  unsigned char version;
+  unsigned char skip1;
+  unsigned char sysid[32];
+  unsigned char volid[32];
+  unsigned char skip2[8];
+  unsigned char vol_sp_size[8];		/* total number of logical blocks */
+  unsigned char skip[32];
+  unsigned char vol_set_size[4];
+  unsigned char vol_seqno[4];
+  unsigned char blksize[4];		/* logical block size */
+  unsigned char ptsize[8];
+  unsigned char type_l_pt[4];
+  unsigned char opt_type_l_pt[4];
+  unsigned char type_m_pt[4];
+  unsigned char opt_type_m_pt[4];
+  unsigned char root[34];
+  unsigned char volset_id[128];
+  unsigned char pub_id[128];
+  unsigned char prep_id[128];
+  unsigned char app_id[128];
+  unsigned char copyr_id[37];
+  unsigned char abstr_id[37];
+  unsigned char biblio_id[37];
+  unsigned char creation_time[17];
+  unsigned char mod_time[17];
+  unsigned char expir_time[17];
+  unsigned char effect_time[17];
+  unsigned char file_structure;
+  unsigned char skip4;
+  unsigned char appl_data[512];
+  unsigned char skip5[652];
+};
+
+/* Directory record */
+struct dirrect
+{
+  unsigned char len;
+  unsigned char ext_attr_len;
+  unsigned char extent[8];
+  unsigned char size[8];
+  unsigned char date[7];
+  unsigned char flags;
+  unsigned char file_unit_size;
+  unsigned char ileave;
+  unsigned char vol_seqno[4];
+  unsigned char namelen;
+  unsigned char name[0];
+};
+
+
+
+/* Numeric conversions for these fields */
+
+#include <endian.h>
+
+static inline unsigned int 
+isonum_733 (unsigned char *addr)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return *(unsigned int *)addr;
+#elif BYTE_ORDER == BIG_ENDIAN
+  return *(unsigned int *)(addr + 4);
+#else
+  return
+    addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24);
+#endif
+}
+
+static inline unsigned int
+isonum_723 (unsigned char *addr)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return *(unsigned short *)addr;
+#elif BYTE_ORDER == BIG_ENDIAN
+  return *(unsigned short *)addr + 2;
+#else
+  return addr[0] | (addr[1] << 8);
+#endif
+}
diff --git a/isofs/isofs.h b/isofs/isofs.h
new file mode 100644
index 00000000..25c449a6
--- /dev/null
+++ b/isofs/isofs.h
@@ -0,0 +1,88 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+
+#include <sys/types.h>
+#include <hurd/diskfs.h>
+#include <hurd/diskfs-pager.h>
+#include <hurd/store.h>
+
+#include "rr.h"
+
+/* There is no such thing as an inode in this format, all such informatio n
+   being recorded in the directory entry.  So we report inode numbers as
+   absolute offsets from DISK_IMAGE. */
+
+struct disknode
+{
+  off_t file_start; /* In store->block_size units */
+
+  struct user_pager_info *fileinfo;
+
+  char *link_target;		/* for S_ISLNK */
+};
+
+struct user_pager_info
+{
+  struct node *np;
+  enum pager_type
+    {
+      DISK,
+      FILE_DATA,
+    } type;
+    struct pager *p;
+};
+
+/* The physical media */
+extern struct store *store;
+
+char *host_name;
+
+/* Name we are mounted on, with trailing slash */
+char *mounted_on;
+
+/* Mapped image of disk */
+void *disk_image;
+
+/* Processed sblock info */
+
+/* Block size of pointers etc. on disk (6.2.2). */
+size_t logical_block_size;
+
+/* Size of "logical sectors" (6.1.2).  These are 2048 or the
+   largest power of two that will fit in a physical sector, whichever is 
+   greater.  I don't know how to fetch the physical sector size; so
+   we'll just use a constant. */
+#define logical_sector_size	2048
+
+/* Unprocessed superblock */
+struct sblock *sblock;
+
+
+
+void drop_pager_softrefs (struct node *);
+void allow_pager_softrefs (struct node *);
+void create_disk_pager (void);
+
+error_t load_inode (struct node **, struct dirrect *, struct rrip_lookup *);
+error_t calculate_file_start (struct dirrect *, off_t *, struct rrip_lookup *);
+
+char *isodate_915 (char *, struct timespec *);
+char *isodate_84261 (char *, struct timespec *);
diff --git a/isofs/lookup.c b/isofs/lookup.c
new file mode 100644
index 00000000..faed5d28
--- /dev/null
+++ b/isofs/lookup.c
@@ -0,0 +1,448 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+#include <string.h>
+#include <dirent.h>
+#include "isofs.h"
+
+/* Forward */
+static error_t
+dirscanblock (void *, char *, size_t, struct dirrect **, struct rrip_lookup *);
+
+static int
+isonamematch (char *dirname, size_t dnamelen, char *username, size_t unamelen)
+{
+  /* Special representations for `.' and `..' */
+  if (dnamelen == 1 && dirname[0] == '\0')
+    return unamelen == 1 && username[0] == '.';
+  
+  if (dnamelen == 1 && dirname[0] == '\1')
+    return unamelen == 2 && username[0] == '.' && username[1] == '.';
+  
+  if (unamelen > dnamelen)
+    return 0;
+
+  if (!strncasecmp (dirname, username, unamelen))
+    {
+      /* A prefix has matched.  Check if it's acceptable. */
+      if (dnamelen == unamelen)
+	return 1;
+      
+      /* User has ommitted the version number */
+      if (dirname[unamelen] == ';')
+	return 1;
+      
+      /* User has ommitted an empty extension */
+      if (dirname[unamelen] == '.' 
+	  && (dirname[unamelen+1] == '\0' || dirname[unamelen+1] == ';'))
+	return 1;
+    }
+
+  return 0;
+}
+
+/* Implement the diskfs_lookup callback from the diskfs library.  See
+   <hurd/diskfs.h> for the interface specification. */
+error_t
+diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
+		    struct node **npp, struct dirstat *ds, struct protid *cred)
+{
+  error_t err = 0;
+  struct dirrect *record;
+  int namelen;
+  int spec_dotdot;
+  void *buf;
+  void *blockaddr;
+  struct rrip_lookup rr;
+  
+  if ((type == REMOVE) || (type == RENAME))
+    assert (npp);
+
+  if (npp)
+    *npp = 0;
+
+  spec_dotdot = type & SPEC_DOTDOT;
+  type &= ~SPEC_DOTDOT;
+  
+  namelen = strlen (name);
+
+  /* This error is constant, but the errors for CREATE and REMOVE depend
+     on whether NAME exists. */
+  if (type == RENAME)
+    return EROFS;
+
+  buf = disk_image + (dp->dn->file_start << store->log2_block_size);
+  
+  for (blockaddr = buf;
+       blockaddr < buf + dp->dn_stat.st_size;
+       blockaddr += logical_sector_size)
+    {
+      err = dirscanblock (blockaddr, name, namelen, &record, &rr);
+
+      if (!err)
+	break;
+
+      if (err != ENOENT)
+	return err;
+    }
+  
+  if ((!err && type == REMOVE)
+      || (err == ENOENT && type == CREATE))
+    err = EROFS;
+  
+  if (err)
+    return err;
+  
+  /* Load the inode */
+  if (namelen == 2 && name[0] == '.' && name[1] == '.')
+    {
+      if (dp == diskfs_root_node)
+	err = EAGAIN;
+      else if (spec_dotdot)
+	{
+	  /* renames and removes can't get this far. */
+	  assert (type == LOOKUP);
+	  diskfs_nput (dp);
+	  err = load_inode (npp, record, &rr);
+	}
+      else
+	{
+	  /* We don't have to do the normal rigamarole, because
+	     we are permanently read-only, so things are necessarily
+	     quiescent.  Just be careful to honor the locking order. */
+	  mutex_unlock (&dp->lock);
+	  err = load_inode (npp, record, &rr);
+	  mutex_lock (&dp->lock);
+	}
+    }
+  else if (namelen == 1 && name[0] == '.')
+    {
+      *npp = dp;
+      diskfs_nref (dp);
+    }
+  else
+    err = load_inode (npp, record, &rr);
+  
+  release_rrip (&rr);
+  return err;
+}
+
+
+/* Scan one logical sector of directory contents (at address BLKADDR)
+   for NAME of length NAMELEN.  Return its address in *RECORD. */
+static error_t
+dirscanblock (void *blkaddr, char *name, size_t namelen, 
+	      struct dirrect **record, struct rrip_lookup *rr)
+{
+  struct dirrect *entry;
+  void *currentoff;
+  size_t reclen;
+  size_t entry_namelen;
+  int matchrr;
+  int matchnormal;
+
+  for (currentoff = blkaddr;
+       currentoff < blkaddr + logical_sector_size;
+       currentoff += reclen)
+    {
+      entry = (struct dirrect *) currentoff;
+      
+      reclen = entry->len;
+      
+      /* Validate reclen */
+      if (reclen == 0
+	  || reclen < sizeof (struct dirrect)
+	  || currentoff + reclen > blkaddr + logical_sector_size)
+	break;
+
+      entry_namelen = entry->namelen;
+      
+      /* More validation */
+      if (reclen < sizeof (struct dirrect) + entry_namelen)
+	break;
+      
+      /* Check to see if the name maches the directory entry. */
+      if (isonamematch (entry->name, entry_namelen, name, namelen))
+	matchnormal = 1;
+      else
+	matchnormal = 0;
+
+      /* Now scan for RRIP fields */
+      matchrr = rrip_match_lookup (entry, name, namelen, rr);
+      
+      /* Ignore RE entries */
+      if (rr->valid & VALID_RE)
+	{
+	  release_rrip (rr);
+	  continue;
+	}
+      
+      /* See if the name matches */
+      if (((rr->valid & VALID_NM) && matchrr)
+	  || (!(rr->valid & VALID_NM) && matchnormal))
+	{
+	  /* We've got it.  Return success */
+	  *record = entry;
+	  return 0;
+	}
+
+      release_rrip (rr);
+    }
+
+  /* Wasn't there. */
+  *record = 0;
+  return ENOENT;
+}
+
+error_t
+diskfs_get_directs (struct node *dp,
+		    int entry,
+		    int nentries,
+		    char **data,
+		    u_int *datacnt,
+		    vm_size_t bufsiz,
+		    int *amt)
+{
+  volatile vm_size_t allocsize;
+  struct dirrect *ep;
+  struct dirent *userp;
+  int i;
+  void *dirbuf, *bufp;
+  char *datap;
+  volatile int ouralloc = 0;
+  error_t err;
+
+  /* Allocate some space to hold the returned data. */
+  allocsize = bufsiz ? round_page (bufsiz) : vm_page_size * 4;
+  if (allocsize > *datacnt)
+    {
+      vm_allocate (mach_task_self (), (vm_address_t *) data, allocsize, 1);
+      ouralloc = 1;
+    }
+  
+  err = diskfs_catch_exception ();
+  if (err)
+    {
+      if (ouralloc)
+	vm_deallocate (mach_task_self (), (vm_address_t)*data, allocsize);
+      return err;
+    }
+
+  /* Skip to ENTRY */
+  dirbuf = disk_image + (dp->dn->file_start << store->log2_block_size); 
+  bufp = dirbuf;
+  for (i = 0; i < entry; i ++)
+    {
+      struct rrip_lookup rr;
+      
+      ep = (struct dirrect *) bufp;
+      rrip_lookup (ep, &rr, 0);
+
+      /* Ignore and skip RE entries */
+      if (rr.valid & VALID_RE)
+	{
+	  bufp = bufp + ep->len;
+	  release_rrip (&rr);
+	  continue;
+	}
+
+      if (bufp - dirbuf >= dp->dn_stat.st_size)
+	{
+	  /* Not that many entries in the directory; return nothing. */
+	  if (allocsize > *datacnt)
+	    vm_deallocate (mach_task_self (), (vm_address_t) data, allocsize);
+	  *datacnt = 0;
+	  *amt = 0;
+	  return 0;
+	}
+      bufp = bufp + ep->len;
+
+      /* If BUFP points at a null, then we have hit the last
+	 record in this logical sector.  In that case, skip up to
+	 the next logical sector. */
+      if (*(char *)bufp == '\0')
+	bufp = (void *) (((long) bufp & ~(logical_sector_size - 1))
+			 + logical_sector_size);
+    }
+  
+  /* Now copy entries one at a time */
+  i = 0;
+  datap = *data;
+  while (((nentries == -1) || (i < nentries))
+	 && (!bufsiz || datap - *data < bufsiz)
+	 && ((void *) bufp - dirbuf < dp->dn_stat.st_size))
+    {
+      struct rrip_lookup rr;
+      char *name;
+      size_t namlen, reclen;
+      off_t file_start;
+
+      ep = (struct dirrect *) bufp;
+
+      /* Fetch Rock-Ridge information for this file */
+      rrip_lookup (ep, &rr, 0);
+
+      /* Ignore and skip RE entries */
+      if (rr.valid & VALID_RE)
+	{
+	  bufp = bufp + ep->len;
+	  release_rrip (&rr);
+	  continue;
+	}
+
+      /* See if there's room to hold this one */
+      name = rr.valid & VALID_NM ? rr.name : ep->name;
+      namlen = rr.valid & VALID_NM ? strlen (name) : ep->namelen;
+
+      /* Name frobnication */
+      if (!(rr.valid & VALID_NM))
+	{
+	  if (namlen == 1 && name[0] == '\0')
+	    {
+	      name = ".";
+	      namlen = 1;
+	    }
+	  else if (namlen == 1 && name[0] == '\1')
+	    {
+	      name = "..";
+	      namlen = 2;
+	    }
+	  /* Perhaps downcase it too? */
+	}
+
+      reclen = sizeof (struct dirent) + namlen;
+      reclen = (reclen + 3) & ~3;
+      
+      /* Expand buffer if necessary */
+      if (datap - *data + reclen > allocsize)
+	{
+	  vm_address_t newdata;
+
+	  vm_allocate (mach_task_self (), &newdata, 
+		       (ouralloc
+			? (allocsize *= 2)
+			: (allocsize = vm_page_size * 2)), 1);
+	  bcopy ((void *) *data, (void *)newdata, datap - *data);
+	  
+	  if (ouralloc)
+	    vm_deallocate (mach_task_self (), (vm_address_t) *data, 
+			   allocsize / 2);
+	 
+ 	  datap = (char *) newdata + (datap - *data);
+	  *data = (char *) newdata;
+	  ouralloc = 1;
+	}
+	  
+      userp = (struct dirent *) datap;
+
+      /* Fill in entry */
+      
+      err = calculate_file_start (ep, &file_start, &rr);
+      if (err)
+	{
+	  diskfs_end_catch_exception ();
+	  if (ouralloc)
+	    vm_deallocate (mach_task_self (), (vm_address_t) *data, allocsize);
+	  return err;
+	}
+	
+      userp->d_fileno = file_start;
+      userp->d_type = DT_UNKNOWN;
+      userp->d_reclen = reclen;
+      userp->d_namlen = namlen;
+      bcopy (name, userp->d_name, namlen);
+      userp->d_name[namlen] = '\0';
+      
+      /* And move along */
+      release_rrip (&rr);
+      datap = datap + reclen;
+      bufp = bufp + ep->len;
+      i++;
+
+      /* If BUFP points at a null, then we have hit the last
+	 record in this logical sector.  In that case, skip up to
+	 the next logical sector. */
+      if (*(char *)bufp == '\0')
+	bufp = (void *) (((long) bufp & ~(logical_sector_size - 1))
+			 + logical_sector_size);
+    }
+
+  diskfs_end_catch_exception ();
+
+  /* If we didn't use all the pages of a buffer we allocated, free
+     the excess.  */
+  if (ouralloc
+      && round_page (datap - *data) < round_page (allocsize))
+    vm_deallocate (mach_task_self (), round_page (datap),
+		   round_page (allocsize) - round_page (datap - *data));
+  
+  /* Return */
+  *amt = i;
+  *datacnt = datap - *data;
+  return 0;
+}
+
+/* We have no dirstats at all. */
+size_t diskfs_dirstat_size = 0;
+
+void
+diskfs_null_dirstat (struct dirstat *ds)
+{
+}
+
+error_t
+diskfs_drop_dirstat (struct node *dp, struct dirstat *ds)
+{
+  return 0;
+}
+
+/* These should never be called. */
+
+error_t
+diskfs_direnter_hard(struct node *dp,
+		     char *name,
+		     struct node *np,
+		     struct dirstat *ds,
+		     struct protid *cred)
+{
+  abort ();
+}
+
+error_t
+diskfs_dirremove_hard(struct node *dp,
+		      struct dirstat *ds)
+{
+  abort ();
+}
+
+error_t
+diskfs_dirrewrite_hard(struct node *dp, 
+		       struct node *np,
+		       struct dirstat *ds)
+{
+  abort ();
+}
+
+int
+diskfs_dirempty(struct node *dp,
+		struct protid *cred)
+{
+  abort ();
+}
diff --git a/isofs/main.c b/isofs/main.c
new file mode 100644
index 00000000..dcefd51d
--- /dev/null
+++ b/isofs/main.c
@@ -0,0 +1,178 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+#include <string.h>
+#include <error.h>
+#include <argp.h>
+#include <version.h>
+#include <limits.h>
+#include "isofs.h"
+
+struct node *diskfs_root_node;
+struct store *store = 0;
+struct store_parsed *store_parsed = 0;
+char *diskfs_disk_name = 0;
+
+char *diskfs_server_name = "isofs";
+char *diskfs_server_version = HURD_VERSION;
+char *diskfs_extra_version = "GNU Hurd";
+int diskfs_synchronous = 0;
+
+int diskfs_link_max = INT_MAX;
+int diskfs_maxsymlinks = 8;
+
+int diskfs_readonly = 1;
+
+/* Fetch the root node */
+static void
+fetch_root ()
+{
+  struct rrip_lookup rl;
+  struct dirrect *dr;
+  error_t err;
+
+  dr = (struct dirrect *) sblock->root;
+
+  /* First check for SUSP and all relevant extensions */
+  rrip_initialize (dr);
+  
+  /* Now rescan the node for real */
+  rrip_lookup (dr, &rl, 1);
+  
+  /* And fetch the node. */
+  err = load_inode (&diskfs_root_node, dr, &rl);
+  assert_perror (err);
+  
+  mutex_unlock (&diskfs_root_node->lock);
+}
+
+
+/* Find and read the superblock.  */
+static void
+read_sblock ()
+{
+  struct voldesc *vd;
+  error_t err;
+  struct sblock * volatile sb = 0;
+  
+  err = diskfs_catch_exception ();
+  if (err)
+    error (4, err, "reading superblock");
+  
+  /* Start at logical sector 16 and keep going until
+     we find a matching superblock */
+  for (vd = disk_image + (logical_sector_size * 16);
+       (void *) vd < disk_image + (logical_sector_size * 500); /* for sanity */
+       vd = (void *) vd + logical_sector_size)
+    {
+      if (vd->type == VOLDESC_END)
+	break;
+
+      if (vd->type == VOLDESC_PRIMARY
+	  && !memcmp (ISO_STANDARD_ID, vd->id, 5)
+	  && vd->version == 1)
+	{
+	  /* Here's a valid primary descriptor. */
+	  sb = (struct sblock *) vd;
+	  break;
+	}
+    }
+  
+  if (!sb)
+    error (1, 0, "Could not find valid superblock");
+
+  sblock = malloc (sizeof (struct sblock));
+  bcopy (sb, sblock, sizeof (struct sblock));
+  diskfs_end_catch_exception ();
+
+  /* Parse some important bits of this */
+  logical_block_size = isonum_723 (sblock->blksize);
+}
+
+int
+main (int argc, char **argv)
+{
+  error_t err;
+  mach_port_t bootstrap;
+  struct store_argp_params store_params = { 0 };
+
+  argp_parse (&diskfs_store_startup_argp, argc, argv, 0, 0, &store_params);
+  store_parsed = store_params.result;
+  
+  err = store_parsed_name (store_parsed, &diskfs_disk_name);
+  if (err)
+    error (2, err, "store_parsed_name");
+  
+  diskfs_console_stdio ();
+  
+  if (diskfs_boot_flags)
+    bootstrap = MACH_PORT_NULL;
+  else
+    {
+      task_get_bootstrap_port (mach_task_self (), &bootstrap);
+      if (bootstrap == MACH_PORT_NULL)
+	error (2, 0, "Must be started as a translator");
+    }
+
+  err = diskfs_init_diskfs ();
+  if (err)
+    error (4, err, "init");
+  
+  err = store_parsed_open (store_parsed, STORE_READONLY, &store);
+  if (err)
+    error (3, err, "%s", diskfs_disk_name);
+   
+  diskfs_readonly = diskfs_hard_readonly = 1;
+
+  create_disk_pager ();
+  
+  diskfs_spawn_first_thread ();
+  
+  read_sblock ();
+  
+  fetch_root ();
+  
+  diskfs_startup_diskfs (bootstrap, 0);
+  
+  cthread_exit (0);
+  
+  return 0;
+}
+
+/* Nothing to do for read-only medium */
+error_t
+diskfs_reload_global_state ()
+{
+  return 0;
+}
+
+error_t
+diskfs_set_hypermetadata (int wait, int clean)
+{
+  return 0;
+}
+
+void
+diskfs_readonly_changed (int readonly)
+{
+  /* We should never get here because we define our own diskfs_set_readonly
+     above. */
+  abort ();
+}
diff --git a/isofs/pager.c b/isofs/pager.c
new file mode 100644
index 00000000..f02d2f35
--- /dev/null
+++ b/isofs/pager.c
@@ -0,0 +1,341 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+#include <string.h>
+#include "isofs.h"
+
+spin_lock_t node2pagelock = SPIN_LOCK_INITIALIZER;
+
+struct port_bucket *pager_bucket;
+
+/* Mapped image of the disk */
+void *disk_image;
+
+
+/* Implement the pager_read_page callback from the pager library.  See
+   <hurd/pager.h> for the interface definition.  */
+error_t
+pager_read_page (struct user_pager_info *upi,
+		 vm_offset_t page,
+		 vm_address_t *buf,
+		 int *writelock)
+{
+  error_t err;
+  daddr_t addr;
+  struct node *np = upi->np;
+  size_t read = 0;
+  size_t overrun = 0;
+
+  /* This is a read-only medium */
+  *writelock = 1;
+
+  if (upi->type == FILE_DATA)
+    {
+      addr = np->dn->file_start + (page >> store->log2_block_size);
+  
+      if (page >= np->dn_stat.st_size)
+	{
+	  vm_allocate (mach_task_self (), buf, vm_page_size, 1);
+	  return 0;
+	}
+
+      if (page + vm_page_size > np->dn_stat.st_size)
+	overrun = page + vm_page_size - np->dn_stat.st_size;
+    }
+  else
+    {
+      assert (upi->type == DISK);
+      addr = page >> store->log2_block_size;
+    }
+
+  err = store_read (store, addr, vm_page_size, (void **) buf, &read);
+  if (read != vm_page_size)
+    return EIO;
+
+  if (overrun)
+    bzero ((void *) *buf + vm_page_size - overrun, overrun);
+    
+  return 0;
+}
+
+/* This function should never be called.  */
+error_t
+pager_write_page (struct user_pager_info *pager,
+		  vm_offset_t page,
+		  vm_address_t buf)
+{
+  assert (0);
+}
+
+/* Never permit unlocks to succeed. */
+error_t
+pager_unlock_page (struct user_pager_info *pager,
+		   vm_offset_t address)
+{
+  return EROFS;
+}
+
+/* Tell how big the file is. */
+error_t
+pager_report_extent (struct user_pager_info *pager,
+		     vm_address_t *offset,
+		     vm_size_t *size)
+{
+  *offset = 0;
+  *size = pager->np->dn_stat.st_size;
+  return 0;
+}
+
+/* Implement the pager_clear_user_data callback from the pager library. */
+void
+pager_clear_user_data (struct user_pager_info *upi)
+{
+  if (upi->type == FILE_DATA)
+    {
+      spin_lock (&node2pagelock);
+      if (upi->np->dn->fileinfo == upi)
+	upi->np->dn->fileinfo = 0;
+      spin_unlock (&node2pagelock);
+      diskfs_nrele_light (upi->np);
+    }
+  free (upi);
+}
+
+void
+pager_dropweak (struct user_pager_info *upi)
+{
+}
+
+
+/* Create the disk pager */
+void
+create_disk_pager (void)
+{
+  struct user_pager_info *upi = malloc (sizeof (struct user_pager_info));
+  
+  upi->type = DISK;
+  upi->np = 0;
+  pager_bucket = ports_create_bucket ();
+  diskfs_start_disk_pager (upi, pager_bucket, 1, store->size, &disk_image);
+  upi->p = diskfs_disk_pager;
+}
+
+/* This need not do anything */
+void
+diskfs_file_update (struct node *np,
+		    int wait)
+{
+}
+
+/* Create a FILE_DATA pager for the specified node */
+mach_port_t
+diskfs_get_filemap (struct node *np, vm_prot_t prot)
+{
+  struct user_pager_info *upi;
+  mach_port_t right;
+  
+  assert (S_ISDIR (np->dn_stat.st_mode)
+	  || S_ISREG (np->dn_stat.st_mode)
+	  || S_ISLNK (np->dn_stat.st_mode));
+  
+  spin_lock (&node2pagelock);
+  
+  do
+    if (!np->dn->fileinfo)
+      {
+	upi = malloc (sizeof (struct user_pager_info));
+	upi->type = FILE_DATA;
+	upi->np = np;
+	diskfs_nref_light (np);
+	upi->p = pager_create (upi, pager_bucket, 1, MEMORY_OBJECT_COPY_DELAY);
+	np->dn->fileinfo = upi;
+	right = pager_get_port (np->dn->fileinfo->p);
+	ports_port_deref (np->dn->fileinfo->p);
+      }
+    else
+      {
+	/* Because NP->dn->fileinfo->p is not a real reference,
+	   this might be nearly deallocated.  If that's so, then
+	   the port right will be null.  In that case, clear here
+	   and loop.  The deallocation will complete separately. */
+	right = pager_get_port (np->dn->fileinfo->p);
+	if (right == MACH_PORT_NULL)
+	  np->dn->fileinfo = 0;
+      }
+  while (right == MACH_PORT_NULL);
+  
+  spin_unlock (&node2pagelock);
+  
+  mach_port_insert_right (mach_task_self (), right, right, 
+			  MACH_MSG_TYPE_MAKE_SEND);
+  
+  return right;
+}
+
+/* Call this when we should turn off caching so that unused memory
+   object ports get freed.  */
+void
+drop_pager_softrefs (struct node *np)
+{
+  struct user_pager_info *upi;
+
+  spin_lock (&node2pagelock);
+  upi = np->dn->fileinfo;
+  if (upi)
+    ports_port_ref (upi->p);
+  spin_unlock (&node2pagelock);
+
+  if (upi)
+    {
+      pager_change_attributes (upi->p, 0, MEMORY_OBJECT_COPY_DELAY, 0);
+      ports_port_deref (upi->p);
+    }
+}
+
+/* Call this when we should turn on caching because it's no longer
+   important for unused memory object ports to get freed.  */
+void
+allow_pager_softrefs (struct node *np)
+{
+  struct user_pager_info *upi;
+
+  spin_lock (&node2pagelock);
+  upi = np->dn->fileinfo;
+  if (upi)
+    ports_port_ref (upi->p);
+  spin_unlock (&node2pagelock);
+
+  if (upi)
+    {
+      pager_change_attributes (upi->p, 1, MEMORY_OBJECT_COPY_DELAY, 0);
+      ports_port_deref (upi->p);
+    }
+}
+	
+	
+static void
+block_caching ()
+{
+  error_t block_cache (void *arg)
+    {
+      struct pager *p = arg;
+
+      pager_change_attributes (p, 0, MEMORY_OBJECT_COPY_DELAY, 1);
+      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_bucket, block_cache);
+}
+	  
+static void
+enable_caching ()
+{
+  error_t enable_cache (void *arg)
+    {
+      struct pager *p = arg;
+      struct user_pager_info *upi = pager_get_upi (p);
+
+      pager_change_attributes (p, 1, MEMORY_OBJECT_COPY_DELAY, 0);
+
+      /* It's possible that we didn't have caching on before, because
+	 the user here is the only reference to the underlying node
+	 (actually, that's quite likely inside this particular
+	 routine), and if that node has no links.  So dinkle the node
+	 ref counting scheme here, which will cause caching to be
+	 turned off, if that's really necessary.  */
+      if (upi->type == FILE_DATA)
+	{
+	  diskfs_nref (upi->np);
+	  diskfs_nrele (upi->np);
+	}
+
+      return 0;
+    }
+
+  ports_bucket_iterate (pager_bucket, enable_cache);
+}
+
+	    
+/* Tell diskfs if there are pagers exported, and if none, then
+   prevent any new ones from showing up.  */
+int
+diskfs_pager_users ()
+{
+  int npagers = ports_count_bucket (pager_bucket);
+
+  if (npagers <= 1)
+    return 0;
+
+  block_caching ();
+
+  /* Give it a second; the kernel doesn't actually shutdown
+     immediately.  XXX */
+  sleep (1);
+
+  npagers = ports_count_bucket (pager_bucket);
+  if (npagers <= 1)
+    return 0;
+
+  /* Darn, there are actual honest users.  Turn caching back on,
+     and return failure. */
+  enable_caching ();
+
+  ports_enable_bucket (pager_bucket);
+
+  return 1;
+}
+
+/* Return the bitwise or of the maximum prot parameter (the second arg to
+   diskfs_get_filemap) for all active user pagers. */
+vm_prot_t
+diskfs_max_user_pager_prot ()
+{
+  /* We never allow writing, so there's no need to carefully check it. */
+  return VM_PROT_READ | VM_PROT_EXECUTE;
+}
+
+/* Call this to find out the struct pager * corresponding to the
+   FILE_DATA pager of inode IP.  This should be used *only* as a subsequent
+   argument to register_memory_fault_area, and will be deleted when
+   the kernel interface is fixed.  NP must be locked.  */
+struct pager *
+diskfs_get_filemap_pager_struct (struct node *np)
+{
+  /* This is safe because fileinfo can't be cleared; there must be
+     an active mapping for this to be called. */
+  return np->dn->fileinfo->p;
+}
+
+/* Shutdown all the pagers. */
+void
+diskfs_shutdown_pager ()
+{
+  /* Because there's no need to ever sync, we don't have to do anything
+     here. */
+}
+
+/* Sync all the pagers. */
+void
+diskfs_sync_everything (int wait)
+{
+  /* ditto */
+}
diff --git a/isofs/rr.c b/isofs/rr.c
new file mode 100644
index 00000000..666eb6ec
--- /dev/null
+++ b/isofs/rr.c
@@ -0,0 +1,600 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+/* Parse Rock-Ridge and related SUSP conformant extensions. */
+
+#include <stdio.h>
+#include <string.h>
+#include "isofs.h"
+
+/* These tell whether the specified extensions are on or not. */
+int susp_live = 0;
+int rock_live = 0;
+
+/* How far to skip when reading SUSP fields. */
+int susp_skip = 0;
+
+void
+release_rrip (struct rrip_lookup *rr)
+{
+  if ((rr->valid & VALID_NM) && rr->name)
+    free (rr->name);
+  if ((rr->valid & VALID_SL) && rr->target)
+    free (rr->target);
+}
+
+
+/* Work function combining the three interfaces below. */
+static int
+rrip_work (struct dirrect *dr, struct rrip_lookup *rr,
+	   char *match_name, char match_name_len,
+	   int initializing, int ignorenm)
+{
+  void *bp, *terminus;
+  void *slbuf, *nmbuf;
+  size_t slbufsize, nmbufsize;
+  int nomorenm, nomoresl;
+
+  /* Initialize RR */
+  rr->valid = 0;
+  rr->target = rr->name = 0;
+
+  if (!susp_live && !initializing)
+    return 0;
+
+  /* The only extensions we currently support are rock-ridge, so
+     this test will cut a lot of useless work. */
+  if (!rock_live && !initializing)
+    return 0;
+
+  /* Initialized the name buffers */
+  nmbuf = slbuf = 0;
+  nmbufsize = slbufsize = 0;
+  nomorenm = nomoresl = 0;
+
+  /* Find the beginning and end of the SUSP area */
+
+  /* If this is the root node, from the root directory, then
+     we look in a special place.  This only happens during the two
+     calls in fetch_root, and we know exactly what the value passed
+     is there.  */
+
+  if (dr == (struct dirrect *)sblock->root)
+    {
+      struct dirrect *p;
+      off_t filestart;
+      char *c;
+      error_t err;
+
+      /* Look at the first directory entry in root. */
+      err = calculate_file_start (dr, &filestart, 0);
+      if (err)
+	return 0;		/* give up */
+      p = disk_image + (filestart << store->log2_block_size);
+      
+      /* Set C to the system use area. */
+      c = p->name + p->namelen;
+      if ((int)c & 1)
+	c++;
+      
+      /* There needs to be an SUSP SP field right here; make sure there is */
+      if (!bcmp (c, "SP\7\1\276\357", 6))
+	bp = c;
+      else if (!bcmp (c + 15, "SP\7\1\276\357", 6))
+	/* Detect CD-ROM XA disk */
+	bp = c + 15;	
+      else
+	/* No SUSP, give up. */
+	return 0;
+
+      terminus = (char *) p + p->len;
+    }
+  else
+    {
+      /* It's in the normal place. */
+      bp = dr->name + dr->namelen;
+      if ((int) bp & 1)
+	bp++;			/* must be even */
+      bp += susp_skip;		/* skip to start of susp area */
+      terminus = (char *) dr + dr->len;
+    }
+  
+
+  /* Loop across all the fields, processing them one at a time. */
+
+  while (bp < terminus)
+    {
+      struct su_header *susp = bp;
+      void *body;
+      
+      /* Make sure the whole thing fits */
+      if (bp + sizeof (struct su_header) > terminus
+	  || bp + susp->len > terminus)
+	break;
+      
+      body = (char *) susp + sizeof (struct su_header);
+
+      /* CE means that further extension fields are elsewhere on 
+	 the disk.  We just reset the pointers and keep going. */
+      if (susp->sig[0] == 'C'
+	  && susp->sig[1] == 'E'
+	  && susp->version == 1)
+	{
+	  int offset;
+	  int location;
+	  int size;
+	  struct su_ce *ce = body;
+
+	  offset = isonum_733 (ce->offset);
+	  location = isonum_733 (ce->continuation);
+	  size = isonum_733 (ce->size);
+	  
+	  /* Reset pointers */
+	  bp = disk_image + (location * logical_block_size) + offset;
+	  terminus = bp + size;
+
+	  /* NOT goto next_field */
+	  continue;
+	}
+
+      /* Only on the root node; SP signals that the sharing protocol
+	 is in use. */
+      if (initializing
+	       && susp->sig[0] == 'S'
+	       && susp->sig[1] == 'P'
+	       && susp->version == 1)
+	{
+	  /* Sharing Protocol */
+	  struct su_sp *sp = body;
+	  
+	  /* Verify magic numbers */
+	  if (sp->check[0] == SU_SP_CHECK_0
+	      && sp->check[1] == SU_SP_CHECK_1)
+	    susp_live = 1;
+	  
+	  susp_skip = sp->skip;
+
+	  goto next_field;
+	}
+
+      /* Only on the root node; ER signals that a specified extension
+	 is present.  We implement and check for only the Rock Ridge
+	 extension. */
+      if (initializing 
+	  && susp->sig[0] == 'E'
+	  && susp->sig[1] == 'R'
+	  && susp->version == 1)
+	{
+	  /* Extension Reference */
+	  struct su_er *er = body;
+	  char *c;
+
+	  /* The only extension we currently support is Rock-Ridge. */
+	  
+	  /* Make sure the ER field is valid */
+	  if ((void *) er->more + er->len_id + er->len_des + er->len_src
+	      < terminus)
+	    goto nomatch;
+	  
+	  if (er->ext_ver != ROCK_VERS)
+	    goto nomatch;
+	  
+	  c = er->more;
+	  if (memcmp (ROCK_ID, c, er->len_id))
+	    goto nomatch;
+
+	  /* At this point we know we have Rock-Ridge, but
+	     we check these and moan about it if they are wrong. */
+
+	  c += er->len_id;
+	  if (memcmp (ROCK_DES, c, er->len_des))
+	    fprintf (stderr, "isofs warning: Rock-Ridge extension description is not standard: %s\n", c);
+
+	  c += er->len_des;
+	  if (memcmp (ROCK_SRC, c, er->len_src))
+	    fprintf (stderr, "isofs warning: Rock-Ridge extensions source is not standard: %s\n", c);
+
+	  rock_live = 1;
+
+	nomatch:
+	  goto next_field;
+	}
+
+      /* PD fields are padding and just get ignored. */
+      if (susp->sig[0] == 'P'
+	  && susp->sig[1] == 'D'
+	  && susp->version == 1)
+	goto next_field;
+
+      /* ST fields mean that there are no more SUSP fields to be processed. */
+      if (susp->sig[0] == 'S'
+	  && susp->sig[1] == 'T'
+	  && susp->version == 1)
+	/* All done */
+	break;
+	  
+      /* The rest are Rock-Ridge, and are not interesting if we are doing
+	 setup. */
+	 
+      if (initializing || !rock_live)
+	goto next_field;
+      
+      /* RE is present in a directory entry to mean that the node 
+	 is specified by a CL field elsewhere.  So this entry needs
+	 to be ignored by anyone who understands CL fields. */
+      if (susp->sig[0] == 'R'
+	  && susp->sig[1] == 'E'
+	  && susp->version == 1)
+	{
+	  rr->valid |= VALID_RE;
+
+	  /* No point in parsing anything else now. */
+	  break;
+	}
+
+      /* NM identifies the real name of the file; it overrides
+	 the name in the directory. */
+      if (susp->sig[0] == 'N'
+	  && susp->sig[1] == 'M'
+	  && susp->version == 1
+	  && !ignorenm)
+	{
+	  struct rr_nm *nm = body;
+	  size_t nmlen = susp->len - 5;
+	  char *name;
+	  size_t namelen;
+	  
+	  if (nomorenm)
+	    goto next_field;
+	  
+	  if (nm->flags & NAME_DOT)
+	    {
+	      name = ".";
+	      namelen = 1;
+	      goto finalize_nm;
+	    }
+	  else if (nm->flags & NAME_DOTDOT)
+	    {
+	      name = "..";
+	      namelen = 2;
+	      goto finalize_nm;
+	    }
+	  else if (nm->flags & NAME_HOST)
+	    {
+	      name = host_name;
+	      namelen = strlen (host_name);
+	      goto finalize_nm;
+	    }
+
+	  /* Add this component to the list. */
+
+	  /* We don't store a trailing null here, but we always leave
+	     room for it.  The null gets stored in the finalization
+	     code below. */
+	  if (!nmbuf)
+	    nmbuf = malloc ((nmbufsize = nmlen) + 1);
+	  else
+	    nmbuf = realloc (nmbuf, (nmbufsize += nmlen) + 1);
+	  assert (nmbuf);
+	  
+	  bcopy (nm->name, nmbuf + nmbufsize - nmlen, nmlen);
+	  
+	  if (nm->flags & NAME_CONTINUE)
+	    goto next_field;
+
+	  name = nmbuf;
+	  namelen = nmbufsize;
+	  
+	finalize_nm:
+	  nomorenm = 1;
+
+	  /* Is this a failed match? */
+	  if (match_name && (match_name_len != namelen
+	      || memcmp (match_name, name, match_name_len)))
+	    return 0;
+	  	
+	  /* Store the name */
+	  rr->valid |= VALID_NM;
+	  if (name != nmbuf)
+	    {
+	      rr->name = malloc (namelen + 1);
+	      strcpy (rr->name, name);
+	    }
+	  else
+	    {
+	      rr->name = name;
+	      name[namelen] = '\0';
+	    }
+	  
+	  if (rr->valid & VALID_CL)
+	    /* Finalize CL processing. */
+	    goto clrecurse;
+
+	  goto next_field;
+	}
+
+      /* PX gives mode, nlink, uid, and gid posix-style attributes. */
+      if (susp->sig[0] == 'P'
+	  && susp->sig[1] == 'X'
+	  && susp->version == 1)
+	{
+	  struct rr_px *px = body;
+	  
+	  rr->valid |= VALID_PX;
+	  
+	  rr->mode = isonum_733 (px->mode);
+	  rr->nlink = isonum_733 (px->nlink);
+	  rr->uid = isonum_733 (px->uid);
+	  rr->gid = isonum_733 (px->gid);
+	  
+	  goto next_field;
+	}
+      
+      /* PN, for S_ISCHR and S_ISDEV devices gives the magic numbers */
+      if (susp->sig[0] == 'P'
+	  && susp->sig[1] == 'N'
+	  && susp->version == 1)
+	{
+#define makedev(maj,min) ((((maj)&0xFF)<<8)+((min)&0xFF))
+	  struct rr_pn *pn = body;
+	  
+	  rr->valid |= VALID_PN;
+	  rr->rdev = makedev (isonum_733 (pn->high), isonum_733 (pn->low));
+	  
+	  goto next_field;
+	}
+      
+      /* SL tells, for a symlink, what the target of the link is */
+      if (susp->sig[0] == 'S'
+	  && susp->sig[1] == 'L'
+	  && susp->version == 1)
+	{
+	  struct rr_sl *sl = body;
+	  size_t crlen = susp->len - 5;
+	  struct rr_sl_comp *comp;
+	  void *cp;
+	  size_t targalloced, targused;
+	  
+	  void add_comp (char *cname, size_t cnamelen)
+	    {
+	      if (rr->target == 0)
+		{
+		  rr->target = malloc (cnamelen * 2);
+		  targused = cnamelen;
+		  targalloced = cnamelen * 2;
+		}
+	      else if (targused + cnamelen > targalloced)
+		rr->target = realloc (rr->target, targalloced *= 2);
+	      assert (rr->target);
+	      
+	      bcopy (cname, rr->target + targused, cnamelen);
+	      targused += cnamelen;
+	    }
+	      
+	  if (nomoresl)
+	    goto next_field;
+
+	  /* Append the component use fields to the records we are saving
+	     up */
+
+	  if (!slbuf)
+	    slbuf = malloc (slbufsize = crlen);
+	  else
+	    slbuf = realloc (slbuf, slbufsize += crlen);
+	  assert (slbuf);
+	  
+	  bcopy (sl->data, slbuf + slbufsize - crlen, crlen);
+	  
+	  if (sl->flags & 1)
+	    /* We'll finish later. */
+	    goto next_field;
+
+	  /* Do the symlink translation */
+	  for (cp = slbuf; cp < slbuf + slbufsize; cp += comp->len)
+	    {
+	      comp = (struct rr_sl_comp *)cp;
+	      nomoresl = 1;
+	      
+	      /* Put in a slash after each component as we go,
+		 unless it's a "continuation" component. */
+
+	      if (comp->flags & NAME_DOT)
+		add_comp ("./", 2);
+	      else if (comp->flags & NAME_DOTDOT)
+		add_comp ("../", 3);
+	      else if (comp->flags & NAME_ROOT)
+		{
+		  targused = 0;
+		  add_comp ("/", 1);
+		}
+	      else if (comp->flags & NAME_VOLROOT)
+		{
+		  targused = 0;
+		  add_comp (mounted_on, strlen (mounted_on));
+		}
+	      else if (comp->flags & NAME_HOST)
+		{
+		  add_comp (host_name, strlen (host_name));
+		  add_comp ("/", 1);
+		}
+	      else
+		{
+		  add_comp (comp->name, comp->len);
+		  if (!(comp->flags & NAME_CONTINUE))
+		    add_comp ("/", 1);
+		}
+	    }
+
+	  /* And turn the final character, if it's a slash, into a null.
+	     Otherwise, add a null. */
+	  if (rr->target[targused - 1] == '/')
+	    rr->target[targused - 1] = '\0';
+	  else
+	    add_comp ("", 1);
+
+	  free (slbuf);
+	  goto next_field;
+	}
+	
+      /* TF gives atime, mtime, ctime (and others we don't care about);
+	 this overrides the time specified in the directory. */
+      if (susp->sig[0] == 'T'
+	  && susp->sig[1] == 'F'
+	  && susp->version == 1)
+	{
+	  char *(*convert)(char *, struct timespec *);
+	  struct rr_tf *tf = body;
+	  char *c;
+	  
+	  if (tf->flags & TF_LONG_FORM)
+	    convert = isodate_84261;
+	  else
+	    convert = isodate_915;
+
+	  rr->valid |= VALID_TF;
+	  rr->tfflags = tf->flags;
+	  c = tf->data;
+
+	  if (rr->tfflags & TF_CREATION)
+	    c = (*convert) (c, &rr->ctime);
+	  if (rr->tfflags & TF_MODIFY)
+	    c = (*convert) (c, &rr->mtime);
+	  if (rr->tfflags & TF_ACCESS)
+	    c = (*convert) (c, &rr->atime);
+
+	  goto next_field;
+	}
+      
+      /* CL means that this entry is a relocated directory.  We ignore
+	 the attributes in this directory entry (except for NM); they
+	 are fetched from the "." entry of the directory itself.  The
+	 CL field identifies the location of the directory, overriding
+	 the location given in the present directory.  This directory
+	 is listed somewhere else too (to keep the format ISO 9660 compliant),
+	 but there's an RE entry on that one so that we ignore it. */
+      if (susp->sig[0] == 'C'
+	  && susp->sig[1] == 'L'
+	  && susp->version == 1)
+	{
+	  struct rr_cl *cl = body;
+
+	  rr->realdirent
+	    = disk_image + (isonum_733 (cl->loc) * logical_block_size);
+	  rr->valid |= VALID_CL;
+
+	  if (rr->valid & VALID_NM)
+	    {
+	      /* We've gotten all we care about from this node.
+		 Remember the NM name, and load all the contents
+		 from the new location. */
+	      char *savename;
+	      struct dirrect *realdir;
+
+	    clrecurse:
+	      /* It might look like VALID_NM is alway set here, but if
+		 we got here from the exit point of the function, then
+		 VALID_NM is actually clear. */
+
+	      /* Save these, becuase rrip_work will clear them. */
+	      savename = (rr->valid & VALID_NM) ? rr->name : 0;
+	      realdir = rr->realdirent;
+
+	      rrip_work (realdir, rr, 0, 0, 0, 1);
+	      
+	      rr->valid |= VALID_CL;
+	      rr->realdirent = realdir;
+	      if (savename)
+		{
+		  rr->valid |= VALID_NM;
+		  rr->name = savename;
+		}
+	      
+	      /* If there's an NM field, then we must have matched
+		 if we got here. */
+	      return (rr->valid & VALID_NM) ? 1 : 0;
+	    }
+	  
+	  /* We must keep looking for an NM record.  When we find one,
+	     the NM code will goto the above piece of code. */
+	  goto next_field;
+	}
+
+      /* PL is found in the ".." entry of a relocated directory. 
+	 The present directory entry points to the fictitious parent 
+	 (the one that holds the fictitious RE link here); the PL
+	 field identifies the real parent (the one that has the CL
+	 entry). */
+      if (susp->sig[0] == 'P'
+	  && susp->sig[1] == 'L'
+	  && susp->version == 1)
+	{
+	  struct rr_pl *pl = body;
+	  
+	  rr->realfilestart = (isonum_733 (pl->loc) 
+			       * (logical_block_size
+				  >> store->log2_block_size));
+	  rr->valid |= VALID_PL;
+	  goto next_field;
+	}
+
+    next_field:
+      bp = bp + susp->len;
+    }
+
+  if (rr->valid & VALID_CL)
+    goto clrecurse;
+
+  /* If we saw an NM field, then it matched; otherwise we
+     didn't see one. */
+  return rr->valid & VALID_NM ? 1 : 0;
+}
+
+/* Parse extensions for directory entry DR.  If we encounter an NM
+   record, and it does not match NAME (length NAMELEN), then stop
+   immediately (but do note the NM file in RR->valid) and return zero.
+   If we encounter no NM record at all, then process all the fields 
+   normally and return zero.  If we encounter an NM field which matches
+   the provided name, then process all the fields and return 1.  In any
+   case, fill RR with information corresponding to the fields we do
+   encounter. */
+int
+rrip_match_lookup (struct dirrect *dr, char *name, size_t namelen, 
+		   struct rrip_lookup *rr)
+{
+  return rrip_work (dr, rr, name, namelen, 0, 0);
+}
+
+/* Parse extensions for dirrect DR and store the results in RR. 
+   If IGNORENM, then do not bother with NM records. */
+void
+rrip_lookup (struct dirrect *dr, struct rrip_lookup *rr, int ignorenm)
+{
+  rrip_work (dr, rr, 0, 0, 0, ignorenm);
+}
+
+/* Scan extensions on dirrect DR looking for the tags that are supposed
+   to be on the root directory. */
+void
+rrip_initialize (struct dirrect *dr)
+{
+  struct rrip_lookup rr;
+  rrip_work (dr, &rr, 0, 0, 1, 1);
+  release_rrip (&rr);
+}
diff --git a/isofs/rr.h b/isofs/rr.h
new file mode 100644
index 00000000..a3995be5
--- /dev/null
+++ b/isofs/rr.h
@@ -0,0 +1,213 @@
+/* 
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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.
+
+   The GNU Hurd 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */
+
+#include "iso9660.h"
+
+/* The results of an rrip_scan_lookup call are one of these */
+struct rrip_lookup
+{
+  /* PX */
+  mode_t mode;
+  nlink_t nlink;
+  uid_t uid;
+  gid_t gid;
+
+  /* PN */
+  dev_t rdev;
+  
+  /* SL */
+  char *target;
+   
+  /* NM */
+  char *name;			/* name of this entry if changed (malloced) */
+  
+  /* CL */
+  off_t newloc;			/* relocated directory */
+  
+  /* PL */
+  off_t parloc;			/* parent of relocated directory */
+
+  /* TF */
+  int tfflags;
+  struct timespec atime, mtime, ctime;	/* file times */
+
+  /* CL */
+  struct dirrect *realdirent;	/* actual directory entry for attributes */
+
+  /* RL */
+  off_t realfilestart;		/* override file start in dir entry */
+
+  int valid;
+};
+
+/* VALID in one of these is from the following bits */
+#define VALID_PX	0x0001
+#define VALID_PN	0x0002
+#define VALID_SL	0x0004
+#define VALID_NM	0x0008
+#define VALID_CL	0x0010
+#define VALID_PL	0x0020
+#define VALID_TF	0x0040
+#define VALID_RE	0x0080
+
+
+/* Definitions for System Use Sharing Protocol.
+   Version 1.  Revision 1.10.  Dated July 16, 1993. */
+
+/* A system use field begins with the following header */
+struct su_header
+{
+  char sig[2];
+  unsigned char len;
+  char version;
+};
+
+/* The body of a CE (Continuation Area) field */
+struct su_ce
+{
+  char continuation[8];
+  char offset[8];
+  char size[8];
+};
+
+/* The body of a SP (Sharing Protocol Indicator) field */
+struct su_sp
+{
+  unsigned char check[2];
+  u_char skip;
+};
+
+#define SU_SP_CHECK_0 0xbe
+#define SU_SP_CHECK_1 0xef
+
+/* The body of a ER (Extension Reference) field */
+struct su_er
+{
+  u_char len_id;
+  u_char len_des;
+  u_char len_src;
+  u_char ext_ver;
+  char more[0];
+};
+
+
+
+
+/* Definitions for Rock Ridge extensions.
+   Version 1.  Revision 1.10.  Dated July 13, 1993. */
+
+/* These are the ER values to indicate the presence of Rock-Ridge
+   extensions. */
+#define ROCK_VERS	1
+#define ROCK_ID		"RRIP_1991A"
+#define ROCK_DES	\
+    "THE ROCK RIDGE INTERCHANGE PROTOCOL PROVIDES SUPPORT FOR POSIX FILE SYSTEM SEMANTICS"
+#define ROCK_SRC	\
+    "ROCK RIDGE SPECIFICATION VERSION 1 REVISION 1.10 JULY 13 1993"
+
+/* The body of a PX (Posix Attributes) field. */
+struct rr_px
+{
+  char mode[8];
+  char nlink[8];
+  char uid[8];
+  char gid[8];
+};
+
+/* The body of a PN (Posix Device Node) field. */
+struct rr_pn
+{
+  char high[8];
+  char low[8];
+};
+
+/* The body of a SL (Symbolic Link) field. */
+struct rr_sl
+{
+  u_char flags;
+  char data[0];
+};
+
+/* Each component in the DATA is: */
+struct rr_sl_comp
+{
+  u_char flags;
+  u_char len;
+  char name[0];
+};
+
+/* The body of a NM (Alternate Name) field. */
+struct rr_nm
+{
+  u_char flags;
+  char name[0];
+};
+
+/* Flags for SL and NM components */
+#define NAME_CONTINUE	0x01
+#define NAME_DOT	0x02
+#define NAME_DOTDOT	0x04
+#define NAME_ROOT	0x08
+#define NAME_VOLROOT	0x10
+#define NAME_HOST	0x20
+
+/* The body of a CL (Child Directory Location) field. */
+struct rr_cl
+{
+  char loc[8];
+};
+
+/* The body of a PL (Parent Directory Location) field. */
+struct rr_pl
+{
+  char loc[8];
+};
+
+/* The body of a TF (Time Stamp) field. */
+struct rr_tf 
+{
+  u_char flags;
+  char data[0];
+};
+
+/* Flags for a TF */
+#define TF_CREATION	0x01
+#define TF_MODIFY	0x02
+#define TF_ACCESS	0x04
+#define TF_ATTRIBUTES	0x08
+#define TF_BACKUP	0x10
+#define TF_EXPIRATION	0x20
+#define TF_EFFECTIVE	0x40
+#define TF_LONG_FORM	0x80
+
+
+/* The body of a SF (Sparse File) field. */
+struct rr_sf
+{
+  char size[8];
+};
+
+
+/* Rock-Ridge related functions. */
+
+int rrip_match_lookup (struct dirrect *, char *, size_t, struct rrip_lookup *);
+void rrip_lookup (struct dirrect *, struct rrip_lookup *, int);
+void rrip_initialize (struct dirrect *);
+void release_rrip (struct rrip_lookup *);