2006-02-24 22:36:10 +00:00
|
|
|
/*
|
2012-12-13 18:21:53 +00:00
|
|
|
* virerror.c: error handling and reporting code for libvirt
|
2006-02-24 22:36:10 +00:00
|
|
|
*
|
2019-01-03 01:55:25 +00:00
|
|
|
* Copyright (C) 2006-2019 Red Hat, Inc.
|
2006-02-24 22:36:10 +00:00
|
|
|
*
|
2012-07-27 09:39:53 +00:00
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-27 09:39:53 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2006-02-24 22:36:10 +00:00
|
|
|
*/
|
|
|
|
|
2008-01-29 18:15:54 +00:00
|
|
|
#include <config.h>
|
2007-12-05 21:40:15 +00:00
|
|
|
|
2006-02-27 16:27:18 +00:00
|
|
|
#include <stdarg.h>
|
Standardize use of header files, making internal.h primary.
* qemud/internal.h, qemud/qemud.h: Rename this file so it
doesn't conflict with src/internal.h.
* HACKING: Document how header files should be used.
* qemud/Makefile.am: Add src/ directory to includes.
* qemud/event.c, qemud/mdns.c, qemud/qemud.c, qemud/remote.c,
qemud/remote_protocol.c, qemud/remote_protocol.h,
qemud/remote_protocol.x, src/buf.c, src/libvirt.c,
src/nodeinfo.c, src/qemu_conf.c, src/qemu_driver.c,
src/stats_linux.c, src/storage_backend.c, src/storage_backend_fs.c,
src/storage_backend_iscsi.c, src/storage_backend_logical.c,
src/storage_conf.c, src/storage_driver.c, src/util.c,
src/util.h, src/virsh.c, src/virterror.c, src/xend_internal.c,
src/xml.c, tests/reconnect.c, tests/xmlrpctest.c,
tests/qparamtest.c: Standardize use of header files.
* docs/*, po/*: Rebuild docs.
2008-05-23 08:24:41 +00:00
|
|
|
|
2012-12-13 18:21:53 +00:00
|
|
|
#include "virerror.h"
|
2008-11-04 23:22:06 +00:00
|
|
|
#include "datatypes.h"
|
2019-04-01 14:28:05 +00:00
|
|
|
#include "viralloc.h"
|
2012-12-12 17:59:27 +00:00
|
|
|
#include "virlog.h"
|
2012-12-13 15:49:48 +00:00
|
|
|
#include "virthread.h"
|
2013-04-03 10:36:23 +00:00
|
|
|
#include "virstring.h"
|
2009-01-20 12:01:45 +00:00
|
|
|
|
2018-11-12 14:33:02 +00:00
|
|
|
#define LIBVIRT_VIRERRORPRIV_H_ALLOW
|
|
|
|
#include "virerrorpriv.h"
|
|
|
|
#undef LIBVIRT_VIRERRORPRIV_H_ALLOW
|
|
|
|
|
2014-02-28 12:16:17 +00:00
|
|
|
VIR_LOG_INIT("util.error");
|
|
|
|
|
2009-01-20 12:01:45 +00:00
|
|
|
virThreadLocal virLastErr;
|
2006-02-24 22:36:10 +00:00
|
|
|
|
2008-11-04 22:30:33 +00:00
|
|
|
virErrorFunc virErrorHandler = NULL; /* global error handler */
|
|
|
|
void *virUserData = NULL; /* associated data */
|
2011-01-21 17:25:01 +00:00
|
|
|
virErrorLogPriorityFunc virErrorLogPriorityFilter = NULL;
|
2006-02-24 22:36:10 +00:00
|
|
|
|
2014-03-18 08:14:35 +00:00
|
|
|
static virLogPriority virErrorLevelPriority(virErrorLevel level)
|
|
|
|
{
|
2010-11-30 13:10:42 +00:00
|
|
|
switch (level) {
|
|
|
|
case VIR_ERR_NONE:
|
2012-03-22 11:33:35 +00:00
|
|
|
return VIR_LOG_INFO;
|
2010-11-30 13:10:42 +00:00
|
|
|
case VIR_ERR_WARNING:
|
2012-03-22 11:33:35 +00:00
|
|
|
return VIR_LOG_WARN;
|
2010-11-30 13:10:42 +00:00
|
|
|
case VIR_ERR_ERROR:
|
2012-03-22 11:33:35 +00:00
|
|
|
return VIR_LOG_ERROR;
|
2010-11-30 13:10:42 +00:00
|
|
|
}
|
2012-03-22 11:33:35 +00:00
|
|
|
return VIR_LOG_ERROR;
|
2010-11-30 13:10:42 +00:00
|
|
|
}
|
|
|
|
|
2012-05-14 15:31:05 +00:00
|
|
|
|
2019-01-20 16:04:56 +00:00
|
|
|
VIR_ENUM_DECL(virErrorDomain);
|
2019-03-16 18:20:32 +00:00
|
|
|
VIR_ENUM_IMPL(virErrorDomain,
|
|
|
|
VIR_ERR_DOMAIN_LAST,
|
2012-05-14 15:31:05 +00:00
|
|
|
"", /* 0 */
|
|
|
|
"Xen Driver",
|
|
|
|
"Xen Daemon",
|
|
|
|
"Xen Store",
|
|
|
|
"S-Expression",
|
|
|
|
|
|
|
|
"XML Util", /* 5 */
|
|
|
|
"Domain",
|
|
|
|
"XML-RPC",
|
|
|
|
"Proxy Daemon",
|
|
|
|
"Config File",
|
|
|
|
|
|
|
|
"QEMU Driver", /* 10 */
|
|
|
|
"Network",
|
|
|
|
"Test Driver",
|
|
|
|
"Remote Driver",
|
|
|
|
"OpenVZ Driver",
|
|
|
|
|
|
|
|
"Xen XM Driver", /* 15 */
|
|
|
|
"Linux Statistics",
|
|
|
|
"LXC Driver",
|
|
|
|
"Storage Driver",
|
|
|
|
"Network Driver",
|
|
|
|
|
|
|
|
"Domain Config", /* 20 */
|
|
|
|
"User Mode Linux Driver",
|
|
|
|
"Node Device Driver",
|
|
|
|
"Xen Inotify Driver",
|
|
|
|
"Security Driver",
|
|
|
|
|
|
|
|
"VirtualBox Driver", /* 25 */
|
|
|
|
"Network Interface Driver",
|
|
|
|
"Open Nebula Driver",
|
|
|
|
"ESX Driver",
|
|
|
|
"Power Hypervisor Driver",
|
|
|
|
|
|
|
|
"Secrets Driver", /* 30 */
|
|
|
|
"CPU Driver",
|
|
|
|
"XenAPI Driver",
|
|
|
|
"Network Filter Driver",
|
|
|
|
"Lifecycle Hook",
|
|
|
|
|
|
|
|
"Domain Snapshot", /* 35 */
|
|
|
|
"Audit Utils",
|
|
|
|
"Sysinfo Utils",
|
|
|
|
"I/O Stream Utils",
|
2016-02-15 14:34:24 +00:00
|
|
|
"VMware Driver",
|
2012-05-14 15:31:05 +00:00
|
|
|
|
|
|
|
"Event Loop", /* 40 */
|
|
|
|
"Xen Light Driver",
|
|
|
|
"Lock Driver",
|
|
|
|
"Hyper-V Driver",
|
|
|
|
"Capabilities Utils",
|
|
|
|
|
|
|
|
"URI Utils", /* 45 */
|
|
|
|
"Authentication Utils",
|
2012-07-31 18:56:05 +00:00
|
|
|
"DBus Utils",
|
2012-08-16 15:41:06 +00:00
|
|
|
"Parallels Cloud Server",
|
2011-11-14 14:30:23 +00:00
|
|
|
"Device Config",
|
|
|
|
|
Introduce an internal API for handling file based lockspaces
The previously introduced virFile{Lock,Unlock} APIs provide a
way to acquire/release fcntl() locks on individual files. For
unknown reason though, the POSIX spec says that fcntl() locks
are released when *any* file handle referring to the same path
is closed. In the following sequence
threadA: fd1 = open("foo")
threadB: fd2 = open("foo")
threadA: virFileLock(fd1)
threadB: virFileLock(fd2)
threadB: close(fd2)
you'd expect threadA to come out holding a lock on 'foo', and
indeed it does hold a lock for a very short time. Unfortunately
when threadB does close(fd2) this releases the lock associated
with fd1. For the current libvirt use case for virFileLock -
pidfiles - this doesn't matter since the lock is acquired
at startup while single threaded an never released until
exit.
To provide a more generally useful API though, it is necessary
to introduce a slightly higher level abstraction, which is to
be referred to as a "lockspace". This is to be provided by
a virLockSpacePtr object in src/util/virlockspace.{c,h}. The
core idea is that the lockspace keeps track of what files are
already open+locked. This means that when a 2nd thread comes
along and tries to acquire a lock, it doesn't end up opening
and closing a new FD. The lockspace just checks the current
list of held locks and immediately returns VIR_ERR_RESOURCE_BUSY.
NB, the API as it stands is designed on the basis that the
files being locked are not being otherwise opened and used
by the application code. One approach to using this API is to
acquire locks based on a hash of the filepath.
eg to lock /var/lib/libvirt/images/foo.img the application
might do
virLockSpacePtr lockspace = virLockSpaceNew("/var/lib/libvirt/imagelocks");
lockname = md5sum("/var/lib/libvirt/images/foo.img");
virLockSpaceAcquireLock(lockspace, lockname);
NB, in this example, the caller should ensure that the path
is canonicalized before calculating the checksum.
It is also possible to do locks directly on resources by
using a NULL lockspace directory and then using the file
path as the lock name eg
virLockSpacePtr lockspace = virLockSpaceNew(NULL);
virLockSpaceAcquireLock(lockspace, "/var/lib/libvirt/images/foo.img");
This is only safe to do though if no other part of the process
will be opening the files. This will be the case when this
code is used inside the soon-to-be-reposted virlockd daemon
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-08-02 16:02:40 +00:00
|
|
|
"SSH transport layer", /* 50 */
|
|
|
|
"Lock Space",
|
2012-11-28 12:17:31 +00:00
|
|
|
"Init control",
|
2012-01-20 17:49:32 +00:00
|
|
|
"Identity",
|
2013-04-05 11:48:47 +00:00
|
|
|
"Cgroup",
|
2012-01-20 18:02:55 +00:00
|
|
|
|
|
|
|
"Access Manager", /* 55 */
|
2013-07-18 09:54:21 +00:00
|
|
|
"Systemd",
|
2014-02-18 10:08:10 +00:00
|
|
|
"Bhyve",
|
2014-03-05 12:34:10 +00:00
|
|
|
"Crypto",
|
2013-03-04 16:30:40 +00:00
|
|
|
"Firewall",
|
2013-08-22 13:27:19 +00:00
|
|
|
|
|
|
|
"Polkit", /* 60 */
|
2013-07-08 10:27:34 +00:00
|
|
|
"Thread jobs",
|
2015-04-15 14:17:11 +00:00
|
|
|
"Admin Interface",
|
2015-02-09 16:35:05 +00:00
|
|
|
"Log Manager",
|
2016-01-20 18:51:55 +00:00
|
|
|
"Xen XL Config",
|
2016-03-28 13:30:28 +00:00
|
|
|
|
2016-11-09 14:28:33 +00:00
|
|
|
"Perf", /* 65 */
|
|
|
|
"Libssh transport layer",
|
2017-07-25 14:03:11 +00:00
|
|
|
"Resource control",
|
2019-01-09 19:11:32 +00:00
|
|
|
"FirewallD",
|
2019-01-03 01:55:25 +00:00
|
|
|
"Domain Checkpoint",
|
2019-07-25 18:22:05 +00:00
|
|
|
|
|
|
|
"TPM", /* 70 */
|
2019-09-09 07:37:32 +00:00
|
|
|
"BPF",
|
2019-01-20 16:30:15 +00:00
|
|
|
);
|
2008-12-22 10:48:59 +00:00
|
|
|
|
2009-01-20 12:01:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal helper that is called when a thread exits, to
|
|
|
|
* release the error object stored in the thread local
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
virLastErrFreeData(void *data)
|
|
|
|
{
|
|
|
|
virErrorPtr err = data;
|
|
|
|
if (!err)
|
|
|
|
return;
|
|
|
|
virResetError(err);
|
|
|
|
VIR_FREE(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-04-24 14:04:54 +00:00
|
|
|
/**
|
|
|
|
* virErrorInitialize:
|
|
|
|
*
|
|
|
|
* Initialize the error data (per thread)
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of failure.
|
|
|
|
*/
|
2009-01-20 12:01:45 +00:00
|
|
|
int
|
|
|
|
virErrorInitialize(void)
|
|
|
|
{
|
|
|
|
return virThreadLocalInit(&virLastErr, virLastErrFreeData);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal helper to ensure a generic error code is stored
|
|
|
|
* in case where API returns failure, but forgot to set an
|
|
|
|
* error
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
virErrorGenericFailure(virErrorPtr err)
|
|
|
|
{
|
|
|
|
err->code = VIR_ERR_INTERNAL_ERROR;
|
|
|
|
err->domain = VIR_FROM_NONE;
|
|
|
|
err->level = VIR_ERR_ERROR;
|
2019-10-18 11:27:03 +00:00
|
|
|
err->message = g_strdup(_("An error occurred, but the cause is unknown"));
|
2009-01-20 12:01:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-02-24 22:36:10 +00:00
|
|
|
/*
|
2012-02-03 18:20:22 +00:00
|
|
|
* Internal helper to perform a deep copy of an error
|
2009-01-20 12:01:45 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
virCopyError(virErrorPtr from,
|
|
|
|
virErrorPtr to)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
if (!to)
|
|
|
|
return 0;
|
|
|
|
virResetError(to);
|
|
|
|
if (!from)
|
|
|
|
return 0;
|
|
|
|
to->code = from->code;
|
|
|
|
to->domain = from->domain;
|
|
|
|
to->level = from->level;
|
2019-10-20 11:49:46 +00:00
|
|
|
to->message = g_strdup(from->message);
|
|
|
|
to->str1 = g_strdup(from->str1);
|
|
|
|
to->str2 = g_strdup(from->str2);
|
|
|
|
to->str3 = g_strdup(from->str3);
|
2009-01-20 12:01:45 +00:00
|
|
|
to->int1 = from->int1;
|
|
|
|
to->int2 = from->int2;
|
|
|
|
/*
|
2011-08-23 17:02:02 +00:00
|
|
|
* Deliberately not setting 'conn', 'dom', 'net' references
|
2009-01-20 12:01:45 +00:00
|
|
|
*/
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-07-10 06:44:41 +00:00
|
|
|
|
|
|
|
virErrorPtr
|
|
|
|
virErrorCopyNew(virErrorPtr err)
|
|
|
|
{
|
|
|
|
virErrorPtr ret;
|
|
|
|
|
|
|
|
if (VIR_ALLOC_QUIET(ret) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (virCopyError(err, ret) < 0)
|
|
|
|
VIR_FREE(ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-01-20 12:01:45 +00:00
|
|
|
static virErrorPtr
|
|
|
|
virLastErrorObject(void)
|
|
|
|
{
|
|
|
|
virErrorPtr err;
|
|
|
|
err = virThreadLocalGet(&virLastErr);
|
|
|
|
if (!err) {
|
2013-06-07 08:37:25 +00:00
|
|
|
if (VIR_ALLOC_QUIET(err) < 0)
|
2009-01-20 12:01:45 +00:00
|
|
|
return NULL;
|
2011-12-20 22:06:47 +00:00
|
|
|
if (virThreadLocalSet(&virLastErr, err) < 0)
|
|
|
|
VIR_FREE(err);
|
2009-01-20 12:01:45 +00:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-02-24 22:36:10 +00:00
|
|
|
* virGetLastError:
|
|
|
|
*
|
|
|
|
* Provide a pointer to the last error caught at the library level
|
2009-01-20 12:01:45 +00:00
|
|
|
*
|
|
|
|
* The error object is kept in thread local storage, so separate
|
|
|
|
* threads can safely access this concurrently.
|
2006-02-24 22:36:10 +00:00
|
|
|
*
|
2008-02-27 10:37:19 +00:00
|
|
|
* Returns a pointer to the last error or NULL if none occurred.
|
2006-02-24 22:36:10 +00:00
|
|
|
*/
|
|
|
|
virErrorPtr
|
2006-03-15 12:13:25 +00:00
|
|
|
virGetLastError(void)
|
|
|
|
{
|
2009-01-20 12:01:45 +00:00
|
|
|
virErrorPtr err = virLastErrorObject();
|
|
|
|
if (!err || err->code == VIR_ERR_OK)
|
|
|
|
return NULL;
|
|
|
|
return err;
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
2013-05-10 17:09:44 +00:00
|
|
|
|
2018-05-05 12:04:20 +00:00
|
|
|
/**
|
|
|
|
* virGetLastErrorCode:
|
|
|
|
*
|
|
|
|
* Get the most recent error code (enum virErrorNumber).
|
|
|
|
*
|
|
|
|
* Returns the most recent error code, or VIR_ERR_OK if none is set.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
virGetLastErrorCode(void)
|
|
|
|
{
|
|
|
|
virErrorPtr err = virLastErrorObject();
|
|
|
|
if (!err)
|
|
|
|
return VIR_ERR_OK;
|
|
|
|
return err->code;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virGetLastErrorDomain:
|
|
|
|
*
|
|
|
|
* Get the most recent error domain (enum virErrorDomain).
|
|
|
|
*
|
|
|
|
* Returns a numerical value of the most recent error's origin, or VIR_FROM_NONE
|
|
|
|
* if none is set.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
virGetLastErrorDomain(void)
|
|
|
|
{
|
|
|
|
virErrorPtr err = virLastErrorObject();
|
|
|
|
if (!err)
|
|
|
|
return VIR_FROM_NONE;
|
|
|
|
return err->domain;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-10 17:09:44 +00:00
|
|
|
/**
|
|
|
|
* virGetLastErrorMessage:
|
|
|
|
*
|
|
|
|
* Get the most recent error message
|
|
|
|
*
|
|
|
|
* Returns the most recent error message string in this
|
|
|
|
* thread, or a generic message if none is set
|
|
|
|
*/
|
|
|
|
const char *
|
|
|
|
virGetLastErrorMessage(void)
|
|
|
|
{
|
|
|
|
virErrorPtr err = virLastErrorObject();
|
2016-05-11 18:10:35 +00:00
|
|
|
if (err && err->code == VIR_ERR_OK)
|
2013-05-10 17:09:44 +00:00
|
|
|
return _("no error");
|
2016-05-11 18:10:35 +00:00
|
|
|
if (!err || !err->message)
|
2013-05-10 17:09:44 +00:00
|
|
|
return _("unknown error");
|
|
|
|
return err->message;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-09 01:38:55 +00:00
|
|
|
/**
|
|
|
|
* virSetError:
|
2010-01-26 00:59:48 +00:00
|
|
|
* @newerr: previously saved error object
|
2010-01-09 01:38:55 +00:00
|
|
|
*
|
|
|
|
* Set the current error from a previously saved error object
|
|
|
|
*
|
|
|
|
* Can be used to re-set an old error, which may have been squashed by
|
|
|
|
* other functions (like cleanup routines).
|
|
|
|
*
|
2011-07-20 23:07:59 +00:00
|
|
|
* Returns 0 on success, -1 on failure. Leaves errno unchanged.
|
2010-01-09 01:38:55 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
virSetError(virErrorPtr newerr)
|
|
|
|
{
|
|
|
|
virErrorPtr err;
|
2011-07-20 23:07:59 +00:00
|
|
|
int saved_errno = errno;
|
|
|
|
int ret = -1;
|
|
|
|
|
2010-02-16 18:07:31 +00:00
|
|
|
err = virLastErrorObject();
|
2010-01-09 01:38:55 +00:00
|
|
|
if (!err)
|
2011-07-20 23:07:59 +00:00
|
|
|
goto cleanup;
|
2010-01-09 01:38:55 +00:00
|
|
|
|
|
|
|
virResetError(err);
|
2011-07-20 23:07:59 +00:00
|
|
|
ret = virCopyError(newerr, err);
|
2014-03-25 06:53:22 +00:00
|
|
|
cleanup:
|
2011-07-20 23:07:59 +00:00
|
|
|
errno = saved_errno;
|
|
|
|
return ret;
|
2010-01-09 01:38:55 +00:00
|
|
|
}
|
|
|
|
|
2009-01-20 12:01:45 +00:00
|
|
|
/**
|
2006-02-24 22:36:10 +00:00
|
|
|
* virCopyLastError:
|
|
|
|
* @to: target to receive the copy
|
|
|
|
*
|
|
|
|
* Copy the content of the last error caught at the library level
|
2009-01-20 12:01:45 +00:00
|
|
|
*
|
|
|
|
* The error object is kept in thread local storage, so separate
|
|
|
|
* threads can safely access this concurrently.
|
|
|
|
*
|
2006-02-24 22:36:10 +00:00
|
|
|
* One will need to free the result with virResetError()
|
|
|
|
*
|
2018-07-02 11:16:52 +00:00
|
|
|
* Returns error code or -1 in case of parameter error.
|
2006-02-24 22:36:10 +00:00
|
|
|
*/
|
|
|
|
int
|
2006-03-15 12:13:25 +00:00
|
|
|
virCopyLastError(virErrorPtr to)
|
|
|
|
{
|
2009-01-20 12:01:45 +00:00
|
|
|
virErrorPtr err = virLastErrorObject();
|
2018-07-02 11:16:52 +00:00
|
|
|
|
|
|
|
if (!to)
|
|
|
|
return -1;
|
|
|
|
|
2011-07-20 22:53:31 +00:00
|
|
|
/* We can't guarantee caller has initialized it to zero */
|
2009-01-20 12:01:45 +00:00
|
|
|
memset(to, 0, sizeof(*to));
|
2018-07-02 11:16:52 +00:00
|
|
|
if (err) {
|
2009-01-20 12:01:45 +00:00
|
|
|
virCopyError(err, to);
|
2018-07-02 11:16:52 +00:00
|
|
|
} else {
|
2009-01-20 12:01:45 +00:00
|
|
|
virResetError(to);
|
2018-07-02 11:16:52 +00:00
|
|
|
to->code = VIR_ERR_NO_MEMORY;
|
|
|
|
to->domain = VIR_FROM_NONE;
|
|
|
|
to->level = VIR_ERR_ERROR;
|
|
|
|
}
|
2009-01-20 12:01:45 +00:00
|
|
|
return to->code;
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 14:16:23 +00:00
|
|
|
/**
|
|
|
|
* virSaveLastError:
|
|
|
|
*
|
2011-07-20 23:07:59 +00:00
|
|
|
* Save the last error into a new error object. On success, errno is
|
|
|
|
* unchanged; on failure, errno is ENOMEM.
|
2009-02-09 14:16:23 +00:00
|
|
|
*
|
|
|
|
* Returns a pointer to the copied error or NULL if allocation failed.
|
|
|
|
* It is the caller's responsibility to free the error with
|
|
|
|
* virFreeError().
|
|
|
|
*/
|
|
|
|
virErrorPtr
|
|
|
|
virSaveLastError(void)
|
|
|
|
{
|
|
|
|
virErrorPtr to;
|
2011-07-20 23:07:59 +00:00
|
|
|
int saved_errno = errno;
|
2009-02-09 14:16:23 +00:00
|
|
|
|
2020-09-11 11:42:03 +00:00
|
|
|
to = g_new0(virError, 1);
|
2009-02-09 14:16:23 +00:00
|
|
|
|
|
|
|
virCopyLastError(to);
|
2011-07-20 23:07:59 +00:00
|
|
|
errno = saved_errno;
|
2009-02-09 14:16:23 +00:00
|
|
|
return to;
|
|
|
|
}
|
|
|
|
|
2017-09-01 14:19:56 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* virErrorPreserveLast:
|
|
|
|
* @saveerr: pointer to virErrorPtr for storing last error object
|
|
|
|
*
|
|
|
|
* Preserves the currently set last error (for the thread) into @saveerr so that
|
|
|
|
* it can be restored via virErrorRestore(). @saveerr must be passed to
|
|
|
|
* virErrorRestore()
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
virErrorPreserveLast(virErrorPtr *saveerr)
|
|
|
|
{
|
|
|
|
int saved_errno = errno;
|
|
|
|
virErrorPtr lasterr = virGetLastError();
|
|
|
|
|
|
|
|
*saveerr = NULL;
|
|
|
|
|
|
|
|
if (lasterr)
|
|
|
|
*saveerr = virErrorCopyNew(lasterr);
|
|
|
|
|
|
|
|
errno = saved_errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virErrorRestore:
|
|
|
|
* @savederr: error object holding saved error
|
|
|
|
*
|
|
|
|
* Restores the error passed via @savederr and clears associated memory.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
virErrorRestore(virErrorPtr *savederr)
|
|
|
|
{
|
|
|
|
int saved_errno = errno;
|
|
|
|
|
|
|
|
if (!*savederr)
|
|
|
|
return;
|
|
|
|
|
|
|
|
virSetError(*savederr);
|
|
|
|
virFreeError(*savederr);
|
|
|
|
*savederr = NULL;
|
|
|
|
errno = saved_errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-02-24 22:36:10 +00:00
|
|
|
/**
|
|
|
|
* virResetError:
|
|
|
|
* @err: pointer to the virError to clean up
|
2008-02-05 19:27:37 +00:00
|
|
|
*
|
2006-02-24 22:36:10 +00:00
|
|
|
* Reset the error being pointed to
|
|
|
|
*/
|
|
|
|
void
|
2006-03-15 12:13:25 +00:00
|
|
|
virResetError(virErrorPtr err)
|
|
|
|
{
|
2006-02-24 22:36:10 +00:00
|
|
|
if (err == NULL)
|
|
|
|
return;
|
2009-12-09 23:00:50 +00:00
|
|
|
VIR_FREE(err->message);
|
|
|
|
VIR_FREE(err->str1);
|
|
|
|
VIR_FREE(err->str2);
|
|
|
|
VIR_FREE(err->str3);
|
2006-02-24 22:36:10 +00:00
|
|
|
memset(err, 0, sizeof(virError));
|
|
|
|
}
|
|
|
|
|
2009-02-09 14:16:23 +00:00
|
|
|
/**
|
|
|
|
* virFreeError:
|
|
|
|
* @err: error to free
|
|
|
|
*
|
|
|
|
* Resets and frees the given error.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
virFreeError(virErrorPtr err)
|
|
|
|
{
|
|
|
|
virResetError(err);
|
|
|
|
VIR_FREE(err);
|
|
|
|
}
|
2009-01-20 12:01:45 +00:00
|
|
|
|
2006-02-24 22:36:10 +00:00
|
|
|
/**
|
|
|
|
* virResetLastError:
|
2008-02-05 19:27:37 +00:00
|
|
|
*
|
2006-02-24 22:36:10 +00:00
|
|
|
* Reset the last error caught at the library level.
|
2009-01-20 12:01:45 +00:00
|
|
|
*
|
|
|
|
* The error object is kept in thread local storage, so separate
|
|
|
|
* threads can safely access this concurrently, only resetting
|
|
|
|
* their own error object.
|
2006-02-24 22:36:10 +00:00
|
|
|
*/
|
|
|
|
void
|
2006-03-15 12:13:25 +00:00
|
|
|
virResetLastError(void)
|
|
|
|
{
|
2009-01-20 12:01:45 +00:00
|
|
|
virErrorPtr err = virLastErrorObject();
|
|
|
|
if (err)
|
|
|
|
virResetError(err);
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConnGetLastError:
|
|
|
|
* @conn: pointer to the hypervisor connection
|
|
|
|
*
|
|
|
|
* Provide a pointer to the last error caught on that connection
|
2009-01-20 12:01:45 +00:00
|
|
|
*
|
|
|
|
* This method is not protected against access from multiple
|
|
|
|
* threads. In a multi-threaded application, always use the
|
|
|
|
* global virGetLastError() API which is backed by thread
|
|
|
|
* local storage.
|
|
|
|
*
|
|
|
|
* If the connection object was discovered to be invalid by
|
|
|
|
* an API call, then the error will be reported against the
|
|
|
|
* global error object.
|
2009-01-20 13:51:52 +00:00
|
|
|
*
|
2009-01-20 12:01:45 +00:00
|
|
|
* Since 0.6.0, all errors reported in the per-connection object
|
|
|
|
* are also duplicated in the global error object. As such an
|
|
|
|
* application can always use virGetLastError(). This method
|
2012-02-03 18:20:22 +00:00
|
|
|
* remains for backwards compatibility.
|
2006-02-24 22:36:10 +00:00
|
|
|
*
|
2008-02-27 10:37:19 +00:00
|
|
|
* Returns a pointer to the last error or NULL if none occurred.
|
2006-02-24 22:36:10 +00:00
|
|
|
*/
|
|
|
|
virErrorPtr
|
2006-03-15 12:13:25 +00:00
|
|
|
virConnGetLastError(virConnectPtr conn)
|
|
|
|
{
|
2006-02-24 22:36:10 +00:00
|
|
|
if (conn == NULL)
|
2009-01-20 12:01:45 +00:00
|
|
|
return NULL;
|
|
|
|
return &conn->err;
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConnCopyLastError:
|
|
|
|
* @conn: pointer to the hypervisor connection
|
|
|
|
* @to: target to receive the copy
|
|
|
|
*
|
|
|
|
* Copy the content of the last error caught on that connection
|
2009-01-20 12:01:45 +00:00
|
|
|
*
|
|
|
|
* This method is not protected against access from multiple
|
|
|
|
* threads. In a multi-threaded application, always use the
|
|
|
|
* global virGetLastError() API which is backed by thread
|
|
|
|
* local storage.
|
|
|
|
*
|
|
|
|
* If the connection object was discovered to be invalid by
|
|
|
|
* an API call, then the error will be reported against the
|
|
|
|
* global error object.
|
2009-01-20 13:51:52 +00:00
|
|
|
*
|
2009-01-20 12:01:45 +00:00
|
|
|
* Since 0.6.0, all errors reported in the per-connection object
|
|
|
|
* are also duplicated in the global error object. As such an
|
|
|
|
* application can always use virGetLastError(). This method
|
2012-02-03 18:20:22 +00:00
|
|
|
* remains for backwards compatibility.
|
2009-01-20 12:01:45 +00:00
|
|
|
*
|
2006-02-24 22:36:10 +00:00
|
|
|
* One will need to free the result with virResetError()
|
|
|
|
*
|
|
|
|
* Returns 0 if no error was found and the error code otherwise and -1 in case
|
|
|
|
* of parameter error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-15 12:13:25 +00:00
|
|
|
virConnCopyLastError(virConnectPtr conn, virErrorPtr to)
|
|
|
|
{
|
2011-07-20 22:53:31 +00:00
|
|
|
/* We can't guarantee caller has initialized it to zero */
|
2009-01-20 12:01:45 +00:00
|
|
|
memset(to, 0, sizeof(*to));
|
|
|
|
|
2006-02-24 22:36:10 +00:00
|
|
|
if (conn == NULL)
|
2009-01-20 12:01:45 +00:00
|
|
|
return -1;
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectLock(conn);
|
2006-02-24 22:36:10 +00:00
|
|
|
if (conn->err.code == VIR_ERR_OK)
|
2009-01-20 12:01:45 +00:00
|
|
|
virResetError(to);
|
|
|
|
else
|
|
|
|
virCopyError(&conn->err, to);
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectUnlock(conn);
|
2009-01-20 12:01:45 +00:00
|
|
|
return to->code;
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConnResetLastError:
|
|
|
|
* @conn: pointer to the hypervisor connection
|
|
|
|
*
|
2009-01-20 12:01:45 +00:00
|
|
|
* The error object is kept in thread local storage, so separate
|
|
|
|
* threads can safely access this concurrently.
|
|
|
|
*
|
2006-02-24 22:36:10 +00:00
|
|
|
* Reset the last error caught on that connection
|
|
|
|
*/
|
|
|
|
void
|
2006-03-15 12:13:25 +00:00
|
|
|
virConnResetLastError(virConnectPtr conn)
|
|
|
|
{
|
2006-02-24 22:36:10 +00:00
|
|
|
if (conn == NULL)
|
|
|
|
return;
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectLock(conn);
|
2006-02-24 22:36:10 +00:00
|
|
|
virResetError(&conn->err);
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectUnlock(conn);
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virSetErrorFunc:
|
|
|
|
* @userData: pointer to the user data provided in the handler callback
|
|
|
|
* @handler: the function to get called in case of error or NULL
|
|
|
|
*
|
|
|
|
* Set a library global error handling function, if @handler is NULL,
|
|
|
|
* it will reset to default printing on stderr. The error raised there
|
|
|
|
* are those for which no handler at the connection level could caught.
|
|
|
|
*/
|
|
|
|
void
|
2006-03-15 12:13:25 +00:00
|
|
|
virSetErrorFunc(void *userData, virErrorFunc handler)
|
|
|
|
{
|
2006-02-24 22:36:10 +00:00
|
|
|
virErrorHandler = handler;
|
|
|
|
virUserData = userData;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virConnSetErrorFunc:
|
|
|
|
* @conn: pointer to the hypervisor connection
|
|
|
|
* @userData: pointer to the user data provided in the handler callback
|
|
|
|
* @handler: the function to get called in case of error or NULL
|
|
|
|
*
|
|
|
|
* Set a connection error handling function, if @handler is NULL
|
|
|
|
* it will reset to default which is to pass error back to the global
|
|
|
|
* library handler.
|
|
|
|
*/
|
|
|
|
void
|
2006-03-15 12:13:25 +00:00
|
|
|
virConnSetErrorFunc(virConnectPtr conn, void *userData,
|
|
|
|
virErrorFunc handler)
|
|
|
|
{
|
2006-02-24 22:36:10 +00:00
|
|
|
if (conn == NULL)
|
|
|
|
return;
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectLock(conn);
|
2006-02-24 22:36:10 +00:00
|
|
|
conn->handler = handler;
|
|
|
|
conn->userData = userData;
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectUnlock(conn);
|
2006-02-24 22:36:10 +00:00
|
|
|
}
|
|
|
|
|
2006-02-27 16:27:18 +00:00
|
|
|
/**
|
2006-02-27 21:34:28 +00:00
|
|
|
* virDefaultErrorFunc:
|
2006-02-27 16:27:18 +00:00
|
|
|
* @err: pointer to the error.
|
|
|
|
*
|
2006-02-27 21:34:28 +00:00
|
|
|
* Default routine reporting an error to stderr.
|
2006-02-27 16:27:18 +00:00
|
|
|
*/
|
2006-02-27 21:34:28 +00:00
|
|
|
void
|
2006-03-15 12:13:25 +00:00
|
|
|
virDefaultErrorFunc(virErrorPtr err)
|
|
|
|
{
|
Tue Feb 14 15:37:17 EST 2007 Mark McLoughlin <markmc@redhat.com>
Note: potential ABI break here, but people should
only really be using virError structs returned from
libvirt itself.
* include/libvirt/virterror.h: add virNetwork
to virError
* src/internal.h, src/virterror.c: add network param
to __virRaiseError()
* src/conf.c, src/hash.c, src/libvirt.c, src/proxy_internal.c,
src/qemu_internal.c, src/sexpr.c, src/test.c, src/xen_internal.c,
src/xend_internal.c, src/xm_internal.c, src/xml.c, src/xmlrpc.c,
src/xs_internal.c: update.
2007-02-14 15:40:53 +00:00
|
|
|
const char *lvl = "", *dom = "", *domain = "", *network = "";
|
2006-02-27 16:27:18 +00:00
|
|
|
int len;
|
|
|
|
|
|
|
|
if ((err == NULL) || (err->code == VIR_ERR_OK))
|
|
|
|
return;
|
|
|
|
switch (err->level) {
|
|
|
|
case VIR_ERR_NONE:
|
2006-03-15 12:13:25 +00:00
|
|
|
lvl = "";
|
|
|
|
break;
|
2006-02-27 16:27:18 +00:00
|
|
|
case VIR_ERR_WARNING:
|
2006-09-21 15:24:37 +00:00
|
|
|
lvl = _("warning");
|
2006-03-15 12:13:25 +00:00
|
|
|
break;
|
2006-02-27 16:27:18 +00:00
|
|
|
case VIR_ERR_ERROR:
|
2006-09-21 15:24:37 +00:00
|
|
|
lvl = _("error");
|
2006-03-15 12:13:25 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-05-14 15:31:05 +00:00
|
|
|
dom = virErrorDomainTypeToString(err->domain);
|
|
|
|
if (!dom)
|
|
|
|
dom = "Unknown";
|
2006-02-27 16:27:18 +00:00
|
|
|
if ((err->dom != NULL) && (err->code != VIR_ERR_INVALID_DOMAIN)) {
|
|
|
|
domain = err->dom->name;
|
Tue Feb 14 15:37:17 EST 2007 Mark McLoughlin <markmc@redhat.com>
Note: potential ABI break here, but people should
only really be using virError structs returned from
libvirt itself.
* include/libvirt/virterror.h: add virNetwork
to virError
* src/internal.h, src/virterror.c: add network param
to __virRaiseError()
* src/conf.c, src/hash.c, src/libvirt.c, src/proxy_internal.c,
src/qemu_internal.c, src/sexpr.c, src/test.c, src/xen_internal.c,
src/xend_internal.c, src/xm_internal.c, src/xml.c, src/xmlrpc.c,
src/xs_internal.c: update.
2007-02-14 15:40:53 +00:00
|
|
|
} else if ((err->net != NULL) && (err->code != VIR_ERR_INVALID_NETWORK)) {
|
|
|
|
network = err->net->name;
|
2006-02-27 16:27:18 +00:00
|
|
|
}
|
|
|
|
len = strlen(err->message);
|
2006-11-08 16:55:20 +00:00
|
|
|
if ((err->domain == VIR_FROM_XML) && (err->code == VIR_ERR_XML_DETAIL) &&
|
|
|
|
(err->int1 != 0))
|
2013-03-04 12:38:18 +00:00
|
|
|
fprintf(stderr, "libvirt: %s %s %s%s: line %d: %s",
|
Tue Feb 14 15:37:17 EST 2007 Mark McLoughlin <markmc@redhat.com>
Note: potential ABI break here, but people should
only really be using virError structs returned from
libvirt itself.
* include/libvirt/virterror.h: add virNetwork
to virError
* src/internal.h, src/virterror.c: add network param
to __virRaiseError()
* src/conf.c, src/hash.c, src/libvirt.c, src/proxy_internal.c,
src/qemu_internal.c, src/sexpr.c, src/test.c, src/xen_internal.c,
src/xend_internal.c, src/xm_internal.c, src/xml.c, src/xmlrpc.c,
src/xs_internal.c: update.
2007-02-14 15:40:53 +00:00
|
|
|
dom, lvl, domain, network, err->int1, err->message);
|
2006-11-08 16:55:20 +00:00
|
|
|
else if ((len == 0) || (err->message[len - 1] != '\n'))
|
2013-03-04 12:38:18 +00:00
|
|
|
fprintf(stderr, "libvirt: %s %s %s%s: %s\n",
|
Tue Feb 14 15:37:17 EST 2007 Mark McLoughlin <markmc@redhat.com>
Note: potential ABI break here, but people should
only really be using virError structs returned from
libvirt itself.
* include/libvirt/virterror.h: add virNetwork
to virError
* src/internal.h, src/virterror.c: add network param
to __virRaiseError()
* src/conf.c, src/hash.c, src/libvirt.c, src/proxy_internal.c,
src/qemu_internal.c, src/sexpr.c, src/test.c, src/xen_internal.c,
src/xend_internal.c, src/xm_internal.c, src/xml.c, src/xmlrpc.c,
src/xs_internal.c: update.
2007-02-14 15:40:53 +00:00
|
|
|
dom, lvl, domain, network, err->message);
|
2006-03-15 12:13:25 +00:00
|
|
|
else
|
2013-03-04 12:38:18 +00:00
|
|
|
fprintf(stderr, "libvirt: %s %s %s%s: %s",
|
Tue Feb 14 15:37:17 EST 2007 Mark McLoughlin <markmc@redhat.com>
Note: potential ABI break here, but people should
only really be using virError structs returned from
libvirt itself.
* include/libvirt/virterror.h: add virNetwork
to virError
* src/internal.h, src/virterror.c: add network param
to __virRaiseError()
* src/conf.c, src/hash.c, src/libvirt.c, src/proxy_internal.c,
src/qemu_internal.c, src/sexpr.c, src/test.c, src/xen_internal.c,
src/xend_internal.c, src/xm_internal.c, src/xml.c, src/xmlrpc.c,
src/xs_internal.c: update.
2007-02-14 15:40:53 +00:00
|
|
|
dom, lvl, domain, network, err->message);
|
2006-02-27 16:27:18 +00:00
|
|
|
}
|
|
|
|
|
2009-04-24 14:04:54 +00:00
|
|
|
/**
|
2009-09-30 15:11:47 +00:00
|
|
|
* virDispatchError:
|
2009-04-24 14:04:54 +00:00
|
|
|
* @conn: pointer to the hypervisor connection
|
|
|
|
*
|
2009-09-30 15:11:47 +00:00
|
|
|
* Internal helper to do final stage of error
|
|
|
|
* reporting in public APIs.
|
|
|
|
*
|
|
|
|
* - Copy the global error to per-connection error if needed
|
|
|
|
* - Set a generic error message if none is already set
|
|
|
|
* - Invoke the error callback functions
|
2009-01-20 12:01:45 +00:00
|
|
|
*/
|
|
|
|
void
|
2009-09-30 15:11:47 +00:00
|
|
|
virDispatchError(virConnectPtr conn)
|
2009-01-20 12:01:45 +00:00
|
|
|
{
|
|
|
|
virErrorPtr err = virLastErrorObject();
|
2009-09-30 15:11:47 +00:00
|
|
|
virErrorFunc handler = virErrorHandler;
|
|
|
|
void *userData = virUserData;
|
|
|
|
|
2011-12-20 22:06:47 +00:00
|
|
|
/* Can only happen on OOM. */
|
2009-09-30 15:11:47 +00:00
|
|
|
if (!err)
|
|
|
|
return;
|
2009-01-20 12:01:45 +00:00
|
|
|
|
2009-09-30 15:11:47 +00:00
|
|
|
/* Set a generic error message if none is already set */
|
|
|
|
if (err->code == VIR_ERR_OK)
|
2009-01-20 12:01:45 +00:00
|
|
|
virErrorGenericFailure(err);
|
|
|
|
|
2009-09-30 15:11:47 +00:00
|
|
|
/* Copy the global error to per-connection error if needed */
|
2009-01-20 12:01:45 +00:00
|
|
|
if (conn) {
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectLock(conn);
|
2009-09-30 15:11:47 +00:00
|
|
|
virCopyError(err, &conn->err);
|
|
|
|
|
|
|
|
if (conn->handler != NULL) {
|
|
|
|
handler = conn->handler;
|
|
|
|
userData = conn->userData;
|
|
|
|
}
|
2015-04-09 07:43:53 +00:00
|
|
|
virObjectUnlock(conn);
|
2009-01-20 12:01:45 +00:00
|
|
|
}
|
2009-09-30 15:11:47 +00:00
|
|
|
|
|
|
|
/* Invoke the error callback functions */
|
|
|
|
if (handler != NULL) {
|
|
|
|
(handler)(userData, err);
|
|
|
|
} else {
|
|
|
|
virDefaultErrorFunc(err);
|
|
|
|
}
|
2009-01-20 12:01:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-19 12:30:24 +00:00
|
|
|
/*
|
|
|
|
* Reports an error through the logging subsystem
|
|
|
|
*/
|
|
|
|
static
|
|
|
|
void virRaiseErrorLog(const char *filename,
|
|
|
|
const char *funcname,
|
|
|
|
size_t linenr,
|
|
|
|
virErrorPtr err,
|
|
|
|
virLogMetadata *meta)
|
|
|
|
{
|
|
|
|
int priority;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hook up the error or warning to the logging facility
|
|
|
|
*/
|
|
|
|
priority = virErrorLevelPriority(err->level);
|
|
|
|
if (virErrorLogPriorityFilter)
|
|
|
|
priority = virErrorLogPriorityFilter(err, priority);
|
|
|
|
|
|
|
|
/* We don't want to pollute stderr if no logging outputs
|
|
|
|
* are explicitly requested by the user, since the default
|
|
|
|
* error function already pollutes stderr and most apps
|
|
|
|
* hate & thus disable that too. If the daemon has set
|
|
|
|
* a priority filter though, we should always forward
|
|
|
|
* all errors to the logging code.
|
|
|
|
*/
|
|
|
|
if (virLogGetNbOutputs() > 0 ||
|
|
|
|
virErrorLogPriorityFilter)
|
|
|
|
virLogMessage(&virLogSelf,
|
|
|
|
priority,
|
|
|
|
filename, linenr, funcname,
|
|
|
|
meta, "%s", err->message);
|
|
|
|
}
|
2009-01-20 12:01:45 +00:00
|
|
|
|
2006-02-27 16:27:18 +00:00
|
|
|
/**
|
2009-05-27 12:10:47 +00:00
|
|
|
* virRaiseErrorFull:
|
|
|
|
* @filename: filename where error was raised
|
|
|
|
* @funcname: function name where error was raised
|
|
|
|
* @linenr: line number where error was raised
|
2006-02-27 16:27:18 +00:00
|
|
|
* @domain: the virErrorDomain indicating where it's coming from
|
|
|
|
* @code: the virErrorNumber code for the error
|
|
|
|
* @level: the virErrorLevel for the error
|
|
|
|
* @str1: extra string info
|
|
|
|
* @str2: extra string info
|
|
|
|
* @str3: extra string info
|
|
|
|
* @int1: extra int info
|
|
|
|
* @int2: extra int info
|
2009-05-29 16:51:15 +00:00
|
|
|
* @fmt: the message to display/transmit
|
2006-02-27 16:27:18 +00:00
|
|
|
* @...: extra parameters for the message display
|
|
|
|
*
|
|
|
|
* Internal routine called when an error is detected. It will raise it
|
|
|
|
* immediately if a callback is found and store it for later handling.
|
|
|
|
*/
|
|
|
|
void
|
2015-01-19 12:30:24 +00:00
|
|
|
virRaiseErrorFull(const char *filename,
|
2009-05-27 12:10:47 +00:00
|
|
|
const char *funcname,
|
|
|
|
size_t linenr,
|
|
|
|
int domain,
|
|
|
|
int code,
|
|
|
|
virErrorLevel level,
|
|
|
|
const char *str1,
|
|
|
|
const char *str2,
|
|
|
|
const char *str3,
|
|
|
|
int int1,
|
|
|
|
int int2,
|
|
|
|
const char *fmt, ...)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2010-12-23 18:23:42 +00:00
|
|
|
int save_errno = errno;
|
2009-01-20 12:01:45 +00:00
|
|
|
virErrorPtr to;
|
2006-02-27 16:27:18 +00:00
|
|
|
char *str;
|
2014-02-21 17:23:10 +00:00
|
|
|
virLogMetadata meta[] = {
|
|
|
|
{ .key = "LIBVIRT_DOMAIN", .s = NULL, .iv = domain },
|
|
|
|
{ .key = "LIBVIRT_CODE", .s = NULL, .iv = code },
|
|
|
|
{ .key = NULL },
|
|
|
|
};
|
2006-02-27 16:27:18 +00:00
|
|
|
|
2009-01-20 12:01:45 +00:00
|
|
|
/*
|
|
|
|
* All errors are recorded in thread local storage
|
2012-02-03 18:20:22 +00:00
|
|
|
* For compatibility, public API calls will copy them
|
2009-09-21 09:44:54 +00:00
|
|
|
* to the per-connection error object when necessary
|
2009-01-20 12:01:45 +00:00
|
|
|
*/
|
|
|
|
to = virLastErrorObject();
|
2010-12-23 18:23:42 +00:00
|
|
|
if (!to) {
|
|
|
|
errno = save_errno;
|
2009-01-20 12:01:45 +00:00
|
|
|
return; /* Hit OOM allocating thread error object, sod all we can do now */
|
2010-12-23 18:23:42 +00:00
|
|
|
}
|
2009-01-20 12:01:45 +00:00
|
|
|
|
|
|
|
virResetError(to);
|
|
|
|
|
2010-12-23 18:23:42 +00:00
|
|
|
if (code == VIR_ERR_OK) {
|
|
|
|
errno = save_errno;
|
2006-03-15 12:13:25 +00:00
|
|
|
return;
|
2010-12-23 18:23:42 +00:00
|
|
|
}
|
2006-02-27 16:27:18 +00:00
|
|
|
|
|
|
|
/*
|
2011-05-24 17:20:19 +00:00
|
|
|
* formats the message; drop message on OOM situations
|
2006-02-27 16:27:18 +00:00
|
|
|
*/
|
2009-05-27 12:10:47 +00:00
|
|
|
if (fmt == NULL) {
|
2019-10-18 11:27:03 +00:00
|
|
|
str = g_strdup(_("No error message provided"));
|
2006-02-27 16:27:18 +00:00
|
|
|
} else {
|
2011-05-24 17:20:19 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
2019-10-22 12:11:15 +00:00
|
|
|
str = g_strdup_vprintf(fmt, ap);
|
2011-05-24 17:20:19 +00:00
|
|
|
va_end(ap);
|
2006-02-27 16:27:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the information about the error
|
|
|
|
*/
|
2009-01-20 12:01:45 +00:00
|
|
|
/*
|
2011-08-23 17:02:02 +00:00
|
|
|
* Deliberately not setting conn, dom & net fields since
|
2009-01-20 12:01:45 +00:00
|
|
|
* they're utterly unsafe
|
|
|
|
*/
|
2006-02-27 16:27:18 +00:00
|
|
|
to->domain = domain;
|
|
|
|
to->code = code;
|
|
|
|
to->message = str;
|
|
|
|
to->level = level;
|
2019-10-18 11:27:03 +00:00
|
|
|
to->str1 = g_strdup(str1);
|
|
|
|
to->str2 = g_strdup(str2);
|
|
|
|
to->str3 = g_strdup(str3);
|
2006-02-27 16:27:18 +00:00
|
|
|
to->int1 = int1;
|
|
|
|
to->int2 = int2;
|
2010-12-23 18:23:42 +00:00
|
|
|
|
2015-01-19 12:30:24 +00:00
|
|
|
virRaiseErrorLog(filename, funcname, linenr,
|
|
|
|
to, meta);
|
2011-01-21 17:25:01 +00:00
|
|
|
|
2010-12-23 18:23:42 +00:00
|
|
|
errno = save_errno;
|
2006-02-27 16:27:18 +00:00
|
|
|
}
|
|
|
|
|
2015-01-19 12:30:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* virRaiseErrorObject:
|
|
|
|
* @filename: filename where error was raised
|
|
|
|
* @funcname: function name where error was raised
|
|
|
|
* @linenr: line number where error was raised
|
|
|
|
* @newerr: the error object to report
|
|
|
|
*
|
|
|
|
* Sets the thread local error object to be a copy of
|
|
|
|
* @newerr and logs the error
|
|
|
|
*
|
|
|
|
* This is like virRaiseErrorFull, except that it accepts the
|
|
|
|
* error information via a pre-filled virErrorPtr object
|
|
|
|
*
|
|
|
|
* This is like virSetError, except that it will trigger the
|
|
|
|
* logging callbacks.
|
|
|
|
*
|
|
|
|
* The caller must clear the @newerr instance afterwards, since
|
|
|
|
* it will be copied into the thread local error.
|
|
|
|
*/
|
|
|
|
void virRaiseErrorObject(const char *filename,
|
|
|
|
const char *funcname,
|
|
|
|
size_t linenr,
|
|
|
|
virErrorPtr newerr)
|
|
|
|
{
|
|
|
|
int saved_errno = errno;
|
|
|
|
virErrorPtr err;
|
|
|
|
virLogMetadata meta[] = {
|
|
|
|
{ .key = "LIBVIRT_DOMAIN", .s = NULL, .iv = newerr->domain },
|
|
|
|
{ .key = "LIBVIRT_CODE", .s = NULL, .iv = newerr->code },
|
|
|
|
{ .key = NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
err = virLastErrorObject();
|
|
|
|
if (!err)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
virResetError(err);
|
|
|
|
virCopyError(newerr, err);
|
|
|
|
virRaiseErrorLog(filename, funcname, linenr,
|
|
|
|
err, meta);
|
|
|
|
cleanup:
|
|
|
|
errno = saved_errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-12-05 13:41:18 +00:00
|
|
|
typedef struct {
|
|
|
|
const char *msg;
|
|
|
|
const char *msginfo;
|
|
|
|
} virErrorMsgTuple;
|
|
|
|
|
|
|
|
|
2020-01-09 08:53:31 +00:00
|
|
|
static const virErrorMsgTuple virErrorMsgStrings[] = {
|
2018-12-05 13:41:18 +00:00
|
|
|
[VIR_ERR_OK] = { NULL, NULL },
|
2018-12-17 16:00:13 +00:00
|
|
|
[VIR_ERR_INTERNAL_ERROR] = {
|
|
|
|
N_("internal error"),
|
|
|
|
N_("internal error: %s") },
|
|
|
|
[VIR_ERR_NO_MEMORY] = {
|
|
|
|
N_("out of memory"),
|
|
|
|
N_("out of memory: %s") },
|
|
|
|
[VIR_ERR_NO_SUPPORT] = {
|
|
|
|
N_("this function is not supported by the connection driver"),
|
|
|
|
N_("this function is not supported by the connection driver: %s") },
|
|
|
|
[VIR_ERR_UNKNOWN_HOST] = {
|
|
|
|
N_("unknown host"),
|
|
|
|
N_("unknown host %s") },
|
|
|
|
[VIR_ERR_NO_CONNECT] = {
|
|
|
|
N_("no connection driver available"),
|
|
|
|
N_("no connection driver available for %s") },
|
|
|
|
[VIR_ERR_INVALID_CONN] = {
|
|
|
|
N_("invalid connection pointer in"),
|
|
|
|
N_("invalid connection pointer in %s") },
|
|
|
|
[VIR_ERR_INVALID_DOMAIN] = {
|
|
|
|
N_("invalid domain pointer in"),
|
|
|
|
N_("invalid domain pointer in %s") },
|
|
|
|
[VIR_ERR_INVALID_ARG] = {
|
|
|
|
N_("invalid argument"),
|
|
|
|
N_("invalid argument: %s") },
|
|
|
|
[VIR_ERR_OPERATION_FAILED] = {
|
|
|
|
N_("operation failed"),
|
|
|
|
N_("operation failed: %s") },
|
|
|
|
[VIR_ERR_GET_FAILED] = {
|
|
|
|
N_("GET operation failed"),
|
|
|
|
N_("GET operation failed: %s") },
|
|
|
|
[VIR_ERR_POST_FAILED] = {
|
|
|
|
N_("POST operation failed"),
|
|
|
|
N_("POST operation failed: %s") },
|
|
|
|
[VIR_ERR_HTTP_ERROR] = {
|
|
|
|
N_("got unknown HTTP error code"),
|
|
|
|
N_("got unknown HTTP error code %s") },
|
|
|
|
[VIR_ERR_SEXPR_SERIAL] = {
|
|
|
|
N_("failed to serialize S-Expr"),
|
|
|
|
N_("failed to serialize S-Expr: %s") },
|
|
|
|
[VIR_ERR_NO_XEN] = {
|
|
|
|
N_("could not use Xen hypervisor entry"),
|
|
|
|
N_("could not use Xen hypervisor entry %s") },
|
|
|
|
[VIR_ERR_XEN_CALL] = {
|
|
|
|
N_("failed Xen syscall"),
|
|
|
|
N_("failed Xen syscall %s") },
|
|
|
|
[VIR_ERR_OS_TYPE] = {
|
|
|
|
N_("unknown OS type"),
|
|
|
|
N_("unknown OS type %s") },
|
|
|
|
[VIR_ERR_NO_KERNEL] = {
|
|
|
|
N_("missing kernel information"),
|
|
|
|
N_("missing kernel information: %s") },
|
|
|
|
[VIR_ERR_NO_ROOT] = {
|
|
|
|
N_("missing root device information"),
|
|
|
|
N_("missing root device information in %s") },
|
|
|
|
[VIR_ERR_NO_SOURCE] = {
|
|
|
|
N_("missing source information for device"),
|
|
|
|
N_("missing source information for device %s") },
|
|
|
|
[VIR_ERR_NO_TARGET] = {
|
|
|
|
N_("missing target information for device"),
|
|
|
|
N_("missing target information for device %s") },
|
|
|
|
[VIR_ERR_NO_NAME] = {
|
|
|
|
N_("missing name information"),
|
|
|
|
N_("missing name information in %s") },
|
|
|
|
[VIR_ERR_NO_OS] = {
|
|
|
|
N_("missing operating system information"),
|
|
|
|
N_("missing operating system information for %s") },
|
|
|
|
[VIR_ERR_NO_DEVICE] = {
|
|
|
|
N_("missing devices information"),
|
|
|
|
N_("missing devices information for %s") },
|
|
|
|
[VIR_ERR_NO_XENSTORE] = {
|
|
|
|
N_("could not connect to Xen Store"),
|
|
|
|
N_("could not connect to Xen Store %s") },
|
|
|
|
[VIR_ERR_DRIVER_FULL] = {
|
|
|
|
N_("too many drivers registered"),
|
|
|
|
N_("too many drivers registered in %s") },
|
|
|
|
[VIR_ERR_CALL_FAILED] = {
|
|
|
|
N_("library call failed"),
|
|
|
|
N_("library call failed: %s") },
|
|
|
|
[VIR_ERR_XML_ERROR] = {
|
|
|
|
N_("XML description is invalid or not well formed"),
|
|
|
|
N_("XML error: %s") },
|
|
|
|
[VIR_ERR_DOM_EXIST] = {
|
|
|
|
N_("this domain exists already"),
|
|
|
|
N_("domain %s exists already") },
|
|
|
|
[VIR_ERR_OPERATION_DENIED] = {
|
|
|
|
N_("operation forbidden for read only access"),
|
|
|
|
N_("operation forbidden: %s") },
|
|
|
|
[VIR_ERR_OPEN_FAILED] = {
|
|
|
|
N_("failed to open configuration file"),
|
|
|
|
N_("failed to open configuration file %s") },
|
|
|
|
[VIR_ERR_READ_FAILED] = {
|
|
|
|
N_("failed to read configuration file"),
|
|
|
|
N_("failed to read configuration file %s") },
|
|
|
|
[VIR_ERR_PARSE_FAILED] = {
|
|
|
|
N_("failed to parse configuration file"),
|
|
|
|
N_("failed to parse configuration file %s") },
|
|
|
|
[VIR_ERR_CONF_SYNTAX] = {
|
|
|
|
N_("configuration file syntax error"),
|
|
|
|
N_("configuration file syntax error: %s") },
|
|
|
|
[VIR_ERR_WRITE_FAILED] = {
|
|
|
|
N_("failed to write configuration file"),
|
|
|
|
N_("failed to write configuration file: %s") },
|
|
|
|
[VIR_ERR_XML_DETAIL] = {
|
|
|
|
N_("parser error"),
|
|
|
|
"%s" },
|
|
|
|
[VIR_ERR_INVALID_NETWORK] = {
|
|
|
|
N_("invalid network pointer in"),
|
|
|
|
N_("invalid network pointer in %s") },
|
|
|
|
[VIR_ERR_NETWORK_EXIST] = {
|
|
|
|
N_("this network exists already"),
|
|
|
|
N_("network %s exists already") },
|
|
|
|
[VIR_ERR_SYSTEM_ERROR] = {
|
|
|
|
N_("system call error"),
|
|
|
|
"%s" },
|
|
|
|
[VIR_ERR_RPC] = {
|
|
|
|
N_("RPC error"),
|
|
|
|
"%s" },
|
|
|
|
[VIR_ERR_GNUTLS_ERROR] = {
|
|
|
|
N_("GNUTLS call error"),
|
|
|
|
"%s" },
|
|
|
|
[VIR_WAR_NO_NETWORK] = {
|
|
|
|
N_("Failed to find the network"),
|
|
|
|
N_("Failed to find the network: %s") },
|
|
|
|
[VIR_ERR_NO_DOMAIN] = {
|
|
|
|
N_("Domain not found"),
|
|
|
|
N_("Domain not found: %s") },
|
|
|
|
[VIR_ERR_NO_NETWORK] = {
|
|
|
|
N_("Network not found"),
|
|
|
|
N_("Network not found: %s") },
|
|
|
|
[VIR_ERR_INVALID_MAC] = {
|
|
|
|
N_("invalid MAC address"),
|
|
|
|
N_("invalid MAC address: %s") },
|
|
|
|
[VIR_ERR_AUTH_FAILED] = {
|
|
|
|
N_("authentication failed"),
|
|
|
|
N_("authentication failed: %s") },
|
|
|
|
[VIR_ERR_INVALID_STORAGE_POOL] = {
|
|
|
|
N_("invalid storage pool pointer in"),
|
|
|
|
N_("invalid storage pool pointer in %s") },
|
|
|
|
[VIR_ERR_INVALID_STORAGE_VOL] = {
|
|
|
|
N_("invalid storage volume pointer in"),
|
|
|
|
N_("invalid storage volume pointer in %s") },
|
|
|
|
[VIR_WAR_NO_STORAGE] = {
|
|
|
|
N_("Failed to find a storage driver"),
|
|
|
|
N_("Failed to find a storage driver: %s") },
|
|
|
|
[VIR_ERR_NO_STORAGE_POOL] = {
|
|
|
|
N_("Storage pool not found"),
|
|
|
|
N_("Storage pool not found: %s") },
|
|
|
|
[VIR_ERR_NO_STORAGE_VOL] = {
|
|
|
|
N_("Storage volume not found"),
|
|
|
|
N_("Storage volume not found: %s") },
|
|
|
|
[VIR_WAR_NO_NODE] = {
|
|
|
|
N_("Failed to find a node driver"),
|
|
|
|
N_("Failed to find a node driver: %s") },
|
|
|
|
[VIR_ERR_INVALID_NODE_DEVICE] = {
|
|
|
|
N_("invalid node device pointer"),
|
|
|
|
N_("invalid node device pointer in %s") },
|
|
|
|
[VIR_ERR_NO_NODE_DEVICE] = {
|
|
|
|
N_("Node device not found"),
|
|
|
|
N_("Node device not found: %s") },
|
|
|
|
[VIR_ERR_NO_SECURITY_MODEL] = {
|
|
|
|
N_("Security model not found"),
|
|
|
|
N_("Security model not found: %s") },
|
|
|
|
[VIR_ERR_OPERATION_INVALID] = {
|
|
|
|
N_("Requested operation is not valid"),
|
|
|
|
N_("Requested operation is not valid: %s") },
|
|
|
|
[VIR_WAR_NO_INTERFACE] = {
|
|
|
|
N_("Failed to find the interface"),
|
|
|
|
N_("Failed to find the interface: %s") },
|
|
|
|
[VIR_ERR_NO_INTERFACE] = {
|
|
|
|
N_("Interface not found"),
|
|
|
|
N_("Interface not found: %s") },
|
|
|
|
[VIR_ERR_INVALID_INTERFACE] = {
|
|
|
|
N_("invalid interface pointer in"),
|
|
|
|
N_("invalid interface pointer in %s") },
|
|
|
|
[VIR_ERR_MULTIPLE_INTERFACES] = {
|
|
|
|
N_("multiple matching interfaces found"),
|
|
|
|
N_("multiple matching interfaces found: %s") },
|
|
|
|
[VIR_WAR_NO_NWFILTER] = {
|
|
|
|
N_("Failed to start the nwfilter driver"),
|
|
|
|
N_("Failed to start the nwfilter driver: %s") },
|
|
|
|
[VIR_ERR_INVALID_NWFILTER] = {
|
|
|
|
N_("Invalid network filter"),
|
|
|
|
N_("Invalid network filter: %s") },
|
|
|
|
[VIR_ERR_NO_NWFILTER] = {
|
|
|
|
N_("Network filter not found"),
|
|
|
|
N_("Network filter not found: %s") },
|
|
|
|
[VIR_ERR_BUILD_FIREWALL] = {
|
|
|
|
N_("Error while building firewall"),
|
|
|
|
N_("Error while building firewall: %s") },
|
|
|
|
[VIR_WAR_NO_SECRET] = {
|
|
|
|
N_("Failed to find a secret storage driver"),
|
|
|
|
N_("Failed to find a secret storage driver: %s") },
|
|
|
|
[VIR_ERR_INVALID_SECRET] = {
|
|
|
|
N_("Invalid secret"),
|
|
|
|
N_("Invalid secret: %s") },
|
|
|
|
[VIR_ERR_NO_SECRET] = {
|
|
|
|
N_("Secret not found"),
|
|
|
|
N_("Secret not found: %s") },
|
|
|
|
[VIR_ERR_CONFIG_UNSUPPORTED] = {
|
|
|
|
N_("unsupported configuration"),
|
|
|
|
N_("unsupported configuration: %s") },
|
|
|
|
[VIR_ERR_OPERATION_TIMEOUT] = {
|
|
|
|
N_("Timed out during operation"),
|
|
|
|
N_("Timed out during operation: %s") },
|
|
|
|
[VIR_ERR_MIGRATE_PERSIST_FAILED] = {
|
|
|
|
N_("Failed to make domain persistent after migration"),
|
|
|
|
N_("Failed to make domain persistent after migration: %s") },
|
|
|
|
[VIR_ERR_HOOK_SCRIPT_FAILED] = {
|
|
|
|
N_("Hook script execution failed"),
|
|
|
|
N_("Hook script execution failed: %s") },
|
|
|
|
[VIR_ERR_INVALID_DOMAIN_SNAPSHOT] = {
|
2019-02-25 16:37:58 +00:00
|
|
|
N_("Invalid domain snapshot"),
|
|
|
|
N_("Invalid domain snapshot: %s") },
|
2018-12-17 16:00:13 +00:00
|
|
|
[VIR_ERR_NO_DOMAIN_SNAPSHOT] = {
|
|
|
|
N_("Domain snapshot not found"),
|
|
|
|
N_("Domain snapshot not found: %s") },
|
|
|
|
[VIR_ERR_INVALID_STREAM] = {
|
|
|
|
N_("invalid stream pointer"),
|
|
|
|
N_("invalid stream pointer in %s") },
|
|
|
|
[VIR_ERR_ARGUMENT_UNSUPPORTED] = {
|
|
|
|
N_("argument unsupported"),
|
|
|
|
N_("argument unsupported: %s") },
|
|
|
|
[VIR_ERR_STORAGE_PROBE_FAILED] = {
|
|
|
|
N_("Storage pool probe failed"),
|
|
|
|
N_("Storage pool probe failed: %s") },
|
|
|
|
[VIR_ERR_STORAGE_POOL_BUILT] = {
|
|
|
|
N_("Storage pool already built"),
|
|
|
|
N_("Storage pool already built: %s") },
|
|
|
|
[VIR_ERR_SNAPSHOT_REVERT_RISKY] = {
|
|
|
|
N_("revert requires force"),
|
|
|
|
N_("revert requires force: %s") },
|
|
|
|
[VIR_ERR_OPERATION_ABORTED] = {
|
|
|
|
N_("operation aborted"),
|
|
|
|
N_("operation aborted: %s") },
|
|
|
|
[VIR_ERR_AUTH_CANCELLED] = {
|
|
|
|
N_("authentication cancelled"),
|
|
|
|
N_("authentication cancelled: %s") },
|
|
|
|
[VIR_ERR_NO_DOMAIN_METADATA] = {
|
|
|
|
N_("metadata not found"),
|
|
|
|
N_("metadata not found: %s") },
|
|
|
|
[VIR_ERR_MIGRATE_UNSAFE] = {
|
|
|
|
N_("Unsafe migration"),
|
|
|
|
N_("Unsafe migration: %s") },
|
|
|
|
[VIR_ERR_OVERFLOW] = {
|
|
|
|
N_("numerical overflow"),
|
|
|
|
N_("numerical overflow: %s") },
|
|
|
|
[VIR_ERR_BLOCK_COPY_ACTIVE] = {
|
|
|
|
N_("block copy still active"),
|
|
|
|
N_("block copy still active: %s") },
|
|
|
|
[VIR_ERR_OPERATION_UNSUPPORTED] = {
|
|
|
|
N_("Operation not supported"),
|
|
|
|
N_("Operation not supported: %s") },
|
|
|
|
[VIR_ERR_SSH] = {
|
|
|
|
N_("SSH transport error"),
|
|
|
|
N_("SSH transport error: %s") },
|
|
|
|
[VIR_ERR_AGENT_UNRESPONSIVE] = {
|
|
|
|
N_("Guest agent is not responding"),
|
|
|
|
N_("Guest agent is not responding: %s") },
|
|
|
|
[VIR_ERR_RESOURCE_BUSY] = {
|
|
|
|
N_("resource busy"),
|
|
|
|
N_("resource busy: %s") },
|
|
|
|
[VIR_ERR_ACCESS_DENIED] = {
|
|
|
|
N_("access denied"),
|
|
|
|
N_("access denied: %s") },
|
|
|
|
[VIR_ERR_DBUS_SERVICE] = {
|
|
|
|
N_("error from service"),
|
|
|
|
N_("error from service: %s") },
|
|
|
|
[VIR_ERR_STORAGE_VOL_EXIST] = {
|
|
|
|
N_("this storage volume exists already"),
|
|
|
|
N_("storage volume %s exists already") },
|
|
|
|
[VIR_ERR_CPU_INCOMPATIBLE] = {
|
|
|
|
N_("the CPU is incompatible with host CPU"),
|
|
|
|
N_("the CPU is incompatible with host CPU: %s") },
|
|
|
|
[VIR_ERR_XML_INVALID_SCHEMA] = {
|
|
|
|
N_("XML document failed to validate against schema"),
|
|
|
|
N_("XML document failed to validate against schema: %s") },
|
|
|
|
[VIR_ERR_MIGRATE_FINISH_OK] = {
|
|
|
|
N_("migration successfully aborted"),
|
|
|
|
N_("migration successfully aborted: %s") },
|
|
|
|
[VIR_ERR_AUTH_UNAVAILABLE] = {
|
|
|
|
N_("authentication unavailable"),
|
|
|
|
N_("authentication unavailable: %s") },
|
|
|
|
[VIR_ERR_NO_SERVER] = {
|
|
|
|
N_("Server not found"),
|
|
|
|
N_("Server not found: %s") },
|
|
|
|
[VIR_ERR_NO_CLIENT] = {
|
|
|
|
N_("Client not found"),
|
|
|
|
N_("Client not found: %s") },
|
|
|
|
[VIR_ERR_AGENT_UNSYNCED] = {
|
|
|
|
N_("guest agent replied with wrong id to guest-sync command"),
|
|
|
|
N_("guest agent replied with wrong id to guest-sync command: %s") },
|
|
|
|
[VIR_ERR_LIBSSH] = {
|
|
|
|
N_("libssh transport error"),
|
|
|
|
N_("libssh transport error: %s") },
|
|
|
|
[VIR_ERR_DEVICE_MISSING] = {
|
|
|
|
N_("device not found"),
|
|
|
|
N_("device not found: %s") },
|
|
|
|
[VIR_ERR_INVALID_NWFILTER_BINDING] = {
|
|
|
|
N_("Invalid network filter binding"),
|
|
|
|
N_("Invalid network filter binding: %s") },
|
|
|
|
[VIR_ERR_NO_NWFILTER_BINDING] = {
|
|
|
|
N_("Network filter binding not found"),
|
|
|
|
N_("Network filter binding not found: %s") },
|
2019-01-03 01:55:25 +00:00
|
|
|
[VIR_ERR_INVALID_DOMAIN_CHECKPOINT] = {
|
|
|
|
N_("Invalid domain checkpoint"),
|
|
|
|
N_("Invalid domain checkpoint: %s") },
|
|
|
|
[VIR_ERR_NO_DOMAIN_CHECKPOINT] = {
|
|
|
|
N_("Domain checkpoint not found"),
|
|
|
|
N_("Domain checkpoint not found: %s") },
|
|
|
|
[VIR_ERR_NO_DOMAIN_BACKUP] = {
|
|
|
|
N_("Domain backup job id not found"),
|
|
|
|
N_("Domain backup job id not found: %s") },
|
2018-11-30 14:55:56 +00:00
|
|
|
[VIR_ERR_INVALID_NETWORK_PORT] = {
|
|
|
|
N_("Invalid network port pointer"),
|
|
|
|
N_("Invalid network port pointer: %s") },
|
|
|
|
[VIR_ERR_NETWORK_PORT_EXIST] = {
|
|
|
|
N_("this network port exists already"),
|
|
|
|
N_("network port %s exists already") },
|
|
|
|
[VIR_ERR_NO_NETWORK_PORT] = {
|
|
|
|
N_("network port not found"),
|
|
|
|
N_("network port not found: %s") },
|
2020-01-09 10:12:37 +00:00
|
|
|
[VIR_ERR_NO_HOSTNAME] = {
|
|
|
|
N_("no hostname found"),
|
|
|
|
N_("no hostname found: %s") },
|
2018-12-05 13:41:18 +00:00
|
|
|
};
|
|
|
|
|
2020-01-09 08:53:31 +00:00
|
|
|
G_STATIC_ASSERT(G_N_ELEMENTS(virErrorMsgStrings) == VIR_ERR_NUMBER_LAST);
|
|
|
|
|
2018-12-05 13:41:18 +00:00
|
|
|
|
2006-02-27 16:27:18 +00:00
|
|
|
/**
|
2008-11-04 22:30:33 +00:00
|
|
|
* virErrorMsg:
|
2006-02-27 16:27:18 +00:00
|
|
|
* @error: the virErrorNumber
|
2018-12-05 13:33:30 +00:00
|
|
|
* @info: additional info string
|
2006-02-27 16:27:18 +00:00
|
|
|
*
|
2018-12-05 13:33:30 +00:00
|
|
|
* Internal routine to get the message associated to @error raised
|
|
|
|
* from the library.
|
2006-02-27 16:27:18 +00:00
|
|
|
*
|
2018-12-05 13:33:30 +00:00
|
|
|
* Returns a *printf format string which describes @error. The returned string
|
|
|
|
* contains exactly one '%s' modifier if @info is non-NULL, or no modifiers at
|
|
|
|
* all if @info is NULL. If @error is invalid NULL is returned.
|
2006-02-27 16:27:18 +00:00
|
|
|
*/
|
2018-11-12 14:33:02 +00:00
|
|
|
const char *
|
2008-11-04 22:30:33 +00:00
|
|
|
virErrorMsg(virErrorNumber error, const char *info)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2018-12-05 13:41:18 +00:00
|
|
|
if (error >= VIR_ERR_NUMBER_LAST)
|
|
|
|
return NULL;
|
2006-02-27 16:27:18 +00:00
|
|
|
|
2018-12-05 13:41:18 +00:00
|
|
|
if (info)
|
|
|
|
return _(virErrorMsgStrings[error].msginfo);
|
|
|
|
else
|
|
|
|
return _(virErrorMsgStrings[error].msg);
|
2006-02-27 16:27:18 +00:00
|
|
|
}
|
2008-10-09 15:38:31 +00:00
|
|
|
|
2018-12-05 13:41:18 +00:00
|
|
|
|
2008-10-09 15:38:31 +00:00
|
|
|
/**
|
2008-11-25 10:32:27 +00:00
|
|
|
* virReportErrorHelper:
|
2008-10-09 15:38:31 +00:00
|
|
|
*
|
|
|
|
* @domcode: the virErrorDomain indicating where it's coming from
|
2012-01-25 20:13:21 +00:00
|
|
|
* @errorcode: the virErrorNumber code for the error
|
2008-10-09 15:38:31 +00:00
|
|
|
* @filename: Source file error is dispatched from
|
|
|
|
* @funcname: Function error is dispatched from
|
|
|
|
* @linenr: Line number error is dispatched from
|
2008-11-25 10:32:27 +00:00
|
|
|
* @fmt: the format string
|
2008-10-09 15:38:31 +00:00
|
|
|
* @...: extra parameters for the message display
|
|
|
|
*
|
|
|
|
* Helper function to do most of the grunt work for individual driver
|
|
|
|
* ReportError
|
|
|
|
*/
|
2011-04-16 08:30:22 +00:00
|
|
|
void virReportErrorHelper(int domcode,
|
2012-01-25 20:13:21 +00:00
|
|
|
int errorcode,
|
2009-05-27 12:10:47 +00:00
|
|
|
const char *filename,
|
|
|
|
const char *funcname,
|
|
|
|
size_t linenr,
|
2008-11-04 22:30:33 +00:00
|
|
|
const char *fmt, ...)
|
2008-10-09 15:38:31 +00:00
|
|
|
{
|
2010-12-23 18:23:42 +00:00
|
|
|
int save_errno = errno;
|
2008-10-09 15:38:31 +00:00
|
|
|
va_list args;
|
2017-11-22 09:28:35 +00:00
|
|
|
char errorMessage[VIR_ERROR_MAX_LENGTH];
|
2008-10-09 15:38:31 +00:00
|
|
|
const char *virerr;
|
|
|
|
|
|
|
|
if (fmt) {
|
|
|
|
va_start(args, fmt);
|
2019-11-13 09:21:29 +00:00
|
|
|
g_vsnprintf(errorMessage, sizeof(errorMessage)-1, fmt, args);
|
2008-10-09 15:38:31 +00:00
|
|
|
va_end(args);
|
|
|
|
} else {
|
|
|
|
errorMessage[0] = '\0';
|
|
|
|
}
|
|
|
|
|
2012-01-25 20:13:21 +00:00
|
|
|
virerr = virErrorMsg(errorcode, (errorMessage[0] ? errorMessage : NULL));
|
2011-04-16 08:30:22 +00:00
|
|
|
virRaiseErrorFull(filename, funcname, linenr,
|
2012-01-25 20:13:21 +00:00
|
|
|
domcode, errorcode, VIR_ERR_ERROR,
|
2009-05-27 12:10:47 +00:00
|
|
|
virerr, errorMessage, NULL,
|
|
|
|
-1, -1, virerr, errorMessage);
|
2010-12-23 18:23:42 +00:00
|
|
|
errno = save_errno;
|
2008-10-09 15:38:31 +00:00
|
|
|
}
|
2009-01-20 17:13:33 +00:00
|
|
|
|
2009-07-01 13:08:17 +00:00
|
|
|
/**
|
|
|
|
* virReportSystemErrorFull:
|
|
|
|
* @domcode: the virErrorDomain indicating where it's coming from
|
|
|
|
* @theerrno: an errno number
|
|
|
|
* @filename: filename where error was raised
|
|
|
|
* @funcname: function name where error was raised
|
|
|
|
* @linenr: line number where error was raised
|
|
|
|
* @fmt: the message to display/transmit
|
|
|
|
* @...: extra parameters for the message display
|
|
|
|
*
|
|
|
|
* Convenience internal routine called when a system error is detected.
|
|
|
|
*/
|
2010-02-04 20:02:58 +00:00
|
|
|
void virReportSystemErrorFull(int domcode,
|
2009-01-27 10:57:18 +00:00
|
|
|
int theerrno,
|
2009-05-27 12:10:47 +00:00
|
|
|
const char *filename,
|
|
|
|
const char *funcname,
|
|
|
|
size_t linenr,
|
2009-01-27 10:57:18 +00:00
|
|
|
const char *fmt, ...)
|
|
|
|
{
|
2010-12-23 18:23:42 +00:00
|
|
|
int save_errno = errno;
|
2017-11-22 09:28:35 +00:00
|
|
|
char msgDetailBuf[VIR_ERROR_MAX_LENGTH];
|
2009-01-27 10:57:18 +00:00
|
|
|
|
2019-10-02 15:30:36 +00:00
|
|
|
const char *errnoDetail = g_strerror(theerrno);
|
2009-01-27 10:57:18 +00:00
|
|
|
const char *msg = virErrorMsg(VIR_ERR_SYSTEM_ERROR, fmt);
|
|
|
|
const char *msgDetail = NULL;
|
2009-01-20 17:13:33 +00:00
|
|
|
|
|
|
|
if (fmt) {
|
2009-01-27 10:57:18 +00:00
|
|
|
va_list args;
|
2020-07-28 17:50:28 +00:00
|
|
|
size_t len;
|
2009-01-27 10:57:18 +00:00
|
|
|
int n;
|
|
|
|
|
2009-01-20 17:13:33 +00:00
|
|
|
va_start(args, fmt);
|
2019-11-13 09:21:29 +00:00
|
|
|
n = g_vsnprintf(msgDetailBuf, sizeof(msgDetailBuf), fmt, args);
|
2009-01-20 17:13:33 +00:00
|
|
|
va_end(args);
|
2009-01-27 10:57:18 +00:00
|
|
|
|
2020-07-28 17:50:28 +00:00
|
|
|
len = strlen(errnoDetail);
|
2012-03-29 09:52:04 +00:00
|
|
|
if (0 <= n && n + 2 + len < sizeof(msgDetailBuf)) {
|
2019-10-02 15:14:45 +00:00
|
|
|
strcpy(msgDetailBuf + n, ": ");
|
|
|
|
n += 2;
|
|
|
|
strcpy(msgDetailBuf + n, errnoDetail);
|
2009-01-27 10:57:18 +00:00
|
|
|
msgDetail = msgDetailBuf;
|
|
|
|
}
|
2009-01-20 17:13:33 +00:00
|
|
|
}
|
|
|
|
|
2009-01-27 12:26:53 +00:00
|
|
|
if (!msgDetail)
|
2009-01-27 10:57:18 +00:00
|
|
|
msgDetail = errnoDetail;
|
2009-01-20 17:13:33 +00:00
|
|
|
|
2011-04-16 08:30:22 +00:00
|
|
|
virRaiseErrorFull(filename, funcname, linenr,
|
2009-05-27 12:10:47 +00:00
|
|
|
domcode, VIR_ERR_SYSTEM_ERROR, VIR_ERR_ERROR,
|
2011-10-24 16:34:18 +00:00
|
|
|
msg, msgDetail, NULL, theerrno, -1, msg, msgDetail);
|
2010-12-23 18:23:42 +00:00
|
|
|
errno = save_errno;
|
2009-01-20 17:13:33 +00:00
|
|
|
}
|
|
|
|
|
2009-07-01 13:08:17 +00:00
|
|
|
/**
|
|
|
|
* virReportOOMErrorFull:
|
|
|
|
* @domcode: the virErrorDomain indicating where it's coming from
|
|
|
|
* @filename: filename where error was raised
|
|
|
|
* @funcname: function name where error was raised
|
|
|
|
* @linenr: line number where error was raised
|
|
|
|
*
|
|
|
|
* Convenience internal routine called when an out of memory error is
|
|
|
|
* detected
|
|
|
|
*/
|
2010-02-04 18:19:08 +00:00
|
|
|
void virReportOOMErrorFull(int domcode,
|
2009-05-27 12:10:47 +00:00
|
|
|
const char *filename,
|
|
|
|
const char *funcname,
|
|
|
|
size_t linenr)
|
2009-01-20 17:13:33 +00:00
|
|
|
{
|
|
|
|
const char *virerr;
|
|
|
|
|
|
|
|
virerr = virErrorMsg(VIR_ERR_NO_MEMORY, NULL);
|
2011-04-16 08:30:22 +00:00
|
|
|
virRaiseErrorFull(filename, funcname, linenr,
|
2009-05-27 12:10:47 +00:00
|
|
|
domcode, VIR_ERR_NO_MEMORY, VIR_ERR_ERROR,
|
|
|
|
virerr, NULL, NULL, -1, -1, virerr, NULL);
|
2009-01-20 17:13:33 +00:00
|
|
|
}
|
2011-01-21 17:25:01 +00:00
|
|
|
|
2011-03-09 03:42:19 +00:00
|
|
|
/**
|
|
|
|
* virSetErrorLogPriorityFunc:
|
|
|
|
* @func: function to install
|
|
|
|
*
|
|
|
|
* Install a function used to filter error logging based on error priority.
|
|
|
|
*/
|
2011-01-21 17:25:01 +00:00
|
|
|
void virSetErrorLogPriorityFunc(virErrorLogPriorityFunc func)
|
|
|
|
{
|
|
|
|
virErrorLogPriorityFilter = func;
|
|
|
|
}
|
2013-07-19 10:14:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virErrorSetErrnoFromLastError:
|
|
|
|
*
|
|
|
|
* If the last error had a code of VIR_ERR_SYSTEM_ERROR
|
|
|
|
* then set errno to the value saved in the error object.
|
|
|
|
*
|
|
|
|
* If the last error had a code of VIR_ERR_NO_MEMORY
|
|
|
|
* then set errno to ENOMEM
|
|
|
|
*
|
|
|
|
* Otherwise set errno to EIO.
|
|
|
|
*/
|
|
|
|
void virErrorSetErrnoFromLastError(void)
|
|
|
|
{
|
|
|
|
virErrorPtr err = virGetLastError();
|
|
|
|
if (err && err->code == VIR_ERR_SYSTEM_ERROR) {
|
|
|
|
errno = err->int1;
|
|
|
|
} else if (err && err->code == VIR_ERR_NO_MEMORY) {
|
|
|
|
errno = ENOMEM;
|
|
|
|
} else {
|
|
|
|
errno = EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virLastErrorIsSystemErrno:
|
|
|
|
* @errnum: the errno value
|
|
|
|
*
|
|
|
|
* Check if the last error reported is a system
|
|
|
|
* error with the specific errno value.
|
|
|
|
*
|
|
|
|
* If @errnum is zero, any system error will pass.
|
|
|
|
*
|
|
|
|
* Returns true if the last error was a system error with errno == @errnum
|
|
|
|
*/
|
|
|
|
bool virLastErrorIsSystemErrno(int errnum)
|
|
|
|
{
|
|
|
|
virErrorPtr err = virGetLastError();
|
|
|
|
if (!err)
|
|
|
|
return false;
|
|
|
|
if (err->code != VIR_ERR_SYSTEM_ERROR)
|
|
|
|
return false;
|
|
|
|
if (errnum != 0 && err->int1 != errnum)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
2019-06-11 09:23:48 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virLastErrorPrefixMessage:
|
|
|
|
* @fmt: printf-style formatting string
|
|
|
|
* @...: Arguments for @fmt
|
|
|
|
*
|
|
|
|
* Prefixes last error reported with message formatted from @fmt. This is useful
|
|
|
|
* if the low level error message does not convey enough information to describe
|
|
|
|
* the problem.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
virLastErrorPrefixMessage(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
int save_errno = errno;
|
|
|
|
virErrorPtr err = virGetLastError();
|
2019-10-15 13:16:31 +00:00
|
|
|
g_autofree char *fmtmsg = NULL;
|
|
|
|
g_autofree char *newmsg = NULL;
|
2019-06-11 09:23:48 +00:00
|
|
|
va_list args;
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
return;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
2019-10-22 12:11:15 +00:00
|
|
|
fmtmsg = g_strdup_vprintf(fmt, args);
|
|
|
|
va_end(args);
|
2019-06-11 09:23:48 +00:00
|
|
|
|
2019-10-22 13:26:14 +00:00
|
|
|
newmsg = g_strdup_printf("%s: %s", fmtmsg, err->message);
|
2019-06-11 09:23:48 +00:00
|
|
|
|
|
|
|
VIR_FREE(err->message);
|
2019-10-16 11:43:52 +00:00
|
|
|
err->message = g_steal_pointer(&newmsg);
|
2019-06-11 09:23:48 +00:00
|
|
|
|
|
|
|
errno = save_errno;
|
|
|
|
}
|