sys/xen/interface/sysctl.h

   1 /******************************************************************************
   2  * sysctl.h
   3  *
   4  * System management operations. For use by node control stack.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to
   8  * deal in the Software without restriction, including without limitation the
   9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  10  * sell copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Copyright (c) 2002-2006, K Fraser
  25  */
  26
  27 #ifndef __XEN_PUBLIC_SYSCTL_H__
  28 #define __XEN_PUBLIC_SYSCTL_H__
  29
  30 #if !defined(__XEN__) && !defined(__XEN_TOOLS__)
  31 #error "sysctl operations are intended for use by node control tools only"
  32 #endif
  33
  34 #include "xen.h"
  35 #include "domctl.h"
  36 #include "physdev.h"
  37 #include "tmem.h"
  38
  39 #define XEN_SYSCTL_INTERFACE_VERSION 0x0000000C
  40
  41 /*
  42  * Read console content from Xen buffer ring.
  43  */
  44 /* XEN_SYSCTL_readconsole */
  45 struct xen_sysctl_readconsole {
  46     /* IN: Non-zero -> clear after reading. */
  47     uint8_t clear;
  48     /* IN: Non-zero -> start index specified by @index field. */
  49     uint8_t incremental;
  50     uint8_t pad0, pad1;
  51     /*
  52      * IN:  Start index for consuming from ring buffer (if @incremental);
  53      * OUT: End index after consuming from ring buffer.
  54      */
  55     uint32_t index;
  56     /* IN: Virtual address to write console data. */
  57     XEN_GUEST_HANDLE_64(char) buffer;
  58     /* IN: Size of buffer; OUT: Bytes written to buffer. */
  59     uint32_t count;
  60 };
  61 typedef struct xen_sysctl_readconsole xen_sysctl_readconsole_t;
  62 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_readconsole_t);
  63
  64 /* Get trace buffers machine base address */
  65 /* XEN_SYSCTL_tbuf_op */
  66 struct xen_sysctl_tbuf_op {
  67     /* IN variables */
  68 #define XEN_SYSCTL_TBUFOP_get_info     0
  69 #define XEN_SYSCTL_TBUFOP_set_cpu_mask 1
  70 #define XEN_SYSCTL_TBUFOP_set_evt_mask 2
  71 #define XEN_SYSCTL_TBUFOP_set_size     3
  72 #define XEN_SYSCTL_TBUFOP_enable       4
  73 #define XEN_SYSCTL_TBUFOP_disable      5
  74     uint32_t cmd;
  75     /* IN/OUT variables */
  76     struct xenctl_bitmap cpu_mask;
  77     uint32_t             evt_mask;
  78     /* OUT variables */
  79     uint64_aligned_t buffer_mfn;
  80     uint32_t size;  /* Also an IN variable! */
  81 };
  82 typedef struct xen_sysctl_tbuf_op xen_sysctl_tbuf_op_t;
  83 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_tbuf_op_t);
  84
  85 /*
  86  * Get physical information about the host machine
  87  */
  88 /* XEN_SYSCTL_physinfo */
  89  /* (x86) The platform supports HVM guests. */
  90 #define _XEN_SYSCTL_PHYSCAP_hvm          0
  91 #define XEN_SYSCTL_PHYSCAP_hvm           (1u<<_XEN_SYSCTL_PHYSCAP_hvm)
  92  /* (x86) The platform supports HVM-guest direct access to I/O devices. */
  93 #define _XEN_SYSCTL_PHYSCAP_hvm_directio 1
  94 #define XEN_SYSCTL_PHYSCAP_hvm_directio  (1u<<_XEN_SYSCTL_PHYSCAP_hvm_directio)
  95 struct xen_sysctl_physinfo {
  96     uint32_t threads_per_core;
  97     uint32_t cores_per_socket;
  98     uint32_t nr_cpus;     /* # CPUs currently online */
  99     uint32_t max_cpu_id;  /* Largest possible CPU ID on this host */
 100     uint32_t nr_nodes;    /* # nodes currently online */
 101     uint32_t max_node_id; /* Largest possible node ID on this host */
 102     uint32_t cpu_khz;
 103     uint64_aligned_t total_pages;
 104     uint64_aligned_t free_pages;
 105     uint64_aligned_t scrub_pages;
 106     uint64_aligned_t outstanding_pages;
 107     uint32_t hw_cap[8];
 108
 109     /* XEN_SYSCTL_PHYSCAP_??? */
 110     uint32_t capabilities;
 111 };
 112 typedef struct xen_sysctl_physinfo xen_sysctl_physinfo_t;
 113 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_physinfo_t);
 114
 115 /*
 116  * Get the ID of the current scheduler.
 117  */
 118 /* XEN_SYSCTL_sched_id */
 119 struct xen_sysctl_sched_id {
 120     /* OUT variable */
 121     uint32_t sched_id;
 122 };
 123 typedef struct xen_sysctl_sched_id xen_sysctl_sched_id_t;
 124 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_sched_id_t);
 125
 126 /* Interface for controlling Xen software performance counters. */
 127 /* XEN_SYSCTL_perfc_op */
 128 /* Sub-operations: */
 129 #define XEN_SYSCTL_PERFCOP_reset 1   /* Reset all counters to zero. */
 130 #define XEN_SYSCTL_PERFCOP_query 2   /* Get perfctr information. */
 131 struct xen_sysctl_perfc_desc {
 132     char         name[80];             /* name of perf counter */
 133     uint32_t     nr_vals;              /* number of values for this counter */
 134 };
 135 typedef struct xen_sysctl_perfc_desc xen_sysctl_perfc_desc_t;
 136 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_desc_t);
 137 typedef uint32_t xen_sysctl_perfc_val_t;
 138 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_val_t);
 139
 140 struct xen_sysctl_perfc_op {
 141     /* IN variables. */
 142     uint32_t       cmd;                /*  XEN_SYSCTL_PERFCOP_??? */
 143     /* OUT variables. */
 144     uint32_t       nr_counters;       /*  number of counters description  */
 145     uint32_t       nr_vals;           /*  number of values  */
 146     /* counter information (or NULL) */
 147     XEN_GUEST_HANDLE_64(xen_sysctl_perfc_desc_t) desc;
 148     /* counter values (or NULL) */
 149     XEN_GUEST_HANDLE_64(xen_sysctl_perfc_val_t) val;
 150 };
 151 typedef struct xen_sysctl_perfc_op xen_sysctl_perfc_op_t;
 152 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_op_t);
 153
 154 /* XEN_SYSCTL_getdomaininfolist */
 155 struct xen_sysctl_getdomaininfolist {
 156     /* IN variables. */
 157     domid_t               first_domain;
 158     uint32_t              max_domains;
 159     XEN_GUEST_HANDLE_64(xen_domctl_getdomaininfo_t) buffer;
 160     /* OUT variables. */
 161     uint32_t              num_domains;
 162 };
 163 typedef struct xen_sysctl_getdomaininfolist xen_sysctl_getdomaininfolist_t;
 164 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_getdomaininfolist_t);
 165
 166 /* Inject debug keys into Xen. */
 167 /* XEN_SYSCTL_debug_keys */
 168 struct xen_sysctl_debug_keys {
 169     /* IN variables. */
 170     XEN_GUEST_HANDLE_64(char) keys;
 171     uint32_t nr_keys;
 172 };
 173 typedef struct xen_sysctl_debug_keys xen_sysctl_debug_keys_t;
 174 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_debug_keys_t);
 175
 176 /* Get physical CPU information. */
 177 /* XEN_SYSCTL_getcpuinfo */
 178 struct xen_sysctl_cpuinfo {
 179     uint64_aligned_t idletime;
 180 };
 181 typedef struct xen_sysctl_cpuinfo xen_sysctl_cpuinfo_t;
 182 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpuinfo_t);
 183 struct xen_sysctl_getcpuinfo {
 184     /* IN variables. */
 185     uint32_t max_cpus;
 186     XEN_GUEST_HANDLE_64(xen_sysctl_cpuinfo_t) info;
 187     /* OUT variables. */
 188     uint32_t nr_cpus;
 189 };
 190 typedef struct xen_sysctl_getcpuinfo xen_sysctl_getcpuinfo_t;
 191 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_getcpuinfo_t);
 192
 193 /* XEN_SYSCTL_availheap */
 194 struct xen_sysctl_availheap {
 195     /* IN variables. */
 196     uint32_t min_bitwidth;  /* Smallest address width (zero if don't care). */
 197     uint32_t max_bitwidth;  /* Largest address width (zero if don't care). */
 198     int32_t  node;          /* NUMA node of interest (-1 for all nodes). */
 199     /* OUT variables. */
 200     uint64_aligned_t avail_bytes;/* Bytes available in the specified region. */
 201 };
 202 typedef struct xen_sysctl_availheap xen_sysctl_availheap_t;
 203 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_availheap_t);
 204
 205 /* XEN_SYSCTL_get_pmstat */
 206 struct pm_px_val {
 207     uint64_aligned_t freq;        /* Px core frequency */
 208     uint64_aligned_t residency;   /* Px residency time */
 209     uint64_aligned_t count;       /* Px transition count */
 210 };
 211 typedef struct pm_px_val pm_px_val_t;
 212 DEFINE_XEN_GUEST_HANDLE(pm_px_val_t);
 213
 214 struct pm_px_stat {
 215     uint8_t total;        /* total Px states */
 216     uint8_t usable;       /* usable Px states */
 217     uint8_t last;         /* last Px state */
 218     uint8_t cur;          /* current Px state */
 219     XEN_GUEST_HANDLE_64(uint64) trans_pt;   /* Px transition table */
 220     XEN_GUEST_HANDLE_64(pm_px_val_t) pt;
 221 };
 222 typedef struct pm_px_stat pm_px_stat_t;
 223 DEFINE_XEN_GUEST_HANDLE(pm_px_stat_t);
 224
 225 struct pm_cx_stat {
 226     uint32_t nr;    /* entry nr in triggers & residencies, including C0 */
 227     uint32_t last;  /* last Cx state */
 228     uint64_aligned_t idle_time;                 /* idle time from boot */
 229     XEN_GUEST_HANDLE_64(uint64) triggers;    /* Cx trigger counts */
 230     XEN_GUEST_HANDLE_64(uint64) residencies; /* Cx residencies */
 231     uint32_t nr_pc;                          /* entry nr in pc[] */
 232     uint32_t nr_cc;                          /* entry nr in cc[] */
 233     /*
 234      * These two arrays may (and generally will) have unused slots; slots not
 235      * having a corresponding hardware register will not be written by the
 236      * hypervisor. It is therefore up to the caller to put a suitable sentinel
 237      * into all slots before invoking the function.
 238      * Indexing is 1-biased (PC1/CC1 being at index 0).
 239      */
 240     XEN_GUEST_HANDLE_64(uint64) pc;
 241     XEN_GUEST_HANDLE_64(uint64) cc;
 242 };
 243
 244 struct xen_sysctl_get_pmstat {
 245 #define PMSTAT_CATEGORY_MASK 0xf0
 246 #define PMSTAT_PX            0x10
 247 #define PMSTAT_CX            0x20
 248 #define PMSTAT_get_max_px    (PMSTAT_PX | 0x1)
 249 #define PMSTAT_get_pxstat    (PMSTAT_PX | 0x2)
 250 #define PMSTAT_reset_pxstat  (PMSTAT_PX | 0x3)
 251 #define PMSTAT_get_max_cx    (PMSTAT_CX | 0x1)
 252 #define PMSTAT_get_cxstat    (PMSTAT_CX | 0x2)
 253 #define PMSTAT_reset_cxstat  (PMSTAT_CX | 0x3)
 254     uint32_t type;
 255     uint32_t cpuid;
 256     union {
 257         struct pm_px_stat getpx;
 258         struct pm_cx_stat getcx;
 259         /* other struct for tx, etc */
 260     } u;
 261 };
 262 typedef struct xen_sysctl_get_pmstat xen_sysctl_get_pmstat_t;
 263 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_get_pmstat_t);
 264
 265 /* XEN_SYSCTL_cpu_hotplug */
 266 struct xen_sysctl_cpu_hotplug {
 267     /* IN variables */
 268     uint32_t cpu;   /* Physical cpu. */
 269 #define XEN_SYSCTL_CPU_HOTPLUG_ONLINE  0
 270 #define XEN_SYSCTL_CPU_HOTPLUG_OFFLINE 1
 271     uint32_t op;    /* hotplug opcode */
 272 };
 273 typedef struct xen_sysctl_cpu_hotplug xen_sysctl_cpu_hotplug_t;
 274 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpu_hotplug_t);
 275
 276 /*
 277  * Get/set xen power management, include
 278  * 1. cpufreq governors and related parameters
 279  */
 280 /* XEN_SYSCTL_pm_op */
 281 struct xen_userspace {
 282     uint32_t scaling_setspeed;
 283 };
 284 typedef struct xen_userspace xen_userspace_t;
 285
 286 struct xen_ondemand {
 287     uint32_t sampling_rate_max;
 288     uint32_t sampling_rate_min;
 289
 290     uint32_t sampling_rate;
 291     uint32_t up_threshold;
 292 };
 293 typedef struct xen_ondemand xen_ondemand_t;
 294
 295 /*
 296  * cpufreq para name of this structure named
 297  * same as sysfs file name of native linux
 298  */
 299 #define CPUFREQ_NAME_LEN 16
 300 struct xen_get_cpufreq_para {
 301     /* IN/OUT variable */
 302     uint32_t cpu_num;
 303     uint32_t freq_num;
 304     uint32_t gov_num;
 305
 306     /* for all governors */
 307     /* OUT variable */
 308     XEN_GUEST_HANDLE_64(uint32) affected_cpus;
 309     XEN_GUEST_HANDLE_64(uint32) scaling_available_frequencies;
 310     XEN_GUEST_HANDLE_64(char)   scaling_available_governors;
 311     char scaling_driver[CPUFREQ_NAME_LEN];
 312
 313     uint32_t cpuinfo_cur_freq;
 314     uint32_t cpuinfo_max_freq;
 315     uint32_t cpuinfo_min_freq;
 316     uint32_t scaling_cur_freq;
 317
 318     char scaling_governor[CPUFREQ_NAME_LEN];
 319     uint32_t scaling_max_freq;
 320     uint32_t scaling_min_freq;
 321
 322     /* for specific governor */
 323     union {
 324         struct  xen_userspace userspace;
 325         struct  xen_ondemand ondemand;
 326     } u;
 327
 328     int32_t turbo_enabled;
 329 };
 330
 331 struct xen_set_cpufreq_gov {
 332     char scaling_governor[CPUFREQ_NAME_LEN];
 333 };
 334
 335 struct xen_set_cpufreq_para {
 336     #define SCALING_MAX_FREQ           1
 337     #define SCALING_MIN_FREQ           2
 338     #define SCALING_SETSPEED           3
 339     #define SAMPLING_RATE              4
 340     #define UP_THRESHOLD               5
 341
 342     uint32_t ctrl_type;
 343     uint32_t ctrl_value;
 344 };
 345
 346 struct xen_sysctl_pm_op {
 347     #define PM_PARA_CATEGORY_MASK      0xf0
 348     #define CPUFREQ_PARA               0x10
 349
 350     /* cpufreq command type */
 351     #define GET_CPUFREQ_PARA           (CPUFREQ_PARA | 0x01)
 352     #define SET_CPUFREQ_GOV            (CPUFREQ_PARA | 0x02)
 353     #define SET_CPUFREQ_PARA           (CPUFREQ_PARA | 0x03)
 354     #define GET_CPUFREQ_AVGFREQ        (CPUFREQ_PARA | 0x04)
 355
 356     /* set/reset scheduler power saving option */
 357     #define XEN_SYSCTL_pm_op_set_sched_opt_smt    0x21
 358
 359     /* cpuidle max_cstate access command */
 360     #define XEN_SYSCTL_pm_op_get_max_cstate       0x22
 361     #define XEN_SYSCTL_pm_op_set_max_cstate       0x23
 362
 363     /* set scheduler migration cost value */
 364     #define XEN_SYSCTL_pm_op_set_vcpu_migration_delay   0x24
 365     #define XEN_SYSCTL_pm_op_get_vcpu_migration_delay   0x25
 366
 367     /* enable/disable turbo mode when in dbs governor */
 368     #define XEN_SYSCTL_pm_op_enable_turbo               0x26
 369     #define XEN_SYSCTL_pm_op_disable_turbo              0x27
 370
 371     uint32_t cmd;
 372     uint32_t cpuid;
 373     union {
 374         struct xen_get_cpufreq_para get_para;
 375         struct xen_set_cpufreq_gov  set_gov;
 376         struct xen_set_cpufreq_para set_para;
 377         uint64_aligned_t get_avgfreq;
 378         uint32_t                    set_sched_opt_smt;
 379         uint32_t                    get_max_cstate;
 380         uint32_t                    set_max_cstate;
 381         uint32_t                    get_vcpu_migration_delay;
 382         uint32_t                    set_vcpu_migration_delay;
 383     } u;
 384 };
 385
 386 /* XEN_SYSCTL_page_offline_op */
 387 struct xen_sysctl_page_offline_op {
 388     /* IN: range of page to be offlined */
 389 #define sysctl_page_offline     1
 390 #define sysctl_page_online      2
 391 #define sysctl_query_page_offline  3
 392     uint32_t cmd;
 393     uint32_t start;
 394     uint32_t end;
 395     /* OUT: result of page offline request */
 396     /*
 397      * bit 0~15: result flags
 398      * bit 16~31: owner
 399      */
 400     XEN_GUEST_HANDLE(uint32) status;
 401 };
 402
 403 #define PG_OFFLINE_STATUS_MASK    (0xFFUL)
 404
 405 /* The result is invalid, i.e. HV does not handle it */
 406 #define PG_OFFLINE_INVALID   (0x1UL << 0)
 407
 408 #define PG_OFFLINE_OFFLINED  (0x1UL << 1)
 409 #define PG_OFFLINE_PENDING   (0x1UL << 2)
 410 #define PG_OFFLINE_FAILED    (0x1UL << 3)
 411 #define PG_OFFLINE_AGAIN     (0x1UL << 4)
 412
 413 #define PG_ONLINE_FAILED     PG_OFFLINE_FAILED
 414 #define PG_ONLINE_ONLINED    PG_OFFLINE_OFFLINED
 415
 416 #define PG_OFFLINE_STATUS_OFFLINED              (0x1UL << 1)
 417 #define PG_OFFLINE_STATUS_ONLINE                (0x1UL << 2)
 418 #define PG_OFFLINE_STATUS_OFFLINE_PENDING       (0x1UL << 3)
 419 #define PG_OFFLINE_STATUS_BROKEN                (0x1UL << 4)
 420
 421 #define PG_OFFLINE_MISC_MASK    (0xFFUL << 4)
 422
 423 /* valid when PG_OFFLINE_FAILED or PG_OFFLINE_PENDING */
 424 #define PG_OFFLINE_XENPAGE   (0x1UL << 8)
 425 #define PG_OFFLINE_DOM0PAGE  (0x1UL << 9)
 426 #define PG_OFFLINE_ANONYMOUS (0x1UL << 10)
 427 #define PG_OFFLINE_NOT_CONV_RAM   (0x1UL << 11)
 428 #define PG_OFFLINE_OWNED     (0x1UL << 12)
 429
 430 #define PG_OFFLINE_BROKEN    (0x1UL << 13)
 431 #define PG_ONLINE_BROKEN     PG_OFFLINE_BROKEN
 432
 433 #define PG_OFFLINE_OWNER_SHIFT 16
 434
 435 /* XEN_SYSCTL_lockprof_op */
 436 /* Sub-operations: */
 437 #define XEN_SYSCTL_LOCKPROF_reset 1   /* Reset all profile data to zero. */
 438 #define XEN_SYSCTL_LOCKPROF_query 2   /* Get lock profile information. */
 439 /* Record-type: */
 440 #define LOCKPROF_TYPE_GLOBAL      0   /* global lock, idx meaningless */
 441 #define LOCKPROF_TYPE_PERDOM      1   /* per-domain lock, idx is domid */
 442 #define LOCKPROF_TYPE_N           2   /* number of types */
 443 struct xen_sysctl_lockprof_data {
 444     char     name[40];     /* lock name (may include up to 2 %d specifiers) */
 445     int32_t  type;         /* LOCKPROF_TYPE_??? */
 446     int32_t  idx;          /* index (e.g. domain id) */
 447     uint64_aligned_t lock_cnt;     /* # of locking succeeded */
 448     uint64_aligned_t block_cnt;    /* # of wait for lock */
 449     uint64_aligned_t lock_time;    /* nsecs lock held */
 450     uint64_aligned_t block_time;   /* nsecs waited for lock */
 451 };
 452 typedef struct xen_sysctl_lockprof_data xen_sysctl_lockprof_data_t;
 453 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_lockprof_data_t);
 454 struct xen_sysctl_lockprof_op {
 455     /* IN variables. */
 456     uint32_t       cmd;               /* XEN_SYSCTL_LOCKPROF_??? */
 457     uint32_t       max_elem;          /* size of output buffer */
 458     /* OUT variables (query only). */
 459     uint32_t       nr_elem;           /* number of elements available */
 460     uint64_aligned_t time;            /* nsecs of profile measurement */
 461     /* profile information (or NULL) */
 462     XEN_GUEST_HANDLE_64(xen_sysctl_lockprof_data_t) data;
 463 };
 464 typedef struct xen_sysctl_lockprof_op xen_sysctl_lockprof_op_t;
 465 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_lockprof_op_t);
 466
 467 /* XEN_SYSCTL_cputopoinfo */
 468 #define XEN_INVALID_CORE_ID     (~0U)
 469 #define XEN_INVALID_SOCKET_ID   (~0U)
 470 #define XEN_INVALID_NODE_ID     (~0U)
 471
 472 struct xen_sysctl_cputopo {
 473     uint32_t core;
 474     uint32_t socket;
 475     uint32_t node;
 476 };
 477 typedef struct xen_sysctl_cputopo xen_sysctl_cputopo_t;
 478 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cputopo_t);
 479
 480 /*
 481  * IN:
 482  *  - a NULL 'cputopo' handle is a request for maximun 'num_cpus'.
 483  *  - otherwise it's the number of entries in 'cputopo'
 484  *
 485  * OUT:
 486  *  - If 'num_cpus' is less than the number Xen wants to write but the handle
 487  *    handle is not a NULL one, partial data gets returned and 'num_cpus' gets
 488  *    updated to reflect the intended number.
 489  *  - Otherwise, 'num_cpus' shall indicate the number of entries written, which
 490  *    may be less than the input value.
 491  */
 492 struct xen_sysctl_cputopoinfo {
 493     uint32_t num_cpus;
 494     XEN_GUEST_HANDLE_64(xen_sysctl_cputopo_t) cputopo;
 495 };
 496 typedef struct xen_sysctl_cputopoinfo xen_sysctl_cputopoinfo_t;
 497 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cputopoinfo_t);
 498
 499 /* XEN_SYSCTL_numainfo */
 500 #define XEN_INVALID_MEM_SZ     (~0U)
 501 #define XEN_INVALID_NODE_DIST  (~0U)
 502
 503 struct xen_sysctl_meminfo {
 504     uint64_t memsize;
 505     uint64_t memfree;
 506 };
 507 typedef struct xen_sysctl_meminfo xen_sysctl_meminfo_t;
 508 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_meminfo_t);
 509
 510 /*
 511  * IN:
 512  *  - Both 'meminfo' and 'distance' handles being null is a request
 513  *    for maximum value of 'num_nodes'.
 514  *  - Otherwise it's the number of entries in 'meminfo' and square root
 515  *    of number of entries in 'distance' (when corresponding handle is
 516  *    non-null)
 517  *
 518  * OUT:
 519  *  - If 'num_nodes' is less than the number Xen wants to write but either
 520  *    handle is not a NULL one, partial data gets returned and 'num_nodes'
 521  *    gets updated to reflect the intended number.
 522  *  - Otherwise, 'num_nodes' shall indicate the number of entries written, which
 523  *    may be less than the input value.
 524  */
 525
 526 struct xen_sysctl_numainfo {
 527     uint32_t num_nodes;
 528
 529     XEN_GUEST_HANDLE_64(xen_sysctl_meminfo_t) meminfo;
 530
 531     /*
 532      * Distance between nodes 'i' and 'j' is stored in index 'i*N + j',
 533      * where N is the number of nodes that will be returned in 'num_nodes'
 534      * (i.e. not 'num_nodes' provided by the caller)
 535      */
 536     XEN_GUEST_HANDLE_64(uint32) distance;
 537 };
 538 typedef struct xen_sysctl_numainfo xen_sysctl_numainfo_t;
 539 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_numainfo_t);
 540
 541 /* XEN_SYSCTL_cpupool_op */
 542 #define XEN_SYSCTL_CPUPOOL_OP_CREATE                1  /* C */
 543 #define XEN_SYSCTL_CPUPOOL_OP_DESTROY               2  /* D */
 544 #define XEN_SYSCTL_CPUPOOL_OP_INFO                  3  /* I */
 545 #define XEN_SYSCTL_CPUPOOL_OP_ADDCPU                4  /* A */
 546 #define XEN_SYSCTL_CPUPOOL_OP_RMCPU                 5  /* R */
 547 #define XEN_SYSCTL_CPUPOOL_OP_MOVEDOMAIN            6  /* M */
 548 #define XEN_SYSCTL_CPUPOOL_OP_FREEINFO              7  /* F */
 549 #define XEN_SYSCTL_CPUPOOL_PAR_ANY     0xFFFFFFFF
 550 struct xen_sysctl_cpupool_op {
 551     uint32_t op;          /* IN */
 552     uint32_t cpupool_id;  /* IN: CDIARM OUT: CI */
 553     uint32_t sched_id;    /* IN: C      OUT: I  */
 554     uint32_t domid;       /* IN: M              */
 555     uint32_t cpu;         /* IN: AR             */
 556     uint32_t n_dom;       /*            OUT: I  */
 557     struct xenctl_bitmap cpumap; /*     OUT: IF */
 558 };
 559 typedef struct xen_sysctl_cpupool_op xen_sysctl_cpupool_op_t;
 560 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpupool_op_t);
 561
 562 #define ARINC653_MAX_DOMAINS_PER_SCHEDULE   64
 563 /*
 564  * This structure is used to pass a new ARINC653 schedule from a
 565  * privileged domain (ie dom0) to Xen.
 566  */
 567 struct xen_sysctl_arinc653_schedule {
 568     /* major_frame holds the time for the new schedule's major frame
 569      * in nanoseconds. */
 570     uint64_aligned_t     major_frame;
 571     /* num_sched_entries holds how many of the entries in the
 572      * sched_entries[] array are valid. */
 573     uint8_t     num_sched_entries;
 574     /* The sched_entries array holds the actual schedule entries. */
 575     struct {
 576         /* dom_handle must match a domain's UUID */
 577         xen_domain_handle_t dom_handle;
 578         /* If a domain has multiple VCPUs, vcpu_id specifies which one
 579          * this schedule entry applies to. It should be set to 0 if
 580          * there is only one VCPU for the domain. */
 581         unsigned int vcpu_id;
 582         /* runtime specifies the amount of time that should be allocated
 583          * to this VCPU per major frame. It is specified in nanoseconds */
 584         uint64_aligned_t runtime;
 585     } sched_entries[ARINC653_MAX_DOMAINS_PER_SCHEDULE];
 586 };
 587 typedef struct xen_sysctl_arinc653_schedule xen_sysctl_arinc653_schedule_t;
 588 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_arinc653_schedule_t);
 589
 590 struct xen_sysctl_credit_schedule {
 591     /* Length of timeslice in milliseconds */
 592 #define XEN_SYSCTL_CSCHED_TSLICE_MAX 1000
 593 #define XEN_SYSCTL_CSCHED_TSLICE_MIN 1
 594     unsigned tslice_ms;
 595     /* Rate limit (minimum timeslice) in microseconds */
 596 #define XEN_SYSCTL_SCHED_RATELIMIT_MAX 500000
 597 #define XEN_SYSCTL_SCHED_RATELIMIT_MIN 100
 598     unsigned ratelimit_us;
 599 };
 600 typedef struct xen_sysctl_credit_schedule xen_sysctl_credit_schedule_t;
 601 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_credit_schedule_t);
 602
 603 /* XEN_SYSCTL_scheduler_op */
 604 /* Set or get info? */
 605 #define XEN_SYSCTL_SCHEDOP_putinfo 0
 606 #define XEN_SYSCTL_SCHEDOP_getinfo 1
 607 struct xen_sysctl_scheduler_op {
 608     uint32_t cpupool_id; /* Cpupool whose scheduler is to be targetted. */
 609     uint32_t sched_id;   /* XEN_SCHEDULER_* (domctl.h) */
 610     uint32_t cmd;        /* XEN_SYSCTL_SCHEDOP_* */
 611     union {
 612         struct xen_sysctl_sched_arinc653 {
 613             XEN_GUEST_HANDLE_64(xen_sysctl_arinc653_schedule_t) schedule;
 614         } sched_arinc653;
 615         struct xen_sysctl_credit_schedule sched_credit;
 616     } u;
 617 };
 618 typedef struct xen_sysctl_scheduler_op xen_sysctl_scheduler_op_t;
 619 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_scheduler_op_t);
 620
 621 /* XEN_SYSCTL_coverage_op */
 622 /*
 623  * Get total size of information, to help allocate
 624  * the buffer. The pointer points to a 32 bit value.
 625  */
 626 #define XEN_SYSCTL_COVERAGE_get_total_size 0
 627
 628 /*
 629  * Read coverage information in a single run
 630  * You must use a tool to split them.
 631  */
 632 #define XEN_SYSCTL_COVERAGE_read           1
 633
 634 /*
 635  * Reset all the coverage counters to 0
 636  * No parameters.
 637  */
 638 #define XEN_SYSCTL_COVERAGE_reset          2
 639
 640 /*
 641  * Like XEN_SYSCTL_COVERAGE_read but reset also
 642  * counters to 0 in a single call.
 643  */
 644 #define XEN_SYSCTL_COVERAGE_read_and_reset 3
 645
 646 struct xen_sysctl_coverage_op {
 647     uint32_t cmd;        /* XEN_SYSCTL_COVERAGE_* */
 648     union {
 649         uint32_t total_size; /* OUT */
 650         XEN_GUEST_HANDLE_64(uint8)  raw_info;   /* OUT */
 651     } u;
 652 };
 653 typedef struct xen_sysctl_coverage_op xen_sysctl_coverage_op_t;
 654 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_coverage_op_t);
 655
 656 #define XEN_SYSCTL_PSR_CMT_get_total_rmid            0
 657 #define XEN_SYSCTL_PSR_CMT_get_l3_upscaling_factor   1
 658 /* The L3 cache size is returned in KB unit */
 659 #define XEN_SYSCTL_PSR_CMT_get_l3_cache_size         2
 660 #define XEN_SYSCTL_PSR_CMT_enabled                   3
 661 #define XEN_SYSCTL_PSR_CMT_get_l3_event_mask         4
 662 struct xen_sysctl_psr_cmt_op {
 663     uint32_t cmd;       /* IN: XEN_SYSCTL_PSR_CMT_* */
 664     uint32_t flags;     /* padding variable, may be extended for future use */
 665     union {
 666         uint64_t data;  /* OUT */
 667         struct {
 668             uint32_t cpu;   /* IN */
 669             uint32_t rsvd;
 670         } l3_cache;
 671     } u;
 672 };
 673 typedef struct xen_sysctl_psr_cmt_op xen_sysctl_psr_cmt_op_t;
 674 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_psr_cmt_op_t);
 675
 676 /* XEN_SYSCTL_pcitopoinfo */
 677 #define XEN_INVALID_DEV (XEN_INVALID_NODE_ID - 1)
 678 struct xen_sysctl_pcitopoinfo {
 679     /*
 680      * IN: Number of elements in 'pcitopo' and 'nodes' arrays.
 681      * OUT: Number of processed elements of those arrays.
 682      */
 683     uint32_t num_devs;
 684
 685     /* IN: list of devices for which node IDs are requested. */
 686     XEN_GUEST_HANDLE_64(physdev_pci_device_t) devs;
 687
 688     /*
 689      * OUT: node identifier for each device.
 690      * If information for a particular device is not available then
 691      * corresponding entry will be set to XEN_INVALID_NODE_ID. If
 692      * device is not known to the hypervisor then XEN_INVALID_DEV
 693      * will be provided.
 694      */
 695     XEN_GUEST_HANDLE_64(uint32) nodes;
 696 };
 697 typedef struct xen_sysctl_pcitopoinfo xen_sysctl_pcitopoinfo_t;
 698 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_pcitopoinfo_t);
 699
 700 #define XEN_SYSCTL_PSR_CAT_get_l3_info               0
 701 struct xen_sysctl_psr_cat_op {
 702     uint32_t cmd;       /* IN: XEN_SYSCTL_PSR_CAT_* */
 703     uint32_t target;    /* IN */
 704     union {
 705         struct {
 706             uint32_t cbm_len;   /* OUT: CBM length */
 707             uint32_t cos_max;   /* OUT: Maximum COS */
 708         } l3_info;
 709     } u;
 710 };
 711 typedef struct xen_sysctl_psr_cat_op xen_sysctl_psr_cat_op_t;
 712 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_psr_cat_op_t);
 713
 714 #define XEN_SYSCTL_TMEM_OP_ALL_CLIENTS 0xFFFFU
 715
 716 #define XEN_SYSCTL_TMEM_OP_THAW                   0
 717 #define XEN_SYSCTL_TMEM_OP_FREEZE                 1
 718 #define XEN_SYSCTL_TMEM_OP_FLUSH                  2
 719 #define XEN_SYSCTL_TMEM_OP_DESTROY                3
 720 #define XEN_SYSCTL_TMEM_OP_LIST                   4
 721 #define XEN_SYSCTL_TMEM_OP_SET_WEIGHT             5
 722 #define XEN_SYSCTL_TMEM_OP_SET_CAP                6
 723 #define XEN_SYSCTL_TMEM_OP_SET_COMPRESS           7
 724 #define XEN_SYSCTL_TMEM_OP_QUERY_FREEABLE_MB      8
 725 #define XEN_SYSCTL_TMEM_OP_SAVE_BEGIN             10
 726 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_VERSION       11
 727 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_MAXPOOLS      12
 728 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_CLIENT_WEIGHT 13
 729 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_CLIENT_CAP    14
 730 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_CLIENT_FLAGS  15
 731 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_POOL_FLAGS    16
 732 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_POOL_NPAGES   17
 733 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_POOL_UUID     18
 734 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_PAGE     19
 735 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_INV      20
 736 #define XEN_SYSCTL_TMEM_OP_SAVE_END               21
 737 #define XEN_SYSCTL_TMEM_OP_RESTORE_BEGIN          30
 738 #define XEN_SYSCTL_TMEM_OP_RESTORE_PUT_PAGE       32
 739 #define XEN_SYSCTL_TMEM_OP_RESTORE_FLUSH_PAGE     33
 740
 741 /*
 742  * XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_[PAGE|INV] override the 'buf' in
 743  * xen_sysctl_tmem_op with this structure - sometimes with an extra
 744  * page tackled on.
 745  */
 746 struct tmem_handle {
 747     uint32_t pool_id;
 748     uint32_t index;
 749     xen_tmem_oid_t oid;
 750 };
 751
 752 struct xen_sysctl_tmem_op {
 753     uint32_t cmd;       /* IN: XEN_SYSCTL_TMEM_OP_* . */
 754     int32_t pool_id;    /* IN: 0 by default unless _SAVE_*, RESTORE_* .*/
 755     uint32_t cli_id;    /* IN: client id, 0 for XEN_SYSCTL_TMEM_QUERY_FREEABLE_MB
 756                            for all others can be the domain id or
 757                            XEN_SYSCTL_TMEM_OP_ALL_CLIENTS for all. */
 758     uint32_t arg1;      /* IN: If not applicable to command use 0. */
 759     uint32_t arg2;      /* IN: If not applicable to command use 0. */
 760     uint32_t pad;       /* Padding so structure is the same under 32 and 64. */
 761     xen_tmem_oid_t oid; /* IN: If not applicable to command use 0s. */
 762     XEN_GUEST_HANDLE_64(char) buf; /* IN/OUT: Buffer to save and restore ops. */
 763 };
 764 typedef struct xen_sysctl_tmem_op xen_sysctl_tmem_op_t;
 765 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_tmem_op_t);
 766
 767 struct xen_sysctl {
 768     uint32_t cmd;
 769 #define XEN_SYSCTL_readconsole                    1
 770 #define XEN_SYSCTL_tbuf_op                        2
 771 #define XEN_SYSCTL_physinfo                       3
 772 #define XEN_SYSCTL_sched_id                       4
 773 #define XEN_SYSCTL_perfc_op                       5
 774 #define XEN_SYSCTL_getdomaininfolist              6
 775 #define XEN_SYSCTL_debug_keys                     7
 776 #define XEN_SYSCTL_getcpuinfo                     8
 777 #define XEN_SYSCTL_availheap                      9
 778 #define XEN_SYSCTL_get_pmstat                    10
 779 #define XEN_SYSCTL_cpu_hotplug                   11
 780 #define XEN_SYSCTL_pm_op                         12
 781 #define XEN_SYSCTL_page_offline_op               14
 782 #define XEN_SYSCTL_lockprof_op                   15
 783 #define XEN_SYSCTL_cputopoinfo                   16
 784 #define XEN_SYSCTL_numainfo                      17
 785 #define XEN_SYSCTL_cpupool_op                    18
 786 #define XEN_SYSCTL_scheduler_op                  19
 787 #define XEN_SYSCTL_coverage_op                   20
 788 #define XEN_SYSCTL_psr_cmt_op                    21
 789 #define XEN_SYSCTL_pcitopoinfo                   22
 790 #define XEN_SYSCTL_psr_cat_op                    23
 791 #define XEN_SYSCTL_tmem_op                       24
 792     uint32_t interface_version; /* XEN_SYSCTL_INTERFACE_VERSION */
 793     union {
 794         struct xen_sysctl_readconsole       readconsole;
 795         struct xen_sysctl_tbuf_op           tbuf_op;
 796         struct xen_sysctl_physinfo          physinfo;
 797         struct xen_sysctl_cputopoinfo       cputopoinfo;
 798         struct xen_sysctl_pcitopoinfo       pcitopoinfo;
 799         struct xen_sysctl_numainfo          numainfo;
 800         struct xen_sysctl_sched_id          sched_id;
 801         struct xen_sysctl_perfc_op          perfc_op;
 802         struct xen_sysctl_getdomaininfolist getdomaininfolist;
 803         struct xen_sysctl_debug_keys        debug_keys;
 804         struct xen_sysctl_getcpuinfo        getcpuinfo;
 805         struct xen_sysctl_availheap         availheap;
 806         struct xen_sysctl_get_pmstat        get_pmstat;
 807         struct xen_sysctl_cpu_hotplug       cpu_hotplug;
 808         struct xen_sysctl_pm_op             pm_op;
 809         struct xen_sysctl_page_offline_op   page_offline;
 810         struct xen_sysctl_lockprof_op       lockprof_op;
 811         struct xen_sysctl_cpupool_op        cpupool_op;
 812         struct xen_sysctl_scheduler_op      scheduler_op;
 813         struct xen_sysctl_coverage_op       coverage_op;
 814         struct xen_sysctl_psr_cmt_op        psr_cmt_op;
 815         struct xen_sysctl_psr_cat_op        psr_cat_op;
 816         struct xen_sysctl_tmem_op           tmem_op;
 817         uint8_t                             pad[128];
 818     } u;
 819 };
 820 typedef struct xen_sysctl xen_sysctl_t;
 821 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_t);
 822
 823 #endif /* __XEN_PUBLIC_SYSCTL_H__ */
 824
 825 /*
 826  * Local variables:
 827  * mode: C
 828  * c-file-style: "BSD"
 829  * c-basic-offset: 4
 830  * tab-width: 4
 831  * indent-tabs-mode: nil
 832  * End:
 833  */