GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-07-23 23:32:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[XFS] Portability changes: remove prdev, stick to one diagnostic

Browse source 
interface.

SGI-PV: 953338
SGI-Modid: xfs-linux-melb:xfs-kern:26103a

Signed-off-by: Nathan Scott <nathans@sgi.com>
This commit is contained in:
Nathan Scott 2006-06-09 15:29:40 +10:00
parent 9c48876a05
commit b65745205f
10 changed files with 67 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

4
fs/xfs/support/debug.c
View file

@ -47,7 +47,7 @@ cmn_err(register int level, char *fmt, ...)
va_start(ap, fmt); va_start(ap, fmt);
if (*fmt == '!') fp++; if (*fmt == '!') fp++;
len = vsprintf(message, fp, ap); len = vsprintf(message, fp, ap);
if (message[len-1] != '\n') if (level != CE_DEBUG && message[len-1] != '\n')
strcat(message, "\n"); strcat(message, "\n");
printk("%s%s", err_level[level], message); printk("%s%s", err_level[level], message);
va_end(ap); va_end(ap);
@ -68,7 +68,7 @@ icmn_err(register int level, char *fmt, va_list ap)
level = XFS_MAX_ERR_LEVEL; level = XFS_MAX_ERR_LEVEL;
spin_lock_irqsave(&xfs_err_lock,flags); spin_lock_irqsave(&xfs_err_lock,flags);
len = vsprintf(message, fmt, ap); len = vsprintf(message, fmt, ap);
if (message[len-1] != '\n') if (level != CE_DEBUG && message[len-1] != '\n')
strcat(message, "\n"); strcat(message, "\n");
spin_unlock_irqrestore(&xfs_err_lock,flags); spin_unlock_irqrestore(&xfs_err_lock,flags);
printk("%s%s", err_level[level], message); printk("%s%s", err_level[level], message);

3
fs/xfs/support/debug.h
View file

@ -33,9 +33,6 @@ extern void cmn_err(int, char *, ...)
__attribute__ ((format (printf, 2, 3))); __attribute__ ((format (printf, 2, 3)));
extern void assfail(char *expr, char *f, int l); extern void assfail(char *expr, char *f, int l);
#define prdev(fmt,targ,args...) \
printk("Device %s - " fmt "\n", XFS_BUFTARG_NAME(targ), ## args)
#define ASSERT_ALWAYS(expr) \ #define ASSERT_ALWAYS(expr) \
(unlikely((expr) != 0) ? (void)0 : assfail(#expr, __FILE__, __LINE__)) (unlikely((expr) != 0) ? (void)0 : assfail(#expr, __FILE__, __LINE__))

6
fs/xfs/xfs_buf_item.c
View file

@ -1030,9 +1030,9 @@ xfs_buf_iodone_callbacks(
if ((XFS_BUF_TARGET(bp) != lasttarg) || if ((XFS_BUF_TARGET(bp) != lasttarg) ||
(time_after(jiffies, (lasttime + 5*HZ)))) { (time_after(jiffies, (lasttime + 5*HZ)))) {
lasttime = jiffies; lasttime = jiffies;
prdev("XFS write error in file system meta-data " cmn_err(CE_ALERT, "Device %s, XFS metadata write error"
"block 0x%llx in %s", " block 0x%llx in %s",
XFS_BUF_TARGET(bp), XFS_BUFTARG_NAME(XFS_BUF_TARGET(bp)),
(__uint64_t)XFS_BUF_ADDR(bp), mp->m_fsname); (__uint64_t)XFS_BUF_ADDR(bp), mp->m_fsname);
} }
lasttarg = XFS_BUF_TARGET(bp); lasttarg = XFS_BUF_TARGET(bp);

5
fs/xfs/xfs_inode.c
View file

@ -352,8 +352,9 @@ xfs_itobp(
if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP, if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP,
XFS_RANDOM_ITOBP_INOTOBP))) { XFS_RANDOM_ITOBP_INOTOBP))) {
#ifdef DEBUG #ifdef DEBUG
prdev("bad inode magic/vsn daddr %lld #%d (magic=%x)", cmn_err(CE_ALERT, "Device %s - bad inode magic/vsn "
mp->m_ddev_targp, "daddr %lld #%d (magic=%x)",
XFS_BUFTARG_NAME(mp->m_ddev_targp),
(unsigned long long)imap.im_blkno, i, (unsigned long long)imap.im_blkno, i,
INT_GET(dip->di_core.di_magic, ARCH_CONVERT)); INT_GET(dip->di_core.di_magic, ARCH_CONVERT));
#endif #endif

18
fs/xfs/xfs_log_recover.c
View file

@ -193,14 +193,14 @@ xlog_header_check_dump(
{ {
int b; int b;
printk("%s: SB : uuid = ", __FUNCTION__); cmn_err(CE_DEBUG, "%s: SB : uuid = ", __FUNCTION__);
for (b = 0; b < 16; b++) for (b = 0; b < 16; b++)
printk("%02x",((unsigned char *)&mp->m_sb.sb_uuid)[b]); cmn_err(CE_DEBUG, "%02x", ((uchar_t *)&mp->m_sb.sb_uuid)[b]);
printk(", fmt = %d\n", XLOG_FMT); cmn_err(CE_DEBUG, ", fmt = %d\n", XLOG_FMT);
printk(" log : uuid = "); cmn_err(CE_DEBUG, " log : uuid = ");
for (b = 0; b < 16; b++) for (b = 0; b < 16; b++)
printk("%02x",((unsigned char *)&head->h_fs_uuid)[b]); cmn_err(CE_DEBUG, "%02x",((uchar_t *)&head->h_fs_uuid)[b]);
printk(", fmt = %d\n", INT_GET(head->h_fmt, ARCH_CONVERT)); cmn_err(CE_DEBUG, ", fmt = %d\n", INT_GET(head->h_fmt, ARCH_CONVERT));
} }
#else #else
#define xlog_header_check_dump(mp, head) #define xlog_header_check_dump(mp, head)
@ -3444,13 +3444,13 @@ xlog_unpack_data_checksum(
if (rhead->h_chksum || if (rhead->h_chksum ||
((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) { ((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) {
cmn_err(CE_DEBUG, cmn_err(CE_DEBUG,
"XFS: LogR chksum mismatch: was (0x%x) is (0x%x)", "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)\n",
INT_GET(rhead->h_chksum, ARCH_CONVERT), chksum); INT_GET(rhead->h_chksum, ARCH_CONVERT), chksum);
cmn_err(CE_DEBUG, cmn_err(CE_DEBUG,
"XFS: Disregard message if filesystem was created with non-DEBUG kernel"); "XFS: Disregard message if filesystem was created with non-DEBUG kernel");
if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) { if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
cmn_err(CE_DEBUG, cmn_err(CE_DEBUG,
"XFS: LogR this is a LogV2 filesystem"); "XFS: LogR this is a LogV2 filesystem\n");
} }
log->l_flags |= XLOG_CHKSUM_MISMATCH; log->l_flags |= XLOG_CHKSUM_MISMATCH;
} }
@ -3999,7 +3999,7 @@ xlog_recover_finish(
log->l_flags &= ~XLOG_RECOVERY_NEEDED; log->l_flags &= ~XLOG_RECOVERY_NEEDED;
} else { } else {
cmn_err(CE_DEBUG, cmn_err(CE_DEBUG,
"!Ending clean XFS mount for filesystem: %s", "!Ending clean XFS mount for filesystem: %s\n",
log->l_mp->m_fsname); log->l_mp->m_fsname);
} }
return 0; return 0;

5
fs/xfs/xfs_mount.c
View file

@ -1006,8 +1006,9 @@ xfs_mountfs(
if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) { if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) {
cmn_err(CE_WARN, "XFS: corrupted root inode"); cmn_err(CE_WARN, "XFS: corrupted root inode");
prdev("Root inode %llu is not a directory", cmn_err(CE_WARN, "Device %s - root %llu is not a directory",
mp->m_ddev_targp, (unsigned long long)rip->i_ino); XFS_BUFTARG_NAME(mp->m_ddev_targp),
(unsigned long long)rip->i_ino);
xfs_iunlock(rip, XFS_ILOCK_EXCL); xfs_iunlock(rip, XFS_ILOCK_EXCL);
XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW, XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
mp); mp);

12
fs/xfs/xfs_rtalloc.c
View file

@ -2404,10 +2404,10 @@ xfs_rtprint_range(
{ {
xfs_extlen_t i; /* block number in the extent */ xfs_extlen_t i; /* block number in the extent */
printk("%Ld: ", (long long)start); cmn_err(CE_DEBUG, "%Ld: ", (long long)start);
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
printk("%d", xfs_rtcheck_bit(mp, tp, start + i, 1)); cmn_err(CE_DEBUG, "%d", xfs_rtcheck_bit(mp, tp, start + i, 1));
printk("\n"); cmn_err(CE_DEBUG, "\n");
} }
/* /*
@ -2431,17 +2431,17 @@ xfs_rtprint_summary(
(void)xfs_rtget_summary(mp, tp, l, i, &sumbp, &sb, &c); (void)xfs_rtget_summary(mp, tp, l, i, &sumbp, &sb, &c);
if (c) { if (c) {
if (!p) { if (!p) {
printk("%Ld-%Ld:", 1LL << l, cmn_err(CE_DEBUG, "%Ld-%Ld:", 1LL << l,
XFS_RTMIN((1LL << l) + XFS_RTMIN((1LL << l) +
((1LL << l) - 1LL), ((1LL << l) - 1LL),
mp->m_sb.sb_rextents)); mp->m_sb.sb_rextents));
p = 1; p = 1;
} }
printk(" %Ld:%d", (long long)i, c); cmn_err(CE_DEBUG, " %Ld:%d", (long long)i, c);
} }
} }
if (p) if (p)
printk("\n"); cmn_err(CE_DEBUG, "\n");
} }
if (sumbp) if (sumbp)
xfs_trans_brelse(tp, sumbp); xfs_trans_brelse(tp, sumbp);

4
fs/xfs/xfs_trans_buf.c
View file

@ -320,7 +320,7 @@ xfs_trans_read_buf(
if (xfs_error_target == target) { if (xfs_error_target == target) {
if (((xfs_req_num++) % xfs_error_mod) == 0) { if (((xfs_req_num++) % xfs_error_mod) == 0) {
xfs_buf_relse(bp); xfs_buf_relse(bp);
printk("Returning error!\n"); cmn_err(CE_DEBUG, "Returning error!\n");
return XFS_ERROR(EIO); return XFS_ERROR(EIO);
} }
} }
@ -425,7 +425,7 @@ xfs_trans_read_buf(
xfs_force_shutdown(tp->t_mountp, xfs_force_shutdown(tp->t_mountp,
SHUTDOWN_META_IO_ERROR); SHUTDOWN_META_IO_ERROR);
xfs_buf_relse(bp); xfs_buf_relse(bp);
printk("Returning error in trans!\n"); cmn_err(CE_DEBUG, "Returning trans error!\n");
return XFS_ERROR(EIO); return XFS_ERROR(EIO);
} }
} }

2
fs/xfs/xfs_trans_item.c
View file

@ -493,7 +493,7 @@ xfs_trans_add_busy(xfs_trans_t *tp, xfs_agnumber_t ag, xfs_extlen_t idx)
break; break;
} else { } else {
/* out-of-order vacancy */ /* out-of-order vacancy */
printk("OOO vacancy lbcp 0x%p\n", lbcp); cmn_err(CE_DEBUG, "OOO vacancy lbcp 0x%p\n", lbcp);
ASSERT(0); ASSERT(0);
} }
} }

59
fs/xfs/xfs_vfsops.c
View file

@ -1708,42 +1708,48 @@ xfs_parseargs(
if (!strcmp(this_char, MNTOPT_LOGBUFS)) { if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
args->logbufs = simple_strtoul(value, &eov, 10); args->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) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
args->logbufsize = suffix_strtoul(value, &eov, 10); args->logbufsize = 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) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
strncpy(args->logname, value, MAXNAMELEN); strncpy(args->logname, value, MAXNAMELEN);
} else if (!strcmp(this_char, MNTOPT_MTPT)) { } else if (!strcmp(this_char, MNTOPT_MTPT)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
strncpy(args->mtpt, value, MAXNAMELEN); strncpy(args->mtpt, value, MAXNAMELEN);
} else if (!strcmp(this_char, MNTOPT_RTDEV)) { } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
strncpy(args->rtname, value, MAXNAMELEN); strncpy(args->rtname, value, MAXNAMELEN);
} else if (!strcmp(this_char, MNTOPT_BIOSIZE)) { } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -1752,7 +1758,8 @@ xfs_parseargs(
args->iosizelog = (uint8_t) iosize; args->iosizelog = (uint8_t) iosize;
} else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) { } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -1761,7 +1768,8 @@ xfs_parseargs(
args->iosizelog = ffs(iosize) - 1; args->iosizelog = ffs(iosize) - 1;
} else if (!strcmp(this_char, MNTOPT_IHASHSIZE)) { } else if (!strcmp(this_char, MNTOPT_IHASHSIZE)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -1782,7 +1790,8 @@ xfs_parseargs(
} else if (!strcmp(this_char, MNTOPT_INO64)) { } else if (!strcmp(this_char, MNTOPT_INO64)) {
args->flags |= XFSMNT_INO64; args->flags |= XFSMNT_INO64;
#if !XFS_BIG_INUMS #if !XFS_BIG_INUMS
printk("XFS: %s option not allowed on this system\n", cmn_err(CE_WARN,
"XFS: %s option not allowed on this system",
this_char); this_char);
return EINVAL; return EINVAL;
#endif #endif
@ -1792,14 +1801,16 @@ xfs_parseargs(
args->flags |= XFSMNT_SWALLOC; args->flags |= XFSMNT_SWALLOC;
} else if (!strcmp(this_char, MNTOPT_SUNIT)) { } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
if (!value || !*value) { if (!value || !*value) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"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) {
printk("XFS: %s option requires an argument\n", cmn_err(CE_WARN,
"XFS: %s option requires an argument",
this_char); this_char);
return EINVAL; return EINVAL;
} }
@ -1807,7 +1818,8 @@ xfs_parseargs(
} else if (!strcmp(this_char, MNTOPT_64BITINODE)) { } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
args->flags &= ~XFSMNT_32BITINODES; args->flags &= ~XFSMNT_32BITINODES;
#if !XFS_BIG_INUMS #if !XFS_BIG_INUMS
printk("XFS: %s option not allowed on this system\n", cmn_err(CE_WARN,
"XFS: %s option not allowed on this system",
this_char); this_char);
return EINVAL; return EINVAL;
#endif #endif
@ -1831,36 +1843,41 @@ xfs_parseargs(
args->flags &= ~XFSMNT_ATTR2; args->flags &= ~XFSMNT_ATTR2;
} else if (!strcmp(this_char, "osyncisdsync")) { } else if (!strcmp(this_char, "osyncisdsync")) {
/* no-op, this is now the default */ /* no-op, this is now the default */
printk("XFS: osyncisdsync is now the default, option is deprecated.\n"); cmn_err(CE_WARN,
"XFS: osyncisdsync is now the default, option is deprecated.");
} else if (!strcmp(this_char, "irixsgid")) { } else if (!strcmp(this_char, "irixsgid")) {
printk("XFS: irixsgid is now a sysctl(2) variable, option is deprecated.\n"); cmn_err(CE_WARN,
"XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
} else { } else {
printk("XFS: unknown mount option [%s].\n", this_char); cmn_err(CE_WARN,
"XFS: unknown mount option [%s].", this_char);
return EINVAL; return EINVAL;
} }
} }
if (args->flags & XFSMNT_NORECOVERY) { if (args->flags & XFSMNT_NORECOVERY) {
if ((vfsp->vfs_flag & VFS_RDONLY) == 0) { if ((vfsp->vfs_flag & VFS_RDONLY) == 0) {
printk("XFS: no-recovery mounts must be read-only.\n"); cmn_err(CE_WARN,
"XFS: no-recovery mounts must be read-only.");
return EINVAL; return EINVAL;
} }
} }
if ((args->flags & XFSMNT_NOALIGN) && (dsunit || dswidth)) { if ((args->flags & XFSMNT_NOALIGN) && (dsunit || dswidth)) {
printk( cmn_err(CE_WARN,
"XFS: sunit and swidth options incompatible with the noalign option\n"); "XFS: sunit and swidth options incompatible with the noalign option");
return EINVAL; return EINVAL;
} }
if ((dsunit && !dswidth) || (!dsunit && dswidth)) { if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
printk("XFS: sunit and swidth must be specified together\n"); cmn_err(CE_WARN,
"XFS: sunit and swidth must be specified together");
return EINVAL; return EINVAL;
} }
if (dsunit && (dswidth % dsunit != 0)) { if (dsunit && (dswidth % dsunit != 0)) {
printk( cmn_err(CE_WARN,
"XFS: stripe width (%d) must be a multiple of the stripe unit (%d)\n", "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
dswidth, dsunit); dswidth, dsunit);
return EINVAL; return EINVAL;
} }