usr/src/cmd/mdb/common/mdb/mdb_rawfile.c

   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 }