From c1ef7bdd8d002ae0889efcf883d0e1b7faa938d4 Mon Sep 17 00:00:00 2001
From: Tim Riker <tim@rikers.org>
Date: Wed, 25 Jan 2006 00:08:53 +0000
Subject: just whitespace

---
 e2fsprogs/Config.in              |  12 ++--
 e2fsprogs/blkid/blkid.h          |   8 +--
 e2fsprogs/blkid/blkid_getsize.c  |   2 +-
 e2fsprogs/blkid/cache.c          |  10 +--
 e2fsprogs/blkid/dev.c            |   2 +-
 e2fsprogs/blkid/devname.c        |   4 +-
 e2fsprogs/blkid/devno.c          |   4 +-
 e2fsprogs/blkid/probe.c          |  98 +++++++++++++--------------
 e2fsprogs/blkid/probe.h          |  12 ++--
 e2fsprogs/blkid/read.c           |   4 +-
 e2fsprogs/blkid/resolve.c        |   4 +-
 e2fsprogs/blkid/save.c           |   2 +-
 e2fsprogs/blkid/tag.c            |  18 ++---
 e2fsprogs/chattr.c               |   4 +-
 e2fsprogs/e2fsck.c               |   4 +-
 e2fsprogs/e2p/feature.c          |   6 +-
 e2fsprogs/e2p/fgetsetversion.c   |   6 +-
 e2fsprogs/e2p/hashstr.c          |   6 +-
 e2fsprogs/e2p/ls.c               |   6 +-
 e2fsprogs/e2p/mntopts.c          |   6 +-
 e2fsprogs/e2p/ostype.c           |  10 +--
 e2fsprogs/e2p/parse_num.c        |  20 +++---
 e2fsprogs/e2p/pf.c               |   2 +-
 e2fsprogs/e2p/uuid.c             |   4 +-
 e2fsprogs/ext2fs/alloc.c         |  14 ++--
 e2fsprogs/ext2fs/alloc_sb.c      |   8 +--
 e2fsprogs/ext2fs/alloc_stats.c   |   2 +-
 e2fsprogs/ext2fs/alloc_tables.c  |  12 ++--
 e2fsprogs/ext2fs/badblocks.c     |  12 ++--
 e2fsprogs/ext2fs/bb_compat.c     |   2 +-
 e2fsprogs/ext2fs/bb_inode.c      |  42 ++++++------
 e2fsprogs/ext2fs/bitmaps.c       |  18 ++---
 e2fsprogs/ext2fs/bitops.c        |   4 +-
 e2fsprogs/ext2fs/bitops.h        |   6 +-
 e2fsprogs/ext2fs/block.c         |  24 +++----
 e2fsprogs/ext2fs/bmap.c          |  34 +++++-----
 e2fsprogs/ext2fs/bmove.c         |  12 ++--
 e2fsprogs/ext2fs/brel.h          |   4 +-
 e2fsprogs/ext2fs/brel_ma.c       |  24 +++----
 e2fsprogs/ext2fs/check_desc.c    |   4 +-
 e2fsprogs/ext2fs/closefs.c       |  22 +++---
 e2fsprogs/ext2fs/cmp_bitmaps.c   |   4 +-
 e2fsprogs/ext2fs/dblist.c        |  20 +++---
 e2fsprogs/ext2fs/dblist_dir.c    |   8 +--
 e2fsprogs/ext2fs/dir_iterate.c   |  24 +++----
 e2fsprogs/ext2fs/dirblock.c      |  12 ++--
 e2fsprogs/ext2fs/dirhash.c       |  22 +++---
 e2fsprogs/ext2fs/dupfs.c         |   6 +-
 e2fsprogs/ext2fs/e2image.h       |  30 ++++-----
 e2fsprogs/ext2fs/expanddir.c     |  14 ++--
 e2fsprogs/ext2fs/ext2_fs.h       |  10 +--
 e2fsprogs/ext2fs/ext2fs.h        |  54 +++++++--------
 e2fsprogs/ext2fs/ext2fsP.h       |   4 +-
 e2fsprogs/ext2fs/ext2fs_inline.c |  38 +++++------
 e2fsprogs/ext2fs/ext_attr.c      |   6 +-
 e2fsprogs/ext2fs/fileio.c        |  42 ++++++------
 e2fsprogs/ext2fs/finddev.c       |  10 +--
 e2fsprogs/ext2fs/flushb.c        |   6 +-
 e2fsprogs/ext2fs/freefs.c        |   4 +-
 e2fsprogs/ext2fs/gen_bitmap.c    |   2 +-
 e2fsprogs/ext2fs/get_pathname.c  |  32 ++++-----
 e2fsprogs/ext2fs/getsectsize.c   |   2 +-
 e2fsprogs/ext2fs/getsize.c       |  16 ++---
 e2fsprogs/ext2fs/icount.c        |  32 ++++-----
 e2fsprogs/ext2fs/imager.c        |  20 +++---
 e2fsprogs/ext2fs/ind_block.c     |   6 +-
 e2fsprogs/ext2fs/initialize.c    |  30 ++++-----
 e2fsprogs/ext2fs/inline.c        |   6 +-
 e2fsprogs/ext2fs/inode.c         |  70 ++++++++++----------
 e2fsprogs/ext2fs/inode_io.c      |  14 ++--
 e2fsprogs/ext2fs/io_manager.c    |   4 +-
 e2fsprogs/ext2fs/irel.h          |   2 +-
 e2fsprogs/ext2fs/irel_ma.c       |  48 +++++++-------
 e2fsprogs/ext2fs/ismounted.c     |  64 +++++++++---------
 e2fsprogs/ext2fs/jfs_dat.h       |  12 ++--
 e2fsprogs/ext2fs/kernel-jbd.h    | 140 +++++++++++++++++++--------------------
 e2fsprogs/ext2fs/kernel-list.h   |   4 +-
 e2fsprogs/ext2fs/link.c          |   6 +-
 e2fsprogs/ext2fs/lookup.c        |   4 +-
 e2fsprogs/ext2fs/mkdir.c         |   6 +-
 e2fsprogs/ext2fs/mkjournal.c     |  28 ++++----
 e2fsprogs/ext2fs/namei.c         |  24 +++----
 e2fsprogs/ext2fs/newdir.c        |   6 +-
 e2fsprogs/ext2fs/openfs.c        |  40 +++++------
 e2fsprogs/ext2fs/read_bb.c       |   8 +--
 e2fsprogs/ext2fs/read_bb_file.c  |   6 +-
 e2fsprogs/ext2fs/rs_bitmap.c     |   6 +-
 e2fsprogs/ext2fs/rw_bitmaps.c    |  14 ++--
 e2fsprogs/ext2fs/swapfs.c        |  10 +--
 e2fsprogs/ext2fs/test_io.c       |  34 +++++-----
 e2fsprogs/ext2fs/unix_io.c       |  52 +++++++--------
 e2fsprogs/ext2fs/unlink.c        |   8 +--
 e2fsprogs/ext2fs/valid_blk.c     |   6 +-
 e2fsprogs/fsck.c                 |   4 +-
 e2fsprogs/lsattr.c               |   4 +-
 e2fsprogs/mke2fs.c               |  18 ++---
 e2fsprogs/tune2fs.c              |  20 +++---
 e2fsprogs/util.c                 |  22 +++---
 e2fsprogs/util.h                 |   2 +-
 e2fsprogs/uuid/compare.c         |   4 +-
 e2fsprogs/uuid/gen_uuid.c        |  24 +++----
 e2fsprogs/uuid/pack.c            |   4 +-
 e2fsprogs/uuid/parse.c           |   8 +--
 e2fsprogs/uuid/unpack.c          |   4 +-
 e2fsprogs/uuid/unparse.c         |   8 +--
 e2fsprogs/uuid/uuid.h            |   8 +--
 e2fsprogs/uuid/uuidP.h           |   4 +-
 e2fsprogs/uuid/uuid_time.c       |  16 ++---
 108 files changed, 862 insertions(+), 862 deletions(-)

(limited to 'e2fsprogs')

diff --git a/e2fsprogs/Config.in b/e2fsprogs/Config.in
index 225e5aaaf..91e873e3a 100644
--- a/e2fsprogs/Config.in
+++ b/e2fsprogs/Config.in
@@ -17,7 +17,7 @@ config CONFIG_E2FSCK
 	help
 	  e2fsck is used to check Linux second extended file systems (ext2fs).
 	  e2fsck also supports ext2 filesystems countaining a journal (ext3).
-	  The normal compat symlinks 'fsck.ext2' and 'fsck.ext3' are also 
+	  The normal compat symlinks 'fsck.ext2' and 'fsck.ext3' are also
 	  provided.
 
 config CONFIG_FSCK
@@ -25,7 +25,7 @@ config CONFIG_FSCK
 	default n
 	help
 	  fsck is used to check and optionally repair one or more filesystems.
-	  In actuality, fsck is simply a front-end for the various file system 
+	  In actuality, fsck is simply a front-end for the various file system
 	  checkers (fsck.fstype) available under Linux.
 
 config CONFIG_LSATTR
@@ -38,14 +38,14 @@ config CONFIG_MKE2FS
 	bool "mke2fs"
 	default n
 	help
-	  mke2fs is used to create an ext2/ext3 filesystem.  The normal compat 
+	  mke2fs is used to create an ext2/ext3 filesystem.  The normal compat
 	  symlinks 'mkfs.ext2' and 'mkfs.ext3' are also provided.
 
 config CONFIG_TUNE2FS
 	bool "tune2fs"
 	default n
 	help
-	  tune2fs allows the system administrator to adjust various tunable 
+	  tune2fs allows the system administrator to adjust various tunable
 	  filesystem parameters on Linux ext2/ext3 filesystems.
 
 config CONFIG_E2LABEL
@@ -53,7 +53,7 @@ config CONFIG_E2LABEL
 	default n
 	depends on CONFIG_TUNE2FS
 	help
-	  e2label will display or change the filesystem label on the ext2 
+	  e2label will display or change the filesystem label on the ext2
 	  filesystem located on device.
 
 config CONFIG_FINDFS
@@ -61,7 +61,7 @@ config CONFIG_FINDFS
 	default n
 	depends on CONFIG_TUNE2FS
 	help
-	  findfs will search the disks in the system looking for a filesystem 
+	  findfs will search the disks in the system looking for a filesystem
 	  which has a label matching label or a UUID equal to uuid.
 
 endmenu
diff --git a/e2fsprogs/blkid/blkid.h b/e2fsprogs/blkid/blkid.h
index 3ea94ac80..3bb0e78d8 100644
--- a/e2fsprogs/blkid/blkid.h
+++ b/e2fsprogs/blkid/blkid.h
@@ -34,13 +34,13 @@ typedef struct blkid_struct_dev_iterate *blkid_dev_iterate;
  * Flags for blkid_get_dev
  *
  * BLKID_DEV_CREATE	Create an empty device structure if not found
- * 			in the cache.
+ *			in the cache.
  * BLKID_DEV_VERIFY	Make sure the device structure corresponds
- * 			with reality.
+ *			with reality.
  * BLKID_DEV_FIND	Just look up a device entry, and return NULL
- * 			if it is not found.
+ *			if it is not found.
  * BLKID_DEV_NORMAL	Get a valid device structure, either from the
- * 			cache or by probing the device.
+ *			cache or by probing the device.
  */
 #define BLKID_DEV_FIND		0x0000
 #define BLKID_DEV_CREATE	0x0001
diff --git a/e2fsprogs/blkid/blkid_getsize.c b/e2fsprogs/blkid/blkid_getsize.c
index 9458c08bf..58cc7352a 100644
--- a/e2fsprogs/blkid/blkid_getsize.c
+++ b/e2fsprogs/blkid/blkid_getsize.c
@@ -70,7 +70,7 @@ blkid_loff_t blkid_get_dev_size(int fd)
 {
 	int valid_blkgetsize64 = 1;
 #ifdef __linux__
-	struct 		utsname ut;
+	struct		utsname ut;
 #endif
 	unsigned long long size64;
 	unsigned long size;
diff --git a/e2fsprogs/blkid/cache.c b/e2fsprogs/blkid/cache.c
index 0dd1b6286..87be1269f 100644
--- a/e2fsprogs/blkid/cache.c
+++ b/e2fsprogs/blkid/cache.c
@@ -47,9 +47,9 @@ int blkid_get_cache(blkid_cache *ret_cache, const char *filename)
 	if (!filename)
 		filename = BLKID_CACHE_FILE;
 	cache->bic_filename = blkid_strdup(filename);
-	
+
 	blkid_read_cache(cache);
-	
+
 	*ret_cache = cache;
 	return 0;
 }
@@ -62,7 +62,7 @@ void blkid_put_cache(blkid_cache cache)
 	(void) blkid_flush_cache(cache);
 
 	DBG(DEBUG_CACHE, printf("freeing cache struct\n"));
-	
+
 	/* DEB_DUMP_CACHE(cache); */
 
 	while (!list_empty(&cache->bic_devs)) {
@@ -79,7 +79,7 @@ void blkid_put_cache(blkid_cache cache)
 
 		while (!list_empty(&tag->bit_names)) {
 			blkid_tag bad = list_entry(tag->bit_names.next,
-						   struct blkid_struct_tag, 
+						   struct blkid_struct_tag,
 						   bit_names);
 
 			DBG(DEBUG_CACHE, printf("warning: unfreed tag %s=%s\n",
@@ -90,7 +90,7 @@ void blkid_put_cache(blkid_cache cache)
 	}
 	if (cache->bic_filename)
 		free(cache->bic_filename);
-	
+
 	free(cache);
 }
 
diff --git a/e2fsprogs/blkid/dev.c b/e2fsprogs/blkid/dev.c
index 0e2b4e1bc..d2e468304 100644
--- a/e2fsprogs/blkid/dev.c
+++ b/e2fsprogs/blkid/dev.c
@@ -73,7 +73,7 @@ extern const char *blkid_dev_devname(blkid_dev dev)
  * This series of functions iterate over all devices in a blkid cache
  */
 #define DEV_ITERATE_MAGIC	0x01a5284c
-	
+
 struct blkid_struct_dev_iterate {
 	int			magic;
 	blkid_cache		cache;
diff --git a/e2fsprogs/blkid/devname.c b/e2fsprogs/blkid/devname.c
index b5db29e30..1e016a55d 100644
--- a/e2fsprogs/blkid/devname.c
+++ b/e2fsprogs/blkid/devname.c
@@ -54,7 +54,7 @@ blkid_dev blkid_get_dev(blkid_cache cache, const char *devname, int flags)
 		if (strcmp(tmp->bid_name, devname))
 			continue;
 
-		DBG(DEBUG_DEVNAME, 
+		DBG(DEBUG_DEVNAME,
 		    printf("found devname %s in cache\n", tmp->bid_name));
 		dev = tmp;
 		break;
@@ -113,7 +113,7 @@ static void probe_one(blkid_cache cache, const char *ptname,
 		    dev->bid_devno == devno)
 			goto set_pri;
 
-		if (stat(device, &st) == 0 && S_ISBLK(st.st_mode) && 
+		if (stat(device, &st) == 0 && S_ISBLK(st.st_mode) &&
 		    st.st_rdev == devno) {
 			devname = blkid_strdup(device);
 			break;
diff --git a/e2fsprogs/blkid/devno.c b/e2fsprogs/blkid/devno.c
index 93a57fd86..7d083e76f 100644
--- a/e2fsprogs/blkid/devno.c
+++ b/e2fsprogs/blkid/devno.c
@@ -171,13 +171,13 @@ char *blkid_devno_to_devname(dev_t devno)
 
 	if (!devname) {
 		DBG(DEBUG_DEVNO,
-		    printf("blkid: couldn't find devno 0x%04lx\n", 
+		    printf("blkid: couldn't find devno 0x%04lx\n",
 			   (unsigned long) devno));
 	} else {
 		DBG(DEBUG_DEVNO,
 		    printf("found devno 0x%04Lx as %s\n", devno, devname));
 	}
-	
+
 
 	return devname;
 }
diff --git a/e2fsprogs/blkid/probe.c b/e2fsprogs/blkid/probe.c
index cb21c1070..2aaa50885 100644
--- a/e2fsprogs/blkid/probe.c
+++ b/e2fsprogs/blkid/probe.c
@@ -41,7 +41,7 @@ static int check_mdraid(int fd, unsigned char *ret_uuid)
 	struct mdp_superblock_s *md;
 	blkid_loff_t		offset;
 	char			buf[4096];
-	
+
 	if (fd < 0)
 		return -BLKID_ERR_PARAM;
 
@@ -83,7 +83,7 @@ static void get_ext2_info(blkid_dev dev, unsigned char *buf)
 	struct ext2_super_block *es = (struct ext2_super_block *) buf;
 	const char *label = 0;
 
-	DBG(DEBUG_PROBE, printf("ext2_sb.compat = %08X:%08X:%08X\n", 
+	DBG(DEBUG_PROBE, printf("ext2_sb.compat = %08X:%08X:%08X\n",
 		   blkid_le32(es->s_feature_compat),
 		   blkid_le32(es->s_feature_incompat),
 		   blkid_le32(es->s_feature_ro_compat)));
@@ -95,8 +95,8 @@ static void get_ext2_info(blkid_dev dev, unsigned char *buf)
 	set_uuid(dev, es->s_uuid);
 }
 
-static int probe_ext3(int fd __BLKID_ATTR((unused)), 
-		      blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_ext3(int fd __BLKID_ATTR((unused)),
+		      blkid_cache cache __BLKID_ATTR((unused)),
 		      blkid_dev dev,
 		      const struct blkid_magic *id, unsigned char *buf)
 {
@@ -105,7 +105,7 @@ static int probe_ext3(int fd __BLKID_ATTR((unused)),
 	es = (struct ext2_super_block *)buf;
 
 	/* Distinguish between jbd and ext2/3 fs */
-	if (blkid_le32(es->s_feature_incompat) & 
+	if (blkid_le32(es->s_feature_incompat) &
 	    EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
 		return -BLKID_ERR_PARAM;
 
@@ -121,8 +121,8 @@ static int probe_ext3(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_ext2(int fd __BLKID_ATTR((unused)), 
-		      blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_ext2(int fd __BLKID_ATTR((unused)),
+		      blkid_cache cache __BLKID_ATTR((unused)),
 		      blkid_dev dev,
 		      const struct blkid_magic *id, unsigned char *buf)
 {
@@ -132,7 +132,7 @@ static int probe_ext2(int fd __BLKID_ATTR((unused)),
 	es = (struct ext2_super_block *)buf;
 
 	/* Distinguish between jbd and ext2/3 fs */
-	if (blkid_le32(es->s_feature_incompat) & 
+	if (blkid_le32(es->s_feature_incompat) &
 	    EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
 		return -BLKID_ERR_PARAM;
 
@@ -141,10 +141,10 @@ static int probe_ext2(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_jbd(int fd __BLKID_ATTR((unused)), 
-		     blkid_cache cache __BLKID_ATTR((unused)), 
-		     blkid_dev dev, 
-		     const struct blkid_magic *id __BLKID_ATTR((unused)), 
+static int probe_jbd(int fd __BLKID_ATTR((unused)),
+		     blkid_cache cache __BLKID_ATTR((unused)),
+		     blkid_dev dev,
+		     const struct blkid_magic *id __BLKID_ATTR((unused)),
 		     unsigned char *buf)
 {
 	struct ext2_super_block *es = (struct ext2_super_block *) buf;
@@ -158,10 +158,10 @@ static int probe_jbd(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_vfat(int fd __BLKID_ATTR((unused)), 
-		      blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_vfat(int fd __BLKID_ATTR((unused)),
+		      blkid_cache cache __BLKID_ATTR((unused)),
 		      blkid_dev dev,
-		      const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		      const struct blkid_magic *id __BLKID_ATTR((unused)),
 		      unsigned char *buf)
 {
 	struct vfat_super_block *vs;
@@ -191,10 +191,10 @@ static int probe_vfat(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_msdos(int fd __BLKID_ATTR((unused)), 
-		       blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_msdos(int fd __BLKID_ATTR((unused)),
+		       blkid_cache cache __BLKID_ATTR((unused)),
 		       blkid_dev dev,
-		       const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		       const struct blkid_magic *id __BLKID_ATTR((unused)),
 		       unsigned char *buf)
 {
 	struct msdos_super_block *ms = (struct msdos_super_block *) buf;
@@ -223,10 +223,10 @@ static int probe_msdos(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_xfs(int fd __BLKID_ATTR((unused)), 
-		     blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_xfs(int fd __BLKID_ATTR((unused)),
+		     blkid_cache cache __BLKID_ATTR((unused)),
 		     blkid_dev dev,
-		     const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		     const struct blkid_magic *id __BLKID_ATTR((unused)),
 		     unsigned char *buf)
 {
 	struct xfs_super_block *xs;
@@ -241,8 +241,8 @@ static int probe_xfs(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_reiserfs(int fd __BLKID_ATTR((unused)), 
-			  blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_reiserfs(int fd __BLKID_ATTR((unused)),
+			  blkid_cache cache __BLKID_ATTR((unused)),
 			  blkid_dev dev,
 			  const struct blkid_magic *id, unsigned char *buf)
 {
@@ -268,10 +268,10 @@ static int probe_reiserfs(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_jfs(int fd __BLKID_ATTR((unused)), 
-		     blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_jfs(int fd __BLKID_ATTR((unused)),
+		     blkid_cache cache __BLKID_ATTR((unused)),
 		     blkid_dev dev,
-		     const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		     const struct blkid_magic *id __BLKID_ATTR((unused)),
 		     unsigned char *buf)
 {
 	struct jfs_super_block *js;
@@ -286,10 +286,10 @@ static int probe_jfs(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_romfs(int fd __BLKID_ATTR((unused)), 
-		       blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_romfs(int fd __BLKID_ATTR((unused)),
+		       blkid_cache cache __BLKID_ATTR((unused)),
 		       blkid_dev dev,
-		       const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		       const struct blkid_magic *id __BLKID_ATTR((unused)),
 		       unsigned char *buf)
 {
 	struct romfs_super_block *ros;
@@ -340,7 +340,7 @@ static int probe_swap1(int fd,
 	/* arbitrary sanity check.. is there any garbage down there? */
 	if (sws->sws_pad[32] == 0 && sws->sws_pad[33] == 0)  {
 		if (sws->sws_volume[0])
-			blkid_set_tag(dev, "LABEL", sws->sws_volume, 
+			blkid_set_tag(dev, "LABEL", sws->sws_volume,
 				      sizeof(sws->sws_volume));
 		if (sws->sws_uuid[0])
 			set_uuid(dev, sws->sws_uuid);
@@ -354,9 +354,9 @@ static const char
 * const udf_magic[] = { "BEA01", "BOOT2", "CD001", "CDW02", "NSR02",
 		 "NSR03", "TEA01", 0 };
 
-static int probe_udf(int fd, blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_udf(int fd, blkid_cache cache __BLKID_ATTR((unused)),
 		     blkid_dev dev __BLKID_ATTR((unused)),
-		     const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		     const struct blkid_magic *id __BLKID_ATTR((unused)),
 		     unsigned char *buf __BLKID_ATTR((unused)))
 {
 	int j, bs;
@@ -396,10 +396,10 @@ static int probe_udf(int fd, blkid_cache cache __BLKID_ATTR((unused)),
 	return 1;
 }
 
-static int probe_ocfs(int fd __BLKID_ATTR((unused)), 
-		      blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_ocfs(int fd __BLKID_ATTR((unused)),
+		      blkid_cache cache __BLKID_ATTR((unused)),
 		      blkid_dev dev,
-		      const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		      const struct blkid_magic *id __BLKID_ATTR((unused)),
 		      unsigned char *buf)
 {
 	struct ocfs_volume_header ovh;
@@ -414,17 +414,17 @@ static int probe_ocfs(int fd __BLKID_ATTR((unused)),
 		blkid_set_tag(dev,"SEC_TYPE","ocfs1",sizeof("ocfs1"));
 	else if (major >= 9)
 		blkid_set_tag(dev,"SEC_TYPE","ntocfs",sizeof("ntocfs"));
-	
+
 	blkid_set_tag(dev, "LABEL", ovl.label, ocfslabellen(ovl));
 	blkid_set_tag(dev, "MOUNT", ovh.mount, ocfsmountlen(ovh));
 	set_uuid(dev, ovl.vol_id);
 	return 0;
 }
 
-static int probe_ocfs2(int fd __BLKID_ATTR((unused)), 
-		       blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_ocfs2(int fd __BLKID_ATTR((unused)),
+		       blkid_cache cache __BLKID_ATTR((unused)),
 		       blkid_dev dev,
-		       const struct blkid_magic *id __BLKID_ATTR((unused)), 
+		       const struct blkid_magic *id __BLKID_ATTR((unused)),
 		       unsigned char *buf)
 {
 	struct ocfs2_super_block *osb;
@@ -436,10 +436,10 @@ static int probe_ocfs2(int fd __BLKID_ATTR((unused)),
 	return 0;
 }
 
-static int probe_oracleasm(int fd __BLKID_ATTR((unused)), 
-			   blkid_cache cache __BLKID_ATTR((unused)), 
+static int probe_oracleasm(int fd __BLKID_ATTR((unused)),
+			   blkid_cache cache __BLKID_ATTR((unused)),
 			   blkid_dev dev,
-			   const struct blkid_magic *id __BLKID_ATTR((unused)), 
+			   const struct blkid_magic *id __BLKID_ATTR((unused)),
 			   unsigned char *buf)
 {
 	struct oracle_asm_disk_label *dl;
@@ -548,13 +548,13 @@ blkid_dev blkid_verify(blkid_cache cache, blkid_dev dev)
 	diff = now - dev->bid_time;
 
 	if ((now < dev->bid_time) ||
-	    (diff < BLKID_PROBE_MIN) || 
+	    (diff < BLKID_PROBE_MIN) ||
 	    (dev->bid_flags & BLKID_BID_FL_VERIFIED &&
 	     diff < BLKID_PROBE_INTERVAL))
 		return dev;
 
 	DBG(DEBUG_PROBE,
-	    printf("need to revalidate %s (time since last check %lu)\n", 
+	    printf("need to revalidate %s (time since last check %lu)\n",
 		   dev->bid_name, diff));
 
 	if (((fd = open(dev->bid_name, O_RDONLY)) < 0) ||
@@ -571,12 +571,12 @@ blkid_dev blkid_verify(blkid_cache cache, blkid_dev dev)
 	}
 
 	memset(bufs, 0, sizeof(bufs));
-	
+
 	/*
 	 * Iterate over the type array.  If we already know the type,
 	 * then try that first.  If it doesn't work, then blow away
 	 * the type information, and try again.
-	 * 
+	 *
 	 */
 try_again:
 	type = 0;
@@ -637,7 +637,7 @@ try_again:
 		blkid_free_dev(dev);
 		return NULL;
 	}
-		
+
 found_type:
 	if (dev && type) {
 		dev->bid_devno = st.st_rdev;
@@ -646,7 +646,7 @@ found_type:
 		cache->bic_flags |= BLKID_BIC_FL_CHANGED;
 
 		blkid_set_tag(dev, "TYPE", type, 0);
-				
+
 		DBG(DEBUG_PROBE, printf("%s: devno 0x%04Lx, type %s\n",
 			   dev->bid_name, st.st_rdev, type));
 	}
@@ -696,7 +696,7 @@ int main(int argc, char **argv)
 		printf("\tlabel is '%s'\n", dev->bid_label);
 	if (dev->bid_uuid)
 		printf("\tuuid is %s\n", dev->bid_uuid);
-	
+
 	blkid_free_dev(dev);
 	return (0);
 }
diff --git a/e2fsprogs/blkid/probe.h b/e2fsprogs/blkid/probe.h
index 10af5d518..530b8efe2 100644
--- a/e2fsprogs/blkid/probe.h
+++ b/e2fsprogs/blkid/probe.h
@@ -18,7 +18,7 @@
 
 struct blkid_magic;
 
-typedef int (*blkid_probe_t)(int fd, blkid_cache cache, blkid_dev dev, 
+typedef int (*blkid_probe_t)(int fd, blkid_cache cache, blkid_dev dev,
 			     const struct blkid_magic *id, unsigned char *buf);
 
 struct blkid_magic {
@@ -222,16 +222,16 @@ struct ocfs_volume_header {
 
 struct ocfs_volume_label {
 	unsigned char	disk_lock[48];
-	unsigned char	label[64];	
+	unsigned char	label[64];
 	unsigned char	label_len[2];
 	unsigned char  vol_id[16];
 	unsigned char  vol_id_len[2];
 };
 
 #define ocfsmajor(o) ((__u32)o.major_version[0] \
-                   + (((__u32) o.major_version[1]) << 8) \
-                   + (((__u32) o.major_version[2]) << 16) \
-                   + (((__u32) o.major_version[3]) << 24))
+		   + (((__u32) o.major_version[1]) << 8) \
+		   + (((__u32) o.major_version[2]) << 16) \
+		   + (((__u32) o.major_version[3]) << 24))
 #define ocfslabellen(o)	((__u32)o.label_len[0] + (((__u32) o.label_len[1]) << 8))
 #define ocfsmountlen(o)	((__u32)o.mount_len[0] + (((__u32) o.mount_len[1])<<8))
 
@@ -334,7 +334,7 @@ _INLINE_ __u64 blkid_swab64(__u64 val)
 	return (blkid_swab32(val >> 32) |
 		(((__u64) blkid_swab32(val & 0xFFFFFFFFUL)) << 32));
 }
-#endif 
+#endif
 
 
 
diff --git a/e2fsprogs/blkid/read.c b/e2fsprogs/blkid/read.c
index 78464145d..08a3162f3 100644
--- a/e2fsprogs/blkid/read.c
+++ b/e2fsprogs/blkid/read.c
@@ -302,7 +302,7 @@ static int parse_tag(blkid_cache cache, blkid_dev dev, char **cp)
 		return ret;
 
 	/* Some tags are stored directly in the device struct */
-	if (!strcmp(name, "DEVNO")) 
+	if (!strcmp(name, "DEVNO"))
 		dev->bid_devno = STRTOULL(value, 0, 0);
 	else if (!strcmp(name, "PRI"))
 		dev->bid_pri = strtol(value, 0, 0);
@@ -389,7 +389,7 @@ void blkid_read_cache(blkid_cache cache)
 					cache->bic_filename));
 		goto errout;
 	}
-	
+
 	DBG(DEBUG_CACHE, printf("reading cache file %s\n",
 				cache->bic_filename));
 
diff --git a/e2fsprogs/blkid/resolve.c b/e2fsprogs/blkid/resolve.c
index 625782d44..591b63057 100644
--- a/e2fsprogs/blkid/resolve.c
+++ b/e2fsprogs/blkid/resolve.c
@@ -69,7 +69,7 @@ char *blkid_get_devname(blkid_cache cache, const char *token,
 
 	if (!token)
 		return NULL;
-	
+
 	if (!cache) {
 		if (blkid_get_cache(&c, NULL) < 0)
 			return NULL;
@@ -125,7 +125,7 @@ int main(int argc, char **argv)
 		fprintf(stderr, "Couldn't get blkid cache\n");
 		exit(1);
 	}
-	
+
 	if (argv[2]) {
 		value = blkid_get_tag_value(cache, argv[1], argv[2]);
 		printf("%s has tag %s=%s\n", argv[2], argv[1],
diff --git a/e2fsprogs/blkid/save.c b/e2fsprogs/blkid/save.c
index 3fba2450a..cc406ebfb 100644
--- a/e2fsprogs/blkid/save.c
+++ b/e2fsprogs/blkid/save.c
@@ -176,7 +176,7 @@ int main(int argc, char **argv)
 		exit(1);
 	}
 	cache->bic_filename = blkid_strdup(argv[1]);
-	
+
 	if ((ret = blkid_flush_cache(cache)) < 0) {
 		fprintf(stderr, "error (%d) saving cache\n", ret);
 		exit(1);
diff --git a/e2fsprogs/blkid/tag.c b/e2fsprogs/blkid/tag.c
index 699d0fb46..e2c785cf0 100644
--- a/e2fsprogs/blkid/tag.c
+++ b/e2fsprogs/blkid/tag.c
@@ -96,7 +96,7 @@ static blkid_tag blkid_find_head_cache(blkid_cache cache, const char *type)
 
 /*
  * Set a tag on an existing device.
- * 
+ *
  * If value is NULL, then delete the tagsfrom the device.
  */
 int blkid_set_tag(blkid_dev dev, const char *name,
@@ -131,7 +131,7 @@ int blkid_set_tag(blkid_dev dev, const char *name,
 		t->bit_dev = dev;
 
 		list_add_tail(&t->bit_tags, &dev->bid_tags);
-		
+
 		if (dev->bid_cache) {
 			head = blkid_find_head_cache(dev->bid_cache,
 						     t->bit_name);
@@ -151,7 +151,7 @@ int blkid_set_tag(blkid_dev dev, const char *name,
 			list_add_tail(&t->bit_names, &head->bit_names);
 		}
 	}
-	
+
 	/* Link common tags directly to the device struct */
 	if (!strcmp(name, "TYPE"))
 		dev->bid_type = val;
@@ -159,7 +159,7 @@ int blkid_set_tag(blkid_dev dev, const char *name,
 		dev->bid_label = val;
 	else if (!strcmp(name, "UUID"))
 		dev->bid_uuid = val;
-		
+
 	if (dev->bid_cache)
 		dev->bid_cache->bic_flags |= BLKID_BIC_FL_CHANGED;
 	return 0;
@@ -235,7 +235,7 @@ errout:
  * This series of functions iterate over all tags in a device
  */
 #define TAG_ITERATE_MAGIC	0x01a5284c
-	
+
 struct blkid_struct_tag_iterate {
 	int			magic;
 	blkid_dev		dev;
@@ -260,7 +260,7 @@ extern int blkid_tag_next(blkid_tag_iterate iter,
 			  const char **type, const char **value)
 {
 	blkid_tag tag;
-	
+
 	*type = 0;
 	*value = 0;
 	if (!iter || iter->magic != TAG_ITERATE_MAGIC ||
@@ -303,9 +303,9 @@ extern blkid_dev blkid_find_dev_with_tag(blkid_cache cache,
 		return NULL;
 
 	blkid_read_cache(cache);
-	
+
 	DBG(DEBUG_TAG, printf("looking for %s=%s in cache\n", type, value));
-	
+
 try_again:
 	pri = -1;
 	dev = 0;
@@ -313,7 +313,7 @@ try_again:
 
 	if (head) {
 		list_for_each(p, &head->bit_names) {
-			blkid_tag tmp = list_entry(p, struct blkid_struct_tag, 
+			blkid_tag tmp = list_entry(p, struct blkid_struct_tag,
 						   bit_names);
 
 			if (!strcmp(tmp->bit_val, value) &&
diff --git a/e2fsprogs/chattr.c b/e2fsprogs/chattr.c
index 66838e642..c39003821 100644
--- a/e2fsprogs/chattr.c
+++ b/e2fsprogs/chattr.c
@@ -161,8 +161,8 @@ skip_setflags:
 		iterate_on_dir(name, chattr_dir_proc, NULL);
 }
 
-static int chattr_dir_proc(const char *dir_name, struct dirent *de, 
-                           void *private EXT2FS_ATTR((unused)))
+static int chattr_dir_proc(const char *dir_name, struct dirent *de,
+			   void *private EXT2FS_ATTR((unused)))
 {
 	/*if (strcmp(de->d_name, ".") && strcmp(de->d_name, "..")) {*/
 	if (de->d_name[0] == '.' && (de->d_name[1] == '\0' || \
diff --git a/e2fsprogs/e2fsck.c b/e2fsprogs/e2fsck.c
index b31b19414..1c97cf4bb 100644
--- a/e2fsprogs/e2fsck.c
+++ b/e2fsprogs/e2fsck.c
@@ -11797,8 +11797,8 @@ static int count_tags(struct buffer_head *bh, int size)
 
 
 /* Make sure we wrap around the log correctly! */
-#define wrap(journal, var)                                              \
-do {                                                                    \
+#define wrap(journal, var)					      \
+do {					                            \
 	if (var >= (journal)->j_last)                                   \
 		var -= ((journal)->j_last - (journal)->j_first);        \
 } while (0)
diff --git a/e2fsprogs/e2p/feature.c b/e2fsprogs/e2p/feature.c
index fe6016102..0a9058384 100644
--- a/e2fsprogs/e2p/feature.c
+++ b/e2fsprogs/e2p/feature.c
@@ -1,11 +1,11 @@
 /*
  * feature.c --- convert between features and strings
- * 
+ *
  * Copyright (C) 1999  Theodore Ts'o <tytso@mit.edu>
- * 
+ *
  * This file can be redistributed under the terms of the GNU Library General
  * Public License
- * 
+ *
  */
 
 #include <stdio.h>
diff --git a/e2fsprogs/e2p/fgetsetversion.c b/e2fsprogs/e2p/fgetsetversion.c
index dcf127c26..8227ab3be 100644
--- a/e2fsprogs/e2p/fgetsetversion.c
+++ b/e2fsprogs/e2p/fgetsetversion.c
@@ -33,11 +33,11 @@
 #define OPEN_FLAGS (O_RDONLY|O_NONBLOCK)
 #endif
 
-/* 
+/*
    To do fsetversion:     unsigned long *ptr_version must be set to NULL.
-                      and unsigned long version must be set to a value   
+		      and unsigned long version must be set to a value
    To do fgetversion:     unsigned long *ptr_version must NOT be set to NULL
-                      and unsigned long version is ignored.
+		      and unsigned long version is ignored.
 	TITO.
 */
 
diff --git a/e2fsprogs/e2p/hashstr.c b/e2fsprogs/e2p/hashstr.c
index c4b3f9fd5..705f63ae0 100644
--- a/e2fsprogs/e2p/hashstr.c
+++ b/e2fsprogs/e2p/hashstr.c
@@ -1,11 +1,11 @@
 /*
  * feature.c --- convert between features and strings
- * 
+ *
  * Copyright (C) 1999  Theodore Ts'o <tytso@mit.edu>
- * 
+ *
  * This file can be redistributed under the terms of the GNU Library General
  * Public License
- * 
+ *
  */
 
 #include <stdio.h>
diff --git a/e2fsprogs/e2p/ls.c b/e2fsprogs/e2p/ls.c
index 71f8f5126..0c91345e1 100644
--- a/e2fsprogs/e2p/ls.c
+++ b/e2fsprogs/e2p/ls.c
@@ -6,7 +6,7 @@
  *                                 Universite Pierre et Marie Curie (Paris VI)
  *
  * Copyright (C) 1995, 1996, 1997  Theodore Ts'o <tytso@mit.edu>
- * 
+ *
  * This file can be redistributed under the terms of the GNU Library General
  * Public License
  */
@@ -190,11 +190,11 @@ void list_super2(struct ext2_super_block * sb, FILE *f)
 		"Block size:               %u\n"
 		"Fragment size:            %u\n",
 		str, sb->s_inodes_count, sb->s_blocks_count, sb->s_r_blocks_count,
-		sb->s_free_blocks_count, sb->s_free_inodes_count, 
+		sb->s_free_blocks_count, sb->s_free_inodes_count,
 		sb->s_first_data_block, EXT2_BLOCK_SIZE(sb), EXT2_FRAG_SIZE(sb));
 	free(str);
 	if (sb->s_reserved_gdt_blocks)
-		fprintf(f, "Reserved GDT blocks:      %u\n", 
+		fprintf(f, "Reserved GDT blocks:      %u\n",
 			sb->s_reserved_gdt_blocks);
 	fprintf(f,
 		"Blocks per group:         %u\n"
diff --git a/e2fsprogs/e2p/mntopts.c b/e2fsprogs/e2p/mntopts.c
index 562a9ccc1..b27f78ed9 100644
--- a/e2fsprogs/e2p/mntopts.c
+++ b/e2fsprogs/e2p/mntopts.c
@@ -1,11 +1,11 @@
 /*
  * mountopts.c --- convert between default mount options and strings
- * 
+ *
  * Copyright (C) 2002  Theodore Ts'o <tytso@mit.edu>
- * 
+ *
  * This file can be redistributed under the terms of the GNU Library General
  * Public License
- * 
+ *
  */
 
 #include <stdio.h>
diff --git a/e2fsprogs/e2p/ostype.c b/e2fsprogs/e2p/ostype.c
index 1084abde2..46230631e 100644
--- a/e2fsprogs/e2p/ostype.c
+++ b/e2fsprogs/e2p/ostype.c
@@ -11,10 +11,10 @@
 #include <string.h>
 
 static const char * const os_tab[] =
-	{ "Linux", 
-	  "Hurd", 
-	  "Masix", 
-	  "FreeBSD", 
+	{ "Linux",
+	  "Hurd",
+	  "Masix",
+	  "FreeBSD",
 	  "Lites",
 	  0 };
 
@@ -53,7 +53,7 @@ int e2p_string2os(char *str)
 #ifdef TEST_PROGRAM
 int main(int argc, char **argv)
 {
-	char 	*s;
+	char	*s;
 	int	i, os;
 
 	for (i=0; i <= EXT2_OS_LITES; i++) {
diff --git a/e2fsprogs/e2p/parse_num.c b/e2fsprogs/e2p/parse_num.c
index 3910e70de..81c160544 100644
--- a/e2fsprogs/e2p/parse_num.c
+++ b/e2fsprogs/e2p/parse_num.c
@@ -1,8 +1,8 @@
 /*
- * parse_num.c		- Parse the number of blocks 
+ * parse_num.c		- Parse the number of blocks
  *
  * Copyright (C) 2004,2005  Theodore Ts'o <tytso@mit.edu>
- * 
+ *
  * This file can be redistributed under the terms of the GNU Library General
  * Public License
  */
@@ -18,25 +18,25 @@ unsigned long parse_num_blocks(const char *arg, int log_block_size)
 
 	num = strtoull(arg, &p, 0);
 
-	if (p[0] && p[1]) 
+	if (p[0] && p[1])
 		return 0;
 
 	switch (*p) {		/* Using fall-through logic */
-	case 'T': case 't': 
+	case 'T': case 't':
 		num <<= 10;
-	case 'G': case 'g': 
+	case 'G': case 'g':
 		num <<= 10;
-	case 'M': case 'm': 
+	case 'M': case 'm':
 		num <<= 10;
-	case 'K': case 'k': 
-		num >>= log_block_size; 
+	case 'K': case 'k':
+		num >>= log_block_size;
 		break;
-	case 's': 
+	case 's':
 		num >>= 1;
 		break;
 	case '\0':
 		break;
-	default: 
+	default:
 		return 0;
 	}
 	return num;
diff --git a/e2fsprogs/e2p/pf.c b/e2fsprogs/e2p/pf.c
index 2194ac6bf..da8357a46 100644
--- a/e2fsprogs/e2p/pf.c
+++ b/e2fsprogs/e2p/pf.c
@@ -41,7 +41,7 @@ static const struct flags_name flags_array[] = {
 	{ EXT2_ECOMPR_FL, "E", "Compression_Error" },
 #endif
 	{ EXT3_JOURNAL_DATA_FL, "j", "Journaled_Data" },
-	{ EXT2_INDEX_FL, "I", "Indexed_direcctory" }, 
+	{ EXT2_INDEX_FL, "I", "Indexed_direcctory" },
 	{ EXT2_NOTAIL_FL, "t", "No_Tailmerging" },
 	{ EXT2_TOPDIR_FL, "T", "Top_of_Directory_Hierarchies" },
 	{ 0, NULL, NULL }
diff --git a/e2fsprogs/e2p/uuid.c b/e2fsprogs/e2p/uuid.c
index 9feca4cfa..cb4ec8072 100644
--- a/e2fsprogs/e2p/uuid.c
+++ b/e2fsprogs/e2p/uuid.c
@@ -19,7 +19,7 @@ struct uuid {
 /* Returns 1 if the uuid is the NULL uuid */
 int e2p_is_null_uuid(void *uu)
 {
-	__u8 	*cp;
+	__u8	*cp;
 	int	i;
 
 	for (i=0, cp = uu; i < 16; i++)
@@ -42,7 +42,7 @@ static void e2p_unpack_uuid(void *in, struct uuid *uu)
 	tmp = *ptr++;
 	tmp = (tmp << 8) | *ptr++;
 	uu->time_mid = tmp;
-	
+
 	tmp = *ptr++;
 	tmp = (tmp << 8) | *ptr++;
 	uu->time_hi_and_version = tmp;
diff --git a/e2fsprogs/ext2fs/alloc.c b/e2fsprogs/ext2fs/alloc.c
index 7385123b8..d56ef2566 100644
--- a/e2fsprogs/ext2fs/alloc.c
+++ b/e2fsprogs/ext2fs/alloc.c
@@ -7,7 +7,7 @@
  * This file may be redistributed under the terms of the GNU Public
  * License.
  * %End-Header%
- * 
+ *
  */
 
 #include <stdio.h>
@@ -32,7 +32,7 @@
  *
  * Should have a special policy for directories.
  */
-errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir, 
+errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir,
 			   int mode EXT2FS_ATTR((unused)),
 			   ext2fs_inode_bitmap map, ext2_ino_t *ret)
 {
@@ -41,13 +41,13 @@ errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir,
 	ext2_ino_t	start_inode;
 
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
-	
+
 	if (!map)
 		map = fs->inode_map;
 	if (!map)
 		return EXT2_ET_NO_INODE_BITMAP;
-	
-	if (dir > 0) 
+
+	if (dir > 0)
 		dir_group = (dir - 1) / EXT2_INODES_PER_GROUP(fs->super);
 
 	start_inode = (dir_group * EXT2_INODES_PER_GROUP(fs->super)) + 1;
@@ -62,7 +62,7 @@ errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir,
 		if (i > fs->super->s_inodes_count)
 			i = EXT2_FIRST_INODE(fs->super);
 	} while (i != start_inode);
-	
+
 	if (ext2fs_test_inode_bitmap(map, i))
 		return EXT2_ET_INODE_ALLOC_FAIL;
 	*ret = i;
@@ -131,7 +131,7 @@ errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
 	retval = io_channel_write_blk(fs->io, block, 1, block_buf);
 	if (retval)
 		goto fail;
-	
+
 	ext2fs_block_alloc_stats(fs, block, +1);
 	*ret = block;
 	return 0;
diff --git a/e2fsprogs/ext2fs/alloc_sb.c b/e2fsprogs/ext2fs/alloc_sb.c
index ef40b938f..aa2cd0568 100644
--- a/e2fsprogs/ext2fs/alloc_sb.c
+++ b/e2fsprogs/ext2fs/alloc_sb.c
@@ -1,5 +1,5 @@
 /*
- * alloc_sb.c --- Allocate the superblock and block group descriptors for a 
+ * alloc_sb.c --- Allocate the superblock and block group descriptors for a
  * newly initialized filesystem.  Used by mke2fs when initializing a filesystem
  *
  * Copyright (C) 1994, 1995, 1996, 2003 Theodore Ts'o.
@@ -27,20 +27,20 @@
 #include "ext2_fs.h"
 #include "ext2fs.h"
 
-int ext2fs_reserve_super_and_bgd(ext2_filsys fs, 
+int ext2fs_reserve_super_and_bgd(ext2_filsys fs,
 				 dgrp_t group,
 				 ext2fs_block_bitmap bmap)
 {
 	blk_t	super_blk, old_desc_blk, new_desc_blk;
 	int	j, old_desc_blocks, num_blocks;
 
-	num_blocks = ext2fs_super_and_bgd_loc(fs, group, &super_blk, 
+	num_blocks = ext2fs_super_and_bgd_loc(fs, group, &super_blk,
 					      &old_desc_blk, &new_desc_blk, 0);
 
 	if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG)
 		old_desc_blocks = fs->super->s_first_meta_bg;
 	else
-		old_desc_blocks = 
+		old_desc_blocks =
 			fs->desc_blocks + fs->super->s_reserved_gdt_blocks;
 
 	if (super_blk || (group == 0))
diff --git a/e2fsprogs/ext2fs/alloc_stats.c b/e2fsprogs/ext2fs/alloc_stats.c
index 4088f7b87..32aa0b6bc 100644
--- a/e2fsprogs/ext2fs/alloc_stats.c
+++ b/e2fsprogs/ext2fs/alloc_stats.c
@@ -7,7 +7,7 @@
  * This file may be redistributed under the terms of the GNU Public
  * License.
  * %End-Header%
- * 
+ *
  */
 
 #include <stdio.h>
diff --git a/e2fsprogs/ext2fs/alloc_tables.c b/e2fsprogs/ext2fs/alloc_tables.c
index 0326321be..10f1f95a4 100644
--- a/e2fsprogs/ext2fs/alloc_tables.c
+++ b/e2fsprogs/ext2fs/alloc_tables.c
@@ -36,14 +36,14 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
 
 	group_blk = fs->super->s_first_data_block +
 		(group * fs->super->s_blocks_per_group);
-	
+
 	last_blk = group_blk + fs->super->s_blocks_per_group;
 	if (last_blk >= fs->super->s_blocks_count)
 		last_blk = fs->super->s_blocks_count - 1;
 
 	if (!bmap)
 		bmap = fs->block_map;
-	
+
 	/*
 	 * Allocate the block and inode bitmaps, if necessary
 	 */
@@ -59,7 +59,7 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
 	if (!fs->group_desc[group].bg_block_bitmap) {
 		retval = ext2fs_get_free_blocks(fs, start_blk, last_blk,
 						1, bmap, &new_blk);
-		if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) 
+		if (retval == EXT2_ET_BLOCK_ALLOC_FAIL)
 			retval = ext2fs_get_free_blocks(fs, group_blk,
 					last_blk, 1, bmap, &new_blk);
 		if (retval)
@@ -71,7 +71,7 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
 	if (!fs->group_desc[group].bg_inode_bitmap) {
 		retval = ext2fs_get_free_blocks(fs, start_blk, last_blk,
 						1, bmap, &new_blk);
-		if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) 
+		if (retval == EXT2_ET_BLOCK_ALLOC_FAIL)
 			retval = ext2fs_get_free_blocks(fs, group_blk,
 					last_blk, 1, bmap, &new_blk);
 		if (retval)
@@ -96,11 +96,11 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
 		fs->group_desc[group].bg_inode_table = new_blk;
 	}
 
-	
+
 	return 0;
 }
 
-	
+
 
 errcode_t ext2fs_allocate_tables(ext2_filsys fs)
 {
diff --git a/e2fsprogs/ext2fs/badblocks.c b/e2fsprogs/ext2fs/badblocks.c
index 4b76ef032..d82041126 100644
--- a/e2fsprogs/ext2fs/badblocks.c
+++ b/e2fsprogs/ext2fs/badblocks.c
@@ -1,6 +1,6 @@
 /*
  * badblocks.c --- routines to manipulate the bad block structure
- * 
+ *
  * Copyright (C) 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -34,7 +34,7 @@ static errcode_t make_u32_list(int size, int num, __u32 *list,
 {
 	ext2_u32_list	bb;
 	errcode_t	retval;
-	
+
 	retval = ext2fs_get_mem(sizeof(struct ext2_struct_u32_list), &bb);
 	if (retval)
 		return retval;
@@ -54,7 +54,7 @@ static errcode_t make_u32_list(int size, int num, __u32 *list,
 	*ret = bb;
 	return 0;
 }
-	
+
 
 /*
  * This procedure creates an empty u32 list.
@@ -79,7 +79,7 @@ errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret, int size)
 errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest)
 {
 	errcode_t	retval;
-	
+
 	retval = make_u32_list(src->size, src->num, src->list, dest);
 	if (retval)
 		return retval;
@@ -271,11 +271,11 @@ int ext2fs_u32_list_iterate(ext2_u32_iterate iter, __u32 *blk)
 
 	if (bb->magic != EXT2_ET_MAGIC_BADBLOCKS_LIST)
 		return 0;
-	
+
 	if (iter->ptr < bb->num) {
 		*blk = bb->list[iter->ptr++];
 		return 1;
-	} 
+	}
 	*blk = 0;
 	return 0;
 }
diff --git a/e2fsprogs/ext2fs/bb_compat.c b/e2fsprogs/ext2fs/bb_compat.c
index 40f734368..5a158b34c 100644
--- a/e2fsprogs/ext2fs/bb_compat.c
+++ b/e2fsprogs/ext2fs/bb_compat.c
@@ -1,6 +1,6 @@
 /*
  * bb_compat.c --- compatibility badblocks routines
- * 
+ *
  * Copyright (C) 1997 Theodore Ts'o.
  *
  * %Begin-Header%
diff --git a/e2fsprogs/ext2fs/bb_inode.c b/e2fsprogs/ext2fs/bb_inode.c
index dd8e7c319..9af117d8f 100644
--- a/e2fsprogs/ext2fs/bb_inode.c
+++ b/e2fsprogs/ext2fs/bb_inode.c
@@ -1,12 +1,12 @@
 /*
  * bb_inode.c --- routines to update the bad block inode.
- * 
+ *
  * WARNING: This routine modifies a lot of state in the filesystem; if
  * this routine returns an error, the bad block inode may be in an
  * inconsistent state.
- * 
+ *
  * Copyright (C) 1994, 1995 Theodore Ts'o.
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
@@ -49,7 +49,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
 				e2_blkcnt_t blockcnt,
 				blk_t ref_block, int ref_offset,
 				void *priv_data);
-	
+
 /*
  * Given a bad blocks bitmap, update the bad blocks inode to reflect
  * the map.
@@ -57,14 +57,14 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
 errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 {
 	errcode_t			retval;
-	struct set_badblock_record 	rec;
+	struct set_badblock_record	rec;
 	struct ext2_inode		inode;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	if (!fs->block_map)
 		return EXT2_ET_NO_BLOCK_BITMAP;
-	
+
 	rec.bad_block_count = 0;
 	rec.ind_blocks_size = rec.ind_blocks_ptr = 0;
 	rec.max_ind_blocks = 10;
@@ -78,9 +78,9 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 		goto cleanup;
 	memset(rec.block_buf, 0, fs->blocksize);
 	rec.err = 0;
-	
+
 	/*
-	 * First clear the old bad blocks (while saving the indirect blocks) 
+	 * First clear the old bad blocks (while saving the indirect blocks)
 	 */
 	retval = ext2fs_block_iterate2(fs, EXT2_BAD_INO,
 				       BLOCK_FLAG_DEPTH_TRAVERSE, 0,
@@ -91,7 +91,7 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 		retval = rec.err;
 		goto cleanup;
 	}
-	
+
 	/*
 	 * Now set the bad blocks!
 	 *
@@ -108,22 +108,22 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 					       BLOCK_FLAG_APPEND, 0,
 					       set_bad_block_proc, &rec);
 		ext2fs_badblocks_list_iterate_end(rec.bb_iter);
-		if (retval) 
+		if (retval)
 			goto cleanup;
 		if (rec.err) {
 			retval = rec.err;
 			goto cleanup;
 		}
 	}
-	
+
 	/*
 	 * Update the bad block inode's mod time and block count
-	 * field.  
+	 * field.
 	 */
 	retval = ext2fs_read_inode(fs, EXT2_BAD_INO, &inode);
 	if (retval)
 		goto cleanup;
-	
+
 	inode.i_atime = inode.i_mtime = time(0);
 	if (!inode.i_ctime)
 		inode.i_ctime = time(0);
@@ -133,7 +133,7 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
 	retval = ext2fs_write_inode(fs, EXT2_BAD_INO, &inode);
 	if (retval)
 		goto cleanup;
-	
+
 cleanup:
 	ext2fs_free_mem(&rec.ind_blocks);
 	ext2fs_free_mem(&rec.block_buf);
@@ -158,7 +158,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
 	struct set_badblock_record *rec = (struct set_badblock_record *)
 		priv_data;
 	errcode_t	retval;
-	unsigned long 	old_size;
+	unsigned long	old_size;
 
 	if (!*block_nr)
 		return 0;
@@ -176,7 +176,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
 		if (rec->ind_blocks_size >= rec->max_ind_blocks) {
 			old_size = rec->max_ind_blocks * sizeof(blk_t);
 			rec->max_ind_blocks += 10;
-			retval = ext2fs_resize_mem(old_size, 
+			retval = ext2fs_resize_mem(old_size,
 				   rec->max_ind_blocks * sizeof(blk_t),
 				   &rec->ind_blocks);
 			if (retval) {
@@ -192,12 +192,12 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
 	 * Mark the block as unused, and update accounting information
 	 */
 	ext2fs_block_alloc_stats(fs, *block_nr, -1);
-	
+
 	*block_nr = 0;
 	return BLOCK_CHANGED;
 }
 
-	
+
 /*
  * Helper function for update_bb_inode()
  *
@@ -250,12 +250,12 @@ static int set_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
 			return BLOCK_ABORT;
 		}
 	}
-	
+
 	/*
 	 * Update block counts
 	 */
 	ext2fs_block_alloc_stats(fs, blk, +1);
-	
+
 	*block_nr = blk;
 	return BLOCK_CHANGED;
 }
diff --git a/e2fsprogs/ext2fs/bitmaps.c b/e2fsprogs/ext2fs/bitmaps.c
index 7edd28d7b..932c345fa 100644
--- a/e2fsprogs/ext2fs/bitmaps.c
+++ b/e2fsprogs/ext2fs/bitmaps.c
@@ -35,7 +35,7 @@ static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end,
 	errcode_t		retval;
 	size_t			size;
 
-	retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap), 
+	retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap),
 				&bitmap);
 	if (retval)
 		return retval;
@@ -106,7 +106,7 @@ void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map)
 		ext2fs_set_bit(j, map->bitmap);
 
 	return;
-}	
+}
 
 errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
 				       const char *descr,
@@ -128,11 +128,11 @@ errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
 						descr, &bitmap);
 	if (retval)
 		return retval;
-	
+
 	bitmap->magic = EXT2_ET_MAGIC_INODE_BITMAP;
 	bitmap->fs = fs;
 	bitmap->base_error_code = EXT2_ET_BAD_INODE_MARK;
-	
+
 	*ret = bitmap;
 	return 0;
 }
@@ -151,9 +151,9 @@ errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
 
 	start = fs->super->s_first_data_block;
 	end = fs->super->s_blocks_count-1;
-	real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)  
+	real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)
 		    * fs->group_desc_count)-1 + start;
-	
+
 	retval = ext2fs_allocate_generic_bitmap(start, end, real_end,
 						descr, &bitmap);
 	if (retval)
@@ -162,7 +162,7 @@ errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
 	bitmap->magic = EXT2_ET_MAGIC_BLOCK_BITMAP;
 	bitmap->fs = fs;
 	bitmap->base_error_code = EXT2_ET_BAD_BLOCK_MARK;
-	
+
 	*ret = bitmap;
 	return 0;
 }
@@ -171,7 +171,7 @@ errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
 					ext2_ino_t end, ext2_ino_t *oend)
 {
 	EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_INODE_BITMAP);
-	
+
 	if (end > bitmap->real_end)
 		return EXT2_ET_FUDGE_INODE_BITMAP_END;
 	if (oend)
@@ -184,7 +184,7 @@ errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
 					blk_t end, blk_t *oend)
 {
 	EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_BLOCK_BITMAP);
-	
+
 	if (end > bitmap->real_end)
 		return EXT2_ET_FUDGE_BLOCK_BITMAP_END;
 	if (oend)
diff --git a/e2fsprogs/ext2fs/bitops.c b/e2fsprogs/ext2fs/bitops.c
index 207c44d92..e44e10cf4 100644
--- a/e2fsprogs/ext2fs/bitops.c
+++ b/e2fsprogs/ext2fs/bitops.c
@@ -1,7 +1,7 @@
 /*
  * bitops.c --- Bitmap frobbing code.  See bitops.h for the inlined
- * 	routines.
- * 
+ *	routines.
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
diff --git a/e2fsprogs/ext2fs/bitops.h b/e2fsprogs/ext2fs/bitops.h
index b6446efa2..4dba050c8 100644
--- a/e2fsprogs/ext2fs/bitops.h
+++ b/e2fsprogs/ext2fs/bitops.h
@@ -1,14 +1,14 @@
 /*
  * bitops.h --- Bitmap frobbing code.  The byte swapping routines are
- * 	also included here.
- * 
+ *	also included here.
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
  * %End-Header%
- * 
+ *
  * i386 bitops operations taken from <asm/bitops.h>, Copyright 1992,
  * Linus Torvalds.
  */
diff --git a/e2fsprogs/ext2fs/block.c b/e2fsprogs/ext2fs/block.c
index 7685680df..18be2a5e8 100644
--- a/e2fsprogs/ext2fs/block.c
+++ b/e2fsprogs/ext2fs/block.c
@@ -1,6 +1,6 @@
 /*
  * block.c --- iterate over all blocks in an inode
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -59,7 +59,7 @@ static int block_iterate_ind(blk_t *ind_block, blk_t ref_block,
 		ret |= BLOCK_ERROR;
 		return ret;
 	}
-	ctx->errcode = ext2fs_read_ind_block(ctx->fs, *ind_block, 
+	ctx->errcode = ext2fs_read_ind_block(ctx->fs, *ind_block,
 					     ctx->ind_buf);
 	if (ctx->errcode) {
 		ret |= BLOCK_ERROR;
@@ -71,7 +71,7 @@ static int block_iterate_ind(blk_t *ind_block, blk_t ref_block,
 	if (ctx->flags & BLOCK_FLAG_APPEND) {
 		for (i = 0; i < limit; i++, ctx->bcount++, block_nr++) {
 			flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount,
-					     *ind_block, offset, 
+					     *ind_block, offset,
 					     ctx->priv_data);
 			changed	|= flags;
 			if (flags & BLOCK_ABORT) {
@@ -85,7 +85,7 @@ static int block_iterate_ind(blk_t *ind_block, blk_t ref_block,
 			if (*block_nr == 0)
 				continue;
 			flags = (*ctx->func)(ctx->fs, block_nr, ctx->bcount,
-					     *ind_block, offset, 
+					     *ind_block, offset,
 					     ctx->priv_data);
 			changed	|= flags;
 			if (flags & BLOCK_ABORT) {
@@ -109,7 +109,7 @@ static int block_iterate_ind(blk_t *ind_block, blk_t ref_block,
 				    ref_offset, ctx->priv_data);
 	return ret;
 }
-	
+
 static int block_iterate_dind(blk_t *dind_block, blk_t ref_block,
 			      int ref_offset, struct block_context *ctx)
 {
@@ -133,7 +133,7 @@ static int block_iterate_dind(blk_t *dind_block, blk_t ref_block,
 		ret |= BLOCK_ERROR;
 		return ret;
 	}
-	ctx->errcode = ext2fs_read_ind_block(ctx->fs, *dind_block, 
+	ctx->errcode = ext2fs_read_ind_block(ctx->fs, *dind_block,
 					     ctx->dind_buf);
 	if (ctx->errcode) {
 		ret |= BLOCK_ERROR;
@@ -185,7 +185,7 @@ static int block_iterate_dind(blk_t *dind_block, blk_t ref_block,
 				    ref_offset, ctx->priv_data);
 	return ret;
 }
-	
+
 static int block_iterate_tind(blk_t *tind_block, blk_t ref_block,
 			      int ref_offset, struct block_context *ctx)
 {
@@ -209,7 +209,7 @@ static int block_iterate_tind(blk_t *tind_block, blk_t ref_block,
 		ret |= BLOCK_ERROR;
 		return ret;
 	}
-	ctx->errcode = ext2fs_read_ind_block(ctx->fs, *tind_block, 
+	ctx->errcode = ext2fs_read_ind_block(ctx->fs, *tind_block,
 					     ctx->tind_buf);
 	if (ctx->errcode) {
 		ret |= BLOCK_ERROR;
@@ -259,10 +259,10 @@ static int block_iterate_tind(blk_t *tind_block, blk_t ref_block,
 		ret |= (*ctx->func)(ctx->fs, tind_block,
 				    BLOCK_COUNT_TIND, ref_block,
 				    ref_offset, ctx->priv_data);
-	
+
 	return ret;
 }
-	
+
 errcode_t ext2fs_block_iterate2(ext2_filsys fs,
 				ext2_ino_t ino,
 				int	flags,
@@ -338,7 +338,7 @@ errcode_t ext2fs_block_iterate2(ext2_filsys fs,
 				goto abort_exit;
 		}
 	}
-	
+
 	/*
 	 * Iterate over normal data blocks
 	 */
@@ -427,7 +427,7 @@ errcode_t ext2fs_block_iterate(ext2_filsys fs,
 			       void *priv_data)
 {
 	struct xlate xl;
-	
+
 	xl.real_private = priv_data;
 	xl.func = func;
 
diff --git a/e2fsprogs/ext2fs/bmap.c b/e2fsprogs/ext2fs/bmap.c
index e84004476..45d49f929 100644
--- a/e2fsprogs/ext2fs/bmap.c
+++ b/e2fsprogs/ext2fs/bmap.c
@@ -25,14 +25,14 @@
 #endif
 
 extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino,
-			     struct ext2_inode *inode, 
+			     struct ext2_inode *inode,
 			     char *block_buf, int bmap_flags,
 			     blk_t block, blk_t *phys_blk);
 
 #define inode_bmap(inode, nr) ((inode)->i_block[(nr)])
 
-static _BMAP_INLINE_ errcode_t block_ind_bmap(ext2_filsys fs, int flags, 
-					      blk_t ind, char *block_buf, 
+static _BMAP_INLINE_ errcode_t block_ind_bmap(ext2_filsys fs, int flags,
+					      blk_t ind, char *block_buf,
 					      int *blocks_alloc,
 					      blk_t nr, blk_t *ret_blk)
 {
@@ -95,17 +95,17 @@ static _BMAP_INLINE_ errcode_t block_ind_bmap(ext2_filsys fs, int flags,
 }
 
 static _BMAP_INLINE_ errcode_t block_dind_bmap(ext2_filsys fs, int flags,
-					       blk_t dind, char *block_buf, 
+					       blk_t dind, char *block_buf,
 					       int *blocks_alloc,
 					       blk_t nr, blk_t *ret_blk)
 {
 	blk_t		b;
 	errcode_t	retval;
 	blk_t		addr_per_block;
-	
+
 	addr_per_block = (blk_t) fs->blocksize >> 2;
 
-	retval = block_ind_bmap(fs, flags & ~BMAP_SET, dind, block_buf, 
+	retval = block_ind_bmap(fs, flags & ~BMAP_SET, dind, block_buf,
 				blocks_alloc, nr / addr_per_block, &b);
 	if (retval)
 		return retval;
@@ -115,17 +115,17 @@ static _BMAP_INLINE_ errcode_t block_dind_bmap(ext2_filsys fs, int flags,
 }
 
 static _BMAP_INLINE_ errcode_t block_tind_bmap(ext2_filsys fs, int flags,
-					       blk_t tind, char *block_buf, 
+					       blk_t tind, char *block_buf,
 					       int *blocks_alloc,
 					       blk_t nr, blk_t *ret_blk)
 {
 	blk_t		b;
 	errcode_t	retval;
 	blk_t		addr_per_block;
-	
+
 	addr_per_block = (blk_t) fs->blocksize >> 2;
 
-	retval = block_dind_bmap(fs, flags & ~BMAP_SET, tind, block_buf, 
+	retval = block_dind_bmap(fs, flags & ~BMAP_SET, tind, block_buf,
 				 blocks_alloc, nr / addr_per_block, &b);
 	if (retval)
 		return retval;
@@ -179,7 +179,7 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode,
 
 		*phys_blk = inode_bmap(inode, block);
 		b = block ? inode_bmap(inode, block-1) : 0;
-		
+
 		if ((*phys_blk == 0) && (bmap_flags & BMAP_ALLOC)) {
 			retval = ext2fs_alloc_block(fs, b, block_buf, &b);
 			if (retval)
@@ -190,7 +190,7 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode,
 		}
 		goto done;
 	}
-	
+
 	/* Indirect block */
 	block -= EXT2_NDIR_BLOCKS;
 	if (block < addr_per_block) {
@@ -203,17 +203,17 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode,
 			}
 
 			b = inode_bmap(inode, EXT2_IND_BLOCK-1);
- 			retval = ext2fs_alloc_block(fs, b, block_buf, &b);
+			retval = ext2fs_alloc_block(fs, b, block_buf, &b);
 			if (retval)
 				goto done;
 			inode_bmap(inode, EXT2_IND_BLOCK) = b;
 			blocks_alloc++;
 		}
-		retval = block_ind_bmap(fs, bmap_flags, b, block_buf, 
+		retval = block_ind_bmap(fs, bmap_flags, b, block_buf,
 					&blocks_alloc, block, phys_blk);
 		goto done;
 	}
-	
+
 	/* Doubly indirect block  */
 	block -= addr_per_block;
 	if (block < addr_per_block * addr_per_block) {
@@ -226,13 +226,13 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode,
 			}
 
 			b = inode_bmap(inode, EXT2_IND_BLOCK);
- 			retval = ext2fs_alloc_block(fs, b, block_buf, &b);
+			retval = ext2fs_alloc_block(fs, b, block_buf, &b);
 			if (retval)
 				goto done;
 			inode_bmap(inode, EXT2_DIND_BLOCK) = b;
 			blocks_alloc++;
 		}
-		retval = block_dind_bmap(fs, bmap_flags, b, block_buf, 
+		retval = block_dind_bmap(fs, bmap_flags, b, block_buf,
 					 &blocks_alloc, block, phys_blk);
 		goto done;
 	}
@@ -254,7 +254,7 @@ errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode,
 		inode_bmap(inode, EXT2_TIND_BLOCK) = b;
 		blocks_alloc++;
 	}
-	retval = block_tind_bmap(fs, bmap_flags, b, block_buf, 
+	retval = block_tind_bmap(fs, bmap_flags, b, block_buf,
 				 &blocks_alloc, block, phys_blk);
 done:
 	if (buf)
diff --git a/e2fsprogs/ext2fs/bmove.c b/e2fsprogs/ext2fs/bmove.c
index 0b2ebb183..fb319f8c3 100644
--- a/e2fsprogs/ext2fs/bmove.c
+++ b/e2fsprogs/ext2fs/bmove.c
@@ -1,6 +1,6 @@
 /*
  * bmove.c --- Move blocks around to make way for a particular
- * 	filesystem structure.
+ *	filesystem structure.
  *
  * Copyright (C) 1997 Theodore Ts'o.  This file may be redistributed
  * under the terms of the GNU Public License.
@@ -44,7 +44,7 @@ static int process_block(ext2_filsys fs, blk_t	*block_nr,
 	pb = (struct process_block_struct *) priv_data;
 	block = orig = *block_nr;
 	ret = 0;
-	
+
 	/*
 	 * Let's see if this is one which we need to relocate
 	 */
@@ -98,7 +98,7 @@ errcode_t ext2fs_move_blocks(ext2_filsys fs,
 	struct process_block_struct pb;
 	ext2_inode_scan	scan;
 	char		*block_buf;
-	
+
 	retval = ext2fs_open_inode_scan(fs, 0, &scan);
 	if (retval)
 		return retval;
@@ -107,7 +107,7 @@ errcode_t ext2fs_move_blocks(ext2_filsys fs,
 	pb.error = 0;
 	pb.alloc_map = alloc_map ? alloc_map : fs->block_map;
 	pb.flags = flags;
-	
+
 	retval = ext2fs_get_mem(fs->blocksize * 4, &block_buf);
 	if (retval)
 		return retval;
@@ -131,12 +131,12 @@ errcode_t ext2fs_move_blocks(ext2_filsys fs,
 	retval = ext2fs_get_next_inode(scan, &ino, &inode);
 	if (retval)
 		return retval;
-	
+
 	while (ino) {
 		if ((inode.i_links_count == 0) ||
 		    !ext2fs_inode_has_valid_blocks(&inode))
 			goto next;
-		
+
 		pb.ino = ino;
 		pb.inode = &inode;
 
diff --git a/e2fsprogs/ext2fs/brel.h b/e2fsprogs/ext2fs/brel.h
index be97243ca..a7f977658 100644
--- a/e2fsprogs/ext2fs/brel.h
+++ b/e2fsprogs/ext2fs/brel.h
@@ -1,6 +1,6 @@
 /*
  * brel.h
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -47,7 +47,7 @@ struct ext2_block_relocation_table {
 	 * Initialize for iterating over the block relocation entries.
 	 */
 	errcode_t (*start_iter)(ext2_brel brel);
-	
+
 	/*
 	 * The iterator function for the inode relocation entries.
 	 * Returns an inode number of 0 when out of entries.
diff --git a/e2fsprogs/ext2fs/brel_ma.c b/e2fsprogs/ext2fs/brel_ma.c
index d422bb2e9..4dcfded37 100644
--- a/e2fsprogs/ext2fs/brel_ma.c
+++ b/e2fsprogs/ext2fs/brel_ma.c
@@ -1,6 +1,6 @@
 /*
  * brel_ma.c
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * TODO: rewrite to not use a direct array!!!  (Fortunately this
@@ -48,7 +48,7 @@ errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block,
 {
 	ext2_brel		brel = 0;
 	errcode_t	retval;
-	struct brel_ma 	*ma = 0;
+	struct brel_ma	*ma = 0;
 	size_t		size;
 
 	*new_brel = 0;
@@ -61,18 +61,18 @@ errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block,
 	if (retval)
 		goto errout;
 	memset(brel, 0, sizeof(struct ext2_block_relocation_table));
-	
+
 	retval = ext2fs_get_mem(strlen(name)+1, &brel->name);
 	if (retval)
 		goto errout;
 	strcpy(brel->name, name);
-	
+
 	retval = ext2fs_get_mem(sizeof(struct brel_ma), &ma);
 	if (retval)
 		goto errout;
 	memset(ma, 0, sizeof(struct brel_ma));
 	brel->priv_data = ma;
-	
+
 	size = (size_t) (sizeof(struct ext2_block_relocate_entry) *
 			 (max_block+1));
 	retval = ext2fs_get_mem(size, &ma->entries);
@@ -91,7 +91,7 @@ errcode_t ext2fs_brel_memarray_create(char *name, blk_t max_block,
 	brel->move = bma_move;
 	brel->delete = bma_delete;
 	brel->free = bma_free;
-	
+
 	*new_brel = brel;
 	return 0;
 
@@ -103,7 +103,7 @@ errout:
 static errcode_t bma_put(ext2_brel brel, blk_t old,
 			struct ext2_block_relocate_entry *ent)
 {
-	struct brel_ma 	*ma;
+	struct brel_ma	*ma;
 
 	ma = brel->priv_data;
 	if (old > ma->max_block)
@@ -115,7 +115,7 @@ static errcode_t bma_put(ext2_brel brel, blk_t old,
 static errcode_t bma_get(ext2_brel brel, blk_t old,
 			struct ext2_block_relocate_entry *ent)
 {
-	struct brel_ma 	*ma;
+	struct brel_ma	*ma;
 
 	ma = brel->priv_data;
 	if (old > ma->max_block)
@@ -135,7 +135,7 @@ static errcode_t bma_start_iter(ext2_brel brel)
 static errcode_t bma_next(ext2_brel brel, blk_t *old,
 			  struct ext2_block_relocate_entry *ent)
 {
-	struct brel_ma 	*ma;
+	struct brel_ma	*ma;
 
 	ma = brel->priv_data;
 	while (++brel->current < ma->max_block) {
@@ -151,7 +151,7 @@ static errcode_t bma_next(ext2_brel brel, blk_t *old,
 
 static errcode_t bma_move(ext2_brel brel, blk_t old, blk_t new)
 {
-	struct brel_ma 	*ma;
+	struct brel_ma	*ma;
 
 	ma = brel->priv_data;
 	if ((old > ma->max_block) || (new > ma->max_block))
@@ -165,7 +165,7 @@ static errcode_t bma_move(ext2_brel brel, blk_t old, blk_t new)
 
 static errcode_t bma_delete(ext2_brel brel, blk_t old)
 {
-	struct brel_ma 	*ma;
+	struct brel_ma	*ma;
 
 	ma = brel->priv_data;
 	if (old > ma->max_block)
@@ -178,7 +178,7 @@ static errcode_t bma_delete(ext2_brel brel, blk_t old)
 
 static errcode_t bma_free(ext2_brel brel)
 {
-	struct brel_ma 	*ma;
+	struct brel_ma	*ma;
 
 	if (!brel)
 		return 0;
diff --git a/e2fsprogs/ext2fs/check_desc.c b/e2fsprogs/ext2fs/check_desc.c
index 2a754c7f6..eab8c7bc8 100644
--- a/e2fsprogs/ext2fs/check_desc.c
+++ b/e2fsprogs/ext2fs/check_desc.c
@@ -1,6 +1,6 @@
 /*
  * check_desc.c --- Check the group descriptors of an ext2 filesystem
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -61,7 +61,7 @@ errcode_t ext2fs_check_desc(ext2_filsys fs)
 		    ((fs->group_desc[i].bg_inode_table +
 		      fs->inode_blocks_per_group) >= next))
 			return EXT2_ET_GDESC_BAD_INODE_TABLE;
-		
+
 		block = next;
 	}
 	return 0;
diff --git a/e2fsprogs/ext2fs/closefs.c b/e2fsprogs/ext2fs/closefs.c
index 23e6332db..da0016b0e 100644
--- a/e2fsprogs/ext2fs/closefs.c
+++ b/e2fsprogs/ext2fs/closefs.c
@@ -1,6 +1,6 @@
 /*
  * closefs.c --- close an ext2 filesystem
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -45,7 +45,7 @@ int ext2fs_bg_has_super(ext2_filsys fs, int group_block)
 	return 0;
 }
 
-int ext2fs_super_and_bgd_loc(ext2_filsys fs, 
+int ext2fs_super_and_bgd_loc(ext2_filsys fs,
 			     dgrp_t group,
 			     blk_t *ret_super_blk,
 			     blk_t *ret_old_desc_blk,
@@ -63,7 +63,7 @@ int ext2fs_super_and_bgd_loc(ext2_filsys fs,
 	if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG)
 		old_desc_blocks = fs->super->s_first_meta_bg;
 	else
-		old_desc_blocks = 
+		old_desc_blocks =
 			fs->desc_blocks + fs->super->s_reserved_gdt_blocks;
 
 	if (group == fs->group_desc_count-1) {
@@ -100,7 +100,7 @@ int ext2fs_super_and_bgd_loc(ext2_filsys fs,
 			numblocks--;
 		}
 	}
-		
+
 	numblocks -= 2 + fs->inode_blocks_per_group;
 
 	if (ret_super_blk)
@@ -188,7 +188,7 @@ static errcode_t write_backup_super(ext2_filsys fs, dgrp_t group,
 				    struct ext2_super_block *super_shadow)
 {
 	dgrp_t	sgrp = group;
-	
+
 	if (sgrp > ((1 << 16) - 1))
 		sgrp = (1 << 16) - 1;
 #ifdef EXT2FS_ENABLE_SWAPFS
@@ -198,7 +198,7 @@ static errcode_t write_backup_super(ext2_filsys fs, dgrp_t group,
 #endif
 		fs->super->s_block_group_nr = sgrp;
 
-	return io_channel_write_blk(fs->io, group_block, -SUPERBLOCK_SIZE, 
+	return io_channel_write_blk(fs->io, group_block, -SUPERBLOCK_SIZE,
 				    super_shadow);
 }
 
@@ -217,7 +217,7 @@ errcode_t ext2fs_flush(ext2_filsys fs)
 	dgrp_t		j;
 	struct ext2_group_desc *s, *t;
 #endif
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	fs_state = fs->super->s_state;
@@ -252,7 +252,7 @@ errcode_t ext2fs_flush(ext2_filsys fs)
 	super_shadow = fs->super;
 	group_shadow = fs->group_desc;
 #endif
-	
+
 	/*
 	 * If this is an external journal device, don't write out the
 	 * block group descriptors or any of the backup superblocks
@@ -289,7 +289,7 @@ errcode_t ext2fs_flush(ext2_filsys fs)
 		blk_t	super_blk, old_desc_blk, new_desc_blk;
 		int	meta_bg;
 
-		ext2fs_super_and_bgd_loc(fs, i, &super_blk, &old_desc_blk, 
+		ext2fs_super_and_bgd_loc(fs, i, &super_blk, &old_desc_blk,
 					 &new_desc_blk, &meta_bg);
 
 		if (!(fs->flags & EXT2_FLAG_MASTER_SB_ONLY) &&i && super_blk) {
@@ -300,7 +300,7 @@ errcode_t ext2fs_flush(ext2_filsys fs)
 		}
 		if (fs->flags & EXT2_FLAG_SUPER_ONLY)
 			continue;
-		if ((old_desc_blk) && 
+		if ((old_desc_blk) &&
 		    (!(fs->flags & EXT2_FLAG_MASTER_SB_ONLY) || (i == 0))) {
 			retval = io_channel_write_blk(fs->io,
 			      old_desc_blk, old_desc_blocks, group_ptr);
@@ -365,7 +365,7 @@ errout:
 errcode_t ext2fs_close(ext2_filsys fs)
 {
 	errcode_t	retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	if (fs->flags & EXT2_FLAG_DIRTY) {
diff --git a/e2fsprogs/ext2fs/cmp_bitmaps.c b/e2fsprogs/ext2fs/cmp_bitmaps.c
index 51cc3d0a5..fa45a4331 100644
--- a/e2fsprogs/ext2fs/cmp_bitmaps.c
+++ b/e2fsprogs/ext2fs/cmp_bitmaps.c
@@ -30,7 +30,7 @@ errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1,
 				      ext2fs_block_bitmap bm2)
 {
 	blk_t	i;
-	
+
 	EXT2_CHECK_MAGIC(bm1, EXT2_ET_MAGIC_BLOCK_BITMAP);
 	EXT2_CHECK_MAGIC(bm2, EXT2_ET_MAGIC_BLOCK_BITMAP);
 
@@ -52,7 +52,7 @@ errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1,
 				      ext2fs_inode_bitmap bm2)
 {
 	ext2_ino_t	i;
-	
+
 	EXT2_CHECK_MAGIC(bm1, EXT2_ET_MAGIC_INODE_BITMAP);
 	EXT2_CHECK_MAGIC(bm2, EXT2_ET_MAGIC_INODE_BITMAP);
 
diff --git a/e2fsprogs/ext2fs/dblist.c b/e2fsprogs/ext2fs/dblist.c
index d5833d728..0cf5698fa 100644
--- a/e2fsprogs/ext2fs/dblist.c
+++ b/e2fsprogs/ext2fs/dblist.c
@@ -1,13 +1,13 @@
 /*
  * dblist.c -- directory block list functions
- * 
+ *
  * Copyright 1997 by Theodore Ts'o
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
  * %End-Header%
- * 
+ *
  */
 
 #include <stdio.h>
@@ -33,7 +33,7 @@ errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs)
 	ext2_ino_t	num_dirs, max_dirs;
 
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
-	
+
 	num_dirs = 0;
 	max_dirs = fs->super->s_inodes_per_group;
 	for (i = 0; i < fs->group_desc_count; i++) {
@@ -88,7 +88,7 @@ static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, ext2_ino_t count,
 	retval = ext2fs_get_mem(len, &dblist->list);
 	if (retval)
 		goto cleanup;
-	
+
 	if (list)
 		memcpy(dblist->list, list, len);
 	else
@@ -155,10 +155,10 @@ errcode_t ext2fs_copy_dblist(ext2_dblist src, ext2_dblist *dest)
 errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino, blk_t blk,
 			       int blockcnt)
 {
-	struct ext2_db_entry 	*new_entry;
+	struct ext2_db_entry	*new_entry;
 	errcode_t		retval;
 	unsigned long		old_size;
-	
+
 	EXT2_CHECK_MAGIC(dblist, EXT2_ET_MAGIC_DBLIST);
 
 	if (dblist->count >= dblist->size) {
@@ -189,7 +189,7 @@ errcode_t ext2fs_set_dir_block(ext2_dblist dblist, ext2_ino_t ino, blk_t blk,
 			       int blockcnt)
 {
 	dgrp_t			i;
-	
+
 	EXT2_CHECK_MAGIC(dblist, EXT2_ET_MAGIC_DBLIST);
 
 	for (i=0; i < dblist->count; i++) {
@@ -225,7 +225,7 @@ errcode_t ext2fs_dblist_iterate(ext2_dblist dblist,
 {
 	ext2_ino_t	i;
 	int		ret;
-	
+
 	EXT2_CHECK_MAGIC(dblist, EXT2_ET_MAGIC_DBLIST);
 
 	if (!dblist->sorted)
@@ -247,7 +247,7 @@ static EXT2_QSORT_TYPE dir_block_cmp(const void *a, const void *b)
 
 	if (db_a->blk != db_b->blk)
 		return (int) (db_a->blk - db_b->blk);
-	
+
 	if (db_a->ino != db_b->ino)
 		return (int) (db_a->ino - db_b->ino);
 
diff --git a/e2fsprogs/ext2fs/dblist_dir.c b/e2fsprogs/ext2fs/dblist_dir.c
index f2e17a61d..20b1cde46 100644
--- a/e2fsprogs/ext2fs/dblist_dir.c
+++ b/e2fsprogs/ext2fs/dblist_dir.c
@@ -2,12 +2,12 @@
  * dblist_dir.c --- iterate by directory entry
  *
  * Copyright 1997 by Theodore Ts'o
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
  * %End-Header%
- * 
+ *
  */
 
 #include <stdio.h>
@@ -54,7 +54,7 @@ errcode_t ext2fs_dblist_dir_iterate(ext2_dblist dblist,
 	ctx.errcode = 0;
 
 	retval = ext2fs_dblist_iterate(dblist, db_dir_proc, &ctx);
-	
+
 	if (!block_buf)
 		ext2fs_free_mem(&ctx.buf);
 	if (retval)
@@ -69,7 +69,7 @@ static int db_dir_proc(ext2_filsys fs, struct ext2_db_entry *db_info,
 
 	ctx = (struct dir_context *) priv_data;
 	ctx->dir = db_info->ino;
-	
+
 	return ext2fs_process_dir_block(fs, &db_info->blk,
 					db_info->blockcnt, 0, 0, priv_data);
 }
diff --git a/e2fsprogs/ext2fs/dir_iterate.c b/e2fsprogs/ext2fs/dir_iterate.c
index 003c0a3bd..df820feaa 100644
--- a/e2fsprogs/ext2fs/dir_iterate.c
+++ b/e2fsprogs/ext2fs/dir_iterate.c
@@ -1,6 +1,6 @@
 /*
  * dir_iterate.c --- ext2fs directory iteration operations
- * 
+ *
  * Copyright (C) 1993, 1994, 1994, 1995, 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -32,7 +32,7 @@
 static int ext2fs_validate_entry(char *buf, int offset, int final_offset)
 {
 	struct ext2_dir_entry *dirent;
-	
+
 	while (offset < final_offset) {
 		dirent = (struct ext2_dir_entry *)(buf + offset);
 		offset += dirent->rec_len;
@@ -59,13 +59,13 @@ errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
 {
 	struct		dir_context	ctx;
 	errcode_t	retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	retval = ext2fs_check_directory(fs, dir);
 	if (retval)
 		return retval;
-	
+
 	ctx.dir = dir;
 	ctx.flags = flags;
 	if (block_buf)
@@ -106,7 +106,7 @@ static int xlate_func(ext2_ino_t dir EXT2FS_ATTR((unused)),
 	return (*xl->func)(dirent, offset, blocksize, buf, xl->real_private);
 }
 
-extern errcode_t ext2fs_dir_iterate(ext2_filsys fs, 
+extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 			      ext2_ino_t dir,
 			      int flags,
 			      char *block_buf,
@@ -118,7 +118,7 @@ extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 			      void *priv_data)
 {
 	struct xlate xl;
-	
+
 	xl.real_private = priv_data;
 	xl.func = func;
 
@@ -151,7 +151,7 @@ int ext2fs_process_dir_block(ext2_filsys fs,
 		return 0;
 
 	entry = blockcnt ? DIRENT_OTHER_FILE : DIRENT_DOT_FILE;
-	
+
 	ctx->errcode = ext2fs_read_dir_block(fs, *blocknr, ctx->buf);
 	if (ctx->errcode)
 		return BLOCK_ABORT;
@@ -177,18 +177,18 @@ int ext2fs_process_dir_block(ext2_filsys fs,
 				  ctx->priv_data);
 		if (entry < DIRENT_OTHER_FILE)
 			entry++;
-			
+
 		if (ret & DIRENT_CHANGED)
 			changed++;
 		if (ret & DIRENT_ABORT) {
 			do_abort++;
 			break;
 		}
-next:		
- 		if (next_real_entry == offset)
+next:
+		if (next_real_entry == offset)
 			next_real_entry += dirent->rec_len;
- 
- 		if (ctx->flags & DIRENT_FLAG_INCLUDE_REMOVED) {
+
+		if (ctx->flags & DIRENT_FLAG_INCLUDE_REMOVED) {
 			size = ((dirent->name_len & 0xFF) + 11) & ~3;
 
 			if (dirent->rec_len != size)  {
diff --git a/e2fsprogs/ext2fs/dirblock.c b/e2fsprogs/ext2fs/dirblock.c
index 5d66ad194..9f82b5002 100644
--- a/e2fsprogs/ext2fs/dirblock.c
+++ b/e2fsprogs/ext2fs/dirblock.c
@@ -1,6 +1,6 @@
 /*
  * dirblock.c --- directory block routines.
- * 
+ *
  * Copyright (C) 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -28,9 +28,9 @@ errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
 	unsigned int	name_len, rec_len;
 #ifdef EXT2FS_ENABLE_SWAPFS
 	unsigned int do_swap;
-#endif	
+#endif
 
- 	retval = io_channel_read_blk(fs->io, block, 1, buf);
+	retval = io_channel_read_blk(fs->io, block, 1, buf);
 	if (retval)
 		return retval;
 #ifdef EXT2FS_ENABLE_SWAPFS
@@ -110,16 +110,16 @@ errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block,
 			dirent->rec_len = ext2fs_swab16(dirent->rec_len);
 			dirent->name_len = ext2fs_swab16(dirent->name_len);
 		}
-#ifdef WORDS_BIGENDIAN 
+#ifdef WORDS_BIGENDIAN
 		if (flags & EXT2_DIRBLOCK_V2_STRUCT)
 			dirent->name_len = ext2fs_swab16(dirent->name_len);
 #endif
 	}
- 	retval = io_channel_write_blk(fs->io, block, 1, buf);
+	retval = io_channel_write_blk(fs->io, block, 1, buf);
 	ext2fs_free_mem(&buf);
 	return retval;
 #else
- 	return io_channel_write_blk(fs->io, block, 1, (char *) inbuf);
+	return io_channel_write_blk(fs->io, block, 1, (char *) inbuf);
 #endif
 }
 
diff --git a/e2fsprogs/ext2fs/dirhash.c b/e2fsprogs/ext2fs/dirhash.c
index 4d18593f5..39678a628 100644
--- a/e2fsprogs/ext2fs/dirhash.c
+++ b/e2fsprogs/ext2fs/dirhash.c
@@ -2,7 +2,7 @@
  * dirhash.c -- Calculate the hash of a directory entry
  *
  * Copyright (c) 2001  Daniel Phillips
- * 
+ *
  * Copyright (c) 2002 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -25,7 +25,7 @@
  * (see Applied Cryptography, 2nd edition, p448).
  *
  * Jeremy Fitzhardinge <jeremy@zip.com.au> 1998
- * 
+ *
  * This code is made available under the terms of the GPL
  */
 #define DELTA 0x9E3779B9
@@ -37,10 +37,10 @@ static void TEA_transform(__u32 buf[4], __u32 const in[])
 	__u32	a = in[0], b = in[1], c = in[2], d = in[3];
 	int	n = 16;
 
-	do {							
-		sum += DELTA;					
-		b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);	
-		b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);	
+	do {
+		sum += DELTA;
+		b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
+		b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
 	} while(--n);
 
 	buf[0] += b0;
@@ -121,7 +121,7 @@ static ext2_dirhash_t dx_hack_hash (const char *name, int len)
 	__u32 hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
 	while (len--) {
 		__u32 hash = hash1 + (hash0 ^ (*name++ * 7152373));
-		
+
 		if (hash & 0x80000000) hash -= 0x7fffffff;
 		hash1 = hash0;
 		hash0 = hash;
@@ -160,11 +160,11 @@ static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
  * Returns the hash of a filename.  If len is 0 and name is NULL, then
  * this function can be used to test whether or not a hash version is
  * supported.
- * 
+ *
  * The seed is an 4 longword (32 bits) "secret" which can be used to
  * uniquify a hash.  If the seed is all zero's, then some default seed
  * may be used.
- * 
+ *
  * A particular hash version specifies whether or not the seed is
  * represented, and whether or not the returned hash is 32 bits or 64
  * bits.  32 bit hashes will return 0 for the minor hash.
@@ -178,7 +178,7 @@ errcode_t ext2fs_dirhash(int version, const char *name, int len,
 	__u32	minor_hash = 0;
 	const char	*p;
 	int		i;
-	__u32 		in[8], buf[4];
+	__u32		in[8], buf[4];
 
 	/* Initialize the default seed for the hash checksum functions */
 	buf[0] = 0x67452301;
@@ -195,7 +195,7 @@ errcode_t ext2fs_dirhash(int version, const char *name, int len,
 		if (i < 4)
 			memcpy(buf, seed, sizeof(buf));
 	}
-		
+
 	switch (version) {
 	case EXT2_HASH_LEGACY:
 		hash = dx_hack_hash(name, len);
diff --git a/e2fsprogs/ext2fs/dupfs.c b/e2fsprogs/ext2fs/dupfs.c
index f8919c222..2009ef701 100644
--- a/e2fsprogs/ext2fs/dupfs.c
+++ b/e2fsprogs/ext2fs/dupfs.c
@@ -1,6 +1,6 @@
 /*
  * dupfs.c --- duplicate a ext2 filesystem handle
- * 
+ *
  * Copyright (C) 1997, 1998, 2001, 2003, 2005 by Theodore Ts'o.
  *
  * %Begin-Header%
@@ -25,7 +25,7 @@ errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest)
 	errcode_t	retval;
 
 	EXT2_CHECK_MAGIC(src, EXT2_ET_MAGIC_EXT2FS_FILSYS);
-	
+
 	retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
 	if (retval)
 		return retval;
@@ -91,6 +91,6 @@ errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest)
 errout:
 	ext2fs_free(fs);
 	return retval;
-	
+
 }
 
diff --git a/e2fsprogs/ext2fs/e2image.h b/e2fsprogs/ext2fs/e2image.h
index e12b7d69b..c05d43e22 100644
--- a/e2fsprogs/ext2fs/e2image.h
+++ b/e2fsprogs/ext2fs/e2image.h
@@ -1,10 +1,10 @@
 /*
  * e2image.h --- header file describing the ext2 image format
- * 
+ *
  * Copyright (C) 2000 Theodore Ts'o.
  *
  * Note: this uses the POSIX IO interfaces, unlike most of the other
- * functions in this library.  So sue me.  
+ * functions in this library.  So sue me.
  *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
@@ -24,7 +24,7 @@ struct ext2_image_hdr {
 	char	fs_uuid[16];	/* UUID of filesystem */
 	__u32	fs_blocksize;	/* Block size of the filesystem */
 	__u32	fs_reserved[8];
-	
+
 	__u32	image_device;	/* Device number of image file */
 	__u32	image_inode;	/* Inode number of image file */
 	__u32	image_time;	/* Time of image creation */
@@ -37,15 +37,15 @@ struct ext2_image_hdr {
 	__u32	offset_reserved[8];
 };
 
-	
-	
-	
-	
-	
-	
-	
-	
-	
-	
-	
-	
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/e2fsprogs/ext2fs/expanddir.c b/e2fsprogs/ext2fs/expanddir.c
index 10a5149cf..c148b93aa 100644
--- a/e2fsprogs/ext2fs/expanddir.c
+++ b/e2fsprogs/ext2fs/expanddir.c
@@ -1,6 +1,6 @@
 /*
  * expand.c --- expand an ext2fs directory
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999  Theodore Ts'o.
  *
  * %Begin-Header%
@@ -36,7 +36,7 @@ static int expand_dir_proc(ext2_filsys	fs,
 	static blk_t	last_blk = 0;
 	char		*block;
 	errcode_t	retval;
-	
+
 	if (*blocknr) {
 		last_blk = *blocknr;
 		return 0;
@@ -62,7 +62,7 @@ static int expand_dir_proc(ext2_filsys	fs,
 		}
 		memset(block, 0, fs->blocksize);
 		retval = io_channel_write_blk(fs->io, new_blk, 1, block);
-	}	
+	}
 	if (retval) {
 		es->err = retval;
 		return BLOCK_ABORT;
@@ -83,7 +83,7 @@ errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir)
 	errcode_t	retval;
 	struct expand_dir_struct es;
 	struct ext2_inode	inode;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	if (!(fs->flags & EXT2_FLAG_RW))
@@ -95,11 +95,11 @@ errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir)
 	retval = ext2fs_check_directory(fs, dir);
 	if (retval)
 		return retval;
-	
+
 	es.done = 0;
 	es.err = 0;
 	es.newblocks = 0;
-	
+
 	retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_APPEND,
 				       0, expand_dir_proc, &es);
 
@@ -114,7 +114,7 @@ errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir)
 	retval = ext2fs_read_inode(fs, dir, &inode);
 	if (retval)
 		return retval;
-	
+
 	inode.i_size += fs->blocksize;
 	inode.i_blocks += (fs->blocksize / 512) * es.newblocks;
 
diff --git a/e2fsprogs/ext2fs/ext2_fs.h b/e2fsprogs/ext2fs/ext2_fs.h
index 7a9890320..400587324 100644
--- a/e2fsprogs/ext2fs/ext2_fs.h
+++ b/e2fsprogs/ext2fs/ext2_fs.h
@@ -231,9 +231,9 @@ struct ext2_dx_countlimit {
 #define EXT2_IMAGIC_FL			0x00002000
 #define EXT3_JOURNAL_DATA_FL		0x00004000 /* file data should be journaled */
 #define EXT2_NOTAIL_FL			0x00008000 /* file tail should not be merged */
-#define EXT2_DIRSYNC_FL 		0x00010000 /* Synchronous directory modifications */
+#define EXT2_DIRSYNC_FL			0x00010000 /* Synchronous directory modifications */
 #define EXT2_TOPDIR_FL			0x00020000 /* Top of directory hierarchies*/
-#define EXT3_EXTENTS_FL 		0x00080000 /* Inode uses extents */
+#define EXT3_EXTENTS_FL			0x00080000 /* Inode uses extents */
 #define EXT2_RESERVED_FL		0x80000000 /* reserved for ext2 lib */
 
 #define EXT2_FL_USER_VISIBLE		0x0003DFFF /* User visible flags */
@@ -501,12 +501,12 @@ struct ext2_super_block {
 	__u32	s_last_orphan;		/* start of list of inodes to delete */
 	__u32	s_hash_seed[4];		/* HTREE hash seed */
 	__u8	s_def_hash_version;	/* Default hash version to use */
-	__u8	s_jnl_backup_type; 	/* Default type of journal backup */
+	__u8	s_jnl_backup_type;	/* Default type of journal backup */
 	__u16	s_reserved_word_pad;
 	__u32	s_default_mount_opts;
 	__u32	s_first_meta_bg;	/* First metablock group */
 	__u32	s_mkfs_time;		/* When the filesystem was created */
-	__u32	s_jnl_blocks[17]; 	/* Backup of the journal inode */
+	__u32	s_jnl_blocks[17];	/* Backup of the journal inode */
 	__u32	s_reserved[172];	/* Padding to the end of the block */
 };
 
@@ -585,7 +585,7 @@ struct ext2_super_block {
 #define EXT2_DEFM_XATTR_USER	0x0004
 #define EXT2_DEFM_ACL		0x0008
 #define EXT2_DEFM_UID16		0x0010
-#define EXT3_DEFM_JMODE		0x0060 
+#define EXT3_DEFM_JMODE		0x0060
 #define EXT3_DEFM_JMODE_DATA	0x0020
 #define EXT3_DEFM_JMODE_ORDERED	0x0040
 #define EXT3_DEFM_JMODE_WBACK	0x0060
diff --git a/e2fsprogs/ext2fs/ext2fs.h b/e2fsprogs/ext2fs/ext2fs.h
index e2e86579b..7d2a43695 100644
--- a/e2fsprogs/ext2fs/ext2fs.h
+++ b/e2fsprogs/ext2fs/ext2fs.h
@@ -1,6 +1,6 @@
 /*
  * ext2fs.h --- ext2fs
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -46,7 +46,7 @@ extern "C" {
  * 1032 bytes long).
  */
 #define SUPERBLOCK_OFFSET	1024
-#define SUPERBLOCK_SIZE 	1024
+#define SUPERBLOCK_SIZE		1024
 
 /*
  * The last ext2fs revision level that this version of the library is
@@ -87,7 +87,7 @@ typedef struct struct_ext2_filsys *ext2_filsys;
 
 struct ext2fs_struct_generic_bitmap {
 	errcode_t	magic;
-	ext2_filsys 	fs;
+	ext2_filsys	fs;
 	__u32		start, end;
 	__u32		real_end;
 	char	*	description;
@@ -96,8 +96,8 @@ struct ext2fs_struct_generic_bitmap {
 	__u32		reserved[7];
 };
 
-#define EXT2FS_MARK_ERROR 	0
-#define EXT2FS_UNMARK_ERROR 	1
+#define EXT2FS_MARK_ERROR	0
+#define EXT2FS_UNMARK_ERROR	1
 #define EXT2FS_TEST_ERROR	2
 
 typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap;
@@ -194,7 +194,7 @@ struct struct_ext2_filsys {
 	io_channel			io;
 	int				flags;
 	char *				device_name;
-	struct ext2_super_block	* 	super;
+	struct ext2_super_block	*	super;
 	unsigned int			blocksize;
 	int				fragsize;
 	dgrp_t				group_desc_count;
@@ -250,7 +250,7 @@ struct struct_ext2_filsys {
  * This is used by ext2fs_expand_dir() to be able to add a new block
  * to an inode.  It can also be used for programs that want to be able
  * to deal with files that contain "holes".
- * 
+ *
  * BLOCK_FLAG_TRAVERSE indicates that the iterator function for the
  * indirect, doubly indirect, etc. blocks should be called after all
  * of the blocks containined in the indirect blocks are processed.
@@ -282,7 +282,7 @@ struct struct_ext2_filsys {
 /*
  * Flags for ext2fs_move_blocks
  */
-#define EXT2_BMOVE_GET_DBLIST	0x0001	
+#define EXT2_BMOVE_GET_DBLIST	0x0001
 #define EXT2_BMOVE_DEBUG	0x0002
 #endif
 
@@ -457,7 +457,7 @@ extern errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
 				    char *block_buf, blk_t *ret);
 
 /* alloc_sb.c */
-extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs, 
+extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs,
 					dgrp_t group,
 					ext2fs_block_bitmap bmap);
 
@@ -567,7 +567,7 @@ errcode_t ext2fs_block_iterate2(ext2_filsys fs,
 
 /* bmap.c */
 extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino,
-			     struct ext2_inode *inode, 
+			     struct ext2_inode *inode,
 			     char *block_buf, int bmap_flags,
 			     blk_t block, blk_t *phys_blk);
 
@@ -587,7 +587,7 @@ extern errcode_t ext2fs_check_desc(ext2_filsys fs);
 extern errcode_t ext2fs_close(ext2_filsys fs);
 extern errcode_t ext2fs_flush(ext2_filsys fs);
 extern int ext2fs_bg_has_super(ext2_filsys fs, int group_block);
-extern int ext2fs_super_and_bgd_loc(ext2_filsys fs, 
+extern int ext2fs_super_and_bgd_loc(ext2_filsys fs,
 				    dgrp_t group,
 				    blk_t *ret_super_blk,
 				    blk_t *ret_old_desc_blk,
@@ -652,7 +652,7 @@ extern errcode_t ext2fs_dirhash(int version, const char *name, int len,
 
 
 /* dir_iterate.c */
-extern errcode_t ext2fs_dir_iterate(ext2_filsys fs, 
+extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 			      ext2_ino_t dir,
 			      int flags,
 			      char *block_buf,
@@ -662,7 +662,7 @@ extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 					  char	*buf,
 					  void	*priv_data),
 			      void *priv_data);
-extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs, 
+extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
 			      ext2_ino_t dir,
 			      int flags,
 			      char *block_buf,
@@ -751,10 +751,10 @@ extern errcode_t ext2fs_initialize(const char *name, int flags,
 
 /* icount.c */
 extern void ext2fs_free_icount(ext2_icount_t icount);
-extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, 
+extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags,
 				       unsigned int size,
 				       ext2_icount_t hint, ext2_icount_t *ret);
-extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags, 
+extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
 				      unsigned int size,
 				      ext2_icount_t *ret);
 extern errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino,
@@ -770,9 +770,9 @@ errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *);
 
 /* inode.c */
 extern errcode_t ext2fs_flush_icache(ext2_filsys fs);
-extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, 
+extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan,
 					    ext2_ino_t *ino,
-					    struct ext2_inode *inode, 
+					    struct ext2_inode *inode,
 					    int bufsize);
 extern errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
 				  ext2_inode_scan *ret_scan);
@@ -791,12 +791,12 @@ extern void ext2fs_set_inode_callback
 extern int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags,
 				   int clear_flags);
 extern errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
-					struct ext2_inode * inode, 
+					struct ext2_inode * inode,
 					int bufsize);
 extern errcode_t ext2fs_read_inode (ext2_filsys fs, ext2_ino_t ino,
 			    struct ext2_inode * inode);
 extern errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
-					 struct ext2_inode * inode, 
+					 struct ext2_inode * inode,
 					 int bufsize);
 extern errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
 			    struct ext2_inode * inode);
@@ -807,12 +807,12 @@ extern errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino);
 
 /* inode_io.c */
 extern io_manager inode_io_manager;
-extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino, 
+extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino,
 					char **name);
 extern errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino,
 					 struct ext2_inode *inode,
 					 char **name);
-	
+
 /* ismounted.c */
 extern errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags);
 extern errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
@@ -852,11 +852,11 @@ extern errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size,
 extern errcode_t ext2fs_open(const char *name, int flags, int superblock,
 			     unsigned int block_size, io_manager manager,
 			     ext2_filsys *ret_fs);
-extern errcode_t ext2fs_open2(const char *name, const char *io_options, 
-			      int flags, int superblock, 
+extern errcode_t ext2fs_open2(const char *name, const char *io_options,
+			      int flags, int superblock,
 			      unsigned int block_size, io_manager manager,
 			      ext2_filsys *ret_fs);
-extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, 
+extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block,
 					 dgrp_t i);
 errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io);
 errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io);
@@ -877,14 +877,14 @@ extern errcode_t ext2fs_read_bb_inode(ext2_filsys fs,
 				      ext2_badblocks_list *bb_list);
 
 /* read_bb_file.c */
-extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f, 
+extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f,
 				      ext2_badblocks_list *bb_list,
 				      void *priv_data,
 				      void (*invalid)(ext2_filsys fs,
 						      blk_t blk,
 						      char *badstr,
 						      void *priv_data));
-extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f, 
+extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f,
 				     ext2_badblocks_list *bb_list,
 				     void (*invalid)(ext2_filsys fs,
 						     blk_t blk));
@@ -904,7 +904,7 @@ extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
 				    ext2fs_generic_bitmap *dest);
 
 /* swapfs.c */
-extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize, 
+extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize,
 				 int has_header);
 extern void ext2fs_swap_super(struct ext2_super_block * super);
 extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp);
diff --git a/e2fsprogs/ext2fs/ext2fsP.h b/e2fsprogs/ext2fs/ext2fsP.h
index eea32d632..90b081232 100644
--- a/e2fsprogs/ext2fs/ext2fsP.h
+++ b/e2fsprogs/ext2fs/ext2fsP.h
@@ -1,6 +1,6 @@
 /*
  * ext2fsP.h --- private header file for ext2 library
- * 
+ *
  * Copyright (C) 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -78,7 +78,7 @@ struct ext2_inode_cache_ent {
 
 /* Function prototypes */
 
-extern int ext2fs_process_dir_block(ext2_filsys  	fs,
+extern int ext2fs_process_dir_block(ext2_filsys		fs,
 				    blk_t		*blocknr,
 				    e2_blkcnt_t		blockcnt,
 				    blk_t		ref_block,
diff --git a/e2fsprogs/ext2fs/ext2fs_inline.c b/e2fsprogs/ext2fs/ext2fs_inline.c
index f14e7b22f..2fa9a9ed2 100644
--- a/e2fsprogs/ext2fs/ext2fs_inline.c
+++ b/e2fsprogs/ext2fs/ext2fs_inline.c
@@ -1,6 +1,6 @@
 /*
  * ext2fs.h --- ext2fs
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -36,7 +36,7 @@ errcode_t ext2fs_free_mem(void *ptr)
 	*pp = 0;
 	return 0;
 }
-	
+
 /*
  *  Resize memory
  */
@@ -154,7 +154,7 @@ blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
 					struct ext2_inode *inode)
 {
        return inode->i_blocks -
-              (inode->i_file_acl ? fs->blocksize >> 9 : 0);
+	      (inode->i_file_acl ? fs->blocksize >> 9 : 0);
 }
 
 
@@ -179,7 +179,7 @@ __u32 ext2fs_swab32(__u32 val)
 int ext2fs_find_first_bit_set(void * addr, unsigned size)
 {
 	char	*cp = (unsigned char *) addr;
-	int 	res = 0, d0;
+	int	res = 0, d0;
 
 	if (!size)
 		return 0;
@@ -191,7 +191,7 @@ int ext2fs_find_first_bit_set(void * addr, unsigned size)
 	d0 = ffs(*cp);
 	if (d0 == 0)
 		return size;
-	
+
 	return res + d0 - 1;
 }
 
@@ -199,10 +199,10 @@ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
 {
 	unsigned char * p;
 	int set = 0, bit = offset & 7, res = 0, d0;
-	
+
 	res = offset >> 3;
 	p = ((unsigned char *) addr) + res;
-	
+
 	if (bit) {
 		set = ffs(*p & ~((1 << bit) - 1));
 		if (set)
@@ -245,35 +245,35 @@ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,
 int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
 					 blk_t block)
 {
-	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
+	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 					    block);
 }
 
 int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
 				       blk_t block)
 {
-	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
+	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 					  block);
 }
 
 int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
 				       ext2_ino_t inode)
 {
-	return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
+	return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 					  inode);
 }
 
 int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
 					 ext2_ino_t inode)
 {
-	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
+	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 				     inode);
 }
 
 int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
 				       ext2_ino_t inode)
 {
-	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
+	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 					  inode);
 }
 
@@ -286,7 +286,7 @@ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
 				   bitmap->description);
 		return;
 	}
-#endif	
+#endif
 	ext2fs_set_bit(block - bitmap->start, bitmap->bitmap);
 }
 
@@ -415,7 +415,7 @@ void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 					     blk_t block, int num)
 {
 	int	i;
-	
+
 	if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
 		ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
 				   bitmap->description);
@@ -429,14 +429,14 @@ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 						  blk_t block, int num)
 {
 	int	i;
-	
+
 #ifdef EXT2FS_DEBUG_FAST_OPS
 	if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
 		ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
 				   bitmap->description);
 		return;
 	}
-#endif	
+#endif
 	for (i=0; i < num; i++)
 		ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap);
 }
@@ -445,7 +445,7 @@ void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 					       blk_t block, int num)
 {
 	int	i;
-	
+
 	if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
 		ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
 				   bitmap->description);
@@ -459,14 +459,14 @@ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 						    blk_t block, int num)
 {
 	int	i;
-	
+
 #ifdef EXT2FS_DEBUG_FAST_OPS
 	if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
 		ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
 				   bitmap->description);
 		return;
 	}
-#endif	
+#endif
 	for (i=0; i < num; i++)
 		ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap);
 }
diff --git a/e2fsprogs/ext2fs/ext_attr.c b/e2fsprogs/ext2fs/ext_attr.c
index 08211c316..10b8bfd9d 100644
--- a/e2fsprogs/ext2fs/ext_attr.c
+++ b/e2fsprogs/ext2fs/ext_attr.c
@@ -1,6 +1,6 @@
 /*
  * ext_attr.c --- extended attribute blocks
- * 
+ *
  * Copyright (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>
  *
  * Copyright (C) 2002 Theodore Ts'o.
@@ -27,7 +27,7 @@ errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
 {
 	errcode_t	retval;
 
- 	retval = io_channel_read_blk(fs->io, block, 1, buf);
+	retval = io_channel_read_blk(fs->io, block, 1, buf);
 	if (retval)
 		return retval;
 #ifdef EXT2FS_ENABLE_SWAPFS
@@ -55,7 +55,7 @@ errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
 	} else
 #endif
 		write_buf = (char *) inbuf;
- 	retval = io_channel_write_blk(fs->io, block, 1, write_buf);
+	retval = io_channel_write_blk(fs->io, block, 1, write_buf);
 	if (buf)
 		ext2fs_free_mem(&buf);
 	if (!retval)
diff --git a/e2fsprogs/ext2fs/fileio.c b/e2fsprogs/ext2fs/fileio.c
index 3e42cbc32..669e80c65 100644
--- a/e2fsprogs/ext2fs/fileio.c
+++ b/e2fsprogs/ext2fs/fileio.c
@@ -1,6 +1,6 @@
 /*
  * fileio.c --- Simple file I/O routines
- * 
+ *
  * Copyright (C) 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -20,14 +20,14 @@
 
 struct ext2_file {
 	errcode_t		magic;
-	ext2_filsys 		fs;
+	ext2_filsys		fs;
 	ext2_ino_t		ino;
 	struct ext2_inode	inode;
-	int 			flags;
+	int			flags;
 	__u64			pos;
 	blk_t			blockno;
 	blk_t			physblock;
-	char 			*buf;
+	char			*buf;
 };
 
 #define BMAP_BUFFER (file->buf + fs->blocksize)
@@ -36,7 +36,7 @@ errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
 			    struct ext2_inode *inode,
 			    int flags, ext2_file_t *ret)
 {
-	ext2_file_t 	file;
+	ext2_file_t	file;
 	errcode_t	retval;
 
 	/*
@@ -50,7 +50,7 @@ errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
 	retval = ext2fs_get_mem(sizeof(struct ext2_file), &file);
 	if (retval)
 		return retval;
-	
+
 	memset(file, 0, sizeof(struct ext2_file));
 	file->magic = EXT2_ET_MAGIC_EXT2_FILE;
 	file->fs = fs;
@@ -64,14 +64,14 @@ errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
 		if (retval)
 			goto fail;
 	}
-	
+
 	retval = ext2fs_get_mem(fs->blocksize * 3, &file->buf);
 	if (retval)
 		goto fail;
 
 	*ret = file;
 	return 0;
-	
+
 fail:
 	if (file->buf)
 		ext2fs_free_mem(&file->buf);
@@ -103,7 +103,7 @@ errcode_t ext2fs_file_flush(ext2_file_t file)
 {
 	errcode_t	retval;
 	ext2_filsys fs;
-	
+
 	EXT2_CHECK_MAGIC(file, EXT2_ET_MAGIC_EXT2_FILE);
 	fs = file->fs;
 
@@ -176,7 +176,7 @@ static errcode_t load_buffer(ext2_file_t file, int dontfill)
 		if (!dontfill) {
 			if (file->physblock) {
 				retval = io_channel_read_blk(fs->io,
-							     file->physblock, 
+							     file->physblock,
 							     1, file->buf);
 				if (retval)
 					return retval;
@@ -187,16 +187,16 @@ static errcode_t load_buffer(ext2_file_t file, int dontfill)
 	}
 	return 0;
 }
-	
+
 
 errcode_t ext2fs_file_close(ext2_file_t file)
 {
 	errcode_t	retval;
-	
+
 	EXT2_CHECK_MAGIC(file, EXT2_ET_MAGIC_EXT2_FILE);
 
 	retval = ext2fs_file_flush(file);
-	
+
 	if (file->buf)
 		ext2fs_free_mem(&file->buf);
 	ext2fs_free_mem(&file);
@@ -232,14 +232,14 @@ errcode_t ext2fs_file_read(ext2_file_t file, void *buf,
 		left = EXT2_I_SIZE(&file->inode) - file->pos ;
 		if (c > left)
 			c = left;
-	
+
 		memcpy(ptr, file->buf+start, c);
 		file->pos += c;
 		ptr += c;
 		count += c;
 		wanted -= c;
 	}
-	
+
 fail:
 	if (got)
 		*got = count;
@@ -265,7 +265,7 @@ errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,
 		retval = sync_buffer_position(file);
 		if (retval)
 			goto fail;
-		
+
 		start = file->pos % fs->blocksize;
 		c = fs->blocksize - start;
 		if (c > nbytes)
@@ -286,7 +286,7 @@ errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,
 		count += c;
 		nbytes -= c;
 	}
-	
+
 fail:
 	if (written)
 		*written = count;
@@ -318,7 +318,7 @@ errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset,
 {
 	__u64		loffset, ret_loffset;
 	errcode_t	retval;
-	
+
 	loffset = offset;
 	retval = ext2fs_file_llseek(file, loffset, whence, &ret_loffset);
 	if (ret_pos)
@@ -354,14 +354,14 @@ ext2_off_t ext2fs_file_get_size(ext2_file_t file)
 
 /*
  * This function sets the size of the file, truncating it if necessary
- * 
+ *
  * XXX still need to call truncate
  */
 errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size)
 {
 	errcode_t	retval;
 	EXT2_CHECK_MAGIC(file, EXT2_ET_MAGIC_EXT2_FILE);
-	
+
 	file->inode.i_size = size;
 	file->inode.i_size_high = 0;
 	if (file->ino) {
@@ -370,7 +370,7 @@ errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size)
 			return retval;
 	}
 
-	/* 
+	/*
 	 * XXX truncate inode if necessary
 	 */
 
diff --git a/e2fsprogs/ext2fs/finddev.c b/e2fsprogs/ext2fs/finddev.c
index c459c0833..552aa79c3 100644
--- a/e2fsprogs/ext2fs/finddev.c
+++ b/e2fsprogs/ext2fs/finddev.c
@@ -1,7 +1,7 @@
 /*
  * finddev.c -- this routine attempts to find a particular device in
- * 	/dev
- * 
+ *	/dev
+ *
  * Copyright (C) 2000 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -124,7 +124,7 @@ char *ext2fs_find_block_device(dev_t device)
 	add_to_dirlist("/devices", &list);
 	add_to_dirlist("/devfs", &list);
 	add_to_dirlist("/dev", &list);
-	
+
 	while (list) {
 		current = list;
 		list = list->next;
@@ -150,7 +150,7 @@ char *ext2fs_find_block_device(dev_t device)
 	return ret_path;
 }
 
-	
+
 #ifdef DEBUG
 int main(int argc, char** argv)
 {
@@ -194,5 +194,5 @@ int main(int argc, char** argv)
 	}
 	return 0;
 }
-	
+
 #endif
diff --git a/e2fsprogs/ext2fs/flushb.c b/e2fsprogs/ext2fs/flushb.c
index 18827955f..9f04647ec 100644
--- a/e2fsprogs/ext2fs/flushb.c
+++ b/e2fsprogs/ext2fs/flushb.c
@@ -1,7 +1,7 @@
 /*
  * flushb.c --- Hides system-dependent information for both syncing a
- * 	device to disk and to flush any buffers from disk cache.
- * 
+ *	device to disk and to flush any buffers from disk cache.
+ *
  * Copyright (C) 2000 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -29,7 +29,7 @@
 #include "ext2fs.h"
 
 /*
- * For Linux, define BLKFLSBUF and FDFLUSH if necessary, since 
+ * For Linux, define BLKFLSBUF and FDFLUSH if necessary, since
  * not all portable header file does so for us.  This really should be
  * fixed in the glibc header files.  (Recent glibcs appear to define
  * BLKFLSBUF in sys/mount.h, but FDFLUSH still doesn't seem to be
diff --git a/e2fsprogs/ext2fs/freefs.c b/e2fsprogs/ext2fs/freefs.c
index 029ffaae1..3fd51f257 100644
--- a/e2fsprogs/ext2fs/freefs.c
+++ b/e2fsprogs/ext2fs/freefs.c
@@ -1,6 +1,6 @@
 /*
  * freefs.c --- free an ext2 filesystem
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -52,7 +52,7 @@ void ext2fs_free(ext2_filsys fs)
 
 	if (fs->icache)
 		ext2fs_free_inode_cache(fs->icache);
-	
+
 	fs->magic = 0;
 
 	ext2fs_free_mem(&fs);
diff --git a/e2fsprogs/ext2fs/gen_bitmap.c b/e2fsprogs/ext2fs/gen_bitmap.c
index 700affa19..3f15ce6a7 100644
--- a/e2fsprogs/ext2fs/gen_bitmap.c
+++ b/e2fsprogs/ext2fs/gen_bitmap.c
@@ -1,6 +1,6 @@
 /*
  * gen_bitmap.c --- Generic bitmap routines that used to be inlined.
- * 
+ *
  * Copyright (C) 2001 Theodore Ts'o.
  *
  * %Begin-Header%
diff --git a/e2fsprogs/ext2fs/get_pathname.c b/e2fsprogs/ext2fs/get_pathname.c
index 23f593f67..594090da0 100644
--- a/e2fsprogs/ext2fs/get_pathname.c
+++ b/e2fsprogs/ext2fs/get_pathname.c
@@ -1,6 +1,6 @@
 /*
  * get_pathname.c --- do directry/inode -> name translation
- * 
+ *
  * Copyright (C) 1993, 1994, 1995 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -8,14 +8,14 @@
  * License.
  * %End-Header%
  *
- * 	ext2fs_get_pathname(fs, dir, ino, name)
+ *	ext2fs_get_pathname(fs, dir, ino, name)
+ *
+ *	This function translates takes two inode numbers into a
+ *	string, placing the result in <name>.  <dir> is the containing
+ *	directory inode, and <ino> is the inode number itself.  If
+ *	<ino> is zero, then ext2fs_get_pathname will return pathname
+ *	of the the directory <dir>.
  *
- * 	This function translates takes two inode numbers into a
- * 	string, placing the result in <name>.  <dir> is the containing
- * 	directory inode, and <ino> is the inode number itself.  If
- * 	<ino> is zero, then ext2fs_get_pathname will return pathname
- * 	of the the directory <dir>.
- * 
  */
 
 #include <stdio.h>
@@ -65,8 +65,8 @@ static int get_pathname_proc(struct ext2_dir_entry *dirent,
 	return 0;
 }
 
-static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir, 
-					 ext2_ino_t ino, int maxdepth, 
+static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir,
+					 ext2_ino_t ino, int maxdepth,
 					 char *buf, char **name)
 {
 	struct get_pathname_struct gp;
@@ -93,7 +93,7 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir,
 	gp.parent = 0;
 	gp.name = 0;
 	gp.errcode = 0;
-	
+
 	retval = ext2fs_dir_iterate(fs, dir, 0, buf, get_pathname_proc, &gp);
 	if (retval)
 		goto cleanup;
@@ -110,15 +110,15 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir,
 		*name = parent_name;
 		return 0;
 	}
-	
-	if (gp.name) 
+
+	if (gp.name)
 		retval = ext2fs_get_mem(strlen(parent_name)+strlen(gp.name)+2,
 					&ret);
 	else
 		retval = ext2fs_get_mem(strlen(parent_name)+5, &ret);
 	if (retval)
 		goto cleanup;
-	
+
 	ret[0] = 0;
 	if (parent_name[1])
 		strcat(ret, parent_name);
@@ -130,7 +130,7 @@ static errcode_t ext2fs_get_pathname_int(ext2_filsys fs, ext2_ino_t dir,
 	*name = ret;
 	ext2fs_free_mem(&parent_name);
 	retval = 0;
-	
+
 cleanup:
 	if (gp.name)
 		ext2fs_free_mem(&gp.name);
@@ -153,5 +153,5 @@ errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino,
 	retval = ext2fs_get_pathname_int(fs, dir, ino, 32, buf, name);
 	ext2fs_free_mem(&buf);
 	return retval;
-	
+
 }
diff --git a/e2fsprogs/ext2fs/getsectsize.c b/e2fsprogs/ext2fs/getsectsize.c
index 77a9e3da7..b561660ba 100644
--- a/e2fsprogs/ext2fs/getsectsize.c
+++ b/e2fsprogs/ext2fs/getsectsize.c
@@ -1,6 +1,6 @@
 /*
  * getsectsize.c --- get the sector size of a device.
- * 
+ *
  * Copyright (C) 1995, 1995 Theodore Ts'o.
  * Copyright (C) 2003 VMware, Inc.
  *
diff --git a/e2fsprogs/ext2fs/getsize.c b/e2fsprogs/ext2fs/getsize.c
index 036d9260c..bfafdf2ba 100644
--- a/e2fsprogs/ext2fs/getsize.c
+++ b/e2fsprogs/ext2fs/getsize.c
@@ -1,11 +1,11 @@
 /*
  * getsize.c --- get the size of a partition.
- * 
+ *
  * Copyright (C) 1995, 1995 Theodore Ts'o.
  * Copyright (C) 2003 VMware, Inc.
  *
  * Windows version of ext2fs_get_device_size by Chris Li, VMware.
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
@@ -75,10 +75,10 @@ errcode_t ext2fs_get_device_size(const char *file, int blocksize,
 	DWORD filesize;
 #endif /* HAVE_GET_FILE_SIZE_EX */
 
-	dev = CreateFile(file, GENERIC_READ, 
+	dev = CreateFile(file, GENERIC_READ,
 			 FILE_SHARE_READ | FILE_SHARE_WRITE ,
-                	 NULL,  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,  NULL); 
- 
+			 NULL,  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,  NULL);
+
 	if (dev == INVALID_HANDLE_VALUE)
 		return EBADF;
 	if (DeviceIoControl(dev, IOCTL_DISK_GET_PARTITION_INFO,
@@ -87,7 +87,7 @@ errcode_t ext2fs_get_device_size(const char *file, int blocksize,
 			    &retbytes, NULL)) {
 
 		*retblocks = pi.PartitionLength.QuadPart / blocksize;
-	
+
 	} else if (DeviceIoControl(dev, IOCTL_DISK_GET_DRIVE_GEOMETRY,
 				&gi, sizeof(DISK_GEOMETRY),
 				&gi, sizeof(DISK_GEOMETRY),
@@ -137,7 +137,7 @@ errcode_t ext2fs_get_device_size(const char *file, int blocksize,
 	int	fd;
 	int valid_blkgetsize64 = 1;
 #ifdef __linux__
-	struct 		utsname ut;
+	struct		utsname ut;
 #endif
 	unsigned long long size64;
 	unsigned long	size;
@@ -272,7 +272,7 @@ int main(int argc, char **argv)
 {
 	blk_t	blocks;
 	int	retval;
-	
+
 	if (argc < 2) {
 		fprintf(stderr, "Usage: %s device\n", argv[0]);
 		exit(1);
diff --git a/e2fsprogs/ext2fs/icount.c b/e2fsprogs/ext2fs/icount.c
index 59977928b..01677775f 100644
--- a/e2fsprogs/ext2fs/icount.c
+++ b/e2fsprogs/ext2fs/icount.c
@@ -81,19 +81,19 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, unsigned int size,
 		if (hint->size > size)
 			size = (size_t) hint->size;
 	}
-	
+
 	retval = ext2fs_get_mem(sizeof(struct ext2_icount), &icount);
 	if (retval)
 		return retval;
 	memset(icount, 0, sizeof(struct ext2_icount));
 
-	retval = ext2fs_allocate_inode_bitmap(fs, 0, 
+	retval = ext2fs_allocate_inode_bitmap(fs, 0,
 					      &icount->single);
 	if (retval)
 		goto errout;
 
 	if (flags & EXT2_ICOUNT_OPT_INCREMENT) {
-		retval = ext2fs_allocate_inode_bitmap(fs, 0, 
+		retval = ext2fs_allocate_inode_bitmap(fs, 0,
 						      &icount->multiple);
 		if (retval)
 			goto errout;
@@ -113,7 +113,7 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, unsigned int size,
 			goto errout;
 		icount->size += fs->super->s_inodes_count / 50;
 	}
-	
+
 	bytes = (size_t) (icount->size * sizeof(struct ext2_icount_el));
 #if 0
 	printf("Icount allocated %d entries, %d bytes.\n",
@@ -148,7 +148,7 @@ errout:
 	return(retval);
 }
 
-errcode_t ext2fs_create_icount(ext2_filsys fs, int flags, 
+errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
 			       unsigned int size,
 			       ext2_icount_t *ret)
 {
@@ -157,12 +157,12 @@ errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
 
 /*
  * insert_icount_el() --- Insert a new entry into the sorted list at a
- * 	specified position.
+ *	specified position.
  */
 static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount,
 					    ext2_ino_t ino, int pos)
 {
-	struct ext2_icount_el 	*el;
+	struct ext2_icount_el	*el;
 	errcode_t		retval;
 	ext2_ino_t			new_size = 0;
 	int			num;
@@ -170,14 +170,14 @@ static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount,
 	if (icount->count >= icount->size) {
 		if (icount->count) {
 			new_size = icount->list[(unsigned)icount->count-1].ino;
-			new_size = (ext2_ino_t) (icount->count * 
+			new_size = (ext2_ino_t) (icount->count *
 				((float) icount->num_inodes / new_size));
 		}
 		if (new_size < (icount->size + 100))
 			new_size = icount->size + 100;
 #if 0
 		printf("Reallocating icount %d entries...\n", new_size);
-#endif	
+#endif
 		retval = ext2fs_resize_mem((size_t) icount->size *
 					   sizeof(struct ext2_icount_el),
 					   (size_t) new_size *
@@ -203,8 +203,8 @@ static struct ext2_icount_el *insert_icount_el(ext2_icount_t icount,
 
 /*
  * get_icount_el() --- given an inode number, try to find icount
- * 	information in the sorted list.  If the create flag is set,
- * 	and we can't find an entry, create one in the sorted list.
+ *	information in the sorted list.  If the create flag is set,
+ *	and we can't find an entry, create one in the sorted list.
  */
 static struct ext2_icount_el *get_icount_el(ext2_icount_t icount,
 					    ext2_ino_t ino, int create)
@@ -222,7 +222,7 @@ static struct ext2_icount_el *get_icount_el(ext2_icount_t icount,
 	}
 	if (icount->count == 0)
 		return 0;
-	
+
 	if (icount->cursor >= icount->count)
 		icount->cursor = 0;
 	if (ino == icount->list[icount->cursor].ino)
@@ -247,7 +247,7 @@ static struct ext2_icount_el *get_icount_el(ext2_icount_t icount,
 				range = 0;
 			else if (ino > highval)
 				range = 1;
-			else 
+			else
 				range = ((float) (ino - lowval)) /
 					(highval - lowval);
 			mid = low + ((int) (range * (high-low)));
@@ -276,7 +276,7 @@ errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *out)
 	errcode_t	ret = 0;
 	unsigned int	i;
 	const char *bad = "bad icount";
-	
+
 	EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
 
 	if (icount->count > icount->size) {
@@ -297,7 +297,7 @@ errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *out)
 errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino, __u16 *ret)
 {
 	struct ext2_icount_el	*el;
-	
+
 	EXT2_CHECK_MAGIC(icount, EXT2_ET_MAGIC_ICOUNT);
 
 	if (!ino || (ino > icount->num_inodes))
@@ -413,7 +413,7 @@ errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
 	if (icount->multiple &&
 	    !ext2fs_test_inode_bitmap(icount->multiple, ino))
 		return EXT2_ET_INVALID_ARGUMENT;
-	
+
 	el = get_icount_el(icount, ino, 0);
 	if (!el || el->count == 0)
 		return EXT2_ET_INVALID_ARGUMENT;
diff --git a/e2fsprogs/ext2fs/imager.c b/e2fsprogs/ext2fs/imager.c
index 3f2826b82..00eb71723 100644
--- a/e2fsprogs/ext2fs/imager.c
+++ b/e2fsprogs/ext2fs/imager.c
@@ -1,11 +1,11 @@
 /*
  * image.c --- writes out the critical parts of the filesystem as a
- * 	flat file.
+ *	flat file.
  *
  * Copyright (C) 2000 Theodore Ts'o.
  *
  * Note: this uses the POSIX IO interfaces, unlike most of the other
- * functions in this library.  So sue me.  
+ * functions in this library.  So sue me.
  *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
@@ -67,7 +67,7 @@ errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags)
 	errcode_t	retval;
 
 	buf = xmalloc(fs->blocksize * BUF_BLOCKS);
-	
+
 	for (group = 0; group < fs->group_desc_count; group++) {
 		blk = fs->group_desc[(unsigned)group].bg_inode_table;
 		if (!blk)
@@ -127,7 +127,7 @@ errout:
 /*
  * Read in the inode table and stuff it into place
  */
-errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, 
+errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd,
 				  int flags EXT2FS_ATTR((unused)))
 {
 	unsigned int	group, c, left;
@@ -137,7 +137,7 @@ errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd,
 	errcode_t	retval;
 
 	buf = xmalloc(fs->blocksize * BUF_BLOCKS);
-	
+
 	for (group = 0; group < fs->group_desc_count; group++) {
 		blk = fs->group_desc[(unsigned)group].bg_inode_table;
 		if (!blk) {
@@ -161,7 +161,7 @@ errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd,
 			retval = io_channel_write_blk(fs->io, blk, c, buf);
 			if (retval)
 				goto errout;
-			
+
 			blk += c;
 			left -= c;
 		}
@@ -176,7 +176,7 @@ errout:
 /*
  * Write out superblock and group descriptors
  */
-errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd, 
+errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd,
 				   int flags EXT2FS_ATTR((unused)))
 {
 	char		*buf, *cp;
@@ -213,7 +213,7 @@ errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd,
 		retval = EXT2_ET_SHORT_WRITE;
 		goto errout;
 	}
-	
+
 	retval = 0;
 
 errout:
@@ -224,7 +224,7 @@ errout:
 /*
  * Read the superblock and group descriptors and overwrite them.
  */
-errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd, 
+errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd,
 				  int flags EXT2FS_ATTR((unused)))
 {
 	char		*buf;
@@ -368,7 +368,7 @@ errcode_t ext2fs_image_bitmap_read(ext2_filsys fs, int fd, int flags)
 		goto errout;
 	}
 	memcpy(ptr, buf, size);
-	
+
 	retval = 0;
 errout:
 	if (buf)
diff --git a/e2fsprogs/ext2fs/ind_block.c b/e2fsprogs/ext2fs/ind_block.c
index c9fd86aae..3e6cdc138 100644
--- a/e2fsprogs/ext2fs/ind_block.c
+++ b/e2fsprogs/ext2fs/ind_block.c
@@ -1,8 +1,8 @@
 /*
  * ind_block.c --- indirect block I/O routines
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 
- * 	2001, 2002, 2003, 2004, 2005 by  Theodore Ts'o.
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+ *	2001, 2002, 2003, 2004, 2005 by  Theodore Ts'o.
  *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
diff --git a/e2fsprogs/ext2fs/initialize.c b/e2fsprogs/ext2fs/initialize.c
index 82cd9f1da..3d326b577 100644
--- a/e2fsprogs/ext2fs/initialize.c
+++ b/e2fsprogs/ext2fs/initialize.c
@@ -1,9 +1,9 @@
 /*
  * initialize.c --- initialize a filesystem handle given superblock
- * 	parameters.  Used by mke2fs when initializing a filesystem.
- * 
+ *	parameters.  Used by mke2fs when initializing a filesystem.
+ *
  * Copyright (C) 1994, 1995, 1996 Theodore Ts'o.
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
@@ -36,7 +36,7 @@
 #if defined(__FreeBSD__) &&	defined(EXT2_OS_FREEBSD)
 #define CREATOR_OS EXT2_OS_FREEBSD
 #else
-#if defined(LITES) 	   &&	defined(EXT2_OS_LITES)
+#if defined(LITES)	   &&	defined(EXT2_OS_LITES)
 #define CREATOR_OS EXT2_OS_LITES
 #else
 #define CREATOR_OS EXT2_OS_LINUX /* by default */
@@ -44,13 +44,13 @@
 #endif /* defined(__FreeBSD__) && defined(EXT2_OS_FREEBSD) */
 #endif /* defined(__GNU__)     && defined(EXT2_OS_HURD) */
 #endif /* defined(__linux__)   && defined(EXT2_OS_LINUX) */
-	
+
 /*
  * Note we override the kernel include file's idea of what the default
  * check interval (never) should be.  It's a good idea to check at
  * least *occasionally*, specially since servers will never rarely get
  * to reboot, since Linux is so robust these days.  :-)
- * 
+ *
  * 180 days (six months) seems like a good value.
  */
 #ifdef EXT2_DFL_CHECKINTERVAL
@@ -108,11 +108,11 @@ errcode_t ext2fs_initialize(const char *name, int flags,
 
 	if (!param || !param->s_blocks_count)
 		return EXT2_ET_INVALID_ARGUMENT;
-	
+
 	retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
 	if (retval)
 		return retval;
-	
+
 	memset(fs, 0, sizeof(struct struct_ext2_filsys));
 	fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS;
 	fs->flags = flags | EXT2_FLAG_RW;
@@ -181,7 +181,7 @@ errcode_t ext2fs_initialize(const char *name, int flags,
 	if (super->s_blocks_per_group > EXT2_MAX_BLOCKS_PER_GROUP(super))
 		super->s_blocks_per_group = EXT2_MAX_BLOCKS_PER_GROUP(super);
 	super->s_frags_per_group = super->s_blocks_per_group * frags_per_block;
-	
+
 	super->s_blocks_count = param->s_blocks_count;
 	super->s_r_blocks_count = param->s_r_blocks_count;
 	if (super->s_r_blocks_count >= param->s_blocks_count) {
@@ -222,7 +222,7 @@ retry:
 	 */
 	if (super->s_inodes_count < EXT2_FIRST_INODE(super)+1)
 		super->s_inodes_count = EXT2_FIRST_INODE(super)+1;
-	
+
 	/*
 	 * There should be at least as many inodes as the user
 	 * requested.  Figure out how many inodes per group that
@@ -332,12 +332,12 @@ retry:
 	retval = ext2fs_get_mem(strlen(fs->device_name) + 80, &buf);
 	if (retval)
 		goto cleanup;
-	
+
 	sprintf(buf, "block bitmap for %s", fs->device_name);
 	retval = ext2fs_allocate_block_bitmap(fs, buf, &fs->block_map);
 	if (retval)
 		goto cleanup;
-	
+
 	sprintf(buf, "inode bitmap for %s", fs->device_name);
 	retval = ext2fs_allocate_inode_bitmap(fs, buf, &fs->inode_map);
 	if (retval)
@@ -369,14 +369,14 @@ retry:
 		fs->group_desc[i].bg_free_inodes_count =
 			fs->super->s_inodes_per_group;
 		fs->group_desc[i].bg_used_dirs_count = 0;
-		
+
 		group_block += super->s_blocks_per_group;
 	}
-	
+
 	ext2fs_mark_super_dirty(fs);
 	ext2fs_mark_bb_dirty(fs);
 	ext2fs_mark_ib_dirty(fs);
-	
+
 	io_channel_set_blksize(fs->io, fs->blocksize);
 
 	*ret_fs = fs;
diff --git a/e2fsprogs/ext2fs/inline.c b/e2fsprogs/ext2fs/inline.c
index 5833b1d9d..9c3a6c0d3 100644
--- a/e2fsprogs/ext2fs/inline.c
+++ b/e2fsprogs/ext2fs/inline.c
@@ -1,8 +1,8 @@
 /*
  * inline.c --- Includes the inlined functions defined in the header
- * 	files as standalone functions, in case the application program
- * 	is compiled with inlining turned off.
- * 
+ *	files as standalone functions, in case the application program
+ *	is compiled with inlining turned off.
+ *
  * Copyright (C) 1993, 1994 Theodore Ts'o.
  *
  * %Begin-Header%
diff --git a/e2fsprogs/ext2fs/inode.c b/e2fsprogs/ext2fs/inode.c
index 30580bf6d..e50bece40 100644
--- a/e2fsprogs/ext2fs/inode.c
+++ b/e2fsprogs/ext2fs/inode.c
@@ -1,6 +1,6 @@
 /*
  * inode.c --- utility routines to read and write inodes
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -59,7 +59,7 @@ struct ext2_struct_inode_scan {
 errcode_t ext2fs_flush_icache(ext2_filsys fs)
 {
 	int	i;
-	
+
 	if (!fs->icache)
 		return 0;
 
@@ -73,7 +73,7 @@ errcode_t ext2fs_flush_icache(ext2_filsys fs)
 static errcode_t create_icache(ext2_filsys fs)
 {
 	errcode_t	retval;
-	
+
 	if (fs->icache)
 		return 0;
 	retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), &fs->icache);
@@ -146,7 +146,7 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
 		group_desc[scan->current_group].bg_inode_table;
 	scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
 	scan->blocks_left = scan->fs->inode_blocks_per_group;
-	retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks * 
+	retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks *
 					  fs->blocksize),
 				&scan->inode_buffer);
 	scan->done_group = 0;
@@ -172,7 +172,7 @@ void ext2fs_close_inode_scan(ext2_inode_scan scan)
 {
 	if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN))
 		return;
-	
+
 	ext2fs_free_mem(&scan->inode_buffer);
 	scan->inode_buffer = NULL;
 	ext2fs_free_mem(&scan->temp_buffer);
@@ -190,7 +190,7 @@ void ext2fs_set_inode_callback(ext2_inode_scan scan,
 {
 	if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN))
 		return;
-	
+
 	scan->done_group = done_group;
 	scan->done_group_data = done_group_data;
 }
@@ -217,7 +217,7 @@ static errcode_t get_next_blockgroup(ext2_inode_scan scan)
 {
 	scan->current_group++;
 	scan->groups_left--;
-			
+
 	scan->current_block = scan->fs->
 		group_desc[scan->current_group].bg_inode_table;
 
@@ -335,7 +335,7 @@ static errcode_t get_next_blocks(ext2_inode_scan scan)
 		if (retval)
 			return retval;
 	}
-		
+
 	if ((scan->scan_flags & EXT2_SF_BAD_INODE_BLK) ||
 	    (scan->current_block == 0)) {
 		memset(scan->inode_buffer, 0,
@@ -367,7 +367,7 @@ static errcode_t get_next_blocks(ext2_inode_scan scan)
 static inline int is_empty_scan(ext2_inode_scan scan)
 {
 	int	i;
-	
+
 	if (scan->bytes_left == 0)
 		return 0;
 
@@ -383,7 +383,7 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 {
 	errcode_t	retval;
 	int		extra_bytes = 0;
-	
+
 	EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN);
 
 	/*
@@ -416,7 +416,7 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 		} else
 			return EXT2_ET_MISSING_INODE_TABLE;
 	}
-	
+
 
 	/*
 	 * Have we run out of space in the inode buffer?  If so, we
@@ -449,9 +449,9 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 #ifdef EXT2FS_ENABLE_SWAPFS
 		if ((scan->fs->flags & EXT2_FLAG_SWAP_BYTES) ||
 		    (scan->fs->flags & EXT2_FLAG_SWAP_BYTES_READ))
-			ext2fs_swap_inode_full(scan->fs, 
+			ext2fs_swap_inode_full(scan->fs,
 				(struct ext2_inode_large *) inode,
-				(struct ext2_inode_large *) scan->temp_buffer, 
+				(struct ext2_inode_large *) scan->temp_buffer,
 				0, bufsize);
 		else
 #endif
@@ -463,7 +463,7 @@ errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
 #ifdef EXT2FS_ENABLE_SWAPFS
 		if ((scan->fs->flags & EXT2_FLAG_SWAP_BYTES) ||
 		    (scan->fs->flags & EXT2_FLAG_SWAP_BYTES_READ))
-			ext2fs_swap_inode_full(scan->fs, 
+			ext2fs_swap_inode_full(scan->fs,
 				(struct ext2_inode_large *) inode,
 				(struct ext2_inode_large *) scan->ptr,
 				0, bufsize);
@@ -495,10 +495,10 @@ errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino,
 errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 				 struct ext2_inode * inode, int bufsize)
 {
-	unsigned long 	group, block, block_nr, offset;
-	char 		*ptr;
+	unsigned long	group, block, block_nr, offset;
+	char		*ptr;
 	errcode_t	retval;
-	int 		clen, i, inodes_per_block, length;
+	int		clen, i, inodes_per_block, length;
 	io_channel	io;
 
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
@@ -541,7 +541,7 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 		block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super);
 		if (!fs->group_desc[(unsigned)group].bg_inode_table)
 			return EXT2_ET_MISSING_INODE_TABLE;
-		block_nr = fs->group_desc[(unsigned)group].bg_inode_table + 
+		block_nr = fs->group_desc[(unsigned)group].bg_inode_table +
 			block;
 		io = fs->io;
 	}
@@ -577,8 +577,8 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 #ifdef EXT2FS_ENABLE_SWAPFS
 	if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
 	    (fs->flags & EXT2_FLAG_SWAP_BYTES_READ))
-		ext2fs_swap_inode_full(fs, (struct ext2_inode_large *) inode, 
-				       (struct ext2_inode_large *) inode, 
+		ext2fs_swap_inode_full(fs, (struct ext2_inode_large *) inode,
+				       (struct ext2_inode_large *) inode,
 				       0, length);
 #endif
 
@@ -587,7 +587,7 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
 		fs->icache->cache_size;
 	fs->icache->cache[fs->icache->cache_last].ino = ino;
 	fs->icache->cache[fs->icache->cache_last].inode = *inode;
-	
+
 	return 0;
 }
 
@@ -629,7 +629,7 @@ errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
 		if (retval)
 			return retval;
 	}
-		
+
 	if (!(fs->flags & EXT2_FLAG_RW))
 		return EXT2_ET_RO_FILSYS;
 
@@ -649,13 +649,13 @@ errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
 #ifdef EXT2FS_ENABLE_SWAPFS
 	if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
 	    (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE))
-		ext2fs_swap_inode_full(fs, w_inode, 
-				       (struct ext2_inode_large *) inode, 
+		ext2fs_swap_inode_full(fs, w_inode,
+				       (struct ext2_inode_large *) inode,
 				       1, bufsize);
 	else
 #endif
 		memcpy(w_inode, inode, bufsize);
-	
+
 	group = (ino - 1) / EXT2_INODES_PER_GROUP(fs->super);
 	offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) *
 		EXT2_INODE_SIZE(fs->super);
@@ -685,11 +685,11 @@ errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
 			fs->icache->buffer_blk = block_nr;
 		}
 
-	
-		memcpy((char *) fs->icache->buffer + (unsigned) offset, 
+
+		memcpy((char *) fs->icache->buffer + (unsigned) offset,
 		       ptr, clen);
 
-		retval = io_channel_write_blk(fs->io, block_nr, 1, 
+		retval = io_channel_write_blk(fs->io, block_nr, 1,
 					      fs->icache->buffer);
 		if (retval)
 			goto errout;
@@ -699,7 +699,7 @@ errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
 		length -= clen;
 		block_nr++;
 	}
-		
+
 	fs->flags |= EXT2_FLAG_CHANGED;
 errout:
 	if (w_inode && w_inode != &temp_inode)
@@ -714,7 +714,7 @@ errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
 				       sizeof(struct ext2_inode));
 }
 
-/* 
+/*
  * This function should be called when writing a new inode.  It makes
  * sure that extra part of large inodes is initialized properly.
  */
@@ -722,7 +722,7 @@ errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
 				 struct ext2_inode *inode)
 {
 	struct ext2_inode	*buf;
-	int 			size = EXT2_INODE_SIZE(fs->super);
+	int			size = EXT2_INODE_SIZE(fs->super);
 	struct ext2_inode_large	*large_inode;
 
 	if (size == sizeof(struct ext2_inode))
@@ -735,19 +735,19 @@ errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
 	*buf = *inode;
 
 	large_inode = (struct ext2_inode_large *) buf;
-	large_inode->i_extra_isize = sizeof(struct ext2_inode_large) - 
+	large_inode->i_extra_isize = sizeof(struct ext2_inode_large) -
 		EXT2_GOOD_OLD_INODE_SIZE;
 
 	return ext2fs_write_inode_full(fs, ino, buf, size);
 }
 
- 
+
 errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks)
 {
 	struct ext2_inode	inode;
 	int			i;
 	errcode_t		retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	if (ino > fs->super->s_inodes_count)
@@ -769,7 +769,7 @@ errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino)
 {
 	struct	ext2_inode	inode;
 	errcode_t		retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	if (ino > fs->super->s_inodes_count)
diff --git a/e2fsprogs/ext2fs/inode_io.c b/e2fsprogs/ext2fs/inode_io.c
index b5c08b90a..deaa95562 100644
--- a/e2fsprogs/ext2fs/inode_io.c
+++ b/e2fsprogs/ext2fs/inode_io.c
@@ -1,6 +1,6 @@
 /*
  * inode_io.c --- This is allows an inode in an ext2 filesystem image
- * 	to be accessed via the I/O manager interface.
+ *	to be accessed via the I/O manager interface.
  *
  * Copyright (C) 2002 Theodore Ts'o.
  *
@@ -35,7 +35,7 @@ struct inode_private_data {
 	char				name[32];
 	ext2_file_t			file;
 	ext2_filsys			fs;
-	ext2_ino_t 			ino;
+	ext2_ino_t			ino;
 	struct ext2_inode		inode;
 	int				flags;
 	struct inode_private_data	*next;
@@ -75,7 +75,7 @@ errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino,
 				  struct ext2_inode *inode,
 				  char **name)
 {
-	struct inode_private_data 	*data;
+	struct inode_private_data	*data;
 	errcode_t			retval;
 
 	if ((retval = ext2fs_get_mem(sizeof(struct inode_private_data),
@@ -150,7 +150,7 @@ static errcode_t inode_open(const char *name, int flags, io_channel *channel)
 				   &data->file);
 	if (retval)
 		goto cleanup;
-		
+
 	*channel = io;
 	return 0;
 
@@ -176,7 +176,7 @@ static errcode_t inode_close(io_channel channel)
 		return 0;
 
 	retval = ext2fs_file_close(data->file);
-	
+
 	ext2fs_free_mem(&channel->private_data);
 	if (channel->name)
 		ext2fs_free_mem(&channel->name);
@@ -255,12 +255,12 @@ static errcode_t inode_write_byte(io_channel channel, unsigned long offset,
 }
 
 /*
- * Flush data buffers to disk.  
+ * Flush data buffers to disk.
  */
 static errcode_t inode_flush(io_channel channel)
 {
 	struct inode_private_data *data;
-	
+
 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 	data = (struct inode_private_data *) channel->private_data;
 	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_INODE_IO_CHANNEL);
diff --git a/e2fsprogs/ext2fs/io_manager.c b/e2fsprogs/ext2fs/io_manager.c
index e50d7e414..3d0987bc1 100644
--- a/e2fsprogs/ext2fs/io_manager.c
+++ b/e2fsprogs/ext2fs/io_manager.c
@@ -61,8 +61,8 @@ errcode_t io_channel_write_byte(io_channel channel, unsigned long offset,
 {
 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 
-	if (channel->manager->write_byte) 
-		return channel->manager->write_byte(channel, offset, 
+	if (channel->manager->write_byte)
+		return channel->manager->write_byte(channel, offset,
 						    count, data);
 
 	return EXT2_ET_UNIMPLEMENTED;
diff --git a/e2fsprogs/ext2fs/irel.h b/e2fsprogs/ext2fs/irel.h
index 9b943ced1..45e031beb 100644
--- a/e2fsprogs/ext2fs/irel.h
+++ b/e2fsprogs/ext2fs/irel.h
@@ -1,6 +1,6 @@
 /*
  * irel.h
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
diff --git a/e2fsprogs/ext2fs/irel_ma.c b/e2fsprogs/ext2fs/irel_ma.c
index eedbe55c8..d9e73f73c 100644
--- a/e2fsprogs/ext2fs/irel_ma.c
+++ b/e2fsprogs/ext2fs/irel_ma.c
@@ -1,6 +1,6 @@
 /*
  * irel_ma.c
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -64,7 +64,7 @@ errcode_t ext2fs_irel_memarray_create(char *name, ext2_ino_t max_inode,
 {
 	ext2_irel		irel = 0;
 	errcode_t	retval;
-	struct irel_ma 	*ma = 0;
+	struct irel_ma	*ma = 0;
 	size_t		size;
 
 	*new_irel = 0;
@@ -77,18 +77,18 @@ errcode_t ext2fs_irel_memarray_create(char *name, ext2_ino_t max_inode,
 	if (retval)
 		goto errout;
 	memset(irel, 0, sizeof(struct ext2_inode_relocation_table));
-	
+
 	retval = ext2fs_get_mem(strlen(name)+1, &irel->name);
 	if (retval)
 		goto errout;
 	strcpy(irel->name, name);
-	
+
 	retval = ext2fs_get_mem(sizeof(struct irel_ma), &ma);
 	if (retval)
 		goto errout;
 	memset(ma, 0, sizeof(struct irel_ma));
 	irel->priv_data = ma;
-	
+
 	size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));
 	retval = ext2fs_get_mem(size, &ma->orig_map);
 	if (retval)
@@ -124,7 +124,7 @@ errcode_t ext2fs_irel_memarray_create(char *name, ext2_ino_t max_inode,
 	irel->move = ima_move;
 	irel->delete = ima_delete;
 	irel->free = ima_free;
-	
+
 	*new_irel = irel;
 	return 0;
 
@@ -137,7 +137,7 @@ static errcode_t ima_put(ext2_irel irel, ext2_ino_t old,
 			struct ext2_inode_relocate_entry *ent)
 {
 	struct inode_reference_entry	*ref_ent;
-	struct irel_ma 			*ma;
+	struct irel_ma			*ma;
 	errcode_t			retval;
 	size_t				size, old_size;
 
@@ -153,7 +153,7 @@ static errcode_t ima_put(ext2_irel irel, ext2_ino_t old,
 		ent->orig = old;
 	else
 		ent->orig = ma->entries[(unsigned) old].orig;
-	
+
 	/*
 	 * If max_refs has changed, reallocate the refs array
 	 */
@@ -176,7 +176,7 @@ static errcode_t ima_put(ext2_irel irel, ext2_ino_t old,
 static errcode_t ima_get(ext2_irel irel, ext2_ino_t old,
 			struct ext2_inode_relocate_entry *ent)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 
 	ma = irel->priv_data;
 	if (old > ma->max_inode)
@@ -190,7 +190,7 @@ static errcode_t ima_get(ext2_irel irel, ext2_ino_t old,
 static errcode_t ima_get_by_orig(ext2_irel irel, ext2_ino_t orig, ext2_ino_t *old,
 			struct ext2_inode_relocate_entry *ent)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 	ext2_ino_t	ino;
 
 	ma = irel->priv_data;
@@ -213,7 +213,7 @@ static errcode_t ima_start_iter(ext2_irel irel)
 static errcode_t ima_next(ext2_irel irel, ext2_ino_t *old,
 			 struct ext2_inode_relocate_entry *ent)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 
 	ma = irel->priv_data;
 	while (++irel->current < ma->max_inode) {
@@ -230,7 +230,7 @@ static errcode_t ima_next(ext2_irel irel, ext2_ino_t *old,
 static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino,
 			     struct ext2_inode_reference *ref)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 	size_t		size;
 	struct inode_reference_entry *ref_ent;
 	struct ext2_inode_relocate_entry *ent;
@@ -242,12 +242,12 @@ static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino,
 
 	ref_ent = ma->ref_entries + (unsigned) ino;
 	ent = ma->entries + (unsigned) ino;
-	
+
 	/*
 	 * If the inode reference array doesn't exist, create it.
 	 */
 	if (ref_ent->refs == 0) {
-		size = (size_t) ((sizeof(struct ext2_inode_reference) * 
+		size = (size_t) ((sizeof(struct ext2_inode_reference) *
 				  ent->max_refs));
 		retval = ext2fs_get_mem(size, &ref_ent->refs);
 		if (retval)
@@ -265,7 +265,7 @@ static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino,
 
 static errcode_t ima_start_iter_ref(ext2_irel irel, ext2_ino_t ino)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 
 	ma = irel->priv_data;
 	if (ino > ma->max_inode)
@@ -280,11 +280,11 @@ static errcode_t ima_start_iter_ref(ext2_irel irel, ext2_ino_t ino)
 static errcode_t ima_next_ref(ext2_irel irel,
 			      struct ext2_inode_reference *ref)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 	struct inode_reference_entry *ref_ent;
 
 	ma = irel->priv_data;
-	
+
 	ref_ent = ma->ref_entries + ma->ref_current;
 
 	if ((ref_ent->refs == NULL) ||
@@ -300,19 +300,19 @@ static errcode_t ima_next_ref(ext2_irel irel,
 
 static errcode_t ima_move(ext2_irel irel, ext2_ino_t old, ext2_ino_t new)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 
 	ma = irel->priv_data;
 	if ((old > ma->max_inode) || (new > ma->max_inode))
 		return EXT2_ET_INVALID_ARGUMENT;
 	if (ma->entries[(unsigned) old].new == 0)
 		return ENOENT;
-	
+
 	ma->entries[(unsigned) new] = ma->entries[(unsigned) old];
 	if (ma->ref_entries[(unsigned) new].refs)
 		ext2fs_free_mem(&ma->ref_entries[(unsigned) new].refs);
 	ma->ref_entries[(unsigned) new] = ma->ref_entries[(unsigned) old];
-	
+
 	ma->entries[(unsigned) old].new = 0;
 	ma->ref_entries[(unsigned) old].num = 0;
 	ma->ref_entries[(unsigned) old].refs = 0;
@@ -323,19 +323,19 @@ static errcode_t ima_move(ext2_irel irel, ext2_ino_t old, ext2_ino_t new)
 
 static errcode_t ima_delete(ext2_irel irel, ext2_ino_t old)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 
 	ma = irel->priv_data;
 	if (old > ma->max_inode)
 		return EXT2_ET_INVALID_ARGUMENT;
 	if (ma->entries[(unsigned) old].new == 0)
 		return ENOENT;
-	
+
 	ma->entries[old].new = 0;
 	if (ma->ref_entries[(unsigned) old].refs)
 		ext2fs_free_mem(&ma->ref_entries[(unsigned) old].refs);
 	ma->orig_map[ma->entries[(unsigned) old].orig] = 0;
-	
+
 	ma->ref_entries[(unsigned) old].num = 0;
 	ma->ref_entries[(unsigned) old].refs = 0;
 	return 0;
@@ -343,7 +343,7 @@ static errcode_t ima_delete(ext2_irel irel, ext2_ino_t old)
 
 static errcode_t ima_free(ext2_irel irel)
 {
-	struct irel_ma 	*ma;
+	struct irel_ma	*ma;
 	ext2_ino_t	ino;
 
 	if (!irel)
diff --git a/e2fsprogs/ext2fs/ismounted.c b/e2fsprogs/ext2fs/ismounted.c
index 3f2241d23..2395ccaed 100644
--- a/e2fsprogs/ext2fs/ismounted.c
+++ b/e2fsprogs/ext2fs/ismounted.c
@@ -1,6 +1,6 @@
 /*
  * ismounted.c --- Check to see if the filesystem was mounted
- * 
+ *
  * Copyright (C) 1995,1996,1997,1998,1999,2000 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -38,17 +38,17 @@
 /*
  * Helper function which checks a file in /etc/mtab format to see if a
  * filesystem is mounted.  Returns an error if the file doesn't exist
- * or can't be opened.  
+ * or can't be opened.
  */
-static errcode_t check_mntent_file(const char *mtab_file, const char *file, 
+static errcode_t check_mntent_file(const char *mtab_file, const char *file,
 				   int *mount_flags, char *mtpt, int mtlen)
 {
-	struct mntent 	*mnt;
+	struct mntent	*mnt;
 	struct stat	st_buf;
 	errcode_t	retval = 0;
 	dev_t		file_dev=0, file_rdev=0;
 	ino_t		file_ino=0;
-	FILE 		*f;
+	FILE		*f;
 	int		fd;
 
 	*mount_flags = 0;
@@ -103,7 +103,7 @@ static errcode_t check_mntent_file(const char *mtab_file, const char *file,
 	}
 #ifndef __GNU__ /* The GNU hurd is deficient; what else is new? */
 	/* Validate the entry in case /etc/mtab is out of date */
-	/* 
+	/*
 	 * We need to be paranoid, because some broken distributions
 	 * (read: Slackware) don't initialize /etc/mtab before checking
 	 * all of the non-root filesystems on the disk.
@@ -128,7 +128,7 @@ static errcode_t check_mntent_file(const char *mtab_file, const char *file,
 	}
 #endif /* __GNU__ */
 	*mount_flags = EXT2_MF_MOUNTED;
-	
+
 #ifdef MNTOPT_RO
 	/* Check to see if the ro option is set */
 	if (hasmntopt(mnt, MNTOPT_RO))
@@ -145,7 +145,7 @@ static errcode_t check_mntent_file(const char *mtab_file, const char *file,
 	 */
 	if (!strcmp(mnt->mnt_dir, "/")) {
 is_root:
-#define TEST_FILE "/.ismount-test-file"		
+#define TEST_FILE "/.ismount-test-file"
 		*mount_flags |= EXT2_MF_ISROOT;
 		fd = open(TEST_FILE, O_RDWR|O_CREAT);
 		if (fd < 0) {
@@ -184,7 +184,7 @@ static errcode_t check_mntent(const char *file, int *mount_flags,
 #endif /* MOUNTED */
 	retval = check_mntent_file(MOUNTED, file, mount_flags, mtpt, mtlen);
 	return retval;
-#else 
+#else
 	*mount_flags = 0;
 	return 0;
 #endif /* defined(MOUNTED) || defined(_PATH_MOUNTED) */
@@ -197,31 +197,31 @@ static errcode_t check_getmntinfo(const char *file, int *mount_flags,
 				  char *mtpt, int mtlen)
 {
 	struct statfs *mp;
-        int    len, n;
-        const  char   *s1;
+	int    len, n;
+	const  char   *s1;
 	char	*s2;
 
-        n = getmntinfo(&mp, MNT_NOWAIT);
-        if (n == 0)
+	n = getmntinfo(&mp, MNT_NOWAIT);
+	if (n == 0)
 		return errno;
 
-        len = sizeof(_PATH_DEV) - 1;
-        s1 = file;
-        if (strncmp(_PATH_DEV, s1, len) == 0)
-                s1 += len;
- 
+	len = sizeof(_PATH_DEV) - 1;
+	s1 = file;
+	if (strncmp(_PATH_DEV, s1, len) == 0)
+		s1 += len;
+
 	*mount_flags = 0;
-        while (--n >= 0) {
-                s2 = mp->f_mntfromname;
-                if (strncmp(_PATH_DEV, s2, len) == 0) {
-                        s2 += len - 1;
-                        *s2 = 'r';
-                }
-                if (strcmp(s1, s2) == 0 || strcmp(s1, &s2[1]) == 0) {
+	while (--n >= 0) {
+		s2 = mp->f_mntfromname;
+		if (strncmp(_PATH_DEV, s2, len) == 0) {
+			s2 += len - 1;
+			*s2 = 'r';
+		}
+		if (strcmp(s1, s2) == 0 || strcmp(s1, &s2[1]) == 0) {
 			*mount_flags = EXT2_MF_MOUNTED;
 			break;
 		}
-                ++mp;
+		++mp;
 	}
 	if (mtpt)
 		strncpy(mtpt, mp->f_mntonname, mtlen);
@@ -270,7 +270,7 @@ static int is_swap_device(const char *file)
 			ret++;
 			break;
 		}
-#endif 	/* __GNU__ */
+#endif	/* __GNU__ */
 	}
 	fclose(f);
 	return ret;
@@ -296,7 +296,7 @@ errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
 	}
 #ifdef HAVE_MNTENT_H
 	return check_mntent(device, mount_flags, mtpt, mtlen);
-#else 
+#else
 #ifdef HAVE_GETMNTINFO
 	return check_getmntinfo(device, mount_flags, mtpt, mtlen);
 #else
@@ -312,7 +312,7 @@ errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
 /*
  * ext2fs_check_if_mounted() sets the mount_flags EXT2_MF_MOUNTED,
  * EXT2_MF_READONLY, and EXT2_MF_ROOT
- * 
+ *
  */
 errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags)
 {
@@ -324,7 +324,7 @@ int main(int argc, char **argv)
 {
 	int	retval, mount_flags;
 	char	mntpt[80];
-	
+
 	if (argc < 2) {
 		fprintf(stderr, "Usage: %s device\n", argv[0]);
 		exit(1);
@@ -347,12 +347,12 @@ int main(int argc, char **argv)
 
 	if (mount_flags & EXT2_MF_READONLY)
 		printf("\t%s is read-only.\n", argv[1]);
-	
+
 	if (mount_flags & EXT2_MF_ISROOT)
 		printf("\t%s is the root filesystem.\n", argv[1]);
 	if (mntpt[0])
 		printf("\t%s is mounted on %s.\n", argv[1], mntpt);
-	
+
 	exit(0);
 }
 #endif /* DEBUG */
diff --git a/e2fsprogs/ext2fs/jfs_dat.h b/e2fsprogs/ext2fs/jfs_dat.h
index d6ad9c489..8ec5d3841 100644
--- a/e2fsprogs/ext2fs/jfs_dat.h
+++ b/e2fsprogs/ext2fs/jfs_dat.h
@@ -1,6 +1,6 @@
 /*
  * jfs_dat.h --- stripped down header file which only contains the JFS
- * 	on-disk data structures
+ *	on-disk data structures
  */
 
 #define JFS_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
@@ -9,7 +9,7 @@
  * On-disk structures
  */
 
-/* 
+/*
  * Descriptor block types:
  */
 
@@ -28,8 +28,8 @@ typedef struct journal_header_s
 } journal_header_t;
 
 
-/* 
- * The block tag: used to describe a single buffer in the journal 
+/*
+ * The block tag: used to describe a single buffer in the journal
  */
 typedef struct journal_block_tag_s
 {
@@ -55,10 +55,10 @@ typedef struct journal_superblock_s
 	__u32		s_blocksize;	/* journal device blocksize */
 	__u32		s_maxlen;	/* total blocks in journal file */
 	__u32		s_first;	/* first block of log information */
-	
+
 	/* Dynamic information describing the current state of the log */
 	__u32		s_sequence;	/* first commit ID expected in log */
 	__u32		s_start;	/* blocknr of start of log */
-	
+
 } journal_superblock_t;
 
diff --git a/e2fsprogs/ext2fs/kernel-jbd.h b/e2fsprogs/ext2fs/kernel-jbd.h
index d0efdb3f7..8a5de5e3e 100644
--- a/e2fsprogs/ext2fs/kernel-jbd.h
+++ b/e2fsprogs/ext2fs/kernel-jbd.h
@@ -1,6 +1,6 @@
 /*
  * linux/include/linux/jbd.h
- * 
+ *
  * Written by Stephen C. Tweedie <sct@redhat.com>
  *
  * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
@@ -51,7 +51,7 @@ extern int journal_enable_debug;
 		if ((n) <= journal_enable_debug) {			\
 			printk (KERN_DEBUG "(%s, %d): %s: ",		\
 				__FILE__, __LINE__, __FUNCTION__);	\
-		  	printk (f, ## a);				\
+			printk (f, ## a);				\
 		}							\
 	} while (0)
 #else
@@ -59,7 +59,7 @@ extern int journal_enable_debug;
 #define jbd_debug(f, a...)	/**/
 #else
 #define jbd_debug(f, ...)	/**/
-#endif	
+#endif
 #endif
 #else
 #define jbd_debug(x)		/* AIX doesn't do STDC */
@@ -88,7 +88,7 @@ typedef struct journal_s	journal_t;	/* Journal control structure */
  * On-disk structures
  */
 
-/* 
+/*
  * Descriptor block types:
  */
 
@@ -109,8 +109,8 @@ typedef struct journal_header_s
 } journal_header_t;
 
 
-/* 
- * The block tag: used to describe a single buffer in the journal 
+/*
+ * The block tag: used to describe a single buffer in the journal
  */
 typedef struct journal_block_tag_s
 {
@@ -118,9 +118,9 @@ typedef struct journal_block_tag_s
 	__u32		t_flags;	/* See below */
 } journal_block_tag_t;
 
-/* 
+/*
  * The revoke descriptor: used on disk to describe a series of blocks to
- * be revoked from the log 
+ * be revoked from the log
  */
 typedef struct journal_revoke_header_s
 {
@@ -149,7 +149,7 @@ typedef struct journal_superblock_s
 	__u32	s_blocksize;		/* journal device blocksize */
 	__u32	s_maxlen;		/* total blocks in journal file */
 	__u32	s_first;		/* first block of log information */
-	
+
 /* 0x0018 */
 	/* Dynamic information describing the current state of the log */
 	__u32	s_sequence;		/* first commit ID expected in log */
@@ -161,17 +161,17 @@ typedef struct journal_superblock_s
 
 /* 0x0024 */
 	/* Remaining fields are only valid in a version-2 superblock */
-	__u32	s_feature_compat; 	/* compatible feature set */
-	__u32	s_feature_incompat; 	/* incompatible feature set */
-	__u32	s_feature_ro_compat; 	/* readonly-compatible feature set */
+	__u32	s_feature_compat;	/* compatible feature set */
+	__u32	s_feature_incompat;	/* incompatible feature set */
+	__u32	s_feature_ro_compat;	/* readonly-compatible feature set */
 /* 0x0030 */
 	__u8	s_uuid[16];		/* 128-bit uuid for journal */
 
 /* 0x0040 */
 	__u32	s_nr_users;		/* Nr of filesystems sharing log */
-	
+
 	__u32	s_dynsuper;		/* Blocknr of dynamic superblock copy*/
-	
+
 /* 0x0048 */
 	__u32	s_max_transaction;	/* Limit of journal blocks per trans.*/
 	__u32	s_max_trans_data;	/* Limit of data blocks per trans. */
@@ -276,7 +276,7 @@ struct jbd_revoke_table_s;
  * the transaction, so that at all times we know how many buffers the
  * outstanding updates on a transaction might possibly touch. */
 
-struct handle_s 
+struct handle_s
 {
 	/* Which compound transaction is this update a part of? */
 	transaction_t	      * h_transaction;
@@ -314,14 +314,14 @@ struct handle_s
  * flushed to home for finished transactions.
  */
 
-struct transaction_s 
+struct transaction_s
 {
 	/* Pointer to the journal for this transaction. */
 	journal_t *		t_journal;
-	
+
 	/* Sequence number for this transaction */
 	tid_t			t_tid;
-	
+
 	/* Transaction's current state */
 	enum {
 		T_RUNNING,
@@ -329,74 +329,74 @@ struct transaction_s
 		T_RUNDOWN,
 		T_FLUSH,
 		T_COMMIT,
-		T_FINISHED 
+		T_FINISHED
 	}			t_state;
 
 	/* Where in the log does this transaction's commit start? */
 	unsigned long		t_log_start;
-	
+
 	/* Doubly-linked circular list of all inodes owned by this
-           transaction */	/* AKPM: unused */
+	   transaction */	/* AKPM: unused */
 	struct inode *		t_ilist;
-	
+
 	/* Number of buffers on the t_buffers list */
 	int			t_nr_buffers;
-	
+
 	/* Doubly-linked circular list of all buffers reserved but not
-           yet modified by this transaction */
+	   yet modified by this transaction */
 	struct journal_head *	t_reserved_list;
-	
+
 	/* Doubly-linked circular list of all metadata buffers owned by this
-           transaction */
+	   transaction */
 	struct journal_head *	t_buffers;
-	
+
 	/*
 	 * Doubly-linked circular list of all data buffers still to be
 	 * flushed before this transaction can be committed.
 	 * Protected by journal_datalist_lock.
 	 */
 	struct journal_head *	t_sync_datalist;
-	
+
 	/*
 	 * Doubly-linked circular list of all writepage data buffers
 	 * still to be written before this transaction can be committed.
 	 * Protected by journal_datalist_lock.
 	 */
 	struct journal_head *	t_async_datalist;
-	
+
 	/* Doubly-linked circular list of all forget buffers (superceded
-           buffers which we can un-checkpoint once this transaction
-           commits) */
+	   buffers which we can un-checkpoint once this transaction
+	   commits) */
 	struct journal_head *	t_forget;
-	
+
 	/*
 	 * Doubly-linked circular list of all buffers still to be
 	 * flushed before this transaction can be checkpointed.
 	 */
 	/* Protected by journal_datalist_lock */
 	struct journal_head *	t_checkpoint_list;
-	
+
 	/* Doubly-linked circular list of temporary buffers currently
-           undergoing IO in the log */
+	   undergoing IO in the log */
 	struct journal_head *	t_iobuf_list;
-	
+
 	/* Doubly-linked circular list of metadata buffers being
-           shadowed by log IO.  The IO buffers on the iobuf list and the
-           shadow buffers on this list match each other one for one at
-           all times. */
+	   shadowed by log IO.  The IO buffers on the iobuf list and the
+	   shadow buffers on this list match each other one for one at
+	   all times. */
 	struct journal_head *	t_shadow_list;
-	
+
 	/* Doubly-linked circular list of control buffers being written
-           to the log. */
+	   to the log. */
 	struct journal_head *	t_log_list;
-	
+
 	/* Number of outstanding updates running on this transaction */
 	int			t_updates;
 
 	/* Number of buffers reserved for use by all handles in this
 	 * transaction handle but not yet modified. */
 	int			t_outstanding_credits;
-	
+
 	/*
 	 * Forward and backward links for the circular list of all
 	 * transactions awaiting checkpoint.
@@ -415,7 +415,7 @@ struct transaction_s
 
 /* The journal_t maintains all of the journaling state information for a
  * single filesystem.  It is linked to from the fs superblock structure.
- * 
+ *
  * We use the journal_t to keep track of all outstanding transaction
  * activity on the filesystem, and to manage the state of the log
  * writing process. */
@@ -428,7 +428,7 @@ struct journal_s
 	/* Is there an outstanding uncleared error on the journal (from
 	 * a prior abort)? */
 	int			j_errno;
-	
+
 	/* The superblock buffer */
 	struct buffer_head *	j_sb_buffer;
 	journal_superblock_t *	j_superblock;
@@ -438,49 +438,49 @@ struct journal_s
 
 	/* Number of processes waiting to create a barrier lock */
 	int			j_barrier_count;
-	
+
 	/* The barrier lock itself */
 	struct semaphore	j_barrier;
-	
+
 	/* Transactions: The current running transaction... */
 	transaction_t *		j_running_transaction;
-	
+
 	/* ... the transaction we are pushing to disk ... */
 	transaction_t *		j_committing_transaction;
-	
+
 	/* ... and a linked circular list of all transactions waiting
 	 * for checkpointing. */
 	/* Protected by journal_datalist_lock */
 	transaction_t *		j_checkpoint_transactions;
 
 	/* Wait queue for waiting for a locked transaction to start
-           committing, or for a barrier lock to be released */
+	   committing, or for a barrier lock to be released */
 	wait_queue_head_t	j_wait_transaction_locked;
-	
+
 	/* Wait queue for waiting for checkpointing to complete */
 	wait_queue_head_t	j_wait_logspace;
-	
+
 	/* Wait queue for waiting for commit to complete */
 	wait_queue_head_t	j_wait_done_commit;
-	
+
 	/* Wait queue to trigger checkpointing */
 	wait_queue_head_t	j_wait_checkpoint;
-	
+
 	/* Wait queue to trigger commit */
 	wait_queue_head_t	j_wait_commit;
-	
+
 	/* Wait queue to wait for updates to complete */
 	wait_queue_head_t	j_wait_updates;
 
 	/* Semaphore for locking against concurrent checkpoints */
-	struct semaphore 	j_checkpoint_sem;
+	struct semaphore	j_checkpoint_sem;
 
 	/* The main journal lock, used by lock_journal() */
 	struct semaphore	j_sem;
-		
+
 	/* Journal head: identifies the first unused block in the journal. */
 	unsigned long		j_head;
-	
+
 	/* Journal tail: identifies the oldest still-used block in the
 	 * journal. */
 	unsigned long		j_tail;
@@ -546,12 +546,12 @@ struct journal_s
 	struct list_head	j_all_journals;
 
 	/* The revoke table: maintains the list of revoked blocks in the
-           current transaction. */
+	   current transaction. */
 	struct jbd_revoke_table_s *j_revoke;
 };
 
-/* 
- * Journal flag definitions 
+/*
+ * Journal flag definitions
  */
 #define JFS_UNMOUNT	0x001	/* Journal thread is being destroyed */
 #define JFS_ABORT	0x002	/* Journaling has been aborted for errors. */
@@ -559,7 +559,7 @@ struct journal_s
 #define JFS_FLUSHED	0x008	/* The journal superblock has been flushed */
 #define JFS_LOADED	0x010	/* The journal superblock has been loaded */
 
-/* 
+/*
  * Function declarations for the journaling transaction and buffer
  * management
  */
@@ -589,7 +589,7 @@ extern void journal_insert_checkpoint(struct journal_head *, transaction_t *);
 extern void __journal_insert_checkpoint(struct journal_head *,transaction_t *);
 
 /* Buffer IO */
-extern int 
+extern int
 journal_write_metadata_buffer(transaction_t	  *transaction,
 			      struct journal_head  *jh_in,
 			      struct journal_head **jh_out,
@@ -603,7 +603,7 @@ extern void		__wait_on_journal (journal_t *);
  *
  * We need to lock the journal during transaction state changes so that
  * nobody ever tries to take a handle on the running transaction while
- * we are in the middle of moving it to the commit phase.  
+ * we are in the middle of moving it to the commit phase.
  *
  * Note that the locking is completely interrupt unsafe.  We never touch
  * journal structures from interrupts.
@@ -637,7 +637,7 @@ static inline handle_t *journal_current_handle(void)
 /* The journaling code user interface:
  *
  * Create and destroy handles
- * Register buffer modifications against the current transaction. 
+ * Register buffer modifications against the current transaction.
  */
 
 extern handle_t *journal_start(journal_t *, int nblocks);
@@ -665,11 +665,11 @@ extern journal_t * journal_init_dev(kdev_t dev, kdev_t fs_dev,
 				int start, int len, int bsize);
 extern journal_t * journal_init_inode (struct inode *);
 extern int	   journal_update_format (journal_t *);
-extern int	   journal_check_used_features 
+extern int	   journal_check_used_features
 		   (journal_t *, unsigned long, unsigned long, unsigned long);
-extern int	   journal_check_available_features 
+extern int	   journal_check_available_features
 		   (journal_t *, unsigned long, unsigned long, unsigned long);
-extern int	   journal_set_features 
+extern int	   journal_set_features
 		   (journal_t *, unsigned long, unsigned long, unsigned long);
 extern int	   journal_create     (journal_t *);
 extern int	   journal_load       (journal_t *journal);
@@ -747,7 +747,7 @@ do {								      \
  * bit, when set, indicates that we have had a fatal error somewhere,
  * either inside the journaling layer or indicated to us by the client
  * (eg. ext3), and that we and should not commit any further
- * transactions.  
+ * transactions.
  */
 
 static inline int is_journal_aborted(journal_t *journal)
@@ -770,7 +770,7 @@ static inline void journal_abort_handle(handle_t *handle)
 /* Not all architectures define BUG() */
 #ifndef BUG
 #define BUG() do { \
-        printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \
+	printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \
 	* ((char *) 0) = 0; \
  } while (0)
 #endif /* BUG */
@@ -826,7 +826,7 @@ extern int journal_blocks_per_page(struct inode *inode);
 #define BJ_LogCtl	7	/* Buffer contains log descriptors */
 #define BJ_Reserved	8	/* Buffer is reserved for access by journal */
 #define BJ_Types	9
- 
+
 extern int jbd_blocks_per_page(struct inode *inode);
 
 #ifdef __KERNEL__
diff --git a/e2fsprogs/ext2fs/kernel-list.h b/e2fsprogs/ext2fs/kernel-list.h
index 24e6ab4a1..fa62ff138 100644
--- a/e2fsprogs/ext2fs/kernel-list.h
+++ b/e2fsprogs/ext2fs/kernel-list.h
@@ -29,7 +29,7 @@ struct list_head {
 #endif
 
 /*
- * Insert a new entry between two known consecutive entries. 
+ * Insert a new entry between two known consecutive entries.
  *
  * This is only for internal list manipulation where we know
  * the prev/next entries already!
@@ -107,6 +107,6 @@ static __inline__ void list_splice(struct list_head *list, struct list_head *hea
 	((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 
 #define list_for_each(pos, head) \
-        for (pos = (head)->next; pos != (head); pos = pos->next)
+	for (pos = (head)->next; pos != (head); pos = pos->next)
 
 #endif
diff --git a/e2fsprogs/ext2fs/link.c b/e2fsprogs/ext2fs/link.c
index 5e0f4f3c0..281ad065f 100644
--- a/e2fsprogs/ext2fs/link.c
+++ b/e2fsprogs/ext2fs/link.c
@@ -1,6 +1,6 @@
 /*
  * link.c --- create links in a ext2fs directory
- * 
+ *
  * Copyright (C) 1993, 1994 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -25,7 +25,7 @@ struct link_struct  {
 	int		flags;
 	int		done;
 	struct ext2_super_block *sb;
-};	
+};
 
 static int link_proc(struct ext2_dir_entry *dirent,
 		     int	offset,
@@ -94,7 +94,7 @@ static int link_proc(struct ext2_dir_entry *dirent,
 #ifdef __TURBOC__
  #pragma argsused
 #endif
-errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name, 
+errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name,
 		      ext2_ino_t ino, int flags)
 {
 	errcode_t		retval;
diff --git a/e2fsprogs/ext2fs/lookup.c b/e2fsprogs/ext2fs/lookup.c
index 1745f33ab..9cb97f1b5 100644
--- a/e2fsprogs/ext2fs/lookup.c
+++ b/e2fsprogs/ext2fs/lookup.c
@@ -1,6 +1,6 @@
 /*
  * lookup.c --- ext2fs directory lookup operations
- * 
+ *
  * Copyright (C) 1993, 1994, 1994, 1995 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -23,7 +23,7 @@ struct lookup_struct  {
 	int		len;
 	ext2_ino_t	*inode;
 	int		found;
-};	
+};
 
 #ifdef __TURBOC__
  #pragma argsused
diff --git a/e2fsprogs/ext2fs/mkdir.c b/e2fsprogs/ext2fs/mkdir.c
index 81e7aea58..bf46e5050 100644
--- a/e2fsprogs/ext2fs/mkdir.c
+++ b/e2fsprogs/ext2fs/mkdir.c
@@ -1,6 +1,6 @@
 /*
  * mkdir.c --- make a directory in the filesystem
- * 
+ *
  * Copyright (C) 1994, 1995 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -94,7 +94,7 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
 	retval = ext2fs_write_dir_block(fs, blk, block);
 	if (retval)
 		goto cleanup;
-	retval = ext2fs_write_new_inode(fs, ino, &inode); 
+	retval = ext2fs_write_new_inode(fs, ino, &inode);
 	if (retval)
 		goto cleanup;
 
@@ -125,7 +125,7 @@ errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
 		if (retval)
 			goto cleanup;
 	}
-	
+
 	/*
 	 * Update accounting....
 	 */
diff --git a/e2fsprogs/ext2fs/mkjournal.c b/e2fsprogs/ext2fs/mkjournal.c
index b748918b6..0a9ae7a4d 100644
--- a/e2fsprogs/ext2fs/mkjournal.c
+++ b/e2fsprogs/ext2fs/mkjournal.c
@@ -2,7 +2,7 @@
  * mkjournal.c --- make a journal for a filesystem
  *
  * Copyright (C) 2000 Theodore Ts'o.
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
@@ -155,7 +155,7 @@ static int mkjournal_proc(ext2_filsys	fs,
 	blk_t	new_blk;
 	static blk_t	last_blk = 0;
 	errcode_t	retval;
-	
+
 	if (*blocknr) {
 		last_blk = *blocknr;
 		return 0;
@@ -186,7 +186,7 @@ static int mkjournal_proc(ext2_filsys	fs,
 		return (BLOCK_CHANGED | BLOCK_ABORT);
 	else
 		return BLOCK_CHANGED;
-	
+
 }
 
 /*
@@ -202,7 +202,7 @@ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino,
 
 	if ((retval = ext2fs_create_journal_superblock(fs, size, flags, &buf)))
 		return retval;
-	
+
 	if ((retval = ext2fs_read_bitmaps(fs)))
 		return retval;
 
@@ -227,7 +227,7 @@ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino,
 	if ((retval = ext2fs_read_inode(fs, journal_ino, &inode)))
 		goto errout;
 
- 	inode.i_size += fs->blocksize * size;
+	inode.i_size += fs->blocksize * size;
 	inode.i_blocks += (fs->blocksize / 512) * es.newblocks;
 	inode.i_mtime = inode.i_ctime = time(0);
 	inode.i_links_count = 1;
@@ -262,7 +262,7 @@ errcode_t ext2fs_add_journal_device(ext2_filsys fs, ext2_filsys journal_dev)
 	/* Make sure the device exists and is a block device */
 	if (stat(journal_dev->device_name, &st) < 0)
 		return errno;
-	
+
 	if (!S_ISBLK(st.st_mode))
 		return EXT2_ET_JOURNAL_NOT_BLOCK; /* Must be a block device */
 
@@ -297,7 +297,7 @@ errcode_t ext2fs_add_journal_device(ext2_filsys fs, ext2_filsys journal_dev)
 	/* Writeback the journal superblock */
 	if ((retval = io_channel_write_blk(journal_dev->io, start, -1024, buf)))
 		return retval;
-	
+
 	fs->super->s_journal_inum = 0;
 	fs->super->s_journal_dev = st.st_rdev;
 	memcpy(fs->super->s_journal_uuid, jsb->s_uuid,
@@ -328,7 +328,7 @@ errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size, int flags)
 		strcat(jfile, "/.journal");
 
 		/*
-		 * If .../.journal already exists, make sure any 
+		 * If .../.journal already exists, make sure any
 		 * immutable or append-only flags are cleared.
 		 */
 #if defined(HAVE_CHFLAGS) && defined(UF_NODUMP)
@@ -350,7 +350,7 @@ errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size, int flags)
 
 		if ((retval = write_journal_file(fs, jfile, size, flags)))
 			goto errout;
-		
+
 		/* Get inode number of the journal file */
 		if (fstat(fd, &st) < 0)
 			goto errout;
@@ -365,7 +365,7 @@ errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size, int flags)
 #endif
 		if (retval)
 			goto errout;
-		
+
 		close(fd);
 		journal_ino = st.st_ino;
 	} else {
@@ -374,7 +374,7 @@ errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size, int flags)
 						  size, flags)))
 			return retval;
 	}
-	
+
 	fs->super->s_journal_inum = journal_ino;
 	fs->super->s_journal_dev = 0;
 	memset(fs->super->s_journal_uuid, 0,
@@ -393,14 +393,14 @@ main(int argc, char **argv)
 {
 	errcode_t	retval;
 	char		*device_name;
-	ext2_filsys 	fs;
+	ext2_filsys	fs;
 
 	if (argc < 2) {
 		fprintf(stderr, "Usage: %s filesystem\n", argv[0]);
 		exit(1);
 	}
 	device_name = argv[1];
-	
+
 	retval = ext2fs_open (device_name, EXT2_FLAG_RW, 0, 0,
 			      unix_io_manager, &fs);
 	if (retval) {
@@ -420,6 +420,6 @@ main(int argc, char **argv)
 	}
 	ext2fs_close(fs);
 	exit(0);
-	
+
 }
 #endif
diff --git a/e2fsprogs/ext2fs/namei.c b/e2fsprogs/ext2fs/namei.c
index 13d13adfe..6ce4bb363 100644
--- a/e2fsprogs/ext2fs/namei.c
+++ b/e2fsprogs/ext2fs/namei.c
@@ -1,6 +1,6 @@
 /*
  * namei.c --- ext2fs directory lookup operations
- * 
+ *
  * Copyright (C) 1993, 1994, 1994, 1995 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -36,7 +36,7 @@ static errcode_t follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir,
 #ifdef NAMEI_DEBUG
 	printf("follow_link: root=%lu, dir=%lu, inode=%lu, lc=%d\n",
 	       root, dir, inode, link_count);
-	
+
 #endif
 	retval = ext2fs_read_inode (fs, inode, &ei);
 	if (retval) return retval;
@@ -85,12 +85,12 @@ static errcode_t dir_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir,
 	errcode_t retval;
 
 	if ((c = *pathname) == '/') {
-        	dir = root;
+		dir = root;
 		pathname++;
 		pathlen--;
 	}
 	while (1) {
-        	thisname = pathname;
+		thisname = pathname;
 		for (len=0; --pathlen >= 0;len++) {
 			c = *(pathname++);
 			if (c == '/')
@@ -100,10 +100,10 @@ static errcode_t dir_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir,
 			break;
 		retval = ext2fs_lookup (fs, dir, thisname, len, buf, &inode);
 		if (retval) return retval;
-        	retval = follow_link (fs, root, dir, inode,
+		retval = follow_link (fs, root, dir, inode,
 				      link_count, buf, &dir);
-        	if (retval) return retval;
-    	}
+		if (retval) return retval;
+	}
 	*name = thisname;
 	*namelen = len;
 	*res_inode = dir;
@@ -152,13 +152,13 @@ errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
 {
 	char *buf;
 	errcode_t retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	retval = ext2fs_get_mem(fs->blocksize, &buf);
 	if (retval)
 		return retval;
-	
+
 	retval = open_namei(fs, root, cwd, name, strlen(name), 0, 0,
 			    buf, inode);
 
@@ -171,13 +171,13 @@ errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
 {
 	char *buf;
 	errcode_t retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	retval = ext2fs_get_mem(fs->blocksize, &buf);
 	if (retval)
 		return retval;
-	
+
 	retval = open_namei(fs, root, cwd, name, strlen(name), 1, 0,
 			    buf, inode);
 
@@ -190,7 +190,7 @@ errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
 {
 	char *buf;
 	errcode_t retval;
-	
+
 	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
 	retval = ext2fs_get_mem(fs->blocksize, &buf);
diff --git a/e2fsprogs/ext2fs/newdir.c b/e2fsprogs/ext2fs/newdir.c
index 3904d9112..27c718ea5 100644
--- a/e2fsprogs/ext2fs/newdir.c
+++ b/e2fsprogs/ext2fs/newdir.c
@@ -1,6 +1,6 @@
 /*
  * newdir.c --- create a new directory block
- * 
+ *
  * Copyright (C) 1994, 1995 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -28,7 +28,7 @@
 errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
 			       ext2_ino_t parent_ino, char **block)
 {
-	struct ext2_dir_entry 	*dir = NULL;
+	struct ext2_dir_entry	*dir = NULL;
 	errcode_t		retval;
 	char			*buf;
 	int			rec_len;
@@ -65,7 +65,7 @@ errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
 		dir->name_len = 2 | filetype;
 		dir->name[0] = '.';
 		dir->name[1] = '.';
-		
+
 	}
 	*block = buf;
 	return 0;
diff --git a/e2fsprogs/ext2fs/openfs.c b/e2fsprogs/ext2fs/openfs.c
index e8f16495d..aa603337d 100644
--- a/e2fsprogs/ext2fs/openfs.c
+++ b/e2fsprogs/ext2fs/openfs.c
@@ -1,8 +1,8 @@
 /*
  * openfs.c --- open an ext2 filesystem
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
@@ -42,7 +42,7 @@ blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, dgrp_t i)
 	bg = (fs->blocksize / sizeof (struct ext2_group_desc)) * i;
 	if (ext2fs_bg_has_super(fs, bg))
 		has_super = 1;
-	ret_blk = (fs->super->s_first_data_block + has_super + 
+	ret_blk = (fs->super->s_first_data_block + has_super +
 		   (bg * fs->super->s_blocks_per_group));
 	/*
 	 * If group_block is not the normal value, we're trying to use
@@ -60,27 +60,27 @@ blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, dgrp_t i)
 }
 
 errcode_t ext2fs_open(const char *name, int flags, int superblock,
-		      unsigned int block_size, io_manager manager, 
+		      unsigned int block_size, io_manager manager,
 		      ext2_filsys *ret_fs)
 {
-	return ext2fs_open2(name, 0, flags, superblock, block_size, 
+	return ext2fs_open2(name, 0, flags, superblock, block_size,
 			    manager, ret_fs);
 }
 
 /*
  *  Note: if superblock is non-zero, block-size must also be non-zero.
- * 	Superblock and block_size can be zero to use the default size.
+ *	Superblock and block_size can be zero to use the default size.
  *
  * Valid flags for ext2fs_open()
- * 
- * 	EXT2_FLAG_RW	- Open the filesystem for read/write.
- * 	EXT2_FLAG_FORCE - Open the filesystem even if some of the
+ *
+ *	EXT2_FLAG_RW	- Open the filesystem for read/write.
+ *	EXT2_FLAG_FORCE - Open the filesystem even if some of the
  *				features aren't supported.
  *	EXT2_FLAG_JOURNAL_DEV_OK - Open an ext3 journal device
  */
 errcode_t ext2fs_open2(const char *name, const char *io_options,
 		       int flags, int superblock,
-		       unsigned int block_size, io_manager manager, 
+		       unsigned int block_size, io_manager manager,
 		       ext2_filsys *ret_fs)
 {
 	ext2_filsys	fs;
@@ -93,13 +93,13 @@ errcode_t ext2fs_open2(const char *name, const char *io_options,
 	int j;
 	struct ext2_group_desc *gdp;
 #endif
-	
+
 	EXT2_CHECK_MAGIC(manager, EXT2_ET_MAGIC_IO_MANAGER);
 
 	retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
 	if (retval)
 		return retval;
-	
+
 	memset(fs, 0, sizeof(struct struct_ext2_filsys));
 	fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS;
 	fs->flags = flags;
@@ -113,13 +113,13 @@ errcode_t ext2fs_open2(const char *name, const char *io_options,
 		*cp++ = 0;
 		io_options = cp;
 	}
-		
-	retval = manager->open(fs->device_name, 
+
+	retval = manager->open(fs->device_name,
 			       (flags & EXT2_FLAG_RW) ? IO_FLAG_RW : 0,
 			       &fs->io);
 	if (retval)
 		goto cleanup;
-	if (io_options && 
+	if (io_options &&
 	    (retval = io_channel_set_options(fs->io, io_options)))
 		goto cleanup;
 	fs->image_io = fs->io;
@@ -183,7 +183,7 @@ errcode_t ext2fs_open2(const char *name, const char *io_options,
 		ext2fs_swap_super(fs->super);
 	}
 #endif
-	
+
 	if (fs->super->s_magic != EXT2_SUPER_MAGIC) {
 		retval = EXT2_ET_BAD_MAGIC;
 		goto cleanup;
@@ -215,7 +215,7 @@ errcode_t ext2fs_open2(const char *name, const char *io_options,
 			goto cleanup;
 		}
 	}
-	
+
 	fs->blocksize = EXT2_BLOCK_SIZE(fs->super);
 	if (fs->blocksize == 0) {
 		retval = EXT2_ET_CORRUPT_SUPERBLOCK;
@@ -247,7 +247,7 @@ errcode_t ext2fs_open2(const char *name, const char *io_options,
 		*ret_fs = fs;
 		return 0;
 	}
-	
+
 	/*
 	 * Read group descriptors
 	 */
@@ -296,7 +296,7 @@ cleanup:
 
 /*
  * Set/get the filesystem data I/O channel.
- * 
+ *
  * These functions are only valid if EXT2_FLAG_IMAGE_FILE is true.
  */
 errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io)
@@ -322,7 +322,7 @@ errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io)
 	if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
 		return EXT2_ET_NOT_IMAGE_FILE;
 	fs->io = fs->image_io = new_io;
-	fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_RW | 
+	fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_RW |
 		EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY;
 	fs->flags &= ~EXT2_FLAG_IMAGE_FILE;
 	return 0;
diff --git a/e2fsprogs/ext2fs/read_bb.c b/e2fsprogs/ext2fs/read_bb.c
index c717adcd2..226c5375a 100644
--- a/e2fsprogs/ext2fs/read_bb.c
+++ b/e2fsprogs/ext2fs/read_bb.c
@@ -38,16 +38,16 @@ struct read_bb_record {
  #pragma argsused
 #endif
 static int mark_bad_block(ext2_filsys fs, blk_t *block_nr,
-			  e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), 
+			  e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
 			  blk_t ref_block EXT2FS_ATTR((unused)),
-			  int ref_offset EXT2FS_ATTR((unused)), 
+			  int ref_offset EXT2FS_ATTR((unused)),
 			  void *priv_data)
 {
 	struct read_bb_record *rb = (struct read_bb_record *) priv_data;
-	
+
 	if (blockcnt < 0)
 		return 0;
-	
+
 	if ((*block_nr < fs->super->s_first_data_block) ||
 	    (*block_nr >= fs->super->s_blocks_count))
 		return 0;	/* Ignore illegal blocks */
diff --git a/e2fsprogs/ext2fs/read_bb_file.c b/e2fsprogs/ext2fs/read_bb_file.c
index 40c34ee3c..f7851f143 100644
--- a/e2fsprogs/ext2fs/read_bb_file.c
+++ b/e2fsprogs/ext2fs/read_bb_file.c
@@ -29,7 +29,7 @@
 /*
  * Reads a list of bad blocks from  a FILE *
  */
-errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f, 
+errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f,
 			       ext2_badblocks_list *bb_list,
 			       void *priv_data,
 			       void (*invalid)(ext2_filsys fs,
@@ -72,7 +72,7 @@ errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f,
 }
 
 static void call_compat_invalid(ext2_filsys fs, blk_t blk,
-				char *badstr EXT2FS_ATTR((unused)), 
+				char *badstr EXT2FS_ATTR((unused)),
 				void *priv_data)
 {
 	void (*invalid)(ext2_filsys, blk_t);
@@ -86,7 +86,7 @@ static void call_compat_invalid(ext2_filsys fs, blk_t blk,
 /*
  * Reads a list of bad blocks from  a FILE *
  */
-errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f, 
+errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f,
 			      ext2_badblocks_list *bb_list,
 			      void (*invalid)(ext2_filsys fs, blk_t blk))
 {
diff --git a/e2fsprogs/ext2fs/rs_bitmap.c b/e2fsprogs/ext2fs/rs_bitmap.c
index 46653f0ec..c2e51e021 100644
--- a/e2fsprogs/ext2fs/rs_bitmap.c
+++ b/e2fsprogs/ext2fs/rs_bitmap.c
@@ -53,7 +53,7 @@ errcode_t ext2fs_resize_generic_bitmap(__u32 new_end, __u32 new_real_end,
 		bmap->end = new_end;
 		return 0;
 	}
-	
+
 	size = ((bmap->real_end - bmap->start) / 8) + 1;
 	new_size = ((new_real_end - bmap->start) / 8) + 1;
 
@@ -74,7 +74,7 @@ errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end,
 				     ext2fs_inode_bitmap bmap)
 {
 	errcode_t	retval;
-	
+
 	if (!bmap)
 		return EXT2_ET_INVALID_ARGUMENT;
 
@@ -91,7 +91,7 @@ errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end,
 				     ext2fs_block_bitmap bmap)
 {
 	errcode_t	retval;
-	
+
 	if (!bmap)
 		return EXT2_ET_INVALID_ARGUMENT;
 
diff --git a/e2fsprogs/ext2fs/rw_bitmaps.c b/e2fsprogs/ext2fs/rw_bitmaps.c
index b67a92599..ae7b6e0cf 100644
--- a/e2fsprogs/ext2fs/rw_bitmaps.c
+++ b/e2fsprogs/ext2fs/rw_bitmaps.c
@@ -45,7 +45,7 @@ static void ext2fs_swap_bitmap(ext2_filsys fs, char *bitmap, int nbytes)
 {
 	__u32 *p = (__u32 *) bitmap;
 	int n;
-		
+
 	for (n = nbytes / sizeof(__u32); n > 0; --n, ++p)
 		*p = ext2fs_swab32(*p);
 }
@@ -53,7 +53,7 @@ static void ext2fs_swap_bitmap(ext2_filsys fs, char *bitmap, int nbytes)
 
 errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs)
 {
-	dgrp_t 		i;
+	dgrp_t		i;
 	size_t		nbytes;
 	errcode_t	retval;
 	char * inode_bitmap = fs->inode_map->bitmap;
@@ -67,7 +67,7 @@ errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs)
 	if (!inode_bitmap)
 		return 0;
 	nbytes = (size_t) ((EXT2_INODES_PER_GROUP(fs->super)+7) / 8);
-	
+
 	retval = ext2fs_get_mem(fs->blocksize, &bitmap_block);
 	if (retval)
 		return retval;
@@ -95,7 +95,7 @@ errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs)
 
 errcode_t ext2fs_write_block_bitmap (ext2_filsys fs)
 {
-	dgrp_t 		i;
+	dgrp_t		i;
 	unsigned int	j;
 	int		nbytes;
 	unsigned int	nbits;
@@ -195,7 +195,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
 		if (block_bitmap) {
 			blk = (fs->image_header->offset_blockmap /
 			       fs->blocksize);
-			retval = io_channel_read_blk(fs->image_io, blk, 
+			retval = io_channel_read_blk(fs->image_io, blk,
 			     -(block_nbytes * fs->group_desc_count),
 			     block_bitmap);
 			if (retval)
@@ -243,7 +243,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
 		}
 	}
 	return 0;
-	
+
 cleanup:
 	if (do_block) {
 		ext2fs_free_mem(&fs->block_map);
@@ -296,5 +296,5 @@ errcode_t ext2fs_write_bitmaps(ext2_filsys fs)
 			return retval;
 	}
 	return 0;
-}	
+}
 
diff --git a/e2fsprogs/ext2fs/swapfs.c b/e2fsprogs/ext2fs/swapfs.c
index 8a0899515..af8b6eb87 100644
--- a/e2fsprogs/ext2fs/swapfs.c
+++ b/e2fsprogs/ext2fs/swapfs.c
@@ -1,6 +1,6 @@
 /*
  * swapfs.c --- swap ext2 filesystem data structures
- * 
+ *
  * Copyright (C) 1995, 1996, 2002 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -23,7 +23,7 @@
 #ifdef EXT2FS_ENABLE_SWAPFS
 void ext2fs_swap_super(struct ext2_super_block * sb)
 {
-  	int i;
+	int i;
 	sb->s_inodes_count = ext2fs_swab32(sb->s_inodes_count);
 	sb->s_blocks_count = ext2fs_swab32(sb->s_blocks_count);
 	sb->s_r_blocks_count = ext2fs_swab32(sb->s_r_blocks_count);
@@ -108,11 +108,11 @@ void ext2fs_swap_ext_attr(char *to, char *from, int bufsize, int has_header)
 	}
 
 	while ((char *)from_entry < from_end && *(__u32 *)from_entry) {
-		to_entry->e_value_offs  =	
+		to_entry->e_value_offs  =
 			ext2fs_swab16(from_entry->e_value_offs);
-		to_entry->e_value_block =	
+		to_entry->e_value_block =
 			ext2fs_swab32(from_entry->e_value_block);
-		to_entry->e_value_size  =	
+		to_entry->e_value_size  =
 			ext2fs_swab32(from_entry->e_value_size);
 		from_entry = EXT2_EXT_ATTR_NEXT(from_entry);
 		to_entry   = EXT2_EXT_ATTR_NEXT(to_entry);
diff --git a/e2fsprogs/ext2fs/test_io.c b/e2fsprogs/ext2fs/test_io.c
index 6a3b248e9..d4b36532f 100644
--- a/e2fsprogs/ext2fs/test_io.c
+++ b/e2fsprogs/ext2fs/test_io.c
@@ -32,7 +32,7 @@
 
 #define EXT2_CHECK_MAGIC(struct, code) \
 	  if ((struct)->magic != (code)) return (code)
-  
+
 struct test_private_data {
 	int	magic;
 	io_channel real;
@@ -56,7 +56,7 @@ static errcode_t test_write_blk(io_channel channel, unsigned long block,
 static errcode_t test_flush(io_channel channel);
 static errcode_t test_write_byte(io_channel channel, unsigned long offset,
 				 int count, const void *buf);
-static errcode_t test_set_option(io_channel channel, const char *option, 
+static errcode_t test_set_option(io_channel channel, const char *option,
 				 const char *arg);
 
 static struct struct_io_manager struct_test_manager = {
@@ -172,10 +172,10 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel)
 			goto cleanup;
 	} else
 		data->real = 0;
-	data->read_blk = 	test_io_cb_read_blk;
-	data->write_blk = 	test_io_cb_write_blk;
-	data->set_blksize = 	test_io_cb_set_blksize;
-	data->write_byte = 	test_io_cb_write_byte;
+	data->read_blk =	test_io_cb_read_blk;
+	data->write_blk =	test_io_cb_write_blk;
+	data->set_blksize =	test_io_cb_set_blksize;
+	data->write_byte =	test_io_cb_write_byte;
 
 	data->outfile = NULL;
 	if ((value = getenv("TEST_IO_LOGFILE")) != NULL)
@@ -186,7 +186,7 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel)
 	data->flags = 0;
 	if ((value = getenv("TEST_IO_FLAGS")) != NULL)
 		data->flags = strtoul(value, NULL, 0);
-	
+
 	data->block = 0;
 	if ((value = getenv("TEST_IO_BLOCK")) != NULL)
 		data->block = strtoul(value, NULL, 0);
@@ -198,7 +198,7 @@ static errcode_t test_open(const char *name, int flags, io_channel *channel)
 	data->write_abort_count = 0;
 	if ((value = getenv("TEST_IO_WRITE_ABORT")) != NULL)
 		data->write_abort_count = strtoul(value, NULL, 0);
-	
+
 	*channel = io;
 	return 0;
 
@@ -221,13 +221,13 @@ static errcode_t test_close(io_channel channel)
 
 	if (--channel->refcount > 0)
 		return 0;
-	
+
 	if (data->real)
 		retval = io_channel_close(data->real);
 
 	if (data->outfile && data->outfile != stderr)
 		fclose(data->outfile);
-	
+
 	ext2fs_free_mem(&channel->private_data);
 	if (channel->name)
 		ext2fs_free_mem(&channel->name);
@@ -280,7 +280,7 @@ static errcode_t test_read_blk(io_channel channel, unsigned long block,
 			test_dump_block(channel, data, block, buf);
 		if (--data->read_abort_count == 0)
 			test_abort(channel, block);
-	} 
+	}
 	return retval;
 }
 
@@ -339,22 +339,22 @@ static errcode_t test_flush(io_channel channel)
 {
 	struct test_private_data *data;
 	errcode_t	retval = 0;
-	
+
 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 	data = (struct test_private_data *) channel->private_data;
 	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL);
 
 	if (data->real)
 		retval = io_channel_flush(data->real);
-	
+
 	if (data->flags & TEST_FLAG_FLUSH)
 		fprintf(data->outfile, "Test_io: flush() returned %s\n",
 			retval ? error_message(retval) : "OK");
-	
+
 	return retval;
 }
 
-static errcode_t test_set_option(io_channel channel, const char *option, 
+static errcode_t test_set_option(io_channel channel, const char *option,
 				 const char *arg)
 {
 	struct test_private_data *data;
@@ -366,10 +366,10 @@ static errcode_t test_set_option(io_channel channel, const char *option,
 
 
 	if (data->flags & TEST_FLAG_SET_OPTION)
-		fprintf(data->outfile, "Test_io: set_option(%s, %s) ", 
+		fprintf(data->outfile, "Test_io: set_option(%s, %s) ",
 			option, arg);
 	if (data->real && data->real->manager->set_option) {
-		retval = (data->real->manager->set_option)(data->real, 
+		retval = (data->real->manager->set_option)(data->real,
 							   option, arg);
 		if (data->flags & TEST_FLAG_SET_OPTION)
 			fprintf(data->outfile, "returned %s\n",
diff --git a/e2fsprogs/ext2fs/unix_io.c b/e2fsprogs/ext2fs/unix_io.c
index 5bc7a6abe..36b222577 100644
--- a/e2fsprogs/ext2fs/unix_io.c
+++ b/e2fsprogs/ext2fs/unix_io.c
@@ -1,13 +1,13 @@
 /*
  * unix_io.c --- This is the Unix (well, really POSIX) implementation
- * 	of the I/O manager.
+ *	of the I/O manager.
  *
  * Implements a one-block write-through cache.
  *
- * Includes support for Windows NT support under Cygwin. 
+ * Includes support for Windows NT support under Cygwin.
  *
  * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- * 	2002 by Theodore Ts'o.
+ *	2002 by Theodore Ts'o.
  *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
@@ -79,7 +79,7 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block,
 static errcode_t unix_flush(io_channel channel);
 static errcode_t unix_write_byte(io_channel channel, unsigned long offset,
 				int size, const void *data);
-static errcode_t unix_set_option(io_channel channel, const char *option, 
+static errcode_t unix_set_option(io_channel channel, const char *option,
 				 const char *arg);
 
 static void reuse_cache(io_channel channel, struct unix_private_data *data,
@@ -140,7 +140,7 @@ static errcode_t raw_read_blk(io_channel channel,
 		goto error_out;
 	}
 	return 0;
-	
+
 error_out:
 	memset((char *) buf+actual, 0, size-actual);
 	if (channel->read_error)
@@ -168,7 +168,7 @@ static errcode_t raw_read_blk(io_channel channel,
 	location = ((ext2_loff_t) block * channel->block_size) + data->offset;
 #ifdef DEBUG
 	printf("count=%d, size=%d, block=%d, blk_size=%d, location=%lx\n",
-	 		count, size, block, channel->block_size, location);
+			count, size, block, channel->block_size, location);
 #endif
 	if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) {
 		retval = errno ? errno : EXT2_ET_LLSEEK_FAILED;
@@ -227,14 +227,14 @@ static errcode_t raw_write_blk(io_channel channel,
 		retval = errno ? errno : EXT2_ET_LLSEEK_FAILED;
 		goto error_out;
 	}
-	
+
 	actual = write(data->dev, buf, size);
 	if (actual != size) {
 		retval = EXT2_ET_SHORT_WRITE;
 		goto error_out;
 	}
 	return 0;
-	
+
 error_out:
 	if (channel->write_error)
 		retval = (channel->write_error)(channel, block, count, buf,
@@ -254,7 +254,7 @@ static errcode_t alloc_cache(io_channel channel,
 	errcode_t		retval;
 	struct unix_cache	*cache;
 	int			i;
-	
+
 	data->access_time = 0;
 	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
 		cache->block = 0;
@@ -273,7 +273,7 @@ static void free_cache(struct unix_private_data *data)
 {
 	struct unix_cache	*cache;
 	int			i;
-	
+
 	data->access_time = 0;
 	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
 		cache->block = 0;
@@ -298,7 +298,7 @@ static struct unix_cache *find_cached_block(struct unix_private_data *data,
 {
 	struct unix_cache	*cache, *unused_cache, *oldest_cache;
 	int			i;
-	
+
 	unused_cache = oldest_cache = 0;
 	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
 		if (!cache->in_use) {
@@ -345,18 +345,18 @@ static errcode_t flush_cached_blocks(io_channel channel,
 	struct unix_cache	*cache;
 	errcode_t		retval, retval2;
 	int			i;
-	
+
 	retval2 = 0;
 	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
 		if (!cache->in_use)
 			continue;
-		
+
 		if (invalidate)
 			cache->in_use = 0;
-		
+
 		if (!cache->dirty)
 			continue;
-		
+
 		retval = raw_write_blk(channel, data,
 				       cache->block, 1, cache->buf);
 		if (retval)
@@ -376,7 +376,7 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel)
 	int		open_flags;
 	struct stat	st;
 #ifdef __linux__
-	struct 		utsname ut;
+	struct		utsname ut;
 #endif
 
 	if (name == 0)
@@ -431,7 +431,7 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel)
 	 * block devices are wrongly getting hit by the filesize
 	 * limit.  This workaround isn't perfect, since it won't work
 	 * if glibc wasn't built against 2.2 header files.  (Sigh.)
-	 * 
+	 *
 	 */
 	if ((flags & IO_FLAG_RW) &&
 	    (uname(&ut) == 0) &&
@@ -442,7 +442,7 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel)
 	    (fstat(data->dev, &st) == 0) &&
 	    (S_ISBLK(st.st_mode))) {
 		struct rlimit	rlim;
-		
+
 		rlim.rlim_cur = rlim.rlim_max = (unsigned long) RLIM_INFINITY;
 		setrlimit(RLIMIT_FSIZE, &rlim);
 		getrlimit(RLIMIT_FSIZE, &rlim);
@@ -507,7 +507,7 @@ static errcode_t unix_set_blksize(io_channel channel, int blksize)
 		if ((retval = flush_cached_blocks(channel, data, 0)))
 			return retval;
 #endif
-		
+
 		channel->block_size = blksize;
 		free_cache(data);
 		if ((retval = alloc_cache(channel, data)))
@@ -568,7 +568,7 @@ static errcode_t unix_read_blk(io_channel channel, unsigned long block,
 #endif
 		if ((retval = raw_read_blk(channel, data, block, i, cp)))
 			return retval;
-		
+
 		/* Save the results in the cache */
 		for (j=0; j < i; j++) {
 			count--;
@@ -597,7 +597,7 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block,
 
 #ifdef NO_IO_CACHE
 	return raw_write_blk(channel, data, block, count, buf);
-#else	
+#else
 	/*
 	 * If we're doing an odd-sized write or a very large write,
 	 * flush out the cache completely and then do a direct write.
@@ -616,7 +616,7 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block,
 	writethrough = channel->flags & CHANNEL_FLAGS_WRITETHROUGH;
 	if (writethrough)
 		retval = raw_write_blk(channel, data, block, count, buf);
-	
+
 	cp = buf;
 	while (count > 0) {
 		cache = find_cached_block(data, block, &reuse);
@@ -655,7 +655,7 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset,
 
 	if (lseek(data->dev, offset + data->offset, SEEK_SET) < 0)
 		return errno;
-	
+
 	actual = write(data->dev, buf, size);
 	if (actual != size)
 		return EXT2_ET_SHORT_WRITE;
@@ -664,13 +664,13 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset,
 }
 
 /*
- * Flush data buffers to disk.  
+ * Flush data buffers to disk.
  */
 static errcode_t unix_flush(io_channel channel)
 {
 	struct unix_private_data *data;
 	errcode_t retval = 0;
-	
+
 	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 	data = (struct unix_private_data *) channel->private_data;
 	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
@@ -682,7 +682,7 @@ static errcode_t unix_flush(io_channel channel)
 	return retval;
 }
 
-static errcode_t unix_set_option(io_channel channel, const char *option, 
+static errcode_t unix_set_option(io_channel channel, const char *option,
 				 const char *arg)
 {
 	struct unix_private_data *data;
diff --git a/e2fsprogs/ext2fs/unlink.c b/e2fsprogs/ext2fs/unlink.c
index e7b2182d2..a6ab53ae8 100644
--- a/e2fsprogs/ext2fs/unlink.c
+++ b/e2fsprogs/ext2fs/unlink.c
@@ -1,6 +1,6 @@
 /*
  * unlink.c --- delete links in a ext2fs directory
- * 
+ *
  * Copyright (C) 1993, 1994, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -25,7 +25,7 @@ struct link_struct  {
 	int		flags;
 	struct ext2_dir_entry *prev;
 	int		done;
-};	
+};
 
 #ifdef __TURBOC__
  #pragma argsused
@@ -56,7 +56,7 @@ static int unlink_proc(struct ext2_dir_entry *dirent,
 			return 0;
 	}
 
-	if (prev) 
+	if (prev)
 		prev->rec_len += dirent->rec_len;
 	else
 		dirent->inode = 0;
@@ -89,7 +89,7 @@ errcode_t ext2fs_unlink(ext2_filsys fs, ext2_ino_t dir,
 	ls.done = 0;
 	ls.prev = 0;
 
-	retval = ext2fs_dir_iterate(fs, dir, DIRENT_FLAG_INCLUDE_EMPTY, 
+	retval = ext2fs_dir_iterate(fs, dir, DIRENT_FLAG_INCLUDE_EMPTY,
 				    0, unlink_proc, &ls);
 	if (retval)
 		return retval;
diff --git a/e2fsprogs/ext2fs/valid_blk.c b/e2fsprogs/ext2fs/valid_blk.c
index 29ff27a7c..d0367e71c 100644
--- a/e2fsprogs/ext2fs/valid_blk.c
+++ b/e2fsprogs/ext2fs/valid_blk.c
@@ -2,12 +2,12 @@
  * valid_blk.c --- does the inode have valid blocks?
  *
  * Copyright 1997 by Theodore Ts'o
- * 
+ *
  * %Begin-Header%
  * This file may be redistributed under the terms of the GNU Public
  * License.
  * %End-Header%
- * 
+ *
  */
 
 #include <stdio.h>
@@ -33,7 +33,7 @@ int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode)
 	if (!LINUX_S_ISDIR(inode->i_mode) && !LINUX_S_ISREG(inode->i_mode) &&
 	    !LINUX_S_ISLNK(inode->i_mode))
 		return 0;
-	
+
 	/*
 	 * If the symbolic link is a "fast symlink", then the symlink
 	 * target is stored in the block entries.
diff --git a/e2fsprogs/fsck.c b/e2fsprogs/fsck.c
index 848d559bc..af76c4d21 100644
--- a/e2fsprogs/fsck.c
+++ b/e2fsprogs/fsck.c
@@ -104,10 +104,10 @@ struct fsck_instance {
  * assure that we only fsck one partition on a particular drive at any
  * one time.  Otherwise, the disk heads will be seeking all over the
  * place.  If the base device can not be determined, return NULL.
- * 
+ *
  * The base_device() function returns an allocated string which must
  * be freed.
- * 
+ *
  */
 
 
diff --git a/e2fsprogs/lsattr.c b/e2fsprogs/lsattr.c
index e25f36d82..b5ec8ab98 100644
--- a/e2fsprogs/lsattr.c
+++ b/e2fsprogs/lsattr.c
@@ -97,8 +97,8 @@ static void lsattr_args(const char *name)
 	}
 }
 
-static int lsattr_dir_proc(const char *dir_name, struct dirent *de, 
-                           void *private EXT2FS_ATTR((unused)))
+static int lsattr_dir_proc(const char *dir_name, struct dirent *de,
+			   void *private EXT2FS_ATTR((unused)))
 {
 	STRUCT_STAT	st;
 	char *path;
diff --git a/e2fsprogs/mke2fs.c b/e2fsprogs/mke2fs.c
index 9c4f1c4d0..10563e2d9 100644
--- a/e2fsprogs/mke2fs.c
+++ b/e2fsprogs/mke2fs.c
@@ -107,9 +107,9 @@ static const struct mke2fs_defaults settings[] = {
 	{ default_str,	 3, 1024, 8192 },
 	{ "journal",	 0, 4096, 8192 },
 	{ "news",	 0, 4096, 4096 },
-	{ "largefile", 	 0, 4096, 1024 * 1024 },
+	{ "largefile",	 0, 4096, 1024 * 1024 },
 	{ "largefile4",  0, 4096, 4096 * 1024 },
-	{ 0, 		 0,    0, 0},
+	{ 0,		 0,    0, 0},
 };
 
 static void set_fs_defaults(const char *fs_type,
@@ -448,7 +448,7 @@ static void write_inode_tables(ext2_filsys fs)
 		num = fs->inode_blocks_per_group;
 
 		retval = zero_blocks(fs, blk, num, 0, &blk, &num);
-		mke2fs_error_msg_and_die(retval, 
+		mke2fs_error_msg_and_die(retval,
 			"write %d blocks in inode table starting at %d.",
 			num, blk);
 		if (sync_kludge) {
@@ -572,7 +572,7 @@ static void zap_sector(ext2_filsys fs, int sect, int nsect)
 
 static void create_journal_dev(ext2_filsys fs)
 {
-	struct progress_struct 	progress;
+	struct progress_struct	progress;
 	errcode_t		retval;
 	char			*buf;
 	char			*fmt = "%s journal superblock";
@@ -624,7 +624,7 @@ static void show_stats(ext2_filsys fs)
 			os,
 			fs->blocksize, s->s_log_block_size,
 			fs->fragsize, s->s_log_frag_size,
-			s->s_inodes_count, s->s_blocks_count, 
+			s->s_inodes_count, s->s_blocks_count,
 			s->s_r_blocks_count, 100.0 * s->s_r_blocks_count / s->s_blocks_count,
 			s->s_first_data_block);
 	free(os);
@@ -679,7 +679,7 @@ static int set_os(struct ext2_super_block *sb, char *os)
 	if((sb->s_creator_os = e2p_string2os(os)) >= 0) {
 		return 1;
 	} else if (!strcasecmp("GNU", os)) {
- 		sb->s_creator_os = EXT2_OS_HURD;
+		sb->s_creator_os = EXT2_OS_HURD;
 		return 1;
 	}
 	return 0;
@@ -842,7 +842,7 @@ static int PRS(int argc, char *argv[])
 #endif
 
 	/* If called as mkfs.ext3, create a journal inode */
-	if (last_char_is(bb_applet_name, '3')) 
+	if (last_char_is(bb_applet_name, '3'))
 		journal_size = -1;
 
 	while ((c = getopt (argc, argv,
@@ -886,8 +886,8 @@ BLOCKSIZE_ERROR:
 			}
 			break;
 		case 'i':
-			if (safe_strtoi(optarg, &inode_ratio) 
-				|| inode_ratio < EXT2_MIN_BLOCK_SIZE 
+			if (safe_strtoi(optarg, &inode_ratio)
+				|| inode_ratio < EXT2_MIN_BLOCK_SIZE
 				|| inode_ratio > EXT2_MAX_BLOCK_SIZE * 1024) {
 				bb_error_msg_and_die("bad inode ratio %s (min %d/max %d)",
 					optarg, EXT2_MIN_BLOCK_SIZE,
diff --git a/e2fsprogs/tune2fs.c b/e2fsprogs/tune2fs.c
index f23688bc3..f228c56aa 100644
--- a/e2fsprogs/tune2fs.c
+++ b/e2fsprogs/tune2fs.c
@@ -163,7 +163,7 @@ no_valid_journal:
 
 /* Helper function for remove_journal_inode */
 static int release_blocks_proc(ext2_filsys fs, blk_t *blocknr,
-			       int blockcnt EXT2FS_ATTR((unused)), 
+			       int blockcnt EXT2FS_ATTR((unused)),
 			       void *private EXT2FS_ATTR((unused)))
 {
 	blk_t	block;
@@ -187,9 +187,9 @@ static void remove_journal_inode(ext2_filsys fs)
 	ino_t			ino = fs->super->s_journal_inum;
 	char *msg = "to read";
 	char *s = "journal inode";
-	
+
 	retval = ext2fs_read_inode(fs, ino,  &inode);
-	if (retval) 
+	if (retval)
 		goto REMOVE_JOURNAL_INODE_ERROR;
 	if (ino == EXT2_JOURNAL_INO) {
 		retval = ext2fs_read_bitmaps(fs);
@@ -343,13 +343,13 @@ static void add_journal(ext2_filsys fs)
 	return;
 }
 
-/*  
+/*
  * Busybox stuff
  */
 static char * x_blkid_get_devname(const char *token)
 {
 	char * dev_name;
-	
+
 	if (!(dev_name = blkid_get_devname(NULL, token, NULL)))
 		bb_error_msg_and_die("Unable to resolve '%s'", token);
 	return dev_name;
@@ -368,11 +368,11 @@ static void parse_e2label_options(int argc, char ** argv)
 		open_flag = EXT2_FLAG_RW | EXT2_FLAG_JOURNAL_DEV_OK;
 		L_flag = 1;
 		new_label = argv[2];
-	} else 
+	} else
 		print_label++;
 }
 #else
-#define parse_e2label_options(x,y)         
+#define parse_e2label_options(x,y)
 #endif
 
 static time_t parse_time(char *str)
@@ -516,7 +516,7 @@ MOUNTS_COUNT_ERROR:
 				mntopts_cmd = optarg;
 				open_flag = EXT2_FLAG_RW;
 				break;
-				
+
 			case 'O':
 				if (features_cmd) {
 					bb_error_msg_and_die("-O may only be specified once");
@@ -594,7 +594,7 @@ int tune2fs_main(int argc, char **argv)
 
 	if (ENABLE_FEATURE_CLEAN_UP)
 		atexit(clean_up);
-		
+
 	if (ENABLE_FINDFS && (bb_applet_name[0] == 'f')) /* findfs */
 		do_findfs(argc, argv);  /* no return */
 	else if (ENABLE_E2LABEL && (bb_applet_name[0] == 'e')) /* e2label */
@@ -603,7 +603,7 @@ int tune2fs_main(int argc, char **argv)
 		parse_tune2fs_options(argc, argv);  /* tune2fs */
 
 	io_ptr = unix_io_manager;
-	retval = ext2fs_open2(device_name, io_options, open_flag, 
+	retval = ext2fs_open2(device_name, io_options, open_flag,
 			      0, 0, io_ptr, &fs);
 	if (retval)
 		bb_error_msg_and_die("No valid superblock on %s", device_name);
diff --git a/e2fsprogs/util.c b/e2fsprogs/util.c
index 7e9c09234..3902f7ef3 100644
--- a/e2fsprogs/util.c
+++ b/e2fsprogs/util.c
@@ -1,6 +1,6 @@
 /*
  * util.c --- helper functions used by tune2fs and mke2fs
- * 
+ *
  * Copyright 1995, 1996, 1997, 1998, 1999, 2000 by Theodore Ts'o.
  *
  * %Begin-Header%
@@ -99,8 +99,8 @@ void check_mount(const char *device, int force, const char *type)
 		bb_error_msg_and_die("will not make a %s here!", type);
 }
 
-void parse_journal_opts(char **journal_device, int *journal_flags, 
-                        int *journal_size, const char *opts)
+void parse_journal_opts(char **journal_device, int *journal_flags,
+			int *journal_size, const char *opts)
 {
 	char *buf, *token, *next, *p, *arg;
 	int journal_usage = 0;
@@ -118,7 +118,7 @@ void parse_journal_opts(char **journal_device, int *journal_flags,
 		if (p) {
 			*p = 0;
 			next = p+1;
-		} 
+		}
 		arg = strchr(token, '=');
 		if (arg) {
 			*arg = 0;
@@ -155,13 +155,13 @@ void parse_journal_opts(char **journal_device, int *journal_flags,
 			"\tdevice=<journal device>\n\n"
 			"The journal size must be between "
 			"1024 and 102400 filesystem blocks.\n\n");
-}	
+}
 
 /*
  * Determine the number of journal blocks to use, either via
  * user-specified # of megabytes, or via some intelligently selected
  * defaults.
- * 
+ *
  * Find a reasonable journal file size (in blocks) given the number of blocks
  * in the filesystem.  For very small filesystems, it is not reasonable to
  * have a journal that fills more than half of the filesystem.
@@ -214,8 +214,8 @@ void make_journal_device(char *journal_device, ext2_filsys fs, int quiet, int fo
 	io_manager	io_ptr;
 
 	check_plausibility(journal_device, force);
-	check_mount(journal_device, force, "journal");	
-	io_ptr = unix_io_manager;	
+	check_mount(journal_device, force, "journal");
+	io_ptr = unix_io_manager;
 	retval = ext2fs_open(journal_device, EXT2_FLAG_RW|
 					EXT2_FLAG_JOURNAL_DEV_OK, 0,
 					fs->blocksize, io_ptr, &jfs);
@@ -236,7 +236,7 @@ void make_journal_blocks(ext2_filsys fs, int journal_size, int journal_flags, in
 {
 	unsigned long journal_blocks;
 	errcode_t	retval;
-		
+
 	journal_blocks = figure_journal_size(journal_size, fs);
 	if (!journal_blocks) {
 		fs->super->s_feature_compat &=
@@ -259,9 +259,9 @@ char *e2fs_set_sbin_path(void)
 	char *oldpath = getenv("PATH");
 	/* Update our PATH to include /sbin  */
 #define PATH_SET "/sbin"
-	if (oldpath) 
+	if (oldpath)
 		oldpath = bb_xasprintf("%s:%s", PATH_SET, oldpath);
-	 else 
+	 else
 		oldpath = PATH_SET;
 	putenv (oldpath);
 	return oldpath;
diff --git a/e2fsprogs/util.h b/e2fsprogs/util.h
index 24d5e6545..5041046c7 100644
--- a/e2fsprogs/util.h
+++ b/e2fsprogs/util.h
@@ -1,7 +1,7 @@
 /*
  * util.h --- header file defining prototypes for helper functions
  * used by tune2fs and mke2fs
- * 
+ *
  * Copyright 2000 by Theodore Ts'o.
  *
  * %Begin-Header%
diff --git a/e2fsprogs/uuid/compare.c b/e2fsprogs/uuid/compare.c
index 83afeafbf..94c32b1d3 100644
--- a/e2fsprogs/uuid/compare.c
+++ b/e2fsprogs/uuid/compare.c
@@ -2,7 +2,7 @@
  * compare.c --- compare whether or not two UUID's are the same
  *
  * Returns 0 if the two UUID's are different, and 1 if they are the same.
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -18,7 +18,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
diff --git a/e2fsprogs/uuid/gen_uuid.c b/e2fsprogs/uuid/gen_uuid.c
index 52328cfc4..fca3ebe91 100644
--- a/e2fsprogs/uuid/gen_uuid.c
+++ b/e2fsprogs/uuid/gen_uuid.c
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
@@ -63,8 +63,8 @@
 #include "uuidP.h"
 
 #ifdef HAVE_SRANDOM
-#define srand(x) 	srandom(x)
-#define rand() 		random()
+#define srand(x)	srandom(x)
+#define rand()		random()
 #endif
 
 static int get_random_fd(void)
@@ -111,7 +111,7 @@ static void get_random_bytes(void *buf, int nbytes)
 			lose_counter = 0;
 		}
 	}
-	
+
 	/*
 	 * We do this all the time, but this is the only source of
 	 * randomness if /dev/random/urandom is out to lunch.
@@ -127,12 +127,12 @@ static void get_random_bytes(void *buf, int nbytes)
 static int get_node_id(unsigned char *node_id)
 {
 #ifdef HAVE_NET_IF_H
-	int 		sd;
-	struct ifreq 	ifr, *ifrp;
-	struct ifconf 	ifc;
+	int		sd;
+	struct ifreq	ifr, *ifrp;
+	struct ifconf	ifc;
 	char buf[1024];
 	int		n, i;
-	unsigned char 	*a;
+	unsigned char	*a;
 #ifdef HAVE_NET_IF_DL_H
 	struct sockaddr_dl *sdlp;
 #endif
@@ -140,7 +140,7 @@ static int get_node_id(unsigned char *node_id)
 /*
  * BSD 4.4 defines the size of an ifreq to be
  * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
- * However, under earlier systems, sa_len isn't present, so the size is 
+ * However, under earlier systems, sa_len isn't present, so the size is
  * just sizeof(struct ifreq)
  */
 #ifdef HAVE_SA_LEN
@@ -214,9 +214,9 @@ static int get_clock(uint32_t *clock_high, uint32_t *clock_low, uint16_t *ret_cl
 	static int			adjustment = 0;
 	static struct timeval		last = {0, 0};
 	static uint16_t			clock_seq;
-	struct timeval 			tv;
+	struct timeval			tv;
 	unsigned long long		clock_reg;
-	
+
 try_again:
 	gettimeofday(&tv, 0);
 	if ((last.tv_sec == 0) && (last.tv_usec == 0)) {
@@ -240,7 +240,7 @@ try_again:
 		adjustment = 0;
 		last = tv;
 	}
-		
+
 	clock_reg = tv.tv_usec*10 + adjustment;
 	clock_reg += ((unsigned long long) tv.tv_sec)*10000000;
 	clock_reg += (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000;
diff --git a/e2fsprogs/uuid/pack.c b/e2fsprogs/uuid/pack.c
index 1013886e5..9d733f000 100644
--- a/e2fsprogs/uuid/pack.c
+++ b/e2fsprogs/uuid/pack.c
@@ -1,6 +1,6 @@
 /*
  * Internal routine for packing UUID's
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
diff --git a/e2fsprogs/uuid/parse.c b/e2fsprogs/uuid/parse.c
index 07b894d11..21b29498e 100644
--- a/e2fsprogs/uuid/parse.c
+++ b/e2fsprogs/uuid/parse.c
@@ -1,6 +1,6 @@
 /*
  * parse.c --- UUID parsing
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
@@ -42,7 +42,7 @@
 int uuid_parse(const char *in, uuid_t uu)
 {
 	struct uuid	uuid;
-	int 		i;
+	int		i;
 	const char	*cp;
 	char		buf[3];
 
@@ -73,7 +73,7 @@ int uuid_parse(const char *in, uuid_t uu)
 		buf[1] = *cp++;
 		uuid.node[i] = strtoul(buf, NULL, 16);
 	}
-	
+
 	uuid_pack(&uuid, uu);
 	return 0;
 }
diff --git a/e2fsprogs/uuid/unpack.c b/e2fsprogs/uuid/unpack.c
index d63589521..8f9c520c1 100644
--- a/e2fsprogs/uuid/unpack.c
+++ b/e2fsprogs/uuid/unpack.c
@@ -1,6 +1,6 @@
 /*
  * Internal routine for unpacking UUID
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
diff --git a/e2fsprogs/uuid/unparse.c b/e2fsprogs/uuid/unparse.c
index c0e08ef49..a95bbb042 100644
--- a/e2fsprogs/uuid/unparse.c
+++ b/e2fsprogs/uuid/unparse.c
@@ -1,6 +1,6 @@
 /*
  * unparse.c -- convert a UUID to string
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
@@ -36,10 +36,10 @@
 
 #include "uuidP.h"
 
-static const char *fmt_lower = 
+static const char *fmt_lower =
 	"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
 
-static const char *fmt_upper = 
+static const char *fmt_upper =
 	"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X";
 
 #ifdef UUID_UNPARSE_DEFAULT_UPPER
diff --git a/e2fsprogs/uuid/uuid.h b/e2fsprogs/uuid/uuid.h
index a05f1c690..cd97a5e78 100644
--- a/e2fsprogs/uuid/uuid.h
+++ b/e2fsprogs/uuid/uuid.h
@@ -1,6 +1,6 @@
 /*
  * Public include file for the UUID library
- * 
+ *
  * Copyright (C) 1996, 1997, 1998 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
@@ -42,8 +42,8 @@
 typedef unsigned char uuid_t[16];
 
 /* UUID Variant definitions */
-#define UUID_VARIANT_NCS 	0
-#define UUID_VARIANT_DCE 	1
+#define UUID_VARIANT_NCS	0
+#define UUID_VARIANT_DCE	1
 #define UUID_VARIANT_MICROSOFT	2
 #define UUID_VARIANT_OTHER	3
 
diff --git a/e2fsprogs/uuid/uuidP.h b/e2fsprogs/uuid/uuidP.h
index d2e1a450a..9d30ce2f8 100644
--- a/e2fsprogs/uuid/uuidP.h
+++ b/e2fsprogs/uuid/uuidP.h
@@ -1,6 +1,6 @@
 /*
  * uuid.h -- private header file for uuids
- * 
+ *
  * Copyright (C) 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -16,7 +16,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
diff --git a/e2fsprogs/uuid/uuid_time.c b/e2fsprogs/uuid/uuid_time.c
index d5f992b39..9ff3607d8 100644
--- a/e2fsprogs/uuid/uuid_time.c
+++ b/e2fsprogs/uuid/uuid_time.c
@@ -1,8 +1,8 @@
 /*
  * uuid_time.c --- Interpret the time field from a uuid.  This program
- * 	violates the UUID abstraction barrier by reaching into the guts
+ *	violates the UUID abstraction barrier by reaching into the guts
  *	of a UUID and interpreting it.
- * 
+ *
  * Copyright (C) 1998, 1999 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -18,7 +18,7 @@
  * 3. The name of the author may not be used to endorse or promote
  *    products derived from this software without specific prior
  *    written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
@@ -51,7 +51,7 @@ time_t uuid_time(const uuid_t uu, struct timeval *ret_tv)
 	unsigned long long	clock_reg;
 
 	uuid_unpack(uu, &uuid);
-	
+
 	high = uuid.time_mid | ((uuid.time_hi_and_version & 0xFFF) << 16);
 	clock_reg = uuid.time_low | ((unsigned long long) high << 32);
 
@@ -69,7 +69,7 @@ int uuid_type(const uuid_t uu)
 {
 	struct uuid		uuid;
 
-	uuid_unpack(uu, &uuid);	
+	uuid_unpack(uu, &uuid);
 	return ((uuid.time_hi_and_version >> 12) & 0xF);
 }
 
@@ -78,7 +78,7 @@ int uuid_variant(const uuid_t uu)
 	struct uuid		uuid;
 	int			var;
 
-	uuid_unpack(uu, &uuid);	
+	uuid_unpack(uu, &uuid);
 	var = uuid.clock_seq;
 
 	if ((var & 0x8000) == 0)
@@ -105,7 +105,7 @@ static const char *variant_string(int variant)
 	}
 }
 
-	
+
 int
 main(int argc, char **argv)
 {
@@ -155,7 +155,7 @@ main(int argc, char **argv)
 	}
 	printf("UUID time is: (%ld, %ld): %s\n", tv.tv_sec, tv.tv_usec,
 	       ctime(&time_reg));
-	
+
 	return 0;
 }
 #endif
-- 
cgit v1.2.3