[dm-devel] device-mapper ./WHATS_NEW dmeventd/.exported_s ...
agk at sourceware.org
agk at sourceware.org
Mon Jan 15 18:21:02 UTC 2007
CVSROOT: /cvs/dm
Module name: device-mapper
Changes by: agk at sourceware.org 2007-01-15 18:21:02
Modified files:
. : WHATS_NEW
dmeventd : .exported_symbols dmeventd.c
libdevmapper-event.c libdevmapper-event.h
lib : .exported_symbols libdevmapper.h libdm-string.c
Log message:
More libdevmapper-event interface changes and fixes.
Rename dm_saprintf() to dm_asprintf().
Patches:
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/WHATS_NEW.diff?cvsroot=dm&r1=1.146&r2=1.147
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/dmeventd/.exported_symbols.diff?cvsroot=dm&r1=1.6&r2=1.7
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/dmeventd/dmeventd.c.diff?cvsroot=dm&r1=1.28&r2=1.29
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/dmeventd/libdevmapper-event.c.diff?cvsroot=dm&r1=1.12&r2=1.13
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/dmeventd/libdevmapper-event.h.diff?cvsroot=dm&r1=1.6&r2=1.7
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/lib/.exported_symbols.diff?cvsroot=dm&r1=1.26&r2=1.27
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/lib/libdevmapper.h.diff?cvsroot=dm&r1=1.62&r2=1.63
http://sourceware.org/cgi-bin/cvsweb.cgi/device-mapper/lib/libdm-string.c.diff?cvsroot=dm&r1=1.5&r2=1.6
--- device-mapper/WHATS_NEW 2007/01/15 14:39:11 1.146
+++ device-mapper/WHATS_NEW 2007/01/15 18:21:01 1.147
@@ -1,5 +1,7 @@
Version 1.02.15 -
===================================
+ More libdevmapper-event interface changes and fixes.
+ Rename dm_saprintf() to dm_asprintf().
Report error if NULL pointer is supplied to dm_strdup_aux().
Reinstate dm_event_get_registered_device.
--- device-mapper/dmeventd/.exported_symbols 2007/01/12 20:22:11 1.6
+++ device-mapper/dmeventd/.exported_symbols 2007/01/15 18:21:01 1.7
@@ -1,17 +1,17 @@
dm_event_handler_create
dm_event_handler_destroy
dm_event_handler_set_dso
-dm_event_handler_set_name
+dm_event_handler_set_devname
dm_event_handler_set_uuid
dm_event_handler_set_major
dm_event_handler_set_minor
-dm_event_handler_set_events
+dm_event_handler_set_event_mask
dm_event_handler_get_dso
-dm_event_handler_get_name
+dm_event_handler_get_devname
dm_event_handler_get_uuid
dm_event_handler_get_major
dm_event_handler_get_minor
-dm_event_handler_get_events
-dm_event_register
-dm_event_unregister
+dm_event_handler_get_event_mask
+dm_event_register_handler
+dm_event_unregister_handler
dm_event_get_registered_device
--- device-mapper/dmeventd/dmeventd.c 2007/01/11 21:54:52 1.28
+++ device-mapper/dmeventd/dmeventd.c 2007/01/15 18:21:01 1.29
@@ -96,7 +96,7 @@
* DM_DEVICE_STATUS). It should not destroy it.
* The caller must dispose of the task.
*/
- void (*process_event)(struct dm_task *dmt, enum dm_event_type event);
+ void (*process_event)(struct dm_task *dmt, enum dm_event_mask event);
/*
* Device registration.
@@ -127,7 +127,7 @@
char *device_uuid; /* Mapped device path. */
union {
char *str; /* Events string as fetched from message. */
- enum dm_event_type field; /* Events bitfield. */
+ enum dm_event_mask field; /* Events bitfield. */
} events;
union {
char *str;
@@ -157,8 +157,8 @@
uint32_t event_nr; /* event number */
int processing; /* Set when event is being processed */
int status; /* running/shutdown/done */
- enum dm_event_type events; /* bitfield for event filter. */
- enum dm_event_type current_events; /* bitfield for occured events. */
+ enum dm_event_mask events; /* bitfield for event filter. */
+ enum dm_event_mask current_events; /* bitfield for occured events. */
struct dm_task *current_task;
time_t next_time;
uint32_t timeout;
@@ -291,7 +291,7 @@
fetch_string(&message_data->events.str, &p) &&
fetch_string(&message_data->timeout.str, &p)) {
if (message_data->events.str) {
- enum dm_event_type i = atoi(message_data->events.str);
+ enum dm_event_mask i = atoi(message_data->events.str);
/*
* Free string representaion of events.
@@ -775,7 +775,7 @@
syslog(LOG_ERR, "dmeventd %s dlopen failed: %s", data->dso_name,
dlerr);
data->msg->size =
- dm_saprintf(&(data->msg->data), "%s dlopen failed: %s",
+ dm_asprintf(&(data->msg->data), "%s dlopen failed: %s",
data->dso_name, dlerr);
return NULL;
}
@@ -954,7 +954,7 @@
if (msg->data)
dm_free(msg->data);
- msg->size = dm_saprintf(&(msg->data), fmt, dso, dev, events);
+ msg->size = dm_asprintf(&(msg->data), fmt, dso, dev, events);
unlock_mutex();
@@ -1049,7 +1049,7 @@
lock_mutex();
if ((thread = lookup_thread_status(message_data))) {
msg->size =
- dm_saprintf(&(msg->data), "%" PRIu32, thread->timeout);
+ dm_asprintf(&(msg->data), "%" PRIu32, thread->timeout);
} else {
msg->data = NULL;
msg->size = 0;
--- device-mapper/dmeventd/libdevmapper-event.c 2007/01/12 20:22:11 1.12
+++ device-mapper/dmeventd/libdevmapper-event.c 2007/01/15 18:21:01 1.13
@@ -32,108 +32,114 @@
struct dm_event_handler {
const char *dso;
- const char *device;
+
+ const char *devname;
+
const char *uuid;
int major;
int minor;
- enum dm_event_type events;
+
+ enum dm_event_mask mask;
};
-static void dm_event_handler_clear_device(struct dm_event_handler *h)
+static void dm_event_handler_clear_devname(struct dm_event_handler *dmevh)
{
- h->device = h->uuid = NULL;
- h->major = h->minor = 0;
+ dmevh->devname = dmevh->uuid = NULL;
+ dmevh->major = dmevh->minor = 0;
}
struct dm_event_handler *dm_event_handler_create(void)
{
- struct dm_event_handler *ret = 0;
+ struct dm_event_handler *dmevh = NULL;
- if (!(ret = dm_malloc(sizeof(*ret))))
+ if (!(dmevh = dm_malloc(sizeof(*dmevh))))
return NULL;
- ret->dso = ret->device = ret->uuid = NULL;
- ret->major = ret->minor = 0;
- ret->events = 0;
+ dmevh->dso = dmevh->devname = dmevh->uuid = NULL;
+ dmevh->major = dmevh->minor = 0;
+ dmevh->mask = 0;
- return ret;
+ return dmevh;
}
-void dm_event_handler_destroy(struct dm_event_handler *h)
+void dm_event_handler_destroy(struct dm_event_handler *dmevh)
{
- dm_free(h);
+ dm_free(dmevh);
}
-void dm_event_handler_set_dso(struct dm_event_handler *h, const char *path)
+void dm_event_handler_set_dso(struct dm_event_handler *dmevh, const char *path)
{
- h->dso = path;
+ dmevh->dso = path;
}
-void dm_event_handler_set_name(struct dm_event_handler *h, const char *name)
+void dm_event_handler_set_devname(struct dm_event_handler *dmevh, const char *devname)
{
- dm_event_handler_clear_device(h);
- h->device = name;
+ dm_event_handler_clear_devname(dmevh);
+
+ dmevh->devname = devname;
}
-void dm_event_handler_set_uuid(struct dm_event_handler *h, const char *uuid)
+void dm_event_handler_set_uuid(struct dm_event_handler *dmevh, const char *uuid)
{
- dm_event_handler_clear_device(h);
- h->uuid = uuid;
+ dm_event_handler_clear_devname(dmevh);
+
+ dmevh->uuid = uuid;
}
-void dm_event_handler_set_major(struct dm_event_handler *h, int major)
+void dm_event_handler_set_major(struct dm_event_handler *dmevh, int major)
{
- int minor = h->minor;
+ int minor = dmevh->minor;
- dm_event_handler_clear_device(h);
- h->major = major;
- h->minor = minor;
+ dm_event_handler_clear_devname(dmevh);
+
+ dmevh->major = major;
+ dmevh->minor = minor;
}
-void dm_event_handler_set_minor(struct dm_event_handler *h, int minor)
+void dm_event_handler_set_minor(struct dm_event_handler *dmevh, int minor)
{
- int major = h->major;
+ int major = dmevh->major;
- dm_event_handler_clear_device(h);
+ dm_event_handler_clear_devname(dmevh);
- h->major = major;
- h->minor = minor;
+ dmevh->major = major;
+ dmevh->minor = minor;
}
-void dm_event_handler_set_events(struct dm_event_handler *h,
- enum dm_event_type event)
+void dm_event_handler_set_event_mask(struct dm_event_handler *dmevh,
+ enum dm_event_mask evmask)
{
- h->events = event;
+ dmevh->mask = evmask;
}
-const char *dm_event_handler_get_dso(const struct dm_event_handler *h)
+const char *dm_event_handler_get_dso(const struct dm_event_handler *dmevh)
{
- return h->dso;
+ return dmevh->dso;
}
-const char *dm_event_handler_get_name(const struct dm_event_handler *h)
+const char *dm_event_handler_get_devname(const struct dm_event_handler *dmevh)
{
- return h->device;
+ return dmevh->devname;
}
-const char *dm_event_handler_get_uuid(const struct dm_event_handler *h)
+const char *dm_event_handler_get_uuid(const struct dm_event_handler *dmevh)
{
- return h->uuid;
+ return dmevh->uuid;
}
-int dm_event_handler_get_major(const struct dm_event_handler *h)
+int dm_event_handler_get_major(const struct dm_event_handler *dmevh)
{
- return h->major;
+ return dmevh->major;
}
-int dm_event_handler_get_minor(const struct dm_event_handler *h)
+int dm_event_handler_get_minor(const struct dm_event_handler *dmevh)
{
- return h->minor;
+ return dmevh->minor;
}
-enum dm_event_type dm_event_handler_get_events(const struct dm_event_handler *h)
+enum dm_event_mask dm_event_handler_get_event_mask(const struct dm_event_handler *dmevh)
{
- return h->events;
+ return dmevh->mask;
}
/*
@@ -145,8 +151,8 @@
*
* Returns: 0 on failure, 1 on success
*/
-static int daemon_read(struct dm_event_fifos *fifos,
- struct dm_event_daemon_message *msg)
+static int _daemon_read(struct dm_event_fifos *fifos,
+ struct dm_event_daemon_message *msg)
{
unsigned bytes = 0;
int ret, i;
@@ -205,8 +211,8 @@
}
/* Write message to daemon. */
-static int daemon_write(struct dm_event_fifos *fifos,
- struct dm_event_daemon_message *msg)
+static int _daemon_write(struct dm_event_fifos *fifos,
+ struct dm_event_daemon_message *msg)
{
unsigned bytes = 0;
int ret = 0;
@@ -248,13 +254,13 @@
return bytes == size;
}
-static int daemon_talk(struct dm_event_fifos *fifos,
- struct dm_event_daemon_message *msg, int cmd,
- const char *dso_name, const char *device,
- enum dm_event_type events, uint32_t timeout)
+static int _daemon_talk(struct dm_event_fifos *fifos,
+ struct dm_event_daemon_message *msg, int cmd,
+ const char *dso_name, const char *devname,
+ enum dm_event_mask evmask, uint32_t timeout)
{
const char *dso = dso_name ? dso_name : "";
- const char *dev = device ? device : "";
+ const char *dev = devname ? devname : "";
const char *fmt = "%s %s %u %" PRIu32;
memset(msg, 0, sizeof(*msg));
@@ -263,18 +269,21 @@
* into ASCII message string.
*/
msg->cmd = cmd;
- msg->size = dm_saprintf(&(msg->data), fmt, dso, dev, events, timeout);
+ if ((msg->size = dm_asprintf(&(msg->data), fmt, dso, dev, evmask,
+ timeout)) < 0) {
+ log_error("_daemon_talk: message allocation failed");
+ }
/*
* Write command and message to and
* read status return code from daemon.
*/
- if (!daemon_write(fifos, msg)) {
+ if (!_daemon_write(fifos, msg)) {
stack;
return -EIO;
}
- if (!daemon_read(fifos, msg)) {
+ if (!_daemon_read(fifos, msg)) {
stack;
return -EIO;
}
@@ -294,7 +303,7 @@
*
* Returns: 1 on success, 0 otherwise
*/
-static int start_daemon(struct dm_event_fifos *fifos)
+static int _start_daemon(struct dm_event_fifos *fifos)
{
int pid, ret = 0;
int status;
@@ -349,7 +358,7 @@
}
/* Initialize client. */
-static int init_client(struct dm_event_fifos *fifos)
+static int _init_client(struct dm_event_fifos *fifos)
{
/* FIXME? Is fifo the most suitable method? Why not share
comms/daemon code with something else e.g. multipath? */
@@ -359,7 +368,7 @@
fifos->client_path = DM_EVENT_FIFO_CLIENT;
fifos->server_path = DM_EVENT_FIFO_SERVER;
- if (!start_daemon(fifos)) {
+ if (!_start_daemon(fifos)) {
stack;
return 0;
}
@@ -391,7 +400,7 @@
return 1;
}
-static void dtr_client(struct dm_event_fifos *fifos)
+static void _dtr_client(struct dm_event_fifos *fifos)
{
if (flock(fifos->server, LOCK_UN))
log_error("flock unlock %s", fifos->server_path);
@@ -400,76 +409,91 @@
close(fifos->server);
}
-/* Get uuid of a device, if it exists (otherwise NULL). */
-static struct dm_task *get_device_info(const struct dm_event_handler *h)
+/* Get uuid of a device */
+static struct dm_task *_get_device_info(const struct dm_event_handler *dmevh)
{
- struct dm_task *dmt = dm_task_create(DM_DEVICE_INFO);
- struct dm_task *ret;
+ struct dm_task *dmt;
+ struct dm_info info;
- if (!dmt)
+ if (!(dmt = dm_task_create(DM_DEVICE_INFO))) {
+ log_error("_get_device_info: dm_task creation for info failed");
return NULL;
+ }
- if (h->uuid)
- dm_task_set_uuid(dmt, h->uuid);
- else if (h->device)
- dm_task_set_name(dmt, h->device);
- else if (h->major && h->minor) {
- dm_task_set_major(dmt, h->major);
- dm_task_set_minor(dmt, h->minor);
+ if (dmevh->uuid)
+ dm_task_set_uuid(dmt, dmevh->uuid);
+ else if (dmevh->devname)
+ dm_task_set_name(dmt, dmevh->devname);
+ 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_run(dmt))
- ret = NULL;
- else
- ret = dmt;
+ if (!dm_task_get_info(dmt, &info))
+ log_error("_get_device_info: failed to get info for device");
+ goto failed;
+ }
- return ret;
+ if (!info.exists) {
+ log_error("_get_device_info: device not found");
+ goto failed;
+ }
+
+ return dmt;
+
+failed:
+ dm_task_destroy(dmt);
+ return NULL;
}
/* Handle the event (de)registration call and return negative error codes. */
-static int do_event(int cmd, struct dm_event_daemon_message *msg,
- const char *dso_name, const char *device,
- enum dm_event_type events, uint32_t timeout)
+static int _do_event(int cmd, struct dm_event_daemon_message *msg,
+ const char *dso_name, const char *devname,
+ enum dm_event_mask evmask, uint32_t timeout)
{
int ret;
struct dm_event_fifos fifos;
- if (!init_client(&fifos)) {
+ if (!_init_client(&fifos)) {
stack;
return -ESRCH;
}
- ret = daemon_talk(&fifos, msg, cmd, dso_name, device, events, timeout);
+ ret = _daemon_talk(&fifos, msg, cmd, dso_name, devname, evmask, timeout);
/* what is the opposite of init? */
- dtr_client(&fifos);
+ _dtr_client(&fifos);
return ret;
}
/* External library interface. */
-int dm_event_register(const struct dm_event_handler *h)
+int dm_event_register_handler(const struct dm_event_handler *dmevh)
{
- int ret, err;
+ int ret = 1, err;
const char *uuid;
struct dm_task *dmt;
struct dm_event_daemon_message msg;
- if (!(dmt = get_device_info(h))) {
- log_error("%s: device not found", h->device);
+ if (!(dmt = _get_device_info(dmevh))) {
+ stack;
return 0;
}
uuid = dm_task_get_uuid(dmt);
- if ((err = do_event(DM_EVENT_CMD_REGISTER_FOR_EVENT, &msg,
- h->dso, uuid, h->events, 0)) < 0) {
+ if ((err = _do_event(DM_EVENT_CMD_REGISTER_FOR_EVENT, &msg,
+ dmevh->dso, uuid, dmevh->mask, 0)) < 0) {
log_error("%s: event registration failed: %s",
dm_task_get_name(dmt),
msg.data ? msg.data : strerror(-err));
ret = 0;
- } else
- ret = 1;
+ }
if (msg.data)
dm_free(msg.data);
@@ -479,28 +503,27 @@
return ret;
}
-int dm_event_unregister(const struct dm_event_handler *h)
+int dm_event_unregister_handler(const struct dm_event_handler *dmevh)
{
- int ret, err;
+ int ret = 1, err;
const char *uuid;
struct dm_task *dmt;
struct dm_event_daemon_message msg;
- if (!(dmt = get_device_info(h))) {
- log_error("%s: device not found", dm_task_get_name(dmt));
+ 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, &msg,
- h->dso, uuid, h->events, 0)) < 0) {
+ if ((err = _do_event(DM_EVENT_CMD_UNREGISTER_FOR_EVENT, &msg,
+ dmevh->dso, uuid, dmevh->mask, 0)) < 0) {
log_error("%s: event deregistration failed: %s",
dm_task_get_name(dmt),
msg.data ? msg.data : strerror(-err));
ret = 0;
- } else
- ret = 1;
+ }
if (msg.data)
dm_free(msg.data);
@@ -511,9 +534,8 @@
}
/* Fetch a string off src and duplicate it into *dest. */
-/* FIXME: move to seperate module to share with the daemon. */
-static const char delimiter = ' ';
-static char *fetch_string(char **src)
+/* FIXME: move to separate module to share with the daemon. */
+static char *_fetch_string(char **src, const char delimiter)
{
char *p, *ret;
@@ -530,13 +552,14 @@
}
/* Parse a device message from the daemon. */
-static int parse_message(struct dm_event_daemon_message *msg, char **dso_name,
- char **device, enum dm_event_type *events)
+static int _parse_message(struct dm_event_daemon_message *msg, char **dso_name,
+ char **devname, enum dm_event_mask *evmask)
{
char *p = msg->data;
- if ((*dso_name = fetch_string(&p)) && (*device = fetch_string(&p))) {
- *events = atoi(p);
+ if ((*dso_name = _fetch_string(&p, ' ')) &&
+ (*devname = _fetch_string(&p, ' '))) {
+ *evmask = atoi(p);
return 0;
}
@@ -548,7 +571,7 @@
* dm_event_get_registered_device
* @dso_name
* @device_path
- * @events
+ * @mask
* @next
*
* FIXME: This function sucks.
@@ -556,17 +579,17 @@
* Returns: 1 if device found, 0 otherwise (even on error)
*/
int dm_event_get_registered_device(char **dso_name, char **device_path,
- enum dm_event_type *events, int next)
+ enum dm_event_mask *mask, int next)
{
int ret;
char *dso_name_arg = NULL, *device_path_arg = NULL;
struct dm_event_daemon_message msg;
- if (!(ret = do_event(next ? DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE :
+ if (!(ret = _do_event(next ? DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE :
DM_EVENT_CMD_GET_REGISTERED_DEVICE,
- &msg, *dso_name, *device_path, *events, 0))) {
- ret = !parse_message(&msg, &dso_name_arg, &device_path_arg,
- events);
+ &msg, *dso_name, *device_path, *mask, 0))) {
+ ret = !_parse_message(&msg, &dso_name_arg, &device_path_arg,
+ mask);
} else /* FIXME: Make sure this is ENOENT */
ret = 0;
@@ -598,7 +621,7 @@
if (!device_exists(device_path))
return -ENODEV;
- return do_event(DM_EVENT_CMD_SET_TIMEOUT, &msg,
+ return _do_event(DM_EVENT_CMD_SET_TIMEOUT, &msg,
NULL, device_path, 0, timeout);
}
@@ -609,7 +632,7 @@
if (!device_exists(device_path))
return -ENODEV;
- if (!(ret = do_event(DM_EVENT_CMD_GET_TIMEOUT, &msg, NULL, device_path,
+ if (!(ret = _do_event(DM_EVENT_CMD_GET_TIMEOUT, &msg, NULL, device_path,
0, 0)))
*timeout = atoi(msg.data);
if (msg.data)
--- device-mapper/dmeventd/libdevmapper-event.h 2007/01/12 20:22:11 1.6
+++ device-mapper/dmeventd/libdevmapper-event.h 2007/01/15 18:21:01 1.7
@@ -23,8 +23,11 @@
#include <stdint.h>
-/* Event type definitions. */
-enum dm_event_type {
+/*
+ * Event library interface.
+ */
+
+enum dm_event_mask {
DM_EVENT_SETTINGS_MASK = 0x0000FF,
DM_EVENT_SINGLE = 0x000001, /* Report multiple errors just once. */
DM_EVENT_MULTI = 0x000002, /* Report all of them. */
@@ -33,7 +36,7 @@
DM_EVENT_SECTOR_ERROR = 0x000100, /* Failure on a particular sector. */
DM_EVENT_DEVICE_ERROR = 0x000200, /* Device failure. */
DM_EVENT_PATH_ERROR = 0x000400, /* Failure on an io path. */
- DM_EVENT_ADAPTOR_ERROR = 0x000800, /* Failure off a host adaptor. */
+ DM_EVENT_ADAPTOR_ERROR = 0x000800, /* Failure of a host adaptor. */
DM_EVENT_STATUS_MASK = 0xFF0000,
DM_EVENT_SYNC_STATUS = 0x010000, /* Mirror synchronization completed/failed. */
@@ -44,54 +47,55 @@
#define DM_EVENT_ALL_ERRORS DM_EVENT_ERROR_MASK
-/* Prototypes for event lib interface. */
-
struct dm_event_handler;
-/* Create and destroy dm_event_handler struct, which is passed to
- register/unregister functions below */
struct dm_event_handler *dm_event_handler_create(void);
-void dm_event_handler_destroy(struct dm_event_handler *h);
+void dm_event_handler_destroy(struct dm_event_handler *dmevh);
-/* Set parameters of a handler:
- - dso - shared library path to handle the events
- (only one of the following three needs to be set)
- - name - device name or path
- - uuid - device uuid
- - major and minor - device major/minor numbers
- - events - a bitfield defining which events to handle (see
- enum dm_event_type above)
-*/
-void dm_event_handler_set_dso(struct dm_event_handler *h, const char *path);
-void dm_event_handler_set_name(struct dm_event_handler *h, const char *name);
-void dm_event_handler_set_uuid(struct dm_event_handler *h, const char *uuid);
-void dm_event_handler_set_major(struct dm_event_handler *h, int major);
-void dm_event_handler_set_minor(struct dm_event_handler *h, int minor);
-void dm_event_handler_set_events(struct dm_event_handler *h,
- enum dm_event_type event);
-
-/* Get parameters of a handler, same as above */
-const char *dm_event_handler_get_dso(const struct dm_event_handler *h);
-const char *dm_event_handler_get_name(const struct dm_event_handler *h);
-const char *dm_event_handler_get_uuid(const struct dm_event_handler *h);
-int dm_event_handler_get_major(const struct dm_event_handler *h);
-int dm_event_handler_get_minor(const struct dm_event_handler *h);
-enum dm_event_type dm_event_handler_get_events(const struct dm_event_handler *h);
+/*
+ * Path of shared library to handle events.
+ */
+void dm_event_handler_set_dso(struct dm_event_handler *dmevh, const char *path);
+
+/*
+ * Identify the device to monitor by exactly one of
+ * devname, uuid or device number.
+ */
+void dm_event_handler_set_devname(struct dm_event_handler *dmevh, const char *devname);
+
+void dm_event_handler_set_uuid(struct dm_event_handler *dmevh, const char *uuid);
+
+void dm_event_handler_set_major(struct dm_event_handler *dmevh, int major);
+void dm_event_handler_set_minor(struct dm_event_handler *dmevh, int minor);
+
+/*
+ * Specify mask for events to monitor.
+ */
+void dm_event_handler_set_event_mask(struct dm_event_handler *dmevh,
+ enum dm_event_mask evmask);
+
+const char *dm_event_handler_get_dso(const struct dm_event_handler *dmevh);
+const char *dm_event_handler_get_devname(const struct dm_event_handler *dmevh);
+const char *dm_event_handler_get_uuid(const struct dm_event_handler *dmevh);
+int dm_event_handler_get_major(const struct dm_event_handler *dmevh);
+int dm_event_handler_get_minor(const struct dm_event_handler *dmevh);
+enum dm_event_mask dm_event_handler_get_event_mask(const struct dm_event_handler *dmevh);
-/* FIXME */
+/* FIXME Review interface */
int dm_event_get_registered_device(char **dso_name, char **device_path,
- enum dm_event_type *events, int next);
+ enum dm_event_mask *evmask, int next);
-/* Call out to dmeventd to register or unregister a handler. If
- dmeventd is not running, it is spawned first. */
-int dm_event_register(const struct dm_event_handler *h);
-int dm_event_unregister(const struct dm_event_handler *h);
+/*
+ * Initiate monitoring using dmeventd.
+ */
+int dm_event_register_handler(const struct dm_event_handler *dmevh);
+int dm_event_unregister_handler(const struct dm_event_handler *dmevh);
/* Prototypes for DSO interface, see dmeventd.c, struct dso_data for
detailed descriptions. */
-void process_event(struct dm_task *dmt, enum dm_event_type event);
-int register_device(const char *device, const char *uuid, int major, int minor);
-int unregister_device(const char *device, const char *uuid, int major,
+void process_event(struct dm_task *dmt, enum dm_event_mask evmask);
+int register_device(const char *devname, const char *uuid, int major, int minor);
+int unregister_device(const char *devname, const char *uuid, int major,
int minor);
#endif
--- device-mapper/lib/.exported_symbols 2007/01/11 21:54:53 1.26
+++ device-mapper/lib/.exported_symbols 2007/01/15 18:21:01 1.27
@@ -115,4 +115,4 @@
dm_split_words
dm_snprintf
dm_basename
-dm_saprintf
+dm_asprintf
--- device-mapper/lib/libdevmapper.h 2007/01/11 21:54:53 1.62
+++ device-mapper/lib/libdevmapper.h 2007/01/15 18:21:01 1.63
@@ -626,7 +626,8 @@
/*
* Returns size of a buffer which is allocated with dm_malloc.
* Pointer to the buffer is stored in *buf.
+ * Returns -1 on failure leaving buf undefined.
*/
-int dm_saprintf(char **buf, const char *format, ...);
+int dm_asprintf(char **buf, const char *format, ...);
#endif /* LIB_DEVICE_MAPPER_H */
--- device-mapper/lib/libdm-string.c 2007/01/11 21:54:53 1.5
+++ device-mapper/lib/libdm-string.c 2007/01/15 18:21:01 1.6
@@ -129,7 +129,7 @@
return p ? p + 1 : (char *) path;
}
-int dm_saprintf(char **result, const char *format, ...)
+int dm_asprintf(char **result, const char *format, ...)
{
int n, ok = 0, size = 32;
va_list ap;
More information about the dm-devel
mailing list