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

1 /*

3 *

4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

5 *

6 * This file contains Original Code and/or Modifications of Original Code

7 * as defined in and that are subject to the Apple Public Source License

8 * Version 2.0 (the 'License'). You may not use this file except in

9 * compliance with the License. The rights granted to you under the License

10 * may not be used to create, or enable the creation or redistribution of,

11 * unlawful or unlicensed copies of an Apple operating system, or to

12 * circumvent, violate, or enable the circumvention or violation of, any

13 * terms of an Apple operating system software license agreement.

14 *

15 * Please obtain a copy of the License at

16 * http://www.opensource.apple.com/apsl/ and read it before using this file.

17 *

18 * The Original Code and all software distributed under the License are

19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,

21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.

23 * Please see the License for the specific language governing rights and

24 * limitations under the License.

25 *

26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

27 */

28 /*

29 * @OSF_FREE_COPYRIGHT@

30 */

31 /*

32 * Mach Operating System

35 *

36 * Permission to use, copy, modify and distribute this software and its

37 * documentation is hereby granted, provided that both the copyright

38 * notice and this permission notice appear in all copies of the

39 * software, derivative works or modified versions, and any portions

40 * thereof, and that both notices appear in supporting documentation.

41 *

42 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"

43 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR

44 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.

45 *

46 * Carnegie Mellon requests users of this software to return to

47 *

48 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU

49 * School of Computer Science

50 * Carnegie Mellon University

51 * Pittsburgh PA 15213-3890

52 *

53 * any improvements or extensions that they make and grant Carnegie Mellon

54 * the rights to redistribute these changes.

55 */

56 /*

57 */

58 /*

59 * File: mach/vm_map.defs

60 *

61 * Exported kernel VM calls for 32-bit client tasks.

62 */

64 subsystem

65 #if KERNEL_SERVER

66 KernelServer

67 #endif /* KERNEL_SERVER */

68 map 3800;

70 serverprefix vm32_;

72 #include <mach/std_types.defs>

73 #include <mach/mach_types.defs>

74 #include <mach_debug/mach_debug_types.defs>

76 #ifdef VM32_SUPPORT

78 /* See vm_map.defs for more information */

80 routine region(

81 target_task : vm_map_t;

82 inout address : vm32_address_t;

83 out size : vm32_size_t;

84 flavor : vm_region_flavor_t;

85 out info : vm_region_info_t, CountInOut;

86 out object_name : memory_object_name_t =

87 MACH_MSG_TYPE_MOVE_SEND

88 ctype: mach_port_t);

90 routine allocate(

91 target_task : vm_task_entry_t;

92 inout address : vm32_address_t;

93 size : vm32_size_t;

94 flags : int);

96 routine deallocate(

97 target_task : vm_task_entry_t;

98 address : vm32_address_t;

99 size : vm32_size_t);

100

101 routine protect(

102 target_task : vm_task_entry_t;

103 address : vm32_address_t;

104 size : vm32_size_t;

105 set_maximum : boolean_t;

106 new_protection : vm_prot_t);

107

108 routine inherit(

109 target_task : vm_task_entry_t;

110 address : vm32_address_t;

111 size : vm32_size_t;

112 new_inheritance : vm_inherit_t);

113

114 routine read(

115 target_task : vm_map_t;

116 address : vm32_address_t;

117 size : vm32_size_t;

118 out data : pointer_t);

119

120 routine read_list(

121 target_task : vm_map_t;

122 inout data_list : vm32_read_entry_t;

123 count : natural_t);

124

125 routine write(

126 target_task : vm_map_t;

127 address : vm32_address_t;

128 data : pointer_t);

129

130 routine copy(

131 target_task : vm_map_t;

132 source_address : vm32_address_t;

133 size : vm32_size_t;

134 dest_address : vm32_address_t);

135

136 routine read_overwrite(

137 target_task : vm_map_t;

138 address : vm32_address_t;

139 size : vm32_size_t;

140 data : vm32_address_t;

141 out outsize : vm32_size_t);

142

143

144 routine msync(

145 target_task : vm_map_t;

146 address : vm32_address_t;

147 size : vm32_size_t;

148 sync_flags : vm_sync_t );

149

150 routine behavior_set(

151 target_task : vm_map_t;

152 address : vm32_address_t;

153 size : vm32_size_t;

154 new_behavior : vm_behavior_t);

155

156 routine map(

157 target_task : vm_task_entry_t;

158 inout address : vm32_address_t;

159 size : vm32_size_t;

160 mask : vm32_address_t;

161 flags : int;

162 object : mem_entry_name_port_t;

163 offset : vm32_offset_t;

164 copy : boolean_t;

165 cur_protection : vm_prot_t;

166 max_protection : vm_prot_t;

167 inheritance : vm_inherit_t);

168

169 routine machine_attribute(

170 target_task : vm_map_t;

171 address : vm32_address_t;

172 size : vm32_size_t;

173 attribute : vm_machine_attribute_t;

174 inout value : vm_machine_attribute_val_t);

175

176 routine remap(

177 target_task : vm_map_t;

178 inout target_address : vm32_address_t;

179 size : vm32_size_t;

180 mask : vm32_address_t;

181 anywhere : boolean_t;

182 src_task : vm_map_t;

183 src_address : vm32_address_t;

184 copy : boolean_t;

185 out cur_protection : vm_prot_t;

186 out max_protection : vm_prot_t;

187 inheritance : vm_inherit_t);

188

189 routine _task_wire(

190 target_task : vm_map_t;

191 must_wire : boolean_t);

192

193 routine make_memory_entry(

194 target_task :vm_map_t;

195 inout size :vm32_size_t;

196 offset :vm32_offset_t;

197 permission :vm_prot_t;

198 out object_handle :mem_entry_name_port_move_send_t;

199 parent_entry :mem_entry_name_port_t);

200

201 routine map_page_query(

202 target_map :vm_map_t;

203 offset :vm32_offset_t;

204 out disposition :integer_t;

205 out ref_count :integer_t);

206

207 routine region_info(

208 task : vm_map_t;

209 address : vm32_address_t;

210 out region : vm_info_region_t;

211 out objects : vm_info_object_array_t);

212

213 routine mapped_pages_info(

214 task : vm_map_t;

215 out pages : page_address_array_t);

216

217 skip; /* was vm_region_object_create */

218

219 routine region_recurse(

220 target_task : vm_map_t;

221 inout address : vm32_address_t;

222 out size : vm32_size_t;

223 inout nesting_depth : natural_t;

224 out info : vm_region_recurse_info_t,CountInOut);

225

226 routine region_recurse_64(

227 target_task : vm_map_t;

228 inout address : vm32_address_t;

229 out size : vm32_size_t;

230 inout nesting_depth : natural_t;

231 out info : vm_region_recurse_info_t,CountInOut);

232

233 routine region_info_64(

234 task : vm_map_t;

235 address : vm32_address_t;

236 out region : vm_info_region_64_t;

237 out objects : vm_info_object_array_t);

238

239 routine region_64(

240 target_task : vm_map_t;

241 inout address : vm32_address_t;

242 out size : vm32_size_t;

243 flavor : vm_region_flavor_t;

244 out info : vm_region_info_t, CountInOut;

245 out object_name : memory_object_name_t =

246 MACH_MSG_TYPE_MOVE_SEND

247 ctype: mach_port_t);

248

249 routine make_memory_entry_64(

250 target_task :vm_map_t;

251 inout size :memory_object_size_t;

252 offset :memory_object_offset_t;

253 permission :vm_prot_t;

254 out object_handle :mach_port_move_send_t;

255 parent_entry :mem_entry_name_port_t);

256

257

258

259 routine map_64(

260 target_task : vm_task_entry_t;

261 inout address : vm32_address_t;

262 size : vm32_size_t;

263 mask : vm32_address_t;

264 flags : int;

265 object : mem_entry_name_port_t;

266 offset : memory_object_offset_t;

267 copy : boolean_t;

268 cur_protection : vm_prot_t;

269 max_protection : vm_prot_t;

270 inheritance : vm_inherit_t);

271

272 skip; /* was vm_map_get_upl */

273 skip; /* was vm_upl_map */

274 skip; /* was vm_upl_unmap */

275

276 routine purgable_control(

277 target_task : vm_map_t;

278 address : vm32_address_t;

279 control : vm_purgable_t;

280 inout state : int);

281

282

283 routine _map_exec_lockdown(

284 target_task : vm_map_t);

285

286

287 #endif /* VM32_SUPPORT */

288

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