int dm_message(char *path, char *message)
{
struct dm_task *task;
int e = -EIO;
if(!path) {
goto fail;
}
if(!(task = dm_task_create(DM_DEVICE_TARGET_MSG))) {
goto fail;
}
if(!dm_task_set_name(task, path)) {
goto fail;
}
if(!dm_task_set_sector(task, 0)) {
goto fail;
}
if(!dm_task_set_message(task, message)) {
goto fail;
}
if(!dm_task_run(task)) {
e = -errno;
goto fail;
}
e = 0;
fail:
dm_task_destroy(task);
return e;
}
extern int
dm_get_status(char * name, char * outstatus)
{
int r = 1;
struct dm_task *dmt;
uint64_t start, length;
char *target_type;
char *status;
if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
return 1;
if (!dm_task_set_name(dmt, name))
goto out;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
/* Fetch 1st target */
dm_get_next_target(dmt, NULL, &start, &length,
&target_type, &status);
if (snprintf(outstatus, PARAMS_SIZE, "%s", status) <= PARAMS_SIZE)
r = 0;
out:
if (r)
condlog(0, "%s: error getting map status string", name);
dm_task_destroy(dmt);
return r;
}
/*
* returns:
* 1 : match
* 0 : no match
* -1 : empty map
*/
extern int
dm_type(const char * name, char * type)
{
int r = 0;
struct dm_task *dmt;
uint64_t start, length;
char *target_type = NULL;
char *params;
if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
return 0;
if (!dm_task_set_name(dmt, name))
goto out;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
/* Fetch 1st target */
dm_get_next_target(dmt, NULL, &start, &length,
&target_type, ¶ms);
if (!target_type)
r = -1;
else if (!strcmp(target_type, type))
r = 1;
out:
dm_task_destroy(dmt);
return r;
}
static int
dm_dev_t (const char * mapname, char * dev_t, int len)
{
int r = 1;
struct dm_task *dmt;
struct dm_info info;
if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
return 0;
if (!dm_task_set_name(dmt, mapname))
goto out;
if (!dm_task_run(dmt))
goto out;
if (!dm_task_get_info(dmt, &info) || !info.exists)
goto out;
if (snprintf(dev_t, len, "%i:%i", info.major, info.minor) > len)
goto out;
r = 0;
out:
dm_task_destroy(dmt);
return r;
}
int
dm_get_minor (char * mapname)
{
int r = -1;
struct dm_task *dmt;
struct dm_info info;
if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
return 0;
if (!dm_task_set_name(dmt, mapname))
goto out;
if (!dm_task_run(dmt))
goto out;
if (!dm_task_get_info(dmt, &info))
goto out;
if (!info.exists)
goto out;
r = info.minor;
out:
dm_task_destroy(dmt);
return r;
}
static int _process_mapper_dir(struct dm_task *dmt)
{
struct dirent *dirent;
DIR *d;
const char *dir;
int r = 1;
dir = dm_dir();
if (!(d = opendir(dir))) {
log_sys_error("opendir", dir);
return 0;
}
while ((dirent = readdir(d))) {
if (!strcmp(dirent->d_name, ".") ||
!strcmp(dirent->d_name, "..") ||
!strcmp(dirent->d_name, "control"))
continue;
dm_task_set_name(dmt, dirent->d_name);
dm_task_run(dmt);
}
if (closedir(d))
log_sys_error("closedir", dir);
return r;
}
int dm_mount_aspect(substrate_t *substrate, u64 header_offset, u8 *header_key, char *name)
{
char *params;
struct dm_task *task;
task = dm_task_create(DM_DEVICE_CREATE);
if(!task) {
die("dm_task_create");
}
if(!dm_task_set_name(task, name)) {
die("dm_task_set_name");
}
if(!dm_task_set_uuid(task, name)) {
die("dm_task_set_uuid");
}
params = steg_malloc(strlen(substrate->filename) + 4096);
sprintf(params, "%s %zu ", substrate->filename, header_offset);
sprint_hex(params + strlen(params), header_key, KEY_BYTES);
if(!dm_task_add_target(task, 0, substrate->bytes, "steg", params)) {
die("dm_task_add_target");
}
if(!dm_task_run(task)) {
die("dm_task_run");
}
dm_task_destroy(task);
steg_free(params);
return 0;
}
extern int
dm_map_present (const char * str)
{
int r = 0;
struct dm_task *dmt;
struct dm_info info;
if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
return 0;
if (!dm_task_set_name(dmt, str))
goto out;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
if (!dm_task_get_info(dmt, &info))
goto out;
if (info.exists)
r = 1;
out:
dm_task_destroy(dmt);
return r;
}
static int
dm_get_prefixed_uuid(const char *name, char *uuid)
{
struct dm_task *dmt;
const char *uuidtmp;
int r = 1;
dmt = dm_task_create(DM_DEVICE_INFO);
if (!dmt)
return 1;
if (!dm_task_set_name (dmt, name))
goto uuidout;
if (!dm_task_run(dmt))
goto uuidout;
uuidtmp = dm_task_get_uuid(dmt);
if (uuidtmp)
strcpy(uuid, uuidtmp);
else
uuid[0] = '\0';
r = 0;
uuidout:
dm_task_destroy(dmt);
return r;
}
int
dm_geteventnr (char *name)
{
struct dm_task *dmt;
struct dm_info info;
int event = -1;
if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
return -1;
if (!dm_task_set_name(dmt, name))
goto out;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
if (!dm_task_get_info(dmt, &info))
goto out;
if (info.exists)
event = info.event_nr;
out:
dm_task_destroy(dmt);
return event;
}
/* Create a task, set its name and run it. */
static int
run_task(struct lib_context *lc, struct raid_set *rs, char *table, int type, char *name)
{
/*
* DM_UUID_LEN is defined in dm-ioctl.h as 129 characters;
* though not all 129 must be used (md uses just 16 from
* a quick review of md.c.
* We will be using: (len vol grp name)
*/
char uuid[DM_UUID_LEN];
int ret;
struct dm_task *dmt;
_init_dm();
ret = (dmt = dm_task_create(type)) && dm_task_set_name(dmt, name);
if (ret && table)
ret = parse_table(lc, dmt, table);
if (ret) {
if (DM_DEVICE_CREATE == type) {
ret = dmraid_uuid(lc, rs, uuid, DM_UUID_LEN, name) &&
dm_task_set_uuid(dmt, uuid) && dm_task_run(dmt);
} else
ret = dm_task_run(dmt);
}
_exit_dm(dmt);
return ret;
}
static int _dm_simple(int task, int wait, const char *name)
{
struct dm_task *dmt;
uint32_t cookie = 0;
int rc;
if (!(dmt = dm_task_create(task)))
return -1;
if (!dm_task_set_name(dmt, name))
goto out;
if (wait && !dm_task_set_cookie(dmt, &cookie, 0))
goto out;
rc = dm_task_run(dmt);
if (wait)
(void) dm_udev_wait(cookie);
dm_task_destroy(dmt);
return rc ? 0 : -1;
out:
dm_task_destroy(dmt);
return -1;
}
int era_dm_message0(const char *name, const char *message)
{
struct dm_task *dmt;
int rc = -1;
if (!(dmt = dm_task_create(DM_DEVICE_TARGET_MSG)))
return -1;
if (!dm_task_set_name(dmt, name))
goto out;
if (!dm_task_set_sector(dmt, 0))
goto out;
if (!dm_task_set_message(dmt, message))
goto out;
if (!dm_task_run(dmt))
goto out;
rc = 0;
out:
dm_task_destroy(dmt);
return rc;
}
static int
virStorageBackendGetMinorNumber(const char *dev_name, uint32_t *minor)
{
int ret = -1;
struct dm_task *dmt;
struct dm_info info;
if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
goto out;
if (!dm_task_set_name(dmt, dev_name))
goto out;
if (!dm_task_run(dmt))
goto out;
if (!dm_task_get_info(dmt, &info))
goto out;
*minor = info.minor;
ret = 0;
out:
if (dmt != NULL)
dm_task_destroy(dmt);
return ret;
}
static int _error_device(const char *name, size_t size)
{
struct dm_task *dmt;
int r = 0;
if (!(dmt = dm_task_create(DM_DEVICE_RELOAD)))
return 0;
if (!dm_task_set_name(dmt, name))
goto error;
if (!dm_task_add_target(dmt, UINT64_C(0), size, "error", ""))
goto error;
if (!dm_task_set_ro(dmt))
goto error;
if (!dm_task_no_open_count(dmt))
goto error;
if (!dm_task_run(dmt))
goto error;
if (!_dm_simple(DM_DEVICE_RESUME, name, 1)) {
_dm_simple(DM_DEVICE_CLEAR, name, 0);
goto error;
}
r = 1;
error:
dm_task_destroy(dmt);
return r;
}
/* DM helpers */
static int _dm_simple(int task, const char *name, int udev_wait)
{
int r = 0;
struct dm_task *dmt;
uint32_t cookie = 0;
if (!_dm_use_udev())
udev_wait = 0;
if (!(dmt = dm_task_create(task)))
return 0;
if (name && !dm_task_set_name(dmt, name))
goto out;
if (udev_wait && !dm_task_set_cookie(dmt, &cookie, 0))
goto out;
r = dm_task_run(dmt);
if (udev_wait)
(void)dm_udev_wait(cookie);
out:
dm_task_destroy(dmt);
return r;
}
int
dm_message(const char * mapname, char * message)
{
int r = 1;
struct dm_task *dmt;
if (!(dmt = dm_task_create(DM_DEVICE_TARGET_MSG)))
return 1;
if (!dm_task_set_name(dmt, mapname))
goto out;
if (!dm_task_set_sector(dmt, 0))
goto out;
if (!dm_task_set_message(dmt, message))
goto out;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
r = 0;
out:
if (r)
condlog(0, "DM message failed [%s]", message);
dm_task_destroy(dmt);
return r;
}
static
int
dm_get_info(const char *name, struct dm_info *dmi)
{
struct dm_task *dmt = NULL;
int error = -1;
if ((dmt = dm_task_create(DM_DEVICE_INFO)) == NULL)
goto out;
if ((dm_task_set_name(dmt, name)) == 0)
goto out;
if ((dm_task_run(dmt)) == 0)
goto out;
if ((dm_task_get_info(dmt, dmi)) == 0)
goto out;
error = 0;
out:
if (dmt)
dm_task_destroy(dmt);
return error;
}
int dm_addmap(int task, const char *name, const char *target,
const char *params, uint64_t size, int ro, const char *uuid,
int part, mode_t mode, uid_t uid, gid_t gid)
{
int r = 0;
struct dm_task *dmt;
char *prefixed_uuid = NULL;
#ifdef LIBDM_API_COOKIE
uint32_t cookie = 0;
uint16_t udev_flags = 0;
#endif
if (!(dmt = dm_task_create (task)))
return 0;
if (!dm_task_set_name (dmt, name))
goto addout;
if (!dm_task_add_target (dmt, 0, size, target, params))
goto addout;
if (ro && !dm_task_set_ro (dmt))
goto addout;
if (task == DM_DEVICE_CREATE && uuid) {
prefixed_uuid = make_prefixed_uuid(part, uuid);
if (prefixed_uuid == NULL)
goto addout;
if (!dm_task_set_uuid(dmt, prefixed_uuid))
goto addout;
}
if (!dm_task_set_mode(dmt, mode))
goto addout;
if (!dm_task_set_uid(dmt, uid))
goto addout;
if (!dm_task_set_gid(dmt, gid))
goto addout;
dm_task_no_open_count(dmt);
#ifdef LIBDM_API_COOKIE
if (!udev_sync)
udev_flags = DM_UDEV_DISABLE_LIBRARY_FALLBACK;
if (task == DM_DEVICE_CREATE &&
!dm_task_set_cookie(dmt, &cookie, udev_flags))
goto addout;
#endif
r = dm_task_run (dmt);
#ifdef LIBDM_API_COOKIE
if (task == DM_DEVICE_CREATE)
dm_udev_wait(cookie);
#endif
addout:
dm_task_destroy (dmt);
free(prefixed_uuid);
return r;
}
static gboolean map_is_multipath (const gchar *map_name, GError **error) {
struct dm_task *task = NULL;
struct dm_info info;
guint64 start = 0;
guint64 length = 0;
gchar *type = NULL;
gchar *params = NULL;
gboolean ret = FALSE;
if (geteuid () != 0) {
g_set_error (error, BD_MPATH_ERROR, BD_MPATH_ERROR_NOT_ROOT,
"Not running as root, cannot query DM maps");
return FALSE;
}
task = dm_task_create (DM_DEVICE_STATUS);
if (!task) {
g_warning ("Failed to create DM task");
g_set_error (error, BD_MPATH_ERROR, BD_MPATH_ERROR_DM_ERROR,
"Failed to create DM task");
return FALSE;
}
if (dm_task_set_name (task, map_name) == 0) {
g_set_error (error, BD_MPATH_ERROR, BD_MPATH_ERROR_DM_ERROR,
"Failed to create DM task");
dm_task_destroy (task);
return FALSE;
}
if (dm_task_run (task) == 0) {
g_set_error (error, BD_MPATH_ERROR, BD_MPATH_ERROR_DM_ERROR,
"Failed to run DM task");
dm_task_destroy (task);
return FALSE;
}
if (dm_task_get_info (task, &info) == 0) {
g_set_error (error, BD_MPATH_ERROR, BD_MPATH_ERROR_DM_ERROR,
"Failed to get task info");
dm_task_destroy (task);
return FALSE;
}
dm_get_next_target(task, NULL, &start, &length, &type, ¶ms);
if (g_strcmp0 (type, "multipath") == 0)
ret = TRUE;
else
ret = FALSE;
dm_task_destroy (task);
return ret;
}
static int _set_task_device(struct dm_task *dmt, const char *name, int optional)
{
if (name) {
if (!dm_task_set_name(dmt, name))
return 0;
} else if (!optional) {
fprintf(stderr, "No device specified.\n");
return 0;
}
return 1;
}
static int _dm_create(int task, int wait,
const char *name, const char *uuid,
uint64_t start, uint64_t length,
const char *target, const char *table,
struct era_dm_info *info)
{
struct dm_task *dmt;
uint32_t cookie = 0;
int rc;
if (!(dmt = dm_task_create(task)))
return -1;
if (!dm_task_set_name(dmt, name))
goto out;
if (uuid && !dm_task_set_uuid(dmt, uuid))
goto out;
if (target && !dm_task_add_target(dmt, start, length, target, table))
goto out;
if (wait && !dm_task_set_cookie(dmt, &cookie, 0))
goto out;
rc = dm_task_run(dmt);
if (wait)
(void) dm_udev_wait(cookie);
if (rc && info)
{
struct dm_info dmi;
if (!dm_task_get_info(dmt, &dmi))
goto out;
info->target_count = dmi.target_count;
info->open_count = dmi.open_count;
info->suspended = dmi.suspended;
info->exists = dmi.exists;
info->major = dmi.major;
info->minor = dmi.minor;
}
dm_task_destroy(dmt);
return rc ? 0 : -1;
out:
dm_task_destroy(dmt);
return -1;
}
/* FIXME: more status for device monitoring... */
int
dm_status(struct lib_context *lc, struct raid_set *rs)
{
int ret;
struct dm_task *dmt;
struct dm_info info;
_init_dm();
/* Status <dev_name>. */
ret = (dmt = dm_task_create(DM_DEVICE_STATUS)) &&
dm_task_set_name(dmt, rs->name) &&
dm_task_run(dmt) && dm_task_get_info(dmt, &info) && info.exists;
_exit_dm(dmt);
return ret;
}
int dm_status_device(const char *name)
{
struct dm_task *dmt;
struct dm_info dmi;
uint64_t start, length;
char *target_type, *params;
void *next = NULL;
int r = -EINVAL;
if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
return -EINVAL;
if (!dm_task_set_name(dmt, name)) {
r = -EINVAL;
goto out;
}
if (!dm_task_run(dmt)) {
r = -EINVAL;
goto out;
}
if (!dm_task_get_info(dmt, &dmi)) {
r = -EINVAL;
goto out;
}
if (!dmi.exists) {
r = -ENODEV;
goto out;
}
next = dm_get_next_target(dmt, next, &start, &length,
&target_type, ¶ms);
if (!target_type || strcmp(target_type, DM_CRYPT_TARGET) != 0 ||
start != 0 || next)
r = -EINVAL;
else
r = (dmi.open_count > 0);
out:
if (dmt)
dm_task_destroy(dmt);
return r;
}
static int
virStorageBackendIsMultipath(const char *devname)
{
int ret = 0;
struct dm_task *dmt = NULL;
void *next = NULL;
uint64_t start, length;
char *target_type = NULL;
char *params = NULL;
dmt = dm_task_create(DM_DEVICE_TABLE);
if (dmt == NULL) {
ret = -1;
goto out;
}
if (dm_task_set_name(dmt, devname) == 0) {
ret = -1;
goto out;
}
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt)) {
ret = -1;
goto out;
}
dm_get_next_target(dmt, next, &start, &length, &target_type, ¶ms);
if (target_type == NULL) {
ret = -1;
goto out;
}
if (STREQ(target_type, "multipath")) {
ret = 1;
}
out:
if (dmt != NULL) {
dm_task_destroy(dmt);
}
return ret;
}
static int dm_device_remove_byname(const char *dev_name)
{
struct dm_task *dmt;
int ret = 0;
BL_LOG_INFO("%s: %s\n", __func__, dev_name);
dmt = dm_task_create(DM_DEVICE_REMOVE);
if (!dmt)
return 0;
ret = dm_task_set_name(dmt, dev_name) && dm_task_run(dmt);
dm_task_update_nodes();
dm_task_destroy(dmt);
return ret;
}
int dm_umount_aspect(char *path)
{
int e = -EIO;
struct dm_task *task;
if(!(task = dm_task_create(DM_DEVICE_REMOVE))) {
goto fail;
}
if(!dm_task_set_name(task, path)) {
goto fail;
}
if(!dm_task_run(task)) {
e = -errno;
goto fail;
}
e = 0;
fail:
dm_task_destroy(task);
return e;
}
int
dm_get_info (char * mapname, struct dm_info ** dmi)
{
int r = 1;
struct dm_task *dmt = NULL;
if (!mapname)
return 1;
if (!*dmi)
*dmi = alloc_dminfo();
if (!*dmi)
return 1;
if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
goto out;
if (!dm_task_set_name(dmt, mapname))
goto out;
dm_task_no_open_count(dmt);
if (!dm_task_run(dmt))
goto out;
if (!dm_task_get_info(dmt, *dmi))
goto out;
r = 0;
out:
if (r) {
memset(*dmi, 0, sizeof(struct dm_info));
FREE(*dmi);
*dmi = NULL;
}
if (dmt)
dm_task_destroy(dmt);
return r;
}
/*
* Create device via device mapper
* return 0 when creation failed
* return dev no for created device
*/
static uint64_t
dm_device_create_mapped(const char *dev_name, struct bl_dm_table *p)
{
struct dm_task *dmt;
struct dm_info dminfo;
int ret = 0;
dmt = dm_task_create(DM_DEVICE_CREATE);
if (!dmt) {
BL_LOG_ERR("Create dm_task for %s failed\n", dev_name);
return 0;
}
ret = dm_task_set_name(dmt, dev_name);
if (!ret)
goto err_out;
while (p) {
ret =
dm_task_add_target(dmt, p->offset, p->size, p->target_type,
p->params);
if (!ret)
goto err_out;
p = p->next;
}
ret = dm_task_run(dmt) && dm_task_get_info(dmt, &dminfo)
&& dminfo.exists;
if (!ret)
goto err_out;
dm_task_update_nodes();
err_out:
dm_task_destroy(dmt);
if (!ret) {
BL_LOG_ERR("Create device %s failed\n", dev_name);
return 0;
}
return MKDEV(dminfo.major, dminfo.minor);
}
/* Get uuid of a device */
static struct dm_task *_get_device_info(const struct dm_event_handler *dmevh)
{
struct dm_task *dmt;
struct dm_info info;
if (!(dmt = dm_task_create(DM_DEVICE_INFO))) {
log_error("_get_device_info: dm_task creation for info failed");
return NULL;
}
if (dmevh->uuid)
dm_task_set_uuid(dmt, dmevh->uuid);
else if (dmevh->dev_name)
dm_task_set_name(dmt, dmevh->dev_name);
else if (dmevh->major && dmevh->minor) {
dm_task_set_major(dmt, dmevh->major);
dm_task_set_minor(dmt, dmevh->minor);
}
/* FIXME Add name or uuid or devno to messages */
if (!dm_task_run(dmt)) {
log_error("_get_device_info: dm_task_run() failed");
goto failed;
}
if (!dm_task_get_info(dmt, &info)) {
log_error("_get_device_info: failed to get info for device");
goto failed;
}
if (!info.exists) {
log_error("_get_device_info: device not found");
goto failed;
}
return dmt;
failed:
dm_task_destroy(dmt);
return NULL;
}
