diff --git a/debugfs/ChangeLog b/debugfs/ChangeLog
index aa703ab..0abfefb 100644
--- a/debugfs/ChangeLog
+++ b/debugfs/ChangeLog
@@ -1,3 +1,8 @@
+Thu May  8 23:05:40 1997  Theodore Ts'o  <tytso@rsts-11.mit.edu>
+
+	* debugfs.8.in: Fix minor typos and grammer oops found by Bill
+ 		Hawes (whawes@star.net).
+
 Thu Apr 24 12:16:42 1997  Theodre Ts'o  <tytso@localhost.mit.edu>
 
 	* Release of E2fsprogs version 1.10
diff --git a/debugfs/debugfs.8.in b/debugfs/debugfs.8.in
index 72b12ec..0e81ca1 100644
--- a/debugfs/debugfs.8.in
+++ b/debugfs/debugfs.8.in
@@ -34,8 +34,8 @@
 .SH OPTIONS
 .TP
 .I -w
-Specify that the file system should be open in read-write mode. Without this
-option, the file system is open in read-only mode.
+Specifies that the file system should be opened in read-write mode.
+Without this option, the file system is opened in read-only mode.
 .TP
 .I -f cmd_file
 Causes 
@@ -44,7 +44,7 @@
 .IR cmd_file , 
 and execute them.  When 
 .B debugfs
-is finsihed executing those commands, it will exit.
+is finished executing those commands, it will exit.
 .TP 
 .I -R request
 Causes 
@@ -95,10 +95,10 @@
 .I find_free_block [goal]
 Find the first free block, starting from
 .I goal
-and allocates it.
+and allocate it.
 .TP
 .I find_free_inode [dir [mode]]
-Find a free inode and allocates it.  If present, 
+Find a free inode and allocate it.  If present, 
 .I dir
 specifies the inode number of the directory 
 which the inode is to be located.  The second 
@@ -114,14 +114,14 @@
 .TP
 .I freei filespec
 Free the inode specified by 
-.I filespec
+.IR filespec .
 .TP
 .I help
 Print a list of commands understood by 
 .BR debugfs (8).
 .TP
 .I icheck block ...
-Print a listing of the inodes which use the one or more block specified
+Print a listing of the inodes which use the one or more blocks specified
 on the command line.
 .TP
 .I initialize device blocksize
@@ -136,11 +136,11 @@
 the superblock and block descriptors.
 .TP
 .I kill_file filespec
-Dellocate the inode 
+Deallocate the inode 
 .I filespec
 and its blocks.  Note that this does not remove any directory
 entries (if any) to this inode.  See the 
-.I rm
+.BR rm (1)
 command if you wish to unlink a file.
 .TP
 .I ln filespec dest_file
@@ -170,7 +170,7 @@
 device numbers must be specified.
 .TP
 .I ncheck inode_num ...
-Take the requested list of inode numbers, and print a listing of pathnams
+Take the requested list of inode numbers, and print a listing of pathnames
 to those inodes.
 .TP
 .I open [-w] device
@@ -186,7 +186,7 @@
 .I rm pathname
 Unlink 
 .IR pathname .
-If this cuases the inode pointed to by 
+If this causes the inode pointed to by 
 .I pathname
 to have no other references, deallocate the file.  This command functions
 as the unlink() system call.
@@ -241,16 +241,23 @@
 commands take a
 .I filespec
 as an argument to specify an inode (as opposed to a pathname) 
-in the filesystem which is currently opened by debugfs. The
+in the filesystem which is currently opened by 
+.BR debugfs . 
+The
 .I filespec
 argument may be specified in two forms.  The first form is an inode 
 number surrounded by angle brackets, e.g., 
 .IR <2> .
 The second form is a pathname; if the pathname is prefixed by a forward slash
 ('/'), then it is interpreted relative to the root of the filesystem 
-which is currently opened by debugfs.  If not, the pathname is 
-interpreted relative to the current working directory as maintained 
-by debugfs.  This may be modified by using the debugfs command
+which is currently opened by 
+.BR debugfs .
+If not, the pathname is 
+interpreted relative to the current working directory as maintained by 
+.BR debugfs .  
+This may be modified by using the 
+.B debugfs
+command
 .IR cd .
 .SH AUTHOR
 .B debugfs
diff --git a/e2fsck/ChangeLog b/e2fsck/ChangeLog
index 5c6348b..b49d558 100644
--- a/e2fsck/ChangeLog
+++ b/e2fsck/ChangeLog
@@ -1,5 +1,8 @@
 Thu May  8 22:45:27 1997  Theodore Ts'o  <tytso@rsts-11.mit.edu>
 
+	* e2fsck.8.in: Fix minor typos and grammer oops found by Bill
+ 		Hawes (whawes@star.net).
+
 	* badblocks.c (read_bad_blocks_file): Pass the blocksize to the
 		bad blocks command so that all of the filesystem gets
  		tested in the case where the blocksize 2048 or 4096.
diff --git a/e2fsck/e2fsck.8.in b/e2fsck/e2fsck.8.in
index 7750b18..9cf9035 100644
--- a/e2fsck/e2fsck.8.in
+++ b/e2fsck/e2fsck.8.in
@@ -37,7 +37,7 @@
 option.  It is provided for backwards compatibility only; it is
 suggested that people use 
 .I -p 
-option whever possible.
+option whenever possible.
 .TP
 .I -b superblock
 Instead of using the normal superblock, use the alternative superblock
@@ -45,30 +45,37 @@
 .IR superblock .
 .TP
 .I -B blocksize
-Normally, e2fsck will search for the superblock at various different
-block sizes in an attempt to find the appropriate block size.  This
-search can be fooled in some cases.  This option forces e2fsck to only
-try locating the superblock at a particular blocksize.  If the
-superblock is not found, e2fsck will terminate with a fatal error.
+Normally, 
+.B e2fsck
+will search for the superblock at various different
+block sizes in an attempt to find the appropriate block size.
+This search can be fooled in some cases.  This option forces 
+.B e2fsck
+to only try locating the superblock at a particular blocksize.
+If the superblock is not found, 
+.B e2fsck 
+will terminate with a fatal error.
 .TP
 .I -c
-This option causes e2fsck to run the 
+This option causes 
+.B e2fsck 
+to run the 
 .BR badblocks (8)
-program to find any blocks 
-which are bad on the filesystem, and then marks them as bad by adding them 
-to the bad block inode.
+program to find any blocks which are bad on the filesystem, 
+and then marks them as bad by adding them to the bad block inode.
 .TP
 .I -d
 Print debugging output (useless unless you are debugging
-.B e2fsck
-).
+.BR e2fsck ).
 .TP
 .I -f
 Force checking even if the file system seems clean.
 .TP
 .I -F
 Flush the filesystem device's buffer caches before beginning.  Only
-really useful for doing e2fsck time trials.
+really useful for doing 
+.B e2fsck 
+time trials.
 .TP
 .I -l filename
 Add the blocks listed in the file specified by 
@@ -104,11 +111,13 @@
 .I -r
 This option does nothing at all; it is provided only for backwards
 compatibility.
-.IP 
+.TP 
 .I -s
 This option will byte-swap the filesystem so that it is using the normalized, 
 standard byte-order (which is i386 or little endian).  If the filesystem is
-already in the standard byte-order, e2fsck will take no action.
+already in the standard byte-order, 
+.B e2fsck 
+will take no action.
 .TP
 .I -S
 This option will byte-swap the filesystem, regardless of its current 
@@ -166,7 +175,7 @@
 have a writeable filesystem where the transcript can be stored, the 
 .BR script (1)
 program is a handy way to save the output of
-.e2fsck
+.B e2fsck
 to a file.
 .PP
 It is also useful to send the output of 
@@ -176,9 +185,9 @@
 trouble, try running the
 .BR debugfs (8)
 command and send the output of the 
-.I stat
-command run on the relevant inode(s).  If the inode is a directory, 
-the debugfs
+.BR stat (1u)
+command run on the relevant inode(s).  If the inode is a directory, the 
+.B debugfs
 .I dump
 command will allow you to extract the contents of the directory inode,
 which can sent to me after being first run through
@@ -190,7 +199,7 @@
 .SH AUTHOR
 This version of 
 .B e2fsck
-is written by Theodore Ts'o <tytso@mit.edu>.
+was written by Theodore Ts'o <tytso@mit.edu>.
 .SH SEE ALSO
 .BR mke2fs (8),
 .BR tune2fs (8),
diff --git a/misc/ChangeLog b/misc/ChangeLog
index b839560..c459966 100644
--- a/misc/ChangeLog
+++ b/misc/ChangeLog
@@ -1,5 +1,9 @@
 Thu May  8 22:22:08 1997  Theodore Ts'o  <tytso@rsts-11.mit.edu>
 
+	* badblocks.8.in, chattr.1.in, dumpe2fs.8.in, fsck.8.in, 
+		mke2fs.8.in, tune2fs.8.in: Fix minor typos and grammer
+		oops found by Bill Hawes (whawes@star.net).
+
 	* mke2fs.c (test_disk): Pass the blocksize to the bad blocks
  		command so that all of the filesystem gets tested in the
  		case where the blocksize 2048 or 4096.
diff --git a/misc/badblocks.8.in b/misc/badblocks.8.in
index f513318..88adb34 100644
--- a/misc/badblocks.8.in
+++ b/misc/badblocks.8.in
@@ -52,10 +52,10 @@
 This option erases data!
 .SH AUTHOR
 .B badblocks
-has been written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
+was written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
 of the ext2 fs.
 .SH BUGS
-I had no chance to make reals tests of this program since I use IDE drives
+I had no chance to make real tests of this program since I use IDE drives,
 which remap bad blocks. I only made some tests on floppies.
 .SH AVAILABILITY
 .B badblocks
diff --git a/misc/chattr.1.in b/misc/chattr.1.in
index af9d6a0..aece86d 100644
--- a/misc/chattr.1.in
+++ b/misc/chattr.1.in
@@ -17,7 +17,7 @@
 .I files...
 .SH DESCRIPTION
 .B chattr
-changes the files attributes on an second extended file system.
+changes the file attributes on a Linux second extended file system.
 .PP
 The format of a symbolic mode is +-=[ASacdisu].
 .PP
@@ -41,7 +41,7 @@
 Set the files version.
 .SH ATTRIBUTES
 When a file with the 'A' attribute set is modified, its atime record is
-not modified.  This avoid a certain amount of disk I/O for laptop
+not modified.  This avoids a certain amount of disk I/O for laptop
 systems.
 
 A file with the `a' attribute set can only be open in append mode for writing.
@@ -65,12 +65,12 @@
 the changes are written synchronously on the disk; this is equivalent to
 the `sync' mount option applied to a subset of the files.
 
-When a file with the `u' attribute set is deleted, its contents is saved.
+When a file with the `u' attribute set is deleted, its contents are saved.
 This allows the user to ask for its undeletion.
 
 .SH AUTHOR
 .B chattr
-has been written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
+was written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
 of the ext2 fs.
 .SH BUGS AND LIMITATIONS
 As of ext2 fs 0.5a, the `c' and `u' attribute are not honoured by the kernel
diff --git a/misc/dumpe2fs.8.in b/misc/dumpe2fs.8.in
index 28fa320..b9da72a 100644
--- a/misc/dumpe2fs.8.in
+++ b/misc/dumpe2fs.8.in
@@ -30,13 +30,15 @@
 print the blocks which are reserved as bad in the filesystem.
 .TP
 .I -V
-print the version number of dumpe2fs and exit.
+print the version number of 
+.B dumpe2fs
+and exit.
 .SH BUGS
 You need to know the physical filesystem structure to understand the
 output.
 .SH AUTHOR
 .B dumpe2fs 
-has been written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
+was written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
 of the ext2 fs.
 .SH AVAILABILITY
 .B dumpe2fs
diff --git a/misc/fsck.8.in b/misc/fsck.8.in
index a28f6dd..58d23b9 100644
--- a/misc/fsck.8.in
+++ b/misc/fsck.8.in
@@ -26,11 +26,14 @@
 is used to check and optionally repair a Linux file system.  
 .I filesys
 is either the device name (e.g. /dev/hda1, /dev/sdb2) or the mount point
-(e.g. /, /usr, /home) for the file system.  If this fsck has several
-filesystems on different physical disk drives to check, this fsck will
-try to run them in parallel.  This reduces the total amount time it
-takes to check all of the filesystems, since fsck takes advantage of the
-parallelism of multiple disk spindles.
+(e.g. /, /usr, /home) for the file system.  If this invocation of 
+.B fsck 
+has several filesystems on different physical disk drives to check, then
+.B fsck 
+will try to run them in parallel.  This reduces the total amount time it
+takes to check all of the filesystems, since 
+.B fsck
+takes advantage of the parallelism of multiple disk spindles.
 .PP
 The exit code returned by
 .B fsck
@@ -90,17 +93,20 @@
 .B -A
 flag is set, check the root filesystem in parallel with the other filesystems.
 This is not the safest thing in the world to do,
-since if the root filesystem is in doubt things like
-the e2fsck executable might be corrupted!  This option is mainly provided
+since if the root filesystem is in doubt things like the 
+.BR e2fsck (8) 
+executable might be corrupted!  This option is mainly provided
 for those sysadmins who don't want to repartition the root
 filesystem to be small and compact (which is really the right solution).
 .TP
 .B -s
-Serialize fsck operations.  This is a good idea if you checking multiple
-filesystems in and the checkers are in an interactive mode.  (Note:
-.B e2fsck
+Serialize 
+.B fsck 
+operations.  This is a good idea if you checking multiple
+filesystems and the checkers are in an interactive mode.  (Note:
+.BR e2fsck (8)
 runs in an interactive mode by default.  To make 
-.B e2fsck
+.BR e2fsck (8)
 run in a non-interactive mode, you must either specify the
 .B -p
 or
@@ -123,7 +129,7 @@
 .I fstype
 is prefixed with 
 .B no
-only filesystems whose filesystem do not match
+then only filesystems whose type does not match
 .I fstype
 are checked.
 .sp
@@ -137,8 +143,7 @@
 will use the type specified by the 
 .B \-t
 option if it specifies a unique filesystem type.  If this type is not
-available, the the default file system type
-(currently ext2) is used. 
+available, then the default file system type (currently ext2) is used. 
 .TP
 .B fs-options
 Any options which are not understood by 
@@ -150,15 +155,16 @@
 .PP
 Currently, standardized file system-specific options are somewhat in
 flux.  Although not guaranteed, the following options are supported
-by most file system checkers.
+by most file system checkers:
 .TP
 .B -a
 Automatically repair the file system without any questions (use
 this option with caution).  Note that 
-.B e2fsck
+.BR e2fsck (8)
 supports 
 .B -a
-for backwards compatibility only.  This option is mapped to e2fsck's
+for backwards compatibility only.  This option is mapped to 
+.BR e2fsck 's
 .B -p
 option which is safe to use, unlike the 
 .B -a 
@@ -168,14 +174,16 @@
 Interactively repair the filesystem (ask for confirmations).  Note: It
 is generally a bad idea to use this option if multiple fsck's are being
 run in parallel.  Also note that this is 
-.B e2fsck
+.BR e2fsck 's
 default behavior; it supports this option for backwards compatibility
 reasons only.
 .SH AUTHOR
 Theodore Ts'o (tytso@mit.edu)
 .PP
 The manual page was shamelessly adapted from David Engel and Fred van
-Kempen's generic fsck front end program, which was in turn shamelessly
+Kempen's generic 
+.B fsck
+front end program, which was in turn shamelessly
 adapted from Remy Card's version for the ext2 file system.
 .SH FILES
 .IR /etc/fstab .
diff --git a/misc/mke2fs.8.in b/misc/mke2fs.8.in
index de08f44..9384c0a 100644
--- a/misc/mke2fs.8.in
+++ b/misc/mke2fs.8.in
@@ -104,7 +104,7 @@
 .TP
 .I -l filename
 Read the bad blocks list from
-.I filename
+.I filename.
 \.
 .TP
 .I -m reserved-blocks-percentage
@@ -118,10 +118,14 @@
 .I -o
 Manually override the default value of the "creator os" field of the 
 filesystem.  Normally the creator field is set by default to the native OS
-of the mke2fs executable.
+of the
+.B mke2fs
+executable.
 .TP
 .I -q
-Quiet execution.  Useful if mke2fs is run in a script.
+Quiet execution.  Useful if 
+.B mke2fs
+is run in a script.
 .TP
 .I -s sparse-super-flag
 If sparse-super-flag is 1, then turn on the sparse superblock flag.  
@@ -136,7 +140,9 @@
 Verbose execution.
 .TP
 .I -F
-Force mke2fs to run, even if the specified device is not a 
+Force 
+.B mke2fs
+to run, even if the specified device is not a 
 block special device.
 .TP
 .I -L
@@ -161,7 +167,9 @@
 .I -S
 Write superblock and group descriptors only.  This is useful if all of
 the superblock and backup superblocks are corrupted, and a last-ditch
-recovery method is desired.  It causes mke2fs to reinitialize the
+recovery method is desired.  It causes 
+.B mke2fs
+to reinitialize the 
 superblock and group descriptors, while not touching the inode table
 and the block and inode bitmaps.  The
 .B e2fsck
diff --git a/misc/tune2fs.8.in b/misc/tune2fs.8.in
index e65f3b5..96139e0 100644
--- a/misc/tune2fs.8.in
+++ b/misc/tune2fs.8.in
@@ -62,23 +62,23 @@
 .BI tune2fs
 adjusts tunable filesystem parameters on a Linux second extended filesystem.
 .PP
-.B Never use tune2fs on a read/write mounted filesystem to change parameters!
+.B Never use tune2fs to change parameters of a read/write mounted filesystem! 
 .PP
 .SH OPTIONS
 .TP
 .I -c max-mount-counts
 adjust the maximal mounts count between two filesystem checks.
 .TP
-.I -e errors-behavior
+.I -e error-behavior
 change the behavior of the kernel code when errors are detected.
-.I errors-behavior
-can be one of the followings:
+.I error-behavior
+can be one of the following:
 .br
 \	continue\	\	Continue normal execution.
 .br
 \	remount-ro\	Remount the filesystem read-only.
 .br
-\	panic\	\	Causes a kernel panic.
+\	panic\	\	Cause a kernel panic.
 .TP
 .I -g group
 set the user group which can benefit from the reserved blocks.
@@ -101,7 +101,7 @@
 adjust the reserved blocks count on the given device.
 .TP
 .I -s sparse_super_flag
-sets and resets the sparse_superblock flag.  The sparse_superblock feature
+set or reset the sparse_superblock flag.  The sparse_superblock feature
 saves space on really big filesystems.
 .B Warning:
 The Linux 2.0 kernel does not properly support this feature.  Neither do
@@ -120,7 +120,7 @@
 set the volume label of the filesystem.
 .TP
 .I -M last-mounted-directory
-set the last-mounted direcctory for the filesystem.
+set the last-mounted directory for the filesystem.
 .TP
 .I -U UUID
 set the UUID of the filesystem.  A sample UUID looks like this: 
@@ -129,13 +129,13 @@
 be "random", which will generate a new random UUID for the filesystem.
 .PP
 .SH BUGS
-We didn't find any bugs yet. Perhaps there are bugs but it's unlikely.
+We haven't found any bugs yet. Perhaps there are bugs but it's unlikely.
 .PP
 .SH WARNING
-.B Use this utility on your own risk. You're modifying filesystems.
+.B Use this utility at your own risk. You're modifying a filesystem!
 .SH AUTHOR
 .B tune2fs 
-has been written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
+was written by Remy Card <card@masi.ibp.fr>, the developer and maintainer
 of the ext2 fs.
 .br
 .B tune2fs
