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 * Copyright (c) 2012 by Delphix. All rights reserved.
27 */
28
29 #include <mdb/mdb_modapi.h>
30 #include <mdb/mdb_ks.h>
31 #include <mdb/mdb_ctf.h>
32 #include <mdb/mdb_gelf.h>
33 #include <mdb/mdb_target_impl.h>
34 #include <mdb/mdb_kvm.h>
35 #include <mdb/mdb.h>
36 #include <xen/public/xen.h>
37 #include <xen/public/arch-x86/xen.h>
38 #include <errno.h>
39
40 static mdb_ctf_id_t domain_type;
41
42 /*
43 * Some constants found in the non-public sched.h header file
44 */
45 #define MAX_EVTCHNS NR_EVENT_CHANNELS
46 #define EVTCHNS_PER_BUCKET 128
47 #define NR_EVTCHN_BUCKETS (MAX_EVTCHNS / EVTCHNS_PER_BUCKET)
48
49 /*
50 * "struct domain" is an internal Xen structure. Rather than trying to
51 * keep the mdb source in sync with Xen, we use CTF to extract the
52 * interesting bits from the binary, and stash them in the structure
53 * defined below.
54 */
55 typedef struct mdb_xpv_domain {
56 short domain_id;
57 int tot_pages;
58 int max_pages;
59 int xenheap_pages;
60 ulong_t domain_flags;
61 char is_hvm;
62 struct vcpu *vcpu[MAX_VIRT_CPUS];
63 struct evtchn *evtchn[NR_EVTCHN_BUCKETS];
64 struct domain *next_in_list;
65 } mdb_xpv_domain_t;
66
67 static uintptr_t
68 get_dom0_addr()
69 {
70 GElf_Sym sym;
71 uintptr_t addr;
72
73 if ((mdb_lookup_by_obj(MDB_TGT_OBJ_EVERY, "dom0", &sym)) == 1) {
74 mdb_warn("can't find symbol 'dom0'");
75 return (0);
76 }
77
78 if (sym.st_size != sizeof (uintptr_t)) {
79 mdb_printf("Symbol 'dom0' found, but with the wrong size\n");
80 return (0);
81 }
82
83 if (mdb_vread(&addr, sym.st_size, sym.st_value) == -1) {
84 mdb_warn("can't read data for symbol 'dom0'");
85 return (0);
86 }
87
88 return (addr);
89 }
90
91 typedef struct domain_walk {
92 uint_t dw_step;
93 } domain_walk_t;
94
95 int
96 domain_walk_init(mdb_walk_state_t *wsp)
97 {
98 domain_walk_t *dwp;
99
100 if (wsp->walk_addr == NULL)
101 if ((wsp->walk_addr = get_dom0_addr()) == NULL)
102 return (WALK_ERR);
103
104 dwp = mdb_alloc(sizeof (domain_walk_t), UM_SLEEP);
105 dwp->dw_step = FALSE;
106 wsp->walk_data = dwp;
107 return (WALK_NEXT);
108 }
109
110 int
111 domain_walk_step(mdb_walk_state_t *wsp)
112 {
113 domain_walk_t *dwp = (domain_walk_t *)wsp->walk_data;
114 mdb_xpv_domain_t dom;
115 int status;
116
117 if (wsp->walk_addr == NULL)
118 return (WALK_DONE);
119
120 status = wsp->walk_callback(wsp->walk_addr, (void *)wsp->walk_addr,
121 wsp->walk_cbdata);
122
123 if (mdb_ctf_vread(&dom, "struct domain", "mdb_xpv_domain_t",
124 wsp->walk_addr, 0) != 0)
125 return (WALK_ERR);
126 wsp->walk_addr = (uintptr_t)dom.next_in_list;
127
128 dwp->dw_step = TRUE;
129 return (status);
130 }
131
132 void
133 domain_walk_fini(mdb_walk_state_t *wsp)
134 {
135 domain_walk_t *dwp = (domain_walk_t *)wsp->walk_data;
136
137 mdb_free(dwp, sizeof (domain_walk_t));
138 }
139
140 typedef struct vcpu_walk {
141 uint_t vw_count;
142 uint_t vw_step;
143 } vcpu_walk_t;
144
145 int
146 vcpu_walk_init(mdb_walk_state_t *wsp)
147 {
148 vcpu_walk_t *vwp;
149 uintptr_t off;
150
151 if (wsp->walk_addr == NULL)
152 if ((wsp->walk_addr = get_dom0_addr()) == NULL)
153 return (WALK_ERR);
154
155 if (mdb_ctf_offsetof(domain_type, "vcpu", &off)) {
156 mdb_warn("can't find per-domain vcpu information");
157 return (WALK_ERR);
158 }
159
160 wsp->walk_addr = wsp->walk_addr + (off / NBBY);
161 vwp = mdb_alloc(sizeof (vcpu_walk_t), UM_SLEEP);
162 vwp->vw_step = FALSE;
163 vwp->vw_count = 0;
164 wsp->walk_data = vwp;
165 return (WALK_NEXT);
166 }
167
168 int
169 vcpu_walk_step(mdb_walk_state_t *wsp)
170 {
171 vcpu_walk_t *vwp = (vcpu_walk_t *)wsp->walk_data;
172 uintptr_t vcpu_ptr;
173 int status;
174
175 if (vwp->vw_count++ >= MAX_VIRT_CPUS)
176 return (WALK_DONE);
177 if ((wsp->walk_addr == NULL) ||
178 (mdb_vread(&vcpu_ptr, sizeof (uintptr_t), wsp->walk_addr) == -1) ||
179 (vcpu_ptr == 0))
180 return (WALK_DONE);
181
182 status = wsp->walk_callback(vcpu_ptr, (void *)vcpu_ptr,
183 wsp->walk_cbdata);
184
185 wsp->walk_addr = wsp->walk_addr + sizeof (uintptr_t);
186 vwp->vw_step = TRUE;
187 return (status);
188 }
189
190 void
191 vcpu_walk_fini(mdb_walk_state_t *wsp)
192 {
193 vcpu_walk_t *vwp = (vcpu_walk_t *)wsp->walk_data;
194
195 mdb_free(vwp, sizeof (vcpu_walk_t));
196 }
197
198 int
199 domain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
200 {
201 mdb_xpv_domain_t dom;
202 uintptr_t off, vcpu_addr, evtchn_addr;
203
204 if (!mdb_ctf_type_valid(domain_type)) {
205 mdb_warn("Can't parse Xen domain info.\n");
206 return (DCMD_ERR);
207 }
208
209 if (!(flags & DCMD_ADDRSPEC)) {
210 if (mdb_walk_dcmd("domain", "domain", argc, argv) == -1) {
211 mdb_warn("can't walk domains");
212 return (DCMD_ERR);
213 }
214 return (DCMD_OK);
215 }
216
217 if (DCMD_HDRSPEC(flags))
218 mdb_printf("%?s %3s %8s %8s %8s %3s %?s %?s\n",
219 "ADDR", "ID", "TPAGES", "MPAGES", "FLAGS", "HVM",
220 "VCPU", "EVTCHN");
221
222 if (mdb_ctf_vread(&dom, "struct domain", "mdb_xpv_domain_t", addr,
223 0) != 0)
224 return (DCMD_ERR);
225
226 if (mdb_ctf_offsetof(domain_type, "vcpu", &off)) {
227 mdb_warn("can't find per-domain vcpu information");
228 return (DCMD_ERR);
229 }
230 vcpu_addr = addr + (off / NBBY);
231 if (mdb_ctf_offsetof(domain_type, "evtchn", &off)) {
232 mdb_warn("can't find per-domain event channel information");
233 return (DCMD_ERR);
234 }
235 evtchn_addr = addr + (off / NBBY);
236 mdb_printf("%?lx %3d %8x %8x %8x %3d %?lx %?lx\n",
237 addr, dom.domain_id, dom.tot_pages, dom.max_pages, dom.domain_flags,
238 dom.is_hvm, vcpu_addr, evtchn_addr);
239
240 return (DCMD_OK);
241 }
242
243 static const mdb_dcmd_t dcmds[] = {
244 { "domain", ":", "display Xen domain info", domain },
245 { NULL }
246 };
247
248 static const mdb_walker_t walkers[] = {
249 { "domain", "walk list of Xen domains",
250 domain_walk_init, domain_walk_step, domain_walk_fini },
251 { "vcpu", "walk a Xen domain's vcpus",
252 vcpu_walk_init, vcpu_walk_step, vcpu_walk_fini },
253 { NULL }
254 };
255
256 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
257
258 typedef struct mdb_xpv_panic_info {
259 int pi_version;
260 } mdb_xpv_panic_info_t;
261
262 const mdb_modinfo_t *
263 _mdb_init(void)
264 {
265 uintptr_t pip;
266 mdb_xpv_panic_info_t pi;
267
268 if (mdb_readsym(&pip, sizeof (pip), "xpv_panic_info") == -1) {
269 mdb_warn("failed to read xpv panic_info pointer");
270 return (NULL);
271 }
272 if (mdb_ctf_vread(&pi, "struct panic_info", "mdb_xpv_panic_info_t",
273 pip, 0) == -1)
274 return (NULL);
275
276 if (pi.pi_version != PANIC_INFO_VERSION) {
277 mdb_warn("unrecognized hypervisor panic format");
278 return (NULL);
279 }
280
281 if (mdb_ctf_lookup_by_name("struct domain", &domain_type) != 0) {
282 mdb_warn("Can't parse Xen domain info: "
283 "'struct domain' not found.\n");
284 mdb_ctf_type_invalidate(&domain_type);
285 }
286
287 return (&modinfo);
288 }