root/fs/xfs/xfs_message.c

DEFINITIONS

1. __xfs_printk
2. xfs_alert_tag
3. asswarn
4. assfail
5. xfs_hex_dump

   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_fsname) {
  24                 printk("%sXFS (%s): %pV\n", level, mp->m_fsname, vaf);
  25                 return;
  26         }
  27         printk("%sXFS: %pV\n", level, vaf);
  28 }
  29 
  30 #define define_xfs_printk_level(func, kern_level)               \
  31 void func(const struct xfs_mount *mp, const char *fmt, ...)     \
  32 {                                                               \
  33         struct va_format        vaf;                            \
  34         va_list                 args;                           \
  35         int                     level;                          \
  36                                                                 \
  37         va_start(args, fmt);                                    \
  38                                                                 \
  39         vaf.fmt = fmt;                                          \
  40         vaf.va = &args;                                         \
  41                                                                 \
  42         __xfs_printk(kern_level, mp, &vaf);                     \
  43         va_end(args);                                           \
  44                                                                 \
  45         if (!kstrtoint(kern_level, 0, &level) &&                \
  46             level <= LOGLEVEL_ERR &&                            \
  47             xfs_error_level >= XFS_ERRLEVEL_HIGH)               \
  48                 xfs_stack_trace();                              \
  49 }                                                               \
  50 
  51 define_xfs_printk_level(xfs_emerg, KERN_EMERG);
  52 define_xfs_printk_level(xfs_alert, KERN_ALERT);
  53 define_xfs_printk_level(xfs_crit, KERN_CRIT);
  54 define_xfs_printk_level(xfs_err, KERN_ERR);
  55 define_xfs_printk_level(xfs_warn, KERN_WARNING);
  56 define_xfs_printk_level(xfs_notice, KERN_NOTICE);
  57 define_xfs_printk_level(xfs_info, KERN_INFO);
  58 #ifdef DEBUG
  59 define_xfs_printk_level(xfs_debug, KERN_DEBUG);
  60 #endif
  61 
  62 void
  63 xfs_alert_tag(
  64         const struct xfs_mount  *mp,
  65         int                     panic_tag,
  66         const char              *fmt, ...)
  67 {
  68         struct va_format        vaf;
  69         va_list                 args;
  70         int                     do_panic = 0;
  71 
  72         if (xfs_panic_mask && (xfs_panic_mask & panic_tag)) {
  73                 xfs_alert(mp, "Transforming an alert into a BUG.");
  74                 do_panic = 1;
  75         }
  76 
  77         va_start(args, fmt);
  78 
  79         vaf.fmt = fmt;
  80         vaf.va = &args;
  81 
  82         __xfs_printk(KERN_ALERT, mp, &vaf);
  83         va_end(args);
  84 
  85         BUG_ON(do_panic);
  86 }
  87 
  88 void
  89 asswarn(char *expr, char *file, int line)
  90 {
  91         xfs_warn(NULL, "Assertion failed: %s, file: %s, line: %d",
  92                 expr, file, line);
  93         WARN_ON(1);
  94 }
  95 
  96 void
  97 assfail(char *expr, char *file, int line)
  98 {
  99         xfs_emerg(NULL, "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(void *p, int length)
 109 {
 110         print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, p, length, 1);
 111 }