1 /*
2 * Copyright (c) 2000-2007 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 #include <mach/mach_types.h>
29 #include <mach/vm_attributes.h>
30 #include <mach/vm_param.h>
31
32 #include <vm/pmap.h>
33
34 #include <mach/thread_status.h>
35 #include <mach-o/loader.h>
36 #include <mach/vm_region.h>
37 #include <mach/vm_statistics.h>
38
39 #include <vm/vm_kern.h>
40 #include <vm/vm_object_xnu.h>
41 #include <vm/vm_protos.h>
42 #include <kdp/kdp_core.h>
43 #include <kdp/kdp_udp.h>
44 #include <kdp/kdp_internal.h>
45 #include <arm/misc_protos.h>
46 #include <arm/caches_internal.h>
47 #include <arm/cpu_data_internal.h>
48 #include <arm/misc_protos.h>
49
50 pmap_t kdp_pmap = 0;
51 boolean_t kdp_trans_off;
52 boolean_t kdp_read_io = 0;
53
54 pmap_paddr_t kdp_vtophys(pmap_t pmap, vm_offset_t va);
55
56 /*
57 * kdp_vtophys
58 */
59 pmap_paddr_t
kdp_vtophys(pmap_t pmap,vm_offset_t va)60 kdp_vtophys(
61 pmap_t pmap,
62 vm_offset_t va)
63 {
64 pmap_paddr_t pa;
65
66
67 /* Ensure that the provided va resides within the provided pmap range. */
68 if (!pmap || ((pmap != kernel_pmap) && ((va < pmap->min) || (va >= pmap->max)))) {
69 #ifdef KDP_VTOPHYS_DEBUG
70 printf("kdp_vtophys(%08x, %016lx) not in range %08x .. %08x\n", (unsigned int) pmap,
71 (unsigned long) va,
72 (unsigned int) (pmap ? pmap->min : 0),
73 (unsigned int) (pmap ? pmap->max : 0));
74 #endif
75 return 0; /* Just return if no translation */
76 }
77
78 pa = pmap_find_pa(pmap, va); /* Get the physical address */
79 return pa;
80 }
81
82 /*
83 * kdp_machine_vm_read
84 *
85 * Verify that src is valid, and physically copy len bytes from src to
86 * dst, translating if necessary. If translation is enabled
87 * (kdp_trans_off is 0), a non-zero kdp_pmap specifies the pmap to use
88 * when translating src.
89 */
90
91 mach_vm_size_t
kdp_machine_vm_read(mach_vm_address_t src,caddr_t dst,mach_vm_size_t len)92 kdp_machine_vm_read( mach_vm_address_t src, caddr_t dst, mach_vm_size_t len)
93 {
94 addr64_t cur_virt_src, cur_virt_dst;
95 addr64_t cur_phys_src, cur_phys_dst;
96 mach_vm_size_t resid, cnt;
97 pmap_t pmap;
98
99 #ifdef KDP_VM_READ_DEBUG
100 kprintf("kdp_machine_vm_read1: src %x dst %x len %x - %08X %08X\n", src, dst, len, ((unsigned long *) src)[0], ((unsigned long *) src)[1]);
101 #endif
102
103 cur_virt_src = (addr64_t) src;
104 cur_virt_dst = (addr64_t) dst;
105
106 if (kdp_trans_off) {
107 kdp_readphysmem64_req_t rq;
108 mach_vm_size_t ret;
109
110 rq.address = src;
111 rq.nbytes = (uint32_t)len;
112 ret = kdp_machine_phys_read(&rq, dst, 0 /* unused */);
113 return ret;
114 } else {
115 resid = len;
116
117 if (kdp_pmap) {
118 pmap = kdp_pmap; /* If special pmap, use it */
119 } else {
120 pmap = kernel_pmap; /* otherwise, use kernel's */
121 }
122 while (resid != 0) {
123 /*
124 * Always translate the destination using the
125 * kernel_pmap.
126 */
127 if ((cur_phys_dst = kdp_vtophys(kernel_pmap, cur_virt_dst)) == 0) {
128 goto exit;
129 }
130
131 if ((cur_phys_src = kdp_vtophys(pmap, cur_virt_src)) == 0) {
132 goto exit;
133 }
134
135 /* Attempt to ensure that there are valid translations for src and dst. */
136 if (!kdp_read_io && ((!pmap_valid_address(cur_phys_dst)) || (!pmap_valid_address(cur_phys_src)))) {
137 goto exit;
138 }
139
140 cnt = ARM_PGBYTES - (cur_virt_src & PAGE_MASK); /* Get length left on
141 * page */
142 if (cnt > (ARM_PGBYTES - (cur_virt_dst & PAGE_MASK))) {
143 cnt = ARM_PGBYTES - (cur_virt_dst & PAGE_MASK);
144 }
145
146 if (cnt > resid) {
147 cnt = resid;
148 }
149
150 #ifdef KDP_VM_READ_DEBUG
151 kprintf("kdp_machine_vm_read2: pmap %08X, virt %016LLX, phys %016LLX\n",
152 pmap, cur_virt_src, cur_phys_src);
153 #endif
154 bcopy_phys(cur_phys_src, cur_phys_dst, cnt);
155
156 cur_virt_src += cnt;
157 cur_virt_dst += cnt;
158 resid -= cnt;
159 }
160 }
161 exit:
162 #ifdef KDP_VM_READ_DEBUG
163 kprintf("kdp_machine_vm_read: ret %08X\n", len - resid);
164 #endif
165 return len - resid;
166 }
167
168 mach_vm_size_t
kdp_machine_phys_read(kdp_readphysmem64_req_t * rq,caddr_t dst,uint16_t lcpu __unused)169 kdp_machine_phys_read(kdp_readphysmem64_req_t *rq, caddr_t dst, uint16_t lcpu __unused)
170 {
171 mach_vm_address_t src = rq->address;
172 mach_vm_size_t len = rq->nbytes;
173
174 addr64_t cur_virt_dst;
175 addr64_t cur_phys_src, cur_phys_dst;
176 mach_vm_size_t resid = len;
177 mach_vm_size_t cnt = 0, cnt_src, cnt_dst;
178
179 #ifdef KDP_VM_READ_DEBUG
180 kprintf("kdp_phys_read src %x dst %p len %x\n", src, dst, len);
181 #endif
182
183 cur_virt_dst = (addr64_t) dst;
184 cur_phys_src = (addr64_t) src;
185
186 while (resid != 0) {
187 if ((cur_phys_dst = kdp_vtophys(kernel_pmap, cur_virt_dst)) == 0) {
188 goto exit;
189 }
190
191 /* Get length left on page */
192
193 cnt_src = ARM_PGBYTES - (cur_phys_src & PAGE_MASK);
194 cnt_dst = ARM_PGBYTES - (cur_phys_dst & PAGE_MASK);
195 if (cnt_src > cnt_dst) {
196 cnt = cnt_dst;
197 } else {
198 cnt = cnt_src;
199 }
200 if (cnt > resid) {
201 cnt = resid;
202 }
203
204 bcopy_phys(cur_phys_src, cur_phys_dst, cnt); /* Copy stuff over */
205 cur_phys_src += cnt;
206 cur_virt_dst += cnt;
207 resid -= cnt;
208 }
209
210 exit:
211 return len - resid;
212 }
213
214 /*
215 * kdp_vm_write
216 */
217 mach_vm_size_t
kdp_machine_vm_write(caddr_t src,mach_vm_address_t dst,mach_vm_size_t len)218 kdp_machine_vm_write( caddr_t src, mach_vm_address_t dst, mach_vm_size_t len)
219 {
220 addr64_t cur_virt_src, cur_virt_dst;
221 addr64_t cur_phys_src, cur_phys_dst;
222 mach_vm_size_t resid, cnt, cnt_src, cnt_dst;
223
224 #ifdef KDP_VM_WRITE_DEBUG
225 printf("kdp_vm_write: src %x dst %x len %x - %08X %08X\n", src, dst, len, ((unsigned long *) src)[0], ((unsigned long *) src)[1]);
226 #endif
227
228 cur_virt_src = (addr64_t) src;
229 cur_virt_dst = (addr64_t) dst;
230
231 resid = len;
232
233 while (resid != 0) {
234 if ((cur_phys_dst = kdp_vtophys(kernel_pmap, cur_virt_dst)) == 0) {
235 goto exit;
236 }
237
238 if ((cur_phys_src = kdp_vtophys(kernel_pmap, cur_virt_src)) == 0) {
239 goto exit;
240 }
241
242 /* Attempt to ensure that there are valid translations for src and dst. */
243 /* No support for enabling writes for an invalid translation at the moment. */
244 if ((!pmap_valid_address(cur_phys_dst)) || (!pmap_valid_address(cur_phys_src))) {
245 goto exit;
246 }
247
248 cnt_src = ((cur_phys_src + ARM_PGBYTES) & (-ARM_PGBYTES)) - cur_phys_src;
249 cnt_dst = ((cur_phys_dst + ARM_PGBYTES) & (-ARM_PGBYTES)) - cur_phys_dst;
250
251 if (cnt_src > cnt_dst) {
252 cnt = cnt_dst;
253 } else {
254 cnt = cnt_src;
255 }
256 if (cnt > resid) {
257 cnt = resid;
258 }
259
260 #ifdef KDP_VM_WRITE_DEBUG
261 printf("kdp_vm_write: cur_phys_src %x cur_phys_src %x len %x - %08X %08X\n", src, dst, cnt);
262 #endif
263 bcopy_phys(cur_phys_src, cur_phys_dst, cnt); /* Copy stuff over */
264 flush_dcache64(cur_phys_dst, (unsigned int)cnt, TRUE);
265 invalidate_icache64(cur_phys_dst, (unsigned int)cnt, TRUE);
266
267 cur_virt_src += cnt;
268 cur_virt_dst += cnt;
269 resid -= cnt;
270 }
271 exit:
272 return len - resid;
273 }
274
275 mach_vm_size_t
kdp_machine_phys_write(kdp_writephysmem64_req_t * rq __unused,caddr_t src __unused,uint16_t lcpu __unused)276 kdp_machine_phys_write(kdp_writephysmem64_req_t *rq __unused, caddr_t src __unused,
277 uint16_t lcpu __unused)
278 {
279 return 0; /* unimplemented */
280 }
281
282 void
kern_collectth_state_size(uint64_t * tstate_count,uint64_t * tstate_size)283 kern_collectth_state_size(uint64_t * tstate_count, uint64_t * tstate_size)
284 {
285 uint64_t count = ml_get_max_cpu_number() + 1;
286
287 *tstate_count = count;
288 *tstate_size = sizeof(struct thread_command)
289 + (sizeof(arm_state_hdr_t)
290 #if defined(__arm64__)
291 + ARM_THREAD_STATE64_COUNT * sizeof(uint32_t));
292 #else
293 + ARM_THREAD_STATE32_COUNT * sizeof(uint32_t));
294 #endif
295 }
296
297 void
kern_collectth_state(thread_t thread __unused,void * buffer,uint64_t size,void ** iter)298 kern_collectth_state(thread_t thread __unused, void *buffer, uint64_t size, void ** iter)
299 {
300 cpu_data_entry_t *cpuentryp = *iter;
301 if (cpuentryp == NULL) {
302 cpuentryp = &CpuDataEntries[0];
303 }
304
305 if (cpuentryp == &CpuDataEntries[ml_get_max_cpu_number()]) {
306 *iter = NULL;
307 } else {
308 *iter = cpuentryp + 1;
309 }
310
311 struct cpu_data *cpudatap = cpuentryp->cpu_data_vaddr;
312
313 struct thread_command *tc = (struct thread_command *)buffer;
314 arm_state_hdr_t *hdr = (arm_state_hdr_t *)(void *)(tc + 1);
315 #if defined(__arm64__)
316 hdr->flavor = ARM_THREAD_STATE64;
317 hdr->count = ARM_THREAD_STATE64_COUNT;
318 arm_thread_state64_t *state = (arm_thread_state64_t *)(void *)(hdr + 1);
319 #else
320 hdr->flavor = ARM_THREAD_STATE;
321 hdr->count = ARM_THREAD_STATE_COUNT;
322 arm_thread_state_t *state = (arm_thread_state_t *)(void *)(hdr + 1);
323 #endif
324
325 tc->cmd = LC_THREAD;
326 tc->cmdsize = (uint32_t) size;
327
328 if ((cpudatap != NULL) && (cpudatap->halt_status == CPU_HALTED_WITH_STATE)) {
329 *state = cpudatap->halt_state;
330 return;
331 }
332
333 processor_t processor = PERCPU_GET_RELATIVE(processor, cpu_data, cpudatap);
334 if ((cpudatap == NULL) || (processor->active_thread == NULL)) {
335 bzero(state, hdr->count * sizeof(uint32_t));
336 return;
337 }
338
339 #if defined(__arm64__)
340 void *kpcb = processor->active_thread->machine.kpcb;
341 if (kpcb != NULL) {
342 arm_saved_state_t *saved_state = (arm_saved_state_t *)kpcb;
343
344 state->fp = saved_state->ss_64.fp;
345 state->lr = saved_state->ss_64.lr;
346 state->sp = saved_state->ss_64.sp;
347 state->pc = saved_state->ss_64.pc;
348 state->cpsr = saved_state->ss_64.cpsr;
349 bcopy(&saved_state->ss_64.x[0], &state->x[0], sizeof(state->x));
350 } else {
351 vm_offset_t kstackptr = (vm_offset_t) processor->active_thread->machine.kstackptr;
352 arm_kernel_saved_state_t *saved_state = (arm_kernel_saved_state_t *) kstackptr;
353
354 state->fp = saved_state->fp;
355 state->lr = saved_state->lr;
356 state->sp = saved_state->sp;
357 state->pc = saved_state->pc_was_in_userspace ? (register_t)ptrauth_strip((void *)&_was_in_userspace, ptrauth_key_function_pointer) : 0;
358 state->cpsr = PSR64_KERNEL_DEFAULT;
359 }
360
361 #else /* __arm64__ */
362 vm_offset_t kstackptr = (vm_offset_t) processor->active_thread->machine.kstackptr;
363 arm_saved_state_t *saved_state = (arm_saved_state_t *) kstackptr;
364
365 state->lr = saved_state->lr;
366 state->sp = saved_state->sp;
367 state->pc = saved_state->pc;
368 state->cpsr = saved_state->cpsr;
369 bcopy(&saved_state->r[0], &state->r[0], sizeof(state->r));
370
371 #endif /* !__arm64__ */
372 }
373
374 static const arm_state_hdr_t user32_thread_flavor_array[] = {
375 { ARM_THREAD_STATE, ARM_UNIFIED_THREAD_STATE_COUNT },
376 };
377
378 #if defined(__arm64__)
379 static const arm_state_hdr_t user64_thread_flavor_array[] = {
380 { ARM_THREAD_STATE64, ARM_THREAD_STATE64_COUNT },
381 { ARM_VFP_STATE, ARM_VFP_STATE_COUNT },
382 { ARM_EXCEPTION_STATE64, ARM_EXCEPTION_STATE64_COUNT },
383 };
384 #endif
385
386 void
kern_collect_userth_state_size(task_t task,uint64_t * tstate_count,uint64_t * tstate_size)387 kern_collect_userth_state_size(task_t task, uint64_t * tstate_count, uint64_t * tstate_size)
388 {
389 uint64_t per_thread_size = 0;
390 uint64_t num_flavors = 0;
391 const arm_state_hdr_t * flavors;
392 #if defined(__arm64__)
393 bool is64bit = task_has_64Bit_addr(task);
394
395 if (is64bit) {
396 flavors = user64_thread_flavor_array;
397 num_flavors = sizeof(user64_thread_flavor_array) / sizeof(user64_thread_flavor_array[0]);
398 } else {
399 flavors = user32_thread_flavor_array;
400 num_flavors = sizeof(user32_thread_flavor_array) / sizeof(user32_thread_flavor_array[0]);
401 }
402 #else
403 flavors = user32_thread_flavor_array;
404 num_flavors = sizeof(user32_thread_flavor_array) / sizeof(user32_thread_flavor_array[0]);
405 #endif
406
407 for (size_t i = 0; i < num_flavors; i++) {
408 per_thread_size += sizeof(arm_state_hdr_t) + (flavors[i].count * sizeof(natural_t));
409 }
410
411 *tstate_count = task->thread_count;
412 *tstate_size = sizeof(struct thread_command) + per_thread_size;
413 }
414
415 void
kern_collect_userth_state(task_t task,thread_t thread,void * buffer,uint64_t size)416 kern_collect_userth_state(task_t task, thread_t thread, void *buffer, uint64_t size)
417 {
418 kern_return_t ret;
419 uint64_t num_flavors = 0;
420 const arm_state_hdr_t * flavors;
421 #if defined(__arm64__)
422 bool is64bit = task_has_64Bit_addr(task);
423
424 if (is64bit) {
425 flavors = user64_thread_flavor_array;
426 num_flavors = sizeof(user64_thread_flavor_array) / sizeof(user64_thread_flavor_array[0]);
427 } else {
428 flavors = user32_thread_flavor_array;
429 num_flavors = sizeof(user32_thread_flavor_array) / sizeof(user32_thread_flavor_array[0]);
430 }
431 #else
432 (void)task;
433 flavors = user32_thread_flavor_array;
434 num_flavors = sizeof(user32_thread_flavor_array) / sizeof(user32_thread_flavor_array[0]);
435 #endif
436
437 struct thread_command *tc = buffer;
438 tc->cmd = LC_THREAD;
439 tc->cmdsize = (uint32_t)size;
440
441 arm_state_hdr_t *hdr = (arm_state_hdr_t *)(tc + 1);
442
443 for (size_t i = 0; i < num_flavors; i++) {
444 hdr->flavor = flavors[i].flavor;
445 hdr->count = flavors[i].count;
446 /* Ensure we can't write past the end of the buffer */
447 assert(hdr->count + sizeof(arm_state_hdr_t) + ((uintptr_t)hdr - (uintptr_t)buffer) <= size);
448 ret = machine_thread_get_state(thread, hdr->flavor, (thread_state_t)(hdr + 1), &hdr->count);
449 assert(ret == KERN_SUCCESS);
450
451 hdr = (arm_state_hdr_t *)((uintptr_t)(hdr + 1) + hdr->count * sizeof(natural_t));
452 }
453 }
454
455 /*
456 * kdp_core_start_addr
457 *
458 * return the address where the kernel core file starts
459 *
460 * The kernel start address is VM_MIN_KERNEL_AND_KEXT_ADDRESS
461 * unless the physical aperture has been relocated below
462 * VM_MIN_KERNEL_AND_KEXT_ADDRESS as in the case of
463 * ARM_LARGE_MEMORY systems
464 *
465 */
466 vm_map_offset_t
kdp_core_start_addr()467 kdp_core_start_addr()
468 {
469 #if defined(__arm64__)
470 extern const vm_map_address_t physmap_base;
471 return MIN(physmap_base, VM_MIN_KERNEL_AND_KEXT_ADDRESS);
472 #else /* !defined(__arm64__) */
473 return VM_MIN_KERNEL_AND_KEXT_ADDRESS;
474 #endif /* !defined(__arm64__) */
475 }
476