From: David Herrmann Date: Thu, 11 Dec 2014 12:19:41 +0000 (+0100) Subject: bus: sync with kdbus.git X-Git-Tag: v219~1065 X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=commitdiff_plain;h=94e15fdc4d9d96fa6607bfb4eaaea164a3aec417;p=elogind.git bus: sync with kdbus.git Sync up with recent kdbus changed: * several ioctls gained .size and .items members (but still unused) * CMD_SEND gained its own ioctl structure * several members of kdbus_msg were dropped as they were only used during SEND, not during RECV etc. * CMD_RECV and CMD_SEND now share a kdbus_reply member which contains the offset and size of the returned message. --- diff --git a/src/core/busname.c b/src/core/busname.c index 99641ec41..d4aa46339 100644 --- a/src/core/busname.c +++ b/src/core/busname.c @@ -727,6 +727,7 @@ _pure_ static const char *busname_sub_state_to_string(Unit *u) { static int busname_peek_message(BusName *n) { struct kdbus_cmd_recv cmd_recv = { + .size = sizeof(cmd_recv), .flags = KDBUS_RECV_PEEK, }; struct kdbus_cmd_free cmd_free = {}; @@ -750,7 +751,7 @@ static int busname_peek_message(BusName *n) { if (log_get_max_level() < LOG_DEBUG) return 0; - r = ioctl(n->starter_fd, KDBUS_CMD_MSG_RECV, &cmd_recv); + r = ioctl(n->starter_fd, KDBUS_CMD_RECV, &cmd_recv); if (r < 0) { if (errno == EINTR || errno == EAGAIN) return 0; @@ -766,9 +767,9 @@ static int busname_peek_message(BusName *n) { * 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); + start = (cmd_recv.reply.offset / ps) * ps; + delta = cmd_recv.reply.offset - start; + sz = PAGE_ALIGN(delta + cmd_recv.reply.msg_size); p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start); if (p == MAP_FAILED) { @@ -800,7 +801,7 @@ finish: if (p) (void) munmap(p, sz); - cmd_free.offset = cmd_recv.offset; + cmd_free.offset = cmd_recv.reply.offset; if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0) log_unit_warning(UNIT(n)->id, "Failed to free peeked message, ignoring: %m"); diff --git a/src/libsystemd/sd-bus/bus-control.c b/src/libsystemd/sd-bus/bus-control.c index 813c97f65..e86546c34 100644 --- a/src/libsystemd/sd-bus/bus-control.c +++ b/src/libsystemd/sd-bus/bus-control.c @@ -232,6 +232,7 @@ static int kernel_get_list(sd_bus *bus, uint64_t flags, char ***x) { /* Caller will free half-constructed list on failure... */ + cmd.size = sizeof(cmd); cmd.flags = flags; r = ioctl(bus->input_fd, KDBUS_CMD_NAME_LIST, &cmd); diff --git a/src/libsystemd/sd-bus/bus-kernel.c b/src/libsystemd/sd-bus/bus-kernel.c index 752c63adb..2978b0a28 100644 --- a/src/libsystemd/sd-bus/bus-kernel.c +++ b/src/libsystemd/sd-bus/bus-kernel.c @@ -294,8 +294,8 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { memzero(m->kdbus, sz); m->kdbus->flags = - ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) | - ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0); + ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_EXPECT_REPLY) | + ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0); if (well_known) /* verify_destination_id will usually be 0, which makes the kernel driver only look @@ -761,7 +761,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { } /* Refuse messages where the reply flag doesn't match up */ - if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_FLAGS_EXPECT_REPLY)) { + if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) { r = -EBADMSG; goto fail; } @@ -773,7 +773,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { } /* Refuse messages where the autostart flag doesn't match up */ - if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)) { + if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) { r = -EBADMSG; goto fail; } @@ -1012,6 +1012,7 @@ static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) { } int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) { + struct kdbus_cmd_send cmd = { }; int r; assert(bus); @@ -1027,15 +1028,20 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call if (r < 0) return r; + cmd.size = sizeof(cmd); + cmd.msg_address = (uintptr_t)m->kdbus; + /* If this is a synchronous method call, then let's tell the * kernel, so that it can pass CPU time/scheduling to the * destination for the time, if it wants to. If we * synchronously wait for the result anyway, we won't need CPU * anyway. */ - if (hint_sync_call) - m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY; + if (hint_sync_call) { + m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY; + cmd.flags |= KDBUS_SEND_SYNC_REPLY; + } - r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus); + r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd); if (r < 0) { _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; sd_bus_message *reply; @@ -1085,7 +1091,7 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call } else if (hint_sync_call) { struct kdbus_msg *k; - k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply); + k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset); assert(k); if (k->payload_type == KDBUS_PAYLOAD_DBUS) { @@ -1246,7 +1252,7 @@ static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) { } int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { - struct kdbus_cmd_recv recv = {}; + struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; struct kdbus_msg *k; int r; @@ -1261,7 +1267,7 @@ int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { recv.priority = priority; } - r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv); + r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv); if (r < 0) { if (errno == EAGAIN) return 0; @@ -1274,7 +1280,7 @@ int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { return -errno; } - k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset); + k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.reply.offset); if (k->payload_type == KDBUS_PAYLOAD_DBUS) { r = bus_kernel_make_message(bus, k); @@ -1798,12 +1804,13 @@ int bus_kernel_try_close(sd_bus *bus) { int bus_kernel_drop_one(int fd) { struct kdbus_cmd_recv recv = { - .flags = KDBUS_RECV_DROP + .size = sizeof(recv), + .flags = KDBUS_RECV_DROP, }; assert(fd >= 0); - if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0) + if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0) return -errno; return 0; diff --git a/src/libsystemd/sd-bus/kdbus.h b/src/libsystemd/sd-bus/kdbus.h index e2262de6b..bd51e3759 100644 --- a/src/libsystemd/sd-bus/kdbus.h +++ b/src/libsystemd/sd-bus/kdbus.h @@ -84,6 +84,7 @@ struct kdbus_creds { * struct kdbus_pids - process identifiers * @pid: Process ID * @tid: Thread ID + * @ppid: Parent process ID * * The PID and TID of a process. * @@ -93,6 +94,7 @@ struct kdbus_creds { struct kdbus_pids { __u64 pid; __u64 tid; + __u64 ppid; }; /** @@ -383,34 +385,26 @@ struct kdbus_item { /** * enum kdbus_msg_flags - type of message - * @KDBUS_MSG_FLAGS_EXPECT_REPLY: Expect a reply message, used for - * method calls. The userspace-supplied - * cookie identifies the message and the - * respective reply carries the cookie - * in cookie_reply - * @KDBUS_MSG_FLAGS_SYNC_REPLY: Wait for destination connection to - * reply to this message. The - * KDBUS_CMD_MSG_SEND ioctl() will block - * until the reply is received, and - * offset_reply in struct kdbus_msg will - * yield the offset in the sender's pool - * where the reply can be found. - * This flag is only valid if - * @KDBUS_MSG_FLAGS_EXPECT_REPLY is set as - * well. - * @KDBUS_MSG_FLAGS_NO_AUTO_START: Do not start a service, if the addressed - * name is not currently active + * @KDBUS_MSG_EXPECT_REPLY: Expect a reply message, used for + * method calls. The userspace-supplied + * cookie identifies the message and the + * respective reply carries the cookie + * in cookie_reply + * @KDBUS_MSG_NO_AUTO_START: Do not start a service, if the addressed + * name is not currently active */ enum kdbus_msg_flags { - KDBUS_MSG_FLAGS_EXPECT_REPLY = 1ULL << 0, - KDBUS_MSG_FLAGS_SYNC_REPLY = 1ULL << 1, - KDBUS_MSG_FLAGS_NO_AUTO_START = 1ULL << 2, + KDBUS_MSG_EXPECT_REPLY = 1ULL << 0, + KDBUS_MSG_NO_AUTO_START = 1ULL << 1, }; /** * enum kdbus_payload_type - type of payload carried by message * @KDBUS_PAYLOAD_KERNEL: Kernel-generated simple message * @KDBUS_PAYLOAD_DBUS: D-Bus marshalling "DBusDBus" + * + * Any payload-type is accepted. Common types will get added here once + * established. */ enum kdbus_payload_type { KDBUS_PAYLOAD_KERNEL, @@ -420,8 +414,7 @@ enum kdbus_payload_type { /** * struct kdbus_msg - the representation of a kdbus message * @size: Total size of the message - * @flags: Message flags (KDBUS_MSG_FLAGS_*), userspace → kernel - * @kernel_flags: Supported message flags, kernel → userspace + * @flags: Message flags (KDBUS_MSG_*), userspace → kernel * @priority: Message queue priority value * @dst_id: 64-bit ID of the destination connection * @src_id: 64-bit ID of the source connection @@ -436,15 +429,11 @@ enum kdbus_payload_type { * @cookie_reply: A reply to the requesting message with the same * cookie. The requesting connection can match its * request and the reply with this value - * @offset_reply: If KDBUS_MSG_FLAGS_EXPECT_REPLY, this field will - * contain the offset in the sender's pool where the - * reply is stored. * @items: A list of kdbus_items containing the message payload */ struct kdbus_msg { __u64 size; __u64 flags; - __u64 kernel_flags; __s64 priority; __u64 dst_id; __u64 src_id; @@ -453,11 +442,61 @@ struct kdbus_msg { union { __u64 timeout_ns; __u64 cookie_reply; - __u64 offset_reply; }; struct kdbus_item items[0]; } __attribute__((aligned(8))); +/** + * struct kdbus_reply - reply container + * @offset: Offset of kdbus_msg slice in pool + * @msg_size: Copy of the kdbus_msg.size field + * @return_flags: Command return flags, kernel → userspace + */ +struct kdbus_reply { + __u64 offset; + __u64 msg_size; + __u64 return_flags; +}; + +/** + * enum kdbus_send_flags - flags for sending messages + * @KDBUS_SEND_SYNC_REPLY: Wait for destination connection to + * reply to this message. The + * KDBUS_CMD_SEND ioctl() will block + * until the reply is received, and + * offset_reply in struct kdbus_msg will + * yield the offset in the sender's pool + * where the reply can be found. + * This flag is only valid if + * @KDBUS_MSG_EXPECT_REPLY is set as well. + */ +enum kdbus_send_flags { + KDBUS_SEND_SYNC_REPLY = 1ULL << 0, +}; + +/** + * 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 + * was given + * @items: Additional items for this command + */ +struct kdbus_cmd_send { + __u64 size; + __u64 flags; + __u64 kernel_flags; + __u64 kernel_msg_flags; + __u64 return_flags; + __u64 msg_address; + struct kdbus_reply reply; + struct kdbus_item items[0]; +} __attribute__((aligned(8))); + /** * enum kdbus_recv_flags - flags for de-queuing messages * @KDBUS_RECV_PEEK: Return the next queued message without @@ -477,49 +516,62 @@ enum kdbus_recv_flags { KDBUS_RECV_USE_PRIORITY = 1ULL << 2, }; +/** + * enum kdbus_recv_return_flags - return flags for message receive commands + * @KDBUS_RECV_RETURN_INCOMPLETE_FDS: One or more file descriptors could not + * be installed. These descriptors in + * KDBUS_ITEM_FDS will carry the value -1. + */ +enum kdbus_recv_return_flags { + KDBUS_RECV_RETURN_INCOMPLETE_FDS = 1ULL << 0, +}; + /** * 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. - * @offset: Returned offset in the pool where the message is - * stored. The user must use KDBUS_CMD_FREE to free - * the allocated memory. - * @dropped_msgs: In case the KDBUS_CMD_MSG_RECV ioctl returns + * @dropped_msgs: In case the KDBUS_CMD_RECV ioctl returns * -EOVERFLOW, this field will contain the number of * broadcast messages that have been lost since the * last call. - * @msg_size: Filled by the kernel with the actual message size. This - * 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. + * @reply: Return storage for received message. + * @items: Additional items for this command. * - * This struct is used with the KDBUS_CMD_MSG_RECV ioctl. + * This struct is used with the KDBUS_CMD_RECV ioctl. */ struct kdbus_cmd_recv { + __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; __s64 priority; - union { - __u64 offset; - __u64 dropped_msgs; - }; - __u64 msg_size; + __u64 dropped_msgs; + struct kdbus_reply reply; + struct kdbus_item items[0]; } __attribute__((aligned(8))); /** * struct kdbus_cmd_cancel - struct to cancel a synchronously pending message - * @cookie: The cookie of the pending message + * @size: Overall size of this object * @flags: Flags for the free command. Currently unused. + * @kernel_flags: Supported flags of CANCEL, kernel → userspace + * @return_flags: Command return flags, kernel → userspace + * @cookie: The cookie of the pending message + * @items: Items to modify the command behavior * * This struct is used with the KDBUS_CMD_CANCEL ioctl. */ struct kdbus_cmd_cancel { - __u64 cookie; + __u64 size; __u64 flags; + __u64 kernel_flags; + __u64 return_flags; + __u64 cookie; + struct kdbus_item items[0]; } __attribute__((aligned(8))); /** @@ -527,6 +579,7 @@ struct kdbus_cmd_cancel { * @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 * * This struct is used with the KDBUS_CMD_FREE ioctl. @@ -535,6 +588,7 @@ struct kdbus_cmd_free { __u64 offset; __u64 flags; __u64 kernel_flags; + __u64 return_flags; } __attribute__((aligned(8))); /** @@ -576,7 +630,7 @@ enum kdbus_policy_type { * policy entries for a name. The provided name * is not activated and not registered with the * name database, it only allows unprivileged - * connections to aquire a name, talk or discover + * connections to acquire a name, talk or discover * a service * @KDBUS_HELLO_MONITOR: Special-purpose connection to monitor * bus traffic @@ -635,6 +689,7 @@ enum kdbus_attach_flags { * @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_*) * @attach_flags_recv: Mask of metadata to attach to each message receieved @@ -657,6 +712,7 @@ struct kdbus_cmd_hello { __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; __u64 attach_flags_send; __u64 attach_flags_recv; __u64 bus_flags; @@ -683,6 +739,7 @@ enum kdbus_make_flags { * @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 @@ -692,6 +749,7 @@ struct kdbus_cmd_make { __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -717,6 +775,7 @@ enum kdbus_name_flags { * @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 * @@ -726,6 +785,7 @@ struct kdbus_cmd_name { __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -746,6 +806,19 @@ struct kdbus_name_info { 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 + * + * Note that the user is responsible for freeing the allocated memory with + * the KDBUS_CMD_FREE ioctl. + */ +struct kdbus_name_list { + __u64 size; + struct kdbus_name_info names[0]; +}; + /** * enum kdbus_name_list_flags - what to include into the returned list * @KDBUS_NAME_LIST_UNIQUE: All active connections @@ -765,6 +838,7 @@ enum kdbus_name_list_flags { * @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. * The user must use KDBUS_CMD_FREE to free the * allocated memory. @@ -773,23 +847,30 @@ enum kdbus_name_list_flags { * This structure is used with the KDBUS_CMD_NAME_LIST ioctl. */ struct kdbus_cmd_name_list { + __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; __u64 offset; - __u64 size; + __u64 list_size; + 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 - 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_name_list { +struct kdbus_info { __u64 size; - struct kdbus_name_info names[0]; + __u64 id; + __u64 flags; + struct kdbus_item items[0]; }; /** @@ -797,6 +878,7 @@ struct kdbus_name_list { * @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 * determine the ID in this case. @@ -816,34 +898,19 @@ 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_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]; -}; - /** * 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. @@ -852,6 +919,7 @@ struct kdbus_cmd_update { __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -873,6 +941,7 @@ enum kdbus_cmd_match_flags { * @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 * @items: A list of items for additional information * * This structure is used with the KDBUS_CMD_MATCH_ADD and @@ -883,6 +952,7 @@ struct kdbus_cmd_match { __u64 cookie; __u64 flags; __u64 kernel_flags; + __u64 return_flags; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -905,11 +975,11 @@ struct kdbus_cmd_match { * the call succeeds, and the handle is rendered * unusable. Otherwise, -EBUSY is returned without * any further side-effects. - * KDBUS_CMD_MSG_SEND: Send a message and pass data from userspace to + * KDBUS_CMD_SEND: Send a message and pass data from userspace to * the kernel. - * KDBUS_CMD_MSG_RECV: Receive a message from the kernel which is + * KDBUS_CMD_RECV: Receive a message from the kernel which is * placed in the receiver's pool. - * KDBUS_CMD_MSG_CANCEL: Cancel a pending request of a message that + * KDBUS_CMD_CANCEL: Cancel a pending request of a message that * blocks while waiting for a reply. The parameter * denotes the cookie of the message in flight. * KDBUS_CMD_FREE: Release the allocated memory in the receiver's @@ -946,11 +1016,11 @@ struct kdbus_cmd_match { struct kdbus_cmd_hello) #define KDBUS_CMD_BYEBYE _IO(KDBUS_IOCTL_MAGIC, 0x21) \ -#define KDBUS_CMD_MSG_SEND _IOWR(KDBUS_IOCTL_MAGIC, 0x30, \ +#define KDBUS_CMD_SEND _IOWR(KDBUS_IOCTL_MAGIC, 0x30, \ struct kdbus_msg) -#define KDBUS_CMD_MSG_RECV _IOWR(KDBUS_IOCTL_MAGIC, 0x31, \ +#define KDBUS_CMD_RECV _IOWR(KDBUS_IOCTL_MAGIC, 0x31, \ struct kdbus_cmd_recv) -#define KDBUS_CMD_MSG_CANCEL _IOW(KDBUS_IOCTL_MAGIC, 0x32, \ +#define KDBUS_CMD_CANCEL _IOW(KDBUS_IOCTL_MAGIC, 0x32, \ struct kdbus_cmd_cancel) #define KDBUS_CMD_FREE _IOW(KDBUS_IOCTL_MAGIC, 0x33, \ struct kdbus_cmd_free)