1 /*
2 * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*-
29 * Copyright (c) 1988 University of Utah.
30 * Copyright (c) 1982, 1986, 1990, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed to Berkeley by
34 * the Systems Programming Group of the University of Utah Computer
35 * Science Department, and code derived from software contributed to
36 * Berkeley by William Jolitz.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * from: Utah $Hdr: mem.c 1.13 89/10/08$
67 * @(#)mem.c 8.1 (Berkeley) 6/11/93
68 */
69
70 /*
71 * Memory special file
72 */
73
74 #include <sys/param.h>
75 #include <sys/dir.h>
76 #include <sys/proc.h>
77 #include <sys/systm.h>
78 #include <sys/conf.h>
79 #include <sys/vm.h>
80 #include <sys/uio_internal.h>
81
82 #include <kern/zalloc.h>
83
84 #include <mach/vm_types.h>
85 #include <mach/vm_param.h>
86 #include <vm/vm_kern.h> /* for kernel_map */
87 #include <libkern/section_keywords.h>
88
89 #include <pexpert/pexpert.h> /* for PE_parse_boot_argn */
90
91 boolean_t iskmemdev(dev_t dev);
92
93 #if CONFIG_DEV_KMEM
94 boolean_t dev_kmem_enabled;
95 boolean_t dev_kmem_mask_top_bit;
96
97 void dev_kmem_init(void);
98
99 #if defined(__x86_64__)
100 extern addr64_t kvtophys(vm_offset_t va);
101 #else
102 #error need kvtophys prototype
103 #endif
104 extern boolean_t kernacc(off_t, size_t );
105
106 #endif
107
108 static SECURITY_READ_ONLY_LATE(caddr_t) devzerobuf;
109
110 int mmread(dev_t dev, struct uio *uio);
111 int mmwrite(dev_t dev, struct uio *uio);
112 int mmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p);
113 int mmrw(dev_t dev, struct uio *uio, enum uio_rw rw);
114
115 int
mmread(dev_t dev,struct uio * uio)116 mmread(dev_t dev, struct uio *uio)
117 {
118 return mmrw(dev, uio, UIO_READ);
119 }
120
121 int
mmwrite(dev_t dev,struct uio * uio)122 mmwrite(dev_t dev, struct uio *uio)
123 {
124 return mmrw(dev, uio, UIO_WRITE);
125 }
126
127 int
mmioctl(dev_t dev,u_long cmd,__unused caddr_t data,__unused int flag,__unused struct proc * p)128 mmioctl(dev_t dev, u_long cmd, __unused caddr_t data,
129 __unused int flag, __unused struct proc *p)
130 {
131 int minnum = minor(dev);
132
133 if (0 == minnum || 1 == minnum) {
134 /* /dev/mem and /dev/kmem */
135 #if CONFIG_DEV_KMEM
136 if (!dev_kmem_enabled) {
137 return ENODEV;
138 }
139 #else
140 return ENODEV;
141 #endif
142 }
143
144 switch (cmd) {
145 case FIONBIO:
146 case FIOASYNC:
147 /* OK to do nothing: we always return immediately */
148 break;
149 default:
150 return ENODEV;
151 }
152
153 return 0;
154 }
155
156 int
mmrw(dev_t dev,struct uio * uio,enum uio_rw rw)157 mmrw(dev_t dev, struct uio *uio, enum uio_rw rw)
158 {
159 user_size_t c;
160 int error = 0;
161
162 while (uio_resid(uio) > 0) {
163 uio_update(uio, 0);
164
165 switch (minor(dev)) {
166 /* minor device 0 is physical memory */
167 case 0:
168 return ENODEV;
169
170 /* minor device 1 is kernel memory */
171 case 1:
172 #if !CONFIG_DEV_KMEM
173 return ENODEV;
174 #else /* CONFIG_DEV_KMEM */
175 if (!dev_kmem_enabled) {
176 return ENODEV;
177 }
178
179 vm_address_t kaddr = (vm_address_t)uio->uio_offset;
180 if (dev_kmem_mask_top_bit) {
181 /*
182 * KVA addresses of the form 0xFFFFFF80AABBCCDD can't be
183 * represented as a signed off_t correctly. In these cases,
184 * 0x7FFFFF80AABBCCDD is passed in, and the top bit OR-ed
185 * on.
186 */
187 const vm_address_t top_bit = (~((vm_address_t)0)) ^ (~((vm_address_t)0) >> 1UL);
188 if (kaddr & top_bit) {
189 /* top bit should not be set already */
190 return EFAULT;
191 }
192 kaddr |= top_bit;
193 }
194
195 c = uio_curriovlen(uio);
196
197 /* Do some sanity checking */
198 if ((kaddr > (VM_MAX_KERNEL_ADDRESS - c)) ||
199 (kaddr <= VM_MIN_KERNEL_AND_KEXT_ADDRESS)) {
200 goto fault;
201 }
202 if (!kernacc(kaddr, c)) {
203 goto fault;
204 }
205 error = uiomove((const char *)(uintptr_t)kaddr,
206 (int)c, uio);
207 if (error) {
208 break;
209 }
210
211 continue; /* Keep going until UIO is done */
212 #endif /* CONFIG_DEV_KMEM */
213
214 /* minor device 2 is EOF/RATHOLE */
215 case 2:
216 if (rw == UIO_READ) {
217 return 0;
218 }
219 c = uio_curriovlen(uio);
220
221 error = 0; /* Always succeeds, always consumes all input */
222 break;
223 case 3:
224 assert(devzerobuf != NULL);
225
226 if (uio->uio_rw == UIO_WRITE) {
227 c = uio_curriovlen(uio);
228
229 error = 0; /* Always succeeds, always consumes all input */
230 break;
231 }
232
233 c = MIN(uio_curriovlen(uio), PAGE_SIZE);
234 error = uiomove(devzerobuf, (int)c, uio);
235 if (error) {
236 break;
237 }
238
239 continue; /* Keep going until UIO is done */
240 default:
241 return ENODEV;
242 }
243
244 if (error) {
245 break;
246 }
247
248 uio_update(uio, c);
249 }
250 return error;
251 #if CONFIG_DEV_KMEM
252 fault:
253 return EFAULT;
254 #endif
255 }
256
257 __startup_func
258 static void
devzerobuf_init(void)259 devzerobuf_init(void)
260 {
261 devzerobuf = zalloc_permanent(PAGE_SIZE, ZALIGN_NONE); /* zeroed */
262 }
263 STARTUP(ZALLOC, STARTUP_RANK_LAST, devzerobuf_init);
264
265 #if CONFIG_DEV_KMEM
266 void
dev_kmem_init(void)267 dev_kmem_init(void)
268 {
269 uint32_t kmem;
270
271 if (PE_i_can_has_debugger(NULL) &&
272 PE_parse_boot_argn("kmem", &kmem, sizeof(kmem))) {
273 if (kmem & 0x1) {
274 dev_kmem_enabled = TRUE;
275 }
276 if (kmem & 0x2) {
277 dev_kmem_mask_top_bit = TRUE;
278 }
279 }
280 }
281
282 boolean_t
kernacc(off_t start,size_t len)283 kernacc(
284 off_t start,
285 size_t len
286 )
287 {
288 off_t base;
289 off_t end;
290
291 base = trunc_page(start);
292 end = start + len;
293
294 while (base < end) {
295 if (kvtophys((vm_offset_t)base) == 0ULL) {
296 return FALSE;
297 }
298 base += page_size;
299 }
300
301 return TRUE;
302 }
303
304 #endif /* CONFIG_DEV_KMEM */
305
306 /*
307 * Returns true if dev is /dev/mem or /dev/kmem.
308 */
309 boolean_t
iskmemdev(dev_t dev)310 iskmemdev(dev_t dev)
311 {
312 return major(dev) == 3 && minor(dev) < 2;
313 }
314