![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memory_object.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 memory_object.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,1987 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * File: mach/memory_object.defs
28: *
29: * Abstract:
30: * Basic Mach external memory management interface declaration.
31: */
32:
33: subsystem
34: #if KERNEL_USER
35: KernelUser
36: #endif /* KERNEL_USER */
37: #if KERNEL_SERVER
38: KernelServer
39: #endif /* KERNEL_SERVER */
40: memory_object 2200;
41:
42: #ifdef KERNEL
43: #include <norma_vm.h>
44: #if NORMA_VM
45: userprefix k_;
46: #endif /* NORMA_VM */
47: #endif /* KERNEL */
48:
49: #include <mach/std_types.defs>
50: #include <mach/mach_types.defs>
51:
52: #if SEQNOS
53: serverprefix seqnos_;
54: serverdemux seqnos_memory_object_server;
55: #endif /* SEQNOS */
56:
57: /*
58: * Initialize the specified memory object, providing
59: * a reqeust port on which control calls can be made, and
60: * a name port that identifies this object to callers of
61: * vm_regions.
62: * [To allow the mapping of this object to be used, the
63: * memory manager must call memory_object_set_attributes,
64: * specifying the "ready" parameter as TRUE. To reject
65: * all mappings of this object, the memory manager may
66: * use memory_object_destroy.]
67: */
68: simpleroutine memory_object_init(
69: memory_object : memory_object_t;
70: #if SEQNOS
71: msgseqno seqno : mach_port_seqno_t;
72: #endif /* SEQNOS */
73: memory_control : memory_object_control_t =
74: MACH_MSG_TYPE_MAKE_SEND
75: ctype: mach_port_t;
76: memory_object_name : memory_object_name_t =
77: MACH_MSG_TYPE_MAKE_SEND
78: ctype: mach_port_t;
79: memory_object_page_size : vm_size_t);
80:
81: /*
82: * Indicates that the specified memory object is no longer
83: * mapped (or cached -- see memory_object_set_attributes),
84: * and that further mappings will cause another memory_object_init
85: * call to be made. No further calls will be made on
86: * the memory object by this kernel.
87: *
88: * [All rights to the control and name ports are included
89: * in this call. The memory manager should use port_deallocate
90: * to release them once they are no longer needed.]
91: */
92: simpleroutine memory_object_terminate(
93: memory_object : memory_object_t =
94: MACH_MSG_TYPE_MOVE_SEND
95: ctype: mach_port_t;
96: #if SEQNOS
97: msgseqno seqno : mach_port_seqno_t;
98: #endif /* SEQNOS */
99: memory_control : memory_object_control_t =
100: MACH_MSG_TYPE_MOVE_RECEIVE
101: ctype: mach_port_t
102: #if KERNEL_USER
103: /* for compatibility with Mach 2.5 kernels */
104: , dealloc
105: #endif /* KERNEL_USER */
106: ;
107: memory_object_name : memory_object_name_t =
108: MACH_MSG_TYPE_MOVE_RECEIVE
109: ctype: mach_port_t
110: #if KERNEL_USER
111: /* for compatibility with Mach 2.5 kernels */
112: , dealloc
113: #endif /* KERNEL_USER */
114: );
115:
116: /*
117: * Indicates that a copy has been made of the specified range of
118: * the given original memory object. The kernel will use the new
119: * memory object, control and name ports to refer to the new copy
120: * (once the memory manager has asserted its "ready" attribute).
121: *
122: * Cached pages from the original memory object at the time of
123: * the copy operation are handled as follows:
124: * Readable pages may be silently copied to the new
125: * memory object (with all access permissions).
126: * Pages not copied are locked to prevent write access.
127: *
128: * This call includes only the new memory object itself; a
129: * memory_object_init call will be made on the new memory
130: * object after the actions above are completed.
131: *
132: * The new memory object is *temporary*, meaning that the
133: * memory manager should not change its contents or allow
134: * the memory object to be mapped in another client. The
135: * memory manager may use the memory_object_data_unavailable
136: * call to indicate that the appropriate page of the original
137: * memory object may be used to fulfill a data request.
138: *
139: * [Reply should be memory_object_set_attributes on the
140: * new memory object control port to indicate readiness.]
141: */
142: simpleroutine memory_object_copy(
143: old_memory_object : memory_object_t;
144: #if SEQNOS
145: msgseqno seqno : mach_port_seqno_t;
146: #endif /* SEQNOS */
147: old_memory_control : memory_object_control_t =
148: MACH_MSG_TYPE_MAKE_SEND
149: ctype: mach_port_t;
150: offset : vm_offset_t;
151: length : vm_size_t;
152: new_memory_object : memory_object_t =
153: MACH_MSG_TYPE_MOVE_RECEIVE
154: ctype: mach_port_t
155: #if KERNEL_USER
156: /* for compatibility with Mach 2.5 kernels */
157: , dealloc
158: #endif /* KERNEL_USER */
159: );
160:
161: /*
162: * Request data from this memory object. At least
163: * the specified data should be returned with at
164: * least the specified access permitted.
165: *
166: * [Reply should be memory_object_data_provided.]
167: */
168: simpleroutine memory_object_data_request(
169: memory_object : memory_object_t;
170: #if SEQNOS
171: msgseqno seqno : mach_port_seqno_t;
172: #endif /* SEQNOS */
173: memory_control : memory_object_control_t =
174: MACH_MSG_TYPE_MAKE_SEND
175: ctype: mach_port_t;
176: offset : vm_offset_t;
177: length : vm_size_t;
178: desired_access : vm_prot_t);
179:
180: /*
181: * Request that the specified portion of this
182: * memory object be unlocked to allow the specified
183: * forms of access; the kernel already has the data.
184: *
185: * [Reply should be memory_object_lock_request.]
186: */
187: simpleroutine memory_object_data_unlock(
188: memory_object : memory_object_t;
189: #if SEQNOS
190: msgseqno seqno : mach_port_seqno_t;
191: #endif /* SEQNOS */
192: memory_control : memory_object_control_t =
193: MACH_MSG_TYPE_MAKE_SEND
194: ctype: mach_port_t;
195: offset : vm_offset_t;
196: length : vm_size_t;
197: desired_access : vm_prot_t);
198:
199: /*
200: * Write back modifications made to this portion of
201: * the memory object while in memory.
202: *
203: * Unless explicitly requested by a memory_object_lock_request
204: * (clean, but not flush), the kernel will not retain
205: * the data.
206: *
207: * [Reply should be vm_deallocate to release the data.]
208: */
209: simpleroutine memory_object_data_write(
210: memory_object : memory_object_t;
211: #if SEQNOS
212: msgseqno seqno : mach_port_seqno_t;
213: #endif /* SEQNOS */
214: memory_control : memory_object_control_t =
215: MACH_MSG_TYPE_MAKE_SEND
216: ctype: mach_port_t;
217: offset : vm_offset_t;
218: data : pointer_t);
219:
220: /*
221: * Indicate that a previous memory_object_lock_reqeust has been
222: * completed. Note that this call is made on whatever
223: * port is specified in the memory_object_lock_request; that port
224: * need not be the memory object port itself.
225: *
226: * [No reply expected.]
227: */
228: simpleroutine memory_object_lock_completed(
229: memory_object : memory_object_t =
230: polymorphic|MACH_MSG_TYPE_PORT_SEND_ONCE
231: ctype: mach_port_t;
232: #if SEQNOS
233: msgseqno seqno : mach_port_seqno_t;
234: #endif /* SEQNOS */
235: memory_control : memory_object_control_t =
236: MACH_MSG_TYPE_MAKE_SEND
237: ctype: mach_port_t;
238: offset : vm_offset_t;
239: length : vm_size_t);
240:
241: /*
242: * Indicate that a previous memory_object_data_supply has been
243: * completed. Note that this call is made on whatever
244: * port is specified in the memory_object_data_supply; that port
245: * need not be the memory object port itself.
246: *
247: * The result parameter indicates what happened during the supply.
248: * If it is not KERN_SUCCESS, then error_offset identifies the
249: * first offset at which a problem occurred. The pagein operation
250: * stopped at this point. Note that the only failures reported
251: * by this mechanism are KERN_MEMORY_PRESENT. All other failures
252: * (invalid argument, error on pagein of supplied data in manager's
253: * address space) cause the entire operation to fail.
254: *
255: * XXX Check what actually happens in latter case!
256: *
257: * [No reply expected.]
258: */
259: simpleroutine memory_object_supply_completed(
260: memory_object : memory_object_t =
261: polymorphic|MACH_MSG_TYPE_PORT_SEND_ONCE
262: ctype: mach_port_t;
263: #if SEQNOS
264: msgseqno seqno : mach_port_seqno_t;
265: #endif /* SEQNOS */
266: memory_control : memory_object_control_t =
267: MACH_MSG_TYPE_MAKE_SEND
268: ctype: mach_port_t;
269: offset : vm_offset_t;
270: length : vm_size_t;
271: result : kern_return_t;
272: error_offset : vm_offset_t);
273:
274: /*
275: * Return data to manager. This call is used in place of data_write
276: * for objects initialized by object_ready instead of set_attributes.
277: * This call indicates whether the returned data is dirty and whether
278: * the kernel kept a copy. Precious data remains precious if the
279: * kernel keeps a copy. The indication that the kernel kept a copy
280: * is only a hint if the data is not precious; the cleaned copy may
281: * be discarded without further notifying the manager.
282: *
283: * [Reply should be vm_deallocate to release the data.]
284: */
285: simpleroutine memory_object_data_return(
286: memory_object : memory_object_t;
287: #if SEQNOS
288: msgseqno seqno : mach_port_seqno_t;
289: #endif /* SEQNOS */
290: memory_control : memory_object_control_t =
291: MACH_MSG_TYPE_MAKE_SEND
292: ctype: mach_port_t;
293: offset : vm_offset_t;
294: data : pointer_t;
295: dirty : boolean_t;
296: kernel_copy : boolean_t);
297:
298: /*
299: * XXX Warning: This routine does NOT contain a memory_object_control_t
300: * XXX because the memory_object_change_attributes call may cause
301: * XXX memory object termination (by uncaching the object). This would
302: * XXX yield an invalid port.
303: */
304:
305: simpleroutine memory_object_change_completed(
306: memory_object : memory_object_t =
307: polymorphic|MACH_MSG_TYPE_PORT_SEND_ONCE
308: ctype: mach_port_t;
309: #if SEQNOS
310: msgseqno seqno : mach_port_seqno_t;
311: #endif /* SEQNOS */
312: may_cache : boolean_t;
313: copy_strategy : memory_object_copy_strategy_t);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.