/*
* dm_detach:
*
* Autoconfiguration detach function for pseudo-device glue.
* This routine is called by dm_ioctl::dm_dev_remove_ioctl and by autoconf to
* remove devices created in device-mapper.
*/
static int
dm_detach(device_t self, int flags)
{
dm_dev_t *dmv;
/* Detach device from global device list */
if ((dmv = dm_dev_detach(self)) == NULL)
return ENOENT;
/* Destroy active table first. */
dm_table_destroy(&dmv->table_head, DM_TABLE_ACTIVE);
/* Destroy inactive table if exits, too. */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
dm_table_head_destroy(&dmv->table_head);
/* Destroy disk device structure */
disk_detach(dmv->diskp);
disk_destroy(dmv->diskp);
/* Destroy device */
(void)dm_dev_free(dmv);
/* Decrement device counter After removing device */
atomic_dec_32(&dm_dev_counter);
return 0;
}
struct inode *dmfs_create_lv(struct super_block *sb, int mode,
struct dentry *dentry)
{
struct inode *inode = dmfs_new_private_inode(sb, mode | S_IFDIR);
struct mapped_device *md;
const char *name = dentry->d_name.name;
char tmp_name[DM_NAME_LEN + 1];
struct dm_table *table;
int ret = -ENOMEM;
if (inode) {
ret = dm_table_create(&table);
if (!ret) {
ret = dm_table_complete(table);
if (!ret) {
inode->i_fop = &dmfs_lv_file_operations;
inode->i_op = &dmfs_lv_inode_operations;
memcpy(tmp_name, name, dentry->d_name.len);
tmp_name[dentry->d_name.len] = 0;
ret = dm_create(tmp_name, -1, table, &md);
if (!ret) {
DMFS_I(inode)->md = md;
md->suspended = 1;
return inode;
}
}
dm_table_destroy(table);
}
iput(inode);
}
return ERR_PTR(ret);
}
/*
* Remove inactive table from device. Routines which work's with inactive tables
* doesn't need to synchronise with dmstrategy. They can synchronise themselves with mutex?.
*
*/
int
dm_table_clear_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
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) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
/* Select unused table */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
atomic_clear_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
dm_dev_unbusy(dmv);
return 0;
}
/*
* Simulate Linux behaviour better and switch tables here and not in
* dm_table_load_ioctl.
*/
int
dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
name = NULL;
uuid = NULL;
flags = 0;
/*
* 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) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
atomic_clear_int(&dmv->flags, (DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG));
atomic_set_int(&dmv->flags, DM_ACTIVE_PRESENT_FLAG);
dm_table_switch_tables(&dmv->table_head);
DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
dmsetdiskinfo(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);
dm_dev_unbusy(dmv);
/* Destroy inactive table after resume. */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
return 0;
}
/*
* 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;
}
