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.
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.
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]
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
25 * Copyright 2018 Joyent, Inc.
29 * Management of KMDB's IDT, which is installed upon KMDB activation.
31 * Debugger activation has two flavors, which cover the cases where KMDB is
32 * loaded at boot, and when it is loaded after boot. In brief, in both cases,
33 * the KDI needs to interpose upon several handlers in the IDT. When
34 * mod-loaded KMDB is deactivated, we undo the IDT interposition, restoring the
35 * handlers to what they were before we started.
37 * We also take over the entirety of IDT (except the double-fault handler) on
38 * the active CPU when we're in kmdb so we can handle things like page faults
43 * When we're first activated, we're running on boot's IDT. We need to be able
44 * to function in this world, so we'll install our handlers into boot's IDT.
45 * This is a little complicated: we're using the fake cpu_t set up by
46 * boot_kdi_tmpinit(), so we can't access cpu_idt directly. Instead,
47 * kdi_idt_write() notices that cpu_idt is NULL, and works around this problem.
49 * Later, when we're about to switch to the kernel's IDT, it'll call us via
50 * kdi_idt_sync(), allowing us to add our handlers to the new IDT. While
51 * boot-loaded KMDB can't be unloaded, we still need to save the descriptors we
52 * replace so we can pass traps back to the kernel as necessary.
54 * The last phase of boot-loaded KMDB activation occurs at non-boot CPU
55 * startup. We will be called on each non-boot CPU, thus allowing us to set up
56 * any watchpoints that may have been configured on the boot CPU and interpose
57 * on the given CPU's IDT. We don't save the interposed descriptors in this
58 * case -- see kdi_cpu_init() for details.
62 * This style of activation is much simpler, as the CPUs are already running,
63 * and are using their own copy of the kernel's IDT. We simply interpose upon
64 * each CPU's IDT. We save the handlers we replace, both for deactivation and
65 * for passing traps back to the kernel. Note that for the hypervisors'
66 * benefit, we need to xcall to the other CPUs to do this, since we need to
67 * actively set the trap entries in its virtual IDT from that vcpu's context
68 * rather than just modifying the IDT table from the CPU running kdi_activate().
71 #include <sys/types.h>
72 #include <sys/segments.h>
74 #include <sys/cpuvar.h>
75 #include <sys/reboot.h>
76 #include <sys/sunddi.h>
77 #include <sys/archsystm.h>
78 #include <sys/kdi_impl.h>
79 #include <sys/x_call.h>
80 #include <ia32/sys/psw.h>
82 #define KDI_GATE_NVECS 3
84 #define KDI_IDT_NOSAVE 0
85 #define KDI_IDT_SAVE 1
87 #define KDI_IDT_DTYPE_KERNEL 0
88 #define KDI_IDT_DTYPE_BOOT 1
90 kdi_cpusave_t
*kdi_cpusave
;
93 static kdi_main_t kdi_kmdb_main
;
95 kdi_drreg_t kdi_drreg
;
98 /* Used to track the current set of valid kernel selectors. */
105 uintptr_t kdi_kernel_handler
;
109 #define KDI_MEMRANGES_MAX 2
111 kdi_memrange_t kdi_memranges
[KDI_MEMRANGES_MAX
];
114 typedef void idt_hdlr_f(void);
116 extern idt_hdlr_f kdi_trap0
, kdi_trap1
, kdi_int2
, kdi_trap3
, kdi_trap4
;
117 extern idt_hdlr_f kdi_trap5
, kdi_trap6
, kdi_trap7
, kdi_trap9
;
118 extern idt_hdlr_f kdi_traperr10
, kdi_traperr11
, kdi_traperr12
;
119 extern idt_hdlr_f kdi_traperr13
, kdi_traperr14
, kdi_trap16
, kdi_trap17
;
120 extern idt_hdlr_f kdi_trap18
, kdi_trap19
, kdi_trap20
, kdi_ivct32
;
121 extern idt_hdlr_f kdi_invaltrap
;
122 extern size_t kdi_ivct_size
;
124 typedef struct kdi_gate_spec
{
130 * Beware: kdi_pass_to_kernel() has unpleasant knowledge of this list.
132 static const kdi_gate_spec_t kdi_gate_specs
[KDI_GATE_NVECS
] = {
133 { T_SGLSTP
, TRP_KPL
},
134 { T_BPTFLT
, TRP_UPL
},
135 { T_DBGENTR
, TRP_KPL
}
138 static gate_desc_t kdi_kgates
[KDI_GATE_NVECS
];
140 gate_desc_t kdi_idt
[NIDT
];
142 struct idt_description
{
145 idt_hdlr_f
*id_basehdlr
;
147 } idt_description
[] = {
148 { T_ZERODIV
, 0, kdi_trap0
, NULL
},
149 { T_SGLSTP
, 0, kdi_trap1
, NULL
},
150 { T_NMIFLT
, 0, kdi_int2
, NULL
},
151 { T_BPTFLT
, 0, kdi_trap3
, NULL
},
152 { T_OVFLW
, 0, kdi_trap4
, NULL
},
153 { T_BOUNDFLT
, 0, kdi_trap5
, NULL
},
154 { T_ILLINST
, 0, kdi_trap6
, NULL
},
155 { T_NOEXTFLT
, 0, kdi_trap7
, NULL
},
157 { T_DBLFLT
, 0, syserrtrap
, NULL
},
159 { T_EXTOVRFLT
, 0, kdi_trap9
, NULL
},
160 { T_TSSFLT
, 0, kdi_traperr10
, NULL
},
161 { T_SEGFLT
, 0, kdi_traperr11
, NULL
},
162 { T_STKFLT
, 0, kdi_traperr12
, NULL
},
163 { T_GPFLT
, 0, kdi_traperr13
, NULL
},
164 { T_PGFLT
, 0, kdi_traperr14
, NULL
},
165 { 15, 0, kdi_invaltrap
, NULL
},
166 { T_EXTERRFLT
, 0, kdi_trap16
, NULL
},
167 { T_ALIGNMENT
, 0, kdi_trap17
, NULL
},
168 { T_MCE
, 0, kdi_trap18
, NULL
},
169 { T_SIMDFPE
, 0, kdi_trap19
, NULL
},
170 { T_DBGENTR
, 0, kdi_trap20
, NULL
},
171 { 21, 31, kdi_invaltrap
, NULL
},
172 { 32, 255, kdi_ivct32
, &kdi_ivct_size
},
177 kdi_idt_init(selector_t sel
)
179 struct idt_description
*id
;
182 for (id
= idt_description
; id
->id_basehdlr
!= NULL
; id
++) {
183 uint_t high
= id
->id_high
!= 0 ? id
->id_high
: id
->id_low
;
184 size_t incr
= id
->id_incrp
!= NULL
? *id
->id_incrp
: 0;
186 for (i
= id
->id_low
; i
<= high
; i
++) {
187 caddr_t hdlr
= (caddr_t
)id
->id_basehdlr
+
188 incr
* (i
- id
->id_low
);
189 set_gatesegd(&kdi_idt
[i
], (void (*)())hdlr
, sel
,
190 SDT_SYSIGT
, TRP_KPL
, i
);
196 kdi_idt_gates_install(selector_t sel
, int saveold
)
198 gate_desc_t gates
[KDI_GATE_NVECS
];
201 bzero(gates
, sizeof (*gates
));
203 for (i
= 0; i
< KDI_GATE_NVECS
; i
++) {
204 const kdi_gate_spec_t
*gs
= &kdi_gate_specs
[i
];
205 uintptr_t func
= GATESEG_GETOFFSET(&kdi_idt
[gs
->kgs_vec
]);
206 set_gatesegd(&gates
[i
], (void (*)())func
, sel
, SDT_SYSIGT
,
207 gs
->kgs_dpl
, gs
->kgs_vec
);
210 for (i
= 0; i
< KDI_GATE_NVECS
; i
++) {
211 uint_t vec
= kdi_gate_specs
[i
].kgs_vec
;
214 kdi_kgates
[i
] = CPU
->cpu_m
.mcpu_idt
[vec
];
216 kdi_idt_write(&gates
[i
], vec
);
221 kdi_idt_gates_restore(void)
225 for (i
= 0; i
< KDI_GATE_NVECS
; i
++)
226 kdi_idt_write(&kdi_kgates
[i
], kdi_gate_specs
[i
].kgs_vec
);
230 * Called when we switch to the kernel's IDT. We need to interpose on the
231 * kernel's IDT entries and stop using KMDBCODE_SEL.
236 kdi_idt_init(KCS_SEL
);
237 kdi_idt_gates_install(KCS_SEL
, KDI_IDT_SAVE
);
241 kdi_update_drreg(kdi_drreg_t
*drreg
)
247 kdi_memrange_add(caddr_t base
, size_t len
)
249 kdi_memrange_t
*mr
= &kdi_memranges
[kdi_nmemranges
];
251 ASSERT(kdi_nmemranges
!= KDI_MEMRANGES_MAX
);
254 mr
->mr_lim
= base
+ len
- 1;
259 kdi_idt_switch(kdi_cpusave_t
*cpusave
)
262 kdi_idtr_set(kdi_idt
, sizeof (kdi_idt
) - 1);
264 kdi_idtr_set(cpusave
->krs_idt
, (sizeof (*idt0
) * NIDT
) - 1);
268 * Activation for CPUs other than the boot CPU, called from that CPU's
269 * mp_startup(). We saved the kernel's descriptors when we initialized the
270 * boot CPU, so we don't want to do it again. Saving the handlers from this
271 * CPU's IDT would actually be dangerous with the CPU initialization method in
272 * use at the time of this writing. With that method, the startup code creates
273 * the IDTs for slave CPUs by copying the one used by the boot CPU, which has
274 * already been interposed upon by KMDB. Were we to interpose again, we'd
275 * replace the kernel's descriptors with our own in the save area. By not
276 * saving, but still overwriting, we'll work in the current world, and in any
277 * future world where the IDT is generated from scratch.
282 kdi_idt_gates_install(KCS_SEL
, KDI_IDT_NOSAVE
);
283 /* Load the debug registers. */
284 kdi_cpu_debug_init(&kdi_cpusave
[CPU
->cpu_id
]);
288 * Activation for all CPUs for mod-loaded kmdb, i.e. a kmdb that wasn't
292 kdi_cpu_activate(void)
294 kdi_idt_gates_install(KCS_SEL
, KDI_IDT_SAVE
);
299 kdi_activate(kdi_main_t main
, kdi_cpusave_t
*cpusave
, uint_t ncpusave
)
306 kdi_cpusave
= cpusave
;
307 kdi_ncpusave
= ncpusave
;
309 kdi_kmdb_main
= main
;
311 for (i
= 0; i
< kdi_ncpusave
; i
++) {
312 kdi_cpusave
[i
].krs_cpu_id
= i
;
314 kdi_cpusave
[i
].krs_curcrumb
=
315 &kdi_cpusave
[i
].krs_crumbs
[KDI_NCRUMBS
- 1];
316 kdi_cpusave
[i
].krs_curcrumbidx
= KDI_NCRUMBS
- 1;
319 if (boothowto
& RB_KMDB
)
320 kdi_idt_init(KMDBCODE_SEL
);
322 kdi_idt_init(KCS_SEL
);
324 /* The initial selector set. Updated by the debugger-entry code */
326 kdi_cs
= B32CODE_SEL
;
327 kdi_ds
= kdi_fs
= kdi_gs
= B32DATA_SEL
;
330 kdi_memranges
[0].mr_base
= kdi_segdebugbase
;
331 kdi_memranges
[0].mr_lim
= kdi_segdebugbase
+ kdi_segdebugsize
- 1;
334 kdi_drreg
.dr_ctl
= KDIREG_DRCTL_RESERVED
;
335 kdi_drreg
.dr_stat
= KDIREG_DRSTAT_RESERVED
;
337 if (boothowto
& RB_KMDB
) {
338 kdi_idt_gates_install(KMDBCODE_SEL
, KDI_IDT_NOSAVE
);
340 xc_call(0, 0, 0, CPUSET2BV(cpuset
),
341 (xc_func_t
)kdi_cpu_activate
);
346 kdi_cpu_deactivate(void)
348 kdi_idt_gates_restore();
358 xc_call(0, 0, 0, CPUSET2BV(cpuset
), (xc_func_t
)kdi_cpu_deactivate
);
363 * We receive all breakpoints and single step traps. Some of them,
364 * including those from userland and those induced by DTrace providers,
365 * are intended for the kernel, and must be processed there. We adopt
366 * this ours-until-proven-otherwise position due to the painful
367 * consequences of sending the kernel an unexpected breakpoint or
368 * single step. Unless someone can prove to us that the kernel is
369 * prepared to handle the trap, we'll assume there's a problem and will
370 * give the user a chance to debug it.
373 kdi_trap_pass(kdi_cpusave_t
*cpusave
)
375 greg_t tt
= cpusave
->krs_gregs
[KDIREG_TRAPNO
];
376 greg_t pc
= cpusave
->krs_gregs
[KDIREG_PC
];
377 greg_t cs
= cpusave
->krs_gregs
[KDIREG_CS
];
382 if (tt
!= T_BPTFLT
&& tt
!= T_SGLSTP
)
385 if (tt
== T_BPTFLT
&& kdi_dtrace_get_state() ==
386 KDI_DTSTATE_DTRACE_ACTIVE
)
390 * See the comments in the kernel's T_SGLSTP handler for why we need to
393 if (tt
== T_SGLSTP
&&
394 (pc
== (greg_t
)sys_sysenter
|| pc
== (greg_t
)brand_sys_sysenter
))
401 * State has been saved, and all CPUs are on the CPU-specific stacks. All
402 * CPUs enter here, and head off into the debugger proper.
405 kdi_debugger_entry(kdi_cpusave_t
*cpusave
)
408 * BPTFLT gives us control with %eip set to the instruction *after*
409 * the int 3. Back it off, so we're looking at the instruction that
410 * triggered the fault.
412 if (cpusave
->krs_gregs
[KDIREG_TRAPNO
] == T_BPTFLT
)
413 cpusave
->krs_gregs
[KDIREG_PC
]--;
415 kdi_kmdb_main(cpusave
);