git.saurik.com Git - apple/xnu.git/blob - osfmk/mach/mach

1 /*

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

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 * NOTICE: This file was modified by McAfee Research in 2004 to introduce

58 * support for mandatory and extensible security protections. This notice

59 * is included in support of clause 2.2 (b) of the Apple Public License,

60 * Version 2.0.

61 */

62 /*

63 */

64 /*

65 * Mach kernel interface type declarations

66 */

68 #ifndef _MACH_MACH_TYPES_DEFS_

69 #define _MACH_MACH_TYPES_DEFS_

72 #include <mach/std_types.defs>

74 type memory_object_offset_t = uint64_t;

75 type memory_object_size_t = uint64_t;

76 type memory_object_cluster_size_t = uint32_t;

77 type memory_object_fault_info_t = array[16] of integer_t;

79 #ifdef KERNEL_PRIVATE

81 /* Universal Page Lists - restricted to (in-kernel) pagers for now */

82 type upl_size_t = uint32_t;

83 type upl_offset_t = uint32_t;

84 type upl_page_info_t = struct[2] of integer_t;

85 type upl_page_info_array_t = array[*:256] of upl_page_info_t;

87 type upl_t = mach_port_t

88 intran: upl_t convert_port_to_upl(mach_port_t)

89 outtran: mach_port_t convert_upl_to_port(upl_t)

90 destructor: upl_deallocate(upl_t)

91 ;

93 #endif /* KERNEL_PRIVATE */

95 type mach_port_status_t = struct[10] of integer_t; /* obsolete */

96 type mach_port_info_ext_t = struct[17] of integer_t;

98 /* mach_port_info_t: can hold either a

99 * mach_port_status_t (9 ints) or a

100 * mach_port_limits_t (1 int) or a

101 * mach_port_info_ext_t (17 ints). If new flavors of

102 * mach_port_{get,set}_attributes are added, the size of

103 * this array may have to be increased. (See mach/port.h)

104 */

105 type mach_port_flavor_t = int;

106 type mach_port_info_t = array[*:17] of integer_t;

107

108 /*

109 * mach_msg_max_trailer_t: can hold

110 * mach_msg_trailer_type_t (1 int)

111 * mach_msg_trailer_size_t (1 int)

112 * mach_port_seqno_t (1 int)

113 * security_token_t (2 ints)

114 * audit_token_t (8 ints)

115 * mach_port_context_t (2 ints)

116 * msgh_ad (1 int)

117 * msg_labels_t (1 int)

118 */

119 type mach_msg_trailer_type_t = int;

120 type mach_msg_trailer_info_t = array[*:68] of char;

121

122 type mach_task_flavor_t = int;

123

124 type task_t = mach_port_t

125 #if KERNEL_SERVER

126 intran: task_t convert_port_to_task(mach_port_t)

127 outtran: mach_port_t convert_task_to_port(task_t)

128 destructor: task_deallocate(task_t)

129 #endif /* KERNEL_SERVER */

130 ;

131

132 type task_name_t = mach_port_t

133 #if KERNEL_SERVER

134 intran: task_name_t convert_port_to_task_name(mach_port_t)

135 outtran: mach_port_t convert_task_name_to_port(task_name_t)

136 destructor: task_name_deallocate(task_name_t)

137 #endif /* KERNEL_SERVER */

138 ;

139

140 type task_policy_set_t = mach_port_t

141 #if KERNEL_SERVER

142 intran: task_policy_set_t convert_port_to_task_policy_set(mach_port_t)

143 destructor: task_policy_set_deallocate(task_policy_set_t)

144 #endif /* KERNEL_SERVER */

145 ;

146

147 type task_policy_get_t = mach_port_t

148 #if KERNEL_SERVER

149 intran: task_policy_get_t convert_port_to_task_policy_get(mach_port_t)

150 destructor: task_policy_get_deallocate(task_policy_get_t)

151 #endif /* KERNEL_SERVER */

152 ;

153

154

155 type task_inspect_t = mach_port_t

156 #if KERNEL_SERVER

157 intran: task_inspect_t convert_port_to_task_inspect(mach_port_t)

158 outtran: mach_port_t convert_task_inspect_to_port(task_inspect_t)

159 destructor: task_inspect_deallocate(task_inspect_t)

160 #endif /* KERNEL_SERVER */

161 ;

162

163 type task_read_t = mach_port_t

164 #if KERNEL_SERVER

165 intran: task_read_t convert_port_to_task_read(mach_port_t)

166 outtran: mach_port_t convert_task_read_to_port(task_read_t)

167 destructor: task_read_deallocate(task_read_t)

168 #endif /* KERNEL_SERVER */

169 ;

170

171 type task_id_token_t = mach_port_t

172 #if KERNEL_SERVER

173 intran: task_id_token_t convert_port_to_task_id_token(mach_port_t)

174 outtran: mach_port_t convert_task_id_token_to_port(task_id_token_t)

175 destructor: task_id_token_release(task_id_token_t)

176 #endif /* KERNEL_SERVER */

177 ;

178

179 type thread_t = mach_port_t

180 #if KERNEL_SERVER

181 intran: thread_t convert_port_to_thread(mach_port_t)

182 outtran: mach_port_t convert_thread_to_port(thread_t)

183 destructor: thread_deallocate(thread_t)

184 #endif /* KERNEL_SERVER */

185 ;

186

187 type thread_inspect_t = mach_port_t

188 #if KERNEL_SERVER

189 intran: thread_inspect_t convert_port_to_thread_inspect(mach_port_t)

190 outtran: mach_port_t convert_thread_inspect_to_port(thread_inspect_t)

191 destructor: thread_inspect_deallocate(thread_inspect_t)

192 #endif /* KERNEL_SERVER */

193 ;

194

195 type thread_read_t = mach_port_t

196 #if KERNEL_SERVER

197 intran: thread_read_t convert_port_to_thread_read(mach_port_t)

198 outtran: mach_port_t convert_thread_read_to_port(thread_read_t)

199 destructor: thread_read_deallocate(thread_read_t)

200 #endif /* KERNEL_SERVER */

201 ;

202

203 type thread_act_t = mach_port_t

204 #if KERNEL_SERVER

205 intran: thread_act_t convert_port_to_thread(mach_port_t)

206 outtran: mach_port_t convert_thread_to_port(thread_act_t)

207 destructor: thread_deallocate(thread_act_t)

208 #endif /* KERNEL_SERVER */

209 ;

210

211 type thread_act_consume_ref_t = mach_port_move_send_t

212 cusertype: thread_act_t

213 #if KERNEL_SERVER

214 intran: thread_act_t convert_port_to_thread(mach_port_t)

215 destructor: thread_deallocate(thread_act_t)

216 #endif /* KERNEL_SERVER */

217 ;

218

219 type suid_cred_path_t = c_string[*:1024];

220 type suid_cred_uid_t = uint32_t;

221 type suid_cred_t = mach_port_t

222 #if KERNEL_SERVER

223 outtran: mach_port_t convert_suid_cred_to_port(suid_cred_t)

224 #endif /* KERNEL_SERVER */

225 ;

226

227

228 /* thread_state_t: This inline array can hold

229 * a machine-dependent amount of data, defined in

230 * mach/machine/???? (currently THREAD_STATE_MAX,

231 * in mach/thread_state.h)

232 */

233 #include <mach/machine/thread_state.h>

234 type thread_state_flavor_t = int;

235 type thread_state_t = array[*:THREAD_STATE_MAX] of natural_t;

236

237 type task_array_t = ^array[] of task_t;

238 type thread_array_t = ^array[] of thread_t;

239 type thread_act_array_t = ^array[] of thread_act_t;

240 type act_params_t = array[6] of int;

241

242 type vm_map_t = mach_port_t

243 #if KERNEL_SERVER

244 intran: vm_map_t convert_port_to_map(mach_port_t)

245 destructor: vm_map_deallocate(vm_map_t)

246 #endif /* KERNEL_SERVER */

247 ;

248

249 type vm_map_inspect_t = mach_port_t

250 #if KERNEL_SERVER

251 intran: vm_map_inspect_t convert_port_to_map_inspect(mach_port_t)

252 destructor: vm_map_inspect_deallocate(vm_map_inspect_t)

253 #endif /* KERNEL_SERVER */

254 ;

255

256 type vm_map_read_t = mach_port_t

257 #if KERNEL_SERVER

258 intran: vm_map_read_t convert_port_to_map_read(mach_port_t)

259 destructor: vm_map_read_deallocate(vm_map_read_t)

260 #endif /* KERNEL_SERVER */

261 ;

262

263 type vm_task_entry_t = mach_port_t

264 cusertype: vm_map_t

265 #if KERNEL_SERVER

266 intran: vm_map_t convert_port_entry_to_map(mach_port_t)

267 destructor: vm_map_deallocate(vm_map_t)

268 #endif /* KERNEL_SERVER */

269 ;

270

271 type ipc_space_t = mach_port_t

272 #if KERNEL_SERVER

273 intran: ipc_space_t convert_port_to_space(mach_port_t)

274 destructor: space_deallocate(ipc_space_t)

275 #endif /* KERNEL_SERVER */

276 ;

277

278 type ipc_space_read_t = mach_port_t

279 #if KERNEL_SERVER

280 intran: ipc_space_read_t convert_port_to_space_read(mach_port_t)

281 destructor: space_read_deallocate(ipc_space_read_t)

282 #endif /* KERNEL_SERVER */

283 ;

284

285 type ipc_space_inspect_t = mach_port_t

286 #if KERNEL_SERVER

287 intran: ipc_space_inspect_t convert_port_to_space_inspect(mach_port_t)

288 destructor: space_inspect_deallocate(ipc_space_inspect_t)

289 #endif /* KERNEL_SERVER */

290 ;

291

292 type arcade_register_t = mach_port_t

293 #if KERNEL_SERVER

294 intran: arcade_register_t convert_port_to_arcade_register(mach_port_t)

295 #endif /* KERNEL_SERVER */

296 ;

297

298 type vm_prot_t = int;

299 type vm_inherit_t = int;

300 type vm_purgable_t = int;

301 type xxx_vm_statistics_data_t = struct[13] of integer_t;

302 type vm_behavior_t = int;

303 type vm_statistics_data_t = struct[15] of integer_t;

304 type vm_machine_attribute_t = int;

305 type vm_machine_attribute_val_t = int;

306 type vm_sync_t = int;

307

308 /* thread_info_t: this inline array can hold any of:

309 * thread_basic_info_t (10 ints)

310 * policy_timeshare_info_t (5 ints)

311 * policy_fifo_info_t (4 ints)

312 * policy_rr_info_t (5 ints)

313 * thread_extended_info (12 ints + 64 chars)

314 * if other thread_info flavors are added, this

315 * definition may need to be changed. (See

316 * mach/thread_info.h and mach/policy.h) */

317 type thread_flavor_t = int;

318 type thread_info_t = array[*:32] of integer_t;

319

320 type thread_policy_flavor_t = natural_t;

321 type thread_policy_t = array[*:16] of integer_t;

322

323 /* task_info_t: this inline array can hold any of:

324 * task_basic_info_32_t (8 ints)

325 * task_basic_info_64_t (10 ints)

326 * task_events_info_t (8 ints)

327 * task_thread_times_info_t (4 ints)

328 * policy_timeshare_info_t (5 ints)

329 * policy_fifo_info_t (4 ints)

330 * policy_rr_info_t (5 ints)

331 * task security token (2 ints)

332 * task audit token (8 ints)

333 * dyld info (2 64-bit ints and 1 int)

334 * task_extmod_info_t (8 64-bit ints)

335 * task_basic_info_64_2_t

336 * mach_task_basic_info_t (12 ints)

337 * task_power_info_t (18 ints)

338 * task_vm_info_t (87 ints)

339 * If other task_info flavors are added, this

340 * definition may need to be changed. (See

341 * mach/task_info.h and mach/policy.h) */

342 type task_flavor_t = int;

343 type task_info_t = array[*:87] of integer_t;

344

345 type task_purgable_info_t = struct[68] of integer_t;

346

347 type task_policy_flavor_t = natural_t;

348 type task_policy_t = array[*:16] of integer_t;

349

350 type task_inspect_flavor_t = natural_t;

351 type task_inspect_info_t = array[*:4] of integer_t;

352

353 type task_exc_guard_behavior_t = uint32_t;

354

355 type mem_entry_name_port_t = mach_port_t

356 #if KERNEL_SERVER

357 intran: mem_entry_name_port_t null_conversion(mach_port_t)

358 outtran: mach_port_t null_conversion(mem_entry_name_port_t)

359 #endif /* KERNEL_SERVER */

360 ;

361

362 type mem_entry_name_port_move_send_t = mach_port_move_send_t

363 cusertype: mem_entry_name_port_t

364 #if KERNEL_SERVER

365 intran: mem_entry_name_port_t null_conversion(mach_port_t)

366 outtran: mach_port_t null_conversion(mem_entry_name_port_t)

367 #endif /* KERNEL_SERVER */

368 ;

369

370 type memory_object_default_t = mach_port_t

371 #if KERNEL_PRIVATE

372 intran: memory_object_default_t null_conversion(mach_port_t)

373 outtran: mach_port_t null_conversion(memory_object_default_t)

374 #endif /* KERNEL_PRIVATE */

375 ;

376

377 type memory_object_t = mach_port_t

378 #if KERNEL_PRIVATE

379 intran: memory_object_t convert_port_to_memory_object(mach_port_t)

380 outtran: mach_port_t convert_memory_object_to_port(memory_object_t)

381 #endif /* KERNEL_PRIVATE */

382 ;

383

384

385 type memory_object_control_t = mach_port_t

386 #if KERNEL_PRIVATE

387 intran: memory_object_control_t convert_port_to_mo_control(mach_port_t)

388 outtran: mach_port_t convert_mo_control_to_port(memory_object_control_t)

389 destructor: memory_object_control_deallocate(memory_object_control_t)

390 #endif /* KERNEL_PRIVATE */

391 ;

392

393 type memory_object_name_t = mach_port_t

394 ctype: mach_port_t

395 ;

396

397

398 type memory_object_copy_strategy_t = int;

399 type memory_object_return_t = int;

400

401 type machine_info_data_t = struct[5] of integer_t;

402 type machine_slot_data_t = struct[8] of integer_t;

403

404 type host_t = mach_port_t

405 #if KERNEL_SERVER

406 intran: host_t convert_port_to_host(mach_port_t)

407 outtran: mach_port_t convert_host_to_port(host_t)

408 #endif /* KERNEL_SERVER */

409 ;

410

411 type host_priv_t = mach_port_t

412 #if KERNEL_SERVER

413 intran: host_priv_t convert_port_to_host_priv(mach_port_t)

414 #endif /* KERNEL_SERVER */

415 ;

416

417 type host_security_t = mach_port_t

418 #if KERNEL_SERVER

419 intran: host_security_t convert_port_to_host_security(mach_port_t)

420 #endif /* KERNEL_SERVER */

421 ;

422

423 /*

424 * host_info_t: variable-sized inline array that can contain:

425 *

426 * host_basic_info_old_t (5 ints)

427 * host_basic_info_t (12 ints)

428 * host_sched_info_t (2 ints)

429 * kernel_resource_sizes_t (5 ints)

430 * host_load_info_t (6 ints)

431 * vm_statistics32_t (15 ints)

432 * host_purgable_info_t (68 ints)

433 * host_expired_task_info uses a task_power_info (18 ints)

434 *

435 * If other host_info flavors are added, this definition may

436 * need to be changed. (See mach/{host_info,vm_statistics}.h)

437 */

438 type host_flavor_t = int;

439 type host_info_t = array[*:68] of integer_t;

440 /*

441 * host_info64_t: variable-sized inline array that can contain:

442 *

443 * vm_statistics_t (6 ints and 9 longs)

444 * vm_extmod_statistics_t (6 64-bit ints)

445 */

446 type host_info64_t = array[*:256] of integer_t;

447

448 type processor_t = mach_port_t

449 #if KERNEL_SERVER

450 intran: processor_t convert_port_to_processor(mach_port_t)

451 outtran: mach_port_t convert_processor_to_port(processor_t)

452 #endif /* KERNEL_SERVER */

453 ;

454

455 type processor_array_t = ^array[] of processor_t;

456

457 /*

458 * processor_info_t: variable-sized inline array that can

459 * contain:

460 *

461 * - processor_basic_info_t: (5 ints)

462 * - processor_cpu_load_info_t: (4 ints)

463 * - processor_machine_info_t: (12 ints)

464 * - processor_cpu_stat_t: (10 ints)

465 * - processor_cpu_stat64_t: (20 ints)

466 *

467 * If other processor_info flavors are added, this definition

468 * may need to be changed.

469 *

470 * See mach/processor_info.h and mach/arm/processor_info.h.

471 */

472

473 type processor_flavor_t = int;

474 type processor_info_t = array[*:20] of integer_t;

475 type processor_info_array_t = ^array[] of integer_t;

476

477 type processor_set_t = mach_port_t

478 #if KERNEL_SERVER

479 intran: processor_set_t convert_port_to_pset(mach_port_t)

480 outtran: mach_port_t convert_pset_to_port(processor_set_t)

481 destructor: pset_deallocate(processor_set_t)

482 #endif /* KERNEL_SERVER */

483 ;

484

485 type processor_set_array_t = ^array[] of processor_set_t;

486

487 type processor_set_name_t = mach_port_t

488 #if KERNEL_SERVER

489 intran: processor_set_name_t convert_port_to_pset_name(mach_port_t)

490 outtran: mach_port_t convert_pset_name_to_port(processor_set_name_t)

491 destructor: pset_deallocate(processor_set_name_t)

492 #endif /* KERNEL_SERVER */

493 ;

494

495 type processor_set_name_array_t = ^array[] of processor_set_name_t;

496

497 /* processor_set_info_t: variable-size inline array

498 * that can hold:

499 * processor_set_basic_info (5 ints)

500 * processor_set_load_info (4 ints)

501 * policy_timeshare_base_t (1 int)

502 * policy_fifo_base_t (1 int)

503 * policy_rr_base_t (1 int)

504 * policy_timeshare_base_t (1 int)

505 * policy_fifo_base_t (1 int)

506 * policy_rr_base_t (1 int)

507 * policy_t (1 int)

508 * If other flavors are added, this definition may

509 * need to be changed. (see mach/processor.h) */

510 type processor_set_flavor_t = int;

511 type processor_set_info_t = array[*:5] of integer_t;

512

513 type bootstrap_t = mach_port_t;

514

515 type kernel_version_t = c_string[*:512];

516 type kernel_boot_info_t = c_string[*:4096];

517

518 type time_value_t = struct[2] of integer_t;

519

520 type mach_port_qos_t = struct[2] of integer_t;

521

522 type mach_port_options_t = struct[3] of uint64_t;

523 type mach_port_options_ptr_t = ^ mach_port_options_t;

524

525 type emulation_vector_t = ^array[] of vm_offset_t;

526

527 type inline_existence_map_t = array[*:512] of char;

528

529 type policy_t = int;

530 /* policy_info_t: variable-size inline array. Can hold:

531 * policy_timeshare_info_t (5 ints)

532 * policy_fifo_info_t (4 ints)

533 * policy_rr_info_t (5 ints) */

534 type policy_base_t = array[*:5] of integer_t;

535 type policy_info_t = array[*:2] of integer_t;

536 type policy_limit_t = array[*:1] of integer_t;

537

538 type ledger_t = mach_port_t

539 #if KERNEL_SERVER

540 intran: ledger_t convert_port_to_ledger(mach_port_t)

541 outtran: mach_port_t convert_ledger_to_port(ledger_t)

542 #endif /* KERNEL_SERVER */

543 ;

544

545 type ledger_array_t = ^array[] of ledger_t;

546 type ledger_item_t = integer_t;

547 /* DEPRECATED */

548

549 type ledger_amount_t = int64_t;

550

551 type security_token_t = struct[2] of uint32_t;

552 type audit_token_t = struct[8] of uint32_t;

553

554 type msg_labels_t = mach_port_t;

555

556 /* memory_object_info_t: variable-size inline array:

557 * memory_object_attr_info_t (5 ints)

558 * XXX actually it's 6 ints temporarily (object_ready!)

559 * memory_object_behave_info_t (4 ints)

560 * memory_object_perf_info_t (2 ints)

561 * old_memory_object_attr_info_t (3 ints)

562 * If other flavors are added, this definition may

563 * need to be changed. (see mach/memory_object.h) */

564 type memory_object_flavor_t = int;

565 type memory_object_info_t = array[*:6] of int;

566

567 /* vm_region_info_t: variable-size inline array that can hold:

568 * vm_region_basic_info_t (8 ints)

569 * If other flavors are added, this definition may

570 * need to be changed. (see mach/vm_region.h) */

571 type vm_region_flavor_t = int;

572 type vm_region_info_t = array[*:10] of int;

573 type vm_region_recurse_info_t = array[*:19] of int;

574

575 type vm_page_info_flavor_t = int;

576 type vm_page_info_t = array[*:32] of int;

577

578 type mach_vm_read_entry_t = array[512] of mach_vm_offset_t;

579 type vm_read_entry_t = array[512] of vm_offset_t;

580 #ifdef VM32_SUPPORT

581 type vm32_read_entry_t = array[512] of vm32_offset_t;

582 #endif

583

584 type exception_mask_t = int;

585 type exception_behavior_t = int;

586

587 type exception_handler_t = mach_port_t;

588

589 type exception_handler_info_t = struct[2] of natural_t;

590

591 type exception_handler_array_t =

592 array[*:32] of exception_handler_t;

593

594 type exception_handler_info_array_t =

595 array[*:32] of exception_handler_info_t;

596

597 type exception_behavior_array_t =

598 array[*:32] of exception_behavior_t;

599

600 type exception_flavor_array_t =

601 array[*:32] of thread_state_flavor_t;

602

603 type exception_mask_array_t =

604 array[*:32] of exception_mask_t;

605

606 type semaphore_t = mach_port_t

607 #if KERNEL_SERVER

608 intran: semaphore_t convert_port_to_semaphore(mach_port_t)

609 outtran: mach_port_t convert_semaphore_to_port(semaphore_t)

610 destructor: semaphore_dereference(semaphore_t)

611 #endif /* KERNEL_SERVER */

612 ;

613

614 type semaphore_consume_ref_t = mach_port_move_send_t

615 cusertype: semaphore_t

616 #if KERNEL_SERVER

617 intran: semaphore_t convert_port_to_semaphore(mach_port_t)

618 outtran: mach_port_t convert_semaphore_to_port(semaphore_t)

619 #endif /* KERNEL_SERVER */

620 ;

621

622 #ifndef _MACH_MACH_EVENTLINK_TYPE_DEFS

623 #define _MACH_MACH_EVENTLINK_TYPE_DEFS

624

625 type eventlink_t = mach_port_t

626 ctype: mach_port_t

627 #if KERNEL_SERVER

628 intran: ipc_eventlink_t convert_port_to_eventlink(mach_port_t)

629 destructor: ipc_eventlink_deallocate(ipc_eventlink_t)

630 #endif /* KERNEL_SERVER */

631 ;

632

633 type eventlink_consume_ref_t = mach_port_move_send_t

634 ctype: mach_port_t

635 #if KERNEL_SERVER

636 intran: ipc_eventlink_t convert_port_to_eventlink(mach_port_t)

637 destructor: ipc_eventlink_deallocate(ipc_eventlink_t)

638 #endif /* KERNEL_SERVER */

639 ;

640

641 type eventlink_port_pair_t = array[2] of mach_port_t;

642 type mach_eventlink_create_option_t = uint32_t;

643 type mach_eventlink_associate_option_t = uint32_t;

644 type mach_eventlink_disassociate_option_t = uint32_t;

645 type mach_eventlink_signal_wait_option_t = uint32_t;

646

647 #endif /* _MACH_MACH_EVENTLINK_TYPE_DEFS */

648

649 type lock_set_t = mach_port_t

650 #if KERNEL_SERVER

651 intran: lock_set_t convert_port_to_lock_set(mach_port_t)

652 outtran: mach_port_t convert_lock_set_to_port(lock_set_t)

653 destructor: lock_set_dereference(lock_set_t)

654 #endif /* KERNEL_SERVER */

655 ;

656

657 type task_suspension_token_t = mach_port_move_send_once_t

658 #if KERNEL_SERVER

659 intran: task_suspension_token_t convert_port_to_task_suspension_token(mach_port_t)

660 outtran: mach_port_t convert_task_suspension_token_to_port(task_suspension_token_t)

661 #endif /* KERNEL_SERVER */

662 ;

663

664 type vfs_path_t = c_string[4096];

665 type nspace_path_t = c_string[1024]; /* 1024 == PATH_MAX */

666

667 /* public voucher types */

668

669 /* Mach voucher object */

670 type mach_voucher_t = mach_port_t;

671 type mach_voucher_name_t = mach_port_name_t;

672

673 type mach_voucher_attr_manager_t = mach_port_t;

674 type mach_voucher_attr_control_t = mach_port_t;

675

676 /* IPC voucher internal object */

677 type ipc_voucher_t = mach_port_t

678 #if KERNEL_SERVER

679 intran: ipc_voucher_t convert_port_to_voucher(mach_port_t)

680 outtran: mach_port_t convert_voucher_to_port(ipc_voucher_t)

681 destructor: ipc_voucher_release(ipc_voucher_t)

682 #endif /* KERNEL_SERVER */

683 ;

684

685 /* IPC voucher attribute control internal object */

686 type ipc_voucher_attr_control_t = mach_port_t

687 #if KERNEL_SERVER

688 intran: ipc_voucher_attr_control_t convert_port_to_voucher_attr_control(mach_port_t)

689 outtran: mach_port_t convert_voucher_attr_control_to_port(ipc_voucher_attr_control_t)

690 destructor: ipc_voucher_attr_control_release(ipc_voucher_attr_control_t)

691 #endif /* KERNEL_SERVER */

692 ;

693

694 type mach_voucher_attr_key_t = uint32_t;

695

696 type mach_voucher_attr_command_t = uint32_t;

697 type mach_voucher_attr_recipe_command_t = uint32_t;

698

699 type mach_voucher_attr_content_size_t = uint32_t;

700 type mach_voucher_attr_content_t = array[*:4096] of uint8_t;

701 type mach_voucher_attr_content_array_t = array[*:5120] of uint8_t;

702

703 type mach_voucher_attr_raw_recipe_size_t = uint32_t;

704 type mach_voucher_attr_raw_recipe_t = array[*:4096] of uint8_t;

705 type mach_voucher_attr_raw_recipe_array_t = array[*:5120] of uint8_t;

706

707 type mach_voucher_selector_t = uint32_t;

708

709 type mach_voucher_attr_value_handle_t = uint64_t;

710 type mach_voucher_attr_value_handle_array_t = array[*:4] of mach_voucher_attr_value_handle_t;

711 type mach_voucher_attr_value_reference_t = uint32_t;

712

713 /* kernel module loader */

714 type kmod_t = int;

715 type kmod_control_flavor_t = int;

716

717 type kmod_args_t = ^array[] of MACH_MSG_TYPE_BYTE

718 ctype: kmod_args_t;

719

720 type io_master_t = mach_port_t;

721 type UNDServerRef = mach_port_t;

722

723 /* These must be kept in sync with definitions in osfmk/mach/dyld_kernel.h */

724 type dyld_kernel_image_info_t = struct[40] of MACH_MSG_TYPE_BYTE;

725 type dyld_kernel_image_info_array_t = ^array[] of dyld_kernel_image_info_t;

726 type dyld_kernel_process_info_t = struct[64] of MACH_MSG_TYPE_BYTE;

727

728 #if KERNEL_SERVER

729 #ifdef MACH_KERNEL_PRIVATE

730 simport <ipc/ipc_voucher.h>; /* for voucher conversions */

731 simport <kern/ipc_kobject.h>; /* for null conversion */

732 simport <kern/ipc_tt.h>; /* for task/thread conversion */

733 simport <kern/ipc_host.h>; /* for host/processor/pset conversions */

734 simport <kern/ipc_sync.h>; /* for lock_set and semaphore conversions */

735 simport <kern/ledger.h>; /* for ledger conversions */

736 simport <kern/processor.h>; /* for processor conversions */

737 simport <kern/sync_lock.h>; /* for lock-set conversions */

738 simport <kern/sync_sema.h>; /* for semaphore conversions */

739 simport <ipc/ipc_eventlink.h>; /* for eventlink conversions */

740 simport <vm/memory_object.h>; /* for memory object type conversions */

741 simport <vm/vm_map.h>; /* for vm_map conversions */

742 #if CONFIG_ARCADE

743 simport <kern/arcade.h>; /* for arcade_register conversions */

744 #endif

745 #endif /* MACH_KERNEL_PRIVATE */

746

747 simport <kern/ipc_mig.h>; /* pick up kernel-specific MIG things */

748

749 simport <kern/suid_cred.h>;

750 simport <kern/task_ident.h>; /* for task_id_token conversions */

751 #endif /* KERNEL_SERVER */

752

753 import <mach/mig.h>;

754 import <mach/mach_types.h>;

755

756 #endif /* _MACH_MACH_TYPES_DEFS_ */

757

758 /* vim: set ft=c : */