sys/cddl/compat/opensolaris/kern/opensolaris_sunddi.c

   1 /*-
   2  * Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/jail.h>
  32 #include <sys/kernel.h>
  33 #include <sys/libkern.h>
  34 #include <sys/limits.h>
  35 #include <sys/misc.h>
  36 #include <sys/sunddi.h>
  37 #include <sys/sysctl.h>
  38
  39 int
  40 ddi_strtol(const char *str, char **nptr, int base, long *result)
  41 {
  42
  43         *result = strtol(str, nptr, base);
  44         return (0);
  45 }
  46
  47 int
  48 ddi_strtoul(const char *str, char **nptr, int base, unsigned long *result)
  49 {
  50
  51         if (str == hw_serial) {
  52                 *result = prison0.pr_hostid;
  53                 return (0);
  54         }
  55
  56         *result = strtoul(str, nptr, base);
  57         return (0);
  58 }
  59
  60 int
  61 ddi_strtoull(const char *str, char **nptr, int base, unsigned long long *result)
  62 {
  63
  64         *result = (unsigned long long)strtouq(str, nptr, base);
  65         return (0);
  66 }
  67
  68 int
  69 ddi_strtoll(const char *str, char **nptr, int base, long long *result)
  70 {
  71
  72         *result = (long long)strtoq(str, nptr, base);
  73         return (0);
  74 }
  75
  76 struct ddi_soft_state_item {
  77         int      ssi_item;
  78         void    *ssi_data;
  79         LIST_ENTRY(ddi_soft_state_item) ssi_next;
  80 };
  81
  82 struct ddi_soft_state {
  83         size_t          ss_size;
  84         kmutex_t        ss_lock;
  85         LIST_HEAD(, ddi_soft_state_item) ss_list;
  86 };
  87
  88 static void *
  89 ddi_get_soft_state_locked(struct ddi_soft_state *ss, int item)
  90 {
  91         struct ddi_soft_state_item *itemp;
  92
  93         ASSERT(MUTEX_HELD(&ss->ss_lock));
  94
  95         LIST_FOREACH(itemp, &ss->ss_list, ssi_next) {
  96                 if (itemp->ssi_item == item)
  97                         return (itemp->ssi_data);
  98         }
  99         return (NULL);
 100 }
 101
 102 void *
 103 ddi_get_soft_state(void *state, int item)
 104 {
 105         struct ddi_soft_state *ss = state;
 106         void *data;
 107
 108         mutex_enter(&ss->ss_lock);
 109         data = ddi_get_soft_state_locked(ss, item);
 110         mutex_exit(&ss->ss_lock);
 111         return (data);
 112 }
 113
 114 int
 115 ddi_soft_state_zalloc(void *state, int item)
 116 {
 117         struct ddi_soft_state *ss = state;
 118         struct ddi_soft_state_item *itemp;
 119
 120         itemp = kmem_alloc(sizeof(*itemp), KM_SLEEP);
 121         itemp->ssi_item = item;
 122         itemp->ssi_data = kmem_zalloc(ss->ss_size, KM_SLEEP);
 123
 124         mutex_enter(&ss->ss_lock);
 125         if (ddi_get_soft_state_locked(ss, item) != NULL) {
 126                 mutex_exit(&ss->ss_lock);
 127                 kmem_free(itemp->ssi_data, ss->ss_size);
 128                 kmem_free(itemp, sizeof(*itemp));
 129                 return (DDI_FAILURE);
 130         }
 131         LIST_INSERT_HEAD(&ss->ss_list, itemp, ssi_next);
 132         mutex_exit(&ss->ss_lock);
 133         return (DDI_SUCCESS);
 134 }
 135
 136 static void
 137 ddi_soft_state_free_locked(struct ddi_soft_state *ss, int item)
 138 {
 139         struct ddi_soft_state_item *itemp;
 140
 141         ASSERT(MUTEX_HELD(&ss->ss_lock));
 142
 143         LIST_FOREACH(itemp, &ss->ss_list, ssi_next) {
 144                 if (itemp->ssi_item == item)
 145                         break;
 146         }
 147         if (itemp != NULL) {
 148                 LIST_REMOVE(itemp, ssi_next);
 149                 kmem_free(itemp->ssi_data, ss->ss_size);
 150                 kmem_free(itemp, sizeof(*itemp));
 151         }
 152 }
 153
 154 void
 155 ddi_soft_state_free(void *state, int item)
 156 {
 157         struct ddi_soft_state *ss = state;
 158
 159         mutex_enter(&ss->ss_lock);
 160         ddi_soft_state_free_locked(ss, item);
 161         mutex_exit(&ss->ss_lock);
 162 }
 163
 164 int
 165 ddi_soft_state_init(void **statep, size_t size, size_t nitems __unused)
 166 {
 167         struct ddi_soft_state *ss;
 168
 169         ss = kmem_alloc(sizeof(*ss), KM_SLEEP);
 170         mutex_init(&ss->ss_lock, NULL, MUTEX_DEFAULT, NULL);
 171         ss->ss_size = size;
 172         LIST_INIT(&ss->ss_list);
 173         *statep = ss;
 174         return (0);
 175 }
 176
 177 void
 178 ddi_soft_state_fini(void **statep)
 179 {
 180         struct ddi_soft_state *ss = *statep;
 181         struct ddi_soft_state_item *itemp;
 182         int item;
 183
 184         mutex_enter(&ss->ss_lock);
 185         while ((itemp = LIST_FIRST(&ss->ss_list)) != NULL) {
 186                 item = itemp->ssi_item;
 187                 ddi_soft_state_free_locked(ss, item);
 188         }
 189         mutex_exit(&ss->ss_lock);
 190         mutex_destroy(&ss->ss_lock);
 191         kmem_free(ss, sizeof(*ss));
 192
 193         *statep = NULL;
 194 }