bsd/dev/mem.c

   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 #include <sys/malloc.h>
  82
  83 #include <mach/vm_types.h>
  84 #include <mach/vm_param.h>
  85 #include <vm/vm_kern.h>         /* for kernel_map */
  86
  87 #include <pexpert/pexpert.h>    /* for PE_parse_boot_argn */
  88
  89 boolean_t iskmemdev(dev_t dev);
  90
  91 #if CONFIG_DEV_KMEM
  92 boolean_t dev_kmem_enabled;
  93 boolean_t dev_kmem_mask_top_bit;
  94
  95 void dev_kmem_init(void);
  96
  97 #if defined(__x86_64__)
  98 extern addr64_t  kvtophys(vm_offset_t va);
  99 #else
 100 #error need kvtophys prototype
 101 #endif
 102 extern boolean_t kernacc(off_t, size_t );
 103
 104 #endif
 105
 106 static caddr_t devzerobuf;
 107
 108 int mmread(dev_t dev, struct uio *uio);
 109 int mmwrite(dev_t dev, struct uio *uio);
 110 int mmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p);
 111 int mmrw(dev_t dev, struct uio *uio, enum uio_rw rw);
 112
 113 int
 114 mmread(dev_t dev, struct uio *uio)
 115 {
 116         return mmrw(dev, uio, UIO_READ);
 117 }
 118
 119 int
 120 mmwrite(dev_t dev, struct uio *uio)
 121 {
 122         return mmrw(dev, uio, UIO_WRITE);
 123 }
 124
 125 int
 126 mmioctl(dev_t dev, u_long cmd, __unused caddr_t data,
 127     __unused int flag, __unused struct proc *p)
 128 {
 129         int minnum = minor(dev);
 130
 131         if (0 == minnum || 1 == minnum) {
 132                 /* /dev/mem and /dev/kmem */
 133 #if CONFIG_DEV_KMEM
 134                 if (!dev_kmem_enabled) {
 135                         return ENODEV;
 136                 }
 137 #else
 138                 return ENODEV;
 139 #endif
 140         }
 141
 142         switch (cmd) {
 143         case FIONBIO:
 144         case FIOASYNC:
 145                 /* OK to do nothing: we always return immediately */
 146                 break;
 147         default:
 148                 return ENODEV;
 149         }
 150
 151         return 0;
 152 }
 153
 154 int
 155 mmrw(dev_t dev, struct uio *uio, enum uio_rw rw)
 156 {
 157         unsigned int c;
 158         int error = 0;
 159
 160         while (uio_resid(uio) > 0) {
 161                 uio_update(uio, 0);
 162
 163                 switch (minor(dev)) {
 164                 /* minor device 0 is physical memory */
 165                 case 0:
 166                         return ENODEV;
 167
 168                 /* minor device 1 is kernel memory */
 169                 case 1:
 170 #if !CONFIG_DEV_KMEM
 171                         return ENODEV;
 172 #else /* CONFIG_DEV_KMEM */
 173                         if (!dev_kmem_enabled) {
 174                                 return ENODEV;
 175                         }
 176
 177                         vm_address_t kaddr = (vm_address_t)uio->uio_offset;
 178                         if (dev_kmem_mask_top_bit) {
 179                                 /*
 180                                  * KVA addresses of the form 0xFFFFFF80AABBCCDD can't be
 181                                  * represented as a signed off_t correctly. In these cases,
 182                                  * 0x7FFFFF80AABBCCDD is passed in, and the top bit OR-ed
 183                                  * on.
 184                                  */
 185                                 const vm_address_t top_bit = (~((vm_address_t)0)) ^ (~((vm_address_t)0) >> 1UL);
 186                                 if (kaddr & top_bit) {
 187                                         /* top bit should not be set already */
 188                                         return EFAULT;
 189                                 }
 190                                 kaddr |= top_bit;
 191                         }
 192
 193                         c = uio_curriovlen(uio);
 194
 195                         /* Do some sanity checking */
 196                         if ((kaddr > (VM_MAX_KERNEL_ADDRESS - c)) ||
 197                             (kaddr <= VM_MIN_KERNEL_AND_KEXT_ADDRESS)) {
 198                                 goto fault;
 199                         }
 200                         if (!kernacc(kaddr, c)) {
 201                                 goto fault;
 202                         }
 203                         error = uiomove((const char *)(uintptr_t)kaddr,
 204                             (int)c, uio);
 205                         if (error) {
 206                                 break;
 207                         }
 208
 209                         continue; /* Keep going until UIO is done */
 210 #endif /* CONFIG_DEV_KMEM */
 211
 212                 /* minor device 2 is EOF/RATHOLE */
 213                 case 2:
 214                         if (rw == UIO_READ) {
 215                                 return 0;
 216                         }
 217                         c = uio_curriovlen(uio);
 218
 219                         error = 0; /* Always succeeds, always consumes all input */
 220                         break;
 221                 case 3:
 222                         if (devzerobuf == NULL) {
 223                                 MALLOC(devzerobuf, caddr_t, PAGE_SIZE, M_TEMP, M_WAITOK);
 224                                 bzero(devzerobuf, PAGE_SIZE);
 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 #if CONFIG_DEV_KMEM
 258 void
 259 dev_kmem_init(void)
 260 {
 261         uint32_t kmem;
 262
 263         if (PE_i_can_has_debugger(NULL) &&
 264             PE_parse_boot_argn("kmem", &kmem, sizeof(kmem))) {
 265                 if (kmem & 0x1) {
 266                         dev_kmem_enabled = TRUE;
 267                 }
 268                 if (kmem & 0x2) {
 269                         dev_kmem_mask_top_bit = TRUE;
 270                 }
 271         }
 272 }
 273
 274 boolean_t
 275 kernacc(
 276         off_t       start,
 277         size_t      len
 278         )
 279 {
 280         off_t base;
 281         off_t end;
 282
 283         base = trunc_page(start);
 284         end = start + len;
 285
 286         while (base < end) {
 287                 if (kvtophys((vm_offset_t)base) == 0ULL) {
 288                         return FALSE;
 289                 }
 290                 base += page_size;
 291         }
 292
 293         return TRUE;
 294 }
 295
 296 #endif /* CONFIG_DEV_KMEM */
 297
 298 /*
 299  * Returns true if dev is /dev/mem or /dev/kmem.
 300  */
 301 boolean_t
 302 iskmemdev(dev_t dev)
 303 {
 304         return major(dev) == 3 && minor(dev) < 2;
 305 }