fs/xfs/xfs_message.c

   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 }