osfmk/vm/vm_protos.h

   1 /*
   2  * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_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
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30
  31 #ifdef  XNU_KERNEL_PRIVATE
  32
  33 #ifndef _VM_VM_PROTOS_H_
  34 #define _VM_VM_PROTOS_H_
  35
  36 #include <mach/mach_types.h>
  37 #include <kern/kern_types.h>
  38
  39 /*
  40  * This file contains various type definitions and routine prototypes
  41  * that are needed to avoid compilation warnings for VM code (in osfmk,
  42  * default_pager and bsd).
  43  * Most of these should eventually go into more appropriate header files.
  44  *
  45  * Include it after all other header files since it doesn't include any
  46  * type definitions and it works around some conflicts with other header
  47  * files.
  48  */
  49
  50 /*
  51  * iokit
  52  */
  53 extern kern_return_t device_data_action(
  54         int                     device_handle,
  55         ipc_port_t              device_pager,
  56         vm_prot_t               protection,
  57         vm_object_offset_t      offset,
  58         vm_size_t               size);
  59
  60 extern kern_return_t device_close(
  61         int     device_handle);
  62
  63 /*
  64  * default_pager
  65  */
  66 extern int start_def_pager(
  67         char *bs_device);
  68
  69 /*
  70  * osfmk
  71  */
  72 #ifndef _KERN_IPC_TT_H_ /* XXX FBDP */
  73 /* these should be exported cleanly from OSFMK since BSD needs them */
  74 extern ipc_port_t convert_task_to_port(
  75         task_t          task);
  76 #endif /* _KERN_IPC_TT_H_ */
  77 #ifndef _IPC_IPC_PORT_H_
  78 extern mach_port_name_t ipc_port_copyout_send(
  79         ipc_port_t      sright,
  80         ipc_space_t     space);
  81 extern task_t port_name_to_task(
  82         mach_port_name_t name);
  83 #endif /* _IPC_IPC_PORT_H_ */
  84
  85 extern ipc_space_t  get_task_ipcspace(
  86         task_t t);
  87
  88 /* Some loose-ends VM stuff */
  89
  90 extern vm_map_t         kalloc_map;
  91 extern vm_size_t        msg_ool_size_small;
  92 extern vm_map_t         zone_map;
  93
  94 extern void consider_machine_adjust(void);
  95 extern pmap_t get_map_pmap(vm_map_t);
  96 extern vm_map_offset_t get_map_min(vm_map_t);
  97 extern vm_map_offset_t get_map_max(vm_map_t);
  98 extern vm_map_size_t get_vmmap_size(vm_map_t);
  99 extern int get_vmmap_entries(vm_map_t);
 100
 101 extern boolean_t coredumpok(vm_map_t map, vm_offset_t va);
 102
 103 /*
 104  * VM routines that used to be published to
 105  * user space, and are now restricted to the kernel.
 106  *
 107  * They should eventually go away entirely -
 108  * to be replaced with standard vm_map() and
 109  * vm_deallocate() calls.
 110  */
 111
 112 extern kern_return_t vm_upl_map
 113 (
 114         vm_map_t target_task,
 115         upl_t upl,
 116         vm_address_t *address
 117 );
 118
 119 extern kern_return_t vm_upl_unmap
 120 (
 121         vm_map_t target_task,
 122         upl_t upl
 123 );
 124
 125 extern kern_return_t vm_region_object_create
 126 (
 127         vm_map_t target_task,
 128         vm_size_t size,
 129         ipc_port_t *object_handle
 130 );
 131
 132 extern mach_vm_offset_t mach_get_vm_start(vm_map_t);
 133 extern mach_vm_offset_t mach_get_vm_end(vm_map_t);
 134
 135 /*
 136  * Legacy routines to get the start and end for a vm_map_t.  They
 137  * return them in the vm_offset_t format.  So, they should only be
 138  * called on maps that are the same size as the kernel map for
 139  * accurate results.
 140  */
 141 extern vm_offset_t get_vm_start(vm_map_t);
 142 extern vm_offset_t get_vm_end(vm_map_t);
 143
 144 #ifdef __PPC__
 145 /*
 146  * LP64todo - map in the commpage cleanly and remove these.
 147  */
 148 extern void vm_map_commpage64( vm_map_t );
 149 extern void vm_map_remove_commpage64( vm_map_t );
 150 #endif /* __PPC__ */
 151
 152 /*
 153  * bsd
 154  */
 155 struct vnode;
 156 extern int is_suser(void);
 157 extern int bsd_read_page_cache_file(
 158         unsigned int    user,
 159         int             *fid,
 160         int             *mod,
 161         char            *app_name,
 162         struct vnode    *app_vp,
 163         vm_offset_t     *buffer,
 164         vm_offset_t     *bufsize);
 165 extern int bsd_write_page_cache_file(
 166         unsigned int    user,
 167         char            *file_name,
 168         caddr_t         buffer,
 169         vm_size_t       size,
 170         int             mod,
 171         int             fid);
 172 extern int prepare_profile_database(
 173         int     user);
 174 extern void vnode_pager_shutdown(void);
 175 extern void *upl_get_internal_page_list(
 176         upl_t upl);
 177 #ifndef _VNODE_PAGER_
 178 typedef int pager_return_t;
 179 extern pager_return_t   vnode_pagein(
 180         struct vnode *, upl_t,
 181         vm_offset_t, vm_object_offset_t,
 182         vm_size_t, int, int *);
 183 extern pager_return_t   vnode_pageout(
 184         struct vnode *, upl_t,
 185         vm_offset_t, vm_object_offset_t,
 186         vm_size_t, int, int *);
 187 extern memory_object_t vnode_pager_setup(
 188         struct vnode *, memory_object_t);
 189 extern vm_object_offset_t vnode_pager_get_filesize(
 190         struct vnode *);
 191 #endif /* _VNODE_PAGER_ */
 192 extern void vnode_pager_bootstrap(void);
 193 extern kern_return_t
 194 vnode_pager_data_unlock(
 195         memory_object_t         mem_obj,
 196         memory_object_offset_t  offset,
 197         vm_size_t               size,
 198         vm_prot_t               desired_access);
 199 extern kern_return_t vnode_pager_init(
 200         memory_object_t,
 201         memory_object_control_t,
 202         vm_size_t);
 203 extern kern_return_t vnode_pager_get_object_size(
 204         memory_object_t,
 205         memory_object_offset_t *);
 206 extern kern_return_t vnode_pager_data_request(
 207         memory_object_t,
 208         memory_object_offset_t,
 209         vm_size_t,
 210         vm_prot_t);
 211 extern kern_return_t vnode_pager_data_return(
 212         memory_object_t,
 213         memory_object_offset_t,
 214         vm_size_t,
 215         memory_object_offset_t *,
 216         int *,
 217         boolean_t,
 218         boolean_t,
 219         int);
 220 extern kern_return_t vnode_pager_data_initialize(
 221         memory_object_t,
 222         memory_object_offset_t,
 223         vm_size_t);
 224 extern void vnode_pager_reference(
 225         memory_object_t         mem_obj);
 226 extern kern_return_t vnode_pager_synchronize(
 227         memory_object_t         mem_obj,
 228         memory_object_offset_t  offset,
 229         vm_size_t               length,
 230         vm_sync_t               sync_flags);
 231 extern kern_return_t vnode_pager_unmap(
 232         memory_object_t         mem_obj);
 233 extern void vnode_pager_deallocate(
 234         memory_object_t);
 235 extern kern_return_t vnode_pager_terminate(
 236         memory_object_t);
 237 extern void vnode_pager_vrele(
 238         struct vnode *vp);
 239 extern void vnode_pager_release_from_cache(
 240         int     *);
 241 extern void ubc_unmap(
 242         struct vnode *vp);
 243
 244 extern int      vnode_pager_workaround;
 245 extern int      device_pager_workaround;
 246
 247 extern void   dp_memory_object_reference(memory_object_t);
 248 extern void   dp_memory_object_deallocate(memory_object_t);
 249 #ifndef _memory_object_server_
 250 extern kern_return_t   dp_memory_object_init(memory_object_t,
 251                                              memory_object_control_t,
 252                                              vm_size_t);
 253 extern  kern_return_t dp_memory_object_terminate(memory_object_t);
 254 extern  kern_return_t   dp_memory_object_data_request(memory_object_t,
 255                         memory_object_offset_t, vm_size_t, vm_prot_t);
 256 extern kern_return_t dp_memory_object_data_return(memory_object_t,
 257                                                     memory_object_offset_t,
 258                                                     vm_size_t,
 259                                                     vm_size_t *,
 260                                                     int *,
 261                                                     boolean_t,
 262                                                     boolean_t,
 263                                                     int);
 264 extern kern_return_t dp_memory_object_data_initialize(memory_object_t,
 265                                                       memory_object_offset_t,
 266                                                       vm_size_t);
 267 extern kern_return_t dp_memory_object_data_unlock(memory_object_t,
 268                                                   memory_object_offset_t,
 269                                                   vm_size_t,
 270                                                   vm_prot_t);
 271 extern kern_return_t dp_memory_object_synchronize(memory_object_t,
 272                                                   memory_object_offset_t,
 273                                                   vm_size_t,
 274                                                   vm_sync_t);
 275 extern kern_return_t dp_memory_object_unmap(memory_object_t);
 276 #endif /* _memory_object_server_ */
 277 #ifndef _memory_object_default_server_
 278 extern kern_return_t default_pager_memory_object_create(
 279         memory_object_default_t,
 280         vm_size_t,
 281         memory_object_t *);
 282 #endif /* _memory_object_default_server_ */
 283
 284 extern void   device_pager_reference(memory_object_t);
 285 extern void   device_pager_deallocate(memory_object_t);
 286 extern kern_return_t   device_pager_init(memory_object_t,
 287                                          memory_object_control_t,
 288                                          vm_size_t);
 289 extern  kern_return_t device_pager_terminate(memory_object_t);
 290 extern  kern_return_t   device_pager_data_request(memory_object_t,
 291                                                   memory_object_offset_t,
 292                                                   vm_size_t,
 293                                                   vm_prot_t);
 294 extern kern_return_t device_pager_data_return(memory_object_t,
 295                                               memory_object_offset_t,
 296                                               vm_size_t,
 297                                               boolean_t,
 298                                               boolean_t,
 299                                               int);
 300 extern kern_return_t device_pager_data_initialize(memory_object_t,
 301                                                   memory_object_offset_t,
 302                                                   vm_size_t);
 303 extern kern_return_t device_pager_data_unlock(memory_object_t,
 304                                               memory_object_offset_t,
 305                                               vm_size_t,
 306                                               vm_prot_t);
 307 extern kern_return_t device_pager_synchronize(memory_object_t,
 308                                               memory_object_offset_t,
 309                                               vm_size_t,
 310                                               vm_sync_t);
 311 extern kern_return_t device_pager_unmap(memory_object_t);
 312 extern kern_return_t device_pager_populate_object(
 313         memory_object_t         device,
 314         memory_object_offset_t  offset,
 315         ppnum_t                 page_num,
 316         vm_size_t               size);
 317 extern memory_object_t device_pager_setup(
 318         memory_object_t,
 319         int,
 320         vm_size_t,
 321         int);
 322 extern void device_pager_bootstrap(void);
 323
 324 extern kern_return_t memory_object_create_named(
 325         memory_object_t pager,
 326         memory_object_offset_t  size,
 327         memory_object_control_t         *control);
 328
 329
 330 extern int macx_swapinfo(
 331         memory_object_size_t    *total_p,
 332         memory_object_size_t    *avail_p,
 333         vm_size_t               *pagesize_p,
 334         boolean_t               *encrypted_p);
 335
 336 #endif  /* _VM_VM_PROTOS_H_ */
 337
 338 #endif  /* XNU_KERNEL_PRIVATE */