rename udevcontrol message types and variables

diff --git a/udevcontrol.c b/udevcontrol.c
index 2d93f65ce8c33c4af6c8c8c42532b2e6a62826cc..3044d02f0b6a02e832277798c63305677e0a9427 100644 (file)
--- a/udevcontrol.c
+++ b/udevcontrol.c
@@ -63,7 +63,7 @@ static void usage(void)
 
 int main(int argc, char *argv[], char *envp[])
 {
 
 int main(int argc, char *argv[], char *envp[])
 {

-       static struct udevd_msg usend_msg;
+       static struct udevd_ctrl_msg ctrl_msg;

        struct sockaddr_un saddr;
        socklen_t addrlen;
        const char *env;
        struct sockaddr_un saddr;
        socklen_t addrlen;
        const char *env;


@@ -85,28 +85,28 @@ int main(int argc, char *argv[], char *envp[])
                goto exit;
        }
 
                goto exit;
        }
 

-       memset(&usend_msg, 0x00, sizeof(struct udevd_msg));
-       strcpy(usend_msg.magic, UDEV_MAGIC);
+       memset(&ctrl_msg, 0x00, sizeof(struct udevd_ctrl_msg));
+       strcpy(ctrl_msg.magic, UDEVD_CTRL_MAGIC);

 
        for (i = 1 ; i < argc; i++) {
                char *arg = argv[i];
 
                if (!strcmp(arg, "stop_exec_queue"))
 
        for (i = 1 ; i < argc; i++) {
                char *arg = argv[i];
 
                if (!strcmp(arg, "stop_exec_queue"))

-                       usend_msg.type = UDEVD_STOP_EXEC_QUEUE;
+                       ctrl_msg.type = UDEVD_CTRL_STOP_EXEC_QUEUE;

                else if (!strcmp(arg, "start_exec_queue"))
                else if (!strcmp(arg, "start_exec_queue"))

-                       usend_msg.type = UDEVD_START_EXEC_QUEUE;
+                       ctrl_msg.type = UDEVD_CTRL_START_EXEC_QUEUE;

                else if (!strcmp(arg, "reload_rules"))
                else if (!strcmp(arg, "reload_rules"))

-                       usend_msg.type = UDEVD_RELOAD_RULES;
+                       ctrl_msg.type = UDEVD_CTRL_RELOAD_RULES;

                else if (!strncmp(arg, "log_priority=", strlen("log_priority="))) {
                else if (!strncmp(arg, "log_priority=", strlen("log_priority="))) {

-                       intval = (int *) usend_msg.envbuf;
+                       intval = (int *) ctrl_msg.buf;

                        val = &arg[strlen("log_priority=")];
                        val = &arg[strlen("log_priority=")];

-                       usend_msg.type = UDEVD_SET_LOG_LEVEL;
+                       ctrl_msg.type = UDEVD_CTRL_SET_LOG_LEVEL;

                        *intval = log_priority(val);
                        info("send log_priority=%i", *intval);
                } else if (!strncmp(arg, "max_childs=", strlen("max_childs="))) {
                        *intval = log_priority(val);
                        info("send log_priority=%i", *intval);
                } else if (!strncmp(arg, "max_childs=", strlen("max_childs="))) {

-                       intval = (int *) usend_msg.envbuf;
+                       intval = (int *) ctrl_msg.buf;

                        val = &arg[strlen("max_childs=")];
                        val = &arg[strlen("max_childs=")];

-                       usend_msg.type = UDEVD_SET_MAX_CHILDS;
+                       ctrl_msg.type = UDEVD_CTRL_SET_MAX_CHILDS;

                        *intval = atoi(val);
                        info("send max_childs=%i", *intval);
                } else if (strcmp(arg, "help") == 0  || strcmp(arg, "--help") == 0  || strcmp(arg, "-h") == 0) {
                        *intval = atoi(val);
                        info("send max_childs=%i", *intval);
                } else if (strcmp(arg, "help") == 0  || strcmp(arg, "--help") == 0  || strcmp(arg, "-h") == 0) {


@@ -133,15 +133,15 @@ int main(int argc, char *argv[], char *envp[])
        memset(&saddr, 0x00, sizeof(struct sockaddr_un));
        saddr.sun_family = AF_LOCAL;
        /* use abstract namespace for socket path */
        memset(&saddr, 0x00, sizeof(struct sockaddr_un));
        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;
 
        addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path+1) + 1;
 

-       retval = sendto(sock, &usend_msg, sizeof(usend_msg), 0, (struct sockaddr *)&saddr, addrlen);
+       retval = sendto(sock, &ctrl_msg, sizeof(ctrl_msg), 0, (struct sockaddr *)&saddr, addrlen);

        if (retval == -1) {
                err("error sending message: %s", strerror(errno));
                retval = 1;
        } else {
        if (retval == -1) {
                err("error sending message: %s", strerror(errno));
                retval = 1;
        } else {

-               dbg("sent message type=0x%02x, %u bytes sent", usend_msg.type, retval);
+               dbg("sent message type=0x%02x, %u bytes sent", ctrl_msg.type, retval);

                retval = 0;
        }
 
                retval = 0;
        }
 

diff --git a/udevd.c b/udevd.c
index 344a806c06201ae4b0f0eff11fda1d474074c376..b221692944c74dbc9604fd157852f0c08a98ce00 100644 (file)
--- a/udevd.c
+++ b/udevd.c
@@ -1,7 +1,7 @@
 /*
  * udevd.c - event listener and serializer
  *
 /*
  * 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>
  *
  *
  * Copyright (C) 2004 Chris Friesen <chris_friesen@sympatico.ca>
  *
  *


@@ -86,7 +86,7 @@ static void asmlinkage udev_event_sig_handler(int signum)
                exit(1);
 }
 
                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;
 {
        struct sigaction act;
        struct udevice *udev;


@@ -153,13 +153,13 @@ enum event_state {
        EVENT_FAILED,
 };
 
        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;
 {
        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));
 
        /* add location of queue files */
        strlcpy(filename, udev_root, sizeof(filename));


@@ -226,7 +226,7 @@ static void export_event_state(struct uevent_msg *msg, enum event_state state)
        }
 }
 
        }
 }
 

-static void msg_queue_delete(struct uevent_msg *msg)
+static void msg_queue_delete(struct udevd_uevent_msg *msg)

 {
        list_del(&msg->node);
 
 {
        list_del(&msg->node);
 


@@ -239,7 +239,7 @@ static void msg_queue_delete(struct uevent_msg *msg)
        free(msg);
 }
 
        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;
 {
        pid_t pid;
        int retval;


@@ -278,7 +278,7 @@ static void udev_event_run(struct uevent_msg *msg)
        }
 }
 
        }
 }
 

-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;
 {
        char filename[PATH_SIZE];
        int fd;


@@ -431,9 +431,9 @@ static int compare_devpath(const char *running, const char *waiting)
 }
 
 /* returns still running task for the same device, its parent or its physical device */
 }
 
 /* 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) {
        int childs_count = 0;
 
        list_for_each_entry(loop_msg, &running_list, node) {


@@ -464,8 +464,8 @@ static int running_with_devpath(struct uevent_msg *msg, int limit)
 /* exec queue management routine executes the events and serializes events in the same sequence */
 static void msg_queue_manager(void)
 {
 /* 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))
        int running;
 
        if (list_empty(&exec_list))


@@ -501,18 +501,18 @@ static void msg_queue_manager(void)
        }
 }
 
        }
 }
 

-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;
 {
        int bufpos;
        int i;

-       struct uevent_msg *msg;
+       struct udevd_uevent_msg *msg;

        int major = 0;
        int minor = 0;
 
        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;
        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);
 
        /* copy environment buffer and reconstruct envp */
        memcpy(msg->envbuf, buf, buf_size);


@@ -558,9 +558,9 @@ static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
 }
 
 /* receive the udevd message from userspace */
 }
 
 /* receive the udevd message from userspace */

-static void get_udevd_msg(void)
+static void get_ctrl_msg(void)

 {
 {

-       struct udevd_msg ctrl_msg;
+       struct udevd_ctrl_msg ctrl_msg;

        ssize_t size;
        struct msghdr smsg;
        struct cmsghdr *cmsg;
        ssize_t size;
        struct msghdr smsg;
        struct cmsghdr *cmsg;


@@ -569,9 +569,9 @@ static void get_udevd_msg(void)
        char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
        int *intval;
 
        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_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;
 
        memset(&smsg, 0x00, sizeof(struct msghdr));
        smsg.msg_iov = &iov;


@@ -598,34 +598,34 @@ static void get_udevd_msg(void)
                return;
        }
 
                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;
        }
 
        switch (ctrl_msg.type) {
                err("message magic '%s' doesn't match, ignore it", ctrl_msg.magic);
                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;
                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;
                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;
                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;
                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;
                info("udevd message (RELOAD_RULES) received");
                reload_config = 1;
                break;


@@ -635,9 +635,9 @@ static void get_udevd_msg(void)
 }
 
 /* receive the kernel user event message and do some sanity checks */
 }
 
 /* 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];
        int bufpos;
        ssize_t size;
        static char buffer[UEVENT_BUFFER_SIZE+512];


@@ -660,7 +660,6 @@ static struct uevent_msg *get_netlink_msg(void)
        msg = get_msg_from_envbuf(&buffer[bufpos], size-bufpos);
        if (msg == NULL)
                return NULL;
        msg = get_msg_from_envbuf(&buffer[bufpos], size-bufpos);
        if (msg == NULL)
                return NULL;

-       msg->type = UDEVD_UEVENT_NETLINK;

 
        /* validate message */
        pos = strchr(buffer, '@');
 
        /* validate message */
        pos = strchr(buffer, '@');


@@ -709,7 +708,7 @@ static void asmlinkage sig_handler(int signum)
 static void udev_done(int pid, int exitstatus)
 {
        /* find msg associated with pid and delete it */
 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) {
 
        list_for_each_entry(msg, &running_list, node) {
                if (msg->pid == pid) {


@@ -755,7 +754,7 @@ static int init_udevd_socket(void)
        memset(&saddr, 0x00, sizeof(saddr));
        saddr.sun_family = AF_LOCAL;
        /* use abstract namespace for socket path */
        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);
        addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path+1) + 1;
 
        udevd_sock = socket(AF_LOCAL, SOCK_DGRAM, 0);


@@ -1026,7 +1025,7 @@ int main(int argc, char *argv[], char *envp[])
        maxfd = UDEV_MAX(maxfd, inotify_fd);
 
        while (!udev_exit) {
        maxfd = UDEV_MAX(maxfd, inotify_fd);
 
        while (!udev_exit) {

-               struct uevent_msg *msg;
+               struct udevd_uevent_msg *msg;

                int fdcount;
 
                FD_ZERO(&readfds);
                int fdcount;
 
                FD_ZERO(&readfds);


@@ -1043,11 +1042,11 @@ int main(int argc, char *argv[], char *envp[])
                        continue;
                }
 
                        continue;
                }
 

-               /* get user socket message */
+               /* get control message */

                if (FD_ISSET(udevd_sock, &readfds))
                if (FD_ISSET(udevd_sock, &readfds))

-                       get_udevd_msg();
+                       get_ctrl_msg();

 
 

-               /* get kernel netlink message */
+               /* get netlink message */

                if (FD_ISSET(uevent_netlink_sock, &readfds)) {
                        msg = get_netlink_msg();
                        if (msg)
                if (FD_ISSET(uevent_netlink_sock, &readfds)) {
                        msg = get_netlink_msg();
                        if (msg)

diff --git a/udevd.h b/udevd.h
index 20dde8e8b344c8a2021b74e755ead74b97af4ac1..b852b5224d40f000851cd2654b06e6dd5764954a 100644 (file)
--- a/udevd.h
+++ b/udevd.h
@@ -21,9 +21,6 @@
 
 #include "list.h"
 
 
 #include "list.h"
 

-#define UDEV_MAGIC                     "udevd_" UDEV_VERSION
-#define UDEVD_SOCK_PATH                        "/org/kernel/udev/udevd"
-

 #define UDEVD_PRIORITY                 -4
 #define UDEV_PRIORITY                  -2
 
 #define UDEVD_PRIORITY                 -4
 #define UDEV_PRIORITY                  -2
 


@@ -36,29 +33,29 @@
 /* start to throttle forking if maximum number of running childs in our session is reached */
 #define UDEVD_MAX_CHILDS_RUNNING       16
 
 /* start to throttle forking if maximum number of running childs in our session is reached */
 #define UDEVD_MAX_CHILDS_RUNNING       16
 

-/* environment buffer, should match the kernel's size in lib/kobject_uevent.h */
+/* linux/include/linux/kobject.h */

 #define UEVENT_BUFFER_SIZE             2048
 #define UEVENT_BUFFER_SIZE             2048

-#define UEVENT_NUM_ENVP                        64
+#define UEVENT_NUM_ENVP                        32

 
 

-enum udevd_msg_type {
-       UDEVD_UNKNOWN,
-       UDEVD_UEVENT_NETLINK,
-       UDEVD_STOP_EXEC_QUEUE,
-       UDEVD_START_EXEC_QUEUE,
-       UDEVD_SET_LOG_LEVEL,
-       UDEVD_SET_MAX_CHILDS,
-       UDEVD_RELOAD_RULES,
-};
+#define UDEVD_CTRL_SOCK_PATH           "/org/kernel/udev/udevd"
+#define UDEVD_CTRL_MAGIC               "udevd_" UDEV_VERSION

 
 

+enum udevd_ctrl_msg_type {
+       UDEVD_CTRL_UNKNOWN,
+       UDEVD_CTRL_STOP_EXEC_QUEUE,
+       UDEVD_CTRL_START_EXEC_QUEUE,
+       UDEVD_CTRL_SET_LOG_LEVEL,
+       UDEVD_CTRL_SET_MAX_CHILDS,
+       UDEVD_CTRL_RELOAD_RULES,
+};

 
 

-struct udevd_msg {
+struct udevd_ctrl_msg {

        char magic[32];
        char magic[32];

-       enum udevd_msg_type type;
-       char envbuf[UEVENT_BUFFER_SIZE+512];
+       enum udevd_ctrl_msg_type type;
+       char buf[256];

 };
 
 };
 

-struct uevent_msg {
-       enum udevd_msg_type type;
+struct udevd_uevent_msg {

        struct list_head node;
        pid_t pid;
        int exitstatus;
        struct list_head node;
        pid_t pid;
        int exitstatus;