Line data    Source code

       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      346178 : __xfs_printk(
      19             :         const char              *level,
      20             :         const struct xfs_mount  *mp,
      21             :         struct va_format        *vaf)
      22             : {
      23      346178 :         if (mp && mp->m_super) {
      24      346130 :                 printk("%sXFS (%s): %pV\n", level, mp->m_super->s_id, vaf);
      25      346130 :                 return;
      26             :         }
      27          50 :         printk("%sXFS: %pV\n", level, vaf);
      28             : }
      29             : 
      30             : void
      31      319998 : xfs_printk_level(
      32             :         const char *kern_level,
      33             :         const struct xfs_mount *mp,
      34             :         const char *fmt, ...)
      35             : {
      36      319998 :         struct va_format        vaf;
      37      319998 :         va_list                 args;
      38      319998 :         int                     level;
      39             : 
      40      319998 :         va_start(args, fmt);
      41      319998 :         vaf.fmt = fmt;
      42      319998 :         vaf.va = &args;
      43             : 
      44      319998 :         __xfs_printk(kern_level, mp, &vaf);
      45             : 
      46      319999 :         va_end(args);
      47             : 
      48      319999 :         if (!kstrtoint(kern_level, 0, &level) &&
      49           0 :             level <= LOGLEVEL_ERR &&
      50           0 :             xfs_error_level >= XFS_ERRLEVEL_HIGH)
      51           0 :                 xfs_stack_trace();
      52      319997 : }
      53             : 
      54             : void
      55       13024 : _xfs_alert_tag(
      56             :         const struct xfs_mount  *mp,
      57             :         uint32_t                panic_tag,
      58             :         const char              *fmt, ...)
      59             : {
      60       13024 :         struct va_format        vaf;
      61       13024 :         va_list                 args;
      62       13024 :         int                     do_panic = 0;
      63             : 
      64       13024 :         if (xfs_panic_mask && (xfs_panic_mask & panic_tag)) {
      65           0 :                 xfs_alert(mp, "Transforming an alert into a BUG.");
      66           0 :                 do_panic = 1;
      67             :         }
      68             : 
      69       13024 :         va_start(args, fmt);
      70             : 
      71       13024 :         vaf.fmt = fmt;
      72       13024 :         vaf.va = &args;
      73             : 
      74       13024 :         __xfs_printk(KERN_ALERT, mp, &vaf);
      75       13024 :         va_end(args);
      76             : 
      77       13024 :         BUG_ON(do_panic);
      78       13024 : }
      79             : 
      80             : void
      81           0 : asswarn(
      82             :         struct xfs_mount        *mp,
      83             :         char                    *expr,
      84             :         char                    *file,
      85             :         int                     line)
      86             : {
      87           0 :         xfs_warn(mp, "Assertion failed: %s, file: %s, line: %d",
      88             :                 expr, file, line);
      89           0 :         WARN_ON(1);
      90           0 : }
      91             : 
      92             : void
      93           9 : assfail(
      94             :         struct xfs_mount        *mp,
      95             :         char                    *expr,
      96             :         char                    *file,
      97             :         int                     line)
      98             : {
      99           9 :         xfs_emerg(mp, "Assertion failed: %s, file: %s, line: %d",
     100             :                 expr, file, line);
     101           9 :         if (xfs_globals.bug_on_assert)
     102           0 :                 BUG();
     103             :         else
     104           9 :                 WARN_ON(1);
     105           9 : }
     106             : 
     107             : void
     108        1303 : xfs_hex_dump(const void *p, int length)
     109             : {
     110        1303 :         print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, p, length, 1);
     111        1303 : }
     112             : 
     113             : void
     114       24560 : xfs_buf_alert_ratelimited(
     115             :         struct xfs_buf          *bp,
     116             :         const char              *rlmsg,
     117             :         const char              *fmt,
     118             :         ...)
     119             : {
     120       24560 :         struct xfs_mount        *mp = bp->b_mount;
     121       24560 :         struct va_format        vaf;
     122       24560 :         va_list                 args;
     123             : 
     124             :         /* use the more aggressive per-target rate limit for buffers */
     125       24560 :         if (!___ratelimit(&bp->b_target->bt_ioerror_rl, rlmsg))
     126       11411 :                 return;
     127             : 
     128       13159 :         va_start(args, fmt);
     129       13159 :         vaf.fmt = fmt;
     130       13159 :         vaf.va = &args;
     131       13159 :         __xfs_printk(KERN_ALERT, mp, &vaf);
     132       13159 :         va_end(args);
     133             : }