ia64/linux-2.6.18-xen.hg

view include/xen/interface/vcpu.h @ 466:26e1e96bd46a

x86 xen: New vcpu_op call to get physical CPU identity.

Some AMD machines have APIC IDs that not equal to CPU IDs. In
the default Xen configuration, ACPI calls on these machines
can get confused. This shows up most noticeably when running
AMD PowerNow!. The only solution is for dom0 to get the
hypervisor's cpuid to apicid table when needed (ie, when dom0
vcpus are pinned).

Add a vcpu op to Xen to allow dom0 to query the hypervisor for
architecture dependent physical cpu information if dom0 vcpus are
pinned.

Signed-off-by: Mark Langsdorf <mark.langsdorf@amd.com>
Signed-off-by: Keir Fraser <keir.fraser@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Wed Mar 05 11:09:41 2008 +0000 (2008-03-05)
parents e9cb774f0bd9
children 3983b041fc51
line source
1 /******************************************************************************
2 * vcpu.h
3 *
4 * VCPU initialisation, query, and hotplug.
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) 2005, Keir Fraser <keir@xensource.com>
25 */
27 #ifndef __XEN_PUBLIC_VCPU_H__
28 #define __XEN_PUBLIC_VCPU_H__
30 /*
31 * Prototype for this hypercall is:
32 * int vcpu_op(int cmd, int vcpuid, void *extra_args)
33 * @cmd == VCPUOP_??? (VCPU operation).
34 * @vcpuid == VCPU to operate on.
35 * @extra_args == Operation-specific extra arguments (NULL if none).
36 */
38 /*
39 * Initialise a VCPU. Each VCPU can be initialised only once. A
40 * newly-initialised VCPU will not run until it is brought up by VCPUOP_up.
41 *
42 * @extra_arg == pointer to vcpu_guest_context structure containing initial
43 * state for the VCPU.
44 */
45 #define VCPUOP_initialise 0
47 /*
48 * Bring up a VCPU. This makes the VCPU runnable. This operation will fail
49 * if the VCPU has not been initialised (VCPUOP_initialise).
50 */
51 #define VCPUOP_up 1
53 /*
54 * Bring down a VCPU (i.e., make it non-runnable).
55 * There are a few caveats that callers should observe:
56 * 1. This operation may return, and VCPU_is_up may return false, before the
57 * VCPU stops running (i.e., the command is asynchronous). It is a good
58 * idea to ensure that the VCPU has entered a non-critical loop before
59 * bringing it down. Alternatively, this operation is guaranteed
60 * synchronous if invoked by the VCPU itself.
61 * 2. After a VCPU is initialised, there is currently no way to drop all its
62 * references to domain memory. Even a VCPU that is down still holds
63 * memory references via its pagetable base pointer and GDT. It is good
64 * practise to move a VCPU onto an 'idle' or default page table, LDT and
65 * GDT before bringing it down.
66 */
67 #define VCPUOP_down 2
69 /* Returns 1 if the given VCPU is up. */
70 #define VCPUOP_is_up 3
72 /*
73 * Return information about the state and running time of a VCPU.
74 * @extra_arg == pointer to vcpu_runstate_info structure.
75 */
76 #define VCPUOP_get_runstate_info 4
77 struct vcpu_runstate_info {
78 /* VCPU's current state (RUNSTATE_*). */
79 int state;
80 /* When was current state entered (system time, ns)? */
81 uint64_t state_entry_time;
82 /*
83 * Time spent in each RUNSTATE_* (ns). The sum of these times is
84 * guaranteed not to drift from system time.
85 */
86 uint64_t time[4];
87 };
88 typedef struct vcpu_runstate_info vcpu_runstate_info_t;
89 DEFINE_XEN_GUEST_HANDLE(vcpu_runstate_info_t);
91 /* VCPU is currently running on a physical CPU. */
92 #define RUNSTATE_running 0
94 /* VCPU is runnable, but not currently scheduled on any physical CPU. */
95 #define RUNSTATE_runnable 1
97 /* VCPU is blocked (a.k.a. idle). It is therefore not runnable. */
98 #define RUNSTATE_blocked 2
100 /*
101 * VCPU is not runnable, but it is not blocked.
102 * This is a 'catch all' state for things like hotplug and pauses by the
103 * system administrator (or for critical sections in the hypervisor).
104 * RUNSTATE_blocked dominates this state (it is the preferred state).
105 */
106 #define RUNSTATE_offline 3
108 /*
109 * Register a shared memory area from which the guest may obtain its own
110 * runstate information without needing to execute a hypercall.
111 * Notes:
112 * 1. The registered address may be virtual or physical or guest handle,
113 * depending on the platform. Virtual address or guest handle should be
114 * registered on x86 systems.
115 * 2. Only one shared area may be registered per VCPU. The shared area is
116 * updated by the hypervisor each time the VCPU is scheduled. Thus
117 * runstate.state will always be RUNSTATE_running and
118 * runstate.state_entry_time will indicate the system time at which the
119 * VCPU was last scheduled to run.
120 * @extra_arg == pointer to vcpu_register_runstate_memory_area structure.
121 */
122 #define VCPUOP_register_runstate_memory_area 5
123 struct vcpu_register_runstate_memory_area {
124 union {
125 XEN_GUEST_HANDLE(vcpu_runstate_info_t) h;
126 struct vcpu_runstate_info *v;
127 uint64_t p;
128 } addr;
129 };
130 typedef struct vcpu_register_runstate_memory_area vcpu_register_runstate_memory_area_t;
131 DEFINE_XEN_GUEST_HANDLE(vcpu_register_runstate_memory_area_t);
133 /*
134 * Set or stop a VCPU's periodic timer. Every VCPU has one periodic timer
135 * which can be set via these commands. Periods smaller than one millisecond
136 * may not be supported.
137 */
138 #define VCPUOP_set_periodic_timer 6 /* arg == vcpu_set_periodic_timer_t */
139 #define VCPUOP_stop_periodic_timer 7 /* arg == NULL */
140 struct vcpu_set_periodic_timer {
141 uint64_t period_ns;
142 };
143 typedef struct vcpu_set_periodic_timer vcpu_set_periodic_timer_t;
144 DEFINE_XEN_GUEST_HANDLE(vcpu_set_periodic_timer_t);
146 /*
147 * Set or stop a VCPU's single-shot timer. Every VCPU has one single-shot
148 * timer which can be set via these commands.
149 */
150 #define VCPUOP_set_singleshot_timer 8 /* arg == vcpu_set_singleshot_timer_t */
151 #define VCPUOP_stop_singleshot_timer 9 /* arg == NULL */
152 struct vcpu_set_singleshot_timer {
153 uint64_t timeout_abs_ns; /* Absolute system time value in nanoseconds. */
154 uint32_t flags; /* VCPU_SSHOTTMR_??? */
155 };
156 typedef struct vcpu_set_singleshot_timer vcpu_set_singleshot_timer_t;
157 DEFINE_XEN_GUEST_HANDLE(vcpu_set_singleshot_timer_t);
159 /* Flags to VCPUOP_set_singleshot_timer. */
160 /* Require the timeout to be in the future (return -ETIME if it's passed). */
161 #define _VCPU_SSHOTTMR_future (0)
162 #define VCPU_SSHOTTMR_future (1U << _VCPU_SSHOTTMR_future)
164 /*
165 * Register a memory location in the guest address space for the
166 * vcpu_info structure. This allows the guest to place the vcpu_info
167 * structure in a convenient place, such as in a per-cpu data area.
168 * The pointer need not be page aligned, but the structure must not
169 * cross a page boundary.
170 *
171 * This may be called only once per vcpu.
172 */
173 #define VCPUOP_register_vcpu_info 10 /* arg == vcpu_register_vcpu_info_t */
174 struct vcpu_register_vcpu_info {
175 uint64_t mfn; /* mfn of page to place vcpu_info */
176 uint32_t offset; /* offset within page */
177 uint32_t rsvd; /* unused */
178 };
179 typedef struct vcpu_register_vcpu_info vcpu_register_vcpu_info_t;
180 DEFINE_XEN_GUEST_HANDLE(vcpu_register_vcpu_info_t);
182 /* Send an NMI to the specified VCPU. @extra_arg == NULL. */
183 #define VCPUOP_send_nmi 11
185 /*
186 * Get the physical ID information for a pinned vcpu's underlying physical
187 * processor. The physical ID informmation is architecture-specific.
188 * On x86: id[7:0]=apic_id, id[15:8]=acpi_id, id[63:16]=mbz,
189 * and an unavailable identifier is returned as 0xff.
190 * This command returns -EINVAL if it is not a valid operation for this VCPU.
191 */
192 #define VCPUOP_get_physid 12 /* arg == vcpu_get_physid_t */
193 struct vcpu_get_physid {
194 uint64_t phys_id;
195 };
196 typedef struct vcpu_get_physid vcpu_get_physid_t;
197 DEFINE_XEN_GUEST_HANDLE(vcpu_get_physid_t);
198 #define xen_vcpu_physid_to_x86_apicid(physid) ((uint8_t)((physid)>>0))
199 #define xen_vcpu_physid_to_x86_acpiid(physid) ((uint8_t)((physid)>>8))
201 #endif /* __XEN_PUBLIC_VCPU_H__ */
203 /*
204 * Local variables:
205 * mode: C
206 * c-set-style: "BSD"
207 * c-basic-offset: 4
208 * tab-width: 4
209 * indent-tabs-mode: nil
210 * End:
211 */