target/s390x: Extend qemu CPACF support
Subsystems (3)
v8 cover target/s390x: Extend qemu CPACF support
This patch series extends the s390 qemu CPACF support to be able to run a subset of the CPACF instruction cross platform. There have been requests on the kernel crypto mailing list about a way to test s390 specific crypto implementations. For example a way to test s390 CPACF exploitation code like the s390_aes.ko kernel module.
So here now is a set of patches verified on x86 and s390 which over (slow but working) support for a subset of the subfunctions of some of the CPACF instructions.
Test: As this series is more or less complete, a full blown linux can be run and the 'usual' in-kernel crpyto modules will be automatically loaded which run a bunch of test cases. So there is now support for these kernel modules:
* sha256_s390x (autoloaded, sha256)
* sha512_s390x (autoloaded, sha512)
* aes_s390x (autoloaded, clear key aes ecb, cbc, ctr, xts)
* pkey_pckmo (autoloaded, derive AES protected key from clear key)
* paes_s390x (not autoloaded, protected key aes ecb, cbc, ctr, xts) All these modules run selftests if configured by the kernel (which is enabled by default). Failures are reported via syslog. Additionally the aes testcases from libica can be run either inside such an qemu environment or with a static build executed with the qemu tcg application qemu-s390x --cpu max <static-build-libica-test>.
Changelog:
v1: Initial version with
- Related code restructured
- Support KIMD SHA512 and thus SHA256
- Support KMC AES-128, AES-192 and AES-256 and thus have basic AES support (ECB mode) enabled.
- Support PCC Compute-XTS-Parameter-AES-128 and Compute-XTS-Parameter-AES-256 but only for block sequence number
0. This is a requirement for the next step:
- Support KM XTS-AES-128 and KM XTS-AES-256. Together with the minimal PCC support this enables AES-XTS CPACF acceleration.
v2: - Basic PCKMO support to be able to 'derive' an AES protected key
from clear key. See header details.
- Support protected key AES-ECB.
- Support protected key AES-CBC.
- Minimal protected key AES-XTS support for CPACF PCC.
- Support protected key AES-XTS.
- Support AES-CTR.
- Support protected key AES-CTR.
v3: - Reordered patches as suggested by Finn.
- One small bug fix in CPACF_aes.c related to address translation.
v4: - Rename of the parameters based on feedback from Janosch to
make clear these are registers or ptrs to registers. Added Tested by from Holger. Fixed typo "face" -> "fake".
v5: - Add documentation file docs/system/s390x/cpacf.rst which
describes the state of the CPACF instructions and which functions are covered when this series is applied. First version sent to public mailing list qemu-s390x.
v6: - Rebase/rework to build on current qemu head.
- Add docs/system/s390x/cpacf.rst to target-s390x.rst
- New file crypto/aes-helpers.c with some simple functions to support AES modes CBC, CTR and XTS.
- Slight rewrite of the s390x CPACF implementations to use these generic AES mode implementations.
v7: - Update on docs/system/s390x/cpacf.rst to mention
the zArchicteture Principles of Operation document which describes all these CPAC instructions.
v8: - Add a fix which deals with incorrect address handling
in the sha512 implementation related to fetch and push data from/to memory.
- Slight rework around the capcf function implementation and exception generation.
- Added some more details to the new cpacf.rst file.
- Fixed some typos and added some suggestions from Finn.
- Fixed cc handling on return of PCKMO (must not update cc).
Missing: simple test cases to verify that the implemented and not implemented cpacf functions and subfunctions work as expected. But see the statement about tests at the header.
Harald Freudenberger (18):
target/s390x: Fix wrong address handling in address loops target/s390x: Rework s390 cpacf implementations target/s390x: Move cpacf sha512 code into a new file target/s390x: Support cpacf sha256
target/s390x: Support AES ECB for cpacf km instruction target/s390x: Support AES CBC for cpacf kmc instruction target/s390x: Support AES CTR for cpacf kmctr instruction target/s390x: Minimal AES XTS support for cpacf pcc instruction target/s390x: Support AES XTS for cpacf km instruction target/s390x: Support pckmo encrypt AES subfunctions target/s390x: Support protected key AES ECB for cpacf km instruction target/s390x: Support protected key AES CBC for cpacf kmc instruction target/s390x: Support protected key AES CTR for cpacf kmctr
instruction
target/s390x: Minimal protected key AES XTS support for cpacf pcc
instruction
target/s390x: Support protected key AES XTS for cpacf km instruction docs/s390: Document CPACF instructions support
crypto: Add aes-helpers file to support some AES modes target/s390x: Use generic AES helper functions
crypto/aes-helpers.c | 106 ++++ crypto/meson.build | 1 + docs/system/s390x/cpacf.rst | 144 +++++ docs/system/target-s390x.rst | 1 + include/crypto/aes.h | 14 + target/s390x/gen-features.c | 31 + target/s390x/tcg/cpacf.h | 66 +++ target/s390x/tcg/cpacf_aes.c | 956 +++++++++++++++++++++++++++++++ target/s390x/tcg/cpacf_sha256.c | 232 ++++++++ target/s390x/tcg/cpacf_sha512.c | 245 ++++++++ target/s390x/tcg/crypto_helper.c | 426 +++++++------- target/s390x/tcg/insn-data.h.inc | 1 + target/s390x/tcg/meson.build | 3 + target/s390x/tcg/translate.c | 11 +- 14 files changed, 2020 insertions(+), 217 deletions(-) create mode 100644 crypto/aes-helpers.c create mode 100644 docs/system/s390x/cpacf.rst create mode 100644 target/s390x/tcg/cpacf.h create mode 100644 target/s390x/tcg/cpacf_aes.c create mode 100644 target/s390x/tcg/cpacf_sha256.c create mode 100644 target/s390x/tcg/cpacf_sha512.c
base-commit: 3b50303f9563a42538a1fd5c0ea7f952e23016e1 --
2.43.0
PATCH v8 1/18 target/s390x: Fix wrong address handling in address loops
With the introduction of the address wrapping function wrap_address() the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.
--- target/s390x/tcg/crypto_helper.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
target/s390x/tcg/crypto_helper.c +8 -8
@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx,const MemOpIdx oi =make_memop_idx (MO_BE |MO_64 |MO_UNALN , mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr); + a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }
@@ -137,8 +137,8 @@ static void sha512_write_ocv(CPUS390XState *env, const int mmu_idx,const MemOpIdx oi =make_memop_idx (MO_BE |MO_64 |MO_UNALN , mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); -cpu_stq_mmu (env, addr, a[i], oi, ra); +uint64_t _addr =wrap_address (env, addr); +cpu_stq_mmu (env, _addr, a[i], oi, ra); } }
@@ -148,8 +148,8 @@ static void sha512_read_block(CPUS390XState *env, const int mmu_idx,const MemOpIdx oi =make_memop_idx (MO_BE |MO_64 |MO_UNALN , mmu_idx);for (int i =0 ; i <16 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr); + a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }
@@ -159,8 +159,8 @@ static void sha512_read_mbl_be64(CPUS390XState *env, const int mmu_idx,const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx);for (int i =0 ; i <16 ; i++, addr +=1 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldb_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr); + a[i] =cpu_ldb_mmu (env, _addr, oi, ra); } }
Signature · 1 line
2.43.0
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Hi Harald,
Quoted 7 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")
This commit merely added an argument. I suppose you meant 9f17bfdab42 ("target/s390x: support SHA-512 extensions").
Quoted 10 lines
Signed-off-by Harald Freudenberger <[email protected]>--- target/s390x/tcg/crypto_helper.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)target/s390x/tcg/crypto_helper.c +0
-0
target/s390x/tcg/crypto_helper.c static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, · line 129
Quoted 6 lines
target/s390x/tcg/crypto_helper.c +1
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx,const MemOpIdx oi =make_memop_idx (MO_BE |MO_64 |MO_UNALN , mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr);
s/_addr/wa/ or even directly inline?
a[i] = cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra);
Quoted 3 lines
target/s390x/tcg/crypto_helper.c +1
-0+ a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 9 lines · Philippe Mathieu-Daudé
Hi Harald,
Quoted 6 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.
Quoted 5 lines
Quoted 1 line
Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")This commit merely added an argument. I suppose you meant
9f17bfdab42("target/s390x: support SHA-512 extensions").
No. Commit fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument") introduces the mmu_idx with the wrap_address() function or macro. And the result was something like this:
for (int i = 0; i < 8; i++, addr += 8) {
addr = wrap_address(env, addr);
a[i] = cpu_ldq_mmu(env, addr, oi, ra);
}This code reuses the addr variable in the loop by setting addr to the wrapped address but after that the loop adds +8 to this wrapped address. This code only works as long as the wrapped address is equal to the address put put in.
Thus introduce another intermediate variable which holds the wrapped address:
for (int i = 0; i < 8; i++, addr += 8) {
uint64_t _addr = wrap_address(env, addr);
a[i] = cpu_ldq_mmu(env, _addr, oi, ra);
}Of course it would also work with a direct replacement:
for (int i = 0; i < 8; i++, addr += 8) {
a[i] = cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra);
}but this isn't that readable.
Quoted 25 lines
Quoted 10 lines
Signed-off-by Harald Freudenberger <[email protected]>--- target/s390x/tcg/crypto_helper.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)target/s390x/tcg/crypto_helper.c +0
-0target/s390x/tcg/crypto_helper.c static void sha512_read_icv(CPUS390XState *env, · line 130
Quoted 7 lines
target/s390x/tcg/crypto_helper.c +1
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env,const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr);s/_addr/wa/ or even directly inline?
a[i] = cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra);Quoted 3 lines
target/s390x/tcg/crypto_helper.c +1
-0+ a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 10 lines · Harald Freudenberger
Quoted 9 lines · Philippe Mathieu-Daudé
Hi Harald,
Quoted 6 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")This commit merely added an argument. I suppose you meant
9f17bfdab42("target/s390x: support SHA-512 extensions").No. Commit
fcc2699d41("target/s390x: Have MSA helper pass ammu_idxargument") introduces themmu_idxwith thewrap_address()function or macro.
You are saying the same, not really explaining, I'm not following...
Quoted 53 lines
And the result was something like this:
for (int i = 0; i < 8; i++, addr += 8) {
addr =wrap_address(env, addr);
a[i] =cpu_ldq_mmu(env, addr, oi, ra);
}This code reuses the addr variable in the loop by setting addr to the wrapped address but after that the loop adds +8 to this wrapped address. This code only works as long as the wrapped address is equal to the address put put in.
Thus introduce another intermediate variable which holds the wrapped address:for (int i = 0; i < 8; i++, addr += 8) {
uint64_t_addr=wrap_address(env, addr);
a[i] =cpu_ldq_mmu(env, _addr, oi, ra);
}Of course it would also work with a direct replacement:
for (int i = 0; i < 8; i++, addr += 8) {
a[i] =cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra); }but this isn't that readable.
Quoted 24 lines
Quoted 10 lines
Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)target/s390x/tcg/crypto_helper.c +0
-0target/s390x/tcg/crypto_helper.c static void sha512_read_icv(CPUS390XState *env, · line 129
Quoted 6 lines
target/s390x/tcg/crypto_helper.c +1
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr);s/_addr/wa/ or even directly inline?
a[i] =
cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra);Quoted 3 lines
target/s390x/tcg/crypto_helper.c +1
-0+ a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 13 lines · Philippe Mathieu-Daudé
Quoted 12 lines · Harald Freudenberger
Quoted 11 lines · Philippe Mathieu-Daudé
Hi Harald,
Quoted 7 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")
Quoted 9 lines
Quoted 6 lines
Quoted 3 lines
This commit merely added an argument. I suppose you meant
9f17bfdab42("target/s390x: support SHA-512 extensions").No. Commit
fcc2699d41("target/s390x: Have MSA helper pass ammu_idxargument") introduces themmu_idxwith thewrap_address()function or macro.You are saying the same, not really explaining, I'm not following...
I rephrased my wording regarding this fix. Please see v9 coming soon.
Quoted 53 lines
Quoted 53 lines
And the result was something like this:
for (int i = 0; i < 8; i++, addr += 8) {
addr =wrap_address(env, addr);
a[i] =cpu_ldq_mmu(env, addr, oi, ra);
}This code reuses the addr variable in the loop by setting addr to the wrapped address but after that the loop adds +8 to this wrapped address. This code only works as long as the wrapped address is equal to the address put put in.
Thus introduce another intermediate variable which holds the wrapped address:for (int i = 0; i < 8; i++, addr += 8) {
uint64_t_addr=wrap_address(env, addr);
a[i] =cpu_ldq_mmu(env, _addr, oi, ra);
}Of course it would also work with a direct replacement:
for (int i = 0; i < 8; i++, addr += 8) {
a[i] =cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra); }but this isn't that readable.
Quoted 24 lines
Quoted 10 lines
Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)target/s390x/tcg/crypto_helper.c +0
-0target/s390x/tcg/crypto_helper.c static void sha512_read_icv(CPUS390XState *env, · line 129
Quoted 6 lines
target/s390x/tcg/crypto_helper.c +1
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr);s/_addr/wa/ or even directly inline?
a[i] =
cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra);Quoted 3 lines
target/s390x/tcg/crypto_helper.c +1
-0+ a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
In reply to Philippe Mathieu-DaudéQuoted 9 lines · Philippe Mathieu-Daudé
Hi Harald,
Quoted 6 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.
Quoted 4 lines
Quoted 1 line
Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")This commit merely added an argument. I suppose you meant
9f17bfdab42("target/s390x: support SHA-512 extensions").
Yep, you are right. This addr overwrite was introduced with the original code - thus the commit you mentioned. I'll correct it.
Quoted 21 lines
Quoted 11 lines
Signed-off-by Harald Freudenberger <[email protected]>--- target/s390x/tcg/crypto_helper.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)target/s390x/tcg/crypto_helper.c +0
-0target/s390x/tcg/crypto_helper.c static void sha512_read_icv(CPUS390XState *env, · line 130
Quoted 7 lines
target/s390x/tcg/crypto_helper.c +1
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env,const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr);s/_addr/wa/ or even directly inline?
Quoted 5 lines
a[i] = cpu_ldq_mmu(env, wrap_address(env, addr), oi, ra);Quoted 3 lines
target/s390x/tcg/crypto_helper.c +1
-0+ a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }
Yes, let's make all these occurrences directly inline.
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
In reply to Harald FreudenbergerQuoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>--- target/s390x/tcg/crypto_helper.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr & 0xffffff) + 8) & 0xffffff) + 8) & 0xffffff
and with your patch it would be:
(addr + 8 + 8) & 0xffffff
which is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx,const MemOpIdx oi =make_memop_idx (MO_BE |MO_64 |MO_UNALN , mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) { - addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr); + a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }
[...]
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 35 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>--- target/s390x/tcg/crypto_helper.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr & 0xffffff) + 8) & 0xffffff) + 8) & 0xffffffand with your patch it would be:
(addr + 8 + 8) & 0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 9 lines
target/s390x/tcg/crypto_helper.c +0
-0@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env,const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx);for (int i =0 ; i <8 ; i++, addr +=8 ) {
Quoted 8 lines
Quoted 6 lines
target/s390x/tcg/crypto_helper.c +2
-2- addr =wrap_address (env, addr); - a[i] =cpu_ldq_mmu (env, addr, oi, ra); +uint64_t _addr =wrap_address (env, addr); + a[i] =cpu_ldq_mmu (env, _addr, oi, ra); } }[...]
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when wrap_address does return the very same address as output as it became as input. My fix corrects this.
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 44 lines · Harald Freudenberger
Quoted 26 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr &
0xffffff) + 8) &0xffffff) + 8) &0xffffffand with your patch it would be:
(addr + 8 + 8) &
0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 16 lines
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr); + a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }[...]
Quoted 7 lines
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when
wrap_addressdoes return the very same address as output as it became as input. My fix corrects this.
What does the patch change w.r.t. wrapping?
Suppose we have amode 24 and addr = 0xfffff0:
Before:
i = 0; addr = wrap(0xfffff0) = 0xfffff0;
a[0] = ldq(0xfffff0);
i = 1; addr = wrap(0xfffff0 + 8) = 0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr = wrap(0xfffff8 + 8) = 0;
a[2] = ldq(0);
i = 3; addr = wrap(0 + 8) = 8;
a[3] = ldq(8);After:
i = 0; addr = 0xfffff0;
_addr = wrap(0xfffff0) = 0xfffff0;
a[0] = ldq(0xfffff0)
i = 1; addr = 0xfffff0 + 8;
_addr = wrap(0xfffff8) = 0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr = 0xfffff8 + 8 = 0x1000000
_addr = wrap(0x1000000) = 0;
a[2] = ldq(0);
i = 3; addr = 0x1000000 + 8 = 0x1000008;
_addr = wrap(0x1000008) = 8;
a[3] = ldq(8);The behavior look identical to me.
What am I missing?
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 82 lines · Ilya Leoshkevich
Quoted 44 lines · Harald Freudenberger
Quoted 26 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr &
0xffffff) + 8) &0xffffff) + 8) &0xffffffand with your patch it would be:
(addr + 8 + 8) &
0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 16 lines
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr); + a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }[...]
Quoted 7 lines
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when
wrap_addressdoes return the very same address as output as it became as input. My fix corrects this.What does the patch change w.r.t. wrapping?
Suppose we have amode 24 and addr =0xfffff0:Before:
i = 0; addr = wrap(0xfffff0) = 0xfffff0; a[0] = ldq(0xfffff0); i = 1; addr = wrap(0xfffff0 + 8) = 0xfffff8; a[1] = ldq(0xfffff8); i = 2; addr = wrap(0xfffff8 + 8) = 0; a[2] = ldq(0); i = 3; addr = wrap(0 + 8) = 8; a[3] = ldq(8);After:
i = 0; addr = 0xfffff0; _addr = wrap(0xfffff0) = 0xfffff0; a[0] = ldq(0xfffff0) i = 1; addr = 0xfffff0 + 8; _addr = wrap(0xfffff8) = 0xfffff8; a[1] = ldq(0xfffff8); i = 2; addr = 0xfffff8 + 8 = 0x1000000 _addr = wrap(0x1000000) = 0; a[2] = ldq(0); i = 3; addr = 0x1000000 + 8 = 0x1000008; _addr = wrap(0x1000008) = 8; a[3] = ldq(8);
Quoted 2 lines
The behavior look identical to me.
What am I missing?
Lets assume addr is some 0x1000 and wrap does just add some offset, e.g. 0x8000
for (int i = 0; i < 8; i++, addr += 8) {
addr = wrap_address(env, addr);
fetch or write something at the wrapped address addr;
}Then the idea of this loop is to run through addr 0x1000 ... 0x103F.
1. loop with i=0 and addr 0x1000
2. loop with i=1 and addr 0x1000 + 8
3. loop with i=2 and addr 0x1000 + 8 + 8
4. loop with i=3 and addr 0x1000 + 8 + 8 + 8
5. loop with i=4 and addr 0x1000 + 8 + 8 + 8 + 8
6. loop with i=5 and addr 0x1000 + 8 + 8 + 8 + 8 + 8
7. loop with i=6 and addr 0x1000 + 8 + 8 + 8 + 8 + 8 + 8
8. loop with i=7 and addr 0x1000 + 8 + 8 + 8 + 8 + 8 + 8 + 8
BUT the given code does something different. As the addr is used in the loop to hold the wrapped address this loop in fact does:
1. loop with i=0 and addr 0x1000 - all fine, but as addr = wrap_address() at the end of the loop now addr is 0x1000 + 0x8000 = 0x9000, so next loop
starts with
2. loop with i=1 and addr 0x9000 + 8
and at the end of the loop addr is 0x9008 + 0x8000 = 0x11008 and next
loop starts
3. loop with i=2 and addr 0x11008 + 8
...
So introducing an intermediate variable which holds the wrapped address makes sure the surrounding addr walk in the loop does as intended.
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 114 lines · Harald Freudenberger
Quoted 82 lines · Ilya Leoshkevich
Quoted 44 lines · Harald Freudenberger
Quoted 26 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr &
0xffffff) + 8) &0xffffff) + 8) &0xffffffand with your patch it would be:
(addr + 8 + 8) &
0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 16 lines
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr); + a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }[...]
Quoted 7 lines
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when
wrap_addressdoes return the very same address as output as it became as input. My fix corrects this.What does the patch change w.r.t. wrapping?
Suppose we have amode 24 and addr =0xfffff0:Before:
i = 0; addr = wrap(0xfffff0) =
0xfffff0;
a[0] = ldq(0xfffff0);
i = 1; addr = wrap(0xfffff0 + 8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr = wrap(0xfffff8 + 8) = 0;
a[2] = ldq(0);
i = 3; addr = wrap(0 + 8) = 8;
a[3] = ldq(8);After:
i = 0; addr =
0xfffff0;
_addr= wrap(0xfffff0) =0xfffff0;
a[0] = ldq(0xfffff0)
i = 1; addr =0xfffff0+ 8;
_addr= wrap(0xfffff8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr =0xfffff8+ 8 =0x1000000
_addr= wrap(0x1000000) = 0;
a[2] = ldq(0);
i = 3; addr =0x1000000+ 8 =0x1000008;
_addr= wrap(0x1000008) = 8;
a[3] = ldq(8);Quoted 2 lines
The behavior look identical to me.
What am I missing?Lets assume addr is some
0x1000and wrap does just add some offset, e.g.0x8000for (int i = 0; i < 8; i++, addr += 8) {
addr =wrap_address(env, addr);
fetch or write something at the wrapped address addr;
}Then the idea of this loop is to run through addr
0x1000...0x103F.
1. loop with i=0 and addr0x1000
2. loop with i=1 and addr0x1000+ 8
3. loop with i=2 and addr0x1000+ 8 + 8
4. loop with i=3 and addr0x1000+ 8 + 8 + 8
5. loop with i=4 and addr0x1000+ 8 + 8 + 8 + 8
6. loop with i=5 and addr0x1000+ 8 + 8 + 8 + 8 + 8
7. loop with i=6 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8
8. loop with i=7 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8 + 8BUT the given code does something different. As the addr is used in the loop to hold the wrapped address this loop in fact does:
1. loop with i=0 and addr0x1000- all fine, but as addr =wrap_address()at the end of the loop now addr is0x1000+0x8000=0x9000, so next loop
starts with
2. loop with i=1 and addr0x9000+ 8
and at the end of the loop addr is0x9008+0x8000=0x11008and
next loop starts
3. loop with i=2 and addr0x11008+ 8
...
Quoted 2 lines
So introducing an intermediate variable which holds the wrapped address makes sure the surrounding addr walk in the loop does as intended.
Ah, now I see where we were talking past each other, thanks for the clarification. You assume that wrap_address() may do arbitrary transformations, like addition in your example above. But today it does only bitwise "and", as defined by the architecture:
static inline uint64_t wrap_address(CPUS390XState *env, uint64_t a)
{
if (!(env->psw.mask & PSW_MASK_64)) {
if (!(env->psw.mask & PSW_MASK_32)) {
/* 24-Bit mode */
a &= 0x00ffffff;
} else {
/* 31-Bit mode */
a &= 0x7fffffff;
}
}
return a;
}and I believe in this specific case the order doesn't matter.
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 123 lines · Ilya Leoshkevich
Quoted 112 lines · Harald Freudenberger
Quoted 82 lines · Ilya Leoshkevich
Quoted 44 lines · Harald Freudenberger
Quoted 26 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr &
0xffffff) + 8) &0xffffff) + 8) &0xffffffand with your patch it would be:
(addr + 8 + 8) &
0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 16 lines
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr); + a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }[...]
Quoted 7 lines
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when
wrap_addressdoes return the very same address as output as it became as input. My fix corrects this.What does the patch change w.r.t. wrapping?
Suppose we have amode 24 and addr =0xfffff0:Before:
i = 0; addr = wrap(0xfffff0) =
0xfffff0;
a[0] = ldq(0xfffff0);
i = 1; addr = wrap(0xfffff0 + 8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr = wrap(0xfffff8 + 8) = 0;
a[2] = ldq(0);
i = 3; addr = wrap(0 + 8) = 8;
a[3] = ldq(8);After:
i = 0; addr =
0xfffff0;
_addr= wrap(0xfffff0) =0xfffff0;
a[0] = ldq(0xfffff0)
i = 1; addr =0xfffff0+ 8;
_addr= wrap(0xfffff8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr =0xfffff8+ 8 =0x1000000
_addr= wrap(0x1000000) = 0;
a[2] = ldq(0);
i = 3; addr =0x1000000+ 8 =0x1000008;
_addr= wrap(0x1000008) = 8;
a[3] = ldq(8);Quoted 2 lines
The behavior look identical to me.
What am I missing?Lets assume addr is some
0x1000and wrap does just add some offset, e.g.0x8000for (int i = 0; i < 8; i++, addr += 8) {
addr =wrap_address(env, addr);
fetch or write something at the wrapped address addr; }Then the idea of this loop is to run through addr
0x1000...0x103F.
1. loop with i=0 and addr0x1000
2. loop with i=1 and addr0x1000+ 8
3. loop with i=2 and addr0x1000+ 8 + 8
4. loop with i=3 and addr0x1000+ 8 + 8 + 8
5. loop with i=4 and addr0x1000+ 8 + 8 + 8 + 8
6. loop with i=5 and addr0x1000+ 8 + 8 + 8 + 8 + 8
7. loop with i=6 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8
8. loop with i=7 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8 + 8BUT the given code does something different. As the addr is used in the loop to hold the wrapped address this loop in fact does:
1. loop with i=0 and addr0x1000- all fine, but as addr =wrap_address()at the end of the loop now addr is0x1000+0x8000=0x9000, so next loop starts with
2. loop with i=1 and addr0x9000+ 8
and at the end of the loop addr is0x9008+0x8000=0x11008and next loop starts
3. loop with i=2 and addr0x11008+ 8
...Quoted 2 lines
So introducing an intermediate variable which holds the wrapped address makes sure the surrounding addr walk in the loop does as intended.
Ah, now I see where we were talking past each other, thanks for the clarification. You assume that
wrap_address()may do arbitrary transformations, like addition in your example above. But today it does only bitwise "and", as defined by the architecture:
Quoted 10 lines
static inline
uint64_twrap_address(CPUS390XState *env, uint64_t a){
if (!(env->psw.mask &PSW_MASK_64)) {
if (!(env->psw.mask &PSW_MASK_32)) {
/* 24-Bit mode */
a &=0x00ffffff;
} else {
/* 31-Bit mode */
a &=0x7fffffff;
}
bool wrap32 = env->psw.mask & PSW_MASK_32;
a = extract64(a, 0, wrap32 ? 31 : 24);Quoted 6 lines
}
return a;
}and I believe in this specific case the order doesn't matter.
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 135 lines · Philippe Mathieu-Daudé
Quoted 123 lines · Ilya Leoshkevich
Quoted 112 lines · Harald Freudenberger
Quoted 82 lines · Ilya Leoshkevich
Quoted 44 lines · Harald Freudenberger
Quoted 26 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr &
0xffffff) + 8) &0xffffff) + 8) &0xffffffand with your patch it would be:
(addr + 8 + 8) &
0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 16 lines
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr); + a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }[...]
Quoted 7 lines
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when
wrap_addressdoes return the very same address as output as it became as input. My fix corrects this.What does the patch change w.r.t. wrapping?
Suppose we have amode 24 and addr =0xfffff0:Before:
i = 0; addr = wrap(0xfffff0) =
0xfffff0;
a[0] = ldq(0xfffff0);
i = 1; addr = wrap(0xfffff0 + 8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr = wrap(0xfffff8 + 8) = 0;
a[2] = ldq(0);
i = 3; addr = wrap(0 + 8) = 8;
a[3] = ldq(8);After:
i = 0; addr =
0xfffff0;
_addr= wrap(0xfffff0) =0xfffff0;
a[0] = ldq(0xfffff0)
i = 1; addr =0xfffff0+ 8;
_addr= wrap(0xfffff8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr =0xfffff8+ 8 =0x1000000
_addr= wrap(0x1000000) = 0;
a[2] = ldq(0);
i = 3; addr =0x1000000+ 8 =0x1000008;
_addr= wrap(0x1000008) = 8;
a[3] = ldq(8);Quoted 2 lines
The behavior look identical to me.
What am I missing?Lets assume addr is some
0x1000and wrap does just add some offset, e.g.0x8000for (int i = 0; i < 8; i++, addr += 8) {
addr =wrap_address(env, addr);
fetch or write something at the wrapped address addr; }Then the idea of this loop is to run through addr
0x1000...0x103F.
1. loop with i=0 and addr0x1000
2. loop with i=1 and addr0x1000+ 8
3. loop with i=2 and addr0x1000+ 8 + 8
4. loop with i=3 and addr0x1000+ 8 + 8 + 8
5. loop with i=4 and addr0x1000+ 8 + 8 + 8 + 8
6. loop with i=5 and addr0x1000+ 8 + 8 + 8 + 8 + 8
7. loop with i=6 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8
8. loop with i=7 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8 + 8BUT the given code does something different. As the addr is used in the loop to hold the wrapped address this loop in fact does:
1. loop with i=0 and addr0x1000- all fine, but as addr =wrap_address()at the end of the loop now addr is0x1000+0x8000=0x9000, so next loop starts with
2. loop with i=1 and addr0x9000+ 8
and at the end of the loop addr is0x9008+0x8000=0x11008and next loop starts
3. loop with i=2 and addr0x11008+ 8
...Quoted 2 lines
So introducing an intermediate variable which holds the wrapped address makes sure the surrounding addr walk in the loop does as intended.
Ah, now I see where we were talking past each other, thanks for the clarification. You assume that
wrap_address()may do arbitrary transformations, like addition in your example above. But today it does only bitwise "and", as defined by the architecture:Quoted 10 lines
static inline
uint64_twrap_address(CPUS390XState *env, uint64_t a){
if (!(env->psw.mask &PSW_MASK_64)) {
if (!(env->psw.mask &PSW_MASK_32)) {
/* 24-Bit mode */
a &=0x00ffffff;
} else {
/* 31-Bit mode */
a &=0x7fffffff;
}
Quoted 8 lines
bool wrap32 = env->psw.mask & PSW_MASK_32; a = extract64(a, 0, wrap32 ? 31 : 24);Quoted 6 lines
}
return a;
}and I believe in this specific case the order doesn't matter.
Hm, however a wrap_address() function may return whatever wrapping address calculation may be. A caller should not rely on the returned address being 'the same' as the address given in. So using separate variables for the address to wrap and the wrapped address is wise in my opinion.
Re: [PATCH v8 01/18] target/s390x: Fix wrong address handling in address loops
Quoted 142 lines · Harald Freudenberger
Quoted 141 lines · Philippe Mathieu-Daudé
Quoted 123 lines · Ilya Leoshkevich
Quoted 112 lines · Harald Freudenberger
Quoted 82 lines · Ilya Leoshkevich
Quoted 44 lines · Harald Freudenberger
Quoted 26 lines · Ilya Leoshkevich
Quoted 11 lines · Harald Freudenberger
With the introduction of the address wrapping function
wrap_address()the result can't be used to walk the source address any more. So introduce a new local variable to hold the wrapped address to avoid mixing source and wrapped address value.Fixes fcc2699d41 ("target/s390x: Have MSA helper pass a mmu_idx argument")Signed-off-by Harald Freudenberger <[email protected]>---
target/s390x/tcg/crypto_helper.c| 16 ++++++++--------1 file changed, 8 insertions(+), 8 deletions(-)If I take as an example AMODE 24 and look at the third loop iteration, with the current code in master I would get:
((((addr &
0xffffff) + 8) &0xffffff) + 8) &0xffffffand with your patch it would be:
(addr + 8 + 8) &
0xffffffwhich is undeniably more elegant, but otherwise looks equivalent to me.
What is the functional issue here?
Quoted 16 lines
Quoted 14 lines
target/s390x/tcg/crypto_helper.c +2
-2@@ -126,8 +126,8 @@ static void sha512_read_icv(CPUS390XState *env, const int mmu_idx, const MemOpIdx oi = make_memop_idx(MO_BE | MO_64 | MO_UNALN, mmu_idx); for (int i = 0; i < 8; i++, addr += 8) { - addr = wrap_address(env, addr); - a[i] = cpu_ldq_mmu(env, addr, oi, ra); + uint64_t _addr = wrap_address(env, addr); + a[i] = cpu_ldq_mmu(env, _addr, oi, ra); } }[...]
Quoted 7 lines
It is a fix, not an improvement. The original code used the addr variable to hold the wrapped address. But as addr is also used as the loop variable there is a mixing between unwrapped and wrapped address here and the unfixed code only works when
wrap_addressdoes return the very same address as output as it became as input. My fix corrects this.What does the patch change w.r.t. wrapping?
Suppose we have amode 24 and addr =0xfffff0:Before:
i = 0; addr = wrap(0xfffff0) =
0xfffff0;
a[0] = ldq(0xfffff0);
i = 1; addr = wrap(0xfffff0 + 8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr = wrap(0xfffff8 + 8) = 0;
a[2] = ldq(0);
i = 3; addr = wrap(0 + 8) = 8;
a[3] = ldq(8);After:
i = 0; addr =
0xfffff0;
_addr= wrap(0xfffff0) =0xfffff0;
a[0] = ldq(0xfffff0)
i = 1; addr =0xfffff0+ 8;
_addr= wrap(0xfffff8) =0xfffff8;
a[1] = ldq(0xfffff8);
i = 2; addr =0xfffff8+ 8 =0x1000000
_addr= wrap(0x1000000) = 0;
a[2] = ldq(0);
i = 3; addr =0x1000000+ 8 =0x1000008;
_addr= wrap(0x1000008) = 8;
a[3] = ldq(8);Quoted 2 lines
The behavior look identical to me.
What am I missing?Lets assume addr is some
0x1000and wrap does just add some offset, e.g.0x8000for (int i = 0; i < 8; i++, addr += 8) {
addr =wrap_address(env, addr);
fetch or write something at the wrapped address addr; }Then the idea of this loop is to run through addr
0x1000...0x103F.
1. loop with i=0 and addr0x1000
2. loop with i=1 and addr0x1000+ 8
3. loop with i=2 and addr0x1000+ 8 + 8
4. loop with i=3 and addr0x1000+ 8 + 8 + 8
5. loop with i=4 and addr0x1000+ 8 + 8 + 8 + 8
6. loop with i=5 and addr0x1000+ 8 + 8 + 8 + 8 + 8
7. loop with i=6 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8
8. loop with i=7 and addr0x1000+ 8 + 8 + 8 + 8 + 8 + 8 + 8BUT the given code does something different. As the addr is used in the loop to hold the wrapped address this loop in fact does:
1. loop with i=0 and addr0x1000- all fine, but as addr =wrap_address()at the end of the loop now addr is0x1000+0x8000=0x9000, so next loop starts with
2. loop with i=1 and addr0x9000+ 8
and at the end of the loop addr is0x9008+0x8000=0x11008and next loop starts
3. loop with i=2 and addr0x11008+ 8
...Quoted 2 lines
So introducing an intermediate variable which holds the wrapped address makes sure the surrounding addr walk in the loop does as intended.
Ah, now I see where we were talking past each other, thanks for the clarification. You assume that
wrap_address()may do arbitrary transformations, like addition in your example above. But today it does only bitwise "and", as defined by the architecture:Quoted 10 lines
static inline
uint64_twrap_address(CPUS390XState *env, uint64_t a){
if (!(env->psw.mask &PSW_MASK_64)) {
if (!(env->psw.mask &PSW_MASK_32)) {
/* 24-Bit mode */
a &=0x00ffffff;
} else {
/* 31-Bit mode */
a &=0x7fffffff;
}bool wrap32 =
env->psw.mask&PSW_MASK_32; a =extract64(a, 0, wrap32 ? 31 : 24);Quoted 4 lines
}
return a;
}
Quoted 8 lines
Quoted 2 lines
Quoted 2 lines
and I believe in this specific case the order doesn't matter.
Hm, however a
wrap_address()function may return whatever wrapping address calculation may be. A caller should not rely on the returned address being 'the same' as the address given in. So using separate variables for the address to wrap and the wrapped address is wise in my opinion.
Sure, I too think it's cleaner and more future-proof. My only point was that there are no practical issues today.
PATCH v8 2/18 target/s390x: Rework s390 cpacf implementations
In reply to Harald FreudenbergerFix missing parts for MSA 9 kdsa and rework the cpacf handling code so that further extensions can be made in a clean and structured way.
--- target/s390x/tcg/crypto_helper.c | 89 +++++++++++++++++++++++++++----- target/s390x/tcg/insn-data.h.inc | 1 + target/s390x/tcg/translate.c | 2 + 3 files changed, 79 insertions(+), 13 deletions(-)
target/s390x/tcg/crypto_helper.c +76 -13
@@ -272,6 +272,57 @@ static void fill_buf_random(CPUS390XState *env, const int mmu_idx, uintptr_t ra, } } +static int cpacf_kimd (CPUS390XState *env,const int mmu_idx,const uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x03 :/* CPACF_KIMD_SHA_512 */ + rc =cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], + &env->regs[r2 +1 ],S390_FEAT_TYPE_KIMD ); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} + +static int cpacf_klmd (CPUS390XState *env,const int mmu_idx,const uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x03 :/* CPACF_KLMD_SHA_512 */ + rc =cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], + &env->regs[r2 +1 ],S390_FEAT_TYPE_KLMD ); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} + +static int cpacf_ppno (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x72 :/* CPACF_PRNO_TRNG */ +fill_buf_random (env, mmu_idx, ra, &env->regs[r1], &env->regs[r1 +1 ]); +fill_buf_random (env, mmu_idx, ra, &env->regs[r2], &env->regs[r2 +1 ]); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} +uint32_t HELPER (msa )(CPUS390XState *env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t type) {
@@ -282,13 +333,15 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,uint8_t subfunc[16 ] = {0 };uint64_t param_addr;MemOpIdx oi; +int rc =0 ;switch (type) { -case S390_FEAT_TYPE_KMAC : +case S390_FEAT_TYPE_KDSA :case S390_FEAT_TYPE_KIMD :case S390_FEAT_TYPE_KLMD : -case S390_FEAT_TYPE_PCKMO : +case S390_FEAT_TYPE_KMAC :case S390_FEAT_TYPE_PCC : +case S390_FEAT_TYPE_PCKMO :if (mod) {tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); }
@@ -300,25 +353,35 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); } -switch (fc) { -case 0 :/* query subfunction */ +/* handle query subfunction */ +if (fc ==0 ) { oi =make_memop_idx (MO_8 , mmu_idx); -for (int i =0 ; i <16 ; i++) { +for (int i =0 ; i <sizeof (subfunc); i++) { param_addr =wrap_address (env, env->regs[1 ] + i);cpu_stb_mmu (env, param_addr, subfunc[i], oi, ra); } + goto out; + } + +switch (type) { +case S390_FEAT_TYPE_KIMD : + rc =cpacf_kimd (env, mmu_idx, ra, r1, r2, r3, fc);break ; -case 3 :/* CPACF_*_SHA_512 */ -return cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], - &env->regs[r2 +1 ], type); -case 114 :/* CPACF_PRNO_TRNG */ -fill_buf_random (env, mmu_idx, ra, &env->regs[r1], &env->regs[r1 +1 ]); -fill_buf_random (env, mmu_idx, ra, &env->regs[r2], &env->regs[r2 +1 ]); +case S390_FEAT_TYPE_KLMD : + rc =cpacf_klmd (env, mmu_idx, ra, r1, r2, r3, fc); +break ; +case S390_FEAT_TYPE_PPNO : + rc =cpacf_ppno (env, mmu_idx, ra, r1, r2, r3, fc); +break ; +case S390_FEAT_TYPE_KDSA : +case S390_FEAT_TYPE_KMAC : +/* subfunctions (other than query) are not implemented yet */ +tcg_s390_program_interrupt (env,PGM_OPERATION , ra);break ;default : -/* we don't implement any other subfunction yet */ g_assert_not_reached (); } -return 0 ; +out: +return rc; }
target/s390x/tcg/insn-data.h.inc +1 -0
@@ -1015,6 +1015,7 @@ D(0xb92e, KM, RRE, MSA, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_KM) D(0xb92f, KMC, RRE, MSA, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_KMC) D(0xb929, KMA, RRF_b, MSA8, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_KMA) + D(0xb93a, KDSA, RRE, MSA9, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_KDSA) E(0xb93c, PPNO, RRE, MSA5, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_PPNO, IF_IO) D(0xb93e, KIMD, RRE, MSA, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_KIMD) D(0xb93f, KLMD, RRE, MSA, 0, 0, 0, 0, msa, 0, S390_FEAT_TYPE_KLMD)
target/s390x/tcg/translate.c +2 -0
@@ -2592,6 +2592,7 @@ static DisasJumpType op_msa(DisasContext *s, DisasOps *o)/* FALL THROUGH */ case S390_FEAT_TYPE_PCKMO :case S390_FEAT_TYPE_PCC : +case S390_FEAT_TYPE_KDSA :break ;default :g_assert_not_reached ();
@@ -6046,6 +6047,7 @@ enum DisasInsnEnum {#define FAC_MSA4 S390_FEAT_MSA_EXT_4/* msa-extension-4 facility */ #define FAC_MSA5 S390_FEAT_MSA_EXT_5/* msa-extension-5 facility */ #define FAC_MSA8 S390_FEAT_MSA_EXT_8/* msa-extension-8 facility */ +#define FAC_MSA9 S390_FEAT_MSA_EXT_9/* msa-extension-9 facility */ #define FAC_ECT S390_FEAT_EXTRACT_CPU_TIME#define FAC_PCI S390_FEAT_ZPCI/* z/PCI facility */ #define FAC_AIS S390_FEAT_ADAPTER_INT_SUPPRESSION
Signature · 1 line
2.43.0
Re: [PATCH v8 02/18] target/s390x: Rework s390 cpacf implementations
Quoted 61 lines · Harald Freudenberger
Fix missing parts for MSA 9 kdsa and rework the cpacf handling code so that further extensions can be made in a clean and structured way.
Signed-off-by Harald Freudenberger <[email protected]>Reviewed-by Holger Dengler <[email protected]>Tested-by Holger Dengler <[email protected]>--- target/s390x/tcg/crypto_helper.c | 89 +++++++++++++++++++++++++++----- target/s390x/tcg/insn-data.h.inc | 1 + target/s390x/tcg/translate.c | 2 + 3 files changed, 79 insertions(+), 13 deletions(-)target/s390x/tcg/crypto_helper.c +40
-0@@ -272,6 +272,57 @@ static void fill_buf_random(CPUS390XState *env, const int mmu_idx, uintptr_t ra, } } +static int cpacf_kimd (CPUS390XState *env,const int mmu_idx,const uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x03 :/* CPACF_KIMD_SHA_512 */ + rc =cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], + &env->regs[r2 +1 ],S390_FEAT_TYPE_KIMD ); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} + +static int cpacf_klmd (CPUS390XState *env,const int mmu_idx,const uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x03 :/* CPACF_KLMD_SHA_512 */ + rc =cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], + &env->regs[r2 +1 ],S390_FEAT_TYPE_KLMD ); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} + +static int cpacf_ppno (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) +{ +int rc =0 ; + +switch (fc) {
target/s390x/tcg/crypto_helper.c static void fill_buf_random(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 324
Quoted 10 lines
target/s390x/tcg/crypto_helper.c +10
-0+case 0x72 :/* CPACF_PRNO_TRNG */ +fill_buf_random (env, mmu_idx, ra, &env->regs[r1], &env->regs[r1 +1 ]); +fill_buf_random (env, mmu_idx, ra, &env->regs[r2], &env->regs[r2 +1 ]); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +}
I wonder if it would make sense to create separate op_kimd(), etc, opcode handlers and make these new functions separate helpers. Multiplexing in op_msa() and then de-multiplexing here looks like busy work to me. That's of course out of scope of this series, so:
[...]
PATCH v8 3/18 target/s390x: Move cpacf sha512 code into a new file
In reply to Harald FreudenbergerMove the cpacf sha512 implementation into a new file cpacf_sha512.c. Add this new file to the build and add a new header file cpacf.h containing the prototypes for the s390 cpacf stuff.
--- target/s390x/tcg/cpacf.h | 19 +++ target/s390x/tcg/cpacf_sha512.c | 245 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 227 +--------------------------- target/s390x/tcg/meson.build | 1 + 4 files changed, 266 insertions(+), 226 deletions(-) create mode 100644 target/s390x/tcg/cpacf.h create mode 100644 target/s390x/tcg/cpacf_sha512.c
target/s390x/tcg/cpacf.h new file +19 -0
@@ -0,0 +1,19 @@ +/* +* s390x cpacf +* +* This work is licensed under the terms of the GNU GPL, version 2 or later. +* See the COPYING file in the top-level directory. +*/ + +#ifndef S390X_CPACF_H +#define S390X_CPACF_H + +#include "cpu.h" +#include <stdint.h> + +/* from cpacf_sha512.c */ +int cpacf_sha512 (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *message_reg,uint64_t *len_reg, +uint32_t type); + +#endif
target/s390x/tcg/cpacf_sha512.c new file +245 -0
245 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +1 -226
233 lines not on this page · raw message
target/s390x/tcg/meson.build +1 -0
@@ -5,6 +5,7 @@ s390x_ss.add(when: 'CONFIG_TCG', if_true: files( )) s390x_common_ss.add(when: 'CONFIG_TCG', if_true: files( 'cc_helper.c', + 'cpacf_sha512.c', 'crypto_helper.c', 'excp_helper.c', 'fpu_helper.c',
Signature · 1 line
2.43.0
Re: [PATCH v8 03/18] target/s390x: Move cpacf sha512 code into a new file
Quoted 25 lines · Harald Freudenberger
Move the cpacf sha512 implementation into a new file
cpacf_sha512.c. Add this new file to the build and add a new header filecpacf.hcontaining the prototypes for the s390 cpacf stuff.Signed-off-by Harald Freudenberger <[email protected]>Tested-by Holger Dengler <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/tcg/cpacf.h | 19 +++ target/s390x/tcg/cpacf_sha512.c | 245 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 227 +--------------------------- target/s390x/tcg/meson.build | 1 + 4 files changed, 266 insertions(+), 226 deletions(-)create mode 100644
target/s390x/tcg/cpacf.hcreate mode 100644target/s390x/tcg/cpacf_sha512.ctarget/s390x/tcg/cpacf.h new file +2
-0@@ -0,0 +1,19 @@ +/* +* s390x cpacf
target/s390x/tcg/cpacf.h line 12
Quoted 10 lines
target/s390x/tcg/cpacf.h new file +10
-0+* +* This work is licensed under the terms of the GNU GPL, version 2 or later. +* See the COPYING file in the top-level directory. +*/ + +#ifndef S390X_CPACF_H +#define S390X_CPACF_H + +#include "cpu.h" +#include <stdint.h>
<stdint.h> is already provided by "qemu/osdep.h", which all C source files include.
Quoted 14 lines
target/s390x/tcg/cpacf.h new file +7
-0+ +/* from cpacf_sha512.c */ +int cpacf_sha512 (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *message_reg,uint64_t *len_reg, +uint32_t type); + +#endif target/s390x/tcg/crypto_helper.c +0
-0
target/s390x/tcg/crypto_helper.c line 23
Quoted 5 lines
target/s390x/tcg/crypto_helper.c +1
-0@@ -19,232 +19,7 @@#include "exec/helper-proto.h" #include "accel/tcg/cpu-ldst-common.h" #include "accel/tcg/cpu-mmu-index.h" +#include "cpacf.h"
target/s390x/tcg/cpacf.h ?
Re: [PATCH v8 03/18] target/s390x: Move cpacf sha512 code into a new file
In reply to Harald FreudenbergerQuoted 8 lines · Harald Freudenberger
Move the cpacf sha512 implementation into a new file
cpacf_sha512.c. Add this new file to the build and add a new header filecpacf.hcontaining the prototypes for the s390 cpacf stuff.Signed-off-by Harald Freudenberger <[email protected]>Tested-by Holger Dengler <[email protected]>Reviewed-by Finn Callies <[email protected]>
Quoted 8 lines
--- target/s390x/tcg/cpacf.h | 19 +++ target/s390x/tcg/cpacf_sha512.c | 245 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 227 +--------------------------- target/s390x/tcg/meson.build | 1 + 4 files changed, 266 insertions(+), 226 deletions(-)create mode 100644
target/s390x/tcg/cpacf.hcreate mode 100644target/s390x/tcg/cpacf_sha512.c
PATCH v8 4/18 target/s390x: Support cpacf sha256
In reply to Harald FreudenbergerAdd a new file cpacf_sha256.c which implements sha256. Add support for the sha256 subfuction for CPACF kimd and klmd.
--- target/s390x/gen-features.c | 2 + target/s390x/tcg/cpacf.h | 5 + target/s390x/tcg/cpacf_sha256.c | 232 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 8 ++ target/s390x/tcg/meson.build | 1 + 5 files changed, 248 insertions(+) create mode 100644 target/s390x/tcg/cpacf_sha256.c
target/s390x/gen-features.c +2 -0
@@ -916,7 +916,9 @@ static uint16_t qemu_V7_1[] = {*/ static uint16_t qemu_MAX[] = {S390_FEAT_MSA_EXT_5 , +S390_FEAT_KIMD_SHA_256 ,S390_FEAT_KIMD_SHA_512 , +S390_FEAT_KLMD_SHA_256 ,S390_FEAT_KLMD_SHA_512 ,S390_FEAT_PRNO_TRNG , };
target/s390x/tcg/cpacf.h +5 -0
@@ -11,6 +11,11 @@#include "cpu.h" #include <stdint.h> +/* from cpacf_sha256.c */ +int cpacf_sha256 (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *message_reg,uint64_t *len_reg, +uint32_t type); +/* from cpacf_sha512.c */ int cpacf_sha512(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *message_reg, uint64_t *len_reg,
target/s390x/tcg/cpacf_sha256.c new file +232 -0
232 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +8 -0
@@ -53,6 +53,10 @@ static int cpacf_kimd(CPUS390XState *env, const int mmu_idx, const uintptr_t ra,int rc =0 ;switch (fc) { +case 0x02 :/* CPACF_KIMD_SHA_256 */ + rc =cpacf_sha256 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], + &env->regs[r2 +1 ],S390_FEAT_TYPE_KIMD ); +break ;case 0x03 :/* CPACF_KIMD_SHA_512 */ rc =cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], &env->regs[r2 +1 ],S390_FEAT_TYPE_KIMD );
@@ -70,6 +74,10 @@ static int cpacf_klmd(CPUS390XState *env, const int mmu_idx, const uintptr_t ra,int rc =0 ;switch (fc) { +case 0x02 :/* CPACF_KLMD_SHA_256 */ + rc =cpacf_sha256 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], + &env->regs[r2 +1 ],S390_FEAT_TYPE_KLMD ); +break ;case 0x03 :/* CPACF_KLMD_SHA_512 */ rc =cpacf_sha512 (env, mmu_idx, ra, env->regs[1 ], &env->regs[r2], &env->regs[r2 +1 ],S390_FEAT_TYPE_KLMD );
target/s390x/tcg/meson.build +1 -0
@@ -5,6 +5,7 @@ s390x_ss.add(when: 'CONFIG_TCG', if_true: files( )) s390x_common_ss.add(when: 'CONFIG_TCG', if_true: files( 'cc_helper.c', + 'cpacf_sha256.c', 'cpacf_sha512.c', 'crypto_helper.c', 'excp_helper.c',
Signature · 1 line
2.43.0
Re: [PATCH v8 04/18] target/s390x: Support cpacf sha256
Quoted 6 lines · Harald Freudenberger
Add a new file
cpacf_sha256.cwhich implements sha256. Add support for the sha256 subfuction for CPACF kimd and klmd.Signed-off-by Harald Freudenberger <[email protected]>Tested-by Holger Dengler <[email protected]>Reviewed-by Finn Callies <[email protected]>
Quoted 8 lines
--- target/s390x/gen-features.c | 2 + target/s390x/tcg/cpacf.h | 5 + target/s390x/tcg/cpacf_sha256.c | 232 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 8 ++ target/s390x/tcg/meson.build | 1 + 5 files changed, 248 insertions(+)create mode 100644
target/s390x/tcg/cpacf_sha256.c
PATCH v8 5/18 target/s390x: Support AES ECB for cpacf km instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KM_AES_128, CPACF_KM_AES_192 and CPACF_KM_AES_256 for the cpacf km instruction.
--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 6 ++ target/s390x/tcg/cpacf_aes.c | 113 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 +++++++ target/s390x/tcg/meson.build | 1 + 5 files changed, 147 insertions(+) create mode 100644 target/s390x/tcg/cpacf_aes.c
target/s390x/gen-features.c +3 -0
@@ -921,6 +921,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KLMD_SHA_256 ,S390_FEAT_KLMD_SHA_512 ,S390_FEAT_PRNO_TRNG , +S390_FEAT_KM_AES_128 , +S390_FEAT_KM_AES_192 , + S390_FEAT_KM_AES_256, };/****** END FEATURE DEFS ******/
target/s390x/tcg/cpacf.h +6 -0
@@ -21,4 +21,10 @@ int cpacf_sha512(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *message_reg, uint64_t *len_reg, uint32_t type); +/* from cpacf_aes.c */ +int cpacf_aes_ecb (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod); +#endif
target/s390x/tcg/cpacf_aes.c new file +113 -0
113 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +24 -0
@@ -89,6 +89,27 @@ static int cpacf_klmd(CPUS390XState *env, const int mmu_idx, const uintptr_t ra,return rc; } +static int cpacf_km (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3, +uint8_t fc,uint8_t mod) +{ +int rc =0 ; + +switch (fc) { +case 0x12 :/* CPACF_KM_AES_128 */ +case 0x13 :/* CPACF_KM_AES_192 */ +case 0x14 :/* CPACF_KM_AES_256 */ + rc =cpacf_aes_ecb (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], +S390_FEAT_TYPE_KM , fc, mod); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} +static int cpacf_ppno (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) {
@@ -153,6 +174,9 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,case S390_FEAT_TYPE_KLMD : rc =cpacf_klmd (env, mmu_idx, ra, r1, r2, r3, fc);break ; +case S390_FEAT_TYPE_KM : + rc =cpacf_km (env, mmu_idx, ra, r1, r2, r3, fc, mod); +break ;case S390_FEAT_TYPE_PPNO : rc =cpacf_ppno (env, mmu_idx, ra, r1, r2, r3, fc);break ;
target/s390x/tcg/meson.build +1 -0
@@ -5,6 +5,7 @@ s390x_ss.add(when: 'CONFIG_TCG', if_true: files( )) s390x_common_ss.add(when: 'CONFIG_TCG', if_true: files( 'cc_helper.c', + 'cpacf_aes.c', 'cpacf_sha256.c', 'cpacf_sha512.c', 'crypto_helper.c',
Signature · 1 line
2.43.0
Re: [PATCH v8 05/18] target/s390x: Support AES ECB for cpacf km instruction
Quoted 14 lines · Harald Freudenberger
Support the subfunctions
CPACF_KM_AES_128,CPACF_KM_AES_192andCPACF_KM_AES_256for the cpacf km instruction.Signed-off-by Harald Freudenberger <[email protected]>Tested-by Holger Dengler <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 6 ++ target/s390x/tcg/cpacf_aes.c | 113 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 +++++++ target/s390x/tcg/meson.build | 1 + 5 files changed, 147 insertions(+)create mode 100644
target/s390x/tcg/cpacf_aes.c
[...]
Quoted 25 lines
target/s390x/tcg/cpacf_aes.c new file +19
-0@@ -0,0 +1,113 @@ +/* +* s390 cpacf aes +* +* Authors: +* Harald Freudenberger <[email protected]> +* +* This work is licensed under the terms of the GNU GPL, version 2 or later. +* See the COPYING file in the top-level directory. +*/ + +#include "qemu/osdep.h" +#include "s390x-internal.h" +#include "tcg_s390x.h" +#include "accel/tcg/cpu-ldst-common.h" +#include "accel/tcg/cpu-mmu-index.h" +#include "crypto/aes.h" +#include "cpacf.h" + +static void aes_read_block(CPUS390XState *env, const int mmu_idx,
target/s390x/tcg/cpacf_aes.c line 29
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c new file +10
-0+ uint64_t addr, uint8_t *a, uintptr_t ra) +{ + const MemOpIdx oi = make_memop_idx(MO_8, mmu_idx); +uint64_t _addr; + +for (int i =0 ; i <AES_BLOCK_SIZE ; i++, addr +=1 ) { + _addr =wrap_address (env, addr); + a[i] =cpu_ldb_mmu (env, _addr, oi, ra); + } +}
This is very similar to sha256_read_mbl_be32().
Would it make sense to factor this out as copy_from_guest_wrap() or something along these lines?
[...]
PATCH v8 6/18 target/s390x: Support AES CBC for cpacf kmc instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KMC_AES_128, CPACF_KMC_AES_192 and CPACF_KMC_AES_256 for the cpacf kmc instruction.
--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 102 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++ 4 files changed, 133 insertions(+)
target/s390x/gen-features.c +3 -0
@@ -924,6 +924,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KM_AES_128 ,S390_FEAT_KM_AES_192 ,S390_FEAT_KM_AES_256 , +S390_FEAT_KMC_AES_128 , +S390_FEAT_KMC_AES_192 , + S390_FEAT_KMC_AES_256, };/****** END FEATURE DEFS ******/
target/s390x/tcg/cpacf.h +4 -0
@@ -26,5 +26,9 @@ int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *dst_ptr_reg, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_aes_cbc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +102 -0
105 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +24 -0
@@ -110,6 +110,27 @@ static int cpacf_km(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return rc; } +static int cpacf_kmc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3, +uint8_t fc,uint8_t mod) +{ +int rc =0 ; + +switch (fc) { +case 0x12 :/* CPACF_KMC_AES_128 */ +case 0x13 :/* CPACF_KMC_AES_192 */ +case 0x14 :/* CPACF_KMC_AES_256 */ + rc =cpacf_aes_cbc (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], +S390_FEAT_TYPE_KMC , fc, mod); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} +static int cpacf_ppno (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) {
@@ -177,6 +198,9 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,case S390_FEAT_TYPE_KM : rc =cpacf_km (env, mmu_idx, ra, r1, r2, r3, fc, mod);break ; +case S390_FEAT_TYPE_KMC : + rc =cpacf_kmc (env, mmu_idx, ra, r1, r2, r3, fc, mod); +break ;case S390_FEAT_TYPE_PPNO : rc =cpacf_ppno (env, mmu_idx, ra, r1, r2, r3, fc);break ;
Signature · 1 line
2.43.0
Re: [PATCH v8 06/18] target/s390x: Support AES CBC for cpacf kmc instruction
Quoted 12 lines · Harald Freudenberger
Support the subfunctions
CPACF_KMC_AES_128,CPACF_KMC_AES_192andCPACF_KMC_AES_256for the cpacf kmc instruction.Signed-off-by Harald Freudenberger <[email protected]>Tested-by Holger Dengler <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 102 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++ 4 files changed, 133 insertions(+)
[...]
Quoted 56 lines
target/s390x/tcg/cpacf_aes.c +48
-0@@ -111,3 +111,105 @@ int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return !len ?0 :3 ; } + +static void aes_xor (const uint8_t *src1,const uint8_t *src2,uint8_t *dst) +{ +for (int i =0 ; i <AES_BLOCK_SIZE ; i++) { + dst[i] = src1[i] ^ src2[i]; + } +} + +int cpacf_aes_cbc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod) +{ +enum {MAX_BLOCKS_PER_RUN =8192 /AES_BLOCK_SIZE }; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ]; +const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); +uint64_t addr, len = *src_len_reg, done =0 ; +int i, keysize, addr_reg_size =64 ; +uint8_t key[32 ], iv[AES_BLOCK_SIZE ]; +AES_KEY exkey; + +g_assert (type ==S390_FEAT_TYPE_KMC ); + +switch (fc) { +case 0x12 :/* CPACF_KMC_AES_128 */ + keysize =16 ; +break ; +case 0x13 :/* CPACF_KMC_AES_192 */ + keysize =24 ; +break ; +case 0x14 :/* CPACF_KMC_AES_256 */ + keysize =32 ; +break ; +default : +g_assert_not_reached (); + } + +if (!(env->psw.mask &PSW_MASK_64 )) { + len = (uint32_t )len; + addr_reg_size = (env->psw.mask &PSW_MASK_32 ) ?32 :24 ; + } + +/* length has to be properly aligned. */ +if (!QEMU_IS_ALIGNED (len,AES_BLOCK_SIZE )) { +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +/* fetch iv from param block */
target/s390x/tcg/cpacf_aes.c int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 171
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c +10
-0+for (i =0 ; i <AES_BLOCK_SIZE ; i++) { + addr =wrap_address (env, param_addr + i); + iv[i] =cpu_ldb_mmu (env, addr, oi, ra); + } + +/* fetch key from param block */ +for (i =0 ; i < keysize; i++) { + addr =wrap_address (env, param_addr +AES_BLOCK_SIZE + i); + key[i] =cpu_ldb_mmu (env, addr, oi, ra); + }
Another couple of candidates for copy_from_guest_wrap().
Quoted 18 lines
target/s390x/tcg/cpacf_aes.c +18
-0+ +/* expand key */ +if (mod) { +AES_set_decrypt_key (key, keysize *8 , &exkey); + }else { +AES_set_encrypt_key (key, keysize *8 , &exkey); + } + +/* process up to MAX_BLOCKS_PER_RUN aes blocks */ +for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) { +aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); +if (mod) { +/* decrypt in => buf */ +AES_decrypt (in, buf, &exkey); +/* buf xor iv => out */ +aes_xor (buf, iv, out); +/* prep iv for next round */ +memcpy (iv, in,AES_BLOCK_SIZE );
target/s390x/tcg/cpacf_aes.c int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 199
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c +10
-0+ }else { +/* in xor iv => buf */ +aes_xor (in, iv, buf); +/* encrypt buf => out */ +AES_encrypt (buf, out, &exkey); +/* prep iv for next round */ +memcpy (iv, out,AES_BLOCK_SIZE ); + } +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); + len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;
I think
len -= AES_BLOCK_SIZE;
done += AES_BLOCK_SIZE;would be clearer.
Other than that:
[...]
Re: [PATCH v8 06/18] target/s390x: Support AES CBC for cpacf kmc instruction
Quoted 80 lines · Ilya Leoshkevich
Quoted 13 lines · Harald Freudenberger
Support the subfunctions
CPACF_KMC_AES_128,CPACF_KMC_AES_192andCPACF_KMC_AES_256for the cpacf kmc instruction.Signed-off-by Harald Freudenberger <[email protected]>Tested-by Holger Dengler <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 102 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++ 4 files changed, 133 insertions(+)[...]
Quoted 63 lines
target/s390x/tcg/cpacf_aes.c +2
-0@@ -111,3 +111,105 @@ int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, return !len ? 0 : 3; } + +static void aes_xor(const uint8_t *src1, const uint8_t *src2, uint8_t*dst)
target/s390x/tcg/cpacf_aes.c +7
-0+{ +for (int i =0 ; i <AES_BLOCK_SIZE ; i++) { + dst[i] = src1[i] ^ src2[i]; + } +} + +int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_tra,
target/s390x/tcg/cpacf_aes.c +6
-0+ uint64_t param_addr, uint64_t *dst_ptr_reg, + uint64_t *src_ptr_reg, uint64_t *src_len_reg, + uint32_t type, uint8_t fc, uint8_t mod) +{ + enum { MAX_BLOCKS_PER_RUN = 8192 / AES_BLOCK_SIZE }; + uint8_t in[AES_BLOCK_SIZE], out[AES_BLOCK_SIZE],buf[AES_BLOCK_SIZE];
target/s390x/tcg/cpacf_aes.c +37
-0+const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); +uint64_t addr, len = *src_len_reg, done =0 ; +int i, keysize, addr_reg_size =64 ; +uint8_t key[32 ], iv[AES_BLOCK_SIZE ]; +AES_KEY exkey; + +g_assert (type ==S390_FEAT_TYPE_KMC ); + +switch (fc) { +case 0x12 :/* CPACF_KMC_AES_128 */ + keysize =16 ; +break ; +case 0x13 :/* CPACF_KMC_AES_192 */ + keysize =24 ; +break ; +case 0x14 :/* CPACF_KMC_AES_256 */ + keysize =32 ; +break ; +default : +g_assert_not_reached (); + } + +if (!(env->psw.mask &PSW_MASK_64 )) { + len = (uint32_t )len; + addr_reg_size = (env->psw.mask &PSW_MASK_32 ) ?32 :24 ; + } + +/* length has to be properly aligned. */ +if (!QEMU_IS_ALIGNED (len,AES_BLOCK_SIZE )) { +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +/* fetch iv from param block */ +for (i =0 ; i <AES_BLOCK_SIZE ; i++) { + addr =wrap_address (env, param_addr + i); + iv[i] =cpu_ldb_mmu (env, addr, oi, ra); + }
Quoted 9 lines
target/s390x/tcg/cpacf_aes.c int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 171
Quoted 6 lines
target/s390x/tcg/cpacf_aes.c +6
-0+ +/* fetch key from param block */ +for (i =0 ; i < keysize; i++) { + addr =wrap_address (env, param_addr +AES_BLOCK_SIZE + i); + key[i] =cpu_ldb_mmu (env, addr, oi, ra); + }Another couple of candidates for
copy_from_guest_wrap().
Yes, makes sense to have some (inline) function. I think I will add something to cpacf.h.
Quoted 43 lines
Quoted 19 lines
target/s390x/tcg/cpacf_aes.c +10
-0+ +/* expand key */ +if (mod) { +AES_set_decrypt_key (key, keysize *8 , &exkey); + }else { +AES_set_encrypt_key (key, keysize *8 , &exkey); + } + +/* process up to MAX_BLOCKS_PER_RUN aes blocks */ +for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++){
target/s390x/tcg/cpacf_aes.c +8
-0+aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); +if (mod) { +/* decrypt in => buf */ +AES_decrypt (in, buf, &exkey); +/* buf xor iv => out */ +aes_xor (buf, iv, out); +/* prep iv for next round */ +memcpy (iv, in,AES_BLOCK_SIZE );target/s390x/tcg/cpacf_aes.c int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 199
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c +10
-0+ }else { +/* in xor iv => buf */ +aes_xor (in, iv, buf); +/* encrypt buf => out */ +AES_encrypt (buf, out, &exkey); +/* prep iv for next round */ +memcpy (iv, out,AES_BLOCK_SIZE ); + } +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); + len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;I think
len -= AES_BLOCK_SIZE; done += AES_BLOCK_SIZE;would be clearer.
Other than that:
Reviewed-by Ilya Leoshkevich <[email protected]>[...]
PATCH v8 7/18 target/s390x: Support AES CTR for cpacf kmctr instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KMCTR_AES_128, CPACF_KMCTR_AES_192 and CPACF_KMCTR_AES_256 for the cpacf kmctr instruction.
--- target/s390x/gen-features.c | 3 ++ target/s390x/tcg/cpacf.h | 5 +++ target/s390x/tcg/cpacf_aes.c | 76 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++++ 4 files changed, 108 insertions(+)
target/s390x/gen-features.c +3 -0
@@ -927,6 +927,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KMC_AES_128 ,S390_FEAT_KMC_AES_192 ,S390_FEAT_KMC_AES_256 , +S390_FEAT_KMCTR_AES_128 , +S390_FEAT_KMCTR_AES_192 , + S390_FEAT_KMCTR_AES_256, };/****** END FEATURE DEFS ******/
target/s390x/tcg/cpacf.h +5 -0
@@ -30,5 +30,10 @@ int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *dst_ptr_reg, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_aes_ctr (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint64_t *ctr_ptr_reg,uint32_t type, +uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +76 -0
79 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +24 -0
@@ -131,6 +131,27 @@ static int cpacf_kmc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return rc; } +static int cpacf_kmctr (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint32_t r1,uint32_t r2,uint32_t r3, +uint8_t fc,uint8_t mod) +{ +int rc =0 ; + +switch (fc) { +case 0x12 :/* CPACF_KMCTR_AES_128 */ +case 0x13 :/* CPACF_KMCTR_AES_192 */ +case 0x14 :/* CPACF_KMCTR_AES_256 */ + rc =cpacf_aes_ctr (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], + &env->regs[r3],S390_FEAT_TYPE_KMCTR , fc, mod); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} +static int cpacf_ppno (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint32_t r1,uint32_t r2,uint32_t r3,uint8_t fc) {
@@ -201,6 +222,9 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,case S390_FEAT_TYPE_KMC : rc =cpacf_kmc (env, mmu_idx, ra, r1, r2, r3, fc, mod);break ; +case S390_FEAT_TYPE_KMCTR : + rc =cpacf_kmctr (env, mmu_idx, ra, r1, r2, r3, fc, mod); +break ;case S390_FEAT_TYPE_PPNO : rc =cpacf_ppno (env, mmu_idx, ra, r1, r2, r3, fc);break ;
Signature · 1 line
2.43.0
Re: [PATCH v8 07/18] target/s390x: Support AES CTR for cpacf kmctr instruction
Quoted 11 lines · Harald Freudenberger
Support the subfunctions
CPACF_KMCTR_AES_128,CPACF_KMCTR_AES_192andCPACF_KMCTR_AES_256for the cpacf kmctr instruction.Signed-off-by Harald Freudenberger <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/gen-features.c | 3 ++ target/s390x/tcg/cpacf.h | 5 +++ target/s390x/tcg/cpacf_aes.c | 76 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++++ 4 files changed, 108 insertions(+)
[...]
Quoted 27 lines
target/s390x/tcg/cpacf_aes.c +21
-0@@ -213,3 +213,79 @@ int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return !len ?0 :3 ; } + +int cpacf_aes_ctr (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint64_t *ctr_ptr_reg,uint32_t type, +uint8_t fc,uint8_t mod) +{ +enum {MAX_BLOCKS_PER_RUN =8192 /AES_BLOCK_SIZE }; +const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); +uint8_t ctr[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ]; +uint64_t addr, len = *src_len_reg, done =0 ; +int i, keysize, addr_reg_size =64 ; +uint8_t key[32 ]; +AES_KEY exkey; + +g_assert (type ==S390_FEAT_TYPE_KMCTR ); + +switch (fc) { +case 0x12 :/* CPACF_KMCTR_AES_128 */ + keysize =16 ;
target/s390x/tcg/cpacf_aes.c int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 246
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c +10
-0+break ; +case 0x13 :/* CPACF_KMCTR_AES_192 */ + keysize =24 ; +break ; +case 0x14 :/* CPACF_KMCTR_AES_256 */ + keysize =32 ; +break ; +default : +g_assert_not_reached (); + }
A general comment; I think I've seen this in previous patches as well. Would it make sense to properly define constants like CPACF_KMCTR_AES_128 and drop comments? Or, if the goal is easier cross-checking with POp, hardcode decimal numbers, since POp specifies them in decimal?
Quoted 23 lines
target/s390x/tcg/cpacf_aes.c +23
-0+ +if (!(env->psw.mask &PSW_MASK_64 )) { + len = (uint32_t )len; + addr_reg_size = (env->psw.mask &PSW_MASK_32 ) ?32 :24 ; + } + +/* length has to be properly aligned. */ +if (!QEMU_IS_ALIGNED (len,AES_BLOCK_SIZE )) { +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +/* fetch key from param block */ +for (i =0 ; i < keysize; i++) { + addr =wrap_address (env, param_addr + i); + key[i] =cpu_ldb_mmu (env, addr, oi, ra); + } + +/* expand key */ +AES_set_encrypt_key (key, keysize *8 , &exkey); + +/* process up to MAX_BLOCKS_PER_RUN aes blocks */ +for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) { +/* read in nonce/ctr => ctr */
target/s390x/tcg/cpacf_aes.c int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 279
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c +10
-0+aes_read_block (env, mmu_idx, *ctr_ptr_reg + done, ctr, ra); +/* encrypt ctr => buf */ +AES_encrypt (ctr, buf, &exkey); +/* read in one block of input data => in */ +aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); +/* xor input data with encrypted ctr => out */ +aes_xor (in, buf, out); +/* write out the processed block */ +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); + len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;
Same comment as in the previous patch.
Otherwise:
[...]
Re: [PATCH v8 07/18] target/s390x: Support AES CTR for cpacf kmctr instruction
Quoted 52 lines · Ilya Leoshkevich
Quoted 12 lines · Harald Freudenberger
Support the subfunctions
CPACF_KMCTR_AES_128,CPACF_KMCTR_AES_192andCPACF_KMCTR_AES_256for the cpacf kmctr instruction.Signed-off-by Harald Freudenberger <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/gen-features.c | 3 ++ target/s390x/tcg/cpacf.h | 5 +++ target/s390x/tcg/cpacf_aes.c | 76 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++++ 4 files changed, 108 insertions(+)[...]
Quoted 36 lines
target/s390x/tcg/cpacf_aes.c +2
-0@@ -213,3 +213,79 @@ int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, return !len ? 0 : 3; } + +int cpacf_aes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_tra,
target/s390x/tcg/cpacf_aes.c +27
-0+ uint64_t param_addr, uint64_t *dst_ptr_reg, + uint64_t *src_ptr_reg, uint64_t *src_len_reg, + uint64_t *ctr_ptr_reg, uint32_t type, + uint8_t fc, uint8_t mod) +{ + enum { MAX_BLOCKS_PER_RUN = 8192 / AES_BLOCK_SIZE }; +const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); +uint8_t ctr[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ]; +uint64_t addr, len = *src_len_reg, done =0 ; +int i, keysize, addr_reg_size =64 ; +uint8_t key[32 ]; +AES_KEY exkey; + +g_assert (type ==S390_FEAT_TYPE_KMCTR ); + +switch (fc) { +case 0x12 :/* CPACF_KMCTR_AES_128 */ + keysize =16 ; +break ; +case 0x13 :/* CPACF_KMCTR_AES_192 */ + keysize =24 ; +break ; +case 0x14 :/* CPACF_KMCTR_AES_256 */ + keysize =32 ; +break ; +default :
Quoted 9 lines
target/s390x/tcg/cpacf_aes.c
Quoted 2 lines
target/s390x/tcg/cpacf_aes.c +2
-0+g_assert_not_reached (); + }A general comment; I think I've seen this in previous patches as well. Would it make sense to properly define constants like
CPACF_KMCTR_AES_128and drop comments? Or, if the goal is easier cross-checking with POp, hardcode decimal numbers, since POp specifies them in decimal?
As I am about to write some tests for all this CPACF support there would be a benefit in having all this as constants or defines in a header file instead of hardcoded values on every switch statement. So I am about to introduce a some cpacf.h with all these values for the next version.
Quoted 43 lines
Quoted 24 lines
target/s390x/tcg/cpacf_aes.c +22
-0+ +if (!(env->psw.mask &PSW_MASK_64 )) { + len = (uint32_t )len; + addr_reg_size = (env->psw.mask &PSW_MASK_32 ) ?32 :24 ; + } + +/* length has to be properly aligned. */ +if (!QEMU_IS_ALIGNED (len,AES_BLOCK_SIZE )) { +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +/* fetch key from param block */ +for (i =0 ; i < keysize; i++) { + addr =wrap_address (env, param_addr + i); + key[i] =cpu_ldb_mmu (env, addr, oi, ra); + } + +/* expand key */ +AES_set_encrypt_key (key, keysize *8 , &exkey); + +/* process up to MAX_BLOCKS_PER_RUN aes blocks */ +for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++){
target/s390x/tcg/cpacf_aes.c +1
-0+/* read in nonce/ctr => ctr */ target/s390x/tcg/cpacf_aes.c int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 279
Quoted 10 lines
target/s390x/tcg/cpacf_aes.c +10
-0+aes_read_block (env, mmu_idx, *ctr_ptr_reg + done, ctr, ra); +/* encrypt ctr => buf */ +AES_encrypt (ctr, buf, &exkey); +/* read in one block of input data => in */ +aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); +/* xor input data with encrypted ctr => out */ +aes_xor (in, buf, out); +/* write out the processed block */ +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); + len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;Same comment as in the previous patch.
Otherwise:
Reviewed-by Ilya Leoshkevich <[email protected]>[...]
Re: [PATCH v8 07/18] target/s390x: Support AES CTR for cpacf kmctr instruction
In reply to Ilya LeoshkevichQuoted 52 lines · Ilya Leoshkevich
Quoted 12 lines · Harald Freudenberger
Support the subfunctions
CPACF_KMCTR_AES_128,CPACF_KMCTR_AES_192andCPACF_KMCTR_AES_256for the cpacf kmctr instruction.Signed-off-by Harald Freudenberger <[email protected]>Reviewed-by Finn Callies <[email protected]>--- target/s390x/gen-features.c | 3 ++ target/s390x/tcg/cpacf.h | 5 +++ target/s390x/tcg/cpacf_aes.c | 76 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 24 ++++++++++ 4 files changed, 108 insertions(+)[...]
Quoted 36 lines
target/s390x/tcg/cpacf_aes.c +2
-0@@ -213,3 +213,79 @@ int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, return !len ? 0 : 3; } + +int cpacf_aes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_tra,
target/s390x/tcg/cpacf_aes.c +27
-0+ uint64_t param_addr, uint64_t *dst_ptr_reg, + uint64_t *src_ptr_reg, uint64_t *src_len_reg, + uint64_t *ctr_ptr_reg, uint32_t type, + uint8_t fc, uint8_t mod) +{ + enum { MAX_BLOCKS_PER_RUN = 8192 / AES_BLOCK_SIZE }; +const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); +uint8_t ctr[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ]; +uint64_t addr, len = *src_len_reg, done =0 ; +int i, keysize, addr_reg_size =64 ; +uint8_t key[32 ]; +AES_KEY exkey; + +g_assert (type ==S390_FEAT_TYPE_KMCTR ); + +switch (fc) { +case 0x12 :/* CPACF_KMCTR_AES_128 */ + keysize =16 ; +break ; +case 0x13 :/* CPACF_KMCTR_AES_192 */ + keysize =24 ; +break ; +case 0x14 :/* CPACF_KMCTR_AES_256 */ + keysize =32 ; +break ; +default :
Quoted 8 lines
target/s390x/tcg/cpacf_aes.c
Quoted 2 lines
target/s390x/tcg/cpacf_aes.c +2
-0+g_assert_not_reached (); + }A general comment; I think I've seen this in previous patches as well. Would it make sense to properly define constants like
CPACF_KMCTR_AES_128and drop comments? Or, if the goal is easier cross-checking with POp, hardcode decimal numbers, since POp specifies them in decimal?
I'll add defines to cpacf.h and remove this hardcoded values here.
Quoted 29 lines
Quoted 29 lines
target/s390x/tcg/cpacf_aes.c +22
-0+ +if (!(env->psw.mask &PSW_MASK_64 )) { + len = (uint32_t )len; + addr_reg_size = (env->psw.mask &PSW_MASK_32 ) ?32 :24 ; + } + +/* length has to be properly aligned. */ +if (!QEMU_IS_ALIGNED (len,AES_BLOCK_SIZE )) { +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +/* fetch key from param block */ +for (i =0 ; i < keysize; i++) { + addr =wrap_address (env, param_addr + i); + key[i] =cpu_ldb_mmu (env, addr, oi, ra); + } + +/* expand key */ +AES_set_encrypt_key (key, keysize *8 , &exkey); + +/* process up to MAX_BLOCKS_PER_RUN aes blocks */ +for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++){
target/s390x/tcg/cpacf_aes.c +5
-0+/* read in nonce/ctr => ctr */ +aes_read_block (env, mmu_idx, *ctr_ptr_reg + done, ctr, ra); +/* encrypt ctr => buf */ +AES_encrypt (ctr, buf, &exkey); +/* read in one block of input data => in */
Quoted 8 lines
target/s390x/tcg/cpacf_aes.c int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, · line 279
Quoted 6 lines
target/s390x/tcg/cpacf_aes.c +6
-0+aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); +/* xor input data with encrypted ctr => out */ +aes_xor (in, buf, out); +/* write out the processed block */ +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); + len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;Same comment as in the previous patch.
Will change this wherever it appears in the series.
Quoted 7 lines
Otherwise:
Reviewed-by Ilya Leoshkevich <[email protected]>[...]
PATCH v8 8/18 target/s390x: Minimal AES XTS support for cpacf pcc instruction
In reply to Harald FreudenbergerSupport CPACF pcc subfunctions PCC-Compute-XTS-Parameter-AES-128 and PCC-Compute-XTS-Parameter-AES-128 but only for the special case block sequential number is 0. However, this covers the s390 AES XTS implementation in the Linux kernel and Libica and thus also Opencryptoki clear key via Libica.
--- target/s390x/gen-features.c | 2 + target/s390x/tcg/cpacf.h | 2 + target/s390x/tcg/cpacf_aes.c | 63 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 20 ++++++++++ 4 files changed, 87 insertions(+)
target/s390x/gen-features.c +2 -0
@@ -930,6 +930,8 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KMCTR_AES_128 ,S390_FEAT_KMCTR_AES_192 ,S390_FEAT_KMCTR_AES_256 , +S390_FEAT_PCC_XTS_AES_128 , + S390_FEAT_PCC_XTS_AES_256, };/****** END FEATURE DEFS ******/
target/s390x/tcg/cpacf.h +2 -0
@@ -35,5 +35,7 @@ int cpacf_aes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint64_t *ctr_ptr_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_aes_pcc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint8_t fc);#endif
target/s390x/tcg/cpacf_aes.c +63 -0
66 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +20 -0
@@ -169,6 +169,23 @@ static int cpacf_ppno(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return rc; } +static int cpacf_pcc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x32 :/* CPACF_PCC compute XTS param AES-128 */ +case 0x34 :/* CPACF PCC compute XTS param AES-256 */ + rc =cpacf_aes_pcc (env, mmu_idx, ra, env->regs[1 ], fc); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} +uint32_t HELPER (msa )(CPUS390XState *env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t type) {
@@ -225,6 +242,9 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,case S390_FEAT_TYPE_KMCTR : rc =cpacf_kmctr (env, mmu_idx, ra, r1, r2, r3, fc, mod);break ; +case S390_FEAT_TYPE_PCC : + rc =cpacf_pcc (env, mmu_idx, ra, fc); +break ;case S390_FEAT_TYPE_PPNO : rc =cpacf_ppno (env, mmu_idx, ra, r1, r2, r3, fc);break ;
Signature · 1 line
2.43.0
PATCH v8 9/18 target/s390x: Support AES XTS for cpacf km instruction
In reply to Harald FreudenbergerSupport the subfunctions XTS-AES-128 and XTS-AES-256 for the cpacf km instruction.
--- target/s390x/gen-features.c | 2 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 107 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 6 ++ 4 files changed, 119 insertions(+)
target/s390x/gen-features.c +2 -0
@@ -924,6 +924,8 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KM_AES_128 ,S390_FEAT_KM_AES_192 ,S390_FEAT_KM_AES_256 , +S390_FEAT_KM_XTS_AES_128 , +S390_FEAT_KM_XTS_AES_256 ,S390_FEAT_KMC_AES_128 ,S390_FEAT_KMC_AES_192 , S390_FEAT_KMC_AES_256,
target/s390x/tcg/cpacf.h +4 -0
@@ -37,5 +37,9 @@ int cpacf_aes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint8_t fc, uint8_t mod);int cpacf_aes_pcc (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint64_t param_addr,uint8_t fc); +int cpacf_aes_xts (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +107 -0
110 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +6 -0
@@ -103,6 +103,12 @@ static int cpacf_km(CPUS390XState *env, const int mmu_idx, uintptr_t ra, &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], S390_FEAT_TYPE_KM, fc, mod);break ; +case 0x32 :/* CPACF_KM_XTS_128 */ +case 0x34 :/* CPACF_KM_XTS_256 */ + rc =cpacf_aes_xts (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], +S390_FEAT_TYPE_KM , fc, mod); +break ;default :tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); }
Signature · 1 line
2.43.0
PATCH v8 10/18 target/s390x: Support pckmo encrypt AES subfunctions
In reply to Harald FreudenbergerSupport the subfuctions PCKMO-Encrypt-AES-128-Key, PCKMO-Encrypt-AES-192-Key and PCKMO-Encrypt-AES-256-Key.
These subfunctions derive a protected key from an AES clear key by encrypting it with an internal AES wrapping key. More details can be found in the "z/Architecture Prinziples of Operation" document.
The qemu version provided here is only a fake intended to make protected key available for developing and testing purpose:
* The protected key is 'derived' from the clear key by xoring the fixed pattern 0xAAAA... onto the key value.
* The AES Wrapping Key Verification Pattern is a fixed value of 32 bytes 0xFACEFACE...
--- target/s390x/gen-features.c | 3 ++ target/s390x/tcg/cpacf.h | 2 + target/s390x/tcg/cpacf_aes.c | 66 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 21 ++++++++++ target/s390x/tcg/translate.c | 9 ++++- 5 files changed, 99 insertions(+), 2 deletions(-)
target/s390x/gen-features.c +3 -0
@@ -934,6 +934,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KMCTR_AES_256 ,S390_FEAT_PCC_XTS_AES_128 ,S390_FEAT_PCC_XTS_AES_256 , +S390_FEAT_PCKMO_AES_128 , +S390_FEAT_PCKMO_AES_192 , + S390_FEAT_PCKMO_AES_256, };/****** END FEATURE DEFS ******/
target/s390x/tcg/cpacf.h +2 -0
@@ -41,5 +41,7 @@ int cpacf_aes_xts(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *dst_ptr_reg, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_aes_pckmo (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint8_t fc);#endif
target/s390x/tcg/cpacf_aes.c +66 -0
69 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +21 -0
@@ -192,6 +192,24 @@ static int cpacf_pcc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return rc; } +static int cpacf_pckmo (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint8_t fc) +{ +int rc =0 ; + +switch (fc) { +case 0x12 :/* CPACF_PCKMO_ENC_AES_128_KEY */ +case 0x13 :/* CPACF_PCKMO_ENC_AES_192_KEY */ +case 0x14 :/* CPACF_PCKMO_ENC_AES_256_KEY */ + rc =cpacf_aes_pckmo (env, mmu_idx, ra, env->regs[1 ], fc); +break ; +default : +tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); + } + +return rc; +} +uint32_t HELPER (msa )(CPUS390XState *env,uint32_t r1,uint32_t r2,uint32_t r3,uint32_t type) {
@@ -251,6 +269,9 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,case S390_FEAT_TYPE_PCC : rc =cpacf_pcc (env, mmu_idx, ra, fc);break ; +case S390_FEAT_TYPE_PCKMO : + rc =cpacf_pckmo (env, mmu_idx, ra, fc); +break ;case S390_FEAT_TYPE_PPNO : rc =cpacf_ppno (env, mmu_idx, ra, r1, r2, r3, fc);break ;
target/s390x/tcg/translate.c +7 -2
@@ -2558,6 +2558,7 @@ static DisasJumpType op_msa(DisasContext *s, DisasOps *o)int r2 =have_field (s, r2) ?get_field (s, r2) :0 ;int r3 =have_field (s, r3) ?get_field (s, r3) :0 ;TCGv_i32 t_r1, t_r2, t_r3, type; +bool update_cc = true;switch (s->insn->data) {case S390_FEAT_TYPE_KMA :
@@ -2589,8 +2590,10 @@ static DisasJumpType op_msa(DisasContext *s, DisasOps *o)gen_program_exception (s,PGM_SPECIFICATION );return DISAS_NORETURN ; } -/* FALL THROUGH */ +break ;case S390_FEAT_TYPE_PCKMO : + update_cc = false; +/* FALL THROUGH */ case S390_FEAT_TYPE_PCC :case S390_FEAT_TYPE_KDSA :break ;
@@ -2603,7 +2606,9 @@ static DisasJumpType op_msa(DisasContext *s, DisasOps *o) t_r3 =tcg_constant_i32 (r3); type =tcg_constant_i32 (s->insn->data);gen_helper_msa (cc_op, tcg_env, t_r1, t_r2, t_r3, type); -set_cc_static (s); +if (update_cc) { +set_cc_static (s); + }return DISAS_NEXT ; }
Signature · 1 line
2.43.0
PATCH v8 11/18 target/s390x: Support protected key AES ECB for cpacf km instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KM_PAES_128, CPACF_KM_PAES_192 and CPACF_KM_PAES_256 for the cpacf km instruction.
--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 113 +++++++++++++++++++++++++++++-- target/s390x/tcg/crypto_helper.c | 7 ++ 4 files changed, 123 insertions(+), 4 deletions(-)
target/s390x/gen-features.c +3 -0
@@ -924,6 +924,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KM_AES_128 ,S390_FEAT_KM_AES_192 ,S390_FEAT_KM_AES_256 , +S390_FEAT_KM_EAES_128 , +S390_FEAT_KM_EAES_192 , +S390_FEAT_KM_EAES_256 ,S390_FEAT_KM_XTS_AES_128 ,S390_FEAT_KM_XTS_AES_256 , S390_FEAT_KMC_AES_128,
target/s390x/tcg/cpacf.h +4 -0
@@ -43,5 +43,9 @@ int cpacf_aes_xts(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint32_t type, uint8_t fc, uint8_t mod);int cpacf_aes_pckmo (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint64_t param_addr,uint8_t fc); +int cpacf_paes_ecb (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +109 -4
128 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +7 -0
@@ -103,6 +103,13 @@ static int cpacf_km(CPUS390XState *env, const int mmu_idx, uintptr_t ra, &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], S390_FEAT_TYPE_KM, fc, mod);break ; +case 0x1a :/* CPACF_KM_PAES_128 */ +case 0x1b :/* CPACF_KM_PAES_192 */ +case 0x1c :/* CPACF_KM_PAES_256 */ + rc =cpacf_paes_ecb (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], +S390_FEAT_TYPE_KM , fc, mod); +break ;case 0x32 :/* CPACF_KM_XTS_128 */ case 0x34 :/* CPACF_KM_XTS_256 */ rc = cpacf_aes_xts(env, mmu_idx, ra, env->regs[1],
Signature · 1 line
2.43.0
PATCH v8 12/18 target/s390x: Support protected key AES CBC for cpacf kmc instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KMC_PAES_128, CPACF_KMC_PAES_192 and CPACF_KMC_PAES_256 for the cpacf kmc instruction.
--- target/s390x/gen-features.c | 3 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 107 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 7 ++ 4 files changed, 121 insertions(+)
target/s390x/gen-features.c +3 -0
@@ -932,6 +932,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KMC_AES_128 ,S390_FEAT_KMC_AES_192 ,S390_FEAT_KMC_AES_256 , +S390_FEAT_KMC_EAES_128 , +S390_FEAT_KMC_EAES_192 , +S390_FEAT_KMC_EAES_256 ,S390_FEAT_KMCTR_AES_128 ,S390_FEAT_KMCTR_AES_192 , S390_FEAT_KMCTR_AES_256,
target/s390x/tcg/cpacf.h +4 -0
@@ -47,5 +47,9 @@ int cpacf_paes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *dst_ptr_reg, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_paes_cbc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +107 -0
110 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +7 -0
@@ -137,6 +137,13 @@ static int cpacf_kmc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], S390_FEAT_TYPE_KMC, fc, mod);break ; +case 0x1a :/* CPACF_KMC_PAES_128 */ +case 0x1b :/* CPACF_KMC_PAES_192 */ +case 0x1c :/* CPACF_KMC_PAES_256 */ + rc =cpacf_paes_cbc (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], +S390_FEAT_TYPE_KMC , fc, mod); +break ;default :tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); }
Signature · 1 line
2.43.0
PATCH v8 13/18 target/s390x: Support protected key AES CTR for cpacf kmctr instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KMCTR_PAES_128, CPACF_KMCTR_PAES_192 and CPACF_KMCTR_PAES_256 for the cpacf kmctr instruction.
--- target/s390x/gen-features.c | 3 ++ target/s390x/tcg/cpacf.h | 5 ++ target/s390x/tcg/cpacf_aes.c | 88 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 7 +++ 4 files changed, 103 insertions(+)
target/s390x/gen-features.c +3 -0
@@ -938,6 +938,9 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KMCTR_AES_128 ,S390_FEAT_KMCTR_AES_192 ,S390_FEAT_KMCTR_AES_256 , +S390_FEAT_KMCTR_EAES_128 , +S390_FEAT_KMCTR_EAES_192 , +S390_FEAT_KMCTR_EAES_256 ,S390_FEAT_PCC_XTS_AES_128 ,S390_FEAT_PCC_XTS_AES_256 , S390_FEAT_PCKMO_AES_128,
target/s390x/tcg/cpacf.h +5 -0
@@ -51,5 +51,10 @@ int cpacf_paes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t param_addr, uint64_t *dst_ptr_reg, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_paes_ctr (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint64_t *ctr_ptr_reg,uint32_t type, +uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +88 -0
91 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +7 -0
@@ -165,6 +165,13 @@ static int cpacf_kmctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], &env->regs[r3], S390_FEAT_TYPE_KMCTR, fc, mod);break ; +case 0x1a :/* CPACF_KMCTR_PAES_128 */ +case 0x1b :/* CPACF_KMCTR_PAES_192 */ +case 0x1c :/* CPACF_KMCTR_PAES_256 */ + rc =cpacf_paes_ctr (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], + &env->regs[r3],S390_FEAT_TYPE_KMCTR , fc, mod); +break ;default :tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); }
Signature · 1 line
2.43.0
PATCH v8 14/18 target/s390x: Minimal protected key AES XTS support for cpacf pcc instruction
In reply to Harald FreudenbergerSupport CPACF pcc subfunctions PCC-Compute-XTS-Parameter-Encrypted-AES-128 and PCC-Compute-XTS-Parameter-Encrypted-AES-128 but only for the special case block sequential number is 0. However, this covers the s390 PAES XTS implementation in the Linux kernel.
--- target/s390x/gen-features.c | 2 + target/s390x/tcg/cpacf.h | 2 + target/s390x/tcg/cpacf_aes.c | 77 ++++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 4 ++ 4 files changed, 85 insertions(+)
target/s390x/gen-features.c +2 -0
@@ -943,6 +943,8 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KMCTR_EAES_256 ,S390_FEAT_PCC_XTS_AES_128 ,S390_FEAT_PCC_XTS_AES_256 , +S390_FEAT_PCC_XTS_EAES_128 , +S390_FEAT_PCC_XTS_EAES_256 ,S390_FEAT_PCKMO_AES_128 ,S390_FEAT_PCKMO_AES_192 , S390_FEAT_PCKMO_AES_256,
target/s390x/tcg/cpacf.h +2 -0
@@ -56,5 +56,7 @@ int cpacf_paes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint64_t *src_ptr_reg, uint64_t *src_len_reg, uint64_t *ctr_ptr_reg, uint32_t type, uint8_t fc, uint8_t mod); +int cpacf_paes_pcc (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint8_t fc);#endif
target/s390x/tcg/cpacf_aes.c +77 -0
80 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +4 -0
@@ -206,6 +206,10 @@ static int cpacf_pcc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,case 0x34 :/* CPACF PCC compute XTS param AES-256 */ rc =cpacf_aes_pcc (env, mmu_idx, ra, env->regs[1 ], fc);break ; +case 0x3a :/* CPACF_PCC compute XTS param Encrypted AES-128 */ +case 0x3c :/* CPACF PCC compute XTS param Encrypted AES-256 */ + rc =cpacf_paes_pcc (env, mmu_idx, ra, env->regs[1 ], fc); +break ;default :tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); }
Signature · 1 line
2.43.0
PATCH v8 15/18 target/s390x: Support protected key AES XTS for cpacf km instruction
In reply to Harald FreudenbergerSupport the subfunctions CPACF_KM_PXTS_128 and CPACF_KM_PXTS_256 for the cpacf km instruction.
--- target/s390x/gen-features.c | 2 + target/s390x/tcg/cpacf.h | 4 ++ target/s390x/tcg/cpacf_aes.c | 104 +++++++++++++++++++++++++++++++ target/s390x/tcg/crypto_helper.c | 6 ++ 4 files changed, 116 insertions(+)
target/s390x/gen-features.c +2 -0
@@ -929,6 +929,8 @@ static uint16_t qemu_MAX[] = {S390_FEAT_KM_EAES_256 ,S390_FEAT_KM_XTS_AES_128 ,S390_FEAT_KM_XTS_AES_256 , +S390_FEAT_KM_XTS_EAES_128 , +S390_FEAT_KM_XTS_EAES_256 ,S390_FEAT_KMC_AES_128 ,S390_FEAT_KMC_AES_192 , S390_FEAT_KMC_AES_256,
target/s390x/tcg/cpacf.h +4 -0
@@ -58,5 +58,9 @@ int cpacf_paes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint8_t fc, uint8_t mod);int cpacf_paes_pcc (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint64_t param_addr,uint8_t fc); +int cpacf_paes_xts (CPUS390XState *env,const int mmu_idx,uintptr_t ra, +uint64_t param_addr,uint64_t *dst_ptr_reg, +uint64_t *src_ptr_reg,uint64_t *src_len_reg, +uint32_t type,uint8_t fc,uint8_t mod);#endif
target/s390x/tcg/cpacf_aes.c +104 -0
107 lines not on this page · raw message
target/s390x/tcg/crypto_helper.c +6 -0
@@ -116,6 +116,12 @@ static int cpacf_km(CPUS390XState *env, const int mmu_idx, uintptr_t ra, &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], S390_FEAT_TYPE_KM, fc, mod);break ; +case 0x3a :/* CPACF_KM_PXTS_128 */ +case 0x3c :/* CPACF_KM_PXTS_256 */ + rc =cpacf_paes_xts (env, mmu_idx, ra, env->regs[1 ], + &env->regs[r1], &env->regs[r2], &env->regs[r2 +1 ], +S390_FEAT_TYPE_KM , fc, mod); +break ;default :tcg_s390_program_interrupt (env,PGM_SPECIFICATION , ra); }
Signature · 1 line
2.43.0
PATCH v8 16/18 docs/s390: Document CPACF instructions support
In reply to Harald FreudenbergerAdd a first document covering the Qemu s390 CPACF instructions and functions supported.
--- docs/system/s390x/cpacf.rst | 144 +++++++++++++++++++++++++++++++++++ docs/system/target-s390x.rst | 1 + 2 files changed, 145 insertions(+) create mode 100644 docs/system/s390x/cpacf.rst
docs/system/s390x/cpacf.rst new file +144 -0
@@ -0,0 +1,144 @@ +CPACF Support +============= + +CPACF +----- + +CP Assist for Cryptographic Function (CPACF) is a hardware-integrated +coprocessor feature built into every processor core of IBM Z and +LinuxONE mainframes (s390x architecture). It provides high-speed, +hardware-accelerated encryption and hashing directly on the CPU. + +CPACF provides a set of z/Architecture instructions (known as Message +Security Assist or MSA) that execute cryptographic operations +synchronously with the main processor. + +- Symmetric Encryption: Support for AES (128, 192, 256-bit), DES, and + Triple-DES (TDES). +- Hashing: Acceleration for SHA-1, SHA-2 (up to SHA-512), SHA-3 and + SHAKE. +- Random Number Generation: Pseudo Random Number Generator (PRNG) and + a hardware-based True Random Number Generator (TRNG). +- Asymmetric Support: Elliptic Curve Cryptography (ECC) primitives + P-256, P-384, P-521, Montgomery/Edwards curves (e.g., Ed25519). + +Documentation about CPACF instructions is publicly available and +can be found in the "z/Architecture Principles of Operation" +accessible at the IBM documentation hub https://www.ibm.com/docs/en. +For example the latest version as a pdf is available here: +https://www.ibm.com/support/pages/zvm/library/other/22783214.pdf + + +CPACF instructions +------------------ + +Here is a list of implemented CPACF instructions and the supported +functions for each instruction: + +KDSA (COMPUTE DIGITAL SIGNATURE AUTHENTICATION) +- Function code 0x00 - Function Query + +KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) +- Function code 0x00 - Function Query +- Function code 0x02 - CPACF_KIMD_SHA_256 +- Function code 0x03 - CPACF_KIMD_SHA_512 + +KLMD (COMPUTE LAST MESSAGE DIGEST) +- Function code 0x00 - Function Query +- Function code 0x02 - CPACF_KLMD_SHA_256 +- Function code 0x03 - CPACF_KLMD_SHA_512 + +KM (CIPHER MESSAGE) +- Function code 0x00 - Function Query +- Function code 0x12 - CPACF_KM_AES_128 +- Function code 0x13 - CPACF_KM_AES_192 +- Function code 0x14 - CPACF_KM_AES_256 +- Function code 0x1a - CPACF_KM_PAES_128 +- Function code 0x1b - CPACF_KM_PAES_192 +- Function code 0x1c - CPACF_KM_PAES_256 +- Function code 0x32 - CPACF_KM_XTS_128 +- Function code 0x34 - CPACF_KM_XTS_256 +- Function code 0x3a - CPACF_KM_PXTS_128 +- Function code 0x3c - CPACF_KM_PXTS_256 + +KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) +- Function code 0x00 - Function Query + +KMC (CIPHER MESSAGE WITH CHAINING) +- Function code 0x00 - Function Query +- Function code 0x12 - CPACF_KMC_AES_128 +- Function code 0x13 - CPACF_KMC_AES_192 +- Function code 0x14 - CPACF_KMC_AES_256 +- Function code 0x1a - CPACF_KMC_PAES_128 +- Function code 0x1b - CPACF_KMC_PAES_192 +- Function code 0x1c - CPACF_KMC_PAES_256 + +KMCTR (CIPHER MESSAGE WITH COUNTER) +- Function code 0x00 - Function Query +- Function code 0x12 - CPACF_KMCTR_AES_128 +- Function code 0x13 - CPACF_KMCTR_AES_192 +- Function code 0x14 - CPACF_KMCTR_AES_256 +- Function code 0x1a - CPACF_KMCTR_PAES_128 +- Function code 0x1b - CPACF_KMCTR_PAES_192 +- Function code 0x1c - CPACF_KMCTR_PAES_256 + +KMF (CIPHER MESSAGE WITH CIPHER FEEDBACK) +- not supported + +KMO (CIPHER MESSAGE WITH OUTPUT FEEDBACK) +- not supported + +PCC (PERFORM CRYPTOGRAPHIC COMPUTATION) +- Function code 0x00 - Function Query +- Function code 0x32 - compute XTS param AES-128 +- Function code 0x34 - compute XTS param AES-256 +- Function code 0x3a - compute XTS param Encrypted AES-128 +- Function code 0x3c - compute XTS param Encrypted AES-256 + +PCKMO (PERFORM CRYPTOGRAPHIC KEY MANAGEMENT OPERATION) +- Function code 0x00 - Function Query +- Function code 0x12 - CPACF_PCKMO_ENC_AES_128_KEY +- Function code 0x13 - CPACF_PCKMO_ENC_AES_192_KEY +- Function code 0x14 - CPACF_PCKMO_ENC_AES_256_KEY + +PRNO (PERFORM RANDOM NUMBER OPERATION) +- Function code 0x00 - Function Query +- Function code 0x72 - CPACF_PRNO_TRNG + +Note that the use of a not supported CPACF instruction (KMF and KMO) +or invocation of a not listed function will result in a Specification +Exception. + +Not listed CPACF instructions (KMA, KMF, KMO) cause an Operation +Exception when used. Not listed functions cause a Specification +Exception when called. If only the query function is listed (KDSA), +then the query function will return a function status word with all +but the query function bit set to 0. + + +Protected key support +--------------------- + +The qemu version for protected key support is only a fake provided +here for developing and testing purpose: + +- The protected key is _derived_ from the clear key by xoring the + fixed pattern 0xAAAA... onto the key value. +- The AES Wrapping Key Verification Pattern is a fixed value of 32 + bytes 0xFACEFACE... + +The PCKMO instruction implementation does exactly this - _derive_ a +_protected_ key from the clear key given by xor 0xAAAA... and writing +the fixed value for the WKVP of 0xFACEFACE into the blob. +The other subfunctions of the CPACF instructions dealing with +protected key treat the protected key blob by first checking for the +WKVP (against the fixed value of 0xFACEFACE...) and second +_decrypting_ the key value by xoring 0xAAAA... and then execute the +clear key operation with the decrypted key value. +This is suitable for testing purpose but such keys are not for real +production load and would open up a huge security breach! + +For more details about protected keys see the "z/Architecture +Principles of Operation" document chapter "General Instructions" +sub-chapter "Protection of Cryptographic Keys" and again the +implementation here does NOT implement what is explained there.
docs/system/target-s390x.rst +1 -0
@@ -35,3 +35,4 @@ Architectural features s390x/bootdevices s390x/protvirt s390x/cpu-topology + s390x/cpacf
Signature · 1 line
2.43.0
PATCH v8 17/18 crypto: Add aes-helpers file to support some AES modes
In reply to Harald FreudenbergerAdd a new file crypto/aes-helpers.c with simple functions to support some AES modes:
- AES cbc: AES_cbc_encrypt() AES_cbc_decrypt()
- AES ctr: AES_ctr_encrypt()
- AES xts: AES_xts_encrypt() AES_xts_decrypt() and some AES related helpers:
- AES_xor()
- AES_xts_prep_next_tweak()
--- crypto/aes-helpers.c | 106 +++++++++++++++++++++++++++++++++++++++++++ crypto/meson.build | 1 + include/crypto/aes.h | 14 ++++++ 3 files changed, 121 insertions(+) create mode 100644 crypto/aes-helpers.c
crypto/aes-helpers.c new file +106 -0
@@ -0,0 +1,106 @@ +/* +* AES helper functions and mode implementations +* +* Authors: +* Harald Freudenberger <[email protected]> +* +* This work is licensed under the terms of the GNU GPL, version 2 or later. +* See the COPYING file in the top-level directory. +*/ + +#include <stdint.h> +#include <string.h> +#include "crypto/aes.h" + +void AES_xor (const unsigned char *src1,const unsigned char *src2, +unsigned char *dst) +{ +int i; + +for (i =0 ; i <AES_BLOCK_SIZE ; i++) { + dst[i] = src1[i] ^ src2[i]; + } +} + +void AES_cbc_encrypt (const unsigned char *in,unsigned char *out, +unsigned char *iv,const AES_KEY *key) +{ +unsigned char buf[AES_BLOCK_SIZE ]; + +/* in xor iv => buf */ +AES_xor (in, iv, buf); +/* encrypt buf => out */ +AES_encrypt (buf, out, key); +/* prep iv for next round */ +memcpy (iv, out,AES_BLOCK_SIZE ); +} + +void AES_cbc_decrypt (const unsigned char *in,unsigned char *out, +unsigned char *iv,const AES_KEY *key) +{ +unsigned char buf[AES_BLOCK_SIZE ]; + +/* decrypt in => buf */ +AES_decrypt (in, buf, key); +/* buf xor iv => out */ +AES_xor (buf, iv, out); +/* prep iv for next round */ +memcpy (iv, in,AES_BLOCK_SIZE ); +} + +void AES_ctr_encrypt (const unsigned char *in,unsigned char *out, +const unsigned char *ctr,const AES_KEY *key) +{ +unsigned char buf[AES_BLOCK_SIZE ]; + +/* encrypt ctr => buf */ +AES_encrypt (ctr, buf, key); +/* exor input data with encrypted ctr => out */ +AES_xor (in, buf, out); +} + +/* Tweak calculation for AES XTS. +* Multiply tweak by α (x) in GF(2^128) per IEEE 1619-2007. The tweak +* is a 128-bit little-endian integer (tweak[0]=LSB, tweak[15]=MSB). +* This implementation has been verified on litte and big endian. +*/ +void AES_xts_prep_next_tweak (unsigned char *tweak) +{ +unsigned char carry; +int i; + + carry = tweak[AES_BLOCK_SIZE -1 ] >>7 ; + +for (i =AES_BLOCK_SIZE -1 ; i >0 ; i--) { + tweak[i] = (unsigned char )((tweak[i] <<1 ) | (tweak[i -1 ] >>7 )); + } + + tweak[i] = (unsigned char )(tweak[i] <<1 ); + tweak[i] ^= (unsigned char )(0x87 & (unsigned char )(-(unsigned char )carry)); +} + +void AES_xts_encrypt (const unsigned char *in,unsigned char *out, +const unsigned char *tweak,const AES_KEY *key) +{ +unsigned char buf1[AES_BLOCK_SIZE ], buf2[AES_BLOCK_SIZE ]; + +/* in xor tweak => buf1 */ +AES_xor (in, tweak, buf1); +/* encrypt buf1 => buf2 */ +AES_encrypt (buf1, buf2, key); +/* buf2 xor tweak => out */ +AES_xor (buf2, tweak, out); +} + +void AES_xts_decrypt (const unsigned char *in,unsigned char *out, +const unsigned char *tweak,const AES_KEY *key) +{ +unsigned char buf1[AES_BLOCK_SIZE ], buf2[AES_BLOCK_SIZE ]; + +/* in xor tweak => buf1 */ +AES_xor (in, tweak, buf1); +/* encrypt buf1 => buf2 */ +AES_decrypt (buf1, buf2, key); +/* buf2 xor tweak => out */ +AES_xor (buf2, tweak, out); +}
crypto/meson.build +1 -0
@@ -55,6 +55,7 @@ system_ss.add(when: gnutls, if_true: files('tls-cipher-suites.c')) util_ss.add(files( 'aes.c', + 'aes-helpers.c', 'clmul.c', 'init.c', 'sm4.c',
include/crypto/aes.h +14 -0
@@ -37,4 +37,18 @@ AES_Td0[x] = Si[x].[0e, 09, 0d, 0b];extern const uint32_t AES_Te0[256 ], AES_Td0[256 ]; +void AES_xor (const unsigned char *src1,const unsigned char *src2, +unsigned char *dst); +void AES_cbc_encrypt (const unsigned char *in,unsigned char *out, +unsigned char *iv,const AES_KEY *key); +void AES_cbc_decrypt (const unsigned char *in,unsigned char *out, +unsigned char *iv,const AES_KEY *key); +void AES_ctr_encrypt (const unsigned char *in,unsigned char *out, +const unsigned char *ctr,const AES_KEY *key); +void AES_xts_prep_next_tweak (unsigned char *tweak); +void AES_xts_encrypt (const unsigned char *in,unsigned char *out, +const unsigned char *tweak,const AES_KEY *key); +void AES_xts_decrypt (const unsigned char *in,unsigned char *out, +const unsigned char *tweak,const AES_KEY *key); +#endif
Signature · 1 line
2.43.0
PATCH v8 18/18 target/s390x: Use generic AES helper functions
In reply to Harald FreudenbergerRewrite the cpacf implementations to use the generic AES helper functions from crypto/aes-helpers.c
--- target/s390x/tcg/cpacf_aes.c | 124 ++++++++++------------------------- 1 file changed, 36 insertions(+), 88 deletions(-)
target/s390x/tcg/cpacf_aes.c +36 -88
@@ -112,20 +112,13 @@ int cpacf_aes_ecb(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return !len ?0 :3 ; } -static void aes_xor (const uint8_t *src1,const uint8_t *src2,uint8_t *dst) -{ -for (int i =0 ; i <AES_BLOCK_SIZE ; i++) { - dst[i] = src1[i] ^ src2[i]; - } -} -int cpacf_aes_cbc (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint64_t param_addr,uint64_t *dst_ptr_reg,uint64_t *src_ptr_reg,uint64_t *src_len_reg,uint32_t type,uint8_t fc,uint8_t mod) {enum {MAX_BLOCKS_PER_RUN =8192 /AES_BLOCK_SIZE }; -uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ];const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx);uint64_t addr, len = *src_len_reg, done =0 ;int i, keysize, addr_reg_size =64 ;
@@ -181,19 +174,11 @@ int cpacf_aes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) {aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra);if (mod) { -/* decrypt in => buf */ -AES_decrypt (in, buf, &exkey); -/* buf xor iv => out */ -aes_xor (buf, iv, out); -/* prep iv for next round */ -memcpy (iv, in,AES_BLOCK_SIZE ); +/* decrypt in => out */ +AES_cbc_decrypt (in, out, iv, &exkey); }else { -/* in xor iv => buf */ -aes_xor (in, iv, buf); -/* encrypt buf => out */ -AES_encrypt (buf, out, &exkey); -/* prep iv for next round */ -memcpy (iv, out,AES_BLOCK_SIZE ); +/* encrypt in => out */ +AES_cbc_encrypt (in, out, iv, &exkey); }aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;
@@ -222,11 +207,10 @@ int cpacf_aes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, {enum {MAX_BLOCKS_PER_RUN =8192 /AES_BLOCK_SIZE };const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); -uint8_t ctr[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ];uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ];uint64_t addr, len = *src_len_reg, done =0 ; +uint8_t ctr[AES_BLOCK_SIZE ], key[32 ];int i, keysize, addr_reg_size =64 ; -uint8_t key[32 ];AES_KEY exkey;g_assert (type ==S390_FEAT_TYPE_KMCTR );
@@ -268,12 +252,10 @@ int cpacf_aes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra,for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) {/* read in nonce/ctr => ctr */ aes_read_block (env, mmu_idx, *ctr_ptr_reg + done, ctr, ra); -/* encrypt ctr => buf */ -AES_encrypt (ctr, buf, &exkey);/* read in one block of input data => in */ aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); -/* xor input data with encrypted ctr => out */ -aes_xor (in, buf, out); +/* encrypt ctr and xor with in => out */ +AES_ctr_encrypt (in, out, ctr, &exkey);/* write out the processed block */ aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;
@@ -353,28 +335,13 @@ int cpacf_aes_pcc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,return 0 ; } -static void aes_xts_prep_next_tweak (uint8_t tweak[AES_BLOCK_SIZE ]) -{ -uint8_t carry; -int i; - - carry = tweak[AES_BLOCK_SIZE -1 ] >>7 ; - -for (i =AES_BLOCK_SIZE -1 ; i >0 ; i--) { - tweak[i] = (uint8_t )((tweak[i] <<1 ) | (tweak[i -1 ] >>7 )); - } - - tweak[i] = (uint8_t )(tweak[i] <<1 ); - tweak[i] ^= (uint8_t )(0x87 & (uint8_t )(-(int8_t )carry)); -} -int cpacf_aes_xts (CPUS390XState *env,const int mmu_idx,uintptr_t ra,uint64_t param_addr,uint64_t *dst_ptr_reg,uint64_t *src_ptr_reg,uint64_t *src_len_reg,uint32_t type,uint8_t fc,uint8_t mod) {enum {MAX_BLOCKS_PER_RUN =8192 /AES_BLOCK_SIZE }; -uint8_t buf1[AES_BLOCK_SIZE ], buf2[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ];const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx);uint64_t addr, len = *src_len_reg, done =0 ;uint8_t key[32 ], tweak[AES_BLOCK_SIZE ];
@@ -425,23 +392,19 @@ int cpacf_aes_xts(CPUS390XState *env, const int mmu_idx, uintptr_t ra,/* process up to MAX_BLOCKS_PER_RUN aes blocks */ for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) { -/* fetch one AES block into buf1 */ -aes_read_block (env, mmu_idx, *src_ptr_reg + done, buf1, ra); -/* buf1 xor tweak => buf2 */ -aes_xor (buf1, tweak, buf2); +/* fetch one AES block into in */ +aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra);if (mod) { -/* decrypt buf2 => buf1 */ -AES_decrypt (buf2, buf1, &exkey); +/* decrypt in => out */ +AES_xts_decrypt (in, out, tweak, &exkey); }else { -/* encrypt buf2 => buf1 */ -AES_encrypt (buf2, buf1, &exkey); +/* encrypt in => out */ +AES_xts_encrypt (in, out, tweak, &exkey); } -/* buf1 xor tweak => buf2 */ -aes_xor (buf1, tweak, buf2);/* prep tweak for next round */ -aes_xts_prep_next_tweak (tweak); -/* write out this processed block from buf2 */ -aes_write_block (env, mmu_idx, *dst_ptr_reg + done, buf2, ra); +AES_xts_prep_next_tweak (tweak); +/* write out this processed block from out */ +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ; }
@@ -637,7 +600,7 @@ int cpacf_paes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint32_t type, uint8_t fc, uint8_t mod) { enum { MAX_BLOCKS_PER_RUN = 8192 / AES_BLOCK_SIZE }; -uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ];const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx);uint8_t key[32 ], wkvp[32 ], iv[AES_BLOCK_SIZE ];uint64_t addr, len = *src_len_reg, done =0 ;
@@ -705,19 +668,11 @@ int cpacf_paes_cbc(CPUS390XState *env, const int mmu_idx, uintptr_t ra,for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) {aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra);if (mod) { -/* decrypt in => buf */ -AES_decrypt (in, buf, &exkey); -/* buf xor iv => out */ -aes_xor (buf, iv, out); -/* prep iv for next round */ -memcpy (iv, in,AES_BLOCK_SIZE ); +/* decrypt in => out */ +AES_cbc_decrypt (in, out, iv, &exkey); }else { -/* in xor iv => buf */ -aes_xor (in, iv, buf); -/* encrypt buf => out */ -AES_encrypt (buf, out, &exkey); -/* prep iv for next round */ -memcpy (iv, out,AES_BLOCK_SIZE ); +/* encrypt in => out */ +AES_cbc_encrypt (in, out, iv, &exkey); }aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;
@@ -746,11 +701,10 @@ int cpacf_paes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra, {enum {MAX_BLOCKS_PER_RUN =8192 /AES_BLOCK_SIZE };const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx); -uint8_t ctr[AES_BLOCK_SIZE ], buf[AES_BLOCK_SIZE ];uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ]; +uint8_t ctr[AES_BLOCK_SIZE ], key[32 ], wkvp[32 ];uint64_t addr, len = *src_len_reg, done =0 ;int i, keysize, addr_reg_size =64 ; -uint8_t key[32 ], wkvp[32 ];AES_KEY exkey;g_assert (type ==S390_FEAT_TYPE_KMCTR );
@@ -804,12 +758,10 @@ int cpacf_paes_ctr(CPUS390XState *env, const int mmu_idx, uintptr_t ra,for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) {/* read in nonce/ctr => ctr */ aes_read_block (env, mmu_idx, *ctr_ptr_reg + done, ctr, ra); -/* encrypt ctr => buf */ -AES_encrypt (ctr, buf, &exkey);/* read in one block of input data => in */ aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra); -/* exor input data with encrypted ctr => out */ -aes_xor (in, buf, out); +/* encrypt ctr and xor with in => out */ +AES_ctr_encrypt (in, out, ctr, &exkey);/* write out the processed block */ aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ;
@@ -909,7 +861,7 @@ int cpacf_paes_xts(CPUS390XState *env, const int mmu_idx, uintptr_t ra, uint32_t type, uint8_t fc, uint8_t mod) { enum { MAX_BLOCKS_PER_RUN = 8192 / AES_BLOCK_SIZE }; -uint8_t buf1[AES_BLOCK_SIZE ], buf2[AES_BLOCK_SIZE ]; +uint8_t in[AES_BLOCK_SIZE ], out[AES_BLOCK_SIZE ];const MemOpIdx oi =make_memop_idx (MO_8 , mmu_idx);uint8_t key[32 ], wkvp[32 ], tweak[AES_BLOCK_SIZE ];uint64_t addr, len = *src_len_reg, done =0 ;
@@ -972,23 +924,19 @@ int cpacf_paes_xts(CPUS390XState *env, const int mmu_idx, uintptr_t ra,/* process up to MAX_BLOCKS_PER_RUN aes blocks */ for (i =0 ; i <MAX_BLOCKS_PER_RUN && len >=AES_BLOCK_SIZE ; i++) { -/* fetch one AES block into buf1 */ -aes_read_block (env, mmu_idx, *src_ptr_reg + done, buf1, ra); -/* buf1 xor tweak => buf2 */ -aes_xor (buf1, tweak, buf2); +/* fetch one AES block into in */ +aes_read_block (env, mmu_idx, *src_ptr_reg + done, in, ra);if (mod) { -/* decrypt buf2 => buf1 */ -AES_decrypt (buf2, buf1, &exkey); +/* decrypt in => out */ +AES_xts_decrypt (in, out, tweak, &exkey); }else { -/* encrypt buf2 => buf1 */ -AES_encrypt (buf2, buf1, &exkey); +/* encrypt in => out */ +AES_xts_encrypt (in, out, tweak, &exkey); } -/* buf1 xor tweak => buf2 */ -aes_xor (buf1, tweak, buf2);/* prep tweak for next round */ -aes_xts_prep_next_tweak (tweak); -/* write out this processed block from buf2 */ -aes_write_block (env, mmu_idx, *dst_ptr_reg + done, buf2, ra); +AES_xts_prep_next_tweak (tweak); +/* write out this processed block from out */ +aes_write_block (env, mmu_idx, *dst_ptr_reg + done, out, ra); len -=AES_BLOCK_SIZE , done +=AES_BLOCK_SIZE ; }
Signature · 1 line
2.43.0