HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/netdev/netdev.c

45,447 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: e49d142c3b941a1486e535e0534e0001d0eaf069

Lines 1001–1287 of 1,287

}
 
static int netdev_request_to_create(NetDev *netdev) {
        int r;
 
        assert(netdev);
        assert(netdev->manager);
 
        if (netdev->manager->test_mode)
                return 0;
 
        if (netdev_is_stacked(netdev))
                return 0;
 
        if (!netdev_is_managed(netdev))
                return 0; /* Already detached, due to e.g. reloading .netdev files. */
 
        if (netdev->state != NETDEV_STATE_LOADING)
                return 0; /* Already configured (at least tried previously). Not necessary to reconfigure. */
 
        r = netdev_queue_request(netdev, independent_netdev_process_request, NULL);
        if (r < 0)
                return log_netdev_warning_errno(netdev, r, "Failed to request to create netdev: %m");
 
        return 0;
}
 
int netdev_load_one(Manager *manager, const char *filename, NetDev **ret) {
        _cleanup_(netdev_unrefp) NetDev *netdev_raw = NULL, *netdev = NULL;
        _cleanup_free_ char *file_basename = NULL;
        const char *dropin_dirname;
        int r;
 
        assert(manager);
        assert(filename);
        assert(ret);
 
        r = null_or_empty_path(filename);
        if (r < 0)
                return log_warning_errno(r, "Failed to check if \"%s\" is empty: %m", filename);
        if (r > 0)
                return log_debug_errno(SYNTHETIC_ERRNO(ENOENT), "Skipping empty file: %s", filename);
 
        netdev_raw = new(NetDev, 1);
        if (!netdev_raw)
                return log_oom();
 
        *netdev_raw = (NetDev) {
                .n_ref = 1,
                .kind = _NETDEV_KIND_INVALID,
                .state = _NETDEV_STATE_INVALID, /* an invalid state means done() of the implementation won't be called on destruction */
        };
 
        r = path_extract_filename(filename, &file_basename);
        if (r < 0)
                return log_warning_errno(r, "Failed to extract file name of '%s': %m", filename);
 
        dropin_dirname = strjoina(file_basename, ".d");
        r = config_parse_many(
                        STRV_MAKE_CONST(filename),
                        NETWORK_DIRS,
                        dropin_dirname,
                        NETDEV_COMMON_SECTIONS NETDEV_OTHER_SECTIONS,
                        config_item_perf_lookup,
                        network_netdev_gperf_lookup,
                        CONFIG_PARSE_WARN,
                        netdev_raw);
        if (r < 0)
                return r; /* config_parse_many() logs internally. */
 
        /* skip out early if configuration does not match the environment */
        if (!condition_test_list_net(netdev_raw->conditions, environ, NULL, NULL, NULL))
                return log_debug_errno(SYNTHETIC_ERRNO(ESTALE), "%s: Conditions in the file do not match the system environment, skipping.", filename);
 
        if (netdev_raw->kind == _NETDEV_KIND_INVALID)
                return log_warning_errno(SYNTHETIC_ERRNO(EINVAL), "NetDev has no Kind= configured in \"%s\", ignoring.", filename);
 
        if (!netdev_raw->ifname)
                return log_warning_errno(SYNTHETIC_ERRNO(EINVAL), "NetDev without Name= configured in \"%s\", ignoring.", filename);
 
        netdev = malloc0(NETDEV_VTABLE(netdev_raw)->object_size);
        if (!netdev)
                return log_oom();
 
        netdev->n_ref = 1;
        netdev->manager = manager;
        netdev->kind = netdev_raw->kind;
        netdev->state = NETDEV_STATE_LOADING; /* we initialize the state here for the first time,
                                                 so that done() will be called on destruction */
 
        if (NETDEV_VTABLE(netdev)->init)
                NETDEV_VTABLE(netdev)->init(netdev);
 
        r = config_parse_many_full(
                        STRV_MAKE_CONST(filename),
                        NETWORK_DIRS,
                        dropin_dirname,
                        /* root= */ NULL,
                        /* root_fd= */ -EBADF,
                        NETDEV_VTABLE(netdev)->sections,
                        config_item_perf_lookup,
                        network_netdev_gperf_lookup,
                        CONFIG_PARSE_WARN,
                        netdev,
                        &netdev->stats_by_path,
                        &netdev->dropins);
        if (r < 0)
                return r; /* config_parse_many() logs internally. */
 
        /* verify configuration */
        if (NETDEV_VTABLE(netdev)->config_verify) {
                r = NETDEV_VTABLE(netdev)->config_verify(netdev, filename);
                if (r < 0)
                        return r; /* config_verify() logs internally. */
        }
 
        netdev->filename = strdup(filename);
        if (!netdev->filename)
                return log_oom();
 
        log_syntax(/* unit= */ NULL, LOG_DEBUG, filename, /* config_line= */ 0, /* error= */ 0, "Successfully loaded.");
 
        *ret = TAKE_PTR(netdev);
        return 0;
}
 
int netdev_load(Manager *manager) {
        _cleanup_strv_free_ char **files = NULL;
        int r;
 
        assert(manager);
 
        r = conf_files_list_strv(&files, ".netdev", /* root= */ NULL, CONF_FILES_WARN, NETWORK_DIRS);
        if (r < 0)
                return log_error_errno(r, "Failed to enumerate netdev files: %m");
 
        STRV_FOREACH(f, files) {
                _cleanup_(netdev_unrefp) NetDev *netdev = NULL;
 
                if (netdev_load_one(manager, *f, &netdev) < 0)
                        continue;
 
                if (netdev_attach(netdev) < 0)
                        continue;
 
                if (netdev_request_to_create(netdev) < 0)
                        continue;
 
                TAKE_PTR(netdev);
        }
 
        return 0;
}
 
int netdev_reload(Manager *manager) {
        _cleanup_hashmap_free_ Hashmap *new_netdevs = NULL;
        _cleanup_strv_free_ char **files = NULL;
        int r;
 
        assert(manager);
 
        r = conf_files_list_strv(&files, ".netdev", /* root= */ NULL, CONF_FILES_WARN, NETWORK_DIRS);
        if (r < 0)
                return log_error_errno(r, "Failed to enumerate netdev files: %m");
 
        STRV_FOREACH(f, files) {
                _cleanup_(netdev_unrefp) NetDev *netdev = NULL;
                NetDev *old;
 
                if (netdev_load_one(manager, *f, &netdev) < 0)
                        continue;
 
                if (netdev_get(manager, netdev->ifname, &old) < 0) {
                        log_netdev_debug(netdev, "Found new .netdev file: %s", netdev->filename);
 
                        if (netdev_attach_name_full(netdev, netdev->ifname, &new_netdevs) >= 0)
                                TAKE_PTR(netdev);
 
                        continue;
                }
 
                if (!stats_by_path_equal(netdev->stats_by_path, old->stats_by_path)) {
                        log_netdev_debug(netdev, "Found updated .netdev file: %s", netdev->filename);
 
                        /* Copy ifindex. */
                        netdev->ifindex = old->ifindex;
 
                        if (netdev_attach_name_full(netdev, netdev->ifname, &new_netdevs) >= 0)
                                TAKE_PTR(netdev);
 
                        continue;
                }
 
                /* Keep the original object, and drop the new one. */
                if (netdev_attach_name_full(old, old->ifname, &new_netdevs) >= 0)
                        netdev_ref(old);
        }
 
        /* Detach old NetDev objects from Manager.
         * The same object may be registered with multiple names, and netdev_detach() may drop multiple entries. */
        for (NetDev *n; (n = hashmap_first(manager->netdevs)); )
                netdev_detach(n);
 
        /* Attach new NetDev objects to Manager. */
        for (;;) {
                _cleanup_(netdev_unrefp) NetDev *netdev = hashmap_steal_first(new_netdevs);
                if (!netdev)
                        break;
 
                netdev->manager = manager;
                if (netdev_attach(netdev) < 0)
                        continue;
 
                /* Create a new netdev or update existing netdev, */
                if (netdev_request_to_create(netdev) < 0)
                        continue;
 
                TAKE_PTR(netdev);
        }
 
        /* Reassign NetDev objects to Link object. */
        Link *link;
        HASHMAP_FOREACH(link, manager->links_by_index)
                link_assign_netdev(link);
 
        return 0;
}
 
int config_parse_netdev_kind(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        NetDevKind k, *kind = ASSERT_PTR(data);
 
        assert(filename);
        assert(rvalue);
 
        k = netdev_kind_from_string(rvalue);
        if (k < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, k, "Failed to parse netdev kind, ignoring assignment: %s", rvalue);
                return 0;
        }
 
        if (*kind != _NETDEV_KIND_INVALID && *kind != k) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Specified netdev kind is different from the previous value '%s', ignoring assignment: %s",
                           netdev_kind_to_string(*kind), rvalue);
                return 0;
        }
 
        *kind = k;
 
        return 0;
}
 
int config_parse_netdev_hw_addr(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        struct hw_addr_data *hw_addr = ASSERT_PTR(data);
 
        assert(rvalue);
 
        if (streq(rvalue, "none")) {
                *hw_addr = HW_ADDR_NONE;
                return 0;
        }
 
        return config_parse_hw_addr(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);
}