osfmk/ppc/chud/chud_xnu.h

   1 /*
   2  * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22
  23 #ifndef _PPC_CHUD_XNU_H_
  24 #define _PPC_CHUD_XNU_H_
  25
  26
  27 #include <stdint.h>
  28 #include <mach/boolean.h>
  29 #include <mach/mach_types.h>
  30
  31 #pragma mark **** version ****
  32 uint32_t chudxnu_version(void);
  33
  34 #pragma mark **** task ****
  35 // ********************************************************************************
  36 // task
  37 // ********************************************************************************
  38 int chudxnu_pid_for_task(task_t task);
  39 task_t chudxnu_task_for_pid(int pid);
  40 int chudxnu_current_pid(void);
  41
  42 kern_return_t chudxnu_task_read(task_t task, void *kernaddr, uint64_t usraddr, vm_size_t size);
  43 kern_return_t chudxnu_task_write(task_t task, uint64_t useraddr, void *kernaddr, vm_size_t size);
  44 kern_return_t chudxnu_kern_read(void *destaddr, vm_offset_t srcaddr, vm_size_t size);
  45 kern_return_t chudxnu_kern_write(vm_offset_t destaddr, void *srcaddr, vm_size_t size);
  46
  47 boolean_t chudxnu_is_64bit_task(task_t task);
  48
  49 #pragma mark **** thread ****
  50 // ********************************************************************************
  51 // thread
  52 // ********************************************************************************
  53 kern_return_t chudxnu_bind_thread(thread_t thread, int cpu);
  54
  55 kern_return_t chudxnu_unbind_thread(thread_t thread);
  56
  57 kern_return_t chudxnu_thread_get_state( thread_t thread,
  58                                                 thread_flavor_t flavor,
  59                                             thread_state_t tstate,
  60                                             mach_msg_type_number_t *count,
  61                                             boolean_t user_only);
  62
  63 kern_return_t chudxnu_thread_set_state( thread_t thread,
  64                                                 thread_flavor_t flavor,
  65                                             thread_state_t tstate,
  66                                             mach_msg_type_number_t count,
  67                                             boolean_t user_only);
  68
  69 kern_return_t chudxnu_thread_user_state_available(thread_t thread);
  70
  71
  72 kern_return_t chudxnu_thread_get_callstack( thread_t thread,
  73                                                                                         uint32_t *callStack,
  74                                                                                         mach_msg_type_number_t *count,
  75                                                                                         boolean_t user_only);
  76
  77 kern_return_t chudxnu_thread_get_callstack64(thread_t thread,
  78                                                                                         uint64_t *callStack,
  79                                                 mach_msg_type_number_t *count,
  80                                                 boolean_t user_only);
  81
  82 task_t chudxnu_current_task(void);
  83 thread_t chudxnu_current_thread(void);
  84
  85 task_t chudxnu_task_for_thread(thread_t thread);
  86
  87 kern_return_t chudxnu_all_tasks(task_array_t            *task_list,
  88                                                                 mach_msg_type_number_t  *count);
  89 kern_return_t chudxnu_free_task_list(task_array_t       *task_list,
  90                                                                          mach_msg_type_number_t *count);
  91
  92 kern_return_t chudxnu_all_threads(      thread_array_t          *thread_list,
  93                                                                         mach_msg_type_number_t  *count);
  94 kern_return_t chudxnu_task_threads(     task_t task,
  95                                                                         thread_array_t *thread_list,
  96                                                                         mach_msg_type_number_t *count);
  97 kern_return_t chudxnu_free_thread_list(thread_array_t   *thread_list,
  98                                                 mach_msg_type_number_t *count);
  99
 100 kern_return_t chudxnu_thread_info(  thread_t thread,
 101                                         thread_flavor_t flavor,
 102                                         thread_info_t thread_info_out,
 103                                         mach_msg_type_number_t *thread_info_count);
 104
 105 kern_return_t chudxnu_thread_last_context_switch(thread_t thread, uint64_t *timestamp);
 106
 107
 108 #pragma mark **** memory ****
 109 // ********************************************************************************
 110 // memory
 111 // ********************************************************************************
 112
 113 uint64_t chudxnu_avail_memory_size(void);
 114 uint64_t chudxnu_phys_memory_size(void);
 115
 116 vm_offset_t chudxnu_io_map(uint64_t phys_addr, vm_size_t size);
 117
 118 uint32_t chudxnu_phys_addr_wimg(uint64_t phys_addr);
 119
 120 #pragma mark **** cpu ****
 121 // ********************************************************************************
 122 // cpu
 123 // ********************************************************************************
 124 int chudxnu_avail_cpu_count(void);
 125 int chudxnu_phys_cpu_count(void);
 126 int chudxnu_cpu_number(void);
 127
 128 kern_return_t chudxnu_enable_cpu(int cpu, boolean_t enable);
 129
 130 kern_return_t chudxnu_enable_cpu_nap(int cpu, boolean_t enable);
 131 boolean_t chudxnu_cpu_nap_enabled(int cpu);
 132
 133 boolean_t chudxnu_get_interrupts_enabled(void);
 134 boolean_t chudxnu_set_interrupts_enabled(boolean_t enable);
 135 boolean_t chudxnu_at_interrupt_context(void);
 136 void chudxnu_cause_interrupt(void);
 137
 138 kern_return_t chudxnu_set_shadowed_spr(int cpu, int spr, uint32_t val);
 139 kern_return_t chudxnu_set_shadowed_spr64(int cpu, int spr, uint64_t val);
 140
 141 uint32_t chudxnu_get_orig_cpu_l2cr(int cpu);
 142 uint32_t chudxnu_get_orig_cpu_l3cr(int cpu);
 143
 144 kern_return_t chudxnu_read_spr(int cpu, int spr, uint32_t *val_p);
 145 kern_return_t chudxnu_read_spr64(int cpu, int spr, uint64_t *val_p);
 146 kern_return_t chudxnu_write_spr(int cpu, int spr, uint32_t val);
 147 kern_return_t chudxnu_write_spr64(int cpu, int spr, uint64_t val);
 148
 149 void chudxnu_flush_caches(void);
 150 void chudxnu_enable_caches(boolean_t enable);
 151
 152 kern_return_t chudxnu_perfmon_acquire_facility(task_t);
 153 kern_return_t chudxnu_perfmon_release_facility(task_t);
 154
 155 uint32_t * chudxnu_get_branch_trace_buffer(uint32_t *entries);
 156
 157 typedef struct {
 158     uint32_t hwResets;
 159     uint32_t hwMachineChecks;
 160     uint32_t hwDSIs;
 161     uint32_t hwISIs;
 162     uint32_t hwExternals;
 163     uint32_t hwAlignments;
 164     uint32_t hwPrograms;
 165     uint32_t hwFloatPointUnavailable;
 166     uint32_t hwDecrementers;
 167     uint32_t hwIOErrors;
 168     uint32_t hwSystemCalls;
 169     uint32_t hwTraces;
 170     uint32_t hwFloatingPointAssists;
 171     uint32_t hwPerformanceMonitors;
 172     uint32_t hwAltivecs;
 173     uint32_t hwInstBreakpoints;
 174     uint32_t hwSystemManagements;
 175     uint32_t hwAltivecAssists;
 176     uint32_t hwThermal;
 177     uint32_t hwSoftPatches;
 178     uint32_t hwMaintenances;
 179     uint32_t hwInstrumentations;
 180 } rupt_counters_t;
 181
 182 kern_return_t chudxnu_get_cpu_rupt_counters(int cpu, rupt_counters_t *rupts);
 183 kern_return_t chudxnu_clear_cpu_rupt_counters(int cpu);
 184
 185 kern_return_t chudxnu_passup_alignment_exceptions(boolean_t enable);
 186
 187 kern_return_t chudxnu_scom_read(uint32_t reg, uint64_t *data);
 188 kern_return_t chudxnu_scom_write(uint32_t reg, uint64_t data);
 189
 190 #pragma mark **** callbacks ****
 191 // ********************************************************************************
 192 // callbacks
 193 // ********************************************************************************
 194
 195 void chudxnu_cancel_all_callbacks(void);
 196
 197 // cpu timer - each cpu has its own callback
 198 typedef kern_return_t (*chudxnu_cpu_timer_callback_func_t)(thread_flavor_t flavor, thread_state_t tstate,  mach_msg_type_number_t count);
 199 kern_return_t chudxnu_cpu_timer_callback_enter(chudxnu_cpu_timer_callback_func_t func, uint32_t time, uint32_t units); // callback is entered on current cpu
 200 kern_return_t chudxnu_cpu_timer_callback_cancel(void); // callback is cleared on current cpu
 201 kern_return_t chudxnu_cpu_timer_callback_cancel_all(void); // callback is cleared on all cpus
 202
 203 // trap callback - one callback for system
 204 typedef kern_return_t (*chudxnu_trap_callback_func_t)(uint32_t trapentry, thread_flavor_t flavor, thread_state_t tstate,  mach_msg_type_number_t count);
 205 kern_return_t chudxnu_trap_callback_enter(chudxnu_trap_callback_func_t func);
 206 kern_return_t chudxnu_trap_callback_cancel(void);
 207
 208 // interrupt callback - one callback for system
 209 typedef kern_return_t (*chudxnu_interrupt_callback_func_t)(uint32_t trapentry, thread_flavor_t flavor, thread_state_t tstate,  mach_msg_type_number_t count);
 210 kern_return_t chudxnu_interrupt_callback_enter(chudxnu_interrupt_callback_func_t func);
 211 kern_return_t chudxnu_interrupt_callback_cancel(void);
 212
 213 // ast callback - one callback for system
 214 typedef kern_return_t (*chudxnu_perfmon_ast_callback_func_t)(thread_flavor_t flavor, thread_state_t tstate,  mach_msg_type_number_t count);
 215 kern_return_t chudxnu_perfmon_ast_callback_enter(chudxnu_perfmon_ast_callback_func_t func);
 216 kern_return_t chudxnu_perfmon_ast_callback_cancel(void);
 217 kern_return_t chudxnu_perfmon_ast_send(void);
 218 kern_return_t chudxnu_perfmon_ast_send_urgent(boolean_t urgent);
 219
 220 // cpusig callback - one callback for system
 221 typedef kern_return_t (*chudxnu_cpusig_callback_func_t)(int request, thread_flavor_t flavor, thread_state_t tstate, mach_msg_type_number_t count);
 222 kern_return_t chudxnu_cpusig_callback_enter(chudxnu_cpusig_callback_func_t func);
 223 kern_return_t chudxnu_cpusig_callback_cancel(void);
 224 kern_return_t chudxnu_cpusig_send(int otherCPU, uint32_t request);
 225
 226 // kdebug callback - one callback for system
 227 typedef kern_return_t (*chudxnu_kdebug_callback_func_t)(uint32_t debugid, uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4);
 228 kern_return_t chudxnu_kdebug_callback_enter(chudxnu_kdebug_callback_func_t func);
 229 kern_return_t chudxnu_kdebug_callback_cancel(void);
 230
 231 // timer callback - multiple callbacks
 232 typedef kern_return_t (*chudxnu_timer_callback_func_t)(uint32_t param0, uint32_t param1);
 233 typedef void *  chud_timer_t;
 234 chud_timer_t chudxnu_timer_alloc(chudxnu_timer_callback_func_t func, uint32_t param0);
 235 kern_return_t chudxnu_timer_callback_enter(chud_timer_t timer, uint32_t param1, uint32_t time, uint32_t units);
 236 kern_return_t chudxnu_timer_callback_cancel(chud_timer_t timer);
 237 kern_return_t chudxnu_timer_free(chud_timer_t timer);
 238
 239 // CHUD systemcall callback - one callback for system
 240 typedef kern_return_t (*chudxnu_syscall_callback_func_t)(thread_flavor_t flavor, thread_state_t tstate, mach_msg_type_number_t count);
 241 kern_return_t chudxnu_syscall_callback_enter(chudxnu_syscall_callback_func_t func);
 242 kern_return_t chudxnu_syscall_callback_cancel(void);
 243
 244 // ********************************************************************************
 245 // DEPRECATED
 246 // ********************************************************************************
 247 kern_return_t chudxnu_bind_current_thread(int cpu);
 248
 249 kern_return_t chudxnu_unbind_current_thread(void);
 250
 251 kern_return_t chudxnu_current_thread_get_callstack(uint32_t *callStack,
 252                         mach_msg_type_number_t *count,
 253                         boolean_t user_only);
 254
 255 thread_t chudxnu_current_act(void);
 256
 257 // thread timer callback - one callback for system
 258 typedef kern_return_t (*chudxnu_thread_timer_callback_func_t)(uint32_t param);
 259 kern_return_t chudxnu_thread_timer_callback_enter(chudxnu_thread_timer_callback_func_t func, uint32_t param, uint32_t time, uint32_t units);
 260 kern_return_t chudxnu_thread_timer_callback_cancel(void);
 261
 262 #endif /* _PPC_CHUD_XNU_H_ */