From: "Elias Huhsovitz" <e.huhsovitz@proxmox.com>
To: "Dominik Csapak" <d.csapak@proxmox.com>, <pve-devel@lists.proxmox.com>
Subject: Re: [PATCH qemu-server-rs v4 1/4] cpu: add pve-qemu-server-cpu crate for vCPU binding
Date: Thu, 19 Nov 2026 10:16:45 +0100 [thread overview]
Message-ID: <DMZ2OMG2IIYY.2JCJ4KQ3VW8QQ@proxmox.com> (raw)
In-Reply-To: <88f12126-6022-47cb-b1b6-ab1895736cff@proxmox.com>
On Tue Nov 17, 2026 at 5:28 PM CET, Dominik Csapak wrote:
> high level: i forgot it the last time, but how does this interact with
> cpu hotplugging? it's totally legit to forbid cpu hotplugging
> with this feature enabled for now, but i guess we'd need to
> pin again after each hotplug step (and possibly take
> into account that not all vcpus are present)
>
My current idea is indeed to simply re-try pinning after hotplug.
Another idea was to restrict the hotplugging when binding is active,
e.g. allow a maximum of `maxcpus`. Assert the pinning constrains using
`maxcpus`, and disallow plugging > `maxcpus` so that we can guarantee a
successful pin for a new vcpu. (The vm would have to start with
vcpus > maxcpus) But this seems a bit too rigid.
> otherwise comments inline
>
> On 11/11/26 4:22 PM, Elias Huhsovitz wrote:
>> Add a new library crate that implements vCPU to host CPU binding of qemu
>> guests.
>>
>> 2 main functions are exposed: gen_vcpu_bindings: (1) Reads the CPU
>> Toplogy from sysfs, validates the configured cpu binding config and
>> Generates a vCPU:hostCPU binding map. This function should be called
>> before the guest starts. (2) bind_vcpus: Applies the binding map
>> generated by gen_vcpu_bindings to the specified vm. The cpu binding is
>> applied using sched_setaffinity(2).
>>
>> 2 modes are implemented: (1) one-to-one: pin each vCPU to its own host
>> cpu. (2) numa: bind the set of vCPUs of each vNUMA node to the set of
>> CPUs of a host NUMA node. The cpu bindings are determined by the numa[N]
>> configuration of the guest.
>>
>> Both settings respect the configured affinity.
>>
>> Thread binding uses sched_setaffinity(2), which accepts a kernel
>> TID directly. The TID used is reported by qemu via query-cpus-fast.
>>
>> Originally-by: Dominik Csapak <d.csapak@proxmox.com>
>> Signed-off-by: Elias Huhsovitz <e.huhsovitz@proxmox.com>
>> ---
>> Cargo.toml | 2 +-
>> build.sh | 2 +-
>> pve-qemu-server-cpu/Cargo.toml | 16 ++
>> pve-qemu-server-cpu/debian/changelog | 5 +
>> pve-qemu-server-cpu/debian/control | 41 ++++
>> pve-qemu-server-cpu/debian/copyright | 18 ++
>> pve-qemu-server-cpu/debian/debcargo.toml | 9 +
>> pve-qemu-server-cpu/src/bind.rs | 136 +++++++++++++
>> pve-qemu-server-cpu/src/config.rs | 146 ++++++++++++++
>> pve-qemu-server-cpu/src/cpuset.rs | 125 ++++++++++++
>> pve-qemu-server-cpu/src/error.rs | 32 ++++
>> pve-qemu-server-cpu/src/lib.rs | 92 +++++++++
>> pve-qemu-server-cpu/src/qmp.rs | 91 +++++++++
>> pve-qemu-server-cpu/src/syscall.rs | 24 +++
>> pve-qemu-server-cpu/src/topology/mod.rs | 222 ++++++++++++++++++++++
>> pve-qemu-server-cpu/src/topology/sysfs.rs | 6 +
>> 16 files changed, 965 insertions(+), 2 deletions(-)
>> create mode 100644 pve-qemu-server-cpu/Cargo.toml
>> create mode 100644 pve-qemu-server-cpu/debian/changelog
>> create mode 100644 pve-qemu-server-cpu/debian/control
>> create mode 100644 pve-qemu-server-cpu/debian/copyright
>> create mode 100644 pve-qemu-server-cpu/debian/debcargo.toml
>> create mode 100644 pve-qemu-server-cpu/src/bind.rs
>> create mode 100644 pve-qemu-server-cpu/src/config.rs
>> create mode 100644 pve-qemu-server-cpu/src/cpuset.rs
>> create mode 100644 pve-qemu-server-cpu/src/error.rs
>> create mode 100644 pve-qemu-server-cpu/src/lib.rs
>> create mode 100644 pve-qemu-server-cpu/src/qmp.rs
>> create mode 100644 pve-qemu-server-cpu/src/syscall.rs
>> create mode 100644 pve-qemu-server-cpu/src/topology/mod.rs
>> create mode 100644 pve-qemu-server-cpu/src/topology/sysfs.rs
>>
>> diff --git a/Cargo.toml b/Cargo.toml
>> index 5eefc79..80f87ff 100644
>> --- a/Cargo.toml
>> +++ b/Cargo.toml
>> @@ -1,5 +1,6 @@
>> [workspace]
>> members = [
>> + "pve-qemu-server-cpu",
>> "pve-qemu-server-pci"
>> ]
>> exclude = [
>> @@ -25,4 +26,3 @@ strum = { version = "0.26", features = ["derive"] }
>>
>> # proxmox dependencies
>> pve-api-types = "8.1"
>> -
>> diff --git a/build.sh b/build.sh
>> index 3c2293b..c3ee7b6 100755
>> --- a/build.sh
>> +++ b/build.sh
>> @@ -28,7 +28,7 @@ debcargo package \
>> --no-overlay-write-back \
>> --directory "$PWD/"${BUILDDIR}"/${CRATE}" \
>> "${CRATE}" \
>> - "$(dpkg-parsechangelog -l "${CRATE}/debian/changelog" -SVersion | sed -e 's/-.*//')"
>> + "$(dpkg-parsechangelog -l "${CRATE}/debian/changelog" -SVersion | sed -e 's/-.*//' -e 's/~/-/')"
>>
>> cd "${BUILDDIR}/${CRATE}"
>> rm -f debian/source/format.debcargo.hint
>> diff --git a/pve-qemu-server-cpu/Cargo.toml b/pve-qemu-server-cpu/Cargo.toml
>> new file mode 100644
>> index 0000000..b236796
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/Cargo.toml
>> @@ -0,0 +1,16 @@
>> +[package]
>> +name = "pve-qemu-server-cpu"
>> +version = "0.1.0"
>> +authors.workspace = true
>> +edition.workspace = true
>> +license.workspace = true
>> +repository.workspace = true
>> +homepage.workspace = true
>> +exclude.workspace = true
>> +rust-version.workspace = true
>> +
>> +[dependencies]
>> +serde = { version = "1", features = ["derive"] }
>> +serde_json = "1"
>> +thiserror = "2"
>> +libc = "0.2"
>> diff --git a/pve-qemu-server-cpu/debian/changelog b/pve-qemu-server-cpu/debian/changelog
>> new file mode 100644
>> index 0000000..3731cfd
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/debian/changelog
>> @@ -0,0 +1,5 @@
>> +rust-pve-qemu-server-cpu (0.1.0) trixie; urgency=medium
>> +
>> + * initial release
>> +
>> + -- Proxmox Support Team <support@proxmox.com> Tue, 01 Sep 2026 14:02:25 +0200
>> diff --git a/pve-qemu-server-cpu/debian/control b/pve-qemu-server-cpu/debian/control
>> new file mode 100644
>> index 0000000..1298d61
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/debian/control
>> @@ -0,0 +1,41 @@
>> +Source: rust-pve-qemu-server-cpu
>> +Section: rust
>> +Priority: optional
>> +Build-Depends: debhelper-compat (= 13),
>> + dh-sequence-cargo,
>> + libhwloc-dev (>= 2.12)
>> +Build-Depends-Arch: cargo:native <!nocheck>,
>> + rustc:native (>= 1.94) <!nocheck>,
>> + libstd-rust-dev <!nocheck>,
>> + librust-libc-0.2+default-dev <!nocheck>,
>> + librust-serde-1+default-dev <!nocheck>,
>> + librust-serde-1+derive-dev <!nocheck>,
>> + librust-serde-json-1+default-dev <!nocheck>,
>> + librust-thiserror-2+default-dev <!nocheck>
>> +Maintainer: Proxmox Support Team <support@proxmox.com>
>> +Standards-Version: 4.7.2
>> +Vcs-Git: git://git.proxmox.com/git/pve-qemu-server-rs.git
>> +Vcs-Browser: https://git.proxmox.com/?p=pve-qemu-server-rs.git
>> +Homepage: https://proxmox.com
>> +X-Cargo-Crate: pve-qemu-server-cpu
>> +
>> +Package: librust-pve-qemu-server-cpu-dev
>> +Architecture: any
>> +Multi-Arch: same
>> +Depends:
>> + ${misc:Depends},
>> + librust-libc-0.2+default-dev,
>> + librust-serde-1+default-dev,
>> + librust-serde-1+derive-dev,
>> + librust-serde-json-1+default-dev,
>> + librust-thiserror-2+default-dev
>> +Provides:
>> + librust-pve-qemu-server-cpu+default-dev (= ${binary:Version}),
>> + librust-pve-qemu-server-cpu-0-dev (= ${binary:Version}),
>> + librust-pve-qemu-server-cpu-0+default-dev (= ${binary:Version}),
>> + librust-pve-qemu-server-cpu-0.1-dev (= ${binary:Version}),
>> + librust-pve-qemu-server-cpu-0.1+default-dev (= ${binary:Version}),
>> + librust-pve-qemu-server-cpu-0.1.0-dev (= ${binary:Version}),
>> + librust-pve-qemu-server-cpu-0.1.0+default-dev (= ${binary:Version})
>> +Description: Rust crate "pve-qemu-server-cpu" - Rust source code
>> + Source code for Debianized Rust crate "pve-qemu-server-cpu"
>> diff --git a/pve-qemu-server-cpu/debian/copyright b/pve-qemu-server-cpu/debian/copyright
>> new file mode 100644
>> index 0000000..01138fa
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/debian/copyright
>> @@ -0,0 +1,18 @@
>> +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
>> +
>> +Files:
>> + *
>> +Copyright: 2026 Proxmox Server Solutions GmbH <support@proxmox.com>
>> +License: AGPL-3.0-or-later
>> + This program is free software: you can redistribute it and/or modify it under
>> + the terms of the GNU Affero General Public License as published by the Free
>> + Software Foundation, either version 3 of the License, or (at your option) any
>> + later version.
>> + .
>> + This program is distributed in the hope that it will be useful, but WITHOUT
>> + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
>> + FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
>> + details.
>> + .
>> + You should have received a copy of the GNU Affero General Public License along
>> + with this program. If not, see <https://www.gnu.org/licenses/>.
>> diff --git a/pve-qemu-server-cpu/debian/debcargo.toml b/pve-qemu-server-cpu/debian/debcargo.toml
>> new file mode 100644
>> index 0000000..23feea4
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/debian/debcargo.toml
>> @@ -0,0 +1,9 @@
>> +overlay = "."
>> +crate_src_path = ".."
>> +maintainer = "Proxmox Support Team <support@proxmox.com>"
>> +allow_prerelease_deps = true
>> +
>> +[source]
>> +vcs_git = "git://git.proxmox.com/git/pve-qemu-server-rs.git"
>> +vcs_browser = "https://git.proxmox.com/?p=pve-qemu-server-rs.git"
>> +build_depends = ["libhwloc-dev (>= 2.12)"]
>> diff --git a/pve-qemu-server-cpu/src/bind.rs b/pve-qemu-server-cpu/src/bind.rs
>> new file mode 100644
>> index 0000000..d7f52f8
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/bind.rs
>> @@ -0,0 +1,136 @@
>> +use std::collections::BTreeMap;
>> +
>> +use crate::cpuset::CpuSet;
>> +use crate::config::NumaConfig;
>> +use crate::qmp::QmpCpu;
>> +use crate::syscall::sched_setaffinity;
>> +use crate::topology::Topology;
>> +use crate::error::CpuError;
>> +
>> +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
>> +pub enum Mode {
>> + None,
>> + OneToOne,
>> + Numa,
>> +}
>> +
>> +impl std::str::FromStr for Mode {
>> + type Err = CpuError;
>> +
>> + fn from_str(s: &str) -> Result<Self, Self::Err> {
>> + match s {
>> + "none" => Ok(Mode::None),
>> + "one-to-one" => Ok(Mode::OneToOne),
>> + "numa" => Ok(Mode::Numa),
>> + other => Err(CpuError::BadSyntax(format!(
>> + "unknown cpu-bind-mode '{other}'"
>> + ))),
>> + }
>> + }
>> +}
>> +
>> +pub fn gen_one_to_one_bindings(
>> + sockets: u32,
>> + cores: u32,
>> + affinity: &Option<CpuSet>,
>> + only_real_cores: bool,
>> +) -> Result<BTreeMap<u32, CpuSet>, CpuError> {
>> + let topo = Topology::new()?;
>> + let mut allowed = topo.online_cpus().clone();
>> +
>> + if let Some(aff) = affinity {
>> + allowed.intersect(aff);
>> + }
>> +
>> + let nr_vcpus = sockets * cores;
>> +
>> + if only_real_cores {
>> + allowed = topo.singlify_per_core(&allowed);
>> + }
>
> nit: this is hardcoded, so no reason to have this code here for now
>
> we can always add it, should we need it
>
Ok
>> +
>> + if allowed.size() < nr_vcpus as usize {
>> + return Err(CpuError::BadSyntax(format!(
>> + "one-to-one mode requires {nr_vcpus} host cpus but only {} are available",
>> + allowed.size()
>> + )));
>> + }
>> +
>> + let available: Vec<u32> = allowed.to_vec();
>> +
>> + let mut bindings: BTreeMap<u32, CpuSet> = BTreeMap::new();
>> +
>> + // qmp::parse_cpuinfo should yield vCPU IDs that are 0..N-1.
>> + // If not: we proably messed up somewhere else
>> + for (vcpu_id, cpu) in available.iter().take(nr_vcpus as usize).enumerate() {
>> + let mut single_cpu = CpuSet::new();
>> + single_cpu.set(*cpu);
>> + bindings.insert(vcpu_id as u32, single_cpu);
>> + }
>> +
>> + Ok(bindings)
>> +}
>> +
>> +pub fn gen_numa_bindings(
>> + numa_cfg: &Vec<NumaConfig>,
>> + affinity: &Option<CpuSet>,
>> +) -> Result<BTreeMap<u32, CpuSet>, CpuError> {
>> + let topo = Topology::new()?;
>> + let mut bindings = BTreeMap::new();
>> +
>> + for (vnode_id, cfg) in numa_cfg.iter().enumerate() {
>> + if cfg.hostnodes.len() != 1 {
>> + return Err(CpuError::BadSyntax(format!(
>> + "vNUMA node {vnode_id} must be bound to exactly one host NUMA node"
>> + )));
>> + }
>> +
>> + let host_node_id = *cfg.hostnodes.first().unwrap();
>> + let host_cpus = topo.numa_cpus(host_node_id).ok_or_else(|| {
>> + CpuError::BadSyntax(format!(
>> + "host NUMA node {host_node_id} does not exist on this host"
>> + ))
>> + })?;
>> +
>> + let mut allowed = host_cpus.clone();
>> +
>> + if let Some(aff) = affinity {
>> + allowed.intersect(aff);
>> + }
>> +
>> + if allowed.is_empty() {
>> + return Err(CpuError::BadSyntax(format!(
>> + "no allowed CPUs available for host NUMA node {host_node_id} \
>> + after applying affinity mask."
>> + )));
>> + }
>> +
>> + for &vcpu_id in &cfg.vcpus {
>> + bindings.insert(vcpu_id, allowed.clone());
>> + }
>> + }
>> +
>> + Ok(bindings)
>> +}
>> +
>> +/// Applies the generated CPU bindings to the running vCPU threads.
>> +pub fn apply_bindings(
>> + bindings: &BTreeMap<u32, CpuSet>,
>> + qmp_cpuinfo: &[QmpCpu],
>> +) -> Result<(), CpuError> {
>> + for (&vcpu_id, cpuset) in bindings {
>> + let vcpu_index = vcpu_id as usize;
>> + if vcpu_index >= qmp_cpuinfo.len() {
>> + return Err(CpuError::VcpuOutOfRange {
>> + vcpu: vcpu_id,
>> + max: qmp_cpuinfo.len() as u32,
>> + });
>
> here we probably get an error when not all vcpus
> are there (hotplugging)
>
>> + }
>> +
>> + let tid = qmp_cpuinfo[vcpu_index].thread_id;
>> + sched_setaffinity(tid as libc::pid_t, cpuset).map_err(|e| CpuError::Bind {
>> + vcpu: vcpu_id,
>> + message: e.to_string(),
>> + })?;
>> + }
>> + Ok(())
>> +}
>> diff --git a/pve-qemu-server-cpu/src/config.rs b/pve-qemu-server-cpu/src/config.rs
>> new file mode 100644
>> index 0000000..a89c62c
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/config.rs
>> @@ -0,0 +1,146 @@
>> +//! Parsing of the Proxmox VE CPU and memory configuration.
>> +
>> +use serde::de::{self, Deserializer, SeqAccess, Visitor};
>> +use serde::Deserialize;
>> +use std::collections::{BTreeMap, BTreeSet, HashMap};
>> +use std::fmt;
>> +
>> +use crate::cpuset::CpuSet;
>> +use crate::error::CpuError;
>> +
>> +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
>> +#[serde(rename_all = "lowercase")]
>> +pub enum NumaPolicy {
>> + Bind,
>> + Interleave,
>> + Preferred,
>> +}
>> +
>> +/// Configuration for a single numa[N] node.
>> +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
>> +pub struct NumaConfig {
>> + /// Guest vCPU IDs assigned to this node.
>> + #[serde(default, deserialize_with = "deserialize_range_set")]
>> + pub vcpus: BTreeSet<u32>,
>> +
>> + /// Host NUMA node IDs.
>> + #[serde(default, deserialize_with = "deserialize_range_set")]
>> + pub hostnodes: BTreeSet<u32>,
>> +
>> + /// Memory provided by this node, in MiB.
>> + pub memory: u32,
>> +
>> + /// NUMA allocation policy.
>> + pub policy: Option<NumaPolicy>,
>> +}
>> +
>> +/// Parses the NUMA configuration from a JSON string.
>> +///
>> +/// Returns a `Vec` where the index corresponds to the NUMA node ID.
>> +/// Assumes the Perl layer has already validated that node IDs are
>> +/// contiguous from `0` to `N-1`.
>> +/// Parses the NUMA configuration from a JSON string.
>> +///
>> +/// Returns a `Vec` where the index corresponds to the NUMA node ID.
>> +/// Assumes the Perl layer has already validated that node IDs are
>> +/// contiguous from `0` to `N-1`.
>> +pub fn numa_config_from_json(cfg_json: &str) -> Result<Vec<NumaConfig>, CpuError> {
>> + let raw_map: HashMap<String, NumaConfig> = serde_json::from_str(cfg_json)
>> + .map_err(|e| CpuError::BadSyntax(format!("invalid NUMA JSON: {e}")))?;
>> +
>> + let len = raw_map.len();
>> +
>> + let mut configs: Vec<Option<NumaConfig>> = vec![None; len];
>> +
>> + for (key, config) in raw_map {
>> + let id_str = key.strip_prefix("numa").unwrap_or(&key);
>> + let id = id_str.parse::<usize>().map_err(|e| {
>> + CpuError::BadSyntax(format!("invalid NUMA node ID '{key}': {e}"))
>> + })?;
>> +
>> + configs[id] = Some(config);
>> + }
>> +
>> + // Unwrap the options. If Perl did its job, every slot will be filled.
>> + // We return an error instead of panicking just in case the invariant is broken.
>> + configs
>> + .into_iter()
>> + .enumerate()
>> + .map(|(i, opt)| {
>> + opt.ok_or_else(|| CpuError::BadSyntax(format!("missing NUMA node {i}")))
>> + })
>> + .collect()
>> +}
>> +
>> +/// Expands a JSON array of ranges into a `BTreeSet<u32>`.
>> +///
>> +/// Perl outputs ranges as `[[0, 3], [8, null]]`. This visitor expands them
>> +/// into a flat set of integers: `{0, 1, 2, 3, 8}`.
>> +fn deserialize_range_set<'de, D>(deserializer: D) -> Result<BTreeSet<u32>, D::Error>
>> +where
>> + D: Deserializer<'de>,
>> +{
>> + struct RangeSetVisitor;
>> +
>> + impl<'de> Visitor<'de> for RangeSetVisitor {
>> + type Value = BTreeSet<u32>;
>> +
>> + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
>> + formatter.write_str("a JSON array of ranges (e.g., [[0, 3], [8, null]])")
>> + }
>> +
>> + fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
>> + where
>> + A: SeqAccess<'de>,
>> + {
>> + let mut set = BTreeSet::new();
>> +
>> + while let Some((start, end_opt)) = seq.next_element::<(u32, Option<u32>)>()? {
>> + let end = end_opt.unwrap_or(start);
>> + if end < start {
>> + return Err(de::Error::custom(format!(
>> + "invalid range: end ({end}) < start ({start})"
>> + )));
>> + }
>> + set.extend(start..=end);
>> + }
>> +
>> + Ok(set)
>> + }
>> +
>> + fn visit_unit<E>(self) -> Result<Self::Value, E> {
>> + Ok(BTreeSet::new())
>> + }
>> +
>> + fn visit_none<E>(self) -> Result<Self::Value, E> {
>> + Ok(BTreeSet::new())
>> + }
>> + }
>> +
>> + deserializer.deserialize_any(RangeSetVisitor)
>> +}
>> +
>> +pub fn bindings_from_json(bind_map_json: &str) -> Result<BTreeMap<u32, CpuSet>, CpuError> {
>> + let raw_map: BTreeMap<u32, Vec<u32>> = serde_json::from_str(bind_map_json)
>> + .map_err(|e| CpuError::BadSyntax(format!("invalid binding map JSON: {e}")))?;
>> +
>> + let mut bindings = BTreeMap::new();
>> + for (vcpu, cpus) in raw_map {
>> + let mut set = CpuSet::new();
>> + for cpu in cpus {
>> + set.set(cpu);
>> + }
>> + bindings.insert(vcpu, set);
>> + }
>> + Ok(bindings)
>> +}
>> +
>> +pub fn bindings_to_json(bindings: &BTreeMap<u32, CpuSet>) -> Result<String, CpuError> {
>> + let map: BTreeMap<u32, Vec<u32>> = bindings
>> + .iter()
>> + .map(|(&vcpu, cpuset)| (vcpu, cpuset.iter().collect()))
>> + .collect();
>> +
>> + serde_json::to_string(&map)
>> + .map_err(|e| CpuError::BadSyntax(format!("failed to serialize bindings: {e}")))
>> +}
>> diff --git a/pve-qemu-server-cpu/src/cpuset.rs b/pve-qemu-server-cpu/src/cpuset.rs
>> new file mode 100644
>> index 0000000..d2ffcf8
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/cpuset.rs
>> @@ -0,0 +1,125 @@
>> +//! Arbitrary-precision CPU bitmask for efficient set operations.
>> +
>> +#[derive(Clone, Debug, Default, PartialEq, Eq)]
>> +pub struct CpuSet {
>> + bits: Vec<u64>,
>> +}
>
> this is a very nice optimization here,and a good way to be efficient,
> but IMHO a bit overkill for this?
>
> we only calculate this once per start
> (and maybe once per hotplug) so having a e.g. Vec<bool>
> or even a HashSet<u64> could be enought?
>
> this would remove most of the implementation code here
> and keep the usage mostly the same?
>
> OTOH, you did the work already so :shrug:
>
This is analog to the approach by the hwloc library and how taskset
computes the cpuset internally (AFAIK). So implementing this was
straightforward.
>> +
>> +struct WordBits {
>> + base: u32,
>> + remaining: u64,
>> +}
>> +
>> +impl Iterator for WordBits {
>> + type Item = u32;
>> +
>> + fn next(&mut self) -> Option<u32> {
>> + if self.remaining == 0 {
>> + return None;
>> + }
>> + let bit = self.remaining.trailing_zeros();
>> + // Clear the lowest set bit so the next call finds the following one.
>> + self.remaining &= self.remaining - 1;
>> + Some(self.base + bit)
>> + }
>> +}
>> +
>> +impl CpuSet {
>> + pub fn new() -> Self {
>> + Self { bits: Vec::new() }
>> + }
>> +
>> + pub fn set(&mut self, cpu: u32) {
>> + let idx = (cpu / 64) as usize;
>> + let bit = cpu % 64;
>> + if idx >= self.bits.len() {
>> + self.bits.resize(idx + 1, 0);
>> + }
>> + self.bits[idx] |= 1u64 << bit;
>> + }
>> +
>> + pub fn intersect(&mut self, other: &CpuSet) {
>> + for (i, word) in self.bits.iter_mut().enumerate() {
>> + if i < other.bits.len() {
>> + *word &= other.bits[i];
>> + } else {
>> + *word = 0;
>> + }
>> + }
>> + }
>> +
>> + pub fn union(&mut self, other: &CpuSet) {
>> + if other.bits.len() > self.bits.len() {
>> + self.bits.resize(other.bits.len(), 0);
>> + }
>> + for (i, word) in other.bits.iter().enumerate() {
>> + self.bits[i] |= word;
>> + }
>> + }
>> +
>> + pub fn is_empty(&self) -> bool {
>> + self.bits.iter().all(|&w| w == 0)
>> + }
>> +
>> + pub fn size(&self) -> usize {
>> + self.bits.iter().map(|w| w.count_ones() as usize).sum()
>> + }
>> +
>> + pub fn first_set(&self) -> Option<u32> {
>> + self.iter().next()
>> + }
>> +
>> + pub fn iter(&self) -> impl Iterator<Item = u32> + '_ {
>> + self.bits
>> + .iter()
>> + .enumerate()
>> + .flat_map(|(idx, &word)| WordBits {
>> + base: (idx as u32) * 64,
>> + remaining: word,
>> + })
>> + }
>> +
>> + /// Returns the set members as an ascending vector.
>> + pub fn to_vec(&self) -> Vec<u32> {
>> + self.iter().collect()
>> + }
>> +
>> + /// Converts the bitmask to a `libc::cpu_set_t` for `sched_setaffinity`.
>> + pub fn to_cpu_set_t(&self) -> libc::cpu_set_t {
>> + unsafe {
>> + let mut set: libc::cpu_set_t = std::mem::zeroed();
>> + for cpu in self.iter() {
>> + libc::CPU_SET(cpu as usize, &mut set);
>> + }
>> + set
>> + }
>> + }
>> +
>> + /// Parses sysfs CPU lists, for example `online`, `cpulist`, `core_cpus_list`.
>> + ///
>> + /// Format: comma-separated CPU IDs and inclusive ranges, such as `0-15,18-31`.
>> + pub fn from_list(list: &str) -> Self {
>> + let mut set = CpuSet::new();
>> + let list = list.trim();
>> + if list.is_empty() {
>> + return set;
>> + }
>> +
>> + for part in list.split(',') {
>> + let part = part.trim();
>> + if part.is_empty() {
>> + continue;
>> + }
>> + if let Some((start_raw, end_raw)) = part.split_once('-') {
>> + let start: u32 = start_raw.trim().parse().unwrap_or(0);
>> + let end: u32 = end_raw.trim().parse().unwrap_or(start);
>> + for i in start..=end {
>> + set.set(i);
>> + }
>> + } else if let Ok(cpu) = part.parse::<u32>() {
>> + set.set(cpu);
>> + }
>> + }
>> + set
>> + }
>> +}
>> diff --git a/pve-qemu-server-cpu/src/error.rs b/pve-qemu-server-cpu/src/error.rs
>> new file mode 100644
>> index 0000000..2efbc12
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/error.rs
>> @@ -0,0 +1,32 @@
>> +use thiserror::Error;
>> +
>> +#[derive(Debug, Error)]
>> +#[error("cpu binding: {0}")]
>> +pub enum CpuError {
>> + #[error("invalid syntax in: '{0}'")]
>> + BadSyntax(String),
>> +
>> + // Validation errors (pre-start)
>> + #[error("host CPU {0} does not exist in this topology")]
>> + UnknownHostCpu(u32),
>> +
>> + #[error("vCPU {vcpu} is out of range (VM has vCPUs 0..{max})")]
>> + VcpuOutOfRange { vcpu: u32, max: u32 },
>> +
>> + // Runtime errors (post-start)
>> + #[error("no running thread found for vCPU {0}")]
>> + ThreadNotFound(u32),
>> +
>> + #[error("invalid kernel TID {tid} for vCPU {vcpu}")]
>> + BadThreadId { vcpu: u32, tid: u32 },
>> +
>> + #[error("failed to init host topology: '{0}'")]
>> + TopologyInit(String),
>> +
>> + #[error("binding vCPU {vcpu} failed: {message}")]
>> + Bind {
>> + vcpu: u32,
>> + /// Human-readable error from sched_setaffinity(2)
>> + message: String,
>> + },
>> +}
>> diff --git a/pve-qemu-server-cpu/src/lib.rs b/pve-qemu-server-cpu/src/lib.rs
>> new file mode 100644
>> index 0000000..cf19aa8
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/lib.rs
>> @@ -0,0 +1,92 @@
>> +mod bind;
>> +mod cpuset;
>> +mod error;
>> +mod config;
>> +mod qmp;
>> +mod syscall;
>> +mod topology;
>> +
>> +/// Generate vcpu:cpu(s) binding map for a guest
>> +///
>> +/// # Arguments
>> +///
>> +/// * `mode` - Pinning mode.
>> +/// * `sockets` - number of sockets configured in <vmid.conf>
>> +/// * `cores` - number of cores configured in <vmid.conf>
>> +/// * `affinity` - Upper bound of host cpus that can be used for binding.
>> +/// * `cfg_json` - Additional config options. (e.g. numa config)
>> +/// * `cpuinfo_json` - JSON output from QMP `query-cpus-fast`.
>> +///
>> +/// # Modes
>> +///
>> +/// | Mode | Meaning |
>> +/// |---|---|
>> +/// | `none` | Do not pin vCPUs. |
>> +/// | `one-to-one` | Assign each vCPU to its own cpu. |
>> +/// | `numa` | Map guest NUMA nodes to host NUMA nodes |
>> +///
>> +/// # Examples
>> +///
>> +/// ```ignore
>> +/// // One-to-one mode:
>> +/// // Distribute vCPUs over host CPUs 0-7.
>> +/// gen_vcpu_bindings("one-to-one", 1, 8, "0-7", "", &cpuinfo_json)?;
>> +///
>> +/// // One-to-one mode over all allowed host CPUs.
>> +/// gen_vcpu_bindings("one-to-one", 1, 4 "", "", &cpuinfo_json)?;
>> +///
>> +/// // NUMA mode:
>> +/// // NUMA mode over all allowed host NUMA nodes.
>> +/// gen_vcpu_bindings("numa", 2, 4, "", &cfg_json, &cpuinfo_json)?;
>> +///
>> +/// // NUMA mode respecting the set affinity
>> +/// gen_vcpu_bindings("numa", 4, 2, "0-7", &cfg_json, &cpuinfo_json)?;
>> +/// ```
>> +///
>> +/// # Errors
>> +///
>> +/// Returns [`CpuError`] if the mode or binding syntax is invalid, if the
>> +/// requested host CPUs or NUMA nodes do not exist, or if binding fails.
>> +pub fn gen_vcpu_bindings(
>> + mode: &str,
>> + sockets: u32,
>> + cores: u32,
>> + affinity: &str,
>> + cfg_json: &str,
>> +) -> Result<String, error::CpuError> {
>
> i'd much prefer 'real' types here at the boundary
> e.g. we can just export the `QmpCpu` etc. structs
> (they already have to impl deserialize) and
> should use that in the perl bindings, or is that not possible for some
> reason? If there is one, it would definitely belong in
> the commit message or cover letter
No specific reason for the json here tbh. Mostly just a habit. I will
implement it in a similar fashion to your PCI series! (Assuming the code
will remain implemented in rust)
>> + let cpu_affinity = if affinity.is_empty() {
>> + None
>> + } else {
>> + Some(cpuset::CpuSet::from_list(affinity))
>> + };
>> +
>> + let bindings: std::collections::BTreeMap<u32, cpuset::CpuSet> = match mode.parse::<bind::Mode>()? {
>> + bind::Mode::None => return Ok("{}".to_string()),
>
> together with the qemu-server patch 4/4 this now skips the
> affinity when cpu-binding-mode is 'none', since the
> qemu-server check skips the taskset and here we return nothing.
>
> we should either return the affinity map for all cores here
> or let the taskset run throuh in qemu-server
>
> (actually we could let the taskset limit the threads anyway, this
> code here can only further restrict it AFAICS)
>
Good catch! I would prefer to just have something like
if (cpu-binding-mode == 'none') {
// init qemu using taskset
}
But I am thinking of simply removing the 'none' state alltogether, as it
seems redundant.
>> + bind::Mode::OneToOne => {
>> + // only_real_cores is hardcoded to false for now, until we device if we actually want this setting
>> + bind::gen_one_to_one_bindings(sockets, cores, &cpu_affinity, false)?
>> + }
>> + bind::Mode::Numa => {
>> + let numa_cfg = config::numa_config_from_json(cfg_json)?;
>> + bind::gen_numa_bindings(&numa_cfg, &cpu_affinity)?
>> + }
>> + };
>> +
>> + // This shouldn't happen, but we should still avoid passing empty config to perl
>> + if bindings.is_empty() {
>> + return Err(error::CpuError::BadSyntax(
>> + "cpu-binding-mode '{mode}' is enabled but no vCPU bindings were generated".to_string(),
>> + ));
>> + }
>> +
>> + config::bindings_to_json(&bindings)
>> +}
>> +
>> +/// Apply vcpu:cpu(s) the binding map
>> +/// The function parses the QMP `query-cpus-fast` response and binds each
>> +/// vCPU thread according to the selected mode.
>> +pub fn bind_vcpus(bind_map_json: &str, qmp_cpuinfo_json: &str) -> Result<(), error::CpuError> {
>> + let bindings = config::bindings_from_json(bind_map_json)?;
>> + let qmp_cpuinfo = qmp::parse_cpuinfo(qmp_cpuinfo_json)?;
>> + bind::apply_bindings(&bindings, &qmp_cpuinfo)
>> +}
>> diff --git a/pve-qemu-server-cpu/src/qmp.rs b/pve-qemu-server-cpu/src/qmp.rs
>> new file mode 100644
>> index 0000000..78fb8bd
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/qmp.rs
>> @@ -0,0 +1,91 @@
>> +//! Parsing of the QEMU `query-cpus-fast` QMP response.
>> +//!
>> +//! The response is a JSON array; each element describes one guest vCPU
>> +//! and carries both its guest-visible topology (socket/core/NUMA node)
>> +//! and its host kernel TID. Every binding mode consumes this shape, so
>> +//! the parsing lives here rather than inside any individual mode.
>> +//!
>> +//! The full QEMU schema is modeled, including fields not currently used
>> +//! by any binding mode. Serde ignores fields it doesn't know about, but
>> +//! keeping them explicit documents the wire format and makes future
>> +//! modes cheaper to implement.
>> +
>> +use serde::Deserialize;
>> +
>> +use crate::error::CpuError;
>> +
>> +/// One entry of the `query-cpus-fast` array.
>> +#[derive(Debug, Clone, Deserialize)]
>> +pub struct QmpCpu {
>> + /// Guest-visible vCPU index (0 .. sockets*cores).
>> + #[serde(rename = "cpu-index")]
>> + pub cpu_index: u32,
>> +
>> + /// Host kernel TID of the QEMU vCPU thread.
>> + #[serde(rename = "thread-id")]
>> + pub thread_id: u32,
>> +
>> + /// QOM path of the CPU object, e.g. `/machine/unattached/device[0]`.
>> + #[expect(dead_code)]
>> + #[serde(rename = "qom-path")]
>> + pub qom_path: String,
>> +
>> + /// QOM type of the CPU object, e.g. `host-x86_64-cpu`.
>> + #[expect(dead_code)]
>> + #[serde(rename = "qom-type")]
>> + pub qom_type: String,
>> +
>> + /// Target architecture, e.g. `x86_64`.
>> + #[expect(dead_code)]
>> + pub target: String,
>> +
>> + /// Guest-visible topology properties of the vCPU.
>> + #[expect(dead_code)]
>> + pub props: QmpCpuProps,
>> +}
>> +
>> +/// Guest-visible topology properties of a vCPU.
>> +#[derive(Debug, Clone, Deserialize)]
>> +pub struct QmpCpuProps {
>> + /// Guest socket the vCPU belongs to.
>> + #[expect(dead_code)]
>> + #[serde(rename = "socket-id")]
>> + pub socket_id: u32,
>> +
>> + /// Guest core within that socket.
>> + #[expect(dead_code)]
>> + #[serde(rename = "core-id")]
>> + pub core_id: u32,
>> +
>> + /// Guest NUMA node the vCPU belongs to.
>> + ///
>> + /// QEMU reports this even when `numa` is disabled in the VM config,
>> + /// in which case every vCPU is on node 0.
>> + #[expect(dead_code)]
>> + #[serde(rename = "node-id")]
>> + pub node_id: u32,
>> +
>> + /// Guest thread within the core.
>> + ///
>> + /// Always 0 today: QEMU's CPU object model carries this field for
>> + /// SMT support in the guest, but PVE does not expose SMT to guests,
>> + /// so it is always zero in practice. Modeled for completeness.
>> + /// TODO: PVE should expose SMT to the guests
>> + #[expect(dead_code)]
>> + #[serde(rename = "thread-id")]
>> + pub thread_id: u32,
>> +}
>
> not sure about it, but are these fields always present? if not
> the deserialization will fail. marking them with #[serde(default)] or
> making them options would be a solution for that
>
Noted. As far as I can tell these fields are always present.
>> +
>> +// returned vec is sorted by vCPU id (0,1,2,3...)
>> +// Guarantees vec[id] == vec[id].cpu_index
>> +pub fn parse_cpuinfo(cpuinfo_json: &str) -> Result<Vec<QmpCpu>, CpuError> {
>> + let mut cpus: Vec<QmpCpu> = serde_json::from_str(cpuinfo_json)
>> + .map_err(|e| CpuError::BadSyntax(format!("invalid query-cpus-fast JSON: {e}")))?;
>> +
>> + // QEMU assigns cpu-index sequentially from 0. Sort by it so
>> + // `vec[i]` indexes vCPU i,
>> + // value should be 0..N-1 so that assumption holds.
>> + cpus.sort_unstable_by_key(|c| c.cpu_index);
>> +
>> + Ok(cpus)
>> +}
>> diff --git a/pve-qemu-server-cpu/src/syscall.rs b/pve-qemu-server-cpu/src/syscall.rs
>> new file mode 100644
>> index 0000000..59b74a9
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/syscall.rs
>> @@ -0,0 +1,24 @@
>> +//! Safe wrappers around Linux syscalls.
>> +
>> +#[cfg(target_os = "linux")]
>> +use std::io;
>> +
>> +use crate::cpuset::CpuSet;
>> +
>> +pub fn sched_setaffinity(tid: libc::pid_t, cpus: &CpuSet) -> io::Result<()> {
>> + let set = cpus.to_cpu_set_t();
>> +
>> + unsafe {
>> + let rc = libc::sched_setaffinity(
>> + tid,
>> + std::mem::size_of::<libc::cpu_set_t>(),
>> + &set,
>> + );
>> +
>> + if rc != 0 {
>> + return Err(io::Error::last_os_error());
>> + }
>> + }
>> +
>> + Ok(())
>> +}
>> diff --git a/pve-qemu-server-cpu/src/topology/mod.rs b/pve-qemu-server-cpu/src/topology/mod.rs
>> new file mode 100644
>> index 0000000..3d7ffaa
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/topology/mod.rs
>> @@ -0,0 +1,222 @@
>> +//! Hierarchical hardware topology discovered from sysfs.
>> +//!
>> +//! The topology is a tree rooted at the machine. Every node owns its
>> +//! children and there are no parent pointers, so traversal is top-down.
>> +//!
>> +//! On modern systems (like AMD EPYC), the hierarchy typically looks like:
>> +//!
>> +//! ```text
>> +//! Machine -> Package -> Die -> NumaNode -> Core -> Pu
>> +//! ```
>> +
>> +mod sysfs;
>> +
>> +use std::collections::HashMap;
>> +use std::fs;
>> +use std::path::Path;
>> +
>> +use crate::cpuset::CpuSet;
>> +use crate::error::CpuError;
>> +
>> +const CPU_DIR: &str = "/sys/devices/system/cpu";
>> +const NODE_DIR: &str = "/sys/devices/system/node";
>> +
>> +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
>> +pub enum ObjectKind {
>> + Machine,
>> + Package,
>> + Die,
>> + NumaNode,
>> + // Cache, // Future extension
>> + Core,
>> + Pu,
>> +}
>
> probably nice to have this (in the future), but we probably should only
> model stuff we can represent for now? we can't e.g. model multiple dies
> of a cpu in our config, so this is kinda wasted?
>
Hmm ok, this design is heavily inspired by hwloc, since IMO there might
be some neat future use cases (automatic placement/rebalancing, or
different pinning options entirely). But I will omitt it for now, to
keep it simple.
>> +
>> +/// A node in the hardware topology tree.
>> +///
>> +/// Each node owns its children. The `cpuset` covers every CPU at or below
>> +/// this node. `os_index` is the operating-system index (hwloc's `P#`).
>> +#[derive(Debug, Clone)]
>> +pub struct TopoObject {
>> + pub kind: ObjectKind,
>> + pub os_index: u32,
>> + pub cpuset: CpuSet,
>> + pub children: Vec<TopoObject>,
>> +}
>> +
>> +impl TopoObject {
>> + fn new(kind: ObjectKind, os_index: u32) -> Self {
>> + Self {
>> + kind,
>> + os_index,
>> + cpuset: CpuSet::new(),
>> + children: Vec::new(),
>> + }
>> + }
>> +
>> + /// Finds an existing child by kind and index, or creates and appends a new one.
>> + fn get_or_add_child(&mut self, kind: ObjectKind, os_index: u32) -> &mut TopoObject {
>> + let pos = self
>> + .children
>> + .iter()
>> + .position(|c| c.kind == kind && c.os_index == os_index)
>> + .unwrap_or_else(|| {
>> + self.children.push(TopoObject::new(kind, os_index));
>> + self.children.len() - 1
>> + });
>> +
>> + &mut self.children[pos]
>> + }
>> +
>> + /// Finds the first node matching `kind` and `os_index` in this subtree.
>> + pub fn find(&self, kind: ObjectKind, os_index: u32) -> Option<&TopoObject> {
>> + if self.kind == kind && self.os_index == os_index {
>> + return Some(self);
>> + }
>> + for child in &self.children {
>> + if let Some(found) = child.find(kind, os_index) {
>> + return Some(found);
>> + }
>> + }
>> + None
>> + }
>> +
>> + /// Calls `f` for every node matching `kind` in this subtree.
>> + pub fn for_each(&self, kind: ObjectKind, f: &mut dyn FnMut(&TopoObject)) {
>> + if self.kind == kind {
>> + f(self);
>> + }
>> + for child in &self.children {
>> + child.for_each(kind, &mut *f);
>> + }
>> + }
>> +
>> + /// Computes this node's cpuset bottom-up from its children.
>> + fn compute_cpuset(&mut self) {
>> + self.cpuset = CpuSet::new();
>> + if self.kind == ObjectKind::Pu {
>> + self.cpuset.set(self.os_index);
>> + } else {
>> + for child in &mut self.children {
>> + child.compute_cpuset();
>> + self.cpuset.union(&child.cpuset);
>> + }
>> + }
>> + }
>> +}
>> +
>> +#[derive(Debug, Clone)]
>> +pub struct Topology {
>> + online_cpus: CpuSet,
>> + root: TopoObject,
>> +}
>> +
>> +impl Topology {
>> + pub fn new() -> Result<Self, CpuError> {
>> + let online_cpus = sysfs::read_file(&Path::new(CPU_DIR).join("online"))
>> + .map(|s| CpuSet::from_list(&s))
>> + .ok_or_else(|| {
>> + CpuError::TopologyInit("cannot read the online CPU mask".to_string())
>> + })?;
>> +
>> + let cpu_to_numa = Self::read_cpu_to_numa();
>> +
>> + let mut root = TopoObject::new(ObjectKind::Machine, 0);
>> + Self::build_tree(&mut root, &online_cpus, &cpu_to_numa)?;
>> +
>> + root.compute_cpuset();
>> +
>> + Ok(Topology { online_cpus, root })
>> + }
>> +
>> + fn build_tree(
>> + root: &mut TopoObject,
>> + online_cpus: &CpuSet,
>> + cpu_to_numa: &HashMap<u32, u32>,
>> + ) -> Result<(), CpuError> {
>> + let cpu_dir = Path::new(CPU_DIR);
>> +
>> + for cpu_id in online_cpus.iter() {
>> + let topo_dir = cpu_dir.join(format!("cpu{cpu_id}")).join("topology");
>> +
>> + let pkg_id = sysfs::read_file(&topo_dir.join("physical_package_id"))
>> + .and_then(|s| s.parse().ok())
>> + .unwrap_or(0);
>> +
>> + let die_id = sysfs::read_file(&topo_dir.join("die_id"))
>> + .and_then(|s| s.parse().ok())
>> + .unwrap_or(0);
>> +
>> + let core_id = sysfs::read_file(&topo_dir.join("core_id"))
>> + .and_then(|s| s.parse().ok())
>> + .unwrap_or(cpu_id);
>> +
>> + let pkg = root.get_or_add_child(ObjectKind::Package, pkg_id);
>> + let die = pkg.get_or_add_child(ObjectKind::Die, die_id);
>> +
>> + // NumaNode is optional. If present, it sits between Die and Core.
>> + let parent_of_core = if let Some(numa_id) = cpu_to_numa.get(&cpu_id).copied() {
>> + die.get_or_add_child(ObjectKind::NumaNode, numa_id)
>> + } else {
>> + &mut *die
>> + };
>> +
>> + let core = parent_of_core.get_or_add_child(ObjectKind::Core, core_id);
>> + core.children.push(TopoObject::new(ObjectKind::Pu, cpu_id));
>> + }
>> +
>> + Ok(())
>> + }
>> +
>> + pub fn online_cpus(&self) -> &CpuSet {
>> + &self.online_cpus
>> + }
>> +
>> + pub fn numa_cpus(&self, os_index: u32) -> Option<&CpuSet> {
>> + self.root
>> + .find(ObjectKind::NumaNode, os_index)
>> + .map(|node| &node.cpuset)
>> + }
>> +
>> + /// Reduces `cpus` to at most one thread per physical core.
>> + /// (Avoids SMT siblings)
>> + pub fn singlify_per_core(&self, cpus: &CpuSet) -> CpuSet {
>> + let mut result = CpuSet::new();
>> + self.root.for_each(ObjectKind::Core, &mut |core| {
>> + let mut core_cpus = core.cpuset.clone();
>> + core_cpus.intersect(cpus);
>> + if let Some(first) = core_cpus.first_set() {
>> + result.set(first);
>> + }
>> + });
>> + result
>> + }
>> +
>> + fn read_cpu_to_numa() -> HashMap<u32, u32> {
>> + let mut map = HashMap::new();
>> + let node_dir = Path::new(NODE_DIR);
>> +
>> + let entries = match fs::read_dir(node_dir) {
>> + Ok(entries) => entries,
>> + Err(_) => return map,
>> + };
>> +
>> + for entry in entries.flatten() {
>> + let name = entry.file_name();
>> + let name_str = name.to_string_lossy();
>> + let node_id = match name_str.strip_prefix("node").and_then(|s| s.parse::<u32>().ok()) {
>> + Some(id) => id,
>> + None => continue,
>> + };
>> +
>> + let cpuset = sysfs::read_file(&entry.path().join("cpulist"))
>> + .map(|s| CpuSet::from_list(&s))
>> + .unwrap_or_else(CpuSet::new);
>> +
>> + for cpu in cpuset.iter() {
>> + map.insert(cpu, node_id);
>> + }
>> + }
>> + map
>> + }
>> +}
>> diff --git a/pve-qemu-server-cpu/src/topology/sysfs.rs b/pve-qemu-server-cpu/src/topology/sysfs.rs
>> new file mode 100644
>> index 0000000..a1ff67a
>> --- /dev/null
>> +++ b/pve-qemu-server-cpu/src/topology/sysfs.rs
>> @@ -0,0 +1,6 @@
>> +use std::fs;
>> +use std::path::Path;
>> +
>> +pub fn read_file(path: &Path) -> Option<String> {
>> + fs::read_to_string(path).ok().map(|s| s.trim().to_string())
>> +}
>
>
> there are already helpers in proxmox-sys::fs::file for things like this
> (e.g. `file_read_string`)
>
> it's just a small function but reusing the ones we have is better IMO
Thanks, I wasn't aware of this!
next prev parent reply other threads:[~2026-11-19 9:17 UTC|newest]
Thread overview: 22+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-11 15:20 [RFC proxmox-perl-rs/qemu-server/qemu-server-rs v4 0/4] vCPU binding for qemu guests Elias Huhsovitz
2026-11-11 15:20 ` [PATCH qemu-server-rs v4 1/4] cpu: add pve-qemu-server-cpu crate for vCPU binding Elias Huhsovitz
2026-11-17 16:28 ` Dominik Csapak
2026-11-19 9:16 ` Elias Huhsovitz [this message]
2026-11-19 10:06 ` Dominik Csapak
2026-11-17 17:20 ` Thomas Lamprecht
2026-11-18 7:47 ` Dominik Csapak
2026-11-18 8:32 ` Thomas Lamprecht
2026-11-18 10:14 ` Fiona Ebner
2026-11-18 11:17 ` Elias Huhsovitz
2026-11-18 11:44 ` Thomas Lamprecht
2026-11-18 13:05 ` Elias Huhsovitz
2026-11-11 15:20 ` [PATCH proxmox-perl-rs v4 2/4] pve: cpu: add binding for pve-qemu-server-cpu crate Elias Huhsovitz
2026-11-17 16:37 ` Dominik Csapak
2026-11-11 15:20 ` [PATCH qemu-server v4 3/4] helpers: return integer values for parse_number_sets Elias Huhsovitz
2026-11-17 16:39 ` Dominik Csapak
2026-11-11 15:20 ` [PATCH qemu-server v4 4/4] cpu: add cpu binding Elias Huhsovitz
2026-11-17 16:36 ` Dominik Csapak
2026-11-19 9:35 ` Elias Huhsovitz
2026-11-19 10:07 ` Dominik Csapak
2026-11-19 13:16 ` Elias Huhsovitz
2026-11-19 17:08 ` Dominik Csapak
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=DMZ2OMG2IIYY.2JCJ4KQ3VW8QQ@proxmox.com \
--to=e.huhsovitz@proxmox.com \
--cc=d.csapak@proxmox.com \
--cc=pve-devel@lists.proxmox.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox