hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

s390 fixes for 4.19-rc4 

One fix for the zcrypt driver to correctly handle incomplete
 encryption/decryption operations.
 
 A cleanup for the aqmask/apmask parsing to avoid variable
 length arrays on the stack.
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2
 
 iQEcBAABCAAGBQJbmkYUAAoJEDjwexyKj9rgrugH/21Uf1S0mkkRfDeYxD6lJva6
 zNmEZ3V+GXc8L/0CisFWQOcIU1fO+jozp9HPGkQxeTvAuqIfVhBRVoMMxiTRaZb3
 xdSBel8EvAGxlZq/6eq6fU59HPWGm+N53rC9J5MMQQqgpSmq8F2QeO5CoidflRh8
 bdio9cliLsjPu+3P2JU3noolhb/f577J3dgP4gKARRpOfh8vUI7NLU3Mham+7886
 ASjG8s/zr9spPnrErJusloOLDJt4M94J8KrIbB/WAT1wZv7GxClaGsCoyCuk4cDt
 TV8zIgMK9TChedwMOO0T8WMaxq+XJV+iI0dC1eZ7xNUlaIBw+UbifxCG335L3E0=
 =dHq1
 -----END PGP SIGNATURE-----

Merge tag 's390-4.19-3' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux

Pull s390 fixes from Martin Schwidefsky:

 - One fix for the zcrypt driver to correctly handle incomplete
   encryption/decryption operations.

 - A cleanup for the aqmask/apmask parsing to avoid variable length
   arrays on the stack.

* tag 's390-4.19-3' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
  s390/zcrypt: remove VLA usage from the AP bus
  s390/crypto: Fix return code checking in cbc_paes_crypt()
This commit is contained in:
Linus Torvalds 2018-09-13 16:22:24 -10:00
parent 7a9cdebdcc fa108f95c6
commit 1d176582c7
2 changed files with 36 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/s390/crypto/paes_s390.c
View File

@ -208,7 +208,7 @@ static int cbc_paes_crypt(struct blkcipher_desc *desc, unsigned long modifier,
walk->dst.virt.addr, walk->src.virt.addr, n);
if (k)
ret = blkcipher_walk_done(desc, walk, nbytes - k);
if (n < k) {
if (k < n) {
if (__cbc_paes_set_key(ctx) != 0)
return blkcipher_walk_done(desc, walk, -EIO);
memcpy(param.key, ctx->pk.protkey, MAXPROTKEYSIZE);

90
drivers/s390/crypto/ap_bus.c
View File

@ -872,8 +872,6 @@ static int hex2bitmap(const char *str, unsigned long *bitmap, int bits)
if (bits & 0x07)
return -EINVAL;
memset(bitmap, 0, bits / 8);
if (str[0] == '0' && str[1] == 'x')
str++;
if (*str == 'x')
@ -895,25 +893,23 @@ static int hex2bitmap(const char *str, unsigned long *bitmap, int bits)
}
/*
* str2clrsetmasks() - parse bitmask argument and set the clear and
* the set bitmap mask. A concatenation (done with ',') of these terms
* is recognized:
* modify_bitmap() - parse bitmask argument and modify an existing
* bit mask accordingly. A concatenation (done with ',') of these
* terms is recognized:
* +<bitnr>[-<bitnr>] or -<bitnr>[-<bitnr>]
* <bitnr> may be any valid number (hex, decimal or octal) in the range
* 0...bits-1; the leading + or - is required. Here are some examples:
* +0-15,+32,-128,-0xFF
* -0-255,+1-16,+0x128
* +1,+2,+3,+4,-5,-7-10
* Returns a clear and a set bitmask. Every positive value in the string
* results in a bit set in the set mask and every negative value in the
* string results in a bit SET in the clear mask. As a bit may be touched
* more than once, the last 'operation' wins: +0-255,-128 = all but bit
* 128 set in the set mask, only bit 128 set in the clear mask.
* Returns the new bitmap after all changes have been applied. Every
* positive value in the string will set a bit and every negative value
* in the string will clear a bit. As a bit may be touched more than once,
* the last 'operation' wins:
* +0-255,-128 = first bits 0-255 will be set, then bit 128 will be
* cleared again. All other bits are unmodified.
*/
static int str2clrsetmasks(const char *str,
unsigned long *clrmap,
unsigned long *setmap,
int bits)
static int modify_bitmap(const char *str, unsigned long *bitmap, int bits)
{
int a, i, z;
char *np, sign;
@ -922,9 +918,6 @@ static int str2clrsetmasks(const char *str,
if (bits & 0x07)
return -EINVAL;
memset(clrmap, 0, bits / 8);
memset(setmap, 0, bits / 8);
while (*str) {
sign = *str++;
if (sign != '+' && sign != '-')
@ -940,13 +933,10 @@ static int str2clrsetmasks(const char *str,
str = np;
}
for (i = a; i <= z; i++)
if (sign == '+') {
set_bit_inv(i, setmap);
clear_bit_inv(i, clrmap);
} else {
clear_bit_inv(i, setmap);
set_bit_inv(i, clrmap);
}
if (sign == '+')
set_bit_inv(i, bitmap);
else
clear_bit_inv(i, bitmap);
while (*str == ',' || *str == '\n')
str++;
}
@ -970,44 +960,34 @@ static int process_mask_arg(const char *str,
unsigned long *bitmap, int bits,
struct mutex *lock)
{
int i;
unsigned long *newmap, size;
int rc;
/* bits needs to be a multiple of 8 */
if (bits & 0x07)
return -EINVAL;
if (*str == '+' || *str == '-') {
DECLARE_BITMAP(clrm, bits);
DECLARE_BITMAP(setm, bits);
i = str2clrsetmasks(str, clrm, setm, bits);
if (i)
return i;
if (mutex_lock_interruptible(lock))
return -ERESTARTSYS;
for (i = 0; i < bits; i++) {
if (test_bit_inv(i, clrm))
clear_bit_inv(i, bitmap);
if (test_bit_inv(i, setm))
set_bit_inv(i, bitmap);
}
} else {
DECLARE_BITMAP(setm, bits);
i = hex2bitmap(str, setm, bits);
if (i)
return i;
if (mutex_lock_interruptible(lock))
return -ERESTARTSYS;
for (i = 0; i < bits; i++)
if (test_bit_inv(i, setm))
set_bit_inv(i, bitmap);
else
clear_bit_inv(i, bitmap);
size = BITS_TO_LONGS(bits)*sizeof(unsigned long);
newmap = kmalloc(size, GFP_KERNEL);
if (!newmap)
return -ENOMEM;
if (mutex_lock_interruptible(lock)) {
kfree(newmap);
return -ERESTARTSYS;
}
mutex_unlock(lock);
return 0;
if (*str == '+' || *str == '-') {
memcpy(newmap, bitmap, size);
rc = modify_bitmap(str, newmap, bits);
} else {
memset(newmap, 0, size);
rc = hex2bitmap(str, newmap, bits);
}
if (rc == 0)
memcpy(bitmap, newmap, size);
mutex_unlock(lock);
kfree(newmap);
return rc;
}
/*