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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright 2017 Joyent, Inc. 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_SEG_H 41 #define _VM_SEG_H 42 43 #include <sys/vnode.h> 44 #include <sys/avl.h> 45 #include <vm/seg_enum.h> 46 #include <vm/faultcode.h> 47 #include <vm/hat.h> 48 49 #ifdef __cplusplus 50 extern "C" { 51 #endif 52 53 /* 54 * VM - Segments. 55 */ 56 57 struct anon_map; 58 59 /* 60 * kstat statistics for segment advise 61 */ 62 typedef struct { 63 kstat_named_t MADV_FREE_hit; 64 kstat_named_t MADV_FREE_miss; 65 } segadvstat_t; 66 67 /* 68 * memory object ids 69 */ 70 typedef struct memid { u_longlong_t val[2]; } memid_t; 71 72 /* 73 * An address space contains a set of segments, managed by drivers. 74 * Drivers support mapped devices, sharing, copy-on-write, etc. 75 * 76 * The seg structure contains a lock to prevent races, the base virtual 77 * address and size of the segment, a back pointer to the containing 78 * address space, pointers to maintain an AVL tree of segments in the 79 * same address space, and procedure and data hooks for the driver. 80 * The AVL tree of segments for the address space is sorted by 81 * ascending base addresses and overlapping segments are not allowed. 82 * 83 * After a segment is created, faults may occur on pages of the segment. 84 * When a fault occurs, the fault handling code must get the desired 85 * object and set up the hardware translation to the object. For some 86 * objects, the fault handling code also implements copy-on-write. 87 * 88 * When the hat wants to unload a translation, it can call the unload 89 * routine which is responsible for processing reference and modify bits. 90 * 91 * Each segment is protected by it's containing address space lock. To 92 * access any field in the segment structure, the "as" must be locked. 93 * If a segment field is to be modified, the address space lock must be 94 * write locked. 95 */ 96 97 typedef struct pcache_link { 98 struct pcache_link *p_lnext; 99 struct pcache_link *p_lprev; 100 } pcache_link_t; 101 102 typedef struct seg { 103 caddr_t s_base; /* base virtual address */ 104 size_t s_size; /* size in bytes */ 105 uint_t s_szc; /* max page size code */ 106 uint_t s_flags; /* flags for segment, see below */ 107 struct as *s_as; /* containing address space */ 108 avl_node_t s_tree; /* AVL tree links to segs in this as */ 109 struct seg_ops *s_ops; /* ops vector: see below */ 110 void *s_data; /* private data for instance */ 111 kmutex_t s_pmtx; /* protects seg's pcache list */ 112 pcache_link_t s_phead; /* head of seg's pcache list */ 113 } seg_t; 114 115 #define S_PURGE (0x01) /* seg should be purged in as_gap() */ 116 #define S_HOLE (0x02) /* seg represents hole in AS */ 117 118 struct seg_ops { 119 int (*dup)(struct seg *, struct seg *); 120 int (*unmap)(struct seg *, caddr_t, size_t); 121 void (*free)(struct seg *); 122 faultcode_t (*fault)(struct hat *, struct seg *, caddr_t, size_t, 123 enum fault_type, enum seg_rw); 124 faultcode_t (*faulta)(struct seg *, caddr_t); 125 int (*setprot)(struct seg *, caddr_t, size_t, uint_t); 126 int (*checkprot)(struct seg *, caddr_t, size_t, uint_t); 127 int (*kluster)(struct seg *, caddr_t, ssize_t); 128 size_t (*swapout)(struct seg *); 129 int (*sync)(struct seg *, caddr_t, size_t, int, uint_t); 130 size_t (*incore)(struct seg *, caddr_t, size_t, char *); 131 int (*lockop)(struct seg *, caddr_t, size_t, int, int, ulong_t *, 132 size_t); 133 int (*getprot)(struct seg *, caddr_t, size_t, uint_t *); 134 u_offset_t (*getoffset)(struct seg *, caddr_t); 135 int (*gettype)(struct seg *, caddr_t); 136 int (*getvp)(struct seg *, caddr_t, struct vnode **); 137 int (*advise)(struct seg *, caddr_t, size_t, uint_t); 138 void (*dump)(struct seg *); 139 int (*pagelock)(struct seg *, caddr_t, size_t, struct page ***, 140 enum lock_type, enum seg_rw); 141 int (*setpagesize)(struct seg *, caddr_t, size_t, uint_t); 142 int (*getmemid)(struct seg *, caddr_t, memid_t *); 143 struct lgrp_mem_policy_info *(*getpolicy)(struct seg *, caddr_t); 144 int (*capable)(struct seg *, segcapability_t); 145 int (*inherit)(struct seg *, caddr_t, size_t, uint_t); 146 }; 147 148 #ifdef _KERNEL 149 150 /* 151 * Generic segment operations 152 */ 153 extern void seg_init(void); 154 extern struct seg *seg_alloc(struct as *as, caddr_t base, size_t size); 155 extern int seg_attach(struct as *as, caddr_t base, size_t size, 156 struct seg *seg); 157 extern void seg_unmap(struct seg *seg); 158 extern void seg_free(struct seg *seg); 159 160 /* 161 * functions for pagelock cache support 162 */ 163 typedef int (*seg_preclaim_cbfunc_t)(void *, caddr_t, size_t, 164 struct page **, enum seg_rw, int); 165 166 extern struct page **seg_plookup(struct seg *seg, struct anon_map *amp, 167 caddr_t addr, size_t len, enum seg_rw rw, uint_t flags); 168 extern void seg_pinactive(struct seg *seg, struct anon_map *amp, 169 caddr_t addr, size_t len, struct page **pp, enum seg_rw rw, 170 uint_t flags, seg_preclaim_cbfunc_t callback); 171 172 extern void seg_ppurge(struct seg *seg, struct anon_map *amp, 173 uint_t flags); 174 extern void seg_ppurge_wiredpp(struct page **pp); 175 176 extern int seg_pinsert_check(struct seg *seg, struct anon_map *amp, 177 caddr_t addr, size_t len, uint_t flags); 178 extern int seg_pinsert(struct seg *seg, struct anon_map *amp, 179 caddr_t addr, size_t len, size_t wlen, struct page **pp, enum seg_rw rw, 180 uint_t flags, seg_preclaim_cbfunc_t callback); 181 182 extern void seg_pasync_thread(void); 183 extern void seg_preap(void); 184 extern int seg_p_disable(void); 185 extern void seg_p_enable(void); 186 187 extern segadvstat_t segadvstat; 188 189 /* 190 * Flags for pagelock cache support. 191 * Flags argument is passed as uint_t to pcache routines. upper 16 bits of 192 * the flags argument are reserved for alignment page shift when SEGP_PSHIFT 193 * is set. 194 */ 195 #define SEGP_FORCE_WIRED 0x1 /* skip check against seg_pwindow */ 196 #define SEGP_AMP 0x2 /* anon map's pcache entry */ 197 #define SEGP_PSHIFT 0x4 /* addr pgsz shift for hash function */ 198 199 /* 200 * Return values for seg_pinsert and seg_pinsert_check functions. 201 */ 202 #define SEGP_SUCCESS 0 /* seg_pinsert() succeeded */ 203 #define SEGP_FAIL 1 /* seg_pinsert() failed */ 204 205 /* Page status bits for segop_incore */ 206 #define SEG_PAGE_INCORE 0x01 /* VA has a page backing it */ 207 #define SEG_PAGE_LOCKED 0x02 /* VA has a page that is locked */ 208 #define SEG_PAGE_HASCOW 0x04 /* VA has a page with a copy-on-write */ 209 #define SEG_PAGE_SOFTLOCK 0x08 /* VA has a page with softlock held */ 210 #define SEG_PAGE_VNODEBACKED 0x10 /* Segment is backed by a vnode */ 211 #define SEG_PAGE_ANON 0x20 /* VA has an anonymous page */ 212 #define SEG_PAGE_VNODE 0x40 /* VA has a vnode page backing it */ 213 214 #define SEGOP_DUP(s, n) (*(s)->s_ops->dup)((s), (n)) 215 #define SEGOP_UNMAP(s, a, l) (*(s)->s_ops->unmap)((s), (a), (l)) 216 #define SEGOP_FREE(s) (*(s)->s_ops->free)((s)) 217 #define SEGOP_FAULT(h, s, a, l, t, rw) \ 218 (*(s)->s_ops->fault)((h), (s), (a), (l), (t), (rw)) 219 #define SEGOP_FAULTA(s, a) (*(s)->s_ops->faulta)((s), (a)) 220 #define SEGOP_SETPROT(s, a, l, p) (*(s)->s_ops->setprot)((s), (a), (l), (p)) 221 #define SEGOP_CHECKPROT(s, a, l, p) (*(s)->s_ops->checkprot)((s), (a), (l), (p)) 222 #define SEGOP_KLUSTER(s, a, d) (*(s)->s_ops->kluster)((s), (a), (d)) 223 #define SEGOP_SWAPOUT(s) (*(s)->s_ops->swapout)((s)) 224 #define SEGOP_SYNC(s, a, l, atr, f) \ 225 (*(s)->s_ops->sync)((s), (a), (l), (atr), (f)) 226 #define SEGOP_INCORE(s, a, l, v) (*(s)->s_ops->incore)((s), (a), (l), (v)) 227 #define SEGOP_LOCKOP(s, a, l, atr, op, b, p) \ 228 (*(s)->s_ops->lockop)((s), (a), (l), (atr), (op), (b), (p)) 229 #define SEGOP_GETPROT(s, a, l, p) (*(s)->s_ops->getprot)((s), (a), (l), (p)) 230 #define SEGOP_GETOFFSET(s, a) (*(s)->s_ops->getoffset)((s), (a)) 231 #define SEGOP_GETTYPE(s, a) (*(s)->s_ops->gettype)((s), (a)) 232 #define SEGOP_GETVP(s, a, vpp) (*(s)->s_ops->getvp)((s), (a), (vpp)) 233 #define SEGOP_ADVISE(s, a, l, b) (*(s)->s_ops->advise)((s), (a), (l), (b)) 234 #define SEGOP_DUMP(s) (*(s)->s_ops->dump)((s)) 235 #define SEGOP_PAGELOCK(s, a, l, p, t, rw) \ 236 (*(s)->s_ops->pagelock)((s), (a), (l), (p), (t), (rw)) 237 #define SEGOP_SETPAGESIZE(s, a, l, szc) \ 238 (*(s)->s_ops->setpagesize)((s), (a), (l), (szc)) 239 #define SEGOP_GETMEMID(s, a, mp) (*(s)->s_ops->getmemid)((s), (a), (mp)) 240 #define SEGOP_GETPOLICY(s, a) (*(s)->s_ops->getpolicy)((s), (a)) 241 #define SEGOP_CAPABLE(s, c) (*(s)->s_ops->capable)((s), (c)) 242 #define SEGOP_INHERIT(s, a, l, b) (*(s)->s_ops->inherit)((s), (a), (l), (b)) 243 244 #define seg_page(seg, addr) \ 245 (((uintptr_t)((addr) - (seg)->s_base)) >> PAGESHIFT) 246 247 #define seg_pages(seg) \ 248 (((uintptr_t)((seg)->s_size + PAGEOFFSET)) >> PAGESHIFT) 249 250 #define IE_NOMEM -1 /* internal to seg layer */ 251 #define IE_RETRY -2 /* internal to seg layer */ 252 #define IE_REATTACH -3 /* internal to seg layer */ 253 254 /* Values for SEGOP_INHERIT */ 255 #define SEGP_INH_ZERO 0x01 256 257 int seg_inherit_notsup(struct seg *, caddr_t, size_t, uint_t); 258 259 /* Delay/retry factors for seg_p_mem_config_pre_del */ 260 #define SEGP_PREDEL_DELAY_FACTOR 4 261 /* 262 * As a workaround to being unable to purge the pagelock 263 * cache during a DR delete memory operation, we use 264 * a stall threshold that is twice the maximum seen 265 * during testing. This workaround will be removed 266 * when a suitable fix is found. 267 */ 268 #define SEGP_STALL_SECONDS 25 269 #define SEGP_STALL_THRESHOLD \ 270 (SEGP_STALL_SECONDS * SEGP_PREDEL_DELAY_FACTOR) 271 272 #ifdef VMDEBUG 273 274 uint_t seg_page(struct seg *, caddr_t); 275 uint_t seg_pages(struct seg *); 276 277 #endif /* VMDEBUG */ 278 279 boolean_t seg_can_change_zones(struct seg *); 280 size_t seg_swresv(struct seg *); 281 282 #endif /* _KERNEL */ 283 284 #ifdef __cplusplus 285 } 286 #endif 287 288 #endif /* _VM_SEG_H */ 289