HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/udev/net/link-config.c
Git blob: ec50a155acdbd5be9dc9e98bbf7495f2e2138fe8
Lines 1001–2000 of 2,207
if (r != 0)
return r;
r = CMP(a->core_id, b->core_id);
if (r != 0)
return r;
return CMP(a->cpu, b->cpu);
}
/* Comparison function for sorting CPUs by CPU number (for die ID assignment) */
static int cpu_number_compare(const CPUTopology *a, const CPUTopology *b) {
assert(a);
assert(b);
return CMP(a->cpu, b->cpu);
}
/* Assign logical die IDs based on L3 cache sharing topology.
*
* For IRQ spreading, the goal is to distribute interrupts across CPUs that
* don't share cache, minimizing cache line contention when processing packets.
* The L3 cache boundary is the key locality domain: CPUs sharing an L3 can
* exchange data cheaply, while cross-L3 communication is expensive.
*
* We use L3 shared_cpu_list rather than the kernel's physical die_id because:
* - On AMD EPYC, multiple CCXs on the same physical die have separate L3 caches
* - On Intel with Sub-NUMA Clustering, one die may have multiple L3 domains
* - L3 sharing reflects actual data locality, not physical packaging */
static int assign_sequential_die_ids(CPUTopology *cpus, size_t count) {
_cleanup_strv_free_ char **l3_groups = NULL;
int r;
assert(cpus);
/* First, sort CPUs by CPU number for consistent discovery order */
typesafe_qsort(cpus, count, cpu_number_compare);
/* Assign die IDs based on order of L3 shared_cpu_list discovery */
FOREACH_ARRAY(cpu, cpus, count) {
_cleanup_(sd_device_unrefp) sd_device *cpu_node = NULL;
char cpu_path[STRLEN("/sys/devices/system/cpu/cpu") + DECIMAL_STR_MAX(unsigned) + 1];
const char *l3_list;
unsigned die_id = 0;
bool found = false;
xsprintf(cpu_path, "/sys/devices/system/cpu/cpu%u", cpu->cpu);
r = sd_device_new_from_syspath(&cpu_node, cpu_path);
if (r < 0)
return r;
r = sd_device_get_sysattr_value(cpu_node, "cache/index3/shared_cpu_list", &l3_list);
if (r < 0) {
/* No L3 info, fall back to package ID */
cpu->die_id = cpu->package_id;
continue;
}
/* Check if we've seen this L3 group before */
STRV_FOREACH(g, l3_groups) {
if (streq(*g, l3_list)) {
cpu->die_id = die_id;
found = true;
break;
}
die_id++;
}
if (!found) {
/* New L3 group, assign next sequential die ID */
cpu->die_id = die_id;
r = strv_extend(&l3_groups, l3_list);
if (r < 0)
return r;
}
}
return 0;
}
static int discover_cpu_topology(CPUTopology **ret, size_t *ret_count) {
_cleanup_(sd_device_unrefp) sd_device *parent_node = NULL;
_cleanup_free_ CPUTopology *cpus = NULL;
const char *name;
size_t count = 0;
int r;
assert(ret);
assert(ret_count);
r = sd_device_new_from_syspath(&parent_node, "/sys/devices/system/cpu");
if (r < 0)
return r;
FOREACH_DEVICE_CHILD_WITH_SUFFIX(parent_node, cpu_node, name) {
char topo_path[STRLEN("/sys/devices/system/cpu/cpu/topology") + DECIMAL_STR_MAX(unsigned) + 1];
const char *n;
unsigned cpu, online, first_thread;
n = startswith(name, "cpu");
if (!n)
continue;
r = safe_atou(n, &cpu);
if (r < 0) {
log_debug_errno(r, "Failed to convert %s to unsigned, skipping: %m", n);
continue;
}
r = device_get_sysattr_unsigned(cpu_node, "online", &online);
if (r == -ENOENT)
online = 1; /* CPU 0 lacks 'online' file, assume online */
else if (r < 0 || online == 0)
continue;
/* Check if topology directory exists (filters out cpu0 on some systems) */
xsprintf(topo_path, "/sys/devices/system/cpu/cpu%u/topology", cpu);
if (access(topo_path, F_OK) < 0) {
log_debug_errno(errno, "Failed to access %s, ignoring: %m", topo_path);
continue;
}
if (!GREEDY_REALLOC(cpus, count + 1))
return -ENOMEM;
cpus[count].cpu = cpu;
r = numa_get_node_from_cpu(cpu, &cpus[count].numa_node);
if (r < 0) {
log_debug_errno(r, "Failed to get NUMA node for CPU %u, assuming NUMA node 0: %m", cpu);
cpus[count].numa_node = 0;
}
r = device_get_sysattr_unsigned(cpu_node, "topology/physical_package_id", &cpus[count].package_id);
if (r < 0) {
log_device_debug_errno(cpu_node, r, "Failed to get physical_package_id, assuming package ID 0: %m");
cpus[count].package_id = 0;
}
/* die_id will be assigned later by assign_sequential_die_ids() */
cpus[count].die_id = 0;
r = device_get_sysattr_unsigned(cpu_node, "topology/core_id", &cpus[count].core_id);
if (r < 0) {
log_device_debug_errno(cpu_node, r, "Failed to get core_id, assuming core ID %u: %m", cpu);
cpus[count].core_id = cpu;
}
r = cpu_topology_get_first_thread(cpu_node, &first_thread);
if (r < 0)
cpus[count].is_first_thread = true;
else
cpus[count].is_first_thread = (first_thread == cpu);
count++;
}
if (count == 0)
return -ENOENT;
/* Assign sequential die IDs based on L3 discovery order */
r = assign_sequential_die_ids(cpus, count);
if (r < 0)
return r;
/* Sort CPUs by topology for consistent ordering */
typesafe_qsort(cpus, count, cpu_topology_compare);
*ret = TAKE_PTR(cpus);
*ret_count = count;
return 0;
}
/* Reorder indices so consecutive elements are maximally spread apart.
*
* Uses recursive divide-and-conquer: split in half, permute each half,
* then interleave. This ensures elements originally far apart become adjacent.
*
* Example trace for [0,1,2,3,4,5,6,7]:
* split into [0,1,2,3] and [4,5,6,7]
* recurse left: [0,1,2,3] -> [0,2,1,3]
* recurse right: [4,5,6,7] -> [4,6,5,7]
* interleave -> [0,4,2,6,1,5,3,7]
*
* The first N elements of the output are roughly evenly distributed across the
* original range, for any N. This is useful when assigning IRQs to CPUs: if a
* NIC has fewer IRQs than CPUs, the assigned CPUs will still be spread across
* the CPUs rather than all at the beginning. */
static int equidist_permute(size_t *indices, size_t n_indices) {
_cleanup_free_ size_t *left = NULL, *right = NULL;
size_t left_count, right_count;
size_t li = 0, ri = 0, ti = 0;
int r;
assert(indices);
if (n_indices <= 1)
return 0;
left_count = DIV_ROUND_UP(n_indices, 2);
right_count = n_indices - left_count;
/* Recursively permute each half */
left = newdup(size_t, indices, left_count);
right = newdup(size_t, &indices[left_count], right_count);
if (!left || !right)
return log_oom();
r = equidist_permute(left, left_count);
if (r < 0)
return r;
r = equidist_permute(right, right_count);
if (r < 0)
return r;
/* Interleave: left[0], right[0], left[1], right[1], ... */
for (size_t i = 0; i < n_indices; i++) {
if (i % 2 == 0 && li < left_count)
indices[ti++] = left[li++];
else if (ri < right_count)
indices[ti++] = right[ri++];
else if (li < left_count)
indices[ti++] = left[li++];
}
return 0;
}
static void die_info_free(DieInfo *dies, size_t count) {
assert(dies || count == 0);
FOREACH_ARRAY(die, dies, count)
free(die->cpus);
free(dies);
}
/* Build die information from topology, grouping CPUs by L3/die and filtering to first HT only */
static int build_die_info(const CPUTopology *topology, size_t topology_count, DieInfo **ret, size_t *ret_count) {
DieInfo *dies = NULL;
size_t die_count = 0;
int r;
assert(topology);
assert(ret);
assert(ret_count);
CLEANUP_ARRAY(dies, die_count, die_info_free);
FOREACH_ARRAY(cpu_topology, topology, topology_count) {
DieInfo *die = NULL;
/* Only consider first hyperthreads for initial spread */
if (!cpu_topology->is_first_thread)
continue;
/* Find or create die entry */
for (size_t j = 0; j < die_count; j++)
if (dies[j].die_id == cpu_topology->die_id) {
die = &dies[j];
break;
}
if (!die) {
if (!GREEDY_REALLOC(dies, die_count + 1))
return log_oom();
die = &dies[die_count++];
*die = (DieInfo) { .die_id = cpu_topology->die_id };
}
if (!GREEDY_REALLOC(die->cpus, die->cpu_count + 1))
return log_oom();
die->cpus[die->cpu_count++] = cpu_topology->cpu;
}
/* Sort dies by die_id for determinism, then apply equidist to CPUs within each die */
FOREACH_ARRAY(die, dies, die_count) {
_cleanup_free_ unsigned *reordered = NULL;
_cleanup_free_ size_t *indices = new(size_t, die->cpu_count);
if (!indices)
return log_oom();
for (size_t j = 0; j < die->cpu_count; j++)
indices[j] = j;
r = equidist_permute(indices, die->cpu_count);
if (r < 0)
return r;
/* Reorder CPUs according to equidist permutation */
reordered = new(unsigned, die->cpu_count);
if (!reordered)
return log_oom();
for (size_t j = 0; j < die->cpu_count; j++)
reordered[j] = die->cpus[indices[j]];
memcpy(die->cpus, reordered, die->cpu_count * sizeof(unsigned));
}
*ret = TAKE_PTR(dies);
*ret_count = die_count;
return 0;
}
/* Select CPUs for IRQ affinity spreading with optimal topology distribution.
*
* Algorithm:
* 1. Group CPUs by die (L3 cache domain), using only first hyperthreads
* 2. Apply equidistant permutation to both die order and CPUs within each die,
* so consecutive selections are maximally spread (e.g., [0,1,2,3] -> [0,2,1,3])
* 3. Round-robin across dies, picking one CPU per die per round
* 4. If more IRQs than physical cores, wrap around and reuse the same CPUs
*
* Ensures each IRQ gets a dedicated physical core before any core handles
* multiple IRQs. Two IRQs on one physical core time-share but benefit from warm
* cache, whereas spreading across SMT siblings causes resource contention with
* no cache benefit.
* Maximizes physical distance between consecutively assigned IRQs, improving
* cache distribution even when only a few IRQs are assigned. */
static int select_spread_cpus(
const CPUTopology *topology,
size_t topology_count,
size_t n_irqs,
unsigned **ret,
size_t *ret_count) {
_cleanup_free_ unsigned *selected = NULL;
_cleanup_free_ size_t *die_order = NULL;
DieInfo *dies = NULL;
size_t die_count = 0, selected_count = 0;
int r;
assert(topology);
assert(ret);
assert(ret_count);
CLEANUP_ARRAY(dies, die_count, die_info_free);
selected = new(unsigned, n_irqs);
if (!selected)
return -ENOMEM;
/* Build die information with first HT CPUs only */
r = build_die_info(topology, topology_count, &dies, &die_count);
if (r < 0)
return r;
if (die_count == 0)
return -ENOENT;
/* Create equidistant die ordering */
die_order = new(size_t, die_count);
if (!die_order)
return -ENOMEM;
for (size_t i = 0; i < die_count; i++)
die_order[i] = i;
r = equidist_permute(die_order, die_count);
if (r < 0)
return r;
/* Round-robin across dies, picking one CPU from each die at a time */
size_t dies_exhausted = 0;
while (selected_count < n_irqs) {
bool made_progress = false;
for (size_t i = 0; i < die_count && selected_count < n_irqs; i++) {
DieInfo *die = &dies[die_order[i]];
if (die->next_idx >= die->cpu_count)
continue;
selected[selected_count++] = die->cpus[die->next_idx++];
made_progress = true;
if (die->next_idx >= die->cpu_count)
dies_exhausted++;
}
if (made_progress)
continue;
/* All first HTs exhausted, wrap around for remaining IRQs */
if (dies_exhausted < die_count)
break;
/* Reset all dies for round-robin wrap */
FOREACH_ARRAY(die, dies, die_count)
die->next_idx = 0;
dies_exhausted = 0;
}
*ret = TAKE_PTR(selected);
*ret_count = selected_count;
return 0;
}
static int set_irq_affinity(Link *link, unsigned irq, unsigned cpu) {
_cleanup_free_ char *affinity_path = NULL, *mask_str = NULL;
unsigned n_groups = cpu / 32;
int r;
assert(link);
if (asprintf(&affinity_path, "/proc/irq/%u/smp_affinity", irq) < 0)
return log_oom();
/* Convert CPU number to hex bitmask.
* For CPU N, set bit N (1 << N). CPUs are split by comma-separated
* 32-bits groups. To assign CPU 32, we should write 1,00000000 */
if (asprintf(&mask_str, "%x", 1U << (cpu % 32)) < 0)
return log_oom();
for (unsigned i = 0; i < n_groups; i++)
if (!strextend(&mask_str, ",00000000"))
return log_oom();
r = write_string_file(affinity_path, mask_str, WRITE_STRING_FILE_DISABLE_BUFFER);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to set IRQ %u affinity to CPU %u: %m", irq, cpu);
log_link_debug(link, "Set IRQ %u affinity to CPU %u.", irq, cpu);
return 0;
}
static int link_apply_irq_affinity_spread(Link *link, const CPUSet *allowed_cpus) {
_cleanup_closedir_ DIR *dir = NULL;
_cleanup_free_ CPUTopology *topology = NULL;
_cleanup_free_ unsigned *irqs = NULL;
_cleanup_free_ unsigned *spread_cpus = NULL;
size_t topology_count = 0, irq_count = 0, spread_count = 0;
int r;
assert(link);
r = device_opendir(link->event->dev, "device/msi_irqs", &dir);
if (r < 0) {
if (r != -ENOENT)
return log_link_error_errno(link, r, "Failed to open device/msi_irqs: %m");
log_link_debug_errno(link, r, "No MSI IRQs found, skipping IRQ affinity configuration: %m");
return 0;
}
FOREACH_DIRENT(de, dir, return log_link_error_errno(link, errno, "Failed to read directory device/msi_irqs: %m")) {
unsigned irq;
r = safe_atou(de->d_name, &irq);
if (r < 0)
return log_link_error_errno(link, r, "Failed to convert parse IRQ number: %s", de->d_name);
if (!GREEDY_REALLOC(irqs, irq_count + 1))
return log_oom();
irqs[irq_count++] = irq;
}
if (irq_count == 0) {
log_link_debug(link, "No IRQs found, skipping spread.");
return 0;
}
typesafe_qsort(irqs, irq_count, cmp_unsigned);
r = discover_cpu_topology(&topology, &topology_count);
if (r < 0)
return log_link_error_errno(link, r, "Failed to discover CPU topology: %m");
/* Filter topology by allowed CPUs if specified */
if (allowed_cpus && allowed_cpus->set) {
_cleanup_free_ CPUTopology *filtered_topology = new(CPUTopology, topology_count);
size_t filtered_count = 0;
if (!filtered_topology)
return log_oom();
for (size_t i = 0; i < topology_count; i++)
if (CPU_ISSET_S(topology[i].cpu, allowed_cpus->allocated, allowed_cpus->set))
filtered_topology[filtered_count++] = topology[i];
if (filtered_count == 0) {
log_link_warning(link, "IRQAffinity= filter excludes all CPUs, skipping spread.");
return 0;
}
log_link_debug(link, "Filtered to %zu CPUs (from %zu) based on IRQAffinity=.", filtered_count, topology_count);
free_and_replace(topology, filtered_topology);
topology_count = filtered_count;
}
log_link_debug(link, "Spreading %zu IRQs across %zu CPUs.", irq_count, topology_count);
/* Select CPUs using maximum distance algorithm */
r = select_spread_cpus(topology, topology_count, irq_count, &spread_cpus, &spread_count);
if (r < 0)
return log_link_error_errno(link, r, "Failed to select spread CPUs: %m");
for (size_t i = 0; i < spread_count; i++)
(void) set_irq_affinity(link, irqs[i], spread_cpus[i]);
log_link_info(link, "Applied IRQ affinity policy 'spread' across %zu CPUs for %zu IRQs.",
MIN(topology_count, irq_count), irq_count);
return 0;
}
static int link_apply_irq_affinity_single(Link *link, const CPUSet *allowed_cpus) {
_cleanup_closedir_ DIR *dir = NULL;
unsigned target_cpu = 0;
int r;
assert(link);
assert(link->config);
assert(ASSERT_PTR(link->event)->dev);
/* If IRQAffinity= is specified, use the first allowed CPU instead of CPU 0 */
if (allowed_cpus && allowed_cpus->set) {
bool found = false;
for (unsigned cpu = 0; cpu < allowed_cpus->allocated * 8; cpu++)
if (CPU_ISSET_S(cpu, allowed_cpus->allocated, allowed_cpus->set)) {
target_cpu = cpu;
found = true;
break;
}
if (!found) {
log_link_warning(link, "IRQAffinity= filter excludes all CPUs, skipping single.");
return 0;
}
}
r = device_opendir(link->event->dev, "device/msi_irqs", &dir);
if (r < 0) {
if (r != -ENOENT)
return log_link_error_errno(link, r, "Failed to open device/msi_irqs: %m");
log_link_debug_errno(link, r, "No MSI IRQs found, skipping IRQ affinity configuration: %m");
return 0;
}
FOREACH_DIRENT(de, dir, return log_link_error_errno(link, errno, "Failed to read directory device/msi_irqs: %m")) {
unsigned irq;
r = safe_atou(de->d_name, &irq);
if (r < 0)
return log_link_error_errno(link, r, "Failed to convert parse IRQ number: %s", de->d_name);
(void) set_irq_affinity(link, irq, target_cpu);
}
log_link_info(link, "Applied IRQ affinity policy 'single' (pinning to CPU %u).", target_cpu);
return 0;
}
static int link_apply_irq_affinity(Link *link) {
_cleanup_(cpu_set_done) CPUSet effective_cpus = {};
const char *syspath;
unsigned numa_node = IRQ_AFFINITY_NUMA_UNSET;
int r;
assert(link);
assert(link->config);
assert(ASSERT_PTR(link->event)->dev);
if (link->event->event_mode != EVENT_UDEV_WORKER) {
log_link_debug(link, "Running in test mode, skipping application of IRQ affinity settings.");
return 0;
}
if (link->config->irq_affinity_policy < 0)
return 0;
r = sd_device_get_syspath(link->event->dev, &syspath);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to get syspath: %m");
/* Compute effective CPU set from IRQAffinity= and IRQAffinityNUMA= */
if (link->config->irq_affinity_numa != IRQ_AFFINITY_NUMA_UNSET) {
_cleanup_(cpu_set_done) CPUSet numa_cpus = {};
/* Resolve "local" to the actual NUMA node */
if (link->config->irq_affinity_numa == IRQ_AFFINITY_NUMA_LOCAL) {
r = link_get_device_numa_node(link, &numa_node);
if (r < 0) {
log_link_warning_errno(
link, r,
"Failed to determine local NUMA node for device, skipping IRQ affinity configuration: %m");
return 0;
}
log_link_debug(link, "Device is on NUMA node %u.", numa_node);
} else
numa_node = link->config->irq_affinity_numa;
/* Get CPUs for the NUMA node */
r = numa_node_get_cpus(numa_node, &numa_cpus);
if (r < 0) {
log_link_warning_errno(
link, r,
"Failed to get CPUs for NUMA node %u, skipping IRQ affinity configuration: %m",
numa_node);
return 0;
}
/* If IRQAffinity= is also specified, compute intersection */
if (link->config->irq_affinity_cpus.set) {
/* Compute intersection of IRQAffinity= and NUMA CPUs */
size_t max_allocated = MAX(numa_cpus.allocated, link->config->irq_affinity_cpus.allocated);
r = cpu_set_realloc(&effective_cpus, max_allocated * 8);
if (r < 0)
return log_oom();
for (size_t i = 0; i < max_allocated * 8; i++) {
bool in_numa = i < numa_cpus.allocated * 8 &&
CPU_ISSET_S(i, numa_cpus.allocated, numa_cpus.set);
bool in_affinity = i < link->config->irq_affinity_cpus.allocated * 8 &&
CPU_ISSET_S(i, link->config->irq_affinity_cpus.allocated, link->config->irq_affinity_cpus.set);
if (in_numa && in_affinity) {
r = cpu_set_add(&effective_cpus, i);
if (r < 0)
return log_oom();
}
}
/* Check if intersection is empty */
if (!effective_cpus.set || CPU_COUNT_S(effective_cpus.allocated, effective_cpus.set) == 0) {
log_link_warning(
link,
"IRQAffinity= and IRQAffinityNUMA= intersection is empty, skipping IRQ affinity configuration.");
return 0;
}
log_link_debug(link, "Using intersection of IRQAffinity= and NUMA node %u CPUs.", numa_node);
} else {
/* Only NUMA filtering, use NUMA CPUs directly */
effective_cpus = TAKE_STRUCT(numa_cpus);
log_link_debug(link, "Using CPUs from NUMA node %u.", numa_node);
}
} else if (link->config->irq_affinity_cpus.set) {
/* Only IRQAffinity= specified, copy it */
r = cpu_set_add_set(&effective_cpus, &link->config->irq_affinity_cpus);
if (r < 0)
return log_oom();
}
/* else: no filtering, effective_cpus remains empty (meaning use all CPUs) */
switch (link->config->irq_affinity_policy) {
case IRQ_AFFINITY_POLICY_SINGLE:
return link_apply_irq_affinity_single(link, effective_cpus.set ? &effective_cpus : NULL);
case IRQ_AFFINITY_POLICY_SPREAD:
return link_apply_irq_affinity_spread(link, effective_cpus.set ? &effective_cpus : NULL);
default:
assert_not_reached();
}
}
static int link_apply_rps_cpu_mask(Link *link) {
_cleanup_free_ char *mask_str = NULL;
LinkConfig *config;
int r;
config = ASSERT_PTR(ASSERT_PTR(link)->config);
assert(ASSERT_PTR(link->event)->dev);
if (link->event->event_mode != EVENT_UDEV_WORKER) {
log_link_debug(link, "Running in test mode, skipping application of RPS setting.");
return 0;
}
/* Skip if the config is not specified. */
if (!config->rps_cpu_mask.set)
return 0;
mask_str = cpu_set_to_mask_string(&config->rps_cpu_mask);
if (!mask_str)
return log_oom();
log_link_debug(link, "Applying RPS CPU mask: %s", mask_str);
/* Currently, this will set CPU mask to all rx queue of matched device. */
FOREACH_DEVICE_SYSATTR(link->event->dev, attr) {
const char *c;
c = path_startswith(attr, "queues/");
if (!c)
continue;
c = startswith(c, "rx-");
if (!c)
continue;
c += strcspn(c, "/");
if (!path_equal(c, "/rps_cpus"))
continue;
r = sd_device_set_sysattr_value(link->event->dev, attr, mask_str);
if (r < 0)
log_link_warning_errno(link, r, "Failed to write %s sysfs attribute, ignoring: %m", attr);
}
return 0;
}
static int link_apply_udev_properties(Link *link) {
LinkConfig *config = ASSERT_PTR(ASSERT_PTR(link)->config);
UdevEvent *event = ASSERT_PTR(link->event);
/* 1. apply ImportProperty=. */
STRV_FOREACH(p, config->import_properties)
(void) udev_builtin_import_property(event, *p);
/* 2. apply Property=. */
STRV_FOREACH(p, config->properties) {
_cleanup_free_ char *key = NULL;
const char *eq;
eq = strchr(*p, '=');
if (!eq)
continue;
key = strndup(*p, eq - *p);
if (!key)
return log_oom();
(void) udev_builtin_add_property(event, key, eq + 1);
}
/* 3. apply UnsetProperty=. */
STRV_FOREACH(p, config->unset_properties)
(void) udev_builtin_add_property(event, *p, NULL);
/* 4. set the default properties. */
(void) udev_builtin_add_property(event, "ID_NET_LINK_FILE", config->filename);
_cleanup_free_ char *joined = NULL;
STRV_FOREACH(d, config->dropins) {
_cleanup_free_ char *escaped = NULL;
escaped = xescape(*d, ":");
if (!escaped)
return log_oom();
if (!strextend_with_separator(&joined, ":", escaped))
return log_oom();
}
(void) udev_builtin_add_property(event, "ID_NET_LINK_FILE_DROPINS", joined);
if (link->new_name)
(void) udev_builtin_add_property(event, "ID_NET_NAME", link->new_name);
return 0;
}
int link_apply_config(LinkConfigContext *ctx, Link *link) {
int r;
assert(ctx);
assert(link);
r = link_apply_ethtool_settings(link, &ctx->ethtool_fd);
if (r < 0)
return r;
r = link_apply_rtnl_settings(link);
if (r < 0)
return r;
r = link_generate_new_name(link);
if (r < 0)
return r;
r = link_generate_alternative_names(link);
if (r < 0)
return r;
r = link_apply_sr_iov_config(link);
if (r < 0)
return r;
r = link_apply_rps_cpu_mask(link);
if (r < 0)
return r;
r = link_apply_irq_affinity(link);
if (r < 0)
return r;
return link_apply_udev_properties(link);
}
int config_parse_udev_property(
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) {
char ***properties = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
*properties = strv_free(*properties);
return 0;
}
for (const char *p = rvalue;; ) {
_cleanup_free_ char *word = NULL, *resolved = NULL, *key = NULL;
const char *eq;
r = extract_first_word(&p, &word, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Invalid syntax, ignoring assignment: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
r = specifier_printf(word, SIZE_MAX, link_specifier_table, NULL, NULL, &resolved);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to resolve specifiers in %s, ignoring assignment: %m", word);
continue;
}
if (!udev_property_assignment_is_valid(resolved)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid udev property, ignoring assignment: %s", word);
continue;
}
assert_se(eq = strchr(resolved, '='));
key = strndup(resolved, eq - resolved);
if (!key)
return log_oom();
if (!device_property_can_set(key)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid udev property name '%s', ignoring assignment: %s", key, resolved);
continue;
}
r = strv_env_replace_consume(properties, TAKE_PTR(resolved));
if (r < 0)
return log_error_errno(r, "Failed to update properties: %m");
}
}
int config_parse_udev_property_name(
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) {
char ***properties = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
*properties = strv_free(*properties);
return 0;
}
for (const char *p = rvalue;; ) {
_cleanup_free_ char *word = NULL, *resolved = NULL;
r = extract_first_word(&p, &word, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Invalid syntax, ignoring assignment: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
r = specifier_printf(word, SIZE_MAX, link_specifier_table, NULL, NULL, &resolved);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to resolve specifiers in %s, ignoring assignment: %m", word);
continue;
}
if (!udev_property_name_is_valid(resolved)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid udev property name, ignoring assignment: %s", resolved);
continue;
}
if (!device_property_can_set(resolved)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid udev property name, ignoring assignment: %s", resolved);
continue;
}
r = strv_consume(properties, TAKE_PTR(resolved));
if (r < 0)
return log_error_errno(r, "Failed to update properties: %m");
}
}
int config_parse_ifalias(
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) {
char **s = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*s = mfree(*s);
return 0;
}
if (!ascii_is_valid(rvalue)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Interface alias is not ASCII clean, ignoring assignment: %s", rvalue);
return 0;
}
if (strlen(rvalue) >= IFALIASZ) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Interface alias is too long, ignoring assignment: %s", rvalue);
return 0;
}
return free_and_strdup_warn(s, rvalue);
}
int config_parse_rx_tx_queues(
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 = 0;
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 == 0 || k > 16384) {