xref: /illumos-gate/usr/src/common/elfcap/elfcap.c (revision 6a634c9d)
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 /*
23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /* LINTLIBRARY */
27 
28 /*
29  * String conversion routine for hardware capabilities types.
30  */
31 #include	<strings.h>
32 #include	<stdio.h>
33 #include	<ctype.h>
34 #include	<sys/machelf.h>
35 #include	<sys/elf.h>
36 #include	<sys/auxv_SPARC.h>
37 #include	<sys/auxv_386.h>
38 #include	<elfcap.h>
39 
40 /*
41  * Given a literal string, generate an initialization for an
42  * elfcap_str_t value.
43  */
44 #define	STRDESC(_str) { _str, sizeof (_str) - 1 }
45 
46 /*
47  * The items in the elfcap_desc_t arrays are required to be
48  * ordered so that the array index is related to the
49  * c_val field as:
50  *
51  *	array[ndx].c_val = 2^ndx
52  *
53  * meaning that
54  *
55  *	array[0].c_val = 2^0 = 1
56  *	array[1].c_val = 2^1 = 2
57  *	array[2].c_val = 2^2 = 4
58  *	.
59  *	.
60  *	.
61  *
62  * Since 0 is not a valid value for the c_val field, we use it to
63  * mark an array entry that is a placeholder. This can happen if there
64  * is a hole in the assigned bits.
65  *
66  * The RESERVED_ELFCAP_DESC macro is used to reserve such holes.
67  */
68 #define	RESERVED_ELFCAP_DESC { 0, { NULL, 0 }, { NULL, 0 }, { NULL, 0 } }
69 
70 /*
71  * Define separators for output string processing. This must be kept in
72  * sync with the elfcap_fmt_t values in elfcap.h.
73  */
74 static const elfcap_str_t format[] = {
75 	STRDESC(" "),			/* ELFCAP_FMT_SNGSPACE */
76 	STRDESC("  "),			/* ELFCAP_FMT_DBLSPACE */
77 	STRDESC(" | ")			/* ELFCAP_FMT_PIPSPACE */
78 };
79 #define	FORMAT_NELTS	(sizeof (format) / sizeof (format[0]))
80 
81 
82 
83 /*
84  * Define all known software capabilities in all the supported styles.
85  * Order the capabilities by their numeric value. See SF1_SUNW_
86  * values in sys/elf.h.
87  */
88 static const elfcap_desc_t sf1[ELFCAP_NUM_SF1] = {
89 	{						/* 0x00000001 */
90 		SF1_SUNW_FPKNWN, STRDESC("SF1_SUNW_FPKNWN"),
91 		STRDESC("FPKNWN"), STRDESC("fpknwn")
92 	},
93 	{						/* 0x00000002 */
94 		SF1_SUNW_FPUSED, STRDESC("SF1_SUNW_FPUSED"),
95 		STRDESC("FPUSED"), STRDESC("fpused"),
96 	},
97 	{						/* 0x00000004 */
98 		SF1_SUNW_ADDR32, STRDESC("SF1_SUNW_ADDR32"),
99 		STRDESC("ADDR32"), STRDESC("addr32"),
100 	}
101 };
102 
103 
104 
105 /*
106  * Order the SPARC hardware capabilities to match their numeric value.  See
107  * AV_SPARC_ values in sys/auxv_SPARC.h.
108  */
109 static const elfcap_desc_t hw1_sparc[ELFCAP_NUM_HW1_SPARC] = {
110 	{						/* 0x00000001 */
111 		AV_SPARC_MUL32, STRDESC("AV_SPARC_MUL32"),
112 		STRDESC("MUL32"), STRDESC("mul32"),
113 	},
114 	{						/* 0x00000002 */
115 		AV_SPARC_DIV32, STRDESC("AV_SPARC_DIV32"),
116 		STRDESC("DIV32"), STRDESC("div32"),
117 	},
118 	{						/* 0x00000004 */
119 		AV_SPARC_FSMULD, STRDESC("AV_SPARC_FSMULD"),
120 		STRDESC("FSMULD"), STRDESC("fsmuld"),
121 	},
122 	{						/* 0x00000008 */
123 		AV_SPARC_V8PLUS, STRDESC("AV_SPARC_V8PLUS"),
124 		STRDESC("V8PLUS"), STRDESC("v8plus"),
125 	},
126 	{						/* 0x00000010 */
127 		AV_SPARC_POPC, STRDESC("AV_SPARC_POPC"),
128 		STRDESC("POPC"), STRDESC("popc"),
129 	},
130 	{						/* 0x00000020 */
131 		AV_SPARC_VIS, STRDESC("AV_SPARC_VIS"),
132 		STRDESC("VIS"), STRDESC("vis"),
133 	},
134 	{						/* 0x00000040 */
135 		AV_SPARC_VIS2, STRDESC("AV_SPARC_VIS2"),
136 		STRDESC("VIS2"), STRDESC("vis2"),
137 	},
138 	{						/* 0x00000080 */
139 		AV_SPARC_ASI_BLK_INIT, STRDESC("AV_SPARC_ASI_BLK_INIT"),
140 		STRDESC("ASI_BLK_INIT"), STRDESC("asi_blk_init"),
141 	},
142 	{						/* 0x00000100 */
143 		AV_SPARC_FMAF, STRDESC("AV_SPARC_FMAF"),
144 		STRDESC("FMAF"), STRDESC("fmaf"),
145 	},
146 	RESERVED_ELFCAP_DESC,				/* 0x00000200 */
147 	{						/* 0x00000400 */
148 		AV_SPARC_VIS3, STRDESC("AV_SPARC_VIS3"),
149 		STRDESC("VIS3"), STRDESC("vis3"),
150 	},
151 	{						/* 0x00000800 */
152 		AV_SPARC_HPC, STRDESC("AV_SPARC_HPC"),
153 		STRDESC("HPC"), STRDESC("hpc"),
154 	},
155 	{						/* 0x00001000 */
156 		AV_SPARC_RANDOM, STRDESC("AV_SPARC_RANDOM"),
157 		STRDESC("RANDOM"), STRDESC("random"),
158 	},
159 	{						/* 0x00002000 */
160 		AV_SPARC_TRANS, STRDESC("AV_SPARC_TRANS"),
161 		STRDESC("TRANS"), STRDESC("trans"),
162 	},
163 	{						/* 0x00004000 */
164 		AV_SPARC_FJFMAU, STRDESC("AV_SPARC_FJFMAU"),
165 		STRDESC("FJFMAU"), STRDESC("fjfmau"),
166 	},
167 	{						/* 0x00008000 */
168 		AV_SPARC_IMA, STRDESC("AV_SPARC_IMA"),
169 		STRDESC("IMA"), STRDESC("ima"),
170 	},
171 	{						/* 0x00010000 */
172 		AV_SPARC_ASI_CACHE_SPARING,
173 		STRDESC("AV_SPARC_ASI_CACHE_SPARING"),
174 		STRDESC("CSPARE"), STRDESC("cspare"),
175 	}
176 };
177 
178 
179 
180 /*
181  * Order the Intel hardware capabilities to match their numeric value.  See
182  * AV_386_ values in sys/auxv_386.h.
183  */
184 static const elfcap_desc_t hw1_386[ELFCAP_NUM_HW1_386] = {
185 	{						/* 0x00000001 */
186 		AV_386_FPU, STRDESC("AV_386_FPU"),
187 		STRDESC("FPU"), STRDESC("fpu"),
188 	},
189 	{						/* 0x00000002 */
190 		AV_386_TSC, STRDESC("AV_386_TSC"),
191 		STRDESC("TSC"), STRDESC("tsc"),
192 	},
193 	{						/* 0x00000004 */
194 		AV_386_CX8, STRDESC("AV_386_CX8"),
195 		STRDESC("CX8"), STRDESC("cx8"),
196 	},
197 	{						/* 0x00000008 */
198 		AV_386_SEP, STRDESC("AV_386_SEP"),
199 		STRDESC("SEP"), STRDESC("sep"),
200 	},
201 	{						/* 0x00000010 */
202 		AV_386_AMD_SYSC, STRDESC("AV_386_AMD_SYSC"),
203 		STRDESC("AMD_SYSC"), STRDESC("amd_sysc"),
204 	},
205 	{						/* 0x00000020 */
206 		AV_386_CMOV, STRDESC("AV_386_CMOV"),
207 		STRDESC("CMOV"), STRDESC("cmov"),
208 	},
209 	{						/* 0x00000040 */
210 		AV_386_MMX, STRDESC("AV_386_MMX"),
211 		STRDESC("MMX"), STRDESC("mmx"),
212 	},
213 	{						/* 0x00000080 */
214 		AV_386_AMD_MMX, STRDESC("AV_386_AMD_MMX"),
215 		STRDESC("AMD_MMX"), STRDESC("amd_mmx"),
216 	},
217 	{						/* 0x00000100 */
218 		AV_386_AMD_3DNow, STRDESC("AV_386_AMD_3DNow"),
219 		STRDESC("AMD_3DNow"), STRDESC("amd_3dnow"),
220 	},
221 	{						/* 0x00000200 */
222 		AV_386_AMD_3DNowx, STRDESC("AV_386_AMD_3DNowx"),
223 		STRDESC("AMD_3DNowx"), STRDESC("amd_3dnowx"),
224 	},
225 	{						/* 0x00000400 */
226 		AV_386_FXSR, STRDESC("AV_386_FXSR"),
227 		STRDESC("FXSR"), STRDESC("fxsr"),
228 	},
229 	{						/* 0x00000800 */
230 		AV_386_SSE, STRDESC("AV_386_SSE"),
231 		STRDESC("SSE"), STRDESC("sse"),
232 	},
233 	{						/* 0x00001000 */
234 		AV_386_SSE2, STRDESC("AV_386_SSE2"),
235 		STRDESC("SSE2"), STRDESC("sse2"),
236 	},
237 	/* 0x02000 withdrawn - do not assign */
238 	{						/* 0x00004000 */
239 		AV_386_SSE3, STRDESC("AV_386_SSE3"),
240 		STRDESC("SSE3"), STRDESC("sse3"),
241 	},
242 	/* 0x08000 withdrawn - do not assign */
243 	{						/* 0x00010000 */
244 		AV_386_CX16, STRDESC("AV_386_CX16"),
245 		STRDESC("CX16"), STRDESC("cx16"),
246 	},
247 	{						/* 0x00020000 */
248 		AV_386_AHF, STRDESC("AV_386_AHF"),
249 		STRDESC("AHF"), STRDESC("ahf"),
250 	},
251 	{						/* 0x00040000 */
252 		AV_386_TSCP, STRDESC("AV_386_TSCP"),
253 		STRDESC("TSCP"), STRDESC("tscp"),
254 	},
255 	{						/* 0x00080000 */
256 		AV_386_AMD_SSE4A, STRDESC("AV_386_AMD_SSE4A"),
257 		STRDESC("AMD_SSE4A"), STRDESC("amd_sse4a"),
258 	},
259 	{						/* 0x00100000 */
260 		AV_386_POPCNT, STRDESC("AV_386_POPCNT"),
261 		STRDESC("POPCNT"), STRDESC("popcnt"),
262 	},
263 	{						/* 0x00200000 */
264 		AV_386_AMD_LZCNT, STRDESC("AV_386_AMD_LZCNT"),
265 		STRDESC("AMD_LZCNT"), STRDESC("amd_lzcnt"),
266 	},
267 	{						/* 0x00400000 */
268 		AV_386_SSSE3, STRDESC("AV_386_SSSE3"),
269 		STRDESC("SSSE3"), STRDESC("ssse3"),
270 	},
271 	{						/* 0x00800000 */
272 		AV_386_SSE4_1, STRDESC("AV_386_SSE4_1"),
273 		STRDESC("SSE4.1"), STRDESC("sse4.1"),
274 	},
275 	{						/* 0x01000000 */
276 		AV_386_SSE4_2, STRDESC("AV_386_SSE4_2"),
277 		STRDESC("SSE4.2"), STRDESC("sse4.2"),
278 	},
279 	{						/* 0x02000000 */
280 		AV_386_MOVBE, STRDESC("AV_386_MOVBE"),
281 		STRDESC("MOVBE"), STRDESC("movbe"),
282 	},
283 	{						/* 0x04000000 */
284 		AV_386_AES, STRDESC("AV_386_AES"),
285 		STRDESC("AES"), STRDESC("aes"),
286 	},
287 	{						/* 0x08000000 */
288 		AV_386_PCLMULQDQ, STRDESC("AV_386_PCLMULQDQ"),
289 		STRDESC("PCLMULQDQ"), STRDESC("pclmulqdq"),
290 	},
291 	{						/* 0x10000000 */
292 		AV_386_XSAVE, STRDESC("AV_386_XSAVE"),
293 		STRDESC("XSAVE"), STRDESC("xsave"),
294 	},
295 	{						/* 0x20000000 */
296 		AV_386_AVX, STRDESC("AV_386_AVX"),
297 		STRDESC("AVX"), STRDESC("avx"),
298 	}
299 };
300 
301 /*
302  * Concatenate a token to the string buffer.  This can be a capabilities token
303  * or a separator token.
304  */
305 static elfcap_err_t
306 token(char **ostr, size_t *olen, const elfcap_str_t *nstr)
307 {
308 	if (*olen < nstr->s_len)
309 		return (ELFCAP_ERR_BUFOVFL);
310 
311 	(void) strcat(*ostr, nstr->s_str);
312 	*ostr += nstr->s_len;
313 	*olen -= nstr->s_len;
314 
315 	return (ELFCAP_ERR_NONE);
316 }
317 
318 static elfcap_err_t
319 get_str_desc(elfcap_style_t style, const elfcap_desc_t *cdp,
320     const elfcap_str_t **ret_str)
321 {
322 	switch (ELFCAP_STYLE_MASK(style)) {
323 	case ELFCAP_STYLE_FULL:
324 		*ret_str = &cdp->c_full;
325 		break;
326 	case ELFCAP_STYLE_UC:
327 		*ret_str = &cdp->c_uc;
328 		break;
329 	case ELFCAP_STYLE_LC:
330 		*ret_str = &cdp->c_lc;
331 		break;
332 	default:
333 		return (ELFCAP_ERR_INVSTYLE);
334 	}
335 
336 	return (ELFCAP_ERR_NONE);
337 }
338 
339 
340 /*
341  * Expand a capabilities value into the strings defined in the associated
342  * capabilities descriptor.
343  */
344 static elfcap_err_t
345 expand(elfcap_style_t style, elfcap_mask_t val, const elfcap_desc_t *cdp,
346     uint_t cnum, char *str, size_t slen, elfcap_fmt_t fmt)
347 {
348 	uint_t			cnt;
349 	int			follow = 0, err;
350 	const elfcap_str_t	*nstr;
351 
352 	if (val == 0)
353 		return (ELFCAP_ERR_NONE);
354 
355 	for (cnt = cnum; cnt > 0; cnt--) {
356 		uint_t mask = cdp[cnt - 1].c_val;
357 
358 		if ((val & mask) != 0) {
359 			if (follow++ && ((err = token(&str, &slen,
360 			    &format[fmt])) != ELFCAP_ERR_NONE))
361 				return (err);
362 
363 			err = get_str_desc(style, &cdp[cnt - 1], &nstr);
364 			if (err != ELFCAP_ERR_NONE)
365 				return (err);
366 			if ((err = token(&str, &slen, nstr)) != ELFCAP_ERR_NONE)
367 				return (err);
368 
369 			val = val & ~mask;
370 		}
371 	}
372 
373 	/*
374 	 * If there are any unknown bits remaining display the numeric value.
375 	 */
376 	if (val) {
377 		if (follow && ((err = token(&str, &slen, &format[fmt])) !=
378 		    ELFCAP_ERR_NONE))
379 			return (err);
380 
381 		(void) snprintf(str, slen, "0x%x", val);
382 	}
383 	return (ELFCAP_ERR_NONE);
384 }
385 
386 /*
387  * Expand a CA_SUNW_HW_1 value.
388  */
389 elfcap_err_t
390 elfcap_hw1_to_str(elfcap_style_t style, elfcap_mask_t val, char *str,
391     size_t len, elfcap_fmt_t fmt, ushort_t mach)
392 {
393 	/*
394 	 * Initialize the string buffer, and validate the format request.
395 	 */
396 	*str = '\0';
397 	if ((fmt < 0) || (fmt >= FORMAT_NELTS))
398 		return (ELFCAP_ERR_INVFMT);
399 
400 	if ((mach == EM_386) || (mach == EM_IA_64) || (mach == EM_AMD64))
401 		return (expand(style, val, &hw1_386[0], ELFCAP_NUM_HW1_386,
402 		    str, len, fmt));
403 
404 	if ((mach == EM_SPARC) || (mach == EM_SPARC32PLUS) ||
405 	    (mach == EM_SPARCV9))
406 		return (expand(style, val, hw1_sparc, ELFCAP_NUM_HW1_SPARC,
407 		    str, len, fmt));
408 
409 	return (ELFCAP_ERR_UNKMACH);
410 }
411 
412 /*
413  * Expand a CA_SUNW_HW_2 value.  Presently, there are no values, this routine
414  * is simply a place holder for future development.
415  */
416 elfcap_err_t
417 /* ARGSUSED0 */
418 elfcap_hw2_to_str(elfcap_style_t style, elfcap_mask_t val, char *str,
419     size_t len, elfcap_fmt_t fmt, ushort_t mach)
420 {
421 	/*
422 	 * Initialize the string buffer, and validate the format request.
423 	 */
424 	*str = '\0';
425 	if ((fmt < 0) || (fmt >= FORMAT_NELTS))
426 		return (ELFCAP_ERR_INVFMT);
427 
428 	return (expand(style, val, NULL, 0, str, len, fmt));
429 }
430 
431 /*
432  * Expand a CA_SUNW_SF_1 value.  Note, that at present these capabilities are
433  * common across all platforms.  The use of "mach" is therefore redundant, but
434  * is retained for compatibility with the interface of elfcap_hw1_to_str(), and
435  * possible future expansion.
436  */
437 elfcap_err_t
438 /* ARGSUSED4 */
439 elfcap_sf1_to_str(elfcap_style_t style, elfcap_mask_t val, char *str,
440     size_t len, elfcap_fmt_t fmt, ushort_t mach)
441 {
442 	/*
443 	 * Initialize the string buffer, and validate the format request.
444 	 */
445 	*str = '\0';
446 	if ((fmt < 0) || (fmt >= FORMAT_NELTS))
447 		return (ELFCAP_ERR_INVFMT);
448 
449 	return (expand(style, val, &sf1[0], ELFCAP_NUM_SF1, str, len, fmt));
450 }
451 
452 /*
453  * Given a capability tag type and value, map it to a string representation.
454  */
455 elfcap_err_t
456 elfcap_tag_to_str(elfcap_style_t style, uint64_t tag, elfcap_mask_t val,
457     char *str, size_t len, elfcap_fmt_t fmt, ushort_t mach)
458 {
459 	switch (tag) {
460 	case CA_SUNW_HW_1:
461 		return (elfcap_hw1_to_str(style, val, str, len, fmt, mach));
462 
463 	case CA_SUNW_SF_1:
464 		return (elfcap_sf1_to_str(style, val, str, len, fmt, mach));
465 
466 	case CA_SUNW_HW_2:
467 		return (elfcap_hw2_to_str(style, val, str, len, fmt, mach));
468 
469 	}
470 
471 	return (ELFCAP_ERR_UNKTAG);
472 }
473 
474 /*
475  * Determine a capabilities value from a capabilities string.
476  */
477 static elfcap_mask_t
478 value(elfcap_style_t style, const char *str, const elfcap_desc_t *cdp,
479     uint_t cnum)
480 {
481 	const elfcap_str_t	*nstr;
482 	uint_t	num;
483 	int	err;
484 
485 	for (num = 0; num < cnum; num++) {
486 		/*
487 		 * Skip "reserved" bits. These are unassigned bits in the
488 		 * middle of the assigned range.
489 		 */
490 		if (cdp[num].c_val == 0)
491 			continue;
492 
493 		if ((err = get_str_desc(style, &cdp[num], &nstr)) != 0)
494 			return (err);
495 		if (style & ELFCAP_STYLE_F_ICMP) {
496 			if (strcasecmp(str, nstr->s_str) == 0)
497 				return (cdp[num].c_val);
498 		} else {
499 			if (strcmp(str, nstr->s_str) == 0)
500 				return (cdp[num].c_val);
501 		}
502 	}
503 
504 	return (0);
505 }
506 
507 elfcap_mask_t
508 elfcap_sf1_from_str(elfcap_style_t style, const char *str, ushort_t mach)
509 {
510 	return (value(style, str, &sf1[0], ELFCAP_NUM_SF1));
511 }
512 
513 elfcap_mask_t
514 elfcap_hw1_from_str(elfcap_style_t style, const char *str, ushort_t mach)
515 {
516 	if ((mach == EM_386) || (mach == EM_IA_64) || (mach == EM_AMD64))
517 		return (value(style, str, &hw1_386[0], ELFCAP_NUM_HW1_386));
518 
519 	if ((mach == EM_SPARC) || (mach == EM_SPARC32PLUS) ||
520 	    (mach == EM_SPARCV9))
521 		return (value(style, str, hw1_sparc, ELFCAP_NUM_HW1_SPARC));
522 
523 	return (0);
524 }
525 elfcap_mask_t
526 /* ARGSUSED0 */
527 elfcap_hw2_from_str(elfcap_style_t style, const char *str, ushort_t mach)
528 {
529 	return (0);
530 }
531 
532 /*
533  * Given a capability tag type and value, return the capabilities values
534  * contained in the string.
535  */
536 elfcap_mask_t
537 elfcap_tag_from_str(elfcap_style_t style, uint64_t tag, const char *str,
538     ushort_t mach)
539 {
540 	switch (tag) {
541 	case CA_SUNW_HW_1:
542 		return (elfcap_hw1_from_str(style, str, mach));
543 
544 	case CA_SUNW_SF_1:
545 		return (elfcap_sf1_from_str(style, str, mach));
546 
547 	case CA_SUNW_HW_2:
548 		return (elfcap_hw2_from_str(style, str, mach));
549 	}
550 
551 	return (0);
552 }
553 
554 /*
555  * These functions allow the caller to get direct access to the
556  * cap descriptors.
557  */
558 const elfcap_desc_t *
559 elfcap_getdesc_hw1_sparc(void)
560 {
561 	return (hw1_sparc);
562 }
563 
564 const elfcap_desc_t *
565 elfcap_getdesc_hw1_386(void)
566 {
567 	return (hw1_386);
568 }
569 
570 const elfcap_desc_t *
571 elfcap_getdesc_sf1(void)
572 {
573 	return (sf1);
574 }
575