+1 -1

arch/arm/crypto/aes-neonbs-glue.c

reviewed

··· 407 407 return crypto_register_skciphers(aes_algs, ARRAY_SIZE(aes_algs)); 408 408 } 409 409 410 410 - late_initcall(aes_init); 410 410 + module_init(aes_init); 411 411 module_exit(aes_exit);

+1 -1

arch/arm/lib/crypto/chacha-glue.c

reviewed

··· 122 122 } 123 123 return 0; 124 124 } 125 125 - arch_initcall(chacha_arm_mod_init); 125 125 + subsys_initcall(chacha_arm_mod_init); 126 126 127 127 static void __exit chacha_arm_mod_exit(void) 128 128 {

+1 -1

arch/arm/lib/crypto/poly1305-glue.c

reviewed

··· 69 69 static_branch_enable(&have_neon); 70 70 return 0; 71 71 } 72 72 - arch_initcall(arm_poly1305_mod_init); 72 72 + subsys_initcall(arm_poly1305_mod_init); 73 73 74 74 static void __exit arm_poly1305_mod_exit(void) 75 75 {

+1 -1

arch/arm/lib/crypto/sha256.c

reviewed

··· 53 53 } 54 54 return 0; 55 55 } 56 56 - arch_initcall(sha256_arm_mod_init); 56 56 + subsys_initcall(sha256_arm_mod_init); 57 57 58 58 static void __exit sha256_arm_mod_exit(void) 59 59 {

+1 -1

arch/arm64/lib/crypto/chacha-neon-glue.c

reviewed

··· 104 104 static_branch_enable(&have_neon); 105 105 return 0; 106 106 } 107 107 - arch_initcall(chacha_simd_mod_init); 107 107 + subsys_initcall(chacha_simd_mod_init); 108 108 109 109 static void __exit chacha_simd_mod_exit(void) 110 110 {

+1 -1

arch/arm64/lib/crypto/poly1305-glue.c

reviewed

··· 62 62 static_branch_enable(&have_neon); 63 63 return 0; 64 64 } 65 65 - arch_initcall(neon_poly1305_mod_init); 65 65 + subsys_initcall(neon_poly1305_mod_init); 66 66 67 67 static void __exit neon_poly1305_mod_exit(void) 68 68 {

+1 -1

arch/arm64/lib/crypto/sha256.c

reviewed

··· 64 64 } 65 65 return 0; 66 66 } 67 67 - arch_initcall(sha256_arm64_mod_init); 67 67 + subsys_initcall(sha256_arm64_mod_init); 68 68 69 69 static void __exit sha256_arm64_mod_exit(void) 70 70 {

+1 -1

arch/powerpc/lib/crypto/chacha-p10-glue.c

reviewed

··· 87 87 static_branch_enable(&have_p10); 88 88 return 0; 89 89 } 90 90 - arch_initcall(chacha_p10_init); 90 90 + subsys_initcall(chacha_p10_init); 91 91 92 92 static void __exit chacha_p10_exit(void) 93 93 {

+1 -1

arch/powerpc/lib/crypto/poly1305-p10-glue.c

reviewed

··· 76 76 static_branch_enable(&have_p10); 77 77 return 0; 78 78 } 79 79 - arch_initcall(poly1305_p10_init); 79 79 + subsys_initcall(poly1305_p10_init); 80 80 81 81 static void __exit poly1305_p10_exit(void) 82 82 {

+1 -1

arch/riscv/lib/crypto/chacha-riscv64-glue.c

reviewed

··· 62 62 static_branch_enable(&use_zvkb); 63 63 return 0; 64 64 } 65 65 - arch_initcall(riscv64_chacha_mod_init); 65 65 + subsys_initcall(riscv64_chacha_mod_init); 66 66 67 67 static void __exit riscv64_chacha_mod_exit(void) 68 68 {

+1 -1

arch/riscv/lib/crypto/sha256.c

reviewed

··· 50 50 static_branch_enable(&have_extensions); 51 51 return 0; 52 52 } 53 53 - arch_initcall(riscv64_sha256_mod_init); 53 53 + subsys_initcall(riscv64_sha256_mod_init); 54 54 55 55 static void __exit riscv64_sha256_mod_exit(void) 56 56 {

+1 -1

arch/s390/lib/crypto/sha256.c

reviewed

··· 36 36 static_branch_enable(&have_cpacf_sha256); 37 37 return 0; 38 38 } 39 39 - arch_initcall(sha256_s390_mod_init); 39 39 + subsys_initcall(sha256_s390_mod_init); 40 40 41 41 static void __exit sha256_s390_mod_exit(void) 42 42 {

+1 -1

arch/sparc/lib/crypto/sha256.c

reviewed

··· 53 53 pr_info("Using sparc64 sha256 opcode optimized SHA-256/SHA-224 implementation\n"); 54 54 return 0; 55 55 } 56 56 - arch_initcall(sha256_sparc64_mod_init); 56 56 + subsys_initcall(sha256_sparc64_mod_init); 57 57 58 58 static void __exit sha256_sparc64_mod_exit(void) 59 59 {

+1 -1

arch/x86/lib/crypto/chacha_glue.c

reviewed

··· 174 174 } 175 175 return 0; 176 176 } 177 177 - arch_initcall(chacha_simd_mod_init); 177 177 + subsys_initcall(chacha_simd_mod_init); 178 178 179 179 static void __exit chacha_simd_mod_exit(void) 180 180 {

+1 -1

arch/x86/lib/crypto/poly1305_glue.c

reviewed

··· 117 117 static_branch_enable(&poly1305_use_avx512); 118 118 return 0; 119 119 } 120 120 - arch_initcall(poly1305_simd_mod_init); 120 120 + subsys_initcall(poly1305_simd_mod_init); 121 121 122 122 static void __exit poly1305_simd_mod_exit(void) 123 123 {

+1 -1

arch/x86/lib/crypto/sha256.c

reviewed

··· 63 63 static_branch_enable(&have_sha256_x86); 64 64 return 0; 65 65 } 66 66 - arch_initcall(sha256_x86_mod_init); 66 66 + subsys_initcall(sha256_x86_mod_init); 67 67 68 68 static void __exit sha256_x86_mod_exit(void) 69 69 {

+1 -1

crypto/842.c

reviewed

··· 70 70 { 71 71 return crypto_register_scomp(&scomp); 72 72 } 73 73 - subsys_initcall(crypto842_mod_init); 73 73 + module_init(crypto842_mod_init); 74 74 75 75 static void __exit crypto842_mod_exit(void) 76 76 {

+1 -1

crypto/adiantum.c

reviewed

··· 639 639 crypto_unregister_template(&adiantum_tmpl); 640 640 } 641 641 642 642 - subsys_initcall(adiantum_module_init); 642 642 + module_init(adiantum_module_init); 643 643 module_exit(adiantum_module_exit); 644 644 645 645 MODULE_DESCRIPTION("Adiantum length-preserving encryption mode");

+1 -1

crypto/aegis128-core.c

reviewed

··· 566 566 crypto_unregister_aead(&crypto_aegis128_alg_generic); 567 567 } 568 568 569 569 - subsys_initcall(crypto_aegis128_module_init); 569 569 + module_init(crypto_aegis128_module_init); 570 570 module_exit(crypto_aegis128_module_exit); 571 571 572 572 MODULE_LICENSE("GPL");

+1 -1

crypto/aes_generic.c

reviewed

··· 1311 1311 crypto_unregister_alg(&aes_alg); 1312 1312 } 1313 1313 1314 1314 - subsys_initcall(aes_init); 1314 1314 + module_init(aes_init); 1315 1315 module_exit(aes_fini); 1316 1316 1317 1317 MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");

+1 -7

crypto/algboss.c

reviewed

··· 247 247 BUG_ON(err); 248 248 } 249 249 250 250 - /* 251 251 - * This is arch_initcall() so that the crypto self-tests are run on algorithms 252 252 - * registered early by subsys_initcall(). subsys_initcall() is needed for 253 253 - * generic implementations so that they're available for comparison tests when 254 254 - * other implementations are registered later by module_init(). 255 255 - */ 256 256 - arch_initcall(cryptomgr_init); 250 250 + module_init(cryptomgr_init); 257 251 module_exit(cryptomgr_exit); 258 252 259 253 MODULE_LICENSE("GPL");

+1 -1

crypto/ansi_cprng.c

reviewed

··· 467 467 MODULE_AUTHOR("Neil Horman <nhorman@tuxdriver.com>"); 468 468 module_param(dbg, int, 0); 469 469 MODULE_PARM_DESC(dbg, "Boolean to enable debugging (0/1 == off/on)"); 470 470 - subsys_initcall(prng_mod_init); 470 470 + module_init(prng_mod_init); 471 471 module_exit(prng_mod_fini); 472 472 MODULE_ALIAS_CRYPTO("stdrng"); 473 473 MODULE_ALIAS_CRYPTO("ansi_cprng");

+1 -1

crypto/anubis.c

reviewed

··· 694 694 crypto_unregister_alg(&anubis_alg); 695 695 } 696 696 697 697 - subsys_initcall(anubis_mod_init); 697 697 + module_init(anubis_mod_init); 698 698 module_exit(anubis_mod_fini); 699 699 700 700 MODULE_LICENSE("GPL");

+1 -1

crypto/arc4.c

reviewed

··· 73 73 crypto_unregister_lskcipher(&arc4_alg); 74 74 } 75 75 76 76 - subsys_initcall(arc4_init); 76 76 + module_init(arc4_init); 77 77 module_exit(arc4_exit); 78 78 79 79 MODULE_LICENSE("GPL");

+1 -1

crypto/aria_generic.c

reviewed

··· 304 304 crypto_unregister_alg(&aria_alg); 305 305 } 306 306 307 307 - subsys_initcall(aria_init); 307 307 + module_init(aria_init); 308 308 module_exit(aria_fini); 309 309 310 310 MODULE_DESCRIPTION("ARIA Cipher Algorithm");

+1 -1

crypto/authenc.c

reviewed

··· 451 451 crypto_unregister_template(&crypto_authenc_tmpl); 452 452 } 453 453 454 454 - subsys_initcall(crypto_authenc_module_init); 454 454 + module_init(crypto_authenc_module_init); 455 455 module_exit(crypto_authenc_module_exit); 456 456 457 457 MODULE_LICENSE("GPL");

+1 -1

crypto/authencesn.c

reviewed

··· 465 465 crypto_unregister_template(&crypto_authenc_esn_tmpl); 466 466 } 467 467 468 468 - subsys_initcall(crypto_authenc_esn_module_init); 468 468 + module_init(crypto_authenc_esn_module_init); 469 469 module_exit(crypto_authenc_esn_module_exit); 470 470 471 471 MODULE_LICENSE("GPL");

+1 -1

crypto/blake2b_generic.c

reviewed

··· 176 176 crypto_unregister_shashes(blake2b_algs, ARRAY_SIZE(blake2b_algs)); 177 177 } 178 178 179 179 - subsys_initcall(blake2b_mod_init); 179 179 + module_init(blake2b_mod_init); 180 180 module_exit(blake2b_mod_fini); 181 181 182 182 MODULE_AUTHOR("David Sterba <kdave@kernel.org>");

+1 -1

crypto/blowfish_generic.c

reviewed

··· 124 124 crypto_unregister_alg(&alg); 125 125 } 126 126 127 127 - subsys_initcall(blowfish_mod_init); 127 127 + module_init(blowfish_mod_init); 128 128 module_exit(blowfish_mod_fini); 129 129 130 130 MODULE_LICENSE("GPL");

+1 -1

crypto/camellia_generic.c

reviewed

··· 1064 1064 crypto_unregister_alg(&camellia_alg); 1065 1065 } 1066 1066 1067 1067 - subsys_initcall(camellia_init); 1067 1067 + module_init(camellia_init); 1068 1068 module_exit(camellia_fini); 1069 1069 1070 1070 MODULE_DESCRIPTION("Camellia Cipher Algorithm");

+1 -1

crypto/cast5_generic.c

reviewed

··· 531 531 crypto_unregister_alg(&alg); 532 532 } 533 533 534 534 - subsys_initcall(cast5_mod_init); 534 534 + module_init(cast5_mod_init); 535 535 module_exit(cast5_mod_fini); 536 536 537 537 MODULE_LICENSE("GPL");

+1 -1

crypto/cast6_generic.c

reviewed

··· 271 271 crypto_unregister_alg(&alg); 272 272 } 273 273 274 274 - subsys_initcall(cast6_mod_init); 274 274 + module_init(cast6_mod_init); 275 275 module_exit(cast6_mod_fini); 276 276 277 277 MODULE_LICENSE("GPL");

+1 -1

crypto/cbc.c

reviewed

··· 179 179 crypto_unregister_template(&crypto_cbc_tmpl); 180 180 } 181 181 182 182 - subsys_initcall(crypto_cbc_module_init); 182 182 + module_init(crypto_cbc_module_init); 183 183 module_exit(crypto_cbc_module_exit); 184 184 185 185 MODULE_LICENSE("GPL");

+1 -1

crypto/ccm.c

reviewed

··· 929 929 ARRAY_SIZE(crypto_ccm_tmpls)); 930 930 } 931 931 932 932 - subsys_initcall(crypto_ccm_module_init); 932 932 + module_init(crypto_ccm_module_init); 933 933 module_exit(crypto_ccm_module_exit); 934 934 935 935 MODULE_LICENSE("GPL");

+1 -1

crypto/chacha.c

reviewed

··· 243 243 crypto_unregister_skciphers(algs, num_algs); 244 244 } 245 245 246 246 - subsys_initcall(crypto_chacha_mod_init); 246 246 + module_init(crypto_chacha_mod_init); 247 247 module_exit(crypto_chacha_mod_fini); 248 248 249 249 MODULE_LICENSE("GPL");

+1 -1

crypto/chacha20poly1305.c

reviewed

··· 476 476 ARRAY_SIZE(rfc7539_tmpls)); 477 477 } 478 478 479 479 - subsys_initcall(chacha20poly1305_module_init); 479 479 + module_init(chacha20poly1305_module_init); 480 480 module_exit(chacha20poly1305_module_exit); 481 481 482 482 MODULE_LICENSE("GPL");

+1 -1

crypto/cmac.c

reviewed

··· 251 251 crypto_unregister_template(&crypto_cmac_tmpl); 252 252 } 253 253 254 254 - subsys_initcall(crypto_cmac_module_init); 254 254 + module_init(crypto_cmac_module_init); 255 255 module_exit(crypto_cmac_module_exit); 256 256 257 257 MODULE_LICENSE("GPL");

+1 -1

crypto/crc32_generic.c

reviewed

··· 172 172 crypto_unregister_shashes(algs, num_algs); 173 173 } 174 174 175 175 - subsys_initcall(crc32_mod_init); 175 175 + module_init(crc32_mod_init); 176 176 module_exit(crc32_mod_fini); 177 177 178 178 MODULE_AUTHOR("Alexander Boyko <alexander_boyko@xyratex.com>");

+1 -1

crypto/crc32c_generic.c

reviewed

··· 212 212 crypto_unregister_shashes(algs, num_algs); 213 213 } 214 214 215 215 - subsys_initcall(crc32c_mod_init); 215 215 + module_init(crc32c_mod_init); 216 216 module_exit(crc32c_mod_fini); 217 217 218 218 MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");

+1 -1

crypto/cryptd.c

reviewed

··· 1138 1138 crypto_unregister_template(&cryptd_tmpl); 1139 1139 } 1140 1140 1141 1141 - subsys_initcall(cryptd_init); 1141 1141 + module_init(cryptd_init); 1142 1142 module_exit(cryptd_exit); 1143 1143 1144 1144 MODULE_LICENSE("GPL");

+1 -1

crypto/crypto_null.c

reviewed

··· 210 210 crypto_unregister_skcipher(&skcipher_null); 211 211 } 212 212 213 213 - subsys_initcall(crypto_null_mod_init); 213 213 + module_init(crypto_null_mod_init); 214 214 module_exit(crypto_null_mod_fini); 215 215 216 216 MODULE_LICENSE("GPL");

+1 -1

crypto/ctr.c

reviewed

··· 350 350 ARRAY_SIZE(crypto_ctr_tmpls)); 351 351 } 352 352 353 353 - subsys_initcall(crypto_ctr_module_init); 353 353 + module_init(crypto_ctr_module_init); 354 354 module_exit(crypto_ctr_module_exit); 355 355 356 356 MODULE_LICENSE("GPL");

+1 -1

crypto/cts.c

reviewed

··· 402 402 crypto_unregister_template(&crypto_cts_tmpl); 403 403 } 404 404 405 405 - subsys_initcall(crypto_cts_module_init); 405 405 + module_init(crypto_cts_module_init); 406 406 module_exit(crypto_cts_module_exit); 407 407 408 408 MODULE_LICENSE("Dual BSD/GPL");

+1 -1

crypto/curve25519-generic.c

reviewed

··· 82 82 crypto_unregister_kpp(&curve25519_alg); 83 83 } 84 84 85 85 - subsys_initcall(curve25519_init); 85 85 + module_init(curve25519_init); 86 86 module_exit(curve25519_exit); 87 87 88 88 MODULE_ALIAS_CRYPTO("curve25519");

+1 -1

crypto/deflate.c

reviewed

··· 243 243 crypto_acomp_free_streams(&deflate_streams); 244 244 } 245 245 246 246 - subsys_initcall(deflate_mod_init); 246 246 + module_init(deflate_mod_init); 247 247 module_exit(deflate_mod_fini); 248 248 249 249 MODULE_LICENSE("GPL");

+1 -1

crypto/des_generic.c

reviewed

··· 122 122 crypto_unregister_algs(des_algs, ARRAY_SIZE(des_algs)); 123 123 } 124 124 125 125 - subsys_initcall(des_generic_mod_init); 125 125 + module_init(des_generic_mod_init); 126 126 module_exit(des_generic_mod_fini); 127 127 128 128 MODULE_LICENSE("GPL");

+1 -1

crypto/dh.c

reviewed

··· 920 920 crypto_unregister_kpp(&dh); 921 921 } 922 922 923 923 - subsys_initcall(dh_init); 923 923 + module_init(dh_init); 924 924 module_exit(dh_exit); 925 925 MODULE_ALIAS_CRYPTO("dh"); 926 926 MODULE_LICENSE("GPL");

+1 -1

crypto/drbg.c

reviewed

··· 2132 2132 crypto_unregister_rngs(drbg_algs, (ARRAY_SIZE(drbg_cores) * 2)); 2133 2133 } 2134 2134 2135 2135 - subsys_initcall(drbg_init); 2135 2135 + module_init(drbg_init); 2136 2136 module_exit(drbg_exit); 2137 2137 #ifndef CRYPTO_DRBG_HASH_STRING 2138 2138 #define CRYPTO_DRBG_HASH_STRING ""

+1 -1

crypto/ecb.c

reviewed

··· 219 219 crypto_unregister_template(&crypto_ecb_tmpl); 220 220 } 221 221 222 222 - subsys_initcall(crypto_ecb_module_init); 222 222 + module_init(crypto_ecb_module_init); 223 223 module_exit(crypto_ecb_module_exit); 224 224 225 225 MODULE_LICENSE("GPL");

+1 -1

crypto/ecdh.c

reviewed

··· 240 240 crypto_unregister_kpp(&ecdh_nist_p384); 241 241 } 242 242 243 243 - subsys_initcall(ecdh_init); 243 243 + module_init(ecdh_init); 244 244 module_exit(ecdh_exit); 245 245 MODULE_ALIAS_CRYPTO("ecdh"); 246 246 MODULE_LICENSE("GPL");

+1 -1

crypto/ecdsa.c

reviewed

··· 334 334 crypto_unregister_sig(&ecdsa_nist_p521); 335 335 } 336 336 337 337 - subsys_initcall(ecdsa_init); 337 337 + module_init(ecdsa_init); 338 338 module_exit(ecdsa_exit); 339 339 340 340 MODULE_LICENSE("GPL");

+1 -1

crypto/echainiv.c

reviewed

··· 157 157 crypto_unregister_template(&echainiv_tmpl); 158 158 } 159 159 160 160 - subsys_initcall(echainiv_module_init); 160 160 + module_init(echainiv_module_init); 161 161 module_exit(echainiv_module_exit); 162 162 163 163 MODULE_LICENSE("GPL");

+1 -1

crypto/essiv.c

reviewed

··· 641 641 crypto_unregister_template(&essiv_tmpl); 642 642 } 643 643 644 644 - subsys_initcall(essiv_module_init); 644 644 + module_init(essiv_module_init); 645 645 module_exit(essiv_module_exit); 646 646 647 647 MODULE_DESCRIPTION("ESSIV skcipher/aead wrapper for block encryption");

+1 -1

crypto/fcrypt.c

reviewed

··· 411 411 crypto_unregister_alg(&fcrypt_alg); 412 412 } 413 413 414 414 - subsys_initcall(fcrypt_mod_init); 414 414 + module_init(fcrypt_mod_init); 415 415 module_exit(fcrypt_mod_fini); 416 416 417 417 MODULE_LICENSE("Dual BSD/GPL");

+1 -1

crypto/fips.c

reviewed

··· 95 95 crypto_proc_fips_exit(); 96 96 } 97 97 98 98 - subsys_initcall(fips_init); 98 98 + module_init(fips_init); 99 99 module_exit(fips_exit);

+1 -1

crypto/gcm.c

reviewed

··· 1152 1152 ARRAY_SIZE(crypto_gcm_tmpls)); 1153 1153 } 1154 1154 1155 1155 - subsys_initcall(crypto_gcm_module_init); 1155 1155 + module_init(crypto_gcm_module_init); 1156 1156 module_exit(crypto_gcm_module_exit); 1157 1157 1158 1158 MODULE_LICENSE("GPL");

+1 -1

crypto/ghash-generic.c

reviewed

··· 153 153 crypto_unregister_shash(&ghash_alg); 154 154 } 155 155 156 156 - subsys_initcall(ghash_mod_init); 156 156 + module_init(ghash_mod_init); 157 157 module_exit(ghash_mod_exit); 158 158 159 159 MODULE_LICENSE("GPL");

+1 -1

crypto/hctr2.c

reviewed

··· 570 570 ARRAY_SIZE(hctr2_tmpls)); 571 571 } 572 572 573 573 - subsys_initcall(hctr2_module_init); 573 573 + module_init(hctr2_module_init); 574 574 module_exit(hctr2_module_exit); 575 575 576 576 MODULE_DESCRIPTION("HCTR2 length-preserving encryption mode");

+1 -1

crypto/hmac.c

reviewed

··· 257 257 crypto_unregister_template(&hmac_tmpl); 258 258 } 259 259 260 260 - subsys_initcall(hmac_module_init); 260 260 + module_init(hmac_module_init); 261 261 module_exit(hmac_module_exit); 262 262 263 263 MODULE_LICENSE("GPL");

+1 -1

crypto/khazad.c

reviewed

··· 871 871 } 872 872 873 873 874 874 - subsys_initcall(khazad_mod_init); 874 874 + module_init(khazad_mod_init); 875 875 module_exit(khazad_mod_fini); 876 876 877 877 MODULE_LICENSE("GPL");

+1 -1

crypto/krb5enc.c

reviewed

··· 496 496 crypto_unregister_template(&crypto_krb5enc_tmpl); 497 497 } 498 498 499 499 - subsys_initcall(crypto_krb5enc_module_init); 499 499 + module_init(crypto_krb5enc_module_init); 500 500 module_exit(crypto_krb5enc_module_exit); 501 501 502 502 MODULE_LICENSE("GPL");

+1 -1

crypto/lrw.c

reviewed

··· 420 420 crypto_unregister_template(&lrw_tmpl); 421 421 } 422 422 423 423 - subsys_initcall(lrw_module_init); 423 423 + module_init(lrw_module_init); 424 424 module_exit(lrw_module_exit); 425 425 426 426 MODULE_LICENSE("GPL");

+1 -1

crypto/lz4.c

reviewed

··· 89 89 crypto_unregister_scomp(&scomp); 90 90 } 91 91 92 92 - subsys_initcall(lz4_mod_init); 92 92 + module_init(lz4_mod_init); 93 93 module_exit(lz4_mod_fini); 94 94 95 95 MODULE_LICENSE("GPL");

+1 -1

crypto/lz4hc.c

reviewed

··· 87 87 crypto_unregister_scomp(&scomp); 88 88 } 89 89 90 90 - subsys_initcall(lz4hc_mod_init); 90 90 + module_init(lz4hc_mod_init); 91 91 module_exit(lz4hc_mod_fini); 92 92 93 93 MODULE_LICENSE("GPL");

+1 -1

crypto/lzo-rle.c

reviewed

··· 91 91 crypto_unregister_scomp(&scomp); 92 92 } 93 93 94 94 - subsys_initcall(lzorle_mod_init); 94 94 + module_init(lzorle_mod_init); 95 95 module_exit(lzorle_mod_fini); 96 96 97 97 MODULE_LICENSE("GPL");

+1 -1

crypto/lzo.c

reviewed

··· 91 91 crypto_unregister_scomp(&scomp); 92 92 } 93 93 94 94 - subsys_initcall(lzo_mod_init); 94 94 + module_init(lzo_mod_init); 95 95 module_exit(lzo_mod_fini); 96 96 97 97 MODULE_LICENSE("GPL");

+1 -1

crypto/md4.c

reviewed

··· 233 233 crypto_unregister_shash(&alg); 234 234 } 235 235 236 236 - subsys_initcall(md4_mod_init); 236 236 + module_init(md4_mod_init); 237 237 module_exit(md4_mod_fini); 238 238 239 239 MODULE_LICENSE("GPL");

+1 -1

crypto/md5.c

reviewed

··· 216 216 crypto_unregister_shash(&alg); 217 217 } 218 218 219 219 - subsys_initcall(md5_mod_init); 219 219 + module_init(md5_mod_init); 220 220 module_exit(md5_mod_fini); 221 221 222 222 MODULE_LICENSE("GPL");

+1 -1

crypto/michael_mic.c

reviewed

··· 167 167 } 168 168 169 169 170 170 - subsys_initcall(michael_mic_init); 170 170 + module_init(michael_mic_init); 171 171 module_exit(michael_mic_exit); 172 172 173 173 MODULE_LICENSE("GPL v2");

+1 -1

crypto/nhpoly1305.c

reviewed

··· 245 245 crypto_unregister_shash(&nhpoly1305_alg); 246 246 } 247 247 248 248 - subsys_initcall(nhpoly1305_mod_init); 248 248 + module_init(nhpoly1305_mod_init); 249 249 module_exit(nhpoly1305_mod_exit); 250 250 251 251 MODULE_DESCRIPTION("NHPoly1305 ε-almost-∆-universal hash function");

+1 -1

crypto/pcbc.c

reviewed

··· 186 186 crypto_unregister_template(&crypto_pcbc_tmpl); 187 187 } 188 188 189 189 - subsys_initcall(crypto_pcbc_module_init); 189 189 + module_init(crypto_pcbc_module_init); 190 190 module_exit(crypto_pcbc_module_exit); 191 191 192 192 MODULE_LICENSE("GPL");

+1 -1

crypto/pcrypt.c

reviewed

··· 381 381 kset_unregister(pcrypt_kset); 382 382 } 383 383 384 384 - subsys_initcall(pcrypt_init); 384 384 + module_init(pcrypt_init); 385 385 module_exit(pcrypt_exit); 386 386 387 387 MODULE_LICENSE("GPL");

+1 -1

crypto/polyval-generic.c

reviewed

··· 196 196 crypto_unregister_shash(&polyval_alg); 197 197 } 198 198 199 199 - subsys_initcall(polyval_mod_init); 199 199 + module_init(polyval_mod_init); 200 200 module_exit(polyval_mod_exit); 201 201 202 202 MODULE_LICENSE("GPL");

+1 -1

crypto/rmd160.c

reviewed

··· 342 342 crypto_unregister_shash(&alg); 343 343 } 344 344 345 345 - subsys_initcall(rmd160_mod_init); 345 345 + module_init(rmd160_mod_init); 346 346 module_exit(rmd160_mod_fini); 347 347 348 348 MODULE_LICENSE("GPL");

+1 -1

crypto/rsa.c

reviewed

··· 430 430 crypto_unregister_akcipher(&rsa); 431 431 } 432 432 433 433 - subsys_initcall(rsa_init); 433 433 + module_init(rsa_init); 434 434 module_exit(rsa_exit); 435 435 MODULE_ALIAS_CRYPTO("rsa"); 436 436 MODULE_LICENSE("GPL");

+1 -1

crypto/seed.c

reviewed

··· 460 460 crypto_unregister_alg(&seed_alg); 461 461 } 462 462 463 463 - subsys_initcall(seed_init); 463 463 + module_init(seed_init); 464 464 module_exit(seed_fini); 465 465 466 466 MODULE_DESCRIPTION("SEED Cipher Algorithm");

+1 -1

crypto/seqiv.c

reviewed

··· 179 179 crypto_unregister_template(&seqiv_tmpl); 180 180 } 181 181 182 182 - subsys_initcall(seqiv_module_init); 182 182 + module_init(seqiv_module_init); 183 183 module_exit(seqiv_module_exit); 184 184 185 185 MODULE_LICENSE("GPL");

+1 -1

crypto/serpent_generic.c

reviewed

··· 599 599 crypto_unregister_alg(&srp_alg); 600 600 } 601 601 602 602 - subsys_initcall(serpent_mod_init); 602 602 + module_init(serpent_mod_init); 603 603 module_exit(serpent_mod_fini); 604 604 605 605 MODULE_LICENSE("GPL");

+1 -1

crypto/sha1_generic.c

reviewed

··· 77 77 crypto_unregister_shash(&alg); 78 78 } 79 79 80 80 - subsys_initcall(sha1_generic_mod_init); 80 80 + module_init(sha1_generic_mod_init); 81 81 module_exit(sha1_generic_mod_fini); 82 82 83 83 MODULE_LICENSE("GPL");

+1 -1

crypto/sha256.c

reviewed

··· 224 224 num_algs /= 2; 225 225 return crypto_register_shashes(algs, ARRAY_SIZE(algs)); 226 226 } 227 227 - subsys_initcall(crypto_sha256_mod_init); 227 227 + module_init(crypto_sha256_mod_init); 228 228 229 229 static void __exit crypto_sha256_mod_exit(void) 230 230 {

+1 -1

crypto/sha512_generic.c

reviewed

··· 205 205 crypto_unregister_shashes(sha512_algs, ARRAY_SIZE(sha512_algs)); 206 206 } 207 207 208 208 - subsys_initcall(sha512_generic_mod_init); 208 208 + module_init(sha512_generic_mod_init); 209 209 module_exit(sha512_generic_mod_fini); 210 210 211 211 MODULE_LICENSE("GPL");

+1 -1

crypto/sm3_generic.c

reviewed

··· 62 62 crypto_unregister_shash(&sm3_alg); 63 63 } 64 64 65 65 - subsys_initcall(sm3_generic_mod_init); 65 65 + module_init(sm3_generic_mod_init); 66 66 module_exit(sm3_generic_mod_fini); 67 67 68 68 MODULE_LICENSE("GPL v2");

+1 -1

crypto/sm4_generic.c

reviewed

··· 83 83 crypto_unregister_alg(&sm4_alg); 84 84 } 85 85 86 86 - subsys_initcall(sm4_init); 86 86 + module_init(sm4_init); 87 87 module_exit(sm4_fini); 88 88 89 89 MODULE_DESCRIPTION("SM4 Cipher Algorithm");

+1 -1

crypto/streebog_generic.c

reviewed

··· 1061 1061 crypto_unregister_shashes(algs, ARRAY_SIZE(algs)); 1062 1062 } 1063 1063 1064 1064 - subsys_initcall(streebog_mod_init); 1064 1064 + module_init(streebog_mod_init); 1065 1065 module_exit(streebog_mod_fini); 1066 1066 1067 1067 MODULE_LICENSE("GPL");

+1 -1

crypto/tea.c

reviewed

··· 255 255 MODULE_ALIAS_CRYPTO("xtea"); 256 256 MODULE_ALIAS_CRYPTO("xeta"); 257 257 258 258 - subsys_initcall(tea_mod_init); 258 258 + module_init(tea_mod_init); 259 259 module_exit(tea_mod_fini); 260 260 261 261 MODULE_LICENSE("GPL");

+1 -1

crypto/twofish_generic.c

reviewed

··· 187 187 crypto_unregister_alg(&alg); 188 188 } 189 189 190 190 - subsys_initcall(twofish_mod_init); 190 190 + module_init(twofish_mod_init); 191 191 module_exit(twofish_mod_fini); 192 192 193 193 MODULE_LICENSE("GPL");

+1 -1

crypto/wp512.c

reviewed

··· 1169 1169 MODULE_ALIAS_CRYPTO("wp384"); 1170 1170 MODULE_ALIAS_CRYPTO("wp256"); 1171 1171 1172 1172 - subsys_initcall(wp512_mod_init); 1172 1172 + module_init(wp512_mod_init); 1173 1173 module_exit(wp512_mod_fini); 1174 1174 1175 1175 MODULE_LICENSE("GPL");

+1 -1

crypto/xcbc.c

reviewed

··· 199 199 crypto_unregister_template(&crypto_xcbc_tmpl); 200 200 } 201 201 202 202 - subsys_initcall(crypto_xcbc_module_init); 202 202 + module_init(crypto_xcbc_module_init); 203 203 module_exit(crypto_xcbc_module_exit); 204 204 205 205 MODULE_LICENSE("GPL");

+1 -1

crypto/xctr.c

reviewed

··· 182 182 crypto_unregister_template(&crypto_xctr_tmpl); 183 183 } 184 184 185 185 - subsys_initcall(crypto_xctr_module_init); 185 185 + module_init(crypto_xctr_module_init); 186 186 module_exit(crypto_xctr_module_exit); 187 187 188 188 MODULE_LICENSE("GPL");

+1 -1

crypto/xts.c

reviewed

··· 466 466 crypto_unregister_template(&xts_tmpl); 467 467 } 468 468 469 469 - subsys_initcall(xts_module_init); 469 469 + module_init(xts_module_init); 470 470 module_exit(xts_module_exit); 471 471 472 472 MODULE_LICENSE("GPL");

+1 -1

crypto/xxhash_generic.c

reviewed

··· 96 96 crypto_unregister_shash(&alg); 97 97 } 98 98 99 99 - subsys_initcall(xxhash_mod_init); 99 99 + module_init(xxhash_mod_init); 100 100 module_exit(xxhash_mod_fini); 101 101 102 102 MODULE_AUTHOR("Nikolay Borisov <nborisov@suse.com>");

+1 -1

crypto/zstd.c

reviewed

··· 196 196 crypto_unregister_scomp(&scomp); 197 197 } 198 198 199 199 - subsys_initcall(zstd_mod_init); 199 199 + module_init(zstd_mod_init); 200 200 module_exit(zstd_mod_fini); 201 201 202 202 MODULE_LICENSE("GPL");