]> git.saurik.com Git - apple/xnu.git/blame_incremental - osfmk/arm64/machine_task.c
xnu-6153.41.3.tar.gz
[apple/xnu.git] / osfmk / arm64 / machine_task.c
... / ...
CommitLineData
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 * @OSF_COPYRIGHT@
30 */
31/*
32 * Mach Operating System
33 * Copyright (c) 1991,1990 Carnegie Mellon University
34 * All Rights Reserved.
35 *
36 * Permission to use, copy, modify and distribute this software and its
37 * documentation is hereby granted, provided that both the copyright
38 * notice and this permission notice appear in all copies of the
39 * software, derivative works or modified versions, and any portions
40 * thereof, and that both notices appear in supporting documentation.
41 *
42 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
43 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
44 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
45 *
46 * Carnegie Mellon requests users of this software to return to
47 *
48 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
49 * School of Computer Science
50 * Carnegie Mellon University
51 * Pittsburgh PA 15213-3890
52 *
53 * any improvements or extensions that they make and grant Carnegie Mellon
54 * the rights to redistribute these changes.
55 */
56
57#include <kern/task.h>
58#include <kern/thread.h>
59#include <arm/misc_protos.h>
60
61extern zone_t ads_zone;
62
63kern_return_t
64machine_task_set_state(
65 task_t task,
66 int flavor,
67 thread_state_t state,
68 mach_msg_type_number_t state_count)
69{
70 switch (flavor) {
71 case ARM_DEBUG_STATE:
72 {
73 arm_legacy_debug_state_t *tstate = (arm_legacy_debug_state_t *) state;
74 if (task_has_64Bit_data(task) ||
75 (state_count != ARM_LEGACY_DEBUG_STATE_COUNT) ||
76 (!debug_legacy_state_is_valid(tstate))) {
77 return KERN_INVALID_ARGUMENT;
78 }
79
80 if (task->task_debug == NULL) {
81 task->task_debug = zalloc(ads_zone);
82 if (task->task_debug == NULL) {
83 return KERN_FAILURE;
84 }
85 }
86
87 copy_legacy_debug_state(tstate, (arm_legacy_debug_state_t *) task->task_debug, FALSE); /* FALSE OR TRUE doesn't matter since we are ignoring it for arm */
88
89 return KERN_SUCCESS;
90 }
91 case ARM_DEBUG_STATE32:
92 {
93 arm_debug_state32_t *tstate = (arm_debug_state32_t *) state;
94 if (task_has_64Bit_data(task) ||
95 (state_count != ARM_DEBUG_STATE32_COUNT) ||
96 (!debug_state_is_valid32(tstate))) {
97 return KERN_INVALID_ARGUMENT;
98 }
99
100 if (task->task_debug == NULL) {
101 task->task_debug = zalloc(ads_zone);
102 if (task->task_debug == NULL) {
103 return KERN_FAILURE;
104 }
105 }
106
107 copy_debug_state32(tstate, (arm_debug_state32_t *) task->task_debug, FALSE); /* FALSE OR TRUE doesn't matter since we are ignoring it for arm */
108
109 return KERN_SUCCESS;
110 }
111 case ARM_DEBUG_STATE64:
112 {
113 arm_debug_state64_t *tstate = (arm_debug_state64_t *) state;
114
115 if ((!task_has_64Bit_data(task)) ||
116 (state_count != ARM_DEBUG_STATE64_COUNT) ||
117 (!debug_state_is_valid64(tstate))) {
118 return KERN_INVALID_ARGUMENT;
119 }
120
121 if (task->task_debug == NULL) {
122 task->task_debug = zalloc(ads_zone);
123 if (task->task_debug == NULL) {
124 return KERN_FAILURE;
125 }
126 }
127
128 copy_debug_state64(tstate, (arm_debug_state64_t *) task->task_debug, FALSE); /* FALSE OR TRUE doesn't matter since we are ignoring it for arm */
129
130 return KERN_SUCCESS;
131 }
132 case THREAD_STATE_NONE: /* Using this flavor to clear task_debug */
133 {
134 if (task->task_debug != NULL) {
135 zfree(ads_zone, task->task_debug);
136 task->task_debug = NULL;
137
138 return KERN_SUCCESS;
139 }
140 return KERN_FAILURE;
141 }
142 default:
143 {
144 return KERN_INVALID_ARGUMENT;
145 }
146 }
147
148 return KERN_FAILURE;
149}
150
151kern_return_t
152machine_task_get_state(task_t task,
153 int flavor,
154 thread_state_t state,
155 mach_msg_type_number_t *state_count)
156{
157 switch (flavor) {
158 case ARM_DEBUG_STATE:
159 {
160 arm_legacy_debug_state_t *tstate = (arm_legacy_debug_state_t *) state;
161
162 if (task_has_64Bit_data(task) || (*state_count != ARM_LEGACY_DEBUG_STATE_COUNT)) {
163 return KERN_INVALID_ARGUMENT;
164 }
165
166 if (task->task_debug == NULL) {
167 bzero(state, sizeof(*tstate));
168 } else {
169 copy_legacy_debug_state((arm_legacy_debug_state_t*) task->task_debug, tstate, FALSE); /* FALSE OR TRUE doesn't matter since we are ignoring it for arm */
170 }
171
172 return KERN_SUCCESS;
173 }
174 case ARM_DEBUG_STATE32:
175 {
176 arm_debug_state32_t *tstate = (arm_debug_state32_t *) state;
177
178 if (task_has_64Bit_data(task) || (*state_count != ARM_DEBUG_STATE32_COUNT)) {
179 return KERN_INVALID_ARGUMENT;
180 }
181
182 if (task->task_debug == NULL) {
183 bzero(state, sizeof(*tstate));
184 } else {
185 copy_debug_state32((arm_debug_state32_t*) task->task_debug, tstate, FALSE); /* FALSE OR TRUE doesn't matter since we are ignoring it for arm */
186 }
187
188 return KERN_SUCCESS;
189 }
190 case ARM_DEBUG_STATE64:
191 {
192 arm_debug_state64_t *tstate = (arm_debug_state64_t *) state;
193
194 if ((!task_has_64Bit_data(task)) || (*state_count != ARM_DEBUG_STATE64_COUNT)) {
195 return KERN_INVALID_ARGUMENT;
196 }
197
198 if (task->task_debug == NULL) {
199 bzero(state, sizeof(*tstate));
200 } else {
201 copy_debug_state64((arm_debug_state64_t*) task->task_debug, tstate, FALSE); /* FALSE OR TRUE doesn't matter since we are ignoring it for arm */
202 }
203
204 return KERN_SUCCESS;
205 }
206 default:
207 {
208 return KERN_INVALID_ARGUMENT;
209 }
210 }
211 return KERN_FAILURE;
212}
213
214void
215machine_task_terminate(task_t task)
216{
217 if (task) {
218 void *task_debug;
219
220 task_debug = task->task_debug;
221 if (task_debug != NULL) {
222 task->task_debug = NULL;
223 zfree(ads_zone, task_debug);
224 }
225 }
226}
227
228
229kern_return_t
230machine_thread_inherit_taskwide(
231 thread_t thread,
232 task_t parent_task)
233{
234 if (parent_task->task_debug) {
235 int flavor;
236 mach_msg_type_number_t count;
237
238 flavor = task_has_64Bit_data(parent_task) ? ARM_DEBUG_STATE64 : ARM_DEBUG_STATE32;
239 count = task_has_64Bit_data(parent_task) ? ARM_DEBUG_STATE64_COUNT : ARM_DEBUG_STATE32_COUNT;
240
241 return machine_thread_set_state(thread, flavor, parent_task->task_debug, count);
242 }
243
244 return KERN_SUCCESS;
245}
246
247
248void
249machine_task_init(__unused task_t new_task,
250 __unused task_t parent_task,
251 __unused boolean_t memory_inherit)
252{
253}