usr/src/uts/common/vm/xhat.h

   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   "%Z%%M% %I%     %E% 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 */