linux-stable.git/arch/x86/kernel/cpu/resctrl/monitor.c, branch v6.2

x86/resctrl: Fix event counts regression in reused RMIDs

2023-01-10T18:51:59+00:00

When creating a new monitoring group, the RMID allocated for it may have
been used by a group which was previously removed. In this case, the
hardware counters will have non-zero values which should be deducted
from what is reported in the new group's counts.

resctrl_arch_reset_rmid() initializes the prev_msr value for counters to
0, causing the initial count to be charged to the new group. Resurrect
__rmid_read() and use it to initialize prev_msr correctly.

Unlike before, __rmid_read() checks for error bits in the MSR read so
that callers don't need to.

Fixes: 1d81d15db39c ("x86/resctrl: Move mbm_overflow_count() into resctrl_arch_rmid_read()")
Signed-off-by: Peter Newman 
Signed-off-by: Borislav Petkov (AMD) 
Reviewed-by: Reinette Chatre 
Tested-by: Babu Moger 
Cc: stable@vger.kernel.org
Link: https://lore.kernel.org/r/20221220164132.443083-1-peternewman@google.com

x86/resctrl: Make resctrl_arch_rmid_read() return values in bytes

2022-09-23T12:25:05+00:00

resctrl_arch_rmid_read() returns a value in chunks, as read from the
hardware. This needs scaling to bytes by mon_scale, as provided by
the architecture code.

Now that resctrl_arch_rmid_read() performs the overflow and corrections
itself, it may as well return a value in bytes directly. This allows
the accesses to the architecture specific 'hw' structure to be removed.

Move the mon_scale conversion into resctrl_arch_rmid_read().
mbm_bw_count() is updated to calculate bandwidth from bytes.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-22-james.morse@arm.com

x86/resctrl: Add resctrl_rmid_realloc_limit to abstract x86's boot_cpu_data

2022-09-23T12:24:16+00:00

resctrl_rmid_realloc_threshold can be set by user-space. The maximum
value is specified by the architecture.

Currently max_threshold_occ_write() reads the maximum value from
boot_cpu_data.x86_cache_size, which is not portable to another
architecture.

Add resctrl_rmid_realloc_limit to describe the maximum size in bytes
that user-space can set the threshold to.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-21-james.morse@arm.com

x86/resctrl: Rename and change the units of resctrl_cqm_threshold

2022-09-23T12:23:41+00:00

resctrl_cqm_threshold is stored in a hardware specific chunk size,
but exposed to user-space as bytes.

This means the filesystem parts of resctrl need to know how the hardware
counts, to convert the user provided byte value to chunks. The interface
between the architecture's resctrl code and the filesystem ought to
treat everything as bytes.

Change the unit of resctrl_cqm_threshold to bytes. resctrl_arch_rmid_read()
still returns its value in chunks, so this needs converting to bytes.
As all the users have been touched, rename the variable to
resctrl_rmid_realloc_threshold, which describes what the value is for.

Neither r->num_rmid nor hw_res->mon_scale are guaranteed to be a power
of 2, so the existing code introduces a rounding error from resctrl's
theoretical fraction of the cache usage. This behaviour is kept as it
ensures the user visible value matches the value read from hardware
when the rmid will be reallocated.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-20-james.morse@arm.com

x86/resctrl: Move get_corrected_mbm_count() into resctrl_arch_rmid_read()

2022-09-23T12:22:53+00:00

resctrl_arch_rmid_read() is intended as the function that an
architecture agnostic resctrl filesystem driver can use to
read a value in bytes from a counter. Currently the function returns
the MBM values in chunks directly from hardware. When reading a bandwidth
counter, get_corrected_mbm_count() must be used to correct the
value read.

get_corrected_mbm_count() is architecture specific, this work should be
done in resctrl_arch_rmid_read().

Move the function calls. This allows the resctrl filesystems's chunks
value to be removed in favour of the architecture private version.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-19-james.morse@arm.com

x86/resctrl: Move mbm_overflow_count() into resctrl_arch_rmid_read()

2022-09-23T12:22:20+00:00

resctrl_arch_rmid_read() is intended as the function that an
architecture agnostic resctrl filesystem driver can use to
read a value in bytes from a counter. Currently the function returns
the MBM values in chunks directly from hardware. When reading a bandwidth
counter, mbm_overflow_count() must be used to correct for any possible
overflow.

mbm_overflow_count() is architecture specific, its behaviour should
be part of resctrl_arch_rmid_read().

Move the mbm_overflow_count() calls into resctrl_arch_rmid_read().
This allows the resctrl filesystems's prev_msr to be removed in
favour of the architecture private version.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-18-james.morse@arm.com

x86/resctrl: Pass the required parameters into resctrl_arch_rmid_read()

2022-09-23T12:21:25+00:00

resctrl_arch_rmid_read() is intended as the function that an
architecture agnostic resctrl filesystem driver can use to
read a value in bytes from a hardware register. Currently the function
returns the MBM values in chunks directly from hardware.

To convert this to bytes, some correction and overflow calculations
are needed. These depend on the resource and domain structures.
Overflow detection requires the old chunks value. None of this
is available to resctrl_arch_rmid_read(). MPAM requires the
resource and domain structures to find the MMIO device that holds
the registers.

Pass the resource and domain to resctrl_arch_rmid_read(). This makes
rmid_dirty() too big. Instead merge it with its only caller, and the
name is kept as a local variable.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-17-james.morse@arm.com

x86/resctrl: Abstract __rmid_read()

2022-09-23T12:17:20+00:00

__rmid_read() selects the specified eventid and returns the counter
value from the MSR. The error handling is architecture specific, and
handled by the callers, rdtgroup_mondata_show() and __mon_event_count().

Error handling should be handled by architecture specific code, as
a different architecture may have different requirements. MPAM's
counters can report that they are 'not ready', requiring a second
read after a short delay. This should be hidden from resctrl.

Make __rmid_read() the architecture specific function for reading
a counter. Rename it resctrl_arch_rmid_read() and move the error
handling into it.

A read from a counter that hardware supports but resctrl does not
now returns -EINVAL instead of -EIO from the default case in
__mon_event_count(). It isn't possible for user-space to see this
change as resctrl doesn't expose counters it doesn't support.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-16-james.morse@arm.com

x86/resctrl: Allow per-rmid arch private storage to be reset

2022-09-23T10:49:04+00:00

To abstract the rmid counters into a helper that returns the number
of bytes counted, architecture specific per-rmid state is needed.

It needs to be possible to reset this hidden state, as the values
may outlive the life of an rmid, or the mount time of the filesystem.

mon_event_read() is called with first = true when an rmid is first
allocated in mkdir_mondata_subdir(). Add resctrl_arch_reset_rmid()
and call it from __mon_event_count()'s rr->first check.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-15-james.morse@arm.com

x86/resctrl: Calculate bandwidth from the previous __mon_event_count() chunks

2022-09-22T15:44:57+00:00

mbm_bw_count() is only called by the mbm_handle_overflow() worker once a
second. It reads the hardware register, calculates the bandwidth and
updates m->prev_bw_msr which is used to hold the previous hardware register
value.

Operating directly on hardware register values makes it difficult to make
this code architecture independent, so that it can be moved to /fs/,
making the mba_sc feature something resctrl supports with no additional
support from the architecture.
Prior to calling mbm_bw_count(), mbm_update() reads from the same hardware
register using __mon_event_count().

Change mbm_bw_count() to use the current chunks value most recently saved
by __mon_event_count(). This removes an extra call to __rmid_read().
Instead of using m->prev_msr to calculate the number of chunks seen,
use the rr->val that was updated by __mon_event_count(). This removes an
extra call to mbm_overflow_count() and get_corrected_mbm_count().
Calculating bandwidth like this means mbm_bw_count() no longer operates
on hardware register values directly.

Signed-off-by: James Morse 
Signed-off-by: Borislav Petkov 
Reviewed-by: Jamie Iles 
Reviewed-by: Shaopeng Tan 
Reviewed-by: Reinette Chatre 
Tested-by: Xin Hao 
Tested-by: Shaopeng Tan 
Tested-by: Cristian Marussi 
Link: https://lore.kernel.org/r/20220902154829.30399-13-james.morse@arm.com