1 /*
2 * IDENTIFICATION:
3 * stub generated Thu Jun 11 18:17:45 2015
4 * with a MiG generated Thu Jun 11 16:16:11 PDT 2015 by kmacy@serenity
5 * OPTIONS:
6 * KernelServer
7 */
8
9 /* Module vm_map */
10
11 #define __MIG_check__Request__vm_map_subsystem__ 1
12
13 #include <sys/cdefs.h>
14 #include <sys/types.h>
15 #ifdef _KERNEL
16 #include <sys/mach/ndr.h>
17 #include <sys/mach/kern_return.h>
18 #include <sys/mach/notify.h>
19 #include <sys/mach/mach_types.h>
20 #include <sys/mach/message.h>
21 #include <sys/mach/mig_errors.h>
22 #else /* !_KERNEL */
23 #include <string.h>
24 #include <mach/ndr.h>
25 #include <mach/boolean.h>
26 #include <mach/kern_return.h>
27 #include <mach/notify.h>
28 #include <mach/mach_types.h>
29 #include <mach/message.h>
30 #include <mach/mig_errors.h>
31 #endif /*_KERNEL */
32
33 #include <sys/mach/std_types.h>
34 #include <sys/mach/mig.h>
35 #include <sys/mach/ipc_sync.h>
36 #include <sys/mach/ipc/ipc_voucher.h>
37 #include <sys/mach/ipc_host.h>
38 #include <sys/mach/ipc_tt.h>
39 #include <sys/mach/ipc_mig.h>
40 #include <sys/mach/mig.h>
41 #include <sys/mach/mach_types.h>
42 #include <sys/mach_debug/mach_debug_types.h>
43 #include <sys/mach/vm_types.h>
44
45 #ifndef mig_internal
46 #define mig_internal static __inline__
47 #endif /* mig_internal */
48
49 #ifndef mig_external
50 #define mig_external
51 #endif /* mig_external */
52
53 #if !defined(__MigTypeCheck) && defined(TypeCheck)
54 #define __MigTypeCheck TypeCheck /* Legacy setting */
55 #endif /* !defined(__MigTypeCheck) */
56
57 #if !defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
58 #define __MigKernelSpecificCode _MIG_KERNEL_SPECIFIC_CODE_ /* Legacy setting */
59 #endif /* !defined(__MigKernelSpecificCode) */
60
61 #ifndef LimitCheck
62 #define LimitCheck 0
63 #endif /* LimitCheck */
64
65 #ifndef min
66 #define min(a,b) ( ((a) < (b))? (a): (b) )
67 #endif /* min */
68
69 #if !defined(_WALIGN_)
70 #define _WALIGN_(x) (((x) + 7) & ~7)
71 #endif /* !defined(_WALIGN_) */
72
73 #if !defined(_WALIGNSZ_)
74 #define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
75 #endif /* !defined(_WALIGNSZ_) */
76
77 #ifndef UseStaticTemplates
78 #define UseStaticTemplates 1
79 #endif /* UseStaticTemplates */
80
81 #define _WALIGN_(x) (((x) + 7) & ~7)
82 #define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
83 #ifndef __DeclareRcvRpc
84 #define __DeclareRcvRpc(_NUM_, _NAME_)
85 #endif /* __DeclareRcvRpc */
86
87 #ifndef __BeforeRcvRpc
88 #define __BeforeRcvRpc(_NUM_, _NAME_)
89 #endif /* __BeforeRcvRpc */
90
91 #ifndef __AfterRcvRpc
92 #define __AfterRcvRpc(_NUM_, _NAME_)
93 #endif /* __AfterRcvRpc */
94
95 #ifndef __DeclareRcvSimple
96 #define __DeclareRcvSimple(_NUM_, _NAME_)
97 #endif /* __DeclareRcvSimple */
98
99 #ifndef __BeforeRcvSimple
100 #define __BeforeRcvSimple(_NUM_, _NAME_)
101 #endif /* __BeforeRcvSimple */
102
103 #ifndef __AfterRcvSimple
104 #define __AfterRcvSimple(_NUM_, _NAME_)
105 #endif /* __AfterRcvSimple */
106
107 #define novalue void
108 #if __MigKernelSpecificCode
109 #define msgh_request_port msgh_remote_port
110 #define MACH_MSGH_BITS_REQUEST(bits) MACH_MSGH_BITS_REMOTE(bits)
111 #define msgh_reply_port msgh_local_port
112 #define MACH_MSGH_BITS_REPLY(bits) MACH_MSGH_BITS_LOCAL(bits)
113 #else
114 #define msgh_request_port msgh_local_port
115 #define MACH_MSGH_BITS_REQUEST(bits) MACH_MSGH_BITS_LOCAL(bits)
116 #define msgh_reply_port msgh_remote_port
117 #define MACH_MSGH_BITS_REPLY(bits) MACH_MSGH_BITS_REMOTE(bits)
118 #endif /* __MigKernelSpecificCode */
119
120 #define MIG_RETURN_ERROR(X, code) {\
121 ((mig_reply_error_t *)X)->RetCode = code;\
122 ((mig_reply_error_t *)X)->NDR = NDR_record;\
123 return;\
124 }
125
126 /* typedefs for all requests */
127
128 #ifndef __Request__vm_map_subsystem__defined
129 #define __Request__vm_map_subsystem__defined
130
131 #ifdef __MigPackStructs
132 #pragma pack(4)
133 #endif
134 typedef struct {
135 mach_msg_header_t Head;
136 /* start of the kernel processed data */
137 mach_msg_body_t msgh_body;
138 /* end of the kernel processed data */
139 NDR_record_t NDR;
140 vm_address_t address;
141 vm_region_flavor_t flavor;
142 mach_msg_type_number_t infoCnt;
143 } __Request__vm_region_t;
144 #ifdef __MigPackStructs
145 #pragma pack()
146 #endif
147
148 #ifdef __MigPackStructs
149 #pragma pack(4)
150 #endif
151 typedef struct {
152 mach_msg_header_t Head;
153 /* start of the kernel processed data */
154 mach_msg_body_t msgh_body;
155 /* end of the kernel processed data */
156 NDR_record_t NDR;
157 vm_address_t address;
158 vm_size_t size;
159 int flags;
160 } __Request__vm_allocate_t;
161 #ifdef __MigPackStructs
162 #pragma pack()
163 #endif
164
165 #ifdef __MigPackStructs
166 #pragma pack(4)
167 #endif
168 typedef struct {
169 mach_msg_header_t Head;
170 /* start of the kernel processed data */
171 mach_msg_body_t msgh_body;
172 /* end of the kernel processed data */
173 NDR_record_t NDR;
174 vm_address_t address;
175 vm_size_t size;
176 } __Request__vm_deallocate_t;
177 #ifdef __MigPackStructs
178 #pragma pack()
179 #endif
180
181 #ifdef __MigPackStructs
182 #pragma pack(4)
183 #endif
184 typedef struct {
185 mach_msg_header_t Head;
186 /* start of the kernel processed data */
187 mach_msg_body_t msgh_body;
188 /* end of the kernel processed data */
189 NDR_record_t NDR;
190 vm_address_t address;
191 vm_size_t size;
192 boolean_t set_maximum;
193 vm_prot_t new_protection;
194 } __Request__vm_protect_t;
195 #ifdef __MigPackStructs
196 #pragma pack()
197 #endif
198
199 #ifdef __MigPackStructs
200 #pragma pack(4)
201 #endif
202 typedef struct {
203 mach_msg_header_t Head;
204 /* start of the kernel processed data */
205 mach_msg_body_t msgh_body;
206 /* end of the kernel processed data */
207 NDR_record_t NDR;
208 vm_address_t address;
209 vm_size_t size;
210 vm_inherit_t new_inheritance;
211 } __Request__vm_inherit_t;
212 #ifdef __MigPackStructs
213 #pragma pack()
214 #endif
215
216 #ifdef __MigPackStructs
217 #pragma pack(4)
218 #endif
219 typedef struct {
220 mach_msg_header_t Head;
221 /* start of the kernel processed data */
222 mach_msg_body_t msgh_body;
223 /* end of the kernel processed data */
224 NDR_record_t NDR;
225 vm_address_t address;
226 vm_size_t size;
227 } __Request__vm_read_t;
228 #ifdef __MigPackStructs
229 #pragma pack()
230 #endif
231
232 #ifdef __MigPackStructs
233 #pragma pack(4)
234 #endif
235 typedef struct {
236 mach_msg_header_t Head;
237 /* start of the kernel processed data */
238 mach_msg_body_t msgh_body;
239 /* end of the kernel processed data */
240 NDR_record_t NDR;
241 vm_read_entry_t data_list;
242 natural_t count;
243 } __Request__vm_read_list_t;
244 #ifdef __MigPackStructs
245 #pragma pack()
246 #endif
247
248 #ifdef __MigPackStructs
249 #pragma pack(4)
250 #endif
251 typedef struct {
252 mach_msg_header_t Head;
253 /* start of the kernel processed data */
254 mach_msg_body_t msgh_body;
255 mach_msg_ool_descriptor_t data;
256 /* end of the kernel processed data */
257 NDR_record_t NDR;
258 vm_address_t address;
259 mach_msg_type_number_t dataCnt;
260 } __Request__vm_write_t;
261 #ifdef __MigPackStructs
262 #pragma pack()
263 #endif
264
265 #ifdef __MigPackStructs
266 #pragma pack(4)
267 #endif
268 typedef struct {
269 mach_msg_header_t Head;
270 /* start of the kernel processed data */
271 mach_msg_body_t msgh_body;
272 /* end of the kernel processed data */
273 NDR_record_t NDR;
274 vm_address_t source_address;
275 vm_size_t size;
276 vm_address_t dest_address;
277 } __Request__vm_copy_t;
278 #ifdef __MigPackStructs
279 #pragma pack()
280 #endif
281
282 #ifdef __MigPackStructs
283 #pragma pack(4)
284 #endif
285 typedef struct {
286 mach_msg_header_t Head;
287 /* start of the kernel processed data */
288 mach_msg_body_t msgh_body;
289 /* end of the kernel processed data */
290 NDR_record_t NDR;
291 vm_address_t address;
292 vm_size_t size;
293 vm_address_t data;
294 } __Request__vm_read_overwrite_t;
295 #ifdef __MigPackStructs
296 #pragma pack()
297 #endif
298
299 #ifdef __MigPackStructs
300 #pragma pack(4)
301 #endif
302 typedef struct {
303 mach_msg_header_t Head;
304 /* start of the kernel processed data */
305 mach_msg_body_t msgh_body;
306 /* end of the kernel processed data */
307 NDR_record_t NDR;
308 vm_address_t address;
309 vm_size_t size;
310 vm_sync_t sync_flags;
311 } __Request__vm_msync_t;
312 #ifdef __MigPackStructs
313 #pragma pack()
314 #endif
315
316 #ifdef __MigPackStructs
317 #pragma pack(4)
318 #endif
319 typedef struct {
320 mach_msg_header_t Head;
321 /* start of the kernel processed data */
322 mach_msg_body_t msgh_body;
323 /* end of the kernel processed data */
324 NDR_record_t NDR;
325 vm_address_t address;
326 vm_size_t size;
327 vm_behavior_t new_behavior;
328 } __Request__vm_behavior_set_t;
329 #ifdef __MigPackStructs
330 #pragma pack()
331 #endif
332
333 #ifdef __MigPackStructs
334 #pragma pack(4)
335 #endif
336 typedef struct {
337 mach_msg_header_t Head;
338 /* start of the kernel processed data */
339 mach_msg_body_t msgh_body;
340 /* end of the kernel processed data */
341 NDR_record_t NDR;
342 vm_address_t address;
343 vm_size_t size;
344 vm_machine_attribute_t attribute;
345 vm_machine_attribute_val_t value;
346 } __Request__vm_machine_attribute_t;
347 #ifdef __MigPackStructs
348 #pragma pack()
349 #endif
350
351 #ifdef __MigPackStructs
352 #pragma pack(4)
353 #endif
354 typedef struct {
355 mach_msg_header_t Head;
356 /* start of the kernel processed data */
357 mach_msg_body_t msgh_body;
358 mach_msg_port_descriptor_t src_task;
359 /* end of the kernel processed data */
360 NDR_record_t NDR;
361 vm_address_t target_address;
362 vm_size_t size;
363 vm_address_t mask;
364 int flags;
365 vm_address_t src_address;
366 boolean_t copy;
367 vm_inherit_t inheritance;
368 } __Request__vm_remap_t;
369 #ifdef __MigPackStructs
370 #pragma pack()
371 #endif
372
373 #ifdef __MigPackStructs
374 #pragma pack(4)
375 #endif
376 typedef struct {
377 mach_msg_header_t Head;
378 /* start of the kernel processed data */
379 mach_msg_body_t msgh_body;
380 /* end of the kernel processed data */
381 NDR_record_t NDR;
382 boolean_t must_wire;
383 } __Request__task_wire_t;
384 #ifdef __MigPackStructs
385 #pragma pack()
386 #endif
387
388 #ifdef __MigPackStructs
389 #pragma pack(4)
390 #endif
391 typedef struct {
392 mach_msg_header_t Head;
393 /* start of the kernel processed data */
394 mach_msg_body_t msgh_body;
395 mach_msg_port_descriptor_t parent_entry;
396 /* end of the kernel processed data */
397 NDR_record_t NDR;
398 vm_size_t size;
399 vm_offset_t offset;
400 vm_prot_t permission;
401 } __Request__mach_make_memory_entry_t;
402 #ifdef __MigPackStructs
403 #pragma pack()
404 #endif
405
406 #ifdef __MigPackStructs
407 #pragma pack(4)
408 #endif
409 typedef struct {
410 mach_msg_header_t Head;
411 /* start of the kernel processed data */
412 mach_msg_body_t msgh_body;
413 /* end of the kernel processed data */
414 NDR_record_t NDR;
415 vm_offset_t offset;
416 } __Request__vm_map_page_query_t;
417 #ifdef __MigPackStructs
418 #pragma pack()
419 #endif
420
421 #ifdef __MigPackStructs
422 #pragma pack(4)
423 #endif
424 typedef struct {
425 mach_msg_header_t Head;
426 /* start of the kernel processed data */
427 mach_msg_body_t msgh_body;
428 /* end of the kernel processed data */
429 NDR_record_t NDR;
430 vm_address_t address;
431 } __Request__mach_vm_region_info_t;
432 #ifdef __MigPackStructs
433 #pragma pack()
434 #endif
435
436 #ifdef __MigPackStructs
437 #pragma pack(4)
438 #endif
439 typedef struct {
440 mach_msg_header_t Head;
441 /* start of the kernel processed data */
442 mach_msg_body_t msgh_body;
443 /* end of the kernel processed data */
444 } __Request__vm_mapped_pages_info_t;
445 #ifdef __MigPackStructs
446 #pragma pack()
447 #endif
448
449 #ifdef __MigPackStructs
450 #pragma pack(4)
451 #endif
452 typedef struct {
453 mach_msg_header_t Head;
454 /* start of the kernel processed data */
455 mach_msg_body_t msgh_body;
456 /* end of the kernel processed data */
457 NDR_record_t NDR;
458 vm_address_t address;
459 natural_t nesting_depth;
460 mach_msg_type_number_t infoCnt;
461 } __Request__vm_region_recurse_t;
462 #ifdef __MigPackStructs
463 #pragma pack()
464 #endif
465
466 #ifdef __MigPackStructs
467 #pragma pack(4)
468 #endif
469 typedef struct {
470 mach_msg_header_t Head;
471 /* start of the kernel processed data */
472 mach_msg_body_t msgh_body;
473 /* end of the kernel processed data */
474 NDR_record_t NDR;
475 vm_address_t address;
476 natural_t nesting_depth;
477 mach_msg_type_number_t infoCnt;
478 } __Request__vm_region_recurse_64_t;
479 #ifdef __MigPackStructs
480 #pragma pack()
481 #endif
482
483 #ifdef __MigPackStructs
484 #pragma pack(4)
485 #endif
486 typedef struct {
487 mach_msg_header_t Head;
488 /* start of the kernel processed data */
489 mach_msg_body_t msgh_body;
490 /* end of the kernel processed data */
491 NDR_record_t NDR;
492 vm_address_t address;
493 } __Request__mach_vm_region_info_64_t;
494 #ifdef __MigPackStructs
495 #pragma pack()
496 #endif
497
498 #ifdef __MigPackStructs
499 #pragma pack(4)
500 #endif
501 typedef struct {
502 mach_msg_header_t Head;
503 /* start of the kernel processed data */
504 mach_msg_body_t msgh_body;
505 /* end of the kernel processed data */
506 NDR_record_t NDR;
507 vm_address_t address;
508 vm_region_flavor_t flavor;
509 mach_msg_type_number_t infoCnt;
510 } __Request__vm_region_64_t;
511 #ifdef __MigPackStructs
512 #pragma pack()
513 #endif
514
515 #ifdef __MigPackStructs
516 #pragma pack(4)
517 #endif
518 typedef struct {
519 mach_msg_header_t Head;
520 /* start of the kernel processed data */
521 mach_msg_body_t msgh_body;
522 mach_msg_port_descriptor_t parent_entry;
523 /* end of the kernel processed data */
524 NDR_record_t NDR;
525 memory_object_size_t size;
526 memory_object_offset_t offset;
527 vm_prot_t permission;
528 } __Request__mach_make_memory_entry_64_t;
529 #ifdef __MigPackStructs
530 #pragma pack()
531 #endif
532
533 #ifdef __MigPackStructs
534 #pragma pack(4)
535 #endif
536 typedef struct {
537 mach_msg_header_t Head;
538 /* start of the kernel processed data */
539 mach_msg_body_t msgh_body;
540 /* end of the kernel processed data */
541 NDR_record_t NDR;
542 vm_address_t address;
543 vm_purgable_t control;
544 int state;
545 } __Request__vm_purgable_control_t;
546 #ifdef __MigPackStructs
547 #pragma pack()
548 #endif
549 #endif /* !__Request__vm_map_subsystem__defined */
550
551 /* typedefs for all replies */
552
553 #ifndef __Reply__vm_map_subsystem__defined
554 #define __Reply__vm_map_subsystem__defined
555
556 #ifdef __MigPackStructs
557 #pragma pack(4)
558 #endif
559 typedef struct {
560 mach_msg_header_t Head;
561 /* start of the kernel processed data */
562 mach_msg_body_t msgh_body;
563 mach_msg_port_descriptor_t object_name;
564 /* end of the kernel processed data */
565 NDR_record_t NDR;
566 vm_address_t address;
567 vm_size_t size;
568 mach_msg_type_number_t infoCnt;
569 int info[10];
570 } __Reply__vm_region_t;
571 #ifdef __MigPackStructs
572 #pragma pack()
573 #endif
574
575 #ifdef __MigPackStructs
576 #pragma pack(4)
577 #endif
578 typedef struct {
579 mach_msg_header_t Head;
580 NDR_record_t NDR;
581 kern_return_t RetCode;
582 vm_address_t address;
583 } __Reply__vm_allocate_t;
584 #ifdef __MigPackStructs
585 #pragma pack()
586 #endif
587
588 #ifdef __MigPackStructs
589 #pragma pack(4)
590 #endif
591 typedef struct {
592 mach_msg_header_t Head;
593 NDR_record_t NDR;
594 kern_return_t RetCode;
595 } __Reply__vm_deallocate_t;
596 #ifdef __MigPackStructs
597 #pragma pack()
598 #endif
599
600 #ifdef __MigPackStructs
601 #pragma pack(4)
602 #endif
603 typedef struct {
604 mach_msg_header_t Head;
605 NDR_record_t NDR;
606 kern_return_t RetCode;
607 } __Reply__vm_protect_t;
608 #ifdef __MigPackStructs
609 #pragma pack()
610 #endif
611
612 #ifdef __MigPackStructs
613 #pragma pack(4)
614 #endif
615 typedef struct {
616 mach_msg_header_t Head;
617 NDR_record_t NDR;
618 kern_return_t RetCode;
619 } __Reply__vm_inherit_t;
620 #ifdef __MigPackStructs
621 #pragma pack()
622 #endif
623
624 #ifdef __MigPackStructs
625 #pragma pack(4)
626 #endif
627 typedef struct {
628 mach_msg_header_t Head;
629 /* start of the kernel processed data */
630 mach_msg_body_t msgh_body;
631 mach_msg_ool_descriptor_t data;
632 /* end of the kernel processed data */
633 NDR_record_t NDR;
634 mach_msg_type_number_t dataCnt;
635 } __Reply__vm_read_t;
636 #ifdef __MigPackStructs
637 #pragma pack()
638 #endif
639
640 #ifdef __MigPackStructs
641 #pragma pack(4)
642 #endif
643 typedef struct {
644 mach_msg_header_t Head;
645 NDR_record_t NDR;
646 kern_return_t RetCode;
647 vm_read_entry_t data_list;
648 } __Reply__vm_read_list_t;
649 #ifdef __MigPackStructs
650 #pragma pack()
651 #endif
652
653 #ifdef __MigPackStructs
654 #pragma pack(4)
655 #endif
656 typedef struct {
657 mach_msg_header_t Head;
658 NDR_record_t NDR;
659 kern_return_t RetCode;
660 } __Reply__vm_write_t;
661 #ifdef __MigPackStructs
662 #pragma pack()
663 #endif
664
665 #ifdef __MigPackStructs
666 #pragma pack(4)
667 #endif
668 typedef struct {
669 mach_msg_header_t Head;
670 NDR_record_t NDR;
671 kern_return_t RetCode;
672 } __Reply__vm_copy_t;
673 #ifdef __MigPackStructs
674 #pragma pack()
675 #endif
676
677 #ifdef __MigPackStructs
678 #pragma pack(4)
679 #endif
680 typedef struct {
681 mach_msg_header_t Head;
682 NDR_record_t NDR;
683 kern_return_t RetCode;
684 vm_size_t outsize;
685 } __Reply__vm_read_overwrite_t;
686 #ifdef __MigPackStructs
687 #pragma pack()
688 #endif
689
690 #ifdef __MigPackStructs
691 #pragma pack(4)
692 #endif
693 typedef struct {
694 mach_msg_header_t Head;
695 NDR_record_t NDR;
696 kern_return_t RetCode;
697 } __Reply__vm_msync_t;
698 #ifdef __MigPackStructs
699 #pragma pack()
700 #endif
701
702 #ifdef __MigPackStructs
703 #pragma pack(4)
704 #endif
705 typedef struct {
706 mach_msg_header_t Head;
707 NDR_record_t NDR;
708 kern_return_t RetCode;
709 } __Reply__vm_behavior_set_t;
710 #ifdef __MigPackStructs
711 #pragma pack()
712 #endif
713
714 #ifdef __MigPackStructs
715 #pragma pack(4)
716 #endif
717 typedef struct {
718 mach_msg_header_t Head;
719 NDR_record_t NDR;
720 kern_return_t RetCode;
721 vm_machine_attribute_val_t value;
722 } __Reply__vm_machine_attribute_t;
723 #ifdef __MigPackStructs
724 #pragma pack()
725 #endif
726
727 #ifdef __MigPackStructs
728 #pragma pack(4)
729 #endif
730 typedef struct {
731 mach_msg_header_t Head;
732 NDR_record_t NDR;
733 kern_return_t RetCode;
734 vm_address_t target_address;
735 vm_prot_t cur_protection;
736 vm_prot_t max_protection;
737 } __Reply__vm_remap_t;
738 #ifdef __MigPackStructs
739 #pragma pack()
740 #endif
741
742 #ifdef __MigPackStructs
743 #pragma pack(4)
744 #endif
745 typedef struct {
746 mach_msg_header_t Head;
747 NDR_record_t NDR;
748 kern_return_t RetCode;
749 } __Reply__task_wire_t;
750 #ifdef __MigPackStructs
751 #pragma pack()
752 #endif
753
754 #ifdef __MigPackStructs
755 #pragma pack(4)
756 #endif
757 typedef struct {
758 mach_msg_header_t Head;
759 /* start of the kernel processed data */
760 mach_msg_body_t msgh_body;
761 mach_msg_port_descriptor_t object_handle;
762 /* end of the kernel processed data */
763 NDR_record_t NDR;
764 vm_size_t size;
765 } __Reply__mach_make_memory_entry_t;
766 #ifdef __MigPackStructs
767 #pragma pack()
768 #endif
769
770 #ifdef __MigPackStructs
771 #pragma pack(4)
772 #endif
773 typedef struct {
774 mach_msg_header_t Head;
775 NDR_record_t NDR;
776 kern_return_t RetCode;
777 integer_t disposition;
778 integer_t ref_count;
779 } __Reply__vm_map_page_query_t;
780 #ifdef __MigPackStructs
781 #pragma pack()
782 #endif
783
784 #ifdef __MigPackStructs
785 #pragma pack(4)
786 #endif
787 typedef struct {
788 mach_msg_header_t Head;
789 /* start of the kernel processed data */
790 mach_msg_body_t msgh_body;
791 mach_msg_ool_descriptor_t objects;
792 /* end of the kernel processed data */
793 NDR_record_t NDR;
794 vm_info_region_t region;
795 mach_msg_type_number_t objectsCnt;
796 } __Reply__mach_vm_region_info_t;
797 #ifdef __MigPackStructs
798 #pragma pack()
799 #endif
800
801 #ifdef __MigPackStructs
802 #pragma pack(4)
803 #endif
804 typedef struct {
805 mach_msg_header_t Head;
806 /* start of the kernel processed data */
807 mach_msg_body_t msgh_body;
808 mach_msg_ool_descriptor_t pages;
809 /* end of the kernel processed data */
810 NDR_record_t NDR;
811 mach_msg_type_number_t pagesCnt;
812 } __Reply__vm_mapped_pages_info_t;
813 #ifdef __MigPackStructs
814 #pragma pack()
815 #endif
816
817 #ifdef __MigPackStructs
818 #pragma pack(4)
819 #endif
820 typedef struct {
821 mach_msg_header_t Head;
822 NDR_record_t NDR;
823 kern_return_t RetCode;
824 vm_address_t address;
825 vm_size_t size;
826 natural_t nesting_depth;
827 mach_msg_type_number_t infoCnt;
828 int info[19];
829 } __Reply__vm_region_recurse_t;
830 #ifdef __MigPackStructs
831 #pragma pack()
832 #endif
833
834 #ifdef __MigPackStructs
835 #pragma pack(4)
836 #endif
837 typedef struct {
838 mach_msg_header_t Head;
839 NDR_record_t NDR;
840 kern_return_t RetCode;
841 vm_address_t address;
842 vm_size_t size;
843 natural_t nesting_depth;
844 mach_msg_type_number_t infoCnt;
845 int info[19];
846 } __Reply__vm_region_recurse_64_t;
847 #ifdef __MigPackStructs
848 #pragma pack()
849 #endif
850
851 #ifdef __MigPackStructs
852 #pragma pack(4)
853 #endif
854 typedef struct {
855 mach_msg_header_t Head;
856 /* start of the kernel processed data */
857 mach_msg_body_t msgh_body;
858 mach_msg_ool_descriptor_t objects;
859 /* end of the kernel processed data */
860 NDR_record_t NDR;
861 vm_info_region_64_t region;
862 mach_msg_type_number_t objectsCnt;
863 } __Reply__mach_vm_region_info_64_t;
864 #ifdef __MigPackStructs
865 #pragma pack()
866 #endif
867
868 #ifdef __MigPackStructs
869 #pragma pack(4)
870 #endif
871 typedef struct {
872 mach_msg_header_t Head;
873 /* start of the kernel processed data */
874 mach_msg_body_t msgh_body;
875 mach_msg_port_descriptor_t object_name;
876 /* end of the kernel processed data */
877 NDR_record_t NDR;
878 vm_address_t address;
879 vm_size_t size;
880 mach_msg_type_number_t infoCnt;
881 int info[10];
882 } __Reply__vm_region_64_t;
883 #ifdef __MigPackStructs
884 #pragma pack()
885 #endif
886
887 #ifdef __MigPackStructs
888 #pragma pack(4)
889 #endif
890 typedef struct {
891 mach_msg_header_t Head;
892 /* start of the kernel processed data */
893 mach_msg_body_t msgh_body;
894 mach_msg_port_descriptor_t object_handle;
895 /* end of the kernel processed data */
896 NDR_record_t NDR;
897 memory_object_size_t size;
898 } __Reply__mach_make_memory_entry_64_t;
899 #ifdef __MigPackStructs
900 #pragma pack()
901 #endif
902
903 #ifdef __MigPackStructs
904 #pragma pack(4)
905 #endif
906 typedef struct {
907 mach_msg_header_t Head;
908 NDR_record_t NDR;
909 kern_return_t RetCode;
910 int state;
911 } __Reply__vm_purgable_control_t;
912 #ifdef __MigPackStructs
913 #pragma pack()
914 #endif
915 #endif /* !__Reply__vm_map_subsystem__defined */
916
917
918 /* union of all replies */
919
920 #ifndef __ReplyUnion__vm_map_subsystem__defined
921 #define __ReplyUnion__vm_map_subsystem__defined
922 union __ReplyUnion__vm_map_subsystem {
923 __Reply__vm_region_t Reply_vm_region;
924 __Reply__vm_allocate_t Reply_vm_allocate;
925 __Reply__vm_deallocate_t Reply_vm_deallocate;
926 __Reply__vm_protect_t Reply_vm_protect;
927 __Reply__vm_inherit_t Reply_vm_inherit;
928 __Reply__vm_read_t Reply_vm_read;
929 __Reply__vm_read_list_t Reply_vm_read_list;
930 __Reply__vm_write_t Reply_vm_write;
931 __Reply__vm_copy_t Reply_vm_copy;
932 __Reply__vm_read_overwrite_t Reply_vm_read_overwrite;
933 __Reply__vm_msync_t Reply_vm_msync;
934 __Reply__vm_behavior_set_t Reply_vm_behavior_set;
935 __Reply__vm_machine_attribute_t Reply_vm_machine_attribute;
936 __Reply__vm_remap_t Reply_vm_remap;
937 __Reply__task_wire_t Reply_task_wire;
938 __Reply__mach_make_memory_entry_t Reply_mach_make_memory_entry;
939 __Reply__vm_map_page_query_t Reply_vm_map_page_query;
940 __Reply__mach_vm_region_info_t Reply_mach_vm_region_info;
941 __Reply__vm_mapped_pages_info_t Reply_vm_mapped_pages_info;
942 __Reply__vm_region_recurse_t Reply_vm_region_recurse;
943 __Reply__vm_region_recurse_64_t Reply_vm_region_recurse_64;
944 __Reply__mach_vm_region_info_64_t Reply_mach_vm_region_info_64;
945 __Reply__vm_region_64_t Reply_vm_region_64;
946 __Reply__mach_make_memory_entry_64_t Reply_mach_make_memory_entry_64;
947 __Reply__vm_purgable_control_t Reply_vm_purgable_control;
948 };
949 #endif /* __RequestUnion__vm_map_subsystem__defined */
950 /* Forward Declarations */
951
952
953 mig_internal novalue _Xvm_region
954 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
955
956 mig_internal novalue _Xvm_allocate
957 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
958
959 mig_internal novalue _Xvm_deallocate
960 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
961
962 mig_internal novalue _Xvm_protect
963 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
964
965 mig_internal novalue _Xvm_inherit
966 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
967
968 mig_internal novalue _Xvm_read
969 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
970
971 mig_internal novalue _Xvm_read_list
972 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
973
974 mig_internal novalue _Xvm_write
975 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
976
977 mig_internal novalue _Xvm_copy
978 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
979
980 mig_internal novalue _Xvm_read_overwrite
981 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
982
983 mig_internal novalue _Xvm_msync
984 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
985
986 mig_internal novalue _Xvm_behavior_set
987 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
988
989 mig_internal novalue _Xvm_machine_attribute
990 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
991
992 mig_internal novalue _Xvm_remap
993 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
994
995 mig_internal novalue _Xtask_wire
996 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
997
998 mig_internal novalue _Xmach_make_memory_entry
999 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1000
1001 mig_internal novalue _Xvm_map_page_query
1002 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1003
1004 mig_internal novalue _Xmach_vm_region_info
1005 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1006
1007 mig_internal novalue _Xvm_mapped_pages_info
1008 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1009
1010 mig_internal novalue _Xvm_region_recurse
1011 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1012
1013 mig_internal novalue _Xvm_region_recurse_64
1014 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1015
1016 mig_internal novalue _Xmach_vm_region_info_64
1017 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1018
1019 mig_internal novalue _Xvm_region_64
1020 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1021
1022 mig_internal novalue _Xmach_make_memory_entry_64
1023 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1024
1025 mig_internal novalue _Xvm_purgable_control
1026 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
1027
1028
1029 #if ( __MigTypeCheck )
1030 #if __MIG_check__Request__vm_map_subsystem__
1031 #if !defined(__MIG_check__Request__vm_region_t__defined)
1032 #define __MIG_check__Request__vm_region_t__defined
1033
__MIG_check__Request__vm_region_t(__Request__vm_region_t * In0P)1034 mig_internal kern_return_t __MIG_check__Request__vm_region_t(__attribute__((__unused__)) __Request__vm_region_t *In0P)
1035 {
1036
1037 typedef __Request__vm_region_t __Request;
1038 #if __MigTypeCheck
1039 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1040 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1041 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1042 return MIG_BAD_ARGUMENTS;
1043 #endif /* __MigTypeCheck */
1044
1045 return MACH_MSG_SUCCESS;
1046 }
1047 #endif /* !defined(__MIG_check__Request__vm_region_t__defined) */
1048 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1049 #endif /* ( __MigTypeCheck ) */
1050
1051
1052 /* Routine vm_region */
1053 #ifdef mig_external
1054 mig_external
1055 #else
1056 extern
1057 #endif /* mig_external */
vm_region(target_task,address,size,flavor,info,infoCnt,object_name)1058 kern_return_t vm_region
1059 #if defined(LINTLIBRARY)
1060 (target_task, address, size, flavor, info, infoCnt, object_name)
1061 vm_map_t target_task;
1062 vm_address_t *address;
1063 vm_size_t *size;
1064 vm_region_flavor_t flavor;
1065 vm_region_info_t info;
1066 mach_msg_type_number_t *infoCnt;
1067 mach_port_t *object_name;
1068 { return vm_region(target_task, address, size, flavor, info, infoCnt, object_name); }
1069 #else
1070 (
1071 vm_map_t target_task,
1072 vm_address_t *address,
1073 vm_size_t *size,
1074 vm_region_flavor_t flavor,
1075 vm_region_info_t info,
1076 mach_msg_type_number_t *infoCnt,
1077 mach_port_t *object_name
1078 );
1079 #endif /* defined(LINTLIBRARY) */
1080
1081 /* Routine vm_region */
_Xvm_region(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1082 mig_internal novalue _Xvm_region
1083 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1084 {
1085
1086 #ifdef __MigPackStructs
1087 #pragma pack(4)
1088 #endif
1089 typedef struct {
1090 mach_msg_header_t Head;
1091 /* start of the kernel processed data */
1092 mach_msg_body_t msgh_body;
1093 /* end of the kernel processed data */
1094 NDR_record_t NDR;
1095 vm_address_t address;
1096 vm_region_flavor_t flavor;
1097 mach_msg_type_number_t infoCnt;
1098 mach_msg_trailer_t trailer;
1099 } Request;
1100 #ifdef __MigPackStructs
1101 #pragma pack()
1102 #endif
1103 typedef __Request__vm_region_t __Request;
1104 typedef __Reply__vm_region_t Reply;
1105
1106 /*
1107 * typedef struct {
1108 * mach_msg_header_t Head;
1109 * NDR_record_t NDR;
1110 * kern_return_t RetCode;
1111 * } mig_reply_error_t;
1112 */
1113
1114 Request *In0P = (Request *) InHeadP;
1115 Reply *OutP = (Reply *) OutHeadP;
1116 #ifdef __MIG_check__Request__vm_region_t__defined
1117 kern_return_t check_result;
1118 #endif /* __MIG_check__Request__vm_region_t__defined */
1119
1120 #if __MigKernelSpecificCode
1121 #if UseStaticTemplates
1122 const static mach_msg_port_descriptor_t object_nameTemplate = {
1123 .name = MACH_PORT_NULL,
1124 .disposition = 17,
1125 .type = MACH_MSG_PORT_DESCRIPTOR,
1126 };
1127 #endif /* UseStaticTemplates */
1128
1129 #else
1130 #if UseStaticTemplates
1131 const static mach_msg_port_descriptor_t object_nameTemplate = {
1132 .name = MACH_PORT_NULL,
1133 .disposition = 17,
1134 .type = MACH_MSG_PORT_DESCRIPTOR,
1135 };
1136 #endif /* UseStaticTemplates */
1137
1138 #endif /* __MigKernelSpecificCode */
1139 kern_return_t RetCode;
1140 vm_map_t target_task;
1141
1142 __DeclareRcvRpc(3800, "vm_region")
1143 __BeforeRcvRpc(3800, "vm_region")
1144 /* RetCArg=0x0 rtSimpleRequest=0 */
1145
1146 #if defined(__MIG_check__Request__vm_region_t__defined)
1147 check_result = __MIG_check__Request__vm_region_t((__Request *)In0P);
1148 if (check_result != MACH_MSG_SUCCESS)
1149 { MIG_RETURN_ERROR(OutP, check_result); }
1150 #endif /* defined(__MIG_check__Request__vm_region_t__defined) */
1151
1152 #if UseStaticTemplates
1153 OutP->object_name = object_nameTemplate;
1154 #else /* UseStaticTemplates */
1155 #if __MigKernelSpecificCode
1156 OutP->object_name.disposition = 17;
1157 #else
1158 OutP->object_name.disposition = 17;
1159 #endif /* __MigKernelSpecificCode */
1160 OutP->object_name.type = MACH_MSG_PORT_DESCRIPTOR;
1161 #endif /* UseStaticTemplates */
1162
1163
1164 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
1165
1166 OutP->infoCnt = 10;
1167 if (In0P->infoCnt < OutP->infoCnt)
1168 OutP->infoCnt = In0P->infoCnt;
1169
1170 RetCode = vm_region(target_task, &In0P->address, &OutP->size, In0P->flavor, OutP->info, &OutP->infoCnt, &OutP->object_name.name);
1171 vm_map_deallocate(target_task);
1172 if (RetCode != KERN_SUCCESS) {
1173 MIG_RETURN_ERROR(OutP, RetCode);
1174 }
1175 #if __MigKernelSpecificCode
1176 #endif /* __MigKernelSpecificCode */
1177
1178 OutP->NDR = NDR_record;
1179
1180
1181 OutP->address = In0P->address;
1182 OutP->Head.msgh_size = (sizeof(Reply) - 40) + (_WALIGN_((4 * OutP->infoCnt)));
1183
1184 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
1185 OutP->msgh_body.msgh_descriptor_count = 1;
1186 __AfterRcvRpc(3800, "vm_region")
1187 }
1188
1189 #if ( __MigTypeCheck )
1190 #if __MIG_check__Request__vm_map_subsystem__
1191 #if !defined(__MIG_check__Request__vm_allocate_t__defined)
1192 #define __MIG_check__Request__vm_allocate_t__defined
1193
__MIG_check__Request__vm_allocate_t(__Request__vm_allocate_t * In0P)1194 mig_internal kern_return_t __MIG_check__Request__vm_allocate_t(__attribute__((__unused__)) __Request__vm_allocate_t *In0P)
1195 {
1196
1197 typedef __Request__vm_allocate_t __Request;
1198 #if __MigTypeCheck
1199 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1200 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1201 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1202 return MIG_BAD_ARGUMENTS;
1203 #endif /* __MigTypeCheck */
1204
1205 return MACH_MSG_SUCCESS;
1206 }
1207 #endif /* !defined(__MIG_check__Request__vm_allocate_t__defined) */
1208 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1209 #endif /* ( __MigTypeCheck ) */
1210
1211
1212 /* Routine vm_allocate */
1213 #ifdef mig_external
1214 mig_external
1215 #else
1216 extern
1217 #endif /* mig_external */
vm_allocate(target_task,address,size,flags)1218 kern_return_t vm_allocate
1219 #if defined(LINTLIBRARY)
1220 (target_task, address, size, flags)
1221 vm_map_t target_task;
1222 vm_address_t *address;
1223 vm_size_t size;
1224 int flags;
1225 { return vm_allocate(target_task, address, size, flags); }
1226 #else
1227 (
1228 vm_map_t target_task,
1229 vm_address_t *address,
1230 vm_size_t size,
1231 int flags
1232 );
1233 #endif /* defined(LINTLIBRARY) */
1234
1235 /* Routine vm_allocate */
_Xvm_allocate(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1236 mig_internal novalue _Xvm_allocate
1237 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1238 {
1239
1240 #ifdef __MigPackStructs
1241 #pragma pack(4)
1242 #endif
1243 typedef struct {
1244 mach_msg_header_t Head;
1245 /* start of the kernel processed data */
1246 mach_msg_body_t msgh_body;
1247 /* end of the kernel processed data */
1248 NDR_record_t NDR;
1249 vm_address_t address;
1250 vm_size_t size;
1251 int flags;
1252 mach_msg_trailer_t trailer;
1253 } Request;
1254 #ifdef __MigPackStructs
1255 #pragma pack()
1256 #endif
1257 typedef __Request__vm_allocate_t __Request;
1258 typedef __Reply__vm_allocate_t Reply;
1259
1260 /*
1261 * typedef struct {
1262 * mach_msg_header_t Head;
1263 * NDR_record_t NDR;
1264 * kern_return_t RetCode;
1265 * } mig_reply_error_t;
1266 */
1267
1268 Request *In0P = (Request *) InHeadP;
1269 Reply *OutP = (Reply *) OutHeadP;
1270 #ifdef __MIG_check__Request__vm_allocate_t__defined
1271 kern_return_t check_result;
1272 #endif /* __MIG_check__Request__vm_allocate_t__defined */
1273
1274 #if __MigKernelSpecificCode
1275 #else
1276 #endif /* __MigKernelSpecificCode */
1277 vm_map_t target_task;
1278
1279 __DeclareRcvRpc(3801, "vm_allocate")
1280 __BeforeRcvRpc(3801, "vm_allocate")
1281 /* RetCArg=0x0 rtSimpleRequest=0 */
1282
1283 #if defined(__MIG_check__Request__vm_allocate_t__defined)
1284 check_result = __MIG_check__Request__vm_allocate_t((__Request *)In0P);
1285 if (check_result != MACH_MSG_SUCCESS)
1286 { MIG_RETURN_ERROR(OutP, check_result); }
1287 #endif /* defined(__MIG_check__Request__vm_allocate_t__defined) */
1288
1289 target_task = convert_port_entry_to_map(In0P->Head.msgh_request_port);
1290
1291 OutP->RetCode = vm_allocate(target_task, &In0P->address, In0P->size, In0P->flags);
1292 vm_map_deallocate(target_task);
1293 if (OutP->RetCode != KERN_SUCCESS) {
1294 MIG_RETURN_ERROR(OutP, OutP->RetCode);
1295 }
1296 #if __MigKernelSpecificCode
1297 #endif /* __MigKernelSpecificCode */
1298
1299 OutP->NDR = NDR_record;
1300
1301
1302 OutP->address = In0P->address;
1303
1304 OutP->Head.msgh_size = (sizeof(Reply));
1305 __AfterRcvRpc(3801, "vm_allocate")
1306 }
1307
1308 #if ( __MigTypeCheck )
1309 #if __MIG_check__Request__vm_map_subsystem__
1310 #if !defined(__MIG_check__Request__vm_deallocate_t__defined)
1311 #define __MIG_check__Request__vm_deallocate_t__defined
1312
__MIG_check__Request__vm_deallocate_t(__Request__vm_deallocate_t * In0P)1313 mig_internal kern_return_t __MIG_check__Request__vm_deallocate_t(__attribute__((__unused__)) __Request__vm_deallocate_t *In0P)
1314 {
1315
1316 typedef __Request__vm_deallocate_t __Request;
1317 #if __MigTypeCheck
1318 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1319 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1320 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1321 return MIG_BAD_ARGUMENTS;
1322 #endif /* __MigTypeCheck */
1323
1324 return MACH_MSG_SUCCESS;
1325 }
1326 #endif /* !defined(__MIG_check__Request__vm_deallocate_t__defined) */
1327 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1328 #endif /* ( __MigTypeCheck ) */
1329
1330
1331 /* Routine vm_deallocate */
1332 #ifdef mig_external
1333 mig_external
1334 #else
1335 extern
1336 #endif /* mig_external */
vm_deallocate(target_task,address,size)1337 kern_return_t vm_deallocate
1338 #if defined(LINTLIBRARY)
1339 (target_task, address, size)
1340 vm_map_t target_task;
1341 vm_address_t address;
1342 vm_size_t size;
1343 { return vm_deallocate(target_task, address, size); }
1344 #else
1345 (
1346 vm_map_t target_task,
1347 vm_address_t address,
1348 vm_size_t size
1349 );
1350 #endif /* defined(LINTLIBRARY) */
1351
1352 /* Routine vm_deallocate */
_Xvm_deallocate(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1353 mig_internal novalue _Xvm_deallocate
1354 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1355 {
1356
1357 #ifdef __MigPackStructs
1358 #pragma pack(4)
1359 #endif
1360 typedef struct {
1361 mach_msg_header_t Head;
1362 /* start of the kernel processed data */
1363 mach_msg_body_t msgh_body;
1364 /* end of the kernel processed data */
1365 NDR_record_t NDR;
1366 vm_address_t address;
1367 vm_size_t size;
1368 mach_msg_trailer_t trailer;
1369 } Request;
1370 #ifdef __MigPackStructs
1371 #pragma pack()
1372 #endif
1373 typedef __Request__vm_deallocate_t __Request;
1374 typedef __Reply__vm_deallocate_t Reply;
1375
1376 /*
1377 * typedef struct {
1378 * mach_msg_header_t Head;
1379 * NDR_record_t NDR;
1380 * kern_return_t RetCode;
1381 * } mig_reply_error_t;
1382 */
1383
1384 Request *In0P = (Request *) InHeadP;
1385 Reply *OutP = (Reply *) OutHeadP;
1386 #ifdef __MIG_check__Request__vm_deallocate_t__defined
1387 kern_return_t check_result;
1388 #endif /* __MIG_check__Request__vm_deallocate_t__defined */
1389
1390 #if __MigKernelSpecificCode
1391 #else
1392 #endif /* __MigKernelSpecificCode */
1393 vm_map_t target_task;
1394
1395 __DeclareRcvRpc(3802, "vm_deallocate")
1396 __BeforeRcvRpc(3802, "vm_deallocate")
1397 /* RetCArg=0x0 rtSimpleRequest=0 */
1398
1399 #if defined(__MIG_check__Request__vm_deallocate_t__defined)
1400 check_result = __MIG_check__Request__vm_deallocate_t((__Request *)In0P);
1401 if (check_result != MACH_MSG_SUCCESS)
1402 { MIG_RETURN_ERROR(OutP, check_result); }
1403 #endif /* defined(__MIG_check__Request__vm_deallocate_t__defined) */
1404
1405 target_task = convert_port_entry_to_map(In0P->Head.msgh_request_port);
1406
1407 OutP->RetCode = vm_deallocate(target_task, In0P->address, In0P->size);
1408 vm_map_deallocate(target_task);
1409 #if __MigKernelSpecificCode
1410 #endif /* __MigKernelSpecificCode */
1411
1412 OutP->NDR = NDR_record;
1413
1414
1415 __AfterRcvRpc(3802, "vm_deallocate")
1416 }
1417
1418 #if ( __MigTypeCheck )
1419 #if __MIG_check__Request__vm_map_subsystem__
1420 #if !defined(__MIG_check__Request__vm_protect_t__defined)
1421 #define __MIG_check__Request__vm_protect_t__defined
1422
__MIG_check__Request__vm_protect_t(__Request__vm_protect_t * In0P)1423 mig_internal kern_return_t __MIG_check__Request__vm_protect_t(__attribute__((__unused__)) __Request__vm_protect_t *In0P)
1424 {
1425
1426 typedef __Request__vm_protect_t __Request;
1427 #if __MigTypeCheck
1428 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1429 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1430 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1431 return MIG_BAD_ARGUMENTS;
1432 #endif /* __MigTypeCheck */
1433
1434 return MACH_MSG_SUCCESS;
1435 }
1436 #endif /* !defined(__MIG_check__Request__vm_protect_t__defined) */
1437 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1438 #endif /* ( __MigTypeCheck ) */
1439
1440
1441 /* Routine vm_protect */
1442 #ifdef mig_external
1443 mig_external
1444 #else
1445 extern
1446 #endif /* mig_external */
vm_protect(target_task,address,size,set_maximum,new_protection)1447 kern_return_t vm_protect
1448 #if defined(LINTLIBRARY)
1449 (target_task, address, size, set_maximum, new_protection)
1450 vm_map_t target_task;
1451 vm_address_t address;
1452 vm_size_t size;
1453 boolean_t set_maximum;
1454 vm_prot_t new_protection;
1455 { return vm_protect(target_task, address, size, set_maximum, new_protection); }
1456 #else
1457 (
1458 vm_map_t target_task,
1459 vm_address_t address,
1460 vm_size_t size,
1461 boolean_t set_maximum,
1462 vm_prot_t new_protection
1463 );
1464 #endif /* defined(LINTLIBRARY) */
1465
1466 /* Routine vm_protect */
_Xvm_protect(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1467 mig_internal novalue _Xvm_protect
1468 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1469 {
1470
1471 #ifdef __MigPackStructs
1472 #pragma pack(4)
1473 #endif
1474 typedef struct {
1475 mach_msg_header_t Head;
1476 /* start of the kernel processed data */
1477 mach_msg_body_t msgh_body;
1478 /* end of the kernel processed data */
1479 NDR_record_t NDR;
1480 vm_address_t address;
1481 vm_size_t size;
1482 boolean_t set_maximum;
1483 vm_prot_t new_protection;
1484 mach_msg_trailer_t trailer;
1485 } Request;
1486 #ifdef __MigPackStructs
1487 #pragma pack()
1488 #endif
1489 typedef __Request__vm_protect_t __Request;
1490 typedef __Reply__vm_protect_t Reply;
1491
1492 /*
1493 * typedef struct {
1494 * mach_msg_header_t Head;
1495 * NDR_record_t NDR;
1496 * kern_return_t RetCode;
1497 * } mig_reply_error_t;
1498 */
1499
1500 Request *In0P = (Request *) InHeadP;
1501 Reply *OutP = (Reply *) OutHeadP;
1502 #ifdef __MIG_check__Request__vm_protect_t__defined
1503 kern_return_t check_result;
1504 #endif /* __MIG_check__Request__vm_protect_t__defined */
1505
1506 #if __MigKernelSpecificCode
1507 #else
1508 #endif /* __MigKernelSpecificCode */
1509 vm_map_t target_task;
1510
1511 __DeclareRcvRpc(3803, "vm_protect")
1512 __BeforeRcvRpc(3803, "vm_protect")
1513 /* RetCArg=0x0 rtSimpleRequest=0 */
1514
1515 #if defined(__MIG_check__Request__vm_protect_t__defined)
1516 check_result = __MIG_check__Request__vm_protect_t((__Request *)In0P);
1517 if (check_result != MACH_MSG_SUCCESS)
1518 { MIG_RETURN_ERROR(OutP, check_result); }
1519 #endif /* defined(__MIG_check__Request__vm_protect_t__defined) */
1520
1521 target_task = convert_port_entry_to_map(In0P->Head.msgh_request_port);
1522
1523 OutP->RetCode = vm_protect(target_task, In0P->address, In0P->size, In0P->set_maximum, In0P->new_protection);
1524 vm_map_deallocate(target_task);
1525 #if __MigKernelSpecificCode
1526 #endif /* __MigKernelSpecificCode */
1527
1528 OutP->NDR = NDR_record;
1529
1530
1531 __AfterRcvRpc(3803, "vm_protect")
1532 }
1533
1534 #if ( __MigTypeCheck )
1535 #if __MIG_check__Request__vm_map_subsystem__
1536 #if !defined(__MIG_check__Request__vm_inherit_t__defined)
1537 #define __MIG_check__Request__vm_inherit_t__defined
1538
__MIG_check__Request__vm_inherit_t(__Request__vm_inherit_t * In0P)1539 mig_internal kern_return_t __MIG_check__Request__vm_inherit_t(__attribute__((__unused__)) __Request__vm_inherit_t *In0P)
1540 {
1541
1542 typedef __Request__vm_inherit_t __Request;
1543 #if __MigTypeCheck
1544 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1545 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1546 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1547 return MIG_BAD_ARGUMENTS;
1548 #endif /* __MigTypeCheck */
1549
1550 return MACH_MSG_SUCCESS;
1551 }
1552 #endif /* !defined(__MIG_check__Request__vm_inherit_t__defined) */
1553 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1554 #endif /* ( __MigTypeCheck ) */
1555
1556
1557 /* Routine vm_inherit */
1558 #ifdef mig_external
1559 mig_external
1560 #else
1561 extern
1562 #endif /* mig_external */
vm_inherit(target_task,address,size,new_inheritance)1563 kern_return_t vm_inherit
1564 #if defined(LINTLIBRARY)
1565 (target_task, address, size, new_inheritance)
1566 vm_map_t target_task;
1567 vm_address_t address;
1568 vm_size_t size;
1569 vm_inherit_t new_inheritance;
1570 { return vm_inherit(target_task, address, size, new_inheritance); }
1571 #else
1572 (
1573 vm_map_t target_task,
1574 vm_address_t address,
1575 vm_size_t size,
1576 vm_inherit_t new_inheritance
1577 );
1578 #endif /* defined(LINTLIBRARY) */
1579
1580 /* Routine vm_inherit */
_Xvm_inherit(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1581 mig_internal novalue _Xvm_inherit
1582 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1583 {
1584
1585 #ifdef __MigPackStructs
1586 #pragma pack(4)
1587 #endif
1588 typedef struct {
1589 mach_msg_header_t Head;
1590 /* start of the kernel processed data */
1591 mach_msg_body_t msgh_body;
1592 /* end of the kernel processed data */
1593 NDR_record_t NDR;
1594 vm_address_t address;
1595 vm_size_t size;
1596 vm_inherit_t new_inheritance;
1597 mach_msg_trailer_t trailer;
1598 } Request;
1599 #ifdef __MigPackStructs
1600 #pragma pack()
1601 #endif
1602 typedef __Request__vm_inherit_t __Request;
1603 typedef __Reply__vm_inherit_t Reply;
1604
1605 /*
1606 * typedef struct {
1607 * mach_msg_header_t Head;
1608 * NDR_record_t NDR;
1609 * kern_return_t RetCode;
1610 * } mig_reply_error_t;
1611 */
1612
1613 Request *In0P = (Request *) InHeadP;
1614 Reply *OutP = (Reply *) OutHeadP;
1615 #ifdef __MIG_check__Request__vm_inherit_t__defined
1616 kern_return_t check_result;
1617 #endif /* __MIG_check__Request__vm_inherit_t__defined */
1618
1619 #if __MigKernelSpecificCode
1620 #else
1621 #endif /* __MigKernelSpecificCode */
1622 vm_map_t target_task;
1623
1624 __DeclareRcvRpc(3804, "vm_inherit")
1625 __BeforeRcvRpc(3804, "vm_inherit")
1626 /* RetCArg=0x0 rtSimpleRequest=0 */
1627
1628 #if defined(__MIG_check__Request__vm_inherit_t__defined)
1629 check_result = __MIG_check__Request__vm_inherit_t((__Request *)In0P);
1630 if (check_result != MACH_MSG_SUCCESS)
1631 { MIG_RETURN_ERROR(OutP, check_result); }
1632 #endif /* defined(__MIG_check__Request__vm_inherit_t__defined) */
1633
1634 target_task = convert_port_entry_to_map(In0P->Head.msgh_request_port);
1635
1636 OutP->RetCode = vm_inherit(target_task, In0P->address, In0P->size, In0P->new_inheritance);
1637 vm_map_deallocate(target_task);
1638 #if __MigKernelSpecificCode
1639 #endif /* __MigKernelSpecificCode */
1640
1641 OutP->NDR = NDR_record;
1642
1643
1644 __AfterRcvRpc(3804, "vm_inherit")
1645 }
1646
1647 #if ( __MigTypeCheck )
1648 #if __MIG_check__Request__vm_map_subsystem__
1649 #if !defined(__MIG_check__Request__vm_read_t__defined)
1650 #define __MIG_check__Request__vm_read_t__defined
1651
__MIG_check__Request__vm_read_t(__Request__vm_read_t * In0P)1652 mig_internal kern_return_t __MIG_check__Request__vm_read_t(__attribute__((__unused__)) __Request__vm_read_t *In0P)
1653 {
1654
1655 typedef __Request__vm_read_t __Request;
1656 #if __MigTypeCheck
1657 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1658 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1659 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1660 return MIG_BAD_ARGUMENTS;
1661 #endif /* __MigTypeCheck */
1662
1663 return MACH_MSG_SUCCESS;
1664 }
1665 #endif /* !defined(__MIG_check__Request__vm_read_t__defined) */
1666 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1667 #endif /* ( __MigTypeCheck ) */
1668
1669
1670 /* Routine vm_read */
1671 #ifdef mig_external
1672 mig_external
1673 #else
1674 extern
1675 #endif /* mig_external */
vm_read(target_task,address,size,data,dataCnt)1676 kern_return_t vm_read
1677 #if defined(LINTLIBRARY)
1678 (target_task, address, size, data, dataCnt)
1679 vm_map_t target_task;
1680 vm_address_t address;
1681 vm_size_t size;
1682 vm_offset_t *data;
1683 mach_msg_type_number_t *dataCnt;
1684 { return vm_read(target_task, address, size, data, dataCnt); }
1685 #else
1686 (
1687 vm_map_t target_task,
1688 vm_address_t address,
1689 vm_size_t size,
1690 vm_offset_t *data,
1691 mach_msg_type_number_t *dataCnt
1692 );
1693 #endif /* defined(LINTLIBRARY) */
1694
1695 /* Routine vm_read */
_Xvm_read(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1696 mig_internal novalue _Xvm_read
1697 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1698 {
1699
1700 #ifdef __MigPackStructs
1701 #pragma pack(4)
1702 #endif
1703 typedef struct {
1704 mach_msg_header_t Head;
1705 /* start of the kernel processed data */
1706 mach_msg_body_t msgh_body;
1707 /* end of the kernel processed data */
1708 NDR_record_t NDR;
1709 vm_address_t address;
1710 vm_size_t size;
1711 mach_msg_trailer_t trailer;
1712 } Request;
1713 #ifdef __MigPackStructs
1714 #pragma pack()
1715 #endif
1716 typedef __Request__vm_read_t __Request;
1717 typedef __Reply__vm_read_t Reply;
1718
1719 /*
1720 * typedef struct {
1721 * mach_msg_header_t Head;
1722 * NDR_record_t NDR;
1723 * kern_return_t RetCode;
1724 * } mig_reply_error_t;
1725 */
1726
1727 Request *In0P = (Request *) InHeadP;
1728 Reply *OutP = (Reply *) OutHeadP;
1729 #ifdef __MIG_check__Request__vm_read_t__defined
1730 kern_return_t check_result;
1731 #endif /* __MIG_check__Request__vm_read_t__defined */
1732
1733 #if __MigKernelSpecificCode
1734 #if UseStaticTemplates
1735 const static mach_msg_ool_descriptor_t dataTemplate = {
1736 .address = (void *)0,
1737 .size = 0,
1738 .deallocate = FALSE,
1739 .copy = MACH_MSG_VIRTUAL_COPY,
1740 .type = MACH_MSG_OOL_DESCRIPTOR,
1741 };
1742 #endif /* UseStaticTemplates */
1743
1744 #else
1745 #if UseStaticTemplates
1746 const static mach_msg_ool_descriptor_t dataTemplate = {
1747 .address = (void *)0,
1748 .size = 0,
1749 .deallocate = FALSE,
1750 .copy = MACH_MSG_VIRTUAL_COPY,
1751 .type = MACH_MSG_OOL_DESCRIPTOR,
1752 };
1753 #endif /* UseStaticTemplates */
1754
1755 #endif /* __MigKernelSpecificCode */
1756 kern_return_t RetCode;
1757 vm_map_t target_task;
1758
1759 __DeclareRcvRpc(3805, "vm_read")
1760 __BeforeRcvRpc(3805, "vm_read")
1761 /* RetCArg=0x0 rtSimpleRequest=0 */
1762
1763 #if defined(__MIG_check__Request__vm_read_t__defined)
1764 check_result = __MIG_check__Request__vm_read_t((__Request *)In0P);
1765 if (check_result != MACH_MSG_SUCCESS)
1766 { MIG_RETURN_ERROR(OutP, check_result); }
1767 #endif /* defined(__MIG_check__Request__vm_read_t__defined) */
1768
1769 #if UseStaticTemplates
1770 OutP->data = dataTemplate;
1771 #else /* UseStaticTemplates */
1772 OutP->data.deallocate = FALSE;
1773 OutP->data.copy = MACH_MSG_VIRTUAL_COPY;
1774 OutP->data.type = MACH_MSG_OOL_DESCRIPTOR;
1775 #endif /* UseStaticTemplates */
1776
1777
1778 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
1779
1780 RetCode = vm_read(target_task, In0P->address, In0P->size, (vm_offset_t *)&(OutP->data.address), &OutP->dataCnt);
1781 vm_map_deallocate(target_task);
1782 if (RetCode != KERN_SUCCESS) {
1783 MIG_RETURN_ERROR(OutP, RetCode);
1784 }
1785 #if __MigKernelSpecificCode
1786 #endif /* __MigKernelSpecificCode */
1787 OutP->data.size = OutP->dataCnt;
1788
1789
1790 OutP->NDR = NDR_record;
1791
1792
1793 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
1794 OutP->Head.msgh_size = (sizeof(Reply));
1795 OutP->msgh_body.msgh_descriptor_count = 1;
1796 __AfterRcvRpc(3805, "vm_read")
1797 }
1798
1799 #if ( __MigTypeCheck )
1800 #if __MIG_check__Request__vm_map_subsystem__
1801 #if !defined(__MIG_check__Request__vm_read_list_t__defined)
1802 #define __MIG_check__Request__vm_read_list_t__defined
1803
__MIG_check__Request__vm_read_list_t(__Request__vm_read_list_t * In0P)1804 mig_internal kern_return_t __MIG_check__Request__vm_read_list_t(__attribute__((__unused__)) __Request__vm_read_list_t *In0P)
1805 {
1806
1807 typedef __Request__vm_read_list_t __Request;
1808 #if __MigTypeCheck
1809 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1810 (In0P->msgh_body.msgh_descriptor_count != 0) ||
1811 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1812 return MIG_BAD_ARGUMENTS;
1813 #endif /* __MigTypeCheck */
1814
1815 return MACH_MSG_SUCCESS;
1816 }
1817 #endif /* !defined(__MIG_check__Request__vm_read_list_t__defined) */
1818 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1819 #endif /* ( __MigTypeCheck ) */
1820
1821
1822 /* Routine vm_read_list */
1823 #ifdef mig_external
1824 mig_external
1825 #else
1826 extern
1827 #endif /* mig_external */
vm_read_list(target_task,data_list,count)1828 kern_return_t vm_read_list
1829 #if defined(LINTLIBRARY)
1830 (target_task, data_list, count)
1831 vm_map_t target_task;
1832 vm_read_entry_t data_list;
1833 natural_t count;
1834 { return vm_read_list(target_task, data_list, count); }
1835 #else
1836 (
1837 vm_map_t target_task,
1838 vm_read_entry_t data_list,
1839 natural_t count
1840 );
1841 #endif /* defined(LINTLIBRARY) */
1842
1843 /* Routine vm_read_list */
_Xvm_read_list(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1844 mig_internal novalue _Xvm_read_list
1845 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1846 {
1847
1848 #ifdef __MigPackStructs
1849 #pragma pack(4)
1850 #endif
1851 typedef struct {
1852 mach_msg_header_t Head;
1853 /* start of the kernel processed data */
1854 mach_msg_body_t msgh_body;
1855 /* end of the kernel processed data */
1856 NDR_record_t NDR;
1857 vm_read_entry_t data_list;
1858 natural_t count;
1859 mach_msg_trailer_t trailer;
1860 } Request;
1861 #ifdef __MigPackStructs
1862 #pragma pack()
1863 #endif
1864 typedef __Request__vm_read_list_t __Request;
1865 typedef __Reply__vm_read_list_t Reply;
1866
1867 /*
1868 * typedef struct {
1869 * mach_msg_header_t Head;
1870 * NDR_record_t NDR;
1871 * kern_return_t RetCode;
1872 * } mig_reply_error_t;
1873 */
1874
1875 Request *In0P = (Request *) InHeadP;
1876 Reply *OutP = (Reply *) OutHeadP;
1877 #ifdef __MIG_check__Request__vm_read_list_t__defined
1878 kern_return_t check_result;
1879 #endif /* __MIG_check__Request__vm_read_list_t__defined */
1880
1881 #if __MigKernelSpecificCode
1882 #else
1883 #endif /* __MigKernelSpecificCode */
1884 vm_map_t target_task;
1885
1886 __DeclareRcvRpc(3806, "vm_read_list")
1887 __BeforeRcvRpc(3806, "vm_read_list")
1888 /* RetCArg=0x0 rtSimpleRequest=0 */
1889
1890 #if defined(__MIG_check__Request__vm_read_list_t__defined)
1891 check_result = __MIG_check__Request__vm_read_list_t((__Request *)In0P);
1892 if (check_result != MACH_MSG_SUCCESS)
1893 { MIG_RETURN_ERROR(OutP, check_result); }
1894 #endif /* defined(__MIG_check__Request__vm_read_list_t__defined) */
1895
1896 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
1897
1898 OutP->RetCode = vm_read_list(target_task, In0P->data_list, In0P->count);
1899 vm_map_deallocate(target_task);
1900 if (OutP->RetCode != KERN_SUCCESS) {
1901 MIG_RETURN_ERROR(OutP, OutP->RetCode);
1902 }
1903 #if __MigKernelSpecificCode
1904 #endif /* __MigKernelSpecificCode */
1905
1906 OutP->NDR = NDR_record;
1907
1908
1909 { typedef struct { char data[4096]; } *sp;
1910 * (sp) OutP->data_list = * (sp) In0P->data_list;
1911 }
1912
1913 OutP->Head.msgh_size = (sizeof(Reply));
1914 __AfterRcvRpc(3806, "vm_read_list")
1915 }
1916
1917 #if ( __MigTypeCheck )
1918 #if __MIG_check__Request__vm_map_subsystem__
1919 #if !defined(__MIG_check__Request__vm_write_t__defined)
1920 #define __MIG_check__Request__vm_write_t__defined
1921
__MIG_check__Request__vm_write_t(__Request__vm_write_t * In0P)1922 mig_internal kern_return_t __MIG_check__Request__vm_write_t(__attribute__((__unused__)) __Request__vm_write_t *In0P)
1923 {
1924
1925 typedef __Request__vm_write_t __Request;
1926 #if __MigTypeCheck
1927 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
1928 (In0P->msgh_body.msgh_descriptor_count != 1) ||
1929 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
1930 return MIG_BAD_ARGUMENTS;
1931 #endif /* __MigTypeCheck */
1932
1933 #if __MigTypeCheck
1934 if (In0P->data.type != MACH_MSG_OOL_DESCRIPTOR)
1935 return MIG_TYPE_ERROR;
1936 #endif /* __MigTypeCheck */
1937
1938 #if __MigTypeCheck
1939 if (In0P->data.size != In0P->dataCnt)
1940 return MIG_TYPE_ERROR;
1941 #endif /* __MigTypeCheck */
1942
1943 return MACH_MSG_SUCCESS;
1944 }
1945 #endif /* !defined(__MIG_check__Request__vm_write_t__defined) */
1946 #endif /* __MIG_check__Request__vm_map_subsystem__ */
1947 #endif /* ( __MigTypeCheck ) */
1948
1949
1950 /* Routine vm_write */
1951 #ifdef mig_external
1952 mig_external
1953 #else
1954 extern
1955 #endif /* mig_external */
vm_write(target_task,address,data,dataCnt)1956 kern_return_t vm_write
1957 #if defined(LINTLIBRARY)
1958 (target_task, address, data, dataCnt)
1959 vm_map_t target_task;
1960 vm_address_t address;
1961 vm_offset_t data;
1962 mach_msg_type_number_t dataCnt;
1963 { return vm_write(target_task, address, data, dataCnt); }
1964 #else
1965 (
1966 vm_map_t target_task,
1967 vm_address_t address,
1968 vm_offset_t data,
1969 mach_msg_type_number_t dataCnt
1970 );
1971 #endif /* defined(LINTLIBRARY) */
1972
1973 /* Routine vm_write */
_Xvm_write(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)1974 mig_internal novalue _Xvm_write
1975 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
1976 {
1977
1978 #ifdef __MigPackStructs
1979 #pragma pack(4)
1980 #endif
1981 typedef struct {
1982 mach_msg_header_t Head;
1983 /* start of the kernel processed data */
1984 mach_msg_body_t msgh_body;
1985 mach_msg_ool_descriptor_t data;
1986 /* end of the kernel processed data */
1987 NDR_record_t NDR;
1988 vm_address_t address;
1989 mach_msg_type_number_t dataCnt;
1990 mach_msg_trailer_t trailer;
1991 } Request;
1992 #ifdef __MigPackStructs
1993 #pragma pack()
1994 #endif
1995 typedef __Request__vm_write_t __Request;
1996 typedef __Reply__vm_write_t Reply;
1997
1998 /*
1999 * typedef struct {
2000 * mach_msg_header_t Head;
2001 * NDR_record_t NDR;
2002 * kern_return_t RetCode;
2003 * } mig_reply_error_t;
2004 */
2005
2006 Request *In0P = (Request *) InHeadP;
2007 Reply *OutP = (Reply *) OutHeadP;
2008 #ifdef __MIG_check__Request__vm_write_t__defined
2009 kern_return_t check_result;
2010 #endif /* __MIG_check__Request__vm_write_t__defined */
2011
2012 #if __MigKernelSpecificCode
2013 #else
2014 #endif /* __MigKernelSpecificCode */
2015 vm_map_t target_task;
2016
2017 __DeclareRcvRpc(3807, "vm_write")
2018 __BeforeRcvRpc(3807, "vm_write")
2019 /* RetCArg=0x0 rtSimpleRequest=0 */
2020
2021 #if defined(__MIG_check__Request__vm_write_t__defined)
2022 check_result = __MIG_check__Request__vm_write_t((__Request *)In0P);
2023 if (check_result != MACH_MSG_SUCCESS)
2024 { MIG_RETURN_ERROR(OutP, check_result); }
2025 #endif /* defined(__MIG_check__Request__vm_write_t__defined) */
2026
2027 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2028
2029 OutP->RetCode = vm_write(target_task, In0P->address, (vm_offset_t)(In0P->data.address), In0P->dataCnt);
2030 vm_map_deallocate(target_task);
2031 #if __MigKernelSpecificCode
2032 #endif /* __MigKernelSpecificCode */
2033
2034 OutP->NDR = NDR_record;
2035
2036
2037 __AfterRcvRpc(3807, "vm_write")
2038 }
2039
2040 #if ( __MigTypeCheck )
2041 #if __MIG_check__Request__vm_map_subsystem__
2042 #if !defined(__MIG_check__Request__vm_copy_t__defined)
2043 #define __MIG_check__Request__vm_copy_t__defined
2044
__MIG_check__Request__vm_copy_t(__Request__vm_copy_t * In0P)2045 mig_internal kern_return_t __MIG_check__Request__vm_copy_t(__attribute__((__unused__)) __Request__vm_copy_t *In0P)
2046 {
2047
2048 typedef __Request__vm_copy_t __Request;
2049 #if __MigTypeCheck
2050 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2051 (In0P->msgh_body.msgh_descriptor_count != 0) ||
2052 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2053 return MIG_BAD_ARGUMENTS;
2054 #endif /* __MigTypeCheck */
2055
2056 return MACH_MSG_SUCCESS;
2057 }
2058 #endif /* !defined(__MIG_check__Request__vm_copy_t__defined) */
2059 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2060 #endif /* ( __MigTypeCheck ) */
2061
2062
2063 /* Routine vm_copy */
2064 #ifdef mig_external
2065 mig_external
2066 #else
2067 extern
2068 #endif /* mig_external */
vm_copy(target_task,source_address,size,dest_address)2069 kern_return_t vm_copy
2070 #if defined(LINTLIBRARY)
2071 (target_task, source_address, size, dest_address)
2072 vm_map_t target_task;
2073 vm_address_t source_address;
2074 vm_size_t size;
2075 vm_address_t dest_address;
2076 { return vm_copy(target_task, source_address, size, dest_address); }
2077 #else
2078 (
2079 vm_map_t target_task,
2080 vm_address_t source_address,
2081 vm_size_t size,
2082 vm_address_t dest_address
2083 );
2084 #endif /* defined(LINTLIBRARY) */
2085
2086 /* Routine vm_copy */
_Xvm_copy(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2087 mig_internal novalue _Xvm_copy
2088 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2089 {
2090
2091 #ifdef __MigPackStructs
2092 #pragma pack(4)
2093 #endif
2094 typedef struct {
2095 mach_msg_header_t Head;
2096 /* start of the kernel processed data */
2097 mach_msg_body_t msgh_body;
2098 /* end of the kernel processed data */
2099 NDR_record_t NDR;
2100 vm_address_t source_address;
2101 vm_size_t size;
2102 vm_address_t dest_address;
2103 mach_msg_trailer_t trailer;
2104 } Request;
2105 #ifdef __MigPackStructs
2106 #pragma pack()
2107 #endif
2108 typedef __Request__vm_copy_t __Request;
2109 typedef __Reply__vm_copy_t Reply;
2110
2111 /*
2112 * typedef struct {
2113 * mach_msg_header_t Head;
2114 * NDR_record_t NDR;
2115 * kern_return_t RetCode;
2116 * } mig_reply_error_t;
2117 */
2118
2119 Request *In0P = (Request *) InHeadP;
2120 Reply *OutP = (Reply *) OutHeadP;
2121 #ifdef __MIG_check__Request__vm_copy_t__defined
2122 kern_return_t check_result;
2123 #endif /* __MIG_check__Request__vm_copy_t__defined */
2124
2125 #if __MigKernelSpecificCode
2126 #else
2127 #endif /* __MigKernelSpecificCode */
2128 vm_map_t target_task;
2129
2130 __DeclareRcvRpc(3808, "vm_copy")
2131 __BeforeRcvRpc(3808, "vm_copy")
2132 /* RetCArg=0x0 rtSimpleRequest=0 */
2133
2134 #if defined(__MIG_check__Request__vm_copy_t__defined)
2135 check_result = __MIG_check__Request__vm_copy_t((__Request *)In0P);
2136 if (check_result != MACH_MSG_SUCCESS)
2137 { MIG_RETURN_ERROR(OutP, check_result); }
2138 #endif /* defined(__MIG_check__Request__vm_copy_t__defined) */
2139
2140 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2141
2142 OutP->RetCode = vm_copy(target_task, In0P->source_address, In0P->size, In0P->dest_address);
2143 vm_map_deallocate(target_task);
2144 #if __MigKernelSpecificCode
2145 #endif /* __MigKernelSpecificCode */
2146
2147 OutP->NDR = NDR_record;
2148
2149
2150 __AfterRcvRpc(3808, "vm_copy")
2151 }
2152
2153 #if ( __MigTypeCheck )
2154 #if __MIG_check__Request__vm_map_subsystem__
2155 #if !defined(__MIG_check__Request__vm_read_overwrite_t__defined)
2156 #define __MIG_check__Request__vm_read_overwrite_t__defined
2157
__MIG_check__Request__vm_read_overwrite_t(__Request__vm_read_overwrite_t * In0P)2158 mig_internal kern_return_t __MIG_check__Request__vm_read_overwrite_t(__attribute__((__unused__)) __Request__vm_read_overwrite_t *In0P)
2159 {
2160
2161 typedef __Request__vm_read_overwrite_t __Request;
2162 #if __MigTypeCheck
2163 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2164 (In0P->msgh_body.msgh_descriptor_count != 0) ||
2165 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2166 return MIG_BAD_ARGUMENTS;
2167 #endif /* __MigTypeCheck */
2168
2169 return MACH_MSG_SUCCESS;
2170 }
2171 #endif /* !defined(__MIG_check__Request__vm_read_overwrite_t__defined) */
2172 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2173 #endif /* ( __MigTypeCheck ) */
2174
2175
2176 /* Routine vm_read_overwrite */
2177 #ifdef mig_external
2178 mig_external
2179 #else
2180 extern
2181 #endif /* mig_external */
vm_read_overwrite(target_task,address,size,data,outsize)2182 kern_return_t vm_read_overwrite
2183 #if defined(LINTLIBRARY)
2184 (target_task, address, size, data, outsize)
2185 vm_map_t target_task;
2186 vm_address_t address;
2187 vm_size_t size;
2188 vm_address_t data;
2189 vm_size_t *outsize;
2190 { return vm_read_overwrite(target_task, address, size, data, outsize); }
2191 #else
2192 (
2193 vm_map_t target_task,
2194 vm_address_t address,
2195 vm_size_t size,
2196 vm_address_t data,
2197 vm_size_t *outsize
2198 );
2199 #endif /* defined(LINTLIBRARY) */
2200
2201 /* Routine vm_read_overwrite */
_Xvm_read_overwrite(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2202 mig_internal novalue _Xvm_read_overwrite
2203 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2204 {
2205
2206 #ifdef __MigPackStructs
2207 #pragma pack(4)
2208 #endif
2209 typedef struct {
2210 mach_msg_header_t Head;
2211 /* start of the kernel processed data */
2212 mach_msg_body_t msgh_body;
2213 /* end of the kernel processed data */
2214 NDR_record_t NDR;
2215 vm_address_t address;
2216 vm_size_t size;
2217 vm_address_t data;
2218 mach_msg_trailer_t trailer;
2219 } Request;
2220 #ifdef __MigPackStructs
2221 #pragma pack()
2222 #endif
2223 typedef __Request__vm_read_overwrite_t __Request;
2224 typedef __Reply__vm_read_overwrite_t Reply;
2225
2226 /*
2227 * typedef struct {
2228 * mach_msg_header_t Head;
2229 * NDR_record_t NDR;
2230 * kern_return_t RetCode;
2231 * } mig_reply_error_t;
2232 */
2233
2234 Request *In0P = (Request *) InHeadP;
2235 Reply *OutP = (Reply *) OutHeadP;
2236 #ifdef __MIG_check__Request__vm_read_overwrite_t__defined
2237 kern_return_t check_result;
2238 #endif /* __MIG_check__Request__vm_read_overwrite_t__defined */
2239
2240 #if __MigKernelSpecificCode
2241 #else
2242 #endif /* __MigKernelSpecificCode */
2243 vm_map_t target_task;
2244
2245 __DeclareRcvRpc(3809, "vm_read_overwrite")
2246 __BeforeRcvRpc(3809, "vm_read_overwrite")
2247 /* RetCArg=0x0 rtSimpleRequest=0 */
2248
2249 #if defined(__MIG_check__Request__vm_read_overwrite_t__defined)
2250 check_result = __MIG_check__Request__vm_read_overwrite_t((__Request *)In0P);
2251 if (check_result != MACH_MSG_SUCCESS)
2252 { MIG_RETURN_ERROR(OutP, check_result); }
2253 #endif /* defined(__MIG_check__Request__vm_read_overwrite_t__defined) */
2254
2255 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2256
2257 OutP->RetCode = vm_read_overwrite(target_task, In0P->address, In0P->size, In0P->data, &OutP->outsize);
2258 vm_map_deallocate(target_task);
2259 if (OutP->RetCode != KERN_SUCCESS) {
2260 MIG_RETURN_ERROR(OutP, OutP->RetCode);
2261 }
2262 #if __MigKernelSpecificCode
2263 #endif /* __MigKernelSpecificCode */
2264
2265 OutP->NDR = NDR_record;
2266
2267
2268 OutP->Head.msgh_size = (sizeof(Reply));
2269 __AfterRcvRpc(3809, "vm_read_overwrite")
2270 }
2271
2272 #if ( __MigTypeCheck )
2273 #if __MIG_check__Request__vm_map_subsystem__
2274 #if !defined(__MIG_check__Request__vm_msync_t__defined)
2275 #define __MIG_check__Request__vm_msync_t__defined
2276
__MIG_check__Request__vm_msync_t(__Request__vm_msync_t * In0P)2277 mig_internal kern_return_t __MIG_check__Request__vm_msync_t(__attribute__((__unused__)) __Request__vm_msync_t *In0P)
2278 {
2279
2280 typedef __Request__vm_msync_t __Request;
2281 #if __MigTypeCheck
2282 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2283 (In0P->msgh_body.msgh_descriptor_count != 0) ||
2284 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2285 return MIG_BAD_ARGUMENTS;
2286 #endif /* __MigTypeCheck */
2287
2288 return MACH_MSG_SUCCESS;
2289 }
2290 #endif /* !defined(__MIG_check__Request__vm_msync_t__defined) */
2291 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2292 #endif /* ( __MigTypeCheck ) */
2293
2294
2295 /* Routine vm_msync */
2296 #ifdef mig_external
2297 mig_external
2298 #else
2299 extern
2300 #endif /* mig_external */
vm_msync(target_task,address,size,sync_flags)2301 kern_return_t vm_msync
2302 #if defined(LINTLIBRARY)
2303 (target_task, address, size, sync_flags)
2304 vm_map_t target_task;
2305 vm_address_t address;
2306 vm_size_t size;
2307 vm_sync_t sync_flags;
2308 { return vm_msync(target_task, address, size, sync_flags); }
2309 #else
2310 (
2311 vm_map_t target_task,
2312 vm_address_t address,
2313 vm_size_t size,
2314 vm_sync_t sync_flags
2315 );
2316 #endif /* defined(LINTLIBRARY) */
2317
2318 /* Routine vm_msync */
_Xvm_msync(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2319 mig_internal novalue _Xvm_msync
2320 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2321 {
2322
2323 #ifdef __MigPackStructs
2324 #pragma pack(4)
2325 #endif
2326 typedef struct {
2327 mach_msg_header_t Head;
2328 /* start of the kernel processed data */
2329 mach_msg_body_t msgh_body;
2330 /* end of the kernel processed data */
2331 NDR_record_t NDR;
2332 vm_address_t address;
2333 vm_size_t size;
2334 vm_sync_t sync_flags;
2335 mach_msg_trailer_t trailer;
2336 } Request;
2337 #ifdef __MigPackStructs
2338 #pragma pack()
2339 #endif
2340 typedef __Request__vm_msync_t __Request;
2341 typedef __Reply__vm_msync_t Reply;
2342
2343 /*
2344 * typedef struct {
2345 * mach_msg_header_t Head;
2346 * NDR_record_t NDR;
2347 * kern_return_t RetCode;
2348 * } mig_reply_error_t;
2349 */
2350
2351 Request *In0P = (Request *) InHeadP;
2352 Reply *OutP = (Reply *) OutHeadP;
2353 #ifdef __MIG_check__Request__vm_msync_t__defined
2354 kern_return_t check_result;
2355 #endif /* __MIG_check__Request__vm_msync_t__defined */
2356
2357 #if __MigKernelSpecificCode
2358 #else
2359 #endif /* __MigKernelSpecificCode */
2360 vm_map_t target_task;
2361
2362 __DeclareRcvRpc(3810, "vm_msync")
2363 __BeforeRcvRpc(3810, "vm_msync")
2364 /* RetCArg=0x0 rtSimpleRequest=0 */
2365
2366 #if defined(__MIG_check__Request__vm_msync_t__defined)
2367 check_result = __MIG_check__Request__vm_msync_t((__Request *)In0P);
2368 if (check_result != MACH_MSG_SUCCESS)
2369 { MIG_RETURN_ERROR(OutP, check_result); }
2370 #endif /* defined(__MIG_check__Request__vm_msync_t__defined) */
2371
2372 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2373
2374 OutP->RetCode = vm_msync(target_task, In0P->address, In0P->size, In0P->sync_flags);
2375 vm_map_deallocate(target_task);
2376 #if __MigKernelSpecificCode
2377 #endif /* __MigKernelSpecificCode */
2378
2379 OutP->NDR = NDR_record;
2380
2381
2382 __AfterRcvRpc(3810, "vm_msync")
2383 }
2384
2385 #if ( __MigTypeCheck )
2386 #if __MIG_check__Request__vm_map_subsystem__
2387 #if !defined(__MIG_check__Request__vm_behavior_set_t__defined)
2388 #define __MIG_check__Request__vm_behavior_set_t__defined
2389
__MIG_check__Request__vm_behavior_set_t(__Request__vm_behavior_set_t * In0P)2390 mig_internal kern_return_t __MIG_check__Request__vm_behavior_set_t(__attribute__((__unused__)) __Request__vm_behavior_set_t *In0P)
2391 {
2392
2393 typedef __Request__vm_behavior_set_t __Request;
2394 #if __MigTypeCheck
2395 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2396 (In0P->msgh_body.msgh_descriptor_count != 0) ||
2397 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2398 return MIG_BAD_ARGUMENTS;
2399 #endif /* __MigTypeCheck */
2400
2401 return MACH_MSG_SUCCESS;
2402 }
2403 #endif /* !defined(__MIG_check__Request__vm_behavior_set_t__defined) */
2404 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2405 #endif /* ( __MigTypeCheck ) */
2406
2407
2408 /* Routine vm_behavior_set */
2409 #ifdef mig_external
2410 mig_external
2411 #else
2412 extern
2413 #endif /* mig_external */
vm_behavior_set(target_task,address,size,new_behavior)2414 kern_return_t vm_behavior_set
2415 #if defined(LINTLIBRARY)
2416 (target_task, address, size, new_behavior)
2417 vm_map_t target_task;
2418 vm_address_t address;
2419 vm_size_t size;
2420 vm_behavior_t new_behavior;
2421 { return vm_behavior_set(target_task, address, size, new_behavior); }
2422 #else
2423 (
2424 vm_map_t target_task,
2425 vm_address_t address,
2426 vm_size_t size,
2427 vm_behavior_t new_behavior
2428 );
2429 #endif /* defined(LINTLIBRARY) */
2430
2431 /* Routine vm_behavior_set */
_Xvm_behavior_set(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2432 mig_internal novalue _Xvm_behavior_set
2433 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2434 {
2435
2436 #ifdef __MigPackStructs
2437 #pragma pack(4)
2438 #endif
2439 typedef struct {
2440 mach_msg_header_t Head;
2441 /* start of the kernel processed data */
2442 mach_msg_body_t msgh_body;
2443 /* end of the kernel processed data */
2444 NDR_record_t NDR;
2445 vm_address_t address;
2446 vm_size_t size;
2447 vm_behavior_t new_behavior;
2448 mach_msg_trailer_t trailer;
2449 } Request;
2450 #ifdef __MigPackStructs
2451 #pragma pack()
2452 #endif
2453 typedef __Request__vm_behavior_set_t __Request;
2454 typedef __Reply__vm_behavior_set_t Reply;
2455
2456 /*
2457 * typedef struct {
2458 * mach_msg_header_t Head;
2459 * NDR_record_t NDR;
2460 * kern_return_t RetCode;
2461 * } mig_reply_error_t;
2462 */
2463
2464 Request *In0P = (Request *) InHeadP;
2465 Reply *OutP = (Reply *) OutHeadP;
2466 #ifdef __MIG_check__Request__vm_behavior_set_t__defined
2467 kern_return_t check_result;
2468 #endif /* __MIG_check__Request__vm_behavior_set_t__defined */
2469
2470 #if __MigKernelSpecificCode
2471 #else
2472 #endif /* __MigKernelSpecificCode */
2473 vm_map_t target_task;
2474
2475 __DeclareRcvRpc(3811, "vm_behavior_set")
2476 __BeforeRcvRpc(3811, "vm_behavior_set")
2477 /* RetCArg=0x0 rtSimpleRequest=0 */
2478
2479 #if defined(__MIG_check__Request__vm_behavior_set_t__defined)
2480 check_result = __MIG_check__Request__vm_behavior_set_t((__Request *)In0P);
2481 if (check_result != MACH_MSG_SUCCESS)
2482 { MIG_RETURN_ERROR(OutP, check_result); }
2483 #endif /* defined(__MIG_check__Request__vm_behavior_set_t__defined) */
2484
2485 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2486
2487 OutP->RetCode = vm_behavior_set(target_task, In0P->address, In0P->size, In0P->new_behavior);
2488 vm_map_deallocate(target_task);
2489 #if __MigKernelSpecificCode
2490 #endif /* __MigKernelSpecificCode */
2491
2492 OutP->NDR = NDR_record;
2493
2494
2495 __AfterRcvRpc(3811, "vm_behavior_set")
2496 }
2497
2498 #if ( __MigTypeCheck )
2499 #if __MIG_check__Request__vm_map_subsystem__
2500 #if !defined(__MIG_check__Request__vm_machine_attribute_t__defined)
2501 #define __MIG_check__Request__vm_machine_attribute_t__defined
2502
__MIG_check__Request__vm_machine_attribute_t(__Request__vm_machine_attribute_t * In0P)2503 mig_internal kern_return_t __MIG_check__Request__vm_machine_attribute_t(__attribute__((__unused__)) __Request__vm_machine_attribute_t *In0P)
2504 {
2505
2506 typedef __Request__vm_machine_attribute_t __Request;
2507 #if __MigTypeCheck
2508 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2509 (In0P->msgh_body.msgh_descriptor_count != 0) ||
2510 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2511 return MIG_BAD_ARGUMENTS;
2512 #endif /* __MigTypeCheck */
2513
2514 return MACH_MSG_SUCCESS;
2515 }
2516 #endif /* !defined(__MIG_check__Request__vm_machine_attribute_t__defined) */
2517 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2518 #endif /* ( __MigTypeCheck ) */
2519
2520
2521 /* Routine vm_machine_attribute */
2522 #ifdef mig_external
2523 mig_external
2524 #else
2525 extern
2526 #endif /* mig_external */
vm_machine_attribute(target_task,address,size,attribute,value)2527 kern_return_t vm_machine_attribute
2528 #if defined(LINTLIBRARY)
2529 (target_task, address, size, attribute, value)
2530 vm_map_t target_task;
2531 vm_address_t address;
2532 vm_size_t size;
2533 vm_machine_attribute_t attribute;
2534 vm_machine_attribute_val_t *value;
2535 { return vm_machine_attribute(target_task, address, size, attribute, value); }
2536 #else
2537 (
2538 vm_map_t target_task,
2539 vm_address_t address,
2540 vm_size_t size,
2541 vm_machine_attribute_t attribute,
2542 vm_machine_attribute_val_t *value
2543 );
2544 #endif /* defined(LINTLIBRARY) */
2545
2546 /* Routine vm_machine_attribute */
_Xvm_machine_attribute(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2547 mig_internal novalue _Xvm_machine_attribute
2548 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2549 {
2550
2551 #ifdef __MigPackStructs
2552 #pragma pack(4)
2553 #endif
2554 typedef struct {
2555 mach_msg_header_t Head;
2556 /* start of the kernel processed data */
2557 mach_msg_body_t msgh_body;
2558 /* end of the kernel processed data */
2559 NDR_record_t NDR;
2560 vm_address_t address;
2561 vm_size_t size;
2562 vm_machine_attribute_t attribute;
2563 vm_machine_attribute_val_t value;
2564 mach_msg_trailer_t trailer;
2565 } Request;
2566 #ifdef __MigPackStructs
2567 #pragma pack()
2568 #endif
2569 typedef __Request__vm_machine_attribute_t __Request;
2570 typedef __Reply__vm_machine_attribute_t Reply;
2571
2572 /*
2573 * typedef struct {
2574 * mach_msg_header_t Head;
2575 * NDR_record_t NDR;
2576 * kern_return_t RetCode;
2577 * } mig_reply_error_t;
2578 */
2579
2580 Request *In0P = (Request *) InHeadP;
2581 Reply *OutP = (Reply *) OutHeadP;
2582 #ifdef __MIG_check__Request__vm_machine_attribute_t__defined
2583 kern_return_t check_result;
2584 #endif /* __MIG_check__Request__vm_machine_attribute_t__defined */
2585
2586 #if __MigKernelSpecificCode
2587 #else
2588 #endif /* __MigKernelSpecificCode */
2589 vm_map_t target_task;
2590
2591 __DeclareRcvRpc(3813, "vm_machine_attribute")
2592 __BeforeRcvRpc(3813, "vm_machine_attribute")
2593 /* RetCArg=0x0 rtSimpleRequest=0 */
2594
2595 #if defined(__MIG_check__Request__vm_machine_attribute_t__defined)
2596 check_result = __MIG_check__Request__vm_machine_attribute_t((__Request *)In0P);
2597 if (check_result != MACH_MSG_SUCCESS)
2598 { MIG_RETURN_ERROR(OutP, check_result); }
2599 #endif /* defined(__MIG_check__Request__vm_machine_attribute_t__defined) */
2600
2601 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2602
2603 OutP->RetCode = vm_machine_attribute(target_task, In0P->address, In0P->size, In0P->attribute, &In0P->value);
2604 vm_map_deallocate(target_task);
2605 if (OutP->RetCode != KERN_SUCCESS) {
2606 MIG_RETURN_ERROR(OutP, OutP->RetCode);
2607 }
2608 #if __MigKernelSpecificCode
2609 #endif /* __MigKernelSpecificCode */
2610
2611 OutP->NDR = NDR_record;
2612
2613
2614 OutP->value = In0P->value;
2615
2616 OutP->Head.msgh_size = (sizeof(Reply));
2617 __AfterRcvRpc(3813, "vm_machine_attribute")
2618 }
2619
2620 #if ( __MigTypeCheck )
2621 #if __MIG_check__Request__vm_map_subsystem__
2622 #if !defined(__MIG_check__Request__vm_remap_t__defined)
2623 #define __MIG_check__Request__vm_remap_t__defined
2624
__MIG_check__Request__vm_remap_t(__Request__vm_remap_t * In0P)2625 mig_internal kern_return_t __MIG_check__Request__vm_remap_t(__attribute__((__unused__)) __Request__vm_remap_t *In0P)
2626 {
2627
2628 typedef __Request__vm_remap_t __Request;
2629 #if __MigTypeCheck
2630 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2631 (In0P->msgh_body.msgh_descriptor_count != 1) ||
2632 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2633 return MIG_BAD_ARGUMENTS;
2634 #endif /* __MigTypeCheck */
2635
2636 #if __MigTypeCheck
2637 if (In0P->src_task.type != MACH_MSG_PORT_DESCRIPTOR ||
2638 In0P->src_task.disposition != 17)
2639 return MIG_TYPE_ERROR;
2640 #endif /* __MigTypeCheck */
2641
2642 return MACH_MSG_SUCCESS;
2643 }
2644 #endif /* !defined(__MIG_check__Request__vm_remap_t__defined) */
2645 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2646 #endif /* ( __MigTypeCheck ) */
2647
2648
2649 /* Routine vm_remap */
2650 #ifdef mig_external
2651 mig_external
2652 #else
2653 extern
2654 #endif /* mig_external */
vm_remap(target_task,target_address,size,mask,flags,src_task,src_address,copy,cur_protection,max_protection,inheritance)2655 kern_return_t vm_remap
2656 #if defined(LINTLIBRARY)
2657 (target_task, target_address, size, mask, flags, src_task, src_address, copy, cur_protection, max_protection, inheritance)
2658 vm_map_t target_task;
2659 vm_address_t *target_address;
2660 vm_size_t size;
2661 vm_address_t mask;
2662 int flags;
2663 vm_map_t src_task;
2664 vm_address_t src_address;
2665 boolean_t copy;
2666 vm_prot_t *cur_protection;
2667 vm_prot_t *max_protection;
2668 vm_inherit_t inheritance;
2669 { return vm_remap(target_task, target_address, size, mask, flags, src_task, src_address, copy, cur_protection, max_protection, inheritance); }
2670 #else
2671 (
2672 vm_map_t target_task,
2673 vm_address_t *target_address,
2674 vm_size_t size,
2675 vm_address_t mask,
2676 int flags,
2677 vm_map_t src_task,
2678 vm_address_t src_address,
2679 boolean_t copy,
2680 vm_prot_t *cur_protection,
2681 vm_prot_t *max_protection,
2682 vm_inherit_t inheritance
2683 );
2684 #endif /* defined(LINTLIBRARY) */
2685
2686 /* Routine vm_remap */
_Xvm_remap(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2687 mig_internal novalue _Xvm_remap
2688 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2689 {
2690
2691 #ifdef __MigPackStructs
2692 #pragma pack(4)
2693 #endif
2694 typedef struct {
2695 mach_msg_header_t Head;
2696 /* start of the kernel processed data */
2697 mach_msg_body_t msgh_body;
2698 mach_msg_port_descriptor_t src_task;
2699 /* end of the kernel processed data */
2700 NDR_record_t NDR;
2701 vm_address_t target_address;
2702 vm_size_t size;
2703 vm_address_t mask;
2704 int flags;
2705 vm_address_t src_address;
2706 boolean_t copy;
2707 vm_inherit_t inheritance;
2708 mach_msg_trailer_t trailer;
2709 } Request;
2710 #ifdef __MigPackStructs
2711 #pragma pack()
2712 #endif
2713 typedef __Request__vm_remap_t __Request;
2714 typedef __Reply__vm_remap_t Reply;
2715
2716 /*
2717 * typedef struct {
2718 * mach_msg_header_t Head;
2719 * NDR_record_t NDR;
2720 * kern_return_t RetCode;
2721 * } mig_reply_error_t;
2722 */
2723
2724 Request *In0P = (Request *) InHeadP;
2725 Reply *OutP = (Reply *) OutHeadP;
2726 #ifdef __MIG_check__Request__vm_remap_t__defined
2727 kern_return_t check_result;
2728 #endif /* __MIG_check__Request__vm_remap_t__defined */
2729
2730 #if __MigKernelSpecificCode
2731 #else
2732 #endif /* __MigKernelSpecificCode */
2733 vm_map_t target_task;
2734 vm_map_t src_task;
2735
2736 __DeclareRcvRpc(3814, "vm_remap")
2737 __BeforeRcvRpc(3814, "vm_remap")
2738 /* RetCArg=0x0 rtSimpleRequest=0 */
2739
2740 #if defined(__MIG_check__Request__vm_remap_t__defined)
2741 check_result = __MIG_check__Request__vm_remap_t((__Request *)In0P);
2742 if (check_result != MACH_MSG_SUCCESS)
2743 { MIG_RETURN_ERROR(OutP, check_result); }
2744 #endif /* defined(__MIG_check__Request__vm_remap_t__defined) */
2745
2746 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2747
2748 src_task = convert_port_to_map(In0P->src_task.name);
2749
2750 OutP->RetCode = vm_remap(target_task, &In0P->target_address, In0P->size, In0P->mask, In0P->flags, src_task, In0P->src_address, In0P->copy, &OutP->cur_protection, &OutP->max_protection, In0P->inheritance);
2751 vm_map_deallocate(src_task);
2752 vm_map_deallocate(target_task);
2753 if (OutP->RetCode != KERN_SUCCESS) {
2754 MIG_RETURN_ERROR(OutP, OutP->RetCode);
2755 }
2756 #if __MigKernelSpecificCode
2757
2758 if (IP_VALID((ipc_port_t)In0P->src_task.name))
2759 ipc_port_release_send((ipc_port_t)In0P->src_task.name);
2760 #endif /* __MigKernelSpecificCode */
2761
2762 OutP->NDR = NDR_record;
2763
2764
2765 OutP->target_address = In0P->target_address;
2766
2767 OutP->Head.msgh_size = (sizeof(Reply));
2768 __AfterRcvRpc(3814, "vm_remap")
2769 }
2770
2771 #if ( __MigTypeCheck )
2772 #if __MIG_check__Request__vm_map_subsystem__
2773 #if !defined(__MIG_check__Request__task_wire_t__defined)
2774 #define __MIG_check__Request__task_wire_t__defined
2775
__MIG_check__Request__task_wire_t(__Request__task_wire_t * In0P)2776 mig_internal kern_return_t __MIG_check__Request__task_wire_t(__attribute__((__unused__)) __Request__task_wire_t *In0P)
2777 {
2778
2779 typedef __Request__task_wire_t __Request;
2780 #if __MigTypeCheck
2781 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2782 (In0P->msgh_body.msgh_descriptor_count != 0) ||
2783 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2784 return MIG_BAD_ARGUMENTS;
2785 #endif /* __MigTypeCheck */
2786
2787 return MACH_MSG_SUCCESS;
2788 }
2789 #endif /* !defined(__MIG_check__Request__task_wire_t__defined) */
2790 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2791 #endif /* ( __MigTypeCheck ) */
2792
2793
2794 /* Routine task_wire */
2795 #ifdef mig_external
2796 mig_external
2797 #else
2798 extern
2799 #endif /* mig_external */
task_wire(target_task,must_wire)2800 kern_return_t task_wire
2801 #if defined(LINTLIBRARY)
2802 (target_task, must_wire)
2803 vm_map_t target_task;
2804 boolean_t must_wire;
2805 { return task_wire(target_task, must_wire); }
2806 #else
2807 (
2808 vm_map_t target_task,
2809 boolean_t must_wire
2810 );
2811 #endif /* defined(LINTLIBRARY) */
2812
2813 /* Routine task_wire */
_Xtask_wire(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2814 mig_internal novalue _Xtask_wire
2815 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2816 {
2817
2818 #ifdef __MigPackStructs
2819 #pragma pack(4)
2820 #endif
2821 typedef struct {
2822 mach_msg_header_t Head;
2823 /* start of the kernel processed data */
2824 mach_msg_body_t msgh_body;
2825 /* end of the kernel processed data */
2826 NDR_record_t NDR;
2827 boolean_t must_wire;
2828 mach_msg_trailer_t trailer;
2829 } Request;
2830 #ifdef __MigPackStructs
2831 #pragma pack()
2832 #endif
2833 typedef __Request__task_wire_t __Request;
2834 typedef __Reply__task_wire_t Reply;
2835
2836 /*
2837 * typedef struct {
2838 * mach_msg_header_t Head;
2839 * NDR_record_t NDR;
2840 * kern_return_t RetCode;
2841 * } mig_reply_error_t;
2842 */
2843
2844 Request *In0P = (Request *) InHeadP;
2845 Reply *OutP = (Reply *) OutHeadP;
2846 #ifdef __MIG_check__Request__task_wire_t__defined
2847 kern_return_t check_result;
2848 #endif /* __MIG_check__Request__task_wire_t__defined */
2849
2850 #if __MigKernelSpecificCode
2851 #else
2852 #endif /* __MigKernelSpecificCode */
2853 vm_map_t target_task;
2854
2855 __DeclareRcvRpc(3815, "task_wire")
2856 __BeforeRcvRpc(3815, "task_wire")
2857 /* RetCArg=0x0 rtSimpleRequest=0 */
2858
2859 #if defined(__MIG_check__Request__task_wire_t__defined)
2860 check_result = __MIG_check__Request__task_wire_t((__Request *)In0P);
2861 if (check_result != MACH_MSG_SUCCESS)
2862 { MIG_RETURN_ERROR(OutP, check_result); }
2863 #endif /* defined(__MIG_check__Request__task_wire_t__defined) */
2864
2865 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
2866
2867 OutP->RetCode = task_wire(target_task, In0P->must_wire);
2868 vm_map_deallocate(target_task);
2869 #if __MigKernelSpecificCode
2870 #endif /* __MigKernelSpecificCode */
2871
2872 OutP->NDR = NDR_record;
2873
2874
2875 __AfterRcvRpc(3815, "task_wire")
2876 }
2877
2878 #if ( __MigTypeCheck )
2879 #if __MIG_check__Request__vm_map_subsystem__
2880 #if !defined(__MIG_check__Request__mach_make_memory_entry_t__defined)
2881 #define __MIG_check__Request__mach_make_memory_entry_t__defined
2882
__MIG_check__Request__mach_make_memory_entry_t(__Request__mach_make_memory_entry_t * In0P)2883 mig_internal kern_return_t __MIG_check__Request__mach_make_memory_entry_t(__attribute__((__unused__)) __Request__mach_make_memory_entry_t *In0P)
2884 {
2885
2886 typedef __Request__mach_make_memory_entry_t __Request;
2887 #if __MigTypeCheck
2888 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
2889 (In0P->msgh_body.msgh_descriptor_count != 1) ||
2890 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
2891 return MIG_BAD_ARGUMENTS;
2892 #endif /* __MigTypeCheck */
2893
2894 #if __MigTypeCheck
2895 if (In0P->parent_entry.type != MACH_MSG_PORT_DESCRIPTOR ||
2896 In0P->parent_entry.disposition != 17)
2897 return MIG_TYPE_ERROR;
2898 #endif /* __MigTypeCheck */
2899
2900 return MACH_MSG_SUCCESS;
2901 }
2902 #endif /* !defined(__MIG_check__Request__mach_make_memory_entry_t__defined) */
2903 #endif /* __MIG_check__Request__vm_map_subsystem__ */
2904 #endif /* ( __MigTypeCheck ) */
2905
2906
2907 /* Routine mach_make_memory_entry */
2908 #ifdef mig_external
2909 mig_external
2910 #else
2911 extern
2912 #endif /* mig_external */
mach_make_memory_entry(target_task,size,offset,permission,object_handle,parent_entry)2913 kern_return_t mach_make_memory_entry
2914 #if defined(LINTLIBRARY)
2915 (target_task, size, offset, permission, object_handle, parent_entry)
2916 vm_map_t target_task;
2917 vm_size_t *size;
2918 vm_offset_t offset;
2919 vm_prot_t permission;
2920 mem_entry_name_port_t *object_handle;
2921 mem_entry_name_port_t parent_entry;
2922 { return mach_make_memory_entry(target_task, size, offset, permission, object_handle, parent_entry); }
2923 #else
2924 (
2925 vm_map_t target_task,
2926 vm_size_t *size,
2927 vm_offset_t offset,
2928 vm_prot_t permission,
2929 mem_entry_name_port_t *object_handle,
2930 mem_entry_name_port_t parent_entry
2931 );
2932 #endif /* defined(LINTLIBRARY) */
2933
2934 /* Routine mach_make_memory_entry */
_Xmach_make_memory_entry(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)2935 mig_internal novalue _Xmach_make_memory_entry
2936 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
2937 {
2938
2939 #ifdef __MigPackStructs
2940 #pragma pack(4)
2941 #endif
2942 typedef struct {
2943 mach_msg_header_t Head;
2944 /* start of the kernel processed data */
2945 mach_msg_body_t msgh_body;
2946 mach_msg_port_descriptor_t parent_entry;
2947 /* end of the kernel processed data */
2948 NDR_record_t NDR;
2949 vm_size_t size;
2950 vm_offset_t offset;
2951 vm_prot_t permission;
2952 mach_msg_trailer_t trailer;
2953 } Request;
2954 #ifdef __MigPackStructs
2955 #pragma pack()
2956 #endif
2957 typedef __Request__mach_make_memory_entry_t __Request;
2958 typedef __Reply__mach_make_memory_entry_t Reply;
2959
2960 /*
2961 * typedef struct {
2962 * mach_msg_header_t Head;
2963 * NDR_record_t NDR;
2964 * kern_return_t RetCode;
2965 * } mig_reply_error_t;
2966 */
2967
2968 Request *In0P = (Request *) InHeadP;
2969 Reply *OutP = (Reply *) OutHeadP;
2970 #ifdef __MIG_check__Request__mach_make_memory_entry_t__defined
2971 kern_return_t check_result;
2972 #endif /* __MIG_check__Request__mach_make_memory_entry_t__defined */
2973
2974 #if __MigKernelSpecificCode
2975 #if UseStaticTemplates
2976 const static mach_msg_port_descriptor_t object_handleTemplate = {
2977 .name = MACH_PORT_NULL,
2978 .disposition = 17,
2979 .type = MACH_MSG_PORT_DESCRIPTOR,
2980 };
2981 #endif /* UseStaticTemplates */
2982
2983 #else
2984 #if UseStaticTemplates
2985 const static mach_msg_port_descriptor_t object_handleTemplate = {
2986 .name = MACH_PORT_NULL,
2987 .disposition = 17,
2988 .type = MACH_MSG_PORT_DESCRIPTOR,
2989 };
2990 #endif /* UseStaticTemplates */
2991
2992 #endif /* __MigKernelSpecificCode */
2993 kern_return_t RetCode;
2994 vm_map_t target_task;
2995 mem_entry_name_port_t object_handle;
2996
2997 __DeclareRcvRpc(3816, "mach_make_memory_entry")
2998 __BeforeRcvRpc(3816, "mach_make_memory_entry")
2999 /* RetCArg=0x0 rtSimpleRequest=0 */
3000
3001 #if defined(__MIG_check__Request__mach_make_memory_entry_t__defined)
3002 check_result = __MIG_check__Request__mach_make_memory_entry_t((__Request *)In0P);
3003 if (check_result != MACH_MSG_SUCCESS)
3004 { MIG_RETURN_ERROR(OutP, check_result); }
3005 #endif /* defined(__MIG_check__Request__mach_make_memory_entry_t__defined) */
3006
3007 #if UseStaticTemplates
3008 OutP->object_handle = object_handleTemplate;
3009 #else /* UseStaticTemplates */
3010 #if __MigKernelSpecificCode
3011 OutP->object_handle.disposition = 17;
3012 #else
3013 OutP->object_handle.disposition = 17;
3014 #endif /* __MigKernelSpecificCode */
3015 OutP->object_handle.type = MACH_MSG_PORT_DESCRIPTOR;
3016 #endif /* UseStaticTemplates */
3017
3018
3019 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
3020
3021 RetCode = mach_make_memory_entry(target_task, &In0P->size, In0P->offset, In0P->permission, &object_handle, null_conversion(In0P->parent_entry.name));
3022 vm_map_deallocate(target_task);
3023 if (RetCode != KERN_SUCCESS) {
3024 MIG_RETURN_ERROR(OutP, RetCode);
3025 }
3026 #if __MigKernelSpecificCode
3027
3028 if (IP_VALID((ipc_port_t)In0P->parent_entry.name))
3029 ipc_port_release_send((ipc_port_t)In0P->parent_entry.name);
3030 #endif /* __MigKernelSpecificCode */
3031 OutP->object_handle.name = (mach_port_t)null_conversion(object_handle);
3032
3033
3034 OutP->NDR = NDR_record;
3035
3036
3037 OutP->size = In0P->size;
3038
3039 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
3040 OutP->Head.msgh_size = (sizeof(Reply));
3041 OutP->msgh_body.msgh_descriptor_count = 1;
3042 __AfterRcvRpc(3816, "mach_make_memory_entry")
3043 }
3044
3045 #if ( __MigTypeCheck )
3046 #if __MIG_check__Request__vm_map_subsystem__
3047 #if !defined(__MIG_check__Request__vm_map_page_query_t__defined)
3048 #define __MIG_check__Request__vm_map_page_query_t__defined
3049
__MIG_check__Request__vm_map_page_query_t(__Request__vm_map_page_query_t * In0P)3050 mig_internal kern_return_t __MIG_check__Request__vm_map_page_query_t(__attribute__((__unused__)) __Request__vm_map_page_query_t *In0P)
3051 {
3052
3053 typedef __Request__vm_map_page_query_t __Request;
3054 #if __MigTypeCheck
3055 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3056 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3057 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3058 return MIG_BAD_ARGUMENTS;
3059 #endif /* __MigTypeCheck */
3060
3061 return MACH_MSG_SUCCESS;
3062 }
3063 #endif /* !defined(__MIG_check__Request__vm_map_page_query_t__defined) */
3064 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3065 #endif /* ( __MigTypeCheck ) */
3066
3067
3068 /* Routine vm_map_page_query */
3069 #ifdef mig_external
3070 mig_external
3071 #else
3072 extern
3073 #endif /* mig_external */
vm_map_page_query(target_map,offset,disposition,ref_count)3074 kern_return_t vm_map_page_query
3075 #if defined(LINTLIBRARY)
3076 (target_map, offset, disposition, ref_count)
3077 vm_map_t target_map;
3078 vm_offset_t offset;
3079 integer_t *disposition;
3080 integer_t *ref_count;
3081 { return vm_map_page_query(target_map, offset, disposition, ref_count); }
3082 #else
3083 (
3084 vm_map_t target_map,
3085 vm_offset_t offset,
3086 integer_t *disposition,
3087 integer_t *ref_count
3088 );
3089 #endif /* defined(LINTLIBRARY) */
3090
3091 /* Routine vm_map_page_query */
_Xvm_map_page_query(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3092 mig_internal novalue _Xvm_map_page_query
3093 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3094 {
3095
3096 #ifdef __MigPackStructs
3097 #pragma pack(4)
3098 #endif
3099 typedef struct {
3100 mach_msg_header_t Head;
3101 /* start of the kernel processed data */
3102 mach_msg_body_t msgh_body;
3103 /* end of the kernel processed data */
3104 NDR_record_t NDR;
3105 vm_offset_t offset;
3106 mach_msg_trailer_t trailer;
3107 } Request;
3108 #ifdef __MigPackStructs
3109 #pragma pack()
3110 #endif
3111 typedef __Request__vm_map_page_query_t __Request;
3112 typedef __Reply__vm_map_page_query_t Reply;
3113
3114 /*
3115 * typedef struct {
3116 * mach_msg_header_t Head;
3117 * NDR_record_t NDR;
3118 * kern_return_t RetCode;
3119 * } mig_reply_error_t;
3120 */
3121
3122 Request *In0P = (Request *) InHeadP;
3123 Reply *OutP = (Reply *) OutHeadP;
3124 #ifdef __MIG_check__Request__vm_map_page_query_t__defined
3125 kern_return_t check_result;
3126 #endif /* __MIG_check__Request__vm_map_page_query_t__defined */
3127
3128 #if __MigKernelSpecificCode
3129 #else
3130 #endif /* __MigKernelSpecificCode */
3131 vm_map_t target_map;
3132
3133 __DeclareRcvRpc(3817, "vm_map_page_query")
3134 __BeforeRcvRpc(3817, "vm_map_page_query")
3135 /* RetCArg=0x0 rtSimpleRequest=0 */
3136
3137 #if defined(__MIG_check__Request__vm_map_page_query_t__defined)
3138 check_result = __MIG_check__Request__vm_map_page_query_t((__Request *)In0P);
3139 if (check_result != MACH_MSG_SUCCESS)
3140 { MIG_RETURN_ERROR(OutP, check_result); }
3141 #endif /* defined(__MIG_check__Request__vm_map_page_query_t__defined) */
3142
3143 target_map = convert_port_to_map(In0P->Head.msgh_request_port);
3144
3145 OutP->RetCode = vm_map_page_query(target_map, In0P->offset, &OutP->disposition, &OutP->ref_count);
3146 vm_map_deallocate(target_map);
3147 if (OutP->RetCode != KERN_SUCCESS) {
3148 MIG_RETURN_ERROR(OutP, OutP->RetCode);
3149 }
3150 #if __MigKernelSpecificCode
3151 #endif /* __MigKernelSpecificCode */
3152
3153 OutP->NDR = NDR_record;
3154
3155
3156 OutP->Head.msgh_size = (sizeof(Reply));
3157 __AfterRcvRpc(3817, "vm_map_page_query")
3158 }
3159
3160 #if ( __MigTypeCheck )
3161 #if __MIG_check__Request__vm_map_subsystem__
3162 #if !defined(__MIG_check__Request__mach_vm_region_info_t__defined)
3163 #define __MIG_check__Request__mach_vm_region_info_t__defined
3164
__MIG_check__Request__mach_vm_region_info_t(__Request__mach_vm_region_info_t * In0P)3165 mig_internal kern_return_t __MIG_check__Request__mach_vm_region_info_t(__attribute__((__unused__)) __Request__mach_vm_region_info_t *In0P)
3166 {
3167
3168 typedef __Request__mach_vm_region_info_t __Request;
3169 #if __MigTypeCheck
3170 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3171 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3172 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3173 return MIG_BAD_ARGUMENTS;
3174 #endif /* __MigTypeCheck */
3175
3176 return MACH_MSG_SUCCESS;
3177 }
3178 #endif /* !defined(__MIG_check__Request__mach_vm_region_info_t__defined) */
3179 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3180 #endif /* ( __MigTypeCheck ) */
3181
3182
3183 /* Routine mach_vm_region_info */
3184 #ifdef mig_external
3185 mig_external
3186 #else
3187 extern
3188 #endif /* mig_external */
mach_vm_region_info(task,address,region,objects,objectsCnt)3189 kern_return_t mach_vm_region_info
3190 #if defined(LINTLIBRARY)
3191 (task, address, region, objects, objectsCnt)
3192 vm_map_t task;
3193 vm_address_t address;
3194 vm_info_region_t *region;
3195 vm_info_object_array_t *objects;
3196 mach_msg_type_number_t *objectsCnt;
3197 { return mach_vm_region_info(task, address, region, objects, objectsCnt); }
3198 #else
3199 (
3200 vm_map_t task,
3201 vm_address_t address,
3202 vm_info_region_t *region,
3203 vm_info_object_array_t *objects,
3204 mach_msg_type_number_t *objectsCnt
3205 );
3206 #endif /* defined(LINTLIBRARY) */
3207
3208 /* Routine mach_vm_region_info */
_Xmach_vm_region_info(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3209 mig_internal novalue _Xmach_vm_region_info
3210 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3211 {
3212
3213 #ifdef __MigPackStructs
3214 #pragma pack(4)
3215 #endif
3216 typedef struct {
3217 mach_msg_header_t Head;
3218 /* start of the kernel processed data */
3219 mach_msg_body_t msgh_body;
3220 /* end of the kernel processed data */
3221 NDR_record_t NDR;
3222 vm_address_t address;
3223 mach_msg_trailer_t trailer;
3224 } Request;
3225 #ifdef __MigPackStructs
3226 #pragma pack()
3227 #endif
3228 typedef __Request__mach_vm_region_info_t __Request;
3229 typedef __Reply__mach_vm_region_info_t Reply;
3230
3231 /*
3232 * typedef struct {
3233 * mach_msg_header_t Head;
3234 * NDR_record_t NDR;
3235 * kern_return_t RetCode;
3236 * } mig_reply_error_t;
3237 */
3238
3239 Request *In0P = (Request *) InHeadP;
3240 Reply *OutP = (Reply *) OutHeadP;
3241 #ifdef __MIG_check__Request__mach_vm_region_info_t__defined
3242 kern_return_t check_result;
3243 #endif /* __MIG_check__Request__mach_vm_region_info_t__defined */
3244
3245 #if __MigKernelSpecificCode
3246 #if UseStaticTemplates
3247 const static mach_msg_ool_descriptor_t objectsTemplate = {
3248 .address = (void *)0,
3249 .size = 0,
3250 .deallocate = FALSE,
3251 .copy = MACH_MSG_VIRTUAL_COPY,
3252 .type = MACH_MSG_OOL_DESCRIPTOR,
3253 };
3254 #endif /* UseStaticTemplates */
3255
3256 #else
3257 #if UseStaticTemplates
3258 const static mach_msg_ool_descriptor_t objectsTemplate = {
3259 .address = (void *)0,
3260 .size = 0,
3261 .deallocate = FALSE,
3262 .copy = MACH_MSG_VIRTUAL_COPY,
3263 .type = MACH_MSG_OOL_DESCRIPTOR,
3264 };
3265 #endif /* UseStaticTemplates */
3266
3267 #endif /* __MigKernelSpecificCode */
3268 kern_return_t RetCode;
3269 vm_map_t task;
3270
3271 __DeclareRcvRpc(3818, "mach_vm_region_info")
3272 __BeforeRcvRpc(3818, "mach_vm_region_info")
3273 /* RetCArg=0x0 rtSimpleRequest=0 */
3274
3275 #if defined(__MIG_check__Request__mach_vm_region_info_t__defined)
3276 check_result = __MIG_check__Request__mach_vm_region_info_t((__Request *)In0P);
3277 if (check_result != MACH_MSG_SUCCESS)
3278 { MIG_RETURN_ERROR(OutP, check_result); }
3279 #endif /* defined(__MIG_check__Request__mach_vm_region_info_t__defined) */
3280
3281 #if UseStaticTemplates
3282 OutP->objects = objectsTemplate;
3283 #else /* UseStaticTemplates */
3284 OutP->objects.deallocate = FALSE;
3285 OutP->objects.copy = MACH_MSG_VIRTUAL_COPY;
3286 OutP->objects.type = MACH_MSG_OOL_DESCRIPTOR;
3287 #endif /* UseStaticTemplates */
3288
3289
3290 task = convert_port_to_map(In0P->Head.msgh_request_port);
3291
3292 RetCode = mach_vm_region_info(task, In0P->address, &OutP->region, (vm_info_object_array_t *)&(OutP->objects.address), &OutP->objectsCnt);
3293 vm_map_deallocate(task);
3294 if (RetCode != KERN_SUCCESS) {
3295 MIG_RETURN_ERROR(OutP, RetCode);
3296 }
3297 #if __MigKernelSpecificCode
3298 #endif /* __MigKernelSpecificCode */
3299 OutP->objects.size = OutP->objectsCnt * 84;
3300
3301
3302 OutP->NDR = NDR_record;
3303
3304
3305 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
3306 OutP->Head.msgh_size = (sizeof(Reply));
3307 OutP->msgh_body.msgh_descriptor_count = 1;
3308 __AfterRcvRpc(3818, "mach_vm_region_info")
3309 }
3310
3311 #if ( __MigTypeCheck )
3312 #if __MIG_check__Request__vm_map_subsystem__
3313 #if !defined(__MIG_check__Request__vm_mapped_pages_info_t__defined)
3314 #define __MIG_check__Request__vm_mapped_pages_info_t__defined
3315
__MIG_check__Request__vm_mapped_pages_info_t(__Request__vm_mapped_pages_info_t * In0P)3316 mig_internal kern_return_t __MIG_check__Request__vm_mapped_pages_info_t(__attribute__((__unused__)) __Request__vm_mapped_pages_info_t *In0P)
3317 {
3318
3319 typedef __Request__vm_mapped_pages_info_t __Request;
3320 #if __MigTypeCheck
3321 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3322 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3323 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3324 return MIG_BAD_ARGUMENTS;
3325 #endif /* __MigTypeCheck */
3326
3327 return MACH_MSG_SUCCESS;
3328 }
3329 #endif /* !defined(__MIG_check__Request__vm_mapped_pages_info_t__defined) */
3330 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3331 #endif /* ( __MigTypeCheck ) */
3332
3333
3334 /* Routine vm_mapped_pages_info */
3335 #ifdef mig_external
3336 mig_external
3337 #else
3338 extern
3339 #endif /* mig_external */
vm_mapped_pages_info(task,pages,pagesCnt)3340 kern_return_t vm_mapped_pages_info
3341 #if defined(LINTLIBRARY)
3342 (task, pages, pagesCnt)
3343 vm_map_t task;
3344 page_address_array_t *pages;
3345 mach_msg_type_number_t *pagesCnt;
3346 { return vm_mapped_pages_info(task, pages, pagesCnt); }
3347 #else
3348 (
3349 vm_map_t task,
3350 page_address_array_t *pages,
3351 mach_msg_type_number_t *pagesCnt
3352 );
3353 #endif /* defined(LINTLIBRARY) */
3354
3355 /* Routine vm_mapped_pages_info */
_Xvm_mapped_pages_info(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3356 mig_internal novalue _Xvm_mapped_pages_info
3357 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3358 {
3359
3360 #ifdef __MigPackStructs
3361 #pragma pack(4)
3362 #endif
3363 typedef struct {
3364 mach_msg_header_t Head;
3365 /* start of the kernel processed data */
3366 mach_msg_body_t msgh_body;
3367 /* end of the kernel processed data */
3368 mach_msg_trailer_t trailer;
3369 } Request;
3370 #ifdef __MigPackStructs
3371 #pragma pack()
3372 #endif
3373 typedef __Request__vm_mapped_pages_info_t __Request;
3374 typedef __Reply__vm_mapped_pages_info_t Reply;
3375
3376 /*
3377 * typedef struct {
3378 * mach_msg_header_t Head;
3379 * NDR_record_t NDR;
3380 * kern_return_t RetCode;
3381 * } mig_reply_error_t;
3382 */
3383
3384 Request *In0P = (Request *) InHeadP;
3385 Reply *OutP = (Reply *) OutHeadP;
3386 #ifdef __MIG_check__Request__vm_mapped_pages_info_t__defined
3387 kern_return_t check_result;
3388 #endif /* __MIG_check__Request__vm_mapped_pages_info_t__defined */
3389
3390 #if __MigKernelSpecificCode
3391 #if UseStaticTemplates
3392 const static mach_msg_ool_descriptor_t pagesTemplate = {
3393 .address = (void *)0,
3394 .size = 0,
3395 .deallocate = FALSE,
3396 .copy = MACH_MSG_VIRTUAL_COPY,
3397 .type = MACH_MSG_OOL_DESCRIPTOR,
3398 };
3399 #endif /* UseStaticTemplates */
3400
3401 #else
3402 #if UseStaticTemplates
3403 const static mach_msg_ool_descriptor_t pagesTemplate = {
3404 .address = (void *)0,
3405 .size = 0,
3406 .deallocate = FALSE,
3407 .copy = MACH_MSG_VIRTUAL_COPY,
3408 .type = MACH_MSG_OOL_DESCRIPTOR,
3409 };
3410 #endif /* UseStaticTemplates */
3411
3412 #endif /* __MigKernelSpecificCode */
3413 kern_return_t RetCode;
3414 vm_map_t task;
3415
3416 __DeclareRcvRpc(3819, "vm_mapped_pages_info")
3417 __BeforeRcvRpc(3819, "vm_mapped_pages_info")
3418 /* RetCArg=0x0 rtSimpleRequest=0 */
3419
3420 #if defined(__MIG_check__Request__vm_mapped_pages_info_t__defined)
3421 check_result = __MIG_check__Request__vm_mapped_pages_info_t((__Request *)In0P);
3422 if (check_result != MACH_MSG_SUCCESS)
3423 { MIG_RETURN_ERROR(OutP, check_result); }
3424 #endif /* defined(__MIG_check__Request__vm_mapped_pages_info_t__defined) */
3425
3426 #if UseStaticTemplates
3427 OutP->pages = pagesTemplate;
3428 #else /* UseStaticTemplates */
3429 OutP->pages.deallocate = FALSE;
3430 OutP->pages.copy = MACH_MSG_VIRTUAL_COPY;
3431 OutP->pages.type = MACH_MSG_OOL_DESCRIPTOR;
3432 #endif /* UseStaticTemplates */
3433
3434
3435 task = convert_port_to_map(In0P->Head.msgh_request_port);
3436
3437 RetCode = vm_mapped_pages_info(task, (page_address_array_t *)&(OutP->pages.address), &OutP->pagesCnt);
3438 vm_map_deallocate(task);
3439 if (RetCode != KERN_SUCCESS) {
3440 MIG_RETURN_ERROR(OutP, RetCode);
3441 }
3442 #if __MigKernelSpecificCode
3443 #endif /* __MigKernelSpecificCode */
3444 OutP->pages.size = OutP->pagesCnt * 4;
3445
3446
3447 OutP->NDR = NDR_record;
3448
3449
3450 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
3451 OutP->Head.msgh_size = (sizeof(Reply));
3452 OutP->msgh_body.msgh_descriptor_count = 1;
3453 __AfterRcvRpc(3819, "vm_mapped_pages_info")
3454 }
3455
3456 #if ( __MigTypeCheck )
3457 #if __MIG_check__Request__vm_map_subsystem__
3458 #if !defined(__MIG_check__Request__vm_region_recurse_t__defined)
3459 #define __MIG_check__Request__vm_region_recurse_t__defined
3460
__MIG_check__Request__vm_region_recurse_t(__Request__vm_region_recurse_t * In0P)3461 mig_internal kern_return_t __MIG_check__Request__vm_region_recurse_t(__attribute__((__unused__)) __Request__vm_region_recurse_t *In0P)
3462 {
3463
3464 typedef __Request__vm_region_recurse_t __Request;
3465 #if __MigTypeCheck
3466 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3467 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3468 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3469 return MIG_BAD_ARGUMENTS;
3470 #endif /* __MigTypeCheck */
3471
3472 return MACH_MSG_SUCCESS;
3473 }
3474 #endif /* !defined(__MIG_check__Request__vm_region_recurse_t__defined) */
3475 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3476 #endif /* ( __MigTypeCheck ) */
3477
3478
3479 /* Routine vm_region_recurse */
3480 #ifdef mig_external
3481 mig_external
3482 #else
3483 extern
3484 #endif /* mig_external */
vm_region_recurse(target_task,address,size,nesting_depth,info,infoCnt)3485 kern_return_t vm_region_recurse
3486 #if defined(LINTLIBRARY)
3487 (target_task, address, size, nesting_depth, info, infoCnt)
3488 vm_map_t target_task;
3489 vm_address_t *address;
3490 vm_size_t *size;
3491 natural_t *nesting_depth;
3492 vm_region_recurse_info_t info;
3493 mach_msg_type_number_t *infoCnt;
3494 { return vm_region_recurse(target_task, address, size, nesting_depth, info, infoCnt); }
3495 #else
3496 (
3497 vm_map_t target_task,
3498 vm_address_t *address,
3499 vm_size_t *size,
3500 natural_t *nesting_depth,
3501 vm_region_recurse_info_t info,
3502 mach_msg_type_number_t *infoCnt
3503 );
3504 #endif /* defined(LINTLIBRARY) */
3505
3506 /* Routine vm_region_recurse */
_Xvm_region_recurse(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3507 mig_internal novalue _Xvm_region_recurse
3508 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3509 {
3510
3511 #ifdef __MigPackStructs
3512 #pragma pack(4)
3513 #endif
3514 typedef struct {
3515 mach_msg_header_t Head;
3516 /* start of the kernel processed data */
3517 mach_msg_body_t msgh_body;
3518 /* end of the kernel processed data */
3519 NDR_record_t NDR;
3520 vm_address_t address;
3521 natural_t nesting_depth;
3522 mach_msg_type_number_t infoCnt;
3523 mach_msg_trailer_t trailer;
3524 } Request;
3525 #ifdef __MigPackStructs
3526 #pragma pack()
3527 #endif
3528 typedef __Request__vm_region_recurse_t __Request;
3529 typedef __Reply__vm_region_recurse_t Reply;
3530
3531 /*
3532 * typedef struct {
3533 * mach_msg_header_t Head;
3534 * NDR_record_t NDR;
3535 * kern_return_t RetCode;
3536 * } mig_reply_error_t;
3537 */
3538
3539 Request *In0P = (Request *) InHeadP;
3540 Reply *OutP = (Reply *) OutHeadP;
3541 #ifdef __MIG_check__Request__vm_region_recurse_t__defined
3542 kern_return_t check_result;
3543 #endif /* __MIG_check__Request__vm_region_recurse_t__defined */
3544
3545 #if __MigKernelSpecificCode
3546 #else
3547 #endif /* __MigKernelSpecificCode */
3548 vm_map_t target_task;
3549
3550 __DeclareRcvRpc(3821, "vm_region_recurse")
3551 __BeforeRcvRpc(3821, "vm_region_recurse")
3552 /* RetCArg=0x0 rtSimpleRequest=0 */
3553
3554 #if defined(__MIG_check__Request__vm_region_recurse_t__defined)
3555 check_result = __MIG_check__Request__vm_region_recurse_t((__Request *)In0P);
3556 if (check_result != MACH_MSG_SUCCESS)
3557 { MIG_RETURN_ERROR(OutP, check_result); }
3558 #endif /* defined(__MIG_check__Request__vm_region_recurse_t__defined) */
3559
3560 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
3561
3562 OutP->infoCnt = 19;
3563 if (In0P->infoCnt < OutP->infoCnt)
3564 OutP->infoCnt = In0P->infoCnt;
3565
3566 OutP->RetCode = vm_region_recurse(target_task, &In0P->address, &OutP->size, &In0P->nesting_depth, OutP->info, &OutP->infoCnt);
3567 vm_map_deallocate(target_task);
3568 if (OutP->RetCode != KERN_SUCCESS) {
3569 MIG_RETURN_ERROR(OutP, OutP->RetCode);
3570 }
3571 #if __MigKernelSpecificCode
3572 #endif /* __MigKernelSpecificCode */
3573
3574 OutP->NDR = NDR_record;
3575
3576
3577 OutP->address = In0P->address;
3578
3579 OutP->nesting_depth = In0P->nesting_depth;
3580 OutP->Head.msgh_size = (sizeof(Reply) - 76) + (_WALIGN_((4 * OutP->infoCnt)));
3581
3582 __AfterRcvRpc(3821, "vm_region_recurse")
3583 }
3584
3585 #if ( __MigTypeCheck )
3586 #if __MIG_check__Request__vm_map_subsystem__
3587 #if !defined(__MIG_check__Request__vm_region_recurse_64_t__defined)
3588 #define __MIG_check__Request__vm_region_recurse_64_t__defined
3589
__MIG_check__Request__vm_region_recurse_64_t(__Request__vm_region_recurse_64_t * In0P)3590 mig_internal kern_return_t __MIG_check__Request__vm_region_recurse_64_t(__attribute__((__unused__)) __Request__vm_region_recurse_64_t *In0P)
3591 {
3592
3593 typedef __Request__vm_region_recurse_64_t __Request;
3594 #if __MigTypeCheck
3595 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3596 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3597 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3598 return MIG_BAD_ARGUMENTS;
3599 #endif /* __MigTypeCheck */
3600
3601 return MACH_MSG_SUCCESS;
3602 }
3603 #endif /* !defined(__MIG_check__Request__vm_region_recurse_64_t__defined) */
3604 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3605 #endif /* ( __MigTypeCheck ) */
3606
3607
3608 /* Routine vm_region_recurse_64 */
3609 #ifdef mig_external
3610 mig_external
3611 #else
3612 extern
3613 #endif /* mig_external */
vm_region_recurse_64(target_task,address,size,nesting_depth,info,infoCnt)3614 kern_return_t vm_region_recurse_64
3615 #if defined(LINTLIBRARY)
3616 (target_task, address, size, nesting_depth, info, infoCnt)
3617 vm_map_t target_task;
3618 vm_address_t *address;
3619 vm_size_t *size;
3620 natural_t *nesting_depth;
3621 vm_region_recurse_info_t info;
3622 mach_msg_type_number_t *infoCnt;
3623 { return vm_region_recurse_64(target_task, address, size, nesting_depth, info, infoCnt); }
3624 #else
3625 (
3626 vm_map_t target_task,
3627 vm_address_t *address,
3628 vm_size_t *size,
3629 natural_t *nesting_depth,
3630 vm_region_recurse_info_t info,
3631 mach_msg_type_number_t *infoCnt
3632 );
3633 #endif /* defined(LINTLIBRARY) */
3634
3635 /* Routine vm_region_recurse_64 */
_Xvm_region_recurse_64(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3636 mig_internal novalue _Xvm_region_recurse_64
3637 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3638 {
3639
3640 #ifdef __MigPackStructs
3641 #pragma pack(4)
3642 #endif
3643 typedef struct {
3644 mach_msg_header_t Head;
3645 /* start of the kernel processed data */
3646 mach_msg_body_t msgh_body;
3647 /* end of the kernel processed data */
3648 NDR_record_t NDR;
3649 vm_address_t address;
3650 natural_t nesting_depth;
3651 mach_msg_type_number_t infoCnt;
3652 mach_msg_trailer_t trailer;
3653 } Request;
3654 #ifdef __MigPackStructs
3655 #pragma pack()
3656 #endif
3657 typedef __Request__vm_region_recurse_64_t __Request;
3658 typedef __Reply__vm_region_recurse_64_t Reply;
3659
3660 /*
3661 * typedef struct {
3662 * mach_msg_header_t Head;
3663 * NDR_record_t NDR;
3664 * kern_return_t RetCode;
3665 * } mig_reply_error_t;
3666 */
3667
3668 Request *In0P = (Request *) InHeadP;
3669 Reply *OutP = (Reply *) OutHeadP;
3670 #ifdef __MIG_check__Request__vm_region_recurse_64_t__defined
3671 kern_return_t check_result;
3672 #endif /* __MIG_check__Request__vm_region_recurse_64_t__defined */
3673
3674 #if __MigKernelSpecificCode
3675 #else
3676 #endif /* __MigKernelSpecificCode */
3677 vm_map_t target_task;
3678
3679 __DeclareRcvRpc(3822, "vm_region_recurse_64")
3680 __BeforeRcvRpc(3822, "vm_region_recurse_64")
3681 /* RetCArg=0x0 rtSimpleRequest=0 */
3682
3683 #if defined(__MIG_check__Request__vm_region_recurse_64_t__defined)
3684 check_result = __MIG_check__Request__vm_region_recurse_64_t((__Request *)In0P);
3685 if (check_result != MACH_MSG_SUCCESS)
3686 { MIG_RETURN_ERROR(OutP, check_result); }
3687 #endif /* defined(__MIG_check__Request__vm_region_recurse_64_t__defined) */
3688
3689 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
3690
3691 OutP->infoCnt = 19;
3692 if (In0P->infoCnt < OutP->infoCnt)
3693 OutP->infoCnt = In0P->infoCnt;
3694
3695 OutP->RetCode = vm_region_recurse_64(target_task, &In0P->address, &OutP->size, &In0P->nesting_depth, OutP->info, &OutP->infoCnt);
3696 vm_map_deallocate(target_task);
3697 if (OutP->RetCode != KERN_SUCCESS) {
3698 MIG_RETURN_ERROR(OutP, OutP->RetCode);
3699 }
3700 #if __MigKernelSpecificCode
3701 #endif /* __MigKernelSpecificCode */
3702
3703 OutP->NDR = NDR_record;
3704
3705
3706 OutP->address = In0P->address;
3707
3708 OutP->nesting_depth = In0P->nesting_depth;
3709 OutP->Head.msgh_size = (sizeof(Reply) - 76) + (_WALIGN_((4 * OutP->infoCnt)));
3710
3711 __AfterRcvRpc(3822, "vm_region_recurse_64")
3712 }
3713
3714 #if ( __MigTypeCheck )
3715 #if __MIG_check__Request__vm_map_subsystem__
3716 #if !defined(__MIG_check__Request__mach_vm_region_info_64_t__defined)
3717 #define __MIG_check__Request__mach_vm_region_info_64_t__defined
3718
__MIG_check__Request__mach_vm_region_info_64_t(__Request__mach_vm_region_info_64_t * In0P)3719 mig_internal kern_return_t __MIG_check__Request__mach_vm_region_info_64_t(__attribute__((__unused__)) __Request__mach_vm_region_info_64_t *In0P)
3720 {
3721
3722 typedef __Request__mach_vm_region_info_64_t __Request;
3723 #if __MigTypeCheck
3724 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3725 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3726 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3727 return MIG_BAD_ARGUMENTS;
3728 #endif /* __MigTypeCheck */
3729
3730 return MACH_MSG_SUCCESS;
3731 }
3732 #endif /* !defined(__MIG_check__Request__mach_vm_region_info_64_t__defined) */
3733 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3734 #endif /* ( __MigTypeCheck ) */
3735
3736
3737 /* Routine mach_vm_region_info_64 */
3738 #ifdef mig_external
3739 mig_external
3740 #else
3741 extern
3742 #endif /* mig_external */
mach_vm_region_info_64(task,address,region,objects,objectsCnt)3743 kern_return_t mach_vm_region_info_64
3744 #if defined(LINTLIBRARY)
3745 (task, address, region, objects, objectsCnt)
3746 vm_map_t task;
3747 vm_address_t address;
3748 vm_info_region_64_t *region;
3749 vm_info_object_array_t *objects;
3750 mach_msg_type_number_t *objectsCnt;
3751 { return mach_vm_region_info_64(task, address, region, objects, objectsCnt); }
3752 #else
3753 (
3754 vm_map_t task,
3755 vm_address_t address,
3756 vm_info_region_64_t *region,
3757 vm_info_object_array_t *objects,
3758 mach_msg_type_number_t *objectsCnt
3759 );
3760 #endif /* defined(LINTLIBRARY) */
3761
3762 /* Routine mach_vm_region_info_64 */
_Xmach_vm_region_info_64(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3763 mig_internal novalue _Xmach_vm_region_info_64
3764 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3765 {
3766
3767 #ifdef __MigPackStructs
3768 #pragma pack(4)
3769 #endif
3770 typedef struct {
3771 mach_msg_header_t Head;
3772 /* start of the kernel processed data */
3773 mach_msg_body_t msgh_body;
3774 /* end of the kernel processed data */
3775 NDR_record_t NDR;
3776 vm_address_t address;
3777 mach_msg_trailer_t trailer;
3778 } Request;
3779 #ifdef __MigPackStructs
3780 #pragma pack()
3781 #endif
3782 typedef __Request__mach_vm_region_info_64_t __Request;
3783 typedef __Reply__mach_vm_region_info_64_t Reply;
3784
3785 /*
3786 * typedef struct {
3787 * mach_msg_header_t Head;
3788 * NDR_record_t NDR;
3789 * kern_return_t RetCode;
3790 * } mig_reply_error_t;
3791 */
3792
3793 Request *In0P = (Request *) InHeadP;
3794 Reply *OutP = (Reply *) OutHeadP;
3795 #ifdef __MIG_check__Request__mach_vm_region_info_64_t__defined
3796 kern_return_t check_result;
3797 #endif /* __MIG_check__Request__mach_vm_region_info_64_t__defined */
3798
3799 #if __MigKernelSpecificCode
3800 #if UseStaticTemplates
3801 const static mach_msg_ool_descriptor_t objectsTemplate = {
3802 .address = (void *)0,
3803 .size = 0,
3804 .deallocate = FALSE,
3805 .copy = MACH_MSG_VIRTUAL_COPY,
3806 .type = MACH_MSG_OOL_DESCRIPTOR,
3807 };
3808 #endif /* UseStaticTemplates */
3809
3810 #else
3811 #if UseStaticTemplates
3812 const static mach_msg_ool_descriptor_t objectsTemplate = {
3813 .address = (void *)0,
3814 .size = 0,
3815 .deallocate = FALSE,
3816 .copy = MACH_MSG_VIRTUAL_COPY,
3817 .type = MACH_MSG_OOL_DESCRIPTOR,
3818 };
3819 #endif /* UseStaticTemplates */
3820
3821 #endif /* __MigKernelSpecificCode */
3822 kern_return_t RetCode;
3823 vm_map_t task;
3824
3825 __DeclareRcvRpc(3823, "mach_vm_region_info_64")
3826 __BeforeRcvRpc(3823, "mach_vm_region_info_64")
3827 /* RetCArg=0x0 rtSimpleRequest=0 */
3828
3829 #if defined(__MIG_check__Request__mach_vm_region_info_64_t__defined)
3830 check_result = __MIG_check__Request__mach_vm_region_info_64_t((__Request *)In0P);
3831 if (check_result != MACH_MSG_SUCCESS)
3832 { MIG_RETURN_ERROR(OutP, check_result); }
3833 #endif /* defined(__MIG_check__Request__mach_vm_region_info_64_t__defined) */
3834
3835 #if UseStaticTemplates
3836 OutP->objects = objectsTemplate;
3837 #else /* UseStaticTemplates */
3838 OutP->objects.deallocate = FALSE;
3839 OutP->objects.copy = MACH_MSG_VIRTUAL_COPY;
3840 OutP->objects.type = MACH_MSG_OOL_DESCRIPTOR;
3841 #endif /* UseStaticTemplates */
3842
3843
3844 task = convert_port_to_map(In0P->Head.msgh_request_port);
3845
3846 RetCode = mach_vm_region_info_64(task, In0P->address, &OutP->region, (vm_info_object_array_t *)&(OutP->objects.address), &OutP->objectsCnt);
3847 vm_map_deallocate(task);
3848 if (RetCode != KERN_SUCCESS) {
3849 MIG_RETURN_ERROR(OutP, RetCode);
3850 }
3851 #if __MigKernelSpecificCode
3852 #endif /* __MigKernelSpecificCode */
3853 OutP->objects.size = OutP->objectsCnt * 84;
3854
3855
3856 OutP->NDR = NDR_record;
3857
3858
3859 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
3860 OutP->Head.msgh_size = (sizeof(Reply));
3861 OutP->msgh_body.msgh_descriptor_count = 1;
3862 __AfterRcvRpc(3823, "mach_vm_region_info_64")
3863 }
3864
3865 #if ( __MigTypeCheck )
3866 #if __MIG_check__Request__vm_map_subsystem__
3867 #if !defined(__MIG_check__Request__vm_region_64_t__defined)
3868 #define __MIG_check__Request__vm_region_64_t__defined
3869
__MIG_check__Request__vm_region_64_t(__Request__vm_region_64_t * In0P)3870 mig_internal kern_return_t __MIG_check__Request__vm_region_64_t(__attribute__((__unused__)) __Request__vm_region_64_t *In0P)
3871 {
3872
3873 typedef __Request__vm_region_64_t __Request;
3874 #if __MigTypeCheck
3875 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
3876 (In0P->msgh_body.msgh_descriptor_count != 0) ||
3877 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
3878 return MIG_BAD_ARGUMENTS;
3879 #endif /* __MigTypeCheck */
3880
3881 return MACH_MSG_SUCCESS;
3882 }
3883 #endif /* !defined(__MIG_check__Request__vm_region_64_t__defined) */
3884 #endif /* __MIG_check__Request__vm_map_subsystem__ */
3885 #endif /* ( __MigTypeCheck ) */
3886
3887
3888 /* Routine vm_region_64 */
3889 #ifdef mig_external
3890 mig_external
3891 #else
3892 extern
3893 #endif /* mig_external */
vm_region_64(target_task,address,size,flavor,info,infoCnt,object_name)3894 kern_return_t vm_region_64
3895 #if defined(LINTLIBRARY)
3896 (target_task, address, size, flavor, info, infoCnt, object_name)
3897 vm_map_t target_task;
3898 vm_address_t *address;
3899 vm_size_t *size;
3900 vm_region_flavor_t flavor;
3901 vm_region_info_t info;
3902 mach_msg_type_number_t *infoCnt;
3903 mach_port_t *object_name;
3904 { return vm_region_64(target_task, address, size, flavor, info, infoCnt, object_name); }
3905 #else
3906 (
3907 vm_map_t target_task,
3908 vm_address_t *address,
3909 vm_size_t *size,
3910 vm_region_flavor_t flavor,
3911 vm_region_info_t info,
3912 mach_msg_type_number_t *infoCnt,
3913 mach_port_t *object_name
3914 );
3915 #endif /* defined(LINTLIBRARY) */
3916
3917 /* Routine vm_region_64 */
_Xvm_region_64(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)3918 mig_internal novalue _Xvm_region_64
3919 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
3920 {
3921
3922 #ifdef __MigPackStructs
3923 #pragma pack(4)
3924 #endif
3925 typedef struct {
3926 mach_msg_header_t Head;
3927 /* start of the kernel processed data */
3928 mach_msg_body_t msgh_body;
3929 /* end of the kernel processed data */
3930 NDR_record_t NDR;
3931 vm_address_t address;
3932 vm_region_flavor_t flavor;
3933 mach_msg_type_number_t infoCnt;
3934 mach_msg_trailer_t trailer;
3935 } Request;
3936 #ifdef __MigPackStructs
3937 #pragma pack()
3938 #endif
3939 typedef __Request__vm_region_64_t __Request;
3940 typedef __Reply__vm_region_64_t Reply;
3941
3942 /*
3943 * typedef struct {
3944 * mach_msg_header_t Head;
3945 * NDR_record_t NDR;
3946 * kern_return_t RetCode;
3947 * } mig_reply_error_t;
3948 */
3949
3950 Request *In0P = (Request *) InHeadP;
3951 Reply *OutP = (Reply *) OutHeadP;
3952 #ifdef __MIG_check__Request__vm_region_64_t__defined
3953 kern_return_t check_result;
3954 #endif /* __MIG_check__Request__vm_region_64_t__defined */
3955
3956 #if __MigKernelSpecificCode
3957 #if UseStaticTemplates
3958 const static mach_msg_port_descriptor_t object_nameTemplate = {
3959 .name = MACH_PORT_NULL,
3960 .disposition = 17,
3961 .type = MACH_MSG_PORT_DESCRIPTOR,
3962 };
3963 #endif /* UseStaticTemplates */
3964
3965 #else
3966 #if UseStaticTemplates
3967 const static mach_msg_port_descriptor_t object_nameTemplate = {
3968 .name = MACH_PORT_NULL,
3969 .disposition = 17,
3970 .type = MACH_MSG_PORT_DESCRIPTOR,
3971 };
3972 #endif /* UseStaticTemplates */
3973
3974 #endif /* __MigKernelSpecificCode */
3975 kern_return_t RetCode;
3976 vm_map_t target_task;
3977
3978 __DeclareRcvRpc(3824, "vm_region_64")
3979 __BeforeRcvRpc(3824, "vm_region_64")
3980 /* RetCArg=0x0 rtSimpleRequest=0 */
3981
3982 #if defined(__MIG_check__Request__vm_region_64_t__defined)
3983 check_result = __MIG_check__Request__vm_region_64_t((__Request *)In0P);
3984 if (check_result != MACH_MSG_SUCCESS)
3985 { MIG_RETURN_ERROR(OutP, check_result); }
3986 #endif /* defined(__MIG_check__Request__vm_region_64_t__defined) */
3987
3988 #if UseStaticTemplates
3989 OutP->object_name = object_nameTemplate;
3990 #else /* UseStaticTemplates */
3991 #if __MigKernelSpecificCode
3992 OutP->object_name.disposition = 17;
3993 #else
3994 OutP->object_name.disposition = 17;
3995 #endif /* __MigKernelSpecificCode */
3996 OutP->object_name.type = MACH_MSG_PORT_DESCRIPTOR;
3997 #endif /* UseStaticTemplates */
3998
3999
4000 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
4001
4002 OutP->infoCnt = 10;
4003 if (In0P->infoCnt < OutP->infoCnt)
4004 OutP->infoCnt = In0P->infoCnt;
4005
4006 RetCode = vm_region_64(target_task, &In0P->address, &OutP->size, In0P->flavor, OutP->info, &OutP->infoCnt, &OutP->object_name.name);
4007 vm_map_deallocate(target_task);
4008 if (RetCode != KERN_SUCCESS) {
4009 MIG_RETURN_ERROR(OutP, RetCode);
4010 }
4011 #if __MigKernelSpecificCode
4012 #endif /* __MigKernelSpecificCode */
4013
4014 OutP->NDR = NDR_record;
4015
4016
4017 OutP->address = In0P->address;
4018 OutP->Head.msgh_size = (sizeof(Reply) - 40) + (_WALIGN_((4 * OutP->infoCnt)));
4019
4020 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
4021 OutP->msgh_body.msgh_descriptor_count = 1;
4022 __AfterRcvRpc(3824, "vm_region_64")
4023 }
4024
4025 #if ( __MigTypeCheck )
4026 #if __MIG_check__Request__vm_map_subsystem__
4027 #if !defined(__MIG_check__Request__mach_make_memory_entry_64_t__defined)
4028 #define __MIG_check__Request__mach_make_memory_entry_64_t__defined
4029
__MIG_check__Request__mach_make_memory_entry_64_t(__Request__mach_make_memory_entry_64_t * In0P)4030 mig_internal kern_return_t __MIG_check__Request__mach_make_memory_entry_64_t(__attribute__((__unused__)) __Request__mach_make_memory_entry_64_t *In0P)
4031 {
4032
4033 typedef __Request__mach_make_memory_entry_64_t __Request;
4034 #if __MigTypeCheck
4035 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
4036 (In0P->msgh_body.msgh_descriptor_count != 1) ||
4037 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
4038 return MIG_BAD_ARGUMENTS;
4039 #endif /* __MigTypeCheck */
4040
4041 #if __MigTypeCheck
4042 if (In0P->parent_entry.type != MACH_MSG_PORT_DESCRIPTOR ||
4043 In0P->parent_entry.disposition != 17)
4044 return MIG_TYPE_ERROR;
4045 #endif /* __MigTypeCheck */
4046
4047 return MACH_MSG_SUCCESS;
4048 }
4049 #endif /* !defined(__MIG_check__Request__mach_make_memory_entry_64_t__defined) */
4050 #endif /* __MIG_check__Request__vm_map_subsystem__ */
4051 #endif /* ( __MigTypeCheck ) */
4052
4053
4054 /* Routine mach_make_memory_entry_64 */
4055 #ifdef mig_external
4056 mig_external
4057 #else
4058 extern
4059 #endif /* mig_external */
mach_make_memory_entry_64(target_task,size,offset,permission,object_handle,parent_entry)4060 kern_return_t mach_make_memory_entry_64
4061 #if defined(LINTLIBRARY)
4062 (target_task, size, offset, permission, object_handle, parent_entry)
4063 vm_map_t target_task;
4064 memory_object_size_t *size;
4065 memory_object_offset_t offset;
4066 vm_prot_t permission;
4067 mach_port_t *object_handle;
4068 mem_entry_name_port_t parent_entry;
4069 { return mach_make_memory_entry_64(target_task, size, offset, permission, object_handle, parent_entry); }
4070 #else
4071 (
4072 vm_map_t target_task,
4073 memory_object_size_t *size,
4074 memory_object_offset_t offset,
4075 vm_prot_t permission,
4076 mach_port_t *object_handle,
4077 mem_entry_name_port_t parent_entry
4078 );
4079 #endif /* defined(LINTLIBRARY) */
4080
4081 /* Routine mach_make_memory_entry_64 */
_Xmach_make_memory_entry_64(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)4082 mig_internal novalue _Xmach_make_memory_entry_64
4083 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
4084 {
4085
4086 #ifdef __MigPackStructs
4087 #pragma pack(4)
4088 #endif
4089 typedef struct {
4090 mach_msg_header_t Head;
4091 /* start of the kernel processed data */
4092 mach_msg_body_t msgh_body;
4093 mach_msg_port_descriptor_t parent_entry;
4094 /* end of the kernel processed data */
4095 NDR_record_t NDR;
4096 memory_object_size_t size;
4097 memory_object_offset_t offset;
4098 vm_prot_t permission;
4099 mach_msg_trailer_t trailer;
4100 } Request;
4101 #ifdef __MigPackStructs
4102 #pragma pack()
4103 #endif
4104 typedef __Request__mach_make_memory_entry_64_t __Request;
4105 typedef __Reply__mach_make_memory_entry_64_t Reply;
4106
4107 /*
4108 * typedef struct {
4109 * mach_msg_header_t Head;
4110 * NDR_record_t NDR;
4111 * kern_return_t RetCode;
4112 * } mig_reply_error_t;
4113 */
4114
4115 Request *In0P = (Request *) InHeadP;
4116 Reply *OutP = (Reply *) OutHeadP;
4117 #ifdef __MIG_check__Request__mach_make_memory_entry_64_t__defined
4118 kern_return_t check_result;
4119 #endif /* __MIG_check__Request__mach_make_memory_entry_64_t__defined */
4120
4121 #if __MigKernelSpecificCode
4122 #if UseStaticTemplates
4123 const static mach_msg_port_descriptor_t object_handleTemplate = {
4124 .name = MACH_PORT_NULL,
4125 .disposition = 17,
4126 .type = MACH_MSG_PORT_DESCRIPTOR,
4127 };
4128 #endif /* UseStaticTemplates */
4129
4130 #else
4131 #if UseStaticTemplates
4132 const static mach_msg_port_descriptor_t object_handleTemplate = {
4133 .name = MACH_PORT_NULL,
4134 .disposition = 17,
4135 .type = MACH_MSG_PORT_DESCRIPTOR,
4136 };
4137 #endif /* UseStaticTemplates */
4138
4139 #endif /* __MigKernelSpecificCode */
4140 kern_return_t RetCode;
4141 vm_map_t target_task;
4142
4143 __DeclareRcvRpc(3825, "mach_make_memory_entry_64")
4144 __BeforeRcvRpc(3825, "mach_make_memory_entry_64")
4145 /* RetCArg=0x0 rtSimpleRequest=0 */
4146
4147 #if defined(__MIG_check__Request__mach_make_memory_entry_64_t__defined)
4148 check_result = __MIG_check__Request__mach_make_memory_entry_64_t((__Request *)In0P);
4149 if (check_result != MACH_MSG_SUCCESS)
4150 { MIG_RETURN_ERROR(OutP, check_result); }
4151 #endif /* defined(__MIG_check__Request__mach_make_memory_entry_64_t__defined) */
4152
4153 #if UseStaticTemplates
4154 OutP->object_handle = object_handleTemplate;
4155 #else /* UseStaticTemplates */
4156 #if __MigKernelSpecificCode
4157 OutP->object_handle.disposition = 17;
4158 #else
4159 OutP->object_handle.disposition = 17;
4160 #endif /* __MigKernelSpecificCode */
4161 OutP->object_handle.type = MACH_MSG_PORT_DESCRIPTOR;
4162 #endif /* UseStaticTemplates */
4163
4164
4165 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
4166
4167 RetCode = mach_make_memory_entry_64(target_task, &In0P->size, In0P->offset, In0P->permission, &OutP->object_handle.name, null_conversion(In0P->parent_entry.name));
4168 vm_map_deallocate(target_task);
4169 if (RetCode != KERN_SUCCESS) {
4170 MIG_RETURN_ERROR(OutP, RetCode);
4171 }
4172 #if __MigKernelSpecificCode
4173
4174 if (IP_VALID((ipc_port_t)In0P->parent_entry.name))
4175 ipc_port_release_send((ipc_port_t)In0P->parent_entry.name);
4176 #endif /* __MigKernelSpecificCode */
4177
4178 OutP->NDR = NDR_record;
4179
4180
4181 OutP->size = In0P->size;
4182
4183 OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
4184 OutP->Head.msgh_size = (sizeof(Reply));
4185 OutP->msgh_body.msgh_descriptor_count = 1;
4186 __AfterRcvRpc(3825, "mach_make_memory_entry_64")
4187 }
4188
4189 #if ( __MigTypeCheck )
4190 #if __MIG_check__Request__vm_map_subsystem__
4191 #if !defined(__MIG_check__Request__vm_purgable_control_t__defined)
4192 #define __MIG_check__Request__vm_purgable_control_t__defined
4193
__MIG_check__Request__vm_purgable_control_t(__Request__vm_purgable_control_t * In0P)4194 mig_internal kern_return_t __MIG_check__Request__vm_purgable_control_t(__attribute__((__unused__)) __Request__vm_purgable_control_t *In0P)
4195 {
4196
4197 typedef __Request__vm_purgable_control_t __Request;
4198 #if __MigTypeCheck
4199 if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
4200 (In0P->msgh_body.msgh_descriptor_count != 0) ||
4201 (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request)))
4202 return MIG_BAD_ARGUMENTS;
4203 #endif /* __MigTypeCheck */
4204
4205 return MACH_MSG_SUCCESS;
4206 }
4207 #endif /* !defined(__MIG_check__Request__vm_purgable_control_t__defined) */
4208 #endif /* __MIG_check__Request__vm_map_subsystem__ */
4209 #endif /* ( __MigTypeCheck ) */
4210
4211
4212 /* Routine vm_purgable_control */
4213 #ifdef mig_external
4214 mig_external
4215 #else
4216 extern
4217 #endif /* mig_external */
vm_purgable_control(target_task,address,control,state)4218 kern_return_t vm_purgable_control
4219 #if defined(LINTLIBRARY)
4220 (target_task, address, control, state)
4221 vm_map_t target_task;
4222 vm_address_t address;
4223 vm_purgable_t control;
4224 int *state;
4225 { return vm_purgable_control(target_task, address, control, state); }
4226 #else
4227 (
4228 vm_map_t target_task,
4229 vm_address_t address,
4230 vm_purgable_t control,
4231 int *state
4232 );
4233 #endif /* defined(LINTLIBRARY) */
4234
4235 /* Routine vm_purgable_control */
_Xvm_purgable_control(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)4236 mig_internal novalue _Xvm_purgable_control
4237 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
4238 {
4239
4240 #ifdef __MigPackStructs
4241 #pragma pack(4)
4242 #endif
4243 typedef struct {
4244 mach_msg_header_t Head;
4245 /* start of the kernel processed data */
4246 mach_msg_body_t msgh_body;
4247 /* end of the kernel processed data */
4248 NDR_record_t NDR;
4249 vm_address_t address;
4250 vm_purgable_t control;
4251 int state;
4252 mach_msg_trailer_t trailer;
4253 } Request;
4254 #ifdef __MigPackStructs
4255 #pragma pack()
4256 #endif
4257 typedef __Request__vm_purgable_control_t __Request;
4258 typedef __Reply__vm_purgable_control_t Reply;
4259
4260 /*
4261 * typedef struct {
4262 * mach_msg_header_t Head;
4263 * NDR_record_t NDR;
4264 * kern_return_t RetCode;
4265 * } mig_reply_error_t;
4266 */
4267
4268 Request *In0P = (Request *) InHeadP;
4269 Reply *OutP = (Reply *) OutHeadP;
4270 #ifdef __MIG_check__Request__vm_purgable_control_t__defined
4271 kern_return_t check_result;
4272 #endif /* __MIG_check__Request__vm_purgable_control_t__defined */
4273
4274 #if __MigKernelSpecificCode
4275 #else
4276 #endif /* __MigKernelSpecificCode */
4277 vm_map_t target_task;
4278
4279 __DeclareRcvRpc(3830, "vm_purgable_control")
4280 __BeforeRcvRpc(3830, "vm_purgable_control")
4281 /* RetCArg=0x0 rtSimpleRequest=0 */
4282
4283 #if defined(__MIG_check__Request__vm_purgable_control_t__defined)
4284 check_result = __MIG_check__Request__vm_purgable_control_t((__Request *)In0P);
4285 if (check_result != MACH_MSG_SUCCESS)
4286 { MIG_RETURN_ERROR(OutP, check_result); }
4287 #endif /* defined(__MIG_check__Request__vm_purgable_control_t__defined) */
4288
4289 target_task = convert_port_to_map(In0P->Head.msgh_request_port);
4290
4291 OutP->RetCode = vm_purgable_control(target_task, In0P->address, In0P->control, &In0P->state);
4292 vm_map_deallocate(target_task);
4293 if (OutP->RetCode != KERN_SUCCESS) {
4294 MIG_RETURN_ERROR(OutP, OutP->RetCode);
4295 }
4296 #if __MigKernelSpecificCode
4297 #endif /* __MigKernelSpecificCode */
4298
4299 OutP->NDR = NDR_record;
4300
4301
4302 OutP->state = In0P->state;
4303
4304 OutP->Head.msgh_size = (sizeof(Reply));
4305 __AfterRcvRpc(3830, "vm_purgable_control")
4306 }
4307
4308
4309 #ifdef mig_external
4310 mig_external
4311 #else
4312 extern
4313 #endif /* mig_external */
4314 boolean_t vm_map_server(
4315 mach_msg_header_t *InHeadP,
4316 mach_msg_header_t *OutHeadP);
4317
4318 #ifdef mig_external
4319 mig_external
4320 #else
4321 extern
4322 #endif /* mig_external */
4323 mig_routine_t vm_map_server_routine(
4324 mach_msg_header_t *InHeadP);
4325
4326
4327 /* Description of this subsystem, for use in direct RPC */
4328 extern const struct vm_map_subsystem vm_map_subsystem;
4329 const struct vm_map_subsystem {
4330 mig_server_routine_t server; /* Server routine */
4331 mach_msg_id_t start; /* Min routine number */
4332 mach_msg_id_t end; /* Max routine number + 1 */
4333 unsigned int maxsize; /* Max msg size */
4334 vm_address_t reserved; /* Reserved */
4335 struct routine_descriptor /*Array of routine descriptors */
4336 routine[31];
4337 } vm_map_subsystem = {
4338 vm_map_server_routine,
4339 3800,
4340 3831,
4341 (mach_msg_size_t)sizeof(union __ReplyUnion__vm_map_subsystem),
4342 (vm_address_t)0,
4343 {
4344 { (mig_impl_routine_t) 0,
4345 (mig_stub_routine_t) _Xvm_region, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_region_t) },
4346 { (mig_impl_routine_t) 0,
4347 (mig_stub_routine_t) _Xvm_allocate, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_allocate_t) },
4348 { (mig_impl_routine_t) 0,
4349 (mig_stub_routine_t) _Xvm_deallocate, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_deallocate_t) },
4350 { (mig_impl_routine_t) 0,
4351 (mig_stub_routine_t) _Xvm_protect, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_protect_t) },
4352 { (mig_impl_routine_t) 0,
4353 (mig_stub_routine_t) _Xvm_inherit, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_inherit_t) },
4354 { (mig_impl_routine_t) 0,
4355 (mig_stub_routine_t) _Xvm_read, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_read_t) },
4356 { (mig_impl_routine_t) 0,
4357 (mig_stub_routine_t) _Xvm_read_list, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_read_list_t) },
4358 { (mig_impl_routine_t) 0,
4359 (mig_stub_routine_t) _Xvm_write, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_write_t) },
4360 { (mig_impl_routine_t) 0,
4361 (mig_stub_routine_t) _Xvm_copy, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_copy_t) },
4362 { (mig_impl_routine_t) 0,
4363 (mig_stub_routine_t) _Xvm_read_overwrite, 8, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_read_overwrite_t) },
4364 { (mig_impl_routine_t) 0,
4365 (mig_stub_routine_t) _Xvm_msync, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_msync_t) },
4366 { (mig_impl_routine_t) 0,
4367 (mig_stub_routine_t) _Xvm_behavior_set, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_behavior_set_t) },
4368 {0, 0, 0, 0, 0, 0},
4369 { (mig_impl_routine_t) 0,
4370 (mig_stub_routine_t) _Xvm_machine_attribute, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_machine_attribute_t) },
4371 { (mig_impl_routine_t) 0,
4372 (mig_stub_routine_t) _Xvm_remap, 14, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_remap_t) },
4373 { (mig_impl_routine_t) 0,
4374 (mig_stub_routine_t) _Xtask_wire, 2, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__task_wire_t) },
4375 { (mig_impl_routine_t) 0,
4376 (mig_stub_routine_t) _Xmach_make_memory_entry, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__mach_make_memory_entry_t) },
4377 { (mig_impl_routine_t) 0,
4378 (mig_stub_routine_t) _Xvm_map_page_query, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_map_page_query_t) },
4379 { (mig_impl_routine_t) 0,
4380 (mig_stub_routine_t) _Xmach_vm_region_info, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__mach_vm_region_info_t) },
4381 { (mig_impl_routine_t) 0,
4382 (mig_stub_routine_t) _Xvm_mapped_pages_info, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_mapped_pages_info_t) },
4383 {0, 0, 0, 0, 0, 0},
4384 { (mig_impl_routine_t) 0,
4385 (mig_stub_routine_t) _Xvm_region_recurse, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_region_recurse_t) },
4386 { (mig_impl_routine_t) 0,
4387 (mig_stub_routine_t) _Xvm_region_recurse_64, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_region_recurse_64_t) },
4388 { (mig_impl_routine_t) 0,
4389 (mig_stub_routine_t) _Xmach_vm_region_info_64, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__mach_vm_region_info_64_t) },
4390 { (mig_impl_routine_t) 0,
4391 (mig_stub_routine_t) _Xvm_region_64, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_region_64_t) },
4392 { (mig_impl_routine_t) 0,
4393 (mig_stub_routine_t) _Xmach_make_memory_entry_64, 7, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__mach_make_memory_entry_64_t) },
4394 {0, 0, 0, 0, 0, 0},
4395 {0, 0, 0, 0, 0, 0},
4396 {0, 0, 0, 0, 0, 0},
4397 {0, 0, 0, 0, 0, 0},
4398 { (mig_impl_routine_t) 0,
4399 (mig_stub_routine_t) _Xvm_purgable_control, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__vm_purgable_control_t) },
4400 }
4401 };
4402
vm_map_server(mach_msg_header_t * InHeadP,mach_msg_header_t * OutHeadP)4403 mig_external boolean_t vm_map_server
4404 (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
4405 {
4406 /*
4407 * typedef struct {
4408 * mach_msg_header_t Head;
4409 * NDR_record_t NDR;
4410 * kern_return_t RetCode;
4411 * } mig_reply_error_t;
4412 */
4413
4414 register mig_routine_t routine;
4415
4416 OutHeadP->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);
4417 OutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;
4418 /* Minimal size: routine() will update it if different */
4419 OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
4420 OutHeadP->msgh_local_port = MACH_PORT_NULL;
4421 OutHeadP->msgh_id = InHeadP->msgh_id + 100;
4422
4423 if ((InHeadP->msgh_id > 3830) || (InHeadP->msgh_id < 3800) ||
4424 ((routine = vm_map_subsystem.routine[InHeadP->msgh_id - 3800].stub_routine) == 0)) {
4425 ((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
4426 ((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
4427 return FALSE;
4428 }
4429 (*routine) (InHeadP, OutHeadP);
4430 return TRUE;
4431 }
4432
vm_map_server_routine(mach_msg_header_t * InHeadP)4433 mig_external mig_routine_t vm_map_server_routine
4434 (mach_msg_header_t *InHeadP)
4435 {
4436 register int msgh_id;
4437
4438 msgh_id = InHeadP->msgh_id - 3800;
4439
4440 if ((msgh_id > 30) || (msgh_id < 0))
4441 return 0;
4442
4443 return vm_map_subsystem.routine[msgh_id].stub_routine;
4444 }
4445