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
52 static dev_info_t *cpuid_devi;
53
54 /*ARGSUSED*/
55 static int
56 cpuid_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
80 static int
81 cpuid_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
91 static int
92 cpuid_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*/
102 static int
103 cpuid_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*/
111 static int
112 cpuid_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*/
150 static int
151 cpuid_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
221 static 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
239 static 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
254 static struct modldrv modldrv = {
255 &mod_driverops,
256 "cpuid driver",
257 &cpuid_dv_ops
258 };
259
260 static struct modlinkage modl = {
261 MODREV_1,
262 &modldrv
263 };
264
265 int
266 _init(void)
267 {
268 return (mod_install(&modl));
269 }
270
271 int
272 _fini(void)
273 {
274 return (mod_remove(&modl));
275 }
276
277 int
278 _info(struct modinfo *modinfo)
279 {
280 return (mod_info(&modl, modinfo));
281 }