src/libsystemd/sd-bus/kdbus.h

   1 /*
   2  * kdbus is free software; you can redistribute it and/or modify it under
   3  * the terms of the GNU Lesser General Public License as published by the
   4  * Free Software Foundation; either version 2.1 of the License, or (at
   5  * your option) any later version.
   6  */
   7
   8 #ifndef _KDBUS_UAPI_H_
   9 #define _KDBUS_UAPI_H_
  10
  11 #include <linux/ioctl.h>
  12 #include <linux/types.h>
  13
  14 #define KDBUS_IOCTL_MAGIC               0x95
  15 #define KDBUS_SRC_ID_KERNEL             (0)
  16 #define KDBUS_DST_ID_NAME               (0)
  17 #define KDBUS_MATCH_ID_ANY              (~0ULL)
  18 #define KDBUS_DST_ID_BROADCAST          (~0ULL)
  19 #define KDBUS_FLAG_KERNEL               (1ULL << 63)
  20
  21 /**
  22  * struct kdbus_notify_id_change - name registry change message
  23  * @id:                 New or former owner of the name
  24  * @flags:              flags field from KDBUS_HELLO_*
  25  *
  26  * Sent from kernel to userspace when the owner or activator of
  27  * a well-known name changes.
  28  *
  29  * Attached to:
  30  *   KDBUS_ITEM_ID_ADD
  31  *   KDBUS_ITEM_ID_REMOVE
  32  */
  33 struct kdbus_notify_id_change {
  34         __u64 id;
  35         __u64 flags;
  36 };
  37
  38 /**
  39  * struct kdbus_notify_name_change - name registry change message
  40  * @old_id:             ID and flags of former owner of a name
  41  * @new_id:             ID and flags of new owner of a name
  42  * @name:               Well-known name
  43  *
  44  * Sent from kernel to userspace when the owner or activator of
  45  * a well-known name changes.
  46  *
  47  * Attached to:
  48  *   KDBUS_ITEM_NAME_ADD
  49  *   KDBUS_ITEM_NAME_REMOVE
  50  *   KDBUS_ITEM_NAME_CHANGE
  51  */
  52 struct kdbus_notify_name_change {
  53         struct kdbus_notify_id_change old_id;
  54         struct kdbus_notify_id_change new_id;
  55         char name[0];
  56 };
  57
  58 /**
  59  * struct kdbus_creds - process credentials
  60  * @uid:                User ID
  61  * @gid:                Group ID
  62  * @pid:                Process ID
  63  * @tid:                Thread ID
  64  * @starttime:          Starttime of the process
  65  *
  66  * The starttime of the process PID. This is useful to detect PID overruns
  67  * from the client side. i.e. if you use the PID to look something up in
  68  * /proc/$PID/ you can afterwards check the starttime field of it, to ensure
  69  * you didn't run into a PID overrun.
  70  *
  71  * Attached to:
  72  *   KDBUS_ITEM_CREDS
  73  */
  74 struct kdbus_creds {
  75         __u64 uid;
  76         __u64 gid;
  77         __u64 pid;
  78         __u64 tid;
  79         __u64 starttime;
  80 };
  81
  82 /**
  83  * struct kdbus_caps - process capabilities
  84  * @last_cap:   Highest currently known capability bit
  85  * @caps:       Variable number of 32-bit capabilities flags
  86  *
  87  * Contains a variable number of 32-bit capabilities flags.
  88  *
  89  * Attached to:
  90  *   KDBUS_ITEM_CAPS
  91  */
  92 struct kdbus_caps {
  93         __u32 last_cap;
  94         __u32 caps[0];
  95 };
  96
  97 /**
  98  * struct kdbus_audit - audit information
  99  * @sessionid:          The audit session ID
 100  * @loginuid:           The audit login uid
 101  *
 102  * Attached to:
 103  *   KDBUS_ITEM_AUDIT
 104  */
 105 struct kdbus_audit {
 106         __u64 sessionid;
 107         __u64 loginuid;
 108 };
 109
 110 /**
 111  * struct kdbus_timestamp
 112  * @seqnum:             Global per-domain message sequence number
 113  * @monotonic_ns:       Monotonic timestamp, in nanoseconds
 114  * @realtime_ns:        Realtime timestamp, in nanoseconds
 115  *
 116  * Attached to:
 117  *   KDBUS_ITEM_TIMESTAMP
 118  */
 119 struct kdbus_timestamp {
 120         __u64 seqnum;
 121         __u64 monotonic_ns;
 122         __u64 realtime_ns;
 123 };
 124
 125 /**
 126  * struct kdbus_vec - I/O vector for kdbus payload items
 127  * @size:               The size of the vector
 128  * @address:            Memory address of data buffer
 129  * @offset:             Offset in the in-message payload memory,
 130  *                      relative to the message head
 131  *
 132  * Attached to:
 133  *   KDBUS_ITEM_PAYLOAD_VEC, KDBUS_ITEM_PAYLOAD_OFF
 134  */
 135 struct kdbus_vec {
 136         __u64 size;
 137         union {
 138                 __u64 address;
 139                 __u64 offset;
 140         };
 141 };
 142
 143 /**
 144  * struct kdbus_bloom_parameter - bus-wide bloom parameters
 145  * @size:               Size of the bit field in bytes (m / 8)
 146  * @n_hash:             Number of hash functions used (k)
 147  */
 148 struct kdbus_bloom_parameter {
 149         __u64 size;
 150         __u64 n_hash;
 151 };
 152
 153 /**
 154  * struct kdbus_bloom_filter - bloom filter containing n elements
 155  * @generation:         Generation of the element set in the filter
 156  * @data:               Bit field, multiple of 8 bytes
 157  */
 158 struct kdbus_bloom_filter {
 159         __u64 generation;
 160         __u64 data[0];
 161 };
 162
 163 /**
 164  * struct kdbus_memfd - a kdbus memfd
 165  * @size:               The memfd's size
 166  * @fd:                 The file descriptor number
 167  * @__pad:              Padding to ensure proper alignment and size
 168  *
 169  * Attached to:
 170  *   KDBUS_ITEM_PAYLOAD_MEMFD
 171  */
 172 struct kdbus_memfd {
 173         __u64 size;
 174         int fd;
 175         __u32 __pad;
 176 };
 177
 178 /**
 179  * struct kdbus_name - a registered well-known name with its flags
 180  * @flags:              Flags from KDBUS_NAME_*
 181  * @name:               Well-known name
 182  *
 183  * Attached to:
 184  *   KDBUS_ITEM_NAME
 185  */
 186 struct kdbus_name {
 187         __u64 flags;
 188         char name[0];
 189 };
 190
 191 /**
 192  * struct kdbus_policy_access - policy access item
 193  * @type:               One of KDBUS_POLICY_ACCESS_* types
 194  * @access:             Access to grant
 195  * @id:                 For KDBUS_POLICY_ACCESS_USER, the uid
 196  *                      For KDBUS_POLICY_ACCESS_GROUP, the gid
 197  */
 198 struct kdbus_policy_access {
 199         __u64 type;     /* USER, GROUP, WORLD */
 200         __u64 access;   /* OWN, TALK, SEE */
 201         __u64 id;       /* uid, gid, 0 */
 202 };
 203
 204 /**
 205  * enum kdbus_item_type - item types to chain data in a list
 206  * @_KDBUS_ITEM_NULL:           Uninitialized/invalid
 207  * @_KDBUS_ITEM_USER_BASE:      Start of user items
 208  * @KDBUS_ITEM_PAYLOAD_VEC:     Vector to data
 209  * @KDBUS_ITEM_PAYLOAD_OFF:     Data at returned offset to message head
 210  * @KDBUS_ITEM_PAYLOAD_MEMFD:   Data as sealed memfd
 211  * @KDBUS_ITEM_FDS:             Attached file descriptors
 212  * @KDBUS_ITEM_BLOOM_PARAMETER: Bus-wide bloom parameters, used with
 213  *                              KDBUS_CMD_BUS_MAKE, carries a
 214  *                              struct kdbus_bloom_parameter
 215  * @KDBUS_ITEM_BLOOM_FILTER:    Bloom filter carried with a message, used to
 216  *                              match against a bloom mask of a connection,
 217  *                              carries a struct kdbus_bloom_filter
 218  * @KDBUS_ITEM_BLOOM_MASK:      Bloom mask used to match against a message's
 219  *                              bloom filter
 220  * @KDBUS_ITEM_DST_NAME:        Destination's well-known name
 221  * @KDBUS_ITEM_MAKE_NAME:       Name of domain, bus, endpoint
 222  * @KDBUS_ITEM_ATTACH_FLAGS:    Attach-flags, used for updating which metadata
 223  *                              a connection subscribes to
 224  * @_KDBUS_ITEM_ATTACH_BASE:    Start of metadata attach items
 225  * @KDBUS_ITEM_NAME:            Well-know name with flags
 226  * @KDBUS_ITEM_ID:              Connection ID
 227  * @KDBUS_ITEM_TIMESTAMP:       Timestamp
 228  * @KDBUS_ITEM_CREDS:           Process credential
 229  * @KDBUS_ITEM_AUXGROUPS:       Auxiliary process groups
 230  * @KDBUS_ITEM_PID_COMM:        Process ID "comm" identifier
 231  * @KDBUS_ITEM_TID_COMM:        Thread ID "comm" identifier
 232  * @KDBUS_ITEM_EXE:             The path of the executable
 233  * @KDBUS_ITEM_CMDLINE:         The process command line
 234  * @KDBUS_ITEM_CGROUP:          The croup membership
 235  * @KDBUS_ITEM_CAPS:            The process capabilities
 236  * @KDBUS_ITEM_SECLABEL:        The security label
 237  * @KDBUS_ITEM_AUDIT:           The audit IDs
 238  * @KDBUS_ITEM_CONN_NAME:       The connection's human-readable name (debugging)
 239  * @_KDBUS_ITEM_POLICY_BASE:    Start of policy items
 240  * @KDBUS_ITEM_POLICY_ACCESS:   Policy access block
 241  * @_KDBUS_ITEM_KERNEL_BASE:    Start of kernel-generated message items
 242  * @KDBUS_ITEM_NAME_ADD:        Notify in struct kdbus_notify_name_change
 243  * @KDBUS_ITEM_NAME_REMOVE:     Notify in struct kdbus_notify_name_change
 244  * @KDBUS_ITEM_NAME_CHANGE:     Notify in struct kdbus_notify_name_change
 245  * @KDBUS_ITEM_ID_ADD:          Notify in struct kdbus_notify_id_change
 246  * @KDBUS_ITEM_ID_REMOVE:       Notify in struct kdbus_notify_id_change
 247  * @KDBUS_ITEM_REPLY_TIMEOUT:   Timeout has been reached
 248  * @KDBUS_ITEM_REPLY_DEAD:      Destination died
 249  */
 250 enum kdbus_item_type {
 251         _KDBUS_ITEM_NULL,
 252         _KDBUS_ITEM_USER_BASE,
 253         KDBUS_ITEM_PAYLOAD_VEC  = _KDBUS_ITEM_USER_BASE,
 254         KDBUS_ITEM_PAYLOAD_OFF,
 255         KDBUS_ITEM_PAYLOAD_MEMFD,
 256         KDBUS_ITEM_FDS,
 257         KDBUS_ITEM_BLOOM_PARAMETER,
 258         KDBUS_ITEM_BLOOM_FILTER,
 259         KDBUS_ITEM_BLOOM_MASK,
 260         KDBUS_ITEM_DST_NAME,
 261         KDBUS_ITEM_MAKE_NAME,
 262         KDBUS_ITEM_ATTACH_FLAGS,
 263
 264         _KDBUS_ITEM_ATTACH_BASE = 0x1000,
 265         KDBUS_ITEM_NAME         = _KDBUS_ITEM_ATTACH_BASE,
 266         KDBUS_ITEM_ID,
 267         KDBUS_ITEM_TIMESTAMP,
 268         KDBUS_ITEM_CREDS,
 269         KDBUS_ITEM_AUXGROUPS,
 270         KDBUS_ITEM_PID_COMM,
 271         KDBUS_ITEM_TID_COMM,
 272         KDBUS_ITEM_EXE,
 273         KDBUS_ITEM_CMDLINE,
 274         KDBUS_ITEM_CGROUP,
 275         KDBUS_ITEM_CAPS,
 276         KDBUS_ITEM_SECLABEL,
 277         KDBUS_ITEM_AUDIT,
 278         KDBUS_ITEM_CONN_NAME,
 279
 280         _KDBUS_ITEM_POLICY_BASE = 0x2000,
 281         KDBUS_ITEM_POLICY_ACCESS = _KDBUS_ITEM_POLICY_BASE,
 282
 283         _KDBUS_ITEM_KERNEL_BASE = 0x8000,
 284         KDBUS_ITEM_NAME_ADD     = _KDBUS_ITEM_KERNEL_BASE,
 285         KDBUS_ITEM_NAME_REMOVE,
 286         KDBUS_ITEM_NAME_CHANGE,
 287         KDBUS_ITEM_ID_ADD,
 288         KDBUS_ITEM_ID_REMOVE,
 289         KDBUS_ITEM_REPLY_TIMEOUT,
 290         KDBUS_ITEM_REPLY_DEAD,
 291 };
 292
 293 /**
 294  * struct kdbus_item - chain of data blocks
 295  * @size:               Overall data record size
 296  * @type:               Kdbus_item type of data
 297  * @data:               Generic bytes
 298  * @data32:             Generic 32 bit array
 299  * @data64:             Generic 64 bit array
 300  * @str:                Generic string
 301  * @id:                 Connection ID
 302  * @vec:                KDBUS_ITEM_PAYLOAD_VEC
 303  * @creds:              KDBUS_ITEM_CREDS
 304  * @audit:              KDBUS_ITEM_AUDIT
 305  * @timestamp:          KDBUS_ITEM_TIMESTAMP
 306  * @name:               KDBUS_ITEM_NAME
 307  * @bloom_parameter:    KDBUS_ITEM_BLOOM_PARAMETER
 308  * @bloom_filter:       KDBUS_ITEM_BLOOM_FILTER
 309  * @memfd:              KDBUS_ITEM_PAYLOAD_MEMFD
 310  * @name_change:        KDBUS_ITEM_NAME_ADD
 311  *                      KDBUS_ITEM_NAME_REMOVE
 312  *                      KDBUS_ITEM_NAME_CHANGE
 313  * @id_change:          KDBUS_ITEM_ID_ADD
 314  *                      KDBUS_ITEM_ID_REMOVE
 315  * @policy:             KDBUS_ITEM_POLICY_ACCESS
 316  */
 317 struct kdbus_item {
 318         __u64 size;
 319         __u64 type;
 320         union {
 321                 __u8 data[0];
 322                 __u32 data32[0];
 323                 __u64 data64[0];
 324                 char str[0];
 325
 326                 __u64 id;
 327                 struct kdbus_vec vec;
 328                 struct kdbus_creds creds;
 329                 struct kdbus_audit audit;
 330                 struct kdbus_caps caps;
 331                 struct kdbus_timestamp timestamp;
 332                 struct kdbus_name name;
 333                 struct kdbus_bloom_parameter bloom_parameter;
 334                 struct kdbus_bloom_filter bloom_filter;
 335                 struct kdbus_memfd memfd;
 336                 int fds[0];
 337                 struct kdbus_notify_name_change name_change;
 338                 struct kdbus_notify_id_change id_change;
 339                 struct kdbus_policy_access policy_access;
 340         };
 341 };
 342
 343 /**
 344  * enum kdbus_msg_flags - type of message
 345  * @KDBUS_MSG_FLAGS_EXPECT_REPLY:       Expect a reply message, used for
 346  *                                      method calls. The userspace-supplied
 347  *                                      cookie identifies the message and the
 348  *                                      respective reply carries the cookie
 349  *                                      in cookie_reply
 350  * @KDBUS_MSG_FLAGS_SYNC_REPLY:         Wait for destination connection to
 351  *                                      reply to this message. The
 352  *                                      KDBUS_CMD_MSG_SEND ioctl() will block
 353  *                                      until the reply is received, and
 354  *                                      offset_reply in struct kdbus_msg will
 355  *                                      yield the offset in the sender's pool
 356  *                                      where the reply can be found.
 357  *                                      This flag is only valid if
 358  *                                      @KDBUS_MSG_FLAGS_EXPECT_REPLY is set as
 359  *                                      well.
 360  * @KDBUS_MSG_FLAGS_NO_AUTO_START:      Do not start a service, if the addressed
 361  *                                      name is not currently active
 362  */
 363 enum kdbus_msg_flags {
 364         KDBUS_MSG_FLAGS_EXPECT_REPLY    = 1ULL << 0,
 365         KDBUS_MSG_FLAGS_SYNC_REPLY      = 1ULL << 1,
 366         KDBUS_MSG_FLAGS_NO_AUTO_START   = 1ULL << 2,
 367 };
 368
 369 /**
 370  * enum kdbus_payload_type - type of payload carried by message
 371  * @KDBUS_PAYLOAD_KERNEL:       Kernel-generated simple message
 372  * @KDBUS_PAYLOAD_DBUS:         D-Bus marshalling "DBusDBus"
 373  */
 374 enum kdbus_payload_type {
 375         KDBUS_PAYLOAD_KERNEL,
 376         KDBUS_PAYLOAD_DBUS      = 0x4442757344427573ULL,
 377 };
 378
 379 /**
 380  * struct kdbus_msg - the representation of a kdbus message
 381  * @size:               Total size of the message
 382  * @flags:              Message flags (KDBUS_MSG_FLAGS_*), userspace → kernel
 383  * @kernel_flags:       Supported message flags, kernel → userspace
 384  * @priority:           Message queue priority value
 385  * @dst_id:             64-bit ID of the destination connection
 386  * @src_id:             64-bit ID of the source connection
 387  * @payload_type:       Payload type (KDBUS_PAYLOAD_*)
 388  * @cookie:             Userspace-supplied cookie, for the connection
 389  *                      to identify its messages
 390  * @timeout_ns:         The time to wait for a message reply from the peer.
 391  *                      If there is no reply, a kernel-generated message
 392  *                      with an attached KDBUS_ITEM_REPLY_TIMEOUT item
 393  *                      is sent to @src_id. The timeout is expected in
 394  *                      nanoseconds and as absolute CLOCK_MONOTONIC value.
 395  * @cookie_reply:       A reply to the requesting message with the same
 396  *                      cookie. The requesting connection can match its
 397  *                      request and the reply with this value
 398  * @offset_reply:       If KDBUS_MSG_FLAGS_EXPECT_REPLY, this field will
 399  *                      contain the offset in the sender's pool where the
 400  *                      reply is stored.
 401  * @items:              A list of kdbus_items containing the message payload
 402  */
 403 struct kdbus_msg {
 404         __u64 size;
 405         __u64 flags;
 406         __u64 kernel_flags;
 407         __s64 priority;
 408         __u64 dst_id;
 409         __u64 src_id;
 410         __u64 payload_type;
 411         __u64 cookie;
 412         union {
 413                 __u64 timeout_ns;
 414                 __u64 cookie_reply;
 415                 __u64 offset_reply;
 416         };
 417         struct kdbus_item items[0];
 418 } __attribute__((aligned(8)));
 419
 420 /**
 421  * enum kdbus_recv_flags - flags for de-queuing messages
 422  * @KDBUS_RECV_PEEK:            Return the next queued message without
 423  *                              actually de-queuing it, and without installing
 424  *                              any file descriptors or other resources. It is
 425  *                              usually used to determine the activating
 426  *                              connection of a bus name.
 427  * @KDBUS_RECV_DROP:            Drop and free the next queued message and all
 428  *                              its resources without actually receiving it.
 429  * @KDBUS_RECV_USE_PRIORITY:    Only de-queue messages with the specified or
 430  *                              higher priority (lowest values); if not set,
 431  *                              the priority value is ignored.
 432  */
 433 enum kdbus_recv_flags {
 434         KDBUS_RECV_PEEK         = 1ULL <<  0,
 435         KDBUS_RECV_DROP         = 1ULL <<  1,
 436         KDBUS_RECV_USE_PRIORITY = 1ULL <<  2,
 437 };
 438
 439 /**
 440  * struct kdbus_cmd_recv - struct to de-queue a buffered message
 441  * @flags:              KDBUS_RECV_* flags, userspace → kernel
 442  * @kernel_flags:       Supported KDBUS_RECV_* flags, kernel → userspace
 443  * @priority:           Minimum priority of the messages to de-queue. Lowest
 444  *                      values have the highest priority.
 445  * @offset:             Returned offset in the pool where the message is
 446  *                      stored. The user must use KDBUS_CMD_FREE to free
 447  *                      the allocated memory.
 448  *
 449  * This struct is used with the KDBUS_CMD_MSG_RECV ioctl.
 450  */
 451 struct kdbus_cmd_recv {
 452         __u64 flags;
 453         __u64 kernel_flags;
 454         __s64 priority;
 455         __u64 offset;
 456 } __attribute__((aligned(8)));
 457
 458 /**
 459  * struct kdbus_cmd_cancel - struct to cancel a synchronously pending message
 460  * @cookie              The cookie of the pending message
 461  * @flags               Flags for the free command. Currently unused.
 462  *
 463  * This struct is used with the KDBUS_CMD_CANCEL ioctl.
 464  */
 465 struct kdbus_cmd_cancel {
 466         __u64 cookie;
 467         __u64 flags;
 468 } __attribute__((aligned(8)));
 469
 470 /**
 471  * struct kdbus_cmd_free - struct to free a slice of memory in the pool
 472  * @offset:             The offset of the memory slice, as returned by other
 473  *                      ioctls
 474  * @flags:              Flags for the free command, userspace → kernel
 475  * @kernel_flags:       Supported flags of the free command, userspace → kernel
 476  *
 477  * This struct is used with the KDBUS_CMD_FREE ioctl.
 478  */
 479 struct kdbus_cmd_free {
 480         __u64 offset;
 481         __u64 flags;
 482         __u64 kernel_flags;
 483 } __attribute__((aligned(8)));
 484
 485 /**
 486  * enum kdbus_policy_access_type - permissions of a policy record
 487  * @_KDBUS_POLICY_ACCESS_NULL:  Uninitialized/invalid
 488  * @KDBUS_POLICY_ACCESS_USER:   Grant access to a uid
 489  * @KDBUS_POLICY_ACCESS_GROUP:  Grant access to gid
 490  * @KDBUS_POLICY_ACCESS_WORLD:  World-accessible
 491  */
 492 enum kdbus_policy_access_type {
 493         _KDBUS_POLICY_ACCESS_NULL,
 494         KDBUS_POLICY_ACCESS_USER,
 495         KDBUS_POLICY_ACCESS_GROUP,
 496         KDBUS_POLICY_ACCESS_WORLD,
 497 };
 498
 499 /**
 500  * enum kdbus_policy_access_flags - mode flags
 501  * @KDBUS_POLICY_OWN:           Allow to own a well-known name
 502  *                              Implies KDBUS_POLICY_TALK and KDBUS_POLICY_SEE
 503  * @KDBUS_POLICY_TALK:          Allow communication to a well-known name
 504  *                              Implies KDBUS_POLICY_SEE
 505  * @KDBUS_POLICY_SEE:           Allow to see a well-known name
 506  */
 507 enum kdbus_policy_type {
 508         KDBUS_POLICY_SEE        = 0,
 509         KDBUS_POLICY_TALK,
 510         KDBUS_POLICY_OWN,
 511 };
 512
 513 /**
 514  * enum kdbus_hello_flags - flags for struct kdbus_cmd_hello
 515  * @KDBUS_HELLO_ACCEPT_FD:      The connection allows the reception of
 516  *                              any passed file descriptors
 517  * @KDBUS_HELLO_ACTIVATOR:      Special-purpose connection which registers
 518  *                              a well-know name for a process to be started
 519  *                              when traffic arrives
 520  * @KDBUS_HELLO_POLICY_HOLDER:  Special-purpose connection which registers
 521  *                              policy entries for a name. The provided name
 522  *                              is not activated and not registered with the
 523  *                              name database, it only allows unprivileged
 524  *                              connections to aquire a name, talk or discover
 525  *                              a service
 526  * @KDBUS_HELLO_MONITOR:        Special-purpose connection to monitor
 527  *                              bus traffic
 528  */
 529 enum kdbus_hello_flags {
 530         KDBUS_HELLO_ACCEPT_FD           =  1ULL <<  0,
 531         KDBUS_HELLO_ACTIVATOR           =  1ULL <<  1,
 532         KDBUS_HELLO_POLICY_HOLDER       =  1ULL <<  2,
 533         KDBUS_HELLO_MONITOR             =  1ULL <<  3,
 534 };
 535
 536 /**
 537  * enum kdbus_attach_flags - flags for metadata attachments
 538  * @KDBUS_ATTACH_TIMESTAMP:     Timestamp
 539  * @KDBUS_ATTACH_CREDS:         Credentials
 540  * @KDBUS_ATTACH_AUXGROUPS:     Auxiliary groups
 541  * @KDBUS_ATTACH_NAMES:         Well-known names
 542  * @KDBUS_ATTACH_COMM_TID:      The "comm" process identifier of the TID
 543  * @KDBUS_ATTACH_COMM_PID:      The "comm" process identifier of the PID
 544  * @KDBUS_ATTACH_EXE:           The path of the executable
 545  * @KDBUS_ATTACH_CMDLINE:       The process command line
 546  * @KDBUS_ATTACH_CGROUP:        The croup membership
 547  * @KDBUS_ATTACH_CAPS:          The process capabilities
 548  * @KDBUS_ATTACH_SECLABEL:      The security label
 549  * @KDBUS_ATTACH_AUDIT:         The audit IDs
 550  * @KDBUS_ATTACH_CONN_NAME:     The human-readable connection name
 551  * @_KDBUS_ATTACH_ALL:          All of the above
 552  */
 553 enum kdbus_attach_flags {
 554         KDBUS_ATTACH_TIMESTAMP          =  1ULL <<  0,
 555         KDBUS_ATTACH_CREDS              =  1ULL <<  1,
 556         KDBUS_ATTACH_AUXGROUPS          =  1ULL <<  2,
 557         KDBUS_ATTACH_NAMES              =  1ULL <<  3,
 558         KDBUS_ATTACH_TID_COMM           =  1ULL <<  4,
 559         KDBUS_ATTACH_PID_COMM           =  1ULL <<  5,
 560         KDBUS_ATTACH_EXE                =  1ULL <<  6,
 561         KDBUS_ATTACH_CMDLINE            =  1ULL <<  7,
 562         KDBUS_ATTACH_CGROUP             =  1ULL <<  8,
 563         KDBUS_ATTACH_CAPS               =  1ULL <<  9,
 564         KDBUS_ATTACH_SECLABEL           =  1ULL << 10,
 565         KDBUS_ATTACH_AUDIT              =  1ULL << 11,
 566         KDBUS_ATTACH_CONN_NAME          =  1ULL << 12,
 567         _KDBUS_ATTACH_ALL               =  (1ULL << 13) - 1,
 568 };
 569
 570 /**
 571  * struct kdbus_cmd_hello - struct to say hello to kdbus
 572  * @size:               The total size of the structure
 573  * @flags:              Connection flags (KDBUS_HELLO_*), userspace → kernel
 574  * @kernel_flags:       Supported connection flags, kernel → userspace
 575  * @attach_flags:       Mask of metadata to attach to each message sent
 576  *                      (KDBUS_ATTACH_*)
 577  * @bus_flags:          The flags field copied verbatim from the original
 578  *                      KDBUS_CMD_BUS_MAKE ioctl. It's intended to be useful
 579  *                      to do negotiation of features of the payload that is
 580  *                      transferred (kernel → userspace)
 581  * @id:                 The ID of this connection (kernel → userspace)
 582  * @pool_size:          Size of the connection's buffer where the received
 583  *                      messages are placed
 584  * @bloom:              The bloom properties of the bus, specified
 585  *                      by the bus creator (kernel → userspace)
 586  * @id128:              Unique 128-bit ID of the bus (kernel → userspace)
 587  * @items:              A list of items
 588  *
 589  * This struct is used with the KDBUS_CMD_HELLO ioctl.
 590  */
 591 struct kdbus_cmd_hello {
 592         __u64 size;
 593         __u64 flags;
 594         __u64 kernel_flags;
 595         __u64 attach_flags;
 596         __u64 bus_flags;
 597         __u64 id;
 598         __u64 pool_size;
 599         struct kdbus_bloom_parameter bloom;
 600         __u8 id128[16];
 601         struct kdbus_item items[0];
 602 } __attribute__((aligned(8)));
 603
 604 /**
 605  * enum kdbus_make_flags - Flags for KDBUS_CMD_{BUS,EP,NS}_MAKE
 606  * @KDBUS_MAKE_ACCESS_GROUP:    Make the device node group-accessible
 607  * @KDBUS_MAKE_ACCESS_WORLD:    Make the device node world-accessible
 608  */
 609 enum kdbus_make_flags {
 610         KDBUS_MAKE_ACCESS_GROUP         = 1ULL <<  0,
 611         KDBUS_MAKE_ACCESS_WORLD         = 1ULL <<  1,
 612 };
 613
 614 /**
 615  * struct kdbus_cmd_make - struct to make a bus, an endpoint or a domain
 616  * @size:               The total size of the struct
 617  * @flags:              Properties for the bus/ep/domain to create,
 618  *                      userspace → kernel
 619  * @kernel_flags:       Supported flags for the used command, kernel → userspace
 620  * @items:              Items describing details
 621  *
 622  * This structure is used with the KDBUS_CMD_BUS_MAKE, KDBUS_CMD_ENDPOINT_MAKE
 623  * and KDBUS_CMD_DOMAIN_MAKE ioctls.
 624  */
 625 struct kdbus_cmd_make {
 626         __u64 size;
 627         __u64 flags;
 628         __u64 kernel_flags;
 629         struct kdbus_item items[0];
 630 } __attribute__((aligned(8)));
 631
 632 /**
 633  * enum kdbus_name_flags - properties of a well-known name
 634  * @KDBUS_NAME_REPLACE_EXISTING:        Try to replace name of other connections
 635  * @KDBUS_NAME_ALLOW_REPLACEMENT:       Allow the replacement of the name
 636  * @KDBUS_NAME_QUEUE:                   Name should be queued if busy
 637  * @KDBUS_NAME_IN_QUEUE:                Name is queued
 638  * @KDBUS_NAME_ACTIVATOR:               Name is owned by a activator connection
 639  */
 640 enum kdbus_name_flags {
 641         KDBUS_NAME_REPLACE_EXISTING     = 1ULL <<  0,
 642         KDBUS_NAME_ALLOW_REPLACEMENT    = 1ULL <<  1,
 643         KDBUS_NAME_QUEUE                = 1ULL <<  2,
 644         KDBUS_NAME_IN_QUEUE             = 1ULL <<  3,
 645         KDBUS_NAME_ACTIVATOR            = 1ULL <<  4,
 646 };
 647
 648 /**
 649  * struct kdbus_cmd_name - struct to describe a well-known name
 650  * @size:               The total size of the struct
 651  * @flags:              Flags for a name entry (KDBUS_NAME_*),
 652  *                      userspace → kernel, kernel → userspace
 653  * @kernel_flags:       Supported flags for a name entry, kernel → userspace
 654  * @items:              Item list, containing the well-known name as
 655  *                      KDBUS_ITEM_NAME
 656  *
 657  * This structure is used with the KDBUS_CMD_NAME_ACQUIRE ioctl.
 658  */
 659 struct kdbus_cmd_name {
 660         __u64 size;
 661         __u64 flags;
 662         __u64 kernel_flags;
 663         struct kdbus_item items[0];
 664 } __attribute__((aligned(8)));
 665
 666 /**
 667  * struct kdbus_name_info - struct to describe a well-known name
 668  * @size:               The total size of the struct
 669  * @flags:              Flags for a name entry (KDBUS_NAME_*),
 670  * @conn_flags:         The flags of the owning connection (KDBUS_HELLO_*)
 671  * @owner_id:           The current owner of the name
 672  * @items:              Item list, containing the well-known name as
 673  *                      KDBUS_ITEM_NAME
 674  *
 675  * This structure is used as return struct for the KDBUS_CMD_NAME_LIST ioctl.
 676  */
 677 struct kdbus_name_info {
 678         __u64 size;
 679         __u64 flags;
 680         __u64 conn_flags;
 681         __u64 owner_id;
 682         struct kdbus_item items[0];
 683 } __attribute__((aligned(8)));
 684
 685 /**
 686  * enum kdbus_name_list_flags - what to include into the returned list
 687  * @KDBUS_NAME_LIST_UNIQUE:     All active connections
 688  * @KDBUS_NAME_LIST_NAMES:      All known well-known names
 689  * @KDBUS_NAME_LIST_ACTIVATORS: All activator connections
 690  * @KDBUS_NAME_LIST_QUEUED:     All queued-up names
 691  */
 692 enum kdbus_name_list_flags {
 693         KDBUS_NAME_LIST_UNIQUE          = 1ULL <<  0,
 694         KDBUS_NAME_LIST_NAMES           = 1ULL <<  1,
 695         KDBUS_NAME_LIST_ACTIVATORS      = 1ULL <<  2,
 696         KDBUS_NAME_LIST_QUEUED          = 1ULL <<  3,
 697 };
 698
 699 /**
 700  * struct kdbus_cmd_name_list - request a list of name entries
 701  * @flags:              Flags for the query (KDBUS_NAME_LIST_*),
 702  *                      userspace → kernel
 703  * @kernel_flags:       Supported flags for queries, kernel → userspace
 704  * @offset:             The returned offset in the caller's pool buffer.
 705  *                      The user must use KDBUS_CMD_FREE to free the
 706  *                      allocated memory.
 707  *
 708  * This structure is used with the KDBUS_CMD_NAME_LIST ioctl.
 709  */
 710 struct kdbus_cmd_name_list {
 711         __u64 flags;
 712         __u64 kernel_flags;
 713         __u64 offset;
 714 } __attribute__((aligned(8)));
 715
 716 /**
 717  * struct kdbus_name_list - information returned by KDBUS_CMD_NAME_LIST
 718  * @size:               The total size of the structure
 719  * @names:              A list of names
 720  *
 721  * Note that the user is responsible for freeing the allocated memory with
 722  * the KDBUS_CMD_FREE ioctl.
 723  */
 724 struct kdbus_name_list {
 725         __u64 size;
 726         struct kdbus_name_info names[0];
 727 };
 728
 729 /**
 730  * struct kdbus_cmd_info - struct used for KDBUS_CMD_CONN_INFO ioctl
 731  * @size:               The total size of the struct
 732  * @flags:              KDBUS_ATTACH_* flags, userspace → kernel
 733  * @kernel_flags:       Supported KDBUS_ATTACH_* flags, kernel → userspace
 734  * @id:                 The 64-bit ID of the connection. If set to zero, passing
 735  *                      @name is required. kdbus will look up the name to
 736  *                      determine the ID in this case.
 737  * @offset:             Returned offset in the caller's pool buffer where the
 738  *                      kdbus_info struct result is stored. The user must
 739  *                      use KDBUS_CMD_FREE to free the allocated memory.
 740  * @items:              The optional item list, containing the
 741  *                      well-known name to look up as a KDBUS_ITEM_NAME.
 742  *                      Only needed in case @id is zero.
 743  *
 744  * On success, the KDBUS_CMD_CONN_INFO ioctl will return 0 and @offset will
 745  * tell the user the offset in the connection pool buffer at which to find the
 746  * result in a struct kdbus_info.
 747  */
 748 struct kdbus_cmd_info {
 749         __u64 size;
 750         __u64 flags;
 751         __u64 kernel_flags;
 752         __u64 id;
 753         __u64 offset;
 754         struct kdbus_item items[0];
 755 } __attribute__((aligned(8)));
 756
 757 /**
 758  * struct kdbus_info - information returned by KDBUS_CMD_*_INFO
 759  * @size:               The total size of the struct
 760  * @id:                 The connection's or bus' 64-bit ID
 761  * @flags:              The connection's or bus' flags
 762  * @items:              A list of struct kdbus_item
 763  *
 764  * Note that the user is responsible for freeing the allocated memory with
 765  * the KDBUS_CMD_FREE ioctl.
 766  */
 767 struct kdbus_info {
 768         __u64 size;
 769         __u64 id;
 770         __u64 flags;
 771         struct kdbus_item items[0];
 772 };
 773
 774 /**
 775  * struct kdbus_cmd_update - update flags of a connection
 776  * @size:               The total size of the struct
 777  * @flags:              Flags for the update command, userspace → kernel
 778  * @kernel_flags:       Supported flags for this command, kernel → userspace
 779  * @items:              A list of struct kdbus_item
 780  *
 781  * This struct is used with the KDBUS_CMD_CONN_UPDATE ioctl.
 782  */
 783 struct kdbus_cmd_update {
 784         __u64 size;
 785         __u64 flags;
 786         __u64 kernel_flags;
 787         struct kdbus_item items[0];
 788 } __attribute__((aligned(8)));
 789
 790 /**
 791  * enum kdbus_cmd_match_flags - flags to control the KDBUS_CMD_MATCH_ADD ioctl
 792  * @KDBUS_MATCH_REPLACE:        If entries with the supplied cookie already
 793  *                              exists, remove them before installing the new
 794  *                              matches.
 795  */
 796 enum kdbus_cmd_match_flags {
 797         KDBUS_MATCH_REPLACE     = 1ULL <<  0,
 798 };
 799
 800 /**
 801  * struct kdbus_cmd_match - struct to add or remove matches
 802  * @size:               The total size of the struct
 803  * @cookie:             Userspace supplied cookie. When removing, the cookie
 804  *                      identifies the match to remove
 805  * @flags:              Flags for match command (KDBUS_MATCH_*),
 806  *                      userspace → kernel
 807  * @kernel_flags:       Supported flags of the used command, kernel → userspace
 808  * @items:              A list of items for additional information
 809  *
 810  * This structure is used with the KDBUS_CMD_MATCH_ADD and
 811  * KDBUS_CMD_MATCH_REMOVE ioctl.
 812  */
 813 struct kdbus_cmd_match {
 814         __u64 size;
 815         __u64 cookie;
 816         __u64 flags;
 817         __u64 kernel_flags;
 818         struct kdbus_item items[0];
 819 } __attribute__((aligned(8)));
 820
 821 /**
 822  * enum kdbus_ioctl_type - Ioctl API
 823  * @KDBUS_CMD_BUS_MAKE:         After opening the "control" device node, this
 824  *                              command creates a new bus with the specified
 825  *                              name. The bus is immediately shut down and
 826  *                              cleaned up when the opened "control" device node
 827  *                              is closed.
 828  * @KDBUS_CMD_DOMAIN_MAKE:      Similar to KDBUS_CMD_BUS_MAKE, but it creates a
 829  *                              new kdbus domain.
 830  * @KDBUS_CMD_ENDPOINT_MAKE:    Creates a new named special endpoint to talk to
 831  *                              the bus. Such endpoints usually carry a more
 832  *                              restrictive policy and grant restricted access
 833  *                              to specific applications.
 834  * @KDBUS_CMD_HELLO:            By opening the bus device node a connection is
 835  *                              created. After a HELLO the opened connection
 836  *                              becomes an active peer on the bus.
 837  * @KDBUS_CMD_BYEBYE:           Disconnect a connection. If there are no
 838  *                              messages queued up in the connection's pool,
 839  *                              the call succeeds, and the handle is rendered
 840  *                              unusable. Otherwise, -EBUSY is returned without
 841  *                              any further side-effects.
 842  * @KDBUS_CMD_MSG_SEND:         Send a message and pass data from userspace to
 843  *                              the kernel.
 844  * @KDBUS_CMD_MSG_RECV:         Receive a message from the kernel which is
 845  *                              placed in the receiver's pool.
 846  * @KDBUS_CMD_MSG_CANCEL:       Cancel a pending request of a message that
 847  *                              blocks while waiting for a reply. The parameter
 848  *                              denotes the cookie of the message in flight.
 849  * @KDBUS_CMD_FREE:             Release the allocated memory in the receiver's
 850  *                              pool.
 851  * @KDBUS_CMD_NAME_ACQUIRE:     Request a well-known bus name to associate with
 852  *                              the connection. Well-known names are used to
 853  *                              address a peer on the bus.
 854  * @KDBUS_CMD_NAME_RELEASE:     Release a well-known name the connection
 855  *                              currently owns.
 856  * @KDBUS_CMD_NAME_LIST:        Retrieve the list of all currently registered
 857  *                              well-known and unique names.
 858  * @KDBUS_CMD_CONN_INFO:        Retrieve credentials and properties of the
 859  *                              initial creator of the connection. The data was
 860  *                              stored at registration time and does not
 861  *                              necessarily represent the connected process or
 862  *                              the actual state of the process.
 863  * @KDBUS_CMD_CONN_UPDATE:      Update the properties of a connection. Used to
 864  *                              update the metadata subscription mask and
 865  *                              policy.
 866  * @KDBUS_CMD_BUS_CREATOR_INFO: Retrieve information of the creator of the bus
 867  *                              a connection is attached to.
 868  * @KDBUS_CMD_ENDPOINT_UPDATE:  Update the properties of a custom enpoint. Used
 869  *                              to update the policy.
 870  * @KDBUS_CMD_MATCH_ADD:        Install a match which broadcast messages should
 871  *                              be delivered to the connection.
 872  * @KDBUS_CMD_MATCH_REMOVE:     Remove a current match for broadcast messages.
 873  */
 874 enum kdbus_ioctl_type {
 875         KDBUS_CMD_BUS_MAKE =            _IOW(KDBUS_IOCTL_MAGIC, 0x00,
 876                                              struct kdbus_cmd_make),
 877         KDBUS_CMD_DOMAIN_MAKE =         _IOW(KDBUS_IOCTL_MAGIC, 0x10,
 878                                              struct kdbus_cmd_make),
 879         KDBUS_CMD_ENDPOINT_MAKE =       _IOW(KDBUS_IOCTL_MAGIC, 0x20,
 880                                              struct kdbus_cmd_make),
 881
 882         KDBUS_CMD_HELLO =               _IOWR(KDBUS_IOCTL_MAGIC, 0x30,
 883                                               struct kdbus_cmd_hello),
 884         KDBUS_CMD_BYEBYE =              _IO(KDBUS_IOCTL_MAGIC, 0x31),
 885
 886         KDBUS_CMD_MSG_SEND =            _IOWR(KDBUS_IOCTL_MAGIC, 0x40,
 887                                               struct kdbus_msg),
 888         KDBUS_CMD_MSG_RECV =            _IOWR(KDBUS_IOCTL_MAGIC, 0x41,
 889                                               struct kdbus_cmd_recv),
 890         KDBUS_CMD_MSG_CANCEL =          _IOW(KDBUS_IOCTL_MAGIC, 0x42,
 891                                              struct kdbus_cmd_cancel),
 892         KDBUS_CMD_FREE =                _IOW(KDBUS_IOCTL_MAGIC, 0x43,
 893                                              struct kdbus_cmd_free),
 894
 895         KDBUS_CMD_NAME_ACQUIRE =        _IOWR(KDBUS_IOCTL_MAGIC, 0x50,
 896                                               struct kdbus_cmd_name),
 897         KDBUS_CMD_NAME_RELEASE =        _IOW(KDBUS_IOCTL_MAGIC, 0x51,
 898                                              struct kdbus_cmd_name),
 899         KDBUS_CMD_NAME_LIST =           _IOWR(KDBUS_IOCTL_MAGIC, 0x52,
 900                                               struct kdbus_cmd_name_list),
 901
 902         KDBUS_CMD_CONN_INFO =           _IOWR(KDBUS_IOCTL_MAGIC, 0x60,
 903                                               struct kdbus_cmd_info),
 904         KDBUS_CMD_CONN_UPDATE =         _IOW(KDBUS_IOCTL_MAGIC, 0x61,
 905                                              struct kdbus_cmd_update),
 906         KDBUS_CMD_BUS_CREATOR_INFO =    _IOWR(KDBUS_IOCTL_MAGIC, 0x62,
 907                                               struct kdbus_cmd_info),
 908
 909         KDBUS_CMD_ENDPOINT_UPDATE =     _IOW(KDBUS_IOCTL_MAGIC, 0x71,
 910                                              struct kdbus_cmd_update),
 911
 912         KDBUS_CMD_MATCH_ADD =           _IOW(KDBUS_IOCTL_MAGIC, 0x80,
 913                                              struct kdbus_cmd_match),
 914         KDBUS_CMD_MATCH_REMOVE =        _IOW(KDBUS_IOCTL_MAGIC, 0x81,
 915                                              struct kdbus_cmd_match),
 916 };
 917
 918 #endif /* _KDBUS_UAPI_H_ */