Merge tag 'cpufreq-arm-fixes-6.16-rc' of git://git.kernel.org/pub/scm/linux/kernel/git/vireshk/pm (332d6a94) · Commits · git / linux-net

MAINTAINERS

+1 −0

Original line number	Diff line number	Diff line
		@@ -6254,6 +6254,7 @@ F: include/linux/cpuhotplug.h
		F: include/linux/smpboot.h
		F: kernel/cpu.c
		F: kernel/smpboot.*
		F: rust/helper/cpu.c
		F: rust/kernel/cpu.rs

		CPU IDLE TIME MANAGEMENT FRAMEWORK

drivers/cpufreq/rcpufreq_dt.rs

+2 −2

Original line number	Diff line number	Diff line
		@@ -26,9 +26,9 @@ fn find_supply_name_exact(dev: &Device, name: &str) -> Option<CString> {
		}

		/// Finds supply name for the CPU from DT.
		fn find_supply_names(dev: &Device, cpu: u32) -> Option<KVec<CString>> {
		fn find_supply_names(dev: &Device, cpu: cpu::CpuId) -> Option<KVec<CString>> {
		// Try "cpu0" for older DTs, fallback to "cpu".
		let name = (cpu == 0)
		let name = (cpu.as_u32() == 0)
		.then(\|\| find_supply_name_exact(dev, "cpu0"))
		.flatten()
		.or_else(\|\| find_supply_name_exact(dev, "cpu"))?;

rust/helpers/cpu.c

0 → 100644

+8 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0

		#include <linux/smp.h>

		unsigned int rust_helper_raw_smp_processor_id(void)
		{
		return raw_smp_processor_id();
		}

rust/helpers/helpers.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -13,6 +13,7 @@
		#include "build_assert.c"
		#include "build_bug.c"
		#include "clk.c"
		#include "cpu.c"
		#include "cpufreq.c"
		#include "cpumask.c"
		#include "cred.c"

rust/kernel/cpu.rs

+123 −2

Original line number	Diff line number	Diff line
		@@ -6,6 +6,127 @@

		use crate::{bindings, device::Device, error::Result, prelude::ENODEV};

		/// Returns the maximum number of possible CPUs in the current system configuration.
		#[inline]
		pub fn nr_cpu_ids() -> u32 {
		#[cfg(any(NR_CPUS_1, CONFIG_FORCE_NR_CPUS))]
		{
		bindings::NR_CPUS
		}

		#[cfg(not(any(NR_CPUS_1, CONFIG_FORCE_NR_CPUS)))]
		// SAFETY: `nr_cpu_ids` is a valid global provided by the kernel.
		unsafe {
		bindings::nr_cpu_ids
		}
		}

		/// The CPU ID.
		///
		/// Represents a CPU identifier as a wrapper around an [`u32`].
		///
		/// # Invariants
		///
		/// The CPU ID lies within the range `[0, nr_cpu_ids())`.
		///
		/// # Examples
		///
		/// ```
		/// use kernel::cpu::CpuId;
		///
		/// let cpu = 0;
		///
		/// // SAFETY: 0 is always a valid CPU number.
		/// let id = unsafe { CpuId::from_u32_unchecked(cpu) };
		///
		/// assert_eq!(id.as_u32(), cpu);
		/// assert!(CpuId::from_i32(0).is_some());
		/// assert!(CpuId::from_i32(-1).is_none());
		/// ```
		#[derive(Copy, Clone, PartialEq, Eq, Debug)]
		pub struct CpuId(u32);

		impl CpuId {
		/// Creates a new [`CpuId`] from the given `id` without checking bounds.
		///
		/// # Safety
		///
		/// The caller must ensure that `id` is a valid CPU ID (i.e., `0 <= id < nr_cpu_ids()`).
		#[inline]
		pub unsafe fn from_i32_unchecked(id: i32) -> Self {
		debug_assert!(id >= 0);
		debug_assert!((id as u32) < nr_cpu_ids());

		// INVARIANT: The function safety guarantees `id` is a valid CPU id.
		Self(id as u32)
		}

		/// Creates a new [`CpuId`] from the given `id`, checking that it is valid.
		pub fn from_i32(id: i32) -> Option<Self> {
		if id < 0 \|\| id as u32 >= nr_cpu_ids() {
		None
		} else {
		// INVARIANT: `id` has just been checked as a valid CPU ID.
		Some(Self(id as u32))
		}
		}

		/// Creates a new [`CpuId`] from the given `id` without checking bounds.
		///
		/// # Safety
		///
		/// The caller must ensure that `id` is a valid CPU ID (i.e., `0 <= id < nr_cpu_ids()`).
		#[inline]
		pub unsafe fn from_u32_unchecked(id: u32) -> Self {
		debug_assert!(id < nr_cpu_ids());

		// Ensure the `id` fits in an [`i32`] as it's also representable that way.
		debug_assert!(id <= i32::MAX as u32);

		// INVARIANT: The function safety guarantees `id` is a valid CPU id.
		Self(id)
		}

		/// Creates a new [`CpuId`] from the given `id`, checking that it is valid.
		pub fn from_u32(id: u32) -> Option<Self> {
		if id >= nr_cpu_ids() {
		None
		} else {
		// INVARIANT: `id` has just been checked as a valid CPU ID.
		Some(Self(id))
		}
		}

		/// Returns CPU number.
		#[inline]
		pub fn as_u32(&self) -> u32 {
		self.0
		}

		/// Returns the ID of the CPU the code is currently running on.
		///
		/// The returned value is considered unstable because it may change
		/// unexpectedly due to preemption or CPU migration. It should only be
		/// used when the context ensures that the task remains on the same CPU
		/// or the users could use a stale (yet valid) CPU ID.
		pub fn current() -> Self {
		// SAFETY: raw_smp_processor_id() always returns a valid CPU ID.
		unsafe { Self::from_u32_unchecked(bindings::raw_smp_processor_id()) }
		}
		}

		impl From<CpuId> for u32 {
		fn from(id: CpuId) -> Self {
		id.as_u32()
		}
		}

		impl From<CpuId> for i32 {
		fn from(id: CpuId) -> Self {
		id.as_u32() as i32
		}
		}

		/// Creates a new instance of CPU's device.
		///
		/// # Safety
		@@ -17,9 +138,9 @@
		/// Callers must ensure that the CPU device is not used after it has been unregistered.
		/// This can be achieved, for example, by registering a CPU hotplug notifier and removing
		/// any references to the CPU device within the notifier's callback.
		pub unsafe fn from_cpu(cpu: u32) -> Result<&'static Device> {
		pub unsafe fn from_cpu(cpu: CpuId) -> Result<&'static Device> {
		// SAFETY: It is safe to call `get_cpu_device()` for any CPU.
		let ptr = unsafe { bindings::get_cpu_device(cpu) };
		let ptr = unsafe { bindings::get_cpu_device(u32::from(cpu)) };
		if ptr.is_null() {
		return Err(ENODEV);
		}