github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-06 21:58:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

arm_mpam: prepare mon_sel locking for MPAM-Fb

Browse Source 
The MSC MON_SEL register needs to be accessed from hardirq for the overflow
interrupt, and when taking an IPI to access these registers on platforms
where MSCs are not accesible from every CPU. This makes an irqsave
spinlock the obvious lock to protect these registers. On systems with
MPAM-Fb mailbox MSC access it must be able to sleep, meaning a mutex must
be used. So MPAM-Fb platforms cannot support an overflow interrupt easily.
Clearly these two methods can't exist for one MSC at the same time.

Change the mon_sel locking wrapper function to only use a spinlock when
the MSC is accessed directly via MMIO. In case of MPAM-Fb, we use a
mutex, but only if we are in a sleepable context. If that's not the
case, we return an error. This should not happen, as MPAM-Fb by design
does not require an MSC access to happen from a specific CPU, so there
is no need for any IPIs or preemption disabling to satisfy CPU
constraints. And since overflow interrupts are not supported at the moment
anyway, we also wouldn't meet the other case.
Bailing out early is already happening in rare occasions today.

Signed-off-by: Andre Przywara <andre.przywara@arm.com>
Reviewed-by: Jonathan Cameron <jonathan.cameron@oss.qualcomm.com>
Reviewed-by: Ben Horgan <ben.horgan@arm.com>
Reviewed-by: Gavin Shan <gshan@redhat.com>
Tested-by: Gavin Shan <gshan@redhat.com> # on NVIDIA Grace Hopper
Signed-off-by: James Morse <james.morse@arm.com>
This commit is contained in:
Andre Przywara 2026-10-01 17:34:35 +02:00 committed by James Morse
parent cea32229ec
commit ca539a37d5
2 changed files with 41 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/resctrl/mpam_devices.c
View File

@ -2349,7 +2349,6 @@ static struct mpam_msc *do_mpam_msc_drv_probe(struct platform_device *pdev)
if (err)
return ERR_PTR(err);
mpam_mon_sel_lock_init(msc);
msc->id = pdev->id;
msc->pdev = pdev;
INIT_LIST_HEAD_RCU(&msc->all_msc_list);
@ -2370,6 +2369,11 @@ static struct mpam_msc *do_mpam_msc_drv_probe(struct platform_device *pdev)
else
msc->iface = MPAM_IFACE_PCC;
/* Lock type depends on MSC interface used */
err = mpam_mon_sel_lock_init(dev, msc);
if (err)
return ERR_PTR(err);
if (msc->iface == MPAM_IFACE_MMIO) {
void __iomem *io;

43
drivers/resctrl/mpam_internal.h
View File

@ -126,6 +126,12 @@ struct mpam_msc {
*/
raw_spinlock_t _mon_sel_lock;
unsigned long _mon_sel_flags;
/*
* mon_sel_mutex is the mutex version of the _mon_sel_lock above.
* Always use the mpam_mon_sel_lock() helpers when taking the lock,
* as this will select the correct lock type automatically.
*/
struct mutex mon_sel_mutex;
void __iomem *mapped_hwpage;
size_t mapped_hwpage_sz;
@ -139,27 +145,50 @@ struct mpam_msc {
/* Returning false here means accesses to mon_sel must fail and report an error. */
static inline bool __must_check mpam_mon_sel_lock(struct mpam_msc *msc)
{
/* Locking will require updating to support a firmware backed interface */
if (WARN_ON_ONCE(msc->iface != MPAM_IFACE_MMIO))
if (msc->iface == MPAM_IFACE_MMIO) {
raw_spin_lock_irqsave(&msc->_mon_sel_lock, msc->_mon_sel_flags);
return true;
}
if (!preemptible())
return false;
raw_spin_lock_irqsave(&msc->_mon_sel_lock, msc->_mon_sel_flags);
mutex_lock(&msc->mon_sel_mutex);
return true;
}
static inline void mpam_mon_sel_unlock(struct mpam_msc *msc)
{
raw_spin_unlock_irqrestore(&msc->_mon_sel_lock, msc->_mon_sel_flags);
if (msc->iface == MPAM_IFACE_MMIO) {
raw_spin_unlock_irqrestore(&msc->_mon_sel_lock,
msc->_mon_sel_flags);
return;
}
mutex_unlock(&msc->mon_sel_mutex);
}
static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc)
{
lockdep_assert_held_once(&msc->_mon_sel_lock);
if (msc->iface == MPAM_IFACE_MMIO)
lockdep_assert_held_once(&msc->_mon_sel_lock);
else
lockdep_assert_held_once(&msc->mon_sel_mutex);
}
static inline void mpam_mon_sel_lock_init(struct mpam_msc *msc)
static inline int mpam_mon_sel_lock_init(struct device *dev,
struct mpam_msc *msc)
{
raw_spin_lock_init(&msc->_mon_sel_lock);
if (msc->iface == MPAM_IFACE_MMIO) {
raw_spin_lock_init(&msc->_mon_sel_lock);
return 0;
}
return devm_mutex_init(dev, &msc->mon_sel_mutex);
}
DEFINE_GUARD(mon_sel, struct mpam_msc *,