/*
* 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[4096];
+ 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 usend_msg;
- struct uevent_msg *msg;
+ struct udevd_ctrl_msg ctrl_msg;
ssize_t size;
struct msghdr smsg;
struct cmsghdr *cmsg;
struct iovec iov;
struct ucred *cred;
char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
- int envbuf_size;
int *intval;
- memset(&usend_msg, 0x00, sizeof(struct udevd_msg));
- iov.iov_base = &usend_msg;
- iov.iov_len = sizeof(struct udevd_msg);
+ memset(&ctrl_msg, 0x00, sizeof(struct udevd_ctrl_msg));
+ iov.iov_base = &ctrl_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(usend_msg.magic, UDEV_MAGIC, sizeof(UDEV_MAGIC)) != 0 ) {
- err("message magic '%s' doesn't match, ignore it", usend_msg.magic);
- return NULL;
+ 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;
}
- switch (usend_msg.type) {
- case UDEVD_UEVENT_UDEVSEND:
- info("udevd event message received");
- envbuf_size = size - offsetof(struct udevd_msg, envbuf);
- dbg("envbuf_size=%i", envbuf_size);
- msg = get_msg_from_envbuf(usend_msg.envbuf, envbuf_size);
- if (msg == NULL)
- return NULL;
- msg->type = usend_msg.type;
- return msg;
- case UDEVD_STOP_EXEC_QUEUE:
+ switch (ctrl_msg.type) {
+ 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 *) usend_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 *) usend_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);
memset(&snl, 0x00, sizeof(struct sockaddr_nl));
snl.nl_family = AF_NETLINK;
snl.nl_pid = getpid();
- snl.nl_groups = 0xffffffff;
+ snl.nl_groups = 1;
uevent_netlink_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
if (uevent_netlink_sock == -1) {
}
strlcpy(filename, udev_root, sizeof(filename));
strlcat(filename, "/" EVENT_SEQNUM, sizeof(filename));
+ create_path(filename);
fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
if (fd >= 0) {
write(fd, seqnum, len);
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)