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