arch/powerpc/kernel/nvram_64.c

502

size_t length, hdr_size;

arch/powerpc/kernel/nvram_64.c

507

hdr_size = sizeof(u16);

arch/powerpc/kernel/nvram_64.c

512

hdr_size = sizeof(*oops_hdr);

arch/powerpc/kernel/nvram_64.c

517

record->buf = kmemdup(buff + hdr_size, length, GFP_KERNEL);

arch/powerpc/platforms/powernv/opal-core.c

302

u32 hdr_size, cpu_notes_size, count;

arch/powerpc/platforms/powernv/opal-core.c

313

hdr_size = (sizeof(Elf64_Ehdr) +

arch/powerpc/platforms/powernv/opal-core.c

322

oc_conf->opalcorebuf_sz = PAGE_ALIGN(hdr_size + cpu_notes_size);

arch/powerpc/platforms/powernv/opal-core.c

386

phdr->p_offset = cpu_to_be64(hdr_size);

drivers/bluetooth/btusb.c

3400

size_t hdr_size)

drivers/bluetooth/btusb.c

3414

size = min_t(size_t, count, hdr_size);

drivers/crypto/intel/qat/qat_common/qat_uclo.c

688

int hdr_size;

drivers/crypto/intel/qat/qat_common/qat_uclo.c

692

hdr_size = (char *)&str_table->strings - (char *)str_table;

drivers/crypto/intel/qat/qat_common/qat_uclo.c

694

chunk_hdr->offset + hdr_size;

drivers/cxl/core/edac.c

843

size_t hdr_size;

drivers/cxl/core/edac.c

852

hdr_size = sizeof(pi->hdr);

drivers/cxl/core/edac.c

857

if (hdr_size + data_in_size > cxl_mbox->payload_size)

drivers/cxl/core/edac.c

863

.size_in = hdr_size + data_in_size,

drivers/cxl/core/features.c

106

hdr_size = struct_size(mbox_out, ents, 0);

drivers/cxl/core/features.c

107

max_size = cxl_mbox->payload_size - hdr_size;

drivers/cxl/core/features.c

138

.min_out = hdr_size,

drivers/cxl/core/features.c

144

if (mbox_cmd.size_out <= hdr_size)

drivers/cxl/core/features.c

151

retrieved = mbox_cmd.size_out - hdr_size;

drivers/cxl/core/features.c

285

size_t hdr_size;

drivers/cxl/core/features.c

299

hdr_size = sizeof(pi->hdr);

drivers/cxl/core/features.c

304

if (hdr_size + FEAT_DATA_MIN_PAYLOAD_SIZE > cxl_mbox->payload_size)

drivers/cxl/core/features.c

307

if (hdr_size + feat_data_size <= cxl_mbox->payload_size) {

drivers/cxl/core/features.c

314

data_in_size = cxl_mbox->payload_size - hdr_size;

drivers/cxl/core/features.c

324

.size_in = hdr_size + data_in_size,

drivers/cxl/core/features.c

341

if ((feat_data_size - data_sent_size) <= (cxl_mbox->payload_size - hdr_size)) {

drivers/cxl/core/features.c

83

int remain_feats, max_size, max_feats, start, rc, hdr_size;

drivers/firmware/efi/ovmf-debug-log.c

18

u64 hdr_size;

drivers/firmware/efi/ovmf-debug-log.c

85

size = hdr->hdr_size + hdr->log_size;

drivers/firmware/efi/ovmf-debug-log.c

96

logbuf = (void *)hdr + hdr->hdr_size;

drivers/gpu/drm/mediatek/mtk_plane.c

150

int hdr_size, hdr_offset;

drivers/gpu/drm/mediatek/mtk_plane.c

156

hdr_size = ALIGN(hdr_pitch * height_in_blocks, AFBC_HEADER_ALIGNMENT);

drivers/gpu/drm/mediatek/mtk_plane.c

177

addr = addr + hdr_size + offset;

drivers/gpu/drm/nouveau/include/nvfw/hs.h

15

u32 hdr_size;

drivers/gpu/drm/nouveau/nvkm/nvfw/hs.c

37

nvkm_debug(subdev, "\thdrSize : 0x%x\n", hdr->hdr_size);

drivers/infiniband/core/mad_rmpp.c

430

int hdr_size, data_size, pad;

drivers/infiniband/core/mad_rmpp.c

436

hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);

drivers/infiniband/core/mad_rmpp.c

438

data_size = sizeof(struct opa_rmpp_mad) - hdr_size;

drivers/infiniband/core/mad_rmpp.c

443

data_size = sizeof(struct ib_rmpp_mad) - hdr_size;

drivers/infiniband/core/mad_rmpp.c

449

return hdr_size + rmpp_recv->seg_num * data_size - pad;

drivers/infiniband/core/user_mad.c

258

packet->mad.hdr.length = hdr_size(file) + mad_recv_wc->mad_len;

drivers/infiniband/core/user_mad.c

316

count < hdr_size(file) + packet->length) ||

drivers/infiniband/core/user_mad.c

318

count < hdr_size(file) + seg_size))

drivers/infiniband/core/user_mad.c

321

if (copy_to_user(buf, &packet->mad, hdr_size(file)))

drivers/infiniband/core/user_mad.c

324

buf += hdr_size(file);

drivers/infiniband/core/user_mad.c

334

if (count < hdr_size(file) + packet->length) {

drivers/infiniband/core/user_mad.c

357

return hdr_size(file) + packet->length;

drivers/infiniband/core/user_mad.c

363

ssize_t size = hdr_size(file) + packet->length;

drivers/infiniband/core/user_mad.c

368

if (copy_to_user(buf, &packet->mad, hdr_size(file)))

drivers/infiniband/core/user_mad.c

371

buf += hdr_size(file);

drivers/infiniband/core/user_mad.c

389

if (count < hdr_size(file))

drivers/infiniband/core/user_mad.c

521

if (count < hdr_size(file) + IB_MGMT_RMPP_HDR)

drivers/infiniband/core/user_mad.c

528

if (copy_from_user(&packet->mad, buf, hdr_size(file))) {

drivers/infiniband/core/user_mad.c

538

buf += hdr_size(file);

drivers/infiniband/core/user_mad.c

592

if (check_sub_overflow(count, hdr_size(file) + hdr_len, &data_len)) {

drivers/infiniband/hw/erdma/erdma_cm.c

379

int hdr_size, int *rcvd_out)

drivers/infiniband/hw/erdma/erdma_cm.c

385

if (hdr_rcvd < hdr_size) {

drivers/infiniband/hw/erdma/erdma_cm.c

386

rcvd = ksock_recv(s, hdr + hdr_rcvd, hdr_size - hdr_rcvd,

drivers/infiniband/hw/erdma/erdma_cm.c

397

if (hdr_rcvd < hdr_size)

drivers/infiniband/hw/hfi1/hfi.h

2587

static inline int hfi1_get_16b_padding(u32 hdr_size, u32 payload)

drivers/infiniband/hw/hfi1/hfi.h

2589

return -(hdr_size + payload + (SIZE_OF_CRC << 2) +

drivers/infiniband/sw/rxe/rxe_icrc.c

43

int hdr_size = sizeof(struct udphdr) +

drivers/infiniband/sw/rxe/rxe_icrc.c

59

memcpy(pshdr, ip_hdr(skb), hdr_size);

drivers/infiniband/sw/rxe/rxe_icrc.c

67

memcpy(pshdr, ipv6_hdr(skb), hdr_size);

drivers/infiniband/sw/rxe/rxe_icrc.c

77

bth_offset += hdr_size;

drivers/infiniband/sw/rxe/rxe_icrc.c

85

length = hdr_size + RXE_BTH_BYTES;

drivers/media/pci/cx18/cx18-vbi.c

104

buf += hdr_size;

drivers/media/pci/cx18/cx18-vbi.c

116

memcpy(q, p + 4, line_size - 4 - hdr_size);

drivers/media/pci/cx18/cx18-vbi.c

117

q += line_size - 4 - hdr_size;

drivers/media/pci/cx18/cx18-vbi.c

118

p += line_size - hdr_size - 1;

drivers/media/pci/cx18/cx18-vbi.c

119

memset(q, (int) *p, hdr_size);

drivers/media/pci/cx18/cx18-vbi.c

129

const u32 hdr_size)

drivers/media/pci/cx18/cx18-vbi.c

138

for (i = hdr_size, buf += hdr_size; i < size; i++, buf++) {

drivers/media/pci/cx18/cx18-vbi.c

150

size -= (i - hdr_size);

drivers/media/pci/cx18/cx18-vbi.c

95

static u32 compress_raw_buf(struct cx18 *cx, u8 *buf, u32 size, u32 hdr_size)

drivers/net/amt.c

2254

int hdr_size;

drivers/net/amt.c

2256

hdr_size = sizeof(*amta) + sizeof(struct udphdr);

drivers/net/amt.c

2257

if (!pskb_may_pull(skb, hdr_size))

drivers/net/amt.c

2286

int hdr_size, len, err;

drivers/net/amt.c

2293

hdr_size = sizeof(*amtmd) + sizeof(struct udphdr);

drivers/net/amt.c

2294

if (!pskb_may_pull(skb, hdr_size))

drivers/net/amt.c

2301

if (iptunnel_pull_header(skb, hdr_size, htons(ETH_P_IP), false))

drivers/net/amt.c

2357

int hdr_size, len;

drivers/net/amt.c

2359

hdr_size = sizeof(*amtmq) + sizeof(struct udphdr);

drivers/net/amt.c

2360

if (!pskb_may_pull(skb, hdr_size))

drivers/net/amt.c

2370

hdr_size -= sizeof(*eth);

drivers/net/amt.c

2371

if (iptunnel_pull_header(skb, hdr_size, htons(ETH_P_TEB), false))

drivers/net/amt.c

2457

int len, hdr_size;

drivers/net/amt.c

2461

hdr_size = sizeof(*amtmu) + sizeof(struct udphdr);

drivers/net/amt.c

2462

if (!pskb_may_pull(skb, hdr_size))

drivers/net/amt.c

2469

if (iptunnel_pull_header(skb, hdr_size, skb->protocol, false))

drivers/net/arcnet/arc-rawmode.c

105

return hdr_size;

drivers/net/arcnet/arc-rawmode.c

110

return hdr_size; /* success */

drivers/net/arcnet/arc-rawmode.c

87

int hdr_size = ARC_HDR_SIZE;

drivers/net/arcnet/arc-rawmode.c

88

struct archdr *pkt = skb_push(skb, hdr_size);

drivers/net/arcnet/capmode.c

103

int hdr_size = ARC_HDR_SIZE;

drivers/net/arcnet/capmode.c

104

struct archdr *pkt = skb_push(skb, hdr_size);

drivers/net/arcnet/capmode.c

124

return hdr_size;

drivers/net/arcnet/capmode.c

129

return hdr_size; /* success */

drivers/net/arcnet/rfc1051.c

165

int hdr_size = ARC_HDR_SIZE + RFC1051_HDR_SIZE;

drivers/net/arcnet/rfc1051.c

166

struct archdr *pkt = skb_push(skb, hdr_size);

drivers/net/arcnet/rfc1051.c

200

return hdr_size;

drivers/net/arcnet/rfc1051.c

205

return hdr_size; /* success */

drivers/net/arcnet/rfc1051.c

92

int hdr_size = ARC_HDR_SIZE + RFC1051_HDR_SIZE;

drivers/net/arcnet/rfc1051.c

96

skb_pull(skb, hdr_size);

drivers/net/arcnet/rfc1201.c

100

skb_pull(skb, hdr_size);

drivers/net/arcnet/rfc1201.c

382

int hdr_size = ARC_HDR_SIZE + RFC1201_HDR_SIZE;

drivers/net/arcnet/rfc1201.c

383

struct archdr *pkt = skb_push(skb, hdr_size);

drivers/net/arcnet/rfc1201.c

436

return hdr_size;

drivers/net/arcnet/rfc1201.c

440

return hdr_size;

drivers/net/arcnet/rfc1201.c

96

int hdr_size = ARC_HDR_SIZE + RFC1201_HDR_SIZE;

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.h

68

unsigned short hdr_size = (ipv6 ?

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.h

74

unsigned short data_size = mtu - hdr_size;

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.h

76

cxgb4_best_aligned_mtu(mtus, hdr_size, data_size, 8, idx);

drivers/net/ethernet/emulex/benet/be_cmds.c

2669

u32 img_offset, u32 img_size, int hdr_size,

drivers/net/ethernet/emulex/benet/be_cmds.c

2681

crc_offset = hdr_size + img_offset + img_size - 4;

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c

741

if (info->hdr_size > ((2 * 1024) - 64)) {

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c

745

rx_ctx.hbuff = info->hdr_size >> I40E_RXQ_CTX_HBUFF_SHIFT;

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

3701

u32 hdr_size = sizeof(struct ixgbe_hic_hdr);

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

3725

dword_len = hdr_size >> 2;

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

3738

if (length < round_up(buf_len, 4) + hdr_size) {

drivers/net/ethernet/qlogic/qed/qed_iwarp.c

2368

u32 hdr_size;

drivers/net/ethernet/qlogic/qed/qed_iwarp.c

2443

hdr_size = ((cm_info.ip_version == QED_TCP_IPV4) ? 40 : 60);

drivers/net/ethernet/qlogic/qed/qed_iwarp.c

2444

ep->mss = p_hwfn->p_rdma_info->iwarp.max_mtu - hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c

3960

u32 mbx_cmd, fw_hal_version, hdr_size, total_size, tmp;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c

3971

hdr_size = sizeof(struct qlcnic_bc_hdr) / sizeof(u32);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c

3972

total_size = cmd->pay_size + hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c

3985

for (i = 2, j = 0; j < hdr_size; i++, j++)

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c

1716

addr = QLC_83XX_RESET_TEMPLATE_ADDR + ahw->reset.hdr->hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c

1717

p_buff = ahw->reset.buff + ahw->reset.hdr->hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c

1718

count = (ahw->reset.hdr->size - ahw->reset.hdr->hdr_size) / sizeof(u32);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c

1732

ahw->reset.stop_offset = ahw->reset.buff + ahw->reset.hdr->hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c

52

u16 hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_init.c

62

u16 hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c

910

u8 i, max = 2, hdr_size, j;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c

912

hdr_size = (sizeof(struct qlcnic_bc_hdr) / sizeof(u32));

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c

913

max = (size / sizeof(u32)) + hdr_size;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c

915

for (i = 2, j = 0; j < hdr_size; i++, j++)

drivers/net/ethernet/wangxun/libwx/wx_hw.c

292

u32 hdr_size = sizeof(struct wx_hic_hdr);

drivers/net/ethernet/wangxun/libwx/wx_hw.c

344

dword_len = hdr_size >> 2;

drivers/net/ethernet/wangxun/libwx/wx_hw.c

357

if (length < buf_len + hdr_size) {

drivers/net/ethernet/wangxun/libwx/wx_hw.c

402

u32 hdr_size = sizeof(struct wx_hic_hdr);

drivers/net/ethernet/wangxun/libwx/wx_hw.c

457

if (length < buf_len + hdr_size) {

drivers/net/ethernet/wangxun/libwx/wx_hw.c

465

for (i = hdr_size >> 2; i <= dword_len; i++) {

drivers/net/thunderbolt/main.c

812

unsigned int hdr_size = sizeof(*hdr);

drivers/net/thunderbolt/main.c

867

skb_reserve(skb, hdr_size);

drivers/net/thunderbolt/main.c

873

page, hdr_size, frame_size,

drivers/net/thunderbolt/main.c

874

TBNET_RX_PAGE_SIZE - hdr_size);

drivers/net/wireless/ath/ath6kl/wmi.c

306

u32 meta_size, hdr_size;

drivers/net/wireless/ath/ath6kl/wmi.c

325

hdr_size = sizeof(struct ethhdr);

drivers/net/wireless/ath/ath6kl/wmi.c

330

meta_size + hdr_size);

drivers/net/wireless/ath/ath6kl/wmi.c

393

u32 hdr_size;

drivers/net/wireless/ath/ath6kl/wmi.c

409

hdr_size = roundup(sizeof(struct ieee80211_qos_hdr),

drivers/net/wireless/ath/ath6kl/wmi.c

411

skb_pull(skb, hdr_size);

drivers/net/wireless/ath/wil6210/wmi.c

1479

size_t hdr_size = sizeof(struct wmi_link_stats_record);

drivers/net/wireless/ath/wil6210/wmi.c

1483

if (payload_size < hdr_size) {

drivers/net/wireless/ath/wil6210/wmi.c

1488

while (payload_size >= hdr_size) {

drivers/net/wireless/ath/wil6210/wmi.c

1491

record_size = hdr_size + stats_size;

drivers/net/wireless/ath/wil6210/wmi.c

1513

wil_link_stats_store_basic(vif, payload + hdr_size);

drivers/net/wireless/ath/wil6210/wmi.c

1535

wil_link_stats_store_global(vif, payload + hdr_size);

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4703

u32 api_ver, hdr_size;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4714

hdr_size = 24;

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4715

if (ucode_raw->size < hdr_size) {

drivers/net/wireless/intel/iwlegacy/4965-mac.c

4730

hdr_size + pieces->inst_size + pieces->data_size +

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

793

u32 hdr_size = 1 + !!rev_data[idx].min_profiles;

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

796

u32 max_size = hdr_size + profile_size * rev_data[idx].profiles;

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

802

min_size = hdr_size +

drivers/net/wireless/intel/iwlwifi/fw/acpi.c

834

hdr_size + profile_size * num_profiles) {

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

597

u32 api_ver, hdr_size, build;

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

606

hdr_size = 28;

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

607

if (ucode_raw->size < hdr_size) {

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

625

hdr_size = 24;

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

626

if (ucode_raw->size < hdr_size) {

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

659

if (ucode_raw->size != hdr_size +

drivers/nfc/s3fwrn5/i2c.c

101

skb = alloc_skb(hdr_size + data_len, GFP_KERNEL);

drivers/nfc/s3fwrn5/i2c.c

105

skb_put_data(skb, hdr, hdr_size);

drivers/nfc/s3fwrn5/i2c.c

83

size_t hdr_size;

drivers/nfc/s3fwrn5/i2c.c

88

hdr_size = (phy->common.mode == S3FWRN5_MODE_NCI) ?

drivers/nfc/s3fwrn5/i2c.c

90

ret = i2c_master_recv(phy->i2c_dev, hdr, hdr_size);

drivers/nfc/s3fwrn5/i2c.c

94

if (ret < hdr_size)

drivers/s390/crypto/zcrypt_ep11misc.c

1207

size_t hdr_size, pl_size;

drivers/s390/crypto/zcrypt_ep11misc.c

1212

&hdr, &hdr_size, &pl, &pl_size);

drivers/s390/crypto/zcrypt_ep11misc.c

1222

*keybufsize = hdr_size + pl_size;

drivers/s390/crypto/zcrypt_ep11misc.c

889

size_t hdr_size, pl_size;

drivers/s390/crypto/zcrypt_ep11misc.c

902

&hdr, &hdr_size, &pl, &pl_size);

drivers/s390/crypto/zcrypt_ep11misc.c

911

*keybufsize = hdr_size + pl_size;

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

723

u32 hdr_size = sizeof(*req);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

730

hdr_size += sizeof(struct cpl_tx_data_iso);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

739

req = (struct fw_ofld_tx_data_wr *)__skb_push(skb, hdr_size);

drivers/scsi/elx/efct/efct_hw.c

1234

u32 hdr_size = EFCT_HW_RQ_SIZE_HDR;

drivers/scsi/elx/efct/efct_hw.c

1245

hdr_size);

drivers/scsi/elx/efct/efct_hw.c

1254

i, rq->hdr->id, rq->entry_count, hdr_size);

drivers/scsi/lpfc/lpfc_sli4.h

547

uint32_t hdr_size;

drivers/scsi/qla2xxx/qla_nx2.c

1549

tmplt_hdr_size = vha->reset_tmplt.hdr->hdr_size/sizeof(uint32_t);

drivers/scsi/qla2xxx/qla_nx2.c

1559

addr = QLA8044_RESET_TEMPLATE_ADDR + vha->reset_tmplt.hdr->hdr_size;

drivers/scsi/qla2xxx/qla_nx2.c

1560

p_buff = vha->reset_tmplt.buff + vha->reset_tmplt.hdr->hdr_size;

drivers/scsi/qla2xxx/qla_nx2.c

1562

vha->reset_tmplt.hdr->hdr_size)/sizeof(uint32_t);

drivers/scsi/qla2xxx/qla_nx2.c

1594

vha->reset_tmplt.hdr->hdr_size;

drivers/scsi/qla2xxx/qla_nx2.h

223

uint16_t hdr_size;

drivers/scsi/qla4xxx/ql4_83xx.c

810

tmplt_hdr_size = ha->reset_tmplt.hdr->hdr_size/sizeof(uint32_t);

drivers/scsi/qla4xxx/ql4_83xx.c

818

addr = QLA83XX_RESET_TEMPLATE_ADDR + ha->reset_tmplt.hdr->hdr_size;

drivers/scsi/qla4xxx/ql4_83xx.c

819

p_buff = ha->reset_tmplt.buff + ha->reset_tmplt.hdr->hdr_size;

drivers/scsi/qla4xxx/ql4_83xx.c

821

ha->reset_tmplt.hdr->hdr_size) / sizeof(uint32_t);

drivers/scsi/qla4xxx/ql4_83xx.c

852

ha->reset_tmplt.hdr->hdr_size;

drivers/scsi/qla4xxx/ql4_83xx.h

166

__le16 hdr_size;

drivers/scsi/scsi_transport_iscsi.c

3863

if ((ev->u.send_pdu.hdr_size > pdu_len) ||

drivers/scsi/scsi_transport_iscsi.c

3864

(ev->u.send_pdu.data_size > (pdu_len - ev->u.send_pdu.hdr_size))) {

drivers/scsi/scsi_transport_iscsi.c

3871

(char *)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,

drivers/soc/qcom/apr.c

192

uint16_t hdr_size, msg_type, ver, svc_id;

drivers/soc/qcom/apr.c

207

hdr_size = APR_HDR_FIELD_SIZE_BYTES(hdr->hdr_field);

drivers/soc/qcom/apr.c

208

if (hdr_size < APR_HDR_SIZE) {

drivers/soc/qcom/apr.c

209

dev_err(apr->dev, "APR: Wrong hdr size:%d\n", hdr_size);

drivers/soc/qcom/apr.c

248

resp.payload_size = hdr->pkt_size - hdr_size;

drivers/soc/qcom/apr.c

255

resp.payload = buf + hdr_size;

drivers/soc/qcom/apr.c

264

uint16_t hdr_size, ver;

drivers/soc/qcom/apr.c

277

hdr_size = hdr->hdr_size;

drivers/soc/qcom/apr.c

278

if (hdr_size < GPR_PKT_HEADER_WORD_SIZE) {

drivers/soc/qcom/apr.c

279

dev_err(gpr->dev, "GPR: Wrong hdr size:%d\n", hdr_size);

drivers/soc/qcom/apr.c

289

resp.payload_size = hdr->pkt_size - (hdr_size * 4);

drivers/soc/qcom/apr.c

296

resp.payload = buf + (hdr_size * 4);

drivers/target/iscsi/cxgbit/cxgbit_target.c

166

u32 hdr_size = sizeof(*req);

drivers/target/iscsi/cxgbit/cxgbit_target.c

175

hdr_size += sizeof(struct cpl_tx_data_iso);

drivers/target/iscsi/cxgbit/cxgbit_target.c

182

req = __skb_push(skb, hdr_size);

drivers/thermal/intel/intel_hfi.c

144

unsigned int hdr_size;

drivers/thermal/intel/intel_hfi.c

351

hfi_instance->data = hfi_instance->hdr + hfi_features.hdr_size;

drivers/thermal/intel/intel_hfi.c

569

hfi_features.hdr_size = DIV_ROUND_UP(nr_capabilities, 8) * 8;

drivers/thunderbolt/nvm.c

102

hdr_size = (*(u32 *)buf) & 0xffffff;

drivers/thunderbolt/nvm.c

103

if (hdr_size + INTEL_NVM_DEVID + 2 >= image_size)

drivers/thunderbolt/nvm.c

107

if (!IS_ALIGNED(hdr_size, SZ_4K))

drivers/thunderbolt/nvm.c

114

ds_size = *(u16 *)(buf + hdr_size);

drivers/thunderbolt/nvm.c

125

device_id = *(u16 *)(buf + hdr_size + INTEL_NVM_DEVID);

drivers/thunderbolt/nvm.c

130

nvm->buf_data_start = buf + hdr_size;

drivers/thunderbolt/nvm.c

131

nvm->buf_data_size = image_size - hdr_size;

drivers/thunderbolt/nvm.c

226

unsigned int image_size, hdr_size;

drivers/thunderbolt/nvm.c

236

hdr_size = (*(u32 *)buf) & 0xffffff;

drivers/thunderbolt/nvm.c

237

if (hdr_size + INTEL_NVM_DEVID + 2 >= image_size)

drivers/thunderbolt/nvm.c

241

if (!IS_ALIGNED(hdr_size, SZ_4K))

drivers/thunderbolt/nvm.c

248

ds_size = *(u16 *)(buf + hdr_size);

drivers/thunderbolt/nvm.c

256

device = *(u16 *)(buf + hdr_size + INTEL_NVM_DEVID);

drivers/thunderbolt/nvm.c

261

nvm->buf_data_start = buf + hdr_size;

drivers/thunderbolt/nvm.c

262

nvm->buf_data_size = image_size - hdr_size;

drivers/thunderbolt/nvm.c

59

u32 val, nvm_size, hdr_size;

drivers/thunderbolt/nvm.c

74

hdr_size = sw->generation < 3 ? SZ_8K : SZ_16K;

drivers/thunderbolt/nvm.c

76

nvm_size = (nvm_size - hdr_size) / 2;

drivers/thunderbolt/nvm.c

92

unsigned int image_size, hdr_size;

drivers/vhost/net.c

629

size_t hdr_size, int out)

drivers/vhost/net.c

635

iov_iter_advance(iter, hdr_size);

fs/smb/client/smb2misc.c

143

int hdr_size = sizeof(struct smb2_hdr);

fs/smb/client/smb2misc.c

194

if ((len >= hdr_size)

fs/xfs/libxfs/xfs_attr_remote.c

308

unsigned int hdr_size = 0;

fs/xfs/libxfs/xfs_attr_remote.c

322

hdr_size = sizeof(struct xfs_attr3_rmt_hdr);

fs/xfs/libxfs/xfs_attr_remote.c

325

memcpy(*dst, src + hdr_size, byte_cnt);

fs/xfs/libxfs/xfs_attr_remote.c

357

unsigned int hdr_size;

fs/xfs/libxfs/xfs_attr_remote.c

361

hdr_size = xfs_attr3_rmt_hdr_set(mp, dst, ino, *offset,

fs/xfs/libxfs/xfs_attr_remote.c

364

memcpy(dst + hdr_size, *src, byte_cnt);

fs/xfs/libxfs/xfs_attr_remote.c

370

if (byte_cnt + hdr_size < blksize) {

fs/xfs/libxfs/xfs_attr_remote.c

373

memset(dst + hdr_size + byte_cnt, 0,

fs/xfs/libxfs/xfs_attr_remote.c

374

blksize - hdr_size - byte_cnt);

include/linux/avf/virtchnl.h

387

u16 hdr_size;

include/linux/soc/qcom/apr.h

81

uint32_t hdr_size:4;

include/scsi/iscsi_if.h

131

uint32_t hdr_size;

include/uapi/linux/io_uring/query.h

67

__u64 hdr_size;

include/uapi/linux/pfrut.h

88

__u32 hdr_size;

io_uring/query.c

51

e->hdr_size = sizeof(struct io_rings);

net/batman-adv/bridge_loop_avoidance.c

1772

struct batadv_orig_node *orig_node, int hdr_size)

net/batman-adv/bridge_loop_avoidance.c

1781

if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))

net/batman-adv/bridge_loop_avoidance.c

1784

vid = batadv_get_vid(skb, hdr_size);

net/batman-adv/bridge_loop_avoidance.h

42

int hdr_size);

net/batman-adv/bridge_loop_avoidance.h

77

int hdr_size)

net/batman-adv/distributed-arp-table.c

1001

ethhdr = (struct ethhdr *)(skb->data + hdr_size);

net/batman-adv/distributed-arp-table.c

1007

if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +

net/batman-adv/distributed-arp-table.c

1011

arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);

net/batman-adv/distributed-arp-table.c

1029

ip_src = batadv_arp_ip_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1030

ip_dst = batadv_arp_ip_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1037

hw_src = batadv_arp_hw_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1043

hw_dst = batadv_arp_hw_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1063

static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)

net/batman-adv/distributed-arp-table.c

1067

vid = batadv_get_vid(skb, *hdr_size);

net/batman-adv/distributed-arp-table.c

1075

*hdr_size += VLAN_HLEN;

net/batman-adv/distributed-arp-table.c

1135

int hdr_size = 0;

net/batman-adv/distributed-arp-table.c

1141

vid = batadv_dat_get_vid(skb, &hdr_size);

net/batman-adv/distributed-arp-table.c

1143

type = batadv_arp_get_type(bat_priv, skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1150

batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REQUEST");

net/batman-adv/distributed-arp-table.c

1152

ip_src = batadv_arp_ip_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1153

hw_src = batadv_arp_hw_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1154

ip_dst = batadv_arp_ip_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1197

skb->len + ETH_HLEN + hdr_size);

net/batman-adv/distributed-arp-table.c

1222

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

1236

vid = batadv_dat_get_vid(skb, &hdr_size);

net/batman-adv/distributed-arp-table.c

1238

type = batadv_arp_get_type(bat_priv, skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1242

hw_src = batadv_arp_hw_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1243

ip_src = batadv_arp_ip_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1244

ip_dst = batadv_arp_ip_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1246

batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST");

net/batman-adv/distributed-arp-table.c

1263

if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))

net/batman-adv/distributed-arp-table.c

1292

int hdr_size = 0;

net/batman-adv/distributed-arp-table.c

1298

vid = batadv_dat_get_vid(skb, &hdr_size);

net/batman-adv/distributed-arp-table.c

1300

type = batadv_arp_get_type(bat_priv, skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1304

batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REPLY");

net/batman-adv/distributed-arp-table.c

1306

hw_src = batadv_arp_hw_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1307

ip_src = batadv_arp_ip_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1308

hw_dst = batadv_arp_hw_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1309

ip_dst = batadv_arp_ip_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1334

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

1346

vid = batadv_dat_get_vid(skb, &hdr_size);

net/batman-adv/distributed-arp-table.c

1348

type = batadv_arp_get_type(bat_priv, skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1352

batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REPLY");

net/batman-adv/distributed-arp-table.c

1354

hw_src = batadv_arp_hw_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1355

ip_src = batadv_arp_ip_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1356

hw_dst = batadv_arp_hw_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1357

ip_dst = batadv_arp_ip_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1734

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

1746

if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))

net/batman-adv/distributed-arp-table.c

1749

ethhdr = (struct ethhdr *)(skb->data + hdr_size);

net/batman-adv/distributed-arp-table.c

1750

skb_set_network_header(skb, hdr_size + ETH_HLEN);

net/batman-adv/distributed-arp-table.c

1757

vid = batadv_dat_get_vid(skb, &hdr_size);

net/batman-adv/distributed-arp-table.c

1785

int hdr_size = sizeof(struct batadv_bcast_packet);

net/batman-adv/distributed-arp-table.c

1797

vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);

net/batman-adv/distributed-arp-table.c

1799

type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);

net/batman-adv/distributed-arp-table.c

1803

ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);

net/batman-adv/distributed-arp-table.c

230

static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

234

addr = (u8 *)(skb->data + hdr_size);

net/batman-adv/distributed-arp-table.c

247

static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

249

return *(__force __be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);

net/batman-adv/distributed-arp-table.c

259

static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

261

return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4;

net/batman-adv/distributed-arp-table.c

271

static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

273

u8 *dst = batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4;

net/batman-adv/distributed-arp-table.c

423

int hdr_size, char *msg)

net/batman-adv/distributed-arp-table.c

433

ip_src = batadv_arp_ip_src(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

434

ip_dst = batadv_arp_ip_dst(skb, hdr_size);

net/batman-adv/distributed-arp-table.c

437

batadv_arp_hw_src(skb, hdr_size), &ip_src,

net/batman-adv/distributed-arp-table.c

438

batadv_arp_hw_dst(skb, hdr_size), &ip_dst);

net/batman-adv/distributed-arp-table.c

440

if (hdr_size < sizeof(struct batadv_unicast_packet))

net/batman-adv/distributed-arp-table.c

490

int hdr_size, char *msg)

net/batman-adv/distributed-arp-table.c

989

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.c

998

if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))

net/batman-adv/distributed-arp-table.h

115

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.h

129

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.h

143

struct sk_buff *skb, int hdr_size)

net/batman-adv/distributed-arp-table.h

30

struct sk_buff *skb, int hdr_size);

net/batman-adv/distributed-arp-table.h

34

struct sk_buff *skb, int hdr_size);

net/batman-adv/distributed-arp-table.h

40

struct sk_buff *skb, int hdr_size);

net/batman-adv/fragmentation.c

145

u16 seqno, hdr_size = sizeof(struct batadv_frag_packet);

net/batman-adv/fragmentation.c

174

chain->size = skb->len - hdr_size;

net/batman-adv/fragmentation.c

191

chain->size += skb->len - hdr_size;

net/batman-adv/fragmentation.c

204

chain->size += skb->len - hdr_size;

net/batman-adv/fragmentation.c

252

int size, hdr_size = sizeof(struct batadv_frag_packet);

net/batman-adv/fragmentation.c

264

size = ntohs(packet->total_size) + hdr_size;

net/batman-adv/fragmentation.c

277

skb_pull(skb_out, hdr_size);

net/batman-adv/fragmentation.c

286

size = entry->skb->len - hdr_size;

net/batman-adv/fragmentation.c

287

skb_put_data(skb_out, entry->skb->data + hdr_size, size);

net/batman-adv/mesh-interface.c

403

struct sk_buff *skb, int hdr_size,

net/batman-adv/mesh-interface.c

416

skb_pull_rcsum(skb, hdr_size);

net/batman-adv/mesh-interface.h

19

struct sk_buff *skb, int hdr_size,

net/batman-adv/multicast_forw.c

1090

int hdr_size = VLAN_ETH_HLEN + IPV6_MIN_MTU - skb->len;

net/batman-adv/multicast_forw.c

1096

if (hdr_size < 0) {

net/batman-adv/multicast_forw.c

1104

if (skb_headroom(skb) < hdr_size &&

net/batman-adv/multicast_forw.c

1105

pskb_expand_head(skb, hdr_size, 0, GFP_ATOMIC) < 0)

net/batman-adv/routing.c

1005

hdr_size))

net/batman-adv/routing.c

1008

hdr_size))

net/batman-adv/routing.c

1011

batadv_dat_snoop_incoming_dhcp_ack(bat_priv, skb, hdr_size);

net/batman-adv/routing.c

1013

batadv_interface_rx(recv_if->mesh_iface, skb, hdr_size,

net/batman-adv/routing.c

1047

int hdr_size = sizeof(*unicast_tvlv_packet);

net/batman-adv/routing.c

1050

if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)

net/batman-adv/routing.c

1054

if (skb_cow(skb, hdr_size) < 0)

net/batman-adv/routing.c

1063

tvlv_buff = (unsigned char *)(skb->data + hdr_size);

net/batman-adv/routing.c

1066

if (tvlv_buff_len > skb->len - hdr_size)

net/batman-adv/routing.c

1165

int hdr_size = sizeof(*bcast_packet);

net/batman-adv/routing.c

1171

if (unlikely(!pskb_may_pull(skb, hdr_size)))

net/batman-adv/routing.c

1240

if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))

net/batman-adv/routing.c

1243

if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))

net/batman-adv/routing.c

1245

if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))

net/batman-adv/routing.c

1248

batadv_dat_snoop_incoming_dhcp_ack(bat_priv, skb, hdr_size);

net/batman-adv/routing.c

1251

batadv_interface_rx(recv_if->mesh_iface, skb, hdr_size, orig_node);

net/batman-adv/routing.c

1284

int hdr_size = sizeof(*mcast_packet);

net/batman-adv/routing.c

1289

if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)

net/batman-adv/routing.c

1304

tvlv_buff = (unsigned char *)(skb->data + hdr_size);

net/batman-adv/routing.c

1307

if (tvlv_buff_len > skb->len - hdr_size)

net/batman-adv/routing.c

1318

hdr_size += tvlv_buff_len;

net/batman-adv/routing.c

1320

if (ret == NET_RX_SUCCESS && (skb->len - hdr_size >= ETH_HLEN)) {

net/batman-adv/routing.c

1323

skb->len - hdr_size);

net/batman-adv/routing.c

1325

batadv_interface_rx(bat_priv->mesh_iface, skb, hdr_size, NULL);

net/batman-adv/routing.c

345

int hdr_size = sizeof(struct batadv_icmp_header);

net/batman-adv/routing.c

349

if (unlikely(!pskb_may_pull(skb, hdr_size)))

net/batman-adv/routing.c

441

struct sk_buff *skb, int hdr_size)

net/batman-adv/routing.c

446

if (unlikely(!pskb_may_pull(skb, hdr_size)))

net/batman-adv/routing.c

912

int check, hdr_size = sizeof(*unicast_packet);

net/batman-adv/routing.c

914

check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);

net/batman-adv/routing.c

945

int check, hdr_size = sizeof(*unicast_packet);

net/batman-adv/routing.c

954

hdr_size = sizeof(*unicast_4addr_packet);

net/batman-adv/routing.c

957

check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);

net/batman-adv/routing.c

961

if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))

net/batman-adv/routing.c

975

hdr_size);

net/batman-adv/send.c

221

batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size,

net/batman-adv/send.c

227

if (batadv_skb_head_push(skb, hdr_size) < 0)

net/batman-adv/translation-table.c

516

int hdr_size;

net/batman-adv/translation-table.c

526

hdr_size = sizeof(struct batadv_unicast_tvlv_packet);

net/batman-adv/translation-table.c

527

hdr_size += sizeof(struct batadv_tvlv_hdr);

net/batman-adv/translation-table.c

528

hdr_size += sizeof(struct batadv_tvlv_tt_data);

net/batman-adv/translation-table.c

529

hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);

net/batman-adv/translation-table.c

531

return hdr_size + batadv_tt_len(tt_local_entries);

net/bluetooth/l2cap_core.c

5674

int hdr_size;

net/bluetooth/l2cap_core.c

5677

hdr_size = L2CAP_EXT_HDR_SIZE;

net/bluetooth/l2cap_core.c

5679

hdr_size = L2CAP_ENH_HDR_SIZE;

net/bluetooth/l2cap_core.c

5684

our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size);

net/mpls/af_mpls.c

2422

unsigned int hdr_size = 0;

net/mpls/af_mpls.c

2487

hdr_size = n_labels * sizeof(struct mpls_shim_hdr);

net/mpls/af_mpls.c

2498

if (hdr_size) {

net/mpls/af_mpls.c

2502

if (skb_cow(skb, hdr_size)) {

net/mpls/af_mpls.c

2507

skb_reserve(skb, hdr_size);

net/mpls/af_mpls.c

2508

skb_push(skb, hdr_size);

net/mpls/af_mpls.c

2527

if (hdr_size) {

net/mpls/af_mpls.c

2528

skb_pull(skb, hdr_size);

net/netfilter/nf_flow_table_ip.c

154

u32 hdr_size;

net/netfilter/nf_flow_table_ip.c

339

ctx->tun.hdr_size = size;

net/netfilter/nf_flow_table_ip.c

369

ctx->tun.hdr_size = hdrlen;

net/netfilter/nf_flow_table_ip.c

372

ctx->offset += ctx->tun.hdr_size;

net/netfilter/nf_flow_table_ip.c

387

skb_pull(skb, ctx->tun.hdr_size);

net/nfc/nci/core.c

1498

unsigned int hdr_size = NCI_CTRL_HDR_SIZE;

net/nfc/nci/core.c

1500

if (skb->len < hdr_size ||

net/nfc/nci/core.c

1501

skb->len < hdr_size + nci_plen(skb->data)) {

samples/bpf/tcp_tos_reflect_kern.c

29

int hdr_size = 0;

samples/bpf/tcp_tos_reflect_kern.c

47

hdr_size = sizeof(struct iphdr);

samples/bpf/tcp_tos_reflect_kern.c

49

hdr_size = sizeof(struct ipv6hdr);

samples/bpf/tcp_tos_reflect_kern.c

51

header, hdr_size);

scripts/dtc/flattree.c

20

int hdr_size;

scripts/dtc/flattree.c

330

reserve_off = ALIGN(vi->hdr_size, 8);

scripts/dtc/flattree.c

405

blob = data_append_data(blob, &fdt, vi->hdr_size);

sound/soc/codecs/rt1320-sdw.c

1589

unsigned int hdr_size = 0;

sound/soc/codecs/rt1320-sdw.c

1673

hdr_size = 64;

sound/soc/codecs/rt1320-sdw.c

1675

hdr_size = 0;

sound/soc/codecs/rt1320-sdw.c

1678

sec[i].len = ptr_img->size - hdr_size;

sound/soc/codecs/rt1320-sdw.c

1679

sec[i].buf = fw_data + hdr_size;

sound/soc/codecs/rt1320-sdw.c

1682

__func__, hdr_size, i, sec[i].buf[0]);

sound/soc/qcom/qdsp6/audioreach.c

246

pkt->hdr.hdr_size = GPR_PKT_HEADER_WORD_SIZE;

tools/perf/util/arm-spe.c

1644

unsigned int i, cpu, hdr_size, cpu_num, cpu_size;

tools/perf/util/arm-spe.c

1652

hdr_size = ARM_SPE_AUXTRACE_V1_PRIV_MAX;

tools/perf/util/arm-spe.c

1656

hdr_size = arr[ARM_SPE_HEADER_SIZE];

tools/perf/util/arm-spe.c

1660

for (i = 0; i < hdr_size; i++)

tools/perf/util/arm-spe.c

1663

arr += hdr_size;

tools/testing/selftests/bpf/progs/bpf_flow.c

102

if (thoff > (USHRT_MAX - hdr_size))

tools/testing/selftests/bpf/progs/bpf_flow.c

106

if (hdr + hdr_size <= data_end)

tools/testing/selftests/bpf/progs/bpf_flow.c

109

if (bpf_skb_load_bytes(skb, thoff, buffer, hdr_size))

tools/testing/selftests/bpf/progs/bpf_flow.c

93

__u16 hdr_size,

tools/testing/selftests/bpf/progs/dynptr_fail.c

1547

__u32 hdr_size = sizeof(struct ethhdr);

tools/testing/selftests/bpf/progs/dynptr_fail.c

1560

hdr = bpf_dynptr_slice(&ptr, 0, buffer, hdr_size);

tools/testing/selftests/bpf/progs/dynptr_fail.c

1578

if (hdr_size <= sizeof(buffer)) {

tools/testing/selftests/bpf/progs/dynptr_fail.c

1580

hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, hdr_size);