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