direct-io.hg

annotate tools/libxc/xenctrl.h @ 7404:75ec60b67f64

Have xenstored initialise its connections, meaning that xend can be out of
that loop completely -- the xc_init_store, initDomainStore calls can all go.

Have xenstored understand where the local domain information goes. Xend no
longer has to generate a path and pass it to xenstored through
xs_introduce_domain -- we just allow xenstored to generate the path, and then
call GetDomainPath later. There is still some work required to tidy this up.

Change the uuid module to generate uuids as lists of bytes, not in the
stringified form. Added a unit test for that module.

Change the semantics of Xend restart, relying on these changes to the
xenstored semantics and earlier changes to add an opaque handle to the
hypervisor's domain-specific data block. The semantics are now clearer, as
Xend can validate whether the details in the store match the current live
domain.

Added a usage statement to xenstored.

Some of this code is by Steven Hand.

Signed-off-by: Ewan Mellor <ewan@xensource.com>
author emellor@leeni.uk.xensource.com
date Mon Oct 17 16:22:05 2005 +0100 (2005-10-17)
parents fa0faada967b
children 8928c89a8d0a
rev   line source
mjw@1623 1 /******************************************************************************
cl349@6388 2 * xenctrl.h
mjw@1623 3 *
mjw@1623 4 * A library for low-level access to the Xen control interfaces.
mjw@1623 5 *
kaf24@2787 6 * Copyright (c) 2003-2004, K A Fraser.
mjw@1623 7 */
mjw@1623 8
cl349@6389 9 #ifndef XENCTRL_H
cl349@6389 10 #define XENCTRL_H
mjw@1623 11
kaf24@3266 12 #include <stdint.h>
kaf24@4719 13 #include <sys/ptrace.h>
kaf24@2821 14 #include <xen/xen.h>
kaf24@2821 15 #include <xen/dom0_ops.h>
vh249@6549 16 #include <xen/version.h>
kaf24@2821 17 #include <xen/event_channel.h>
kaf24@7196 18 #include <xen/sched.h>
kaf24@2821 19 #include <xen/sched_ctl.h>
kaf24@5541 20 #include <xen/acm.h>
kaf24@2787 21
kaf24@5914 22 #ifdef __ia64__
kaf24@5914 23 #define XC_PAGE_SHIFT 14
kaf24@5914 24 #else
kaf24@5914 25 #define XC_PAGE_SHIFT 12
kaf24@5914 26 #endif
kaf24@5914 27 #define XC_PAGE_SIZE (1UL << XC_PAGE_SHIFT)
kaf24@5914 28 #define XC_PAGE_MASK (~(XC_PAGE_SIZE-1))
kaf24@5914 29
kaf24@3961 30 /*
kaf24@3961 31 * DEFINITIONS FOR CPU BARRIERS
kaf24@3961 32 */
kaf24@3961 33
kaf24@3961 34 #if defined(__i386__)
kaf24@3966 35 #define mb() __asm__ __volatile__ ( "lock; addl $0,0(%%esp)" : : : "memory" )
kaf24@3966 36 #define rmb() __asm__ __volatile__ ( "lock; addl $0,0(%%esp)" : : : "memory" )
kaf24@3966 37 #define wmb() __asm__ __volatile__ ( "" : : : "memory")
kaf24@3961 38 #elif defined(__x86_64__)
kaf24@3966 39 #define mb() __asm__ __volatile__ ( "mfence" : : : "memory")
kaf24@3966 40 #define rmb() __asm__ __volatile__ ( "lfence" : : : "memory")
kaf24@3966 41 #define wmb() __asm__ __volatile__ ( "" : : : "memory")
kaf24@5914 42 #elif defined(__ia64__)
kaf24@5914 43 /* FIXME */
kaf24@5914 44 #define mb()
kaf24@5914 45 #define rmb()
kaf24@5914 46 #define wmb()
kaf24@3961 47 #else
kaf24@3961 48 #error "Define barriers"
kaf24@3961 49 #endif
kaf24@3961 50
kaf24@3961 51 /*
iap10@3443 52 * INITIALIZATION FUNCTIONS
kaf24@3961 53 */
iap10@3443 54
iap10@3443 55 /**
iap10@3443 56 * This function opens a handle to the hypervisor interface. This function can
iap10@3443 57 * be called multiple times within a single process. Multiple processes can
iap10@3443 58 * have an open hypervisor interface at the same time.
iap10@3443 59 *
iap10@3443 60 * Each call to this function should have a corresponding call to
iap10@3443 61 * xc_interface_close().
iap10@3443 62 *
iap10@3443 63 * This function can fail if the caller does not have superuser permission or
iap10@3443 64 * if a Xen-enabled kernel is not currently running.
iap10@3443 65 *
iap10@3443 66 * @return a handle to the hypervisor interface or -1 on failure
iap10@3443 67 */
mjw@1623 68 int xc_interface_open(void);
iap10@3443 69
iap10@3443 70 /**
iap10@3443 71 * This function closes an open hypervisor interface.
iap10@3443 72 *
iap10@3443 73 * This function can fail if the handle does not represent an open interface or
iap10@3443 74 * if there were problems closing the interface.
iap10@3443 75 *
iap10@3443 76 * @parm xc_handle a handle to an open hypervisor interface
iap10@3443 77 * @return 0 on success, -1 otherwise.
iap10@3443 78 */
mjw@1623 79 int xc_interface_close(int xc_handle);
mjw@1623 80
kaf24@3961 81 /*
kaf24@4719 82 * DOMAIN DEBUGGING FUNCTIONS
kaf24@4719 83 */
kaf24@4719 84
kaf24@4719 85 typedef struct xc_core_header {
kaf24@4719 86 unsigned int xch_magic;
kaf24@4719 87 unsigned int xch_nr_vcpus;
kaf24@4719 88 unsigned int xch_nr_pages;
kaf24@4719 89 unsigned int xch_ctxt_offset;
kaf24@4719 90 unsigned int xch_index_offset;
kaf24@4719 91 unsigned int xch_pages_offset;
kaf24@4719 92 } xc_core_header_t;
kaf24@4719 93
kaf24@4719 94
kaf24@6941 95 long xc_ptrace(
kaf24@6941 96 int xc_handle,
kaf24@6941 97 enum __ptrace_request request,
kaf24@7339 98 uint32_t domid,
kaf24@6941 99 long addr,
kaf24@6941 100 long data);
kaf24@4719 101
kaf24@6941 102 long xc_ptrace_core(
kaf24@6941 103 int xc_handle,
kaf24@6941 104 enum __ptrace_request request,
kaf24@7339 105 uint32_t domid,
kaf24@6941 106 long addr,
kaf24@6941 107 long data);
kaf24@4719 108
kaf24@6941 109 int xc_waitdomain(
kaf24@6941 110 int xc_handle,
kaf24@6941 111 int domain,
kaf24@6941 112 int *status,
kaf24@6941 113 int options);
kaf24@4719 114
kaf24@6941 115 int xc_waitdomain_core(
kaf24@6941 116 int xc_handle,
kaf24@6941 117 int domain,
kaf24@6941 118 int *status,
kaf24@6941 119 int options);
kaf24@4719 120
kaf24@4719 121 /*
iap10@3443 122 * DOMAIN MANAGEMENT FUNCTIONS
kaf24@3961 123 */
iap10@3443 124
mjw@1623 125 typedef struct {
kaf24@7378 126 uint32_t domid;
kaf24@7378 127 uint32_t ssidref;
mjw@1623 128 unsigned int dying:1, crashed:1, shutdown:1,
mjw@1623 129 paused:1, blocked:1, running:1;
mjw@1623 130 unsigned int shutdown_reason; /* only meaningful if shutdown==1 */
mjw@1623 131 unsigned long nr_pages;
mjw@1623 132 unsigned long shared_info_frame;
kaf24@7378 133 uint64_t cpu_time;
mjw@1623 134 unsigned long max_memkb;
kaf24@7397 135 unsigned int nr_online_vcpus;
kaf24@7397 136 unsigned int max_vcpu_id;
kaf24@7378 137 xen_domain_handle_t handle;
mjw@1623 138 } xc_dominfo_t;
mjw@1623 139
kaf24@2787 140 typedef dom0_getdomaininfo_t xc_domaininfo_t;
mjw@1623 141 int xc_domain_create(int xc_handle,
kaf24@7339 142 uint32_t ssidref,
kaf24@7378 143 xen_domain_handle_t handle,
kaf24@7339 144 uint32_t *pdomid);
iap10@3443 145
kaf24@4719 146
kaf24@4719 147 int xc_domain_dumpcore(int xc_handle,
kaf24@7339 148 uint32_t domid,
cl349@4853 149 const char *corename);
kaf24@4719 150
kaf24@7354 151 /*
kaf24@7354 152 * This function sets the maximum number vcpus that a domian may create.
kaf24@7354 153 *
kaf24@7354 154 * @parm xc_handle a handle to an open hypervisor interface.
kaf24@7354 155 * @parm domid the domain id in which vcpus are to be created.
kaf24@7354 156 * @parm max the maximum number of vcpus that the domain may create.
kaf24@7354 157 * @return 0 on success, -1 on failure.
kaf24@7354 158 */
kaf24@7354 159 int xc_domain_max_vcpus(int xc_handle,
kaf24@7354 160 uint32_t domid,
kaf24@7354 161 unsigned int max);
kaf24@4719 162
iap10@3443 163 /**
iap10@3443 164 * This function pauses a domain. A paused domain still exists in memory
iap10@3443 165 * however it does not receive any timeslices from the hypervisor.
iap10@3443 166 *
iap10@3443 167 * @parm xc_handle a handle to an open hypervisor interface
iap10@3443 168 * @parm domid the domain id to pause
iap10@3443 169 * @return 0 on success, -1 on failure.
iap10@3443 170 */
mjw@1623 171 int xc_domain_pause(int xc_handle,
kaf24@7339 172 uint32_t domid);
iap10@3443 173 /**
iap10@3443 174 * This function unpauses a domain. The domain should have been previously
iap10@3443 175 * paused.
iap10@3443 176 *
iap10@3443 177 * @parm xc_handle a handle to an open hypervisor interface
iap10@3443 178 * @parm domid the domain id to unpause
iap10@3443 179 * return 0 on success, -1 on failure
iap10@3443 180 */
mjw@1623 181 int xc_domain_unpause(int xc_handle,
kaf24@7339 182 uint32_t domid);
iap10@3443 183
iap10@3443 184 /**
iap10@3443 185 * This function will destroy a domain. Destroying a domain removes the domain
iap10@3443 186 * completely from memory. This function should be called after sending the
iap10@3443 187 * domain a SHUTDOWN control message to free up the domain resources.
iap10@3443 188 *
iap10@3443 189 * @parm xc_handle a handle to an open hypervisor interface
iap10@3443 190 * @parm domid the domain id to destroy
iap10@3443 191 * @return 0 on success, -1 on failure
iap10@3443 192 */
mjw@1623 193 int xc_domain_destroy(int xc_handle,
kaf24@7339 194 uint32_t domid);
mjw@1623 195 int xc_domain_pincpu(int xc_handle,
kaf24@7339 196 uint32_t domid,
cl349@4845 197 int vcpu,
kaf24@7378 198 cpumap_t cpumap);
kaf24@7378 199
iap10@3443 200 /**
dsteklof@5498 201 * This function will return information about one or more domains. It is
dsteklof@5498 202 * designed to iterate over the list of domains. If a single domain is
dsteklof@5498 203 * requested, this function will return the next domain in the list - if
dsteklof@5498 204 * one exists. It is, therefore, important in this case to make sure the
dsteklof@5498 205 * domain requested was the one returned.
iap10@3443 206 *
iap10@3443 207 * @parm xc_handle a handle to an open hypervisor interface
iap10@3443 208 * @parm first_domid the first domain to enumerate information from. Domains
iap10@3443 209 * are currently enumerate in order of creation.
iap10@3443 210 * @parm max_doms the number of elements in info
iap10@3443 211 * @parm info an array of max_doms size that will contain the information for
iap10@3443 212 * the enumerated domains.
iap10@3443 213 * @return the number of domains enumerated or -1 on error
iap10@3443 214 */
mjw@1623 215 int xc_domain_getinfo(int xc_handle,
kaf24@7339 216 uint32_t first_domid,
mjw@1623 217 unsigned int max_doms,
mjw@1623 218 xc_dominfo_t *info);
iap10@3443 219
iap10@3443 220 /**
kaf24@5699 221 * This function will return information about one or more domains, using a
kaf24@5699 222 * single hypercall. The domain information will be stored into the supplied
kaf24@5699 223 * array of xc_domaininfo_t structures.
kaf24@5699 224 *
kaf24@5699 225 * @parm xc_handle a handle to an open hypervisor interface
kaf24@5699 226 * @parm first_domain the first domain to enumerate information from.
kaf24@5699 227 * Domains are currently enumerate in order of creation.
kaf24@5699 228 * @parm max_domains the number of elements in info
kaf24@5699 229 * @parm info an array of max_doms size that will contain the information for
kaf24@5699 230 * the enumerated domains.
kaf24@5699 231 * @return the number of domains enumerated or -1 on error
kaf24@5699 232 */
kaf24@5699 233 int xc_domain_getinfolist(int xc_handle,
kaf24@7339 234 uint32_t first_domain,
kaf24@5699 235 unsigned int max_domains,
kaf24@5699 236 xc_domaininfo_t *info);
kaf24@5699 237
kaf24@5699 238 /**
emellor@7404 239 * This function returns information about the execution context of a
emellor@7404 240 * particular vcpu of a domain.
iap10@3443 241 *
iap10@3443 242 * @parm xc_handle a handle to an open hypervisor interface
iap10@3443 243 * @parm domid the domain to get information from
emellor@7404 244 * @parm vcpu the vcpu number
iap10@3443 245 * @parm ctxt a pointer to a structure to store the execution context of the
iap10@3443 246 * domain
iap10@3443 247 * @return 0 on success, -1 on failure
iap10@3443 248 */
cl349@4849 249 int xc_domain_get_vcpu_context(int xc_handle,
kaf24@7339 250 uint32_t domid,
kaf24@7339 251 uint32_t vcpu,
cl349@4853 252 vcpu_guest_context_t *ctxt);
cl349@4849 253
kaf24@7397 254 typedef dom0_getvcpuinfo_t xc_vcpuinfo_t;
kaf24@7397 255 int xc_domain_get_vcpu_info(int xc_handle,
kaf24@7397 256 uint32_t domid,
kaf24@7397 257 uint32_t vcpu,
kaf24@7397 258 xc_vcpuinfo_t *info);
kaf24@7397 259
kaf24@7397 260
gm281@2236 261 int xc_domain_setcpuweight(int xc_handle,
kaf24@7339 262 uint32_t domid,
gm281@2236 263 float weight);
kaf24@2787 264 long long xc_domain_get_cpu_usage(int xc_handle,
mafetter@3435 265 domid_t domid,
mafetter@3435 266 int vcpu);
mjw@1623 267
kaf24@7379 268 int xc_domain_sethandle(int xc_handle, uint32_t domid,
kaf24@7379 269 xen_domain_handle_t handle);
kaf24@2787 270
kaf24@2787 271 typedef dom0_shadow_control_stats_t xc_shadow_control_stats_t;
mjw@1623 272 int xc_shadow_control(int xc_handle,
kaf24@7339 273 uint32_t domid,
mjw@1623 274 unsigned int sop,
mjw@1623 275 unsigned long *dirty_bitmap,
mjw@1623 276 unsigned long pages,
mjw@1623 277 xc_shadow_control_stats_t *stats);
mjw@1623 278
mjw@1623 279 int xc_bvtsched_global_set(int xc_handle,
mjw@1623 280 unsigned long ctx_allow);
mjw@1623 281
mjw@1623 282 int xc_bvtsched_domain_set(int xc_handle,
kaf24@7339 283 uint32_t domid,
kaf24@7339 284 uint32_t mcuadv,
gm281@2058 285 int warpback,
kaf24@7339 286 int32_t warpvalue,
gm281@2058 287 long long warpl,
gm281@2058 288 long long warpu);
mjw@1623 289
mjw@1623 290 int xc_bvtsched_global_get(int xc_handle,
mjw@1623 291 unsigned long *ctx_allow);
mjw@1623 292
mjw@1623 293 int xc_bvtsched_domain_get(int xc_handle,
kaf24@7339 294 uint32_t domid,
kaf24@7339 295 uint32_t *mcuadv,
gm281@2058 296 int *warpback,
kaf24@7339 297 int32_t *warpvalue,
gm281@2058 298 long long *warpl,
gm281@2058 299 long long *warpu);
mjw@1623 300
sd386@3449 301 int xc_sedf_domain_set(int xc_handle,
kaf24@7339 302 uint32_t domid,
kaf24@7339 303 uint64_t period, uint64_t slice,
kaf24@7339 304 uint64_t latency, uint16_t extratime,
kaf24@7339 305 uint16_t weight);
sd386@3449 306
sd386@3449 307 int xc_sedf_domain_get(int xc_handle,
kaf24@7339 308 uint32_t domid,
kaf24@7339 309 uint64_t* period, uint64_t *slice,
kaf24@7339 310 uint64_t *latency, uint16_t *extratime,
kaf24@7339 311 uint16_t *weight);
sd386@3449 312
kaf24@2787 313 typedef evtchn_status_t xc_evtchn_status_t;
iap10@3443 314
kaf24@3961 315 /*
iap10@3443 316 * EVENT CHANNEL FUNCTIONS
kaf24@3961 317 */
iap10@3443 318
iap10@3443 319 /**
iap10@3443 320 * This function allocates an unbound port. Ports are named endpoints used for
iap10@3443 321 * interdomain communication. This function is most useful in opening a
iap10@3443 322 * well-known port within a domain to receive events on.
iap10@3443 323 *
iap10@3443 324 * @parm xc_handle a handle to an open hypervisor interface
kaf24@7223 325 * @parm dom the ID of the local domain (the 'allocatee')
kaf24@7237 326 * @parm remote_dom the ID of the domain who will later bind
kaf24@7237 327 * @return allocated port (in @dom) on success, -1 on failure
iap10@3443 328 */
kaf24@2713 329 int xc_evtchn_alloc_unbound(int xc_handle,
kaf24@7339 330 uint32_t dom,
kaf24@7339 331 uint32_t remote_dom);
iap10@3443 332
mjw@1623 333 int xc_evtchn_status(int xc_handle,
kaf24@7339 334 uint32_t dom, /* may be DOMID_SELF */
mjw@1623 335 int port,
mjw@1623 336 xc_evtchn_status_t *status);
mjw@1623 337
mjw@1623 338 int xc_physdev_pci_access_modify(int xc_handle,
kaf24@7339 339 uint32_t domid,
mjw@1623 340 int bus,
mjw@1623 341 int dev,
mjw@1623 342 int func,
mjw@1623 343 int enable);
mjw@1623 344
mjw@1623 345 int xc_readconsolering(int xc_handle,
kaf24@5327 346 char **pbuffer,
kaf24@5327 347 unsigned int *pnr_chars,
mjw@1623 348 int clear);
mjw@1623 349
kaf24@2787 350 typedef dom0_physinfo_t xc_physinfo_t;
mjw@1623 351 int xc_physinfo(int xc_handle,
mjw@1623 352 xc_physinfo_t *info);
mjw@1623 353
gm281@2236 354 int xc_sched_id(int xc_handle,
gm281@2236 355 int *sched_id);
gm281@2236 356
mjw@1623 357 int xc_domain_setmaxmem(int xc_handle,
kaf24@7339 358 uint32_t domid,
kaf24@3231 359 unsigned int max_memkb);
mjw@1623 360
cl349@5045 361 int xc_domain_memory_increase_reservation(int xc_handle,
kaf24@7339 362 uint32_t domid,
iap10@6688 363 unsigned long nr_extents,
iap10@6682 364 unsigned int extent_order,
iap10@6688 365 unsigned int address_bits,
iap10@6688 366 unsigned long *extent_start);
iap10@6688 367
iap10@6688 368 int xc_domain_memory_decrease_reservation(int xc_handle,
kaf24@7339 369 uint32_t domid,
iap10@6688 370 unsigned long nr_extents,
iap10@6688 371 unsigned int extent_order,
iap10@6688 372 unsigned long *extent_start);
iap10@6688 373
kaf24@7339 374 unsigned long xc_make_page_below_4G(int xc_handle, uint32_t domid,
iap10@6688 375 unsigned long mfn);
cl349@5045 376
kaf24@3231 377 typedef dom0_perfc_desc_t xc_perfc_desc_t;
kaf24@3231 378 /* IMPORTANT: The caller is responsible for mlock()'ing the @desc array. */
kaf24@3231 379 int xc_perfc_control(int xc_handle,
kaf24@7339 380 uint32_t op,
kaf24@3231 381 xc_perfc_desc_t *desc);
mjw@1623 382
rneugeba@3963 383 /* read/write msr */
rneugeba@3963 384 long long xc_msr_read(int xc_handle, int cpu_mask, int msr);
rneugeba@3963 385 int xc_msr_write(int xc_handle, int cpu_mask, int msr, unsigned int low,
rneugeba@3963 386 unsigned int high);
rneugeba@3963 387
iap10@3443 388 /**
iap10@3443 389 * Memory maps a range within one domain to a local address range. Mappings
iap10@3443 390 * should be unmapped with munmap and should follow the same rules as mmap
rusty@4866 391 * regarding page alignment. Returns NULL on failure.
iap10@3443 392 *
iap10@3443 393 * In Linux, the ring queue for the control channel is accessible by mapping
iap10@3443 394 * the shared_info_frame (from xc_domain_getinfo()) + 2048. The structure
iap10@3443 395 * stored there is of type control_if_t.
iap10@3443 396 *
iap10@3443 397 * @parm xc_handle a handle on an open hypervisor interface
iap10@3443 398 * @parm dom the domain to map memory from
iap10@3443 399 * @parm size the amount of memory to map (in multiples of page size)
iap10@3443 400 * @parm prot same flag as in mmap().
iap10@3443 401 * @parm mfn the frame address to map.
iap10@3443 402 */
kaf24@7339 403 void *xc_map_foreign_range(int xc_handle, uint32_t dom,
iap10@2325 404 int size, int prot,
iap10@2325 405 unsigned long mfn );
iap10@2325 406
kaf24@7339 407 void *xc_map_foreign_batch(int xc_handle, uint32_t dom, int prot,
iap10@2325 408 unsigned long *arr, int num );
iap10@2325 409
kaf24@7339 410 int xc_get_pfn_list(int xc_handle, uint32_t domid, unsigned long *pfn_buf,
cl349@4853 411 unsigned long max_pfns);
iap10@3390 412
kaf24@7339 413 int xc_ia64_get_pfn_list(int xc_handle, uint32_t domid,
kaf24@7339 414 unsigned long *pfn_buf,
kaf24@7339 415 unsigned int start_page, unsigned int nr_pages);
kaf24@5914 416
kaf24@7339 417 long xc_get_max_pages(int xc_handle, uint32_t domid);
djm@6856 418
cl349@6389 419 int xc_mmuext_op(int xc_handle, struct mmuext_op *op, unsigned int nr_ops,
cl349@6389 420 domid_t dom);
cl349@6389 421
kaf24@6468 422 int xc_memory_op(int xc_handle, int cmd, void *arg);
cl349@6389 423
kaf24@7339 424 int xc_get_pfn_type_batch(int xc_handle, uint32_t dom,
kaf24@7339 425 int num, unsigned long *arr);
cl349@6389 426
cl349@6389 427
cwc22@3985 428 /*\
cwc22@3985 429 * GRANT TABLE FUNCTIONS
cwc22@3985 430 \*/
cwc22@3985 431
cwc22@3985 432 /**
cwc22@3985 433 * This function opens a handle to the more restricted grant table hypervisor
cwc22@3985 434 * interface. This may be used where the standard interface is not
cwc22@3985 435 * available because the domain is not privileged.
cwc22@3985 436 * This function can be called multiple times within a single process.
cwc22@3985 437 * Multiple processes can have an open hypervisor interface at the same time.
cwc22@3985 438 *
cwc22@3985 439 * Each call to this function should have a corresponding call to
cwc22@3985 440 * xc_grant_interface_close().
cwc22@3985 441 *
cwc22@3985 442 * This function can fail if a Xen-enabled kernel is not currently running.
cwc22@3985 443 *
cwc22@3985 444 * @return a handle to the hypervisor grant table interface or -1 on failure
cwc22@3985 445 */
cwc22@3985 446 int xc_grant_interface_open(void);
cwc22@3985 447
cwc22@3985 448 /**
cwc22@3985 449 * This function closes an open grant table hypervisor interface.
cwc22@3985 450 *
cwc22@3985 451 * This function can fail if the handle does not represent an open interface or
cwc22@3985 452 * if there were problems closing the interface.
cwc22@3985 453 *
cwc22@3985 454 * @parm xc_handle a handle to an open grant table hypervisor interface
cwc22@3985 455 * @return 0 on success, -1 otherwise.
cwc22@3985 456 */
cwc22@3985 457 int xc_grant_interface_close(int xc_handle);
cwc22@3985 458
kaf24@7339 459 int xc_gnttab_map_grant_ref(int xc_handle,
kaf24@7339 460 uint64_t host_virt_addr,
kaf24@7339 461 uint32_t dom,
kaf24@7339 462 uint16_t ref,
kaf24@7339 463 uint16_t flags,
kaf24@7339 464 int16_t *handle,
kaf24@7339 465 uint64_t *dev_bus_addr);
cwc22@3985 466
kaf24@6281 467 int xc_gnttab_unmap_grant_ref(int xc_handle,
kaf24@7339 468 uint64_t host_virt_addr,
kaf24@7339 469 uint64_t dev_bus_addr,
kaf24@7339 470 uint16_t handle,
kaf24@7339 471 int16_t *status);
cwc22@3985 472
cwc22@3985 473 int xc_gnttab_setup_table(int xc_handle,
kaf24@7339 474 uint32_t dom,
kaf24@7339 475 uint16_t nr_frames,
kaf24@7339 476 int16_t *status,
kaf24@6281 477 unsigned long **frame_list);
cwc22@3985 478
cwc22@3985 479 /* Grant debug builds only: */
cwc22@3985 480 int xc_gnttab_dump_table(int xc_handle,
kaf24@7339 481 uint32_t dom,
kaf24@7339 482 int16_t *status);
cwc22@3985 483
kaf24@5318 484 /* Get current total pages allocated to a domain. */
kaf24@7339 485 long xc_get_tot_pages(int xc_handle, uint32_t domid);
kaf24@5318 486
kaf24@5318 487 /* Execute a privileged dom0 operation. */
kaf24@5318 488 int xc_dom0_op(int xc_handle, dom0_op_t *op);
cwc22@3985 489
vh249@6549 490 int xc_version(int xc_handle, int cmd, void *arg);
vh249@6549 491
cl349@6389 492 /*
cl349@6389 493 * MMU updates.
cl349@6389 494 */
cl349@6389 495 #define MAX_MMU_UPDATES 1024
cl349@6389 496 struct xc_mmu {
cl349@6389 497 mmu_update_t updates[MAX_MMU_UPDATES];
cl349@6389 498 int idx;
cl349@6389 499 domid_t subject;
cl349@6389 500 };
cl349@6389 501 typedef struct xc_mmu xc_mmu_t;
cl349@6389 502 xc_mmu_t *xc_init_mmu_updates(int xc_handle, domid_t dom);
cl349@6389 503 int xc_add_mmu_update(int xc_handle, xc_mmu_t *mmu,
iap10@6680 504 unsigned long long ptr, unsigned long long val);
cl349@6389 505 int xc_finish_mmu_updates(int xc_handle, xc_mmu_t *mmu);
cl349@6389 506
cl349@6389 507 #endif