tag_size
(atag->hdr.size != tag_size(tag_core) &&
tag->hdr.size = tag_size(tag_core);
tag->hdr.size = tag_size(tag_ramdisk);
tag->hdr.size = tag_size(tag_initrd);
tag->hdr.size = tag_size(tag_serialnr);
tag->hdr.size = tag_size(tag_revision);
tag->hdr.size = tag_size(tag_memclk);
tag->hdr.size = tag_size(tag_videotext);
tag->hdr.size = tag_size(tag_acorn);
tag->hdr.size = tag_size(tag_mem32);
{ tag_size(tag_core), ATAG_CORE },
{ tag_size(tag_mem32), ATAG_MEM },
return sysfs_emit(page, "%u\n", bi->tag_size);
static DEVICE_ATTR_RO(tag_size);
ti->tag_size = bi->tag_size;
bi->tag_size || ((bi->flags & BLK_INTEGRITY_REF_TAG))) {
if (q->crypto_profile && lim->integrity.tag_size) {
if (ti->tag_size != bi->tag_size)
.tag_size = p->tag_size,
int tag_size = crypto_aead_authsize(tfm);
if (instruction == OCS_DECRYPT && req->cryptlen < tag_size)
const int tag_size = crypto_aead_authsize(crypto_aead_reqtfm(req));
in_size = req->cryptlen - tag_size;
tag_size, req->assoclen + in_size);
out_size = (rctx->mode == OCS_MODE_CCM) ? in_size + tag_size :
dst_size = req->assoclen + in_size + tag_size;
const int tag_size = crypto_aead_authsize(crypto_aead_reqtfm(req));
rctx->in_tag, tag_size);
rctx->out_tag, tag_size);
rc = memcmp(rctx->in_tag, rctx->out_tag, tag_size) ?
tag_size, req->assoclen + req->cryptlen);
ocs_aes_gcm_read_tag(aes_dev, out_tag, tag_size);
const u8 *in_tag, u32 tag_size)
for (i = 0; i < tag_size; i++) {
const u8 *iv, u32 adata_size, u32 tag_size,
b0[0] |= (((tag_size - 2) / 2) & 0x7) << 3;
u32 tag_size)
in_tag, tag_size, cipher, OCS_MODE_CCM,
iowrite32(tag_size, aes_dev->base_reg + AES_TLEN_OFFSET);
rc = ocs_aes_ccm_write_b0(aes_dev, iv, adata_size, tag_size, src_size);
ocs_aes_ccm_write_encrypted_tag(aes_dev, in_tag, tag_size);
return ccm_compare_tag_to_yr(aes_dev, tag_size);
const u8 *tag, u32 tag_size,
if (tag_size > (AES_MAX_TAG_SIZE_U32 * sizeof(u32)))
if (tag_size > (AES_MAX_TAG_SIZE_U32 * sizeof(u32)))
u8 *tag, u32 tag_size)
memcpy(tag, tag_u32, tag_size);
u32 tag_size)
aad_size, out_tag, tag_size, cipher,
iowrite32(tag_size, aes_dev->base_reg + AES_TLEN_OFFSET);
u32 tag_size);
u32 tag_size);
memcpy(&buf[2], data, tag_size);
memcpy(data, &buf[2], tag_size);
void *data, size_t tag_size)
size_t size = tag_size + 12;
u32 tag_size, tag_margin, tag_align;
tag_size = (ltc->num_tags / 64) * 0x6000 + tag_margin;
tag_size += tag_align;
ret = nvkm_ram_get(device, NVKM_RAM_MM_NORMAL, 0x01, 12, tag_size,
int i, tag_num, tag_size, ret;
tag_size = 1; /* ib_srpt does not use se_sess->sess_cmd_map */
tag_size, TARGET_PROT_NORMAL,
tag_size, TARGET_PROT_NORMAL, i_port_id,
tag_size, TARGET_PROT_NORMAL,
if (likely(is_power_of_2(ic->tag_size))) {
if (unlikely(hash_offset == ic->tag_size)) {
if (unlikely(digest_size < ic->tag_size))
memset(result + digest_size, 0, ic->tag_size - digest_size);
get_random_bytes(result, ic->tag_size);
unsigned int tag_size;
if (unlikely(digest_size < ic->tag_size))
memset(result + digest_size, 0, ic->tag_size - digest_size);
get_random_bytes(result, ic->tag_size);
&dio->metadata_offset, ic->tag_size, TAG_CMP);
unsigned int extra_space = unlikely(digest_size > ic->tag_size) ? digest_size - ic->tag_size : 0;
checksums = kmalloc((PAGE_SIZE >> SECTOR_SHIFT >> ic->sb->log2_sectors_per_block) * ic->tag_size + extra_space,
unsigned int max_blocks = max_size / ic->tag_size;
this_step_blocks * ic->tag_size, TAG_WRITE);
checksums_ptr += ic->tag_size;
data_to_process *= ic->tag_size;
wanted_tag_size *= ic->tag_size;
unsigned int tag_todo = ic->tag_size;
if (unlikely(digest_size > ic->tag_size)) {
memcpy(journal_entry_tag(ic, je), checksums_onstack, ic->tag_size);
extra_size = unlikely(digest_size > ic->tag_size) ? digest_size - ic->tag_size : 0;
if (ic->tag_size < ic->tuple_size)
memset(dio->integrity_payload + pos + ic->tag_size, 0, ic->tuple_size - ic->tag_size);
if (unlikely(crypto_memneq(digest, dio->integrity_payload, min(ic->internal_hash_digestsize, ic->tag_size)))) {
min(ic->internal_hash_digestsize, ic->tag_size)))) {
if (unlikely(crypto_memneq(test_tag, journal_entry_tag(ic, je2), ic->tag_size))) {
ic->tag_size, TAG_WRITE);
recalc_tags_size = (recalc_sectors >> ic->sb->log2_sectors_per_block) * ic->tag_size;
if (ic->internal_hash_digestsize > ic->tag_size)
recalc_tags_size += ic->internal_hash_digestsize - ic->tag_size;
t += ic->tag_size;
ic->tag_size, ic->mode, arg_count);
ic->dev->name, ic->start, ic->tag_size, ic->mode);
bi->metadata_size = ic->tag_size;
bi->tag_size = bi->metadata_size;
ic->journal_entry_size = roundup(offsetof(struct journal_entry, last_bytes[ic->sectors_per_block]) + ic->tag_size,
ic->metadata_run = round_up((__u64)ic->tag_size << (ic->sb->log2_interleave_sectors - ic->sb->log2_sectors_per_block),
__u64 meta_size = (ic->provided_data_sectors >> ic->sb->log2_sectors_per_block) * ic->tag_size;
ic->sb->integrity_tag_size = cpu_to_le16(ic->tag_size);
ms += (__u64)offset * ic->tag_size >> (SECTOR_SHIFT + ic->log2_buffer_sectors);
mo = (offset * ic->tag_size) & ((1U << SECTOR_SHIFT << ic->log2_buffer_sectors) - 1);
if (sscanf(argv[2], "%u%c", &ic->tag_size, &dummy) != 1 || !ic->tag_size) {
if (!ic->tag_size) {
ic->tag_size = ic->internal_hash_digestsize;
if (ic->tag_size > MAX_TAG_SIZE) {
if (!(ic->tag_size & (ic->tag_size - 1)))
ic->log2_tag_size = __ffs(ic->tag_size);
if (bi->metadata_size < ic->tag_size) {
if (le16_to_cpu(ic->sb->integrity_tag_size) != ic->tag_size) {
const unsigned int tag_size = crypto_aead_authsize(ks->encrypt);
__skb_push(skb, tag_size);
sg_set_buf(sg + ret + 1, skb->data, tag_size);
const unsigned int tag_size = crypto_aead_authsize(ks->decrypt);
payload_offset = OVPN_AAD_SIZE + tag_size;
sg_set_buf(sg + ret + 1, skb->data + OVPN_AAD_SIZE, tag_size);
aead_request_set_crypt(req, sg, sg, payload_len + tag_size, iv);
lim.integrity.tag_size = btt_meta_size(btt);
bi->tag_size = sizeof(u16) + sizeof(u32);
bi->tag_size = sizeof(u16) + 6;
bi->tag_size = sizeof(u16);
bi->tag_size = sizeof(u16);
bi->tag_size = sizeof(u16) + sizeof(u32);
bi->tag_size = sizeof(u16);
blk_integrity_profile_name(bi), bi->tag_size);
int sessiontype = 0, ret = 0, tag_num, tag_size;
tag_size = sizeof(struct iscsit_cmd) + conn->conn_transport->priv_size;
ret = transport_alloc_session_tags(sess->se_sess, tag_num, tag_size);
unsigned int tag_num, unsigned int tag_size)
se_sess->sess_cmd_map = kvcalloc(tag_size, tag_num,
transport_init_session_tags(unsigned int tag_num, unsigned int tag_size,
if (tag_num != 0 && !tag_size) {
if (!tag_num && tag_size) {
" %u, but zero tag_num\n", tag_size);
rc = transport_alloc_session_tags(se_sess, tag_num, tag_size);
unsigned int tag_num, unsigned int tag_size,
sess = transport_init_session_tags(tag_num, tag_size, prot_op);
unsigned char tag_size;
size_t tag_size;
u16 tag_size;
void *data, size_t tag_size);
void *data, size_t tag_size)
__u8 tag_size;
.tag_size = sizeof(struct alloc_tag),
cttype->desc.tag_size;
BUG_ON(desc->tag_size <= 0);
((char *)iter->ct + iter->cttype->desc.tag_size);
pkt_len = plaintext_len + prot->tag_size;
size += prot->tag_size;
if (unlikely(pfrag->size - pfrag->offset < prot->tag_size) &&
!skb_page_frag_refill(prot->tag_size, pfrag, sk->sk_allocation)) {
tls_append_frag(record, pfrag, prot->tag_size);
cipher_overhead = prot->tag_size;
prot->tag_size = cipher_desc->tag;
prot->overhead_size = prot->prepend_size + prot->tag_size + prot->tail_size;
rc = crypto_aead_setauthsize(*aead, prot->tag_size);
data_len + prot->tag_size,
ctx.tag_size = strtoul(optarg, NULL, 0);
ctx.tag_size) {
.tag_size = ctx->tag_size,
__u8 tag_size;