Home | History | Annotate | Line # | Download | only in public
      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 0x00000011
     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 
     62 /* Get trace buffers machine base address */
     63 /* XEN_SYSCTL_tbuf_op */
     64 struct xen_sysctl_tbuf_op {
     65     /* IN variables */
     66 #define XEN_SYSCTL_TBUFOP_get_info     0
     67 #define XEN_SYSCTL_TBUFOP_set_cpu_mask 1
     68 #define XEN_SYSCTL_TBUFOP_set_evt_mask 2
     69 #define XEN_SYSCTL_TBUFOP_set_size     3
     70 #define XEN_SYSCTL_TBUFOP_enable       4
     71 #define XEN_SYSCTL_TBUFOP_disable      5
     72     uint32_t cmd;
     73     /* IN/OUT variables */
     74     struct xenctl_bitmap cpu_mask;
     75     uint32_t             evt_mask;
     76     /* OUT variables */
     77     uint64_aligned_t buffer_mfn;
     78     uint32_t size;  /* Also an IN variable! */
     79 };
     80 
     81 /*
     82  * Get physical information about the host machine
     83  */
     84 /* XEN_SYSCTL_physinfo */
     85  /* (x86) The platform supports HVM guests. */
     86 #define _XEN_SYSCTL_PHYSCAP_hvm          0
     87 #define XEN_SYSCTL_PHYSCAP_hvm           (1u<<_XEN_SYSCTL_PHYSCAP_hvm)
     88  /* (x86) The platform supports HVM-guest direct access to I/O devices. */
     89 #define _XEN_SYSCTL_PHYSCAP_hvm_directio 1
     90 #define XEN_SYSCTL_PHYSCAP_hvm_directio  (1u<<_XEN_SYSCTL_PHYSCAP_hvm_directio)
     91 struct xen_sysctl_physinfo {
     92     uint32_t threads_per_core;
     93     uint32_t cores_per_socket;
     94     uint32_t nr_cpus;     /* # CPUs currently online */
     95     uint32_t max_cpu_id;  /* Largest possible CPU ID on this host */
     96     uint32_t nr_nodes;    /* # nodes currently online */
     97     uint32_t max_node_id; /* Largest possible node ID on this host */
     98     uint32_t cpu_khz;
     99     uint32_t capabilities;/* XEN_SYSCTL_PHYSCAP_??? */
    100     uint64_aligned_t total_pages;
    101     uint64_aligned_t free_pages;
    102     uint64_aligned_t scrub_pages;
    103     uint64_aligned_t outstanding_pages;
    104     uint64_aligned_t max_mfn; /* Largest possible MFN on this host */
    105     uint32_t hw_cap[8];
    106 };
    107 
    108 /*
    109  * Get the ID of the current scheduler.
    110  */
    111 /* XEN_SYSCTL_sched_id */
    112 struct xen_sysctl_sched_id {
    113     /* OUT variable */
    114     uint32_t sched_id;
    115 };
    116 
    117 /* Interface for controlling Xen software performance counters. */
    118 /* XEN_SYSCTL_perfc_op */
    119 /* Sub-operations: */
    120 #define XEN_SYSCTL_PERFCOP_reset 1   /* Reset all counters to zero. */
    121 #define XEN_SYSCTL_PERFCOP_query 2   /* Get perfctr information. */
    122 struct xen_sysctl_perfc_desc {
    123     char         name[80];             /* name of perf counter */
    124     uint32_t     nr_vals;              /* number of values for this counter */
    125 };
    126 typedef struct xen_sysctl_perfc_desc xen_sysctl_perfc_desc_t;
    127 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_desc_t);
    128 typedef uint32_t xen_sysctl_perfc_val_t;
    129 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_perfc_val_t);
    130 
    131 struct xen_sysctl_perfc_op {
    132     /* IN variables. */
    133     uint32_t       cmd;                /*  XEN_SYSCTL_PERFCOP_??? */
    134     /* OUT variables. */
    135     uint32_t       nr_counters;       /*  number of counters description  */
    136     uint32_t       nr_vals;           /*  number of values  */
    137     /* counter information (or NULL) */
    138     XEN_GUEST_HANDLE_64(xen_sysctl_perfc_desc_t) desc;
    139     /* counter values (or NULL) */
    140     XEN_GUEST_HANDLE_64(xen_sysctl_perfc_val_t) val;
    141 };
    142 
    143 /* XEN_SYSCTL_getdomaininfolist */
    144 struct xen_sysctl_getdomaininfolist {
    145     /* IN variables. */
    146     domid_t               first_domain;
    147     uint32_t              max_domains;
    148     XEN_GUEST_HANDLE_64(xen_domctl_getdomaininfo_t) buffer;
    149     /* OUT variables. */
    150     uint32_t              num_domains;
    151 };
    152 
    153 /* Inject debug keys into Xen. */
    154 /* XEN_SYSCTL_debug_keys */
    155 struct xen_sysctl_debug_keys {
    156     /* IN variables. */
    157     XEN_GUEST_HANDLE_64(char) keys;
    158     uint32_t nr_keys;
    159 };
    160 
    161 /* Get physical CPU information. */
    162 /* XEN_SYSCTL_getcpuinfo */
    163 struct xen_sysctl_cpuinfo {
    164     uint64_aligned_t idletime;
    165 };
    166 typedef struct xen_sysctl_cpuinfo xen_sysctl_cpuinfo_t;
    167 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cpuinfo_t);
    168 struct xen_sysctl_getcpuinfo {
    169     /* IN variables. */
    170     uint32_t max_cpus;
    171     XEN_GUEST_HANDLE_64(xen_sysctl_cpuinfo_t) info;
    172     /* OUT variables. */
    173     uint32_t nr_cpus;
    174 };
    175 
    176 /* XEN_SYSCTL_availheap */
    177 struct xen_sysctl_availheap {
    178     /* IN variables. */
    179     uint32_t min_bitwidth;  /* Smallest address width (zero if don't care). */
    180     uint32_t max_bitwidth;  /* Largest address width (zero if don't care). */
    181     int32_t  node;          /* NUMA node of interest (-1 for all nodes). */
    182     /* OUT variables. */
    183     uint64_aligned_t avail_bytes;/* Bytes available in the specified region. */
    184 };
    185 
    186 /* XEN_SYSCTL_get_pmstat */
    187 struct pm_px_val {
    188     uint64_aligned_t freq;        /* Px core frequency */
    189     uint64_aligned_t residency;   /* Px residency time */
    190     uint64_aligned_t count;       /* Px transition count */
    191 };
    192 typedef struct pm_px_val pm_px_val_t;
    193 DEFINE_XEN_GUEST_HANDLE(pm_px_val_t);
    194 
    195 struct pm_px_stat {
    196     uint8_t total;        /* total Px states */
    197     uint8_t usable;       /* usable Px states */
    198     uint8_t last;         /* last Px state */
    199     uint8_t cur;          /* current Px state */
    200     XEN_GUEST_HANDLE_64(uint64) trans_pt;   /* Px transition table */
    201     XEN_GUEST_HANDLE_64(pm_px_val_t) pt;
    202 };
    203 
    204 struct pm_cx_stat {
    205     uint32_t nr;    /* entry nr in triggers & residencies, including C0 */
    206     uint32_t last;  /* last Cx state */
    207     uint64_aligned_t idle_time;                 /* idle time from boot */
    208     XEN_GUEST_HANDLE_64(uint64) triggers;    /* Cx trigger counts */
    209     XEN_GUEST_HANDLE_64(uint64) residencies; /* Cx residencies */
    210     uint32_t nr_pc;                          /* entry nr in pc[] */
    211     uint32_t nr_cc;                          /* entry nr in cc[] */
    212     /*
    213      * These two arrays may (and generally will) have unused slots; slots not
    214      * having a corresponding hardware register will not be written by the
    215      * hypervisor. It is therefore up to the caller to put a suitable sentinel
    216      * into all slots before invoking the function.
    217      * Indexing is 1-biased (PC1/CC1 being at index 0).
    218      */
    219     XEN_GUEST_HANDLE_64(uint64) pc;
    220     XEN_GUEST_HANDLE_64(uint64) cc;
    221 };
    222 
    223 struct xen_sysctl_get_pmstat {
    224 #define PMSTAT_CATEGORY_MASK 0xf0
    225 #define PMSTAT_PX            0x10
    226 #define PMSTAT_CX            0x20
    227 #define PMSTAT_get_max_px    (PMSTAT_PX | 0x1)
    228 #define PMSTAT_get_pxstat    (PMSTAT_PX | 0x2)
    229 #define PMSTAT_reset_pxstat  (PMSTAT_PX | 0x3)
    230 #define PMSTAT_get_max_cx    (PMSTAT_CX | 0x1)
    231 #define PMSTAT_get_cxstat    (PMSTAT_CX | 0x2)
    232 #define PMSTAT_reset_cxstat  (PMSTAT_CX | 0x3)
    233     uint32_t type;
    234     uint32_t cpuid;
    235     union {
    236         struct pm_px_stat getpx;
    237         struct pm_cx_stat getcx;
    238         /* other struct for tx, etc */
    239     } u;
    240 };
    241 
    242 /* XEN_SYSCTL_cpu_hotplug */
    243 struct xen_sysctl_cpu_hotplug {
    244     /* IN variables */
    245     uint32_t cpu;   /* Physical cpu. */
    246 #define XEN_SYSCTL_CPU_HOTPLUG_ONLINE  0
    247 #define XEN_SYSCTL_CPU_HOTPLUG_OFFLINE 1
    248     uint32_t op;    /* hotplug opcode */
    249 };
    250 
    251 /*
    252  * Get/set xen power management, include
    253  * 1. cpufreq governors and related parameters
    254  */
    255 /* XEN_SYSCTL_pm_op */
    256 struct xen_userspace {
    257     uint32_t scaling_setspeed;
    258 };
    259 
    260 struct xen_ondemand {
    261     uint32_t sampling_rate_max;
    262     uint32_t sampling_rate_min;
    263 
    264     uint32_t sampling_rate;
    265     uint32_t up_threshold;
    266 };
    267 
    268 /*
    269  * cpufreq para name of this structure named
    270  * same as sysfs file name of native linux
    271  */
    272 #define CPUFREQ_NAME_LEN 16
    273 struct xen_get_cpufreq_para {
    274     /* IN/OUT variable */
    275     uint32_t cpu_num;
    276     uint32_t freq_num;
    277     uint32_t gov_num;
    278 
    279     /* for all governors */
    280     /* OUT variable */
    281     XEN_GUEST_HANDLE_64(uint32) affected_cpus;
    282     XEN_GUEST_HANDLE_64(uint32) scaling_available_frequencies;
    283     XEN_GUEST_HANDLE_64(char)   scaling_available_governors;
    284     char scaling_driver[CPUFREQ_NAME_LEN];
    285 
    286     uint32_t cpuinfo_cur_freq;
    287     uint32_t cpuinfo_max_freq;
    288     uint32_t cpuinfo_min_freq;
    289     uint32_t scaling_cur_freq;
    290 
    291     char scaling_governor[CPUFREQ_NAME_LEN];
    292     uint32_t scaling_max_freq;
    293     uint32_t scaling_min_freq;
    294 
    295     /* for specific governor */
    296     union {
    297         struct  xen_userspace userspace;
    298         struct  xen_ondemand ondemand;
    299     } u;
    300 
    301     int32_t turbo_enabled;
    302 };
    303 
    304 struct xen_set_cpufreq_gov {
    305     char scaling_governor[CPUFREQ_NAME_LEN];
    306 };
    307 
    308 struct xen_set_cpufreq_para {
    309     #define SCALING_MAX_FREQ           1
    310     #define SCALING_MIN_FREQ           2
    311     #define SCALING_SETSPEED           3
    312     #define SAMPLING_RATE              4
    313     #define UP_THRESHOLD               5
    314 
    315     uint32_t ctrl_type;
    316     uint32_t ctrl_value;
    317 };
    318 
    319 struct xen_sysctl_pm_op {
    320     #define PM_PARA_CATEGORY_MASK      0xf0
    321     #define CPUFREQ_PARA               0x10
    322 
    323     /* cpufreq command type */
    324     #define GET_CPUFREQ_PARA           (CPUFREQ_PARA | 0x01)
    325     #define SET_CPUFREQ_GOV            (CPUFREQ_PARA | 0x02)
    326     #define SET_CPUFREQ_PARA           (CPUFREQ_PARA | 0x03)
    327     #define GET_CPUFREQ_AVGFREQ        (CPUFREQ_PARA | 0x04)
    328 
    329     /* set/reset scheduler power saving option */
    330     #define XEN_SYSCTL_pm_op_set_sched_opt_smt    0x21
    331 
    332     /* cpuidle max_cstate access command */
    333     #define XEN_SYSCTL_pm_op_get_max_cstate       0x22
    334     #define XEN_SYSCTL_pm_op_set_max_cstate       0x23
    335 
    336     /* set scheduler migration cost value */
    337     #define XEN_SYSCTL_pm_op_set_vcpu_migration_delay   0x24
    338     #define XEN_SYSCTL_pm_op_get_vcpu_migration_delay   0x25
    339 
    340     /* enable/disable turbo mode when in dbs governor */
    341     #define XEN_SYSCTL_pm_op_enable_turbo               0x26
    342     #define XEN_SYSCTL_pm_op_disable_turbo              0x27
    343 
    344     uint32_t cmd;
    345     uint32_t cpuid;
    346     union {
    347         struct xen_get_cpufreq_para get_para;
    348         struct xen_set_cpufreq_gov  set_gov;
    349         struct xen_set_cpufreq_para set_para;
    350         uint64_aligned_t get_avgfreq;
    351         uint32_t                    set_sched_opt_smt;
    352         uint32_t                    get_max_cstate;
    353         uint32_t                    set_max_cstate;
    354     } u;
    355 };
    356 
    357 /* XEN_SYSCTL_page_offline_op */
    358 struct xen_sysctl_page_offline_op {
    359     /* IN: range of page to be offlined */
    360 #define sysctl_page_offline     1
    361 #define sysctl_page_online      2
    362 #define sysctl_query_page_offline  3
    363     uint32_t cmd;
    364     uint32_t start;
    365     uint32_t end;
    366     /* OUT: result of page offline request */
    367     /*
    368      * bit 0~15: result flags
    369      * bit 16~31: owner
    370      */
    371     XEN_GUEST_HANDLE(uint32) status;
    372 };
    373 
    374 #define PG_OFFLINE_STATUS_MASK    (0xFFUL)
    375 
    376 /* The result is invalid, i.e. HV does not handle it */
    377 #define PG_OFFLINE_INVALID   (0x1UL << 0)
    378 
    379 #define PG_OFFLINE_OFFLINED  (0x1UL << 1)
    380 #define PG_OFFLINE_PENDING   (0x1UL << 2)
    381 #define PG_OFFLINE_FAILED    (0x1UL << 3)
    382 #define PG_OFFLINE_AGAIN     (0x1UL << 4)
    383 
    384 #define PG_ONLINE_FAILED     PG_OFFLINE_FAILED
    385 #define PG_ONLINE_ONLINED    PG_OFFLINE_OFFLINED
    386 
    387 #define PG_OFFLINE_STATUS_OFFLINED              (0x1UL << 1)
    388 #define PG_OFFLINE_STATUS_ONLINE                (0x1UL << 2)
    389 #define PG_OFFLINE_STATUS_OFFLINE_PENDING       (0x1UL << 3)
    390 #define PG_OFFLINE_STATUS_BROKEN                (0x1UL << 4)
    391 
    392 #define PG_OFFLINE_MISC_MASK    (0xFFUL << 4)
    393 
    394 /* valid when PG_OFFLINE_FAILED or PG_OFFLINE_PENDING */
    395 #define PG_OFFLINE_XENPAGE   (0x1UL << 8)
    396 #define PG_OFFLINE_DOM0PAGE  (0x1UL << 9)
    397 #define PG_OFFLINE_ANONYMOUS (0x1UL << 10)
    398 #define PG_OFFLINE_NOT_CONV_RAM   (0x1UL << 11)
    399 #define PG_OFFLINE_OWNED     (0x1UL << 12)
    400 
    401 #define PG_OFFLINE_BROKEN    (0x1UL << 13)
    402 #define PG_ONLINE_BROKEN     PG_OFFLINE_BROKEN
    403 
    404 #define PG_OFFLINE_OWNER_SHIFT 16
    405 
    406 /* XEN_SYSCTL_lockprof_op */
    407 /* Sub-operations: */
    408 #define XEN_SYSCTL_LOCKPROF_reset 1   /* Reset all profile data to zero. */
    409 #define XEN_SYSCTL_LOCKPROF_query 2   /* Get lock profile information. */
    410 /* Record-type: */
    411 #define LOCKPROF_TYPE_GLOBAL      0   /* global lock, idx meaningless */
    412 #define LOCKPROF_TYPE_PERDOM      1   /* per-domain lock, idx is domid */
    413 #define LOCKPROF_TYPE_N           2   /* number of types */
    414 struct xen_sysctl_lockprof_data {
    415     char     name[40];     /* lock name (may include up to 2 %d specifiers) */
    416     int32_t  type;         /* LOCKPROF_TYPE_??? */
    417     int32_t  idx;          /* index (e.g. domain id) */
    418     uint64_aligned_t lock_cnt;     /* # of locking succeeded */
    419     uint64_aligned_t block_cnt;    /* # of wait for lock */
    420     uint64_aligned_t lock_time;    /* nsecs lock held */
    421     uint64_aligned_t block_time;   /* nsecs waited for lock */
    422 };
    423 typedef struct xen_sysctl_lockprof_data xen_sysctl_lockprof_data_t;
    424 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_lockprof_data_t);
    425 struct xen_sysctl_lockprof_op {
    426     /* IN variables. */
    427     uint32_t       cmd;               /* XEN_SYSCTL_LOCKPROF_??? */
    428     uint32_t       max_elem;          /* size of output buffer */
    429     /* OUT variables (query only). */
    430     uint32_t       nr_elem;           /* number of elements available */
    431     uint64_aligned_t time;            /* nsecs of profile measurement */
    432     /* profile information (or NULL) */
    433     XEN_GUEST_HANDLE_64(xen_sysctl_lockprof_data_t) data;
    434 };
    435 
    436 /* XEN_SYSCTL_cputopoinfo */
    437 #define XEN_INVALID_CORE_ID     (~0U)
    438 #define XEN_INVALID_SOCKET_ID   (~0U)
    439 #define XEN_INVALID_NODE_ID     (~0U)
    440 
    441 struct xen_sysctl_cputopo {
    442     uint32_t core;
    443     uint32_t socket;
    444     uint32_t node;
    445 };
    446 typedef struct xen_sysctl_cputopo xen_sysctl_cputopo_t;
    447 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_cputopo_t);
    448 
    449 /*
    450  * IN:
    451  *  - a NULL 'cputopo' handle is a request for maximun 'num_cpus'.
    452  *  - otherwise it's the number of entries in 'cputopo'
    453  *
    454  * OUT:
    455  *  - If 'num_cpus' is less than the number Xen wants to write but the handle
    456  *    handle is not a NULL one, partial data gets returned and 'num_cpus' gets
    457  *    updated to reflect the intended number.
    458  *  - Otherwise, 'num_cpus' shall indicate the number of entries written, which
    459  *    may be less than the input value.
    460  */
    461 struct xen_sysctl_cputopoinfo {
    462     uint32_t num_cpus;
    463     XEN_GUEST_HANDLE_64(xen_sysctl_cputopo_t) cputopo;
    464 };
    465 
    466 /* XEN_SYSCTL_numainfo */
    467 #define XEN_INVALID_MEM_SZ     (~0U)
    468 #define XEN_INVALID_NODE_DIST  (~0U)
    469 
    470 struct xen_sysctl_meminfo {
    471     uint64_t memsize;
    472     uint64_t memfree;
    473 };
    474 typedef struct xen_sysctl_meminfo xen_sysctl_meminfo_t;
    475 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_meminfo_t);
    476 
    477 /*
    478  * IN:
    479  *  - Both 'meminfo' and 'distance' handles being null is a request
    480  *    for maximum value of 'num_nodes'.
    481  *  - Otherwise it's the number of entries in 'meminfo' and square root
    482  *    of number of entries in 'distance' (when corresponding handle is
    483  *    non-null)
    484  *
    485  * OUT:
    486  *  - If 'num_nodes' is less than the number Xen wants to write but either
    487  *    handle is not a NULL one, partial data gets returned and 'num_nodes'
    488  *    gets updated to reflect the intended number.
    489  *  - Otherwise, 'num_nodes' shall indicate the number of entries written, which
    490  *    may be less than the input value.
    491  */
    492 
    493 struct xen_sysctl_numainfo {
    494     uint32_t num_nodes;
    495 
    496     XEN_GUEST_HANDLE_64(xen_sysctl_meminfo_t) meminfo;
    497 
    498     /*
    499      * Distance between nodes 'i' and 'j' is stored in index 'i*N + j',
    500      * where N is the number of nodes that will be returned in 'num_nodes'
    501      * (i.e. not 'num_nodes' provided by the caller)
    502      */
    503     XEN_GUEST_HANDLE_64(uint32) distance;
    504 };
    505 
    506 /* XEN_SYSCTL_cpupool_op */
    507 #define XEN_SYSCTL_CPUPOOL_OP_CREATE                1  /* C */
    508 #define XEN_SYSCTL_CPUPOOL_OP_DESTROY               2  /* D */
    509 #define XEN_SYSCTL_CPUPOOL_OP_INFO                  3  /* I */
    510 #define XEN_SYSCTL_CPUPOOL_OP_ADDCPU                4  /* A */
    511 #define XEN_SYSCTL_CPUPOOL_OP_RMCPU                 5  /* R */
    512 #define XEN_SYSCTL_CPUPOOL_OP_MOVEDOMAIN            6  /* M */
    513 #define XEN_SYSCTL_CPUPOOL_OP_FREEINFO              7  /* F */
    514 #define XEN_SYSCTL_CPUPOOL_PAR_ANY     0xFFFFFFFF
    515 struct xen_sysctl_cpupool_op {
    516     uint32_t op;          /* IN */
    517     uint32_t cpupool_id;  /* IN: CDIARM OUT: CI */
    518     uint32_t sched_id;    /* IN: C      OUT: I  */
    519     uint32_t domid;       /* IN: M              */
    520     uint32_t cpu;         /* IN: AR             */
    521     uint32_t n_dom;       /*            OUT: I  */
    522     struct xenctl_bitmap cpumap; /*     OUT: IF */
    523 };
    524 
    525 /*
    526  * Error return values of cpupool operations:
    527  *
    528  * -EADDRINUSE:
    529  *  XEN_SYSCTL_CPUPOOL_OP_RMCPU: A vcpu is temporarily pinned to the cpu
    530  *    which is to be removed from a cpupool.
    531  * -EADDRNOTAVAIL:
    532  *  XEN_SYSCTL_CPUPOOL_OP_ADDCPU, XEN_SYSCTL_CPUPOOL_OP_RMCPU: A previous
    533  *    request to remove a cpu from a cpupool was terminated with -EAGAIN
    534  *    and has not been retried using the same parameters.
    535  * -EAGAIN:
    536  *  XEN_SYSCTL_CPUPOOL_OP_RMCPU: The cpu can't be removed from the cpupool
    537  *    as it is active in the hypervisor. A retry will succeed soon.
    538  * -EBUSY:
    539  *  XEN_SYSCTL_CPUPOOL_OP_DESTROY, XEN_SYSCTL_CPUPOOL_OP_RMCPU: A cpupool
    540  *    can't be destroyed or the last cpu can't be removed as there is still
    541  *    a running domain in that cpupool.
    542  * -EEXIST:
    543  *  XEN_SYSCTL_CPUPOOL_OP_CREATE: A cpupool_id was specified and is already
    544  *    existing.
    545  * -EINVAL:
    546  *  XEN_SYSCTL_CPUPOOL_OP_ADDCPU, XEN_SYSCTL_CPUPOOL_OP_RMCPU: An illegal
    547  *    cpu was specified (cpu does not exist).
    548  *  XEN_SYSCTL_CPUPOOL_OP_MOVEDOMAIN: An illegal domain was specified
    549  *    (domain id illegal or not suitable for operation).
    550  * -ENODEV:
    551  *  XEN_SYSCTL_CPUPOOL_OP_ADDCPU, XEN_SYSCTL_CPUPOOL_OP_RMCPU: The specified
    552  *    cpu is either not free (add) or not member of the specified cpupool
    553  *    (remove).
    554  * -ENOENT:
    555  *  all: The cpupool with the specified cpupool_id doesn't exist.
    556  *
    557  * Some common error return values like -ENOMEM and -EFAULT are possible for
    558  * all the operations.
    559  */
    560 
    561 #define ARINC653_MAX_DOMAINS_PER_SCHEDULE   64
    562 /*
    563  * This structure is used to pass a new ARINC653 schedule from a
    564  * privileged domain (ie dom0) to Xen.
    565  */
    566 struct xen_sysctl_arinc653_schedule {
    567     /* major_frame holds the time for the new schedule's major frame
    568      * in nanoseconds. */
    569     uint64_aligned_t     major_frame;
    570     /* num_sched_entries holds how many of the entries in the
    571      * sched_entries[] array are valid. */
    572     uint8_t     num_sched_entries;
    573     /* The sched_entries array holds the actual schedule entries. */
    574     struct {
    575         /* dom_handle must match a domain's UUID */
    576         xen_domain_handle_t dom_handle;
    577         /* If a domain has multiple VCPUs, vcpu_id specifies which one
    578          * this schedule entry applies to. It should be set to 0 if
    579          * there is only one VCPU for the domain. */
    580         unsigned int vcpu_id;
    581         /* runtime specifies the amount of time that should be allocated
    582          * to this VCPU per major frame. It is specified in nanoseconds */
    583         uint64_aligned_t runtime;
    584     } sched_entries[ARINC653_MAX_DOMAINS_PER_SCHEDULE];
    585 };
    586 typedef struct xen_sysctl_arinc653_schedule xen_sysctl_arinc653_schedule_t;
    587 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_arinc653_schedule_t);
    588 
    589 /*
    590  * Valid range for context switch rate limit (in microseconds).
    591  * Applicable to Credit and Credit2 schedulers.
    592  */
    593 #define XEN_SYSCTL_SCHED_RATELIMIT_MAX 500000
    594 #define XEN_SYSCTL_SCHED_RATELIMIT_MIN 100
    595 
    596 struct xen_sysctl_credit_schedule {
    597     /* Length of timeslice in milliseconds */
    598 #define XEN_SYSCTL_CSCHED_TSLICE_MAX 1000
    599 #define XEN_SYSCTL_CSCHED_TSLICE_MIN 1
    600     unsigned tslice_ms;
    601     unsigned ratelimit_us;
    602     /*
    603      * How long we consider a vCPU to be cache-hot on the
    604      * CPU where it has run (max 100ms, in microseconds)
    605     */
    606 #define XEN_SYSCTL_CSCHED_MGR_DLY_MAX_US (100 * 1000)
    607     unsigned vcpu_migr_delay_us;
    608 };
    609 
    610 struct xen_sysctl_credit2_schedule {
    611     unsigned ratelimit_us;
    612 };
    613 
    614 /* XEN_SYSCTL_scheduler_op */
    615 /* Set or get info? */
    616 #define XEN_SYSCTL_SCHEDOP_putinfo 0
    617 #define XEN_SYSCTL_SCHEDOP_getinfo 1
    618 struct xen_sysctl_scheduler_op {
    619     uint32_t cpupool_id; /* Cpupool whose scheduler is to be targetted. */
    620     uint32_t sched_id;   /* XEN_SCHEDULER_* (domctl.h) */
    621     uint32_t cmd;        /* XEN_SYSCTL_SCHEDOP_* */
    622     union {
    623         struct xen_sysctl_sched_arinc653 {
    624             XEN_GUEST_HANDLE_64(xen_sysctl_arinc653_schedule_t) schedule;
    625         } sched_arinc653;
    626         struct xen_sysctl_credit_schedule sched_credit;
    627         struct xen_sysctl_credit2_schedule sched_credit2;
    628     } u;
    629 };
    630 
    631 /*
    632  * Output format of gcov data:
    633  *
    634  * XEN_GCOV_FORMAT_MAGIC XEN_GCOV_RECORD ... XEN_GCOV_RECORD
    635  *
    636  * That is, one magic number followed by 0 or more record.
    637  *
    638  * The magic number is stored as an uint32_t field.
    639  *
    640  * The record is packed and variable in length. It has the form:
    641  *
    642  *  filename: a NULL terminated path name extracted from gcov, used to
    643  *            create the name of gcda file.
    644  *  size:     a uint32_t field indicating the size of the payload, the
    645  *            unit is byte.
    646  *  payload:  the actual payload, length is `size' bytes.
    647  *
    648  * Userspace tool will split the record to different files.
    649  */
    650 
    651 #define XEN_GCOV_FORMAT_MAGIC    0x58434f56 /* XCOV */
    652 
    653 /*
    654  * Ouput format of LLVM coverage data is just a raw stream, as would be
    655  * written by the compiler_rt run time library into a .profraw file. There
    656  * are no special Xen tags or delimiters because none are needed.
    657  */
    658 
    659 #define XEN_SYSCTL_COVERAGE_get_size 0 /* Get total size of output data */
    660 #define XEN_SYSCTL_COVERAGE_read     1 /* Read output data */
    661 #define XEN_SYSCTL_COVERAGE_reset    2 /* Reset all counters */
    662 
    663 struct xen_sysctl_coverage_op {
    664     uint32_t cmd;
    665     uint32_t size; /* IN/OUT: size of the buffer  */
    666     XEN_GUEST_HANDLE_64(char) buffer; /* OUT */
    667 };
    668 
    669 #define XEN_SYSCTL_PSR_CMT_get_total_rmid            0
    670 #define XEN_SYSCTL_PSR_CMT_get_l3_upscaling_factor   1
    671 /* The L3 cache size is returned in KB unit */
    672 #define XEN_SYSCTL_PSR_CMT_get_l3_cache_size         2
    673 #define XEN_SYSCTL_PSR_CMT_enabled                   3
    674 #define XEN_SYSCTL_PSR_CMT_get_l3_event_mask         4
    675 struct xen_sysctl_psr_cmt_op {
    676     uint32_t cmd;       /* IN: XEN_SYSCTL_PSR_CMT_* */
    677     uint32_t flags;     /* padding variable, may be extended for future use */
    678     union {
    679         uint64_t data;  /* OUT */
    680         struct {
    681             uint32_t cpu;   /* IN */
    682             uint32_t rsvd;
    683         } l3_cache;
    684     } u;
    685 };
    686 
    687 /* XEN_SYSCTL_pcitopoinfo */
    688 #define XEN_INVALID_DEV (XEN_INVALID_NODE_ID - 1)
    689 struct xen_sysctl_pcitopoinfo {
    690     /*
    691      * IN: Number of elements in 'devs' and 'nodes' arrays.
    692      * OUT: Number of processed elements of those arrays.
    693      */
    694     uint32_t num_devs;
    695 
    696     /* IN: list of devices for which node IDs are requested. */
    697     XEN_GUEST_HANDLE_64(physdev_pci_device_t) devs;
    698 
    699     /*
    700      * OUT: node identifier for each device.
    701      * If information for a particular device is not available then
    702      * corresponding entry will be set to XEN_INVALID_NODE_ID. If
    703      * device is not known to the hypervisor then XEN_INVALID_DEV
    704      * will be provided.
    705      */
    706     XEN_GUEST_HANDLE_64(uint32) nodes;
    707 };
    708 
    709 #define XEN_SYSCTL_PSR_get_l3_info               0
    710 #define XEN_SYSCTL_PSR_get_l2_info               1
    711 #define XEN_SYSCTL_PSR_get_mba_info              2
    712 struct xen_sysctl_psr_alloc {
    713     uint32_t cmd;       /* IN: XEN_SYSCTL_PSR_* */
    714     uint32_t target;    /* IN */
    715     union {
    716         struct {
    717             uint32_t cbm_len;   /* OUT: CBM length */
    718             uint32_t cos_max;   /* OUT: Maximum COS */
    719 #define XEN_SYSCTL_PSR_CAT_L3_CDP       (1u << 0)
    720             uint32_t flags;     /* OUT: CAT flags */
    721         } cat_info;
    722 
    723         struct {
    724             uint32_t thrtl_max; /* OUT: Maximum throttle */
    725             uint32_t cos_max;   /* OUT: Maximum COS */
    726 #define XEN_SYSCTL_PSR_MBA_LINEAR      (1u << 0)
    727             uint32_t flags;     /* OUT: MBA flags */
    728         } mba_info;
    729     } u;
    730 };
    731 
    732 #define XEN_SYSCTL_TMEM_OP_ALL_CLIENTS 0xFFFFU
    733 
    734 #define XEN_SYSCTL_TMEM_OP_THAW                   0
    735 #define XEN_SYSCTL_TMEM_OP_FREEZE                 1
    736 #define XEN_SYSCTL_TMEM_OP_FLUSH                  2
    737 #define XEN_SYSCTL_TMEM_OP_DESTROY                3
    738 #define XEN_SYSCTL_TMEM_OP_LIST                   4
    739 #define XEN_SYSCTL_TMEM_OP_GET_CLIENT_INFO        5
    740 #define XEN_SYSCTL_TMEM_OP_SET_CLIENT_INFO        6
    741 #define XEN_SYSCTL_TMEM_OP_GET_POOLS              7
    742 #define XEN_SYSCTL_TMEM_OP_QUERY_FREEABLE_MB      8
    743 #define XEN_SYSCTL_TMEM_OP_SET_POOLS              9
    744 #define XEN_SYSCTL_TMEM_OP_SAVE_BEGIN             10
    745 #define XEN_SYSCTL_TMEM_OP_SET_AUTH               11
    746 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_PAGE     19
    747 #define XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_INV      20
    748 #define XEN_SYSCTL_TMEM_OP_SAVE_END               21
    749 #define XEN_SYSCTL_TMEM_OP_RESTORE_BEGIN          30
    750 #define XEN_SYSCTL_TMEM_OP_RESTORE_PUT_PAGE       32
    751 #define XEN_SYSCTL_TMEM_OP_RESTORE_FLUSH_PAGE     33
    752 
    753 /*
    754  * XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_[PAGE|INV] override the 'buf' in
    755  * xen_sysctl_tmem_op with this structure - sometimes with an extra
    756  * page tackled on.
    757  */
    758 struct tmem_handle {
    759     uint32_t pool_id;
    760     uint32_t index;
    761     xen_tmem_oid_t oid;
    762 };
    763 
    764 /*
    765  * XEN_SYSCTL_TMEM_OP_[GET,SAVE]_CLIENT uses the 'client' in
    766  * xen_tmem_op with this structure, which is mostly used during migration.
    767  */
    768 struct xen_tmem_client {
    769     uint32_t version;   /* If mismatched we will get XEN_EOPNOTSUPP. */
    770     uint32_t maxpools;  /* If greater than what hypervisor supports, will get
    771                            XEN_ERANGE. */
    772     uint32_t nr_pools;  /* Current amount of pools. Ignored on SET*/
    773     union {             /* See TMEM_CLIENT_[COMPRESS,FROZEN] */
    774         uint32_t raw;
    775         struct {
    776             uint8_t frozen:1,
    777                     compress:1,
    778                     migrating:1;
    779         } u;
    780     } flags;
    781     uint32_t weight;
    782 };
    783 typedef struct xen_tmem_client xen_tmem_client_t;
    784 DEFINE_XEN_GUEST_HANDLE(xen_tmem_client_t);
    785 
    786 /*
    787  * XEN_SYSCTL_TMEM_OP_[GET|SET]_POOLS or XEN_SYSCTL_TMEM_OP_SET_AUTH
    788  * uses the 'pool' array in * xen_sysctl_tmem_op with this structure.
    789  * The XEN_SYSCTL_TMEM_OP_GET_POOLS hypercall will
    790  * return the number of entries in 'pool' or a negative value
    791  * if an error was encountered.
    792  * The XEN_SYSCTL_TMEM_OP_SET_[AUTH|POOLS] will return the number of
    793  * entries in 'pool' processed or a negative value if an error
    794  * was encountered.
    795  */
    796 struct xen_tmem_pool_info {
    797     union {
    798         uint32_t raw;
    799         struct {
    800             uint32_t persist:1,    /* See TMEM_POOL_PERSIST. */
    801                      shared:1,     /* See TMEM_POOL_SHARED. */
    802                      auth:1,       /* See TMEM_POOL_AUTH. */
    803                      rsv1:1,
    804                      pagebits:8,   /* TMEM_POOL_PAGESIZE_[SHIFT,MASK]. */
    805                      rsv2:12,
    806                      version:8;    /* TMEM_POOL_VERSION_[SHIFT,MASK]. */
    807         } u;
    808     } flags;
    809     uint32_t id;                  /* Less than tmem_client.maxpools. */
    810     uint64_t n_pages;             /* Zero on XEN_SYSCTL_TMEM_OP_SET_[AUTH|POOLS]. */
    811     uint64_aligned_t uuid[2];
    812 };
    813 typedef struct xen_tmem_pool_info xen_tmem_pool_info_t;
    814 DEFINE_XEN_GUEST_HANDLE(xen_tmem_pool_info_t);
    815 
    816 struct xen_sysctl_tmem_op {
    817     uint32_t cmd;       /* IN: XEN_SYSCTL_TMEM_OP_* . */
    818     int32_t pool_id;    /* IN: 0 by default unless _SAVE_*, RESTORE_* .*/
    819     uint32_t cli_id;    /* IN: client id, 0 for XEN_SYSCTL_TMEM_QUERY_FREEABLE_MB
    820                            for all others can be the domain id or
    821                            XEN_SYSCTL_TMEM_OP_ALL_CLIENTS for all. */
    822     uint32_t len;       /* IN: length of 'buf'. If not applicable to use 0. */
    823     uint32_t arg;       /* IN: If not applicable to command use 0. */
    824     uint32_t pad;       /* Padding so structure is the same under 32 and 64. */
    825     xen_tmem_oid_t oid; /* IN: If not applicable to command use 0s. */
    826     union {
    827         XEN_GUEST_HANDLE_64(char) buf; /* IN/OUT: Buffer to save/restore */
    828         XEN_GUEST_HANDLE_64(xen_tmem_client_t) client; /* IN/OUT for */
    829                         /*  XEN_SYSCTL_TMEM_OP_[GET,SAVE]_CLIENT. */
    830         XEN_GUEST_HANDLE_64(xen_tmem_pool_info_t) pool; /* OUT for */
    831                         /* XEN_SYSCTL_TMEM_OP_GET_POOLS. Must have 'len' */
    832                         /* of them. */
    833     } u;
    834 };
    835 
    836 /*
    837  * XEN_SYSCTL_get_cpu_levelling_caps (x86 specific)
    838  *
    839  * Return hardware capabilities concerning masking or faulting of the cpuid
    840  * instruction for PV guests.
    841  */
    842 struct xen_sysctl_cpu_levelling_caps {
    843 #define XEN_SYSCTL_CPU_LEVELCAP_faulting    (1ul <<  0) /* CPUID faulting    */
    844 #define XEN_SYSCTL_CPU_LEVELCAP_ecx         (1ul <<  1) /* 0x00000001.ecx    */
    845 #define XEN_SYSCTL_CPU_LEVELCAP_edx         (1ul <<  2) /* 0x00000001.edx    */
    846 #define XEN_SYSCTL_CPU_LEVELCAP_extd_ecx    (1ul <<  3) /* 0x80000001.ecx    */
    847 #define XEN_SYSCTL_CPU_LEVELCAP_extd_edx    (1ul <<  4) /* 0x80000001.edx    */
    848 #define XEN_SYSCTL_CPU_LEVELCAP_xsave_eax   (1ul <<  5) /* 0x0000000D:1.eax  */
    849 #define XEN_SYSCTL_CPU_LEVELCAP_thermal_ecx (1ul <<  6) /* 0x00000006.ecx    */
    850 #define XEN_SYSCTL_CPU_LEVELCAP_l7s0_eax    (1ul <<  7) /* 0x00000007:0.eax  */
    851 #define XEN_SYSCTL_CPU_LEVELCAP_l7s0_ebx    (1ul <<  8) /* 0x00000007:0.ebx  */
    852     uint32_t caps;
    853 };
    854 
    855 /*
    856  * XEN_SYSCTL_get_cpu_featureset (x86 specific)
    857  *
    858  * Return information about featuresets available on this host.
    859  *  -  Raw: The real cpuid values.
    860  *  - Host: The values Xen is using, (after command line overrides, etc).
    861  *  -   PV: Maximum set of features which can be given to a PV guest.
    862  *  -  HVM: Maximum set of features which can be given to a HVM guest.
    863  */
    864 struct xen_sysctl_cpu_featureset {
    865 #define XEN_SYSCTL_cpu_featureset_raw      0
    866 #define XEN_SYSCTL_cpu_featureset_host     1
    867 #define XEN_SYSCTL_cpu_featureset_pv       2
    868 #define XEN_SYSCTL_cpu_featureset_hvm      3
    869     uint32_t index;       /* IN: Which featureset to query? */
    870     uint32_t nr_features; /* IN/OUT: Number of entries in/written to
    871                            * 'features', or the maximum number of features if
    872                            * the guest handle is NULL.  NB. All featuresets
    873                            * come from the same numberspace, so have the same
    874                            * maximum length. */
    875     XEN_GUEST_HANDLE_64(uint32) features; /* OUT: */
    876 };
    877 
    878 /*
    879  * XEN_SYSCTL_LIVEPATCH_op
    880  *
    881  * Refer to the docs/unstable/misc/livepatch.markdown
    882  * for the design details of this hypercall.
    883  *
    884  * There are four sub-ops:
    885  *  XEN_SYSCTL_LIVEPATCH_UPLOAD (0)
    886  *  XEN_SYSCTL_LIVEPATCH_GET (1)
    887  *  XEN_SYSCTL_LIVEPATCH_LIST (2)
    888  *  XEN_SYSCTL_LIVEPATCH_ACTION (3)
    889  *
    890  * The normal sequence of sub-ops is to:
    891  *  1) XEN_SYSCTL_LIVEPATCH_UPLOAD to upload the payload. If errors STOP.
    892  *  2) XEN_SYSCTL_LIVEPATCH_GET to check the `->rc`. If -XEN_EAGAIN spin.
    893  *     If zero go to next step.
    894  *  3) XEN_SYSCTL_LIVEPATCH_ACTION with LIVEPATCH_ACTION_APPLY to apply the patch.
    895  *  4) XEN_SYSCTL_LIVEPATCH_GET to check the `->rc`. If in -XEN_EAGAIN spin.
    896  *     If zero exit with success.
    897  */
    898 
    899 #define LIVEPATCH_PAYLOAD_VERSION 1
    900 /*
    901  * .livepatch.funcs structure layout defined in the `Payload format`
    902  * section in the Live Patch design document.
    903  *
    904  * We guard this with __XEN__ as toolstacks SHOULD not use it.
    905  */
    906 #ifdef __XEN__
    907 struct livepatch_func {
    908     const char *name;       /* Name of function to be patched. */
    909     void *new_addr;
    910     void *old_addr;
    911     uint32_t new_size;
    912     uint32_t old_size;
    913     uint8_t version;        /* MUST be LIVEPATCH_PAYLOAD_VERSION. */
    914     uint8_t opaque[31];
    915 };
    916 typedef struct livepatch_func livepatch_func_t;
    917 #endif
    918 
    919 /*
    920  * Structure describing an ELF payload. Uniquely identifies the
    921  * payload. Should be human readable.
    922  * Recommended length is upto XEN_LIVEPATCH_NAME_SIZE.
    923  * Includes the NUL terminator.
    924  */
    925 #define XEN_LIVEPATCH_NAME_SIZE 128
    926 struct xen_livepatch_name {
    927     XEN_GUEST_HANDLE_64(char) name;         /* IN: pointer to name. */
    928     uint16_t size;                          /* IN: size of name. May be upto
    929                                                XEN_LIVEPATCH_NAME_SIZE. */
    930     uint16_t pad[3];                        /* IN: MUST be zero. */
    931 };
    932 
    933 /*
    934  * Upload a payload to the hypervisor. The payload is verified
    935  * against basic checks and if there are any issues the proper return code
    936  * will be returned. The payload is not applied at this time - that is
    937  * controlled by XEN_SYSCTL_LIVEPATCH_ACTION.
    938  *
    939  * The return value is zero if the payload was succesfully uploaded.
    940  * Otherwise an EXX return value is provided. Duplicate `name` are not
    941  * supported.
    942  *
    943  * The payload at this point is verified against basic checks.
    944  *
    945  * The `payload` is the ELF payload as mentioned in the `Payload format`
    946  * section in the Live Patch design document.
    947  */
    948 #define XEN_SYSCTL_LIVEPATCH_UPLOAD 0
    949 struct xen_sysctl_livepatch_upload {
    950     struct xen_livepatch_name name;         /* IN, name of the patch. */
    951     uint64_t size;                          /* IN, size of the ELF file. */
    952     XEN_GUEST_HANDLE_64(uint8) payload;     /* IN, the ELF file. */
    953 };
    954 
    955 /*
    956  * Retrieve an status of an specific payload.
    957  *
    958  * Upon completion the `struct xen_livepatch_status` is updated.
    959  *
    960  * The return value is zero on success and XEN_EXX on failure. This operation
    961  * is synchronous and does not require preemption.
    962  */
    963 #define XEN_SYSCTL_LIVEPATCH_GET 1
    964 
    965 struct xen_livepatch_status {
    966 #define LIVEPATCH_STATE_CHECKED      1
    967 #define LIVEPATCH_STATE_APPLIED      2
    968     uint32_t state;                /* OUT: LIVEPATCH_STATE_*. */
    969     int32_t rc;                    /* OUT: 0 if no error, otherwise -XEN_EXX. */
    970 };
    971 typedef struct xen_livepatch_status xen_livepatch_status_t;
    972 DEFINE_XEN_GUEST_HANDLE(xen_livepatch_status_t);
    973 
    974 struct xen_sysctl_livepatch_get {
    975     struct xen_livepatch_name name;         /* IN, name of the payload. */
    976     struct xen_livepatch_status status;     /* IN/OUT, state of it. */
    977 };
    978 
    979 /*
    980  * Retrieve an array of abbreviated status and names of payloads that are
    981  * loaded in the hypervisor.
    982  *
    983  * If the hypercall returns an positive number, it is the number (up to `nr`)
    984  * of the payloads returned, along with `nr` updated with the number of remaining
    985  * payloads, `version` updated (it may be the same across hypercalls. If it
    986  * varies the data is stale and further calls could fail). The `status`,
    987  * `name`, and `len`' are updated at their designed index value (`idx`) with
    988  * the returned value of data.
    989  *
    990  * If the hypercall returns E2BIG the `nr` is too big and should be
    991  * lowered. The upper limit of `nr` is left to the implemention.
    992  *
    993  * Note that due to the asynchronous nature of hypercalls the domain might have
    994  * added or removed the number of payloads making this information stale. It is
    995  * the responsibility of the toolstack to use the `version` field to check
    996  * between each invocation. if the version differs it should discard the stale
    997  * data and start from scratch. It is OK for the toolstack to use the new
    998  * `version` field.
    999  */
   1000 #define XEN_SYSCTL_LIVEPATCH_LIST 2
   1001 struct xen_sysctl_livepatch_list {
   1002     uint32_t version;                       /* OUT: Hypervisor stamps value.
   1003                                                If varies between calls, we are
   1004                                              * getting stale data. */
   1005     uint32_t idx;                           /* IN: Index into hypervisor list. */
   1006     uint32_t nr;                            /* IN: How many status, name, and len
   1007                                                should fill out. Can be zero to get
   1008                                                amount of payloads and version.
   1009                                                OUT: How many payloads left. */
   1010     uint32_t pad;                           /* IN: Must be zero. */
   1011     XEN_GUEST_HANDLE_64(xen_livepatch_status_t) status;  /* OUT. Must have enough
   1012                                                space allocate for nr of them. */
   1013     XEN_GUEST_HANDLE_64(char) name;         /* OUT: Array of names. Each member
   1014                                                MUST XEN_LIVEPATCH_NAME_SIZE in size.
   1015                                                Must have nr of them. */
   1016     XEN_GUEST_HANDLE_64(uint32) len;        /* OUT: Array of lengths of name's.
   1017                                                Must have nr of them. */
   1018 };
   1019 
   1020 /*
   1021  * Perform an operation on the payload structure referenced by the `name` field.
   1022  * The operation request is asynchronous and the status should be retrieved
   1023  * by using either XEN_SYSCTL_LIVEPATCH_GET or XEN_SYSCTL_LIVEPATCH_LIST hypercall.
   1024  */
   1025 #define XEN_SYSCTL_LIVEPATCH_ACTION 3
   1026 struct xen_sysctl_livepatch_action {
   1027     struct xen_livepatch_name name;         /* IN, name of the patch. */
   1028 #define LIVEPATCH_ACTION_UNLOAD       1
   1029 #define LIVEPATCH_ACTION_REVERT       2
   1030 #define LIVEPATCH_ACTION_APPLY        3
   1031 #define LIVEPATCH_ACTION_REPLACE      4
   1032     uint32_t cmd;                           /* IN: LIVEPATCH_ACTION_*. */
   1033     uint32_t timeout;                       /* IN: If zero then uses */
   1034                                             /* hypervisor default. */
   1035                                             /* Or upper bound of time (ns) */
   1036                                             /* for operation to take. */
   1037 };
   1038 
   1039 struct xen_sysctl_livepatch_op {
   1040     uint32_t cmd;                           /* IN: XEN_SYSCTL_LIVEPATCH_*. */
   1041     uint32_t pad;                           /* IN: Always zero. */
   1042     union {
   1043         struct xen_sysctl_livepatch_upload upload;
   1044         struct xen_sysctl_livepatch_list list;
   1045         struct xen_sysctl_livepatch_get get;
   1046         struct xen_sysctl_livepatch_action action;
   1047     } u;
   1048 };
   1049 
   1050 /*
   1051  * XEN_SYSCTL_set_parameter
   1052  *
   1053  * Change hypervisor parameters at runtime.
   1054  * The input string is parsed similar to the boot parameters.
   1055  * Parameters are a single string terminated by a NUL byte of max. size
   1056  * characters. Multiple settings can be specified by separating them
   1057  * with blanks.
   1058  */
   1059 
   1060 struct xen_sysctl_set_parameter {
   1061     XEN_GUEST_HANDLE_64(char) params;       /* IN: pointer to parameters. */
   1062     uint16_t size;                          /* IN: size of parameters. */
   1063     uint16_t pad[3];                        /* IN: MUST be zero. */
   1064 };
   1065 
   1066 struct xen_sysctl {
   1067     uint32_t cmd;
   1068 #define XEN_SYSCTL_readconsole                    1
   1069 #define XEN_SYSCTL_tbuf_op                        2
   1070 #define XEN_SYSCTL_physinfo                       3
   1071 #define XEN_SYSCTL_sched_id                       4
   1072 #define XEN_SYSCTL_perfc_op                       5
   1073 #define XEN_SYSCTL_getdomaininfolist              6
   1074 #define XEN_SYSCTL_debug_keys                     7
   1075 #define XEN_SYSCTL_getcpuinfo                     8
   1076 #define XEN_SYSCTL_availheap                      9
   1077 #define XEN_SYSCTL_get_pmstat                    10
   1078 #define XEN_SYSCTL_cpu_hotplug                   11
   1079 #define XEN_SYSCTL_pm_op                         12
   1080 #define XEN_SYSCTL_page_offline_op               14
   1081 #define XEN_SYSCTL_lockprof_op                   15
   1082 #define XEN_SYSCTL_cputopoinfo                   16
   1083 #define XEN_SYSCTL_numainfo                      17
   1084 #define XEN_SYSCTL_cpupool_op                    18
   1085 #define XEN_SYSCTL_scheduler_op                  19
   1086 #define XEN_SYSCTL_coverage_op                   20
   1087 #define XEN_SYSCTL_psr_cmt_op                    21
   1088 #define XEN_SYSCTL_pcitopoinfo                   22
   1089 #define XEN_SYSCTL_psr_alloc                     23
   1090 #define XEN_SYSCTL_tmem_op                       24
   1091 #define XEN_SYSCTL_get_cpu_levelling_caps        25
   1092 #define XEN_SYSCTL_get_cpu_featureset            26
   1093 #define XEN_SYSCTL_livepatch_op                  27
   1094 #define XEN_SYSCTL_set_parameter                 28
   1095     uint32_t interface_version; /* XEN_SYSCTL_INTERFACE_VERSION */
   1096     union {
   1097         struct xen_sysctl_readconsole       readconsole;
   1098         struct xen_sysctl_tbuf_op           tbuf_op;
   1099         struct xen_sysctl_physinfo          physinfo;
   1100         struct xen_sysctl_cputopoinfo       cputopoinfo;
   1101         struct xen_sysctl_pcitopoinfo       pcitopoinfo;
   1102         struct xen_sysctl_numainfo          numainfo;
   1103         struct xen_sysctl_sched_id          sched_id;
   1104         struct xen_sysctl_perfc_op          perfc_op;
   1105         struct xen_sysctl_getdomaininfolist getdomaininfolist;
   1106         struct xen_sysctl_debug_keys        debug_keys;
   1107         struct xen_sysctl_getcpuinfo        getcpuinfo;
   1108         struct xen_sysctl_availheap         availheap;
   1109         struct xen_sysctl_get_pmstat        get_pmstat;
   1110         struct xen_sysctl_cpu_hotplug       cpu_hotplug;
   1111         struct xen_sysctl_pm_op             pm_op;
   1112         struct xen_sysctl_page_offline_op   page_offline;
   1113         struct xen_sysctl_lockprof_op       lockprof_op;
   1114         struct xen_sysctl_cpupool_op        cpupool_op;
   1115         struct xen_sysctl_scheduler_op      scheduler_op;
   1116         struct xen_sysctl_coverage_op       coverage_op;
   1117         struct xen_sysctl_psr_cmt_op        psr_cmt_op;
   1118         struct xen_sysctl_psr_alloc         psr_alloc;
   1119         struct xen_sysctl_tmem_op           tmem_op;
   1120         struct xen_sysctl_cpu_levelling_caps cpu_levelling_caps;
   1121         struct xen_sysctl_cpu_featureset    cpu_featureset;
   1122         struct xen_sysctl_livepatch_op      livepatch;
   1123         struct xen_sysctl_set_parameter     set_parameter;
   1124         uint8_t                             pad[128];
   1125     } u;
   1126 };
   1127 typedef struct xen_sysctl xen_sysctl_t;
   1128 DEFINE_XEN_GUEST_HANDLE(xen_sysctl_t);
   1129 
   1130 #endif /* __XEN_PUBLIC_SYSCTL_H__ */
   1131 
   1132 /*
   1133  * Local variables:
   1134  * mode: C
   1135  * c-file-style: "BSD"
   1136  * c-basic-offset: 4
   1137  * tab-width: 4
   1138  * indent-tabs-mode: nil
   1139  * End:
   1140  */
   1141