[XFS] Implement the silent parameter to fill_super, previously ignored.

SGI-PV: 951299
SGI-Modid: xfs-linux-melb:xfs-kern:25632a

Signed-off-by: Nathan Scott <nathans@sgi.com>

diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 1884300417e37a3c28a920fda036e6851810e4e9..68f4793e8a11f27588a3d211ec00a07303f3bca3 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -67,7 +67,8 @@ mempool_t *xfs_ioend_pool;
 
 STATIC struct xfs_mount_args *
 xfs_args_allocate(
-       struct super_block      *sb)
+       struct super_block      *sb,
+       int                     silent)
 {
        struct xfs_mount_args   *args;
 
@@ -80,8 +81,8 @@ xfs_args_allocate(
                args->flags |= XFSMNT_DIRSYNC;
        if (sb->s_flags & MS_SYNCHRONOUS)
                args->flags |= XFSMNT_WSYNC;
-
-       /* Default to 32 bit inodes on Linux all the time */
+       if (silent)
+               args->flags |= XFSMNT_QUIET;
        args->flags |= XFSMNT_32BITINODES;
 
        return args;
@@ -719,7 +720,7 @@ xfs_fs_remount(
        char                    *options)
 {
        vfs_t                   *vfsp = vfs_from_sb(sb);
-       struct xfs_mount_args   *args = xfs_args_allocate(sb);
+       struct xfs_mount_args   *args = xfs_args_allocate(sb, 0);
        int                     error;
 
        VFS_PARSEARGS(vfsp, options, args, 1, error);
@@ -825,7 +826,7 @@ xfs_fs_fill_super(
 {
        vnode_t                 *rootvp;
        struct vfs              *vfsp = vfs_allocate(sb);
-       struct xfs_mount_args   *args = xfs_args_allocate(sb);
+       struct xfs_mount_args   *args = xfs_args_allocate(sb, silent);
        struct kstatfs          statvfs;
        int                     error, error2;
 

diff --git a/fs/xfs/xfs_clnt.h b/fs/xfs/xfs_clnt.h
index 022fff62085b144ebe30f87a01ca46b96b00afec..5b7eb81453be02160cf7911e8905d0d7a2871c22 100644 (file)
--- a/fs/xfs/xfs_clnt.h
+++ b/fs/xfs/xfs_clnt.h
@@ -68,6 +68,7 @@ struct xfs_mount_args {
                                                 * enforcement */
 #define XFSMNT_PQUOTAENF       0x00000040      /* IRIX project quota limit
                                                 * enforcement */
+#define XFSMNT_QUIET           0x00000080      /* don't report mount errors */
 #define XFSMNT_NOALIGN         0x00000200      /* don't allocate at
                                                 * stripe boundaries*/
 #define XFSMNT_RETERR          0x00000400      /* return error to user */

diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h
index 26b8e709a569059f694b0bd9ac6c14dda141af56..bc43163456ef854ae2820a25af87e3a146d73cc9 100644 (file)
--- a/fs/xfs/xfs_error.h
+++ b/fs/xfs/xfs_error.h
@@ -186,4 +186,7 @@ extern void xfs_fs_cmn_err(int level, struct xfs_mount *mp, char *fmt, ...);
 #define xfs_fs_repair_cmn_err(level, mp, fmt, args...) \
        xfs_fs_cmn_err(level, mp, fmt "  Unmount and run xfs_repair.", ## args)
 
+#define xfs_fs_mount_cmn_err(f, fmt, args...) \
+       ((f & XFS_MFSI_QUIET)? cmn_err(CE_WARN, "XFS: " fmt, ## args) : (void)0)
+
 #endif /* __XFS_ERROR_H__ */

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 72e7e78bfff8afe9a1e41426e404c77e320bc365..049fabb7f7e0b87652586e30d6224a0f847de2ce 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -213,7 +213,8 @@ xfs_mount_free(
 STATIC int
 xfs_mount_validate_sb(
        xfs_mount_t     *mp,
-       xfs_sb_t        *sbp)
+       xfs_sb_t        *sbp,
+       int             flags)
 {
        /*
         * If the log device and data device have the
@@ -223,33 +224,29 @@ xfs_mount_validate_sb(
         * a volume filesystem in a non-volume manner.
         */
        if (sbp->sb_magicnum != XFS_SB_MAGIC) {
-               cmn_err(CE_WARN, "XFS: bad magic number");
+               xfs_fs_mount_cmn_err(flags, "bad magic number");
                return XFS_ERROR(EWRONGFS);
        }
 
        if (!XFS_SB_GOOD_VERSION(sbp)) {
-               cmn_err(CE_WARN, "XFS: bad version");
+               xfs_fs_mount_cmn_err(flags, "bad version");
                return XFS_ERROR(EWRONGFS);
        }
 
        if (unlikely(
            sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) {
-               cmn_err(CE_WARN,
-       "XFS: filesystem is marked as having an external log; "
-       "specify logdev on the\nmount command line.");
-               XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(1)",
-                                    XFS_ERRLEVEL_HIGH, mp, sbp);
-               return XFS_ERROR(EFSCORRUPTED);
+               xfs_fs_mount_cmn_err(flags,
+                       "filesystem is marked as having an external log; "
+                       "specify logdev on the\nmount command line.");
+               return XFS_ERROR(EINVAL);
        }
 
        if (unlikely(
            sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) {
-               cmn_err(CE_WARN,
-       "XFS: filesystem is marked as having an internal log; "
-       "don't specify logdev on\nthe mount command line.");
-               XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(2)",
-                                    XFS_ERRLEVEL_HIGH, mp, sbp);
-               return XFS_ERROR(EFSCORRUPTED);
+               xfs_fs_mount_cmn_err(flags,
+                       "filesystem is marked as having an internal log; "
+                       "do not specify logdev on\nthe mount command line.");
+               return XFS_ERROR(EINVAL);
        }
 
        /*
@@ -274,9 +271,7 @@ xfs_mount_validate_sb(
            (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE)  ||
            (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE)  ||
            (sbp->sb_imax_pct > 100 || sbp->sb_imax_pct < 1))) {
-               cmn_err(CE_WARN, "XFS: SB sanity check 1 failed");
-               XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(3)",
-                                    XFS_ERRLEVEL_LOW, mp, sbp);
+               xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed");
                return XFS_ERROR(EFSCORRUPTED);
        }
 
@@ -289,9 +284,7 @@ xfs_mount_validate_sb(
             (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks ||
            sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) *
                              sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) {
-               cmn_err(CE_WARN, "XFS: SB sanity check 2 failed");
-               XFS_ERROR_REPORT("xfs_mount_validate_sb(4)",
-                                XFS_ERRLEVEL_LOW, mp);
+               xfs_fs_mount_cmn_err(flags, "SB sanity check 2 failed");
                return XFS_ERROR(EFSCORRUPTED);
        }
 
@@ -307,15 +300,13 @@ xfs_mount_validate_sb(
            (sbp->sb_dblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX ||
            (sbp->sb_rblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX)) {
 #endif
-               cmn_err(CE_WARN,
-       "XFS: File system is too large to be mounted on this system.");
+               xfs_fs_mount_cmn_err(flags,
+                       "file system too large to be mounted on this system.");
                return XFS_ERROR(E2BIG);
        }
 
        if (unlikely(sbp->sb_inprogress)) {
-               cmn_err(CE_WARN, "XFS: file system busy");
-               XFS_ERROR_REPORT("xfs_mount_validate_sb(5)",
-                                XFS_ERRLEVEL_LOW, mp);
+               xfs_fs_mount_cmn_err(flags, "file system busy");
                return XFS_ERROR(EFSCORRUPTED);
        }
 
@@ -323,8 +314,8 @@ xfs_mount_validate_sb(
         * Version 1 directory format has never worked on Linux.
         */
        if (unlikely(!XFS_SB_VERSION_HASDIRV2(sbp))) {
-               cmn_err(CE_WARN,
-       "XFS: Attempted to mount file system using version 1 directory format");
+               xfs_fs_mount_cmn_err(flags,
+                       "file system using version 1 directory format");
                return XFS_ERROR(ENOSYS);
        }
 
@@ -332,11 +323,11 @@ xfs_mount_validate_sb(
         * Until this is fixed only page-sized or smaller data blocks work.
         */
        if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
-               cmn_err(CE_WARN,
-               "XFS: Attempted to mount file system with blocksize %d bytes",
+               xfs_fs_mount_cmn_err(flags,
+                       "file system with blocksize %d bytes",
                        sbp->sb_blocksize);
-               cmn_err(CE_WARN,
-               "XFS: Only page-sized (%ld) or less blocksizes currently work.",
+               xfs_fs_mount_cmn_err(flags,
+                       "only pagesize (%ld) or less will currently work.",
                        PAGE_SIZE);
                return XFS_ERROR(ENOSYS);
        }
@@ -484,7 +475,7 @@ xfs_xlatesb(
  * Does the initial read of the superblock.
  */
 int
-xfs_readsb(xfs_mount_t *mp)
+xfs_readsb(xfs_mount_t *mp, int flags)
 {
        unsigned int    sector_size;
        unsigned int    extra_flags;
@@ -506,7 +497,7 @@ xfs_readsb(xfs_mount_t *mp)
        bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
                                BTOBB(sector_size), extra_flags);
        if (!bp || XFS_BUF_ISERROR(bp)) {
-               cmn_err(CE_WARN, "XFS: SB read failed");
+               xfs_fs_mount_cmn_err(flags, "SB read failed");
                error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
                goto fail;
        }
@@ -520,9 +511,9 @@ xfs_readsb(xfs_mount_t *mp)
        sbp = XFS_BUF_TO_SBP(bp);
        xfs_xlatesb(XFS_BUF_PTR(bp), &(mp->m_sb), 1, XFS_SB_ALL_BITS);
 
-       error = xfs_mount_validate_sb(mp, &(mp->m_sb));
+       error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags);
        if (error) {
-               cmn_err(CE_WARN, "XFS: SB validate failed");
+               xfs_fs_mount_cmn_err(flags, "SB validate failed");
                goto fail;
        }
 
@@ -530,8 +521,8 @@ xfs_readsb(xfs_mount_t *mp)
         * We must be able to do sector-sized and sector-aligned IO.
         */
        if (sector_size > mp->m_sb.sb_sectsize) {
-               cmn_err(CE_WARN,
-                       "XFS: device supports only %u byte sectors (not %u)",
+               xfs_fs_mount_cmn_err(flags,
+                       "device supports only %u byte sectors (not %u)",
                        sector_size, mp->m_sb.sb_sectsize);
                error = ENOSYS;
                goto fail;
@@ -548,7 +539,7 @@ xfs_readsb(xfs_mount_t *mp)
                bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
                                        BTOBB(sector_size), extra_flags);
                if (!bp || XFS_BUF_ISERROR(bp)) {
-                       cmn_err(CE_WARN, "XFS: SB re-read failed");
+                       xfs_fs_mount_cmn_err(flags, "SB re-read failed");
                        error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
                        goto fail;
                }
@@ -678,7 +669,7 @@ xfs_mountfs(
        int             error = 0;
 
        if (mp->m_sb_bp == NULL) {
-               if ((error = xfs_readsb(mp))) {
+               if ((error = xfs_readsb(mp, mfsi_flags))) {
                        return error;
                }
        }

diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 66cbee79864e224e30ee9d04044748e6caaa25c9..668ad23fd37c9c5683dea0cfbfef387a0364e32c 100644 (file)
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -510,9 +510,12 @@ xfs_preferred_iosize(xfs_mount_t *mp)
  */
 #define XFS_MFSI_SECOND                0x01    /* Secondary mount -- skip stuff */
 #define XFS_MFSI_CLIENT                0x02    /* Is a client -- skip lots of stuff */
+/*     XFS_MFSI_RRINODES       */
 #define XFS_MFSI_NOUNLINK      0x08    /* Skip unlinked inode processing in */
                                        /* log recovery */
 #define XFS_MFSI_NO_QUOTACHECK 0x10    /* Skip quotacheck processing */
+/*     XFS_MFSI_CONVERT_SUNIT  */
+#define XFS_MFSI_QUIET         0x40    /* Be silent if mount errors found */
 
 /*
  * Macros for getting from mount to vfs and back.
@@ -581,7 +584,7 @@ extern int  xfs_mod_incore_sb_unlocked(xfs_mount_t *, xfs_sb_field_t,
 extern int     xfs_mod_incore_sb_batch(xfs_mount_t *, xfs_mod_sb_t *,
                        uint, int);
 extern struct xfs_buf *xfs_getsb(xfs_mount_t *, int);
-extern int     xfs_readsb(xfs_mount_t *mp);
+extern int     xfs_readsb(xfs_mount_t *, int);
 extern void    xfs_freesb(xfs_mount_t *);
 extern void    xfs_do_force_shutdown(bhv_desc_t *, int, char *, int);
 extern int     xfs_syncsub(xfs_mount_t *, int, int, int *);

diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 504d2a80747a70be21686fee02cf6fb87f32cd46..89020c15d88a41999c844d36ff1ad39b68501e01 100644 (file)
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -442,6 +442,9 @@ xfs_mount(
        p = vfs_bhv_lookup(vfsp, VFS_POSITION_IO);
        mp->m_io_ops = p ? *(xfs_ioops_t *) vfs_bhv_custom(p) : xfs_iocore_xfs;
 
+       if (args->flags & XFSMNT_QUIET)
+               flags |= XFS_MFSI_QUIET;
+
        /*
         * Open real time and log devices - order is important.
         */
@@ -492,7 +495,7 @@ xfs_mount(
        error = xfs_start_flags(vfsp, args, mp);
        if (error)
                goto error1;
-       error = xfs_readsb(mp);
+       error = xfs_readsb(mp, flags);
        if (error)
                goto error1;
        error = xfs_finish_flags(vfsp, args, mp);