HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/udev/net/link-config.c

80,782 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: ec50a155acdbd5be9dc9e98bbf7495f2e2138fe8

Lines 2001–2207 of 2,207

                log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid %s=, ignoring assignment: %s.", lvalue, rvalue);
                return 0;
        }
 
        *v = k;
        return 0;
}
 
int config_parse_txqueuelen(
                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) {
 
        uint32_t k, *v = data;
        int r;
 
        if (isempty(rvalue)) {
                *v = UINT32_MAX;
                return 0;
        }
 
        r = safe_atou32(rvalue, &k);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s=, ignoring assignment: %s.", lvalue, rvalue);
                return 0;
        }
        if (k == UINT32_MAX) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid %s=, ignoring assignment: %s.", lvalue, rvalue);
                return 0;
        }
 
        *v = k;
        return 0;
}
 
int config_parse_wol_password(
                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) {
 
        LinkConfig *config = ASSERT_PTR(userdata);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                config->wol_password = erase_and_free(config->wol_password);
                config->wol_password_file = mfree(config->wol_password_file);
                return 0;
        }
 
        if (path_is_absolute(rvalue) && path_is_safe(rvalue)) {
                config->wol_password = erase_and_free(config->wol_password);
                return free_and_strdup_warn(&config->wol_password_file, rvalue);
        }
 
        warn_file_is_world_accessible(filename, NULL, unit, line);
 
        r = link_parse_wol_password(config, rvalue);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to parse %s=, ignoring assignment: %s.", lvalue, rvalue);
                return 0;
        }
 
        config->wol_password_file = mfree(config->wol_password_file);
        return 0;
}
 
int config_parse_rps_cpu_mask(
                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) {
 
        CPUSet *mask = ASSERT_PTR(data);
        int r;
 
        assert(rvalue);
 
        if (streq(rvalue, "disable")) {
                _cleanup_(cpu_set_done) CPUSet c = {};
 
                r = cpu_set_realloc(&c, 1);
                if (r < 0)
                        return log_oom();
 
                return cpu_set_done_and_replace(*mask, c);
        }
 
        if (streq(rvalue, "all")) {
                _cleanup_(cpu_set_done) CPUSet c = {};
 
                r = cpu_set_add_all(&c);
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r,
                                   "Failed to create CPU affinity mask representing \"all\" cpus, ignoring: %m");
                        return 0;
                }
 
                return cpu_set_done_and_replace(*mask, c);
        }
 
        return config_parse_cpu_set(unit, filename, line, section, section_line, lvalue, ltype, rvalue, data, userdata);
}
 
static const char* const mac_address_policy_table[_MAC_ADDRESS_POLICY_MAX] = {
        [MAC_ADDRESS_POLICY_PERSISTENT] = "persistent",
        [MAC_ADDRESS_POLICY_RANDOM] = "random",
        [MAC_ADDRESS_POLICY_NONE] = "none",
};
 
DEFINE_STRING_TABLE_LOOKUP(mac_address_policy, MACAddressPolicy);
DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(
        config_parse_mac_address_policy,
        mac_address_policy,
        MACAddressPolicy,
        MAC_ADDRESS_POLICY_NONE);
 
DEFINE_CONFIG_PARSE_ENUMV(config_parse_name_policy, name_policy, NamePolicy,
                          _NAMEPOLICY_INVALID);
 
DEFINE_CONFIG_PARSE_ENUMV(config_parse_alternative_names_policy, alternative_names_policy, NamePolicy,
                          _NAMEPOLICY_INVALID);
 
int config_parse_irq_affinity_numa(
                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) {
 
        unsigned tmp, *numa = ASSERT_PTR(data);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                *numa = IRQ_AFFINITY_NUMA_UNSET;
                return 0;
        }
 
        if (streq(rvalue, "local")) {
                *numa = IRQ_AFFINITY_NUMA_LOCAL;
                return 0;
        }
 
        /* Parse as NUMA node number */
        r = safe_atou(rvalue, &tmp);
        if (r < 0)
                return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
 
        /* UINT_MAX and UINT_MAX-1 are used to flag "unset" and "local NUMA node" respectively. */
        if (tmp >= IRQ_AFFINITY_NUMA_LOCAL) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Invalid NUMA node number %u, ignoring assignment: %s", tmp, rvalue);
                return 0;
        }
 
        *numa = tmp;
 
        return 0;
}
 
static const char* const irq_affinity_policy_table[_IRQ_AFFINITY_POLICY_MAX] = {
        [IRQ_AFFINITY_POLICY_SINGLE] = "single",
        [IRQ_AFFINITY_POLICY_SPREAD] = "spread",
};
 
DEFINE_STRING_TABLE_LOOKUP(irq_affinity_policy, IRQAffinityPolicy);
DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(
        config_parse_irq_affinity_policy,
        irq_affinity_policy,
        IRQAffinityPolicy,
        _IRQ_AFFINITY_POLICY_INVALID);