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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Copyright 2018 Joyent, Inc.
26 */
27
28 /*
29 * Raw File Target
30 *
31 * The raw file target is invoked whenever a file of unrecognizable type is
32 * specified on the command line, or when raw file examination is forced using
33 * the -f option. If one file is specified, that file will be opened as the
34 * "object" file. If two files are specified, the second one will be opened
35 * as the "core" file. Each file is opened using the fdio backend, which
36 * internally supports both byte-oriented i/o and block-oriented i/o as needed.
37 */
38
39 #include <mdb/mdb_modapi.h>
40 #include <mdb/mdb_target_impl.h>
41 #include <mdb/mdb_io_impl.h>
42 #include <mdb/mdb_conf.h>
43 #include <mdb/mdb_err.h>
44 #include <mdb/mdb.h>
45
46 #include <sys/dtrace.h>
47 #include <fcntl.h>
48
49 typedef struct rf_data {
50 mdb_io_t *r_object_fio;
51 mdb_io_t *r_core_fio;
52 } rf_data_t;
53
54 #define RF_OBJECT(p) (((rf_data_t *)(p))->r_object_fio)
55 #define RF_CORE(p) (((rf_data_t *)(p))->r_core_fio)
56
57 static void
58 rf_data_destroy(rf_data_t *rf)
59 {
60 if (rf->r_object_fio != NULL)
61 mdb_io_destroy(rf->r_object_fio);
62
63 if (rf->r_core_fio != NULL)
64 mdb_io_destroy(rf->r_core_fio);
65
66 mdb_free(rf, sizeof (rf_data_t));
67 }
68
69 static int
70 rf_setflags(mdb_tgt_t *t, int flags)
71 {
72 if ((flags ^ t->t_flags) & MDB_TGT_F_RDWR) {
73 uint_t otflags = t->t_flags;
74 rf_data_t *orf = t->t_data;
75 const char *argv[2];
76 int argc = 0;
77
78 if (orf->r_object_fio != NULL)
79 argv[argc++] = IOP_NAME(orf->r_object_fio);
80 if (orf->r_core_fio != NULL)
81 argv[argc++] = IOP_NAME(orf->r_core_fio);
82
83 t->t_flags = (t->t_flags & ~MDB_TGT_F_RDWR) |
84 (flags & MDB_TGT_F_RDWR);
85
86 if (mdb_rawfile_tgt_create(t, argc, argv) == -1) {
87 t->t_flags = otflags;
88 t->t_data = orf;
89 return (-1);
90 }
91
92 rf_data_destroy(orf);
93 }
94
95 return (0);
96 }
97
98 static void
99 rf_destroy(mdb_tgt_t *t)
100 {
101 rf_data_destroy(t->t_data);
102 }
103
104 /*ARGSUSED*/
105 static const char *
106 rf_name(mdb_tgt_t *t)
107 {
108 return ("raw");
109 }
110
111 static ssize_t
112 rf_read(mdb_io_t *io, void *buf, size_t nbytes, uint64_t addr)
113 {
114 ssize_t rbytes;
115
116 if (io == NULL)
117 return (set_errno(EMDB_NOMAP));
118
119 if (IOP_SEEK(io, addr, SEEK_SET) == -1)
120 return (-1); /* errno is set for us */
121
122 if ((rbytes = IOP_READ(io, buf, nbytes)) == 0)
123 (void) set_errno(EMDB_EOF);
124
125 return (rbytes);
126 }
127
128 static ssize_t
129 rf_write(mdb_io_t *io, const void *buf, size_t nbytes, uint64_t addr)
130 {
131 if (io == NULL)
132 return (set_errno(EMDB_NOMAP));
133
134 if (IOP_SEEK(io, addr, SEEK_SET) == -1)
135 return (-1); /* errno is set for us */
136
137 return (IOP_WRITE(io, buf, nbytes));
138 }
139
140 static ssize_t
141 rf_aread(mdb_tgt_t *t, mdb_tgt_as_t as, void *buf,
142 size_t len, mdb_tgt_addr_t addr)
143 {
144 switch ((uintptr_t)as) {
145 case (uintptr_t)MDB_TGT_AS_VIRT:
146 case (uintptr_t)MDB_TGT_AS_PHYS:
147 if (RF_CORE(t->t_data) != NULL)
148 return (rf_read(RF_CORE(t->t_data), buf, len, addr));
149 /*FALLTHRU*/
150 case (uintptr_t)MDB_TGT_AS_FILE:
151 return (rf_read(RF_OBJECT(t->t_data), buf, len, addr));
152 default:
153 return (set_errno(EMDB_NOMAP));
154 }
155 }
156
157 static ssize_t
158 rf_awrite(mdb_tgt_t *t, mdb_tgt_as_t as, const void *buf,
159 size_t len, mdb_tgt_addr_t addr)
160 {
161 switch ((uintptr_t)as) {
162 case (uintptr_t)MDB_TGT_AS_VIRT:
163 case (uintptr_t)MDB_TGT_AS_PHYS:
164 if (RF_CORE(t->t_data) != NULL)
165 return (rf_write(RF_CORE(t->t_data), buf, len, addr));
166 /*FALLTHRU*/
167 case (uintptr_t)MDB_TGT_AS_FILE:
168 return (rf_write(RF_OBJECT(t->t_data), buf, len, addr));
169 default:
170 return (set_errno(EMDB_NOMAP));
171 }
172 }
173
174 static ssize_t
175 rf_vread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
176 {
177 if (RF_CORE(t->t_data) != NULL)
178 return (rf_read(RF_CORE(t->t_data), buf, nbytes, addr));
179
180 return (rf_read(RF_OBJECT(t->t_data), buf, nbytes, addr));
181 }
182
183 static ssize_t
184 rf_vwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
185 {
186 if (RF_CORE(t->t_data) != NULL)
187 return (rf_write(RF_CORE(t->t_data), buf, nbytes, addr));
188
189 return (rf_write(RF_OBJECT(t->t_data), buf, nbytes, addr));
190 }
191
192 static ssize_t
193 rf_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr)
194 {
195 if (RF_CORE(t->t_data) != NULL)
196 return (rf_read(RF_CORE(t->t_data), buf, nbytes, addr));
197
198 return (rf_read(RF_OBJECT(t->t_data), buf, nbytes, addr));
199 }
200
201 static ssize_t
202 rf_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr)
203 {
204 if (RF_CORE(t->t_data) != NULL)
205 return (rf_write(RF_CORE(t->t_data), buf, nbytes, addr));
206
207 return (rf_write(RF_OBJECT(t->t_data), buf, nbytes, addr));
208 }
209
210 static ssize_t
211 rf_fread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
212 {
213 return (rf_read(RF_OBJECT(t->t_data), buf, nbytes, addr));
214 }
215
216 static ssize_t
217 rf_fwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
218 {
219 return (rf_write(RF_OBJECT(t->t_data), buf, nbytes, addr));
220 }
221
222
223 static int
224 rf_print_map(mdb_io_t *io, const char *type, int tflags,
225 mdb_tgt_map_f *func, void *private)
226 {
227 mdb_map_t map;
228
229 (void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ,
230 "%s (%s)", IOP_NAME(io), type);
231
232 map.map_base = 0;
233 map.map_size = IOP_SEEK(io, 0, SEEK_END);
234 map.map_flags = MDB_TGT_MAP_R;
235
236 if (tflags & MDB_TGT_F_RDWR)
237 map.map_flags |= MDB_TGT_MAP_W;
238
239 return (func(private, &map, map.map_name));
240 }
241
242 static int
243 rf_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
244 {
245 rf_data_t *rf = t->t_data;
246
247 if (rf->r_object_fio != NULL && rf_print_map(rf->r_object_fio,
248 "object file", t->t_flags, func, private) != 0)
249 return (0);
250
251 if (rf->r_core_fio != NULL && rf_print_map(rf->r_core_fio,
252 "core file", t->t_flags, func, private) != 0)
253 return (0);
254
255 return (0);
256 }
257
258 /*ARGSUSED*/
259 static int
260 rf_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
261 {
262 bzero(tsp, sizeof (mdb_tgt_status_t));
263
264 if (RF_CORE(t->t_data) != NULL)
265 tsp->st_state = MDB_TGT_DEAD;
266 else
267 tsp->st_state = MDB_TGT_IDLE;
268
269 return (0);
270 }
271
272 /*ARGSUSED*/
273 static int
274 rf_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
275 {
276 rf_data_t *rf = mdb.m_target->t_data;
277
278 if (rf->r_object_fio != NULL) {
279 mdb_printf("debugging file '%s' (object file)",
280 IOP_NAME(rf->r_object_fio));
281
282 if (rf->r_core_fio != NULL) {
283 mdb_printf(" and file '%s' (core file)",
284 IOP_NAME(rf->r_core_fio));
285 }
286
287 mdb_printf("\n");
288 } else {
289 mdb_printf("debugging empty target\n");
290 }
291
292 return (DCMD_OK);
293 }
294
295 static const mdb_dcmd_t rf_dcmds[] = {
296 { "status", NULL, "print summary of current target", rf_status_dcmd },
297 { NULL }
298 };
299
300 static const struct rf_magic {
301 const char *rfm_str;
302 size_t rfm_len;
303 const char *rfm_mod;
304 } rf_magic[] = {
305 { DOF_MAG_STRING, DOF_MAG_STRLEN, "dof" },
306 { NULL, 0, NULL }
307 };
308
309 static void
310 rf_activate(mdb_tgt_t *t)
311 {
312 rf_data_t *rf = t->t_data;
313 const struct rf_magic *m;
314 mdb_var_t *v;
315 off64_t size;
316
317 (void) mdb_tgt_register_dcmds(t, &rf_dcmds[0], MDB_MOD_FORCE);
318
319 /*
320 * We set the legacy adb variable 'd' to be the size of the file (data
321 * segment). To get this value, we call seek() on the underlying fdio.
322 */
323 if (rf->r_object_fio != NULL) {
324 size = IOP_SEEK(rf->r_object_fio, 0, SEEK_END);
325 if ((v = mdb_nv_lookup(&mdb.m_nv, "d")) != NULL)
326 mdb_nv_set_value(v, size);
327 }
328
329 /*
330 * Load any debugging support modules that match the file type, as
331 * determined by our poor man's /etc/magic. If many clients need
332 * to use this feature, rf_magic[] should be computed dynamically.
333 */
334 for (m = rf_magic; m->rfm_str != NULL; m++) {
335 char *buf = mdb_alloc(m->rfm_len, UM_SLEEP);
336
337 if (mdb_tgt_vread(t, buf, m->rfm_len, 0) == m->rfm_len &&
338 bcmp(buf, m->rfm_str, m->rfm_len) == 0) {
339 (void) mdb_module_load(m->rfm_mod,
340 MDB_MOD_LOCAL | MDB_MOD_SILENT);
341 }
342
343 mdb_free(buf, m->rfm_len);
344 }
345 }
346
347 static void
348 rf_deactivate(mdb_tgt_t *t)
349 {
350 const mdb_dcmd_t *dcp;
351
352 for (dcp = &rf_dcmds[0]; dcp->dc_name != NULL; dcp++) {
353 if (mdb_module_remove_dcmd(t->t_module, dcp->dc_name) == -1)
354 warn("failed to remove dcmd %s", dcp->dc_name);
355 }
356 }
357
358 static const mdb_tgt_ops_t rawfile_ops = {
359 rf_setflags, /* t_setflags */
360 (int (*)()) mdb_tgt_notsup, /* t_setcontext */
361 rf_activate, /* t_activate */
362 rf_deactivate, /* t_deactivate */
363 (void (*)()) mdb_tgt_nop, /* t_periodic */
364 rf_destroy, /* t_destroy */
365 rf_name, /* t_name */
366 (const char *(*)()) mdb_conf_isa, /* t_isa */
367 (const char *(*)()) mdb_conf_platform, /* t_platform */
368 (int (*)()) mdb_tgt_notsup, /* t_uname */
369 (int (*)()) mdb_tgt_notsup, /* t_dmodel */
370 rf_aread, /* t_aread */
371 rf_awrite, /* t_awrite */
372 rf_vread, /* t_vread */
373 rf_vwrite, /* t_vwrite */
374 rf_pread, /* t_pread */
375 rf_pwrite, /* t_pwrite */
376 rf_fread, /* t_fread */
377 rf_fwrite, /* t_fwrite */
378 (ssize_t (*)()) mdb_tgt_notsup, /* t_ioread */
379 (ssize_t (*)()) mdb_tgt_notsup, /* t_iowrite */
380 (int (*)()) mdb_tgt_notsup, /* t_vtop */
381 (int (*)()) mdb_tgt_notsup, /* t_lookup_by_name */
382 (int (*)()) mdb_tgt_notsup, /* t_lookup_by_addr */
383 (int (*)()) mdb_tgt_notsup, /* t_symbol_iter */
384 rf_mapping_iter, /* t_mapping_iter */
385 rf_mapping_iter, /* t_object_iter */
386 (const mdb_map_t *(*)()) mdb_tgt_null, /* t_addr_to_map */
387 (const mdb_map_t *(*)()) mdb_tgt_null, /* t_name_to_map */
388 (struct ctf_file *(*)()) mdb_tgt_null, /* t_addr_to_ctf */
389 (struct ctf_file *(*)()) mdb_tgt_null, /* t_name_to_ctf */
390 rf_status, /* t_status */
391 (int (*)()) mdb_tgt_notsup, /* t_run */
392 (int (*)()) mdb_tgt_notsup, /* t_step */
393 (int (*)()) mdb_tgt_notsup, /* t_step_out */
394 (int (*)()) mdb_tgt_notsup, /* t_next */
395 (int (*)()) mdb_tgt_notsup, /* t_cont */
396 (int (*)()) mdb_tgt_notsup, /* t_signal */
397 (int (*)()) mdb_tgt_null, /* t_add_vbrkpt */
398 (int (*)()) mdb_tgt_null, /* t_add_sbrkpt */
399 (int (*)()) mdb_tgt_null, /* t_add_pwapt */
400 (int (*)()) mdb_tgt_null, /* t_add_vwapt */
401 (int (*)()) mdb_tgt_null, /* t_add_iowapt */
402 (int (*)()) mdb_tgt_null, /* t_add_sysenter */
403 (int (*)()) mdb_tgt_null, /* t_add_sysexit */
404 (int (*)()) mdb_tgt_null, /* t_add_signal */
405 (int (*)()) mdb_tgt_null, /* t_add_fault */
406 (int (*)()) mdb_tgt_notsup, /* t_getareg */
407 (int (*)()) mdb_tgt_notsup, /* t_putareg */
408 (int (*)()) mdb_tgt_notsup, /* t_stack_iter */
409 (int (*)()) mdb_tgt_notsup /* t_auxv */
410 };
411
412 int
413 mdb_rawfile_tgt_create(mdb_tgt_t *t, int argc, const char *argv[])
414 {
415 mdb_io_t *io[2] = { NULL, NULL };
416 rf_data_t *rf;
417 int oflags, i;
418
419 if (argc > 2)
420 return (set_errno(EINVAL));
421
422 rf = mdb_zalloc(sizeof (rf_data_t), UM_SLEEP);
423 t->t_ops = &rawfile_ops;
424 t->t_data = rf;
425
426 if (t->t_flags & MDB_TGT_F_RDWR)
427 oflags = O_RDWR;
428 else
429 oflags = O_RDONLY;
430
431 for (i = 0; i < argc; i++) {
432 io[i] = mdb_fdio_create_path(NULL, argv[i], oflags, 0);
433 if (io[i] == NULL) {
434 warn("failed to open %s", argv[i]);
435 goto err;
436 }
437 }
438
439 rf->r_object_fio = io[0]; /* first file is the "object" */
440 rf->r_core_fio = io[1]; /* second file is the "core" */
441 t->t_flags |= MDB_TGT_F_ASIO; /* do i/o using aread and awrite */
442
443 return (0);
444
445 err:
446 for (i = 0; i < argc; i++) {
447 if (io[i] != NULL)
448 mdb_io_destroy(io[i]);
449 }
450
451
452 mdb_free(rf, sizeof (rf_data_t));
453 return (set_errno(EMDB_TGT));
454 }