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 #else
 137                 return (ENODEV);
 138 #endif
 139         }
 140
 141         switch (cmd) {
 142         case FIONBIO:
 143         case FIOASYNC:
 144                 /* OK to do nothing: we always return immediately */
 145                 break;
 146         default:
 147                 return ENODEV;
 148         }
 149
 150         return (0);
 151 }
 152
 153 int
 154 mmrw(dev_t dev, struct uio *uio, enum uio_rw rw)
 155 {
 156         unsigned int c;
 157         int error = 0;
 158
 159         while (uio_resid(uio) > 0) {
 160                 uio_update(uio, 0);
 161
 162                 switch (minor(dev)) {
 163
 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                         vm_address_t kaddr = (vm_address_t)uio->uio_offset;
 177                         if (dev_kmem_mask_top_bit) {
 178                                 /*
 179                                  * KVA addresses of the form 0xFFFFFF80AABBCCDD can't be
 180                                  * represented as a signed off_t correctly. In these cases,
 181                                  * 0x7FFFFF80AABBCCDD is passed in, and the top bit OR-ed
 182                                  * on.
 183                                  */
 184                                 const vm_address_t top_bit = (~((vm_address_t)0)) ^ (~((vm_address_t)0) >> 1UL);
 185                                 if (kaddr & top_bit) {
 186                                         /* top bit should not be set already */
 187                                         return (EFAULT);
 188                                 }
 189                                 kaddr |= top_bit;
 190                         }
 191
 192                         c = uio_curriovlen(uio);
 193
 194                         /* Do some sanity checking */
 195                         if ((kaddr > (VM_MAX_KERNEL_ADDRESS - c)) ||
 196                                 (kaddr <= VM_MIN_KERNEL_AND_KEXT_ADDRESS))
 197                                 goto fault;
 198                         if (!kernacc(kaddr, c))
 199                                 goto fault;
 200                         error = uiomove((const char *)(uintptr_t)kaddr,
 201                                         (int)c, uio);
 202                         if (error)
 203                                 break;
 204
 205                         continue; /* Keep going until UIO is done */
 206 #endif /* CONFIG_DEV_KMEM */
 207
 208                 /* minor device 2 is EOF/RATHOLE */
 209                 case 2:
 210                         if (rw == UIO_READ)
 211                                 return (0);
 212                         c = uio_curriovlen(uio);
 213
 214                         error = 0; /* Always succeeds, always consumes all input */
 215                         break;
 216                 case 3:
 217                         if(devzerobuf == NULL) {
 218                                 MALLOC(devzerobuf, caddr_t,PAGE_SIZE, M_TEMP, M_WAITOK);
 219                                 bzero(devzerobuf, PAGE_SIZE);
 220                         }
 221                         if(uio->uio_rw == UIO_WRITE) {
 222                                 c = uio_curriovlen(uio);
 223
 224                                 error = 0; /* Always succeeds, always consumes all input */
 225                                 break;
 226                         }
 227
 228                         c = min(uio_curriovlen(uio), PAGE_SIZE);
 229                         error = uiomove(devzerobuf, (int)c, uio);
 230                         if (error)
 231                                 break;
 232
 233                         continue; /* Keep going until UIO is done */
 234                 default:
 235                         return (ENODEV);
 236                 }
 237
 238                 if (error)
 239                         break;
 240
 241                 uio_update(uio, c);
 242         }
 243         return (error);
 244 #if CONFIG_DEV_KMEM
 245 fault:
 246         return (EFAULT);
 247 #endif
 248 }
 249
 250 #if CONFIG_DEV_KMEM
 251 void dev_kmem_init(void)
 252 {
 253         uint32_t kmem;
 254
 255         if (PE_i_can_has_debugger(NULL) &&
 256             PE_parse_boot_argn("kmem", &kmem, sizeof (kmem))) {
 257                 if (kmem & 0x1) {
 258                         dev_kmem_enabled = TRUE;
 259                 }
 260                 if (kmem & 0x2) {
 261                         dev_kmem_mask_top_bit = TRUE;
 262                 }
 263         }
 264 }
 265
 266 boolean_t
 267 kernacc(
 268     off_t       start,
 269     size_t      len
 270 )
 271 {
 272         off_t base;
 273         off_t end;
 274
 275         base = trunc_page(start);
 276         end = start + len;
 277
 278         while (base < end) {
 279           if(kvtophys((vm_offset_t)base) == 0ULL)
 280                         return(FALSE);
 281                 base += page_size;
 282         }
 283
 284         return (TRUE);
 285 }
 286
 287 #endif /* CONFIG_DEV_KMEM */
 288
 289 /*
 290  * Returns true if dev is /dev/mem or /dev/kmem.
 291  */
 292 boolean_t iskmemdev(dev_t dev)
 293 {
 294         return (major(dev) == 3 && minor(dev) < 2);
 295 }