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, 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 2004 Sun Microsystems, Inc.  All rights reserved.
     24  * Use is subject to license terms.
     25  */
     26 
     27 #ifndef _VM_XHAT_H
     28 #define	_VM_XHAT_H
     29 
     30 #pragma ident	"@(#)xhat.h	1.3	05/06/08 SMI"
     31 
     32 
     33 #ifdef	__cplusplus
     34 extern "C" {
     35 #endif
     36 
     37 #ifndef _ASM
     38 
     39 #include <sys/types.h>
     40 #include <vm/page.h>
     41 #include <sys/kmem.h>
     42 
     43 struct xhat;
     44 struct xhat_hme_blk;
     45 
     46 struct xhat_ops {
     47 	struct xhat	*(*xhat_alloc)(void *);
     48 	void		(*xhat_free)(struct xhat *);
     49 	void		(*xhat_free_start)(struct xhat *);
     50 	void		(*xhat_free_end)(struct xhat *);
     51 	int		(*xhat_dup)(struct xhat *, struct xhat *, caddr_t,
     52 	    size_t, uint_t);
     53 	void		(*xhat_swapin)(struct xhat *);
     54 	void		(*xhat_swapout)(struct xhat *);
     55 	void		(*xhat_memload)(struct xhat *, caddr_t, struct page *,
     56 			    uint_t, uint_t);
     57 	void		(*xhat_memload_array)(struct xhat *, caddr_t, size_t,
     58 			    struct page **, uint_t, uint_t);
     59 	void		(*xhat_devload)(struct xhat *, caddr_t, size_t, pfn_t,
     60 	    uint_t, int);
     61 	void		(*xhat_unload)(struct xhat *, caddr_t, size_t, uint_t);
     62 	void		(*xhat_unload_callback)(struct xhat *, caddr_t, size_t,
     63 	    uint_t, hat_callback_t *);
     64 	void		(*xhat_setattr)(struct xhat *, caddr_t, size_t, uint_t);
     65 	void		(*xhat_clrattr)(struct xhat *, caddr_t, size_t, uint_t);
     66 	void		(*xhat_chgattr)(struct xhat *, caddr_t, size_t, uint_t);
     67 	void		(*xhat_unshare)(struct xhat *, caddr_t, size_t);
     68 	void		(*xhat_chgprot)(struct xhat *, caddr_t, size_t, uint_t);
     69 	int		(*xhat_pageunload)(struct xhat *, struct page *, uint_t,
     70 			    void *);
     71 };
     72 
     73 
     74 #define	XHAT_POPS(_p)	(_p)->xhat_provider_ops
     75 #define	XHAT_PROPS(_h)	XHAT_POPS(((struct xhat *)(_h))->xhat_provider)
     76 #define	XHAT_HOPS(hat, func, args) \
     77 	{ \
     78 		if (XHAT_PROPS(hat)-> /* */ func) \
     79 			XHAT_PROPS(hat)-> /* */ func /* */ args; \
     80 	}
     81 
     82 #define	XHAT_FREE_START(a) \
     83 	XHAT_HOPS(a, xhat_free_start, ((struct xhat *)(a)))
     84 #define	XHAT_FREE_END(a) \
     85 	XHAT_HOPS(a, xhat_free_end, ((struct xhat *)(a)))
     86 #define	XHAT_DUP(a, b, c, d, e) \
     87 	((XHAT_PROPS(a)->xhat_dup == NULL) ? (0) : \
     88 	XHAT_PROPS(a)->xhat_dup((struct xhat *)(a), \
     89 				(struct xhat *)(b), c, d, e))
     90 #define	XHAT_SWAPIN(a) \
     91 	XHAT_HOPS(a, xhat_swapin, ((struct xhat *)(a)))
     92 #define	XHAT_SWAPOUT(a) \
     93 	XHAT_HOPS(a, xhat_swapout, ((struct xhat *)(a)))
     94 #define	XHAT_MEMLOAD(a, b, c, d, e) \
     95 	XHAT_HOPS(a, xhat_memload, ((struct xhat *)(a), b, c, d, e))
     96 #define	XHAT_MEMLOAD_ARRAY(a, b, c, d, e, f) \
     97 	XHAT_HOPS(a, xhat_memload_array, ((struct xhat *)(a), b, c, d, e, f))
     98 #define	XHAT_DEVLOAD(a, b, c, d, e, f) \
     99 	XHAT_HOPS(a, xhat_devload, ((struct xhat *)(a), b, c, d, e, f))
    100 #define	XHAT_UNLOAD(a, b, c, d) \
    101 	XHAT_HOPS(a, xhat_unload, ((struct xhat *)(a), b, c, d))
    102 #define	XHAT_UNLOAD_CALLBACK(a, b, c, d, e) \
    103 	XHAT_HOPS(a, xhat_unload_callback, ((struct xhat *)(a), b, c, d, e))
    104 #define	XHAT_SETATTR(a, b, c, d) \
    105 	XHAT_HOPS(a, xhat_setattr, ((struct xhat *)(a), b, c, d))
    106 #define	XHAT_CLRATTR(a, b, c, d) \
    107 	XHAT_HOPS(a, xhat_clrattr, ((struct xhat *)(a), b, c, d))
    108 #define	XHAT_CHGATTR(a, b, c, d) \
    109 	XHAT_HOPS(a, xhat_chgattr, ((struct xhat *)(a), b, c, d))
    110 #define	XHAT_UNSHARE(a, b, c) \
    111 	XHAT_HOPS(a, xhat_unshare, ((struct xhat *)(a), b, c))
    112 #define	XHAT_CHGPROT(a, b, c, d) \
    113 	XHAT_HOPS(a, xhat_chgprot, ((struct xhat *)(a), b, c, d))
    114 #define	XHAT_PAGEUNLOAD(a, b, c, d) \
    115 	((XHAT_PROPS(a)->xhat_pageunload == NULL) ? (0) : \
    116 	XHAT_PROPS(a)->xhat_pageunload((struct xhat *)(a), b, c, d))
    117 
    118 
    119 
    120 #define	XHAT_PROVIDER_VERSION	1
    121 
    122 /*
    123  * Provider name will be appended with "_cache"
    124  * when initializing kmem cache.
    125  * The resulting sring must be less than
    126  * KMEM_CACHE_NAMELEN
    127  */
    128 #define	XHAT_CACHE_NAMELEN	24
    129 
    130 typedef struct xblk_cache {
    131 	kmutex_t	lock;
    132 	kmem_cache_t	*cache;
    133 	void		*free_blks;
    134 	void		(*reclaim)(void *);
    135 } xblk_cache_t;
    136 
    137 typedef struct xhat_provider {
    138 	int		xhat_provider_version;
    139 	int		xhat_provider_refcnt;
    140 	struct xhat_provider *next;
    141 	struct xhat_provider *prev;
    142 	char		xhat_provider_name[XHAT_CACHE_NAMELEN];
    143 	xblk_cache_t	*xblkcache;
    144 	struct xhat_ops *xhat_provider_ops;
    145 	int		xhat_provider_blk_size;
    146 } xhat_provider_t;
    147 
    148 /*
    149  * The xhat structure is protected by xhat_lock.
    150  * A particular xhat implementation is a extension of the
    151  * xhat structure and may contain its own lock(s) to
    152  * protect those additional fields.
    153  * The xhat structure is never allocated directly.
    154  * Instead its allocation is provided by the hat implementation.
    155  * The xhat provider ops xhat_alloc/xhat_free are used to
    156  * alloc/free a implementation dependant xhat structure.
    157  */
    158 struct xhat {
    159 	xhat_provider_t		*xhat_provider;
    160 	struct as		*xhat_as;
    161 	void			*arg;
    162 	struct xhat		*prev;
    163 	struct xhat		*next;
    164 	kmutex_t		xhat_lock;
    165 	int			xhat_refcnt;
    166 	kthread_t		*holder;
    167 };
    168 
    169 
    170 /* Error codes */
    171 #define	XH_PRVDR	(1)	/* Provider-specific error */
    172 #define	XH_ASBUSY	(2)	/* Address space is busy */
    173 #define	XH_XHHELD	(3)	/* XHAT is being held */
    174 #define	XH_NOTATTCHD	(4)	/* Provider is not attached to as */
    175 
    176 
    177 int	xhat_provider_register(xhat_provider_t *);
    178 int	xhat_provider_unregister(xhat_provider_t *);
    179 void	xhat_init(void);
    180 int	xhat_attach_xhat(xhat_provider_t *, struct as *, struct xhat **,
    181     void *);
    182 int	xhat_detach_xhat(xhat_provider_t *, struct as *);
    183 pfn_t	xhat_insert_xhatblk(page_t *, struct xhat *, void **);
    184 int	xhat_delete_xhatblk(void *, int);
    185 void	xhat_hat_hold(struct xhat *);
    186 void	xhat_hat_rele(struct xhat *);
    187 int	xhat_hat_holders(struct xhat *);
    188 
    189 void	xhat_free_start_all(struct as *);
    190 void	xhat_free_end_all(struct as *);
    191 int	xhat_dup_all(struct as *, struct as *, caddr_t, size_t, uint_t);
    192 void	xhat_swapout_all(struct as *);
    193 void	xhat_unload_callback_all(struct as *, caddr_t, size_t, uint_t,
    194     hat_callback_t *);
    195 void	xhat_setattr_all(struct as *, caddr_t, size_t, uint_t);
    196 void	xhat_clrattr_all(struct as *, caddr_t, size_t, uint_t);
    197 void	xhat_chgattr_all(struct as *, caddr_t, size_t, uint_t);
    198 void	xhat_chgprot_all(struct as *, caddr_t, size_t, uint_t);
    199 void	xhat_unshare_all(struct as *, caddr_t, size_t);
    200 
    201 
    202 #endif /* _ASM */
    203 
    204 #ifdef	__cplusplus
    205 }
    206 #endif
    207 
    208 #endif	/* _VM_XHAT_H */
    209