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 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) {