core: show log message about process triggering kdbus service activation

diff --git a/src/core/busname.c b/src/core/busname.c
index 68cb6ca7b7f2e0d7b62ce378caf1f1edc70ee588..1583d57416e56241fbe1eee815fd2d78e3bd72f6 100644 (file)
--- a/src/core/busname.c
+++ b/src/core/busname.c
@@ -19,6 +19,8 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
+#include <sys/mman.h>
+
 #include "special.h"
 #include "bus-kernel.h"
 #include "bus-internal.h"
@@ -26,6 +28,7 @@
 #include "service.h"
 #include "dbus-busname.h"
 #include "busname.h"
+#include "kdbus.h"
 
 static const UnitActiveState state_translation_table[_BUSNAME_STATE_MAX] = {
         [BUSNAME_DEAD] = UNIT_INACTIVE,
@@ -301,8 +304,7 @@ static int busname_open_fd(BusName *n) {
         mode = UNIT(n)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user";
         n->starter_fd = bus_kernel_open_bus_fd(mode, &path);
         if (n->starter_fd < 0) {
-                log_warning_unit(UNIT(n)->id, "Failed to open %s: %s",
-                                 path ?: "kdbus", strerror(-n->starter_fd));
+                log_warning_unit(UNIT(n)->id, "Failed to open %s: %s", path ?: "kdbus", strerror(-n->starter_fd));
                 return n->starter_fd;
         }
 
@@ -725,6 +727,81 @@ _pure_ static const char *busname_sub_state_to_string(Unit *u) {
         return busname_state_to_string(BUSNAME(u)->state);
 }
 
+static int busname_peek_message(BusName *n) {
+        struct kdbus_cmd_recv cmd_recv = {
+                .flags = KDBUS_RECV_PEEK,
+        };
+        const char *comm = NULL;
+        struct kdbus_item *d;
+        struct kdbus_msg *k;
+        size_t start, ps, sz, delta;
+        void *p = NULL;
+        pid_t pid = 0;
+        int r;
+
+        assert(n);
+
+        /* Generate a friendly log message about which process caused
+         * triggering of this bus name. This simply peeks the metadata
+         * of the first queued message and logs it. */
+
+        r = ioctl(n->starter_fd, KDBUS_CMD_MSG_RECV, &cmd_recv);
+        if (r < 0) {
+                if (errno == EINTR || errno == EAGAIN)
+                        return 0;
+
+                log_error_unit(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
+                return -errno;
+        }
+
+        /* We map as late as possible, and unmap imemdiately after
+         * use. On 32bit address space is scarce and we want to be
+         * able to handle a lot of activator connections at the same
+         * time, and hence shouldn't keep the mmap()s around for
+         * longer than necessary. */
+
+        ps = page_size();
+        start = (cmd_recv.offset / ps) * ps;
+        delta = cmd_recv.offset - start;
+        sz = PAGE_ALIGN(delta + cmd_recv.msg_size);
+
+        p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
+        if (p == MAP_FAILED) {
+                log_error_unit(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
+                r = -errno;
+                goto finish;
+        }
+
+        k = (struct kdbus_msg *) ((uint8_t *) p + delta);
+        KDBUS_ITEM_FOREACH(d, k, items) {
+                switch (d->type) {
+
+                case KDBUS_ITEM_PIDS:
+                        pid = d->pids.pid;
+                        break;
+
+                case KDBUS_ITEM_PID_COMM:
+                        comm = d->str;
+                        break;
+                }
+        }
+
+        if (pid > 0)
+                log_debug_unit(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
+
+        r = 0;
+
+finish:
+        if (p)
+                (void) munmap(p, sz);
+
+        /* Hint: we don't invoke KDBUS_CMD_MSG_FREE here, as we only
+         * PEEKed the message, and didn't ask for it to be dropped
+         * from the queue. */
+
+        return r;
+}
+
 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
         BusName *n = userdata;
 
@@ -742,6 +819,7 @@ static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents
                 goto fail;
         }
 
+        busname_peek_message(n);
         busname_enter_running(n);
         return 0;
 fail:

diff --git a/src/libsystemd/sd-bus/kdbus.h b/src/libsystemd/sd-bus/kdbus.h
index ae900c27201828ed23642de2439507feb7023812..3e841f4003d55a4976858a94820a7b9445ec6e43 100644 (file)
--- a/src/libsystemd/sd-bus/kdbus.h
+++ b/src/libsystemd/sd-bus/kdbus.h
@@ -494,10 +494,11 @@ enum kdbus_recv_flags {
  *                     broadcast messages that have been lost since the
  *                     last call.
  * @msg_size:          Filled by the kernel with the actual message size. This
- *                     mirrors the 'size' member of the message stored at
- *                     @offset, but allows callers to access it without mapping
- *                     their pool. By using @msg_size and @offset, you can map
- *                     only the message itself, not the whole pool.
+ *                     is the full size of the slice placed at @offset. It
+ *                     includes the memory used for the kdbus_msg object, but
+ *                     also for all appended VECs. By using @msg_size and
+ *                     @offset, you can map a single message, instead of
+ *                     mapping the whole pool.
  *
  * This struct is used with the KDBUS_CMD_MSG_RECV ioctl.
  */