/*
* 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.
*/
int
dm_table_deps_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
dm_table_t *tbl;
dm_table_entry_t *table_en;
prop_array_t cmd_array;
const char *name, *uuid;
uint32_t flags, minor;
int table_type;
name = NULL;
uuid = NULL;
dmv = 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);
/* create array for dev_t's */
cmd_array = prop_array_create();
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 (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);
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;
}
/*
* Get description of all tables loaded to device from kernel
* and send it to libdevmapper.
*
* Output dictionary for every table:
*
* <key>cmd_data</key>
* <array>
* <dict>
* <key>type<key>
* <string>...</string>
*
* <key>start</key>
* <integer>...</integer>
*
* <key>length</key>
* <integer>...</integer>
*
* <key>params</key>
* <string>...</string>
* </dict>
* </array>
*
*/
int
dm_table_status_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
dm_table_t *tbl;
dm_table_entry_t *table_en;
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;
params = NULL;
flags = 0;
rec_size = 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);
cmd_array = prop_array_create();
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 (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) {
target_dict = prop_dictionary_create();
aprint_debug("%016" PRIu64 ", length %016" PRIu64
", target %s\n", table_en->start, table_en->length,
table_en->target->name);
prop_dictionary_set_uint64(target_dict, DM_TABLE_START,
table_en->start);
prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH,
table_en->length);
prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE,
table_en->target->name);
/* dm_table_get_cur_actv.table ?? */
prop_dictionary_set_int32(target_dict, DM_TABLE_STAT,
dmv->table_head.cur_active_table);
if (flags & DM_STATUS_TABLE_FLAG) {
params = table_en->target->status
(table_en->target_config);
if (params != NULL) {
prop_dictionary_set_cstring(target_dict,
DM_TABLE_PARAMS, params);
kfree(params, M_DM);
}
}
prop_array_add(cmd_array, target_dict);
prop_object_release(target_dict);
}
/*
* Load new table/tables to device.
* Call apropriate target init routine open all physical pdev's and
* link them to device. For other targets mirror, strip, snapshot
* etc. also add dependency devices to upcalls list.
*
* Load table to inactive slot table are switched in dm_device_resume_ioctl.
* This simulates Linux behaviour better there should not be any difference.
*
*/
int
dm_table_load_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
dm_table_entry_t *table_en, *last_table;
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;
char *str;
ret = 0;
flags = 0;
name = NULL;
uuid = NULL;
dmv = NULL;
last_table = NULL;
str = NULL;
/*
* 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_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.
*/
if (dmv->flags & DM_INACTIVE_PRESENT_FLAG)
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
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) {
prop_dictionary_get_cstring_nocopy(target_dict,
DM_TABLE_TYPE, &type);
/*
* If we want to deny table with 2 or more different
* target we should do it here
*/
if (((target = dm_target_lookup(type)) == NULL) &&
((target = dm_target_autoload(type)) == NULL)) {
dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
dm_dev_unbusy(dmv);
return ENOENT;
}
if ((table_en = kmalloc(sizeof(dm_table_entry_t),
M_DM, M_WAITOK)) == NULL) {
dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
dm_dev_unbusy(dmv);
dm_target_unbusy(target);
return ENOMEM;
}
prop_dictionary_get_uint64(target_dict, DM_TABLE_START,
&table_en->start);
prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH,
&table_en->length);
aprint_debug("dm_ioctl.c... table_en->start = %ju, "
"table_en->length = %ju\n",
(uintmax_t)table_en->start,
(uintmax_t)table_en->length);
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
* table. String str points to this text. This can be
* null and therefore it should be checked before we try to
* use it.
*/
prop_dictionary_get_cstring(target_dict,
DM_TABLE_PARAMS, &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.
*/
aprint_debug("DM: str passed in is: %s", str);
if ((ret = target->init(dmv, &table_en->target_config,
str)) != 0) {
dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
kfree(str, M_TEMP);
dm_dev_unbusy(dmv);
dm_target_unbusy(target);
return ret;
}
last_table = table_en;
kfree(str, M_TEMP);
}
prop_object_iterator_release(iter);
DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
atomic_set_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
dm_dev_unbusy(dmv);
#if 0
dmsetdiskinfo(dmv->diskp, &dmv->table_head);
#endif
return 0;
}
/*
* Do all IO operations on dm logical devices.
*/
static int
dmstrategy(struct dev_strategy_args *ap)
{
cdev_t dev = ap->a_head.a_dev;
struct bio *bio = ap->a_bio;
struct buf *bp = bio->bio_buf;
int bypass;
dm_dev_t *dmv;
dm_table_t *tbl;
dm_table_entry_t *table_en;
struct buf *nestbuf;
uint32_t dev_type;
uint64_t buf_start, buf_len, issued_len;
uint64_t table_start, table_end;
uint64_t start, end;
buf_start = bio->bio_offset;
buf_len = bp->b_bcount;
tbl = NULL;
table_end = 0;
dev_type = 0;
issued_len = 0;
dmv = dev->si_drv1;
switch(bp->b_cmd) {
case BUF_CMD_READ:
case BUF_CMD_WRITE:
case BUF_CMD_FREEBLKS:
bypass = 0;
break;
case BUF_CMD_FLUSH:
bypass = 1;
KKASSERT(buf_len == 0);
break;
default:
bp->b_error = EIO;
bp->b_resid = bp->b_bcount;
biodone(bio);
return 0;
}
if (bypass == 0 &&
bounds_check_with_mediasize(bio, DEV_BSIZE,
dm_table_size(&dmv->table_head)) <= 0) {
bp->b_resid = bp->b_bcount;
biodone(bio);
return 0;
}
/* Select active table */
tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_ACTIVE);
nestiobuf_init(bio);
devstat_start_transaction(&dmv->stats);
/*
* Find out what tables I want to select.
*/
SLIST_FOREACH(table_en, tbl, next) {
/*
* I need need number of bytes not blocks.
*/
table_start = table_en->start * DEV_BSIZE;
table_end = table_start + (table_en->length) * DEV_BSIZE;
/*
* Calculate the start and end
*/
start = MAX(table_start, buf_start);
end = MIN(table_end, buf_start + buf_len);
aprint_debug("----------------------------------------\n");
aprint_debug("table_start %010" PRIu64", table_end %010"
PRIu64 "\n", table_start, table_end);
aprint_debug("buf_start %010" PRIu64", buf_len %010"
PRIu64"\n", buf_start, buf_len);
aprint_debug("start-buf_start %010"PRIu64", end %010"
PRIu64"\n", start - buf_start, end);
aprint_debug("start %010" PRIu64" , end %010"
PRIu64"\n", start, end);
aprint_debug("\n----------------------------------------\n");
if (bypass) {
nestbuf = getpbuf(NULL);
nestbuf->b_flags |= bio->bio_buf->b_flags & B_HASBOGUS;
nestiobuf_add(bio, nestbuf, 0, 0, &dmv->stats);
nestbuf->b_bio1.bio_offset = 0;
table_en->target->strategy(table_en, nestbuf);
} else if (start < end) {
nestbuf = getpbuf(NULL);
nestbuf->b_flags |= bio->bio_buf->b_flags & B_HASBOGUS;
nestiobuf_add(bio, nestbuf,
start - buf_start, (end - start),
&dmv->stats);
issued_len += end - start;
nestbuf->b_bio1.bio_offset = (start - table_start);
table_en->target->strategy(table_en, nestbuf);
}
}
static int
disk_ioctl_switch(dev_t dev, u_long cmd, void *data)
{
dm_dev_t *dmv;
/* disk ioctls make sense only on block devices */
if (minor(dev) == 0)
return ENOTTY;
switch(cmd) {
case DIOCGWEDGEINFO:
{
struct dkwedge_info *dkw = (void *) data;
unsigned secsize;
if ((dmv = dm_dev_lookup(NULL, NULL, minor(dev))) == NULL)
return ENODEV;
aprint_debug("DIOCGWEDGEINFO ioctl called\n");
strlcpy(dkw->dkw_devname, dmv->name, 16);
strlcpy(dkw->dkw_wname, dmv->name, DM_NAME_LEN);
strlcpy(dkw->dkw_parent, dmv->name, 16);
dkw->dkw_offset = 0;
dm_table_disksize(&dmv->table_head, &dkw->dkw_size, &secsize);
strcpy(dkw->dkw_ptype, DKW_PTYPE_FFS);
dm_dev_unbusy(dmv);
break;
}
case DIOCGDISKINFO:
{
struct plistref *pref = (struct plistref *) data;
if ((dmv = dm_dev_lookup(NULL, NULL, minor(dev))) == NULL)
return ENODEV;
if (dmv->diskp->dk_info == NULL) {
dm_dev_unbusy(dmv);
return ENOTSUP;
} else
prop_dictionary_copyout_ioctl(pref, cmd,
dmv->diskp->dk_info);
dm_dev_unbusy(dmv);
break;
}
case DIOCCACHESYNC:
{
dm_table_entry_t *table_en;
dm_table_t *tbl;
if ((dmv = dm_dev_lookup(NULL, NULL, minor(dev))) == NULL)
return ENODEV;
/* Select active table */
tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_ACTIVE);
/*
* Call sync target routine for all table entries. Target sync
* routine basically call DIOCCACHESYNC on underlying devices.
*/
SLIST_FOREACH(table_en, tbl, next)
{
(void)table_en->target->sync(table_en);
}
dm_table_release(&dmv->table_head, DM_TABLE_ACTIVE);
dm_dev_unbusy(dmv);
break;
}
default:
aprint_debug("unknown disk_ioctl called\n");
return ENOTTY;
break; /* NOT REACHED */
}
