include/sys/ddidevmap.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 (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #ifndef _SYS_DDIDEVMAP_H
  26 #define _SYS_DDIDEVMAP_H
  27
  28 #ifdef  __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #ifdef  _KERNEL
  33
  34 #include <sys/mman.h>
  35
  36 struct devmap_info {
  37         size_t  length;         /* and this length */
  38         size_t  page_size;      /* pte page size selected by framework */
  39         size_t  offset;         /* optimal page size based on this offset */
  40         ushort_t valid_flag;    /* flag to indicate the validity of data */
  41         uchar_t byte_order;     /* the  endian characteristics of the mapping */
  42
  43         /*
  44          * describes  order in which the CPU will reference data.
  45          */
  46         uchar_t data_order;
  47 };
  48
  49 typedef void * ddi_umem_cookie_t;
  50
  51 /*
  52  * umem callback function vector for drivers
  53  *
  54  * NOTE: IMPORTANT!  When umem_lockmemory is called with a valid
  55  * umem_callback_ops and DDI_UMEMLOCK_LONGTERM set, the 'cleanup'
  56  * callback function may be called AFTER a call to ddi_umem_lock.
  57  * It is the users responsibility to make sure that ddi_umem_lock is
  58  * called ONLY once for each ddi_umem_lock/umem_lockmemory cookie.
  59  */
  60 #define UMEM_CALLBACK_VERSION 1
  61 struct umem_callback_ops {
  62         int     cbo_umem_callback_version;      /* version number */
  63         void (*cbo_umem_lock_cleanup)(ddi_umem_cookie_t *);
  64 };
  65
  66 struct ddi_umem_cookie {
  67         size_t  size;   /* size of allocation */
  68         caddr_t cvaddr; /* cookie virtual address. */
  69                         /* KMEM - kvaddr returned from ddi_umem_alloc() */
  70                         /* For LOCKEDUMEM - user address of backing store */
  71                         /* For TRASH_UMEM - unused */
  72         kmutex_t        lock;
  73         uint_t          type;   /* see below for umem_cookie types */
  74         /*
  75          * Following 4 members are used for UMEM_LOCKED cookie type
  76          */
  77         page_t          **pparray;      /* shadow list from as_pagelock */
  78         void            *procp;         /* user process owning backing store */
  79         struct as       *asp;           /* as ptr for use by ddi_umem_unlock */
  80         enum seg_rw     s_flags;        /* flags used during pagelock/fault */
  81         /*
  82          * locked indicates underlying memory locked for KMEM_PAGEABLE
  83          * locked is a count of for how many pages this has been locked
  84          */
  85         uint_t          locked;
  86         struct umem_callback_ops callbacks;
  87         /*
  88          * cook_refcnt used in UMEM_LOCKED type
  89          */
  90         ulong_t         cook_refcnt;    /* cookie reference count */
  91         struct ddi_umem_cookie *unl_forw;   /* list ptr for unlock cookies */
  92         ulong_t         upd_max_lock_rctl;  /* track max-locked mem rctl? */
  93 };
  94
  95 typedef struct as *ddi_as_handle_t;
  96
  97
  98 /*
  99  * type of umem_cookie:
 100  *    pageable memory allocated from segkp segment driver
 101  *    non-pageable memory allocated from kmem_getpages()
 102  *    locked umem allocated from ddi_umem_lock
 103  *    trash umem maps all user virtual addresses to a common trash page
 104  */
 105 #define KMEM_PAGEABLE           0x100   /* un-locked kernel memory */
 106 #define KMEM_NON_PAGEABLE       0x200   /* locked kernel memeory */
 107 #define UMEM_LOCKED             0x400   /* locked user process memeory */
 108 #define UMEM_TRASH              0x800   /* trash page mapping */
 109
 110 typedef struct __devmap_pmem_cookie *devmap_pmem_cookie_t;
 111
 112 typedef void *devmap_cookie_t;
 113
 114 struct devmap_callback_ctl {
 115         int     devmap_rev;             /* devmap_callback_ctl version number */
 116         int     (*devmap_map)(devmap_cookie_t dhp, dev_t dev, uint_t flags,
 117                                 offset_t off, size_t len, void **pvtp);
 118         int     (*devmap_access)(devmap_cookie_t dhp, void *pvtp, offset_t off,
 119                                 size_t len, uint_t type, uint_t rw);
 120         int     (*devmap_dup)(devmap_cookie_t dhp, void *pvtp,
 121                                 devmap_cookie_t new_dhp, void **new_pvtp);
 122         void    (*devmap_unmap)(devmap_cookie_t dhp, void *pvtp, offset_t off,
 123                                 size_t len, devmap_cookie_t new_dhp1,
 124                                 void **new_pvtp1, devmap_cookie_t new_dhp2,
 125                                 void **new_pvtp2);
 126 };
 127
 128 struct devmap_softlock {
 129         ulong_t         id;     /* handle grouping id */
 130         dev_t           dev; /* Device to which we are mapping */
 131         struct          devmap_softlock *next;
 132         kmutex_t        lock;
 133         kcondvar_t      cv;
 134         int             refcnt; /* Number of threads with mappings */
 135         ssize_t         softlocked;
 136 };
 137
 138 struct devmap_ctx {
 139         ulong_t         id; /* handle grouping id */
 140         dev_info_t      *dip; /* Device info struct for tracing context */
 141         struct devmap_ctx *next;
 142         kmutex_t        lock;
 143         kcondvar_t      cv;
 144         int             refcnt; /* Number of threads with mappings */
 145         uint_t          oncpu; /* this context is running on a cpu */
 146         timeout_id_t    timeout; /* Timeout ID */
 147 };
 148
 149 /*
 150  * Fault information passed to the driver fault handling routine.
 151  * The DEVMAP_LOCK and DEVMAP_UNLOCK are used by software
 152  * to lock and unlock pages for physical I/O.
 153  */
 154 enum devmap_fault_type {
 155         DEVMAP_ACCESS,          /* invalid page */
 156         DEVMAP_PROT,            /* protection fault */
 157         DEVMAP_LOCK,            /* software requested locking */
 158         DEVMAP_UNLOCK           /* software requested unlocking */
 159 };
 160
 161 /*
 162  * seg_rw gives the access type for a fault operation
 163  */
 164 enum devmap_rw {
 165         DEVMAP_OTHER,           /* unknown or not touched */
 166         DEVMAP_READ,            /* read access attempted */
 167         DEVMAP_WRITE,           /* write access attempted */
 168         DEVMAP_EXEC,            /* execution access attempted */
 169         DEVMAP_CREATE           /* create if page doesn't exist */
 170 };
 171
 172 typedef struct devmap_handle {
 173
 174         /*
 175          * physical offset at the beginning of mapping.
 176          */
 177         offset_t        dh_roff;
 178
 179         /*
 180          * user offset at the beginning of mapping.
 181          */
 182         offset_t        dh_uoff;
 183         size_t          dh_len;         /* length of mapping */
 184         dev_t           dh_dev;         /* dev_t for this mapping */
 185         caddr_t         dh_cvaddr;  /* cookie virtual address */
 186         caddr_t         dh_uvaddr;  /* user address within dh_seg */
 187
 188         /*
 189          * Lock protects fields that can change during remap
 190          * dh_roff, dh_cookie, dh_flags, dh_mmulevel, dh_maxprot,
 191          * dh_pfn, dh_hat_attr
 192          */
 193         kmutex_t        dh_lock;
 194
 195         /*
 196          * to sync. faults for remap and unlocked kvaddr.
 197          */
 198         struct seg              *dh_seg; /* segment created for this mapping */
 199         void                    *dh_pvtp; /* device mapping private data */
 200         struct devmap_handle    *dh_next;
 201         struct devmap_softlock  *dh_softlock;
 202         struct devmap_ctx       *dh_ctx;
 203         ddi_umem_cookie_t       dh_cookie;      /* kmem cookie */
 204         devmap_pmem_cookie_t    dh_pcookie;     /* pmem cookie */
 205
 206         /*
 207          * protection flag possible for attempted mapping.
 208          */
 209         uint_t          dh_prot;
 210
 211         /*
 212          * Current maximum protection flag for attempted mapping.
 213          * This controls how dh_prot can be changed in segdev_setprot
 214          * See dh_orig_maxprot below also
 215          */
 216         uint_t          dh_maxprot;
 217
 218         /*
 219          * mmu level corresponds to the Max page size can be use for
 220          * the mapping.
 221          */
 222         uint_t          dh_mmulevel;
 223         uint_t          dh_flags;   /* see defines below */
 224         pfn_t           dh_pfn;         /* pfn corresponds to dh_reg_off */
 225         uint_t          dh_hat_attr;
 226         clock_t         dh_timeout_length;
 227         struct devmap_callback_ctl dh_callbackops;
 228
 229         /*
 230          * orig_maxprot is what the original mmap set maxprot to.
 231          * This is never modified once it is setup during mmap(2)
 232          * This is different from the current dh_maxprot which can
 233          * be changed in devmap_*_setup/remap
 234          */
 235         uint_t          dh_orig_maxprot;
 236 } devmap_handle_t;
 237
 238 #endif  /* _KERNEL */
 239
 240 /*
 241  * define for devmap_rev
 242  */
 243 #define DEVMAP_OPS_REV 1
 244
 245 /*
 246  * defines for devmap_*_setup flag, called by drivers
 247  */
 248 #define DEVMAP_DEFAULTS                 0x00
 249 #define DEVMAP_MAPPING_INVALID          0x01    /* mapping is invalid */
 250 #define DEVMAP_ALLOW_REMAP              0x02    /* allow remap */
 251 #define DEVMAP_USE_PAGESIZE             0x04    /* use pagesize for mmu load */
 252
 253 /* flags used by drivers */
 254 #define DEVMAP_SETUP_FLAGS      \
 255         (DEVMAP_MAPPING_INVALID | DEVMAP_ALLOW_REMAP | DEVMAP_USE_PAGESIZE)
 256
 257 /*
 258  * defines for dh_flags, these are used internally in devmap
 259  */
 260 #define DEVMAP_SETUP_DONE               0x100   /* mapping setup is done */
 261 #define DEVMAP_LOCK_INITED              0x200   /* locks are initailized */
 262 #define DEVMAP_LOCKED                   0x800   /* dhp is locked. */
 263 #define DEVMAP_FLAG_LARGE               0x1000  /* cal. optimal pgsize */
 264
 265 /*
 266  * Flags to pass to ddi_umem_alloc and ddi_umem_iosetup
 267  */
 268 #define DDI_UMEM_SLEEP          0x0
 269 #define DDI_UMEM_NOSLEEP        0x01
 270 #define DDI_UMEM_PAGEABLE       0x02
 271 #define DDI_UMEM_TRASH          0x04
 272
 273 /*
 274  * Flags to pass to ddi_umem_lock to indicate expected access pattern
 275  * DDI_UMEMLOCK_READ implies the memory being locked will be read
 276  * (e.g., data read from memory is written out to the disk or network)
 277  * DDI_UMEMLOCK_WRITE implies the memory being locked will be written
 278  * (e.g., data from the disk or network is written to memory)
 279  * Both flags may be set in the call to ddi_umem_lock,
 280  * Note that this corresponds to the VM subsystem definition of read/write
 281  * and also correspond to the prots set in devmap
 282  * When doing I/O, B_READ/B_WRITE are used which have exactly the opposite
 283  * meaning. Be careful when using it both for I/O and devmap
 284  *
 285  *
 286  */
 287 #define DDI_UMEMLOCK_READ       0x01
 288 #define DDI_UMEMLOCK_WRITE      0x02
 289
 290 #ifdef  __cplusplus
 291 }
 292 #endif
 293
 294 #endif  /* _SYS_DDIDEVMAP_H */