tree c26d34c22fd51a49b7b26758a59549a033f2e050
parent e4937694b66d1468aec3cd95e90888f291c3f599
author Markus Armbruster <armbru@redhat.com> 1450452921 +0100
committer Markus Armbruster <armbru@redhat.com> 1452694578 +0100

vmdk: Clean up "Invalid extent lines" error message

vmdk_parse_extents() reports parse errors like this:

    error_setg(errp, "Invalid extent lines:\n%s", p);

where p points to the beginning of the malformed line in the image
descriptor.  This results in a multi-line error message

    Invalid extent lines:
    <first line that doesn't parse>
    <remaining text that may or may not parse, if any>

Error messages should not have newlines embedded.  Since the remaining
text is not helpful, we can simply report:

    Invalid extent line: <first line that doesn't parse>

Cc: Fam Zheng <famz@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <1450452927-8346-19-git-send-email-armbru@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
