Home | History | Annotate | Download | only in vm
      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 2007 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_AS_H
     40 #define	_VM_AS_H
     41 
     42 #pragma ident	"@(#)as.h	1.93	07/12/10 SMI"
     43 
     44 #include <sys/watchpoint.h>
     45 #include <vm/seg.h>
     46 #include <vm/faultcode.h>
     47 #include <vm/hat.h>
     48 #include <sys/avl.h>
     49 #include <sys/proc.h>
     50 
     51 #ifdef	__cplusplus
     52 extern "C" {
     53 #endif
     54 
     55 /*
     56  * VM - Address spaces.
     57  */
     58 
     59 /*
     60  * Each address space consists of a sorted list of segments
     61  * and machine dependent address translation information.
     62  *
     63  * All the hard work is in the segment drivers and the
     64  * hardware address translation code.
     65  *
     66  * The segment list is represented as an AVL tree.
     67  *
     68  * The address space lock (a_lock) is a long term lock which serializes
     69  * access to certain operations (as_map, as_unmap) and protects the
     70  * underlying generic segment data (seg.h) along with some fields in the
     71  * address space structure as shown below:
     72  *
     73  *	address space structure 	segment structure
     74  *
     75  *	a_segtree			s_base
     76  *	a_size				s_size
     77  *	a_lastgap			s_link
     78  *	a_seglast			s_ops
     79  *					s_as
     80  *					s_data
     81  *
     82  * The address space contents lock (a_contents) is a short term
     83  * lock that protects most of the data in the address space structure.
     84  * This lock is always acquired after the "a_lock" in all situations
     85  * except while dealing with AS_CLAIMGAP to avoid deadlocks.
     86  *
     87  * The following fields are protected by this lock:
     88  *
     89  *	a_flags (AS_PAGLCK, AS_CLAIMGAP, etc.)
     90  *	a_unmapwait
     91  *	a_seglast
     92  *
     93  * The address space lock (a_lock) is always held prior to any segment
     94  * operation.  Some segment drivers use the address space lock to protect
     95  * some or all of their segment private data, provided the version of
     96  * "a_lock" (read vs. write) is consistent with the use of the data.
     97  *
     98  * The following fields are protected by the hat layer lock:
     99  *
    100  *	a_vbits
    101  *	a_hat
    102  *	a_hrm
    103  */
    104 
    105 struct as {
    106 	kmutex_t a_contents;	/* protect certain fields in the structure */
    107 	uchar_t  a_flags;	/* as attributes */
    108 	uchar_t	a_vbits;	/* used for collecting statistics */
    109 	kcondvar_t a_cv;	/* used by as_rangelock */
    110 	struct	hat *a_hat;	/* hat structure */
    111 	struct	hrmstat *a_hrm; /* ref and mod bits */
    112 	caddr_t	a_userlimit;	/* highest allowable address in this as */
    113 	struct seg *a_seglast;	/* last segment hit on the addr space */
    114 	krwlock_t a_lock;	/* protects segment related fields */
    115 	size_t	a_size;		/* size of address space */
    116 	struct seg *a_lastgap;	/* last seg found by as_gap() w/ AS_HI (mmap) */
    117 	struct seg *a_lastgaphl; /* last seg saved in as_gap() either for */
    118 				/* AS_HI or AS_LO used in as_addseg() */
    119 	avl_tree_t a_segtree;	/* segments in this address space. (AVL tree) */
    120 	avl_tree_t a_wpage;	/* watched pages (procfs) */
    121 	uchar_t	a_updatedir;	/* mappings changed, rebuild a_objectdir */
    122 	timespec_t a_updatetime;	/* time when mappings last changed */
    123 	vnode_t	**a_objectdir;	/* object directory (procfs) */
    124 	size_t	a_sizedir;	/* size of object directory */
    125 	struct as_callback *a_callbacks; /* callback list */
    126 	void *a_xhat;		/* list of xhat providers */
    127 	proc_t	*a_proc;	/* back pointer to proc */
    128 };
    129 
    130 #define	AS_PAGLCK		0x80
    131 #define	AS_CLAIMGAP		0x40
    132 #define	AS_UNMAPWAIT		0x20
    133 #define	AS_NEEDSPURGE		0x10	/* mostly for seg_nf, see as_purge() */
    134 #define	AS_BUSY			0x01	/* needed by XHAT framework */
    135 
    136 #define	AS_ISPGLCK(as)		((as)->a_flags & AS_PAGLCK)
    137 #define	AS_ISCLAIMGAP(as)	((as)->a_flags & AS_CLAIMGAP)
    138 #define	AS_ISUNMAPWAIT(as)	((as)->a_flags & AS_UNMAPWAIT)
    139 #define	AS_ISBUSY(as)		((as)->a_flags & AS_BUSY)
    140 
    141 
    142 #define	AS_SETPGLCK(as)		((as)->a_flags |= AS_PAGLCK)
    143 #define	AS_SETCLAIMGAP(as)	((as)->a_flags |= AS_CLAIMGAP)
    144 #define	AS_SETUNMAPWAIT(as)	((as)->a_flags |= AS_UNMAPWAIT)
    145 #define	AS_SETBUSY(as)		((as)->a_flags |= AS_BUSY)
    146 
    147 #define	AS_CLRPGLCK(as)		((as)->a_flags &= ~AS_PAGLCK)
    148 #define	AS_CLRCLAIMGAP(as)	((as)->a_flags &= ~AS_CLAIMGAP)
    149 #define	AS_CLRUNMAPWAIT(as)	((as)->a_flags &= ~AS_UNMAPWAIT)
    150 #define	AS_CLRBUSY(as)		((as)->a_flags &= ~AS_BUSY)
    151 
    152 #define	AS_TYPE_64BIT(as)	\
    153 	    (((as)->a_userlimit > (caddr_t)UINT32_MAX) ? 1 : 0)
    154 
    155 /*
    156  * Flags for as_map/as_map_ansegs
    157  */
    158 #define	AS_MAP_NO_LPOOB		((uint_t)-1)
    159 #define	AS_MAP_HEAP		((uint_t)-2)
    160 #define	AS_MAP_STACK		((uint_t)-3)
    161 
    162 /*
    163  * The as_callback is the basic structure which supports the ability to
    164  * inform clients of specific events pertaining to address space management.
    165  * A user calls as_add_callback to register an address space callback
    166  * for a range of pages, specifying the events that need to occur.
    167  * When as_do_callbacks is called and finds a 'matching' entry, the
    168  * callback is called once, and the callback function MUST call
    169  * as_delete_callback when all callback activities are complete.
    170  * The thread calling as_do_callbacks blocks until the as_delete_callback
    171  * is called.  This allows for asynchorous events to subside before the
    172  * as_do_callbacks thread continues.
    173  *
    174  * An example of the need for this is a driver which has done long-term
    175  * locking of memory.  Address space management operations (events) such
    176  * as as_free, as_umap, and as_setprot will block indefinitely until the
    177  * pertinent memory is unlocked.  The callback mechanism provides the
    178  * way to inform the driver of the event so that the driver may do the
    179  * necessary unlocking.
    180  *
    181  * The contents of this structure is protected by a_contents lock
    182  */
    183 typedef void (*callback_func_t)(struct as *, void *, uint_t);
    184 struct as_callback {
    185 	struct as_callback	*ascb_next;		/* list link */
    186 	uint_t			ascb_events;		/* event types */
    187 	callback_func_t		ascb_func;   		/* callback function */
    188 	void			*ascb_arg;		/* callback argument */
    189 	caddr_t			ascb_saddr;		/* start address */
    190 	size_t			ascb_len;		/* address range */
    191 };
    192 /*
    193  * Callback events
    194  */
    195 #define	AS_FREE_EVENT		0x1
    196 #define	AS_SETPROT_EVENT	0x2
    197 #define	AS_UNMAP_EVENT		0x4
    198 #define	AS_CALLBACK_CALLED	((uint_t)(1U << (8 * sizeof (uint_t) - 1U)))
    199 #define	AS_UNMAPWAIT_EVENT				\
    200 		(AS_FREE_EVENT | AS_SETPROT_EVENT | AS_UNMAP_EVENT)
    201 #define	AS_ALL_EVENT					\
    202 		(AS_FREE_EVENT | AS_SETPROT_EVENT | AS_UNMAP_EVENT)
    203 
    204 
    205 /* Return code values for as_callback_delete */
    206 enum as_cbdelete_rc {
    207 	AS_CALLBACK_DELETED,
    208 	AS_CALLBACK_NOTFOUND,
    209 	AS_CALLBACK_DELETE_DEFERRED
    210 };
    211 
    212 #ifdef _KERNEL
    213 
    214 /*
    215  * Flags for as_gap.
    216  */
    217 #define	AH_DIR		0x1	/* direction flag mask */
    218 #define	AH_LO		0x0	/* find lowest hole */
    219 #define	AH_HI		0x1	/* find highest hole */
    220 #define	AH_CONTAIN	0x2	/* hole must contain `addr' */
    221 
    222 extern struct as kas;		/* kernel's address space */
    223 
    224 /*
    225  * Macros for address space locking.
    226  */
    227 #define	AS_LOCK_ENTER(as, lock, type)		rw_enter((lock), (type))
    228 #define	AS_LOCK_EXIT(as, lock)			rw_exit((lock))
    229 #define	AS_LOCK_DESTROY(as, lock)		rw_destroy((lock))
    230 #define	AS_LOCK_TRYENTER(as, lock, type)	rw_tryenter((lock), (type))
    231 
    232 /*
    233  * Macros to test lock states.
    234  */
    235 #define	AS_LOCK_HELD(as, lock)		RW_LOCK_HELD((lock))
    236 #define	AS_READ_HELD(as, lock)		RW_READ_HELD((lock))
    237 #define	AS_WRITE_HELD(as, lock)		RW_WRITE_HELD((lock))
    238 
    239 /*
    240  * macros to walk thru segment lists
    241  */
    242 #define	AS_SEGFIRST(as)		avl_first(&(as)->a_segtree)
    243 #define	AS_SEGNEXT(as, seg)	AVL_NEXT(&(as)->a_segtree, (seg))
    244 #define	AS_SEGPREV(as, seg)	AVL_PREV(&(as)->a_segtree, (seg))
    245 
    246 void	as_init(void);
    247 void	as_avlinit(struct as *);
    248 struct	seg *as_segat(struct as *as, caddr_t addr);
    249 void	as_rangelock(struct as *as);
    250 void	as_rangeunlock(struct as *as);
    251 struct	as *as_alloc();
    252 void	as_free(struct as *as);
    253 int	as_dup(struct as *as, struct as **outas);
    254 struct	seg *as_findseg(struct as *as, caddr_t addr, int tail);
    255 int	as_addseg(struct as *as, struct seg *newseg);
    256 struct	seg *as_removeseg(struct as *as, struct seg *seg);
    257 faultcode_t as_fault(struct hat *hat, struct as *as, caddr_t addr, size_t size,
    258 		enum fault_type type, enum seg_rw rw);
    259 faultcode_t as_faulta(struct as *as, caddr_t addr, size_t size);
    260 int	as_setprot(struct as *as, caddr_t addr, size_t size, uint_t prot);
    261 int	as_checkprot(struct as *as, caddr_t addr, size_t size, uint_t prot);
    262 int	as_unmap(struct as *as, caddr_t addr, size_t size);
    263 int	as_map(struct as *as, caddr_t addr, size_t size, int ((*crfp)()),
    264 		void *argsp);
    265 void	as_purge(struct as *as);
    266 int	as_gap(struct as *as, size_t minlen, caddr_t *basep, size_t *lenp,
    267 		uint_t flags, caddr_t addr);
    268 int	as_gap_aligned(struct as *as, size_t minlen, caddr_t *basep,
    269 	    size_t *lenp, uint_t flags, caddr_t addr, size_t align,
    270 	    size_t redzone, size_t off);
    271 
    272 int	as_memory(struct as *as, caddr_t *basep, size_t *lenp);
    273 size_t	as_swapout(struct as *as);
    274 int	as_incore(struct as *as, caddr_t addr, size_t size, char *vec,
    275 		size_t *sizep);
    276 int	as_ctl(struct as *as, caddr_t addr, size_t size, int func, int attr,
    277 		uintptr_t arg, ulong_t *lock_map, size_t pos);
    278 int	as_exec(struct as *oas, caddr_t ostka, size_t stksz,
    279 		struct as *nas, caddr_t nstka, uint_t hatflag);
    280 int	as_pagelock(struct as *as, struct page ***ppp, caddr_t addr,
    281 		size_t size, enum seg_rw rw);
    282 void	as_pageunlock(struct as *as, struct page **pp, caddr_t addr,
    283 		size_t size, enum seg_rw rw);
    284 void	as_pagereclaim(struct as *as, struct page **pp, caddr_t addr,
    285 		size_t size, enum seg_rw rw);
    286 int	as_setpagesize(struct as *as, caddr_t addr, size_t size, uint_t szc,
    287 		boolean_t wait);
    288 int	as_set_default_lpsize(struct as *as, caddr_t addr, size_t size);
    289 void	as_setwatch(struct as *as);
    290 void	as_clearwatch(struct as *as);
    291 int	as_getmemid(struct as *, caddr_t, memid_t *);
    292 
    293 int	as_add_callback(struct as *, void (*)(), void *, uint_t,
    294 			caddr_t, size_t, int);
    295 uint_t	as_delete_callback(struct as *, void *);
    296 
    297 #endif	/* _KERNEL */
    298 
    299 #ifdef	__cplusplus
    300 }
    301 #endif
    302 
    303 #endif	/* _VM_AS_H */
    304