xen_internal.c 50.4 KB
Newer Older
1 2 3
/*
 * xen_internal.c: direct access to Xen hypervisor level
 *
D
Daniel Veillard 已提交
4
 * Copyright (C) 2005, 2006 Red Hat, Inc.
5 6 7 8 9 10 11 12
 *
 * See COPYING.LIB for the License of this software
 *
 * Daniel Veillard <veillard@redhat.com>
 */

#include <stdio.h>
#include <string.h>
13
/* required for uint8_t, uint32_t, etc ... */
14 15 16 17 18 19 20
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
21
#include <limits.h>
22 23 24
#include <stdint.h>

/* required for dom0_getdomaininfo_t */
25
#include <xen/dom0_ops.h>
26
#include <xen/version.h>
27
#include <xen/xen.h>
28
#include <xen/linux/privcmd.h>
29

30 31 32
/* required for shutdown flags */
#include <xen/sched.h>

33 34
/* #define DEBUG */
/*
35
 * so far there is 2 versions of the structures usable for doing
36 37 38 39
 * hypervisor calls.
 */
/* the old one */
typedef struct v0_hypercall_struct {
40 41
    unsigned long op;
    unsigned long arg[5];
42 43 44 45 46 47 48 49 50 51
} v0_hypercall_t;
#define XEN_V0_IOCTL_HYPERCALL_CMD \
        _IOC(_IOC_NONE, 'P', 0, sizeof(v0_hypercall_t))

/* the new one */
typedef struct v1_hypercall_struct
{
    uint64_t op;
    uint64_t arg[5];
} v1_hypercall_t;
52 53
#define XEN_V1_IOCTL_HYPERCALL_CMD                  \
    _IOC(_IOC_NONE, 'P', 0, sizeof(v1_hypercall_t))
54

55 56 57 58 59 60 61 62
typedef v1_hypercall_t hypercall_t;

#ifndef __HYPERVISOR_sysctl
#define __HYPERVISOR_sysctl 35
#endif
#ifndef __HYPERVISOR_domctl
#define __HYPERVISOR_domctl 36
#endif
63

64 65
static int xen_ioctl_hypercall_cmd = 0;
static int initialized = 0;
66
static int in_init = 0;
67
static int hv_version = 0;
68 69 70
static int hypervisor_version = 2;
static int sys_interface_version = -1;
static int dom_interface_version = -1;
71
static int kb_per_pages = 0;
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

/*
 * The content of the structures for a getdomaininfolist system hypercall
 */
#ifndef DOMFLAGS_DYING
#define DOMFLAGS_DYING     (1<<0) /* Domain is scheduled to die.             */
#define DOMFLAGS_SHUTDOWN  (1<<2) /* The guest OS has shut down.             */
#define DOMFLAGS_PAUSED    (1<<3) /* Currently paused by control software.   */
#define DOMFLAGS_BLOCKED   (1<<4) /* Currently blocked pending an event.     */
#define DOMFLAGS_RUNNING   (1<<5) /* Domain is currently running.            */
#define DOMFLAGS_CPUMASK      255 /* CPU to which this domain is bound.      */
#define DOMFLAGS_CPUSHIFT       8
#define DOMFLAGS_SHUTDOWNMASK 255 /* DOMFLAGS_SHUTDOWN guest-supplied code.  */
#define DOMFLAGS_SHUTDOWNSHIFT 16
#endif

88 89 90 91 92 93 94 95 96 97 98
/*
 * These flags explain why a system is in the state of "shutdown".  Normally,
 * They are defined in xen/sched.h
 */
#ifndef SHUTDOWN_poweroff
#define SHUTDOWN_poweroff   0  /* Domain exited normally. Clean up and kill. */
#define SHUTDOWN_reboot     1  /* Clean up, kill, and then restart.          */
#define SHUTDOWN_suspend    2  /* Clean up, save suspend info, kill.         */
#define SHUTDOWN_crash      3  /* Tell controller we've crashed.             */
#endif

99 100 101 102 103 104 105 106 107
#define XEN_V0_OP_GETDOMAININFOLIST	38
#define XEN_V1_OP_GETDOMAININFOLIST	38
#define XEN_V2_OP_GETDOMAININFOLIST	6

struct xen_v0_getdomaininfo {
    domid_t  domain;	/* the domain number */
    uint32_t flags;	/* falgs, see before */
    uint64_t tot_pages;	/* total number of pages used */
    uint64_t max_pages;	/* maximum number of pages allowed */
108
    unsigned long shared_info_frame; /* MFN of shared_info struct */
109 110 111 112 113 114 115 116
    uint64_t cpu_time;  /* CPU time used */
    uint32_t nr_online_vcpus;  /* Number of VCPUs currently online. */
    uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
    uint32_t ssidref;
    xen_domain_handle_t handle;
};
typedef struct xen_v0_getdomaininfo xen_v0_getdomaininfo;

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
struct xen_v2_getdomaininfo {
    domid_t  domain;	/* the domain number */
    uint32_t flags;	/* falgs, see before */
    uint64_t tot_pages;	/* total number of pages used */
    uint64_t max_pages;	/* maximum number of pages allowed */
    uint64_t shared_info_frame; /* MFN of shared_info struct */
    uint64_t cpu_time;  /* CPU time used */
    uint32_t nr_online_vcpus;  /* Number of VCPUs currently online. */
    uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
    uint32_t ssidref;
    xen_domain_handle_t handle;
};
typedef struct xen_v2_getdomaininfo xen_v2_getdomaininfo;

union xen_getdomaininfo {
    struct xen_v0_getdomaininfo v0;
    struct xen_v2_getdomaininfo v2;
};
typedef union xen_getdomaininfo xen_getdomaininfo;

union xen_getdomaininfolist {
    struct xen_v0_getdomaininfo *v0;
    struct xen_v2_getdomaininfo *v2;
};
typedef union xen_getdomaininfolist xen_getdomaininfolist;

#define XEN_GETDOMAININFOLIST_ALLOC(domlist, size)                      \
    (hypervisor_version < 2 ?                                           \
     ((domlist.v0 = malloc(sizeof(xen_v0_getdomaininfo)*(size))) != NULL) : \
     ((domlist.v2 = malloc(sizeof(xen_v2_getdomaininfo)*(size))) != NULL))

#define XEN_GETDOMAININFOLIST_FREE(domlist)     \
    (hypervisor_version < 2 ?                   \
     free(domlist.v0) :                         \
     free(domlist.v2))

#define XEN_GETDOMAININFOLIST_CLEAR(domlist, size)                  \
    (hypervisor_version < 2 ?                                       \
     memset(domlist.v0, 0, sizeof(xen_v0_getdomaininfo) * size) :   \
     memset(domlist.v2, 0, sizeof(xen_v2_getdomaininfo) * size))

#define XEN_GETDOMAININFOLIST_DOMAIN(domlist, n)    \
    (hypervisor_version < 2 ?                       \
     domlist.v0[n].domain :                         \
     domlist.v2[n].domain)

163 164 165 166
#define XEN_GETDOMAININFOLIST_DATA(domlist)     \
    (hypervisor_version < 2 ?                   \
     (void*)(domlist->v0) :                     \
     (void*)(domlist->v2))
167

168 169 170 171
#define XEN_GETDOMAININFO_SIZE                  \
    (hypervisor_version < 2 ?                   \
     sizeof(xen_v0_getdomaininfo) :             \
     sizeof(xen_v2_getdomaininfo))
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

#define XEN_GETDOMAININFO_CLEAR(dominfo)                        \
    (hypervisor_version < 2 ?                                   \
     memset(&(dominfo.v0), 0, sizeof(xen_v0_getdomaininfo)) :   \
     memset(&(dominfo.v2), 0, sizeof(xen_v2_getdomaininfo)))

#define XEN_GETDOMAININFO_DOMAIN(dominfo)       \
    (hypervisor_version < 2 ?                   \
     dominfo.v0.domain :                        \
     dominfo.v2.domain)

#define XEN_GETDOMAININFO_CPUTIME(dominfo)      \
    (hypervisor_version < 2 ?                   \
     dominfo.v0.cpu_time :                      \
     dominfo.v2.cpu_time)

#define XEN_GETDOMAININFO_CPUCOUNT(dominfo)     \
    (hypervisor_version < 2 ?                   \
     dominfo.v0.nr_online_vcpus :               \
     dominfo.v2.nr_online_vcpus)

#define XEN_GETDOMAININFO_FLAGS(dominfo)        \
    (hypervisor_version < 2 ?                   \
     dominfo.v0.flags :                         \
     dominfo.v2.flags)

#define XEN_GETDOMAININFO_TOT_PAGES(dominfo)    \
    (hypervisor_version < 2 ?                   \
     dominfo.v0.tot_pages :                     \
     dominfo.v2.tot_pages)

#define XEN_GETDOMAININFO_MAX_PAGES(dominfo)    \
    (hypervisor_version < 2 ?                   \
     dominfo.v0.max_pages :                     \
     dominfo.v2.max_pages)



struct xen_v0_getdomaininfolistop {
211 212 213 214 215
    domid_t   first_domain;
    uint32_t  max_domains;
    struct xen_v0_getdomaininfo *buffer;
    uint32_t  num_domains;
};
216 217 218 219 220 221 222 223 224 225 226 227
typedef struct xen_v0_getdomaininfolistop xen_v0_getdomaininfolistop;


struct xen_v2_getdomaininfolistop {
    domid_t   first_domain;
    uint32_t  max_domains;
    struct xen_v2_getdomaininfo *buffer;
    uint32_t  num_domains;
};
typedef struct xen_v2_getdomaininfolistop xen_v2_getdomaininfolistop;


228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319

struct xen_v0_domainop {
    domid_t   domain;
};
typedef struct xen_v0_domainop xen_v0_domainop;

/*
 * The informations for a destroydomain system hypercall
 */
#define XEN_V0_OP_DESTROYDOMAIN	9
#define XEN_V1_OP_DESTROYDOMAIN	9
#define XEN_V2_OP_DESTROYDOMAIN	2

/*
 * The informations for a pausedomain system hypercall
 */
#define XEN_V0_OP_PAUSEDOMAIN	10
#define XEN_V1_OP_PAUSEDOMAIN	10
#define XEN_V2_OP_PAUSEDOMAIN	3

/*
 * The informations for an unpausedomain system hypercall
 */
#define XEN_V0_OP_UNPAUSEDOMAIN	11
#define XEN_V1_OP_UNPAUSEDOMAIN	11
#define XEN_V2_OP_UNPAUSEDOMAIN	4

/*
 * The informations for an setmaxmem system hypercall
 */
#define XEN_V0_OP_SETMAXMEM	28
#define XEN_V1_OP_SETMAXMEM	28
#define XEN_V2_OP_SETMAXMEM	14

struct xen_v0_setmaxmem {
    domid_t	domain;
    uint64_t	maxmem;
};
typedef struct xen_v0_setmaxmem xen_v0_setmaxmem;
typedef struct xen_v0_setmaxmem xen_v1_setmaxmem;

struct xen_v2_setmaxmem {
    uint64_t	maxmem;
};
typedef struct xen_v2_setmaxmem xen_v2_setmaxmem;

/*
 * The informations for an setmaxvcpu system hypercall
 */
#define XEN_V0_OP_SETMAXVCPU	41
#define XEN_V1_OP_SETMAXVCPU	41
#define XEN_V2_OP_SETMAXVCPU	15

struct xen_v0_setmaxvcpu {
    domid_t	domain;
    uint32_t	maxvcpu;
};
typedef struct xen_v0_setmaxvcpu xen_v0_setmaxvcpu;
typedef struct xen_v0_setmaxvcpu xen_v1_setmaxvcpu;

struct xen_v2_setmaxvcpu {
    uint32_t	maxvcpu;
};
typedef struct xen_v2_setmaxvcpu xen_v2_setmaxvcpu;

/*
 * The informations for an setvcpumap system hypercall
 * Note that between 1 and 2 the limitation to 64 physical CPU was lifted
 * hence the difference in structures
 */
#define XEN_V0_OP_SETVCPUMAP	20
#define XEN_V1_OP_SETVCPUMAP	20
#define XEN_V2_OP_SETVCPUMAP	9

struct xen_v0_setvcpumap {
    domid_t	domain;
    uint32_t	vcpu;
    cpumap_t    cpumap;
};
typedef struct xen_v0_setvcpumap xen_v0_setvcpumap;
typedef struct xen_v0_setvcpumap xen_v1_setvcpumap;

struct xen_v2_cpumap {
    uint8_t    *bitmap;
    uint32_t    nr_cpus;
};
struct xen_v2_setvcpumap {
    uint32_t	vcpu;
    struct xen_v2_cpumap cpumap;
};
typedef struct xen_v2_setvcpumap xen_v2_setvcpumap;

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
/*
 * The informations for an vcpuinfo system hypercall
 */
#define XEN_V0_OP_GETVCPUINFO   43
#define XEN_V1_OP_GETVCPUINFO	43
#define XEN_V2_OP_GETVCPUINFO   14

struct xen_v0_vcpuinfo {
    domid_t	domain;		/* owner's domain */
    uint32_t	vcpu;		/* the vcpu number */
    uint8_t	online;		/* seen as on line */
    uint8_t	blocked;	/* blocked on event */
    uint8_t	running;	/* scheduled on CPU */
    uint64_t    cpu_time;	/* nanosecond of CPU used */
    uint32_t	cpu;		/* current mapping */
    cpumap_t	cpumap;		/* deprecated in V2 */
};
typedef struct xen_v0_vcpuinfo xen_v0_vcpuinfo;
typedef struct xen_v0_vcpuinfo xen_v1_vcpuinfo;

struct xen_v2_vcpuinfo {
    uint32_t	vcpu;		/* the vcpu number */
    uint8_t	online;		/* seen as on line */
    uint8_t	blocked;	/* blocked on event */
    uint8_t	running;	/* scheduled on CPU */
    uint64_t    cpu_time;	/* nanosecond of CPU used */
    uint32_t	cpu;		/* current mapping */
};
typedef struct xen_v2_vcpuinfo xen_v2_vcpuinfo;

/*
 * from V2 the pinning of a vcpu is read with a separate call
 */
#define XEN_V2_OP_GETVCPUMAP	25
typedef struct xen_v2_setvcpumap xen_v2_getvcpumap;

356 357 358 359 360 361 362 363 364
/*
 * The hypercall operation structures also have changed on
 * changeset 86d26e6ec89b
 */
/* the old structure */
struct xen_op_v0 {
    uint32_t cmd;
    uint32_t interface_version;
    union {
365 366 367 368 369 370 371
        xen_v0_getdomaininfolistop getdomaininfolist;
        xen_v0_domainop          domain;
        xen_v0_setmaxmem         setmaxmem;
        xen_v0_setmaxvcpu        setmaxvcpu;
        xen_v0_setvcpumap        setvcpumap;
        xen_v0_vcpuinfo          getvcpuinfo;
        uint8_t padding[128];
372 373 374 375 376 377 378 379 380 381
    } u;
};
typedef struct xen_op_v0 xen_op_v0;
typedef struct xen_op_v0 xen_op_v1;

/* the new structure for systems operations */
struct xen_op_v2_sys {
    uint32_t cmd;
    uint32_t interface_version;
    union {
382 383
        xen_v2_getdomaininfolistop getdomaininfolist;
        uint8_t padding[128];
384 385 386 387 388 389 390 391 392 393
    } u;
};
typedef struct xen_op_v2_sys xen_op_v2_sys;

/* the new structure for domains operation */
struct xen_op_v2_dom {
    uint32_t cmd;
    uint32_t interface_version;
    domid_t  domain;
    union {
394 395 396 397 398 399
        xen_v2_setmaxmem         setmaxmem;
        xen_v2_setmaxvcpu        setmaxvcpu;
        xen_v2_setvcpumap        setvcpumap;
        xen_v2_vcpuinfo          getvcpuinfo;
        xen_v2_getvcpumap        getvcpumap;
        uint8_t padding[128];
400 401 402
    } u;
};
typedef struct xen_op_v2_dom xen_op_v2_dom;
403 404

#include "internal.h"
405
#include "driver.h"
406 407 408 409
#include "xen_internal.h"

#define XEN_HYPERVISOR_SOCKET "/proc/xen/privcmd"

410
#ifndef PROXY
411
static const char * xenHypervisorGetType(virConnectPtr conn);
412
static unsigned long xenHypervisorGetMaxMemory(virDomainPtr domain);
413
#endif
414

415
#ifndef PROXY
416
static virDriver xenHypervisorDriver = {
417
    VIR_DRV_XEN_HYPERVISOR,
418
    "Xen",
419 420 421
    (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
    ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
    (DOM0_INTERFACE_VERSION & 0xFFFF),
422 423
    xenHypervisorOpen, /* open */
    xenHypervisorClose, /* close */
424
    xenHypervisorGetType, /* type */
425
    xenHypervisorGetVersion, /* version */
426
    NULL, /* nodeGetInfo */
427 428
    xenHypervisorListDomains, /* listDomains */
    xenHypervisorNumOfDomains, /* numOfDomains */
429 430 431 432 433 434 435
    NULL, /* domainCreateLinux */
    NULL, /* domainLookupByID */
    NULL, /* domainLookupByUUID */
    NULL, /* domainLookupByName */
    xenHypervisorPauseDomain, /* domainSuspend */
    xenHypervisorResumeDomain, /* domainResume */
    NULL, /* domainShutdown */
436
    NULL, /* domainReboot */
437 438
    xenHypervisorDestroyDomain, /* domainDestroy */
    NULL, /* domainGetOSType */
439
    xenHypervisorGetMaxMemory, /* domainGetMaxMemory */
440
    xenHypervisorSetMaxMemory, /* domainSetMaxMemory */
441
    NULL, /* domainSetMemory */
442 443
    xenHypervisorGetDomainInfo, /* domainGetInfo */
    NULL, /* domainSave */
444
    NULL, /* domainRestore */
D
Daniel Veillard 已提交
445
    NULL, /* domainCoreDump */
446 447
    xenHypervisorSetVcpus, /* domainSetVcpus */
    xenHypervisorPinVcpu, /* domainPinVcpu */
448 449
    xenHypervisorGetVcpus, /* domainGetVcpus */
    NULL, /* domainDumpXML */
450 451 452 453 454
    NULL, /* listDefinedDomains */
    NULL, /* numOfDefinedDomains */
    NULL, /* domainCreate */
    NULL, /* domainDefineXML */
    NULL, /* domainUndefine */
455 456
    NULL, /* domainAttachDevice */
    NULL, /* domainDetachDevice */
457 458
    NULL, /* domainGetAutostart */
    NULL, /* domainSetAutostart */
459
};
460
#endif /* !PROXY */
461

462 463 464 465 466 467 468 469 470
/**
 * virXenError:
 * @conn: the connection if available
 * @error: the error number
 * @info: extra information string
 *
 * Handle an error at the xend daemon interface
 */
static void
471 472
virXenError(virErrorNumber error, const char *info, int value)
{
473
    const char *errmsg;
474

475
    if ((error == VIR_ERR_OK) || (in_init != 0))
476 477 478
        return;

    errmsg = __virErrorMsg(error, info);
479
    __virRaiseError(NULL, NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
480
                    errmsg, info, NULL, value, 0, errmsg, info, value);
481 482
}

483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
/**
 * xenHypervisorDoV0Op:
 * @handle: the handle to the Xen hypervisor
 * @op: pointer to the hyperviros operation structure
 *
 * Do an hypervisor operation though the old interface,
 * this leads to an hypervisor call through ioctl.
 *
 * Returns 0 in case of success and -1 in case of error.
 */
static int
xenHypervisorDoV0Op(int handle, xen_op_v0 * op)
{
    int ret;
    v0_hypercall_t hc;

    memset(&hc, 0, sizeof(hc));
    op->interface_version = hv_version << 8;
    hc.op = __HYPERVISOR_dom0_op;
    hc.arg[0] = (unsigned long) op;

    if (mlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
        return (-1);
    }

    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
    if (ret < 0) {
        virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
    }

    if (munlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
        ret = -1;
    }

    if (ret < 0)
        return (-1);

    return (0);
}
/**
 * xenHypervisorDoV1Op:
 * @handle: the handle to the Xen hypervisor
 * @op: pointer to the hyperviros operation structure
 *
 * Do an hypervisor v1 operation, this leads to an hypervisor call through
 * ioctl.
 *
 * Returns 0 in case of success and -1 in case of error.
 */
static int
xenHypervisorDoV1Op(int handle, xen_op_v1* op)
{
    int ret;
    hypercall_t hc;

    memset(&hc, 0, sizeof(hc));
    op->interface_version = DOM0_INTERFACE_VERSION;
    hc.op = __HYPERVISOR_dom0_op;
    hc.arg[0] = (unsigned long) op;

    if (mlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
        return (-1);
    }

    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
    if (ret < 0) {
        virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
    }

    if (munlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
        ret = -1;
    }

    if (ret < 0)
        return (-1);

    return (0);
}

/**
 * xenHypervisorDoV2Sys:
 * @handle: the handle to the Xen hypervisor
 * @op: pointer to the hypervisor operation structure
 *
 * Do an hypervisor v2 stsyem operation, this leads to an hypervisor
 * call through ioctl.
 *
 * Returns 0 in case of success and -1 in case of error.
 */
static int
xenHypervisorDoV2Sys(int handle, xen_op_v2_sys* op)
{
    int ret;
    hypercall_t hc;

    memset(&hc, 0, sizeof(hc));
    op->interface_version = sys_interface_version;
    hc.op = __HYPERVISOR_sysctl;
    hc.arg[0] = (unsigned long) op;

    if (mlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
        return (-1);
    }

    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
    if (ret < 0) {
        virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
    }

    if (munlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
        ret = -1;
    }

    if (ret < 0)
        return (-1);

    return (0);
}

608
#ifndef PROXY
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
/**
 * xenHypervisorDoV2Dom:
 * @handle: the handle to the Xen hypervisor
 * @op: pointer to the hypervisor domain operation structure
 *
 * Do an hypervisor v2 domain operation, this leads to an hypervisor
 * call through ioctl.
 *
 * Returns 0 in case of success and -1 in case of error.
 */
static int
xenHypervisorDoV2Dom(int handle, xen_op_v2_dom* op)
{
    int ret;
    hypercall_t hc;

    memset(&hc, 0, sizeof(hc));
    op->interface_version = dom_interface_version;
    hc.op = __HYPERVISOR_domctl;
    hc.arg[0] = (unsigned long) op;

    if (mlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(*op));
        return (-1);
    }

    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
    if (ret < 0) {
        virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
    }

    if (munlock(op, sizeof(dom0_op_t)) < 0) {
        virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(*op));
        ret = -1;
    }

    if (ret < 0)
        return (-1);

    return (0);
}
650
#endif /* PROXY */
651 652 653 654 655 656 657 658 659 660 661 662 663 664

/**
 * virXen_getdomaininfolist:
 * @handle: the hypervisor handle
 * @first_domain: first domain in the range
 * @maxids: maximum number of domains to list
 * @dominfos: output structures
 *
 * Do a low level hypercall to list existing domains informations
 *
 * Returns the number of domains or -1 in case of failure
 */
static int
virXen_getdomaininfolist(int handle, int first_domain, int maxids,
665
                         xen_getdomaininfolist *dominfos)
666 667 668
{
    int ret = -1;

669 670
    if (mlock(XEN_GETDOMAININFOLIST_DATA(dominfos),
              XEN_GETDOMAININFO_SIZE * maxids) < 0) {
671
        virXenError(VIR_ERR_XEN_CALL, " locking",
672
                    XEN_GETDOMAININFO_SIZE * maxids);
673 674 675 676 677 678
        return (-1);
    }
    if (hypervisor_version > 1) {
        xen_op_v2_sys op;

        memset(&op, 0, sizeof(op));
679 680 681 682 683 684 685 686
        op.cmd = XEN_V2_OP_GETDOMAININFOLIST;
        op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
        op.u.getdomaininfolist.max_domains = maxids;
        op.u.getdomaininfolist.buffer = dominfos->v2;
        op.u.getdomaininfolist.num_domains = maxids;
        ret = xenHypervisorDoV2Sys(handle, &op);
        if (ret == 0)
            ret = op.u.getdomaininfolist.num_domains;
687 688 689 690
    } else if (hypervisor_version == 1) {
        xen_op_v1 op;

        memset(&op, 0, sizeof(op));
691 692 693 694 695 696 697 698
        op.cmd = XEN_V1_OP_GETDOMAININFOLIST;
        op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
        op.u.getdomaininfolist.max_domains = maxids;
        op.u.getdomaininfolist.buffer = dominfos->v0;
        op.u.getdomaininfolist.num_domains = maxids;
        ret = xenHypervisorDoV1Op(handle, &op);
        if (ret == 0)
            ret = op.u.getdomaininfolist.num_domains;
699 700 701 702
    } else if (hypervisor_version == 0) {
        xen_op_v0 op;

        memset(&op, 0, sizeof(op));
703 704 705 706 707 708 709 710
        op.cmd = XEN_V0_OP_GETDOMAININFOLIST;
        op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
        op.u.getdomaininfolist.max_domains = maxids;
        op.u.getdomaininfolist.buffer = dominfos->v0;
        op.u.getdomaininfolist.num_domains = maxids;
        ret = xenHypervisorDoV0Op(handle, &op);
        if (ret == 0)
            ret = op.u.getdomaininfolist.num_domains;
711
    }
712 713
    if (munlock(XEN_GETDOMAININFOLIST_DATA(dominfos),
                XEN_GETDOMAININFO_SIZE * maxids) < 0) {
714
        virXenError(VIR_ERR_XEN_CALL, " release",
715
                    XEN_GETDOMAININFO_SIZE * maxids);
716 717 718 719 720
        ret = -1;
    }
    return(ret);
}

721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
static int
virXen_getdomaininfo(int handle, int first_domain,
                     xen_getdomaininfo *dominfo) {
    xen_getdomaininfolist dominfos;

    if (hypervisor_version < 2) {
        dominfos.v0 = &(dominfo->v0);
    } else {
        dominfos.v2 = &(dominfo->v2);
    }

    return virXen_getdomaininfolist(handle, first_domain, 1, &dominfos);
}


736
#ifndef PROXY
737 738 739 740 741 742 743 744 745 746
/**
 * virXen_pausedomain:
 * @handle: the hypervisor handle
 * @id: the domain id
 *
 * Do a low level hypercall to pause the domain
 *
 * Returns 0 or -1 in case of failure
 */
static int
747
virXen_pausedomain(int handle, int id)
748 749 750 751 752 753 754
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

        memset(&op, 0, sizeof(op));
755 756 757
        op.cmd = XEN_V2_OP_PAUSEDOMAIN;
        op.domain = (domid_t) id;
        ret = xenHypervisorDoV2Dom(handle, &op);
758 759 760 761
    } else if (hypervisor_version == 1) {
        xen_op_v1 op;

        memset(&op, 0, sizeof(op));
762 763 764
        op.cmd = XEN_V1_OP_PAUSEDOMAIN;
        op.u.domain.domain = (domid_t) id;
        ret = xenHypervisorDoV1Op(handle, &op);
765 766 767 768
    } else if (hypervisor_version == 0) {
        xen_op_v0 op;

        memset(&op, 0, sizeof(op));
769 770 771
        op.cmd = XEN_V0_OP_PAUSEDOMAIN;
        op.u.domain.domain = (domid_t) id;
        ret = xenHypervisorDoV0Op(handle, &op);
772 773 774 775 776 777 778 779 780 781 782 783 784 785
    }
    return(ret);
}

/**
 * virXen_unpausedomain:
 * @handle: the hypervisor handle
 * @id: the domain id
 *
 * Do a low level hypercall to unpause the domain
 *
 * Returns 0 or -1 in case of failure
 */
static int
786
virXen_unpausedomain(int handle, int id)
787 788 789 790 791 792 793
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

        memset(&op, 0, sizeof(op));
794 795 796
        op.cmd = XEN_V2_OP_UNPAUSEDOMAIN;
        op.domain = (domid_t) id;
        ret = xenHypervisorDoV2Dom(handle, &op);
797 798 799 800
    } else if (hypervisor_version == 1) {
        xen_op_v1 op;

        memset(&op, 0, sizeof(op));
801 802 803
        op.cmd = XEN_V1_OP_UNPAUSEDOMAIN;
        op.u.domain.domain = (domid_t) id;
        ret = xenHypervisorDoV1Op(handle, &op);
804 805 806 807
    } else if (hypervisor_version == 0) {
        xen_op_v0 op;

        memset(&op, 0, sizeof(op));
808 809 810
        op.cmd = XEN_V0_OP_UNPAUSEDOMAIN;
        op.u.domain.domain = (domid_t) id;
        ret = xenHypervisorDoV0Op(handle, &op);
811 812 813 814 815 816 817 818 819 820 821 822 823 824
    }
    return(ret);
}

/**
 * virXen_destroydomain:
 * @handle: the hypervisor handle
 * @id: the domain id
 *
 * Do a low level hypercall to destroy the domain
 *
 * Returns 0 or -1 in case of failure
 */
static int
825
virXen_destroydomain(int handle, int id)
826 827 828 829 830 831 832
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

        memset(&op, 0, sizeof(op));
833 834 835
        op.cmd = XEN_V2_OP_DESTROYDOMAIN;
        op.domain = (domid_t) id;
        ret = xenHypervisorDoV2Dom(handle, &op);
836 837 838 839
    } else if (hypervisor_version == 1) {
        xen_op_v1 op;

        memset(&op, 0, sizeof(op));
840 841 842
        op.cmd = XEN_V1_OP_DESTROYDOMAIN;
        op.u.domain.domain = (domid_t) id;
        ret = xenHypervisorDoV1Op(handle, &op);
843 844 845 846
    } else if (hypervisor_version == 0) {
        xen_op_v0 op;

        memset(&op, 0, sizeof(op));
847 848 849
        op.cmd = XEN_V0_OP_DESTROYDOMAIN;
        op.u.domain.domain = (domid_t) id;
        ret = xenHypervisorDoV0Op(handle, &op);
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
    }
    return(ret);
}

/**
 * virXen_setmaxmem:
 * @handle: the hypervisor handle
 * @id: the domain id
 * @memory: the amount of memory in kilobytes
 *
 * Do a low level hypercall to change the max memory amount
 *
 * Returns 0 or -1 in case of failure
 */
static int
865
virXen_setmaxmem(int handle, int id, unsigned long memory)
866 867 868 869 870 871 872
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

        memset(&op, 0, sizeof(op));
873 874 875 876
        op.cmd = XEN_V2_OP_SETMAXMEM;
        op.domain = (domid_t) id;
        op.u.setmaxmem.maxmem = memory;
        ret = xenHypervisorDoV2Dom(handle, &op);
877 878 879 880
    } else if (hypervisor_version == 1) {
        xen_op_v1 op;

        memset(&op, 0, sizeof(op));
881 882 883 884
        op.cmd = XEN_V1_OP_SETMAXMEM;
        op.u.setmaxmem.domain = (domid_t) id;
        op.u.setmaxmem.maxmem = memory;
        ret = xenHypervisorDoV1Op(handle, &op);
885
    } else if (hypervisor_version == 0) {
886
        xen_op_v0 op;
887 888

        memset(&op, 0, sizeof(op));
889 890 891 892
        op.cmd = XEN_V0_OP_SETMAXMEM;
        op.u.setmaxmem.domain = (domid_t) id;
        op.u.setmaxmem.maxmem = memory;
        ret = xenHypervisorDoV0Op(handle, &op);
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
    }
    return(ret);
}

/**
 * virXen_setmaxvcpus:
 * @handle: the hypervisor handle
 * @id: the domain id
 * @vcpus: the numbers of vcpus
 *
 * Do a low level hypercall to change the max vcpus amount
 *
 * Returns 0 or -1 in case of failure
 */
static int
908
virXen_setmaxvcpus(int handle, int id, unsigned int vcpus)
909 910 911 912 913 914 915
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

        memset(&op, 0, sizeof(op));
916 917 918 919
        op.cmd = XEN_V2_OP_SETMAXVCPU;
        op.domain = (domid_t) id;
        op.u.setmaxvcpu.maxvcpu = vcpus;
        ret = xenHypervisorDoV2Dom(handle, &op);
920 921 922 923
    } else if (hypervisor_version == 1) {
        xen_op_v1 op;

        memset(&op, 0, sizeof(op));
924 925 926 927
        op.cmd = XEN_V1_OP_SETMAXVCPU;
        op.u.setmaxvcpu.domain = (domid_t) id;
        op.u.setmaxvcpu.maxvcpu = vcpus;
        ret = xenHypervisorDoV1Op(handle, &op);
928
    } else if (hypervisor_version == 0) {
929
        xen_op_v0 op;
930 931

        memset(&op, 0, sizeof(op));
932 933 934 935
        op.cmd = XEN_V0_OP_SETMAXVCPU;
        op.u.setmaxvcpu.domain = (domid_t) id;
        op.u.setmaxvcpu.maxvcpu = vcpus;
        ret = xenHypervisorDoV0Op(handle, &op);
936 937 938 939 940 941 942 943 944 945
    }
    return(ret);
}

/**
 * virXen_setvcpumap:
 * @handle: the hypervisor handle
 * @id: the domain id
 * @vcpu: the vcpu to map
 * @cpumap: the bitmap for this vcpu
946
 * @maplen: the size of the bitmap in bytes
947 948 949 950 951 952 953 954 955 956 957 958 959 960
 *
 * Do a low level hypercall to change the pinning for vcpu
 *
 * Returns 0 or -1 in case of failure
 */
static int
virXen_setvcpumap(int handle, int id, unsigned int vcpu,
                  unsigned char * cpumap, int maplen)
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

961 962 963 964
        if (mlock(cpumap, maplen) < 0) {
            virXenError(VIR_ERR_XEN_CALL, " locking", maplen);
            return (-1);
        }
965
        memset(&op, 0, sizeof(op));
966 967 968 969 970 971 972 973 974 975
        op.cmd = XEN_V2_OP_SETVCPUMAP;
        op.domain = (domid_t) id;
        op.u.setvcpumap.vcpu = vcpu;
        op.u.setvcpumap.cpumap.bitmap = cpumap;
        op.u.setvcpumap.cpumap.nr_cpus = maplen * 8;
        ret = xenHypervisorDoV2Dom(handle, &op);
        if (munlock(cpumap, maplen) < 0) {
            virXenError(VIR_ERR_XEN_CALL, " release", maplen);
            ret = -1;
        }
976
    } else {
977 978 979
        cpumap_t xen_cpumap; /* limited to 64 CPUs in old hypervisors */
        uint64_t *pm = &xen_cpumap;
        int j;
980

981 982
        if ((maplen > (int)sizeof(cpumap_t)) || (sizeof(cpumap_t) & 7))
            return (-1);
983

984 985 986
        memset(pm, 0, sizeof(cpumap_t));
        for (j = 0; j < maplen; j++)
            *(pm + (j / 8)) |= cpumap[j] << (8 * (j & 7));
987 988

        if (hypervisor_version == 1) {
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
            xen_op_v1 op;

            memset(&op, 0, sizeof(op));
            op.cmd = XEN_V1_OP_SETVCPUMAP;
            op.u.setvcpumap.domain = (domid_t) id;
            op.u.setvcpumap.vcpu = vcpu;
            op.u.setvcpumap.cpumap = xen_cpumap;
            ret = xenHypervisorDoV1Op(handle, &op);
        } else if (hypervisor_version == 0) {
            xen_op_v0 op;

            memset(&op, 0, sizeof(op));
            op.cmd = XEN_V0_OP_SETVCPUMAP;
            op.u.setvcpumap.domain = (domid_t) id;
            op.u.setvcpumap.vcpu = vcpu;
            op.u.setvcpumap.cpumap = xen_cpumap;
            ret = xenHypervisorDoV0Op(handle, &op);
        }
1007 1008 1009
    }
    return(ret);
}
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
/**
 * virXen_getvcpusinfo:
 * @handle: the hypervisor handle
 * @id: the domain id
 * @vcpu: the vcpu to map
 * @cpumap: the bitmap for this vcpu
 * @maplen: the size of the bitmap in bytes
 *
 * Do a low level hypercall to change the pinning for vcpu
 *
 * Returns 0 or -1 in case of failure
 */
static int
virXen_getvcpusinfo(int handle, int id, unsigned int vcpu, virVcpuInfoPtr ipt,
1024
                    unsigned char *cpumap, int maplen)
1025 1026 1027 1028 1029 1030 1031
{
    int ret = -1;

    if (hypervisor_version > 1) {
        xen_op_v2_dom op;

        memset(&op, 0, sizeof(op));
1032 1033
        op.cmd = XEN_V2_OP_GETVCPUINFO;
        op.domain = (domid_t) id;
1034
        op.u.getvcpuinfo.vcpu = (uint16_t) vcpu;
1035 1036 1037
        ret = xenHypervisorDoV2Dom(handle, &op);
        if (ret < 0)
            return(-1);
1038
        ipt->number = vcpu;
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
        if (op.u.getvcpuinfo.online) {
            if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
            if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
        }
        else ipt->state = VIR_VCPU_OFFLINE;
        ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
        ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
        if ((cpumap != NULL) && (maplen > 0)) {
            if (mlock(cpumap, maplen) < 0) {
                virXenError(VIR_ERR_XEN_CALL, " locking", maplen);
                return (-1);
            }
            memset(&op, 0, sizeof(op));
            op.cmd = XEN_V2_OP_GETVCPUMAP;
            op.domain = (domid_t) id;
            op.u.setvcpumap.vcpu = vcpu;
            op.u.setvcpumap.cpumap.bitmap = cpumap;
            op.u.setvcpumap.cpumap.nr_cpus = maplen * 8;
            ret = xenHypervisorDoV2Dom(handle, &op);
            if (munlock(cpumap, maplen) < 0) {
                virXenError(VIR_ERR_XEN_CALL, " release", maplen);
                ret = -1;
            }
        }
1063
    } else {
1064 1065 1066 1067 1068
        int mapl = maplen;
        int cpu;

        if (maplen > (int)sizeof(cpumap_t))
            mapl = (int)sizeof(cpumap_t);
1069 1070

        if (hypervisor_version == 1) {
1071 1072 1073 1074 1075 1076 1077 1078 1079
            xen_op_v1 op;

            memset(&op, 0, sizeof(op));
            op.cmd = XEN_V1_OP_GETVCPUINFO;
            op.u.getvcpuinfo.domain = (domid_t) id;
            op.u.getvcpuinfo.vcpu = vcpu;
            ret = xenHypervisorDoV1Op(handle, &op);
            if (ret < 0)
                return(-1);
1080
            ipt->number = vcpu;
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
            if (op.u.getvcpuinfo.online) {
                if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
                if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
            }
            else ipt->state = VIR_VCPU_OFFLINE;
            ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
            ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
            if ((cpumap != NULL) && (maplen > 0)) {
                for (cpu = 0; cpu < (mapl * 8); cpu++) {
                    if (op.u.getvcpuinfo.cpumap & ((uint64_t)1<<cpu))
                        VIR_USE_CPU(cpumap, cpu);
                }
            }
        } else if (hypervisor_version == 0) {
            xen_op_v1 op;

            memset(&op, 0, sizeof(op));
            op.cmd = XEN_V0_OP_GETVCPUINFO;
            op.u.getvcpuinfo.domain = (domid_t) id;
            op.u.getvcpuinfo.vcpu = vcpu;
            ret = xenHypervisorDoV0Op(handle, &op);
            if (ret < 0)
                return(-1);
1104
            ipt->number = vcpu;
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
            if (op.u.getvcpuinfo.online) {
                if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
                if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
            }
            else ipt->state = VIR_VCPU_OFFLINE;
            ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
            ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
            if ((cpumap != NULL) && (maplen > 0)) {
                for (cpu = 0; cpu < (mapl * 8); cpu++) {
                    if (op.u.getvcpuinfo.cpumap & ((uint64_t)1<<cpu))
                        VIR_USE_CPU(cpumap, cpu);
                }
            }
        }
1119 1120 1121
    }
    return(ret);
}
1122
#endif /* !PROXY*/
1123

1124 1125 1126 1127 1128 1129
/**
 * xenHypervisorInit:
 *
 * Initialize the hypervisor layer. Try to detect the kind of interface
 * used i.e. pre or post changeset 10277
 */
1130
static int
D
Daniel P. Berrange 已提交
1131
xenHypervisorInit(void)
1132 1133 1134
{
    int fd, ret, cmd;
    hypercall_t hc;
1135
    v0_hypercall_t v0_hc;
1136
    xen_getdomaininfo info;
1137 1138

    if (initialized) {
1139
        if (hypervisor_version == -1)
1140 1141
            return(-1);
        return(0);
1142 1143
    }
    initialized = 1;
1144
    in_init = 1;
1145 1146 1147

    ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
    if (ret < 0) {
1148
        hypervisor_version = -1;
1149 1150 1151 1152
        return (-1);
    }
    fd = ret;

1153 1154 1155 1156
    /*
     * The size of the hypervisor call block changed July 2006
     * this detect if we are using the new or old hypercall_t structure
     */
1157 1158 1159 1160 1161 1162 1163 1164
    hc.op = __HYPERVISOR_xen_version;
    hc.arg[0] = (unsigned long) XENVER_version;
    hc.arg[1] = 0;

    cmd = IOCTL_PRIVCMD_HYPERCALL;
    ret = ioctl(fd, cmd, (unsigned long) &hc);

    if ((ret != -1) && (ret != 0)) {
D
Daniel Veillard 已提交
1165
#ifdef DEBUG
1166
        fprintf(stderr, "Using new hypervisor call: %X\n", ret);
D
Daniel Veillard 已提交
1167
#endif
1168 1169 1170
        hv_version = ret;
        xen_ioctl_hypercall_cmd = cmd;
        goto detect_v2;
1171
    }
1172

1173 1174 1175 1176 1177 1178 1179 1180
    /*
     * check if the old hypercall are actually working
     */
    v0_hc.op = __HYPERVISOR_xen_version;
    v0_hc.arg[0] = (unsigned long) XENVER_version;
    v0_hc.arg[1] = 0;
    cmd = _IOC(_IOC_NONE, 'P', 0, sizeof(v0_hypercall_t));
    ret = ioctl(fd, cmd, (unsigned long) &v0_hc);
1181
    if ((ret != -1) && (ret != 0)) {
D
Daniel Veillard 已提交
1182
#ifdef DEBUG
1183
        fprintf(stderr, "Using old hypervisor call: %X\n", ret);
D
Daniel Veillard 已提交
1184
#endif
1185 1186
        hv_version = ret;
        xen_ioctl_hypercall_cmd = cmd;
1187
        hypervisor_version = 0;
1188
        goto done;
1189 1190
    }

1191 1192 1193 1194 1195
    /*
     * we faild to make any hypercall
     */

    hypervisor_version = -1;
1196 1197
    virXenError(VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
    close(fd);
1198 1199 1200
    in_init = 0;
    return(-1);

1201
 detect_v2:
1202 1203 1204 1205 1206 1207 1208 1209 1210
    /*
     * The hypercalls were refactored into 3 different section in August 2006
     * Try to detect if we are running a version post 3.0.2 with the new ones
     * or the old ones
     */
    hypervisor_version = 2;
    /* TODO: one probably will need to autodetect thse subversions too */
    sys_interface_version = 2; /* XEN_SYSCTL_INTERFACE_VERSION */
    dom_interface_version = 3; /* XEN_DOMCTL_INTERFACE_VERSION */
1211
    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
D
Daniel Veillard 已提交
1212
#ifdef DEBUG
1213
        fprintf(stderr, "Using hypervisor call v2, sys version 2\n");
D
Daniel Veillard 已提交
1214
#endif
1215
        goto done;
1216 1217 1218
    }
    hypervisor_version = 1;
    sys_interface_version = -1;
1219
    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
D
Daniel Veillard 已提交
1220
#ifdef DEBUG
1221
        fprintf(stderr, "Using hypervisor call v1\n");
D
Daniel Veillard 已提交
1222
#endif
1223
        goto done;
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
    }

    /*
     * we faild to make the getdomaininfolist hypercall
     */

    hypervisor_version = -1;
    virXenError(VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
    close(fd);
    in_init = 0;
1234 1235
    return(-1);

1236
 done:
1237
    close(fd);
1238
    in_init = 0;
1239 1240 1241
    return(0);
}

1242
#ifndef PROXY
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
/**
 * xenHypervisorRegister:
 *
 * Registers the xenHypervisor driver
 */
void xenHypervisorRegister(void)
{
    if (initialized == 0)
        xenHypervisorInit();

    virRegisterDriver(&xenHypervisorDriver);
}
1255
#endif /* !PROXY */
1256

1257 1258
/**
 * xenHypervisorOpen:
1259 1260 1261
 * @conn: pointer to the connection block
 * @name: URL for the target, NULL for local
 * @flags: combination of virDrvOpenFlag(s)
1262 1263 1264
 *
 * Connects to the Xen hypervisor.
 *
1265
 * Returns 0 or -1 in case of error.
1266
 */
1267
int
1268
xenHypervisorOpen(virConnectPtr conn, const char *name, int flags)
1269
{
1270 1271
    int ret;

1272 1273 1274
    if (initialized == 0)
        xenHypervisorInit();

1275
    if ((name != NULL) && (strcasecmp(name, "xen")))
1276 1277 1278 1279
        return(-1);

    conn->handle = -1;

1280
    ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
1281
    if (ret < 0) {
1282
        if (!(flags & VIR_DRV_OPEN_QUIET))
1283 1284
            virXenError(VIR_ERR_NO_XEN, XEN_HYPERVISOR_SOCKET, 0);
        return (-1);
1285
    }
1286
    conn->handle = ret;
1287

1288
    return(0);
1289 1290 1291 1292
}

/**
 * xenHypervisorClose:
1293
 * @conn: pointer to the connection block
1294 1295 1296 1297 1298
 *
 * Close the connection to the Xen hypervisor.
 *
 * Returns 0 in case of success or -1 in case of error.
 */
1299
int
1300
xenHypervisorClose(virConnectPtr conn)
1301
{
1302 1303
    int ret;

1304
    if ((conn == NULL) || (conn->handle < 0))
1305
        return (-1);
1306

1307
    ret = close(conn->handle);
1308
    if (ret < 0)
1309 1310
        return (-1);
    return (0);
1311 1312 1313
}


1314
#ifndef PROXY
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
/**
 * xenHypervisorGetType:
 * @conn: pointer to the Xen Hypervisor block
 *
 * Get the version level of the Hypervisor running.
 *
 * Returns -1 in case of error, 0 otherwise. if the version can't be
 *    extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
 *    @hvVer value is major * 1,000,000 + minor * 1,000 + release
 */
static const char *
xenHypervisorGetType(virConnectPtr conn)
{
    if (!VIR_IS_CONNECT(conn)) {
        virXenError(VIR_ERR_INVALID_CONN, __FUNCTION__, 0);
        return (NULL);
    }
    return("Xen");
}
1334
#endif
1335

1336 1337
/**
 * xenHypervisorGetVersion:
1338 1339
 * @conn: pointer to the connection block
 * @hvVer: where to store the version
1340 1341 1342
 *
 * Call the hypervisor to extracts his own internal API version
 *
1343
 * Returns 0 in case of success, -1 in case of error
1344
 */
1345 1346
int
xenHypervisorGetVersion(virConnectPtr conn, unsigned long *hvVer)
1347
{
1348 1349
    if ((conn == NULL) || (conn->handle < 0) || (hvVer == NULL))
        return (-1);
1350
    *hvVer = (hv_version >> 16) * 1000000 + (hv_version & 0xFFFF) * 1000;
1351
    return(0);
1352 1353
}

1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
/**
 * xenHypervisorNumOfDomains:
 * @conn: pointer to the connection block
 *
 * Provides the number of active domains.
 *
 * Returns the number of domain found or -1 in case of error
 */
int
xenHypervisorNumOfDomains(virConnectPtr conn)
{
1365
    xen_getdomaininfolist dominfos;
1366 1367 1368 1369 1370 1371 1372
    int ret, nbids;
    static int last_maxids = 2;
    int maxids = last_maxids;

    if ((conn == NULL) || (conn->handle < 0))
        return (-1);

1373 1374
 retry:
    if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
1375
        virXenError(VIR_ERR_NO_MEMORY, _("allocating %d domain info"),
1376 1377
                    maxids);
        return(-1);
1378 1379
    }

1380 1381 1382
    XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);

    ret = virXen_getdomaininfolist(conn->handle, 0, maxids, &dominfos);
1383

1384
    XEN_GETDOMAININFOLIST_FREE(dominfos);
1385 1386 1387 1388

    if (ret < 0)
        return (-1);

1389
    nbids = ret;
1390 1391 1392
    if (nbids == maxids) {
        last_maxids *= 2;
        maxids *= 2;
1393
        goto retry;
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
    }
    if ((nbids < 0) || (nbids > maxids))
        return(-1);
    return(nbids);
}

/**
 * xenHypervisorListDomains:
 * @conn: pointer to the connection block
 * @ids: array to collect the list of IDs of active domains
 * @maxids: size of @ids
 *
 * Collect the list of active domains, and store their ID in @maxids
 *
 * Returns the number of domain found or -1 in case of error
 */
int
xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
{
1413
    xen_getdomaininfolist dominfos;
1414 1415 1416 1417 1418 1419
    int ret, nbids, i;

    if ((conn == NULL) || (conn->handle < 0) ||
        (ids == NULL) || (maxids < 1))
        return (-1);

1420
    if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
1421
        virXenError(VIR_ERR_NO_MEMORY, "allocating %d domain info",
1422 1423
                    maxids);
        return(-1);
1424
    }
1425 1426

    XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
1427 1428
    memset(ids, 0, maxids * sizeof(int));

1429
    ret = virXen_getdomaininfolist(conn->handle, 0, maxids, &dominfos);
1430 1431

    if (ret < 0) {
1432
        XEN_GETDOMAININFOLIST_FREE(dominfos);
1433 1434 1435
        return (-1);
    }

1436
    nbids = ret;
1437
    if ((nbids < 0) || (nbids > maxids)) {
1438
        XEN_GETDOMAININFOLIST_FREE(dominfos);
1439 1440 1441 1442
        return(-1);
    }

    for (i = 0;i < nbids;i++) {
1443
        ids[i] = XEN_GETDOMAININFOLIST_DOMAIN(dominfos, i);
1444 1445
    }

1446
    XEN_GETDOMAININFOLIST_FREE(dominfos);
1447 1448 1449
    return (nbids);
}

1450
/**
1451 1452 1453
 * xenHypervisorGetDomMaxMemory:
 * @conn: connection data
 * @id: domain id
1454
 *
1455
 * Retrieve the maximum amount of physical memory allocated to a
1456
 * domain.
1457 1458 1459
 *
 * Returns the memory size in kilobytes or 0 in case of error.
 */
1460 1461
unsigned long
xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
1462
{
1463
    xen_getdomaininfo dominfo;
1464 1465
    int ret;

1466
    if ((conn == NULL) || (conn->handle < 0))
1467 1468
        return (0);

1469 1470 1471 1472 1473 1474
    if (kb_per_pages == 0) {
        kb_per_pages = sysconf(_SC_PAGESIZE) / 1024;
	if (kb_per_pages <= 0) 
	    kb_per_pages = 4;
    }

1475
    XEN_GETDOMAININFO_CLEAR(dominfo);
1476

1477
    ret = virXen_getdomaininfo(conn->handle, id, &dominfo);
1478

1479
    if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
1480 1481
        return (0);

1482
    return((unsigned long) XEN_GETDOMAININFO_MAX_PAGES(dominfo) * kb_per_pages);
1483 1484
}

1485
#ifndef PROXY
1486 1487 1488
/**
 * xenHypervisorGetMaxMemory:
 * @domain: a domain object or NULL
1489
 *
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
 * Retrieve the maximum amount of physical memory allocated to a
 * domain. If domain is NULL, then this get the amount of memory reserved
 * to Domain0 i.e. the domain where the application runs.
 *
 * Returns the memory size in kilobytes or 0 in case of error.
 */
static unsigned long
xenHypervisorGetMaxMemory(virDomainPtr domain)
{
    if ((domain == NULL) || (domain->conn == NULL) ||
1500
        (domain->conn->handle < 0) || (domain->id < 0))
1501 1502
        return (0);

1503
    return(xenHypervisorGetDomMaxMemory(domain->conn, domain->id));
1504
}
1505
#endif
1506

1507
/**
1508 1509 1510
 * xenHypervisorGetDomInfo:
 * @conn: connection data
 * @id: the domain ID
1511
 * @info: the place where information should be stored
1512
 *
1513
 * Do an hypervisor call to get the related set of domain information.
1514 1515 1516 1517
 *
 * Returns 0 in case of success, -1 in case of error.
 */
int
1518
xenHypervisorGetDomInfo(virConnectPtr conn, int id, virDomainInfoPtr info)
1519
{
1520
    xen_getdomaininfo dominfo;
1521
    int ret;
1522
    uint32_t domain_flags, domain_state, domain_shutdown_cause;
1523 1524 1525 1526 1527 1528

    if (kb_per_pages == 0) {
        kb_per_pages = sysconf(_SC_PAGESIZE) / 1024;
	if (kb_per_pages <= 0) 
	    kb_per_pages = 4;
    }
1529

1530
    if ((conn == NULL) || (conn->handle < 0) || (info == NULL))
1531
        return (-1);
1532

1533
    memset(info, 0, sizeof(virDomainInfo));
1534
    XEN_GETDOMAININFO_CLEAR(dominfo);
1535

1536
    ret = virXen_getdomaininfo(conn->handle, id, &dominfo);
1537

1538
    if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
1539
        return (-1);
1540

1541 1542 1543
    domain_flags = XEN_GETDOMAININFO_FLAGS(dominfo);
    domain_state = domain_flags & 0xFF;
    switch (domain_state) {
1544 1545 1546 1547
	case DOMFLAGS_DYING:
	    info->state = VIR_DOMAIN_SHUTDOWN;
	    break;
	case DOMFLAGS_SHUTDOWN:
1548 1549 1550 1551 1552 1553 1554 1555 1556
            /* The domain is shutdown.  Determine the cause. */
            domain_shutdown_cause = domain_flags >> DOMFLAGS_SHUTDOWNSHIFT;
            switch (domain_shutdown_cause) {
                case SHUTDOWN_crash:
                    info->state = VIR_DOMAIN_CRASHED;
                    break;
                default:
                    info->state = VIR_DOMAIN_SHUTOFF;
            }
1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
	    break;
	case DOMFLAGS_PAUSED:
	    info->state = VIR_DOMAIN_PAUSED;
	    break;
	case DOMFLAGS_BLOCKED:
	    info->state = VIR_DOMAIN_BLOCKED;
	    break;
	case DOMFLAGS_RUNNING:
	    info->state = VIR_DOMAIN_RUNNING;
	    break;
	default:
	    info->state = VIR_DOMAIN_NONE;
    }

    /*
     * the API brings back the cpu time in nanoseconds,
     * convert to microseconds, same thing convert to
     * kilobytes from page counts
     */
1576
    info->cpuTime = XEN_GETDOMAININFO_CPUTIME(dominfo);
1577 1578
    info->memory = XEN_GETDOMAININFO_TOT_PAGES(dominfo) * kb_per_pages;
    info->maxMem = XEN_GETDOMAININFO_MAX_PAGES(dominfo) * kb_per_pages;
1579
    info->nrVirtCpu = XEN_GETDOMAININFO_CPUCOUNT(dominfo);
1580
    return (0);
1581 1582
}

1583 1584 1585
/**
 * xenHypervisorGetDomainInfo:
 * @domain: pointer to the domain block
1586
 * @info: the place where information should be stored
1587
 *
1588
 * Do an hypervisor call to get the related set of domain information.
1589 1590 1591 1592 1593 1594 1595 1596
 *
 * Returns 0 in case of success, -1 in case of error.
 */
int
xenHypervisorGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
{
    if ((domain == NULL) || (domain->conn == NULL) ||
        (domain->conn->handle < 0) || (info == NULL) ||
1597
        (domain->id < 0))
1598
        return (-1);
1599

1600
    return(xenHypervisorGetDomInfo(domain->conn, domain->id, info));
1601 1602 1603

}

1604
#ifndef PROXY
1605 1606
/**
 * xenHypervisorPauseDomain:
1607
 * @domain: pointer to the domain block
1608 1609 1610 1611 1612 1613
 *
 * Do an hypervisor call to pause the given domain
 *
 * Returns 0 in case of success, -1 in case of error.
 */
int
1614
xenHypervisorPauseDomain(virDomainPtr domain)
1615
{
1616 1617
    int ret;

1618
    if ((domain == NULL) || (domain->conn == NULL) ||
1619
        (domain->conn->handle < 0) || (domain->id < 0))
1620 1621
        return (-1);

1622
    ret = virXen_pausedomain(domain->conn->handle, domain->id);
1623
    if (ret < 0)
1624 1625
        return (-1);
    return (0);
1626 1627 1628 1629
}

/**
 * xenHypervisorResumeDomain:
1630
 * @domain: pointer to the domain block
1631 1632 1633 1634 1635 1636
 *
 * Do an hypervisor call to resume the given domain
 *
 * Returns 0 in case of success, -1 in case of error.
 */
int
1637
xenHypervisorResumeDomain(virDomainPtr domain)
1638
{
1639 1640
    int ret;

1641
    if ((domain == NULL) || (domain->conn == NULL) ||
1642
        (domain->conn->handle < 0) || (domain->id < 0))
1643 1644
        return (-1);

1645
    ret = virXen_unpausedomain(domain->conn->handle, domain->id);
1646
    if (ret < 0)
1647 1648
        return (-1);
    return (0);
1649 1650 1651 1652
}

/**
 * xenHypervisorDestroyDomain:
1653
 * @domain: pointer to the domain block
1654 1655 1656 1657 1658 1659
 *
 * Do an hypervisor call to destroy the given domain
 *
 * Returns 0 in case of success, -1 in case of error.
 */
int
1660
xenHypervisorDestroyDomain(virDomainPtr domain)
1661
{
1662 1663
    int ret;

1664
    if ((domain == NULL) || (domain->conn == NULL) ||
1665
        (domain->conn->handle < 0) || (domain->id < 0))
1666 1667
        return (-1);

1668
    ret = virXen_destroydomain(domain->conn->handle, domain->id);
1669
    if (ret < 0)
1670 1671
        return (-1);
    return (0);
1672 1673
}

1674 1675
/**
 * xenHypervisorSetMaxMemory:
1676
 * @domain: pointer to the domain block
1677 1678 1679 1680 1681 1682 1683
 * @memory: the max memory size in kilobytes.
 *
 * Do an hypervisor call to change the maximum amount of memory used
 *
 * Returns 0 in case of success, -1 in case of error.
 */
int
1684
xenHypervisorSetMaxMemory(virDomainPtr domain, unsigned long memory)
1685
{
1686 1687
    int ret;

1688
    if ((domain == NULL) || (domain->conn == NULL) ||
1689
        (domain->conn->handle < 0) || (domain->id < 0))
1690 1691
        return (-1);

1692
    ret = virXen_setmaxmem(domain->conn->handle, domain->id, memory);
1693
    if (ret < 0)
1694 1695
        return (-1);
    return (0);
1696
}
1697
#endif /* PROXY */
1698

1699
#ifndef PROXY
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
/**
 * xenHypervisorSetVcpus:
 * @domain: pointer to domain object
 * @nvcpus: the new number of virtual CPUs for this domain
 *
 * Dynamically change the number of virtual CPUs used by the domain.
 *
 * Returns 0 in case of success, -1 in case of failure.
 */

int
xenHypervisorSetVcpus(virDomainPtr domain, unsigned int nvcpus)
{
1713
    int ret;
1714

1715
    if ((domain == NULL) || (domain->conn == NULL) ||
1716
        (domain->conn->handle < 0) || (domain->id < 0) ||
1717
        (nvcpus < 1))
1718
        return (-1);
1719

1720
    ret = virXen_setmaxvcpus(domain->conn->handle, domain->id, nvcpus);
1721
    if (ret < 0)
1722
        return (-1);
1723
    return (0);
1724 1725 1726 1727 1728 1729 1730 1731
}

/**
 * xenHypervisorPinVcpu:
 * @domain: pointer to domain object
 * @vcpu: virtual CPU number
 * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes)
 * @maplen: length of cpumap in bytes
1732
 *
1733 1734 1735 1736 1737 1738 1739 1740 1741
 * Dynamically change the real CPUs which can be allocated to a virtual CPU.
 *
 * Returns 0 in case of success, -1 in case of failure.
 */

int
xenHypervisorPinVcpu(virDomainPtr domain, unsigned int vcpu,
                     unsigned char *cpumap, int maplen)
{
1742
    int ret;
1743

1744
    if ((domain == NULL) || (domain->conn == NULL) ||
1745
        (domain->conn->handle < 0) || (domain->id < 0) ||
1746
        (cpumap == NULL) || (maplen < 1))
1747 1748
        return (-1);

1749
    ret = virXen_setvcpumap(domain->conn->handle, domain->id, vcpu,
1750 1751
                            cpumap, maplen);
    if (ret < 0)
1752
        return (-1);
1753
    return (0);
1754
}
1755
#endif
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769

/**
 * virDomainGetVcpus:
 * @domain: pointer to domain object, or NULL for Domain0
 * @info: pointer to an array of virVcpuInfo structures (OUT)
 * @maxinfo: number of structures in info array
 * @cpumaps: pointer to an bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT)
 *	If cpumaps is NULL, then no cupmap information is returned by the API.
 *	It's assumed there is <maxinfo> cpumap in cpumaps array.
 *	The memory allocated to cpumaps must be (maxinfo * maplen) bytes
 *	(ie: calloc(maxinfo, maplen)).
 *	One cpumap inside cpumaps has the format described in virDomainPinVcpu() API.
 * @maplen: number of bytes in one cpumap, from 1 up to size of CPU map in
 *	underlying virtualization system (Xen...).
1770
 *
1771 1772 1773 1774 1775
 * Extract information about virtual CPUs of domain, store it in info array
 * and also in cpumaps if this pointer is'nt NULL.
 *
 * Returns the number of info filled in case of success, -1 in case of failure.
 */
1776
#ifndef PROXY
1777 1778
int
xenHypervisorGetVcpus(virDomainPtr domain, virVcpuInfoPtr info, int maxinfo,
1779
                      unsigned char *cpumaps, int maplen)
1780
{
1781
    xen_getdomaininfo dominfo;
1782 1783
    int ret;

1784
    virVcpuInfoPtr ipt;
1785
    int nbinfo, i;
1786

1787
    if ((domain == NULL) || (domain->conn == NULL) ||
1788
        (domain->conn->handle < 0) || (domain->id < 0) ||
1789 1790
        (info == NULL) || (maxinfo < 1) ||
        (sizeof(cpumap_t) & 7))
1791
        return (-1);
1792
    if ((cpumaps != NULL) && (maplen < 1))
1793
        return -1;
1794 1795

    /* first get the number of virtual CPUs in this domain */
1796
    XEN_GETDOMAININFO_CLEAR(dominfo);
1797
    ret = virXen_getdomaininfo(domain->conn->handle, domain->id,
1798
                               &dominfo);
1799

1800
    if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id))
1801
        return (-1);
1802
    nbinfo = XEN_GETDOMAININFO_CPUCOUNT(dominfo) + 1;
1803 1804 1805
    if (nbinfo > maxinfo) nbinfo = maxinfo;

    if (cpumaps != NULL)
1806
        memset(cpumaps, 0, maxinfo * maplen);
1807

1808 1809
    for (i = 0, ipt = info; i < nbinfo; i++, ipt++) {
        if ((cpumaps != NULL) && (i < maxinfo)) {
1810
            ret = virXen_getvcpusinfo(domain->conn->handle, domain->id, i,
1811 1812 1813 1814 1815 1816
                                      ipt,
                                      (unsigned char *)VIR_GET_CPUMAP(cpumaps, maplen, i),
                                      maplen);
            if (ret < 0)
                return(-1);
        } else {
1817
            ret = virXen_getvcpusinfo(domain->conn->handle, domain->id, i,
1818 1819 1820 1821
                                      ipt, NULL, 0);
            if (ret < 0)
                return(-1);
        }
1822 1823 1824
    }
    return nbinfo;
}
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
#endif

/*
 * Local variables:
 *  indent-tabs-mode: nil
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 4
 * End:
 */