1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2011 Red Hat, Inc. All Rights Reserved. 4 */ 5 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_error.h" 9 #include "xfs_shared.h" 10 #include "xfs_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_mount.h" 13 14 /* 15 * XFS logging functions 16 */ 17 static void 18 __xfs_printk( 19 const char *level, 20 const struct xfs_mount *mp, 21 struct va_format *vaf) 22 { 23 if (mp && mp->m_super) { 24 printk("%sXFS (%s): %pV\n", level, mp->m_super->s_id, vaf); 25 return; 26 } 27 printk("%sXFS: %pV\n", level, vaf); 28 } 29 30 void 31 xfs_printk_level( 32 const char *kern_level, 33 const struct xfs_mount *mp, 34 const char *fmt, ...) 35 { 36 struct va_format vaf; 37 va_list args; 38 int level; 39 40 va_start(args, fmt); 41 vaf.fmt = fmt; 42 vaf.va = &args; 43 44 __xfs_printk(kern_level, mp, &vaf); 45 46 va_end(args); 47 48 if (!kstrtoint(kern_level, 0, &level) && 49 level <= LOGLEVEL_ERR && 50 xfs_error_level >= XFS_ERRLEVEL_HIGH) 51 xfs_stack_trace(); 52 } 53 54 void 55 _xfs_alert_tag( 56 const struct xfs_mount *mp, 57 uint32_t panic_tag, 58 const char *fmt, ...) 59 { 60 struct va_format vaf; 61 va_list args; 62 int do_panic = 0; 63 64 if (xfs_panic_mask && (xfs_panic_mask & panic_tag)) { 65 xfs_alert(mp, "Transforming an alert into a BUG."); 66 do_panic = 1; 67 } 68 69 va_start(args, fmt); 70 71 vaf.fmt = fmt; 72 vaf.va = &args; 73 74 __xfs_printk(KERN_ALERT, mp, &vaf); 75 va_end(args); 76 77 BUG_ON(do_panic); 78 } 79 80 void 81 asswarn( 82 struct xfs_mount *mp, 83 char *expr, 84 char *file, 85 int line) 86 { 87 xfs_warn(mp, "Assertion failed: %s, file: %s, line: %d", 88 expr, file, line); 89 WARN_ON(1); 90 } 91 92 void 93 assfail( 94 struct xfs_mount *mp, 95 char *expr, 96 char *file, 97 int line) 98 { 99 xfs_emerg(mp, "Assertion failed: %s, file: %s, line: %d", 100 expr, file, line); 101 if (xfs_globals.bug_on_assert) 102 BUG(); 103 else 104 WARN_ON(1); 105 } 106 107 void 108 xfs_hex_dump(const void *p, int length) 109 { 110 print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, p, length, 1); 111 } 112 113 void 114 xfs_buf_alert_ratelimited( 115 struct xfs_buf *bp, 116 const char *rlmsg, 117 const char *fmt, 118 ...) 119 { 120 struct xfs_mount *mp = bp->b_mount; 121 struct va_format vaf; 122 va_list args; 123 124 /* use the more aggressive per-target rate limit for buffers */ 125 if (!___ratelimit(&bp->b_target->bt_ioerror_rl, rlmsg)) 126 return; 127 128 va_start(args, fmt); 129 vaf.fmt = fmt; 130 vaf.va = &args; 131 __xfs_printk(KERN_ALERT, mp, &vaf); 132 va_end(args); 133 } 134 135 void 136 xfs_warn_experimental( 137 struct xfs_mount *mp, 138 enum xfs_experimental_feat feat) 139 { 140 static const struct { 141 const char *name; 142 long opstate; 143 } features[] = { 144 [XFS_EXPERIMENTAL_PNFS] = { 145 .opstate = XFS_OPSTATE_WARNED_PNFS, 146 .name = "pNFS", 147 }, 148 [XFS_EXPERIMENTAL_SCRUB] = { 149 .opstate = XFS_OPSTATE_WARNED_SCRUB, 150 .name = "online scrub", 151 }, 152 [XFS_EXPERIMENTAL_SHRINK] = { 153 .opstate = XFS_OPSTATE_WARNED_SHRINK, 154 .name = "online shrink", 155 }, 156 [XFS_EXPERIMENTAL_LARP] = { 157 .opstate = XFS_OPSTATE_WARNED_LARP, 158 .name = "logged extended attributes", 159 }, 160 [XFS_EXPERIMENTAL_LBS] = { 161 .opstate = XFS_OPSTATE_WARNED_LBS, 162 .name = "large block size", 163 }, 164 [XFS_EXPERIMENTAL_EXCHRANGE] = { 165 .opstate = XFS_OPSTATE_WARNED_EXCHRANGE, 166 .name = "exchange range", 167 }, 168 [XFS_EXPERIMENTAL_PPTR] = { 169 .opstate = XFS_OPSTATE_WARNED_PPTR, 170 .name = "parent pointer", 171 }, 172 [XFS_EXPERIMENTAL_METADIR] = { 173 .opstate = XFS_OPSTATE_WARNED_METADIR, 174 .name = "metadata directory tree", 175 }, 176 }; 177 ASSERT(feat >= 0 && feat < XFS_EXPERIMENTAL_MAX); 178 BUILD_BUG_ON(ARRAY_SIZE(features) != XFS_EXPERIMENTAL_MAX); 179 180 if (xfs_should_warn(mp, features[feat].opstate)) 181 xfs_warn(mp, 182 "EXPERIMENTAL %s feature enabled. Use at your own risk!", 183 features[feat].name); 184 } 185