Print this page
7127 remove -Wno-missing-braces from Makefile.uts
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/cpuid_drv.c
+++ new/usr/src/uts/common/io/cpuid_drv.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 */
24 24 /*
25 25 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
26 26 */
27 27
28 28
29 29 #include <sys/types.h>
30 30 #include <sys/file.h>
31 31 #include <sys/errno.h>
32 32 #include <sys/open.h>
33 33 #include <sys/cred.h>
34 34 #include <sys/conf.h>
35 35 #include <sys/stat.h>
36 36 #include <sys/processor.h>
37 37 #include <sys/cpuvar.h>
38 38 #include <sys/kmem.h>
39 39 #include <sys/modctl.h>
40 40 #include <sys/ddi.h>
41 41 #include <sys/sunddi.h>
42 42
43 43 #include <sys/auxv.h>
44 44 #include <sys/cpuid_drv.h>
45 45 #include <sys/systeminfo.h>
46 46
47 47 #if defined(__x86)
48 48 #include <sys/x86_archext.h>
49 49 #endif
50 50
51 51 static dev_info_t *cpuid_devi;
52 52
53 53 /*ARGSUSED*/
54 54 static int
55 55 cpuid_getinfo(dev_info_t *devi, ddi_info_cmd_t cmd, void *arg, void **result)
56 56 {
57 57 switch (cmd) {
58 58 case DDI_INFO_DEVT2DEVINFO:
59 59 case DDI_INFO_DEVT2INSTANCE:
60 60 break;
61 61 default:
62 62 return (DDI_FAILURE);
63 63 }
64 64
65 65 switch (getminor((dev_t)arg)) {
66 66 case CPUID_SELF_CPUID_MINOR:
67 67 break;
68 68 default:
69 69 return (DDI_FAILURE);
70 70 }
71 71
72 72 if (cmd == DDI_INFO_DEVT2INSTANCE)
73 73 *result = 0;
74 74 else
75 75 *result = cpuid_devi;
76 76 return (DDI_SUCCESS);
77 77 }
78 78
79 79 static int
80 80 cpuid_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
81 81 {
82 82 if (cmd != DDI_ATTACH)
83 83 return (DDI_FAILURE);
84 84 cpuid_devi = devi;
85 85
86 86 return (ddi_create_minor_node(devi, CPUID_DRIVER_SELF_NODE, S_IFCHR,
87 87 CPUID_SELF_CPUID_MINOR, DDI_PSEUDO, 0));
88 88 }
89 89
90 90 static int
91 91 cpuid_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
92 92 {
93 93 if (cmd != DDI_DETACH)
94 94 return (DDI_FAILURE);
95 95 ddi_remove_minor_node(devi, NULL);
96 96 cpuid_devi = NULL;
97 97 return (DDI_SUCCESS);
98 98 }
99 99
100 100 /*ARGSUSED1*/
101 101 static int
102 102 cpuid_open(dev_t *dev, int flag, int otyp, cred_t *cr)
103 103 {
104 104 return (getminor(*dev) == CPUID_SELF_CPUID_MINOR ? 0 : ENXIO);
105 105 }
106 106
107 107 #if defined(_HAVE_CPUID_INSN)
108 108
109 109 /*ARGSUSED*/
110 110 static int
111 111 cpuid_read(dev_t dev, uio_t *uio, cred_t *cr)
112 112 {
113 113 struct cpuid_regs crs;
114 114 int error = 0;
115 115
116 116 if (!is_x86_feature(x86_featureset, X86FSET_CPUID))
117 117 return (ENXIO);
118 118
119 119 if (uio->uio_resid & (sizeof (crs) - 1))
120 120 return (EINVAL);
121 121
122 122 while (uio->uio_resid > 0) {
123 123 u_offset_t uoff;
124 124
125 125 if ((uoff = (u_offset_t)uio->uio_loffset) > UINT_MAX) {
126 126 error = EINVAL;
127 127 break;
128 128 }
129 129
130 130 crs.cp_eax = (uint32_t)uoff;
131 131 crs.cp_ebx = crs.cp_ecx = crs.cp_edx = 0;
132 132 (void) cpuid_insn(NULL, &crs);
133 133
134 134 if ((error = uiomove(&crs, sizeof (crs), UIO_READ, uio)) != 0)
135 135 break;
136 136 uio->uio_loffset = uoff + 1;
137 137 }
138 138
139 139 return (error);
140 140 }
141 141
142 142 #else
143 143
144 144 #define cpuid_read nodev
145 145
146 146 #endif /* _HAVE_CPUID_INSN */
147 147
148 148 /*ARGSUSED*/
149 149 static int
150 150 cpuid_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval)
151 151 {
152 152 char areq[16];
153 153 void *ustr;
154 154
155 155 switch (cmd) {
156 156 case CPUID_GET_HWCAP: {
157 157 STRUCT_DECL(cpuid_get_hwcap, h);
158 158
159 159 STRUCT_INIT(h, mode);
160 160 if (ddi_copyin((void *)arg,
161 161 STRUCT_BUF(h), STRUCT_SIZE(h), mode))
162 162 return (EFAULT);
163 163 if ((ustr = STRUCT_FGETP(h, cgh_archname)) != NULL &&
164 164 copyinstr(ustr, areq, sizeof (areq), NULL) != 0)
165 165 return (EFAULT);
166 166 areq[sizeof (areq) - 1] = '\0';
167 167
168 168 if (strcmp(areq, architecture) == 0) {
169 169 STRUCT_FSET(h, cgh_hwcap[0], auxv_hwcap);
170 170 STRUCT_FSET(h, cgh_hwcap[1], auxv_hwcap_2);
171 171 #if defined(_SYSCALL32_IMPL)
172 172 } else if (strcmp(areq, architecture_32) == 0) {
173 173 STRUCT_FSET(h, cgh_hwcap[0], auxv_hwcap32);
174 174 STRUCT_FSET(h, cgh_hwcap[1], auxv_hwcap32_2);
175 175 #endif
176 176 } else {
177 177 STRUCT_FSET(h, cgh_hwcap[0], 0);
178 178 STRUCT_FSET(h, cgh_hwcap[1], 0);
179 179 }
180 180 if (ddi_copyout(STRUCT_BUF(h),
181 181 (void *)arg, STRUCT_SIZE(h), mode))
182 182 return (EFAULT);
183 183 return (0);
184 184 }
185 185
186 186 default:
187 187 return (ENOTTY);
188 188 }
189 189 }
190 190
191 191 static struct cb_ops cpuid_cb_ops = {
192 192 cpuid_open,
193 193 nulldev, /* close */
194 194 nodev, /* strategy */
195 195 nodev, /* print */
196 196 nodev, /* dump */
197 197 cpuid_read,
198 198 nodev, /* write */
199 199 cpuid_ioctl,
200 200 nodev, /* devmap */
201 201 nodev, /* mmap */
202 202 nodev, /* segmap */
203 203 nochpoll, /* poll */
204 204 ddi_prop_op,
205 205 NULL,
206 206 D_64BIT | D_NEW | D_MP
207 207 };
208 208
209 209 static struct dev_ops cpuid_dv_ops = {
210 210 DEVO_REV,
211 211 0,
212 212 cpuid_getinfo,
213 213 nulldev, /* identify */
214 214 nulldev, /* probe */
215 215 cpuid_attach,
216 216 cpuid_detach,
217 217 nodev, /* reset */
218 218 &cpuid_cb_ops,
219 219 (struct bus_ops *)0,
220 220 NULL,
221 221 ddi_quiesce_not_needed, /* quiesce */
|
↓ open down ↓ |
221 lines elided |
↑ open up ↑ |
222 222 };
223 223
224 224 static struct modldrv modldrv = {
225 225 &mod_driverops,
226 226 "cpuid driver",
227 227 &cpuid_dv_ops
228 228 };
229 229
230 230 static struct modlinkage modl = {
231 231 MODREV_1,
232 - &modldrv
232 + { &modldrv, NULL }
233 233 };
234 234
235 235 int
236 236 _init(void)
237 237 {
238 238 return (mod_install(&modl));
239 239 }
240 240
241 241 int
242 242 _fini(void)
243 243 {
244 244 return (mod_remove(&modl));
245 245 }
246 246
247 247 int
248 248 _info(struct modinfo *modinfo)
249 249 {
250 250 return (mod_info(&modl, modinfo));
251 251 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX