[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Xen-devel] [RFC PATCH v4 2/9] xen/arm: implement HYPERVISOR_sysctl



I'll do this in the next patch-set.

Oleksandr Dmytryshyn | Product Engineering and Development
GlobalLogic
M +38.067.382.2525
www.globallogic.com

http://www.globallogic.com/email_disclaimer.txt


On Thu, Nov 6, 2014 at 5:29 PM, Stefano Stabellini
<stefano.stabellini@xxxxxxxxxxxxx> wrote:
> On Thu, 6 Nov 2014, Oleksandr Dmytryshyn wrote:
>> On Thu, Nov 6, 2014 at 5:16 PM, Stefano Stabellini
>> <stefano.stabellini@xxxxxxxxxxxxx> wrote:
>> > On Thu, 6 Nov 2014, Oleksandr Dmytryshyn wrote:
>> >> On Tue, Nov 4, 2014 at 6:17 PM, Stefano Stabellini
>> >> <stefano.stabellini@xxxxxxxxxxxxx> wrote:
>> >> > On Tue, 4 Nov 2014, Oleksandr Dmytryshyn wrote:
>> >> >> Signed-off-by: Oleksandr Dmytryshyn 
>> >> >> <oleksandr.dmytryshyn@xxxxxxxxxxxxxxx>
>> >> >
>> >> > Why?
>> >> I'll add authors Signed-off-by before my Signed-off-by in the next 
>> >> patch-set.
>> >
>> > Sorry, I meant why are you introducing HYPERVISOR_sysctl?
>> I use it to get real physical CPUs counter.
>> Also I'll implement a new sysctl operation: XEN_SYSCTL_cpufreq_op
>> Kernel will use this op to start/stop cpufreq notification
>> events sending.
>
> Please add the exaplanation to the commit message. Also don't add
> structs and definitions that you don't need, such as
> xen_sysctl_readconsole and XEN_SYSCTL_SCHEDOP_putinfo.
>
>
>> >> >>  arch/arm/include/asm/xen/hypercall.h |   1 +
>> >> >>  arch/arm/include/asm/xen/interface.h |   2 +
>> >> >>  arch/arm/xen/enlighten.c             |   1 +
>> >> >>  arch/arm/xen/hypercall.S             |   1 +
>> >> >>  include/xen/interface/sysctl.h       | 646 
>> >> >> +++++++++++++++++++++++++++++++++++
>> >> >>  include/xen/interface/xen.h          |   6 +
>> >> >>  6 files changed, 657 insertions(+)
>> >> >>  create mode 100644 include/xen/interface/sysctl.h
>> >> >>
>> >> >> diff --git a/arch/arm/include/asm/xen/hypercall.h 
>> >> >> b/arch/arm/include/asm/xen/hypercall.h
>> >> >> index c817c56..751869eb 100644
>> >> >> --- a/arch/arm/include/asm/xen/hypercall.h
>> >> >> +++ b/arch/arm/include/asm/xen/hypercall.h
>> >> >> @@ -48,6 +48,7 @@ int HYPERVISOR_memory_op(unsigned int cmd, void 
>> >> >> *arg);
>> >> >>  int HYPERVISOR_physdev_op(int cmd, void *arg);
>> >> >>  int HYPERVISOR_vcpu_op(int cmd, int vcpuid, void *extra_args);
>> >> >>  int HYPERVISOR_tmem_op(void *arg);
>> >> >> +int HYPERVISOR_sysctl(void *arg);
>> >> >>
>> >> >>  static inline void
>> >> >>  MULTI_update_va_mapping(struct multicall_entry *mcl, unsigned long va,
>> >> >> diff --git a/arch/arm/include/asm/xen/interface.h 
>> >> >> b/arch/arm/include/asm/xen/interface.h
>> >> >> index 1151188..acf4b7a 100644
>> >> >> --- a/arch/arm/include/asm/xen/interface.h
>> >> >> +++ b/arch/arm/include/asm/xen/interface.h
>> >> >> @@ -19,6 +19,7 @@
>> >> >>       __DEFINE_GUEST_HANDLE(name, struct name)
>> >> >>  #define DEFINE_GUEST_HANDLE(name) __DEFINE_GUEST_HANDLE(name, name)
>> >> >>  #define GUEST_HANDLE(name)        __guest_handle_ ## name
>> >> >> +#define GUEST_HANDLE_64(name)     GUEST_HANDLE(name)
>> >> >>
>> >> >>  #define set_xen_guest_handle(hnd, val)                       \
>> >> >>       do {                                            \
>> >> >> @@ -48,6 +49,7 @@ DEFINE_GUEST_HANDLE(int);
>> >> >>  DEFINE_GUEST_HANDLE(void);
>> >> >>  DEFINE_GUEST_HANDLE(uint64_t);
>> >> >>  DEFINE_GUEST_HANDLE(uint32_t);
>> >> >> +DEFINE_GUEST_HANDLE(uint8_t);
>> >> >>  DEFINE_GUEST_HANDLE(xen_pfn_t);
>> >> >>  DEFINE_GUEST_HANDLE(xen_ulong_t);
>> >> >>
>> >> >> diff --git a/arch/arm/xen/enlighten.c b/arch/arm/xen/enlighten.c
>> >> >> index eb0d851..675f17a 100644
>> >> >> --- a/arch/arm/xen/enlighten.c
>> >> >> +++ b/arch/arm/xen/enlighten.c
>> >> >> @@ -350,4 +350,5 @@ EXPORT_SYMBOL_GPL(HYPERVISOR_memory_op);
>> >> >>  EXPORT_SYMBOL_GPL(HYPERVISOR_physdev_op);
>> >> >>  EXPORT_SYMBOL_GPL(HYPERVISOR_vcpu_op);
>> >> >>  EXPORT_SYMBOL_GPL(HYPERVISOR_tmem_op);
>> >> >> +EXPORT_SYMBOL_GPL(HYPERVISOR_sysctl);
>> >> >>  EXPORT_SYMBOL_GPL(privcmd_call);
>> >> >> diff --git a/arch/arm/xen/hypercall.S b/arch/arm/xen/hypercall.S
>> >> >> index d1cf7b7..a1276df 100644
>> >> >> --- a/arch/arm/xen/hypercall.S
>> >> >> +++ b/arch/arm/xen/hypercall.S
>> >> >> @@ -89,6 +89,7 @@ HYPERCALL2(memory_op);
>> >> >>  HYPERCALL2(physdev_op);
>> >> >>  HYPERCALL3(vcpu_op);
>> >> >>  HYPERCALL1(tmem_op);
>> >> >> +HYPERCALL1(sysctl);
>> >> >>
>> >> >>  ENTRY(privcmd_call)
>> >> >>       stmdb sp!, {r4}
>> >> >> diff --git a/include/xen/interface/sysctl.h 
>> >> >> b/include/xen/interface/sysctl.h
>> >> >> new file mode 100644
>> >> >> index 0000000..1a8cf7a
>> >> >> --- /dev/null
>> >> >> +++ b/include/xen/interface/sysctl.h
>> >> >> @@ -0,0 +1,646 @@
>> >> >> +/******************************************************************************
>> >> >> + * sysctl.h
>> >> >> + *
>> >> >> + * System management operations. For use by node control stack.
>> >> >> + *
>> >> >> + * Reused from xen: xen/include/public/sysctl.h
>> >> >> + *
>> >> >> + * Permission is hereby granted, free of charge, to any person 
>> >> >> obtaining a copy
>> >> >> + * of this software and associated documentation files (the 
>> >> >> "Software"), to
>> >> >> + * deal in the Software without restriction, including without 
>> >> >> limitation the
>> >> >> + * rights to use, copy, modify, merge, publish, distribute, 
>> >> >> sublicense, and/or
>> >> >> + * sell copies of the Software, and to permit persons to whom the 
>> >> >> Software is
>> >> >> + * furnished to do so, subject to the following conditions:
>> >> >> + *
>> >> >> + * The above copyright notice and this permission notice shall be 
>> >> >> included in
>> >> >> + * all copies or substantial portions of the Software.
>> >> >> + *
>> >> >> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
>> >> >> EXPRESS OR
>> >> >> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
>> >> >> MERCHANTABILITY,
>> >> >> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 
>> >> >> SHALL THE
>> >> >> + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 
>> >> >> OTHER
>> >> >> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
>> >> >> ARISING
>> >> >> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> >> >> + * DEALINGS IN THE SOFTWARE.
>> >> >> + *
>> >> >> + * Copyright (c) 2002-2006, K Fraser
>> >> >> + * Copyright (c) 2014, GlobalLogic Inc.
>> >> >> + */
>> >> >> +
>> >> >> +#ifndef __XEN_PUBLIC_SYSCTL_H__
>> >> >> +#define __XEN_PUBLIC_SYSCTL_H__
>> >> >> +
>> >> >> +#include <xen/interface/xen.h>
>> >> >> +
>> >> >> +#define XEN_SYSCTL_INTERFACE_VERSION 0x0000000A
>> >> >> +
>> >> >> +/*
>> >> >> + * Read console content from Xen buffer ring.
>> >> >> + */
>> >> >> +/* XEN_SYSCTL_readconsole */
>> >> >> +struct xen_sysctl_readconsole {
>> >> >> +     /* IN: Non-zero -> clear after reading. */
>> >> >> +     uint8_t clear;
>> >> >> +     /* IN: Non-zero -> start index specified by @index field. */
>> >> >> +     uint8_t incremental;
>> >> >> +     uint8_t pad0, pad1;
>> >> >> +     /*
>> >> >> +     * IN:  Start index for consuming from ring buffer (if 
>> >> >> @incremental);
>> >> >> +     * OUT: End index after consuming from ring buffer.
>> >> >> +     */
>> >> >> +     uint32_t index;
>> >> >> +     /* IN: Virtual address to write console data. */
>> >> >> +     GUEST_HANDLE_64(char) buffer;
>> >> >> +     /* IN: Size of buffer; OUT: Bytes written to buffer. */
>> >> >> +     uint32_t count;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_readconsole);
>> >> >> +
>> >> >> +/* Get trace buffers machine base address */
>> >> >> +/* XEN_SYSCTL_tbuf_op */
>> >> >> +struct xen_sysctl_tbuf_op {
>> >> >> +    /* IN variables */
>> >> >> +#define XEN_SYSCTL_TBUFOP_get_info     0
>> >> >> +#define XEN_SYSCTL_TBUFOP_set_cpu_mask 1
>> >> >> +#define XEN_SYSCTL_TBUFOP_set_evt_mask 2
>> >> >> +#define XEN_SYSCTL_TBUFOP_set_size     3
>> >> >> +#define XEN_SYSCTL_TBUFOP_enable       4
>> >> >> +#define XEN_SYSCTL_TBUFOP_disable      5
>> >> >> +     uint32_t cmd;
>> >> >> +     /* IN/OUT variables */
>> >> >> +     struct xenctl_bitmap cpu_mask;
>> >> >> +     uint32_t             evt_mask;
>> >> >> +     /* OUT variables */
>> >> >> +     uint64_aligned_t buffer_mfn;
>> >> >> +     uint32_t size;  /* Also an IN variable! */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_tbuf_op);
>> >> >> +
>> >> >> +/*
>> >> >> + * Get physical information about the host machine
>> >> >> + */
>> >> >> +/* XEN_SYSCTL_physinfo */
>> >> >> + /* (x86) The platform supports HVM guests. */
>> >> >> +#define _XEN_SYSCTL_PHYSCAP_hvm          0
>> >> >> +#define XEN_SYSCTL_PHYSCAP_hvm           (1u<<_XEN_SYSCTL_PHYSCAP_hvm)
>> >> >> + /* (x86) The platform supports HVM-guest direct access to I/O 
>> >> >> devices. */
>> >> >> +#define _XEN_SYSCTL_PHYSCAP_hvm_directio 1
>> >> >> +#define XEN_SYSCTL_PHYSCAP_hvm_directio  
>> >> >> (1u<<_XEN_SYSCTL_PHYSCAP_hvm_directio)
>> >> >> +struct xen_sysctl_physinfo {
>> >> >> +     uint32_t threads_per_core;
>> >> >> +     uint32_t cores_per_socket;
>> >> >> +     uint32_t nr_cpus;     /* # CPUs currently online */
>> >> >> +     uint32_t max_cpu_id;  /* Largest possible CPU ID on this host */
>> >> >> +     uint32_t nr_nodes;    /* # nodes currently online */
>> >> >> +     uint32_t max_node_id; /* Largest possible node ID on this host */
>> >> >> +     uint32_t cpu_khz;
>> >> >> +     uint64_aligned_t total_pages;
>> >> >> +     uint64_aligned_t free_pages;
>> >> >> +     uint64_aligned_t scrub_pages;
>> >> >> +     uint64_aligned_t outstanding_pages;
>> >> >> +     uint32_t hw_cap[8];
>> >> >> +
>> >> >> +     /* XEN_SYSCTL_PHYSCAP_??? */
>> >> >> +     uint32_t capabilities;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_physinfo);
>> >> >> +
>> >> >> +/*
>> >> >> + * Get the ID of the current scheduler.
>> >> >> + */
>> >> >> +/* XEN_SYSCTL_sched_id */
>> >> >> +struct xen_sysctl_sched_id {
>> >> >> +     /* OUT variable */
>> >> >> +     uint32_t sched_id;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_sched_id);
>> >> >> +
>> >> >> +/* Interface for controlling Xen software performance counters. */
>> >> >> +/* XEN_SYSCTL_perfc_op */
>> >> >> +/* Sub-operations: */
>> >> >> +#define XEN_SYSCTL_PERFCOP_reset 1   /* Reset all counters to zero. */
>> >> >> +#define XEN_SYSCTL_PERFCOP_query 2   /* Get perfctr information. */
>> >> >> +struct xen_sysctl_perfc_desc {
>> >> >> +     char         name[80];           /* name of perf counter */
>> >> >> +     uint32_t     nr_vals;            /* number of values for this 
>> >> >> counter */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_perfc_desc);
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_perfc_val);
>> >> >> +
>> >> >> +struct xen_sysctl_perfc_op {
>> >> >> +     /* IN variables. */
>> >> >> +     uint32_t       cmd;                /*  XEN_SYSCTL_PERFCOP_??? */
>> >> >> +     /* OUT variables. */
>> >> >> +     uint32_t       nr_counters;       /*  number of counters 
>> >> >> description  */
>> >> >> +     uint32_t       nr_vals;           /*  number of values  */
>> >> >> +     /* counter information (or NULL) */
>> >> >> +     GUEST_HANDLE_64(xen_sysctl_perfc_desc) desc;
>> >> >> +     /* counter values (or NULL) */
>> >> >> +     GUEST_HANDLE_64(xen_sysctl_perfc_val) val;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_perfc_op);
>> >> >> +
>> >> >> +/* Inject debug keys into Xen. */
>> >> >> +/* XEN_SYSCTL_debug_keys */
>> >> >> +struct xen_sysctl_debug_keys {
>> >> >> +     /* IN variables. */
>> >> >> +     GUEST_HANDLE_64(char) keys;
>> >> >> +     uint32_t nr_keys;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_debug_keys);
>> >> >> +
>> >> >> +/* Get physical CPU information. */
>> >> >> +/* XEN_SYSCTL_getcpuinfo */
>> >> >> +struct xen_sysctl_cpuinfo {
>> >> >> +     uint64_aligned_t idletime;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_cpuinfo);
>> >> >> +struct xen_sysctl_getcpuinfo {
>> >> >> +     /* IN variables. */
>> >> >> +     uint32_t max_cpus;
>> >> >> +     GUEST_HANDLE_64(xen_sysctl_cpuinfo) info;
>> >> >> +     /* OUT variables. */
>> >> >> +     uint32_t nr_cpus;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_getcpuinfo);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_availheap */
>> >> >> +struct xen_sysctl_availheap {
>> >> >> +     /* IN variables. */
>> >> >> +     uint32_t min_bitwidth; /* Smallest address width (zero if don't 
>> >> >> care) */
>> >> >> +     uint32_t max_bitwidth; /* Largest address width (zero if don't 
>> >> >> care)  */
>> >> >> +     int32_t  node;         /* NUMA node of interest (-1 for all 
>> >> >> nodes)   */
>> >> >> +     /* OUT variables. */
>> >> >> +     uint64_aligned_t avail_bytes;/* Bytes available in the specified 
>> >> >> region */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_availheap);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_get_pmstat */
>> >> >> +struct pm_px_val {
>> >> >> +     uint64_aligned_t freq;        /* Px core frequency */
>> >> >> +     uint64_aligned_t residency;   /* Px residency time */
>> >> >> +     uint64_aligned_t count;       /* Px transition count */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(pm_px_val);
>> >> >> +
>> >> >> +struct pm_px_stat {
>> >> >> +     uint8_t total;        /* total Px states */
>> >> >> +     uint8_t usable;       /* usable Px states */
>> >> >> +     uint8_t last;         /* last Px state */
>> >> >> +     uint8_t cur;          /* current Px state */
>> >> >> +     GUEST_HANDLE_64(uint64_t) trans_pt;   /* Px transition table */
>> >> >> +     GUEST_HANDLE_64(pm_px_val) pt;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(pm_px_stat);
>> >> >> +
>> >> >> +struct pm_cx_stat {
>> >> >> +     uint32_t nr;    /* entry nr in triggers & residencies, including 
>> >> >> C0 */
>> >> >> +     uint32_t last;  /* last Cx state */
>> >> >> +     uint64_aligned_t idle_time;                 /* idle time from 
>> >> >> boot */
>> >> >> +     GUEST_HANDLE_64(uint64_t) triggers;    /* Cx trigger counts */
>> >> >> +     GUEST_HANDLE_64(uint64_t) residencies; /* Cx residencies */
>> >> >> +     uint64_aligned_t pc2;
>> >> >> +     uint64_aligned_t pc3;
>> >> >> +     uint64_aligned_t pc6;
>> >> >> +     uint64_aligned_t pc7;
>> >> >> +     uint64_aligned_t cc3;
>> >> >> +     uint64_aligned_t cc6;
>> >> >> +     uint64_aligned_t cc7;
>> >> >> +};
>> >> >> +
>> >> >> +struct xen_sysctl_get_pmstat {
>> >> >> +#define PMSTAT_CATEGORY_MASK 0xf0
>> >> >> +#define PMSTAT_PX            0x10
>> >> >> +#define PMSTAT_CX            0x20
>> >> >> +#define PMSTAT_get_max_px    (PMSTAT_PX | 0x1)
>> >> >> +#define PMSTAT_get_pxstat    (PMSTAT_PX | 0x2)
>> >> >> +#define PMSTAT_reset_pxstat  (PMSTAT_PX | 0x3)
>> >> >> +#define PMSTAT_get_max_cx    (PMSTAT_CX | 0x1)
>> >> >> +#define PMSTAT_get_cxstat    (PMSTAT_CX | 0x2)
>> >> >> +#define PMSTAT_reset_cxstat  (PMSTAT_CX | 0x3)
>> >> >> +     uint32_t type;
>> >> >> +     uint32_t cpuid;
>> >> >> +     union {
>> >> >> +             struct pm_px_stat getpx;
>> >> >> +             struct pm_cx_stat getcx;
>> >> >> +             /* other struct for tx, etc */
>> >> >> +     } u;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_get_pmstat);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_cpu_hotplug */
>> >> >> +struct xen_sysctl_cpu_hotplug {
>> >> >> +     /* IN variables */
>> >> >> +     uint32_t cpu;   /* Physical cpu. */
>> >> >> +#define XEN_SYSCTL_CPU_HOTPLUG_ONLINE  0
>> >> >> +#define XEN_SYSCTL_CPU_HOTPLUG_OFFLINE 1
>> >> >> +     uint32_t op;    /* hotplug opcode */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_cpu_hotplug);
>> >> >> +
>> >> >> +/*
>> >> >> + * Get/set xen power management, include
>> >> >> + * 1. cpufreq governors and related parameters
>> >> >> + */
>> >> >> +/* XEN_SYSCTL_pm_op */
>> >> >> +struct xen_userspace {
>> >> >> +     uint32_t scaling_setspeed;
>> >> >> +};
>> >> >> +
>> >> >> +struct xen_ondemand {
>> >> >> +     uint32_t sampling_rate_max;
>> >> >> +     uint32_t sampling_rate_min;
>> >> >> +
>> >> >> +     uint32_t sampling_rate;
>> >> >> +     uint32_t up_threshold;
>> >> >> +};
>> >> >> +
>> >> >> +/*
>> >> >> + * cpufreq para name of this structure named
>> >> >> + * same as sysfs file name of native linux
>> >> >> + */
>> >> >> +#define CPUFREQ_NAME_LEN 16
>> >> >> +struct xen_get_cpufreq_para {
>> >> >> +     /* IN/OUT variable */
>> >> >> +     uint32_t cpu_num;
>> >> >> +     uint32_t freq_num;
>> >> >> +     uint32_t gov_num;
>> >> >> +
>> >> >> +     /* for all governors */
>> >> >> +     /* OUT variable */
>> >> >> +     GUEST_HANDLE_64(uint32_t) affected_cpus;
>> >> >> +     GUEST_HANDLE_64(uint32_t) scaling_available_frequencies;
>> >> >> +     GUEST_HANDLE_64(char)   scaling_available_governors;
>> >> >> +     char scaling_driver[CPUFREQ_NAME_LEN];
>> >> >> +
>> >> >> +     uint32_t cpuinfo_cur_freq;
>> >> >> +     uint32_t cpuinfo_max_freq;
>> >> >> +     uint32_t cpuinfo_min_freq;
>> >> >> +     uint32_t scaling_cur_freq;
>> >> >> +
>> >> >> +     char scaling_governor[CPUFREQ_NAME_LEN];
>> >> >> +     uint32_t scaling_max_freq;
>> >> >> +     uint32_t scaling_min_freq;
>> >> >> +
>> >> >> +     /* for specific governor */
>> >> >> +     union {
>> >> >> +             struct  xen_userspace userspace;
>> >> >> +             struct  xen_ondemand ondemand;
>> >> >> +     } u;
>> >> >> +
>> >> >> +     int32_t turbo_enabled;
>> >> >> +};
>> >> >> +
>> >> >> +struct xen_set_cpufreq_gov {
>> >> >> +     char scaling_governor[CPUFREQ_NAME_LEN];
>> >> >> +};
>> >> >> +
>> >> >> +struct xen_set_cpufreq_para {
>> >> >> +     #define SCALING_MAX_FREQ           1
>> >> >> +     #define SCALING_MIN_FREQ           2
>> >> >> +     #define SCALING_SETSPEED           3
>> >> >> +     #define SAMPLING_RATE              4
>> >> >> +     #define UP_THRESHOLD               5
>> >> >> +
>> >> >> +     uint32_t ctrl_type;
>> >> >> +     uint32_t ctrl_value;
>> >> >> +};
>> >> >> +
>> >> >> +struct xen_sysctl_pm_op {
>> >> >> +     #define PM_PARA_CATEGORY_MASK      0xf0
>> >> >> +     #define CPUFREQ_PARA               0x10
>> >> >> +
>> >> >> +     /* cpufreq command type */
>> >> >> +     #define GET_CPUFREQ_PARA           (CPUFREQ_PARA | 0x01)
>> >> >> +     #define SET_CPUFREQ_GOV            (CPUFREQ_PARA | 0x02)
>> >> >> +     #define SET_CPUFREQ_PARA           (CPUFREQ_PARA | 0x03)
>> >> >> +     #define GET_CPUFREQ_AVGFREQ        (CPUFREQ_PARA | 0x04)
>> >> >> +
>> >> >> +     /* set/reset scheduler power saving option */
>> >> >> +     #define XEN_SYSCTL_pm_op_set_sched_opt_smt    0x21
>> >> >> +
>> >> >> +     /* cpuidle max_cstate access command */
>> >> >> +     #define XEN_SYSCTL_pm_op_get_max_cstate       0x22
>> >> >> +     #define XEN_SYSCTL_pm_op_set_max_cstate       0x23
>> >> >> +
>> >> >> +     /* set scheduler migration cost value */
>> >> >> +     #define XEN_SYSCTL_pm_op_set_vcpu_migration_delay   0x24
>> >> >> +     #define XEN_SYSCTL_pm_op_get_vcpu_migration_delay   0x25
>> >> >> +
>> >> >> +     /* enable/disable turbo mode when in dbs governor */
>> >> >> +     #define XEN_SYSCTL_pm_op_enable_turbo               0x26
>> >> >> +     #define XEN_SYSCTL_pm_op_disable_turbo              0x27
>> >> >> +
>> >> >> +     uint32_t cmd;
>> >> >> +     uint32_t cpuid;
>> >> >> +     union {
>> >> >> +             struct xen_get_cpufreq_para get_para;
>> >> >> +             struct xen_set_cpufreq_gov  set_gov;
>> >> >> +             struct xen_set_cpufreq_para set_para;
>> >> >> +             uint64_aligned_t get_avgfreq;
>> >> >> +             uint32_t                    set_sched_opt_smt;
>> >> >> +             uint32_t                    get_max_cstate;
>> >> >> +             uint32_t                    set_max_cstate;
>> >> >> +             uint32_t                    get_vcpu_migration_delay;
>> >> >> +             uint32_t                    set_vcpu_migration_delay;
>> >> >> +     } u;
>> >> >> +};
>> >> >> +
>> >> >> +/* XEN_SYSCTL_page_offline_op */
>> >> >> +struct xen_sysctl_page_offline_op {
>> >> >> +     /* IN: range of page to be offlined */
>> >> >> +#define sysctl_page_offline     1
>> >> >> +#define sysctl_page_online      2
>> >> >> +#define sysctl_query_page_offline  3
>> >> >> +     uint32_t cmd;
>> >> >> +     uint32_t start;
>> >> >> +     uint32_t end;
>> >> >> +     /* OUT: result of page offline request */
>> >> >> +     /*
>> >> >> +     * bit 0~15: result flags
>> >> >> +     * bit 16~31: owner
>> >> >> +     */
>> >> >> +     GUEST_HANDLE(uint32_t) status;
>> >> >> +};
>> >> >> +
>> >> >> +#define PG_OFFLINE_STATUS_MASK    (0xFFUL)
>> >> >> +
>> >> >> +/* The result is invalid, i.e. HV does not handle it */
>> >> >> +#define PG_OFFLINE_INVALID   (0x1UL << 0)
>> >> >> +
>> >> >> +#define PG_OFFLINE_OFFLINED  (0x1UL << 1)
>> >> >> +#define PG_OFFLINE_PENDING   (0x1UL << 2)
>> >> >> +#define PG_OFFLINE_FAILED    (0x1UL << 3)
>> >> >> +#define PG_OFFLINE_AGAIN     (0x1UL << 4)
>> >> >> +
>> >> >> +#define PG_ONLINE_FAILED     PG_OFFLINE_FAILED
>> >> >> +#define PG_ONLINE_ONLINED    PG_OFFLINE_OFFLINED
>> >> >> +
>> >> >> +#define PG_OFFLINE_STATUS_OFFLINED              (0x1UL << 1)
>> >> >> +#define PG_OFFLINE_STATUS_ONLINE                (0x1UL << 2)
>> >> >> +#define PG_OFFLINE_STATUS_OFFLINE_PENDING       (0x1UL << 3)
>> >> >> +#define PG_OFFLINE_STATUS_BROKEN                (0x1UL << 4)
>> >> >> +
>> >> >> +#define PG_OFFLINE_MISC_MASK    (0xFFUL << 4)
>> >> >> +
>> >> >> +/* valid when PG_OFFLINE_FAILED or PG_OFFLINE_PENDING */
>> >> >> +#define PG_OFFLINE_XENPAGE   (0x1UL << 8)
>> >> >> +#define PG_OFFLINE_DOM0PAGE  (0x1UL << 9)
>> >> >> +#define PG_OFFLINE_ANONYMOUS (0x1UL << 10)
>> >> >> +#define PG_OFFLINE_NOT_CONV_RAM   (0x1UL << 11)
>> >> >> +#define PG_OFFLINE_OWNED     (0x1UL << 12)
>> >> >> +
>> >> >> +#define PG_OFFLINE_BROKEN    (0x1UL << 13)
>> >> >> +#define PG_ONLINE_BROKEN     PG_OFFLINE_BROKEN
>> >> >> +
>> >> >> +#define PG_OFFLINE_OWNER_SHIFT 16
>> >> >> +
>> >> >> +/* XEN_SYSCTL_lockprof_op */
>> >> >> +/* Sub-operations: */
>> >> >> +#define XEN_SYSCTL_LOCKPROF_reset 1   /* Reset all profile data to 
>> >> >> zero. */
>> >> >> +#define XEN_SYSCTL_LOCKPROF_query 2   /* Get lock profile 
>> >> >> information. */
>> >> >> +/* Record-type: */
>> >> >> +#define LOCKPROF_TYPE_GLOBAL      0   /* global lock, idx meaningless 
>> >> >> */
>> >> >> +#define LOCKPROF_TYPE_PERDOM      1   /* per-domain lock, idx is 
>> >> >> domid */
>> >> >> +#define LOCKPROF_TYPE_N           2   /* number of types */
>> >> >> +struct xen_sysctl_lockprof_data {
>> >> >> +     char     name[40];   /* lock name (may include up to 2 %d 
>> >> >> specifiers) */
>> >> >> +     int32_t  type;       /* LOCKPROF_TYPE_??? */
>> >> >> +     int32_t  idx;        /* index (e.g. domain id) */
>> >> >> +     uint64_aligned_t lock_cnt;     /* # of locking succeeded */
>> >> >> +     uint64_aligned_t block_cnt;    /* # of wait for lock */
>> >> >> +     uint64_aligned_t lock_time;    /* nsecs lock held */
>> >> >> +     uint64_aligned_t block_time;   /* nsecs waited for lock */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_lockprof_data);
>> >> >> +
>> >> >> +struct xen_sysctl_lockprof_op {
>> >> >> +     /* IN variables. */
>> >> >> +     uint32_t       cmd;               /* XEN_SYSCTL_LOCKPROF_??? */
>> >> >> +     uint32_t       max_elem;          /* size of output buffer */
>> >> >> +     /* OUT variables (query only). */
>> >> >> +     uint32_t       nr_elem;           /* number of elements 
>> >> >> available */
>> >> >> +     uint64_aligned_t time;            /* nsecs of profile 
>> >> >> measurement */
>> >> >> +     /* profile information (or NULL) */
>> >> >> +     GUEST_HANDLE_64(xen_sysctl_lockprof_data) data;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_lockprof_op);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_topologyinfo */
>> >> >> +#define INVALID_TOPOLOGY_ID  (~0U)
>> >> >> +struct xen_sysctl_topologyinfo {
>> >> >> +     /*
>> >> >> +      * IN: maximum addressable entry in the caller-provided arrays.
>> >> >> +      * OUT: largest cpu identifier in the system.
>> >> >> +      * If OUT is greater than IN then the arrays are truncated!
>> >> >> +      * If OUT is leass than IN then the array tails are not written 
>> >> >> by
>> >> >> +      * sysctl.
>> >> >> +      */
>> >> >> +     uint32_t max_cpu_index;
>> >> >> +
>> >> >> +     /*
>> >> >> +      * If not NULL, these arrays are filled with core/socket/node 
>> >> >> identifier
>> >> >> +      * for each cpu.
>> >> >> +      * If a cpu has no core/socket/node information (e.g., cpu not 
>> >> >> present)
>> >> >> +      * then the sentinel value ~0u is written to each array.
>> >> >> +      * The number of array elements written by the sysctl is:
>> >> >> +      *   min(@max_cpu_index_IN,@max_cpu_index_OUT)+1
>> >> >> +      */
>> >> >> +     GUEST_HANDLE_64(uint32_t) cpu_to_core;
>> >> >> +     GUEST_HANDLE_64(uint32_t) cpu_to_socket;
>> >> >> +     GUEST_HANDLE_64(uint32_t) cpu_to_node;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_topologyinfo);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_numainfo */
>> >> >> +#define INVALID_NUMAINFO_ID (~0U)
>> >> >> +struct xen_sysctl_numainfo {
>> >> >> +     /*
>> >> >> +      * IN: maximum addressable entry in the caller-provided arrays.
>> >> >> +      * OUT: largest node identifier in the system.
>> >> >> +      * If OUT is greater than IN then the arrays are truncated!
>> >> >> +      */
>> >> >> +     uint32_t max_node_index;
>> >> >> +
>> >> >> +     /* NB. Entries are 0 if node is not present. */
>> >> >> +     GUEST_HANDLE_64(uint64_t) node_to_memsize;
>> >> >> +     GUEST_HANDLE_64(uint64_t) node_to_memfree;
>> >> >> +
>> >> >> +     /*
>> >> >> +      * Array, of size (max_node_index+1)^2, listing memory access 
>> >> >> distances
>> >> >> +      * between nodes. If an entry has no node distance information 
>> >> >> (e.g., node
>> >> >> +      * not present) then the value ~0u is written.
>> >> >> +      *
>> >> >> +      * Note that the array rows must be indexed by multiplying by 
>> >> >> the minimum
>> >> >> +      * of the caller-provided max_node_index and the returned value 
>> >> >> of
>> >> >> +      * max_node_index. That is, if the largest node index in the 
>> >> >> system is
>> >> >> +      * smaller than the caller can handle, a smaller 2-d array is 
>> >> >> constructed
>> >> >> +      * within the space provided by the caller. When this occurs, 
>> >> >> trailing
>> >> >> +      * space provided by the caller is not modified. If the largest 
>> >> >> node index
>> >> >> +      * in the system is larger than the caller can handle, then a 
>> >> >> 2-d array of
>> >> >> +      * the maximum size handleable by the caller is constructed.
>> >> >> +      */
>> >> >> +     GUEST_HANDLE_64(uint32_t) node_to_node_distance;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_numainfo);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_cpupool_op */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_CREATE                1  /* C */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_DESTROY               2  /* D */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_INFO                  3  /* I */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_ADDCPU                4  /* A */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_RMCPU                 5  /* R */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_MOVEDOMAIN            6  /* M */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_OP_FREEINFO              7  /* F */
>> >> >> +#define XEN_SYSCTL_CPUPOOL_PAR_ANY     0xFFFFFFFF
>> >> >> +struct xen_sysctl_cpupool_op {
>> >> >> +     uint32_t op;          /* IN */
>> >> >> +     uint32_t cpupool_id;  /* IN: CDIARM OUT: CI */
>> >> >> +     uint32_t sched_id;    /* IN: C      OUT: I  */
>> >> >> +     uint32_t domid;       /* IN: M              */
>> >> >> +     uint32_t cpu;         /* IN: AR             */
>> >> >> +     uint32_t n_dom;       /*            OUT: I  */
>> >> >> +     struct xenctl_bitmap cpumap; /*     OUT: IF */
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_cpupool_op);
>> >> >> +
>> >> >> +#define ARINC653_MAX_DOMAINS_PER_SCHEDULE   64
>> >> >> +/*
>> >> >> + * This structure is used to pass a new ARINC653 schedule from a
>> >> >> + * privileged domain (ie dom0) to Xen.
>> >> >> + */
>> >> >> +struct xen_sysctl_arinc653_schedule {
>> >> >> +     /* major_frame holds the time for the new schedule's major frame
>> >> >> +     * in nanoseconds. */
>> >> >> +     uint64_aligned_t     major_frame;
>> >> >> +     /* num_sched_entries holds how many of the entries in the
>> >> >> +     * sched_entries[] array are valid. */
>> >> >> +     uint8_t     num_sched_entries;
>> >> >> +     /* The sched_entries array holds the actual schedule entries. */
>> >> >> +     struct {
>> >> >> +             /* dom_handle must match a domain's UUID */
>> >> >> +             xen_domain_handle_t dom_handle;
>> >> >> +             /*
>> >> >> +              * If a domain has multiple VCPUs, vcpu_id specifies 
>> >> >> which one
>> >> >> +              * this schedule entry applies to. It should be set to 0 
>> >> >> if
>> >> >> +              * there is only one VCPU for the domain. */
>> >> >> +             unsigned int vcpu_id;
>> >> >> +             /*
>> >> >> +              * runtime specifies the amount of time that should be 
>> >> >> allocated
>> >> >> +              * to this VCPU per major frame. It is specified in 
>> >> >> nanoseconds
>> >> >> +              */
>> >> >> +             uint64_aligned_t runtime;
>> >> >> +     } sched_entries[ARINC653_MAX_DOMAINS_PER_SCHEDULE];
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_arinc653_schedule);
>> >> >> +
>> >> >> +struct xen_sysctl_credit_schedule {
>> >> >> +    /* Length of timeslice in milliseconds */
>> >> >> +#define XEN_SYSCTL_CSCHED_TSLICE_MAX 1000
>> >> >> +#define XEN_SYSCTL_CSCHED_TSLICE_MIN 1
>> >> >> +     unsigned tslice_ms;
>> >> >> +    /* Rate limit (minimum timeslice) in microseconds */
>> >> >> +#define XEN_SYSCTL_SCHED_RATELIMIT_MAX 500000
>> >> >> +#define XEN_SYSCTL_SCHED_RATELIMIT_MIN 100
>> >> >> +     unsigned ratelimit_us;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_credit_schedule);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_scheduler_op */
>> >> >> +/* Set or get info? */
>> >> >> +#define XEN_SYSCTL_SCHEDOP_putinfo 0
>> >> >> +#define XEN_SYSCTL_SCHEDOP_getinfo 1
>> >> >> +struct xen_sysctl_scheduler_op {
>> >> >> +     uint32_t cpupool_id; /* Cpupool whose scheduler is to be 
>> >> >> targetted. */
>> >> >> +     uint32_t sched_id;   /* XEN_SCHEDULER_* (domctl.h) */
>> >> >> +     uint32_t cmd;        /* XEN_SYSCTL_SCHEDOP_* */
>> >> >> +     union {
>> >> >> +             struct xen_sysctl_sched_arinc653 {
>> >> >> +                     GUEST_HANDLE_64(xen_sysctl_arinc653_schedule) 
>> >> >> schedule;
>> >> >> +             } sched_arinc653;
>> >> >> +             struct xen_sysctl_credit_schedule sched_credit;
>> >> >> +     } u;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_scheduler_op);
>> >> >> +
>> >> >> +/* XEN_SYSCTL_coverage_op */
>> >> >> +/*
>> >> >> + * Get total size of information, to help allocate
>> >> >> + * the buffer. The pointer points to a 32 bit value.
>> >> >> + */
>> >> >> +#define XEN_SYSCTL_COVERAGE_get_total_size 0
>> >> >> +
>> >> >> +/*
>> >> >> + * Read coverage information in a single run
>> >> >> + * You must use a tool to split them.
>> >> >> + */
>> >> >> +#define XEN_SYSCTL_COVERAGE_read           1
>> >> >> +
>> >> >> +/*
>> >> >> + * Reset all the coverage counters to 0
>> >> >> + * No parameters.
>> >> >> + */
>> >> >> +#define XEN_SYSCTL_COVERAGE_reset          2
>> >> >> +
>> >> >> +/*
>> >> >> + * Like XEN_SYSCTL_COVERAGE_read but reset also
>> >> >> + * counters to 0 in a single call.
>> >> >> + */
>> >> >> +#define XEN_SYSCTL_COVERAGE_read_and_reset 3
>> >> >> +
>> >> >> +struct xen_sysctl_coverage_op {
>> >> >> +     uint32_t cmd;        /* XEN_SYSCTL_COVERAGE_* */
>> >> >> +     union {
>> >> >> +             uint32_t total_size; /* OUT */
>> >> >> +             GUEST_HANDLE_64(uint8_t)  raw_info;   /* OUT */
>> >> >> +     } u;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl_coverage_op);
>> >> >> +
>> >> >> +
>> >> >> +struct xen_sysctl {
>> >> >> +     uint32_t cmd;
>> >> >> +#define XEN_SYSCTL_readconsole                    1
>> >> >> +#define XEN_SYSCTL_tbuf_op                        2
>> >> >> +#define XEN_SYSCTL_physinfo                       3
>> >> >> +#define XEN_SYSCTL_sched_id                       4
>> >> >> +#define XEN_SYSCTL_perfc_op                       5
>> >> >> +#define XEN_SYSCTL_debug_keys                     7
>> >> >> +#define XEN_SYSCTL_getcpuinfo                     8
>> >> >> +#define XEN_SYSCTL_availheap                      9
>> >> >> +#define XEN_SYSCTL_get_pmstat                    10
>> >> >> +#define XEN_SYSCTL_cpu_hotplug                   11
>> >> >> +#define XEN_SYSCTL_pm_op                         12
>> >> >> +#define XEN_SYSCTL_page_offline_op               14
>> >> >> +#define XEN_SYSCTL_lockprof_op                   15
>> >> >> +#define XEN_SYSCTL_topologyinfo                  16
>> >> >> +#define XEN_SYSCTL_numainfo                      17
>> >> >> +#define XEN_SYSCTL_cpupool_op                    18
>> >> >> +#define XEN_SYSCTL_scheduler_op                  19
>> >> >> +#define XEN_SYSCTL_coverage_op                   20
>> >> >> +     uint32_t interface_version; /* XEN_SYSCTL_INTERFACE_VERSION */
>> >> >> +     union {
>> >> >> +             struct xen_sysctl_readconsole       readconsole;
>> >> >> +             struct xen_sysctl_tbuf_op           tbuf_op;
>> >> >> +             struct xen_sysctl_physinfo          physinfo;
>> >> >> +             struct xen_sysctl_topologyinfo      topologyinfo;
>> >> >> +             struct xen_sysctl_numainfo          numainfo;
>> >> >> +             struct xen_sysctl_sched_id          sched_id;
>> >> >> +             struct xen_sysctl_perfc_op          perfc_op;
>> >> >> +             struct xen_sysctl_debug_keys        debug_keys;
>> >> >> +             struct xen_sysctl_getcpuinfo        getcpuinfo;
>> >> >> +             struct xen_sysctl_availheap         availheap;
>> >> >> +             struct xen_sysctl_get_pmstat        get_pmstat;
>> >> >> +             struct xen_sysctl_cpu_hotplug       cpu_hotplug;
>> >> >> +             struct xen_sysctl_pm_op             pm_op;
>> >> >> +             struct xen_sysctl_page_offline_op   page_offline;
>> >> >> +             struct xen_sysctl_lockprof_op       lockprof_op;
>> >> >> +             struct xen_sysctl_cpupool_op        cpupool_op;
>> >> >> +             struct xen_sysctl_scheduler_op      scheduler_op;
>> >> >> +             struct xen_sysctl_coverage_op       coverage_op;
>> >> >> +             uint8_t                             pad[128];
>> >> >> +     } u;
>> >> >> +};
>> >> >> +DEFINE_GUEST_HANDLE_STRUCT(xen_sysctl);
>> >> >> +
>> >> >> +#endif /* __XEN_PUBLIC_SYSCTL_H__ */
>> >> >
>> >> > We usually only introduce what we need from Xen header files in Linux:
>> >> > do not copy the entirety of sysctl.h, just introduce what you need.
>> >> I'll do this in the next patch-set.
>> >>
>> >> >> diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h
>> >> >> index 53ec416..cf64566 100644
>> >> >> --- a/include/xen/interface/xen.h
>> >> >> +++ b/include/xen/interface/xen.h
>> >> >> @@ -57,6 +57,7 @@
>> >> >>  #define __HYPERVISOR_event_channel_op     32
>> >> >>  #define __HYPERVISOR_physdev_op           33
>> >> >>  #define __HYPERVISOR_hvm_op               34
>> >> >> +#define __HYPERVISOR_sysctl               35
>> >> >>  #define __HYPERVISOR_tmem_op              38
>> >> >>
>> >> >>  /* Architecture-specific hypercall definitions. */
>> >> >> @@ -526,6 +527,11 @@ struct tmem_op {
>> >> >>
>> >> >>  DEFINE_GUEST_HANDLE(u64);
>> >> >>
>> >> >> +struct xenctl_bitmap {
>> >> >> +     GUEST_HANDLE_64(uint8_t) bitmap;
>> >> >> +     uint32_t nr_bits;
>> >> >> +};
>> >> >> +
>> >> >>  #else /* __ASSEMBLY__ */
>> >> >>
>> >> >>  /* In assembly code we cannot use C numeric constant suffixes. */
>> >> >> --
>> >> >> 1.9.1
>> >> >>
>> >>
>>

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.