chiark / gitweb /
bus: sync with kdbus (ABI break)
authorDavid Herrmann <dh.herrmann@gmail.com>
Wed, 4 Feb 2015 15:21:27 +0000 (16:21 +0100)
committerDavid Herrmann <dh.herrmann@gmail.com>
Thu, 5 Feb 2015 15:52:42 +0000 (16:52 +0100)
src/bus-proxyd/driver.c
src/core/bus-endpoint.c
src/libsystemd/sd-bus/bus-control.c
src/libsystemd/sd-bus/bus-kernel.c
src/libsystemd/sd-bus/bus-kernel.h
src/libsystemd/sd-bus/kdbus.h

index 6a72d18..23911c6 100644 (file)
@@ -327,9 +327,8 @@ int bus_proxy_process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m, SharedPoli
                 return synthetic_reply_return_strv(m, names);
 
         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListQueuedOwners")) {
-                struct kdbus_cmd_name_list cmd = {};
-                struct kdbus_name_list *name_list;
-                struct kdbus_name_info *name;
+                struct kdbus_cmd_list cmd = {};
+                struct kdbus_info *name_list, *name;
                 _cleanup_strv_free_ char **owners = NULL;
                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
                 char *arg0;
@@ -350,14 +349,14 @@ int bus_proxy_process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m, SharedPoli
                 if (r < 0)
                         return synthetic_reply_method_errno(m, r, NULL);
 
-                cmd.flags = KDBUS_NAME_LIST_QUEUED;
-                r = ioctl(a->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
+                cmd.flags = KDBUS_LIST_QUEUED;
+                r = ioctl(a->input_fd, KDBUS_CMD_LIST, &cmd);
                 if (r < 0)
                         return synthetic_reply_method_errno(m, -errno, NULL);
 
-                name_list = (struct kdbus_name_list *) ((uint8_t *) a->kdbus_buffer + cmd.offset);
+                name_list = (struct kdbus_info *) ((uint8_t *) a->kdbus_buffer + cmd.offset);
 
-                KDBUS_ITEM_FOREACH(name, name_list, names) {
+                KDBUS_FOREACH(name, name_list, cmd.list_size) {
                         const char *entry_name = NULL;
                         struct kdbus_item *item;
                         char *n;
@@ -369,7 +368,7 @@ int bus_proxy_process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m, SharedPoli
                         if (!streq_ptr(entry_name, arg0))
                                 continue;
 
-                        if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
+                        if (asprintf(&n, ":1.%llu", (unsigned long long) name->id) < 0) {
                                 err  = -ENOMEM;
                                 break;
                         }
index 27dd192..0c4b3e7 100644 (file)
 
 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
 
-        struct kdbus_cmd_update *update;
+        struct kdbus_cmd *update;
         struct kdbus_item *n;
         BusEndpointPolicy *po;
         Iterator i;
         size_t size;
         int r;
 
-        size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
+        size = ALIGN8(offsetof(struct kdbus_cmd, items));
 
         HASHMAP_FOREACH(po, ep->policy_hash, i) {
                 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
index ac27df8..2d51c74 100644 (file)
@@ -52,7 +52,7 @@ _public_ int sd_bus_get_unique_name(sd_bus *bus, const char **unique) {
 }
 
 static int bus_request_name_kernel(sd_bus *bus, const char *name, uint64_t flags) {
-        struct kdbus_cmd_name *n;
+        struct kdbus_cmd *n;
         size_t size, l;
         int r;
 
@@ -60,7 +60,7 @@ static int bus_request_name_kernel(sd_bus *bus, const char *name, uint64_t flags
         assert(name);
 
         l = strlen(name) + 1;
-        size = offsetof(struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(l);
+        size = offsetof(struct kdbus_cmd, items) + KDBUS_ITEM_SIZE(l);
         n = alloca0_align(size, 8);
         n->size = size;
         n->flags = request_name_flags_to_kdbus(flags);
@@ -151,7 +151,7 @@ _public_ int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags)
 }
 
 static int bus_release_name_kernel(sd_bus *bus, const char *name) {
-        struct kdbus_cmd_name *n;
+        struct kdbus_cmd *n;
         size_t size, l;
         int r;
 
@@ -159,7 +159,7 @@ static int bus_release_name_kernel(sd_bus *bus, const char *name) {
         assert(name);
 
         l = strlen(name) + 1;
-        size = offsetof(struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(l);
+        size = offsetof(struct kdbus_cmd, items) + KDBUS_ITEM_SIZE(l);
         n = alloca0_align(size, 8);
         n->size = size;
 
@@ -233,9 +233,8 @@ _public_ int sd_bus_release_name(sd_bus *bus, const char *name) {
 }
 
 static int kernel_get_list(sd_bus *bus, uint64_t flags, char ***x) {
-        struct kdbus_cmd_name_list cmd = {};
-        struct kdbus_name_list *name_list;
-        struct kdbus_name_info *name;
+        struct kdbus_cmd_list cmd = {};
+        struct kdbus_info *name_list, *name;
         uint64_t previous_id = 0;
         int r;
 
@@ -244,21 +243,21 @@ static int kernel_get_list(sd_bus *bus, uint64_t flags, char ***x) {
         cmd.size = sizeof(cmd);
         cmd.flags = flags;
 
-        r = ioctl(bus->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
+        r = ioctl(bus->input_fd, KDBUS_CMD_LIST, &cmd);
         if (r < 0)
                 return -errno;
 
-        name_list = (struct kdbus_name_list *) ((uint8_t *) bus->kdbus_buffer + cmd.offset);
+        name_list = (struct kdbus_info *) ((uint8_t *) bus->kdbus_buffer + cmd.offset);
 
-        KDBUS_ITEM_FOREACH(name, name_list, names) {
+        KDBUS_FOREACH(name, name_list, cmd.list_size) {
 
                 struct kdbus_item *item;
                 const char *entry_name = NULL;
 
-                if ((flags & KDBUS_NAME_LIST_UNIQUE) && name->owner_id != previous_id) {
+                if ((flags & KDBUS_LIST_UNIQUE) && name->id != previous_id) {
                         char *n;
 
-                        if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
+                        if (asprintf(&n, ":1.%llu", (unsigned long long) name->id) < 0) {
                                 r = -ENOMEM;
                                 goto fail;
                         }
@@ -267,7 +266,7 @@ static int kernel_get_list(sd_bus *bus, uint64_t flags, char ***x) {
                         if (r < 0)
                                 goto fail;
 
-                        previous_id = name->owner_id;
+                        previous_id = name->id;
                 }
 
                 KDBUS_ITEM_FOREACH(item, name, items)
@@ -295,13 +294,13 @@ static int bus_list_names_kernel(sd_bus *bus, char ***acquired, char ***activata
         int r;
 
         if (acquired) {
-                r = kernel_get_list(bus, KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES, &x);
+                r = kernel_get_list(bus, KDBUS_LIST_UNIQUE | KDBUS_LIST_NAMES, &x);
                 if (r < 0)
                         return r;
         }
 
         if (activatable) {
-                r = kernel_get_list(bus, KDBUS_NAME_LIST_ACTIVATORS, &y);
+                r = kernel_get_list(bus, KDBUS_LIST_ACTIVATORS, &y);
                 if (r < 0)
                         return r;
 
index b4d0af1..1714188 100644 (file)
@@ -1521,7 +1521,7 @@ uint64_t attach_flags_to_kdbus(uint64_t mask) {
 }
 
 int bus_kernel_create_bus(const char *name, bool world, char **s) {
-        struct kdbus_cmd_make *make;
+        struct kdbus_cmd *make;
         struct kdbus_item *n;
         size_t l;
         int fd;
@@ -1534,14 +1534,14 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) {
                 return -errno;
 
         l = strlen(name);
-        make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
+        make = alloca0_align(offsetof(struct kdbus_cmd, items) +
                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
                              8);
 
-        make->size = offsetof(struct kdbus_cmd_make, items);
+        make->size = offsetof(struct kdbus_cmd, items);
 
         /* Set the bloom parameters */
         n = make->items;
@@ -1634,7 +1634,7 @@ int bus_kernel_open_bus_fd(const char *bus, char **path) {
 
 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
         _cleanup_free_ char *path = NULL;
-        struct kdbus_cmd_make *make;
+        struct kdbus_cmd *make;
         struct kdbus_item *n;
         const char *name;
         int fd;
@@ -1643,10 +1643,10 @@ int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char *
         if (fd < 0)
                 return fd;
 
-        make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
+        make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) +
                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
                              8);
-        make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
+        make->size = ALIGN8(offsetof(struct kdbus_cmd, items));
         make->flags = KDBUS_MAKE_ACCESS_WORLD;
 
         n = make->items;
@@ -1677,10 +1677,12 @@ int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char *
 }
 
 int bus_kernel_try_close(sd_bus *bus) {
+        struct kdbus_cmd byebye = { .size = sizeof(byebye) };
+
         assert(bus);
         assert(bus->is_kernel);
 
-        if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
+        if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0)
                 return -errno;
 
         return 0;
@@ -1701,13 +1703,13 @@ int bus_kernel_drop_one(int fd) {
 }
 
 int bus_kernel_realize_attach_flags(sd_bus *bus) {
-        struct kdbus_cmd_update *update;
+        struct kdbus_cmd *update;
         struct kdbus_item *n;
 
         assert(bus);
         assert(bus->is_kernel);
 
-        update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
+        update = alloca0_align(offsetof(struct kdbus_cmd, items) +
                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
                                8);
 
@@ -1717,10 +1719,10 @@ int bus_kernel_realize_attach_flags(sd_bus *bus) {
         n->data64[0] = bus->attach_flags;
 
         update->size =
-                offsetof(struct kdbus_cmd_update, items) +
+                offsetof(struct kdbus_cmd, items) +
                 ALIGN8(n->size);
 
-        if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
+        if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0)
                 return -errno;
 
         return 0;
index 7b1e9ef..b9f31ba 100644 (file)
              ((uint8_t *)(part) < (uint8_t *)(head) + (head)->size) &&  \
                 ((uint8_t *) part >= (uint8_t *) head);                 \
              part = KDBUS_ITEM_NEXT(part))
+#define KDBUS_FOREACH(iter, first, _size)                               \
+        for (iter = (first);                                            \
+             ((uint8_t *)(iter) < (uint8_t *)(first) + (_size)) &&      \
+               ((uint8_t *)(iter) >= (uint8_t *)(first));               \
+             iter = (void*)(((uint8_t *)iter) + ALIGN8((iter)->size)))
 
 #define KDBUS_ITEM_HEADER_SIZE offsetof(struct kdbus_item, data)
 #define KDBUS_ITEM_SIZE(s) ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE)
index c238d79..1cc475e 100644 (file)
@@ -16,7 +16,7 @@
 #define KDBUS_DST_ID_NAME              (0)
 #define KDBUS_MATCH_ID_ANY             (~0ULL)
 #define KDBUS_DST_ID_BROADCAST         (~0ULL)
-#define KDBUS_FLAG_KERNEL              (1ULL << 63)
+#define KDBUS_FLAG_NEGOTIATE           (1ULL << 63)
 
 /**
  * struct kdbus_notify_id_change - name registry change message
@@ -33,7 +33,7 @@
 struct kdbus_notify_id_change {
        __u64 id;
        __u64 flags;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_notify_name_change - name registry change message
@@ -53,7 +53,7 @@ struct kdbus_notify_name_change {
        struct kdbus_notify_id_change old_id;
        struct kdbus_notify_id_change new_id;
        char name[0];
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_creds - process credentials
@@ -78,7 +78,7 @@ struct kdbus_creds {
        __u32 egid;
        __u32 sgid;
        __u32 fsgid;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_pids - process identifiers
@@ -95,7 +95,7 @@ struct kdbus_pids {
        __u64 pid;
        __u64 tid;
        __u64 ppid;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_caps - process capabilities
@@ -110,7 +110,7 @@ struct kdbus_pids {
 struct kdbus_caps {
        __u32 last_cap;
        __u32 caps[0];
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_audit - audit information
@@ -123,7 +123,7 @@ struct kdbus_caps {
 struct kdbus_audit {
        __u32 sessionid;
        __u32 loginuid;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_timestamp
@@ -138,7 +138,7 @@ struct kdbus_timestamp {
        __u64 seqnum;
        __u64 monotonic_ns;
        __u64 realtime_ns;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_vec - I/O vector for kdbus payload items
@@ -156,7 +156,7 @@ struct kdbus_vec {
                __u64 address;
                __u64 offset;
        };
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_bloom_parameter - bus-wide bloom parameters
@@ -166,7 +166,7 @@ struct kdbus_vec {
 struct kdbus_bloom_parameter {
        __u64 size;
        __u64 n_hash;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_bloom_filter - bloom filter containing n elements
@@ -176,7 +176,7 @@ struct kdbus_bloom_parameter {
 struct kdbus_bloom_filter {
        __u64 generation;
        __u64 data[0];
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_memfd - a kdbus memfd
@@ -193,7 +193,7 @@ struct kdbus_memfd {
        __u64 size;
        int fd;
        __u32 __pad;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_name - a registered well-known name with its flags
@@ -206,6 +206,34 @@ struct kdbus_memfd {
 struct kdbus_name {
        __u64 flags;
        char name[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_policy_access_type - permissions of a policy record
+ * @_KDBUS_POLICY_ACCESS_NULL: Uninitialized/invalid
+ * @KDBUS_POLICY_ACCESS_USER:  Grant access to a uid
+ * @KDBUS_POLICY_ACCESS_GROUP: Grant access to gid
+ * @KDBUS_POLICY_ACCESS_WORLD: World-accessible
+ */
+enum kdbus_policy_access_type {
+       _KDBUS_POLICY_ACCESS_NULL,
+       KDBUS_POLICY_ACCESS_USER,
+       KDBUS_POLICY_ACCESS_GROUP,
+       KDBUS_POLICY_ACCESS_WORLD,
+};
+
+/**
+ * enum kdbus_policy_access_flags - mode flags
+ * @KDBUS_POLICY_OWN:          Allow to own a well-known name
+ *                             Implies KDBUS_POLICY_TALK and KDBUS_POLICY_SEE
+ * @KDBUS_POLICY_TALK:         Allow communication to a well-known name
+ *                             Implies KDBUS_POLICY_SEE
+ * @KDBUS_POLICY_SEE:          Allow to see a well-known name
+ */
+enum kdbus_policy_type {
+       KDBUS_POLICY_SEE        = 0,
+       KDBUS_POLICY_TALK,
+       KDBUS_POLICY_OWN,
 };
 
 /**
@@ -219,12 +247,52 @@ struct kdbus_policy_access {
        __u64 type;     /* USER, GROUP, WORLD */
        __u64 access;   /* OWN, TALK, SEE */
        __u64 id;       /* uid, gid, 0 */
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_attach_flags - flags for metadata attachments
+ * @KDBUS_ATTACH_TIMESTAMP:            Timestamp
+ * @KDBUS_ATTACH_CREDS:                        Credentials
+ * @KDBUS_ATTACH_PIDS:                 PIDs
+ * @KDBUS_ATTACH_AUXGROUPS:            Auxiliary groups
+ * @KDBUS_ATTACH_NAMES:                        Well-known names
+ * @KDBUS_ATTACH_TID_COMM:             The "comm" process identifier of the TID
+ * @KDBUS_ATTACH_PID_COMM:             The "comm" process identifier of the PID
+ * @KDBUS_ATTACH_EXE:                  The path of the executable
+ * @KDBUS_ATTACH_CMDLINE:              The process command line
+ * @KDBUS_ATTACH_CGROUP:               The croup membership
+ * @KDBUS_ATTACH_CAPS:                 The process capabilities
+ * @KDBUS_ATTACH_SECLABEL:             The security label
+ * @KDBUS_ATTACH_AUDIT:                        The audit IDs
+ * @KDBUS_ATTACH_CONN_DESCRIPTION:     The human-readable connection name
+ * @_KDBUS_ATTACH_ALL:                 All of the above
+ * @_KDBUS_ATTACH_ANY:                 Wildcard match to enable any kind of
+ *                                     metatdata.
+ */
+enum kdbus_attach_flags {
+       KDBUS_ATTACH_TIMESTAMP          =  1ULL <<  0,
+       KDBUS_ATTACH_CREDS              =  1ULL <<  1,
+       KDBUS_ATTACH_PIDS               =  1ULL <<  2,
+       KDBUS_ATTACH_AUXGROUPS          =  1ULL <<  3,
+       KDBUS_ATTACH_NAMES              =  1ULL <<  4,
+       KDBUS_ATTACH_TID_COMM           =  1ULL <<  5,
+       KDBUS_ATTACH_PID_COMM           =  1ULL <<  6,
+       KDBUS_ATTACH_EXE                =  1ULL <<  7,
+       KDBUS_ATTACH_CMDLINE            =  1ULL <<  8,
+       KDBUS_ATTACH_CGROUP             =  1ULL <<  9,
+       KDBUS_ATTACH_CAPS               =  1ULL << 10,
+       KDBUS_ATTACH_SECLABEL           =  1ULL << 11,
+       KDBUS_ATTACH_AUDIT              =  1ULL << 12,
+       KDBUS_ATTACH_CONN_DESCRIPTION   =  1ULL << 13,
+       _KDBUS_ATTACH_ALL               =  (1ULL << 14) - 1,
+       _KDBUS_ATTACH_ANY               =  ~0ULL
 };
 
 /**
  * enum kdbus_item_type - item types to chain data in a list
  * @_KDBUS_ITEM_NULL:                  Uninitialized/invalid
  * @_KDBUS_ITEM_USER_BASE:             Start of user items
+ * @KDBUS_ITEM_NEGOTIATE:              Negotiate supported items
  * @KDBUS_ITEM_PAYLOAD_VEC:            Vector to data
  * @KDBUS_ITEM_PAYLOAD_OFF:            Data at returned offset to message head
  * @KDBUS_ITEM_PAYLOAD_MEMFD:          Data as sealed memfd
@@ -291,7 +359,8 @@ struct kdbus_policy_access {
 enum kdbus_item_type {
        _KDBUS_ITEM_NULL,
        _KDBUS_ITEM_USER_BASE,
-       KDBUS_ITEM_PAYLOAD_VEC  = _KDBUS_ITEM_USER_BASE,
+       KDBUS_ITEM_NEGOTIATE    = _KDBUS_ITEM_USER_BASE,
+       KDBUS_ITEM_PAYLOAD_VEC,
        KDBUS_ITEM_PAYLOAD_OFF,
        KDBUS_ITEM_PAYLOAD_MEMFD,
        KDBUS_ITEM_FDS,
@@ -385,7 +454,7 @@ struct kdbus_item {
                struct kdbus_notify_id_change id_change;
                struct kdbus_policy_access policy_access;
        };
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_item_list - A list of items
@@ -395,7 +464,7 @@ struct kdbus_item {
 struct kdbus_item_list {
        __u64 size;
        struct kdbus_item items[0];
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * enum kdbus_msg_flags - type of message
@@ -460,7 +529,7 @@ struct kdbus_msg {
                __u64 cookie_reply;
        };
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_msg_info - returned message container
@@ -472,7 +541,7 @@ struct kdbus_msg_info {
        __u64 offset;
        __u64 msg_size;
        __u64 return_flags;
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * enum kdbus_send_flags - flags for sending messages
@@ -494,8 +563,6 @@ enum kdbus_send_flags {
  * struct kdbus_cmd_send - send message
  * @size:              Overall size of this structure
  * @flags:             Flags to change send behavior (KDBUS_SEND_*)
- * @kernel_flags:      Supported send flags, kernel → userspace
- * @kernel_msg_flags:  Supported message flags, kernel → userspace
  * @return_flags:      Command return flags, kernel → userspace
  * @msg_address:       Storage address of the kdbus_msg to send
  * @reply:             Storage for message reply if KDBUS_SEND_SYNC_REPLY
@@ -505,13 +572,11 @@ enum kdbus_send_flags {
 struct kdbus_cmd_send {
        __u64 size;
        __u64 flags;
-       __u64 kernel_flags;
-       __u64 kernel_msg_flags;
        __u64 return_flags;
        __u64 msg_address;
        struct kdbus_msg_info reply;
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
+} __attribute__((__aligned__(8)));
 
 /**
  * enum kdbus_recv_flags - flags for de-queuing messages
@@ -546,7 +611,6 @@ enum kdbus_recv_return_flags {
  * struct kdbus_cmd_recv - struct to de-queue a buffered message
  * @size:              Overall size of this object
  * @flags:             KDBUS_RECV_* flags, userspace → kernel
- * @kernel_flags:      Supported KDBUS_RECV_* flags, kernel → userspace
  * @return_flags:      Command return flags, kernel → userspace
  * @priority:          Minimum priority of the messages to de-queue. Lowest
  *                     values have the highest priority.
@@ -554,7 +618,7 @@ enum kdbus_recv_return_flags {
  *                     -EOVERFLOW, this field will contain the number of
  *                     broadcast messages that have been lost since the
  *                     last call.
- * @reply:             Return storage for received message.
+ * @msg:               Return storage for received message.
  * @items:             Additional items for this command.
  *
  * This struct is used with the KDBUS_CMD_RECV ioctl.
@@ -562,62 +626,31 @@ enum kdbus_recv_return_flags {
 struct kdbus_cmd_recv {
        __u64 size;
        __u64 flags;
-       __u64 kernel_flags;
        __u64 return_flags;
        __s64 priority;
        __u64 dropped_msgs;
        struct kdbus_msg_info msg;
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_cmd_free - struct to free a slice of memory in the pool
  * @size:              Overall size of this structure
- * @offset:            The offset of the memory slice, as returned by other
- *                     ioctls
  * @flags:             Flags for the free command, userspace → kernel
  * @return_flags:      Command return flags, kernel → userspace
- * @kernel_flags:      Supported flags of the free command, userspace → kernel
+ * @offset:            The offset of the memory slice, as returned by other
+ *                     ioctls
  * @items:             Additional items to modify the behavior
  *
  * This struct is used with the KDBUS_CMD_FREE ioctl.
  */
 struct kdbus_cmd_free {
        __u64 size;
-       __u64 offset;
        __u64 flags;
-       __u64 kernel_flags;
        __u64 return_flags;
+       __u64 offset;
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
-
-/**
- * enum kdbus_policy_access_type - permissions of a policy record
- * @_KDBUS_POLICY_ACCESS_NULL: Uninitialized/invalid
- * @KDBUS_POLICY_ACCESS_USER:  Grant access to a uid
- * @KDBUS_POLICY_ACCESS_GROUP: Grant access to gid
- * @KDBUS_POLICY_ACCESS_WORLD: World-accessible
- */
-enum kdbus_policy_access_type {
-       _KDBUS_POLICY_ACCESS_NULL,
-       KDBUS_POLICY_ACCESS_USER,
-       KDBUS_POLICY_ACCESS_GROUP,
-       KDBUS_POLICY_ACCESS_WORLD,
-};
-
-/**
- * enum kdbus_policy_access_flags - mode flags
- * @KDBUS_POLICY_OWN:          Allow to own a well-known name
- *                             Implies KDBUS_POLICY_TALK and KDBUS_POLICY_SEE
- * @KDBUS_POLICY_TALK:         Allow communication to a well-known name
- *                             Implies KDBUS_POLICY_SEE
- * @KDBUS_POLICY_SEE:          Allow to see a well-known name
- */
-enum kdbus_policy_type {
-       KDBUS_POLICY_SEE        = 0,
-       KDBUS_POLICY_TALK,
-       KDBUS_POLICY_OWN,
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * enum kdbus_hello_flags - flags for struct kdbus_cmd_hello
@@ -643,49 +676,9 @@ enum kdbus_hello_flags {
 };
 
 /**
- * enum kdbus_attach_flags - flags for metadata attachments
- * @KDBUS_ATTACH_TIMESTAMP:            Timestamp
- * @KDBUS_ATTACH_CREDS:                        Credentials
- * @KDBUS_ATTACH_PIDS:                 PIDs
- * @KDBUS_ATTACH_AUXGROUPS:            Auxiliary groups
- * @KDBUS_ATTACH_NAMES:                        Well-known names
- * @KDBUS_ATTACH_TID_COMM:             The "comm" process identifier of the TID
- * @KDBUS_ATTACH_PID_COMM:             The "comm" process identifier of the PID
- * @KDBUS_ATTACH_EXE:                  The path of the executable
- * @KDBUS_ATTACH_CMDLINE:              The process command line
- * @KDBUS_ATTACH_CGROUP:               The croup membership
- * @KDBUS_ATTACH_CAPS:                 The process capabilities
- * @KDBUS_ATTACH_SECLABEL:             The security label
- * @KDBUS_ATTACH_AUDIT:                        The audit IDs
- * @KDBUS_ATTACH_CONN_DESCRIPTION:     The human-readable connection name
- * @_KDBUS_ATTACH_ALL:                 All of the above
- * @_KDBUS_ATTACH_ANY:                 Wildcard match to enable any kind of
- *                                     metatdata.
- */
-enum kdbus_attach_flags {
-       KDBUS_ATTACH_TIMESTAMP          =  1ULL <<  0,
-       KDBUS_ATTACH_CREDS              =  1ULL <<  1,
-       KDBUS_ATTACH_PIDS               =  1ULL <<  2,
-       KDBUS_ATTACH_AUXGROUPS          =  1ULL <<  3,
-       KDBUS_ATTACH_NAMES              =  1ULL <<  4,
-       KDBUS_ATTACH_TID_COMM           =  1ULL <<  5,
-       KDBUS_ATTACH_PID_COMM           =  1ULL <<  6,
-       KDBUS_ATTACH_EXE                =  1ULL <<  7,
-       KDBUS_ATTACH_CMDLINE            =  1ULL <<  8,
-       KDBUS_ATTACH_CGROUP             =  1ULL <<  9,
-       KDBUS_ATTACH_CAPS               =  1ULL << 10,
-       KDBUS_ATTACH_SECLABEL           =  1ULL << 11,
-       KDBUS_ATTACH_AUDIT              =  1ULL << 12,
-       KDBUS_ATTACH_CONN_DESCRIPTION   =  1ULL << 13,
-       _KDBUS_ATTACH_ALL               =  (1ULL << 14) - 1,
-       _KDBUS_ATTACH_ANY               =  ~0ULL
-};
-
-/**
  * struct kdbus_cmd_hello - struct to say hello to kdbus
  * @size:              The total size of the structure
  * @flags:             Connection flags (KDBUS_HELLO_*), userspace → kernel
- * @kernel_flags:      Supported connection flags, kernel → userspace
  * @return_flags:      Command return flags, kernel → userspace
  * @attach_flags_send: Mask of metadata to attach to each message sent
  *                     off by this connection (KDBUS_ATTACH_*)
@@ -710,7 +703,6 @@ enum kdbus_attach_flags {
 struct kdbus_cmd_hello {
        __u64 size;
        __u64 flags;
-       __u64 kernel_flags;
        __u64 return_flags;
        __u64 attach_flags_send;
        __u64 attach_flags_recv;
@@ -721,165 +713,66 @@ struct kdbus_cmd_hello {
        __u64 items_size;
        __u8 id128[16];
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
+} __attribute__((__aligned__(8)));
 
 /**
- * enum kdbus_make_flags - Flags for KDBUS_CMD_{BUS,EP,NS}_MAKE
- * @KDBUS_MAKE_ACCESS_GROUP:   Make the bus or endpoint node group-accessible
- * @KDBUS_MAKE_ACCESS_WORLD:   Make the bus or endpoint node world-accessible
- */
-enum kdbus_make_flags {
-       KDBUS_MAKE_ACCESS_GROUP         = 1ULL <<  0,
-       KDBUS_MAKE_ACCESS_WORLD         = 1ULL <<  1,
-};
-
-/**
- * struct kdbus_cmd_make - struct to make a bus, an endpoint or a domain
- * @size:              The total size of the struct
- * @flags:             Properties for the bus/ep/domain to create,
- *                     userspace → kernel
- * @kernel_flags:      Supported flags for the used command, kernel → userspace
- * @return_flags:      Command return flags, kernel → userspace
- * @items:             Items describing details
- *
- * This structure is used with the KDBUS_CMD_BUS_MAKE and
- * KDBUS_CMD_ENDPOINT_MAKE ioctls.
- */
-struct kdbus_cmd_make {
-       __u64 size;
-       __u64 flags;
-       __u64 kernel_flags;
-       __u64 return_flags;
-       struct kdbus_item items[0];
-} __attribute__((aligned(8)));
-
-/**
- * enum kdbus_name_flags - properties of a well-known name
- * @KDBUS_NAME_REPLACE_EXISTING:       Try to replace name of other connections
- * @KDBUS_NAME_ALLOW_REPLACEMENT:      Allow the replacement of the name
- * @KDBUS_NAME_QUEUE:                  Name should be queued if busy
- * @KDBUS_NAME_IN_QUEUE:               Name is queued
- * @KDBUS_NAME_ACTIVATOR:              Name is owned by a activator connection
- */
-enum kdbus_name_flags {
-       KDBUS_NAME_REPLACE_EXISTING     = 1ULL <<  0,
-       KDBUS_NAME_ALLOW_REPLACEMENT    = 1ULL <<  1,
-       KDBUS_NAME_QUEUE                = 1ULL <<  2,
-       KDBUS_NAME_IN_QUEUE             = 1ULL <<  3,
-       KDBUS_NAME_ACTIVATOR            = 1ULL <<  4,
-};
-
-/**
- * struct kdbus_cmd_name - struct to describe a well-known name
- * @size:              The total size of the struct
- * @flags:             Flags for a name entry (KDBUS_NAME_*),
- *                     userspace → kernel, kernel → userspace
- * @kernel_flags:      Supported flags for a name entry, kernel → userspace
- * @return_flags:      Command return flags, kernel → userspace
- * @items:             Item list, containing the well-known name as
- *                     KDBUS_ITEM_NAME
- *
- * This structure is used with the KDBUS_CMD_NAME_ACQUIRE ioctl.
- */
-struct kdbus_cmd_name {
-       __u64 size;
-       __u64 flags;
-       __u64 kernel_flags;
-       __u64 return_flags;
-       struct kdbus_item items[0];
-} __attribute__((aligned(8)));
-
-/**
- * struct kdbus_name_info - struct to describe a well-known name
- * @size:              The total size of the struct
- * @conn_flags:                The flags of the owning connection (KDBUS_HELLO_*)
- * @owner_id:          The current owner of the name
- * @items:             Item list, containing the well-known name as
- *                     KDBUS_ITEM_OWNED_NAME
- *
- * This structure is used as return struct for the KDBUS_CMD_NAME_LIST ioctl.
- */
-struct kdbus_name_info {
-       __u64 size;
-       __u64 conn_flags;
-       __u64 owner_id;
-       struct kdbus_item items[0];
-} __attribute__((aligned(8)));
-
-/**
- * struct kdbus_name_list - information returned by KDBUS_CMD_NAME_LIST
- * @size:              The total size of the structure
- * @names:             A list of names
+ * struct kdbus_info - connection information
+ * @size:              total size of the struct
+ * @id:                        64bit object ID
+ * @flags:             object creation flags
+ * @items:             list of items
  *
  * Note that the user is responsible for freeing the allocated memory with
  * the KDBUS_CMD_FREE ioctl.
  */
-struct kdbus_name_list {
+struct kdbus_info {
        __u64 size;
-       struct kdbus_name_info names[0];
-};
+       __u64 id;
+       __u64 flags;
+       struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
 
 /**
- * enum kdbus_name_list_flags - what to include into the returned list
- * @KDBUS_NAME_LIST_UNIQUE:    All active connections
- * @KDBUS_NAME_LIST_NAMES:     All known well-known names
- * @KDBUS_NAME_LIST_ACTIVATORS:        All activator connections
- * @KDBUS_NAME_LIST_QUEUED:    All queued-up names
+ * enum kdbus_list_flags - what to include into the returned list
+ * @KDBUS_LIST_UNIQUE:         active connections
+ * @KDBUS_LIST_ACTIVATORS:     activator connections
+ * @KDBUS_LIST_NAMES:          known well-known names
+ * @KDBUS_LIST_QUEUED:         queued-up names
  */
-enum kdbus_name_list_flags {
-       KDBUS_NAME_LIST_UNIQUE          = 1ULL <<  0,
-       KDBUS_NAME_LIST_NAMES           = 1ULL <<  1,
-       KDBUS_NAME_LIST_ACTIVATORS      = 1ULL <<  2,
-       KDBUS_NAME_LIST_QUEUED          = 1ULL <<  3,
+enum kdbus_list_flags {
+       KDBUS_LIST_UNIQUE               = 1ULL <<  0,
+       KDBUS_LIST_NAMES                = 1ULL <<  1,
+       KDBUS_LIST_ACTIVATORS           = 1ULL <<  2,
+       KDBUS_LIST_QUEUED               = 1ULL <<  3,
 };
 
 /**
- * struct kdbus_cmd_name_list - request a list of name entries
- * @flags:             Flags for the query (KDBUS_NAME_LIST_*),
- *                     userspace → kernel
- * @kernel_flags:      Supported flags for queries, kernel → userspace
- * @return_flags:      Command return flags, kernel → userspace
- * @offset:            The returned offset in the caller's pool buffer.
+ * struct kdbus_cmd_list - list connections
+ * @size:              overall size of this object
+ * @flags:             flags for the query (KDBUS_LIST_*), userspace → kernel
+ * @return_flags:      command return flags, kernel → userspace
+ * @offset:            Offset in the caller's pool buffer where an array of
+ *                     kdbus_info objects is stored.
  *                     The user must use KDBUS_CMD_FREE to free the
  *                     allocated memory.
- * @list_size:         Returned size of list in bytes
- * @size:              Output buffer to report size of data at @offset.
+ * @list_size:         size of returned list in bytes
  * @items:             Items for the command. Reserved for future use.
  *
- * This structure is used with the KDBUS_CMD_NAME_LIST ioctl.
+ * This structure is used with the KDBUS_CMD_LIST ioctl.
  */
-struct kdbus_cmd_name_list {
+struct kdbus_cmd_list {
        __u64 size;
        __u64 flags;
-       __u64 kernel_flags;
        __u64 return_flags;
        __u64 offset;
        __u64 list_size;
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
-
-/**
- * struct kdbus_info - information returned by KDBUS_CMD_*_INFO
- * @size:              The total size of the struct
- * @id:                        The connection's or bus' 64-bit ID
- * @flags:             The connection's or bus' flags
- * @items:             A list of struct kdbus_item
- *
- * Note that the user is responsible for freeing the allocated memory with
- * the KDBUS_CMD_FREE ioctl.
- */
-struct kdbus_info {
-       __u64 size;
-       __u64 id;
-       __u64 flags;
-       struct kdbus_item items[0];
-};
+} __attribute__((__aligned__(8)));
 
 /**
  * struct kdbus_cmd_info - struct used for KDBUS_CMD_CONN_INFO ioctl
  * @size:              The total size of the struct
  * @flags:             KDBUS_ATTACH_* flags, userspace → kernel
- * @kernel_flags:      Supported KDBUS_ATTACH_* flags, kernel → userspace
  * @return_flags:      Command return flags, kernel → userspace
  * @id:                        The 64-bit ID of the connection. If set to zero, passing
  *                     @name is required. kdbus will look up the name to
@@ -899,31 +792,12 @@ struct kdbus_info {
 struct kdbus_cmd_info {
        __u64 size;
        __u64 flags;
-       __u64 kernel_flags;
        __u64 return_flags;
        __u64 id;
        __u64 offset;
        __u64 info_size;
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
-
-/**
- * struct kdbus_cmd_update - update flags of a connection
- * @size:              The total size of the struct
- * @flags:             Flags for the update command, userspace → kernel
- * @kernel_flags:      Supported flags for this command, kernel → userspace
- * @return_flags:      Command return flags, kernel → userspace
- * @items:             A list of struct kdbus_item
- *
- * This struct is used with the KDBUS_CMD_CONN_UPDATE ioctl.
- */
-struct kdbus_cmd_update {
-       __u64 size;
-       __u64 flags;
-       __u64 kernel_flags;
-       __u64 return_flags;
-       struct kdbus_item items[0];
-} __attribute__((aligned(8)));
+} __attribute__((__aligned__(8)));
 
 /**
  * enum kdbus_cmd_match_flags - flags to control the KDBUS_CMD_MATCH_ADD ioctl
@@ -938,12 +812,11 @@ enum kdbus_cmd_match_flags {
 /**
  * struct kdbus_cmd_match - struct to add or remove matches
  * @size:              The total size of the struct
- * @cookie:            Userspace supplied cookie. When removing, the cookie
- *                     identifies the match to remove
  * @flags:             Flags for match command (KDBUS_MATCH_*),
  *                     userspace → kernel
- * @kernel_flags:      Supported flags of the used command, kernel → userspace
  * @return_flags:      Command return flags, kernel → userspace
+ * @cookie:            Userspace supplied cookie. When removing, the cookie
+ *                     identifies the match to remove
  * @items:             A list of items for additional information
  *
  * This structure is used with the KDBUS_CMD_MATCH_ADD and
@@ -951,98 +824,149 @@ enum kdbus_cmd_match_flags {
  */
 struct kdbus_cmd_match {
        __u64 size;
+       __u64 flags;
+       __u64 return_flags;
        __u64 cookie;
+       struct kdbus_item items[0];
+} __attribute__((__aligned__(8)));
+
+/**
+ * enum kdbus_make_flags - Flags for KDBUS_CMD_{BUS,ENDPOINT}_MAKE
+ * @KDBUS_MAKE_ACCESS_GROUP:   Make the bus or endpoint node group-accessible
+ * @KDBUS_MAKE_ACCESS_WORLD:   Make the bus or endpoint node world-accessible
+ */
+enum kdbus_make_flags {
+       KDBUS_MAKE_ACCESS_GROUP         = 1ULL <<  0,
+       KDBUS_MAKE_ACCESS_WORLD         = 1ULL <<  1,
+};
+
+/**
+ * enum kdbus_name_flags - flags for KDBUS_CMD_NAME_ACQUIRE
+ * @KDBUS_NAME_REPLACE_EXISTING:       Try to replace name of other connections
+ * @KDBUS_NAME_ALLOW_REPLACEMENT:      Allow the replacement of the name
+ * @KDBUS_NAME_QUEUE:                  Name should be queued if busy
+ * @KDBUS_NAME_IN_QUEUE:               Name is queued
+ * @KDBUS_NAME_ACTIVATOR:              Name is owned by a activator connection
+ */
+enum kdbus_name_flags {
+       KDBUS_NAME_REPLACE_EXISTING     = 1ULL <<  0,
+       KDBUS_NAME_ALLOW_REPLACEMENT    = 1ULL <<  1,
+       KDBUS_NAME_QUEUE                = 1ULL <<  2,
+       KDBUS_NAME_IN_QUEUE             = 1ULL <<  3,
+       KDBUS_NAME_ACTIVATOR            = 1ULL <<  4,
+};
+
+/**
+ * struct kdbus_cmd - generic ioctl payload
+ * @size:              Overall size of this structure
+ * @flags:             Flags for this ioctl, userspace → kernel
+ * @return_flags:      Ioctl return flags, kernel → userspace
+ * @items:             Additional items to modify the behavior
+ *
+ * This is a generic ioctl payload object. It's used by all ioctls that only
+ * take flags and items as input.
+ */
+struct kdbus_cmd {
+       __u64 size;
        __u64 flags;
-       __u64 kernel_flags;
        __u64 return_flags;
        struct kdbus_item items[0];
-} __attribute__((aligned(8)));
+} __attribute__((__aligned__(8)));
 
 /**
  * Ioctl API
+ *
  * KDBUS_CMD_BUS_MAKE:         After opening the "control" node, this command
  *                             creates a new bus with the specified
  *                             name. The bus is immediately shut down and
  *                             cleaned up when the opened file descriptor is
  *                             closed.
+ *
  * KDBUS_CMD_ENDPOINT_MAKE:    Creates a new named special endpoint to talk to
  *                             the bus. Such endpoints usually carry a more
  *                             restrictive policy and grant restricted access
  *                             to specific applications.
+ * KDBUS_CMD_ENDPOINT_UPDATE:  Update the properties of a custom enpoint. Used
+ *                             to update the policy.
+ *
  * KDBUS_CMD_HELLO:            By opening the bus node, a connection is
  *                             created. After a HELLO the opened connection
  *                             becomes an active peer on the bus.
+ * KDBUS_CMD_UPDATE:           Update the properties of a connection. Used to
+ *                             update the metadata subscription mask and
+ *                             policy.
  * KDBUS_CMD_BYEBYE:           Disconnect a connection. If there are no
  *                             messages queued up in the connection's pool,
  *                             the call succeeds, and the handle is rendered
  *                             unusable. Otherwise, -EBUSY is returned without
  *                             any further side-effects.
+ * KDBUS_CMD_FREE:             Release the allocated memory in the receiver's
+ *                             pool.
+ * KDBUS_CMD_CONN_INFO:                Retrieve credentials and properties of the
+ *                             initial creator of the connection. The data was
+ *                             stored at registration time and does not
+ *                             necessarily represent the connected process or
+ *                             the actual state of the process.
+ * KDBUS_CMD_BUS_CREATOR_INFO: Retrieve information of the creator of the bus
+ *                             a connection is attached to.
+ *
  * KDBUS_CMD_SEND:             Send a message and pass data from userspace to
  *                             the kernel.
  * KDBUS_CMD_RECV:             Receive a message from the kernel which is
  *                             placed in the receiver's pool.
- * KDBUS_CMD_FREE:             Release the allocated memory in the receiver's
- *                             pool.
+ *
  * KDBUS_CMD_NAME_ACQUIRE:     Request a well-known bus name to associate with
  *                             the connection. Well-known names are used to
  *                             address a peer on the bus.
  * KDBUS_CMD_NAME_RELEASE:     Release a well-known name the connection
  *                             currently owns.
- * KDBUS_CMD_NAME_LIST:                Retrieve the list of all currently registered
+ * KDBUS_CMD_LIST:             Retrieve the list of all currently registered
  *                             well-known and unique names.
- * KDBUS_CMD_CONN_INFO:                Retrieve credentials and properties of the
- *                             initial creator of the connection. The data was
- *                             stored at registration time and does not
- *                             necessarily represent the connected process or
- *                             the actual state of the process.
- * KDBUS_CMD_CONN_UPDATE:      Update the properties of a connection. Used to
- *                             update the metadata subscription mask and
- *                             policy.
- * KDBUS_CMD_BUS_CREATOR_INFO: Retrieve information of the creator of the bus
- *                             a connection is attached to.
- * KDBUS_CMD_ENDPOINT_UPDATE:  Update the properties of a custom enpoint. Used
- *                             to update the policy.
+ *
  * KDBUS_CMD_MATCH_ADD:                Install a match which broadcast messages should
  *                             be delivered to the connection.
  * KDBUS_CMD_MATCH_REMOVE:     Remove a current match for broadcast messages.
  */
 enum kdbus_ioctl_type {
+       /* bus owner (00-0f) */
        KDBUS_CMD_BUS_MAKE =            _IOW(KDBUS_IOCTL_MAGIC, 0x00,
-                                            struct kdbus_cmd_make),
+                                            struct kdbus_cmd),
+
+       /* endpoint owner (10-1f) */
        KDBUS_CMD_ENDPOINT_MAKE =       _IOW(KDBUS_IOCTL_MAGIC, 0x10,
-                                            struct kdbus_cmd_make),
+                                            struct kdbus_cmd),
+       KDBUS_CMD_ENDPOINT_UPDATE =     _IOW(KDBUS_IOCTL_MAGIC, 0x11,
+                                            struct kdbus_cmd),
 
-       KDBUS_CMD_HELLO =               _IOWR(KDBUS_IOCTL_MAGIC, 0x20,
+       /* connection owner (80-ff) */
+       KDBUS_CMD_HELLO =               _IOWR(KDBUS_IOCTL_MAGIC, 0x80,
                                              struct kdbus_cmd_hello),
-       KDBUS_CMD_BYEBYE =              _IO(KDBUS_IOCTL_MAGIC, 0x21),
-
-       KDBUS_CMD_SEND =                _IOWR(KDBUS_IOCTL_MAGIC, 0x30,
-                                             struct kdbus_cmd_send),
-       KDBUS_CMD_RECV =                _IOWR(KDBUS_IOCTL_MAGIC, 0x31,
-                                             struct kdbus_cmd_recv),
-       KDBUS_CMD_FREE =                _IOW(KDBUS_IOCTL_MAGIC, 0x32,
+       KDBUS_CMD_UPDATE =              _IOW(KDBUS_IOCTL_MAGIC, 0x81,
+                                            struct kdbus_cmd),
+       KDBUS_CMD_BYEBYE =              _IOW(KDBUS_IOCTL_MAGIC, 0x82,
+                                            struct kdbus_cmd),
+       KDBUS_CMD_FREE =                _IOW(KDBUS_IOCTL_MAGIC, 0x83,
                                             struct kdbus_cmd_free),
-
-       KDBUS_CMD_NAME_ACQUIRE =        _IOWR(KDBUS_IOCTL_MAGIC, 0x40,
-                                             struct kdbus_cmd_name),
-       KDBUS_CMD_NAME_RELEASE =        _IOW(KDBUS_IOCTL_MAGIC, 0x41,
-                                            struct kdbus_cmd_name),
-       KDBUS_CMD_NAME_LIST =           _IOWR(KDBUS_IOCTL_MAGIC, 0x42,
-                                             struct kdbus_cmd_name_list),
-
-       KDBUS_CMD_CONN_INFO =           _IOWR(KDBUS_IOCTL_MAGIC, 0x50,
-                                             struct kdbus_cmd_info),
-       KDBUS_CMD_CONN_UPDATE =         _IOW(KDBUS_IOCTL_MAGIC, 0x51,
-                                            struct kdbus_cmd_update),
-       KDBUS_CMD_BUS_CREATOR_INFO =    _IOWR(KDBUS_IOCTL_MAGIC, 0x52,
-                                             struct kdbus_cmd_info),
-
-       KDBUS_CMD_ENDPOINT_UPDATE =     _IOW(KDBUS_IOCTL_MAGIC, 0x61,
-                                            struct kdbus_cmd_update),
-
-       KDBUS_CMD_MATCH_ADD =           _IOW(KDBUS_IOCTL_MAGIC, 0x70,
+       KDBUS_CMD_CONN_INFO =           _IOR(KDBUS_IOCTL_MAGIC, 0x84,
+                                            struct kdbus_cmd_info),
+       KDBUS_CMD_BUS_CREATOR_INFO =    _IOR(KDBUS_IOCTL_MAGIC, 0x85,
+                                            struct kdbus_cmd_info),
+       KDBUS_CMD_LIST =                _IOR(KDBUS_IOCTL_MAGIC, 0x86,
+                                            struct kdbus_cmd_list),
+
+       KDBUS_CMD_SEND =                _IOW(KDBUS_IOCTL_MAGIC, 0x90,
+                                            struct kdbus_cmd_send),
+       KDBUS_CMD_RECV =                _IOR(KDBUS_IOCTL_MAGIC, 0x91,
+                                            struct kdbus_cmd_recv),
+
+       KDBUS_CMD_NAME_ACQUIRE =        _IOW(KDBUS_IOCTL_MAGIC, 0xa0,
+                                            struct kdbus_cmd),
+       KDBUS_CMD_NAME_RELEASE =        _IOW(KDBUS_IOCTL_MAGIC, 0xa1,
+                                            struct kdbus_cmd),
+
+       KDBUS_CMD_MATCH_ADD =           _IOW(KDBUS_IOCTL_MAGIC, 0xb0,
                                             struct kdbus_cmd_match),
-       KDBUS_CMD_MATCH_REMOVE =        _IOW(KDBUS_IOCTL_MAGIC, 0x71,
+       KDBUS_CMD_MATCH_REMOVE =        _IOW(KDBUS_IOCTL_MAGIC, 0xb1,
                                             struct kdbus_cmd_match),
 };