Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-5.4/0206-5.4.107-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-5.4/0206-5.4.107-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3635 - (show annotations) (download)
    Mon Oct 24 12:34:12 2022 UTC (18 months, 3 weeks ago) by niro
    File size: 118318 byte(s) 
    -sync kernel patches
    1 diff --git a/Makefile b/Makefile
    2 index a333b378f1f71..43159b21a83f4 100644
    3 --- a/Makefile
    4 +++ b/Makefile
    5 @@ -1,7 +1,7 @@
    6 # SPDX-License-Identifier: GPL-2.0
    7 VERSION = 5
    8 PATCHLEVEL = 4
    9 -SUBLEVEL = 106
    10 +SUBLEVEL = 107
    11 EXTRAVERSION =
    12 NAME = Kleptomaniac Octopus
    13
    14 diff --git a/arch/arm64/include/asm/kvm_hyp.h b/arch/arm64/include/asm/kvm_hyp.h
    15 index 97f21cc666579..7f7fdb16bb968 100644
    16 --- a/arch/arm64/include/asm/kvm_hyp.h
    17 +++ b/arch/arm64/include/asm/kvm_hyp.h
    18 @@ -71,6 +71,9 @@ void __sysreg32_restore_state(struct kvm_vcpu *vcpu);
    19
    20 void __debug_switch_to_guest(struct kvm_vcpu *vcpu);
    21 void __debug_switch_to_host(struct kvm_vcpu *vcpu);
    22 +void __debug_save_host_buffers_nvhe(struct kvm_vcpu *vcpu);
    23 +void __debug_restore_host_buffers_nvhe(struct kvm_vcpu *vcpu);
    24 +
    25
    26 void __fpsimd_save_state(struct user_fpsimd_state *fp_regs);
    27 void __fpsimd_restore_state(struct user_fpsimd_state *fp_regs);
    28 diff --git a/arch/arm64/kvm/hyp/debug-sr.c b/arch/arm64/kvm/hyp/debug-sr.c
    29 index 0fc9872a14671..aead8a5fbe919 100644
    30 --- a/arch/arm64/kvm/hyp/debug-sr.c
    31 +++ b/arch/arm64/kvm/hyp/debug-sr.c
    32 @@ -168,6 +168,21 @@ static void __hyp_text __debug_restore_state(struct kvm_vcpu *vcpu,
    33 write_sysreg(ctxt->sys_regs[MDCCINT_EL1], mdccint_el1);
    34 }
    35
    36 +void __hyp_text __debug_save_host_buffers_nvhe(struct kvm_vcpu *vcpu)
    37 +{
    38 + /*
    39 + * Non-VHE: Disable and flush SPE data generation
    40 + * VHE: The vcpu can run, but it can't hide.
    41 + */
    42 + __debug_save_spe_nvhe(&vcpu->arch.host_debug_state.pmscr_el1);
    43 +
    44 +}
    45 +
    46 +void __hyp_text __debug_restore_host_buffers_nvhe(struct kvm_vcpu *vcpu)
    47 +{
    48 + __debug_restore_spe_nvhe(vcpu->arch.host_debug_state.pmscr_el1);
    49 +}
    50 +
    51 void __hyp_text __debug_switch_to_guest(struct kvm_vcpu *vcpu)
    52 {
    53 struct kvm_cpu_context *host_ctxt;
    54 @@ -175,13 +190,6 @@ void __hyp_text __debug_switch_to_guest(struct kvm_vcpu *vcpu)
    55 struct kvm_guest_debug_arch *host_dbg;
    56 struct kvm_guest_debug_arch *guest_dbg;
    57
    58 - /*
    59 - * Non-VHE: Disable and flush SPE data generation
    60 - * VHE: The vcpu can run, but it can't hide.
    61 - */
    62 - if (!has_vhe())
    63 - __debug_save_spe_nvhe(&vcpu->arch.host_debug_state.pmscr_el1);
    64 -
    65 if (!(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY))
    66 return;
    67
    68 @@ -201,8 +209,6 @@ void __hyp_text __debug_switch_to_host(struct kvm_vcpu *vcpu)
    69 struct kvm_guest_debug_arch *host_dbg;
    70 struct kvm_guest_debug_arch *guest_dbg;
    71
    72 - if (!has_vhe())
    73 - __debug_restore_spe_nvhe(vcpu->arch.host_debug_state.pmscr_el1);
    74
    75 if (!(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY))
    76 return;
    77 diff --git a/arch/arm64/kvm/hyp/switch.c b/arch/arm64/kvm/hyp/switch.c
    78 index 84964983198e2..14607fac7ca38 100644
    79 --- a/arch/arm64/kvm/hyp/switch.c
    80 +++ b/arch/arm64/kvm/hyp/switch.c
    81 @@ -682,6 +682,15 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)
    82
    83 __sysreg_save_state_nvhe(host_ctxt);
    84
    85 + /*
    86 + * We must flush and disable the SPE buffer for nVHE, as
    87 + * the translation regime(EL1&0) is going to be loaded with
    88 + * that of the guest. And we must do this before we change the
    89 + * translation regime to EL2 (via MDCR_EL2_EPB == 0) and
    90 + * before we load guest Stage1.
    91 + */
    92 + __debug_save_host_buffers_nvhe(vcpu);
    93 +
    94 __activate_vm(kern_hyp_va(vcpu->kvm));
    95 __activate_traps(vcpu);
    96
    97 @@ -720,11 +729,13 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)
    98 if (vcpu->arch.flags & KVM_ARM64_FP_ENABLED)
    99 __fpsimd_save_fpexc32(vcpu);
    100
    101 + __debug_switch_to_host(vcpu);
    102 +
    103 /*
    104 * This must come after restoring the host sysregs, since a non-VHE
    105 * system may enable SPE here and make use of the TTBRs.
    106 */
    107 - __debug_switch_to_host(vcpu);
    108 + __debug_restore_host_buffers_nvhe(vcpu);
    109
    110 if (pmu_switch_needed)
    111 __pmu_switch_to_host(host_ctxt);
    112 diff --git a/arch/x86/crypto/aesni-intel_asm.S b/arch/x86/crypto/aesni-intel_asm.S
    113 index 9afeb58c910eb..dd954d8db629b 100644
    114 --- a/arch/x86/crypto/aesni-intel_asm.S
    115 +++ b/arch/x86/crypto/aesni-intel_asm.S
    116 @@ -319,7 +319,7 @@ _initial_blocks_\@:
    117
    118 # Main loop - Encrypt/Decrypt remaining blocks
    119
    120 - cmp $0, %r13
    121 + test %r13, %r13
    122 je _zero_cipher_left_\@
    123 sub $64, %r13
    124 je _four_cipher_left_\@
    125 @@ -438,7 +438,7 @@ _multiple_of_16_bytes_\@:
    126
    127 mov PBlockLen(%arg2), %r12
    128
    129 - cmp $0, %r12
    130 + test %r12, %r12
    131 je _partial_done\@
    132
    133 GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
    134 @@ -475,7 +475,7 @@ _T_8_\@:
    135 add $8, %r10
    136 sub $8, %r11
    137 psrldq $8, %xmm0
    138 - cmp $0, %r11
    139 + test %r11, %r11
    140 je _return_T_done_\@
    141 _T_4_\@:
    142 movd %xmm0, %eax
    143 @@ -483,7 +483,7 @@ _T_4_\@:
    144 add $4, %r10
    145 sub $4, %r11
    146 psrldq $4, %xmm0
    147 - cmp $0, %r11
    148 + test %r11, %r11
    149 je _return_T_done_\@
    150 _T_123_\@:
    151 movd %xmm0, %eax
    152 @@ -620,7 +620,7 @@ _get_AAD_blocks\@:
    153
    154 /* read the last <16B of AAD */
    155 _get_AAD_rest\@:
    156 - cmp $0, %r11
    157 + test %r11, %r11
    158 je _get_AAD_done\@
    159
    160 READ_PARTIAL_BLOCK %r10, %r11, \TMP1, \TMP7
    161 @@ -641,7 +641,7 @@ _get_AAD_done\@:
    162 .macro PARTIAL_BLOCK CYPH_PLAIN_OUT PLAIN_CYPH_IN PLAIN_CYPH_LEN DATA_OFFSET \
    163 AAD_HASH operation
    164 mov PBlockLen(%arg2), %r13
    165 - cmp $0, %r13
    166 + test %r13, %r13
    167 je _partial_block_done_\@ # Leave Macro if no partial blocks
    168 # Read in input data without over reading
    169 cmp $16, \PLAIN_CYPH_LEN
    170 @@ -693,7 +693,7 @@ _no_extra_mask_1_\@:
    171 PSHUFB_XMM %xmm2, %xmm3
    172 pxor %xmm3, \AAD_HASH
    173
    174 - cmp $0, %r10
    175 + test %r10, %r10
    176 jl _partial_incomplete_1_\@
    177
    178 # GHASH computation for the last <16 Byte block
    179 @@ -728,7 +728,7 @@ _no_extra_mask_2_\@:
    180 PSHUFB_XMM %xmm2, %xmm9
    181 pxor %xmm9, \AAD_HASH
    182
    183 - cmp $0, %r10
    184 + test %r10, %r10
    185 jl _partial_incomplete_2_\@
    186
    187 # GHASH computation for the last <16 Byte block
    188 @@ -748,7 +748,7 @@ _encode_done_\@:
    189 PSHUFB_XMM %xmm2, %xmm9
    190 .endif
    191 # output encrypted Bytes
    192 - cmp $0, %r10
    193 + test %r10, %r10
    194 jl _partial_fill_\@
    195 mov %r13, %r12
    196 mov $16, %r13
    197 @@ -1946,7 +1946,7 @@ ENTRY(aesni_set_key)
    198 ENDPROC(aesni_set_key)
    199
    200 /*
    201 - * void aesni_enc(struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
    202 + * void aesni_enc(const void *ctx, u8 *dst, const u8 *src)
    203 */
    204 ENTRY(aesni_enc)
    205 FRAME_BEGIN
    206 @@ -2137,7 +2137,7 @@ _aesni_enc4:
    207 ENDPROC(_aesni_enc4)
    208
    209 /*
    210 - * void aesni_dec (struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
    211 + * void aesni_dec (const void *ctx, u8 *dst, const u8 *src)
    212 */
    213 ENTRY(aesni_dec)
    214 FRAME_BEGIN
    215 @@ -2726,25 +2726,18 @@ ENDPROC(aesni_ctr_enc)
    216 pxor CTR, IV;
    217
    218 /*
    219 - * void aesni_xts_crypt8(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
    220 - * bool enc, u8 *iv)
    221 + * void aesni_xts_encrypt(const struct crypto_aes_ctx *ctx, u8 *dst,
    222 + * const u8 *src, unsigned int len, le128 *iv)
    223 */
    224 -ENTRY(aesni_xts_crypt8)
    225 +ENTRY(aesni_xts_encrypt)
    226 FRAME_BEGIN
    227 - cmpb $0, %cl
    228 - movl $0, %ecx
    229 - movl $240, %r10d
    230 - leaq _aesni_enc4, %r11
    231 - leaq _aesni_dec4, %rax
    232 - cmovel %r10d, %ecx
    233 - cmoveq %rax, %r11
    234
    235 movdqa .Lgf128mul_x_ble_mask, GF128MUL_MASK
    236 movups (IVP), IV
    237
    238 mov 480(KEYP), KLEN
    239 - addq %rcx, KEYP
    240
    241 +.Lxts_enc_loop4:
    242 movdqa IV, STATE1
    243 movdqu 0x00(INP), INC
    244 pxor INC, STATE1
    245 @@ -2768,71 +2761,103 @@ ENTRY(aesni_xts_crypt8)
    246 pxor INC, STATE4
    247 movdqu IV, 0x30(OUTP)
    248
    249 - CALL_NOSPEC %r11
    250 + call _aesni_enc4
    251
    252 movdqu 0x00(OUTP), INC
    253 pxor INC, STATE1
    254 movdqu STATE1, 0x00(OUTP)
    255
    256 - _aesni_gf128mul_x_ble()
    257 - movdqa IV, STATE1
    258 - movdqu 0x40(INP), INC
    259 - pxor INC, STATE1
    260 - movdqu IV, 0x40(OUTP)
    261 -
    262 movdqu 0x10(OUTP), INC
    263 pxor INC, STATE2
    264 movdqu STATE2, 0x10(OUTP)
    265
    266 - _aesni_gf128mul_x_ble()
    267 - movdqa IV, STATE2
    268 - movdqu 0x50(INP), INC
    269 - pxor INC, STATE2
    270 - movdqu IV, 0x50(OUTP)
    271 -
    272 movdqu 0x20(OUTP), INC
    273 pxor INC, STATE3
    274 movdqu STATE3, 0x20(OUTP)
    275
    276 - _aesni_gf128mul_x_ble()
    277 - movdqa IV, STATE3
    278 - movdqu 0x60(INP), INC
    279 - pxor INC, STATE3
    280 - movdqu IV, 0x60(OUTP)
    281 -
    282 movdqu 0x30(OUTP), INC
    283 pxor INC, STATE4
    284 movdqu STATE4, 0x30(OUTP)
    285
    286 _aesni_gf128mul_x_ble()
    287 - movdqa IV, STATE4
    288 - movdqu 0x70(INP), INC
    289 - pxor INC, STATE4
    290 - movdqu IV, 0x70(OUTP)
    291
    292 - _aesni_gf128mul_x_ble()
    293 + add $64, INP
    294 + add $64, OUTP
    295 + sub $64, LEN
    296 + ja .Lxts_enc_loop4
    297 +
    298 movups IV, (IVP)
    299
    300 - CALL_NOSPEC %r11
    301 + FRAME_END
    302 + ret
    303 +ENDPROC(aesni_xts_encrypt)
    304 +
    305 +/*
    306 + * void aesni_xts_decrypt(const struct crypto_aes_ctx *ctx, u8 *dst,
    307 + * const u8 *src, unsigned int len, le128 *iv)
    308 + */
    309 +ENTRY(aesni_xts_decrypt)
    310 + FRAME_BEGIN
    311 +
    312 + movdqa .Lgf128mul_x_ble_mask, GF128MUL_MASK
    313 + movups (IVP), IV
    314 +
    315 + mov 480(KEYP), KLEN
    316 + add $240, KEYP
    317
    318 - movdqu 0x40(OUTP), INC
    319 +.Lxts_dec_loop4:
    320 + movdqa IV, STATE1
    321 + movdqu 0x00(INP), INC
    322 pxor INC, STATE1
    323 - movdqu STATE1, 0x40(OUTP)
    324 + movdqu IV, 0x00(OUTP)
    325
    326 - movdqu 0x50(OUTP), INC
    327 + _aesni_gf128mul_x_ble()
    328 + movdqa IV, STATE2
    329 + movdqu 0x10(INP), INC
    330 + pxor INC, STATE2
    331 + movdqu IV, 0x10(OUTP)
    332 +
    333 + _aesni_gf128mul_x_ble()
    334 + movdqa IV, STATE3
    335 + movdqu 0x20(INP), INC
    336 + pxor INC, STATE3
    337 + movdqu IV, 0x20(OUTP)
    338 +
    339 + _aesni_gf128mul_x_ble()
    340 + movdqa IV, STATE4
    341 + movdqu 0x30(INP), INC
    342 + pxor INC, STATE4
    343 + movdqu IV, 0x30(OUTP)
    344 +
    345 + call _aesni_dec4
    346 +
    347 + movdqu 0x00(OUTP), INC
    348 + pxor INC, STATE1
    349 + movdqu STATE1, 0x00(OUTP)
    350 +
    351 + movdqu 0x10(OUTP), INC
    352 pxor INC, STATE2
    353 - movdqu STATE2, 0x50(OUTP)
    354 + movdqu STATE2, 0x10(OUTP)
    355
    356 - movdqu 0x60(OUTP), INC
    357 + movdqu 0x20(OUTP), INC
    358 pxor INC, STATE3
    359 - movdqu STATE3, 0x60(OUTP)
    360 + movdqu STATE3, 0x20(OUTP)
    361
    362 - movdqu 0x70(OUTP), INC
    363 + movdqu 0x30(OUTP), INC
    364 pxor INC, STATE4
    365 - movdqu STATE4, 0x70(OUTP)
    366 + movdqu STATE4, 0x30(OUTP)
    367 +
    368 + _aesni_gf128mul_x_ble()
    369 +
    370 + add $64, INP
    371 + add $64, OUTP
    372 + sub $64, LEN
    373 + ja .Lxts_dec_loop4
    374 +
    375 + movups IV, (IVP)
    376
    377 FRAME_END
    378 ret
    379 -ENDPROC(aesni_xts_crypt8)
    380 +ENDPROC(aesni_xts_decrypt)
    381
    382 #endif
    383 diff --git a/arch/x86/crypto/aesni-intel_avx-x86_64.S b/arch/x86/crypto/aesni-intel_avx-x86_64.S
    384 index 91c039ab56999..4e4d34956170b 100644
    385 --- a/arch/x86/crypto/aesni-intel_avx-x86_64.S
    386 +++ b/arch/x86/crypto/aesni-intel_avx-x86_64.S
    387 @@ -370,7 +370,7 @@ _initial_num_blocks_is_0\@:
    388
    389
    390 _initial_blocks_encrypted\@:
    391 - cmp $0, %r13
    392 + test %r13, %r13
    393 je _zero_cipher_left\@
    394
    395 sub $128, %r13
    396 @@ -529,7 +529,7 @@ _multiple_of_16_bytes\@:
    397 vmovdqu HashKey(arg2), %xmm13
    398
    399 mov PBlockLen(arg2), %r12
    400 - cmp $0, %r12
    401 + test %r12, %r12
    402 je _partial_done\@
    403
    404 #GHASH computation for the last <16 Byte block
    405 @@ -574,7 +574,7 @@ _T_8\@:
    406 add $8, %r10
    407 sub $8, %r11
    408 vpsrldq $8, %xmm9, %xmm9
    409 - cmp $0, %r11
    410 + test %r11, %r11
    411 je _return_T_done\@
    412 _T_4\@:
    413 vmovd %xmm9, %eax
    414 @@ -582,7 +582,7 @@ _T_4\@:
    415 add $4, %r10
    416 sub $4, %r11
    417 vpsrldq $4, %xmm9, %xmm9
    418 - cmp $0, %r11
    419 + test %r11, %r11
    420 je _return_T_done\@
    421 _T_123\@:
    422 vmovd %xmm9, %eax
    423 @@ -626,7 +626,7 @@ _get_AAD_blocks\@:
    424 cmp $16, %r11
    425 jge _get_AAD_blocks\@
    426 vmovdqu \T8, \T7
    427 - cmp $0, %r11
    428 + test %r11, %r11
    429 je _get_AAD_done\@
    430
    431 vpxor \T7, \T7, \T7
    432 @@ -645,7 +645,7 @@ _get_AAD_rest8\@:
    433 vpxor \T1, \T7, \T7
    434 jmp _get_AAD_rest8\@
    435 _get_AAD_rest4\@:
    436 - cmp $0, %r11
    437 + test %r11, %r11
    438 jle _get_AAD_rest0\@
    439 mov (%r10), %eax
    440 movq %rax, \T1
    441 @@ -750,7 +750,7 @@ _done_read_partial_block_\@:
    442 .macro PARTIAL_BLOCK GHASH_MUL CYPH_PLAIN_OUT PLAIN_CYPH_IN PLAIN_CYPH_LEN DATA_OFFSET \
    443 AAD_HASH ENC_DEC
    444 mov PBlockLen(arg2), %r13
    445 - cmp $0, %r13
    446 + test %r13, %r13
    447 je _partial_block_done_\@ # Leave Macro if no partial blocks
    448 # Read in input data without over reading
    449 cmp $16, \PLAIN_CYPH_LEN
    450 @@ -802,7 +802,7 @@ _no_extra_mask_1_\@:
    451 vpshufb %xmm2, %xmm3, %xmm3
    452 vpxor %xmm3, \AAD_HASH, \AAD_HASH
    453
    454 - cmp $0, %r10
    455 + test %r10, %r10
    456 jl _partial_incomplete_1_\@
    457
    458 # GHASH computation for the last <16 Byte block
    459 @@ -837,7 +837,7 @@ _no_extra_mask_2_\@:
    460 vpshufb %xmm2, %xmm9, %xmm9
    461 vpxor %xmm9, \AAD_HASH, \AAD_HASH
    462
    463 - cmp $0, %r10
    464 + test %r10, %r10
    465 jl _partial_incomplete_2_\@
    466
    467 # GHASH computation for the last <16 Byte block
    468 @@ -857,7 +857,7 @@ _encode_done_\@:
    469 vpshufb %xmm2, %xmm9, %xmm9
    470 .endif
    471 # output encrypted Bytes
    472 - cmp $0, %r10
    473 + test %r10, %r10
    474 jl _partial_fill_\@
    475 mov %r13, %r12
    476 mov $16, %r13
    477 diff --git a/arch/x86/crypto/aesni-intel_glue.c b/arch/x86/crypto/aesni-intel_glue.c
    478 index 88ad272aa2b46..18cfb76daa232 100644
    479 --- a/arch/x86/crypto/aesni-intel_glue.c
    480 +++ b/arch/x86/crypto/aesni-intel_glue.c
    481 @@ -83,10 +83,8 @@ struct gcm_context_data {
    482
    483 asmlinkage int aesni_set_key(struct crypto_aes_ctx *ctx, const u8 *in_key,
    484 unsigned int key_len);
    485 -asmlinkage void aesni_enc(struct crypto_aes_ctx *ctx, u8 *out,
    486 - const u8 *in);
    487 -asmlinkage void aesni_dec(struct crypto_aes_ctx *ctx, u8 *out,
    488 - const u8 *in);
    489 +asmlinkage void aesni_enc(const void *ctx, u8 *out, const u8 *in);
    490 +asmlinkage void aesni_dec(const void *ctx, u8 *out, const u8 *in);
    491 asmlinkage void aesni_ecb_enc(struct crypto_aes_ctx *ctx, u8 *out,
    492 const u8 *in, unsigned int len);
    493 asmlinkage void aesni_ecb_dec(struct crypto_aes_ctx *ctx, u8 *out,
    494 @@ -99,6 +97,12 @@ asmlinkage void aesni_cbc_dec(struct crypto_aes_ctx *ctx, u8 *out,
    495 #define AVX_GEN2_OPTSIZE 640
    496 #define AVX_GEN4_OPTSIZE 4096
    497
    498 +asmlinkage void aesni_xts_encrypt(const struct crypto_aes_ctx *ctx, u8 *out,
    499 + const u8 *in, unsigned int len, u8 *iv);
    500 +
    501 +asmlinkage void aesni_xts_decrypt(const struct crypto_aes_ctx *ctx, u8 *out,
    502 + const u8 *in, unsigned int len, u8 *iv);
    503 +
    504 #ifdef CONFIG_X86_64
    505
    506 static void (*aesni_ctr_enc_tfm)(struct crypto_aes_ctx *ctx, u8 *out,
    507 @@ -106,9 +110,6 @@ static void (*aesni_ctr_enc_tfm)(struct crypto_aes_ctx *ctx, u8 *out,
    508 asmlinkage void aesni_ctr_enc(struct crypto_aes_ctx *ctx, u8 *out,
    509 const u8 *in, unsigned int len, u8 *iv);
    510
    511 -asmlinkage void aesni_xts_crypt8(struct crypto_aes_ctx *ctx, u8 *out,
    512 - const u8 *in, bool enc, u8 *iv);
    513 -
    514 /* asmlinkage void aesni_gcm_enc()
    515 * void *ctx, AES Key schedule. Starts on a 16 byte boundary.
    516 * struct gcm_context_data. May be uninitialized.
    517 @@ -550,29 +551,24 @@ static int xts_aesni_setkey(struct crypto_skcipher *tfm, const u8 *key,
    518 }
    519
    520
    521 -static void aesni_xts_tweak(void *ctx, u8 *out, const u8 *in)
    522 -{
    523 - aesni_enc(ctx, out, in);
    524 -}
    525 -
    526 -static void aesni_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    527 +static void aesni_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    528 {
    529 - glue_xts_crypt_128bit_one(ctx, dst, src, iv, GLUE_FUNC_CAST(aesni_enc));
    530 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, aesni_enc);
    531 }
    532
    533 -static void aesni_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    534 +static void aesni_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    535 {
    536 - glue_xts_crypt_128bit_one(ctx, dst, src, iv, GLUE_FUNC_CAST(aesni_dec));
    537 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, aesni_dec);
    538 }
    539
    540 -static void aesni_xts_enc8(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    541 +static void aesni_xts_enc32(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    542 {
    543 - aesni_xts_crypt8(ctx, (u8 *)dst, (const u8 *)src, true, (u8 *)iv);
    544 + aesni_xts_encrypt(ctx, dst, src, 32 * AES_BLOCK_SIZE, (u8 *)iv);
    545 }
    546
    547 -static void aesni_xts_dec8(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    548 +static void aesni_xts_dec32(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    549 {
    550 - aesni_xts_crypt8(ctx, (u8 *)dst, (const u8 *)src, false, (u8 *)iv);
    551 + aesni_xts_decrypt(ctx, dst, src, 32 * AES_BLOCK_SIZE, (u8 *)iv);
    552 }
    553
    554 static const struct common_glue_ctx aesni_enc_xts = {
    555 @@ -580,11 +576,11 @@ static const struct common_glue_ctx aesni_enc_xts = {
    556 .fpu_blocks_limit = 1,
    557
    558 .funcs = { {
    559 - .num_blocks = 8,
    560 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(aesni_xts_enc8) }
    561 + .num_blocks = 32,
    562 + .fn_u = { .xts = aesni_xts_enc32 }
    563 }, {
    564 .num_blocks = 1,
    565 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(aesni_xts_enc) }
    566 + .fn_u = { .xts = aesni_xts_enc }
    567 } }
    568 };
    569
    570 @@ -593,11 +589,11 @@ static const struct common_glue_ctx aesni_dec_xts = {
    571 .fpu_blocks_limit = 1,
    572
    573 .funcs = { {
    574 - .num_blocks = 8,
    575 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(aesni_xts_dec8) }
    576 + .num_blocks = 32,
    577 + .fn_u = { .xts = aesni_xts_dec32 }
    578 }, {
    579 .num_blocks = 1,
    580 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(aesni_xts_dec) }
    581 + .fn_u = { .xts = aesni_xts_dec }
    582 } }
    583 };
    584
    585 @@ -606,8 +602,7 @@ static int xts_encrypt(struct skcipher_request *req)
    586 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    587 struct aesni_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    588
    589 - return glue_xts_req_128bit(&aesni_enc_xts, req,
    590 - XTS_TWEAK_CAST(aesni_xts_tweak),
    591 + return glue_xts_req_128bit(&aesni_enc_xts, req, aesni_enc,
    592 aes_ctx(ctx->raw_tweak_ctx),
    593 aes_ctx(ctx->raw_crypt_ctx),
    594 false);
    595 @@ -618,8 +613,7 @@ static int xts_decrypt(struct skcipher_request *req)
    596 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    597 struct aesni_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    598
    599 - return glue_xts_req_128bit(&aesni_dec_xts, req,
    600 - XTS_TWEAK_CAST(aesni_xts_tweak),
    601 + return glue_xts_req_128bit(&aesni_dec_xts, req, aesni_enc,
    602 aes_ctx(ctx->raw_tweak_ctx),
    603 aes_ctx(ctx->raw_crypt_ctx),
    604 true);
    605 diff --git a/arch/x86/crypto/camellia_aesni_avx2_glue.c b/arch/x86/crypto/camellia_aesni_avx2_glue.c
    606 index a4f00128ea552..a8cc2c83fe1bb 100644
    607 --- a/arch/x86/crypto/camellia_aesni_avx2_glue.c
    608 +++ b/arch/x86/crypto/camellia_aesni_avx2_glue.c
    609 @@ -19,20 +19,17 @@
    610 #define CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS 32
    611
    612 /* 32-way AVX2/AES-NI parallel cipher functions */
    613 -asmlinkage void camellia_ecb_enc_32way(struct camellia_ctx *ctx, u8 *dst,
    614 - const u8 *src);
    615 -asmlinkage void camellia_ecb_dec_32way(struct camellia_ctx *ctx, u8 *dst,
    616 - const u8 *src);
    617 +asmlinkage void camellia_ecb_enc_32way(const void *ctx, u8 *dst, const u8 *src);
    618 +asmlinkage void camellia_ecb_dec_32way(const void *ctx, u8 *dst, const u8 *src);
    619
    620 -asmlinkage void camellia_cbc_dec_32way(struct camellia_ctx *ctx, u8 *dst,
    621 - const u8 *src);
    622 -asmlinkage void camellia_ctr_32way(struct camellia_ctx *ctx, u8 *dst,
    623 - const u8 *src, le128 *iv);
    624 +asmlinkage void camellia_cbc_dec_32way(const void *ctx, u8 *dst, const u8 *src);
    625 +asmlinkage void camellia_ctr_32way(const void *ctx, u8 *dst, const u8 *src,
    626 + le128 *iv);
    627
    628 -asmlinkage void camellia_xts_enc_32way(struct camellia_ctx *ctx, u8 *dst,
    629 - const u8 *src, le128 *iv);
    630 -asmlinkage void camellia_xts_dec_32way(struct camellia_ctx *ctx, u8 *dst,
    631 - const u8 *src, le128 *iv);
    632 +asmlinkage void camellia_xts_enc_32way(const void *ctx, u8 *dst, const u8 *src,
    633 + le128 *iv);
    634 +asmlinkage void camellia_xts_dec_32way(const void *ctx, u8 *dst, const u8 *src,
    635 + le128 *iv);
    636
    637 static const struct common_glue_ctx camellia_enc = {
    638 .num_funcs = 4,
    639 @@ -40,16 +37,16 @@ static const struct common_glue_ctx camellia_enc = {
    640
    641 .funcs = { {
    642 .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS,
    643 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_enc_32way) }
    644 + .fn_u = { .ecb = camellia_ecb_enc_32way }
    645 }, {
    646 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    647 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_enc_16way) }
    648 + .fn_u = { .ecb = camellia_ecb_enc_16way }
    649 }, {
    650 .num_blocks = 2,
    651 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk_2way) }
    652 + .fn_u = { .ecb = camellia_enc_blk_2way }
    653 }, {
    654 .num_blocks = 1,
    655 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk) }
    656 + .fn_u = { .ecb = camellia_enc_blk }
    657 } }
    658 };
    659
    660 @@ -59,16 +56,16 @@ static const struct common_glue_ctx camellia_ctr = {
    661
    662 .funcs = { {
    663 .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS,
    664 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_ctr_32way) }
    665 + .fn_u = { .ctr = camellia_ctr_32way }
    666 }, {
    667 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    668 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_ctr_16way) }
    669 + .fn_u = { .ctr = camellia_ctr_16way }
    670 }, {
    671 .num_blocks = 2,
    672 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) }
    673 + .fn_u = { .ctr = camellia_crypt_ctr_2way }
    674 }, {
    675 .num_blocks = 1,
    676 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) }
    677 + .fn_u = { .ctr = camellia_crypt_ctr }
    678 } }
    679 };
    680
    681 @@ -78,13 +75,13 @@ static const struct common_glue_ctx camellia_enc_xts = {
    682
    683 .funcs = { {
    684 .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS,
    685 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc_32way) }
    686 + .fn_u = { .xts = camellia_xts_enc_32way }
    687 }, {
    688 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    689 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc_16way) }
    690 + .fn_u = { .xts = camellia_xts_enc_16way }
    691 }, {
    692 .num_blocks = 1,
    693 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc) }
    694 + .fn_u = { .xts = camellia_xts_enc }
    695 } }
    696 };
    697
    698 @@ -94,16 +91,16 @@ static const struct common_glue_ctx camellia_dec = {
    699
    700 .funcs = { {
    701 .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS,
    702 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_dec_32way) }
    703 + .fn_u = { .ecb = camellia_ecb_dec_32way }
    704 }, {
    705 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    706 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_dec_16way) }
    707 + .fn_u = { .ecb = camellia_ecb_dec_16way }
    708 }, {
    709 .num_blocks = 2,
    710 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) }
    711 + .fn_u = { .ecb = camellia_dec_blk_2way }
    712 }, {
    713 .num_blocks = 1,
    714 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) }
    715 + .fn_u = { .ecb = camellia_dec_blk }
    716 } }
    717 };
    718
    719 @@ -113,16 +110,16 @@ static const struct common_glue_ctx camellia_dec_cbc = {
    720
    721 .funcs = { {
    722 .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS,
    723 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_cbc_dec_32way) }
    724 + .fn_u = { .cbc = camellia_cbc_dec_32way }
    725 }, {
    726 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    727 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_cbc_dec_16way) }
    728 + .fn_u = { .cbc = camellia_cbc_dec_16way }
    729 }, {
    730 .num_blocks = 2,
    731 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) }
    732 + .fn_u = { .cbc = camellia_decrypt_cbc_2way }
    733 }, {
    734 .num_blocks = 1,
    735 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) }
    736 + .fn_u = { .cbc = camellia_dec_blk }
    737 } }
    738 };
    739
    740 @@ -132,13 +129,13 @@ static const struct common_glue_ctx camellia_dec_xts = {
    741
    742 .funcs = { {
    743 .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS,
    744 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec_32way) }
    745 + .fn_u = { .xts = camellia_xts_dec_32way }
    746 }, {
    747 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    748 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec_16way) }
    749 + .fn_u = { .xts = camellia_xts_dec_16way }
    750 }, {
    751 .num_blocks = 1,
    752 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec) }
    753 + .fn_u = { .xts = camellia_xts_dec }
    754 } }
    755 };
    756
    757 @@ -161,8 +158,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    758
    759 static int cbc_encrypt(struct skcipher_request *req)
    760 {
    761 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(camellia_enc_blk),
    762 - req);
    763 + return glue_cbc_encrypt_req_128bit(camellia_enc_blk, req);
    764 }
    765
    766 static int cbc_decrypt(struct skcipher_request *req)
    767 @@ -180,8 +176,7 @@ static int xts_encrypt(struct skcipher_request *req)
    768 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    769 struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    770
    771 - return glue_xts_req_128bit(&camellia_enc_xts, req,
    772 - XTS_TWEAK_CAST(camellia_enc_blk),
    773 + return glue_xts_req_128bit(&camellia_enc_xts, req, camellia_enc_blk,
    774 &ctx->tweak_ctx, &ctx->crypt_ctx, false);
    775 }
    776
    777 @@ -190,8 +185,7 @@ static int xts_decrypt(struct skcipher_request *req)
    778 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    779 struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    780
    781 - return glue_xts_req_128bit(&camellia_dec_xts, req,
    782 - XTS_TWEAK_CAST(camellia_enc_blk),
    783 + return glue_xts_req_128bit(&camellia_dec_xts, req, camellia_enc_blk,
    784 &ctx->tweak_ctx, &ctx->crypt_ctx, true);
    785 }
    786
    787 diff --git a/arch/x86/crypto/camellia_aesni_avx_glue.c b/arch/x86/crypto/camellia_aesni_avx_glue.c
    788 index f28d282779b87..31a82a79f4ac9 100644
    789 --- a/arch/x86/crypto/camellia_aesni_avx_glue.c
    790 +++ b/arch/x86/crypto/camellia_aesni_avx_glue.c
    791 @@ -18,41 +18,36 @@
    792 #define CAMELLIA_AESNI_PARALLEL_BLOCKS 16
    793
    794 /* 16-way parallel cipher functions (avx/aes-ni) */
    795 -asmlinkage void camellia_ecb_enc_16way(struct camellia_ctx *ctx, u8 *dst,
    796 - const u8 *src);
    797 +asmlinkage void camellia_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);
    798 EXPORT_SYMBOL_GPL(camellia_ecb_enc_16way);
    799
    800 -asmlinkage void camellia_ecb_dec_16way(struct camellia_ctx *ctx, u8 *dst,
    801 - const u8 *src);
    802 +asmlinkage void camellia_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);
    803 EXPORT_SYMBOL_GPL(camellia_ecb_dec_16way);
    804
    805 -asmlinkage void camellia_cbc_dec_16way(struct camellia_ctx *ctx, u8 *dst,
    806 - const u8 *src);
    807 +asmlinkage void camellia_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);
    808 EXPORT_SYMBOL_GPL(camellia_cbc_dec_16way);
    809
    810 -asmlinkage void camellia_ctr_16way(struct camellia_ctx *ctx, u8 *dst,
    811 - const u8 *src, le128 *iv);
    812 +asmlinkage void camellia_ctr_16way(const void *ctx, u8 *dst, const u8 *src,
    813 + le128 *iv);
    814 EXPORT_SYMBOL_GPL(camellia_ctr_16way);
    815
    816 -asmlinkage void camellia_xts_enc_16way(struct camellia_ctx *ctx, u8 *dst,
    817 - const u8 *src, le128 *iv);
    818 +asmlinkage void camellia_xts_enc_16way(const void *ctx, u8 *dst, const u8 *src,
    819 + le128 *iv);
    820 EXPORT_SYMBOL_GPL(camellia_xts_enc_16way);
    821
    822 -asmlinkage void camellia_xts_dec_16way(struct camellia_ctx *ctx, u8 *dst,
    823 - const u8 *src, le128 *iv);
    824 +asmlinkage void camellia_xts_dec_16way(const void *ctx, u8 *dst, const u8 *src,
    825 + le128 *iv);
    826 EXPORT_SYMBOL_GPL(camellia_xts_dec_16way);
    827
    828 -void camellia_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    829 +void camellia_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    830 {
    831 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    832 - GLUE_FUNC_CAST(camellia_enc_blk));
    833 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, camellia_enc_blk);
    834 }
    835 EXPORT_SYMBOL_GPL(camellia_xts_enc);
    836
    837 -void camellia_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    838 +void camellia_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    839 {
    840 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    841 - GLUE_FUNC_CAST(camellia_dec_blk));
    842 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, camellia_dec_blk);
    843 }
    844 EXPORT_SYMBOL_GPL(camellia_xts_dec);
    845
    846 @@ -62,13 +57,13 @@ static const struct common_glue_ctx camellia_enc = {
    847
    848 .funcs = { {
    849 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    850 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_enc_16way) }
    851 + .fn_u = { .ecb = camellia_ecb_enc_16way }
    852 }, {
    853 .num_blocks = 2,
    854 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk_2way) }
    855 + .fn_u = { .ecb = camellia_enc_blk_2way }
    856 }, {
    857 .num_blocks = 1,
    858 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk) }
    859 + .fn_u = { .ecb = camellia_enc_blk }
    860 } }
    861 };
    862
    863 @@ -78,13 +73,13 @@ static const struct common_glue_ctx camellia_ctr = {
    864
    865 .funcs = { {
    866 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    867 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_ctr_16way) }
    868 + .fn_u = { .ctr = camellia_ctr_16way }
    869 }, {
    870 .num_blocks = 2,
    871 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) }
    872 + .fn_u = { .ctr = camellia_crypt_ctr_2way }
    873 }, {
    874 .num_blocks = 1,
    875 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) }
    876 + .fn_u = { .ctr = camellia_crypt_ctr }
    877 } }
    878 };
    879
    880 @@ -94,10 +89,10 @@ static const struct common_glue_ctx camellia_enc_xts = {
    881
    882 .funcs = { {
    883 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    884 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc_16way) }
    885 + .fn_u = { .xts = camellia_xts_enc_16way }
    886 }, {
    887 .num_blocks = 1,
    888 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_enc) }
    889 + .fn_u = { .xts = camellia_xts_enc }
    890 } }
    891 };
    892
    893 @@ -107,13 +102,13 @@ static const struct common_glue_ctx camellia_dec = {
    894
    895 .funcs = { {
    896 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    897 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_dec_16way) }
    898 + .fn_u = { .ecb = camellia_ecb_dec_16way }
    899 }, {
    900 .num_blocks = 2,
    901 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) }
    902 + .fn_u = { .ecb = camellia_dec_blk_2way }
    903 }, {
    904 .num_blocks = 1,
    905 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) }
    906 + .fn_u = { .ecb = camellia_dec_blk }
    907 } }
    908 };
    909
    910 @@ -123,13 +118,13 @@ static const struct common_glue_ctx camellia_dec_cbc = {
    911
    912 .funcs = { {
    913 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    914 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_cbc_dec_16way) }
    915 + .fn_u = { .cbc = camellia_cbc_dec_16way }
    916 }, {
    917 .num_blocks = 2,
    918 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) }
    919 + .fn_u = { .cbc = camellia_decrypt_cbc_2way }
    920 }, {
    921 .num_blocks = 1,
    922 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) }
    923 + .fn_u = { .cbc = camellia_dec_blk }
    924 } }
    925 };
    926
    927 @@ -139,10 +134,10 @@ static const struct common_glue_ctx camellia_dec_xts = {
    928
    929 .funcs = { {
    930 .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,
    931 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec_16way) }
    932 + .fn_u = { .xts = camellia_xts_dec_16way }
    933 }, {
    934 .num_blocks = 1,
    935 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(camellia_xts_dec) }
    936 + .fn_u = { .xts = camellia_xts_dec }
    937 } }
    938 };
    939
    940 @@ -165,8 +160,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    941
    942 static int cbc_encrypt(struct skcipher_request *req)
    943 {
    944 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(camellia_enc_blk),
    945 - req);
    946 + return glue_cbc_encrypt_req_128bit(camellia_enc_blk, req);
    947 }
    948
    949 static int cbc_decrypt(struct skcipher_request *req)
    950 @@ -206,8 +200,7 @@ static int xts_encrypt(struct skcipher_request *req)
    951 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    952 struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    953
    954 - return glue_xts_req_128bit(&camellia_enc_xts, req,
    955 - XTS_TWEAK_CAST(camellia_enc_blk),
    956 + return glue_xts_req_128bit(&camellia_enc_xts, req, camellia_enc_blk,
    957 &ctx->tweak_ctx, &ctx->crypt_ctx, false);
    958 }
    959
    960 @@ -216,8 +209,7 @@ static int xts_decrypt(struct skcipher_request *req)
    961 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    962 struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    963
    964 - return glue_xts_req_128bit(&camellia_dec_xts, req,
    965 - XTS_TWEAK_CAST(camellia_enc_blk),
    966 + return glue_xts_req_128bit(&camellia_dec_xts, req, camellia_enc_blk,
    967 &ctx->tweak_ctx, &ctx->crypt_ctx, true);
    968 }
    969
    970 diff --git a/arch/x86/crypto/camellia_glue.c b/arch/x86/crypto/camellia_glue.c
    971 index 7c62db56ffe1b..5f3ed5af68d70 100644
    972 --- a/arch/x86/crypto/camellia_glue.c
    973 +++ b/arch/x86/crypto/camellia_glue.c
    974 @@ -18,19 +18,17 @@
    975 #include <asm/crypto/glue_helper.h>
    976
    977 /* regular block cipher functions */
    978 -asmlinkage void __camellia_enc_blk(struct camellia_ctx *ctx, u8 *dst,
    979 - const u8 *src, bool xor);
    980 +asmlinkage void __camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src,
    981 + bool xor);
    982 EXPORT_SYMBOL_GPL(__camellia_enc_blk);
    983 -asmlinkage void camellia_dec_blk(struct camellia_ctx *ctx, u8 *dst,
    984 - const u8 *src);
    985 +asmlinkage void camellia_dec_blk(const void *ctx, u8 *dst, const u8 *src);
    986 EXPORT_SYMBOL_GPL(camellia_dec_blk);
    987
    988 /* 2-way parallel cipher functions */
    989 -asmlinkage void __camellia_enc_blk_2way(struct camellia_ctx *ctx, u8 *dst,
    990 - const u8 *src, bool xor);
    991 +asmlinkage void __camellia_enc_blk_2way(const void *ctx, u8 *dst, const u8 *src,
    992 + bool xor);
    993 EXPORT_SYMBOL_GPL(__camellia_enc_blk_2way);
    994 -asmlinkage void camellia_dec_blk_2way(struct camellia_ctx *ctx, u8 *dst,
    995 - const u8 *src);
    996 +asmlinkage void camellia_dec_blk_2way(const void *ctx, u8 *dst, const u8 *src);
    997 EXPORT_SYMBOL_GPL(camellia_dec_blk_2way);
    998
    999 static void camellia_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
    1000 @@ -1267,8 +1265,10 @@ static int camellia_setkey_skcipher(struct crypto_skcipher *tfm, const u8 *key,
    1001 return camellia_setkey(&tfm->base, key, key_len);
    1002 }
    1003
    1004 -void camellia_decrypt_cbc_2way(void *ctx, u128 *dst, const u128 *src)
    1005 +void camellia_decrypt_cbc_2way(const void *ctx, u8 *d, const u8 *s)
    1006 {
    1007 + u128 *dst = (u128 *)d;
    1008 + const u128 *src = (const u128 *)s;
    1009 u128 iv = *src;
    1010
    1011 camellia_dec_blk_2way(ctx, (u8 *)dst, (u8 *)src);
    1012 @@ -1277,9 +1277,11 @@ void camellia_decrypt_cbc_2way(void *ctx, u128 *dst, const u128 *src)
    1013 }
    1014 EXPORT_SYMBOL_GPL(camellia_decrypt_cbc_2way);
    1015
    1016 -void camellia_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1017 +void camellia_crypt_ctr(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    1018 {
    1019 be128 ctrblk;
    1020 + u128 *dst = (u128 *)d;
    1021 + const u128 *src = (const u128 *)s;
    1022
    1023 if (dst != src)
    1024 *dst = *src;
    1025 @@ -1291,9 +1293,11 @@ void camellia_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1026 }
    1027 EXPORT_SYMBOL_GPL(camellia_crypt_ctr);
    1028
    1029 -void camellia_crypt_ctr_2way(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1030 +void camellia_crypt_ctr_2way(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    1031 {
    1032 be128 ctrblks[2];
    1033 + u128 *dst = (u128 *)d;
    1034 + const u128 *src = (const u128 *)s;
    1035
    1036 if (dst != src) {
    1037 dst[0] = src[0];
    1038 @@ -1315,10 +1319,10 @@ static const struct common_glue_ctx camellia_enc = {
    1039
    1040 .funcs = { {
    1041 .num_blocks = 2,
    1042 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk_2way) }
    1043 + .fn_u = { .ecb = camellia_enc_blk_2way }
    1044 }, {
    1045 .num_blocks = 1,
    1046 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk) }
    1047 + .fn_u = { .ecb = camellia_enc_blk }
    1048 } }
    1049 };
    1050
    1051 @@ -1328,10 +1332,10 @@ static const struct common_glue_ctx camellia_ctr = {
    1052
    1053 .funcs = { {
    1054 .num_blocks = 2,
    1055 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) }
    1056 + .fn_u = { .ctr = camellia_crypt_ctr_2way }
    1057 }, {
    1058 .num_blocks = 1,
    1059 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) }
    1060 + .fn_u = { .ctr = camellia_crypt_ctr }
    1061 } }
    1062 };
    1063
    1064 @@ -1341,10 +1345,10 @@ static const struct common_glue_ctx camellia_dec = {
    1065
    1066 .funcs = { {
    1067 .num_blocks = 2,
    1068 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) }
    1069 + .fn_u = { .ecb = camellia_dec_blk_2way }
    1070 }, {
    1071 .num_blocks = 1,
    1072 - .fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) }
    1073 + .fn_u = { .ecb = camellia_dec_blk }
    1074 } }
    1075 };
    1076
    1077 @@ -1354,10 +1358,10 @@ static const struct common_glue_ctx camellia_dec_cbc = {
    1078
    1079 .funcs = { {
    1080 .num_blocks = 2,
    1081 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) }
    1082 + .fn_u = { .cbc = camellia_decrypt_cbc_2way }
    1083 }, {
    1084 .num_blocks = 1,
    1085 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) }
    1086 + .fn_u = { .cbc = camellia_dec_blk }
    1087 } }
    1088 };
    1089
    1090 @@ -1373,8 +1377,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    1091
    1092 static int cbc_encrypt(struct skcipher_request *req)
    1093 {
    1094 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(camellia_enc_blk),
    1095 - req);
    1096 + return glue_cbc_encrypt_req_128bit(camellia_enc_blk, req);
    1097 }
    1098
    1099 static int cbc_decrypt(struct skcipher_request *req)
    1100 diff --git a/arch/x86/crypto/cast6_avx_glue.c b/arch/x86/crypto/cast6_avx_glue.c
    1101 index a8a38fffb4a98..da5297475f9ec 100644
    1102 --- a/arch/x86/crypto/cast6_avx_glue.c
    1103 +++ b/arch/x86/crypto/cast6_avx_glue.c
    1104 @@ -20,20 +20,17 @@
    1105
    1106 #define CAST6_PARALLEL_BLOCKS 8
    1107
    1108 -asmlinkage void cast6_ecb_enc_8way(struct cast6_ctx *ctx, u8 *dst,
    1109 - const u8 *src);
    1110 -asmlinkage void cast6_ecb_dec_8way(struct cast6_ctx *ctx, u8 *dst,
    1111 - const u8 *src);
    1112 -
    1113 -asmlinkage void cast6_cbc_dec_8way(struct cast6_ctx *ctx, u8 *dst,
    1114 - const u8 *src);
    1115 -asmlinkage void cast6_ctr_8way(struct cast6_ctx *ctx, u8 *dst, const u8 *src,
    1116 +asmlinkage void cast6_ecb_enc_8way(const void *ctx, u8 *dst, const u8 *src);
    1117 +asmlinkage void cast6_ecb_dec_8way(const void *ctx, u8 *dst, const u8 *src);
    1118 +
    1119 +asmlinkage void cast6_cbc_dec_8way(const void *ctx, u8 *dst, const u8 *src);
    1120 +asmlinkage void cast6_ctr_8way(const void *ctx, u8 *dst, const u8 *src,
    1121 le128 *iv);
    1122
    1123 -asmlinkage void cast6_xts_enc_8way(struct cast6_ctx *ctx, u8 *dst,
    1124 - const u8 *src, le128 *iv);
    1125 -asmlinkage void cast6_xts_dec_8way(struct cast6_ctx *ctx, u8 *dst,
    1126 - const u8 *src, le128 *iv);
    1127 +asmlinkage void cast6_xts_enc_8way(const void *ctx, u8 *dst, const u8 *src,
    1128 + le128 *iv);
    1129 +asmlinkage void cast6_xts_dec_8way(const void *ctx, u8 *dst, const u8 *src,
    1130 + le128 *iv);
    1131
    1132 static int cast6_setkey_skcipher(struct crypto_skcipher *tfm,
    1133 const u8 *key, unsigned int keylen)
    1134 @@ -41,21 +38,21 @@ static int cast6_setkey_skcipher(struct crypto_skcipher *tfm,
    1135 return cast6_setkey(&tfm->base, key, keylen);
    1136 }
    1137
    1138 -static void cast6_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1139 +static void cast6_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    1140 {
    1141 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    1142 - GLUE_FUNC_CAST(__cast6_encrypt));
    1143 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, __cast6_encrypt);
    1144 }
    1145
    1146 -static void cast6_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1147 +static void cast6_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    1148 {
    1149 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    1150 - GLUE_FUNC_CAST(__cast6_decrypt));
    1151 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, __cast6_decrypt);
    1152 }
    1153
    1154 -static void cast6_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1155 +static void cast6_crypt_ctr(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    1156 {
    1157 be128 ctrblk;
    1158 + u128 *dst = (u128 *)d;
    1159 + const u128 *src = (const u128 *)s;
    1160
    1161 le128_to_be128(&ctrblk, iv);
    1162 le128_inc(iv);
    1163 @@ -70,10 +67,10 @@ static const struct common_glue_ctx cast6_enc = {
    1164
    1165 .funcs = { {
    1166 .num_blocks = CAST6_PARALLEL_BLOCKS,
    1167 - .fn_u = { .ecb = GLUE_FUNC_CAST(cast6_ecb_enc_8way) }
    1168 + .fn_u = { .ecb = cast6_ecb_enc_8way }
    1169 }, {
    1170 .num_blocks = 1,
    1171 - .fn_u = { .ecb = GLUE_FUNC_CAST(__cast6_encrypt) }
    1172 + .fn_u = { .ecb = __cast6_encrypt }
    1173 } }
    1174 };
    1175
    1176 @@ -83,10 +80,10 @@ static const struct common_glue_ctx cast6_ctr = {
    1177
    1178 .funcs = { {
    1179 .num_blocks = CAST6_PARALLEL_BLOCKS,
    1180 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(cast6_ctr_8way) }
    1181 + .fn_u = { .ctr = cast6_ctr_8way }
    1182 }, {
    1183 .num_blocks = 1,
    1184 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(cast6_crypt_ctr) }
    1185 + .fn_u = { .ctr = cast6_crypt_ctr }
    1186 } }
    1187 };
    1188
    1189 @@ -96,10 +93,10 @@ static const struct common_glue_ctx cast6_enc_xts = {
    1190
    1191 .funcs = { {
    1192 .num_blocks = CAST6_PARALLEL_BLOCKS,
    1193 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_enc_8way) }
    1194 + .fn_u = { .xts = cast6_xts_enc_8way }
    1195 }, {
    1196 .num_blocks = 1,
    1197 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_enc) }
    1198 + .fn_u = { .xts = cast6_xts_enc }
    1199 } }
    1200 };
    1201
    1202 @@ -109,10 +106,10 @@ static const struct common_glue_ctx cast6_dec = {
    1203
    1204 .funcs = { {
    1205 .num_blocks = CAST6_PARALLEL_BLOCKS,
    1206 - .fn_u = { .ecb = GLUE_FUNC_CAST(cast6_ecb_dec_8way) }
    1207 + .fn_u = { .ecb = cast6_ecb_dec_8way }
    1208 }, {
    1209 .num_blocks = 1,
    1210 - .fn_u = { .ecb = GLUE_FUNC_CAST(__cast6_decrypt) }
    1211 + .fn_u = { .ecb = __cast6_decrypt }
    1212 } }
    1213 };
    1214
    1215 @@ -122,10 +119,10 @@ static const struct common_glue_ctx cast6_dec_cbc = {
    1216
    1217 .funcs = { {
    1218 .num_blocks = CAST6_PARALLEL_BLOCKS,
    1219 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(cast6_cbc_dec_8way) }
    1220 + .fn_u = { .cbc = cast6_cbc_dec_8way }
    1221 }, {
    1222 .num_blocks = 1,
    1223 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__cast6_decrypt) }
    1224 + .fn_u = { .cbc = __cast6_decrypt }
    1225 } }
    1226 };
    1227
    1228 @@ -135,10 +132,10 @@ static const struct common_glue_ctx cast6_dec_xts = {
    1229
    1230 .funcs = { {
    1231 .num_blocks = CAST6_PARALLEL_BLOCKS,
    1232 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_dec_8way) }
    1233 + .fn_u = { .xts = cast6_xts_dec_8way }
    1234 }, {
    1235 .num_blocks = 1,
    1236 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(cast6_xts_dec) }
    1237 + .fn_u = { .xts = cast6_xts_dec }
    1238 } }
    1239 };
    1240
    1241 @@ -154,8 +151,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    1242
    1243 static int cbc_encrypt(struct skcipher_request *req)
    1244 {
    1245 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__cast6_encrypt),
    1246 - req);
    1247 + return glue_cbc_encrypt_req_128bit(__cast6_encrypt, req);
    1248 }
    1249
    1250 static int cbc_decrypt(struct skcipher_request *req)
    1251 @@ -199,8 +195,7 @@ static int xts_encrypt(struct skcipher_request *req)
    1252 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    1253 struct cast6_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1254
    1255 - return glue_xts_req_128bit(&cast6_enc_xts, req,
    1256 - XTS_TWEAK_CAST(__cast6_encrypt),
    1257 + return glue_xts_req_128bit(&cast6_enc_xts, req, __cast6_encrypt,
    1258 &ctx->tweak_ctx, &ctx->crypt_ctx, false);
    1259 }
    1260
    1261 @@ -209,8 +204,7 @@ static int xts_decrypt(struct skcipher_request *req)
    1262 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    1263 struct cast6_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1264
    1265 - return glue_xts_req_128bit(&cast6_dec_xts, req,
    1266 - XTS_TWEAK_CAST(__cast6_encrypt),
    1267 + return glue_xts_req_128bit(&cast6_dec_xts, req, __cast6_encrypt,
    1268 &ctx->tweak_ctx, &ctx->crypt_ctx, true);
    1269 }
    1270
    1271 diff --git a/arch/x86/crypto/glue_helper.c b/arch/x86/crypto/glue_helper.c
    1272 index d15b99397480b..d3d91a0abf88f 100644
    1273 --- a/arch/x86/crypto/glue_helper.c
    1274 +++ b/arch/x86/crypto/glue_helper.c
    1275 @@ -134,7 +134,8 @@ int glue_cbc_decrypt_req_128bit(const struct common_glue_ctx *gctx,
    1276 src -= num_blocks - 1;
    1277 dst -= num_blocks - 1;
    1278
    1279 - gctx->funcs[i].fn_u.cbc(ctx, dst, src);
    1280 + gctx->funcs[i].fn_u.cbc(ctx, (u8 *)dst,
    1281 + (const u8 *)src);
    1282
    1283 nbytes -= func_bytes;
    1284 if (nbytes < bsize)
    1285 @@ -188,7 +189,9 @@ int glue_ctr_req_128bit(const struct common_glue_ctx *gctx,
    1286
    1287 /* Process multi-block batch */
    1288 do {
    1289 - gctx->funcs[i].fn_u.ctr(ctx, dst, src, &ctrblk);
    1290 + gctx->funcs[i].fn_u.ctr(ctx, (u8 *)dst,
    1291 + (const u8 *)src,
    1292 + &ctrblk);
    1293 src += num_blocks;
    1294 dst += num_blocks;
    1295 nbytes -= func_bytes;
    1296 @@ -210,7 +213,8 @@ int glue_ctr_req_128bit(const struct common_glue_ctx *gctx,
    1297
    1298 be128_to_le128(&ctrblk, (be128 *)walk.iv);
    1299 memcpy(&tmp, walk.src.virt.addr, nbytes);
    1300 - gctx->funcs[gctx->num_funcs - 1].fn_u.ctr(ctx, &tmp, &tmp,
    1301 + gctx->funcs[gctx->num_funcs - 1].fn_u.ctr(ctx, (u8 *)&tmp,
    1302 + (const u8 *)&tmp,
    1303 &ctrblk);
    1304 memcpy(walk.dst.virt.addr, &tmp, nbytes);
    1305 le128_to_be128((be128 *)walk.iv, &ctrblk);
    1306 @@ -240,7 +244,8 @@ static unsigned int __glue_xts_req_128bit(const struct common_glue_ctx *gctx,
    1307
    1308 if (nbytes >= func_bytes) {
    1309 do {
    1310 - gctx->funcs[i].fn_u.xts(ctx, dst, src,
    1311 + gctx->funcs[i].fn_u.xts(ctx, (u8 *)dst,
    1312 + (const u8 *)src,
    1313 walk->iv);
    1314
    1315 src += num_blocks;
    1316 @@ -354,8 +359,8 @@ out:
    1317 }
    1318 EXPORT_SYMBOL_GPL(glue_xts_req_128bit);
    1319
    1320 -void glue_xts_crypt_128bit_one(void *ctx, u128 *dst, const u128 *src, le128 *iv,
    1321 - common_glue_func_t fn)
    1322 +void glue_xts_crypt_128bit_one(const void *ctx, u8 *dst, const u8 *src,
    1323 + le128 *iv, common_glue_func_t fn)
    1324 {
    1325 le128 ivblk = *iv;
    1326
    1327 @@ -363,13 +368,13 @@ void glue_xts_crypt_128bit_one(void *ctx, u128 *dst, const u128 *src, le128 *iv,
    1328 gf128mul_x_ble(iv, &ivblk);
    1329
    1330 /* CC <- T xor C */
    1331 - u128_xor(dst, src, (u128 *)&ivblk);
    1332 + u128_xor((u128 *)dst, (const u128 *)src, (u128 *)&ivblk);
    1333
    1334 /* PP <- D(Key2,CC) */
    1335 - fn(ctx, (u8 *)dst, (u8 *)dst);
    1336 + fn(ctx, dst, dst);
    1337
    1338 /* P <- T xor PP */
    1339 - u128_xor(dst, dst, (u128 *)&ivblk);
    1340 + u128_xor((u128 *)dst, (u128 *)dst, (u128 *)&ivblk);
    1341 }
    1342 EXPORT_SYMBOL_GPL(glue_xts_crypt_128bit_one);
    1343
    1344 diff --git a/arch/x86/crypto/serpent_avx2_glue.c b/arch/x86/crypto/serpent_avx2_glue.c
    1345 index 13fd8d3d2da00..f973ace44ad35 100644
    1346 --- a/arch/x86/crypto/serpent_avx2_glue.c
    1347 +++ b/arch/x86/crypto/serpent_avx2_glue.c
    1348 @@ -19,18 +19,16 @@
    1349 #define SERPENT_AVX2_PARALLEL_BLOCKS 16
    1350
    1351 /* 16-way AVX2 parallel cipher functions */
    1352 -asmlinkage void serpent_ecb_enc_16way(struct serpent_ctx *ctx, u8 *dst,
    1353 - const u8 *src);
    1354 -asmlinkage void serpent_ecb_dec_16way(struct serpent_ctx *ctx, u8 *dst,
    1355 - const u8 *src);
    1356 -asmlinkage void serpent_cbc_dec_16way(void *ctx, u128 *dst, const u128 *src);
    1357 +asmlinkage void serpent_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);
    1358 +asmlinkage void serpent_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);
    1359 +asmlinkage void serpent_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);
    1360
    1361 -asmlinkage void serpent_ctr_16way(void *ctx, u128 *dst, const u128 *src,
    1362 +asmlinkage void serpent_ctr_16way(const void *ctx, u8 *dst, const u8 *src,
    1363 le128 *iv);
    1364 -asmlinkage void serpent_xts_enc_16way(struct serpent_ctx *ctx, u8 *dst,
    1365 - const u8 *src, le128 *iv);
    1366 -asmlinkage void serpent_xts_dec_16way(struct serpent_ctx *ctx, u8 *dst,
    1367 - const u8 *src, le128 *iv);
    1368 +asmlinkage void serpent_xts_enc_16way(const void *ctx, u8 *dst, const u8 *src,
    1369 + le128 *iv);
    1370 +asmlinkage void serpent_xts_dec_16way(const void *ctx, u8 *dst, const u8 *src,
    1371 + le128 *iv);
    1372
    1373 static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
    1374 const u8 *key, unsigned int keylen)
    1375 @@ -44,13 +42,13 @@ static const struct common_glue_ctx serpent_enc = {
    1376
    1377 .funcs = { {
    1378 .num_blocks = 16,
    1379 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_16way) }
    1380 + .fn_u = { .ecb = serpent_ecb_enc_16way }
    1381 }, {
    1382 .num_blocks = 8,
    1383 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) }
    1384 + .fn_u = { .ecb = serpent_ecb_enc_8way_avx }
    1385 }, {
    1386 .num_blocks = 1,
    1387 - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) }
    1388 + .fn_u = { .ecb = __serpent_encrypt }
    1389 } }
    1390 };
    1391
    1392 @@ -60,13 +58,13 @@ static const struct common_glue_ctx serpent_ctr = {
    1393
    1394 .funcs = { {
    1395 .num_blocks = 16,
    1396 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_16way) }
    1397 + .fn_u = { .ctr = serpent_ctr_16way }
    1398 }, {
    1399 .num_blocks = 8,
    1400 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) }
    1401 + .fn_u = { .ctr = serpent_ctr_8way_avx }
    1402 }, {
    1403 .num_blocks = 1,
    1404 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) }
    1405 + .fn_u = { .ctr = __serpent_crypt_ctr }
    1406 } }
    1407 };
    1408
    1409 @@ -76,13 +74,13 @@ static const struct common_glue_ctx serpent_enc_xts = {
    1410
    1411 .funcs = { {
    1412 .num_blocks = 16,
    1413 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_16way) }
    1414 + .fn_u = { .xts = serpent_xts_enc_16way }
    1415 }, {
    1416 .num_blocks = 8,
    1417 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) }
    1418 + .fn_u = { .xts = serpent_xts_enc_8way_avx }
    1419 }, {
    1420 .num_blocks = 1,
    1421 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) }
    1422 + .fn_u = { .xts = serpent_xts_enc }
    1423 } }
    1424 };
    1425
    1426 @@ -92,13 +90,13 @@ static const struct common_glue_ctx serpent_dec = {
    1427
    1428 .funcs = { {
    1429 .num_blocks = 16,
    1430 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_16way) }
    1431 + .fn_u = { .ecb = serpent_ecb_dec_16way }
    1432 }, {
    1433 .num_blocks = 8,
    1434 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) }
    1435 + .fn_u = { .ecb = serpent_ecb_dec_8way_avx }
    1436 }, {
    1437 .num_blocks = 1,
    1438 - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) }
    1439 + .fn_u = { .ecb = __serpent_decrypt }
    1440 } }
    1441 };
    1442
    1443 @@ -108,13 +106,13 @@ static const struct common_glue_ctx serpent_dec_cbc = {
    1444
    1445 .funcs = { {
    1446 .num_blocks = 16,
    1447 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_16way) }
    1448 + .fn_u = { .cbc = serpent_cbc_dec_16way }
    1449 }, {
    1450 .num_blocks = 8,
    1451 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) }
    1452 + .fn_u = { .cbc = serpent_cbc_dec_8way_avx }
    1453 }, {
    1454 .num_blocks = 1,
    1455 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) }
    1456 + .fn_u = { .cbc = __serpent_decrypt }
    1457 } }
    1458 };
    1459
    1460 @@ -124,13 +122,13 @@ static const struct common_glue_ctx serpent_dec_xts = {
    1461
    1462 .funcs = { {
    1463 .num_blocks = 16,
    1464 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_16way) }
    1465 + .fn_u = { .xts = serpent_xts_dec_16way }
    1466 }, {
    1467 .num_blocks = 8,
    1468 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) }
    1469 + .fn_u = { .xts = serpent_xts_dec_8way_avx }
    1470 }, {
    1471 .num_blocks = 1,
    1472 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) }
    1473 + .fn_u = { .xts = serpent_xts_dec }
    1474 } }
    1475 };
    1476
    1477 @@ -146,8 +144,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    1478
    1479 static int cbc_encrypt(struct skcipher_request *req)
    1480 {
    1481 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
    1482 - req);
    1483 + return glue_cbc_encrypt_req_128bit(__serpent_encrypt, req);
    1484 }
    1485
    1486 static int cbc_decrypt(struct skcipher_request *req)
    1487 @@ -166,8 +163,8 @@ static int xts_encrypt(struct skcipher_request *req)
    1488 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1489
    1490 return glue_xts_req_128bit(&serpent_enc_xts, req,
    1491 - XTS_TWEAK_CAST(__serpent_encrypt),
    1492 - &ctx->tweak_ctx, &ctx->crypt_ctx, false);
    1493 + __serpent_encrypt, &ctx->tweak_ctx,
    1494 + &ctx->crypt_ctx, false);
    1495 }
    1496
    1497 static int xts_decrypt(struct skcipher_request *req)
    1498 @@ -176,8 +173,8 @@ static int xts_decrypt(struct skcipher_request *req)
    1499 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1500
    1501 return glue_xts_req_128bit(&serpent_dec_xts, req,
    1502 - XTS_TWEAK_CAST(__serpent_encrypt),
    1503 - &ctx->tweak_ctx, &ctx->crypt_ctx, true);
    1504 + __serpent_encrypt, &ctx->tweak_ctx,
    1505 + &ctx->crypt_ctx, true);
    1506 }
    1507
    1508 static struct skcipher_alg serpent_algs[] = {
    1509 diff --git a/arch/x86/crypto/serpent_avx_glue.c b/arch/x86/crypto/serpent_avx_glue.c
    1510 index 7d3dca38a5a2e..7806d1cbe8541 100644
    1511 --- a/arch/x86/crypto/serpent_avx_glue.c
    1512 +++ b/arch/x86/crypto/serpent_avx_glue.c
    1513 @@ -20,33 +20,35 @@
    1514 #include <asm/crypto/serpent-avx.h>
    1515
    1516 /* 8-way parallel cipher functions */
    1517 -asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    1518 +asmlinkage void serpent_ecb_enc_8way_avx(const void *ctx, u8 *dst,
    1519 const u8 *src);
    1520 EXPORT_SYMBOL_GPL(serpent_ecb_enc_8way_avx);
    1521
    1522 -asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    1523 +asmlinkage void serpent_ecb_dec_8way_avx(const void *ctx, u8 *dst,
    1524 const u8 *src);
    1525 EXPORT_SYMBOL_GPL(serpent_ecb_dec_8way_avx);
    1526
    1527 -asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    1528 +asmlinkage void serpent_cbc_dec_8way_avx(const void *ctx, u8 *dst,
    1529 const u8 *src);
    1530 EXPORT_SYMBOL_GPL(serpent_cbc_dec_8way_avx);
    1531
    1532 -asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    1533 - const u8 *src, le128 *iv);
    1534 +asmlinkage void serpent_ctr_8way_avx(const void *ctx, u8 *dst, const u8 *src,
    1535 + le128 *iv);
    1536 EXPORT_SYMBOL_GPL(serpent_ctr_8way_avx);
    1537
    1538 -asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    1539 +asmlinkage void serpent_xts_enc_8way_avx(const void *ctx, u8 *dst,
    1540 const u8 *src, le128 *iv);
    1541 EXPORT_SYMBOL_GPL(serpent_xts_enc_8way_avx);
    1542
    1543 -asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    1544 +asmlinkage void serpent_xts_dec_8way_avx(const void *ctx, u8 *dst,
    1545 const u8 *src, le128 *iv);
    1546 EXPORT_SYMBOL_GPL(serpent_xts_dec_8way_avx);
    1547
    1548 -void __serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1549 +void __serpent_crypt_ctr(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    1550 {
    1551 be128 ctrblk;
    1552 + u128 *dst = (u128 *)d;
    1553 + const u128 *src = (const u128 *)s;
    1554
    1555 le128_to_be128(&ctrblk, iv);
    1556 le128_inc(iv);
    1557 @@ -56,17 +58,15 @@ void __serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1558 }
    1559 EXPORT_SYMBOL_GPL(__serpent_crypt_ctr);
    1560
    1561 -void serpent_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1562 +void serpent_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    1563 {
    1564 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    1565 - GLUE_FUNC_CAST(__serpent_encrypt));
    1566 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, __serpent_encrypt);
    1567 }
    1568 EXPORT_SYMBOL_GPL(serpent_xts_enc);
    1569
    1570 -void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1571 +void serpent_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    1572 {
    1573 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    1574 - GLUE_FUNC_CAST(__serpent_decrypt));
    1575 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, __serpent_decrypt);
    1576 }
    1577 EXPORT_SYMBOL_GPL(serpent_xts_dec);
    1578
    1579 @@ -102,10 +102,10 @@ static const struct common_glue_ctx serpent_enc = {
    1580
    1581 .funcs = { {
    1582 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1583 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) }
    1584 + .fn_u = { .ecb = serpent_ecb_enc_8way_avx }
    1585 }, {
    1586 .num_blocks = 1,
    1587 - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) }
    1588 + .fn_u = { .ecb = __serpent_encrypt }
    1589 } }
    1590 };
    1591
    1592 @@ -115,10 +115,10 @@ static const struct common_glue_ctx serpent_ctr = {
    1593
    1594 .funcs = { {
    1595 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1596 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) }
    1597 + .fn_u = { .ctr = serpent_ctr_8way_avx }
    1598 }, {
    1599 .num_blocks = 1,
    1600 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) }
    1601 + .fn_u = { .ctr = __serpent_crypt_ctr }
    1602 } }
    1603 };
    1604
    1605 @@ -128,10 +128,10 @@ static const struct common_glue_ctx serpent_enc_xts = {
    1606
    1607 .funcs = { {
    1608 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1609 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) }
    1610 + .fn_u = { .xts = serpent_xts_enc_8way_avx }
    1611 }, {
    1612 .num_blocks = 1,
    1613 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) }
    1614 + .fn_u = { .xts = serpent_xts_enc }
    1615 } }
    1616 };
    1617
    1618 @@ -141,10 +141,10 @@ static const struct common_glue_ctx serpent_dec = {
    1619
    1620 .funcs = { {
    1621 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1622 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) }
    1623 + .fn_u = { .ecb = serpent_ecb_dec_8way_avx }
    1624 }, {
    1625 .num_blocks = 1,
    1626 - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) }
    1627 + .fn_u = { .ecb = __serpent_decrypt }
    1628 } }
    1629 };
    1630
    1631 @@ -154,10 +154,10 @@ static const struct common_glue_ctx serpent_dec_cbc = {
    1632
    1633 .funcs = { {
    1634 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1635 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) }
    1636 + .fn_u = { .cbc = serpent_cbc_dec_8way_avx }
    1637 }, {
    1638 .num_blocks = 1,
    1639 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) }
    1640 + .fn_u = { .cbc = __serpent_decrypt }
    1641 } }
    1642 };
    1643
    1644 @@ -167,10 +167,10 @@ static const struct common_glue_ctx serpent_dec_xts = {
    1645
    1646 .funcs = { {
    1647 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1648 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) }
    1649 + .fn_u = { .xts = serpent_xts_dec_8way_avx }
    1650 }, {
    1651 .num_blocks = 1,
    1652 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) }
    1653 + .fn_u = { .xts = serpent_xts_dec }
    1654 } }
    1655 };
    1656
    1657 @@ -186,8 +186,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    1658
    1659 static int cbc_encrypt(struct skcipher_request *req)
    1660 {
    1661 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
    1662 - req);
    1663 + return glue_cbc_encrypt_req_128bit(__serpent_encrypt, req);
    1664 }
    1665
    1666 static int cbc_decrypt(struct skcipher_request *req)
    1667 @@ -206,8 +205,8 @@ static int xts_encrypt(struct skcipher_request *req)
    1668 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1669
    1670 return glue_xts_req_128bit(&serpent_enc_xts, req,
    1671 - XTS_TWEAK_CAST(__serpent_encrypt),
    1672 - &ctx->tweak_ctx, &ctx->crypt_ctx, false);
    1673 + __serpent_encrypt, &ctx->tweak_ctx,
    1674 + &ctx->crypt_ctx, false);
    1675 }
    1676
    1677 static int xts_decrypt(struct skcipher_request *req)
    1678 @@ -216,8 +215,8 @@ static int xts_decrypt(struct skcipher_request *req)
    1679 struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1680
    1681 return glue_xts_req_128bit(&serpent_dec_xts, req,
    1682 - XTS_TWEAK_CAST(__serpent_encrypt),
    1683 - &ctx->tweak_ctx, &ctx->crypt_ctx, true);
    1684 + __serpent_encrypt, &ctx->tweak_ctx,
    1685 + &ctx->crypt_ctx, true);
    1686 }
    1687
    1688 static struct skcipher_alg serpent_algs[] = {
    1689 diff --git a/arch/x86/crypto/serpent_sse2_glue.c b/arch/x86/crypto/serpent_sse2_glue.c
    1690 index 5fdf1931d0690..4fed8d26b91a4 100644
    1691 --- a/arch/x86/crypto/serpent_sse2_glue.c
    1692 +++ b/arch/x86/crypto/serpent_sse2_glue.c
    1693 @@ -31,9 +31,11 @@ static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
    1694 return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
    1695 }
    1696
    1697 -static void serpent_decrypt_cbc_xway(void *ctx, u128 *dst, const u128 *src)
    1698 +static void serpent_decrypt_cbc_xway(const void *ctx, u8 *d, const u8 *s)
    1699 {
    1700 u128 ivs[SERPENT_PARALLEL_BLOCKS - 1];
    1701 + u128 *dst = (u128 *)d;
    1702 + const u128 *src = (const u128 *)s;
    1703 unsigned int j;
    1704
    1705 for (j = 0; j < SERPENT_PARALLEL_BLOCKS - 1; j++)
    1706 @@ -45,9 +47,11 @@ static void serpent_decrypt_cbc_xway(void *ctx, u128 *dst, const u128 *src)
    1707 u128_xor(dst + (j + 1), dst + (j + 1), ivs + j);
    1708 }
    1709
    1710 -static void serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1711 +static void serpent_crypt_ctr(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    1712 {
    1713 be128 ctrblk;
    1714 + u128 *dst = (u128 *)d;
    1715 + const u128 *src = (const u128 *)s;
    1716
    1717 le128_to_be128(&ctrblk, iv);
    1718 le128_inc(iv);
    1719 @@ -56,10 +60,12 @@ static void serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1720 u128_xor(dst, src, (u128 *)&ctrblk);
    1721 }
    1722
    1723 -static void serpent_crypt_ctr_xway(void *ctx, u128 *dst, const u128 *src,
    1724 +static void serpent_crypt_ctr_xway(const void *ctx, u8 *d, const u8 *s,
    1725 le128 *iv)
    1726 {
    1727 be128 ctrblks[SERPENT_PARALLEL_BLOCKS];
    1728 + u128 *dst = (u128 *)d;
    1729 + const u128 *src = (const u128 *)s;
    1730 unsigned int i;
    1731
    1732 for (i = 0; i < SERPENT_PARALLEL_BLOCKS; i++) {
    1733 @@ -79,10 +85,10 @@ static const struct common_glue_ctx serpent_enc = {
    1734
    1735 .funcs = { {
    1736 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1737 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_enc_blk_xway) }
    1738 + .fn_u = { .ecb = serpent_enc_blk_xway }
    1739 }, {
    1740 .num_blocks = 1,
    1741 - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) }
    1742 + .fn_u = { .ecb = __serpent_encrypt }
    1743 } }
    1744 };
    1745
    1746 @@ -92,10 +98,10 @@ static const struct common_glue_ctx serpent_ctr = {
    1747
    1748 .funcs = { {
    1749 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1750 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr_xway) }
    1751 + .fn_u = { .ctr = serpent_crypt_ctr_xway }
    1752 }, {
    1753 .num_blocks = 1,
    1754 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr) }
    1755 + .fn_u = { .ctr = serpent_crypt_ctr }
    1756 } }
    1757 };
    1758
    1759 @@ -105,10 +111,10 @@ static const struct common_glue_ctx serpent_dec = {
    1760
    1761 .funcs = { {
    1762 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1763 - .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_dec_blk_xway) }
    1764 + .fn_u = { .ecb = serpent_dec_blk_xway }
    1765 }, {
    1766 .num_blocks = 1,
    1767 - .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) }
    1768 + .fn_u = { .ecb = __serpent_decrypt }
    1769 } }
    1770 };
    1771
    1772 @@ -118,10 +124,10 @@ static const struct common_glue_ctx serpent_dec_cbc = {
    1773
    1774 .funcs = { {
    1775 .num_blocks = SERPENT_PARALLEL_BLOCKS,
    1776 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_decrypt_cbc_xway) }
    1777 + .fn_u = { .cbc = serpent_decrypt_cbc_xway }
    1778 }, {
    1779 .num_blocks = 1,
    1780 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) }
    1781 + .fn_u = { .cbc = __serpent_decrypt }
    1782 } }
    1783 };
    1784
    1785 @@ -137,7 +143,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    1786
    1787 static int cbc_encrypt(struct skcipher_request *req)
    1788 {
    1789 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
    1790 + return glue_cbc_encrypt_req_128bit(__serpent_encrypt,
    1791 req);
    1792 }
    1793
    1794 diff --git a/arch/x86/crypto/twofish_avx_glue.c b/arch/x86/crypto/twofish_avx_glue.c
    1795 index d561c821788b7..3b36e97ec7abb 100644
    1796 --- a/arch/x86/crypto/twofish_avx_glue.c
    1797 +++ b/arch/x86/crypto/twofish_avx_glue.c
    1798 @@ -22,20 +22,17 @@
    1799 #define TWOFISH_PARALLEL_BLOCKS 8
    1800
    1801 /* 8-way parallel cipher functions */
    1802 -asmlinkage void twofish_ecb_enc_8way(struct twofish_ctx *ctx, u8 *dst,
    1803 - const u8 *src);
    1804 -asmlinkage void twofish_ecb_dec_8way(struct twofish_ctx *ctx, u8 *dst,
    1805 - const u8 *src);
    1806 +asmlinkage void twofish_ecb_enc_8way(const void *ctx, u8 *dst, const u8 *src);
    1807 +asmlinkage void twofish_ecb_dec_8way(const void *ctx, u8 *dst, const u8 *src);
    1808
    1809 -asmlinkage void twofish_cbc_dec_8way(struct twofish_ctx *ctx, u8 *dst,
    1810 - const u8 *src);
    1811 -asmlinkage void twofish_ctr_8way(struct twofish_ctx *ctx, u8 *dst,
    1812 - const u8 *src, le128 *iv);
    1813 +asmlinkage void twofish_cbc_dec_8way(const void *ctx, u8 *dst, const u8 *src);
    1814 +asmlinkage void twofish_ctr_8way(const void *ctx, u8 *dst, const u8 *src,
    1815 + le128 *iv);
    1816
    1817 -asmlinkage void twofish_xts_enc_8way(struct twofish_ctx *ctx, u8 *dst,
    1818 - const u8 *src, le128 *iv);
    1819 -asmlinkage void twofish_xts_dec_8way(struct twofish_ctx *ctx, u8 *dst,
    1820 - const u8 *src, le128 *iv);
    1821 +asmlinkage void twofish_xts_enc_8way(const void *ctx, u8 *dst, const u8 *src,
    1822 + le128 *iv);
    1823 +asmlinkage void twofish_xts_dec_8way(const void *ctx, u8 *dst, const u8 *src,
    1824 + le128 *iv);
    1825
    1826 static int twofish_setkey_skcipher(struct crypto_skcipher *tfm,
    1827 const u8 *key, unsigned int keylen)
    1828 @@ -43,22 +40,19 @@ static int twofish_setkey_skcipher(struct crypto_skcipher *tfm,
    1829 return twofish_setkey(&tfm->base, key, keylen);
    1830 }
    1831
    1832 -static inline void twofish_enc_blk_3way(struct twofish_ctx *ctx, u8 *dst,
    1833 - const u8 *src)
    1834 +static inline void twofish_enc_blk_3way(const void *ctx, u8 *dst, const u8 *src)
    1835 {
    1836 __twofish_enc_blk_3way(ctx, dst, src, false);
    1837 }
    1838
    1839 -static void twofish_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1840 +static void twofish_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    1841 {
    1842 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    1843 - GLUE_FUNC_CAST(twofish_enc_blk));
    1844 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, twofish_enc_blk);
    1845 }
    1846
    1847 -static void twofish_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    1848 +static void twofish_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv)
    1849 {
    1850 - glue_xts_crypt_128bit_one(ctx, dst, src, iv,
    1851 - GLUE_FUNC_CAST(twofish_dec_blk));
    1852 + glue_xts_crypt_128bit_one(ctx, dst, src, iv, twofish_dec_blk);
    1853 }
    1854
    1855 struct twofish_xts_ctx {
    1856 @@ -93,13 +87,13 @@ static const struct common_glue_ctx twofish_enc = {
    1857
    1858 .funcs = { {
    1859 .num_blocks = TWOFISH_PARALLEL_BLOCKS,
    1860 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_ecb_enc_8way) }
    1861 + .fn_u = { .ecb = twofish_ecb_enc_8way }
    1862 }, {
    1863 .num_blocks = 3,
    1864 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_3way) }
    1865 + .fn_u = { .ecb = twofish_enc_blk_3way }
    1866 }, {
    1867 .num_blocks = 1,
    1868 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk) }
    1869 + .fn_u = { .ecb = twofish_enc_blk }
    1870 } }
    1871 };
    1872
    1873 @@ -109,13 +103,13 @@ static const struct common_glue_ctx twofish_ctr = {
    1874
    1875 .funcs = { {
    1876 .num_blocks = TWOFISH_PARALLEL_BLOCKS,
    1877 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_ctr_8way) }
    1878 + .fn_u = { .ctr = twofish_ctr_8way }
    1879 }, {
    1880 .num_blocks = 3,
    1881 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_enc_blk_ctr_3way) }
    1882 + .fn_u = { .ctr = twofish_enc_blk_ctr_3way }
    1883 }, {
    1884 .num_blocks = 1,
    1885 - .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(twofish_enc_blk_ctr) }
    1886 + .fn_u = { .ctr = twofish_enc_blk_ctr }
    1887 } }
    1888 };
    1889
    1890 @@ -125,10 +119,10 @@ static const struct common_glue_ctx twofish_enc_xts = {
    1891
    1892 .funcs = { {
    1893 .num_blocks = TWOFISH_PARALLEL_BLOCKS,
    1894 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_enc_8way) }
    1895 + .fn_u = { .xts = twofish_xts_enc_8way }
    1896 }, {
    1897 .num_blocks = 1,
    1898 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_enc) }
    1899 + .fn_u = { .xts = twofish_xts_enc }
    1900 } }
    1901 };
    1902
    1903 @@ -138,13 +132,13 @@ static const struct common_glue_ctx twofish_dec = {
    1904
    1905 .funcs = { {
    1906 .num_blocks = TWOFISH_PARALLEL_BLOCKS,
    1907 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_ecb_dec_8way) }
    1908 + .fn_u = { .ecb = twofish_ecb_dec_8way }
    1909 }, {
    1910 .num_blocks = 3,
    1911 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk_3way) }
    1912 + .fn_u = { .ecb = twofish_dec_blk_3way }
    1913 }, {
    1914 .num_blocks = 1,
    1915 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk) }
    1916 + .fn_u = { .ecb = twofish_dec_blk }
    1917 } }
    1918 };
    1919
    1920 @@ -154,13 +148,13 @@ static const struct common_glue_ctx twofish_dec_cbc = {
    1921
    1922 .funcs = { {
    1923 .num_blocks = TWOFISH_PARALLEL_BLOCKS,
    1924 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_cbc_dec_8way) }
    1925 + .fn_u = { .cbc = twofish_cbc_dec_8way }
    1926 }, {
    1927 .num_blocks = 3,
    1928 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk_cbc_3way) }
    1929 + .fn_u = { .cbc = twofish_dec_blk_cbc_3way }
    1930 }, {
    1931 .num_blocks = 1,
    1932 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk) }
    1933 + .fn_u = { .cbc = twofish_dec_blk }
    1934 } }
    1935 };
    1936
    1937 @@ -170,10 +164,10 @@ static const struct common_glue_ctx twofish_dec_xts = {
    1938
    1939 .funcs = { {
    1940 .num_blocks = TWOFISH_PARALLEL_BLOCKS,
    1941 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_dec_8way) }
    1942 + .fn_u = { .xts = twofish_xts_dec_8way }
    1943 }, {
    1944 .num_blocks = 1,
    1945 - .fn_u = { .xts = GLUE_XTS_FUNC_CAST(twofish_xts_dec) }
    1946 + .fn_u = { .xts = twofish_xts_dec }
    1947 } }
    1948 };
    1949
    1950 @@ -189,8 +183,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    1951
    1952 static int cbc_encrypt(struct skcipher_request *req)
    1953 {
    1954 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(twofish_enc_blk),
    1955 - req);
    1956 + return glue_cbc_encrypt_req_128bit(twofish_enc_blk, req);
    1957 }
    1958
    1959 static int cbc_decrypt(struct skcipher_request *req)
    1960 @@ -208,8 +201,7 @@ static int xts_encrypt(struct skcipher_request *req)
    1961 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    1962 struct twofish_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1963
    1964 - return glue_xts_req_128bit(&twofish_enc_xts, req,
    1965 - XTS_TWEAK_CAST(twofish_enc_blk),
    1966 + return glue_xts_req_128bit(&twofish_enc_xts, req, twofish_enc_blk,
    1967 &ctx->tweak_ctx, &ctx->crypt_ctx, false);
    1968 }
    1969
    1970 @@ -218,8 +210,7 @@ static int xts_decrypt(struct skcipher_request *req)
    1971 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
    1972 struct twofish_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
    1973
    1974 - return glue_xts_req_128bit(&twofish_dec_xts, req,
    1975 - XTS_TWEAK_CAST(twofish_enc_blk),
    1976 + return glue_xts_req_128bit(&twofish_dec_xts, req, twofish_enc_blk,
    1977 &ctx->tweak_ctx, &ctx->crypt_ctx, true);
    1978 }
    1979
    1980 diff --git a/arch/x86/crypto/twofish_glue_3way.c b/arch/x86/crypto/twofish_glue_3way.c
    1981 index 1dc9e29f221e8..768af6075479c 100644
    1982 --- a/arch/x86/crypto/twofish_glue_3way.c
    1983 +++ b/arch/x86/crypto/twofish_glue_3way.c
    1984 @@ -25,21 +25,22 @@ static int twofish_setkey_skcipher(struct crypto_skcipher *tfm,
    1985 return twofish_setkey(&tfm->base, key, keylen);
    1986 }
    1987
    1988 -static inline void twofish_enc_blk_3way(struct twofish_ctx *ctx, u8 *dst,
    1989 - const u8 *src)
    1990 +static inline void twofish_enc_blk_3way(const void *ctx, u8 *dst, const u8 *src)
    1991 {
    1992 __twofish_enc_blk_3way(ctx, dst, src, false);
    1993 }
    1994
    1995 -static inline void twofish_enc_blk_xor_3way(struct twofish_ctx *ctx, u8 *dst,
    1996 +static inline void twofish_enc_blk_xor_3way(const void *ctx, u8 *dst,
    1997 const u8 *src)
    1998 {
    1999 __twofish_enc_blk_3way(ctx, dst, src, true);
    2000 }
    2001
    2002 -void twofish_dec_blk_cbc_3way(void *ctx, u128 *dst, const u128 *src)
    2003 +void twofish_dec_blk_cbc_3way(const void *ctx, u8 *d, const u8 *s)
    2004 {
    2005 u128 ivs[2];
    2006 + u128 *dst = (u128 *)d;
    2007 + const u128 *src = (const u128 *)s;
    2008
    2009 ivs[0] = src[0];
    2010 ivs[1] = src[1];
    2011 @@ -51,9 +52,11 @@ void twofish_dec_blk_cbc_3way(void *ctx, u128 *dst, const u128 *src)
    2012 }
    2013 EXPORT_SYMBOL_GPL(twofish_dec_blk_cbc_3way);
    2014
    2015 -void twofish_enc_blk_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    2016 +void twofish_enc_blk_ctr(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    2017 {
    2018 be128 ctrblk;
    2019 + u128 *dst = (u128 *)d;
    2020 + const u128 *src = (const u128 *)s;
    2021
    2022 if (dst != src)
    2023 *dst = *src;
    2024 @@ -66,10 +69,11 @@ void twofish_enc_blk_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
    2025 }
    2026 EXPORT_SYMBOL_GPL(twofish_enc_blk_ctr);
    2027
    2028 -void twofish_enc_blk_ctr_3way(void *ctx, u128 *dst, const u128 *src,
    2029 - le128 *iv)
    2030 +void twofish_enc_blk_ctr_3way(const void *ctx, u8 *d, const u8 *s, le128 *iv)
    2031 {
    2032 be128 ctrblks[3];
    2033 + u128 *dst = (u128 *)d;
    2034 + const u128 *src = (const u128 *)s;
    2035
    2036 if (dst != src) {
    2037 dst[0] = src[0];
    2038 @@ -94,10 +98,10 @@ static const struct common_glue_ctx twofish_enc = {
    2039
    2040 .funcs = { {
    2041 .num_blocks = 3,
    2042 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_3way) }
    2043 + .fn_u = { .ecb = twofish_enc_blk_3way }
    2044 }, {
    2045 .num_blocks = 1,
    2046 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk) }
    2047 + .fn_u = { .ecb = twofish_enc_blk }
    2048 } }
    2049 };
    2050
    2051 @@ -107,10 +111,10 @@ static const struct common_glue_ctx twofish_ctr = {
    2052
    2053 .funcs = { {
    2054 .num_blocks = 3,
    2055 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr_3way) }
    2056 + .fn_u = { .ctr = twofish_enc_blk_ctr_3way }
    2057 }, {
    2058 .num_blocks = 1,
    2059 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_enc_blk_ctr) }
    2060 + .fn_u = { .ctr = twofish_enc_blk_ctr }
    2061 } }
    2062 };
    2063
    2064 @@ -120,10 +124,10 @@ static const struct common_glue_ctx twofish_dec = {
    2065
    2066 .funcs = { {
    2067 .num_blocks = 3,
    2068 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk_3way) }
    2069 + .fn_u = { .ecb = twofish_dec_blk_3way }
    2070 }, {
    2071 .num_blocks = 1,
    2072 - .fn_u = { .ecb = GLUE_FUNC_CAST(twofish_dec_blk) }
    2073 + .fn_u = { .ecb = twofish_dec_blk }
    2074 } }
    2075 };
    2076
    2077 @@ -133,10 +137,10 @@ static const struct common_glue_ctx twofish_dec_cbc = {
    2078
    2079 .funcs = { {
    2080 .num_blocks = 3,
    2081 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk_cbc_3way) }
    2082 + .fn_u = { .cbc = twofish_dec_blk_cbc_3way }
    2083 }, {
    2084 .num_blocks = 1,
    2085 - .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(twofish_dec_blk) }
    2086 + .fn_u = { .cbc = twofish_dec_blk }
    2087 } }
    2088 };
    2089
    2090 @@ -152,8 +156,7 @@ static int ecb_decrypt(struct skcipher_request *req)
    2091
    2092 static int cbc_encrypt(struct skcipher_request *req)
    2093 {
    2094 - return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(twofish_enc_blk),
    2095 - req);
    2096 + return glue_cbc_encrypt_req_128bit(twofish_enc_blk, req);
    2097 }
    2098
    2099 static int cbc_decrypt(struct skcipher_request *req)
    2100 diff --git a/arch/x86/include/asm/crypto/camellia.h b/arch/x86/include/asm/crypto/camellia.h
    2101 index a5d86fc0593f2..f1592619dd651 100644
    2102 --- a/arch/x86/include/asm/crypto/camellia.h
    2103 +++ b/arch/x86/include/asm/crypto/camellia.h
    2104 @@ -32,65 +32,60 @@ extern int xts_camellia_setkey(struct crypto_skcipher *tfm, const u8 *key,
    2105 unsigned int keylen);
    2106
    2107 /* regular block cipher functions */
    2108 -asmlinkage void __camellia_enc_blk(struct camellia_ctx *ctx, u8 *dst,
    2109 - const u8 *src, bool xor);
    2110 -asmlinkage void camellia_dec_blk(struct camellia_ctx *ctx, u8 *dst,
    2111 - const u8 *src);
    2112 +asmlinkage void __camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src,
    2113 + bool xor);
    2114 +asmlinkage void camellia_dec_blk(const void *ctx, u8 *dst, const u8 *src);
    2115
    2116 /* 2-way parallel cipher functions */
    2117 -asmlinkage void __camellia_enc_blk_2way(struct camellia_ctx *ctx, u8 *dst,
    2118 - const u8 *src, bool xor);
    2119 -asmlinkage void camellia_dec_blk_2way(struct camellia_ctx *ctx, u8 *dst,
    2120 - const u8 *src);
    2121 +asmlinkage void __camellia_enc_blk_2way(const void *ctx, u8 *dst, const u8 *src,
    2122 + bool xor);
    2123 +asmlinkage void camellia_dec_blk_2way(const void *ctx, u8 *dst, const u8 *src);
    2124
    2125 /* 16-way parallel cipher functions (avx/aes-ni) */
    2126 -asmlinkage void camellia_ecb_enc_16way(struct camellia_ctx *ctx, u8 *dst,
    2127 - const u8 *src);
    2128 -asmlinkage void camellia_ecb_dec_16way(struct camellia_ctx *ctx, u8 *dst,
    2129 - const u8 *src);
    2130 -
    2131 -asmlinkage void camellia_cbc_dec_16way(struct camellia_ctx *ctx, u8 *dst,
    2132 - const u8 *src);
    2133 -asmlinkage void camellia_ctr_16way(struct camellia_ctx *ctx, u8 *dst,
    2134 - const u8 *src, le128 *iv);
    2135 -
    2136 -asmlinkage void camellia_xts_enc_16way(struct camellia_ctx *ctx, u8 *dst,
    2137 - const u8 *src, le128 *iv);
    2138 -asmlinkage void camellia_xts_dec_16way(struct camellia_ctx *ctx, u8 *dst,
    2139 - const u8 *src, le128 *iv);
    2140 -
    2141 -static inline void camellia_enc_blk(struct camellia_ctx *ctx, u8 *dst,
    2142 - const u8 *src)
    2143 +asmlinkage void camellia_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);
    2144 +asmlinkage void camellia_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);
    2145 +
    2146 +asmlinkage void camellia_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);
    2147 +asmlinkage void camellia_ctr_16way(const void *ctx, u8 *dst, const u8 *src,
    2148 + le128 *iv);
    2149 +
    2150 +asmlinkage void camellia_xts_enc_16way(const void *ctx, u8 *dst, const u8 *src,
    2151 + le128 *iv);
    2152 +asmlinkage void camellia_xts_dec_16way(const void *ctx, u8 *dst, const u8 *src,
    2153 + le128 *iv);
    2154 +
    2155 +static inline void camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src)
    2156 {
    2157 __camellia_enc_blk(ctx, dst, src, false);
    2158 }
    2159
    2160 -static inline void camellia_enc_blk_xor(struct camellia_ctx *ctx, u8 *dst,
    2161 - const u8 *src)
    2162 +static inline void camellia_enc_blk_xor(const void *ctx, u8 *dst, const u8 *src)
    2163 {
    2164 __camellia_enc_blk(ctx, dst, src, true);
    2165 }
    2166
    2167 -static inline void camellia_enc_blk_2way(struct camellia_ctx *ctx, u8 *dst,
    2168 +static inline void camellia_enc_blk_2way(const void *ctx, u8 *dst,
    2169 const u8 *src)
    2170 {
    2171 __camellia_enc_blk_2way(ctx, dst, src, false);
    2172 }
    2173
    2174 -static inline void camellia_enc_blk_xor_2way(struct camellia_ctx *ctx, u8 *dst,
    2175 +static inline void camellia_enc_blk_xor_2way(const void *ctx, u8 *dst,
    2176 const u8 *src)
    2177 {
    2178 __camellia_enc_blk_2way(ctx, dst, src, true);
    2179 }
    2180
    2181 /* glue helpers */
    2182 -extern void camellia_decrypt_cbc_2way(void *ctx, u128 *dst, const u128 *src);
    2183 -extern void camellia_crypt_ctr(void *ctx, u128 *dst, const u128 *src,
    2184 +extern void camellia_decrypt_cbc_2way(const void *ctx, u8 *dst, const u8 *src);
    2185 +extern void camellia_crypt_ctr(const void *ctx, u8 *dst, const u8 *src,
    2186 le128 *iv);
    2187 -extern void camellia_crypt_ctr_2way(void *ctx, u128 *dst, const u128 *src,
    2188 +extern void camellia_crypt_ctr_2way(const void *ctx, u8 *dst, const u8 *src,
    2189 le128 *iv);
    2190
    2191 -extern void camellia_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv);
    2192 -extern void camellia_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv);
    2193 +extern void camellia_xts_enc(const void *ctx, u8 *dst, const u8 *src,
    2194 + le128 *iv);
    2195 +extern void camellia_xts_dec(const void *ctx, u8 *dst, const u8 *src,
    2196 + le128 *iv);
    2197
    2198 #endif /* ASM_X86_CAMELLIA_H */
    2199 diff --git a/arch/x86/include/asm/crypto/glue_helper.h b/arch/x86/include/asm/crypto/glue_helper.h
    2200 index 8d4a8e1226ee3..777c0f63418c8 100644
    2201 --- a/arch/x86/include/asm/crypto/glue_helper.h
    2202 +++ b/arch/x86/include/asm/crypto/glue_helper.h
    2203 @@ -11,18 +11,13 @@
    2204 #include <asm/fpu/api.h>
    2205 #include <crypto/b128ops.h>
    2206
    2207 -typedef void (*common_glue_func_t)(void *ctx, u8 *dst, const u8 *src);
    2208 -typedef void (*common_glue_cbc_func_t)(void *ctx, u128 *dst, const u128 *src);
    2209 -typedef void (*common_glue_ctr_func_t)(void *ctx, u128 *dst, const u128 *src,
    2210 +typedef void (*common_glue_func_t)(const void *ctx, u8 *dst, const u8 *src);
    2211 +typedef void (*common_glue_cbc_func_t)(const void *ctx, u8 *dst, const u8 *src);
    2212 +typedef void (*common_glue_ctr_func_t)(const void *ctx, u8 *dst, const u8 *src,
    2213 le128 *iv);
    2214 -typedef void (*common_glue_xts_func_t)(void *ctx, u128 *dst, const u128 *src,
    2215 +typedef void (*common_glue_xts_func_t)(const void *ctx, u8 *dst, const u8 *src,
    2216 le128 *iv);
    2217
    2218 -#define GLUE_FUNC_CAST(fn) ((common_glue_func_t)(fn))
    2219 -#define GLUE_CBC_FUNC_CAST(fn) ((common_glue_cbc_func_t)(fn))
    2220 -#define GLUE_CTR_FUNC_CAST(fn) ((common_glue_ctr_func_t)(fn))
    2221 -#define GLUE_XTS_FUNC_CAST(fn) ((common_glue_xts_func_t)(fn))
    2222 -
    2223 struct common_glue_func_entry {
    2224 unsigned int num_blocks; /* number of blocks that @fn will process */
    2225 union {
    2226 @@ -116,7 +111,8 @@ extern int glue_xts_req_128bit(const struct common_glue_ctx *gctx,
    2227 common_glue_func_t tweak_fn, void *tweak_ctx,
    2228 void *crypt_ctx, bool decrypt);
    2229
    2230 -extern void glue_xts_crypt_128bit_one(void *ctx, u128 *dst, const u128 *src,
    2231 - le128 *iv, common_glue_func_t fn);
    2232 +extern void glue_xts_crypt_128bit_one(const void *ctx, u8 *dst,
    2233 + const u8 *src, le128 *iv,
    2234 + common_glue_func_t fn);
    2235
    2236 #endif /* _CRYPTO_GLUE_HELPER_H */
    2237 diff --git a/arch/x86/include/asm/crypto/serpent-avx.h b/arch/x86/include/asm/crypto/serpent-avx.h
    2238 index db7c9cc322342..251c2c89d7cfe 100644
    2239 --- a/arch/x86/include/asm/crypto/serpent-avx.h
    2240 +++ b/arch/x86/include/asm/crypto/serpent-avx.h
    2241 @@ -15,26 +15,26 @@ struct serpent_xts_ctx {
    2242 struct serpent_ctx crypt_ctx;
    2243 };
    2244
    2245 -asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    2246 +asmlinkage void serpent_ecb_enc_8way_avx(const void *ctx, u8 *dst,
    2247 const u8 *src);
    2248 -asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    2249 +asmlinkage void serpent_ecb_dec_8way_avx(const void *ctx, u8 *dst,
    2250 const u8 *src);
    2251
    2252 -asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    2253 +asmlinkage void serpent_cbc_dec_8way_avx(const void *ctx, u8 *dst,
    2254 const u8 *src);
    2255 -asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    2256 - const u8 *src, le128 *iv);
    2257 +asmlinkage void serpent_ctr_8way_avx(const void *ctx, u8 *dst, const u8 *src,
    2258 + le128 *iv);
    2259
    2260 -asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    2261 +asmlinkage void serpent_xts_enc_8way_avx(const void *ctx, u8 *dst,
    2262 const u8 *src, le128 *iv);
    2263 -asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
    2264 +asmlinkage void serpent_xts_dec_8way_avx(const void *ctx, u8 *dst,
    2265 const u8 *src, le128 *iv);
    2266
    2267 -extern void __serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src,
    2268 +extern void __serpent_crypt_ctr(const void *ctx, u8 *dst, const u8 *src,
    2269 le128 *iv);
    2270
    2271 -extern void serpent_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv);
    2272 -extern void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv);
    2273 +extern void serpent_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv);
    2274 +extern void serpent_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv);
    2275
    2276 extern int xts_serpent_setkey(struct crypto_skcipher *tfm, const u8 *key,
    2277 unsigned int keylen);
    2278 diff --git a/arch/x86/include/asm/crypto/serpent-sse2.h b/arch/x86/include/asm/crypto/serpent-sse2.h
    2279 index 1a345e8a7496c..860ca248914b1 100644
    2280 --- a/arch/x86/include/asm/crypto/serpent-sse2.h
    2281 +++ b/arch/x86/include/asm/crypto/serpent-sse2.h
    2282 @@ -9,25 +9,23 @@
    2283
    2284 #define SERPENT_PARALLEL_BLOCKS 4
    2285
    2286 -asmlinkage void __serpent_enc_blk_4way(struct serpent_ctx *ctx, u8 *dst,
    2287 +asmlinkage void __serpent_enc_blk_4way(const struct serpent_ctx *ctx, u8 *dst,
    2288 const u8 *src, bool xor);
    2289 -asmlinkage void serpent_dec_blk_4way(struct serpent_ctx *ctx, u8 *dst,
    2290 +asmlinkage void serpent_dec_blk_4way(const struct serpent_ctx *ctx, u8 *dst,
    2291 const u8 *src);
    2292
    2293 -static inline void serpent_enc_blk_xway(struct serpent_ctx *ctx, u8 *dst,
    2294 - const u8 *src)
    2295 +static inline void serpent_enc_blk_xway(const void *ctx, u8 *dst, const u8 *src)
    2296 {
    2297 __serpent_enc_blk_4way(ctx, dst, src, false);
    2298 }
    2299
    2300 -static inline void serpent_enc_blk_xway_xor(struct serpent_ctx *ctx, u8 *dst,
    2301 - const u8 *src)
    2302 +static inline void serpent_enc_blk_xway_xor(const struct serpent_ctx *ctx,
    2303 + u8 *dst, const u8 *src)
    2304 {
    2305 __serpent_enc_blk_4way(ctx, dst, src, true);
    2306 }
    2307
    2308 -static inline void serpent_dec_blk_xway(struct serpent_ctx *ctx, u8 *dst,
    2309 - const u8 *src)
    2310 +static inline void serpent_dec_blk_xway(const void *ctx, u8 *dst, const u8 *src)
    2311 {
    2312 serpent_dec_blk_4way(ctx, dst, src);
    2313 }
    2314 @@ -36,25 +34,23 @@ static inline void serpent_dec_blk_xway(struct serpent_ctx *ctx, u8 *dst,
    2315
    2316 #define SERPENT_PARALLEL_BLOCKS 8
    2317
    2318 -asmlinkage void __serpent_enc_blk_8way(struct serpent_ctx *ctx, u8 *dst,
    2319 +asmlinkage void __serpent_enc_blk_8way(const struct serpent_ctx *ctx, u8 *dst,
    2320 const u8 *src, bool xor);
    2321 -asmlinkage void serpent_dec_blk_8way(struct serpent_ctx *ctx, u8 *dst,
    2322 +asmlinkage void serpent_dec_blk_8way(const struct serpent_ctx *ctx, u8 *dst,
    2323 const u8 *src);
    2324
    2325 -static inline void serpent_enc_blk_xway(struct serpent_ctx *ctx, u8 *dst,
    2326 - const u8 *src)
    2327 +static inline void serpent_enc_blk_xway(const void *ctx, u8 *dst, const u8 *src)
    2328 {
    2329 __serpent_enc_blk_8way(ctx, dst, src, false);
    2330 }
    2331
    2332 -static inline void serpent_enc_blk_xway_xor(struct serpent_ctx *ctx, u8 *dst,
    2333 - const u8 *src)
    2334 +static inline void serpent_enc_blk_xway_xor(const struct serpent_ctx *ctx,
    2335 + u8 *dst, const u8 *src)
    2336 {
    2337 __serpent_enc_blk_8way(ctx, dst, src, true);
    2338 }
    2339
    2340 -static inline void serpent_dec_blk_xway(struct serpent_ctx *ctx, u8 *dst,
    2341 - const u8 *src)
    2342 +static inline void serpent_dec_blk_xway(const void *ctx, u8 *dst, const u8 *src)
    2343 {
    2344 serpent_dec_blk_8way(ctx, dst, src);
    2345 }
    2346 diff --git a/arch/x86/include/asm/crypto/twofish.h b/arch/x86/include/asm/crypto/twofish.h
    2347 index f618bf272b900..2c377a8042e17 100644
    2348 --- a/arch/x86/include/asm/crypto/twofish.h
    2349 +++ b/arch/x86/include/asm/crypto/twofish.h
    2350 @@ -7,22 +7,19 @@
    2351 #include <crypto/b128ops.h>
    2352
    2353 /* regular block cipher functions from twofish_x86_64 module */
    2354 -asmlinkage void twofish_enc_blk(struct twofish_ctx *ctx, u8 *dst,
    2355 - const u8 *src);
    2356 -asmlinkage void twofish_dec_blk(struct twofish_ctx *ctx, u8 *dst,
    2357 - const u8 *src);
    2358 +asmlinkage void twofish_enc_blk(const void *ctx, u8 *dst, const u8 *src);
    2359 +asmlinkage void twofish_dec_blk(const void *ctx, u8 *dst, const u8 *src);
    2360
    2361 /* 3-way parallel cipher functions */
    2362 -asmlinkage void __twofish_enc_blk_3way(struct twofish_ctx *ctx, u8 *dst,
    2363 - const u8 *src, bool xor);
    2364 -asmlinkage void twofish_dec_blk_3way(struct twofish_ctx *ctx, u8 *dst,
    2365 - const u8 *src);
    2366 +asmlinkage void __twofish_enc_blk_3way(const void *ctx, u8 *dst, const u8 *src,
    2367 + bool xor);
    2368 +asmlinkage void twofish_dec_blk_3way(const void *ctx, u8 *dst, const u8 *src);
    2369
    2370 /* helpers from twofish_x86_64-3way module */
    2371 -extern void twofish_dec_blk_cbc_3way(void *ctx, u128 *dst, const u128 *src);
    2372 -extern void twofish_enc_blk_ctr(void *ctx, u128 *dst, const u128 *src,
    2373 +extern void twofish_dec_blk_cbc_3way(const void *ctx, u8 *dst, const u8 *src);
    2374 +extern void twofish_enc_blk_ctr(const void *ctx, u8 *dst, const u8 *src,
    2375 le128 *iv);
    2376 -extern void twofish_enc_blk_ctr_3way(void *ctx, u128 *dst, const u128 *src,
    2377 +extern void twofish_enc_blk_ctr_3way(const void *ctx, u8 *dst, const u8 *src,
    2378 le128 *iv);
    2379
    2380 #endif /* ASM_X86_TWOFISH_H */
    2381 diff --git a/crypto/cast6_generic.c b/crypto/cast6_generic.c
    2382 index a8248f8e2777e..85328522c5ca1 100644
    2383 --- a/crypto/cast6_generic.c
    2384 +++ b/crypto/cast6_generic.c
    2385 @@ -154,7 +154,7 @@ int cast6_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
    2386 EXPORT_SYMBOL_GPL(cast6_setkey);
    2387
    2388 /*forward quad round*/
    2389 -static inline void Q(u32 *block, u8 *Kr, u32 *Km)
    2390 +static inline void Q(u32 *block, const u8 *Kr, const u32 *Km)
    2391 {
    2392 u32 I;
    2393 block[2] ^= F1(block[3], Kr[0], Km[0]);
    2394 @@ -164,7 +164,7 @@ static inline void Q(u32 *block, u8 *Kr, u32 *Km)
    2395 }
    2396
    2397 /*reverse quad round*/
    2398 -static inline void QBAR(u32 *block, u8 *Kr, u32 *Km)
    2399 +static inline void QBAR(u32 *block, const u8 *Kr, const u32 *Km)
    2400 {
    2401 u32 I;
    2402 block[3] ^= F1(block[0], Kr[3], Km[3]);
    2403 @@ -173,13 +173,14 @@ static inline void QBAR(u32 *block, u8 *Kr, u32 *Km)
    2404 block[2] ^= F1(block[3], Kr[0], Km[0]);
    2405 }
    2406
    2407 -void __cast6_encrypt(struct cast6_ctx *c, u8 *outbuf, const u8 *inbuf)
    2408 +void __cast6_encrypt(const void *ctx, u8 *outbuf, const u8 *inbuf)
    2409 {
    2410 + const struct cast6_ctx *c = ctx;
    2411 const __be32 *src = (const __be32 *)inbuf;
    2412 __be32 *dst = (__be32 *)outbuf;
    2413 u32 block[4];
    2414 - u32 *Km;
    2415 - u8 *Kr;
    2416 + const u32 *Km;
    2417 + const u8 *Kr;
    2418
    2419 block[0] = be32_to_cpu(src[0]);
    2420 block[1] = be32_to_cpu(src[1]);
    2421 @@ -211,13 +212,14 @@ static void cast6_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf)
    2422 __cast6_encrypt(crypto_tfm_ctx(tfm), outbuf, inbuf);
    2423 }
    2424
    2425 -void __cast6_decrypt(struct cast6_ctx *c, u8 *outbuf, const u8 *inbuf)
    2426 +void __cast6_decrypt(const void *ctx, u8 *outbuf, const u8 *inbuf)
    2427 {
    2428 + const struct cast6_ctx *c = ctx;
    2429 const __be32 *src = (const __be32 *)inbuf;
    2430 __be32 *dst = (__be32 *)outbuf;
    2431 u32 block[4];
    2432 - u32 *Km;
    2433 - u8 *Kr;
    2434 + const u32 *Km;
    2435 + const u8 *Kr;
    2436
    2437 block[0] = be32_to_cpu(src[0]);
    2438 block[1] = be32_to_cpu(src[1]);
    2439 diff --git a/crypto/serpent_generic.c b/crypto/serpent_generic.c
    2440 index 56fa665a4f010..492c1d0bfe068 100644
    2441 --- a/crypto/serpent_generic.c
    2442 +++ b/crypto/serpent_generic.c
    2443 @@ -449,8 +449,9 @@ int serpent_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
    2444 }
    2445 EXPORT_SYMBOL_GPL(serpent_setkey);
    2446
    2447 -void __serpent_encrypt(struct serpent_ctx *ctx, u8 *dst, const u8 *src)
    2448 +void __serpent_encrypt(const void *c, u8 *dst, const u8 *src)
    2449 {
    2450 + const struct serpent_ctx *ctx = c;
    2451 const u32 *k = ctx->expkey;
    2452 const __le32 *s = (const __le32 *)src;
    2453 __le32 *d = (__le32 *)dst;
    2454 @@ -514,8 +515,9 @@ static void serpent_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
    2455 __serpent_encrypt(ctx, dst, src);
    2456 }
    2457
    2458 -void __serpent_decrypt(struct serpent_ctx *ctx, u8 *dst, const u8 *src)
    2459 +void __serpent_decrypt(const void *c, u8 *dst, const u8 *src)
    2460 {
    2461 + const struct serpent_ctx *ctx = c;
    2462 const u32 *k = ctx->expkey;
    2463 const __le32 *s = (const __le32 *)src;
    2464 __le32 *d = (__le32 *)dst;
    2465 diff --git a/drivers/gpu/drm/i915/gvt/display.c b/drivers/gpu/drm/i915/gvt/display.c
    2466 index 59aa5e64acb04..21a562c2b1f50 100644
    2467 --- a/drivers/gpu/drm/i915/gvt/display.c
    2468 +++ b/drivers/gpu/drm/i915/gvt/display.c
    2469 @@ -172,21 +172,176 @@ static void emulate_monitor_status_change(struct intel_vgpu *vgpu)
    2470 int pipe;
    2471
    2472 if (IS_BROXTON(dev_priv)) {
    2473 + enum transcoder trans;
    2474 + enum port port;
    2475 +
    2476 + /* Clear PIPE, DDI, PHY, HPD before setting new */
    2477 vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) &= ~(BXT_DE_PORT_HP_DDIA |
    2478 BXT_DE_PORT_HP_DDIB |
    2479 BXT_DE_PORT_HP_DDIC);
    2480
    2481 + for_each_pipe(dev_priv, pipe) {
    2482 + vgpu_vreg_t(vgpu, PIPECONF(pipe)) &=
    2483 + ~(PIPECONF_ENABLE | I965_PIPECONF_ACTIVE);
    2484 + vgpu_vreg_t(vgpu, DSPCNTR(pipe)) &= ~DISPLAY_PLANE_ENABLE;
    2485 + vgpu_vreg_t(vgpu, SPRCTL(pipe)) &= ~SPRITE_ENABLE;
    2486 + vgpu_vreg_t(vgpu, CURCNTR(pipe)) &= ~MCURSOR_MODE;
    2487 + vgpu_vreg_t(vgpu, CURCNTR(pipe)) |= MCURSOR_MODE_DISABLE;
    2488 + }
    2489 +
    2490 + for (trans = TRANSCODER_A; trans <= TRANSCODER_EDP; trans++) {
    2491 + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(trans)) &=
    2492 + ~(TRANS_DDI_BPC_MASK | TRANS_DDI_MODE_SELECT_MASK |
    2493 + TRANS_DDI_PORT_MASK | TRANS_DDI_FUNC_ENABLE);
    2494 + }
    2495 + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_A)) &=
    2496 + ~(TRANS_DDI_BPC_MASK | TRANS_DDI_MODE_SELECT_MASK |
    2497 + TRANS_DDI_PORT_MASK);
    2498 +
    2499 + for (port = PORT_A; port <= PORT_C; port++) {
    2500 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(port)) &=
    2501 + ~BXT_PHY_LANE_ENABLED;
    2502 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(port)) |=
    2503 + (BXT_PHY_CMNLANE_POWERDOWN_ACK |
    2504 + BXT_PHY_LANE_POWERDOWN_ACK);
    2505 +
    2506 + vgpu_vreg_t(vgpu, BXT_PORT_PLL_ENABLE(port)) &=
    2507 + ~(PORT_PLL_POWER_STATE | PORT_PLL_POWER_ENABLE |
    2508 + PORT_PLL_REF_SEL | PORT_PLL_LOCK |
    2509 + PORT_PLL_ENABLE);
    2510 +
    2511 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(port)) &=
    2512 + ~(DDI_INIT_DISPLAY_DETECTED |
    2513 + DDI_BUF_CTL_ENABLE);
    2514 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(port)) |= DDI_BUF_IS_IDLE;
    2515 + }
    2516 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &=
    2517 + ~(PORTA_HOTPLUG_ENABLE | PORTA_HOTPLUG_STATUS_MASK);
    2518 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &=
    2519 + ~(PORTB_HOTPLUG_ENABLE | PORTB_HOTPLUG_STATUS_MASK);
    2520 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &=
    2521 + ~(PORTC_HOTPLUG_ENABLE | PORTC_HOTPLUG_STATUS_MASK);
    2522 + /* No hpd_invert set in vgpu vbt, need to clear invert mask */
    2523 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &= ~BXT_DDI_HPD_INVERT_MASK;
    2524 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) &= ~BXT_DE_PORT_HOTPLUG_MASK;
    2525 +
    2526 + vgpu_vreg_t(vgpu, BXT_P_CR_GT_DISP_PWRON) &= ~(BIT(0) | BIT(1));
    2527 + vgpu_vreg_t(vgpu, BXT_PORT_CL1CM_DW0(DPIO_PHY0)) &=
    2528 + ~PHY_POWER_GOOD;
    2529 + vgpu_vreg_t(vgpu, BXT_PORT_CL1CM_DW0(DPIO_PHY1)) &=
    2530 + ~PHY_POWER_GOOD;
    2531 + vgpu_vreg_t(vgpu, BXT_PHY_CTL_FAMILY(DPIO_PHY0)) &= ~BIT(30);
    2532 + vgpu_vreg_t(vgpu, BXT_PHY_CTL_FAMILY(DPIO_PHY1)) &= ~BIT(30);
    2533 +
    2534 + vgpu_vreg_t(vgpu, SFUSE_STRAP) &= ~SFUSE_STRAP_DDIB_DETECTED;
    2535 + vgpu_vreg_t(vgpu, SFUSE_STRAP) &= ~SFUSE_STRAP_DDIC_DETECTED;
    2536 +
    2537 + /*
    2538 + * Only 1 PIPE enabled in current vGPU display and PIPE_A is
    2539 + * tied to TRANSCODER_A in HW, so it's safe to assume PIPE_A,
    2540 + * TRANSCODER_A can be enabled. PORT_x depends on the input of
    2541 + * setup_virtual_dp_monitor.
    2542 + */
    2543 + vgpu_vreg_t(vgpu, PIPECONF(PIPE_A)) |= PIPECONF_ENABLE;
    2544 + vgpu_vreg_t(vgpu, PIPECONF(PIPE_A)) |= I965_PIPECONF_ACTIVE;
    2545 +
    2546 + /*
    2547 + * Golden M/N are calculated based on:
    2548 + * 24 bpp, 4 lanes, 154000 pixel clk (from virtual EDID),
    2549 + * DP link clk 1620 MHz and non-constant_n.
    2550 + * TODO: calculate DP link symbol clk and stream clk m/n.
    2551 + */
    2552 + vgpu_vreg_t(vgpu, PIPE_DATA_M1(TRANSCODER_A)) = 63 << TU_SIZE_SHIFT;
    2553 + vgpu_vreg_t(vgpu, PIPE_DATA_M1(TRANSCODER_A)) |= 0x5b425e;
    2554 + vgpu_vreg_t(vgpu, PIPE_DATA_N1(TRANSCODER_A)) = 0x800000;
    2555 + vgpu_vreg_t(vgpu, PIPE_LINK_M1(TRANSCODER_A)) = 0x3cd6e;
    2556 + vgpu_vreg_t(vgpu, PIPE_LINK_N1(TRANSCODER_A)) = 0x80000;
    2557 +
    2558 + /* Enable per-DDI/PORT vreg */
    2559 if (intel_vgpu_has_monitor_on_port(vgpu, PORT_A)) {
    2560 + vgpu_vreg_t(vgpu, BXT_P_CR_GT_DISP_PWRON) |= BIT(1);
    2561 + vgpu_vreg_t(vgpu, BXT_PORT_CL1CM_DW0(DPIO_PHY1)) |=
    2562 + PHY_POWER_GOOD;
    2563 + vgpu_vreg_t(vgpu, BXT_PHY_CTL_FAMILY(DPIO_PHY1)) |=
    2564 + BIT(30);
    2565 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_A)) |=
    2566 + BXT_PHY_LANE_ENABLED;
    2567 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_A)) &=
    2568 + ~(BXT_PHY_CMNLANE_POWERDOWN_ACK |
    2569 + BXT_PHY_LANE_POWERDOWN_ACK);
    2570 + vgpu_vreg_t(vgpu, BXT_PORT_PLL_ENABLE(PORT_A)) |=
    2571 + (PORT_PLL_POWER_STATE | PORT_PLL_POWER_ENABLE |
    2572 + PORT_PLL_REF_SEL | PORT_PLL_LOCK |
    2573 + PORT_PLL_ENABLE);
    2574 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(PORT_A)) |=
    2575 + (DDI_BUF_CTL_ENABLE | DDI_INIT_DISPLAY_DETECTED);
    2576 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(PORT_A)) &=
    2577 + ~DDI_BUF_IS_IDLE;
    2578 + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_EDP)) |=
    2579 + (TRANS_DDI_BPC_8 | TRANS_DDI_MODE_SELECT_DP_SST |
    2580 + TRANS_DDI_FUNC_ENABLE);
    2581 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2582 + PORTA_HOTPLUG_ENABLE;
    2583 vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) |=
    2584 BXT_DE_PORT_HP_DDIA;
    2585 }
    2586
    2587 if (intel_vgpu_has_monitor_on_port(vgpu, PORT_B)) {
    2588 + vgpu_vreg_t(vgpu, SFUSE_STRAP) |= SFUSE_STRAP_DDIB_DETECTED;
    2589 + vgpu_vreg_t(vgpu, BXT_P_CR_GT_DISP_PWRON) |= BIT(0);
    2590 + vgpu_vreg_t(vgpu, BXT_PORT_CL1CM_DW0(DPIO_PHY0)) |=
    2591 + PHY_POWER_GOOD;
    2592 + vgpu_vreg_t(vgpu, BXT_PHY_CTL_FAMILY(DPIO_PHY0)) |=
    2593 + BIT(30);
    2594 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_B)) |=
    2595 + BXT_PHY_LANE_ENABLED;
    2596 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_B)) &=
    2597 + ~(BXT_PHY_CMNLANE_POWERDOWN_ACK |
    2598 + BXT_PHY_LANE_POWERDOWN_ACK);
    2599 + vgpu_vreg_t(vgpu, BXT_PORT_PLL_ENABLE(PORT_B)) |=
    2600 + (PORT_PLL_POWER_STATE | PORT_PLL_POWER_ENABLE |
    2601 + PORT_PLL_REF_SEL | PORT_PLL_LOCK |
    2602 + PORT_PLL_ENABLE);
    2603 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(PORT_B)) |=
    2604 + DDI_BUF_CTL_ENABLE;
    2605 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(PORT_B)) &=
    2606 + ~DDI_BUF_IS_IDLE;
    2607 + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_A)) |=
    2608 + (TRANS_DDI_BPC_8 | TRANS_DDI_MODE_SELECT_DP_SST |
    2609 + (PORT_B << TRANS_DDI_PORT_SHIFT) |
    2610 + TRANS_DDI_FUNC_ENABLE);
    2611 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2612 + PORTB_HOTPLUG_ENABLE;
    2613 vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) |=
    2614 BXT_DE_PORT_HP_DDIB;
    2615 }
    2616
    2617 if (intel_vgpu_has_monitor_on_port(vgpu, PORT_C)) {
    2618 + vgpu_vreg_t(vgpu, SFUSE_STRAP) |= SFUSE_STRAP_DDIC_DETECTED;
    2619 + vgpu_vreg_t(vgpu, BXT_P_CR_GT_DISP_PWRON) |= BIT(0);
    2620 + vgpu_vreg_t(vgpu, BXT_PORT_CL1CM_DW0(DPIO_PHY0)) |=
    2621 + PHY_POWER_GOOD;
    2622 + vgpu_vreg_t(vgpu, BXT_PHY_CTL_FAMILY(DPIO_PHY0)) |=
    2623 + BIT(30);
    2624 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_C)) |=
    2625 + BXT_PHY_LANE_ENABLED;
    2626 + vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_C)) &=
    2627 + ~(BXT_PHY_CMNLANE_POWERDOWN_ACK |
    2628 + BXT_PHY_LANE_POWERDOWN_ACK);
    2629 + vgpu_vreg_t(vgpu, BXT_PORT_PLL_ENABLE(PORT_C)) |=
    2630 + (PORT_PLL_POWER_STATE | PORT_PLL_POWER_ENABLE |
    2631 + PORT_PLL_REF_SEL | PORT_PLL_LOCK |
    2632 + PORT_PLL_ENABLE);
    2633 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(PORT_C)) |=
    2634 + DDI_BUF_CTL_ENABLE;
    2635 + vgpu_vreg_t(vgpu, DDI_BUF_CTL(PORT_C)) &=
    2636 + ~DDI_BUF_IS_IDLE;
    2637 + vgpu_vreg_t(vgpu, TRANS_DDI_FUNC_CTL(TRANSCODER_A)) |=
    2638 + (TRANS_DDI_BPC_8 | TRANS_DDI_MODE_SELECT_DP_SST |
    2639 + (PORT_B << TRANS_DDI_PORT_SHIFT) |
    2640 + TRANS_DDI_FUNC_ENABLE);
    2641 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2642 + PORTC_HOTPLUG_ENABLE;
    2643 vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) |=
    2644 BXT_DE_PORT_HP_DDIC;
    2645 }
    2646 @@ -511,6 +666,63 @@ void intel_vgpu_emulate_hotplug(struct intel_vgpu *vgpu, bool connected)
    2647 vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2648 PORTD_HOTPLUG_STATUS_MASK;
    2649 intel_vgpu_trigger_virtual_event(vgpu, DP_D_HOTPLUG);
    2650 + } else if (IS_BROXTON(dev_priv)) {
    2651 + if (intel_vgpu_has_monitor_on_port(vgpu, PORT_A)) {
    2652 + if (connected) {
    2653 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) |=
    2654 + BXT_DE_PORT_HP_DDIA;
    2655 + } else {
    2656 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) &=
    2657 + ~BXT_DE_PORT_HP_DDIA;
    2658 + }
    2659 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_IIR) |=
    2660 + BXT_DE_PORT_HP_DDIA;
    2661 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &=
    2662 + ~PORTA_HOTPLUG_STATUS_MASK;
    2663 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2664 + PORTA_HOTPLUG_LONG_DETECT;
    2665 + intel_vgpu_trigger_virtual_event(vgpu, DP_A_HOTPLUG);
    2666 + }
    2667 + if (intel_vgpu_has_monitor_on_port(vgpu, PORT_B)) {
    2668 + if (connected) {
    2669 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) |=
    2670 + BXT_DE_PORT_HP_DDIB;
    2671 + vgpu_vreg_t(vgpu, SFUSE_STRAP) |=
    2672 + SFUSE_STRAP_DDIB_DETECTED;
    2673 + } else {
    2674 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) &=
    2675 + ~BXT_DE_PORT_HP_DDIB;
    2676 + vgpu_vreg_t(vgpu, SFUSE_STRAP) &=
    2677 + ~SFUSE_STRAP_DDIB_DETECTED;
    2678 + }
    2679 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_IIR) |=
    2680 + BXT_DE_PORT_HP_DDIB;
    2681 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &=
    2682 + ~PORTB_HOTPLUG_STATUS_MASK;
    2683 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2684 + PORTB_HOTPLUG_LONG_DETECT;
    2685 + intel_vgpu_trigger_virtual_event(vgpu, DP_B_HOTPLUG);
    2686 + }
    2687 + if (intel_vgpu_has_monitor_on_port(vgpu, PORT_C)) {
    2688 + if (connected) {
    2689 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) |=
    2690 + BXT_DE_PORT_HP_DDIC;
    2691 + vgpu_vreg_t(vgpu, SFUSE_STRAP) |=
    2692 + SFUSE_STRAP_DDIC_DETECTED;
    2693 + } else {
    2694 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_ISR) &=
    2695 + ~BXT_DE_PORT_HP_DDIC;
    2696 + vgpu_vreg_t(vgpu, SFUSE_STRAP) &=
    2697 + ~SFUSE_STRAP_DDIC_DETECTED;
    2698 + }
    2699 + vgpu_vreg_t(vgpu, GEN8_DE_PORT_IIR) |=
    2700 + BXT_DE_PORT_HP_DDIC;
    2701 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) &=
    2702 + ~PORTC_HOTPLUG_STATUS_MASK;
    2703 + vgpu_vreg_t(vgpu, PCH_PORT_HOTPLUG) |=
    2704 + PORTC_HOTPLUG_LONG_DETECT;
    2705 + intel_vgpu_trigger_virtual_event(vgpu, DP_C_HOTPLUG);
    2706 + }
    2707 }
    2708 }
    2709
    2710 diff --git a/drivers/gpu/drm/i915/gvt/handlers.c b/drivers/gpu/drm/i915/gvt/handlers.c
    2711 index 689b07bc91c47..245c20d36f1b2 100644
    2712 --- a/drivers/gpu/drm/i915/gvt/handlers.c
    2713 +++ b/drivers/gpu/drm/i915/gvt/handlers.c
    2714 @@ -1632,6 +1632,34 @@ static int edp_psr_imr_iir_write(struct intel_vgpu *vgpu,
    2715 return 0;
    2716 }
    2717
    2718 +/**
    2719 + * FixMe:
    2720 + * If guest fills non-priv batch buffer on ApolloLake/Broxton as Mesa i965 did:
    2721 + * 717e7539124d (i965: Use a WC map and memcpy for the batch instead of pwrite.)
    2722 + * Due to the missing flush of bb filled by VM vCPU, host GPU hangs on executing
    2723 + * these MI_BATCH_BUFFER.
    2724 + * Temporarily workaround this by setting SNOOP bit for PAT3 used by PPGTT
    2725 + * PML4 PTE: PAT(0) PCD(1) PWT(1).
    2726 + * The performance is still expected to be low, will need further improvement.
    2727 + */
    2728 +static int bxt_ppat_low_write(struct intel_vgpu *vgpu, unsigned int offset,
    2729 + void *p_data, unsigned int bytes)
    2730 +{
    2731 + u64 pat =
    2732 + GEN8_PPAT(0, CHV_PPAT_SNOOP) |
    2733 + GEN8_PPAT(1, 0) |
    2734 + GEN8_PPAT(2, 0) |
    2735 + GEN8_PPAT(3, CHV_PPAT_SNOOP) |
    2736 + GEN8_PPAT(4, CHV_PPAT_SNOOP) |
    2737 + GEN8_PPAT(5, CHV_PPAT_SNOOP) |
    2738 + GEN8_PPAT(6, CHV_PPAT_SNOOP) |
    2739 + GEN8_PPAT(7, CHV_PPAT_SNOOP);
    2740 +
    2741 + vgpu_vreg(vgpu, offset) = lower_32_bits(pat);
    2742 +
    2743 + return 0;
    2744 +}
    2745 +
    2746 static int mmio_read_from_hw(struct intel_vgpu *vgpu,
    2747 unsigned int offset, void *p_data, unsigned int bytes)
    2748 {
    2749 @@ -2778,7 +2806,7 @@ static int init_broadwell_mmio_info(struct intel_gvt *gvt)
    2750
    2751 MMIO_DH(GEN6_PCODE_MAILBOX, D_BDW_PLUS, NULL, mailbox_write);
    2752
    2753 - MMIO_D(GEN8_PRIVATE_PAT_LO, D_BDW_PLUS);
    2754 + MMIO_D(GEN8_PRIVATE_PAT_LO, D_BDW_PLUS & ~D_BXT);
    2755 MMIO_D(GEN8_PRIVATE_PAT_HI, D_BDW_PLUS);
    2756
    2757 MMIO_D(GAMTARBMODE, D_BDW_PLUS);
    2758 @@ -3104,7 +3132,7 @@ static int init_skl_mmio_info(struct intel_gvt *gvt)
    2759 NULL, NULL);
    2760
    2761 MMIO_D(GAMT_CHKN_BIT_REG, D_KBL | D_CFL);
    2762 - MMIO_D(GEN9_CTX_PREEMPT_REG, D_SKL_PLUS);
    2763 + MMIO_D(GEN9_CTX_PREEMPT_REG, D_SKL_PLUS & ~D_BXT);
    2764
    2765 return 0;
    2766 }
    2767 @@ -3278,9 +3306,17 @@ static int init_bxt_mmio_info(struct intel_gvt *gvt)
    2768 MMIO_D(GEN8_PUSHBUS_SHIFT, D_BXT);
    2769 MMIO_D(GEN6_GFXPAUSE, D_BXT);
    2770 MMIO_DFH(GEN8_L3SQCREG1, D_BXT, F_CMD_ACCESS, NULL, NULL);
    2771 + MMIO_DFH(GEN8_L3CNTLREG, D_BXT, F_CMD_ACCESS, NULL, NULL);
    2772 + MMIO_DFH(_MMIO(0x20D8), D_BXT, F_CMD_ACCESS, NULL, NULL);
    2773 + MMIO_F(HSW_CS_GPR(0), 0x40, F_CMD_ACCESS, 0, 0, D_BXT, NULL, NULL);
    2774 + MMIO_F(_MMIO(0x12600), 0x40, F_CMD_ACCESS, 0, 0, D_BXT, NULL, NULL);
    2775 + MMIO_F(BCS_GPR(0), 0x40, F_CMD_ACCESS, 0, 0, D_BXT, NULL, NULL);
    2776 + MMIO_F(_MMIO(0x1a600), 0x40, F_CMD_ACCESS, 0, 0, D_BXT, NULL, NULL);
    2777
    2778 MMIO_DFH(GEN9_CTX_PREEMPT_REG, D_BXT, F_CMD_ACCESS, NULL, NULL);
    2779
    2780 + MMIO_DH(GEN8_PRIVATE_PAT_LO, D_BXT, NULL, bxt_ppat_low_write);
    2781 +
    2782 return 0;
    2783 }
    2784
    2785 diff --git a/drivers/gpu/drm/i915/gvt/mmio.c b/drivers/gpu/drm/i915/gvt/mmio.c
    2786 index a55178884d67a..e0e7adc545a5b 100644
    2787 --- a/drivers/gpu/drm/i915/gvt/mmio.c
    2788 +++ b/drivers/gpu/drm/i915/gvt/mmio.c
    2789 @@ -271,6 +271,11 @@ void intel_vgpu_reset_mmio(struct intel_vgpu *vgpu, bool dmlr)
    2790 vgpu_vreg_t(vgpu, BXT_PHY_CTL(PORT_C)) |=
    2791 BXT_PHY_CMNLANE_POWERDOWN_ACK |
    2792 BXT_PHY_LANE_POWERDOWN_ACK;
    2793 + vgpu_vreg_t(vgpu, SKL_FUSE_STATUS) |=
    2794 + SKL_FUSE_DOWNLOAD_STATUS |
    2795 + SKL_FUSE_PG_DIST_STATUS(SKL_PG0) |
    2796 + SKL_FUSE_PG_DIST_STATUS(SKL_PG1) |
    2797 + SKL_FUSE_PG_DIST_STATUS(SKL_PG2);
    2798 }
    2799 } else {
    2800 #define GVT_GEN8_MMIO_RESET_OFFSET (0x44200)
    2801 diff --git a/drivers/gpu/drm/i915/gvt/vgpu.c b/drivers/gpu/drm/i915/gvt/vgpu.c
    2802 index 32e57635709ad..4deb7fec5eb52 100644
    2803 --- a/drivers/gpu/drm/i915/gvt/vgpu.c
    2804 +++ b/drivers/gpu/drm/i915/gvt/vgpu.c
    2805 @@ -432,8 +432,9 @@ static struct intel_vgpu *__intel_gvt_create_vgpu(struct intel_gvt *gvt,
    2806 if (ret)
    2807 goto out_clean_sched_policy;
    2808
    2809 - /*TODO: add more platforms support */
    2810 - if (IS_SKYLAKE(gvt->dev_priv) || IS_KABYLAKE(gvt->dev_priv))
    2811 + if (IS_BROADWELL(gvt->dev_priv) || IS_BROXTON(gvt->dev_priv))
    2812 + ret = intel_gvt_hypervisor_set_edid(vgpu, PORT_B);
    2813 + else
    2814 ret = intel_gvt_hypervisor_set_edid(vgpu, PORT_D);
    2815 if (ret)
    2816 goto out_clean_sched_policy;
    2817 diff --git a/drivers/net/dsa/b53/b53_common.c b/drivers/net/dsa/b53/b53_common.c
    2818 index 0b1223f360d97..f35757b63ea78 100644
    2819 --- a/drivers/net/dsa/b53/b53_common.c
    2820 +++ b/drivers/net/dsa/b53/b53_common.c
    2821 @@ -514,6 +514,19 @@ void b53_imp_vlan_setup(struct dsa_switch *ds, int cpu_port)
    2822 }
    2823 EXPORT_SYMBOL(b53_imp_vlan_setup);
    2824
    2825 +static void b53_port_set_learning(struct b53_device *dev, int port,
    2826 + bool learning)
    2827 +{
    2828 + u16 reg;
    2829 +
    2830 + b53_read16(dev, B53_CTRL_PAGE, B53_DIS_LEARNING, &reg);
    2831 + if (learning)
    2832 + reg &= ~BIT(port);
    2833 + else
    2834 + reg |= BIT(port);
    2835 + b53_write16(dev, B53_CTRL_PAGE, B53_DIS_LEARNING, reg);
    2836 +}
    2837 +
    2838 int b53_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
    2839 {
    2840 struct b53_device *dev = ds->priv;
    2841 @@ -527,6 +540,7 @@ int b53_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
    2842 cpu_port = ds->ports[port].cpu_dp->index;
    2843
    2844 b53_br_egress_floods(ds, port, true, true);
    2845 + b53_port_set_learning(dev, port, false);
    2846
    2847 if (dev->ops->irq_enable)
    2848 ret = dev->ops->irq_enable(dev, port);
    2849 @@ -645,6 +659,7 @@ static void b53_enable_cpu_port(struct b53_device *dev, int port)
    2850 b53_brcm_hdr_setup(dev->ds, port);
    2851
    2852 b53_br_egress_floods(dev->ds, port, true, true);
    2853 + b53_port_set_learning(dev, port, false);
    2854 }
    2855
    2856 static void b53_enable_mib(struct b53_device *dev)
    2857 @@ -1704,6 +1719,8 @@ int b53_br_join(struct dsa_switch *ds, int port, struct net_device *br)
    2858 b53_write16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), pvlan);
    2859 dev->ports[port].vlan_ctl_mask = pvlan;
    2860
    2861 + b53_port_set_learning(dev, port, true);
    2862 +
    2863 return 0;
    2864 }
    2865 EXPORT_SYMBOL(b53_br_join);
    2866 @@ -1751,6 +1768,7 @@ void b53_br_leave(struct dsa_switch *ds, int port, struct net_device *br)
    2867 vl->untag |= BIT(port) | BIT(cpu_port);
    2868 b53_set_vlan_entry(dev, pvid, vl);
    2869 }
    2870 + b53_port_set_learning(dev, port, false);
    2871 }
    2872 EXPORT_SYMBOL(b53_br_leave);
    2873
    2874 diff --git a/drivers/net/dsa/b53/b53_regs.h b/drivers/net/dsa/b53/b53_regs.h
    2875 index c90985c294a2e..b2c539a421545 100644
    2876 --- a/drivers/net/dsa/b53/b53_regs.h
    2877 +++ b/drivers/net/dsa/b53/b53_regs.h
    2878 @@ -115,6 +115,7 @@
    2879 #define B53_UC_FLOOD_MASK 0x32
    2880 #define B53_MC_FLOOD_MASK 0x34
    2881 #define B53_IPMC_FLOOD_MASK 0x36
    2882 +#define B53_DIS_LEARNING 0x3c
    2883
    2884 /*
    2885 * Override Ports 0-7 State on devices with xMII interfaces (8 bit)
    2886 diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c
    2887 index 6dd29bad1609f..ca425c15953b1 100644
    2888 --- a/drivers/net/dsa/bcm_sf2.c
    2889 +++ b/drivers/net/dsa/bcm_sf2.c
    2890 @@ -172,11 +172,6 @@ static int bcm_sf2_port_setup(struct dsa_switch *ds, int port,
    2891 reg &= ~P_TXQ_PSM_VDD(port);
    2892 core_writel(priv, reg, CORE_MEM_PSM_VDD_CTRL);
    2893
    2894 - /* Enable learning */
    2895 - reg = core_readl(priv, CORE_DIS_LEARN);
    2896 - reg &= ~BIT(port);
    2897 - core_writel(priv, reg, CORE_DIS_LEARN);
    2898 -
    2899 /* Enable Broadcom tags for that port if requested */
    2900 if (priv->brcm_tag_mask & BIT(port))
    2901 b53_brcm_hdr_setup(ds, port);
    2902 diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
    2903 index 08ca9441270d2..a352c1704042d 100644
    2904 --- a/fs/btrfs/block-group.c
    2905 +++ b/fs/btrfs/block-group.c
    2906 @@ -2048,8 +2048,17 @@ static u64 update_block_group_flags(struct btrfs_fs_info *fs_info, u64 flags)
    2907 return flags;
    2908 }
    2909
    2910 -int btrfs_inc_block_group_ro(struct btrfs_block_group_cache *cache)
    2911 -
    2912 +/*
    2913 + * Mark one block group RO, can be called several times for the same block
    2914 + * group.
    2915 + *
    2916 + * @cache: the destination block group
    2917 + * @do_chunk_alloc: whether need to do chunk pre-allocation, this is to
    2918 + * ensure we still have some free space after marking this
    2919 + * block group RO.
    2920 + */
    2921 +int btrfs_inc_block_group_ro(struct btrfs_block_group_cache *cache,
    2922 + bool do_chunk_alloc)
    2923 {
    2924 struct btrfs_fs_info *fs_info = cache->fs_info;
    2925 struct btrfs_trans_handle *trans;
    2926 @@ -2079,25 +2088,29 @@ again:
    2927 goto again;
    2928 }
    2929
    2930 - /*
    2931 - * if we are changing raid levels, try to allocate a corresponding
    2932 - * block group with the new raid level.
    2933 - */
    2934 - alloc_flags = update_block_group_flags(fs_info, cache->flags);
    2935 - if (alloc_flags != cache->flags) {
    2936 - ret = btrfs_chunk_alloc(trans, alloc_flags, CHUNK_ALLOC_FORCE);
    2937 + if (do_chunk_alloc) {
    2938 /*
    2939 - * ENOSPC is allowed here, we may have enough space
    2940 - * already allocated at the new raid level to
    2941 - * carry on
    2942 + * If we are changing raid levels, try to allocate a
    2943 + * corresponding block group with the new raid level.
    2944 */
    2945 - if (ret == -ENOSPC)
    2946 - ret = 0;
    2947 - if (ret < 0)
    2948 - goto out;
    2949 + alloc_flags = update_block_group_flags(fs_info, cache->flags);
    2950 + if (alloc_flags != cache->flags) {
    2951 + ret = btrfs_chunk_alloc(trans, alloc_flags,
    2952 + CHUNK_ALLOC_FORCE);
    2953 + /*
    2954 + * ENOSPC is allowed here, we may have enough space
    2955 + * already allocated at the new raid level to carry on
    2956 + */
    2957 + if (ret == -ENOSPC)
    2958 + ret = 0;
    2959 + if (ret < 0)
    2960 + goto out;
    2961 + }
    2962 }
    2963
    2964 - ret = inc_block_group_ro(cache, 0);
    2965 + ret = inc_block_group_ro(cache, !do_chunk_alloc);
    2966 + if (!do_chunk_alloc)
    2967 + goto unlock_out;
    2968 if (!ret)
    2969 goto out;
    2970 alloc_flags = btrfs_get_alloc_profile(fs_info, cache->space_info->flags);
    2971 @@ -2112,6 +2125,7 @@ out:
    2972 check_system_chunk(trans, alloc_flags);
    2973 mutex_unlock(&fs_info->chunk_mutex);
    2974 }
    2975 +unlock_out:
    2976 mutex_unlock(&fs_info->ro_block_group_mutex);
    2977
    2978 btrfs_end_transaction(trans);
    2979 diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h
    2980 index c391800388dda..0758e6d52acba 100644
    2981 --- a/fs/btrfs/block-group.h
    2982 +++ b/fs/btrfs/block-group.h
    2983 @@ -205,7 +205,8 @@ int btrfs_read_block_groups(struct btrfs_fs_info *info);
    2984 int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used,
    2985 u64 type, u64 chunk_offset, u64 size);
    2986 void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans);
    2987 -int btrfs_inc_block_group_ro(struct btrfs_block_group_cache *cache);
    2988 +int btrfs_inc_block_group_ro(struct btrfs_block_group_cache *cache,
    2989 + bool do_chunk_alloc);
    2990 void btrfs_dec_block_group_ro(struct btrfs_block_group_cache *cache);
    2991 int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans);
    2992 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans);
    2993 diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
    2994 index 05b3e27b21d44..68b5d7c4aa491 100644
    2995 --- a/fs/btrfs/relocation.c
    2996 +++ b/fs/btrfs/relocation.c
    2997 @@ -4428,7 +4428,7 @@ int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start)
    2998 rc->extent_root = extent_root;
    2999 rc->block_group = bg;
    3000
    3001 - ret = btrfs_inc_block_group_ro(rc->block_group);
    3002 + ret = btrfs_inc_block_group_ro(rc->block_group, true);
    3003 if (ret) {
    3004 err = ret;
    3005 goto out;
    3006 diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
    3007 index 93d7cb56e44b2..e5db948daa123 100644
    3008 --- a/fs/btrfs/scrub.c
    3009 +++ b/fs/btrfs/scrub.c
    3010 @@ -3560,7 +3560,26 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
    3011 * -> btrfs_scrub_pause()
    3012 */
    3013 scrub_pause_on(fs_info);
    3014 - ret = btrfs_inc_block_group_ro(cache);
    3015 +
    3016 + /*
    3017 + * Don't do chunk preallocation for scrub.
    3018 + *
    3019 + * This is especially important for SYSTEM bgs, or we can hit
    3020 + * -EFBIG from btrfs_finish_chunk_alloc() like:
    3021 + * 1. The only SYSTEM bg is marked RO.
    3022 + * Since SYSTEM bg is small, that's pretty common.
    3023 + * 2. New SYSTEM bg will be allocated
    3024 + * Due to regular version will allocate new chunk.
    3025 + * 3. New SYSTEM bg is empty and will get cleaned up
    3026 + * Before cleanup really happens, it's marked RO again.
    3027 + * 4. Empty SYSTEM bg get scrubbed
    3028 + * We go back to 2.
    3029 + *
    3030 + * This can easily boost the amount of SYSTEM chunks if cleaner
    3031 + * thread can't be triggered fast enough, and use up all space
    3032 + * of btrfs_super_block::sys_chunk_array
    3033 + */
    3034 + ret = btrfs_inc_block_group_ro(cache, false);
    3035 if (!ret && sctx->is_dev_replace) {
    3036 /*
    3037 * If we are doing a device replace wait for any tasks
    3038 diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
    3039 index e3688312e9f1b..43bacf0a6bd31 100644
    3040 --- a/fs/fuse/fuse_i.h
    3041 +++ b/fs/fuse/fuse_i.h
    3042 @@ -791,6 +791,7 @@ static inline u64 fuse_get_attr_version(struct fuse_conn *fc)
    3043
    3044 static inline void fuse_make_bad(struct inode *inode)
    3045 {
    3046 + remove_inode_hash(inode);
    3047 set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);
    3048 }
    3049
    3050 diff --git a/include/crypto/cast6.h b/include/crypto/cast6.h
    3051 index c71f6ef47f0f4..4c8d0c72f78d4 100644
    3052 --- a/include/crypto/cast6.h
    3053 +++ b/include/crypto/cast6.h
    3054 @@ -19,7 +19,7 @@ int __cast6_setkey(struct cast6_ctx *ctx, const u8 *key,
    3055 unsigned int keylen, u32 *flags);
    3056 int cast6_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen);
    3057
    3058 -void __cast6_encrypt(struct cast6_ctx *ctx, u8 *dst, const u8 *src);
    3059 -void __cast6_decrypt(struct cast6_ctx *ctx, u8 *dst, const u8 *src);
    3060 +void __cast6_encrypt(const void *ctx, u8 *dst, const u8 *src);
    3061 +void __cast6_decrypt(const void *ctx, u8 *dst, const u8 *src);
    3062
    3063 #endif
    3064 diff --git a/include/crypto/serpent.h b/include/crypto/serpent.h
    3065 index 7dd780c5d0589..75c7eaa208535 100644
    3066 --- a/include/crypto/serpent.h
    3067 +++ b/include/crypto/serpent.h
    3068 @@ -22,7 +22,7 @@ int __serpent_setkey(struct serpent_ctx *ctx, const u8 *key,
    3069 unsigned int keylen);
    3070 int serpent_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen);
    3071
    3072 -void __serpent_encrypt(struct serpent_ctx *ctx, u8 *dst, const u8 *src);
    3073 -void __serpent_decrypt(struct serpent_ctx *ctx, u8 *dst, const u8 *src);
    3074 +void __serpent_encrypt(const void *ctx, u8 *dst, const u8 *src);
    3075 +void __serpent_decrypt(const void *ctx, u8 *dst, const u8 *src);
    3076
    3077 #endif
    3078 diff --git a/include/crypto/xts.h b/include/crypto/xts.h
    3079 index 75fd96ff976b7..15ae7fdc04789 100644
    3080 --- a/include/crypto/xts.h
    3081 +++ b/include/crypto/xts.h
    3082 @@ -8,8 +8,6 @@
    3083
    3084 #define XTS_BLOCK_SIZE 16
    3085
    3086 -#define XTS_TWEAK_CAST(x) ((void (*)(void *, u8*, const u8*))(x))
    3087 -
    3088 static inline int xts_check_key(struct crypto_tfm *tfm,
    3089 const u8 *key, unsigned int keylen)
    3090 {
    3091 diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
    3092 index e6a43c0fdee88..ab2a4b7dfca57 100644
    3093 --- a/kernel/bpf/verifier.c
    3094 +++ b/kernel/bpf/verifier.c
    3095 @@ -4268,10 +4268,14 @@ static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg,
    3096 {
    3097 bool mask_to_left = (opcode == BPF_ADD && off_is_neg) ||
    3098 (opcode == BPF_SUB && !off_is_neg);
    3099 - u32 off;
    3100 + u32 off, max;
    3101
    3102 switch (ptr_reg->type) {
    3103 case PTR_TO_STACK:
    3104 + /* Offset 0 is out-of-bounds, but acceptable start for the
    3105 + * left direction, see BPF_REG_FP.
    3106 + */
    3107 + max = MAX_BPF_STACK + mask_to_left;
    3108 /* Indirect variable offset stack access is prohibited in
    3109 * unprivileged mode so it's not handled here.
    3110 */
    3111 @@ -4279,16 +4283,17 @@ static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg,
    3112 if (mask_to_left)
    3113 *ptr_limit = MAX_BPF_STACK + off;
    3114 else
    3115 - *ptr_limit = -off;
    3116 - return 0;
    3117 + *ptr_limit = -off - 1;
    3118 + return *ptr_limit >= max ? -ERANGE : 0;
    3119 case PTR_TO_MAP_VALUE:
    3120 + max = ptr_reg->map_ptr->value_size;
    3121 if (mask_to_left) {
    3122 *ptr_limit = ptr_reg->umax_value + ptr_reg->off;
    3123 } else {
    3124 off = ptr_reg->smin_value + ptr_reg->off;
    3125 - *ptr_limit = ptr_reg->map_ptr->value_size - off;
    3126 + *ptr_limit = ptr_reg->map_ptr->value_size - off - 1;
    3127 }
    3128 - return 0;
    3129 + return *ptr_limit >= max ? -ERANGE : 0;
    3130 default:
    3131 return -EINVAL;
    3132 }
    3133 @@ -4341,6 +4346,7 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env,
    3134 u32 alu_state, alu_limit;
    3135 struct bpf_reg_state tmp;
    3136 bool ret;
    3137 + int err;
    3138
    3139 if (can_skip_alu_sanitation(env, insn))
    3140 return 0;
    3141 @@ -4356,10 +4362,13 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env,
    3142 alu_state |= ptr_is_dst_reg ?
    3143 BPF_ALU_SANITIZE_SRC : BPF_ALU_SANITIZE_DST;
    3144
    3145 - if (retrieve_ptr_limit(ptr_reg, &alu_limit, opcode, off_is_neg))
    3146 - return 0;
    3147 - if (update_alu_sanitation_state(aux, alu_state, alu_limit))
    3148 - return -EACCES;
    3149 + err = retrieve_ptr_limit(ptr_reg, &alu_limit, opcode, off_is_neg);
    3150 + if (err < 0)
    3151 + return err;
    3152 +
    3153 + err = update_alu_sanitation_state(aux, alu_state, alu_limit);
    3154 + if (err < 0)
    3155 + return err;
    3156 do_sim:
    3157 /* Simulate and find potential out-of-bounds access under
    3158 * speculative execution from truncation as a result of
    3159 @@ -4467,7 +4476,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
    3160 case BPF_ADD:
    3161 ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);
    3162 if (ret < 0) {
    3163 - verbose(env, "R%d tried to add from different maps or paths\n", dst);
    3164 + verbose(env, "R%d tried to add from different maps, paths, or prohibited types\n", dst);
    3165 return ret;
    3166 }
    3167 /* We can take a fixed offset as long as it doesn't overflow
    3168 @@ -4522,7 +4531,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
    3169 case BPF_SUB:
    3170 ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);
    3171 if (ret < 0) {
    3172 - verbose(env, "R%d tried to sub from different maps or paths\n", dst);
    3173 + verbose(env, "R%d tried to sub from different maps, paths, or prohibited types\n", dst);
    3174 return ret;
    3175 }
    3176 if (dst_reg == off_reg) {
    3177 @@ -9077,7 +9086,7 @@ static int fixup_bpf_calls(struct bpf_verifier_env *env)
    3178 off_reg = issrc ? insn->src_reg : insn->dst_reg;
    3179 if (isneg)
    3180 *patch++ = BPF_ALU64_IMM(BPF_MUL, off_reg, -1);
    3181 - *patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit - 1);
    3182 + *patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit);
    3183 *patch++ = BPF_ALU64_REG(BPF_SUB, BPF_REG_AX, off_reg);
    3184 *patch++ = BPF_ALU64_REG(BPF_OR, BPF_REG_AX, off_reg);
    3185 *patch++ = BPF_ALU64_IMM(BPF_NEG, BPF_REG_AX, 0);
    3186 diff --git a/net/dsa/tag_mtk.c b/net/dsa/tag_mtk.c
    3187 index d6619edd53e5a..edc505e07125b 100644
    3188 --- a/net/dsa/tag_mtk.c
    3189 +++ b/net/dsa/tag_mtk.c
    3190 @@ -13,6 +13,7 @@
    3191 #define MTK_HDR_LEN 4
    3192 #define MTK_HDR_XMIT_UNTAGGED 0
    3193 #define MTK_HDR_XMIT_TAGGED_TPID_8100 1
    3194 +#define MTK_HDR_XMIT_TAGGED_TPID_88A8 2
    3195 #define MTK_HDR_RECV_SOURCE_PORT_MASK GENMASK(2, 0)
    3196 #define MTK_HDR_XMIT_DP_BIT_MASK GENMASK(5, 0)
    3197 #define MTK_HDR_XMIT_SA_DIS BIT(6)
    3198 @@ -21,8 +22,8 @@ static struct sk_buff *mtk_tag_xmit(struct sk_buff *skb,
    3199 struct net_device *dev)
    3200 {
    3201 struct dsa_port *dp = dsa_slave_to_port(dev);
    3202 + u8 xmit_tpid;
    3203 u8 *mtk_tag;
    3204 - bool is_vlan_skb = true;
    3205 unsigned char *dest = eth_hdr(skb)->h_dest;
    3206 bool is_multicast_skb = is_multicast_ether_addr(dest) &&
    3207 !is_broadcast_ether_addr(dest);
    3208 @@ -33,13 +34,20 @@ static struct sk_buff *mtk_tag_xmit(struct sk_buff *skb,
    3209 * the both special and VLAN tag at the same time and then look up VLAN
    3210 * table with VID.
    3211 */
    3212 - if (!skb_vlan_tagged(skb)) {
    3213 + switch (skb->protocol) {
    3214 + case htons(ETH_P_8021Q):
    3215 + xmit_tpid = MTK_HDR_XMIT_TAGGED_TPID_8100;
    3216 + break;
    3217 + case htons(ETH_P_8021AD):
    3218 + xmit_tpid = MTK_HDR_XMIT_TAGGED_TPID_88A8;
    3219 + break;
    3220 + default:
    3221 if (skb_cow_head(skb, MTK_HDR_LEN) < 0)
    3222 return NULL;
    3223
    3224 + xmit_tpid = MTK_HDR_XMIT_UNTAGGED;
    3225 skb_push(skb, MTK_HDR_LEN);
    3226 memmove(skb->data, skb->data + MTK_HDR_LEN, 2 * ETH_ALEN);
    3227 - is_vlan_skb = false;
    3228 }
    3229
    3230 mtk_tag = skb->data + 2 * ETH_ALEN;
    3231 @@ -47,8 +55,7 @@ static struct sk_buff *mtk_tag_xmit(struct sk_buff *skb,
    3232 /* Mark tag attribute on special tag insertion to notify hardware
    3233 * whether that's a combined special tag with 802.1Q header.
    3234 */
    3235 - mtk_tag[0] = is_vlan_skb ? MTK_HDR_XMIT_TAGGED_TPID_8100 :
    3236 - MTK_HDR_XMIT_UNTAGGED;
    3237 + mtk_tag[0] = xmit_tpid;
    3238 mtk_tag[1] = (1 << dp->index) & MTK_HDR_XMIT_DP_BIT_MASK;
    3239
    3240 /* Disable SA learning for multicast frames */
    3241 @@ -56,7 +63,7 @@ static struct sk_buff *mtk_tag_xmit(struct sk_buff *skb,
    3242 mtk_tag[1] |= MTK_HDR_XMIT_SA_DIS;
    3243
    3244 /* Tag control information is kept for 802.1Q */
    3245 - if (!is_vlan_skb) {
    3246 + if (xmit_tpid == MTK_HDR_XMIT_UNTAGGED) {
    3247 mtk_tag[2] = 0;
    3248 mtk_tag[3] = 0;
    3249 }
    3250 diff --git a/tools/testing/selftests/bpf/verifier/bounds_deduction.c b/tools/testing/selftests/bpf/verifier/bounds_deduction.c
    3251 index 1fd07a4f27ac2..c162498a64fc6 100644
    3252 --- a/tools/testing/selftests/bpf/verifier/bounds_deduction.c
    3253 +++ b/tools/testing/selftests/bpf/verifier/bounds_deduction.c
    3254 @@ -6,8 +6,9 @@
    3255 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3256 BPF_EXIT_INSN(),
    3257 },
    3258 - .result = REJECT,
    3259 + .errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
    3260 .errstr = "R0 tried to subtract pointer from scalar",
    3261 + .result = REJECT,
    3262 },
    3263 {
    3264 "check deducing bounds from const, 2",
    3265 @@ -20,6 +21,8 @@
    3266 BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),
    3267 BPF_EXIT_INSN(),
    3268 },
    3269 + .errstr_unpriv = "R1 tried to sub from different maps, paths, or prohibited types",
    3270 + .result_unpriv = REJECT,
    3271 .result = ACCEPT,
    3272 .retval = 1,
    3273 },
    3274 @@ -31,8 +34,9 @@
    3275 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3276 BPF_EXIT_INSN(),
    3277 },
    3278 - .result = REJECT,
    3279 + .errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
    3280 .errstr = "R0 tried to subtract pointer from scalar",
    3281 + .result = REJECT,
    3282 },
    3283 {
    3284 "check deducing bounds from const, 4",
    3285 @@ -45,6 +49,8 @@
    3286 BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),
    3287 BPF_EXIT_INSN(),
    3288 },
    3289 + .errstr_unpriv = "R1 tried to sub from different maps, paths, or prohibited types",
    3290 + .result_unpriv = REJECT,
    3291 .result = ACCEPT,
    3292 },
    3293 {
    3294 @@ -55,8 +61,9 @@
    3295 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3296 BPF_EXIT_INSN(),
    3297 },
    3298 - .result = REJECT,
    3299 + .errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
    3300 .errstr = "R0 tried to subtract pointer from scalar",
    3301 + .result = REJECT,
    3302 },
    3303 {
    3304 "check deducing bounds from const, 6",
    3305 @@ -67,8 +74,9 @@
    3306 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3307 BPF_EXIT_INSN(),
    3308 },
    3309 - .result = REJECT,
    3310 + .errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
    3311 .errstr = "R0 tried to subtract pointer from scalar",
    3312 + .result = REJECT,
    3313 },
    3314 {
    3315 "check deducing bounds from const, 7",
    3316 @@ -80,8 +88,9 @@
    3317 offsetof(struct __sk_buff, mark)),
    3318 BPF_EXIT_INSN(),
    3319 },
    3320 - .result = REJECT,
    3321 + .errstr_unpriv = "R1 tried to sub from different maps, paths, or prohibited types",
    3322 .errstr = "dereference of modified ctx ptr",
    3323 + .result = REJECT,
    3324 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
    3325 },
    3326 {
    3327 @@ -94,8 +103,9 @@
    3328 offsetof(struct __sk_buff, mark)),
    3329 BPF_EXIT_INSN(),
    3330 },
    3331 - .result = REJECT,
    3332 + .errstr_unpriv = "R1 tried to add from different maps, paths, or prohibited types",
    3333 .errstr = "dereference of modified ctx ptr",
    3334 + .result = REJECT,
    3335 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
    3336 },
    3337 {
    3338 @@ -106,8 +116,9 @@
    3339 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3340 BPF_EXIT_INSN(),
    3341 },
    3342 - .result = REJECT,
    3343 + .errstr_unpriv = "R0 tried to sub from different maps, paths, or prohibited types",
    3344 .errstr = "R0 tried to subtract pointer from scalar",
    3345 + .result = REJECT,
    3346 },
    3347 {
    3348 "check deducing bounds from const, 10",
    3349 @@ -119,6 +130,6 @@
    3350 BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3351 BPF_EXIT_INSN(),
    3352 },
    3353 - .result = REJECT,
    3354 .errstr = "math between ctx pointer and register with unbounded min value is not allowed",
    3355 + .result = REJECT,
    3356 },
    3357 diff --git a/tools/testing/selftests/bpf/verifier/unpriv.c b/tools/testing/selftests/bpf/verifier/unpriv.c
    3358 index 91bb77c24a2ef..0d621c841db14 100644
    3359 --- a/tools/testing/selftests/bpf/verifier/unpriv.c
    3360 +++ b/tools/testing/selftests/bpf/verifier/unpriv.c
    3361 @@ -495,7 +495,7 @@
    3362 .result = ACCEPT,
    3363 },
    3364 {
    3365 - "unpriv: adding of fp",
    3366 + "unpriv: adding of fp, reg",
    3367 .insns = {
    3368 BPF_MOV64_IMM(BPF_REG_0, 0),
    3369 BPF_MOV64_IMM(BPF_REG_1, 0),
    3370 @@ -503,6 +503,19 @@
    3371 BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8),
    3372 BPF_EXIT_INSN(),
    3373 },
    3374 + .errstr_unpriv = "R1 tried to add from different maps, paths, or prohibited types",
    3375 + .result_unpriv = REJECT,
    3376 + .result = ACCEPT,
    3377 +},
    3378 +{
    3379 + "unpriv: adding of fp, imm",
    3380 + .insns = {
    3381 + BPF_MOV64_IMM(BPF_REG_0, 0),
    3382 + BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),
    3383 + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 0),
    3384 + BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8),
    3385 + BPF_EXIT_INSN(),
    3386 + },
    3387 .errstr_unpriv = "R1 stack pointer arithmetic goes out of range",
    3388 .result_unpriv = REJECT,
    3389 .result = ACCEPT,
    3390 diff --git a/tools/testing/selftests/bpf/verifier/value_ptr_arith.c b/tools/testing/selftests/bpf/verifier/value_ptr_arith.c
    3391 index a53d99cebd9ff..00b59d5d7a7f0 100644
    3392 --- a/tools/testing/selftests/bpf/verifier/value_ptr_arith.c
    3393 +++ b/tools/testing/selftests/bpf/verifier/value_ptr_arith.c
    3394 @@ -169,7 +169,7 @@
    3395 .fixup_map_array_48b = { 1 },
    3396 .result = ACCEPT,
    3397 .result_unpriv = REJECT,
    3398 - .errstr_unpriv = "R2 tried to add from different maps or paths",
    3399 + .errstr_unpriv = "R2 tried to add from different maps, paths, or prohibited types",
    3400 .retval = 0,
    3401 },
    3402 {
    3403 @@ -516,6 +516,27 @@
    3404 .result = ACCEPT,
    3405 .retval = 0xabcdef12,
    3406 },
    3407 +{
    3408 + "map access: value_ptr += N, value_ptr -= N known scalar",
    3409 + .insns = {
    3410 + BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
    3411 + BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
    3412 + BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
    3413 + BPF_LD_MAP_FD(BPF_REG_1, 0),
    3414 + BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
    3415 + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
    3416 + BPF_MOV32_IMM(BPF_REG_1, 0x12345678),
    3417 + BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
    3418 + BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 2),
    3419 + BPF_MOV64_IMM(BPF_REG_1, 2),
    3420 + BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
    3421 + BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0),
    3422 + BPF_EXIT_INSN(),
    3423 + },
    3424 + .fixup_map_array_48b = { 3 },
    3425 + .result = ACCEPT,
    3426 + .retval = 0x12345678,
    3427 +},
    3428 {
    3429 "map access: unknown scalar += value_ptr, 1",
    3430 .insns = {