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 */
Cache object: ef0a3ee748061747af62cac8b917eda2
|