bug-hurd
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[PATCH 06/17] ext2fs: reindent files


From: Etienne Brateau
Subject: [PATCH 06/17] ext2fs: reindent files
Date: Sun, 23 Jan 2022 05:17:04 +0100

  * balloc.c: reindent
  * bitmap.c: reindent
  * dir.c: reindent
  * ext2fs.c: reindent
  * getblk.c: reindent
  * hyper.c: reindent
  * ialloc.c: reindent
  * inode.c: reindent
  * msg.c: reindent
  * pager.c: reindent
  * pokel.c: reindent
  * truncate.c: reindent
---
 ext2fs/balloc.c    | 264 +++++++++---------
 ext2fs/bitmap.c    |  24 +-
 ext2fs/dir.c       | 668 ++++++++++++++++++++++-----------------------
 ext2fs/ext2fs.c    |  24 +-
 ext2fs/getblk.c    |  92 +++----
 ext2fs/hyper.c     |  58 ++--
 ext2fs/ialloc.c    | 170 ++++++------
 ext2fs/inode.c     | 356 ++++++++++++------------
 ext2fs/msg.c       |   2 +-
 ext2fs/pager.c     | 588 +++++++++++++++++++--------------------
 ext2fs/pokel.c     |  76 +++---
 ext2fs/storeinfo.c |  94 +++----
 ext2fs/truncate.c  | 100 +++----
 ext2fs/xattr.c     | 256 ++++++++---------
 14 files changed, 1390 insertions(+), 1382 deletions(-)

diff --git a/ext2fs/balloc.c b/ext2fs/balloc.c
index 8ebd11cd..105aaa54 100644
--- a/ext2fs/balloc.c
+++ b/ext2fs/balloc.c
@@ -69,7 +69,7 @@ ext2_free_blocks (block_t block, unsigned long count)
       (block + count) > sblock->s_blocks_count)
     {
       ext2_error ("freeing blocks not in datazone - "
-                 "block = %u, count = %lu", block, count);
+                  "block = %u, count = %lu", block, count);
       pthread_spin_unlock (&global_lock);
       return;
     }
@@ -81,37 +81,42 @@ ext2_free_blocks (block_t block, unsigned long count)
       unsigned long int gcount = count;
 
       block_group = ((block - sblock->s_first_data_block)
-                    / sblock->s_blocks_per_group);
+         / sblock->s_blocks_per_group);
       bit = (block - sblock->s_first_data_block) % sblock->s_blocks_per_group;
+
+      /*
+       * Check to see if we are freeing blocks accross a group
+       * boundary
+       */
       if (bit + count > sblock->s_blocks_per_group)
-       {
-         unsigned long overflow = bit + count - sblock->s_blocks_per_group;
-         gcount -= overflow;
-         ext2_debug ("freeing blocks across group boundary - "
-                     "block = %u, count = %lu",
-                     block, count);
-       }
+        {
+          unsigned long overflow = bit + count - sblock->s_blocks_per_group;
+          gcount -= overflow;
+          ext2_debug ("freeing blocks across group boundary - "
+          "block = %u, count = %lu",
+          block, count);
+        }
       gdp = group_desc (block_group);
       bh = disk_cache_block_ref (gdp->bg_block_bitmap);
 
       if (in_range (gdp->bg_block_bitmap, block, gcount) ||
-         in_range (gdp->bg_inode_bitmap, block, gcount) ||
-         in_range (block, gdp->bg_inode_table, itb_per_group) ||
-         in_range (block + gcount - 1, gdp->bg_inode_table, itb_per_group))
-       ext2_panic ("freeing blocks in system zones - "
-                   "block = %u, count = %lu",
-                   block, count);
+          in_range (gdp->bg_inode_bitmap, block, gcount) ||
+          in_range (block, gdp->bg_inode_table, itb_per_group) ||
+          in_range (block + gcount - 1, gdp->bg_inode_table, itb_per_group))
+        ext2_panic ("freeing blocks in system zones - "
+                    "block = %u, count = %lu",
+                    block, count);
 
       for (i = 0; i < gcount; i++)
-       {
-         if (!clear_bit (bit + i, bh))
-           ext2_warning ("bit already cleared for block %lu", block + i);
-         else
-           {
-             gdp->bg_free_blocks_count++;
-             sblock->s_free_blocks_count++;
-           }
-       }
+        {
+          if (!clear_bit (bit + i, bh))
+            ext2_warning ("bit already cleared for block %lu", block + i);
+          else
+            {
+              gdp->bg_free_blocks_count++;
+              sblock->s_free_blocks_count++;
+            }
+        }
 
       record_global_poke (bh);
       disk_cache_block_ref_ptr (gdp);
@@ -137,8 +142,9 @@ ext2_free_blocks (block_t block, unsigned long count)
  */
 block_t
 ext2_new_block (block_t goal,
-               block_t prealloc_goal,
-               block_t *prealloc_count, block_t *prealloc_block)
+                block_t prealloc_goal,
+                block_t *prealloc_count,
+                block_t *prealloc_block)
 {
   unsigned char *bh = NULL;
   unsigned char *p, *r;
@@ -156,7 +162,7 @@ ext2_new_block (block_t goal,
   if (sblock->s_free_blocks_count <= sblock->s_r_blocks_count &&
       (!fsuser () && (sb->u.ext2_sb.s_resuid != current->fsuid) &&
        (sb->u.ext2_sb.s_resgid == 0 ||
-       !in_group_p (sb->u.ext2_sb.s_resgid))))
+      !in_group_p (sb->u.ext2_sb.s_resgid))))
     {
       pthread_spin_unlock (&global_lock);
       return 0;
@@ -168,7 +174,7 @@ ext2_new_block (block_t goal,
 repeat:
   assert_backtrace (bh == NULL);
   /*
-     * First, test whether the goal block is free.
+   * First, test whether the goal block is free.
    */
   if (goal < sblock->s_first_data_block || goal >= sblock->s_blocks_count)
     goal = sblock->s_first_data_block;
@@ -179,46 +185,48 @@ repeat:
       j = ((goal - sblock->s_first_data_block) % sblock->s_blocks_per_group);
 #ifdef EXT2FS_DEBUG
       if (j)
-       goal_attempts++;
+        goal_attempts++;
 #endif
       bh = disk_cache_block_ref (gdp->bg_block_bitmap);
 
       ext2_debug ("goal is at %d:%d", i, j);
 
       if (!test_bit (j, bh))
-       {
+        {
 #ifdef EXT2FS_DEBUG
-         goal_hits++;
-         ext2_debug ("goal bit allocated!");
+          goal_hits++;
+          ext2_debug ("goal bit allocated!");
 #endif
-         goto got_block;
-       }
+          goto got_block;
+        }
       if (j)
-       {
-         /*
-            * The goal was occupied; search forward for a free
-            * block within the next 32 blocks
-          */
-         if ((j & 31) == 31)
-           lmap = 0;
-         else
-           lmap = ((((unsigned long *) bh)[j >> 5]) >>
-                   ((j & 31) + 1));
-         if (j < sblock->s_blocks_per_group - 32)
-           lmap |= (((unsigned long *) bh)[(j >> 5) + 1]) <<
-             (31 - (j & 31));
-         else
-           lmap |= 0xffffffff << (31 - (j & 31));
-         if (lmap != 0xffffffffl)
-           {
-             k = ffz (lmap) + 1;
-             if ((j + k) < sblock->s_blocks_per_group)
-               {
-                 j += k;
-                 goto got_block;
-               }
-           }
-       }
+        {
+          /*
+           * The goal was occupied; search forward for a free
+           * block within the next 32 blocks
+           */
+          if ((j & 31) == 31)
+            lmap = 0;
+          else
+            lmap = ((((unsigned long *) bh)[j >> 5]) >>
+            ((j & 31) + 1));
+     
+          if (j < sblock->s_blocks_per_group - 32)
+            lmap |= (((unsigned long *) bh)[(j >> 5) + 1]) <<
+            (31 - (j & 31));
+          else
+            lmap |= 0xffffffff << (31 - (j & 31));
+
+          if (lmap != 0xffffffffl)
+            {
+              k = ffz (lmap) + 1;
+              if ((j + k) < sblock->s_blocks_per_group)
+                {
+                  j += k;
+                  goto got_block;
+                }
+            }
+        }
 
       ext2_debug ("bit not found near goal");
 
@@ -235,18 +243,18 @@ repeat:
       r = memscan (p, 0, (sblock->s_blocks_per_group - j + 7) >> 3);
       k = (r - bh) << 3;
       if (k < sblock->s_blocks_per_group)
-       {
-         j = k;
-         goto search_back;
-       }
+        {
+          j = k;
+          goto search_back;
+        }
       k = find_next_zero_bit ((unsigned long *) bh,
-                             sblock->s_blocks_per_group,
-                             j);
+                              sblock->s_blocks_per_group,
+                              j);
       if (k < sblock->s_blocks_per_group)
-       {
-         j = k;
-         goto got_block;
-       }
+        {
+          j = k;
+          goto got_block;
+        }
 
       disk_cache_block_deref (bh);
       bh = NULL;
@@ -255,17 +263,17 @@ repeat:
   ext2_debug ("bit not found in block group %d", i);
 
   /*
-     * Now search the rest of the groups.  We assume that
-     * i and gdp correctly point to the last group visited.
+   * Now search the rest of the groups.  We assume that
+   * i and gdp correctly point to the last group visited.
    */
   for (k = 0; k < groups_count; k++)
     {
       i++;
       if (i >= groups_count)
-       i = 0;
+        i = 0;
       gdp = group_desc (i);
       if (gdp->bg_free_blocks_count > 0)
-       break;
+        break;
     }
   if (k >= groups_count)
     {
@@ -280,7 +288,7 @@ repeat:
     goto search_back;
   else
     j = find_first_zero_bit ((unsigned long *) bh,
-                            sblock->s_blocks_per_group);
+                             sblock->s_blocks_per_group);
   if (j >= sblock->s_blocks_per_group)
     {
       disk_cache_block_deref (bh);
@@ -340,20 +348,20 @@ got_block:
       *prealloc_count = 0;
       *prealloc_block = tmp + 1;
       for (k = 1;
-          k < prealloc_goal && (j + k) < sblock->s_blocks_per_group; k++)
-       {
-         if (set_bit (j + k, bh))
-           break;
-         (*prealloc_count)++;
-
-         /* (See comment before the clear_bit above) */
-         if (modified_global_blocks)
-           {
-             pthread_spin_lock (&modified_global_blocks_lock);
-             clear_bit (tmp + k, modified_global_blocks);
-             pthread_spin_unlock (&modified_global_blocks_lock);
-           }
-       }
+           k < prealloc_goal && (j + k) < sblock->s_blocks_per_group; k++)
+        {
+          if (set_bit (j + k, bh))
+            break;
+          (*prealloc_count)++;
+
+          /* (See comment before the clear_bit above) */
+          if (modified_global_blocks)
+            {
+              pthread_spin_lock (&modified_global_blocks_lock);
+              clear_bit (tmp + k, modified_global_blocks);
+              pthread_spin_unlock (&modified_global_blocks_lock);
+            }
+        }
       gdp->bg_free_blocks_count -= *prealloc_count;
       sblock->s_free_blocks_count -= *prealloc_count;
       ext2_debug ("preallocated a further %u bits", *prealloc_count);
@@ -373,7 +381,7 @@ got_block:
     }
 
   ext2_debug ("allocating block %d; goal hits %d of %d",
-             j, goal_hits, goal_attempts);
+              j, goal_hits, goal_attempts);
 
   gdp->bg_free_blocks_count--;
   disk_cache_block_ref_ptr (gdp);
@@ -412,11 +420,11 @@ ext2_count_free_blocks ()
       x = count_free (bh, block_size);
       disk_cache_block_deref (bh);
       printf ("group %d: stored = %d, counted = %lu",
-             i, gdp->bg_free_blocks_count, x);
+              i, gdp->bg_free_blocks_count, x);
       bitmap_count += x;
     }
   printf ("ext2_count_free_blocks: stored = %u, computed = %lu, %lu",
-         sblock->s_free_blocks_count, desc_count, bitmap_count);
+          sblock->s_free_blocks_count, desc_count, bitmap_count);
   pthread_spin_unlock (&global_lock);
   return bitmap_count;
 #else
@@ -428,7 +436,7 @@ static inline int
 block_in_use (block_t block, unsigned char *map)
 {
   return test_bit ((block - sblock->s_first_data_block) %
-                  sblock->s_blocks_per_group, map);
+                   sblock->s_blocks_per_group, map);
 }
 
 void
@@ -451,62 +459,62 @@ ext2_check_blocks_bitmap ()
   for (i = 0; i < groups_count; i++)
     {
       inline int test_root (int a, int b)
-       {
-         if (a == 0)
-           return 1;
-         while (1)
-           {
-             if (a == 1)
-               return 1;
-             if (a % b)
-               return 0;
-             a = a / b;
-           }
-       }
+        {
+          if (a == 0)
+            return 1;
+          while (1)
+            {
+              if (a == 1)
+                return 1;
+              if (a % b)
+                return 0;
+              a = a / b;
+            }
+        }
       inline int ext2_group_sparse (int group)
-       {
-         return (test_root (group, 3) || test_root (group, 5)
-                 || test_root (group, 7));
-       }
+        {
+          return (test_root (group, 3) || test_root (group, 5)
+                  || test_root (group, 7));
+        }
 
       gdp = group_desc (i);
       desc_count += gdp->bg_free_blocks_count;
       bh = disk_cache_block_ref (gdp->bg_block_bitmap);
 
       if (!EXT2_HAS_RO_COMPAT_FEATURE (sblock,
-                                      EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)
-         || ext2_group_sparse (i))
-       {
-         if (!test_bit (0, bh))
-           ext2_error ("superblock in group %d is marked free", i);
-
-         for (j = 0; j < desc_blocks; j++)
-           if (!test_bit (j + 1, bh))
-             ext2_error ("descriptor block #%d in group %d is marked free",
-                         j, i);
-       }
+                                       EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)
+          || ext2_group_sparse (i))
+        {
+          if (!test_bit (0, bh))
+            ext2_error ("superblock in group %d is marked free", i);
+
+          for (j = 0; j < desc_blocks; j++)
+            if (!test_bit (j + 1, bh))
+              ext2_error ("descriptor block #%d in group %d is marked free",
+              j, i);
+        }
 
       if (!block_in_use (gdp->bg_block_bitmap, bh))
-       ext2_error ("block bitmap for group %d is marked free", i);
+        ext2_error ("block bitmap for group %d is marked free", i);
 
       if (!block_in_use (gdp->bg_inode_bitmap, bh))
-       ext2_error ("inode bitmap for group %d is marked free", i);
+        ext2_error ("inode bitmap for group %d is marked free", i);
 
       for (j = 0; j < itb_per_group; j++)
-       if (!block_in_use (gdp->bg_inode_table + j, bh))
-         ext2_error ("block #%d of the inode table in group %d is marked 
free", j, i);
+        if (!block_in_use (gdp->bg_inode_table + j, bh))
+          ext2_error ("block #%d of the inode table in group %d is marked 
free", j, i);
 
       x = count_free (bh, block_size);
       disk_cache_block_deref (bh);
       if (gdp->bg_free_blocks_count != x)
-       ext2_error ("wrong free blocks count for group %d,"
-                   " stored = %d, counted = %lu",
-                   i, gdp->bg_free_blocks_count, x);
+        ext2_error ("wrong free blocks count for group %d,"
+                    " stored = %d, counted = %lu",
+                    i, gdp->bg_free_blocks_count, x);
       bitmap_count += x;
     }
   if (sblock->s_free_blocks_count != bitmap_count)
     ext2_error ("wrong free blocks count in super block,"
-               " stored = %lu, counted = %lu",
-               (unsigned long) sblock->s_free_blocks_count, bitmap_count);
+                " stored = %lu, counted = %lu",
+                (unsigned long) sblock->s_free_blocks_count, bitmap_count);
   pthread_spin_unlock (&global_lock);
 }
diff --git a/ext2fs/bitmap.c b/ext2fs/bitmap.c
index c6d882b9..7b35d206 100644
--- a/ext2fs/bitmap.c
+++ b/ext2fs/bitmap.c
@@ -34,15 +34,15 @@ static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 
1, 2, 1, 1, 0};
 static inline
 unsigned long count_free (unsigned char *map, unsigned int numchars)
 {
-       unsigned int i;
-       unsigned long sum = 0;
-
-       if (!map)
-               return (0);
-       for (i = 0; i < numchars; i++)
-               sum += nibblemap[map[i] & 0xf] +
-                       nibblemap[(map[i] >> 4) & 0xf];
-       return (sum);
+  unsigned int i;
+  unsigned long sum = 0;
+
+  if (!map)
+    return (0);
+  for (i = 0; i < numchars; i++)
+    sum += nibblemap[map[i] & 0xf] +
+      nibblemap[(map[i] >> 4) & 0xf];
+  return (sum);
 }
 
 /* ---------------------------------------------------------------- */
@@ -72,16 +72,16 @@ find_next_zero_bit(void *addr, unsigned long size, unsigned 
long offset)
       tmp = *(p++);
       tmp |= ~0UL >> (32-offset);
       if (size < 32)
-       goto found_first;
+        goto found_first;
       if (~tmp)
-       goto found_middle;
+        goto found_middle;
       size -= 32;
       result += 32;
     }
   while (size & ~31UL)
     {
       if (~(tmp = *(p++)))
-       goto found_middle;
+        goto found_middle;
       result += 32;
       size -= 32;
     }
diff --git a/ext2fs/dir.c b/ext2fs/dir.c
index bcf90469..7ba08a2e 100644
--- a/ext2fs/dir.c
+++ b/ext2fs/dir.c
@@ -101,8 +101,8 @@ diskfs_null_dirstat (struct dirstat *ds)
 
 static error_t
 dirscanblock (vm_address_t blockoff, struct node *dp, int idx,
-             const char *name, size_t namelen, enum lookup_type type,
-             struct dirstat *ds, ino_t *inum);
+              const char *name, size_t namelen, enum lookup_type type,
+              struct dirstat *ds, ino_t *inum);
 
 
 #if 0                          /* XXX unused for now */
@@ -135,7 +135,7 @@ static const unsigned char file_type_ext2[] =
    <hurd/diskfs.h> for the interface specification.  */
 error_t
 diskfs_lookup_hard (struct node *dp, const char *name, enum lookup_type type,
-                   struct node **npp, struct dirstat *ds, struct protid *cred)
+                    struct node **npp, struct dirstat *ds, struct protid *cred)
 {
   error_t err;
   ino_t inum;
@@ -166,7 +166,7 @@ diskfs_lookup_hard (struct node *dp, const char *name, enum 
lookup_type type,
   if (namelen > EXT2_NAME_LEN)
     {
       if (ds)
-       diskfs_null_dirstat (ds);
+        diskfs_null_dirstat (ds);
       return ENAMETOOLONG;
     }
 
@@ -195,7 +195,7 @@ diskfs_lookup_hard (struct node *dp, const char *name, enum 
lookup_type type,
   /* We allow extra space in case we have to do an EXTEND. */
   buflen = round_page (dp->dn_stat.st_size + DIRBLKSIZ);
   err = vm_map (mach_task_self (),
-               &buf, buflen, 0, 1, memobj, 0, 0, prot, prot, 0);
+                &buf, buflen, 0, 1, memobj, 0, 0, prot, prot, 0);
   mach_port_deallocate (mach_task_self (), memobj);
   if (err)
     return err;
@@ -218,25 +218,25 @@ diskfs_lookup_hard (struct node *dp, const char *name, 
enum lookup_type type,
     {
       err = dirscanblock (blockaddr, dp, idx, name, namelen, type, ds, &inum);
       if (!err)
-       {
-         diskfs_node_disknode (dp)->dir_idx = idx;
-         break;
-       }
+        {
+          diskfs_node_disknode (dp)->dir_idx = idx;
+          break;
+        }
       if (err != ENOENT)
-       {
-         munmap ((caddr_t) buf, buflen);
-         return err;
-       }
+        {
+          munmap ((caddr_t) buf, buflen);
+          return err;
+        }
 
       blockaddr += DIRBLKSIZ;
       idx++;
       if (blockaddr - buf >= dp->dn_stat.st_size && !looped)
-       {
-         /* We've gotten to the end; start back at the beginning */
-         looped = 1;
-         blockaddr = buf;
-         idx = 0;
-       }
+        {
+          /* We've gotten to the end; start back at the beginning */
+          looped = 1;
+          blockaddr = buf;
+          idx = 0;
+        }
     }
 
   diskfs_set_node_atime (dp);
@@ -250,75 +250,75 @@ diskfs_lookup_hard (struct node *dp, const char *name, 
enum lookup_type type,
   if (inum && npp)
     {
       if (namelen != 2 || name[0] != '.' || name[1] != '.')
-       {
-         if (inum == dp->cache_id)
-           {
-             np = dp;
-             diskfs_nref (np);
-           }
-         else
-           {
-             err = diskfs_cached_lookup (inum, &np);
-             if (err)
-               goto out;
-           }
-       }
+        {
+          if (inum == dp->cache_id)
+            {
+              np = dp;
+              diskfs_nref (np);
+            }
+          else
+            {
+              err = diskfs_cached_lookup (inum, &np);
+              if (err)
+                goto out;
+            }
+        }
 
       /* We are looking up .. */
       /* Check to see if this is the root of the filesystem. */
       else if (dp->cache_id == 2)
-       {
-         err = EAGAIN;
-         goto out;
-       }
+        {
+          err = EAGAIN;
+          goto out;
+        }
 
       /* We can't just do diskfs_cached_lookup, because we would then deadlock.
-        So we do this.  Ick.  */
+         So we do this.  Ick.  */
       else if (retry_dotdot)
-       {
-         /* Check to see that we got the same answer as last time. */
-         if (inum != retry_dotdot)
-           {
-             /* Drop what we *thought* was .. (but isn't any more) and
-                try *again*. */
-             diskfs_nput (np);
-             pthread_mutex_unlock (&dp->lock);
-             err = diskfs_cached_lookup (inum, &np);
-             pthread_mutex_lock (&dp->lock);
-             if (err)
-               goto out;
-             retry_dotdot = inum;
-             goto try_again;
-           }
-         /* Otherwise, we got it fine and np is already set properly. */
-       }
+        {
+          /* Check to see that we got the same answer as last time. */
+          if (inum != retry_dotdot)
+            {
+              /* Drop what we *thought* was .. (but isn't any more) and
+                 try *again*. */
+              diskfs_nput (np);
+              pthread_mutex_unlock (&dp->lock);
+              err = diskfs_cached_lookup (inum, &np);
+              pthread_mutex_lock (&dp->lock);
+              if (err)
+                goto out;
+              retry_dotdot = inum;
+              goto try_again;
+            }
+          /* Otherwise, we got it fine and np is already set properly. */
+        }
       else if (!spec_dotdot)
-       {
-         /* Lock them in the proper order, and then
-            repeat the directory scan to see if this is still
-            right.  */
-         pthread_mutex_unlock (&dp->lock);
-         err = diskfs_cached_lookup (inum, &np);
-         pthread_mutex_lock (&dp->lock);
-         if (err)
-           goto out;
-         retry_dotdot = inum;
-         goto try_again;
-       }
+        {
+          /* Lock them in the proper order, and then
+             repeat the directory scan to see if this is still
+             right.  */
+          pthread_mutex_unlock (&dp->lock);
+          err = diskfs_cached_lookup (inum, &np);
+          pthread_mutex_lock (&dp->lock);
+          if (err)
+            goto out;
+          retry_dotdot = inum;
+          goto try_again;
+        }
 
       /* Here below are the spec dotdot cases. */
       else if (type == RENAME || type == REMOVE)
-       np = diskfs_cached_ifind (inum);
+        np = diskfs_cached_ifind (inum);
 
       else if (type == LOOKUP)
-       {
-         diskfs_nput (dp);
-         err = diskfs_cached_lookup (inum, &np);
-         if (err)
-           goto out;
-       }
+        {
+          diskfs_nput (dp);
+          err = diskfs_cached_lookup (inum, &np);
+          if (err)
+            goto out;
+        }
       else
-       assert_backtrace (0);
+        assert_backtrace (0);
     }
 
   if ((type == CREATE || type == RENAME) && !inum && ds && ds->stat == LOOKING)
@@ -339,7 +339,7 @@ diskfs_lookup_hard (struct node *dp, const char *name, enum 
lookup_type type,
     {
       munmap ((caddr_t) buf, buflen);
       if (ds)
-       ds->type = LOOKUP;      /* set to be ignored by drop_dirstat */
+        ds->type = LOOKUP;     /* set to be ignored by drop_dirstat */
     }
   else
     {
@@ -351,25 +351,25 @@ diskfs_lookup_hard (struct node *dp, const char *name, 
enum lookup_type type,
     {
       assert_backtrace (npp);
       if (err)
-       {
-         if (!spec_dotdot)
-           {
-             /* Normal case */
-             if (np == dp)
-               diskfs_nrele (np);
-             else
-               diskfs_nput (np);
-           }
-         else if (type == RENAME || type == REMOVE)
-           /* We just did diskfs_cached_ifind to get np; that allocates
-              no new references, so we don't have anything to do */
-           ;
-         else if (type == LOOKUP)
-           /* We did diskfs_cached_lookup */
-           diskfs_nput (np);
-       }
+        {
+          if (!spec_dotdot)
+          {
+            /* Normal case */
+            if (np == dp)
+              diskfs_nrele (np);
+            else
+              diskfs_nput (np);
+          }
+          else if (type == RENAME || type == REMOVE)
+            /* We just did diskfs_cached_ifind to get np; that allocates
+               no new references, so we don't have anything to do */
+            ;
+          else if (type == LOOKUP)
+            /* We did diskfs_cached_lookup */
+            diskfs_nput (np);
+        }
       else
-       *npp = np;
+        *npp = np;
     }
 
   return err ? : inum ? 0 : ENOENT;
@@ -381,8 +381,8 @@ diskfs_lookup_hard (struct node *dp, const char *name, enum 
lookup_type type,
    return ENOENT.  */
 static error_t
 dirscanblock (vm_address_t blockaddr, struct node *dp, int idx,
-             const char *name, size_t namelen, enum lookup_type type,
-             struct dirstat *ds, ino_t *inum)
+              const char *name, size_t namelen, enum lookup_type type,
+              struct dirstat *ds, ino_t *inum)
 {
   size_t nfree = 0;
   size_t needed = 0;
@@ -395,7 +395,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int 
idx,
   int consider_compress = 0;
 
   if (ds && (ds->stat == LOOKING
-            || ds->stat == COMPRESS))
+      || ds->stat == COMPRESS))
     {
       looking = 1;
       countcopies = 1;
@@ -409,68 +409,68 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, 
int idx,
       entry = (struct ext2_dir_entry_2 *)currentoff;
 
       if (!entry->rec_len
-         || entry->rec_len % EXT2_DIR_PAD
-         || entry->name_len > EXT2_NAME_LEN
-         || currentoff + entry->rec_len > blockaddr + DIRBLKSIZ
-         || EXT2_DIR_REC_LEN (entry->name_len) > entry->rec_len
-         || memchr (entry->name, '\0', entry->name_len))
-       {
-         ext2_warning ("bad directory entry: inode: %Ld offset: %lu",
-                       dp->cache_id,
-                       currentoff - blockaddr + idx * DIRBLKSIZ);
-         return ENOENT;
-       }
+          || entry->rec_len % EXT2_DIR_PAD
+          || entry->name_len > EXT2_NAME_LEN
+          || currentoff + entry->rec_len > blockaddr + DIRBLKSIZ
+          || EXT2_DIR_REC_LEN (entry->name_len) > entry->rec_len
+          || memchr (entry->name, '\0', entry->name_len))
+        {
+          ext2_warning ("bad directory entry: inode: %Ld offset: %lu",
+              dp->cache_id,
+              currentoff - blockaddr + idx * DIRBLKSIZ);
+          return ENOENT;
+        }
 
       if (looking || countcopies)
-       {
-         size_t thisfree;
-
-         /* Count how much free space this entry has in it. */
-         if (entry->inode == 0)
-           thisfree = entry->rec_len;
-         else
-           thisfree = entry->rec_len - EXT2_DIR_REC_LEN (entry->name_len);
-
-         /* If this isn't at the front of the block, then it will
-            have to be copied if we do a compression; count the
-            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
-              this one, so don't bother counting any more. */
-           countcopies = 0;
-
-         if (thisfree >= needed)
-           {
-             ds->type = CREATE;
-             ds->stat = entry->inode == 0 ? TAKE : SHRINK;
-             ds->entry = entry;
-             ds->idx = idx;
-             looking = countcopies = 0;
-           }
-         else
-           {
-             nfree += thisfree;
-             if (nfree >= needed)
-               consider_compress = 1;
-           }
-       }
+        {
+          size_t thisfree;
+
+          /* Count how much free space this entry has in it. */
+          if (entry->inode == 0)
+            thisfree = entry->rec_len;
+          else
+            thisfree = entry->rec_len - EXT2_DIR_REC_LEN (entry->name_len);
+
+          /* If this isn't at the front of the block, then it will
+             have to be copied if we do a compression; count the
+             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
+               this one, so don't bother counting any more. */
+            countcopies = 0;
+
+          if (thisfree >= needed)
+          {
+            ds->type = CREATE;
+            ds->stat = entry->inode == 0 ? TAKE : SHRINK;
+            ds->entry = entry;
+            ds->idx = idx;
+            looking = countcopies = 0;
+          }
+          else
+          {
+            nfree += thisfree;
+            if (nfree >= needed)
+              consider_compress = 1;
+          }
+        }
 
       if (entry->inode)
-       nentries++;
+        nentries++;
 
       if (entry->name_len == namelen
-         && entry->name[0] == name[0]
-         && entry->inode
-         && !bcmp (entry->name, name, namelen))
-       break;
+          && entry->name[0] == name[0]
+          && entry->inode
+          && !bcmp (entry->name, name, namelen))
+        break;
     }
 
   if (consider_compress
       && (ds->stat == LOOKING
-         || (ds->stat == COMPRESS && ds->nbytes > nbytes)))
+        || (ds->stat == COMPRESS && ds->nbytes > nbytes)))
     {
       ds->type = CREATE;
       ds->stat = COMPRESS;
@@ -485,17 +485,17 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, 
int idx,
       /* The name is not in this block. */
 
       /* Because we scanned the entire block, we should write
-        down how many entries there were. */
+         down how many entries there were. */
       if (!diskfs_node_disknode (dp)->dirents)
-       {
-         diskfs_node_disknode (dp)->dirents =
-           malloc ((dp->dn_stat.st_size / DIRBLKSIZ) * sizeof (int));
-         for (i = 0; i < dp->dn_stat.st_size/DIRBLKSIZ; i++)
-           diskfs_node_disknode (dp)->dirents[i] = -1;
-       }
+        {
+          diskfs_node_disknode (dp)->dirents =
+            malloc ((dp->dn_stat.st_size / DIRBLKSIZ) * sizeof (int));
+          for (i = 0; i < dp->dn_stat.st_size/DIRBLKSIZ; i++)
+            diskfs_node_disknode (dp)->dirents[i] = -1;
+        }
       /* Make sure the count is correct if there is one now. */
       assert_backtrace (diskfs_node_disknode (dp)->dirents[idx] == -1
-             || diskfs_node_disknode (dp)->dirents[idx] == nentries);
+          || diskfs_node_disknode (dp)->dirents[idx] == nentries);
       diskfs_node_disknode (dp)->dirents[idx] = nentries;
 
       return ENOENT;
@@ -526,7 +526,7 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int 
idx,
    the preceding lookup call, and only if that call returned ENOENT. */
 error_t
 diskfs_direnter_hard (struct node *dp, const char *name, struct node *np,
-                     struct dirstat *ds, struct protid *cred)
+                      struct dirstat *ds, struct protid *cred)
 {
   struct ext2_dir_entry_2 *new;
   size_t namelen = strlen (name);
@@ -558,7 +558,7 @@ diskfs_direnter_hard (struct node *dp, const char *name, 
struct node *np,
 
     case SHRINK:
       /* We are supposed to take the extra space at the end
-        of this slot. */
+         of this slot. */
       oldneeded = EXT2_DIR_REC_LEN (ds->entry->name_len);
       assert_backtrace (ds->entry->rec_len - oldneeded >= needed);
 
@@ -570,28 +570,28 @@ diskfs_direnter_hard (struct node *dp, const char *name, 
struct node *np,
 
     case COMPRESS:
       /* We are supposed to move all the entries to the
-        front of the block, giving each the minimum
-        necessary room.  This should free up enough space
-        for the new entry. */
+         front of the block, giving each the minimum
+         necessary room.  This should free up enough space
+         for the new entry. */
       fromoff = tooff = (vm_address_t) ds->entry;
 
       while (fromoff < (vm_address_t) ds->entry + DIRBLKSIZ)
-       {
-         struct ext2_dir_entry_2 *from = (struct ext2_dir_entry_2 *)fromoff;
-         struct ext2_dir_entry_2 *to = (struct ext2_dir_entry_2 *) tooff;
-         size_t fromreclen = from->rec_len;
+        {
+          struct ext2_dir_entry_2 *from = (struct ext2_dir_entry_2 *)fromoff;
+          struct ext2_dir_entry_2 *to = (struct ext2_dir_entry_2 *) tooff;
+          size_t fromreclen = from->rec_len;
 
-         if (from->inode != 0)
-           {
-             assert_backtrace (fromoff >= tooff);
+          if (from->inode != 0)
+            {
+              assert_backtrace (fromoff >= tooff);
 
-             memmove (to, from, fromreclen);
-             to->rec_len = EXT2_DIR_REC_LEN (to->name_len);
+              memmove (to, from, fromreclen);
+              to->rec_len = EXT2_DIR_REC_LEN (to->name_len);
 
-             tooff += to->rec_len;
-           }
-         fromoff += fromreclen;
-       }
+              tooff += to->rec_len;
+            }
+          fromoff += fromreclen;
+        }
 
       totfreed = (vm_address_t) ds->entry + DIRBLKSIZ - tooff;
       assert_backtrace (totfreed >= needed);
@@ -606,27 +606,27 @@ diskfs_direnter_hard (struct node *dp, const char *name, 
struct node *np,
 
       oldsize = dp->dn_stat.st_size;
       if ((off_t)(oldsize + DIRBLKSIZ) != (dp->dn_stat.st_size + DIRBLKSIZ))
-       {
-         /* We can't possibly map the whole directory in.  */
-         munmap ((caddr_t) ds->mapbuf, ds->mapextent);
-         return EOVERFLOW;
-       }
+        {
+          /* We can't possibly map the whole directory in.  */
+          munmap ((caddr_t) ds->mapbuf, ds->mapextent);
+          return EOVERFLOW;
+        }
       while (oldsize + DIRBLKSIZ > dp->allocsize)
-       {
-         err = diskfs_grow (dp, oldsize + DIRBLKSIZ, cred);
-         if (err)
-           {
-             munmap ((caddr_t) ds->mapbuf, ds->mapextent);
-             return err;
-           }
-       }
+        {
+          err = diskfs_grow (dp, oldsize + DIRBLKSIZ, cred);
+          if (err)
+          {
+            munmap ((caddr_t) ds->mapbuf, ds->mapextent);
+            return err;
+          }
+        }
 
       new = (struct ext2_dir_entry_2 *) (ds->mapbuf + oldsize);
       err = hurd_safe_memset (new, 0, DIRBLKSIZ);
       if (err)
        {
-        if (err == EKERN_MEMORY_ERROR)
-          err = ENOSPC;
+         if (err == EKERN_MEMORY_ERROR)
+           err = ENOSPC;
          munmap ((caddr_t) ds->mapbuf, ds->mapextent);
          return err;
        }
@@ -653,9 +653,9 @@ diskfs_direnter_hard (struct node *dp, const char *name, 
struct node *np,
      the virtual node to cause all the directory entries linked to
      its underlying inode to reflect the proper type.  */
   new->file_type = (EXT2_HAS_INCOMPAT_FEATURE (sblock,
-                                              EXT2_FEATURE_INCOMPAT_FILETYPE)
-                   ? file_type_ext2[IFTODT (np->dn_stat.st_mode & S_IFMT)]
-                   : 0);
+                                               EXT2_FEATURE_INCOMPAT_FILETYPE)
+                    ? file_type_ext2[IFTODT (np->dn_stat.st_mode & S_IFMT)]
+                    : 0);
 #else
   new->file_type = 0;
 #endif
@@ -671,36 +671,36 @@ diskfs_direnter_hard (struct node *dp, const char *name, 
struct node *np,
   if (ds->stat != EXTEND)
     {
       /* If we are keeping count of this block, then keep the count up
-        to date. */
+         to date. */
       if (diskfs_node_disknode (dp)->dirents
-         && diskfs_node_disknode (dp)->dirents[ds->idx] != -1)
-       diskfs_node_disknode (dp)->dirents[ds->idx]++;
+          && diskfs_node_disknode (dp)->dirents[ds->idx] != -1)
+        diskfs_node_disknode (dp)->dirents[ds->idx]++;
     }
   else
     {
       int i;
       /* It's cheap, so start a count here even if we aren't counting
-        anything at all. */
+         anything at all. */
       if (diskfs_node_disknode (dp)->dirents)
-       {
-         diskfs_node_disknode (dp)->dirents =
-           realloc (diskfs_node_disknode (dp)->dirents,
-                    (dp->dn_stat.st_size / DIRBLKSIZ * sizeof (int)));
-         for (i = oldsize / DIRBLKSIZ;
-              i < dp->dn_stat.st_size / DIRBLKSIZ;
-              i++)
-           diskfs_node_disknode (dp)->dirents[i] = -1;
-
-         diskfs_node_disknode (dp)->dirents[ds->idx] = 1;
-       }
+        {
+          diskfs_node_disknode (dp)->dirents =
+            realloc (diskfs_node_disknode (dp)->dirents,
+                (dp->dn_stat.st_size / DIRBLKSIZ * sizeof (int)));
+          for (i = oldsize / DIRBLKSIZ;
+              i < dp->dn_stat.st_size / DIRBLKSIZ;
+              i++)
+            diskfs_node_disknode (dp)->dirents[i] = -1;
+
+          diskfs_node_disknode (dp)->dirents[ds->idx] = 1;
+        }
       else
-       {
-         diskfs_node_disknode (dp)->dirents =
-           malloc (dp->dn_stat.st_size / DIRBLKSIZ * sizeof (int));
-         for (i = 0; i < dp->dn_stat.st_size / DIRBLKSIZ; i++)
-           diskfs_node_disknode (dp)->dirents[i] = -1;
-         diskfs_node_disknode (dp)->dirents[ds->idx] = 1;
-       }
+        {
+          diskfs_node_disknode (dp)->dirents =
+            malloc (dp->dn_stat.st_size / DIRBLKSIZ * sizeof (int));
+          for (i = 0; i < dp->dn_stat.st_size / DIRBLKSIZ; i++)
+            diskfs_node_disknode (dp)->dirents[i] = -1;
+          diskfs_node_disknode (dp)->dirents[ds->idx] = 1;
+        }
     }
 
   diskfs_file_update (dp, diskfs_synchronous);
@@ -726,7 +726,7 @@ diskfs_dirremove_hard (struct node *dp, struct dirstat *ds)
   else
     {
       assert_backtrace ((vm_address_t) ds->entry - (vm_address_t) ds->preventry
-             == ds->preventry->rec_len);
+                        == ds->preventry->rec_len);
       ds->preventry->rec_len += ds->entry->rec_len;
     }
 
@@ -788,7 +788,7 @@ diskfs_dirempty (struct node *dp, struct protid *cred)
     return 0;
 
   err = vm_map (mach_task_self (), &buf, dp->dn_stat.st_size, 0,
-               1, memobj, 0, 0, VM_PROT_READ, VM_PROT_READ, 0);
+                1, memobj, 0, 0, VM_PROT_READ, VM_PROT_READ, 0);
   mach_port_deallocate (mach_task_self (), memobj);
   assert_backtrace (!err);
 
@@ -801,11 +801,11 @@ diskfs_dirempty (struct node *dp, struct protid *cred)
       entry = (struct ext2_dir_entry_2 *) curoff;
 
       if (entry->inode != 0
-         && (entry->name_len > 2
-             || entry->name[0] != '.'
-             || (entry->name[1] != '.'
-                 && entry->name[1] != '\0')))
-       hit = 1;
+          && (entry->name_len > 2
+            || entry->name[0] != '.'
+            || (entry->name[1] != '.'
+              && entry->name[1] != '\0')))
+        hit = 1;
     }
 
   diskfs_set_node_atime (dp);
@@ -857,11 +857,11 @@ count_dirents (struct node *dp, block_t nb, char *buf)
     {
       entry = (struct ext2_dir_entry_2 *) offinblk;
       if (entry->inode)
-       count++;
+        count++;
     }
 
   assert_backtrace (diskfs_node_disknode (dp)->dirents[nb] == -1
-         || diskfs_node_disknode (dp)->dirents[nb] == count);
+                    || diskfs_node_disknode (dp)->dirents[nb] == count);
   diskfs_node_disknode (dp)->dirents[nb] = count;
   return 0;
 }
@@ -874,12 +874,12 @@ count_dirents (struct node *dp, block_t nb, char *buf)
    <hurd/diskfs.h>. */
 error_t
 diskfs_get_directs (struct node *dp,
-                   int entry,
-                   int nentries,
-                   char **data,
-                   size_t *datacnt,
-                   vm_size_t bufsiz,
-                   int *amt)
+                    int entry,
+                    int nentries,
+                    char **data,
+                    size_t *datacnt,
+                    vm_size_t bufsiz,
+                    int *amt)
 {
   block_t blkno;
   block_t nblks;
@@ -901,7 +901,7 @@ diskfs_get_directs (struct node *dp,
     {
       diskfs_node_disknode (dp)->dirents = malloc (nblks * sizeof (int));
       for (i = 0; i < nblks; i++)
-       diskfs_node_disknode (dp)->dirents[i] = -1;
+        diskfs_node_disknode (dp)->dirents[i] = -1;
     }
 
   /* Scan through the entries to find ENTRY.  If we encounter
@@ -912,16 +912,16 @@ diskfs_get_directs (struct node *dp,
   for (blkno = 0; blkno < nblks; blkno++)
     {
       if (diskfs_node_disknode (dp)->dirents[blkno] == -1)
-       {
-         err = count_dirents (dp, blkno, buf);
-         if (err)
-           return err;
-         bufvalid = 1;
-       }
+        {
+          err = count_dirents (dp, blkno, buf);
+          if (err)
+            return err;
+          bufvalid = 1;
+        }
 
       if (curentry + diskfs_node_disknode (dp)->dirents[blkno] > entry)
-       /* ENTRY starts in this block. */
-       break;
+        /* ENTRY starts in this block. */
+        break;
 
       curentry += diskfs_node_disknode (dp)->dirents[blkno];
 
@@ -931,8 +931,8 @@ diskfs_get_directs (struct node *dp,
   if (blkno == nblks)
     {
       /* We reached the end of the directory without seeing ENTRY.
-        This is treated as an EOF condition, meaning we return
-        success with empty results.  */
+         This is treated as an EOF condition, meaning we return
+         success with empty results.  */
       *datacnt = 0;
       *amt = 0;
       return 0;
@@ -953,9 +953,9 @@ diskfs_get_directs (struct node *dp,
       size_t max_entries = dp->dn_stat.st_size / min_entry_size;
       /* The maximum difference in size per directory entry.  */
       size_t entry_extra =
-       DIRENT_ALIGN
-         + (min_dirent_size > min_entry_size
-            ? min_dirent_size - min_entry_size : 0);
+        DIRENT_ALIGN
+        + (min_dirent_size > min_entry_size
+            ? min_dirent_size - min_entry_size : 0);
 
       allocsize = round_page (dp->dn_stat.st_size + max_entries * entry_extra);
     }
@@ -970,20 +970,20 @@ diskfs_get_directs (struct node *dp,
   if (curentry != entry)
     {
       /* Look through the block to find out where to start,
-        setting bufp appropriately.  */
+         setting bufp appropriately.  */
       if (!bufvalid)
-       {
-         err = diskfs_node_rdwr (dp, buf, blkno * DIRBLKSIZ, DIRBLKSIZ,
-                                 0, 0, &checklen);
-         if (err)
-           return err;
-         assert_backtrace (checklen == DIRBLKSIZ);
-         bufvalid = 1;
-       }
+        {
+          err = diskfs_node_rdwr (dp, buf, blkno * DIRBLKSIZ, DIRBLKSIZ,
+                                  0, 0, &checklen);
+          if (err)
+            return err;
+          assert_backtrace (checklen == DIRBLKSIZ);
+          bufvalid = 1;
+        }
       for (i = 0, bufp = buf;
-          i < entry - curentry && bufp - buf < DIRBLKSIZ;
-          bufp += ((struct ext2_dir_entry_2 *)bufp)->rec_len, i++)
-       ;
+          i < entry - curentry && bufp - buf < DIRBLKSIZ;
+          bufp += ((struct ext2_dir_entry_2 *)bufp)->rec_len, i++)
+        ;
       /* Make sure we didn't run off the end. */
       assert_backtrace (bufp - buf < DIRBLKSIZ);
     }
@@ -993,100 +993,100 @@ diskfs_get_directs (struct node *dp,
 
   /* Copy the entries, one at a time. */
   while (((nentries == -1) || (i < nentries))
-        && (!bufsiz || (datap - *data < bufsiz) )
-        && blkno < nblks)
+         && (!bufsiz || (datap - *data < bufsiz) )
+         && blkno < nblks)
     {
       if (!bufvalid)
-       {
-         err = diskfs_node_rdwr (dp, buf, blkno * DIRBLKSIZ, DIRBLKSIZ,
-                                 0, 0, &checklen);
-         if (err)
-           return err;
-         assert_backtrace (checklen == DIRBLKSIZ);
-         bufvalid = 1;
-         bufp = buf;
-       }
+        {
+          err = diskfs_node_rdwr (dp, buf, blkno * DIRBLKSIZ, DIRBLKSIZ,
+              0, 0, &checklen);
+          if (err)
+            return err;
+          assert_backtrace (checklen == DIRBLKSIZ);
+          bufvalid = 1;
+          bufp = buf;
+        }
 
       entryp = (struct ext2_dir_entry_2 *)bufp;
 
       if (entryp->inode)
-       {
-         int rec_len;
-         int name_len = entryp->name_len;
-
-         userp = (struct dirent *) datap;
-
-         /* Length is structure before the name + the name + '\0', all
-            padded to a four-byte alignment.  */
-         rec_len =
-           ((offsetof (struct dirent, d_name)
-             + name_len + 1
-             + (DIRENT_ALIGN - 1))
-            & ~(DIRENT_ALIGN - 1));
-
-         /* See if this record would run over the end of the return buffer. */
-         if (bufsiz == 0)
-           /* It shouldn't ever, as we calculated the worst case size.  */
-           assert_backtrace (datap + rec_len <= *data + allocsize);
-         else
-           /* It's ok if it does, just leave off returning this entry.  */
-           if (datap + rec_len > *data + allocsize)
-             break;
-
-         userp->d_fileno = entryp->inode;
-         userp->d_reclen = rec_len;
-         userp->d_namlen = name_len;
+        {
+          int rec_len;
+          int name_len = entryp->name_len;
+
+          userp = (struct dirent *) datap;
+
+          /* Length is structure before the name + the name + '\0', all
+             padded to a four-byte alignment.  */
+          rec_len =
+            ((offsetof (struct dirent, d_name)
+              + name_len + 1
+              + (DIRENT_ALIGN - 1))
+             & ~(DIRENT_ALIGN - 1));
+
+          /* See if this record would run over the end of the return buffer. */
+          if (bufsiz == 0)
+            /* It shouldn't ever, as we calculated the worst case size.  */
+            assert_backtrace (datap + rec_len <= *data + allocsize);
+          else
+            /* It's ok if it does, just leave off returning this entry.  */
+            if (datap + rec_len > *data + allocsize)
+              break;
+
+          userp->d_fileno = entryp->inode;
+          userp->d_reclen = rec_len;
+          userp->d_namlen = name_len;
 
 #if 0
-         /* We don't bother to check the EXT2_FEATURE_INCOMPAT_FILETYPE
-            flag in the superblock, because in old filesystems the
-            file_type field is the high byte of the length field and is
-            always zero because names cannot be that long.  */
-         if (entryp->file_type < EXT2_FT_MAX)
-           userp->d_type = ext2_file_type[entryp->file_type];
-         else
-           {
-             ext2_warning ("bad type %d in directory entry: "
-                           "inode: %d offset: %d",
-                           entryp->file_type,
-                           dp->cache_id,
-                           blkno * DIRBLKSIZ + bufp - buf);
-             userp->d_type = DT_UNKNOWN;
-           }
+          /* We don't bother to check the EXT2_FEATURE_INCOMPAT_FILETYPE
+             flag in the superblock, because in old filesystems the
+             file_type field is the high byte of the length field and is
+             always zero because names cannot be that long.  */
+          if (entryp->file_type < EXT2_FT_MAX)
+            userp->d_type = ext2_file_type[entryp->file_type];
+          else
+            {
+              ext2_warning ("bad type %d in directory entry: "
+                            "inode: %d offset: %d",
+                            entryp->file_type,
+                            dp->cache_id,
+                            blkno * DIRBLKSIZ + bufp - buf);
+              userp->d_type = DT_UNKNOWN;
+            }
 #else
-         /* XXX
-            For complex reasons it might not be correct to return
-            the filesystem's d_type value to the user.  */
-         userp->d_type = DT_UNKNOWN;
+          /* XXX
+             For complex reasons it might not be correct to return
+             the filesystem's d_type value to the user.  */
+          userp->d_type = DT_UNKNOWN;
 #endif
-         memcpy (userp->d_name, entryp->name, name_len);
-         userp->d_name[name_len] = '\0';
+          memcpy (userp->d_name, entryp->name, name_len);
+          userp->d_name[name_len] = '\0';
 
-         datap += rec_len;
-         i++;
-       }
+          datap += rec_len;
+          i++;
+        }
 
       if (entryp->rec_len == 0)
-       {
-         ext2_warning ("zero length directory entry: inode: %Ld offset: %zd",
-                       dp->cache_id,
-                       blkno * DIRBLKSIZ + bufp - buf);
-         return EIO;
-       }
+        {
+          ext2_warning ("zero length directory entry: inode: %Ld offset: %zd",
+              dp->cache_id,
+              blkno * DIRBLKSIZ + bufp - buf);
+          return EIO;
+        }
 
       bufp += entryp->rec_len;
       if (bufp - buf == DIRBLKSIZ)
-       {
-         blkno++;
-         bufvalid = 0;
-       }
+        {
+          blkno++;
+          bufvalid = 0;
+        }
       else if (bufp - buf > DIRBLKSIZ)
-       {
-         ext2_warning ("directory entry too long: inode: %Ld offset: %zd",
-                       dp->cache_id,
-                       blkno * DIRBLKSIZ + bufp - buf - entryp->rec_len);
-         return EIO;
-       }
+        {
+          ext2_warning ("directory entry too long: inode: %Ld offset: %zd",
+              dp->cache_id,
+              blkno * DIRBLKSIZ + bufp - buf - entryp->rec_len);
+          return EIO;
+        }
     }
 
   /* We've copied all we can.  If we allocated our own array
@@ -1094,8 +1094,8 @@ diskfs_get_directs (struct node *dp,
   if (allocsize > *datacnt)
     {
       if (round_page (datap - *data) < allocsize)
-       munmap ((caddr_t) (*data + round_page (datap - *data)),
-               allocsize - round_page (datap - *data));
+        munmap ((caddr_t) (*data + round_page (datap - *data)),
+            allocsize - round_page (datap - *data));
     }
 
   /* Set variables for return */
diff --git a/ext2fs/ext2fs.c b/ext2fs/ext2fs.c
index 50435c76..5a5506c6 100644
--- a/ext2fs/ext2fs.c
+++ b/ext2fs/ext2fs.c
@@ -144,10 +144,10 @@ parse_opt (int key, char *arg, struct argp_state *state)
     case 'S':
       values->sb_block = strtoul (arg, &arg, 0);
       if (!arg || *arg != '\0')
-       {
-         argp_error (state, "invalid number for --sblock");
-         return EINVAL;
-       }
+        {
+          argp_error (state, "invalid number for --sblock");
+          return EINVAL;
+        }
       break;
 #endif
 
@@ -155,7 +155,7 @@ parse_opt (int key, char *arg, struct argp_state *state)
       state->child_inputs[0] = state->input;
       values = malloc (sizeof *values);
       if (values == 0)
-       return ENOMEM;
+        return ENOMEM;
       state->hook = values;
       memset (values, 0, sizeof *values);
 #ifdef ALTERNATE_SBLOCK
@@ -166,14 +166,14 @@ parse_opt (int key, char *arg, struct argp_state *state)
     case ARGP_KEY_SUCCESS:
       /* All options parse successfully, so implement ours if possible.  */
       if (values->debug_flag)
-       {
+        {
 #ifdef EXT2FS_DEBUG
-         ext2_debug_flag = !ext2_debug_flag;
+          ext2_debug_flag = !ext2_debug_flag;
 #else
-         argp_failure (state, 2, 0, "debugging support not compiled in");
-         return EINVAL;
+          argp_failure (state, 2, 0, "debugging support not compiled in");
+          return EINVAL;
 #endif
-       }
+        }
 
       use_xattr_translator_records = values->use_xattr_translator_records;
       break;
@@ -227,13 +227,13 @@ main (int argc, char **argv)
   /* Initialize the diskfs library, parse arguments, and open the store.
      This starts the first diskfs thread for us.  */
   store = diskfs_init_main (&startup_argp, argc, argv,
-                           &store_parsed, &bootstrap);
+                            &store_parsed, &bootstrap);
 
   if (store->size < SBLOCK_OFFS + SBLOCK_SIZE)
     ext2_panic ("device too small for superblock (%Ld bytes)", store->size);
   if (store->log2_blocks_per_page < 0)
     ext2_panic ("device block size (%zu) greater than page size (%zd)",
-               store->block_size, vm_page_size);
+                store->block_size, vm_page_size);
 
   /* Map the entire disk. */
   create_disk_pager ();
diff --git a/ext2fs/getblk.c b/ext2fs/getblk.c
index 43daf6c9..10a34f8d 100644
--- a/ext2fs/getblk.c
+++ b/ext2fs/getblk.c
@@ -53,7 +53,7 @@ ext2_discard_prealloc (struct node *node)
     {
       int i = diskfs_node_disknode (node)->info.i_prealloc_count;
       ext2_debug ("discarding %d prealloced blocks for inode %d",
-                 i, node->cache_id);
+                  i, node->cache_id);
       diskfs_node_disknode (node)->info.i_prealloc_count = 0;
       ext2_free_blocks (diskfs_node_disknode (node)->info.i_prealloc_block, i);
     }
@@ -79,24 +79,24 @@ ext2_alloc_block (struct node *node, block_t goal, int zero)
       result = diskfs_node_disknode (node)->info.i_prealloc_block++;
       diskfs_node_disknode (node)->info.i_prealloc_count--;
       ext2_debug ("preallocation hit (%lu/%lu) => %u",
-                 ++alloc_hits, ++alloc_attempts, result);
+                  ++alloc_hits, ++alloc_attempts, result);
     }
   else
     {
       ext2_debug ("preallocation miss (%lu/%lu)",
-                 alloc_hits, ++alloc_attempts);
+                  alloc_hits, ++alloc_attempts);
       ext2_discard_prealloc (node);
-      result = ext2_new_block
-       (goal,
-        S_ISREG (node->dn_stat.st_mode)
-        ? (sblock->s_prealloc_blocks ?: EXT2_DEFAULT_PREALLOC_BLOCKS)
-        : (S_ISDIR (node->dn_stat.st_mode)
-           && EXT2_HAS_COMPAT_FEATURE(sblock,
-                                      EXT2_FEATURE_COMPAT_DIR_PREALLOC))
-        ? sblock->s_prealloc_dir_blocks
-        : 0,
-        &diskfs_node_disknode (node)->info.i_prealloc_count,
-        &diskfs_node_disknode (node)->info.i_prealloc_block);
+      result = ext2_new_block (
+          goal,
+          S_ISREG (node->dn_stat.st_mode)
+          ? (sblock->s_prealloc_blocks ?: EXT2_DEFAULT_PREALLOC_BLOCKS)
+          : (S_ISDIR (node->dn_stat.st_mode)
+            && EXT2_HAS_COMPAT_FEATURE(sblock,
+              EXT2_FEATURE_COMPAT_DIR_PREALLOC))
+          ? sblock->s_prealloc_dir_blocks
+          : 0,
+          &diskfs_node_disknode (node)->info.i_prealloc_count,
+          &diskfs_node_disknode (node)->info.i_prealloc_block);
     }
 #else
   result = ext2_new_block (goal, 0, 0);
@@ -114,7 +114,7 @@ ext2_alloc_block (struct node *node, block_t goal, int zero)
 
 static error_t
 inode_getblk (struct node *node, int nr, int create, int zero,
-             block_t new_block, block_t *result)
+              block_t new_block, block_t *result)
 {
   int i;
   block_t goal = 0;
@@ -141,24 +141,24 @@ inode_getblk (struct node *node, int nr, int create, int 
zero,
   if (!goal)
     {
       for (i = nr - 1; i >= 0; i--)
-       {
-         if (diskfs_node_disknode (node)->info.i_data[i])
-           {
-             goal = diskfs_node_disknode (node)->info.i_data[i];
-             break;
-           }
-       }
+        {
+          if (diskfs_node_disknode (node)->info.i_data[i])
+            {
+              goal = diskfs_node_disknode (node)->info.i_data[i];
+              break;
+            }
+        }
       if (!goal)
-       goal =
-         (diskfs_node_disknode (node)->info.i_block_group
+        goal =
+          (diskfs_node_disknode (node)->info.i_block_group
            * EXT2_BLOCKS_PER_GROUP (sblock))
-         + sblock->s_first_data_block;
+          + sblock->s_first_data_block;
     }
 
   *result = ext2_alloc_block (node, goal, zero);
 
   ext2_debug ("%screate, hint = %u, goal = %u => %u",
-             create ? "" : "no", hint, goal, *result);
+              create ? "" : "no", hint, goal, *result);
 
   if (!*result)
     return ENOSPC;
@@ -179,7 +179,7 @@ inode_getblk (struct node *node, int nr, int create, int 
zero,
 
 error_t
 block_getblk (struct node *node, block_t block, int nr, int create, int zero,
-             block_t new_block, block_t *result)
+              block_t new_block, block_t *result)
 {
   int i;
   block_t goal = 0;
@@ -203,15 +203,15 @@ block_getblk (struct node *node, block_t block, int nr, 
int create, int zero,
   if (!goal)
     {
       for (i = nr - 1; i >= 0; i--)
-       {
-         if (bh[i])
-           {
-             goal = bh[i];
-             break;
-           }
-       }
+        {
+          if (bh[i])
+            {
+              goal = bh[i];
+              break;
+            }
+        }
       if (!goal)
-       goal = block;
+        goal = block;
     }
 
   *result = ext2_alloc_block (node, goal, zero);
@@ -261,8 +261,8 @@ ext2_getblk (struct node *node, block_t block, int create, 
block_t *disk_block)
    */
 
   ext2_debug ("block = %u, next = %u, goal = %u", block,
-             diskfs_node_disknode (node)->info.i_next_alloc_block,
-             diskfs_node_disknode (node)->info.i_next_alloc_goal);
+              diskfs_node_disknode (node)->info.i_next_alloc_block,
+              diskfs_node_disknode (node)->info.i_next_alloc_goal);
 
   if (block == diskfs_node_disknode (node)->info.i_next_alloc_block + 1)
     {
@@ -280,7 +280,7 @@ ext2_getblk (struct node *node, block_t block, int create, 
block_t *disk_block)
     {
       err = inode_getblk (node, EXT2_IND_BLOCK, create, 1, b, &indir);
       if (!err)
-       err = block_getblk (node, indir, block, create, 0, b, disk_block);
+        err = block_getblk (node, indir, block, create, 0, b, disk_block);
       return err;
     }
 
@@ -289,11 +289,11 @@ ext2_getblk (struct node *node, block_t block, int 
create, block_t *disk_block)
     {
       err = inode_getblk (node, EXT2_DIND_BLOCK, create, 1, b, &indir);
       if (!err)
-       err = block_getblk (node, indir, block / addr_per_block, create, 1,
-                           b, &indir);
+        err = block_getblk (node, indir, block / addr_per_block, create, 1,
+                            b, &indir);
       if (!err)
-       err = block_getblk (node, indir, block & (addr_per_block - 1),
-                           create, 0, b, disk_block);
+        err = block_getblk (node, indir, block & (addr_per_block - 1),
+                            create, 0, b, disk_block);
       return err;
     }
 
@@ -301,15 +301,15 @@ ext2_getblk (struct node *node, block_t block, int 
create, block_t *disk_block)
   err = inode_getblk (node, EXT2_TIND_BLOCK, create, 1, b, &indir);
   if (!err)
     err = block_getblk (node, indir, block / (addr_per_block * addr_per_block),
-                       create, 1, b, &indir);
+                        create, 1, b, &indir);
   if (!err)
     err =
       block_getblk (node, indir,
-                   (block / addr_per_block) & (addr_per_block - 1),
-                   create, 1, b, &indir);
+                    (block / addr_per_block) & (addr_per_block - 1),
+                    create, 1, b, &indir);
   if (!err)
     err = block_getblk (node, indir, block & (addr_per_block - 1), create, 0,
-                       b, disk_block);
+                        b, disk_block);
 
   return err;
 }
diff --git a/ext2fs/hyper.c b/ext2fs/hyper.c
index e77c0266..93fb7dbb 100644
--- a/ext2fs/hyper.c
+++ b/ext2fs/hyper.c
@@ -35,7 +35,7 @@ allocate_mod_map (void)
     /* Get rid of the old one.  */
     munmap (modified_global_blocks, mod_map_size);
 
- if (!diskfs_readonly && block_size < vm_page_size)
+  if (!diskfs_readonly && block_size < vm_page_size)
     /* If the block size is too small, we have to take extra care when
        writing out pages from the global pager, to make sure we don't stomp
        on any file pager blocks.  In this case use a bitmap to record which
@@ -44,7 +44,7 @@ allocate_mod_map (void)
       /* One bit per filesystem block.  */
       mod_map_size = sblock->s_blocks_count >> 3;
       modified_global_blocks = mmap (0, mod_map_size, PROT_READ|PROT_WRITE,
-                                    MAP_ANON, 0, 0);
+                                     MAP_ANON, 0, 0);
       assert_backtrace (modified_global_blocks != (void *) -1);
     }
   else
@@ -65,7 +65,7 @@ get_hypermetadata (void)
     munmap (sblock, SBLOCK_SIZE);
 
   err = store_read (store, SBLOCK_OFFS >> store->log2_block_size,
-                   SBLOCK_SIZE, (void **)&sblock, &read);
+                    SBLOCK_SIZE, (void **)&sblock, &read);
   if (err || read != SBLOCK_SIZE)
     ext2_panic ("Cannot read hypermetadata");
 
@@ -75,19 +75,19 @@ get_hypermetadata (void)
 #endif
       )
     ext2_panic ("bad magic number %#x (should be %#x)",
-               sblock->s_magic, EXT2_SUPER_MAGIC);
+                sblock->s_magic, EXT2_SUPER_MAGIC);
 
   log2_block_size = EXT2_MIN_BLOCK_LOG_SIZE + sblock->s_log_block_size;
   block_size = 1 << log2_block_size;
 
   if (block_size > EXT2_MAX_BLOCK_SIZE)
     ext2_panic ("block size %d is too big (max is %d bytes)",
-               block_size, EXT2_MAX_BLOCK_SIZE);
+                block_size, EXT2_MAX_BLOCK_SIZE);
 
   if (log2_block_size < store->log2_block_size)
     ext2_panic ("block size %d isn't a power-of-two multiple of the device"
-               " block size (%zd)!",
-               block_size, store->block_size);
+                " block size (%zd)!",
+                block_size, store->block_size);
   log2_dev_blocks_per_fs_block = log2_block_size - store->log2_block_size;
 
   log2_stat_blocks_per_fs_block = 0;
@@ -95,18 +95,18 @@ get_hypermetadata (void)
     log2_stat_blocks_per_fs_block++;
   if ((512 << log2_stat_blocks_per_fs_block) != block_size)
     ext2_panic ("block size %d isn't a power-of-two multiple of 512!",
-               block_size);
+                block_size);
 
   if ((store->size >> log2_block_size) < sblock->s_blocks_count)
     ext2_panic ("disk size (%qd bytes) too small; superblock says we need %qd",
-               (long long int) store->size,
-               (long long int) sblock->s_blocks_count << log2_block_size);
+               (long long int) store->size,
+               (long long int) sblock->s_blocks_count << log2_block_size);
   if (log2_dev_blocks_per_fs_block != 0
       && (store->size & ((1 << log2_dev_blocks_per_fs_block) - 1)) != 0)
     ext2_warning ("%Ld (%zd byte) device blocks "
-                 " unused after last filesystem (%d byte) block",
-                 (store->size & ((1 << log2_dev_blocks_per_fs_block) - 1)),
-                 store->block_size, block_size);
+                  " unused after last filesystem (%d byte) block",
+                  (store->size & ((1 << log2_dev_blocks_per_fs_block) - 1)),
+                  store->block_size, block_size);
 
   /* Set these handy variables.  */
   inodes_per_block = block_size / EXT2_INODE_SIZE (sblock);
@@ -120,18 +120,18 @@ get_hypermetadata (void)
   if (sblock->s_rev_level > EXT2_GOOD_OLD_REV)
     {
       if (sblock->s_feature_incompat & ~EXT2_FEATURE_INCOMPAT_SUPP)
-       ext2_panic ("could not mount because of unsupported optional features"
-                   " (0x%x)",
-                   sblock->s_feature_incompat & ~EXT2_FEATURE_INCOMPAT_SUPP);
+        ext2_panic ("could not mount because of unsupported optional features"
+                    " (0x%x)",
+                    sblock->s_feature_incompat & ~EXT2_FEATURE_INCOMPAT_SUPP);
       if (sblock->s_feature_ro_compat & ~EXT2_FEATURE_RO_COMPAT_SUPP)
-       {
-         ext2_warning ("mounted readonly because of"
-                       " unsupported optional features (0x%x)",
-                       sblock->s_feature_ro_compat & 
~EXT2_FEATURE_RO_COMPAT_SUPP);
-         diskfs_readonly = 1;
-       }
+      {
+        ext2_warning ("mounted readonly because of"
+                      " unsupported optional features (0x%x)",
+                      sblock->s_feature_ro_compat & 
~EXT2_FEATURE_RO_COMPAT_SUPP);
+        diskfs_readonly = 1;
+      }
       if (sblock->s_inode_size != EXT2_GOOD_OLD_INODE_SIZE)
-       ext2_panic ("inode size %d isn't supported", sblock->s_inode_size);
+        ext2_panic ("inode size %d isn't supported", sblock->s_inode_size);
     }
 
   groups_count =
@@ -149,10 +149,10 @@ get_hypermetadata (void)
     {
       ext2_warning ("FILESYSTEM NOT UNMOUNTED CLEANLY; PLEASE fsck");
       if (! diskfs_readonly)
-       {
-         diskfs_readonly = 1;
-         ext2_warning ("MOUNTED READ-ONLY; MUST USE `fsysopts --writable'");
-       }
+        {
+          diskfs_readonly = 1;
+          ext2_warning ("MOUNTED READ-ONLY; MUST USE `fsysopts --writable'");
+        }
     }
 
   allocate_mod_map ();
@@ -195,7 +195,7 @@ diskfs_set_hypermetadata (int wait, int clean)
       wait = 1;
     }
 
- if (sblock_dirty)
+  if (sblock_dirty)
    {
      sblock_dirty = 0;
      memcpy (mapped_sblock, sblock, SBLOCK_SIZE);
@@ -217,7 +217,7 @@ diskfs_readonly_changed (int readonly)
   (*(readonly ? store_set_flags : store_clear_flags)) (store, STORE_READONLY);
 
   mprotect (disk_cache, disk_cache_size,
-           PROT_READ | (readonly ? 0 : PROT_WRITE));
+            PROT_READ | (readonly ? 0 : PROT_WRITE));
 
   if (!readonly && !(sblock->s_state & EXT2_VALID_FS))
     ext2_warning ("UNCLEANED FILESYSTEM NOW WRITABLE");
diff --git a/ext2fs/ialloc.c b/ext2fs/ialloc.c
index 49122319..46821a1f 100644
--- a/ext2fs/ialloc.c
+++ b/ext2fs/ialloc.c
@@ -88,7 +88,7 @@ diskfs_free_node (struct node *np, mode_t old_mode)
 
       gdp->bg_free_inodes_count++;
       if (S_ISDIR (old_mode))
-       gdp->bg_used_dirs_count--;
+        gdp->bg_used_dirs_count--;
       disk_cache_block_ref_ptr (gdp);
       record_global_poke (gdp);
 
@@ -136,35 +136,35 @@ repeat:
 /* I am not yet convinced that this next bit is necessary.
       i = inode_group_num(dir_inum);
       for (j = 0; j < groups_count; j++)
-       {
-         tmp = group_desc (i);
-         if ((tmp->bg_used_dirs_count << 8) < tmp->bg_free_inodes_count)
-           {
-             gdp = tmp;
-             break;
-           }
-         else
-           i = ++i % groups_count;
-       }
+        {
+          tmp = group_desc (i);
+          if ((tmp->bg_used_dirs_count << 8) < tmp->bg_free_inodes_count)
+            {
+              gdp = tmp;
+              break;
+            }
+          else
+            i = ++i % groups_count;
+        }
  */
 
       if (!gdp)
-       {
-         for (j = 0; j < groups_count; j++)
-           {
-             tmp = group_desc (j);
-             if (tmp->bg_free_inodes_count
-                 && tmp->bg_free_inodes_count >= avefreei)
-               {
-                 if (!gdp ||
-                     (tmp->bg_free_blocks_count > gdp->bg_free_blocks_count))
-                   {
-                     i = j;
-                     gdp = tmp;
-                   }
-               }
-           }
-       }
+        {
+          for (j = 0; j < groups_count; j++)
+            {
+              tmp = group_desc (j);
+              if (tmp->bg_free_inodes_count
+                  && tmp->bg_free_inodes_count >= avefreei)
+                {
+                  if (!gdp ||
+                      (tmp->bg_free_blocks_count > gdp->bg_free_blocks_count))
+                  {
+                    i = j;
+                    gdp = tmp;
+                  }
+                }
+            }
+        }
     }
   else
     {
@@ -174,44 +174,44 @@ repeat:
       i = inode_group_num(dir_inum);
       tmp = group_desc (i);
       if (tmp->bg_free_inodes_count)
-       gdp = tmp;
+        gdp = tmp;
       else
-       {
-         /*
-          * Use a quadratic hash to find a group with a
-          * free inode
-          */
-         for (j = 1; j < groups_count; j <<= 1)
-           {
-             i += j;
-             if (i >= groups_count)
-               i -= groups_count;
-             tmp = group_desc (i);
-             if (tmp->bg_free_inodes_count)
-               {
-                 gdp = tmp;
-                 break;
-               }
-           }
-       }
+        {
+          /*
+           * Use a quadratic hash to find a group with a
+           * free inode
+           */
+          for (j = 1; j < groups_count; j <<= 1)
+          {
+            i += j;
+            if (i >= groups_count)
+              i -= groups_count;
+            tmp = group_desc (i);
+            if (tmp->bg_free_inodes_count)
+              {
+                gdp = tmp;
+                break;
+              }
+          }
+        }
       if (!gdp)
-       {
-         /*
-          * That failed: try linear search for a free inode
-          */
-         i = inode_group_num(dir_inum) + 1;
-         for (j = 2; j < groups_count; j++)
-           {
-             if (++i >= groups_count)
-               i = 0;
-             tmp = group_desc (i);
-             if (tmp->bg_free_inodes_count)
-               {
-                 gdp = tmp;
-                 break;
-               }
-           }
-       }
+        {
+          /*
+           * That failed: try linear search for a free inode
+           */
+          i = inode_group_num(dir_inum) + 1;
+          for (j = 2; j < groups_count; j++)
+            {
+              if (++i >= groups_count)
+                i = 0;
+              tmp = group_desc (i);
+              if (tmp->bg_free_inodes_count)
+                {
+                  gdp = tmp;
+                  break;
+                }
+            }
+        }
     }
 
   if (!gdp)
@@ -226,12 +226,12 @@ repeat:
       < sblock->s_inodes_per_group)
     {
       if (set_bit (inum, bh))
-       {
-         ext2_warning ("bit already set for inode %llu", inum);
-         disk_cache_block_deref (bh);
-         bh = NULL;
-         goto repeat;
-       }
+        {
+          ext2_warning ("bit already set for inode %llu", inum);
+          disk_cache_block_deref (bh);
+          bh = NULL;
+          goto repeat;
+        }
       record_global_poke (bh);
       bh = NULL;
     }
@@ -240,11 +240,11 @@ repeat:
       disk_cache_block_deref (bh);
       bh = NULL;
       if (gdp->bg_free_inodes_count != 0)
-       {
-         ext2_error ("free inodes count corrupted in group %d", i);
-         inum = 0;
-         goto sync_out;
-       }
+        {
+          ext2_error ("free inodes count corrupted in group %d", i);
+          inum = 0;
+          goto sync_out;
+        }
       goto repeat;
     }
 
@@ -252,7 +252,7 @@ repeat:
   if (inum < EXT2_FIRST_INO (sblock) || inum > sblock->s_inodes_count)
     {
       ext2_error ("reserved inode or inode > inodes count - "
-                 "block_group = %d,inode=%llu", i, inum);
+                  "block_group = %d,inode=%llu", i, inum);
       inum = 0;
       goto sync_out;
     }
@@ -321,8 +321,8 @@ diskfs_alloc_node (struct node *dir, mode_t mode, struct 
node **node)
   for (block = 0; block < EXT2_N_BLOCKS; block++)
     if (diskfs_node_disknode (np)->info.i_data[block] != 0)
       {
-       diskfs_node_disknode (np)->info.i_data[block] = 0;
-       np->dn_set_ctime = 1;
+        diskfs_node_disknode (np)->info.i_data[block] = 0;
+        np->dn_set_ctime = 1;
       }
 
   if (diskfs_node_disknode (np)->info_i_translator != 0)
@@ -342,7 +342,7 @@ diskfs_alloc_node (struct node *dir, mode_t mode, struct 
node **node)
   /* Propagate initial inode flags from the directory, as Linux does.  */
   diskfs_node_disknode (np)->info.i_flags =
     ext2_mask_flags(mode,
-              diskfs_node_disknode (dir)->info.i_flags & EXT2_FL_INHERITED);
+                    diskfs_node_disknode (dir)->info.i_flags & 
EXT2_FL_INHERITED);
 
   st->st_flags = 0;
 
@@ -386,11 +386,11 @@ ext2_count_free_inodes ()
       x = count_free (bh, sblock->s_inodes_per_group / 8);
       disk_cache_block_deref (bh);
       ext2_debug ("group %d: stored = %d, counted = %lu",
-                 i, gdp->bg_free_inodes_count, x);
+                  i, gdp->bg_free_inodes_count, x);
       bitmap_count += x;
     }
   ext2_debug ("stored = %u, computed = %lu, %lu",
-             sblock->s_free_inodes_count, desc_count, bitmap_count);
+              sblock->s_free_inodes_count, desc_count, bitmap_count);
   pthread_spin_unlock (&global_lock);
   return desc_count;
 #else
@@ -421,15 +421,15 @@ ext2_check_inodes_bitmap ()
       x = count_free (bh, sblock->s_inodes_per_group / 8);
       disk_cache_block_deref (bh);
       if (gdp->bg_free_inodes_count != x)
-       ext2_error ("wrong free inodes count in group %d, "
-                   "stored = %d, counted = %lu",
-                   i, gdp->bg_free_inodes_count, x);
+        ext2_error ("wrong free inodes count in group %d, "
+                    "stored = %d, counted = %lu",
+                    i, gdp->bg_free_inodes_count, x);
       bitmap_count += x;
     }
   if (sblock->s_free_inodes_count != bitmap_count)
     ext2_error ("wrong free inodes count in super block, "
-               "stored = %lu, counted = %lu",
-               (unsigned long) sblock->s_free_inodes_count, bitmap_count);
+                "stored = %lu, counted = %lu",
+                (unsigned long) sblock->s_free_inodes_count, bitmap_count);
 
   pthread_spin_unlock (&global_lock);
 }
diff --git a/ext2fs/inode.c b/ext2fs/inode.c
index 3bfbdfdb..fe1af528 100644
--- a/ext2fs/inode.c
+++ b/ext2fs/inode.c
@@ -169,21 +169,21 @@ diskfs_user_read_node (struct node *np, struct 
lookup_context *ctx)
       st->st_mode &= ~S_ITRANS;
 
       if (di->i_translator)
-       st->st_mode |= S_IPTRANS;
+        st->st_mode |= S_IPTRANS;
       else
-       {
-         size_t datalen = 0;
-         err = ext2_get_xattr (np, "gnu.translator", NULL, &datalen);
-         if (! err && datalen > 0)
-           st->st_mode |= S_IPTRANS;
-       }
+        {
+          size_t datalen = 0;
+          err = ext2_get_xattr (np, "gnu.translator", NULL, &datalen);
+          if (! err && datalen > 0)
+            st->st_mode |= S_IPTRANS;
+        }
 
       st->st_uid = di->i_uid | (di->i_uid_high << 16);
       st->st_gid = di->i_gid | (di->i_gid_high << 16);
 
       st->st_author = di->i_author;
       if (st->st_author == -1)
-       st->st_author = st->st_uid;
+        st->st_author = st->st_uid;
     }
   else
     {
@@ -208,18 +208,18 @@ diskfs_user_read_node (struct node *np, struct 
lookup_context *ctx)
     {
       info->i_dir_acl = 0;
       if (sizeof (off_t) >= 8)
-       /* 64bit file size */
-       st->st_size += ((off_t) di->i_size_high) << 32;
+        /* 64bit file size */
+        st->st_size += ((off_t) di->i_size_high) << 32;
       else
-       {
-         if (di->i_size_high)  /* XXX */
-           {
-             dino_deref (di);
-             ext2_warning ("cannot handle large file inode %Ld", np->cache_id);
-             diskfs_end_catch_exception ();
-             return EFBIG;
-           }
-       }
+        {
+          if (di->i_size_high) /* XXX */
+            {
+              dino_deref (di);
+              ext2_warning ("cannot handle large file inode %Ld", 
np->cache_id);
+              diskfs_end_catch_exception ();
+              return EFBIG;
+            }
+        }
     }
   info->i_block_group = inode_group_num (np->cache_id);
   info->i_next_alloc_block = 0;
@@ -234,7 +234,7 @@ diskfs_user_read_node (struct node *np, struct 
lookup_context *ctx)
   else
     {
       memcpy (info->i_data, di->i_block,
-             EXT2_N_BLOCKS * sizeof info->i_data[0]);
+              EXT2_N_BLOCKS * sizeof info->i_data[0]);
       st->st_rdev = 0;
     }
   dn->info_i_translator = di->i_translator;
@@ -252,7 +252,7 @@ diskfs_user_read_node (struct node *np, struct 
lookup_context *ctx)
       /* Round up to a block multiple.  */
       offset = np->allocsize & ((1 << log2_block_size) - 1);
       if (offset > 0)
-       np->allocsize += block_size - offset;
+        np->allocsize += block_size - offset;
     }
   else
     /* Allocsize should be zero for anything except directories, files, and
@@ -266,7 +266,7 @@ diskfs_user_read_node (struct node *np, struct 
lookup_context *ctx)
     {
       pthread_spin_lock (&generation_lock);
       if (++next_generation < diskfs_mtime->seconds)
-       next_generation = diskfs_mtime->seconds;
+        next_generation = diskfs_mtime->seconds;
       np->dn_stat.st_gen = next_generation;
       pthread_spin_unlock (&generation_lock);
       np->dn_set_ctime = 1;
@@ -368,38 +368,38 @@ write_node (struct node *np)
 
       err = diskfs_catch_exception ();
       if (err)
-       return NULL;
+        return NULL;
 
       di = dino_ref (np->cache_id);
 
       di->i_generation = st->st_gen;
 
       /* We happen to know that the stat mode bits are the same
-        as the ext2fs mode bits. */
+         as the ext2fs mode bits. */
       /* XXX? */
 
       /* Only the low 16 bits of these fields are standard across all ext2
-        implementations.  */
+         implementations.  */
       di->i_mode = st->st_mode & 0xFFFF & ~S_ITRANS;
       di->i_uid = st->st_uid & 0xFFFF;
       di->i_gid = st->st_gid & 0xFFFF;
 
       if (sblock->s_creator_os == EXT2_OS_HURD)
-       /* If this is a hurd-compatible filesystem, write the high bits too. */
-       {
-         di->i_mode_high = (st->st_mode >> 16) & 0xffff & ~S_ITRANS;
-         di->i_uid_high = st->st_uid >> 16;
-         di->i_gid_high = st->st_gid >> 16;
-         di->i_author = st->st_author;
-       }
+        /* If this is a hurd-compatible filesystem, write the high bits too. */
+        {
+          di->i_mode_high = (st->st_mode >> 16) & 0xffff & ~S_ITRANS;
+          di->i_uid_high = st->st_uid >> 16;
+          di->i_gid_high = st->st_gid >> 16;
+          di->i_author = st->st_author;
+        }
       else
-       /* No hurd extensions should be turned on.  */
-       {
-         assert_backtrace ((st->st_uid & ~0xFFFF) == 0);
-         assert_backtrace ((st->st_gid & ~0xFFFF) == 0);
-         assert_backtrace ((st->st_mode & ~0xFFFF) == 0);
-         assert_backtrace (np->author_tracks_uid && st->st_author == 
st->st_uid);
-       }
+        /* No hurd extensions should be turned on.  */
+        {
+          assert_backtrace ((st->st_uid & ~0xFFFF) == 0);
+          assert_backtrace ((st->st_gid & ~0xFFFF) == 0);
+          assert_backtrace ((st->st_mode & ~0xFFFF) == 0);
+          assert_backtrace (np->author_tracks_uid && st->st_author == 
st->st_uid);
+        }
 
       di->i_links_count = st->st_nlink;
 
@@ -419,38 +419,38 @@ write_node (struct node *np)
 
       /* Convert generic flags in ST->st_flags to ext2-specific flags in DI
          (but don't mess with ext2 flags we don't know about).  The original
-        set was copied from DI into INFO by read_node, but might have been
-        modified for ext2fs-specific reasons; so we use INFO->i_flags
-        to start with, and then apply the flags in ST->st_flags.  */
+         set was copied from DI into INFO by read_node, but might have been
+         modified for ext2fs-specific reasons; so we use INFO->i_flags
+         to start with, and then apply the flags in ST->st_flags.  */
       info->i_flags &= ~(EXT2_APPEND_FL | EXT2_NODUMP_FL | EXT2_IMMUTABLE_FL);
       if (st->st_flags & UF_APPEND)
-       info->i_flags |= EXT2_APPEND_FL;
+        info->i_flags |= EXT2_APPEND_FL;
       if (st->st_flags & UF_NODUMP)
-       info->i_flags |= EXT2_NODUMP_FL;
+        info->i_flags |= EXT2_NODUMP_FL;
       if (st->st_flags & UF_IMMUTABLE)
-       info->i_flags |= EXT2_IMMUTABLE_FL;
+        info->i_flags |= EXT2_IMMUTABLE_FL;
       di->i_flags = info->i_flags;
 
       if (st->st_mode == 0)
-       /* Set dtime non-zero to indicate a deleted file.
-          We don't clear i_size, i_blocks, and i_translator in this case,
-          to give "undeletion" utilities a chance.  */
-       di->i_dtime = di->i_mtime;
+        /* Set dtime non-zero to indicate a deleted file.
+           We don't clear i_size, i_blocks, and i_translator in this case,
+           to give "undeletion" utilities a chance.  */
+        di->i_dtime = di->i_mtime;
       else
-       {
-         di->i_dtime = 0;
-         di->i_size = st->st_size;
-         if (sizeof (off_t) >= 8 && !S_ISDIR (st->st_mode))
-           /* 64bit file size */
-           di->i_size_high = st->st_size >> 32;
-         di->i_blocks = st->st_blocks;
-       }
+        {
+          di->i_dtime = 0;
+          di->i_size = st->st_size;
+          if (sizeof (off_t) >= 8 && !S_ISDIR (st->st_mode))
+            /* 64bit file size */
+            di->i_size_high = st->st_size >> 32;
+          di->i_blocks = st->st_blocks;
+        }
 
       if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
-       di->i_block[0] = st->st_rdev;
+        di->i_block[0] = st->st_rdev;
       else
-       memcpy (di->i_block, diskfs_node_disknode (np)->info.i_data,
-               EXT2_N_BLOCKS * sizeof di->i_block[0]);
+        memcpy (di->i_block, diskfs_node_disknode (np)->info.i_data,
+                EXT2_N_BLOCKS * sizeof di->i_block[0]);
 
       diskfs_end_catch_exception ();
       np->dn_stat_dirty = 0;
@@ -490,7 +490,7 @@ write_all_disknodes ()
       struct ext2_inode *di;
 
       /* Sync the indirect blocks here; they'll all be done before any
-        inodes.  Waiting for them shouldn't be too bad.  */
+         inodes.  Waiting for them shouldn't be too bad.  */
       pokel_sync (&diskfs_node_disknode (node)->indir_pokel, 1);
 
       diskfs_set_node_times (node);
@@ -498,7 +498,7 @@ write_all_disknodes ()
       /* Update the inode image.  */
       di = write_node (node);
       if (di)
-       record_global_poke (di);
+        record_global_poke (di);
 
       return 0;
     }
@@ -516,9 +516,9 @@ diskfs_write_disknode (struct node *np, int wait)
   if (di)
     {
       if (wait)
-       sync_global_ptr (di, 1);
+        sync_global_ptr (di, 1);
       else
-       record_global_poke (di);
+        record_global_poke (di);
     }
 }
 
@@ -547,7 +547,7 @@ diskfs_set_statfs (struct statfs *st)
    library; see <hurd/diskfs.h> for the interface description. */
 error_t
 diskfs_set_translator (struct node *np, const char *name, unsigned namelen,
-                      struct protid *cred)
+                       struct protid *cred)
 {
   error_t err;
 
@@ -573,49 +573,49 @@ diskfs_set_translator (struct node *np, const char *name, 
unsigned namelen,
 
       /* If a legacy translator record found, clear it */
       if (blkno)
-       {
-         ext2_debug ("Old translator record found, clear it");
-
-         /* Clear block for translator going away. */
-         di->i_translator = 0;
-         diskfs_node_disknode (np)->info_i_translator = 0;
-         record_global_poke (di);
-         ext2_free_blocks (blkno, 1);
-
-         np->dn_stat.st_blocks -= 1 << log2_stat_blocks_per_fs_block;
-         np->dn_stat.st_mode &= ~S_IPTRANS;
-         np->dn_set_ctime = 1;
-       }
+        {
+          ext2_debug ("Old translator record found, clear it");
+
+          /* Clear block for translator going away. */
+          di->i_translator = 0;
+          diskfs_node_disknode (np)->info_i_translator = 0;
+          record_global_poke (di);
+          ext2_free_blocks (blkno, 1);
+
+          np->dn_stat.st_blocks -= 1 << log2_stat_blocks_per_fs_block;
+          np->dn_stat.st_mode &= ~S_IPTRANS;
+          np->dn_set_ctime = 1;
+        }
       else
-       dino_deref (di);
+        dino_deref (di);
 
       /* Use xattr to store translator record, with key "gnu.translator" */
       if (namelen)
-       {
-         err = ext2_set_xattr (np, "gnu.translator", name, namelen, 0);
-
-         if (!err)
-           {
-             np->dn_stat.st_mode |= S_IPTRANS;
-             np->dn_set_ctime = 1;
-           }
-       }
+        {
+          err = ext2_set_xattr (np, "gnu.translator", name, namelen, 0);
+
+          if (!err)
+            {
+              np->dn_stat.st_mode |= S_IPTRANS;
+              np->dn_set_ctime = 1;
+            }
+        }
       else
-       {
-         /* Removing the translator.  */
-         err = ext2_set_xattr (np, "gnu.translator", NULL, 0, 0);
-
-         if (err == ENODATA)
-           /* Happens if the key did not exist in the first place.  */
-           err = 0;
-
-         if (!err)
-           {
-             /* Do not use hurd extensions on non-hurd created filesystem */
-             np->dn_stat.st_mode &= ~S_IPTRANS;
-             np->dn_set_ctime = 1;
-           }
-       }
+        {
+          /* Removing the translator.  */
+          err = ext2_set_xattr (np, "gnu.translator", NULL, 0, 0);
+
+          if (err == ENODATA)
+            /* Happens if the key did not exist in the first place.  */
+            err = 0;
+
+          if (!err)
+            {
+              /* Do not use hurd extensions on non-hurd created filesystem */
+              np->dn_stat.st_mode &= ~S_IPTRANS;
+              np->dn_set_ctime = 1;
+            }
+        }
     }
   else
     {
@@ -625,82 +625,82 @@ diskfs_set_translator (struct node *np, const char *name, 
unsigned namelen,
       char buf[block_size];
 
       if (namelen + 2 > block_size)
-       return ENAMETOOLONG;
+        return ENAMETOOLONG;
 
       di = dino_ref (np->cache_id);
       blkno = di->i_translator;
 
       if (namelen && !blkno)
-       {
-         mode_t newmode = 0;
-
-         if (S_ISLNK (np->dn_stat.st_mode))
-           {
-             /* Avoid storing both a symlink and a translator,
-              * e2fsck does not like it.  */
-             newmode = (np->dn_stat.st_mode & ~S_IFMT) | S_IFREG;
-             err = diskfs_validate_mode_change (np, newmode);
-             if (err)
-               return err;
-           }
-
-         /* Allocate block for translator */
-         blkno =
-           ext2_new_block ((diskfs_node_disknode (np)->info.i_block_group
-                           * EXT2_BLOCKS_PER_GROUP (sblock))
-                           + sblock->s_first_data_block,
-                           0, 0, 0);
-         if (blkno == 0)
-           {
-             dino_deref (di);
-             diskfs_end_catch_exception ();
-             return ENOSPC;
-           }
-
-         if (newmode)
-           {
-             /* Clear previous data */
-             diskfs_truncate (np, 0);
-             np->dn_stat.st_mode = newmode;
-           }
-
-         di->i_translator = blkno;
-         diskfs_node_disknode (np)->info_i_translator = blkno;
-         record_global_poke (di);
-
-         np->dn_stat.st_blocks += 1 << log2_stat_blocks_per_fs_block;
-         np->dn_set_ctime = 1;
-       }
+        {
+          mode_t newmode = 0;
+
+          if (S_ISLNK (np->dn_stat.st_mode))
+            {
+              /* Avoid storing both a symlink and a translator,
+               * e2fsck does not like it.  */
+              newmode = (np->dn_stat.st_mode & ~S_IFMT) | S_IFREG;
+              err = diskfs_validate_mode_change (np, newmode);
+              if (err)
+                return err;
+            }
+
+          /* Allocate block for translator */
+          blkno =
+            ext2_new_block ((diskfs_node_disknode (np)->info.i_block_group
+                            * EXT2_BLOCKS_PER_GROUP (sblock))
+                            + sblock->s_first_data_block,
+                            0, 0, 0);
+          if (blkno == 0)
+            {
+              dino_deref (di);
+              diskfs_end_catch_exception ();
+              return ENOSPC;
+            }
+
+          if (newmode)
+            {
+              /* Clear previous data */
+              diskfs_truncate (np, 0);
+              np->dn_stat.st_mode = newmode;
+            }
+
+          di->i_translator = blkno;
+          diskfs_node_disknode (np)->info_i_translator = blkno;
+          record_global_poke (di);
+
+          np->dn_stat.st_blocks += 1 << log2_stat_blocks_per_fs_block;
+          np->dn_set_ctime = 1;
+        }
       else if (!namelen && blkno)
-       {
-         /* Clear block for translator going away. */
-         di->i_translator = 0;
-         diskfs_node_disknode (np)->info_i_translator = 0;
-         record_global_poke (di);
-         ext2_free_blocks (blkno, 1);
-
-         np->dn_stat.st_blocks -= 1 << log2_stat_blocks_per_fs_block;
-         np->dn_stat.st_mode &= ~S_IPTRANS;
-         np->dn_set_ctime = 1;
-       }
+        {
+          /* Clear block for translator going away. */
+          di->i_translator = 0;
+          diskfs_node_disknode (np)->info_i_translator = 0;
+          record_global_poke (di);
+          ext2_free_blocks (blkno, 1);
+
+          np->dn_stat.st_blocks -= 1 << log2_stat_blocks_per_fs_block;
+          np->dn_stat.st_mode &= ~S_IPTRANS;
+          np->dn_set_ctime = 1;
+        }
       else
-       dino_deref (di);
+        dino_deref (di);
 
       if (namelen)
-       {
-         void *blkptr;
+        {
+          void *blkptr;
 
-         buf[0] = namelen & 0xFF;
-         buf[1] = (namelen >> 8) & 0xFF;
-         memcpy (buf + 2, name, namelen);
+          buf[0] = namelen & 0xFF;
+          buf[1] = (namelen >> 8) & 0xFF;
+          memcpy (buf + 2, name, namelen);
 
-         blkptr = disk_cache_block_ref (blkno);
-         memcpy (blkptr, buf, block_size);
-         record_global_poke (blkptr);
+          blkptr = disk_cache_block_ref (blkno);
+          memcpy (blkptr, buf, block_size);
+          record_global_poke (blkptr);
 
-         np->dn_stat.st_mode |= S_IPTRANS;
-         np->dn_set_ctime = 1;
-       }
+          np->dn_stat.st_mode |= S_IPTRANS;
+          np->dn_set_ctime = 1;
+        }
     }
 
   diskfs_end_catch_exception ();
@@ -735,22 +735,22 @@ diskfs_get_translator (struct node *np, char **namep, 
unsigned *namelen)
     {
       /* If xattr is no supported by this filesystem, don't report a warning */
       if (EXT2_HAS_COMPAT_FEATURE (sblock, EXT2_FEATURE_COMPAT_EXT_ATTR)
-         && use_xattr_translator_records)
-       ext2_debug ("This is an old translator record, please update it");
+          && use_xattr_translator_records)
+        ext2_debug ("This is an old translator record, please update it");
 
       transloc = disk_cache_block_ref (blkno);
       datalen =
-       ((unsigned char *)transloc)[0] + (((unsigned char *)transloc)[1] << 8);
+        ((unsigned char *)transloc)[0] + (((unsigned char *)transloc)[1] << 8);
       if (datalen > block_size - 2)
-       err = EFTYPE;  /* ? */
+        err = EFTYPE;  /* ? */
       else
-       {
-         *namep = malloc (datalen);
-         if (!*namep)
-           err = ENOMEM;
-         else
-           memcpy (*namep, transloc + 2, datalen);
-       }
+        {
+          *namep = malloc (datalen);
+          if (!*namep)
+            err = ENOMEM;
+          else
+            memcpy (*namep, transloc + 2, datalen);
+        }
 
       disk_cache_block_deref (transloc);
       diskfs_end_catch_exception ();
diff --git a/ext2fs/msg.c b/ext2fs/msg.c
index 83939b06..6b8a50ff 100644
--- a/ext2fs/msg.c
+++ b/ext2fs/msg.c
@@ -66,7 +66,7 @@ void _ext2_panic (const char * function, const char * fmt, 
...)
   va_end (args);
 
   fprintf(stderr, "ext2fs: %s: panic: %s: %s\n",
-         diskfs_disk_name, function, error_buf);
+          diskfs_disk_name, function, error_buf);
 
   pthread_mutex_unlock (&printf_lock);
 
diff --git a/ext2fs/pager.c b/ext2fs/pager.c
index a47c53ce..acb7f8b1 100644
--- a/ext2fs/pager.c
+++ b/ext2fs/pager.c
@@ -100,24 +100,24 @@ get_page_buf ()
       buf = free_page_bufs;
       num_free_page_bufs --;
       if (num_free_page_bufs > 0)
-       free_page_bufs += vm_page_size;
+        free_page_bufs += vm_page_size;
 #ifndef NDEBUG
       else
-       free_page_bufs = 0;
+        free_page_bufs = 0;
 #endif /* ! NDEBUG */
     }
   else
     {
       assert_backtrace (free_page_bufs == 0);
       buf = mmap (0, vm_page_size * FREE_PAGE_BUFS,
-                 PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
+                  PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
       if (buf == MAP_FAILED)
-       buf = 0;
+        buf = 0;
       else
-       {
-         free_page_bufs = buf + vm_page_size;
-         num_free_page_bufs = FREE_PAGE_BUFS - 1;
-       }
+        {
+          free_page_bufs = buf + vm_page_size;
+          num_free_page_bufs = FREE_PAGE_BUFS - 1;
+        }
     }
 
   pthread_mutex_unlock (&free_page_bufs_lock);
@@ -138,7 +138,7 @@ free_page_buf (void *buf)
    on success otherwise an error code.  */
 static error_t
 find_block (struct node *node, vm_offset_t offset,
-           block_t *block, pthread_rwlock_t **lock)
+            block_t *block, pthread_rwlock_t **lock)
 {
   error_t err;
 
@@ -167,7 +167,7 @@ find_block (struct node *node, vm_offset_t offset,
    to consolidate the i/o if possible.  */
 static error_t
 file_pager_read_page (struct node *node, vm_offset_t page,
-                     void **buf, int *writelock)
+                      void **buf, int *writelock)
 {
   error_t err;
   int offs = 0;
@@ -178,7 +178,7 @@ file_pager_read_page (struct node *node, vm_offset_t page,
   int num_pending_blocks = 0;
 
   ext2_debug ("reading inode %llu page %lu[%u]",
-             node->cache_id, page, vm_page_size);
+              node->cache_id, page, vm_page_size);
 
   /* Read the NUM_PENDING_BLOCKS blocks in PENDING_BLOCKS, into the buffer
      pointed to by BUF (allocating it if necessary) at offset OFFS.  OFFS in
@@ -187,44 +187,44 @@ file_pager_read_page (struct node *node, vm_offset_t page,
   error_t do_pending_reads ()
     {
       if (num_pending_blocks > 0)
-       {
-         store_offset_t dev_block = (store_offset_t) pending_blocks
-           << log2_dev_blocks_per_fs_block;
-         size_t amount = num_pending_blocks << log2_block_size;
-         /* The buffer we try to read into; on the first read, we pass in a
-            size of zero, so that the read is guaranteed to allocate a new
-            buffer, otherwise, we try to read directly into the tail of the
-            buffer we've already got.  */
-         void *new_buf = *buf + offs;
-         size_t new_len = offs == 0 ? 0 : vm_page_size - offs;
-
-         STAT_INC (file_pagein_reads);
-
-         err = store_read (store, dev_block, amount, &new_buf, &new_len);
-         if (err)
-           return err;
-         else if (amount != new_len)
-           return EIO;
-
-         if (new_buf != *buf + offs)
-           {
-             /* The read went into a different buffer than the one we
+        {
+          store_offset_t dev_block = (store_offset_t) pending_blocks
+            << log2_dev_blocks_per_fs_block;
+          size_t amount = num_pending_blocks << log2_block_size;
+          /* The buffer we try to read into; on the first read, we pass in a
+             size of zero, so that the read is guaranteed to allocate a new
+             buffer, otherwise, we try to read directly into the tail of the
+             buffer we've already got.  */
+          void *new_buf = *buf + offs;
+          size_t new_len = offs == 0 ? 0 : vm_page_size - offs;
+
+          STAT_INC (file_pagein_reads);
+
+          err = store_read (store, dev_block, amount, &new_buf, &new_len);
+          if (err)
+            return err;
+          else if (amount != new_len)
+            return EIO;
+
+          if (new_buf != *buf + offs)
+            {
+              /* The read went into a different buffer than the one we
                  passed. */
-             if (offs == 0)
-               /* First read, make the returned page be our buffer.  */
-               *buf = new_buf;
-             else
-               /* We've already got some buffer, so copy into it.  */
-               {
-                 memcpy (*buf + offs, new_buf, new_len);
-                 free_page_buf (new_buf); /* Return NEW_BUF to our pool.  */
-                 STAT_INC (file_pagein_freed_bufs);
-               }
-           }
-
-         offs += new_len;
-         num_pending_blocks = 0;
-       }
+              if (offs == 0)
+                /* First read, make the returned page be our buffer.  */
+                *buf = new_buf;
+              else
+                /* We've already got some buffer, so copy into it.  */
+                {
+                  memcpy (*buf + offs, new_buf, new_len);
+                  free_page_buf (new_buf); /* Return NEW_BUF to our pool.  */
+                  STAT_INC (file_pagein_freed_bufs);
+                }
+            }
+
+          offs += new_len;
+          num_pending_blocks = 0;
+        }
 
       return 0;
     }
@@ -250,33 +250,33 @@ file_pager_read_page (struct node *node, vm_offset_t page,
 
       err = find_block (node, page, &block, &lock);
       if (err)
-       break;
+        break;
 
       if (block != pending_blocks + num_pending_blocks)
-       {
-         err = do_pending_reads ();
-         if (err)
-           break;
-         pending_blocks = block;
-       }
+        {
+          err = do_pending_reads ();
+          if (err)
+            break;
+          pending_blocks = block;
+        }
 
       if (block == 0)
-       /* Reading unallocated block, just make a zero-filled one.  */
-       {
-         *writelock = 1;
-         if (offs == 0)
-           /* No page allocated to read into yet.  */
-           {
-             *buf = get_page_buf ();
-             if (! *buf)
-               break;
-             STAT_INC (file_pagein_alloced_bufs);
-           }
-         memset (*buf + offs, 0, block_size);
-         offs += block_size;
-       }
+        /* Reading unallocated block, just make a zero-filled one.  */
+        {
+          *writelock = 1;
+          if (offs == 0)
+            /* No page allocated to read into yet.  */
+            {
+              *buf = get_page_buf ();
+              if (! *buf)
+                break;
+              STAT_INC (file_pagein_alloced_bufs);
+            }
+          memset (*buf + offs, 0, block_size);
+          offs += block_size;
+        }
       else
-       num_pending_blocks++;
+        num_pending_blocks++;
 
       page += block_size;
       left -= block_size;
@@ -314,25 +314,25 @@ pending_blocks_write (struct pending_blocks *pb)
     {
       error_t err;
       store_offset_t dev_block = (store_offset_t) pb->block
-       << log2_dev_blocks_per_fs_block;
+        << log2_dev_blocks_per_fs_block;
       size_t length = pb->num << log2_block_size, amount;
 
       ext2_debug ("writing block %u[%ld]", pb->block, pb->num);
 
       if (pb->offs > 0)
-       /* Put what we're going to write into a page-aligned buffer.  */
-       {
-         void *page_buf = get_page_buf ();
-         memcpy ((void *)page_buf, pb->buf + pb->offs, length);
-         err = store_write (store, dev_block, page_buf, length, &amount);
-         free_page_buf (page_buf);
-       }
+        /* Put what we're going to write into a page-aligned buffer.  */
+      {
+        void *page_buf = get_page_buf ();
+        memcpy ((void *)page_buf, pb->buf + pb->offs, length);
+        err = store_write (store, dev_block, page_buf, length, &amount);
+        free_page_buf (page_buf);
+      }
       else
-       err = store_write (store, dev_block, pb->buf, length, &amount);
+        err = store_write (store, dev_block, pb->buf, length, &amount);
       if (err)
-       return err;
+        return err;
       else if (amount != length)
-       return EIO;
+        return EIO;
 
       pb->offs += length;
       pb->num = 0;
@@ -369,7 +369,7 @@ pending_blocks_add (struct pending_blocks *pb, block_t 
block)
     {
       error_t err = pending_blocks_write (pb);
       if (err)
-       return err;
+        return err;
       pb->block = block;
     }
   pb->num++;
@@ -408,7 +408,7 @@ file_pager_write_page (struct node *node, vm_offset_t 
offset, void *buf)
     {
       err = find_block (node, offset, &block, &lock);
       if (err)
-       break;
+        break;
       assert_backtrace (block);
       pending_blocks_add (&pb, block);
       offset += block_size;
@@ -449,7 +449,7 @@ disk_pager_read_page (vm_offset_t page, void **buf, int 
*writelock)
     length = dev_end - offset;
 
   err = store_read (store, offset >> store->log2_block_size, length,
-                   buf, &read);
+                    buf, &read);
   if (read != length)
     return EIO;
   if (!err && length != vm_page_size)
@@ -474,9 +474,9 @@ disk_pager_write_page (vm_offset_t page, void *buf)
     + offset % block_size;
 #ifdef DEBUG_DISK_CACHE                        /* Not strictly needed.  */
   assert_backtrace ((disk_cache_info[index].last_read ^ 
DISK_CACHE_LAST_READ_XOR)
-         == disk_cache_info[index].last_read_xor);
+                    == disk_cache_info[index].last_read_xor);
   assert_backtrace (disk_cache_info[index].last_read
-         == disk_cache_info[index].block);
+                    == disk_cache_info[index].block);
 #endif
   pthread_mutex_unlock (&disk_cache_lock);
 
@@ -495,38 +495,38 @@ disk_pager_write_page (vm_offset_t page, void *buf)
       pending_blocks_init (&pb, buf);
 
       while (length > 0 && !err)
-       {
-         block_t block = boffs_block (offset);
-
-         /* We don't clear the block modified bit here because this paging
-            write request may not be the same one that actually set the bit,
-            and our copy of the page may be out of date; we have to leave
-            the bit on in case a paging write request corresponding to the
-            modification comes along later.  The bit is only actually ever
-            cleared if the block is allocated to a file, so this results in
-            excess writes of blocks from modified pages.  Unfortunately I
-            know of no way to get arount this given the current external
-            paging interface.  XXXX */
-         if (test_bit (block, modified_global_blocks))
-           /* This block may have been modified, so write it out.  */
-           err = pending_blocks_add (&pb, block);
-         else
-           /* Otherwise just skip it.  */
-           err = pending_blocks_skip (&pb);
-
-         offset += block_size;
-         length -= block_size;
-       }
+        {
+          block_t block = boffs_block (offset);
+
+          /* We don't clear the block modified bit here because this paging
+             write request may not be the same one that actually set the bit,
+             and our copy of the page may be out of date; we have to leave
+             the bit on in case a paging write request corresponding to the
+             modification comes along later.  The bit is only actually ever
+             cleared if the block is allocated to a file, so this results in
+             excess writes of blocks from modified pages.  Unfortunately I
+             know of no way to get arount this given the current external
+             paging interface.  XXXX */
+          if (test_bit (block, modified_global_blocks))
+            /* This block may have been modified, so write it out.  */
+            err = pending_blocks_add (&pb, block);
+          else
+            /* Otherwise just skip it.  */
+            err = pending_blocks_skip (&pb);
+
+          offset += block_size;
+          length -= block_size;
+      }
 
       if (!err)
-       err = pending_blocks_write (&pb);
+        err = pending_blocks_write (&pb);
     }
   else
     {
       err = store_write (store, offset >> store->log2_block_size,
-                        buf, length, &amount);
+                         buf, length, &amount);
       if (!err && length != amount)
-       err = EIO;
+        err = EIO;
     }
 
   return err;
@@ -552,7 +552,7 @@ disk_pager_notify_evict (vm_offset_t page)
    the pager should make the page writeable.  */
 error_t
 pager_read_page (struct user_pager_info *pager, vm_offset_t page,
-                vm_address_t *buf, int *writelock)
+                 vm_address_t *buf, int *writelock)
 {
   if (pager->type == DISK)
     return disk_pager_read_page (page, (void **)buf, writelock);
@@ -564,7 +564,7 @@ pager_read_page (struct user_pager_info *pager, vm_offset_t 
page,
    PAGER, from the page at offset PAGE from BUF.  */
 error_t
 pager_write_page (struct user_pager_info *pager, vm_offset_t page,
-                 vm_address_t buf)
+                  vm_address_t buf)
 {
   if (pager->type == DISK)
     return disk_pager_write_page (page, (void *)buf);
@@ -601,38 +601,38 @@ pager_unlock_page (struct user_pager_info *pager, 
vm_offset_t page)
 
       err = diskfs_catch_exception ();
       if (!err)
-       {
-         block_t block = page >> log2_block_size;
-         int left = (partial_page ? node->allocsize - page : vm_page_size);
-
-         while (left > 0)
-           {
-             block_t disk_block;
-             err = ext2_getblk (node, block++, 1, &disk_block);
-             if (err)
-               break;
-             left -= block_size;
-           }
-       }
+        {
+          block_t block = page >> log2_block_size;
+          int left = (partial_page ? node->allocsize - page : vm_page_size);
+
+          while (left > 0)
+            {
+              block_t disk_block;
+              err = ext2_getblk (node, block++, 1, &disk_block);
+              if (err)
+                break;
+              left -= block_size;
+            }
+        }
       diskfs_end_catch_exception ();
 
       if (partial_page)
-       /* If an error occurred, this page still isn't writable; otherwise,
-          since it's at the end of the file, it's now partially writable.  */
-       dn->last_page_partially_writable = !err;
+        /* If an error occurred, this page still isn't writable; otherwise,
+           since it's at the end of the file, it's now partially writable.  */
+        dn->last_page_partially_writable = !err;
       else if (page + vm_page_size == node->allocsize)
-       /* This makes the last page writable, which ends exactly at the end
-          of the file.  If any error occurred, the page still isn't
-          writable, and if not, then the whole thing is writable.  */
-       dn->last_page_partially_writable = 0;
+        /* This makes the last page writable, which ends exactly at the end
+           of the file.  If any error occurred, the page still isn't
+           writable, and if not, then the whole thing is writable.  */
+        dn->last_page_partially_writable = 0;
 
 #ifdef EXT2FS_DEBUG
       if (dn->last_page_partially_writable)
-       ext2_debug ("made page %u[%lu] in inode %d partially writable",
-                   page, node->allocsize - page, node->cache_id);
+        ext2_debug ("made page %u[%lu] in inode %d partially writable",
+                    page, node->allocsize - page, node->cache_id);
       else
-       ext2_debug ("made page %u[%u] in inode %d writable",
-                   page, vm_page_size, node->cache_id);
+        ext2_debug ("made page %u[%u] in inode %d writable",
+                    page, vm_page_size, node->cache_id);
 #endif
 
       STAT_INC (file_page_unlocks);
@@ -640,10 +640,10 @@ pager_unlock_page (struct user_pager_info *pager, 
vm_offset_t page)
       pthread_rwlock_unlock (&dn->alloc_lock);
 
       if (err == ENOSPC)
-       ext2_warning ("This filesystem is out of space.");
+        ext2_warning ("This filesystem is out of space.");
       else if (err)
-       ext2_warning ("inode=%Ld, page=0x%lx: %s",
-                     node->cache_id, page, strerror (err));
+        ext2_warning ("inode=%Ld, page=0x%lx: %s",
+                      node->cache_id, page, strerror (err));
 
       return err;
     }
@@ -674,64 +674,64 @@ diskfs_grow (struct node *node, off_t size, struct protid 
*cred)
       new_size = round_block (size);
 
       /* The first unallocated blocks after the old and new ends of the
-        file, respectively.  */
+         file, respectively.  */
       end_block = old_size >> log2_block_size;
       new_end_block = new_size >> log2_block_size;
 
       if (new_end_block > end_block)
-       {
-         /* The first block of the first unallocate page after the old end
-            of the file.  If LAST_PAGE_PARTIALLY_WRITABLE is true, any
-            blocks between this and END_BLOCK were unallocated, but are
-            considered `unlocked' -- that is pager_unlock_page has been
-            called on the page they're in.  Since after this grow the pager
-            will expect them to be writable, we'd better allocate them.  */
-         block_t old_page_end_block =
-           round_page (old_size) >> log2_block_size;
-
-         ext2_debug ("growing inode %d to %lu bytes (from %lu)", 
node->cache_id,
-                     new_size, old_size);
-
-         if (dn->last_page_partially_writable
-             && old_page_end_block > end_block)
-           {
-             volatile block_t writable_end =
-               (old_page_end_block > new_end_block
-                ? new_end_block
-                : old_page_end_block);
-
-             ext2_debug ("extending writable page %u by %d blocks"
-                         "; first new block = %u",
-                         trunc_page (old_size),
-                         writable_end - end_block,
-                         end_block);
-
-             err = diskfs_catch_exception ();
-             while (!err && end_block < writable_end)
-               {
-                 block_t disk_block;
-                 err = ext2_getblk (node, end_block++, 1, &disk_block);
-               }
-             diskfs_end_catch_exception ();
-
-             if (! err)
-               /* Reflect how much we allocated successfully.  */
-               new_size = end_block << log2_block_size;
-             else
-               /* See if it's still valid to say this.  */
-               dn->last_page_partially_writable =
-                 (old_page_end_block > end_block);
-           }
-       }
+        {
+          /* The first block of the first unallocate page after the old end
+             of the file.  If LAST_PAGE_PARTIALLY_WRITABLE is true, any
+             blocks between this and END_BLOCK were unallocated, but are
+             considered `unlocked' -- that is pager_unlock_page has been
+             called on the page they're in.  Since after this grow the pager
+             will expect them to be writable, we'd better allocate them.  */
+          block_t old_page_end_block =
+            round_page (old_size) >> log2_block_size;
+
+          ext2_debug ("growing inode %d to %lu bytes (from %lu)", 
node->cache_id,
+                      new_size, old_size);
+
+          if (dn->last_page_partially_writable
+              && old_page_end_block > end_block)
+            {
+              volatile block_t writable_end =
+                (old_page_end_block > new_end_block
+                 ? new_end_block
+                 : old_page_end_block);
+
+              ext2_debug ("extending writable page %u by %d blocks"
+                          "; first new block = %u",
+                          trunc_page (old_size),
+                          writable_end - end_block,
+                          end_block);
+
+              err = diskfs_catch_exception ();
+              while (!err && end_block < writable_end)
+                {
+                  block_t disk_block;
+                  err = ext2_getblk (node, end_block++, 1, &disk_block);
+                }
+              diskfs_end_catch_exception ();
+
+              if (! err)
+                /* Reflect how much we allocated successfully.  */
+                new_size = end_block << log2_block_size;
+              else
+                /* See if it's still valid to say this.  */
+                dn->last_page_partially_writable =
+                  (old_page_end_block > end_block);
+            }
+        }
 
       STAT_INC (file_grows);
 
       ext2_debug ("new size: %ld%s.", new_size,
-                 dn->last_page_partially_writable
-                 ? " (last page writable)": "");
+                  dn->last_page_partially_writable
+                  ? " (last page writable)": "");
       if (err)
-       ext2_warning ("inode=%Ld, target=%Ld: %s",
-                     node->cache_id, new_size, strerror (err));
+        ext2_warning ("inode=%Ld, target=%Ld: %s",
+            node->cache_id, new_size, strerror (err));
 
       node->allocsize = new_size;
 
@@ -792,7 +792,7 @@ flush_node_pager (struct node *node)
    accept and the size of the object.  */
 inline error_t
 pager_report_extent (struct user_pager_info *pager,
-                    vm_address_t *offset, vm_size_t *size)
+                     vm_address_t *offset, vm_size_t *size)
 {
   assert_backtrace (pager->type == DISK || pager->type == FILE_DATA);
 
@@ -837,10 +837,10 @@ pager_dropweak (struct user_pager_info *upi)
       pthread_spin_lock (&node_to_page_lock);
       pager = diskfs_node_disknode (upi->node)->pager;
       if (pager && pager_get_upi (pager) == upi)
-       {
-         diskfs_node_disknode (upi->node)->pager = NULL;
-         ports_port_deref_weak (pager);
-       }
+        {
+          diskfs_node_disknode (upi->node)->pager = NULL;
+          ports_port_deref_weak (pager);
+        }
       pthread_spin_unlock (&node_to_page_lock);
     }
 }
@@ -877,10 +877,10 @@ disk_cache_info_free_pop (void)
       pthread_mutex_lock (&disk_cache_info_free_lock);
       p = disk_cache_info_free;
       if (p)
-       {
-         disk_cache_info_free = p->next;
-         p->next = NULL;
-       }
+        {
+          disk_cache_info_free = p->next;
+          p->next = NULL;
+        }
       pthread_mutex_unlock (&disk_cache_info_free_lock);
     }
   while (p && (p->flags & DC_DONT_REUSE || p->ref_count > 0));
@@ -906,7 +906,7 @@ disk_cache_init (void)
 {
   if (block_size != vm_page_size)
     ext2_panic ("Block size %u != vm_page_size %u",
-               block_size, vm_page_size);
+                block_size, vm_page_size);
 
   pthread_mutex_init (&disk_cache_lock, NULL);
   pthread_cond_init (&disk_cache_reassociation, NULL);
@@ -934,7 +934,7 @@ disk_cache_init (void)
 #ifdef DEBUG_DISK_CACHE
       disk_cache_info[i].last_read = DC_NO_BLOCK;
       disk_cache_info[i].last_read_xor
-       = DC_NO_BLOCK ^ DISK_CACHE_LAST_READ_XOR;
+        = DC_NO_BLOCK ^ DISK_CACHE_LAST_READ_XOR;
 #endif
     }
 
@@ -972,26 +972,26 @@ disk_cache_return_unused (void)
   pthread_mutex_lock (&disk_cache_lock);
   for (index = 0; index < disk_cache_blocks; index++)
     if (! (disk_cache_info[index].flags & (DC_DONT_REUSE & ~DC_INCORE))
-       && ! disk_cache_info[index].ref_count)
+        && ! disk_cache_info[index].ref_count)
       {
-       ext2_debug ("return %u -> %d",
-                   disk_cache_info[index].block, index);
-       if (index != pending_end)
-         {
-           /* Return previous region, if there is such, ... */
-           if (pending_end >= 0)
-             {
-               pthread_mutex_unlock (&disk_cache_lock);
-               pager_return_some (diskfs_disk_pager,
-                                  pending_begin * vm_page_size,
-                                  (pending_end - pending_begin)
-                                  * vm_page_size, 1);
-               pthread_mutex_lock (&disk_cache_lock);
-             }
-           /* ... and start new region.  */
-           pending_begin = index;
-         }
-       pending_end = index + 1;
+        ext2_debug ("return %u -> %d",
+                    disk_cache_info[index].block, index);
+        if (index != pending_end)
+          {
+            /* Return previous region, if there is such, ... */
+            if (pending_end >= 0)
+            {
+              pthread_mutex_unlock (&disk_cache_lock);
+              pager_return_some (diskfs_disk_pager,
+                  pending_begin * vm_page_size,
+                  (pending_end - pending_begin)
+                  * vm_page_size, 1);
+              pthread_mutex_lock (&disk_cache_lock);
+            }
+            /* ... and start new region.  */
+            pending_begin = index;
+          }
+        pending_end = index + 1;
       }
 
   pthread_mutex_unlock (&disk_cache_lock);
@@ -999,9 +999,9 @@ disk_cache_return_unused (void)
   /* Return last region, if there is such.   */
   if (pending_end >= 0)
     pager_return_some (diskfs_disk_pager,
-                      pending_begin * vm_page_size,
-                      (pending_end - pending_begin) * vm_page_size,
-                      1);
+                       pending_begin * vm_page_size,
+                       (pending_end - pending_begin) * vm_page_size,
+                       1);
   else
     {
       ext2_debug ("ext2fs: disk cache is starving\n");
@@ -1035,27 +1035,27 @@ retry_ref:
 
       /* In process of re-associating?  */
       if (disk_cache_info[index].flags & DC_UNTOUCHED)
-       {
-         /* Wait re-association to finish.  */
-         pthread_cond_wait (&disk_cache_reassociation, &disk_cache_lock);
-         pthread_mutex_unlock (&disk_cache_lock);
+        {
+          /* Wait re-association to finish.  */
+          pthread_cond_wait (&disk_cache_reassociation, &disk_cache_lock);
+          pthread_mutex_unlock (&disk_cache_lock);
 
 #if 0
-         printf ("Re-association -- wait finished.\n");
+          printf ("Re-association -- wait finished.\n");
 #endif
 
-         goto retry_ref;
-       }
+          goto retry_ref;
+        }
 
       /* Just increment reference and return.  */
       assert_backtrace (disk_cache_info[index].ref_count + 1
-             > disk_cache_info[index].ref_count);
+                        > disk_cache_info[index].ref_count);
       disk_cache_info[index].ref_count++;
 
       ext2_debug ("cached %u -> %d (ref_count = %hu, flags = %#hx, ptr = %p)",
-                 disk_cache_info[index].block, index,
-                 disk_cache_info[index].ref_count,
-                 disk_cache_info[index].flags, bptr);
+                  disk_cache_info[index].block, index,
+                  disk_cache_info[index].ref_count,
+                  disk_cache_info[index].flags, bptr);
 
       pthread_mutex_unlock (&disk_cache_lock);
 
@@ -1115,7 +1115,7 @@ retry_ref:
   int page = (bptr - disk_cache) / vm_page_size;
   assert_backtrace (page >= 0);
   int is_incore = (page < diskfs_disk_pager->pagemapsize
-                  && (diskfs_disk_pager->pagemap[page] & PM_INCORE));
+      && (diskfs_disk_pager->pagemap[page] & PM_INCORE));
   pthread_mutex_unlock (&diskfs_disk_pager->interlock);
   if (is_incore)
     {
@@ -1159,7 +1159,7 @@ retry_ref:
 
       /* Prepare next time association of this page to succeed.  */
       pager_flush_some (diskfs_disk_pager, bptr - disk_cache,
-                       vm_page_size, 0);
+                        vm_page_size, 0);
 
 #if 0
       printf ("Re-association failed.\n");
@@ -1186,13 +1186,13 @@ disk_cache_block_ref_ptr (void *ptr)
   index = bptr_index (ptr);
   assert_backtrace (disk_cache_info[index].ref_count >= 1);
   assert_backtrace (disk_cache_info[index].ref_count + 1
-         > disk_cache_info[index].ref_count);
+                    > disk_cache_info[index].ref_count);
   disk_cache_info[index].ref_count++;
   assert_backtrace (! (disk_cache_info[index].flags & DC_UNTOUCHED));
   ext2_debug ("(%p) (ref_count = %hu, flags = %#hx)",
-             ptr,
-             disk_cache_info[index].ref_count,
-             disk_cache_info[index].flags);
+              ptr,
+              disk_cache_info[index].ref_count,
+              disk_cache_info[index].flags);
   pthread_mutex_unlock (&disk_cache_lock);
 }
 
@@ -1206,9 +1206,9 @@ _disk_cache_block_deref (void *ptr)
   pthread_mutex_lock (&disk_cache_lock);
   index = bptr_index (ptr);
   ext2_debug ("(%p) (ref_count = %hu, flags = %#hx)",
-             ptr,
-             disk_cache_info[index].ref_count - 1,
-             disk_cache_info[index].flags);
+              ptr,
+              disk_cache_info[index].ref_count - 1,
+              disk_cache_info[index].flags);
   assert_backtrace (! (disk_cache_info[index].flags & DC_UNTOUCHED));
   assert_backtrace (disk_cache_info[index].ref_count >= 1);
   disk_cache_info[index].ref_count--;
@@ -1252,7 +1252,7 @@ create_disk_pager (void)
   disk_cache_blocks = DISK_CACHE_BLOCKS;
   disk_cache_size = disk_cache_blocks << log2_block_size;
   diskfs_start_disk_pager (upi, disk_pager_bucket, MAY_CACHE, 1,
-                          disk_cache_size, &disk_cache);
+                           disk_cache_size, &disk_cache);
   disk_cache_init ();
 
   /* The file pager.  */
@@ -1299,49 +1299,49 @@ diskfs_get_filemap (struct node *node, vm_prot_t prot)
   mach_port_t right;
 
   assert_backtrace (S_ISDIR (node->dn_stat.st_mode)
-         || S_ISREG (node->dn_stat.st_mode)
-         || (S_ISLNK (node->dn_stat.st_mode)));
+                    || S_ISREG (node->dn_stat.st_mode)
+                    || (S_ISLNK (node->dn_stat.st_mode)));
 
   pthread_spin_lock (&node_to_page_lock);
   do
     {
       struct pager *pager = diskfs_node_disknode (node)->pager;
       if (pager)
-       {
-         right = pager_get_port (pager);
-         assert_backtrace (MACH_PORT_VALID (right));
-         pager_get_upi (pager)->max_prot |= prot;
-       }
+        {
+          right = pager_get_port (pager);
+          assert_backtrace (MACH_PORT_VALID (right));
+          pager_get_upi (pager)->max_prot |= prot;
+        }
       else
-       {
-         struct user_pager_info *upi;
-         pager = pager_create_alloc (sizeof *upi, file_pager_bucket,
-                                     MAY_CACHE, MEMORY_OBJECT_COPY_DELAY, 0);
-         if (pager == NULL)
-           {
-             pthread_spin_unlock (&node_to_page_lock);
-             return MACH_PORT_NULL;
-           }
-
-         upi = pager_get_upi (pager);
-         upi->type = FILE_DATA;
-         upi->node = node;
-         upi->max_prot = prot;
-         diskfs_nref_light (node);
-         diskfs_node_disknode (node)->pager = pager;
-
-         /* A weak reference for being part of the node.  */
-         ports_port_ref_weak (diskfs_node_disknode (node)->pager);
-
-         right = pager_get_port (diskfs_node_disknode (node)->pager);
-         ports_port_deref (diskfs_node_disknode (node)->pager);
-       }
+        {
+          struct user_pager_info *upi;
+          pager = pager_create_alloc (sizeof *upi, file_pager_bucket,
+              MAY_CACHE, MEMORY_OBJECT_COPY_DELAY, 0);
+          if (pager == NULL)
+            {
+              pthread_spin_unlock (&node_to_page_lock);
+              return MACH_PORT_NULL;
+            }
+
+          upi = pager_get_upi (pager);
+          upi->type = FILE_DATA;
+          upi->node = node;
+          upi->max_prot = prot;
+          diskfs_nref_light (node);
+          diskfs_node_disknode (node)->pager = pager;
+
+          /* A weak reference for being part of the node.  */
+          ports_port_ref_weak (diskfs_node_disknode (node)->pager);
+
+          right = pager_get_port (diskfs_node_disknode (node)->pager);
+          ports_port_deref (diskfs_node_disknode (node)->pager);
+        }
     }
   while (right == MACH_PORT_NULL);
   pthread_spin_unlock (&node_to_page_lock);
 
   mach_port_insert_right (mach_task_self (), right, right,
-                         MACH_MSG_TYPE_MAKE_SEND);
+                          MACH_MSG_TYPE_MAKE_SEND);
 
   return right;
 }
@@ -1467,16 +1467,16 @@ enable_caching ()
       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.  */
+         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->node);
-         diskfs_nrele (upi->node);
-       }
+        {
+          diskfs_nref (upi->node);
+          diskfs_nrele (upi->node);
+        }
 
       return 0;
     }
@@ -1500,15 +1500,15 @@ diskfs_pager_users ()
       disable_caching ();
 
       /* Give it a second; the kernel doesn't actually shutdown
-        immediately.  XXX */
+         immediately.  XXX */
       sleep (1);
 
       npagers = ports_count_bucket (file_pager_bucket);
       if (npagers == 0)
-       return 0;
+        return 0;
 
       /* Darn, there are actual honest users.  Turn caching back on,
-        and return failure. */
+         and return failure. */
       enable_caching ();
     }
 
@@ -1528,18 +1528,18 @@ diskfs_max_user_pager_prot ()
   if (npagers > 0)
     {
       error_t add_pager_max_prot (void *v_p)
-       {
-         struct pager *p = v_p;
-         struct user_pager_info *upi = pager_get_upi (p);
-         max_prot |= upi->max_prot;
-         /* Stop iterating if MAX_PROT is as filled as it's going to get. */
-         return max_prot == (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
-       }
+      {
+        struct pager *p = v_p;
+        struct user_pager_info *upi = pager_get_upi (p);
+        max_prot |= upi->max_prot;
+        /* Stop iterating if MAX_PROT is as filled as it's going to get. */
+        return max_prot == (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
+      }
 
       disable_caching ();              /* Make any silly pagers go away. */
 
       /* Give it a second; the kernel doesn't actually shutdown
-        immediately.  XXX */
+         immediately.  XXX */
       sleep (1);
 
       ports_bucket_iterate (file_pager_bucket, add_pager_max_prot);
diff --git a/ext2fs/pokel.c b/ext2fs/pokel.c
index 38209428..d4373bc5 100644
--- a/ext2fs/pokel.c
+++ b/ext2fs/pokel.c
@@ -68,30 +68,30 @@ pokel_add (struct pokel *pokel, void *loc, vm_size_t length)
       vm_size_t p_end = p_offs + pl->length;
 
       if (p_offs <= offset && end <= p_end)
-       {
-         if (pokel->image == disk_cache)
-           for (vm_offset_t i = offset; i < end; i += block_size)
-             _disk_cache_block_deref (disk_cache + i);
+        {
+          if (pokel->image == disk_cache)
+            for (vm_offset_t i = offset; i < end; i += block_size)
+              _disk_cache_block_deref (disk_cache + i);
 
-         break;
-       }
+          break;
+        }
       else if (p_end >= offset && end >= p_offs)
-       {
-         pl->offset = offset < p_offs ? offset : p_offs;
-         pl->length = (end > p_end ? end : p_end) - pl->offset;
-
-         if (pokel->image == disk_cache)
-           {
-             vm_offset_t i_begin = p_offs > offset ? p_offs : offset;
-             vm_offset_t i_end = p_end < end ? p_end : end;
-             for (vm_offset_t i = i_begin; i < i_end; i += block_size)
-               _disk_cache_block_deref (disk_cache + i);
-           }
-
-         ext2_debug ("extended 0x%x[%ul] to 0x%x[%ul]",
-                     p_offs, p_end - p_offs, pl->offset, pl->length);
-         break;
-       }
+        {
+          pl->offset = offset < p_offs ? offset : p_offs;
+          pl->length = (end > p_end ? end : p_end) - pl->offset;
+
+          if (pokel->image == disk_cache)
+            {
+              vm_offset_t i_begin = p_offs > offset ? p_offs : offset;
+              vm_offset_t i_end = p_end < end ? p_end : end;
+              for (vm_offset_t i = i_begin; i < i_end; i += block_size)
+                _disk_cache_block_deref (disk_cache + i);
+            }
+
+          ext2_debug ("extended 0x%x[%ul] to 0x%x[%ul]",
+                      p_offs, p_end - p_offs, pl->offset, pl->length);
+          break;
+        }
 
       pl = pl->next;
     }
@@ -100,12 +100,12 @@ pokel_add (struct pokel *pokel, void *loc, vm_size_t 
length)
     {
       pl = pokel->free_pokes;
       if (pl == NULL)
-       {
-         pl = malloc (sizeof (struct poke));
-         assert_backtrace (pl);
-       }
+        {
+          pl = malloc (sizeof (struct poke));
+          assert_backtrace (pl);
+        }
       else
-       pokel->free_pokes = pl->next;
+        pokel->free_pokes = pl->next;
       pl->offset = offset;
       pl->length = end - offset;
       pl->next = pokel->pokes;
@@ -130,18 +130,18 @@ _pokel_exec (struct pokel *pokel, int sync, int wait)
   for (pl = pokes; pl; last = pl, pl = pl->next)
     {
       if (sync)
-       {
-         ext2_debug ("syncing 0x%lx[%ul]", pl->offset, pl->length);
-         pager_sync_some (pokel->pager, pl->offset, pl->length, wait);
-       }
+        {
+          ext2_debug ("syncing 0x%lx[%ul]", pl->offset, pl->length);
+          pager_sync_some (pokel->pager, pl->offset, pl->length, wait);
+        }
 
       if (pokel->image == disk_cache)
-       {
-         vm_offset_t begin = trunc_block (pl->offset);
-         vm_offset_t end = round_block (pl->offset + pl->length);
-         for (vm_offset_t i = begin; i != end; i += block_size)
-           _disk_cache_block_deref (pokel->image + i);
-       }
+        {
+          vm_offset_t begin = trunc_block (pl->offset);
+          vm_offset_t end = round_block (pl->offset + pl->length);
+          for (vm_offset_t i = begin; i != end; i += block_size)
+            _disk_cache_block_deref (pokel->image + i);
+        }
     }
 
   if (last)
@@ -188,7 +188,7 @@ pokel_inherit (struct pokel *pokel, struct pokel *from)
   if (last)
     {
       while (last->next)
-       last = last->next;
+        last = last->next;
       last->next = pokes;
     }
   else
diff --git a/ext2fs/storeinfo.c b/ext2fs/storeinfo.c
index 40e0f603..59db97d6 100644
--- a/ext2fs/storeinfo.c
+++ b/ext2fs/storeinfo.c
@@ -26,13 +26,13 @@
 
 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,
-                               data_t *data, mach_msg_type_number_t *data_len)
+                                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,
+                                data_t *data, mach_msg_type_number_t *data_len)
 {
   error_t err = 0;
   unsigned num_fs_blocks;
@@ -64,38 +64,38 @@ diskfs_S_file_get_storage_info (struct protid *cred,
 
       err = ext2_getblk (node, index++, 0, &block);
       if (err == EINVAL)
-       /* Either a hole, or past the end of the file.
-          A hole can't be mapped in runs since we don't know
-          where the blocks will be allocated, so we can't return the
-          underlying storage.  */
-       err = EOPNOTSUPP;
+        /* Either a hole, or past the end of the file.
+           A hole can't be mapped in runs since we don't know
+           where the blocks will be allocated, so we can't return the
+           underlying storage.  */
+        err = EOPNOTSUPP;
       if (err)
-       break;
+        break;
 
       block <<= log2_dev_blocks_per_fs_block;
       if (num_runs == 0
-         || block != run->start + run->length) /* BLOCK doesn't follow RUN */
-       /* Add a new run.  */
-       {
-         if (num_runs == runs_alloced)
-           /* Make some more space in RUNS.  */
-           {
-             struct store_run *new;
-             runs_alloced *= 2;
-             new = realloc (runs, runs_alloced * sizeof (struct store_run));
-             if (! new)
-               {
-                 err = ENOMEM;
-                 break;
-               }
-             runs = new;
-           }
-
-         run = runs + num_runs++;
-         run->start = block;
-         /* The length will get extended just below.  */
-         run->length = 0;
-       }
+          || block != run->start + run->length) /* BLOCK doesn't follow RUN */
+        /* Add a new run.  */
+        {
+          if (num_runs == runs_alloced)
+            /* Make some more space in RUNS.  */
+            {
+              struct store_run *new;
+              runs_alloced *= 2;
+              new = realloc (runs, runs_alloced * sizeof (struct store_run));
+              if (! new)
+                {
+                  err = ENOMEM;
+                  break;
+                }
+              runs = new;
+            }
+
+          run = runs + num_runs++;
+          run->start = block;
+          /* The length will get extended just below.  */
+          run->length = 0;
+        }
 
       /* Increase the size of the current run by one filesystem block.  */
       run->length += 1 << log2_dev_blocks_per_fs_block;
@@ -109,19 +109,19 @@ diskfs_S_file_get_storage_info (struct protid *cred,
     {
       err = store_remap (file_store, runs, num_runs, &file_store);
       if (!err
-         && !idvec_contains (cred->user->uids, 0)
-         && !store_is_securely_returnable (file_store, cred->po->openstat))
-       {
-         err = store_set_flags (file_store, STORE_INACTIVE);
-         if (err == EINVAL)
-           err = EACCES;
-       }
+          && !idvec_contains (cred->user->uids, 0)
+          && !store_is_securely_returnable (file_store, cred->po->openstat))
+        {
+          err = store_set_flags (file_store, STORE_INACTIVE);
+          if (err == EINVAL)
+            err = EACCES;
+        }
       if (! err)
-       {
-         *ports_type = MACH_MSG_TYPE_COPY_SEND;
-         err = store_return (file_store, ports, num_ports, ints, num_ints,
-                             offsets, num_offsets, data, data_len);
-       }
+        {
+          *ports_type = MACH_MSG_TYPE_COPY_SEND;
+          err = store_return (file_store, ports, num_ports, ints, num_ints,
+                              offsets, num_offsets, data, data_len);
+        }
       store_free (file_store);
     }
 
diff --git a/ext2fs/truncate.c b/ext2fs/truncate.c
index 44aab3c7..756aad0b 100644
--- a/ext2fs/truncate.c
+++ b/ext2fs/truncate.c
@@ -116,9 +116,9 @@ trunc_direct (struct node *node, block_t end, struct 
free_block_run *fbr)
    set to 0, otherwise it is left alone.  */
 static void
 trunc_indirect (struct node *node, block_t end,
-               block_t *p, block_t offset,
-               void (*free_block)(block_t *p, unsigned index),
-               struct free_block_run *fbr)
+                block_t *p, block_t offset,
+                void (*free_block)(block_t *p, unsigned index),
+                struct free_block_run *fbr)
 {
   if (*p)
     {
@@ -128,34 +128,34 @@ trunc_indirect (struct node *node, block_t end,
       unsigned first = end < offset ? 0 : end - offset;
 
       for (index = first; index < addr_per_block; index++)
-       if (ind_bh[index])
-         {
-           (*free_block)(ind_bh + index, index);
-           if (ind_bh[index])
-             all_freed = 0;    /* Some descendent hasn't been freed.  */
-           else
-             modified = 1;
-         }
+        if (ind_bh[index])
+          {
+            (*free_block)(ind_bh + index, index);
+            if (ind_bh[index])
+              all_freed = 0;   /* Some descendent hasn't been freed.  */
+            else
+              modified = 1;
+          }
 
       if (first == 0 && all_freed)
-       {
-         pager_flush_some (diskfs_disk_pager,
-                           bptr_index (ind_bh) << log2_block_size,
-                           block_size, 1);
-         free_block_run_free_ptr (fbr, p);
-         disk_cache_block_deref (ind_bh);
-       }
+        {
+          pager_flush_some (diskfs_disk_pager,
+                            bptr_index (ind_bh) << log2_block_size,
+                            block_size, 1);
+          free_block_run_free_ptr (fbr, p);
+          disk_cache_block_deref (ind_bh);
+        }
       else if (modified)
-       record_indir_poke (node, ind_bh);
+        record_indir_poke (node, ind_bh);
       else
-       disk_cache_block_deref (ind_bh);
+        disk_cache_block_deref (ind_bh);
     }
 }
 
 static void
 trunc_single_indirect (struct node *node, block_t end,
-                      block_t *p, block_t offset,
-                      struct free_block_run *fbr)
+                       block_t *p, block_t offset,
+                       struct free_block_run *fbr)
 {
   void free_block (block_t *p, unsigned index)
     {
@@ -166,8 +166,8 @@ trunc_single_indirect (struct node *node, block_t end,
 
 static void
 trunc_double_indirect (struct node *node, block_t end,
-                      block_t *p, block_t offset,
-                      struct free_block_run *fbr)
+                       block_t *p, block_t offset,
+                       struct free_block_run *fbr)
 {
   void free_block (block_t *p, unsigned index)
     {
@@ -179,8 +179,8 @@ trunc_double_indirect (struct node *node, block_t end,
 
 static void
 trunc_triple_indirect (struct node *node, block_t end,
-                      block_t *p, block_t offset,
-                      struct free_block_run *fbr)
+                       block_t *p, block_t offset,
+                       struct free_block_run *fbr)
 {
   void free_block (block_t *p, unsigned index)
     {
@@ -204,17 +204,17 @@ poke_pages (memory_object_t obj, vm_offset_t start, 
vm_offset_t end)
       vm_address_t addr = 0;
 
       if (len > end - start)
-       len = end - start;
+        len = end - start;
 
       err = vm_map (mach_task_self (), &addr, len, 0, 1, obj, start, 0,
-                   VM_PROT_WRITE|VM_PROT_READ, VM_PROT_READ|VM_PROT_WRITE, 0);
+                    VM_PROT_WRITE|VM_PROT_READ, VM_PROT_READ|VM_PROT_WRITE, 0);
       if (!err)
-       {
-         vm_address_t poke;
-         for (poke = addr; poke < addr + len; poke += vm_page_size)
-           *(volatile int *)poke = *(volatile int *)poke;
-         munmap ((caddr_t) addr, len);
-       }
+        {
+          vm_address_t poke;
+          for (poke = addr; poke < addr + len; poke += vm_page_size)
+            *(volatile int *)poke = *(volatile int *)poke;
+          munmap ((caddr_t) addr, len);
+        }
 
       start += len;
     }
@@ -242,13 +242,13 @@ force_delayed_copies (struct node *node, off_t length)
       pager_change_attributes (pager, MAY_CACHE, MEMORY_OBJECT_COPY_NONE, 1);
       obj = diskfs_get_filemap (node, VM_PROT_READ | VM_PROT_WRITE);
       if (obj != MACH_PORT_NULL)
-       {
-         /* XXX should cope with errors from diskfs_get_filemap */
-         poke_pages (obj, round_page (length), round_page (node->allocsize));
-         mach_port_deallocate (mach_task_self (), obj);
-         pager_flush_some (pager, round_page(length),
-                           node->allocsize - length, 1);
-       }
+        {
+          /* XXX should cope with errors from diskfs_get_filemap */
+          poke_pages (obj, round_page (length), round_page (node->allocsize));
+          mach_port_deallocate (mach_task_self (), obj);
+          pager_flush_some (pager, round_page(length),
+                            node->allocsize - length, 1);
+        }
 
       ports_port_deref (pager);
     }
@@ -300,14 +300,14 @@ diskfs_truncate (struct node *node, off_t length)
       off_t frobmax = sizeof(diskfs_node_disknode (node)->info.i_data);
 
       if (froblen > frobmax)
-       {
-         ext2_warning ("inline data was %lld, more than max %lld",
-             (long long) froblen, (long long) frobmax);
-         froblen = frobmax;
-       }
+        {
+          ext2_warning ("inline data was %lld, more than max %lld",
+                        (long long) froblen, (long long) frobmax);
+          froblen = frobmax;
+        }
       froblen -= length;
       memset (((char *) (diskfs_node_disknode (node)->info.i_data)) + length,
-             0, froblen);
+              0, froblen);
 
       node->dn_stat.st_size = length;
       node->dn_set_mtime = 1;
@@ -326,7 +326,7 @@ diskfs_truncate (struct node *node, off_t length)
   if (offset > 0)
     {
       diskfs_node_rdwr (node, (void *)zeroblock, length, block_size - offset,
-                       1, 0, 0);
+                        1, 0, 0);
       /* Make sure that really happens to avoid leaks.  */
       diskfs_file_update (node, 1);
     }
@@ -367,9 +367,9 @@ diskfs_truncate (struct node *node, off_t length)
       node->allocsize = round_block (length);
 
       /* Set our last_page_partially_writable to a pessimistic state -- it
-        won't hurt if is wrong.  */
+         won't hurt if is wrong.  */
       diskfs_node_disknode (node)->last_page_partially_writable =
-               trunc_page (node->allocsize) != node->allocsize;
+        trunc_page (node->allocsize) != node->allocsize;
 
       diskfs_end_catch_exception ();
     }
diff --git a/ext2fs/xattr.c b/ext2fs/xattr.c
index ff84a3b9..6bb89bec 100644
--- a/ext2fs/xattr.c
+++ b/ext2fs/xattr.c
@@ -57,12 +57,12 @@ xattr_name_prefix (const char *full_name, int *index, const 
char **name)
   for (i = 0; xattr_prefixes[i].prefix != NULL; i++)
     {
       if (!strncmp (xattr_prefixes[i].prefix, full_name,
-                   xattr_prefixes[i].size))
-       {
-         *name = full_name + xattr_prefixes[i].size;
-         *index = xattr_prefixes[i].index;
-         break;
-       }
+          xattr_prefixes[i].size))
+        {
+          *name = full_name + xattr_prefixes[i].size;
+          *index = xattr_prefixes[i].index;
+          break;
+        }
     }
   return i;
 }
@@ -75,7 +75,7 @@ xattr_name_prefix (const char *full_name, int *index, const 
char **name)
  */
 static void
 xattr_entry_hash (struct ext2_xattr_header *header,
-                 struct ext2_xattr_entry *entry)
+                  struct ext2_xattr_entry *entry)
 {
 
   __u32 hash = 0;
@@ -86,19 +86,19 @@ xattr_entry_hash (struct ext2_xattr_header *header,
     {
       hash = (hash << NAME_HASH_SHIFT)
         ^ (hash >> (8 * sizeof (hash) - NAME_HASH_SHIFT))
-           ^ *name++;
+        ^ *name++;
     }
 
   if (entry->e_value_block == 0 && entry->e_value_size != 0)
     {
       __u32 *value = (__u32 *) ((char *) header + entry->e_value_offs);
       for (n = (entry->e_value_size + EXT2_XATTR_ROUND) >>
-             EXT2_XATTR_PAD_BITS; n; n--)
-       {
-         hash = (hash << VALUE_HASH_SHIFT)
-             ^ (hash >> (8 * sizeof (hash) - VALUE_HASH_SHIFT))
-             ^ *value++;
-       }
+          EXT2_XATTR_PAD_BITS; n; n--)
+        {
+          hash = (hash << VALUE_HASH_SHIFT)
+          ^ (hash >> (8 * sizeof (hash) - VALUE_HASH_SHIFT))
+          ^ *value++;
+        }
     }
 
   entry->e_hash = hash;
@@ -116,7 +116,7 @@ xattr_entry_hash (struct ext2_xattr_header *header,
  */
 static void
 xattr_entry_rehash (struct ext2_xattr_header *header,
-                   struct ext2_xattr_entry *entry)
+                    struct ext2_xattr_entry *entry)
 {
 
   __u32 hash = 0;
@@ -128,15 +128,15 @@ xattr_entry_rehash (struct ext2_xattr_header *header,
   while (!EXT2_XATTR_ENTRY_LAST (position))
     {
       if (position->e_hash == 0)
-       {
-         /* Block is not shared if an entry's hash value == 0 */
-         hash = 0;
-         break;
-       }
+        {
+          /* Block is not shared if an entry's hash value == 0 */
+          hash = 0;
+          break;
+        }
 
       hash = (hash << BLOCK_HASH_SHIFT)
-         ^ (hash >> (8 * sizeof (hash) - BLOCK_HASH_SHIFT))
-         ^ position->e_hash;
+        ^ (hash >> (8 * sizeof (hash) - BLOCK_HASH_SHIFT))
+        ^ position->e_hash;
 
       position = EXT2_XATTR_ENTRY_NEXT (position);
     }
@@ -165,7 +165,7 @@ xattr_entry_list (struct ext2_xattr_entry *entry, char 
*buffer, size_t *len)
   for (i = 0; xattr_prefixes[i].prefix != NULL; i++)
     {
       if (entry->e_name_index == xattr_prefixes[i].index)
-       break;
+        break;
     }
 
   if (xattr_prefixes[i].prefix == NULL)
@@ -176,17 +176,17 @@ xattr_entry_list (struct ext2_xattr_entry *entry, char 
*buffer, size_t *len)
   if (buffer)
     {
       if (size <= *len)
-       {
-         memcpy (buffer, xattr_prefixes[i].prefix, xattr_prefixes[i].size);
-         buffer += xattr_prefixes[i].size;
-         memcpy (buffer, entry->e_name, entry->e_name_len);
-         buffer += entry->e_name_len;
-         *buffer++ = 0;
-       }
+        {
+          memcpy (buffer, xattr_prefixes[i].prefix, xattr_prefixes[i].size);
+          buffer += xattr_prefixes[i].size;
+          memcpy (buffer, entry->e_name, entry->e_name_len);
+          buffer += entry->e_name_len;
+          *buffer++ = 0;
+        }
       else
-       {
-         return ERANGE;
-       }
+        {
+          return ERANGE;
+        }
     }
 
   *len -= size;
@@ -209,7 +209,7 @@ xattr_entry_list (struct ext2_xattr_entry *entry, char 
*buffer, size_t *len)
  */
 static error_t
 xattr_entry_get (void *block, struct ext2_xattr_entry *entry,
-                const char *full_name, char *value, size_t *len, int *cmp)
+                 const char *full_name, char *value, size_t *len, int *cmp)
 {
 
   int i;
@@ -231,16 +231,16 @@ xattr_entry_get (void *block, struct ext2_xattr_entry 
*entry,
   if (tmp_cmp)
     {
       if (cmp)
-       *cmp = tmp_cmp;
+        *cmp = tmp_cmp;
       return ENODATA;
     }
 
   if (value)
     {
       if (*len < entry->e_value_size)
-       {
-         return ERANGE;
-       }
+        {
+          return ERANGE;
+        }
       memcpy (value, block + entry->e_value_offs, entry->e_value_size);
     }
 
@@ -258,10 +258,10 @@ xattr_entry_get (void *block, struct ext2_xattr_entry 
*entry,
  */
 static error_t
 xattr_entry_create (struct ext2_xattr_header *header,
-                   struct ext2_xattr_entry *last,
-                   struct ext2_xattr_entry *position,
-                   const char *full_name, const char *value,
-                   size_t len, size_t rest)
+                    struct ext2_xattr_entry *last,
+                    struct ext2_xattr_entry *position,
+                    const char *full_name, const char *value,
+                    size_t len, size_t rest)
 {
 
   int i;
@@ -302,7 +302,7 @@ xattr_entry_create (struct ext2_xattr_header *header,
 
   memcpy ((char *) header + position->e_value_offs, value, len);
   memset ((char *) header + position->e_value_offs + len, 0,
-         value_size - len);
+          value_size - len);
 
   return 0;
 
@@ -315,8 +315,8 @@ xattr_entry_create (struct ext2_xattr_header *header,
  */
 static error_t
 xattr_entry_remove (struct ext2_xattr_header *header,
-                   struct ext2_xattr_entry *last,
-                   struct ext2_xattr_entry *position, size_t rest)
+                    struct ext2_xattr_entry *last,
+                    struct ext2_xattr_entry *position, size_t rest)
 {
 
   size_t size;
@@ -330,7 +330,7 @@ xattr_entry_remove (struct ext2_xattr_header *header,
   end = position->e_value_offs;
 
   memmove ((char *) header + start + size, (char *) header + start,
-          end - start);
+           end - start);
   memset ((char *) header + start, 0, size);
 
   /* Adjust all value offsets */
@@ -338,7 +338,7 @@ xattr_entry_remove (struct ext2_xattr_header *header,
   while (!EXT2_XATTR_ENTRY_LAST (entry))
     {
       if (entry->e_value_offs < end)
-       entry->e_value_offs += size;
+        entry->e_value_offs += size;
       entry = EXT2_XATTR_ENTRY_NEXT (entry);
     }
 
@@ -348,7 +348,7 @@ xattr_entry_remove (struct ext2_xattr_header *header,
   end = EXT2_XATTR_ENTRY_OFFSET (header, last);
 
   memmove ((char *) header + start , (char *) header + start + size,
-          end - (start + size));
+           end - (start + size));
   memset ((char *) header + end - size, 0, size);
 
   return 0;
@@ -364,9 +364,9 @@ xattr_entry_remove (struct ext2_xattr_header *header,
  */
 static error_t
 xattr_entry_replace (struct ext2_xattr_header *header,
-                    struct ext2_xattr_entry *last,
-                    struct ext2_xattr_entry *position,
-                    const char *value, size_t len, size_t rest)
+                     struct ext2_xattr_entry *last,
+                     struct ext2_xattr_entry *position,
+                     const char *value, size_t len, size_t rest)
 {
 
   size_t old_size;
@@ -389,16 +389,16 @@ xattr_entry_replace (struct ext2_xattr_header *header,
 
       /* Remove the old value */
       memmove ((char *) header + start + old_size, (char *) header + start,
-              end - start);
+               end - start);
 
       /* Adjust all value offsets */
       entry = EXT2_XATTR_ENTRY_FIRST (header);
       while (!EXT2_XATTR_ENTRY_LAST (entry))
-       {
-         if (entry->e_value_offs < end)
-           entry->e_value_offs += old_size;
-         entry = EXT2_XATTR_ENTRY_NEXT (entry);
-       }
+        {
+          if (entry->e_value_offs < end)
+            entry->e_value_offs += old_size;
+          entry = EXT2_XATTR_ENTRY_NEXT (entry);
+        }
 
       position->e_value_offs = start - (new_size - old_size);
     }
@@ -548,7 +548,7 @@ ext2_list_xattr (struct node *np, char *buffer, size_t *len)
     {
       err = xattr_entry_list (entry, buffer, &size);
       if (err)
-       goto cleanup;
+        goto cleanup;
       if (buffer)
         buffer += strlen (buffer) + 1;
       entry = EXT2_XATTR_ENTRY_NEXT (entry);
@@ -623,8 +623,8 @@ ext2_get_xattr (struct node *np, const char *name, char 
*value, size_t *len)
     {
       size = *len;
       err = xattr_entry_get (block, entry, name, value, &size, NULL);
-      if (err!= ENODATA)
-       break;
+      if (err != ENODATA)
+        break;
       entry = EXT2_XATTR_ENTRY_NEXT (entry);
     }
 
@@ -656,7 +656,7 @@ cleanup:
  */
 error_t
 ext2_set_xattr (struct node *np, const char *name, const char *value,
-               size_t len, int flags)
+                size_t len, int flags)
 {
 
   int found;
@@ -700,14 +700,14 @@ ext2_set_xattr (struct node *np, const char *name, const 
char *value,
       assert_backtrace (!diskfs_readonly);
 
       goal = sblock->s_first_data_block + np->dn->info.i_block_group *
-       EXT2_BLOCKS_PER_GROUP (sblock);
+        EXT2_BLOCKS_PER_GROUP (sblock);
       blkno = ext2_new_block (goal, 0, 0, 0);
 
       if (blkno == 0)
-       {
-         err = ENOSPC;
-         goto cleanup;
-       }
+        {
+          err = ENOSPC;
+          goto cleanup;
+        }
 
       block = disk_cache_block_ref (blkno);
       memset (block, 0, block_size);
@@ -722,11 +722,11 @@ ext2_set_xattr (struct node *np, const char *name, const 
char *value,
       block = disk_cache_block_ref (blkno);
       header = EXT2_XATTR_HEADER (block);
       if (header->h_magic != EXT2_XATTR_BLOCK_MAGIC || header->h_blocks != 1)
-       {
-         ext2_warning ("Invalid extended attribute block.");
-         err = EIO;
-         goto cleanup;
-       }
+        {
+          ext2_warning ("Invalid extended attribute block.");
+          err = EIO;
+          goto cleanup;
+        }
     }
 
   entry = EXT2_XATTR_ENTRY_FIRST (header);
@@ -743,23 +743,23 @@ ext2_set_xattr (struct node *np, const char *name, const 
char *value,
 
       err = xattr_entry_get (NULL, entry, name, NULL, &size, &cmp);
       if (err == 0)
-       {
-         location = entry;
-         found = TRUE;
-       }
+        {
+          location = entry;
+          found = TRUE;
+        }
       else if (err == ENODATA)
-       {
-         /* The xattr entries are sorted by attribute name */
-         if (cmp < 0 && !found)
-           {
-             location = entry;
-             found = FALSE;
-           }
-       }
+        {
+          /* The xattr entries are sorted by attribute name */
+          if (cmp < 0 && !found)
+            {
+              location = entry;
+              found = FALSE;
+            }
+        }
       else
-       {
-         break;
-       }
+        {
+          break;
+        }
 
       rest -= EXT2_XATTR_ALIGN (entry->e_value_size);
       entry = EXT2_XATTR_ENTRY_NEXT (entry);
@@ -786,46 +786,46 @@ ext2_set_xattr (struct node *np, const char *name, const 
char *value,
   if (value && flags & XATTR_CREATE)
     {
       if (found)
-       {
-         err = EEXIST;
-         goto cleanup;
-       }
+        {
+          err = EEXIST;
+          goto cleanup;
+        }
       else
-       err = xattr_entry_create (header, entry, location, name, value, len,
-         rest);
+        err = xattr_entry_create (header, entry, location, name, value, len,
+          rest);
     }
   else if (value && flags & XATTR_REPLACE)
     {
       if (!found)
-       {
-         err = ENODATA;
-         goto cleanup;
-       }
+        {
+          err = ENODATA;
+          goto cleanup;
+        }
       else
-       err = xattr_entry_replace (header, entry, location, value, len, rest);
+        err = xattr_entry_replace (header, entry, location, value, len, rest);
     }
   else if (value)
     {
       if (found)
-       err = xattr_entry_replace (header, entry, location, value, len, rest);
+        err = xattr_entry_replace (header, entry, location, value, len, rest);
       else
-       err = xattr_entry_create (header, entry, location, name, value, len,
-               rest);
+        err = xattr_entry_create (header, entry, location, name, value, len,
+          rest);
     }
   else
     {
       if (flags & XATTR_REPLACE || flags & XATTR_CREATE)
-       {
-         err = EINVAL;
-         goto cleanup;
-       }
+        {
+          err = EINVAL;
+          goto cleanup;
+        }
       else if (!found)
-       {
-         err = ENODATA;
-         goto cleanup;
-       }
+        {
+          err = ENODATA;
+          goto cleanup;
+        }
       else
-       err = xattr_entry_remove (header, entry, location, rest);
+        err = xattr_entry_remove (header, entry, location, rest);
     }
 
   /* Check if the xattr block is empty */
@@ -835,31 +835,31 @@ ext2_set_xattr (struct node *np, const char *name, const 
char *value,
   if (err == 0)
     {
       if (empty)
-       {
-         disk_cache_block_deref (block);
-         dino_deref (ei);
+        {
+          disk_cache_block_deref (block);
+          dino_deref (ei);
 
-         return ext2_free_xattr_block (np);
-       }
+          return ext2_free_xattr_block (np);
+        }
       else
-       {
-         xattr_entry_rehash (header, location);
+        {
+          xattr_entry_rehash (header, location);
 
-         record_global_poke (block);
+          record_global_poke (block);
 
-         if (ei->i_file_acl == 0)
-           {
-             np->dn_stat.st_blocks += 1 << log2_stat_blocks_per_fs_block;
-             np->dn_set_ctime = 1;
+          if (ei->i_file_acl == 0)
+            {
+              np->dn_stat.st_blocks += 1 << log2_stat_blocks_per_fs_block;
+              np->dn_set_ctime = 1;
 
-             ei->i_file_acl = blkno;
-             record_global_poke (ei);
-           }
-         else
-             dino_deref (ei);
+              ei->i_file_acl = blkno;
+              record_global_poke (ei);
+            }
+          else
+            dino_deref (ei);
 
-         return 0;
-       }
+          return 0;
+        }
     }
 
 cleanup:
-- 
2.34.1




reply via email to

[Prev in Thread] Current Thread [Next in Thread]