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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24/*
25 * Copyright 2019 Joyent, Inc.
26 */
27
28
29#include <sys/types.h>
30#include <sys/file.h>
31#include <sys/errno.h>
32#include <sys/open.h>
33#include <sys/cred.h>
34#include <sys/conf.h>
35#include <sys/stat.h>
36#include <sys/processor.h>
37#include <sys/cpuvar.h>
38#include <sys/kmem.h>
39#include <sys/modctl.h>
40#include <sys/ddi.h>
41#include <sys/sunddi.h>
42#include <sys/policy.h>
43
44#include <sys/auxv.h>
45#include <sys/cpuid_drv.h>
46#include <sys/systeminfo.h>
47
48#if defined(__x86)
49#include <sys/x86_archext.h>
50#endif
51
52static dev_info_t *cpuid_devi;
53
54/*ARGSUSED*/
55static int
56cpuid_getinfo(dev_info_t *devi, ddi_info_cmd_t cmd, void *arg, void **result)
57{
58	switch (cmd) {
59	case DDI_INFO_DEVT2DEVINFO:
60	case DDI_INFO_DEVT2INSTANCE:
61		break;
62	default:
63		return (DDI_FAILURE);
64	}
65
66	switch (getminor((dev_t)arg)) {
67	case CPUID_SELF_CPUID_MINOR:
68		break;
69	default:
70		return (DDI_FAILURE);
71	}
72
73	if (cmd == DDI_INFO_DEVT2INSTANCE)
74		*result = 0;
75	else
76		*result = cpuid_devi;
77	return (DDI_SUCCESS);
78}
79
80static int
81cpuid_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
82{
83	if (cmd != DDI_ATTACH)
84		return (DDI_FAILURE);
85	cpuid_devi = devi;
86
87	return (ddi_create_minor_node(devi, CPUID_DRIVER_SELF_NODE, S_IFCHR,
88	    CPUID_SELF_CPUID_MINOR, DDI_PSEUDO, 0));
89}
90
91static int
92cpuid_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
93{
94	if (cmd != DDI_DETACH)
95		return (DDI_FAILURE);
96	ddi_remove_minor_node(devi, NULL);
97	cpuid_devi = NULL;
98	return (DDI_SUCCESS);
99}
100
101/*ARGSUSED1*/
102static int
103cpuid_open(dev_t *dev, int flag, int otyp, cred_t *cr)
104{
105	return (getminor(*dev) == CPUID_SELF_CPUID_MINOR ? 0 : ENXIO);
106}
107
108#if defined(_HAVE_CPUID_INSN)
109
110/*ARGSUSED*/
111static int
112cpuid_read(dev_t dev, uio_t *uio, cred_t *cr)
113{
114	struct cpuid_regs crs;
115	int error = 0;
116
117	if (!is_x86_feature(x86_featureset, X86FSET_CPUID))
118		return (ENXIO);
119
120	if (uio->uio_resid & (sizeof (crs) - 1))
121		return (EINVAL);
122
123	while (uio->uio_resid > 0) {
124		u_offset_t uoff;
125
126		if ((uoff = (u_offset_t)uio->uio_loffset) > UINT_MAX) {
127			error = EINVAL;
128			break;
129		}
130
131		crs.cp_eax = (uint32_t)uoff;
132		crs.cp_ebx = crs.cp_ecx = crs.cp_edx = 0;
133		(void) cpuid_insn(NULL, &crs);
134
135		if ((error = uiomove(&crs, sizeof (crs), UIO_READ, uio)) != 0)
136			break;
137		uio->uio_loffset = uoff + 1;
138	}
139
140	return (error);
141}
142
143#else
144
145#define	cpuid_read	nodev
146
147#endif	/* _HAVE_CPUID_INSN */
148
149/*ARGSUSED*/
150static int
151cpuid_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval)
152{
153	char areq[16];
154	void *ustr;
155
156	switch (cmd) {
157	case CPUID_GET_HWCAP: {
158		STRUCT_DECL(cpuid_get_hwcap, h);
159
160		STRUCT_INIT(h, mode);
161		if (ddi_copyin((void *)arg,
162		    STRUCT_BUF(h), STRUCT_SIZE(h), mode))
163			return (EFAULT);
164		if ((ustr = STRUCT_FGETP(h, cgh_archname)) != NULL &&
165		    copyinstr(ustr, areq, sizeof (areq), NULL) != 0)
166			return (EFAULT);
167		areq[sizeof (areq) - 1] = '\0';
168
169		if (strcmp(areq, architecture) == 0) {
170			STRUCT_FSET(h, cgh_hwcap[0], auxv_hwcap);
171			STRUCT_FSET(h, cgh_hwcap[1], auxv_hwcap_2);
172#if defined(_SYSCALL32_IMPL)
173		} else if (strcmp(areq, architecture_32) == 0) {
174			STRUCT_FSET(h, cgh_hwcap[0], auxv_hwcap32);
175			STRUCT_FSET(h, cgh_hwcap[1], auxv_hwcap32_2);
176#endif
177		} else {
178			STRUCT_FSET(h, cgh_hwcap[0], 0);
179			STRUCT_FSET(h, cgh_hwcap[1], 0);
180		}
181		if (ddi_copyout(STRUCT_BUF(h),
182		    (void *)arg, STRUCT_SIZE(h), mode))
183			return (EFAULT);
184		return (0);
185	}
186
187#ifdef __x86
188	case CPUID_RDMSR: {
189		struct cpuid_rdmsr crm = { 0, };
190		label_t label;
191
192		if (secpolicy_sys_config(cr, B_FALSE) != 0)
193			return (EPERM);
194
195		if (ddi_copyin((void *)arg, &crm, sizeof (crm), mode))
196			return (EFAULT);
197
198		kpreempt_disable();
199
200		if (on_fault(&label)) {
201			kpreempt_enable();
202			return (ENOENT);
203		}
204
205		crm.cr_msr_val = rdmsr(crm.cr_msr_nr);
206
207		no_fault();
208		kpreempt_enable();
209
210		if (ddi_copyout(&crm, (void *)arg, sizeof (crm), mode))
211			return (EFAULT);
212		return (0);
213	}
214#endif
215
216	default:
217		return (ENOTTY);
218	}
219}
220
221static struct cb_ops cpuid_cb_ops = {
222	cpuid_open,
223	nulldev,	/* close */
224	nodev,		/* strategy */
225	nodev,		/* print */
226	nodev,		/* dump */
227	cpuid_read,
228	nodev,		/* write */
229	cpuid_ioctl,
230	nodev,		/* devmap */
231	nodev,		/* mmap */
232	nodev,		/* segmap */
233	nochpoll,	/* poll */
234	ddi_prop_op,
235	NULL,
236	D_64BIT | D_NEW | D_MP
237};
238
239static struct dev_ops cpuid_dv_ops = {
240	DEVO_REV,
241	0,
242	cpuid_getinfo,
243	nulldev,	/* identify */
244	nulldev,	/* probe */
245	cpuid_attach,
246	cpuid_detach,
247	nodev,		/* reset */
248	&cpuid_cb_ops,
249	(struct bus_ops *)0,
250	NULL,
251	ddi_quiesce_not_needed,		/* quiesce */
252};
253
254static struct modldrv modldrv = {
255	&mod_driverops,
256	"cpuid driver",
257	&cpuid_dv_ops
258};
259
260static struct modlinkage modl = {
261	MODREV_1,
262	&modldrv
263};
264
265int
266_init(void)
267{
268	return (mod_install(&modl));
269}
270
271int
272_fini(void)
273{
274	return (mod_remove(&modl));
275}
276
277int
278_info(struct modinfo *modinfo)
279{
280	return (mod_info(&modl, modinfo));
281}
282