hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

xfs: Convert linux-2.6/ files to new logging interface 

Convert the files in fs/xfs/linux-2.6/ to use the new xfs_<level>
logging format that replaces the old Irix inherited cmn_err()
interfaces. While there, also convert naked printk calls to use the
relevant xfs logging function to standardise output format.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Alex Elder <aelder@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
This commit is contained in:
Dave Chinner 2011-03-07 10:00:35 +11:00 committed by Dave Chinner
parent 10e38391c0
commit 4f10700a2e
6 changed files with 76 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
fs/xfs/linux-2.6/kmem.c
View File

@ -23,6 +23,7 @@
#include <linux/backing-dev.h> #include <linux/backing-dev.h>
#include "time.h" #include "time.h"
#include "kmem.h" #include "kmem.h"
#include "xfs_message.h"
/* /*
* Greedy allocation. May fail and may return vmalloced memory. * Greedy allocation. May fail and may return vmalloced memory.
@ -56,8 +57,8 @@ kmem_alloc(size_t size, unsigned int __nocast flags)
if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP))) if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
return ptr; return ptr;
if (!(++retries % 100)) if (!(++retries % 100))
printk(KERN_ERR "XFS: possible memory allocation " xfs_err(NULL,
"deadlock in %s (mode:0x%x)\n", "possible memory allocation deadlock in %s (mode:0x%x)",
__func__, lflags); __func__, lflags);
congestion_wait(BLK_RW_ASYNC, HZ/50); congestion_wait(BLK_RW_ASYNC, HZ/50);
} while (1); } while (1);
@ -112,8 +113,8 @@ kmem_zone_alloc(kmem_zone_t *zone, unsigned int __nocast flags)
if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP))) if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
return ptr; return ptr;
if (!(++retries % 100)) if (!(++retries % 100))
printk(KERN_ERR "XFS: possible memory allocation " xfs_err(NULL,
"deadlock in %s (mode:0x%x)\n", "possible memory allocation deadlock in %s (mode:0x%x)",
__func__, lflags); __func__, lflags);
congestion_wait(BLK_RW_ASYNC, HZ/50); congestion_wait(BLK_RW_ASYNC, HZ/50);
} while (1); } while (1);

6
fs/xfs/linux-2.6/xfs_aops.c
View File

@ -854,7 +854,7 @@ xfs_aops_discard_page(
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) if (XFS_FORCED_SHUTDOWN(ip->i_mount))
goto out_invalidate; goto out_invalidate;
xfs_fs_cmn_err(CE_ALERT, ip->i_mount, xfs_alert(ip->i_mount,
"page discard on page %p, inode 0x%llx, offset %llu.", "page discard on page %p, inode 0x%llx, offset %llu.",
page, ip->i_ino, offset); page, ip->i_ino, offset);
@ -872,7 +872,7 @@ xfs_aops_discard_page(
if (error) { if (error) {
/* something screwed, just bail */ /* something screwed, just bail */
if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) { if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
xfs_fs_cmn_err(CE_ALERT, ip->i_mount, xfs_alert(ip->i_mount,
"page discard unable to remove delalloc mapping."); "page discard unable to remove delalloc mapping.");
} }
break; break;
@ -1411,7 +1411,7 @@ xfs_vm_write_failed(
if (error) { if (error) {
/* something screwed, just bail */ /* something screwed, just bail */
if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) { if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
xfs_fs_cmn_err(CE_ALERT, ip->i_mount, xfs_alert(ip->i_mount,
"xfs_vm_write_failed: unable to clean up ino %lld", "xfs_vm_write_failed: unable to clean up ino %lld",
ip->i_ino); ip->i_ino);
} }

17
fs/xfs/linux-2.6/xfs_buf.c
View File

@ -401,9 +401,8 @@ _xfs_buf_lookup_pages(
* handle buffer allocation failures we can't do much. * handle buffer allocation failures we can't do much.
*/ */
if (!(++retries % 100)) if (!(++retries % 100))
printk(KERN_ERR xfs_err(NULL,
"XFS: possible memory allocation " "possible memory allocation deadlock in %s (mode:0x%x)",
"deadlock in %s (mode:0x%x)\n",
__func__, gfp_mask); __func__, gfp_mask);
XFS_STATS_INC(xb_page_retries); XFS_STATS_INC(xb_page_retries);
@ -615,8 +614,8 @@ xfs_buf_get(
if (!(bp->b_flags & XBF_MAPPED)) { if (!(bp->b_flags & XBF_MAPPED)) {
error = _xfs_buf_map_pages(bp, flags); error = _xfs_buf_map_pages(bp, flags);
if (unlikely(error)) { if (unlikely(error)) {
printk(KERN_WARNING "%s: failed to map pages\n", xfs_warn(target->bt_mount,
__func__); "%s: failed to map pages\n", __func__);
goto no_buffer; goto no_buffer;
} }
} }
@ -850,8 +849,8 @@ xfs_buf_get_uncached(
error = _xfs_buf_map_pages(bp, XBF_MAPPED); error = _xfs_buf_map_pages(bp, XBF_MAPPED);
if (unlikely(error)) { if (unlikely(error)) {
printk(KERN_WARNING "%s: failed to map pages\n", xfs_warn(target->bt_mount,
__func__); "%s: failed to map pages\n", __func__);
goto fail_free_mem; goto fail_free_mem;
} }
@ -1617,8 +1616,8 @@ xfs_setsize_buftarg_flags(
btp->bt_smask = sectorsize - 1; btp->bt_smask = sectorsize - 1;
if (set_blocksize(btp->bt_bdev, sectorsize)) { if (set_blocksize(btp->bt_bdev, sectorsize)) {
printk(KERN_WARNING xfs_warn(btp->bt_mount,
"XFS: Cannot set_blocksize to %u on device %s\n", "Cannot set_blocksize to %u on device %s\n",
sectorsize, XFS_BUFTARG_NAME(btp)); sectorsize, XFS_BUFTARG_NAME(btp));
return EINVAL; return EINVAL;
} }

127
fs/xfs/linux-2.6/xfs_super.c
View File

@ -172,6 +172,15 @@ xfs_parseargs(
int iosize = 0; int iosize = 0;
__uint8_t iosizelog = 0; __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. * Copy binary VFS mount flags we are interested in.
*/ */
@ -208,24 +217,21 @@ xfs_parseargs(
if (!strcmp(this_char, MNTOPT_LOGBUFS)) { if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
mp->m_logbufs = simple_strtoul(value, &eov, 10); mp->m_logbufs = simple_strtoul(value, &eov, 10);
} else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) { } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
mp->m_logbsize = suffix_strtoul(value, &eov, 10); mp->m_logbsize = suffix_strtoul(value, &eov, 10);
} else if (!strcmp(this_char, MNTOPT_LOGDEV)) { } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -233,14 +239,12 @@ xfs_parseargs(
if (!mp->m_logname) if (!mp->m_logname)
return ENOMEM; return ENOMEM;
} else if (!strcmp(this_char, MNTOPT_MTPT)) { } else if (!strcmp(this_char, MNTOPT_MTPT)) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option not allowed on this system",
"XFS: %s option not allowed on this system",
this_char); this_char);
return EINVAL; return EINVAL;
} else if (!strcmp(this_char, MNTOPT_RTDEV)) { } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -249,8 +253,7 @@ xfs_parseargs(
return ENOMEM; return ENOMEM;
} else if (!strcmp(this_char, MNTOPT_BIOSIZE)) { } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -258,8 +261,7 @@ xfs_parseargs(
iosizelog = ffs(iosize) - 1; iosizelog = ffs(iosize) - 1;
} else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) { } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -281,16 +283,14 @@ xfs_parseargs(
mp->m_flags |= XFS_MOUNT_SWALLOC; mp->m_flags |= XFS_MOUNT_SWALLOC;
} else if (!strcmp(this_char, MNTOPT_SUNIT)) { } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
dsunit = simple_strtoul(value, &eov, 10); dsunit = simple_strtoul(value, &eov, 10);
} else if (!strcmp(this_char, MNTOPT_SWIDTH)) { } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
if (!value || !*value) { if (!value || !*value) {
cmn_err(CE_WARN, xfs_warn(mp, "%s option requires an argument",
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -298,8 +298,7 @@ xfs_parseargs(
} else if (!strcmp(this_char, MNTOPT_64BITINODE)) { } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS; mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
#if !XFS_BIG_INUMS #if !XFS_BIG_INUMS
cmn_err(CE_WARN, xfs_warn(mp, "%s option not allowed on this system",
"XFS: %s option not allowed on this system",
this_char); this_char);
return EINVAL; return EINVAL;
#endif #endif
@ -357,20 +356,19 @@ xfs_parseargs(
} else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) { } else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
mp->m_flags &= ~XFS_MOUNT_DELAYLOG; mp->m_flags &= ~XFS_MOUNT_DELAYLOG;
} else if (!strcmp(this_char, "ihashsize")) { } else if (!strcmp(this_char, "ihashsize")) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: ihashsize no longer used, option is deprecated."); "ihashsize no longer used, option is deprecated.");
} else if (!strcmp(this_char, "osyncisdsync")) { } else if (!strcmp(this_char, "osyncisdsync")) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: osyncisdsync has no effect, option is deprecated."); "osyncisdsync has no effect, option is deprecated.");
} else if (!strcmp(this_char, "osyncisosync")) { } else if (!strcmp(this_char, "osyncisosync")) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: osyncisosync has no effect, option is deprecated."); "osyncisosync has no effect, option is deprecated.");
} else if (!strcmp(this_char, "irixsgid")) { } else if (!strcmp(this_char, "irixsgid")) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: irixsgid is now a sysctl(2) variable, option is deprecated."); "irixsgid is now a sysctl(2) variable, option is deprecated.");
} else { } else {
cmn_err(CE_WARN, xfs_warn(mp, "unknown mount option [%s].", this_char);
"XFS: unknown mount option [%s].", this_char);
return EINVAL; return EINVAL;
} }
} }
@ -380,40 +378,37 @@ xfs_parseargs(
*/ */
if ((mp->m_flags & XFS_MOUNT_NORECOVERY) && if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
!(mp->m_flags & XFS_MOUNT_RDONLY)) { !(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; return EINVAL;
} }
if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) { if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: sunit and swidth options incompatible with the noalign option"); "sunit and swidth options incompatible with the noalign option");
return EINVAL; return EINVAL;
} }
#ifndef CONFIG_XFS_QUOTA #ifndef CONFIG_XFS_QUOTA
if (XFS_IS_QUOTA_RUNNING(mp)) { if (XFS_IS_QUOTA_RUNNING(mp)) {
cmn_err(CE_WARN, xfs_warn(mp, "quota support not available in this kernel.");
"XFS: quota support not available in this kernel.");
return EINVAL; return EINVAL;
} }
#endif #endif
if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) && if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
(mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) { (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
cmn_err(CE_WARN, xfs_warn(mp, "cannot mount with both project and group quota");
"XFS: cannot mount with both project and group quota");
return EINVAL; return EINVAL;
} }
if ((dsunit && !dswidth) || (!dsunit && dswidth)) { if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
cmn_err(CE_WARN, xfs_warn(mp, "sunit and swidth must be specified together");
"XFS: sunit and swidth must be specified together");
return EINVAL; return EINVAL;
} }
if (dsunit && (dswidth % dsunit != 0)) { if (dsunit && (dswidth % dsunit != 0)) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: stripe width (%d) must be a multiple of the stripe unit (%d)", "stripe width (%d) must be a multiple of the stripe unit (%d)",
dswidth, dsunit); dswidth, dsunit);
return EINVAL; return EINVAL;
} }
@ -439,8 +434,7 @@ done:
mp->m_logbufs != 0 && mp->m_logbufs != 0 &&
(mp->m_logbufs < XLOG_MIN_ICLOGS || (mp->m_logbufs < XLOG_MIN_ICLOGS ||
mp->m_logbufs > XLOG_MAX_ICLOGS)) { mp->m_logbufs > XLOG_MAX_ICLOGS)) {
cmn_err(CE_WARN, xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
"XFS: invalid logbufs value: %d [not %d-%d]",
mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS); mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
return XFS_ERROR(EINVAL); return XFS_ERROR(EINVAL);
} }
@ -449,22 +443,16 @@ done:
(mp->m_logbsize < XLOG_MIN_RECORD_BSIZE || (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
mp->m_logbsize > XLOG_MAX_RECORD_BSIZE || mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
!is_power_of_2(mp->m_logbsize))) { !is_power_of_2(mp->m_logbsize))) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]", "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
mp->m_logbsize); mp->m_logbsize);
return XFS_ERROR(EINVAL); 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) {
if (iosizelog > XFS_MAX_IO_LOG || if (iosizelog > XFS_MAX_IO_LOG ||
iosizelog < XFS_MIN_IO_LOG) { iosizelog < XFS_MIN_IO_LOG) {
cmn_err(CE_WARN, xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
"XFS: invalid log iosize: %d [not %d-%d]",
iosizelog, XFS_MIN_IO_LOG, iosizelog, XFS_MIN_IO_LOG,
XFS_MAX_IO_LOG); XFS_MAX_IO_LOG);
return XFS_ERROR(EINVAL); return XFS_ERROR(EINVAL);
@ -611,7 +599,7 @@ xfs_blkdev_get(
mp); mp);
if (IS_ERR(*bdevp)) { if (IS_ERR(*bdevp)) {
error = PTR_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; return -error;
@ -665,23 +653,23 @@ xfs_mountfs_check_barriers(xfs_mount_t *mp)
int error; int error;
if (mp->m_logdev_targp != mp->m_ddev_targp) { 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"); "Disabling barriers, not supported with external log device");
mp->m_flags &= ~XFS_MOUNT_BARRIER; mp->m_flags &= ~XFS_MOUNT_BARRIER;
return; return;
} }
if (xfs_readonly_buftarg(mp->m_ddev_targp)) { if (xfs_readonly_buftarg(mp->m_ddev_targp)) {
xfs_fs_cmn_err(CE_NOTE, mp, xfs_notice(mp,
"Disabling barriers, underlying device is readonly"); "Disabling barriers, underlying device is readonly");
mp->m_flags &= ~XFS_MOUNT_BARRIER; mp->m_flags &= ~XFS_MOUNT_BARRIER;
return; return;
} }
error = xfs_barrier_test(mp); error = xfs_barrier_test(mp);
if (error) { if (error) {
xfs_fs_cmn_err(CE_NOTE, mp, xfs_notice(mp,
"Disabling barriers, trial barrier write failed"); "Disabling barriers, trial barrier write failed");
mp->m_flags &= ~XFS_MOUNT_BARRIER; mp->m_flags &= ~XFS_MOUNT_BARRIER;
return; return;
} }
@ -744,8 +732,8 @@ xfs_open_devices(
goto out_close_logdev; goto out_close_logdev;
if (rtdev == ddev || rtdev == logdev) { if (rtdev == ddev || rtdev == logdev) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: Cannot mount filesystem with identical rtdev and ddev/logdev."); "Cannot mount filesystem with identical rtdev and ddev/logdev.");
error = EINVAL; error = EINVAL;
goto out_close_rtdev; goto out_close_rtdev;
} }
@ -1346,8 +1334,8 @@ xfs_fs_remount(
* options that we can't actually change. * options that we can't actually change.
*/ */
#if 0 #if 0
printk(KERN_INFO xfs_info(mp,
"XFS: mount option \"%s\" not supported for remount\n", p); "mount option \"%s\" not supported for remount\n", p);
return -EINVAL; return -EINVAL;
#else #else
break; break;
@ -1368,8 +1356,7 @@ xfs_fs_remount(
if (mp->m_update_flags) { if (mp->m_update_flags) {
error = xfs_mount_log_sb(mp, mp->m_update_flags); error = xfs_mount_log_sb(mp, mp->m_update_flags);
if (error) { if (error) {
cmn_err(CE_WARN, xfs_warn(mp, "failed to write sb changes");
"XFS: failed to write sb changes");
return error; return error;
} }
mp->m_update_flags = 0; mp->m_update_flags = 0;
@ -1453,15 +1440,15 @@ xfs_finish_flags(
mp->m_logbsize = mp->m_sb.sb_logsunit; mp->m_logbsize = mp->m_sb.sb_logsunit;
} else if (mp->m_logbsize > 0 && } else if (mp->m_logbsize > 0 &&
mp->m_logbsize < mp->m_sb.sb_logsunit) { mp->m_logbsize < mp->m_sb.sb_logsunit) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: logbuf size must be greater than or equal to log stripe size"); "logbuf size must be greater than or equal to log stripe size");
return XFS_ERROR(EINVAL); return XFS_ERROR(EINVAL);
} }
} else { } else {
/* Fail a mount if the logbuf is larger than 32K */ /* Fail a mount if the logbuf is larger than 32K */
if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) { if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: logbuf size for version 1 logs must be 16K or 32K"); "logbuf size for version 1 logs must be 16K or 32K");
return XFS_ERROR(EINVAL); return XFS_ERROR(EINVAL);
} }
} }
@ -1478,8 +1465,8 @@ xfs_finish_flags(
* prohibit r/w mounts of read-only filesystems * prohibit r/w mounts of read-only filesystems
*/ */
if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) { if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
cmn_err(CE_WARN, xfs_warn(mp,
"XFS: cannot mount a read-only filesystem as read-write"); "cannot mount a read-only filesystem as read-write");
return XFS_ERROR(EROFS); return XFS_ERROR(EROFS);
} }

5
fs/xfs/linux-2.6/xfs_sync.c
View File

@ -425,8 +425,7 @@ xfs_quiesce_attr(
/* Push the superblock and write an unmount record */ /* Push the superblock and write an unmount record */
error = xfs_log_sbcount(mp, 1); error = xfs_log_sbcount(mp, 1);
if (error) if (error)
xfs_fs_cmn_err(CE_WARN, mp, xfs_warn(mp, "xfs_attr_quiesce: failed to log sb changes. "
"xfs_attr_quiesce: failed to log sb changes. "
"Frozen image may not be consistent."); "Frozen image may not be consistent.");
xfs_log_unmount_write(mp); xfs_log_unmount_write(mp);
xfs_unmountfs_writesb(mp); xfs_unmountfs_writesb(mp);
@ -806,7 +805,7 @@ xfs_reclaim_inode(
* pass on the error. * pass on the error.
*/ */
if (error && error != EAGAIN && !XFS_FORCED_SHUTDOWN(ip->i_mount)) { if (error && error != EAGAIN && !XFS_FORCED_SHUTDOWN(ip->i_mount)) {
xfs_fs_cmn_err(CE_WARN, ip->i_mount, xfs_warn(ip->i_mount,
"inode 0x%llx background reclaim flush failed with %d", "inode 0x%llx background reclaim flush failed with %d",
(long long)ip->i_ino, error); (long long)ip->i_ino, error);
} }

2
fs/xfs/linux-2.6/xfs_sysctl.c
View File

@ -37,7 +37,7 @@ xfs_stats_clear_proc_handler(
ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos); ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
if (!ret && write && *valp) { if (!ret && write && *valp) {
printk("XFS Clearing xfsstats\n"); xfs_notice(NULL, "Clearing xfsstats");
for_each_possible_cpu(c) { for_each_possible_cpu(c) {
preempt_disable(); preempt_disable();
/* save vn_active, it's a universal truth! */ /* save vn_active, it's a universal truth! */