HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/import/importd.c

76,042 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 00d52b3f46be75346d5aeccc6ecd0ec4a0bec147

Lines 2001–2145 of 2,145

        int r;
 
        assert(m);
        assert(m->event);
        assert(!m->varlink_server);
 
        r = varlink_server_new(
                        &m->varlink_server,
                        (m->runtime_scope != RUNTIME_SCOPE_USER ? SD_VARLINK_SERVER_ACCOUNT_UID : 0)|
                        SD_VARLINK_SERVER_INHERIT_USERDATA,
                        m);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate varlink server object: %m");
 
        r = sd_varlink_server_add_interface_many(
                        m->varlink_server,
                        &vl_interface_io_systemd_Import,
                        &vl_interface_io_systemd_service);
        if (r < 0)
                return log_error_errno(r, "Failed to add Import interface to varlink server: %m");
 
        r = sd_varlink_server_bind_method_many(
                        m->varlink_server,
                        "io.systemd.Import.ListTransfers",   vl_method_list_transfers,
                        "io.systemd.Import.Pull",            vl_method_pull,
                        "io.systemd.service.Ping",           varlink_method_ping,
                        "io.systemd.service.SetLogLevel",    varlink_method_set_log_level,
                        "io.systemd.service.GetLogLevel",    varlink_method_get_log_level,
                        "io.systemd.service.GetEnvironment", varlink_method_get_environment);
        if (r < 0)
                return log_error_errno(r, "Failed to bind Varlink method calls: %m");
 
        r = sd_varlink_server_attach_event(m->varlink_server, m->event, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return log_error_errno(r, "Failed to attach Varlink server to event loop: %m");
 
        r = sd_varlink_server_listen_auto(m->varlink_server);
        if (r < 0)
                return log_error_errno(r, "Failed to bind to passed Varlink sockets: %m");
        if (r == 0) {
                _cleanup_free_ char *socket_path = NULL;
                r = runtime_directory_generic(m->runtime_scope, "systemd/io.systemd.Import", &socket_path);
                if (r < 0)
                        return log_error_errno(r, "Failed to determine socket path: %m");
 
                r = sd_varlink_server_listen_address(m->varlink_server, socket_path, runtime_scope_to_socket_mode(m->runtime_scope) | SD_VARLINK_SERVER_MODE_MKDIR_0755);
                if (r < 0)
                        return log_error_errno(r, "Failed to bind to Varlink socket: %m");
        }
 
        return 0;
}
 
static bool manager_check_idle(void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        return hashmap_isempty(m->transfers) &&
                hashmap_isempty(m->polkit_registry) &&
                sd_varlink_server_current_connections(m->varlink_server) == 0;
}
 
static void manager_parse_env(Manager *m) {
        int r;
 
        assert(m);
 
        /* Same as src/import/{import,pull}.c:
         * Let's make these relatively low-level settings also controllable via env vars. User can then set
         * them for systemd-importd.service if they like to tweak behaviour */
 
        r = getenv_bool("SYSTEMD_IMPORT_BTRFS_SUBVOL");
        if (r >= 0)
                m->use_btrfs_subvol = r;
        else if (r != -ENXIO)
                log_warning_errno(r, "Failed to parse $SYSTEMD_IMPORT_BTRFS_SUBVOL: %m");
 
        r = getenv_bool("SYSTEMD_IMPORT_BTRFS_QUOTA");
        if (r >= 0)
                m->use_btrfs_quota = r;
        else if (r != -ENXIO)
                log_warning_errno(r, "Failed to parse $SYSTEMD_IMPORT_BTRFS_QUOTA: %m");
}
 
COMMAND(
        "systemd-importd\0",
        "Import and export VM and container images.",
        .man_pages = "systemd-importd.service(8)\0",
        .option_namespace = "service",
        .option_groups =
                "Options\0"
                "Bus introspection\0"
                "Runtime scope\0",
);
 
static int run(int argc, char *argv[]) {
        _cleanup_(manager_unrefp) Manager *m = NULL;
        RuntimeScope scope = RUNTIME_SCOPE_SYSTEM;
        int r;
 
        LIBSELINUX_NOTE(recommended);
 
        log_setup();
 
        r = service_parse_argv(BUS_IMPLEMENTATIONS(&manager_object,
                                                   &log_control_object),
                               &scope,
                               argc, argv);
        if (r <= 0)
                return r;
 
        umask(0022);
 
        r = manager_new(scope, &m);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate manager object: %m");
 
        manager_parse_env(m);
 
        r = manager_connect_bus(m);
        if (r < 0)
                return r;
 
        r = manager_connect_varlink(m);
        if (r < 0)
                return r;
 
        r = sd_notify(false, NOTIFY_READY_MESSAGE);
        if (r < 0)
                log_warning_errno(r, "Failed to send readiness notification, ignoring: %m");
 
        r = bus_event_loop_with_idle(
                        m->event,
                        m->api_bus,
                        "org.freedesktop.import1",
                        DEFAULT_EXIT_USEC,
                        manager_check_idle,
                        m);
        if (r < 0)
                return log_error_errno(r, "Failed to run event loop: %m");
 
        return 0;
}
 
DEFINE_MAIN_FUNCTION(run);