1/*
2 * Copyright (c) 2000-2004 Apple Computer, 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#include <mach_load.h>
71
72/*
73 * Memory special file
74 */
75
76#include <sys/param.h>
77#include <sys/dir.h>
78#include <sys/proc.h>
79#include <sys/systm.h>
80#include <sys/conf.h>
81#include <sys/vm.h>
82#include <sys/uio_internal.h>
83#include <sys/malloc.h>
84
85#include <mach/vm_types.h>
86#include <mach/vm_param.h>
87#include <vm/vm_kern.h>         /* for kernel_map */
88
89extern addr64_t kvtophys(vm_offset_t va);
90extern boolean_t kernacc(off_t, size_t);
91#if !defined(SECURE_KERNEL)
92extern int setup_kmem;
93#endif
94
95static caddr_t devzerobuf;
96
97int mmread(dev_t dev, struct uio *uio);
98int mmwrite(dev_t dev, struct uio *uio);
99int mmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p);
100int mmrw(dev_t dev, struct uio *uio, enum uio_rw rw);
101
102int mmread(dev_t dev, struct uio *uio)
103{
104
105    return (mmrw(dev, uio, UIO_READ));
106}
107
108int mmwrite(dev_t dev, struct uio *uio)
109{
110
111    return (mmrw(dev, uio, UIO_WRITE));
112}
113
114int mmioctl(dev_t dev, u_long cmd, __unused caddr_t data, __unused int flag, __unused struct proc *p)
115{
116    int minnum = minor(dev);
117
118    if (0 == minnum || 1 == minnum) {
119        /*
120         * /dev/mem and /dev/kmem
121         */
122#if defined(SECURE_KERNEL)
123        return (ENODEV);
124#else
125        if (0 == setup_kmem)
126            return (EINVAL);
127#endif
128    }
129
130    switch (cmd) {
131    case FIONBIO:
132    case FIOASYNC:
133        /*
134         * OK to do nothing: we always return immediately
135         */
136        break;
137    default:
138        return ENODEV;
139    }
140
141    return (0);
142}
143
144int mmrw(dev_t dev, struct uio *uio, enum uio_rw rw)
145{
146    register int o;
147    register u_int c, v;
148    int error = 0;
149    vm_offset_t where;
150    vm_size_t size;
151
152    while (uio_resid(uio) > 0 && error == 0) {
153        uio_update(uio, 0);
154
155        switch (minor(dev)) {
156
157            /*
158             * minor device 0 is physical memory
159             */
160        case 0:
161#if defined(SECURE_KERNEL)
162            return (ENODEV);
163#else
164            if (setup_kmem == 0)
165                return (ENODEV);
166#endif
167
168            v = trunc_page(uio->uio_offset);
169            if (uio->uio_offset >= (off_t) mem_size)
170                goto fault;
171
172            size = PAGE_SIZE;
173            if (kmem_alloc(kernel_map, &where, size)
174                != KERN_SUCCESS) {
175                goto fault;
176            }
177            o = uio->uio_offset - v;
178            c = min(PAGE_SIZE - o, uio_curriovlen(uio));
179            error = uiomove((caddr_t) (where + o), c, uio);
180            kmem_free(kernel_map, where, PAGE_SIZE);
181            continue;
182
183            /*
184             * minor device 1 is kernel memory
185             */
186        case 1:
187#if defined(SECURE_KERNEL)
188            return (ENODEV);
189#else
190            if (setup_kmem == 0)
191                return (ENODEV);
192#endif
193            /*
194             * Do some sanity checking
195             */
196            if (((vm_address_t) uio->uio_offset >= VM_MAX_KERNEL_ADDRESS) || ((vm_address_t) uio->uio_offset <= VM_MIN_KERNEL_AND_KEXT_ADDRESS))
197                goto fault;
198            c = uio_curriovlen(uio);
199            if (!kernacc(uio->uio_offset, c))
200                goto fault;
201            error = uiomove((caddr_t) (uintptr_t) uio->uio_offset, (int) c, uio);
202            continue;
203
204            /*
205             * minor device 2 is EOF/RATHOLE
206             */
207        case 2:
208            if (rw == UIO_READ)
209                return (0);
210            c = uio_curriovlen(uio);
211            break;
212        case 3:
213            if (devzerobuf == NULL) {
214                MALLOC(devzerobuf, caddr_t, PAGE_SIZE, M_TEMP, M_WAITOK);
215                bzero(devzerobuf, PAGE_SIZE);
216            }
217            if (uio->uio_rw == UIO_WRITE) {
218                c = uio_curriovlen(uio);
219                break;
220            }
221            c = min(uio_curriovlen(uio), PAGE_SIZE);
222            error = uiomove(devzerobuf, (int) c, uio);
223            continue;
224        default:
225            goto fault;
226            break;
227        }
228
229        if (error)
230            break;
231        uio_update(uio, c);
232    }
233    return (error);
234 fault:
235    return (EFAULT);
236}
237
238boolean_t kernacc(off_t start, size_t len)
239{
240    off_t base;
241    off_t end;
242
243    base = trunc_page(start);
244    end = start + len;
245
246    while (base < end) {
247        if (kvtophys((vm_offset_t) base) == 0ULL)
248            return (FALSE);
249        base += page_size;
250    }
251
252    return (TRUE);
253}
254