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 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 /*
29 * The KDI is used to allow the kernel debugger to directly invoke various
30 * kernel functions. In some cases, such as with kdi_mod_iter(), the
31 * debugger needs to execute functions that use the kernel's linker bindings.
32 * In other cases, the implementation of the KDI functions vary by platform
33 * and/or by CPU. By embedding the implementation of these functions in
34 * the platmod/cpumod, we can avoid the need for platform-specific knowledge
35 * in the debugger, and can thus have a single debugger binary for all
36 * platforms.
37 *
38 * There are three classes of KDI function:
39 *
40 * 1. Normal - These are functions whose implementations are in the kernel for
41 * convenience. An example is the modctl iterator, kdi_mod_iter. Using the
42 * modules symbol, this function iterates through the kernel's modctl list,
43 * invoking a debugger-provided callback for each one. This function is in
44 * the KDI because the debugger needs to be able to execute it in order to
45 * enable symbol resolution. Without symbol resolution, the debugger can't
46 * locate the modules symbol. A chicken-and-egg problem results. We solve
47 * this problem by locating the module iterator in the kernel, where run-time
48 * linking solves the problem for us.
49 *
50 * 2. CPU-specific - Functions in this class have implementations that differ
51 * by CPU. For example, the crosscall delivery notification method differs
52 * between Cheetah and Jalapeno, necessitating a different implementation for
53 * each. By locating the KDI implementation of these functions in the
54 * cpumods, we automatically get the correct implementation, as krtld
55 * automatically loads the correct cpumod when it starts. The cpumods
56 * directly fill in their portion of the kdi_t, using the mandatory
57 * cpu_kdi_init cpumod entry point.
58 *
59 * 3. Platform-specific - Similar to the CPU-specific class, platform-specific
60 * KDI functions have implementations that differ from platform to platform.
61 * As such, the implementations live in the platmods. Further
62 * differentiating the platform-specific KDI functions from their
63 * CPU-dependent brethren, many directly invoke PROM functions. This poses
64 * a problem, as the platmods use the kernel's promif functions, rather than
65 * the lock-free kmdb versions. We provide an interposition layer for these
66 * platform-specific calls that disables the pre- and post-processing
67 * functions used by the kernel to implement kernel-specific functionality
68 * that must not be executed when kmdb has control of the machine. Platmods
69 * fill in a kdi_plat_t using their optional plat_kdi_init entry point.
70 * krtld provides wrapper functions which suspend the necessary functions in
71 * the promif layer before invoking the kdi_plat_t functions (if any).
72 */
73
74 #include <sys/types.h>
75 #include <sys/systm.h>
76 #include <sys/reboot.h>
77 #include <sys/kdi_impl.h>
78
79 #include <krtld/kobj_kdi.h>
80
81 #define KOBJ_KDI_MOD_IDLE 0
82 #define KOBJ_KDI_MOD_CHANGING 1
83 #define KOBJ_KDI_MOD_CHANGED 2
84
85 static int kobj_kdi_mod_state = KOBJ_KDI_MOD_IDLE;
86
87 extern int standalone;
88
89 cons_polledio_t *
kobj_kdi_get_polled_io(void)90 kobj_kdi_get_polled_io(void)
91 {
92 cons_polledio_t **polled_io = &cons_polledio;
93
94 return (polled_io == NULL ? NULL : *polled_io);
95 }
96
97 int
kobj_kdi_mod_iter(int (* func)(struct modctl *,void *),void * arg)98 kobj_kdi_mod_iter(int (*func)(struct modctl *, void *), void *arg)
99 {
100 int rc;
101
102 if (standalone) {
103 struct modctl_list *lp, **lpp;
104
105 for (lpp = kobj_linkmaps; *lpp != NULL; lpp++) {
106 for (lp = *lpp; lp != NULL; lp = lp->modl_next) {
107 if ((rc = func(lp->modl_modp, arg)) != 0)
108 return (rc);
109 }
110 }
111
112 } else {
113 struct modctl *modp = &modules;
114
115 do {
116 if ((rc = func(modp, arg)) != 0)
117 return (rc);
118 } while ((modp = modp->mod_next) != &modules);
119 }
120
121 return (0);
122 }
123
124 int
kobj_kdi_mod_isloaded(struct modctl * modp)125 kobj_kdi_mod_isloaded(struct modctl *modp)
126 {
127 return (modp->mod_mp != NULL);
128 }
129
130 int
kobj_kdi_mods_changed(void)131 kobj_kdi_mods_changed(void)
132 {
133 int state;
134
135 if ((state = kobj_kdi_mod_state) == KOBJ_KDI_MOD_CHANGED)
136 kobj_kdi_mod_state = KOBJ_KDI_MOD_IDLE;
137
138 return (state != KOBJ_KDI_MOD_IDLE);
139 }
140
141 /*ARGSUSED1*/
142 void
kobj_kdi_mod_notify(uint_t why,struct modctl * what)143 kobj_kdi_mod_notify(uint_t why, struct modctl *what)
144 {
145 switch (why) {
146 case KOBJ_NOTIFY_MODLOADING:
147 kobj_kdi_mod_state = KOBJ_KDI_MOD_CHANGING;
148 break;
149 case KOBJ_NOTIFY_MODLOADED:
150 kobj_kdi_mod_state = KOBJ_KDI_MOD_CHANGED;
151 if (boothowto & RB_DEBUG)
152 kdi_dvec_mod_loaded(what);
153 break;
154 case KOBJ_NOTIFY_MODUNLOADING:
155 kobj_kdi_mod_state = KOBJ_KDI_MOD_CHANGING;
156 if (boothowto & RB_DEBUG)
157 kdi_dvec_mod_unloading(what);
158 break;
159 case KOBJ_NOTIFY_MODUNLOADED:
160 kobj_kdi_mod_state = KOBJ_KDI_MOD_CHANGED;
161 break;
162 }
163 }
164
165 /*
166 * Compare two modctl and module snapshots, attempting to determine whether
167 * the module to which they both refer has changed between the time of the first
168 * and the time of the second. We can't do a straight bcmp, because there are
169 * fields that change in the normal course of operations. False positives
170 * aren't the end of the world, but it'd be nice to avoid flagging a module
171 * as changed every time someone holds or releases it.
172 */
173 int
kobj_kdi_mod_haschanged(struct modctl * mc1,struct module * mp1,struct modctl * mc2,struct module * mp2)174 kobj_kdi_mod_haschanged(struct modctl *mc1, struct module *mp1,
175 struct modctl *mc2, struct module *mp2)
176 {
177 if (mc1->mod_loadcnt != mc2->mod_loadcnt || mc1->mod_mp != mc2->mod_mp)
178 return (1);
179
180 if (mc1->mod_mp == NULL)
181 return (0);
182
183 /* Take breath here. */
184 return (bcmp(&mp1->hdr, &mp2->hdr, sizeof (mp1->hdr)) != 0 ||
185 mp1->symhdr != mp2->symhdr || mp1->strhdr != mp2->strhdr ||
186 mp1->text != mp2->text || mp1->bss != mp2->bss ||
187 mp1->ctfdata != mp2->ctfdata || mp1->ctfsize != mp2->ctfsize);
188 }
189
190 void
kobj_kdi_system_claim(void)191 kobj_kdi_system_claim(void)
192 {
193 kobj_kdi.kdi_plat_call(kobj_kdi.pkdi_system_claim);
194 kobj_kdi.kdi_plat_call(kobj_kdi.pkdi_console_claim);
195 }
196
197 void
kobj_kdi_system_release(void)198 kobj_kdi_system_release(void)
199 {
200 kobj_kdi.kdi_plat_call(kobj_kdi.pkdi_console_release);
201 kobj_kdi.kdi_plat_call(kobj_kdi.pkdi_system_release);
202 }
203
204 void
kobj_kdi_init(void)205 kobj_kdi_init(void)
206 {
207 static const char *const initializers[] = {
208 "cpu_kdi_init", "mach_kdi_init", "plat_kdi_init", NULL
209 };
210
211 Sym *sym;
212 int i;
213
214 for (i = 0; initializers[i] != NULL; i++) {
215 if ((sym = kobj_lookup_kernel(initializers[i])) != NULL)
216 ((void (*)(kdi_t *))sym->st_value)(&kobj_kdi);
217 }
218 }
219
220 kdi_t kobj_kdi = {
221 KDI_VERSION,
222 kobj_kdi_mods_changed,
223 kobj_kdi_mod_iter,
224 kobj_kdi_mod_isloaded,
225 kobj_kdi_mod_haschanged,
226 kobj_kdi_system_claim,
227 kobj_kdi_system_release,
228 kdi_pread,
229 kdi_pwrite,
230 kdi_flush_caches,
231 kdi_range_is_nontoxic,
232 kobj_kdi_get_polled_io,
233 kdi_vtop,
234 kdi_dtrace_get_state,
235 kdi_dtrace_set,
236 /*
237 * The rest are filled in by cpu_kdi_init, mach_kdi_init, and/or
238 * plat_kdi_init.
239 */
240 NULL, /* kdi_plat_call */
241 NULL, /* kdi_kmdb_enter */
242 { NULL }, /* kdi_arch */
243 { NULL } /* kdi_plat */
244 };
245