osfmk/kdp/ml/i386/kdp_x86_common.c

   1 /*
   2  * Copyright (c) 2008 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 #include <sys/errno.h>
  30
  31 #include <mach/mach_types.h>
  32 #include <mach/vm_attributes.h>
  33 #include <mach/vm_param.h>
  34 #include <libsa/types.h>
  35
  36 #include <vm/vm_map.h>
  37 #include <i386/pmap.h>
  38 #include <i386/pmap_internal.h> /* pmap_pde */
  39 #include <i386/mp.h>
  40 #include <i386/misc_protos.h>
  41 #include <i386/pio.h>
  42 #include <i386/proc_reg.h>
  43
  44 #include <i386/pmap_internal.h>
  45
  46 #include <kdp/kdp_internal.h>
  47 #include <kdp/kdp_core.h>
  48 #include <kdp/ml/i386/kdp_x86_common.h>
  49 #include <mach/vm_map.h>
  50
  51 #include <vm/vm_protos.h>
  52 #include <vm/vm_kern.h>
  53
  54 #include <machine/pal_routines.h>
  55 #include <libkern/kernel_mach_header.h>
  56
  57 // #define KDP_VM_READ_DEBUG 1
  58 // #define KDP_VM_WRITE_DEBUG 1
  59
  60 /*
  61  * A (potentially valid) physical address is not a kernel address
  62  * i.e. it'a a user address.
  63  */
  64 #define IS_PHYS_ADDR(addr)              IS_USERADDR64_CANONICAL(addr)
  65
  66 boolean_t kdp_read_io;
  67 boolean_t kdp_trans_off;
  68
  69 addr64_t kdp_vtophys(pmap_t pmap, addr64_t va);
  70
  71 pmap_t kdp_pmap = 0;
  72
  73 addr64_t
  74 kdp_vtophys(
  75         pmap_t pmap,
  76         addr64_t va)
  77 {
  78         addr64_t    pa;
  79         ppnum_t pp;
  80
  81         pp = pmap_find_phys(pmap, va);
  82         if(!pp) return 0;
  83
  84         pa = ((addr64_t)pp << PAGE_SHIFT) | (va & PAGE_MASK);
  85
  86         return(pa);
  87 }
  88
  89 mach_vm_size_t
  90 kdp_machine_vm_read( mach_vm_address_t src, caddr_t dst, mach_vm_size_t len)
  91 {
  92         addr64_t cur_virt_src = PAL_KDP_ADDR((addr64_t)src);
  93         addr64_t cur_virt_dst = PAL_KDP_ADDR((addr64_t)(intptr_t)dst);
  94         addr64_t cur_phys_dst, cur_phys_src;
  95         mach_vm_size_t resid = len;
  96         mach_vm_size_t cnt = 0, cnt_src, cnt_dst;
  97         pmap_t src_pmap = kernel_pmap;
  98
  99 #ifdef KDP_VM_READ_DEBUG
 100         printf("kdp_vm_read: src %llx dst %p len %llx\n", src, (void *)dst, len);
 101 #endif
 102
 103         if (kdp_trans_off && IS_PHYS_ADDR(src)) {
 104                 kdp_readphysmem64_req_t rq;
 105                 mach_vm_size_t ret;
 106
 107                 rq.address = src;
 108                 rq.nbytes = (uint32_t)len;
 109                 ret = kdp_machine_phys_read(&rq, dst, KDP_CURRENT_LCPU);
 110                 return ret;
 111         }
 112
 113 /* If a different pmap has been specified with kdp_pmap, use it to translate the
 114  * source (cur_virt_src); otherwise, the source is translated using the
 115  * kernel_pmap.
 116  */
 117         if (kdp_pmap)
 118                 src_pmap = kdp_pmap;
 119
 120         while (resid != 0) {
 121                 if (!(cur_phys_src = kdp_vtophys(src_pmap,
 122                             cur_virt_src)))
 123                         goto exit;
 124
 125 /* Always translate the destination buffer using the kernel_pmap */
 126                 if(!(cur_phys_dst = kdp_vtophys(kernel_pmap, cur_virt_dst)))
 127                         goto exit;
 128
 129                 /* Validate physical page numbers unless kdp_read_io is set */
 130                 if (kdp_read_io == FALSE)
 131                         if (!pmap_valid_page(i386_btop(cur_phys_dst)) || !pmap_valid_page(i386_btop(cur_phys_src)))
 132                                 goto exit;
 133
 134 /* Get length left on page */
 135                 cnt_src = PAGE_SIZE - (cur_phys_src & PAGE_MASK);
 136                 cnt_dst = PAGE_SIZE - (cur_phys_dst & PAGE_MASK);
 137                 if (cnt_src > cnt_dst)
 138                         cnt = cnt_dst;
 139                 else
 140                         cnt = cnt_src;
 141                 if (cnt > resid)
 142                         cnt = resid;
 143
 144 /* Do a physical copy */
 145                 if (EFAULT == ml_copy_phys(cur_phys_src,
 146                                            cur_phys_dst,
 147                                            (vm_size_t)cnt))
 148                         goto exit;
 149                 cur_virt_src += cnt;
 150                 cur_virt_dst += cnt;
 151                 resid -= cnt;
 152         }
 153 exit:
 154         return (len - resid);
 155 }
 156
 157 mach_vm_size_t
 158 kdp_machine_phys_read(kdp_readphysmem64_req_t *rq, caddr_t dst,
 159                       uint16_t lcpu)
 160 {
 161         mach_vm_address_t src = rq->address;
 162         mach_vm_size_t    len = rq->nbytes;
 163
 164         addr64_t cur_virt_dst;
 165         addr64_t cur_phys_dst, cur_phys_src;
 166         mach_vm_size_t resid = len;
 167         mach_vm_size_t cnt = 0, cnt_src, cnt_dst;
 168
 169         if ((lcpu != KDP_CURRENT_LCPU) && (lcpu != cpu_number())) {
 170                 return (mach_vm_size_t)
 171                         kdp_x86_xcpu_invoke(lcpu, (kdp_x86_xcpu_func_t)kdp_machine_phys_read, rq, dst);
 172         }
 173
 174 #ifdef KDP_VM_READ_DEBUG
 175         printf("kdp_phys_read: src %llx dst %p len %llx\n", src, (void *)dst, len);
 176 #endif
 177
 178         cur_virt_dst = (addr64_t)(intptr_t)dst;
 179         cur_phys_src = (addr64_t)src;
 180
 181         while (resid != 0) {
 182
 183                 if(!(cur_phys_dst = kdp_vtophys(kernel_pmap, cur_virt_dst)))
 184                         goto exit;
 185
 186 /* Get length left on page */
 187                 cnt_src = PAGE_SIZE - (cur_phys_src & PAGE_MASK);
 188                 cnt_dst = PAGE_SIZE - (cur_phys_dst & PAGE_MASK);
 189                 if (cnt_src > cnt_dst)
 190                         cnt = cnt_dst;
 191                 else
 192                         cnt = cnt_src;
 193                 if (cnt > resid)
 194                         cnt = resid;
 195
 196         /* Do a physical copy; use ml_copy_phys() in the event this is
 197          * a short read with potential side effects.
 198          */
 199                 if (EFAULT == ml_copy_phys(cur_phys_src,
 200                                            cur_phys_dst,
 201                                            (vm_size_t)cnt))
 202                         goto exit;
 203                 cur_phys_src += cnt;
 204                 cur_virt_dst += cnt;
 205                 resid -= cnt;
 206         }
 207 exit:
 208         return (len - resid);
 209 }
 210
 211 /*
 212  *
 213  */
 214 mach_vm_size_t
 215 kdp_machine_vm_write( caddr_t src, mach_vm_address_t dst, mach_vm_size_t len)
 216 {
 217         addr64_t cur_virt_src, cur_virt_dst;
 218         addr64_t cur_phys_src, cur_phys_dst;
 219         unsigned resid, cnt, cnt_src, cnt_dst;
 220
 221 #ifdef KDP_VM_WRITE_DEBUG
 222         printf("kdp_vm_write: src %p dst %llx len %llx - %08X %08X\n", (void *)src, dst, len, ((unsigned int *)src)[0], ((unsigned int *)src)[1]);
 223 #endif
 224
 225         cur_virt_src = PAL_KDP_ADDR((addr64_t)(intptr_t)src);
 226         cur_virt_dst = PAL_KDP_ADDR((addr64_t)dst);
 227
 228         resid = (unsigned)len;
 229
 230         while (resid != 0) {
 231                 if ((cur_phys_dst = kdp_vtophys(kernel_pmap, cur_virt_dst)) == 0)
 232                         goto exit;
 233
 234                 if ((cur_phys_src = kdp_vtophys(kernel_pmap, cur_virt_src)) == 0)
 235                         goto exit;
 236
 237                 /* Copy as many bytes as possible without crossing a page */
 238                 cnt_src = (unsigned)(PAGE_SIZE - (cur_phys_src & PAGE_MASK));
 239                 cnt_dst = (unsigned)(PAGE_SIZE - (cur_phys_dst & PAGE_MASK));
 240
 241                 if (cnt_src > cnt_dst)
 242                         cnt = cnt_dst;
 243                 else
 244                         cnt = cnt_src;
 245                 if (cnt > resid)
 246                         cnt = resid;
 247
 248                 if (EFAULT == ml_copy_phys(cur_phys_src, cur_phys_dst, cnt))
 249                         goto exit;              /* Copy stuff over */
 250
 251                 cur_virt_src +=cnt;
 252                 cur_virt_dst +=cnt;
 253                 resid -= cnt;
 254         }
 255 exit:
 256         return (len - resid);
 257 }
 258
 259 /*
 260  *
 261  */
 262 mach_vm_size_t
 263 kdp_machine_phys_write(kdp_writephysmem64_req_t *rq, caddr_t src,
 264                        uint16_t lcpu)
 265 {
 266         mach_vm_address_t dst = rq->address;
 267         mach_vm_size_t    len = rq->nbytes;
 268         addr64_t cur_virt_src;
 269         addr64_t cur_phys_src, cur_phys_dst;
 270         unsigned resid, cnt, cnt_src, cnt_dst;
 271
 272         if ((lcpu != KDP_CURRENT_LCPU) && (lcpu != cpu_number())) {
 273                 return (mach_vm_size_t)
 274                         kdp_x86_xcpu_invoke(lcpu, (kdp_x86_xcpu_func_t)kdp_machine_phys_write, rq, src);
 275         }
 276
 277 #ifdef KDP_VM_WRITE_DEBUG
 278         printf("kdp_phys_write: src %p dst %llx len %llx - %08X %08X\n", (void *)src, dst, len, ((unsigned int *)src)[0], ((unsigned int *)src)[1]);
 279 #endif
 280
 281         cur_virt_src = (addr64_t)(intptr_t)src;
 282         cur_phys_dst = (addr64_t)dst;
 283
 284         resid = (unsigned)len;
 285
 286         while (resid != 0) {
 287                 if ((cur_phys_src = kdp_vtophys(kernel_pmap, cur_virt_src)) == 0)
 288                         goto exit;
 289
 290                 /* Copy as many bytes as possible without crossing a page */
 291                 cnt_src = (unsigned)(PAGE_SIZE - (cur_phys_src & PAGE_MASK));
 292                 cnt_dst = (unsigned)(PAGE_SIZE - (cur_phys_dst & PAGE_MASK));
 293
 294                 if (cnt_src > cnt_dst)
 295                         cnt = cnt_dst;
 296                 else
 297                         cnt = cnt_src;
 298                 if (cnt > resid)
 299                         cnt = resid;
 300
 301                 if (EFAULT == ml_copy_phys(cur_phys_src, cur_phys_dst, cnt))
 302                         goto exit;              /* Copy stuff over */
 303
 304                 cur_virt_src +=cnt;
 305                 cur_phys_dst +=cnt;
 306                 resid -= cnt;
 307         }
 308
 309 exit:
 310         return (len - resid);
 311 }
 312
 313 int
 314 kdp_machine_ioport_read(kdp_readioport_req_t *rq, caddr_t data, uint16_t lcpu)
 315 {
 316         uint16_t addr = rq->address;
 317         uint16_t size = rq->nbytes;
 318
 319         if ((lcpu != KDP_CURRENT_LCPU) && (lcpu != cpu_number())) {
 320                 return (int) kdp_x86_xcpu_invoke(lcpu, (kdp_x86_xcpu_func_t)kdp_machine_ioport_read, rq, data);
 321         }
 322
 323         switch (size)
 324         {
 325         case 1:
 326                 *((uint8_t *) data)  = inb(addr);
 327                 break;
 328         case 2:
 329                 *((uint16_t *) data) = inw(addr);
 330                 break;
 331         case 4:
 332                 *((uint32_t *) data) = inl(addr);
 333                 break;
 334         default:
 335                 return KDPERR_BADFLAVOR;
 336                 break;
 337         }
 338
 339         return KDPERR_NO_ERROR;
 340 }
 341
 342 int
 343 kdp_machine_ioport_write(kdp_writeioport_req_t *rq, caddr_t data, uint16_t lcpu)
 344 {
 345         uint16_t addr = rq->address;
 346         uint16_t size = rq->nbytes;
 347
 348         if ((lcpu != KDP_CURRENT_LCPU) && (lcpu != cpu_number())) {
 349                 return (int) kdp_x86_xcpu_invoke(lcpu, (kdp_x86_xcpu_func_t)kdp_machine_ioport_write, rq, data);
 350         }
 351
 352         switch (size)
 353         {
 354         case 1:
 355                 outb(addr, *((uint8_t *) data));
 356                 break;
 357         case 2:
 358                 outw(addr, *((uint16_t *) data));
 359                 break;
 360         case 4:
 361                 outl(addr, *((uint32_t *) data));
 362                 break;
 363         default:
 364                 return KDPERR_BADFLAVOR;
 365                 break;
 366         }
 367
 368         return KDPERR_NO_ERROR;
 369 }
 370
 371 int
 372 kdp_machine_msr64_read(kdp_readmsr64_req_t *rq, caddr_t data, uint16_t lcpu)
 373 {
 374         uint64_t *value = (uint64_t *) data;
 375         uint32_t msr    = rq->address;
 376
 377         if ((lcpu != KDP_CURRENT_LCPU) && (lcpu != cpu_number())) {
 378                 return (int) kdp_x86_xcpu_invoke(lcpu, (kdp_x86_xcpu_func_t)kdp_machine_msr64_read, rq, data);
 379         }
 380
 381         *value = rdmsr64(msr);
 382         return KDPERR_NO_ERROR;
 383 }
 384
 385 int
 386 kdp_machine_msr64_write(kdp_writemsr64_req_t *rq, caddr_t data, uint16_t lcpu)
 387 {
 388         uint64_t *value = (uint64_t *) data;
 389         uint32_t msr    = rq->address;
 390
 391         if ((lcpu != KDP_CURRENT_LCPU) && (lcpu != cpu_number())) {
 392                 return (int) kdp_x86_xcpu_invoke(lcpu, (kdp_x86_xcpu_func_t)kdp_machine_msr64_write, rq, data);
 393         }
 394
 395         wrmsr64(msr, *value);
 396         return KDPERR_NO_ERROR;
 397 }
 398
 399 pt_entry_t *debugger_ptep;
 400 vm_map_offset_t debugger_window_kva;
 401
 402 /* Establish a pagetable window that can be remapped on demand.
 403  * This is utilized by the debugger to address regions outside
 404  * the physical map.
 405  */
 406
 407 void
 408 kdp_machine_init(void) {
 409         if (debug_boot_arg == 0)
 410                 return;
 411
 412         vm_map_entry_t e;
 413         kern_return_t kr = vm_map_find_space(kernel_map,
 414             &debugger_window_kva,
 415             PAGE_SIZE, 0,
 416             VM_MAKE_TAG(VM_KERN_MEMORY_OSFMK), &e);
 417
 418         if (kr != KERN_SUCCESS) {
 419                 panic("%s: vm_map_find_space failed with %d\n", __FUNCTION__, kr);
 420         }
 421
 422         vm_map_unlock(kernel_map);
 423
 424         debugger_ptep = pmap_pte(kernel_pmap, debugger_window_kva);
 425
 426         if (debugger_ptep == NULL) {
 427                 pmap_expand(kernel_pmap, debugger_window_kva, PMAP_EXPAND_OPTIONS_NONE);
 428                 debugger_ptep = pmap_pte(kernel_pmap, debugger_window_kva);
 429         }
 430 }
 431
 432
 433