static int
virLockManagerLockDaemonConnectionRestrict(virLockManagerPtr lock ATTRIBUTE_UNUSED,
virNetClientPtr client,
virNetClientProgramPtr program,
int *counter)
{
virLockSpaceProtocolRestrictArgs args;
int rv = -1;
memset(&args, 0, sizeof(args));
args.flags = 0;
if (virNetClientProgramCall(program,
client,
(*counter)++,
VIR_LOCK_SPACE_PROTOCOL_PROC_RESTRICT,
0, NULL, NULL, NULL,
(xdrproc_t)xdr_virLockSpaceProtocolRestrictArgs, (char*)&args,
(xdrproc_t)xdr_void, NULL) < 0)
goto cleanup;
rv = 0;
cleanup:
return rv;
}
static int
virLockManagerLockDaemonConnectionRegister(virLockManagerPtr lock,
virNetClientPtr client,
virNetClientProgramPtr program,
int *counter)
{
virLockManagerLockDaemonPrivatePtr priv = lock->privateData;
virLockSpaceProtocolRegisterArgs args;
int rv = -1;
memset(&args, 0, sizeof(args));
args.flags = 0;
memcpy(args.owner.uuid, priv->uuid, VIR_UUID_BUFLEN);
args.owner.name = priv->name;
args.owner.id = priv->id;
args.owner.pid = priv->pid;
if (virNetClientProgramCall(program,
client,
(*counter)++,
VIR_LOCK_SPACE_PROTOCOL_PROC_REGISTER,
0, NULL, NULL, NULL,
(xdrproc_t)xdr_virLockSpaceProtocolRegisterArgs, (char*)&args,
(xdrproc_t)xdr_void, NULL) < 0)
goto cleanup;
rv = 0;
cleanup:
return rv;
}
char *
virLogManagerDomainReadLogFile(virLogManagerPtr mgr,
const char *path,
ino_t inode,
off_t offset,
size_t maxlen,
unsigned int flags)
{
struct virLogManagerProtocolDomainReadLogFileArgs args;
struct virLogManagerProtocolDomainReadLogFileRet ret;
char *rv = NULL;
memset(&args, 0, sizeof(args));
memset(&ret, 0, sizeof(ret));
args.path = (char *)path;
args.flags = flags;
args.pos.inode = inode;
args.pos.offset = offset;
args.maxlen = maxlen;
if (virNetClientProgramCall(mgr->program,
mgr->client,
mgr->serial++,
VIR_LOG_MANAGER_PROTOCOL_PROC_DOMAIN_READ_LOG_FILE,
0, NULL, NULL, NULL,
(xdrproc_t)xdr_virLogManagerProtocolDomainReadLogFileArgs, &args,
(xdrproc_t)xdr_virLogManagerProtocolDomainReadLogFileRet, &ret) < 0)
goto cleanup;
rv = ret.data;
cleanup:
return rv;
}
int
virLogManagerDomainGetLogFilePosition(virLogManagerPtr mgr,
const char *path,
unsigned int flags,
ino_t *inode,
off_t *offset)
{
struct virLogManagerProtocolDomainGetLogFilePositionArgs args;
struct virLogManagerProtocolDomainGetLogFilePositionRet ret;
int rv = -1;
memset(&args, 0, sizeof(args));
memset(&ret, 0, sizeof(ret));
args.path = (char *)path;
args.flags = flags;
if (virNetClientProgramCall(mgr->program,
mgr->client,
mgr->serial++,
VIR_LOG_MANAGER_PROTOCOL_PROC_DOMAIN_GET_LOG_FILE_POSITION,
0, NULL, NULL, NULL,
(xdrproc_t)xdr_virLogManagerProtocolDomainGetLogFilePositionArgs, &args,
(xdrproc_t)xdr_virLogManagerProtocolDomainGetLogFilePositionRet, &ret) < 0)
goto cleanup;
*inode = ret.pos.inode;
*offset = ret.pos.offset;
rv = 0;
cleanup:
return rv;
}
int
virLogManagerDomainOpenLogFile(virLogManagerPtr mgr,
const char *driver,
const unsigned char *domuuid,
const char *domname,
const char *path,
unsigned int flags,
ino_t *inode,
off_t *offset)
{
struct virLogManagerProtocolDomainOpenLogFileArgs args;
struct virLogManagerProtocolDomainOpenLogFileRet ret;
int *fdout = NULL;
size_t fdoutlen = 0;
int rv = -1;
memset(&args, 0, sizeof(args));
memset(&ret, 0, sizeof(ret));
args.driver = (char *)driver;
memcpy(args.dom.uuid, domuuid, VIR_UUID_BUFLEN);
args.dom.name = (char *)domname;
args.path = (char *)path;
args.flags = flags;
if (virNetClientProgramCall(mgr->program,
mgr->client,
mgr->serial++,
VIR_LOG_MANAGER_PROTOCOL_PROC_DOMAIN_OPEN_LOG_FILE,
0, NULL, &fdoutlen, &fdout,
(xdrproc_t)xdr_virLogManagerProtocolDomainOpenLogFileArgs, &args,
(xdrproc_t)xdr_virLogManagerProtocolDomainOpenLogFileRet, &ret) < 0)
goto cleanup;
if (fdoutlen != 1) {
if (fdoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("too many file descriptors received"));
} else {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("no file descriptor received"));
}
goto cleanup;
}
*inode = ret.pos.inode;
*offset = ret.pos.offset;
rv = fdout[0];
cleanup:
if (rv < 0) {
while (fdoutlen)
VIR_FORCE_CLOSE(fdout[--fdoutlen]);
}
VIR_FREE(fdout);
return rv;
}
static int virLockManagerLockDaemonSetupLockspace(const char *path)
{
virNetClientPtr client;
virNetClientProgramPtr program = NULL;
virLockSpaceProtocolCreateLockSpaceArgs args;
int rv = -1;
int counter = 0;
memset(&args, 0, sizeof(args));
args.path = (char*)path;
if (!(client = virLockManagerLockDaemonConnectionNew(getuid() == 0, &program)))
return -1;
if (virNetClientProgramCall(program,
client,
counter++,
VIR_LOCK_SPACE_PROTOCOL_PROC_CREATE_LOCKSPACE,
0, NULL, NULL, NULL,
(xdrproc_t)xdr_virLockSpaceProtocolCreateLockSpaceArgs, (char*)&args,
(xdrproc_t)xdr_void, NULL) < 0) {
virErrorPtr err = virGetLastError();
if (err && err->code == VIR_ERR_OPERATION_INVALID) {
/* The lockspace already exists */
virResetLastError();
rv = 0;
} else {
goto cleanup;
}
}
rv = 0;
cleanup:
virObjectUnref(program);
virNetClientClose(client);
virObjectUnref(client);
return rv;
}
static int
callFull(virAdmConnectPtr conn ATTRIBUTE_UNUSED,
remoteAdminPrivPtr priv,
int *fdin,
size_t fdinlen,
int **fdout,
size_t *fdoutlen,
int proc_nr,
xdrproc_t args_filter, char *args,
xdrproc_t ret_filter, char *ret)
{
int rv;
virNetClientProgramPtr prog = priv->program;
int counter = priv->counter++;
virNetClientPtr client = priv->client;
/* Unlock, so that if we get any async events/stream data
* while processing the RPC, we don't deadlock when our
* callbacks for those are invoked
*/
virObjectRef(priv);
virObjectUnlock(priv);
rv = virNetClientProgramCall(prog,
client,
counter,
proc_nr,
fdinlen, fdin,
fdoutlen, fdout,
args_filter, args,
ret_filter, ret);
virObjectLock(priv);
virObjectUnref(priv);
return rv;
}
