![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to default_pager_internal.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / default_pager|
Return to default_pager_internal.h CVS log | Up to [Apple XNU] / XNU / osfmk / default_pager |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * Mach Operating System ! 27: * Copyright (c) 1991,1990,1989 Carnegie Mellon University ! 28: * All Rights Reserved. ! 29: * ! 30: * Permission to use, copy, modify and distribute this software and its ! 31: * documentation is hereby granted, provided that both the copyright ! 32: * notice and this permission notice appear in all copies of the ! 33: * software, derivative works or modified versions, and any portions ! 34: * thereof, and that both notices appear in supporting documentation. ! 35: * ! 36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 39: * ! 40: * Carnegie Mellon requests users of this software to return to ! 41: * ! 42: * Software Distribution Coordinator or [email protected] ! 43: * School of Computer Science ! 44: * Carnegie Mellon University ! 45: * Pittsburgh PA 15213-3890 ! 46: * ! 47: * any improvements or extensions that they make and grant Carnegie Mellon ! 48: * the rights to redistribute these changes. ! 49: */ ! 50: ! 51: /* ! 52: * Default pager. ! 53: * General definitions. ! 54: */ ! 55: ! 56: #ifndef _DEFAULT_PAGER_INTERNAL_H_ ! 57: #define _DEFAULT_PAGER_INTERNAL_H_ ! 58: ! 59: #include <default_pager/diag.h> ! 60: #include <default_pager/default_pager_types.h> ! 61: #include <mach/mach_types.h> ! 62: #include <ipc/ipc_port.h> ! 63: #include <ipc/ipc_types.h> ! 64: #include <ipc/ipc_space.h> ! 65: #include <kern/lock.h> ! 66: #include <kern/kalloc.h> ! 67: #include <kern/thread.h> ! 68: #include <vm/vm_kern.h> ! 69: #include <device/device_types.h> ! 70: ! 71: /* ! 72: * Default option settings. ! 73: */ ! 74: #ifndef PARALLEL ! 75: #define PARALLEL 1 ! 76: #endif ! 77: ! 78: #ifndef CHECKSUM ! 79: #define CHECKSUM 0 ! 80: #endif ! 81: ! 82: #define MACH_PORT_FACE mach_port_t ! 83: ! 84: #ifndef USE_PRECIOUS ! 85: #define USE_PRECIOUS TRUE ! 86: #endif ! 87: ! 88: #ifdef USER_PAGER ! 89: #define UP(stuff) stuff ! 90: #else /* USER_PAGER */ ! 91: #define UP(stuff) ! 92: #endif /* USER_PAGER */ ! 93: ! 94: extern int norma_mk; /* is the kernel configured with NORMA ? */ ! 95: ! 96: #ifndef MACH_KERNEL ! 97: extern struct mutex dprintf_lock; ! 98: #define PRINTF_LOCK_INIT() mutex_init(&dprintf_lock) ! 99: #define PRINTF_LOCK() mutex_lock(&dprintf_lock) ! 100: #define PRINTF_UNLOCK() mutex_unlock(&dprintf_lock) ! 101: #endif ! 102: ! 103: #ifndef MACH_KERNEL ! 104: #define dprintf(args) \ ! 105: do { \ ! 106: PRINTF_LOCK(); \ ! 107: printf("%s[%d]%s: ", my_name, dp_thread_id(), here); \ ! 108: printf args; \ ! 109: PRINTF_UNLOCK(); \ ! 110: } while (0) ! 111: #else ! 112: #define dprintf(args) \ ! 113: do { \ ! 114: printf("%s[KERNEL:]%s: ", my_name, here); \ ! 115: printf args; \ ! 116: } while (0) ! 117: #endif ! 118: ! 119: /* ! 120: * Debug. ! 121: */ ! 122: extern char my_name[]; ! 123: ! 124: #define DEFAULT_PAGER_DEBUG 0 ! 125: ! 126: #if DEFAULT_PAGER_DEBUG ! 127: ! 128: extern int debug_mask; ! 129: #define DEBUG_MSG_EXTERNAL 0x00000001 ! 130: #define DEBUG_MSG_INTERNAL 0x00000002 ! 131: #define DEBUG_MO_EXTERNAL 0x00000100 ! 132: #define DEBUG_MO_INTERNAL 0x00000200 ! 133: #define DEBUG_VS_EXTERNAL 0x00010000 ! 134: #define DEBUG_VS_INTERNAL 0x00020000 ! 135: #define DEBUG_BS_EXTERNAL 0x01000000 ! 136: #define DEBUG_BS_INTERNAL 0x02000000 ! 137: ! 138: #define DEBUG(level, args) \ ! 139: do { \ ! 140: if (debug_mask & (level)) \ ! 141: dprintf(args); \ ! 142: } while (0) ! 143: ! 144: #define ASSERT(expr) \ ! 145: do { \ ! 146: if (!(expr)) \ ! 147: #ifndef MACH_KERNEL ! 148: panic("%s[%d]%s: assertion failed in %s line %d: %s",\ ! 149: my_name, dp_thread_id(), here, \ ! 150: __FILE__, __LINE__, # expr); \ ! 151: #else ! 152: panic("%s[KERNEL]%s: assertion failed in %s line %d: %s",\ ! 153: my_name, here, __FILE__, __LINE__, # expr); \ ! 154: #endif ! 155: } while (0) ! 156: ! 157: #else /* DEFAULT_PAGER_DEBUG */ ! 158: ! 159: #define DEBUG(level, args) here[0] = here[0] ! 160: #define ASSERT(clause) here[0] = here[0] ! 161: ! 162: #endif /* DEFAULT_PAGER_DEBUG */ ! 163: ! 164: #ifndef MACH_KERNEL ! 165: extern char *mach_error_string(kern_return_t); ! 166: #endif ! 167: ! 168: #define MIN(a,b) (((a) < (b)) ? (a) : (b)) ! 169: ! 170: #define PAGER_SUCCESS 0 ! 171: #define PAGER_FULL 1 ! 172: #define PAGER_ERROR 2 ! 173: ! 174: /* ! 175: * VM and IPC globals. ! 176: */ ! 177: #ifdef MACH_KERNEL ! 178: #define vm_page_size page_size ! 179: extern vm_size_t page_size; ! 180: #else ! 181: extern vm_size_t vm_page_size; ! 182: #endif ! 183: extern int vm_page_mask; ! 184: extern int vm_page_shift; ! 185: ! 186: #ifndef MACH_KERNEL ! 187: #define ptoa(p) ((p)*vm_page_size) ! 188: #define atop(a) ((a)/vm_page_size) ! 189: #endif ! 190: #define howmany(a,b) (((a) + (b) - 1)/(b)) ! 191: ! 192: #ifdef MACH_KERNEL ! 193: extern mutex_t dpt_lock; /* Lock for the dpt array */ ! 194: extern unsigned int default_pager_internal_count; ! 195: extern MACH_PORT_FACE default_pager_host_port; ! 196: /* extern task_t default_pager_self; */ /* dont need or want */ ! 197: extern MACH_PORT_FACE default_pager_internal_set; ! 198: extern MACH_PORT_FACE default_pager_external_set; ! 199: extern MACH_PORT_FACE default_pager_default_port; ! 200: extern MACH_PORT_FACE default_pager_default_set; ! 201: #else ! 202: extern mach_port_t default_pager_host_port; ! 203: extern task_port_t default_pager_self; ! 204: extern mach_port_t default_pager_internal_set; ! 205: extern mach_port_t default_pager_external_set; ! 206: extern mach_port_t default_pager_default_port; ! 207: extern mach_port_t default_pager_default_set; ! 208: #endif ! 209: ! 210: typedef struct default_pager_thread { ! 211: #ifndef MACH_KERNEL ! 212: cthread_t dpt_thread; /* Server thread. */ ! 213: #endif ! 214: vm_offset_t dpt_buffer; /* Read buffer. */ ! 215: boolean_t dpt_internal; /* Do we handle internal objects? */ ! 216: #ifndef MACH_KERNEL ! 217: int dpt_id; /* thread id for printf */ ! 218: #else ! 219: int checked_out; ! 220: #endif ! 221: boolean_t dpt_initialized_p; /* Thread is ready for requests. */ ! 222: } default_pager_thread_t; ! 223: ! 224: #ifdef MACH_KERNEL ! 225: extern default_pager_thread_t **dpt_array; ! 226: #endif ! 227: ! 228: /* ! 229: * Global statistics. ! 230: */ ! 231: struct { ! 232: unsigned int gs_pageout_calls; /* # pageout calls */ ! 233: unsigned int gs_pagein_calls; /* # pagein calls */ ! 234: unsigned int gs_pages_in; /* # pages paged in (total) */ ! 235: unsigned int gs_pages_out; /* # pages paged out (total) */ ! 236: unsigned int gs_pages_unavail; /* # zero-fill pages */ ! 237: unsigned int gs_pages_init; /* # page init requests */ ! 238: unsigned int gs_pages_init_writes; /* # page init writes */ ! 239: VSTATS_LOCK_DECL(gs_lock) ! 240: } global_stats; ! 241: #define GSTAT(clause) VSTATS_ACTION(&global_stats.gs_lock, (clause)) ! 242: ! 243: /* ! 244: * Cluster related definitions. ! 245: * Clusters are sized in number of pages per cluster. ! 246: * Cluster sizes must be powers of two. ! 247: * ! 248: * These numbers are related to the struct vs_map, ! 249: * defined below. ! 250: */ ! 251: #define MAX_CLUSTER_SIZE 8 ! 252: #define MAX_CLUSTER_SHIFT 3 ! 253: #define NO_CLSIZE 0 ! 254: ! 255: /* ! 256: * bit map related macros ! 257: */ ! 258: #define NBBY 8 /* bits per byte XXX */ ! 259: #define BYTEMASK 0xff ! 260: #define setbit(a,i) (*(((char *)(a)) + ((i)/NBBY)) |= 1<<((i)%NBBY)) ! 261: #define clrbit(a,i) (*(((char *)(a)) + ((i)/NBBY)) &= ~(1<<((i)%NBBY))) ! 262: #define isset(a,i) (*(((char *)(a)) + ((i)/NBBY)) & (1<<((i)%NBBY))) ! 263: #define isclr(a,i) ((*(((char *)(a)) + ((i)/NBBY)) & (1<<((i)%NBBY))) == 0) ! 264: ! 265: /* ! 266: * Default Pager. ! 267: * Backing Store Management. ! 268: */ ! 269: ! 270: #define BS_MAXPRI 4 ! 271: #define BS_MINPRI 0 ! 272: #define BS_NOPRI -1 ! 273: #define BS_FULLPRI -2 ! 274: ! 275: /* ! 276: * Mapping between backing store port and backing store object. ! 277: */ ! 278: struct backing_store { ! 279: queue_chain_t bs_links; /* link in backing_store_list */ ! 280: #ifdef MACH_KERNEL ! 281: mutex_t bs_lock; /* lock for the structure */ ! 282: #else ! 283: struct mutex bs_lock; /* lock for the structure */ ! 284: #endif ! 285: MACH_PORT_FACE bs_port; /* backing store port */ ! 286: int bs_priority; ! 287: int bs_clsize; /* cluster size in pages */ ! 288: ! 289: /* statistics */ ! 290: unsigned int bs_pages_free; /* # unallocated pages */ ! 291: unsigned int bs_pages_total; /* # pages (total) */ ! 292: unsigned int bs_pages_in; /* # page read requests */ ! 293: unsigned int bs_pages_in_fail; /* # page read errors */ ! 294: unsigned int bs_pages_out; /* # page write requests */ ! 295: unsigned int bs_pages_out_fail; /* # page write errors */ ! 296: }; ! 297: typedef struct backing_store *backing_store_t; ! 298: #define BACKING_STORE_NULL ((backing_store_t) 0) ! 299: #define BS_STAT(bs, clause) VSTATS_ACTION(&(bs)->bs_lock, (clause)) ! 300: ! 301: #ifdef MACH_KERNEL ! 302: #define BS_LOCK_INIT(bs) mutex_init(&(bs)->bs_lock, ETAP_DPAGE_BS) ! 303: #else ! 304: #define BS_LOCK_INIT(bs) mutex_init(&(bs)->bs_lock) ! 305: #endif ! 306: #define BS_LOCK(bs) mutex_lock(&(bs)->bs_lock) ! 307: #define BS_UNLOCK(bs) mutex_unlock(&(bs)->bs_lock) ! 308: ! 309: struct backing_store_list_head { ! 310: queue_head_t bsl_queue; ! 311: #ifdef MACH_KERNEL ! 312: mutex_t bsl_lock; ! 313: #else ! 314: struct mutex bsl_lock; ! 315: #endif ! 316: }; ! 317: extern struct backing_store_list_head backing_store_list; ! 318: ! 319: #ifdef MACH_KERNEL ! 320: #define BSL_LOCK_INIT() mutex_init(&backing_store_list.bsl_lock, ETAP_DPAGE_BSL) ! 321: #else ! 322: #define BSL_LOCK_INIT() mutex_init(&backing_store_list.bsl_lock) ! 323: #endif ! 324: #define BSL_LOCK() mutex_lock(&backing_store_list.bsl_lock) ! 325: #define BSL_UNLOCK() mutex_unlock(&backing_store_list.bsl_lock) ! 326: ! 327: /* ! 328: * Paging segment management. ! 329: * Controls allocation of blocks within paging area. ! 330: */ ! 331: struct paging_segment { ! 332: /* device management */ ! 333: union { ! 334: MACH_PORT_FACE dev; /* Port to device */ ! 335: struct vnode *vnode; /* vnode for bs file */ ! 336: } storage_type; ! 337: unsigned int ps_segtype; /* file type or partition */ ! 338: MACH_PORT_FACE ps_device; /* Port to device */ ! 339: vm_offset_t ps_offset; /* Offset of segment within device */ ! 340: vm_offset_t ps_recnum; /* Number of device records in segment*/ ! 341: unsigned int ps_pgnum; /* Number of pages in segment */ ! 342: unsigned int ps_record_shift;/* Bit shift: pages to device records */ ! 343: ! 344: /* clusters and pages */ ! 345: unsigned int ps_clshift; /* Bit shift: clusters to pages */ ! 346: unsigned int ps_ncls; /* Number of clusters in segment */ ! 347: unsigned int ps_clcount; /* Number of free clusters */ ! 348: unsigned int ps_pgcount; /* Number of free pages */ ! 349: long ps_hint; /* Hint of where to look next. */ ! 350: ! 351: /* bitmap */ ! 352: #ifdef MACH_KERNEL ! 353: mutex_t ps_lock; /* Lock for contents of struct */ ! 354: #else ! 355: struct mutex ps_lock; /* Lock for contents of struct */ ! 356: #endif ! 357: unsigned char *ps_bmap; /* Map of used clusters */ ! 358: ! 359: /* backing store */ ! 360: backing_store_t ps_bs; /* Backing store segment belongs to */ ! 361: ! 362: boolean_t ps_going_away; /* Destroy attempt in progress */ ! 363: }; ! 364: ! 365: #define ps_vnode storage_type.vnode ! 366: #define ps_device storage_type.dev ! 367: #define PS_PARTITION 1 ! 368: #define PS_FILE 2 ! 369: ! 370: typedef struct paging_segment *paging_segment_t; ! 371: ! 372: #define PAGING_SEGMENT_NULL ((paging_segment_t) 0) ! 373: ! 374: #ifdef MACH_KERNEL ! 375: #define PS_LOCK_INIT(ps) mutex_init(&(ps)->ps_lock, ETAP_DPAGE_SEGMENT) ! 376: #else ! 377: #define PS_LOCK_INIT(ps) mutex_init(&(ps)->ps_lock) ! 378: #endif ! 379: #define PS_LOCK(ps) mutex_lock(&(ps)->ps_lock) ! 380: #define PS_UNLOCK(ps) mutex_unlock(&(ps)->ps_lock) ! 381: ! 382: typedef unsigned int pseg_index_t; ! 383: ! 384: #define INVALID_PSEG_INDEX ((pseg_index_t)-1) ! 385: #define NULL_PSEG_INDEX ((pseg_index_t) 0) ! 386: /* ! 387: * MAX_PSEG_INDEX value is related to struct vs_map below. ! 388: * "0" is reserved for empty map entries (no segment). ! 389: */ ! 390: #define MAX_PSEG_INDEX 31 /* 0 is reserved for empty map */ ! 391: #define MAX_NUM_PAGING_SEGMENTS MAX_PSEG_INDEX ! 392: ! 393: /* paging segments array */ ! 394: extern paging_segment_t paging_segments[MAX_NUM_PAGING_SEGMENTS]; ! 395: #ifdef MACH_KERNEL ! 396: extern mutex_t paging_segments_lock; ! 397: #else ! 398: extern struct mutex paging_segments_lock; ! 399: #endif ! 400: extern int paging_segment_count; /* number of active paging segments */ ! 401: extern int paging_segment_max; /* highest used paging segment index */ ! 402: extern int ps_select_array[DEFAULT_PAGER_BACKING_STORE_MAXPRI+1]; ! 403: ! 404: #ifdef MACH_KERNEL ! 405: #define PSL_LOCK_INIT() mutex_init(&paging_segments_lock, ETAP_DPAGE_SEGLIST) ! 406: #else ! 407: #define PSL_LOCK_INIT() mutex_init(&paging_segments_lock) ! 408: #endif ! 409: #define PSL_LOCK() mutex_lock(&paging_segments_lock) ! 410: #define PSL_UNLOCK() mutex_unlock(&paging_segments_lock) ! 411: ! 412: /* ! 413: * Vstruct manipulation. The vstruct is the pager's internal ! 414: * representation of vm objects it manages. There is one vstruct allocated ! 415: * per vm object. ! 416: * ! 417: * The following data structures are defined for vstruct and vm object ! 418: * management. ! 419: */ ! 420: ! 421: /* ! 422: * vs_map ! 423: * A structure used only for temporary objects. It is the element ! 424: * contained in the vs_clmap structure, which contains information ! 425: * about which clusters and pages in an object are present on backing ! 426: * store (a paging file). ! 427: * Note that this structure and its associated constants may change ! 428: * with minimal impact on code. The only function which knows the ! 429: * internals of this structure is ps_clmap(). ! 430: * ! 431: * If it is necessary to change the maximum number of paging segments ! 432: * or pages in a cluster, then this structure is the one most ! 433: * affected. The constants and structures which *may* change are: ! 434: * MAX_CLUSTER_SIZE ! 435: * MAX_CLUSTER_SHIFT ! 436: * MAX_NUM_PAGING_SEGMENTS ! 437: * VSTRUCT_DEF_CLSHIFT ! 438: * struct vs_map and associated macros and constants (VSM_*) ! 439: * (only the macro definitions need change, the exported (inside the ! 440: * pager only) interfaces remain the same; the constants are for ! 441: * internal vs_map manipulation only). ! 442: * struct clbmap (below). ! 443: */ ! 444: struct vs_map { ! 445: unsigned int vsmap_entry:23, /* offset in paging segment */ ! 446: vsmap_psindex:8, /* paging segment */ ! 447: vsmap_error:1, ! 448: vsmap_bmap:16, ! 449: vsmap_alloc:16; ! 450: }; ! 451: ! 452: typedef struct vs_map *vs_map_t; ! 453: ! 454: ! 455: #define VSM_ENTRY_NULL 0x7fffff ! 456: ! 457: /* ! 458: * Exported macros for manipulating the vs_map structure -- ! 459: * checking status, getting and setting bits. ! 460: */ ! 461: #define VSCLSIZE(vs) (1 << (vs)->vs_clshift) ! 462: #define VSM_ISCLR(vsm) (((vsm).vsmap_entry == VSM_ENTRY_NULL) && \ ! 463: ((vsm).vsmap_error == 0)) ! 464: #define VSM_ISERR(vsm) ((vsm).vsmap_error) ! 465: #define VSM_SETCLOFF(vsm, val) ((vsm).vsmap_entry = (val)) ! 466: #define VSM_SETERR(vsm, err) ((vsm).vsmap_error = 1, \ ! 467: (vsm).vsmap_entry = (err)) ! 468: #define VSM_GETERR(vsm) ((vsm).vsmap_entry) ! 469: #define VSM_SETPG(vsm, page) ((vsm).vsmap_bmap |= (1 << (page))) ! 470: #define VSM_CLRPG(vsm, page) ((vsm).vsmap_bmap &= ~(1 << (page))) ! 471: #define VSM_SETPS(vsm, psindx) ((vsm).vsmap_psindex = (psindx)) ! 472: #define VSM_PSINDEX(vsm) ((vsm).vsmap_psindex) ! 473: #define VSM_PS(vsm) paging_segments[(vsm).vsmap_psindex] ! 474: #define VSM_BMAP(vsm) ((vsm).vsmap_bmap) ! 475: #define VSM_CLOFF(vsm) ((vsm).vsmap_entry) ! 476: #define VSM_CLR(vsm) ((vsm).vsmap_entry = VSM_ENTRY_NULL, \ ! 477: (vsm).vsmap_psindex = 0, \ ! 478: (vsm).vsmap_error = 0, \ ! 479: (vsm).vsmap_bmap = 0, \ ! 480: (vsm).vsmap_alloc = 0) ! 481: #define VSM_ALLOC(vsm) ((vsm).vsmap_alloc) ! 482: #define VSM_SETALLOC(vsm, page) ((vsm).vsmap_alloc |= (1 << (page))) ! 483: #define VSM_CLRALLOC(vsm, page) ((vsm).vsmap_alloc &= ~(1 << (page))) ! 484: ! 485: /* ! 486: * Constants and macros for dealing with vstruct maps, ! 487: * which comprise vs_map structures, which ! 488: * map vm objects to backing storage (paging files and clusters). ! 489: */ ! 490: #define CLMAP_THRESHOLD 512 /* bytes */ ! 491: #define CLMAP_ENTRIES (CLMAP_THRESHOLD/sizeof(struct vs_map)) ! 492: #define CLMAP_SIZE(ncls) (ncls*sizeof(struct vs_map)) ! 493: ! 494: #define INDIRECT_CLMAP_ENTRIES(ncls) (((ncls-1)/CLMAP_ENTRIES) + 1) ! 495: #define INDIRECT_CLMAP_SIZE(ncls) (INDIRECT_CLMAP_ENTRIES(ncls) * sizeof(struct vs_map *)) ! 496: #define INDIRECT_CLMAP(size) (CLMAP_SIZE(size) > CLMAP_THRESHOLD) ! 497: ! 498: #define RMAPSIZE(blocks) (howmany(blocks,NBBY)) ! 499: ! 500: #define CL_FIND 1 ! 501: #define CL_ALLOC 2 ! 502: ! 503: /* ! 504: * clmap ! 505: * ! 506: * A cluster map returned by ps_clmap. It is an abstracted cluster of ! 507: * pages. It gives the caller information about the cluster ! 508: * desired. On read it tells the caller if a cluster is mapped, and if so, ! 509: * which of its pages are valid. It should not be referenced directly, ! 510: * except by ps_clmap; macros should be used. If the number of pages ! 511: * in a cluster needs to be more than 32, then the struct clbmap must ! 512: * become larger. ! 513: */ ! 514: struct clbmap { ! 515: unsigned int clb_map; ! 516: }; ! 517: ! 518: struct clmap { ! 519: paging_segment_t cl_ps; /* paging segment backing cluster */ ! 520: int cl_numpages; /* number of valid pages */ ! 521: struct clbmap cl_bmap; /* map of pages in cluster */ ! 522: int cl_error; /* cluster error value */ ! 523: struct clbmap cl_alloc; /* map of allocated pages in cluster */ ! 524: }; ! 525: ! 526: #define CLMAP_ERROR(clm) (clm).cl_error ! 527: #define CLMAP_PS(clm) (clm).cl_ps ! 528: #define CLMAP_NPGS(clm) (clm).cl_numpages ! 529: #define CLMAP_ISSET(clm,i) ((1<<(i))&((clm).cl_bmap.clb_map)) ! 530: #define CLMAP_ALLOC(clm) (clm).cl_alloc.clb_map ! 531: /* ! 532: * Shift off unused bits in a partial cluster ! 533: */ ! 534: #define CLMAP_SHIFT(clm,vs) \ ! 535: (clm)->cl_bmap.clb_map >>= (VSCLSIZE(vs) - (clm)->cl_numpages) ! 536: #define CLMAP_SHIFTALLOC(clm,vs) \ ! 537: (clm)->cl_alloc.clb_map >>= (VSCLSIZE(vs) - (clm)->cl_numpages) ! 538: ! 539: typedef struct vstruct_alias { ! 540: vm_offset_t name; ! 541: struct vstruct *vs; ! 542: } vstruct_alias_t; ! 543: ! 544: /* ! 545: * VM Object Structure: This is the structure used to manage pagers associated ! 546: * to VM objects.Mapping between pager port and paging object. ! 547: */ ! 548: ! 549: typedef struct vstruct { ! 550: queue_chain_t vs_links; /* Link in pager-port list */ ! 551: #ifdef MACH_KERNEL ! 552: hw_lock_data_t vs_lock; /* Lock for the structure */ ! 553: #else ! 554: struct mutex vs_lock; /* Lock for the structure */ ! 555: #endif ! 556: MACH_PORT_FACE vs_mem_obj_port; /* Memory object port */ ! 557: mach_port_seqno_t vs_next_seqno; /* next sequence number to issue */ ! 558: mach_port_seqno_t vs_seqno; /* Pager port sequence number */ ! 559: MACH_PORT_FACE vs_control_port;/* Memory object's control port */ ! 560: mach_port_urefs_t vs_control_refs; /* Mem object's control port refs */ ! 561: MACH_PORT_FACE vs_object_name; /* Name port */ ! 562: mach_port_urefs_t vs_name_refs; /* Name port user-refs */ ! 563: ! 564: #ifdef MACH_KERNEL ! 565: boolean_t vs_waiting_seqno;/* to wait on seqno */ ! 566: boolean_t vs_waiting_read; /* to wait on readers */ ! 567: boolean_t vs_waiting_write;/* to wait on writers */ ! 568: boolean_t vs_waiting_refs; /* to wait on refs */ ! 569: boolean_t vs_waiting_async;/* to wait on async_pending */ ! 570: #else ! 571: event_t vs_waiting_seqno;/* to wait on seqno */ ! 572: event_t vs_waiting_read; /* to wait on readers */ ! 573: event_t vs_waiting_write;/* to wait on writers */ ! 574: event_t vs_waiting_refs; /* to wait on refs */ ! 575: event_t vs_waiting_async;/* to wait on async_pending */ ! 576: #endif ! 577: unsigned int vs_readers; /* Reads in progress */ ! 578: unsigned int vs_writers; /* Writes in progress */ ! 579: ! 580: unsigned int vs_errors; /* Pageout error count */ ! 581: ! 582: int vs_clshift; /* Bit shift: clusters to pages */ ! 583: int vs_size; /* Object size in clusters */ ! 584: int vs_indirect:1, /* Is the map indirect ? */ ! 585: vs_xfer_pending:1; /* xfering out of a seg ? */ ! 586: int vs_async_pending; /* Count of pending async writes */ ! 587: #ifdef MACH_KERNEL ! 588: mutex_t vs_map_lock; /* to protect map below */ ! 589: #else ! 590: struct mutex vs_map_lock; /* to protect map below */ ! 591: #endif ! 592: union { ! 593: struct vs_map *vsu_dmap; /* Direct map of clusters */ ! 594: struct vs_map **vsu_imap; /* Indirect map of clusters */ ! 595: } vs_un; ! 596: } *vstruct_t; ! 597: ! 598: #define vs_dmap vs_un.vsu_dmap ! 599: #define vs_imap vs_un.vsu_imap ! 600: #define MEM_OBJ_CTL(vs) ((vs)->vs_control_port) ! 601: ! 602: #define VSTRUCT_NULL ((vstruct_t) 0) ! 603: ! 604: #ifdef MACH_KERNEL ! 605: #define DPT_LOCK_INIT(lock) mutex_init(&(lock), ETAP_DPAGE_VSTRUCT) ! 606: #define DPT_LOCK(lock) mutex_lock(&(lock)) ! 607: #define DPT_UNLOCK(lock) mutex_unlock(&(lock)) ! 608: #define VS_LOCK_INIT(vs) hw_lock_init(&(vs)->vs_lock) ! 609: #define VS_TRY_LOCK(vs) (VS_LOCK(vs),TRUE) ! 610: #define VS_LOCK(vs) hw_lock_lock(&(vs)->vs_lock) ! 611: #define VS_UNLOCK(vs) hw_lock_unlock(&(vs)->vs_lock) ! 612: #else ! 613: #define VS_LOCK_INIT(vs) mutex_init(&(vs)->vs_lock, ETAP_DPAGE_VSTRUCT) ! 614: #define VS_TRY_LOCK(vs) mutex_try_lock(&(vs)->vs_lock) ! 615: #define VS_LOCK(vs) mutex_lock(&(vs)->vs_lock) ! 616: #define VS_UNLOCK(vs) mutex_unlock(&(vs)->vs_lock) ! 617: #endif ! 618: ! 619: #ifdef MACH_KERNEL ! 620: #define VS_MAP_LOCK_INIT(vs) mutex_init(&(vs)->vs_map_lock, ETAP_DPAGE_VSMAP) ! 621: #else ! 622: #define VS_MAP_LOCK_INIT(vs) mutex_init(&(vs)->vs_map_lock) ! 623: #endif ! 624: #define VS_MAP_LOCK(vs) mutex_lock(&(vs)->vs_map_lock) ! 625: #ifndef MACH_KERNEL ! 626: #define VS_MAP_TRY_LOCK(vs) mutex_try_lock(&(vs)->vs_map_lock) ! 627: #else ! 628: #define VS_MAP_TRY_LOCK(vs) mutex_try(&(vs)->vs_map_lock) ! 629: #endif ! 630: #define VS_MAP_UNLOCK(vs) mutex_unlock(&(vs)->vs_map_lock) ! 631: ! 632: /* ! 633: * Data structures and variables dealing with asynchronous ! 634: * completion of paging operations. ! 635: */ ! 636: /* ! 637: * vs_async ! 638: * A structure passed to ps_write_device for asynchronous completions. ! 639: * It contains enough information to complete the write and ! 640: * inform the VM of its completion. ! 641: */ ! 642: struct vs_async { ! 643: struct vs_async *vsa_next; /* pointer to next structure */ ! 644: vstruct_t vsa_vs; /* the vstruct for the object */ ! 645: vm_offset_t vsa_addr; /* the vaddr of the data moved */ ! 646: vm_offset_t vsa_offset; /* the object offset of the data */ ! 647: vm_size_t vsa_size; /* the number of bytes moved */ ! 648: paging_segment_t vsa_ps; /* the paging segment used */ ! 649: int vsa_flags; /* flags */ ! 650: int vsa_error; /* error, if there is one */ ! 651: mutex_t vsa_lock; ! 652: MACH_PORT_FACE reply_port; /* associated reply port */ ! 653: }; ! 654: ! 655: /* ! 656: * flags values. ! 657: */ ! 658: #define VSA_READ 0x0001 ! 659: #define VSA_WRITE 0x0002 ! 660: #define VSA_TRANSFER 0x0004 ! 661: ! 662: /* ! 663: * List of all vstructs. A specific vstruct is ! 664: * found directly via its port, this list is ! 665: * only used for monitoring purposes by the ! 666: * default_pager_object* calls ! 667: */ ! 668: struct vstruct_list_head { ! 669: queue_head_t vsl_queue; ! 670: #ifdef MACH_KERNEL ! 671: mutex_t vsl_lock; ! 672: #else ! 673: struct mutex vsl_lock; ! 674: #endif ! 675: int vsl_count; /* saves code */ ! 676: queue_head_t vsl_leak_queue; ! 677: }; ! 678: extern struct vstruct_list_head vstruct_list; ! 679: ! 680: #ifdef MACH_KERNEL ! 681: #define VSL_LOCK_INIT() mutex_init(&vstruct_list.vsl_lock, ETAP_DPAGE_VSLIST) ! 682: #else ! 683: #define VSL_LOCK_INIT() mutex_init(&vstruct_list.vsl_lock) ! 684: #endif ! 685: #define VSL_LOCK() mutex_lock(&vstruct_list.vsl_lock) ! 686: #define VSL_LOCK_TRY() mutex_try(&vstruct_list.vsl_lock) ! 687: #define VSL_UNLOCK() mutex_unlock(&vstruct_list.vsl_lock) ! 688: ! 689: /* ! 690: * Create port alias for vstruct address. ! 691: * ! 692: * We assume that the last two bits of a vstruct address will be zero due to ! 693: * memory allocation restrictions, hence are available for use as a sanity ! 694: * check. ! 695: */ ! 696: #ifdef MACH_KERNEL ! 697: #define ISVS 123456 ! 698: #define port_is_vs(_port_) \ ! 699: ((((struct vstruct_alias *)((_port_)->alias)) != NULL) && \ ! 700: (((struct vstruct_alias *)(_port_)->alias)->name==ISVS)) ! 701: #define port_to_vs(_port_) \ ! 702: ((struct vstruct_alias *)(_port_)->alias)->vs ! 703: #define vs_to_port(_vs_) (_vs_->vs_mem_obj_port) ! 704: #define vs_lookup(_port_, _vs_) \ ! 705: do { \ ! 706: if ((((struct vstruct_alias *)(_port_)->alias) == NULL) || \ ! 707: (((struct vstruct_alias *)(_port_)->alias)->name!=ISVS)) \ ! 708: panic("bad pager port"); \ ! 709: _vs_ = port_to_vs(_port_); \ ! 710: } while (0) ! 711: #else ! 712: #define vs_to_port(_vs_) (((vm_offset_t)(_vs_))+1) ! 713: #define port_to_vs(_port_) ((vstruct_t)(((vm_offset_t)(_port_))&~3)) ! 714: #define port_is_vs(_port_) ((((vm_offset_t)(_port_))&3) == 1) ! 715: ! 716: #define vs_lookup(_port_, _vs_) \ ! 717: do { \ ! 718: if (!MACH_PORT_VALID(_port_) || !port_is_vs(_port_) \ ! 719: || port_to_vs(_port_)->vs_mem_obj_port != (_port_)) \ ! 720: Panic("bad pager port"); \ ! 721: _vs_ = port_to_vs(_port_); \ ! 722: } while (0) ! 723: #endif ! 724: ! 725: /* ! 726: * Cross-module routines declaration. ! 727: */ ! 728: #ifndef MACH_KERNEL ! 729: extern int dp_thread_id(void); ! 730: #endif ! 731: extern boolean_t device_reply_server(mach_msg_header_t *, ! 732: mach_msg_header_t *); ! 733: #ifdef MACH_KERNEL ! 734: extern void default_pager_no_senders(MACH_PORT_FACE, ! 735: mach_port_seqno_t, ! 736: mach_port_mscount_t); ! 737: #else ! 738: extern void default_pager_no_senders(memory_object_t, ! 739: mach_port_seqno_t, ! 740: mach_port_mscount_t); ! 741: #endif ! 742: extern int local_log2(unsigned int); ! 743: extern void bs_initialize(void); ! 744: extern void bs_global_info(vm_size_t *, ! 745: vm_size_t *); ! 746: extern boolean_t bs_add_device(char *, ! 747: MACH_PORT_FACE); ! 748: extern vstruct_t ps_vstruct_create(vm_size_t); ! 749: extern void ps_vstruct_dealloc(vstruct_t); ! 750: extern kern_return_t pvs_cluster_read(vstruct_t, ! 751: vm_offset_t, ! 752: vm_size_t); ! 753: extern kern_return_t vs_cluster_write(vstruct_t, ! 754: vm_offset_t, ! 755: vm_offset_t, ! 756: vm_size_t, ! 757: boolean_t); ! 758: extern vm_offset_t ps_clmap(vstruct_t, ! 759: vm_offset_t, ! 760: struct clmap *, ! 761: int, ! 762: vm_size_t, ! 763: int); ! 764: extern vm_size_t ps_vstruct_allocated_size(vstruct_t); ! 765: extern size_t ps_vstruct_allocated_pages(vstruct_t, ! 766: default_pager_page_t *, ! 767: size_t); ! 768: extern boolean_t bs_set_default_clsize(unsigned int); ! 769: ! 770: extern boolean_t verbose; ! 771: ! 772: #endif /* _DEFAULT_PAGER_INTERNAL_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.