Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs

* 'for-linus' of git://oss.sgi.com/xfs/xfs: (23 commits)
  xfs: don't name variables "panic"
  xfs: factor agf counter updates into a helper
  xfs: clean up the xfs_alloc_compute_aligned calling convention
  xfs: kill support/debug.[ch]
  xfs: Convert remaining cmn_err() callers to new API
  xfs: convert the quota debug prints to new API
  xfs: rename xfs_cmn_err_fsblock_zero()
  xfs: convert xfs_fs_cmn_err to new error logging API
  xfs: kill xfs_fs_mount_cmn_err() macro
  xfs: kill xfs_fs_repair_cmn_err() macro
  xfs: convert xfs_cmn_err to xfs_alert_tag
  xfs: Convert xlog_warn to new logging interface
  xfs: Convert linux-2.6/ files to new logging interface
  xfs: introduce new logging API.
  xfs: zero proper structure size for geometry calls
  xfs: enable delaylog by default
  xfs: more sensible inode refcounting for ialloc
  xfs: stop using xfs_trans_iget in the RT allocator
  xfs: check if device support discard in xfs_ioc_trim()
  xfs: prevent leaking uninitialized stack memory in FSGEOMETRY_V1
  ...

1 files changed, 58 insertions, 70 deletions

diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 9731898083ae..818c4cf2de86 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -173,6 +173,15 @@ xfs_parseargs(
         __uint8_t               iosizelog = 0;
 
         /*
+         * set up the mount name first so all the errors will refer to the
+         * correct device.
+         */
+        mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
+        if (!mp->m_fsname)
+                return ENOMEM;
+        mp->m_fsname_len = strlen(mp->m_fsname) + 1;
+
+        /*
          * Copy binary VFS mount flags we are interested in.
          */
         if (sb->s_flags & MS_RDONLY)
@@ -189,6 +198,7 @@ xfs_parseargs(
         mp->m_flags |= XFS_MOUNT_BARRIER;
         mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
         mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
+        mp->m_flags |= XFS_MOUNT_DELAYLOG;
 
         /*
          * These can be overridden by the mount option parsing.
@@ -207,24 +217,21 @@ xfs_parseargs(
 
                 if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
                         mp->m_logbufs = simple_strtoul(value, &eov, 10);
                 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
                         mp->m_logbsize = suffix_strtoul(value, &eov, 10);
                 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -232,14 +239,12 @@ xfs_parseargs(
                         if (!mp->m_logname)
                                 return ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
-                        cmn_err(CE_WARN,
-                                "XFS: %s option not allowed on this system",
+                        xfs_warn(mp, "%s option not allowed on this system",
                                 this_char);
                         return EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -248,8 +253,7 @@ xfs_parseargs(
                                 return ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -257,8 +261,7 @@ xfs_parseargs(
                         iosizelog = ffs(iosize) - 1;
                 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -280,16 +283,14 @@ xfs_parseargs(
                         mp->m_flags |= XFS_MOUNT_SWALLOC;
                 } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
                         dsunit = simple_strtoul(value, &eov, 10);
                 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -297,8 +298,7 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
                         mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
 #if !XFS_BIG_INUMS
-                        cmn_err(CE_WARN,
-                                "XFS: %s option not allowed on this system",
+                        xfs_warn(mp, "%s option not allowed on this system",
                                 this_char);
                         return EINVAL;
 #endif
@@ -356,20 +356,19 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
                         mp->m_flags &= ~XFS_MOUNT_DELAYLOG;
                 } else if (!strcmp(this_char, "ihashsize")) {
-                        cmn_err(CE_WARN,
-        "XFS: ihashsize no longer used, option is deprecated.");
+                        xfs_warn(mp,
+        "ihashsize no longer used, option is deprecated.");
                 } else if (!strcmp(this_char, "osyncisdsync")) {
-                        cmn_err(CE_WARN,
-        "XFS: osyncisdsync has no effect, option is deprecated.");
+                        xfs_warn(mp,
+        "osyncisdsync has no effect, option is deprecated.");
                 } else if (!strcmp(this_char, "osyncisosync")) {
-                        cmn_err(CE_WARN,
-        "XFS: osyncisosync has no effect, option is deprecated.");
+                        xfs_warn(mp,
+        "osyncisosync has no effect, option is deprecated.");
                 } else if (!strcmp(this_char, "irixsgid")) {
-                        cmn_err(CE_WARN,
-        "XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
+                        xfs_warn(mp,
+        "irixsgid is now a sysctl(2) variable, option is deprecated.");
                 } else {
-                        cmn_err(CE_WARN,
-                                "XFS: unknown mount option [%s].", this_char);
+                        xfs_warn(mp, "unknown mount option [%s].", this_char);
                         return EINVAL;
                 }
         }
@@ -379,40 +378,37 @@ xfs_parseargs(
          */
         if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
             !(mp->m_flags & XFS_MOUNT_RDONLY)) {
-                cmn_err(CE_WARN, "XFS: no-recovery mounts must be read-only.");
+                xfs_warn(mp, "no-recovery mounts must be read-only.");
                 return EINVAL;
         }
 
         if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
-                cmn_err(CE_WARN,
-        "XFS: sunit and swidth options incompatible with the noalign option");
+                xfs_warn(mp,
+        "sunit and swidth options incompatible with the noalign option");
                 return EINVAL;
         }
 
 #ifndef CONFIG_XFS_QUOTA
         if (XFS_IS_QUOTA_RUNNING(mp)) {
-                cmn_err(CE_WARN,
-                        "XFS: quota support not available in this kernel.");
+                xfs_warn(mp, "quota support not available in this kernel.");
                 return EINVAL;
         }
 #endif
 
         if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
             (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
-                cmn_err(CE_WARN,
-                        "XFS: cannot mount with both project and group quota");
+                xfs_warn(mp, "cannot mount with both project and group quota");
                 return EINVAL;
         }
 
         if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
-                cmn_err(CE_WARN,
-                        "XFS: sunit and swidth must be specified together");
+                xfs_warn(mp, "sunit and swidth must be specified together");
                 return EINVAL;
         }
 
         if (dsunit && (dswidth % dsunit != 0)) {
-                cmn_err(CE_WARN,
-        "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
+                xfs_warn(mp,
+        "stripe width (%d) must be a multiple of the stripe unit (%d)",
                         dswidth, dsunit);
                 return EINVAL;
         }
@@ -438,8 +434,7 @@ done:
             mp->m_logbufs != 0 &&
             (mp->m_logbufs < XLOG_MIN_ICLOGS ||
              mp->m_logbufs > XLOG_MAX_ICLOGS)) {
-                cmn_err(CE_WARN,
-                        "XFS: invalid logbufs value: %d [not %d-%d]",
+                xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
                         mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
                 return XFS_ERROR(EINVAL);
         }
@@ -448,22 +443,16 @@ done:
             (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
              mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
              !is_power_of_2(mp->m_logbsize))) {
-                cmn_err(CE_WARN,
-        "XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
+                xfs_warn(mp,
+                        "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
                         mp->m_logbsize);
                 return XFS_ERROR(EINVAL);
         }
 
-        mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
-        if (!mp->m_fsname)
-                return ENOMEM;
-        mp->m_fsname_len = strlen(mp->m_fsname) + 1;
-
         if (iosizelog) {
                 if (iosizelog > XFS_MAX_IO_LOG ||
                     iosizelog < XFS_MIN_IO_LOG) {
-                        cmn_err(CE_WARN,
-                "XFS: invalid log iosize: %d [not %d-%d]",
+                        xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
                                 iosizelog, XFS_MIN_IO_LOG,
                                 XFS_MAX_IO_LOG);
                         return XFS_ERROR(EINVAL);
@@ -610,7 +599,7 @@ xfs_blkdev_get(
                                     mp);
         if (IS_ERR(*bdevp)) {
                 error = PTR_ERR(*bdevp);
-                printk("XFS: Invalid device [%s], error=%d\n", name, error);
+                xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
         }
 
         return -error;
@@ -664,23 +653,23 @@ xfs_mountfs_check_barriers(xfs_mount_t *mp)
         int error;
 
         if (mp->m_logdev_targp != mp->m_ddev_targp) {
-                xfs_fs_cmn_err(CE_NOTE, mp,
+                xfs_notice(mp,
                   "Disabling barriers, not supported with external log device");
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 return;
         }
 
         if (xfs_readonly_buftarg(mp->m_ddev_targp)) {
-                xfs_fs_cmn_err(CE_NOTE, mp,
-                  "Disabling barriers, underlying device is readonly");
+                xfs_notice(mp,
+                        "Disabling barriers, underlying device is readonly");
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 return;
         }
 
         error = xfs_barrier_test(mp);
         if (error) {
-                xfs_fs_cmn_err(CE_NOTE, mp,
-                  "Disabling barriers, trial barrier write failed");
+                xfs_notice(mp,
+                        "Disabling barriers, trial barrier write failed");
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 return;
         }
@@ -743,8 +732,8 @@ xfs_open_devices(
                         goto out_close_logdev;
 
                 if (rtdev == ddev || rtdev == logdev) {
-                        cmn_err(CE_WARN,
-        "XFS: Cannot mount filesystem with identical rtdev and ddev/logdev.");
+                        xfs_warn(mp,
+        "Cannot mount filesystem with identical rtdev and ddev/logdev.");
                         error = EINVAL;
                         goto out_close_rtdev;
                 }
@@ -1345,8 +1334,8 @@ xfs_fs_remount(
                          * options that we can't actually change.
                          */
 #if 0
-                        printk(KERN_INFO
-        "XFS: mount option \"%s\" not supported for remount\n", p);
+                        xfs_info(mp,
+                "mount option \"%s\" not supported for remount\n", p);
                         return -EINVAL;
 #else
                         break;
@@ -1367,8 +1356,7 @@ xfs_fs_remount(
                 if (mp->m_update_flags) {
                         error = xfs_mount_log_sb(mp, mp->m_update_flags);
                         if (error) {
-                                cmn_err(CE_WARN,
-                                        "XFS: failed to write sb changes");
+                                xfs_warn(mp, "failed to write sb changes");
                                 return error;
                         }
                         mp->m_update_flags = 0;
@@ -1452,15 +1440,15 @@ xfs_finish_flags(
                         mp->m_logbsize = mp->m_sb.sb_logsunit;
                 } else if (mp->m_logbsize > 0 &&
                            mp->m_logbsize < mp->m_sb.sb_logsunit) {
-                        cmn_err(CE_WARN,
-        "XFS: logbuf size must be greater than or equal to log stripe size");
+                        xfs_warn(mp,
+                "logbuf size must be greater than or equal to log stripe size");
                         return XFS_ERROR(EINVAL);
                 }
         } else {
                 /* Fail a mount if the logbuf is larger than 32K */
                 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
-                        cmn_err(CE_WARN,
-        "XFS: logbuf size for version 1 logs must be 16K or 32K");
+                        xfs_warn(mp,
+                "logbuf size for version 1 logs must be 16K or 32K");
                         return XFS_ERROR(EINVAL);
                 }
         }
@@ -1477,8 +1465,8 @@ xfs_finish_flags(
          * prohibit r/w mounts of read-only filesystems
          */
         if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
-                cmn_err(CE_WARN,
-        "XFS: cannot mount a read-only filesystem as read-write");
+                xfs_warn(mp,
+                        "cannot mount a read-only filesystem as read-write");
                 return XFS_ERROR(EROFS);
         }