int era_dm_list(int (*cb)(void *arg, const char *name), void *cbarg)
{
struct dm_task *dmt;
struct dm_names *names;
unsigned next = 0;
if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
return -1;
if (!dm_task_run(dmt))
goto out;
if (!(names = dm_task_get_names(dmt)))
goto out;
if (names->dev)
{
do {
names = (struct dm_names *)((char *)names + next);
if (cb(cbarg, names->name))
goto out;
next = names->next;
} while(next);
}
dm_task_destroy(dmt);
return 0;
out:
dm_task_destroy(dmt);
return -1;
}
static int _dm_check_versions(void)
{
struct dm_task *dmt;
struct dm_versions *target, *last_target;
if (_dm_crypt_checked)
return 1;
if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS)))
return 0;
if (!dm_task_run(dmt)) {
dm_task_destroy(dmt);
return 0;
}
target = dm_task_get_versions(dmt);
do {
last_target = target;
if (!strcmp(DM_CRYPT_TARGET, target->name)) {
_dm_set_crypt_compat((int)target->version[0],
(int)target->version[1],
(int)target->version[2]);
}
target = (void *) target + target->next;
} while (last_target != target);
dm_task_destroy(dmt);
return 1;
}
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;
}
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 _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;
}
int main(int argc, char** argv) {
/*
* Dump a devices table. First arg should be the device name.
*
*/
char* name;
if (argc < 2) {
printf("usage: dump_table <device name>\n");
return 1;
} else {
name = argv[1];
}
struct dm_task *dmt;
struct dm_info info;
struct dm_names *names;
uint64_t start, length;
char* params, * target_type;
void* next = NULL;
if (!(dmt = dm_task_create(DM_DEVICE_TABLE))) {
printf("could not create dm task\n");
return 1;
}
if (!_set_task_device(dmt, name, 0)) {
printf("device %s may not exist -?\n", name);
}
if (!dm_task_run(dmt)) {
printf("error running task\n");
dm_task_destroy(dmt);
return 1;
}
if (!dm_task_get_info(dmt, &info) || !info.exists) {
printf("could not get info for %s\n", name);
return 1;
}
/* not sure about this bit */
do {
next = dm_get_next_target(dmt, next, &start, &length, &target_type, ¶ms);
printf("%" PRIu64 " %" PRIu64 " %s %s\n", start, length, target_type, params);
} while(next);
dm_task_destroy(dmt);
return 0;
}
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_flush_maps (void)
{
int r = 0;
struct dm_task *dmt;
struct dm_names *names;
unsigned next = 0;
if (!(dmt = dm_task_create (DM_DEVICE_LIST)))
return 0;
dm_task_no_open_count(dmt);
if (!dm_task_run (dmt))
goto out;
if (!(names = dm_task_get_names (dmt)))
goto out;
if (!names->dev)
goto out;
do {
r |= dm_suspend_and_flush_map(names->name);
next = names->next;
names = (void *) names + next;
} while (next);
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
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;
}
/*
* 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 _info_run(const char *name, const char *dlid, struct dm_info *info,
uint32_t *read_ahead, int mknodes, int with_open_count,
int with_read_ahead, uint32_t major, uint32_t minor)
{
int r = 0;
struct dm_task *dmt;
int dmtask;
dmtask = mknodes ? DM_DEVICE_MKNODES : DM_DEVICE_INFO;
if (!(dmt = _setup_task(mknodes ? name : NULL, dlid, 0, dmtask, major, minor)))
return_0;
if (!with_open_count)
if (!dm_task_no_open_count(dmt))
log_error("Failed to disable open_count");
if (!dm_task_run(dmt))
goto_out;
if (!dm_task_get_info(dmt, info))
goto_out;
if (with_read_ahead && info->exists) {
if (!dm_task_get_read_ahead(dmt, read_ahead))
goto_out;
} else if (read_ahead)
*read_ahead = DM_READ_AHEAD_NONE;
r = 1;
out:
dm_task_destroy(dmt);
return r;
}
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;
}
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;
}
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 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
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;
}
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;
}
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;
}
int dm_event_unregister_handler(const struct dm_event_handler *dmevh)
{
int ret = 1, err;
const char *uuid;
struct dm_task *dmt;
struct dm_event_daemon_message msg = { 0, 0, NULL };
if (!(dmt = _get_device_info(dmevh))) {
stack;
return 0;
}
uuid = dm_task_get_uuid(dmt);
if ((err = _do_event(DM_EVENT_CMD_UNREGISTER_FOR_EVENT, dmevh->dmeventd_path, &msg,
dmevh->dso, uuid, dmevh->mask, dmevh->timeout)) < 0) {
log_error("%s: event deregistration failed: %s",
dm_task_get_name(dmt),
msg.data ? msg.data : strerror(-err));
ret = 0;
}
dm_free(msg.data);
dm_task_destroy(dmt);
return ret;
}
static int _lookup_dev_name(uint64_t dev, char *buf, size_t len)
{
struct dm_names *names;
unsigned next = 0;
struct dm_task *dmt;
int r = 0;
if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
return 0;
if (!dm_task_run(dmt))
goto out;
if (!(names = dm_task_get_names(dmt)))
goto out;
if (!names->dev)
goto out;
do {
names = (void *) names + next;
if (names->dev == dev) {
strncpy(buf, names->name, len);
r = 1;
break;
}
next = names->next;
} while (next);
out:
dm_task_destroy(dmt);
return r;
}
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;
}
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;
}
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;
}
void free_waiter (void *data)
{
sigset_t old;
struct event_thread *wp = (struct event_thread *)data;
/*
* indicate in mpp that the wp is already freed storage
*/
block_signal(SIGHUP, &old);
lock(wp->vecs->lock);
if (wp->mpp)
/*
* be careful, mpp may already be freed -- null if so
*/
wp->mpp->waiter = NULL;
else
/*
* This is OK condition during shutdown.
*/
condlog(3, "free_waiter, mpp freed before wp=%p (%s).", wp, wp->mapname);
unlock(wp->vecs->lock);
pthread_sigmask(SIG_SETMASK, &old, NULL);
if (wp->dmt)
dm_task_destroy(wp->dmt);
FREE(wp);
}
char *
dm_mapname(int major, int minor)
{
char * response = NULL;
const char *map;
struct dm_task *dmt;
int r;
int loop = MAX_WAIT * LOOPS_PER_SEC;
if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
return NULL;
if (!dm_task_set_major(dmt, major) ||
!dm_task_set_minor(dmt, minor))
goto bad;
dm_task_no_open_count(dmt);
/*
* device map might not be ready when we get here from
* daemon uev_trigger -> uev_add_map
*/
while (--loop) {
r = dm_task_run(dmt);
if (r)
break;
usleep(1000 * 1000 / LOOPS_PER_SEC);
}
if (!r) {
condlog(0, "%i:%i: timeout fetching map name", major, minor);
goto bad;
}
map = dm_task_get_name(dmt);
if (map && strlen(map))
response = STRDUP((char *)dm_task_get_name(dmt));
dm_task_destroy(dmt);
return response;
bad:
dm_task_destroy(dmt);
condlog(0, "%i:%i: error fetching map name", major, minor);
return NULL;
}
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 void _free_thread_status(struct thread_status *thread)
{
if (thread->current_task)
dm_task_destroy(thread->current_task);
dm_free(thread->device.uuid);
dm_free(thread->device.name);
dm_free(thread);
}
/* Cleanup at exit. */
static void
_exit_dm(struct dm_task *dmt)
{
if (dmt)
dm_task_destroy(dmt);
dm_lib_release();
dm_lib_exit();
}
