Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * dev_printk.h - printk messages helpers for devices
0004  *
0005  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
0006  * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
0007  * Copyright (c) 2008-2009 Novell Inc.
0008  *
0009  */
0010 
0011 #ifndef _DEVICE_PRINTK_H_
0012 #define _DEVICE_PRINTK_H_
0013 
0014 #include <linux/compiler.h>
0015 #include <linux/types.h>
0016 #include <linux/ratelimit.h>
0017 
0018 #ifndef dev_fmt
0019 #define dev_fmt(fmt) fmt
0020 #endif
0021 
0022 struct device;
0023 
0024 #define PRINTK_INFO_SUBSYSTEM_LEN   16
0025 #define PRINTK_INFO_DEVICE_LEN      48
0026 
0027 struct dev_printk_info {
0028     char subsystem[PRINTK_INFO_SUBSYSTEM_LEN];
0029     char device[PRINTK_INFO_DEVICE_LEN];
0030 };
0031 
0032 #ifdef CONFIG_PRINTK
0033 
0034 __printf(3, 0) __cold
0035 int dev_vprintk_emit(int level, const struct device *dev,
0036              const char *fmt, va_list args);
0037 __printf(3, 4) __cold
0038 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
0039 
0040 __printf(3, 4) __cold
0041 void _dev_printk(const char *level, const struct device *dev,
0042          const char *fmt, ...);
0043 __printf(2, 3) __cold
0044 void _dev_emerg(const struct device *dev, const char *fmt, ...);
0045 __printf(2, 3) __cold
0046 void _dev_alert(const struct device *dev, const char *fmt, ...);
0047 __printf(2, 3) __cold
0048 void _dev_crit(const struct device *dev, const char *fmt, ...);
0049 __printf(2, 3) __cold
0050 void _dev_err(const struct device *dev, const char *fmt, ...);
0051 __printf(2, 3) __cold
0052 void _dev_warn(const struct device *dev, const char *fmt, ...);
0053 __printf(2, 3) __cold
0054 void _dev_notice(const struct device *dev, const char *fmt, ...);
0055 __printf(2, 3) __cold
0056 void _dev_info(const struct device *dev, const char *fmt, ...);
0057 
0058 #else
0059 
0060 static inline __printf(3, 0)
0061 int dev_vprintk_emit(int level, const struct device *dev,
0062              const char *fmt, va_list args)
0063 { return 0; }
0064 static inline __printf(3, 4)
0065 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
0066 { return 0; }
0067 
0068 static inline void __dev_printk(const char *level, const struct device *dev,
0069                 struct va_format *vaf)
0070 {}
0071 static inline __printf(3, 4)
0072 void _dev_printk(const char *level, const struct device *dev,
0073          const char *fmt, ...)
0074 {}
0075 
0076 static inline __printf(2, 3)
0077 void _dev_emerg(const struct device *dev, const char *fmt, ...)
0078 {}
0079 static inline __printf(2, 3)
0080 void _dev_crit(const struct device *dev, const char *fmt, ...)
0081 {}
0082 static inline __printf(2, 3)
0083 void _dev_alert(const struct device *dev, const char *fmt, ...)
0084 {}
0085 static inline __printf(2, 3)
0086 void _dev_err(const struct device *dev, const char *fmt, ...)
0087 {}
0088 static inline __printf(2, 3)
0089 void _dev_warn(const struct device *dev, const char *fmt, ...)
0090 {}
0091 static inline __printf(2, 3)
0092 void _dev_notice(const struct device *dev, const char *fmt, ...)
0093 {}
0094 static inline __printf(2, 3)
0095 void _dev_info(const struct device *dev, const char *fmt, ...)
0096 {}
0097 
0098 #endif
0099 
0100 /*
0101  * Need to take variadic arguments even though we don't use them, as dev_fmt()
0102  * may only just have been expanded and may result in multiple arguments.
0103  */
0104 #define dev_printk_index_emit(level, fmt, ...) \
0105     printk_index_subsys_emit("%s %s: ", level, fmt)
0106 
0107 #define dev_printk_index_wrap(_p_func, level, dev, fmt, ...)        \
0108     ({                              \
0109         dev_printk_index_emit(level, fmt);          \
0110         _p_func(dev, fmt, ##__VA_ARGS__);           \
0111     })
0112 
0113 /*
0114  * Some callsites directly call dev_printk rather than going through the
0115  * dev_<level> infrastructure, so we need to emit here as well as inside those
0116  * level-specific macros. Only one index entry will be produced, either way,
0117  * since dev_printk's `fmt` isn't known at compile time if going through the
0118  * dev_<level> macros.
0119  *
0120  * dev_fmt() isn't called for dev_printk when used directly, as it's used by
0121  * the dev_<level> macros internally which already have dev_fmt() processed.
0122  *
0123  * We also can't use dev_printk_index_wrap directly, because we have a separate
0124  * level to process.
0125  */
0126 #define dev_printk(level, dev, fmt, ...)                \
0127     ({                              \
0128         dev_printk_index_emit(level, fmt);          \
0129         _dev_printk(level, dev, fmt, ##__VA_ARGS__);        \
0130     })
0131 
0132 /*
0133  * #defines for all the dev_<level> macros to prefix with whatever
0134  * possible use of #define dev_fmt(fmt) ...
0135  */
0136 
0137 #define dev_emerg(dev, fmt, ...) \
0138     dev_printk_index_wrap(_dev_emerg, KERN_EMERG, dev, dev_fmt(fmt), ##__VA_ARGS__)
0139 #define dev_crit(dev, fmt, ...) \
0140     dev_printk_index_wrap(_dev_crit, KERN_CRIT, dev, dev_fmt(fmt), ##__VA_ARGS__)
0141 #define dev_alert(dev, fmt, ...) \
0142     dev_printk_index_wrap(_dev_alert, KERN_ALERT, dev, dev_fmt(fmt), ##__VA_ARGS__)
0143 #define dev_err(dev, fmt, ...) \
0144     dev_printk_index_wrap(_dev_err, KERN_ERR, dev, dev_fmt(fmt), ##__VA_ARGS__)
0145 #define dev_warn(dev, fmt, ...) \
0146     dev_printk_index_wrap(_dev_warn, KERN_WARNING, dev, dev_fmt(fmt), ##__VA_ARGS__)
0147 #define dev_notice(dev, fmt, ...) \
0148     dev_printk_index_wrap(_dev_notice, KERN_NOTICE, dev, dev_fmt(fmt), ##__VA_ARGS__)
0149 #define dev_info(dev, fmt, ...) \
0150     dev_printk_index_wrap(_dev_info, KERN_INFO, dev, dev_fmt(fmt), ##__VA_ARGS__)
0151 
0152 #if defined(CONFIG_DYNAMIC_DEBUG) || \
0153     (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
0154 #define dev_dbg(dev, fmt, ...)                      \
0155     dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
0156 #elif defined(DEBUG)
0157 #define dev_dbg(dev, fmt, ...)                      \
0158     dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
0159 #else
0160 #define dev_dbg(dev, fmt, ...)                      \
0161 ({                                  \
0162     if (0)                              \
0163         dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
0164 })
0165 #endif
0166 
0167 #ifdef CONFIG_PRINTK
0168 #define dev_level_once(dev_level, dev, fmt, ...)            \
0169 do {                                    \
0170     static bool __print_once __read_mostly;             \
0171                                     \
0172     if (!__print_once) {                        \
0173         __print_once = true;                    \
0174         dev_level(dev, fmt, ##__VA_ARGS__);         \
0175     }                               \
0176 } while (0)
0177 #else
0178 #define dev_level_once(dev_level, dev, fmt, ...)            \
0179 do {                                    \
0180     if (0)                              \
0181         dev_level(dev, fmt, ##__VA_ARGS__);         \
0182 } while (0)
0183 #endif
0184 
0185 #define dev_emerg_once(dev, fmt, ...)                   \
0186     dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__)
0187 #define dev_alert_once(dev, fmt, ...)                   \
0188     dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__)
0189 #define dev_crit_once(dev, fmt, ...)                    \
0190     dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__)
0191 #define dev_err_once(dev, fmt, ...)                 \
0192     dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__)
0193 #define dev_warn_once(dev, fmt, ...)                    \
0194     dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__)
0195 #define dev_notice_once(dev, fmt, ...)                  \
0196     dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__)
0197 #define dev_info_once(dev, fmt, ...)                    \
0198     dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
0199 #define dev_dbg_once(dev, fmt, ...)                 \
0200     dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__)
0201 
0202 #define dev_level_ratelimited(dev_level, dev, fmt, ...)         \
0203 do {                                    \
0204     static DEFINE_RATELIMIT_STATE(_rs,              \
0205                       DEFAULT_RATELIMIT_INTERVAL,   \
0206                       DEFAULT_RATELIMIT_BURST);     \
0207     if (__ratelimit(&_rs))                      \
0208         dev_level(dev, fmt, ##__VA_ARGS__);         \
0209 } while (0)
0210 
0211 #define dev_emerg_ratelimited(dev, fmt, ...)                \
0212     dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
0213 #define dev_alert_ratelimited(dev, fmt, ...)                \
0214     dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
0215 #define dev_crit_ratelimited(dev, fmt, ...)             \
0216     dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
0217 #define dev_err_ratelimited(dev, fmt, ...)              \
0218     dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
0219 #define dev_warn_ratelimited(dev, fmt, ...)             \
0220     dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
0221 #define dev_notice_ratelimited(dev, fmt, ...)               \
0222     dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
0223 #define dev_info_ratelimited(dev, fmt, ...)             \
0224     dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
0225 #if defined(CONFIG_DYNAMIC_DEBUG) || \
0226     (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
0227 /* descriptor check is first to prevent flooding with "callbacks suppressed" */
0228 #define dev_dbg_ratelimited(dev, fmt, ...)              \
0229 do {                                    \
0230     static DEFINE_RATELIMIT_STATE(_rs,              \
0231                       DEFAULT_RATELIMIT_INTERVAL,   \
0232                       DEFAULT_RATELIMIT_BURST);     \
0233     DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
0234     if (DYNAMIC_DEBUG_BRANCH(descriptor) &&             \
0235         __ratelimit(&_rs))                      \
0236         __dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt),   \
0237                   ##__VA_ARGS__);           \
0238 } while (0)
0239 #elif defined(DEBUG)
0240 #define dev_dbg_ratelimited(dev, fmt, ...)              \
0241 do {                                    \
0242     static DEFINE_RATELIMIT_STATE(_rs,              \
0243                       DEFAULT_RATELIMIT_INTERVAL,   \
0244                       DEFAULT_RATELIMIT_BURST);     \
0245     if (__ratelimit(&_rs))                      \
0246         dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
0247 } while (0)
0248 #else
0249 #define dev_dbg_ratelimited(dev, fmt, ...)              \
0250 do {                                    \
0251     if (0)                              \
0252         dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
0253 } while (0)
0254 #endif
0255 
0256 #ifdef VERBOSE_DEBUG
0257 #define dev_vdbg    dev_dbg
0258 #else
0259 #define dev_vdbg(dev, fmt, ...)                     \
0260 ({                                  \
0261     if (0)                              \
0262         dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
0263 })
0264 #endif
0265 
0266 /*
0267  * dev_WARN*() acts like dev_printk(), but with the key difference of
0268  * using WARN/WARN_ONCE to include file/line information and a backtrace.
0269  */
0270 #define dev_WARN(dev, format, arg...) \
0271     WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg)
0272 
0273 #define dev_WARN_ONCE(dev, condition, format, arg...) \
0274     WARN_ONCE(condition, "%s %s: " format, \
0275             dev_driver_string(dev), dev_name(dev), ## arg)
0276 
0277 #endif /* _DEVICE_PRINTK_H_ */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!