![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mach.defs CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / include / mach|
Return to mach.defs CVS log | Up to [GnuMach] / OSKit-Mach / include / mach |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University.
4: * Copyright (c) 1993,1994 The University of Utah and
5: * the Computer Systems Laboratory (CSL).
6: * All rights reserved.
7: *
8: * Permission to use, copy, modify and distribute this software and its
9: * documentation is hereby granted, provided that both the copyright
10: * notice and this permission notice appear in all copies of the
11: * software, derivative works or modified versions, and any portions
12: * thereof, and that both notices appear in supporting documentation.
13: *
14: * CARNEGIE MELLON, THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF
15: * THIS SOFTWARE IN ITS "AS IS" CONDITION, AND DISCLAIM ANY LIABILITY
16: * OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF
17: * THIS SOFTWARE.
18: *
19: * Carnegie Mellon requests users of this software to return to
20: *
21: * Software Distribution Coordinator or [email protected]
22: * School of Computer Science
23: * Carnegie Mellon University
24: * Pittsburgh PA 15213-3890
25: *
26: * any improvements or extensions that they make and grant Carnegie Mellon
27: * the rights to redistribute these changes.
28: */
29: /*
30: * Matchmaker definitions file for Mach kernel interface.
31: */
32:
33: #ifdef MACH_KERNEL
34: #include <mach_ipc_compat.h>
35:
36: simport <kern/compat_xxx_defs.h>; /* for obsolete routines */
37: #endif /* MACH_KERNEL */
38:
39: subsystem
40: #if KERNEL_USER
41: KernelUser
42: #endif /* KERNEL_USER */
43: #if KERNEL_SERVER
44: KernelServer
45: #endif /* KERNEL_SERVER */
46: mach 2000;
47:
48: #ifdef KERNEL_USER
49: userprefix r_;
50: #endif /* KERNEL_USER */
51:
52: #include <mach/std_types.defs>
53: #include <mach/mach_types.defs>
54:
55: skip; /* old port_allocate */
56: skip; /* old port_deallocate */
57: skip; /* old port_enable */
58: skip; /* old port_disable */
59: skip; /* old port_select */
60: skip; /* old port_set_backlog */
61: skip; /* old port_status */
62:
63: /*
64: * Create a new task with an empty set of IPC rights,
65: * and having an address space constructed from the
66: * target task (or empty, if inherit_memory is FALSE).
67: */
68: routine task_create(
69: target_task : task_t;
70: inherit_memory : boolean_t;
71: out child_task : task_t);
72:
73: /*
74: * Destroy the target task, causing all of its threads
75: * to be destroyed, all of its IPC rights to be deallocated,
76: * and all of its address space to be deallocated.
77: */
78: routine task_terminate(
79: target_task : task_t);
80:
81: /*
82: * Get user-level handler entry points for all
83: * emulated system calls.
84: */
85: routine task_get_emulation_vector(
86: task : task_t;
87: out vector_start : int;
88: out emulation_vector: emulation_vector_t);
89:
90: /*
91: * Establish user-level handlers for the specified
92: * system calls. Non-emulated system calls are specified
93: * with emulation_vector[i] == EML_ROUTINE_NULL.
94: */
95: routine task_set_emulation_vector(
96: task : task_t;
97: vector_start : int;
98: emulation_vector: emulation_vector_t);
99:
100:
101: /*
102: * Returns the set of threads belonging to the target task.
103: */
104: routine task_threads(
105: target_task : task_t;
106: out thread_list : thread_array_t);
107:
108: /*
109: * Returns information about the target task.
110: */
111: routine task_info(
112: target_task : task_t;
113: flavor : int;
114: out task_info_out : task_info_t, CountInOut);
115:
116:
117: skip; /* old task_status */
118: skip; /* old task_set_notify */
119: skip; /* old thread_create */
120:
121: /*
122: * Destroy the target thread.
123: */
124: routine thread_terminate(
125: target_thread : thread_t);
126:
127: /*
128: * Return the selected state information for the target
129: * thread. If the thread is currently executing, the results
130: * may be stale. [Flavor THREAD_STATE_FLAVOR_LIST provides a
131: * list of valid flavors for the target thread.]
132: */
133: routine thread_get_state(
134: target_thread : thread_t;
135: flavor : int;
136: out old_state : thread_state_t, CountInOut);
137:
138: /*
139: * Set the selected state information for the target thread.
140: * If the thread is currently executing, the state change
141: * may be ill-defined.
142: */
143: routine thread_set_state(
144: target_thread : thread_t;
145: flavor : int;
146: new_state : thread_state_t);
147:
148: /*
149: * Returns information about the target thread.
150: */
151: routine thread_info(
152: target_thread : thread_t;
153: flavor : int;
154: out thread_info_out : thread_info_t, CountInOut);
155:
156: skip; /* old thread_mutate */
157:
158: /*
159: * Allocate zero-filled memory in the address space
160: * of the target task, either at the specified address,
161: * or wherever space can be found (if anywhere is TRUE),
162: * of the specified size. The address at which the
163: * allocation actually took place is returned.
164: */
165: #ifdef EMULATOR
166: skip; /* the emulator redefines vm_allocate using vm_map */
167: #else /* EMULATOR */
168: routine vm_allocate(
169: target_task : vm_task_t;
170: inout address : vm_address_t;
171: size : vm_size_t;
172: anywhere : boolean_t);
173: #endif /* EMULATOR */
174:
175: skip; /* old vm_allocate_with_pager */
176:
177: /*
178: * Deallocate the specified range from the virtual
179: * address space of the target task.
180: */
181: routine vm_deallocate(
182: target_task : vm_task_t;
183: address : vm_address_t;
184: size : vm_size_t);
185:
186: /*
187: * Set the current or maximum protection attribute
188: * for the specified range of the virtual address
189: * space of the target task. The current protection
190: * limits the memory access rights of threads within
191: * the task; the maximum protection limits the accesses
192: * that may be given in the current protection.
193: * Protections are specified as a set of {read, write, execute}
194: * *permissions*.
195: */
196: routine vm_protect(
197: target_task : vm_task_t;
198: address : vm_address_t;
199: size : vm_size_t;
200: set_maximum : boolean_t;
201: new_protection : vm_prot_t);
202:
203: /*
204: * Set the inheritance attribute for the specified range
205: * of the virtual address space of the target task.
206: * The inheritance value is one of {none, copy, share}, and
207: * specifies how the child address space should acquire
208: * this memory at the time of a task_create call.
209: */
210: routine vm_inherit(
211: target_task : vm_task_t;
212: address : vm_address_t;
213: size : vm_size_t;
214: new_inheritance : vm_inherit_t);
215:
216: /*
217: * Returns the contents of the specified range of the
218: * virtual address space of the target task. [The
219: * range must be aligned on a virtual page boundary,
220: * and must be a multiple of pages in extent. The
221: * protection on the specified range must permit reading.]
222: */
223: routine vm_read(
224: target_task : vm_task_t;
225: address : vm_address_t;
226: size : vm_size_t;
227: out data : pointer_t);
228:
229: /*
230: * Writes the contents of the specified range of the
231: * virtual address space of the target task. [The
232: * range must be aligned on a virtual page boundary,
233: * and must be a multiple of pages in extent. The
234: * protection on the specified range must permit writing.]
235: */
236: routine vm_write(
237: target_task : vm_task_t;
238: address : vm_address_t;
239: data : pointer_t);
240:
241: /*
242: * Copy the contents of the source range of the virtual
243: * address space of the target task to the destination
244: * range in that same address space. [Both of the
245: * ranges must be aligned on a virtual page boundary,
246: * and must be multiples of pages in extent. The
247: * protection on the source range must permit reading,
248: * and the protection on the destination range must
249: * permit writing.]
250: */
251: routine vm_copy(
252: target_task : vm_task_t;
253: source_address : vm_address_t;
254: size : vm_size_t;
255: dest_address : vm_address_t);
256:
257: /*
258: * Returns information about the contents of the virtual
259: * address space of the target task at the specified
260: * address. The returned protection, inheritance, sharing
261: * and memory object values apply to the entire range described
262: * by the address range returned; the memory object offset
263: * corresponds to the beginning of the address range.
264: * [If the specified address is not allocated, the next
265: * highest address range is described. If no addresses beyond
266: * the one specified are allocated, the call returns KERN_NO_SPACE.]
267: */
268: routine vm_region(
269: target_task : vm_task_t;
270: inout address : vm_address_t;
271: out size : vm_size_t;
272: out protection : vm_prot_t;
273: out max_protection : vm_prot_t;
274: out inheritance : vm_inherit_t;
275: out is_shared : boolean_t;
276: /* avoid out-translation of the argument */
277: out object_name : memory_object_name_t =
278: MACH_MSG_TYPE_MOVE_SEND
279: ctype: mach_port_t;
280: out offset : vm_offset_t);
281:
282: /*
283: * Return virtual memory statistics for the host
284: * on which the target task resides. [Note that the
285: * statistics are not specific to the target task.]
286: */
287: routine vm_statistics(
288: target_task : vm_task_t;
289: out vm_stats : vm_statistics_data_t);
290:
291: skip; /* old task_by_u*x_pid */
292: skip; /* old vm_pageable */
293:
294: /*
295: * Stash a handful of ports for the target task; child
296: * tasks inherit this stash at task_create time.
297: */
298: routine mach_ports_register(
299: target_task : task_t;
300: init_port_set : mach_port_array_t =
301: ^array[] of mach_port_t);
302:
303: /*
304: * Retrieve the stashed ports for the target task.
305: */
306: routine mach_ports_lookup(
307: target_task : task_t;
308: out init_port_set : mach_port_array_t =
309: ^array[] of mach_port_t);
310:
311: skip; /* old u*x_pid */
312: skip; /* old netipc_listen */
313: skip; /* old netipc_ignore */
314:
315: /*
316: * Provide the data contents of a range of the given memory
317: * object, with the access restriction specified. [Only
318: * whole virtual pages of data can be accepted; partial pages
319: * will be discarded. Data should be provided on request, but
320: * may be provided in advance as desired. When data already
321: * held by this kernel is provided again, the new data is ignored.
322: * The access restriction is the subset of {read, write, execute}
323: * which are prohibited. The kernel may not provide any data (or
324: * protection) consistency among pages with different virtual page
325: * alignments within the same object.]
326: */
327: simpleroutine memory_object_data_provided(
328: memory_control : memory_object_control_t;
329: offset : vm_offset_t;
330: data : pointer_t;
331: lock_value : vm_prot_t);
332:
333: /*
334: * Indicate that a range of the given temporary memory object does
335: * not exist, and that the backing memory object should be used
336: * instead (or zero-fill memory be used, if no backing object exists).
337: * [This call is intended for use only by the default memory manager.
338: * It should not be used to indicate a real error --
339: * memory_object_data_error should be used for that purpose.]
340: */
341: simpleroutine memory_object_data_unavailable(
342: memory_control : memory_object_control_t;
343: offset : vm_offset_t;
344: size : vm_size_t);
345:
346: /*
347: * Retrieves the attributes currently associated with
348: * a memory object.
349: */
350: routine memory_object_get_attributes(
351: memory_control : memory_object_control_t;
352: out object_ready : boolean_t;
353: out may_cache : boolean_t;
354: out copy_strategy : memory_object_copy_strategy_t);
355:
356: /*
357: * Sets the default memory manager, the port to which
358: * newly-created temporary memory objects are delivered.
359: * [See (memory_object_default)memory_object_create.]
360: * The old memory manager port is returned.
361: */
362: routine vm_set_default_memory_manager(
363: host_priv : host_priv_t;
364: inout default_manager : mach_port_make_send_t);
365:
366: skip; /* old pager_flush_request */
367:
368: /*
369: * Control use of the data associated with the given
370: * memory object. For each page in the given range,
371: * perform the following operations, in order:
372: * 1) restrict access to the page (disallow
373: * forms specified by "prot");
374: * 2) write back modifications (if "should_return"
375: * is RETURN_DIRTY and the page is dirty, or
376: * "should_return" is RETURN_ALL and the page
377: * is either dirty or precious); and,
378: * 3) flush the cached copy (if "should_flush"
379: * is asserted).
380: * The set of pages is defined by a starting offset
381: * ("offset") and size ("size"). Only pages with the
382: * same page alignment as the starting offset are
383: * considered.
384: *
385: * A single acknowledgement is sent (to the "reply_to"
386: * port) when these actions are complete.
387: *
388: * There are two versions of this routine because IPC distinguishes
389: * between booleans and integers (a 2-valued integer is NOT a
390: * boolean). The new routine is backwards compatible at the C
391: * language interface.
392: */
393: simpleroutine xxx_memory_object_lock_request(
394: memory_control : memory_object_control_t;
395: offset : vm_offset_t;
396: size : vm_size_t;
397: should_clean : boolean_t;
398: should_flush : boolean_t;
399: lock_value : vm_prot_t;
400: reply_to : mach_port_t =
401: MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
402:
403:
404: simpleroutine memory_object_lock_request(
405: memory_control : memory_object_control_t;
406: offset : vm_offset_t;
407: size : vm_size_t;
408: should_return : memory_object_return_t;
409: should_flush : boolean_t;
410: lock_value : vm_prot_t;
411: reply_to : mach_port_t =
412: MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
413:
414: /* obsolete */
415: routine xxx_task_get_emulation_vector(
416: task : task_t;
417: out vector_start : int;
418: out emulation_vector: xxx_emulation_vector_t, IsLong);
419:
420: /* obsolete */
421: routine xxx_task_set_emulation_vector(
422: task : task_t;
423: vector_start : int;
424: emulation_vector: xxx_emulation_vector_t, IsLong);
425:
426: /*
427: * Returns information about the host on which the
428: * target object resides. [This object may be
429: * a task, thread, or memory_object_control port.]
430: */
431: routine xxx_host_info(
432: target_task : mach_port_t;
433: out info : machine_info_data_t);
434:
435: /*
436: * Returns information about a particular processor on
437: * the host on which the target task resides.
438: */
439: routine xxx_slot_info(
440: target_task : task_t;
441: slot : int;
442: out info : machine_slot_data_t);
443:
444: /*
445: * Performs control operations (currently only
446: * turning off or on) on a particular processor on
447: * the host on which the target task resides.
448: */
449: routine xxx_cpu_control(
450: target_task : task_t;
451: cpu : int;
452: running : boolean_t);
453:
454: skip; /* old thread_statistics */
455: skip; /* old task_statistics */
456: skip; /* old netport_init */
457: skip; /* old netport_enter */
458: skip; /* old netport_remove */
459: skip; /* old thread_set_priority */
460:
461: /*
462: * Increment the suspend count for the target task.
463: * No threads within a task may run when the suspend
464: * count for that task is non-zero.
465: */
466: routine task_suspend(
467: target_task : task_t);
468:
469: /*
470: * Decrement the suspend count for the target task,
471: * if the count is currently non-zero. If the resulting
472: * suspend count is zero, then threads within the task
473: * that also have non-zero suspend counts may execute.
474: */
475: routine task_resume(
476: target_task : task_t);
477:
478: /*
479: * Returns the current value of the selected special port
480: * associated with the target task.
481: */
482: routine task_get_special_port(
483: task : task_t;
484: which_port : int;
485: out special_port : mach_port_t);
486:
487: /*
488: * Set one of the special ports associated with the
489: * target task.
490: */
491: routine task_set_special_port(
492: task : task_t;
493: which_port : int;
494: special_port : mach_port_t);
495:
496: /* obsolete */
497: routine xxx_task_info(
498: target_task : task_t;
499: flavor : int;
500: out task_info_out : task_info_t, IsLong);
501:
502:
503: /*
504: * Create a new thread within the target task, returning
505: * the port representing that new thread. The
506: * initial execution state of the thread is undefined.
507: */
508: routine thread_create(
509: parent_task : task_t;
510: out child_thread : thread_t);
511:
512: /*
513: * Increment the suspend count for the target thread.
514: * Once this call has completed, the thread will not
515: * execute any further user or meta- instructions.
516: * Once suspended, a thread may not execute again until
517: * its suspend count is zero, and the suspend count
518: * for its task is also zero.
519: */
520: routine thread_suspend(
521: target_thread : thread_t);
522:
523: /*
524: * Decrement the suspend count for the target thread,
525: * if that count is not already zero.
526: */
527: routine thread_resume(
528: target_thread : thread_t);
529:
530: /*
531: * Cause any user or meta- instructions currently being
532: * executed by the target thread to be aborted. [Meta-
533: * instructions consist of the basic traps for IPC
534: * (e.g., msg_send, msg_receive) and self-identification
535: * (e.g., task_self, thread_self, thread_reply). Calls
536: * described by MiG interfaces are not meta-instructions
537: * themselves.]
538: */
539: routine thread_abort(
540: target_thread : thread_t);
541:
542: /* obsolete */
543: routine xxx_thread_get_state(
544: target_thread : thread_t;
545: flavor : int;
546: out old_state : thread_state_t, IsLong);
547:
548: /* obsolete */
549: routine xxx_thread_set_state(
550: target_thread : thread_t;
551: flavor : int;
552: new_state : thread_state_t, IsLong);
553:
554: /*
555: * Returns the current value of the selected special port
556: * associated with the target thread.
557: */
558: routine thread_get_special_port(
559: thread : thread_t;
560: which_port : int;
561: out special_port : mach_port_t);
562:
563: /*
564: * Set one of the special ports associated with the
565: * target thread.
566: */
567: routine thread_set_special_port(
568: thread : thread_t;
569: which_port : int;
570: special_port : mach_port_t);
571:
572: /* obsolete */
573: routine xxx_thread_info(
574: target_thread : thread_t;
575: flavor : int;
576: out thread_info_out : thread_info_t, IsLong);
577:
578: /*
579: * Establish a user-level handler for the specified
580: * system call.
581: */
582: routine task_set_emulation(
583: target_port : task_t;
584: routine_entry_pt: vm_address_t;
585: routine_number : int);
586:
587: /*
588: * Establish restart pc for interrupted atomic sequences.
589: * This reuses the message number for the old task_get_io_port.
590: * See task_info.h for description of flavors.
591: *
592: */
593: routine task_ras_control(
594: target_task : task_t;
595: basepc : vm_address_t;
596: boundspc : vm_address_t;
597: flavor : int);
598:
599:
600:
601: skip; /* old host_ipc_statistics */
602:
603:
604: #if MACH_IPC_COMPAT
605:
606: /*
607: * Returns the set of port and port set names
608: * to which the target task has access, along with
609: * the type (set or port) for each name.
610: */
611: routine port_names(
612: task : ipc_space_t;
613: out port_names_p : port_name_array_t;
614: out port_types : port_type_array_t);
615:
616: /*
617: * Returns the type (set or port) for the port name
618: * within the target task.
619: */
620: routine port_type(
621: task : ipc_space_t;
622: port_name : port_name_t;
623: out port_type_p : port_type_t);
624:
625: /*
626: * Changes the name by which a port (or port set) is known to
627: * the target task.
628: */
629: routine port_rename(
630: task : ipc_space_t;
631: old_name : port_name_t;
632: new_name : port_name_t);
633:
634: /*
635: * Allocate a new port (with all rights) in the target task.
636: * The port name in that task is returned.
637: */
638: routine port_allocate(
639: task : ipc_space_t;
640: out port_name : port_name_t);
641:
642: /*
643: * Deallocate the port with the given name from the target task.
644: */
645: routine port_deallocate(
646: task : ipc_space_t;
647: port_name : port_name_t);
648:
649: /*
650: * Set the number of messages that may be queued to
651: * the port in the target task with the given name
652: * before further message queueing operations block.
653: * The target task must hold receive rights for the
654: * port named.
655: */
656: routine port_set_backlog(
657: task : ipc_space_t;
658: port_name : port_name_t;
659: backlog : int);
660:
661: /*
662: * Return information about the port with the given
663: * name in the target task. Only the ownership and
664: * receive_rights results are meaningful unless the
665: * target task holds receive rights for the port.
666: */
667: routine port_status(
668: task : ipc_space_t;
669: port_name : port_name_t;
670: out enabled : port_set_name_t;
671: out num_msgs : int;
672: out backlog : int;
673: out ownership : boolean_t;
674: out receive_rights : boolean_t);
675:
676: /*
677: * Allocate a new port set in the target task, returning
678: * the name of that new port set. [The new set is
679: * initially empty.]
680: */
681: routine port_set_allocate(
682: task : ipc_space_t;
683: out set_name : port_set_name_t);
684:
685: /*
686: * Deallocate the named port set from the target task.
687: * Ports that are currently members of the named port
688: * set are first removed from the set.
689: */
690: routine port_set_deallocate(
691: task : ipc_space_t;
692: set_name : port_set_name_t);
693:
694: /*
695: * Add the named port to the port set named within
696: * the target task. [If the port currently is a member
697: * of another port set, it is removed from that set.]
698: */
699: routine port_set_add(
700: task : ipc_space_t;
701: set_name : port_set_name_t;
702: port_name : port_name_t);
703:
704: /*
705: * Remove the named port from the port set named within
706: * the target task.
707: */
708: routine port_set_remove(
709: task : ipc_space_t;
710: port_name : port_name_t);
711:
712: /*
713: * Returns the current set of ports that are members
714: * of the named port set in the target task.
715: */
716: routine port_set_status(
717: task : ipc_space_t;
718: set_name : port_set_name_t;
719: out members : port_name_array_t);
720:
721: /*
722: * Insert send rights for the specified port into
723: * the target task with the specified port name.
724: * [If the name is in use, or the target task already
725: * has another name for the specified port, then
726: * the operation will fail.]
727: */
728: routine port_insert_send(
729: task : ipc_space_t;
730: my_port : port_t;
731: his_name : port_name_t);
732:
733: /*
734: * Returns send rights for the named port in the
735: * target task, removing that port name and port
736: * send rights from the target task. [If the
737: * target task holds receive rights for this port,
738: * the operation will fail.]
739: */
740: routine port_extract_send(
741: task : ipc_space_t;
742: his_name : port_name_t;
743: out his_port : port_t);
744:
745: /*
746: * Insert receive rights for the specified port into
747: * the target task with the specified port name.
748: * [If the name is in use, or the target task already
749: * has another name for the specified port, then
750: * the operation will fail.
751: */
752: routine port_insert_receive(
753: task : ipc_space_t;
754: my_port : port_all_t;
755: his_name : port_name_t);
756:
757: /*
758: * Returns receive rights for the named port in the
759: * target task, removing that port name and all port
760: * rights from the target task.
761: */
762: routine port_extract_receive(
763: task : ipc_space_t;
764: his_name : port_name_t;
765: out his_port : port_all_t);
766:
767: #else /* MACH_IPC_COMPAT */
768:
769: skip; /* old port_names */
770: skip; /* old port_type */
771: skip; /* old port_rename */
772: skip; /* old port_allocate */
773: skip; /* old port_deallocate */
774: skip; /* old port_set_backlog */
775: skip; /* old port_status */
776: skip; /* old port_set_allocate */
777: skip; /* old port_set_deallocate */
778: skip; /* old port_set_add */
779: skip; /* old port_set_remove */
780: skip; /* old port_set_status */
781: skip; /* old port_insert_send */
782: skip; /* old port_extract_send */
783: skip; /* old port_insert_receive */
784: skip; /* old port_extract_receive */
785:
786: #endif /* MACH_IPC_COMPAT */
787:
788: /*
789: * Map a user-defined memory object into the virtual address
790: * space of the target task. If desired (anywhere is TRUE),
791: * the kernel will find a suitable address range of the
792: * specified size; else, the specific address will be allocated.
793: *
794: * The beginning address of the range will be aligned on a virtual
795: * page boundary, be at or beyond the address specified, and
796: * meet the mask requirements (bits turned on in the mask must not
797: * be turned on in the result); the size of the range, in bytes,
798: * will be rounded up to an integral number of virtual pages.
799: *
800: * The memory in the resulting range will be associated with the
801: * specified memory object, with the beginning of the memory range
802: * referring to the specified offset into the memory object.
803: *
804: * The mapping will take the current and maximum protections and
805: * the inheritance attributes specified; see the vm_protect and
806: * vm_inherit calls for a description of these attributes.
807: *
808: * If desired (copy is TRUE), the memory range will be filled
809: * with a copy of the data from the memory object; this copy will
810: * be private to this mapping in this target task. Otherwise,
811: * the memory in this mapping will be shared with other mappings
812: * of the same memory object at the same offset (in this task or
813: * in other tasks). [The Mach kernel only enforces shared memory
814: * consistency among mappings on one host with similar page alignments.
815: * The user-defined memory manager for this object is responsible
816: * for further consistency.]
817: */
818: #ifdef EMULATOR
819: routine htg_vm_map(
820: target_task : vm_task_t;
821: ureplyport reply_port : mach_port_make_send_once_t;
822: inout address : vm_address_t;
823: size : vm_size_t;
824: mask : vm_address_t;
825: anywhere : boolean_t;
826: memory_object : memory_object_t;
827: offset : vm_offset_t;
828: copy : boolean_t;
829: cur_protection : vm_prot_t;
830: max_protection : vm_prot_t;
831: inheritance : vm_inherit_t);
832: #else /* EMULATOR */
833: routine vm_map(
834: target_task : vm_task_t;
835: inout address : vm_address_t;
836: size : vm_size_t;
837: mask : vm_address_t;
838: anywhere : boolean_t;
839: memory_object : memory_object_t;
840: offset : vm_offset_t;
841: copy : boolean_t;
842: cur_protection : vm_prot_t;
843: max_protection : vm_prot_t;
844: inheritance : vm_inherit_t);
845: #endif /* EMULATOR */
846:
847: /*
848: * Indicate that a range of the specified memory object cannot
849: * be provided at this time. [Threads waiting for memory pages
850: * specified by this call will experience a memory exception.
851: * Only threads waiting at the time of the call are affected.]
852: */
853: simpleroutine memory_object_data_error(
854: memory_control : memory_object_control_t;
855: offset : vm_offset_t;
856: size : vm_size_t;
857: error_value : kern_return_t);
858:
859: /*
860: * Make decisions regarding the use of the specified
861: * memory object.
862: */
863: simpleroutine memory_object_set_attributes(
864: memory_control : memory_object_control_t;
865: object_ready : boolean_t;
866: may_cache : boolean_t;
867: copy_strategy : memory_object_copy_strategy_t);
868:
869: /*
870: */
871: simpleroutine memory_object_destroy(
872: memory_control : memory_object_control_t;
873: reason : kern_return_t);
874:
875: /*
876: * Provide the data contents of a range of the given memory
877: * object, with the access restriction specified, optional
878: * precious attribute, and reply message. [Only
879: * whole virtual pages of data can be accepted; partial pages
880: * will be discarded. Data should be provided on request, but
881: * may be provided in advance as desired. When data already
882: * held by this kernel is provided again, the new data is ignored.
883: * The access restriction is the subset of {read, write, execute}
884: * which are prohibited. The kernel may not provide any data (or
885: * protection) consistency among pages with different virtual page
886: * alignments within the same object. The precious value controls
887: * how the kernel treats the data. If it is FALSE, the kernel treats
888: * its copy as a temporary and may throw it away if it hasn't been
889: * changed. If the precious value is TRUE, the kernel treats its
890: * copy as a data repository and promises to return it to the manager;
891: * the manager may tell the kernel to throw it away instead by flushing
892: * and not cleaning the data -- see memory_object_lock_request. The
893: * reply_to port is for a compeletion message; it will be
894: * memory_object_supply_completed.]
895: */
896:
897: simpleroutine memory_object_data_supply(
898: memory_control : memory_object_control_t;
899: offset : vm_offset_t;
900: data : pointer_t, Dealloc[];
901: lock_value : vm_prot_t;
902: precious : boolean_t;
903: reply_to : mach_port_t =
904: MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
905:
906: simpleroutine memory_object_ready(
907: memory_control : memory_object_control_t;
908: may_cache : boolean_t;
909: copy_strategy : memory_object_copy_strategy_t);
910:
911: simpleroutine memory_object_change_attributes(
912: memory_control : memory_object_control_t;
913: may_cache : boolean_t;
914: copy_strategy : memory_object_copy_strategy_t;
915: reply_to : mach_port_t =
916: MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
917:
918: skip; /* old host_callout_statistics_reset */
919: skip; /* old port_set_select */
920:
921: #if MACH_IPC_COMPAT
922:
923: /*
924: * Sets a backup port for the named port. The task
925: * must have receive rights for the named port.
926: * Returns the previous backup port, if any.
927: */
928:
929: routine port_set_backup(
930: task : ipc_space_t;
931: port_name : port_name_t;
932: backup : port_t = MACH_MSG_TYPE_MAKE_SEND
933: ctype: mach_port_t;
934: out previous : port_t);
935:
936: #else /* MACH_IPC_COMPAT */
937:
938: skip; /* old port_set_backup */
939:
940: #endif /* MACH_IPC_COMPAT */
941:
942: /*
943: * Set/Get special properties of memory associated
944: * to some virtual address range, such as cachability,
945: * migrability, replicability. Machine-dependent.
946: */
947: routine vm_machine_attribute(
948: target_task : vm_task_t;
949: address : vm_address_t;
950: size : vm_size_t;
951: attribute : vm_machine_attribute_t;
952: inout value : vm_machine_attribute_val_t);
953:
954: skip; /* old host_fpa_counters_reset */
955:
956: /*
957: * There is no more room in this interface for additional calls.
958: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.