sys/dev/disk/dm/dm_target.c

   1 /*        $NetBSD: dm_target.c,v 1.12 2010/01/04 00:14:41 haad Exp $      */
   2
   3 /*
   4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Adam Hamsik.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code Must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/param.h>
  34
  35 #include <sys/malloc.h>
  36 #include <sys/module.h>
  37
  38
  39 #include "netbsd-dm.h"
  40 #include "dm.h"
  41
  42 static dm_target_t *dm_target_lookup_name(const char *);
  43
  44 TAILQ_HEAD(dm_target_head, dm_target);
  45
  46 static struct dm_target_head dm_target_list =
  47 TAILQ_HEAD_INITIALIZER(dm_target_list);
  48
  49 struct lock dm_target_mutex;
  50
  51 /*
  52  * Called indirectly from dm_table_load_ioctl to mark target as used.
  53  */
  54 void
  55 dm_target_busy(dm_target_t * target)
  56 {
  57         atomic_add_int(&target->ref_cnt, 1);
  58 }
  59 /*
  60  * Release reference counter on target.
  61  */
  62 void
  63 dm_target_unbusy(dm_target_t * target)
  64 {
  65         KKASSERT(target->ref_cnt > 0);
  66         atomic_subtract_int(&target->ref_cnt, 1);
  67 }
  68
  69 /*
  70  * Lookup for target in global target list.
  71  */
  72 dm_target_t *
  73 dm_target_lookup(const char *dm_target_name)
  74 {
  75         dm_target_t *dmt;
  76
  77         dmt = NULL;
  78
  79         if (dm_target_name == NULL)
  80                 return NULL;
  81
  82         lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
  83
  84         dmt = dm_target_lookup_name(dm_target_name);
  85         if (dmt != NULL)
  86                 dm_target_busy(dmt);
  87
  88         lockmgr(&dm_target_mutex, LK_RELEASE);
  89
  90         return dmt;
  91 }
  92 /*
  93  * Search for name in TAIL and return apropriate pointer.
  94  */
  95 static dm_target_t *
  96 dm_target_lookup_name(const char *dm_target_name)
  97 {
  98         dm_target_t *dm_target;
  99         int dlen;
 100         int slen;
 101
 102         slen = strlen(dm_target_name) + 1;
 103
 104         TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) {
 105                 dlen = strlen(dm_target->name) + 1;
 106                 if (dlen != slen)
 107                         continue;
 108
 109                 if (strncmp(dm_target_name, dm_target->name, slen) == 0)
 110                         return dm_target;
 111         }
 112
 113         return NULL;
 114 }
 115 /*
 116  * Insert new target struct into the TAIL.
 117  * dm_target
 118  *   contains name, version, function pointer to specifif target functions.
 119  */
 120 int
 121 dm_target_insert(dm_target_t * dm_target)
 122 {
 123         dm_target_t *dmt;
 124
 125         lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
 126
 127         dmt = dm_target_lookup_name(dm_target->name);
 128         if (dmt != NULL) {
 129                 kprintf("uhoh, target_insert EEXIST\n");
 130                 lockmgr(&dm_target_mutex, LK_RELEASE);
 131                 return EEXIST;
 132         }
 133         TAILQ_INSERT_TAIL(&dm_target_list, dm_target, dm_target_next);
 134
 135         lockmgr(&dm_target_mutex, LK_RELEASE);
 136
 137         return 0;
 138 }
 139
 140
 141 /*
 142  * Remove target from TAIL, target is selected with it's name.
 143  */
 144 int
 145 dm_target_rem(char *dm_target_name)
 146 {
 147         dm_target_t *dmt;
 148
 149         KKASSERT(dm_target_name != NULL);
 150
 151         lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
 152
 153         dmt = dm_target_lookup_name(dm_target_name);
 154         if (dmt == NULL) {
 155                 lockmgr(&dm_target_mutex, LK_RELEASE);
 156                 return ENOENT;
 157         }
 158         if (dmt->ref_cnt > 0) {
 159                 lockmgr(&dm_target_mutex, LK_RELEASE);
 160                 return EBUSY;
 161         }
 162         TAILQ_REMOVE(&dm_target_list,
 163             dmt, dm_target_next);
 164
 165         lockmgr(&dm_target_mutex, LK_RELEASE);
 166
 167         (void) kfree(dmt, M_DM);
 168
 169         return 0;
 170 }
 171 /*
 172  * Destroy all targets and remove them from queue.
 173  * This routine is called from dm_detach, before module
 174  * is unloaded.
 175  */
 176 int
 177 dm_target_destroy(void)
 178 {
 179         dm_target_t *dm_target;
 180
 181         lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
 182         while (TAILQ_FIRST(&dm_target_list) != NULL) {
 183
 184                 dm_target = TAILQ_FIRST(&dm_target_list);
 185
 186                 TAILQ_REMOVE(&dm_target_list, TAILQ_FIRST(&dm_target_list),
 187                     dm_target_next);
 188
 189                 (void) kfree(dm_target, M_DM);
 190         }
 191         lockmgr(&dm_target_mutex, LK_RELEASE);
 192
 193         lockuninit(&dm_target_mutex);
 194
 195         return 0;
 196 }
 197 /*
 198  * Allocate new target entry.
 199  */
 200 dm_target_t *
 201 dm_target_alloc(const char *name)
 202 {
 203         return kmalloc(sizeof(dm_target_t), M_DM, M_WAITOK | M_ZERO);
 204 }
 205 /*
 206  * Return prop_array of dm_target dictionaries.
 207  */
 208 prop_array_t
 209 dm_target_prop_list(void)
 210 {
 211         prop_array_t target_array, ver;
 212         prop_dictionary_t target_dict;
 213         dm_target_t *dm_target;
 214
 215         size_t i;
 216
 217         target_array = prop_array_create();
 218
 219         lockmgr(&dm_target_mutex, LK_EXCLUSIVE);
 220
 221         TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) {
 222
 223                 target_dict = prop_dictionary_create();
 224                 ver = prop_array_create();
 225                 prop_dictionary_set_cstring(target_dict, DM_TARGETS_NAME,
 226                     dm_target->name);
 227
 228                 for (i = 0; i < 3; i++)
 229                         prop_array_add_uint32(ver, dm_target->version[i]);
 230
 231                 prop_dictionary_set(target_dict, DM_TARGETS_VERSION, ver);
 232                 prop_array_add(target_array, target_dict);
 233
 234                 prop_object_release(ver);
 235                 prop_object_release(target_dict);
 236         }
 237
 238         lockmgr(&dm_target_mutex, LK_RELEASE);
 239
 240         return target_array;
 241 }
 242
 243 /* Initialize dm_target subsystem. */
 244 int
 245 dm_target_init(void)
 246 {
 247         lockinit(&dm_target_mutex, "dmtrgt", 0, LK_CANRECURSE);
 248
 249         return 0;
 250 }