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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/sysinfo.h> 30 #include <sys/nvpair.h> 31 #include <sys/nvpair_impl.h> 32 33 #include <ctype.h> 34 #include <mdb/mdb_modapi.h> 35 36 #include "nvpair.h" 37 38 #define NVPAIR_VALUE_INDENT 4 39 #define NELEM(a) (sizeof (a) / sizeof ((a)[0])) 40 41 /* 42 * nvpair walker 43 */ 44 int 45 nvpair_walk_init(mdb_walk_state_t *wsp) 46 { 47 nvlist_t nvlist; 48 nvpriv_t nvpriv; 49 i_nvp_t *tmp; 50 51 if (wsp->walk_addr == NULL) { 52 mdb_warn("nvpair does not support global walks\n"); 53 return (WALK_ERR); 54 } 55 56 if (mdb_vread(&nvlist, sizeof (nvlist), wsp->walk_addr) == -1) { 57 mdb_warn("failed to read nvlist at %p", wsp->walk_addr); 58 return (WALK_ERR); 59 } 60 61 if (mdb_vread(&nvpriv, sizeof (nvpriv), nvlist.nvl_priv) == -1) { 62 mdb_warn("failed to read nvpriv at %p", nvlist.nvl_priv); 63 return (WALK_ERR); 64 } 65 66 tmp = (i_nvp_t *)nvpriv.nvp_list; 67 wsp->walk_addr = (uintptr_t)tmp; 68 return (WALK_NEXT); 69 } 70 71 int 72 nvpair_walk_step(mdb_walk_state_t *wsp) 73 { 74 int status; 75 nvpair_t *nvpair; 76 i_nvp_t i_nvp, *tmp; 77 78 if (wsp->walk_addr == NULL) 79 return (WALK_DONE); 80 81 if (mdb_vread(&i_nvp, sizeof (i_nvp), wsp->walk_addr) == -1) { 82 mdb_warn("failed to read i_nvp at %p", wsp->walk_addr); 83 return (WALK_ERR); 84 } 85 86 nvpair = &((i_nvp_t *)wsp->walk_addr)->nvi_nvp; 87 status = wsp->walk_callback((uintptr_t)nvpair, NULL, wsp->walk_cbdata); 88 89 tmp = i_nvp.nvi_next; 90 wsp->walk_addr = (uintptr_t)tmp; 91 return (status); 92 } 93 94 /* 95 * ::nvlist [-v] 96 * 97 * Print out an entire nvlist. This is shorthand for '::walk nvpair | 98 * ::nvpair -rq'. The '-v' option invokes '::nvpair' without the "-q" option. 99 */ 100 /*ARGSUSED*/ 101 int 102 nvlist_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 103 { 104 int verbose = B_FALSE; 105 mdb_arg_t v; 106 107 if (!(flags & DCMD_ADDRSPEC)) 108 return (DCMD_USAGE); 109 110 if (mdb_getopts(argc, argv, 111 'v', MDB_OPT_SETBITS, TRUE, &verbose, 112 NULL) != argc) 113 return (DCMD_USAGE); 114 115 v.a_type = MDB_TYPE_STRING; 116 if (verbose) 117 v.a_un.a_str = "-r"; 118 else 119 v.a_un.a_str = "-rq"; 120 121 return (mdb_pwalk_dcmd("nvpair", "nvpair", 1, &v, addr)); 122 } 123 124 /* 125 * ::nvpair [-rq] 126 * 127 * -r Recursively print any nvlist elements 128 * -q Quiet mode; print members only as "name=value" 129 * 130 * Prints out a single nvpair. By default, all information is printed. When 131 * given the '-q' option, the type of elements is hidden, and elements are 132 * instead printed simply as 'name=value'. 133 */ 134 typedef struct { 135 data_type_t type; 136 int elem_size; 137 char *type_name; 138 } nvpair_info_t; 139 140 nvpair_info_t nvpair_info[] = { 141 { DATA_TYPE_BOOLEAN, 1, "boolean" }, 142 { DATA_TYPE_BOOLEAN_VALUE, 4, "boolean_value" }, 143 { DATA_TYPE_BYTE, 1, "byte" }, 144 { DATA_TYPE_INT8, 1, "int8" }, 145 { DATA_TYPE_UINT8, 1, "uint8" }, 146 { DATA_TYPE_INT16, 2, "int16" }, 147 { DATA_TYPE_UINT16, 2, "uint16" }, 148 { DATA_TYPE_INT32, 4, "int32" }, 149 { DATA_TYPE_UINT32, 4, "uint32" }, 150 { DATA_TYPE_INT64, 8, "int64" }, 151 { DATA_TYPE_UINT64, 8, "uint64" }, 152 { DATA_TYPE_STRING, 0, "string" }, 153 { DATA_TYPE_NVLIST, 0, "nvpair_list" }, 154 { DATA_TYPE_HRTIME, 8, "hrtime" }, 155 { DATA_TYPE_BOOLEAN_ARRAY, 4, "boolean_array" }, 156 { DATA_TYPE_BYTE_ARRAY, 1, "byte_array" }, 157 { DATA_TYPE_INT8_ARRAY, 1, "int8_array" }, 158 { DATA_TYPE_UINT8_ARRAY, 1, "uint8_array" }, 159 { DATA_TYPE_INT16_ARRAY, 2, "int16_array" }, 160 { DATA_TYPE_UINT16_ARRAY, 2, "uint16_array" }, 161 { DATA_TYPE_INT32_ARRAY, 4, "int32_array" }, 162 { DATA_TYPE_UINT32_ARRAY, 4, "uint32_array" }, 163 { DATA_TYPE_INT64_ARRAY, 8, "int64_array" }, 164 { DATA_TYPE_UINT64_ARRAY, 8, "uint64_array" }, 165 { DATA_TYPE_STRING_ARRAY, 0, "string_array" }, 166 { DATA_TYPE_NVLIST_ARRAY, 0, "nvpair list_array" } 167 }; 168 169 static void 170 nvpair_print_value(char *data, int32_t elem_size, int32_t nelem, 171 data_type_t type) 172 { 173 int32_t i; 174 175 if (elem_size == 0) { 176 char *p = data; 177 178 /* print out all the strings */ 179 for (i = 0; i < nelem - 1; i++) { 180 mdb_printf("'%s' + ", p); 181 p += strlen(p) + 1; 182 } 183 mdb_printf("'%s'", p); 184 } else if (type == DATA_TYPE_BOOLEAN_VALUE || 185 type == DATA_TYPE_BOOLEAN_ARRAY) { 186 /* LINTED - pointer alignment */ 187 boolean_t *p = (boolean_t *)data; 188 189 for (i = 0; i < nelem; i++) { 190 if (i > 0) 191 mdb_printf("."); 192 mdb_printf("%d", p[i]); 193 } 194 } else { 195 unsigned char *p = (unsigned char *)data; 196 int size = elem_size * nelem; 197 198 /* 199 * if elem_size != 0 then we are printing out an array 200 * where each element is of elem_size 201 */ 202 mdb_nhconvert(p, p, elem_size); 203 mdb_printf("%02x", *p); 204 for (i = 1; i < size; i++) { 205 if ((i % elem_size) == 0) { 206 mdb_nhconvert(&p[i], &p[i], elem_size); 207 mdb_printf("."); 208 } 209 mdb_printf("%02x", p[i]); 210 } 211 } 212 mdb_printf("\n"); 213 } 214 215 /*ARGSUSED*/ 216 int 217 nvpair_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 218 { 219 nvpair_t nvpair_tmp, *nvpair; 220 int32_t i, size, nelem, elem_size = 0; 221 char *data = NULL, *data_end = NULL; 222 char *type_name = NULL; 223 data_type_t type = DATA_TYPE_UNKNOWN; 224 int quiet = FALSE; 225 int recurse = FALSE; 226 227 if (!(flags & DCMD_ADDRSPEC)) 228 return (DCMD_USAGE); 229 230 if (mdb_getopts(argc, argv, 231 'r', MDB_OPT_SETBITS, TRUE, &recurse, 232 'q', MDB_OPT_SETBITS, TRUE, &quiet, 233 NULL) != argc) 234 return (DCMD_USAGE); 235 236 /* read in the nvpair header so we can get the size */ 237 if (mdb_vread(&nvpair_tmp, sizeof (nvpair), addr) == -1) { 238 mdb_warn("failed to read nvpair at %p", addr); 239 return (DCMD_ERR); 240 } 241 size = NVP_SIZE(&nvpair_tmp); 242 if (size == 0) { 243 mdb_warn("nvpair of size zero at %p", addr); 244 return (DCMD_OK); 245 } 246 247 /* read in the entire nvpair */ 248 nvpair = mdb_alloc(size, UM_SLEEP | UM_GC); 249 if (mdb_vread(nvpair, size, addr) == -1) { 250 mdb_warn("failed to read nvpair and data at %p", addr); 251 return (DCMD_ERR); 252 } 253 254 /* lookup type decoding information for this nvpair */ 255 type = NVP_TYPE(nvpair); 256 nelem = NVP_NELEM(nvpair); 257 for (i = 0; i < NELEM(nvpair_info); i++) { 258 if (nvpair_info[i].type == type) { 259 elem_size = nvpair_info[i].elem_size; 260 type_name = nvpair_info[i].type_name; 261 break; 262 } 263 } 264 265 if (quiet) { 266 mdb_printf("%s", NVP_NAME(nvpair)); 267 } else { 268 /* print out the first line of nvpair info */ 269 mdb_printf("name='%s'", NVP_NAME(nvpair)); 270 if (type_name != NULL) { 271 mdb_printf(" type=%s", type_name); 272 } else { 273 /* 274 * If the nvpair type is unknown we print the type 275 * number 276 */ 277 mdb_printf(" type=0x%x", type); 278 } 279 mdb_printf(" items=%d\n", nelem); 280 } 281 282 /* if there is no data and the type is known then we're done */ 283 if ((nelem == 0) && (type_name != NULL)) { 284 if (quiet) 285 mdb_printf("(unknown)\n"); 286 return (DCMD_OK); 287 } 288 289 /* get pointers to the data to print out */ 290 data = (char *)NVP_VALUE(nvpair); 291 data_end = (char *)nvpair + NVP_SIZE(nvpair); 292 293 /* 294 * The value of the name-value pair for a single embedded 295 * list is the nvlist_t structure for the embedded list. 296 * So we print that address out (computed as an offset from 297 * the nvpair address we received as addr). 298 * 299 * The value of the name-value pair for an array of embedded 300 * lists is nelem pointers to nvlist_t structures followed 301 * by the structures themselves. We display the list 302 * of pointers as the pair's value. 303 */ 304 if (type == DATA_TYPE_NVLIST) { 305 char *p = (char *)addr + (data - (char *)nvpair); 306 if (recurse) { 307 if (quiet) 308 mdb_printf("\n"); 309 mdb_inc_indent(NVPAIR_VALUE_INDENT); 310 if (mdb_pwalk_dcmd("nvpair", "nvpair", argc, argv, 311 (uintptr_t)p) != DCMD_OK) 312 return (DCMD_ERR); 313 mdb_dec_indent(NVPAIR_VALUE_INDENT); 314 } else { 315 if (!quiet) { 316 mdb_inc_indent(NVPAIR_VALUE_INDENT); 317 mdb_printf("value", p); 318 } 319 mdb_printf("=%p\n", p); 320 if (!quiet) 321 mdb_dec_indent(NVPAIR_VALUE_INDENT); 322 } 323 return (DCMD_OK); 324 325 } else if (type == DATA_TYPE_NVLIST_ARRAY) { 326 if (recurse) { 327 for (i = 0; i < nelem; i++, 328 data += sizeof (nvlist_t *)) { 329 nvlist_t **nl = (nvlist_t **)(void *)data; 330 if (quiet && i != 0) 331 mdb_printf("%s", NVP_NAME(nvpair)); 332 mdb_printf("[%d]\n", i); 333 mdb_inc_indent(NVPAIR_VALUE_INDENT); 334 if (mdb_pwalk_dcmd("nvpair", "nvpair", argc, 335 argv, (uintptr_t)*nl) != DCMD_OK) 336 return (DCMD_ERR); 337 mdb_dec_indent(NVPAIR_VALUE_INDENT); 338 } 339 } else { 340 if (!quiet) { 341 mdb_inc_indent(NVPAIR_VALUE_INDENT); 342 mdb_printf("value"); 343 } 344 mdb_printf("="); 345 for (i = 0; i < nelem; i++, 346 data += sizeof (nvlist_t *)) { 347 nvlist_t **nl = (nvlist_t **)(void *)data; 348 mdb_printf("%c%p", " "[i == 0], *nl); 349 } 350 mdb_printf("\n"); 351 if (!quiet) 352 mdb_dec_indent(NVPAIR_VALUE_INDENT); 353 } 354 return (DCMD_OK); 355 } 356 357 /* if it's a string array, skip the index pointers */ 358 if (type == DATA_TYPE_STRING_ARRAY) 359 data += (sizeof (int64_t) * nelem); 360 361 /* if the type is unknown, treat the data as a byte array */ 362 if (type_name == NULL) { 363 elem_size = 1; 364 nelem = data_end - data; 365 } 366 367 /* 368 * if the type is of strings, make sure they are printable 369 * otherwise print them out as byte arrays 370 */ 371 if (elem_size == 0) { 372 int32_t count = 0; 373 374 i = 0; 375 while ((&data[i] < data_end) && (count < nelem)) { 376 if (data[i] == '\0') 377 count++; 378 else if (!isprint(data[i])) 379 break; 380 i++; 381 } 382 if (count != nelem) { 383 /* there is unprintable data, output as byte array */ 384 elem_size = 1; 385 nelem = data_end - data; 386 } 387 } 388 389 if (!quiet) { 390 mdb_inc_indent(NVPAIR_VALUE_INDENT); 391 mdb_printf("value="); 392 } else { 393 mdb_printf("="); 394 } 395 nvpair_print_value(data, elem_size, nelem, type); 396 if (!quiet) 397 mdb_dec_indent(NVPAIR_VALUE_INDENT); 398 399 return (DCMD_OK); 400 } 401