[PATCH 0/6] treewide: Add and use dev_fmt similar to pr_fmt

[PATCH 0/6] treewide: Add and use dev_fmt similar to pr_fmt

[Joe Perches]

The pr_fmt mechanism exists for pr_<level> logging message prefixing,
but no similar capability exists for dev_<level> message prefixing.

Many uses of dev_<level> have an embedded prefix for logging output.

So add a similar dev_fmt macro that can automatically prefix the
dev_<level> logging output.

Rename the existing dev_<level> functions to _dev_<level> and add new
macros that call _dev_<level> with the desired prefix if defined.

The new default #define for dev_fmt is blank.

Convert ipmi and infiniband to use this mechanism.

Miscellanea:

o x86/early-quirks uses an internal macro for #define dev_err which conflicts
 with the existing dev_err macro, so rename it.

Joe Perches (6):
  x86/early-quirks: Rename duplicate define of dev_err
  device: Add #define dev_fmt similar to #define pr_fmt
  ipmi: msghandler: Add and use pr_fmt and dev_fmt, remove PFX
  ipmi: Use more common logging styles
  ipmi: Convert printk(KERN_<level> to pr_<level>(
  infiniband: qplib_fp: Use dev_fmt

 arch/x86/kernel/early-quirks.c           |   8 +-
 drivers/base/core.c                      |  12 +--
 drivers/char/ipmi/ipmi_bt_sm.c           |  64 ++++++++--------
 drivers/char/ipmi/ipmi_devintf.c         |  11 ++-
 drivers/char/ipmi/ipmi_kcs_sm.c          |   4 +-
 drivers/char/ipmi/ipmi_msghandler.c      |  53 +++++++------
 drivers/char/ipmi/ipmi_poweroff.c        |  67 ++++++++---------
 drivers/char/ipmi/ipmi_si_hardcode.c     |   9 ++-
 drivers/char/ipmi/ipmi_si_hotmod.c       |  17 +++--
 drivers/char/ipmi/ipmi_si_intf.c         |  22 +++---
 drivers/char/ipmi/ipmi_si_pci.c          |  12 +--
 drivers/char/ipmi/ipmi_si_platform.c     |  20 ++---
 drivers/char/ipmi/ipmi_smic_sm.c         |  26 +++----
 drivers/char/ipmi/ipmi_ssif.c            |  73 +++++++++---------
 drivers/char/ipmi/ipmi_watchdog.c        |  52 +++++++------
 drivers/infiniband/hw/bnxt_re/qplib_fp.c | 125 ++++++++++++++-----------------
 include/linux/device.h                   | 103 ++++++++++++++-----------
 17 files changed, 330 insertions(+), 348 deletions(-)

-- 
2.15.0

[PATCH 1/6] x86/early-quirks: Rename duplicate define of dev_err

[Joe Perches]

dev_err is becoming a macro calling _dev_err to allow prefixing of
dev_fmt to any dev_<level> use that has a #define dev_fmt(fmt) similar
to the existing #define pr_fmt(fmt) uses.

Remove this dev_err macro and convert the existing two uses to pr_err.
This allows clean compilation in the patch that introduces dev_fmt which
can prefix dev_<level> logging macros with arbitrary content similar to
the #define pr_fmt macro.

Signed-off-by: Joe Perches <joe@perches.com>
---
 arch/x86/kernel/early-quirks.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
index bae0d32e327b..da5d8ac60062 100644
--- a/arch/x86/kernel/early-quirks.c
+++ b/arch/x86/kernel/early-quirks.c
@@ -28,8 +28,6 @@
 #include <asm/irq_remapping.h>
 #include <asm/early_ioremap.h>
 
-#define dev_err(msg)  pr_err("pci 0000:%02x:%02x.%d: %s", bus, slot, func, msg)
-
 static void __init fix_hypertransport_config(int num, int slot, int func)
 {
 	u32 htcfg;
@@ -617,7 +615,8 @@ static void __init apple_airport_reset(int bus, int slot, int func)
 
 		pmcsr = read_pci_config_16(bus, slot, func, BCM4331_PM_CAP + PCI_PM_CTRL);
 		if ((pmcsr & PCI_PM_CTRL_STATE_MASK) != PCI_D0) {
-			dev_err("Cannot power up Apple AirPort card\n");
+			pr_err("pci 0000:%02x:%02x.%d: Cannot power up Apple AirPort card\n",
+			       bus, slot, func);
 			return;
 		}
 	}
@@ -628,7 +627,8 @@ static void __init apple_airport_reset(int bus, int slot, int func)
 
 	mmio = early_ioremap(addr, BCM4331_MMIO_SIZE);
 	if (!mmio) {
-		dev_err("Cannot iomap Apple AirPort card\n");
+		pr_err("pci 0000:%02x:%02x.%d: Cannot iomap Apple AirPort card\n",
+		       bus, slot, func);
 		return;
 	}
 
-- 
2.15.0

Re: [PATCH 1/6] x86/early-quirks: Rename duplicate define of dev_err

[Thomas Gleixner]

On Wed, 9 May 2018, Joe Perches wrote:

> dev_err is becoming a macro calling _dev_err to allow prefixing of
> dev_fmt to any dev_<level> use that has a #define dev_fmt(fmt) similar
> to the existing #define pr_fmt(fmt) uses.
> 
> Remove this dev_err macro and convert the existing two uses to pr_err.
> This allows clean compilation in the patch that introduces dev_fmt which
> can prefix dev_<level> logging macros with arbitrary content similar to
> the #define pr_fmt macro.
> 
> Signed-off-by: Joe Perches <joe@perches.com>

I assume you want to take them as block, so:

Reviewed-by: Thomas Gleixner <tglx@linutronix.de>

Re: [PATCH 1/6] x86/early-quirks: Rename duplicate define of dev_err

[Joe Perches]

On Sun, 2018-05-13 at 15:03 +0200, Thomas Gleixner wrote:
> On Wed, 9 May 2018, Joe Perches wrote:
> 
> > dev_err is becoming a macro calling _dev_err to allow prefixing of
> > dev_fmt to any dev_<level> use that has a #define dev_fmt(fmt) similar
> > to the existing #define pr_fmt(fmt) uses.
> > 
> > Remove this dev_err macro and convert the existing two uses to pr_err.
> > This allows clean compilation in the patch that introduces dev_fmt which
> > can prefix dev_<level> logging macros with arbitrary content similar to
> > the #define pr_fmt macro.
> > 
> > Signed-off-by: Joe Perches <joe@perches.com>
> 
> I assume you want to take them as block, so:
> 
> Reviewed-by: Thomas Gleixner <tglx@linutronix.de>

I do not have a tree that Linus pulls.

I think it'd be fine if you apply this one as it's a
simple rename deduplication.

Corey Minyard has already taken the ipmi changes
separately.

Patch 2/6 could go separately, probably via Greg KH's
tree, after this 1/6 change is in the tree.

[tip:x86/cleanups] x86/early-quirks: Rename duplicate define of dev_err

[tip-bot for Joe Perches]

Commit-ID:  a7a3153a98d581196ce092e0b83cac2c4ee1fd1f
Gitweb:     https://git.kernel.org/tip/a7a3153a98d581196ce092e0b83cac2c4ee1fd1f
Author:     Joe Perches <joe@perches.com>
AuthorDate: Wed, 9 May 2018 08:15:45 -0700
Committer:  Thomas Gleixner <tglx@linutronix.de>
CommitDate: Sun, 13 May 2018 20:04:35 +0200

x86/early-quirks: Rename duplicate define of dev_err

dev_err is becoming a macro calling _dev_err to allow prefixing of
dev_fmt to any dev_<level> use that has a #define dev_fmt(fmt) similar
to the existing #define pr_fmt(fmt) uses.

Remove this dev_err macro and convert the existing two uses to pr_err.
This allows clean compilation in the patch that introduces dev_fmt which
can prefix dev_<level> logging macros with arbitrary content similar to
the #define pr_fmt macro.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Link: https://lkml.kernel.org/r/8fb4b2a77d50e21ae1f7e4e267e68691efe2c270.1525878372.git.joe@perches.com

---
 arch/x86/kernel/early-quirks.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
index bae0d32e327b..da5d8ac60062 100644
--- a/arch/x86/kernel/early-quirks.c
+++ b/arch/x86/kernel/early-quirks.c
@@ -28,8 +28,6 @@
 #include <asm/irq_remapping.h>
 #include <asm/early_ioremap.h>
 
-#define dev_err(msg)  pr_err("pci 0000:%02x:%02x.%d: %s", bus, slot, func, msg)
-
 static void __init fix_hypertransport_config(int num, int slot, int func)
 {
 	u32 htcfg;
@@ -617,7 +615,8 @@ static void __init apple_airport_reset(int bus, int slot, int func)
 
 		pmcsr = read_pci_config_16(bus, slot, func, BCM4331_PM_CAP + PCI_PM_CTRL);
 		if ((pmcsr & PCI_PM_CTRL_STATE_MASK) != PCI_D0) {
-			dev_err("Cannot power up Apple AirPort card\n");
+			pr_err("pci 0000:%02x:%02x.%d: Cannot power up Apple AirPort card\n",
+			       bus, slot, func);
 			return;
 		}
 	}
@@ -628,7 +627,8 @@ static void __init apple_airport_reset(int bus, int slot, int func)
 
 	mmio = early_ioremap(addr, BCM4331_MMIO_SIZE);
 	if (!mmio) {
-		dev_err("Cannot iomap Apple AirPort card\n");
+		pr_err("pci 0000:%02x:%02x.%d: Cannot iomap Apple AirPort card\n",
+		       bus, slot, func);
 		return;
 	}
 

[PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Joe Perches]

Add a prefixing macro to dev_<level> uses similar to the pr_fmt
prefixing macro used in pr_<level> calls.

This can help avoid some string duplication in dev_<level> uses.

The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt

Rename the existing dev_<level> functions to _dev_<level> and
introduce #define dev_<level> _dev_<level> macros that use the
new #define dev_fmt

Miscellanea:

o Consistently use #defines with fmt, ... and ##__VA_ARGS__
o Remove unnecessary externs

Signed-off-by: Joe Perches <joe@perches.com>
---
 drivers/base/core.c    |  12 +++---
 include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
 2 files changed, 64 insertions(+), 51 deletions(-)

diff --git a/drivers/base/core.c b/drivers/base/core.c
index ad7b50897bcc..9c87a41cef82 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -2985,12 +2985,12 @@ void func(const struct device *dev, const char *fmt, ...)	\
 }								\
 EXPORT_SYMBOL(func);
 
-define_dev_printk_level(dev_emerg, KERN_EMERG);
-define_dev_printk_level(dev_alert, KERN_ALERT);
-define_dev_printk_level(dev_crit, KERN_CRIT);
-define_dev_printk_level(dev_err, KERN_ERR);
-define_dev_printk_level(dev_warn, KERN_WARNING);
-define_dev_printk_level(dev_notice, KERN_NOTICE);
+define_dev_printk_level(_dev_emerg, KERN_EMERG);
+define_dev_printk_level(_dev_alert, KERN_ALERT);
+define_dev_printk_level(_dev_crit, KERN_CRIT);
+define_dev_printk_level(_dev_err, KERN_ERR);
+define_dev_printk_level(_dev_warn, KERN_WARNING);
+define_dev_printk_level(_dev_notice, KERN_NOTICE);
 define_dev_printk_level(_dev_info, KERN_INFO);
 
 #endif
diff --git a/include/linux/device.h b/include/linux/device.h
index 563077d1cdc1..49c6b5d6a9f8 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -1306,30 +1306,34 @@ struct device_link *device_link_add(struct device *consumer,
 				    struct device *supplier, u32 flags);
 void device_link_del(struct device_link *link);
 
+#ifndef dev_fmt
+#define dev_fmt(fmt) fmt
+#endif
+
 #ifdef CONFIG_PRINTK
 
-extern __printf(3, 0)
+__printf(3, 0)
 int dev_vprintk_emit(int level, const struct device *dev,
 		     const char *fmt, va_list args);
-extern __printf(3, 4)
+__printf(3, 4)
 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
 
-extern __printf(3, 4)
+__printf(3, 4)
 void dev_printk(const char *level, const struct device *dev,
 		const char *fmt, ...);
-extern __printf(2, 3)
-void dev_emerg(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_alert(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_crit(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_err(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_warn(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_notice(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
+__printf(2, 3)
+void _dev_emerg(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_alert(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_crit(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_err(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_warn(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_notice(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
 void _dev_info(const struct device *dev, const char *fmt, ...);
 
 #else
@@ -1347,26 +1351,26 @@ static inline void __dev_printk(const char *level, const struct device *dev,
 {}
 static inline __printf(3, 4)
 void dev_printk(const char *level, const struct device *dev,
-		const char *fmt, ...)
+		 const char *fmt, ...)
 {}
 
 static inline __printf(2, 3)
-void dev_emerg(const struct device *dev, const char *fmt, ...)
+void _dev_emerg(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_crit(const struct device *dev, const char *fmt, ...)
+void _dev_crit(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_alert(const struct device *dev, const char *fmt, ...)
+void _dev_alert(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_err(const struct device *dev, const char *fmt, ...)
+void _dev_err(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_warn(const struct device *dev, const char *fmt, ...)
+void _dev_warn(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_notice(const struct device *dev, const char *fmt, ...)
+void _dev_notice(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
 void _dev_info(const struct device *dev, const char *fmt, ...)
@@ -1375,27 +1379,36 @@ void _dev_info(const struct device *dev, const char *fmt, ...)
 #endif
 
 /*
- * Stupid hackaround for existing uses of non-printk uses dev_info
- *
- * Note that the definition of dev_info below is actually _dev_info
- * and a macro is used to avoid redefining dev_info
+ * #defines for all the dev_<level> macros to prefix with whatever
+ * possible use of #define dev_fmt(fmt) ...
  */
 
-#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
+#define dev_emerg(dev, fmt, ...)					\
+	_dev_emerg(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_crit(dev, fmt, ...)						\
+	_dev_crit(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_alert(dev, fmt, ...)					\
+	_dev_alert(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_err(dev, fmt, ...)						\
+	_dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_warn(dev, fmt, ...)						\
+	_dev_warn(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_notice(dev, fmt, ...)					\
+	_dev_notice(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_info(dev, fmt, ...)						\
+	_dev_info(dev, dev_fmt(fmt), ##__VA_ARGS__)
 
 #if defined(CONFIG_DYNAMIC_DEBUG)
-#define dev_dbg(dev, format, ...)		     \
-do {						     \
-	dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
-} while (0)
+#define dev_dbg(dev, fmt, ...)						\
+	dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
 #elif defined(DEBUG)
-#define dev_dbg(dev, format, arg...)		\
-	dev_printk(KERN_DEBUG, dev, format, ##arg)
+#define dev_dbg(dev, fmt, ...)						\
+	dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
 #else
-#define dev_dbg(dev, format, arg...)				\
-({								\
-	if (0)							\
-		dev_printk(KERN_DEBUG, dev, format, ##arg);	\
+#define dev_dbg(dev, fmt, ...)						\
+({									\
+	if (0)								\
+		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 })
 #endif
 
@@ -1467,7 +1480,7 @@ do {									\
 	DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);			\
 	if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) &&	\
 	    __ratelimit(&_rs))						\
-		__dynamic_dev_dbg(&descriptor, dev, fmt,		\
+		__dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt),	\
 				  ##__VA_ARGS__);			\
 } while (0)
 #elif defined(DEBUG)
@@ -1477,23 +1490,23 @@ do {									\
 				      DEFAULT_RATELIMIT_INTERVAL,	\
 				      DEFAULT_RATELIMIT_BURST);		\
 	if (__ratelimit(&_rs))						\
-		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
+		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 } while (0)
 #else
 #define dev_dbg_ratelimited(dev, fmt, ...)				\
 do {									\
 	if (0)								\
-		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
+		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 } while (0)
 #endif
 
 #ifdef VERBOSE_DEBUG
 #define dev_vdbg	dev_dbg
 #else
-#define dev_vdbg(dev, format, arg...)				\
-({								\
-	if (0)							\
-		dev_printk(KERN_DEBUG, dev, format, ##arg);	\
+#define dev_vdbg(dev, fmt, ...)						\
+({									\
+	if (0)								\
+		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 })
 #endif
 
-- 
2.15.0

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Joe Perches]

Greg?  Ping?

The patches to impi have hit -next and the impi code
works differently without this patch.


On Wed, 2018-05-09 at 08:15 -0700, Joe Perches wrote:
> Add a prefixing macro to dev_<level> uses similar to the pr_fmt
> prefixing macro used in pr_<level> calls.
> 
> This can help avoid some string duplication in dev_<level> uses.
> 
> The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
> 
> Rename the existing dev_<level> functions to _dev_<level> and
> introduce #define dev_<level> _dev_<level> macros that use the
> new #define dev_fmt
> 
> Miscellanea:
> 
> o Consistently use #defines with fmt, ... and ##__VA_ARGS__
> o Remove unnecessary externs
> 
> Signed-off-by: Joe Perches <joe@perches.com>
> ---
>  drivers/base/core.c    |  12 +++---
>  include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
>  2 files changed, 64 insertions(+), 51 deletions(-)
> 
> diff --git a/drivers/base/core.c b/drivers/base/core.c
> index ad7b50897bcc..9c87a41cef82 100644
> --- a/drivers/base/core.c
> +++ b/drivers/base/core.c
> @@ -2985,12 +2985,12 @@ void func(const struct device *dev, const char *fmt, ...)	\
>  }								\
>  EXPORT_SYMBOL(func);
>  
> -define_dev_printk_level(dev_emerg, KERN_EMERG);
> -define_dev_printk_level(dev_alert, KERN_ALERT);
> -define_dev_printk_level(dev_crit, KERN_CRIT);
> -define_dev_printk_level(dev_err, KERN_ERR);
> -define_dev_printk_level(dev_warn, KERN_WARNING);
> -define_dev_printk_level(dev_notice, KERN_NOTICE);
> +define_dev_printk_level(_dev_emerg, KERN_EMERG);
> +define_dev_printk_level(_dev_alert, KERN_ALERT);
> +define_dev_printk_level(_dev_crit, KERN_CRIT);
> +define_dev_printk_level(_dev_err, KERN_ERR);
> +define_dev_printk_level(_dev_warn, KERN_WARNING);
> +define_dev_printk_level(_dev_notice, KERN_NOTICE);
>  define_dev_printk_level(_dev_info, KERN_INFO);
>  
>  #endif
> diff --git a/include/linux/device.h b/include/linux/device.h
> index 563077d1cdc1..49c6b5d6a9f8 100644
> --- a/include/linux/device.h
> +++ b/include/linux/device.h
> @@ -1306,30 +1306,34 @@ struct device_link *device_link_add(struct device *consumer,
>  				    struct device *supplier, u32 flags);
>  void device_link_del(struct device_link *link);
>  
> +#ifndef dev_fmt
> +#define dev_fmt(fmt) fmt
> +#endif
> +
>  #ifdef CONFIG_PRINTK
>  
> -extern __printf(3, 0)
> +__printf(3, 0)
>  int dev_vprintk_emit(int level, const struct device *dev,
>  		     const char *fmt, va_list args);
> -extern __printf(3, 4)
> +__printf(3, 4)
>  int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
>  
> -extern __printf(3, 4)
> +__printf(3, 4)
>  void dev_printk(const char *level, const struct device *dev,
>  		const char *fmt, ...);
> -extern __printf(2, 3)
> -void dev_emerg(const struct device *dev, const char *fmt, ...);
> -extern __printf(2, 3)
> -void dev_alert(const struct device *dev, const char *fmt, ...);
> -extern __printf(2, 3)
> -void dev_crit(const struct device *dev, const char *fmt, ...);
> -extern __printf(2, 3)
> -void dev_err(const struct device *dev, const char *fmt, ...);
> -extern __printf(2, 3)
> -void dev_warn(const struct device *dev, const char *fmt, ...);
> -extern __printf(2, 3)
> -void dev_notice(const struct device *dev, const char *fmt, ...);
> -extern __printf(2, 3)
> +__printf(2, 3)
> +void _dev_emerg(const struct device *dev, const char *fmt, ...);
> +__printf(2, 3)
> +void _dev_alert(const struct device *dev, const char *fmt, ...);
> +__printf(2, 3)
> +void _dev_crit(const struct device *dev, const char *fmt, ...);
> +__printf(2, 3)
> +void _dev_err(const struct device *dev, const char *fmt, ...);
> +__printf(2, 3)
> +void _dev_warn(const struct device *dev, const char *fmt, ...);
> +__printf(2, 3)
> +void _dev_notice(const struct device *dev, const char *fmt, ...);
> +__printf(2, 3)
>  void _dev_info(const struct device *dev, const char *fmt, ...);
>  
>  #else
> @@ -1347,26 +1351,26 @@ static inline void __dev_printk(const char *level, const struct device *dev,
>  {}
>  static inline __printf(3, 4)
>  void dev_printk(const char *level, const struct device *dev,
> -		const char *fmt, ...)
> +		 const char *fmt, ...)
>  {}
>  
>  static inline __printf(2, 3)
> -void dev_emerg(const struct device *dev, const char *fmt, ...)
> +void _dev_emerg(const struct device *dev, const char *fmt, ...)
>  {}
>  static inline __printf(2, 3)
> -void dev_crit(const struct device *dev, const char *fmt, ...)
> +void _dev_crit(const struct device *dev, const char *fmt, ...)
>  {}
>  static inline __printf(2, 3)
> -void dev_alert(const struct device *dev, const char *fmt, ...)
> +void _dev_alert(const struct device *dev, const char *fmt, ...)
>  {}
>  static inline __printf(2, 3)
> -void dev_err(const struct device *dev, const char *fmt, ...)
> +void _dev_err(const struct device *dev, const char *fmt, ...)
>  {}
>  static inline __printf(2, 3)
> -void dev_warn(const struct device *dev, const char *fmt, ...)
> +void _dev_warn(const struct device *dev, const char *fmt, ...)
>  {}
>  static inline __printf(2, 3)
> -void dev_notice(const struct device *dev, const char *fmt, ...)
> +void _dev_notice(const struct device *dev, const char *fmt, ...)
>  {}
>  static inline __printf(2, 3)
>  void _dev_info(const struct device *dev, const char *fmt, ...)
> @@ -1375,27 +1379,36 @@ void _dev_info(const struct device *dev, const char *fmt, ...)
>  #endif
>  
>  /*
> - * Stupid hackaround for existing uses of non-printk uses dev_info
> - *
> - * Note that the definition of dev_info below is actually _dev_info
> - * and a macro is used to avoid redefining dev_info
> + * #defines for all the dev_<level> macros to prefix with whatever
> + * possible use of #define dev_fmt(fmt) ...
>   */
>  
> -#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
> +#define dev_emerg(dev, fmt, ...)					\
> +	_dev_emerg(dev, dev_fmt(fmt), ##__VA_ARGS__)
> +#define dev_crit(dev, fmt, ...)						\
> +	_dev_crit(dev, dev_fmt(fmt), ##__VA_ARGS__)
> +#define dev_alert(dev, fmt, ...)					\
> +	_dev_alert(dev, dev_fmt(fmt), ##__VA_ARGS__)
> +#define dev_err(dev, fmt, ...)						\
> +	_dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
> +#define dev_warn(dev, fmt, ...)						\
> +	_dev_warn(dev, dev_fmt(fmt), ##__VA_ARGS__)
> +#define dev_notice(dev, fmt, ...)					\
> +	_dev_notice(dev, dev_fmt(fmt), ##__VA_ARGS__)
> +#define dev_info(dev, fmt, ...)						\
> +	_dev_info(dev, dev_fmt(fmt), ##__VA_ARGS__)
>  
>  #if defined(CONFIG_DYNAMIC_DEBUG)
> -#define dev_dbg(dev, format, ...)		     \
> -do {						     \
> -	dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
> -} while (0)
> +#define dev_dbg(dev, fmt, ...)						\
> +	dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
>  #elif defined(DEBUG)
> -#define dev_dbg(dev, format, arg...)		\
> -	dev_printk(KERN_DEBUG, dev, format, ##arg)
> +#define dev_dbg(dev, fmt, ...)						\
> +	dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
>  #else
> -#define dev_dbg(dev, format, arg...)				\
> -({								\
> -	if (0)							\
> -		dev_printk(KERN_DEBUG, dev, format, ##arg);	\
> +#define dev_dbg(dev, fmt, ...)						\
> +({									\
> +	if (0)								\
> +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
>  })
>  #endif
>  
> @@ -1467,7 +1480,7 @@ do {									\
>  	DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);			\
>  	if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) &&	\
>  	    __ratelimit(&_rs))						\
> -		__dynamic_dev_dbg(&descriptor, dev, fmt,		\
> +		__dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt),	\
>  				  ##__VA_ARGS__);			\
>  } while (0)
>  #elif defined(DEBUG)
> @@ -1477,23 +1490,23 @@ do {									\
>  				      DEFAULT_RATELIMIT_INTERVAL,	\
>  				      DEFAULT_RATELIMIT_BURST);		\
>  	if (__ratelimit(&_rs))						\
> -		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
> +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
>  } while (0)
>  #else
>  #define dev_dbg_ratelimited(dev, fmt, ...)				\
>  do {									\
>  	if (0)								\
> -		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
> +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
>  } while (0)
>  #endif
>  
>  #ifdef VERBOSE_DEBUG
>  #define dev_vdbg	dev_dbg
>  #else
> -#define dev_vdbg(dev, format, arg...)				\
> -({								\
> -	if (0)							\
> -		dev_printk(KERN_DEBUG, dev, format, ##arg);	\
> +#define dev_vdbg(dev, fmt, ...)						\
> +({									\
> +	if (0)								\
> +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
>  })
>  #endif
>  

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Joe Perches]

On Tue, 2018-06-19 at 06:31 -0700, Joe Perches wrote:
> Greg?  Ping?
> 
> The patches to impi have hit -next and the impi code
> works differently without this patch.

Greg?

You are listed as the maintainer for this subsystem.
Do you want me to  get this applied via someone else?

> 
> On Wed, 2018-05-09 at 08:15 -0700, Joe Perches wrote:
> > Add a prefixing macro to dev_<level> uses similar to the pr_fmt
> > prefixing macro used in pr_<level> calls.
> > 
> > This can help avoid some string duplication in dev_<level> uses.
> > 
> > The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
> > 
> > Rename the existing dev_<level> functions to _dev_<level> and
> > introduce #define dev_<level> _dev_<level> macros that use the
> > new #define dev_fmt
> > 
> > Miscellanea:
> > 
> > o Consistently use #defines with fmt, ... and ##__VA_ARGS__
> > o Remove unnecessary externs
> > 
> > Signed-off-by: Joe Perches <joe@perches.com>
> > ---
> >  drivers/base/core.c    |  12 +++---
> >  include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
> >  2 files changed, 64 insertions(+), 51 deletions(-)
> > 
> > diff --git a/drivers/base/core.c b/drivers/base/core.c
> > index ad7b50897bcc..9c87a41cef82 100644
> > --- a/drivers/base/core.c
> > +++ b/drivers/base/core.c
> > @@ -2985,12 +2985,12 @@ void func(const struct device *dev, const char *fmt, ...)	\
> >  }								\
> >  EXPORT_SYMBOL(func);
> >  
> > -define_dev_printk_level(dev_emerg, KERN_EMERG);
> > -define_dev_printk_level(dev_alert, KERN_ALERT);
> > -define_dev_printk_level(dev_crit, KERN_CRIT);
> > -define_dev_printk_level(dev_err, KERN_ERR);
> > -define_dev_printk_level(dev_warn, KERN_WARNING);
> > -define_dev_printk_level(dev_notice, KERN_NOTICE);
> > +define_dev_printk_level(_dev_emerg, KERN_EMERG);
> > +define_dev_printk_level(_dev_alert, KERN_ALERT);
> > +define_dev_printk_level(_dev_crit, KERN_CRIT);
> > +define_dev_printk_level(_dev_err, KERN_ERR);
> > +define_dev_printk_level(_dev_warn, KERN_WARNING);
> > +define_dev_printk_level(_dev_notice, KERN_NOTICE);
> >  define_dev_printk_level(_dev_info, KERN_INFO);
> >  
> >  #endif
> > diff --git a/include/linux/device.h b/include/linux/device.h
> > index 563077d1cdc1..49c6b5d6a9f8 100644
> > --- a/include/linux/device.h
> > +++ b/include/linux/device.h
> > @@ -1306,30 +1306,34 @@ struct device_link *device_link_add(struct device *consumer,
> >  				    struct device *supplier, u32 flags);
> >  void device_link_del(struct device_link *link);
> >  
> > +#ifndef dev_fmt
> > +#define dev_fmt(fmt) fmt
> > +#endif
> > +
> >  #ifdef CONFIG_PRINTK
> >  
> > -extern __printf(3, 0)
> > +__printf(3, 0)
> >  int dev_vprintk_emit(int level, const struct device *dev,
> >  		     const char *fmt, va_list args);
> > -extern __printf(3, 4)
> > +__printf(3, 4)
> >  int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
> >  
> > -extern __printf(3, 4)
> > +__printf(3, 4)
> >  void dev_printk(const char *level, const struct device *dev,
> >  		const char *fmt, ...);
> > -extern __printf(2, 3)
> > -void dev_emerg(const struct device *dev, const char *fmt, ...);
> > -extern __printf(2, 3)
> > -void dev_alert(const struct device *dev, const char *fmt, ...);
> > -extern __printf(2, 3)
> > -void dev_crit(const struct device *dev, const char *fmt, ...);
> > -extern __printf(2, 3)
> > -void dev_err(const struct device *dev, const char *fmt, ...);
> > -extern __printf(2, 3)
> > -void dev_warn(const struct device *dev, const char *fmt, ...);
> > -extern __printf(2, 3)
> > -void dev_notice(const struct device *dev, const char *fmt, ...);
> > -extern __printf(2, 3)
> > +__printf(2, 3)
> > +void _dev_emerg(const struct device *dev, const char *fmt, ...);
> > +__printf(2, 3)
> > +void _dev_alert(const struct device *dev, const char *fmt, ...);
> > +__printf(2, 3)
> > +void _dev_crit(const struct device *dev, const char *fmt, ...);
> > +__printf(2, 3)
> > +void _dev_err(const struct device *dev, const char *fmt, ...);
> > +__printf(2, 3)
> > +void _dev_warn(const struct device *dev, const char *fmt, ...);
> > +__printf(2, 3)
> > +void _dev_notice(const struct device *dev, const char *fmt, ...);
> > +__printf(2, 3)
> >  void _dev_info(const struct device *dev, const char *fmt, ...);
> >  
> >  #else
> > @@ -1347,26 +1351,26 @@ static inline void __dev_printk(const char *level, const struct device *dev,
> >  {}
> >  static inline __printf(3, 4)
> >  void dev_printk(const char *level, const struct device *dev,
> > -		const char *fmt, ...)
> > +		 const char *fmt, ...)
> >  {}
> >  
> >  static inline __printf(2, 3)
> > -void dev_emerg(const struct device *dev, const char *fmt, ...)
> > +void _dev_emerg(const struct device *dev, const char *fmt, ...)
> >  {}
> >  static inline __printf(2, 3)
> > -void dev_crit(const struct device *dev, const char *fmt, ...)
> > +void _dev_crit(const struct device *dev, const char *fmt, ...)
> >  {}
> >  static inline __printf(2, 3)
> > -void dev_alert(const struct device *dev, const char *fmt, ...)
> > +void _dev_alert(const struct device *dev, const char *fmt, ...)
> >  {}
> >  static inline __printf(2, 3)
> > -void dev_err(const struct device *dev, const char *fmt, ...)
> > +void _dev_err(const struct device *dev, const char *fmt, ...)
> >  {}
> >  static inline __printf(2, 3)
> > -void dev_warn(const struct device *dev, const char *fmt, ...)
> > +void _dev_warn(const struct device *dev, const char *fmt, ...)
> >  {}
> >  static inline __printf(2, 3)
> > -void dev_notice(const struct device *dev, const char *fmt, ...)
> > +void _dev_notice(const struct device *dev, const char *fmt, ...)
> >  {}
> >  static inline __printf(2, 3)
> >  void _dev_info(const struct device *dev, const char *fmt, ...)
> > @@ -1375,27 +1379,36 @@ void _dev_info(const struct device *dev, const char *fmt, ...)
> >  #endif
> >  
> >  /*
> > - * Stupid hackaround for existing uses of non-printk uses dev_info
> > - *
> > - * Note that the definition of dev_info below is actually _dev_info
> > - * and a macro is used to avoid redefining dev_info
> > + * #defines for all the dev_<level> macros to prefix with whatever
> > + * possible use of #define dev_fmt(fmt) ...
> >   */
> >  
> > -#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
> > +#define dev_emerg(dev, fmt, ...)					\
> > +	_dev_emerg(dev, dev_fmt(fmt), ##__VA_ARGS__)
> > +#define dev_crit(dev, fmt, ...)						\
> > +	_dev_crit(dev, dev_fmt(fmt), ##__VA_ARGS__)
> > +#define dev_alert(dev, fmt, ...)					\
> > +	_dev_alert(dev, dev_fmt(fmt), ##__VA_ARGS__)
> > +#define dev_err(dev, fmt, ...)						\
> > +	_dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
> > +#define dev_warn(dev, fmt, ...)						\
> > +	_dev_warn(dev, dev_fmt(fmt), ##__VA_ARGS__)
> > +#define dev_notice(dev, fmt, ...)					\
> > +	_dev_notice(dev, dev_fmt(fmt), ##__VA_ARGS__)
> > +#define dev_info(dev, fmt, ...)						\
> > +	_dev_info(dev, dev_fmt(fmt), ##__VA_ARGS__)
> >  
> >  #if defined(CONFIG_DYNAMIC_DEBUG)
> > -#define dev_dbg(dev, format, ...)		     \
> > -do {						     \
> > -	dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
> > -} while (0)
> > +#define dev_dbg(dev, fmt, ...)						\
> > +	dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
> >  #elif defined(DEBUG)
> > -#define dev_dbg(dev, format, arg...)		\
> > -	dev_printk(KERN_DEBUG, dev, format, ##arg)
> > +#define dev_dbg(dev, fmt, ...)						\
> > +	dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
> >  #else
> > -#define dev_dbg(dev, format, arg...)				\
> > -({								\
> > -	if (0)							\
> > -		dev_printk(KERN_DEBUG, dev, format, ##arg);	\
> > +#define dev_dbg(dev, fmt, ...)						\
> > +({									\
> > +	if (0)								\
> > +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
> >  })
> >  #endif
> >  
> > @@ -1467,7 +1480,7 @@ do {									\
> >  	DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);			\
> >  	if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) &&	\
> >  	    __ratelimit(&_rs))						\
> > -		__dynamic_dev_dbg(&descriptor, dev, fmt,		\
> > +		__dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt),	\
> >  				  ##__VA_ARGS__);			\
> >  } while (0)
> >  #elif defined(DEBUG)
> > @@ -1477,23 +1490,23 @@ do {									\
> >  				      DEFAULT_RATELIMIT_INTERVAL,	\
> >  				      DEFAULT_RATELIMIT_BURST);		\
> >  	if (__ratelimit(&_rs))						\
> > -		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
> > +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
> >  } while (0)
> >  #else
> >  #define dev_dbg_ratelimited(dev, fmt, ...)				\
> >  do {									\
> >  	if (0)								\
> > -		dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);	\
> > +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
> >  } while (0)
> >  #endif
> >  
> >  #ifdef VERBOSE_DEBUG
> >  #define dev_vdbg	dev_dbg
> >  #else
> > -#define dev_vdbg(dev, format, arg...)				\
> > -({								\
> > -	if (0)							\
> > -		dev_printk(KERN_DEBUG, dev, format, ##arg);	\
> > +#define dev_vdbg(dev, fmt, ...)						\
> > +({									\
> > +	if (0)								\
> > +		dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
> >  })
> >  #endif
> >  

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Greg Kroah-Hartman]

On Sun, Jun 24, 2018 at 08:41:03AM -0700, Joe Perches wrote:
> On Tue, 2018-06-19 at 06:31 -0700, Joe Perches wrote:
> > Greg?  Ping?
> > 
> > The patches to impi have hit -next and the impi code
> > works differently without this patch.
> 
> Greg?
> 
> You are listed as the maintainer for this subsystem.
> Do you want me to  get this applied via someone else?

I am traveling in Asia right now, please give me a chance to catch up on
patches...

thanks,

greg k-h

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Joe Perches]

On Mon, 2018-06-25 at 08:51 +0800, Greg Kroah-Hartman wrote:
> On Sun, Jun 24, 2018 at 08:41:03AM -0700, Joe Perches wrote:
> > On Tue, 2018-06-19 at 06:31 -0700, Joe Perches wrote:
> > > Greg?  Ping?
> > > 
> > > The patches to impi have hit -next and the impi code
> > > works differently without this patch.
> > 
> > Greg?
> > 
> > You are listed as the maintainer for this subsystem.
> > Do you want me to  get this applied via someone else?
> 
> I am traveling in Asia right now, please give me a chance to catch up on
> patches...

Caught up yet?

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Greg Kroah-Hartman]

On Thu, Jul 05, 2018 at 03:57:56PM -0700, Joe Perches wrote:
> On Mon, 2018-06-25 at 08:51 +0800, Greg Kroah-Hartman wrote:
> > On Sun, Jun 24, 2018 at 08:41:03AM -0700, Joe Perches wrote:
> > > On Tue, 2018-06-19 at 06:31 -0700, Joe Perches wrote:
> > > > Greg?  Ping?
> > > > 
> > > > The patches to impi have hit -next and the impi code
> > > > works differently without this patch.
> > > 
> > > Greg?
> > > 
> > > You are listed as the maintainer for this subsystem.
> > > Do you want me to  get this applied via someone else?
> > 
> > I am traveling in Asia right now, please give me a chance to catch up on
> > patches...
> 
> Caught up yet?

Nope!

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Joe Perches]

On Fri, 2018-07-06 at 15:38 +0200, Greg Kroah-Hartman wrote:
> On Thu, Jul 05, 2018 at 03:57:56PM -0700, Joe Perches wrote:
> > On Mon, 2018-06-25 at 08:51 +0800, Greg Kroah-Hartman wrote:
> > > On Sun, Jun 24, 2018 at 08:41:03AM -0700, Joe Perches wrote:
> > > > On Tue, 2018-06-19 at 06:31 -0700, Joe Perches wrote:
> > > > > Greg?  Ping?
> > > > > 
> > > > > The patches to impi have hit -next and the impi code
> > > > > works differently without this patch.
> > > > 
> > > > Greg?
> > > > 
> > > > You are listed as the maintainer for this subsystem.
> > > > Do you want me to  get this applied via someone else?
> > > 
> > > I am traveling in Asia right now, please give me a chance to catch up on
> > > patches...
> > 
> > Caught up yet?
> 
> Nope!

The patch was sent May 9th.

https://lkml.org/lkml/2018/5/9/610

I think it's well past the time
for you to be able to review and
apply it.

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Greg Kroah-Hartman]

On Wed, May 09, 2018 at 08:15:46AM -0700, Joe Perches wrote:
> Add a prefixing macro to dev_<level> uses similar to the pr_fmt
> prefixing macro used in pr_<level> calls.
> 
> This can help avoid some string duplication in dev_<level> uses.
> 
> The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
> 
> Rename the existing dev_<level> functions to _dev_<level> and
> introduce #define dev_<level> _dev_<level> macros that use the
> new #define dev_fmt
> 
> Miscellanea:
> 
> o Consistently use #defines with fmt, ... and ##__VA_ARGS__
> o Remove unnecessary externs

SHouldn't these be separate patches please?

> Signed-off-by: Joe Perches <joe@perches.com>
> ---
>  drivers/base/core.c    |  12 +++---
>  include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
>  2 files changed, 64 insertions(+), 51 deletions(-)

Ok this seems like a lot of churn for no real apparent gain.  What is
all of this getting us?  What is the benifit, you have more code now,
why is that good?

confused,

greg k-h

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Joe Perches]

On Fri, 2018-07-06 at 17:30 +0200, Greg Kroah-Hartman wrote:
> On Wed, May 09, 2018 at 08:15:46AM -0700, Joe Perches wrote:
> > Add a prefixing macro to dev_<level> uses similar to the pr_fmt
> > prefixing macro used in pr_<level> calls.
> > 
> > This can help avoid some string duplication in dev_<level> uses.
> > 
> > The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
> > 
> > Rename the existing dev_<level> functions to _dev_<level> and
> > introduce #define dev_<level> _dev_<level> macros that use the
> > new #define dev_fmt
> > 
> > Miscellanea:
> > 
> > o Consistently use #defines with fmt, ... and ##__VA_ARGS__
> > o Remove unnecessary externs
> 
> SHouldn't these be separate patches please?

Multiple patches touching the same lines are unnecessary work.

So I don't think so as it's just touching bits that need change
anyway.  

> > Signed-off-by: Joe Perches <joe@perches.com>
> > ---
> >  drivers/base/core.c    |  12 +++---
> >  include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
> >  2 files changed, 64 insertions(+), 51 deletions(-)
> 
> Ok this seems like a lot of churn for no real apparent gain.  What is
> all of this getting us?
>
> What is the benifit, you have more code now,
> why is that good?

IPMI and a few other subsystems prefix all their output
dev_<level> with specific duplicated content.

This centralizes those prefixes just like pr_fmt.

The IPMI changes are already in mainline and now
need this mechanism to maintain their output content.

IPMI and a few other subsystems prefix all their output
dev_<level> with specific duplicated content.

This centralizes those prefixes just like pr_fmt.

commit a2d70dfdda6f ("ipmi: msghandler: Add and use pr_fmt and dev_fmt,
remove PFX")

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Greg Kroah-Hartman]

On Fri, Jul 06, 2018 at 08:41:34AM -0700, Joe Perches wrote:
> On Fri, 2018-07-06 at 17:30 +0200, Greg Kroah-Hartman wrote:
> > On Wed, May 09, 2018 at 08:15:46AM -0700, Joe Perches wrote:
> > > Add a prefixing macro to dev_<level> uses similar to the pr_fmt
> > > prefixing macro used in pr_<level> calls.
> > > 
> > > This can help avoid some string duplication in dev_<level> uses.
> > > 
> > > The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
> > > 
> > > Rename the existing dev_<level> functions to _dev_<level> and
> > > introduce #define dev_<level> _dev_<level> macros that use the
> > > new #define dev_fmt
> > > 
> > > Miscellanea:
> > > 
> > > o Consistently use #defines with fmt, ... and ##__VA_ARGS__
> > > o Remove unnecessary externs
> > 
> > SHouldn't these be separate patches please?
> 
> Multiple patches touching the same lines are unnecessary work.
> 
> So I don't think so as it's just touching bits that need change
> anyway.  
> 
> > > Signed-off-by: Joe Perches <joe@perches.com>
> > > ---
> > >  drivers/base/core.c    |  12 +++---
> > >  include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
> > >  2 files changed, 64 insertions(+), 51 deletions(-)
> > 
> > Ok this seems like a lot of churn for no real apparent gain.  What is
> > all of this getting us?
> >
> > What is the benifit, you have more code now,
> > why is that good?
> 
> IPMI and a few other subsystems prefix all their output
> dev_<level> with specific duplicated content.

That's crazy and strange as the whole idea was that dev_* would uniquely
identify the driver/device such that "prefixes" would not be needed.

Ugh.

> This centralizes those prefixes just like pr_fmt.
> 
> The IPMI changes are already in mainline and now
> need this mechanism to maintain their output content.
> 
> IPMI and a few other subsystems prefix all their output
> dev_<level> with specific duplicated content.
> 
> This centralizes those prefixes just like pr_fmt.
> 
> commit a2d70dfdda6f ("ipmi: msghandler: Add and use pr_fmt and dev_fmt,
> remove PFX")

Ok, I'll take this.  I don't like it, as drivers should really not need
this at all.  But ipmi is known for doing "odd" things anyway...

greg k-h

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Corey Minyard]

On 07/06/2018 10:50 AM, Greg Kroah-Hartman wrote:
> On Fri, Jul 06, 2018 at 08:41:34AM -0700, Joe Perches wrote:
>> On Fri, 2018-07-06 at 17:30 +0200, Greg Kroah-Hartman wrote:
>>> On Wed, May 09, 2018 at 08:15:46AM -0700, Joe Perches wrote:
>>>> Add a prefixing macro to dev_<level> uses similar to the pr_fmt
>>>> prefixing macro used in pr_<level> calls.
>>>>
>>>> This can help avoid some string duplication in dev_<level> uses.
>>>>
>>>> The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
>>>>
>>>> Rename the existing dev_<level> functions to _dev_<level> and
>>>> introduce #define dev_<level> _dev_<level> macros that use the
>>>> new #define dev_fmt
>>>>
>>>> Miscellanea:
>>>>
>>>> o Consistently use #defines with fmt, ... and ##__VA_ARGS__
>>>> o Remove unnecessary externs
>>> SHouldn't these be separate patches please?
>> Multiple patches touching the same lines are unnecessary work.
>>
>> So I don't think so as it's just touching bits that need change
>> anyway.
>>
>>>> Signed-off-by: Joe Perches <joe@perches.com>
>>>> ---
>>>>   drivers/base/core.c    |  12 +++---
>>>>   include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
>>>>   2 files changed, 64 insertions(+), 51 deletions(-)
>>> Ok this seems like a lot of churn for no real apparent gain.  What is
>>> all of this getting us?
>>>
>>> What is the benifit, you have more code now,
>>> why is that good?
>> IPMI and a few other subsystems prefix all their output
>> dev_<level> with specific duplicated content.
> That's crazy and strange as the whole idea was that dev_* would uniquely
> identify the driver/device such that "prefixes" would not be needed.
>
> Ugh.
>
>> This centralizes those prefixes just like pr_fmt.
>>
>> The IPMI changes are already in mainline and now
>> need this mechanism to maintain their output content.
>>
>> IPMI and a few other subsystems prefix all their output
>> dev_<level> with specific duplicated content.
>>
>> This centralizes those prefixes just like pr_fmt.
>>
>> commit a2d70dfdda6f ("ipmi: msghandler: Add and use pr_fmt and dev_fmt,
>> remove PFX")
> Ok, I'll take this.  I don't like it, as drivers should really not need
> this at all.  But ipmi is known for doing "odd" things anyway...

I've been trying to make things less odd as time has gone by.  And I'm 
happy to
pull out this change.  I've been slowly working on the logging in the 
ipmi driver
to clean this kind of stuff up.

-corey

>
> greg k-h

Re: [PATCH 2/6] device: Add #define dev_fmt similar to #define pr_fmt

[Greg Kroah-Hartman]

On Fri, Jul 06, 2018 at 03:50:16PM -0500, Corey Minyard wrote:
> On 07/06/2018 10:50 AM, Greg Kroah-Hartman wrote:
> > On Fri, Jul 06, 2018 at 08:41:34AM -0700, Joe Perches wrote:
> > > On Fri, 2018-07-06 at 17:30 +0200, Greg Kroah-Hartman wrote:
> > > > On Wed, May 09, 2018 at 08:15:46AM -0700, Joe Perches wrote:
> > > > > Add a prefixing macro to dev_<level> uses similar to the pr_fmt
> > > > > prefixing macro used in pr_<level> calls.
> > > > > 
> > > > > This can help avoid some string duplication in dev_<level> uses.
> > > > > 
> > > > > The default, like pr_fmt, is an empty #define dev_fmt(fmt) fmt
> > > > > 
> > > > > Rename the existing dev_<level> functions to _dev_<level> and
> > > > > introduce #define dev_<level> _dev_<level> macros that use the
> > > > > new #define dev_fmt
> > > > > 
> > > > > Miscellanea:
> > > > > 
> > > > > o Consistently use #defines with fmt, ... and ##__VA_ARGS__
> > > > > o Remove unnecessary externs
> > > > SHouldn't these be separate patches please?
> > > Multiple patches touching the same lines are unnecessary work.
> > > 
> > > So I don't think so as it's just touching bits that need change
> > > anyway.
> > > 
> > > > > Signed-off-by: Joe Perches <joe@perches.com>
> > > > > ---
> > > > >   drivers/base/core.c    |  12 +++---
> > > > >   include/linux/device.h | 103 ++++++++++++++++++++++++++++---------------------
> > > > >   2 files changed, 64 insertions(+), 51 deletions(-)
> > > > Ok this seems like a lot of churn for no real apparent gain.  What is
> > > > all of this getting us?
> > > > 
> > > > What is the benifit, you have more code now,
> > > > why is that good?
> > > IPMI and a few other subsystems prefix all their output
> > > dev_<level> with specific duplicated content.
> > That's crazy and strange as the whole idea was that dev_* would uniquely
> > identify the driver/device such that "prefixes" would not be needed.
> > 
> > Ugh.
> > 
> > > This centralizes those prefixes just like pr_fmt.
> > > 
> > > The IPMI changes are already in mainline and now
> > > need this mechanism to maintain their output content.
> > > 
> > > IPMI and a few other subsystems prefix all their output
> > > dev_<level> with specific duplicated content.
> > > 
> > > This centralizes those prefixes just like pr_fmt.
> > > 
> > > commit a2d70dfdda6f ("ipmi: msghandler: Add and use pr_fmt and dev_fmt,
> > > remove PFX")
> > Ok, I'll take this.  I don't like it, as drivers should really not need
> > this at all.  But ipmi is known for doing "odd" things anyway...
> 
> I've been trying to make things less odd as time has gone by.  And I'm happy
> to pull out this change.  I've been slowly working on the logging in
> the ipmi driver to clean this kind of stuff up.

Cleaning up the logging would be great to see happen.  Until then, we
can leave these patches in.

thanks,

greg k-h

[PATCH 3/6] ipmi: msghandler: Add and use pr_fmt and dev_fmt, remove PFX

[Joe Perches]

Standardize the prefixing of output messages using the pr_fmt and dev_fmt
mechanisms instead of a separate #define PFX

Miscellanea:

o Because this message prefix is very long, use a non-standard define
  of #define pr_fmt(fmt) "%s" fmt, "IPMI message handler: "
  which removes ~170 bytes of object code in an x86-64 defconfig with ipmi
  (with even more object code reduction on 32 bit compilations)

Signed-off-by: Joe Perches <joe@perches.com>
---
 drivers/char/ipmi/ipmi_msghandler.c | 53 +++++++++++++++++--------------------
 1 file changed, 25 insertions(+), 28 deletions(-)

diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 946bfcb1eeee..db81f1e51bb9 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -11,6 +11,9 @@
  * Copyright 2002 MontaVista Software Inc.
  */
 
+#define pr_fmt(fmt) "%s" fmt, "IPMI message handler: "
+#define dev_fmt pr_fmt
+
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/poll.h>
@@ -30,8 +33,6 @@
 #include <linux/workqueue.h>
 #include <linux/uuid.h>
 
-#define PFX "IPMI message handler: "
-
 #define IPMI_DRIVER_VERSION "39.2"
 
 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
@@ -1490,8 +1491,7 @@ int ipmi_set_gets_events(struct ipmi_user *user, bool val)
 			list_move_tail(&msg->link, &msgs);
 		intf->waiting_events_count = 0;
 		if (intf->event_msg_printed) {
-			dev_warn(intf->si_dev,
-				 PFX "Event queue no longer full\n");
+			dev_warn(intf->si_dev, "Event queue no longer full\n");
 			intf->event_msg_printed = 0;
 		}
 
@@ -2289,16 +2289,15 @@ static void bmc_device_id_handler(struct ipmi_smi *intf,
 			|| (msg->msg.netfn != IPMI_NETFN_APP_RESPONSE)
 			|| (msg->msg.cmd != IPMI_GET_DEVICE_ID_CMD)) {
 		dev_warn(intf->si_dev,
-			 PFX "invalid device_id msg: addr_type=%d netfn=%x cmd=%x\n",
-			msg->addr.addr_type, msg->msg.netfn, msg->msg.cmd);
+			 "invalid device_id msg: addr_type=%d netfn=%x cmd=%x\n",
+			 msg->addr.addr_type, msg->msg.netfn, msg->msg.cmd);
 		return;
 	}
 
 	rv = ipmi_demangle_device_id(msg->msg.netfn, msg->msg.cmd,
 			msg->msg.data, msg->msg.data_len, &intf->bmc->fetch_id);
 	if (rv) {
-		dev_warn(intf->si_dev,
-			 PFX "device id demangle failed: %d\n", rv);
+		dev_warn(intf->si_dev, "device id demangle failed: %d\n", rv);
 		intf->bmc->dyn_id_set = 0;
 	} else {
 		/*
@@ -3131,8 +3130,7 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf,
 		mutex_unlock(&bmc->dyn_mutex);
 
 		dev_info(intf->si_dev,
-			 "ipmi: interfacing existing BMC (man_id: 0x%6.6x,"
-			 " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
+			 "interfacing existing BMC (man_id: 0x%6.6x, prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
 			 bmc->id.manufacturer_id,
 			 bmc->id.product_id,
 			 bmc->id.device_id);
@@ -3171,7 +3169,7 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf,
 		rv = platform_device_register(&bmc->pdev);
 		if (rv) {
 			dev_err(intf->si_dev,
-				PFX " Unable to register bmc device: %d\n",
+				"Unable to register bmc device: %d\n",
 				rv);
 			goto out_list_del;
 		}
@@ -3189,8 +3187,7 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf,
 	 */
 	rv = sysfs_create_link(&intf->si_dev->kobj, &bmc->pdev.dev.kobj, "bmc");
 	if (rv) {
-		dev_err(intf->si_dev,
-			PFX "Unable to create bmc symlink: %d\n", rv);
+		dev_err(intf->si_dev, "Unable to create bmc symlink: %d\n", rv);
 		goto out_put_bmc;
 	}
 
@@ -3199,8 +3196,8 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf,
 	intf->my_dev_name = kasprintf(GFP_KERNEL, "ipmi%d", intf_num);
 	if (!intf->my_dev_name) {
 		rv = -ENOMEM;
-		dev_err(intf->si_dev,
-			PFX "Unable to allocate link from BMC: %d\n", rv);
+		dev_err(intf->si_dev, "Unable to allocate link from BMC: %d\n",
+			rv);
 		goto out_unlink1;
 	}
 
@@ -3209,8 +3206,8 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf,
 	if (rv) {
 		kfree(intf->my_dev_name);
 		intf->my_dev_name = NULL;
-		dev_err(intf->si_dev,
-			PFX "Unable to create symlink to bmc: %d\n", rv);
+		dev_err(intf->si_dev, "Unable to create symlink to bmc: %d\n",
+			rv);
 		goto out_free_my_dev_name;
 	}
 
@@ -3294,7 +3291,7 @@ static void guid_handler(struct ipmi_smi *intf, struct ipmi_recv_msg *msg)
 	if (msg->msg.data_len < 17) {
 		bmc->dyn_guid_set = 0;
 		dev_warn(intf->si_dev,
-			 PFX "The GUID response from the BMC was too short, it was %d but should have been 17.  Assuming GUID is not available.\n",
+			 "The GUID response from the BMC was too short, it was %d but should have been 17.  Assuming GUID is not available.\n",
 			 msg->msg.data_len);
 		goto out;
 	}
@@ -3418,7 +3415,7 @@ channel_handler(struct ipmi_smi *intf, struct ipmi_recv_msg *msg)
 		if (rv) {
 			/* Got an error somehow, just give up. */
 			dev_warn(intf->si_dev,
-				 PFX "Error sending channel information for channel %d: %d\n",
+				 "Error sending channel information for channel %d: %d\n",
 				 intf->curr_channel, rv);
 
 			intf->channel_list = intf->wchannels + set;
@@ -4311,7 +4308,7 @@ static int handle_read_event_rsp(struct ipmi_smi *intf,
 		 * message.
 		 */
 		dev_warn(intf->si_dev,
-			 PFX "Event queue full, discarding incoming events\n");
+			 "Event queue full, discarding incoming events\n");
 		intf->event_msg_printed = 1;
 	}
 
@@ -4330,7 +4327,7 @@ static int handle_bmc_rsp(struct ipmi_smi *intf,
 	recv_msg = (struct ipmi_recv_msg *) msg->user_data;
 	if (recv_msg == NULL) {
 		dev_warn(intf->si_dev,
-			 "IPMI message received with no owner. This could be because of a malformed message, or because of a hardware error.  Contact your hardware vender for assistance\n");
+			 "IPMI message received with no owner. This could be because of a malformed message, or because of a hardware error.  Contact your hardware vendor for assistance.\n");
 		return 0;
 	}
 
@@ -4366,7 +4363,7 @@ static int handle_one_recv_msg(struct ipmi_smi *intf,
 	if (msg->rsp_size < 2) {
 		/* Message is too small to be correct. */
 		dev_warn(intf->si_dev,
-			 PFX "BMC returned to small a message for netfn %x cmd %x, got %d bytes\n",
+			 "BMC returned too small a message for netfn %x cmd %x, got %d bytes\n",
 			 (msg->data[0] >> 2) | 1, msg->data[1], msg->rsp_size);
 
 		/* Generate an error response for the message. */
@@ -4381,7 +4378,7 @@ static int handle_one_recv_msg(struct ipmi_smi *intf,
 		 * marginally correct.
 		 */
 		dev_warn(intf->si_dev,
-			 PFX "BMC returned incorrect response, expected netfn %x cmd %x, got netfn %x cmd %x\n",
+			 "BMC returned incorrect response, expected netfn %x cmd %x, got netfn %x cmd %x\n",
 			 (msg->data[0] >> 2) | 1, msg->data[1],
 			 msg->rsp[0] >> 2, msg->rsp[1]);
 
@@ -5271,16 +5268,16 @@ static int ipmi_init_msghandler(void)
 
 	rv = driver_register(&ipmidriver.driver);
 	if (rv) {
-		pr_err(PFX "Could not register IPMI driver\n");
+		pr_err("Could not register IPMI driver\n");
 		return rv;
 	}
 
-	pr_info("ipmi message handler version " IPMI_DRIVER_VERSION "\n");
+	pr_info("version %s\n", IPMI_DRIVER_VERSION);
 
 #ifdef CONFIG_IPMI_PROC_INTERFACE
 	proc_ipmi_root = proc_mkdir("ipmi", NULL);
 	if (!proc_ipmi_root) {
-	    pr_err(PFX "Unable to create IPMI proc dir");
+	    pr_err("Unable to create IPMI proc dir\n");
 	    driver_unregister(&ipmidriver.driver);
 	    return -ENOMEM;
 	}
@@ -5336,10 +5333,10 @@ static void __exit cleanup_ipmi(void)
 	/* Check for buffer leaks. */
 	count = atomic_read(&smi_msg_inuse_count);
 	if (count != 0)
-		pr_warn(PFX "SMI message count %d at exit\n", count);
+		pr_warn("SMI message count %d at exit\n", count);
 	count = atomic_read(&recv_msg_inuse_count);
 	if (count != 0)
-		pr_warn(PFX "recv message count %d at exit\n", count);
+		pr_warn("recv message count %d at exit\n", count);
 }
 module_exit(cleanup_ipmi);
 
-- 
2.15.0

[PATCH 4/6] ipmi: Use more common logging styles

[Joe Perches]

Add and use #define pr_fmt/dev_fmt, and remove #define PFX

This also prefixes some messages that were not previously prefixed.

Miscellanea:

o Convert printk(KERN_<level> to pr_<level>(
o Use %s, __func__ where appropriate

Signed-off-by: Joe Perches <joe@perches.com>
---
 drivers/char/ipmi/ipmi_poweroff.c    | 67 +++++++++++++++------------------
 drivers/char/ipmi/ipmi_si_hardcode.c |  9 +++--
 drivers/char/ipmi/ipmi_si_hotmod.c   | 17 +++++----
 drivers/char/ipmi/ipmi_si_intf.c     | 22 +++++------
 drivers/char/ipmi/ipmi_si_pci.c      | 12 +++---
 drivers/char/ipmi/ipmi_si_platform.c | 20 +++++-----
 drivers/char/ipmi/ipmi_ssif.c        | 73 +++++++++++++++++-------------------
 drivers/char/ipmi/ipmi_watchdog.c    | 52 ++++++++++++-------------
 8 files changed, 132 insertions(+), 140 deletions(-)

diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index f6e19410dc57..bc3a18daf97a 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -11,6 +11,9 @@
  *
  * Copyright 2002,2004 MontaVista Software Inc.
  */
+
+#define pr_fmt(fmt) "IPMI poweroff: " fmt
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/proc_fs.h>
@@ -21,8 +24,6 @@
 #include <linux/ipmi.h>
 #include <linux/ipmi_smi.h>
 
-#define PFX "IPMI poweroff: "
-
 static void ipmi_po_smi_gone(int if_num);
 static void ipmi_po_new_smi(int if_num, struct device *device);
 
@@ -192,7 +193,7 @@ static void pps_poweroff_atca(struct ipmi_user *user)
 	smi_addr.channel = IPMI_BMC_CHANNEL;
 	smi_addr.lun = 0;
 
-	printk(KERN_INFO PFX "PPS powerdown hook used");
+	pr_info("PPS powerdown hook used\n");
 
 	send_msg.netfn = IPMI_NETFN_OEM;
 	send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART;
@@ -201,10 +202,9 @@ static void pps_poweroff_atca(struct ipmi_user *user)
 	rv = ipmi_request_in_rc_mode(user,
 				     (struct ipmi_addr *) &smi_addr,
 				     &send_msg);
-	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
-		printk(KERN_ERR PFX "Unable to send ATCA ,"
-		       " IPMI error 0x%x\n", rv);
-	}
+	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE)
+		pr_err("Unable to send ATCA, IPMI error 0x%x\n", rv);
+
 	return;
 }
 
@@ -234,12 +234,10 @@ static int ipmi_atca_detect(struct ipmi_user *user)
 					    (struct ipmi_addr *) &smi_addr,
 					    &send_msg);
 
-	printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n",
-	       mfg_id, prod_id);
+	pr_info("ATCA Detect mfg 0x%X prod 0x%X\n", mfg_id, prod_id);
 	if ((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID)
 	    && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) {
-		printk(KERN_INFO PFX
-		       "Installing Pigeon Point Systems Poweroff Hook\n");
+		pr_info("Installing Pigeon Point Systems Poweroff Hook\n");
 		atca_oem_poweroff_hook = pps_poweroff_atca;
 	}
 	return !rv;
@@ -259,7 +257,7 @@ static void ipmi_poweroff_atca(struct ipmi_user *user)
 	smi_addr.channel = IPMI_BMC_CHANNEL;
 	smi_addr.lun = 0;
 
-	printk(KERN_INFO PFX "Powering down via ATCA power command\n");
+	pr_info("Powering down via ATCA power command\n");
 
 	/*
 	 * Power down
@@ -282,8 +280,8 @@ static void ipmi_poweroff_atca(struct ipmi_user *user)
 	 * return code
 	 */
 	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
-		printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
-		       " IPMI error 0x%x\n", rv);
+		pr_err("Unable to send ATCA powerdown message, IPMI error 0x%x\n",
+		       rv);
 		goto out;
 	}
 
@@ -334,7 +332,7 @@ static void ipmi_poweroff_cpi1(struct ipmi_user *user)
 	smi_addr.channel = IPMI_BMC_CHANNEL;
 	smi_addr.lun = 0;
 
-	printk(KERN_INFO PFX "Powering down via CPI1 power command\n");
+	pr_info("Powering down via CPI1 power command\n");
 
 	/*
 	 * Get IPMI ipmb address
@@ -482,7 +480,7 @@ static void ipmi_poweroff_chassis(struct ipmi_user *user)
 	smi_addr.lun = 0;
 
  powercyclefailed:
-	printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
+	pr_info("Powering %s via IPMI chassis control command\n",
 		(poweroff_powercycle ? "cycle" : "down"));
 
 	/*
@@ -502,14 +500,14 @@ static void ipmi_poweroff_chassis(struct ipmi_user *user)
 	if (rv) {
 		if (poweroff_powercycle) {
 			/* power cycle failed, default to power down */
-			printk(KERN_ERR PFX "Unable to send chassis power " \
-			       "cycle message, IPMI error 0x%x\n", rv);
+			pr_err("Unable to send chassis power cycle message, IPMI error 0x%x\n",
+			       rv);
 			poweroff_powercycle = 0;
 			goto powercyclefailed;
 		}
 
-		printk(KERN_ERR PFX "Unable to send chassis power " \
-		       "down message, IPMI error 0x%x\n", rv);
+		pr_err("Unable to send chassis power down message, IPMI error 0x%x\n",
+		       rv);
 	}
 }
 
@@ -571,8 +569,7 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
 	rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL,
 			      &ipmi_user);
 	if (rv) {
-		printk(KERN_ERR PFX "could not create IPMI user, error %d\n",
-		       rv);
+		pr_err("could not create IPMI user, error %d\n", rv);
 		return;
 	}
 
@@ -594,14 +591,13 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
 					    (struct ipmi_addr *) &smi_addr,
 					    &send_msg);
 	if (rv) {
-		printk(KERN_ERR PFX "Unable to send IPMI get device id info,"
-		       " IPMI error 0x%x\n", rv);
+		pr_err("Unable to send IPMI get device id info, IPMI error 0x%x\n",
+		       rv);
 		goto out_err;
 	}
 
 	if (halt_recv_msg.msg.data_len < 12) {
-		printk(KERN_ERR PFX "(chassis) IPMI get device id info too,"
-		       " short, was %d bytes, needed %d bytes\n",
+		pr_err("(chassis) IPMI get device id info too short, was %d bytes, needed %d bytes\n",
 		       halt_recv_msg.msg.data_len, 12);
 		goto out_err;
 	}
@@ -622,14 +618,13 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
 	}
 
  out_err:
-	printk(KERN_ERR PFX "Unable to find a poweroff function that"
-	       " will work, giving up\n");
+	pr_err("Unable to find a poweroff function that will work, giving up\n");
 	ipmi_destroy_user(ipmi_user);
 	return;
 
  found:
-	printk(KERN_INFO PFX "Found a %s style poweroff function\n",
-	       poweroff_functions[i].platform_type);
+	pr_info("Found a %s style poweroff function\n",
+		poweroff_functions[i].platform_type);
 	specific_poweroff_func = poweroff_functions[i].poweroff_func;
 	old_poweroff_func = pm_power_off;
 	pm_power_off = ipmi_poweroff_function;
@@ -692,16 +687,15 @@ static int __init ipmi_poweroff_init(void)
 {
 	int rv;
 
-	printk(KERN_INFO "Copyright (C) 2004 MontaVista Software -"
-	       " IPMI Powerdown via sys_reboot.\n");
+	pr_info("Copyright (C) 2004 MontaVista Software - IPMI Powerdown via sys_reboot\n");
 
 	if (poweroff_powercycle)
-		printk(KERN_INFO PFX "Power cycle is enabled.\n");
+		pr_info("Power cycle is enabled\n");
 
 #ifdef CONFIG_PROC_FS
 	ipmi_table_header = register_sysctl_table(ipmi_root_table);
 	if (!ipmi_table_header) {
-		printk(KERN_ERR PFX "Unable to register powercycle sysctl\n");
+		pr_err("Unable to register powercycle sysctl\n");
 		rv = -ENOMEM;
 		goto out_err;
 	}
@@ -712,7 +706,7 @@ static int __init ipmi_poweroff_init(void)
 #ifdef CONFIG_PROC_FS
 	if (rv) {
 		unregister_sysctl_table(ipmi_table_header);
-		printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
+		pr_err("Unable to register SMI watcher: %d\n", rv);
 		goto out_err;
 	}
 
@@ -735,8 +729,7 @@ static void __exit ipmi_poweroff_cleanup(void)
 	if (ready) {
 		rv = ipmi_destroy_user(ipmi_user);
 		if (rv)
-			printk(KERN_ERR PFX "could not cleanup the IPMI"
-			       " user: 0x%x\n", rv);
+			pr_err("could not cleanup the IPMI user: 0x%x\n", rv);
 		pm_power_off = old_poweroff_func;
 	}
 }
diff --git a/drivers/char/ipmi/ipmi_si_hardcode.c b/drivers/char/ipmi/ipmi_si_hardcode.c
index 10219f24546b..487642809c58 100644
--- a/drivers/char/ipmi/ipmi_si_hardcode.c
+++ b/drivers/char/ipmi/ipmi_si_hardcode.c
@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: GPL-2.0+
 
+#define pr_fmt(fmt) "ipmi_hardcode: " fmt
+
 #include <linux/moduleparam.h>
 #include "ipmi_si.h"
 
-#define PFX "ipmi_hardcode: "
 /*
  * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
  * a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS.
@@ -100,7 +101,7 @@ int ipmi_si_hardcode_find_bmc(void)
 			continue;
 
 		io.addr_source = SI_HARDCODED;
-		pr_info(PFX "probing via hardcoded address\n");
+		pr_info("probing via hardcoded address\n");
 
 		if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
 			io.si_type = SI_KCS;
@@ -109,7 +110,7 @@ int ipmi_si_hardcode_find_bmc(void)
 		} else if (strcmp(si_type[i], "bt") == 0) {
 			io.si_type = SI_BT;
 		} else {
-			pr_warn(PFX "Interface type specified for interface %d, was invalid: %s\n",
+			pr_warn("Interface type specified for interface %d, was invalid: %s\n",
 				i, si_type[i]);
 			continue;
 		}
@@ -123,7 +124,7 @@ int ipmi_si_hardcode_find_bmc(void)
 			io.addr_data = addrs[i];
 			io.addr_type = IPMI_MEM_ADDR_SPACE;
 		} else {
-			pr_warn(PFX "Interface type specified for interface %d, but port and address were not set or set to zero.\n",
+			pr_warn("Interface type specified for interface %d, but port and address were not set or set to zero\n",
 				i);
 			continue;
 		}
diff --git a/drivers/char/ipmi/ipmi_si_hotmod.c b/drivers/char/ipmi/ipmi_si_hotmod.c
index a98ca42a50b1..c0067fd0480d 100644
--- a/drivers/char/ipmi/ipmi_si_hotmod.c
+++ b/drivers/char/ipmi/ipmi_si_hotmod.c
@@ -5,12 +5,13 @@
  * Handling for dynamically adding/removing IPMI devices through
  * a module parameter (and thus sysfs).
  */
+
+#define pr_fmt(fmt) "ipmi_hotmod: " fmt
+
 #include <linux/moduleparam.h>
 #include <linux/ipmi.h>
 #include "ipmi_si.h"
 
-#define PFX "ipmi_hotmod: "
-
 static int hotmod_handler(const char *val, const struct kernel_param *kp);
 
 module_param_call(hotmod, hotmod_handler, NULL, NULL, 0200);
@@ -61,7 +62,7 @@ static int parse_str(const struct hotmod_vals *v, int *val, char *name,
 
 	s = strchr(*curr, ',');
 	if (!s) {
-		pr_warn(PFX "No hotmod %s given.\n", name);
+		pr_warn("No hotmod %s given\n", name);
 		return -EINVAL;
 	}
 	*s = '\0';
@@ -74,7 +75,7 @@ static int parse_str(const struct hotmod_vals *v, int *val, char *name,
 		}
 	}
 
-	pr_warn(PFX "Invalid hotmod %s '%s'\n", name, *curr);
+	pr_warn("Invalid hotmod %s '%s'\n", name, *curr);
 	return -EINVAL;
 }
 
@@ -85,12 +86,12 @@ static int check_hotmod_int_op(const char *curr, const char *option,
 
 	if (strcmp(curr, name) == 0) {
 		if (!option) {
-			pr_warn(PFX "No option given for '%s'\n", curr);
+			pr_warn("No option given for '%s'\n", curr);
 			return -EINVAL;
 		}
 		*val = simple_strtoul(option, &n, 0);
 		if ((*n != '\0') || (*option == '\0')) {
-			pr_warn(PFX "Bad option given for '%s'\n", curr);
+			pr_warn("Bad option given for '%s'\n", curr);
 			return -EINVAL;
 		}
 		return 1;
@@ -160,7 +161,7 @@ static int hotmod_handler(const char *val, const struct kernel_param *kp)
 		}
 		addr = simple_strtoul(curr, &n, 0);
 		if ((*n != '\0') || (*curr == '\0')) {
-			pr_warn(PFX "Invalid hotmod address '%s'\n", curr);
+			pr_warn("Invalid hotmod address '%s'\n", curr);
 			break;
 		}
 
@@ -203,7 +204,7 @@ static int hotmod_handler(const char *val, const struct kernel_param *kp)
 				continue;
 
 			rv = -EINVAL;
-			pr_warn(PFX "Invalid hotmod option '%s'\n", curr);
+			pr_warn("Invalid hotmod option '%s'\n", curr);
 			goto out;
 		}
 
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index f2c39bf91bf5..a43845821c92 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -19,6 +19,8 @@
  * and drives the real SMI state machine.
  */
 
+#define pr_fmt(fmt) "ipmi_si: " fmt
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/sched.h>
@@ -41,8 +43,6 @@
 #include <linux/string.h>
 #include <linux/ctype.h>
 
-#define PFX "ipmi_si: "
-
 /* Measure times between events in the driver. */
 #undef DEBUG_TIMING
 
@@ -1530,7 +1530,7 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
 
 	rv = wait_for_msg_done(smi_info);
 	if (rv) {
-		pr_warn(PFX "Error getting response from get global enables command, the event buffer is not enabled.\n");
+		pr_warn("Error getting response from get global enables command, the event buffer is not enabled\n");
 		goto out;
 	}
 
@@ -1541,7 +1541,7 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
 			resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
 			resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
 			resp[2] != 0) {
-		pr_warn(PFX "Invalid return from get global enables command, cannot enable the event buffer.\n");
+		pr_warn("Invalid return from get global enables command, cannot enable the event buffer\n");
 		rv = -EINVAL;
 		goto out;
 	}
@@ -1559,7 +1559,7 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
 
 	rv = wait_for_msg_done(smi_info);
 	if (rv) {
-		pr_warn(PFX "Error getting response from set global, enables command, the event buffer is not enabled.\n");
+		pr_warn("Error getting response from set global, enables command, the event buffer is not enabled\n");
 		goto out;
 	}
 
@@ -1569,7 +1569,7 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
 	if (resp_len < 3 ||
 			resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
 			resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
-		pr_warn(PFX "Invalid return from get global, enables command, not enable the event buffer.\n");
+		pr_warn("Invalid return from get global, enables command, not enable the event buffer\n");
 		rv = -EINVAL;
 		goto out;
 	}
@@ -1996,7 +1996,7 @@ int ipmi_si_add_smi(struct si_sm_io *io)
 		}
 	}
 
-	pr_info(PFX "Adding %s-specified %s state machine\n",
+	pr_info("Adding %s-specified %s state machine\n",
 		ipmi_addr_src_to_str(new_smi->io.addr_source),
 		si_to_str[new_smi->io.si_type]);
 
@@ -2020,7 +2020,7 @@ static int try_smi_init(struct smi_info *new_smi)
 	int i;
 	char *init_name = NULL;
 
-	pr_info(PFX "Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n",
+	pr_info("Trying %s-specified %s state machine at %s address 0x%lx, slave address 0x%x, irq %d\n",
 		ipmi_addr_src_to_str(new_smi->io.addr_source),
 		si_to_str[new_smi->io.si_type],
 		addr_space_to_str[new_smi->io.addr_type],
@@ -2060,7 +2060,7 @@ static int try_smi_init(struct smi_info *new_smi)
 		new_smi->pdev = platform_device_alloc("ipmi_si",
 						      new_smi->si_num);
 		if (!new_smi->pdev) {
-			pr_err(PFX "Unable to allocate platform device\n");
+			pr_err("Unable to allocate platform device\n");
 			rv = -ENOMEM;
 			goto out_err;
 		}
@@ -2229,7 +2229,7 @@ static int init_ipmi_si(void)
 	if (initialized)
 		return 0;
 
-	pr_info("IPMI System Interface driver.\n");
+	pr_info("IPMI System Interface driver\n");
 
 	/* If the user gave us a device, they presumably want us to use it */
 	if (!ipmi_si_hardcode_find_bmc())
@@ -2283,7 +2283,7 @@ static int init_ipmi_si(void)
 	if (unload_when_empty && list_empty(&smi_infos)) {
 		mutex_unlock(&smi_infos_lock);
 		cleanup_ipmi_si();
-		pr_warn(PFX "Unable to find any System Interface(s)\n");
+		pr_warn("Unable to find any System Interface(s)\n");
 		return -ENODEV;
 	} else {
 		mutex_unlock(&smi_infos_lock);
diff --git a/drivers/char/ipmi/ipmi_si_pci.c b/drivers/char/ipmi/ipmi_si_pci.c
index f54ca6869ed2..ecf9a7150a78 100644
--- a/drivers/char/ipmi/ipmi_si_pci.c
+++ b/drivers/char/ipmi/ipmi_si_pci.c
@@ -4,12 +4,13 @@
  *
  * Handling for IPMI devices on the PCI bus.
  */
+
+#define pr_fmt(fmt) "ipmi_pci: " fmt
+
 #include <linux/module.h>
 #include <linux/pci.h>
 #include "ipmi_si.h"
 
-#define PFX "ipmi_pci: "
-
 static bool pci_registered;
 
 static bool si_trypci = true;
@@ -45,8 +46,7 @@ static int ipmi_pci_probe_regspacing(struct si_sm_io *io)
 		for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
 			io->regspacing = regspacing;
 			if (io->io_setup(io)) {
-				dev_err(io->dev,
-					"Could not setup I/O space\n");
+				dev_err(io->dev, "Could not setup I/O space\n");
 				return DEFAULT_REGSPACING;
 			}
 			/* write invalid cmd */
@@ -131,7 +131,7 @@ static int ipmi_pci_probe(struct pci_dev *pdev,
 	io.dev = &pdev->dev;
 
 	dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
-		&pdev->resource[0], io.regsize, io.regspacing, io.irq);
+		 &pdev->resource[0], io.regsize, io.regspacing, io.irq);
 
 	rv = ipmi_si_add_smi(&io);
 	if (rv)
@@ -166,7 +166,7 @@ void ipmi_si_pci_init(void)
 	if (si_trypci) {
 		int rv = pci_register_driver(&ipmi_pci_driver);
 		if (rv)
-			pr_err(PFX "Unable to register PCI driver: %d\n", rv);
+			pr_err("Unable to register PCI driver: %d\n", rv);
 		else
 			pci_registered = true;
 	}
diff --git a/drivers/char/ipmi/ipmi_si_platform.c b/drivers/char/ipmi/ipmi_si_platform.c
index bf69927502bd..999fba24e29c 100644
--- a/drivers/char/ipmi/ipmi_si_platform.c
+++ b/drivers/char/ipmi/ipmi_si_platform.c
@@ -5,6 +5,10 @@
  * Handling for platform devices in IPMI (ACPI, OF, and things
  * coming from the platform.
  */
+
+#define pr_fmt(fmt) "ipmi_platform: " fmt
+#define dev_fmt pr_fmt
+
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
@@ -15,8 +19,6 @@
 #include "ipmi_si.h"
 #include "ipmi_dmi.h"
 
-#define PFX "ipmi_platform: "
-
 static bool si_tryplatform = true;
 #ifdef CONFIG_ACPI
 static bool          si_tryacpi = true;
@@ -158,7 +160,7 @@ static int platform_ipmi_probe(struct platform_device *pdev)
 
 	memset(&io, 0, sizeof(io));
 	io.addr_source = addr_source;
-	dev_info(&pdev->dev, PFX "probing via %s\n",
+	dev_info(&pdev->dev, "probing via %s\n",
 		 ipmi_addr_src_to_str(addr_source));
 
 	switch (type) {
@@ -236,25 +238,25 @@ static int of_ipmi_probe(struct platform_device *pdev)
 
 	ret = of_address_to_resource(np, 0, &resource);
 	if (ret) {
-		dev_warn(&pdev->dev, PFX "invalid address from OF\n");
+		dev_warn(&pdev->dev, "invalid address from OF\n");
 		return ret;
 	}
 
 	regsize = of_get_property(np, "reg-size", &proplen);
 	if (regsize && proplen != 4) {
-		dev_warn(&pdev->dev, PFX "invalid regsize from OF\n");
+		dev_warn(&pdev->dev, "invalid regsize from OF\n");
 		return -EINVAL;
 	}
 
 	regspacing = of_get_property(np, "reg-spacing", &proplen);
 	if (regspacing && proplen != 4) {
-		dev_warn(&pdev->dev, PFX "invalid regspacing from OF\n");
+		dev_warn(&pdev->dev, "invalid regspacing from OF\n");
 		return -EINVAL;
 	}
 
 	regshift = of_get_property(np, "reg-shift", &proplen);
 	if (regshift && proplen != 4) {
-		dev_warn(&pdev->dev, PFX "invalid regshift from OF\n");
+		dev_warn(&pdev->dev, "invalid regshift from OF\n");
 		return -EINVAL;
 	}
 
@@ -326,7 +328,7 @@ static int acpi_ipmi_probe(struct platform_device *pdev)
 
 	memset(&io, 0, sizeof(io));
 	io.addr_source = SI_ACPI;
-	dev_info(&pdev->dev, PFX "probing via ACPI\n");
+	dev_info(&pdev->dev, "probing via ACPI\n");
 
 	io.addr_info.acpi_info.acpi_handle = handle;
 
@@ -431,7 +433,7 @@ void ipmi_si_platform_init(void)
 {
 	int rv = platform_driver_register(&ipmi_platform_driver);
 	if (rv)
-		pr_err(PFX "Unable to register driver: %d\n", rv);
+		pr_err("Unable to register driver: %d\n", rv);
 }
 
 void ipmi_si_platform_shutdown(void)
diff --git a/drivers/char/ipmi/ipmi_ssif.c b/drivers/char/ipmi/ipmi_ssif.c
index 37f9ae2de6a4..d57bfd65c603 100644
--- a/drivers/char/ipmi/ipmi_ssif.c
+++ b/drivers/char/ipmi/ipmi_ssif.c
@@ -27,6 +27,8 @@
  * interface into the I2C driver, I believe.
  */
 
+#define pr_fmt(fmt) "ipmi_ssif: " fmt
+
 #if defined(MODVERSIONS)
 #include <linux/modversions.h>
 #endif
@@ -52,7 +54,6 @@
 #include "ipmi_si_sm.h"
 #include "ipmi_dmi.h"
 
-#define PFX "ipmi_ssif: "
 #define DEVICE_NAME "ipmi_ssif"
 
 #define IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD	0x57
@@ -314,9 +315,8 @@ static void deliver_recv_msg(struct ssif_info *ssif_info,
 {
 	if (msg->rsp_size < 0) {
 		return_hosed_msg(ssif_info, msg);
-		pr_err(PFX
-		       "Malformed message in deliver_recv_msg: rsp_size = %d\n",
-		       msg->rsp_size);
+		pr_err("%s: Malformed message: rsp_size = %d\n",
+		       __func__, msg->rsp_size);
 	} else {
 		ipmi_smi_msg_received(ssif_info->intf, msg);
 	}
@@ -650,7 +650,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 		if (len == 0) {
 			result = -EIO;
 			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
-				pr_info(PFX "Middle message with no data\n");
+				pr_info("Middle message with no data\n");
 
 			goto continue_op;
 		}
@@ -694,8 +694,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 					   I2C_SMBUS_BLOCK_DATA);
 			if (rv < 0) {
 				if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
-					pr_info(PFX
-						"Error from ssif_i2c_send\n");
+					pr_info("Error from ssif_i2c_send\n");
 
 				result = -EIO;
 			} else
@@ -713,7 +712,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 
  continue_op:
 	if (ssif_info->ssif_debug & SSIF_DEBUG_STATE)
-		pr_info(PFX "DONE 1: state = %d, result=%d.\n",
+		pr_info("DONE 1: state = %d, result=%d\n",
 			ssif_info->ssif_state, result);
 
 	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
@@ -747,8 +746,8 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 			 */
 			ssif_info->ssif_state = SSIF_NORMAL;
 			ipmi_ssif_unlock_cond(ssif_info, flags);
-			pr_warn(PFX "Error getting flags: %d %d, %x\n",
-			       result, len, (len >= 3) ? data[2] : 0);
+			pr_warn("Error getting flags: %d %d, %x\n",
+				result, len, (len >= 3) ? data[2] : 0);
 		} else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 			   || data[1] != IPMI_GET_MSG_FLAGS_CMD) {
 			/*
@@ -756,7 +755,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 			 * response to a previous command.
 			 */
 			ipmi_ssif_unlock_cond(ssif_info, flags);
-			pr_warn(PFX "Invalid response getting flags: %x %x\n",
+			pr_warn("Invalid response getting flags: %x %x\n",
 				data[0], data[1]);
 		} else {
 			ssif_inc_stat(ssif_info, flag_fetches);
@@ -769,11 +768,11 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 		/* We cleared the flags. */
 		if ((result < 0) || (len < 3) || (data[2] != 0)) {
 			/* Error clearing flags */
-			pr_warn(PFX "Error clearing flags: %d %d, %x\n",
-			       result, len, (len >= 3) ? data[2] : 0);
+			pr_warn("Error clearing flags: %d %d, %x\n",
+				result, len, (len >= 3) ? data[2] : 0);
 		} else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 			   || data[1] != IPMI_CLEAR_MSG_FLAGS_CMD) {
-			pr_warn(PFX "Invalid response clearing flags: %x %x\n",
+			pr_warn("Invalid response clearing flags: %x %x\n",
 				data[0], data[1]);
 		}
 		ssif_info->ssif_state = SSIF_NORMAL;
@@ -790,7 +789,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 			handle_flags(ssif_info, flags);
 		} else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 			   || msg->rsp[1] != IPMI_READ_EVENT_MSG_BUFFER_CMD) {
-			pr_warn(PFX "Invalid response getting events: %x %x\n",
+			pr_warn("Invalid response getting events: %x %x\n",
 				msg->rsp[0], msg->rsp[1]);
 			msg->done(msg);
 			/* Take off the event flag. */
@@ -813,7 +812,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 			handle_flags(ssif_info, flags);
 		} else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 			   || msg->rsp[1] != IPMI_GET_MSG_CMD) {
-			pr_warn(PFX "Invalid response clearing flags: %x %x\n",
+			pr_warn("Invalid response clearing flags: %x %x\n",
 				msg->rsp[0], msg->rsp[1]);
 			msg->done(msg);
 
@@ -840,7 +839,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 		ipmi_ssif_unlock_cond(ssif_info, flags);
 
 	if (ssif_info->ssif_debug & SSIF_DEBUG_STATE)
-		pr_info(PFX "DONE 2: state = %d.\n", ssif_info->ssif_state);
+		pr_info("DONE 2: state = %d.\n", ssif_info->ssif_state);
 }
 
 static void msg_written_handler(struct ssif_info *ssif_info, int result,
@@ -860,8 +859,7 @@ static void msg_written_handler(struct ssif_info *ssif_info, int result,
 			ssif_inc_stat(ssif_info, send_errors);
 
 			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
-				pr_info(PFX
-					"Out of retries in msg_written_handler\n");
+				pr_info("%s: Out of retries\n", __func__);
 			msg_done_handler(ssif_info, -EIO, NULL, 0);
 			return;
 		}
@@ -1041,8 +1039,8 @@ static void sender(void                *send_info,
 
 		ktime_get_real_ts64(&t);
 		pr_info("**Enqueue %02x %02x: %lld.%6.6ld\n",
-		       msg->data[0], msg->data[1],
-		       (long long) t.tv_sec, (long) t.tv_nsec / NSEC_PER_USEC);
+			msg->data[0], msg->data[1],
+			(long long)t.tv_sec, (long)t.tv_nsec / NSEC_PER_USEC);
 	}
 }
 
@@ -1506,9 +1504,9 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 
 	slave_addr = find_slave_address(client, slave_addr);
 
-	pr_info(PFX "Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n",
-	       ipmi_addr_src_to_str(ssif_info->addr_source),
-	       client->addr, client->adapter->name, slave_addr);
+	pr_info("Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n",
+		ipmi_addr_src_to_str(ssif_info->addr_source),
+		client->addr, client->adapter->name, slave_addr);
 
 	ssif_info->client = client;
 	i2c_set_clientdata(client, ssif_info);
@@ -1521,7 +1519,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 	if (!rv && (len >= 3) && (resp[2] == 0)) {
 		if (len < 7) {
 			if (ssif_dbg_probe)
-				pr_info(PFX "SSIF info too short: %d\n", len);
+				pr_info("SSIF info too short: %d\n", len);
 			goto no_support;
 		}
 
@@ -1577,8 +1575,8 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 	} else {
  no_support:
 		/* Assume no multi-part or PEC support */
-		pr_info(PFX "Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n",
-		       rv, len, resp[2]);
+		pr_info("Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n",
+			rv, len, resp[2]);
 
 		ssif_info->max_xmit_msg_size = 32;
 		ssif_info->max_recv_msg_size = 32;
@@ -1592,7 +1590,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 	msg[2] = WDT_PRE_TIMEOUT_INT;
 	rv = do_cmd(client, 3, msg, &len, resp);
 	if (rv || (len < 3) || (resp[2] != 0))
-		pr_warn(PFX "Unable to clear message flags: %d %d %2.2x\n",
+		pr_warn("Unable to clear message flags: %d %d %2.2x\n",
 			rv, len, resp[2]);
 
 	/* Attempt to enable the event buffer. */
@@ -1600,7 +1598,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 	msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
 	rv = do_cmd(client, 2, msg, &len, resp);
 	if (rv || (len < 4) || (resp[2] != 0)) {
-		pr_warn(PFX "Error getting global enables: %d %d %2.2x\n",
+		pr_warn("Error getting global enables: %d %d %2.2x\n",
 			rv, len, resp[2]);
 		rv = 0; /* Not fatal */
 		goto found;
@@ -1619,7 +1617,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 	msg[2] = ssif_info->global_enables | IPMI_BMC_EVT_MSG_BUFF;
 	rv = do_cmd(client, 3, msg, &len, resp);
 	if (rv || (len < 2)) {
-		pr_warn(PFX "Error setting global enables: %d %d %2.2x\n",
+		pr_warn("Error setting global enables: %d %d %2.2x\n",
 			rv, len, resp[2]);
 		rv = 0; /* Not fatal */
 		goto found;
@@ -1640,7 +1638,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 	msg[2] = ssif_info->global_enables | IPMI_BMC_RCV_MSG_INTR;
 	rv = do_cmd(client, 3, msg, &len, resp);
 	if (rv || (len < 2)) {
-		pr_warn(PFX "Error setting global enables: %d %d %2.2x\n",
+		pr_warn("Error setting global enables: %d %d %2.2x\n",
 			rv, len, resp[2]);
 		rv = 0; /* Not fatal */
 		goto found;
@@ -1708,7 +1706,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 			       &ssif_info->client->dev,
 			       slave_addr);
 	 if (rv) {
-		pr_err(PFX "Unable to register device: error %d\n", rv);
+		pr_err("Unable to register device: error %d\n", rv);
 		goto out_remove_attr;
 	}
 
@@ -1717,7 +1715,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 				     &smi_type_proc_ops,
 				     ssif_info);
 	if (rv) {
-		pr_err(PFX "Unable to create proc entry: %d\n", rv);
+		pr_err("Unable to create proc entry: %d\n", rv);
 		goto out_err_unreg;
 	}
 
@@ -1725,7 +1723,7 @@ static int ssif_probe(struct i2c_client *client, const struct i2c_device_id *id)
 				     &smi_stats_proc_ops,
 				     ssif_info);
 	if (rv) {
-		pr_err(PFX "Unable to create proc entry: %d\n", rv);
+		pr_err("Unable to create proc entry: %d\n", rv);
 		goto out_err_unreg;
 	}
 #endif
@@ -1888,7 +1886,7 @@ static int dmi_ipmi_probe(struct platform_device *pdev)
 
 	rv = device_property_read_u16(&pdev->dev, "i2c-addr", &i2c_addr);
 	if (rv) {
-		dev_warn(&pdev->dev, PFX "No i2c-addr property\n");
+		dev_warn(&pdev->dev, "No i2c-addr property\n");
 		return -ENODEV;
 	}
 
@@ -1969,8 +1967,7 @@ static int init_ipmi_ssif(void)
 				     dbg[i], slave_addrs[i],
 				     SI_HARDCODED, NULL);
 		if (rv)
-			pr_err(PFX
-			       "Couldn't add hardcoded device at addr 0x%x\n",
+			pr_err("Couldn't add hardcoded device at addr 0x%x\n",
 			       addr[i]);
 	}
 
@@ -1981,7 +1978,7 @@ static int init_ipmi_ssif(void)
 	if (ssif_trydmi) {
 		rv = platform_driver_register(&ipmi_driver);
 		if (rv)
-			pr_err(PFX "Unable to register driver: %d\n", rv);
+			pr_err("Unable to register driver: %d\n", rv);
 	}
 
 	ssif_i2c_driver.address_list = ssif_address_list();
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index ca1c5c5109f0..2924a4bc4a32 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -11,6 +11,8 @@
  * Copyright 2002 MontaVista Software Inc.
  */
 
+#define pr_fmt(fmt) "IPMI Watchdog: " fmt
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/ipmi.h>
@@ -50,8 +52,6 @@
 #define HAVE_DIE_NMI
 #endif
 
-#define	PFX "IPMI Watchdog: "
-
 /*
  * The IPMI command/response information for the watchdog timer.
  */
@@ -407,7 +407,7 @@ static int __ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
 				      recv_msg,
 				      1);
 	if (rv)
-		pr_warn(PFX "set timeout error: %d\n", rv);
+		pr_warn("set timeout error: %d\n", rv);
 	else if (send_heartbeat_now)
 		*send_heartbeat_now = hbnow;
 
@@ -530,7 +530,7 @@ static void panic_halt_ipmi_set_timeout(void)
 				&send_heartbeat_now);
 	if (rv) {
 		atomic_sub(1, &panic_done_count);
-		pr_warn(PFX "Unable to extend the watchdog timeout.");
+		pr_warn("Unable to extend the watchdog timeout\n");
 	} else {
 		if (send_heartbeat_now)
 			panic_halt_ipmi_heartbeat();
@@ -573,7 +573,7 @@ static int __ipmi_heartbeat(void)
 				      &recv_msg,
 				      1);
 	if (rv) {
-		pr_warn(PFX "heartbeat send failure: %d\n", rv);
+		pr_warn("heartbeat send failure: %d\n", rv);
 		return rv;
 	}
 
@@ -583,7 +583,7 @@ static int __ipmi_heartbeat(void)
 	if (recv_msg.msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)  {
 		timeout_retries++;
 		if (timeout_retries > 3) {
-			pr_err(PFX ": Unable to restore the IPMI watchdog's settings, giving up.\n");
+			pr_err("Unable to restore the IPMI watchdog's settings, giving up\n");
 			rv = -EIO;
 			goto out;
 		}
@@ -598,7 +598,7 @@ static int __ipmi_heartbeat(void)
 		 */
 		rv = _ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 		if (rv) {
-			pr_err(PFX ": Unable to send the command to set the watchdog's settings, giving up.\n");
+			pr_err("Unable to send the command to set the watchdog's settings, giving up\n");
 			goto out;
 		}
 
@@ -876,8 +876,7 @@ static int ipmi_close(struct inode *ino, struct file *filep)
 			_ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 			mutex_unlock(&ipmi_watchdog_mutex);
 		} else {
-			pr_crit(PFX
-				"Unexpected close, not stopping watchdog!\n");
+			pr_crit("Unexpected close, not stopping watchdog!\n");
 			ipmi_heartbeat();
 		}
 		clear_bit(0, &ipmi_wdog_open);
@@ -911,9 +910,9 @@ static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
 {
 	if (msg->msg.cmd == IPMI_WDOG_RESET_TIMER &&
 			msg->msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)
-		pr_info(PFX "response: The IPMI controller appears to have been reset, will attempt to reinitialize the watchdog timer\n");
+		pr_info("response: The IPMI controller appears to have been reset, will attempt to reinitialize the watchdog timer\n");
 	else if (msg->msg.data[0] != 0)
-		pr_err(PFX "response: Error %x on cmd %x\n",
+		pr_err("response: Error %x on cmd %x\n",
 		       msg->msg.data[0],
 		       msg->msg.cmd);
 
@@ -985,7 +984,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
 
 	rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
 	if (rv < 0) {
-		pr_crit(PFX "Unable to register with ipmi\n");
+		pr_crit("Unable to register with ipmi\n");
 		goto out;
 	}
 
@@ -993,7 +992,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
 			      &ipmi_version_major,
 			      &ipmi_version_minor);
 	if (rv) {
-		pr_warn(PFX "Unable to get IPMI version, assuming 1.0\n");
+		pr_warn("Unable to get IPMI version, assuming 1.0\n");
 		ipmi_version_major = 1;
 		ipmi_version_minor = 0;
 	}
@@ -1002,7 +1001,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
 	if (rv < 0) {
 		ipmi_destroy_user(watchdog_user);
 		watchdog_user = NULL;
-		pr_crit(PFX "Unable to register misc device\n");
+		pr_crit("Unable to register misc device\n");
 	}
 
 #ifdef HAVE_DIE_NMI
@@ -1024,7 +1023,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
 
 		rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
 		if (rv) {
-			pr_warn(PFX "Error starting timer to test NMI: 0x%x.  The NMI pretimeout will likely not work\n",
+			pr_warn("Error starting timer to test NMI: 0x%x.  The NMI pretimeout will likely not work\n",
 				rv);
 			rv = 0;
 			goto out_restore;
@@ -1033,7 +1032,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
 		msleep(1500);
 
 		if (testing_nmi != 2) {
-			pr_warn(PFX "IPMI NMI didn't seem to occur.  The NMI pretimeout will likely not work\n");
+			pr_warn("IPMI NMI didn't seem to occur.  The NMI pretimeout will likely not work\n");
 		}
  out_restore:
 		testing_nmi = 0;
@@ -1049,7 +1048,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
 		start_now = 0; /* Disable this function after first startup. */
 		ipmi_watchdog_state = action_val;
 		ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
-		pr_info(PFX "Starting now!\n");
+		pr_info("Starting now!\n");
 	} else {
 		/* Stop the timer now. */
 		ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
@@ -1086,7 +1085,7 @@ static void ipmi_unregister_watchdog(int ipmi_intf)
 	/* Disconnect from IPMI. */
 	rv = ipmi_destroy_user(loc_user);
 	if (rv)
-		pr_warn(PFX "error unlinking from IPMI: %d\n",  rv);
+		pr_warn("error unlinking from IPMI: %d\n",  rv);
 
 	/* If it comes back, restart it properly. */
 	ipmi_start_timer_on_heartbeat = 1;
@@ -1127,7 +1126,7 @@ ipmi_nmi(unsigned int val, struct pt_regs *regs)
 		   the timer.   So do so. */
 		atomic_set(&pretimeout_since_last_heartbeat, 1);
 		if (atomic_inc_and_test(&preop_panic_excl))
-			nmi_panic(regs, PFX "pre-timeout");
+			nmi_panic(regs, "pre-timeout");
 	}
 
 	return NMI_HANDLED;
@@ -1259,7 +1258,7 @@ static void check_parms(void)
 	if (preaction_val == WDOG_PRETIMEOUT_NMI) {
 		do_nmi = 1;
 		if (preop_val == WDOG_PREOP_GIVE_DATA) {
-			pr_warn(PFX "Pretimeout op is to give data but NMI pretimeout is enabled, setting pretimeout op to none\n");
+			pr_warn("Pretimeout op is to give data but NMI pretimeout is enabled, setting pretimeout op to none\n");
 			preop_op("preop_none", NULL);
 			do_nmi = 0;
 		}
@@ -1268,7 +1267,7 @@ static void check_parms(void)
 		rv = register_nmi_handler(NMI_UNKNOWN, ipmi_nmi, 0,
 						"ipmi");
 		if (rv) {
-			pr_warn(PFX "Can't register nmi handler\n");
+			pr_warn("Can't register nmi handler\n");
 			return;
 		} else
 			nmi_handler_registered = 1;
@@ -1285,19 +1284,18 @@ static int __init ipmi_wdog_init(void)
 
 	if (action_op(action, NULL)) {
 		action_op("reset", NULL);
-		pr_info(PFX "Unknown action '%s', defaulting to reset\n",
-			action);
+		pr_info("Unknown action '%s', defaulting to reset\n", action);
 	}
 
 	if (preaction_op(preaction, NULL)) {
 		preaction_op("pre_none", NULL);
-		pr_info(PFX "Unknown preaction '%s', defaulting to none\n",
+		pr_info("Unknown preaction '%s', defaulting to none\n",
 			preaction);
 	}
 
 	if (preop_op(preop, NULL)) {
 		preop_op("preop_none", NULL);
-		pr_info(PFX "Unknown preop '%s', defaulting to none\n", preop);
+		pr_info("Unknown preop '%s', defaulting to none\n", preop);
 	}
 
 	check_parms();
@@ -1311,11 +1309,11 @@ static int __init ipmi_wdog_init(void)
 			unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
 #endif
 		unregister_reboot_notifier(&wdog_reboot_notifier);
-		pr_warn(PFX "can't register smi watcher\n");
+		pr_warn("can't register smi watcher\n");
 		return rv;
 	}
 
-	pr_info(PFX "driver initialized\n");
+	pr_info("driver initialized\n");
 
 	return 0;
 }
-- 
2.15.0

[PATCH 5/6] ipmi: Convert printk(KERN_<level> to pr_<level>(

[Joe Perches]

Use the more common logging style.

Miscellanea:

o Convert old style continuation printks without KERN_CONT to pr_cont
o Coalesce formats
o Realign arguments
o Remove unnecessary casts

Signed-off-by: Joe Perches <joe@perches.com>
---
 drivers/char/ipmi/ipmi_bt_sm.c   | 64 +++++++++++++++++++---------------------
 drivers/char/ipmi/ipmi_devintf.c | 11 ++++---
 drivers/char/ipmi/ipmi_kcs_sm.c  |  4 +--
 drivers/char/ipmi/ipmi_smic_sm.c | 26 +++++++---------
 4 files changed, 48 insertions(+), 57 deletions(-)

diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index fd4ea8d87d4b..95cfa20456e6 100644
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -221,11 +221,11 @@ static int bt_start_transaction(struct si_sm_data *bt,
 		return IPMI_NOT_IN_MY_STATE_ERR;
 
 	if (bt_debug & BT_DEBUG_MSG) {
-		printk(KERN_WARNING "BT: +++++++++++++++++ New command\n");
-		printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2);
+		pr_warn("BT: +++++++++++++++++ New command\n");
+		pr_warn("BT: NetFn/LUN CMD [%d data]:", size - 2);
 		for (i = 0; i < size; i ++)
-			printk(" %02x", data[i]);
-		printk("\n");
+			pr_cont(" %02x", data[i]);
+		pr_cont("\n");
 	}
 	bt->write_data[0] = size + 1;	/* all data plus seq byte */
 	bt->write_data[1] = *data;	/* NetFn/LUN */
@@ -266,10 +266,10 @@ static int bt_get_result(struct si_sm_data *bt,
 		memcpy(data + 2, bt->read_data + 4, msg_len - 2);
 
 	if (bt_debug & BT_DEBUG_MSG) {
-		printk(KERN_WARNING "BT: result %d bytes:", msg_len);
+		pr_warn("BT: result %d bytes:", msg_len);
 		for (i = 0; i < msg_len; i++)
-			printk(" %02x", data[i]);
-		printk("\n");
+			pr_cont(" %02x", data[i]);
+		pr_cont("\n");
 	}
 	return msg_len;
 }
@@ -280,8 +280,7 @@ static int bt_get_result(struct si_sm_data *bt,
 static void reset_flags(struct si_sm_data *bt)
 {
 	if (bt_debug)
-		printk(KERN_WARNING "IPMI BT: flag reset %s\n",
-					status2txt(BT_STATUS));
+		pr_warn("IPMI BT: flag reset %s\n", status2txt(BT_STATUS));
 	if (BT_STATUS & BT_H_BUSY)
 		BT_CONTROL(BT_H_BUSY);	/* force clear */
 	BT_CONTROL(BT_CLR_WR_PTR);	/* always reset */
@@ -307,14 +306,13 @@ static void drain_BMC2HOST(struct si_sm_data *bt)
 	BT_CONTROL(BT_B2H_ATN);		/* some BMCs are stubborn */
 	BT_CONTROL(BT_CLR_RD_PTR);	/* always reset */
 	if (bt_debug)
-		printk(KERN_WARNING "IPMI BT: stale response %s; ",
-			status2txt(BT_STATUS));
+		pr_warn("IPMI BT: stale response %s; ", status2txt(BT_STATUS));
 	size = BMC2HOST;
 	for (i = 0; i < size ; i++)
 		BMC2HOST;
 	BT_CONTROL(BT_H_BUSY);		/* now clear */
 	if (bt_debug)
-		printk("drained %d bytes\n", size + 1);
+		pr_cont("drained %d bytes\n", size + 1);
 }
 
 static inline void write_all_bytes(struct si_sm_data *bt)
@@ -322,11 +320,11 @@ static inline void write_all_bytes(struct si_sm_data *bt)
 	int i;
 
 	if (bt_debug & BT_DEBUG_MSG) {
-		printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
+		pr_warn("BT: write %d bytes seq=0x%02X",
 			bt->write_count, bt->seq);
 		for (i = 0; i < bt->write_count; i++)
-			printk(" %02x", bt->write_data[i]);
-		printk("\n");
+			pr_cont(" %02x", bt->write_data[i]);
+		pr_cont("\n");
 	}
 	for (i = 0; i < bt->write_count; i++)
 		HOST2BMC(bt->write_data[i]);
@@ -346,8 +344,7 @@ static inline int read_all_bytes(struct si_sm_data *bt)
 
 	if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) {
 		if (bt_debug & BT_DEBUG_MSG)
-			printk(KERN_WARNING "BT: bad raw rsp len=%d\n",
-				bt->read_count);
+			pr_warn("BT: bad raw rsp len=%d\n", bt->read_count);
 		bt->truncated = 1;
 		return 1;	/* let next XACTION START clean it up */
 	}
@@ -358,13 +355,12 @@ static inline int read_all_bytes(struct si_sm_data *bt)
 	if (bt_debug & BT_DEBUG_MSG) {
 		int max = bt->read_count;
 
-		printk(KERN_WARNING "BT: got %d bytes seq=0x%02X",
-			max, bt->read_data[2]);
+		pr_warn("BT: got %d bytes seq=0x%02X", max, bt->read_data[2]);
 		if (max > 16)
 			max = 16;
 		for (i = 0; i < max; i++)
-			printk(KERN_CONT " %02x", bt->read_data[i]);
-		printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ...");
+			pr_cont(" %02x", bt->read_data[i]);
+		pr_cont("%s\n", bt->read_count == max ? "" : " ...");
 	}
 
 	/* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
@@ -374,10 +370,10 @@ static inline int read_all_bytes(struct si_sm_data *bt)
 			return 1;
 
 	if (bt_debug & BT_DEBUG_MSG)
-		printk(KERN_WARNING "IPMI BT: bad packet: "
-		"want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
-		bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3],
-		bt->read_data[1],  bt->read_data[2],  bt->read_data[3]);
+		pr_warn("IPMI BT: bad packet: want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
+			bt->write_data[1] | 0x04, bt->write_data[2],
+			bt->write_data[3],
+			bt->read_data[1],  bt->read_data[2],  bt->read_data[3]);
 	return 0;
 }
 
@@ -400,7 +396,7 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
 		break;
 	}
 
-	printk(KERN_WARNING "IPMI BT: %s in %s %s ", 	/* open-ended line */
+	pr_warn("IPMI BT: %s in %s %s ", 	/* open-ended line */
 		reason, STATE2TXT, STATUS2TXT);
 
 	/*
@@ -409,20 +405,20 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
 	 */
 	(bt->error_retries)++;
 	if (bt->error_retries < bt->BT_CAP_retries) {
-		printk("%d retries left\n",
+		pr_cont("%d retries left\n",
 			bt->BT_CAP_retries - bt->error_retries);
 		bt->state = BT_STATE_RESTART;
 		return SI_SM_CALL_WITHOUT_DELAY;
 	}
 
-	printk(KERN_WARNING "failed %d retries, sending error response\n",
-	       bt->BT_CAP_retries);
+	pr_warn("failed %d retries, sending error response\n",
+		bt->BT_CAP_retries);
 	if (!bt->nonzero_status)
-		printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
+		pr_err("IPMI BT: stuck, try power cycle\n");
 
 	/* this is most likely during insmod */
 	else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) {
-		printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n");
+		pr_warn("IPMI: BT reset (takes 5 secs)\n");
 		bt->state = BT_STATE_RESET1;
 		return SI_SM_CALL_WITHOUT_DELAY;
 	}
@@ -458,7 +454,7 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 	status = BT_STATUS;
 	bt->nonzero_status |= status;
 	if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
-		printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
+		pr_warn("BT: %s %s TO=%ld - %ld\n",
 			STATE2TXT,
 			STATUS2TXT,
 			bt->timeout,
@@ -636,10 +632,10 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 			bt->BT_CAP_req2rsp = BT_CAP[6] * USEC_PER_SEC;
 			bt->BT_CAP_retries = BT_CAP[7];
 		} else
-			printk(KERN_WARNING "IPMI BT: using default values\n");
+			pr_warn("IPMI BT: using default values\n");
 		if (!bt->BT_CAP_outreqs)
 			bt->BT_CAP_outreqs = 1;
-		printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n",
+		pr_warn("IPMI BT: req2rsp=%ld secs retries=%d\n",
 			bt->BT_CAP_req2rsp / USEC_PER_SEC, bt->BT_CAP_retries);
 		bt->timeout = bt->BT_CAP_req2rsp;
 		return SI_SM_CALL_WITHOUT_DELAY;
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index 1a486aec99b6..effab11887ca 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -818,8 +818,7 @@ static void ipmi_new_smi(int if_num, struct device *device)
 
 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 	if (!entry) {
-		printk(KERN_ERR "ipmi_devintf: Unable to create the"
-		       " ipmi class device link\n");
+		pr_err("ipmi_devintf: Unable to create the ipmi class device link\n");
 		return;
 	}
 	entry->dev = dev;
@@ -861,18 +860,18 @@ static int __init init_ipmi_devintf(void)
 	if (ipmi_major < 0)
 		return -EINVAL;
 
-	printk(KERN_INFO "ipmi device interface\n");
+	pr_info("ipmi device interface\n");
 
 	ipmi_class = class_create(THIS_MODULE, "ipmi");
 	if (IS_ERR(ipmi_class)) {
-		printk(KERN_ERR "ipmi: can't register device class\n");
+		pr_err("ipmi: can't register device class\n");
 		return PTR_ERR(ipmi_class);
 	}
 
 	rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
 	if (rv < 0) {
 		class_destroy(ipmi_class);
-		printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
+		pr_err("ipmi: can't get major %d\n", ipmi_major);
 		return rv;
 	}
 
@@ -884,7 +883,7 @@ static int __init init_ipmi_devintf(void)
 	if (rv) {
 		unregister_chrdev(ipmi_major, DEVICE_NAME);
 		class_destroy(ipmi_class);
-		printk(KERN_WARNING "ipmi: can't register smi watcher\n");
+		pr_warn("ipmi: can't register smi watcher\n");
 		return rv;
 	}
 
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index f4ea9f47230a..2e7cda08b079 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -274,8 +274,8 @@ static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
 	if (kcs_debug & KCS_DEBUG_MSG) {
 		printk(KERN_DEBUG "start_kcs_transaction -");
 		for (i = 0; i < size; i++)
-			printk(" %02x", (unsigned char) (data [i]));
-		printk("\n");
+			pr_cont(" %02x", data[i]);
+		pr_cont("\n");
 	}
 	kcs->error_retries = 0;
 	memcpy(kcs->write_data, data, size);
diff --git a/drivers/char/ipmi/ipmi_smic_sm.c b/drivers/char/ipmi/ipmi_smic_sm.c
index 466a5aac5298..b6225bba2532 100644
--- a/drivers/char/ipmi/ipmi_smic_sm.c
+++ b/drivers/char/ipmi/ipmi_smic_sm.c
@@ -132,8 +132,8 @@ static int start_smic_transaction(struct si_sm_data *smic,
 	if (smic_debug & SMIC_DEBUG_MSG) {
 		printk(KERN_DEBUG "start_smic_transaction -");
 		for (i = 0; i < size; i++)
-			printk(" %02x", (unsigned char) data[i]);
-		printk("\n");
+			pr_cont(" %02x", data[i]);
+		pr_cont("\n");
 	}
 	smic->error_retries = 0;
 	memcpy(smic->write_data, data, size);
@@ -154,8 +154,8 @@ static int smic_get_result(struct si_sm_data *smic,
 	if (smic_debug & SMIC_DEBUG_MSG) {
 		printk(KERN_DEBUG "smic_get result -");
 		for (i = 0; i < smic->read_pos; i++)
-			printk(" %02x", smic->read_data[i]);
-		printk("\n");
+			pr_cont(" %02x", smic->read_data[i]);
+		pr_cont("\n");
 	}
 	if (length < smic->read_pos) {
 		smic->read_pos = length;
@@ -212,8 +212,7 @@ static inline void start_error_recovery(struct si_sm_data *smic, char *reason)
 	(smic->error_retries)++;
 	if (smic->error_retries > SMIC_MAX_ERROR_RETRIES) {
 		if (smic_debug & SMIC_DEBUG_ENABLE)
-			printk(KERN_WARNING
-			       "ipmi_smic_drv: smic hosed: %s\n", reason);
+			pr_warn("ipmi_smic_drv: smic hosed: %s\n", reason);
 		smic->state = SMIC_HOSED;
 	} else {
 		smic->write_count = smic->orig_write_count;
@@ -326,8 +325,7 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 	if (smic->state != SMIC_IDLE) {
 		if (smic_debug & SMIC_DEBUG_STATES)
 			printk(KERN_DEBUG
-			       "smic_event - smic->smic_timeout = %ld,"
-			       " time = %ld\n",
+			       "smic_event - smic->smic_timeout = %ld, time = %ld\n",
 			       smic->smic_timeout, time);
 		/*
 		 * FIXME: smic_event is sometimes called with time >
@@ -347,9 +345,7 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 
 	status = read_smic_status(smic);
 	if (smic_debug & SMIC_DEBUG_STATES)
-		printk(KERN_DEBUG
-		       "smic_event - state = %d, flags = 0x%02x,"
-		       " status = 0x%02x\n",
+		printk(KERN_DEBUG "smic_event - state = %d, flags = 0x%02x, status = 0x%02x\n",
 		       smic->state, flags, status);
 
 	switch (smic->state) {
@@ -440,8 +436,8 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 		data = read_smic_data(smic);
 		if (data != 0) {
 			if (smic_debug & SMIC_DEBUG_ENABLE)
-				printk(KERN_DEBUG
-				       "SMIC_WRITE_END: data = %02x\n", data);
+				printk(KERN_DEBUG "SMIC_WRITE_END: data = %02x\n",
+				       data);
 			start_error_recovery(smic,
 					     "state = SMIC_WRITE_END, "
 					     "data != SUCCESS");
@@ -520,8 +516,8 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 		/* data register holds an error code */
 		if (data != 0) {
 			if (smic_debug & SMIC_DEBUG_ENABLE)
-				printk(KERN_DEBUG
-				       "SMIC_READ_END: data = %02x\n", data);
+				printk(KERN_DEBUG "SMIC_READ_END: data = %02x\n",
+				       data);
 			start_error_recovery(smic,
 					     "state = SMIC_READ_END, "
 					     "data != SUCCESS");
-- 
2.15.0

[PATCH 6/6] infiniband: qplib_fp: Use dev_fmt

[Joe Perches]

Convert the embedded dev_<level> uses to use the new dev_fmt
prefix and remove the prefix from the formats.

Miscellanea:

o Add missing terminating newlines to avoid possible interleaving
o Realign arguments

Signed-off-by: Joe Perches <joe@perches.com>
---
 drivers/infiniband/hw/bnxt_re/qplib_fp.c | 125 ++++++++++++++-----------------
 1 file changed, 57 insertions(+), 68 deletions(-)

diff --git a/drivers/infiniband/hw/bnxt_re/qplib_fp.c b/drivers/infiniband/hw/bnxt_re/qplib_fp.c
index 3a78faba8d91..cbe6dbea9ab6 100644
--- a/drivers/infiniband/hw/bnxt_re/qplib_fp.c
+++ b/drivers/infiniband/hw/bnxt_re/qplib_fp.c
@@ -36,6 +36,8 @@
  * Description: Fast Path Operators
  */
 
+#define dev_fmt(fmt) "QPLIB: " fmt
+
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/sched.h>
@@ -70,8 +72,7 @@ static void __bnxt_qplib_add_flush_qp(struct bnxt_qplib_qp *qp)
 	rcq = qp->rcq;
 
 	if (!qp->sq.flushed) {
-		dev_dbg(&scq->hwq.pdev->dev,
-			"QPLIB: FP: Adding to SQ Flush list = %p",
+		dev_dbg(&scq->hwq.pdev->dev, "FP: Adding to SQ Flush list = %p\n",
 			qp);
 		bnxt_qplib_cancel_phantom_processing(qp);
 		list_add_tail(&qp->sq_flush, &scq->sqf_head);
@@ -79,8 +80,7 @@ static void __bnxt_qplib_add_flush_qp(struct bnxt_qplib_qp *qp)
 	}
 	if (!qp->srq) {
 		if (!qp->rq.flushed) {
-			dev_dbg(&rcq->hwq.pdev->dev,
-				"QPLIB: FP: Adding to RQ Flush list = %p",
+			dev_dbg(&rcq->hwq.pdev->dev, "FP: Adding to RQ Flush list = %p\n",
 				qp);
 			list_add_tail(&qp->rq_flush, &rcq->rqf_head);
 			qp->rq.flushed = true;
@@ -161,7 +161,7 @@ static void bnxt_qpn_cqn_sched_task(struct work_struct *work)
 		spin_lock_bh(&cq->compl_lock);
 		if (atomic_read(&cq->arm_state) && nq->cqn_handler) {
 			dev_dbg(&nq->pdev->dev,
-				"%s:Trigger cq  = %p event nq = %p\n",
+				"%s: Trigger cq  = %p event nq = %p\n",
 				__func__, cq, nq);
 			nq->cqn_handler(nq, cq);
 		}
@@ -206,8 +206,7 @@ static int bnxt_qplib_alloc_qp_hdr_buf(struct bnxt_qplib_res *res,
 					&qp->sq_hdr_buf_map, GFP_KERNEL);
 		if (!qp->sq_hdr_buf) {
 			rc = -ENOMEM;
-			dev_err(&res->pdev->dev,
-				"QPLIB: Failed to create sq_hdr_buf");
+			dev_err(&res->pdev->dev, "Failed to create sq_hdr_buf\n");
 			goto fail;
 		}
 	}
@@ -220,8 +219,7 @@ static int bnxt_qplib_alloc_qp_hdr_buf(struct bnxt_qplib_res *res,
 						    GFP_KERNEL);
 		if (!qp->rq_hdr_buf) {
 			rc = -ENOMEM;
-			dev_err(&res->pdev->dev,
-				"QPLIB: Failed to create rq_hdr_buf");
+			dev_err(&res->pdev->dev, "Failed to create rq_hdr_buf\n");
 			goto fail;
 		}
 	}
@@ -276,8 +274,7 @@ static void bnxt_qplib_service_nq(unsigned long data)
 			if (!nq->cqn_handler(nq, (cq)))
 				num_cqne_processed++;
 			else
-				dev_warn(&nq->pdev->dev,
-					 "QPLIB: cqn - type 0x%x not handled",
+				dev_warn(&nq->pdev->dev, "cqn - type 0x%x not handled\n",
 					 type);
 			spin_unlock_bh(&cq->compl_lock);
 			break;
@@ -297,16 +294,14 @@ static void bnxt_qplib_service_nq(unsigned long data)
 					      nqsrqe->event))
 				num_srqne_processed++;
 			else
-				dev_warn(&nq->pdev->dev,
-					 "QPLIB: SRQ event 0x%x not handled",
+				dev_warn(&nq->pdev->dev, "SRQ event 0x%x not handled\n",
 					 nqsrqe->event);
 			break;
 		}
 		case NQ_BASE_TYPE_DBQ_EVENT:
 			break;
 		default:
-			dev_warn(&nq->pdev->dev,
-				 "QPLIB: nqe with type = 0x%x not handled",
+			dev_warn(&nq->pdev->dev, "nqe with type = 0x%x not handled\n",
 				 type);
 			break;
 		}
@@ -393,7 +388,7 @@ int bnxt_qplib_enable_nq(struct pci_dev *pdev, struct bnxt_qplib_nq *nq,
 	rc = request_irq(nq->vector, bnxt_qplib_nq_irq, 0, nq->name, nq);
 	if (rc) {
 		dev_err(&nq->pdev->dev,
-			"Failed to request IRQ for NQ: %#x", rc);
+			"Failed to request IRQ for NQ: %#x\n", rc);
 		goto fail;
 	}
 
@@ -401,8 +396,7 @@ int bnxt_qplib_enable_nq(struct pci_dev *pdev, struct bnxt_qplib_nq *nq,
 	cpumask_set_cpu(nq_idx, &nq->mask);
 	rc = irq_set_affinity_hint(nq->vector, &nq->mask);
 	if (rc) {
-		dev_warn(&nq->pdev->dev,
-			 "QPLIB: set affinity failed; vector: %d nq_idx: %d\n",
+		dev_warn(&nq->pdev->dev, "set affinity failed; vector: %d nq_idx: %d\n",
 			 nq->vector, nq_idx);
 	}
 
@@ -636,7 +630,7 @@ int bnxt_qplib_post_srq_recv(struct bnxt_qplib_srq *srq,
 
 	spin_lock(&srq_hwq->lock);
 	if (srq->start_idx == srq->last_idx) {
-		dev_err(&srq_hwq->pdev->dev, "QPLIB: FP: SRQ (0x%x) is full!",
+		dev_err(&srq_hwq->pdev->dev, "FP: SRQ (0x%x) is full!\n",
 			srq->id);
 		rc = -EINVAL;
 		spin_unlock(&srq_hwq->lock);
@@ -1298,7 +1292,7 @@ int bnxt_qplib_query_qp(struct bnxt_qplib_res *res, struct bnxt_qplib_qp *qp)
 		}
 	}
 	if (i == res->sgid_tbl.max)
-		dev_warn(&res->pdev->dev, "QPLIB: SGID not found??");
+		dev_warn(&res->pdev->dev, "SGID not found??\n");
 
 	qp->ah.hop_limit = sb->hop_limit;
 	qp->ah.traffic_class = sb->traffic_class;
@@ -1502,7 +1496,7 @@ int bnxt_qplib_post_send(struct bnxt_qplib_qp *qp,
 		if (qp->state == CMDQ_MODIFY_QP_NEW_STATE_ERR) {
 			sch_handler = true;
 			dev_dbg(&sq->hwq.pdev->dev,
-				"%s Error QP. Scheduling for poll_cq\n",
+				"%s: Error QP. Scheduling for poll_cq\n",
 				__func__);
 			goto queue_err;
 		}
@@ -1510,7 +1504,7 @@ int bnxt_qplib_post_send(struct bnxt_qplib_qp *qp,
 
 	if (bnxt_qplib_queue_full(sq)) {
 		dev_err(&sq->hwq.pdev->dev,
-			"QPLIB: prod = %#x cons = %#x qdepth = %#x delta = %#x",
+			"prod = %#x cons = %#x qdepth = %#x delta = %#x\n",
 			sq->hwq.prod, sq->hwq.cons, sq->hwq.max_elements,
 			sq->q_full_delta);
 		rc = -ENOMEM;
@@ -1535,7 +1529,7 @@ int bnxt_qplib_post_send(struct bnxt_qplib_qp *qp,
 		/* Copy the inline data */
 		if (wqe->inline_len > BNXT_QPLIB_SWQE_MAX_INLINE_LENGTH) {
 			dev_warn(&sq->hwq.pdev->dev,
-				 "QPLIB: Inline data length > 96 detected");
+				 "Inline data length > 96 detected\n");
 			data_len = BNXT_QPLIB_SWQE_MAX_INLINE_LENGTH;
 		} else {
 			data_len = wqe->inline_len;
@@ -1750,7 +1744,7 @@ int bnxt_qplib_post_send(struct bnxt_qplib_qp *qp,
 			queue_work(qp->scq->nq->cqn_wq, &nq_work->work);
 		} else {
 			dev_err(&sq->hwq.pdev->dev,
-				"QPLIB: FP: Failed to allocate SQ nq_work!");
+				"FP: Failed to allocate SQ nq_work!\n");
 			rc = -ENOMEM;
 		}
 	}
@@ -1789,13 +1783,13 @@ int bnxt_qplib_post_recv(struct bnxt_qplib_qp *qp,
 	if (qp->state == CMDQ_MODIFY_QP_NEW_STATE_ERR) {
 		sch_handler = true;
 		dev_dbg(&rq->hwq.pdev->dev,
-			"%s Error QP. Scheduling for poll_cq\n",
+			"%s: Error QP. Scheduling for poll_cq\n",
 			__func__);
 		goto queue_err;
 	}
 	if (bnxt_qplib_queue_full(rq)) {
-		dev_err(&rq->hwq.pdev->dev,
-			"QPLIB: FP: QP (0x%x) RQ is full!", qp->id);
+		dev_err(&rq->hwq.pdev->dev, "FP: QP (0x%x) RQ is full!\n",
+			qp->id);
 		rc = -EINVAL;
 		goto done;
 	}
@@ -1844,7 +1838,7 @@ int bnxt_qplib_post_recv(struct bnxt_qplib_qp *qp,
 			queue_work(qp->rcq->nq->cqn_wq, &nq_work->work);
 		} else {
 			dev_err(&rq->hwq.pdev->dev,
-				"QPLIB: FP: Failed to allocate RQ nq_work!");
+				"FP: Failed to allocate RQ nq_work!\n");
 			rc = -ENOMEM;
 		}
 	}
@@ -1906,7 +1900,7 @@ int bnxt_qplib_create_cq(struct bnxt_qplib_res *res, struct bnxt_qplib_cq *cq)
 
 	if (!cq->dpi) {
 		dev_err(&rcfw->pdev->dev,
-			"QPLIB: FP: CREATE_CQ failed due to NULL DPI");
+			"FP: CREATE_CQ failed due to NULL DPI\n");
 		return -EINVAL;
 	}
 	req.dpi = cpu_to_le32(cq->dpi->dpi);
@@ -2146,7 +2140,7 @@ static int do_wa9060(struct bnxt_qplib_qp *qp, struct bnxt_qplib_cq *cq,
 						 *  comes back
 						 */
 						dev_dbg(&cq->hwq.pdev->dev,
-							"FP:Got Phantom CQE");
+							"FP:Got Phantom CQE\n");
 						sq->condition = false;
 						sq->single = true;
 						rc = 0;
@@ -2163,7 +2157,7 @@ static int do_wa9060(struct bnxt_qplib_qp *qp, struct bnxt_qplib_cq *cq,
 			peek_raw_cq_cons++;
 		}
 		dev_err(&cq->hwq.pdev->dev,
-			"Should not have come here! cq_cons=0x%x qp=0x%x sq cons sw=0x%x hw=0x%x",
+			"Should not have come here! cq_cons=0x%x qp=0x%x sq cons sw=0x%x hw=0x%x\n",
 			cq_cons, qp->id, sw_sq_cons, cqe_sq_cons);
 		rc = -EINVAL;
 	}
@@ -2186,18 +2180,15 @@ static int bnxt_qplib_cq_process_req(struct bnxt_qplib_cq *cq,
 	qp = (struct bnxt_qplib_qp *)((unsigned long)
 				      le64_to_cpu(hwcqe->qp_handle));
 	if (!qp) {
-		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: FP: Process Req qp is NULL");
+		dev_err(&cq->hwq.pdev->dev, "FP: Process Req qp is NULL\n");
 		return -EINVAL;
 	}
 	sq = &qp->sq;
 
 	cqe_sq_cons = HWQ_CMP(le16_to_cpu(hwcqe->sq_cons_idx), &sq->hwq);
 	if (cqe_sq_cons > sq->hwq.max_elements) {
-		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: FP: CQ Process req reported ");
-		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: sq_cons_idx 0x%x which exceeded max 0x%x",
+		dev_err(&cq->hwq.pdev->dev, "FP: CQ Process req reported\n");
+		dev_err(&cq->hwq.pdev->dev, "sq_cons_idx 0x%x which exceeded max 0x%x\n",
 			cqe_sq_cons, sq->hwq.max_elements);
 		return -EINVAL;
 	}
@@ -2236,9 +2227,9 @@ static int bnxt_qplib_cq_process_req(struct bnxt_qplib_cq *cq,
 		    hwcqe->status != CQ_REQ_STATUS_OK) {
 			cqe->status = hwcqe->status;
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Processed Req ");
+				"FP: CQ Processed Req\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: wr_id[%d] = 0x%llx with status 0x%x",
+				"wr_id[%d] = 0x%llx with status 0x%x\n",
 				sw_sq_cons, cqe->wr_id, cqe->status);
 			cqe++;
 			(*budget)--;
@@ -2304,7 +2295,7 @@ static int bnxt_qplib_cq_process_res_rc(struct bnxt_qplib_cq *cq,
 	qp = (struct bnxt_qplib_qp *)((unsigned long)
 				      le64_to_cpu(hwcqe->qp_handle));
 	if (!qp) {
-		dev_err(&cq->hwq.pdev->dev, "QPLIB: process_cq RC qp is NULL");
+		dev_err(&cq->hwq.pdev->dev, "process_cq RC qp is NULL\n");
 		return -EINVAL;
 	}
 	if (qp->rq.flushed) {
@@ -2330,9 +2321,9 @@ static int bnxt_qplib_cq_process_res_rc(struct bnxt_qplib_cq *cq,
 			return -EINVAL;
 		if (wr_id_idx > srq->hwq.max_elements) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Process RC ");
+				"FP: CQ Process RC\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: wr_id idx 0x%x exceeded SRQ max 0x%x",
+				"wr_id idx 0x%x exceeded SRQ max 0x%x\n",
 				wr_id_idx, srq->hwq.max_elements);
 			return -EINVAL;
 		}
@@ -2345,9 +2336,9 @@ static int bnxt_qplib_cq_process_res_rc(struct bnxt_qplib_cq *cq,
 		rq = &qp->rq;
 		if (wr_id_idx > rq->hwq.max_elements) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Process RC ");
+				"FP: CQ Process RC\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: wr_id idx 0x%x exceeded RQ max 0x%x",
+				"wr_id idx 0x%x exceeded RQ max 0x%x\n",
 				wr_id_idx, rq->hwq.max_elements);
 			return -EINVAL;
 		}
@@ -2383,7 +2374,7 @@ static int bnxt_qplib_cq_process_res_ud(struct bnxt_qplib_cq *cq,
 	qp = (struct bnxt_qplib_qp *)((unsigned long)
 				      le64_to_cpu(hwcqe->qp_handle));
 	if (!qp) {
-		dev_err(&cq->hwq.pdev->dev, "QPLIB: process_cq UD qp is NULL");
+		dev_err(&cq->hwq.pdev->dev, "process_cq UD qp is NULL\n");
 		return -EINVAL;
 	}
 	if (qp->rq.flushed) {
@@ -2413,9 +2404,9 @@ static int bnxt_qplib_cq_process_res_ud(struct bnxt_qplib_cq *cq,
 
 		if (wr_id_idx > srq->hwq.max_elements) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Process UD ");
+				"FP: CQ Process UD\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: wr_id idx 0x%x exceeded SRQ max 0x%x",
+				"wr_id idx 0x%x exceeded SRQ max 0x%x\n",
 				wr_id_idx, srq->hwq.max_elements);
 			return -EINVAL;
 		}
@@ -2428,9 +2419,9 @@ static int bnxt_qplib_cq_process_res_ud(struct bnxt_qplib_cq *cq,
 		rq = &qp->rq;
 		if (wr_id_idx > rq->hwq.max_elements) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Process UD ");
+				"FP: CQ Process UD\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: wr_id idx 0x%x exceeded RQ max 0x%x",
+				"wr_id idx 0x%x exceeded RQ max 0x%x\n",
 				wr_id_idx, rq->hwq.max_elements);
 			return -EINVAL;
 		}
@@ -2483,7 +2474,7 @@ static int bnxt_qplib_cq_process_res_raweth_qp1(struct bnxt_qplib_cq *cq,
 				      le64_to_cpu(hwcqe->qp_handle));
 	if (!qp) {
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: process_cq Raw/QP1 qp is NULL");
+			"process_cq Raw/QP1 qp is NULL\n");
 		return -EINVAL;
 	}
 	if (qp->rq.flushed) {
@@ -2517,14 +2508,14 @@ static int bnxt_qplib_cq_process_res_raweth_qp1(struct bnxt_qplib_cq *cq,
 		srq = qp->srq;
 		if (!srq) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: SRQ used but not defined??");
+				"FP: SRQ used but not defined??\n");
 			return -EINVAL;
 		}
 		if (wr_id_idx > srq->hwq.max_elements) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Process Raw/QP1 ");
+				"FP: CQ Process Raw/QP1\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: wr_id idx 0x%x exceeded SRQ max 0x%x",
+				"wr_id idx 0x%x exceeded SRQ max 0x%x\n",
 				wr_id_idx, srq->hwq.max_elements);
 			return -EINVAL;
 		}
@@ -2537,9 +2528,9 @@ static int bnxt_qplib_cq_process_res_raweth_qp1(struct bnxt_qplib_cq *cq,
 		rq = &qp->rq;
 		if (wr_id_idx > rq->hwq.max_elements) {
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: FP: CQ Process Raw/QP1 RQ wr_id ");
+				"FP: CQ Process Raw/QP1 RQ wr_id\n");
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: ix 0x%x exceeded RQ max 0x%x",
+				"ix 0x%x exceeded RQ max 0x%x\n",
 				wr_id_idx, rq->hwq.max_elements);
 			return -EINVAL;
 		}
@@ -2574,14 +2565,14 @@ static int bnxt_qplib_cq_process_terminal(struct bnxt_qplib_cq *cq,
 	/* Check the Status */
 	if (hwcqe->status != CQ_TERMINAL_STATUS_OK)
 		dev_warn(&cq->hwq.pdev->dev,
-			 "QPLIB: FP: CQ Process Terminal Error status = 0x%x",
+			 "FP: CQ Process Terminal Error status = 0x%x\n",
 			 hwcqe->status);
 
 	qp = (struct bnxt_qplib_qp *)((unsigned long)
 				      le64_to_cpu(hwcqe->qp_handle));
 	if (!qp) {
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: FP: CQ Process terminal qp is NULL");
+			"FP: CQ Process terminal qp is NULL\n");
 		return -EINVAL;
 	}
 
@@ -2597,9 +2588,9 @@ static int bnxt_qplib_cq_process_terminal(struct bnxt_qplib_cq *cq,
 
 	if (cqe_cons > sq->hwq.max_elements) {
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: FP: CQ Process terminal reported ");
+			"FP: CQ Process terminal reported\n");
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: sq_cons_idx 0x%x which exceeded max 0x%x",
+			"sq_cons_idx 0x%x which exceeded max 0x%x\n",
 			cqe_cons, sq->hwq.max_elements);
 		goto do_rq;
 	}
@@ -2647,9 +2638,9 @@ static int bnxt_qplib_cq_process_terminal(struct bnxt_qplib_cq *cq,
 		goto done;
 	} else if (cqe_cons > rq->hwq.max_elements) {
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: FP: CQ Processed terminal ");
+			"FP: CQ Processed terminal\n");
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: reported rq_cons_idx 0x%x exceeds max 0x%x",
+			"reported rq_cons_idx 0x%x exceeds max 0x%x\n",
 			cqe_cons, rq->hwq.max_elements);
 		goto done;
 	}
@@ -2678,7 +2669,7 @@ static int bnxt_qplib_cq_process_cutoff(struct bnxt_qplib_cq *cq,
 	/* Check the Status */
 	if (hwcqe->status != CQ_CUTOFF_STATUS_OK) {
 		dev_err(&cq->hwq.pdev->dev,
-			"QPLIB: FP: CQ Process Cutoff Error status = 0x%x",
+			"FP: CQ Process Cutoff Error status = 0x%x\n",
 			hwcqe->status);
 		return -EINVAL;
 	}
@@ -2699,15 +2690,13 @@ int bnxt_qplib_process_flush_list(struct bnxt_qplib_cq *cq,
 	spin_lock_irqsave(&cq->flush_lock, flags);
 	list_for_each_entry(qp, &cq->sqf_head, sq_flush) {
 		dev_dbg(&cq->hwq.pdev->dev,
-			"QPLIB: FP: Flushing SQ QP= %p",
-			qp);
+			"FP: Flushing SQ QP= %p\n", qp);
 		__flush_sq(&qp->sq, qp, &cqe, &budget);
 	}
 
 	list_for_each_entry(qp, &cq->rqf_head, rq_flush) {
 		dev_dbg(&cq->hwq.pdev->dev,
-			"QPLIB: FP: Flushing RQ QP= %p",
-			qp);
+			"FP: Flushing RQ QP= %p\n", qp);
 		__flush_rq(&qp->rq, qp, &cqe, &budget);
 	}
 	spin_unlock_irqrestore(&cq->flush_lock, flags);
@@ -2775,7 +2764,7 @@ int bnxt_qplib_poll_cq(struct bnxt_qplib_cq *cq, struct bnxt_qplib_cqe *cqe,
 			goto exit;
 		default:
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: process_cq unknown type 0x%lx",
+				"process_cq unknown type 0x%lx\n",
 				hw_cqe->cqe_type_toggle &
 				CQ_BASE_CQE_TYPE_MASK);
 			rc = -EINVAL;
@@ -2788,7 +2777,7 @@ int bnxt_qplib_poll_cq(struct bnxt_qplib_cq *cq, struct bnxt_qplib_cqe *cqe,
 			 * next one
 			 */
 			dev_err(&cq->hwq.pdev->dev,
-				"QPLIB: process_cqe error rc = 0x%x", rc);
+				"process_cqe error rc = 0x%x\n", rc);
 		}
 		raw_cons++;
 	}
-- 
2.15.0

Re: [PATCH 6/6] infiniband: qplib_fp: Use dev_fmt

[Doug Ledford]

[-- Attachment #1: Type: text/plain, Size: 595 bytes --]

On Wed, 2018-05-09 at 08:15 -0700, Joe Perches wrote:
> Convert the embedded dev_<level> uses to use the new dev_fmt
> prefix and remove the prefix from the formats.
> 
> Miscellanea:
> 
> o Add missing terminating newlines to avoid possible interleaving
> o Realign arguments
> 
> Signed-off-by: Joe Perches <joe@perches.com>

I don't see any problem with this patch.  For the IB part:

Acked-by: Doug Ledford <dledford@redhat.com>

-- 
Doug Ledford <dledford@redhat.com>
    GPG KeyID: B826A3330E572FDD
    Key fingerprint = AE6B 1BDA 122B 23B4 265B  1274 B826 A333 0E57 2FDD

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 6/6] infiniband: qplib_fp: Use dev_fmt

[Selvin Xavier]

On Tue, May 15, 2018 at 8:10 PM, Doug Ledford <dledford@redhat.com> wrote:
> On Wed, 2018-05-09 at 08:15 -0700, Joe Perches wrote:
>> Convert the embedded dev_<level> uses to use the new dev_fmt
>> prefix and remove the prefix from the formats.
>>
>> Miscellanea:
>>
>> o Add missing terminating newlines to avoid possible interleaving
>> o Realign arguments
>>
>> Signed-off-by: Joe Perches <joe@perches.com>
>
> I don't see any problem with this patch.  For the IB part:
>
> Acked-by: Doug Ledford <dledford@redhat.com>
>
>
Acked-by: Selvin Xavier <selvin.xavier@broadcom.com>

Re: [PATCH 0/6] treewide: Add and use dev_fmt similar to pr_fmt

[Corey Minyard]

On 05/09/2018 10:15 AM, Joe Perches wrote:
> The pr_fmt mechanism exists for pr_<level> logging message prefixing,
> but no similar capability exists for dev_<level> message prefixing.
>
> Many uses of dev_<level> have an embedded prefix for logging output.
>
> So add a similar dev_fmt macro that can automatically prefix the
> dev_<level> logging output.
>
> Rename the existing dev_<level> functions to _dev_<level> and add new
> macros that call _dev_<level> with the desired prefix if defined.
>
> The new default #define for dev_fmt is blank.
>
> Convert ipmi and infiniband to use this mechanism.

The IPMI changes look good to me.

There are some conflicts with a patch I have pulling out the proc 
interface that is
destined for 3.18.  I can take the IPMI changes into my tree, if you want.

Thanks,

-corey

> Miscellanea:
>
> o x86/early-quirks uses an internal macro for #define dev_err which conflicts
>   with the existing dev_err macro, so rename it.
>
> Joe Perches (6):
>    x86/early-quirks: Rename duplicate define of dev_err
>    device: Add #define dev_fmt similar to #define pr_fmt
>    ipmi: msghandler: Add and use pr_fmt and dev_fmt, remove PFX
>    ipmi: Use more common logging styles
>    ipmi: Convert printk(KERN_<level> to pr_<level>(
>    infiniband: qplib_fp: Use dev_fmt
>
>   arch/x86/kernel/early-quirks.c           |   8 +-
>   drivers/base/core.c                      |  12 +--
>   drivers/char/ipmi/ipmi_bt_sm.c           |  64 ++++++++--------
>   drivers/char/ipmi/ipmi_devintf.c         |  11 ++-
>   drivers/char/ipmi/ipmi_kcs_sm.c          |   4 +-
>   drivers/char/ipmi/ipmi_msghandler.c      |  53 +++++++------
>   drivers/char/ipmi/ipmi_poweroff.c        |  67 ++++++++---------
>   drivers/char/ipmi/ipmi_si_hardcode.c     |   9 ++-
>   drivers/char/ipmi/ipmi_si_hotmod.c       |  17 +++--
>   drivers/char/ipmi/ipmi_si_intf.c         |  22 +++---
>   drivers/char/ipmi/ipmi_si_pci.c          |  12 +--
>   drivers/char/ipmi/ipmi_si_platform.c     |  20 ++---
>   drivers/char/ipmi/ipmi_smic_sm.c         |  26 +++----
>   drivers/char/ipmi/ipmi_ssif.c            |  73 +++++++++---------
>   drivers/char/ipmi/ipmi_watchdog.c        |  52 +++++++------
>   drivers/infiniband/hw/bnxt_re/qplib_fp.c | 125 ++++++++++++++-----------------
>   include/linux/device.h                   | 103 ++++++++++++++-----------
>   17 files changed, 330 insertions(+), 348 deletions(-)
>

Re: [PATCH 0/6] treewide: Add and use dev_fmt similar to pr_fmt

[Joe Perches]

On Wed, 2018-05-09 at 11:47 -0500, Corey Minyard wrote:
> On 05/09/2018 10:15 AM, Joe Perches wrote:
> > The pr_fmt mechanism exists for pr_<level> logging message prefixing,
> > but no similar capability exists for dev_<level> message prefixing.
> > 
> > Many uses of dev_<level> have an embedded prefix for logging output.
> > 
> > So add a similar dev_fmt macro that can automatically prefix the
> > dev_<level> logging output.
> > 
> > Rename the existing dev_<level> functions to _dev_<level> and add new
> > macros that call _dev_<level> with the desired prefix if defined.
> > 
> > The new default #define for dev_fmt is blank.
> > 
> > Convert ipmi and infiniband to use this mechanism.
> 
> The IPMI changes look good to me.

Oh good.

> There are some conflicts with a patch I have pulling out the proc 
> interface that is destined for 3.18.

I'm sure you mean 4.18.

> I can take the IPMI changes into my tree, if you want.

These patches are not at all urgent and were done
on top of next-20180509.

As there are dependencies between the patch that
introduces dev_fmt and the reset of the patches,
I think it makes sense to take these as a single
patchset rather than take parts into various trees.

Respinning the IPMI patches is trivial and can be
done whenever appropriate.

When do you expect your IPMI patches to hit -next?

Re: [PATCH 0/6] treewide: Add and use dev_fmt similar to pr_fmt

[Corey Minyard]

On 05/09/2018 12:04 PM, Joe Perches wrote:
> On Wed, 2018-05-09 at 11:47 -0500, Corey Minyard wrote:
>> On 05/09/2018 10:15 AM, Joe Perches wrote:
>>> The pr_fmt mechanism exists for pr_<level> logging message prefixing,
>>> but no similar capability exists for dev_<level> message prefixing.
>>>
>>> Many uses of dev_<level> have an embedded prefix for logging output.
>>>
>>> So add a similar dev_fmt macro that can automatically prefix the
>>> dev_<level> logging output.
>>>
>>> Rename the existing dev_<level> functions to _dev_<level> and add new
>>> macros that call _dev_<level> with the desired prefix if defined.
>>>
>>> The new default #define for dev_fmt is blank.
>>>
>>> Convert ipmi and infiniband to use this mechanism.
>> The IPMI changes look good to me.
> Oh good.
>
>> There are some conflicts with a patch I have pulling out the proc
>> interface that is destined for 3.18.
> I'm sure you mean 4.18.

Oops, yes :).  I was just looking at a 3.x kernel and it stuck in my brain.

>> I can take the IPMI changes into my tree, if you want.
> These patches are not at all urgent and were done
> on top of next-20180509.
>
> As there are dependencies between the patch that
> introduces dev_fmt and the reset of the patches,
> I think it makes sense to take these as a single
> patchset rather than take parts into various trees.

The dependency isn't hard, the changes work without dev_fmt,
it just won't print the prefix.  But I'm fine with you keeping
them.

>
> Respinning the IPMI patches is trivial and can be
> done whenever appropriate.
>
> When do you expect your IPMI patches to hit -next?
>
I went ahead and pulled it in now, it's been tested well enough
in my tree.

For patches 3, 4, and 5:

Acked-by: Corey Minyard <cminyard@mvista.com>