uevent: new applet

This applet listens on netlink socket with kernel's uevent messages.
Run-tested.

function                                             old     new   delta
uevent_main                                            -     416    +416
packed_usage                                       30671   30713     +42
applet_names                                        2531    2538      +7
applet_main                                         1468    1472      +4
RCVBUF                                                 -       4      +4
applet_nameofs                                       734     736      +2
------------------------------------------------------------------------------
(add/remove: 3/0 grow/shrink: 4/0 up/down: 475/0)             Total: 475 bytes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

diff --git a/util-linux/uevent.c b/util-linux/uevent.c
new file mode 100644 (file)
index 0000000..fb98b48
--- /dev/null
+++ b/util-linux/uevent.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2015 Denys Vlasenko
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+
+//config:config UEVENT
+//config:      bool "uevent"
+//config:      default y
+//config:      select PLATFORM_LINUX
+//config:      help
+//config:        uevent is a netlink listener for kernel uevent notifications
+//config:        sent via netlink. It is usually used for dynamic device creation.
+
+//applet:IF_UEVENT(APPLET(uevent, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_UEVENT) += uevent.o
+
+//usage:#define uevent_trivial_usage
+//usage:       "[PROG [ARGS]]"
+//usage:#define uevent_full_usage "\n\n"
+//usage:       "uevent runs PROG for every netlink notification."
+//usage:   "\n""PROG's environment contains data passed from the kernel."
+//usage:   "\n""Typical usage (daemon for dynamic device node creation):"
+//usage:   "\n""       # uevent mdev & mdev -s"
+
+#include "libbb.h"
+#include <linux/netlink.h>
+
+#define BUFFER_SIZE 16*1024
+
+#define env ((char **)&bb_common_bufsiz1)
+enum {
+       MAX_ENV = COMMON_BUFSIZE / sizeof(env[0]) - 1,
+};
+
+#ifndef SO_RCVBUFFORCE
+#define SO_RCVBUFFORCE 33
+#endif
+static const int RCVBUF = 2 * 1024 * 1024;
+
+int uevent_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int uevent_main(int argc UNUSED_PARAM, char **argv)
+{
+       struct sockaddr_nl sa;
+       int fd;
+
+       argv++;
+
+       // Subscribe for UEVENT kernel messages
+       sa.nl_family = AF_NETLINK;
+       sa.nl_pad = 0;
+       sa.nl_pid = getpid();
+       sa.nl_groups = 1 << 0;
+       fd = xsocket(AF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
+       xbind(fd, (struct sockaddr *) &sa, sizeof(sa));
+       close_on_exec_on(fd);
+
+       // Without a sufficiently big RCVBUF, a ton of simultaneous events
+       // can trigger ENOBUFS on read, which is unrecoverable.
+       // Reproducer:
+       //      uevent mdev &
+       //      find /sys -name uevent -exec sh -c 'echo add >"{}"' ';'
+       //
+       // SO_RCVBUFFORCE (root only) can go above net.core.rmem_max sysctl
+       setsockopt(fd, SOL_SOCKET, SO_RCVBUF,      &RCVBUF, sizeof(RCVBUF));
+       setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &RCVBUF, sizeof(RCVBUF));
+       if (0) {
+               int z;
+               socklen_t zl = sizeof(z);
+               getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &z, &zl);
+               bb_error_msg("SO_RCVBUF:%d", z);
+       }
+
+       for (;;) {
+               char *netbuf;
+               char *s, *end;
+               ssize_t len;
+               int idx;
+
+               // In many cases, a system sits for *days* waiting
+               // for a new uevent notification to come in.
+               // We use a fresh mmap so that buffer is not allocated
+               // until kernel actually starts filling it.
+               netbuf = mmap(NULL, BUFFER_SIZE,
+                                       PROT_READ | PROT_WRITE,
+                                       MAP_PRIVATE | MAP_ANON,
+                                       /* ignored: */ -1, 0);
+               if (netbuf == MAP_FAILED)
+                       bb_perror_msg_and_die("mmap");
+
+               // Here we block, possibly for a very long time
+               len = safe_read(fd, netbuf, BUFFER_SIZE - 1);
+               if (len < 0)
+                       bb_perror_msg_and_die("read");
+               end = netbuf + len;
+               *end = '\0';
+
+               // Each netlink message starts with "ACTION@/path"
+               // (which we currently ignore),
+               // followed by environment variables.
+               if (!argv[0])
+                       putchar('\n');
+               idx = 0;
+               s = netbuf;
+               while (s < end) {
+                       if (!argv[0])
+                               puts(s);
+                       if (strchr(s, '=') && idx < MAX_ENV)
+                               env[idx++] = s;
+                       s += strlen(s) + 1;
+               }
+               env[idx] = NULL;
+
+               idx = 0;
+               while (env[idx])
+                       putenv(env[idx++]);
+               if (argv[0])
+                       spawn_and_wait(argv);
+               idx = 0;
+               while (env[idx])
+                       bb_unsetenv(env[idx++]);
+               munmap(netbuf, BUFFER_SIZE);
+       }
+
+       return 0; // not reached
+}