shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2025-01-02 01:18:26 +03:00
Code Releases Activity

first changes to get comms back to work after flock changes

Browse Source
This commit is contained in:
Heinz Mauelshagen 2005-04-29 13:41:25 +00:00
parent b0e25eef22
commit 96c5c1f9ea
3 changed files with 133 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
daemons/dmeventd/dmevent.c
View File

@ -94,23 +94,43 @@ static int parse_argv(int argc, char **argv,
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int list = 0, ret, reg = default_reg; int list = 0, next = 0, ret, reg = default_reg;
char *device, *dso_name = default_dso_name; char *device, *device_arg, *dso_name = default_dso_name, *dso_name_arg;
if (!parse_argv(argc, argv, &dso_name, &device, &reg, &list)) if (!parse_argv(argc, argv, &dso_name_arg, &device_arg, &reg, &list))
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
if (dso_name_arg)
dso_name = dso_name_arg;
if (device_arg)
device = device_arg;
if (list) { if (list) {
do { do {
if (!(ret= dm_get_next_registered_device(&dso_name, /* FIXME: dso_name and/or device name given. */
&device, if (!(ret= dm_get_registered_device(&dso_name,
&events))) { &device,
&events, next))) {
printf("%s %s 0x%x\n", printf("%s %s 0x%x\n",
dso_name, device, events); dso_name, device, events);
free(dso_name);
free(device); if (!dso_name_arg) {
free(dso_name);
dso_name = NULL;
}
if (!device_arg) {
free(device);
device = NULL;
}
if (dso_name_arg && device_arg)
break;
next = 1;
} }
} while (ret); } while (!ret);
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
} }

128
daemons/dmeventd/dmeventd.c
View File

@ -22,7 +22,7 @@
#include "log.h" #include "log.h"
#include "libdm-event.h" #include "libdm-event.h"
#include "list.h" #include "list.h"
#include "libmultilog.h" // #include "libmultilog.h"
#include <dlfcn.h> #include <dlfcn.h>
#include <errno.h> #include <errno.h>
@ -279,7 +279,7 @@ static int storepid(int lf)
* Used to synchronize daemon startups. * Used to synchronize daemon startups.
*/ */
static int lf = -1; static int lf = -1;
static char *pidfile = "/var/run/dmeventd.pid"; static char pidfile[] = "/var/run/dmeventd.pid";
/* Store pid in pidfile. */ /* Store pid in pidfile. */
static int lock(void) static int lock(void)
@ -403,19 +403,19 @@ log_print("%s: %s\n", __func__, params);
} }
/* Register a device with the DSO. */ /* Register a device with the DSO. */
static int register_device(struct thread_status *thread) static int do_register_device(struct thread_status *thread)
{ {
return thread->dso_data->register_device(thread->device_path); return thread->dso_data->register_device(thread->device_path);
} }
/* Unregister a device with the DSO. */ /* Unregister a device with the DSO. */
static int unregister_device(struct thread_status *thread) static int do_unregister_device(struct thread_status *thread)
{ {
return thread->dso_data->unregister_device(thread->device_path); return thread->dso_data->unregister_device(thread->device_path);
} }
/* Process an event the DSO. */ /* Process an event the DSO. */
static void process_event(struct thread_status *thread) static void do_process_event(struct thread_status *thread)
{ {
thread->dso_data->process_event(thread->device_path, thread->dso_data->process_event(thread->device_path,
thread->current_events); thread->current_events);
@ -426,7 +426,7 @@ static void monitor_unregister(void *arg)
{ {
struct thread_status *thread = arg; struct thread_status *thread = arg;
if (!unregister_device(thread)) if (!do_unregister_device(thread))
log_err("%s: %s unregister failed\n", __func__, log_err("%s: %s unregister failed\n", __func__,
thread->device_path); thread->device_path);
} }
@ -464,7 +464,7 @@ log_print("%s: cycle on %s\n", __func__, thread->device_path);
if (thread->events & if (thread->events &
thread->current_events & thread->current_events &
~thread->processed_events) { ~thread->processed_events) {
process_event(thread); do_process_event(thread);
thread->processed_events |= thread->current_events; thread->processed_events |= thread->current_events;
} }
} }
@ -545,14 +545,16 @@ static int lookup_symbols(void *dl, struct dso_data *data)
static char *create_dso_file_name(char *dso_name) static char *create_dso_file_name(char *dso_name)
{ {
char *ret; char *ret;
static char *prefix = "libdmeventd_"; static char prefix[] = "libdmeventd";
static char *suffix = ".so"; static char suffix[] = ".so";
if ((ret = dbg_malloc(strlen(prefix) + if ((ret = dbg_malloc(strlen(prefix) +
strlen(dso_name) + strlen(dso_name) +
strlen(suffix) + 1))) strlen(suffix) + 1)))
sprintf(ret, "%s%s%s", prefix, dso_name, suffix); sprintf(ret, "%s%s%s", prefix, dso_name, suffix);
log_print("%s: \"%s\"\n", __func__, ret);
return ret; return ret;
} }
@ -563,6 +565,8 @@ static struct dso_data *load_dso(struct message_data *data)
struct dso_data *ret = NULL; struct dso_data *ret = NULL;
char *dso_file; char *dso_file;
log_print("%s: \"%s\"\n", __func__, data->dso_name);
if (!(dso_file = create_dso_file_name(data->dso_name))) if (!(dso_file = create_dso_file_name(data->dso_name)))
return NULL; return NULL;
@ -633,7 +637,7 @@ static int register_for_event(struct message_data *message_data)
goto out; goto out;
} }
if (!(ret = register_device(thread_new))) if (!(ret = do_register_device(thread_new)))
goto out; goto out;
lock_mutex(); lock_mutex();
@ -732,46 +736,69 @@ static int unregister_for_event(struct message_data *message_data)
* *
* Only one caller at a time here as with register_for_event(). * Only one caller at a time here as with register_for_event().
*/ */
static int next_registered_device(struct message_data *message_data) static int registered_device(struct message_data *message_data,
struct thread_status *thread)
{ {
struct daemon_message *msg = message_data->msg; struct daemon_message *msg = message_data->msg;
snprintf(msg->msg, sizeof(msg->msg), "%s %s %u", snprintf(msg->msg, sizeof(msg->msg), "%s %s %u",
message_data->dso_name, message_data->device_path, thread->dso_data->dso_name, thread->device_path,
message_data->events.field); thread->events);
unlock_mutex();
return 0; return 0;
} }
static struct list *device_iter = NULL; static int get_registered_device(struct message_data *message_data, int next)
static int get_next_registered_device(struct message_data *message_data)
{ {
struct thread_status *thread; int dev, dso, hit = 0;
struct thread_status *thread = list_item(thread_registry.n,
struct thread_status);
if (!device_iter) { lock_mutex();
if (list_empty(&thread_registry))
return -ENOENT;
device_iter = thread_registry.n; if (!message_data->dso_name &&
} else if (device_iter == &thread_registry) { !message_data->device_path)
device_iter = NULL; goto out;
list_iterate_items(thread, &thread_registry) {
dev = dso = 0;
/* If we've got a DSO name. */
if (message_data->dso_name &&
!strcmp(message_data->dso_name,
thread->dso_data->dso_name))
dso = 1;
if (message_data->device_path &&
!strcmp(message_data->device_path,
thread->device_path))
dev = 1;
/* We've got both DSO name and device patch. */
if ((dso && dev) || dso || dev) {
hit = 1;
break;
}
}
/*
* If we got a registered device and want the next one ->
* fetch next element off the list.
*/
if (hit && next)
thread = list_item(&thread->list.n, struct thread_status);
out:
if (list_empty(&thread->list) ||
list_end(&thread_registry, &thread->list)) {
unlock_mutex();
return -ENOENT; return -ENOENT;
} }
thread = list_item(device_iter, struct thread_status); return registered_device(message_data, thread);
device_iter = device_iter->n;
log_print("%s: device_path: %s\n", __func__, message_data->device_path);
if (message_data->device_path &&
!strcmp(thread->device_path, message_data->device_path))
return next_registered_device(message_data);
log_print("%s: dso_name: %s\n", __func__, message_data->dso_name);
if (message_data->dso_name &&
!strcmp(thread->dso_data->dso_name, message_data->dso_name))
return next_registered_device(message_data);
return next_registered_device(message_data);
} }
/* Initialize a fifos structure with path names. */ /* Initialize a fifos structure with path names. */
@ -830,15 +857,22 @@ static int client_read(struct fifos *fifos, struct daemon_message *msg)
*/ */
static int client_write(struct fifos *fifos, struct daemon_message *msg) static int client_write(struct fifos *fifos, struct daemon_message *msg)
{ {
int bytes = 0, ret = 0;
fd_set fds; fd_set fds;
do { errno = 0;
/* Watch client write FIFO if it's ready for output. */ while (bytes < sizeof(*msg) && errno != EIO) {
FD_ZERO(&fds); do {
FD_SET(fifos->server, &fds); /* Watch client write FIFO to be ready for output. */
} while (select(fifos->server + 1, NULL, &fds, NULL, NULL) <= 0); FD_ZERO(&fds);
FD_SET(fifos->server, &fds);
} while (select(fifos->server +1, NULL, &fds, NULL, NULL) != 1);
return write(fifos->server, msg, sizeof(*msg)) == sizeof(*msg); ret = write(fifos->server, msg, sizeof(*msg) - bytes);
bytes += ret > 0 ? ret : 0;
}
return bytes == sizeof(*msg);
} }
/* Process a request passed from the communication thread. */ /* Process a request passed from the communication thread. */
@ -847,6 +881,7 @@ static int do_process_request(struct daemon_message *msg)
int ret; int ret;
static struct message_data message_data; static struct message_data message_data;
log_print("%s: \"%s\"\n", __func__, msg->msg);
/* Parse the message. */ /* Parse the message. */
message_data.msg = msg; message_data.msg = msg;
if (msg->opcode.cmd != CMD_ACTIVE && if (msg->opcode.cmd != CMD_ACTIVE &&
@ -855,6 +890,8 @@ static int do_process_request(struct daemon_message *msg)
return -EINVAL; return -EINVAL;
} }
log_print("%s: \"%s\"\n", __func__, message_data.msg->msg);
/* Check the request type. */ /* Check the request type. */
switch (msg->opcode.cmd) { switch (msg->opcode.cmd) {
case CMD_ACTIVE: case CMD_ACTIVE:
@ -866,8 +903,11 @@ static int do_process_request(struct daemon_message *msg)
case CMD_UNREGISTER_FOR_EVENT: case CMD_UNREGISTER_FOR_EVENT:
ret = unregister_for_event(&message_data); ret = unregister_for_event(&message_data);
break; break;
case CMD_GET_REGISTERED_DEVICE:
ret = get_registered_device(&message_data, 0);
break;
case CMD_GET_NEXT_REGISTERED_DEVICE: case CMD_GET_NEXT_REGISTERED_DEVICE:
ret = get_next_registered_device(&message_data); ret = get_registered_device(&message_data, 1);
break; break;
} }
@ -969,12 +1009,14 @@ int main(void)
kill(getppid(), SIGHUP); kill(getppid(), SIGHUP);
/* Startup the syslog thread now so log_* macros work */ /* Startup the syslog thread now so log_* macros work */
/*
if(!start_syslog_thread(&log_thread, 100)) { if(!start_syslog_thread(&log_thread, 100)) {
fprintf(stderr, "Could not start logging thread\n"); fprintf(stderr, "Could not start logging thread\n");
munlockall(); munlockall();
pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex);
break; break;
} }
*/
init_fifos(&fifos); init_fifos(&fifos);
pthread_mutex_init(&mutex, NULL); pthread_mutex_init(&mutex, NULL);

23
libdm/libdm-event.h
View File

@ -19,6 +19,15 @@
#include <stdint.h> #include <stdint.h>
/* FIXME Replace with log.h */
#undef log_print
#undef log_err
#undef stack
#define log_print(x...) fprintf(stderr, "[dmeventdlib] " x)
#define log_err(x...) log_print(x)
#define stack log_print("trace: %s:%s(%d)\n", __FILE__, __func__, __LINE__);
#define DAEMON "/sbin/dmeventd" #define DAEMON "/sbin/dmeventd"
#define LOCKFILE "/var/lock/dmeventd" #define LOCKFILE "/var/lock/dmeventd"
#define FIFO_CLIENT "/var/run/dmeventd-client" #define FIFO_CLIENT "/var/run/dmeventd-client"
@ -30,6 +39,7 @@ enum dmeventd_command {
CMD_ACTIVE = 1, CMD_ACTIVE = 1,
CMD_REGISTER_FOR_EVENT, CMD_REGISTER_FOR_EVENT,
CMD_UNREGISTER_FOR_EVENT, CMD_UNREGISTER_FOR_EVENT,
CMD_GET_REGISTERED_DEVICE,
CMD_GET_NEXT_REGISTERED_DEVICE, CMD_GET_NEXT_REGISTERED_DEVICE,
}; };
@ -43,8 +53,7 @@ struct daemon_message {
} __attribute__((packed)); } __attribute__((packed));
/* Fifos for client/daemon communication. */ /* Fifos for client/daemon communication. */
struct fifos struct fifos {
{
int client; int client;
int server; int server;
char *client_path; char *client_path;
@ -63,11 +72,17 @@ enum event_type {
}; };
#define ALL_ERRORS (SECTOR_ERROR | DEVICE_ERROR | PATH_ERROR | ADAPTOR_ERROR) #define ALL_ERRORS (SECTOR_ERROR | DEVICE_ERROR | PATH_ERROR | ADAPTOR_ERROR)
/* Prototypes for event lib interface. */
int dm_register_for_event(char *dso_name, char *device, enum event_type events); int dm_register_for_event(char *dso_name, char *device, enum event_type events);
int dm_unregister_for_event(char *dso_name, char *device, int dm_unregister_for_event(char *dso_name, char *device,
enum event_type events); enum event_type events);
int dm_get_next_registered_device(char **dso_name, char **device, int dm_get_registered_device(char **dso_name, char **device,
enum event_type *events); enum event_type *events, int next);
/* Prototypes for DSO interface. */
void process_event(char *device, enum event_type event);
int register_device(char *device);
int unregister_device(char *device);
#endif #endif