drivers/crypto/hisilicon/sec2/sec_crypto.c

1646

u32 iv_size = req->ctx->c_ctx.ivsize;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1663

sz = sg_pcopy_to_buffer(sgl, sg_nents(sgl), iv, iv_size,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1664

cryptlen - iv_size);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1665

if (unlikely(sz != iv_size))

drivers/crypto/hisilicon/sec2/sec_crypto.c

1668

sz = (cryptlen + iv_size - 1) / iv_size;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1669

ctr_iv_inc(iv, iv_size, sz);

drivers/crypto/hisilicon/sec2/sec_crypto.c

2372

sec_min_key_size, sec_max_key_size, blk_size, iv_size)\

drivers/crypto/hisilicon/sec2/sec_crypto.c

2391

.ivsize = iv_size,\

drivers/crypto/hisilicon/sec2/sec_crypto.c

2600

ctx_exit, blk_size, iv_size, max_authsize)\

drivers/crypto/hisilicon/sec2/sec_crypto.c

2618

.ivsize = iv_size,\

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

256

int iv_size = crypto_skcipher_ivsize(tfm);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

272

if (!req->iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

283

if (!req->iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

293

if (!req->iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

403

int iv_size = crypto_skcipher_ivsize(tfm);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

415

req->cryptlen - iv_size, iv_size, 0);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

520

int iv_size = crypto_skcipher_ivsize(tfm);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

551

req->cryptlen, req->iv, iv_size);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

571

req->cryptlen - iv_size,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

572

iv_size, 0);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

577

memcpy(req->iv, rctx->last_ct_blk, iv_size);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

580

req->cryptlen - iv_size,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

581

iv_size, 0);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

600

int iv_size = crypto_aead_ivsize(tfm);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

612

if (iv_size != GCM_AES_IV_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

619

if (iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

602

const u8 *iv, u32 iv_size,

drivers/crypto/intel/keembay/ocs-aes.c

665

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

681

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

697

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

704

if (!iv || iv_size != GCM_AES_IV_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

731

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

805

u32 iv_size)

drivers/crypto/intel/keembay/ocs-aes.c

810

rc = ocs_aes_validate_inputs(src_dma_list, src_size, iv, iv_size, 0, 0,

drivers/crypto/intel/keembay/ocs-aes.h

78

u32 iv_size);

drivers/crypto/sa2ul.c

108

u8 iv_size;

drivers/crypto/sa2ul.c

1458

cfg.iv_size = 0;

drivers/crypto/sa2ul.c

1804

cfg.iv_size = crypto_aead_ivsize(authenc);

drivers/crypto/sa2ul.c

585

if (cfg->iv_size)

drivers/crypto/sa2ul.c

586

auth_offset += cfg->iv_size;

drivers/crypto/sa2ul.c

601

if (cfg->iv_size) {

drivers/crypto/sa2ul.c

605

upd_info->enc_iv.size = cfg->iv_size;

drivers/crypto/sa2ul.c

608

SA_CMDL_HEADER_SIZE_BYTES + cfg->iv_size;

drivers/crypto/sa2ul.c

611

(SA_CTX_ENC_AUX2_OFFSET | (cfg->iv_size >> 3));

drivers/crypto/sa2ul.c

612

total += SA_CMDL_HEADER_SIZE_BYTES + cfg->iv_size;

drivers/crypto/sa2ul.c

903

cfg.iv_size = crypto_skcipher_ivsize(tfm);

drivers/gpu/drm/amd/amdgpu/amdgpu_ih.c

301

uint32_t iv_size = 32;

drivers/gpu/drm/amd/amdgpu/amdgpu_ih.c

305

rptr += iv_size * offset;

drivers/md/dm-crypt.c

1214

return iv_of_dmreq(cc, dmreq) + cc->iv_size;

drivers/md/dm-crypt.c

1220

u8 *ptr = iv_of_dmreq(cc, dmreq) + cc->iv_size + cc->iv_size;

drivers/md/dm-crypt.c

1228

u8 *ptr = iv_of_dmreq(cc, dmreq) + cc->iv_size +

drivers/md/dm-crypt.c

1229

cc->iv_size + sizeof(uint64_t);

drivers/md/dm-crypt.c

1262

BUG_ON(cc->integrity_iv_size && cc->integrity_iv_size != cc->iv_size);

drivers/md/dm-crypt.c

1291

sg_set_buf(&dmreq->sg_in[1], org_iv, cc->iv_size);

drivers/md/dm-crypt.c

1297

sg_set_buf(&dmreq->sg_out[1], org_iv, cc->iv_size);

drivers/md/dm-crypt.c

1304

memcpy(org_iv, tag_iv, cc->iv_size);

drivers/md/dm-crypt.c

1311

memcpy(tag_iv, org_iv, cc->iv_size);

drivers/md/dm-crypt.c

1314

memcpy(iv, org_iv, cc->iv_size);

drivers/md/dm-crypt.c

1317

aead_request_set_ad(req, sizeof(uint64_t) + cc->iv_size);

drivers/md/dm-crypt.c

1410

memcpy(iv, org_iv, cc->iv_size);

drivers/md/dm-crypt.c

184

unsigned int iv_size;

drivers/md/dm-crypt.c

2755

cc->iv_size = crypto_aead_ivsize(any_tfm_aead(cc));

drivers/md/dm-crypt.c

2757

cc->iv_size = crypto_skcipher_ivsize(any_tfm(cc));

drivers/md/dm-crypt.c

2759

if (cc->iv_size)

drivers/md/dm-crypt.c

2761

cc->iv_size = max(cc->iv_size,

drivers/md/dm-crypt.c

2807

cc->key_extra_size = cc->iv_size + TCW_WHITENING_SIZE;

drivers/md/dm-crypt.c

2811

cc->integrity_iv_size = cc->iv_size;

drivers/md/dm-crypt.c

2925

cc->iv_size = crypto_aead_ivsize(any_tfm_aead(cc));

drivers/md/dm-crypt.c

2927

cc->iv_size = crypto_skcipher_ivsize(any_tfm(cc));

drivers/md/dm-crypt.c

3259

iv_size_padding + cc->iv_size +

drivers/md/dm-crypt.c

3260

cc->iv_size +

drivers/md/dm-crypt.c

365

memset(iv, 0, cc->iv_size);

drivers/md/dm-crypt.c

374

memset(iv, 0, cc->iv_size);

drivers/md/dm-crypt.c

383

memset(iv, 0, cc->iv_size);

drivers/md/dm-crypt.c

385

*(__be64 *)&iv[cc->iv_size - sizeof(u64)] = cpu_to_be64(dmreq->iv_sector);

drivers/md/dm-crypt.c

397

memset(iv, 0, cc->iv_size);

drivers/md/dm-crypt.c

443

memset(iv, 0, cc->iv_size - sizeof(u64)); /* rest is cleared below */

drivers/md/dm-crypt.c

446

put_unaligned(val, (__be64 *)(iv + cc->iv_size - sizeof(u64)));

drivers/md/dm-crypt.c

454

memset(iv, 0, cc->iv_size);

drivers/md/dm-crypt.c

543

memcpy(iv, ctx.state.h, cc->iv_size);

drivers/md/dm-crypt.c

558

memset(iv, 0, cc->iv_size);

drivers/md/dm-crypt.c

576

crypto_xor(dst + sg->offset, iv, cc->iv_size);

drivers/md/dm-crypt.c

601

if (cc->key_size <= (cc->iv_size + TCW_WHITENING_SIZE)) {

drivers/md/dm-crypt.c

606

tcw->iv_seed = kzalloc(cc->iv_size, GFP_KERNEL);

drivers/md/dm-crypt.c

620

int key_offset = cc->key_size - cc->iv_size - TCW_WHITENING_SIZE;

drivers/md/dm-crypt.c

622

memcpy(tcw->iv_seed, &cc->key[key_offset], cc->iv_size);

drivers/md/dm-crypt.c

623

memcpy(tcw->whitening, &cc->key[key_offset + cc->iv_size],

drivers/md/dm-crypt.c

633

memset(tcw->iv_seed, 0, cc->iv_size);

drivers/md/dm-crypt.c

679

if (cc->iv_size > 8)

drivers/md/dm-crypt.c

681

cc->iv_size - 8);

drivers/md/dm-crypt.c

706

get_random_bytes(iv, cc->iv_size);

drivers/md/dm-crypt.c

718

if (crypto_skcipher_blocksize(any_tfm(cc)) != cc->iv_size) {

drivers/md/dm-crypt.c

740

req = kmalloc(reqsize + cc->iv_size, GFP_NOIO);

drivers/md/dm-crypt.c

747

memset(buf, 0, cc->iv_size);

drivers/md/dm-crypt.c

750

sg_init_one(&src, page_address(ZERO_PAGE(0)), cc->iv_size);

drivers/md/dm-crypt.c

751

sg_init_one(&dst, iv, cc->iv_size);

drivers/md/dm-crypt.c

752

skcipher_request_set_crypt(req, &src, &dst, cc->iv_size, buf);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1183

cipher_start = TLS_HEADER_SIZE + tx_info->iv_size + 1;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1362

(!tls_rec_offset ? TLS_HEADER_SIZE + tx_info->iv_size : 0);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1419

memcpy(pos + tx_info->salt_size, &iv_record, tx_info->iv_size);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1420

*(__be32 *)(pos + tx_info->salt_size + tx_info->iv_size) =

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1422

(TLS_HEADER_SIZE + tx_info->iv_size)) / AES_BLOCK_LEN) : 0));

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1803

if (tls_rec_offset + data_len <= (TLS_HEADER_SIZE + tx_info->iv_size)) {

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1821

if (tls_rec_offset < (TLS_HEADER_SIZE + tx_info->iv_size)) {

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1828

(TLS_HEADER_SIZE + tx_info->iv_size))

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

90

tx_info->iv_size = TLS_CIPHER_AES_GCM_128_IV_SIZE;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.h

50

u32 iv_size;

drivers/s390/cio/airq.c

138

size = iv_size(bits);

drivers/s390/cio/airq.c

210

cio_dma_free(iv->vector, iv_size(iv->bits));

fs/smb/client/smb2ops.c

4499

unsigned int iv_size = crypto_aead_ivsize(tfm);

fs/smb/client/smb2ops.c

4509

len = iv_size;

fs/smb/client/smb2ops.c

4521

*req = (struct aead_request *)PTR_ALIGN(*iv + iv_size,

include/net/tls.h

220

u16 iv_size;

net/tipc/crypto.c

681

unsigned int iv_size, req_size;

net/tipc/crypto.c

685

iv_size = crypto_aead_ivsize(tfm);

net/tipc/crypto.c

689

len += iv_size;

net/tipc/crypto.c

702

*req = (struct aead_request *)PTR_ALIGN(*iv + iv_size,

net/tls/tls.h

320

prot->iv_size);

net/tls/tls.h

340

size_t pkt_len, iv_size = prot->iv_size;

net/tls/tls.h

345

pkt_len += iv_size;

net/tls/tls.h

348

ctx->tx.iv + prot->salt_size, iv_size);

net/tls/tls_sw.c

1334

prot->iv_size + prot->salt_size);

net/tls/tls_sw.c

1338

prot->iv_size);

net/tls/tls_sw.c

2194

cipher_overhead += prot->iv_size;

net/tls/tls_sw.c

2488

prot->iv_size = cipher_desc->iv;

net/tls/tls_sw.c

559

prot->iv_size + prot->salt_size);