/*
* udevd.c - event listener and serializer
*
- * Copyright (C) 2004-2005 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2004-2006 Kay Sievers <kay.sievers@vrfy.org>
* Copyright (C) 2004 Chris Friesen <chris_friesen@sympatico.ca>
*
*
exit(1);
}
-static int udev_event_process(struct uevent_msg *msg)
+static int udev_event_process(struct udevd_uevent_msg *msg)
{
struct sigaction act;
struct udevice *udev;
EVENT_FAILED,
};
-static void export_event_state(struct uevent_msg *msg, enum event_state state)
+static void export_event_state(struct udevd_uevent_msg *msg, enum event_state state)
{
char filename[PATH_SIZE];
char filename_failed[PATH_SIZE];
char target[PATH_SIZE];
size_t start, end, i;
- struct uevent_msg *loop_msg;
+ struct udevd_uevent_msg *loop_msg;
/* add location of queue files */
strlcpy(filename, udev_root, sizeof(filename));
}
}
-static void msg_queue_delete(struct uevent_msg *msg)
+static void msg_queue_delete(struct udevd_uevent_msg *msg)
{
list_del(&msg->node);
free(msg);
}
-static void udev_event_run(struct uevent_msg *msg)
+static void udev_event_run(struct udevd_uevent_msg *msg)
{
pid_t pid;
int retval;
logging_init("udevd-event");
setpriority(PRIO_PROCESS, 0, UDEV_PRIORITY);
+
retval = udev_event_process(msg);
info("seq %llu finished", msg->seqnum);
}
}
-static void msg_queue_insert(struct uevent_msg *msg)
+static void msg_queue_insert(struct udevd_uevent_msg *msg)
{
char filename[PATH_SIZE];
int fd;
static int running_processes(void)
{
int f;
- static char buf[32768];
+ char buf[32768];
int len;
int running;
const char *pos;
}
/* returns still running task for the same device, its parent or its physical device */
-static int running_with_devpath(struct uevent_msg *msg, int limit)
+static int running_with_devpath(struct udevd_uevent_msg *msg, int limit)
{
- struct uevent_msg *loop_msg;
+ struct udevd_uevent_msg *loop_msg;
int childs_count = 0;
list_for_each_entry(loop_msg, &running_list, node) {
/* exec queue management routine executes the events and serializes events in the same sequence */
static void msg_queue_manager(void)
{
- struct uevent_msg *loop_msg;
- struct uevent_msg *tmp_msg;
+ struct udevd_uevent_msg *loop_msg;
+ struct udevd_uevent_msg *tmp_msg;
int running;
if (list_empty(&exec_list))
}
}
-static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
+static struct udevd_uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
{
int bufpos;
int i;
- struct uevent_msg *msg;
+ struct udevd_uevent_msg *msg;
int major = 0;
int minor = 0;
- msg = malloc(sizeof(struct uevent_msg) + buf_size);
+ msg = malloc(sizeof(struct udevd_uevent_msg) + buf_size);
if (msg == NULL)
return NULL;
- memset(msg, 0x00, sizeof(struct uevent_msg) + buf_size);
+ memset(msg, 0x00, sizeof(struct udevd_uevent_msg) + buf_size);
/* copy environment buffer and reconstruct envp */
memcpy(msg->envbuf, buf, buf_size);
}
/* receive the udevd message from userspace */
-static struct uevent_msg *get_udevd_msg(void)
+static void get_ctrl_msg(void)
{
- static struct udevd_msg ctrl_msg;
+ struct udevd_ctrl_msg ctrl_msg;
ssize_t size;
struct msghdr smsg;
struct cmsghdr *cmsg;
char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
int *intval;
- memset(&ctrl_msg, 0x00, sizeof(struct udevd_msg));
+ memset(&ctrl_msg, 0x00, sizeof(struct udevd_ctrl_msg));
iov.iov_base = &ctrl_msg;
- iov.iov_len = sizeof(struct udevd_msg);
+ iov.iov_len = sizeof(struct udevd_ctrl_msg);
memset(&smsg, 0x00, sizeof(struct msghdr));
smsg.msg_iov = &iov;
if (size < 0) {
if (errno != EINTR)
err("unable to receive user udevd message: %s", strerror(errno));
- return NULL;
+ return;
}
cmsg = CMSG_FIRSTHDR(&smsg);
cred = (struct ucred *) CMSG_DATA(cmsg);
if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {
err("no sender credentials received, message ignored");
- return NULL;
+ return;
}
if (cred->uid != 0) {
err("sender uid=%i, message ignored", cred->uid);
- return NULL;
+ return;
}
- if (strncmp(ctrl_msg.magic, UDEV_MAGIC, sizeof(UDEV_MAGIC)) != 0 ) {
+ if (strncmp(ctrl_msg.magic, UDEVD_CTRL_MAGIC, sizeof(UDEVD_CTRL_MAGIC)) != 0 ) {
err("message magic '%s' doesn't match, ignore it", ctrl_msg.magic);
- return NULL;
+ return;
}
switch (ctrl_msg.type) {
- case UDEVD_STOP_EXEC_QUEUE:
+ case UDEVD_CTRL_STOP_EXEC_QUEUE:
info("udevd message (STOP_EXEC_QUEUE) received");
stop_exec_q = 1;
break;
- case UDEVD_START_EXEC_QUEUE:
+ case UDEVD_CTRL_START_EXEC_QUEUE:
info("udevd message (START_EXEC_QUEUE) received");
stop_exec_q = 0;
msg_queue_manager();
break;
- case UDEVD_SET_LOG_LEVEL:
- intval = (int *) ctrl_msg.envbuf;
+ case UDEVD_CTRL_SET_LOG_LEVEL:
+ intval = (int *) ctrl_msg.buf;
info("udevd message (SET_LOG_PRIORITY) received, udev_log_priority=%i", *intval);
udev_log_priority = *intval;
sprintf(udev_log, "UDEV_LOG=%i", udev_log_priority);
putenv(udev_log);
break;
- case UDEVD_SET_MAX_CHILDS:
- intval = (int *) ctrl_msg.envbuf;
+ case UDEVD_CTRL_SET_MAX_CHILDS:
+ intval = (int *) ctrl_msg.buf;
info("udevd message (UDEVD_SET_MAX_CHILDS) received, max_childs=%i", *intval);
max_childs = *intval;
break;
- case UDEVD_RELOAD_RULES:
+ case UDEVD_CTRL_RELOAD_RULES:
info("udevd message (RELOAD_RULES) received");
reload_config = 1;
break;
default:
dbg("unknown message type");
}
- return NULL;
}
/* receive the kernel user event message and do some sanity checks */
-static struct uevent_msg *get_netlink_msg(void)
+static struct udevd_uevent_msg *get_netlink_msg(void)
{
- struct uevent_msg *msg;
+ struct udevd_uevent_msg *msg;
int bufpos;
ssize_t size;
static char buffer[UEVENT_BUFFER_SIZE+512];
msg = get_msg_from_envbuf(&buffer[bufpos], size-bufpos);
if (msg == NULL)
return NULL;
- msg->type = UDEVD_UEVENT_NETLINK;
/* validate message */
pos = strchr(buffer, '@');
static void udev_done(int pid, int exitstatus)
{
/* find msg associated with pid and delete it */
- struct uevent_msg *msg;
+ struct udevd_uevent_msg *msg;
list_for_each_entry(msg, &running_list, node) {
if (msg->pid == pid) {
memset(&saddr, 0x00, sizeof(saddr));
saddr.sun_family = AF_LOCAL;
/* use abstract namespace for socket path */
- strcpy(&saddr.sun_path[1], UDEVD_SOCK_PATH);
+ strcpy(&saddr.sun_path[1], UDEVD_CTRL_SOCK_PATH);
addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path+1) + 1;
udevd_sock = socket(AF_LOCAL, SOCK_DGRAM, 0);
maxfd = UDEV_MAX(maxfd, inotify_fd);
while (!udev_exit) {
- struct uevent_msg *msg;
+ struct udevd_uevent_msg *msg;
int fdcount;
FD_ZERO(&readfds);
continue;
}
- /* get user socket message */
- if (FD_ISSET(udevd_sock, &readfds)) {
- msg = get_udevd_msg();
- if (msg)
- msg_queue_insert(msg);
- }
+ /* get control message */
+ if (FD_ISSET(udevd_sock, &readfds))
+ get_ctrl_msg();
- /* get kernel netlink message */
+ /* get netlink message */
if (FD_ISSET(uevent_netlink_sock, &readfds)) {
msg = get_netlink_msg();
if (msg)