arm_mpam: Add basic mpam driver
Subsystems (6)
Re: [PATCH 10/33] arm_mpam: Add probe/remove for mpam msc driver and kbuild boiler plate
In reply to James MorseQuoted 22 lines · James Morse
Hi Dave,
Quoted 19 lines · Dave Martin
Quoted 13 lines · James Morse
Probing MPAM is convoluted. MSCs that are integrated with a CPU may only be accessible from those CPUs, and they may not be online. Touching the hardware early is pointless as MPAM can't be used until the system-wide common values for
num_partidandnum_pmghave been discovered.Start with driver probe/remove and mapping the MSC.
drivers/resctrl/Kconfig new file +0
-0drivers/resctrl/Kconfig line 2
Quoted 2 lines
drivers/resctrl/Kconfig new file +2
-0@@ -0,0 +1,11 @@ +# Confusingly, this is everything but the CPU bits of MPAM. CPU here means +# CPU resources, not containers or cgroups etc.Drop confusing comment?
Quoted 7 lines
Quoted 3 lines
CPUs are not mentioned other than in the comment -- I think the descriptions are sufficiently self-explanatory that they don't read onto CPUs.
This used to add
ARM_CPU_RESCTRL, to mirrorX86_CPU_RESCTRL. It's been tidied up since then, but the comment remains. I'll remove it.
OK
Quoted 9 lines
Quoted 9 lines
drivers/resctrl/Kconfig line 8
Quoted 6 lines
drivers/resctrl/Kconfig new file +6
-0+config ARM64_MPAM_DRIVER + bool "MPAM driver for System IP, e,g. caches and memory controllers" + depends on ARM64_MPAM && EXPERT + +config ARM64_MPAM_DRIVER_DEBUG + bool "Enable debug messages from the MPAM driver."Nit: spurious full stop.
Quoted 5 lines
Quoted 3 lines
(i.e., people don't add one in these one-line descriptions. They are title-like and self-delimiting, even when the text is a valid sentence.)
/me waves hands around
I did say "Nit" ;) (This was mainly a "hmm, this doesn't look quite like the rest" thing.)
Quoted 25 lines
Quoted 25 lines
Quoted 12 lines
drivers/resctrl/Kconfig new file +3
-0+ depends on ARM64_MPAM_DRIVER + help + Say yes here to enable debug messages from the MPAM driver.drivers/resctrl/mpam_devices.c new file +1
-0@@ -0,0 +1,336 @@ +/* drivers/resctrl/mpam_devices.c line 40
Quoted 10 lines
drivers/resctrl/mpam_devices.c new file +10
-0+* mpam_list_lock protects the SRCU lists when writing. Once the +* mpam_enabled key is enabled these lists are read-only, +* unless the error interrupt disables the driver. +*/ +static DEFINE_MUTEX (mpam_list_lock); +static LIST_HEAD (mpam_all_msc); + +static struct srcu_struct mpam_srcu; + +/* MPAM isn't available until all the MSC have been probed. */ Comment doesn't really explain the variable.
Quoted 6 lines
Quoted 2 lines
Maybe something like "Number of MSCs that need to be probed for MPAM to be usable" ?
Its the count not the remainder. I went with:
| * Number of MSCs that have been probed. Once all MSC have been probed MPAM | * can be enabled.
Thanks, that's clearer.
Quoted 4 lines
Quoted 3 lines
Quoted 1 line
+static u32
mpam_num_msc;Any particular reason this is u32 and not unsigned int?
u32 is less typing!
But more effort for the reader / reviewer -- it's semantic noise.
(It works either way though, obviosly. It looks like this code may have caught fixed-size-itis off the resctrl code, to some degree.)
Quoted 4 lines
Quoted 1 line
How are accesses to this protected against data races?
It's under the list-lock, but after Rob's feedback I've made it an
atomic_tand stopped using it as an id for all the print messages.
Converting to atomic_t reduces the chance of people asking the question, but doesn't really answer the question.
Since mpam_num_msc shadows the contents of the lists and msc data structures, it may matter whether the two can be seen out of sync.
Does it definitely not matter?
Quoted 4 lines
Quoted 4 lines
If there are supposed to be locks to protect globals in the MPAM driver, is it worth wrapping them in access functions with a lockdep assert? Otherwise, it feels rather easy to get this wrong -- I think I've found at least one bug (see
mpam_msc_drv_probe().)
Quoted 8 lines
Broadly: everything is protected by the
list_lockwhen things are being discovered. Once everything has been discovered, these things can become read-only.It's not until everything has been discovered that interrupts get registered, and things like a potential PMU driver could make calls in a strange context.
Adding helpers would need some global state variable, if (state == foo)
lockdep_assert... I had that early on, but figured it was overkill.
I wonder whether it would be worth migrating this, so that the probe- time variables (which are read-write) can be kept separate from the run-time system description variables (which are mostly write-once).
This would avoid having to support two different locking scenarios with a single mechanism.
I have a bit of a concern that there are too many synchronisation mechanisms in use, with purposes that overlap and are in some cases not clealy described and not obvious -- at least, not to me.
I don't think the fact that there have been few comments on this area necessarily indicates that other reviewers have fully understood the locking.
Quoted 10 lines
Quoted 7 lines
drivers/resctrl/mpam_devices.c line 46
Quoted 4 lines
drivers/resctrl/mpam_devices.c new file +4
-0+static void mpam_discovery_complete (void ) +{ +pr_err ("Discovered all MSC\n" ); +}As others have commented, if this is non-functional code that gets removed later on, it's probably best to drop this up-front?
It's illustrating that something happens after all the MSC have been discovered. Knowing that from the beginning of the series is supposed to make the insertion of the cpuhp notifiers in the middle easier to think about...
So long as this was not unintentionally left behind when splitting the series, I guess it's OK to have it here -- as you say, it does motivate the shape that the code will eventually need to have.
Quoted 35 lines
Quoted 26 lines
Quoted 26 lines
drivers/resctrl/mpam_devices.c new file +26
-0+static int mpam_dt_parse_resource (struct mpam_msc *msc,struct device_node *np, +u32 ris_idx) +{ +int err =0 ; +u32 level =0 ; +unsigned long cache_id; +struct device_node *cache; + + do { + if (of_device_is_compatible(np, "arm,mpam-cache")) { + cache = of_parse_phandle(np, "arm,mpam-device", 0); + if (!cache) { + pr_err("Failed to read phandle\n"); + break; + } + } else if (of_device_is_compatible(np->parent, "cache")) { + cache = of_node_get(np->parent); + } else { + /* For now, only caches are supported */ + cache = NULL; + break; + } + + err = of_property_read_u32(cache, "cache-level", &level); + if (err) { + pr_err("Failed to read cache-level\n");Quoted 8 lines
drivers/resctrl/mpam_devices.c line 91
Quoted 5 lines
drivers/resctrl/mpam_devices.c new file +5
-0+break ; + } + + cache_id =cache_of_calculate_id (cache); +if (cache_id == ~0UL ) {The type of
cache_idmay change if the return type ofcache_of_calculate_id()changes (see comments on patch 1).
Quoted 6 lines
Yup,
Quoted 1 line
Possible #define for the exceptional value.
I don't think its any more surprising than '-1' as an error value, and its only got one caller, which is pretty obviously an error path.
A #define is not essential. (As I say elsewhere, I don't entirely trust uses of ~ where the types may be mixed. But this case look low- isk for future maintenance.)
Quoted 11 lines
Quoted 5 lines
drivers/resctrl/mpam_devices.c line 93
Quoted 2 lines
drivers/resctrl/mpam_devices.c new file +2
-0+ err = -ENOENT ; +break ;The lack of a diagnostic here is inconsistent with the level of diagnostics in the rest of the loop.
I've never needed to debug that one because its already visible to user-space. If the cache-id's are missing, you can tell that in sysfs, you don't need to instrument the kernel.
I'll add one if you think its important. They can all be
_once, and as its related to the probing of a particular device, can use thedev_print helpers.
No, I guess that's fine. I don't have a strong feel for which things a user is likely to have to debug in practice, and I accept that we shouldn't try to cover absolutely everything.
Quoted 11 lines
Quoted 9 lines
drivers/resctrl/mpam_devices.c line 98
Quoted 5 lines
drivers/resctrl/mpam_devices.c new file +5
-0+ } + + err =mpam_ris_create (msc, ris_idx,MPAM_CLASS_CACHE , level, + cache_id); + }while (0 );Abuse of do ... while () here?
There is no loop. The breaks are stealth "goto"s to this statement:
Yes. The alternative would be actual gotos - which is surely worse! It just wasn't worth pulling this out as a separate function.
Again, it's semantic noise. do ... while is a looping construct. If you write "do {", the reader expects a loop and has to analyse the code in order to conclude that there isn't.
Using a loop in order to avoid giving a label to the sequence point at the closing bracket is a neat trick, but it's not helpful to someone reading the code. I can live with it, but as an idiom this seems rare.
Use of gotos for doing cleanup seems to be the most common idiom for this in the kernel. It may be inelegant, but it is likely to be readily understood. However...
Quoted 7 lines
Quoted 6 lines
drivers/resctrl/mpam_devices.c line 99
Quoted 3 lines
drivers/resctrl/mpam_devices.c new file +1
-0+of_node_put (cache);(It works either way, but maybe gotos to an explicit label would be more readable, as well as avoiding an unnecessary level of indentation.)
As the cleanup magic has become fashionable, I'll switch to using that...
...I guess that works, too.
(Not that I much like that clunky bolt-on extension to the language, but it should do the job and at least avoids arguments about precisely how or where the cleanup happens.)
Quoted 22 lines
Quoted 6 lines
Quoted 3 lines
drivers/resctrl/mpam_devices.c new file +3
-0+ +return err; +}[...]
Quoted 7 lines
Quoted 5 lines
+/*
+ * An MSC can control traffic from a set of CPUs, but may only be accessible
+ * from a (hopefully wider) set of CPUs. The common reason for this is power
+ * management. If all the CPUs in a cluster are in PSCI:CPU_SUSPEND, the
+ * the corresponding cache may also be powered off. By making accesses fromNit: the the
Fixed,
Quoted 5 lines
Quoted 4 lines
+ * one of those CPUs, we ensure this isn't the case.
+ */+static int
fw_num_msc;
Quoted 7 lines
Quoted 4 lines
Does this need to be protected against data races?
If individual
mpam_msc_drv_probe()calls may execute on different CPUs frommpam_msc_driver_init(), then seem to be potential races here.Incrementing was under the list-lock, but not the last 'are they all done' read. Following Rob's comments I've made this an
atomic_t.
As with mpam_num_msc, this eliminates data races on fw_num_msc, but races between this variable and other data structures may remain.
Can you explain what prevents such races, or why they don't matter?
Quoted 10 lines
Quoted 10 lines
drivers/resctrl/mpam_devices.c line 173
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +4
-0+ +static void mpam_pcc_rx_callback (struct mbox_client *cl,void *msg) +{ +/* TODO: wake up tasks blocked on this MSC's PCC channel */ So, is this broken in this commit?>
(If the series does not get broken up or applied piecemail, that's not such a concern, though.)
Quoted 5 lines
Unsupported - or at least only enough to not mistake them for MMIO devices. I've pulled this out to a later patch in the tree that isn't in this series.
The platforms that need this haven't yet materialised, (and may not!). There is a prototype for DT/SCMI, but nothing I've seen yet for ACPI.
OK; I guess deferring the introduction of this until there is more context for it makes sense.
Quoted 7 lines
Quoted 7 lines
drivers/resctrl/mpam_devices.c line 177
Quoted 4 lines
drivers/resctrl/mpam_devices.c new file +4
-0+} + +static void mpam_msc_drv_remove (struct platform_device *pdev) +{The MPAM driver cannot currently be built as a module.
Quoted 5 lines
Quoted 1 line
Is it possible to exercise the driver remove paths, today?
Yes, through the sysfs unbind interface.
It doesn't make a lot of sense for MPAM as the moment you unbind the driver from one MSC it has to work out if it needs to teardown resctrl...
Has to, but doesn't? Have I missed something?
Are we supposed to put the MSC back into a sane state, for e.g. the kexec path?
For resctrl, one option would be to stub out the backend -- i.e., we don't tell resctrl that the affected resources disappeared, but attempts to manipulate the affected MSC(s) are stubbed out (similarly to what happens to an open tty after a hangup).
(Something along these lines may be done somewhere, but I'm not currently aware of it.)
Is there an outstanding get on the device that prevents us from getting here until resctrl is shut down? Thanks to the wisdom and restraint of systemd I'd expect resctrl to tangled up in some rat's nest of unremovable mounts by the time we try to shut down, but I hope I'm being pessimistic. (Arguably that's not our bug, if so.)
Quoted 28 lines
Quoted 28 lines
Quoted 28 lines
drivers/resctrl/mpam_devices.c new file +28
-0+struct mpam_msc *msc =platform_get_drvdata (pdev); + +if (!msc) +return ; + +mutex_lock (&mpam_list_lock); + mpam_num_msc--; +platform_set_drvdata (pdev,NULL ); +list_del_rcu (&msc->glbl_list); +synchronize_srcu (&mpam_srcu); +devm_kfree (&pdev->dev, msc); +mutex_unlock (&mpam_list_lock); +} + +static int mpam_msc_drv_probe (struct platform_device *pdev) +{ +int err; +struct mpam_msc *msc; +struct resource *msc_res; +void *plat_data = pdev->dev.platform_data; + +mutex_lock (&mpam_list_lock); + do { + msc = devm_kzalloc(&pdev->dev, sizeof(*msc), GFP_KERNEL); + if (!msc) { + err = -ENOMEM; + break; + }
Quoted 8 lines
Quoted 8 lines
drivers/resctrl/mpam_devices.c line 213
Quoted 8 lines
drivers/resctrl/mpam_devices.c new file +8
-0+ +mutex_init (&msc->probe_lock); +mutex_init (&msc->part_sel_lock); +mutex_init (&msc->outer_mon_sel_lock); +raw_spin_lock_init (&msc->inner_mon_sel_lock); + msc->id = mpam_num_msc++; + msc->pdev = pdev; +INIT_LIST_HEAD_RCU (&msc->glbl_list);
msc->glbl_list is not a list head? Does it need to be initialised at all? list_add_rcu() will just splat it, by the looks of it.
Quoted 1 line
Quoted 1 line
drivers/resctrl/mpam_devices.c line 214
Quoted 1 line
drivers/resctrl/mpam_devices.c new file +1
-0+INIT_LIST_HEAD_RCU (&msc->ris);
Maybe INIT_LIST_HEAD_RCU() isn't needed here. Do we ever access this list without holding one of the MSC locks?
This list is not used until a cpuhp hook comes in to probe the MSC, and then mpam_discovery_cpu_online() obtains a pointer via list_for_each_entry() -- but this is not RCU-protected. The MSC probe lock is taken, there...
Quoted 27 lines
Quoted 27 lines
Quoted 27 lines
drivers/resctrl/mpam_devices.c new file +27
-0+ + err =update_msc_accessibility (msc); +if (err) +break ; +if (cpumask_empty (&msc->accessibility)) { +pr_err_once ("msc:%u is not accessible from any CPU!" , + msc->id); + err = -EINVAL ; +break ; + } + +if (device_property_read_u32 (&pdev->dev,"pcc-channel" , + &msc->pcc_subspace_id)) + msc->iface =MPAM_IFACE_MMIO ; +else + msc->iface =MPAM_IFACE_PCC ; + +if (msc->iface ==MPAM_IFACE_MMIO ) { +void __iomem *io; + + io =devm_platform_get_and_ioremap_resource (pdev,0 , + &msc_res); +if (IS_ERR (io)) { +pr_err ("Failed to map MSC base address\n" ); + err =PTR_ERR (io); +break ; + }
Quoted 8 lines
Quoted 8 lines
drivers/resctrl/mpam_devices.c line 249
Quoted 8 lines
drivers/resctrl/mpam_devices.c new file +8
-0+ msc->mapped_hwpage_sz = msc_res->end - msc_res->start; + msc->mapped_hwpage = io; + }else if (msc->iface ==MPAM_IFACE_PCC ) { + msc->pcc_cl.dev = &pdev->dev; + msc->pcc_cl.rx_callback = mpam_pcc_rx_callback; + msc->pcc_cl.tx_block = false; + msc->pcc_cl.tx_tout =1000 ;/* 1s */ + msc->pcc_cl.knows_txdone = false;
... so, it feels like we may need to hold the probe lock, or ensure that all iterations over the msc list are RCU-protected (see below for counterexamples), or both.
Quoted 12 lines
Quoted 11 lines
drivers/resctrl/mpam_devices.c line 258
Quoted 9 lines
drivers/resctrl/mpam_devices.c new file +9
-0+ + msc->pcc_chan =pcc_mbox_request_channel (&msc->pcc_cl, + msc->pcc_subspace_id); +if (IS_ERR (msc->pcc_chan)) { +pr_err ("Failed to request MSC PCC channel\n" ); + err =PTR_ERR (msc->pcc_chan); +break ; + } + }Should the lock be held across initialisation of the msc fields?
Quoted 2 lines
The msc isn't visible until its added to the list, so provided all that inialisation is done 'before' its added to the list, it doesn't matter.
Is it possible for other code to get a pointer to the new msc after this, other than by dereferencing the list?
(The obvious case is the interrupt handlers, but it looks like the msc pointers used for registering the interrupts are indeed obtained through an RCU-protected iteration over mpam_all_msc.)
Note, there seem to be non-RCU-protected iterations over mpam_all_msc in the mpam_discovery_cpu_online() (patch 14) and mpam_enable_merge_features() paths (patch 18). The lack of symmetry between list maintenance and consumption look a little suspect for those -- is safety ensured in some other way?
Quoted 9 lines
Quoted 5 lines
list_add_rcu()might imply sufficient barriers to ensure that the initialisations are visible to other threads that obtain the msc pointer by iterating overmpam_all_msc.It's probably cleaner to hold the lock explicitly, though.
The list lock? We do.
But the readers don't need to take the list lock, its only there to prevent concurrent writers.
I meant whatever lock is supposed to protect the fields of the specific msc. The list lock is not that lock.
Quoted 6 lines
Quoted 3 lines
What other ways of obtaining the msc pointer exist?
The class/component/device structures in a subsequent patch, protected in the same way. Once MPAM is enabled all that can be sprayed through resctrl - at which point no modifications are allowed, and teardown for fatal errors depends on the static-key.
I'll bear this in mind as I review.
Quoted 17 lines
Quoted 9 lines
Quoted 9 lines
drivers/resctrl/mpam_devices.c new file +9
-0+ +list_add_rcu (&msc->glbl_list, &mpam_all_msc); +platform_set_drvdata (pdev, msc); + }while (0 ); +mutex_unlock (&mpam_list_lock); + +if (!err) { +/* Create RIS entries described by firmware */ +if (!acpi_disabled)Quoted 8 lines
drivers/resctrl/mpam_devices.c line 273
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +6
-0+ err =acpi_mpam_parse_resources (msc, plat_data); + else + err =mpam_dt_parse_resources (msc, plat_data); + } + +if (!err && fw_num_msc == mpam_num_msc)Unlocked read of
mpam_num_msc?
Quoted 1 line
Fixed as an
atomic_tflavoured thing.
Ditto comments above about whether it is a problem that mpam_num_msc can now be seen out of sync with the list.
Quoted 41 lines
Quoted 6 lines
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +6
-0+mpam_discovery_complete (); + +if (err && msc) +mpam_msc_drv_remove (pdev); + +return err;Quoted 8 lines
drivers/resctrl/mpam_devices.c line 301
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +6
-0+} +/* +* MSC that are hidden under caches are not created as platform devices +* as there is no cache driver. Caches are also special-cased in +* update_msc_accessibility(). +*/ Can you elaborate? I don't understand quite what this is doing.
/ { my_thing { compatible = "my_thing"; msc { compatible = "arm,mpam-msc"; }; }; other_thing { compatible = "other_thing"; }; msc { compatible = "arm,mpam-msc"; arm,mpam-device = <&other_thing>; }; l2-cache { compatible = "cache"; msc { compatible = "arm,mpam-msc"; }; }; };
Quoted 2 lines
my_thingand other_thing's MSC will have devices created - but the cache will not, because it's a cache not a device, and anything below it is ignored.
OK. Maybe reword as something like:
--8<--
MSCs that are declared by the firmware as being part of a cache may not be created automatically as platform devices, since there is no dedicated cache driver.
Deal with those MSCs here.
-->8--
Maybe add a comment at update_msc_accessibility() that references this comment, instead of a reader of that function just needing to know that this comment is here?
Quoted 42 lines
Quoted 33 lines
Quoted 13 lines
drivers/resctrl/mpam_devices.c new file +11
-0+static void mpam_dt_create_foundling_msc (void ) +{ +int err; +struct device_node *cache; + +for_each_compatible_node (cache,NULL ,"cache" ) { + err =of_platform_populate (cache, mpam_of_match,NULL ,NULL ); +if (err) +pr_err ("Failed to create MSC devices under caches\n" ); + } +}[...]
Quoted 17 lines
drivers/resctrl/mpam_internal.h new file +11
-0@@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +// Copyright (C) 2024 Arm Ltd. + +#ifndef MPAM_INTERNAL_H +#define MPAM_INTERNAL_H + +#include <linux/arm_mpam.h> +#include <linux/cpumask.h> +#include <linux/io.h> +#include <linux/mailbox_client.h> +#include <linux/mutex.h> Quoted 8 lines
drivers/resctrl/mpam_internal.h line 17
Quoted 6 lines
drivers/resctrl/mpam_internal.h new file +6
-0+#include <linux/resctrl.h> +#include <linux/sizes.h> + +struct mpam_msc { +/* member of mpam_all_msc */ +struct list_head glbl_list;It is worth making these names less mismatched?
Quoted 4 lines
all_msc_list?It's because its global. The pattern otherwise is parent has a list foo, and all the children have a member '
foo_list'.
"all_msc", then?
I'm not sure that it's essential for the list head's name to have "list" in it: that's clear from the type and from how it is used. "all" seems sufficient to imply that this is a list (?)
It doesn't get much more global than "all".
(This is purely cosmetic, of course.)
Quoted 24 lines
Quoted 15 lines
Quoted 15 lines
drivers/resctrl/mpam_internal.h new file +13
-0+ +int id; +struct platform_device *pdev; + +/* Not modified after mpam_is_enabled() becomes true */ +enum mpam_msc_iface iface; +u32 pcc_subspace_id; +struct mbox_client pcc_cl; +struct pcc_mbox_chan *pcc_chan; +u32 nrdy_usec; +cpumask_t accessibility; + +/* Quoted 8 lines
drivers/resctrl/mpam_internal.h line 34
Quoted 4 lines
drivers/resctrl/mpam_internal.h new file +4
-0+* probe_lock is only take during discovery. After discovery these +* properties become read-only and the lists are protected by SRCU. +*/ +struct mutex probe_lock;Can we have more clarify about the locking strategy, including details of which things each lock is supposed to apply to and when, and how (if at all) the locks are intended to nest?
Quoted 3 lines
The comment above is supposed to describe that. A rule of thumb is its all the stuff 'below' it in the struct, there is also a comment for each order. This one is a bit of a catch all for the values in this struct that can be written.
I get that, but the devil is in the detail.
A lock that is "a bit of a catch-all" would always need to be taken, if safety is the goal.
I guess we should try to close out the other discussions about locking before working out whether anything else is needed, here.
Quoted 2 lines
The purpose of the
part_sel_lockandmon_sel_lockarrangement becomes much more obvious in subsequent patches when the driver starts accessing the registers of those names.
It's fair enough to defer that context until later -- though arguably these could be added later when they are actually used. Not really worth resplitting the series just for that, though.
Quoted 11 lines
Quoted 10 lines
(Similarly for the global locks.)
drivers/resctrl/mpam_internal.h line 36
Quoted 2 lines
drivers/resctrl/mpam_internal.h new file +2
-0+unsigned long ris_idxs[128 /BITS_PER_LONG ]; +u32 ris_max;
nrdy_usec,ris_idxsandris_maxappear unused in this patch (though I suppose they get initialised by virtue ofkzalloc()). Is this intentional?
Quoted 3 lines
To reduce the amount of churn in the series the bulk of the structure is added here, then the stuff that build more complicated structures, accesses hardware, deals with interrupts etc.
Ack, just checking that something wasn't unintentionally dropped.
Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
drivers/resctrl/mpam_internal.h new file +4
-0+ +/* mpam_msc_ris of this component */ +struct list_head ris; +Quoted 8 lines
drivers/resctrl/mpam_internal.h line 46
Quoted 6 lines
drivers/resctrl/mpam_internal.h new file +6
-0+/* +* part_sel_lock protects access to the MSC hardware registers that are +* affected by MPAMCFG_PART_SEL. (including the ID registers that vary +* by RIS). +* If needed, take msc->lock first. +*/ What's
msc->lock?
Quoted 6 lines
The old name for
probe_lock, before it was necessary to lock the hardware registers separately. I've fixed the name.Thanks,
James
Ack
Cheers
---Dave
Quoted 2 lines
James Morse
maintainerRe: [PATCH 10/33] arm_mpam: Add probe/remove for mpam msc driver and kbuild boiler plate
Hi Dave,
Quoted 24 lines · Dave Martin
Quoted 20 lines · James Morse
Quoted 10 lines · Dave Martin
Quoted 7 lines · James Morse
Probing MPAM is convoluted. MSCs that are integrated with a CPU may only be accessible from those CPUs, and they may not be online. Touching the hardware early is pointless as MPAM can't be used until the system-wide common values for
num_partidandnum_pmghave been discovered.Start with driver probe/remove and mapping the MSC.
Quoted 8 lines
drivers/resctrl/mpam_devices.c
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +0
-0@@ -0,0 +1,336 @@How are accesses to this protected against data races?
Quoted 2 lines
It's under the list-lock, but after Rob's feedback I've made it an
atomic_tand stopped using it as an id for all the print messages.
Quoted 7 lines
Converting to
atomic_treduces the chance of people asking the question, but doesn't really answer the question.Since
mpam_num_mscshadows the contents of the lists and msc data structures, it may matter whether the two can be seen out of sync.Does it definitely not matter?
v2 uses the firmware-table id as the id. The only thing mpam_num_msc needs to do is spot which MSC was last to be probed so that the cpuhp calls can be registered.
The amount of skid that happens on the way there doesn't matter.
[..]
Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
drivers/resctrl/mpam_devices.c line 169
Quoted 1 line
drivers/resctrl/mpam_devices.c new file +1
-0+static int fw_num_msc;Does this need to be protected against data races?
If individual
mpam_msc_drv_probe()calls may execute on different CPUs frommpam_msc_driver_init(), then seem to be potential races here.
Quoted 8 lines
Quoted 2 lines
Incrementing was under the list-lock, but not the last 'are they all done' read. Following Rob's comments I've made this an
atomic_t.As with
mpam_num_msc, this eliminates data races onfw_num_msc, but races between this variable and other data structures may remain.Can you explain what prevents such races, or why they don't matter?
See mpam_msc_driver_init(). The value is set before the driver is registered. It can't probe before its registered, so all the readers must happen after the writer.
[..]
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
drivers/resctrl/mpam_devices.c line 177
Quoted 4 lines
drivers/resctrl/mpam_devices.c new file +4
-0+} + +static void mpam_msc_drv_remove (struct platform_device *pdev) +{The MPAM driver cannot currently be built as a module.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Is it possible to exercise the driver remove paths, today?
Yes, through the sysfs unbind interface.
It doesn't make a lot of sense for MPAM as the moment you unbind the driver from one MSC it has to work out if it needs to teardown resctrl...
Has to, but doesn't? Have I missed something?
It's probably not what the user wants, but it is what they're asking for if they do this.
Quoted 2 lines
Are we supposed to put the MSC back into a sane state, for e.g. the kexec path?
kdump on panic() means you couldn't trust it to do this.
The driver reset all the configurations during probing. It will initially run with whatever configuration was left in partid-0, there is very little we can do about this.
Quoted 7 lines
For resctrl, one option would be to stub out the backend -- i.e., we don't tell resctrl that the affected resources disappeared, but attempts to manipulate the affected MSC(s) are stubbed out (similarly to what happens to an open tty after a hangup).
(Something along these lines may be done somewhere, but I'm not currently aware of it.)
On teardown the cpuhp callbacks are unregistered, which makes all the CPUs and resctrl:domains appear offline, and the static key behind mpam_enabled() is disabled, which makes a bunch of paths return an error.
The result is no more access to the hardware after an error has occured. The aim is to prevent accidentally muddling important/unimportant tasks due to PARTID truncation.
Quoted 5 lines
Is there an outstanding get on the device that prevents us from getting here until resctrl is shut down? Thanks to the wisdom and restraint of systemd I'd expect resctrl to tangled up in some rat's nest of unremovable mounts by the time we try to shut down, but I hope I'm being pessimistic. (Arguably that's not our bug, if so.)
The resctrl_exit() path removes the kernfs internals from the mount point. Systemd is able to keep zombie mount points, but they end up being empty. (to reproduce this, put resctrl in fstab!)
Quoted 31 lines
Quoted 31 lines
Quoted 31 lines
Quoted 31 lines
drivers/resctrl/mpam_devices.c new file +31
-0+struct mpam_msc *msc =platform_get_drvdata (pdev); + +if (!msc) +return ; + +mutex_lock (&mpam_list_lock); + mpam_num_msc--; +platform_set_drvdata (pdev,NULL ); +list_del_rcu (&msc->glbl_list); +synchronize_srcu (&mpam_srcu); +devm_kfree (&pdev->dev, msc); +mutex_unlock (&mpam_list_lock); +} + +static int mpam_msc_drv_probe (struct platform_device *pdev) +{ +int err; +struct mpam_msc *msc; +struct resource *msc_res; +void *plat_data = pdev->dev.platform_data; + +mutex_lock (&mpam_list_lock); + do { + msc = devm_kzalloc(&pdev->dev, sizeof(*msc), GFP_KERNEL); + if (!msc) { + err = -ENOMEM; + break; + } + + mutex_init(&msc->probe_lock); + mutex_init(&msc->part_sel_lock);
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
drivers/resctrl/mpam_devices.c line 213
Quoted 5 lines
drivers/resctrl/mpam_devices.c new file +5
-0+mutex_init (&msc->outer_mon_sel_lock); +raw_spin_lock_init (&msc->inner_mon_sel_lock); + msc->id = mpam_num_msc++; + msc->pdev = pdev; +INIT_LIST_HEAD_RCU (&msc->glbl_list);
msc->glbl_listis not a list head? Does it need to be initialised at all?list_add_rcu()will just splat it, by the looks of it.
It's the member of the global list, hence the comment above it in the struct. I've never known if the member 'list head' needs to be initialised or not, better safe than sorry.
Quoted 9 lines
Quoted 1 line
Quoted 1 line
drivers/resctrl/mpam_devices.c line 214
Quoted 1 line
drivers/resctrl/mpam_devices.c new file +1
-0+INIT_LIST_HEAD_RCU (&msc->ris);Maybe
INIT_LIST_HEAD_RCU()isn't needed here. Do we ever access this list without holding one of the MSC locks?This list is not used until a cpuhp hook comes in to probe the MSC, and then
mpam_discovery_cpu_online()obtains a pointer vialist_for_each_entry()-- but this is not RCU-protected. The MSC probe lock is taken, there...
mpam_reprogram_msc(), mpam_msmon_reset_all_mbwu() and mpam_reset_msc() all do this under (s)rcu.
The aim is to not take a lock on the read side. Once the cpuhp callbacks are registered the only thing that writes to these lists is the error interrupt teardown.
Quoted 31 lines
Quoted 31 lines
Quoted 31 lines
Quoted 31 lines
drivers/resctrl/mpam_devices.c new file +31
-0+ + err =update_msc_accessibility (msc); +if (err) +break ; +if (cpumask_empty (&msc->accessibility)) { +pr_err_once ("msc:%u is not accessible from any CPU!" , + msc->id); + err = -EINVAL ; +break ; + } + +if (device_property_read_u32 (&pdev->dev,"pcc-channel" , + &msc->pcc_subspace_id)) + msc->iface =MPAM_IFACE_MMIO ; +else + msc->iface =MPAM_IFACE_PCC ; + +if (msc->iface ==MPAM_IFACE_MMIO ) { +void __iomem *io; + + io =devm_platform_get_and_ioremap_resource (pdev,0 , + &msc_res); +if (IS_ERR (io)) { +pr_err ("Failed to map MSC base address\n" ); + err =PTR_ERR (io); +break ; + } + msc->mapped_hwpage_sz = msc_res->end - msc_res->start; + msc->mapped_hwpage = io; + }else if (msc->iface ==MPAM_IFACE_PCC ) { + msc->pcc_cl.dev = &pdev->dev;
Quoted 8 lines
Quoted 4 lines
Quoted 4 lines
drivers/resctrl/mpam_devices.c line 249
Quoted 4 lines
drivers/resctrl/mpam_devices.c new file +4
-0+ msc->pcc_cl.rx_callback = mpam_pcc_rx_callback; + msc->pcc_cl.tx_block = false; + msc->pcc_cl.tx_tout =1000 ;/* 1s */ + msc->pcc_cl.knows_txdone = false;... so, it feels like we may need to hold the probe lock, or ensure that all iterations over the msc list are RCU-protected (see below for counterexamples), or both.
In here, the msc hasn't yet been added to the global list, so it can't be found by anyone. Anyone that does find it, found it by taking the list_lock and walking the global list.
Quoted 10 lines
Quoted 10 lines
Quoted 9 lines
Quoted 9 lines
drivers/resctrl/mpam_devices.c new file +9
-0+ + msc->pcc_chan =pcc_mbox_request_channel (&msc->pcc_cl, + msc->pcc_subspace_id); +if (IS_ERR (msc->pcc_chan)) { +pr_err ("Failed to request MSC PCC channel\n" ); + err =PTR_ERR (msc->pcc_chan); +break ; + } + }
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
Should the lock be held across initialisation of the msc fields?
The msc isn't visible until its added to the list, so provided all that inialisation is done 'before' its added to the list, it doesn't matter.
Is it possible for other code to get a pointer to the new msc after this, other than by dereferencing the list?
While MSC are still being created - nothing walks the list. There are no interrupts or hotplug callabacks.
Once all the MSC have been found, hardware probing starts.
During hardware probing, the cpuhp callback walks the global list under srcu. Once all the hardware has been probed, the cpuhp callbacks are swapped out, and mpam_enable_once() does things with static_keys and registering interrupts. After this point, the mpam_class list/tree is used under srcu, and yes interrupts know which MSC they are for.
Quoted 6 lines
(The obvious case is the interrupt handlers, but it looks like the msc pointers used for registering the interrupts are indeed obtained through an RCU-protected iteration over
mpam_all_msc.)Note, there seem to be non-RCU-protected iterations over
mpam_all_mscin thempam_discovery_cpu_online()(patch 14) and
That was taking the write side lock unecessarily. I've fixed it to walk the list under srcu.
Quoted 1 line
mpam_enable_merge_features()paths (patch 18).
Holds the write side lock.
Quoted 3 lines
The lack of symmetry
between list maintenance and consumption look a little suspect for those -- is safety ensured in some other way?
Readers must use the RCU primitives to be safe against a concurrent writer. Writers must take some write side lock to be safe against each other - they don't need to use the RCU list-walking primitives.
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
list_add_rcu()might imply sufficient barriers to ensure that the initialisations are visible to other threads that obtain the msc pointer by iterating overmpam_all_msc.
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
It's probably cleaner to hold the lock explicitly, though.
The list lock? We do.
But the readers don't need to take the list lock, its only there to prevent concurrent writers.I meant whatever lock is supposed to protect the fields of the specific msc. The list lock is not that lock.
We could bundle that under the probe_lock - but there would be no need to hold that here, the struct mpam_msc isn't reachable.
[..]
Quoted 52 lines
Quoted 41 lines
Quoted 6 lines
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +6
-0+mpam_discovery_complete (); + +if (err && msc) +mpam_msc_drv_remove (pdev); + +return err;Quoted 8 lines
drivers/resctrl/mpam_devices.c line 301
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +6
-0+} +/* +* MSC that are hidden under caches are not created as platform devices +* as there is no cache driver. Caches are also special-cased in +* update_msc_accessibility(). +*/ Can you elaborate? I don't understand quite what this is doing.
/ { my_thing { compatible = "my_thing"; msc { compatible = "arm,mpam-msc"; }; }; other_thing { compatible = "other_thing"; }; msc { compatible = "arm,mpam-msc"; arm,mpam-device = <&other_thing>; }; l2-cache { compatible = "cache"; msc { compatible = "arm,mpam-msc"; }; }; };Quoted 2 lines
my_thingand other_thing's MSC will have devices created - but the cache will not, because it's a cache not a device, and anything below it is ignored.OK. Maybe reword as something like:
--8<--
MSCs that are declared by the firmware as being part of a cache may not be created automatically as platform devices, since there is no dedicated cache driver.
Quoted 7 lines
Deal with those MSCs here.
-->8--
Maybe add a comment at
update_msc_accessibility()that references this comment, instead of a reader of that function just needing to know that this comment is here?
I'll just drop the bit about update_msc_accessibility(), its less relevant once the next patch adds the memory node in a similar way. (and even less relevant once I rip out DT support)
Quoted 33 lines
Quoted 26 lines
Quoted 17 lines
Quoted 17 lines
drivers/resctrl/mpam_internal.h new file +11
-0@@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +// Copyright (C) 2024 Arm Ltd. + +#ifndef MPAM_INTERNAL_H +#define MPAM_INTERNAL_H + +#include <linux/arm_mpam.h> +#include <linux/cpumask.h> +#include <linux/io.h> +#include <linux/mailbox_client.h> +#include <linux/mutex.h> Quoted 8 lines
drivers/resctrl/mpam_internal.h line 17
Quoted 6 lines
drivers/resctrl/mpam_internal.h new file +6
-0+#include <linux/resctrl.h> +#include <linux/sizes.h> + +struct mpam_msc { +/* member of mpam_all_msc */ +struct list_head glbl_list;It is worth making these names less mismatched?
Quoted 4 lines
all_msc_list?It's because its global. The pattern otherwise is parent has a list foo, and all the children have a member '
foo_list'."
all_msc", then?
Quoted 7 lines
I'm not sure that it's essential for the list head's name to have "list" in it: that's clear from the type and from how it is used. "all" seems sufficient to imply that this is a list (?)
It doesn't get much more global than "all".
(This is purely cosmetic, of course.)
Ending in _list is part of a pattern with the class->component --> component->component_list relationship. We can discuss whatever suffix is best on v2 - as long as they all follow the same pattern!
Thanks,
James
James Morse
maintainerPATCH 10/33 arm_mpam: Add probe/remove for mpam msc driver and kbuild boiler plate
In reply to James MorseProbing MPAM is convoluted. MSCs that are integrated with a CPU may only be accessible from those CPUs, and they may not be online. Touching the hardware early is pointless as MPAM can't be used until the system-wide common values for num_partid and num_pmg have been discovered.
Start with driver probe/remove and mapping the MSC.
---
Changes since RFC:
* Check for status=broken DT devices.
* Moved all the files around.
* Made Kconfig symbols depend on EXPERT
--- arch/arm64/Kconfig | 1 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/resctrl/Kconfig | 11 ++ drivers/resctrl/Makefile | 4 + drivers/resctrl/mpam_devices.c | 336 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 62 ++++++ 7 files changed, 417 insertions(+) create mode 100644 drivers/resctrl/Kconfig create mode 100644 drivers/resctrl/Makefile create mode 100644 drivers/resctrl/mpam_devices.c create mode 100644 drivers/resctrl/mpam_internal.h
arch/arm64/Kconfig +1 -0
@@ -2062,6 +2062,7 @@ config ARM64_TLB_RANGE config ARM64_MPAM bool "Enable support for MPAM" + select ARM64_MPAM_DRIVER select ACPI_MPAM if ACPI help Memory Partitioning and Monitoring is an optional extension
drivers/Kconfig +2 -0
@@ -251,4 +251,6 @@ source "drivers/hte/Kconfig" source "drivers/cdx/Kconfig" +source "drivers/resctrl/Kconfig" + endmenu
drivers/Makefile +1 -0
@@ -194,5 +194,6 @@ obj-$(CONFIG_HTE) += hte/ obj-$(CONFIG_DRM_ACCEL) += accel/ obj-$(CONFIG_CDX_BUS) += cdx/ obj-$(CONFIG_DPLL) += dpll/ +obj-y += resctrl/ obj-$(CONFIG_S390) += s390/
drivers/resctrl/Kconfig new file +11 -0
@@ -0,0 +1,11 @@ +# Confusingly, this is everything but the CPU bits of MPAM. CPU here means +# CPU resources, not containers or cgroups etc. +config ARM64_MPAM_DRIVER + bool "MPAM driver for System IP, e,g. caches and memory controllers" + depends on ARM64_MPAM && EXPERT + +config ARM64_MPAM_DRIVER_DEBUG + bool "Enable debug messages from the MPAM driver." + depends on ARM64_MPAM_DRIVER + help + Say yes here to enable debug messages from the MPAM driver.
drivers/resctrl/Makefile new file +4 -0
@@ -0,0 +1,4 @@ +obj-$(CONFIG_ARM64_MPAM_DRIVER) += mpam.o +mpam-y += mpam_devices.o + +cflags-$(CONFIG_ARM64_MPAM_DRIVER_DEBUG) += -DDEBUG
drivers/resctrl/mpam_devices.c new file +336 -0
336 lines not on this page · raw message
drivers/resctrl/mpam_internal.h new file +62 -0
62 lines not on this page · raw message
Signature · 1 line
2.20.1
RE: [PATCH 10/33] arm_mpam: Add probe/remove for mpam msc driver and kbuild boiler plate
Hello James,
Quoted 210 lines
Probing MPAM is convoluted. MSCs that are integrated with a CPU may only be accessible from those CPUs, and they may not be online. Touching the hardware early is pointless as MPAM can't be used until the system-wide common values for
num_partidandnum_pmghave been discovered.Start with driver probe/remove and mapping the MSC.
CC Carl Worth <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* Check for status=broken DT devices.
* Moved all the files around.
* MadeKconfigsymbols depend on EXPERT--- arch/arm64/Kconfig | 1 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/resctrl/Kconfig | 11 ++ drivers/resctrl/Makefile | 4 + drivers/resctrl/mpam_devices.c | 336 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 62 ++++++ 7 files changed, 417 insertions(+) create mode 100644 drivers/resctrl/Kconfig create mode 100644
drivers/resctrl/Makefilecreate mode 100644drivers/resctrl/mpam_devices.ccreate mode 100644drivers/resctrl/mpam_internal.harch/arm64/Kconfig index renamed from arch/arm64/Kconfig +0
-0
e51ccf1da102..ea3c54e04275100644arch/arm64/Kconfig +1
-1@@ -2062,6 +2062,7 @@ config ARM64_TLB_RANGE config ARM64_MPAM bool "Enable support for MPAM" + select ARM64_MPAM_DRIVER select ACPI_MPAM if ACPI help Memory Partitioning and Monitoring is an optional extension diff --git a/drivers/Kconfig b/drivers/Kconfig index 4915a63866b0..3054b50a2f4c100644
drivers/Kconfig +2
-0@@ -251,4 +251,6 @@ source "drivers/hte/Kconfig" source "drivers/cdx/Kconfig" +source "drivers/resctrl/Kconfig" + endmenudrivers/Makefile index renamed from drivers/Makefile +0
-0
b5749cf67044..f41cf4eddeba100644drivers/Makefile +1
-0@@ -194,5 +194,6 @@ obj-$(CONFIG_HTE) += hte/ obj-$(CONFIG_DRM_ACCEL) += accel/ obj-$(CONFIG_CDX_BUS) += cdx/ obj-$(CONFIG_DPLL) += dpll/ +obj-y += resctrl/ obj-$(CONFIG_S390) += s390/drivers/resctrl/Kconfig new file mode renamed from drivers/resctrl/Kconfig +0
-0100644 index 000000000000..dff7b87280ab
drivers/resctrl/Kconfig new file +11
-0@@ -0,0 +1,11 @@ +# Confusingly, this is everything but the CPU bits of MPAM. CPU here +means # CPU resources, not containers or cgroups etc. +config ARM64_MPAM_DRIVER + bool "MPAM driver for System IP, e,g. caches and memory controllers" + depends on ARM64_MPAM && EXPERT + +config ARM64_MPAM_DRIVER_DEBUG + bool "Enable debug messages from the MPAM driver." + depends on ARM64_MPAM_DRIVER + help + Say yes here to enable debug messages from the MPAM driver.drivers/resctrl/Makefile new file mode renamed from drivers/resctrl/Makefile +0
-0100644 index 000000000000..92b48fa20108
drivers/resctrl/Makefile new file +2
-0@@ -0,0 +1,4 @@ +obj-$(CONFIG_ARM64_MPAM_DRIVER) += mpam.o +mpam-y +=mpam_devices.o
drivers/resctrl/Makefile new file +2
-0+ +cflags-$(CONFIG_ARM64_MPAM_DRIVER_DEBUG) += -DDEBUGdrivers/resctrl/mpam_devices.c new file +60
-0@@ -0,0 +1,336 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2025 Arm Ltd. + +#define pr_fmt (fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__ + +#include <linux/acpi.h> +#include <linux/arm_mpam.h> +#include <linux/cacheinfo.h> +#include <linux/cpu.h> +#include <linux/cpumask.h> +#include <linux/device.h> +#include <linux/errno.h> +#include <linux/gfp.h> +#include <linux/list.h> +#include <linux/lockdep.h> +#include <linux/mutex.h> +#include <linux/of.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h> +#include <linux/printk.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/srcu.h> +#include <linux/types.h> + +#include <acpi/pcc.h> + +#include "mpam_internal.h" + +/* +* mpam_list_lock protects the SRCU lists when writing. Once the +* mpam_enabled key is enabled these lists are read-only, +* unless the error interrupt disables the driver. +*/ +static DEFINE_MUTEX (mpam_list_lock); +static LIST_HEAD (mpam_all_msc); + +static struct srcu_struct mpam_srcu; + +/* MPAM isn't available until all the MSC have been probed. */ static +u32 mpam_num_msc; + +static void mpam_discovery_complete (void ) { +pr_err ("Discovered all MSC\n" ); +} + +static int mpam_dt_count_msc (void ) +{ +int count =0 ; +struct device_node *np; + +for_each_compatible_node (np,NULL ,"arm,mpam-msc" ) { +if (of_device_is_available (np)) + count++; + } + +return count; +} + +static int mpam_dt_parse_resource(struct mpam_msc *msc, struct
device_node*np,drivers/resctrl/mpam_devices.c new file +10
-0+ u32 ris_idx) +{ + int err = 0; + u32 level = 0; + unsigned long cache_id; + struct device_node *cache; + + do { + if (of_device_is_compatible(np, "arm,mpam-cache")) { + cache = of_parse_phandle(np, "arm,mpam-device",0);
drivers/resctrl/mpam_devices.c new file +25
-0+if (!cache) { +pr_err ("Failed to read phandle\n" ); +break ; + } + }else if (of_device_is_compatible (np->parent,"cache" )) { + cache =of_node_get (np->parent); + }else { +/* For now, only caches are supported */ + cache =NULL ; +break ; + } + + err =of_property_read_u32 (cache,"cache-level" , &level); +if (err) { +pr_err ("Failed to read cache-level\n" ); +break ; + } + + cache_id =cache_of_calculate_id (cache); +if (cache_id == ~0UL ) { + err = -ENOENT ; +break ; + } + + err = mpam_ris_create(msc, ris_idx, MPAM_CLASS_CACHE,level,
drivers/resctrl/mpam_devices.c new file +18
-0+ cache_id); + }while (0 ); +of_node_put (cache); + +return err; +} + +static int mpam_dt_parse_resources (struct mpam_msc *msc,void *ignored) +{ +int err, num_ris =0 ; +const u32 *ris_idx_p; +struct device_node *iter, *np; + + np = msc->pdev->dev.of_node; +for_each_child_of_node (np, iter) { + ris_idx_p =of_get_property (iter,"reg" ,NULL ); +if (ris_idx_p) { + num_ris++;
drivers/resctrl/mpam_devices.c line 124
Quoted 10 lines
drivers/resctrl/mpam_devices.c new file +10
-0+ err =mpam_dt_parse_resource (msc, iter, *ris_idx_p); +if (err) { +of_node_put (iter); +return err; + } + } + } + +if (!num_ris) +mpam_dt_parse_resource (msc, np,0 );
err = mpam_dt_parse_resource(msc, np, 0);
Best regards,
Shaopeng TAN
Quoted 295 lines
drivers/resctrl/mpam_devices.c new file +21
-0+return err; +} + +/* +* An MSC can control traffic from a set of CPUs, but may only be +accessible +* from a (hopefully wider) set of CPUs. The common reason for this is +power +* management. If all the CPUs in a cluster are in PSCI:CPU_SUSPEND, +the +* the corresponding cache may also be powered off. By making accesses +from +* one of those CPUs, we ensure this isn't the case. +*/ +static int update_msc_accessibility (struct mpam_msc *msc) { +struct device_node *parent; +u32 affinity_id; +int err; + +if (!acpi_disabled) { + err = device_property_read_u32(&msc->pdev->dev,"
cpu_affinity",drivers/resctrl/mpam_devices.c new file +3
-0+ &affinity_id); +if (err) + cpumask_copy(&msc->accessibility,
cpu_possible_mask);drivers/resctrl/mpam_devices.c new file +3
-0+else + acpi_pptt_get_cpus_from_container(affinity_id, +
&msc->accessibility);drivers/resctrl/mpam_devices.c new file +48
-0+ +return 0 ; + } + +/* This depends on the path to of_node */ + parent =of_get_parent (msc->pdev->dev.of_node); +if (parent == of_root) { +cpumask_copy (&msc->accessibility, cpu_possible_mask); + err =0 ; + }else { + err = -EINVAL ; +pr_err ("Cannot determine accessibility of MSC: %s\n" , +dev_name (&msc->pdev->dev)); + } +of_node_put (parent); + +return err; +} + +static int fw_num_msc; + +static void mpam_pcc_rx_callback (struct mbox_client *cl,void *msg) { +/* TODO: wake up tasks blocked on this MSC's PCC channel */ } + +static void mpam_msc_drv_remove (struct platform_device *pdev) { +struct mpam_msc *msc =platform_get_drvdata (pdev); + +if (!msc) +return ; + +mutex_lock (&mpam_list_lock); + mpam_num_msc--; +platform_set_drvdata (pdev,NULL ); +list_del_rcu (&msc->glbl_list); +synchronize_srcu (&mpam_srcu); +devm_kfree (&pdev->dev, msc); +mutex_unlock (&mpam_list_lock); +} + +static int mpam_msc_drv_probe(struct platform_device *pdev) { + int err; + struct mpam_msc *msc; + struct resource *msc_res; + void *plat_data = pdev->dev.platform_data; + + mutex_lock(&mpam_list_lock); + do { + msc = devm_kzalloc(&pdev->dev, sizeof(*msc),
GFP_KERNEL);drivers/resctrl/mpam_devices.c new file +19
-0+if (!msc) { + err = -ENOMEM ; +break ; + } + +mutex_init (&msc->probe_lock); +mutex_init (&msc->part_sel_lock); +mutex_init (&msc->outer_mon_sel_lock); +raw_spin_lock_init (&msc->inner_mon_sel_lock); + msc->id = mpam_num_msc++; + msc->pdev = pdev; +INIT_LIST_HEAD_RCU (&msc->glbl_list); +INIT_LIST_HEAD_RCU (&msc->ris); + + err =update_msc_accessibility (msc); +if (err) +break ; +if (cpumask_empty (&msc->accessibility)) { + pr_err_once("msc:%u is not accessible from anyCPU!",
drivers/resctrl/mpam_devices.c new file +15
-0+ msc->id); + err = -EINVAL ; +break ; + } + +if (device_property_read_u32 (&pdev->dev,"pcc-channel" , + &msc->pcc_subspace_id)) + msc->iface =MPAM_IFACE_MMIO ; +else + msc->iface =MPAM_IFACE_PCC ; + +if (msc->iface ==MPAM_IFACE_MMIO ) { +void __iomem *io; + + io = devm_platform_get_and_ioremap_resource(pdev,0,
+&msc_res);drivers/resctrl/mpam_devices.c new file +6
-0+if (IS_ERR (io)) { +pr_err ("Failed to map MSC base address\n" ); + err =PTR_ERR (io); +break ; + } + msc->mapped_hwpage_sz = msc_res->end -
msc_res->start;drivers/resctrl/mpam_devices.c new file +9
-0+ msc->mapped_hwpage = io; + }else if (msc->iface ==MPAM_IFACE_PCC ) { + msc->pcc_cl.dev = &pdev->dev; + msc->pcc_cl.rx_callback = mpam_pcc_rx_callback; + msc->pcc_cl.tx_block = false; + msc->pcc_cl.tx_tout =1000 ;/* 1s */ + msc->pcc_cl.knows_txdone = false; + + msc->pcc_chan =pcc_mbox_request_channel(&msc->pcc_cl,
+msc->pcc_subspace_id);drivers/resctrl/mpam_devices.c new file +2
-0+if (IS_ERR (msc->pcc_chan)) { + pr_err("Failed to request MSC PCCchannel\n");
drivers/resctrl/mpam_devices.c new file +54
-0+ err =PTR_ERR (msc->pcc_chan); +break ; + } + } + +list_add_rcu (&msc->glbl_list, &mpam_all_msc); +platform_set_drvdata (pdev, msc); + }while (0 ); +mutex_unlock (&mpam_list_lock); + +if (!err) { +/* Create RIS entries described by firmware */ +if (!acpi_disabled) + err =acpi_mpam_parse_resources (msc, plat_data); +else + err =mpam_dt_parse_resources (msc, plat_data); + } + +if (!err && fw_num_msc == mpam_num_msc) +mpam_discovery_complete (); + +if (err && msc) +mpam_msc_drv_remove (pdev); + +return err; +} + +static const struct of_device_id mpam_of_match[] = { + { .compatible ="arm,mpam-msc" , }, + {}, +}; +MODULE_DEVICE_TABLE (of, mpam_of_match); + +static struct platform_driver mpam_msc_driver = { + .driver = { + .name ="mpam_msc" , + .of_match_table =of_match_ptr (mpam_of_match), + }, + .probe = mpam_msc_drv_probe, + .remove = mpam_msc_drv_remove, +}; + +/* +* MSC that are hidden under caches are not created as platform devices +* as there is no cache driver. Caches are also special-cased in +* update_msc_accessibility(). +*/ +static void mpam_dt_create_foundling_msc (void ) +{ +int err; +struct device_node *cache; + +for_each_compatible_node (cache,NULL ,"cache" ) { + err = of_platform_populate(cache, mpam_of_match, NULL,NULL);
drivers/resctrl/mpam_devices.c new file +2
-0+if (err) + pr_err("Failed to create MSC devices undercaches\n");
drivers/resctrl/mpam_devices.c new file +25
-0+ } +} + +static int __init mpam_msc_driver_init (void ) { +if (!system_supports_mpam ()) +return -EOPNOTSUPP ; + +init_srcu_struct (&mpam_srcu); + +if (!acpi_disabled) + fw_num_msc =acpi_mpam_count_msc (); +else + fw_num_msc =mpam_dt_count_msc (); + +if (fw_num_msc <=0 ) { +pr_err ("No MSC devices found in firmware\n" ); +return -EINVAL ; + } + +if (acpi_disabled) +mpam_dt_create_foundling_msc (); + +return platform_driver_register (&mpam_msc_driver); +} +subsys_initcall (mpam_msc_driver_init);(quoted diff) +0
-0
b/drivers/resctrl/mpam_internal.hnew file mode 100644 index 000000000000..07e0f240eacadrivers/resctrl/mpam_internal.h new file +42
-0@@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +// Copyright (C) 2024 Arm Ltd. + +#ifndef MPAM_INTERNAL_H +#define MPAM_INTERNAL_H + +#include <linux/arm_mpam.h> +#include <linux/cpumask.h> +#include <linux/io.h> +#include <linux/mailbox_client.h> +#include <linux/mutex.h> +#include <linux/resctrl.h> +#include <linux/sizes.h> + +struct mpam_msc { + /* member of mpam_all_msc */ + struct list_head glbl_list; + + int id; + struct platform_device *pdev; + + /* Not modified after mpam_is_enabled() becomes true */ + enum mpam_msc_iface iface; + u32 pcc_subspace_id; + struct mbox_client pcc_cl; + struct pcc_mbox_chan *pcc_chan; + u32 nrdy_usec; + cpumask_t accessibility; + + /* + * probe_lock is only take during discovery. After discovery these + * properties become read-only and the lists are protected by SRCU. + */ + struct mutex probe_lock; + unsigned long ris_idxs[128 / BITS_PER_LONG]; + u32 ris_max; + + /* mpam_msc_ris of this component */ + struct list_head ris; + + /* + * part_sel_lock protects access to the MSC hardware registers thatare
drivers/resctrl/mpam_internal.h new file +1
-0+* affected by MPAMCFG_PART_SEL. (including the ID registers that vary
drivers/resctrl/mpam_internal.h new file +7
-0+* by RIS). +* If needed, take msc->lock first. +*/ +struct mutex part_sel_lock; + +/* +* mon_sel_lock protects access to the MSC hardware registers that are
drivers/resctrl/mpam_internal.h new file +12
-1+* affeted by MPAMCFG_MON_SEL. +* If needed, take msc->lock first. +*/ +struct mutex outer_mon_sel_lock; +raw_spinlock_t inner_mon_sel_lock; +unsigned long inner_mon_sel_flags; + +void __iomem *mapped_hwpage; + size_t mapped_hwpage_sz; +}; + +#endif /* MPAM_INTERNAL_H */ --2.20.1
James Morse
maintainerRe: [PATCH 10/33] arm_mpam: Add probe/remove for mpam msc driver and kbuild boiler plate
Hi Shaopeng,
Quoted 29 lines · Shaopeng Tan (Fujitsu)
Quoted 29 lines
Probing MPAM is convoluted. MSCs that are integrated with a CPU may only be accessible from those CPUs, and they may not be online. Touching the hardware early is pointless as MPAM can't be used until the system-wide common values for
num_partidandnum_pmghave been discovered.Start with driver probe/remove and mapping the MSC.
drivers/resctrl/mpam_devices.c new file +15
-0@@ -0,0 +1,336 @@ +static int mpam_dt_parse_resources (struct mpam_msc *msc,void *ignored) +{ +int err, num_ris =0 ; +const u32 *ris_idx_p; +struct device_node *iter, *np; + + np = msc->pdev->dev.of_node; +for_each_child_of_node (np, iter) { + ris_idx_p =of_get_property (iter,"reg" ,NULL ); +if (ris_idx_p) { + num_ris++; + err =mpam_dt_parse_resource (msc, iter, *ris_idx_p); +if (err) { +of_node_put (iter); +return err;
Quoted 8 lines
drivers/resctrl/mpam_devices.c line 124
Quoted 6 lines
drivers/resctrl/mpam_devices.c new file +6
-0+ } + } + } + +if (!num_ris) +mpam_dt_parse_resource (msc, np,0 );err =
mpam_dt_parse_resource(msc, np, 0);
Oops! Thanks for catching that,
James
James Morse
maintainerPATCH 11/33 arm_mpam: Add support for memory controller MSC on DT platforms
In reply to James MorseFrom: Shanker Donthineni <[email protected]>
The device-tree binding has two examples for MSC associated with memory controllers. Add the support to discover the component_id from the device-tree and create 'memory' RIS.
--- drivers/resctrl/mpam_devices.c | 67 ++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 20 deletions(-)
drivers/resctrl/mpam_devices.c +47 -20
@@ -62,41 +62,63 @@ static int mpam_dt_parse_resource(struct mpam_msc *msc, struct device_node *np, u32 ris_idx) {int err =0 ; -u32 level =0 ; -unsigned long cache_id; -struct device_node *cache; +u32 class_id =0 , component_id =0 ; +struct device_node *cache =NULL , *memory =NULL ; +enum mpam_class_types type =MPAM_CLASS_UNKNOWN ;do { +/* What kind of MSC is this? */ if (of_device_is_compatible (np,"arm,mpam-cache" )) { cache =of_parse_phandle (np,"arm,mpam-device" ,0 );if (!cache) {pr_err ("Failed to read phandle\n" );break ; } + type =MPAM_CLASS_CACHE ; }else if (of_device_is_compatible (np->parent,"cache" )) { cache =of_node_get (np->parent); + type =MPAM_CLASS_CACHE ; + }else if (of_device_is_compatible (np,"arm,mpam-memory" )) { + memory =of_parse_phandle (np,"arm,mpam-device" ,0 ); +if (!memory) { +pr_err ("Failed to read phandle\n" ); +break ; + } + type =MPAM_CLASS_MEMORY ; + }else if (of_device_is_compatible (np,"arm,mpam-memory-controller-msc" )) { + memory =of_node_get (np->parent); + type =MPAM_CLASS_MEMORY ; }else { -/* For now, only caches are supported */ - cache =NULL ; +/* +* For now, only caches and memory controllers are +* supported. +*/ break ; } - err =of_property_read_u32 (cache,"cache-level" , &level); -if (err) { -pr_err ("Failed to read cache-level\n" ); -break ; - } - - cache_id =cache_of_calculate_id (cache); -if (cache_id == ~0UL ) { - err = -ENOENT ; -break ; +/* Determine the class and component ids, based on type. */ +if (type ==MPAM_CLASS_CACHE ) { + err =of_property_read_u32 (cache,"cache-level" , &class_id); +if (err) { +pr_err ("Failed to read cache-level\n" ); +break ; + } + component_id =cache_of_calculate_id (cache); +if (component_id == ~0UL ) { + err = -ENOENT ; +break ; + } + }else if (type ==MPAM_CLASS_MEMORY ) { + err =of_node_to_nid (np); + component_id = (err ==NUMA_NO_NODE ) ?0 : err; + class_id =255 ; } - err =mpam_ris_create (msc, ris_idx,MPAM_CLASS_CACHE , level, - cache_id); + err =mpam_ris_create (msc, ris_idx, type, class_id, + component_id); }while (0 );of_node_put (cache); +of_node_put (memory);return err; }
@@ -157,9 +179,14 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { - err = -EINVAL ; -pr_err ("Cannot determine accessibility of MSC: %s\n" , -dev_name (&msc->pdev->dev)); +if (of_device_is_compatible (parent,"memory" )) { +cpumask_copy (&msc->accessibility, cpu_possible_mask); + err =0 ; + }else { + err = -EINVAL ; +pr_err ("Cannot determine accessibility of MSC: %s\n" , +dev_name (&msc->pdev->dev)); + } }of_node_put (parent);
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 11/33 arm_mpam: Add support for memory controller MSC on DT platforms
In reply to James MorseFrom: Shanker Donthineni <[email protected]>
The device-tree binding has two examples for MSC associated with memory controllers. Add the support to discover the component_id from the device-tree and create 'memory' RIS.
--- drivers/resctrl/mpam_devices.c | 67 ++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 20 deletions(-)
drivers/resctrl/mpam_devices.c +47 -20
@@ -62,41 +62,63 @@ static int mpam_dt_parse_resource(struct mpam_msc *msc, struct device_node *np, u32 ris_idx) {int err =0 ; -u32 level =0 ; -unsigned long cache_id; -struct device_node *cache; +u32 class_id =0 , component_id =0 ; +struct device_node *cache =NULL , *memory =NULL ; +enum mpam_class_types type =MPAM_CLASS_UNKNOWN ;do { +/* What kind of MSC is this? */ if (of_device_is_compatible (np,"arm,mpam-cache" )) { cache =of_parse_phandle (np,"arm,mpam-device" ,0 );if (!cache) {pr_err ("Failed to read phandle\n" );break ; } + type =MPAM_CLASS_CACHE ; }else if (of_device_is_compatible (np->parent,"cache" )) { cache =of_node_get (np->parent); + type =MPAM_CLASS_CACHE ; + }else if (of_device_is_compatible (np,"arm,mpam-memory" )) { + memory =of_parse_phandle (np,"arm,mpam-device" ,0 ); +if (!memory) { +pr_err ("Failed to read phandle\n" ); +break ; + } + type =MPAM_CLASS_MEMORY ; + }else if (of_device_is_compatible (np,"arm,mpam-memory-controller-msc" )) { + memory =of_node_get (np->parent); + type =MPAM_CLASS_MEMORY ; }else { -/* For now, only caches are supported */ - cache =NULL ; +/* +* For now, only caches and memory controllers are +* supported. +*/ break ; } - err =of_property_read_u32 (cache,"cache-level" , &level); -if (err) { -pr_err ("Failed to read cache-level\n" ); -break ; - } - - cache_id =cache_of_calculate_id (cache); -if (cache_id == ~0UL ) { - err = -ENOENT ; -break ; +/* Determine the class and component ids, based on type. */ +if (type ==MPAM_CLASS_CACHE ) { + err =of_property_read_u32 (cache,"cache-level" , &class_id); +if (err) { +pr_err ("Failed to read cache-level\n" ); +break ; + } + component_id =cache_of_calculate_id (cache); +if (component_id == ~0UL ) { + err = -ENOENT ; +break ; + } + }else if (type ==MPAM_CLASS_MEMORY ) { + err =of_node_to_nid (np); + component_id = (err ==NUMA_NO_NODE ) ?0 : err; + class_id =255 ; } - err =mpam_ris_create (msc, ris_idx,MPAM_CLASS_CACHE , level, - cache_id); + err =mpam_ris_create (msc, ris_idx, type, class_id, + component_id); }while (0 );of_node_put (cache); +of_node_put (memory);return err; }
@@ -157,9 +179,14 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { - err = -EINVAL ; -pr_err ("Cannot determine accessibility of MSC: %s\n" , -dev_name (&msc->pdev->dev)); +if (of_device_is_compatible (parent,"memory" )) { +cpumask_copy (&msc->accessibility, cpu_possible_mask); + err =0 ; + }else { + err = -EINVAL ; +pr_err ("Cannot determine accessibility of MSC: %s\n" , +dev_name (&msc->pdev->dev)); + } }of_node_put (parent);
Signature · 1 line
2.20.1
RE: [PATCH 11/33] arm_mpam: Add support for memory controller MSC on DT platforms
Hello James,
Quoted 55 lines
From: Shanker Donthineni <[email protected]>
The device-tree binding has two examples for MSC associated with memory controllers. Add the support to discover the
component_idfrom the device-tree and create 'memory' RIS.Signed-off-by Shanker Donthineni <[email protected]> [ morse: splitout of a bigger patch, added affinity piece ]
Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 67 ++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 20 deletions(-)drivers/resctrl/mpam_devices.c +15
-3@@ -62,41 +62,63 @@ static int mpam_dt_parse_resource(struct mpam_msc *msc, struct device_node *np, u32 ris_idx) {int err =0 ; -u32 level =0 ; -unsigned long cache_id; -struct device_node *cache; +u32 class_id =0 , component_id =0 ; +struct device_node *cache =NULL , *memory =NULL ; +enum mpam_class_types type =MPAM_CLASS_UNKNOWN ; do { + /* What kind of MSC is this? */ if (of_device_is_compatible(np, "arm,mpam-cache")) { cache = of_parse_phandle(np, "arm,mpam-device", 0); if (!cache) { pr_err("Failed to read phandle\n"); break; } + type = MPAM_CLASS_CACHE; } else if (of_device_is_compatible(np->parent, "cache")) { cache = of_node_get(np->parent); + type = MPAM_CLASS_CACHE; + } else if (of_device_is_compatible(np, "arm,mpam-memory")) { + memory = of_parse_phandle(np, "arm,mpam-device", 0); + if (!memory) { + pr_err("Failed to read phandle\n"); + break; + } + type = MPAM_CLASS_MEMORY; + } else if (of_device_is_compatible(np, "arm,mpam-memory-controller-msc")) { + memory = of_node_get(np->parent);
drivers/resctrl/mpam_devices.c static int mpam_dt_parse_resource(struct mpam_msc · line 102
Quoted 10 lines
drivers/resctrl/mpam_devices.c +5
-2+ type =MPAM_CLASS_MEMORY ; }else { -/* For now, only caches are supported */ - cache =NULL ; +/* +* For now, only caches and memory controllers are +* supported. +*/ break ; }
There is no need "{}" here.
Best regards,
Shaopeng TAN
Quoted 63 lines
drivers/resctrl/mpam_devices.c +27
-15- err =of_property_read_u32 (cache,"cache-level" , &level); -if (err) { -pr_err ("Failed to read cache-level\n" ); -break ; - } - - cache_id =cache_of_calculate_id (cache); -if (cache_id == ~0UL ) { - err = -ENOENT ; -break ; +/* Determine the class and component ids, based on type. */ +if (type ==MPAM_CLASS_CACHE ) { + err =of_property_read_u32 (cache,"cache-level" , &class_id); +if (err) { +pr_err ("Failed to read cache-level\n" ); +break ; + } + component_id =cache_of_calculate_id (cache); +if (component_id == ~0UL ) { + err = -ENOENT ; +break ; + } + }else if (type ==MPAM_CLASS_MEMORY ) { + err =of_node_to_nid (np); + component_id = (err ==NUMA_NO_NODE ) ?0 : err; + class_id =255 ; } - err =mpam_ris_create (msc, ris_idx,MPAM_CLASS_CACHE , level, - cache_id); + err =mpam_ris_create (msc, ris_idx, type, class_id, + component_id); }while (0 );of_node_put (cache); +of_node_put (memory);return err; }@@ -157,9 +179,14 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { - err = -EINVAL ; -pr_err ("Cannot determine accessibility of MSC: %s\n" , -dev_name (&msc->pdev->dev)); +if (of_device_is_compatible (parent,"memory" )) { +cpumask_copy (&msc->accessibility, cpu_possible_mask); + err =0 ; + }else { + err = -EINVAL ; +pr_err ("Cannot determine accessibility of MSC: %s\n", +dev_name (&msc->pdev->dev)); + }drivers/resctrl/mpam_devices.c +0
-1}of_node_put (parent); --2.20.1
James Morse
maintainerRe: [PATCH 11/33] arm_mpam: Add support for memory controller MSC on DT platforms
Hi Shaopeng,
Quoted 51 lines · Shaopeng Tan (Fujitsu)
Quoted 51 lines
From: Shanker Donthineni <[email protected]>
The device-tree binding has two examples for MSC associated with memory controllers. Add the support to discover the
component_idfrom the device-tree and create 'memory' RIS.drivers/resctrl/mpam_devices.c +16
-5@@ -62,41 +62,63 @@ static int mpam_dt_parse_resource(struct mpam_msc *msc, struct device_node *np, u32 ris_idx) {int err =0 ; -u32 level =0 ; -unsigned long cache_id; -struct device_node *cache; +u32 class_id =0 , component_id =0 ; +struct device_node *cache =NULL , *memory =NULL ; +enum mpam_class_types type =MPAM_CLASS_UNKNOWN ; do { + /* What kind of MSC is this? */ if (of_device_is_compatible(np, "arm,mpam-cache")) { cache = of_parse_phandle(np, "arm,mpam-device", 0); if (!cache) { pr_err("Failed to read phandle\n"); break; } + type = MPAM_CLASS_CACHE; } else if (of_device_is_compatible(np->parent, "cache")) { cache = of_node_get(np->parent); + type = MPAM_CLASS_CACHE; + } else if (of_device_is_compatible(np, "arm,mpam-memory")) { + memory = of_parse_phandle(np, "arm,mpam-device", 0); + if (!memory) { + pr_err("Failed to read phandle\n"); + break; + } + type = MPAM_CLASS_MEMORY; + } else if (of_device_is_compatible(np, "arm,mpam-memory-controller-msc")) { + memory = of_node_get(np->parent); + type = MPAM_CLASS_MEMORY; } else { - /* For now, only caches are supported */ - cache = NULL;
Quoted 8 lines
drivers/resctrl/mpam_devices.c static int mpam_dt_parse_resource(struct mpam_msc *msc, struct device_node *np, · line 97
Quoted 6 lines
drivers/resctrl/mpam_devices.c +4
-0+/* +* For now, only caches and memory controllers are +* supported. +*/ break ; }There is no need "{}" here.
Sure, but its more than one line, and all the previous parts of this else-if tree have them. Keeping this here make it much easier to read.
Thanks,
James
James Morse
maintainerPATCH 12/33 arm_mpam: Add the class and component structures for ris firmware described
In reply to James MorseAn MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct mpam_components are a set of struct mpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outside mpam_devices.c
struct mpam_vmsc are then a set of struct mpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.
Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
---
Changes since RFC:
* removed a pr_err() debug message that crept in.
--- drivers/resctrl/mpam_devices.c | 488 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 91 ++++++ include/linux/arm_mpam.h | 8 +- 3 files changed, 574 insertions(+), 13 deletions(-)
drivers/resctrl/mpam_devices.c +481 -7
@@ -20,7 +20,6 @@#include <linux/printk.h> #include <linux/slab.h> #include <linux/spinlock.h> -#include <linux/srcu.h> #include <linux/types.h> #include <acpi/pcc.h>
@@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +/* +* An MSC is a physical container for controls and monitors, each identified by +* their RIS index. These share a base-address, interrupts and some MMIO +* registers. A vMSC is a virtual container for RIS in an MSC that control or +* monitor the same thing. Members of a vMSC are all RIS in the same MSC, but +* not all RIS in an MSC share a vMSC. +* Components are a group of vMSC that control or monitor the same thing but +* are from different MSC, so have different base-address, interrupts etc. +* Classes are the set components of the same type. +* +* The features of a vMSC is the union of the RIS it contains. +* The features of a Class and Component are the common subset of the vMSC +* they contain. +* +* e.g. The system cache may have bandwidth controls on multiple interfaces, +* for regulating traffic from devices independently of traffic from CPUs. +* If these are two RIS in one MSC, they will be treated as controlling +* different things, and will not share a vMSC/component/class. +* +* e.g. The L2 may have one MSC and two RIS, one for cache-controls another +* for bandwidth. These two RIS are members of the same vMSC. +* +* e.g. The set of RIS that make up the L2 are grouped as a component. These +* are sometimes termed slices. They should be configured the same, as if there +* were only one. +* +* e.g. The SoC probably has more than one L2, each attached to a distinct set +* of CPUs. All the L2 components are grouped as a class. +* +* When creating an MSC, struct mpam_msc is added to the all mpam_all_msc list, +* then linked via struct mpam_ris to a vmsc, component and class. +* The same MSC may exist under different class->component->vmsc paths, but the +* RIS index will be unique. +*/ +LIST_HEAD (mpam_classes); + +/* List of all objects that can be free()d after synchronise_srcu() */ +static LLIST_HEAD (mpam_garbage); + +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) + +static struct mpam_vmsc * +mpam_vmsc_alloc (struct mpam_component *comp,struct mpam_msc *msc,gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + + vmsc =kzalloc (sizeof (*vmsc), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (vmsc); + +INIT_LIST_HEAD_RCU (&vmsc->ris); +INIT_LIST_HEAD_RCU (&vmsc->comp_list); + vmsc->comp = comp; + vmsc->msc = msc; + +list_add_rcu (&vmsc->comp_list, &comp->vmsc); + +return vmsc; +} + +static struct mpam_vmsc *mpam_vmsc_get (struct mpam_component *comp, +struct mpam_msc *msc,bool alloc, +gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +if (vmsc->msc->id == msc->id) +return vmsc; + } + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_vmsc_alloc (comp, msc, gfp); +} + +static struct mpam_component * +mpam_component_alloc (struct mpam_class *class,int id,gfp_t gfp) +{ +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + + comp =kzalloc (sizeof (*comp), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (comp); + + comp->comp_id = id; +INIT_LIST_HEAD_RCU (&comp->vmsc); +/* affinity is updated when ris are added */ +INIT_LIST_HEAD_RCU (&comp->class_list); + comp->class = class; + +list_add_rcu (&comp->class_list, &class->components); + +return comp; +} + +static struct mpam_component * +mpam_component_get (struct mpam_class *class,int id,bool alloc,gfp_t gfp) +{ +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (comp, &class->components, class_list) { +if (comp->comp_id == id) +return comp; + } + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_component_alloc (class, id, gfp); +} + +static struct mpam_class * +mpam_class_alloc (u8 level_idx,enum mpam_class_types type,gfp_t gfp) +{ +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + + class =kzalloc (sizeof (*class), gfp); +if (!class) +return ERR_PTR (-ENOMEM ); +init_garbage (class); + +INIT_LIST_HEAD_RCU (&class->components); +/* affinity is updated when ris are added */ + class->level = level_idx; + class->type = type; +INIT_LIST_HEAD_RCU (&class->classes_list); + +list_add_rcu (&class->classes_list, &mpam_classes); + +return class; +} + +static struct mpam_class * +mpam_class_get (u8 level_idx,enum mpam_class_types type,bool alloc,gfp_t gfp) +{ +bool found = false; +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (class, &mpam_classes, classes_list) { +if (class->type == type && class->level == level_idx) { + found = true; +break ; + } + } + +if (found) +return class; + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_class_alloc (level_idx, type, gfp); +} + +#define add_to_garbage (x) \ +do { \ + __typeof__(x) _x = x; \ + (_x)->garbage.to_free = (_x); \ + llist_add(&(_x)->garbage.llist, &mpam_garbage); \ +} while (0) + +static void mpam_class_destroy (struct mpam_class *class) +{ +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&class->classes_list); +add_to_garbage (class); +} + +static void mpam_comp_destroy (struct mpam_component *comp) +{ +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&comp->class_list); +add_to_garbage (comp); + +if (list_empty (&class->components)) +mpam_class_destroy (class); +} + +static void mpam_vmsc_destroy (struct mpam_vmsc *vmsc) +{ +struct mpam_component *comp = vmsc->comp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&vmsc->comp_list); +add_to_garbage (vmsc); + +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +} + +static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity); +clear_bit (ris->ris_idx, msc->ris_idxs); +list_del_rcu (&ris->vmsc_list); +list_del_rcu (&ris->msc_list); +add_to_garbage (ris); + ris->garbage.pdev = pdev; + +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +} + +/* +* There are two ways of reaching a struct mpam_msc_ris. Via the +* class->component->vmsc->ris, or via the msc. +* When destroying the msc, the other side needs unlinking and cleaning up too. +*/ +static void mpam_msc_destroy (struct mpam_msc *msc) +{ +struct platform_device *pdev = msc->pdev; +struct mpam_msc_ris *ris, *tmp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&msc->glbl_list); +platform_set_drvdata (pdev,NULL ); + +list_for_each_entry_safe (ris, tmp, &msc->ris, msc_list) +mpam_ris_destroy (ris); + +add_to_garbage (msc); + msc->garbage.pdev = pdev; +} + +static void mpam_free_garbage (void ) +{ +struct mpam_garbage *iter, *tmp; +struct llist_node *to_free =llist_del_all (&mpam_garbage); + +if (!to_free) +return ; + +synchronize_srcu (&mpam_srcu); + +llist_for_each_entry_safe (iter, tmp, to_free, llist) { +if (iter->pdev) +devm_kfree (&iter->pdev->dev, iter->to_free); +else +kfree (iter->to_free); + } +} + +/* Called recursively to walk the list of caches from a particular CPU */ +static void __mpam_get_cpumask_from_cache_id (int cpu,struct device_node *cache_node, +unsigned long cache_id, +u32 cache_level, +cpumask_t *affinity) +{ +int err; +u32 iter_level; +unsigned long iter_cache_id; + struct device_node *iter_node __free(device_node) = of_find_next_cache_node(cache_node); + +if (!iter_node) +return ; + + err =of_property_read_u32 (iter_node,"cache-level" , &iter_level); +if (err) +return ; + +/* +* get_cpu_cacheinfo_id() isn't ready until sometime +* during device_initcall(). Use cache_of_calculate_id(). +*/ + iter_cache_id =cache_of_calculate_id (iter_node); +if (cache_id == ~0UL ) +return ; + +if (iter_level == cache_level && iter_cache_id == cache_id) +cpumask_set_cpu (cpu, affinity); + +__mpam_get_cpumask_from_cache_id (cpu, iter_node, cache_id, cache_level, + affinity); +} + +/* +* The cacheinfo structures are only populated when CPUs are online. +* This helper walks the device tree to include offline CPUs too. +*/ +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level, +cpumask_t *affinity) +{ +int cpu; + +if (!acpi_disabled) +return acpi_pptt_get_cpumask_from_cache_id (cache_id, affinity); + +for_each_possible_cpu (cpu) { + struct device_node *cpu_node __free(device_node) = of_get_cpu_node(cpu, NULL); +if (!cpu_node) { +pr_err ("Failed to find cpu%d device node\n" , cpu); +return -ENOENT ; + } + +__mpam_get_cpumask_from_cache_id (cpu, cpu_node, cache_id, + cache_level, affinity); +continue ; + } + +return 0 ; +} + +/* +* cpumask_of_node() only knows about online CPUs. This can't tell us whether +* a class is represented on all possible CPUs. +*/ +static void get_cpumask_from_node_id (u32 node_id,cpumask_t *affinity) +{ +int cpu; + +for_each_possible_cpu (cpu) { +if (node_id ==cpu_to_node (cpu)) +cpumask_set_cpu (cpu, affinity); + } +} + +static int get_cpumask_from_cache (struct device_node *cache, +cpumask_t *affinity) +{ +int err; +u32 cache_level; +unsigned long cache_id; + + err =of_property_read_u32 (cache,"cache-level" , &cache_level); +if (err) { +pr_err ("Failed to read cache-level from cache node\n" ); +return -ENOENT ; + } + + cache_id =cache_of_calculate_id (cache); +if (cache_id == ~0UL ) { +pr_err ("Failed to calculate cache-id from cache node\n" ); +return -ENOENT ; + } + +return mpam_get_cpumask_from_cache_id (cache_id, cache_level, affinity); +} + +static int mpam_ris_get_affinity (struct mpam_msc *msc,cpumask_t *affinity, +enum mpam_class_types type, +struct mpam_class *class, +struct mpam_component *comp) +{ +int err; + +switch (type) { +case MPAM_CLASS_CACHE : + err =mpam_get_cpumask_from_cache_id (comp->comp_id, class->level, + affinity); +if (err) +return err; + +if (cpumask_empty (affinity)) +pr_warn_once ("%s no CPUs associated with cache node" , +dev_name (&msc->pdev->dev)); + +break ; +case MPAM_CLASS_MEMORY : +get_cpumask_from_node_id (comp->comp_id, affinity); +/* affinity may be empty for CPU-less memory nodes */ +break ; +case MPAM_CLASS_UNKNOWN : +return 0 ; + } + +cpumask_and (affinity, affinity, &msc->accessibility); + +return 0 ; +} + +static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id, +int component_id,gfp_t gfp) +{ +int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ; + + ris =devm_kzalloc (&msc->pdev->dev,sizeof (*ris), gfp); +if (!ris) +return -ENOMEM ; +init_garbage (ris); + + class =mpam_class_get (class_id, type, true, gfp); +if (IS_ERR (class)) +return PTR_ERR (class); + + comp =mpam_component_get (class, component_id, true, gfp); +if (IS_ERR (comp)) { +if (list_empty (&class->components)) +mpam_class_destroy (class); +return PTR_ERR (comp); + } + + vmsc =mpam_vmsc_get (comp, msc, true, gfp); +if (IS_ERR (vmsc)) { +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +return PTR_ERR (vmsc); + } + + err =mpam_ris_get_affinity (msc, &ris->affinity, type, class, comp); +if (err) { +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +return err; + } + + ris->ris_idx = ris_idx; +INIT_LIST_HEAD_RCU (&ris->vmsc_list); + ris->vmsc = vmsc; + +cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_or (&class->affinity, &class->affinity, &ris->affinity); +list_add_rcu (&ris->vmsc_list, &vmsc->ris); + +return 0 ; +} + +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id,int component_id) +{ +int err; + +mutex_lock (&mpam_list_lock); + err =mpam_ris_create_locked (msc, ris_idx, type, class_id, + component_id,GFP_KERNEL ); +mutex_unlock (&mpam_list_lock); +if (err) +mpam_free_garbage (); + +return err; +} +static void mpam_discovery_complete (void ) {pr_err ("Discovered all MSC\n" );
@@ -179,7 +650,10 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { -if (of_device_is_compatible (parent,"memory" )) { +if (of_device_is_compatible (parent,"cache" )) { + err =get_cpumask_from_cache (parent, + &msc->accessibility); + }else if (of_device_is_compatible (parent,"memory" )) {cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else {
@@ -209,11 +683,10 @@ static void mpam_msc_drv_remove(struct platform_device *pdev)mutex_lock (&mpam_list_lock); mpam_num_msc--; -platform_set_drvdata (pdev,NULL ); -list_del_rcu (&msc->glbl_list); -synchronize_srcu (&mpam_srcu); -devm_kfree (&pdev->dev, msc); +mpam_msc_destroy (msc);mutex_unlock (&mpam_list_lock); + +mpam_free_garbage (); }static int mpam_msc_drv_probe (struct platform_device *pdev)
@@ -230,6 +703,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) err = -ENOMEM ;break ; } +init_garbage (msc);mutex_init (&msc->probe_lock);mutex_init (&msc->part_sel_lock);
drivers/resctrl/mpam_internal.h +91 -0
107 lines not on this page · raw message
include/linux/arm_mpam.h +2 -6
@@ -36,11 +36,7 @@ static inline int acpi_mpam_parse_resources(struct mpam_msc *msc,static inline int acpi_mpam_count_msc (void ) {return -EINVAL ; }#endif -static inline int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, -enum mpam_class_types type,u8 class_id, -int component_id) -{ -return -EINVAL ; -} +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id,int component_id);#endif /* __LINUX_ARM_MPAM_H */
Signature · 1 line
2.20.1
Fenghua Yu
reviewerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi, James,
Quoted 40 lines · James Morse
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
CC Ben Horgan <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* removed apr_err()debug message that crept in.--- drivers/resctrl/mpam_devices.c | 488 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 91 ++++++ include/linux/arm_mpam.h | 8 +- 3 files changed, 574 insertions(+), 13 deletions(-)drivers/resctrl/mpam_devices.c +0
-0
[SNIP]
drivers/resctrl/mpam_devices.c line 91
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static struct mpam_vmsc * +mpam_vmsc_alloc (struct mpam_component *comp,struct mpam_msc *msc,gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + + vmsc =kzalloc (sizeof (*vmsc), gfp); +if (!comp)
s/if (!cmp)/if (!vmsc)/
drivers/resctrl/mpam_devices.c line 103
Quoted 12 lines
drivers/resctrl/mpam_devices.c +12
-0+return ERR_PTR (-ENOMEM ); +init_garbage (vmsc); + +INIT_LIST_HEAD_RCU (&vmsc->ris); +INIT_LIST_HEAD_RCU (&vmsc->comp_list); + vmsc->comp = comp; + vmsc->msc = msc; + +list_add_rcu (&vmsc->comp_list, &comp->vmsc); + +return vmsc; +}
Thanks.
-Fenghua
James Morse
maintainerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi Fenghua,
Quoted 31 lines · Fenghua Yu
Quoted 29 lines · James Morse
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
drivers/resctrl/mpam_devices.c +0
-0[SNIP]
Quoted 14 lines
drivers/resctrl/mpam_devices.c line 91
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static struct mpam_vmsc * +mpam_vmsc_alloc (struct mpam_component *comp,struct mpam_msc *msc,gfp_t gfp) +{ + struct mpam_vmsc *vmsc; + + lockdep_assert_held(&mpam_list_lock); + + vmsc = kzalloc(sizeof(*vmsc), gfp); + if (!comp)s/if (!cmp)/if (!vmsc)/
Quoted 1 line
+ return
ERR_PTR(-ENOMEM);
Yup, that's a copy-and-paste typo. Fixed,
Thanks,
James
Re: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
In reply to James MorseHi,
Quoted 1 line
Subject:
arm_mpam: Add the class and component structures for ris firmware described
Mangled subject line?
There is a fair intersection between the commit message and what the patch does, but they don't quite seem to match up.
Some key issues like locking / object lifecycle management and DT parsing (a bit of which, it appears, lives here too) are not mentioned at all.
In lieu of a complete rewrite, it might be best to discard the explanation of the various object types. The comment in the code speaks for itself, and looks clearer.
[...]
Quoted 40 lines · James Morse
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.CC Ben Horgan <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* removed apr_err()debug message that crept in.--- drivers/resctrl/mpam_devices.c | 488 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 91 ++++++ include/linux/arm_mpam.h | 8 +- 3 files changed, 574 insertions(+), 13 deletions(-)drivers/resctrl/mpam_devices.c +0
-0@@ -20,7 +20,6 @@
[...]
drivers/resctrl/mpam_devices.c line 37
Quoted 6 lines
drivers/resctrl/mpam_devices.c +1
-1@@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;
Why expose this here? This patch makes no use of the exposed symbol.
Quoted 28 lines
drivers/resctrl/mpam_devices.c +24
-0/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +/* +* An MSC is a physical container for controls and monitors, each identified by +* their RIS index. These share a base-address, interrupts and some MMIO +* registers. A vMSC is a virtual container for RIS in an MSC that control or +* monitor the same thing. Members of a vMSC are all RIS in the same MSC, but +* not all RIS in an MSC share a vMSC. +* Components are a group of vMSC that control or monitor the same thing but +* are from different MSC, so have different base-address, interrupts etc. +* Classes are the set components of the same type. +* +* The features of a vMSC is the union of the RIS it contains. +* The features of a Class and Component are the common subset of the vMSC +* they contain. +* +* e.g. The system cache may have bandwidth controls on multiple interfaces, +* for regulating traffic from devices independently of traffic from CPUs. +* If these are two RIS in one MSC, they will be treated as controlling +* different things, and will not share a vMSC/component/class. +* +* e.g. The L2 may have one MSC and two RIS, one for cache-controls another +* for bandwidth. These two RIS are members of the same vMSC. +* +* e.g. The set of RIS that make up the L2 are grouped as a component. These +* are sometimes termed slices. They should be configured the same, as if there
drivers/resctrl/mpam_devices.c line 75
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+* were only one. +* +* e.g. The SoC probably has more than one L2, each attached to a distinct set +* of CPUs. All the L2 components are grouped as a class. +* +* When creating an MSC, struct mpam_msc is added to the all mpam_all_msc list, +* then linked via struct mpam_ris to a vmsc, component and class. +* The same MSC may exist under different class->component->vmsc paths, but the +* RIS index will be unique. +*/
This description of the structures and how they relate to each other seems OK (bearing in mind that I am already familiar with this stuff -- I can't speak for other people).
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+LIST_HEAD (mpam_classes); + +/* List of all objects that can be free()d after synchronise_srcu() */ +static LLIST_HEAD (mpam_garbage); + +#define init_garbage (x) init_llist_node(&(x)->garbage.llist)
[...]
drivers/resctrl/mpam_devices.c line 214
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+#define add_to_garbage (x) \ +do { \ + __typeof__(x) _x = x; \
Nit:
= (x)
(for the paranoid)
drivers/resctrl/mpam_devices.c line 215
Quoted 1 line
drivers/resctrl/mpam_devices.c +1
-0+ (_x)->garbage.to_free = (_x); \
_x->garbage.to_free = _x;
(_x is an identifier, not a macro argument. It can't get re-parsed as something else -- assuming that there is not a #define for _x, but then all bets would be off anyway.)
drivers/resctrl/mpam_devices.c line 216
Quoted 1 line
drivers/resctrl/mpam_devices.c +1
-0+llist_add (&(_x)->garbage.llist, &mpam_garbage); \
&_x->...
[...]
drivers/resctrl/mpam_devices.c line 264
Quoted 12 lines
drivers/resctrl/mpam_devices.c +12
-0+static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity);
This is not the inverse of the cpumask_or()s in mpam_ris_create_locked(), unless the the ris associated with each class and each component have strictly disjoint affinity masks. Is that checked anywhere, or should it be impossible by construction?
But, thinking about it:
I wonder why we ever really need to do the teardown. If we get an error interrupt then we can just go into a sulk, spam dmesg a bit, put the hardware into the most vanilla state that we can, and refuse to manipulate it further. But this only happens in the case of a software or hardware *bug* (or, in a future world where we might implement virtualisation, an uncontainable MPAM error triggered by a guest -- for which tearing down the host MPAM would be an overreaction).
Trying to cleanly tear the MPAM driver down after such an error seems a bit futile.
The MPAM resctrl glue could eventually be made into a module (though not needed from day 1) -- which would allow for unloading resctrlfs if that is eventually module-ised. I think this wouldn't require the MPAM devices backend to be torn down at any point, though (?)
If we can simplify or eliminate the teardown, does it simplify the locking at all? The garbage collection logic can also be dispensed with if there is never any garbage.
Since MSCs etc. never disappear from the hardware, it feels like it ought not to be necessary ever to remove items from any of these lists except when trying to do a teardown (?)
(Putting the hardware into a quiecent state is not the same thing as tearing down the data structures -- we do want to quiesce MPAM when shutting down the kernel, as least for the kexec scenario.)
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+clear_bit (ris->ris_idx, msc->ris_idxs); +list_del_rcu (&ris->vmsc_list); +list_del_rcu (&ris->msc_list); +add_to_garbage (ris); + ris->garbage.pdev = pdev; + +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +}
[...]
Quoted 4 lines
drivers/resctrl/mpam_devices.c +4
-0+static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id, +int component_id,gfp_t gfp) +{
drivers/resctrl/mpam_devices.c line 456
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ;
Is it impossible by construction to get in here with an out-of-range ris_idx?
To avoid the callers (i.e., ACPI) needing to understand the internal limitations of this code, maybe it is worth having a check here (even if technically redundant).
[...]
Cheers
---Dave
James Morse
maintainerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi Dave,
Quoted 3 lines · Dave Martin
Quoted 1 line
Subject:
arm_mpam: Add the class and component structures for ris firmware describedMangled subject line?
order words hard is.
Quoted 6 lines
There is a fair intersection between the commit message and what the patch does, but they don't quite seem to match up.
Some key issues like locking / object lifecycle management and DT parsing (a bit of which, it appears, lives here too) are not mentioned at all.
I don't think everything needs mentioning - you have the diff for that.This should capture the motivation, what you have and what you need to find, the grouping etc.
Quoted 3 lines
In lieu of a complete rewrite, it might be best to discard the explanation of the various object types. The comment in the code speaks for itself, and looks clearer.
Fair enough,
Quoted 35 lines
[...]
Quoted 29 lines · James Morse
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.drivers/resctrl/mpam_devices.c +0
-0@@ -20,7 +20,6 @@[...]
Quoted 8 lines
drivers/resctrl/mpam_devices.c line 37
Quoted 6 lines
drivers/resctrl/mpam_devices.c +1
-1@@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;Why expose this here? This patch makes no use of the exposed symbol.
The mpam_resctrl code needs to take it when it walks these lists. I don't want to change it then because its just additional churn.
Quoted 38 lines
Quoted 27 lines
drivers/resctrl/mpam_devices.c +24
-0/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +/* +* An MSC is a physical container for controls and monitors, each identified by +* their RIS index. These share a base-address, interrupts and some MMIO +* registers. A vMSC is a virtual container for RIS in an MSC that control or +* monitor the same thing. Members of a vMSC are all RIS in the same MSC, but +* not all RIS in an MSC share a vMSC. +* Components are a group of vMSC that control or monitor the same thing but +* are from different MSC, so have different base-address, interrupts etc. +* Classes are the set components of the same type. +* +* The features of a vMSC is the union of the RIS it contains. +* The features of a Class and Component are the common subset of the vMSC +* they contain. +* +* e.g. The system cache may have bandwidth controls on multiple interfaces, +* for regulating traffic from devices independently of traffic from CPUs. +* If these are two RIS in one MSC, they will be treated as controlling +* different things, and will not share a vMSC/component/class. +* +* e.g. The L2 may have one MSC and two RIS, one for cache-controls another +* for bandwidth. These two RIS are members of the same vMSC. +* +* e.g. The set of RIS that make up the L2 are grouped as a component. These +* are sometimes termed slices. They should be configured the same, as if there drivers/resctrl/mpam_devices.c line 75
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+* were only one. +* +* e.g. The SoC probably has more than one L2, each attached to a distinct set +* of CPUs. All the L2 components are grouped as a class. +* +* When creating an MSC, struct mpam_msc is added to the all mpam_all_msc list, +* then linked via struct mpam_ris to a vmsc, component and class. +* The same MSC may exist under different class->component->vmsc paths, but the +* RIS index will be unique. +*/
Quoted 3 lines
This description of the structures and how they relate to each other seems OK (bearing in mind that I am already familiar with this stuff -- I can't speak for other people).
Great!
Quoted 11 lines
[...]
drivers/resctrl/mpam_devices.c line 214
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+#define add_to_garbage (x) \ +do { \ + __typeof__(x) _x = x; \Nit:
= (x)
(for the paranoid)
Fixed,
Quoted 11 lines
drivers/resctrl/mpam_devices.c line 215
Quoted 1 line
drivers/resctrl/mpam_devices.c +1
-0+ (_x)->garbage.to_free = (_x); \
_x->garbage.to_free= _x;(_x is an identifier, not a macro argument. It can't get re-parsed as something else -- assuming that there is not a #define for _x, but then all bets would be off anyway.)
drivers/resctrl/mpam_devices.c line 216
Quoted 1 line
drivers/resctrl/mpam_devices.c +1
-0+llist_add (&(_x)->garbage.llist, &mpam_garbage); \&_x->...
Fixed,
Quoted 11 lines
[...]
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock);
Quoted 8 lines
drivers/resctrl/mpam_devices.c line 264
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+ +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity);This is not the inverse of the cpumask_or()s in
mpam_ris_create_locked(), unless the the ris associated with each class and each component have strictly disjoint affinity masks. Is that checked anywhere, or should it be impossible by construction?
They should be disjoint. These bitmaps are built from firmware description of the cache hierarchy. I don't think its possible to describe a situation where there are overlaps.
You can build a nonsense cache hierarchy, e.g. where CPU-0's L3 is CPU-6's L2, but if you do the scheduler is going to complain when it tries to chose the scheduler domains. I think this should be filed under "you've got bigger problems". There is a check that catches this in mpam_resctrl_pick_caches(), to see that all the CPUs are accounted for, which is to avoid tasks that get lucky with task-placement managing to escape their resource limit.
Quoted 9 lines
But, thinking about it:
I wonder why we ever really need to do the teardown. If we get an error interrupt then we can just go into a sulk, spam dmesg a bit, put the hardware into the most vanilla state that we can, and refuse to manipulate it further. But this only happens in the case of a software or hardware *bug* (or, in a future world where we might implement virtualisation, an uncontainable MPAM error triggered by a guest -- for which tearing down the host MPAM would be an overreaction).
The good news is guests can't escape the PARTID virtualisation that the CPU does, so any mess a guest manages to make is confined to that guest's PARTID range.
Quoted 7 lines
Trying to cleanly tear the MPAM driver down after such an error seems a bit futile.
The MPAM resctrl glue could eventually be made into a module (though not needed from day 1) -- which would allow for unloading resctrlfs if that is eventually module-ised. I think this wouldn't require the MPAM devices backend to be torn down at any point, though (?)
It would certainly be optional. kernfs->resctrl->mpam is the reason all this has to be built-in. If that changes I'd aim for this to be a module.
All this free()ing was added so that the driver doesn't end up sitting on memory when it isn't providing any usable feature. I have seen a platform where the error interrupt goes off during boot, (I suspect firmware configures an out-of-range PARTID). On such a platform any memory that isn't free()d is a waste.
But I agree its a small amount of memory.
Quoted 3 lines
If we can simplify or eliminate the teardown, does it simplify the locking at all? The garbage collection logic can also be dispensed with if there is never any garbage.
It wouldn't simplify the locking, only remove that deferred free()ing which is needed because of SRCU.
Quoted 3 lines
Since MSCs etc. never disappear from the hardware, it feels like it ought not to be necessary ever to remove items from any of these lists except when trying to do a teardown (?)
Unbinding the driver from an MSC is another case where this may be triggered via mpam_msc_drv_remove(). If you look at the whole thing, mpam_ris_destroy() pokes mpam_resctrl_teardown_class() to see if resctrl needs to be torn down.
I don't anticipate folk actually needing to do that. One Reasons is for VFIO - but this kind of stuff has a performance impact on the hypervisor, so its unlikely to ever allow a guest direct access to this kind of thing. Another reason is to load a more specific driver, which sounds unlikely.
Ultimately this memory free-ing code is here because its the right thing to do. I'd prefer to keep it as making this a loadable module would mean we have to do this.
Quoted 24 lines
(Putting the hardware into a quiecent state is not the same thing as tearing down the data structures -- we do want to quiesce MPAM when shutting down the kernel, as least for the kexec scenario.)
[...]
Quoted 4 lines
drivers/resctrl/mpam_devices.c +4
-0+static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id, +int component_id,gfp_t gfp) +{drivers/resctrl/mpam_devices.c line 456
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ;Is it impossible by construction to get in here with an out-of-range
ris_idx?
Quoted 3 lines
To avoid the callers (i.e., ACPI) needing to understand the internal limitations of this code, maybe it is worth having a check here (even if technically redundant).
It's possible - but only if you mess up the firmware tables. I'll add a check for this as its easy enough.
Thanks,
James
Re: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi,
Quoted 21 lines · James Morse
Hi Dave,
Quoted 3 lines · Dave Martin
Quoted 1 line
Subject:
arm_mpam: Add the class and component structures for ris firmware describedMangled subject line?
order words hard is.
Quoted 6 lines
There is a fair intersection between the commit message and what the patch does, but they don't quite seem to match up.
Some key issues like locking / object lifecycle management and DT parsing (a bit of which, it appears, lives here too) are not mentioned at all.
I don't think everything needs mentioning - you have the diff for that.This should capture the motivation, what you have and what you need to find, the grouping etc.
Quoted 5 lines
Quoted 3 lines
In lieu of a complete rewrite, it might be best to discard the explanation of the various object types. The comment in the code speaks for itself, and looks clearer.
Fair enough,
OK
[...]
Quoted 12 lines
Quoted 12 lines
Quoted 5 lines
drivers/resctrl/mpam_devices.c +0
-0@@ -20,7 +20,6 @@[...]
Quoted 4 lines
drivers/resctrl/mpam_devices.c +0
-0@@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc);
Quoted 7 lines
Quoted 4 lines
drivers/resctrl/mpam_devices.c line 37
Quoted 2 lines
drivers/resctrl/mpam_devices.c +1
-1-static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;Why expose this here? This patch makes no use of the exposed symbol.
The
mpam_resctrlcode needs to take it when it walks these lists. I don't want to change it then because its just additional churn.
I guess this is harmless, but it's no help to the kernel, or to reviewers...
[...]
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
drivers/resctrl/mpam_devices.c +2
-0+/* +* An MSC is a physical container for controls and monitors, each identified by
[...]
Quoted 9 lines
Quoted 7 lines
Quoted 3 lines
+ * The same MSC may exist under different
class->component->vmscpaths, but the
+ * RIS index will be unique.
+ */This description of the structures and how they relate to each other seems OK (bearing in mind that I am already familiar with this stuff -- I can't speak for other people).
Great!
OK
[...]
Quoted 21 lines
Quoted 9 lines
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock);Quoted 8 lines
drivers/resctrl/mpam_devices.c line 264
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+ +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity);This is not the inverse of the cpumask_or()s in
mpam_ris_create_locked(), unless the the ris associated with each class and each component have strictly disjoint affinity masks. Is that checked anywhere, or should it be impossible by construction?They should be disjoint. These bitmaps are built from firmware description of the cache hierarchy. I don't think its possible to describe a situation where there are overlaps.
Quoted 6 lines
You can build a nonsense cache hierarchy, e.g. where CPU-0's L3 is CPU-6's L2, but if you do the scheduler is going to complain when it tries to chose the scheduler domains. I think this should be filed under "you've got bigger problems". There is a check that catches this in
mpam_resctrl_pick_caches(), to see that all the CPUs are accounted for, which is to avoid tasks that get lucky with task-placement managing to escape their resource limit.
I guess that makes sense.
If the firmware description is formally a tree structure then it should be impossible to end up with overlapping affinity masks.
Since this doesn't bite us until teardown-time in any case, I think this probably doesn't need to be checked explicitly, unless we observe actual problems.
A comment documenting this assumption may be worth having.
Quoted 22 lines
Quoted 9 lines
But, thinking about it:
I wonder why we ever really need to do the teardown. If we get an error interrupt then we can just go into a sulk, spam dmesg a bit, put the hardware into the most vanilla state that we can, and refuse to manipulate it further. But this only happens in the case of a software or hardware *bug* (or, in a future world where we might implement virtualisation, an uncontainable MPAM error triggered by a guest -- for which tearing down the host MPAM would be an overreaction).
The good news is guests can't escape the PARTID virtualisation that the CPU does, so any mess a guest manages to make is confined to that guest's PARTID range.
Quoted 7 lines
Trying to cleanly tear the MPAM driver down after such an error seems a bit futile.
The MPAM resctrl glue could eventually be made into a module (though not needed from day 1) -- which would allow for unloading resctrlfs if that is eventually module-ised. I think this wouldn't require the MPAM devices backend to be torn down at any point, though (?)
Quoted 5 lines
It would certainly be optional.
kernfs->resctrl->mpamis the reason all this has to be built-in. If that changes I'd aim for this to be a module.All this free()ing was added so that the driver doesn't end up sitting on memory when it isn't providing any usable feature. I have seen a platform where the error interrupt goes
I guess that's reasonable, but this is only applies to hardware that has MPAM but where it is either broken, or where it is unsuitable for running Linux but Linux has been deployed on it anyway while still leaving the ACPI tables intact. This does not violate any specification, but it seems of marginal benefit to introduce a load of complexity just to safe a few K in this situation. (Or do we get stuck, unable to free the config and mbwu_state arrays? Those don't count as large on a server-class system, but they are about the "a few K" magnitude.)
(Not that I'm not saying that teardown is something we shouldn't do -- rather, my point is: do we really need to do it now if it is subtle and complex to make it work, or can this be a later addition?)
Quoted 6 lines
off during boot, (I suspect firmware configures an out-of-range PARTID). On such a platform any memory that isn't free()d is a waste.
But I agree its a small amount of memory.
Quoted 6 lines
Quoted 3 lines
If we can simplify or eliminate the teardown, does it simplify the locking at all? The garbage collection logic can also be dispensed with if there is never any garbage.
It wouldn't simplify the locking, only remove that deferred free()ing which is needed because of SRCU.
My point was that there is no need to defend against concurrent removal if list entries if list entries are never removed.
Quoted 8 lines
Quoted 3 lines
Since MSCs etc. never disappear from the hardware, it feels like it ought not to be necessary ever to remove items from any of these lists except when trying to do a teardown (?)
Unbinding the driver from an MSC is another case where this may be triggered via
mpam_msc_drv_remove(). If you look at the whole thing,mpam_ris_destroy()pokesmpam_resctrl_teardown_class()to see if resctrl needs to be torn down.
Quoted 8 lines
I don't anticipate folk actually needing to do that. One Reasons is for VFIO - but this kind of stuff has a performance impact on the hypervisor, so its unlikely to ever allow a guest direct access to this kind of thing. Another reason is to load a more specific driver, which sounds unlikely.
Ultimately this memory free-ing code is here because its the right thing to do. I'd prefer to keep it as making this a loadable module would mean we have to do this.
I don't disagree with that: it is messy to retrofit teardown if it was never considered in the initial design.
I guess that this all comes from my uncertainty about the object lifecycles and locking behaviour.
I would still prefer to see this documented. If the the documentation would be too unwieldy or infrasible to write, this would suggest that the code would benefit from simplification...
For the probe phase, or for teardown, I'm really not sure why it would break anything to have a single Big MPAM Lock (however inelegant).
For the run phase (when resctrl and other clients of the driver are able to use the driver), the discovered system properties and the mappings onto resctrl resources are all static, and we don't seem to need all this RCU stuff.
Quoted 24 lines
Quoted 24 lines
(Putting the hardware into a quiecent state is not the same thing as tearing down the data structures -- we do want to quiesce MPAM when shutting down the kernel, as least for the kexec scenario.)
[...]
Quoted 4 lines
drivers/resctrl/mpam_devices.c +4
-0+static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id, +int component_id,gfp_t gfp) +{drivers/resctrl/mpam_devices.c line 456
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; +. +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ;Is it impossible by construction to get in here with an out-of-range
ris_idx?
Quoted 6 lines
Quoted 3 lines
To avoid the callers (i.e., ACPI) needing to understand the internal limitations of this code, maybe it is worth having a check here (even if technically redundant).
It's possible - but only if you mess up the firmware tables. I'll add a check for this as its easy enough.
OK, suits me.
Cheers
---Dave
James Morse
maintainerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi Dave,
Quoted 19 lines · Dave Martin
Quoted 18 lines · James Morse
Quoted 16 lines · Dave Martin
Quoted 7 lines
Subject:
arm_mpam: Add the class and component structures for ris firmware describeddrivers/resctrl/mpam_devices.c +0
-0@@ -20,7 +20,6 @@[...]
Quoted 6 lines
drivers/resctrl/mpam_devices.c +1
-1@@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
Why expose this here? This patch makes no use of the exposed symbol.
The
mpam_resctrlcode needs to take it when it walks these lists. I don't want to change it then because its just additional churn.I guess this is harmless, but it's no help to the kernel, or to reviewers...
A trade-off has to be made here. The series is too big to post in one go. driver/resctrl is the obvious split - but until both arrive then there is no need for mpam_internal.h, or really any of the driver as it doesn't have a user-space interface.
I can barf the other series on the list as an illustration - but I think that would just frustrate people.
[...]
Quoted 30 lines
Quoted 21 lines
Quoted 9 lines
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock);Quoted 8 lines
drivers/resctrl/mpam_devices.c line 264
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+ +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity);This is not the inverse of the cpumask_or()s in
mpam_ris_create_locked(), unless the the ris associated with each class and each component have strictly disjoint affinity masks. Is that checked anywhere, or should it be impossible by construction?They should be disjoint. These bitmaps are built from firmware description of the cache hierarchy. I don't think its possible to describe a situation where there are overlaps.
Quoted 6 lines
You can build a nonsense cache hierarchy, e.g. where CPU-0's L3 is CPU-6's L2, but if you do the scheduler is going to complain when it tries to chose the scheduler domains. I think this should be filed under "you've got bigger problems". There is a check that catches this in
mpam_resctrl_pick_caches(), to see that all the CPUs are accounted for, which is to avoid tasks that get lucky with task-placement managing to escape their resource limit.I guess that makes sense.
Quoted 8 lines
If the firmware description is formally a tree structure then it should be impossible to end up with overlapping affinity masks.
Since this doesn't bite us until teardown-time in any case, I think this probably doesn't need to be checked explicitly, unless we observe actual problems.
A comment documenting this assumption may be worth having.
Sure,
Quoted 38 lines
Quoted 22 lines
Quoted 9 lines
But, thinking about it:
I wonder why we ever really need to do the teardown. If we get an error interrupt then we can just go into a sulk, spam dmesg a bit, put the hardware into the most vanilla state that we can, and refuse to manipulate it further. But this only happens in the case of a software or hardware *bug* (or, in a future world where we might implement virtualisation, an uncontainable MPAM error triggered by a guest -- for which tearing down the host MPAM would be an overreaction).
The good news is guests can't escape the PARTID virtualisation that the CPU does, so any mess a guest manages to make is confined to that guest's PARTID range.
Quoted 7 lines
Trying to cleanly tear the MPAM driver down after such an error seems a bit futile.
The MPAM resctrl glue could eventually be made into a module (though not needed from day 1) -- which would allow for unloading resctrlfs if that is eventually module-ised. I think this wouldn't require the MPAM devices backend to be torn down at any point, though (?)
Quoted 5 lines
It would certainly be optional.
kernfs->resctrl->mpamis the reason all this has to be built-in. If that changes I'd aim for this to be a module.All this free()ing was added so that the driver doesn't end up sitting on memory when it isn't providing any usable feature. I have seen a platform where the error interrupt goes
I guess that's reasonable, but this is only applies to hardware that has MPAM but where it is either broken, or where it is unsuitable for running Linux but Linux has been deployed on it anyway while still leaving the ACPI tables intact. This does not violate any specification, but it seems of marginal benefit to introduce a load of complexity just to safe a few K in this situation. (Or do we get stuck, unable to free the config and
mbwu_statearrays? Those don't count as large on a server-class system, but they are about the "a few K" magnitude.)
Quoted 3 lines
(Not that I'm not saying that teardown is something we shouldn't do -- rather, my point is: do we really need to do it now if it is subtle and complex to make it work, or can this be a later addition?)
Equally, can't someone say this memory has been leaked once the MPAM driver has given up. As alloc/free were done together it seems to odd to do them at separate times - that will certainly make it more subtle.
Quoted 10 lines
Quoted 10 lines
off during boot, (I suspect firmware configures an out-of-range PARTID). On such a platform any memory that isn't free()d is a waste.
But I agree its a small amount of memory.
Quoted 3 lines
If we can simplify or eliminate the teardown, does it simplify the locking at all? The garbage collection logic can also be dispensed with if there is never any garbage.
Quoted 5 lines
Quoted 2 lines
It wouldn't simplify the locking, only remove that deferred free()ing which is needed because of SRCU.
My point was that there is no need to defend against concurrent removal if list entries if list entries are never removed.
You can eyeball the writers are recognise the pattern as srcu. If it's an "oh that list is read only" - then its much more of a driver specific hack.
I'd prefer to keep close to the srcu pattern - even if it is a bit complex.
Quoted 20 lines
Quoted 8 lines
Quoted 3 lines
Since MSCs etc. never disappear from the hardware, it feels like it ought not to be necessary ever to remove items from any of these lists except when trying to do a teardown (?)
Unbinding the driver from an MSC is another case where this may be triggered via
mpam_msc_drv_remove(). If you look at the whole thing,mpam_ris_destroy()pokesmpam_resctrl_teardown_class()to see if resctrl needs to be torn down.Quoted 8 lines
I don't anticipate folk actually needing to do that. One Reasons is for VFIO - but this kind of stuff has a performance impact on the hypervisor, so its unlikely to ever allow a guest direct access to this kind of thing. Another reason is to load a more specific driver, which sounds unlikely.
Ultimately this memory free-ing code is here because its the right thing to do. I'd prefer to keep it as making this a loadable module would mean we have to do this.
I don't disagree with that: it is messy to retrofit teardown if it was never considered in the initial design.
Quoted 6 lines
I guess that this all comes from my uncertainty about the object lifecycles and locking behaviour.
I would still prefer to see this documented. If the the documentation would be too unwieldy or infrasible to write, this would suggest that the code would benefit from simplification...
Right - nothing describes the 'phases' the driver has, they just emerge. I'll try and add that, but it won't be in time for v2.
Quoted 2 lines
For the probe phase, or for teardown, I'm really not sure why it would break anything to have a single Big MPAM Lock (however inelegant).
That is broadly what mpam_list_lock is doing before the cpuhp calls are registered.
Quoted 4 lines
For the run phase (when resctrl and other clients of the driver are able to use the driver), the discovered system properties and the mappings onto resctrl resources are all static, and we don't seem to need all this RCU stuff.
Iff we say "driver specific hack - read only list" - I think that is worse. Making it srcu makes it recognisable, and lets us free the memory instead of leaking it.
Thanks,
James
James Morse
maintainerPATCH 12/33 arm_mpam: Add the class and component structures for ris firmware described
In reply to James MorseAn MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct mpam_components are a set of struct mpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outside mpam_devices.c
struct mpam_vmsc are then a set of struct mpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.
Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
---
Changes since RFC:
* removed a pr_err() debug message that crept in.
--- drivers/resctrl/mpam_devices.c | 488 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 91 ++++++ include/linux/arm_mpam.h | 8 +- 3 files changed, 574 insertions(+), 13 deletions(-)
drivers/resctrl/mpam_devices.c +481 -7
@@ -20,7 +20,6 @@#include <linux/printk.h> #include <linux/slab.h> #include <linux/spinlock.h> -#include <linux/srcu.h> #include <linux/types.h> #include <acpi/pcc.h>
@@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +/* +* An MSC is a physical container for controls and monitors, each identified by +* their RIS index. These share a base-address, interrupts and some MMIO +* registers. A vMSC is a virtual container for RIS in an MSC that control or +* monitor the same thing. Members of a vMSC are all RIS in the same MSC, but +* not all RIS in an MSC share a vMSC. +* Components are a group of vMSC that control or monitor the same thing but +* are from different MSC, so have different base-address, interrupts etc. +* Classes are the set components of the same type. +* +* The features of a vMSC is the union of the RIS it contains. +* The features of a Class and Component are the common subset of the vMSC +* they contain. +* +* e.g. The system cache may have bandwidth controls on multiple interfaces, +* for regulating traffic from devices independently of traffic from CPUs. +* If these are two RIS in one MSC, they will be treated as controlling +* different things, and will not share a vMSC/component/class. +* +* e.g. The L2 may have one MSC and two RIS, one for cache-controls another +* for bandwidth. These two RIS are members of the same vMSC. +* +* e.g. The set of RIS that make up the L2 are grouped as a component. These +* are sometimes termed slices. They should be configured the same, as if there +* were only one. +* +* e.g. The SoC probably has more than one L2, each attached to a distinct set +* of CPUs. All the L2 components are grouped as a class. +* +* When creating an MSC, struct mpam_msc is added to the all mpam_all_msc list, +* then linked via struct mpam_ris to a vmsc, component and class. +* The same MSC may exist under different class->component->vmsc paths, but the +* RIS index will be unique. +*/ +LIST_HEAD (mpam_classes); + +/* List of all objects that can be free()d after synchronise_srcu() */ +static LLIST_HEAD (mpam_garbage); + +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) + +static struct mpam_vmsc * +mpam_vmsc_alloc (struct mpam_component *comp,struct mpam_msc *msc,gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + + vmsc =kzalloc (sizeof (*vmsc), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (vmsc); + +INIT_LIST_HEAD_RCU (&vmsc->ris); +INIT_LIST_HEAD_RCU (&vmsc->comp_list); + vmsc->comp = comp; + vmsc->msc = msc; + +list_add_rcu (&vmsc->comp_list, &comp->vmsc); + +return vmsc; +} + +static struct mpam_vmsc *mpam_vmsc_get (struct mpam_component *comp, +struct mpam_msc *msc,bool alloc, +gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +if (vmsc->msc->id == msc->id) +return vmsc; + } + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_vmsc_alloc (comp, msc, gfp); +} + +static struct mpam_component * +mpam_component_alloc (struct mpam_class *class,int id,gfp_t gfp) +{ +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + + comp =kzalloc (sizeof (*comp), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (comp); + + comp->comp_id = id; +INIT_LIST_HEAD_RCU (&comp->vmsc); +/* affinity is updated when ris are added */ +INIT_LIST_HEAD_RCU (&comp->class_list); + comp->class = class; + +list_add_rcu (&comp->class_list, &class->components); + +return comp; +} + +static struct mpam_component * +mpam_component_get (struct mpam_class *class,int id,bool alloc,gfp_t gfp) +{ +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (comp, &class->components, class_list) { +if (comp->comp_id == id) +return comp; + } + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_component_alloc (class, id, gfp); +} + +static struct mpam_class * +mpam_class_alloc (u8 level_idx,enum mpam_class_types type,gfp_t gfp) +{ +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + + class =kzalloc (sizeof (*class), gfp); +if (!class) +return ERR_PTR (-ENOMEM ); +init_garbage (class); + +INIT_LIST_HEAD_RCU (&class->components); +/* affinity is updated when ris are added */ + class->level = level_idx; + class->type = type; +INIT_LIST_HEAD_RCU (&class->classes_list); + +list_add_rcu (&class->classes_list, &mpam_classes); + +return class; +} + +static struct mpam_class * +mpam_class_get (u8 level_idx,enum mpam_class_types type,bool alloc,gfp_t gfp) +{ +bool found = false; +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (class, &mpam_classes, classes_list) { +if (class->type == type && class->level == level_idx) { + found = true; +break ; + } + } + +if (found) +return class; + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_class_alloc (level_idx, type, gfp); +} + +#define add_to_garbage (x) \ +do { \ + __typeof__(x) _x = x; \ + (_x)->garbage.to_free = (_x); \ + llist_add(&(_x)->garbage.llist, &mpam_garbage); \ +} while (0) + +static void mpam_class_destroy (struct mpam_class *class) +{ +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&class->classes_list); +add_to_garbage (class); +} + +static void mpam_comp_destroy (struct mpam_component *comp) +{ +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&comp->class_list); +add_to_garbage (comp); + +if (list_empty (&class->components)) +mpam_class_destroy (class); +} + +static void mpam_vmsc_destroy (struct mpam_vmsc *vmsc) +{ +struct mpam_component *comp = vmsc->comp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&vmsc->comp_list); +add_to_garbage (vmsc); + +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +} + +static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity); +clear_bit (ris->ris_idx, msc->ris_idxs); +list_del_rcu (&ris->vmsc_list); +list_del_rcu (&ris->msc_list); +add_to_garbage (ris); + ris->garbage.pdev = pdev; + +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +} + +/* +* There are two ways of reaching a struct mpam_msc_ris. Via the +* class->component->vmsc->ris, or via the msc. +* When destroying the msc, the other side needs unlinking and cleaning up too. +*/ +static void mpam_msc_destroy (struct mpam_msc *msc) +{ +struct platform_device *pdev = msc->pdev; +struct mpam_msc_ris *ris, *tmp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&msc->glbl_list); +platform_set_drvdata (pdev,NULL ); + +list_for_each_entry_safe (ris, tmp, &msc->ris, msc_list) +mpam_ris_destroy (ris); + +add_to_garbage (msc); + msc->garbage.pdev = pdev; +} + +static void mpam_free_garbage (void ) +{ +struct mpam_garbage *iter, *tmp; +struct llist_node *to_free =llist_del_all (&mpam_garbage); + +if (!to_free) +return ; + +synchronize_srcu (&mpam_srcu); + +llist_for_each_entry_safe (iter, tmp, to_free, llist) { +if (iter->pdev) +devm_kfree (&iter->pdev->dev, iter->to_free); +else +kfree (iter->to_free); + } +} + +/* Called recursively to walk the list of caches from a particular CPU */ +static void __mpam_get_cpumask_from_cache_id (int cpu,struct device_node *cache_node, +unsigned long cache_id, +u32 cache_level, +cpumask_t *affinity) +{ +int err; +u32 iter_level; +unsigned long iter_cache_id; + struct device_node *iter_node __free(device_node) = of_find_next_cache_node(cache_node); + +if (!iter_node) +return ; + + err =of_property_read_u32 (iter_node,"cache-level" , &iter_level); +if (err) +return ; + +/* +* get_cpu_cacheinfo_id() isn't ready until sometime +* during device_initcall(). Use cache_of_calculate_id(). +*/ + iter_cache_id =cache_of_calculate_id (iter_node); +if (cache_id == ~0UL ) +return ; + +if (iter_level == cache_level && iter_cache_id == cache_id) +cpumask_set_cpu (cpu, affinity); + +__mpam_get_cpumask_from_cache_id (cpu, iter_node, cache_id, cache_level, + affinity); +} + +/* +* The cacheinfo structures are only populated when CPUs are online. +* This helper walks the device tree to include offline CPUs too. +*/ +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level, +cpumask_t *affinity) +{ +int cpu; + +if (!acpi_disabled) +return acpi_pptt_get_cpumask_from_cache_id (cache_id, affinity); + +for_each_possible_cpu (cpu) { + struct device_node *cpu_node __free(device_node) = of_get_cpu_node(cpu, NULL); +if (!cpu_node) { +pr_err ("Failed to find cpu%d device node\n" , cpu); +return -ENOENT ; + } + +__mpam_get_cpumask_from_cache_id (cpu, cpu_node, cache_id, + cache_level, affinity); +continue ; + } + +return 0 ; +} + +/* +* cpumask_of_node() only knows about online CPUs. This can't tell us whether +* a class is represented on all possible CPUs. +*/ +static void get_cpumask_from_node_id (u32 node_id,cpumask_t *affinity) +{ +int cpu; + +for_each_possible_cpu (cpu) { +if (node_id ==cpu_to_node (cpu)) +cpumask_set_cpu (cpu, affinity); + } +} + +static int get_cpumask_from_cache (struct device_node *cache, +cpumask_t *affinity) +{ +int err; +u32 cache_level; +unsigned long cache_id; + + err =of_property_read_u32 (cache,"cache-level" , &cache_level); +if (err) { +pr_err ("Failed to read cache-level from cache node\n" ); +return -ENOENT ; + } + + cache_id =cache_of_calculate_id (cache); +if (cache_id == ~0UL ) { +pr_err ("Failed to calculate cache-id from cache node\n" ); +return -ENOENT ; + } + +return mpam_get_cpumask_from_cache_id (cache_id, cache_level, affinity); +} + +static int mpam_ris_get_affinity (struct mpam_msc *msc,cpumask_t *affinity, +enum mpam_class_types type, +struct mpam_class *class, +struct mpam_component *comp) +{ +int err; + +switch (type) { +case MPAM_CLASS_CACHE : + err =mpam_get_cpumask_from_cache_id (comp->comp_id, class->level, + affinity); +if (err) +return err; + +if (cpumask_empty (affinity)) +pr_warn_once ("%s no CPUs associated with cache node" , +dev_name (&msc->pdev->dev)); + +break ; +case MPAM_CLASS_MEMORY : +get_cpumask_from_node_id (comp->comp_id, affinity); +/* affinity may be empty for CPU-less memory nodes */ +break ; +case MPAM_CLASS_UNKNOWN : +return 0 ; + } + +cpumask_and (affinity, affinity, &msc->accessibility); + +return 0 ; +} + +static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id, +int component_id,gfp_t gfp) +{ +int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ; + + ris =devm_kzalloc (&msc->pdev->dev,sizeof (*ris), gfp); +if (!ris) +return -ENOMEM ; +init_garbage (ris); + + class =mpam_class_get (class_id, type, true, gfp); +if (IS_ERR (class)) +return PTR_ERR (class); + + comp =mpam_component_get (class, component_id, true, gfp); +if (IS_ERR (comp)) { +if (list_empty (&class->components)) +mpam_class_destroy (class); +return PTR_ERR (comp); + } + + vmsc =mpam_vmsc_get (comp, msc, true, gfp); +if (IS_ERR (vmsc)) { +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +return PTR_ERR (vmsc); + } + + err =mpam_ris_get_affinity (msc, &ris->affinity, type, class, comp); +if (err) { +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +return err; + } + + ris->ris_idx = ris_idx; +INIT_LIST_HEAD_RCU (&ris->vmsc_list); + ris->vmsc = vmsc; + +cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_or (&class->affinity, &class->affinity, &ris->affinity); +list_add_rcu (&ris->vmsc_list, &vmsc->ris); + +return 0 ; +} + +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id,int component_id) +{ +int err; + +mutex_lock (&mpam_list_lock); + err =mpam_ris_create_locked (msc, ris_idx, type, class_id, + component_id,GFP_KERNEL ); +mutex_unlock (&mpam_list_lock); +if (err) +mpam_free_garbage (); + +return err; +} +static void mpam_discovery_complete (void ) {pr_err ("Discovered all MSC\n" );
@@ -179,7 +650,10 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { -if (of_device_is_compatible (parent,"memory" )) { +if (of_device_is_compatible (parent,"cache" )) { + err =get_cpumask_from_cache (parent, + &msc->accessibility); + }else if (of_device_is_compatible (parent,"memory" )) {cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else {
@@ -209,11 +683,10 @@ static void mpam_msc_drv_remove(struct platform_device *pdev)mutex_lock (&mpam_list_lock); mpam_num_msc--; -platform_set_drvdata (pdev,NULL ); -list_del_rcu (&msc->glbl_list); -synchronize_srcu (&mpam_srcu); -devm_kfree (&pdev->dev, msc); +mpam_msc_destroy (msc);mutex_unlock (&mpam_list_lock); + +mpam_free_garbage (); }static int mpam_msc_drv_probe (struct platform_device *pdev)
@@ -230,6 +703,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) err = -ENOMEM ;break ; } +init_garbage (msc);mutex_init (&msc->probe_lock);mutex_init (&msc->part_sel_lock);
drivers/resctrl/mpam_internal.h +91 -0
107 lines not on this page · raw message
include/linux/arm_mpam.h +2 -6
@@ -36,11 +36,7 @@ static inline int acpi_mpam_parse_resources(struct mpam_msc *msc,static inline int acpi_mpam_count_msc (void ) {return -EINVAL ; }#endif -static inline int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, -enum mpam_class_types type,u8 class_id, -int component_id) -{ -return -EINVAL ; -} +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id,int component_id);#endif /* __LINUX_ARM_MPAM_H */
Signature · 1 line
2.20.1
Ben Horgan
maintainerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi James,
Quoted 534 lines · James Morse
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
CC Ben Horgan <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* removed apr_err()debug message that crept in.--- drivers/resctrl/mpam_devices.c | 488 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 91 ++++++ include/linux/arm_mpam.h | 8 +- 3 files changed, 574 insertions(+), 13 deletions(-)drivers/resctrl/mpam_devices.c +473
-2@@ -20,7 +20,6 @@#include <linux/printk.h> #include <linux/slab.h> #include <linux/spinlock.h> -#include <linux/srcu.h> #include <linux/types.h> #include <acpi/pcc.h> @@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +/* +* An MSC is a physical container for controls and monitors, each identified by +* their RIS index. These share a base-address, interrupts and some MMIO +* registers. A vMSC is a virtual container for RIS in an MSC that control or +* monitor the same thing. Members of a vMSC are all RIS in the same MSC, but +* not all RIS in an MSC share a vMSC. +* Components are a group of vMSC that control or monitor the same thing but +* are from different MSC, so have different base-address, interrupts etc. +* Classes are the set components of the same type. +* +* The features of a vMSC is the union of the RIS it contains. +* The features of a Class and Component are the common subset of the vMSC +* they contain. +* +* e.g. The system cache may have bandwidth controls on multiple interfaces, +* for regulating traffic from devices independently of traffic from CPUs. +* If these are two RIS in one MSC, they will be treated as controlling +* different things, and will not share a vMSC/component/class. +* +* e.g. The L2 may have one MSC and two RIS, one for cache-controls another +* for bandwidth. These two RIS are members of the same vMSC. +* +* e.g. The set of RIS that make up the L2 are grouped as a component. These +* are sometimes termed slices. They should be configured the same, as if there +* were only one. +* +* e.g. The SoC probably has more than one L2, each attached to a distinct set +* of CPUs. All the L2 components are grouped as a class. +* +* When creating an MSC, struct mpam_msc is added to the all mpam_all_msc list, +* then linked via struct mpam_ris to a vmsc, component and class. +* The same MSC may exist under different class->component->vmsc paths, but the +* RIS index will be unique. +*/ +LIST_HEAD (mpam_classes); + +/* List of all objects that can be free()d after synchronise_srcu() */ +static LLIST_HEAD (mpam_garbage); + +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) + +static struct mpam_vmsc * +mpam_vmsc_alloc (struct mpam_component *comp,struct mpam_msc *msc,gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + + vmsc =kzalloc (sizeof (*vmsc), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (vmsc); + +INIT_LIST_HEAD_RCU (&vmsc->ris); +INIT_LIST_HEAD_RCU (&vmsc->comp_list); + vmsc->comp = comp; + vmsc->msc = msc; + +list_add_rcu (&vmsc->comp_list, &comp->vmsc); + +return vmsc; +} + +static struct mpam_vmsc *mpam_vmsc_get (struct mpam_component *comp, +struct mpam_msc *msc,bool alloc, +gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +if (vmsc->msc->id == msc->id) +return vmsc; + } + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_vmsc_alloc (comp, msc, gfp); +} + +static struct mpam_component * +mpam_component_alloc (struct mpam_class *class,int id,gfp_t gfp) +{ +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + + comp =kzalloc (sizeof (*comp), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (comp); + + comp->comp_id = id; +INIT_LIST_HEAD_RCU (&comp->vmsc); +/* affinity is updated when ris are added */ +INIT_LIST_HEAD_RCU (&comp->class_list); + comp->class = class; + +list_add_rcu (&comp->class_list, &class->components); + +return comp; +} + +static struct mpam_component * +mpam_component_get (struct mpam_class *class,int id,bool alloc,gfp_t gfp) +{ +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (comp, &class->components, class_list) { +if (comp->comp_id == id) +return comp; + } + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_component_alloc (class, id, gfp); +} + +static struct mpam_class * +mpam_class_alloc (u8 level_idx,enum mpam_class_types type,gfp_t gfp) +{ +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + + class =kzalloc (sizeof (*class), gfp); +if (!class) +return ERR_PTR (-ENOMEM ); +init_garbage (class); + +INIT_LIST_HEAD_RCU (&class->components); +/* affinity is updated when ris are added */ + class->level = level_idx; + class->type = type; +INIT_LIST_HEAD_RCU (&class->classes_list); + +list_add_rcu (&class->classes_list, &mpam_classes); + +return class; +} + +static struct mpam_class * +mpam_class_get (u8 level_idx,enum mpam_class_types type,bool alloc,gfp_t gfp) +{ +bool found = false; +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (class, &mpam_classes, classes_list) { +if (class->type == type && class->level == level_idx) { + found = true; +break ; + } + } + +if (found) +return class; + +if (!alloc) +return ERR_PTR (-ENOENT ); + +return mpam_class_alloc (level_idx, type, gfp); +} + +#define add_to_garbage (x) \ +do { \ + __typeof__(x) _x = x; \ + (_x)->garbage.to_free = (_x); \ + llist_add(&(_x)->garbage.llist, &mpam_garbage); \ +} while (0) + +static void mpam_class_destroy (struct mpam_class *class) +{ +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&class->classes_list); +add_to_garbage (class); +} + +static void mpam_comp_destroy (struct mpam_component *comp) +{ +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&comp->class_list); +add_to_garbage (comp); + +if (list_empty (&class->components)) +mpam_class_destroy (class); +} + +static void mpam_vmsc_destroy (struct mpam_vmsc *vmsc) +{ +struct mpam_component *comp = vmsc->comp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&vmsc->comp_list); +add_to_garbage (vmsc); + +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +} + +static void mpam_ris_destroy (struct mpam_msc_ris *ris) +{ +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity); +clear_bit (ris->ris_idx, msc->ris_idxs); +list_del_rcu (&ris->vmsc_list); +list_del_rcu (&ris->msc_list); +add_to_garbage (ris); + ris->garbage.pdev = pdev; + +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +} + +/* +* There are two ways of reaching a struct mpam_msc_ris. Via the +* class->component->vmsc->ris, or via the msc. +* When destroying the msc, the other side needs unlinking and cleaning up too. +*/ +static void mpam_msc_destroy (struct mpam_msc *msc) +{ +struct platform_device *pdev = msc->pdev; +struct mpam_msc_ris *ris, *tmp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&msc->glbl_list); +platform_set_drvdata (pdev,NULL ); + +list_for_each_entry_safe (ris, tmp, &msc->ris, msc_list) +mpam_ris_destroy (ris); + +add_to_garbage (msc); + msc->garbage.pdev = pdev; +} + +static void mpam_free_garbage (void ) +{ +struct mpam_garbage *iter, *tmp; +struct llist_node *to_free =llist_del_all (&mpam_garbage); + +if (!to_free) +return ; + +synchronize_srcu (&mpam_srcu); + +llist_for_each_entry_safe (iter, tmp, to_free, llist) { +if (iter->pdev) +devm_kfree (&iter->pdev->dev, iter->to_free); +else +kfree (iter->to_free); + } +} + +/* Called recursively to walk the list of caches from a particular CPU */ +static void __mpam_get_cpumask_from_cache_id (int cpu,struct device_node *cache_node, +unsigned long cache_id, +u32 cache_level, +cpumask_t *affinity) +{ +int err; +u32 iter_level; +unsigned long iter_cache_id; + struct device_node *iter_node __free(device_node) = of_find_next_cache_node(cache_node); + +if (!iter_node) +return ; + + err =of_property_read_u32 (iter_node,"cache-level" , &iter_level); +if (err) +return ; + +/* +* get_cpu_cacheinfo_id() isn't ready until sometime +* during device_initcall(). Use cache_of_calculate_id(). +*/ + iter_cache_id =cache_of_calculate_id (iter_node); +if (cache_id == ~0UL ) +return ; + +if (iter_level == cache_level && iter_cache_id == cache_id) +cpumask_set_cpu (cpu, affinity); + +__mpam_get_cpumask_from_cache_id (cpu, iter_node, cache_id, cache_level, + affinity); +} + +/* +* The cacheinfo structures are only populated when CPUs are online. +* This helper walks the device tree to include offline CPUs too. +*/ +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level, +cpumask_t *affinity) +{ +int cpu; + +if (!acpi_disabled) +return acpi_pptt_get_cpumask_from_cache_id (cache_id, affinity); + +for_each_possible_cpu (cpu) { + struct device_node *cpu_node __free(device_node) = of_get_cpu_node(cpu, NULL); +if (!cpu_node) { +pr_err ("Failed to find cpu%d device node\n" , cpu); +return -ENOENT ; + } + +__mpam_get_cpumask_from_cache_id (cpu, cpu_node, cache_id, + cache_level, affinity); +continue ; + } + +return 0 ; +} + +/* +* cpumask_of_node() only knows about online CPUs. This can't tell us whether +* a class is represented on all possible CPUs. +*/ +static void get_cpumask_from_node_id (u32 node_id,cpumask_t *affinity) +{ +int cpu; + +for_each_possible_cpu (cpu) { +if (node_id ==cpu_to_node (cpu)) +cpumask_set_cpu (cpu, affinity); + } +} + +static int get_cpumask_from_cache (struct device_node *cache, +cpumask_t *affinity) +{ +int err; +u32 cache_level; +unsigned long cache_id; + + err =of_property_read_u32 (cache,"cache-level" , &cache_level); +if (err) { +pr_err ("Failed to read cache-level from cache node\n" ); +return -ENOENT ; + } + + cache_id =cache_of_calculate_id (cache); +if (cache_id == ~0UL ) { +pr_err ("Failed to calculate cache-id from cache node\n" ); +return -ENOENT ; + } + +return mpam_get_cpumask_from_cache_id (cache_id, cache_level, affinity); +} + +static int mpam_ris_get_affinity (struct mpam_msc *msc,cpumask_t *affinity, +enum mpam_class_types type, +struct mpam_class *class, +struct mpam_component *comp) +{ +int err; + +switch (type) { +case MPAM_CLASS_CACHE : + err =mpam_get_cpumask_from_cache_id (comp->comp_id, class->level, + affinity); +if (err) +return err; + +if (cpumask_empty (affinity)) +pr_warn_once ("%s no CPUs associated with cache node" , +dev_name (&msc->pdev->dev)); + +break ; +case MPAM_CLASS_MEMORY : +get_cpumask_from_node_id (comp->comp_id, affinity); +/* affinity may be empty for CPU-less memory nodes */ +break ; +case MPAM_CLASS_UNKNOWN : +return 0 ; + } + +cpumask_and (affinity, affinity, &msc->accessibility); + +return 0 ; +} + +static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id, +int component_id,gfp_t gfp) +{ +int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ; + + ris =devm_kzalloc (&msc->pdev->dev,sizeof (*ris), gfp); +if (!ris) +return -ENOMEM ; +init_garbage (ris); + + class =mpam_class_get (class_id, type, true, gfp); +if (IS_ERR (class)) +return PTR_ERR (class); + + comp =mpam_component_get (class, component_id, true, gfp); +if (IS_ERR (comp)) { +if (list_empty (&class->components)) +mpam_class_destroy (class); +return PTR_ERR (comp); + } + + vmsc =mpam_vmsc_get (comp, msc, true, gfp); +if (IS_ERR (vmsc)) { +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +return PTR_ERR (vmsc); + } + + err =mpam_ris_get_affinity (msc, &ris->affinity, type, class, comp); +if (err) { +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +return err; + } + + ris->ris_idx = ris_idx; +INIT_LIST_HEAD_RCU (&ris->vmsc_list); + ris->vmsc = vmsc; + +cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_or (&class->affinity, &class->affinity, &ris->affinity); +list_add_rcu (&ris->vmsc_list, &vmsc->ris); + +return 0 ; +} + +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id,int component_id) +{ +int err; + +mutex_lock (&mpam_list_lock); + err =mpam_ris_create_locked (msc, ris_idx, type, class_id, + component_id,GFP_KERNEL ); +mutex_unlock (&mpam_list_lock); +if (err) +mpam_free_garbage (); + +return err; +} +static void mpam_discovery_complete (void ) {pr_err ("Discovered all MSC\n" );
drivers/resctrl/mpam_devices.c static int update_msc_accessibility(struct mpam_msc *msc) · line 656
Quoted 8 lines
drivers/resctrl/mpam_devices.c +4
-1@@ -179,7 +650,10 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { -if (of_device_is_compatible (parent,"memory" )) { +if (of_device_is_compatible (parent,"cache" )) { + err =get_cpumask_from_cache (parent, + &msc->accessibility); + }else if (of_device_is_compatible (parent,"memory" )) {
The determination of the accessibility for the h/w msc doesn't fit with the subject of this patch. Could this hunk and the supporting functions be split into a precursor patch?
Quoted 35 lines
drivers/resctrl/mpam_devices.c +4
-4cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else {@@ -209,11 +683,10 @@ static void mpam_msc_drv_remove(struct platform_device *pdev)mutex_lock (&mpam_list_lock); mpam_num_msc--; -platform_set_drvdata (pdev,NULL ); -list_del_rcu (&msc->glbl_list); -synchronize_srcu (&mpam_srcu); -devm_kfree (&pdev->dev, msc); +mpam_msc_destroy (msc);mutex_unlock (&mpam_list_lock); + +mpam_free_garbage (); }static int mpam_msc_drv_probe (struct platform_device *pdev)@@ -230,6 +703,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) err = -ENOMEM ;break ; } +init_garbage (msc);mutex_init (&msc->probe_lock);mutex_init (&msc->part_sel_lock);drivers/resctrl/mpam_internal.h +1
-0@@ -7,10 +7,27 @@#include <linux/arm_mpam.h> #include <linux/cpumask.h> #include <linux/io.h> +#include <linux/llist.h>
drivers/resctrl/mpam_internal.h line 20
Quoted 10 lines
drivers/resctrl/mpam_internal.h +6
-0#include <linux/mailbox_client.h> #include <linux/mutex.h> #include <linux/resctrl.h> #include <linux/sizes.h> +#include <linux/srcu.h> + +/* +* Structures protected by SRCU may not be freed for a surprising amount of +* time (especially if perf is running). To ensure the MPAM error interrupt can +* tear down all the structures, build a list of objects that can be gargbage
nit: s/gargbage/garbage/
drivers/resctrl/mpam_internal.h line 21
Quoted 1 line
drivers/resctrl/mpam_internal.h +1
-0+* collected once synchronize_srcu() has returned.> + * If pdev is
non-NULL, use devm_kfree().
Quoted 100 lines
drivers/resctrl/mpam_internal.h +82
-0+*/ +struct mpam_garbage { +/* member of mpam_garbage */ +struct llist_node llist; + +void *to_free; +struct platform_device *pdev; +};struct mpam_msc {/* member of mpam_all_msc */ @@ -57,6 +74,80 @@ struct mpam_msc {void __iomem *mapped_hwpage;size_t mapped_hwpage_sz; + +struct mpam_garbage garbage; +}; + +struct mpam_class { +/* mpam_components in this class */ +struct list_head components; + +cpumask_t affinity; + +u8 level; +enum mpam_class_types type; + +/* member of mpam_classes */ +struct list_head classes_list; + +struct mpam_garbage garbage; +}; + +struct mpam_component { +u32 comp_id; + +/* mpam_vmsc in this component */ +struct list_head vmsc; + +cpumask_t affinity; + +/* member of mpam_class:components */ +struct list_head class_list; + +/* parent: */ +struct mpam_class *class; + +struct mpam_garbage garbage; }; +struct mpam_vmsc { +/* member of mpam_component:vmsc_list */ +struct list_head comp_list; + +/* mpam_msc_ris in this vmsc */ +struct list_head ris; + +/* All RIS in this vMSC are members of this MSC */ +struct mpam_msc *msc; + +/* parent: */ +struct mpam_component *comp; + +struct mpam_garbage garbage; +}; + +struct mpam_msc_ris { +u8 ris_idx; + +cpumask_t affinity; + +/* member of mpam_vmsc:ris */ +struct list_head vmsc_list; + +/* member of mpam_msc:ris */ +struct list_head msc_list; + +/* parent: */ +struct mpam_vmsc *vmsc; + +struct mpam_garbage garbage; +}; + +/* List of all classes - protected by srcu*/ +extern struct srcu_struct mpam_srcu; +extern struct list_head mpam_classes; + +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level, +cpumask_t *affinity); +#endif /* MPAM_INTERNAL_H */ include/linux/arm_mpam.h +0
-0@@ -36,11 +36,7 @@ static inline int acpi_mpam_parse_resources(struct mpam_msc *msc,static inline int acpi_mpam_count_msc (void ) {return -EINVAL ; }#endif
include/linux/arm_mpam.h static inline int acpi_mpam_parse_resources(struct mpam_msc *msc, · line 42
Quoted 10 lines
include/linux/arm_mpam.h +2
-6-static inline int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, -enum mpam_class_types type,u8 class_id, -int component_id) -{ -return -EINVAL ; -} +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, +enum mpam_class_types type,u8 class_id,int component_id);#endif /* __LINUX_ARM_MPAM_H */
Thanks,
Ben
James Morse
maintainerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi Ben,
Quoted 35 lines · Ben Horgan
Quoted 34 lines · James Morse
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
drivers/resctrl/mpam_devices.c +0
-1@@ -179,7 +650,10 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { -if (of_device_is_compatible (parent,"memory" )) {
Quoted 8 lines
drivers/resctrl/mpam_devices.c static int update_msc_accessibility(struct mpam_msc *msc) · line 656
Quoted 4 lines
drivers/resctrl/mpam_devices.c +4
-0+if (of_device_is_compatible (parent,"cache" )) { + err =get_cpumask_from_cache (parent, + &msc->accessibility); + }else if (of_device_is_compatible (parent,"memory" )) {The determination of the accessibility for the h/w msc doesn't fit with the subject of this patch. Could this hunk and the supporting functions be split into a precursor patch?
I've moved this bit into the previous patches.
Thanks,
James
RE: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
In reply to James MorseHello James,
Quoted 142 lines
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
CC Ben Horgan <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* removed apr_err()debug message that crept in.--- drivers/resctrl/mpam_devices.c | 488 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 91 ++++++ include/linux/arm_mpam.h | 8 +- 3 files changed, 574 insertions(+), 13 deletions(-)drivers/resctrl/mpam_devices.c +82
-2@@ -20,7 +20,6 @@#include <linux/printk.h> #include <linux/slab.h> #include <linux/spinlock.h> -#include <linux/srcu.h> #include <linux/types.h> #include <acpi/pcc.h> @@ -35,11 +34,483 @@static DEFINE_MUTEX (mpam_list_lock);static LIST_HEAD (mpam_all_msc); -static struct srcu_struct mpam_srcu; +struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +/* +* An MSC is a physical container for controls and monitors, each +identified by +* their RIS index. These share a base-address, interrupts and some +MMIO +* registers. A vMSC is a virtual container for RIS in an MSC that +control or +* monitor the same thing. Members of a vMSC are all RIS in the same +MSC, but +* not all RIS in an MSC share a vMSC. +* Components are a group of vMSC that control or monitor the same +thing but +* are from different MSC, so have different base-address, interrupts etc. +* Classes are the set components of the same type. +* +* The features of a vMSC is the union of the RIS it contains. +* The features of a Class and Component are the common subset of the +vMSC +* they contain. +* +* e.g. The system cache may have bandwidth controls on multiple +interfaces, +* for regulating traffic from devices independently of traffic from CPUs. +* If these are two RIS in one MSC, they will be treated as controlling +* different things, and will not share a vMSC/component/class. +* +* e.g. The L2 may have one MSC and two RIS, one for cache-controls +another +* for bandwidth. These two RIS are members of the same vMSC. +* +* e.g. The set of RIS that make up the L2 are grouped as a component. +These +* are sometimes termed slices. They should be configured the same, as +if there +* were only one. +* +* e.g. The SoC probably has more than one L2, each attached to a +distinct set +* of CPUs. All the L2 components are grouped as a class. +* +* When creating an MSC, struct mpam_msc is added to the all +mpam_all_msc list, +* then linked via struct mpam_ris to a vmsc, component and class. +* The same MSC may exist under different class->component->vmsc paths, +but the +* RIS index will be unique. +*/ +LIST_HEAD (mpam_classes); + +/* List of all objects that can be free()d after synchronise_srcu() */ +static LLIST_HEAD (mpam_garbage); + +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) + +static struct mpam_vmsc * +mpam_vmsc_alloc (struct mpam_component *comp,struct mpam_msc *msc, +gfp_t gfp) { +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + + vmsc =kzalloc (sizeof (*vmsc), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (vmsc); + +INIT_LIST_HEAD_RCU (&vmsc->ris); +INIT_LIST_HEAD_RCU (&vmsc->comp_list); + vmsc->comp = comp; + vmsc->msc = msc; + +list_add_rcu (&vmsc->comp_list, &comp->vmsc); + +return vmsc; +} + +static struct mpam_vmsc *mpam_vmsc_get (struct mpam_component *comp, +struct mpam_msc *msc,bool alloc, +gfp_t gfp) +{ +struct mpam_vmsc *vmsc;
drivers/resctrl/mpam_devices.c line 134
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+ +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +if (vmsc->msc->id == msc->id) +return vmsc; + } + +if (!alloc) +return ERR_PTR (-ENOENT );
It seems like it is always false here.
If necessary, why not do this at the beginning of the function?
Quoted 28 lines
drivers/resctrl/mpam_devices.c +28
-0+return mpam_vmsc_alloc (comp, msc, gfp); } + +static struct mpam_component * +mpam_component_alloc (struct mpam_class *class,int id,gfp_t gfp) { +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + + comp =kzalloc (sizeof (*comp), gfp); +if (!comp) +return ERR_PTR (-ENOMEM ); +init_garbage (comp); + + comp->comp_id = id; +INIT_LIST_HEAD_RCU (&comp->vmsc); +/* affinity is updated when ris are added */ +INIT_LIST_HEAD_RCU (&comp->class_list); + comp->class = class; + +list_add_rcu (&comp->class_list, &class->components); + +return comp; +} + +static struct mpam_component * +mpam_component_get (struct mpam_class *class,int id,bool alloc,gfp_t +gfp) { +struct mpam_component *comp;
drivers/resctrl/mpam_devices.c line 160
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+ +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (comp, &class->components, class_list) { +if (comp->comp_id == id) +return comp; + } + +if (!alloc) +return ERR_PTR (-ENOENT );
Same here.
Quoted 34 lines
drivers/resctrl/mpam_devices.c +34
-0+return mpam_component_alloc (class, id, gfp); } + +static struct mpam_class * +mpam_class_alloc (u8 level_idx,enum mpam_class_types type,gfp_t gfp) { +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + + class =kzalloc (sizeof (*class), gfp); +if (!class) +return ERR_PTR (-ENOMEM ); +init_garbage (class); + +INIT_LIST_HEAD_RCU (&class->components); +/* affinity is updated when ris are added */ + class->level = level_idx; + class->type = type; +INIT_LIST_HEAD_RCU (&class->classes_list); + +list_add_rcu (&class->classes_list, &mpam_classes); + +return class; +} + +static struct mpam_class * +mpam_class_get (u8 level_idx,enum mpam_class_types type,bool alloc, +gfp_t gfp) { +bool found = false; +struct mpam_class *class; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (class, &mpam_classes, classes_list) { +if (class->type == type && class->level == level_idx) {
drivers/resctrl/mpam_devices.c line 207
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+ found = true; +break ; + } + } + +if (found) +return class; + +if (!alloc) +return ERR_PTR (-ENOENT );
Same here.
Best regards,
Shaopeng TAN
Quoted 490 lines
drivers/resctrl/mpam_devices.c +65
-0+return mpam_class_alloc (level_idx, type, gfp); } + +#define add_to_garbage (x) \ +do { \ + __typeof__(x) _x = x; \ + (_x)->garbage.to_free = (_x); \ + llist_add(&(_x)->garbage.llist, &mpam_garbage); \ +} while (0) + +static void mpam_class_destroy (struct mpam_class *class) { +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&class->classes_list); +add_to_garbage (class); +} + +static void mpam_comp_destroy (struct mpam_component *comp) { +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&comp->class_list); +add_to_garbage (comp); + +if (list_empty (&class->components)) +mpam_class_destroy (class); +} + +static void mpam_vmsc_destroy (struct mpam_vmsc *vmsc) { +struct mpam_component *comp = vmsc->comp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&vmsc->comp_list); +add_to_garbage (vmsc); + +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +} + +static void mpam_ris_destroy (struct mpam_msc_ris *ris) { +struct mpam_vmsc *vmsc = ris->vmsc; +struct mpam_msc *msc = vmsc->msc; +struct platform_device *pdev = msc->pdev; +struct mpam_component *comp = vmsc->comp; +struct mpam_class *class = comp->class; + +lockdep_assert_held (&mpam_list_lock); + +cpumask_andnot (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_andnot (&class->affinity, &class->affinity, &ris->affinity); +clear_bit (ris->ris_idx, msc->ris_idxs); +list_del_rcu (&ris->vmsc_list); +list_del_rcu (&ris->msc_list); +add_to_garbage (ris); + ris->garbage.pdev = pdev; + +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +} + +/* +* There are two ways of reaching a struct mpam_msc_ris. Via the +* class->component->vmsc->ris, or via the msc. +* When destroying the msc, the other side needs unlinking and cleaning up too.
+ */drivers/resctrl/mpam_devices.c +36
-0+static void mpam_msc_destroy (struct mpam_msc *msc) { +struct platform_device *pdev = msc->pdev; +struct mpam_msc_ris *ris, *tmp; + +lockdep_assert_held (&mpam_list_lock); + +list_del_rcu (&msc->glbl_list); +platform_set_drvdata (pdev,NULL ); + +list_for_each_entry_safe (ris, tmp, &msc->ris, msc_list) +mpam_ris_destroy (ris); + +add_to_garbage (msc); + msc->garbage.pdev = pdev; +} + +static void mpam_free_garbage (void ) +{ +struct mpam_garbage *iter, *tmp; +struct llist_node *to_free =llist_del_all (&mpam_garbage); + +if (!to_free) +return ; + +synchronize_srcu (&mpam_srcu); + +llist_for_each_entry_safe (iter, tmp, to_free, llist) { +if (iter->pdev) +devm_kfree (&iter->pdev->dev, iter->to_free); +else +kfree (iter->to_free); + } +} + +/* Called recursively to walk the list of caches from a particular CPU +*/ static void __mpam_get_cpumask_from_cache_id(int cpu, struct
device_node*cache_node,drivers/resctrl/mpam_devices.c +29
-0+unsigned long cache_id, + u32 cache_level, + cpumask_t *affinity) +{ + int err; +u32 iter_level; +unsigned long iter_cache_id; + struct device_node *iter_node __free(device_node) = +of_find_next_cache_node (cache_node); + +if (!iter_node) +return ; + + err =of_property_read_u32 (iter_node,"cache-level" , &iter_level); +if (err) +return ; + +/* +* get_cpu_cacheinfo_id() isn't ready until sometime +* during device_initcall(). Use cache_of_calculate_id(). +*/ + iter_cache_id =cache_of_calculate_id (iter_node); +if (cache_id == ~0UL ) +return ; + +if (iter_level == cache_level && iter_cache_id == cache_id) +cpumask_set_cpu (cpu, affinity); + + __mpam_get_cpumask_from_cache_id(cpu, iter_node, cache_id,
cache_level,drivers/resctrl/mpam_devices.c +8
-0+ affinity); +} + +/* +* The cacheinfo structures are only populated when CPUs are online. +* This helper walks the device tree to include offline CPUs too. +*/ +int mpam_get_cpumask_from_cache_id(unsigned long cache_id, u32
cache_level,drivers/resctrl/mpam_devices.c +6
-0+ cpumask_t *affinity) +{ +int cpu; + +if (!acpi_disabled) + return acpi_pptt_get_cpumask_from_cache_id(cache_id,affinity);
drivers/resctrl/mpam_devices.c +3
-0+ +for_each_possible_cpu (cpu) { + struct device_node *cpu_node __free(device_node) =
of_get_cpu_node(cpu, NULL);drivers/resctrl/mpam_devices.c +6
-0+if (!cpu_node) { +pr_err ("Failed to find cpu%d device node\n" , cpu); +return -ENOENT ; + } + + __mpam_get_cpumask_from_cache_id(cpu, cpu_node,
cache_id,drivers/resctrl/mpam_devices.c +45
-0+ cache_level, affinity); +continue ; + } + +return 0 ; +} + +/* +* cpumask_of_node() only knows about online CPUs. This can't tell us +whether +* a class is represented on all possible CPUs. +*/ +static void get_cpumask_from_node_id (u32 node_id,cpumask_t *affinity) +{ +int cpu; + +for_each_possible_cpu (cpu) { +if (node_id ==cpu_to_node (cpu)) +cpumask_set_cpu (cpu, affinity); + } +} + +static int get_cpumask_from_cache (struct device_node *cache, +cpumask_t *affinity) +{ +int err; +u32 cache_level; +unsigned long cache_id; + + err =of_property_read_u32 (cache,"cache-level" , &cache_level); +if (err) { +pr_err ("Failed to read cache-level from cache node\n" ); +return -ENOENT ; + } + + cache_id =cache_of_calculate_id (cache); +if (cache_id == ~0UL ) { +pr_err ("Failed to calculate cache-id from cache node\n" ); +return -ENOENT ; + } + +return mpam_get_cpumask_from_cache_id (cache_id, cache_level, +affinity); } + +static int mpam_ris_get_affinity(struct mpam_msc *msc, cpumask_t*affinity,
drivers/resctrl/mpam_devices.c +9
-0+enum mpam_class_types type, + struct mpam_class *class, + struct mpam_component *comp) +{ + int err; + +switch (type) { +case MPAM_CLASS_CACHE : + err = mpam_get_cpumask_from_cache_id(comp->comp_id,
class->level,drivers/resctrl/mpam_devices.c +6
-0+ affinity); +if (err) +return err; + +if (cpumask_empty (affinity)) + pr_warn_once("%s no CPUs associated with cachenode",
drivers/resctrl/mpam_devices.c +18
-0+ dev_name(&msc->pdev->dev)); + +break ; +case MPAM_CLASS_MEMORY : +get_cpumask_from_node_id (comp->comp_id, affinity); +/* affinity may be empty for CPU-less memory nodes */ +break ; +case MPAM_CLASS_UNKNOWN : +return 0 ; + } + +cpumask_and (affinity, affinity, &msc->accessibility); + +return 0 ; +} + +static int mpam_ris_create_locked (struct mpam_msc *msc,u8 ris_idx, + enum mpam_class_types type, u8
class_id,drivers/resctrl/mpam_devices.c +56
-0+ int component_id, gfp_t gfp) +{ + int err; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +if (test_and_set_bit (ris_idx, msc->ris_idxs)) +return -EBUSY ; + + ris =devm_kzalloc (&msc->pdev->dev,sizeof (*ris), gfp); +if (!ris) +return -ENOMEM ; +init_garbage (ris); + + class =mpam_class_get (class_id, type, true, gfp); +if (IS_ERR (class)) +return PTR_ERR (class); + + comp =mpam_component_get (class, component_id, true, gfp); +if (IS_ERR (comp)) { +if (list_empty (&class->components)) +mpam_class_destroy (class); +return PTR_ERR (comp); + } + + vmsc =mpam_vmsc_get (comp, msc, true, gfp); +if (IS_ERR (vmsc)) { +if (list_empty (&comp->vmsc)) +mpam_comp_destroy (comp); +return PTR_ERR (vmsc); + } + + err =mpam_ris_get_affinity (msc, &ris->affinity, type, class, comp); +if (err) { +if (list_empty (&vmsc->ris)) +mpam_vmsc_destroy (vmsc); +return err; + } + + ris->ris_idx = ris_idx; +INIT_LIST_HEAD_RCU (&ris->vmsc_list); + ris->vmsc = vmsc; + +cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity); +cpumask_or (&class->affinity, &class->affinity, &ris->affinity); +list_add_rcu (&ris->vmsc_list, &vmsc->ris); + +return 0 ; +} + +int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, + enum mpam_class_types type, u8 class_id, int
component_id) {drivers/resctrl/mpam_devices.c +16
-1+int err; + +mutex_lock (&mpam_list_lock); + err =mpam_ris_create_locked (msc, ris_idx, type, class_id, + component_id,GFP_KERNEL ); +mutex_unlock (&mpam_list_lock); +if (err) +mpam_free_garbage (); + +return err; +} +static void mpam_discovery_complete (void ) {pr_err ("Discovered all MSC\n" );@@ -179,7 +650,10 @@ static int update_msc_accessibility(struct mpam_msc *msc)cpumask_copy (&msc->accessibility, cpu_possible_mask); err =0 ; }else { -if (of_device_is_compatible (parent,"memory" )) { +if (of_device_is_compatible (parent,"cache" )) { + err =get_cpumask_from_cache (parent, + &msc->accessibility); + }else if (of_device_is_compatible (parent,"memory" )) {cpumask_copy (&msc->accessibility, cpu_possible_mask);drivers/resctrl/mpam_devices.c +3
-4err =0 ; }else {@@ -209,11 +683,10 @@ static void mpam_msc_drv_remove(struct platform_device *pdev) mutex_lock(&mpam_list_lock); mpam_num_msc--; -platform_set_drvdata (pdev,NULL ); -list_del_rcu (&msc->glbl_list); -synchronize_srcu (&mpam_srcu); -devm_kfree (&pdev->dev, msc); +mpam_msc_destroy (msc);mutex_unlock (&mpam_list_lock); + +mpam_free_garbage (); }static int
mpam_msc_drv_probe(struct platform_device *pdev)@@ -230,6
+703,7 @@ static intmpam_msc_drv_probe(struct platform_device *pdev)drivers/resctrl/mpam_devices.c +1
-0err = -ENOMEM ;break ; } +init_garbage (msc);mutex_init (&msc->probe_lock);mutex_init (&msc->part_sel_lock);(quoted diff) +0
-0
b/drivers/resctrl/mpam_internal.hindex07e0f240eaca..d49bb884b433100644drivers/resctrl/mpam_internal.h +93
-0@@ -7,10 +7,27 @@#include <linux/arm_mpam.h> #include <linux/cpumask.h> #include <linux/io.h> +#include <linux/llist.h> #include <linux/mailbox_client.h> #include <linux/mutex.h> #include <linux/resctrl.h> #include <linux/sizes.h> +#include <linux/srcu.h> + +/* +* Structures protected by SRCU may not be freed for a surprising +amount of +* time (especially if perf is running). To ensure the MPAM error +interrupt can +* tear down all the structures, build a list of objects that can be +gargbage +* collected once synchronize_srcu() has returned. +* If pdev is non-NULL, use devm_kfree(). +*/ +struct mpam_garbage { +/* member of mpam_garbage */ +struct llist_node llist; + +void *to_free; +struct platform_device *pdev; +};struct mpam_msc {/* member of mpam_all_msc */ @@ -57,6 +74,80 @@ struct mpam_msc {void __iomem *mapped_hwpage;size_t mapped_hwpage_sz; + +struct mpam_garbage garbage; +}; + +struct mpam_class { +/* mpam_components in this class */ +struct list_head components; + +cpumask_t affinity; + +u8 level; +enum mpam_class_types type; + +/* member of mpam_classes */ +struct list_head classes_list; + +struct mpam_garbage garbage; +}; + +struct mpam_component { +u32 comp_id; + +/* mpam_vmsc in this component */ +struct list_head vmsc; + +cpumask_t affinity; + +/* member of mpam_class:components */ +struct list_head class_list; + +/* parent: */ +struct mpam_class *class; + +struct mpam_garbage garbage; }; +struct mpam_vmsc { +/* member of mpam_component:vmsc_list */ +struct list_head comp_list; + +/* mpam_msc_ris in this vmsc */ +struct list_head ris; + +/* All RIS in this vMSC are members of this MSC */ +struct mpam_msc *msc; + +/* parent: */ +struct mpam_component *comp; + +struct mpam_garbage garbage; +}; + +struct mpam_msc_ris { +u8 ris_idx; + +cpumask_t affinity; + +/* member of mpam_vmsc:ris */ +struct list_head vmsc_list; + +/* member of mpam_msc:ris */ +struct list_head msc_list; + +/* parent: */ +struct mpam_vmsc *vmsc; + +struct mpam_garbage garbage; +}; + +/* List of all classes - protected by srcu*/ extern struct srcu_struct +mpam_srcu;extern struct list_head mpam_classes; + +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level, +cpumask_t *affinity); +#endif /* MPAM_INTERNAL_H */ include/linux/arm_mpam.h index renamed from include/linux/arm_mpam.h +0
-0
0edefa6ba019..406a77be68cb100644include/linux/arm_mpam.h +0
-0@@ -36,11 +36,7 @@ static inline int acpi_mpam_parse_resources(struct
mpam_msc*msc, static inline intacpi_mpam_count_msc(void){ returninclude/linux/arm_mpam.h +0
-3-EINVAL ; }#endif -static inline int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, - enum mpam_class_types type, u8
class_id,include/linux/arm_mpam.h +2
-4- int component_id) -{ -return -EINVAL ; -} +int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx, + enum mpam_class_types type, u8 class_id, int
component_id);#endif /*
__LINUX_ARM_MPAM_H*/
--
2.20.1
James Morse
maintainerRe: [PATCH 12/33] arm_mpam: Add the class and component structures for ris firmware described
Hi Shaopeng,
Quoted 42 lines · Shaopeng Tan (Fujitsu)
Quoted 42 lines
An MSC is a container of resources, each identified by their RIS index. Some RIS are described by firmware to provide their position in the system. Others are discovered when the driver probes the hardware.
To configure a resource it needs to be found by its class, e.g. 'L2'. There are two kinds of grouping, a class is a set of components, which are visible to user-space as there are likely to be multiple instances of the L2 cache. (e.g. one per cluster or package)
struct
mpam_componentsare a set of structmpam_vmsc. A vMSC groups the RIS in an MSC that control the same logical piece of hardware. (e.g. L2). This is to allow hardware implementations where two controls are presented as different RIS. Re-combining these RIS allows their feature bits to be or-ed. This structure is not visible outsidempam_devices.cstruct
mpam_vmscare then a set of structmpam_msc_ris, which are not visible as each L2 cache may be composed of individual slices which need to be configured the same as the hardware is not able to distribute the configuration.Add support for creating and destroying these structures.
A gfp is passed as the structures may need creating when a new RIS entry is discovered when probing the MSC.
drivers/resctrl/mpam_devices.c +10
-0@@ -35,11 +34,483 @@ +static struct mpam_vmsc *mpam_vmsc_get (struct mpam_component *comp, +struct mpam_msc *msc,bool alloc, +gfp_t gfp) +{ +struct mpam_vmsc *vmsc; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +if (vmsc->msc->id == msc->id)
Quoted 8 lines
drivers/resctrl/mpam_devices.c line 119
Quoted 5 lines
drivers/resctrl/mpam_devices.c +5
-0+return vmsc; + } + +if (!alloc) +return ERR_PTR (-ENOENT );It seems like it is always false here.
If necessary, why not do this at the beginning of the function?
Because the VMSC may exist - in which case the 'get' function should return it regardless of whether the caller wants to allocate it if its missing.
I'd anticipated callers like resctrl would want to grab components by things like cache- id, without allocating them by accident. But that coded ended up just searching the lists instead. I'll rip this out.
Thanks,
James
James Morse
maintainerPATCH 13/33 arm_mpam: Add MPAM MSC register layout definitions
In reply to James MorseMemory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.
Add the definitions for these registers as offset within the page(s).
---
Changes since RFC:
* Renamed MSMON_CFG_MBWU_CTL_TYPE_CSU as MSMON_CFG_CSU_CTL_TYPE_CSU
* Whitepsace churn.
* Cite a more recent document.
* Removed some stale feature, fixed some names etc.
--- drivers/resctrl/mpam_internal.h | 266 ++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+)
drivers/resctrl/mpam_internal.h +266 -0
@@ -150,4 +150,270 @@ extern struct list_head mpam_classes;int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity); +/* +* MPAM MSCs have the following register layout. See: +* Arm Memory System Resource Partitioning and Monitoring (MPAM) System +* Component Specification. +* https://developer.arm.com/documentation/ihi0099/latest/ +*/ +#define MPAM_ARCHITECTURE_V1 0x10 + +/* Memory mapped control pages: */ +/* ID Register offsets in the memory mapped page */ +#define MPAMF_IDR 0x0000/* features id register */ +#define MPAMF_MSMON_IDR 0x0080/* performance monitoring features */ +#define MPAMF_IMPL_IDR 0x0028/* imp-def partitioning */ +#define MPAMF_CPOR_IDR 0x0030/* cache-portion partitioning */ +#define MPAMF_CCAP_IDR 0x0038/* cache-capacity partitioning */ +#define MPAMF_MBW_IDR 0x0040/* mem-bw partitioning */ +#define MPAMF_PRI_IDR 0x0048/* priority partitioning */ +#define MPAMF_CSUMON_IDR 0x0088/* cache-usage monitor */ +#define MPAMF_MBWUMON_IDR 0x0090/* mem-bw usage monitor */ +#define MPAMF_PARTID_NRW_IDR 0x0050/* partid-narrowing */ +#define MPAMF_IIDR 0x0018/* implementer id register */ +#define MPAMF_AIDR 0x0020/* architectural id register */ + +/* Configuration and Status Register offsets in the memory mapped page */ +#define MPAMCFG_PART_SEL 0x0100/* partid to configure: */ +#define MPAMCFG_CPBM 0x1000/* cache-portion config */ +#define MPAMCFG_CMAX 0x0108/* cache-capacity config */ +#define MPAMCFG_CMIN 0x0110/* cache-capacity config */ +#define MPAMCFG_MBW_MIN 0x0200/* min mem-bw config */ +#define MPAMCFG_MBW_MAX 0x0208/* max mem-bw config */ +#define MPAMCFG_MBW_WINWD 0x0220/* mem-bw accounting window config */ +#define MPAMCFG_MBW_PBM 0x2000/* mem-bw portion bitmap config */ +#define MPAMCFG_PRI 0x0400/* priority partitioning config */ +#define MPAMCFG_MBW_PROP 0x0500/* mem-bw stride config */ +#define MPAMCFG_INTPARTID 0x0600/* partid-narrowing config */ + +#define MSMON_CFG_MON_SEL 0x0800/* monitor selector */ +#define MSMON_CFG_CSU_FLT 0x0810/* cache-usage monitor filter */ +#define MSMON_CFG_CSU_CTL 0x0818/* cache-usage monitor config */ +#define MSMON_CFG_MBWU_FLT 0x0820/* mem-bw monitor filter */ +#define MSMON_CFG_MBWU_CTL 0x0828/* mem-bw monitor config */ +#define MSMON_CSU 0x0840/* current cache-usage */ +#define MSMON_CSU_CAPTURE 0x0848/* last cache-usage value captured */ +#define MSMON_MBWU 0x0860/* current mem-bw usage value */ +#define MSMON_MBWU_CAPTURE 0x0868/* last mem-bw value captured */ +#define MSMON_MBWU_L 0x0880/* current long mem-bw usage value */ +#define MSMON_MBWU_CAPTURE_L 0x0890/* last long mem-bw value captured */ +#define MSMON_CAPT_EVNT 0x0808/* signal a capture event */ +#define MPAMF_ESR 0x00F8/* error status register */ +#define MPAMF_ECR 0x00F0/* error control register */ + +/* MPAMF_IDR - MPAM features ID register */ +#define MPAMF_IDR_PARTID_MAX GENMASK(15, 0) +#define MPAMF_IDR_PMG_MAX GENMASK(23, 16) +#define MPAMF_IDR_HAS_CCAP_PART BIT(24) +#define MPAMF_IDR_HAS_CPOR_PART BIT(25) +#define MPAMF_IDR_HAS_MBW_PART BIT(26) +#define MPAMF_IDR_HAS_PRI_PART BIT(27) +#define MPAMF_IDR_EXT BIT(28) +#define MPAMF_IDR_HAS_IMPL_IDR BIT(29) +#define MPAMF_IDR_HAS_MSMON BIT(30) +#define MPAMF_IDR_HAS_PARTID_NRW BIT(31) +#define MPAMF_IDR_HAS_RIS BIT(32) +#define MPAMF_IDR_HAS_EXTD_ESR BIT(38) +#define MPAMF_IDR_HAS_ESR BIT(39) +#define MPAMF_IDR_RIS_MAX GENMASK(59, 56) + +/* MPAMF_MSMON_IDR - MPAM performance monitoring ID register */ +#define MPAMF_MSMON_IDR_MSMON_CSU BIT(16) +#define MPAMF_MSMON_IDR_MSMON_MBWU BIT(17) +#define MPAMF_MSMON_IDR_HAS_LOCAL_CAPT_EVNT BIT(31) + +/* MPAMF_CPOR_IDR - MPAM features cache portion partitioning ID register */ +#define MPAMF_CPOR_IDR_CPBM_WD GENMASK(15, 0) + +/* MPAMF_CCAP_IDR - MPAM features cache capacity partitioning ID register */ +#define MPAMF_CCAP_IDR_CMAX_WD GENMASK(5, 0) +#define MPAMF_CCAP_IDR_CASSOC_WD GENMASK(12, 8) +#define MPAMF_CCAP_IDR_HAS_CASSOC BIT(28) +#define MPAMF_CCAP_IDR_HAS_CMIN BIT(29) +#define MPAMF_CCAP_IDR_NO_CMAX BIT(30) +#define MPAMF_CCAP_IDR_HAS_CMAX_SOFTLIM BIT(31) + +/* MPAMF_MBW_IDR - MPAM features memory bandwidth partitioning ID register */ +#define MPAMF_MBW_IDR_BWA_WD GENMASK(5, 0) +#define MPAMF_MBW_IDR_HAS_MIN BIT(10) +#define MPAMF_MBW_IDR_HAS_MAX BIT(11) +#define MPAMF_MBW_IDR_HAS_PBM BIT(12) +#define MPAMF_MBW_IDR_HAS_PROP BIT(13) +#define MPAMF_MBW_IDR_WINDWR BIT(14) +#define MPAMF_MBW_IDR_BWPBM_WD GENMASK(28, 16) + +/* MPAMF_PRI_IDR - MPAM features priority partitioning ID register */ +#define MPAMF_PRI_IDR_HAS_INTPRI BIT(0) +#define MPAMF_PRI_IDR_INTPRI_0_IS_LOW BIT(1) +#define MPAMF_PRI_IDR_INTPRI_WD GENMASK(9, 4) +#define MPAMF_PRI_IDR_HAS_DSPRI BIT(16) +#define MPAMF_PRI_IDR_DSPRI_0_IS_LOW BIT(17) +#define MPAMF_PRI_IDR_DSPRI_WD GENMASK(25, 20) + +/* MPAMF_CSUMON_IDR - MPAM cache storage usage monitor ID register */ +#define MPAMF_CSUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_CAPT BIT(24) +#define MPAMF_CSUMON_IDR_HAS_CEVNT_OFLW BIT(25) +#define MPAMF_CSUMON_IDR_HAS_OFSR BIT(26) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_LNKG BIT(27) +#define MPAMF_CSUMON_IDR_HAS_XCL BIT(29) +#define MPAMF_CSUMON_IDR_CSU_RO BIT(30) +#define MPAMF_CSUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_MBWUMON_IDR - MPAM memory bandwidth usage monitor ID register */ +#define MPAMF_MBWUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_MBWUMON_IDR_HAS_RWBW BIT(28) +#define MPAMF_MBWUMON_IDR_LWD BIT(29) +#define MPAMF_MBWUMON_IDR_HAS_LONG BIT(30) +#define MPAMF_MBWUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_PARTID_NRW_IDR - MPAM PARTID narrowing ID register */ +#define MPAMF_PARTID_NRW_IDR_INTPARTID_MAX GENMASK(15, 0) + +/* MPAMF_IIDR - MPAM implementation ID register */ +#define MPAMF_IIDR_PRODUCTID GENMASK(31, 20) +#define MPAMF_IIDR_PRODUCTID_SHIFT 20 +#define MPAMF_IIDR_VARIANT GENMASK(19, 16) +#define MPAMF_IIDR_VARIANT_SHIFT 16 +#define MPAMF_IIDR_REVISON GENMASK(15, 12) +#define MPAMF_IIDR_REVISON_SHIFT 12 +#define MPAMF_IIDR_IMPLEMENTER GENMASK(11, 0) +#define MPAMF_IIDR_IMPLEMENTER_SHIFT 0 + +/* MPAMF_AIDR - MPAM architecture ID register */ +#define MPAMF_AIDR_ARCH_MAJOR_REV GENMASK(7, 4) +#define MPAMF_AIDR_ARCH_MINOR_REV GENMASK(3, 0) + +/* MPAMCFG_PART_SEL - MPAM partition configuration selection register */ +#define MPAMCFG_PART_SEL_PARTID_SEL GENMASK(15, 0) +#define MPAMCFG_PART_SEL_INTERNAL BIT(16) +#define MPAMCFG_PART_SEL_RIS GENMASK(27, 24) + +/* MPAMCFG_CMAX - MPAM cache capacity configuration register */ +#define MPAMCFG_CMAX_SOFTLIM BIT(31) +#define MPAMCFG_CMAX_CMAX GENMASK(15, 0) + +/* MPAMCFG_CMIN - MPAM cache capacity configuration register */ +#define MPAMCFG_CMIN_CMIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MIN - MPAM memory minimum bandwidth partitioning configuration +* register +*/ +#define MPAMCFG_MBW_MIN_MIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MAX - MPAM memory maximum bandwidth partitioning configuration +* register +*/ +#define MPAMCFG_MBW_MAX_MAX GENMASK(15, 0) +#define MPAMCFG_MBW_MAX_HARDLIM BIT(31) + +/* +* MPAMCFG_MBW_WINWD - MPAM memory bandwidth partitioning window width +* register +*/ +#define MPAMCFG_MBW_WINWD_US_FRAC GENMASK(7, 0) +#define MPAMCFG_MBW_WINWD_US_INT GENMASK(23, 8) + +/* MPAMCFG_PRI - MPAM priority partitioning configuration register */ +#define MPAMCFG_PRI_INTPRI GENMASK(15, 0) +#define MPAMCFG_PRI_DSPRI GENMASK(31, 16) + +/* +* MPAMCFG_MBW_PROP - Memory bandwidth proportional stride partitioning +* configuration register +*/ +#define MPAMCFG_MBW_PROP_STRIDEM1 GENMASK(15, 0) +#define MPAMCFG_MBW_PROP_EN BIT(31) + +/* +* MPAMCFG_INTPARTID - MPAM internal partition narrowing configuration register +*/ +#define MPAMCFG_INTPARTID_INTPARTID GENMASK(15, 0) +#define MPAMCFG_INTPARTID_INTERNAL BIT(16) + +/* MSMON_CFG_MON_SEL - Memory system performance monitor selection register */ +#define MSMON_CFG_MON_SEL_MON_SEL GENMASK(15, 0) +#define MSMON_CFG_MON_SEL_RIS GENMASK(27, 24) + +/* MPAMF_ESR - MPAM Error Status Register */ +#define MPAMF_ESR_PARTID_MON GENMASK(15, 0) +#define MPAMF_ESR_PMG GENMASK(23, 16) +#define MPAMF_ESR_ERRCODE GENMASK(27, 24) +#define MPAMF_ESR_OVRWR BIT(31) +#define MPAMF_ESR_RIS GENMASK(35, 32) + +/* MPAMF_ECR - MPAM Error Control Register */ +#define MPAMF_ECR_INTEN BIT(0) + +/* Error conditions in accessing memory mapped registers */ +#define MPAM_ERRCODE_NONE 0 +#define MPAM_ERRCODE_PARTID_SEL_RANGE 1 +#define MPAM_ERRCODE_REQ_PARTID_RANGE 2 +#define MPAM_ERRCODE_MSMONCFG_ID_RANGE 3 +#define MPAM_ERRCODE_REQ_PMG_RANGE 4 +#define MPAM_ERRCODE_MONITOR_RANGE 5 +#define MPAM_ERRCODE_INTPARTID_RANGE 6 +#define MPAM_ERRCODE_UNEXPECTED_INTERNAL 7 + +/* +* MSMON_CFG_CSU_FLT - Memory system performance monitor configure cache storage +* usage monitor filter register +*/ +#define MSMON_CFG_CSU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_CSU_FLT_PMG GENMASK(23, 16) + +/* +* MSMON_CFG_CSU_CTL - Memory system performance monitor configure cache storage +* usage monitor control register +* MSMON_CFG_MBWU_CTL - Memory system performance monitor configure memory +* bandwidth usage monitor control register +*/ +#define MSMON_CFG_x_CTL_TYPE GENMASK(7, 0) +#define MSMON_CFG_MBWU_CTL_OFLOW_STATUS_L BIT(15) +#define MSMON_CFG_x_CTL_MATCH_PARTID BIT(16) +#define MSMON_CFG_x_CTL_MATCH_PMG BIT(17) +#define MSMON_CFG_x_CTL_SCLEN BIT(19) +#define MSMON_CFG_x_CTL_SUBTYPE GENMASK(22, 20) +#define MSMON_CFG_x_CTL_OFLOW_FRZ BIT(24) +#define MSMON_CFG_x_CTL_OFLOW_INTR BIT(25) +#define MSMON_CFG_x_CTL_OFLOW_STATUS BIT(26) +#define MSMON_CFG_x_CTL_CAPT_RESET BIT(27) +#define MSMON_CFG_x_CTL_CAPT_EVNT GENMASK(30, 28) +#define MSMON_CFG_x_CTL_EN BIT(31) + +#define MSMON_CFG_MBWU_CTL_TYPE_MBWU 0x42 +#define MSMON_CFG_CSU_CTL_TYPE_CSU 0 + +/* +* MSMON_CFG_MBWU_FLT - Memory system performance monitor configure memory +* bandwidth usage monitor filter register +*/ +#define MSMON_CFG_MBWU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_MBWU_FLT_PMG GENMASK(23, 16) +#define MSMON_CFG_MBWU_FLT_RWBW GENMASK(31, 30) + +/* +* MSMON_CSU - Memory system performance monitor cache storage usage monitor +* register +* MSMON_CSU_CAPTURE - Memory system performance monitor cache storage usage +* capture register +* MSMON_MBWU - Memory system performance monitor memory bandwidth usage +* monitor register +* MSMON_MBWU_CAPTURE - Memory system performance monitor memory bandwidth usage +* capture register +*/ +#define MSMON___VALUE GENMASK(30, 0) +#define MSMON___NRDY BIT(31) +#define MSMON___NRDY_L BIT(63) +#define MSMON___L_VALUE GENMASK(43, 0) +#define MSMON___LWD_VALUE GENMASK(62, 0) + +/* +* MSMON_CAPT_EVNT - Memory system performance monitoring capture event +* generation register +*/ +#define MSMON_CAPT_EVNT_NOW BIT(0) +#endif /* MPAM_INTERNAL_H */
Signature · 1 line
2.20.1
Re: [PATCH 13/33] arm_mpam: Add MPAM MSC register layout definitions
Hi James,
Quoted 134 lines · James Morse
Memory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.
Add the definitions for these registers as offset within the page(s).
Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* RenamedMSMON_CFG_MBWU_CTL_TYPE_CSUasMSMON_CFG_CSU_CTL_TYPE_CSU
* Whitepsace churn.
* Cite a more recent document.
* Removed some stale feature, fixed some names etc.--- drivers/resctrl/mpam_internal.h | 266 ++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+)drivers/resctrl/mpam_internal.h +109
-0@@ -150,4 +150,270 @@ extern struct list_head mpam_classes;int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity); +/* +* MPAM MSCs have the following register layout. See: +* Arm Memory System Resource Partitioning and Monitoring (MPAM) System +* Component Specification. +* https://developer.arm.com/documentation/ihi0099/latest/ +*/ +#define MPAM_ARCHITECTURE_V1 0x10 + +/* Memory mapped control pages: */ +/* ID Register offsets in the memory mapped page */ +#define MPAMF_IDR 0x0000/* features id register */ +#define MPAMF_MSMON_IDR 0x0080/* performance monitoring features */ +#define MPAMF_IMPL_IDR 0x0028/* imp-def partitioning */ +#define MPAMF_CPOR_IDR 0x0030/* cache-portion partitioning */ +#define MPAMF_CCAP_IDR 0x0038/* cache-capacity partitioning */ +#define MPAMF_MBW_IDR 0x0040/* mem-bw partitioning */ +#define MPAMF_PRI_IDR 0x0048/* priority partitioning */ +#define MPAMF_CSUMON_IDR 0x0088/* cache-usage monitor */ +#define MPAMF_MBWUMON_IDR 0x0090/* mem-bw usage monitor */ +#define MPAMF_PARTID_NRW_IDR 0x0050/* partid-narrowing */ +#define MPAMF_IIDR 0x0018/* implementer id register */ +#define MPAMF_AIDR 0x0020/* architectural id register */ + +/* Configuration and Status Register offsets in the memory mapped page */ +#define MPAMCFG_PART_SEL 0x0100/* partid to configure: */ +#define MPAMCFG_CPBM 0x1000/* cache-portion config */ +#define MPAMCFG_CMAX 0x0108/* cache-capacity config */ +#define MPAMCFG_CMIN 0x0110/* cache-capacity config */ +#define MPAMCFG_MBW_MIN 0x0200/* min mem-bw config */ +#define MPAMCFG_MBW_MAX 0x0208/* max mem-bw config */ +#define MPAMCFG_MBW_WINWD 0x0220/* mem-bw accounting window config */ +#define MPAMCFG_MBW_PBM 0x2000/* mem-bw portion bitmap config */ +#define MPAMCFG_PRI 0x0400/* priority partitioning config */ +#define MPAMCFG_MBW_PROP 0x0500/* mem-bw stride config */ +#define MPAMCFG_INTPARTID 0x0600/* partid-narrowing config */ + +#define MSMON_CFG_MON_SEL 0x0800/* monitor selector */ +#define MSMON_CFG_CSU_FLT 0x0810/* cache-usage monitor filter */ +#define MSMON_CFG_CSU_CTL 0x0818/* cache-usage monitor config */ +#define MSMON_CFG_MBWU_FLT 0x0820/* mem-bw monitor filter */ +#define MSMON_CFG_MBWU_CTL 0x0828/* mem-bw monitor config */ +#define MSMON_CSU 0x0840/* current cache-usage */ +#define MSMON_CSU_CAPTURE 0x0848/* last cache-usage value captured */ +#define MSMON_MBWU 0x0860/* current mem-bw usage value */ +#define MSMON_MBWU_CAPTURE 0x0868/* last mem-bw value captured */ +#define MSMON_MBWU_L 0x0880/* current long mem-bw usage value */ +#define MSMON_MBWU_CAPTURE_L 0x0890/* last long mem-bw value captured */ +#define MSMON_CAPT_EVNT 0x0808/* signal a capture event */ +#define MPAMF_ESR 0x00F8/* error status register */ +#define MPAMF_ECR 0x00F0/* error control register */ + +/* MPAMF_IDR - MPAM features ID register */ +#define MPAMF_IDR_PARTID_MAX GENMASK(15, 0) +#define MPAMF_IDR_PMG_MAX GENMASK(23, 16) +#define MPAMF_IDR_HAS_CCAP_PART BIT(24) +#define MPAMF_IDR_HAS_CPOR_PART BIT(25) +#define MPAMF_IDR_HAS_MBW_PART BIT(26) +#define MPAMF_IDR_HAS_PRI_PART BIT(27) +#define MPAMF_IDR_EXT BIT(28) +#define MPAMF_IDR_HAS_IMPL_IDR BIT(29) +#define MPAMF_IDR_HAS_MSMON BIT(30) +#define MPAMF_IDR_HAS_PARTID_NRW BIT(31) +#define MPAMF_IDR_HAS_RIS BIT(32) +#define MPAMF_IDR_HAS_EXTD_ESR BIT(38) +#define MPAMF_IDR_HAS_ESR BIT(39) +#define MPAMF_IDR_RIS_MAX GENMASK(59, 56) + +/* MPAMF_MSMON_IDR - MPAM performance monitoring ID register */ +#define MPAMF_MSMON_IDR_MSMON_CSU BIT(16) +#define MPAMF_MSMON_IDR_MSMON_MBWU BIT(17) +#define MPAMF_MSMON_IDR_HAS_LOCAL_CAPT_EVNT BIT(31) + +/* MPAMF_CPOR_IDR - MPAM features cache portion partitioning ID register */ +#define MPAMF_CPOR_IDR_CPBM_WD GENMASK(15, 0) + +/* MPAMF_CCAP_IDR - MPAM features cache capacity partitioning ID register */ +#define MPAMF_CCAP_IDR_CMAX_WD GENMASK(5, 0) +#define MPAMF_CCAP_IDR_CASSOC_WD GENMASK(12, 8) +#define MPAMF_CCAP_IDR_HAS_CASSOC BIT(28) +#define MPAMF_CCAP_IDR_HAS_CMIN BIT(29) +#define MPAMF_CCAP_IDR_NO_CMAX BIT(30) +#define MPAMF_CCAP_IDR_HAS_CMAX_SOFTLIM BIT(31) + +/* MPAMF_MBW_IDR - MPAM features memory bandwidth partitioning ID register */ +#define MPAMF_MBW_IDR_BWA_WD GENMASK(5, 0) +#define MPAMF_MBW_IDR_HAS_MIN BIT(10) +#define MPAMF_MBW_IDR_HAS_MAX BIT(11) +#define MPAMF_MBW_IDR_HAS_PBM BIT(12) +#define MPAMF_MBW_IDR_HAS_PROP BIT(13) +#define MPAMF_MBW_IDR_WINDWR BIT(14) +#define MPAMF_MBW_IDR_BWPBM_WD GENMASK(28, 16) + +/* MPAMF_PRI_IDR - MPAM features priority partitioning ID register */ +#define MPAMF_PRI_IDR_HAS_INTPRI BIT(0) +#define MPAMF_PRI_IDR_INTPRI_0_IS_LOW BIT(1) +#define MPAMF_PRI_IDR_INTPRI_WD GENMASK(9, 4) +#define MPAMF_PRI_IDR_HAS_DSPRI BIT(16) +#define MPAMF_PRI_IDR_DSPRI_0_IS_LOW BIT(17) +#define MPAMF_PRI_IDR_DSPRI_WD GENMASK(25, 20) + +/* MPAMF_CSUMON_IDR - MPAM cache storage usage monitor ID register */ +#define MPAMF_CSUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_CAPT BIT(24) +#define MPAMF_CSUMON_IDR_HAS_CEVNT_OFLW BIT(25) +#define MPAMF_CSUMON_IDR_HAS_OFSR BIT(26) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_LNKG BIT(27) +#define MPAMF_CSUMON_IDR_HAS_XCL BIT(29) +#define MPAMF_CSUMON_IDR_CSU_RO BIT(30) +#define MPAMF_CSUMON_IDR_HAS_CAPTURE BIT(31)
drivers/resctrl/mpam_internal.h extern struct list_head mpam_classes; · line 271
Quoted 10 lines
drivers/resctrl/mpam_internal.h +10
-0+ +/* MPAMF_MBWUMON_IDR - MPAM memory bandwidth usage monitor ID register */ +#define MPAMF_MBWUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_MBWUMON_IDR_HAS_RWBW BIT(28) +#define MPAMF_MBWUMON_IDR_LWD BIT(29) +#define MPAMF_MBWUMON_IDR_HAS_LONG BIT(30) +#define MPAMF_MBWUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_PARTID_NRW_IDR - MPAM PARTID narrowing ID register */ +#define MPAMF_PARTID_NRW_IDR_INTPARTID_MAX GENMASK(15, 0)
nit: spaces used instead of tabs
Quoted 138 lines
drivers/resctrl/mpam_internal.h +138
-0+ +/* MPAMF_IIDR - MPAM implementation ID register */ +#define MPAMF_IIDR_PRODUCTID GENMASK(31, 20) +#define MPAMF_IIDR_PRODUCTID_SHIFT 20 +#define MPAMF_IIDR_VARIANT GENMASK(19, 16) +#define MPAMF_IIDR_VARIANT_SHIFT 16 +#define MPAMF_IIDR_REVISON GENMASK(15, 12) +#define MPAMF_IIDR_REVISON_SHIFT 12 +#define MPAMF_IIDR_IMPLEMENTER GENMASK(11, 0) +#define MPAMF_IIDR_IMPLEMENTER_SHIFT 0 + +/* MPAMF_AIDR - MPAM architecture ID register */ +#define MPAMF_AIDR_ARCH_MAJOR_REV GENMASK(7, 4) +#define MPAMF_AIDR_ARCH_MINOR_REV GENMASK(3, 0) + +/* MPAMCFG_PART_SEL - MPAM partition configuration selection register */ +#define MPAMCFG_PART_SEL_PARTID_SEL GENMASK(15, 0) +#define MPAMCFG_PART_SEL_INTERNAL BIT(16) +#define MPAMCFG_PART_SEL_RIS GENMASK(27, 24) + +/* MPAMCFG_CMAX - MPAM cache capacity configuration register */ +#define MPAMCFG_CMAX_SOFTLIM BIT(31) +#define MPAMCFG_CMAX_CMAX GENMASK(15, 0) + +/* MPAMCFG_CMIN - MPAM cache capacity configuration register */ +#define MPAMCFG_CMIN_CMIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MIN - MPAM memory minimum bandwidth partitioning configuration +* register +*/ +#define MPAMCFG_MBW_MIN_MIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MAX - MPAM memory maximum bandwidth partitioning configuration +* register +*/ +#define MPAMCFG_MBW_MAX_MAX GENMASK(15, 0) +#define MPAMCFG_MBW_MAX_HARDLIM BIT(31) + +/* +* MPAMCFG_MBW_WINWD - MPAM memory bandwidth partitioning window width +* register +*/ +#define MPAMCFG_MBW_WINWD_US_FRAC GENMASK(7, 0) +#define MPAMCFG_MBW_WINWD_US_INT GENMASK(23, 8) + +/* MPAMCFG_PRI - MPAM priority partitioning configuration register */ +#define MPAMCFG_PRI_INTPRI GENMASK(15, 0) +#define MPAMCFG_PRI_DSPRI GENMASK(31, 16) + +/* +* MPAMCFG_MBW_PROP - Memory bandwidth proportional stride partitioning +* configuration register +*/ +#define MPAMCFG_MBW_PROP_STRIDEM1 GENMASK(15, 0) +#define MPAMCFG_MBW_PROP_EN BIT(31) + +/* +* MPAMCFG_INTPARTID - MPAM internal partition narrowing configuration register +*/ +#define MPAMCFG_INTPARTID_INTPARTID GENMASK(15, 0) +#define MPAMCFG_INTPARTID_INTERNAL BIT(16) + +/* MSMON_CFG_MON_SEL - Memory system performance monitor selection register */ +#define MSMON_CFG_MON_SEL_MON_SEL GENMASK(15, 0) +#define MSMON_CFG_MON_SEL_RIS GENMASK(27, 24) + +/* MPAMF_ESR - MPAM Error Status Register */ +#define MPAMF_ESR_PARTID_MON GENMASK(15, 0) +#define MPAMF_ESR_PMG GENMASK(23, 16) +#define MPAMF_ESR_ERRCODE GENMASK(27, 24) +#define MPAMF_ESR_OVRWR BIT(31) +#define MPAMF_ESR_RIS GENMASK(35, 32) + +/* MPAMF_ECR - MPAM Error Control Register */ +#define MPAMF_ECR_INTEN BIT(0) + +/* Error conditions in accessing memory mapped registers */ +#define MPAM_ERRCODE_NONE 0 +#define MPAM_ERRCODE_PARTID_SEL_RANGE 1 +#define MPAM_ERRCODE_REQ_PARTID_RANGE 2 +#define MPAM_ERRCODE_MSMONCFG_ID_RANGE 3 +#define MPAM_ERRCODE_REQ_PMG_RANGE 4 +#define MPAM_ERRCODE_MONITOR_RANGE 5 +#define MPAM_ERRCODE_INTPARTID_RANGE 6 +#define MPAM_ERRCODE_UNEXPECTED_INTERNAL 7 + +/* +* MSMON_CFG_CSU_FLT - Memory system performance monitor configure cache storage +* usage monitor filter register +*/ +#define MSMON_CFG_CSU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_CSU_FLT_PMG GENMASK(23, 16) + +/* +* MSMON_CFG_CSU_CTL - Memory system performance monitor configure cache storage +* usage monitor control register +* MSMON_CFG_MBWU_CTL - Memory system performance monitor configure memory +* bandwidth usage monitor control register +*/ +#define MSMON_CFG_x_CTL_TYPE GENMASK(7, 0) +#define MSMON_CFG_MBWU_CTL_OFLOW_STATUS_L BIT(15) +#define MSMON_CFG_x_CTL_MATCH_PARTID BIT(16) +#define MSMON_CFG_x_CTL_MATCH_PMG BIT(17) +#define MSMON_CFG_x_CTL_SCLEN BIT(19) +#define MSMON_CFG_x_CTL_SUBTYPE GENMASK(22, 20) +#define MSMON_CFG_x_CTL_OFLOW_FRZ BIT(24) +#define MSMON_CFG_x_CTL_OFLOW_INTR BIT(25) +#define MSMON_CFG_x_CTL_OFLOW_STATUS BIT(26) +#define MSMON_CFG_x_CTL_CAPT_RESET BIT(27) +#define MSMON_CFG_x_CTL_CAPT_EVNT GENMASK(30, 28) +#define MSMON_CFG_x_CTL_EN BIT(31) + +#define MSMON_CFG_MBWU_CTL_TYPE_MBWU 0x42 +#define MSMON_CFG_CSU_CTL_TYPE_CSU 0 + +/* +* MSMON_CFG_MBWU_FLT - Memory system performance monitor configure memory +* bandwidth usage monitor filter register +*/ +#define MSMON_CFG_MBWU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_MBWU_FLT_PMG GENMASK(23, 16) +#define MSMON_CFG_MBWU_FLT_RWBW GENMASK(31, 30) + +/* +* MSMON_CSU - Memory system performance monitor cache storage usage monitor +* register +* MSMON_CSU_CAPTURE - Memory system performance monitor cache storage usage +* capture register +* MSMON_MBWU - Memory system performance monitor memory bandwidth usage +* monitor register +* MSMON_MBWU_CAPTURE - Memory system performance monitor memory bandwidth usage +* capture register +*/ +#define MSMON___VALUE GENMASK(30, 0) +#define MSMON___NRDY BIT(31) +#define MSMON___NRDY_L BIT(63)
drivers/resctrl/mpam_internal.h extern struct list_head mpam_classes; · line 419
Quoted 10 lines
drivers/resctrl/mpam_internal.h +9
-0+#define MSMON___L_VALUE GENMASK(43, 0) +#define MSMON___LWD_VALUE GENMASK(62, 0) + +/* +* MSMON_CAPT_EVNT - Memory system performance monitoring capture event +* generation register +*/ +#define MSMON_CAPT_EVNT_NOW BIT(0) +#endif /* MPAM_INTERNAL_H */
The names and values match the specification.
Thanks,
Ben
James Morse
maintainerRe: [PATCH 13/33] arm_mpam: Add MPAM MSC register layout definitions
Hi Ben,
Quoted 12 lines · Ben Horgan
Quoted 10 lines · James Morse
Memory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.
Add the definitions for these registers as offset within the page(s).
drivers/resctrl/mpam_internal.h +0
-0@@ -150,4 +150,270 @@ extern struct list_head mpam_classes;
Quoted 4 lines
drivers/resctrl/mpam_internal.h extern struct list_head mpam_classes; · line 271
Quoted 2 lines
drivers/resctrl/mpam_internal.h +2
-0+/* MPAMF_PARTID_NRW_IDR - MPAM PARTID narrowing ID register */ +#define MPAMF_PARTID_NRW_IDR_INTPARTID_MAX GENMASK(15, 0)nit: spaces used instead of tabs
Fixed,
~
Quoted 3 lines
The names and values match the specification.
Reviewed-by Ben Horgan <[email protected]>
Thanks!
James
RE: [PATCH 13/33] arm_mpam: Add MPAM MSC register layout definitions
In reply to James MorseHello James,
Quoted 295 lines
Memory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.
Add the definitions for these registers as offset within the page(s).
Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* RenamedMSMON_CFG_MBWU_CTL_TYPE_CSUasMSMON_CFG_CSU_CTL_TYPE_CSU
* Whitepsace churn.
* Cite a more recent document.
* Removed some stale feature, fixed some names etc.--- drivers/resctrl/mpam_internal.h | 266 ++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+)drivers/resctrl/mpam_internal.h +12
-0@@ -150,4 +150,270 @@ extern struct list_head mpam_classes; int mpam_get_cpumask_from_cache_id(unsigned long cache_id, u32 cache_level, cpumask_t *affinity); +/* +* MPAM MSCs have the following register layout. See: +* Arm Memory System Resource Partitioning and Monitoring (MPAM) System +* Component Specification. +* https://developer.arm.com/documentation/ihi0099/latest/ +*/ +#define MPAM_ARCHITECTURE_V1 0x10 + +/* Memory mapped control pages: */ +/* ID Register offsets in the memory mapped page */ +#define MPAMF_IDR 0x0000/* features id register */ +#define MPAMF_MSMON_IDR 0x0080/* performance monitoring features */
drivers/resctrl/mpam_internal.h +2
-0+#define MPAMF_IMPL_IDR 0x0028/* imp-def partitioning */ +#define MPAMF_CPOR_IDR 0x0030/* cache-portion partitioning */
+#defineMPAMF_CCAP_IDR0x0038/* cache-capacity
partitioning */drivers/resctrl/mpam_internal.h +4
-0+#define MPAMF_MBW_IDR 0x0040/* mem-bw partitioning */ +#define MPAMF_PRI_IDR 0x0048/* priority partitioning */ +#define MPAMF_CSUMON_IDR 0x0088/* cache-usage monitor */ +#define MPAMF_MBWUMON_IDR 0x0090/* mem-bw usage monitor */
drivers/resctrl/mpam_internal.h +11
-0+#define MPAMF_PARTID_NRW_IDR 0x0050/* partid-narrowing */ +#define MPAMF_IIDR 0x0018/* implementer id register */ +#define MPAMF_AIDR 0x0020/* architectural id register */ + +/* Configuration and Status Register offsets in the memory mapped page */ +#define MPAMCFG_PART_SEL 0x0100/* partid to configure: */ +#define MPAMCFG_CPBM 0x1000/* cache-portion config */ +#define MPAMCFG_CMAX 0x0108/* cache-capacity config */ +#define MPAMCFG_CMIN 0x0110/* cache-capacity config */ +#define MPAMCFG_MBW_MIN 0x0200/* min mem-bw config */ +#define MPAMCFG_MBW_MAX 0x0208/* max mem-bw config */
+#defineMPAMCFG_MBW_WINWD0x0220/* mem-bw accounting
window config */
+#defineMPAMCFG_MBW_PBM0x2000/* mem-bw portion
bitmap config */
+#defineMPAMCFG_PRI0x0400/* priority partitioning
config */drivers/resctrl/mpam_internal.h +2
-0+#define MPAMCFG_MBW_PROP 0x0500/* mem-bw stride config */ +#define MPAMCFG_INTPARTID 0x0600/* partid-narrowing config */
drivers/resctrl/mpam_internal.h +3
-0+ +#define MSMON_CFG_MON_SEL 0x0800/* monitor selector */ +#define MSMON_CFG_CSU_FLT 0x0810/* cache-usage monitor filter */
+#defineMSMON_CFG_CSU_CTL0x0818/* cache-usage monitor
config */drivers/resctrl/mpam_internal.h +2
-0+#define MSMON_CFG_MBWU_FLT 0x0820/* mem-bw monitor filter */ +#define MSMON_CFG_MBWU_CTL 0x0828/* mem-bw monitor config */
drivers/resctrl/mpam_internal.h +2
-0+#define MSMON_CSU 0x0840/* current cache-usage */ +#define MSMON_CSU_CAPTURE 0x0848/* last cache-usage value captured */
+#defineMSMON_MBWU0x0860/* current mem-bw usage
value */
+#defineMSMON_MBWU_CAPTURE0x0868/* last mem-bw value
captured */
+#defineMSMON_MBWU_L0x0880/* current long mem-bw
usage value */
+#defineMSMON_MBWU_CAPTURE_L0x0890/* last long mem-bw value
captured */drivers/resctrl/mpam_internal.h +26
-0+#define MSMON_CAPT_EVNT 0x0808/* signal a capture event */ +#define MPAMF_ESR 0x00F8/* error status register */ +#define MPAMF_ECR 0x00F0/* error control register */ + +/* MPAMF_IDR - MPAM features ID register */ +#define MPAMF_IDR_PARTID_MAX GENMASK(15, 0) +#define MPAMF_IDR_PMG_MAX GENMASK(23, 16) +#define MPAMF_IDR_HAS_CCAP_PART BIT(24) +#define MPAMF_IDR_HAS_CPOR_PART BIT(25) +#define MPAMF_IDR_HAS_MBW_PART BIT(26) +#define MPAMF_IDR_HAS_PRI_PART BIT(27) +#define MPAMF_IDR_EXT BIT(28) +#define MPAMF_IDR_HAS_IMPL_IDR BIT(29) +#define MPAMF_IDR_HAS_MSMON BIT(30) +#define MPAMF_IDR_HAS_PARTID_NRW BIT(31) +#define MPAMF_IDR_HAS_RIS BIT(32) +#define MPAMF_IDR_HAS_EXTD_ESR BIT(38) +#define MPAMF_IDR_HAS_ESR BIT(39) +#define MPAMF_IDR_RIS_MAX GENMASK(59, 56) + +/* MPAMF_MSMON_IDR - MPAM performance monitoring ID register */ +#define MPAMF_MSMON_IDR_MSMON_CSU BIT(16) +#define MPAMF_MSMON_IDR_MSMON_MBWU BIT(17) +#define MPAMF_MSMON_IDR_HAS_LOCAL_CAPT_EVNT BIT(31) + +/* MPAMF_CPOR_IDR - MPAM features cache portion partitioning ID register */
+#defineMPAMF_CPOR_IDR_CPBM_WDGENMASK(15, 0)drivers/resctrl/mpam_internal.h +2
-0+ +/* MPAMF_CCAP_IDR - MPAM features cache capacity partitioning ID register */
+#defineMPAMF_CCAP_IDR_CMAX_WDGENMASK(5, 0)drivers/resctrl/mpam_internal.h +7
-0+#define MPAMF_CCAP_IDR_CASSOC_WD GENMASK(12, 8) +#define MPAMF_CCAP_IDR_HAS_CASSOC BIT(28) +#define MPAMF_CCAP_IDR_HAS_CMIN BIT(29) +#define MPAMF_CCAP_IDR_NO_CMAX BIT(30) +#define MPAMF_CCAP_IDR_HAS_CMAX_SOFTLIM BIT(31) + +/* MPAMF_MBW_IDR - MPAM features memory bandwidth partitioning ID register */
drivers/resctrl/mpam_internal.h +27
-0+#define MPAMF_MBW_IDR_BWA_WD GENMASK(5, 0) +#define MPAMF_MBW_IDR_HAS_MIN BIT(10) +#define MPAMF_MBW_IDR_HAS_MAX BIT(11) +#define MPAMF_MBW_IDR_HAS_PBM BIT(12) +#define MPAMF_MBW_IDR_HAS_PROP BIT(13) +#define MPAMF_MBW_IDR_WINDWR BIT(14) +#define MPAMF_MBW_IDR_BWPBM_WD GENMASK(28, 16) + +/* MPAMF_PRI_IDR - MPAM features priority partitioning ID register */ +#define MPAMF_PRI_IDR_HAS_INTPRI BIT(0) +#define MPAMF_PRI_IDR_INTPRI_0_IS_LOW BIT(1) +#define MPAMF_PRI_IDR_INTPRI_WD GENMASK(9, 4) +#define MPAMF_PRI_IDR_HAS_DSPRI BIT(16) +#define MPAMF_PRI_IDR_DSPRI_0_IS_LOW BIT(17) +#define MPAMF_PRI_IDR_DSPRI_WD GENMASK(25, 20) + +/* MPAMF_CSUMON_IDR - MPAM cache storage usage monitor ID register */ +#define MPAMF_CSUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_CAPT BIT(24) +#define MPAMF_CSUMON_IDR_HAS_CEVNT_OFLW BIT(25) +#define MPAMF_CSUMON_IDR_HAS_OFSR BIT(26) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_LNKG BIT(27) +#define MPAMF_CSUMON_IDR_HAS_XCL BIT(29) +#define MPAMF_CSUMON_IDR_CSU_RO BIT(30) +#define MPAMF_CSUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_MBWUMON_IDR - MPAM memory bandwidth usage monitor ID register */
drivers/resctrl/mpam_internal.h +8
-0+#define MPAMF_MBWUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_MBWUMON_IDR_HAS_RWBW BIT(28) +#define MPAMF_MBWUMON_IDR_LWD BIT(29) +#define MPAMF_MBWUMON_IDR_HAS_LONG BIT(30) +#define MPAMF_MBWUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_PARTID_NRW_IDR - MPAM PARTID narrowing ID register */ +#define MPAMF_PARTID_NRW_IDR_INTPARTID_MAX GENMASK(15,0)
drivers/resctrl/mpam_internal.h +29
-0+ +/* MPAMF_IIDR - MPAM implementation ID register */ +#define MPAMF_IIDR_PRODUCTID GENMASK(31, 20) +#define MPAMF_IIDR_PRODUCTID_SHIFT 20 +#define MPAMF_IIDR_VARIANT GENMASK(19, 16) +#define MPAMF_IIDR_VARIANT_SHIFT 16 +#define MPAMF_IIDR_REVISON GENMASK(15, 12) +#define MPAMF_IIDR_REVISON_SHIFT 12 +#define MPAMF_IIDR_IMPLEMENTER GENMASK(11, 0) +#define MPAMF_IIDR_IMPLEMENTER_SHIFT 0 + +/* MPAMF_AIDR - MPAM architecture ID register */ +#define MPAMF_AIDR_ARCH_MAJOR_REV GENMASK(7, 4) +#define MPAMF_AIDR_ARCH_MINOR_REV GENMASK(3, 0) + +/* MPAMCFG_PART_SEL - MPAM partition configuration selection register */ +#define MPAMCFG_PART_SEL_PARTID_SEL GENMASK(15, 0) +#define MPAMCFG_PART_SEL_INTERNAL BIT(16) +#define MPAMCFG_PART_SEL_RIS GENMASK(27, 24) + +/* MPAMCFG_CMAX - MPAM cache capacity configuration register */ +#define MPAMCFG_CMAX_SOFTLIM BIT(31) +#define MPAMCFG_CMAX_CMAX GENMASK(15, 0) + +/* MPAMCFG_CMIN - MPAM cache capacity configuration register */ +#define MPAMCFG_CMIN_CMIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MIN - MPAM memory minimum bandwidth partitioning configuration
+ * register
+ */drivers/resctrl/mpam_internal.h +4
-0+#define MPAMCFG_MBW_MIN_MIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MAX - MPAM memory maximum bandwidth partitioning configuration
+ * register
+ */drivers/resctrl/mpam_internal.h +5
-0+#define MPAMCFG_MBW_MAX_MAX GENMASK(15, 0) +#define MPAMCFG_MBW_MAX_HARDLIM BIT(31) + +/* +* MPAMCFG_MBW_WINWD - MPAM memory bandwidth partitioning window width
+ * register
+ */drivers/resctrl/mpam_internal.h +9
-0+#define MPAMCFG_MBW_WINWD_US_FRAC GENMASK(7, 0) +#define MPAMCFG_MBW_WINWD_US_INT GENMASK(23, 8) + +/* MPAMCFG_PRI - MPAM priority partitioning configuration register */ +#define MPAMCFG_PRI_INTPRI GENMASK(15, 0) +#define MPAMCFG_PRI_DSPRI GENMASK(31, 16) + +/* +* MPAMCFG_MBW_PROP - Memory bandwidth proportional stride partitioning
+ * configuration register
+ */drivers/resctrl/mpam_internal.h +10
-0+#define MPAMCFG_MBW_PROP_STRIDEM1 GENMASK(15, 0) +#define MPAMCFG_MBW_PROP_EN BIT(31) + +/* +* MPAMCFG_INTPARTID - MPAM internal partition narrowing configuration +register */ +#define MPAMCFG_INTPARTID_INTPARTID GENMASK(15, 0) +#define MPAMCFG_INTPARTID_INTERNAL BIT(16) + +/* MSMON_CFG_MON_SEL - Memory system performance monitor selection register */
drivers/resctrl/mpam_internal.h +25
-0+#define MSMON_CFG_MON_SEL_MON_SEL GENMASK(15, 0) +#define MSMON_CFG_MON_SEL_RIS GENMASK(27, 24) + +/* MPAMF_ESR - MPAM Error Status Register */ +#define MPAMF_ESR_PARTID_MON GENMASK(15, 0) +#define MPAMF_ESR_PMG GENMASK(23, 16) +#define MPAMF_ESR_ERRCODE GENMASK(27, 24) +#define MPAMF_ESR_OVRWR BIT(31) +#define MPAMF_ESR_RIS GENMASK(35, 32) + +/* MPAMF_ECR - MPAM Error Control Register */ +#define MPAMF_ECR_INTEN BIT(0) + +/* Error conditions in accessing memory mapped registers */ +#define MPAM_ERRCODE_NONE 0 +#define MPAM_ERRCODE_PARTID_SEL_RANGE 1 +#define MPAM_ERRCODE_REQ_PARTID_RANGE 2 +#define MPAM_ERRCODE_MSMONCFG_ID_RANGE 3 +#define MPAM_ERRCODE_REQ_PMG_RANGE 4 +#define MPAM_ERRCODE_MONITOR_RANGE 5 +#define MPAM_ERRCODE_INTPARTID_RANGE 6 +#define MPAM_ERRCODE_UNEXPECTED_INTERNAL 7 + +/* +* MSMON_CFG_CSU_FLT - Memory system performance monitor configure cache storage
+ * usage monitor filter register
+ */drivers/resctrl/mpam_internal.h +5
-0+#define MSMON_CFG_CSU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_CSU_FLT_PMG GENMASK(23, 16) + +/* +* MSMON_CFG_CSU_CTL - Memory system performance monitor configure cache storage
+ * usage monitor control register
+ *MSMON_CFG_MBWU_CTL- Memory system performance monitor configure memory
+ * bandwidth usage monitor control register
+ */drivers/resctrl/mpam_internal.h +6
-0+#define MSMON_CFG_x_CTL_TYPE GENMASK(7, 0) +#define MSMON_CFG_MBWU_CTL_OFLOW_STATUS_L BIT(15) +#define MSMON_CFG_x_CTL_MATCH_PARTID BIT(16) +#define MSMON_CFG_x_CTL_MATCH_PMG BIT(17) +#define MSMON_CFG_x_CTL_SCLEN BIT(19) +#define MSMON_CFG_x_CTL_SUBTYPEGENMASK(22, 20)drivers/resctrl/mpam_internal.h +8
-0+#define MSMON_CFG_x_CTL_OFLOW_FRZ BIT(24) +#define MSMON_CFG_x_CTL_OFLOW_INTR BIT(25) +#define MSMON_CFG_x_CTL_OFLOW_STATUS BIT(26) +#define MSMON_CFG_x_CTL_CAPT_RESET BIT(27) +#define MSMON_CFG_x_CTL_CAPT_EVNT GENMASK(30, 28) +#define MSMON_CFG_x_CTL_EN BIT(31) + +#define MSMON_CFG_MBWU_CTL_TYPE_MBWU 0x42
Quoted 1 line
+#define
MSMON_CFG_CSU_CTL_TYPE_CSU0
+#define MSMON_CFG_CSU_CTL_TYPE_CSU 0x43?
Best regards,
Shaopeng TAN
Quoted 41 lines
+/*
+ *MSMON_CFG_MBWU_FLT- Memory system performance monitor configure memory
+ * bandwidth usage monitor filter register
+ */drivers/resctrl/mpam_internal.h +2
-0+#define MSMON_CFG_MBWU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_MBWU_FLT_PMG GENMASK(23, 16) +#define MSMON_CFG_MBWU_FLT_RWBW GENMASK(31, 30)drivers/resctrl/mpam_internal.h +3
-0+ +/* +* MSMON_CSU - Memory system performance monitor cache storage usage monitor
+ * register
+ *MSMON_CSU_CAPTURE- Memory system performance monitor cache storage usage
+ * capture register
+ *MSMON_MBWU- Memory system performance monitor memory bandwidth usage
+ * monitor register
+ *MSMON_MBWU_CAPTURE- Memory system performance monitor memory bandwidth usage
+ * capture register
+ */drivers/resctrl/mpam_internal.h +8
-0+#define MSMON___VALUE GENMASK(30, 0) +#define MSMON___NRDY BIT(31) +#define MSMON___NRDY_L BIT(63) +#define MSMON___L_VALUE GENMASK(43, 0) +#define MSMON___LWD_VALUE GENMASK(62, 0) + +/* +* MSMON_CAPT_EVNT - Memory system performance monitoring capture event
+ * generation register
+ */drivers/resctrl/mpam_internal.h +2
-1+#define MSMON_CAPT_EVNT_NOW BIT(0) +#endif /* MPAM_INTERNAL_H */ --2.20.1
James Morse
maintainerRe: [PATCH 13/33] arm_mpam: Add MPAM MSC register layout definitions
Hi Shaopeng,
Quoted 11 lines · Shaopeng Tan (Fujitsu)
Quoted 10 lines
Memory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.
Add the definitions for these registers as offset within the page(s).
drivers/resctrl/mpam_internal.h +0
-0@@ -150,4 +150,270 @@ extern struct list_head mpam_classes; int
Quoted 5 lines
drivers/resctrl/mpam_internal.h extern struct list_head mpam_classes; int · line 152
Quoted 3 lines
drivers/resctrl/mpam_internal.h +2
-0+#define MSMON_CFG_MBWU_CTL_TYPE_MBWU 0x42 +#define MSMON_CFG_CSU_CTL_TYPE_CSU 0+#define
MSMON_CFG_CSU_CTL_TYPE_CSU0x43?
Yes, that looks like the line got truncated.
This would have caused the counter type to be mismatched and reprogrammed each time. Thanks for spotting it!
James
James Morse
maintainerPATCH 13/33 arm_mpam: Add MPAM MSC register layout definitions
In reply to James MorseMemory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.
Add the definitions for these registers as offset within the page(s).
---
Changes since RFC:
* Renamed MSMON_CFG_MBWU_CTL_TYPE_CSU as MSMON_CFG_CSU_CTL_TYPE_CSU
* Whitepsace churn.
* Cite a more recent document.
* Removed some stale feature, fixed some names etc.
--- drivers/resctrl/mpam_internal.h | 266 ++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+)
drivers/resctrl/mpam_internal.h +266 -0
@@ -150,4 +150,270 @@ extern struct list_head mpam_classes;int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity); +/* +* MPAM MSCs have the following register layout. See: +* Arm Memory System Resource Partitioning and Monitoring (MPAM) System +* Component Specification. +* https://developer.arm.com/documentation/ihi0099/latest/ +*/ +#define MPAM_ARCHITECTURE_V1 0x10 + +/* Memory mapped control pages: */ +/* ID Register offsets in the memory mapped page */ +#define MPAMF_IDR 0x0000/* features id register */ +#define MPAMF_MSMON_IDR 0x0080/* performance monitoring features */ +#define MPAMF_IMPL_IDR 0x0028/* imp-def partitioning */ +#define MPAMF_CPOR_IDR 0x0030/* cache-portion partitioning */ +#define MPAMF_CCAP_IDR 0x0038/* cache-capacity partitioning */ +#define MPAMF_MBW_IDR 0x0040/* mem-bw partitioning */ +#define MPAMF_PRI_IDR 0x0048/* priority partitioning */ +#define MPAMF_CSUMON_IDR 0x0088/* cache-usage monitor */ +#define MPAMF_MBWUMON_IDR 0x0090/* mem-bw usage monitor */ +#define MPAMF_PARTID_NRW_IDR 0x0050/* partid-narrowing */ +#define MPAMF_IIDR 0x0018/* implementer id register */ +#define MPAMF_AIDR 0x0020/* architectural id register */ + +/* Configuration and Status Register offsets in the memory mapped page */ +#define MPAMCFG_PART_SEL 0x0100/* partid to configure: */ +#define MPAMCFG_CPBM 0x1000/* cache-portion config */ +#define MPAMCFG_CMAX 0x0108/* cache-capacity config */ +#define MPAMCFG_CMIN 0x0110/* cache-capacity config */ +#define MPAMCFG_MBW_MIN 0x0200/* min mem-bw config */ +#define MPAMCFG_MBW_MAX 0x0208/* max mem-bw config */ +#define MPAMCFG_MBW_WINWD 0x0220/* mem-bw accounting window config */ +#define MPAMCFG_MBW_PBM 0x2000/* mem-bw portion bitmap config */ +#define MPAMCFG_PRI 0x0400/* priority partitioning config */ +#define MPAMCFG_MBW_PROP 0x0500/* mem-bw stride config */ +#define MPAMCFG_INTPARTID 0x0600/* partid-narrowing config */ + +#define MSMON_CFG_MON_SEL 0x0800/* monitor selector */ +#define MSMON_CFG_CSU_FLT 0x0810/* cache-usage monitor filter */ +#define MSMON_CFG_CSU_CTL 0x0818/* cache-usage monitor config */ +#define MSMON_CFG_MBWU_FLT 0x0820/* mem-bw monitor filter */ +#define MSMON_CFG_MBWU_CTL 0x0828/* mem-bw monitor config */ +#define MSMON_CSU 0x0840/* current cache-usage */ +#define MSMON_CSU_CAPTURE 0x0848/* last cache-usage value captured */ +#define MSMON_MBWU 0x0860/* current mem-bw usage value */ +#define MSMON_MBWU_CAPTURE 0x0868/* last mem-bw value captured */ +#define MSMON_MBWU_L 0x0880/* current long mem-bw usage value */ +#define MSMON_MBWU_CAPTURE_L 0x0890/* last long mem-bw value captured */ +#define MSMON_CAPT_EVNT 0x0808/* signal a capture event */ +#define MPAMF_ESR 0x00F8/* error status register */ +#define MPAMF_ECR 0x00F0/* error control register */ + +/* MPAMF_IDR - MPAM features ID register */ +#define MPAMF_IDR_PARTID_MAX GENMASK(15, 0) +#define MPAMF_IDR_PMG_MAX GENMASK(23, 16) +#define MPAMF_IDR_HAS_CCAP_PART BIT(24) +#define MPAMF_IDR_HAS_CPOR_PART BIT(25) +#define MPAMF_IDR_HAS_MBW_PART BIT(26) +#define MPAMF_IDR_HAS_PRI_PART BIT(27) +#define MPAMF_IDR_EXT BIT(28) +#define MPAMF_IDR_HAS_IMPL_IDR BIT(29) +#define MPAMF_IDR_HAS_MSMON BIT(30) +#define MPAMF_IDR_HAS_PARTID_NRW BIT(31) +#define MPAMF_IDR_HAS_RIS BIT(32) +#define MPAMF_IDR_HAS_EXTD_ESR BIT(38) +#define MPAMF_IDR_HAS_ESR BIT(39) +#define MPAMF_IDR_RIS_MAX GENMASK(59, 56) + +/* MPAMF_MSMON_IDR - MPAM performance monitoring ID register */ +#define MPAMF_MSMON_IDR_MSMON_CSU BIT(16) +#define MPAMF_MSMON_IDR_MSMON_MBWU BIT(17) +#define MPAMF_MSMON_IDR_HAS_LOCAL_CAPT_EVNT BIT(31) + +/* MPAMF_CPOR_IDR - MPAM features cache portion partitioning ID register */ +#define MPAMF_CPOR_IDR_CPBM_WD GENMASK(15, 0) + +/* MPAMF_CCAP_IDR - MPAM features cache capacity partitioning ID register */ +#define MPAMF_CCAP_IDR_CMAX_WD GENMASK(5, 0) +#define MPAMF_CCAP_IDR_CASSOC_WD GENMASK(12, 8) +#define MPAMF_CCAP_IDR_HAS_CASSOC BIT(28) +#define MPAMF_CCAP_IDR_HAS_CMIN BIT(29) +#define MPAMF_CCAP_IDR_NO_CMAX BIT(30) +#define MPAMF_CCAP_IDR_HAS_CMAX_SOFTLIM BIT(31) + +/* MPAMF_MBW_IDR - MPAM features memory bandwidth partitioning ID register */ +#define MPAMF_MBW_IDR_BWA_WD GENMASK(5, 0) +#define MPAMF_MBW_IDR_HAS_MIN BIT(10) +#define MPAMF_MBW_IDR_HAS_MAX BIT(11) +#define MPAMF_MBW_IDR_HAS_PBM BIT(12) +#define MPAMF_MBW_IDR_HAS_PROP BIT(13) +#define MPAMF_MBW_IDR_WINDWR BIT(14) +#define MPAMF_MBW_IDR_BWPBM_WD GENMASK(28, 16) + +/* MPAMF_PRI_IDR - MPAM features priority partitioning ID register */ +#define MPAMF_PRI_IDR_HAS_INTPRI BIT(0) +#define MPAMF_PRI_IDR_INTPRI_0_IS_LOW BIT(1) +#define MPAMF_PRI_IDR_INTPRI_WD GENMASK(9, 4) +#define MPAMF_PRI_IDR_HAS_DSPRI BIT(16) +#define MPAMF_PRI_IDR_DSPRI_0_IS_LOW BIT(17) +#define MPAMF_PRI_IDR_DSPRI_WD GENMASK(25, 20) + +/* MPAMF_CSUMON_IDR - MPAM cache storage usage monitor ID register */ +#define MPAMF_CSUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_CAPT BIT(24) +#define MPAMF_CSUMON_IDR_HAS_CEVNT_OFLW BIT(25) +#define MPAMF_CSUMON_IDR_HAS_OFSR BIT(26) +#define MPAMF_CSUMON_IDR_HAS_OFLOW_LNKG BIT(27) +#define MPAMF_CSUMON_IDR_HAS_XCL BIT(29) +#define MPAMF_CSUMON_IDR_CSU_RO BIT(30) +#define MPAMF_CSUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_MBWUMON_IDR - MPAM memory bandwidth usage monitor ID register */ +#define MPAMF_MBWUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_MBWUMON_IDR_HAS_RWBW BIT(28) +#define MPAMF_MBWUMON_IDR_LWD BIT(29) +#define MPAMF_MBWUMON_IDR_HAS_LONG BIT(30) +#define MPAMF_MBWUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_PARTID_NRW_IDR - MPAM PARTID narrowing ID register */ +#define MPAMF_PARTID_NRW_IDR_INTPARTID_MAX GENMASK(15, 0) + +/* MPAMF_IIDR - MPAM implementation ID register */ +#define MPAMF_IIDR_PRODUCTID GENMASK(31, 20) +#define MPAMF_IIDR_PRODUCTID_SHIFT 20 +#define MPAMF_IIDR_VARIANT GENMASK(19, 16) +#define MPAMF_IIDR_VARIANT_SHIFT 16 +#define MPAMF_IIDR_REVISON GENMASK(15, 12) +#define MPAMF_IIDR_REVISON_SHIFT 12 +#define MPAMF_IIDR_IMPLEMENTER GENMASK(11, 0) +#define MPAMF_IIDR_IMPLEMENTER_SHIFT 0 + +/* MPAMF_AIDR - MPAM architecture ID register */ +#define MPAMF_AIDR_ARCH_MAJOR_REV GENMASK(7, 4) +#define MPAMF_AIDR_ARCH_MINOR_REV GENMASK(3, 0) + +/* MPAMCFG_PART_SEL - MPAM partition configuration selection register */ +#define MPAMCFG_PART_SEL_PARTID_SEL GENMASK(15, 0) +#define MPAMCFG_PART_SEL_INTERNAL BIT(16) +#define MPAMCFG_PART_SEL_RIS GENMASK(27, 24) + +/* MPAMCFG_CMAX - MPAM cache capacity configuration register */ +#define MPAMCFG_CMAX_SOFTLIM BIT(31) +#define MPAMCFG_CMAX_CMAX GENMASK(15, 0) + +/* MPAMCFG_CMIN - MPAM cache capacity configuration register */ +#define MPAMCFG_CMIN_CMIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MIN - MPAM memory minimum bandwidth partitioning configuration +* register +*/ +#define MPAMCFG_MBW_MIN_MIN GENMASK(15, 0) + +/* +* MPAMCFG_MBW_MAX - MPAM memory maximum bandwidth partitioning configuration +* register +*/ +#define MPAMCFG_MBW_MAX_MAX GENMASK(15, 0) +#define MPAMCFG_MBW_MAX_HARDLIM BIT(31) + +/* +* MPAMCFG_MBW_WINWD - MPAM memory bandwidth partitioning window width +* register +*/ +#define MPAMCFG_MBW_WINWD_US_FRAC GENMASK(7, 0) +#define MPAMCFG_MBW_WINWD_US_INT GENMASK(23, 8) + +/* MPAMCFG_PRI - MPAM priority partitioning configuration register */ +#define MPAMCFG_PRI_INTPRI GENMASK(15, 0) +#define MPAMCFG_PRI_DSPRI GENMASK(31, 16) + +/* +* MPAMCFG_MBW_PROP - Memory bandwidth proportional stride partitioning +* configuration register +*/ +#define MPAMCFG_MBW_PROP_STRIDEM1 GENMASK(15, 0) +#define MPAMCFG_MBW_PROP_EN BIT(31) + +/* +* MPAMCFG_INTPARTID - MPAM internal partition narrowing configuration register +*/ +#define MPAMCFG_INTPARTID_INTPARTID GENMASK(15, 0) +#define MPAMCFG_INTPARTID_INTERNAL BIT(16) + +/* MSMON_CFG_MON_SEL - Memory system performance monitor selection register */ +#define MSMON_CFG_MON_SEL_MON_SEL GENMASK(15, 0) +#define MSMON_CFG_MON_SEL_RIS GENMASK(27, 24) + +/* MPAMF_ESR - MPAM Error Status Register */ +#define MPAMF_ESR_PARTID_MON GENMASK(15, 0) +#define MPAMF_ESR_PMG GENMASK(23, 16) +#define MPAMF_ESR_ERRCODE GENMASK(27, 24) +#define MPAMF_ESR_OVRWR BIT(31) +#define MPAMF_ESR_RIS GENMASK(35, 32) + +/* MPAMF_ECR - MPAM Error Control Register */ +#define MPAMF_ECR_INTEN BIT(0) + +/* Error conditions in accessing memory mapped registers */ +#define MPAM_ERRCODE_NONE 0 +#define MPAM_ERRCODE_PARTID_SEL_RANGE 1 +#define MPAM_ERRCODE_REQ_PARTID_RANGE 2 +#define MPAM_ERRCODE_MSMONCFG_ID_RANGE 3 +#define MPAM_ERRCODE_REQ_PMG_RANGE 4 +#define MPAM_ERRCODE_MONITOR_RANGE 5 +#define MPAM_ERRCODE_INTPARTID_RANGE 6 +#define MPAM_ERRCODE_UNEXPECTED_INTERNAL 7 + +/* +* MSMON_CFG_CSU_FLT - Memory system performance monitor configure cache storage +* usage monitor filter register +*/ +#define MSMON_CFG_CSU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_CSU_FLT_PMG GENMASK(23, 16) + +/* +* MSMON_CFG_CSU_CTL - Memory system performance monitor configure cache storage +* usage monitor control register +* MSMON_CFG_MBWU_CTL - Memory system performance monitor configure memory +* bandwidth usage monitor control register +*/ +#define MSMON_CFG_x_CTL_TYPE GENMASK(7, 0) +#define MSMON_CFG_MBWU_CTL_OFLOW_STATUS_L BIT(15) +#define MSMON_CFG_x_CTL_MATCH_PARTID BIT(16) +#define MSMON_CFG_x_CTL_MATCH_PMG BIT(17) +#define MSMON_CFG_x_CTL_SCLEN BIT(19) +#define MSMON_CFG_x_CTL_SUBTYPE GENMASK(22, 20) +#define MSMON_CFG_x_CTL_OFLOW_FRZ BIT(24) +#define MSMON_CFG_x_CTL_OFLOW_INTR BIT(25) +#define MSMON_CFG_x_CTL_OFLOW_STATUS BIT(26) +#define MSMON_CFG_x_CTL_CAPT_RESET BIT(27) +#define MSMON_CFG_x_CTL_CAPT_EVNT GENMASK(30, 28) +#define MSMON_CFG_x_CTL_EN BIT(31) + +#define MSMON_CFG_MBWU_CTL_TYPE_MBWU 0x42 +#define MSMON_CFG_CSU_CTL_TYPE_CSU 0 + +/* +* MSMON_CFG_MBWU_FLT - Memory system performance monitor configure memory +* bandwidth usage monitor filter register +*/ +#define MSMON_CFG_MBWU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_MBWU_FLT_PMG GENMASK(23, 16) +#define MSMON_CFG_MBWU_FLT_RWBW GENMASK(31, 30) + +/* +* MSMON_CSU - Memory system performance monitor cache storage usage monitor +* register +* MSMON_CSU_CAPTURE - Memory system performance monitor cache storage usage +* capture register +* MSMON_MBWU - Memory system performance monitor memory bandwidth usage +* monitor register +* MSMON_MBWU_CAPTURE - Memory system performance monitor memory bandwidth usage +* capture register +*/ +#define MSMON___VALUE GENMASK(30, 0) +#define MSMON___NRDY BIT(31) +#define MSMON___NRDY_L BIT(63) +#define MSMON___L_VALUE GENMASK(43, 0) +#define MSMON___LWD_VALUE GENMASK(62, 0) + +/* +* MSMON_CAPT_EVNT - Memory system performance monitoring capture event +* generation register +*/ +#define MSMON_CAPT_EVNT_NOW BIT(0) +#endif /* MPAM_INTERNAL_H */
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 14/33 arm_mpam: Add cpuhp callbacks to probe MSC hardware
In reply to James MorseBecause an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
Enabling a static key will also take the cpuhp lock, so can't be done from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
--- drivers/resctrl/mpam_devices.c | 144 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 8 +- 2 files changed, 147 insertions(+), 5 deletions(-)
drivers/resctrl/mpam_devices.c +141 -3
@@ -4,6 +4,7 @@#define pr_fmt (fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__#include <linux/acpi.h> +#include <linux/atomic.h> #include <linux/arm_mpam.h> #include <linux/cacheinfo.h> #include <linux/cpu.h>
@@ -21,6 +22,7 @@#include <linux/slab.h> #include <linux/spinlock.h> #include <linux/types.h> +#include <linux/workqueue.h> #include <acpi/pcc.h>
@@ -39,6 +41,16 @@ struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +static int mpam_cpuhp_state; +static DEFINE_MUTEX (mpam_cpuhp_state_lock); + +/* +* mpam is enabled once all devices have been probed from CPU online callbacks, +* scheduled via this work_struct. If access to an MSC depends on a CPU that +* was not brought online at boot, this can happen surprisingly late. +*/ +static DECLARE_WORK(mpam_enable_work, &mpam_enable); +/* * An MSC is a physical container for controls and monitors, each identified by * their RIS index. These share a base-address, interrupts and some MMIO
@@ -78,6 +90,22 @@ LIST_HEAD(mpam_classes);/* List of all objects that can be free()d after synchronise_srcu() */ static LLIST_HEAD (mpam_garbage); +static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) +{ +WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility)); + +return readl_relaxed (msc->mapped_hwpage + reg); +} + +static inline u32 _mpam_read_partsel_reg (struct mpam_msc *msc,u16 reg) +{ +lockdep_assert_held_once (&msc->part_sel_lock); +return __mpam_read_reg (msc, reg); +} + +#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *
@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } -static void mpam_discovery_complete (void ) +static int mpam_msc_hw_probe (struct mpam_msc *msc) +{ +u64 idr; +int err; + +lockdep_assert_held (&msc->probe_lock); + +mutex_lock (&msc->part_sel_lock); + idr =mpam_read_partsel_reg (msc,AIDR ); +if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) { +pr_err_once ("%s does not match MPAM architecture v1.x\n" , +dev_name (&msc->pdev->dev)); + err = -EIO ; + }else { + msc->probed = true; + err =0 ; + } +mutex_unlock (&msc->part_sel_lock); + +return err; +} + +static int mpam_cpu_online (unsigned int cpu) { -pr_err ("Discovered all MSC\n" ); +return 0 ; +} + +/* Before mpam is enabled, try to probe new MSC */ +static int mpam_discovery_cpu_online (unsigned int cpu) +{ +int err =0 ; +struct mpam_msc *msc; +bool new_device_probed = false; + +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +mutex_lock (&msc->probe_lock); +if (!msc->probed) + err =mpam_msc_hw_probe (msc); +mutex_unlock (&msc->probe_lock); + +if (!err) + new_device_probed = true; +else +break ;// mpam_broken + } +mutex_unlock (&mpam_list_lock); + +if (new_device_probed && !err) +schedule_work (&mpam_enable_work); + +return err; +} + +static int mpam_cpu_offline (unsigned int cpu) +{ +return 0 ; +} + +static void mpam_register_cpuhp_callbacks (int (*online)(unsigned int online), +int (*offline)(unsigned int offline)) +{ +mutex_lock (&mpam_cpuhp_state_lock); +if (mpam_cpuhp_state) { +cpuhp_remove_state (mpam_cpuhp_state); + mpam_cpuhp_state =0 ; + } + + mpam_cpuhp_state =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"mpam:online" , + online, offline); +if (mpam_cpuhp_state <=0 ) { +pr_err ("Failed to register cpuhp callbacks" ); + mpam_cpuhp_state =0 ; + } +mutex_unlock (&mpam_cpuhp_state_lock); }static int mpam_dt_count_msc (void )
@@ -772,7 +875,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) }if (!err && fw_num_msc == mpam_num_msc) -mpam_discovery_complete (); +mpam_register_cpuhp_callbacks (&mpam_discovery_cpu_online,NULL );if (err && msc)mpam_msc_drv_remove (pdev);
@@ -795,6 +898,41 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +static void mpam_enable_once (void ) +{ +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); + +pr_info ("MPAM enabled\n" ); +} + +/* +* Enable mpam once all devices have been probed. +* Scheduled by mpam_discovery_cpu_online() once all devices have been created. +* Also scheduled when new devices are probed when new CPUs come online. +*/ +void mpam_enable (struct work_struct *work) +{ +static atomic_t once; +struct mpam_msc *msc; +bool all_devices_probed = true; + +/* Have we probed all the hw devices? */ +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +mutex_lock (&msc->probe_lock); +if (!msc->probed) + all_devices_probed = false; +mutex_unlock (&msc->probe_lock); + +if (!all_devices_probed) +break ; + } +mutex_unlock (&mpam_list_lock); + +if (all_devices_probed && !atomic_fetch_inc (&once)) +mpam_enable_once (); +} +/* * MSC that are hidden under caches are not created as platform devices * as there is no cache driver. Caches are also special-cased in
drivers/resctrl/mpam_internal.h +6 -2
@@ -49,6 +49,7 @@ struct mpam_msc {* properties become read-only and the lists are protected by SRCU. */ struct mutex probe_lock; +bool probed;unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;
@@ -59,14 +60,14 @@ struct mpam_msc {* part_sel_lock protects access to the MSC hardware registers that are * affected by MPAMCFG_PART_SEL. (including the ID registers that vary * by RIS). -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first. */ struct mutex part_sel_lock;/* * mon_sel_lock protects access to the MSC hardware registers that are * affeted by MPAMCFG_MON_SEL. -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock;raw_spinlock_t inner_mon_sel_lock;
@@ -147,6 +148,9 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +/* Scheduled work callback to enable mpam once all MSC have been probed */ +void mpam_enable (struct work_struct *work); +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity);
Signature · 1 line
2.20.1
Rob Herring
maintainerRe: [PATCH 14/33] arm_mpam: Add cpuhp callbacks to probe MSC hardware
Quoted 61 lines · James Morse
Because an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
Enabling a static key will also take the cpuhp lock, so can't be done from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
CC Lecopzer Chen <[email protected]>Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 144 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 8 +- 2 files changed, 147 insertions(+), 5 deletions(-)drivers/resctrl/mpam_devices.c +12
-0@@ -4,6 +4,7 @@#define pr_fmt (fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__#include <linux/acpi.h> +#include <linux/atomic.h> #include <linux/arm_mpam.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> @@ -21,6 +22,7 @@#include <linux/slab.h> #include <linux/spinlock.h> #include <linux/types.h> +#include <linux/workqueue.h> #include <acpi/pcc.h> @@ -39,6 +41,16 @@ struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +static int mpam_cpuhp_state; +static DEFINE_MUTEX (mpam_cpuhp_state_lock); + +/* +* mpam is enabled once all devices have been probed from CPU online callbacks, +* scheduled via this work_struct. If access to an MSC depends on a CPU that +* was not brought online at boot, this can happen surprisingly late. +*/ +static DECLARE_WORK(mpam_enable_work, &mpam_enable); +/* * An MSC is a physical container for controls and monitors, each identified by * their RIS index. These share a base-address, interrupts and some MMIO
drivers/resctrl/mpam_devices.c LIST_HEAD(mpam_classes); · line 96
Quoted 7 lines
drivers/resctrl/mpam_devices.c +4
-0@@ -78,6 +90,22 @@ LIST_HEAD(mpam_classes);/* List of all objects that can be free()d after synchronise_srcu() */ static LLIST_HEAD (mpam_garbage); +static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) +{ +WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility));
These either make __mpam_read_reg uninlined or add 2 checks to every register read. Neither seems very good.
drivers/resctrl/mpam_devices.c LIST_HEAD(mpam_classes); · line 103
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+ +return readl_relaxed (msc->mapped_hwpage + reg); +} + +static inline u32 _mpam_read_partsel_reg (struct mpam_msc *msc,u16 reg) +{ +lockdep_assert_held_once (&msc->part_sel_lock);
Similar thing here.
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 514
Quoted 13 lines
drivers/resctrl/mpam_devices.c +5
-1+return __mpam_read_reg (msc, reg); +} + +#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } -static void mpam_discovery_complete (void )
It is annoying to review things which disappear in later patches...
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 550
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static int mpam_msc_hw_probe (struct mpam_msc *msc) +{ +u64 idr; +int err; + +lockdep_assert_held (&msc->probe_lock); + +mutex_lock (&msc->part_sel_lock); + idr =mpam_read_partsel_reg (msc,AIDR );
I don't think AIDR access depends on PART_SEL.
Quoted 137 lines
drivers/resctrl/mpam_devices.c +104
-2+if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) { +pr_err_once ("%s does not match MPAM architecture v1.x\n" , +dev_name (&msc->pdev->dev)); + err = -EIO ; + }else { + msc->probed = true; + err =0 ; + } +mutex_unlock (&msc->part_sel_lock); + +return err; +} + +static int mpam_cpu_online (unsigned int cpu) { -pr_err ("Discovered all MSC\n" ); +return 0 ; +} + +/* Before mpam is enabled, try to probe new MSC */ +static int mpam_discovery_cpu_online (unsigned int cpu) +{ +int err =0 ; +struct mpam_msc *msc; +bool new_device_probed = false; + +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +mutex_lock (&msc->probe_lock); +if (!msc->probed) + err =mpam_msc_hw_probe (msc); +mutex_unlock (&msc->probe_lock); + +if (!err) + new_device_probed = true; +else +break ;// mpam_broken + } +mutex_unlock (&mpam_list_lock); + +if (new_device_probed && !err) +schedule_work (&mpam_enable_work); + +return err; +} + +static int mpam_cpu_offline (unsigned int cpu) +{ +return 0 ; +} + +static void mpam_register_cpuhp_callbacks (int (*online)(unsigned int online), +int (*offline)(unsigned int offline)) +{ +mutex_lock (&mpam_cpuhp_state_lock); +if (mpam_cpuhp_state) { +cpuhp_remove_state (mpam_cpuhp_state); + mpam_cpuhp_state =0 ; + } + + mpam_cpuhp_state =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"mpam:online" , + online, offline); +if (mpam_cpuhp_state <=0 ) { +pr_err ("Failed to register cpuhp callbacks" ); + mpam_cpuhp_state =0 ; + } +mutex_unlock (&mpam_cpuhp_state_lock); }static int mpam_dt_count_msc (void )@@ -772,7 +875,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) }if (!err && fw_num_msc == mpam_num_msc) -mpam_discovery_complete (); +mpam_register_cpuhp_callbacks (&mpam_discovery_cpu_online,NULL );if (err && msc)mpam_msc_drv_remove (pdev);@@ -795,6 +898,41 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +static void mpam_enable_once (void ) +{ +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); + +pr_info ("MPAM enabled\n" ); +} + +/* +* Enable mpam once all devices have been probed. +* Scheduled by mpam_discovery_cpu_online() once all devices have been created. +* Also scheduled when new devices are probed when new CPUs come online. +*/ +void mpam_enable (struct work_struct *work) +{ +static atomic_t once; +struct mpam_msc *msc; +bool all_devices_probed = true; + +/* Have we probed all the hw devices? */ +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +mutex_lock (&msc->probe_lock); +if (!msc->probed) + all_devices_probed = false; +mutex_unlock (&msc->probe_lock); + +if (!all_devices_probed) +break ; + } +mutex_unlock (&mpam_list_lock); + +if (all_devices_probed && !atomic_fetch_inc (&once)) +mpam_enable_once (); +} +/* * MSC that are hidden under caches are not created as platform devices * as there is no cache driver. Caches are also special-cased in drivers/resctrl/mpam_internal.h +1
-0@@ -49,6 +49,7 @@ struct mpam_msc {* properties become read-only and the lists are protected by SRCU. */ struct mutex probe_lock; +bool probed;unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 63
Quoted 5 lines
drivers/resctrl/mpam_internal.h +1
-1@@ -59,14 +60,14 @@ struct mpam_msc {* part_sel_lock protects access to the MSC hardware registers that are * affected by MPAMCFG_PART_SEL. (including the ID registers that vary * by RIS). -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first.
Humm. I think this belongs in patch 10.
Quoted 24 lines
drivers/resctrl/mpam_internal.h +4
-2*/ struct mutex part_sel_lock;/* * mon_sel_lock protects access to the MSC hardware registers that are * affeted by MPAMCFG_MON_SEL. -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock;raw_spinlock_t inner_mon_sel_lock;@@ -147,6 +148,9 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +/* Scheduled work callback to enable mpam once all MSC have been probed */ +void mpam_enable (struct work_struct *work); +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity); --2.20.1
James Morse
maintainerRe: [PATCH 14/33] arm_mpam: Add cpuhp callbacks to probe MSC hardware
Hi Rob,
Quoted 25 lines · Rob Herring
Quoted 24 lines · James Morse
Because an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
Enabling a static key will also take the cpuhp lock, so can't be done from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
drivers/resctrl/mpam_devices.c +0
-0@@ -78,6 +90,22 @@ LIST_HEAD(mpam_classes);/* List of all objects that can be free()d after synchronise_srcu() */ static LLIST_HEAD (mpam_garbage);
Quoted 7 lines
drivers/resctrl/mpam_devices.c LIST_HEAD(mpam_classes); · line 96
Quoted 4 lines
drivers/resctrl/mpam_devices.c +4
-0+static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) +{ +WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility));These either make
__mpam_read_reguninlined or add 2 checks to every register read. Neither seems very good.
The mapping-bounds one is from before the ACPI table had the size of the mapping. I can remove that one now.
The accessibility one really needs checking as getting this wrong will only occasionally cause a deadlock if you get unlucky with power-management. I don't think we'd ever manage to debug that, hence the check. The server platforms we'll see first aren't going to bother with PSCI CPU_SUSPEND - but mobile devices will.
If the compiler choses not to inline this, I'm fine with that. Accesses to the device mapped configuration are rare, and always via a resctrl filesystem access. I don't think the performance matters.
Quoted 9 lines
drivers/resctrl/mpam_devices.c LIST_HEAD(mpam_classes); · line 103
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+ +return readl_relaxed (msc->mapped_hwpage + reg); +} + +static inline u32 _mpam_read_partsel_reg (struct mpam_msc *msc,u16 reg) +{ +lockdep_assert_held_once (&msc->part_sel_lock);Similar thing here.
If don't build with lockdep this costs you nothing.
Quoted 7 lines
Quoted 7 lines
drivers/resctrl/mpam_devices.c +5
-0+return __mpam_read_reg (msc, reg); +} + +#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +#define init_garbage (x) init_llist_node(&(x)->garbage.llist)
Quoted 8 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 514
Quoted 6 lines
drivers/resctrl/mpam_devices.c +0
-1static struct mpam_vmsc *@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } -static void mpam_discovery_complete (void )It is annoying to review things which disappear in later patches...
It's a printk - its purpose was to show something happens once all the MSC have been probed. That was supposed to make it easier to review as it has always has this shape from the beginning. This patch adds the hardware accesses that do the probing, which happen from cpuhp calls - which in turn moves this 'complete' work to be scheduled. As this seems to be causing confusion I'll inline it so it doesn't look strange.
Quoted 11 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 550
Quoted 9 lines
drivers/resctrl/mpam_devices.c +9
-0+static int mpam_msc_hw_probe (struct mpam_msc *msc) +{ +u64 idr; +int err; + +lockdep_assert_held (&msc->probe_lock); + +mutex_lock (&msc->part_sel_lock); + idr =mpam_read_partsel_reg (msc,AIDR );I don't think AIDR access depends on
PART_SEL.
It doesn't, but as most registers do, it was just simpler to pretend it does.
I'll shove the __version in here instead, which will save taking the lock.
Quoted 13 lines
Quoted 12 lines
drivers/resctrl/mpam_devices.c +12
-0+if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) { +pr_err_once ("%s does not match MPAM architecture v1.x\n" , +dev_name (&msc->pdev->dev)); + err = -EIO ; + }else { + msc->probed = true; + err =0 ; + } +mutex_unlock (&msc->part_sel_lock); + +return err; +}
Quoted 12 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 63
Quoted 10 lines
drivers/resctrl/mpam_internal.h +1
-1@@ -59,14 +60,14 @@ struct mpam_msc {* part_sel_lock protects access to the MSC hardware registers that are * affected by MPAMCFG_PART_SEL. (including the ID registers that vary * by RIS). -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first. Humm. I think this belongs in patch 10.
Yup, fixed.
Thanks,
James
Re: [PATCH 14/33] arm_mpam: Add cpuhp callbacks to probe MSC hardware
In reply to James MorseHi James,
Quoted 7 lines · James Morse
Because an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
It may be worth mentioning that the low-level MSC register accessors are added by this patch.
Quoted 2 lines
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
I misread this is as meaning "later in the patch series" and got confused.
Perhaps, something like the following? (though this got a bit verbose)
--8<--
Once all MSCs reported by the firmware have been probed from a CPU in their respective cpu-affinity set, the probe-time cpuhp callbacks are replaced. The replacement callbacks will ultimately need to handle save/restore of the runtime MSC state across power transitions, but for now there is nothing to do in them: so do nothing.
-->8--
Quoted 1 line
Enabling a static key will also take the cpuhp lock, so can't be done
What static key?
None in this patch that I can see.
Quoted 11 lines
from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
CC Lecopzer Chen <[email protected]>Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 144 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 8 +- 2 files changed, 147 insertions(+), 5 deletions(-)drivers/resctrl/mpam_devices.c +0
-0
[...]
Quoted 1 line
drivers/resctrl/mpam_devices.c +0
-0@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,
[...]
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 516
Quoted 3 lines
drivers/resctrl/mpam_devices.c +1
-1+static int mpam_cpu_online (unsigned int cpu) { -pr_err ("Discovered all MSC\n" );
I guess this disappears later?
If we print anything, it feels like it should be in the mpam_enable_once() path, otherwise it looks like dmesg is going to get spammed on every hotplug. I might have missed something, here.
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 576
Quoted 11 lines
drivers/resctrl/mpam_devices.c +11
-0+return 0 ; +} + +/* Before mpam is enabled, try to probe new MSC */ +static int mpam_discovery_cpu_online (unsigned int cpu) +{ +int err =0 ; +struct mpam_msc *msc; +bool new_device_probed = false; + +mutex_lock (&mpam_list_lock);
I take it nothing breaks if we sleep here?
Pending cpuhp callbacks for this CPU look to be blocked while we sleep, at the very least.
Since this only happens during the probing phase, maybe that's not such a big deal.
Is it likely that some late CPUs might be left offline indefinitely?
If so, we might end up doing futile work here forever.
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 589
Quoted 13 lines
drivers/resctrl/mpam_devices.c +13
-0+list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +mutex_lock (&msc->probe_lock); +if (!msc->probed) + err =mpam_msc_hw_probe (msc); +mutex_unlock (&msc->probe_lock); + +if (!err) + new_device_probed = true; +else +break ;// mpam_broken
What's the effect of returning a non-zero value to the CPU hotplug callback dispatcher here?
Do we want to tear anything down if MPAM is unusable?
Quoted 17 lines
drivers/resctrl/mpam_devices.c +17
-0+ } +mutex_unlock (&mpam_list_lock); + +if (new_device_probed && !err) +schedule_work (&mpam_enable_work); + +return err; +} + +static int mpam_cpu_offline (unsigned int cpu) +{ +return 0 ; +} + +static void mpam_register_cpuhp_callbacks (int (*online)(unsigned int online), +int (*offline)(unsigned int offline)) +{
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 616
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+mutex_lock (&mpam_cpuhp_state_lock); +if (mpam_cpuhp_state) { +cpuhp_remove_state (mpam_cpuhp_state); + mpam_cpuhp_state =0 ; + } + + mpam_cpuhp_state =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"mpam:online" , + online, offline); +if (mpam_cpuhp_state <=0 ) { +pr_err ("Failed to register cpuhp callbacks" );
Should an error code be returned to the caller if this fails?
drivers/resctrl/mpam_devices.c static int mpam_msc_drv_probe(struct platform_device *pdev) · line 878
Quoted 12 lines
drivers/resctrl/mpam_devices.c +4
-1+ mpam_cpuhp_state =0 ; + } +mutex_unlock (&mpam_cpuhp_state_lock); }static int mpam_dt_count_msc (void )@@ -772,7 +875,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) }if (!err && fw_num_msc == mpam_num_msc) -mpam_discovery_complete (); +mpam_register_cpuhp_callbacks (&mpam_discovery_cpu_online,NULL );
Abandon probing the MSC if this fails?
(However, the next phase of probing hangs off CPU hotplug, so it just won't happen if the callbacks can't be registered -- but it looks like MPAM may be left in a half-probed state. I'm not entirely convinced that this matters if the MPAM driver is not unloadable anyway...)
Nit: redundant &
(You don't have it in the similar call in mpam_enable_once().)
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 903
Quoted 10 lines
drivers/resctrl/mpam_devices.c +3
-0if (err && msc)mpam_msc_drv_remove (pdev);@@ -795,6 +898,41 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +static void mpam_enable_once (void ) +{ +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline);
Should it be fatal if this fails?
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 915
Quoted 12 lines
drivers/resctrl/mpam_devices.c +12
-0+ +pr_info ("MPAM enabled\n" ); +} + +/* +* Enable mpam once all devices have been probed. +* Scheduled by mpam_discovery_cpu_online() once all devices have been created. +* Also scheduled when new devices are probed when new CPUs come online. +*/ +void mpam_enable (struct work_struct *work) +{ +static atomic_t once;
Nit: possibly unnecessary atomic_t? This is slow-path code, and we already have to take mpam_list_lock. Harmless, though.
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 928
Quoted 13 lines
drivers/resctrl/mpam_devices.c +13
-0+struct mpam_msc *msc; +bool all_devices_probed = true; + +/* Have we probed all the hw devices? */ +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +mutex_lock (&msc->probe_lock); +if (!msc->probed) + all_devices_probed = false; +mutex_unlock (&msc->probe_lock); + +if (!all_devices_probed) +break ;
WARN()?
We counted the MSCs in via the mpam_discovery_cpu_online(), so I think we shouldn't get in here if some failed to probe?
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 934
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+ } +mutex_unlock (&mpam_list_lock); + +if (all_devices_probed && !atomic_fetch_inc (&once)) +mpam_enable_once (); +}
[...]
Cheers
---Dave
James Morse
maintainerRe: [PATCH 14/33] arm_mpam: Add cpuhp callbacks to probe MSC hardware
Hi Dave,
Quoted 11 lines · Dave Martin
Quoted 7 lines · James Morse
Because an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
It may be worth mentioning that the low-level MSC register accessors are added by this patch.
Sure,
Quoted 10 lines
Quoted 2 lines
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
I misread this is as meaning "later in the patch series" and got confused.
Perhaps, something like the following? (though this got a bit verbose)
--8<--
Quoted 7 lines
Once all MSCs reported by the firmware have been probed from a CPU in their respective cpu-affinity set, the probe-time cpuhp callbacks are replaced. The replacement callbacks will ultimately need to handle save/restore of the runtime MSC state across power transitions, but for now there is nothing to do in them: so do nothing.
-->8--
Done.
Quoted 3 lines
Quoted 1 line
Enabling a static key will also take the cpuhp lock, so can't be done
What static key?
The one that enables the architectures context-switch code. That was added by an earlier patch, but got moved later to reduce the number of trees that this series touches. (also, there is no point having the context switch code if you can't have different values until the resctrl code shows up.)
This is trying to describe why mpam_enable() is scheduled, instead of just being called in cpuhp context. (again - to reduce the churn caused by changing that later).
I'll rephrase it as:
| The architecture's context switch code will be enabled by a static-key, this can be set | by mpam_enable(), but must be done from process context, not a cpuhp callback because | both take the cpuhp lock. | Whenever a new MSC has been probed, the mpam_enable() work is scheduled to test if all | the MSCs have been probed.
Quoted 20 lines
None in this patch that I can see.
Quoted 5 lines
from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
drivers/resctrl/mpam_devices.c +0
-0[...]
Quoted 1 line
drivers/resctrl/mpam_devices.c +0
-0@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,[...]
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 516
Quoted 3 lines
drivers/resctrl/mpam_devices.c +1
-1+static int mpam_cpu_online (unsigned int cpu) { -pr_err ("Discovered all MSC\n" );I guess this disappears later?
Quoted 3 lines
If we print anything, it feels like it should be in the
mpam_enable_once()path, otherwise it looks like dmesg is going to get spammed on every hotplug. I might have missed something, here.
Yes - there is a print that happens on the mpam_enable_once() path that shows the number of PARTID/PMG discovered. That "Discovered all MSC" message was so that probing had this shape from the very beginning - it is unfortunately not as simple as probing a stand-alone driver.
Quoted 5 lines
Quoted 5 lines
drivers/resctrl/mpam_devices.c +5
-0+return 0 ; +} + +/* Before mpam is enabled, try to probe new MSC */ +static int mpam_discovery_cpu_online (unsigned int cpu)
Quoted 8 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 576
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+{ +int err =0 ; +struct mpam_msc *msc; +bool new_device_probed = false; + +mutex_lock (&mpam_list_lock);I take it nothing breaks if we sleep here?
From memory, callbacks registered at CPUHP_AP_ONLINE_DYN are allowed to sleep. There is some point in the state machine where you can't. I can't find where this comes from right now...
e.g. resctrl does this in x86's resctrl_arch_online_cpu() and friends.
Quoted 7 lines
Pending cpuhp callbacks for this CPU look to be blocked while we sleep, at the very least.
Since this only happens during the probing phase, maybe that's not such a big deal.Is it likely that some late CPUs might be left offline indefinitely?
Offlined and never come back is certainly something that can happen.
Quoted 1 line
If so, we might end up doing futile work here forever.
It may never probe all the MSC? Yes, that can certainly happen.
But the work only happens when CPUs come online, which is already a major serialising event. There is no cost to run in this 'not done yet' state forever. It's not retrying on a timer or something like that.
Quoted 8 lines
Quoted 8 lines
drivers/resctrl/mpam_devices.c +8
-0+list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +mutex_lock (&msc->probe_lock); +if (!msc->probed) + err =mpam_msc_hw_probe (msc); +mutex_unlock (&msc->probe_lock);
Quoted 8 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 589
Quoted 5 lines
drivers/resctrl/mpam_devices.c +5
-0+ +if (!err) + new_device_probed = true; +else +break ;// mpam_broken What's the effect of returning a non-zero value to the CPU hotplug callback dispatcher here?
I think the dynamically allocated ones can fail without any ill effects, it'll print a message but nothing else will happen. In this case the callbacks are synchronous with the attempt to register them, so it propagates the error back there.
Quoted 1 line
Do we want to tear anything down if MPAM is unusable?
It will keep trying, whereas it could pack up shop completely.
Looks like that '// mpam_broken' is where I intended to schedule the work, but the code doesn't exist this early in the series. I'll pull bits of that earlier.
Quoted 21 lines
Quoted 21 lines
drivers/resctrl/mpam_devices.c +21
-0+ } +mutex_unlock (&mpam_list_lock); + +if (new_device_probed && !err) +schedule_work (&mpam_enable_work); + +return err; +} + +static int mpam_cpu_offline (unsigned int cpu) +{ +return 0 ; +} + +static void mpam_register_cpuhp_callbacks (int (*online)(unsigned int online), +int (*offline)(unsigned int offline)) +{ +mutex_lock (&mpam_cpuhp_state_lock); +if (mpam_cpuhp_state) { +cpuhp_remove_state (mpam_cpuhp_state); + mpam_cpuhp_state =0 ;
Quoted 8 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 616
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+ } + + mpam_cpuhp_state =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"mpam:online" , + online, offline); +if (mpam_cpuhp_state <=0 ) { +pr_err ("Failed to register cpuhp callbacks" );Should an error code be returned to the caller if this fails?
It can fail asynchronously - so any error handling for this is only solves part of the problem, a failure here means at least one of the callbacks ran and returned an error. If we schedule the disable call in the callback then that will take care of tearing the whole thing down.
The cpuhp callbacks don't get registered until all the driver has found all the MSC that firmware described, so there is no race with driver:probing an MSC after the disable call got scheduled which tears the whole thing down.
Quoted 9 lines
Quoted 9 lines
drivers/resctrl/mpam_devices.c +3
-0+ mpam_cpuhp_state =0 ; + } +mutex_unlock (&mpam_cpuhp_state_lock); }static int mpam_dt_count_msc (void )@@ -772,7 +875,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) }
Quoted 5 lines
drivers/resctrl/mpam_devices.c static int mpam_msc_drv_probe(struct platform_device *pdev) · line 878
Quoted 3 lines
drivers/resctrl/mpam_devices.c +1
-1if (!err && fw_num_msc == mpam_num_msc) -mpam_discovery_complete (); +mpam_register_cpuhp_callbacks (&mpam_discovery_cpu_online,NULL );Abandon probing the MSC if this fails?
Any error returned here is most likely to be from mpam_discovery_cpu_online(), but that can also happen asynchronously. Scheduling mpam_disable() is a better approach as it covers the asynchronous case too.
Quoted 4 lines
(However, the next phase of probing hangs off CPU hotplug, so it just won't happen if the callbacks can't be registered -- but it looks like MPAM may be left in a half-probed state. I'm not entirely convinced that this matters if the MPAM driver is not unloadable anyway...)
I'm not at all worried about failing to register the cpuhp callbacks. The space needed for that is pre-allocated, if there isn't enough space, you get a splat from the cpuhp core - and the callbacks never run. No additional/unnecessary work happens - sure the memory didn't get free'd, but the WARN() from cpuhp_reserve_state() should be enough to debug this.
Quoted 3 lines
Nit: redundant &
(You don't have it in the similar call in
mpam_enable_once().)
Done,
Quoted 11 lines
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 903
Quoted 9 lines
drivers/resctrl/mpam_devices.c +3
-0if (err && msc)mpam_msc_drv_remove (pdev);@@ -795,6 +898,41 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +static void mpam_enable_once (void ) +{ +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline);Should it be fatal if this fails?
As above. Once case doesn't matter - and any handling here is incomplete.
Quoted 7 lines
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+ +pr_info ("MPAM enabled\n" ); +} + +/* +* Enable mpam once all devices have been probed. +* Scheduled by mpam_discovery_cpu_online() once all devices have been created.
Quoted 8 lines
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 915
Quoted 5 lines
drivers/resctrl/mpam_devices.c +5
-0+* Also scheduled when new devices are probed when new CPUs come online. +*/ +void mpam_enable (struct work_struct *work) +{ +static atomic_t once;Nit: possibly unnecessary
atomic_t? This is slow-path code, and we already have to takempam_list_lock. Harmless, though.
mpam_enable_once() can't be called under the lock because of the ordering with cpuhp. This just ended up being cleaner. Too much is stuffed under that lock already!
Quoted 7 lines
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+struct mpam_msc *msc; +bool all_devices_probed = true; + +/* Have we probed all the hw devices? */ +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +mutex_lock (&msc->probe_lock);
Quoted 8 lines
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 928
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+if (!msc->probed) + all_devices_probed = false; +mutex_unlock (&msc->probe_lock); + +if (!all_devices_probed) +break ;
WARN()?
Expected condition...
Quoted 2 lines
We counted the MSCs in via the
mpam_discovery_cpu_online(), so I think we shouldn't get in here if some failed to probe?
No we didn't!
We counted them in mpam_msc_drv_probe() before registering the cpuhp callbacks. The cpuhp callbacks run asynchronously, each one schedules mpam_enable() iff it probed a new device. mpam_enable() then has to check if all the devices had been probed.
This is done so that mpam_discovery_cpu_online() only has to take the msc->probe_lock for MSC that it can access - instead of all of them. That was to avoid having something that serialises CPUs coming online ... but mpam_discovery_cpu_online() is taking the list_lock due to an incomplete switch to SRCU. I'll fix that.
Quoted 6 lines
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 934
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+ } +mutex_unlock (&mpam_list_lock); + +if (all_devices_probed && !atomic_fetch_inc (&once)) +mpam_enable_once (); +}
Thanks,
James
Re: [PATCH 14/33] arm_mpam: Add cpuhp callbacks to probe MSC hardware
In reply to James MorseHi James,
While I'm here:
Quoted 26 lines · James Morse
Because an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
Enabling a static key will also take the cpuhp lock, so can't be done from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
CC Lecopzer Chen <[email protected]>Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 144 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 8 +- 2 files changed, 147 insertions(+), 5 deletions(-)drivers/resctrl/mpam_devices.c +0
-0
[...]
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 545
Quoted 9 lines
drivers/resctrl/mpam_devices.c +4
-1@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } -static void mpam_discovery_complete (void ) +static int mpam_msc_hw_probe (struct mpam_msc *msc) +{ +u64 idr; +int err;
Redundant variable which gets removed again in the next patch?
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+ +lockdep_assert_held (&msc->probe_lock); + +mutex_lock (&msc->part_sel_lock); + idr =mpam_read_partsel_reg (msc,AIDR ); +if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) { + pr_err_once("%s does not match MPAM architecture v1.x\n",
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 562
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+ dev_name(&msc->pdev->dev)); + err = -EIO ; + }else { + msc->probed = true; + err =0 ; + } +mutex_unlock (&msc->part_sel_lock); + +return err; +}
[...]
Cheers
---Dave
James Morse
maintainerPATCH 14/33 arm_mpam: Add cpuhp callbacks to probe MSC hardware
In reply to James MorseBecause an MSC can only by accessed from the CPUs in its cpu-affinity set we need to be running on one of those CPUs to probe the MSC hardware.
Do this work in the cpuhp callback. Probing the hardware will only happen before MPAM is enabled, walk all the MSCs and probe those we can reach that haven't already been probed.
Later once MPAM is enabled, this cpuhp callback will be replaced by one that avoids the global list.
Enabling a static key will also take the cpuhp lock, so can't be done from the cpuhp callback. Whenever a new MSC has been probed schedule work to test if all the MSCs have now been probed.
--- drivers/resctrl/mpam_devices.c | 144 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 8 +- 2 files changed, 147 insertions(+), 5 deletions(-)
drivers/resctrl/mpam_devices.c +141 -3
@@ -4,6 +4,7 @@#define pr_fmt (fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__#include <linux/acpi.h> +#include <linux/atomic.h> #include <linux/arm_mpam.h> #include <linux/cacheinfo.h> #include <linux/cpu.h>
@@ -21,6 +22,7 @@#include <linux/slab.h> #include <linux/spinlock.h> #include <linux/types.h> +#include <linux/workqueue.h> #include <acpi/pcc.h>
@@ -39,6 +41,16 @@ struct srcu_struct mpam_srcu;/* MPAM isn't available until all the MSC have been probed. */ static u32 mpam_num_msc; +static int mpam_cpuhp_state; +static DEFINE_MUTEX (mpam_cpuhp_state_lock); + +/* +* mpam is enabled once all devices have been probed from CPU online callbacks, +* scheduled via this work_struct. If access to an MSC depends on a CPU that +* was not brought online at boot, this can happen surprisingly late. +*/ +static DECLARE_WORK(mpam_enable_work, &mpam_enable); +/* * An MSC is a physical container for controls and monitors, each identified by * their RIS index. These share a base-address, interrupts and some MMIO
@@ -78,6 +90,22 @@ LIST_HEAD(mpam_classes);/* List of all objects that can be free()d after synchronise_srcu() */ static LLIST_HEAD (mpam_garbage); +static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) +{ +WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility)); + +return readl_relaxed (msc->mapped_hwpage + reg); +} + +static inline u32 _mpam_read_partsel_reg (struct mpam_msc *msc,u16 reg) +{ +lockdep_assert_held_once (&msc->part_sel_lock); +return __mpam_read_reg (msc, reg); +} + +#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *
@@ -511,9 +539,84 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } -static void mpam_discovery_complete (void ) +static int mpam_msc_hw_probe (struct mpam_msc *msc) +{ +u64 idr; +int err; + +lockdep_assert_held (&msc->probe_lock); + +mutex_lock (&msc->part_sel_lock); + idr =mpam_read_partsel_reg (msc,AIDR ); +if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) { +pr_err_once ("%s does not match MPAM architecture v1.x\n" , +dev_name (&msc->pdev->dev)); + err = -EIO ; + }else { + msc->probed = true; + err =0 ; + } +mutex_unlock (&msc->part_sel_lock); + +return err; +} + +static int mpam_cpu_online (unsigned int cpu) { -pr_err ("Discovered all MSC\n" ); +return 0 ; +} + +/* Before mpam is enabled, try to probe new MSC */ +static int mpam_discovery_cpu_online (unsigned int cpu) +{ +int err =0 ; +struct mpam_msc *msc; +bool new_device_probed = false; + +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +mutex_lock (&msc->probe_lock); +if (!msc->probed) + err =mpam_msc_hw_probe (msc); +mutex_unlock (&msc->probe_lock); + +if (!err) + new_device_probed = true; +else +break ;// mpam_broken + } +mutex_unlock (&mpam_list_lock); + +if (new_device_probed && !err) +schedule_work (&mpam_enable_work); + +return err; +} + +static int mpam_cpu_offline (unsigned int cpu) +{ +return 0 ; +} + +static void mpam_register_cpuhp_callbacks (int (*online)(unsigned int online), +int (*offline)(unsigned int offline)) +{ +mutex_lock (&mpam_cpuhp_state_lock); +if (mpam_cpuhp_state) { +cpuhp_remove_state (mpam_cpuhp_state); + mpam_cpuhp_state =0 ; + } + + mpam_cpuhp_state =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"mpam:online" , + online, offline); +if (mpam_cpuhp_state <=0 ) { +pr_err ("Failed to register cpuhp callbacks" ); + mpam_cpuhp_state =0 ; + } +mutex_unlock (&mpam_cpuhp_state_lock); }static int mpam_dt_count_msc (void )
@@ -772,7 +875,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) }if (!err && fw_num_msc == mpam_num_msc) -mpam_discovery_complete (); +mpam_register_cpuhp_callbacks (&mpam_discovery_cpu_online,NULL );if (err && msc)mpam_msc_drv_remove (pdev);
@@ -795,6 +898,41 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +static void mpam_enable_once (void ) +{ +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); + +pr_info ("MPAM enabled\n" ); +} + +/* +* Enable mpam once all devices have been probed. +* Scheduled by mpam_discovery_cpu_online() once all devices have been created. +* Also scheduled when new devices are probed when new CPUs come online. +*/ +void mpam_enable (struct work_struct *work) +{ +static atomic_t once; +struct mpam_msc *msc; +bool all_devices_probed = true; + +/* Have we probed all the hw devices? */ +mutex_lock (&mpam_list_lock); +list_for_each_entry (msc, &mpam_all_msc, glbl_list) { +mutex_lock (&msc->probe_lock); +if (!msc->probed) + all_devices_probed = false; +mutex_unlock (&msc->probe_lock); + +if (!all_devices_probed) +break ; + } +mutex_unlock (&mpam_list_lock); + +if (all_devices_probed && !atomic_fetch_inc (&once)) +mpam_enable_once (); +} +/* * MSC that are hidden under caches are not created as platform devices * as there is no cache driver. Caches are also special-cased in
drivers/resctrl/mpam_internal.h +6 -2
@@ -49,6 +49,7 @@ struct mpam_msc {* properties become read-only and the lists are protected by SRCU. */ struct mutex probe_lock; +bool probed;unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;
@@ -59,14 +60,14 @@ struct mpam_msc {* part_sel_lock protects access to the MSC hardware registers that are * affected by MPAMCFG_PART_SEL. (including the ID registers that vary * by RIS). -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first. */ struct mutex part_sel_lock;/* * mon_sel_lock protects access to the MSC hardware registers that are * affeted by MPAMCFG_MON_SEL. -* If needed, take msc->lock first. +* If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock;raw_spinlock_t inner_mon_sel_lock;
@@ -147,6 +148,9 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +/* Scheduled work callback to enable mpam once all MSC have been probed */ +void mpam_enable (struct work_struct *work); +int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity);
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 15/33 arm_mpam: Probe MSCs to find the supported partid/pmg values
In reply to James MorseCPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create under MPAM_CLASS_UNKNOWN.
While we're here, implement the mpam_register_requestor() call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.
--- drivers/resctrl/mpam_devices.c | 158 ++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 6 ++ include/linux/arm_mpam.h | 14 +++ 3 files changed, 171 insertions(+), 7 deletions(-)
drivers/resctrl/mpam_devices.c +151 -7
@@ -6,6 +6,7 @@#include <linux/acpi.h> #include <linux/atomic.h> #include <linux/arm_mpam.h> +#include <linux/bitfield.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h>
@@ -44,6 +45,15 @@ static u32 mpam_num_msc;static int mpam_cpuhp_state;static DEFINE_MUTEX (mpam_cpuhp_state_lock); +/* +* The smallest common values for any CPU or MSC in the system. +* Generating traffic outside this range will result in screaming interrupts. +*/ +u16 mpam_partid_max; +u8 mpam_pmg_max; +static bool partid_max_init, partid_max_published; +static DEFINE_SPINLOCK (partid_max_lock); +/* * mpam is enabled once all devices have been probed from CPU online callbacks, * scheduled via this work_struct. If access to an MSC depends on a CPU that
@@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg)#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +static void __mpam_write_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility)); + +writel_relaxed (val, msc->mapped_hwpage + reg); +} + +static inline void _mpam_write_partsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +lockdep_assert_held_once (&msc->part_sel_lock); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) + +static u64 mpam_msc_read_idr (struct mpam_msc *msc) +{ +u64 idr_high =0 , idr_low; + +lockdep_assert_held (&msc->part_sel_lock); + + idr_low =mpam_read_partsel_reg (msc,IDR ); +if (FIELD_GET (MPAMF_IDR_EXT , idr_low)) + idr_high =mpam_read_partsel_reg (msc,IDR +4 ); + +return (idr_high <<32 ) | idr_low; +} + +static void __mpam_part_sel_raw (u32 partsel,struct mpam_msc *msc) +{ +lockdep_assert_held (&msc->part_sel_lock); + +mpam_write_partsel_reg (msc,PART_SEL , partsel); +} + +static void __mpam_part_sel (u8 ris_idx,u16 partid,struct mpam_msc *msc) +{ +u32 partsel =FIELD_PREP (MPAMCFG_PART_SEL_RIS , ris_idx) | +FIELD_PREP (MPAMCFG_PART_SEL_PARTID_SEL , partid); + +__mpam_part_sel_raw (partsel, msc); +} + +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; + +lockdep_assert_irqs_enabled (); + +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) { + mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max); + }else { +/* New requestors can't lower the values */ +if (partid_max < mpam_partid_max || pmg_max < mpam_pmg_max) + err = -EBUSY ; + } +spin_unlock (&partid_max_lock); + +return err; +} +EXPORT_SYMBOL (mpam_register_requestor); +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *
@@ -520,6 +598,7 @@ static int mpam_ris_create_locked(struct mpam_msc *msc, u8 ris_idx,cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity);cpumask_or (&class->affinity, &class->affinity, &ris->affinity);list_add_rcu (&ris->vmsc_list, &vmsc->ris); +list_add_rcu (&ris->msc_list, &msc->ris);return 0 ; }
@@ -539,10 +618,37 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } +static struct mpam_msc_ris *mpam_get_or_create_ris (struct mpam_msc *msc, +u8 ris_idx) +{ +int err; +struct mpam_msc_ris *ris, *found =ERR_PTR (-ENOENT ); + +lockdep_assert_held (&mpam_list_lock); + +if (!test_bit (ris_idx, msc->ris_idxs)) { + err =mpam_ris_create_locked (msc, ris_idx,MPAM_CLASS_UNKNOWN , +0 ,0 ,GFP_ATOMIC ); +if (err) +return ERR_PTR (err); + } + +list_for_each_entry (ris, &msc->ris, msc_list) { +if (ris->ris_idx == ris_idx) { + found = ris; +break ; + } + } + +return found; +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr; -int err; +u16 partid_max; +u8 ris_idx, pmg_max; +struct mpam_msc_ris *ris;lockdep_assert_held (&msc->probe_lock);
@@ -551,14 +657,42 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) {pr_err_once ("%s does not match MPAM architecture v1.x\n" ,dev_name (&msc->pdev->dev)); - err = -EIO ; - }else { - msc->probed = true; - err =0 ; +mutex_unlock (&msc->part_sel_lock); +return -EIO ; } + + idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr); + +/* Use these values so partid/pmg always starts with a valid value */ + msc->partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + msc->pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + +for (ris_idx =0 ; ris_idx <= msc->ris_max; ris_idx++) { +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); + idr =mpam_msc_read_idr (msc); +mutex_unlock (&msc->part_sel_lock); + + partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + msc->partid_max =min (msc->partid_max, partid_max); + msc->pmg_max =min (msc->pmg_max, pmg_max); + + ris =mpam_get_or_create_ris (msc, ris_idx); +if (IS_ERR (ris)) +return PTR_ERR (ris); + } -return err; +spin_lock (&partid_max_lock); + mpam_partid_max =min (mpam_partid_max, msc->partid_max); + mpam_pmg_max =min (mpam_pmg_max, msc->pmg_max); +spin_unlock (&partid_max_lock); + + msc->probed = true; + +return 0 ; }static int mpam_cpu_online (unsigned int cpu)
@@ -900,9 +1034,18 @@ static struct platform_driver mpam_msc_driver = {static void mpam_enable_once (void ) { +/* +* Once the cpuhp callbacks have been changed, mpam_partid_max can no +* longer change. +*/ +spin_lock (&partid_max_lock); + partid_max_published = true; +spin_unlock (&partid_max_lock); +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); -pr_info ("MPAM enabled\n" ); +printk (KERN_INFO "MPAM enabled with %u partid and %u pmg\n" , + mpam_partid_max +1 , mpam_pmg_max +1 ); }/*
@@ -972,4 +1115,5 @@ static int __init mpam_msc_driver_init(void)return platform_driver_register (&mpam_msc_driver); } +/* Must occur after arm64_mpam_register_cpus() from arch_initcall() */ subsys_initcall (mpam_msc_driver_init);
drivers/resctrl/mpam_internal.h +6 -0
@@ -50,6 +50,8 @@ struct mpam_msc {*/ struct mutex probe_lock;bool probed; +u16 partid_max; +u8 pmg_max;unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;
@@ -148,6 +150,10 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +/* System wide partid/pmg values */ +extern u16 mpam_partid_max; +extern u8 mpam_pmg_max; +/* Scheduled work callback to enable mpam once all MSC have been probed */ void mpam_enable (struct work_struct *work);
include/linux/arm_mpam.h +14 -0
@@ -39,4 +39,18 @@ static inline int acpi_mpam_count_msc(void) { return -EINVAL; }int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx,enum mpam_class_types type,u8 class_id,int component_id); +/** +* mpam_register_requestor() - Register a requestor with the MPAM driver +* @partid_max: The maximum PARTID value the requestor can generate. +* @pmg_max: The maximum PMG value the requestor can generate. +* +* Registers a requestor with the MPAM driver to ensure the chosen system-wide +* minimum PARTID and PMG values will allow the requestors features to be used. +* +* Returns an error if the registration is too late, and a larger PARTID/PMG +* value has been advertised to user-space. In this case the requestor should +* not use its MPAM features. Returns 0 on success. +*/ +int mpam_register_requestor (u16 partid_max,u8 pmg_max); +#endif /* __LINUX_ARM_MPAM_H */
Signature · 1 line
2.20.1
Ben Horgan
maintainerRe: [PATCH 15/33] arm_mpam: Probe MSCs to find the supported partid/pmg values
Hi James,
Quoted 98 lines · James Morse
CPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create under
MPAM_CLASS_UNKNOWN.While we're here, implement the
mpam_register_requestor()call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 158 ++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 6 ++ include/linux/arm_mpam.h | 14 +++ 3 files changed, 171 insertions(+), 7 deletions(-)drivers/resctrl/mpam_devices.c +57
-0@@ -6,6 +6,7 @@#include <linux/acpi.h> #include <linux/atomic.h> #include <linux/arm_mpam.h> +#include <linux/bitfield.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h> @@ -44,6 +45,15 @@ static u32 mpam_num_msc;static int mpam_cpuhp_state;static DEFINE_MUTEX (mpam_cpuhp_state_lock); +/* +* The smallest common values for any CPU or MSC in the system. +* Generating traffic outside this range will result in screaming interrupts. +*/ +u16 mpam_partid_max; +u8 mpam_pmg_max; +static bool partid_max_init, partid_max_published; +static DEFINE_SPINLOCK (partid_max_lock); +/* * mpam is enabled once all devices have been probed from CPU online callbacks, * scheduled via this work_struct. If access to an MSC depends on a CPU that @@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg)#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +static void __mpam_write_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility)); + +writel_relaxed (val, msc->mapped_hwpage + reg); +} + +static inline void _mpam_write_partsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +lockdep_assert_held_once (&msc->part_sel_lock); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) + +static u64 mpam_msc_read_idr (struct mpam_msc *msc) +{ +u64 idr_high =0 , idr_low; + +lockdep_assert_held (&msc->part_sel_lock); + + idr_low =mpam_read_partsel_reg (msc,IDR ); +if (FIELD_GET (MPAMF_IDR_EXT , idr_low)) + idr_high =mpam_read_partsel_reg (msc,IDR +4 ); + +return (idr_high <<32 ) | idr_low; +} + +static void __mpam_part_sel_raw (u32 partsel,struct mpam_msc *msc) +{ +lockdep_assert_held (&msc->part_sel_lock); + +mpam_write_partsel_reg (msc,PART_SEL , partsel); +} + +static void __mpam_part_sel (u8 ris_idx,u16 partid,struct mpam_msc *msc) +{ +u32 partsel =FIELD_PREP (MPAMCFG_PART_SEL_RIS , ris_idx) | +FIELD_PREP (MPAMCFG_PART_SEL_PARTID_SEL , partid); + +__mpam_part_sel_raw (partsel, msc); +} + +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; +
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 175
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+lockdep_assert_irqs_enabled (); + +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) { + mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max);
Do we really need to reduce these maximum here? If, say, we add an SMMU requester which supports fewer partids than the cpus don't we want to be able to carry on using those partids from the cpus. In this case the SMMU requestor can, without risk of error interrupts, just use all the partids it supports.
Quoted 172 lines
drivers/resctrl/mpam_devices.c +84
-7+ }else { +/* New requestors can't lower the values */ +if (partid_max < mpam_partid_max || pmg_max < mpam_pmg_max) + err = -EBUSY ; + } +spin_unlock (&partid_max_lock); + +return err; +} +EXPORT_SYMBOL (mpam_register_requestor); +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *@@ -520,6 +598,7 @@ static int mpam_ris_create_locked(struct mpam_msc *msc, u8 ris_idx,cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity);cpumask_or (&class->affinity, &class->affinity, &ris->affinity);list_add_rcu (&ris->vmsc_list, &vmsc->ris); +list_add_rcu (&ris->msc_list, &msc->ris);return 0 ; }@@ -539,10 +618,37 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } +static struct mpam_msc_ris *mpam_get_or_create_ris (struct mpam_msc *msc, +u8 ris_idx) +{ +int err; +struct mpam_msc_ris *ris, *found =ERR_PTR (-ENOENT ); + +lockdep_assert_held (&mpam_list_lock); + +if (!test_bit (ris_idx, msc->ris_idxs)) { + err =mpam_ris_create_locked (msc, ris_idx,MPAM_CLASS_UNKNOWN , +0 ,0 ,GFP_ATOMIC ); +if (err) +return ERR_PTR (err); + } + +list_for_each_entry (ris, &msc->ris, msc_list) { +if (ris->ris_idx == ris_idx) { + found = ris; +break ; + } + } + +return found; +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr; -int err; +u16 partid_max; +u8 ris_idx, pmg_max; +struct mpam_msc_ris *ris;lockdep_assert_held (&msc->probe_lock);@@ -551,14 +657,42 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) {pr_err_once ("%s does not match MPAM architecture v1.x\n" ,dev_name (&msc->pdev->dev)); - err = -EIO ; - }else { - msc->probed = true; - err =0 ; +mutex_unlock (&msc->part_sel_lock); +return -EIO ; } + + idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr); + +/* Use these values so partid/pmg always starts with a valid value */ + msc->partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + msc->pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + +for (ris_idx =0 ; ris_idx <= msc->ris_max; ris_idx++) { +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); + idr =mpam_msc_read_idr (msc); +mutex_unlock (&msc->part_sel_lock); + + partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + msc->partid_max =min (msc->partid_max, partid_max); + msc->pmg_max =min (msc->pmg_max, pmg_max); + + ris =mpam_get_or_create_ris (msc, ris_idx); +if (IS_ERR (ris)) +return PTR_ERR (ris); + } -return err; +spin_lock (&partid_max_lock); + mpam_partid_max =min (mpam_partid_max, msc->partid_max); + mpam_pmg_max =min (mpam_pmg_max, msc->pmg_max); +spin_unlock (&partid_max_lock); + + msc->probed = true; + +return 0 ; }static int mpam_cpu_online (unsigned int cpu)@@ -900,9 +1034,18 @@ static struct platform_driver mpam_msc_driver = {static void mpam_enable_once (void ) { +/* +* Once the cpuhp callbacks have been changed, mpam_partid_max can no +* longer change. +*/ +spin_lock (&partid_max_lock); + partid_max_published = true; +spin_unlock (&partid_max_lock); +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); -pr_info ("MPAM enabled\n" ); +printk (KERN_INFO "MPAM enabled with %u partid and %u pmg\n" , + mpam_partid_max +1 , mpam_pmg_max +1 ); }/* @@ -972,4 +1115,5 @@ static int __init mpam_msc_driver_init(void)return platform_driver_register (&mpam_msc_driver); } +/* Must occur after arm64_mpam_register_cpus() from arch_initcall() */ subsys_initcall (mpam_msc_driver_init);drivers/resctrl/mpam_internal.h +6
-0@@ -50,6 +50,8 @@ struct mpam_msc {*/ struct mutex probe_lock;bool probed; +u16 partid_max; +u8 pmg_max;unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;@@ -148,6 +150,10 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +/* System wide partid/pmg values */ +extern u16 mpam_partid_max; +extern u8 mpam_pmg_max; +/* Scheduled work callback to enable mpam once all MSC have been probed */ void mpam_enable (struct work_struct *work);include/linux/arm_mpam.h +5
-0@@ -39,4 +39,18 @@ static inline int acpi_mpam_count_msc(void) { return -EINVAL; }int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx,enum mpam_class_types type,u8 class_id,int component_id); +/** +* mpam_register_requestor() - Register a requestor with the MPAM driver +* @partid_max: The maximum PARTID value the requestor can generate. +* @pmg_max: The maximum PMG value the requestor can generate. +*
include/linux/arm_mpam.h static inline int acpi_mpam_count_msc(void) { return -EINVAL; } · line 56
Quoted 10 lines
include/linux/arm_mpam.h +9
-0+* Registers a requestor with the MPAM driver to ensure the chosen system-wide +* minimum PARTID and PMG values will allow the requestors features to be used. +* +* Returns an error if the registration is too late, and a larger PARTID/PMG +* value has been advertised to user-space. In this case the requestor should +* not use its MPAM features. Returns 0 on success. +*/ +int mpam_register_requestor (u16 partid_max,u8 pmg_max); +#endif /* __LINUX_ARM_MPAM_H */
Thanks,
Ben
James Morse
maintainerRe: [PATCH 15/33] arm_mpam: Probe MSCs to find the supported partid/pmg values
Hi Ben,
Quoted 31 lines · Ben Horgan
Quoted 30 lines · James Morse
CPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create under
MPAM_CLASS_UNKNOWN.While we're here, implement the
mpam_register_requestor()call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.drivers/resctrl/mpam_devices.c +12
-0@@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; + +lockdep_assert_irqs_enabled (); + +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) {
Quoted 8 lines
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 175
Quoted 2 lines
drivers/resctrl/mpam_devices.c +2
-0+ mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max);Do we really need to reduce these maximum here? If, say, we add an SMMU requester which supports fewer partids than the cpus don't we want to be able to carry on using those partids from the cpus. In this case the SMMU requestor can, without risk of error interrupts, just use all the partids it supports.
How would it do that?
We're probably going to expose that SMMU, or the devices behind it, via resctrl. You can create 10 control groups in resctrl - but can't assign the SMMU/devices to the last two because it doesn't actually support that many...
Thanks,
James
Ben Horgan
maintainerRe: [PATCH 15/33] arm_mpam: Probe MSCs to find the supported partid/pmg values
Hi James,
Quoted 43 lines · James Morse
Hi Ben,
Quoted 31 lines · Ben Horgan
Quoted 30 lines · James Morse
CPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create under
MPAM_CLASS_UNKNOWN.While we're here, implement the
mpam_register_requestor()call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.drivers/resctrl/mpam_devices.c +12
-0@@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; + +lockdep_assert_irqs_enabled (); + +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) {Quoted 8 lines
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 175
Quoted 2 lines
drivers/resctrl/mpam_devices.c +2
-0+ mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max);Do we really need to reduce these maximum here? If, say, we add an SMMU requester which supports fewer partids than the cpus don't we want to be able to carry on using those partids from the cpus. In this case the SMMU requestor can, without risk of error interrupts, just use all the partids it supports.
Quoted 5 lines
How would it do that?
We're probably going to expose that SMMU, or the devices behind it, via resctrl. You can create 10 control groups in resctrl - but can't assign the SMMU/devices to the last two because it doesn't actually support that many...
Ok. If that's how it's going to be exposed to the user then it make sense.
Quoted 5 lines
Thanks,
James
Thanks,
Ben
Re: [PATCH 15/33] arm_mpam: Probe MSCs to find the supported partid/pmg values
In reply to James MorseHi,
Quoted 1 line · James Morse
Subject: Re: [PATCH 15/33]
arm_mpam: Probe MSCs to find the supported partid/pmg values
Summary line does not describe the patch (i.e., the requestor registration interface is something different... and the probing of RIS properties has nothing architecturally to do with determining the max PARTID and PMG values.)
Even regarding the MSC probing, there is considerably more in this patch than just the determination of the ID limits.
Quoted 6 lines
CPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create
Nit: created
Quoted 1 line
under
MPAM_CLASS_UNKNOWN.
What are the effects / implications of this?
Quoted 3 lines
While we're here, implement the
mpam_register_requestor()call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.
This function seems to be dead in this series; registration of CPUs is "future" too. Does it make sense to boot this into the next series?
Quoted 22 lines
Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 158 ++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 6 ++ include/linux/arm_mpam.h | 14 +++ 3 files changed, 171 insertions(+), 7 deletions(-)drivers/resctrl/mpam_devices.c +1
-0@@ -6,6 +6,7 @@#include <linux/acpi.h> #include <linux/atomic.h> #include <linux/arm_mpam.h> +#include <linux/bitfield.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h> @@ -44,6 +45,15 @@ static u32 mpam_num_msc;static int mpam_cpuhp_state;static DEFINE_MUTEX (mpam_cpuhp_state_lock);
drivers/resctrl/mpam_devices.c static u32 mpam_num_msc; · line 56
Quoted 10 lines
drivers/resctrl/mpam_devices.c +9
-0+/* +* The smallest common values for any CPU or MSC in the system. +* Generating traffic outside this range will result in screaming interrupts. +*/ +u16 mpam_partid_max; +u8 mpam_pmg_max; +static bool partid_max_init, partid_max_published; +static DEFINE_SPINLOCK (partid_max_lock); +
Can partid_max and pmg_max simply be statically initialised with the max value of the respective type instead? -1 or ~0 would be adequate initialisers.
This would allow us to get rid of partid_max_init and the associated logic.
This assumes that we don't enable MPAM (and start using nonzero values in MPAM[10]_EL1) unless at least one usable MSC was found, so that the initialiser is not left behing.
I think that's true by construction -- if the firmware reports no MSCs, we probe nothing. Otherwise, we require every MSC reported by the firmware to probe before enabling MPAM.
Quoted 45 lines
drivers/resctrl/mpam_devices.c +38
-0/* * mpam is enabled once all devices have been probed from CPU online callbacks, * scheduled via this work_struct. If access to an MSC depends on a CPU that @@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg)#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +static void __mpam_write_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility)); + +writel_relaxed (val, msc->mapped_hwpage + reg); +} + +static inline void _mpam_write_partsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +lockdep_assert_held_once (&msc->part_sel_lock); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) + +static u64 mpam_msc_read_idr (struct mpam_msc *msc) +{ +u64 idr_high =0 , idr_low; + +lockdep_assert_held (&msc->part_sel_lock); + + idr_low =mpam_read_partsel_reg (msc,IDR ); +if (FIELD_GET (MPAMF_IDR_EXT , idr_low)) + idr_high =mpam_read_partsel_reg (msc,IDR +4 ); + +return (idr_high <<32 ) | idr_low; +} + +static void __mpam_part_sel_raw (u32 partsel,struct mpam_msc *msc) +{ +lockdep_assert_held (&msc->part_sel_lock); + +mpam_write_partsel_reg (msc,PART_SEL , partsel); +} + +static void __mpam_part_sel (u8 ris_idx,u16 partid,struct mpam_msc *msc) +{ + u32 partsel = FIELD_PREP(MPAMCFG_PART_SEL_RIS, ris_idx) |
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 166
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+FIELD_PREP (MPAMCFG_PART_SEL_PARTID_SEL , partid); + +__mpam_part_sel_raw (partsel, msc); +} + +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; + +lockdep_assert_irqs_enabled ();
This is just because we don't use spin_lock_irqsave(), right?
(Just checking my understanding.)
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 179
Quoted 13 lines
drivers/resctrl/mpam_devices.c +13
-0+ +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) { + mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max); + }else { +/* New requestors can't lower the values */ +if (partid_max < mpam_partid_max || pmg_max < mpam_pmg_max) + err = -EBUSY ;
What will actually happen here? Will the arch code reject the offending late secondary?
It feels a bit like we're reinventing part of cpufeatures here -- though I suppose the split between early and late CPUs is not the same as for the kernel proper: the "MPAM early CPUs" are those that have appeared by the time the last MSC probes, which can be a different set than the kernel's early CPUs. So I guess there is no choice but to have some special logic here.
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 185
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+ } +spin_unlock (&partid_max_lock); + +return err; +} +EXPORT_SYMBOL (mpam_register_requestor);
As noted above, dead function (in this series)?
Also, would it be better to split out the common core shared by this and the last stanza of mpam_msc_hw_probe()?
(This common core would make sense in this series even if mpam_register_requestor() is deferred.)
Quoted 15 lines
drivers/resctrl/mpam_devices.c +2
-0+#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *@@ -520,6 +598,7 @@ static int mpam_ris_create_locked(struct mpam_msc *msc, u8 ris_idx,cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity);cpumask_or (&class->affinity, &class->affinity, &ris->affinity);list_add_rcu (&ris->vmsc_list, &vmsc->ris); +list_add_rcu (&ris->msc_list, &msc->ris);return 0 ; }@@ -539,10 +618,37 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; }
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 629
Quoted 10 lines
drivers/resctrl/mpam_devices.c +9
-0+static struct mpam_msc_ris *mpam_get_or_create_ris (struct mpam_msc *msc, +u8 ris_idx) +{ +int err; +struct mpam_msc_ris *ris, *found =ERR_PTR (-ENOENT ); + +lockdep_assert_held (&mpam_list_lock); + +if (!test_bit (ris_idx, msc->ris_idxs)) {
I was a bit puzzled by this.
A comment somewhere might help: if ris_idx wasn't already seen while parsing firmware tables, then there is nothing to tell us what it controls in the hardware: mark it as MPAM_CLASS_UNKNOWN.
(If I understood correctly, that is.)
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 631
Quoted 2 lines
drivers/resctrl/mpam_devices.c +2
-0+ err =mpam_ris_create_locked (msc, ris_idx,MPAM_CLASS_UNKNOWN , +0 ,0 ,GFP_ATOMIC );
It's mildly unfortunate that these allocations are from the GFP_ATOMIC pool. I think we were in regular thread context until we started taking MPAM locks?
But it's a finite amount of memory and not under userspace control, so not a huge deal.
This could possibly be improved later; it doesn't feel critical right now.
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 638
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+if (err) +return ERR_PTR (err); + } + +list_for_each_entry (ris, &msc->ris, msc_list) { +if (ris->ris_idx == ris_idx) { + found = ris;
return ris; (?)
(You could then also delete all the curlies.)
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 545
Quoted 11 lines
drivers/resctrl/mpam_devices.c +7
-1+break ; + } + } + +return found; +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr; -int err;
Churn? (See patch 14.)
Quoted 34 lines
drivers/resctrl/mpam_devices.c +21
-4+u16 partid_max; +u8 ris_idx, pmg_max; +struct mpam_msc_ris *ris;lockdep_assert_held (&msc->probe_lock);@@ -551,14 +657,42 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) {pr_err_once ("%s does not match MPAM architecture v1.x\n" ,dev_name (&msc->pdev->dev)); - err = -EIO ; - }else { - msc->probed = true; - err =0 ; +mutex_unlock (&msc->part_sel_lock); +return -EIO ; } + + idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr); + +/* Use these values so partid/pmg always starts with a valid value */ + msc->partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + msc->pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + +for (ris_idx =0 ; ris_idx <= msc->ris_max; ris_idx++) { +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); + idr =mpam_msc_read_idr (msc); +mutex_unlock (&msc->part_sel_lock); + + partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr);
drivers/resctrl/mpam_devices.c static int mpam_msc_hw_probe(struct mpam_msc *msc) · line 688
Quoted 10 lines
drivers/resctrl/mpam_devices.c +8
-1+ msc->partid_max =min (msc->partid_max, partid_max); + msc->pmg_max =min (msc->pmg_max, pmg_max); + + ris =mpam_get_or_create_ris (msc, ris_idx); +if (IS_ERR (ris)) +return PTR_ERR (ris); + } -return err; +spin_lock (&partid_max_lock);
Can we get in here with partid_max_init = false? Do we need to check / set it? Or, maybe get rid of it; see mpam_partid_max etc.
Quoted 17 lines
drivers/resctrl/mpam_devices.c +10
-0+ mpam_partid_max =min (mpam_partid_max, msc->partid_max); + mpam_pmg_max =min (mpam_pmg_max, msc->pmg_max); +spin_unlock (&partid_max_lock); + + msc->probed = true; + +return 0 ; }static int mpam_cpu_online (unsigned int cpu)@@ -900,9 +1034,18 @@ static struct platform_driver mpam_msc_driver = {static void mpam_enable_once (void ) { +/* +* Once the cpuhp callbacks have been changed, mpam_partid_max can no +* longer change.
drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 1048
Quoted 10 lines
drivers/resctrl/mpam_devices.c +7
-1+*/ +spin_lock (&partid_max_lock); + partid_max_published = true; +spin_unlock (&partid_max_lock); +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); -pr_info ("MPAM enabled\n" ); +printk (KERN_INFO "MPAM enabled with %u partid and %u pmg\n" , + mpam_partid_max +1 , mpam_pmg_max +1 );
Nit: Since this is the main advertisement in dmesg that MPAM has been successfully probed, maybe use the formal architectural terms here, e.g.:
printk(KERN_INFO "MPAM enabled with %u PARTIDs and %u PMGs\n",
(Largely cosmetic, though.)
Quoted 14 lines
drivers/resctrl/mpam_devices.c +1
-0}/* @@ -972,4 +1115,5 @@ static int __init mpam_msc_driver_init(void)return platform_driver_register (&mpam_msc_driver); } +/* Must occur after arm64_mpam_register_cpus() from arch_initcall() */ subsys_initcall (mpam_msc_driver_init);drivers/resctrl/mpam_internal.h +0
-0
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 54
Quoted 5 lines
drivers/resctrl/mpam_internal.h +2
-0@@ -50,6 +50,8 @@ struct mpam_msc {*/ struct mutex probe_lock;bool probed; +u16 partid_max; +u8 pmg_max;
Are these actually used for anything?
mpam_msc_hw_probe() already merges these into mpam_partid_max etc., so we just leave the hardware-reported values here -- which we can't ever use, for fear of triggering error interrupts.
(Keeping them would make it easier to migrate to merging these max values through the mpam_enable_merge_features() logic introduced in patch 18. That's a possibly simplification, but it inessential to do that right now.
Quoted 2 lines
drivers/resctrl/mpam_internal.h +0
-0unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;
[...]
Quoted 12 lines
include/linux/arm_mpam.h +4
-0@@ -39,4 +39,18 @@ static inline int acpi_mpam_count_msc(void) { return -EINVAL; }int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx,enum mpam_class_types type,u8 class_id,int component_id); +/** +* mpam_register_requestor() - Register a requestor with the MPAM driver +* @partid_max: The maximum PARTID value the requestor can generate. +* @pmg_max: The maximum PMG value the requestor can generate.
include/linux/arm_mpam.h static inline int acpi_mpam_count_msc(void) { return -EINVAL; } · line 55
Quoted 10 lines
include/linux/arm_mpam.h +10
-0+* +* Registers a requestor with the MPAM driver to ensure the chosen system-wide +* minimum PARTID and PMG values will allow the requestors features to be used. +* +* Returns an error if the registration is too late, and a larger PARTID/PMG +* value has been advertised to user-space. In this case the requestor should +* not use its MPAM features. Returns 0 on success. +*/ +int mpam_register_requestor (u16 partid_max,u8 pmg_max); +
Remove if the declared function is punted from this series.
Cheers
---Dave
James Morse
maintainerRe: [PATCH 15/33] arm_mpam: Probe MSCs to find the supported partid/pmg values
Hi Dave,
Quoted 7 lines · Dave Martin
Quoted 1 line · James Morse
Subject: Re: [PATCH 15/33]
arm_mpam: Probe MSCs to find the supported partid/pmg valuesSummary line does not describe the patch (i.e., the requestor registration interface is something different... and the probing of RIS properties has nothing architecturally to do with determining the max PARTID and PMG values.)
The values are allowed to vary by 'instance' of the id register - which someone is going to read as per-RIS. (it should really have said per security state). Doing this makes its robust against that, and we're going to have to walk the list of RIS anyway.
The CPU requestor probing isn't part of the MSC, I'll rephrase it 'probe hardware'.
Quoted 2 lines
Even regarding the MSC probing, there is considerably more in this patch than just the determination of the ID limits.
The only real exta bit is creating the UNKNOWN MSC as they've now been discovered. I don't think that's worth a patch on its own, there are too many as it is.
Quoted 8 lines
Quoted 6 lines
CPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create
Nit: created
Fixed,
Quoted 3 lines
Quoted 1 line
under
MPAM_CLASS_UNKNOWN.What are the effects / implications of this?
They're accounted for, reset, exposed to debugfs. But unused.
Quoted 15 lines
Quoted 3 lines
While we're here, implement the
mpam_register_requestor()call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.This function seems to be dead in this series; registration of CPUs is "future" too. Does it make sense to boot this into the next series?
Quoted 8 lines
drivers/resctrl/mpam_devices.c +0
-0@@ -44,6 +45,15 @@ static u32 mpam_num_msc;static int mpam_cpuhp_state;static DEFINE_MUTEX (mpam_cpuhp_state_lock);
Quoted 12 lines
drivers/resctrl/mpam_devices.c static u32 mpam_num_msc; · line 55
Quoted 8 lines
drivers/resctrl/mpam_devices.c +8
-0+/* +* The smallest common values for any CPU or MSC in the system. +* Generating traffic outside this range will result in screaming interrupts. +*/ +u16 mpam_partid_max; +u8 mpam_pmg_max; +static bool partid_max_init, partid_max_published; +static DEFINE_SPINLOCK (partid_max_lock);Can
partid_maxandpmg_maxsimply be statically initialised with the max value of the respective type instead? -1 or ~0 would be adequate initialisers.
How do we know ~0 isn't the final value?
Quoted 2 lines
This would allow us to get rid of
partid_max_initand the associated logic.
This is what causes the driver to report 0 PARTID and 0 PMG if no requestors turn up.
I think initialising as ~0 would result in more handing of ~0 as a special case, and wouldn't be self contained. As it is, 0 doesn't need handling as its safe to use when there are no requestors.
Quoted 7 lines
This assumes that we don't enable MPAM (and start using nonzero values in MPAM[10]_EL1) unless at least one usable MSC was found, so that the initialiser is not left behing.
I think that's true by construction -- if the firmware reports no MSCs, we probe nothing. Otherwise, we require every MSC reported by the firmware to probe before enabling MPAM.
But we can't know how many requestors there are - only which ones showed up. It's not just about the MSC.
Quoted 8 lines
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 120
Quoted 6 lines
drivers/resctrl/mpam_devices.c +5
-0@@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; + +lockdep_assert_irqs_enabled ();This is just because we don't use
spin_lock_irqsave(), right?
raw_spinlock_t is (now) needed from irq-masked contexts like IPI - but wasn't at the time I wrote this. It can go now as mainline checks this.
Quoted 18 lines
(Just checking my understanding.)
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 179
Quoted 13 lines
drivers/resctrl/mpam_devices.c +13
-0+ +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) { + mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max); + }else { +/* New requestors can't lower the values */ +if (partid_max < mpam_partid_max || pmg_max < mpam_pmg_max) + err = -EBUSY ;What will actually happen here? Will the arch code reject the offending late secondary?
its not meant for the CPUs as these get registers way before anything else happpens.
This is for things like the SMMU or ITS, where if they probe too late, they need to be told they can't use their MPAM features. See:
https://git.kernel.org/pub/scm/linux/kernel/git/morse/linux.git/commit/?h=mpam/snapshot%2bextras/v6.17-rc2&id=41c768c1705d3fa0814bb1cb92c83280c872cb3e
Quoted 1 line
It feels a bit like we're reinventing part of cpufeatures here --
yes, but for system-ip, hence the new wheel.
Quoted 5 lines
though I suppose the split between early and late CPUs is not the same as for the kernel proper: the "MPAM early CPUs" are those that have appeared by the time the last MSC probes, which can be a different set than the kernel's early CPUs. So I guess there is no choice but to have some special logic here.
Late online-ing CPUs are cpufeature's problem to deal with, yes it has similar logic for MPAMIDR_EL1.
Quoted 8 lines
drivers/resctrl/mpam_devices.c static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg) · line 185
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+ } +spin_unlock (&partid_max_lock); + +return err; +} +EXPORT_SYMBOL (mpam_register_requestor);As noted above, dead function (in this series)?
Yes, its a chicken and egg problem. The caller was in the arm64 patches at the begining, but got moved later, and then out of this series to reduce the number of trees this series touches. Its too big to post the whole thing in one go, and however you break it up its always possible the throw the whole lot away as being unusable until its all present. I'm damned whatever I do here. I plan to post the arm64 patches as RFC along side the v2.
Quoted 5 lines
Also, would it be better to split out the common core shared by this and the last stanza of
mpam_msc_hw_probe()?(This common core would make sense in this series even if
mpam_register_requestor()is deferred.)
It's not common because of the extra flags that requestors need to pay attention to, which can't happen by construction for the hardware probing. The he hardware probing version can't fail. I'd like to keep the requestor logic separate - its maybe two lines in common.
Quoted 16 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 629
Quoted 13 lines
drivers/resctrl/mpam_devices.c +9
-0@@ -539,10 +618,37 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } +static struct mpam_msc_ris *mpam_get_or_create_ris (struct mpam_msc *msc, +u8 ris_idx) +{ +int err; +struct mpam_msc_ris *ris, *found =ERR_PTR (-ENOENT ); + +lockdep_assert_held (&mpam_list_lock); + +if (!test_bit (ris_idx, msc->ris_idxs)) {I was a bit puzzled by this.
Quoted 5 lines
A comment somewhere might help: if
ris_idxwasn't already seen while parsing firmware tables, then there is nothing to tell us what it controls in the hardware: mark it asMPAM_CLASS_UNKNOWN.(If I understood correctly, that is.)
Spot on.
Taken your comment with some word order changes.
Quoted 7 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 631
Quoted 2 lines
drivers/resctrl/mpam_devices.c +2
-0+ err =mpam_ris_create_locked (msc, ris_idx,MPAM_CLASS_UNKNOWN , +0 ,0 ,GFP_ATOMIC );It's mildly unfortunate that these allocations are from the
GFP_ATOMICpool. I think we were in regular thread context until we started taking MPAM locks?
Quoted 5 lines
But it's a finite amount of memory and not under userspace control, so not a huge deal.
This could possibly be improved later; it doesn't feel critical right now.
I've fixed that up - its from when msc->lock was a spin lock that was taken for any hardware access. Now that there is a separate probe_lock which is a mutex, all of these can always sleep.
Quoted 11 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 638
Quoted 7 lines
drivers/resctrl/mpam_devices.c +7
-0+if (err) +return ERR_PTR (err); + } + +list_for_each_entry (ris, &msc->ris, msc_list) { +if (ris->ris_idx == ris_idx) { + found = ris;return ris; (?)
(You could then also delete all the curlies.)
I'll keep the outer ones as its easier to parse lines that expressions as you skim this.
Quoted 5 lines
Quoted 5 lines
drivers/resctrl/mpam_devices.c +5
-0+break ; + } + } + +return found;
Quoted 8 lines
drivers/resctrl/mpam_devices.c int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx, · line 545
Quoted 6 lines
drivers/resctrl/mpam_devices.c +2
-1+} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr; -int err;Churn? (See patch 14.)
I'll try and come up with a version that doesn't do that,
Quoted 42 lines
Quoted 42 lines
drivers/resctrl/mpam_devices.c +28
-4+u16 partid_max; +u8 ris_idx, pmg_max; +struct mpam_msc_ris *ris;lockdep_assert_held (&msc->probe_lock);@@ -551,14 +657,42 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) {pr_err_once ("%s does not match MPAM architecture v1.x\n" ,dev_name (&msc->pdev->dev)); - err = -EIO ; - }else { - msc->probed = true; - err =0 ; +mutex_unlock (&msc->part_sel_lock); +return -EIO ; } + + idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr); + +/* Use these values so partid/pmg always starts with a valid value */ + msc->partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + msc->pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + +for (ris_idx =0 ; ris_idx <= msc->ris_max; ris_idx++) { +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); + idr =mpam_msc_read_idr (msc); +mutex_unlock (&msc->part_sel_lock); + + partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + msc->partid_max =min (msc->partid_max, partid_max); + msc->pmg_max =min (msc->pmg_max, pmg_max); + + ris =mpam_get_or_create_ris (msc, ris_idx); +if (IS_ERR (ris)) +return PTR_ERR (ris); + }
Quoted 4 lines
drivers/resctrl/mpam_devices.c static int mpam_msc_hw_probe(struct mpam_msc *msc) · line 688
Quoted 2 lines
drivers/resctrl/mpam_devices.c +1
-1-return err; +spin_lock (&partid_max_lock);Can we get in here with
partid_max_init= false?
Today, yes - because the arch code has been ripped out to reduce the number of trees this touches.
Quoted 2 lines
Do we need to check /
set it? Or, maybe get rid of it; seempam_partid_maxetc.
Nope - it causes the 0 PARTID value to get consumed as a minimum (no special casing!), meaning you get 0 PARTID 0 PMG reported after probing because there are no requestors. Once a requestor shows up, the right thing happens.
This relies on the arch_initcall() running to register the CPUs before the driver probes.
Quoted 31 lines
Quoted 16 lines
drivers/resctrl/mpam_devices.c +10
-0+ mpam_partid_max =min (mpam_partid_max, msc->partid_max); + mpam_pmg_max =min (mpam_pmg_max, msc->pmg_max); +spin_unlock (&partid_max_lock); + + msc->probed = true; + +return 0 ; }@@ -900,9 +1034,18 @@ static struct platform_driver mpam_msc_driver = {static void mpam_enable_once (void ) { +/* +* Once the cpuhp callbacks have been changed, mpam_partid_max can no +* longer change. drivers/resctrl/mpam_devices.c static struct platform_driver mpam_msc_driver = { · line 1048
Quoted 10 lines
drivers/resctrl/mpam_devices.c +7
-1+*/ +spin_lock (&partid_max_lock); + partid_max_published = true; +spin_unlock (&partid_max_lock); +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); -pr_info ("MPAM enabled\n" ); +printk (KERN_INFO "MPAM enabled with %u partid and %u pmg\n" , + mpam_partid_max +1 , mpam_pmg_max +1 );Nit: Since this is the main advertisement in dmesg that MPAM has been successfully probed, maybe use the formal architectural terms here, e.g.:
Quoted 3 lines
printk(KERN_INFO "MPAM enabled with %u PARTIDs and %u PMGs\n",
(Largely cosmetic, though.)
Done,
Quoted 4 lines
Quoted 4 lines
drivers/resctrl/mpam_internal.h +0
-0
Quoted 8 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 54
Quoted 6 lines
drivers/resctrl/mpam_internal.h +2
-0@@ -50,6 +50,8 @@ struct mpam_msc {*/ struct mutex probe_lock;bool probed; +u16 partid_max; +u8 pmg_max;Are these actually used for anything?
There are a few things kept around to expose to debugfs to answer the question "why doesn't this hardware do what I wanted". In this case - finding which MSC is causing the PARTID/PMG values to be lower than expected.
Quoted 8 lines
mpam_msc_hw_probe()already merges these intompam_partid_maxetc., so we just leave the hardware-reported values here -- which we can't ever use, for fear of triggering error interrupts.(Keeping them would make it easier to migrate to merging these max values through the
mpam_enable_merge_features()logic introduced in patch 18. That's a possibly simplification, but it inessential to do that right now.
Thanks,
James
James Morse
maintainerPATCH 15/33 arm_mpam: Probe MSCs to find the supported partid/pmg values
In reply to James MorseCPUs can generate traffic with a range of PARTID and PMG values, but each MSC may have its own maximum size for these fields. Before MPAM can be used, the driver needs to probe each RIS on each MSC, to find the system-wide smallest value that can be used.
While doing this, RIS entries that firmware didn't describe are create under MPAM_CLASS_UNKNOWN.
While we're here, implement the mpam_register_requestor() call for the arch code to register the CPU limits. Future callers of this will tell us about the SMMU and ITS.
--- drivers/resctrl/mpam_devices.c | 158 ++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 6 ++ include/linux/arm_mpam.h | 14 +++ 3 files changed, 171 insertions(+), 7 deletions(-)
drivers/resctrl/mpam_devices.c +151 -7
@@ -6,6 +6,7 @@#include <linux/acpi.h> #include <linux/atomic.h> #include <linux/arm_mpam.h> +#include <linux/bitfield.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h>
@@ -44,6 +45,15 @@ static u32 mpam_num_msc;static int mpam_cpuhp_state;static DEFINE_MUTEX (mpam_cpuhp_state_lock); +/* +* The smallest common values for any CPU or MSC in the system. +* Generating traffic outside this range will result in screaming interrupts. +*/ +u16 mpam_partid_max; +u8 mpam_pmg_max; +static bool partid_max_init, partid_max_published; +static DEFINE_SPINLOCK (partid_max_lock); +/* * mpam is enabled once all devices have been probed from CPU online callbacks, * scheduled via this work_struct. If access to an MSC depends on a CPU that
@@ -106,6 +116,74 @@ static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg)#define mpam_read_partsel_reg (msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg) +static void __mpam_write_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz); +WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility)); + +writel_relaxed (val, msc->mapped_hwpage + reg); +} + +static inline void _mpam_write_partsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +lockdep_assert_held_once (&msc->part_sel_lock); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) + +static u64 mpam_msc_read_idr (struct mpam_msc *msc) +{ +u64 idr_high =0 , idr_low; + +lockdep_assert_held (&msc->part_sel_lock); + + idr_low =mpam_read_partsel_reg (msc,IDR ); +if (FIELD_GET (MPAMF_IDR_EXT , idr_low)) + idr_high =mpam_read_partsel_reg (msc,IDR +4 ); + +return (idr_high <<32 ) | idr_low; +} + +static void __mpam_part_sel_raw (u32 partsel,struct mpam_msc *msc) +{ +lockdep_assert_held (&msc->part_sel_lock); + +mpam_write_partsel_reg (msc,PART_SEL , partsel); +} + +static void __mpam_part_sel (u8 ris_idx,u16 partid,struct mpam_msc *msc) +{ +u32 partsel =FIELD_PREP (MPAMCFG_PART_SEL_RIS , ris_idx) | +FIELD_PREP (MPAMCFG_PART_SEL_PARTID_SEL , partid); + +__mpam_part_sel_raw (partsel, msc); +} + +int mpam_register_requestor (u16 partid_max,u8 pmg_max) +{ +int err =0 ; + +lockdep_assert_irqs_enabled (); + +spin_lock (&partid_max_lock); +if (!partid_max_init) { + mpam_partid_max = partid_max; + mpam_pmg_max = pmg_max; + partid_max_init = true; + }else if (!partid_max_published) { + mpam_partid_max =min (mpam_partid_max, partid_max); + mpam_pmg_max =min (mpam_pmg_max, pmg_max); + }else { +/* New requestors can't lower the values */ +if (partid_max < mpam_partid_max || pmg_max < mpam_pmg_max) + err = -EBUSY ; + } +spin_unlock (&partid_max_lock); + +return err; +} +EXPORT_SYMBOL (mpam_register_requestor); +#define init_garbage (x) init_llist_node(&(x)->garbage.llist) static struct mpam_vmsc *
@@ -520,6 +598,7 @@ static int mpam_ris_create_locked(struct mpam_msc *msc, u8 ris_idx,cpumask_or (&comp->affinity, &comp->affinity, &ris->affinity);cpumask_or (&class->affinity, &class->affinity, &ris->affinity);list_add_rcu (&ris->vmsc_list, &vmsc->ris); +list_add_rcu (&ris->msc_list, &msc->ris);return 0 ; }
@@ -539,10 +618,37 @@ int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,return err; } +static struct mpam_msc_ris *mpam_get_or_create_ris (struct mpam_msc *msc, +u8 ris_idx) +{ +int err; +struct mpam_msc_ris *ris, *found =ERR_PTR (-ENOENT ); + +lockdep_assert_held (&mpam_list_lock); + +if (!test_bit (ris_idx, msc->ris_idxs)) { + err =mpam_ris_create_locked (msc, ris_idx,MPAM_CLASS_UNKNOWN , +0 ,0 ,GFP_ATOMIC ); +if (err) +return ERR_PTR (err); + } + +list_for_each_entry (ris, &msc->ris, msc_list) { +if (ris->ris_idx == ris_idx) { + found = ris; +break ; + } + } + +return found; +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr; -int err; +u16 partid_max; +u8 ris_idx, pmg_max; +struct mpam_msc_ris *ris;lockdep_assert_held (&msc->probe_lock);
@@ -551,14 +657,42 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)if ((idr &MPAMF_AIDR_ARCH_MAJOR_REV ) !=MPAM_ARCHITECTURE_V1 ) {pr_err_once ("%s does not match MPAM architecture v1.x\n" ,dev_name (&msc->pdev->dev)); - err = -EIO ; - }else { - msc->probed = true; - err =0 ; +mutex_unlock (&msc->part_sel_lock); +return -EIO ; } + + idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr); + +/* Use these values so partid/pmg always starts with a valid value */ + msc->partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + msc->pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + +for (ris_idx =0 ; ris_idx <= msc->ris_max; ris_idx++) { +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); + idr =mpam_msc_read_idr (msc); +mutex_unlock (&msc->part_sel_lock); + + partid_max =FIELD_GET (MPAMF_IDR_PARTID_MAX , idr); + pmg_max =FIELD_GET (MPAMF_IDR_PMG_MAX , idr); + msc->partid_max =min (msc->partid_max, partid_max); + msc->pmg_max =min (msc->pmg_max, pmg_max); + + ris =mpam_get_or_create_ris (msc, ris_idx); +if (IS_ERR (ris)) +return PTR_ERR (ris); + } -return err; +spin_lock (&partid_max_lock); + mpam_partid_max =min (mpam_partid_max, msc->partid_max); + mpam_pmg_max =min (mpam_pmg_max, msc->pmg_max); +spin_unlock (&partid_max_lock); + + msc->probed = true; + +return 0 ; }static int mpam_cpu_online (unsigned int cpu)
@@ -900,9 +1034,18 @@ static struct platform_driver mpam_msc_driver = {static void mpam_enable_once (void ) { +/* +* Once the cpuhp callbacks have been changed, mpam_partid_max can no +* longer change. +*/ +spin_lock (&partid_max_lock); + partid_max_published = true; +spin_unlock (&partid_max_lock); +mpam_register_cpuhp_callbacks (mpam_cpu_online, mpam_cpu_offline); -pr_info ("MPAM enabled\n" ); +printk (KERN_INFO "MPAM enabled with %u partid and %u pmg\n" , + mpam_partid_max +1 , mpam_pmg_max +1 ); }/*
@@ -972,4 +1115,5 @@ static int __init mpam_msc_driver_init(void)return platform_driver_register (&mpam_msc_driver); } +/* Must occur after arm64_mpam_register_cpus() from arch_initcall() */ subsys_initcall (mpam_msc_driver_init);
drivers/resctrl/mpam_internal.h +6 -0
@@ -50,6 +50,8 @@ struct mpam_msc {*/ struct mutex probe_lock;bool probed; +u16 partid_max; +u8 pmg_max;unsigned long ris_idxs[128 /BITS_PER_LONG ];u32 ris_max;
@@ -148,6 +150,10 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +/* System wide partid/pmg values */ +extern u16 mpam_partid_max; +extern u8 mpam_pmg_max; +/* Scheduled work callback to enable mpam once all MSC have been probed */ void mpam_enable (struct work_struct *work);
include/linux/arm_mpam.h +14 -0
@@ -39,4 +39,18 @@ static inline int acpi_mpam_count_msc(void) { return -EINVAL; }int mpam_ris_create (struct mpam_msc *msc,u8 ris_idx,enum mpam_class_types type,u8 class_id,int component_id); +/** +* mpam_register_requestor() - Register a requestor with the MPAM driver +* @partid_max: The maximum PARTID value the requestor can generate. +* @pmg_max: The maximum PMG value the requestor can generate. +* +* Registers a requestor with the MPAM driver to ensure the chosen system-wide +* minimum PARTID and PMG values will allow the requestors features to be used. +* +* Returns an error if the registration is too late, and a larger PARTID/PMG +* value has been advertised to user-space. In this case the requestor should +* not use its MPAM features. Returns 0 on success. +*/ +int mpam_register_requestor (u16 partid_max,u8 pmg_max); +#endif /* __LINUX_ARM_MPAM_H */
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 16/33 arm_mpam: Add helpers for managing the locking around the mon_sel registers
In reply to James MorseThe MSC MON_SEL register needs to be accessed from hardirq context by the PMU drivers, making an irqsave spinlock the obvious lock to protect these registers. On systems with SCMI mailboxes it must be able to sleep, meaning a mutex must be used.
Clearly these two can't exist at the same time.
Add helpers for the MON_SEL locking. The outer lock must be taken in a pre-emptible context before the inner lock can be taken. On systems with SCMI mailboxes where the MON_SEL accesses must sleep - the inner lock will fail to be 'taken' if the caller is unable to sleep. This will allow the PMU driver to fail without having to check the interface type of each MSC.
--- drivers/resctrl/mpam_internal.h | 57 ++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-)
drivers/resctrl/mpam_internal.h +56 -1
@@ -68,10 +68,19 @@ struct mpam_msc {/* * mon_sel_lock protects access to the MSC hardware registers that are -* affeted by MPAMCFG_MON_SEL. +* affected by MPAMCFG_MON_SEL, and the mbwu_state. +* Both the 'inner' and 'outer' must be taken. +* For real MMIO MSC, the outer lock is unnecessary - but keeps the +* code common with: +* Firmware backed MSC need to sleep when accessing the MSC, which +* means some code-paths will always fail. For these MSC the outer +* lock is providing the protection, and the inner lock fails to +* be taken if the task is unable to sleep. +* * If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock; +bool outer_lock_held;raw_spinlock_t inner_mon_sel_lock;unsigned long inner_mon_sel_flags;
@@ -81,6 +90,52 @@ struct mpam_msc {struct mpam_garbage garbage; }; +static inline bool __must_check mpam_mon_sel_inner_lock (struct mpam_msc *msc) +{ +/* +* The outer lock may be taken by a CPU that then issues an IPI to run +* a helper that takes the inner lock. lockdep can't help us here. +*/ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) { +raw_spin_lock_irqsave (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +return true; + } + +/* Accesses must fail if we are not pre-emptible */ +return !!preemptible (); +} + +static inline void mpam_mon_sel_inner_unlock (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) +raw_spin_unlock_irqrestore (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +} + +static inline void mpam_mon_sel_outer_lock (struct mpam_msc *msc) +{ +mutex_lock (&msc->outer_mon_sel_lock); + msc->outer_lock_held = true; +} + +static inline void mpam_mon_sel_outer_unlock (struct mpam_msc *msc) +{ + msc->outer_lock_held = false; +mutex_unlock (&msc->outer_mon_sel_lock); +} + +static inline void mpam_mon_sel_lock_held (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); +if (msc->iface ==MPAM_IFACE_MMIO ) +lockdep_assert_held_once (&msc->inner_mon_sel_lock); +else +lockdep_assert_preemption_enabled (); +} +struct mpam_class {/* mpam_components in this class */ struct list_head components;
Signature · 1 line
2.20.1
Fenghua Yu
reviewerRe: [PATCH 16/33] arm_mpam: Add helpers for managing the locking around the mon_sel registers
Hi, James,
Quoted 31 lines · James Morse
The MSC
MON_SELregister needs to be accessed from hardirq context by the PMU drivers, making an irqsave spinlock the obvious lock to protect these registers. On systems with SCMI mailboxes it must be able to sleep, meaning a mutex must be used.Clearly these two can't exist at the same time.
Add helpers for the
MON_SELlocking. The outer lock must be taken in a pre-emptible context before the inner lock can be taken. On systems with SCMI mailboxes where theMON_SELaccesses must sleep - the inner lock will fail to be 'taken' if the caller is unable to sleep. This will allow the PMU driver to fail without having to check the interface type of each MSC.Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_internal.h | 57 ++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-)drivers/resctrl/mpam_internal.h +3
-1@@ -68,10 +68,19 @@ struct mpam_msc {/* * mon_sel_lock protects access to the MSC hardware registers that are -* affeted by MPAMCFG_MON_SEL. +* affected by MPAMCFG_MON_SEL, and the mbwu_state. +* Both the 'inner' and 'outer' must be taken. +* For real MMIO MSC, the outer lock is unnecessary - but keeps the
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 83
Quoted 10 lines
drivers/resctrl/mpam_internal.h +7
-0+* code common with: +* Firmware backed MSC need to sleep when accessing the MSC, which +* means some code-paths will always fail. For these MSC the outer +* lock is providing the protection, and the inner lock fails to +* be taken if the task is unable to sleep. +* * If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock; +bool outer_lock_held;
Is it better to define outer_lock_held at atomic_t?
Quoted 4 lines
drivers/resctrl/mpam_internal.h +0
-0raw_spinlock_t inner_mon_sel_lock;unsigned long inner_mon_sel_flags;
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 99
Quoted 10 lines
drivers/resctrl/mpam_internal.h +7
-0@@ -81,6 +90,52 @@ struct mpam_msc {struct mpam_garbage garbage; }; +static inline bool __must_check mpam_mon_sel_inner_lock (struct mpam_msc *msc) +{ +/* +* The outer lock may be taken by a CPU that then issues an IPI to run +* a helper that takes the inner lock. lockdep can't help us here. +*/ +WARN_ON_ONCE (!msc->outer_lock_held);
At this point, msc->outer_lock_held might not be true yet due to no memory barrier on it on this CPU. If it's atomic_t and it's set as true on another CPU by smp_store_release(), it's guaranteed to be visible as true on this CPU. Without atomic setting, we may see a false warning here and cause debug difficult.
Quoted 32 lines
drivers/resctrl/mpam_internal.h +32
-0+ +if (msc->iface ==MPAM_IFACE_MMIO ) { +raw_spin_lock_irqsave (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +return true; + } + +/* Accesses must fail if we are not pre-emptible */ +return !!preemptible (); +} + +static inline void mpam_mon_sel_inner_unlock (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) +raw_spin_unlock_irqrestore (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +} + +static inline void mpam_mon_sel_outer_lock (struct mpam_msc *msc) +{ +mutex_lock (&msc->outer_mon_sel_lock); + msc->outer_lock_held = true; +} + +static inline void mpam_mon_sel_outer_unlock (struct mpam_msc *msc) +{ + msc->outer_lock_held = false; +mutex_unlock (&msc->outer_mon_sel_lock); +} + +static inline void mpam_mon_sel_lock_held (struct mpam_msc *msc) +{
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 141
Quoted 10 lines
drivers/resctrl/mpam_internal.h +7
-0+WARN_ON_ONCE (!msc->outer_lock_held); +if (msc->iface ==MPAM_IFACE_MMIO ) +lockdep_assert_held_once (&msc->inner_mon_sel_lock); +else +lockdep_assert_preemption_enabled (); +} +struct mpam_class {/* mpam_components in this class */ struct list_head components;
Thanks.
-Fenghua
James Morse
maintainerRe: [PATCH 16/33] arm_mpam: Add helpers for managing the locking around the mon_sel registers
Hi Fenghua,
Quoted 31 lines · Fenghua Yu
Quoted 30 lines · James Morse
The MSC
MON_SELregister needs to be accessed from hardirq context by the PMU drivers, making an irqsave spinlock the obvious lock to protect these registers. On systems with SCMI mailboxes it must be able to sleep, meaning a mutex must be used.Clearly these two can't exist at the same time.
Add helpers for the
MON_SELlocking. The outer lock must be taken in a pre-emptible context before the inner lock can be taken. On systems with SCMI mailboxes where theMON_SELaccesses must sleep - the inner lock will fail to be 'taken' if the caller is unable to sleep. This will allow the PMU driver to fail without having to check the interface type of each MSC.drivers/resctrl/mpam_internal.h +7
-1@@ -68,10 +68,19 @@ struct mpam_msc { /** mon_sel_lock protects access to the MSC hardware registers that are -* affeted by MPAMCFG_MON_SEL. +* affected by MPAMCFG_MON_SEL, and the mbwu_state. +* Both the 'inner' and 'outer' must be taken. +* For real MMIO MSC, the outer lock is unnecessary - but keeps the +* code common with: +* Firmware backed MSC need to sleep when accessing the MSC, which +* means some code-paths will always fail. For these MSC the outer +* lock is providing the protection, and the inner lock fails to
Quoted 8 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 83
Quoted 6 lines
drivers/resctrl/mpam_internal.h +3
-0+* be taken if the task is unable to sleep. +* * If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock; + bool outer_lock_held;Is it better to define
outer_lock_heldatatomic_t?
Writes a protected by the outer lock, its just something to generate a warning for debug. I can make it a READ_ONCE() if you're worried about torn values in the failure case. (as its just for debug, I'm not worried about false-negatives)
Quoted 13 lines
Quoted 4 lines
drivers/resctrl/mpam_internal.h +0
-0raw_spinlock_t inner_mon_sel_lock; unsigned long inner_mon_sel_flags; @@ -81,6 +90,52 @@ struct mpam_msc { struct mpam_garbage garbage;Quoted 8 lines
};
+static inline bool__must_checkmpam_mon_sel_inner_lock(struct mpam_msc *msc)+{
+ /*
+ * The outer lock may be taken by a CPU that then issues an IPI to run + * a helper that takes the inner lock. lockdep can't help us here. + */
+WARN_ON_ONCE(!msc->outer_lock_held);
Quoted 2 lines
At this point,
msc->outer_lock_heldmight not be true yet due to no memory barrier on it on this CPU.
The IPI machinery has this covered:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/irqchip/irq-gic.c#n838
Quoted 3 lines
If it's
atomic_tand it's set as true on another CPU bysmp_store_release(), it's guaranteed to be visible as true on this CPU. Without atomic setting, we may see a false warning here and cause debug difficult.
Thanks,
James
Re: [PATCH 16/33] arm_mpam: Add helpers for managing the locking around the mon_sel registers
In reply to James MorseHi,
Quoted 2 lines · James Morse
The MSC
MON_SELregister needs to be accessed from hardirq context by the PMU drivers, making an irqsave spinlock the obvious lock to protect these
What PMU drivers? MPAM itself doesn't define its monitors as PMUs, and (as of this series) there is no intergration with perf.
Quoted 4 lines
registers. On systems with SCMI mailboxes it must be able to sleep, meaning a mutex must be used.
Clearly these two can't exist at the same time.
The locks obvisouly do exist at the same time. Do you mean that an individual MSC must be either MMIO or SCMI/PCC?
(I don't think anything prevents both kinds of MSC from existing in the same system?)
Above, you seem to imply that each kind of MSC interface requires a different kind of lock, but below, you imply that the locks must be used together, with holding the outer lock being a precondition for taking the inner lock.
Because these functions are introduced with no user, the code doesn't offer much in the way of clues. In particular, there is no indication of what the outer lock is supposed to protect.
Quoted 5 lines
Add helpers for the
MON_SELlocking. The outer lock must be taken in a pre-emptible context before the inner lock can be taken. On systems with SCMI mailboxes where theMON_SELaccesses must sleep - the inner lock will fail to be 'taken' if the caller is unable to sleep. This will allow the PMU driver to fail without having to check the interface type of
Why is it acceptable to fail (i.e., don't the counts need to be read on non-MMIO MSCs?)
Quoted 19 lines
each MSC.
Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_internal.h | 57 ++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-)drivers/resctrl/mpam_internal.h +3
-1@@ -68,10 +68,19 @@ struct mpam_msc {/* * mon_sel_lock protects access to the MSC hardware registers that are -* affeted by MPAMCFG_MON_SEL. +* affected by MPAMCFG_MON_SEL, and the mbwu_state. +* Both the 'inner' and 'outer' must be taken. +* For real MMIO MSC, the outer lock is unnecessary - but keeps the
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 83
Quoted 10 lines
drivers/resctrl/mpam_internal.h +7
-0+* code common with: +* Firmware backed MSC need to sleep when accessing the MSC, which +* means some code-paths will always fail. For these MSC the outer +* lock is providing the protection, and the inner lock fails to +* be taken if the task is unable to sleep. +* * If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock; +bool outer_lock_held;
Why not use mutex_is_locked()?
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 84
Quoted 1 line
drivers/resctrl/mpam_internal.h +0
-0raw_spinlock_t inner_mon_sel_lock;
Why raw? The commit message makes no mention of it.
(We really to need to sit on a specific CPU while holding this lock, so "raw" makes sense. But we're always doing this in a cross-call, presumably with the hotplug lock held -- so I think we can't be migrated anyway?)
Quoted 11 lines
drivers/resctrl/mpam_internal.h +5
-0unsigned long inner_mon_sel_flags;@@ -81,6 +90,52 @@ struct mpam_msc {struct mpam_garbage garbage; }; +static inline bool __must_check mpam_mon_sel_inner_lock (struct mpam_msc *msc) +{ +/* +* The outer lock may be taken by a CPU that then issues an IPI to run +* a helper that takes the inner lock. lockdep can't help us here.
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 107
Quoted 10 lines
drivers/resctrl/mpam_internal.h +10
-0+*/ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) { +raw_spin_lock_irqsave (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +return true; + } + +/* Accesses must fail if we are not pre-emptible */ +return !!preemptible ();
What accesses?
In the MPAM_IFACE_MMIO case, this returns true even though non- preemptible (because of getting the lock).
So, what is the semantics of the return value?
A comment would probably help.
Quoted 22 lines
drivers/resctrl/mpam_internal.h +21
-0+} + +static inline void mpam_mon_sel_inner_unlock (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) +raw_spin_unlock_irqrestore (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +} + +static inline void mpam_mon_sel_outer_lock (struct mpam_msc *msc) +{ +mutex_lock (&msc->outer_mon_sel_lock); + msc->outer_lock_held = true; +} + +static inline void mpam_mon_sel_outer_unlock (struct mpam_msc *msc) +{ + msc->outer_lock_held = false; +mutex_unlock (&msc->outer_mon_sel_lock); +}
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 138
Quoted 10 lines
drivers/resctrl/mpam_internal.h +10
-0+ +static inline void mpam_mon_sel_lock_held (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); +if (msc->iface ==MPAM_IFACE_MMIO ) +lockdep_assert_held_once (&msc->inner_mon_sel_lock); +else +lockdep_assert_preemption_enabled (); +} +
Except that monitors may need to be accessed in interrupt context, I don't see an obvious difference between controls and monitors that motivates this locking model.
Is the outer lock ever needfully held for extended periods of time, making a (raw) spinlock unsuitable?
Cheers
---Dave
James Morse
maintainerRe: [PATCH 16/33] arm_mpam: Add helpers for managing the locking around the mon_sel registers
Hi Dave,
Quoted 6 lines · Dave Martin
Quoted 2 lines · James Morse
The MSC
MON_SELregister needs to be accessed from hardirq context by the PMU drivers, making an irqsave spinlock the obvious lock to protect theseWhat PMU drivers? MPAM itself doesn't define its monitors as PMUs, and (as of this series) there is no intergration with perf.
I can redraw this as the IPI that is needed on platforms with cache:MSC and PSCI:CPU_SUSPEND.
The PMU driver got dragged further out in time as ABMC may be a viable alternative for platforms with insufficient monitors. (but there are also platforms which don't look enough like a Xeon for this to work)
Quoted 7 lines
Quoted 4 lines
registers. On systems with SCMI mailboxes it must be able to sleep, meaning a mutex must be used.
Clearly these two can't exist at the same time.
The locks obvisouly do exist at the same time. Do you mean that an individual MSC must be either MMIO or SCMI/PCC?
Yes, I've reworded that as 'for one MSC at the same time'.
Quoted 11 lines
(I don't think anything prevents both kinds of MSC from existing in the same system?)
Above, you seem to imply that each kind of MSC interface requires a different kind of lock, but below, you imply that the locks must be used together, with holding the outer lock being a precondition for taking the inner lock.
Because these functions are introduced with no user, the code doesn't offer much in the way of clues. In particular, there is no indication of what the outer lock is supposed to protect.
It's a structure to you do the right things in the right context. You have to try to take both locks - all the inner lock does on a system that needs to sleep is check the context, so the outer lock does all the 'protecting'. On 'normal' systems, the inner lock takes an irqsave spinlock which makes does all the work, and makes it safe for the overflow interrupt.
Quoted 8 lines
Quoted 5 lines
Add helpers for the
MON_SELlocking. The outer lock must be taken in a pre-emptible context before the inner lock can be taken. On systems with SCMI mailboxes where theMON_SELaccesses must sleep - the inner lock will fail to be 'taken' if the caller is unable to sleep. This will allow the PMU driver to fail without having to check the interface type ofWhy is it acceptable to fail (i.e., don't the counts need to be read on non-MMIO MSCs?)
They can't from contexts that need to sleep. If you've got this firmware thing you also need to have a platform that doesn't need IPI to reach the mailbox (why would it), overflow interrupts, or a PMU driver.
Instead of having two drivers, or type checks all over the place - this structure lets such a platform get through as much of the driver as possible, before failing at the point that would deadlock. (need to wait for an interrupt in interrupt context).
I think this is the most maintainable approach as it has the most in common. I don't like the two drivers alternative.
Quoted 20 lines
Quoted 20 lines
each MSC.
drivers/resctrl/mpam_internal.h +7
-1@@ -68,10 +68,19 @@ struct mpam_msc {/* * mon_sel_lock protects access to the MSC hardware registers that are -* affeted by MPAMCFG_MON_SEL. +* affected by MPAMCFG_MON_SEL, and the mbwu_state. +* Both the 'inner' and 'outer' must be taken. +* For real MMIO MSC, the outer lock is unnecessary - but keeps the +* code common with: +* Firmware backed MSC need to sleep when accessing the MSC, which +* means some code-paths will always fail. For these MSC the outer +* lock is providing the protection, and the inner lock fails to
Quoted 8 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 83
Quoted 6 lines
drivers/resctrl/mpam_internal.h +3
-0+* be taken if the task is unable to sleep. +* * If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock; +bool outer_lock_held;Why not use
mutex_is_locked()?
That works. I've had a bad experience with the lockdep version of that checking who owns the mutex, and getting confused when there is an IPI involved.
Quoted 8 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 84
Quoted 1 line
drivers/resctrl/mpam_internal.h +0
-0raw_spinlock_t inner_mon_sel_lock;Why raw? The commit message makes no mention of it.
(We really to need to sit on a specific CPU while holding this lock, so "raw" makes sense. But we're always doing this in a cross-call, presumably with the hotplug lock held -- so I think we can't be migrated anyway?)
Nothing to do with hotplug. (my recollection as to why this got changed - ) is because an IPI results in the kind of context where you can't sleep - and regular spinlocks can end up sleeping. This is the trick RT pulls. Without raw here - the atomic sleep check starts complaining about taking a spinlock behind and IPI.
Quoted 15 lines
Quoted 15 lines
drivers/resctrl/mpam_internal.h +9
-0unsigned long inner_mon_sel_flags;@@ -81,6 +90,52 @@ struct mpam_msc {struct mpam_garbage garbage; }; +static inline bool __must_check mpam_mon_sel_inner_lock (struct mpam_msc *msc) +{ +/* +* The outer lock may be taken by a CPU that then issues an IPI to run +* a helper that takes the inner lock. lockdep can't help us here. +*/ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) {
Quoted 8 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 107
Quoted 6 lines
drivers/resctrl/mpam_internal.h +6
-0+raw_spin_lock_irqsave (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +return true; + } + +/* Accesses must fail if we are not pre-emptible */ +return !!preemptible ();What accesses?
To the mon_sel register.
Quoted 6 lines
In the
MPAM_IFACE_MMIOcase, this returns true even though non- preemptible (because of getting the lock).So, what is the semantics of the return value?
A comment would probably help.
/* Returning false here means accesses to mon_sel must fail and report an error. */
Quoted 28 lines
Quoted 28 lines
drivers/resctrl/mpam_internal.h +27
-0+} + +static inline void mpam_mon_sel_inner_unlock (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) +raw_spin_unlock_irqrestore (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +} + +static inline void mpam_mon_sel_outer_lock (struct mpam_msc *msc) +{ +mutex_lock (&msc->outer_mon_sel_lock); + msc->outer_lock_held = true; +} + +static inline void mpam_mon_sel_outer_unlock (struct mpam_msc *msc) +{ + msc->outer_lock_held = false; +mutex_unlock (&msc->outer_mon_sel_lock); +} + +static inline void mpam_mon_sel_lock_held (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); +if (msc->iface ==MPAM_IFACE_MMIO ) +lockdep_assert_held_once (&msc->inner_mon_sel_lock);
Quoted 8 lines
drivers/resctrl/mpam_internal.h struct mpam_msc { · line 138
Quoted 4 lines
drivers/resctrl/mpam_internal.h +4
-0+else +lockdep_assert_preemption_enabled (); +} +Except that monitors may need to be accessed in interrupt context, I don't see an obvious difference between controls and monitors that motivates this locking model.
Controls don't have an overflow interrupt, and would never be accessed by perf in nasty contexts.
Quoted 2 lines
Is the outer lock ever needfully held for extended periods of time, making a (raw) spinlock unsuitable?
It's held before sending the IPI - but only because the firmware platforms should never need to send that IPI.
I can drop the outer lock for now as the firmware platforms haven't properly materialised, (promised ~three years ago - also promised in December this year). But some kind of abstraction is needed here to keep the code common, and these mon_sel accesses need to be something that can fail.
Thanks,
James
James Morse
maintainerPATCH 16/33 arm_mpam: Add helpers for managing the locking around the mon_sel registers
In reply to James MorseThe MSC MON_SEL register needs to be accessed from hardirq context by the PMU drivers, making an irqsave spinlock the obvious lock to protect these registers. On systems with SCMI mailboxes it must be able to sleep, meaning a mutex must be used.
Clearly these two can't exist at the same time.
Add helpers for the MON_SEL locking. The outer lock must be taken in a pre-emptible context before the inner lock can be taken. On systems with SCMI mailboxes where the MON_SEL accesses must sleep - the inner lock will fail to be 'taken' if the caller is unable to sleep. This will allow the PMU driver to fail without having to check the interface type of each MSC.
--- drivers/resctrl/mpam_internal.h | 57 ++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-)
drivers/resctrl/mpam_internal.h +56 -1
@@ -68,10 +68,19 @@ struct mpam_msc {/* * mon_sel_lock protects access to the MSC hardware registers that are -* affeted by MPAMCFG_MON_SEL. +* affected by MPAMCFG_MON_SEL, and the mbwu_state. +* Both the 'inner' and 'outer' must be taken. +* For real MMIO MSC, the outer lock is unnecessary - but keeps the +* code common with: +* Firmware backed MSC need to sleep when accessing the MSC, which +* means some code-paths will always fail. For these MSC the outer +* lock is providing the protection, and the inner lock fails to +* be taken if the task is unable to sleep. +* * If needed, take msc->probe_lock first. */ struct mutex outer_mon_sel_lock; +bool outer_lock_held;raw_spinlock_t inner_mon_sel_lock;unsigned long inner_mon_sel_flags;
@@ -81,6 +90,52 @@ struct mpam_msc {struct mpam_garbage garbage; }; +static inline bool __must_check mpam_mon_sel_inner_lock (struct mpam_msc *msc) +{ +/* +* The outer lock may be taken by a CPU that then issues an IPI to run +* a helper that takes the inner lock. lockdep can't help us here. +*/ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) { +raw_spin_lock_irqsave (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +return true; + } + +/* Accesses must fail if we are not pre-emptible */ +return !!preemptible (); +} + +static inline void mpam_mon_sel_inner_unlock (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); + +if (msc->iface ==MPAM_IFACE_MMIO ) +raw_spin_unlock_irqrestore (&msc->inner_mon_sel_lock, msc->inner_mon_sel_flags); +} + +static inline void mpam_mon_sel_outer_lock (struct mpam_msc *msc) +{ +mutex_lock (&msc->outer_mon_sel_lock); + msc->outer_lock_held = true; +} + +static inline void mpam_mon_sel_outer_unlock (struct mpam_msc *msc) +{ + msc->outer_lock_held = false; +mutex_unlock (&msc->outer_mon_sel_lock); +} + +static inline void mpam_mon_sel_lock_held (struct mpam_msc *msc) +{ +WARN_ON_ONCE (!msc->outer_lock_held); +if (msc->iface ==MPAM_IFACE_MMIO ) +lockdep_assert_held_once (&msc->inner_mon_sel_lock); +else +lockdep_assert_preemption_enabled (); +} +struct mpam_class {/* mpam_components in this class */ struct list_head components;
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 17/33 arm_mpam: Probe the hardware features resctrl supports
In reply to James MorseExpand the probing support with the control and monitor types we can use with resctrl.
---
Changes since RFC:
* Made mpam_ris_hw_probe_hw_nrdy() more in C.
* Added static assert on features bitmap size.
--- drivers/resctrl/mpam_devices.c | 156 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 54 +++++++++++ 2 files changed, 209 insertions(+), 1 deletion(-)
drivers/resctrl/mpam_devices.c +155 -1
@@ -102,7 +102,7 @@ static LLIST_HEAD(mpam_garbage);static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) { -WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz);WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility));return readl_relaxed (msc->mapped_hwpage + reg);
@@ -131,6 +131,20 @@ static inline void _mpam_write_partsel_reg(struct mpam_msc *msc, u16 reg, u32 va }#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) +static inline u32 _mpam_read_monsel_reg (struct mpam_msc *msc,u16 reg) +{ +mpam_mon_sel_lock_held (msc); +return __mpam_read_reg (msc, reg); +} +#define mpam_read_monsel_reg (msc, reg) _mpam_read_monsel_reg(msc, MSMON_##reg) + +static inline void _mpam_write_monsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +mpam_mon_sel_lock_held (msc); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_monsel_reg (msc, reg, val) _mpam_write_monsel_reg(msc, MSMON_##reg, val) +static u64 mpam_msc_read_idr (struct mpam_msc *msc) {u64 idr_high =0 , idr_low;
@@ -643,6 +657,139 @@ static struct mpam_msc_ris *mpam_get_or_create_ris(struct mpam_msc *msc,return found; } +/* +* IHI009A.a has this nugget: "If a monitor does not support automatic behaviour +* of NRDY, software can use this bit for any purpose" - so hardware might not +* implement this - but it isn't RES0. +* +* Try and see what values stick in this bit. If we can write either value, +* its probably not implemented by hardware. +*/ +static bool _mpam_ris_hw_probe_hw_nrdy (struct mpam_msc_ris * ris,u32 mon_reg) +{ +u32 now; +u64 mon_sel; +bool can_set, can_clear; +struct mpam_msc *msc = ris->vmsc->msc; + +if (WARN_ON_ONCE (!mpam_mon_sel_inner_lock (msc))) +return false; + + mon_sel =FIELD_PREP (MSMON_CFG_MON_SEL_MON_SEL ,0 ) | +FIELD_PREP (MSMON_CFG_MON_SEL_RIS , ris->ris_idx); +_mpam_write_monsel_reg (msc, mon_reg, mon_sel); + +_mpam_write_monsel_reg (msc, mon_reg,MSMON___NRDY ); + now =_mpam_read_monsel_reg (msc, mon_reg); + can_set = now &MSMON___NRDY ; + +_mpam_write_monsel_reg (msc, mon_reg,0 ); + now =_mpam_read_monsel_reg (msc, mon_reg); + can_clear = !(now &MSMON___NRDY ); +mpam_mon_sel_inner_unlock (msc); + +return (!can_set || !can_clear); +} + +#define mpam_ris_hw_probe_hw_nrdy (_ris, _mon_reg) \ + _mpam_ris_hw_probe_hw_nrdy(_ris, MSMON_##_mon_reg) + +static void mpam_ris_hw_probe (struct mpam_msc_ris *ris) +{ +int err; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *props = &ris->props; + +lockdep_assert_held (&msc->probe_lock); +lockdep_assert_held (&msc->part_sel_lock); + +/* Cache Portion partitioning */ +if (FIELD_GET (MPAMF_IDR_HAS_CPOR_PART , ris->idr)) { +u32 cpor_features =mpam_read_partsel_reg (msc,CPOR_IDR ); + + props->cpbm_wd =FIELD_GET (MPAMF_CPOR_IDR_CPBM_WD , cpor_features); +if (props->cpbm_wd) +mpam_set_feature (mpam_feat_cpor_part, props); + } + +/* Memory bandwidth partitioning */ +if (FIELD_GET (MPAMF_IDR_HAS_MBW_PART , ris->idr)) { +u32 mbw_features =mpam_read_partsel_reg (msc,MBW_IDR ); + +/* portion bitmap resolution */ + props->mbw_pbm_bits =FIELD_GET (MPAMF_MBW_IDR_BWPBM_WD , mbw_features); +if (props->mbw_pbm_bits && +FIELD_GET (MPAMF_MBW_IDR_HAS_PBM , mbw_features)) +mpam_set_feature (mpam_feat_mbw_part, props); + + props->bwa_wd =FIELD_GET (MPAMF_MBW_IDR_BWA_WD , mbw_features); +if (props->bwa_wd &&FIELD_GET (MPAMF_MBW_IDR_HAS_MAX , mbw_features)) +mpam_set_feature (mpam_feat_mbw_max, props); + } + +/* Performance Monitoring */ +if (FIELD_GET (MPAMF_IDR_HAS_MSMON , ris->idr)) { +u32 msmon_features =mpam_read_partsel_reg (msc,MSMON_IDR ); + +/* +* If the firmware max-nrdy-us property is missing, the +* CSU counters can't be used. Should we wait forever? +*/ + err =device_property_read_u32 (&msc->pdev->dev, +"arm,not-ready-us" , + &msc->nrdy_usec); + +if (FIELD_GET (MPAMF_MSMON_IDR_MSMON_CSU , msmon_features)) { +u32 csumonidr; + + csumonidr =mpam_read_partsel_reg (msc,CSUMON_IDR ); + props->num_csu_mon =FIELD_GET (MPAMF_CSUMON_IDR_NUM_MON , csumonidr); +if (props->num_csu_mon) { +bool hw_managed; + +mpam_set_feature (mpam_feat_msmon_csu, props); + +/* Is NRDY hardware managed? */ +mpam_mon_sel_outer_lock (msc); + hw_managed =mpam_ris_hw_probe_hw_nrdy (ris,CSU ); +mpam_mon_sel_outer_unlock (msc); +if (hw_managed) +mpam_set_feature (mpam_feat_msmon_csu_hw_nrdy, props); + } + +/* +* Accept the missing firmware property if NRDY appears +* un-implemented. +*/ +if (err &&mpam_has_feature (mpam_feat_msmon_csu_hw_nrdy, props)) +pr_err_once ("Counters are not usable because not-ready timeout was not provided by firmware." ); + } +if (FIELD_GET (MPAMF_MSMON_IDR_MSMON_MBWU , msmon_features)) { +bool hw_managed; +u32 mbwumonidr =mpam_read_partsel_reg (msc,MBWUMON_IDR ); + + props->num_mbwu_mon =FIELD_GET (MPAMF_MBWUMON_IDR_NUM_MON , mbwumonidr); +if (props->num_mbwu_mon) +mpam_set_feature (mpam_feat_msmon_mbwu, props); + +if (FIELD_GET (MPAMF_MBWUMON_IDR_HAS_RWBW , mbwumonidr)) +mpam_set_feature (mpam_feat_msmon_mbwu_rwbw, props); + +/* Is NRDY hardware managed? */ +mpam_mon_sel_outer_lock (msc); + hw_managed =mpam_ris_hw_probe_hw_nrdy (ris,MBWU ); +mpam_mon_sel_outer_unlock (msc); +if (hw_managed) +mpam_set_feature (mpam_feat_msmon_mbwu_hw_nrdy, props); + +/* +* Don't warn about any missing firmware property for +* MBWU NRDY - it doesn't make any sense! +*/ + } + } +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr;
@@ -663,6 +810,7 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr);/* Use these values so partid/pmg always starts with a valid value */
@@ -683,6 +831,12 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) ris =mpam_get_or_create_ris (msc, ris_idx);if (IS_ERR (ris))return PTR_ERR (ris); + ris->idr = idr; + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); +mpam_ris_hw_probe (ris); +mutex_unlock (&msc->part_sel_lock); }spin_lock (&partid_max_lock);
drivers/resctrl/mpam_internal.h +54 -0
72 lines not on this page · raw message
Signature · 1 line
2.20.1
Ben Horgan
maintainerRe: [PATCH 17/33] arm_mpam: Probe the hardware features resctrl supports
Hi James,
Quoted 19 lines · James Morse
Expand the probing support with the control and monitor types we can use with resctrl.
CC Dave Martin <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* Madempam_ris_hw_probe_hw_nrdy()more in C.
* Added static assert on features bitmap size.--- drivers/resctrl/mpam_devices.c | 156 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 54 +++++++++++ 2 files changed, 209 insertions(+), 1 deletion(-)drivers/resctrl/mpam_devices.c +0
-0
drivers/resctrl/mpam_devices.c static LLIST_HEAD(mpam_garbage); · line 105
Quoted 5 lines
drivers/resctrl/mpam_devices.c +1
-1@@ -102,7 +102,7 @@ static LLIST_HEAD(mpam_garbage);static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) { -WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz);
Update in the patch that introduced this line.
Quoted 207 lines
drivers/resctrl/mpam_devices.c +154
-0WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility));return readl_relaxed (msc->mapped_hwpage + reg);@@ -131,6 +131,20 @@ static inline void _mpam_write_partsel_reg(struct mpam_msc *msc, u16 reg, u32 va }#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) +static inline u32 _mpam_read_monsel_reg (struct mpam_msc *msc,u16 reg) +{ +mpam_mon_sel_lock_held (msc); +return __mpam_read_reg (msc, reg); +} +#define mpam_read_monsel_reg (msc, reg) _mpam_read_monsel_reg(msc, MSMON_##reg) + +static inline void _mpam_write_monsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +mpam_mon_sel_lock_held (msc); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_monsel_reg (msc, reg, val) _mpam_write_monsel_reg(msc, MSMON_##reg, val) +static u64 mpam_msc_read_idr (struct mpam_msc *msc) {u64 idr_high =0 , idr_low;@@ -643,6 +657,139 @@ static struct mpam_msc_ris *mpam_get_or_create_ris(struct mpam_msc *msc,return found; } +/* +* IHI009A.a has this nugget: "If a monitor does not support automatic behaviour +* of NRDY, software can use this bit for any purpose" - so hardware might not +* implement this - but it isn't RES0. +* +* Try and see what values stick in this bit. If we can write either value, +* its probably not implemented by hardware. +*/ +static bool _mpam_ris_hw_probe_hw_nrdy (struct mpam_msc_ris * ris,u32 mon_reg) +{ +u32 now; +u64 mon_sel; +bool can_set, can_clear; +struct mpam_msc *msc = ris->vmsc->msc; + +if (WARN_ON_ONCE (!mpam_mon_sel_inner_lock (msc))) +return false; + + mon_sel =FIELD_PREP (MSMON_CFG_MON_SEL_MON_SEL ,0 ) | +FIELD_PREP (MSMON_CFG_MON_SEL_RIS , ris->ris_idx); +_mpam_write_monsel_reg (msc, mon_reg, mon_sel); + +_mpam_write_monsel_reg (msc, mon_reg,MSMON___NRDY ); + now =_mpam_read_monsel_reg (msc, mon_reg); + can_set = now &MSMON___NRDY ; + +_mpam_write_monsel_reg (msc, mon_reg,0 ); + now =_mpam_read_monsel_reg (msc, mon_reg); + can_clear = !(now &MSMON___NRDY ); +mpam_mon_sel_inner_unlock (msc); + +return (!can_set || !can_clear); +} + +#define mpam_ris_hw_probe_hw_nrdy (_ris, _mon_reg) \ + _mpam_ris_hw_probe_hw_nrdy(_ris, MSMON_##_mon_reg) + +static void mpam_ris_hw_probe (struct mpam_msc_ris *ris) +{ +int err; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *props = &ris->props; + +lockdep_assert_held (&msc->probe_lock); +lockdep_assert_held (&msc->part_sel_lock); + +/* Cache Portion partitioning */ +if (FIELD_GET (MPAMF_IDR_HAS_CPOR_PART , ris->idr)) { +u32 cpor_features =mpam_read_partsel_reg (msc,CPOR_IDR ); + + props->cpbm_wd =FIELD_GET (MPAMF_CPOR_IDR_CPBM_WD , cpor_features); +if (props->cpbm_wd) +mpam_set_feature (mpam_feat_cpor_part, props); + } + +/* Memory bandwidth partitioning */ +if (FIELD_GET (MPAMF_IDR_HAS_MBW_PART , ris->idr)) { +u32 mbw_features =mpam_read_partsel_reg (msc,MBW_IDR ); + +/* portion bitmap resolution */ + props->mbw_pbm_bits =FIELD_GET (MPAMF_MBW_IDR_BWPBM_WD , mbw_features); +if (props->mbw_pbm_bits && +FIELD_GET (MPAMF_MBW_IDR_HAS_PBM , mbw_features)) +mpam_set_feature (mpam_feat_mbw_part, props); + + props->bwa_wd =FIELD_GET (MPAMF_MBW_IDR_BWA_WD , mbw_features); +if (props->bwa_wd &&FIELD_GET (MPAMF_MBW_IDR_HAS_MAX , mbw_features)) +mpam_set_feature (mpam_feat_mbw_max, props); + } + +/* Performance Monitoring */ +if (FIELD_GET (MPAMF_IDR_HAS_MSMON , ris->idr)) { +u32 msmon_features =mpam_read_partsel_reg (msc,MSMON_IDR ); + +/* +* If the firmware max-nrdy-us property is missing, the +* CSU counters can't be used. Should we wait forever? +*/ + err =device_property_read_u32 (&msc->pdev->dev, +"arm,not-ready-us" , + &msc->nrdy_usec); + +if (FIELD_GET (MPAMF_MSMON_IDR_MSMON_CSU , msmon_features)) { +u32 csumonidr; + + csumonidr =mpam_read_partsel_reg (msc,CSUMON_IDR ); + props->num_csu_mon =FIELD_GET (MPAMF_CSUMON_IDR_NUM_MON , csumonidr); +if (props->num_csu_mon) { +bool hw_managed; + +mpam_set_feature (mpam_feat_msmon_csu, props); + +/* Is NRDY hardware managed? */ +mpam_mon_sel_outer_lock (msc); + hw_managed =mpam_ris_hw_probe_hw_nrdy (ris,CSU ); +mpam_mon_sel_outer_unlock (msc); +if (hw_managed) +mpam_set_feature (mpam_feat_msmon_csu_hw_nrdy, props); + } + +/* +* Accept the missing firmware property if NRDY appears +* un-implemented. +*/ +if (err &&mpam_has_feature (mpam_feat_msmon_csu_hw_nrdy, props)) +pr_err_once ("Counters are not usable because not-ready timeout was not provided by firmware." ); + } +if (FIELD_GET (MPAMF_MSMON_IDR_MSMON_MBWU , msmon_features)) { +bool hw_managed; +u32 mbwumonidr =mpam_read_partsel_reg (msc,MBWUMON_IDR ); + + props->num_mbwu_mon =FIELD_GET (MPAMF_MBWUMON_IDR_NUM_MON , mbwumonidr); +if (props->num_mbwu_mon) +mpam_set_feature (mpam_feat_msmon_mbwu, props); + +if (FIELD_GET (MPAMF_MBWUMON_IDR_HAS_RWBW , mbwumonidr)) +mpam_set_feature (mpam_feat_msmon_mbwu_rwbw, props); + +/* Is NRDY hardware managed? */ +mpam_mon_sel_outer_lock (msc); + hw_managed =mpam_ris_hw_probe_hw_nrdy (ris,MBWU ); +mpam_mon_sel_outer_unlock (msc); +if (hw_managed) +mpam_set_feature (mpam_feat_msmon_mbwu_hw_nrdy, props); + +/* +* Don't warn about any missing firmware property for +* MBWU NRDY - it doesn't make any sense! +*/ + } + } +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr;@@ -663,6 +810,7 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr);/* Use these values so partid/pmg always starts with a valid value */ @@ -683,6 +831,12 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) ris =mpam_get_or_create_ris (msc, ris_idx);if (IS_ERR (ris))return PTR_ERR (ris); + ris->idr = idr; + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); +mpam_ris_hw_probe (ris); +mutex_unlock (&msc->part_sel_lock); }spin_lock (&partid_max_lock);drivers/resctrl/mpam_internal.h +14
-0@@ -136,6 +136,56 @@ static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc)lockdep_assert_preemption_enabled (); } +/* +* When we compact the supported features, we don't care what they are. +* Storing them as a bitmap makes life easy. +*/ +typedef u16 mpam_features_t ; + +/* Bits for mpam_features_t */ +enum mpam_device_features { + mpam_feat_ccap_part =0 , + mpam_feat_cpor_part, + mpam_feat_mbw_part, + mpam_feat_mbw_min, + mpam_feat_mbw_max, + mpam_feat_mbw_prop,
drivers/resctrl/mpam_internal.h static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) · line 162
Quoted 10 lines
drivers/resctrl/mpam_internal.h +10
-0+ mpam_feat_msmon, + mpam_feat_msmon_csu, + mpam_feat_msmon_csu_capture, + mpam_feat_msmon_csu_hw_nrdy, + mpam_feat_msmon_mbwu, + mpam_feat_msmon_mbwu_capture, + mpam_feat_msmon_mbwu_rwbw, + mpam_feat_msmon_mbwu_hw_nrdy, + mpam_feat_msmon_capt, + MPAM_FEATURE_LAST,
This isn't all the features or just the features supported by resctrl. Just add them all in this patch?
drivers/resctrl/mpam_internal.h static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) · line 165
Quoted 3 lines
drivers/resctrl/mpam_internal.h +3
-0+}; +static_assert (BITS_PER_TYPE (mpam_features_t) >=MPAM_FEATURE_LAST ); +#define MPAM_ALL_FEATURES ((1 << MPAM_FEATURE_LAST) - 1)
Unused?
Quoted 36 lines
drivers/resctrl/mpam_internal.h +25
-0+ +struct mpam_props { +mpam_features_t features; + +u16 cpbm_wd; +u16 mbw_pbm_bits; +u16 bwa_wd; +u16 num_csu_mon; +u16 num_mbwu_mon; +}; + +static inline bool mpam_has_feature (enum mpam_device_features feat, +struct mpam_props *props) +{ +return (1 << feat) & props->features; +} + +static inline void mpam_set_feature (enum mpam_device_features feat, +struct mpam_props *props) +{ + props->features |= (1 << feat); +} +struct mpam_class {/* mpam_components in this class */ struct list_head components;@@ -175,6 +225,8 @@ struct mpam_vmsc {/* mpam_msc_ris in this vmsc */ struct list_head ris; +struct mpam_props props; +/* All RIS in this vMSC are members of this MSC */ struct mpam_msc *msc;
drivers/resctrl/mpam_internal.h struct mpam_vmsc { · line 245
Quoted 8 lines
drivers/resctrl/mpam_internal.h +2
-0@@ -186,6 +238,8 @@ struct mpam_vmsc {struct mpam_msc_ris {u8 ris_idx; +u64 idr; +struct mpam_props props;cpumask_t affinity;
Thanks,
Ben
James Morse
maintainerRe: [PATCH 17/33] arm_mpam: Probe the hardware features resctrl supports
Hi Ben,
Quoted 10 lines · Ben Horgan
Quoted 9 lines · James Morse
Expand the probing support with the control and monitor types we can use with resctrl.
drivers/resctrl/mpam_devices.c +0
-0@@ -102,7 +102,7 @@ static LLIST_HEAD(mpam_garbage);
Quoted 6 lines
drivers/resctrl/mpam_devices.c static LLIST_HEAD(mpam_garbage); · line 105
Quoted 4 lines
drivers/resctrl/mpam_devices.c +1
-1static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) { -WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz);Update in the patch that introduced this line.
Yeah - this got ripped out.
Now that the size is in the ACPI table, I should never need to debug it being wrong! (and the resulting translation fault will be enough to say something is wrong)
Quoted 19 lines
Quoted 19 lines
drivers/resctrl/mpam_internal.h +13
-0@@ -136,6 +136,56 @@ static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) +/* Bits for mpam_features_t */ +enum mpam_device_features { + mpam_feat_ccap_part =0 , + mpam_feat_cpor_part, + mpam_feat_mbw_part, + mpam_feat_mbw_min, + mpam_feat_mbw_max, + mpam_feat_mbw_prop, + mpam_feat_msmon, + mpam_feat_msmon_csu, + mpam_feat_msmon_csu_capture, + mpam_feat_msmon_csu_hw_nrdy, + mpam_feat_msmon_mbwu,
Quoted 8 lines
drivers/resctrl/mpam_internal.h static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) · line 162
Quoted 5 lines
drivers/resctrl/mpam_internal.h +5
-0+ mpam_feat_msmon_mbwu_capture, + mpam_feat_msmon_mbwu_rwbw, + mpam_feat_msmon_mbwu_hw_nrdy, + mpam_feat_msmon_capt, + MPAM_FEATURE_LAST,This isn't all the features or just the features supported by resctrl. Just add them all in this patch?
I'm having trouble parsing this ...
I needed somewhere to split the features up, as there are rather a lot. Those that resctrl supports seemed like the logical spot.
Quoted 5 lines
drivers/resctrl/mpam_internal.h static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) · line 165
Quoted 3 lines
drivers/resctrl/mpam_internal.h +3
-0+}; +static_assert (BITS_PER_TYPE (mpam_features_t) >=MPAM_FEATURE_LAST ); +#define MPAM_ALL_FEATURES ((1 << MPAM_FEATURE_LAST) - 1)Unused?
Fixed, thanks!
Thanks,
James
Ben Horgan
maintainerRe: [PATCH 17/33] arm_mpam: Probe the hardware features resctrl supports
Hi James,
Quoted 53 lines · James Morse
Hi Ben,
Quoted 10 lines · Ben Horgan
Quoted 9 lines · James Morse
Expand the probing support with the control and monitor types we can use with resctrl.
drivers/resctrl/mpam_devices.c +0
-0@@ -102,7 +102,7 @@ static LLIST_HEAD(mpam_garbage);Quoted 6 lines
drivers/resctrl/mpam_devices.c static LLIST_HEAD(mpam_garbage); · line 105
Quoted 4 lines
drivers/resctrl/mpam_devices.c +1
-1static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) { -WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz);Update in the patch that introduced this line.
Yeah - this got ripped out.
Now that the size is in the ACPI table, I should never need to debug it being wrong! (and the resulting translation fault will be enough to say something is wrong)Quoted 19 lines
Quoted 19 lines
drivers/resctrl/mpam_internal.h +13
-0@@ -136,6 +136,56 @@ static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) +/* Bits for mpam_features_t */ +enum mpam_device_features { + mpam_feat_ccap_part =0 , + mpam_feat_cpor_part, + mpam_feat_mbw_part, + mpam_feat_mbw_min, + mpam_feat_mbw_max, + mpam_feat_mbw_prop, + mpam_feat_msmon, + mpam_feat_msmon_csu, + mpam_feat_msmon_csu_capture, + mpam_feat_msmon_csu_hw_nrdy, + mpam_feat_msmon_mbwu,Quoted 8 lines
drivers/resctrl/mpam_internal.h static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) · line 162
Quoted 5 lines
drivers/resctrl/mpam_internal.h +5
-0+ mpam_feat_msmon_mbwu_capture, + mpam_feat_msmon_mbwu_rwbw, + mpam_feat_msmon_mbwu_hw_nrdy, + mpam_feat_msmon_capt, + MPAM_FEATURE_LAST,This isn't all the features or just the features supported by resctrl. Just add them all in this patch?
Quoted 4 lines
I'm having trouble parsing this ...
I needed somewhere to split the features up, as there are rather a lot. Those that resctrl supports seemed like the logical spot.
I don't think resctrl doesn't support ccap, mpam_feat_ccap_part. Possibly the point is that this is split into more detailed features later but that's not clear from this patch or commit message.
Quoted 8 lines
Quoted 7 lines
drivers/resctrl/mpam_internal.h static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc) · line 165
Quoted 5 lines
drivers/resctrl/mpam_internal.h +3
-0+}; +static_assert (BITS_PER_TYPE (mpam_features_t) >=MPAM_FEATURE_LAST ); +#define MPAM_ALL_FEATURES ((1 << MPAM_FEATURE_LAST) - 1)Unused?
Quoted 6 lines
Fixed, thanks!
Thanks,
James
Thanks,
Ben
James Morse
maintainercover arm_mpam: Add basic mpam driver
In reply to James MorseHello,
This is just enough MPAM driver for the ACPI and DT pre-requisites. It doesn't contain any of the resctrl code, meaning you can't actually drive it from user-space yet. Becuase of that, its hidden behind CONFIG_EXPERT. This will change once the user interface is connected up.
This is the initial group of patches that allows the resctrl code to be built on top. Including that will increase the number of trees that may need to coordinate, so breaking it up make sense.
The locking looks very strange - but is influenced by the 'mpam-fb' firmware interface specification that is still alpha. That thing needs to wait for an interrupt after every system register write, which significantly impacts the driver. Some features just won't work, e.g. reading the monitor registers via perf.
The aim is to not have to make invasive changes to the locking to support the firmware interface, hence it looks strange from day-1.
I've not found a platform that can test all the behaviours around the monitors, so this is where I'd expect the most bugs.
The MPAM spec that describes all the system and MMIO registers can be found here:
https://developer.arm.com/documentation/ddi0598/db/?lang=en
(Ignored the 'RETIRED' warning - that is just arm moving the documentation around.
This document has the best overview)
The expectation is this will go via the arm64 tree.
This series is based on v6.17-rc2, and can be retrieved from:
https://git.kernel.org/pub/scm/linux/kernel/git/morse/linux.git mpam/driver/rv1
The rest of the driver can be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/morse/linux.git mpam/snapshot/v6.17-rc2
What is MPAM? Set your time-machine to 2020:
https://lore.kernel.org/lkml/[email protected]/
This series was previously posted here:
[RFC] lore.kernel.org/r/[email protected]
Bugs welcome,
Thanks,
James Morse (29):
cacheinfo: Expose the code to generate a cache-id from a device_node
drivers: base: cacheinfo: Add helper to find the cache size from
cpu+level
ACPI / PPTT: Add a helper to fill a cpumask from a processor container ACPI / PPTT: Stop acpi_count_levels() expecting callers to clear
levels
ACPI / PPTT: Find cache level by cache-id
ACPI / PPTT: Add a helper to fill a cpumask from a cache_id
arm64: kconfig: Add Kconfig entry for MPAM
ACPI / MPAM: Parse the MPAM table
arm_mpam: Add probe/remove for mpam msc driver and kbuild boiler plate
arm_mpam: Add the class and component structures for ris firmware
described
arm_mpam: Add MPAM MSC register layout definitions
arm_mpam: Add cpuhp callbacks to probe MSC hardware
arm_mpam: Probe MSCs to find the supported partid/pmg values
arm_mpam: Add helpers for managing the locking around the mon_sel
registers
arm_mpam: Probe the hardware features resctrl supports
arm_mpam: Merge supported features during mpam_enable() into
mpam_class
arm_mpam: Reset MSC controls from cpu hp callbacks
arm_mpam: Add a helper to touch an MSC from any CPU
arm_mpam: Extend reset logic to allow devices to be reset any time
arm_mpam: Register and enable IRQs
arm_mpam: Use a static key to indicate when mpam is enabled
arm_mpam: Allow configuration to be applied and restored during cpu
online
arm_mpam: Probe and reset the rest of the features
arm_mpam: Add helpers to allocate monitors
arm_mpam: Add mpam_msmon_read() to read monitor value
arm_mpam: Track bandwidth counter state for overflow and power
management
arm_mpam: Add helper to reset saved mbwu state
arm_mpam: Add kunit test for bitmap reset
arm_mpam: Add kunit tests for props_mismatch()
Rob Herring (1):
dt-bindings: arm: Add MPAM MSC binding
Rohit Mathew (2):
arm_mpam: Probe for long/lwd mbwu counters
arm_mpam: Use long MBWU counters if supported
Shanker Donthineni (1):
arm_mpam: Add support for memory controller MSC on DT platforms
.../devicetree/bindings/arm/arm,mpam-msc.yaml | 200 ++ arch/arm64/Kconfig | 19 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/acpi/arm64/Kconfig | 3 + drivers/acpi/arm64/Makefile | 1 + drivers/acpi/arm64/mpam.c | 331 ++ drivers/acpi/pptt.c | 230 +- drivers/acpi/tables.c | 2 +- drivers/base/cacheinfo.c | 19 +- drivers/resctrl/Kconfig | 24 + drivers/resctrl/Makefile | 4 + drivers/resctrl/mpam_devices.c | 2909 +++++++++++++++++ drivers/resctrl/mpam_internal.h | 692 ++++ drivers/resctrl/test_mpam_devices.c | 390 +++ include/linux/acpi.h | 26 + include/linux/arm_mpam.h | 56 + include/linux/cacheinfo.h | 16 + 18 files changed, 4911 insertions(+), 14 deletions(-) create mode 100644 Documentation/devicetree/bindings/arm/arm,mpam-msc.yaml create mode 100644 drivers/acpi/arm64/mpam.c create mode 100644 drivers/resctrl/Kconfig create mode 100644 drivers/resctrl/Makefile create mode 100644 drivers/resctrl/mpam_devices.c create mode 100644 drivers/resctrl/mpam_internal.h create mode 100644 drivers/resctrl/test_mpam_devices.c create mode 100644 include/linux/arm_mpam.h
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 17/33 arm_mpam: Probe the hardware features resctrl supports
In reply to James MorseExpand the probing support with the control and monitor types we can use with resctrl.
---
Changes since RFC:
* Made mpam_ris_hw_probe_hw_nrdy() more in C.
* Added static assert on features bitmap size.
--- drivers/resctrl/mpam_devices.c | 156 +++++++++++++++++++++++++++++++- drivers/resctrl/mpam_internal.h | 54 +++++++++++ 2 files changed, 209 insertions(+), 1 deletion(-)
drivers/resctrl/mpam_devices.c +155 -1
@@ -102,7 +102,7 @@ static LLIST_HEAD(mpam_garbage);static u32 __mpam_read_reg (struct mpam_msc *msc,u16 reg) { -WARN_ON_ONCE (reg > msc->mapped_hwpage_sz); +WARN_ON_ONCE (reg +sizeof (u32) > msc->mapped_hwpage_sz);WARN_ON_ONCE (!cpumask_test_cpu (smp_processor_id (), &msc->accessibility));return readl_relaxed (msc->mapped_hwpage + reg);
@@ -131,6 +131,20 @@ static inline void _mpam_write_partsel_reg(struct mpam_msc *msc, u16 reg, u32 va }#define mpam_write_partsel_reg (msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val) +static inline u32 _mpam_read_monsel_reg (struct mpam_msc *msc,u16 reg) +{ +mpam_mon_sel_lock_held (msc); +return __mpam_read_reg (msc, reg); +} +#define mpam_read_monsel_reg (msc, reg) _mpam_read_monsel_reg(msc, MSMON_##reg) + +static inline void _mpam_write_monsel_reg (struct mpam_msc *msc,u16 reg,u32 val) +{ +mpam_mon_sel_lock_held (msc); +__mpam_write_reg (msc, reg, val); +} +#define mpam_write_monsel_reg (msc, reg, val) _mpam_write_monsel_reg(msc, MSMON_##reg, val) +static u64 mpam_msc_read_idr (struct mpam_msc *msc) {u64 idr_high =0 , idr_low;
@@ -643,6 +657,139 @@ static struct mpam_msc_ris *mpam_get_or_create_ris(struct mpam_msc *msc,return found; } +/* +* IHI009A.a has this nugget: "If a monitor does not support automatic behaviour +* of NRDY, software can use this bit for any purpose" - so hardware might not +* implement this - but it isn't RES0. +* +* Try and see what values stick in this bit. If we can write either value, +* its probably not implemented by hardware. +*/ +static bool _mpam_ris_hw_probe_hw_nrdy (struct mpam_msc_ris * ris,u32 mon_reg) +{ +u32 now; +u64 mon_sel; +bool can_set, can_clear; +struct mpam_msc *msc = ris->vmsc->msc; + +if (WARN_ON_ONCE (!mpam_mon_sel_inner_lock (msc))) +return false; + + mon_sel =FIELD_PREP (MSMON_CFG_MON_SEL_MON_SEL ,0 ) | +FIELD_PREP (MSMON_CFG_MON_SEL_RIS , ris->ris_idx); +_mpam_write_monsel_reg (msc, mon_reg, mon_sel); + +_mpam_write_monsel_reg (msc, mon_reg,MSMON___NRDY ); + now =_mpam_read_monsel_reg (msc, mon_reg); + can_set = now &MSMON___NRDY ; + +_mpam_write_monsel_reg (msc, mon_reg,0 ); + now =_mpam_read_monsel_reg (msc, mon_reg); + can_clear = !(now &MSMON___NRDY ); +mpam_mon_sel_inner_unlock (msc); + +return (!can_set || !can_clear); +} + +#define mpam_ris_hw_probe_hw_nrdy (_ris, _mon_reg) \ + _mpam_ris_hw_probe_hw_nrdy(_ris, MSMON_##_mon_reg) + +static void mpam_ris_hw_probe (struct mpam_msc_ris *ris) +{ +int err; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *props = &ris->props; + +lockdep_assert_held (&msc->probe_lock); +lockdep_assert_held (&msc->part_sel_lock); + +/* Cache Portion partitioning */ +if (FIELD_GET (MPAMF_IDR_HAS_CPOR_PART , ris->idr)) { +u32 cpor_features =mpam_read_partsel_reg (msc,CPOR_IDR ); + + props->cpbm_wd =FIELD_GET (MPAMF_CPOR_IDR_CPBM_WD , cpor_features); +if (props->cpbm_wd) +mpam_set_feature (mpam_feat_cpor_part, props); + } + +/* Memory bandwidth partitioning */ +if (FIELD_GET (MPAMF_IDR_HAS_MBW_PART , ris->idr)) { +u32 mbw_features =mpam_read_partsel_reg (msc,MBW_IDR ); + +/* portion bitmap resolution */ + props->mbw_pbm_bits =FIELD_GET (MPAMF_MBW_IDR_BWPBM_WD , mbw_features); +if (props->mbw_pbm_bits && +FIELD_GET (MPAMF_MBW_IDR_HAS_PBM , mbw_features)) +mpam_set_feature (mpam_feat_mbw_part, props); + + props->bwa_wd =FIELD_GET (MPAMF_MBW_IDR_BWA_WD , mbw_features); +if (props->bwa_wd &&FIELD_GET (MPAMF_MBW_IDR_HAS_MAX , mbw_features)) +mpam_set_feature (mpam_feat_mbw_max, props); + } + +/* Performance Monitoring */ +if (FIELD_GET (MPAMF_IDR_HAS_MSMON , ris->idr)) { +u32 msmon_features =mpam_read_partsel_reg (msc,MSMON_IDR ); + +/* +* If the firmware max-nrdy-us property is missing, the +* CSU counters can't be used. Should we wait forever? +*/ + err =device_property_read_u32 (&msc->pdev->dev, +"arm,not-ready-us" , + &msc->nrdy_usec); + +if (FIELD_GET (MPAMF_MSMON_IDR_MSMON_CSU , msmon_features)) { +u32 csumonidr; + + csumonidr =mpam_read_partsel_reg (msc,CSUMON_IDR ); + props->num_csu_mon =FIELD_GET (MPAMF_CSUMON_IDR_NUM_MON , csumonidr); +if (props->num_csu_mon) { +bool hw_managed; + +mpam_set_feature (mpam_feat_msmon_csu, props); + +/* Is NRDY hardware managed? */ +mpam_mon_sel_outer_lock (msc); + hw_managed =mpam_ris_hw_probe_hw_nrdy (ris,CSU ); +mpam_mon_sel_outer_unlock (msc); +if (hw_managed) +mpam_set_feature (mpam_feat_msmon_csu_hw_nrdy, props); + } + +/* +* Accept the missing firmware property if NRDY appears +* un-implemented. +*/ +if (err &&mpam_has_feature (mpam_feat_msmon_csu_hw_nrdy, props)) +pr_err_once ("Counters are not usable because not-ready timeout was not provided by firmware." ); + } +if (FIELD_GET (MPAMF_MSMON_IDR_MSMON_MBWU , msmon_features)) { +bool hw_managed; +u32 mbwumonidr =mpam_read_partsel_reg (msc,MBWUMON_IDR ); + + props->num_mbwu_mon =FIELD_GET (MPAMF_MBWUMON_IDR_NUM_MON , mbwumonidr); +if (props->num_mbwu_mon) +mpam_set_feature (mpam_feat_msmon_mbwu, props); + +if (FIELD_GET (MPAMF_MBWUMON_IDR_HAS_RWBW , mbwumonidr)) +mpam_set_feature (mpam_feat_msmon_mbwu_rwbw, props); + +/* Is NRDY hardware managed? */ +mpam_mon_sel_outer_lock (msc); + hw_managed =mpam_ris_hw_probe_hw_nrdy (ris,MBWU ); +mpam_mon_sel_outer_unlock (msc); +if (hw_managed) +mpam_set_feature (mpam_feat_msmon_mbwu_hw_nrdy, props); + +/* +* Don't warn about any missing firmware property for +* MBWU NRDY - it doesn't make any sense! +*/ + } + } +} +static int mpam_msc_hw_probe (struct mpam_msc *msc) {u64 idr;
@@ -663,6 +810,7 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) idr =mpam_msc_read_idr (msc);mutex_unlock (&msc->part_sel_lock); + msc->ris_max =FIELD_GET (MPAMF_IDR_RIS_MAX , idr);/* Use these values so partid/pmg always starts with a valid value */
@@ -683,6 +831,12 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) ris =mpam_get_or_create_ris (msc, ris_idx);if (IS_ERR (ris))return PTR_ERR (ris); + ris->idr = idr; + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris_idx,0 , msc); +mpam_ris_hw_probe (ris); +mutex_unlock (&msc->part_sel_lock); }spin_lock (&partid_max_lock);
drivers/resctrl/mpam_internal.h +54 -0
72 lines not on this page · raw message
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 18/33 arm_mpam: Merge supported features during mpam_enable() into mpam_class
In reply to James MorseTo make a decision about whether to expose an mpam class as a resctrl resource we need to know its overall supported features and properties.
Once we've probed all the resources, we can walk the tree and produce overall values by merging the bitmaps. This eliminates features that are only supported by some MSC that make up a component or class.
If bitmap properties are mismatched within a component we cannot support the mismatched feature.
Care has to be taken as vMSC may hold mismatched RIS.
--- drivers/resctrl/mpam_devices.c | 215 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 8 ++ 2 files changed, 223 insertions(+)
drivers/resctrl/mpam_devices.c +215 -0
@@ -1186,8 +1186,223 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +/* Any of these features mean the BWA_WD field is valid. */ +static bool mpam_has_bwa_wd_feature (struct mpam_props *props) +{ +if (mpam_has_feature (mpam_feat_mbw_min, props)) +return true; +if (mpam_has_feature (mpam_feat_mbw_max, props)) +return true; +if (mpam_has_feature (mpam_feat_mbw_prop, props)) +return true; +return false; +} + +#define MISMATCHED_HELPER (parent, child, helper, field, alias) \ + helper(parent) && \ + ((helper(child) && (parent)->field != (child)->field) || \ + (!helper(child) && !(alias))) + +#define MISMATCHED_FEAT (parent, child, feat, field, alias) \ + mpam_has_feature((feat), (parent)) && \ + ((mpam_has_feature((feat), (child)) && (parent)->field != (child)->field) || \ + (!mpam_has_feature((feat), (child)) && !(alias))) + +#define CAN_MERGE_FEAT (parent, child, feat, alias) \ + (alias) && !mpam_has_feature((feat), (parent)) && \ + mpam_has_feature((feat), (child)) + +/* +* Combine two props fields. +* If this is for controls that alias the same resource, it is safe to just +* copy the values over. If two aliasing controls implement the same scheme +* a safe value must be picked. +* For non-aliasing controls, these control different resources, and the +* resulting safe value must be compatible with both. When merging values in +* the tree, all the aliasing resources must be handled first. +* On mismatch, parent is modified. +*/ +static void __props_mismatch (struct mpam_props *parent, +struct mpam_props *child,bool alias) +{ +if (CAN_MERGE_FEAT (parent, child, mpam_feat_cpor_part, alias)) { + parent->cpbm_wd = child->cpbm_wd; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_cpor_part, + cpbm_wd, alias)) { +pr_debug ("%s cleared cpor_part\n" , __func__); +mpam_clear_feature (mpam_feat_cpor_part, &parent->features); + parent->cpbm_wd =0 ; + } + +if (CAN_MERGE_FEAT (parent, child, mpam_feat_mbw_part, alias)) { + parent->mbw_pbm_bits = child->mbw_pbm_bits; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_mbw_part, + mbw_pbm_bits, alias)) { +pr_debug ("%s cleared mbw_part\n" , __func__); +mpam_clear_feature (mpam_feat_mbw_part, &parent->features); + parent->mbw_pbm_bits =0 ; + } + +/* bwa_wd is a count of bits, fewer bits means less precision */ +if (alias && !mpam_has_bwa_wd_feature (parent) &&mpam_has_bwa_wd_feature (child)) { + parent->bwa_wd = child->bwa_wd; + }else if (MISMATCHED_HELPER (parent, child, mpam_has_bwa_wd_feature, + bwa_wd, alias)) { +pr_debug ("%s took the min bwa_wd\n" , __func__); + parent->bwa_wd =min (parent->bwa_wd, child->bwa_wd); + } + +/* For num properties, take the minimum */ +if (CAN_MERGE_FEAT (parent, child, mpam_feat_msmon_csu, alias)) { + parent->num_csu_mon = child->num_csu_mon; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_msmon_csu, + num_csu_mon, alias)) { +pr_debug ("%s took the min num_csu_mon\n" , __func__); + parent->num_csu_mon =min (parent->num_csu_mon, child->num_csu_mon); + } + +if (CAN_MERGE_FEAT (parent, child, mpam_feat_msmon_mbwu, alias)) { + parent->num_mbwu_mon = child->num_mbwu_mon; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_msmon_mbwu, + num_mbwu_mon, alias)) { +pr_debug ("%s took the min num_mbwu_mon\n" , __func__); + parent->num_mbwu_mon =min (parent->num_mbwu_mon, child->num_mbwu_mon); + } + +if (alias) { +/* Merge features for aliased resources */ + parent->features |= child->features; + }else { +/* Clear missing features for non aliasing */ + parent->features &= child->features; + } +} + +/* +* If a vmsc doesn't match class feature/configuration, do the right thing(tm). +* For 'num' properties we can just take the minimum. +* For properties where the mismatched unused bits would make a difference, we +* nobble the class feature, as we can't configure all the resources. +* e.g. The L3 cache is composed of two resources with 13 and 17 portion +* bitmaps respectively. +*/ +static void +__class_props_mismatch (struct mpam_class *class,struct mpam_vmsc *vmsc) +{ +struct mpam_props *cprops = &class->props; +struct mpam_props *vprops = &vmsc->props; + +lockdep_assert_held (&mpam_list_lock);/* we modify class */ + +pr_debug ("%s: Merging features for class:0x%lx &= vmsc:0x%lx\n" , +dev_name (&vmsc->msc->pdev->dev), + (long )cprops->features, (long )vprops->features); + +/* Take the safe value for any common features */ +__props_mismatch (cprops, vprops, false); +} + +static void +__vmsc_props_mismatch (struct mpam_vmsc *vmsc,struct mpam_msc_ris *ris) +{ +struct mpam_props *rprops = &ris->props; +struct mpam_props *vprops = &vmsc->props; + +lockdep_assert_held (&mpam_list_lock);/* we modify vmsc */ + +pr_debug ("%s: Merging features for vmsc:0x%lx |= ris:0x%lx\n" , +dev_name (&vmsc->msc->pdev->dev), + (long )vprops->features, (long )rprops->features); + +/* +* Merge mismatched features - Copy any features that aren't common, +* but take the safe value for any common features. +*/ +__props_mismatch (vprops, rprops, true); +} + +/* +* Copy the first component's first vMSC's properties and features to the +* class. __class_props_mismatch() will remove conflicts. +* It is not possible to have a class with no components, or a component with +* no resources. The vMSC properties have already been built. +*/ +static void mpam_enable_init_class_features (struct mpam_class *class) +{ +struct mpam_vmsc *vmsc; +struct mpam_component *comp; + + comp =list_first_entry_or_null (&class->components, + struct mpam_component, class_list); +if (WARN_ON (!comp)) +return ; + + vmsc =list_first_entry_or_null (&comp->vmsc, + struct mpam_vmsc, comp_list); +if (WARN_ON (!vmsc)) +return ; + + class->props = vmsc->props; +} + +static void mpam_enable_merge_vmsc_features (struct mpam_component *comp) +{ +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class = comp->class; + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +list_for_each_entry (ris, &vmsc->ris, vmsc_list) { +__vmsc_props_mismatch (vmsc, ris); + class->nrdy_usec =max (class->nrdy_usec, + vmsc->msc->nrdy_usec); + } + } +} + +static void mpam_enable_merge_class_features (struct mpam_component *comp) +{ +struct mpam_vmsc *vmsc; +struct mpam_class *class = comp->class; + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) +__class_props_mismatch (class, vmsc); +} + +/* +* Merge all the common resource features into class. +* vmsc features are bitwise-or'd together, this must be done first. +* Next the class features are the bitwise-and of all the vmsc features. +* Other features are the min/max as appropriate. +* +* To avoid walking the whole tree twice, the class->nrdy_usec property is +* updated when working with the vmsc as it is a max(), and doesn't need +* initialising first. +*/ +static void mpam_enable_merge_features (struct list_head *all_classes_list) +{ +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (class, all_classes_list, classes_list) { +list_for_each_entry (comp, &class->components, class_list) +mpam_enable_merge_vmsc_features (comp); + +mpam_enable_init_class_features (class); + +list_for_each_entry (comp, &class->components, class_list) +mpam_enable_merge_class_features (comp); + } +} +static void mpam_enable_once (void ) { +mutex_lock (&mpam_list_lock); +mpam_enable_merge_features (&mpam_classes); +mutex_unlock (&mpam_list_lock); +/* * Once the cpuhp callbacks have been changed, mpam_partid_max can no * longer change.
drivers/resctrl/mpam_internal.h +8 -0
@@ -186,12 +186,20 @@ static inline void mpam_set_feature(enum mpam_device_features feat, props->features |= (1 << feat); } +static inline void mpam_clear_feature (enum mpam_device_features feat, +mpam_features_t *supported) +{ + *supported &= ~(1 << feat); +} +struct mpam_class {/* mpam_components in this class */ struct list_head components;cpumask_t affinity; +struct mpam_props props; +u32 nrdy_usec;u8 level;enum mpam_class_types type;
Signature · 1 line
2.20.1
Re: [PATCH 18/33] arm_mpam: Merge supported features during mpam_enable() into mpam_class
Hi James,
Quoted 12 lines · James Morse
To make a decision about whether to expose an mpam class as a resctrl resource we need to know its overall supported features and properties.
Once we've probed all the resources, we can walk the tree and produce overall values by merging the bitmaps. This eliminates features that are only supported by some MSC that make up a component or class.
If bitmap properties are mismatched within a component we cannot support the mismatched feature.
Quoted 7 lines
Care has to be taken as vMSC may hold mismatched RIS.
Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 215 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 8 ++ 2 files changed, 223 insertions(+)
Intricate but, as far as I can tell, all correct.
Thanks,
Ben
James Morse
maintainerRe: [PATCH 18/33] arm_mpam: Merge supported features during mpam_enable() into mpam_class
Hi Ben,
Quoted 10 lines · Ben Horgan
Quoted 9 lines · James Morse
To make a decision about whether to expose an mpam class as a resctrl resource we need to know its overall supported features and properties.
Once we've probed all the resources, we can walk the tree and produce overall values by merging the bitmaps. This eliminates features that are only supported by some MSC that make up a component or class.
Quoted 6 lines
Quoted 4 lines
If bitmap properties are mismatched within a component we cannot support the mismatched feature.
Care has to be taken as vMSC may hold mismatched RIS.
Intricate but, as far as I can tell, all correct.
Yeah - its cpufeature.c all over again.
Quoted 1 line
Reviewed-by Ben Horgan <[email protected]>
Thanks!
James
James Morse
maintainerPATCH 18/33 arm_mpam: Merge supported features during mpam_enable() into mpam_class
In reply to James MorseTo make a decision about whether to expose an mpam class as a resctrl resource we need to know its overall supported features and properties.
Once we've probed all the resources, we can walk the tree and produce overall values by merging the bitmaps. This eliminates features that are only supported by some MSC that make up a component or class.
If bitmap properties are mismatched within a component we cannot support the mismatched feature.
Care has to be taken as vMSC may hold mismatched RIS.
--- drivers/resctrl/mpam_devices.c | 215 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 8 ++ 2 files changed, 223 insertions(+)
drivers/resctrl/mpam_devices.c +215 -0
@@ -1186,8 +1186,223 @@ static struct platform_driver mpam_msc_driver = { .remove = mpam_msc_drv_remove, }; +/* Any of these features mean the BWA_WD field is valid. */ +static bool mpam_has_bwa_wd_feature (struct mpam_props *props) +{ +if (mpam_has_feature (mpam_feat_mbw_min, props)) +return true; +if (mpam_has_feature (mpam_feat_mbw_max, props)) +return true; +if (mpam_has_feature (mpam_feat_mbw_prop, props)) +return true; +return false; +} + +#define MISMATCHED_HELPER (parent, child, helper, field, alias) \ + helper(parent) && \ + ((helper(child) && (parent)->field != (child)->field) || \ + (!helper(child) && !(alias))) + +#define MISMATCHED_FEAT (parent, child, feat, field, alias) \ + mpam_has_feature((feat), (parent)) && \ + ((mpam_has_feature((feat), (child)) && (parent)->field != (child)->field) || \ + (!mpam_has_feature((feat), (child)) && !(alias))) + +#define CAN_MERGE_FEAT (parent, child, feat, alias) \ + (alias) && !mpam_has_feature((feat), (parent)) && \ + mpam_has_feature((feat), (child)) + +/* +* Combine two props fields. +* If this is for controls that alias the same resource, it is safe to just +* copy the values over. If two aliasing controls implement the same scheme +* a safe value must be picked. +* For non-aliasing controls, these control different resources, and the +* resulting safe value must be compatible with both. When merging values in +* the tree, all the aliasing resources must be handled first. +* On mismatch, parent is modified. +*/ +static void __props_mismatch (struct mpam_props *parent, +struct mpam_props *child,bool alias) +{ +if (CAN_MERGE_FEAT (parent, child, mpam_feat_cpor_part, alias)) { + parent->cpbm_wd = child->cpbm_wd; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_cpor_part, + cpbm_wd, alias)) { +pr_debug ("%s cleared cpor_part\n" , __func__); +mpam_clear_feature (mpam_feat_cpor_part, &parent->features); + parent->cpbm_wd =0 ; + } + +if (CAN_MERGE_FEAT (parent, child, mpam_feat_mbw_part, alias)) { + parent->mbw_pbm_bits = child->mbw_pbm_bits; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_mbw_part, + mbw_pbm_bits, alias)) { +pr_debug ("%s cleared mbw_part\n" , __func__); +mpam_clear_feature (mpam_feat_mbw_part, &parent->features); + parent->mbw_pbm_bits =0 ; + } + +/* bwa_wd is a count of bits, fewer bits means less precision */ +if (alias && !mpam_has_bwa_wd_feature (parent) &&mpam_has_bwa_wd_feature (child)) { + parent->bwa_wd = child->bwa_wd; + }else if (MISMATCHED_HELPER (parent, child, mpam_has_bwa_wd_feature, + bwa_wd, alias)) { +pr_debug ("%s took the min bwa_wd\n" , __func__); + parent->bwa_wd =min (parent->bwa_wd, child->bwa_wd); + } + +/* For num properties, take the minimum */ +if (CAN_MERGE_FEAT (parent, child, mpam_feat_msmon_csu, alias)) { + parent->num_csu_mon = child->num_csu_mon; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_msmon_csu, + num_csu_mon, alias)) { +pr_debug ("%s took the min num_csu_mon\n" , __func__); + parent->num_csu_mon =min (parent->num_csu_mon, child->num_csu_mon); + } + +if (CAN_MERGE_FEAT (parent, child, mpam_feat_msmon_mbwu, alias)) { + parent->num_mbwu_mon = child->num_mbwu_mon; + }else if (MISMATCHED_FEAT (parent, child, mpam_feat_msmon_mbwu, + num_mbwu_mon, alias)) { +pr_debug ("%s took the min num_mbwu_mon\n" , __func__); + parent->num_mbwu_mon =min (parent->num_mbwu_mon, child->num_mbwu_mon); + } + +if (alias) { +/* Merge features for aliased resources */ + parent->features |= child->features; + }else { +/* Clear missing features for non aliasing */ + parent->features &= child->features; + } +} + +/* +* If a vmsc doesn't match class feature/configuration, do the right thing(tm). +* For 'num' properties we can just take the minimum. +* For properties where the mismatched unused bits would make a difference, we +* nobble the class feature, as we can't configure all the resources. +* e.g. The L3 cache is composed of two resources with 13 and 17 portion +* bitmaps respectively. +*/ +static void +__class_props_mismatch (struct mpam_class *class,struct mpam_vmsc *vmsc) +{ +struct mpam_props *cprops = &class->props; +struct mpam_props *vprops = &vmsc->props; + +lockdep_assert_held (&mpam_list_lock);/* we modify class */ + +pr_debug ("%s: Merging features for class:0x%lx &= vmsc:0x%lx\n" , +dev_name (&vmsc->msc->pdev->dev), + (long )cprops->features, (long )vprops->features); + +/* Take the safe value for any common features */ +__props_mismatch (cprops, vprops, false); +} + +static void +__vmsc_props_mismatch (struct mpam_vmsc *vmsc,struct mpam_msc_ris *ris) +{ +struct mpam_props *rprops = &ris->props; +struct mpam_props *vprops = &vmsc->props; + +lockdep_assert_held (&mpam_list_lock);/* we modify vmsc */ + +pr_debug ("%s: Merging features for vmsc:0x%lx |= ris:0x%lx\n" , +dev_name (&vmsc->msc->pdev->dev), + (long )vprops->features, (long )rprops->features); + +/* +* Merge mismatched features - Copy any features that aren't common, +* but take the safe value for any common features. +*/ +__props_mismatch (vprops, rprops, true); +} + +/* +* Copy the first component's first vMSC's properties and features to the +* class. __class_props_mismatch() will remove conflicts. +* It is not possible to have a class with no components, or a component with +* no resources. The vMSC properties have already been built. +*/ +static void mpam_enable_init_class_features (struct mpam_class *class) +{ +struct mpam_vmsc *vmsc; +struct mpam_component *comp; + + comp =list_first_entry_or_null (&class->components, + struct mpam_component, class_list); +if (WARN_ON (!comp)) +return ; + + vmsc =list_first_entry_or_null (&comp->vmsc, + struct mpam_vmsc, comp_list); +if (WARN_ON (!vmsc)) +return ; + + class->props = vmsc->props; +} + +static void mpam_enable_merge_vmsc_features (struct mpam_component *comp) +{ +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; +struct mpam_class *class = comp->class; + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) { +list_for_each_entry (ris, &vmsc->ris, vmsc_list) { +__vmsc_props_mismatch (vmsc, ris); + class->nrdy_usec =max (class->nrdy_usec, + vmsc->msc->nrdy_usec); + } + } +} + +static void mpam_enable_merge_class_features (struct mpam_component *comp) +{ +struct mpam_vmsc *vmsc; +struct mpam_class *class = comp->class; + +list_for_each_entry (vmsc, &comp->vmsc, comp_list) +__class_props_mismatch (class, vmsc); +} + +/* +* Merge all the common resource features into class. +* vmsc features are bitwise-or'd together, this must be done first. +* Next the class features are the bitwise-and of all the vmsc features. +* Other features are the min/max as appropriate. +* +* To avoid walking the whole tree twice, the class->nrdy_usec property is +* updated when working with the vmsc as it is a max(), and doesn't need +* initialising first. +*/ +static void mpam_enable_merge_features (struct list_head *all_classes_list) +{ +struct mpam_class *class; +struct mpam_component *comp; + +lockdep_assert_held (&mpam_list_lock); + +list_for_each_entry (class, all_classes_list, classes_list) { +list_for_each_entry (comp, &class->components, class_list) +mpam_enable_merge_vmsc_features (comp); + +mpam_enable_init_class_features (class); + +list_for_each_entry (comp, &class->components, class_list) +mpam_enable_merge_class_features (comp); + } +} +static void mpam_enable_once (void ) { +mutex_lock (&mpam_list_lock); +mpam_enable_merge_features (&mpam_classes); +mutex_unlock (&mpam_list_lock); +/* * Once the cpuhp callbacks have been changed, mpam_partid_max can no * longer change.
drivers/resctrl/mpam_internal.h +8 -0
@@ -186,12 +186,20 @@ static inline void mpam_set_feature(enum mpam_device_features feat, props->features |= (1 << feat); } +static inline void mpam_clear_feature (enum mpam_device_features feat, +mpam_features_t *supported) +{ + *supported &= ~(1 << feat); +} +struct mpam_class {/* mpam_components in this class */ struct list_head components;cpumask_t affinity; +struct mpam_props props; +u32 nrdy_usec;u8 level;enum mpam_class_types type;
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 19/33 arm_mpam: Reset MSC controls from cpu hp callbacks
In reply to James MorseWhen a CPU comes online, it may bring a newly accessible MSC with it. Only the default partid has its value reset by hardware, and even then the MSC might not have been reset since its config was previously dirtyied. e.g. Kexec.
Any in-use partid must have its configuration restored, or reset. In-use partids may be held in caches and evicted later.
MSC are also reset when CPUs are taken offline to cover cases where firmware doesn't reset the MSC over reboot using UEFI, or kexec where there is no firmware involvement.
If the configuration for a RIS has not been touched since it was brought online, it does not need resetting again.
To reset, write the maximum values for all discovered controls.
---
Changes since RFC:
* Last bitmap write will always be non-zero.
* Dropped READ_ONCE() - teh value can no longer change.
--- drivers/resctrl/mpam_devices.c | 121 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 8 +++ 2 files changed, 129 insertions(+)
drivers/resctrl/mpam_devices.c +121 -0
@@ -7,6 +7,7 @@#include <linux/atomic.h> #include <linux/arm_mpam.h> #include <linux/bitfield.h> +#include <linux/bitmap.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h>
@@ -849,8 +850,115 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)return 0 ; } +static void mpam_reset_msc_bitmap (struct mpam_msc *msc,u16 reg,u16 wd) +{ +u32 num_words, msb; +u32 bm = ~0 ; +int i; + +lockdep_assert_held (&msc->part_sel_lock); + +if (wd ==0 ) +return ; + +/* +* Write all ~0 to all but the last 32bit-word, which may +* have fewer bits... +*/ + num_words =DIV_ROUND_UP (wd,32 ); +for (i =0 ; i < num_words -1 ; i++, reg +=sizeof (bm)) +__mpam_write_reg (msc, reg, bm); + +/* +* ....and then the last (maybe) partial 32bit word. When wd is a +* multiple of 32, msb should be 31 to write a full 32bit word. +*/ + msb = (wd -1 ) %32 ; + bm =GENMASK (msb,0 ); +__mpam_write_reg (msc, reg, bm); +} + +static void mpam_reset_ris_partid (struct mpam_msc_ris *ris,u16 partid) +{ +u16 bwa_fract =MPAMCFG_MBW_MAX_MAX ; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *rprops = &ris->props; + +mpam_assert_srcu_read_lock_held (); + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris->ris_idx, partid, msc); + +if (mpam_has_feature (mpam_feat_cpor_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_CPBM , rprops->cpbm_wd); + +if (mpam_has_feature (mpam_feat_mbw_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_MBW_PBM , rprops->mbw_pbm_bits); + +if (mpam_has_feature (mpam_feat_mbw_min, rprops)) +mpam_write_partsel_reg (msc,MBW_MIN ,0 ); + +if (mpam_has_feature (mpam_feat_mbw_max, rprops)) +mpam_write_partsel_reg (msc,MBW_MAX , bwa_fract); + +if (mpam_has_feature (mpam_feat_mbw_prop, rprops)) +mpam_write_partsel_reg (msc,MBW_PROP , bwa_fract); +mutex_unlock (&msc->part_sel_lock); +} + +static void mpam_reset_ris (struct mpam_msc_ris *ris) +{ +u16 partid, partid_max; + +mpam_assert_srcu_read_lock_held (); + +if (ris->in_reset_state) +return ; + +spin_lock (&partid_max_lock); + partid_max = mpam_partid_max; +spin_unlock (&partid_max_lock); +for (partid =0 ; partid < partid_max; partid++) +mpam_reset_ris_partid (ris, partid); +} + +static void mpam_reset_msc (struct mpam_msc *msc,bool online) +{ +int idx; +struct mpam_msc_ris *ris; + +mpam_assert_srcu_read_lock_held (); + +mpam_mon_sel_outer_lock (msc); + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (ris, &msc->ris, msc_list,srcu_read_lock_held (&mpam_srcu)) { +mpam_reset_ris (ris); + +/* +* Set in_reset_state when coming online. The reset state +* for non-zero partid may be lost while the CPUs are offline. +*/ + ris->in_reset_state = online; + } +srcu_read_unlock (&mpam_srcu, idx); +mpam_mon_sel_outer_unlock (msc); +} +static int mpam_cpu_online (unsigned int cpu) { +int idx; +struct mpam_msc *msc; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (msc, &mpam_all_msc, glbl_list,srcu_read_lock_held (&mpam_srcu)) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +if (atomic_fetch_inc (&msc->online_refs) ==0 ) +mpam_reset_msc (msc, true); + } +srcu_read_unlock (&mpam_srcu, idx); +return 0 ; }
@@ -886,6 +994,19 @@ static int mpam_discovery_cpu_online(unsigned int cpu)static int mpam_cpu_offline (unsigned int cpu) { +int idx; +struct mpam_msc *msc; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (msc, &mpam_all_msc, glbl_list,srcu_read_lock_held (&mpam_srcu)) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +if (atomic_dec_and_test (&msc->online_refs)) +mpam_reset_msc (msc, false); + } +srcu_read_unlock (&mpam_srcu, idx); +return 0 ; }
drivers/resctrl/mpam_internal.h +8 -0
@@ -5,6 +5,7 @@#define MPAM_INTERNAL_H #include <linux/arm_mpam.h> +#include <linux/atomic.h> #include <linux/cpumask.h> #include <linux/io.h> #include <linux/llist.h>
@@ -43,6 +44,7 @@ struct mpam_msc {struct pcc_mbox_chan *pcc_chan;u32 nrdy_usec;cpumask_t accessibility; +atomic_t online_refs;/* * probe_lock is only take during discovery. After discovery these
@@ -248,6 +250,7 @@ struct mpam_msc_ris {u8 ris_idx;u64 idr;struct mpam_props props; +bool in_reset_state;cpumask_t affinity;
@@ -267,6 +270,11 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +static inline void mpam_assert_srcu_read_lock_held (void ) +{ +WARN_ON_ONCE (!srcu_read_lock_held ((&mpam_srcu))); +} +/* System wide partid/pmg values */ extern u16 mpam_partid_max;extern u8 mpam_pmg_max;
Signature · 1 line
2.20.1
Ben Horgan
maintainerRe: [PATCH 19/33] arm_mpam: Reset MSC controls from cpu hp callbacks
Hi James,
Quoted 84 lines · James Morse
When a CPU comes online, it may bring a newly accessible MSC with it. Only the default partid has its value reset by hardware, and even then the MSC might not have been reset since its config was previously dirtyied. e.g. Kexec.
Any in-use partid must have its configuration restored, or reset. In-use partids may be held in caches and evicted later.
MSC are also reset when CPUs are taken offline to cover cases where firmware doesn't reset the MSC over reboot using UEFI, or kexec where there is no firmware involvement.
If the configuration for a RIS has not been touched since it was brought online, it does not need resetting again.
To reset, write the maximum values for all discovered controls.
CC Rohit Mathew <[email protected]>Signed-off-by James Morse <[email protected]>---
Changes since RFC:
* Last bitmap write will always be non-zero.
* DroppedREAD_ONCE()- teh value can no longer change.--- drivers/resctrl/mpam_devices.c | 121 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 8 +++ 2 files changed, 129 insertions(+)drivers/resctrl/mpam_devices.c +41
-0@@ -7,6 +7,7 @@#include <linux/atomic.h> #include <linux/arm_mpam.h> #include <linux/bitfield.h> +#include <linux/bitmap.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h> @@ -849,8 +850,115 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)return 0 ; } +static void mpam_reset_msc_bitmap (struct mpam_msc *msc,u16 reg,u16 wd) +{ +u32 num_words, msb; +u32 bm = ~0 ; +int i; + +lockdep_assert_held (&msc->part_sel_lock); + +if (wd ==0 ) +return ; + +/* +* Write all ~0 to all but the last 32bit-word, which may +* have fewer bits... +*/ + num_words =DIV_ROUND_UP (wd,32 ); +for (i =0 ; i < num_words -1 ; i++, reg +=sizeof (bm)) +__mpam_write_reg (msc, reg, bm); + +/* +* ....and then the last (maybe) partial 32bit word. When wd is a +* multiple of 32, msb should be 31 to write a full 32bit word. +*/ + msb = (wd -1 ) %32 ; + bm =GENMASK (msb,0 ); +__mpam_write_reg (msc, reg, bm); +} + +static void mpam_reset_ris_partid (struct mpam_msc_ris *ris,u16 partid) +{ +u16 bwa_fract =MPAMCFG_MBW_MAX_MAX ; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *rprops = &ris->props; + +mpam_assert_srcu_read_lock_held (); + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris->ris_idx, partid, msc); + +if (mpam_has_feature (mpam_feat_cpor_part, rprops))
drivers/resctrl/mpam_devices.c static int mpam_msc_hw_probe(struct mpam_msc *msc) · line 902
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+mpam_reset_msc_bitmap (msc,MPAMCFG_CPBM , rprops->cpbm_wd); + +if (mpam_has_feature (mpam_feat_mbw_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_MBW_PBM , rprops->mbw_pbm_bits); + +if (mpam_has_feature (mpam_feat_mbw_min, rprops)) +mpam_write_partsel_reg (msc,MBW_MIN ,0 ); + +if (mpam_has_feature (mpam_feat_mbw_max, rprops)) +mpam_write_partsel_reg (msc,MBW_MAX , bwa_fract);
MPAMCFG_MBW_MAX_MAX can be used directly instead of bwa_fract.
drivers/resctrl/mpam_devices.c static int mpam_msc_hw_probe(struct mpam_msc *msc) · line 905
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+ +if (mpam_has_feature (mpam_feat_mbw_prop, rprops)) +mpam_write_partsel_reg (msc,MBW_PROP , bwa_fract);
Shouldn't this reset to 0? STRIDEM1 is a cost.
Quoted 109 lines
drivers/resctrl/mpam_devices.c +67
-0+mutex_unlock (&msc->part_sel_lock); +} + +static void mpam_reset_ris (struct mpam_msc_ris *ris) +{ +u16 partid, partid_max; + +mpam_assert_srcu_read_lock_held (); + +if (ris->in_reset_state) +return ; + +spin_lock (&partid_max_lock); + partid_max = mpam_partid_max; +spin_unlock (&partid_max_lock); +for (partid =0 ; partid < partid_max; partid++) +mpam_reset_ris_partid (ris, partid); +} + +static void mpam_reset_msc (struct mpam_msc *msc,bool online) +{ +int idx; +struct mpam_msc_ris *ris; + +mpam_assert_srcu_read_lock_held (); + +mpam_mon_sel_outer_lock (msc); + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (ris, &msc->ris, msc_list,srcu_read_lock_held (&mpam_srcu)) { +mpam_reset_ris (ris); + +/* +* Set in_reset_state when coming online. The reset state +* for non-zero partid may be lost while the CPUs are offline. +*/ + ris->in_reset_state = online; + } +srcu_read_unlock (&mpam_srcu, idx); +mpam_mon_sel_outer_unlock (msc); +} +static int mpam_cpu_online (unsigned int cpu) { +int idx; +struct mpam_msc *msc; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (msc, &mpam_all_msc, glbl_list,srcu_read_lock_held (&mpam_srcu)) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +if (atomic_fetch_inc (&msc->online_refs) ==0 ) +mpam_reset_msc (msc, true); + } +srcu_read_unlock (&mpam_srcu, idx); +return 0 ; }@@ -886,6 +994,19 @@ static int mpam_discovery_cpu_online(unsigned int cpu)static int mpam_cpu_offline (unsigned int cpu) { +int idx; +struct mpam_msc *msc; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (msc, &mpam_all_msc, glbl_list,srcu_read_lock_held (&mpam_srcu)) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +if (atomic_dec_and_test (&msc->online_refs)) +mpam_reset_msc (msc, false); + } +srcu_read_unlock (&mpam_srcu, idx); +return 0 ; }drivers/resctrl/mpam_internal.h +3
-0@@ -5,6 +5,7 @@#define MPAM_INTERNAL_H #include <linux/arm_mpam.h> +#include <linux/atomic.h> #include <linux/cpumask.h> #include <linux/io.h> #include <linux/llist.h> @@ -43,6 +44,7 @@ struct mpam_msc {struct pcc_mbox_chan *pcc_chan;u32 nrdy_usec;cpumask_t accessibility; +atomic_t online_refs;/* * probe_lock is only take during discovery. After discovery these @@ -248,6 +250,7 @@ struct mpam_msc_ris {u8 ris_idx;u64 idr;struct mpam_props props; +bool in_reset_state;cpumask_t affinity;@@ -267,6 +270,11 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;
drivers/resctrl/mpam_internal.h struct mpam_msc_ris { · line 280
Quoted 10 lines
drivers/resctrl/mpam_internal.h +5
-0extern struct list_head mpam_classes; +static inline void mpam_assert_srcu_read_lock_held (void ) +{ +WARN_ON_ONCE (!srcu_read_lock_held ((&mpam_srcu))); +} +/* System wide partid/pmg values */ extern u16 mpam_partid_max;extern u8 mpam_pmg_max;
Thanks,
Ben
James Morse
maintainerRe: [PATCH 19/33] arm_mpam: Reset MSC controls from cpu hp callbacks
Hi Ben,
Quoted 41 lines · Ben Horgan
Quoted 40 lines · James Morse
When a CPU comes online, it may bring a newly accessible MSC with it. Only the default partid has its value reset by hardware, and even then the MSC might not have been reset since its config was previously dirtyied. e.g. Kexec.
Any in-use partid must have its configuration restored, or reset. In-use partids may be held in caches and evicted later.
MSC are also reset when CPUs are taken offline to cover cases where firmware doesn't reset the MSC over reboot using UEFI, or kexec where there is no firmware involvement.
If the configuration for a RIS has not been touched since it was brought online, it does not need resetting again.
To reset, write the maximum values for all discovered controls.
drivers/resctrl/mpam_devices.c +16
-0@@ -849,8 +850,115 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc) +static void mpam_reset_ris_partid (struct mpam_msc_ris *ris,u16 partid) +{ +u16 bwa_fract =MPAMCFG_MBW_MAX_MAX ; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *rprops = &ris->props; + +mpam_assert_srcu_read_lock_held (); + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris->ris_idx, partid, msc); + +if (mpam_has_feature (mpam_feat_cpor_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_CPBM , rprops->cpbm_wd); + +if (mpam_has_feature (mpam_feat_mbw_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_MBW_PBM , rprops->mbw_pbm_bits);
Quoted 8 lines
drivers/resctrl/mpam_devices.c static int mpam_msc_hw_probe(struct mpam_msc *msc) · line 902
Quoted 6 lines
drivers/resctrl/mpam_devices.c +6
-0+ +if (mpam_has_feature (mpam_feat_mbw_min, rprops)) +mpam_write_partsel_reg (msc,MBW_MIN ,0 ); + +if (mpam_has_feature (mpam_feat_mbw_max, rprops)) +mpam_write_partsel_reg (msc,MBW_MAX , bwa_fract);
MPAMCFG_MBW_MAX_MAXcan be used directly instead ofbwa_fract.
Without the second user, yes.
Quoted 5 lines
drivers/resctrl/mpam_devices.c static int mpam_msc_hw_probe(struct mpam_msc *msc) · line 905
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+ +if (mpam_has_feature (mpam_feat_mbw_prop, rprops)) +mpam_write_partsel_reg (msc,MBW_PROP , bwa_fract);Shouldn't this reset to 0? STRIDEM1 is a cost.
Heh, this is just a copy and paste of the last value, because it clears the 'enable' bit, and the spec says "there is no setting of the STRIDEM1 control field that disables the effects of proportional-stride".
Yes - zero would be better.
Thanks,
James
James Morse
maintainerPATCH 19/33 arm_mpam: Reset MSC controls from cpu hp callbacks
In reply to James MorseWhen a CPU comes online, it may bring a newly accessible MSC with it. Only the default partid has its value reset by hardware, and even then the MSC might not have been reset since its config was previously dirtyied. e.g. Kexec.
Any in-use partid must have its configuration restored, or reset. In-use partids may be held in caches and evicted later.
MSC are also reset when CPUs are taken offline to cover cases where firmware doesn't reset the MSC over reboot using UEFI, or kexec where there is no firmware involvement.
If the configuration for a RIS has not been touched since it was brought online, it does not need resetting again.
To reset, write the maximum values for all discovered controls.
---
Changes since RFC:
* Last bitmap write will always be non-zero.
* Dropped READ_ONCE() - teh value can no longer change.
--- drivers/resctrl/mpam_devices.c | 121 ++++++++++++++++++++++++++++++++ drivers/resctrl/mpam_internal.h | 8 +++ 2 files changed, 129 insertions(+)
drivers/resctrl/mpam_devices.c +121 -0
@@ -7,6 +7,7 @@#include <linux/atomic.h> #include <linux/arm_mpam.h> #include <linux/bitfield.h> +#include <linux/bitmap.h> #include <linux/cacheinfo.h> #include <linux/cpu.h> #include <linux/cpumask.h>
@@ -849,8 +850,115 @@ static int mpam_msc_hw_probe(struct mpam_msc *msc)return 0 ; } +static void mpam_reset_msc_bitmap (struct mpam_msc *msc,u16 reg,u16 wd) +{ +u32 num_words, msb; +u32 bm = ~0 ; +int i; + +lockdep_assert_held (&msc->part_sel_lock); + +if (wd ==0 ) +return ; + +/* +* Write all ~0 to all but the last 32bit-word, which may +* have fewer bits... +*/ + num_words =DIV_ROUND_UP (wd,32 ); +for (i =0 ; i < num_words -1 ; i++, reg +=sizeof (bm)) +__mpam_write_reg (msc, reg, bm); + +/* +* ....and then the last (maybe) partial 32bit word. When wd is a +* multiple of 32, msb should be 31 to write a full 32bit word. +*/ + msb = (wd -1 ) %32 ; + bm =GENMASK (msb,0 ); +__mpam_write_reg (msc, reg, bm); +} + +static void mpam_reset_ris_partid (struct mpam_msc_ris *ris,u16 partid) +{ +u16 bwa_fract =MPAMCFG_MBW_MAX_MAX ; +struct mpam_msc *msc = ris->vmsc->msc; +struct mpam_props *rprops = &ris->props; + +mpam_assert_srcu_read_lock_held (); + +mutex_lock (&msc->part_sel_lock); +__mpam_part_sel (ris->ris_idx, partid, msc); + +if (mpam_has_feature (mpam_feat_cpor_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_CPBM , rprops->cpbm_wd); + +if (mpam_has_feature (mpam_feat_mbw_part, rprops)) +mpam_reset_msc_bitmap (msc,MPAMCFG_MBW_PBM , rprops->mbw_pbm_bits); + +if (mpam_has_feature (mpam_feat_mbw_min, rprops)) +mpam_write_partsel_reg (msc,MBW_MIN ,0 ); + +if (mpam_has_feature (mpam_feat_mbw_max, rprops)) +mpam_write_partsel_reg (msc,MBW_MAX , bwa_fract); + +if (mpam_has_feature (mpam_feat_mbw_prop, rprops)) +mpam_write_partsel_reg (msc,MBW_PROP , bwa_fract); +mutex_unlock (&msc->part_sel_lock); +} + +static void mpam_reset_ris (struct mpam_msc_ris *ris) +{ +u16 partid, partid_max; + +mpam_assert_srcu_read_lock_held (); + +if (ris->in_reset_state) +return ; + +spin_lock (&partid_max_lock); + partid_max = mpam_partid_max; +spin_unlock (&partid_max_lock); +for (partid =0 ; partid < partid_max; partid++) +mpam_reset_ris_partid (ris, partid); +} + +static void mpam_reset_msc (struct mpam_msc *msc,bool online) +{ +int idx; +struct mpam_msc_ris *ris; + +mpam_assert_srcu_read_lock_held (); + +mpam_mon_sel_outer_lock (msc); + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (ris, &msc->ris, msc_list,srcu_read_lock_held (&mpam_srcu)) { +mpam_reset_ris (ris); + +/* +* Set in_reset_state when coming online. The reset state +* for non-zero partid may be lost while the CPUs are offline. +*/ + ris->in_reset_state = online; + } +srcu_read_unlock (&mpam_srcu, idx); +mpam_mon_sel_outer_unlock (msc); +} +static int mpam_cpu_online (unsigned int cpu) { +int idx; +struct mpam_msc *msc; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (msc, &mpam_all_msc, glbl_list,srcu_read_lock_held (&mpam_srcu)) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +if (atomic_fetch_inc (&msc->online_refs) ==0 ) +mpam_reset_msc (msc, true); + } +srcu_read_unlock (&mpam_srcu, idx); +return 0 ; }
@@ -886,6 +994,19 @@ static int mpam_discovery_cpu_online(unsigned int cpu)static int mpam_cpu_offline (unsigned int cpu) { +int idx; +struct mpam_msc *msc; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (msc, &mpam_all_msc, glbl_list,srcu_read_lock_held (&mpam_srcu)) { +if (!cpumask_test_cpu (cpu, &msc->accessibility)) +continue ; + +if (atomic_dec_and_test (&msc->online_refs)) +mpam_reset_msc (msc, false); + } +srcu_read_unlock (&mpam_srcu, idx); +return 0 ; }
drivers/resctrl/mpam_internal.h +8 -0
@@ -5,6 +5,7 @@#define MPAM_INTERNAL_H #include <linux/arm_mpam.h> +#include <linux/atomic.h> #include <linux/cpumask.h> #include <linux/io.h> #include <linux/llist.h>
@@ -43,6 +44,7 @@ struct mpam_msc {struct pcc_mbox_chan *pcc_chan;u32 nrdy_usec;cpumask_t accessibility; +atomic_t online_refs;/* * probe_lock is only take during discovery. After discovery these
@@ -248,6 +250,7 @@ struct mpam_msc_ris {u8 ris_idx;u64 idr;struct mpam_props props; +bool in_reset_state;cpumask_t affinity;
@@ -267,6 +270,11 @@ struct mpam_msc_ris {extern struct srcu_struct mpam_srcu;extern struct list_head mpam_classes; +static inline void mpam_assert_srcu_read_lock_held (void ) +{ +WARN_ON_ONCE (!srcu_read_lock_held ((&mpam_srcu))); +} +/* System wide partid/pmg values */ extern u16 mpam_partid_max;extern u8 mpam_pmg_max;
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 20/33 arm_mpam: Add a helper to touch an MSC from any CPU
In reply to James MorseResetting RIS entries from the cpuhp callback is easy as the callback occurs on the correct CPU. This won't be true for any other caller that wants to reset or configure an MSC.
Add a helper that schedules the provided function if necessary. Prevent the cpuhp callbacks from changing the MSC state by taking the cpuhp lock.
--- drivers/resctrl/mpam_devices.c | 37 +++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
drivers/resctrl/mpam_devices.c +34 -3
@@ -906,20 +906,51 @@ static void mpam_reset_ris_partid(struct mpam_msc_ris *ris, u16 partid)mutex_unlock (&msc->part_sel_lock); } -static void mpam_reset_ris (struct mpam_msc_ris *ris) +/* +* Called via smp_call_on_cpu() to prevent migration, while still being +* pre-emptible. +*/ +static int mpam_reset_ris (void *arg) {u16 partid, partid_max; +struct mpam_msc_ris *ris = arg;mpam_assert_srcu_read_lock_held ();if (ris->in_reset_state) -return ; +return 0 ;spin_lock (&partid_max_lock); partid_max = mpam_partid_max;spin_unlock (&partid_max_lock);for (partid =0 ; partid < partid_max; partid++)mpam_reset_ris_partid (ris, partid); + +return 0 ; +} + +/* +* Get the preferred CPU for this MSC. If it is accessible from this CPU, +* this CPU is preferred. This can be preempted/migrated, it will only result +* in more work. +*/ +static int mpam_get_msc_preferred_cpu (struct mpam_msc *msc) +{ +int cpu =raw_smp_processor_id (); + +if (cpumask_test_cpu (cpu, &msc->accessibility)) +return cpu; + +return cpumask_first_and (&msc->accessibility, cpu_online_mask); +} + +static int mpam_touch_msc (struct mpam_msc *msc,int (*fn)(void *a),void *arg) +{ +lockdep_assert_irqs_enabled (); +lockdep_assert_cpus_held (); +mpam_assert_srcu_read_lock_held (); + +return smp_call_on_cpu (mpam_get_msc_preferred_cpu (msc), fn, arg, true); }static void mpam_reset_msc (struct mpam_msc *msc,bool online)
@@ -932,7 +963,7 @@ static void mpam_reset_msc(struct mpam_msc *msc, bool online)mpam_mon_sel_outer_lock (msc); idx =srcu_read_lock (&mpam_srcu);list_for_each_entry_srcu (ris, &msc->ris, msc_list,srcu_read_lock_held (&mpam_srcu)) { -mpam_reset_ris (ris); +mpam_touch_msc (msc, &mpam_reset_ris, ris);/* * Set in_reset_state when coming online. The reset state
Signature · 1 line
2.20.1
Re: [PATCH 20/33] arm_mpam: Add a helper to touch an MSC from any CPU
Hi James,
Quoted 7 lines · James Morse
Resetting RIS entries from the cpuhp callback is easy as the callback occurs on the correct CPU. This won't be true for any other caller that wants to reset or configure an MSC.
Add a helper that schedules the provided function if necessary. Prevent the cpuhp callbacks from changing the MSC state by taking the cpuhp lock.
At first, I thought this was referring to something done in the patch. Consider changing to something like:
Callers should take the cpuhp lock to prevent the cpuhp callbacks from changing the MSC state.
Regardless, this looks good to me.
Quoted 65 lines
Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 37 +++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)drivers/resctrl/mpam_devices.c +33
-2@@ -906,20 +906,51 @@ static void mpam_reset_ris_partid(struct mpam_msc_ris *ris, u16 partid)mutex_unlock (&msc->part_sel_lock); } -static void mpam_reset_ris (struct mpam_msc_ris *ris) +/* +* Called via smp_call_on_cpu() to prevent migration, while still being +* pre-emptible. +*/ +static int mpam_reset_ris (void *arg) {u16 partid, partid_max; +struct mpam_msc_ris *ris = arg;mpam_assert_srcu_read_lock_held ();if (ris->in_reset_state) -return ; +return 0 ;spin_lock (&partid_max_lock); partid_max = mpam_partid_max;spin_unlock (&partid_max_lock);for (partid =0 ; partid < partid_max; partid++)mpam_reset_ris_partid (ris, partid); + +return 0 ; +} + +/* +* Get the preferred CPU for this MSC. If it is accessible from this CPU, +* this CPU is preferred. This can be preempted/migrated, it will only result +* in more work. +*/ +static int mpam_get_msc_preferred_cpu (struct mpam_msc *msc) +{ +int cpu =raw_smp_processor_id (); + +if (cpumask_test_cpu (cpu, &msc->accessibility)) +return cpu; + +return cpumask_first_and (&msc->accessibility, cpu_online_mask); +} + +static int mpam_touch_msc (struct mpam_msc *msc,int (*fn)(void *a),void *arg) +{ +lockdep_assert_irqs_enabled (); +lockdep_assert_cpus_held (); +mpam_assert_srcu_read_lock_held (); + +return smp_call_on_cpu (mpam_get_msc_preferred_cpu (msc), fn, arg, true); }static void mpam_reset_msc (struct mpam_msc *msc,bool online)
drivers/resctrl/mpam_devices.c static void mpam_reset_msc(struct mpam_msc *msc, bool online) · line 969
Quoted 8 lines
drivers/resctrl/mpam_devices.c +1
-1@@ -932,7 +963,7 @@ static void mpam_reset_msc(struct mpam_msc *msc, bool online)mpam_mon_sel_outer_lock (msc); idx =srcu_read_lock (&mpam_srcu);list_for_each_entry_srcu (ris, &msc->ris, msc_list,srcu_read_lock_held (&mpam_srcu)) { -mpam_reset_ris (ris); +mpam_touch_msc (msc, &mpam_reset_ris, ris);/* * Set in_reset_state when coming online. The reset state
Thanks,
Ben
James Morse
maintainerRe: [PATCH 20/33] arm_mpam: Add a helper to touch an MSC from any CPU
Hi Ben,
Quoted 9 lines · Ben Horgan
Quoted 7 lines · James Morse
Resetting RIS entries from the cpuhp callback is easy as the callback occurs on the correct CPU. This won't be true for any other caller that wants to reset or configure an MSC.
Add a helper that schedules the provided function if necessary. Prevent the cpuhp callbacks from changing the MSC state by taking the cpuhp lock.
Quoted 5 lines
At first, I thought this was referring to something done in the patch. Consider changing to something like:
Callers should take the cpuhp lock to prevent the cpuhp callbacks from changing the MSC state.
Yes - that is better,
Quoted 3 lines
Regardless, this looks good to me.
Reviewed-by Ben Horgan <[email protected]>
Thanks!
James
James Morse
maintainerPATCH 20/33 arm_mpam: Add a helper to touch an MSC from any CPU
In reply to James MorseResetting RIS entries from the cpuhp callback is easy as the callback occurs on the correct CPU. This won't be true for any other caller that wants to reset or configure an MSC.
Add a helper that schedules the provided function if necessary. Prevent the cpuhp callbacks from changing the MSC state by taking the cpuhp lock.
--- drivers/resctrl/mpam_devices.c | 37 +++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
drivers/resctrl/mpam_devices.c +34 -3
@@ -906,20 +906,51 @@ static void mpam_reset_ris_partid(struct mpam_msc_ris *ris, u16 partid)mutex_unlock (&msc->part_sel_lock); } -static void mpam_reset_ris (struct mpam_msc_ris *ris) +/* +* Called via smp_call_on_cpu() to prevent migration, while still being +* pre-emptible. +*/ +static int mpam_reset_ris (void *arg) {u16 partid, partid_max; +struct mpam_msc_ris *ris = arg;mpam_assert_srcu_read_lock_held ();if (ris->in_reset_state) -return ; +return 0 ;spin_lock (&partid_max_lock); partid_max = mpam_partid_max;spin_unlock (&partid_max_lock);for (partid =0 ; partid < partid_max; partid++)mpam_reset_ris_partid (ris, partid); + +return 0 ; +} + +/* +* Get the preferred CPU for this MSC. If it is accessible from this CPU, +* this CPU is preferred. This can be preempted/migrated, it will only result +* in more work. +*/ +static int mpam_get_msc_preferred_cpu (struct mpam_msc *msc) +{ +int cpu =raw_smp_processor_id (); + +if (cpumask_test_cpu (cpu, &msc->accessibility)) +return cpu; + +return cpumask_first_and (&msc->accessibility, cpu_online_mask); +} + +static int mpam_touch_msc (struct mpam_msc *msc,int (*fn)(void *a),void *arg) +{ +lockdep_assert_irqs_enabled (); +lockdep_assert_cpus_held (); +mpam_assert_srcu_read_lock_held (); + +return smp_call_on_cpu (mpam_get_msc_preferred_cpu (msc), fn, arg, true); }static void mpam_reset_msc (struct mpam_msc *msc,bool online)
@@ -932,7 +963,7 @@ static void mpam_reset_msc(struct mpam_msc *msc, bool online)mpam_mon_sel_outer_lock (msc); idx =srcu_read_lock (&mpam_srcu);list_for_each_entry_srcu (ris, &msc->ris, msc_list,srcu_read_lock_held (&mpam_srcu)) { -mpam_reset_ris (ris); +mpam_touch_msc (msc, &mpam_reset_ris, ris);/* * Set in_reset_state when coming online. The reset state
Signature · 1 line
2.20.1
James Morse
maintainerPATCH 21/33 arm_mpam: Extend reset logic to allow devices to be reset any time
In reply to James Morsecpuhp callbacks aren't the only time the MSC configuration may need to be reset. Resctrl has an API call to reset a class.
If an MPAM error interrupt arrives it indicates the driver has misprogrammed an MSC. The safest thing to do is reset all the MSCs and disable MPAM.
Add a helper to reset RIS via their class. Call this from mpam_disable(), which can be scheduled from the error interrupt handler.
--- drivers/resctrl/mpam_devices.c | 62 +++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 1 + 2 files changed, 61 insertions(+), 2 deletions(-)
drivers/resctrl/mpam_devices.c +60 -2
@@ -915,8 +915,6 @@ static int mpam_reset_ris(void *arg)u16 partid, partid_max;struct mpam_msc_ris *ris = arg; -mpam_assert_srcu_read_lock_held (); -if (ris->in_reset_state)return 0 ;
@@ -1569,6 +1567,66 @@ static void mpam_enable_once(void) mpam_partid_max + 1, mpam_pmg_max + 1); } +static void mpam_reset_component_locked (struct mpam_component *comp) +{ +int idx; +struct mpam_msc *msc; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; + +might_sleep (); +lockdep_assert_cpus_held (); + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_rcu (vmsc, &comp->vmsc, comp_list) { + msc = vmsc->msc; + +list_for_each_entry_rcu (ris, &vmsc->ris, vmsc_list) { +if (!ris->in_reset_state) +mpam_touch_msc (msc, mpam_reset_ris, ris); + ris->in_reset_state = true; + } + } +srcu_read_unlock (&mpam_srcu, idx); +} + +static void mpam_reset_class_locked (struct mpam_class *class) +{ +int idx; +struct mpam_component *comp; + +lockdep_assert_cpus_held (); + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_rcu (comp, &class->components, class_list) +mpam_reset_component_locked (comp); +srcu_read_unlock (&mpam_srcu, idx); +} + +static void mpam_reset_class (struct mpam_class *class) +{ +cpus_read_lock (); +mpam_reset_class_locked (class); +cpus_read_unlock (); +} + +/* +* Called in response to an error IRQ. +* All of MPAMs errors indicate a software bug, restore any modified +* controls to their reset values. +*/ +void mpam_disable (void ) +{ +int idx; +struct mpam_class *class; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (class, &mpam_classes, classes_list, +srcu_read_lock_held (&mpam_srcu)) +mpam_reset_class (class); +srcu_read_unlock (&mpam_srcu, idx); +} +/* * Enable mpam once all devices have been probed. * Scheduled by mpam_discovery_cpu_online() once all devices have been created.
drivers/resctrl/mpam_internal.h +1 -0
@@ -281,6 +281,7 @@ extern u8 mpam_pmg_max;/* Scheduled work callback to enable mpam once all MSC have been probed */ void mpam_enable (struct work_struct *work); +void mpam_disable (void );int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity);
Signature · 1 line
2.20.1
Ben Horgan
maintainerRe: [PATCH 21/33] arm_mpam: Extend reset logic to allow devices to be reset any time
Hi James,
Quoted 78 lines · James Morse
cpuhp callbacks aren't the only time the MSC configuration may need to be reset. Resctrl has an API call to reset a class.
If an MPAM error interrupt arrives it indicates the driver has misprogrammed an MSC. The safest thing to do is reset all the MSCs and disable MPAM.Add a helper to reset RIS via their class. Call this from
mpam_disable(), which can be scheduled from the error interrupt handler.Signed-off-by James Morse <[email protected]>--- drivers/resctrl/mpam_devices.c | 62 +++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 1 + 2 files changed, 61 insertions(+), 2 deletions(-)drivers/resctrl/mpam_devices.c +46
-2@@ -915,8 +915,6 @@ static int mpam_reset_ris(void *arg)u16 partid, partid_max;struct mpam_msc_ris *ris = arg; -mpam_assert_srcu_read_lock_held (); -if (ris->in_reset_state)return 0 ;@@ -1569,6 +1567,66 @@ static void mpam_enable_once(void) mpam_partid_max + 1, mpam_pmg_max + 1); } +static void mpam_reset_component_locked (struct mpam_component *comp) +{ +int idx; +struct mpam_msc *msc; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; + +might_sleep (); +lockdep_assert_cpus_held (); + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_rcu (vmsc, &comp->vmsc, comp_list) { + msc = vmsc->msc; + +list_for_each_entry_rcu (ris, &vmsc->ris, vmsc_list) { +if (!ris->in_reset_state) +mpam_touch_msc (msc, mpam_reset_ris, ris); + ris->in_reset_state = true; + } + } +srcu_read_unlock (&mpam_srcu, idx); +} + +static void mpam_reset_class_locked (struct mpam_class *class) +{ +int idx; +struct mpam_component *comp; + +lockdep_assert_cpus_held (); + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_rcu (comp, &class->components, class_list) +mpam_reset_component_locked (comp); +srcu_read_unlock (&mpam_srcu, idx); +} + +static void mpam_reset_class (struct mpam_class *class) +{ +cpus_read_lock (); +mpam_reset_class_locked (class); +cpus_read_unlock (); +} + +/* +* Called in response to an error IRQ. +* All of MPAMs errors indicate a software bug, restore any modified
drivers/resctrl/mpam_devices.c static void mpam_enable_once(void) · line 1625
Quoted 10 lines
drivers/resctrl/mpam_devices.c +10
-0+* controls to their reset values. +*/ +void mpam_disable (void ) +{ +int idx; +struct mpam_class *class; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (class, &mpam_classes, classes_list, +srcu_read_lock_held (&mpam_srcu))
Why do you use list_for_each_entry_srcu() here when in other places you use list_for_each_entry_rcu()?
Quoted 12 lines
drivers/resctrl/mpam_devices.c +4
-0+mpam_reset_class (class); +srcu_read_unlock (&mpam_srcu, idx); +} +/* * Enable mpam once all devices have been probed. * Scheduled by mpam_discovery_cpu_online() once all devices have been created. drivers/resctrl/mpam_internal.h +0
-0
drivers/resctrl/mpam_internal.h extern u8 mpam_pmg_max; · line 287
Quoted 7 lines
drivers/resctrl/mpam_internal.h +1
-0@@ -281,6 +281,7 @@ extern u8 mpam_pmg_max;/* Scheduled work callback to enable mpam once all MSC have been probed */ void mpam_enable (struct work_struct *work); +void mpam_disable (void );int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity);
Thanks,
Ben
James Morse
maintainerRe: [PATCH 21/33] arm_mpam: Extend reset logic to allow devices to be reset any time
Hi Ben,
Quoted 16 lines · Ben Horgan
Quoted 14 lines · James Morse
cpuhp callbacks aren't the only time the MSC configuration may need to be reset. Resctrl has an API call to reset a class.
If an MPAM error interrupt arrives it indicates the driver has misprogrammed an MSC. The safest thing to do is reset all the MSCs and disable MPAM.Add a helper to reset RIS via their class. Call this from
mpam_disable(), which can be scheduled from the error interrupt handler.drivers/resctrl/mpam_devices.c +0
-0@@ -1569,6 +1567,66 @@ static void mpam_enable_once(void)
Quoted 16 lines
drivers/resctrl/mpam_devices.c static void mpam_enable_once(void) · line 1625
Quoted 13 lines
drivers/resctrl/mpam_devices.c +13
-0+/* +* Called in response to an error IRQ. +* All of MPAMs errors indicate a software bug, restore any modified +* controls to their reset values. +*/ +void mpam_disable (void ) +{ +int idx; +struct mpam_class *class; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (class, &mpam_classes, classes_list, +srcu_read_lock_held (&mpam_srcu))Why do you use
list_for_each_entry_srcu()here when in other places you uselist_for_each_entry_rcu()?
It's a mistake. I was part way making this use RCU when someone 'invented' the firmware interface meaning readl() needs to be able to sleep... Those were added in a later patch than I thought, and I missed fixing them up.
I think the srcu version provides extra checking - and is the correct one to use. I'll fix those -- thanks for spotting it!
Thanks,
James
Quoted 3 lines
Quoted 3 lines
drivers/resctrl/mpam_devices.c +3
-0+mpam_reset_class (class); +srcu_read_unlock (&mpam_srcu, idx); +}
James Morse
maintainerPATCH 21/33 arm_mpam: Extend reset logic to allow devices to be reset any time
In reply to James Morsecpuhp callbacks aren't the only time the MSC configuration may need to be reset. Resctrl has an API call to reset a class.
If an MPAM error interrupt arrives it indicates the driver has misprogrammed an MSC. The safest thing to do is reset all the MSCs and disable MPAM.
Add a helper to reset RIS via their class. Call this from mpam_disable(), which can be scheduled from the error interrupt handler.
--- drivers/resctrl/mpam_devices.c | 62 +++++++++++++++++++++++++++++++-- drivers/resctrl/mpam_internal.h | 1 + 2 files changed, 61 insertions(+), 2 deletions(-)
drivers/resctrl/mpam_devices.c +60 -2
@@ -915,8 +915,6 @@ static int mpam_reset_ris(void *arg)u16 partid, partid_max;struct mpam_msc_ris *ris = arg; -mpam_assert_srcu_read_lock_held (); -if (ris->in_reset_state)return 0 ;
@@ -1569,6 +1567,66 @@ static void mpam_enable_once(void) mpam_partid_max + 1, mpam_pmg_max + 1); } +static void mpam_reset_component_locked (struct mpam_component *comp) +{ +int idx; +struct mpam_msc *msc; +struct mpam_vmsc *vmsc; +struct mpam_msc_ris *ris; + +might_sleep (); +lockdep_assert_cpus_held (); + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_rcu (vmsc, &comp->vmsc, comp_list) { + msc = vmsc->msc; + +list_for_each_entry_rcu (ris, &vmsc->ris, vmsc_list) { +if (!ris->in_reset_state) +mpam_touch_msc (msc, mpam_reset_ris, ris); + ris->in_reset_state = true; + } + } +srcu_read_unlock (&mpam_srcu, idx); +} + +static void mpam_reset_class_locked (struct mpam_class *class) +{ +int idx; +struct mpam_component *comp; + +lockdep_assert_cpus_held (); + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_rcu (comp, &class->components, class_list) +mpam_reset_component_locked (comp); +srcu_read_unlock (&mpam_srcu, idx); +} + +static void mpam_reset_class (struct mpam_class *class) +{ +cpus_read_lock (); +mpam_reset_class_locked (class); +cpus_read_unlock (); +} + +/* +* Called in response to an error IRQ. +* All of MPAMs errors indicate a software bug, restore any modified +* controls to their reset values. +*/ +void mpam_disable (void ) +{ +int idx; +struct mpam_class *class; + + idx =srcu_read_lock (&mpam_srcu); +list_for_each_entry_srcu (class, &mpam_classes, classes_list, +srcu_read_lock_held (&mpam_srcu)) +mpam_reset_class (class); +srcu_read_unlock (&mpam_srcu, idx); +} +/* * Enable mpam once all devices have been probed. * Scheduled by mpam_discovery_cpu_online() once all devices have been created.
drivers/resctrl/mpam_internal.h +1 -0
@@ -281,6 +281,7 @@ extern u8 mpam_pmg_max;/* Scheduled work callback to enable mpam once all MSC have been probed */ void mpam_enable (struct work_struct *work); +void mpam_disable (void );int mpam_get_cpumask_from_cache_id (unsigned long cache_id,u32 cache_level,cpumask_t *affinity);
Signature · 1 line
2.20.1