diff mbox

[RFC,v3,2/3] qemu-error: Implement a more generic error reporting

Message ID 2c9645b5dce991f7a324dc2b61e2553e08230a9f.1499276048.git.alistair.francis@xilinx.com (mailing list archive)
State New, archived
Headers show

Commit Message

Alistair Francis July 5, 2017, 5:36 p.m. UTC
This patch converts the existing error_vreport() function into a generic
qmesg_vreport() function that takes an enum describing the
information to be reported.

As part of this change a new qmesg_report() function is added as well with the
same capability.

To maintain full compatibility the original error_report() function is
maintained and no changes to the way errors are printed have been made.
To improve access to the new informaiton and warning options wrapper functions
similar to error_report() have been added for warnings and information
printing.

Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
---
RFC V3:
 - Change the function and enum names to be more descriptive
 - Add wrapper functions for *_report() and *_vreport()

 include/qemu/error-report.h | 16 +++++++++
 scripts/checkpatch.pl       |  8 ++++-
 util/qemu-error.c           | 80 +++++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 100 insertions(+), 4 deletions(-)

Comments

Thomas Huth July 6, 2017, 2:42 a.m. UTC | #1
On 05.07.2017 19:36, Alistair Francis wrote:
> This patch converts the existing error_vreport() function into a generic
> qmesg_vreport() function that takes an enum describing the

s/qmesg/qmsg/

> information to be reported.
> 
> As part of this change a new qmesg_report() function is added as well with the

s/qmesg/qmsg/

> same capability.
> 
> To maintain full compatibility the original error_report() function is
> maintained and no changes to the way errors are printed have been made.
> To improve access to the new informaiton and warning options wrapper functions

s/informaition/information/

> similar to error_report() have been added for warnings and information
> printing.
> 
> Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
> ---
> RFC V3:
>  - Change the function and enum names to be more descriptive
>  - Add wrapper functions for *_report() and *_vreport()
> 
>  include/qemu/error-report.h | 16 +++++++++
>  scripts/checkpatch.pl       |  8 ++++-
>  util/qemu-error.c           | 80 +++++++++++++++++++++++++++++++++++++++++++--
>  3 files changed, 100 insertions(+), 4 deletions(-)

With the typos fixed:

Reviewed-by: Thomas Huth <thuth@redhat.com>
Markus Armbruster July 6, 2017, 6:15 a.m. UTC | #2
Alistair Francis <alistair.francis@xilinx.com> writes:

> This patch converts the existing error_vreport() function into a generic
> qmesg_vreport() function that takes an enum describing the
> information to be reported.
>
> As part of this change a new qmesg_report() function is added as well with the
> same capability.
>
> To maintain full compatibility the original error_report() function is
> maintained and no changes to the way errors are printed have been made.
> To improve access to the new informaiton and warning options wrapper functions
> similar to error_report() have been added for warnings and information
> printing.
>
> Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>

In addition to the typos Thomas pointed out, please wrap your lines at
column 70 or so.

> ---
> RFC V3:
>  - Change the function and enum names to be more descriptive
>  - Add wrapper functions for *_report() and *_vreport()
>
>  include/qemu/error-report.h | 16 +++++++++
>  scripts/checkpatch.pl       |  8 ++++-
>  util/qemu-error.c           | 80 +++++++++++++++++++++++++++++++++++++++++++--
>  3 files changed, 100 insertions(+), 4 deletions(-)
>
> diff --git a/include/qemu/error-report.h b/include/qemu/error-report.h
> index 3001865896..62fc167ace 100644
> --- a/include/qemu/error-report.h
> +++ b/include/qemu/error-report.h
> @@ -21,6 +21,12 @@ typedef struct Location {
>      struct Location *prev;
>  } Location;
>  
> +typedef enum {
> +    REPORT_TYPE_ERROR,
> +    REPORT_TYPE_WARNING,
> +    REPORT_TYPE_INFO,
> +} report_type;
> +
>  Location *loc_push_restore(Location *loc);
>  Location *loc_push_none(Location *loc);
>  Location *loc_pop(Location *loc);
> @@ -30,13 +36,23 @@ void loc_set_none(void);
>  void loc_set_cmdline(char **argv, int idx, int cnt);
>  void loc_set_file(const char *fname, int lno);
>  
> +void qmsg_vreport(report_type type, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0);
> +void qmsg_report(report_type type, const char *fmt, ...)  GCC_FMT_ATTR(2, 3);
> +

Let's keep these hidden in qemu-error.c until we have users outside of
qemu-error.c.  @report_type, too.  No need for qmsg_report() then.  Not
sure we need the qmsg_ prefix; I find it ugly.  I'd prefer vreport(),
msg_vreport() or maybe do_vreport().

Suggest to update the commit message to put less emphasis on the
(static) generic functions, and more on the functions we're actually
going to use, starting with your PATCH 3, perhaps like this:

    error: Functions to report warnings and informational messages

    Add warn_report(), warn_vreport() for reporting warnings, and
    info_report(), info_vreport() for informational messages.

    Implement them with a helper function factored out of
    error_vreport(), suitably generalized.  Take care not to change the
    way error messages are printed.


>  void error_vprintf(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
>  void error_printf(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
>  void error_vprintf_unless_qmp(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
>  void error_printf_unless_qmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
>  void error_set_progname(const char *argv0);
> +
>  void error_vreport(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
> +void warn_vreport(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
> +void info_vreport(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
> +
>  void error_report(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
> +void warn_report(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
> +void info_report(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
> +
>  const char *error_get_progname(void);
>  extern bool enable_timestamp_msg;
>  
> diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
> index 45027b9281..8b02621739 100755
> --- a/scripts/checkpatch.pl
> +++ b/scripts/checkpatch.pl
> @@ -2530,8 +2530,14 @@ sub process {
>  				error_set|
>  				error_prepend|
>  				error_reportf_err|
> +				qmsg_vreport|
>  				error_vreport|
> -				error_report}x;
> +				warn_vreport|
> +				info_vreport|
> +				qmsg_report|
> +				error_report|
> +				warn_report|
> +				info_report}x;
>  
>  	if ($rawline =~ /\b(?:$qemu_error_funcs)\s*\(.*\".*\\n/) {
>  		ERROR("Error messages should not contain newlines\n" . $herecurr);

Extra points for updating checkpatch.pl :)

> diff --git a/util/qemu-error.c b/util/qemu-error.c
> index 1c5e35ecdb..63fdc0e174 100644
> --- a/util/qemu-error.c
> +++ b/util/qemu-error.c
> @@ -179,17 +179,29 @@ static void print_loc(void)
>  
>  bool enable_timestamp_msg;
>  /*
> - * Print an error message to current monitor if we have one, else to stderr.
> + * Print a message to current monitor if we have one, else to stderr.
>   * Format arguments like vsprintf().  The resulting message should be
>   * a single phrase, with no newline or trailing punctuation.
>   * Prepend the current location and append a newline.
>   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
>   */
> -void error_vreport(const char *fmt, va_list ap)
> +void qmsg_vreport(report_type type, const char *fmt, va_list ap)
>  {
>      GTimeVal tv;
>      gchar *timestr;
>  
> +    switch (type) {
> +    case REPORT_TYPE_ERROR:
> +        /* To maintain compatibility we don't add anything here */

I feel the comment isn't going to be useful in the future.  Let's drop
it.

> +        break;
> +    case REPORT_TYPE_WARNING:
> +        error_printf("warning: ");
> +        break;
> +    case REPORT_TYPE_INFO:
> +        error_printf("info: ");
> +        break;

       default:
           assert(0);

> +    }
> +
>      if (enable_timestamp_msg && !cur_mon) {
>          g_get_current_time(&tv);
>          timestr = g_time_val_to_iso8601(&tv);
> @@ -204,16 +216,78 @@ void error_vreport(const char *fmt, va_list ap)
>  
>  /*
>   * Print an error message to current monitor if we have one, else to stderr.
> + */
> +void error_vreport(const char *fmt, va_list ap)
> +{
> +    qmsg_vreport(REPORT_TYPE_ERROR, fmt, ap);
> +}
> +
> +/*
> + * Print a warning message to current monitor if we have one, else to stderr.
> + */
> +void warn_vreport(const char *fmt, va_list ap)
> +{
> +    qmsg_vreport(REPORT_TYPE_WARNING, fmt, ap);
> +}
> +
> +/*
> + * Print an information message to current monitor if we have one, else to
> + * stderr.
> + */
> +void info_vreport(const char *fmt, va_list ap)
> +{
> +    qmsg_vreport(REPORT_TYPE_INFO, fmt, ap);
> +}
> +
> +/*
> + * Print a message to current monitor if we have one, else to stderr.
>   * Format arguments like sprintf().  The resulting message should be a
>   * single phrase, with no newline or trailing punctuation.
>   * Prepend the current location and append a newline.
>   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
>   */
> +void qmsg_report(report_type type, const char *fmt, ...)
> +{
> +    va_list ap;
> +
> +    va_start(ap, fmt);
> +    qmsg_vreport(type, fmt, ap);
> +    va_end(ap);
> +}
> +
> +/*
> + * Print an error message to current monitor if we have one, else to stderr.
> + */
>  void error_report(const char *fmt, ...)
>  {
>      va_list ap;
>  
>      va_start(ap, fmt);
> -    error_vreport(fmt, ap);
> +    qmsg_vreport(REPORT_TYPE_ERROR, fmt, ap);
> +    va_end(ap);
> +}
> +
> +/*
> + * Print a warning message to current monitor if we have one, else to stderr.
> + */
> +void warn_report(const char *fmt, ...)
> +{
> +    va_list ap;
> +
> +    va_start(ap, fmt);
> +    qmsg_vreport(REPORT_TYPE_WARNING, fmt, ap);
> +    va_end(ap);
> +}
> +
> +/*
> + * Print an information message to current monitor if we have one, else to
> + * stderr.
> + */
> +void info_report(const char *fmt, ...)
> +{
> +    va_list ap;
> +
> +    va_start(ap, fmt);
> +    qmsg_vreport(REPORT_TYPE_INFO, fmt, ap);
>      va_end(ap);
>  }
Daniel P. Berrangé July 6, 2017, 8:07 a.m. UTC | #3
On Thu, Jul 06, 2017 at 08:15:54AM +0200, Markus Armbruster wrote:
> Alistair Francis <alistair.francis@xilinx.com> writes:
> 
> > This patch converts the existing error_vreport() function into a generic
> > qmesg_vreport() function that takes an enum describing the
> > information to be reported.
> >
> > As part of this change a new qmesg_report() function is added as well with the
> > same capability.
> >
> > To maintain full compatibility the original error_report() function is
> > maintained and no changes to the way errors are printed have been made.
> > To improve access to the new informaiton and warning options wrapper functions
> > similar to error_report() have been added for warnings and information
> > printing.
> >
> > Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>

> > diff --git a/util/qemu-error.c b/util/qemu-error.c
> > index 1c5e35ecdb..63fdc0e174 100644
> > --- a/util/qemu-error.c
> > +++ b/util/qemu-error.c
> > @@ -179,17 +179,29 @@ static void print_loc(void)
> >  
> >  bool enable_timestamp_msg;
> >  /*
> > - * Print an error message to current monitor if we have one, else to stderr.
> > + * Print a message to current monitor if we have one, else to stderr.
> >   * Format arguments like vsprintf().  The resulting message should be
> >   * a single phrase, with no newline or trailing punctuation.
> >   * Prepend the current location and append a newline.
> >   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
> >   */
> > -void error_vreport(const char *fmt, va_list ap)
> > +void qmsg_vreport(report_type type, const char *fmt, va_list ap)
> >  {
> >      GTimeVal tv;
> >      gchar *timestr;
> >  
> > +    switch (type) {
> > +    case REPORT_TYPE_ERROR:
> > +        /* To maintain compatibility we don't add anything here */
> 
> I feel the comment isn't going to be useful in the future.  Let's drop
> it.

Do we really need to care about compatibility of the precise way we output
error messages. It has never been something we call a "stable API", as we
don't guarantee error message text will remain the same across releases. So
anyone relying on scraping QEMU stderr to match some error message has always
been liable to break.

IOW, just add an "error: " prefix to the text

> 
> > +        break;
> > +    case REPORT_TYPE_WARNING:
> > +        error_printf("warning: ");
> > +        break;
> > +    case REPORT_TYPE_INFO:
> > +        error_printf("info: ");
> > +        break;
> 
>        default:
>            assert(0);
> 
> > +    }
> > +
> >      if (enable_timestamp_msg && !cur_mon) {
> >          g_get_current_time(&tv);
> >          timestr = g_time_val_to_iso8601(&tv);

Regards,
Daniel
Markus Armbruster July 6, 2017, 11:27 a.m. UTC | #4
"Daniel P. Berrange" <berrange@redhat.com> writes:

> On Thu, Jul 06, 2017 at 08:15:54AM +0200, Markus Armbruster wrote:
>> Alistair Francis <alistair.francis@xilinx.com> writes:
>> 
>> > This patch converts the existing error_vreport() function into a generic
>> > qmesg_vreport() function that takes an enum describing the
>> > information to be reported.
>> >
>> > As part of this change a new qmesg_report() function is added as well with the
>> > same capability.
>> >
>> > To maintain full compatibility the original error_report() function is
>> > maintained and no changes to the way errors are printed have been made.
>> > To improve access to the new informaiton and warning options wrapper functions
>> > similar to error_report() have been added for warnings and information
>> > printing.
>> >
>> > Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
>
>> > diff --git a/util/qemu-error.c b/util/qemu-error.c
>> > index 1c5e35ecdb..63fdc0e174 100644
>> > --- a/util/qemu-error.c
>> > +++ b/util/qemu-error.c
>> > @@ -179,17 +179,29 @@ static void print_loc(void)
>> >  
>> >  bool enable_timestamp_msg;
>> >  /*
>> > - * Print an error message to current monitor if we have one, else to stderr.
>> > + * Print a message to current monitor if we have one, else to stderr.
>> >   * Format arguments like vsprintf().  The resulting message should be
>> >   * a single phrase, with no newline or trailing punctuation.
>> >   * Prepend the current location and append a newline.
>> >   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
>> >   */
>> > -void error_vreport(const char *fmt, va_list ap)
>> > +void qmsg_vreport(report_type type, const char *fmt, va_list ap)
>> >  {
>> >      GTimeVal tv;
>> >      gchar *timestr;
>> >  
>> > +    switch (type) {
>> > +    case REPORT_TYPE_ERROR:
>> > +        /* To maintain compatibility we don't add anything here */
>> 
>> I feel the comment isn't going to be useful in the future.  Let's drop
>> it.
>
> Do we really need to care about compatibility of the precise way we output
> error messages. It has never been something we call a "stable API", as we
> don't guarantee error message text will remain the same across releases. So
> anyone relying on scraping QEMU stderr to match some error message has always
> been liable to break.
>
> IOW, just add an "error: " prefix to the text

I agree the error message format isn't ABI.

But what would adding "error: " buy us?
Daniel P. Berrangé July 6, 2017, 11:45 a.m. UTC | #5
On Thu, Jul 06, 2017 at 01:27:15PM +0200, Markus Armbruster wrote:
> "Daniel P. Berrange" <berrange@redhat.com> writes:
> 
> > On Thu, Jul 06, 2017 at 08:15:54AM +0200, Markus Armbruster wrote:
> >> Alistair Francis <alistair.francis@xilinx.com> writes:
> >> 
> >> > This patch converts the existing error_vreport() function into a generic
> >> > qmesg_vreport() function that takes an enum describing the
> >> > information to be reported.
> >> >
> >> > As part of this change a new qmesg_report() function is added as well with the
> >> > same capability.
> >> >
> >> > To maintain full compatibility the original error_report() function is
> >> > maintained and no changes to the way errors are printed have been made.
> >> > To improve access to the new informaiton and warning options wrapper functions
> >> > similar to error_report() have been added for warnings and information
> >> > printing.
> >> >
> >> > Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
> >
> >> > diff --git a/util/qemu-error.c b/util/qemu-error.c
> >> > index 1c5e35ecdb..63fdc0e174 100644
> >> > --- a/util/qemu-error.c
> >> > +++ b/util/qemu-error.c
> >> > @@ -179,17 +179,29 @@ static void print_loc(void)
> >> >  
> >> >  bool enable_timestamp_msg;
> >> >  /*
> >> > - * Print an error message to current monitor if we have one, else to stderr.
> >> > + * Print a message to current monitor if we have one, else to stderr.
> >> >   * Format arguments like vsprintf().  The resulting message should be
> >> >   * a single phrase, with no newline or trailing punctuation.
> >> >   * Prepend the current location and append a newline.
> >> >   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
> >> >   */
> >> > -void error_vreport(const char *fmt, va_list ap)
> >> > +void qmsg_vreport(report_type type, const char *fmt, va_list ap)
> >> >  {
> >> >      GTimeVal tv;
> >> >      gchar *timestr;
> >> >  
> >> > +    switch (type) {
> >> > +    case REPORT_TYPE_ERROR:
> >> > +        /* To maintain compatibility we don't add anything here */
> >> 
> >> I feel the comment isn't going to be useful in the future.  Let's drop
> >> it.
> >
> > Do we really need to care about compatibility of the precise way we output
> > error messages. It has never been something we call a "stable API", as we
> > don't guarantee error message text will remain the same across releases. So
> > anyone relying on scraping QEMU stderr to match some error message has always
> > been liable to break.
> >
> > IOW, just add an "error: " prefix to the text
> 
> I agree the error message format isn't ABI.
> 
> But what would adding "error: " buy us?

It would clearly distinguish errors from any other output on stderr, which
may not be error related (for example SPICE commonly pollutes stderr with
lots of messages).

Regards,
Daniel
Markus Armbruster July 6, 2017, 12:20 p.m. UTC | #6
"Daniel P. Berrange" <berrange@redhat.com> writes:

> On Thu, Jul 06, 2017 at 01:27:15PM +0200, Markus Armbruster wrote:
>> "Daniel P. Berrange" <berrange@redhat.com> writes:
>> 
>> > On Thu, Jul 06, 2017 at 08:15:54AM +0200, Markus Armbruster wrote:
>> >> Alistair Francis <alistair.francis@xilinx.com> writes:
>> >> 
>> >> > This patch converts the existing error_vreport() function into a generic
>> >> > qmesg_vreport() function that takes an enum describing the
>> >> > information to be reported.
>> >> >
>> >> > As part of this change a new qmesg_report() function is added as well with the
>> >> > same capability.
>> >> >
>> >> > To maintain full compatibility the original error_report() function is
>> >> > maintained and no changes to the way errors are printed have been made.
>> >> > To improve access to the new informaiton and warning options wrapper functions
>> >> > similar to error_report() have been added for warnings and information
>> >> > printing.
>> >> >
>> >> > Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
>> >
>> >> > diff --git a/util/qemu-error.c b/util/qemu-error.c
>> >> > index 1c5e35ecdb..63fdc0e174 100644
>> >> > --- a/util/qemu-error.c
>> >> > +++ b/util/qemu-error.c
>> >> > @@ -179,17 +179,29 @@ static void print_loc(void)
>> >> >  
>> >> >  bool enable_timestamp_msg;
>> >> >  /*
>> >> > - * Print an error message to current monitor if we have one, else to stderr.
>> >> > + * Print a message to current monitor if we have one, else to stderr.
>> >> >   * Format arguments like vsprintf().  The resulting message should be
>> >> >   * a single phrase, with no newline or trailing punctuation.
>> >> >   * Prepend the current location and append a newline.
>> >> >   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
>> >> >   */
>> >> > -void error_vreport(const char *fmt, va_list ap)
>> >> > +void qmsg_vreport(report_type type, const char *fmt, va_list ap)
>> >> >  {
>> >> >      GTimeVal tv;
>> >> >      gchar *timestr;
>> >> >  
>> >> > +    switch (type) {
>> >> > +    case REPORT_TYPE_ERROR:
>> >> > +        /* To maintain compatibility we don't add anything here */
>> >> 
>> >> I feel the comment isn't going to be useful in the future.  Let's drop
>> >> it.
>> >
>> > Do we really need to care about compatibility of the precise way we output
>> > error messages. It has never been something we call a "stable API", as we
>> > don't guarantee error message text will remain the same across releases. So
>> > anyone relying on scraping QEMU stderr to match some error message has always
>> > been liable to break.
>> >
>> > IOW, just add an "error: " prefix to the text
>> 
>> I agree the error message format isn't ABI.
>> 
>> But what would adding "error: " buy us?
>
> It would clearly distinguish errors from any other output on stderr, which
> may not be error related (for example SPICE commonly pollutes stderr with
> lots of messages).

Changing the current error message format

    <TIMESTAMP><PROGNAME>:<LOCATION><MSG>

to

    <TIMESTAMP><PROGNAME>:<LOCATION>error: <MSG>

makes recognizing error messages a bit easier, but it also makes them
even longer.  Can't we make do with recognizing <PROGNAME>:?

If SPICE babbles to stderr, it needs a gag.
Daniel P. Berrangé July 6, 2017, 1:10 p.m. UTC | #7
On Thu, Jul 06, 2017 at 02:20:51PM +0200, Markus Armbruster wrote:
> "Daniel P. Berrange" <berrange@redhat.com> writes:
> 
> > On Thu, Jul 06, 2017 at 01:27:15PM +0200, Markus Armbruster wrote:
> >> "Daniel P. Berrange" <berrange@redhat.com> writes:
> >> 
> >> > On Thu, Jul 06, 2017 at 08:15:54AM +0200, Markus Armbruster wrote:
> >> >> Alistair Francis <alistair.francis@xilinx.com> writes:
> >> >> 
> >> >> > This patch converts the existing error_vreport() function into a generic
> >> >> > qmesg_vreport() function that takes an enum describing the
> >> >> > information to be reported.
> >> >> >
> >> >> > As part of this change a new qmesg_report() function is added as well with the
> >> >> > same capability.
> >> >> >
> >> >> > To maintain full compatibility the original error_report() function is
> >> >> > maintained and no changes to the way errors are printed have been made.
> >> >> > To improve access to the new informaiton and warning options wrapper functions
> >> >> > similar to error_report() have been added for warnings and information
> >> >> > printing.
> >> >> >
> >> >> > Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
> >> >
> >> >> > diff --git a/util/qemu-error.c b/util/qemu-error.c
> >> >> > index 1c5e35ecdb..63fdc0e174 100644
> >> >> > --- a/util/qemu-error.c
> >> >> > +++ b/util/qemu-error.c
> >> >> > @@ -179,17 +179,29 @@ static void print_loc(void)
> >> >> >  
> >> >> >  bool enable_timestamp_msg;
> >> >> >  /*
> >> >> > - * Print an error message to current monitor if we have one, else to stderr.
> >> >> > + * Print a message to current monitor if we have one, else to stderr.
> >> >> >   * Format arguments like vsprintf().  The resulting message should be
> >> >> >   * a single phrase, with no newline or trailing punctuation.
> >> >> >   * Prepend the current location and append a newline.
> >> >> >   * It's wrong to call this in a QMP monitor.  Use error_setg() there.
> >> >> >   */
> >> >> > -void error_vreport(const char *fmt, va_list ap)
> >> >> > +void qmsg_vreport(report_type type, const char *fmt, va_list ap)
> >> >> >  {
> >> >> >      GTimeVal tv;
> >> >> >      gchar *timestr;
> >> >> >  
> >> >> > +    switch (type) {
> >> >> > +    case REPORT_TYPE_ERROR:
> >> >> > +        /* To maintain compatibility we don't add anything here */
> >> >> 
> >> >> I feel the comment isn't going to be useful in the future.  Let's drop
> >> >> it.
> >> >
> >> > Do we really need to care about compatibility of the precise way we output
> >> > error messages. It has never been something we call a "stable API", as we
> >> > don't guarantee error message text will remain the same across releases. So
> >> > anyone relying on scraping QEMU stderr to match some error message has always
> >> > been liable to break.
> >> >
> >> > IOW, just add an "error: " prefix to the text
> >> 
> >> I agree the error message format isn't ABI.
> >> 
> >> But what would adding "error: " buy us?
> >
> > It would clearly distinguish errors from any other output on stderr, which
> > may not be error related (for example SPICE commonly pollutes stderr with
> > lots of messages).
> 
> Changing the current error message format
> 
>     <TIMESTAMP><PROGNAME>:<LOCATION><MSG>
> 
> to
> 
>     <TIMESTAMP><PROGNAME>:<LOCATION>error: <MSG>
> 
> makes recognizing error messages a bit easier, but it also makes them
> even longer.  Can't we make do with recognizing <PROGNAME>:?

I'm not convinced 7 extra characters is a big deal compared with the
size of the timestamps, program name, location & error message itself.
We'll already have such a prefix for info & warnings, so consistency is
good IMHO.

If line length is a concern, perhaps we should make the error printing
function able to intelligently line wrap at 80 chars, taking into account
the size of the metadata (timestamp, program, location, msg type prefix).

Regards,
Daniel
Markus Armbruster July 6, 2017, 2:44 p.m. UTC | #8
"Daniel P. Berrange" <berrange@redhat.com> writes:

> On Thu, Jul 06, 2017 at 02:20:51PM +0200, Markus Armbruster wrote:
>> "Daniel P. Berrange" <berrange@redhat.com> writes:
>> 
>> > On Thu, Jul 06, 2017 at 01:27:15PM +0200, Markus Armbruster wrote:
>> >> "Daniel P. Berrange" <berrange@redhat.com> writes:
[...]
>> >> > Do we really need to care about compatibility of the precise way we output
>> >> > error messages. It has never been something we call a "stable API", as we
>> >> > don't guarantee error message text will remain the same across releases. So
>> >> > anyone relying on scraping QEMU stderr to match some error message has always
>> >> > been liable to break.
>> >> >
>> >> > IOW, just add an "error: " prefix to the text
>> >> 
>> >> I agree the error message format isn't ABI.
>> >> 
>> >> But what would adding "error: " buy us?
>> >
>> > It would clearly distinguish errors from any other output on stderr, which
>> > may not be error related (for example SPICE commonly pollutes stderr with
>> > lots of messages).
>> 
>> Changing the current error message format
>> 
>>     <TIMESTAMP><PROGNAME>:<LOCATION><MSG>
>> 
>> to
>> 
>>     <TIMESTAMP><PROGNAME>:<LOCATION>error: <MSG>
>> 
>> makes recognizing error messages a bit easier, but it also makes them
>> even longer.  Can't we make do with recognizing <PROGNAME>:?
>
> I'm not convinced 7 extra characters is a big deal compared with the
> size of the timestamps, program name, location & error message itself.
> We'll already have such a prefix for info & warnings, so consistency is
> good IMHO.

I don't see the value of consistency here.  What matters is whether
errors are easy to spot and recognize.

GCC doesn't put "error:" into its error messages.  Clang does.  Feels
like a matter of taste to me.

If adding "error:" solves a problem people have, let's do it.  If not, I
don't see why we should change what we have.

> If line length is a concern, perhaps we should make the error printing
> function able to intelligently line wrap at 80 chars, taking into account
> the size of the metadata (timestamp, program, location, msg type prefix).

Uh, that cure feels worse than the disease :)
Alistair Francis July 6, 2017, 6:45 p.m. UTC | #9
On Thu, Jul 6, 2017 at 7:44 AM, Markus Armbruster <armbru@redhat.com> wrote:
> "Daniel P. Berrange" <berrange@redhat.com> writes:
>
>> On Thu, Jul 06, 2017 at 02:20:51PM +0200, Markus Armbruster wrote:
>>> "Daniel P. Berrange" <berrange@redhat.com> writes:
>>>
>>> > On Thu, Jul 06, 2017 at 01:27:15PM +0200, Markus Armbruster wrote:
>>> >> "Daniel P. Berrange" <berrange@redhat.com> writes:
> [...]
>>> >> > Do we really need to care about compatibility of the precise way we output
>>> >> > error messages. It has never been something we call a "stable API", as we
>>> >> > don't guarantee error message text will remain the same across releases. So
>>> >> > anyone relying on scraping QEMU stderr to match some error message has always
>>> >> > been liable to break.
>>> >> >
>>> >> > IOW, just add an "error: " prefix to the text
>>> >>
>>> >> I agree the error message format isn't ABI.
>>> >>
>>> >> But what would adding "error: " buy us?
>>> >
>>> > It would clearly distinguish errors from any other output on stderr, which
>>> > may not be error related (for example SPICE commonly pollutes stderr with
>>> > lots of messages).
>>>
>>> Changing the current error message format
>>>
>>>     <TIMESTAMP><PROGNAME>:<LOCATION><MSG>
>>>
>>> to
>>>
>>>     <TIMESTAMP><PROGNAME>:<LOCATION>error: <MSG>
>>>
>>> makes recognizing error messages a bit easier, but it also makes them
>>> even longer.  Can't we make do with recognizing <PROGNAME>:?
>>
>> I'm not convinced 7 extra characters is a big deal compared with the
>> size of the timestamps, program name, location & error message itself.
>> We'll already have such a prefix for info & warnings, so consistency is
>> good IMHO.
>
> I don't see the value of consistency here.  What matters is whether
> errors are easy to spot and recognize.
>
> GCC doesn't put "error:" into its error messages.  Clang does.  Feels
> like a matter of taste to me.
>
> If adding "error:" solves a problem people have, let's do it.  If not, I
> don't see why we should change what we have.

Ok, adding "error: " actually helps with what I was originally trying
to do, so I have added it in my next version.

I have also removed the qmsg_* prefix and updated the commit message.

Thanks,
Alistair

>
>> If line length is a concern, perhaps we should make the error printing
>> function able to intelligently line wrap at 80 chars, taking into account
>> the size of the metadata (timestamp, program, location, msg type prefix).
>
> Uh, that cure feels worse than the disease :)
diff mbox

Patch

diff --git a/include/qemu/error-report.h b/include/qemu/error-report.h
index 3001865896..62fc167ace 100644
--- a/include/qemu/error-report.h
+++ b/include/qemu/error-report.h
@@ -21,6 +21,12 @@  typedef struct Location {
     struct Location *prev;
 } Location;
 
+typedef enum {
+    REPORT_TYPE_ERROR,
+    REPORT_TYPE_WARNING,
+    REPORT_TYPE_INFO,
+} report_type;
+
 Location *loc_push_restore(Location *loc);
 Location *loc_push_none(Location *loc);
 Location *loc_pop(Location *loc);
@@ -30,13 +36,23 @@  void loc_set_none(void);
 void loc_set_cmdline(char **argv, int idx, int cnt);
 void loc_set_file(const char *fname, int lno);
 
+void qmsg_vreport(report_type type, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0);
+void qmsg_report(report_type type, const char *fmt, ...)  GCC_FMT_ATTR(2, 3);
+
 void error_vprintf(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
 void error_printf(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 void error_vprintf_unless_qmp(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
 void error_printf_unless_qmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 void error_set_progname(const char *argv0);
+
 void error_vreport(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
+void warn_vreport(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
+void info_vreport(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
+
 void error_report(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
+void warn_report(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
+void info_report(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
+
 const char *error_get_progname(void);
 extern bool enable_timestamp_msg;
 
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 45027b9281..8b02621739 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -2530,8 +2530,14 @@  sub process {
 				error_set|
 				error_prepend|
 				error_reportf_err|
+				qmsg_vreport|
 				error_vreport|
-				error_report}x;
+				warn_vreport|
+				info_vreport|
+				qmsg_report|
+				error_report|
+				warn_report|
+				info_report}x;
 
 	if ($rawline =~ /\b(?:$qemu_error_funcs)\s*\(.*\".*\\n/) {
 		ERROR("Error messages should not contain newlines\n" . $herecurr);
diff --git a/util/qemu-error.c b/util/qemu-error.c
index 1c5e35ecdb..63fdc0e174 100644
--- a/util/qemu-error.c
+++ b/util/qemu-error.c
@@ -179,17 +179,29 @@  static void print_loc(void)
 
 bool enable_timestamp_msg;
 /*
- * Print an error message to current monitor if we have one, else to stderr.
+ * Print a message to current monitor if we have one, else to stderr.
  * Format arguments like vsprintf().  The resulting message should be
  * a single phrase, with no newline or trailing punctuation.
  * Prepend the current location and append a newline.
  * It's wrong to call this in a QMP monitor.  Use error_setg() there.
  */
-void error_vreport(const char *fmt, va_list ap)
+void qmsg_vreport(report_type type, const char *fmt, va_list ap)
 {
     GTimeVal tv;
     gchar *timestr;
 
+    switch (type) {
+    case REPORT_TYPE_ERROR:
+        /* To maintain compatibility we don't add anything here */
+        break;
+    case REPORT_TYPE_WARNING:
+        error_printf("warning: ");
+        break;
+    case REPORT_TYPE_INFO:
+        error_printf("info: ");
+        break;
+    }
+
     if (enable_timestamp_msg && !cur_mon) {
         g_get_current_time(&tv);
         timestr = g_time_val_to_iso8601(&tv);
@@ -204,16 +216,78 @@  void error_vreport(const char *fmt, va_list ap)
 
 /*
  * Print an error message to current monitor if we have one, else to stderr.
+ */
+void error_vreport(const char *fmt, va_list ap)
+{
+    qmsg_vreport(REPORT_TYPE_ERROR, fmt, ap);
+}
+
+/*
+ * Print a warning message to current monitor if we have one, else to stderr.
+ */
+void warn_vreport(const char *fmt, va_list ap)
+{
+    qmsg_vreport(REPORT_TYPE_WARNING, fmt, ap);
+}
+
+/*
+ * Print an information message to current monitor if we have one, else to
+ * stderr.
+ */
+void info_vreport(const char *fmt, va_list ap)
+{
+    qmsg_vreport(REPORT_TYPE_INFO, fmt, ap);
+}
+
+/*
+ * Print a message to current monitor if we have one, else to stderr.
  * Format arguments like sprintf().  The resulting message should be a
  * single phrase, with no newline or trailing punctuation.
  * Prepend the current location and append a newline.
  * It's wrong to call this in a QMP monitor.  Use error_setg() there.
  */
+void qmsg_report(report_type type, const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    qmsg_vreport(type, fmt, ap);
+    va_end(ap);
+}
+
+/*
+ * Print an error message to current monitor if we have one, else to stderr.
+ */
 void error_report(const char *fmt, ...)
 {
     va_list ap;
 
     va_start(ap, fmt);
-    error_vreport(fmt, ap);
+    qmsg_vreport(REPORT_TYPE_ERROR, fmt, ap);
+    va_end(ap);
+}
+
+/*
+ * Print a warning message to current monitor if we have one, else to stderr.
+ */
+void warn_report(const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    qmsg_vreport(REPORT_TYPE_WARNING, fmt, ap);
+    va_end(ap);
+}
+
+/*
+ * Print an information message to current monitor if we have one, else to
+ * stderr.
+ */
+void info_report(const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    qmsg_vreport(REPORT_TYPE_INFO, fmt, ap);
     va_end(ap);
 }