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