1998-09-04 Roland McGrath <roland@baalperazim.frob.com>

	* dir.c (dirscanblock): Fix defn with `const'.
	(diskfs_direnter_hard): Likewise.
	* inode.c (diskfs_create_symlink_hook): Likewise.
	(write_symlink): Likewise.
	* dir.c (diskfs_lookup_hard): Fix defn with `const'.
	* inode.c (diskfs_set_translator): Likewise.

2 files changed, 103 insertions, 103 deletions

diff --git a/ext2fs/dir.c b/ext2fs/dir.c
index f1ea285c..b6b8f587 100644
--- a/ext2fs/dir.c
+++ b/ext2fs/dir.c
@@ -1,6 +1,6 @@
 /* Directory management routines
 
-   Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
 
    Converted for ext2fs by Miles Bader <miles@gnu.ai.mit.edu>
 
@@ -72,8 +72,8 @@ struct dirstat
 
   /* Index of this directory block. */
   int idx;
-  
-  /* For stat COMPRESS, this is the address (inside mapbuf) 
+
+  /* For stat COMPRESS, this is the address (inside mapbuf)
      of the first direct in the directory block to be compressed. */
   /* For stat HERE_TIS, SHRINK, and TAKE, this is the entry referenced. */
   struct ext2_dir_entry *entry;
@@ -90,21 +90,21 @@ struct dirstat
 size_t diskfs_dirstat_size = sizeof (struct dirstat);
 
 /* Initialize DS such that diskfs_drop_dirstat will ignore it. */
-void 
+void
 diskfs_null_dirstat (struct dirstat *ds)
 {
   ds->type = LOOKUP;
 }
 
-static error_t					
-dirscanblock (vm_address_t blockoff, struct node *dp, int idx, char *name, 
-	      int namelen, enum lookup_type type, struct dirstat *ds,
-	      ino_t *inum);
+static error_t
+dirscanblock (vm_address_t blockoff, struct node *dp, int idx,
+	      const char *name, int namelen, enum lookup_type type,
+	      struct dirstat *ds, ino_t *inum);
 
 /* Implement the diskfs_lookup 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,
+diskfs_lookup_hard (struct node *dp, const char *name, enum lookup_type type,
 		    struct node **npp, struct dirstat *ds, struct protid *cred)
 {
   error_t err;
@@ -121,7 +121,7 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
   int blockaddr;
   int idx, lastidx;
   int looped;
-  
+
   if ((type == REMOVE) || (type == RENAME))
     assert (npp);
 
@@ -130,12 +130,12 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
 
   spec_dotdot = type & SPEC_DOTDOT;
   type &= ~SPEC_DOTDOT;
-  
+
   namelen = strlen (name);
 
   if (namelen > EXT2_NAME_LEN)
     return ENAMETOOLONG;
-  
+
  try_again:
   if (ds)
     {
@@ -165,10 +165,10 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
   mach_port_deallocate (mach_task_self (), memobj);
 
   inum = 0;
-  
+
   if (!diskfs_check_readonly ())
     dp->dn_set_atime = 1;
-  
+
   /* Start the lookup at DP->dn->dir_idx.  */
   idx = dp->dn->dir_idx;
   if (idx * DIRBLKSIZ > dp->dn_stat.st_size)
@@ -229,7 +229,7 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
 		goto out;
 	    }
 	}
-	  
+
       /* We are looking up .. */
       /* Check to see if this is the root of the filesystem. */
       else if (dp->cache_id == 2)
@@ -237,7 +237,7 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
 	  err = EAGAIN;
 	  goto out;
 	}
-	  
+
       /* We can't just do diskfs_cached_lookup, because we would then deadlock.
 	 So we do this.  Ick.  */
       else if (retry_dotdot)
@@ -271,11 +271,11 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
 	  retry_dotdot = inum;
 	  goto try_again;
 	}
-      
+
       /* Here below are the spec dotdot cases. */
       else if (type == RENAME || type == REMOVE)
 	np = ifind (inum);
-      
+
       else if (type == LOOKUP)
 	{
 	  diskfs_nput (dp);
@@ -286,7 +286,7 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
       else
 	assert (0);
     }
-  
+
   if ((type == CREATE || type == RENAME) && !inum && ds && ds->stat == LOOKING)
     {
       /* We didn't find any room, so mark ds to extend the dir */
@@ -312,7 +312,7 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
       ds->mapbuf = buf;
       ds->mapextent = buflen;
     }
-  
+
   if (np)
     {
       assert (npp);
@@ -346,8 +346,8 @@ diskfs_lookup_hard (struct node *dp, char *name, enum lookup_type type,
    diskfs_lookup.  If found, set *INUM to the inode number, else
    return ENOENT.  */
 static error_t
-dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
-	      int namelen, enum lookup_type type, 
+dirscanblock (vm_address_t blockaddr, struct node *dp, int idx,
+	      const char *name, int namelen, enum lookup_type type,
 	      struct dirstat *ds, ino_t *inum)
 {
   int nfree = 0;
@@ -359,7 +359,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
   int looking = 0;
   int countcopies = 0;
   int consider_compress = 0;
-  
+
   if (ds && (ds->stat == LOOKING
 	     || ds->stat == COMPRESS))
     {
@@ -373,7 +373,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
        prevoff = currentoff, currentoff += entry->rec_len)
     {
       entry = (struct ext2_dir_entry *)currentoff;
-      
+
       if (!entry->rec_len
 	  || entry->rec_len % EXT2_DIR_PAD
 	  || entry->name_len > EXT2_NAME_LEN
@@ -386,11 +386,11 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
 			currentoff - blockaddr + idx * DIRBLKSIZ);
 	  return ENOENT;
 	}
-      
+
       if (looking || countcopies)
 	{
 	  int thisfree;
-	  
+
 	  /* Count how much free space this entry has in it. */
 	  if (entry->inode == 0)
 	    thisfree = entry->rec_len;
@@ -402,9 +402,9 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
 	     number of bytes there too. */
 	  if (countcopies && currentoff != blockaddr)
 	    nbytes += EXT2_DIR_REC_LEN (entry->name_len);
-	  
+
 	  if (ds->stat == COMPRESS && nbytes > ds->nbytes)
-	    /* The previously found compress is better than 
+	    /* The previously found compress is better than
 	       this one, so don't bother counting any more. */
 	    countcopies = 0;
 
@@ -421,9 +421,9 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
 	      nfree += thisfree;
 	      if (nfree >= needed)
 		consider_compress = 1;
-	    }	      
+	    }
 	}
-      
+
       if (entry->inode)
 	nentries++;
 
@@ -434,7 +434,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
 	break;
     }
 
-  if (consider_compress 
+  if (consider_compress
       && (ds->type == LOOKING
 	  || (ds->type == COMPRESS && ds->nbytes > nbytes)))
     {
@@ -444,7 +444,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
       ds->idx = idx;
       ds->nbytes = nbytes;
     }
-  
+
   if (currentoff >= blockaddr + DIRBLKSIZ)
     {
       int i;
@@ -454,9 +454,9 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
 	 down how many entries there were. */
       if (!dp->dn->dirents)
 	{
-	  dp->dn->dirents = malloc ((dp->dn_stat.st_size / DIRBLKSIZ) 
+	  dp->dn->dirents = malloc ((dp->dn_stat.st_size / DIRBLKSIZ)
 				    * sizeof (int));
-	  for (i = 0; i < dp->dn_stat.st_size/DIRBLKSIZ; i++) 
+	  for (i = 0; i < dp->dn_stat.st_size/DIRBLKSIZ; i++)
 	    dp->dn->dirents[i] = -1;
 	}
       /* Make sure the count is correct if there is one now. */
@@ -466,7 +466,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
 
       return ENOENT;
     }
-  
+
   /* We have found the required name. */
 
   if (ds && type == CREATE)
@@ -491,7 +491,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx, char *name,
    only be made if the directory has been held locked continuously since
    the preceding lookup call, and only if that call returned ENOENT. */
 error_t
-diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
+diskfs_direnter_hard (struct node *dp, const char *name, struct node *np,
 		      struct dirstat *ds, struct protid *cred)
 {
   struct ext2_dir_entry *new;
@@ -499,12 +499,12 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
   int needed = EXT2_DIR_REC_LEN (namelen);
   int oldneeded;
   vm_address_t fromoff, tooff;
-  int totfreed;  
+  int totfreed;
   error_t err;
   off_t oldsize = 0;
 
   assert (ds->type == CREATE);
-  
+
   assert (!diskfs_readonly);
 
   dp->dn_set_mtime = 1;
@@ -514,30 +514,30 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
     case TAKE:
       /* We are supposed to consume this slot. */
       assert (ds->entry->inode == 0 && ds->entry->rec_len >= needed);
-      
+
       ds->entry->inode = np->cache_id;
       ds->entry->name_len = namelen;
       bcopy (name, ds->entry->name, namelen);
 
       break;
-      
+
     case SHRINK:
       /* We are supposed to take the extra space at the end
 	 of this slot. */
       oldneeded = EXT2_DIR_REC_LEN (ds->entry->name_len);
       assert (ds->entry->rec_len - oldneeded >= needed);
-      
+
       new = (struct ext2_dir_entry *) ((vm_address_t) ds->entry + oldneeded);
 
       new->inode = np->cache_id;
       new->rec_len = ds->entry->rec_len - oldneeded;
       new->name_len = namelen;
       bcopy (name, new->name, namelen);
-      
+
       ds->entry->rec_len = oldneeded;
-      
+
       break;
-      
+
     case COMPRESS:
       /* We are supposed to move all the entries to the
 	 front of the block, giving each the minimum
@@ -565,7 +565,7 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
 
       totfreed = (vm_address_t) ds->entry + DIRBLKSIZ - tooff;
       assert (totfreed >= needed);
-      
+
       new = (struct ext2_dir_entry *) tooff;
       new->inode = np->cache_id;
       new->rec_len = totfreed;
@@ -576,7 +576,7 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
     case EXTEND:
       /* Extend the file. */
       assert (needed <= DIRBLKSIZ);
-      
+
       oldsize = dp->dn_stat.st_size;
       while (oldsize + DIRBLKSIZ > dp->allocsize)
 	{
@@ -598,7 +598,7 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
       new->name_len = namelen;
       bcopy (name, new->name, namelen);
       break;
-      
+
     default:
       assert (0);
     }
@@ -606,10 +606,10 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
   dp->dn_set_mtime = 1;
 
   vm_deallocate (mach_task_self (), ds->mapbuf, ds->mapextent);
-        
+
   if (ds->stat != EXTEND)
     {
-      /* If we are keeping count of this block, then keep the count up 
+      /* If we are keeping count of this block, then keep the count up
 	 to date. */
       if (dp->dn->dirents && dp->dn->dirents[ds->idx] != -1)
 	dp->dn->dirents[ds->idx]++;
@@ -621,10 +621,10 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
 	 anything at all. */
       if (dp->dn->dirents)
 	{
-	  dp->dn->dirents = realloc (dp->dn->dirents, 
+	  dp->dn->dirents = realloc (dp->dn->dirents,
 				     (dp->dn_stat.st_size / DIRBLKSIZ
 				      * sizeof (int)));
-	  for (i = oldsize / DIRBLKSIZ; 
+	  for (i = oldsize / DIRBLKSIZ;
 	       i < dp->dn_stat.st_size / DIRBLKSIZ;
 	       i++)
 	    dp->dn->dirents[i] = -1;
@@ -633,14 +633,14 @@ diskfs_direnter_hard (struct node *dp, char *name, struct node *np,
 	}
       else
 	{
-	  dp->dn->dirents = malloc (dp->dn_stat.st_size / DIRBLKSIZ 
+	  dp->dn->dirents = malloc (dp->dn_stat.st_size / DIRBLKSIZ
 				    * sizeof (int));
 	  for (i = 0; i < dp->dn_stat.st_size / DIRBLKSIZ; i++)
 	    dp->dn->dirents[i] = -1;
 	  dp->dn->dirents[ds->idx] = 1;
 	}
     }
-  
+
   diskfs_file_update (dp, 1);
 
   return 0;
@@ -656,7 +656,7 @@ diskfs_dirremove_hard (struct node *dp, struct dirstat *ds)
 {
   assert (ds->type == REMOVE);
   assert (ds->stat == HERE_TIS);
-  
+
   assert (!diskfs_readonly);
 
   dp->dn_set_mtime = 1;
@@ -678,16 +678,16 @@ diskfs_dirremove_hard (struct node *dp, struct dirstat *ds)
      to date. */
   if (dp->dn->dirents && dp->dn->dirents[ds->idx] != -1)
     dp->dn->dirents[ds->idx]--;
-  
+
   diskfs_file_update (dp, 1);
 
   return 0;
 }
-  
+
 
 /* Following a lookup call for RENAME, this changes the inode number
-   on a directory entry.  DP is the directory being changed; NP is 
-   the new node being linked in; DP is the cached information returned 
+   on a directory entry.  DP is the directory being changed; NP is
+   the new node being linked in; DP is the cached information returned
    by lookup.  This call is only valid if the directory has been locked
    continuously since the call to lookup, and only if that call
    succeeded.  */
@@ -696,14 +696,14 @@ diskfs_dirrewrite_hard (struct node *dp, struct node *np, struct dirstat *ds)
 {
   assert (ds->type == RENAME);
   assert (ds->stat == HERE_TIS);
-  
+
   assert (!diskfs_readonly);
 
   ds->entry->inode = np->cache_id;
   dp->dn_set_mtime = 1;
 
   vm_deallocate (mach_task_self (), ds->mapbuf, ds->mapextent);
-  
+
   diskfs_file_update (dp, 1);
 
   return 0;
@@ -719,7 +719,7 @@ diskfs_dirempty (struct node *dp, struct protid *cred)
   struct ext2_dir_entry *entry;
   int hit = 0;			/* Found something in the directory.  */
   memory_object_t memobj = diskfs_get_filemap (dp, VM_PROT_READ);
-  
+
   if (memobj == MACH_PORT_NULL)
     /* XXX should reflect error properly. */
     return 0;
@@ -732,7 +732,7 @@ diskfs_dirempty (struct node *dp, struct protid *cred)
   if (! diskfs_check_readonly ())
     dp->dn_set_atime = 1;
 
-  for (curoff = buf; 
+  for (curoff = buf;
        !hit && curoff < buf + dp->dn_stat.st_size;
        curoff += entry->rec_len)
     {
@@ -784,12 +784,12 @@ count_dirents (struct node *dp, int nb, char *buf)
 
   assert (dp->dn->dirents);
   assert ((nb + 1) * DIRBLKSIZ <= dp->dn_stat.st_size);
-  
+
   err = diskfs_node_rdwr (dp, buf, nb * DIRBLKSIZ, DIRBLKSIZ, 0, 0, &amt);
   if (err)
     return err;
   assert (amt == DIRBLKSIZ);
-  
+
   for (offinblk = buf;
        offinblk < buf + DIRBLKSIZ;
        offinblk += entry->rec_len)
@@ -798,7 +798,7 @@ count_dirents (struct node *dp, int nb, char *buf)
       if (entry->inode)
 	count++;
     }
-  
+
   assert (dp->dn->dirents[nb] == -1 || dp->dn->dirents[nb] == count);
   dp->dn->dirents[nb] = count;
   return 0;
@@ -811,8 +811,8 @@ count_dirents (struct node *dp, int nb, char *buf)
 /* Implement the disikfs_get_directs callback as described in
    <hurd/diskfs.h>. */
 error_t
-diskfs_get_directs (struct node *dp, 
-		    int entry, 
+diskfs_get_directs (struct node *dp,
+		    int entry,
 		    int nentries,
 		    char **data,
 		    u_int *datacnt,
@@ -832,7 +832,7 @@ diskfs_get_directs (struct node *dp,
   int allocsize;
   int checklen;
   struct dirent *userp;
-  
+
   nblks = dp->dn_stat.st_size/DIRBLKSIZ;
 
   if (!dp->dn->dirents)
@@ -868,7 +868,7 @@ diskfs_get_directs (struct node *dp,
 
   if (allocsize > *datacnt)
     vm_allocate (mach_task_self (), (vm_address_t *) data, allocsize, 1);
-  
+
   /* Scan through the entries to find ENTRY.  If we encounter
      a -1 in the process then stop to fill it.  When we run
      off the end, ENTRY is too big. */
@@ -889,10 +889,10 @@ diskfs_get_directs (struct node *dp,
 	break;
 
       curentry += dp->dn->dirents[blkno];
-      
+
       bufvalid = 0;
     }
-  
+
   if (blkno == nblks)
     {
       *datacnt = 0;
@@ -915,13 +915,13 @@ diskfs_get_directs (struct node *dp,
 	  assert (checklen == DIRBLKSIZ);
 	  bufvalid = 1;
 	}
-      for (i = 0, bufp = buf; 
-	   i < entry - curentry && bufp - buf < DIRBLKSIZ; 
+      for (i = 0, bufp = buf;
+	   i < entry - curentry && bufp - buf < DIRBLKSIZ;
 	   bufp += ((struct ext2_dir_entry *)bufp)->rec_len, i++)
 	;
       /* Make sure we didn't run off the end. */
       assert (bufp - buf < DIRBLKSIZ);
-    }      
+    }
 
   i = 0;
   datap = *data;
@@ -933,7 +933,7 @@ diskfs_get_directs (struct node *dp,
     {
       if (!bufvalid)
 	{
-	  err = diskfs_node_rdwr (dp, buf, blkno * DIRBLKSIZ, DIRBLKSIZ, 
+	  err = diskfs_node_rdwr (dp, buf, blkno * DIRBLKSIZ, DIRBLKSIZ,
 				  0, 0, &checklen);
 	  if (err)
 	    return err;
@@ -1000,17 +1000,17 @@ diskfs_get_directs (struct node *dp,
 	  return EIO;
 	}
     }
-  
+
   /* We've copied all we can.  If we allocated our own array
      but didn't fill all of it, then free whatever memory we didn't use. */
   if (allocsize > *datacnt)
     {
       if (round_page (datap - *data) < allocsize)
-	vm_deallocate (mach_task_self (), 
+	vm_deallocate (mach_task_self (),
 		       (vm_address_t) (*data + round_page (datap - *data)),
 		       allocsize - round_page (datap - *data));
     }
-  
+
   /* Set variables for return */
   *datacnt = datap - *data;
   *amt = i;
diff --git a/ext2fs/inode.c b/ext2fs/inode.c
index 8a365b74..68962037 100644
--- a/ext2fs/inode.c
+++ b/ext2fs/inode.c
@@ -1,6 +1,6 @@
 /* Inode management routines
 
-   Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
 
    Converted for ext2fs by Miles Bader <miles@gnu.ai.mit.edu>
 
@@ -58,9 +58,9 @@ inode_init ()
     nodehash[n] = 0;
 }
 
-/* Fetch inode INUM, set *NPP to the node structure; 
+/* Fetch inode INUM, set *NPP to the node structure;
    gain one user reference and lock the node.  */
-error_t 
+error_t
 diskfs_cached_lookup (int inum, struct node **npp)
 {
   error_t err;
@@ -77,7 +77,7 @@ diskfs_cached_lookup (int inum, struct node **npp)
 	*npp = np;
 	return 0;
       }
-  
+
   /* Format specific data for the new node.  */
   dn = malloc (sizeof (struct disknode));
   if (! dn)
@@ -105,10 +105,10 @@ diskfs_cached_lookup (int inum, struct node **npp)
   nodehash[INOHASH(inum)] = np;
 
   spin_unlock (&diskfs_node_refcnt_lock);
-  
+
   /* Get the contents of NP off disk.  */
   err = read_node (np);
-  
+
   if (!diskfs_check_readonly () && !np->dn_stat.st_gen)
     {
       spin_lock (&generation_lock);
@@ -118,7 +118,7 @@ diskfs_cached_lookup (int inum, struct node **npp)
       spin_unlock (&generation_lock);
       np->dn_set_ctime = 1;
     }
-  
+
   if (err)
     return err;
   else
@@ -134,13 +134,13 @@ struct node *
 ifind (ino_t inum)
 {
   struct node *np;
-  
+
   spin_lock (&diskfs_node_refcnt_lock);
   for (np = nodehash[INOHASH(inum)]; np; np = np->dn->hnext)
     {
       if (np->cache_id != inum)
 	continue;
-      
+
       assert (np->references);
       spin_unlock (&diskfs_node_refcnt_lock);
       return np;
@@ -150,7 +150,7 @@ ifind (ino_t inum)
 
 /* The last reference to a node has gone away; drop
    it from the hash table and clean all state in the dn structure. */
-void      
+void
 diskfs_node_norefs (struct node *np)
 {
   *np->dn->hprevp = np->dn->hnext;
@@ -201,7 +201,7 @@ read_node (struct node *np)
   struct disknode *dn = np->dn;
   struct ext2_inode *di = dino (np->cache_id);
   struct ext2_inode_info *info = &dn->info;
-  
+
   err = diskfs_catch_exception ();
   if (err)
     return err;
@@ -293,7 +293,7 @@ read_node (struct node *np)
     }
 
   diskfs_end_catch_exception ();
-  
+
   if (S_ISREG (st->st_mode) || S_ISDIR (st->st_mode)
       || (S_ISLNK (st->st_mode) && st->st_blocks))
     {
@@ -388,7 +388,7 @@ write_node (struct node *np)
 
   if (np->dn->info.i_prealloc_count)
     ext2_discard_prealloc (np);
-  
+
   assert (!np->dn_set_ctime && !np->dn_set_atime && !np->dn_set_mtime);
   if (np->dn_stat_dirty)
     {
@@ -399,7 +399,7 @@ write_node (struct node *np)
       err = diskfs_catch_exception ();
       if (err)
 	return NULL;
-  
+
       di->i_version = st->st_gen;
 
       /* We happen to know that the stat mode bits are the same
@@ -467,7 +467,7 @@ write_node (struct node *np)
 	  for (block = 0; block < EXT2_N_BLOCKS; block++)
 	    di->i_block[block] = np->dn->info.i_data[block];
 	}
-  
+
       diskfs_end_catch_exception ();
       np->dn_stat_dirty = 0;
 
@@ -505,7 +505,7 @@ diskfs_node_iterate (error_t (*fun)(struct node *))
   error_t err = 0;
   int n, num_nodes = 0;
   struct node *node, **node_list, **p;
-  
+
   spin_lock (&diskfs_node_refcnt_lock);
 
   /* We must copy everything from the hash table into another data structure
@@ -604,7 +604,7 @@ diskfs_set_statfs (struct statfs *st)
 /* Implement the diskfs_set_translator callback from the diskfs
    library; see <hurd/diskfs.h> for the interface description. */
 error_t
-diskfs_set_translator (struct node *np, char *name, unsigned namelen,
+diskfs_set_translator (struct node *np, const char *name, unsigned namelen,
 		       struct protid *cred)
 {
   daddr_t blkno;
@@ -623,10 +623,10 @@ diskfs_set_translator (struct node *np, char *name, unsigned namelen,
   err = diskfs_catch_exception ();
   if (err)
     return err;
-  
+
   di = dino (np->cache_id);
   blkno = di->i_translator;
-  
+
   if (namelen && !blkno)
     {
       /* Allocate block for translator */
@@ -640,7 +640,7 @@ diskfs_set_translator (struct node *np, char *name, unsigned namelen,
 	  diskfs_end_catch_exception ();
 	  return ENOSPC;
 	}
-      
+
       di->i_translator = blkno;
       record_global_poke (di);
 
@@ -658,7 +658,7 @@ diskfs_set_translator (struct node *np, char *name, unsigned namelen,
       np->dn_stat.st_mode &= ~S_IPTRANS;
       np->dn_set_ctime = 1;
     }
-  
+
   if (namelen)
     {
       buf[0] = namelen & 0xFF;
@@ -671,7 +671,7 @@ diskfs_set_translator (struct node *np, char *name, unsigned namelen,
       np->dn_stat.st_mode |= S_IPTRANS;
       np->dn_set_ctime = 1;
     }
-  
+
   diskfs_end_catch_exception ();
   return err;
 }
@@ -695,7 +695,7 @@ diskfs_get_translator (struct node *np, char **namep, unsigned *namelen)
   blkno = (dino (np->cache_id))->i_translator;
   assert (blkno);
   transloc = bptr (blkno);
-  
+
   datalen =
     ((unsigned char *)transloc)[0] + (((unsigned char *)transloc)[1] << 8);
   *namep = malloc (datalen);
@@ -713,7 +713,7 @@ diskfs_get_translator (struct node *np, char **namep, unsigned *namelen)
 
 /* Write an in-inode symlink, or return EINVAL if we can't.  */
 static error_t
-write_symlink (struct node *node, char *target)
+write_symlink (struct node *node, const char *target)
 {
   size_t len = strlen (target) + 1;
 
@@ -747,7 +747,7 @@ read_symlink (struct node *node, char *target)
    is called to set a symlink.  If it returns EINVAL or isn't set,
    then the normal method (writing the contents into the file data) is
    used.  If it returns any other error, it is returned to the user.  */
-error_t (*diskfs_create_symlink_hook)(struct node *np, char *target) =
+error_t (*diskfs_create_symlink_hook)(struct node *np, const char *target) =
   write_symlink;
 
 /* If this function is nonzero (and diskfs_shortcut_symlink is set) it