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