<feed xmlns='http://www.w3.org/2005/Atom'>
<title>kernel.git/arch/arm64/kernel/entry-fpsimd.S, branch linux-5.16.y</title>
<subtitle>Hosts the 0x221E linux distro kernel.
</subtitle>
<id>https://git.0xinfinity.dev/distro/kernel.git/atom?h=linux-5.16.y</id>
<link rel='self' href='https://git.0xinfinity.dev/distro/kernel.git/atom?h=linux-5.16.y'/>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/'/>
<updated>2021-10-21T09:18:17Z</updated>
<entry>
<title>arm64/sve: Explicitly load vector length when restoring SVE state</title>
<updated>2021-10-21T09:18:17Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-10-19T17:22:13Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=ddc806b5c4752d35bdaa4dfa2aaa72785711a3da'/>
<id>urn:sha1:ddc806b5c4752d35bdaa4dfa2aaa72785711a3da</id>
<content type='text'>
Currently when restoring the SVE state we supply the SVE vector length
as an argument to sve_load_state() and the underlying macros. This becomes
inconvenient with the addition of SME since we may need to restore any
combination of SVE and SME vector lengths, and we already separately
restore the vector length in the KVM code. We don't need to know the vector
length during the actual register load since the SME load instructions can
index into the data array for us.

Refactor the interface so we explicitly set the vector length separately
to restoring the SVE registers in preparation for adding SME support, no
functional change should be involved.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Link: https://lore.kernel.org/r/20211019172247.3045838-9-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Make access to FFR optional</title>
<updated>2021-10-21T09:18:17Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-10-19T17:22:09Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=9f5848665788a0f07bc175cb2cdd06d367b7556e'/>
<id>urn:sha1:9f5848665788a0f07bc175cb2cdd06d367b7556e</id>
<content type='text'>
SME introduces streaming SVE mode in which FFR is not present and the
instructions for accessing it UNDEF. In preparation for handling this
update the low level SVE state access functions to take a flag specifying
if FFR should be handled. When saving the register state we store a zero
for FFR to guard against uninitialized data being read. No behaviour change
should be introduced by this patch.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Link: https://lore.kernel.org/r/20211019172247.3045838-5-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Remove sve_load_from_fpsimd_state()</title>
<updated>2021-10-21T09:18:17Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-10-19T17:22:07Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=b53223e0a4d9fbdba1a1dd1161f7240506666946'/>
<id>urn:sha1:b53223e0a4d9fbdba1a1dd1161f7240506666946</id>
<content type='text'>
Following optimisations of the SVE register handling we no longer load the
SVE state from a saved copy of the FPSIMD registers, we convert directly
in registers or from one saved state to another. Remove the function so we
don't need to update it during further refactoring.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Link: https://lore.kernel.org/r/20211019172247.3045838-3-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Add some comments for sve_save/load_state()</title>
<updated>2021-08-24T15:44:23Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-08-12T20:11:43Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=38ee3c5e36a134050df93ab911d4713e30a6cde5'/>
<id>urn:sha1:38ee3c5e36a134050df93ab911d4713e30a6cde5</id>
<content type='text'>
The use of macros for the actual function bodies means legibility is always
going to be a bit of a challenge, especially while we can't rely on SVE
support in the toolchain, but this helps a little.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Link: https://lore.kernel.org/r/20210812201143.35578-1-broonie@kernel.org
Signed-off-by: Catalin Marinas &lt;catalin.marinas@arm.com&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Skip flushing Z registers with 128 bit vectors</title>
<updated>2021-05-26T19:04:28Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-05-12T15:11:31Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=ad4711f962e08eff8d6e9b03f9670b1af6ea9395'/>
<id>urn:sha1:ad4711f962e08eff8d6e9b03f9670b1af6ea9395</id>
<content type='text'>
When the SVE vector length is 128 bits then there are no bits in the Z
registers which are not shared with the V registers so we can skip them
when zeroing state not shared with FPSIMD, this results in a minor
performance improvement.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Reviewed-by: Dave Martin &lt;Dave.Martin@arm.com&gt;
Acked-by: Catalin Marinas &lt;catalin.marinas@arm.com&gt;
Link: https://lore.kernel.org/r/20210512151131.27877-4-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Use the sve_flush macros in sve_load_from_fpsimd_state()</title>
<updated>2021-05-26T19:04:28Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-05-12T15:11:30Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=c9f6890bca111a879a8af1f2390ac49cf05b11df'/>
<id>urn:sha1:c9f6890bca111a879a8af1f2390ac49cf05b11df</id>
<content type='text'>
This makes the code a bit clearer and as a result we can also make the
indentation more normal, there is no change to the generated code.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Reviewed-by: Dave Martin &lt;Dave.Martin@arm.com&gt;
Acked-by: Catalin Marinas &lt;catalin.marinas@arm.com&gt;
Link: https://lore.kernel.org/r/20210512151131.27877-3-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Split _sve_flush macro into separate Z and predicate flushes</title>
<updated>2021-05-26T19:04:28Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-05-12T15:11:29Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=483dbf6a35907610597fdc304bd32ecba40cdff0'/>
<id>urn:sha1:483dbf6a35907610597fdc304bd32ecba40cdff0</id>
<content type='text'>
Trivial refactoring to support further work, no change to generated code.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Reviewed-by: Dave Martin &lt;Dave.Martin@arm.com&gt;
Acked-by: Catalin Marinas &lt;catalin.marinas@arm.com&gt;
Link: https://lore.kernel.org/r/20210512151131.27877-2-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Rework SVE access trap to convert state in registers</title>
<updated>2021-04-08T16:43:43Z</updated>
<author>
<name>Mark Brown</name>
</author>
<published>2021-03-12T19:03:13Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=cccb78ce89c45a4414db712be4986edfb92434bd'/>
<id>urn:sha1:cccb78ce89c45a4414db712be4986edfb92434bd</id>
<content type='text'>
When we enable SVE usage in userspace after taking a SVE access trap we
need to ensure that the portions of the register state that are not
shared with the FPSIMD registers are zeroed. Currently we do this by
forcing the FPSIMD registers to be saved to the task struct and converting
them there. This is wasteful in the common case where the task state is
loaded into the registers and we will immediately return to userspace
since we can initialise the SVE state directly in registers instead of
accessing multiple copies of the register state in memory.

Instead in that common case do the conversion in the registers and
update the task metadata so that we can return to userspace without
spilling the register state to memory unless there is some other reason
to do so.

Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Link: https://lore.kernel.org/r/20210312190313.24598-1-broonie@kernel.org
Signed-off-by: Catalin Marinas &lt;catalin.marinas@arm.com&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Implement a helper to load SVE registers from FPSIMD state</title>
<updated>2020-09-21T17:06:33Z</updated>
<author>
<name>Julien Grall</name>
</author>
<published>2020-08-28T18:11:53Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=9c4b4c701e53183df94f6b9802b63762f0c0e1e3'/>
<id>urn:sha1:9c4b4c701e53183df94f6b9802b63762f0c0e1e3</id>
<content type='text'>
In a follow-up patch, we may save the FPSIMD rather than the full SVE
state when the state has to be zeroed on return to userspace (e.g
during a syscall).

Introduce an helper to load SVE vectors from FPSIMD state and zero the rest
of SVE registers.

Signed-off-by: Julien Grall &lt;julien.grall@arm.com&gt;
Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Reviewed-by: Dave Martin &lt;Dave.Martin@arm.com&gt;
Link: https://lore.kernel.org/r/20200828181155.17745-7-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
<entry>
<title>arm64/sve: Implement a helper to flush SVE registers</title>
<updated>2020-09-21T17:06:33Z</updated>
<author>
<name>Julien Grall</name>
</author>
<published>2020-08-28T18:11:52Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=1e530f1352a2709d7bcacdb8b6d42c8900ba2c80'/>
<id>urn:sha1:1e530f1352a2709d7bcacdb8b6d42c8900ba2c80</id>
<content type='text'>
Introduce a new helper that will zero all SVE registers but the first
128-bits of each vector. This will be used by subsequent patches to
avoid costly store/maipulate/reload sequences in places like do_sve_acc().

Signed-off-by: Julien Grall &lt;julien.grall@arm.com&gt;
Signed-off-by: Mark Brown &lt;broonie@kernel.org&gt;
Reviewed-by: Dave Martin &lt;Dave.Martin@arm.com&gt;
Link: https://lore.kernel.org/r/20200828181155.17745-6-broonie@kernel.org
Signed-off-by: Will Deacon &lt;will@kernel.org&gt;
</content>
</entry>
</feed>
