X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd%2Fsd-bus%2Fkdbus.h;h=e9d9c9f31b367c0bd371139c27f89c0f57b69e3d;hp=3e841f4003d55a4976858a94820a7b9445ec6e43;hb=d031efb271130f07b468a5b59a02a9ec766c7f92;hpb=bd5f920f1288c0d4d488629fadf067f709227030 diff --git a/src/libsystemd/sd-bus/kdbus.h b/src/libsystemd/sd-bus/kdbus.h index 3e841f400..e9d9c9f31 100644 --- a/src/libsystemd/sd-bus/kdbus.h +++ b/src/libsystemd/sd-bus/kdbus.h @@ -70,26 +70,23 @@ struct kdbus_notify_name_change { * KDBUS_ITEM_CREDS */ struct kdbus_creds { - __u64 uid; - __u64 euid; - __u64 suid; - __u64 fsuid; - __u64 gid; - __u64 egid; - __u64 sgid; - __u64 fsgid; + __u32 uid; + __u32 euid; + __u32 suid; + __u32 fsuid; + __u32 gid; + __u32 egid; + __u32 sgid; + __u32 fsgid; }; /** * struct kdbus_pids - process identifiers * @pid: Process ID * @tid: Thread ID - * @starttime: Starttime of the process + * @ppid: Parent process ID * - * The PID, TID and starttime of a process. The start tmie is useful to detect - * PID overruns from the client side. i.e. if you use the PID to look something - * up in /proc/$PID/ you can afterwards check the starttime field of it, to - * ensure you didn't run into a PID overrun. + * The PID and TID of a process. * * Attached to: * KDBUS_ITEM_PIDS @@ -97,7 +94,7 @@ struct kdbus_creds { struct kdbus_pids { __u64 pid; __u64 tid; - __u64 starttime; + __u64 ppid; }; /** @@ -124,8 +121,8 @@ struct kdbus_caps { * KDBUS_ITEM_AUDIT */ struct kdbus_audit { - __u64 sessionid; - __u64 loginuid; + __u32 sessionid; + __u32 loginuid; }; /** @@ -183,7 +180,8 @@ struct kdbus_bloom_filter { /** * struct kdbus_memfd - a kdbus memfd - * @size: The memfd's size + * @start: The offset into the memfd where the segment starts + * @size: The size of the memfd segment * @fd: The file descriptor number * @__pad: Padding to ensure proper alignment and size * @@ -191,6 +189,7 @@ struct kdbus_bloom_filter { * KDBUS_ITEM_PAYLOAD_MEMFD */ struct kdbus_memfd { + __u64 start; __u64 size; int fd; __u32 __pad; @@ -230,6 +229,9 @@ struct kdbus_policy_access { * @KDBUS_ITEM_PAYLOAD_OFF: Data at returned offset to message head * @KDBUS_ITEM_PAYLOAD_MEMFD: Data as sealed memfd * @KDBUS_ITEM_FDS: Attached file descriptors + * @KDBUS_ITEM_CANCEL_FD: FD used to cancel a synchronous + * operation by writing to it from + * userspace * @KDBUS_ITEM_BLOOM_PARAMETER: Bus-wide bloom parameters, used with * KDBUS_CMD_BUS_MAKE, carries a * struct kdbus_bloom_parameter @@ -293,6 +295,7 @@ enum kdbus_item_type { KDBUS_ITEM_PAYLOAD_OFF, KDBUS_ITEM_PAYLOAD_MEMFD, KDBUS_ITEM_FDS, + KDBUS_ITEM_CANCEL_FD, KDBUS_ITEM_BLOOM_PARAMETER, KDBUS_ITEM_BLOOM_FILTER, KDBUS_ITEM_BLOOM_MASK, @@ -384,36 +387,40 @@ struct kdbus_item { }; }; +/** + * struct kdbus_item_list - A list of items + * @size: The total size of the structure + * @items: Array of items + */ +struct kdbus_item_list { + __u64 size; + struct kdbus_item items[0]; +}; + /** * 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 + * @KDBUS_MSG_SIGNAL: Treat this message as signal */ 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, + KDBUS_MSG_SIGNAL = 1ULL << 2, }; /** * 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, @@ -423,8 +430,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 @@ -439,15 +445,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; @@ -456,11 +458,61 @@ struct kdbus_msg { union { __u64 timeout_ns; __u64 cookie_reply; - __u64 offset_reply; }; struct kdbus_item items[0]; } __attribute__((aligned(8))); +/** + * struct kdbus_msg_info - returned message 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_msg_info { + __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_msg_info 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 @@ -480,64 +532,63 @@ 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; -} __attribute__((aligned(8))); - -/** - * struct kdbus_cmd_cancel - struct to cancel a synchronously pending message - * @cookie: The cookie of the pending message - * @flags: Flags for the free command. Currently unused. - * - * This struct is used with the KDBUS_CMD_CANCEL ioctl. - */ -struct kdbus_cmd_cancel { - __u64 cookie; - __u64 flags; + __u64 dropped_msgs; + struct kdbus_msg_info reply; + struct kdbus_item items[0]; } __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 + * @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; + struct kdbus_item items[0]; } __attribute__((aligned(8))); /** @@ -579,16 +630,19 @@ 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 + * @KDBUS_HELLO_UNPRIVILEGED: Don't treat this connection as privileged once + * the bus connection was established. */ enum kdbus_hello_flags { KDBUS_HELLO_ACCEPT_FD = 1ULL << 0, KDBUS_HELLO_ACTIVATOR = 1ULL << 1, KDBUS_HELLO_POLICY_HOLDER = 1ULL << 2, KDBUS_HELLO_MONITOR = 1ULL << 3, + KDBUS_HELLO_UNPRIVILEGED = 1ULL << 4, }; /** @@ -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 @@ -646,8 +701,10 @@ enum kdbus_attach_flags { * @id: The ID of this connection (kernel → userspace) * @pool_size: Size of the connection's buffer where the received * messages are placed - * @bloom: The bloom properties of the bus, specified - * by the bus creator (kernel → userspace) + * @offset: Pool offset where additional items of type + * kdbus_item_list are stored. They contain information + * about the bus and the newly created connection. + * @items_size: Copy of item_list.size stored in @offset. * @id128: Unique 128-bit ID of the bus (kernel → userspace) * @items: A list of items * @@ -657,12 +714,14 @@ 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; __u64 id; __u64 pool_size; - struct kdbus_bloom_parameter bloom; + __u64 offset; + __u64 items_size; __u8 id128[16]; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -683,6 +742,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 +752,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 +778,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 +788,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 +809,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,29 +841,41 @@ 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. + * @list_size: Returned size of list in bytes + * @size: Output buffer to report size of data at @offset. + * @items: Items for the command. Reserved for future use. * * 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 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]; }; /** @@ -795,12 +883,14 @@ 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. * @offset: Returned offset in the caller's pool buffer where the * kdbus_info struct result is stored. The user must * use KDBUS_CMD_FREE to free the allocated memory. + * @info_size: Output buffer to report size of data at @offset. * @items: The optional item list, containing the * well-known name to look up as a KDBUS_ITEM_NAME. * Only needed in case @id is zero. @@ -813,33 +903,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. @@ -848,6 +924,7 @@ struct kdbus_cmd_update { __u64 size; __u64 flags; __u64 kernel_flags; + __u64 return_flags; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -869,6 +946,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 @@ -879,6 +957,7 @@ struct kdbus_cmd_match { __u64 cookie; __u64 flags; __u64 kernel_flags; + __u64 return_flags; struct kdbus_item items[0]; } __attribute__((aligned(8))); @@ -901,13 +980,10 @@ 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 - * 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 * pool. * KDBUS_CMD_NAME_ACQUIRE: Request a well-known bus name to associate with @@ -929,48 +1005,48 @@ struct kdbus_cmd_match { * 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 + * 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. */ -#define KDBUS_CMD_BUS_MAKE _IOW(KDBUS_IOCTL_MAGIC, 0x00, \ - struct kdbus_cmd_make) -#define KDBUS_CMD_ENDPOINT_MAKE _IOW(KDBUS_IOCTL_MAGIC, 0x10, \ - struct kdbus_cmd_make) - -#define KDBUS_CMD_HELLO _IOWR(KDBUS_IOCTL_MAGIC, 0x20, \ - struct kdbus_cmd_hello) -#define KDBUS_CMD_BYEBYE _IO(KDBUS_IOCTL_MAGIC, 0x21) \ - -#define KDBUS_CMD_MSG_SEND _IOWR(KDBUS_IOCTL_MAGIC, 0x30, \ - struct kdbus_msg) -#define KDBUS_CMD_MSG_RECV _IOWR(KDBUS_IOCTL_MAGIC, 0x31, \ - struct kdbus_cmd_recv) -#define KDBUS_CMD_MSG_CANCEL _IOW(KDBUS_IOCTL_MAGIC, 0x32, \ - struct kdbus_cmd_cancel) -#define KDBUS_CMD_FREE _IOW(KDBUS_IOCTL_MAGIC, 0x33, \ - struct kdbus_cmd_free) - -#define KDBUS_CMD_NAME_ACQUIRE _IOWR(KDBUS_IOCTL_MAGIC, 0x40, \ - struct kdbus_cmd_name) -#define KDBUS_CMD_NAME_RELEASE _IOW(KDBUS_IOCTL_MAGIC, 0x41, \ - struct kdbus_cmd_name) -#define KDBUS_CMD_NAME_LIST _IOWR(KDBUS_IOCTL_MAGIC, 0x42, \ - struct kdbus_cmd_name_list) - -#define KDBUS_CMD_CONN_INFO _IOWR(KDBUS_IOCTL_MAGIC, 0x50, \ - struct kdbus_cmd_info) -#define KDBUS_CMD_CONN_UPDATE _IOW(KDBUS_IOCTL_MAGIC, 0x51, \ - struct kdbus_cmd_update) -#define KDBUS_CMD_BUS_CREATOR_INFO _IOWR(KDBUS_IOCTL_MAGIC, 0x52, \ - struct kdbus_cmd_info) - -#define KDBUS_CMD_ENDPOINT_UPDATE _IOW(KDBUS_IOCTL_MAGIC, 0x61, \ - struct kdbus_cmd_update) - -#define KDBUS_CMD_MATCH_ADD _IOW(KDBUS_IOCTL_MAGIC, 0x70, \ - struct kdbus_cmd_match) -#define KDBUS_CMD_MATCH_REMOVE _IOW(KDBUS_IOCTL_MAGIC, 0x71, \ - struct kdbus_cmd_match) +enum kdbus_ioctl_type { + KDBUS_CMD_BUS_MAKE = _IOW(KDBUS_IOCTL_MAGIC, 0x00, + struct kdbus_cmd_make), + KDBUS_CMD_ENDPOINT_MAKE = _IOW(KDBUS_IOCTL_MAGIC, 0x10, + struct kdbus_cmd_make), + + KDBUS_CMD_HELLO = _IOWR(KDBUS_IOCTL_MAGIC, 0x20, + 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, + 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, + struct kdbus_cmd_match), + KDBUS_CMD_MATCH_REMOVE = _IOW(KDBUS_IOCTL_MAGIC, 0x71, + struct kdbus_cmd_match), +}; #endif /* _KDBUS_UAPI_H_ */