struct sd_bus

  1. struct sd_bus {
  2.     unsigned n_ref; =-1
  4.     enum bus_state state; =BUS_OPENING
  5.     int input_fd, output_fd; =-1
  6.     int inotify_fd; =-1
  7.     int message_version; =1
  8.     int message_endian;
  10.     bool can_fds:1;
  11.     bool bus_client:1;
  12.     bool ucred_valid:1;
  13.     bool is_server:1;
  14.     bool anonymous_auth:1;
  15.     bool prefer_readv:1;
  16.     bool prefer_writev:1;
  17.     bool match_callbacks_modified:1;
  18.     bool filter_callbacks_modified:1;
  19.     bool nodes_modified:1;
  20.     bool trusted:1;
  21.     bool manual_peer_interface:1;
  22.     bool is_system:1;
  23.     bool is_user:1;
  24.     bool allow_interactive_authorization:1;
  25.     bool exit_on_disconnect:1;
  26.     bool exited:1;
  27.     bool exit_triggered:1;
  28.     bool is_local:1; =true
  29.     bool watch_bind:1;
  30.     bool is_monitor:1;
  31.     bool accept_fd:1;
  32.     bool attach_timestamp:1;
  33.     bool connected_signal:1;
  34.     bool close_on_exit:1;
  36.     signed int use_memfd:2;
  38.     void *rbuffer;
  39.     size_t rbuffer_size;
  41.     sd_bus_message **rqueue;
  42.     size_t rqueue_size;
  43.     size_t rqueue_allocated;
  45.     sd_bus_message **wqueue;
  46.     size_t wqueue_size;
  47.     size_t windex;
  48.     size_t wqueue_allocated;
  50.     uint64_t cookie;
  51.     uint64_t read_counter; /* A counter for each incoming msg */
  53.     char *unique_name;
  54.     uint64_t unique_id;
  56.     struct bus_match_node match_callbacks;
  57.     Prioq *reply_callbacks_prioq;
  58.     OrderedHashmap *reply_callbacks;
  59.     LIST_HEAD(struct filter_callback, filter_callbacks);
  61.     Hashmap *nodes;
  62.     Hashmap *vtable_methods;
  63.     Hashmap *vtable_properties;
  65.     union sockaddr_union sockaddr; sockaddr.family = AF_UNIX
  66.     socklen_t sockaddr_size;
  68.     pid_t nspid;
  69.     char *machine;
  71.     sd_id128_t server_id; 
  73.     char *address; =unix:path=/run/systemd/private
  74.     unsigned address_index;
  76.     int last_connect_error;
  78.     enum bus_auth auth;
  79.     unsigned auth_index;
  80.     struct iovec auth_iovec[3];
  81.     size_t auth_rbegin;
  82.     char *auth_buffer;
  83.     usec_t auth_timeout;
  85.     struct ucred ucred;
  86.     char *label;
  87.     gid_t *groups;
  88.     size_t n_groups;
  90.     uint64_t creds_mask;=SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME
  92.     int *fds;
  93.     size_t n_fds;
  95.     char *exec_path;
  96.     char **exec_argv;
  98.     /* We do locking around the memfd cache, since we want to
  99.     * allow people to process a sd_bus_message in a different
  100.     * thread then it was generated on and free it there. Since
  101.     * adding something to the memfd cache might happen when a
  102.     * message is released, we hence need to protect this bit with
  103.     * a mutex. */
  104.     pthread_mutex_t memfd_cache_mutex;
  105.     struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
  106.     unsigned n_memfd_cache;
  108.     pid_t original_pid;
  109.     pid_t busexec_pid;
  111.     unsigned iteration_counter;
  113.     sd_event_source *input_io_event_source;
  114.     sd_event_source *output_io_event_source;
  115.     sd_event_source *time_event_source;
  116.     sd_event_source *quit_event_source;
  117.     sd_event_source *inotify_event_source;
  118.     sd_event *event;
  119.     int event_priority;
  121.     pid_t tid;
  123.     sd_bus_message *current_message;
  124.     sd_bus_slot *current_slot;
  125.     sd_bus_message_handler_t current_handler;
  126.     void *current_userdata;
  128.     sd_bus **default_bus_ptr;
  130.     char *description;
  131.     char *patch_sender;
  133.     sd_bus_track *track_queue;
  135.     LIST_HEAD(sd_bus_slot, slots);
  136.     LIST_HEAD(sd_bus_track, tracks);
  138.     int *inotify_watches;
  139.     size_t n_inotify_watches;
  141.     /* zero means use value specified by $SYSTEMD_BUS_TIMEOUT= environment variable or built-in default */
  142.     usec_t method_call_timeout;
  143. };

struct manager

  1. struct Manager {
  2.     /* Note that the set of units we know of is allowed to be
  3.     * inconsistent. However the subset of it that is loaded may
  4.     * not, and the list of jobs may neither. */
  6.     /* Active jobs and units */
  7.     Hashmap *units;  /* name string => Unit object n:1 */
  8.     Hashmap *units_by_invocation_id;
  9.     Hashmap *jobs;   /* job id => Job object 1:1 */
  11.     /* To make it easy to iterate through the units of a specific
  12.     * type we maintain a per type linked list */
  13.     LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);
  15.     /* Units that need to be loaded */
  16.     LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */
  18.     /* Jobs that need to be run */
  19.     struct Prioq *run_queue;
  21.     /* Units and jobs that have not yet been announced via
  22.     * D-Bus. When something about a job changes it is added here
  23.     * if it is not in there yet. This allows easy coalescing of
  24.     * D-Bus change signals. */
  25.     LIST_HEAD(Unit, dbus_unit_queue);
  26.     LIST_HEAD(Job, dbus_job_queue);
  28.     /* Units to remove */
  29.     LIST_HEAD(Unit, cleanup_queue);
  31.     /* Units and jobs to check when doing GC */
  32.     LIST_HEAD(Unit, gc_unit_queue);
  33.     LIST_HEAD(Job, gc_job_queue);
  35.     /* Units that should be realized */
  36.     LIST_HEAD(Unit, cgroup_realize_queue);
  38.     /* Units whose cgroup ran empty */
  39.     LIST_HEAD(Unit, cgroup_empty_queue);
  41.     /* Units whose memory.event fired */
  42.     LIST_HEAD(Unit, cgroup_oom_queue);
  44.     /* Target units whose default target dependencies haven't been set yet */
  45.     LIST_HEAD(Unit, target_deps_queue);
  47.     /* Units that might be subject to StopWhenUnneeded= clean-up */
  48.     LIST_HEAD(Unit, stop_when_unneeded_queue);
  50.     sd_event *event;
  52.     /* This maps PIDs we care about to units that are interested in. We allow multiple units to he interested in
  53.     * the same PID and multiple PIDs to be relevant to the same unit. Since in most cases only a single unit will
  54.     * be interested in the same PID we use a somewhat special encoding here: the first unit interested in a PID is
  55.     * stored directly in the hashmap, keyed by the PID unmodified. If there are other units interested too they'll
  56.     * be stored in a NULL-terminated array, and keyed by the negative PID. This is safe as pid_t is signed and
  57.     * negative PIDs are not used for regular processes but process groups, which we don't care about in this
  58.     * context, but this allows us to use the negative range for our own purposes. */
  59.     Hashmap *watch_pids;  /* pid => unit as well as -pid => array of units */
  61.     /* A set contains all units which cgroup should be refreshed after startup */
  62.     Set *startup_units;
  64.     /* A set which contains all currently failed units */
  65.     Set *failed_units;
  67.     sd_event_source *run_queue_event_source;
  69.     char *notify_socket;
  70.     int notify_fd;
  71.     sd_event_source *notify_event_source;
  73.     int cgroups_agent_fd;
  74.     sd_event_source *cgroups_agent_event_source;
  76.     int signal_fd;
  77.     sd_event_source *signal_event_source;
  79.     sd_event_source *sigchld_event_source;
  81.     int time_change_fd;
  82.     sd_event_source *time_change_event_source;
  84.     sd_event_source *timezone_change_event_source;
  86.     sd_event_source *jobs_in_progress_event_source;
  88.     int user_lookup_fds[2];
  89.     sd_event_source *user_lookup_event_source;
  91.     sd_event_source *sync_bus_names_event_source;
  93.     UnitFileScope unit_file_scope; // == UNIT_FILE_SYSTEM. setup by manager_new()
  94.     LookupPaths lookup_paths;
  95.     Hashmap *unit_id_map;
  96.     Hashmap *unit_name_map;
  97.     Set *unit_path_cache;
  98.     usec_t unit_cache_mtime;
  100.     char **transient_environment;  /* The environment, as determined from config files, kernel cmdline and environment generators */
  101.     char **client_environment;     /* Environment variables created by clients through the bus API */
  103.     usec_t runtime_watchdog;
  104.     usec_t reboot_watchdog;
  105.     usec_t kexec_watchdog;
  107.     dual_timestamp timestamps[_MANAGER_TIMESTAMP_MAX];
  109.     /* Data specific to the device subsystem */
  110.     sd_device_monitor *device_monitor;
  111.     Hashmap *devices_by_sysfs;
  113.     /* Data specific to the mount subsystem */
  114.     struct libmnt_monitor *mount_monitor;
  115.     sd_event_source *mount_event_source;
  117.     /* Data specific to the swap filesystem */
  118.     FILE *proc_swaps;
  119.     sd_event_source *swap_event_source;
  120.     Hashmap *swaps_by_devnode;
  122.     /* Data specific to the D-Bus subsystem */
  123.     sd_bus *api_bus, *system_bus;
  124.     Set *private_buses;
  125.     int private_listen_fd;
  126.     sd_event_source *private_listen_event_source;
  128.     /* Contains all the clients that are subscribed to signals via
  129.     the API bus. Note that private bus connections are always
  130.     considered subscribes, since they last for very short only,
  131.     and it is much simpler that way. */
  132.     sd_bus_track *subscribed;
  133.     char **deserialized_subscribed;
  135.     /* This is used during reloading: before the reload we queue
  136.     * the reply message here, and afterwards we send it */
  137.     sd_bus_message *pending_reload_message;
  139.     Hashmap *watch_bus;  /* D-Bus names => Unit object n:1 */
  141.     bool send_reloading_done;
  143.     uint32_t current_job_id;
  144.     uint32_t default_unit_job_id;
  146.     /* Data specific to the Automount subsystem */
  147.     int dev_autofs_fd;
  149.     /* Data specific to the cgroup subsystem */
  150.     Hashmap *cgroup_unit;
  151.     CGroupMask cgroup_supported;
  152.     char *cgroup_root;
  154.     /* Notifications from cgroups, when the unified hierarchy is used is done via inotify. */
  155.     int cgroup_inotify_fd;
  156.     sd_event_source *cgroup_inotify_event_source;
  158.     /* Maps for finding the unit for each inotify watch descriptor for the cgroup.events and
  159.     * memory.events cgroupv2 attributes. */
  160.     Hashmap *cgroup_control_inotify_wd_unit;
  161.     Hashmap *cgroup_memory_inotify_wd_unit;
  163.     /* A defer event for handling cgroup empty events and processing them after SIGCHLD in all cases. */
  164.     sd_event_source *cgroup_empty_event_source;
  165.     sd_event_source *cgroup_oom_event_source;
  167.     /* Make sure the user cannot accidentally unmount our cgroup
  168.     * file system */
  169.     int pin_cgroupfs_fd;
  171.     unsigned gc_marker;
  173.     /* The stat() data the last time we saw /etc/localtime */
  174.     usec_t etc_localtime_mtime;
  175.     bool etc_localtime_accessible:1;
  177.     ManagerObjective objective:5;    //= _MANAGER_OBJECTIVE_INVALID. setup by manager_new()
  179.     /* Flags */
  180.     bool dispatching_load_queue:1;
  182.     bool taint_usr:1;
  184.     /* Have we already sent out the READY=1 notification? */
  185.     bool ready_sent:1;
  187.     /* Have we already printed the taint line if necessary? */
  188.     bool taint_logged:1;
  190.     /* Have we ever changed the "kernel.pid_max" sysctl? */
  191.     bool sysctl_pid_max_changed:1;
  193.     ManagerTestRunFlags test_run_flags:8;
  195.     /* If non-zero, exit with the following value when the systemd
  196.     * process terminate. Useful for containers: systemd-nspawn could get
  197.     * the return value. */
  198.     uint8_t return_value;
  200.     ShowStatus show_status;
  201.     StatusUnitFormat status_unit_format;    //= STATUS_UNIT_FORMAT_DEFAULT. setup by manager_new()
  202.     char *confirm_spawn;
  203.     bool no_console_output;
  204.     bool service_watchdogs;
  206.     ExecOutput default_std_output, default_std_error;
  208.     usec_t default_restart_usec, default_timeout_start_usec, default_timeout_stop_usec;
  209.     usec_t default_timeout_abort_usec;
  210.     bool default_timeout_abort_set;
  212.     usec_t default_start_limit_interval;
  213.     unsigned default_start_limit_burst;
  215.     bool default_cpu_accounting;
  216.     bool default_memory_accounting;
  217.     bool default_io_accounting;
  218.     bool default_blockio_accounting;
  219.     bool default_tasks_accounting;
  220.     bool default_ip_accounting;
  222.     uint64_t default_tasks_max;
  223.     usec_t default_timer_accuracy_usec;
  225.     OOMPolicy default_oom_policy;
  227.     int original_log_level;
  228.     LogTarget original_log_target;
  229.     bool log_level_overridden:1;
  230.     bool log_target_overridden:1;
  232.     struct rlimit *rlimit[_RLIMIT_MAX];
  234.     /* non-zero if we are reloading or reexecuting, */
  235.     int n_reloading;
  237.     unsigned n_installed_jobs;
  238.     unsigned n_failed_jobs;
  240.     /* Jobs in progress watching */
  241.     unsigned n_running_jobs;
  242.     unsigned n_on_console;
  243.     unsigned jobs_in_progress_iteration;
  245.     /* Do we have any outstanding password prompts? */
  246.     int have_ask_password;
  247.     int ask_password_inotify_fd;
  248.     sd_event_source *ask_password_event_source;
  250.     /* Type=idle pipes */
  251.     int idle_pipe[4];
  252.     sd_event_source *idle_pipe_event_source;
  254.     char *switch_root;
  255.     char *switch_root_init;
  257.     /* This maps all possible path prefixes to the units needing
  258.     * them. It's a hashmap with a path string as key and a Set as
  259.     * value where Unit objects are contained. */
  260.     Hashmap *units_requiring_mounts_for;
  262.     /* Used for processing polkit authorization responses */
  263.     Hashmap *polkit_registry;
  265.     /* Dynamic users/groups, indexed by their name */
  266.     Hashmap *dynamic_users;
  268.     /* Keep track of all UIDs and GIDs any of our services currently use. This is useful for the RemoveIPC= logic. */
  269.     Hashmap *uid_refs;
  270.     Hashmap *gid_refs;
  272.     /* ExecRuntime, indexed by their owner unit id */
  273.     Hashmap *exec_runtime_by_id;
  275.     /* When the user hits C-A-D more than 7 times per 2s, do something immediately... */
  276.     RateLimit ctrl_alt_del_ratelimit;
  277.     EmergencyAction cad_burst_action;
  279.     const char *unit_log_field;
  280.     const char *unit_log_format_string;
  282.     const char *invocation_log_field;
  283.     const char *invocation_log_format_string;
  285.     int first_boot; /* tri-state */
  287.     /* Prefixes of e.g. RuntimeDirectory= */
  288.     char *prefix[_EXEC_DIRECTORY_TYPE_MAX];
  290.     /* Used in the SIGCHLD and sd_notify() message invocation logic to avoid that we dispatch the same event
  291.     * multiple times on the same unit. */
  292.     unsigned sigchldgen;
  293.     unsigned notifygen;
  295.     bool honor_device_enumeration;
  296. };