1843e1988Sjohnlev /*
2843e1988Sjohnlev * CDDL HEADER START
3843e1988Sjohnlev *
4843e1988Sjohnlev * The contents of this file are subject to the terms of the
5843e1988Sjohnlev * Common Development and Distribution License (the "License").
6843e1988Sjohnlev * You may not use this file except in compliance with the License.
7843e1988Sjohnlev *
8843e1988Sjohnlev * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9843e1988Sjohnlev * or http://www.opensolaris.org/os/licensing.
10843e1988Sjohnlev * See the License for the specific language governing permissions
11843e1988Sjohnlev * and limitations under the License.
12843e1988Sjohnlev *
13843e1988Sjohnlev * When distributing Covered Code, include this CDDL HEADER in each
14843e1988Sjohnlev * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15843e1988Sjohnlev * If applicable, add the following below this CDDL HEADER, with the
16843e1988Sjohnlev * fields enclosed by brackets "[]" replaced with your own identifying
17843e1988Sjohnlev * information: Portions Copyright [yyyy] [name of copyright owner]
18843e1988Sjohnlev *
19843e1988Sjohnlev * CDDL HEADER END
20843e1988Sjohnlev */
21843e1988Sjohnlev
22843e1988Sjohnlev /*
23349b53ddSStuart Maybee * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24843e1988Sjohnlev * Use is subject to license terms.
25843e1988Sjohnlev */
26843e1988Sjohnlev
27843e1988Sjohnlev /* derived from netbsd's xen_machdep.c 1.1.2.1 */
28843e1988Sjohnlev
29843e1988Sjohnlev /*
30843e1988Sjohnlev *
31843e1988Sjohnlev * Copyright (c) 2004 Christian Limpach.
32843e1988Sjohnlev * All rights reserved.
33843e1988Sjohnlev *
34843e1988Sjohnlev * Redistribution and use in source and binary forms, with or without
35843e1988Sjohnlev * modification, are permitted provided that the following conditions
36843e1988Sjohnlev * are met:
37843e1988Sjohnlev * 1. Redistributions of source code must retain the above copyright
38843e1988Sjohnlev * notice, this list of conditions and the following disclaimer.
39843e1988Sjohnlev * 2. Redistributions in binary form must reproduce the above copyright
40843e1988Sjohnlev * notice, this list of conditions and the following disclaimer in the
41843e1988Sjohnlev * documentation and/or other materials provided with the distribution.
42843e1988Sjohnlev * 3. This section intentionally left blank.
43843e1988Sjohnlev * 4. The name of the author may not be used to endorse or promote products
44843e1988Sjohnlev * derived from this software without specific prior written permission.
45843e1988Sjohnlev *
46843e1988Sjohnlev * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
47843e1988Sjohnlev * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
48843e1988Sjohnlev * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
49843e1988Sjohnlev * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
50843e1988Sjohnlev * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
51843e1988Sjohnlev * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
52843e1988Sjohnlev * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
53843e1988Sjohnlev * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
54843e1988Sjohnlev * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
55843e1988Sjohnlev * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56843e1988Sjohnlev */
57843e1988Sjohnlev /*
58843e1988Sjohnlev * Section 3 of the above license was updated in response to bug 6379571.
59843e1988Sjohnlev */
60843e1988Sjohnlev
61349b53ddSStuart Maybee #include <sys/xpv_user.h>
62349b53ddSStuart Maybee
63349b53ddSStuart Maybee /* XXX 3.3. TODO remove this include */
64349b53ddSStuart Maybee #include <xen/public/arch-x86/xen-mca.h>
65349b53ddSStuart Maybee
669e839ce9Sgarypen #include <sys/ctype.h>
67843e1988Sjohnlev #include <sys/types.h>
68843e1988Sjohnlev #include <sys/cmn_err.h>
69843e1988Sjohnlev #include <sys/trap.h>
70843e1988Sjohnlev #include <sys/segments.h>
71843e1988Sjohnlev #include <sys/hypervisor.h>
72843e1988Sjohnlev #include <sys/xen_mmu.h>
73843e1988Sjohnlev #include <sys/machsystm.h>
74843e1988Sjohnlev #include <sys/promif.h>
75843e1988Sjohnlev #include <sys/bootconf.h>
76843e1988Sjohnlev #include <sys/bootinfo.h>
77843e1988Sjohnlev #include <sys/cpr.h>
78843e1988Sjohnlev #include <sys/taskq.h>
79843e1988Sjohnlev #include <sys/uadmin.h>
80843e1988Sjohnlev #include <sys/evtchn_impl.h>
81843e1988Sjohnlev #include <sys/archsystm.h>
82843e1988Sjohnlev #include <xen/sys/xenbus_impl.h>
83843e1988Sjohnlev #include <sys/mach_mmu.h>
84843e1988Sjohnlev #include <vm/hat_i86.h>
85843e1988Sjohnlev #include <sys/gnttab.h>
86843e1988Sjohnlev #include <sys/reboot.h>
87843e1988Sjohnlev #include <sys/stack.h>
88843e1988Sjohnlev #include <sys/clock.h>
89843e1988Sjohnlev #include <sys/bitmap.h>
90843e1988Sjohnlev #include <sys/processor.h>
91843e1988Sjohnlev #include <sys/xen_errno.h>
92843e1988Sjohnlev #include <sys/xpv_panic.h>
93843e1988Sjohnlev #include <sys/smp_impldefs.h>
94843e1988Sjohnlev #include <sys/cpu.h>
95843e1988Sjohnlev #include <sys/balloon_impl.h>
96843e1988Sjohnlev #include <sys/ddi.h>
97843e1988Sjohnlev
98843e1988Sjohnlev #ifdef DEBUG
99843e1988Sjohnlev #define SUSPEND_DEBUG if (xen_suspend_debug) xen_printf
100843e1988Sjohnlev #else
101843e1988Sjohnlev #define SUSPEND_DEBUG(...)
102843e1988Sjohnlev #endif
103843e1988Sjohnlev
104843e1988Sjohnlev int cpr_debug;
105843e1988Sjohnlev cpuset_t cpu_suspend_lost_set;
106843e1988Sjohnlev static int xen_suspend_debug;
107843e1988Sjohnlev
108e4b86885SCheng Sean Ye uint_t xen_phys_ncpus;
109e4b86885SCheng Sean Ye xen_mc_logical_cpu_t *xen_phys_cpus;
110e4b86885SCheng Sean Ye int xen_physinfo_debug = 0;
111e4b86885SCheng Sean Ye
1129e839ce9Sgarypen /*
1139e839ce9Sgarypen * Determine helpful version information.
1149e839ce9Sgarypen *
1159e839ce9Sgarypen * (And leave copies in the data segment so we can look at them later
1169e839ce9Sgarypen * with e.g. kmdb.)
1179e839ce9Sgarypen */
1189e839ce9Sgarypen
1199e839ce9Sgarypen typedef enum xen_version {
1209e839ce9Sgarypen XENVER_BOOT_IDX,
1219e839ce9Sgarypen XENVER_CURRENT_IDX
1229e839ce9Sgarypen } xen_version_t;
1239e839ce9Sgarypen
1249e839ce9Sgarypen struct xenver {
1259e839ce9Sgarypen ulong_t xv_major;
1269e839ce9Sgarypen ulong_t xv_minor;
1279e839ce9Sgarypen ulong_t xv_revision;
1289e839ce9Sgarypen xen_extraversion_t xv_ver;
129ab4a9bebSjohnlev ulong_t xv_is_xvm;
1309e839ce9Sgarypen xen_changeset_info_t xv_chgset;
1319e839ce9Sgarypen xen_compile_info_t xv_build;
1329e839ce9Sgarypen xen_capabilities_info_t xv_caps;
1339e839ce9Sgarypen } xenver[2];
1349e839ce9Sgarypen
1359e839ce9Sgarypen #define XENVER_BOOT(m) (xenver[XENVER_BOOT_IDX].m)
1369e839ce9Sgarypen #define XENVER_CURRENT(m) (xenver[XENVER_CURRENT_IDX].m)
1379e839ce9Sgarypen
1389e839ce9Sgarypen /*
1399e839ce9Sgarypen * Update the xenver data. We maintain two copies, boot and
1409e839ce9Sgarypen * current. If we are setting the boot, then also set current.
1419e839ce9Sgarypen */
1429e839ce9Sgarypen static void
xen_set_version(xen_version_t idx)1439e839ce9Sgarypen xen_set_version(xen_version_t idx)
1449e839ce9Sgarypen {
1459e839ce9Sgarypen ulong_t ver;
1469e839ce9Sgarypen
1479e839ce9Sgarypen bzero(&xenver[idx], sizeof (xenver[idx]));
1489e839ce9Sgarypen
1499e839ce9Sgarypen ver = HYPERVISOR_xen_version(XENVER_version, 0);
1509e839ce9Sgarypen
1519e839ce9Sgarypen xenver[idx].xv_major = BITX(ver, 31, 16);
1529e839ce9Sgarypen xenver[idx].xv_minor = BITX(ver, 15, 0);
1539e839ce9Sgarypen
1549e839ce9Sgarypen (void) HYPERVISOR_xen_version(XENVER_extraversion, &xenver[idx].xv_ver);
1559e839ce9Sgarypen
1569e839ce9Sgarypen /*
1579e839ce9Sgarypen * The revision is buried in the extraversion information that is
1589e839ce9Sgarypen * maintained by the hypervisor. For our purposes we expect that
1599e839ce9Sgarypen * the revision number is:
1609e839ce9Sgarypen * - the second character in the extraversion information
1619e839ce9Sgarypen * - one character long
1629e839ce9Sgarypen * - numeric digit
1639e839ce9Sgarypen * If it isn't then we can't extract the revision and we leave it
1649e839ce9Sgarypen * set to 0.
1659e839ce9Sgarypen */
1669e839ce9Sgarypen if (strlen(xenver[idx].xv_ver) > 1 && isdigit(xenver[idx].xv_ver[1]))
1679e839ce9Sgarypen xenver[idx].xv_revision = xenver[idx].xv_ver[1] - '0';
1689e839ce9Sgarypen else
1699e839ce9Sgarypen cmn_err(CE_WARN, "Cannot extract revision on this hypervisor "
1709e839ce9Sgarypen "version: v%s, unexpected version format",
1719e839ce9Sgarypen xenver[idx].xv_ver);
1729e839ce9Sgarypen
173ab4a9bebSjohnlev xenver[idx].xv_is_xvm = 0;
174ab4a9bebSjohnlev
175ad09f8b8SMark Johnson if (strstr(xenver[idx].xv_ver, "-xvm") != NULL)
176ab4a9bebSjohnlev xenver[idx].xv_is_xvm = 1;
177ab4a9bebSjohnlev
1789e839ce9Sgarypen (void) HYPERVISOR_xen_version(XENVER_changeset,
1799e839ce9Sgarypen &xenver[idx].xv_chgset);
1809e839ce9Sgarypen
1819e839ce9Sgarypen (void) HYPERVISOR_xen_version(XENVER_compile_info,
1829e839ce9Sgarypen &xenver[idx].xv_build);
1839e839ce9Sgarypen /*
1849e839ce9Sgarypen * Capabilities are a set of space separated ascii strings
1859e839ce9Sgarypen * e.g. 'xen-3.1-x86_32p' or 'hvm-3.2-x86_64'
1869e839ce9Sgarypen */
1879e839ce9Sgarypen (void) HYPERVISOR_xen_version(XENVER_capabilities,
1889e839ce9Sgarypen &xenver[idx].xv_caps);
1899e839ce9Sgarypen
1909e839ce9Sgarypen cmn_err(CE_CONT, "?v%lu.%lu%s chgset '%s'\n", xenver[idx].xv_major,
1919e839ce9Sgarypen xenver[idx].xv_minor, xenver[idx].xv_ver, xenver[idx].xv_chgset);
1929e839ce9Sgarypen
1939e839ce9Sgarypen if (idx == XENVER_BOOT_IDX)
1949e839ce9Sgarypen bcopy(&xenver[XENVER_BOOT_IDX], &xenver[XENVER_CURRENT_IDX],
1959e839ce9Sgarypen sizeof (xenver[XENVER_BOOT_IDX]));
1969e839ce9Sgarypen }
1979e839ce9Sgarypen
1989e839ce9Sgarypen typedef enum xen_hypervisor_check {
1999e839ce9Sgarypen XEN_RUN_CHECK,
2009e839ce9Sgarypen XEN_SUSPEND_CHECK
2019e839ce9Sgarypen } xen_hypervisor_check_t;
2029e839ce9Sgarypen
2039e839ce9Sgarypen /*
2049e839ce9Sgarypen * To run the hypervisor must be 3.0.4 or better. To suspend/resume
2059e839ce9Sgarypen * we need 3.0.4 or better and if it is 3.0.4. then it must be provided
2069e839ce9Sgarypen * by the Solaris xVM project.
2079e839ce9Sgarypen * Checking can be disabled for testing purposes by setting the
2089e839ce9Sgarypen * xen_suspend_debug variable.
2099e839ce9Sgarypen */
2109e839ce9Sgarypen static int
xen_hypervisor_supports_solaris(xen_hypervisor_check_t check)2119e839ce9Sgarypen xen_hypervisor_supports_solaris(xen_hypervisor_check_t check)
2129e839ce9Sgarypen {
2139e839ce9Sgarypen if (xen_suspend_debug == 1)
2149e839ce9Sgarypen return (1);
2159e839ce9Sgarypen if (XENVER_CURRENT(xv_major) < 3)
2169e839ce9Sgarypen return (0);
2179e839ce9Sgarypen if (XENVER_CURRENT(xv_major) > 3)
2189e839ce9Sgarypen return (1);
2199e839ce9Sgarypen if (XENVER_CURRENT(xv_minor) > 0)
2209e839ce9Sgarypen return (1);
2219e839ce9Sgarypen if (XENVER_CURRENT(xv_revision) < 4)
2229e839ce9Sgarypen return (0);
223ab4a9bebSjohnlev if (check == XEN_SUSPEND_CHECK && XENVER_CURRENT(xv_revision) == 4 &&
224ab4a9bebSjohnlev !XENVER_CURRENT(xv_is_xvm))
2259e839ce9Sgarypen return (0);
226ab4a9bebSjohnlev
2279e839ce9Sgarypen return (1);
2289e839ce9Sgarypen }
2299e839ce9Sgarypen
230ab4a9bebSjohnlev /*
231ab4a9bebSjohnlev * If the hypervisor is -xvm, or 3.1.2 or higher, we don't need the
232ab4a9bebSjohnlev * workaround.
233ab4a9bebSjohnlev */
234ab4a9bebSjohnlev static void
xen_pte_workaround(void)235ab4a9bebSjohnlev xen_pte_workaround(void)
236ab4a9bebSjohnlev {
237ab4a9bebSjohnlev extern int pt_kern;
238ab4a9bebSjohnlev
239ab4a9bebSjohnlev if (XENVER_CURRENT(xv_major) != 3)
240ab4a9bebSjohnlev return;
241ab4a9bebSjohnlev if (XENVER_CURRENT(xv_minor) > 1)
242ab4a9bebSjohnlev return;
243ab4a9bebSjohnlev if (XENVER_CURRENT(xv_minor) == 1 &&
244ab4a9bebSjohnlev XENVER_CURRENT(xv_revision) > 1)
245ab4a9bebSjohnlev return;
246ab4a9bebSjohnlev if (XENVER_CURRENT(xv_is_xvm))
247ab4a9bebSjohnlev return;
248ab4a9bebSjohnlev
249ab4a9bebSjohnlev pt_kern = PT_USER;
250ab4a9bebSjohnlev }
251ab4a9bebSjohnlev
252843e1988Sjohnlev void
xen_set_callback(void (* func)(void),uint_t type,uint_t flags)253843e1988Sjohnlev xen_set_callback(void (*func)(void), uint_t type, uint_t flags)
254843e1988Sjohnlev {
255843e1988Sjohnlev struct callback_register cb;
256843e1988Sjohnlev
257843e1988Sjohnlev bzero(&cb, sizeof (cb));
258843e1988Sjohnlev cb.address = (ulong_t)func;
259843e1988Sjohnlev cb.type = type;
260843e1988Sjohnlev cb.flags = flags;
261843e1988Sjohnlev
262843e1988Sjohnlev /*
263843e1988Sjohnlev * XXPV always ignore return value for NMI
264843e1988Sjohnlev */
265843e1988Sjohnlev if (HYPERVISOR_callback_op(CALLBACKOP_register, &cb) != 0 &&
266843e1988Sjohnlev type != CALLBACKTYPE_nmi)
267843e1988Sjohnlev panic("HYPERVISOR_callback_op failed");
268843e1988Sjohnlev }
269843e1988Sjohnlev
270843e1988Sjohnlev void
xen_init_callbacks(void)271843e1988Sjohnlev xen_init_callbacks(void)
272843e1988Sjohnlev {
273843e1988Sjohnlev /*
274843e1988Sjohnlev * register event (interrupt) handler.
275843e1988Sjohnlev */
276843e1988Sjohnlev xen_set_callback(xen_callback, CALLBACKTYPE_event, 0);
277843e1988Sjohnlev
278843e1988Sjohnlev /*
279843e1988Sjohnlev * failsafe handler.
280843e1988Sjohnlev */
281843e1988Sjohnlev xen_set_callback(xen_failsafe_callback, CALLBACKTYPE_failsafe,
282843e1988Sjohnlev CALLBACKF_mask_events);
283843e1988Sjohnlev
284843e1988Sjohnlev /*
285843e1988Sjohnlev * NMI handler.
286843e1988Sjohnlev */
287843e1988Sjohnlev xen_set_callback(nmiint, CALLBACKTYPE_nmi, 0);
288843e1988Sjohnlev
289843e1988Sjohnlev /*
290843e1988Sjohnlev * system call handler
291843e1988Sjohnlev * XXPV move to init_cpu_syscall?
292843e1988Sjohnlev */
293843e1988Sjohnlev xen_set_callback(sys_syscall, CALLBACKTYPE_syscall,
294843e1988Sjohnlev CALLBACKF_mask_events);
295843e1988Sjohnlev }
296843e1988Sjohnlev
297843e1988Sjohnlev
298843e1988Sjohnlev /*
299843e1988Sjohnlev * cmn_err() followed by a 1/4 second delay; this gives the
300843e1988Sjohnlev * logging service a chance to flush messages and helps avoid
301843e1988Sjohnlev * intermixing output from prom_printf().
302843e1988Sjohnlev * XXPV: doesn't exactly help us on UP though.
303843e1988Sjohnlev */
304843e1988Sjohnlev /*PRINTFLIKE2*/
305843e1988Sjohnlev void
cpr_err(int ce,const char * fmt,...)306843e1988Sjohnlev cpr_err(int ce, const char *fmt, ...)
307843e1988Sjohnlev {
308843e1988Sjohnlev va_list adx;
309843e1988Sjohnlev
310843e1988Sjohnlev va_start(adx, fmt);
311843e1988Sjohnlev vcmn_err(ce, fmt, adx);
312843e1988Sjohnlev va_end(adx);
313843e1988Sjohnlev drv_usecwait(MICROSEC >> 2);
314843e1988Sjohnlev }
315843e1988Sjohnlev
316843e1988Sjohnlev void
xen_suspend_devices(void)317843e1988Sjohnlev xen_suspend_devices(void)
318843e1988Sjohnlev {
319843e1988Sjohnlev int rc;
320843e1988Sjohnlev
321843e1988Sjohnlev SUSPEND_DEBUG("xen_suspend_devices\n");
322843e1988Sjohnlev
323843e1988Sjohnlev if ((rc = cpr_suspend_devices(ddi_root_node())) != 0)
324843e1988Sjohnlev panic("failed to suspend devices: %d", rc);
325843e1988Sjohnlev }
326843e1988Sjohnlev
327843e1988Sjohnlev void
xen_resume_devices(void)328843e1988Sjohnlev xen_resume_devices(void)
329843e1988Sjohnlev {
330843e1988Sjohnlev int rc;
331843e1988Sjohnlev
332843e1988Sjohnlev SUSPEND_DEBUG("xen_resume_devices\n");
333843e1988Sjohnlev
334843e1988Sjohnlev if ((rc = cpr_resume_devices(ddi_root_node(), 0)) != 0)
335843e1988Sjohnlev panic("failed to resume devices: %d", rc);
336843e1988Sjohnlev }
337843e1988Sjohnlev
338843e1988Sjohnlev /*
339843e1988Sjohnlev * The list of mfn pages is out of date. Recompute it.
340843e1988Sjohnlev */
341843e1988Sjohnlev static void
rebuild_mfn_list(void)342843e1988Sjohnlev rebuild_mfn_list(void)
343843e1988Sjohnlev {
344843e1988Sjohnlev int i = 0;
345843e1988Sjohnlev size_t sz;
346843e1988Sjohnlev size_t off;
347843e1988Sjohnlev pfn_t pfn;
348843e1988Sjohnlev
349843e1988Sjohnlev SUSPEND_DEBUG("rebuild_mfn_list\n");
350843e1988Sjohnlev
351843e1988Sjohnlev sz = ((mfn_count * sizeof (mfn_t)) + MMU_PAGEOFFSET) & MMU_PAGEMASK;
352843e1988Sjohnlev
353843e1988Sjohnlev for (off = 0; off < sz; off += MMU_PAGESIZE) {
354843e1988Sjohnlev size_t j = mmu_btop(off);
355843e1988Sjohnlev if (((j * sizeof (mfn_t)) & MMU_PAGEOFFSET) == 0) {
356843e1988Sjohnlev pfn = hat_getpfnum(kas.a_hat,
357843e1988Sjohnlev (caddr_t)&mfn_list_pages[j]);
358843e1988Sjohnlev mfn_list_pages_page[i++] = pfn_to_mfn(pfn);
359843e1988Sjohnlev }
360843e1988Sjohnlev
361843e1988Sjohnlev pfn = hat_getpfnum(kas.a_hat, (caddr_t)mfn_list + off);
362843e1988Sjohnlev mfn_list_pages[j] = pfn_to_mfn(pfn);
363843e1988Sjohnlev }
364843e1988Sjohnlev
365843e1988Sjohnlev pfn = hat_getpfnum(kas.a_hat, (caddr_t)mfn_list_pages_page);
366843e1988Sjohnlev HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list
367843e1988Sjohnlev = pfn_to_mfn(pfn);
368843e1988Sjohnlev }
369843e1988Sjohnlev
370843e1988Sjohnlev static void
suspend_cpus(void)371843e1988Sjohnlev suspend_cpus(void)
372843e1988Sjohnlev {
373843e1988Sjohnlev int i;
374843e1988Sjohnlev
375843e1988Sjohnlev SUSPEND_DEBUG("suspend_cpus\n");
376843e1988Sjohnlev
3771d03c31eSjohnlev mp_enter_barrier();
378843e1988Sjohnlev
379843e1988Sjohnlev for (i = 1; i < ncpus; i++) {
380843e1988Sjohnlev if (!CPU_IN_SET(cpu_suspend_lost_set, i)) {
381843e1988Sjohnlev SUSPEND_DEBUG("xen_vcpu_down %d\n", i);
382843e1988Sjohnlev (void) xen_vcpu_down(i);
383843e1988Sjohnlev }
384843e1988Sjohnlev
385843e1988Sjohnlev mach_cpucontext_reset(cpu[i]);
386843e1988Sjohnlev }
387843e1988Sjohnlev }
388843e1988Sjohnlev
389843e1988Sjohnlev static void
resume_cpus(void)390843e1988Sjohnlev resume_cpus(void)
391843e1988Sjohnlev {
392843e1988Sjohnlev int i;
393843e1988Sjohnlev
394843e1988Sjohnlev for (i = 1; i < ncpus; i++) {
395843e1988Sjohnlev if (cpu[i] == NULL)
396843e1988Sjohnlev continue;
397843e1988Sjohnlev
398843e1988Sjohnlev if (!CPU_IN_SET(cpu_suspend_lost_set, i)) {
399843e1988Sjohnlev SUSPEND_DEBUG("xen_vcpu_up %d\n", i);
400843e1988Sjohnlev mach_cpucontext_restore(cpu[i]);
401843e1988Sjohnlev (void) xen_vcpu_up(i);
402843e1988Sjohnlev }
403843e1988Sjohnlev }
404843e1988Sjohnlev
4051d03c31eSjohnlev mp_leave_barrier();
406843e1988Sjohnlev }
407843e1988Sjohnlev
408843e1988Sjohnlev /*
409843e1988Sjohnlev * Top level routine to direct suspend/resume of a domain.
410843e1988Sjohnlev */
411843e1988Sjohnlev void
xen_suspend_domain(void)412843e1988Sjohnlev xen_suspend_domain(void)
413843e1988Sjohnlev {
414843e1988Sjohnlev extern void rtcsync(void);
415843e1988Sjohnlev extern hrtime_t hres_last_tick;
416843e1988Sjohnlev mfn_t start_info_mfn;
417843e1988Sjohnlev ulong_t flags;
418843e1988Sjohnlev pfn_t pfn;
419843e1988Sjohnlev int i;
420843e1988Sjohnlev
421843e1988Sjohnlev /*
4229e839ce9Sgarypen * Check that we are happy to suspend on this hypervisor.
4239e839ce9Sgarypen */
4249e839ce9Sgarypen if (xen_hypervisor_supports_solaris(XEN_SUSPEND_CHECK) == 0) {
4259e839ce9Sgarypen cpr_err(CE_WARN, "Cannot suspend on this hypervisor "
4269e839ce9Sgarypen "version: v%lu.%lu%s, need at least version v3.0.4 or "
4279e839ce9Sgarypen "-xvm based hypervisor", XENVER_CURRENT(xv_major),
4289e839ce9Sgarypen XENVER_CURRENT(xv_minor), XENVER_CURRENT(xv_ver));
4299e839ce9Sgarypen return;
4309e839ce9Sgarypen }
4319e839ce9Sgarypen
4329e839ce9Sgarypen /*
433843e1988Sjohnlev * XXPV - Are we definitely OK to suspend by the time we've connected
434843e1988Sjohnlev * the handler?
435843e1988Sjohnlev */
436843e1988Sjohnlev
437843e1988Sjohnlev cpr_err(CE_NOTE, "Domain suspending for save/migrate");
438843e1988Sjohnlev
439843e1988Sjohnlev SUSPEND_DEBUG("xen_suspend_domain\n");
440843e1988Sjohnlev
441843e1988Sjohnlev /*
442843e1988Sjohnlev * suspend interrupts and devices
443843e1988Sjohnlev * XXPV - we use suspend/resume for both save/restore domains (like sun
444843e1988Sjohnlev * cpr) and for migration. Would be nice to know the difference if
445843e1988Sjohnlev * possible. For save/restore where down time may be a long time, we
446843e1988Sjohnlev * may want to do more of the things that cpr does. (i.e. notify user
447843e1988Sjohnlev * processes, shrink memory footprint for faster restore, etc.)
448843e1988Sjohnlev */
449843e1988Sjohnlev xen_suspend_devices();
450843e1988Sjohnlev SUSPEND_DEBUG("xenbus_suspend\n");
451843e1988Sjohnlev xenbus_suspend();
452843e1988Sjohnlev
453843e1988Sjohnlev pfn = hat_getpfnum(kas.a_hat, (caddr_t)xen_info);
454843e1988Sjohnlev start_info_mfn = pfn_to_mfn(pfn);
455843e1988Sjohnlev
456843e1988Sjohnlev /*
457843e1988Sjohnlev * XXPV: cpu hotplug can hold this under a xenbus watch. Are we safe
458843e1988Sjohnlev * wrt xenbus being suspended here?
459843e1988Sjohnlev */
460843e1988Sjohnlev mutex_enter(&cpu_lock);
461843e1988Sjohnlev
462843e1988Sjohnlev /*
463843e1988Sjohnlev * Suspend must be done on vcpu 0, as no context for other CPUs is
464843e1988Sjohnlev * saved.
465843e1988Sjohnlev *
466843e1988Sjohnlev * XXPV - add to taskq API ?
467843e1988Sjohnlev */
468843e1988Sjohnlev thread_affinity_set(curthread, 0);
469843e1988Sjohnlev kpreempt_disable();
470843e1988Sjohnlev
471843e1988Sjohnlev SUSPEND_DEBUG("xen_start_migrate\n");
472843e1988Sjohnlev xen_start_migrate();
473843e1988Sjohnlev if (ncpus > 1)
474843e1988Sjohnlev suspend_cpus();
475843e1988Sjohnlev
476843e1988Sjohnlev /*
477843e1988Sjohnlev * We can grab the ec_lock as it's a spinlock with a high SPL. Hence
478843e1988Sjohnlev * any holder would have dropped it to get through suspend_cpus().
479843e1988Sjohnlev */
480843e1988Sjohnlev mutex_enter(&ec_lock);
481843e1988Sjohnlev
482843e1988Sjohnlev /*
483843e1988Sjohnlev * From here on in, we can't take locks.
484843e1988Sjohnlev */
485843e1988Sjohnlev SUSPEND_DEBUG("ec_suspend\n");
486843e1988Sjohnlev ec_suspend();
487843e1988Sjohnlev SUSPEND_DEBUG("gnttab_suspend\n");
488843e1988Sjohnlev gnttab_suspend();
489843e1988Sjohnlev
490843e1988Sjohnlev flags = intr_clear();
491843e1988Sjohnlev
492843e1988Sjohnlev xpv_time_suspend();
493843e1988Sjohnlev
494843e1988Sjohnlev /*
495843e1988Sjohnlev * Currently, the hypervisor incorrectly fails to bring back
496843e1988Sjohnlev * powered-down VCPUs. Thus we need to record any powered-down VCPUs
497843e1988Sjohnlev * to prevent any attempts to operate on them. But we have to do this
498843e1988Sjohnlev * *after* the very first time we do ec_suspend().
499843e1988Sjohnlev */
500843e1988Sjohnlev for (i = 1; i < ncpus; i++) {
501843e1988Sjohnlev if (cpu[i] == NULL)
502843e1988Sjohnlev continue;
503843e1988Sjohnlev
504843e1988Sjohnlev if (cpu_get_state(cpu[i]) == P_POWEROFF)
505843e1988Sjohnlev CPUSET_ATOMIC_ADD(cpu_suspend_lost_set, i);
506843e1988Sjohnlev }
507843e1988Sjohnlev
508843e1988Sjohnlev /*
509843e1988Sjohnlev * The dom0 save/migrate code doesn't automatically translate
510843e1988Sjohnlev * these into PFNs, but expects them to be, so we do it here.
511843e1988Sjohnlev * We don't use mfn_to_pfn() because so many OS services have
512843e1988Sjohnlev * been disabled at this point.
513843e1988Sjohnlev */
514843e1988Sjohnlev xen_info->store_mfn = mfn_to_pfn_mapping[xen_info->store_mfn];
515843e1988Sjohnlev xen_info->console.domU.mfn =
516843e1988Sjohnlev mfn_to_pfn_mapping[xen_info->console.domU.mfn];
517843e1988Sjohnlev
518843e1988Sjohnlev if (CPU->cpu_m.mcpu_vcpu_info->evtchn_upcall_mask == 0) {
519843e1988Sjohnlev prom_printf("xen_suspend_domain(): "
520843e1988Sjohnlev "CPU->cpu_m.mcpu_vcpu_info->evtchn_upcall_mask not set\n");
521843e1988Sjohnlev (void) HYPERVISOR_shutdown(SHUTDOWN_crash);
522843e1988Sjohnlev }
523843e1988Sjohnlev
524843e1988Sjohnlev if (HYPERVISOR_update_va_mapping((uintptr_t)HYPERVISOR_shared_info,
525843e1988Sjohnlev 0, UVMF_INVLPG)) {
526843e1988Sjohnlev prom_printf("xen_suspend_domain(): "
527843e1988Sjohnlev "HYPERVISOR_update_va_mapping() failed\n");
528843e1988Sjohnlev (void) HYPERVISOR_shutdown(SHUTDOWN_crash);
529843e1988Sjohnlev }
530843e1988Sjohnlev
531843e1988Sjohnlev SUSPEND_DEBUG("HYPERVISOR_suspend\n");
532843e1988Sjohnlev
533843e1988Sjohnlev /*
534843e1988Sjohnlev * At this point we suspend and sometime later resume.
535843e1988Sjohnlev */
536843e1988Sjohnlev if (HYPERVISOR_suspend(start_info_mfn)) {
537843e1988Sjohnlev prom_printf("xen_suspend_domain(): "
538843e1988Sjohnlev "HYPERVISOR_suspend() failed\n");
539843e1988Sjohnlev (void) HYPERVISOR_shutdown(SHUTDOWN_crash);
540843e1988Sjohnlev }
541843e1988Sjohnlev
542843e1988Sjohnlev /*
543843e1988Sjohnlev * Point HYPERVISOR_shared_info to its new value.
544843e1988Sjohnlev */
545843e1988Sjohnlev if (HYPERVISOR_update_va_mapping((uintptr_t)HYPERVISOR_shared_info,
546843e1988Sjohnlev xen_info->shared_info | PT_NOCONSIST | PT_VALID | PT_WRITABLE,
547843e1988Sjohnlev UVMF_INVLPG))
548843e1988Sjohnlev (void) HYPERVISOR_shutdown(SHUTDOWN_crash);
549843e1988Sjohnlev
550843e1988Sjohnlev if (xen_info->nr_pages != mfn_count) {
551843e1988Sjohnlev prom_printf("xen_suspend_domain(): number of pages"
552843e1988Sjohnlev " changed, was 0x%lx, now 0x%lx\n", mfn_count,
553843e1988Sjohnlev xen_info->nr_pages);
554843e1988Sjohnlev (void) HYPERVISOR_shutdown(SHUTDOWN_crash);
555843e1988Sjohnlev }
556843e1988Sjohnlev
557843e1988Sjohnlev xpv_time_resume();
558843e1988Sjohnlev
559843e1988Sjohnlev cached_max_mfn = 0;
560843e1988Sjohnlev
561843e1988Sjohnlev SUSPEND_DEBUG("gnttab_resume\n");
562843e1988Sjohnlev gnttab_resume();
563843e1988Sjohnlev
564843e1988Sjohnlev /* XXPV: add a note that this must be lockless. */
565843e1988Sjohnlev SUSPEND_DEBUG("ec_resume\n");
566843e1988Sjohnlev ec_resume();
567843e1988Sjohnlev
568843e1988Sjohnlev intr_restore(flags);
569843e1988Sjohnlev
570843e1988Sjohnlev if (ncpus > 1)
571843e1988Sjohnlev resume_cpus();
572843e1988Sjohnlev
573843e1988Sjohnlev mutex_exit(&ec_lock);
574843e1988Sjohnlev xen_end_migrate();
575843e1988Sjohnlev mutex_exit(&cpu_lock);
576843e1988Sjohnlev
577843e1988Sjohnlev /*
578843e1988Sjohnlev * Now we can take locks again.
579843e1988Sjohnlev */
580843e1988Sjohnlev
581843e1988Sjohnlev /*
582843e1988Sjohnlev * Force the tick value used for tv_nsec in hres_tick() to be up to
583843e1988Sjohnlev * date. rtcsync() will reset the hrestime value appropriately.
584843e1988Sjohnlev */
585843e1988Sjohnlev hres_last_tick = xpv_gethrtime();
586843e1988Sjohnlev
587843e1988Sjohnlev /*
588843e1988Sjohnlev * XXPV: we need to have resumed the CPUs since this takes locks, but
589843e1988Sjohnlev * can remote CPUs see bad state? Presumably yes. Should probably nest
590843e1988Sjohnlev * taking of todlock inside of cpu_lock, or vice versa, then provide an
591843e1988Sjohnlev * unlocked version. Probably need to call clkinitf to reset cpu freq
592843e1988Sjohnlev * and re-calibrate if we migrated to a different speed cpu. Also need
593843e1988Sjohnlev * to make a (re)init_cpu_info call to update processor info structs
594843e1988Sjohnlev * and device tree info. That remains to be written at the moment.
595843e1988Sjohnlev */
596843e1988Sjohnlev rtcsync();
597843e1988Sjohnlev
598843e1988Sjohnlev rebuild_mfn_list();
599843e1988Sjohnlev
600843e1988Sjohnlev SUSPEND_DEBUG("xenbus_resume\n");
601843e1988Sjohnlev xenbus_resume();
602843e1988Sjohnlev SUSPEND_DEBUG("xenbus_resume_devices\n");
603843e1988Sjohnlev xen_resume_devices();
604843e1988Sjohnlev
605843e1988Sjohnlev thread_affinity_clear(curthread);
606843e1988Sjohnlev kpreempt_enable();
607843e1988Sjohnlev
608843e1988Sjohnlev SUSPEND_DEBUG("finished xen_suspend_domain\n");
6099e839ce9Sgarypen
6109e839ce9Sgarypen /*
6119e839ce9Sgarypen * We have restarted our suspended domain, update the hypervisor
6129e839ce9Sgarypen * details. NB: This must be done at the end of this function,
6139e839ce9Sgarypen * since we need the domain to be completely resumed before
6149e839ce9Sgarypen * these functions will work correctly.
6159e839ce9Sgarypen */
6169e839ce9Sgarypen xen_set_version(XENVER_CURRENT_IDX);
6179e839ce9Sgarypen
6189e839ce9Sgarypen /*
6199e839ce9Sgarypen * We can check and report a warning, but we don't stop the
6209e839ce9Sgarypen * process.
6219e839ce9Sgarypen */
6229e839ce9Sgarypen if (xen_hypervisor_supports_solaris(XEN_SUSPEND_CHECK) == 0)
6239e839ce9Sgarypen cmn_err(CE_WARN, "Found hypervisor version: v%lu.%lu%s "
6249e839ce9Sgarypen "but need at least version v3.0.4",
6259e839ce9Sgarypen XENVER_CURRENT(xv_major), XENVER_CURRENT(xv_minor),
6269e839ce9Sgarypen XENVER_CURRENT(xv_ver));
6279e839ce9Sgarypen
628843e1988Sjohnlev cmn_err(CE_NOTE, "domain restore/migrate completed");
629843e1988Sjohnlev }
630843e1988Sjohnlev
631db830ba5SToomas Soome uint_t
xen_debug_handler(caddr_t arg __unused,caddr_t arg1 __unused)632db830ba5SToomas Soome xen_debug_handler(caddr_t arg __unused, caddr_t arg1 __unused)
633843e1988Sjohnlev {
634843e1988Sjohnlev debug_enter("External debug event received");
635843e1988Sjohnlev
636843e1988Sjohnlev /*
637843e1988Sjohnlev * If we've not got KMDB loaded, output some stuff difficult to capture
638843e1988Sjohnlev * from a domain core.
639843e1988Sjohnlev */
640843e1988Sjohnlev if (!(boothowto & RB_DEBUG)) {
641843e1988Sjohnlev shared_info_t *si = HYPERVISOR_shared_info;
642843e1988Sjohnlev int i;
643843e1988Sjohnlev
644843e1988Sjohnlev prom_printf("evtchn_pending [ ");
645843e1988Sjohnlev for (i = 0; i < 8; i++)
646843e1988Sjohnlev prom_printf("%lx ", si->evtchn_pending[i]);
647843e1988Sjohnlev prom_printf("]\nevtchn_mask [ ");
648843e1988Sjohnlev for (i = 0; i < 8; i++)
649843e1988Sjohnlev prom_printf("%lx ", si->evtchn_mask[i]);
650843e1988Sjohnlev prom_printf("]\n");
651843e1988Sjohnlev
652843e1988Sjohnlev for (i = 0; i < ncpus; i++) {
653843e1988Sjohnlev vcpu_info_t *vcpu = &si->vcpu_info[i];
654843e1988Sjohnlev if (cpu[i] == NULL)
655843e1988Sjohnlev continue;
656843e1988Sjohnlev prom_printf("CPU%d pending %d mask %d sel %lx\n",
657843e1988Sjohnlev i, vcpu->evtchn_upcall_pending,
658843e1988Sjohnlev vcpu->evtchn_upcall_mask,
659843e1988Sjohnlev vcpu->evtchn_pending_sel);
660843e1988Sjohnlev }
661843e1988Sjohnlev }
662843e1988Sjohnlev
663843e1988Sjohnlev return (0);
664843e1988Sjohnlev }
665843e1988Sjohnlev
666843e1988Sjohnlev /*ARGSUSED*/
667843e1988Sjohnlev static void
xen_sysrq_handler(struct xenbus_watch * watch,const char ** vec,unsigned int len)668843e1988Sjohnlev xen_sysrq_handler(struct xenbus_watch *watch, const char **vec,
669843e1988Sjohnlev unsigned int len)
670843e1988Sjohnlev {
671843e1988Sjohnlev xenbus_transaction_t xbt;
672843e1988Sjohnlev char key = '\0';
673843e1988Sjohnlev int ret;
674843e1988Sjohnlev
675843e1988Sjohnlev retry:
676843e1988Sjohnlev if (xenbus_transaction_start(&xbt)) {
677843e1988Sjohnlev cmn_err(CE_WARN, "failed to start sysrq transaction");
678843e1988Sjohnlev return;
679843e1988Sjohnlev }
680843e1988Sjohnlev
681843e1988Sjohnlev if ((ret = xenbus_scanf(xbt, "control", "sysrq", "%c", &key)) != 0) {
682843e1988Sjohnlev /*
683843e1988Sjohnlev * ENOENT happens in response to our own xenbus_rm.
684843e1988Sjohnlev * XXPV - this happens spuriously on boot?
685843e1988Sjohnlev */
686843e1988Sjohnlev if (ret != ENOENT)
687843e1988Sjohnlev cmn_err(CE_WARN, "failed to read sysrq: %d", ret);
688843e1988Sjohnlev goto out;
689843e1988Sjohnlev }
690843e1988Sjohnlev
691843e1988Sjohnlev if ((ret = xenbus_rm(xbt, "control", "sysrq")) != 0) {
692843e1988Sjohnlev cmn_err(CE_WARN, "failed to reset sysrq: %d", ret);
693843e1988Sjohnlev goto out;
694843e1988Sjohnlev }
695843e1988Sjohnlev
696843e1988Sjohnlev if (xenbus_transaction_end(xbt, 0) == EAGAIN)
697843e1988Sjohnlev goto retry;
698843e1988Sjohnlev
699843e1988Sjohnlev /*
700843e1988Sjohnlev * Somewhat arbitrary - on Linux this means 'reboot'. We could just
701843e1988Sjohnlev * accept any key, but this might increase the risk of sending a
702843e1988Sjohnlev * harmless sysrq to the wrong domain...
703843e1988Sjohnlev */
704843e1988Sjohnlev if (key == 'b')
705db830ba5SToomas Soome (void) xen_debug_handler(NULL, NULL);
706843e1988Sjohnlev else
707843e1988Sjohnlev cmn_err(CE_WARN, "Ignored sysrq %c", key);
708843e1988Sjohnlev return;
709843e1988Sjohnlev
710843e1988Sjohnlev out:
711843e1988Sjohnlev (void) xenbus_transaction_end(xbt, 1);
712843e1988Sjohnlev }
713843e1988Sjohnlev
714843e1988Sjohnlev taskq_t *xen_shutdown_tq;
715843e1988Sjohnlev
716843e1988Sjohnlev #define SHUTDOWN_INVALID -1
717843e1988Sjohnlev #define SHUTDOWN_POWEROFF 0
718843e1988Sjohnlev #define SHUTDOWN_REBOOT 1
719843e1988Sjohnlev #define SHUTDOWN_SUSPEND 2
720843e1988Sjohnlev #define SHUTDOWN_HALT 3
721843e1988Sjohnlev #define SHUTDOWN_MAX 4
722843e1988Sjohnlev
723843e1988Sjohnlev #define SHUTDOWN_TIMEOUT_SECS (60 * 5)
724843e1988Sjohnlev
725843e1988Sjohnlev static const char *cmd_strings[SHUTDOWN_MAX] = {
726843e1988Sjohnlev "poweroff",
727843e1988Sjohnlev "reboot",
728843e1988Sjohnlev "suspend",
729843e1988Sjohnlev "halt"
730843e1988Sjohnlev };
731843e1988Sjohnlev
732843e1988Sjohnlev static void
xen_dirty_shutdown(void * arg)733843e1988Sjohnlev xen_dirty_shutdown(void *arg)
734843e1988Sjohnlev {
735843e1988Sjohnlev int cmd = (uintptr_t)arg;
736843e1988Sjohnlev
737843e1988Sjohnlev cmn_err(CE_WARN, "Externally requested shutdown failed or "
738843e1988Sjohnlev "timed out.\nShutting down.\n");
739843e1988Sjohnlev
740843e1988Sjohnlev switch (cmd) {
741843e1988Sjohnlev case SHUTDOWN_HALT:
742843e1988Sjohnlev case SHUTDOWN_POWEROFF:
743843e1988Sjohnlev (void) kadmin(A_SHUTDOWN, AD_POWEROFF, NULL, kcred);
744843e1988Sjohnlev break;
745843e1988Sjohnlev case SHUTDOWN_REBOOT:
746843e1988Sjohnlev (void) kadmin(A_REBOOT, AD_BOOT, NULL, kcred);
747843e1988Sjohnlev break;
748843e1988Sjohnlev }
749843e1988Sjohnlev }
750843e1988Sjohnlev
751843e1988Sjohnlev static void
xen_shutdown(void * arg)752843e1988Sjohnlev xen_shutdown(void *arg)
753843e1988Sjohnlev {
754843e1988Sjohnlev int cmd = (uintptr_t)arg;
755c48ac12eSjohnlev proc_t *initpp;
756843e1988Sjohnlev
757843e1988Sjohnlev ASSERT(cmd > SHUTDOWN_INVALID && cmd < SHUTDOWN_MAX);
758843e1988Sjohnlev
759843e1988Sjohnlev if (cmd == SHUTDOWN_SUSPEND) {
760843e1988Sjohnlev xen_suspend_domain();
761843e1988Sjohnlev return;
762843e1988Sjohnlev }
763843e1988Sjohnlev
764c48ac12eSjohnlev switch (cmd) {
765c48ac12eSjohnlev case SHUTDOWN_POWEROFF:
766c48ac12eSjohnlev force_shutdown_method = AD_POWEROFF;
767c48ac12eSjohnlev break;
768c48ac12eSjohnlev case SHUTDOWN_HALT:
769c48ac12eSjohnlev force_shutdown_method = AD_HALT;
770c48ac12eSjohnlev break;
771c48ac12eSjohnlev case SHUTDOWN_REBOOT:
772c48ac12eSjohnlev force_shutdown_method = AD_BOOT;
773c48ac12eSjohnlev break;
774c48ac12eSjohnlev }
775843e1988Sjohnlev
776c48ac12eSjohnlev /*
777c48ac12eSjohnlev * If we're still booting and init(1) isn't set up yet, simply halt.
778c48ac12eSjohnlev */
779c48ac12eSjohnlev mutex_enter(&pidlock);
780c48ac12eSjohnlev initpp = prfind(P_INITPID);
781c48ac12eSjohnlev mutex_exit(&pidlock);
782c48ac12eSjohnlev if (initpp == NULL) {
783c48ac12eSjohnlev extern void halt(char *);
784c48ac12eSjohnlev halt("Power off the System"); /* just in case */
785c48ac12eSjohnlev }
786843e1988Sjohnlev
787c48ac12eSjohnlev /*
788c48ac12eSjohnlev * else, graceful shutdown with inittab and all getting involved
789c48ac12eSjohnlev */
790c48ac12eSjohnlev psignal(initpp, SIGPWR);
791843e1988Sjohnlev
792843e1988Sjohnlev (void) timeout(xen_dirty_shutdown, arg,
793843e1988Sjohnlev SHUTDOWN_TIMEOUT_SECS * drv_usectohz(MICROSEC));
794843e1988Sjohnlev }
795843e1988Sjohnlev
796843e1988Sjohnlev /*ARGSUSED*/
797843e1988Sjohnlev static void
xen_shutdown_handler(struct xenbus_watch * watch,const char ** vec,unsigned int len)798843e1988Sjohnlev xen_shutdown_handler(struct xenbus_watch *watch, const char **vec,
799843e1988Sjohnlev unsigned int len)
800843e1988Sjohnlev {
801843e1988Sjohnlev char *str;
802843e1988Sjohnlev xenbus_transaction_t xbt;
803843e1988Sjohnlev int err, shutdown_code = SHUTDOWN_INVALID;
804843e1988Sjohnlev unsigned int slen;
805843e1988Sjohnlev
806843e1988Sjohnlev again:
807843e1988Sjohnlev err = xenbus_transaction_start(&xbt);
808843e1988Sjohnlev if (err)
809843e1988Sjohnlev return;
810843e1988Sjohnlev if (xenbus_read(xbt, "control", "shutdown", (void *)&str, &slen)) {
811843e1988Sjohnlev (void) xenbus_transaction_end(xbt, 1);
812843e1988Sjohnlev return;
813843e1988Sjohnlev }
814843e1988Sjohnlev
815843e1988Sjohnlev SUSPEND_DEBUG("%d: xen_shutdown_handler: \"%s\"\n", CPU->cpu_id, str);
816843e1988Sjohnlev
817843e1988Sjohnlev /*
818843e1988Sjohnlev * If this is a watch fired from our write below, check out early to
819843e1988Sjohnlev * avoid an infinite loop.
820843e1988Sjohnlev */
821843e1988Sjohnlev if (strcmp(str, "") == 0) {
822843e1988Sjohnlev (void) xenbus_transaction_end(xbt, 0);
823843e1988Sjohnlev kmem_free(str, slen);
824843e1988Sjohnlev return;
825843e1988Sjohnlev } else if (strcmp(str, "poweroff") == 0) {
826843e1988Sjohnlev shutdown_code = SHUTDOWN_POWEROFF;
827843e1988Sjohnlev } else if (strcmp(str, "reboot") == 0) {
828843e1988Sjohnlev shutdown_code = SHUTDOWN_REBOOT;
829843e1988Sjohnlev } else if (strcmp(str, "suspend") == 0) {
830843e1988Sjohnlev shutdown_code = SHUTDOWN_SUSPEND;
831843e1988Sjohnlev } else if (strcmp(str, "halt") == 0) {
832843e1988Sjohnlev shutdown_code = SHUTDOWN_HALT;
833843e1988Sjohnlev } else {
834843e1988Sjohnlev printf("Ignoring shutdown request: %s\n", str);
835843e1988Sjohnlev }
836843e1988Sjohnlev
837843e1988Sjohnlev /*
838843e1988Sjohnlev * XXPV Should we check the value of xenbus_write() too, or are all
839843e1988Sjohnlev * errors automatically folded into xenbus_transaction_end() ??
840843e1988Sjohnlev */
841843e1988Sjohnlev (void) xenbus_write(xbt, "control", "shutdown", "");
842843e1988Sjohnlev err = xenbus_transaction_end(xbt, 0);
843843e1988Sjohnlev if (err == EAGAIN) {
844843e1988Sjohnlev SUSPEND_DEBUG("%d: trying again\n", CPU->cpu_id);
845843e1988Sjohnlev kmem_free(str, slen);
846843e1988Sjohnlev goto again;
847843e1988Sjohnlev }
848843e1988Sjohnlev
849843e1988Sjohnlev kmem_free(str, slen);
850843e1988Sjohnlev if (shutdown_code != SHUTDOWN_INVALID) {
851843e1988Sjohnlev (void) taskq_dispatch(xen_shutdown_tq, xen_shutdown,
852843e1988Sjohnlev (void *)(intptr_t)shutdown_code, 0);
853843e1988Sjohnlev }
854843e1988Sjohnlev }
855843e1988Sjohnlev
856843e1988Sjohnlev static struct xenbus_watch shutdown_watch;
857843e1988Sjohnlev static struct xenbus_watch sysrq_watch;
858843e1988Sjohnlev
859843e1988Sjohnlev void
xen_late_startup(void)860843e1988Sjohnlev xen_late_startup(void)
861843e1988Sjohnlev {
862843e1988Sjohnlev if (!DOMAIN_IS_INITDOMAIN(xen_info)) {
863843e1988Sjohnlev xen_shutdown_tq = taskq_create("shutdown_taskq", 1,
864843e1988Sjohnlev maxclsyspri - 1, 1, 1, TASKQ_PREPOPULATE);
865843e1988Sjohnlev shutdown_watch.node = "control/shutdown";
866843e1988Sjohnlev shutdown_watch.callback = xen_shutdown_handler;
867843e1988Sjohnlev if (register_xenbus_watch(&shutdown_watch))
868843e1988Sjohnlev cmn_err(CE_WARN, "Failed to set shutdown watcher");
869843e1988Sjohnlev
870843e1988Sjohnlev sysrq_watch.node = "control/sysrq";
871843e1988Sjohnlev sysrq_watch.callback = xen_sysrq_handler;
872843e1988Sjohnlev if (register_xenbus_watch(&sysrq_watch))
873843e1988Sjohnlev cmn_err(CE_WARN, "Failed to set sysrq watcher");
874843e1988Sjohnlev }
875843e1988Sjohnlev balloon_init(xen_info->nr_pages);
876843e1988Sjohnlev }
877843e1988Sjohnlev
878843e1988Sjohnlev #ifdef DEBUG
879843e1988Sjohnlev #define XEN_PRINTF_BUFSIZE 1024
880843e1988Sjohnlev
881843e1988Sjohnlev char xen_printf_buffer[XEN_PRINTF_BUFSIZE];
882843e1988Sjohnlev
883843e1988Sjohnlev /*
884843e1988Sjohnlev * Printf function that calls hypervisor directly. For DomU it only
885843e1988Sjohnlev * works when running on a xen hypervisor built with debug on. Works
886843e1988Sjohnlev * always since no I/O ring interaction is needed.
887843e1988Sjohnlev */
888843e1988Sjohnlev /*PRINTFLIKE1*/
889843e1988Sjohnlev void
xen_printf(const char * fmt,...)890843e1988Sjohnlev xen_printf(const char *fmt, ...)
891843e1988Sjohnlev {
892843e1988Sjohnlev va_list ap;
893843e1988Sjohnlev
894843e1988Sjohnlev va_start(ap, fmt);
895843e1988Sjohnlev (void) vsnprintf(xen_printf_buffer, XEN_PRINTF_BUFSIZE, fmt, ap);
896843e1988Sjohnlev va_end(ap);
897843e1988Sjohnlev
898843e1988Sjohnlev (void) HYPERVISOR_console_io(CONSOLEIO_write,
899843e1988Sjohnlev strlen(xen_printf_buffer), xen_printf_buffer);
900843e1988Sjohnlev }
901843e1988Sjohnlev #else
902843e1988Sjohnlev void
xen_printf(const char * fmt,...)903843e1988Sjohnlev xen_printf(const char *fmt, ...)
904843e1988Sjohnlev {
905843e1988Sjohnlev }
906843e1988Sjohnlev #endif /* DEBUG */
907843e1988Sjohnlev
908843e1988Sjohnlev void
startup_xen_version(void)909ab4a9bebSjohnlev startup_xen_version(void)
910843e1988Sjohnlev {
9119e839ce9Sgarypen xen_set_version(XENVER_BOOT_IDX);
9129e839ce9Sgarypen if (xen_hypervisor_supports_solaris(XEN_RUN_CHECK) == 0)
9139e839ce9Sgarypen cmn_err(CE_WARN, "Found hypervisor version: v%lu.%lu%s "
9149e839ce9Sgarypen "but need at least version v3.0.4",
9159e839ce9Sgarypen XENVER_CURRENT(xv_major), XENVER_CURRENT(xv_minor),
9169e839ce9Sgarypen XENVER_CURRENT(xv_ver));
917ab4a9bebSjohnlev xen_pte_workaround();
918843e1988Sjohnlev }
919843e1988Sjohnlev
920e4b86885SCheng Sean Ye int xen_mca_simulate_mc_physinfo_failure = 0;
921e4b86885SCheng Sean Ye
922e4b86885SCheng Sean Ye void
startup_xen_mca(void)923e4b86885SCheng Sean Ye startup_xen_mca(void)
924e4b86885SCheng Sean Ye {
925e4b86885SCheng Sean Ye if (!DOMAIN_IS_INITDOMAIN(xen_info))
926e4b86885SCheng Sean Ye return;
927e4b86885SCheng Sean Ye
928e4b86885SCheng Sean Ye xen_phys_ncpus = 0;
929e4b86885SCheng Sean Ye xen_phys_cpus = NULL;
930e4b86885SCheng Sean Ye
931e4b86885SCheng Sean Ye if (xen_mca_simulate_mc_physinfo_failure ||
932e4b86885SCheng Sean Ye xen_get_mc_physcpuinfo(NULL, &xen_phys_ncpus) != 0) {
933e4b86885SCheng Sean Ye cmn_err(CE_WARN,
934e4b86885SCheng Sean Ye "%sxen_get_mc_physinfo failure during xen MCA startup: "
935e4b86885SCheng Sean Ye "there will be no machine check support",
936e4b86885SCheng Sean Ye xen_mca_simulate_mc_physinfo_failure ? "(simulated) " : "");
937e4b86885SCheng Sean Ye return;
938e4b86885SCheng Sean Ye }
939e4b86885SCheng Sean Ye
940e4b86885SCheng Sean Ye xen_phys_cpus = kmem_alloc(xen_phys_ncpus *
941e4b86885SCheng Sean Ye sizeof (xen_mc_logical_cpu_t), KM_NOSLEEP);
942e4b86885SCheng Sean Ye
943e4b86885SCheng Sean Ye if (xen_phys_cpus == NULL) {
944e4b86885SCheng Sean Ye cmn_err(CE_WARN,
945349b53ddSStuart Maybee "xen_get_mc_physinfo failure: can't allocate CPU array");
946e4b86885SCheng Sean Ye return;
947e4b86885SCheng Sean Ye }
948e4b86885SCheng Sean Ye
949e4b86885SCheng Sean Ye if (xen_get_mc_physcpuinfo(xen_phys_cpus, &xen_phys_ncpus) != 0) {
950e4b86885SCheng Sean Ye cmn_err(CE_WARN, "xen_get_mc_physinfo failure: no "
951e4b86885SCheng Sean Ye "physical CPU info");
952e4b86885SCheng Sean Ye kmem_free(xen_phys_cpus,
953e4b86885SCheng Sean Ye xen_phys_ncpus * sizeof (xen_mc_logical_cpu_t));
954e4b86885SCheng Sean Ye xen_phys_ncpus = 0;
955e4b86885SCheng Sean Ye xen_phys_cpus = NULL;
956e4b86885SCheng Sean Ye }
957e4b86885SCheng Sean Ye
958e4b86885SCheng Sean Ye if (xen_physinfo_debug) {
959e4b86885SCheng Sean Ye xen_mc_logical_cpu_t *xcp;
960e4b86885SCheng Sean Ye unsigned i;
961e4b86885SCheng Sean Ye
962e4b86885SCheng Sean Ye cmn_err(CE_NOTE, "xvm mca: %u physical cpus:\n",
963e4b86885SCheng Sean Ye xen_phys_ncpus);
964e4b86885SCheng Sean Ye for (i = 0; i < xen_phys_ncpus; i++) {
965e4b86885SCheng Sean Ye xcp = &xen_phys_cpus[i];
966e4b86885SCheng Sean Ye cmn_err(CE_NOTE, "cpu%u: (%u, %u, %u) apid %u",
967e4b86885SCheng Sean Ye xcp->mc_cpunr, xcp->mc_chipid, xcp->mc_coreid,
968e4b86885SCheng Sean Ye xcp->mc_threadid, xcp->mc_apicid);
969e4b86885SCheng Sean Ye }
970e4b86885SCheng Sean Ye }
971e4b86885SCheng Sean Ye }
972e4b86885SCheng Sean Ye
973843e1988Sjohnlev /*
974843e1988Sjohnlev * Miscellaneous hypercall wrappers with slightly more verbose diagnostics.
975843e1988Sjohnlev */
976843e1988Sjohnlev
977843e1988Sjohnlev void
xen_set_gdt(ulong_t * frame_list,int entries)978843e1988Sjohnlev xen_set_gdt(ulong_t *frame_list, int entries)
979843e1988Sjohnlev {
980843e1988Sjohnlev int err;
981843e1988Sjohnlev if ((err = HYPERVISOR_set_gdt(frame_list, entries)) != 0) {
982843e1988Sjohnlev /*
983843e1988Sjohnlev * X_EINVAL: reserved entry or bad frames
984843e1988Sjohnlev * X_EFAULT: bad address
985843e1988Sjohnlev */
986843e1988Sjohnlev panic("xen_set_gdt(%p, %d): error %d",
987843e1988Sjohnlev (void *)frame_list, entries, -(int)err);
988843e1988Sjohnlev }
989843e1988Sjohnlev }
990843e1988Sjohnlev
991843e1988Sjohnlev void
xen_set_ldt(user_desc_t * ldt,uint_t nsels)992843e1988Sjohnlev xen_set_ldt(user_desc_t *ldt, uint_t nsels)
993843e1988Sjohnlev {
994843e1988Sjohnlev struct mmuext_op op;
995843e1988Sjohnlev long err;
996843e1988Sjohnlev
997843e1988Sjohnlev op.cmd = MMUEXT_SET_LDT;
998843e1988Sjohnlev op.arg1.linear_addr = (uintptr_t)ldt;
999843e1988Sjohnlev op.arg2.nr_ents = nsels;
1000843e1988Sjohnlev
1001843e1988Sjohnlev if ((err = HYPERVISOR_mmuext_op(&op, 1, NULL, DOMID_SELF)) != 0) {
1002843e1988Sjohnlev panic("xen_set_ldt(%p, %d): error %d",
1003843e1988Sjohnlev (void *)ldt, nsels, -(int)err);
1004843e1988Sjohnlev }
1005843e1988Sjohnlev }
1006843e1988Sjohnlev
1007843e1988Sjohnlev void
xen_stack_switch(ulong_t ss,ulong_t esp)1008843e1988Sjohnlev xen_stack_switch(ulong_t ss, ulong_t esp)
1009843e1988Sjohnlev {
1010843e1988Sjohnlev long err;
1011843e1988Sjohnlev
1012843e1988Sjohnlev if ((err = HYPERVISOR_stack_switch(ss, esp)) != 0) {
1013843e1988Sjohnlev /*
1014843e1988Sjohnlev * X_EPERM: bad selector
1015843e1988Sjohnlev */
1016843e1988Sjohnlev panic("xen_stack_switch(%lx, %lx): error %d", ss, esp,
1017843e1988Sjohnlev -(int)err);
1018843e1988Sjohnlev }
1019843e1988Sjohnlev }
1020843e1988Sjohnlev
1021843e1988Sjohnlev long
xen_set_trap_table(trap_info_t * table)1022843e1988Sjohnlev xen_set_trap_table(trap_info_t *table)
1023843e1988Sjohnlev {
1024843e1988Sjohnlev long err;
1025843e1988Sjohnlev
1026843e1988Sjohnlev if ((err = HYPERVISOR_set_trap_table(table)) != 0) {
1027843e1988Sjohnlev /*
1028843e1988Sjohnlev * X_EFAULT: bad address
1029843e1988Sjohnlev * X_EPERM: bad selector
1030843e1988Sjohnlev */
1031843e1988Sjohnlev panic("xen_set_trap_table(%p): error %d", (void *)table,
1032843e1988Sjohnlev -(int)err);
1033843e1988Sjohnlev }
1034843e1988Sjohnlev return (err);
1035843e1988Sjohnlev }
1036843e1988Sjohnlev
1037843e1988Sjohnlev void
xen_set_segment_base(int reg,ulong_t value)1038843e1988Sjohnlev xen_set_segment_base(int reg, ulong_t value)
1039843e1988Sjohnlev {
1040843e1988Sjohnlev long err;
1041843e1988Sjohnlev
1042843e1988Sjohnlev if ((err = HYPERVISOR_set_segment_base(reg, value)) != 0) {
1043843e1988Sjohnlev /*
1044843e1988Sjohnlev * X_EFAULT: bad address
1045843e1988Sjohnlev * X_EINVAL: bad type
1046843e1988Sjohnlev */
1047843e1988Sjohnlev panic("xen_set_segment_base(%d, %lx): error %d",
1048843e1988Sjohnlev reg, value, -(int)err);
1049843e1988Sjohnlev }
1050843e1988Sjohnlev }
1051843e1988Sjohnlev
1052843e1988Sjohnlev /*
1053843e1988Sjohnlev * Translate a hypervisor errcode to a Solaris error code.
1054843e1988Sjohnlev */
1055843e1988Sjohnlev int
xen_xlate_errcode(int error)1056843e1988Sjohnlev xen_xlate_errcode(int error)
1057843e1988Sjohnlev {
1058843e1988Sjohnlev switch (-error) {
1059843e1988Sjohnlev
1060843e1988Sjohnlev /*
1061843e1988Sjohnlev * Translate hypervisor errno's into native errno's
1062843e1988Sjohnlev */
1063843e1988Sjohnlev
1064843e1988Sjohnlev #define CASE(num) case X_##num: error = num; break
1065843e1988Sjohnlev
1066843e1988Sjohnlev CASE(EPERM); CASE(ENOENT); CASE(ESRCH);
1067843e1988Sjohnlev CASE(EINTR); CASE(EIO); CASE(ENXIO);
1068843e1988Sjohnlev CASE(E2BIG); CASE(ENOMEM); CASE(EACCES);
1069843e1988Sjohnlev CASE(EFAULT); CASE(EBUSY); CASE(EEXIST);
1070843e1988Sjohnlev CASE(ENODEV); CASE(EISDIR); CASE(EINVAL);
1071843e1988Sjohnlev CASE(ENOSPC); CASE(ESPIPE); CASE(EROFS);
1072843e1988Sjohnlev CASE(ENOSYS); CASE(ENOTEMPTY); CASE(EISCONN);
1073349b53ddSStuart Maybee CASE(ENODATA); CASE(EAGAIN);
1074843e1988Sjohnlev
1075843e1988Sjohnlev #undef CASE
1076843e1988Sjohnlev
1077843e1988Sjohnlev default:
1078843e1988Sjohnlev panic("xen_xlate_errcode: unknown error %d", error);
1079843e1988Sjohnlev }
1080843e1988Sjohnlev
1081843e1988Sjohnlev return (error);
1082843e1988Sjohnlev }
1083843e1988Sjohnlev
1084843e1988Sjohnlev /*
1085843e1988Sjohnlev * Raise PS_IOPL on current vcpu to user level.
1086843e1988Sjohnlev * Caller responsible for preventing kernel preemption.
1087843e1988Sjohnlev */
1088843e1988Sjohnlev void
xen_enable_user_iopl(void * arg __unused)1089*5a469116SPatrick Mooney xen_enable_user_iopl(void *arg __unused)
1090843e1988Sjohnlev {
1091843e1988Sjohnlev physdev_set_iopl_t set_iopl;
1092843e1988Sjohnlev set_iopl.iopl = 3; /* user ring 3 */
1093843e1988Sjohnlev (void) HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
1094843e1988Sjohnlev }
1095843e1988Sjohnlev
1096843e1988Sjohnlev /*
1097843e1988Sjohnlev * Drop PS_IOPL on current vcpu to kernel level
1098843e1988Sjohnlev */
1099843e1988Sjohnlev void
xen_disable_user_iopl(void * arg __unused)1100*5a469116SPatrick Mooney xen_disable_user_iopl(void *arg __unused)
1101843e1988Sjohnlev {
1102843e1988Sjohnlev physdev_set_iopl_t set_iopl;
1103843e1988Sjohnlev set_iopl.iopl = 1; /* kernel pseudo ring 1 */
1104843e1988Sjohnlev (void) HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
1105843e1988Sjohnlev }
1106843e1988Sjohnlev
1107843e1988Sjohnlev int
xen_gdt_setprot(cpu_t * cp,uint_t prot)1108843e1988Sjohnlev xen_gdt_setprot(cpu_t *cp, uint_t prot)
1109843e1988Sjohnlev {
1110843e1988Sjohnlev int err;
1111843e1988Sjohnlev int pt_bits = PT_VALID;
1112843e1988Sjohnlev if (prot & PROT_WRITE)
1113843e1988Sjohnlev pt_bits |= PT_WRITABLE;
1114843e1988Sjohnlev
1115843e1988Sjohnlev if ((err = as_setprot(&kas, (caddr_t)cp->cpu_gdt,
1116843e1988Sjohnlev MMU_PAGESIZE, prot)) != 0)
1117843e1988Sjohnlev goto done;
1118843e1988Sjohnlev
1119843e1988Sjohnlev err = xen_kpm_page(mmu_btop(cp->cpu_m.mcpu_gdtpa), pt_bits);
1120843e1988Sjohnlev
1121843e1988Sjohnlev done:
1122843e1988Sjohnlev if (err) {
1123843e1988Sjohnlev cmn_err(CE_WARN, "cpu%d: xen_gdt_setprot(%s) failed: error %d",
1124843e1988Sjohnlev cp->cpu_id, (prot & PROT_WRITE) ? "writable" : "read-only",
1125843e1988Sjohnlev err);
1126843e1988Sjohnlev }
1127843e1988Sjohnlev
1128843e1988Sjohnlev return (err);
1129843e1988Sjohnlev }
1130843e1988Sjohnlev
1131843e1988Sjohnlev int
xen_ldt_setprot(user_desc_t * ldt,size_t lsize,uint_t prot)1132843e1988Sjohnlev xen_ldt_setprot(user_desc_t *ldt, size_t lsize, uint_t prot)
1133843e1988Sjohnlev {
1134843e1988Sjohnlev int err;
1135843e1988Sjohnlev caddr_t lva = (caddr_t)ldt;
1136843e1988Sjohnlev int pt_bits = PT_VALID;
1137843e1988Sjohnlev pgcnt_t npgs;
1138843e1988Sjohnlev if (prot & PROT_WRITE)
1139843e1988Sjohnlev pt_bits |= PT_WRITABLE;
1140843e1988Sjohnlev
1141843e1988Sjohnlev if ((err = as_setprot(&kas, (caddr_t)ldt, lsize, prot)) != 0)
1142843e1988Sjohnlev goto done;
1143843e1988Sjohnlev
1144843e1988Sjohnlev
1145843e1988Sjohnlev ASSERT(IS_P2ALIGNED(lsize, PAGESIZE));
1146843e1988Sjohnlev npgs = mmu_btop(lsize);
1147843e1988Sjohnlev while (npgs--) {
1148843e1988Sjohnlev if ((err = xen_kpm_page(hat_getpfnum(kas.a_hat, lva),
1149843e1988Sjohnlev pt_bits)) != 0)
1150843e1988Sjohnlev break;
1151843e1988Sjohnlev lva += PAGESIZE;
1152843e1988Sjohnlev }
1153843e1988Sjohnlev
1154843e1988Sjohnlev done:
1155843e1988Sjohnlev if (err) {
1156843e1988Sjohnlev cmn_err(CE_WARN, "xen_ldt_setprot(%p, %s) failed: error %d",
1157843e1988Sjohnlev (void *)lva,
1158843e1988Sjohnlev (prot & PROT_WRITE) ? "writable" : "read-only", err);
1159843e1988Sjohnlev }
1160843e1988Sjohnlev
1161843e1988Sjohnlev return (err);
1162843e1988Sjohnlev }
1163e4b86885SCheng Sean Ye
1164e4b86885SCheng Sean Ye int
xen_get_mc_physcpuinfo(xen_mc_logical_cpu_t * log_cpus,uint_t * ncpus)1165e4b86885SCheng Sean Ye xen_get_mc_physcpuinfo(xen_mc_logical_cpu_t *log_cpus, uint_t *ncpus)
1166e4b86885SCheng Sean Ye {
1167ad09f8b8SMark Johnson xen_mc_t xmc;
1168ad09f8b8SMark Johnson struct xen_mc_physcpuinfo *cpi = &xmc.u.mc_physcpuinfo;
1169e4b86885SCheng Sean Ye
1170ad09f8b8SMark Johnson cpi->ncpus = *ncpus;
1171e4b86885SCheng Sean Ye /*LINTED: constant in conditional context*/
1172ad09f8b8SMark Johnson set_xen_guest_handle(cpi->info, log_cpus);
1173e4b86885SCheng Sean Ye
1174ad09f8b8SMark Johnson if (HYPERVISOR_mca(XEN_MC_physcpuinfo, &xmc) != 0)
1175e4b86885SCheng Sean Ye return (-1);
1176e4b86885SCheng Sean Ye
1177ad09f8b8SMark Johnson *ncpus = cpi->ncpus;
1178e4b86885SCheng Sean Ye return (0);
1179e4b86885SCheng Sean Ye }
1180e4b86885SCheng Sean Ye
1181e4b86885SCheng Sean Ye void
print_panic(const char * str)1182e4b86885SCheng Sean Ye print_panic(const char *str)
1183e4b86885SCheng Sean Ye {
1184e4b86885SCheng Sean Ye xen_printf(str);
1185e4b86885SCheng Sean Ye }
1186e4b86885SCheng Sean Ye
1187e4b86885SCheng Sean Ye /*
1188e4b86885SCheng Sean Ye * Interfaces to iterate over real cpu information, but only that info
1189e4b86885SCheng Sean Ye * which we choose to expose here. These are of interest to dom0
1190e4b86885SCheng Sean Ye * only (and the backing hypercall should not work for domu).
1191e4b86885SCheng Sean Ye */
1192e4b86885SCheng Sean Ye
1193e4b86885SCheng Sean Ye xen_mc_lcpu_cookie_t
xen_physcpu_next(xen_mc_lcpu_cookie_t cookie)1194e4b86885SCheng Sean Ye xen_physcpu_next(xen_mc_lcpu_cookie_t cookie)
1195e4b86885SCheng Sean Ye {
1196e4b86885SCheng Sean Ye xen_mc_logical_cpu_t *xcp = (xen_mc_logical_cpu_t *)cookie;
1197e4b86885SCheng Sean Ye
1198e4b86885SCheng Sean Ye if (!DOMAIN_IS_INITDOMAIN(xen_info))
1199e4b86885SCheng Sean Ye return (NULL);
1200e4b86885SCheng Sean Ye
1201e4b86885SCheng Sean Ye if (cookie == NULL)
1202e4b86885SCheng Sean Ye return ((xen_mc_lcpu_cookie_t)xen_phys_cpus);
1203e4b86885SCheng Sean Ye
1204e4b86885SCheng Sean Ye if (xcp == xen_phys_cpus + xen_phys_ncpus - 1)
1205e4b86885SCheng Sean Ye return (NULL);
1206e4b86885SCheng Sean Ye else
1207e4b86885SCheng Sean Ye return ((xen_mc_lcpu_cookie_t)++xcp);
1208e4b86885SCheng Sean Ye }
1209e4b86885SCheng Sean Ye
1210e4b86885SCheng Sean Ye #define COOKIE2XCP(c) ((xen_mc_logical_cpu_t *)(c))
1211e4b86885SCheng Sean Ye
1212e4b86885SCheng Sean Ye const char *
xen_physcpu_vendorstr(xen_mc_lcpu_cookie_t cookie)1213e4b86885SCheng Sean Ye xen_physcpu_vendorstr(xen_mc_lcpu_cookie_t cookie)
1214e4b86885SCheng Sean Ye {
1215e4b86885SCheng Sean Ye xen_mc_logical_cpu_t *xcp = COOKIE2XCP(cookie);
1216e4b86885SCheng Sean Ye
1217e4b86885SCheng Sean Ye return ((const char *)&xcp->mc_vendorid[0]);
1218e4b86885SCheng Sean Ye }
1219e4b86885SCheng Sean Ye
1220e4b86885SCheng Sean Ye int
xen_physcpu_family(xen_mc_lcpu_cookie_t cookie)1221e4b86885SCheng Sean Ye xen_physcpu_family(xen_mc_lcpu_cookie_t cookie)
1222e4b86885SCheng Sean Ye {
1223e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_family);
1224e4b86885SCheng Sean Ye }
1225e4b86885SCheng Sean Ye
1226e4b86885SCheng Sean Ye int
xen_physcpu_model(xen_mc_lcpu_cookie_t cookie)1227e4b86885SCheng Sean Ye xen_physcpu_model(xen_mc_lcpu_cookie_t cookie)
1228e4b86885SCheng Sean Ye {
1229e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_model);
1230e4b86885SCheng Sean Ye }
1231e4b86885SCheng Sean Ye
1232e4b86885SCheng Sean Ye int
xen_physcpu_stepping(xen_mc_lcpu_cookie_t cookie)1233e4b86885SCheng Sean Ye xen_physcpu_stepping(xen_mc_lcpu_cookie_t cookie)
1234e4b86885SCheng Sean Ye {
1235e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_step);
1236e4b86885SCheng Sean Ye }
1237e4b86885SCheng Sean Ye
1238e4b86885SCheng Sean Ye id_t
xen_physcpu_chipid(xen_mc_lcpu_cookie_t cookie)1239e4b86885SCheng Sean Ye xen_physcpu_chipid(xen_mc_lcpu_cookie_t cookie)
1240e4b86885SCheng Sean Ye {
1241e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_chipid);
1242e4b86885SCheng Sean Ye }
1243e4b86885SCheng Sean Ye
1244e4b86885SCheng Sean Ye id_t
xen_physcpu_coreid(xen_mc_lcpu_cookie_t cookie)1245e4b86885SCheng Sean Ye xen_physcpu_coreid(xen_mc_lcpu_cookie_t cookie)
1246e4b86885SCheng Sean Ye {
1247e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_coreid);
1248e4b86885SCheng Sean Ye }
1249e4b86885SCheng Sean Ye
1250e4b86885SCheng Sean Ye id_t
xen_physcpu_strandid(xen_mc_lcpu_cookie_t cookie)1251e4b86885SCheng Sean Ye xen_physcpu_strandid(xen_mc_lcpu_cookie_t cookie)
1252e4b86885SCheng Sean Ye {
1253e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_threadid);
1254e4b86885SCheng Sean Ye }
1255e4b86885SCheng Sean Ye
1256e4b86885SCheng Sean Ye id_t
xen_physcpu_initial_apicid(xen_mc_lcpu_cookie_t cookie)1257074bb90dSTom Pothier xen_physcpu_initial_apicid(xen_mc_lcpu_cookie_t cookie)
1258074bb90dSTom Pothier {
1259074bb90dSTom Pothier return (COOKIE2XCP(cookie)->mc_clusterid);
1260074bb90dSTom Pothier }
1261074bb90dSTom Pothier
1262074bb90dSTom Pothier id_t
xen_physcpu_logical_id(xen_mc_lcpu_cookie_t cookie)1263e4b86885SCheng Sean Ye xen_physcpu_logical_id(xen_mc_lcpu_cookie_t cookie)
1264e4b86885SCheng Sean Ye {
1265e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_cpunr);
1266e4b86885SCheng Sean Ye }
1267e4b86885SCheng Sean Ye
1268e4b86885SCheng Sean Ye boolean_t
xen_physcpu_is_cmt(xen_mc_lcpu_cookie_t cookie)1269e4b86885SCheng Sean Ye xen_physcpu_is_cmt(xen_mc_lcpu_cookie_t cookie)
1270e4b86885SCheng Sean Ye {
1271e4b86885SCheng Sean Ye return (COOKIE2XCP(cookie)->mc_nthreads > 1);
1272e4b86885SCheng Sean Ye }
1273e4b86885SCheng Sean Ye
1274e4b86885SCheng Sean Ye uint64_t
xen_physcpu_mcg_cap(xen_mc_lcpu_cookie_t cookie)1275e4b86885SCheng Sean Ye xen_physcpu_mcg_cap(xen_mc_lcpu_cookie_t cookie)
1276e4b86885SCheng Sean Ye {
1277e4b86885SCheng Sean Ye xen_mc_logical_cpu_t *xcp = COOKIE2XCP(cookie);
1278e4b86885SCheng Sean Ye
1279e4b86885SCheng Sean Ye /*
1280e4b86885SCheng Sean Ye * Need to #define the indices, or search through the array.
1281e4b86885SCheng Sean Ye */
1282e4b86885SCheng Sean Ye return (xcp->mc_msrvalues[0].value);
1283e4b86885SCheng Sean Ye }
12847eea693dSMark Johnson
12857eea693dSMark Johnson int
xen_map_gref(uint_t cmd,gnttab_map_grant_ref_t * mapop,uint_t count,boolean_t uvaddr)12867eea693dSMark Johnson xen_map_gref(uint_t cmd, gnttab_map_grant_ref_t *mapop, uint_t count,
12877eea693dSMark Johnson boolean_t uvaddr)
12887eea693dSMark Johnson {
12897eea693dSMark Johnson long rc;
1290349b53ddSStuart Maybee uint_t i;
12917eea693dSMark Johnson
12927eea693dSMark Johnson ASSERT(cmd == GNTTABOP_map_grant_ref);
12937eea693dSMark Johnson
12947eea693dSMark Johnson #if !defined(_BOOT)
1295349b53ddSStuart Maybee if (uvaddr == B_FALSE) {
12967eea693dSMark Johnson for (i = 0; i < count; ++i) {
1297349b53ddSStuart Maybee mapop[i].flags |= (PT_FOREIGN <<_GNTMAP_guest_avail0);
12987eea693dSMark Johnson }
12997eea693dSMark Johnson }
13007eea693dSMark Johnson #endif
13017eea693dSMark Johnson
1302349b53ddSStuart Maybee rc = HYPERVISOR_grant_table_op(cmd, mapop, count);
1303349b53ddSStuart Maybee
13047eea693dSMark Johnson return (rc);
13057eea693dSMark Johnson }
1306349b53ddSStuart Maybee
1307349b53ddSStuart Maybee static int
xpv_get_physinfo(xen_sysctl_physinfo_t * pi)1308349b53ddSStuart Maybee xpv_get_physinfo(xen_sysctl_physinfo_t *pi)
1309349b53ddSStuart Maybee {
1310349b53ddSStuart Maybee xen_sysctl_t op;
1311349b53ddSStuart Maybee struct sp { void *p; } *sp = (struct sp *)&op.u.physinfo.cpu_to_node;
1312349b53ddSStuart Maybee int ret;
1313349b53ddSStuart Maybee
1314349b53ddSStuart Maybee bzero(&op, sizeof (op));
1315349b53ddSStuart Maybee op.cmd = XEN_SYSCTL_physinfo;
1316349b53ddSStuart Maybee op.interface_version = XEN_SYSCTL_INTERFACE_VERSION;
1317349b53ddSStuart Maybee /*LINTED: constant in conditional context*/
1318349b53ddSStuart Maybee set_xen_guest_handle(*sp, NULL);
1319349b53ddSStuart Maybee
1320349b53ddSStuart Maybee ret = HYPERVISOR_sysctl(&op);
1321349b53ddSStuart Maybee
1322349b53ddSStuart Maybee if (ret != 0)
1323349b53ddSStuart Maybee return (xen_xlate_errcode(ret));
1324349b53ddSStuart Maybee
1325349b53ddSStuart Maybee bcopy(&op.u.physinfo, pi, sizeof (op.u.physinfo));
1326349b53ddSStuart Maybee return (0);
1327349b53ddSStuart Maybee }
1328349b53ddSStuart Maybee
1329349b53ddSStuart Maybee /*
1330349b53ddSStuart Maybee * On dom0, we can determine the number of physical cpus on the machine.
1331349b53ddSStuart Maybee * This number is important when figuring out what workarounds are
1332349b53ddSStuart Maybee * appropriate, so compute it now.
1333349b53ddSStuart Maybee */
1334349b53ddSStuart Maybee uint_t
xpv_nr_phys_cpus(void)1335349b53ddSStuart Maybee xpv_nr_phys_cpus(void)
1336349b53ddSStuart Maybee {
1337349b53ddSStuart Maybee static uint_t nphyscpus = 0;
1338349b53ddSStuart Maybee
1339349b53ddSStuart Maybee ASSERT(DOMAIN_IS_INITDOMAIN(xen_info));
1340349b53ddSStuart Maybee
1341349b53ddSStuart Maybee if (nphyscpus == 0) {
1342349b53ddSStuart Maybee xen_sysctl_physinfo_t pi;
1343349b53ddSStuart Maybee int ret;
1344349b53ddSStuart Maybee
1345349b53ddSStuart Maybee if ((ret = xpv_get_physinfo(&pi)) != 0)
1346349b53ddSStuart Maybee panic("xpv_get_physinfo() failed: %d\n", ret);
1347349b53ddSStuart Maybee nphyscpus = pi.nr_cpus;
1348349b53ddSStuart Maybee }
1349349b53ddSStuart Maybee return (nphyscpus);
1350349b53ddSStuart Maybee }
1351349b53ddSStuart Maybee
1352349b53ddSStuart Maybee pgcnt_t
xpv_nr_phys_pages(void)1353349b53ddSStuart Maybee xpv_nr_phys_pages(void)
1354349b53ddSStuart Maybee {
1355349b53ddSStuart Maybee xen_sysctl_physinfo_t pi;
1356349b53ddSStuart Maybee int ret;
1357349b53ddSStuart Maybee
1358349b53ddSStuart Maybee ASSERT(DOMAIN_IS_INITDOMAIN(xen_info));
1359349b53ddSStuart Maybee
1360349b53ddSStuart Maybee if ((ret = xpv_get_physinfo(&pi)) != 0)
1361349b53ddSStuart Maybee panic("xpv_get_physinfo() failed: %d\n", ret);
1362349b53ddSStuart Maybee
1363349b53ddSStuart Maybee return ((pgcnt_t)pi.total_pages);
1364349b53ddSStuart Maybee }
1365349b53ddSStuart Maybee
1366349b53ddSStuart Maybee uint64_t
xpv_cpu_khz(void)1367349b53ddSStuart Maybee xpv_cpu_khz(void)
1368349b53ddSStuart Maybee {
1369349b53ddSStuart Maybee xen_sysctl_physinfo_t pi;
1370349b53ddSStuart Maybee int ret;
1371349b53ddSStuart Maybee
1372349b53ddSStuart Maybee ASSERT(DOMAIN_IS_INITDOMAIN(xen_info));
1373349b53ddSStuart Maybee
1374349b53ddSStuart Maybee if ((ret = xpv_get_physinfo(&pi)) != 0)
1375349b53ddSStuart Maybee panic("xpv_get_physinfo() failed: %d\n", ret);
1376349b53ddSStuart Maybee return ((uint64_t)pi.cpu_khz);
1377349b53ddSStuart Maybee }
1378