1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 /* 30 * University Copyright- Copyright (c) 1982, 1986, 1988 31 * The Regents of the University of California 32 * All Rights Reserved 33 * 34 * University Acknowledgment- Portions of this document are derived from 35 * software developed by the University of California, Berkeley, and its 36 * contributors. 37 */ 38 39 #ifndef _VM_HAT_H 40 #define _VM_HAT_H 41 42 #include <sys/types.h> 43 #include <sys/t_lock.h> 44 #include <vm/faultcode.h> 45 #include <sys/kstat.h> 46 #include <sys/siginfo.h> 47 48 #ifdef __cplusplus 49 extern "C" { 50 #endif 51 52 /* 53 * VM - Hardware Address Translation management. 54 * 55 * This file describes the machine independent interfaces to 56 * the hardware address translation management routines. Other 57 * machine specific interfaces and structures are defined 58 * in <vm/hat_xxx.h>. The hat layer manages the address 59 * translation hardware as a cache driven by calls from the 60 * higher levels of the VM system. 61 */ 62 63 struct hat; 64 struct kpme; 65 struct memseg; 66 67 #include <vm/page.h> 68 69 /* 70 * a callback used with hat_unload_callback() 71 * start and end mark are set to a range of unloaded addresses 72 * and the function is invoked with a pointer to this data structure 73 */ 74 typedef struct hat_callback { 75 caddr_t hcb_start_addr; 76 caddr_t hcb_end_addr; 77 void (*hcb_function)(struct hat_callback *); 78 void *hcb_data; 79 } hat_callback_t; 80 81 typedef void *hat_region_cookie_t; 82 83 #ifdef _KERNEL 84 85 /* 86 * One time hat initialization 87 */ 88 void hat_init(void); 89 90 /* 91 * Notify hat of a system dump 92 */ 93 void hat_dump(void); 94 95 /* 96 * Operations on an address space: 97 * 98 * struct hat *hat_alloc(as) 99 * allocated a hat structure for as. 100 * 101 * void hat_free_start(hat) 102 * informs hat layer process has finished executing but as has not 103 * been cleaned up yet. 104 * 105 * void hat_free_end(hat) 106 * informs hat layer as is being destroyed. hat layer cannot use as 107 * pointer after this call. 108 * 109 * void hat_swapin(hat) 110 * allocate any hat resources required for process being swapped in. 111 * 112 * void hat_swapout(hat) 113 * deallocate hat resources for process being swapped out. 114 * 115 * size_t hat_get_mapped_size(hat) 116 * returns number of bytes that have valid mappings in hat. 117 * 118 * void hat_stats_enable(hat) 119 * void hat_stats_disable(hat) 120 * enables/disables collection of stats for hat. 121 * 122 * int hat_dup(parenthat, childhat, addr, len, flags) 123 * Duplicate address translations of the parent to the child. Supports 124 * the entire address range or a range depending on flag, 125 * zero returned on success, non-zero on error 126 * 127 * void hat_thread_exit(thread) 128 * Notifies the HAT that a thread is exiting, called after it has been 129 * reassigned to the kernel AS. 130 */ 131 132 struct hat *hat_alloc(struct as *); 133 void hat_free_start(struct hat *); 134 void hat_free_end(struct hat *); 135 int hat_dup(struct hat *, struct hat *, caddr_t, size_t, uint_t); 136 void hat_swapin(struct hat *); 137 void hat_swapout(struct hat *); 138 size_t hat_get_mapped_size(struct hat *); 139 int hat_stats_enable(struct hat *); 140 void hat_stats_disable(struct hat *); 141 void hat_thread_exit(kthread_t *); 142 143 /* 144 * Operations on a named address within a segment: 145 * 146 * void hat_memload(hat, addr, pp, attr, flags) 147 * load/lock the given page struct 148 * 149 * void hat_memload_array(hat, addr, len, ppa, attr, flags) 150 * load/lock the given array of page structs 151 * 152 * void hat_devload(hat, addr, len, pf, attr, flags) 153 * load/lock the given page frame number 154 * 155 * void hat_unlock(hat, addr, len) 156 * unlock a given range of addresses 157 * 158 * void hat_unload(hat, addr, len, flags) 159 * void hat_unload_callback(hat, addr, len, flags, callback) 160 * unload a given range of addresses (has optional callback) 161 * 162 * void hat_sync(hat, addr, len, flags) 163 * synchronize mapping with software data structures 164 * 165 * void hat_map(hat, addr, len, flags) 166 * 167 * void hat_setattr(hat, addr, len, attr) 168 * void hat_clrattr(hat, addr, len, attr) 169 * void hat_chgattr(hat, addr, len, attr) 170 * modify attributes for a range of addresses. skips any invalid mappings 171 * 172 * uint_t hat_getattr(hat, addr, *attr) 173 * returns attr for <hat,addr> in *attr. returns 0 if there was a 174 * mapping and *attr is valid, nonzero if there was no mapping and 175 * *attr is not valid. 176 * 177 * size_t hat_getpagesize(hat, addr) 178 * returns pagesize in bytes for <hat, addr>. returns -1 if there is 179 * no mapping. This is an advisory call. 180 * 181 * pfn_t hat_getpfnum(hat, addr) 182 * returns pfn for <hat, addr> or PFN_INVALID if mapping is invalid. 183 * 184 * pfn_t hat_getkpfnum(addr) 185 * returns pfn for non-memory mapped addr in kernel address space 186 * or PFN_INVALID if mapping is invalid or is kernel memory. 187 * 188 * int hat_probe(hat, addr) 189 * return 0 if no valid mapping is present. Faster version 190 * of hat_getattr in certain architectures. 191 * 192 * int hat_share(dhat, daddr, shat, saddr, len, szc) 193 * 194 * void hat_unshare(hat, addr, len, szc) 195 * 196 * void hat_chgprot(hat, addr, len, vprot) 197 * This is a deprecated call. New segment drivers should store 198 * all attributes and use hat_*attr calls. 199 * Change the protections in the virtual address range 200 * given to the specified virtual protection. If vprot is ~PROT_WRITE, 201 * then remove write permission, leaving the other permissions 202 * unchanged. If vprot is ~PROT_USER, remove user permissions. 203 */ 204 205 void hat_memload(struct hat *, caddr_t, struct page *, uint_t, uint_t); 206 void hat_memload_array(struct hat *, caddr_t, size_t, struct page **, 207 uint_t, uint_t); 208 void hat_memload_region(struct hat *, caddr_t, struct page *, uint_t, 209 uint_t, hat_region_cookie_t); 210 void hat_memload_array_region(struct hat *, caddr_t, size_t, struct page **, 211 uint_t, uint_t, hat_region_cookie_t); 212 213 void hat_devload(struct hat *, caddr_t, size_t, pfn_t, uint_t, int); 214 215 void hat_unlock(struct hat *, caddr_t, size_t); 216 void hat_unlock_region(struct hat *, caddr_t, size_t, hat_region_cookie_t); 217 218 void hat_unload(struct hat *, caddr_t, size_t, uint_t); 219 void hat_unload_callback(struct hat *, caddr_t, size_t, uint_t, 220 hat_callback_t *); 221 void hat_sync(struct hat *, caddr_t, size_t, uint_t); 222 void hat_map(struct hat *, caddr_t, size_t, uint_t); 223 void hat_setattr(struct hat *, caddr_t, size_t, uint_t); 224 void hat_clrattr(struct hat *, caddr_t, size_t, uint_t); 225 void hat_chgattr(struct hat *, caddr_t, size_t, uint_t); 226 uint_t hat_getattr(struct hat *, caddr_t, uint_t *); 227 ssize_t hat_getpagesize(struct hat *, caddr_t); 228 pfn_t hat_getpfnum(struct hat *, caddr_t); 229 int hat_probe(struct hat *, caddr_t); 230 int hat_share(struct hat *, caddr_t, struct hat *, caddr_t, size_t, uint_t); 231 void hat_unshare(struct hat *, caddr_t, size_t, uint_t); 232 void hat_chgprot(struct hat *, caddr_t, size_t, uint_t); 233 void hat_reserve(struct as *, caddr_t, size_t); 234 pfn_t va_to_pfn(void *); 235 uint64_t va_to_pa(void *); 236 237 /* 238 * hat_getkpfnum() is never supported on amd64 and will be 239 * removed from other platforms in future release 240 */ 241 #if !defined(__amd64) 242 pfn_t hat_getkpfnum(caddr_t); 243 #endif 244 245 246 /* 247 * Kernel Physical Mapping (segkpm) hat interface routines. 248 */ 249 caddr_t hat_kpm_mapin(struct page *, struct kpme *); 250 void hat_kpm_mapout(struct page *, struct kpme *, caddr_t); 251 caddr_t hat_kpm_mapin_pfn(pfn_t); 252 void hat_kpm_mapout_pfn(pfn_t); 253 caddr_t hat_kpm_page2va(struct page *, int); 254 struct page *hat_kpm_vaddr2page(caddr_t); 255 int hat_kpm_fault(struct hat *, caddr_t); 256 void hat_kpm_mseghash_clear(int); 257 void hat_kpm_mseghash_update(pgcnt_t, struct memseg *); 258 void hat_kpm_addmem_mseg_update(struct memseg *, pgcnt_t, offset_t); 259 void hat_kpm_addmem_mseg_insert(struct memseg *); 260 void hat_kpm_addmem_memsegs_update(struct memseg *); 261 caddr_t hat_kpm_mseg_reuse(struct memseg *); 262 void hat_kpm_delmem_mseg_update(struct memseg *, struct memseg **); 263 void hat_kpm_split_mseg_update(struct memseg *, struct memseg **, 264 struct memseg *, struct memseg *, struct memseg *); 265 void hat_kpm_walk(void (*)(void *, void *, size_t), void *); 266 267 /* 268 * Operations on all translations for a given page(s) 269 * 270 * void hat_page_setattr(pp, flag) 271 * void hat_page_clrattr(pp, flag) 272 * used to set/clr red/mod bits. 273 * 274 * uint hat_page_getattr(pp, flag) 275 * If flag is specified, returns 0 if attribute is disabled 276 * and non zero if enabled. If flag specifes multiple attributs 277 * then returns 0 if ALL atriibutes are disabled. This is an advisory 278 * call. 279 * 280 * int hat_pageunload(pp, forceflag) 281 * unload all translations attached to pp. 282 * 283 * uint_t hat_pagesync(pp, flags) 284 * get hw stats from hardware into page struct and reset hw stats 285 * returns attributes of page 286 * 287 * ulong_t hat_page_getshare(pp) 288 * returns approx number of mappings to this pp. A return of 0 implies 289 * there are no mappings to the page. 290 * 291 * faultcode_t hat_softlock(hat, addr, lenp, ppp, flags); 292 * called to softlock pages for zero copy tcp 293 * 294 * void hat_page_demote(pp); 295 * unload all large mappings to pp and decrease p_szc of all 296 * constituent pages according to the remaining mappings. 297 */ 298 299 void hat_page_setattr(struct page *, uint_t); 300 void hat_page_clrattr(struct page *, uint_t); 301 uint_t hat_page_getattr(struct page *, uint_t); 302 int hat_pageunload(struct page *, uint_t); 303 uint_t hat_pagesync(struct page *, uint_t); 304 ulong_t hat_page_getshare(struct page *); 305 int hat_page_checkshare(struct page *, ulong_t); 306 faultcode_t hat_softlock(struct hat *, caddr_t, size_t *, 307 struct page **, uint_t); 308 void hat_page_demote(struct page *); 309 310 /* 311 * Rountine to expose supported HAT features to PIM. 312 */ 313 enum hat_features { 314 HAT_SHARED_PT, /* Shared page tables */ 315 HAT_DYNAMIC_ISM_UNMAP, /* hat_pageunload() handles ISM pages */ 316 HAT_VMODSORT, /* support for VMODSORT flag of vnode */ 317 HAT_SHARED_REGIONS /* shared regions support */ 318 }; 319 320 int hat_supported(enum hat_features, void *); 321 322 /* 323 * Services provided to the hat: 324 * 325 * void as_signal_proc(as, siginfo) 326 * deliver signal to all processes that have this as. 327 * 328 * int hat_setstat(as, addr, len, rmbits) 329 * informs hatstat layer that ref/mod bits need to be updated for 330 * address range. Returns 0 on success, 1 for failure. 331 */ 332 void as_signal_proc(struct as *, k_siginfo_t *siginfo); 333 void hat_setstat(struct as *, caddr_t, size_t, uint_t); 334 335 /* 336 * Flags to pass to hat routines. 337 * 338 * Certain flags only apply to some interfaces: 339 * 340 * HAT_LOAD Default flags to load a translation to the page. 341 * HAT_LOAD_LOCK Lock down mapping resources; hat_map(), hat_memload(), 342 * and hat_devload(). 343 * HAT_LOAD_ADV Advisory load - Load translation if and only if 344 * sufficient MMU resources exist (i.e., do not steal). 345 * HAT_LOAD_SHARE A flag to hat_memload() to indicate h/w page tables 346 * that map some user pages (not kas) is shared by more 347 * than one process (eg. ISM). 348 * HAT_LOAD_CONTIG Pages are contigous 349 * HAT_LOAD_NOCONSIST Do not add mapping to mapping list. 350 * HAT_LOAD_REMAP Reload a valid pte with a different page frame. 351 * HAT_RELOAD_SHARE Reload a shared page table entry. Some platforms 352 * may require different actions than on the first 353 * load of a shared mapping. 354 * HAT_NO_KALLOC Do not kmem_alloc while creating the mapping; at this 355 * point, it's setting up mapping to allocate internal 356 * hat layer data structures. This flag forces hat layer 357 * to tap its reserves in order to prevent infinite 358 * recursion. 359 * HAT_LOAD_TEXT A flag to hat_memload() to indicate loading text pages. 360 */ 361 362 /* 363 * Flags for hat_memload/hat_devload 364 */ 365 #define HAT_FLAGS_RESV 0xFF000000 /* resv for hat impl */ 366 #define HAT_LOAD 0x00 367 #define HAT_LOAD_LOCK 0x01 368 #define HAT_LOAD_ADV 0x04 369 #define HAT_LOAD_CONTIG 0x10 370 #define HAT_LOAD_NOCONSIST 0x20 371 #define HAT_LOAD_SHARE 0x40 372 #define HAT_LOAD_REMAP 0x80 373 #define HAT_RELOAD_SHARE 0x100 374 #define HAT_NO_KALLOC 0x200 375 #define HAT_LOAD_TEXT 0x400 376 377 /* 378 * Flags for initializing disable_*large_pages. 379 * 380 * HAT_AUTO_TEXT Get MMU specific disable_auto_text_large_pages 381 * HAT_AUTO_DATA Get MMU specific disable_auto_data_large_pages 382 */ 383 #define HAT_AUTO_TEXT 0x800 384 #define HAT_AUTO_DATA 0x1000 385 386 /* 387 * Attributes for hat_memload/hat_devload/hat_*attr 388 * are a superset of prot flags defined in mman.h. 389 */ 390 #define HAT_PLAT_ATTR_MASK 0xF00000 391 #define HAT_PROT_MASK 0x0F 392 393 #define HAT_NOFAULT 0x10 394 #define HAT_NOSYNC 0x20 395 396 /* 397 * Advisory ordering attributes. Apply only to device mappings. 398 * 399 * HAT_STRICTORDER: the CPU must issue the references in order, as the 400 * programmer specified. This is the default. 401 * HAT_UNORDERED_OK: the CPU may reorder the references (this is all kinds 402 * of reordering; store or load with store or load). 403 * HAT_MERGING_OK: merging and batching: the CPU may merge individual stores 404 * to consecutive locations (for example, turn two consecutive byte 405 * stores into one halfword store), and it may batch individual loads 406 * (for example, turn two consecutive byte loads into one halfword load). 407 * This also implies re-ordering. 408 * HAT_LOADCACHING_OK: the CPU may cache the data it fetches and reuse it 409 * until another store occurs. The default is to fetch new data 410 * on every load. This also implies merging. 411 * HAT_STORECACHING_OK: the CPU may keep the data in the cache and push it to 412 * the device (perhaps with other data) at a later time. The default is 413 * to push the data right away. This also implies load caching. 414 */ 415 #define HAT_STRICTORDER 0x0000 416 #define HAT_UNORDERED_OK 0x0100 417 #define HAT_MERGING_OK 0x0200 418 #define HAT_LOADCACHING_OK 0x0300 419 #define HAT_STORECACHING_OK 0x0400 420 #define HAT_ORDER_MASK 0x0700 421 422 /* endian attributes */ 423 #define HAT_NEVERSWAP 0x0000 424 #define HAT_STRUCTURE_BE 0x1000 425 #define HAT_STRUCTURE_LE 0x2000 426 #define HAT_ENDIAN_MASK 0x3000 427 428 /* 429 * Attributes for non-coherent I-cache support. 430 * 431 * We detect if an I-cache has been filled by first resetting 432 * execute permission in a tte entry. This forces a trap when 433 * an instruction fetch first occurs in that page. In "soft 434 * execute mode", the hardware execute permission is cleared 435 * and a different software execution bit is set in the tte. 436 * 437 * HAT_ATTR_TEXT: set this flag to avoid the extra trap associated 438 * with soft execute mode. Same meaning as HAT_LOAD_TEXT. 439 * 440 * HAT_ATTR_NOSOFTEXEC: set this flag when installing a permanent 441 * mapping, or installing a mapping that will never be 442 * freed. Overrides soft execute mode. 443 */ 444 #define HAT_ATTR_TEXT 0x4000 445 #define HAT_ATTR_NOSOFTEXEC 0x8000 446 447 /* flags for hat_softlock */ 448 #define HAT_COW 0x0001 449 450 /* 451 * Flags for hat_unload 452 */ 453 #define HAT_UNLOAD 0x00 454 #define HAT_UNLOAD_NOSYNC 0x02 455 #define HAT_UNLOAD_UNLOCK 0x04 456 #define HAT_UNLOAD_OTHER 0x08 457 #define HAT_UNLOAD_UNMAP 0x10 458 459 /* 460 * Flags for hat_pagesync, hat_getstat, hat_sync 461 */ 462 #define HAT_SYNC_DONTZERO 0x00 463 #define HAT_SYNC_ZERORM 0x01 464 /* Additional flags for hat_pagesync */ 465 #define HAT_SYNC_STOPON_REF 0x02 466 #define HAT_SYNC_STOPON_MOD 0x04 467 #define HAT_SYNC_STOPON_RM (HAT_SYNC_STOPON_REF | HAT_SYNC_STOPON_MOD) 468 #define HAT_SYNC_STOPON_SHARED 0x08 469 470 /* 471 * Flags for hat_dup 472 * 473 * HAT_DUP_ALL dup entire address space 474 * HAT_DUP_COW dup plus hat_clrattr(..PROT_WRITE) on newas 475 */ 476 #define HAT_DUP_ALL 1 477 #define HAT_DUP_COW 2 478 #define HAT_DUP_SRD 3 479 480 481 /* 482 * Flags for hat_map 483 */ 484 #define HAT_MAP 0x00 485 486 /* 487 * Flag for hat_pageunload 488 */ 489 #define HAT_ADV_PGUNLOAD 0x00 490 #define HAT_FORCE_PGUNLOAD 0x01 491 492 /* 493 * Attributes for hat_page_*attr, hat_setstats and 494 * returned by hat_pagesync. 495 */ 496 #define P_MOD 0x1 /* the modified bit */ 497 #define P_REF 0x2 /* the referenced bit */ 498 #define P_RO 0x4 /* Read only page */ 499 #define P_NSH 0x8 /* Not to shuffle v_pages */ 500 501 #define hat_ismod(pp) (hat_page_getattr(pp, P_MOD)) 502 #define hat_isref(pp) (hat_page_getattr(pp, P_REF)) 503 #define hat_isro(pp) (hat_page_getattr(pp, P_RO)) 504 505 #define hat_setmod(pp) (hat_page_setattr(pp, P_MOD)) 506 #define hat_setmod_only(pp) (hat_page_setattr(pp, P_MOD|P_NSH)) 507 #define hat_setref(pp) (hat_page_setattr(pp, P_REF)) 508 #define hat_setrefmod(pp) (hat_page_setattr(pp, P_REF|P_MOD)) 509 510 #define hat_clrmod(pp) (hat_page_clrattr(pp, P_MOD)) 511 #define hat_clrref(pp) (hat_page_clrattr(pp, P_REF)) 512 #define hat_clrrefmod(pp) (hat_page_clrattr(pp, P_REF|P_MOD)) 513 514 #define hat_page_is_mapped(pp) (hat_page_getshare(pp)) 515 516 /* 517 * hat_setup is being used in sparc/os/sundep.c 518 */ 519 void hat_setup(struct hat *, int); 520 521 /* 522 * Flags for hat_setup 523 */ 524 #define HAT_DONTALLOC 0 525 #define HAT_ALLOC 1 526 #define HAT_INIT 2 527 528 /* 529 * Other routines, for statistics 530 */ 531 int hat_startstat(struct as *); 532 void hat_getstat(struct as *, caddr_t, size_t, uint_t, char *, int); 533 void hat_freestat(struct as *, int); 534 void hat_resvstat(size_t, struct as *, caddr_t); 535 536 /* 537 * Transitionary routine while we still allow hat_getkpfnum(caddr_t) 538 * to return a pfn for kernel memory, but want to warn the user that 539 * it isn't supported. 540 */ 541 void hat_getkpfnum_badcall(void *caller); 542 543 /* 544 * Relocation callback routines. Currently only sfmmu HAT supports 545 * these. 546 */ 547 extern int hat_add_callback(id_t, caddr_t, uint_t, uint_t, void *, 548 pfn_t *, void **); 549 extern id_t hat_register_callback(int, 550 int (*prehandler)(caddr_t, uint_t, uint_t, void *), 551 int (*posthandler)(caddr_t, uint_t, uint_t, void *, pfn_t), 552 int (*errhandler)(caddr_t, uint_t, uint_t, void *), int); 553 extern void hat_delete_callback(caddr_t, uint_t, void *, uint_t, void *); 554 555 /* 556 * hat_add_callback()/hat_delete_callback() flags. 557 */ 558 #define HAC_NOSLEEP 0x0 559 #define HAC_SLEEP 0x1 560 #define HAC_PAGELOCK 0x2 561 562 /* 563 * Suspend/unsuspend handler callback arguments. 564 */ 565 #define HAT_SUSPEND 0x0010 566 #define HAT_UNSUSPEND 0x0010 567 #define HAT_PRESUSPEND 0x0020 568 #define HAT_POSTUNSUSPEND 0x0020 569 570 /* 571 * Error handler callback arguments. See the block comments 572 * before the implementation of hat_add_callback() for an 573 * explanation of what these mean. 574 */ 575 #define HAT_CB_ERR_LEAKED 0x1 576 577 #endif /* _KERNEL */ 578 579 /* 580 * The size of the bit array for ref and mod bit storage must be a power of 2. 581 * 2 bits are collected for each page. Below the power used is 4, 582 * which is 16 8-bit characters = 128 bits, ref and mod bit information 583 * for 64 pages. 584 */ 585 #define HRM_SHIFT 4 586 #define HRM_BYTES (1 << HRM_SHIFT) 587 #define HRM_PAGES ((HRM_BYTES * NBBY) / 2) 588 #define HRM_PGPERBYTE (NBBY/2) 589 #define HRM_PGBYTEMASK (HRM_PGPERBYTE-1) 590 591 #define HRM_PGOFFMASK ((HRM_PGPERBYTE-1) << MMU_PAGESHIFT) 592 #define HRM_BASEOFFSET (((MMU_PAGESIZE * HRM_PAGES) - 1)) 593 #define HRM_BASEMASK (~(HRM_BASEOFFSET)) 594 595 #define HRM_BASESHIFT (MMU_PAGESHIFT + (HRM_SHIFT + 2)) 596 #define HRM_PAGEMASK (MMU_PAGEMASK ^ HRM_BASEMASK) 597 598 #define HRM_HASHSIZE 0x200 599 #define HRM_HASHMASK (HRM_HASHSIZE - 1) 600 601 #define HRM_BLIST_INCR 0x200 602 603 /* 604 * The structure for maintaining referenced and modified information 605 */ 606 struct hrmstat { 607 struct as *hrm_as; /* stat block belongs to this as */ 608 uintptr_t hrm_base; /* base of block */ 609 ushort_t hrm_id; /* opaque identifier, one of a_vbits */ 610 struct hrmstat *hrm_anext; /* as statistics block list */ 611 struct hrmstat *hrm_hnext; /* list for hashed blocks */ 612 uchar_t hrm_bits[HRM_BYTES]; /* the ref and mod bits */ 613 }; 614 615 extern struct hrmstat **hrm_hashtab; 616 617 /* 618 * For global monitoring of the reference and modified bits 619 * of all address spaces we reserve one id bit. 620 */ 621 #define HRM_SWSMONID 1 622 623 624 #ifdef _KERNEL 625 626 /* 627 * Hat locking functions 628 * XXX - these two functions are currently being used by hatstats 629 * they can be removed by using a per-as mutex for hatstats. 630 */ 631 void hat_enter(struct hat *); 632 void hat_exit(struct hat *); 633 634 typedef void (*hat_rgn_cb_func_t)(caddr_t, caddr_t, caddr_t, 635 size_t, void *, u_offset_t); 636 637 void hat_join_srd(struct hat *, vnode_t *); 638 639 hat_region_cookie_t hat_join_region(struct hat *, caddr_t, size_t, void *, 640 u_offset_t, uchar_t, uchar_t, hat_rgn_cb_func_t, 641 uint_t); 642 void hat_leave_region(struct hat *, hat_region_cookie_t, 643 uint_t); 644 void hat_dup_region(struct hat *, hat_region_cookie_t); 645 646 #define HAT_INVALID_REGION_COOKIE ((hat_region_cookie_t)-1) 647 #define HAT_IS_REGION_COOKIE_VALID(c) ((c) != HAT_INVALID_REGION_COOKIE) 648 649 /* hat_join_region() flags */ 650 651 #define HAT_REGION_TEXT 0x1 /* passed by segvn */ 652 #define HAT_REGION_ISM 0x2 /* for hat_share()/hat_unshare() */ 653 654 #define HAT_REGION_TYPE_MASK (0x7) 655 656 #endif /* _KERNEL */ 657 658 #ifdef __cplusplus 659 } 660 #endif 661 662 #endif /* _VM_HAT_H */ 663