Module Name: src
Committed By: haad
Date: Mon Jan 4 00:19:08 UTC 2010
Modified Files:
src/sys/dev/dm: dm_dev.c dm_ioctl.c dm_pdev.c dm_table.c
Log Message:
Indent files remove unnecessary blank lines, white spaces and KNFize code.
To generate a diff of this commit:
cvs rdiff -u -r1.7 -r1.8 src/sys/dev/dm/dm_dev.c
cvs rdiff -u -r1.19 -r1.20 src/sys/dev/dm/dm_ioctl.c
cvs rdiff -u -r1.5 -r1.6 src/sys/dev/dm/dm_pdev.c
cvs rdiff -u -r1.4 -r1.5 src/sys/dev/dm/dm_table.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/dev/dm/dm_dev.c
diff -u src/sys/dev/dm/dm_dev.c:1.7 src/sys/dev/dm/dm_dev.c:1.8
--- src/sys/dev/dm/dm_dev.c:1.7 Tue Dec 29 23:37:48 2009
+++ src/sys/dev/dm/dm_dev.c Mon Jan 4 00:19:08 2010
@@ -1,4 +1,4 @@
-/* $NetBSD: dm_dev.c,v 1.7 2009/12/29 23:37:48 haad Exp $ */
+/* $NetBSD: dm_dev.c,v 1.8 2010/01/04 00:19:08 haad Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -41,9 +41,9 @@
#include "netbsd-dm.h"
#include "dm.h"
-static dm_dev_t* dm_dev_lookup_name(const char *);
-static dm_dev_t* dm_dev_lookup_uuid(const char *);
-static dm_dev_t* dm_dev_lookup_minor(int);
+static dm_dev_t *dm_dev_lookup_name(const char *);
+static dm_dev_t *dm_dev_lookup_uuid(const char *);
+static dm_dev_t *dm_dev_lookup_minor(int);
static struct dm_dev_head dm_dev_list =
TAILQ_HEAD_INITIALIZER(dm_dev_list);
@@ -52,90 +52,88 @@
/* dm_dev_mutex must be holdby caller before using disable_dev. */
__inline static void
-disable_dev(dm_dev_t *dmv)
+disable_dev(dm_dev_t * dmv)
{
- TAILQ_REMOVE(&dm_dev_list, dmv, next_devlist);
- mutex_enter(&dmv->dev_mtx);
- mutex_exit(&dm_dev_mutex);
- while(dmv->ref_cnt != 0)
- cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
- mutex_exit(&dmv->dev_mtx);
-}
-
+ TAILQ_REMOVE(&dm_dev_list, dmv, next_devlist);
+ mutex_enter(&dmv->dev_mtx);
+ mutex_exit(&dm_dev_mutex);
+ while (dmv->ref_cnt != 0)
+ cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
+ mutex_exit(&dmv->dev_mtx);
+}
/*
- * Generic function used to lookup dm_dev_t. Calling with dm_dev_name
+ * Generic function used to lookup dm_dev_t. Calling with dm_dev_name
* and dm_dev_uuid NULL is allowed.
*/
-dm_dev_t*
+dm_dev_t *
dm_dev_lookup(const char *dm_dev_name, const char *dm_dev_uuid,
- int dm_dev_minor)
+ int dm_dev_minor)
{
dm_dev_t *dmv;
-
+
dmv = NULL;
mutex_enter(&dm_dev_mutex);
-
- /* KASSERT(dm_dev_name != NULL && dm_dev_uuid != NULL && dm_dev_minor > 0); */
+
+ /* KASSERT(dm_dev_name != NULL && dm_dev_uuid != NULL && dm_dev_minor
+ * > 0); */
if (dm_dev_minor > 0)
- if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL){
+ if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL) {
dm_dev_busy(dmv);
mutex_exit(&dm_dev_mutex);
return dmv;
}
-
- if (dm_dev_name != NULL)
- if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL){
+ if (dm_dev_name != NULL)
+ if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL) {
dm_dev_busy(dmv);
mutex_exit(&dm_dev_mutex);
- return dmv;
+ return dmv;
}
-
if (dm_dev_uuid != NULL)
- if ((dmv = dm_dev_lookup_uuid(dm_dev_uuid)) != NULL){
+ if ((dmv = dm_dev_lookup_uuid(dm_dev_uuid)) != NULL) {
dm_dev_busy(dmv);
mutex_exit(&dm_dev_mutex);
return dmv;
}
- mutex_exit(&dm_dev_mutex);
- return NULL;
+ mutex_exit(&dm_dev_mutex);
+ return NULL;
}
-
+
/*
* Lookup device with its minor number.
*/
-static dm_dev_t*
+static dm_dev_t *
dm_dev_lookup_minor(int dm_dev_minor)
{
dm_dev_t *dmv;
-
- TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
+
+ TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
if (dm_dev_minor == dmv->minor)
return dmv;
}
-
+
return NULL;
}
-
/*
* Lookup device with it's device name.
*/
-static dm_dev_t*
+static dm_dev_t *
dm_dev_lookup_name(const char *dm_dev_name)
{
dm_dev_t *dmv;
- int dlen; int slen;
+ int dlen;
+ int slen;
slen = strlen(dm_dev_name);
if (slen == 0)
return NULL;
-
- TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
+
+ TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
dlen = strlen(dmv->name);
-
- if(slen != dlen)
+
+ if (slen != dlen)
continue;
if (strncmp(dm_dev_name, dmv->name, slen) == 0)
@@ -144,62 +142,59 @@
return NULL;
}
-
/*
* Lookup device with it's device uuid. Used mostly by LVM2tools.
*/
-static dm_dev_t*
+static dm_dev_t *
dm_dev_lookup_uuid(const char *dm_dev_uuid)
{
dm_dev_t *dmv;
size_t len;
-
+
len = 0;
len = strlen(dm_dev_uuid);
-
+
if (len == 0)
return NULL;
- TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
+ TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
if (strlen(dmv->uuid) != len)
continue;
-
+
if (strncmp(dm_dev_uuid, dmv->uuid, strlen(dmv->uuid)) == 0)
return dmv;
}
return NULL;
}
-
/*
* Insert new device to the global list of devices.
*/
int
-dm_dev_insert(dm_dev_t *dev)
+dm_dev_insert(dm_dev_t * dev)
{
dm_dev_t *dmv;
int r;
dmv = NULL;
r = 0;
-
+
KASSERT(dev != NULL);
mutex_enter(&dm_dev_mutex);
if (((dmv = dm_dev_lookup_uuid(dev->uuid)) == NULL) &&
((dmv = dm_dev_lookup_name(dev->name)) == NULL) &&
- ((dmv = dm_dev_lookup_minor(dev->minor)) == NULL)){
+ ((dmv = dm_dev_lookup_minor(dev->minor)) == NULL)) {
TAILQ_INSERT_TAIL(&dm_dev_list, dev, next_devlist);
-
+
} else
r = EEXIST;
-
- mutex_exit(&dm_dev_mutex);
+
+ mutex_exit(&dm_dev_mutex);
return r;
}
-
-#ifdef notyet
+#ifdef notyet
/*
* Lookup device with its minor number.
*/
@@ -207,16 +202,16 @@
dm_dev_test_minor(int dm_dev_minor)
{
dm_dev_t *dmv;
-
+
mutex_enter(&dm_dev_mutex);
- TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
- if (dm_dev_minor == dmv->minor){
+ TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
+ if (dm_dev_minor == dmv->minor) {
mutex_exit(&dm_dev_mutex);
return 1;
}
}
mutex_exit(&dm_dev_mutex);
-
+
return 0;
}
#endif
@@ -231,45 +226,42 @@
dm_dev_detach(device_t devt)
{
dm_dev_t *dmv;
-
+
mutex_enter(&dm_dev_mutex);
- TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
- if (devt == dmv->devt){
+ TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
+ if (devt == dmv->devt) {
disable_dev(dmv);
return dmv;
}
}
mutex_exit(&dm_dev_mutex);
-
+
return NULL;
}
-
-/*
- * Remove device selected with dm_dev from global list of devices.
+/*
+ * Remove device selected with dm_dev from global list of devices.
*/
-dm_dev_t*
+dm_dev_t *
dm_dev_rem(const char *dm_dev_name, const char *dm_dev_uuid,
- int dm_dev_minor)
-{
+ int dm_dev_minor)
+{
dm_dev_t *dmv;
dmv = NULL;
-
+
mutex_enter(&dm_dev_mutex);
-
+
if (dm_dev_minor > 0)
- if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL){
+ if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL) {
disable_dev(dmv);
return dmv;
}
-
- if (dm_dev_name != NULL)
- if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL){
+ if (dm_dev_name != NULL)
+ if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL) {
disable_dev(dmv);
return dmv;
}
-
if (dm_dev_uuid != NULL)
- if ((dmv = dm_dev_lookup_name(dm_dev_uuid)) != NULL){
+ if ((dmv = dm_dev_lookup_name(dm_dev_uuid)) != NULL) {
disable_dev(dmv);
return dmv;
}
@@ -277,10 +269,9 @@
return NULL;
}
-
/*
* Destroy all devices created in device-mapper. Remove all tables
- * free all allocated memmory.
+ * free all allocated memmory.
*/
int
dm_dev_destroy(void)
@@ -288,10 +279,10 @@
dm_dev_t *dmv;
mutex_enter(&dm_dev_mutex);
- while (TAILQ_FIRST(&dm_dev_list) != NULL){
+ while (TAILQ_FIRST(&dm_dev_list) != NULL) {
dmv = TAILQ_FIRST(&dm_dev_list);
-
+
TAILQ_REMOVE(&dm_dev_list, TAILQ_FIRST(&dm_dev_list),
next_devlist);
@@ -299,7 +290,7 @@
while (dmv->ref_cnt != 0)
cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
-
+
/* Destroy active table first. */
dm_table_destroy(&dmv->table_head, DM_TABLE_ACTIVE);
@@ -311,36 +302,34 @@
mutex_exit(&dmv->dev_mtx);
mutex_destroy(&dmv->dev_mtx);
cv_destroy(&dmv->dev_cv);
-
- (void)kmem_free(dmv, sizeof(dm_dev_t));
+
+ (void) kmem_free(dmv, sizeof(dm_dev_t));
}
mutex_exit(&dm_dev_mutex);
mutex_destroy(&dm_dev_mutex);
- return 0;
+ return 0;
}
-
/*
* Allocate new device entry.
*/
-dm_dev_t*
+dm_dev_t *
dm_dev_alloc(void)
{
dm_dev_t *dmv;
-
+
dmv = kmem_zalloc(sizeof(dm_dev_t), KM_SLEEP);
-
- if(dmv != NULL)
+
+ if (dmv != NULL)
dmv->diskp = kmem_zalloc(sizeof(struct disk), KM_SLEEP);
-
+
return dmv;
}
-
/*
* Freed device entry.
*/
int
-dm_dev_free(dm_dev_t *dmv)
+dm_dev_free(dm_dev_t * dmv)
{
KASSERT(dmv != NULL);
@@ -348,33 +337,32 @@
mutex_destroy(&dmv->diskp_mtx);
cv_destroy(&dmv->dev_cv);
- if(dmv->diskp != NULL)
- (void)kmem_free(dmv->diskp, sizeof(struct disk));
-
- (void)kmem_free(dmv, sizeof(dm_dev_t));
-
+ if (dmv->diskp != NULL)
+ (void) kmem_free(dmv->diskp, sizeof(struct disk));
+
+ (void) kmem_free(dmv, sizeof(dm_dev_t));
+
return 0;
}
void
-dm_dev_busy(dm_dev_t *dmv)
+dm_dev_busy(dm_dev_t * dmv)
{
mutex_enter(&dmv->dev_mtx);
dmv->ref_cnt++;
mutex_exit(&dmv->dev_mtx);
-}
+}
void
-dm_dev_unbusy(dm_dev_t *dmv)
+dm_dev_unbusy(dm_dev_t * dmv)
{
KASSERT(dmv->ref_cnt != 0);
-
+
mutex_enter(&dmv->dev_mtx);
if (--dmv->ref_cnt == 0)
cv_broadcast(&dmv->dev_cv);
mutex_exit(&dmv->dev_mtx);
}
-
/*
* Return prop_array of dm_targer_list dictionaries.
*/
@@ -384,14 +372,14 @@
dm_dev_t *dmv;
prop_array_t dev_array;
prop_dictionary_t dev_dict;
-
+
dev_array = prop_array_create();
-
+
mutex_enter(&dm_dev_mutex);
-
+
TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
- dev_dict = prop_dictionary_create();
-
+ dev_dict = prop_dictionary_create();
+
prop_dictionary_set_cstring(dev_dict, DM_DEV_NAME, dmv->name);
prop_dictionary_set_uint32(dev_dict, DM_DEV_DEV, dmv->minor);
@@ -399,17 +387,16 @@
prop_object_release(dev_dict);
}
- mutex_exit(&dm_dev_mutex);
+ mutex_exit(&dm_dev_mutex);
return dev_array;
}
-
/*
* Initialize global device mutex.
*/
int
dm_dev_init(void)
{
- TAILQ_INIT(&dm_dev_list); /* initialize global dev list */
+ TAILQ_INIT(&dm_dev_list); /* initialize global dev list */
mutex_init(&dm_dev_mutex, MUTEX_DEFAULT, IPL_NONE);
return 0;
}
Index: src/sys/dev/dm/dm_ioctl.c
diff -u src/sys/dev/dm/dm_ioctl.c:1.19 src/sys/dev/dm/dm_ioctl.c:1.20
--- src/sys/dev/dm/dm_ioctl.c:1.19 Sun Jan 3 22:22:23 2010
+++ src/sys/dev/dm/dm_ioctl.c Mon Jan 4 00:19:08 2010
@@ -1,5 +1,4 @@
-
-/* $NetBSD: dm_ioctl.c,v 1.19 2010/01/03 22:22:23 haad Exp $ */
+/* $NetBSD: dm_ioctl.c,v 1.20 2010/01/04 00:19:08 haad Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -45,15 +44,15 @@
* up them.
*
* table_head locking:
- * To access table entries dm_table_* routines must be used.
+ * To access table entries dm_table_* routines must be used.
*
* dm_table_get_entry will increment table users reference
- * counter. It will return active or inactive table depedns
+ * counter. It will return active or inactive table depedns
* on uint8_t argument.
*
* dm_table_release must be called for every table_entry from
* dm_table_get_entry. Between these to calls tables can'tbe switched
- * or destroyed.
+ * or destroyed.
*
* dm_table_head_init initialize talbe_entries SLISTS and io_cv.
*
@@ -64,7 +63,7 @@
* dm_table_size etc. There is another user for table_head which wants
* to change table lists e.g. dm_dev_resume_ioctl, dm_dev_remove_ioctl,
* dm_table_clear_ioctl.
- *
+ *
* NOTE: It is not allowed to call dm_table_destroy, dm_table_switch_tables
* with hold table reference counter. Table reference counter is hold
* after calling dm_table_get_entry routine. After calling this
@@ -94,7 +93,7 @@
#include "netbsd-dm.h"
#include "dm.h"
-static uint64_t sc_minor_num;
+static uint64_t sc_minor_num;
extern const struct dkdriver dmdkdriver;
uint64_t dev_counter;
@@ -105,18 +104,17 @@
.cf_fstate = FSTATE_STAR,
.cf_unit = 0
};
-
#define DM_REMOVE_FLAG(flag, name) do { \
prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
flag &= ~name; \
prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
- } while (/*CONSTCOND*/0)
+} while (/*CONSTCOND*/0)
#define DM_ADD_FLAG(flag, name) do { \
prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
flag |= name; \
prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
- } while (/*CONSTCOND*/0)
+} while (/*CONSTCOND*/0)
static int dm_dbg_print_flags(int);
@@ -126,8 +124,8 @@
static int
dm_dbg_print_flags(int flags)
{
- aprint_debug("dbg_print --- %d\n",flags);
-
+ aprint_debug("dbg_print --- %d\n", flags);
+
if (flags & DM_READONLY_FLAG)
aprint_debug("dbg_flags: DM_READONLY_FLAG set In/Out\n");
@@ -157,10 +155,9 @@
if (flags & DM_NOFLUSH_FLAG)
aprint_debug("dbg_flags: DM_NOFLUSH_FLAG set In\n");
-
+
return 0;
}
-
/*
* Get version ioctl call I do it as default therefore this
* function is unused now.
@@ -168,9 +165,9 @@
int
dm_get_version_ioctl(prop_dictionary_t dm_dict)
{
+
return 0;
}
-
/*
* Get list of all available targets from global
* target list and sent them back to libdevmapper.
@@ -184,18 +181,15 @@
flags = 0;
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
-
- dm_dbg_print_flags(flags);
+ dm_dbg_print_flags(flags);
target_list = dm_target_prop_list();
prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list);
-
prop_object_release(target_list);
-
+
return 0;
}
-
/*
* Create in-kernel entry for device. Device attributes such as name, uuid are
* taken from proplib dictionary.
@@ -208,49 +202,47 @@
const char *name, *uuid;
int r, flags;
device_t devt;
-
+
r = 0;
flags = 0;
- name = NULL;
+ name = NULL;
uuid = NULL;
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
-
+
dm_dbg_print_flags(flags);
/* Lookup name and uuid if device already exist quit. */
if ((dmv = dm_dev_lookup(name, uuid, -1)) != NULL) {
- DM_ADD_FLAG(flags, DM_EXISTS_FLAG); /* Device already exists */
+ DM_ADD_FLAG(flags, DM_EXISTS_FLAG); /* Device already exists */
dm_dev_unbusy(dmv);
return EEXIST;
}
-
if ((devt = config_attach_pseudo(&dm_cfdata)) == NULL) {
aprint_error("Unable to attach pseudo device dm/%s\n", name);
return (ENOMEM);
}
-
if ((dmv = dm_dev_alloc()) == NULL)
return ENOMEM;
if (uuid)
strncpy(dmv->uuid, uuid, DM_UUID_LEN);
- else
+ else
dmv->uuid[0] = '\0';
-
+
if (name)
strlcpy(dmv->name, name, DM_NAME_LEN);
dmv->minor = atomic_inc_64_nv(&sc_minor_num);
- dmv->flags = 0; /* device flags are set when needed */
+ dmv->flags = 0; /* device flags are set when needed */
dmv->ref_cnt = 0;
dmv->event_nr = 0;
dmv->dev_type = 0;
dmv->devt = devt;
-
+
dm_table_head_init(&dmv->table_head);
mutex_init(&dmv->dev_mtx, MUTEX_DEFAULT, IPL_NONE);
@@ -266,19 +258,18 @@
disk_attach(dmv->diskp);
dmv->diskp->dk_info = NULL;
-
- if ((r = dm_dev_insert(dmv)) != 0)
+
+ if ((r = dm_dev_insert(dmv)) != 0)
dm_dev_free(dmv);
-
+
DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
/* Increment device counter After creating device */
atomic_inc_64(&dev_counter);
-
+
return r;
}
-
/*
* Get list of created device-mapper devices fromglobal list and
* send it to kernel.
@@ -295,7 +286,7 @@
* <integer>...</integer>
* </dict>
* </array>
- *
+ *
*/
int
dm_dev_list_ioctl(prop_dictionary_t dm_dict)
@@ -303,21 +294,20 @@
prop_array_t dev_list;
uint32_t flags;
-
+
flags = 0;
-
+
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
-
+
dm_dbg_print_flags(flags);
-
+
dev_list = dm_dev_prop_list();
prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, dev_list);
prop_object_release(dev_list);
-
+
return 0;
}
-
/*
* Rename selected devices old name is in struct dm_ioctl.
* newname is taken from dictionary
@@ -332,14 +322,14 @@
{
prop_array_t cmd_array;
dm_dev_t *dmv;
-
+
const char *name, *uuid, *n_name;
uint32_t flags, minor;
name = NULL;
uuid = NULL;
minor = 0;
-
+
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
@@ -347,35 +337,34 @@
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
dm_dbg_print_flags(flags);
-
+
cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
-
+
if (strlen(n_name) + 1 > DM_NAME_LEN)
return EINVAL;
-
+
if ((dmv = dm_dev_rem(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
/* change device name */
- /* XXX How to deal with this change, name only used in
- * dm_dev_routines, should I add dm_dev_change_name which will run under the
- * dm_dev_list mutex ?
+ /*
+ * XXX How to deal with this change, name only used in
+ * dm_dev_routines, should I add dm_dev_change_name which will run
+ * under the dm_dev_list mutex ?
*/
strlcpy(dmv->name, n_name, DM_NAME_LEN);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
dm_dev_insert(dmv);
-
+
return 0;
}
-
/*
* Remove device from global list I have to remove active
* and inactive tables first.
@@ -387,34 +376,37 @@
const char *name, *uuid;
uint32_t flags, minor;
device_t devt;
-
+
flags = 0;
name = NULL;
uuid = NULL;
-
+
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
-
+
dm_dbg_print_flags(flags);
- /* This seems as hack to me, probably use routine dm_dev_get_devt to
- atomicaly get devt from device. */
+ /*
+ * This seems as hack to me, probably use routine dm_dev_get_devt to
+ * atomicaly get devt from device.
+ */
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
devt = dmv->devt;
dm_dev_unbusy(dmv);
-
- /* This will call dm_detach routine which will actually removes device. */
+
+ /*
+ * This will call dm_detach routine which will actually removes
+ * device.
+ */
return config_detach(devt, DETACH_QUIET);
}
-
/*
* Return actual state of device to libdevmapper.
*/
@@ -424,24 +416,23 @@
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, j, minor;
-
+
name = NULL;
uuid = NULL;
flags = 0;
j = 0;
-
+
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
-
+
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
dm_dbg_print_flags(dmv->flags);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
@@ -449,25 +440,26 @@
if (dmv->flags & DM_SUSPEND_FLAG)
DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
- /* Add status flags for tables I have to check both
- active and inactive tables. */
+ /*
+ * Add status flags for tables I have to check both active and
+ * inactive tables.
+ */
if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))) {
DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
} else
DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j);
-
+
if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
else
DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
dm_dev_unbusy(dmv);
-
+
return 0;
}
-
/*
* Set only flag to suggest that device is suspended. This call is
* not supported in NetBSD.
@@ -479,40 +471,38 @@
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
-
+
name = NULL;
uuid = NULL;
flags = 0;
-
+
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
-
- if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL){
+
+ if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
atomic_or_32(&dmv->flags, DM_SUSPEND_FLAG);
-
+
dm_dbg_print_flags(dmv->flags);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
-
+
dm_dev_unbusy(dmv);
-
+
/* Add flags to dictionary flag after dmv -> dict copy */
- DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
-
+ DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
+
return 0;
}
-
/*
* Simulate Linux behaviour better and switch tables here and not in
- * dm_table_load_ioctl.
+ * dm_table_load_ioctl.
*/
int
dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
@@ -524,31 +514,31 @@
name = NULL;
uuid = NULL;
flags = 0;
-
-/* char *xml;
- xml = prop_dictionary_externalize(dm_dict);
- printf("%s\n",xml);*/
-
+
+ /*
+ * char *xml; xml = prop_dictionary_externalize(dm_dict);
+ * printf("%s\n",xml);
+ */
+
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
-
+
/* Remove device from global device list */
- if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL){
+ if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
atomic_and_32(&dmv->flags, ~(DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG));
atomic_or_32(&dmv->flags, DM_ACTIVE_PRESENT_FLAG);
-
+
dm_table_switch_tables(&dmv->table_head);
-
- DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
+
+ DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
dmgetproperties(dmv->diskp, &dmv->table_head);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
@@ -557,10 +547,9 @@
/* Destroy inactive table after resume. */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
-
+
return 0;
}
-
/*
* Table management routines
* lvm2tools doens't send name/uuid to kernel with table
@@ -579,41 +568,39 @@
const char *name, *uuid;
uint32_t flags, minor;
- dmv = NULL;
+ dmv = NULL;
name = NULL;
uuid = NULL;
flags = 0;
minor = 0;
-
+
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
-
+
aprint_debug("Clearing inactive table from device: %s--%s\n",
name, uuid);
-
- if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL){
+
+ if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
/* Select unused table */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
atomic_and_32(&dmv->flags, ~DM_INACTIVE_PRESENT_FLAG);
dm_dev_unbusy(dmv);
-
+
return 0;
}
-
/*
* Get list of physical devices for active table.
* Get dev_t from pdev vnode and insert it into cmd_array.
*
* XXX. This function is called from lvm2tools to get information
- * about physical devices, too e.g. during vgcreate.
+ * about physical devices, too e.g. during vgcreate.
*/
int
dm_table_deps_ioctl(prop_dictionary_t dm_dict)
@@ -631,9 +618,9 @@
name = NULL;
uuid = NULL;
- dmv = NULL;
+ dmv = NULL;
flags = 0;
-
+
i = 0;
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
@@ -644,37 +631,38 @@
/* create array for dev_t's */
cmd_array = prop_array_create();
- if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL){
+ if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
-
+
aprint_debug("Getting table deps for device: %s\n", dmv->name);
- /* if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query INACTIVE TABLE */
+ /*
+ * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
+ * INACTIVE TABLE
+ */
if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
table_type = DM_TABLE_INACTIVE;
else
table_type = DM_TABLE_ACTIVE;
-
+
tbl = dm_table_get_entry(&dmv->table_head, table_type);
SLIST_FOREACH(table_en, tbl, next)
- table_en->target->deps(table_en, cmd_array);
+ table_en->target->deps(table_en, cmd_array);
dm_table_release(&dmv->table_head, table_type);
dm_dev_unbusy(dmv);
-
+
prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
prop_object_release(cmd_array);
-
+
return 0;
}
-
/*
* Load new table/tables to device.
* Call apropriate target init routine open all physical pdev's and
@@ -690,13 +678,13 @@
{
dm_dev_t *dmv;
dm_table_entry_t *table_en, *last_table;
- dm_table_t *tbl;
+ dm_table_t *tbl;
dm_target_t *target;
prop_object_iterator_t iter;
prop_array_t cmd_array;
prop_dictionary_t target_dict;
-
+
const char *name, *uuid, *type;
uint32_t flags, ret, minor;
@@ -711,27 +699,27 @@
last_table = NULL;
str = NULL;
- /* char *xml;
- xml = prop_dictionary_externalize(dm_dict);
- printf("%s\n",xml);*/
-
+ /*
+ * char *xml; xml = prop_dictionary_externalize(dm_dict);
+ * printf("%s\n",xml);
+ */
+
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
-
+
cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
iter = prop_array_iterator(cmd_array);
- dm_dbg_print_flags(flags);
-
- if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL){
+ dm_dbg_print_flags(flags);
+
+ if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
aprint_debug("Loading table to device: %s--%d\n", name,
dmv->table_head.cur_active_table);
-
+
/*
* I have to check if this table slot is not used by another table list.
* if it is used I should free them.
@@ -741,12 +729,12 @@
dm_dbg_print_flags(dmv->flags);
tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_INACTIVE);
-
+
aprint_debug("dmv->name = %s\n", dmv->name);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
- while((target_dict = prop_object_iterator_next(iter)) != NULL){
+ while ((target_dict = prop_object_iterator_next(iter)) != NULL) {
prop_dictionary_get_cstring_nocopy(target_dict,
DM_TABLE_TYPE, &type);
@@ -760,14 +748,12 @@
dm_dev_unbusy(dmv);
return ENOENT;
}
-
if ((table_en = kmem_alloc(sizeof(dm_table_entry_t),
KM_SLEEP)) == NULL) {
dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
dm_dev_unbusy(dmv);
return ENOMEM;
}
-
prop_dictionary_get_uint64(target_dict, DM_TABLE_START,
&table_en->start);
prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH,
@@ -776,7 +762,7 @@
table_en->target = target;
table_en->dm_dev = dmv;
table_en->target_config = NULL;
-
+
/*
* There is a parameter string after dm_target_spec
* structure which points to /dev/wd0a 284 part of
@@ -785,20 +771,20 @@
* use it.
*/
prop_dictionary_get_cstring(target_dict,
- DM_TABLE_PARAMS, (char**)&str);
-
+ DM_TABLE_PARAMS, (char **) &str);
+
if (SLIST_EMPTY(tbl))
/* insert this table to head */
SLIST_INSERT_HEAD(tbl, table_en, next);
else
SLIST_INSERT_AFTER(last_table, table_en, next);
-
+
/*
* Params string is different for every target,
* therfore I have to pass it to target init
* routine and parse parameters there.
*/
-
+
if ((ret = target->init(dmv, &table_en->target_config,
str)) != 0) {
@@ -813,15 +799,14 @@
free(str, M_TEMP);
}
prop_object_iterator_release(iter);
-
+
DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
atomic_or_32(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
-
+
dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
dm_dev_unbusy(dmv);
return 0;
}
-
/*
* Get description of all tables loaded to device from kernel
* and send it to libdevmapper.
@@ -855,14 +840,14 @@
prop_array_t cmd_array;
prop_dictionary_t target_dict;
-
+
uint32_t rec_size, minor;
-
+
const char *name, *uuid;
char *params;
int flags;
int table_type;
-
+
dmv = NULL;
uuid = NULL;
name = NULL;
@@ -876,42 +861,43 @@
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
cmd_array = prop_array_create();
-
- if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL){
+
+ if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
-
- /* if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query INACTIVE TABLE */
+ /*
+ * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
+ * INACTIVE TABLE
+ */
if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
table_type = DM_TABLE_INACTIVE;
else
table_type = DM_TABLE_ACTIVE;
-
+
if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))
DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
else {
DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
-
+
if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
else {
DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
}
}
-
+
if (dmv->flags & DM_SUSPEND_FLAG)
DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
-
+
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
-
+
aprint_debug("Status of device tables: %s--%d\n",
name, dmv->table_head.cur_active_table);
-
+
tbl = dm_table_get_entry(&dmv->table_head, table_type);
-
- SLIST_FOREACH(table_en, tbl, next)
- {
+
+ SLIST_FOREACH(table_en, tbl, next) {
target_dict = prop_dictionary_create();
aprint_debug("%016" PRIu64 ", length %016" PRIu64
", target %s\n", table_en->start, table_en->length,
@@ -933,14 +919,13 @@
params = table_en->target->status
(table_en->target_config);
- if(params != NULL){
+ if (params != NULL) {
prop_dictionary_set_cstring(target_dict,
DM_TABLE_PARAMS, params);
-
+
kmem_free(params, DM_MAX_PARAMS_SIZE);
}
}
-
prop_array_add(cmd_array, target_dict);
prop_object_release(target_dict);
}
@@ -951,7 +936,7 @@
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
prop_object_release(cmd_array);
-
+
return 0;
}
@@ -959,7 +944,7 @@
/*
* For every call I have to set kernel driver version.
* Because I can have commands supported only in other
- * newer/later version. This routine is called for every
+ * newer/later version. This routine is called for every
* ioctl command.
*/
int
@@ -968,26 +953,25 @@
size_t i;
int dm_version[3];
prop_array_t ver;
-
+
ver = prop_dictionary_get(dm_dict, DM_IOCTL_VERSION);
-
- for(i=0; i < 3; i++)
+
+ for (i = 0; i < 3; i++)
prop_array_get_uint32(ver, i, &dm_version[i]);
- if (DM_VERSION_MAJOR != dm_version[0] || DM_VERSION_MINOR < dm_version[1]){
+ if (DM_VERSION_MAJOR != dm_version[0] || DM_VERSION_MINOR < dm_version[1]) {
aprint_debug("libdevmapper/kernel version mismatch "
"kernel: %d.%d.%d libdevmapper: %d.%d.%d\n",
DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL,
dm_version[0], dm_version[1], dm_version[2]);
-
+
return EIO;
}
-
prop_array_set_uint32(ver, 0, DM_VERSION_MAJOR);
prop_array_set_uint32(ver, 1, DM_VERSION_MINOR);
prop_array_set_uint32(ver, 2, DM_VERSION_PATCHLEVEL);
prop_dictionary_set(dm_dict, DM_IOCTL_VERSION, ver);
-
+
return 0;
}
Index: src/sys/dev/dm/dm_pdev.c
diff -u src/sys/dev/dm/dm_pdev.c:1.5 src/sys/dev/dm/dm_pdev.c:1.6
--- src/sys/dev/dm/dm_pdev.c:1.5 Sun Jan 3 12:53:00 2010
+++ src/sys/dev/dm/dm_pdev.c Mon Jan 4 00:19:08 2010
@@ -1,4 +1,4 @@
-/* $NetBSD: dm_pdev.c,v 1.5 2010/01/03 12:53:00 haad Exp $ */
+/* $NetBSD: dm_pdev.c,v 1.6 2010/01/04 00:19:08 haad Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -44,20 +44,21 @@
SLIST_HEAD(dm_pdevs, dm_pdev) dm_pdev_list;
-kmutex_t dm_pdev_mutex;
+ kmutex_t dm_pdev_mutex;
-static dm_pdev_t *dm_pdev_alloc(const char *);
-static int dm_pdev_rem(dm_pdev_t *);
-static dm_pdev_t* dm_pdev_lookup_name(const char *);
+ static dm_pdev_t *dm_pdev_alloc(const char *);
+ static int dm_pdev_rem(dm_pdev_t *);
+ static dm_pdev_t *dm_pdev_lookup_name(const char *);
/*
* Find used pdev with name == dm_pdev_name.
*/
-dm_pdev_t*
-dm_pdev_lookup_name(const char *dm_pdev_name)
+ dm_pdev_t *
+ dm_pdev_lookup_name(const char *dm_pdev_name)
{
dm_pdev_t *dm_pdev;
- int dlen; int slen;
+ int dlen;
+ int slen;
KASSERT(dm_pdev_name != NULL);
@@ -68,38 +69,37 @@
if (slen != dlen)
continue;
-
+
if (strncmp(dm_pdev_name, dm_pdev->name, slen) == 0)
return dm_pdev;
}
return NULL;
}
-
/*
* Create entry for device with name dev_name and open vnode for it.
* If entry already exists in global SLIST I will only increment
* reference counter.
*/
-dm_pdev_t*
+dm_pdev_t *
dm_pdev_insert(const char *dev_name)
{
dm_pdev_t *dmp;
int error;
-
+
KASSERT(dev_name != NULL);
-
+
mutex_enter(&dm_pdev_mutex);
dmp = dm_pdev_lookup_name(dev_name);
if (dmp != NULL) {
dmp->ref_cnt++;
- aprint_debug("dmp_pdev_insert pdev %s already in tree\n",dev_name);
+ aprint_debug("dmp_pdev_insert pdev %s already in tree\n", dev_name);
mutex_exit(&dm_pdev_mutex);
return dmp;
}
mutex_exit(&dm_pdev_mutex);
-
+
if ((dmp = dm_pdev_alloc(dev_name)) == NULL)
return NULL;
@@ -110,33 +110,30 @@
kmem_free(dmp, sizeof(dm_pdev_t));
return NULL;
}
-
dmp->ref_cnt = 1;
-
+
mutex_enter(&dm_pdev_mutex);
SLIST_INSERT_HEAD(&dm_pdev_list, dmp, next_pdev);
mutex_exit(&dm_pdev_mutex);
return dmp;
}
-
/*
* Initialize pdev subsystem.
*/
int
dm_pdev_init(void)
{
- SLIST_INIT(&dm_pdev_list); /* initialize global pdev list */
+ SLIST_INIT(&dm_pdev_list); /* initialize global pdev list */
mutex_init(&dm_pdev_mutex, MUTEX_DEFAULT, IPL_NONE);
-
+
return 0;
}
-
/*
* Allocat new pdev structure if is not already present and
* set name.
*/
-static dm_pdev_t*
+static dm_pdev_t *
dm_pdev_alloc(const char *name)
{
dm_pdev_t *dmp;
@@ -145,35 +142,32 @@
return NULL;
strlcpy(dmp->name, name, MAX_DEV_NAME);
-
+
dmp->ref_cnt = 0;
dmp->pdev_vnode = NULL;
-
+
return dmp;
}
-
/*
* Destroy allocated dm_pdev.
*/
static int
-dm_pdev_rem(dm_pdev_t *dmp)
+dm_pdev_rem(dm_pdev_t * dmp)
{
int err;
KASSERT(dmp != NULL);
-
+
if (dmp->pdev_vnode != NULL) {
err = vn_close(dmp->pdev_vnode, FREAD | FWRITE, FSCRED);
if (err != 0)
return err;
}
-
kmem_free(dmp, sizeof(*dmp));
dmp = NULL;
-
+
return 0;
}
-
/*
* Destroy all existing pdev's in device-mapper.
*/
@@ -183,10 +177,10 @@
dm_pdev_t *dm_pdev;
mutex_enter(&dm_pdev_mutex);
- while (!SLIST_EMPTY(&dm_pdev_list)) { /* List Deletion. */
-
+ while (!SLIST_EMPTY(&dm_pdev_list)) { /* List Deletion. */
+
dm_pdev = SLIST_FIRST(&dm_pdev_list);
-
+
SLIST_REMOVE_HEAD(&dm_pdev_list, next_pdev);
dm_pdev_rem(dm_pdev);
@@ -196,7 +190,6 @@
mutex_destroy(&dm_pdev_mutex);
return 0;
}
-
/*
* This funcion is called from dm_dev_remove_ioctl.
* When I'm removing device from list, I have to decrement
@@ -209,7 +202,7 @@
* Decrement pdev reference counter if 0 remove it.
*/
int
-dm_pdev_decr(dm_pdev_t *dmp)
+dm_pdev_decr(dm_pdev_t * dmp)
{
KASSERT(dmp != NULL);
/*
@@ -217,18 +210,16 @@
* global list also.
*/
mutex_enter(&dm_pdev_mutex);
-
+
if (--dmp->ref_cnt == 0) {
- SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
+ SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
mutex_exit(&dm_pdev_mutex);
dm_pdev_rem(dmp);
return 0;
}
-
mutex_exit(&dm_pdev_mutex);
return 0;
}
-
/*static int
dm_pdev_dump_list(void)
{
@@ -241,6 +232,6 @@
dmp->name, dmp->ref_cnt, dmp->list_ref_cnt);
}
- return 0;
+ return 0;
}*/
Index: src/sys/dev/dm/dm_table.c
diff -u src/sys/dev/dm/dm_table.c:1.4 src/sys/dev/dm/dm_table.c:1.5
--- src/sys/dev/dm/dm_table.c:1.4 Fri Oct 23 20:41:11 2009
+++ src/sys/dev/dm/dm_table.c Mon Jan 4 00:19:08 2010
@@ -1,4 +1,4 @@
-/* $NetBSD: dm_table.c,v 1.4 2009/10/23 20:41:11 joerg Exp $ */
+/* $NetBSD: dm_table.c,v 1.5 2010/01/04 00:19:08 haad Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -38,7 +38,7 @@
/*
* There are two types of users of this interface:
- *
+ *
* a) Readers such as
* dmstrategy, dmgetdisklabel, dmsize, dm_dev_status_ioctl,
* dm_table_deps_ioctl, dm_table_status_ioctl, dm_table_reload_ioctl
@@ -51,7 +51,7 @@
*
*/
-static int dm_table_busy(dm_table_head_t *, uint8_t );
+static int dm_table_busy(dm_table_head_t *, uint8_t);
static void dm_table_unbusy(dm_table_head_t *);
/*
@@ -61,7 +61,7 @@
* DM_TABLE_INACTIVE will return inactive table id.
*/
static int
-dm_table_busy(dm_table_head_t *head, uint8_t table_id)
+dm_table_busy(dm_table_head_t * head, uint8_t table_id)
{
uint8_t id;
@@ -79,50 +79,46 @@
mutex_exit(&head->table_mtx);
return id;
}
-
/*
* Function release table lock and eventually wakeup all waiters.
*/
static void
-dm_table_unbusy(dm_table_head_t *head)
+dm_table_unbusy(dm_table_head_t * head)
{
KASSERT(head->io_cnt != 0);
mutex_enter(&head->table_mtx);
-
+
if (--head->io_cnt == 0)
cv_broadcast(&head->table_cv);
-
+
mutex_exit(&head->table_mtx);
}
-
/*
* Return current active table to caller, increment io_cnt reference counter.
*/
dm_table_t *
-dm_table_get_entry(dm_table_head_t *head, uint8_t table_id)
+dm_table_get_entry(dm_table_head_t * head, uint8_t table_id)
{
uint8_t id;
id = dm_table_busy(head, table_id);
-
+
return &head->tables[id];
}
-
/*
* Decrement io reference counter and wake up all callers, with table_head cv.
*/
void
-dm_table_release(dm_table_head_t *head, uint8_t table_id)
+dm_table_release(dm_table_head_t * head, uint8_t table_id)
{
dm_table_unbusy(head);
}
-
/*
* Switch table from inactive to active mode. Have to wait until io_cnt is 0.
*/
void
-dm_table_switch_tables(dm_table_head_t *head)
+dm_table_switch_tables(dm_table_head_t * head)
{
mutex_enter(&head->table_mtx);
@@ -133,7 +129,6 @@
mutex_exit(&head->table_mtx);
}
-
/*
* Destroy all table data. This function can run when there are no
* readers on table lists.
@@ -141,9 +136,9 @@
* XXX Is it ok to call kmem_free and potentialy VOP_CLOSE with held mutex ?xs
*/
int
-dm_table_destroy(dm_table_head_t *head, uint8_t table_id)
+dm_table_destroy(dm_table_head_t * head, uint8_t table_id)
{
- dm_table_t *tbl;
+ dm_table_t *tbl;
dm_table_entry_t *table_en;
uint8_t id;
@@ -158,45 +153,44 @@
id = head->cur_active_table;
else
id = 1 - head->cur_active_table;
-
+
tbl = &head->tables[id];
-
- while (!SLIST_EMPTY(tbl)) { /* List Deletion. */
+
+ while (!SLIST_EMPTY(tbl)) { /* List Deletion. */
table_en = SLIST_FIRST(tbl);
/*
* Remove target specific config data. After successfull
* call table_en->target_config must be set to NULL.
*/
- table_en->target->destroy(table_en);
-
+ table_en->target->destroy(table_en);
+
SLIST_REMOVE_HEAD(tbl, next);
kmem_free(table_en, sizeof(*table_en));
}
mutex_exit(&head->table_mtx);
-
+
return 0;
}
-
/*
* Return length of active table in device.
*/
uint64_t
-dm_table_size(dm_table_head_t *head)
+dm_table_size(dm_table_head_t * head)
{
- dm_table_t *tbl;
+ dm_table_t *tbl;
dm_table_entry_t *table_en;
uint64_t length;
uint8_t id;
-
+
length = 0;
id = dm_table_busy(head, DM_TABLE_ACTIVE);
-
+
/* Select active table */
tbl = &head->tables[id];
-
+
/*
* Find out what tables I want to select.
* if length => rawblkno then we should used that table.
@@ -205,10 +199,9 @@
length += table_en->length;
dm_table_unbusy(head);
-
+
return length;
}
-
/*
* Return > 0 if table is at least one table entry (returns number of entries)
* and return 0 if there is not. Target count returned from this function
@@ -216,8 +209,8 @@
* there can be dm_dev_resume_ioctl), therfore this isonly informative.
*/
int
-dm_table_get_target_count(dm_table_head_t *head, uint8_t table_id)
-{
+dm_table_get_target_count(dm_table_head_t * head, uint8_t table_id)
+{
dm_table_entry_t *table_en;
dm_table_t *tbl;
uint32_t target_count;
@@ -233,7 +226,7 @@
target_count++;
dm_table_unbusy(head);
-
+
return target_count;
}
@@ -243,11 +236,11 @@
* opaque as possible.
*/
void
-dm_table_head_init(dm_table_head_t *head)
+dm_table_head_init(dm_table_head_t * head)
{
head->cur_active_table = 0;
head->io_cnt = 0;
-
+
/* Initialize tables. */
SLIST_INIT(&head->tables[0]);
SLIST_INIT(&head->tables[1]);
@@ -255,19 +248,18 @@
mutex_init(&head->table_mtx, MUTEX_DEFAULT, IPL_NONE);
cv_init(&head->table_cv, "dm_io");
}
-
/*
* Destroy all variables in table_head
*/
void
-dm_table_head_destroy(dm_table_head_t *head)
+dm_table_head_destroy(dm_table_head_t * head)
{
KASSERT(!mutex_owned(&head->table_mtx));
KASSERT(!cv_has_waiters(&head->table_cv));
- /* tables doens't exists when I call this routine, therefore
- it doesn't make sense to have io_cnt != 0 */
- KASSERT(head->io_cnt == 0);
-
+ /* tables doens't exists when I call this routine, therefore it
+ * doesn't make sense to have io_cnt != 0 */
+ KASSERT(head->io_cnt == 0);
+
cv_destroy(&head->table_cv);
mutex_destroy(&head->table_mtx);
}
