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