[packages/kernel.git] / kernel-small_fixes.patch

--- linux-2.6.33/scripts/mod/modpost.c~	2010-02-24 19:52:17.000000000 +0100
+++ linux-2.6.33/scripts/mod/modpost.c	2010-03-07 14:26:47.242168558 +0100
@@ -15,7 +15,8 @@
 #include <stdio.h>
 #include <ctype.h>
 #include "modpost.h"
-#include "../../include/generated/autoconf.h"
+// PLD architectures don't use CONFIG_SYMBOL_PREFIX
+//#include "../../include/generated/autoconf.h"
 #include "../../include/linux/license.h"
 
 /* Some toolchains use a `_' prefix for all user symbols. */

--- linux-3.0/scripts/kconfig/lxdialog/check-lxdialog.sh~	2011-07-22 04:17:23.000000000 +0200
+++ linux-3.0/scripts/kconfig/lxdialog/check-lxdialog.sh	2011-08-25 21:26:04.799150642 +0200
@@ -9,6 +9,12 @@
 			$cc -print-file-name=lib${lib}.${ext} | grep -q /
 			if [ $? -eq 0 ]; then
 				echo "-l${lib}"
+				for libt in tinfow tinfo ; do
+					$cc -print-file-name=lib${libt}.${ext} | grep -q /
+					if [ $? -eq 0 ]; then
+						echo "-l${libt}"
+					fi
+				done
 				exit
 			fi
 		done

From: Dave Chinner <dchinner@redhat.com>

When we do dquot readahead in log recovery, we do not use a verifier
as the underlying buffer may not have dquots in it. e.g. the
allocation operation hasn't yet been replayed. Hence we do not want
to fail recovery because we detect an operation to be replayed has
not been run yet. This problem was addressed for inodes in commit
d891400 ("xfs: inode buffers may not be valid during recovery
readahead") but the problem was not recognised to exist for dquots
and their buffers as the dquot readahead did not have a verifier.

The result of not using a verifier is that when the buffer is then
next read to replay a dquot modification, the dquot buffer verifier
will only be attached to the buffer if *readahead is not complete*.
Hence we can read the buffer, replay the dquot changes and then add
it to the delwri submission list without it having a verifier
attached to it. This then generates warnings in xfs_buf_ioapply(),
which catches and warns about this case.

Fix this and make it handle the same readahead verifier error cases
as for inode buffers by adding a new readahead verifier that has a
write operation as well as a read operation that marks the buffer as
not done if any corruption is detected.  Also make sure we don't run
readahead if the dquot buffer has been marked as cancelled by
recovery.

This will result in readahead either succeeding and the buffer
having a valid write verifier, or readahead failing and the buffer
state requiring the subsequent read to resubmit the IO with the new
verifier.  In either case, this will result in the buffer always
ending up with a valid write verifier on it.

Note: we also need to fix the inode buffer readahead error handling
to mark the buffer with EIO. Brian noticed the code I copied from
there wrong during review, so fix it at the same time. Add comments
linking the two functions that handle readahead verifier errors
together so we don't forget this behavioural link in future.

cc: <stable@vger.kernel.org> # 3.12 - current
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
---
 fs/xfs/libxfs/xfs_dquot_buf.c  | 36 ++++++++++++++++++++++++++++++------
 fs/xfs/libxfs/xfs_inode_buf.c  |  2 ++
 fs/xfs/libxfs/xfs_quota_defs.h |  2 +-
 fs/xfs/libxfs/xfs_shared.h     |  1 +
 fs/xfs/xfs_log_recover.c       |  9 +++++++--
 5 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index 11cefb2..3cc3cf7 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -54,7 +54,7 @@ xfs_dqcheck(
 	xfs_dqid_t	 id,
 	uint		 type,	  /* used only when IO_dorepair is true */
 	uint		 flags,
-	char		 *str)
+	const char	 *str)
 {
 	xfs_dqblk_t	 *d = (xfs_dqblk_t *)ddq;
 	int		errs = 0;
@@ -207,7 +207,8 @@ xfs_dquot_buf_verify_crc(
 STATIC bool
 xfs_dquot_buf_verify(
 	struct xfs_mount	*mp,
-	struct xfs_buf		*bp)
+	struct xfs_buf		*bp,
+	int			warn)
 {
 	struct xfs_dqblk	*d = (struct xfs_dqblk *)bp->b_addr;
 	xfs_dqid_t		id = 0;
@@ -240,8 +241,7 @@ xfs_dquot_buf_verify(
 		if (i == 0)
 			id = be32_to_cpu(ddq->d_id);
 
-		error = xfs_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
-				       "xfs_dquot_buf_verify");
+		error = xfs_dqcheck(mp, ddq, id + i, 0, warn, __func__);
 		if (error)
 			return false;
 	}
@@ -256,7 +256,7 @@ xfs_dquot_buf_read_verify(
 
 	if (!xfs_dquot_buf_verify_crc(mp, bp))
 		xfs_buf_ioerror(bp, -EFSBADCRC);
-	else if (!xfs_dquot_buf_verify(mp, bp))
+	else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
 		xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
 	if (bp->b_error)
@@ -264,6 +264,25 @@ xfs_dquot_buf_read_verify(
 }
 
 /*
+ * readahead errors are silent and simply leave the buffer as !done so a real
+ * read will then be run with the xfs_dquot_buf_ops verifier. See
+ * xfs_inode_buf_verify() for why we use EIO and ~XBF_DONE here rather than
+ * reporting the failure.
+ */
+static void
+xfs_dquot_buf_readahead_verify(
+	struct xfs_buf	*bp)
+{
+	struct xfs_mount	*mp = bp->b_target->bt_mount;
+
+	if (!xfs_dquot_buf_verify_crc(mp, bp) ||
+	    !xfs_dquot_buf_verify(mp, bp, 0)) {
+		xfs_buf_ioerror(bp, -EIO);
+		bp->b_flags &= ~XBF_DONE;
+	}
+}
+
+/*
  * we don't calculate the CRC here as that is done when the dquot is flushed to
  * the buffer after the update is done. This ensures that the dquot in the
  * buffer always has an up-to-date CRC value.
@@ -274,7 +293,7 @@ xfs_dquot_buf_write_verify(
 {
 	struct xfs_mount	*mp = bp->b_target->bt_mount;
 
-	if (!xfs_dquot_buf_verify(mp, bp)) {
+	if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN)) {
 		xfs_buf_ioerror(bp, -EFSCORRUPTED);
 		xfs_verifier_error(bp);
 		return;
@@ -287,3 +306,8 @@ const struct xfs_buf_ops xfs_dquot_buf_ops = {
 	.verify_write = xfs_dquot_buf_write_verify,
 };
 
+const struct xfs_buf_ops xfs_dquot_buf_ra_ops = {
+
+	.verify_read = xfs_dquot_buf_readahead_verify,
+	.verify_write = xfs_dquot_buf_write_verify,
+};
diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index ff17c48..1aabfda 100644
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -68,6 +68,8 @@ xfs_inobp_check(
  * recovery and we don't get unnecssary panics on debug kernels. We use EIO here
  * because all we want to do is say readahead failed; there is no-one to report
  * the error to, so this will distinguish it from a non-ra verifier failure.
+ * Changes to this readahead error behavour also need to be reflected in
+ * xfs_dquot_buf_readahead_verify().
  */
 static void
 xfs_inode_buf_verify(
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 1b0a083..f51078f 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -153,7 +153,7 @@ typedef __uint16_t	xfs_qwarncnt_t;
 #define XFS_QMOPT_RESBLK_MASK	(XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
 
 extern int xfs_dqcheck(struct xfs_mount *mp, xfs_disk_dquot_t *ddq,
-		       xfs_dqid_t id, uint type, uint flags, char *str);
+		       xfs_dqid_t id, uint type, uint flags, const char *str);
 extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
 
 #endif	/* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
index 5be5297..15c3ceb 100644
--- a/fs/xfs/libxfs/xfs_shared.h
+++ b/fs/xfs/libxfs/xfs_shared.h
@@ -49,6 +49,7 @@ extern const struct xfs_buf_ops xfs_inobt_buf_ops;
 extern const struct xfs_buf_ops xfs_inode_buf_ops;
 extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;
 extern const struct xfs_buf_ops xfs_dquot_buf_ops;
+extern const struct xfs_buf_ops xfs_dquot_buf_ra_ops;
 extern const struct xfs_buf_ops xfs_sb_buf_ops;
 extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
 extern const struct xfs_buf_ops xfs_symlink_buf_ops;
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index c5ecaac..5991cdc 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -3204,6 +3204,7 @@ xlog_recover_dquot_ra_pass2(
 	struct xfs_disk_dquot	*recddq;
 	struct xfs_dq_logformat	*dq_f;
 	uint			type;
+	int			len;
 
 
 	if (mp->m_qflags == 0)
@@ -3224,8 +3225,12 @@ xlog_recover_dquot_ra_pass2(
 	ASSERT(dq_f);
 	ASSERT(dq_f->qlf_len == 1);
 
-	xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno,
-			  XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL);
+	len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
+	if (xlog_peek_buffer_cancelled(log, dq_f->qlf_blkno, len, 0))
+		return;
+
+	xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len,
+			  &xfs_dquot_buf_ra_ops);
 }
 
 STATIC void
-- 
2.5.0

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
Commit	Line	Data
08aa9d92	1	--- linux-2.6.33/scripts/mod/modpost.c~ 2010-02-24 19:52:17.000000000 +0100
	2	+++ linux-2.6.33/scripts/mod/modpost.c 2010-03-07 14:26:47.242168558 +0100
	3	@@ -15,7 +15,8 @@
	4	#include <stdio.h>
	5	#include <ctype.h>
	6	#include "modpost.h"
	7	-#include "../../include/generated/autoconf.h"
	8	+// PLD architectures don't use CONFIG_SYMBOL_PREFIX
	9	+//#include "../../include/generated/autoconf.h"
	10	#include "../../include/linux/license.h"
	11
	12	/* Some toolchains use a `_' prefix for all user symbols. */
	13
2136e199 AM	14	--- linux-3.0/scripts/kconfig/lxdialog/check-lxdialog.sh~ 2011-07-22 04:17:23.000000000 +0200
	15	+++ linux-3.0/scripts/kconfig/lxdialog/check-lxdialog.sh 2011-08-25 21:26:04.799150642 +0200
	16	@@ -9,6 +9,12 @@
	17	$cc -print-file-name=lib${lib}.${ext} \| grep -q /
	18	if [ $? -eq 0 ]; then
	19	echo "-l${lib}"
	20	+ for libt in tinfow tinfo ; do
	21	+ $cc -print-file-name=lib${libt}.${ext} \| grep -q /
	22	+ if [ $? -eq 0 ]; then
	23	+ echo "-l${libt}"
	24	+ fi
	25	+ done
	26	exit
	27	fi
	28	done
7e7bde06	29
28b20467 AM	30	From: Dave Chinner <dchinner@redhat.com>
28b20467 AM	31
ea1e61a2 AM	32	When we do dquot readahead in log recovery, we do not use a verifier
	33	as the underlying buffer may not have dquots in it. e.g. the
	34	allocation operation hasn't yet been replayed. Hence we do not want
	35	to fail recovery because we detect an operation to be replayed has
	36	not been run yet. This problem was addressed for inodes in commit
	37	d891400 ("xfs: inode buffers may not be valid during recovery
	38	readahead") but the problem was not recognised to exist for dquots
	39	and their buffers as the dquot readahead did not have a verifier.
	40
	41	The result of not using a verifier is that when the buffer is then
	42	next read to replay a dquot modification, the dquot buffer verifier
	43	will only be attached to the buffer if readahead is not complete.
	44	Hence we can read the buffer, replay the dquot changes and then add
	45	it to the delwri submission list without it having a verifier
	46	attached to it. This then generates warnings in xfs_buf_ioapply(),
	47	which catches and warns about this case.
	48
	49	Fix this and make it handle the same readahead verifier error cases
	50	as for inode buffers by adding a new readahead verifier that has a
	51	write operation as well as a read operation that marks the buffer as
	52	not done if any corruption is detected. Also make sure we don't run
	53	readahead if the dquot buffer has been marked as cancelled by
	54	recovery.
	55
	56	This will result in readahead either succeeding and the buffer
	57	having a valid write verifier, or readahead failing and the buffer
	58	state requiring the subsequent read to resubmit the IO with the new
	59	verifier. In either case, this will result in the buffer always
	60	ending up with a valid write verifier on it.
	61
	62	Note: we also need to fix the inode buffer readahead error handling
	63	to mark the buffer with EIO. Brian noticed the code I copied from
	64	there wrong during review, so fix it at the same time. Add comments
	65	linking the two functions that handle readahead verifier errors
	66	together so we don't forget this behavioural link in future.
	67
	68	cc: <stable@vger.kernel.org> # 3.12 - current
	69	Signed-off-by: Dave Chinner <dchinner@redhat.com>
28b20467 AM	70	Reviewed-by: Brian Foster <bfoster@redhat.com>
28b20467 AM	71	Signed-off-by: Dave Chinner <david@fromorbit.com>
ea1e61a2	72	---
ea1e61a2	73	fs/xfs/libxfs/xfs_dquot_buf.c \| 36 ++++++++++++++++++++++++++++++------
28b20467	74	fs/xfs/libxfs/xfs_inode_buf.c \| 2 ++
ea1e61a2 AM	75	fs/xfs/libxfs/xfs_quota_defs.h \| 2 +-
	76	fs/xfs/libxfs/xfs_shared.h \| 1 +
	77	fs/xfs/xfs_log_recover.c \| 9 +++++++--
28b20467	78	5 files changed, 41 insertions(+), 9 deletions(-)
ea1e61a2 AM	79
	80	diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
	81	index 11cefb2..3cc3cf7 100644
	82	--- a/fs/xfs/libxfs/xfs_dquot_buf.c
	83	+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
	84	@@ -54,7 +54,7 @@ xfs_dqcheck(
	85	xfs_dqid_t id,
	86	uint type, /* used only when IO_dorepair is true */
	87	uint flags,
	88	- char *str)
	89	+ const char *str)
	90	{
	91	xfs_dqblk_t d = (xfs_dqblk_t )ddq;
	92	int errs = 0;
	93	@@ -207,7 +207,8 @@ xfs_dquot_buf_verify_crc(
	94	STATIC bool
	95	xfs_dquot_buf_verify(
	96	struct xfs_mount *mp,
	97	- struct xfs_buf *bp)
	98	+ struct xfs_buf *bp,
	99	+ int warn)
	100	{
	101	struct xfs_dqblk d = (struct xfs_dqblk )bp->b_addr;
	102	xfs_dqid_t id = 0;
	103	@@ -240,8 +241,7 @@ xfs_dquot_buf_verify(
	104	if (i == 0)
	105	id = be32_to_cpu(ddq->d_id);
	106
	107	- error = xfs_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
	108	- "xfs_dquot_buf_verify");
	109	+ error = xfs_dqcheck(mp, ddq, id + i, 0, warn, __func__);
	110	if (error)
	111	return false;
	112	}
	113	@@ -256,7 +256,7 @@ xfs_dquot_buf_read_verify(
	114
	115	if (!xfs_dquot_buf_verify_crc(mp, bp))
	116	xfs_buf_ioerror(bp, -EFSBADCRC);
	117	- else if (!xfs_dquot_buf_verify(mp, bp))
	118	+ else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
	119	xfs_buf_ioerror(bp, -EFSCORRUPTED);
	120
	121	if (bp->b_error)
	122	@@ -264,6 +264,25 @@ xfs_dquot_buf_read_verify(
	123	}
	124
	125	/*
	126	+ * readahead errors are silent and simply leave the buffer as !done so a real
	127	+ * read will then be run with the xfs_dquot_buf_ops verifier. See
	128	+ * xfs_inode_buf_verify() for why we use EIO and ~XBF_DONE here rather than
	129	+ * reporting the failure.
	130	+ */
	131	+static void
	132	+xfs_dquot_buf_readahead_verify(
	133	+ struct xfs_buf *bp)
	134	+{
	135	+ struct xfs_mount *mp = bp->b_target->bt_mount;
	136	+
	137	+ if (!xfs_dquot_buf_verify_crc(mp, bp) \|\|
	138	+ !xfs_dquot_buf_verify(mp, bp, 0)) {
	139	+ xfs_buf_ioerror(bp, -EIO);
	140	+ bp->b_flags &= ~XBF_DONE;
	141	+ }
	142	+}
143	+
144	+/*
145	* we don't calculate the CRC here as that is done when the dquot is flushed to
146	* the buffer after the update is done. This ensures that the dquot in the
147	* buffer always has an up-to-date CRC value.
148	@@ -274,7 +293,7 @@ xfs_dquot_buf_write_verify(
149	{
150	struct xfs_mount *mp = bp->b_target->bt_mount;
151
152	- if (!xfs_dquot_buf_verify(mp, bp)) {
153	+ if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN)) {
154	xfs_buf_ioerror(bp, -EFSCORRUPTED);
155	xfs_verifier_error(bp);
156	return;
157	@@ -287,3 +306,8 @@ const struct xfs_buf_ops xfs_dquot_buf_ops = {
158	.verify_write = xfs_dquot_buf_write_verify,
159	};
160
161	+const struct xfs_buf_ops xfs_dquot_buf_ra_ops = {
162	+
163	+ .verify_read = xfs_dquot_buf_readahead_verify,
164	+ .verify_write = xfs_dquot_buf_write_verify,
165	+};
166	diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
28b20467	167	index ff17c48..1aabfda 100644
ea1e61a2 AM	168	--- a/fs/xfs/libxfs/xfs_inode_buf.c
ea1e61a2 AM	169	+++ b/fs/xfs/libxfs/xfs_inode_buf.c
28b20467 AM	170	@@ -68,6 +68,8 @@ xfs_inobp_check(
	171	* recovery and we don't get unnecssary panics on debug kernels. We use EIO here
	172	* because all we want to do is say readahead failed; there is no-one to report
	173	* the error to, so this will distinguish it from a non-ra verifier failure.
ea1e61a2 AM	174	+ * Changes to this readahead error behavour also need to be reflected in
	175	+ * xfs_dquot_buf_readahead_verify().
	176	*/
	177	static void
	178	xfs_inode_buf_verify(
ea1e61a2 AM	179	diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
	180	index 1b0a083..f51078f 100644
	181	--- a/fs/xfs/libxfs/xfs_quota_defs.h
	182	+++ b/fs/xfs/libxfs/xfs_quota_defs.h
	183	@@ -153,7 +153,7 @@ typedef __uint16_t xfs_qwarncnt_t;
	184	#define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS \| XFS_QMOPT_RES_RTBLKS)
	185
	186	extern int xfs_dqcheck(struct xfs_mount mp, xfs_disk_dquot_t ddq,
	187	- xfs_dqid_t id, uint type, uint flags, char *str);
	188	+ xfs_dqid_t id, uint type, uint flags, const char *str);
	189	extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
	190
	191	#endif /* __XFS_QUOTA_H__ */
	192	diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
	193	index 5be5297..15c3ceb 100644
	194	--- a/fs/xfs/libxfs/xfs_shared.h
	195	+++ b/fs/xfs/libxfs/xfs_shared.h
	196	@@ -49,6 +49,7 @@ extern const struct xfs_buf_ops xfs_inobt_buf_ops;
	197	extern const struct xfs_buf_ops xfs_inode_buf_ops;
	198	extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;
	199	extern const struct xfs_buf_ops xfs_dquot_buf_ops;
	200	+extern const struct xfs_buf_ops xfs_dquot_buf_ra_ops;
	201	extern const struct xfs_buf_ops xfs_sb_buf_ops;
	202	extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
	203	extern const struct xfs_buf_ops xfs_symlink_buf_ops;
	204	diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
28b20467	205	index c5ecaac..5991cdc 100644
ea1e61a2 AM	206	--- a/fs/xfs/xfs_log_recover.c
ea1e61a2 AM	207	+++ b/fs/xfs/xfs_log_recover.c
28b20467	208	@@ -3204,6 +3204,7 @@ xlog_recover_dquot_ra_pass2(
ea1e61a2 AM	209	struct xfs_disk_dquot *recddq;
	210	struct xfs_dq_logformat *dq_f;
	211	uint type;
	212	+ int len;
	213
	214
	215	if (mp->m_qflags == 0)
28b20467	216	@@ -3224,8 +3225,12 @@ xlog_recover_dquot_ra_pass2(
ea1e61a2 AM	217	ASSERT(dq_f);
	218	ASSERT(dq_f->qlf_len == 1);
	219
	220	- xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno,
	221	- XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL);
	222	+ len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
	223	+ if (xlog_peek_buffer_cancelled(log, dq_f->qlf_blkno, len, 0))
	224	+ return;
	225	+
	226	+ xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len,
	227	+ &xfs_dquot_buf_ra_ops);
	228	}
	229
	230	STATIC void
28b20467 AM	231	--
28b20467 AM	232	2.5.0
ea1e61a2 AM	233
	234	_______________________________________________
	235	xfs mailing list
	236	xfs@oss.sgi.com
	237	http://oss.sgi.com/mailman/listinfo/xfs