xref: /titanic_44/usr/src/uts/i86xpv/os/xpv_panic.c (revision 21bf64a78855d076f09716ea1c06175d954e934c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <sys/types.h>
30 #include <sys/clock.h>
31 #include <sys/psm.h>
32 #include <sys/archsystm.h>
33 #include <sys/machsystm.h>
34 #include <sys/compress.h>
35 #include <sys/modctl.h>
36 #include <sys/trap.h>
37 #include <sys/panic.h>
38 #include <sys/regset.h>
39 #include <sys/frame.h>
40 #include <sys/kobj.h>
41 #include <sys/apic.h>
42 #include <sys/dumphdr.h>
43 #include <sys/mem.h>
44 #include <sys/x86_archext.h>
45 #include <sys/xpv_panic.h>
46 #include <sys/boot_console.h>
47 #include <sys/bootsvcs.h>
48 #include <sys/consdev.h>
49 #include <vm/hat_pte.h>
50 #include <vm/hat_i86.h>
51 
52 /* XXX: need to add a PAE version too, if we ever support both PAE and non */
53 #if defined(__i386)
54 #define	XPV_FILENAME	"/boot/xen-syms"
55 #else
56 #define	XPV_FILENAME	"/boot/amd64/xen-syms"
57 #endif
58 #define	XPV_MODNAME	"xpv"
59 
60 int xpv_panicking = 0;
61 
62 struct module *xpv_module;
63 struct modctl *xpv_modctl;
64 
65 #define	ALIGN(x, a)	((a) == 0 ? (uintptr_t)(x) : \
66 	(((uintptr_t)(x) + (uintptr_t)(a) - 1l) & ~((uintptr_t)(a) - 1l)))
67 
68 /* Pointer to the xpv_panic_info structure handed to us by Xen.  */
69 static struct panic_info *xpv_panic_info = NULL;
70 
71 /* Timer support */
72 #define	NSEC_SHIFT 5
73 #define	T_XPV_TIMER	0xd1
74 #define	XPV_TIMER_INTERVAL	1000	/* 1000 microseconds */
75 static uint32_t *xpv_apicadr = NULL;
76 static uint_t	nsec_scale;
77 
78 /* IDT support */
79 #pragma	align	16(xpv_panic_idt)
80 static gate_desc_t	xpv_panic_idt[NIDT];	/* interrupt descriptor table */
81 
82 /* Xen pagetables mapped into our HAT's ptable windows */
83 static pfn_t ptable_pfn[MAX_NUM_LEVEL];
84 
85 /* Number of MMU_PAGESIZE pages we're adding to the Solaris dump */
86 static int xpv_dump_pages;
87 
88 /*
89  * There are up to two large swathes of RAM that we don't want to include
90  * in the dump: those that comprise the Xen version of segkpm.  On 32-bit
91  * systems there is no such region of memory.  On 64-bit systems, there
92  * should be just a single contiguous region that corresponds to all of
93  * physical memory.  The tricky bit is that Xen's heap sometimes lives in
94  * the middle of their segkpm, and is mapped using only kpm-like addresses.
95  * In that case, we need to skip the swathes before and after Xen's heap.
96  */
97 uintptr_t kpm1_low = 0;
98 uintptr_t kpm1_high = 0;
99 uintptr_t kpm2_low = 0;
100 uintptr_t kpm2_high = 0;
101 
102 /*
103  * Some commonly used values that we don't want to recompute over and over.
104  */
105 static int xpv_panic_nptes[MAX_NUM_LEVEL];
106 static ulong_t xpv_panic_cr3;
107 static uintptr_t xpv_end;
108 
109 static void xpv_panic_console_print(const char *fmt, ...);
110 static void (*xpv_panic_printf)(const char *, ...) = xpv_panic_console_print;
111 
112 #define	CONSOLE_BUF_SIZE	256
113 static char console_buffer[CONSOLE_BUF_SIZE];
114 static boolean_t use_polledio;
115 
116 static void
117 xpv_panic_putc(int m)
118 {
119 	struct cons_polledio *c = cons_polledio;
120 
121 	/* This really shouldn't happen */
122 	if (console == CONS_HYPERVISOR)
123 		return;
124 
125 	if (use_polledio == B_TRUE)
126 		c->cons_polledio_putchar(c->cons_polledio_argument, m);
127 	else
128 		bcons_putchar(m);
129 }
130 
131 static void
132 xpv_panic_puts(char *msg)
133 {
134 	char *m;
135 
136 	dump_timeleft = dump_timeout;
137 	for (m = msg; *m; m++)
138 		xpv_panic_putc((int)*m);
139 }
140 
141 static void
142 xpv_panic_console_print(const char *fmt, ...)
143 {
144 	va_list ap;
145 
146 	va_start(ap, fmt);
147 	(void) vsnprintf(console_buffer, sizeof (console_buffer), fmt, ap);
148 	va_end(ap);
149 
150 	xpv_panic_puts(console_buffer);
151 }
152 
153 static void
154 xpv_panic_map(int level, pfn_t pfn)
155 {
156 	x86pte_t pte, *pteptr;
157 
158 	/*
159 	 * The provided pfn represents a level 'level' page table.  Map it
160 	 * into the 'level' slot in the list of page table windows.
161 	 */
162 	pteptr = (x86pte_t *)PWIN_PTE_VA(level);
163 	pte = pfn_to_pa(pfn) | PT_VALID;
164 
165 	XPV_ALLOW_PAGETABLE_UPDATES();
166 	if (mmu.pae_hat)
167 		*pteptr = pte;
168 	else
169 		*(x86pte32_t *)pteptr = pte;
170 	XPV_DISALLOW_PAGETABLE_UPDATES();
171 
172 	mmu_tlbflush_entry(PWIN_VA(level));
173 }
174 
175 /*
176  * Walk the page tables to find the pfn mapped by the given va.
177  */
178 static pfn_t
179 xpv_va_walk(uintptr_t *vaddr)
180 {
181 	int l, idx;
182 	pfn_t pfn;
183 	x86pte_t pte;
184 	x86pte_t *ptep;
185 	uintptr_t va = *vaddr;
186 	uintptr_t scan_va;
187 	caddr_t ptable_window;
188 	static pfn_t toplevel_pfn;
189 	static uintptr_t lastva;
190 
191 	/*
192 	 * If we do anything other than a simple scan through memory, don't
193 	 * trust the mapped page tables.
194 	 */
195 	if (va != lastva + MMU_PAGESIZE)
196 		for (l = mmu.max_level; l >= 0; l--)
197 			ptable_pfn[l] = PFN_INVALID;
198 
199 	toplevel_pfn = mmu_btop(xpv_panic_cr3);
200 
201 	while (va < xpv_end && va >= *vaddr) {
202 		/* Find the lowest table with any entry for va */
203 		pfn = toplevel_pfn;
204 		for (l = mmu.max_level; l >= 0; l--) {
205 			if (ptable_pfn[l] != pfn) {
206 				xpv_panic_map(l, pfn);
207 				ptable_pfn[l] = pfn;
208 			}
209 
210 			/*
211 			 * Search this pagetable for any mapping to an
212 			 * address >= va.
213 			 */
214 			ptable_window = PWIN_VA(l);
215 			if (l == mmu.max_level && mmu.pae_hat)
216 				ptable_window +=
217 				    (xpv_panic_cr3 & MMU_PAGEOFFSET);
218 
219 			idx = (va >> LEVEL_SHIFT(l)) & (xpv_panic_nptes[l] - 1);
220 			scan_va = va;
221 			while (idx < xpv_panic_nptes[l] && scan_va < xpv_end &&
222 			    scan_va >= *vaddr) {
223 				ptep = (x86pte_t *)(ptable_window +
224 				    (idx << mmu.pte_size_shift));
225 				pte = GET_PTE(ptep);
226 				if (pte & PTE_VALID)
227 					break;
228 				idx++;
229 				scan_va += mmu.level_size[l];
230 			}
231 
232 			/*
233 			 * If there are no valid mappings in this table, we
234 			 * can skip to the end of the VA range it covers.
235 			 */
236 			if (idx == xpv_panic_nptes[l]) {
237 				va = NEXT_ENTRY_VA(va, l + 1);
238 				break;
239 			}
240 
241 			va = scan_va;
242 			/*
243 			 * See if we've hit the end of the range.
244 			 */
245 			if (va >= xpv_end || va < *vaddr)
246 				break;
247 
248 			/*
249 			 * If this mapping is for a pagetable, we drop down
250 			 * to the next level in the hierarchy and look for
251 			 * a mapping in it.
252 			 */
253 			pfn = PTE2MFN(pte, l);
254 			if (!PTE_ISPAGE(pte, l))
255 				continue;
256 
257 			/*
258 			 * The APIC page is magic.  Nothing to see here;
259 			 * move along.
260 			 */
261 			if (((uintptr_t)xpv_apicadr & MMU_PAGEMASK) ==
262 			    (va & MMU_PAGEMASK)) {
263 				va += MMU_PAGESIZE;
264 				break;
265 			}
266 
267 			/*
268 			 * See if the address is within one of the two
269 			 * kpm-like regions we want to skip.
270 			 */
271 			if (va >= kpm1_low && va < kpm1_high) {
272 				va = kpm1_high;
273 				break;
274 			}
275 			if (va >= kpm2_low && va < kpm2_high) {
276 				va = kpm2_high;
277 				break;
278 			}
279 
280 			/*
281 			 * The Xen panic code only handles small pages.  If
282 			 * this mapping is for a large page, we need to
283 			 * identify the consituent page that covers the
284 			 * specific VA we were looking for.
285 			 */
286 			if (l > 0) {
287 				if (l > 1)
288 					panic("Xen panic can't cope with "
289 					    "giant pages.");
290 				idx = (va >> LEVEL_SHIFT(0)) &
291 				    (xpv_panic_nptes[0] - 1);
292 				pfn += idx;
293 			}
294 
295 			*vaddr = va;
296 			lastva = va;
297 			return (pfn | PFN_IS_FOREIGN_MFN);
298 		}
299 	}
300 	return (PFN_INVALID);
301 }
302 
303 /*
304  * Walk through the Xen VA space, finding pages that are mapped in.
305  *
306  * These pages all have MFNs rather than PFNs, meaning they may be outside
307  * the physical address space the kernel knows about, or they may collide
308  * with PFNs the kernel is using.
309  *
310  * The obvious trick of just adding the PFN_IS_FOREIGN_MFN bit to the MFNs
311  * to avoid collisions doesn't work.  The pages need to be written to disk
312  * in PFN-order or savecore gets confused.  We can't allocate memory to
313  * contruct a sorted pfn->VA reverse mapping, so we have to write the pages
314  * to disk in VA order.
315  *
316  * To square this circle, we simply make up PFNs for each of Xen's pages.
317  * We assign each mapped page a fake PFN in ascending order.  These fake
318  * PFNs each have the FOREIGN bit set, ensuring that they fall outside the
319  * range of Solaris PFNs written by the kernel.
320  */
321 int
322 dump_xpv_addr()
323 {
324 	uintptr_t va;
325 	mem_vtop_t mem_vtop;
326 
327 	xpv_dump_pages = 0;
328 	va = xen_virt_start;
329 
330 	while (xpv_va_walk(&va) != PFN_INVALID) {
331 		mem_vtop.m_as = &kas;
332 		mem_vtop.m_va = (void *)va;
333 		mem_vtop.m_pfn = (pfn_t)xpv_dump_pages | PFN_IS_FOREIGN_MFN;
334 
335 		dumpvp_write(&mem_vtop, sizeof (mem_vtop_t));
336 		xpv_dump_pages++;
337 
338 		va += MMU_PAGESIZE;
339 	}
340 
341 	/*
342 	 * Add the shared_info page.  This page actually ends up in the
343 	 * dump twice: once for the Xen va and once for the Solaris va.
344 	 * This isn't ideal, but we don't know the address Xen is using for
345 	 * the page, so we can't share it.
346 	 */
347 	mem_vtop.m_as = &kas;
348 	mem_vtop.m_va = HYPERVISOR_shared_info;
349 	mem_vtop.m_pfn = (pfn_t)xpv_dump_pages | PFN_IS_FOREIGN_MFN;
350 	dumpvp_write(&mem_vtop, sizeof (mem_vtop_t));
351 	xpv_dump_pages++;
352 
353 	return (xpv_dump_pages);
354 }
355 
356 void
357 dump_xpv_pfn()
358 {
359 	pfn_t pfn;
360 	int cnt;
361 
362 	for (cnt = 0; cnt < xpv_dump_pages; cnt++) {
363 		pfn = (pfn_t)cnt | PFN_IS_FOREIGN_MFN;
364 		dumpvp_write(&pfn, sizeof (pfn));
365 	}
366 }
367 
368 int
369 dump_xpv_data(void *dump_cbuf)
370 {
371 	uintptr_t va;
372 	uint32_t csize;
373 	int cnt = 0;
374 
375 	/*
376 	 * XXX: we should probably run this data through a UE check.  The
377 	 * catch is that the UE code relies on on_trap() and getpfnum()
378 	 * working.
379 	 */
380 	va = xen_virt_start;
381 
382 	while (xpv_va_walk(&va) != PFN_INVALID) {
383 		csize = (uint32_t)compress((void *)va, dump_cbuf, PAGESIZE);
384 		dumpvp_write(&csize, sizeof (uint32_t));
385 		dumpvp_write(dump_cbuf, csize);
386 		if (dump_ioerr) {
387 			dumphdr->dump_flags &= ~DF_COMPLETE;
388 			return (cnt);
389 		}
390 		cnt++;
391 		va += MMU_PAGESIZE;
392 	}
393 
394 	/*
395 	 * Finally, dump the shared_info page
396 	 */
397 	csize = (uint32_t)compress((void *)HYPERVISOR_shared_info, dump_cbuf,
398 	    PAGESIZE);
399 	dumpvp_write(&csize, sizeof (uint32_t));
400 	dumpvp_write(dump_cbuf, csize);
401 	if (dump_ioerr)
402 		dumphdr->dump_flags &= ~DF_COMPLETE;
403 	cnt++;
404 
405 	return (cnt);
406 }
407 
408 static void *
409 showstack(void *fpreg, int xpv_only)
410 {
411 	struct frame *fpp;
412 	ulong_t off;
413 	char *sym;
414 	uintptr_t pc, fp, lastfp;
415 	uintptr_t minaddr = min(KERNELBASE, xen_virt_start);
416 
417 	fp = (uintptr_t)fpreg;
418 	if (fp < minaddr) {
419 		xpv_panic_printf("Bad frame ptr: 0x%p\n", fpreg);
420 		return (fpreg);
421 	}
422 
423 	do {
424 		fpp = (struct frame *)fp;
425 		pc = fpp->fr_savpc;
426 
427 		if ((xpv_only != 0) &&
428 		    (fp > xpv_end || fp < xen_virt_start))
429 			break;
430 		if ((sym = kobj_getsymname(pc, &off)) != NULL)
431 			xpv_panic_printf("%08lx %s:%s+%lx\n", fp,
432 			    mod_containing_pc((caddr_t)pc), sym, off);
433 		else if ((pc >= xen_virt_start) && (pc <= xpv_end))
434 			xpv_panic_printf("%08lx 0x%lx (in Xen)\n", fp, pc);
435 		else
436 			xpv_panic_printf("%08lx %lx\n", fp, pc);
437 
438 		lastfp = fp;
439 		fp = fpp->fr_savfp;
440 
441 		/*
442 		 * Xen marks an exception frame by inverting the frame
443 		 * pointer.
444 		 */
445 		if (fp < lastfp) {
446 			if ((~fp > minaddr) && ((~fp) ^ lastfp) < 0xfff)
447 				fp = ~fp;
448 		}
449 	} while (fp > lastfp);
450 	return ((void *)fp);
451 }
452 
453 void *
454 xpv_traceback(void *fpreg)
455 {
456 	return (showstack(fpreg, 1));
457 }
458 
459 #if defined(__amd64)
460 static void
461 xpv_panic_hypercall(ulong_t call)
462 {
463 	panic("Illegally issued hypercall %d during panic!\n", (int)call);
464 }
465 #endif
466 
467 void
468 xpv_die(struct regs *rp)
469 {
470 	struct panic_trap_info ti;
471 	struct cregs creg;
472 
473 	ti.trap_regs = rp;
474 	ti.trap_type = rp->r_trapno;
475 
476 	curthread->t_panic_trap = &ti;
477 	if (ti.trap_type == T_PGFLT) {
478 		getcregs(&creg);
479 		ti.trap_addr = (caddr_t)creg.cr_cr2;
480 		panic("Fatal pagefault at 0x%lx.  fault addr=0x%p  rp=0x%p",
481 		    rp->r_pc, ti.trap_addr, rp);
482 	} else {
483 		ti.trap_addr = (caddr_t)rp->r_pc;
484 		panic("Fatal trap %ld at 0x%lx.  rp=0x%p", rp->r_trapno,
485 		    rp->r_pc, rp);
486 	}
487 }
488 
489 /*
490  * Build IDT to handle a Xen panic
491  */
492 static void
493 switch_to_xpv_panic_idt()
494 {
495 	int i;
496 	desctbr_t idtr;
497 	gate_desc_t *idt = xpv_panic_idt;
498 	selector_t cs = get_cs_register();
499 
500 	for (i = 0; i < 32; i++)
501 		set_gatesegd(&idt[i], &xpv_invaltrap, cs, SDT_SYSIGT, TRP_XPL);
502 
503 	set_gatesegd(&idt[T_ZERODIV], &xpv_div0trap, cs, SDT_SYSIGT, TRP_XPL);
504 	set_gatesegd(&idt[T_SGLSTP], &xpv_dbgtrap, cs, SDT_SYSIGT, TRP_XPL);
505 	set_gatesegd(&idt[T_NMIFLT], &xpv_nmiint, cs, SDT_SYSIGT, TRP_XPL);
506 	set_gatesegd(&idt[T_BOUNDFLT], &xpv_boundstrap, cs, SDT_SYSIGT,
507 	    TRP_XPL);
508 	set_gatesegd(&idt[T_ILLINST], &xpv_invoptrap, cs, SDT_SYSIGT, TRP_XPL);
509 	set_gatesegd(&idt[T_NOEXTFLT], &xpv_ndptrap, cs, SDT_SYSIGT, TRP_XPL);
510 	set_gatesegd(&idt[T_TSSFLT], &xpv_invtsstrap, cs, SDT_SYSIGT, TRP_XPL);
511 	set_gatesegd(&idt[T_SEGFLT], &xpv_segnptrap, cs, SDT_SYSIGT, TRP_XPL);
512 	set_gatesegd(&idt[T_STKFLT], &xpv_stktrap, cs, SDT_SYSIGT, TRP_XPL);
513 	set_gatesegd(&idt[T_GPFLT], &xpv_gptrap, cs, SDT_SYSIGT, TRP_XPL);
514 	set_gatesegd(&idt[T_PGFLT], &xpv_pftrap, cs, SDT_SYSIGT, TRP_XPL);
515 	set_gatesegd(&idt[T_EXTERRFLT], &xpv_ndperr, cs, SDT_SYSIGT, TRP_XPL);
516 	set_gatesegd(&idt[T_ALIGNMENT], &xpv_achktrap, cs, SDT_SYSIGT, TRP_XPL);
517 	set_gatesegd(&idt[T_MCE], &xpv_mcetrap, cs, SDT_SYSIGT, TRP_XPL);
518 	set_gatesegd(&idt[T_SIMDFPE], &xpv_xmtrap, cs, SDT_SYSIGT, TRP_XPL);
519 
520 	/*
521 	 * We have no double fault handler.  Any single fault represents a
522 	 * catastrophic failure for us, so there is no attempt to handle
523 	 * them cleanly: we just print a message and reboot.  If we
524 	 * encounter a second fault while doing that, there is nothing
525 	 * else we can do.
526 	 */
527 
528 	/*
529 	 * Be prepared to absorb any stray device interrupts received
530 	 * while writing the core to disk.
531 	 */
532 	for (i = 33; i < NIDT; i++)
533 		set_gatesegd(&idt[i], &xpv_surprise_intr, cs, SDT_SYSIGT,
534 		    TRP_XPL);
535 
536 	/* The one interrupt we expect to get is from the APIC timer.  */
537 	set_gatesegd(&idt[T_XPV_TIMER], &xpv_timer_trap, cs, SDT_SYSIGT,
538 	    TRP_XPL);
539 
540 	idtr.dtr_base = (uintptr_t)xpv_panic_idt;
541 	idtr.dtr_limit = sizeof (xpv_panic_idt) - 1;
542 	wr_idtr(&idtr);
543 
544 #if defined(__amd64)
545 	/* Catch any hypercalls. */
546 	wrmsr(MSR_AMD_LSTAR, (uintptr_t)xpv_panic_hypercall);
547 	wrmsr(MSR_AMD_CSTAR, (uintptr_t)xpv_panic_hypercall);
548 #endif
549 }
550 
551 static void
552 xpv_apic_clkinit()
553 {
554 	uint_t		apic_ticks = 0;
555 
556 	/*
557 	 * Measure how many APIC ticks there are within a fixed time
558 	 * period.  We're going to be fairly coarse here.  This timer is
559 	 * just being used to detect a stalled panic, so as long as we have
560 	 * the right order of magnitude, everything should be fine.
561 	 */
562 	xpv_apicadr[APIC_SPUR_INT_REG] = AV_UNIT_ENABLE | APIC_SPUR_INTR;
563 	xpv_apicadr[APIC_LOCAL_TIMER] = AV_MASK;
564 	xpv_apicadr[APIC_INT_VECT0] = AV_MASK;	/* local intr reg 0 */
565 
566 	xpv_apicadr[APIC_DIVIDE_REG] = 0;
567 	xpv_apicadr[APIC_INIT_COUNT] = APIC_MAXVAL;
568 	drv_usecwait(XPV_TIMER_INTERVAL);
569 	apic_ticks = APIC_MAXVAL - xpv_apicadr[APIC_CURR_COUNT];
570 
571 	/*
572 	 * apic_ticks now represents roughly how many apic ticks comprise
573 	 * one timeout interval.  Program the timer to send us an interrupt
574 	 * every time that interval expires.
575 	 */
576 	xpv_apicadr[APIC_LOCAL_TIMER] = T_XPV_TIMER | AV_TIME;
577 	xpv_apicadr[APIC_INIT_COUNT] = apic_ticks;
578 	xpv_apicadr[APIC_EOI_REG] = 0;
579 }
580 
581 void
582 xpv_timer_tick(void)
583 {
584 	static int ticks = 0;
585 
586 	if (ticks++ >= MICROSEC / XPV_TIMER_INTERVAL) {
587 		ticks = 0;
588 		if (dump_timeleft && (--dump_timeleft == 0))
589 			panic("Xen panic timeout\n");
590 	}
591 	xpv_apicadr[APIC_EOI_REG] = 0;
592 }
593 
594 void
595 xpv_interrupt(void)
596 {
597 #ifdef	DEBUG
598 	static int cnt = 0;
599 
600 	if (cnt++ < 10)
601 		xpv_panic_printf("Unexpected interrupt received.\n");
602 	if ((cnt < 1000) && ((cnt % 100) == 0))
603 		xpv_panic_printf("%d unexpected interrupts received.\n", cnt);
604 #endif
605 
606 	xpv_apicadr[APIC_EOI_REG] = 0;
607 }
608 
609 /*
610  * Managing time in panic context is trivial.  We only have a single CPU,
611  * we never get rescheduled, we never get suspended.  We just need to
612  * convert clock ticks into nanoseconds.
613  */
614 static hrtime_t
615 xpv_panic_gethrtime(void)
616 {
617 	hrtime_t tsc, hrt;
618 	unsigned int *l = (unsigned int *)&(tsc);
619 
620 	tsc = __rdtsc_insn();
621 	hrt = (mul32(l[1], nsec_scale) << NSEC_SHIFT) +
622 	    (mul32(l[0], nsec_scale) >> (32 - NSEC_SHIFT));
623 
624 	return (hrt);
625 }
626 
627 static void
628 xpv_panic_time_init()
629 {
630 	nsec_scale =
631 	    CPU->cpu_m.mcpu_vcpu_info->time.tsc_to_system_mul >> NSEC_SHIFT;
632 
633 	gethrtimef = xpv_panic_gethrtime;
634 }
635 
636 static void
637 xpv_panicsys(struct regs *rp, char *fmt, ...)
638 {
639 	extern void panicsys(const char *, va_list, struct regs *, int);
640 	va_list alist;
641 
642 	va_start(alist, fmt);
643 	panicsys(fmt, alist, rp, 1);
644 	va_end(alist);
645 }
646 
647 void
648 xpv_do_panic(void *arg)
649 {
650 	struct panic_info *pip = (struct panic_info *)arg;
651 	int l;
652 	struct cregs creg;
653 #if defined(__amd64)
654 	extern uintptr_t postbootkernelbase;
655 #endif
656 
657 	if (xpv_panicking++ > 0)
658 		panic("multiple calls to xpv_do_panic()");
659 
660 	/*
661 	 * Indicate to the underlying panic framework that a panic has been
662 	 * initiated.  This is ordinarily done as part of vpanic().  Since
663 	 * we already have all the register state saved by the hypervisor,
664 	 * we skip that and jump straight into the panic processing code.
665 	 */
666 	(void) panic_trigger(&panic_quiesce);
667 
668 #if defined(__amd64)
669 	/*
670 	 * bzero() and bcopy() get unhappy when asked to operate on
671 	 * addresses outside of the kernel.  At this point Xen is really a
672 	 * part of the kernel, so we update the routines' notion of where
673 	 * the kernel starts.
674 	 */
675 	postbootkernelbase = xen_virt_start;
676 #endif
677 
678 #if defined(HYPERVISOR_VIRT_END)
679 	xpv_end = HYPERVISOR_VIRT_END;
680 #else
681 	xpv_end = (uintptr_t)UINTPTR_MAX - sizeof (uintptr_t);
682 #endif
683 
684 	/*
685 	 * If we were redirecting console output to the hypervisor, we have
686 	 * to stop.
687 	 */
688 	use_polledio = B_FALSE;
689 	if (console == CONS_HYPERVISOR) {
690 		bcons_device_change(CONS_HYPERVISOR);
691 	} else if (cons_polledio != NULL &&
692 	    cons_polledio->cons_polledio_putchar != NULL)  {
693 		if (cons_polledio->cons_polledio_enter != NULL)
694 			cons_polledio->cons_polledio_enter(
695 			    cons_polledio->cons_polledio_argument);
696 		use_polledio = 1;
697 	}
698 
699 	/* Make sure we handle all console output from here on. */
700 	sysp->bsvc_putchar = xpv_panic_putc;
701 
702 	/*
703 	 * If we find an unsupported panic_info structure, there's not much
704 	 * we can do other than complain, plow on, and hope for the best.
705 	 */
706 	if (pip->pi_version != PANIC_INFO_VERSION)
707 		xpv_panic_printf("Warning: Xen is using an unsupported "
708 		    "version of the panic_info structure.\n");
709 
710 	xpv_panic_info = pip;
711 
712 #if defined(__amd64)
713 	kpm1_low = (uintptr_t)xpv_panic_info->pi_ram_start;
714 	if (xpv_panic_info->pi_xen_start == NULL) {
715 		kpm1_high = (uintptr_t)xpv_panic_info->pi_ram_end;
716 	} else {
717 		kpm1_high = (uintptr_t)xpv_panic_info->pi_xen_start;
718 		kpm2_low = (uintptr_t)xpv_panic_info->pi_xen_end;
719 		kpm2_high = (uintptr_t)xpv_panic_info->pi_ram_end;
720 	}
721 #endif
722 
723 	/*
724 	 * Make sure we are running on the Solaris %gs.  The Xen panic code
725 	 * should already have set up the GDT properly.
726 	 */
727 	xpv_panic_resetgs();
728 #if defined(__amd64)
729 	wrmsr(MSR_AMD_GSBASE, (uint64_t)&cpus[0]);
730 #endif
731 
732 	xpv_panic_time_init();
733 
734 	/*
735 	 * Switch to our own IDT, avoiding any accidental returns to Xen
736 	 * world.
737 	 */
738 	switch_to_xpv_panic_idt();
739 
740 	/*
741 	 * Initialize the APIC timer, which is used to detect a hung dump
742 	 * attempt.
743 	 */
744 	xpv_apicadr = pip->pi_apic;
745 	xpv_apic_clkinit();
746 
747 	/*
748 	 * Set up a few values that we'll need repeatedly.
749 	 */
750 	getcregs(&creg);
751 	xpv_panic_cr3 = creg.cr_cr3;
752 	for (l = mmu.max_level; l >= 0; l--)
753 		xpv_panic_nptes[l] = mmu.ptes_per_table;
754 #ifdef __i386
755 	if (mmu.pae_hat)
756 		xpv_panic_nptes[mmu.max_level] = 4;
757 #endif
758 
759 	/* Add the fake Xen module to the module list */
760 	if (xpv_module != NULL) {
761 		extern int last_module_id;
762 
763 		xpv_modctl->mod_id = last_module_id++;
764 		xpv_modctl->mod_next = &modules;
765 		xpv_modctl->mod_prev = modules.mod_prev;
766 		modules.mod_prev->mod_next = xpv_modctl;
767 		modules.mod_prev = xpv_modctl;
768 	}
769 	xpv_panic_printf = printf;
770 	xpv_panicsys((struct regs *)pip->pi_regs, pip->pi_panicstr);
771 	xpv_panic_printf("Failed to reboot following panic.\n");
772 	for (;;)
773 		;
774 }
775 
776 /*
777  * Set up the necessary data structures to pretend that the Xen hypervisor
778  * is a loadable module, allowing mdb to find the Xen symbols in a crash
779  * dump.  Since these symbols all map to VA space Solaris doesn't normally
780  * have access to, we don't link these structures into the kernel's lists
781  * until/unless we hit a Xen panic.
782  *
783  * The observant reader will note a striking amount of overlap between this
784  * code and that found in krtld.  While it would be handy if we could just
785  * ask krtld to do this work for us, it's not that simple.  Among the
786  * complications: we're not actually loading the text here (grub did it at
787  * boot), the .text section is writable, there are no relocations to do,
788  * none of the module text/data is in readable memory, etc.  Training krtld
789  * to deal with this weird module is as complicated, and more risky, than
790  * reimplementing the necessary subset of it here.
791  */
792 static void
793 init_xen_module()
794 {
795 	struct _buf *file = NULL;
796 	struct module *mp;
797 	struct modctl *mcp;
798 	int i, shn;
799 	Shdr *shp, *ctf_shp;
800 	char *names = NULL;
801 	size_t n, namesize, text_align, data_align;
802 #if defined(__amd64)
803 	const char machine = EM_AMD64;
804 #else
805 	const char machine = EM_386;
806 #endif
807 
808 	/* Allocate and init the module structure */
809 	mp = kmem_zalloc(sizeof (*mp), KM_SLEEP);
810 	mp->filename = kobj_zalloc(strlen(XPV_FILENAME) + 1, KM_SLEEP);
811 	(void) strcpy(mp->filename, XPV_FILENAME);
812 
813 	/* Allocate and init the modctl structure */
814 	mcp = kmem_zalloc(sizeof (*mcp), KM_SLEEP);
815 	mcp->mod_modname = kobj_zalloc(strlen(XPV_MODNAME) + 1, KM_SLEEP);
816 	(void) strcpy(mcp->mod_modname, XPV_MODNAME);
817 	mcp->mod_filename = kobj_zalloc(strlen(XPV_FILENAME) + 1, KM_SLEEP);
818 	(void) strcpy(mcp->mod_filename, XPV_FILENAME);
819 	mcp->mod_inprogress_thread = (kthread_id_t)-1;
820 	mcp->mod_ref = 1;
821 	mcp->mod_loaded = 1;
822 	mcp->mod_loadcnt = 1;
823 	mcp->mod_mp = mp;
824 
825 	/*
826 	 * Try to open a Xen image that hasn't had its symbol and CTF
827 	 * information stripped off.
828 	 */
829 	file = kobj_open_file(XPV_FILENAME);
830 	if (file == (struct _buf *)-1) {
831 		file = NULL;
832 		goto err;
833 	}
834 
835 	/*
836 	 * Read the header and ensure that this is an ELF file for the
837 	 * proper ISA.  If it's not, somebody has done something very
838 	 * stupid.  Why bother?  See Mencken.
839 	 */
840 	if (kobj_read_file(file, (char *)&mp->hdr, sizeof (mp->hdr), 0) < 0)
841 		goto err;
842 	for (i = 0; i < SELFMAG; i++)
843 		if (mp->hdr.e_ident[i] != ELFMAG[i])
844 			goto err;
845 	if ((mp->hdr.e_ident[EI_DATA] != ELFDATA2LSB) ||
846 	    (mp->hdr.e_machine != machine))
847 		goto err;
848 
849 	/* Read in the section headers */
850 	n = mp->hdr.e_shentsize * mp->hdr.e_shnum;
851 	mp->shdrs = kmem_zalloc(n, KM_SLEEP);
852 	if (kobj_read_file(file, mp->shdrs, n, mp->hdr.e_shoff) < 0)
853 		goto err;
854 
855 	/* Read the section names */
856 	shp = (Shdr *)(mp->shdrs + mp->hdr.e_shstrndx * mp->hdr.e_shentsize);
857 	namesize = shp->sh_size;
858 	names = kmem_zalloc(shp->sh_size, KM_SLEEP);
859 	if (kobj_read_file(file, names, shp->sh_size, shp->sh_offset) < 0)
860 		goto err;
861 
862 	/*
863 	 * Fill in the text and data size fields.
864 	 */
865 	ctf_shp = NULL;
866 	text_align = data_align = 0;
867 	for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
868 		shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize);
869 
870 		/* Sanity check the offset of the section name */
871 		if (shp->sh_name >= namesize)
872 			continue;
873 
874 		/* If we find the symtab section, remember it for later. */
875 		if (shp->sh_type == SHT_SYMTAB) {
876 			mp->symtbl_section = shn;
877 			mp->symhdr = shp;
878 			continue;
879 		}
880 
881 		/* If we find the CTF section, remember it for later. */
882 		if ((shp->sh_size != 0) &&
883 		    (strcmp(names + shp->sh_name, ".SUNW_ctf") == 0)) {
884 			ctf_shp = shp;
885 			continue;
886 		}
887 
888 		if (!(shp->sh_flags & SHF_ALLOC))
889 			continue;
890 
891 		/*
892 		 * Xen marks its text section as writable, so we need to
893 		 * look for the name - not just the flag.
894 		 */
895 		if ((strcmp(&names[shp->sh_name], ".text") != NULL) &&
896 		    (shp->sh_flags & SHF_WRITE) != 0) {
897 			if (shp->sh_addralign > data_align)
898 				data_align = shp->sh_addralign;
899 			mp->data_size = ALIGN(mp->data_size, data_align);
900 			mp->data_size += ALIGN(shp->sh_size, 8);
901 			if (mp->data == NULL || mp->data > (char *)shp->sh_addr)
902 				mp->data = (char *)shp->sh_addr;
903 		} else {
904 			if (shp->sh_addralign > text_align)
905 				text_align = shp->sh_addralign;
906 			mp->text_size = ALIGN(mp->text_size, text_align);
907 			mp->text_size += ALIGN(shp->sh_size, 8);
908 			if (mp->text == NULL || mp->text > (char *)shp->sh_addr)
909 				mp->text = (char *)shp->sh_addr;
910 		}
911 	}
912 	kmem_free(names, namesize);
913 	names = NULL;
914 	shp = NULL;
915 	mcp->mod_text = mp->text;
916 	mcp->mod_text_size = mp->text_size;
917 
918 	/*
919 	 * If we have symbol table and string table sections, read them in
920 	 * now.  If we don't, we just plow on.  We'll still get a valid
921 	 * core dump, but finding anything useful will be just a bit
922 	 * harder.
923 	 *
924 	 * Note: we don't bother with a hash table.  We'll never do a
925 	 * symbol lookup unless we crash, and then mdb creates its own.  We
926 	 * also don't try to perform any relocations.  Xen should be loaded
927 	 * exactly where the ELF file indicates, and the symbol information
928 	 * in the file should be complete and correct already.  Static
929 	 * linking ain't all bad.
930 	 */
931 	if ((mp->symhdr != NULL) && (mp->symhdr->sh_link < mp->hdr.e_shnum)) {
932 		mp->strhdr = (Shdr *)
933 		    (mp->shdrs + mp->symhdr->sh_link * mp->hdr.e_shentsize);
934 		mp->nsyms = mp->symhdr->sh_size / mp->symhdr->sh_entsize;
935 
936 		/* Allocate space for the symbol table and strings.  */
937 		mp->symsize = mp->symhdr->sh_size +
938 		    mp->nsyms * sizeof (symid_t) + mp->strhdr->sh_size;
939 		mp->symspace = kmem_zalloc(mp->symsize, KM_SLEEP);
940 		mp->symtbl = mp->symspace;
941 		mp->strings = (char *)(mp->symtbl + mp->symhdr->sh_size);
942 
943 		if ((kobj_read_file(file, mp->symtbl,
944 		    mp->symhdr->sh_size, mp->symhdr->sh_offset) < 0) ||
945 		    (kobj_read_file(file, mp->strings,
946 		    mp->strhdr->sh_size, mp->strhdr->sh_offset) < 0))
947 			goto err;
948 	}
949 
950 	/*
951 	 * Read in the CTF section
952 	 */
953 	if ((ctf_shp != NULL) && ((moddebug & MODDEBUG_NOCTF) == 0)) {
954 		mp->ctfdata = kmem_zalloc(ctf_shp->sh_size, KM_SLEEP);
955 		mp->ctfsize = ctf_shp->sh_size;
956 		if (kobj_read_file(file, mp->ctfdata, mp->ctfsize,
957 		    ctf_shp->sh_offset) < 0)
958 			goto err;
959 	}
960 
961 	kobj_close_file(file);
962 
963 	xpv_module = mp;
964 	xpv_modctl = mcp;
965 	return;
966 
967 err:
968 	cmn_err(CE_WARN, "Failed to initialize xpv module.");
969 	if (file != NULL)
970 		kobj_close_file(file);
971 
972 	kmem_free(mp->filename, strlen(XPV_FILENAME) + 1);
973 	if (mp->shdrs != NULL)
974 		kmem_free(mp->shdrs, mp->hdr.e_shentsize * mp->hdr.e_shnum);
975 	if (mp->symspace != NULL)
976 		kmem_free(mp->symspace, mp->symsize);
977 	if (mp->ctfdata != NULL)
978 		kmem_free(mp->ctfdata, mp->ctfsize);
979 	kmem_free(mp, sizeof (*mp));
980 	kmem_free(mcp->mod_filename, strlen(XPV_FILENAME) + 1);
981 	kmem_free(mcp->mod_modname, strlen(XPV_MODNAME) + 1);
982 	kmem_free(mcp, sizeof (*mcp));
983 	if (names != NULL)
984 		kmem_free(names, namesize);
985 }
986 
987 void
988 xpv_panic_init()
989 {
990 	xen_platform_op_t op;
991 	int i;
992 
993 	ASSERT(DOMAIN_IS_INITDOMAIN(xen_info));
994 
995 	for (i = 0; i < mmu.num_level; i++)
996 		ptable_pfn[i] = PFN_INVALID;
997 
998 	/* Let Xen know where to jump if/when it panics. */
999 	op.cmd = XENPF_panic_init;
1000 	op.interface_version = XENPF_INTERFACE_VERSION;
1001 	op.u.panic_init.panic_addr = (unsigned long)xpv_panic_hdlr;
1002 
1003 	(void) HYPERVISOR_platform_op(&op);
1004 
1005 	init_xen_module();
1006 }
1007