usr/src/uts/common/vm/seg_map.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 2006 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_SEG_MAP_H
  40 #define _VM_SEG_MAP_H
  41
  42 #pragma ident   "%Z%%M% %I%     %E% SMI"
  43
  44 #ifdef  __cplusplus
  45 extern "C" {
  46 #endif
  47
  48 /*
  49  * When segmap is created it is possible to program its behavior,
  50  *      using the create args [needed for performance reasons].
  51  * Segmap creates n lists of pages.
  52  *      For VAC machines, there will be at least one free list
  53  *      per color. If more than one free list per color is needed,
  54  *      set nfreelist as needed.
  55  *
  56  *      For PAC machines, it will be treated as VAC with only one
  57  *      color- every page is of the same color. Again, set nfreelist
  58  *      to get more than one free list.
  59  */
  60 struct segmap_crargs {
  61         uint_t  prot;
  62         uint_t  shmsize;        /* shm_alignment for VAC, 0 for PAC. */
  63         uint_t  nfreelist;      /* number of freelist per color, >= 1 */
  64 };
  65
  66 #include <vm/kpm.h>
  67 #include <vm/vpm.h>
  68
  69 /*
  70  * Each smap struct represents a MAXBSIZE sized mapping to the
  71  * <sm_vp, sm_off> given in the structure.  The location of the
  72  * the structure in the array gives the virtual address of the
  73  * mapping. Structure rearranged for 64bit sm_off.
  74  */
  75 struct  smap {
  76         kmutex_t        sm_mtx;         /* protect non-list fields */
  77         struct  vnode   *sm_vp;         /* vnode pointer (if mapped) */
  78         struct  smap    *sm_hash;       /* hash pointer */
  79         struct  smap    *sm_next;       /* next pointer */
  80         struct  smap    *sm_prev;       /* previous pointer */
  81         u_offset_t      sm_off;         /* file offset for mapping */
  82         ushort_t        sm_bitmap;      /* bit map for locked translations */
  83         ushort_t        sm_refcnt;      /* reference count for uses */
  84         ushort_t        sm_flags;       /* smap flags */
  85         ushort_t        sm_free_ndx;    /* freelist */
  86 #ifdef  SEGKPM_SUPPORT
  87         struct kpme     sm_kpme;        /* segkpm */
  88 #endif
  89 };
  90
  91 #ifdef  SEGKPM_SUPPORT
  92 #define GET_KPME(smp)   (&(smp)->sm_kpme)
  93 #define sm_kpme_next    sm_kpme.kpe_next
  94 #define sm_kpme_prev    sm_kpme.kpe_prev
  95 #define sm_kpme_page    sm_kpme.kpe_page
  96 #else
  97 #define GET_KPME(smp)   ((struct kpme *)NULL)
  98 #endif
  99
 100 /* sm_flags */
 101 #define SM_KPM_NEWPAGE     0x00000001   /* page created in segmap_getmapft */
 102 #define SM_NOTKPM_RELEASED 0x00000002   /* released smap not in segkpm mode */
 103 #define SM_QNDX_ZERO       0x00000004   /* on the index 0 freelist */
 104 #define SM_READ_DATA       0x00000010   /* page created for read */
 105 #define SM_WRITE_DATA      0x00000020   /* page created for write */
 106
 107 /*
 108  * Multiple smap free lists are maintained so that allocations
 109  * will scale with cpu count. Each free list is made up of 2 queues
 110  * so that allocations and deallocations can proceed concurrently.
 111  * Each queue structure is padded to 64 bytes to avoid false sharing.
 112  */
 113 #define SM_FREEQ_PAD (64 - sizeof (struct smap *) - sizeof (kmutex_t))
 114 struct  sm_freeq {
 115         struct smap     *smq_free;      /* points into freelist */
 116         kmutex_t        smq_mtx;        /* protects smq_free */
 117         char            smq_pad[SM_FREEQ_PAD];
 118 };
 119
 120 struct  smfree {
 121         struct sm_freeq sm_freeq[2];    /* alloc and release queues */
 122         struct sm_freeq *sm_allocq;     /* current allocq */
 123         struct sm_freeq *sm_releq;      /* current releq */
 124         kcondvar_t      sm_free_cv;
 125         ushort_t        sm_want;        /* someone wants a slot of this color */
 126 };
 127
 128 /*
 129  * Cached smaps are kept on hash chains to enable fast reclaim lookups.
 130  */
 131 struct  smaphash {
 132         kmutex_t        sh_mtx;         /* protects this hash chain */
 133         struct  smap    *sh_hash_list;  /* start of hash chain */
 134 };
 135
 136 /*
 137  * (Semi) private data maintained by the segmap driver per SEGMENT mapping
 138  * All fields in segmap_data are read-only after the segment is created.
 139  *
 140  */
 141
 142 struct  segmap_data {
 143         struct  smap    *smd_sm;        /* array of smap structures */
 144         long            smd_npages;     /* size of smap array */
 145         struct smfree   *smd_free;      /* ptr to freelist header array */
 146         struct smaphash *smd_hash;      /* ptr to hash header array */
 147         int             smd_nfree;      /* number of free lists */
 148         uchar_t         smd_prot;       /* protections for all smap's */
 149 };
 150
 151 /*
 152  * Statistics for segmap operations.
 153  *
 154  * No explicit locking to protect these stats.
 155  */
 156 struct segmapcnt {
 157         kstat_named_t   smp_fault;      /* number of segmap_faults */
 158         kstat_named_t   smp_faulta;     /* number of segmap_faultas */
 159         kstat_named_t   smp_getmap;     /* number of segmap_getmaps */
 160         kstat_named_t   smp_get_use;    /* getmaps that reuse existing map */
 161         kstat_named_t   smp_get_reclaim; /* getmaps that do a reclaim */
 162         kstat_named_t   smp_get_reuse;  /* getmaps that reuse a slot */
 163         kstat_named_t   smp_get_unused; /* getmaps that reuse existing map */
 164         kstat_named_t   smp_get_nofree; /* getmaps with no free slots */
 165         kstat_named_t   smp_rel_async;  /* releases that are async */
 166         kstat_named_t   smp_rel_write;  /* releases that write */
 167         kstat_named_t   smp_rel_free;   /* releases that free */
 168         kstat_named_t   smp_rel_abort;  /* releases that abort */
 169         kstat_named_t   smp_rel_dontneed; /* releases with dontneed set */
 170         kstat_named_t   smp_release;    /* releases with no other action */
 171         kstat_named_t   smp_pagecreate; /* pagecreates */
 172         kstat_named_t   smp_free_notfree; /* pages not freed in */
 173                                         /* segmap_pagefree */
 174         kstat_named_t   smp_free_dirty; /* dirty pages freeed */
 175                                         /* in segmap_pagefree */
 176         kstat_named_t   smp_free;       /* clean pages freeed in */
 177                                         /* segmap_pagefree */
 178         kstat_named_t   smp_stolen;     /* segmap_getmapflt() stole */
 179                                         /* from get_free_smp() */
 180         kstat_named_t   smp_get_nomtx;  /* free smaps but no mutex */
 181 };
 182
 183 /*
 184  * These are flags used on release.  Some of these might get handled
 185  * by segment operations needed for msync (when we figure them out).
 186  * SM_ASYNC modifies SM_WRITE.  SM_DONTNEED modifies SM_FREE.  SM_FREE
 187  * and SM_INVAL as well as SM_FREE and SM_DESTROY are mutually exclusive.
 188  * SM_DESTROY behaves like SM_INVAL but also forces the pages to be
 189  * destroyed -- this prevents them from being written to the backing
 190  * store.
 191  */
 192 #define SM_WRITE        0x01            /* write back the pages upon release */
 193 #define SM_ASYNC        0x02            /* do the write asynchronously */
 194 #define SM_FREE         0x04            /* put pages back on free list */
 195 #define SM_INVAL        0x08            /* invalidate page (no caching) */
 196 #define SM_DONTNEED     0x10            /* less likely to be needed soon */
 197 #define SM_DESTROY      0x20            /* invalidate page, don't write back */
 198
 199 /*
 200  * These are the forcefault flags used on getmapflt.
 201  *
 202  * The orginal semantic was extended to allow using the segkpm mapping
 203  * scheme w/o a major segmap interface change for MAXBSIZE == PAGESIZE
 204  * (which is required to enable segkpm for MAXBSIZE > PAGESIZE).
 205  * Most segmap consumers needn't to be changed at all or only need to
 206  * be changed slightly to take advantage of segkpm. Because the segkpm
 207  * virtual address is based on the physical address of a page, a page is
 208  * required to determine the virtual address (return value). Pages mapped
 209  * with segkpm are always at least read locked and are hence protected
 210  * from pageout or fsflush from segmap_getmap until segmap_release. This
 211  * implies, that the segkpm mappings are locked within this period too.
 212  * No trap driven segmap_fault's are possible in segkpm mode.
 213  *
 214  * The following combinations of "forcefault" and "rw" allow segkpm mode.
 215  * (1) SM_FAULT, S_READ
 216  * (2) SM_FAULT, S_WRITE
 217  * (3) SM_PAGECREATE, S_WRITE
 218  * (4) SM_LOCKPROTO, {S_READ, S_WRITE, S_OTHER}
 219  *
 220  * The regular additional operations (come in pairs in most of the cases):
 221  * . segmap_pagecreate/segmap_pageunlock
 222  * . segmap_fault(F_SOFTLOCK)/segmap_fault(F_SOFTUNLOCK)
 223  *
 224  * are mostly a no-op in segkpm mode with the following exceptions:
 225  * . The "newpage" return value of segmap_pagecreate is still supported
 226  *   for zeroout operations needed on newly created pages.
 227  *
 228  * . segmap_fault() must follow when a error could be expected in
 229  *   the VOP_GETPAGE. In segkpm mode this error is recognized in
 230  *   segmap_getmapflt and returned from the following segmap_fault()
 231  *   call. The "hole" optimization (read only after first VOP_GETPAGE
 232  *   mapping in segmap_getmapflt followed by a trap driven protection
 233  *   fault and a second VOP_GETPAGE via segmap_fault) cannot be used.
 234  *
 235  * . segmap_fault(F_SOFTUNLOCK) must follow when segmap_getmapflt was
 236  *   called w/ (SM_LOCKPROTO, S_OTHER). S_WRITE has to be applied, when
 237  *   the page should be marked "dirty". Otherwise the page is not
 238  *   written to the backing store later (as mentioned above, no page
 239  *   or protection faults are possible in segkpm mode). Caller cannot
 240  *   use only S_OTHER and rely on a protection fault to force the page
 241  *   to become dirty.
 242  *
 243  * . The segmap_pagecreate parameter softlock is ignored, pages and
 244  *   mappings are locked anyway.
 245  *
 246  * SM_LOCKPROTO is used in the fbio layer and some special segmap consumers.
 247  */
 248 #define SM_PAGECREATE   0x00            /* create page in segkpm mode, no I/O */
 249 #define SM_FAULT        0x01            /* fault in page if necessary */
 250 #define SM_LOCKPROTO    0x02            /* lock/unlock protocol used */
 251
 252 #define MAXBSHIFT       13              /* log2(MAXBSIZE) */
 253
 254 #define MAXBOFFSET      (MAXBSIZE - 1)
 255 #define MAXBMASK        (~MAXBOFFSET)
 256
 257 /*
 258  * SMAP_HASHAVELEN is the average length desired for this chain, from
 259  * which the size of the smd_hash table is derived at segment create time.
 260  * SMAP_HASHVPSHIFT is defined so that 1 << SMAP_HASHVPSHIFT is the
 261  * approximate size of a vnode struct.
 262  */
 263 #define SMAP_HASHAVELEN         4
 264 #define SMAP_HASHVPSHIFT        6
 265
 266
 267 #ifdef _KERNEL
 268 /*
 269  * The kernel generic mapping segment.
 270  */
 271 extern struct seg *segkmap;
 272
 273 /*
 274  * Public seg_map segment operations.
 275  */
 276 extern int      segmap_create(struct seg *, void *);
 277 extern int      segmap_pagecreate(struct seg *, caddr_t, size_t, int);
 278 extern void     segmap_pageunlock(struct seg *, caddr_t, size_t, enum seg_rw);
 279 extern faultcode_t segmap_fault(struct hat *, struct seg *, caddr_t, size_t,
 280                 enum fault_type, enum seg_rw);
 281 extern caddr_t  segmap_getmap(struct seg *, struct vnode *, u_offset_t);
 282 extern caddr_t  segmap_getmapflt(struct seg *, struct vnode *, u_offset_t,
 283                 size_t, int, enum seg_rw);
 284 extern int      segmap_release(struct seg *, caddr_t, uint_t);
 285 extern void     segmap_flush(struct seg *, struct vnode *);
 286 extern void     segmap_inval(struct seg *, struct vnode *, u_offset_t);
 287
 288 #endif  /* _KERNEL */
 289
 290 #ifdef  __cplusplus
 291 }
 292 #endif
 293
 294 #endif  /* _VM_SEG_MAP_H */