arch/arm/kernel/traps.c

570

unsigned long chunk = min(PAGE_SIZE, end - start);

arch/arm/kernel/traps.c

576

ret = flush_icache_user_range(start, start + chunk);

arch/arm/kernel/traps.c

582

start += chunk;

arch/arm64/kernel/sys_compat.c

29

unsigned long chunk = min(PAGE_SIZE, end - start);

arch/arm64/kernel/sys_compat.c

43

ret = caches_clean_inval_user_pou(start, start + chunk);

arch/arm64/kernel/sys_compat.c

48

start += chunk;

arch/mips/dec/prom/console.c

19

unsigned int chunk = sizeof(buf) - 1;

arch/mips/dec/prom/console.c

24

if (chunk > c)

arch/mips/dec/prom/console.c

25

chunk = c;

arch/mips/dec/prom/console.c

26

memcpy(buf, s, chunk);

arch/mips/dec/prom/console.c

27

buf[chunk] = '\0';

arch/mips/dec/prom/console.c

29

s += chunk;

arch/mips/dec/prom/console.c

30

c -= chunk;

arch/powerpc/kernel/prom_init.c

2491

unsigned long room, chunk;

arch/powerpc/kernel/prom_init.c

2501

chunk = alloc_up(room, 0);

arch/powerpc/kernel/prom_init.c

2502

if (chunk == 0)

arch/powerpc/kernel/prom_init.c

2505

*mem_end = chunk + room;

arch/powerpc/mm/book3s64/iommu_api.c

100

chunk = (1UL << (PAGE_SHIFT + MAX_PAGE_ORDER)) /

arch/powerpc/mm/book3s64/iommu_api.c

102

chunk = min(chunk, entries);

arch/powerpc/mm/book3s64/iommu_api.c

103

for (entry = 0; entry < entries; entry += chunk) {

arch/powerpc/mm/book3s64/iommu_api.c

104

unsigned long n = min(entries - entry, chunk);

arch/powerpc/mm/book3s64/iommu_api.c

63

unsigned long entry, chunk;

arch/powerpc/platforms/powernv/memtrace.c

85

unsigned long chunk)

arch/powerpc/platforms/powernv/memtrace.c

89

for (i = start; i < stop; i += chunk) {

arch/powerpc/platforms/powernv/memtrace.c

90

flush_dcache_range(i, min(stop, i + chunk));

arch/powerpc/platforms/pseries/vio.c

393

size_t avail = 0, level, chunk, need;

arch/powerpc/platforms/pseries/vio.c

441

chunk = min_t(size_t, avail, VIO_CMO_BALANCE_CHUNK);

arch/powerpc/platforms/pseries/vio.c

442

chunk = min(chunk, (viodev->cmo.desired -

arch/powerpc/platforms/pseries/vio.c

444

viodev->cmo.entitled += chunk;

arch/s390/crypto/prng.c

514

int chunk, n, ret = 0;

arch/s390/crypto/prng.c

542

chunk = min_t(int, nbytes, prng_chunk_size);

arch/s390/crypto/prng.c

545

n = (chunk + 7) & -8;

arch/s390/crypto/prng.c

572

if (copy_to_user(ubuf, prng_data->buf, chunk)) {

arch/s390/crypto/prng.c

577

nbytes -= chunk;

arch/s390/crypto/prng.c

578

ret += chunk;

arch/s390/crypto/prng.c

579

ubuf += chunk;

arch/s390/mm/maccess.c

103

copied = copy_to_iter(chunk, len, iter);

arch/s390/mm/maccess.c

87

void *chunk;

arch/s390/mm/maccess.c

94

chunk = (void *)(__memcpy_real_area + offset);

arch/um/drivers/mconsole_kern.h

27

#define CONFIG_CHUNK(str, size, current, chunk, end) \

arch/um/drivers/mconsole_kern.h

29

current += strlen(chunk); \

arch/um/drivers/mconsole_kern.h

33

strcpy(str, chunk); \

arch/um/drivers/mconsole_kern.h

34

str += strlen(chunk); \

arch/x86/kernel/cpu/microcode/intel.c

420

static void write_mbox_data(void __iomem *mmio_base, u32 *chunk, unsigned int chunk_bytes)

arch/x86/kernel/cpu/microcode/intel.c

430

write_mbox_dword(mmio_base, chunk[i]);

arch/x86/kernel/cpu/sgx/main.c

305

struct sgx_epc_page *chunk[SGX_NR_TO_SCAN];

arch/x86/kernel/cpu/sgx/main.c

325

chunk[cnt++] = epc_page;

arch/x86/kernel/cpu/sgx/main.c

335

epc_page = chunk[i];

arch/x86/kernel/cpu/sgx/main.c

361

chunk[i] = NULL;

arch/x86/kernel/cpu/sgx/main.c

365

epc_page = chunk[i];

arch/x86/kernel/cpu/sgx/main.c

371

epc_page = chunk[i];

arch/x86/xen/p2m.c

323

unsigned int i, chunk;

arch/x86/xen/p2m.c

346

for (pfn = 0; pfn < xen_max_p2m_pfn; pfn += chunk) {

arch/x86/xen/p2m.c

357

chunk = (pfn & (P2M_PER_PAGE * P2M_MID_PER_PAGE - 1)) ?

arch/x86/xen/p2m.c

363

for (i = 1; i < chunk; i++)

arch/x86/xen/p2m.c

366

if (i < chunk)

arch/x86/xen/p2m.c

368

chunk = P2M_PER_PAGE;

arch/x86/xen/p2m.c

370

if (type == P2M_TYPE_PFN || i < chunk) {

arch/x86/xen/p2m.c

380

if (chunk == P2M_PER_PAGE) {

arch/x86/xen/setup.c

297

unsigned int i, chunk;

arch/x86/xen/setup.c

306

chunk = (left < REMAP_SIZE) ? left : REMAP_SIZE;

arch/x86/xen/setup.c

315

xen_remap_buf.size = chunk;

arch/x86/xen/setup.c

316

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

arch/x86/xen/setup.c

323

set_phys_range_identity(ident_pfn_iter, ident_pfn_iter + chunk);

arch/x86/xen/setup.c

325

left -= chunk;

crypto/lskcipher.c

100

if (chunk > cs)

crypto/lskcipher.c

101

chunk &= ~(cs - 1);

crypto/lskcipher.c

103

memcpy(p, src, chunk);

crypto/lskcipher.c

104

err = crypt(tfm, p, p, chunk, tiv, CRYPTO_LSKCIPHER_FLAG_FINAL);

crypto/lskcipher.c

108

memcpy(dst, p, chunk);

crypto/lskcipher.c

109

src += chunk;

crypto/lskcipher.c

110

dst += chunk;

crypto/lskcipher.c

111

len -= chunk;

crypto/lskcipher.c

97

unsigned chunk = min((unsigned)PAGE_SIZE, len);

drivers/accel/habanalabs/common/command_submission.c

1204

struct hl_cs_chunk *chunk,

drivers/accel/habanalabs/common/command_submission.c

1214

if (chunk->queue_index >= asic->max_queues) {

drivers/accel/habanalabs/common/command_submission.c

1216

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1220

hw_queue_prop = &asic->hw_queues_props[chunk->queue_index];

drivers/accel/habanalabs/common/command_submission.c

1224

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1230

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1237

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1245

if (chunk->cs_chunk_flags & HL_CS_CHUNK_FLAGS_USER_ALLOC_CB) {

drivers/accel/habanalabs/common/command_submission.c

1249

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1259

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1276

struct hl_cs_chunk *chunk)

drivers/accel/habanalabs/common/command_submission.c

1280

cb = hl_cb_get(mmg, chunk->cb_handle);

drivers/accel/habanalabs/common/command_submission.c

1282

dev_err(hdev->dev, "CB handle 0x%llx invalid\n", chunk->cb_handle);

drivers/accel/habanalabs/common/command_submission.c

1286

if ((chunk->cb_size < 8) || (chunk->cb_size > cb->size)) {

drivers/accel/habanalabs/common/command_submission.c

1287

dev_err(hdev->dev, "CB size %u invalid\n", chunk->cb_size);

drivers/accel/habanalabs/common/command_submission.c

1542

struct hl_cs_chunk *chunk = &cs_chunk_array[i];

drivers/accel/habanalabs/common/command_submission.c

1546

rc = validate_queue_index(hdev, chunk, &queue_type,

drivers/accel/habanalabs/common/command_submission.c

1555

cb = get_cb_from_cs_chunk(hdev, &hpriv->mem_mgr, chunk);

drivers/accel/habanalabs/common/command_submission.c

1564

cb = (struct hl_cb *) (uintptr_t) chunk->cb_handle;

drivers/accel/habanalabs/common/command_submission.c

1578

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

1600

job->user_cb_size = chunk->cb_size;

drivers/accel/habanalabs/common/command_submission.c

1601

job->hw_queue_id = chunk->queue_index;

drivers/accel/habanalabs/common/command_submission.c

1879

struct hl_cs_chunk *chunk, u64 *signal_seq, struct hl_ctx *ctx,

drivers/accel/habanalabs/common/command_submission.c

1887

*signal_seq = chunk->encaps_signal_seq;

drivers/accel/habanalabs/common/command_submission.c

1891

signal_seq_arr_len = chunk->num_signal_seq_arr;

drivers/accel/habanalabs/common/command_submission.c

1917

u64_to_user_ptr(chunk->signal_seq_arr),

drivers/accel/habanalabs/common/command_submission.c

2205

struct hl_cs_chunk *cs_chunk_array, *chunk;

drivers/accel/habanalabs/common/command_submission.c

2228

chunk = &cs_chunk_array[0];

drivers/accel/habanalabs/common/command_submission.c

2230

if (chunk->queue_index >= hdev->asic_prop.max_queues) {

drivers/accel/habanalabs/common/command_submission.c

2234

chunk->queue_index);

drivers/accel/habanalabs/common/command_submission.c

2239

q_idx = chunk->queue_index;

drivers/accel/habanalabs/common/command_submission.c

2272

collective_engine_id = chunk->collective_engine_id;

drivers/accel/habanalabs/common/command_submission.c

2281

rc = cs_ioctl_extract_signal_seq(hdev, chunk, &signal_seq,

drivers/accel/habanalabs/common/command_submission.c

2321

if (chunk->encaps_signal_offset >

drivers/accel/habanalabs/common/command_submission.c

2324

chunk->encaps_signal_offset,

drivers/accel/habanalabs/common/command_submission.c

2405

q_idx, chunk->encaps_signal_offset);

drivers/accel/habanalabs/common/command_submission.c

2409

chunk->encaps_signal_offset);

drivers/accel/habanalabs/common/mmu/mmu.c

753

struct gen_pool_chunk *chunk,

drivers/accel/habanalabs/common/mmu/mmu.c

758

hl_asic_dma_free_coherent(hdev, (chunk->end_addr - chunk->start_addr) + 1,

drivers/accel/habanalabs/common/mmu/mmu.c

759

(void *)chunk->start_addr, chunk->phys_addr);

drivers/char/hw_random/arm_smccc_trng.c

39

unsigned int chunk, copied;

drivers/char/hw_random/arm_smccc_trng.c

44

chunk = min(bytes, sizeof(long));

drivers/char/hw_random/arm_smccc_trng.c

45

memcpy(buf, &res->a3, chunk);

drivers/char/hw_random/arm_smccc_trng.c

46

copied = chunk;

drivers/char/hw_random/arm_smccc_trng.c

50

chunk = min((bytes - copied), sizeof(long));

drivers/char/hw_random/arm_smccc_trng.c

51

memcpy(&buf[copied], &res->a2, chunk);

drivers/char/hw_random/arm_smccc_trng.c

52

copied += chunk;

drivers/char/hw_random/arm_smccc_trng.c

56

chunk = min((bytes - copied), sizeof(long));

drivers/char/hw_random/arm_smccc_trng.c

57

memcpy(&buf[copied], &res->a1, chunk);

drivers/char/hw_random/arm_smccc_trng.c

59

return copied + chunk;

drivers/char/hw_random/virtio-rng.c

104

unsigned int chunk;

drivers/char/hw_random/virtio-rng.c

114

chunk = copy_data(vi, buf, size);

drivers/char/hw_random/virtio-rng.c

115

size -= chunk;

drivers/char/hw_random/virtio-rng.c

116

read += chunk;

drivers/char/hw_random/virtio-rng.c

136

chunk = copy_data(vi, buf + read, size);

drivers/char/hw_random/virtio-rng.c

137

size -= chunk;

drivers/char/hw_random/virtio-rng.c

138

read += chunk;

drivers/char/mem.c

455

size_t chunk = iov_iter_count(iter), n;

drivers/char/mem.c

457

if (chunk > PAGE_SIZE)

drivers/char/mem.c

458

chunk = PAGE_SIZE; /* Just for latency reasons */

drivers/char/mem.c

459

n = iov_iter_zero(chunk, iter);

drivers/char/mem.c

480

size_t chunk = min_t(size_t, count, PAGE_SIZE);

drivers/char/mem.c

483

left = clear_user(buf + cleared, chunk);

drivers/char/mem.c

485

cleared += (chunk - left);

drivers/char/mem.c

490

cleared += chunk;

drivers/char/mem.c

491

count -= chunk;

drivers/crypto/axis/artpec6_crypto.c

824

size_t chunk;

drivers/crypto/axis/artpec6_crypto.c

829

chunk = min(count, artpec6_crypto_walk_chunklen(walk));

drivers/crypto/axis/artpec6_crypto.c

838

chunk = min_t(dma_addr_t, chunk,

drivers/crypto/axis/artpec6_crypto.c

842

pr_debug("CHUNK-b %pad:%zu\n", &addr, chunk);

drivers/crypto/axis/artpec6_crypto.c

843

ret = setup_bounce_buffer_in(common, walk, chunk);

drivers/crypto/axis/artpec6_crypto.c

844

} else if (chunk < ARTPEC_CACHE_LINE_MAX) {

drivers/crypto/axis/artpec6_crypto.c

845

pr_debug("CHUNK-b %pad:%zu\n", &addr, chunk);

drivers/crypto/axis/artpec6_crypto.c

846

ret = setup_bounce_buffer_in(common, walk, chunk);

drivers/crypto/axis/artpec6_crypto.c

850

chunk = chunk & ~(ARTPEC_CACHE_LINE_MAX-1);

drivers/crypto/axis/artpec6_crypto.c

852

pr_debug("CHUNK %pad:%zu\n", &addr, chunk);

drivers/crypto/axis/artpec6_crypto.c

858

chunk,

drivers/crypto/axis/artpec6_crypto.c

866

chunk, false);

drivers/crypto/axis/artpec6_crypto.c

872

count = count - chunk;

drivers/crypto/axis/artpec6_crypto.c

873

artpec6_crypto_walk_advance(walk, chunk);

drivers/crypto/axis/artpec6_crypto.c

887

size_t chunk;

drivers/crypto/axis/artpec6_crypto.c

892

chunk = min(count, artpec6_crypto_walk_chunklen(walk));

drivers/crypto/axis/artpec6_crypto.c

895

pr_debug("OUT-CHUNK %pad:%zu\n", &addr, chunk);

drivers/crypto/axis/artpec6_crypto.c

900

chunk = min_t(size_t, chunk, (4-(addr&3)));

drivers/crypto/axis/artpec6_crypto.c

902

sg_pcopy_to_buffer(walk->sg, 1, buf, chunk,

drivers/crypto/axis/artpec6_crypto.c

906

chunk,

drivers/crypto/axis/artpec6_crypto.c

915

chunk,

drivers/crypto/axis/artpec6_crypto.c

923

chunk, false);

drivers/crypto/axis/artpec6_crypto.c

929

count = count - chunk;

drivers/crypto/axis/artpec6_crypto.c

930

artpec6_crypto_walk_advance(walk, chunk);

drivers/crypto/cavium/cpt/cptvf_main.c

171

struct command_chunk *chunk = NULL;

drivers/crypto/cavium/cpt/cptvf_main.c

181

hlist_for_each_entry_safe(chunk, node, &cqinfo->queue[i].chead,

drivers/crypto/cavium/cpt/cptvf_main.c

184

chunk->size + CPT_NEXT_CHUNK_PTR_SIZE,

drivers/crypto/cavium/cpt/cptvf_main.c

185

chunk->head,

drivers/crypto/cavium/cpt/cptvf_main.c

186

chunk->dma_addr);

drivers/crypto/cavium/cpt/cptvf_main.c

187

chunk->head = NULL;

drivers/crypto/cavium/cpt/cptvf_main.c

188

chunk->dma_addr = 0;

drivers/crypto/cavium/cpt/cptvf_main.c

189

hlist_del(&chunk->nextchunk);

drivers/crypto/cavium/cpt/cptvf_main.c

190

kfree_sensitive(chunk);

drivers/crypto/cavium/cpt/cptvf_reqmanager.c

229

struct command_chunk *chunk;

drivers/crypto/cavium/cpt/cptvf_reqmanager.c

247

hlist_for_each_entry(chunk, &queue->chead, nextchunk) {

drivers/crypto/cavium/cpt/cptvf_reqmanager.c

248

if (chunk == queue->qhead) {

drivers/crypto/cavium/cpt/cptvf_reqmanager.c

251

queue->qhead = chunk;

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

493

char *chunk;

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

501

chunk = buf + file_chunk->offset;

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

503

chunk, file_chunk->size))

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

508

obj_hdr->file_buff = chunk;

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

159

struct otx_cpt_cmd_chunk *chunk = NULL;

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

168

chunk = list_first_entry(&cqinfo->queue[i].chead,

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

172

chunk->size + OTX_CPT_NEXT_CHUNK_PTR_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

173

chunk->head,

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

174

chunk->dma_addr);

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

175

chunk->head = NULL;

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

176

chunk->dma_addr = 0;

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

177

list_del(&chunk->nextchunk);

drivers/crypto/marvell/octeontx/otx_cptvf_main.c

178

kfree_sensitive(chunk);

drivers/dax/fsdev.c

36

unsigned int chunk = min_t(unsigned int, len, PAGE_SIZE - off);

drivers/dax/fsdev.c

38

memcpy_flushcache(addr, mem + off, chunk);

drivers/dax/fsdev.c

40

len -= chunk;

drivers/dax/fsdev.c

43

addr += chunk;

drivers/dma/at_hdmac.c

901

struct data_chunk *chunk = xt->sgl + i;

drivers/dma/at_hdmac.c

903

if ((chunk->size != xt->sgl->size) ||

drivers/dma/at_hdmac.c

904

(dmaengine_get_dst_icg(xt, chunk) != dmaengine_get_dst_icg(xt, first)) ||

drivers/dma/at_hdmac.c

905

(dmaengine_get_src_icg(xt, chunk) != dmaengine_get_src_icg(xt, first))) {

drivers/dma/at_hdmac.c

912

len += chunk->size;

drivers/dma/at_xdmac.c

1006

dwidth = at_xdmac_align_width(chan, src | dst | chunk->size);

drivers/dma/at_xdmac.c

1007

if (chunk->size >= (AT_XDMAC_MBR_UBC_UBLEN_MAX << dwidth)) {

drivers/dma/at_xdmac.c

1010

__func__, chunk->size,

drivers/dma/at_xdmac.c

1043

ublen = chunk->size >> dwidth;

drivers/dma/at_xdmac.c

1047

desc->lld.mbr_sus = dmaengine_get_src_icg(xt, chunk);

drivers/dma/at_xdmac.c

1048

desc->lld.mbr_dus = dmaengine_get_dst_icg(xt, chunk);

drivers/dma/at_xdmac.c

1077

struct data_chunk *chunk;

drivers/dma/at_xdmac.c

1117

chunk = xt->sgl + i;

drivers/dma/at_xdmac.c

1119

dst_icg = dmaengine_get_dst_icg(xt, chunk);

drivers/dma/at_xdmac.c

1120

src_icg = dmaengine_get_src_icg(xt, chunk);

drivers/dma/at_xdmac.c

1122

src_skip = chunk->size + src_icg;

drivers/dma/at_xdmac.c

1123

dst_skip = chunk->size + dst_icg;

drivers/dma/at_xdmac.c

1127

__func__, chunk->size, src_icg, dst_icg);

drivers/dma/at_xdmac.c

1132

xt, chunk);

drivers/dma/at_xdmac.c

1153

len += chunk->size;

drivers/dma/at_xdmac.c

980

struct data_chunk *chunk)

drivers/dma/dw-edma/dw-edma-core.c

102

chunk->burst = NULL;

drivers/dma/dw-edma/dw-edma-core.c

104

desc->chunk = chunk;

drivers/dma/dw-edma/dw-edma-core.c

107

return chunk;

drivers/dma/dw-edma/dw-edma-core.c

127

static void dw_edma_free_burst(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-edma-core.c

132

list_for_each_entry_safe(child, _next, &chunk->burst->list, list) {

drivers/dma/dw-edma/dw-edma-core.c

135

chunk->bursts_alloc--;

drivers/dma/dw-edma/dw-edma-core.c

140

chunk->burst = NULL;

drivers/dma/dw-edma/dw-edma-core.c

147

if (!desc->chunk)

drivers/dma/dw-edma/dw-edma-core.c

151

list_for_each_entry_safe(child, _next, &desc->chunk->list, list) {

drivers/dma/dw-edma/dw-edma-core.c

160

desc->chunk = NULL;

drivers/dma/dw-edma/dw-edma-core.c

189

child = list_first_entry_or_null(&desc->chunk->list,

drivers/dma/dw-edma/dw-edma-core.c

393

struct dw_edma_chunk *chunk;

drivers/dma/dw-edma/dw-edma-core.c

43

static struct dw_edma_burst *dw_edma_alloc_burst(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-edma-core.c

467

chunk = dw_edma_alloc_chunk(desc);

drivers/dma/dw-edma/dw-edma-core.c

468

if (unlikely(!chunk))

drivers/dma/dw-edma/dw-edma-core.c

498

if (chunk->bursts_alloc == bursts_max) {

drivers/dma/dw-edma/dw-edma-core.c

499

chunk = dw_edma_alloc_chunk(desc);

drivers/dma/dw-edma/dw-edma-core.c

500

if (unlikely(!chunk))

drivers/dma/dw-edma/dw-edma-core.c

504

burst = dw_edma_alloc_burst(chunk);

drivers/dma/dw-edma/dw-edma-core.c

515

chunk->ll_region.sz += burst->sz;

drivers/dma/dw-edma/dw-edma-core.c

52

if (chunk->burst) {

drivers/dma/dw-edma/dw-edma-core.c

54

chunk->bursts_alloc++;

drivers/dma/dw-edma/dw-edma-core.c

55

list_add_tail(&burst->list, &chunk->burst->list);

drivers/dma/dw-edma/dw-edma-core.c

58

chunk->bursts_alloc = 0;

drivers/dma/dw-edma/dw-edma-core.c

59

chunk->burst = burst;

drivers/dma/dw-edma/dw-edma-core.c

69

struct dw_edma_chunk *chunk;

drivers/dma/dw-edma/dw-edma-core.c

71

chunk = kzalloc_obj(*chunk, GFP_NOWAIT);

drivers/dma/dw-edma/dw-edma-core.c

72

if (unlikely(!chunk))

drivers/dma/dw-edma/dw-edma-core.c

75

INIT_LIST_HEAD(&chunk->list);

drivers/dma/dw-edma/dw-edma-core.c

76

chunk->chan = chan;

drivers/dma/dw-edma/dw-edma-core.c

83

chunk->cb = !(desc->chunks_alloc % 2);

drivers/dma/dw-edma/dw-edma-core.c

85

chunk->ll_region.paddr = chip->ll_region_wr[chan->id].paddr;

drivers/dma/dw-edma/dw-edma-core.c

86

chunk->ll_region.vaddr = chip->ll_region_wr[chan->id].vaddr;

drivers/dma/dw-edma/dw-edma-core.c

88

chunk->ll_region.paddr = chip->ll_region_rd[chan->id].paddr;

drivers/dma/dw-edma/dw-edma-core.c

89

chunk->ll_region.vaddr = chip->ll_region_rd[chan->id].vaddr;

drivers/dma/dw-edma/dw-edma-core.c

92

if (desc->chunk) {

drivers/dma/dw-edma/dw-edma-core.c

94

if (!dw_edma_alloc_burst(chunk)) {

drivers/dma/dw-edma/dw-edma-core.c

95

kfree(chunk);

drivers/dma/dw-edma/dw-edma-core.c

99

list_add_tail(&chunk->list, &desc->chunk->list);

drivers/dma/dw-edma/dw-edma-core.h

127

void (*start)(struct dw_edma_chunk *chunk, bool first);

drivers/dma/dw-edma/dw-edma-core.h

195

void dw_edma_core_start(struct dw_edma *dw, struct dw_edma_chunk *chunk, bool first)

drivers/dma/dw-edma/dw-edma-core.h

197

dw->core->start(chunk, first);

drivers/dma/dw-edma/dw-edma-core.h

66

struct dw_edma_chunk *chunk;

drivers/dma/dw-edma/dw-edma-v0-core.c

279

static void dw_edma_v0_write_ll_data(struct dw_edma_chunk *chunk, int i,

drivers/dma/dw-edma/dw-edma-v0-core.c

284

if (chunk->chan->dw->chip->flags & DW_EDMA_CHIP_LOCAL) {

drivers/dma/dw-edma/dw-edma-v0-core.c

285

struct dw_edma_v0_lli *lli = chunk->ll_region.vaddr.mem + ofs;

drivers/dma/dw-edma/dw-edma-v0-core.c

292

struct dw_edma_v0_lli __iomem *lli = chunk->ll_region.vaddr.io + ofs;

drivers/dma/dw-edma/dw-edma-v0-core.c

301

static void dw_edma_v0_write_ll_link(struct dw_edma_chunk *chunk,

drivers/dma/dw-edma/dw-edma-v0-core.c

306

if (chunk->chan->dw->chip->flags & DW_EDMA_CHIP_LOCAL) {

drivers/dma/dw-edma/dw-edma-v0-core.c

307

struct dw_edma_v0_llp *llp = chunk->ll_region.vaddr.mem + ofs;

drivers/dma/dw-edma/dw-edma-v0-core.c

312

struct dw_edma_v0_llp __iomem *llp = chunk->ll_region.vaddr.io + ofs;

drivers/dma/dw-edma/dw-edma-v0-core.c

319

static void dw_edma_v0_core_write_chunk(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-edma-v0-core.c

322

struct dw_edma_chan *chan = chunk->chan;

drivers/dma/dw-edma/dw-edma-v0-core.c

326

if (chunk->cb)

drivers/dma/dw-edma/dw-edma-v0-core.c

329

j = chunk->bursts_alloc;

drivers/dma/dw-edma/dw-edma-v0-core.c

330

list_for_each_entry(child, &chunk->burst->list, list) {

drivers/dma/dw-edma/dw-edma-v0-core.c

338

dw_edma_v0_write_ll_data(chunk, i++, control, child->sz,

drivers/dma/dw-edma/dw-edma-v0-core.c

343

if (!chunk->cb)

drivers/dma/dw-edma/dw-edma-v0-core.c

346

dw_edma_v0_write_ll_link(chunk, i, control, chunk->ll_region.paddr);

drivers/dma/dw-edma/dw-edma-v0-core.c

349

static void dw_edma_v0_sync_ll_data(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-edma-v0-core.c

359

if (!(chunk->chan->dw->chip->flags & DW_EDMA_CHIP_LOCAL))

drivers/dma/dw-edma/dw-edma-v0-core.c

360

readl(chunk->ll_region.vaddr.io);

drivers/dma/dw-edma/dw-edma-v0-core.c

363

static void dw_edma_v0_core_start(struct dw_edma_chunk *chunk, bool first)

drivers/dma/dw-edma/dw-edma-v0-core.c

365

struct dw_edma_chan *chan = chunk->chan;

drivers/dma/dw-edma/dw-edma-v0-core.c

370

dw_edma_v0_core_write_chunk(chunk);

drivers/dma/dw-edma/dw-edma-v0-core.c

431

lower_32_bits(chunk->ll_region.paddr));

drivers/dma/dw-edma/dw-edma-v0-core.c

433

upper_32_bits(chunk->ll_region.paddr));

drivers/dma/dw-edma/dw-edma-v0-core.c

436

dw_edma_v0_sync_ll_data(chunk);

drivers/dma/dw-edma/dw-hdma-v0-core.c

155

static void dw_hdma_v0_write_ll_data(struct dw_edma_chunk *chunk, int i,

drivers/dma/dw-edma/dw-hdma-v0-core.c

160

if (chunk->chan->dw->chip->flags & DW_EDMA_CHIP_LOCAL) {

drivers/dma/dw-edma/dw-hdma-v0-core.c

161

struct dw_hdma_v0_lli *lli = chunk->ll_region.vaddr.mem + ofs;

drivers/dma/dw-edma/dw-hdma-v0-core.c

168

struct dw_hdma_v0_lli __iomem *lli = chunk->ll_region.vaddr.io + ofs;

drivers/dma/dw-edma/dw-hdma-v0-core.c

177

static void dw_hdma_v0_write_ll_link(struct dw_edma_chunk *chunk,

drivers/dma/dw-edma/dw-hdma-v0-core.c

182

if (chunk->chan->dw->chip->flags & DW_EDMA_CHIP_LOCAL) {

drivers/dma/dw-edma/dw-hdma-v0-core.c

183

struct dw_hdma_v0_llp *llp = chunk->ll_region.vaddr.mem + ofs;

drivers/dma/dw-edma/dw-hdma-v0-core.c

188

struct dw_hdma_v0_llp __iomem *llp = chunk->ll_region.vaddr.io + ofs;

drivers/dma/dw-edma/dw-hdma-v0-core.c

195

static void dw_hdma_v0_core_write_chunk(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-hdma-v0-core.c

200

if (chunk->cb)

drivers/dma/dw-edma/dw-hdma-v0-core.c

203

list_for_each_entry(child, &chunk->burst->list, list)

drivers/dma/dw-edma/dw-hdma-v0-core.c

204

dw_hdma_v0_write_ll_data(chunk, i++, control, child->sz,

drivers/dma/dw-edma/dw-hdma-v0-core.c

208

if (!chunk->cb)

drivers/dma/dw-edma/dw-hdma-v0-core.c

211

dw_hdma_v0_write_ll_link(chunk, i, control, chunk->ll_region.paddr);

drivers/dma/dw-edma/dw-hdma-v0-core.c

214

static void dw_hdma_v0_sync_ll_data(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-hdma-v0-core.c

224

if (!(chunk->chan->dw->chip->flags & DW_EDMA_CHIP_LOCAL))

drivers/dma/dw-edma/dw-hdma-v0-core.c

225

readl(chunk->ll_region.vaddr.io);

drivers/dma/dw-edma/dw-hdma-v0-core.c

228

static void dw_hdma_v0_core_ll_start(struct dw_edma_chunk *chunk, bool first)

drivers/dma/dw-edma/dw-hdma-v0-core.c

230

struct dw_edma_chan *chan = chunk->chan;

drivers/dma/dw-edma/dw-hdma-v0-core.c

234

dw_hdma_v0_core_write_chunk(chunk);

drivers/dma/dw-edma/dw-hdma-v0-core.c

252

lower_32_bits(chunk->ll_region.paddr));

drivers/dma/dw-edma/dw-hdma-v0-core.c

254

upper_32_bits(chunk->ll_region.paddr));

drivers/dma/dw-edma/dw-hdma-v0-core.c

260

dw_hdma_v0_sync_ll_data(chunk);

drivers/dma/dw-edma/dw-hdma-v0-core.c

266

static void dw_hdma_v0_core_non_ll_start(struct dw_edma_chunk *chunk)

drivers/dma/dw-edma/dw-hdma-v0-core.c

268

struct dw_edma_chan *chan = chunk->chan;

drivers/dma/dw-edma/dw-hdma-v0-core.c

273

child = list_first_entry_or_null(&chunk->burst->list,

drivers/dma/dw-edma/dw-hdma-v0-core.c

318

static void dw_hdma_v0_core_start(struct dw_edma_chunk *chunk, bool first)

drivers/dma/dw-edma/dw-hdma-v0-core.c

320

struct dw_edma_chan *chan = chunk->chan;

drivers/dma/dw-edma/dw-hdma-v0-core.c

323

dw_hdma_v0_core_non_ll_start(chunk);

drivers/dma/dw-edma/dw-hdma-v0-core.c

325

dw_hdma_v0_core_ll_start(chunk, first);

drivers/dma/ioat/dma.c

342

int chunk;

drivers/dma/ioat/dma.c

347

chunk = idx / IOAT_DESCS_PER_CHUNK;

drivers/dma/ioat/dma.c

350

pos = (u8 *)ioat_chan->descs[chunk].virt + offs;

drivers/dma/ioat/dma.c

351

phys = ioat_chan->descs[chunk].hw + offs;

drivers/dma/sh/rcar-dmac.c

1005

chunk->src_addr = dev_addr;

drivers/dma/sh/rcar-dmac.c

1006

chunk->dst_addr = mem_addr;

drivers/dma/sh/rcar-dmac.c

1008

chunk->src_addr = mem_addr;

drivers/dma/sh/rcar-dmac.c

1009

chunk->dst_addr = dev_addr;

drivers/dma/sh/rcar-dmac.c

1012

chunk->size = size;

drivers/dma/sh/rcar-dmac.c

1016

chan->index, chunk, desc, i, sg, size, len,

drivers/dma/sh/rcar-dmac.c

1017

&chunk->src_addr, &chunk->dst_addr);

drivers/dma/sh/rcar-dmac.c

1025

list_add_tail(&chunk->node, &desc->chunks);

drivers/dma/sh/rcar-dmac.c

1320

struct rcar_dmac_xfer_chunk *chunk;

drivers/dma/sh/rcar-dmac.c

1409

list_for_each_entry_reverse(chunk, &desc->chunks, node) {

drivers/dma/sh/rcar-dmac.c

1410

if (chunk == running || ++dptr == desc->nchunks)

drivers/dma/sh/rcar-dmac.c

1413

residue += chunk->size;

drivers/dma/sh/rcar-dmac.c

388

struct rcar_dmac_xfer_chunk *chunk =

drivers/dma/sh/rcar-dmac.c

398

chunk->src_addr >> 32);

drivers/dma/sh/rcar-dmac.c

400

chunk->dst_addr >> 32);

drivers/dma/sh/rcar-dmac.c

419

chunk->dst_addr & 0xffffffff);

drivers/dma/sh/rcar-dmac.c

449

struct rcar_dmac_xfer_chunk *chunk = desc->running;

drivers/dma/sh/rcar-dmac.c

453

chan->index, chunk, chunk->size, &chunk->src_addr,

drivers/dma/sh/rcar-dmac.c

454

&chunk->dst_addr);

drivers/dma/sh/rcar-dmac.c

458

chunk->src_addr >> 32);

drivers/dma/sh/rcar-dmac.c

460

chunk->dst_addr >> 32);

drivers/dma/sh/rcar-dmac.c

463

chunk->src_addr & 0xffffffff);

drivers/dma/sh/rcar-dmac.c

465

chunk->dst_addr & 0xffffffff);

drivers/dma/sh/rcar-dmac.c

467

chunk->size >> desc->xfer_shift);

drivers/dma/sh/rcar-dmac.c

673

struct rcar_dmac_xfer_chunk *chunk = &page->chunks[i];

drivers/dma/sh/rcar-dmac.c

675

list_add_tail(&chunk->node, &list);

drivers/dma/sh/rcar-dmac.c

698

struct rcar_dmac_xfer_chunk *chunk;

drivers/dma/sh/rcar-dmac.c

718

chunk = list_first_entry(&chan->desc.chunks_free,

drivers/dma/sh/rcar-dmac.c

720

list_del(&chunk->node);

drivers/dma/sh/rcar-dmac.c

724

return chunk;

drivers/dma/sh/rcar-dmac.c

762

struct rcar_dmac_xfer_chunk *chunk;

drivers/dma/sh/rcar-dmac.c

771

list_for_each_entry(chunk, &desc->chunks, node) {

drivers/dma/sh/rcar-dmac.c

772

hwdesc->sar = chunk->src_addr;

drivers/dma/sh/rcar-dmac.c

773

hwdesc->dar = chunk->dst_addr;

drivers/dma/sh/rcar-dmac.c

774

hwdesc->tcr = chunk->size >> desc->xfer_shift;

drivers/dma/sh/rcar-dmac.c

933

struct rcar_dmac_xfer_chunk *chunk;

drivers/dma/sh/rcar-dmac.c

998

chunk = rcar_dmac_xfer_chunk_get(chan);

drivers/dma/sh/rcar-dmac.c

999

if (!chunk) {

drivers/dma/sh/shdma-base.c

102

chunk->async_tx.callback = NULL;

drivers/dma/sh/shdma-base.c

104

chunk->cookie = cookie;

drivers/dma/sh/shdma-base.c

105

list_move_tail(&chunk->node, &schan->ld_queue);

drivers/dma/sh/shdma-base.c

108

tx->cookie, &chunk->async_tx, schan->id);

drivers/dma/sh/shdma-base.c

138

list_for_each_entry_safe(chunk, c, &schan->ld_queue, node) {

drivers/dma/sh/shdma-base.c

139

if (chunk->cookie == cookie) {

drivers/dma/sh/shdma-base.c

140

chunk->mark = DESC_IDLE;

drivers/dma/sh/shdma-base.c

141

list_move(&chunk->node, &schan->ld_free);

drivers/dma/sh/shdma-base.c

72

struct shdma_desc *chunk, *c, *desc =

drivers/dma/sh/shdma-base.c

86

list_for_each_entry_safe(chunk, c, desc->node.prev, node) {

drivers/dma/sh/shdma-base.c

91

if (chunk != desc && (chunk->mark == DESC_IDLE ||

drivers/dma/sh/shdma-base.c

92

chunk->async_tx.cookie > 0 ||

drivers/dma/sh/shdma-base.c

93

chunk->async_tx.cookie == -EBUSY ||

drivers/dma/sh/shdma-base.c

94

&chunk->node == &schan->ld_free))

drivers/dma/sh/shdma-base.c

96

chunk->mark = DESC_SUBMITTED;

drivers/dma/sh/shdma-base.c

97

if (chunk->chunks == 1) {

drivers/dma/sh/shdma-base.c

98

chunk->async_tx.callback = callback;

drivers/dma/sh/shdma-base.c

99

chunk->async_tx.callback_param = tx->callback_param;

drivers/dma/stm32/stm32-dma3.c

1330

size_t chunk = min_t(size_t, len, STM32_DMA3_MAX_BLOCK_SIZE);

drivers/dma/stm32/stm32-dma3.c

1333

(chunk < STM32_DMA3_MAX_BLOCK_SIZE && chunk >= chan->max_burst))

drivers/dma/stm32/stm32-dma3.c

1334

chunk = chan->max_burst * (len / chan->max_burst);

drivers/dma/stm32/stm32-dma3.c

1341

src, dst, chunk);

drivers/dma/stm32/stm32-dma3.c

1344

dev_addr += chunk;

drivers/dma/stm32/stm32-dma3.c

1350

src, dst, chunk);

drivers/dma/stm32/stm32-dma3.c

1353

dev_addr += chunk;

drivers/dma/stm32/stm32-dma3.c

1359

stm32_dma3_chan_prep_hwdesc(chan, swdesc, j, src, dst, chunk,

drivers/dma/stm32/stm32-dma3.c

1362

sg_addr += chunk;

drivers/dma/stm32/stm32-dma3.c

1363

len -= chunk;

drivers/firmware/arm_scmi/pinctrl.c

474

u32 chunk;

drivers/firmware/arm_scmi/pinctrl.c

486

chunk = (nr_configs - conf_num > configs_in_chunk) ?

drivers/firmware/arm_scmi/pinctrl.c

491

chunk * 2 * sizeof(__le32), 0, &t);

drivers/firmware/arm_scmi/pinctrl.c

499

FIELD_PREP(GENMASK(9, 2), chunk);

drivers/firmware/arm_scmi/pinctrl.c

502

for (i = 0; i < chunk; i++) {

drivers/firmware/arm_scmi/pinctrl.c

516

conf_num += chunk;

drivers/firmware/cirrus/cs_dsp.c

3585

struct cs_dsp_chunk chunk;

drivers/firmware/cirrus/cs_dsp.c

3606

chunk = cs_dsp_chunk(words, wseq->ctl->len);

drivers/firmware/cirrus/cs_dsp.c

3608

while (!cs_dsp_chunk_end(&chunk)) {

drivers/firmware/cirrus/cs_dsp.c

3615

op->offset = cs_dsp_chunk_bytes(&chunk);

drivers/firmware/cirrus/cs_dsp.c

3616

op->operation = cs_dsp_chunk_read(&chunk, 8);

drivers/firmware/cirrus/cs_dsp.c

3623

op->data = cs_dsp_chunk_read(&chunk, 16);

drivers/firmware/cirrus/cs_dsp.c

3626

op->address = cs_dsp_chunk_read(&chunk, 8);

drivers/firmware/cirrus/cs_dsp.c

3627

op->data = cs_dsp_chunk_read(&chunk, 32);

drivers/firmware/cirrus/cs_dsp.c

3631

op->address = cs_dsp_chunk_read(&chunk, 24);

drivers/firmware/cirrus/cs_dsp.c

3632

op->data = cs_dsp_chunk_read(&chunk, 16);

drivers/firmware/cirrus/cs_dsp.c

3635

op->address = cs_dsp_chunk_read(&chunk, 32);

drivers/firmware/cirrus/cs_dsp.c

3636

op->data = cs_dsp_chunk_read(&chunk, 32);

drivers/firmware/cirrus/cs_dsp.c

3725

struct cs_dsp_chunk chunk;

drivers/firmware/cirrus/cs_dsp.c

3751

chunk = cs_dsp_chunk(words, sizeof(words));

drivers/firmware/cirrus/cs_dsp.c

3752

cs_dsp_chunk_write(&chunk, 8, op_new->operation);

drivers/firmware/cirrus/cs_dsp.c

3756

cs_dsp_chunk_write(&chunk, 32, op_new->address);

drivers/firmware/cirrus/cs_dsp.c

3757

cs_dsp_chunk_write(&chunk, 32, op_new->data);

drivers/firmware/cirrus/cs_dsp.c

3761

cs_dsp_chunk_write(&chunk, 24, op_new->address);

drivers/firmware/cirrus/cs_dsp.c

3762

cs_dsp_chunk_write(&chunk, 16, op_new->data);

drivers/firmware/cirrus/cs_dsp.c

3770

new_op_size = cs_dsp_chunk_bytes(&chunk);

drivers/firmware/qcom/qcom_tzmem.c

304

struct qcom_tzmem_chunk *chunk;

drivers/firmware/qcom/qcom_tzmem.c

316

chunk = radix_tree_deref_slot_protected(slot,

drivers/firmware/qcom/qcom_tzmem.c

319

if (chunk->owner == pool)

drivers/firmware/qcom/qcom_tzmem.c

417

struct qcom_tzmem_chunk *chunk __free(kfree) = kzalloc(sizeof(*chunk),

drivers/firmware/qcom/qcom_tzmem.c

419

if (!chunk)

drivers/firmware/qcom/qcom_tzmem.c

431

chunk->size = size;

drivers/firmware/qcom/qcom_tzmem.c

432

chunk->owner = pool;

drivers/firmware/qcom/qcom_tzmem.c

435

ret = radix_tree_insert(&qcom_tzmem_chunks, vaddr, chunk);

drivers/firmware/qcom/qcom_tzmem.c

441

chunk = NULL;

drivers/firmware/qcom/qcom_tzmem.c

456

struct qcom_tzmem_chunk *chunk;

drivers/firmware/qcom/qcom_tzmem.c

459

chunk = radix_tree_delete_item(&qcom_tzmem_chunks,

drivers/firmware/qcom/qcom_tzmem.c

462

if (!chunk) {

drivers/firmware/qcom/qcom_tzmem.c

468

scoped_guard(spinlock_irqsave, &chunk->owner->lock)

drivers/firmware/qcom/qcom_tzmem.c

469

gen_pool_free(chunk->owner->genpool, (unsigned long)vaddr,

drivers/firmware/qcom/qcom_tzmem.c

470

chunk->size);

drivers/firmware/qcom/qcom_tzmem.c

471

kfree(chunk);

drivers/firmware/qcom/qcom_tzmem.c

487

struct qcom_tzmem_chunk *chunk;

drivers/firmware/qcom/qcom_tzmem.c

495

chunk = radix_tree_deref_slot_protected(slot,

drivers/firmware/qcom/qcom_tzmem.c

498

ret = gen_pool_virt_to_phys(chunk->owner->genpool,

drivers/fsi/fsi-sbefifo.c

498

size_t len, chunk, vacant = 0, remaining = cmd_len;

drivers/fsi/fsi-sbefifo.c

516

len = chunk = min(vacant, remaining);

drivers/fsi/fsi-sbefifo.c

519

status, vacant, chunk);

drivers/fsi/fsi-sbefifo.c

529

remaining -= chunk;

drivers/fsi/fsi-sbefifo.c

530

vacant -= chunk;

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1475

size_t chunk;

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1504

chunk = min(available, count);

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1505

memcpy(buffer, dev->bulk_in_buffer + dev->bulk_in_copied, chunk);

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1506

rv = chunk;

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1507

dev->bulk_in_copied += chunk;

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1513

chunk = min(available, count + 2);

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1514

if (chunk < 2) {

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1515

dev_err(&dev->udev->dev, "BAD READ - chunk: %zu\n", chunk);

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1520

memcpy(buffer, dev->bulk_in_buffer + 2, chunk - 2);

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1521

rv = chunk;

drivers/gpib/lpvo_usb_gpib/lpvo_usb_gpib.c

1522

dev->bulk_in_copied += chunk;

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

438

u32 chunk = ring->ring_size - (pos << 2);

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

440

memcpy(signature, &ring->ring[pos], chunk);

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

441

memcpy(signature + chunk, ring->ring, CPER_SIGNATURE_SZ - chunk);

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

451

u32 chunk, rec_len = 0;

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

453

chunk = ring->ring_size - (pos << 2);

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

456

if (chunk >= sizeof(chdr)) {

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

459

memcpy(&chdr, &ring->ring[pos], chunk);

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

460

memcpy((u8 *)&chdr + chunk, ring->ring, sizeof(chdr) - chunk);

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

480

return chunk;

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

482

return umin(rec_len, chunk);

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

489

u32 chunk, ent_sz;

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

507

chunk = umin(ent_sz, count);

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

509

memcpy(&ring->ring[ring->wptr], s, chunk);

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

511

ring->wptr += (chunk >> 2);

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

513

count -= chunk;

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

514

s += chunk;

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

330

struct amdgpu_cs_chunk *chunk,

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

334

struct drm_amdgpu_cs_chunk_ib *chunk_ib = chunk->kdata;

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

395

struct amdgpu_cs_chunk *chunk)

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

397

struct drm_amdgpu_cs_chunk_dep *deps = chunk->kdata;

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

402

num_deps = chunk->length_dw * 4 /

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

430

if (chunk->chunk_id == AMDGPU_CHUNK_ID_SCHEDULED_DEPENDENCIES) {

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

467

struct amdgpu_cs_chunk *chunk)

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

469

struct drm_amdgpu_cs_chunk_sem *deps = chunk->kdata;

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

473

num_deps = chunk->length_dw * 4 /

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

485

struct amdgpu_cs_chunk *chunk)

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

487

struct drm_amdgpu_cs_chunk_syncobj *syncobj_deps = chunk->kdata;

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

491

num_deps = chunk->length_dw * 4 /

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

505

struct amdgpu_cs_chunk *chunk)

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

507

struct drm_amdgpu_cs_chunk_sem *deps = chunk->kdata;

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

511

num_deps = chunk->length_dw * 4 /

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

538

struct amdgpu_cs_chunk *chunk)

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

540

struct drm_amdgpu_cs_chunk_syncobj *syncobj_deps = chunk->kdata;

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

544

num_deps = chunk->length_dw * 4 /

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

580

struct amdgpu_cs_chunk *chunk)

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

582

struct drm_amdgpu_cs_chunk_cp_gfx_shadow *shadow = chunk->kdata;

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

605

struct amdgpu_cs_chunk *chunk;

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

607

chunk = &p->chunks[i];

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

609

switch (chunk->chunk_id) {

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

611

r = amdgpu_cs_p2_ib(p, chunk, &ce_preempt, &de_preempt);

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

617

r = amdgpu_cs_p2_dependencies(p, chunk);

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

622

r = amdgpu_cs_p2_syncobj_in(p, chunk);

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

627

r = amdgpu_cs_p2_syncobj_out(p, chunk);

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

632

r = amdgpu_cs_p2_syncobj_timeline_wait(p, chunk);

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

637

r = amdgpu_cs_p2_syncobj_timeline_signal(p, chunk);

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

642

r = amdgpu_cs_p2_shadow(p, chunk);

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

103

list_for_each_entry(chunk, &e->list, entry) {

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

104

if (chunk->sync_seq > last_seq && chunk->sync_seq <= seq) {

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

106

chunk->sync_seq,

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

108

if (chunk->sync_seq ==

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

110

if (chunk->cntl_offset <= e->ring->buf_mask)

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

112

chunk->cntl_offset);

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

113

if (chunk->ce_offset <= e->ring->buf_mask)

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

114

amdgpu_ring_patch_ce(e->ring, chunk->ce_offset);

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

115

if (chunk->de_offset <= e->ring->buf_mask)

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

116

amdgpu_ring_patch_de(e->ring, chunk->de_offset);

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

119

chunk->start,

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

120

chunk->end);

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

121

mux->wptr_resubmit = chunk->end;

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

178

struct amdgpu_mux_chunk *chunk, *chunk2;

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

183

list_for_each_entry_safe(chunk, chunk2, &e->list, entry) {

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

184

list_del(&chunk->entry);

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

185

kmem_cache_free(amdgpu_mux_chunk_slab, chunk);

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

436

struct amdgpu_mux_chunk *chunk;

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

448

chunk = kmem_cache_alloc(amdgpu_mux_chunk_slab, GFP_KERNEL);

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

449

if (!chunk) {

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

454

chunk->start = ring->wptr;

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

456

chunk->cntl_offset = ring->buf_mask + 1;

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

457

chunk->de_offset = ring->buf_mask + 1;

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

458

chunk->ce_offset = ring->buf_mask + 1;

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

459

list_add_tail(&chunk->entry, &e->list);

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

466

struct amdgpu_mux_chunk *chunk, *tmp;

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

476

list_for_each_entry_safe(chunk, tmp, &e->list, entry) {

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

477

if (chunk->sync_seq <= last_seq) {

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

478

list_del(&chunk->entry);

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

479

kmem_cache_free(amdgpu_mux_chunk_slab, chunk);

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

489

struct amdgpu_mux_chunk *chunk;

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

497

chunk = list_last_entry(&e->list, struct amdgpu_mux_chunk, entry);

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

498

if (!chunk) {

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

505

chunk->cntl_offset = offset;

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

508

chunk->de_offset = offset;

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

511

chunk->ce_offset = offset;

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

522

struct amdgpu_mux_chunk *chunk;

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

530

chunk = list_last_entry(&e->list, struct amdgpu_mux_chunk, entry);

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

531

if (!chunk) {

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

536

chunk->end = ring->wptr;

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

537

chunk->sync_seq = READ_ONCE(ring->fence_drv.sync_seq);

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

79

struct amdgpu_mux_chunk *chunk;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

1870

uint16_t chunk;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

1900

chunk = ((uint64_t) addr >> (i * 16)) & 0xFFFF;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

1902

ret = dm_dmub_send_vbios_gpint_command(adev, send_addrs[i], chunk, 30000);

drivers/gpu/drm/display/drm_dp_mst_topology.c

2796

u8 chunk[48];

drivers/gpu/drm/display/drm_dp_mst_topology.c

2828

drm_dp_encode_sideband_msg_hdr(&hdr, chunk, &idx);

drivers/gpu/drm/display/drm_dp_mst_topology.c

2829

memcpy(&chunk[idx], &txmsg->msg[txmsg->cur_offset], tosend);

drivers/gpu/drm/display/drm_dp_mst_topology.c

2831

drm_dp_crc_sideband_chunk_req(&chunk[idx], tosend);

drivers/gpu/drm/display/drm_dp_mst_topology.c

2834

ret = drm_dp_send_sideband_msg(mgr, up, chunk, idx);

drivers/gpu/drm/display/drm_dp_mst_topology.c

794

msg->curchunk_len > ARRAY_SIZE(msg->chunk) ||

drivers/gpu/drm/display/drm_dp_mst_topology.c

795

msg->curchunk_idx + replybuflen > ARRAY_SIZE(msg->chunk))

drivers/gpu/drm/display/drm_dp_mst_topology.c

798

memcpy(&msg->chunk[msg->curchunk_idx], replybuf, replybuflen);

drivers/gpu/drm/display/drm_dp_mst_topology.c

803

crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1);

drivers/gpu/drm/display/drm_dp_mst_topology.c

804

if (crc4 != msg->chunk[msg->curchunk_len - 1])

drivers/gpu/drm/display/drm_dp_mst_topology.c

807

msg->chunk, msg->curchunk_len, false);

drivers/gpu/drm/display/drm_dp_mst_topology.c

812

memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1);

drivers/gpu/drm/drm_mipi_dbi.c

1208

size_t chunk;

drivers/gpu/drm/drm_mipi_dbi.c

1221

chunk = min(len, max_chunk);

drivers/gpu/drm/drm_mipi_dbi.c

1224

tr.len = chunk;

drivers/gpu/drm/drm_mipi_dbi.c

1225

buf += chunk;

drivers/gpu/drm/drm_mipi_dbi.c

1226

len -= chunk;

drivers/gpu/drm/drm_mipi_dbi.c

747

size_t chunk, max_chunk = dbi->tx_buf9_len;

drivers/gpu/drm/drm_mipi_dbi.c

788

chunk = min(len, max_chunk);

drivers/gpu/drm/drm_mipi_dbi.c

789

len -= chunk;

drivers/gpu/drm/drm_mipi_dbi.c

792

if (chunk < 8) {

drivers/gpu/drm/drm_mipi_dbi.c

799

for (i = 1; i < (chunk + 1); i++) {

drivers/gpu/drm/drm_mipi_dbi.c

811

for (i = 1; i < (chunk + 1); i++) {

drivers/gpu/drm/drm_mipi_dbi.c

819

chunk = 8;

drivers/gpu/drm/drm_mipi_dbi.c

822

for (i = 0; i < chunk; i += 8) {

drivers/gpu/drm/drm_mipi_dbi.c

850

tr.len = chunk + added;

drivers/gpu/drm/drm_mipi_dbi.c

892

size_t chunk = min(len, max_chunk);

drivers/gpu/drm/drm_mipi_dbi.c

896

for (i = 0; i < (chunk * 2); i += 2) {

drivers/gpu/drm/drm_mipi_dbi.c

905

for (i = 0; i < chunk; i++) {

drivers/gpu/drm/drm_mipi_dbi.c

912

tr.len = chunk * 2;

drivers/gpu/drm/drm_mipi_dbi.c

913

len -= chunk;

drivers/gpu/drm/i915/gem/i915_gem_mman.c

202

unsigned int chunk)

drivers/gpu/drm/i915/gem/i915_gem_mman.c

207

chunk = roundup(chunk, tile_row_pages(obj) ?: 1);

drivers/gpu/drm/i915/gem/i915_gem_mman.c

210

view.partial.offset = rounddown(page_offset, chunk);

drivers/gpu/drm/i915/gem/i915_gem_mman.c

212

min_t(unsigned int, chunk,

drivers/gpu/drm/i915/gem/i915_gem_mman.c

216

if (chunk >= obj->base.size >> PAGE_SHIFT)

drivers/gpu/drm/lima/lima_sched.c

286

struct lima_dump_chunk *chunk;

drivers/gpu/drm/lima/lima_sched.c

333

chunk = (struct lima_dump_chunk *)(dt + 1);

drivers/gpu/drm/lima/lima_sched.c

334

memset(chunk, 0, sizeof(*chunk));

drivers/gpu/drm/lima/lima_sched.c

335

chunk->id = LIMA_DUMP_CHUNK_FRAME;

drivers/gpu/drm/lima/lima_sched.c

336

chunk->size = pipe->frame_size;

drivers/gpu/drm/lima/lima_sched.c

337

memcpy(chunk + 1, task->frame, pipe->frame_size);

drivers/gpu/drm/lima/lima_sched.c

340

chunk = (void *)(chunk + 1) + chunk->size;

drivers/gpu/drm/lima/lima_sched.c

341

memset(chunk, 0, sizeof(*chunk));

drivers/gpu/drm/lima/lima_sched.c

342

chunk->id = LIMA_DUMP_CHUNK_PROCESS_NAME;

drivers/gpu/drm/lima/lima_sched.c

343

chunk->size = sizeof(ctx->pname);

drivers/gpu/drm/lima/lima_sched.c

344

memcpy(chunk + 1, ctx->pname, sizeof(ctx->pname));

drivers/gpu/drm/lima/lima_sched.c

347

pid_chunk = (void *)(chunk + 1) + chunk->size;

drivers/gpu/drm/nouveau/nouveau_dmem.c

104

struct nouveau_dmem_chunk *chunk = nouveau_page_to_chunk(page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

106

return chunk->drm;

drivers/gpu/drm/nouveau/nouveau_dmem.c

111

struct nouveau_dmem_chunk *chunk = nouveau_page_to_chunk(page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

113

chunk->pagemap.range.start;

drivers/gpu/drm/nouveau/nouveau_dmem.c

115

return chunk->bo->offset + off;

drivers/gpu/drm/nouveau/nouveau_dmem.c

121

struct nouveau_dmem_chunk *chunk = nouveau_page_to_chunk(page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

122

struct nouveau_dmem *dmem = chunk->drm->dmem;

drivers/gpu/drm/nouveau/nouveau_dmem.c

133

WARN_ON(!chunk->callocated);

drivers/gpu/drm/nouveau/nouveau_dmem.c

134

chunk->callocated--;

drivers/gpu/drm/nouveau/nouveau_dmem.c

299

struct nouveau_dmem_chunk *chunk;

drivers/gpu/drm/nouveau/nouveau_dmem.c

306

chunk = kzalloc_obj(*chunk);

drivers/gpu/drm/nouveau/nouveau_dmem.c

307

if (chunk == NULL) {

drivers/gpu/drm/nouveau/nouveau_dmem.c

320

chunk->drm = drm;

drivers/gpu/drm/nouveau/nouveau_dmem.c

321

chunk->pagemap.type = MEMORY_DEVICE_PRIVATE;

drivers/gpu/drm/nouveau/nouveau_dmem.c

322

chunk->pagemap.range.start = res->start;

drivers/gpu/drm/nouveau/nouveau_dmem.c

323

chunk->pagemap.range.end = res->end;

drivers/gpu/drm/nouveau/nouveau_dmem.c

324

chunk->pagemap.nr_range = 1;

drivers/gpu/drm/nouveau/nouveau_dmem.c

325

chunk->pagemap.ops = &nouveau_dmem_pagemap_ops;

drivers/gpu/drm/nouveau/nouveau_dmem.c

326

chunk->pagemap.owner = drm->dev;

drivers/gpu/drm/nouveau/nouveau_dmem.c

329

&chunk->bo);

drivers/gpu/drm/nouveau/nouveau_dmem.c

333

ptr = memremap_pages(&chunk->pagemap, numa_node_id());

drivers/gpu/drm/nouveau/nouveau_dmem.c

340

list_add(&chunk->list, &drm->dmem->chunks);

drivers/gpu/drm/nouveau/nouveau_dmem.c

343

pfn_first = chunk->pagemap.range.start >> PAGE_SHIFT;

drivers/gpu/drm/nouveau/nouveau_dmem.c

374

chunk->callocated++;

drivers/gpu/drm/nouveau/nouveau_dmem.c

384

nouveau_bo_unpin_del(&chunk->bo);

drivers/gpu/drm/nouveau/nouveau_dmem.c

386

release_mem_region(chunk->pagemap.range.start, range_len(&chunk->pagemap.range));

drivers/gpu/drm/nouveau/nouveau_dmem.c

388

kfree(chunk);

drivers/gpu/drm/nouveau/nouveau_dmem.c

396

struct nouveau_dmem_chunk *chunk;

drivers/gpu/drm/nouveau/nouveau_dmem.c

407

chunk = nouveau_page_to_chunk(&folio->page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

408

chunk->callocated++;

drivers/gpu/drm/nouveau/nouveau_dmem.c

414

chunk = nouveau_page_to_chunk(page);

drivers/gpu/drm/nouveau/nouveau_dmem.c

415

chunk->callocated++;

drivers/gpu/drm/nouveau/nouveau_dmem.c

442

struct nouveau_dmem_chunk *chunk;

drivers/gpu/drm/nouveau/nouveau_dmem.c

449

list_for_each_entry(chunk, &drm->dmem->chunks, list) {

drivers/gpu/drm/nouveau/nouveau_dmem.c

450

ret = nouveau_bo_pin(chunk->bo, NOUVEAU_GEM_DOMAIN_VRAM, false);

drivers/gpu/drm/nouveau/nouveau_dmem.c

460

struct nouveau_dmem_chunk *chunk;

drivers/gpu/drm/nouveau/nouveau_dmem.c

466

list_for_each_entry(chunk, &drm->dmem->chunks, list)

drivers/gpu/drm/nouveau/nouveau_dmem.c

467

nouveau_bo_unpin(chunk->bo);

drivers/gpu/drm/nouveau/nouveau_dmem.c

475

nouveau_dmem_evict_chunk(struct nouveau_dmem_chunk *chunk)

drivers/gpu/drm/nouveau/nouveau_dmem.c

477

unsigned long i, npages = range_len(&chunk->pagemap.range) >> PAGE_SHIFT;

drivers/gpu/drm/nouveau/nouveau_dmem.c

486

migrate_device_range(src_pfns, chunk->pagemap.range.start >> PAGE_SHIFT,

drivers/gpu/drm/nouveau/nouveau_dmem.c

510

nouveau_dmem_copy_folio(chunk->drm,

drivers/gpu/drm/nouveau/nouveau_dmem.c

517

nouveau_fence_new(&fence, chunk->drm->dmem->migrate.chan);

drivers/gpu/drm/nouveau/nouveau_dmem.c

524

dma_unmap_page(chunk->drm->dev->dev, dma_info[i].dma_addr,

drivers/gpu/drm/nouveau/nouveau_dmem.c

532

struct nouveau_dmem_chunk *chunk, *tmp;

drivers/gpu/drm/nouveau/nouveau_dmem.c

539

list_for_each_entry_safe(chunk, tmp, &drm->dmem->chunks, list) {

drivers/gpu/drm/nouveau/nouveau_dmem.c

540

nouveau_dmem_evict_chunk(chunk);

drivers/gpu/drm/nouveau/nouveau_dmem.c

541

nouveau_bo_unpin_del(&chunk->bo);

drivers/gpu/drm/nouveau/nouveau_dmem.c

542

WARN_ON(chunk->callocated);

drivers/gpu/drm/nouveau/nouveau_dmem.c

543

list_del(&chunk->list);

drivers/gpu/drm/nouveau/nouveau_dmem.c

544

memunmap_pages(&chunk->pagemap);

drivers/gpu/drm/nouveau/nouveau_dmem.c

545

release_mem_region(chunk->pagemap.range.start,

drivers/gpu/drm/nouveau/nouveau_dmem.c

546

range_len(&chunk->pagemap.range));

drivers/gpu/drm/nouveau/nouveau_dmem.c

547

kfree(chunk);

drivers/gpu/drm/panel/panel-novatek-nt35510.c

589

int chunk = cmdlen;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

592

if (chunk > 15)

drivers/gpu/drm/panel/panel-novatek-nt35510.c

593

chunk = 15;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

594

ret = mipi_dsi_dcs_write(dsi, cmd, seqp, chunk);

drivers/gpu/drm/panel/panel-novatek-nt35510.c

599

cmdwritten += chunk;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

600

seqp += chunk;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

603

chunk = cmdlen - cmdwritten;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

604

if (chunk > 15)

drivers/gpu/drm/panel/panel-novatek-nt35510.c

605

chunk = 15;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

606

ret = mipi_dsi_generic_write(dsi, seqp, chunk);

drivers/gpu/drm/panel/panel-novatek-nt35510.c

611

cmdwritten += chunk;

drivers/gpu/drm/panel/panel-novatek-nt35510.c

612

seqp += chunk;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

43

int chunk;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

53

chunk = remain;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

56

if (chunk > S6E63M0_DSI_MAX_CHUNK)

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

57

chunk = S6E63M0_DSI_MAX_CHUNK;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

58

ret = mipi_dsi_dcs_write(dsi, cmd, seqp, chunk);

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

63

cmdwritten += chunk;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

64

seqp += chunk;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

67

chunk = remain - cmdwritten;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

68

if (chunk > S6E63M0_DSI_MAX_CHUNK)

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

69

chunk = S6E63M0_DSI_MAX_CHUNK;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

76

ret = mipi_dsi_dcs_write(dsi, cmd, seqp, chunk);

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

81

cmdwritten += chunk;

drivers/gpu/drm/panel/panel-samsung-s6e63m0-dsi.c

82

seqp += chunk;

drivers/gpu/drm/panthor/panthor_heap.c

127

struct panthor_heap_chunk *chunk)

drivers/gpu/drm/panthor/panthor_heap.c

130

list_del(&chunk->node);

drivers/gpu/drm/panthor/panthor_heap.c

136

panthor_kernel_bo_destroy(chunk->bo);

drivers/gpu/drm/panthor/panthor_heap.c

137

kfree(chunk);

drivers/gpu/drm/panthor/panthor_heap.c

144

struct panthor_heap_chunk *chunk;

drivers/gpu/drm/panthor/panthor_heap.c

148

chunk = kmalloc_obj(*chunk);

drivers/gpu/drm/panthor/panthor_heap.c

149

if (!chunk)

drivers/gpu/drm/panthor/panthor_heap.c

152

chunk->bo = panthor_kernel_bo_create(pool->ptdev, pool->vm, heap->chunk_size,

drivers/gpu/drm/panthor/panthor_heap.c

157

if (IS_ERR(chunk->bo)) {

drivers/gpu/drm/panthor/panthor_heap.c

158

ret = PTR_ERR(chunk->bo);

drivers/gpu/drm/panthor/panthor_heap.c

162

ret = panthor_kernel_bo_vmap(chunk->bo);

drivers/gpu/drm/panthor/panthor_heap.c

166

hdr = chunk->bo->kmap;

drivers/gpu/drm/panthor/panthor_heap.c

182

panthor_kernel_bo_vunmap(chunk->bo);

drivers/gpu/drm/panthor/panthor_heap.c

185

list_add(&chunk->node, &heap->chunks);

drivers/gpu/drm/panthor/panthor_heap.c

194

panthor_kernel_bo_destroy(chunk->bo);

drivers/gpu/drm/panthor/panthor_heap.c

197

kfree(chunk);

drivers/gpu/drm/panthor/panthor_heap.c

205

struct panthor_heap_chunk *chunk, *tmp;

drivers/gpu/drm/panthor/panthor_heap.c

207

list_for_each_entry_safe(chunk, tmp, &heap->chunks, node)

drivers/gpu/drm/panthor/panthor_heap.c

208

panthor_free_heap_chunk(pool, heap, chunk);

drivers/gpu/drm/panthor/panthor_heap.c

376

struct panthor_heap_chunk *chunk, *tmp, *removed = NULL;

drivers/gpu/drm/panthor/panthor_heap.c

393

list_for_each_entry_safe(chunk, tmp, &heap->chunks, node) {

drivers/gpu/drm/panthor/panthor_heap.c

394

if (panthor_kernel_bo_gpuva(chunk->bo) == chunk_gpu_va) {

drivers/gpu/drm/panthor/panthor_heap.c

395

removed = chunk;

drivers/gpu/drm/panthor/panthor_heap.c

396

list_del(&chunk->node);

drivers/gpu/drm/panthor/panthor_heap.c

405

panthor_kernel_bo_destroy(chunk->bo);

drivers/gpu/drm/panthor/panthor_heap.c

406

kfree(chunk);

drivers/gpu/drm/panthor/panthor_heap.c

440

struct panthor_heap_chunk *chunk;

drivers/gpu/drm/panthor/panthor_heap.c

480

chunk = list_first_entry(&heap->chunks,

drivers/gpu/drm/panthor/panthor_heap.c

483

*new_chunk_gpu_va = (panthor_kernel_bo_gpuva(chunk->bo) & GENMASK_ULL(63, 12)) |

drivers/gpu/drm/qxl/qxl_dev.h

418

struct qxl_data_chunk chunk;

drivers/gpu/drm/qxl/qxl_dev.h

479

struct qxl_data_chunk chunk;

drivers/gpu/drm/qxl/qxl_dev.h

758

struct qxl_data_chunk chunk;

drivers/gpu/drm/qxl/qxl_dev.h

776

struct qxl_data_chunk chunk;

drivers/gpu/drm/qxl/qxl_display.c

627

cursor.chunk.next_chunk = 0;

drivers/gpu/drm/qxl/qxl_display.c

628

cursor.chunk.prev_chunk = 0;

drivers/gpu/drm/qxl/qxl_display.c

629

cursor.chunk.data_size = size;

drivers/gpu/drm/qxl/qxl_draw.c

58

dev_clips->chunk.next_chunk = 0;

drivers/gpu/drm/qxl/qxl_draw.c

59

dev_clips->chunk.prev_chunk = 0;

drivers/gpu/drm/qxl/qxl_draw.c

60

dev_clips->chunk.data_size = sizeof(struct qxl_rect) * num_clips;

drivers/gpu/drm/qxl/qxl_draw.c

61

return (struct qxl_rect *)dev_clips->chunk.data;

drivers/gpu/drm/qxl/qxl_image.c

112

struct qxl_data_chunk *chunk;

drivers/gpu/drm/qxl/qxl_image.c

130

chunk = ptr;

drivers/gpu/drm/qxl/qxl_image.c

131

chunk->data_size = height * chunk_stride;

drivers/gpu/drm/qxl/qxl_image.c

132

chunk->prev_chunk = 0;

drivers/gpu/drm/qxl/qxl_image.c

133

chunk->next_chunk = 0;

drivers/gpu/drm/qxl/qxl_image.c

151

chunk = ptr;

drivers/gpu/drm/qxl/qxl_image.c

152

k_data = chunk->data;

drivers/gpu/drm/qxl/qxl_image.c

40

struct qxl_drm_chunk *chunk;

drivers/gpu/drm/qxl/qxl_image.c

43

chunk = kmalloc_obj(struct qxl_drm_chunk);

drivers/gpu/drm/qxl/qxl_image.c

44

if (!chunk)

drivers/gpu/drm/qxl/qxl_image.c

47

ret = qxl_alloc_bo_reserved(qdev, release, chunk_size, &chunk->bo);

drivers/gpu/drm/qxl/qxl_image.c

49

kfree(chunk);

drivers/gpu/drm/qxl/qxl_image.c

53

list_add_tail(&chunk->head, &image->chunk_list);

drivers/gpu/drm/qxl/qxl_image.c

90

struct qxl_drm_chunk *chunk, *tmp;

drivers/gpu/drm/qxl/qxl_image.c

92

list_for_each_entry_safe(chunk, tmp, &dimage->chunk_list, head) {

drivers/gpu/drm/qxl/qxl_image.c

93

qxl_bo_unref(&chunk->bo);

drivers/gpu/drm/qxl/qxl_image.c

94

kfree(chunk);

drivers/gpu/drm/radeon/radeon_cs.c

108

r = (struct drm_radeon_cs_reloc *)&chunk->kdata[i*4];

drivers/gpu/drm/radeon/radeon_cs.c

83

struct radeon_cs_chunk *chunk;

drivers/gpu/drm/radeon/radeon_cs.c

92

chunk = p->chunk_relocs;

drivers/gpu/drm/radeon/radeon_cs.c

95

p->nrelocs = chunk->length_dw / 4;

drivers/gpu/drm/vboxvideo/vbva_base.c

100

len -= chunk;

drivers/gpu/drm/vboxvideo/vbva_base.c

101

p += chunk;

drivers/gpu/drm/vboxvideo/vbva_base.c

78

u32 chunk = len;

drivers/gpu/drm/vboxvideo/vbva_base.c

80

if (chunk >= available) {

drivers/gpu/drm/vboxvideo/vbva_base.c

85

if (chunk >= available) {

drivers/gpu/drm/vboxvideo/vbva_base.c

90

chunk = available - vbva->partial_write_tresh;

drivers/gpu/drm/vboxvideo/vbva_base.c

93

vbva_buffer_place_data_at(vbva_ctx, p, chunk,

drivers/gpu/drm/vboxvideo/vbva_base.c

96

vbva->free_offset = (vbva->free_offset + chunk) %

drivers/gpu/drm/vboxvideo/vbva_base.c

98

record->len_and_flags += chunk;

drivers/gpu/drm/vboxvideo/vbva_base.c

99

available -= chunk;

drivers/gpu/drm/xe/xe_migrate.c

1751

u32 chunk;

drivers/gpu/drm/xe/xe_migrate.c

1772

chunk = min(size, MAX_PTE_PER_SDI);

drivers/gpu/drm/xe/xe_migrate.c

1778

bb->cs[bb->len++] = MI_STORE_DATA_IMM | MI_SDI_NUM_QW(chunk);

drivers/gpu/drm/xe/xe_migrate.c

1783

ofs, chunk, update);

drivers/gpu/drm/xe/xe_migrate.c

1786

ofs, chunk, update);

drivers/gpu/drm/xe/xe_migrate.c

1788

bb->len += chunk * 2;

drivers/gpu/drm/xe/xe_migrate.c

1789

ofs += chunk;

drivers/gpu/drm/xe/xe_migrate.c

1790

size -= chunk;

drivers/gpu/drm/xe/xe_migrate.c

1939

u32 chunk = min(MAX_PTE_PER_SDI, ptes);

drivers/gpu/drm/xe/xe_migrate.c

1943

MI_SDI_NUM_QW(chunk);

drivers/gpu/drm/xe/xe_migrate.c

1956

if (idx == chunk)

drivers/gpu/drm/xe/xe_migrate.c

1975

ptes -= chunk;

drivers/gpu/drm/xe/xe_migrate.c

1976

ofs += chunk * sizeof(u64);

drivers/gpu/drm/xe/xe_migrate.c

2137

u32 chunk = min(MAX_PTE_PER_SDI, ptes);

drivers/gpu/drm/xe/xe_migrate.c

2140

chunk = ALIGN_DOWN(chunk, PAGE_SIZE / XE_PAGE_SIZE);

drivers/gpu/drm/xe/xe_migrate.c

2142

bb->cs[bb->len++] = MI_STORE_DATA_IMM | MI_SDI_NUM_QW(chunk);

drivers/gpu/drm/xe/xe_migrate.c

2146

pt_offset += chunk * 8;

drivers/gpu/drm/xe/xe_migrate.c

2147

ptes -= chunk;

drivers/gpu/drm/xe/xe_migrate.c

2149

while (chunk--) {

drivers/gpu/drm/xe/xe_migrate.c

2169

chunk--;

drivers/gpu/drm/xe/xe_migrate.c

568

u64 chunk = max_t(u64, cur->size, m->min_chunk_size);

drivers/gpu/drm/xe/xe_migrate.c

570

size = min_t(u64, size, chunk);

drivers/gpu/drm/xe/xe_migrate.c

649

u32 chunk = min(MAX_PTE_PER_SDI, ptes);

drivers/gpu/drm/xe/xe_migrate.c

651

bb->cs[bb->len++] = MI_STORE_DATA_IMM | MI_SDI_NUM_QW(chunk);

drivers/gpu/drm/xe/xe_migrate.c

656

ofs += chunk * 8;

drivers/gpu/drm/xe/xe_migrate.c

657

ptes -= chunk;

drivers/gpu/drm/xe/xe_migrate.c

659

while (chunk--) {

drivers/gpu/drm/xe/xe_svm.c

591

bool match = false, chunk, last;

drivers/gpu/drm/xe/xe_svm.c

594

chunk = (i - pos) == (XE_MIGRATE_CHUNK_SIZE / PAGE_SIZE);

drivers/gpu/drm/xe/xe_svm.c

626

chunk = (i - pos) == (XE_MIGRATE_CHUNK_SIZE / PAGE_SIZE);

drivers/gpu/drm/xe/xe_svm.c

635

if (!match || chunk || last) {

drivers/i3c/master/mipi-i3c-hci/pio.c

439

unsigned int room, left, chunk, bytes_to_move;

drivers/i3c/master/mipi-i3c-hci/pio.c

450

chunk = min(count, room);

drivers/i3c/master/mipi-i3c-hci/pio.c

451

if (chunk > left) {

drivers/i3c/master/mipi-i3c-hci/pio.c

452

hci_pio_push_to_next_rx(hci, xfer, chunk - left);

drivers/i3c/master/mipi-i3c-hci/pio.c

453

left = chunk;

drivers/i3c/master/mipi-i3c-hci/pio.c

464

memmove(xfer->data + chunk, xfer->data, bytes_to_move);

drivers/i3c/master/mipi-i3c-hci/pio.c

467

chunk -= 1;

drivers/i3c/master/mipi-i3c-hci/pio.c

469

memcpy(xfer->data, from, chunk * 4);

drivers/i3c/master/mipi-i3c-hci/pio.c

470

xfer->data_left -= chunk * 4;

drivers/i3c/master/mipi-i3c-hci/pio.c

471

from += chunk;

drivers/i3c/master/mipi-i3c-hci/pio.c

472

count -= chunk;

drivers/i3c/master/mipi-i3c-hci/pio.c

483

p_byte += chunk * 4;

drivers/i3c/master/mipi-i3c-hci/pio.c

493

p[chunk] = last_word;

drivers/iio/imu/bno055/bno055_ser_trace.h

16

__dynamic_array(u8, chunk, len)

drivers/iio/imu/bno055/bno055_ser_trace.h

20

memcpy(__get_dynamic_array(chunk),

drivers/iio/imu/bno055/bno055_ser_trace.h

24

__entry->len, __entry->len, __get_dynamic_array(chunk)

drivers/infiniband/hw/cxgb4/resource.c

483

unsigned start, chunk, top;

drivers/infiniband/hw/cxgb4/resource.c

490

chunk = rdev->lldi.vr->ocq.size;

drivers/infiniband/hw/cxgb4/resource.c

491

top = start + chunk;

drivers/infiniband/hw/cxgb4/resource.c

494

chunk = min(top - start + 1, chunk);

drivers/infiniband/hw/cxgb4/resource.c

495

if (gen_pool_add(rdev->ocqp_pool, start, chunk, -1)) {

drivers/infiniband/hw/cxgb4/resource.c

497

start, chunk);

drivers/infiniband/hw/cxgb4/resource.c

498

if (chunk <= 1024 << MIN_OCQP_SHIFT) {

drivers/infiniband/hw/cxgb4/resource.c

503

chunk >>= 1;

drivers/infiniband/hw/cxgb4/resource.c

506

start, chunk);

drivers/infiniband/hw/cxgb4/resource.c

507

start += chunk;

drivers/infiniband/hw/irdma/pble.c

103

chunk->type = PBLE_SD_CONTIGOUS;

drivers/infiniband/hw/irdma/pble.c

107

chunk->size = info->pages << HMC_PAGED_BP_SHIFT;

drivers/infiniband/hw/irdma/pble.c

108

chunk->vaddr = sd_entry->u.bp.addr.va + offset;

drivers/infiniband/hw/irdma/pble.c

109

chunk->fpm_addr = pble_rsrc->next_fpm_addr;

drivers/infiniband/hw/irdma/pble.c

112

chunk->size, chunk->size, chunk->vaddr, chunk->fpm_addr);

drivers/infiniband/hw/irdma/pble.c

145

struct irdma_chunk *chunk = info->chunk;

drivers/infiniband/hw/irdma/pble.c

151

if (irdma_pble_get_paged_mem(chunk, info->pages))

drivers/infiniband/hw/irdma/pble.c

160

addr = chunk->vaddr;

drivers/infiniband/hw/irdma/pble.c

162

mem.pa = (u64)chunk->dmainfo.dmaaddrs[i];

drivers/infiniband/hw/irdma/pble.c

176

chunk->fpm_addr = pble_rsrc->next_fpm_addr;

drivers/infiniband/hw/irdma/pble.c

18

struct irdma_chunk *chunk;

drivers/infiniband/hw/irdma/pble.c

180

irdma_pble_free_paged_mem(chunk);

drivers/infiniband/hw/irdma/pble.c

217

struct irdma_chunk *chunk;

drivers/infiniband/hw/irdma/pble.c

22

chunk = (struct irdma_chunk *) pinfo->clist.next;

drivers/infiniband/hw/irdma/pble.c

23

list_del(&chunk->list);

drivers/infiniband/hw/irdma/pble.c

232

chunkmem.size = sizeof(*chunk);

drivers/infiniband/hw/irdma/pble.c

237

chunk = chunkmem.va;

drivers/infiniband/hw/irdma/pble.c

238

chunk->chunkmem = chunkmem;

drivers/infiniband/hw/irdma/pble.c

24

if (chunk->type == PBLE_SD_PAGED)

drivers/infiniband/hw/irdma/pble.c

240

chunk->dev = dev;

drivers/infiniband/hw/irdma/pble.c

241

chunk->fpm_addr = pble_rsrc->next_fpm_addr;

drivers/infiniband/hw/irdma/pble.c

247

info.chunk = chunk;

drivers/infiniband/hw/irdma/pble.c

25

irdma_pble_free_paged_mem(chunk);

drivers/infiniband/hw/irdma/pble.c

26

bitmap_free(chunk->bitmapbuf);

drivers/infiniband/hw/irdma/pble.c

27

kfree(chunk->chunkmem.va);

drivers/infiniband/hw/irdma/pble.c

277

ret_code = irdma_prm_add_pble_mem(&pble_rsrc->pinfo, chunk);

drivers/infiniband/hw/irdma/pble.c

281

pble_rsrc->next_fpm_addr += chunk->size;

drivers/infiniband/hw/irdma/pble.c

284

pble_rsrc->next_fpm_addr, chunk->size, chunk->size);

drivers/infiniband/hw/irdma/pble.c

285

pble_rsrc->unallocated_pble -= (u32)(chunk->size >> 3);

drivers/infiniband/hw/irdma/pble.c

298

list_add(&chunk->list, &pble_rsrc->pinfo.clist);

drivers/infiniband/hw/irdma/pble.c

303

bitmap_free(chunk->bitmapbuf);

drivers/infiniband/hw/irdma/pble.c

304

kfree(chunk->chunkmem.va);

drivers/infiniband/hw/irdma/pble.c

90

struct irdma_chunk *chunk = info->chunk;

drivers/infiniband/hw/irdma/pble.h

129

void irdma_pble_free_paged_mem(struct irdma_chunk *chunk);

drivers/infiniband/hw/irdma/pble.h

130

int irdma_pble_get_paged_mem(struct irdma_chunk *chunk, u32 pg_cnt);

drivers/infiniband/hw/irdma/pble.h

131

void irdma_prm_rem_bitmapmem(struct irdma_hw *hw, struct irdma_chunk *chunk);

drivers/infiniband/hw/irdma/pble.h

62

struct irdma_chunk *chunk;

drivers/infiniband/hw/irdma/utils.c

2232

void irdma_pble_free_paged_mem(struct irdma_chunk *chunk)

drivers/infiniband/hw/irdma/utils.c

2234

if (!chunk->pg_cnt)

drivers/infiniband/hw/irdma/utils.c

2237

irdma_unmap_vm_page_list(chunk->dev->hw, chunk->dmainfo.dmaaddrs,

drivers/infiniband/hw/irdma/utils.c

2238

chunk->pg_cnt);

drivers/infiniband/hw/irdma/utils.c

2241

kvfree(chunk->dmainfo.dmaaddrs);

drivers/infiniband/hw/irdma/utils.c

2242

chunk->dmainfo.dmaaddrs = NULL;

drivers/infiniband/hw/irdma/utils.c

2243

vfree(chunk->vaddr);

drivers/infiniband/hw/irdma/utils.c

2244

chunk->vaddr = NULL;

drivers/infiniband/hw/irdma/utils.c

2245

chunk->type = 0;

drivers/infiniband/hw/irdma/utils.c

2253

int irdma_pble_get_paged_mem(struct irdma_chunk *chunk, u32 pg_cnt)

drivers/infiniband/hw/irdma/utils.c

2258

chunk->dmainfo.dmaaddrs = kvzalloc(pg_cnt << 3, GFP_KERNEL);

drivers/infiniband/hw/irdma/utils.c

2259

if (!chunk->dmainfo.dmaaddrs)

drivers/infiniband/hw/irdma/utils.c

2267

if (irdma_map_vm_page_list(chunk->dev->hw, va, chunk->dmainfo.dmaaddrs,

drivers/infiniband/hw/irdma/utils.c

2272

chunk->vaddr = va;

drivers/infiniband/hw/irdma/utils.c

2273

chunk->size = size;

drivers/infiniband/hw/irdma/utils.c

2274

chunk->pg_cnt = pg_cnt;

drivers/infiniband/hw/irdma/utils.c

2275

chunk->type = PBLE_SD_PAGED;

drivers/infiniband/hw/irdma/utils.c

2279

kvfree(chunk->dmainfo.dmaaddrs);

drivers/infiniband/hw/irdma/utils.c

2280

chunk->dmainfo.dmaaddrs = NULL;

drivers/infiniband/hw/mthca/mthca_memfree.c

101

kfree(chunk);

drivers/infiniband/hw/mthca/mthca_memfree.c

141

struct mthca_icm_chunk *chunk = NULL;

drivers/infiniband/hw/mthca/mthca_memfree.c

158

if (!chunk) {

drivers/infiniband/hw/mthca/mthca_memfree.c

159

chunk = kmalloc_obj(*chunk,

drivers/infiniband/hw/mthca/mthca_memfree.c

161

if (!chunk)

drivers/infiniband/hw/mthca/mthca_memfree.c

164

sg_init_table(chunk->mem, MTHCA_ICM_CHUNK_LEN);

drivers/infiniband/hw/mthca/mthca_memfree.c

165

chunk->npages = 0;

drivers/infiniband/hw/mthca/mthca_memfree.c

166

chunk->nsg = 0;

drivers/infiniband/hw/mthca/mthca_memfree.c

167

list_add_tail(&chunk->list, &icm->chunk_list);

drivers/infiniband/hw/mthca/mthca_memfree.c

175

&chunk->mem[chunk->npages],

drivers/infiniband/hw/mthca/mthca_memfree.c

178

ret = mthca_alloc_icm_pages(&chunk->mem[chunk->npages],

drivers/infiniband/hw/mthca/mthca_memfree.c

182

++chunk->npages;

drivers/infiniband/hw/mthca/mthca_memfree.c

185

++chunk->nsg;

drivers/infiniband/hw/mthca/mthca_memfree.c

186

else if (chunk->npages == MTHCA_ICM_CHUNK_LEN) {

drivers/infiniband/hw/mthca/mthca_memfree.c

187

chunk->nsg =

drivers/infiniband/hw/mthca/mthca_memfree.c

188

dma_map_sg(&dev->pdev->dev, chunk->mem,

drivers/infiniband/hw/mthca/mthca_memfree.c

189

chunk->npages,

drivers/infiniband/hw/mthca/mthca_memfree.c

192

if (chunk->nsg <= 0)

drivers/infiniband/hw/mthca/mthca_memfree.c

196

if (chunk->npages == MTHCA_ICM_CHUNK_LEN)

drivers/infiniband/hw/mthca/mthca_memfree.c

197

chunk = NULL;

drivers/infiniband/hw/mthca/mthca_memfree.c

207

if (!coherent && chunk) {

drivers/infiniband/hw/mthca/mthca_memfree.c

208

chunk->nsg = dma_map_sg(&dev->pdev->dev, chunk->mem,

drivers/infiniband/hw/mthca/mthca_memfree.c

209

chunk->npages, DMA_BIDIRECTIONAL);

drivers/infiniband/hw/mthca/mthca_memfree.c

211

if (chunk->nsg <= 0)

drivers/infiniband/hw/mthca/mthca_memfree.c

281

struct mthca_icm_chunk *chunk;

drivers/infiniband/hw/mthca/mthca_memfree.c

297

list_for_each_entry(chunk, &icm->chunk_list, list) {

drivers/infiniband/hw/mthca/mthca_memfree.c

298

for (i = 0; i < chunk->npages; ++i) {

drivers/infiniband/hw/mthca/mthca_memfree.c

300

if (sg_dma_len(&chunk->mem[i]) > dma_offset)

drivers/infiniband/hw/mthca/mthca_memfree.c

301

*dma_handle = sg_dma_address(&chunk->mem[i]) +

drivers/infiniband/hw/mthca/mthca_memfree.c

303

dma_offset -= sg_dma_len(&chunk->mem[i]);

drivers/infiniband/hw/mthca/mthca_memfree.c

308

if (chunk->mem[i].length > offset) {

drivers/infiniband/hw/mthca/mthca_memfree.c

309

page = sg_page(&chunk->mem[i]);

drivers/infiniband/hw/mthca/mthca_memfree.c

312

offset -= chunk->mem[i].length;

drivers/infiniband/hw/mthca/mthca_memfree.c

64

static void mthca_free_icm_pages(struct mthca_dev *dev, struct mthca_icm_chunk *chunk)

drivers/infiniband/hw/mthca/mthca_memfree.c

68

if (chunk->nsg > 0)

drivers/infiniband/hw/mthca/mthca_memfree.c

69

dma_unmap_sg(&dev->pdev->dev, chunk->mem, chunk->npages,

drivers/infiniband/hw/mthca/mthca_memfree.c

72

for (i = 0; i < chunk->npages; ++i)

drivers/infiniband/hw/mthca/mthca_memfree.c

73

__free_pages(sg_page(&chunk->mem[i]),

drivers/infiniband/hw/mthca/mthca_memfree.c

74

get_order(chunk->mem[i].length));

drivers/infiniband/hw/mthca/mthca_memfree.c

77

static void mthca_free_icm_coherent(struct mthca_dev *dev, struct mthca_icm_chunk *chunk)

drivers/infiniband/hw/mthca/mthca_memfree.c

81

for (i = 0; i < chunk->npages; ++i) {

drivers/infiniband/hw/mthca/mthca_memfree.c

82

dma_free_coherent(&dev->pdev->dev, chunk->mem[i].length,

drivers/infiniband/hw/mthca/mthca_memfree.c

83

lowmem_page_address(sg_page(&chunk->mem[i])),

drivers/infiniband/hw/mthca/mthca_memfree.c

84

sg_dma_address(&chunk->mem[i]));

drivers/infiniband/hw/mthca/mthca_memfree.c

90

struct mthca_icm_chunk *chunk, *tmp;

drivers/infiniband/hw/mthca/mthca_memfree.c

95

list_for_each_entry_safe(chunk, tmp, &icm->chunk_list, list) {

drivers/infiniband/hw/mthca/mthca_memfree.c

97

mthca_free_icm_coherent(dev, chunk);

drivers/infiniband/hw/mthca/mthca_memfree.c

99

mthca_free_icm_pages(dev, chunk);

drivers/infiniband/hw/mthca/mthca_memfree.h

103

iter->chunk = list_empty(&icm->chunk_list) ?

drivers/infiniband/hw/mthca/mthca_memfree.h

111

return !iter->chunk;

drivers/infiniband/hw/mthca/mthca_memfree.h

116

if (++iter->page_idx >= iter->chunk->nsg) {

drivers/infiniband/hw/mthca/mthca_memfree.h

117

if (iter->chunk->list.next == &iter->icm->chunk_list) {

drivers/infiniband/hw/mthca/mthca_memfree.h

118

iter->chunk = NULL;

drivers/infiniband/hw/mthca/mthca_memfree.h

122

iter->chunk = list_entry(iter->chunk->list.next,

drivers/infiniband/hw/mthca/mthca_memfree.h

130

return sg_dma_address(&iter->chunk->mem[iter->page_idx]);

drivers/infiniband/hw/mthca/mthca_memfree.h

135

return sg_dma_len(&iter->chunk->mem[iter->page_idx]);

drivers/infiniband/hw/mthca/mthca_memfree.h

76

struct mthca_icm_chunk *chunk;

drivers/infiniband/hw/mthca/mthca_mr.c

359

int chunk;

drivers/infiniband/hw/mthca/mthca_mr.c

366

chunk = min(size, list_len);

drivers/infiniband/hw/mthca/mthca_mr.c

369

buffer_list, chunk);

drivers/infiniband/hw/mthca/mthca_mr.c

372

buffer_list, chunk);

drivers/infiniband/hw/mthca/mthca_mr.c

374

list_len -= chunk;

drivers/infiniband/hw/mthca/mthca_mr.c

375

start_index += chunk;

drivers/infiniband/hw/mthca/mthca_mr.c

376

buffer_list += chunk;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

110

chunk = usnic_ib_qp_grp_get_chunk(qp_grp, USNIC_VNIC_RES_TYPE_RQ);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

111

if (IS_ERR(chunk)) {

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

115

PTR_ERR(chunk));

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

116

return PTR_ERR(chunk);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

119

WARN_ON(chunk->type != USNIC_VNIC_RES_TYPE_RQ);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

120

resp.rq_cnt = chunk->cnt;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

121

for (i = 0; i < chunk->cnt; i++)

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

122

resp.rq_idx[i] = chunk->res[i]->vnic_idx;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

124

chunk = usnic_ib_qp_grp_get_chunk(qp_grp, USNIC_VNIC_RES_TYPE_WQ);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

125

if (IS_ERR(chunk)) {

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

129

PTR_ERR(chunk));

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

130

return PTR_ERR(chunk);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

133

WARN_ON(chunk->type != USNIC_VNIC_RES_TYPE_WQ);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

134

resp.wq_cnt = chunk->cnt;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

135

for (i = 0; i < chunk->cnt; i++)

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

136

resp.wq_idx[i] = chunk->res[i]->vnic_idx;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

138

chunk = usnic_ib_qp_grp_get_chunk(qp_grp, USNIC_VNIC_RES_TYPE_CQ);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

139

if (IS_ERR(chunk)) {

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

143

PTR_ERR(chunk));

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

144

return PTR_ERR(chunk);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

147

WARN_ON(chunk->type != USNIC_VNIC_RES_TYPE_CQ);

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

148

resp.cq_cnt = chunk->cnt;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

149

for (i = 0; i < chunk->cnt; i++)

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

150

resp.cq_idx[i] = chunk->res[i]->vnic_idx;

drivers/infiniband/hw/usnic/usnic_ib_verbs.c

88

struct usnic_vnic_res_chunk *chunk;

drivers/infiniband/hw/usnic/usnic_uiom.c

152

chunk = kmalloc_flex(*chunk, page_list,

drivers/infiniband/hw/usnic/usnic_uiom.c

154

if (!chunk) {

drivers/infiniband/hw/usnic/usnic_uiom.c

159

chunk->nents = min_t(int, ret, USNIC_UIOM_PAGE_CHUNK);

drivers/infiniband/hw/usnic/usnic_uiom.c

160

sg_init_table(chunk->page_list, chunk->nents);

drivers/infiniband/hw/usnic/usnic_uiom.c

161

for_each_sg(chunk->page_list, sg, chunk->nents, i) {

drivers/infiniband/hw/usnic/usnic_uiom.c

168

cur_base += chunk->nents * PAGE_SIZE;

drivers/infiniband/hw/usnic/usnic_uiom.c

169

ret -= chunk->nents;

drivers/infiniband/hw/usnic/usnic_uiom.c

170

off += chunk->nents;

drivers/infiniband/hw/usnic/usnic_uiom.c

171

list_add_tail(&chunk->list, chunk_list);

drivers/infiniband/hw/usnic/usnic_uiom.c

243

struct usnic_uiom_chunk *chunk;

drivers/infiniband/hw/usnic/usnic_uiom.c

254

chunk = list_first_entry(&uiomr->chunk_list, struct usnic_uiom_chunk,

drivers/infiniband/hw/usnic/usnic_uiom.c

258

for (i = 0; i < chunk->nents; i++, va += PAGE_SIZE) {

drivers/infiniband/hw/usnic/usnic_uiom.c

259

pa = sg_phys(&chunk->page_list[i]);

drivers/infiniband/hw/usnic/usnic_uiom.c

309

if (i == chunk->nents) {

drivers/infiniband/hw/usnic/usnic_uiom.c

314

chunk = list_first_entry(&chunk->list,

drivers/infiniband/hw/usnic/usnic_uiom.c

67

struct usnic_uiom_chunk *chunk, *tmp;

drivers/infiniband/hw/usnic/usnic_uiom.c

73

list_for_each_entry_safe(chunk, tmp, chunk_list, list) {

drivers/infiniband/hw/usnic/usnic_uiom.c

74

for_each_sg(chunk->page_list, sg, chunk->nents, i) {

drivers/infiniband/hw/usnic/usnic_uiom.c

80

kfree(chunk);

drivers/infiniband/hw/usnic/usnic_uiom.c

91

struct usnic_uiom_chunk *chunk;

drivers/infiniband/hw/usnic/usnic_vnic.c

118

chunk = &vnic->chunks[i];

drivers/infiniband/hw/usnic/usnic_vnic.c

119

for (j = 0; j < chunk->cnt; j++) {

drivers/infiniband/hw/usnic/usnic_vnic.c

120

res = chunk->res[j];

drivers/infiniband/hw/usnic/usnic_vnic.c

273

void usnic_vnic_put_resources(struct usnic_vnic_res_chunk *chunk)

drivers/infiniband/hw/usnic/usnic_vnic.c

278

struct usnic_vnic *vnic = chunk->vnic;

drivers/infiniband/hw/usnic/usnic_vnic.c

280

if (chunk->cnt > 0) {

drivers/infiniband/hw/usnic/usnic_vnic.c

282

while ((i = --chunk->cnt) >= 0) {

drivers/infiniband/hw/usnic/usnic_vnic.c

283

res = chunk->res[i];

drivers/infiniband/hw/usnic/usnic_vnic.c

284

chunk->res[i] = NULL;

drivers/infiniband/hw/usnic/usnic_vnic.c

291

kfree(chunk->res);

drivers/infiniband/hw/usnic/usnic_vnic.c

292

kfree(chunk);

drivers/infiniband/hw/usnic/usnic_vnic.c

302

struct usnic_vnic_res_chunk *chunk)

drivers/infiniband/hw/usnic/usnic_vnic.c

313

chunk->cnt = chunk->free_cnt = cnt;

drivers/infiniband/hw/usnic/usnic_vnic.c

314

chunk->res = kzalloc_objs(*(chunk->res), cnt);

drivers/infiniband/hw/usnic/usnic_vnic.c

315

if (!chunk->res)

drivers/infiniband/hw/usnic/usnic_vnic.c

329

chunk->res[i] = res;

drivers/infiniband/hw/usnic/usnic_vnic.c

332

chunk->vnic = vnic;

drivers/infiniband/hw/usnic/usnic_vnic.c

336

kfree(chunk->res[i]);

drivers/infiniband/hw/usnic/usnic_vnic.c

337

kfree(chunk->res);

drivers/infiniband/hw/usnic/usnic_vnic.c

341

static void usnic_vnic_free_res_chunk(struct usnic_vnic_res_chunk *chunk)

drivers/infiniband/hw/usnic/usnic_vnic.c

344

for (i = 0; i < chunk->cnt; i++)

drivers/infiniband/hw/usnic/usnic_vnic.c

345

kfree(chunk->res[i]);

drivers/infiniband/hw/usnic/usnic_vnic.c

346

kfree(chunk->res);

drivers/infiniband/hw/usnic/usnic_vnic.c

95

struct usnic_vnic_res_chunk *chunk;

drivers/infiniband/hw/usnic/usnic_vnic.h

110

void usnic_vnic_put_resources(struct usnic_vnic_res_chunk *chunk);

drivers/input/misc/ims-pcu.c

539

u8 command, int chunk, int len)

drivers/input/misc/ims-pcu.c

551

command, chunk, error);

drivers/input/misc/ims-pcu.c

562

int chunk = 0;

drivers/input/misc/ims-pcu.c

590

++chunk, count);

drivers/input/misc/ims-pcu.c

608

error = ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);

drivers/input/misc/ims-pcu.c

621

return ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);

drivers/input/touchscreen/wdt87xx_i2c.c

686

static int wdt87xx_write_firmware(struct i2c_client *client, const void *chunk)

drivers/input/touchscreen/wdt87xx_i2c.c

688

u32 start_addr = get_unaligned_le32(chunk + FW_CHUNK_TGT_START_OFFSET);

drivers/input/touchscreen/wdt87xx_i2c.c

689

u32 size = get_unaligned_le32(chunk + FW_CHUNK_PAYLOAD_LEN_OFFSET);

drivers/input/touchscreen/wdt87xx_i2c.c

690

const void *data = chunk + FW_CHUNK_PAYLOAD_OFFSET;

drivers/input/touchscreen/wdt87xx_i2c.c

788

const void *chunk;

drivers/input/touchscreen/wdt87xx_i2c.c

791

chunk = wdt87xx_get_fw_chunk(fw, ck_id);

drivers/input/touchscreen/wdt87xx_i2c.c

792

if (!chunk) {

drivers/input/touchscreen/wdt87xx_i2c.c

798

error = wdt87xx_validate_fw_chunk(chunk, ck_id);

drivers/input/touchscreen/wdt87xx_i2c.c

805

error = wdt87xx_write_firmware(client, chunk);

drivers/macintosh/smu.c

903

unsigned int chunk;

drivers/macintosh/smu.c

911

chunk = 0xe;

drivers/macintosh/smu.c

914

unsigned int clen = min(len, chunk);

drivers/macintosh/smu.c

919

cmd.reply_len = chunk;

drivers/md/dm-exception-store.h

143

static inline chunk_t dm_chunk_number(chunk_t chunk)

drivers/md/dm-exception-store.h

145

return chunk & (chunk_t)((1ULL << DM_CHUNK_NUMBER_BITS) - 1ULL);

drivers/md/dm-pcache/cache_dev.c

22

long i = 0, chunk;

drivers/md/dm-pcache/cache_dev.c

31

chunk = dax_direct_access(dax_dev, i, total_pages - i,

drivers/md/dm-pcache/cache_dev.c

33

if (chunk <= 0) {

drivers/md/dm-pcache/cache_dev.c

34

ret = chunk ? chunk : -EINVAL;

drivers/md/dm-pcache/cache_dev.c

43

while (chunk-- && i < total_pages) {

drivers/md/dm-snap-persistent.c

232

static int chunk_io(struct pstore *ps, void *area, chunk_t chunk, blk_opf_t opf,

drivers/md/dm-snap-persistent.c

237

.sector = ps->store->chunk_size * chunk,

drivers/md/dm-snap-persistent.c

290

chunk_t chunk = area_location(ps, ps->current_area);

drivers/md/dm-snap-persistent.c

292

return chunk_io(ps, ps->area, chunk, opf, 0);

drivers/md/dm-snap-persistent.c

516

chunk_t chunk;

drivers/md/dm-snap-persistent.c

534

chunk = area_location(ps, ps->current_area);

drivers/md/dm-snap-persistent.c

536

area = dm_bufio_read(client, chunk, &bp);

drivers/md/dm-snap-persistent.c

550

dm_bufio_forget(client, chunk);

drivers/md/dm-snap.c

1834

__lookup_pending_exception(struct dm_snapshot *s, chunk_t chunk)

drivers/md/dm-snap.c

1836

struct dm_exception *e = dm_lookup_exception(&s->pending, chunk);

drivers/md/dm-snap.c

1852

struct dm_snap_pending_exception *pe, chunk_t chunk)

drivers/md/dm-snap.c

1854

pe->e.old_chunk = chunk;

drivers/md/dm-snap.c

1885

struct dm_snap_pending_exception *pe, chunk_t chunk)

drivers/md/dm-snap.c

1889

pe2 = __lookup_pending_exception(s, chunk);

drivers/md/dm-snap.c

1895

return __insert_pending_exception(s, pe, chunk);

drivers/md/dm-snap.c

1899

struct bio *bio, chunk_t chunk)

drivers/md/dm-snap.c

190

chunk_t chunk)

drivers/md/dm-snap.c

1904

(chunk - e->old_chunk)) +

drivers/md/dm-snap.c

1919

struct bio *bio, chunk_t chunk)

drivers/md/dm-snap.c

192

return chunk << store->chunk_shift;

drivers/md/dm-snap.c

1944

chunk_t chunk;

drivers/md/dm-snap.c

1955

chunk = sector_to_chunk(s->store, bio->bi_iter.bi_sector);

drivers/md/dm-snap.c

1956

dm_exception_table_lock_init(s, chunk, &lock);

drivers/md/dm-snap.c

1986

track_chunk(s, bio, chunk);

drivers/md/dm-snap.c

1993

e = dm_lookup_exception(&s->complete, chunk);

drivers/md/dm-snap.c

1995

remap_exception(s, e, bio, chunk);

drivers/md/dm-snap.c

2000

zero_exception(s, e, bio, chunk);

drivers/md/dm-snap.c

2023

pe = __lookup_pending_exception(s, chunk);

drivers/md/dm-snap.c

2029

e = dm_lookup_exception(&s->complete, chunk);

drivers/md/dm-snap.c

2032

remap_exception(s, e, bio, chunk);

drivers/md/dm-snap.c

2036

pe = __find_pending_exception(s, pe, chunk);

drivers/md/dm-snap.c

2057

remap_exception(s, &pe->e, bio, chunk);

drivers/md/dm-snap.c

2085

track_chunk(s, bio, chunk);

drivers/md/dm-snap.c

2112

chunk_t chunk;

drivers/md/dm-snap.c

2130

chunk = sector_to_chunk(s->store, bio->bi_iter.bi_sector);

drivers/md/dm-snap.c

2139

e = dm_lookup_exception(&s->complete, chunk);

drivers/md/dm-snap.c

2143

chunk >= s->first_merging_chunk &&

drivers/md/dm-snap.c

2144

chunk < (s->first_merging_chunk +

drivers/md/dm-snap.c

2152

remap_exception(s, e, bio, chunk);

drivers/md/dm-snap.c

2155

track_chunk(s, bio, chunk);

drivers/md/dm-snap.c

2435

chunk_t chunk;

drivers/md/dm-snap.c

2454

chunk = sector_to_chunk(snap->store, sector);

drivers/md/dm-snap.c

2455

dm_exception_table_lock_init(snap, chunk, &lock);

drivers/md/dm-snap.c

2464

pe = __lookup_pending_exception(snap, chunk);

drivers/md/dm-snap.c

247

chunk_t chunk;

drivers/md/dm-snap.c

2471

e = dm_lookup_exception(&snap->complete, chunk);

drivers/md/dm-snap.c

2479

pe2 = __lookup_pending_exception(snap, chunk);

drivers/md/dm-snap.c

2482

e = dm_lookup_exception(&snap->complete, chunk);

drivers/md/dm-snap.c

2488

pe = __insert_pending_exception(snap, pe, chunk);

drivers/md/dm-snap.c

264

static void track_chunk(struct dm_snapshot *s, struct bio *bio, chunk_t chunk)

drivers/md/dm-snap.c

268

c->chunk = chunk;

drivers/md/dm-snap.c

272

&s->tracked_chunk_hash[DM_TRACKED_CHUNK_HASH(chunk)]);

drivers/md/dm-snap.c

286

static int __chunk_is_tracked(struct dm_snapshot *s, chunk_t chunk)

drivers/md/dm-snap.c

294

&s->tracked_chunk_hash[DM_TRACKED_CHUNK_HASH(chunk)], node) {

drivers/md/dm-snap.c

295

if (c->chunk == chunk) {

drivers/md/dm-snap.c

310

static void __check_for_conflicting_io(struct dm_snapshot *s, chunk_t chunk)

drivers/md/dm-snap.c

312

while (__chunk_is_tracked(s, chunk))

drivers/md/dm-snap.c

629

static uint32_t exception_hash(struct dm_exception_table *et, chunk_t chunk);

drivers/md/dm-snap.c

637

static void dm_exception_table_lock_init(struct dm_snapshot *s, chunk_t chunk,

drivers/md/dm-snap.c

643

lock->complete_slot = &complete->table[exception_hash(complete, chunk)].lock;

drivers/md/dm-snap.c

644

lock->pending_slot = &pending->table[exception_hash(pending, chunk)].lock;

drivers/md/dm-snap.c

700

static uint32_t exception_hash(struct dm_exception_table *et, chunk_t chunk)

drivers/md/dm-snap.c

702

return (chunk >> et->hash_shift) & et->hash_mask;

drivers/md/dm-snap.c

715

chunk_t chunk)

drivers/md/dm-snap.c

720

slot = &et->table[exception_hash(et, chunk)].head;

drivers/md/dm-snap.c

722

if (chunk >= e->old_chunk &&

drivers/md/dm-snap.c

723

chunk <= e->old_chunk + dm_consecutive_chunk_count(e))

drivers/md/dm-stripe.c

205

sector_t chunk = dm_target_offset(sc->ti, sector);

drivers/md/dm-stripe.c

209

chunk_offset = sector_div(chunk, sc->chunk_size);

drivers/md/dm-stripe.c

211

chunk_offset = chunk & (sc->chunk_size - 1);

drivers/md/dm-stripe.c

212

chunk >>= sc->chunk_size_shift;

drivers/md/dm-stripe.c

216

*stripe = sector_div(chunk, sc->stripes);

drivers/md/dm-stripe.c

218

*stripe = chunk & (sc->stripes - 1);

drivers/md/dm-stripe.c

219

chunk >>= sc->stripes_shift;

drivers/md/dm-stripe.c

223

chunk *= sc->chunk_size;

drivers/md/dm-stripe.c

225

chunk <<= sc->chunk_size_shift;

drivers/md/dm-stripe.c

227

*result = chunk + chunk_offset;

drivers/md/dm-zoned-metadata.c

1684

unsigned int i = 0, e = 0, chunk = 0;

drivers/md/dm-zoned-metadata.c

1694

while (chunk < zmd->nr_chunks) {

drivers/md/dm-zoned-metadata.c

1713

chunk, dzone_id);

drivers/md/dm-zoned-metadata.c

1720

chunk, dzone_id);

drivers/md/dm-zoned-metadata.c

1724

dzone->chunk = chunk;

drivers/md/dm-zoned-metadata.c

1741

chunk, bzone_id);

drivers/md/dm-zoned-metadata.c

1748

chunk, bzone_id);

drivers/md/dm-zoned-metadata.c

1753

chunk, bzone_id);

drivers/md/dm-zoned-metadata.c

1759

bzone->chunk = chunk;

drivers/md/dm-zoned-metadata.c

1768

chunk++;

drivers/md/dm-zoned-metadata.c

1802

dzone->chunk = DMZ_MAP_UNMAPPED;

drivers/md/dm-zoned-metadata.c

1828

static void dmz_set_chunk_mapping(struct dmz_metadata *zmd, unsigned int chunk,

drivers/md/dm-zoned-metadata.c

1831

struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];

drivers/md/dm-zoned-metadata.c

1833

int map_idx = chunk & DMZ_MAP_ENTRIES_MASK;

drivers/md/dm-zoned-metadata.c

2042

unsigned int chunk, enum req_op op)

drivers/md/dm-zoned-metadata.c

2044

struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];

drivers/md/dm-zoned-metadata.c

2046

int dmap_idx = chunk & DMZ_MAP_ENTRIES_MASK;

drivers/md/dm-zoned-metadata.c

2075

dmz_map_zone(zmd, dzone, chunk);

drivers/md/dm-zoned-metadata.c

2084

if (dzone->chunk != chunk) {

drivers/md/dm-zoned-metadata.c

2182

dmz_set_chunk_mapping(zmd, dzone->chunk, dzone->id, bzone->id);

drivers/md/dm-zoned-metadata.c

2185

bzone->chunk = dzone->chunk;

drivers/md/dm-zoned-metadata.c

2307

unsigned int chunk)

drivers/md/dm-zoned-metadata.c

2310

dmz_set_chunk_mapping(zmd, chunk, dzone->id,

drivers/md/dm-zoned-metadata.c

2312

dzone->chunk = chunk;

drivers/md/dm-zoned-metadata.c

2327

unsigned int chunk = zone->chunk;

drivers/md/dm-zoned-metadata.c

2330

if (chunk == DMZ_MAP_UNMAPPED) {

drivers/md/dm-zoned-metadata.c

2356

dmz_set_chunk_mapping(zmd, chunk, dzone_id, DMZ_MAP_UNMAPPED);

drivers/md/dm-zoned-metadata.c

2358

zone->chunk = DMZ_MAP_UNMAPPED;

drivers/md/dm-zoned-metadata.c

319

zone->chunk = DMZ_MAP_UNMAPPED;

drivers/md/dm-zoned-reclaim.c

205

dzone->chunk, bzone->id, dmz_weight(bzone),

drivers/md/dm-zoned-reclaim.c

237

unsigned int chunk = dzone->chunk;

drivers/md/dm-zoned-reclaim.c

244

chunk, dzone->id, dmz_weight(dzone),

drivers/md/dm-zoned-reclaim.c

267

dmz_map_zone(zmd, bzone, chunk);

drivers/md/dm-zoned-reclaim.c

282

unsigned int chunk = dzone->chunk;

drivers/md/dm-zoned-reclaim.c

302

dmz_metadata_label(zmd), zrc->dev_idx, chunk,

drivers/md/dm-zoned-reclaim.c

328

dmz_map_zone(zmd, szone, chunk);

drivers/md/dm-zoned-target.c

33

unsigned int chunk;

drivers/md/dm-zoned-target.c

470

radix_tree_delete(&cw->target->chunk_rxtree, cw->chunk);

drivers/md/dm-zoned-target.c

536

unsigned int chunk = dmz_bio_chunk(dmz->metadata, bio);

drivers/md/dm-zoned-target.c

543

cw = radix_tree_lookup(&dmz->chunk_rxtree, chunk);

drivers/md/dm-zoned-target.c

557

cw->chunk = chunk;

drivers/md/dm-zoned-target.c

560

ret = radix_tree_insert(&dmz->chunk_rxtree, chunk, cw);

drivers/md/dm-zoned.h

118

unsigned int chunk;

drivers/md/dm-zoned.h

222

unsigned int chunk);

drivers/md/dm-zoned.h

249

unsigned int chunk, enum req_op op);

drivers/md/md-autodetect.c

196

ainfo.chunk_size = args->chunk;

drivers/md/md-autodetect.c

34

int chunk;

drivers/md/md-autodetect.c

98

md_setup_args[ent].chunk = 1 << (factor+12);

drivers/md/md-bitmap.c

1000

return chunk & (PAGE_BITS - 1);

drivers/md/md-bitmap.c

1008

unsigned long chunk)

drivers/md/md-bitmap.c

1010

if (file_page_index(store, chunk) >= store->file_pages)

drivers/md/md-bitmap.c

1012

return store->filemap[file_page_index(store, chunk)];

drivers/md/md-bitmap.c

1155

unsigned long chunk = block >> bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1157

unsigned long index = file_page_index(store, chunk);

drivers/md/md-bitmap.c

1164

page = filemap_get_page(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1167

bit = file_page_offset(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1186

unsigned long chunk = block >> bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1188

unsigned long index = file_page_index(store, chunk);

drivers/md/md-bitmap.c

1195

page = filemap_get_page(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1198

bit = file_page_offset(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1216

unsigned long chunk = block >> bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

1219

page = filemap_get_page(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1222

bit = file_page_offset(&bitmap->storage, chunk);

drivers/md/md-bitmap.c

1466

sector_t chunk = offset >> bitmap->chunkshift;

drivers/md/md-bitmap.c

1467

unsigned long page = chunk >> PAGE_COUNTER_SHIFT;

drivers/md/md-bitmap.c

1474

sector_t chunk = offset >> bitmap->chunkshift;

drivers/md/md-bitmap.c

1475

unsigned long page = chunk >> PAGE_COUNTER_SHIFT;

drivers/md/md-bitmap.c

1639

sector_t chunk = offset >> bitmap->chunkshift;

drivers/md/md-bitmap.c

1640

unsigned long page = chunk >> PAGE_COUNTER_SHIFT;

drivers/md/md-bitmap.c

1641

unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;

drivers/md/md-bitmap.c

1963

unsigned long chunk;

drivers/md/md-bitmap.c

1969

for (chunk = s; chunk <= e; chunk++) {

drivers/md/md-bitmap.c

1970

sector_t sec = (sector_t)chunk << bitmap->counts.chunkshift;

drivers/md/md-bitmap.c

987

unsigned long chunk)

drivers/md/md-bitmap.c

990

chunk += sizeof(bitmap_super_t) << 3;

drivers/md/md-bitmap.c

991

return chunk >> PAGE_BIT_SHIFT;

drivers/md/md-bitmap.c

996

unsigned long chunk)

drivers/md/md-bitmap.c

999

chunk += sizeof(bitmap_super_t) << 3;

drivers/md/md.c

4880

unsigned long chunk, end_chunk;

drivers/md/md.c

4893

chunk = end_chunk = simple_strtoul(buf, &end, 0);

drivers/md/md.c

4907

mddev->bitmap_ops->dirty_bits(mddev, chunk, end_chunk);

drivers/md/md.c

5593

int chunk;

drivers/md/md.c

5607

chunk = mddev->chunk_sectors;

drivers/md/md.c

5608

if (chunk) {

drivers/md/md.c

5612

if (sector_div(temp, chunk))

drivers/md/raid0.c

329

sector_t chunk;

drivers/md/raid0.c

340

chunk = *sector_offset;

drivers/md/raid0.c

342

sector_div(chunk, zone->nb_dev << chunksect_bits);

drivers/md/raid0.c

345

chunk = *sector_offset;

drivers/md/raid0.c

346

sector_div(chunk, chunk_sects * zone->nb_dev);

drivers/md/raid0.c

353

*sector_offset = (chunk * chunk_sects) + sect_in_chunk;

drivers/md/raid10.c

1625

sector_t chunk;

drivers/md/raid10.c

1726

chunk = bio_start >> geo->chunk_shift;

drivers/md/raid10.c

1727

chunk *= geo->near_copies;

drivers/md/raid10.c

1728

first_stripe_index = chunk;

drivers/md/raid10.c

1735

chunk = bio_end >> geo->chunk_shift;

drivers/md/raid10.c

1736

chunk *= geo->near_copies;

drivers/md/raid10.c

1737

last_stripe_index = chunk;

drivers/md/raid10.c

3787

int layout, chunk, disks;

drivers/md/raid10.c

3791

chunk = mddev->chunk_sectors;

drivers/md/raid10.c

3796

chunk = mddev->new_chunk_sectors;

drivers/md/raid10.c

3803

chunk = mddev->new_chunk_sectors;

drivers/md/raid10.c

3809

if (chunk < (PAGE_SIZE >> 9) ||

drivers/md/raid10.c

3810

!is_power_of_2(chunk))

drivers/md/raid10.c

3837

geo->chunk_mask = chunk - 1;

drivers/md/raid10.c

3838

geo->chunk_shift = ffz(~chunk);

drivers/md/raid10.c

585

sector_t chunk;

drivers/md/raid10.c

598

chunk = r10bio->sector >> geo->chunk_shift;

drivers/md/raid10.c

601

chunk *= geo->near_copies;

drivers/md/raid10.c

602

stripe = chunk;

drivers/md/raid10.c

661

sector_t offset, chunk, vchunk;

drivers/md/raid10.c

684

chunk = sector >> geo->chunk_shift;

drivers/md/raid10.c

685

fc = sector_div(chunk, geo->far_copies);

drivers/md/raid10.c

697

chunk = sector >> geo->chunk_shift;

drivers/md/raid10.c

699

vchunk = chunk * geo->raid_disks + dev;

drivers/media/dvb-frontends/drxk_hard.c

408

int chunk = blk_size > state->m_chunk_size ?

drivers/media/dvb-frontends/drxk_hard.c

410

u8 *adr_buf = &state->chunk[0];

drivers/media/dvb-frontends/drxk_hard.c

420

if (chunk == state->m_chunk_size)

drivers/media/dvb-frontends/drxk_hard.c

421

chunk -= 2;

drivers/media/dvb-frontends/drxk_hard.c

428

memcpy(&state->chunk[adr_length], p_block, chunk);

drivers/media/dvb-frontends/drxk_hard.c

431

dprintk(2, "%*ph\n", chunk, p_block);

drivers/media/dvb-frontends/drxk_hard.c

433

&state->chunk[0], chunk + adr_length);

drivers/media/dvb-frontends/drxk_hard.c

439

p_block += chunk;

drivers/media/dvb-frontends/drxk_hard.c

440

address += (chunk >> 1);

drivers/media/dvb-frontends/drxk_hard.c

441

blk_size -= chunk;

drivers/media/dvb-frontends/drxk_hard.h

225

u8 chunk[256];

drivers/media/rc/serial_ir.c

182

unsigned char chunk, shifted;

drivers/media/rc/serial_ir.c

187

chunk = 3;

drivers/media/rc/serial_ir.c

189

chunk = 1;

drivers/media/rc/serial_ir.c

191

shifted = chunk << (i * 3);

drivers/media/usb/go7007/go7007-fw.c

370

int size = 0, i, off = 0, chunk;

drivers/media/usb/go7007/go7007-fw.c

380

chunk = mjpeg_frame_header(go, buf + size, 1);

drivers/media/usb/go7007/go7007-fw.c

381

memmove(buf + size, buf + size + 80, chunk - 80);

drivers/media/usb/go7007/go7007-fw.c

382

size += chunk - 80;

drivers/media/usb/go7007/go7007-fw.c

384

for (i = 0; i < size; i += chunk * 2) {

drivers/media/usb/go7007/go7007-fw.c

392

chunk = 28;

drivers/media/usb/go7007/go7007-fw.c

393

if (mem + chunk > 0x4000)

drivers/media/usb/go7007/go7007-fw.c

394

chunk = 0x4000 - mem;

drivers/media/usb/go7007/go7007-fw.c

395

if (i + 2 * chunk > size)

drivers/media/usb/go7007/go7007-fw.c

396

chunk = (size - i) / 2;

drivers/media/usb/go7007/go7007-fw.c

398

if (chunk < 28) {

drivers/media/usb/go7007/go7007-fw.c

399

code[off] = __cpu_to_le16(0x4000 | chunk);

drivers/media/usb/go7007/go7007-fw.c

408

memcpy(&code[off + 2], buf + i, chunk * 2);

drivers/media/usb/go7007/go7007-fw.c

637

int i, off = 0, chunk;

drivers/media/usb/go7007/go7007-fw.c

673

for (i = 0; i < 5120; i += chunk * 2) {

drivers/media/usb/go7007/go7007-fw.c

681

chunk = 28;

drivers/media/usb/go7007/go7007-fw.c

682

if (mem + chunk > 0x4000)

drivers/media/usb/go7007/go7007-fw.c

683

chunk = 0x4000 - mem;

drivers/media/usb/go7007/go7007-fw.c

684

if (i + 2 * chunk > 5120)

drivers/media/usb/go7007/go7007-fw.c

685

chunk = (5120 - i) / 2;

drivers/media/usb/go7007/go7007-fw.c

687

if (chunk < 28) {

drivers/media/usb/go7007/go7007-fw.c

688

code[off] = __cpu_to_le16(0x4000 | chunk);

drivers/media/usb/go7007/go7007-fw.c

690

if (mem + chunk == 0x4000) {

drivers/media/usb/go7007/go7007-fw.c

700

memcpy(&code[off + 2], buf + i, chunk * 2);

drivers/media/usb/go7007/go7007-fw.c

823

int i, off = 0, chunk;

drivers/media/usb/go7007/go7007-fw.c

841

for (i = 0; i < 5120; i += chunk * 2) {

drivers/media/usb/go7007/go7007-fw.c

849

chunk = 28;

drivers/media/usb/go7007/go7007-fw.c

850

if (mem + chunk > 0x4000)

drivers/media/usb/go7007/go7007-fw.c

851

chunk = 0x4000 - mem;

drivers/media/usb/go7007/go7007-fw.c

852

if (i + 2 * chunk > 5120)

drivers/media/usb/go7007/go7007-fw.c

853

chunk = (5120 - i) / 2;

drivers/media/usb/go7007/go7007-fw.c

855

if (chunk < 28) {

drivers/media/usb/go7007/go7007-fw.c

856

code[off] = __cpu_to_le16(0x4000 | chunk);

drivers/media/usb/go7007/go7007-fw.c

858

if (mem + chunk == 0x4000) {

drivers/media/usb/go7007/go7007-fw.c

868

memcpy(&code[off + 2], buf + i, chunk * 2);

drivers/media/usb/go7007/go7007-fw.c

884

for (i = 0; i < 5120; i += chunk * 2) {

drivers/media/usb/go7007/go7007-fw.c

892

chunk = 28;

drivers/media/usb/go7007/go7007-fw.c

893

if (mem + chunk > 0x4000)

drivers/media/usb/go7007/go7007-fw.c

894

chunk = 0x4000 - mem;

drivers/media/usb/go7007/go7007-fw.c

895

if (i + 2 * chunk > 5120)

drivers/media/usb/go7007/go7007-fw.c

896

chunk = (5120 - i) / 2;

drivers/media/usb/go7007/go7007-fw.c

898

if (chunk < 28) {

drivers/media/usb/go7007/go7007-fw.c

899

code[off] = __cpu_to_le16(0x4000 | chunk);

drivers/media/usb/go7007/go7007-fw.c

901

if (mem + chunk == 0x4000) {

drivers/media/usb/go7007/go7007-fw.c

911

memcpy(&code[off + 2], buf + i, chunk * 2);

drivers/media/usb/usbtv/usbtv-video.c

398

static void usbtv_image_chunk(struct usbtv *usbtv, __be32 *chunk)

drivers/media/usb/usbtv/usbtv-video.c

406

if (!USBTV_MAGIC_OK(chunk))

drivers/media/usb/usbtv/usbtv-video.c

408

frame_id = USBTV_FRAME_ID(chunk);

drivers/media/usb/usbtv/usbtv-video.c

409

odd = USBTV_ODD(chunk);

drivers/media/usb/usbtv/usbtv-video.c

410

chunk_no = USBTV_CHUNK_NO(chunk);

drivers/media/usb/usbtv/usbtv-video.c

435

usbtv_chunk_to_vbuf(frame, &chunk[1], chunk_no, odd);

drivers/media/usb/usbtv/usbtv.h

65

#define USBTV_MAGIC_OK(chunk) ((be32_to_cpu(chunk[0]) & 0xff000000) \

drivers/media/usb/usbtv/usbtv.h

67

#define USBTV_FRAME_ID(chunk) ((be32_to_cpu(chunk[0]) & 0x00ff0000) >> 16)

drivers/media/usb/usbtv/usbtv.h

68

#define USBTV_ODD(chunk) ((be32_to_cpu(chunk[0]) & 0x0000f000) >> 15)

drivers/media/usb/usbtv/usbtv.h

69

#define USBTV_CHUNK_NO(chunk) (be32_to_cpu(chunk[0]) & 0x00000fff)

drivers/memstick/core/mspro_block.c

633

bool chunk;

drivers/memstick/core/mspro_block.c

635

chunk = blk_update_request(msb->block_req,

drivers/memstick/core/mspro_block.c

638

if (chunk)

drivers/memstick/core/mspro_block.c

666

bool chunk;

drivers/memstick/core/mspro_block.c

699

chunk = blk_update_request(msb->block_req,

drivers/memstick/core/mspro_block.c

701

if (chunk) {

drivers/misc/pci_endpoint_test.c

520

size_t off, chunk;

drivers/misc/pci_endpoint_test.c

603

for (off = 0; off < sub_size; off += chunk) {

drivers/misc/pci_endpoint_test.c

606

chunk = min_t(size_t, buf_size, sub_size - off);

drivers/misc/pci_endpoint_test.c

608

chunk);

drivers/misc/pci_endpoint_test.c

609

bad = memchr_inv(read_buf, pattern, chunk);

drivers/mmc/host/sdhci.c

538

size_t blksize, len, chunk;

drivers/mmc/host/sdhci.c

545

chunk = 0;

drivers/mmc/host/sdhci.c

558

if (chunk == 0) {

drivers/mmc/host/sdhci.c

560

chunk = 4;

drivers/mmc/host/sdhci.c

567

chunk--;

drivers/mmc/host/sdhci.c

577

size_t blksize, len, chunk;

drivers/mmc/host/sdhci.c

584

chunk = 0;

drivers/mmc/host/sdhci.c

598

scratch |= (u32)*buf << (chunk * 8);

drivers/mmc/host/sdhci.c

601

chunk++;

drivers/mmc/host/sdhci.c

604

if ((chunk == 4) || ((len == 0) && (blksize == 0))) {

drivers/mmc/host/sdhci.c

606

chunk = 0;

drivers/mtd/nand/raw/marvell_nand.c

1271

int chunk;

drivers/mtd/nand/raw/marvell_nand.c

1280

for (chunk = 0; chunk < lt->nchunks; chunk++) {

drivers/mtd/nand/raw/marvell_nand.c

1282

if (chunk >= lt->full_chunk_cnt) {

drivers/mtd/nand/raw/marvell_nand.c

1289

nand_change_read_column_op(chip, chunk * chunk_size,

drivers/mtd/nand/raw/marvell_nand.c

1290

buf + (lt->data_bytes * chunk),

drivers/mtd/nand/raw/marvell_nand.c

1294

nand_read_data_op(chip, oob + (lt->spare_bytes * chunk),

drivers/mtd/nand/raw/marvell_nand.c

1299

(ALIGN(lt->ecc_bytes, 32) * chunk),

drivers/mtd/nand/raw/marvell_nand.c

1306

static void marvell_nfc_hw_ecc_bch_read_chunk(struct nand_chip *chip, int chunk,

drivers/mtd/nand/raw/marvell_nand.c

1328

if (chunk == 0)

drivers/mtd/nand/raw/marvell_nand.c

1337

if (chunk == 0)

drivers/mtd/nand/raw/marvell_nand.c

1339

else if (chunk < lt->nchunks - 1)

drivers/mtd/nand/raw/marvell_nand.c

1383

int chunk, ret;

drivers/mtd/nand/raw/marvell_nand.c

1397

for (chunk = 0; chunk < lt->nchunks; chunk++) {

drivers/mtd/nand/raw/marvell_nand.c

1399

if (chunk >= lt->full_chunk_cnt) {

drivers/mtd/nand/raw/marvell_nand.c

1405

marvell_nfc_hw_ecc_bch_read_chunk(chip, chunk, data, data_len,

drivers/mtd/nand/raw/marvell_nand.c

1409

failure_mask |= BIT(chunk);

drivers/mtd/nand/raw/marvell_nand.c

1439

for (chunk = 0; chunk < lt->nchunks; chunk++) {

drivers/mtd/nand/raw/marvell_nand.c

1445

if (!(failure_mask & BIT(chunk)))

drivers/mtd/nand/raw/marvell_nand.c

1448

data_off_in_page = chunk * (lt->data_bytes + lt->spare_bytes +

drivers/mtd/nand/raw/marvell_nand.c

1451

(chunk < lt->full_chunk_cnt ? lt->data_bytes :

drivers/mtd/nand/raw/marvell_nand.c

1454

(chunk < lt->full_chunk_cnt ? lt->spare_bytes :

drivers/mtd/nand/raw/marvell_nand.c

1457

data_off = chunk * lt->data_bytes;

drivers/mtd/nand/raw/marvell_nand.c

1458

spare_off = chunk * lt->spare_bytes;

drivers/mtd/nand/raw/marvell_nand.c

1461

(chunk * (lt->ecc_bytes + 2));

drivers/mtd/nand/raw/marvell_nand.c

1463

data_len = chunk < lt->full_chunk_cnt ? lt->data_bytes :

drivers/mtd/nand/raw/marvell_nand.c

1465

spare_len = chunk < lt->full_chunk_cnt ? lt->spare_bytes :

drivers/mtd/nand/raw/marvell_nand.c

1467

ecc_len = chunk < lt->full_chunk_cnt ? lt->ecc_bytes :

drivers/mtd/nand/raw/marvell_nand.c

1526

int chunk;

drivers/mtd/nand/raw/marvell_nand.c

1532

for (chunk = 0; chunk < lt->nchunks; chunk++) {

drivers/mtd/nand/raw/marvell_nand.c

1533

if (chunk >= lt->full_chunk_cnt) {

drivers/mtd/nand/raw/marvell_nand.c

1540

nand_change_write_column_op(chip, chunk * full_chunk_size,

drivers/mtd/nand/raw/marvell_nand.c

1544

nand_write_data_op(chip, buf + (chunk * lt->data_bytes),

drivers/mtd/nand/raw/marvell_nand.c

1568

marvell_nfc_hw_ecc_bch_write_chunk(struct nand_chip *chip, int chunk,

drivers/mtd/nand/raw/marvell_nand.c

1591

if (chunk == 0) {

drivers/mtd/nand/raw/marvell_nand.c

1602

} else if (chunk < lt->nchunks - 1) {

drivers/mtd/nand/raw/marvell_nand.c

1609

if (chunk == lt->nchunks - 1)

drivers/mtd/nand/raw/marvell_nand.c

1641

int chunk, ret;

drivers/mtd/nand/raw/marvell_nand.c

1652

for (chunk = 0; chunk < lt->nchunks; chunk++) {

drivers/mtd/nand/raw/marvell_nand.c

1653

if (chunk >= lt->full_chunk_cnt) {

drivers/mtd/nand/raw/marvell_nand.c

1658

marvell_nfc_hw_ecc_bch_write_chunk(chip, chunk, data, data_len,

drivers/mtd/nand/raw/marvell_nand.c

2267

ecc->size == l->chunk && ecc->strength == l->strength) {

drivers/mtd/nand/raw/marvell_nand.c

258

int chunk;

drivers/mtd/nand/raw/marvell_nand.c

274

.chunk = dc, \

drivers/mtd/nand/raw/nand_base.c

3647

int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;

drivers/mtd/nand/raw/nand_base.c

3660

pos = eccsize + i * (eccsize + chunk);

drivers/mtd/nand/raw/nand_base.c

3673

toread = min_t(int, length, chunk);

drivers/mtd/nand/raw/nand_base.c

3714

int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;

drivers/mtd/nand/raw/nand_base.c

3725

pos = steps * (eccsize + chunk);

drivers/mtd/nand/raw/nand_base.c

3751

pos = eccsize + i * (eccsize + chunk);

drivers/mtd/nand/raw/nand_base.c

3760

len = min_t(int, length, chunk);

drivers/mtd/nand/raw/pl35x-nand-controller.c

452

int chunk;

drivers/mtd/nand/raw/pl35x-nand-controller.c

454

for (chunk = 0; chunk < chip->ecc.steps;

drivers/mtd/nand/raw/pl35x-nand-controller.c

455

chunk++, read_ecc += chip->ecc.bytes) {

drivers/mtd/nand/raw/pl35x-nand-controller.c

456

ecc_value = readl(nfc->conf_regs + PL35X_SMC_ECC_VALUE(chunk));

drivers/mtd/nand/raw/pl35x-nand-controller.c

471

unsigned int max_bitflips = 0, chunk;

drivers/mtd/nand/raw/pl35x-nand-controller.c

476

for (chunk = 0; chunk < chip->ecc.steps;

drivers/mtd/nand/raw/pl35x-nand-controller.c

477

chunk++, data += chip->ecc.size, read_ecc += chip->ecc.bytes) {

drivers/mtd/nand/raw/pl35x-nand-controller.c

479

ecc_value = readl(nfc->conf_regs + PL35X_SMC_ECC_VALUE(chunk));

drivers/net/dsa/sja1105/sja1105_spi.c

100

chunk.buf += chunk.len;

drivers/net/dsa/sja1105/sja1105_spi.c

101

chunk.reg_addr += chunk.len / 4;

drivers/net/dsa/sja1105/sja1105_spi.c

102

chunk.len = min_t(size_t, (ptrdiff_t)(buf + len - chunk.buf),

drivers/net/dsa/sja1105/sja1105_spi.c

43

struct sja1105_chunk chunk;

drivers/net/dsa/sja1105/sja1105_spi.c

49

chunk.reg_addr = reg_addr;

drivers/net/dsa/sja1105/sja1105_spi.c

50

chunk.buf = buf;

drivers/net/dsa/sja1105/sja1105_spi.c

51

chunk.len = min_t(size_t, len, priv->max_xfer_len);

drivers/net/dsa/sja1105/sja1105_spi.c

61

msg.address = chunk.reg_addr;

drivers/net/dsa/sja1105/sja1105_spi.c

64

msg.read_count = chunk.len / 4;

drivers/net/dsa/sja1105/sja1105_spi.c

74

chunk_xfer->rx_buf = chunk.buf;

drivers/net/dsa/sja1105/sja1105_spi.c

76

chunk_xfer->tx_buf = chunk.buf;

drivers/net/dsa/sja1105/sja1105_spi.c

77

chunk_xfer->len = chunk.len;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

2484

unsigned int chunk =

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

2488

t3_mc7_bd_read(mem, t.addr / 8, chunk / 8,

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

2492

if (copy_to_user(useraddr, buf, chunk))

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

2494

useraddr += chunk;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

2495

t.addr += chunk;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

2496

t.len -= chunk;

drivers/net/ethernet/chelsio/cxgb3/sge.c

323

unsigned int chunk)

drivers/net/ethernet/chelsio/cxgb3/sge.c

327

reclaim = min(chunk, reclaim);

drivers/net/ethernet/ibm/emac/core.c

1478

int chunk = min(len, MAL_MAX_TX_SIZE);

drivers/net/ethernet/ibm/emac/core.c

1479

len -= chunk;

drivers/net/ethernet/ibm/emac/core.c

1490

dev->tx_desc[slot].data_len = (u16) chunk;

drivers/net/ethernet/ibm/emac/core.c

1497

pd += chunk;

drivers/net/ethernet/ibm/emac/core.c

1508

int len = skb->len, chunk;

drivers/net/ethernet/ibm/emac/core.c

1532

chunk = min(len, MAL_MAX_TX_SIZE);

drivers/net/ethernet/ibm/emac/core.c

1535

dev->tx_desc[slot].data_len = (u16) chunk;

drivers/net/ethernet/ibm/emac/core.c

1536

len -= chunk;

drivers/net/ethernet/ibm/emac/core.c

1538

slot = emac_xmit_split(dev, slot, pd + chunk, len, !nr_frags,

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1336

struct virtchnl2_vector_chunk *chunk;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1340

chunk = &chunks->vchunks[j];

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1341

num_vec = le16_to_cpu(chunk->num_vectors);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1342

reg_val.dyn_ctl_reg = le32_to_cpu(chunk->dynctl_reg_start);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1343

reg_val.itrn_reg = le32_to_cpu(chunk->itrn_reg_start);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1344

reg_val.itrn_index_spacing = le32_to_cpu(chunk->itrn_index_spacing);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1346

dynctl_reg_spacing = le32_to_cpu(chunk->dynctl_reg_spacing);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1347

itrn_reg_spacing = le32_to_cpu(chunk->itrn_reg_spacing);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1384

struct idpf_queue_id_reg_chunk *chunk;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1387

chunk = &chunks->queue_chunks[num_chunks];

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1388

if (chunk->type != q_type)

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1391

num_q = chunk->num_queues;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1392

reg_val = chunk->qtail_reg_start;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

1395

reg_val += chunk->qtail_reg_spacing;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3843

struct virtchnl2_vector_chunk *chunk;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3846

chunk = &chunks->vchunks[j];

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3847

num_vec = le16_to_cpu(chunk->num_vectors);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3848

start_vecid = le16_to_cpu(chunk->start_vector_id);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3882

struct idpf_queue_id_reg_chunk *chunk;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3884

chunk = &chunks->queue_chunks[num_chunks];

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3885

if (chunk->type != q_type)

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3888

num_q = chunk->num_queues;

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

3889

start_q_id = chunk->start_queue_id;

drivers/net/ethernet/marvell/skge.c

2537

u32 chunk, ram_addr;

drivers/net/ethernet/marvell/skge.c

2601

chunk = (hw->ram_size - hw->ram_offset) / (hw->ports * 2);

drivers/net/ethernet/marvell/skge.c

2602

ram_addr = hw->ram_offset + 2 * chunk * port;

drivers/net/ethernet/marvell/skge.c

2604

skge_ramset(hw, rxqaddr[port], ram_addr, chunk);

drivers/net/ethernet/marvell/skge.c

2608

skge_ramset(hw, txqaddr[port], ram_addr+chunk, chunk);

drivers/net/ethernet/mellanox/mlx4/icm.c

136

struct mlx4_icm_chunk *chunk = NULL;

drivers/net/ethernet/mellanox/mlx4/icm.c

160

if (!chunk) {

drivers/net/ethernet/mellanox/mlx4/icm.c

161

chunk = kzalloc_node(sizeof(*chunk),

drivers/net/ethernet/mellanox/mlx4/icm.c

165

if (!chunk) {

drivers/net/ethernet/mellanox/mlx4/icm.c

166

chunk = kzalloc_obj(*chunk,

drivers/net/ethernet/mellanox/mlx4/icm.c

168

if (!chunk)

drivers/net/ethernet/mellanox/mlx4/icm.c

171

chunk->coherent = coherent;

drivers/net/ethernet/mellanox/mlx4/icm.c

174

sg_init_table(chunk->sg, MLX4_ICM_CHUNK_LEN);

drivers/net/ethernet/mellanox/mlx4/icm.c

175

list_add_tail(&chunk->list, &icm->chunk_list);

drivers/net/ethernet/mellanox/mlx4/icm.c

187

&chunk->buf[chunk->npages],

drivers/net/ethernet/mellanox/mlx4/icm.c

190

ret = mlx4_alloc_icm_pages(&chunk->sg[chunk->npages],

drivers/net/ethernet/mellanox/mlx4/icm.c

201

++chunk->npages;

drivers/net/ethernet/mellanox/mlx4/icm.c

204

++chunk->nsg;

drivers/net/ethernet/mellanox/mlx4/icm.c

205

else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {

drivers/net/ethernet/mellanox/mlx4/icm.c

206

chunk->nsg = dma_map_sg(&dev->persist->pdev->dev,

drivers/net/ethernet/mellanox/mlx4/icm.c

207

chunk->sg, chunk->npages,

drivers/net/ethernet/mellanox/mlx4/icm.c

210

if (!chunk->nsg)

drivers/net/ethernet/mellanox/mlx4/icm.c

214

if (chunk->npages == MLX4_ICM_CHUNK_LEN)

drivers/net/ethernet/mellanox/mlx4/icm.c

215

chunk = NULL;

drivers/net/ethernet/mellanox/mlx4/icm.c

220

if (!coherent && chunk) {

drivers/net/ethernet/mellanox/mlx4/icm.c

221

chunk->nsg = dma_map_sg(&dev->persist->pdev->dev, chunk->sg,

drivers/net/ethernet/mellanox/mlx4/icm.c

222

chunk->npages, DMA_BIDIRECTIONAL);

drivers/net/ethernet/mellanox/mlx4/icm.c

224

if (!chunk->nsg)

drivers/net/ethernet/mellanox/mlx4/icm.c

318

struct mlx4_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx4/icm.c

334

list_for_each_entry(chunk, &icm->chunk_list, list) {

drivers/net/ethernet/mellanox/mlx4/icm.c

335

for (i = 0; i < chunk->npages; ++i) {

drivers/net/ethernet/mellanox/mlx4/icm.c

340

len = chunk->buf[i].size;

drivers/net/ethernet/mellanox/mlx4/icm.c

341

dma_addr = chunk->buf[i].dma_addr;

drivers/net/ethernet/mellanox/mlx4/icm.c

342

addr = chunk->buf[i].addr;

drivers/net/ethernet/mellanox/mlx4/icm.c

346

len = sg_dma_len(&chunk->sg[i]);

drivers/net/ethernet/mellanox/mlx4/icm.c

347

dma_addr = sg_dma_address(&chunk->sg[i]);

drivers/net/ethernet/mellanox/mlx4/icm.c

354

page = sg_page(&chunk->sg[i]);

drivers/net/ethernet/mellanox/mlx4/icm.c

55

static void mlx4_free_icm_pages(struct mlx4_dev *dev, struct mlx4_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx4/icm.c

59

if (chunk->nsg > 0)

drivers/net/ethernet/mellanox/mlx4/icm.c

60

dma_unmap_sg(&dev->persist->pdev->dev, chunk->sg, chunk->npages,

drivers/net/ethernet/mellanox/mlx4/icm.c

63

for (i = 0; i < chunk->npages; ++i)

drivers/net/ethernet/mellanox/mlx4/icm.c

64

__free_pages(sg_page(&chunk->sg[i]),

drivers/net/ethernet/mellanox/mlx4/icm.c

65

get_order(chunk->sg[i].length));

drivers/net/ethernet/mellanox/mlx4/icm.c

68

static void mlx4_free_icm_coherent(struct mlx4_dev *dev, struct mlx4_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx4/icm.c

72

for (i = 0; i < chunk->npages; ++i)

drivers/net/ethernet/mellanox/mlx4/icm.c

74

chunk->buf[i].size,

drivers/net/ethernet/mellanox/mlx4/icm.c

75

chunk->buf[i].addr,

drivers/net/ethernet/mellanox/mlx4/icm.c

76

chunk->buf[i].dma_addr);

drivers/net/ethernet/mellanox/mlx4/icm.c

81

struct mlx4_icm_chunk *chunk, *tmp;

drivers/net/ethernet/mellanox/mlx4/icm.c

86

list_for_each_entry_safe(chunk, tmp, &icm->chunk_list, list) {

drivers/net/ethernet/mellanox/mlx4/icm.c

88

mlx4_free_icm_coherent(dev, chunk);

drivers/net/ethernet/mellanox/mlx4/icm.c

90

mlx4_free_icm_pages(dev, chunk);

drivers/net/ethernet/mellanox/mlx4/icm.c

92

kfree(chunk);

drivers/net/ethernet/mellanox/mlx4/icm.h

100

iter->chunk = list_empty(&icm->chunk_list) ?

drivers/net/ethernet/mellanox/mlx4/icm.h

108

return !iter->chunk;

drivers/net/ethernet/mellanox/mlx4/icm.h

113

if (++iter->page_idx >= iter->chunk->nsg) {

drivers/net/ethernet/mellanox/mlx4/icm.h

114

if (iter->chunk->list.next == &iter->icm->chunk_list) {

drivers/net/ethernet/mellanox/mlx4/icm.h

115

iter->chunk = NULL;

drivers/net/ethernet/mellanox/mlx4/icm.h

119

iter->chunk = list_entry(iter->chunk->list.next,

drivers/net/ethernet/mellanox/mlx4/icm.h

127

if (iter->chunk->coherent)

drivers/net/ethernet/mellanox/mlx4/icm.h

128

return iter->chunk->buf[iter->page_idx].dma_addr;

drivers/net/ethernet/mellanox/mlx4/icm.h

130

return sg_dma_address(&iter->chunk->sg[iter->page_idx]);

drivers/net/ethernet/mellanox/mlx4/icm.h

135

if (iter->chunk->coherent)

drivers/net/ethernet/mellanox/mlx4/icm.h

136

return iter->chunk->buf[iter->page_idx].size;

drivers/net/ethernet/mellanox/mlx4/icm.h

138

return sg_dma_len(&iter->chunk->sg[iter->page_idx]);

drivers/net/ethernet/mellanox/mlx4/icm.h

74

struct mlx4_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

722

int chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

731

chunk = min_t(int, max_mtts_first_page, npages);

drivers/net/ethernet/mellanox/mlx4/mr.c

734

err = mlx4_write_mtt_chunk(dev, mtt, start_index, chunk, page_list);

drivers/net/ethernet/mellanox/mlx4/mr.c

737

npages -= chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

738

start_index += chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

739

page_list += chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

741

chunk = min_t(int, mtts_per_page, npages);

drivers/net/ethernet/mellanox/mlx4/mr.c

751

int chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

765

chunk = min_t(int, MLX4_MAILBOX_SIZE / sizeof(u64) - 2,

drivers/net/ethernet/mellanox/mlx4/mr.c

769

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

drivers/net/ethernet/mellanox/mlx4/mr.c

772

err = mlx4_WRITE_MTT(dev, mailbox, chunk);

drivers/net/ethernet/mellanox/mlx4/mr.c

778

npages -= chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

779

start_index += chunk;

drivers/net/ethernet/mellanox/mlx4/mr.c

780

page_list += chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

388

struct mlx5hws_action_ste_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

392

err = mlx5hws_pool_chunk_alloc(action_tbl->pool, &chunk->ste);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

396

chunk->action_tbl = action_tbl;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

404

struct mlx5hws_action_ste_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

420

skip_rx, skip_tx, chunk->ste.order);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

424

if (!hws_action_ste_table_chunk_alloc(action_tbl, chunk)) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

437

err = hws_action_ste_table_chunk_alloc(action_tbl, chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

453

void mlx5hws_action_ste_chunk_free(struct mlx5hws_action_ste_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

455

struct mutex *lock = &chunk->action_tbl->parent_elem->parent_pool->lock;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

457

mlx5hws_dbg(chunk->action_tbl->pool->ctx,

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

459

chunk->ste.offset, chunk->ste.order);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

462

mlx5hws_pool_chunk_free(chunk->action_tbl->pool, &chunk->ste);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

463

chunk->action_tbl->last_used = jiffies;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

464

list_move(&chunk->action_tbl->list_node,

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.c

465

&chunk->action_tbl->parent_elem->available);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.h

65

struct mlx5hws_action_ste_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action_ste_pool.h

67

void mlx5hws_action_ste_chunk_free(struct mlx5hws_action_ste_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

137

struct mlx5hws_pool_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

146

chunk->offset = mlx5hws_buddy_alloc_mem(buddy, chunk->order);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

147

if (chunk->offset >= 0)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

154

struct mlx5hws_pool_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

164

mlx5hws_buddy_free_mem(buddy, chunk->offset, chunk->order);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

231

struct mlx5hws_pool_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

235

if (chunk->order != 0) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

248

chunk->offset = find_first_bit(bitmap, size);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

249

if (chunk->offset >= size)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

252

bitmap_clear(bitmap, chunk->offset, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

258

struct mlx5hws_pool_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

268

bitmap_set(bitmap, chunk->offset, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

322

struct mlx5hws_pool_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

327

ret = pool->p_get_chunk(pool, chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

329

pool->available_elems -= 1 << chunk->order;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

336

struct mlx5hws_pool_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

339

pool->p_put_chunk(pool, chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.c

340

pool->available_elems += 1 << chunk->order;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.h

64

struct mlx5hws_pool_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.h

66

struct mlx5hws_pool_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.h

94

struct mlx5hws_pool_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/pool.h

97

struct mlx5hws_pool_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_action.c

713

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_action.c

730

chunk = is_rx_rule ? dest_tbl->tbl->rx.s_anchor->chunk :

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_action.c

731

dest_tbl->tbl->tx.s_anchor->chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_action.c

733

*final_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_dbg.c

717

s_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(matcher_rx_tx->s_htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_dbg.c

718

e_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(matcher_rx_tx->e_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_dbg.c

817

s_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(table_rx_tx->s_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

101

return mlx5dr_icm_pool_chunk_size_to_byte(chunk->size,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

102

chunk->buddy_mem->pool->icm_type);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

105

u32 mlx5dr_icm_pool_get_chunk_num_of_entries(struct mlx5dr_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

107

return mlx5dr_icm_pool_chunk_size_to_entries(chunk->size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

209

static void dr_icm_chunk_ste_init(struct mlx5dr_icm_chunk *chunk, int offset)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

211

int num_of_entries = mlx5dr_icm_pool_get_chunk_num_of_entries(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

212

struct mlx5dr_icm_buddy_mem *buddy = chunk->buddy_mem;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

216

chunk->ste_arr = &buddy->ste_arr[index];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

217

chunk->miss_list = &buddy->miss_list[index];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

218

chunk->hw_ste_arr = buddy->hw_ste_arr + index * ste_size;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

220

memset(chunk->hw_ste_arr, 0, num_of_entries * ste_size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

221

memset(chunk->ste_arr, 0,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

222

num_of_entries * sizeof(chunk->ste_arr[0]));

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

320

dr_icm_chunk_init(struct mlx5dr_icm_chunk *chunk,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

328

chunk->seg = seg;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

329

chunk->size = chunk_size;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

330

chunk->buddy_mem = buddy_mem_pool;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

334

dr_icm_chunk_ste_init(chunk, offset);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

337

buddy_mem_pool->used_memory += mlx5dr_icm_pool_get_chunk_byte_size(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

437

struct mlx5dr_icm_chunk *chunk = NULL;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

451

chunk = kmem_cache_alloc(pool->chunks_kmem_cache, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

452

if (!chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

455

dr_icm_chunk_init(chunk, pool, chunk_size, buddy, seg);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

463

return chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

466

void mlx5dr_icm_free_chunk(struct mlx5dr_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

468

struct mlx5dr_icm_buddy_mem *buddy = chunk->buddy_mem;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

478

pool->hot_memory_size += mlx5dr_icm_pool_get_chunk_byte_size(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

481

hot_chunk->buddy_mem = chunk->buddy_mem;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

482

hot_chunk->seg = chunk->seg;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

483

hot_chunk->size = chunk->size;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

485

kmem_cache_free(chunks_cache, chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

80

u64 mlx5dr_icm_pool_get_chunk_mr_addr(struct mlx5dr_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

82

u32 offset = mlx5dr_icm_pool_dm_type_to_entry_size(chunk->buddy_mem->pool->icm_type);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

84

return (u64)offset * chunk->seg;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

87

u32 mlx5dr_icm_pool_get_chunk_rkey(struct mlx5dr_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

89

return chunk->buddy_mem->icm_mr->mkey;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

92

u64 mlx5dr_icm_pool_get_chunk_icm_addr(struct mlx5dr_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

94

u32 size = mlx5dr_icm_pool_dm_type_to_entry_size(chunk->buddy_mem->pool->icm_type);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

96

return (u64)chunk->buddy_mem->icm_mr->icm_start_addr + size * chunk->seg;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

99

u32 mlx5dr_icm_pool_get_chunk_byte_size(struct mlx5dr_icm_chunk *chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

1048

next_nic_matcher->s_htbl->pointing_ste = prev_anchor->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

1049

prev_anchor->chunk->ste_arr[0].next_htbl = next_nic_matcher->s_htbl;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

1053

prev_anchor->chunk->ste_arr[0].next_htbl = NULL;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

708

info.miss_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(curr_nic_matcher->e_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

729

curr_nic_matcher->s_htbl->pointing_ste = prev_htbl->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

730

prev_htbl->chunk->ste_arr[0].next_htbl = curr_nic_matcher->s_htbl;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

734

curr_nic_matcher->e_anchor->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_matcher.c

735

curr_nic_matcher->e_anchor->chunk->ste_arr[0].next_htbl =

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

107

pattern->chunk = chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

119

mlx5dr_icm_free_chunk(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

127

mlx5dr_icm_free_chunk(pattern->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

165

if (mlx5dr_send_postsend_pattern(mgr->dmn, pattern->chunk,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

81

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

89

chunk = mlx5dr_icm_alloc_chunk(mgr->ptrn_icm_pool, chunk_size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

90

if (!chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ptrn.c

93

index = (mlx5dr_icm_pool_get_chunk_icm_addr(chunk) -

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

102

ste->htbl->chunk->miss_list = mlx5dr_ste_get_miss_list(orig_ste);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

210

new_ste->htbl->chunk->miss_list = mlx5dr_ste_get_miss_list(col_ste);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

272

new_ste = &new_htbl->chunk->ste_arr[new_idx];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

359

cur_entries = mlx5dr_icm_pool_chunk_size_to_entries(cur_htbl->chunk->size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

367

cur_ste = &cur_htbl->chunk->ste_arr[i];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

433

info.miss_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(nic_matcher->e_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

481

prev_htbl->chunk->hw_ste_arr,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

482

mlx5dr_icm_pool_get_chunk_icm_addr(new_htbl->chunk),

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

483

mlx5dr_icm_pool_get_chunk_num_of_entries(new_htbl->chunk));

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

485

ste_to_update = &prev_htbl->chunk->ste_arr[0];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

524

new_size = mlx5dr_icm_next_higher_chunk(cur_htbl->chunk->size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

527

if (new_size == cur_htbl->chunk->size)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

53

icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(nic_matcher->e_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

694

if (dmn->info.max_log_sw_icm_sz <= htbl->chunk->size)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

700

if (dr_get_bits_per_mask(htbl->byte_mask) * BITS_PER_BYTE <= htbl->chunk->size)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

77

ste = new_htbl->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

856

miss_list = &cur_htbl->chunk->miss_list[index];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

857

ste = &cur_htbl->chunk->ste_arr[index];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

893

cur_htbl->chunk->size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

661

u32 chunk_byte_size = mlx5dr_icm_pool_get_chunk_byte_size(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

671

*num_stes = mlx5dr_icm_pool_get_chunk_num_of_entries(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

707

send_info.rkey = mlx5dr_icm_pool_get_chunk_rkey(ste->htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

716

u32 byte_size = mlx5dr_icm_pool_get_chunk_byte_size(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

740

struct mlx5dr_ste *ste = &htbl->chunk->ste_arr[ste_index + j];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

749

htbl->chunk->hw_ste_arr +

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

766

mlx5dr_ste_get_mr_addr(htbl->chunk->ste_arr + ste_index);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

767

send_info.rkey = mlx5dr_icm_pool_get_chunk_rkey(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

785

u32 byte_size = mlx5dr_icm_pool_get_chunk_byte_size(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

801

copy_dst = htbl->chunk->hw_ste_arr + i * DR_STE_SIZE_REDUCED;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

823

mlx5dr_ste_get_mr_addr(htbl->chunk->ste_arr + ste_index);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

824

send_info.rkey = mlx5dr_icm_pool_get_chunk_rkey(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

846

mlx5dr_icm_pool_get_chunk_mr_addr(action->rewrite->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

847

send_info.rkey = mlx5dr_icm_pool_get_chunk_rkey(action->rewrite->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

853

struct mlx5dr_icm_chunk *chunk,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

862

send_info.remote_addr = mlx5dr_icm_pool_get_chunk_mr_addr(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

863

send_info.rkey = mlx5dr_icm_pool_get_chunk_rkey(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

126

u64 base_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(ste->htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

127

u32 index = ste - ste->htbl->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

134

u32 index = ste - ste->htbl->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

136

return mlx5dr_icm_pool_get_chunk_mr_addr(ste->htbl->chunk) + DR_STE_SIZE * index;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

141

u64 index = ste - ste->htbl->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

143

return ste->htbl->chunk->hw_ste_arr + DR_STE_SIZE_REDUCED * index;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

148

u32 index = ste - ste->htbl->chunk->ste_arr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

150

return &ste->htbl->chunk->miss_list[index];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

157

struct mlx5dr_icm_chunk *chunk = next_htbl->chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

161

ste_ctx->set_hit_addr(hw_ste, mlx5dr_icm_pool_get_chunk_icm_addr(chunk),

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

162

mlx5dr_icm_pool_get_chunk_num_of_entries(chunk));

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

208

miss_addr = mlx5dr_icm_pool_get_chunk_icm_addr(nic_matcher->e_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

29

u32 num_entries = mlx5dr_icm_pool_get_chunk_num_of_entries(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

386

u64 icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(next_htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

388

mlx5dr_icm_pool_get_chunk_num_of_entries(next_htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

476

mlx5dr_icm_pool_get_chunk_icm_addr(nic_matcher->e_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

500

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

509

chunk = mlx5dr_icm_alloc_chunk(pool, chunk_size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

510

if (!chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

513

htbl->chunk = chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

520

num_entries = mlx5dr_icm_pool_get_chunk_num_of_entries(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

523

struct mlx5dr_ste *ste = &chunk->ste_arr[i];

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

528

INIT_LIST_HEAD(&chunk->miss_list[i]);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

540

struct mlx5dr_icm_pool *pool = htbl->chunk->buddy_mem->pool;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

545

mlx5dr_icm_free_chunk(htbl->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

649

action->rewrite->chunk = mlx5dr_icm_alloc_chunk(dmn->action_icm_pool,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

651

if (!action->rewrite->chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

654

action->rewrite->index = (mlx5dr_icm_pool_get_chunk_icm_addr(action->rewrite->chunk) -

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

665

mlx5dr_icm_free_chunk(action->rewrite->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

671

mlx5dr_icm_free_chunk(action->rewrite->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

13

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

230

icm_addr_rx = mlx5dr_icm_pool_get_chunk_icm_addr(tbl->rx.s_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

233

icm_addr_tx = mlx5dr_icm_pool_get_chunk_icm_addr(tbl->tx.s_anchor->chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

27

chunk = nic_tbl->nic_dmn->type == DR_DOMAIN_NIC_TYPE_RX ?

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

28

action->dest_tbl->tbl->rx.s_anchor->chunk :

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

29

action->dest_tbl->tbl->tx.s_anchor->chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_table.c

30

nic_tbl->default_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1016

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1033

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1218

u64 mlx5dr_icm_pool_get_chunk_mr_addr(struct mlx5dr_icm_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1219

u32 mlx5dr_icm_pool_get_chunk_rkey(struct mlx5dr_icm_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1220

u64 mlx5dr_icm_pool_get_chunk_icm_addr(struct mlx5dr_icm_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1221

u32 mlx5dr_icm_pool_get_chunk_num_of_entries(struct mlx5dr_icm_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1222

u32 mlx5dr_icm_pool_get_chunk_byte_size(struct mlx5dr_icm_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1260

mlx5dr_icm_pool_chunk_size_to_entries(htbl->chunk->size);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1269

if (htbl->chunk->size == DR_CHUNK_SIZE_MAX - 1 || !htbl->byte_mask)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1393

void mlx5dr_icm_free_chunk(struct mlx5dr_icm_chunk *chunk);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

1490

struct mlx5dr_icm_chunk *chunk,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

194

struct mlx5dr_icm_chunk *chunk;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

79

mlx5dr_icm_next_higher_chunk(enum mlx5dr_icm_chunk_size chunk)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

81

chunk += 2;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

82

if (chunk < DR_CHUNK_SIZE_MAX)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

83

return chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

157

struct mlxsw_sp1_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

159

mlxsw_sp_acl_ctcam_chunk_init(&region->cregion, &chunk->cchunk,

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

165

struct mlxsw_sp1_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

167

mlxsw_sp_acl_ctcam_chunk_fini(&chunk->cchunk);

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

176

struct mlxsw_sp1_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

180

&chunk->cchunk, &entry->centry,

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

189

struct mlxsw_sp1_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum1_acl_tcam.c

193

&chunk->cchunk, &entry->centry);

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

197

struct mlxsw_sp2_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

199

mlxsw_sp_acl_atcam_chunk_init(&region->aregion, &chunk->achunk,

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

205

struct mlxsw_sp2_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

207

mlxsw_sp_acl_atcam_chunk_fini(&chunk->achunk);

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

216

struct mlxsw_sp2_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

221

&chunk->achunk, &entry->aentry,

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

230

struct mlxsw_sp2_acl_tcam_chunk *chunk = chunk_priv;

drivers/net/ethernet/mellanox/mlxsw/spectrum2_acl_tcam.c

233

mlxsw_sp_acl_atcam_entry_del(mlxsw_sp, &region->aregion, &chunk->achunk,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_bloom_filter.c

254

char *chunk = output;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_bloom_filter.c

266

memset(chunk, 0, pad_bytes);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_bloom_filter.c

267

memcpy(chunk + pad_bytes, &erp_region_id,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_bloom_filter.c

270

memcpy(chunk + key_offset, enc_key, chunk_key_len);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_bloom_filter.c

271

chunk += chunk_len;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1009

mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1051

struct mlxsw_sp_acl_tcam_chunk *chunk)

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1061

entry->chunk = chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1063

err = ops->entry_add(mlxsw_sp, chunk->region->priv, chunk->priv,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1080

ops->entry_del(mlxsw_sp, entry->chunk->region->priv,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1081

entry->chunk->priv, entry->priv);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1104

return ops->entry_activity_get(mlxsw_sp, entry->chunk->region->priv,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1128

vchunk->chunk);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1190

struct mlxsw_sp_acl_tcam_chunk *chunk,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1196

if (ventry->entry->chunk == chunk)

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1202

new_entry = mlxsw_sp_acl_tcam_entry_create(mlxsw_sp, ventry, chunk);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1223

vchunk->chunk2 = vchunk->chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1224

vchunk->chunk = new_chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1251

if (vchunk->chunk->region != region) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1283

vchunk->chunk, credits);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

1296

swap(vchunk->chunk, vchunk->chunk2);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

175

struct mlxsw_sp_acl_tcam_chunk *chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

188

struct mlxsw_sp_acl_tcam_chunk *chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

906

struct mlxsw_sp_acl_tcam_chunk *chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

908

chunk = kzalloc(sizeof(*chunk) + ops->chunk_priv_size, GFP_KERNEL);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

909

if (!chunk)

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

911

chunk->vchunk = vchunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

912

chunk->region = region;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

914

ops->chunk_init(region->priv, chunk->priv, vchunk->priority);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

915

return chunk;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

920

struct mlxsw_sp_acl_tcam_chunk *chunk)

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

924

ops->chunk_fini(chunk->priv);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

925

kfree(chunk);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

965

vchunk->chunk = mlxsw_sp_acl_tcam_chunk_create(mlxsw_sp, vchunk,

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

967

if (IS_ERR(vchunk->chunk)) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

969

err = PTR_ERR(vchunk->chunk);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

504

void *chunk;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

526

chunks[i].chunk = kmalloc(chunk_size,

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

528

if (!chunks[i].chunk)

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

536

memcpy(chunks[i].chunk, arg->in_buf + off, coff);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

538

memset(chunks[i].chunk + coff, 0, chunk_size - coff);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

548

addr = dma_map_single(dev, chunks[i].chunk, chunks[i].len,

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

596

memcpy(arg->out_buf + off, chunks[i].chunk, len);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

614

kfree(chunks[i].chunk);

drivers/net/ethernet/sfc/efx_reflash.c

276

size_t chunk, offset, next_update;

drivers/net/ethernet/sfc/efx_reflash.c

293

chunk = align;

drivers/net/ethernet/sfc/efx_reflash.c

295

chunk = rounddown(EFX_NVRAM_ERASE_IDEAL_CHUNK_SIZE, align);

drivers/net/ethernet/sfc/efx_reflash.c

297

for (offset = 0, next_update = 0; offset < partition_size; offset += chunk) {

drivers/net/ethernet/sfc/efx_reflash.c

305

chunk = min_t(size_t, partition_size - offset, chunk);

drivers/net/ethernet/sfc/efx_reflash.c

306

rc = efx_mcdi_nvram_erase(efx, type, offset, chunk);

drivers/net/ethernet/sfc/efx_reflash.c

310

type, offset, offset + chunk - 1);

drivers/net/ethernet/sfc/efx_reflash.c

327

size_t write_max, chunk, offset, next_update;

drivers/net/ethernet/sfc/efx_reflash.c

343

chunk = rounddown(write_max, align);

drivers/net/ethernet/sfc/efx_reflash.c

345

for (offset = 0, next_update = 0; offset + chunk <= data_size; offset += chunk) {

drivers/net/ethernet/sfc/efx_reflash.c

353

rc = efx_mcdi_nvram_write(efx, type, offset, data + offset, chunk);

drivers/net/ethernet/sfc/efx_reflash.c

357

type, offset, offset + chunk - 1);

drivers/net/ethernet/sfc/efx_reflash.c

372

chunk = roundup(remaining, align);

drivers/net/ethernet/sfc/efx_reflash.c

373

buf = kmalloc(chunk, GFP_KERNEL);

drivers/net/ethernet/sfc/efx_reflash.c

378

memset(buf + remaining, 0xFF, chunk - remaining);

drivers/net/ethernet/sfc/efx_reflash.c

379

rc = efx_mcdi_nvram_write(efx, type, offset, buf, chunk);

drivers/net/ethernet/sfc/efx_reflash.c

384

type, offset, offset + chunk - 1);

drivers/net/ethernet/sfc/mcdi.c

2380

size_t chunk;

drivers/net/ethernet/sfc/mcdi.c

2384

chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);

drivers/net/ethernet/sfc/mcdi.c

2386

buffer, chunk);

drivers/net/ethernet/sfc/mcdi.c

2389

offset += chunk;

drivers/net/ethernet/sfc/mcdi.c

2390

buffer += chunk;

drivers/net/ethernet/sfc/mcdi.c

2403

size_t chunk = part->common.mtd.erasesize;

drivers/net/ethernet/sfc/mcdi.c

2418

chunk);

drivers/net/ethernet/sfc/mcdi.c

2421

offset += chunk;

drivers/net/ethernet/sfc/mcdi.c

2434

size_t chunk;

drivers/net/ethernet/sfc/mcdi.c

2445

chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);

drivers/net/ethernet/sfc/mcdi.c

2447

buffer, chunk);

drivers/net/ethernet/sfc/mcdi.c

2450

offset += chunk;

drivers/net/ethernet/sfc/mcdi.c

2451

buffer += chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2158

size_t chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2162

chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);

drivers/net/ethernet/sfc/siena/mcdi.c

2164

buffer, chunk);

drivers/net/ethernet/sfc/siena/mcdi.c

2167

offset += chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2168

buffer += chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2181

size_t chunk = part->common.mtd.erasesize;

drivers/net/ethernet/sfc/siena/mcdi.c

2196

chunk);

drivers/net/ethernet/sfc/siena/mcdi.c

2199

offset += chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2212

size_t chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2223

chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);

drivers/net/ethernet/sfc/siena/mcdi.c

2225

buffer, chunk);

drivers/net/ethernet/sfc/siena/mcdi.c

2228

offset += chunk;

drivers/net/ethernet/sfc/siena/mcdi.c

2229

buffer += chunk;

drivers/net/hyperv/netvsc.c

976

u32 chunk = min_t(u32, len, PAGE_SIZE - off);

drivers/net/hyperv/netvsc.c

979

memcpy(dest, src + off, chunk);

drivers/net/hyperv/netvsc.c

981

dest += chunk;

drivers/net/hyperv/netvsc.c

982

paddr += chunk;

drivers/net/hyperv/netvsc.c

983

len -= chunk;

drivers/net/wireless/ath/ar5523/ar5523.c

539

struct ar5523_chunk *chunk;

drivers/net/wireless/ath/ar5523/ar5523.c

560

chunk = (struct ar5523_chunk *) data->skb->data;

drivers/net/wireless/ath/ar5523/ar5523.c

562

if (((chunk->flags & UATH_CFLAGS_FINAL) == 0) ||

drivers/net/wireless/ath/ar5523/ar5523.c

563

chunk->seqnum != 0) {

drivers/net/wireless/ath/ar5523/ar5523.c

565

chunk->seqnum, chunk->flags,

drivers/net/wireless/ath/ar5523/ar5523.c

566

be16_to_cpu(chunk->length));

drivers/net/wireless/ath/ar5523/ar5523.c

592

skb_reserve(data->skb, sizeof(*chunk));

drivers/net/wireless/ath/ar5523/ar5523.c

802

struct ar5523_chunk *chunk;

drivers/net/wireless/ath/ar5523/ar5523.c

844

chunk = skb_push(skb, sizeof(*chunk));

drivers/net/wireless/ath/ar5523/ar5523.c

846

chunk->seqnum = 0;

drivers/net/wireless/ath/ar5523/ar5523.c

847

chunk->flags = UATH_CFLAGS_FINAL;

drivers/net/wireless/ath/ar5523/ar5523.c

848

chunk->length = cpu_to_be16(skb->len);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1820

struct host_memory_chunk_tlv *chunk;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1827

tlv_len = __cpu_to_le16(sizeof(*chunk));

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1832

chunk = (void *)tlv->value;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1834

chunk->ptr = __cpu_to_le32(ar->wmi.mem_chunks[i].paddr);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1835

chunk->size = __cpu_to_le32(ar->wmi.mem_chunks[i].len);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1836

chunk->req_id = __cpu_to_le32(ar->wmi.mem_chunks[i].req_id);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1841

chunk->ptr_high = __cpu_to_le32(upper_32_bits(paddr));

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1852

host_mem_chunks += sizeof(*chunk);

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

6568

struct host_memory_chunk *chunk;

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

6574

chunk = &chunks->items[i];

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

6575

chunk->ptr = __cpu_to_le32(ar->wmi.mem_chunks[i].paddr);

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

6576

chunk->size = __cpu_to_le32(ar->wmi.mem_chunks[i].len);

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

6577

chunk->req_id = __cpu_to_le32(ar->wmi.mem_chunks[i].req_id);

drivers/net/wireless/ath/ath11k/qmi.c

1982

struct target_mem_chunk *chunk;

drivers/net/wireless/ath/ath11k/qmi.c

1987

chunk = &ab->qmi.target_mem[i];

drivers/net/wireless/ath/ath11k/qmi.c

1992

if (chunk->vaddr) {

drivers/net/wireless/ath/ath11k/qmi.c

1993

if (chunk->prev_type == chunk->type &&

drivers/net/wireless/ath/ath11k/qmi.c

1994

chunk->prev_size == chunk->size)

drivers/net/wireless/ath/ath11k/qmi.c

2000

chunk->size, chunk->type,

drivers/net/wireless/ath/ath11k/qmi.c

2001

chunk->prev_size, chunk->prev_type);

drivers/net/wireless/ath/ath11k/qmi.c

2007

dma_free_coherent(ab->dev, chunk->prev_size,

drivers/net/wireless/ath/ath11k/qmi.c

2008

chunk->vaddr, chunk->paddr);

drivers/net/wireless/ath/ath11k/qmi.c

2009

chunk->vaddr = NULL;

drivers/net/wireless/ath/ath11k/qmi.c

2012

chunk->vaddr = dma_alloc_coherent(ab->dev,

drivers/net/wireless/ath/ath11k/qmi.c

2013

chunk->size,

drivers/net/wireless/ath/ath11k/qmi.c

2014

&chunk->paddr,

drivers/net/wireless/ath/ath11k/qmi.c

2016

if (!chunk->vaddr) {

drivers/net/wireless/ath/ath11k/qmi.c

2020

chunk->size,

drivers/net/wireless/ath/ath11k/qmi.c

2021

chunk->type);

drivers/net/wireless/ath/ath11k/qmi.c

2028

chunk->size,

drivers/net/wireless/ath/ath11k/qmi.c

2029

chunk->type);

drivers/net/wireless/ath/ath11k/qmi.c

2032

chunk->prev_type = chunk->type;

drivers/net/wireless/ath/ath11k/qmi.c

2033

chunk->prev_size = chunk->size;

drivers/net/wireless/ath/ath12k/core.h

881

struct target_mem_chunk chunk[ATH12K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01];

drivers/net/wireless/ath/ath12k/qmi.c

2497

for (i = 0; i < ARRAY_SIZE(ag->mlo_mem.chunk); i++) {

drivers/net/wireless/ath/ath12k/qmi.c

2498

mlo_chunk = &ag->mlo_mem.chunk[i];

drivers/net/wireless/ath/ath12k/qmi.c

2510

struct target_mem_chunk *chunk,

drivers/net/wireless/ath/ath12k/qmi.c

2522

if (idx >= ARRAY_SIZE(ag->mlo_mem.chunk)) {

drivers/net/wireless/ath/ath12k/qmi.c

2528

mlo_chunk = &ag->mlo_mem.chunk[idx];

drivers/net/wireless/ath/ath12k/qmi.c

2544

chunk->v.ioaddr = NULL;

drivers/net/wireless/ath/ath12k/qmi.c

2546

chunk->v.addr = NULL;

drivers/net/wireless/ath/ath12k/qmi.c

2547

chunk->paddr = 0;

drivers/net/wireless/ath/ath12k/qmi.c

2548

chunk->size = 0;

drivers/net/wireless/ath/ath12k/qmi.c

2585

struct target_mem_chunk *chunk)

drivers/net/wireless/ath/ath12k/qmi.c

2590

if (chunk->v.addr) {

drivers/net/wireless/ath/ath12k/qmi.c

2591

if (chunk->prev_type == chunk->type &&

drivers/net/wireless/ath/ath12k/qmi.c

2592

chunk->prev_size == chunk->size)

drivers/net/wireless/ath/ath12k/qmi.c

2596

dma_free_coherent(ab->dev, chunk->prev_size,

drivers/net/wireless/ath/ath12k/qmi.c

2597

chunk->v.addr, chunk->paddr);

drivers/net/wireless/ath/ath12k/qmi.c

2598

chunk->v.addr = NULL;

drivers/net/wireless/ath/ath12k/qmi.c

2601

chunk->v.addr = dma_alloc_coherent(ab->dev,

drivers/net/wireless/ath/ath12k/qmi.c

2602

chunk->size,

drivers/net/wireless/ath/ath12k/qmi.c

2603

&chunk->paddr,

drivers/net/wireless/ath/ath12k/qmi.c

2605

if (!chunk->v.addr) {

drivers/net/wireless/ath/ath12k/qmi.c

2606

if (chunk->size > ATH12K_QMI_MAX_CHUNK_SIZE) {

drivers/net/wireless/ath/ath12k/qmi.c

2610

chunk->size,

drivers/net/wireless/ath/ath12k/qmi.c

2611

chunk->type);

drivers/net/wireless/ath/ath12k/qmi.c

2616

chunk->type, chunk->size);

drivers/net/wireless/ath/ath12k/qmi.c

2619

chunk->prev_type = chunk->type;

drivers/net/wireless/ath/ath12k/qmi.c

2620

chunk->prev_size = chunk->size;

drivers/net/wireless/ath/ath12k/qmi.c

2627

struct target_mem_chunk *chunk, *mlo_chunk;

drivers/net/wireless/ath/ath12k/qmi.c

2635

memset(ag->mlo_mem.chunk, 0, sizeof(ag->mlo_mem.chunk));

drivers/net/wireless/ath/ath12k/qmi.c

2642

chunk = &ab->qmi.target_mem[i];

drivers/net/wireless/ath/ath12k/qmi.c

2648

switch (chunk->type) {

drivers/net/wireless/ath/ath12k/qmi.c

2654

ret = ath12k_qmi_alloc_chunk(ab, chunk);

drivers/net/wireless/ath/ath12k/qmi.c

2659

mlo_size += chunk->size;

drivers/net/wireless/ath/ath12k/qmi.c

2668

mlo_chunk = &ag->mlo_mem.chunk[mlo_idx];

drivers/net/wireless/ath/ath12k/qmi.c

2670

if (chunk->size != mlo_chunk->size) {

drivers/net/wireless/ath/ath12k/qmi.c

2672

mlo_idx, chunk->size, mlo_chunk->size);

drivers/net/wireless/ath/ath12k/qmi.c

2677

mlo_chunk->size = chunk->size;

drivers/net/wireless/ath/ath12k/qmi.c

2678

mlo_chunk->type = chunk->type;

drivers/net/wireless/ath/ath12k/qmi.c

2685

chunk->paddr = mlo_chunk->paddr;

drivers/net/wireless/ath/ath12k/qmi.c

2686

chunk->v.addr = mlo_chunk->v.addr;

drivers/net/wireless/ath/ath12k/qmi.c

2692

chunk->type);

drivers/net/wireless/ath/ath12k/qmi.c

2693

chunk->paddr = 0;

drivers/net/wireless/ath/ath12k/qmi.c

2694

chunk->v.addr = NULL;

drivers/net/wireless/intel/ipw2x00/ipw2200.c

3142

struct fw_chunk *chunk;

drivers/net/wireless/intel/ipw2x00/ipw2200.c

3182

chunk = (struct fw_chunk *)(data + offset);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

3184

chunk_len = le32_to_cpu(chunk->length);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

3209

nr, le32_to_cpu(chunk->address),

drivers/net/wireless/marvell/libertas/if_sdio.c

321

u16 size, type, chunk;

drivers/net/wireless/marvell/libertas/if_sdio.c

343

chunk = sdio_align_size(card->func, size);

drivers/net/wireless/marvell/libertas/if_sdio.c

345

ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);

drivers/net/wireless/marvell/libertas/if_sdio.c

349

chunk = card->buffer[0] | (card->buffer[1] << 8);

drivers/net/wireless/marvell/libertas/if_sdio.c

353

(int)type, (int)chunk);

drivers/net/wireless/marvell/libertas/if_sdio.c

355

if (chunk > size) {

drivers/net/wireless/marvell/libertas/if_sdio.c

357

(int)chunk, (int)size);

drivers/net/wireless/marvell/libertas/if_sdio.c

362

if (chunk < size) {

drivers/net/wireless/marvell/libertas/if_sdio.c

364

(int)chunk, (int)size);

drivers/net/wireless/marvell/libertas/if_sdio.c

369

ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);

drivers/net/wireless/marvell/libertas/if_sdio.c

374

ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);

drivers/net/wireless/marvell/libertas/if_sdio.c

379

ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);

drivers/net/wireless/ti/wlcore/boot.c

165

u8 *p, *chunk;

drivers/net/wireless/ti/wlcore/boot.c

180

chunk = kmalloc(CHUNK_SIZE, GFP_KERNEL);

drivers/net/wireless/ti/wlcore/boot.c

181

if (!chunk) {

drivers/net/wireless/ti/wlcore/boot.c

212

memcpy(chunk, p, CHUNK_SIZE);

drivers/net/wireless/ti/wlcore/boot.c

215

ret = wlcore_write(wl, addr, chunk, CHUNK_SIZE, false);

drivers/net/wireless/ti/wlcore/boot.c

225

memcpy(chunk, p, fw_data_len % CHUNK_SIZE);

drivers/net/wireless/ti/wlcore/boot.c

228

ret = wlcore_write(wl, addr, chunk, fw_data_len % CHUNK_SIZE, false);

drivers/net/wireless/ti/wlcore/boot.c

231

kfree(chunk);

drivers/nfc/pn544/i2c.c

657

struct pn544_i2c_fw_secure_frame *chunk;

drivers/nfc/pn544/i2c.c

664

chunk = (struct pn544_i2c_fw_secure_frame *) buf;

drivers/nfc/pn544/i2c.c

666

chunk->cmd = PN544_FW_CMD_SECURE_CHUNK_WRITE;

drivers/nfc/pn544/i2c.c

668

put_unaligned_be16(datalen, &chunk->be_datalen);

drivers/nfc/pn544/i2c.c

670

memcpy(chunk->data, data, datalen);

drivers/nfc/pn544/i2c.c

672

chunklen = sizeof(chunk->cmd) + sizeof(chunk->be_datalen) + datalen;

drivers/nvdimm/btt.c

520

unsigned long chunk = min(len, PAGE_SIZE);

drivers/nvdimm/btt.c

523

chunk, 0);

drivers/nvdimm/btt.c

526

len -= chunk;

drivers/nvdimm/btt.c

527

nsoff += chunk;

drivers/nvdimm/pfn_devs.c

394

unsigned long chunk = min(zero_len, PAGE_SIZE);

drivers/nvdimm/pfn_devs.c

397

chunk, 0);

drivers/nvdimm/pfn_devs.c

401

zero_len -= chunk;

drivers/nvdimm/pfn_devs.c

402

nsoff += chunk;

drivers/nvdimm/pmem.c

127

unsigned int chunk;

drivers/nvdimm/pmem.c

132

chunk = min_t(unsigned int, len, PAGE_SIZE - off);

drivers/nvdimm/pmem.c

133

memcpy_flushcache(pmem_addr, mem + off, chunk);

drivers/nvdimm/pmem.c

135

len -= chunk;

drivers/nvdimm/pmem.c

138

pmem_addr += chunk;

drivers/nvdimm/pmem.c

145

unsigned int chunk;

drivers/nvdimm/pmem.c

151

chunk = min_t(unsigned int, len, PAGE_SIZE - off);

drivers/nvdimm/pmem.c

152

rem = copy_mc_to_kernel(mem + off, pmem_addr, chunk);

drivers/nvdimm/pmem.c

156

len -= chunk;

drivers/nvdimm/pmem.c

159

pmem_addr += chunk;

drivers/nvmem/jz4780-efuse.c

108

memcpy(val, &buf[offset - start], chunk);

drivers/nvmem/jz4780-efuse.c

110

val += chunk;

drivers/nvmem/jz4780-efuse.c

111

offset += chunk;

drivers/nvmem/jz4780-efuse.c

112

bytes -= chunk;

drivers/nvmem/jz4780-efuse.c

76

size_t chunk = min(bytes, (start + JZ_EFU_READ_SIZE)

drivers/nvmem/rave-sp-eeprom.c

226

unsigned int chunk;

drivers/nvmem/rave-sp-eeprom.c

243

chunk = RAVE_SP_EEPROM_PAGE_SIZE - head;

drivers/nvmem/rave-sp-eeprom.c

252

chunk = RAVE_SP_EEPROM_PAGE_SIZE;

drivers/nvmem/rave-sp-eeprom.c

258

chunk = min(chunk, residue);

drivers/nvmem/rave-sp-eeprom.c

260

data, chunk);

drivers/nvmem/rave-sp-eeprom.c

264

residue -= chunk;

drivers/nvmem/rave-sp-eeprom.c

265

offset += chunk;

drivers/nvmem/rave-sp-eeprom.c

266

data += chunk;

drivers/s390/block/dasd.c

1141

char *data, *chunk;

drivers/s390/block/dasd.c

1152

data = chunk = dasd_alloc_chunk(&device->ccw_chunks, size);

drivers/s390/block/dasd.c

1154

if (!chunk)

drivers/s390/block/dasd.c

1161

cqr->mem_chunk = chunk;

drivers/s390/block/dasd_int.h

731

struct dasd_mchunk *chunk;

drivers/s390/block/dasd_int.h

734

chunk = (struct dasd_mchunk *) mem;

drivers/s390/block/dasd_int.h

735

chunk->size = size - sizeof(struct dasd_mchunk);

drivers/s390/block/dasd_int.h

736

list_add(&chunk->list, chunk_list);

drivers/s390/block/dasd_int.h

742

struct dasd_mchunk *chunk, *tmp;

drivers/s390/block/dasd_int.h

745

list_for_each_entry(chunk, chunk_list, list) {

drivers/s390/block/dasd_int.h

746

if (chunk->size < size)

drivers/s390/block/dasd_int.h

748

if (chunk->size > size + sizeof(struct dasd_mchunk)) {

drivers/s390/block/dasd_int.h

749

char *endaddr = (char *) (chunk + 1) + chunk->size;

drivers/s390/block/dasd_int.h

752

chunk->size -= size + sizeof(struct dasd_mchunk);

drivers/s390/block/dasd_int.h

753

chunk = tmp;

drivers/s390/block/dasd_int.h

755

list_del(&chunk->list);

drivers/s390/block/dasd_int.h

756

return (void *) (chunk + 1);

drivers/s390/block/dasd_int.h

764

struct dasd_mchunk *chunk, *tmp;

drivers/s390/block/dasd_int.h

767

chunk = (struct dasd_mchunk *)

drivers/s390/block/dasd_int.h

772

if (list_entry(p, struct dasd_mchunk, list) > chunk)

drivers/s390/block/dasd_int.h

779

if ((char *) (chunk + 1) + chunk->size == (char *) tmp) {

drivers/s390/block/dasd_int.h

781

chunk->size += tmp->size + sizeof(struct dasd_mchunk);

drivers/s390/block/dasd_int.h

787

if ((char *) (tmp + 1) + tmp->size == (char *) chunk) {

drivers/s390/block/dasd_int.h

788

tmp->size += chunk->size + sizeof(struct dasd_mchunk);

drivers/s390/block/dasd_int.h

792

__list_add(&chunk->list, left, left->next);

drivers/s390/cio/css.c

1059

struct gen_pool_chunk *chunk, void *data)

drivers/s390/cio/css.c

1061

size_t chunk_size = chunk->end_addr - chunk->start_addr + 1;

drivers/s390/cio/css.c

1064

(void *) chunk->start_addr,

drivers/s390/cio/css.c

1065

(dma_addr_t) chunk->phys_addr);

drivers/s390/cio/itcw.c

184

void *chunk;

drivers/s390/cio/itcw.c

196

chunk = fit_chunk(&start, end, sizeof(struct itcw), 1, 0);

drivers/s390/cio/itcw.c

197

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

198

return chunk;

drivers/s390/cio/itcw.c

199

itcw = chunk;

drivers/s390/cio/itcw.c

212

chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);

drivers/s390/cio/itcw.c

213

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

214

return chunk;

drivers/s390/cio/itcw.c

215

itcw->tcw = chunk;

drivers/s390/cio/itcw.c

220

chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);

drivers/s390/cio/itcw.c

221

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

222

return chunk;

drivers/s390/cio/itcw.c

223

itcw->intrg_tcw = chunk;

drivers/s390/cio/itcw.c

229

chunk = fit_chunk(&start, end, sizeof(struct tidaw) *

drivers/s390/cio/itcw.c

231

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

232

return chunk;

drivers/s390/cio/itcw.c

233

tcw_set_data(itcw->tcw, chunk, 1);

drivers/s390/cio/itcw.c

237

chunk = fit_chunk(&start, end, sizeof(struct tidaw) *

drivers/s390/cio/itcw.c

239

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

240

return chunk;

drivers/s390/cio/itcw.c

241

tcw_set_data(itcw->intrg_tcw, chunk, 1);

drivers/s390/cio/itcw.c

244

chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);

drivers/s390/cio/itcw.c

245

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

246

return chunk;

drivers/s390/cio/itcw.c

247

tsb_init(chunk);

drivers/s390/cio/itcw.c

248

tcw_set_tsb(itcw->tcw, chunk);

drivers/s390/cio/itcw.c

251

chunk = fit_chunk(&start, end, sizeof(struct tsb), 8, 0);

drivers/s390/cio/itcw.c

252

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

253

return chunk;

drivers/s390/cio/itcw.c

254

tsb_init(chunk);

drivers/s390/cio/itcw.c

255

tcw_set_tsb(itcw->intrg_tcw, chunk);

drivers/s390/cio/itcw.c

258

chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);

drivers/s390/cio/itcw.c

259

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

260

return chunk;

drivers/s390/cio/itcw.c

261

tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_DEFAULT);

drivers/s390/cio/itcw.c

262

tcw_set_tccb(itcw->tcw, chunk);

drivers/s390/cio/itcw.c

265

chunk = fit_chunk(&start, end, TCCB_MAX_SIZE, 8, 0);

drivers/s390/cio/itcw.c

266

if (IS_ERR(chunk))

drivers/s390/cio/itcw.c

267

return chunk;

drivers/s390/cio/itcw.c

268

tccb_init(chunk, TCCB_MAX_SIZE, TCCB_SAC_INTRG);

drivers/s390/cio/itcw.c

269

tcw_set_tccb(itcw->intrg_tcw, chunk);

drivers/s390/cio/itcw.c

270

tccb_add_dcw(chunk, TCCB_MAX_SIZE, DCW_CMD_INTRG, 0, NULL,

drivers/scsi/ips.h

716

IPS_CHUNK chunk[IPS_MAX_CHUNKS];

drivers/scsi/qla2xxx/qla_dbg.c

110

uint32_t *chunk = (uint32_t *)ha->gid_list;

drivers/scsi/qla2xxx/qla_dbg.c

183

chunk[j] : swab32(chunk[j]);

drivers/scsi/qla2xxx/qla_dbg.c

198

uint32_t *chunk = (uint32_t *)ha->gid_list;

drivers/scsi/qla2xxx/qla_dbg.c

266

chunk[j] : swab32(chunk[j]));

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

324

int out_width, out_height, chunk, rest, kmax, y, x, k, elm_start, elm, ofs;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

339

chunk = ISP_VEC_NELEMS >> host_stats->grid.deci_factor_log2;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

340

chunk = max(chunk, 1);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

347

kmax = (rest > chunk) ? chunk : rest;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

352

hi[elm + chunk * 0], lo[elm + chunk * 0]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

354

hi[elm + chunk * 1], lo[elm + chunk * 1]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

356

hi[elm + chunk * 2], lo[elm + chunk * 2]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

358

hi[elm + chunk * 3], lo[elm + chunk * 3]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

360

hi[elm + chunk * 4], lo[elm + chunk * 4]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

362

hi[elm + chunk * 5], lo[elm + chunk * 5]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

364

hi[elm + chunk * 6], lo[elm + chunk * 6]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

366

hi[elm + chunk * 7], lo[elm + chunk * 7]);

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

368

x += chunk;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

369

rest -= chunk;

drivers/thermal/ti-soc-thermal/ti-bandgap.c

848

void __iomem *chunk;

drivers/thermal/ti-soc-thermal/ti-bandgap.c

853

chunk = devm_ioremap_resource(&pdev->dev, res);

drivers/thermal/ti-soc-thermal/ti-bandgap.c

855

bgp->base = chunk;

drivers/thermal/ti-soc-thermal/ti-bandgap.c

856

if (IS_ERR(chunk))

drivers/thermal/ti-soc-thermal/ti-bandgap.c

857

return ERR_CAST(chunk);

drivers/tty/serial/qcom_geni_serial.c

1004

qcom_geni_serial_send_chunk_fifo(uport, chunk);

drivers/tty/serial/qcom_geni_serial.c

1005

port->tx_queued += chunk;

drivers/tty/serial/qcom_geni_serial.c

586

int chunk = min_t(int, bytes - i, BYTES_PER_FIFO_WORD);

drivers/tty/serial/qcom_geni_serial.c

589

i += chunk;

drivers/tty/serial/qcom_geni_serial.c

593

for (c = 0; c < chunk; c++) {

drivers/tty/serial/qcom_geni_serial.c

938

unsigned int chunk)

drivers/tty/serial/qcom_geni_serial.c

941

unsigned int tx_bytes, remaining = chunk;

drivers/tty/serial/qcom_geni_serial.c

966

unsigned int chunk;

drivers/tty/serial/qcom_geni_serial.c

989

chunk = min(avail, pending);

drivers/tty/serial/qcom_geni_serial.c

990

if (!chunk)

drivers/tty/tty_io.c

1000

size_t size = min(chunk, count);

drivers/tty/tty_io.c

955

size_t chunk, count = iov_iter_count(from);

drivers/tty/tty_io.c

975

chunk = 2048;

drivers/tty/tty_io.c

977

chunk = 65536;

drivers/tty/tty_io.c

978

if (count < chunk)

drivers/tty/tty_io.c

979

chunk = count;

drivers/tty/tty_io.c

982

if (tty->write_cnt < chunk) {

drivers/tty/tty_io.c

985

if (chunk < 1024)

drivers/tty/tty_io.c

986

chunk = 1024;

drivers/tty/tty_io.c

988

buf_chunk = kvmalloc(chunk, GFP_KERNEL | __GFP_RETRY_MAYFAIL);

drivers/tty/tty_io.c

994

tty->write_cnt = chunk;

drivers/usb/early/ehci-dbgp.c

910

int chunk;

drivers/usb/early/ehci-dbgp.c

935

for (chunk = 0; chunk < DBGP_MAX_PACKET && n > 0;

drivers/usb/early/ehci-dbgp.c

936

str++, chunk++, n--) {

drivers/usb/early/ehci-dbgp.c

939

buf[chunk] = '\r';

drivers/usb/early/ehci-dbgp.c

946

buf[chunk] = *str;

drivers/usb/early/ehci-dbgp.c

948

if (chunk > 0) {

drivers/usb/early/ehci-dbgp.c

950

dbgp_endpoint_out, buf, chunk);

drivers/usb/early/xhci-dbc.c

882

int chunk, ret;

drivers/usb/early/xhci-dbc.c

889

for (chunk = 0; chunk < XDBC_MAX_PACKET && n > 0; str++, chunk++, n--) {

drivers/usb/early/xhci-dbc.c

893

buf[chunk] = '\r';

drivers/usb/early/xhci-dbc.c

901

buf[chunk] = *str;

drivers/usb/early/xhci-dbc.c

904

if (chunk > 0) {

drivers/usb/early/xhci-dbc.c

905

ret = xdbc_bulk_write(buf, chunk);

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

179

unsigned int chunk;

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

202

chunk = req->req.length - req->req.actual;

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

203

if (chunk > ep->ep.maxpacket)

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

204

chunk = ep->ep.maxpacket;

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

205

else if ((chunk < ep->ep.maxpacket) || !req->req.zero)

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

209

chunk, req->last_desc, req->req.actual, ep->ep.maxpacket);

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

215

if (chunk && req->req.buf)

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

216

memcpy(ep->buf, req->req.buf + req->req.actual, chunk);

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

221

reg = VHUB_EP0_SET_TX_LEN(chunk);

drivers/usb/gadget/udc/aspeed-vhub/ep0.c

224

req->req.actual += chunk;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

174

unsigned int chunk;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

196

chunk = len - act;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

197

if (chunk <= ep->epn.chunk_max) {

drivers/usb/gadget/udc/aspeed-vhub/epn.c

206

if (!chunk || !req->req.zero || (chunk % ep->ep.maxpacket) != 0)

drivers/usb/gadget/udc/aspeed-vhub/epn.c

209

chunk = ep->epn.chunk_max;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

213

act, len, chunk, req->last_desc, d_num,

drivers/usb/gadget/udc/aspeed-vhub/epn.c

229

desc->w1 = cpu_to_le32(VHUB_DSC1_IN_SET_LEN(chunk));

drivers/usb/gadget/udc/aspeed-vhub/epn.c

234

req->act_count = act = act + chunk;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

44

unsigned int chunk;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

50

chunk = len - act;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

51

if (chunk > ep->ep.maxpacket)

drivers/usb/gadget/udc/aspeed-vhub/epn.c

52

chunk = ep->ep.maxpacket;

drivers/usb/gadget/udc/aspeed-vhub/epn.c

53

else if ((chunk < ep->ep.maxpacket) || !req->req.zero)

drivers/usb/gadget/udc/aspeed-vhub/epn.c

57

req, act, len, chunk, req->last_desc);

drivers/usb/gadget/udc/aspeed-vhub/epn.c

64

memcpy(ep->buf, req->req.buf + act, chunk);

drivers/usb/gadget/udc/aspeed-vhub/epn.c

76

writel(VHUB_EP_DMA_SET_TX_SIZE(chunk),

drivers/usb/gadget/udc/aspeed-vhub/epn.c

78

writel(VHUB_EP_DMA_SET_TX_SIZE(chunk) | VHUB_EP_DMA_SINGLE_KICK,

drivers/usb/gadget/udc/aspeed_udc.c

480

int chunk, count;

drivers/usb/gadget/udc/aspeed_udc.c

489

chunk = tx_len;

drivers/usb/gadget/udc/aspeed_udc.c

497

while (chunk >= 0 && !last && count < AST_UDC_DESCS_COUNT) {

drivers/usb/gadget/udc/aspeed_udc.c

501

if (chunk > ep->chunk_max) {

drivers/usb/gadget/udc/aspeed_udc.c

504

ep->descs[ep->descs_wptr].des_1 = chunk;

drivers/usb/gadget/udc/aspeed_udc.c

508

chunk -= ep->chunk_max;

drivers/usb/usb-skeleton.c

286

size_t chunk = min(available, count);

drivers/usb/usb-skeleton.c

306

chunk))

drivers/usb/usb-skeleton.c

309

rv = chunk;

drivers/usb/usb-skeleton.c

311

dev->bulk_in_copied += chunk;

drivers/usb/usb-skeleton.c

318

skel_do_read_io(dev, count - chunk);

drivers/vfio/pci/mlx5/cmd.c

138

MLX5_SET(query_vhca_migration_state_in, in, chunk, mvdev->chunk_mode);

drivers/zorro/zorro.c

104

u32 chunk = start>>Z2RAM_CHUNKSHIFT;

drivers/zorro/zorro.c

107

set_bit(chunk, zorro_unused_z2ram);

drivers/zorro/zorro.c

109

clear_bit(chunk, zorro_unused_z2ram);

fs/btrfs/block-group.c

530

u64 chunk = block_group->flags & BTRFS_BLOCK_GROUP_METADATA ?

fs/btrfs/block-group.c

532

u64 step = chunk << 1;

fs/btrfs/block-group.c

534

while (len > chunk) {

fs/btrfs/block-group.c

535

btrfs_remove_free_space(block_group, start, chunk);

fs/btrfs/disk-io.c

2334

struct btrfs_chunk *chunk;

fs/btrfs/disk-io.c

2355

chunk = (struct btrfs_chunk *)(sb->sys_chunk_array + cur);

fs/btrfs/disk-io.c

2356

num_stripes = btrfs_stack_chunk_num_stripes(chunk);

fs/btrfs/disk-io.c

2359

type = btrfs_stack_chunk_type(chunk);

fs/btrfs/disk-io.c

2366

ret = btrfs_check_chunk_valid(fs_info, NULL, chunk, key.offset,

fs/btrfs/print-tree.c

63

static void print_chunk(const struct extent_buffer *eb, struct btrfs_chunk *chunk)

fs/btrfs/print-tree.c

65

int num_stripes = btrfs_chunk_num_stripes(eb, chunk);

fs/btrfs/print-tree.c

68

btrfs_chunk_length(eb, chunk), btrfs_chunk_owner(eb, chunk),

fs/btrfs/print-tree.c

69

btrfs_chunk_type(eb, chunk), num_stripes);

fs/btrfs/print-tree.c

72

btrfs_stripe_devid_nr(eb, chunk, i),

fs/btrfs/print-tree.c

73

btrfs_stripe_offset_nr(eb, chunk, i));

fs/btrfs/relocation.c

4745

struct btrfs_chunk *chunk;

fs/btrfs/relocation.c

4766

chunk = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_chunk);

fs/btrfs/relocation.c

4767

btrfs_set_chunk_num_stripes(leaf, chunk, 0);

fs/btrfs/relocation.c

4768

btrfs_set_chunk_sub_stripes(leaf, chunk, 0);

fs/btrfs/relocation.c

4982

struct btrfs_chunk *chunk;

fs/btrfs/relocation.c

5010

chunk = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_chunk);

fs/btrfs/relocation.c

5011

btrfs_set_chunk_type(leaf, chunk, type);

fs/btrfs/tree-checker.c

1002

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1008

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1022

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1028

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1036

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1042

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1051

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1064

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1072

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1079

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1087

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

1104

struct btrfs_chunk *chunk,

fs/btrfs/tree-checker.c

1111

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1119

num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/tree-checker.c

1126

chunk_err(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

1133

return btrfs_check_chunk_valid(fs_info, leaf, chunk, key->offset,

fs/btrfs/tree-checker.c

2325

struct btrfs_chunk *chunk;

fs/btrfs/tree-checker.c

2349

chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

fs/btrfs/tree-checker.c

2350

ret = check_leaf_chunk_item(leaf, chunk, key, slot);

fs/btrfs/tree-checker.c

855

const struct btrfs_chunk *chunk, u64 logical,

fs/btrfs/tree-checker.c

871

(unsigned long)chunk) {

fs/btrfs/tree-checker.c

930

const struct btrfs_chunk *chunk, u64 logical,

fs/btrfs/tree-checker.c

948

length = btrfs_chunk_length(leaf, chunk);

fs/btrfs/tree-checker.c

949

stripe_len = btrfs_chunk_stripe_len(leaf, chunk);

fs/btrfs/tree-checker.c

950

num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/tree-checker.c

951

sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);

fs/btrfs/tree-checker.c

952

type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/tree-checker.c

953

chunk_sector_size = btrfs_chunk_sector_size(leaf, chunk);

fs/btrfs/tree-checker.c

955

length = btrfs_stack_chunk_length(chunk);

fs/btrfs/tree-checker.c

956

stripe_len = btrfs_stack_chunk_stripe_len(chunk);

fs/btrfs/tree-checker.c

957

num_stripes = btrfs_stack_chunk_num_stripes(chunk);

fs/btrfs/tree-checker.c

958

sub_stripes = btrfs_stack_chunk_sub_stripes(chunk);

fs/btrfs/tree-checker.c

959

type = btrfs_stack_chunk_type(chunk);

fs/btrfs/tree-checker.c

960

chunk_sector_size = btrfs_stack_chunk_sector_size(chunk);

fs/btrfs/tree-checker.c

968

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

973

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

979

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

985

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

991

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.c

997

chunk_err(fs_info, leaf, chunk, logical,

fs/btrfs/tree-checker.h

77

const struct btrfs_chunk *chunk, u64 logical,

fs/btrfs/volumes.c

3229

struct btrfs_chunk *chunk;

fs/btrfs/volumes.c

3251

chunk = (struct btrfs_chunk *)(ptr + len);

fs/btrfs/volumes.c

3252

num_stripes = btrfs_stack_chunk_num_stripes(chunk);

fs/btrfs/volumes.c

3679

struct btrfs_chunk *chunk;

fs/btrfs/volumes.c

3727

chunk = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/volumes.c

3729

chunk_type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4078

static bool chunk_devid_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4082

int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

4086

stripe = btrfs_stripe_nr(chunk, i);

fs/btrfs/volumes.c

4104

static bool chunk_drange_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4108

int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

4118

type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4122

stripe = btrfs_stripe_nr(chunk, i);

fs/btrfs/volumes.c

4127

stripe_length = btrfs_chunk_length(leaf, chunk);

fs/btrfs/volumes.c

4139

static bool chunk_vrange_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4143

chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)

fs/btrfs/volumes.c

4151

struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4154

int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

4177

static int should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunk *chunk,

fs/btrfs/volumes.c

4183

u64 chunk_type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4231

chunk_devid_filter(leaf, chunk, bargs)) {

fs/btrfs/volumes.c

4237

chunk_drange_filter(leaf, chunk, bargs)) {

fs/btrfs/volumes.c

4243

chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {

fs/btrfs/volumes.c

4249

chunk_stripes_range_filter(leaf, chunk, bargs)) {

fs/btrfs/volumes.c

4397

struct btrfs_chunk *chunk;

fs/btrfs/volumes.c

4486

chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

fs/btrfs/volumes.c

4487

chunk_type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

4491

btrfs_chunk_num_stripes(leaf, chunk) == 0) {

fs/btrfs/volumes.c

4503

ret = should_balance_chunk(leaf, chunk, found_key.offset);

fs/btrfs/volumes.c

5433

struct btrfs_chunk *chunk, int item_size)

fs/btrfs/volumes.c

5451

memcpy(ptr, chunk, item_size);

fs/btrfs/volumes.c

6184

struct btrfs_chunk *chunk;

fs/btrfs/volumes.c

6224

chunk = kzalloc(item_size, GFP_NOFS);

fs/btrfs/volumes.c

6225

if (unlikely(!chunk)) {

fs/btrfs/volumes.c

6239

stripe = &chunk->stripe;

fs/btrfs/volumes.c

6250

btrfs_set_stack_chunk_length(chunk, bg->length);

fs/btrfs/volumes.c

6251

btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID);

fs/btrfs/volumes.c

6252

btrfs_set_stack_chunk_stripe_len(chunk, BTRFS_STRIPE_LEN);

fs/btrfs/volumes.c

6253

btrfs_set_stack_chunk_type(chunk, map->type);

fs/btrfs/volumes.c

6254

btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);

fs/btrfs/volumes.c

6255

btrfs_set_stack_chunk_io_align(chunk, BTRFS_STRIPE_LEN);

fs/btrfs/volumes.c

6256

btrfs_set_stack_chunk_io_width(chunk, BTRFS_STRIPE_LEN);

fs/btrfs/volumes.c

6257

btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize);

fs/btrfs/volumes.c

6258

btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);

fs/btrfs/volumes.c

6264

ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);

fs/btrfs/volumes.c

6271

ret = btrfs_add_system_chunk(fs_info, &key, chunk, item_size);

fs/btrfs/volumes.c

6277

kfree(chunk);

fs/btrfs/volumes.c

7590

struct btrfs_chunk *chunk)

fs/btrfs/volumes.c

7606

length = btrfs_chunk_length(leaf, chunk);

fs/btrfs/volumes.c

7607

type = btrfs_chunk_type(leaf, chunk);

fs/btrfs/volumes.c

7609

num_stripes = btrfs_chunk_num_stripes(leaf, chunk);

fs/btrfs/volumes.c

7635

map->io_width = btrfs_chunk_io_width(leaf, chunk);

fs/btrfs/volumes.c

7636

map->io_align = btrfs_chunk_io_align(leaf, chunk);

fs/btrfs/volumes.c

7656

btrfs_stripe_offset_nr(leaf, chunk, i);

fs/btrfs/volumes.c

7657

devid = btrfs_stripe_devid_nr(leaf, chunk, i);

fs/btrfs/volumes.c

7660

btrfs_stripe_dev_uuid_nr(chunk, i),

fs/btrfs/volumes.c

7913

struct btrfs_chunk *chunk;

fs/btrfs/volumes.c

7931

chunk = (struct btrfs_chunk *)sb_array_offset;

fs/btrfs/volumes.c

7932

ASSERT(btrfs_chunk_type(sb, chunk) & BTRFS_BLOCK_GROUP_SYSTEM);

fs/btrfs/volumes.c

7934

len = btrfs_chunk_item_size(btrfs_chunk_num_stripes(sb, chunk));

fs/btrfs/volumes.c

7938

ret = read_one_chunk(&key, sb, chunk);

fs/btrfs/volumes.c

8089

struct btrfs_chunk *chunk;

fs/btrfs/volumes.c

8099

chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

fs/btrfs/volumes.c

8100

ret = read_one_chunk(&found_key, leaf, chunk);

fs/ext4/mballoc.c

814

ext4_grpblk_t chunk;

fs/ext4/mballoc.c

830

chunk = 1 << min;

fs/ext4/mballoc.c

838

len -= chunk;

fs/ext4/mballoc.c

839

first += chunk;

fs/gfs2/aops.c

458

size_t offset, chunk;

fs/gfs2/aops.c

468

chunk = min(size - copied, folio_size(folio) - offset);

fs/gfs2/aops.c

469

memcpy_from_folio(buf + copied, folio, offset, chunk);

fs/gfs2/aops.c

472

copied += chunk;

fs/gfs2/bmap.c

1355

u64 chunk;

fs/gfs2/bmap.c

1362

chunk = oldsize - newsize;

fs/gfs2/bmap.c

1363

if (chunk > max_chunk)

fs/gfs2/bmap.c

1364

chunk = max_chunk;

fs/gfs2/bmap.c

1367

if (offs && chunk > PAGE_SIZE)

fs/gfs2/bmap.c

1368

chunk = offs + ((chunk - offs) & PAGE_MASK);

fs/gfs2/bmap.c

1370

truncate_pagecache(inode, oldsize - chunk);

fs/gfs2/bmap.c

1371

oldsize -= chunk;

fs/gfs2/bmap.c

2406

loff_t chunk;

fs/gfs2/bmap.c

2409

chunk = length;

fs/gfs2/bmap.c

2410

if (chunk > max_chunk)

fs/gfs2/bmap.c

2411

chunk = max_chunk;

fs/gfs2/bmap.c

2414

if (offs && chunk > PAGE_SIZE)

fs/gfs2/bmap.c

2415

chunk = offs + ((chunk - offs) & PAGE_MASK);

fs/gfs2/bmap.c

2417

truncate_pagecache_range(inode, offset, chunk);

fs/gfs2/bmap.c

2418

offset += chunk;

fs/gfs2/bmap.c

2419

length -= chunk;

fs/iomap/buffered-io.c

1188

size_t chunk = mapping_max_folio_size(mapping);

fs/iomap/buffered-io.c

1202

offset = iter->pos & (chunk - 1);

fs/iomap/buffered-io.c

1203

bytes = min(chunk - offset, bytes);

fs/iomap/buffered-io.c

1274

if (chunk > PAGE_SIZE)

fs/iomap/buffered-io.c

1275

chunk /= 2;

fs/nfs/blocklayout/dev.c

258

u64 chunk;

fs/nfs/blocklayout/dev.c

263

chunk = div_u64(offset, dev->chunk_size);

fs/nfs/blocklayout/dev.c

264

disk_chunk = div_u64_rem(chunk, dev->nr_children, &chunk_idx);

fs/nfs/blocklayout/dev.c

274

offset = chunk * dev->chunk_size;

fs/ocfs2/ioctl.c

445

unsigned int offset = 0, cluster, chunk;

fs/ocfs2/ioctl.c

500

for (chunk = 0; chunk < chunks_in_group; chunk++) {

fs/ocfs2/quota_local.c

1074

list_add_tail(&chunk->qc_chunk, &oinfo->dqi_chunk);

fs/ocfs2/quota_local.c

1075

chunk->qc_num = list_entry(chunk->qc_chunk.prev,

fs/ocfs2/quota_local.c

1078

chunk->qc_headerbh = bh;

fs/ocfs2/quota_local.c

1080

return chunk;

fs/ocfs2/quota_local.c

1086

kmem_cache_free(ocfs2_qf_chunk_cachep, chunk);

fs/ocfs2/quota_local.c

1098

struct ocfs2_quota_chunk *chunk;

fs/ocfs2/quota_local.c

1111

chunk = list_entry(oinfo->dqi_chunk.prev,

fs/ocfs2/quota_local.c

1114

ol_quota_chunk_block(sb, chunk->qc_num) - 1;

fs/ocfs2/quota_local.c

1171

chunk->qc_headerbh,

fs/ocfs2/quota_local.c

1178

dchunk = (struct ocfs2_local_disk_chunk *)chunk->qc_headerbh->b_data;

fs/ocfs2/quota_local.c

1179

lock_buffer(chunk->qc_headerbh);

fs/ocfs2/quota_local.c

1181

unlock_buffer(chunk->qc_headerbh);

fs/ocfs2/quota_local.c

1182

ocfs2_journal_dirty(handle, chunk->qc_headerbh);

fs/ocfs2/quota_local.c

1198

return chunk;

fs/ocfs2/quota_local.c

1221

struct ocfs2_quota_chunk *chunk;

fs/ocfs2/quota_local.c

1230

chunk = ocfs2_find_free_entry(sb, type, &offset);

fs/ocfs2/quota_local.c

1231

if (!chunk) {

fs/ocfs2/quota_local.c

1232

chunk = ocfs2_extend_local_quota_file(sb, type, &offset);

fs/ocfs2/quota_local.c

1233

if (IS_ERR(chunk)) {

fs/ocfs2/quota_local.c

1234

status = PTR_ERR(chunk);

fs/ocfs2/quota_local.c

1237

} else if (IS_ERR(chunk)) {

fs/ocfs2/quota_local.c

1238

status = PTR_ERR(chunk);

fs/ocfs2/quota_local.c

1241

od->dq_local_off = ol_dqblk_off(sb, chunk->qc_num, offset);

fs/ocfs2/quota_local.c

1242

od->dq_chunk = chunk;

fs/ocfs2/quota_local.c

1244

ol_dqblk_block(sb, chunk->qc_num, offset),

fs/ocfs2/quota_local.c

1261

status = ocfs2_modify_bh(lqinode, chunk->qc_headerbh, olq_alloc_dquot,

fs/ocfs2/quota_local.c

296

int chunk,

fs/ocfs2/quota_local.c

304

rc->rc_chunk = chunk;

fs/ocfs2/quota_local.c

469

int bit, chunk;

fs/ocfs2/quota_local.c

477

chunk = rchunk->rc_chunk;

fs/ocfs2/quota_local.c

480

ol_quota_chunk_block(sb, chunk),

fs/ocfs2/quota_local.c

490

ol_dqblk_block(sb, chunk, bit),

fs/ocfs2/quota_local.c

497

ol_dqblk_block_off(sb, chunk, bit));

fs/ocfs2/quota_local.c

814

struct ocfs2_quota_chunk *chunk;

fs/ocfs2/quota_local.c

822

list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) {

fs/ocfs2/quota_local.c

824

(chunk->qc_headerbh->b_data);

fs/ocfs2/quota_local.c

825

if (chunk->qc_num < oinfo->dqi_chunks - 1) {

fs/ocfs2/quota_local.c

829

ol_quota_chunk_block(sb, chunk->qc_num) - 1)

fs/ocfs2/quota_local.c

924

struct ocfs2_quota_chunk *chunk = NULL, *iter;

fs/ocfs2/quota_local.c

932

chunk = iter;

fs/ocfs2/quota_local.c

936

if (!chunk)

fs/ocfs2/quota_local.c

939

if (chunk->qc_num < oinfo->dqi_chunks - 1) {

fs/ocfs2/quota_local.c

943

ol_quota_chunk_block(sb, chunk->qc_num) - 1)

fs/ocfs2/quota_local.c

951

" entries free (type=%d)\n", chunk->qc_num,

fs/ocfs2/quota_local.c

956

return chunk;

fs/ocfs2/quota_local.c

968

struct ocfs2_quota_chunk *chunk = NULL;

fs/ocfs2/quota_local.c

990

chunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS);

fs/ocfs2/quota_local.c

991

if (!chunk) {

fs/smb/client/smb2ops.c

1893

struct srv_copychunk *chunk;

fs/smb/client/smb2ops.c

1947

chunk = &cc_req->Chunks[chunks++];

fs/smb/client/smb2ops.c

1949

chunk->SourceOffset = cpu_to_le64(src_off);

fs/smb/client/smb2ops.c

1950

chunk->TargetOffset = cpu_to_le64(dst_off);

fs/smb/client/smb2ops.c

1954

chunk->Length = cpu_to_le32(chunk_bytes);

fs/splice.c

327

size_t used, npages, chunk, remain, keep = 0;

fs/splice.c

351

chunk = min_t(size_t, PAGE_SIZE, remain);

fs/splice.c

354

bv[i].bv_len = chunk;

fs/splice.c

355

remain -= chunk;

fs/splice.c

385

chunk = min_t(size_t, remain, PAGE_SIZE);

fs/splice.c

390

.len = chunk,

fs/splice.c

393

remain -= chunk;

fs/xfs/xfs_zone_gc.c

1002

struct xfs_gc_bio *chunk;

fs/xfs/xfs_zone_gc.c

1015

chunk = container_of(bio, struct xfs_gc_bio, bio);

fs/xfs/xfs_zone_gc.c

1016

chunk->data = data;

fs/xfs/xfs_zone_gc.c

1017

WRITE_ONCE(chunk->state, XFS_GC_BIO_NEW);

fs/xfs/xfs_zone_gc.c

1018

list_add_tail(&chunk->entry, &data->resetting);

fs/xfs/xfs_zone_gc.c

1035

struct xfs_gc_bio *chunk, *next;

fs/xfs/xfs_zone_gc.c

1049

list_for_each_entry_safe(chunk, next, &data->resetting, entry) {

fs/xfs/xfs_zone_gc.c

1050

if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)

fs/xfs/xfs_zone_gc.c

1053

xfs_zone_gc_finish_reset(chunk);

fs/xfs/xfs_zone_gc.c

1056

list_for_each_entry_safe(chunk, next, &data->writing, entry) {

fs/xfs/xfs_zone_gc.c

1057

if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)

fs/xfs/xfs_zone_gc.c

1060

xfs_zone_gc_finish_chunk(chunk);

fs/xfs/xfs_zone_gc.c

1064

list_for_each_entry_safe(chunk, next, &data->reading, entry) {

fs/xfs/xfs_zone_gc.c

1065

if (READ_ONCE(chunk->state) != XFS_GC_BIO_DONE)

fs/xfs/xfs_zone_gc.c

1068

xfs_zone_gc_write_chunk(chunk);

fs/xfs/xfs_zone_gc.c

604

struct xfs_gc_bio *chunk =

fs/xfs/xfs_zone_gc.c

606

struct xfs_zone_gc_data *data = chunk->data;

fs/xfs/xfs_zone_gc.c

608

WRITE_ONCE(chunk->state, XFS_GC_BIO_DONE);

fs/xfs/xfs_zone_gc.c

655

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

657

struct xfs_zone_gc_data *data = chunk->data;

fs/xfs/xfs_zone_gc.c

658

unsigned int len = chunk->len;

fs/xfs/xfs_zone_gc.c

665

bio_add_folio_nofail(&chunk->bio,

fs/xfs/xfs_zone_gc.c

705

struct xfs_gc_bio *chunk;

fs/xfs/xfs_zone_gc.c

730

chunk = container_of(bio, struct xfs_gc_bio, bio);

fs/xfs/xfs_zone_gc.c

731

chunk->ip = ip;

fs/xfs/xfs_zone_gc.c

732

chunk->offset = XFS_FSB_TO_B(mp, irec.rm_offset);

fs/xfs/xfs_zone_gc.c

733

chunk->len = XFS_FSB_TO_B(mp, irec.rm_blockcount);

fs/xfs/xfs_zone_gc.c

734

chunk->old_startblock =

fs/xfs/xfs_zone_gc.c

736

chunk->new_daddr = daddr;

fs/xfs/xfs_zone_gc.c

737

chunk->is_seq = is_seq;

fs/xfs/xfs_zone_gc.c

738

chunk->data = data;

fs/xfs/xfs_zone_gc.c

739

chunk->oz = data->oz;

fs/xfs/xfs_zone_gc.c

740

chunk->victim_rtg = iter->victim_rtg;

fs/xfs/xfs_zone_gc.c

741

atomic_inc(&rtg_group(chunk->victim_rtg)->xg_active_ref);

fs/xfs/xfs_zone_gc.c

742

atomic_inc(&chunk->victim_rtg->rtg_gccount);

fs/xfs/xfs_zone_gc.c

744

bio->bi_iter.bi_sector = xfs_rtb_to_daddr(mp, chunk->old_startblock);

fs/xfs/xfs_zone_gc.c

746

xfs_zone_gc_add_data(chunk);

fs/xfs/xfs_zone_gc.c

748

(data->scratch_head + chunk->len) % data->scratch_size;

fs/xfs/xfs_zone_gc.c

749

data->scratch_available -= chunk->len;

fs/xfs/xfs_zone_gc.c

753

WRITE_ONCE(chunk->state, XFS_GC_BIO_NEW);

fs/xfs/xfs_zone_gc.c

754

list_add_tail(&chunk->entry, &data->reading);

fs/xfs/xfs_zone_gc.c

763

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

765

atomic_dec(&chunk->victim_rtg->rtg_gccount);

fs/xfs/xfs_zone_gc.c

766

xfs_rtgroup_rele(chunk->victim_rtg);

fs/xfs/xfs_zone_gc.c

767

list_del(&chunk->entry);

fs/xfs/xfs_zone_gc.c

768

xfs_open_zone_put(chunk->oz);

fs/xfs/xfs_zone_gc.c

769

xfs_irele(chunk->ip);

fs/xfs/xfs_zone_gc.c

770

bio_put(&chunk->bio);

fs/xfs/xfs_zone_gc.c

776

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

778

if (chunk->is_seq) {

fs/xfs/xfs_zone_gc.c

779

chunk->bio.bi_opf &= ~REQ_OP_WRITE;

fs/xfs/xfs_zone_gc.c

780

chunk->bio.bi_opf |= REQ_OP_ZONE_APPEND;

fs/xfs/xfs_zone_gc.c

782

chunk->bio.bi_iter.bi_sector = chunk->new_daddr;

fs/xfs/xfs_zone_gc.c

783

chunk->bio.bi_end_io = xfs_zone_gc_end_io;

fs/xfs/xfs_zone_gc.c

784

submit_bio(&chunk->bio);

fs/xfs/xfs_zone_gc.c

790

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

793

&bdev_get_queue(chunk->bio.bi_bdev)->limits;

fs/xfs/xfs_zone_gc.c

800

if (!chunk->is_seq)

fs/xfs/xfs_zone_gc.c

803

split_sectors = bio_split_rw_at(&chunk->bio, lim, &nsegs,

fs/xfs/xfs_zone_gc.c

813

split = bio_split(&chunk->bio, split_sectors, GFP_NOFS, &data->bio_set);

fs/xfs/xfs_zone_gc.c

816

ihold(VFS_I(chunk->ip));

fs/xfs/xfs_zone_gc.c

817

split_chunk->ip = chunk->ip;

fs/xfs/xfs_zone_gc.c

818

split_chunk->is_seq = chunk->is_seq;

fs/xfs/xfs_zone_gc.c

819

split_chunk->offset = chunk->offset;

fs/xfs/xfs_zone_gc.c

821

split_chunk->old_startblock = chunk->old_startblock;

fs/xfs/xfs_zone_gc.c

822

split_chunk->new_daddr = chunk->new_daddr;

fs/xfs/xfs_zone_gc.c

823

split_chunk->oz = chunk->oz;

fs/xfs/xfs_zone_gc.c

824

atomic_inc(&chunk->oz->oz_ref);

fs/xfs/xfs_zone_gc.c

826

split_chunk->victim_rtg = chunk->victim_rtg;

fs/xfs/xfs_zone_gc.c

827

atomic_inc(&rtg_group(chunk->victim_rtg)->xg_active_ref);

fs/xfs/xfs_zone_gc.c

828

atomic_inc(&chunk->victim_rtg->rtg_gccount);

fs/xfs/xfs_zone_gc.c

830

chunk->offset += split_len;

fs/xfs/xfs_zone_gc.c

831

chunk->len -= split_len;

fs/xfs/xfs_zone_gc.c

832

chunk->old_startblock += XFS_B_TO_FSB(data->mp, split_len);

fs/xfs/xfs_zone_gc.c

836

list_add_tail(&split_chunk->entry, &chunk->entry);

fs/xfs/xfs_zone_gc.c

842

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

844

struct xfs_zone_gc_data *data = chunk->data;

fs/xfs/xfs_zone_gc.c

845

struct xfs_mount *mp = chunk->ip->i_mount;

fs/xfs/xfs_zone_gc.c

848

if (chunk->bio.bi_status)

fs/xfs/xfs_zone_gc.c

851

xfs_zone_gc_free_chunk(chunk);

fs/xfs/xfs_zone_gc.c

856

XFS_STATS_ADD(mp, xs_gc_bytes, chunk->len);

fs/xfs/xfs_zone_gc.c

858

WRITE_ONCE(chunk->state, XFS_GC_BIO_NEW);

fs/xfs/xfs_zone_gc.c

859

list_move_tail(&chunk->entry, &data->writing);

fs/xfs/xfs_zone_gc.c

861

bio_reuse(&chunk->bio, REQ_OP_WRITE);

fs/xfs/xfs_zone_gc.c

862

while ((split_chunk = xfs_zone_gc_split_write(data, chunk)))

fs/xfs/xfs_zone_gc.c

864

xfs_zone_gc_submit_write(data, chunk);

fs/xfs/xfs_zone_gc.c

869

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

872

struct xfs_zone_gc_data *data = chunk->data;

fs/xfs/xfs_zone_gc.c

873

struct xfs_inode *ip = chunk->ip;

fs/xfs/xfs_zone_gc.c

877

if (chunk->bio.bi_status)

fs/xfs/xfs_zone_gc.c

880

xfs_zone_gc_free_chunk(chunk);

fs/xfs/xfs_zone_gc.c

885

(data->scratch_tail + chunk->len) % data->scratch_size;

fs/xfs/xfs_zone_gc.c

886

data->scratch_available += chunk->len;

fs/xfs/xfs_zone_gc.c

904

if (chunk->is_seq)

fs/xfs/xfs_zone_gc.c

905

chunk->new_daddr = chunk->bio.bi_iter.bi_sector;

fs/xfs/xfs_zone_gc.c

906

error = xfs_zoned_end_io(ip, chunk->offset, chunk->len,

fs/xfs/xfs_zone_gc.c

907

chunk->new_daddr, chunk->oz, chunk->old_startblock);

fs/xfs/xfs_zone_gc.c

911

xfs_zone_gc_free_chunk(chunk);

fs/xfs/xfs_zone_gc.c

916

struct xfs_gc_bio *chunk)

fs/xfs/xfs_zone_gc.c

918

struct xfs_rtgroup *rtg = chunk->bio.bi_private;

fs/xfs/xfs_zone_gc.c

922

if (chunk->bio.bi_status) {

fs/xfs/xfs_zone_gc.c

932

list_del(&chunk->entry);

fs/xfs/xfs_zone_gc.c

933

bio_put(&chunk->bio);

include/drm/display/drm_dp_mst_helper.h

171

u8 chunk[48];

include/drm/display/drm_dp_mst_helper.h

500

u8 chunk[48];

include/linux/dmaengine.h

1351

struct data_chunk *chunk)

include/linux/dmaengine.h

1354

chunk->icg, chunk->dst_icg);

include/linux/dmaengine.h

1358

struct data_chunk *chunk)

include/linux/dmaengine.h

1361

chunk->icg, chunk->src_icg);

include/linux/highmem.h

509

size_t chunk = len;

include/linux/highmem.h

512

chunk > PAGE_SIZE - offset_in_page(dst_off))

include/linux/highmem.h

513

chunk = PAGE_SIZE - offset_in_page(dst_off);

include/linux/highmem.h

515

chunk > PAGE_SIZE - offset_in_page(src_off))

include/linux/highmem.h

516

chunk = PAGE_SIZE - offset_in_page(src_off);

include/linux/highmem.h

517

memcpy(dst, src, chunk);

include/linux/highmem.h

521

dst_off += chunk;

include/linux/highmem.h

522

src_off += chunk;

include/linux/highmem.h

523

len -= chunk;

include/linux/highmem.h

582

size_t chunk = len;

include/linux/highmem.h

585

chunk > PAGE_SIZE - offset_in_page(offset))

include/linux/highmem.h

586

chunk = PAGE_SIZE - offset_in_page(offset);

include/linux/highmem.h

587

memcpy(to, from, chunk);

include/linux/highmem.h

590

to += chunk;

include/linux/highmem.h

591

offset += chunk;

include/linux/highmem.h

592

len -= chunk;

include/linux/highmem.h

610

size_t chunk = len;

include/linux/highmem.h

613

chunk > PAGE_SIZE - offset_in_page(offset))

include/linux/highmem.h

614

chunk = PAGE_SIZE - offset_in_page(offset);

include/linux/highmem.h

615

memcpy(to, from, chunk);

include/linux/highmem.h

618

from += chunk;

include/linux/highmem.h

619

offset += chunk;

include/linux/highmem.h

620

len -= chunk;

include/linux/mlx5/mlx5_ifc.h

13372

u8 chunk[0x1];

include/linux/sunrpc/svc_rdma_pcl.h

100

pos <= &(chunk)->ch_segments[(chunk)->ch_segcount - 1]; \

include/linux/sunrpc/svc_rdma_pcl.h

110

pcl_chunk_end_offset(const struct svc_rdma_chunk *chunk)

include/linux/sunrpc/svc_rdma_pcl.h

112

return xdr_align_size(chunk->ch_position + chunk->ch_payload_length);

include/linux/sunrpc/svc_rdma_pcl.h

76

pcl_next_chunk(const struct svc_rdma_pcl *pcl, struct svc_rdma_chunk *chunk)

include/linux/sunrpc/svc_rdma_pcl.h

78

if (list_is_last(&chunk->ch_list, &pcl->cl_chunks))

include/linux/sunrpc/svc_rdma_pcl.h

80

return list_next_entry(chunk, ch_list);

include/linux/sunrpc/svc_rdma_pcl.h

98

#define pcl_for_each_segment(pos, chunk) \

include/linux/sunrpc/svc_rdma_pcl.h

99

for (pos = &(chunk)->ch_segments[0]; \

include/net/sctp/auth.h

82

int sctp_auth_send_cid(enum sctp_cid chunk,

include/net/sctp/auth.h

84

int sctp_auth_recv_cid(enum sctp_cid chunk,

include/net/sctp/command.h

116

struct sctp_chunk *chunk;

include/net/sctp/command.h

157

SCTP_ARG_CONSTRUCTOR(CHUNK, struct sctp_chunk *, chunk)

include/net/sctp/constants.h

117

enum sctp_cid chunk;

include/net/sctp/constants.h

128

SCTP_SUBTYPE_CONSTRUCTOR(CHUNK, enum sctp_cid, chunk)

include/net/sctp/sctp.h

414

static inline bool sctp_chunk_pending(const struct sctp_chunk *chunk)

include/net/sctp/sctp.h

416

return !list_empty(&chunk->list);

include/net/sctp/sctp.h

424

#define sctp_walk_params(pos, chunk)\

include/net/sctp/sctp.h

425

_sctp_walk_params((pos), (chunk), ntohs((chunk)->chunk_hdr.length))

include/net/sctp/sctp.h

427

#define _sctp_walk_params(pos, chunk, end)\

include/net/sctp/sctp.h

428

for (pos.v = (u8 *)(chunk + 1);\

include/net/sctp/sctp.h

430

(void *)chunk + end) &&\

include/net/sctp/sctp.h

431

pos.v <= (void *)chunk + end - ntohs(pos.p->length) &&\

include/net/sctp/sctp.h

447

#define sctp_walk_fwdtsn(pos, chunk)\

include/net/sctp/sctp.h

448

_sctp_walk_fwdtsn((pos), (chunk), ntohs((chunk)->chunk_hdr->length) - sizeof(struct sctp_fwdtsn_chunk))

include/net/sctp/sctp.h

450

#define _sctp_walk_fwdtsn(pos, chunk, end)\

include/net/sctp/sctp.h

451

for (pos = (void *)(chunk->subh.fwdtsn_hdr + 1);\

include/net/sctp/sctp.h

452

(void *)pos <= (void *)(chunk->subh.fwdtsn_hdr + 1) + end - sizeof(struct sctp_fwdtsn_skip);\

include/net/sctp/sm.h

333

static inline __u16 sctp_data_size(struct sctp_chunk *chunk)

include/net/sctp/sm.h

337

size = ntohs(chunk->chunk_hdr->length);

include/net/sctp/sm.h

338

size -= sctp_datachk_len(&chunk->asoc->stream);

include/net/sctp/sm.h

383

if (ntohl(chunk->sctp_hdr->vtag) != asoc->c.my_vtag)

include/net/sctp/sm.h

386

chunk->transport->encap_port = SCTP_INPUT_CB(chunk->skb)->encap_port;

include/net/sctp/sm.h

418

if ((!sctp_test_T_bit(chunk) &&

include/net/sctp/sm.h

419

(ntohl(chunk->sctp_hdr->vtag) == asoc->c.my_vtag)) ||

include/net/sctp/sm.h

420

(sctp_test_T_bit(chunk) && asoc->c.peer_vtag &&

include/net/sctp/sm.h

421

(ntohl(chunk->sctp_hdr->vtag) == asoc->c.peer_vtag))) {

include/net/sctp/stream_interleave.h

26

void (*assign_number)(struct sctp_chunk *chunk);

include/net/sctp/stream_interleave.h

27

bool (*validate_data)(struct sctp_chunk *chunk);

include/net/sctp/stream_interleave.h

29

struct sctp_chunk *chunk, gfp_t gfp);

include/net/sctp/stream_interleave.h

33

struct sctp_chunk *chunk, gfp_t gfp);

include/net/sctp/stream_interleave.h

38

bool (*validate_ftsn)(struct sctp_chunk *chunk);

include/net/sctp/stream_interleave.h

41

struct sctp_chunk *chunk);

include/net/sctp/stream_sched.h

37

void (*dequeue_done)(struct sctp_outq *q, struct sctp_chunk *chunk);

include/net/sctp/structs.h

1111

void sctp_outq_tail(struct sctp_outq *, struct sctp_chunk *chunk, gfp_t);

include/net/sctp/structs.h

1137

struct sctp_chunk *chunk;

include/net/sctp/structs.h

1150

const struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;

include/net/sctp/structs.h

1152

return chunk->head_skb ? : skb;

include/net/sctp/structs.h

1361

struct sctp_chunk *chunk, struct sctp_chunk **err_chunk);

include/net/sctp/structs.h

1362

int sctp_process_init(struct sctp_association *, struct sctp_chunk *chunk,

include/net/sctp/structs.h

655

#define sctp_chunk_retransmitted(chunk) (chunk->sent_count > 1)

include/net/sctp/structs.h

658

int sctp_user_addto_chunk(struct sctp_chunk *chunk, int len,

include/net/sctp/structs.h

667

const union sctp_addr *sctp_source(const struct sctp_chunk *chunk);

include/net/sctp/structs.h

730

struct sctp_chunk *chunk,

include/net/sctp/structs.h

733

struct sctp_chunk *chunk);

include/net/sctp/ulpevent.h

100

struct sctp_chunk *chunk,

include/net/sctp/ulpevent.h

119

struct sctp_chunk *chunk,

include/net/sctp/ulpevent.h

40

struct sctp_chunk *chunk;

include/net/sctp/ulpevent.h

80

struct sctp_chunk *chunk,

include/net/sctp/ulpevent.h

88

struct sctp_chunk *chunk,

include/net/sctp/ulpevent.h

93

struct sctp_chunk *chunk,

include/trace/events/rpcrdma.h

1682

const struct svc_rdma_chunk *chunk,

include/trace/events/rpcrdma.h

1686

TP_ARGS(cid, chunk, segment),

include/trace/events/rpcrdma.h

1701

__entry->segno = chunk->ch_segcount;

include/trace/events/rpcrdma.h

1702

__entry->position = chunk->ch_position;

include/trace/events/rpcrdma.h

1718

const struct svc_rdma_chunk *chunk,

include/trace/events/rpcrdma.h

1722

TP_ARGS(cid, chunk, segno),

include/trace/events/rpcrdma.h

1735

&chunk->ch_segments[segno];

include/trace/events/rpcrdma.h

1780

DEFINE_ERROR_EVENT(chunk);

include/trace/events/sctp.h

54

struct sctp_chunk *chunk),

include/trace/events/sctp.h

56

TP_ARGS(ep, asoc, chunk),

include/trace/events/sctp.h

69

struct sk_buff *skb = chunk->skb;

kernel/audit.h

301

extern void audit_put_chunk(struct audit_chunk *chunk);

kernel/audit.h

302

extern bool audit_tree_match(struct audit_chunk *chunk,

kernel/audit_tree.c

1008

static void evict_chunk(struct audit_chunk *chunk)

kernel/audit_tree.c

1017

while (!list_empty(&chunk->trees)) {

kernel/audit_tree.c

1018

owner = list_entry(chunk->trees.next,

kernel/audit_tree.c

1033

list_del_rcu(&chunk->hash);

kernel/audit_tree.c

1034

for (n = 0; n < chunk->count; n++)

kernel/audit_tree.c

1035

list_del_init(&chunk->owners[n].list);

kernel/audit_tree.c

1052

struct audit_chunk *chunk;

kernel/audit_tree.c

1056

chunk = mark_chunk(mark);

kernel/audit_tree.c

1060

if (chunk) {

kernel/audit_tree.c

1061

evict_chunk(chunk);

kernel/audit_tree.c

1062

audit_mark_put_chunk(chunk);

kernel/audit_tree.c

130

static void free_chunk(struct audit_chunk *chunk)

kernel/audit_tree.c

134

for (i = 0; i < chunk->count; i++) {

kernel/audit_tree.c

135

if (chunk->owners[i].owner)

kernel/audit_tree.c

136

put_tree(chunk->owners[i].owner);

kernel/audit_tree.c

138

kfree(chunk);

kernel/audit_tree.c

141

void audit_put_chunk(struct audit_chunk *chunk)

kernel/audit_tree.c

143

if (atomic_long_dec_and_test(&chunk->refs))

kernel/audit_tree.c

144

free_chunk(chunk);

kernel/audit_tree.c

149

struct audit_chunk *chunk = container_of(rcu, struct audit_chunk, head);

kernel/audit_tree.c

150

audit_put_chunk(chunk);

kernel/audit_tree.c

158

static void audit_mark_put_chunk(struct audit_chunk *chunk)

kernel/audit_tree.c

160

call_rcu(&chunk->head, __put_chunk);

kernel/audit_tree.c

170

return audit_mark(mark)->chunk;

kernel/audit_tree.c

192

struct audit_chunk *chunk;

kernel/audit_tree.c

195

chunk = kzalloc_flex(*chunk, owners, count);

kernel/audit_tree.c

196

if (!chunk)

kernel/audit_tree.c

199

INIT_LIST_HEAD(&chunk->hash);

kernel/audit_tree.c

200

INIT_LIST_HEAD(&chunk->trees);

kernel/audit_tree.c

201

chunk->count = count;

kernel/audit_tree.c

202

atomic_long_set(&chunk->refs, 1);

kernel/audit_tree.c

204

INIT_LIST_HEAD(&chunk->owners[i].list);

kernel/audit_tree.c

205

chunk->owners[i].index = i;

kernel/audit_tree.c

207

return chunk;

kernel/audit_tree.c

228

static void insert_hash(struct audit_chunk *chunk)

kernel/audit_tree.c

238

WARN_ON_ONCE(!chunk->key);

kernel/audit_tree.c

239

list = chunk_hash(chunk->key);

kernel/audit_tree.c

240

list_add_rcu(&chunk->hash, list);

kernel/audit_tree.c

263

bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree)

kernel/audit_tree.c

266

for (n = 0; n < chunk->count; n++)

kernel/audit_tree.c

267

if (chunk->owners[n].owner == tree)

kernel/audit_tree.c

282

struct audit_chunk *chunk)

kernel/audit_tree.c

288

audit_mark(mark)->chunk = chunk;

kernel/audit_tree.c

289

if (chunk)

kernel/audit_tree.c

290

chunk->mark = mark;

kernel/audit_tree.c

327

static void remove_chunk_node(struct audit_chunk *chunk, struct audit_node *p)

kernel/audit_tree.c

331

if (owner->root == chunk) {

kernel/audit_tree.c

340

static int chunk_count_trees(struct audit_chunk *chunk)

kernel/audit_tree.c

345

for (i = 0; i < chunk->count; i++)

kernel/audit_tree.c

346

if (chunk->owners[i].owner)

kernel/audit_tree.c

351

static void untag_chunk(struct audit_chunk *chunk, struct fsnotify_mark *mark)

kernel/audit_tree.c

362

mark_chunk(mark) != chunk)

kernel/audit_tree.c

365

size = chunk_count_trees(chunk);

kernel/audit_tree.c

368

list_del_init(&chunk->trees);

kernel/audit_tree.c

369

list_del_rcu(&chunk->hash);

kernel/audit_tree.c

374

audit_mark_put_chunk(chunk);

kernel/audit_tree.c

388

replace_chunk(new, chunk);

kernel/audit_tree.c

391

audit_mark_put_chunk(chunk);

kernel/audit_tree.c

402

struct audit_chunk *chunk = alloc_chunk(1);

kernel/audit_tree.c

404

if (!chunk) {

kernel/audit_tree.c

412

kfree(chunk);

kernel/audit_tree.c

419

kfree(chunk);

kernel/audit_tree.c

42

struct audit_chunk *chunk;

kernel/audit_tree.c

430

kfree(chunk);

kernel/audit_tree.c

433

replace_mark_chunk(mark, chunk);

kernel/audit_tree.c

434

chunk->owners[0].index = (1U << 31);

kernel/audit_tree.c

435

chunk->owners[0].owner = tree;

kernel/audit_tree.c

437

list_add(&chunk->owners[0].list, &tree->chunks);

kernel/audit_tree.c

439

tree->root = chunk;

kernel/audit_tree.c

440

list_add(&tree->same_root, &chunk->trees);

kernel/audit_tree.c

442

chunk->key = inode_to_key(inode);

kernel/audit_tree.c

447

insert_hash(chunk);

kernel/audit_tree.c

463

struct audit_chunk *chunk, *old;

kernel/audit_tree.c

490

chunk = alloc_chunk(old->count + 1);

kernel/audit_tree.c

491

if (!chunk) {

kernel/audit_tree.c

502

kfree(chunk);

kernel/audit_tree.c

505

p = &chunk->owners[chunk->count - 1];

kernel/audit_tree.c

506

p->index = (chunk->count - 1) | (1U<<31);

kernel/audit_tree.c

511

tree->root = chunk;

kernel/audit_tree.c

512

list_add(&tree->same_root, &chunk->trees);

kernel/audit_tree.c

518

replace_chunk(chunk, old);

kernel/audit_tree.c

576

struct audit_chunk *chunk;

kernel/audit_tree.c

583

chunk = find_chunk(p);

kernel/audit_tree.c

584

mark = chunk->mark;

kernel/audit_tree.c

585

remove_chunk_node(chunk, p);

kernel/audit_tree.c

592

untag_chunk(chunk, mark);

kernel/audit_tree.c

703

struct audit_chunk *chunk = find_chunk(node);

kernel/audit_tree.c

708

if (inode_to_key(inode) == chunk->key) {

kernel/auditsc.c

2064

struct audit_chunk *chunk;

kernel/auditsc.c

2073

chunk = audit_tree_lookup(inode);

kernel/auditsc.c

2075

if (!chunk)

kernel/auditsc.c

2077

if (likely(put_tree_ref(context, chunk)))

kernel/auditsc.c

2082

audit_put_chunk(chunk);

kernel/auditsc.c

2086

put_tree_ref(context, chunk);

kernel/auditsc.c

2110

struct audit_chunk *chunk;

kernel/auditsc.c

2112

chunk = audit_tree_lookup(inode);

kernel/auditsc.c

2113

if (chunk) {

kernel/auditsc.c

2114

if (unlikely(!put_tree_ref(context, chunk))) {

kernel/auditsc.c

2115

drop = chunk;

kernel/auditsc.c

232

static int put_tree_ref(struct audit_context *ctx, struct audit_chunk *chunk)

kernel/auditsc.c

238

p->c[--left] = chunk;

kernel/auditsc.c

246

p->c[30] = chunk;

kernel/liveupdate/kexec_handover.c

1011

struct kho_vmalloc_chunk *chunk;

kernel/liveupdate/kexec_handover.c

1014

chunk = (struct kho_vmalloc_chunk *)get_zeroed_page(GFP_KERNEL);

kernel/liveupdate/kexec_handover.c

1015

if (!chunk)

kernel/liveupdate/kexec_handover.c

1018

err = kho_preserve_pages(virt_to_page(chunk), 1);

kernel/liveupdate/kexec_handover.c

1022

KHOSER_STORE_PTR(cur->hdr.next, chunk);

kernel/liveupdate/kexec_handover.c

1023

return chunk;

kernel/liveupdate/kexec_handover.c

1026

free_page((unsigned long)chunk);

kernel/liveupdate/kexec_handover.c

1030

static void kho_vmalloc_unpreserve_chunk(struct kho_vmalloc_chunk *chunk,

kernel/liveupdate/kexec_handover.c

1034

unsigned long pfn = PHYS_PFN(virt_to_phys(chunk));

kernel/liveupdate/kexec_handover.c

1038

for (int i = 0; i < ARRAY_SIZE(chunk->phys) && chunk->phys[i]; i++) {

kernel/liveupdate/kexec_handover.c

1039

pfn = PHYS_PFN(chunk->phys[i]);

kernel/liveupdate/kexec_handover.c

1061

struct kho_vmalloc_chunk *chunk;

kernel/liveupdate/kexec_handover.c

1076

chunk = new_vmalloc_chunk(NULL);

kernel/liveupdate/kexec_handover.c

1077

if (!chunk)

kernel/liveupdate/kexec_handover.c

1079

KHOSER_STORE_PTR(preservation->first, chunk);

kernel/liveupdate/kexec_handover.c

1089

chunk->phys[idx++] = phys;

kernel/liveupdate/kexec_handover.c

1090

if (idx == ARRAY_SIZE(chunk->phys)) {

kernel/liveupdate/kexec_handover.c

1091

chunk = new_vmalloc_chunk(chunk);

kernel/liveupdate/kexec_handover.c

1092

if (!chunk) {

kernel/liveupdate/kexec_handover.c

1121

struct kho_vmalloc_chunk *chunk = KHOSER_LOAD_PTR(preservation->first);

kernel/liveupdate/kexec_handover.c

1123

while (chunk) {

kernel/liveupdate/kexec_handover.c

1124

struct kho_vmalloc_chunk *tmp = chunk;

kernel/liveupdate/kexec_handover.c

1126

kho_vmalloc_unpreserve_chunk(chunk, preservation->order);

kernel/liveupdate/kexec_handover.c

1128

chunk = KHOSER_LOAD_PTR(chunk->hdr.next);

kernel/liveupdate/kexec_handover.c

1146

struct kho_vmalloc_chunk *chunk = KHOSER_LOAD_PTR(preservation->first);

kernel/liveupdate/kexec_handover.c

1169

while (chunk) {

kernel/liveupdate/kexec_handover.c

1172

for (int i = 0; i < ARRAY_SIZE(chunk->phys) && chunk->phys[i]; i++) {

kernel/liveupdate/kexec_handover.c

1173

phys_addr_t phys = chunk->phys[i];

kernel/liveupdate/kexec_handover.c

1188

page = kho_restore_pages(virt_to_phys(chunk), 1);

kernel/liveupdate/kexec_handover.c

1191

chunk = KHOSER_LOAD_PTR(chunk->hdr.next);

kernel/sched/ext/arena.c

39

static void scx_arena_clear_chunk(struct gen_pool *pool, struct gen_pool_chunk *chunk,

kernel/sched/ext/arena.c

43

size_t chunk_sz = chunk->end_addr - chunk->start_addr + 1;

kernel/sched/ext/arena.c

47

for_each_set_bitrange(b, e, chunk->bits, end_bit)

kernel/sched/ext/arena.c

48

gen_pool_free(pool, chunk->start_addr + (b << order),

kernel/trace/pid_list.c

15

union lower_chunk *chunk;

kernel/trace/pid_list.c

22

chunk = pid_list->lower_list;

kernel/trace/pid_list.c

23

pid_list->lower_list = chunk->next;

kernel/trace/pid_list.c

26

chunk->next = NULL;

kernel/trace/pid_list.c

34

return chunk;

kernel/trace/pid_list.c

360

union upper_chunk *chunk;

kernel/trace/pid_list.c

362

chunk = kzalloc_obj(*chunk, GFP_NOWAIT);

kernel/trace/pid_list.c

363

if (!chunk)

kernel/trace/pid_list.c

365

*upper_next = chunk;

kernel/trace/pid_list.c

366

upper_next = &chunk->next;

kernel/trace/pid_list.c

371

union lower_chunk *chunk;

kernel/trace/pid_list.c

373

chunk = kzalloc_obj(*chunk, GFP_NOWAIT);

kernel/trace/pid_list.c

374

if (!chunk)

kernel/trace/pid_list.c

376

*lower_next = chunk;

kernel/trace/pid_list.c

377

lower_next = &chunk->next;

kernel/trace/pid_list.c

39

union upper_chunk *chunk;

kernel/trace/pid_list.c

436

union upper_chunk *chunk;

kernel/trace/pid_list.c

438

chunk = kzalloc_obj(*chunk);

kernel/trace/pid_list.c

439

if (!chunk)

kernel/trace/pid_list.c

441

chunk->next = pid_list->upper_list;

kernel/trace/pid_list.c

442

pid_list->upper_list = chunk;

kernel/trace/pid_list.c

447

union lower_chunk *chunk;

kernel/trace/pid_list.c

449

chunk = kzalloc_obj(*chunk);

kernel/trace/pid_list.c

450

if (!chunk)

kernel/trace/pid_list.c

452

chunk->next = pid_list->lower_list;

kernel/trace/pid_list.c

453

pid_list->lower_list = chunk;

kernel/trace/pid_list.c

46

chunk = pid_list->upper_list;

kernel/trace/pid_list.c

47

pid_list->upper_list = chunk->next;

kernel/trace/pid_list.c

478

union lower_chunk *chunk;

kernel/trace/pid_list.c

480

chunk = pid_list->lower_list;

kernel/trace/pid_list.c

482

kfree(chunk);

kernel/trace/pid_list.c

486

union upper_chunk *chunk;

kernel/trace/pid_list.c

488

chunk = pid_list->upper_list;

kernel/trace/pid_list.c

490

kfree(chunk);

kernel/trace/pid_list.c

50

chunk->next = NULL;

kernel/trace/pid_list.c

58

return chunk;

kernel/trace/pid_list.c

62

union lower_chunk *chunk)

kernel/trace/pid_list.c

66

chunk->next = pid_list->lower_list;

kernel/trace/pid_list.c

67

pid_list->lower_list = chunk;

kernel/trace/pid_list.c

72

union upper_chunk *chunk)

kernel/trace/pid_list.c

76

chunk->next = pid_list->upper_list;

kernel/trace/pid_list.c

77

pid_list->upper_list = chunk;

kernel/trace/pid_list.c

81

static inline bool upper_empty(union upper_chunk *chunk)

kernel/trace/pid_list.c

87

return bitmap_empty((unsigned long *)chunk->data, BITS_PER_TYPE(chunk->data));

lib/bitmap-str.c

448

int chunk;

lib/bitmap-str.c

450

for (chunk = 0; ; chunk++) {

lib/bitmap-str.c

459

end = bitmap_get_x32_reverse(start, end, &bitmap[chunk ^ 1]);

lib/bitmap-str.c

461

end = bitmap_get_x32_reverse(start, end, &bitmap[chunk]);

lib/crc/arm/crc64.h

19

size_t chunk = min_t(size_t, len & ~15, SZ_4K);

lib/crc/arm/crc64.h

22

crc = crc64_nvme_neon(crc, p, chunk);

lib/crc/arm/crc64.h

24

p += chunk;

lib/crc/arm/crc64.h

25

len -= chunk;

lib/crc/arm64/crc64.h

19

size_t chunk = len & ~15;

lib/crc/arm64/crc64.h

22

crc = crc64_nvme_neon(crc, p, chunk);

lib/crc/arm64/crc64.h

24

p += chunk;

lib/genalloc.c

187

struct gen_pool_chunk *chunk;

lib/genalloc.c

192

chunk = vzalloc_node(nbytes, nid);

lib/genalloc.c

193

if (unlikely(chunk == NULL))

lib/genalloc.c

196

chunk->phys_addr = phys;

lib/genalloc.c

197

chunk->start_addr = virt;

lib/genalloc.c

198

chunk->end_addr = virt + size - 1;

lib/genalloc.c

199

chunk->owner = owner;

lib/genalloc.c

200

atomic_long_set(&chunk->avail, size);

lib/genalloc.c

203

list_add_rcu(&chunk->next_chunk, &pool->chunks);

lib/genalloc.c

219

struct gen_pool_chunk *chunk;

lib/genalloc.c

223

list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) {

lib/genalloc.c

224

if (addr >= chunk->start_addr && addr <= chunk->end_addr) {

lib/genalloc.c

225

paddr = chunk->phys_addr + (addr - chunk->start_addr);

lib/genalloc.c

245

struct gen_pool_chunk *chunk;

lib/genalloc.c

250

chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk);

lib/genalloc.c

251

list_del(&chunk->next_chunk);

lib/genalloc.c

253

end_bit = chunk_size(chunk) >> order;

lib/genalloc.c

254

bit = find_first_bit(chunk->bits, end_bit);

lib/genalloc.c

257

vfree(chunk);

lib/genalloc.c

280

struct gen_pool_chunk *chunk;

lib/genalloc.c

297

list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) {

lib/genalloc.c

298

if (size > atomic_long_read(&chunk->avail))

lib/genalloc.c

302

end_bit = chunk_size(chunk) >> order;

lib/genalloc.c

304

start_bit = algo(chunk->bits, end_bit, start_bit,

lib/genalloc.c

305

nbits, data, pool, chunk->start_addr);

lib/genalloc.c

308

remain = bitmap_set_ll(chunk->bits, start_bit, nbits);

lib/genalloc.c

310

remain = bitmap_clear_ll(chunk->bits, start_bit,

lib/genalloc.c

316

addr = chunk->start_addr + ((unsigned long)start_bit << order);

lib/genalloc.c

318

atomic_long_sub(size, &chunk->avail);

lib/genalloc.c

320

*owner = chunk->owner;

lib/genalloc.c

40

static inline size_t chunk_size(const struct gen_pool_chunk *chunk)

lib/genalloc.c

42

return chunk->end_addr - chunk->start_addr + 1;

lib/genalloc.c

490

struct gen_pool_chunk *chunk;

lib/genalloc.c

503

list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) {

lib/genalloc.c

504

if (addr >= chunk->start_addr && addr <= chunk->end_addr) {

lib/genalloc.c

505

BUG_ON(addr + size - 1 > chunk->end_addr);

lib/genalloc.c

506

start_bit = (addr - chunk->start_addr) >> order;

lib/genalloc.c

507

remain = bitmap_clear_ll(chunk->bits, start_bit, nbits);

lib/genalloc.c

510

atomic_long_add(size, &chunk->avail);

lib/genalloc.c

512

*owner = chunk->owner;

lib/genalloc.c

532

void (*func)(struct gen_pool *pool, struct gen_pool_chunk *chunk, void *data),

lib/genalloc.c

535

struct gen_pool_chunk *chunk;

lib/genalloc.c

538

list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk)

lib/genalloc.c

539

func(pool, chunk, data);

lib/genalloc.c

558

struct gen_pool_chunk *chunk;

lib/genalloc.c

561

list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) {

lib/genalloc.c

562

if (start >= chunk->start_addr && start <= chunk->end_addr) {

lib/genalloc.c

563

if (end <= chunk->end_addr) {

lib/genalloc.c

582

struct gen_pool_chunk *chunk;

lib/genalloc.c

586

list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk)

lib/genalloc.c

587

avail += atomic_long_read(&chunk->avail);

lib/genalloc.c

601

struct gen_pool_chunk *chunk;

lib/genalloc.c

605

list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk)

lib/genalloc.c

606

size += chunk_size(chunk);

lib/test_hmm.c

188

static void dmirror_device_evict_chunk(struct dmirror_chunk *chunk)

lib/test_hmm.c

190

unsigned long start_pfn = chunk->pagemap.range.start >> PAGE_SHIFT;

lib/test_hmm.c

191

unsigned long end_pfn = chunk->pagemap.range.end >> PAGE_SHIFT;

lib/zstd/compress/zstd_lazy.c

1018

const uint8x16_t chunk = vld1q_u8(src);

lib/zstd/compress/zstd_lazy.c

1019

const uint16x8_t equalMask = vreinterpretq_u16_u8(vceqq_u8(chunk, vdupq_n_u8(tag)));

lib/zstd/compress/zstd_lazy.c

1027

const uint16x8x2_t chunk = vld2q_u16((const uint16_t*)(const void*)src);

lib/zstd/compress/zstd_lazy.c

1028

const uint8x16_t chunk0 = vreinterpretq_u8_u16(chunk.val[0]);

lib/zstd/compress/zstd_lazy.c

1029

const uint8x16_t chunk1 = vreinterpretq_u8_u16(chunk.val[1]);

lib/zstd/compress/zstd_lazy.c

1037

const uint8x16x4_t chunk = vld4q_u8(src);

lib/zstd/compress/zstd_lazy.c

1039

const uint8x16_t cmp0 = vceqq_u8(chunk.val[0], dup);

lib/zstd/compress/zstd_lazy.c

1040

const uint8x16_t cmp1 = vceqq_u8(chunk.val[1], dup);

lib/zstd/compress/zstd_lazy.c

1041

const uint8x16_t cmp2 = vceqq_u8(chunk.val[2], dup);

lib/zstd/compress/zstd_lazy.c

1042

const uint8x16_t cmp3 = vceqq_u8(chunk.val[3], dup);

lib/zstd/compress/zstd_lazy.c

1094

size_t chunk = MEM_readST(&src[i]);

lib/zstd/compress/zstd_lazy.c

1095

chunk ^= splatChar;

lib/zstd/compress/zstd_lazy.c

1096

chunk = (((chunk | x80) - x01) | chunk) & x80;

lib/zstd/compress/zstd_lazy.c

1098

matches |= (chunk * extractMagic) >> shiftAmount;

lib/zstd/compress/zstd_lazy.c

1105

size_t chunk = MEM_readST(&src[i]);

lib/zstd/compress/zstd_lazy.c

1106

chunk ^= splatChar;

lib/zstd/compress/zstd_lazy.c

1107

chunk = (((chunk | x80) - x01) | chunk) & x80;

lib/zstd/compress/zstd_lazy.c

1109

matches |= ((chunk >> 7) * extractMagic) >> shiftAmount;

lib/zstd/compress/zstd_lazy.c

996

const __m128i chunk = _mm_loadu_si128((const __m128i*)(const void*)(src + 16*i));

lib/zstd/compress/zstd_lazy.c

997

const __m128i equalMask = _mm_cmpeq_epi8(chunk, comparisonMask);

lib/zstd/compress/zstd_ldm.c

536

size_t chunk;

lib/zstd/compress/zstd_ldm.c

549

for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) {

lib/zstd/compress/zstd_ldm.c

550

BYTE const* const chunkStart = istart + chunk * kMaxChunkSize;

mm/filemap.c

4336

size_t chunk = mapping_max_folio_size(mapping);

mm/filemap.c

4349

offset = pos & (chunk - 1);

mm/filemap.c

4350

bytes = min(chunk - offset, bytes);

mm/filemap.c

4395

if (chunk > PAGE_SIZE)

mm/filemap.c

4396

chunk /= 2;

mm/percpu-internal.h

117

static inline int pcpu_chunk_nr_blocks(struct pcpu_chunk *chunk)

mm/percpu-internal.h

119

return chunk->nr_pages * PAGE_SIZE / PCPU_BITMAP_BLOCK_SIZE;

mm/percpu-internal.h

141

static inline int pcpu_chunk_map_bits(struct pcpu_chunk *chunk)

mm/percpu-internal.h

143

return pcpu_nr_pages_to_map_bits(chunk->nr_pages);

mm/percpu-internal.h

202

static inline void pcpu_stats_area_alloc(struct pcpu_chunk *chunk, size_t size)

mm/percpu-internal.h

215

chunk->nr_alloc++;

mm/percpu-internal.h

216

chunk->max_alloc_size = max(chunk->max_alloc_size, size);

mm/percpu-internal.h

226

static inline void pcpu_stats_area_dealloc(struct pcpu_chunk *chunk)

mm/percpu-internal.h

233

chunk->nr_alloc--;

mm/percpu-internal.h

270

static inline void pcpu_stats_area_alloc(struct pcpu_chunk *chunk, size_t size)

mm/percpu-internal.h

274

static inline void pcpu_stats_area_dealloc(struct pcpu_chunk *chunk)

mm/percpu-km.c

127

static bool pcpu_should_reclaim_chunk(struct pcpu_chunk *chunk)

mm/percpu-km.c

35

static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,

mm/percpu-km.c

41

static int pcpu_populate_chunk(struct pcpu_chunk *chunk,

mm/percpu-km.c

47

static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,

mm/percpu-km.c

56

struct pcpu_chunk *chunk;

mm/percpu-km.c

61

chunk = pcpu_alloc_chunk(gfp);

mm/percpu-km.c

62

if (!chunk)

mm/percpu-km.c

67

pcpu_free_chunk(chunk);

mm/percpu-km.c

72

pcpu_set_page_chunk(pages + i, chunk);

mm/percpu-km.c

74

chunk->data = pages;

mm/percpu-km.c

75

chunk->base_addr = page_address(pages);

mm/percpu-km.c

78

pcpu_chunk_populated(chunk, 0, chunk->nr_pages);

mm/percpu-km.c

82

trace_percpu_create_chunk(chunk->base_addr);

mm/percpu-km.c

84

return chunk;

mm/percpu-km.c

87

static void pcpu_destroy_chunk(struct pcpu_chunk *chunk)

mm/percpu-km.c

91

if (!chunk)

mm/percpu-km.c

95

trace_percpu_destroy_chunk(chunk->base_addr);

mm/percpu-km.c

97

if (chunk->data)

mm/percpu-km.c

98

__free_pages(chunk->data, order_base_2(nr_pages));

mm/percpu-km.c

99

pcpu_free_chunk(chunk);

mm/percpu-stats.c

120

P("nr_alloc", chunk->nr_alloc);

mm/percpu-stats.c

121

P("max_alloc_size", chunk->max_alloc_size);

mm/percpu-stats.c

122

P("empty_pop_pages", chunk->nr_empty_pop_pages);

mm/percpu-stats.c

124

P("free_bytes", chunk->free_bytes);

mm/percpu-stats.c

136

struct pcpu_chunk *chunk;

mm/percpu-stats.c

205

list_for_each_entry(chunk, &pcpu_chunk_lists[slot], list) {

mm/percpu-stats.c

206

if (chunk == pcpu_first_chunk)

mm/percpu-stats.c

214

chunk_map_stats(m, chunk, buffer);

mm/percpu-stats.c

34

struct pcpu_chunk *chunk;

mm/percpu-stats.c

39

list_for_each_entry(chunk, &pcpu_chunk_lists[slot], list)

mm/percpu-stats.c

40

max_nr_alloc = max(max_nr_alloc, chunk->nr_alloc);

mm/percpu-stats.c

51

static void chunk_map_stats(struct seq_file *m, struct pcpu_chunk *chunk,

mm/percpu-stats.c

54

struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu-stats.c

68

last_alloc = find_last_bit(chunk->alloc_map,

mm/percpu-stats.c

69

pcpu_chunk_map_bits(chunk) -

mm/percpu-stats.c

70

chunk->end_offset / PCPU_MIN_ALLOC_SIZE - 1);

mm/percpu-stats.c

71

last_alloc = test_bit(last_alloc, chunk->alloc_map) ?

mm/percpu-stats.c

75

start = chunk->start_offset / PCPU_MIN_ALLOC_SIZE;

mm/percpu-stats.c

87

if (test_bit(start, chunk->alloc_map)) {

mm/percpu-stats.c

88

end = find_next_bit(chunk->bound_map, last_alloc,

mm/percpu-stats.c

92

end = find_next_bit(chunk->alloc_map, last_alloc,

mm/percpu-vm.c

127

static void pcpu_pre_unmap_flush(struct pcpu_chunk *chunk,

mm/percpu-vm.c

13

static struct page *pcpu_chunk_page(struct pcpu_chunk *chunk,

mm/percpu-vm.c

131

pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),

mm/percpu-vm.c

132

pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));

mm/percpu-vm.c

153

static void pcpu_unmap_pages(struct pcpu_chunk *chunk,

mm/percpu-vm.c

163

page = pcpu_chunk_page(chunk, cpu, i);

mm/percpu-vm.c

167

__pcpu_unmap_pages(pcpu_chunk_addr(chunk, cpu, page_start),

mm/percpu-vm.c

17

WARN_ON(chunk->immutable);

mm/percpu-vm.c

185

static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,

mm/percpu-vm.c

189

pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),

mm/percpu-vm.c

19

return vmalloc_to_page((void *)pcpu_chunk_addr(chunk, cpu, page_idx));

mm/percpu-vm.c

190

pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));

mm/percpu-vm.c

214

static int pcpu_map_pages(struct pcpu_chunk *chunk,

mm/percpu-vm.c

221

err = __pcpu_map_pages(pcpu_chunk_addr(chunk, cpu, page_start),

mm/percpu-vm.c

229

chunk);

mm/percpu-vm.c

234

__pcpu_unmap_pages(pcpu_chunk_addr(chunk, tcpu, page_start),

mm/percpu-vm.c

239

pcpu_post_unmap_tlb_flush(chunk, page_start, page_end);

mm/percpu-vm.c

255

static void pcpu_post_map_flush(struct pcpu_chunk *chunk,

mm/percpu-vm.c

259

pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),

mm/percpu-vm.c

260

pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));

mm/percpu-vm.c

276

static int pcpu_populate_chunk(struct pcpu_chunk *chunk,

mm/percpu-vm.c

285

if (pcpu_alloc_pages(chunk, pages, page_start, page_end, gfp))

mm/percpu-vm.c

288

if (pcpu_map_pages(chunk, pages, page_start, page_end)) {

mm/percpu-vm.c

289

pcpu_free_pages(chunk, pages, page_start, page_end);

mm/percpu-vm.c

292

pcpu_post_map_flush(chunk, page_start, page_end);

mm/percpu-vm.c

312

static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,

mm/percpu-vm.c

326

pcpu_pre_unmap_flush(chunk, page_start, page_end);

mm/percpu-vm.c

328

pcpu_unmap_pages(chunk, pages, page_start, page_end);

mm/percpu-vm.c

330

pcpu_free_pages(chunk, pages, page_start, page_end);

mm/percpu-vm.c

335

struct pcpu_chunk *chunk;

mm/percpu-vm.c

338

chunk = pcpu_alloc_chunk(gfp);

mm/percpu-vm.c

339

if (!chunk)

mm/percpu-vm.c

345

pcpu_free_chunk(chunk);

mm/percpu-vm.c

349

chunk->data = vms;

mm/percpu-vm.c

350

chunk->base_addr = vms[0]->addr - pcpu_group_offsets[0];

mm/percpu-vm.c

353

trace_percpu_create_chunk(chunk->base_addr);

mm/percpu-vm.c

355

return chunk;

mm/percpu-vm.c

358

static void pcpu_destroy_chunk(struct pcpu_chunk *chunk)

mm/percpu-vm.c

360

if (!chunk)

mm/percpu-vm.c

364

trace_percpu_destroy_chunk(chunk->base_addr);

mm/percpu-vm.c

366

if (chunk->data)

mm/percpu-vm.c

367

pcpu_free_vm_areas(chunk->data, pcpu_nr_groups);

mm/percpu-vm.c

368

pcpu_free_chunk(chunk);

mm/percpu-vm.c

394

static bool pcpu_should_reclaim_chunk(struct pcpu_chunk *chunk)

mm/percpu-vm.c

397

if (chunk == pcpu_first_chunk || chunk == pcpu_reserved_chunk)

mm/percpu-vm.c

406

return ((chunk->isolated && chunk->nr_empty_pop_pages) ||

mm/percpu-vm.c

408

(PCPU_EMPTY_POP_PAGES_HIGH + chunk->nr_empty_pop_pages) &&

mm/percpu-vm.c

409

chunk->nr_empty_pop_pages >= chunk->nr_pages / 4));

mm/percpu-vm.c

54

static void pcpu_free_pages(struct pcpu_chunk *chunk,

mm/percpu-vm.c

82

static int pcpu_alloc_pages(struct pcpu_chunk *chunk,

mm/percpu.c

1006

int l_bit = find_last_bit(pcpu_index_alloc_map(chunk, s_index),

mm/percpu.c

1015

end = find_next_bit(pcpu_index_alloc_map(chunk, e_index),

mm/percpu.c

1044

pcpu_update_empty_pages(chunk, nr_empty_pages);

mm/percpu.c

1053

pcpu_chunk_refresh_hint(chunk, true);

mm/percpu.c

1055

pcpu_block_update(&chunk->chunk_md,

mm/percpu.c

1073

static bool pcpu_is_populated(struct pcpu_chunk *chunk, int bit_off, int bits,

mm/percpu.c

1081

start = find_next_zero_bit(chunk->populated, end, start);

mm/percpu.c

1085

end = find_next_bit(chunk->populated, end, start + 1);

mm/percpu.c

1110

static int pcpu_find_block_fit(struct pcpu_chunk *chunk, int alloc_bits,

mm/percpu.c

1113

struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu.c

1126

pcpu_for_each_fit_region(chunk, alloc_bits, align, bit_off, bits) {

mm/percpu.c

1127

if (!pop_only || pcpu_is_populated(chunk, bit_off, bits,

mm/percpu.c

1135

if (bit_off == pcpu_chunk_map_bits(chunk))

mm/percpu.c

1216

static int pcpu_alloc_area(struct pcpu_chunk *chunk, int alloc_bits,

mm/percpu.c

1219

struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu.c

1226

oslot = pcpu_chunk_slot(chunk);

mm/percpu.c

1232

pcpu_chunk_map_bits(chunk));

mm/percpu.c

1233

bit_off = pcpu_find_zero_area(chunk->alloc_map, end, start, alloc_bits,

mm/percpu.c

1239

pcpu_block_update_scan(chunk, area_off, area_bits);

mm/percpu.c

1242

bitmap_set(chunk->alloc_map, bit_off, alloc_bits);

mm/percpu.c

1245

set_bit(bit_off, chunk->bound_map);

mm/percpu.c

1246

bitmap_clear(chunk->bound_map, bit_off + 1, alloc_bits - 1);

mm/percpu.c

1247

set_bit(bit_off + alloc_bits, chunk->bound_map);

mm/percpu.c

1249

chunk->free_bytes -= alloc_bits * PCPU_MIN_ALLOC_SIZE;

mm/percpu.c

1254

chunk->alloc_map,

mm/percpu.c

1255

pcpu_chunk_map_bits(chunk),

mm/percpu.c

1258

pcpu_block_update_hint_alloc(chunk, bit_off, alloc_bits);

mm/percpu.c

1260

pcpu_chunk_relocate(chunk, oslot);

mm/percpu.c

1276

static int pcpu_free_area(struct pcpu_chunk *chunk, int off)

mm/percpu.c

1278

struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu.c

1283

oslot = pcpu_chunk_slot(chunk);

mm/percpu.c

1288

if (!test_bit(bit_off, chunk->alloc_map) ||

mm/percpu.c

1289

!test_bit(bit_off, chunk->bound_map))

mm/percpu.c

1293

end = find_next_bit(chunk->bound_map, pcpu_chunk_map_bits(chunk),

mm/percpu.c

1296

bitmap_clear(chunk->alloc_map, bit_off, bits);

mm/percpu.c

1301

chunk->free_bytes += freed;

mm/percpu.c

1306

pcpu_block_update_hint_free(chunk, bit_off, bits);

mm/percpu.c

1308

pcpu_chunk_relocate(chunk, oslot);

mm/percpu.c

1310

pcpu_stats_area_dealloc(chunk);

mm/percpu.c

1325

static void pcpu_init_md_blocks(struct pcpu_chunk *chunk)

mm/percpu.c

1330

pcpu_init_md_block(&chunk->chunk_md, pcpu_chunk_map_bits(chunk));

mm/percpu.c

1332

for (md_block = chunk->md_blocks;

mm/percpu.c

1333

md_block != chunk->md_blocks + pcpu_chunk_nr_blocks(chunk);

mm/percpu.c

1354

struct pcpu_chunk *chunk;

mm/percpu.c

1366

alloc_size = struct_size(chunk, populated,

mm/percpu.c

1368

chunk = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);

mm/percpu.c

1370

INIT_LIST_HEAD(&chunk->list);

mm/percpu.c

1372

chunk->base_addr = (void *)aligned_addr;

mm/percpu.c

1373

chunk->start_offset = start_offset;

mm/percpu.c

1374

chunk->end_offset = region_size - chunk->start_offset - map_size;

mm/percpu.c

1376

chunk->nr_pages = region_size >> PAGE_SHIFT;

mm/percpu.c

1377

region_bits = pcpu_chunk_map_bits(chunk);

mm/percpu.c

1379

alloc_size = BITS_TO_LONGS(region_bits) * sizeof(chunk->alloc_map[0]);

mm/percpu.c

1380

chunk->alloc_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);

mm/percpu.c

1383

BITS_TO_LONGS(region_bits + 1) * sizeof(chunk->bound_map[0]);

mm/percpu.c

1384

chunk->bound_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);

mm/percpu.c

1386

alloc_size = pcpu_chunk_nr_blocks(chunk) * sizeof(chunk->md_blocks[0]);

mm/percpu.c

1387

chunk->md_blocks = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);

mm/percpu.c

1390

chunk->obj_exts = NULL;

mm/percpu.c

1392

pcpu_init_md_blocks(chunk);

mm/percpu.c

1395

chunk->immutable = true;

mm/percpu.c

1396

bitmap_fill(chunk->populated, chunk->nr_pages);

mm/percpu.c

1397

chunk->nr_populated = chunk->nr_pages;

mm/percpu.c

1398

chunk->nr_empty_pop_pages = chunk->nr_pages;

mm/percpu.c

1400

chunk->free_bytes = map_size;

mm/percpu.c

1402

if (chunk->start_offset) {

mm/percpu.c

1404

offset_bits = chunk->start_offset / PCPU_MIN_ALLOC_SIZE;

mm/percpu.c

1405

bitmap_set(chunk->alloc_map, 0, offset_bits);

mm/percpu.c

1406

set_bit(0, chunk->bound_map);

mm/percpu.c

1407

set_bit(offset_bits, chunk->bound_map);

mm/percpu.c

1409

chunk->chunk_md.first_free = offset_bits;

mm/percpu.c

1411

pcpu_block_update_hint_alloc(chunk, 0, offset_bits);

mm/percpu.c

1414

if (chunk->end_offset) {

mm/percpu.c

1416

offset_bits = chunk->end_offset / PCPU_MIN_ALLOC_SIZE;

mm/percpu.c

1417

bitmap_set(chunk->alloc_map,

mm/percpu.c

1418

pcpu_chunk_map_bits(chunk) - offset_bits,

mm/percpu.c

1421

chunk->bound_map);

mm/percpu.c

1422

set_bit(region_bits, chunk->bound_map);

mm/percpu.c

1424

pcpu_block_update_hint_alloc(chunk, pcpu_chunk_map_bits(chunk)

mm/percpu.c

1428

return chunk;

mm/percpu.c

1433

struct pcpu_chunk *chunk;

mm/percpu.c

1436

chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size, gfp);

mm/percpu.c

1437

if (!chunk)

mm/percpu.c

1440

INIT_LIST_HEAD(&chunk->list);

mm/percpu.c

1441

chunk->nr_pages = pcpu_unit_pages;

mm/percpu.c

1442

region_bits = pcpu_chunk_map_bits(chunk);

mm/percpu.c

1444

chunk->alloc_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits) *

mm/percpu.c

1445

sizeof(chunk->alloc_map[0]), gfp);

mm/percpu.c

1446

if (!chunk->alloc_map)

mm/percpu.c

1449

chunk->bound_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits + 1) *

mm/percpu.c

1450

sizeof(chunk->bound_map[0]), gfp);

mm/percpu.c

1451

if (!chunk->bound_map)

mm/percpu.c

1454

chunk->md_blocks = pcpu_mem_zalloc(pcpu_chunk_nr_blocks(chunk) *

mm/percpu.c

1455

sizeof(chunk->md_blocks[0]), gfp);

mm/percpu.c

1456

if (!chunk->md_blocks)

mm/percpu.c

1461

chunk->obj_exts =

mm/percpu.c

1462

pcpu_mem_zalloc(pcpu_chunk_map_bits(chunk) *

mm/percpu.c

1464

if (!chunk->obj_exts)

mm/percpu.c

1469

pcpu_init_md_blocks(chunk);

mm/percpu.c

1472

chunk->free_bytes = chunk->nr_pages * PAGE_SIZE;

mm/percpu.c

1474

return chunk;

mm/percpu.c

1478

pcpu_mem_free(chunk->md_blocks);

mm/percpu.c

1481

pcpu_mem_free(chunk->bound_map);

mm/percpu.c

1483

pcpu_mem_free(chunk->alloc_map);

mm/percpu.c

1485

pcpu_mem_free(chunk);

mm/percpu.c

1490

static void pcpu_free_chunk(struct pcpu_chunk *chunk)

mm/percpu.c

1492

if (!chunk)

mm/percpu.c

1495

pcpu_mem_free(chunk->obj_exts);

mm/percpu.c

1497

pcpu_mem_free(chunk->md_blocks);

mm/percpu.c

1498

pcpu_mem_free(chunk->bound_map);

mm/percpu.c

1499

pcpu_mem_free(chunk->alloc_map);

mm/percpu.c

1500

pcpu_mem_free(chunk);

mm/percpu.c

1513

static void pcpu_chunk_populated(struct pcpu_chunk *chunk, int page_start,

mm/percpu.c

1520

bitmap_set(chunk->populated, page_start, nr);

mm/percpu.c

1521

chunk->nr_populated += nr;

mm/percpu.c

1524

pcpu_update_empty_pages(chunk, nr);

mm/percpu.c

1537

static void pcpu_chunk_depopulated(struct pcpu_chunk *chunk,

mm/percpu.c

1544

bitmap_clear(chunk->populated, page_start, nr);

mm/percpu.c

1545

chunk->nr_populated -= nr;

mm/percpu.c

1548

pcpu_update_empty_pages(chunk, -nr);

mm/percpu.c

1567

static int pcpu_populate_chunk(struct pcpu_chunk *chunk,

mm/percpu.c

1569

static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,

mm/percpu.c

1571

static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,

mm/percpu.c

1574

static void pcpu_destroy_chunk(struct pcpu_chunk *chunk);

mm/percpu.c

1636

struct pcpu_chunk *chunk, int off,

mm/percpu.c

1642

if (likely(chunk && chunk->obj_exts)) {

mm/percpu.c

1644

chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].cgroup = objcg;

mm/percpu.c

1655

static void pcpu_memcg_free_hook(struct pcpu_chunk *chunk, int off, size_t size)

mm/percpu.c

1659

if (unlikely(!chunk->obj_exts))

mm/percpu.c

1662

objcg = chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].cgroup;

mm/percpu.c

1665

chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].cgroup = NULL;

mm/percpu.c

1685

struct pcpu_chunk *chunk, int off,

mm/percpu.c

1690

static void pcpu_memcg_free_hook(struct pcpu_chunk *chunk, int off, size_t size)

mm/percpu.c

1696

static void pcpu_alloc_tag_alloc_hook(struct pcpu_chunk *chunk, int off,

mm/percpu.c

1699

if (mem_alloc_profiling_enabled() && likely(chunk->obj_exts)) {

mm/percpu.c

1700

alloc_tag_add(&chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].tag,

mm/percpu.c

1705

static void pcpu_alloc_tag_free_hook(struct pcpu_chunk *chunk, int off, size_t size)

mm/percpu.c

1707

if (mem_alloc_profiling_enabled() && likely(chunk->obj_exts))

mm/percpu.c

1708

alloc_tag_sub(&chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].tag, size);

mm/percpu.c

1711

static void pcpu_alloc_tag_alloc_hook(struct pcpu_chunk *chunk, int off,

mm/percpu.c

1716

static void pcpu_alloc_tag_free_hook(struct pcpu_chunk *chunk, int off, size_t size)

mm/percpu.c

1744

struct pcpu_chunk *chunk, *next;

mm/percpu.c

1798

chunk = pcpu_reserved_chunk;

mm/percpu.c

1800

off = pcpu_find_block_fit(chunk, bits, bit_align, is_atomic);

mm/percpu.c

1806

off = pcpu_alloc_area(chunk, bits, bit_align, off);

mm/percpu.c

1817

list_for_each_entry_safe(chunk, next, &pcpu_chunk_lists[slot],

mm/percpu.c

1819

off = pcpu_find_block_fit(chunk, bits, bit_align,

mm/percpu.c

1823

pcpu_chunk_move(chunk, 0);

mm/percpu.c

1827

off = pcpu_alloc_area(chunk, bits, bit_align, off);

mm/percpu.c

1829

pcpu_reintegrate_chunk(chunk);

mm/percpu.c

1844

chunk = pcpu_create_chunk(pcpu_gfp);

mm/percpu.c

1845

if (!chunk) {

mm/percpu.c

1851

pcpu_chunk_relocate(chunk, -1);

mm/percpu.c

1859

pcpu_stats_area_alloc(chunk, size);

mm/percpu.c

1873

for_each_clear_bitrange_from(rs, re, chunk->populated, page_end) {

mm/percpu.c

1874

WARN_ON(chunk->immutable);

mm/percpu.c

1876

ret = pcpu_populate_chunk(chunk, rs, re, pcpu_gfp);

mm/percpu.c

1880

pcpu_free_area(chunk, off);

mm/percpu.c

1884

pcpu_chunk_populated(chunk, rs, re);

mm/percpu.c

1893

memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size);

mm/percpu.c

1895

ptr = __addr_to_pcpu_ptr(chunk->base_addr + off);

mm/percpu.c

1899

chunk->base_addr, off, ptr,

mm/percpu.c

1902

pcpu_memcg_post_alloc_hook(objcg, chunk, off, size);

mm/percpu.c

1904

pcpu_alloc_tag_alloc_hook(chunk, off, size);

mm/percpu.c

1955

struct pcpu_chunk *chunk, *next;

mm/percpu.c

1963

list_for_each_entry_safe(chunk, next, free_head, list) {

mm/percpu.c

1964

WARN_ON(chunk->immutable);

mm/percpu.c

1967

if (chunk == list_first_entry(free_head, struct pcpu_chunk, list))

mm/percpu.c

1970

if (!empty_only || chunk->nr_empty_pop_pages == 0)

mm/percpu.c

1971

list_move(&chunk->list, &to_free);

mm/percpu.c

1978

list_for_each_entry_safe(chunk, next, &to_free, list) {

mm/percpu.c

1981

for_each_set_bitrange(rs, re, chunk->populated, chunk->nr_pages) {

mm/percpu.c

1982

pcpu_depopulate_chunk(chunk, rs, re);

mm/percpu.c

1984

pcpu_chunk_depopulated(chunk, rs, re);

mm/percpu.c

1987

pcpu_destroy_chunk(chunk);

mm/percpu.c

2009

struct pcpu_chunk *chunk;

mm/percpu.c

2041

list_for_each_entry(chunk, &pcpu_chunk_lists[slot], list) {

mm/percpu.c

2042

nr_unpop = chunk->nr_pages - chunk->nr_populated;

mm/percpu.c

2051

for_each_clear_bitrange(rs, re, chunk->populated, chunk->nr_pages) {

mm/percpu.c

2055

ret = pcpu_populate_chunk(chunk, rs, rs + nr, gfp);

mm/percpu.c

2060

pcpu_chunk_populated(chunk, rs, rs + nr);

mm/percpu.c

2073

chunk = pcpu_create_chunk(gfp);

mm/percpu.c

2076

if (chunk) {

mm/percpu.c

2077

pcpu_chunk_relocate(chunk, -1);

mm/percpu.c

2100

struct pcpu_chunk *chunk;

mm/percpu.c

2114

while ((chunk = list_first_entry_or_null(

mm/percpu.c

2117

WARN_ON(chunk->immutable);

mm/percpu.c

2123

freed_page_start = chunk->nr_pages;

mm/percpu.c

2126

for (i = chunk->nr_pages - 1, end = -1; i >= 0; i--) {

mm/percpu.c

2128

if (chunk->nr_empty_pop_pages == 0)

mm/percpu.c

2143

block = chunk->md_blocks + i;

mm/percpu.c

2145

test_bit(i, chunk->populated)) {

mm/percpu.c

215

static bool pcpu_addr_in_chunk(struct pcpu_chunk *chunk, void *addr)

mm/percpu.c

2158

pcpu_depopulate_chunk(chunk, i + 1, end + 1);

mm/percpu.c

2162

pcpu_chunk_depopulated(chunk, i + 1, end + 1);

mm/percpu.c

2173

pcpu_post_unmap_tlb_flush(chunk,

mm/percpu.c

2180

if (reintegrate || chunk->free_bytes == pcpu_unit_size)

mm/percpu.c

2181

pcpu_reintegrate_chunk(chunk);

mm/percpu.c

2183

list_move_tail(&chunk->list,

mm/percpu.c

219

if (!chunk)

mm/percpu.c

222

start_addr = chunk->base_addr + chunk->start_offset;

mm/percpu.c

223

end_addr = chunk->base_addr + chunk->nr_pages * PAGE_SIZE -

mm/percpu.c

2235

struct pcpu_chunk *chunk;

mm/percpu.c

224

chunk->end_offset;

mm/percpu.c

2246

chunk = pcpu_chunk_addr_search(addr);

mm/percpu.c

2247

off = addr - chunk->base_addr;

mm/percpu.c

2250

size = pcpu_free_area(chunk, off);

mm/percpu.c

2259

pcpu_alloc_tag_free_hook(chunk, off, size);

mm/percpu.c

2261

pcpu_memcg_free_hook(chunk, off, size);

mm/percpu.c

2268

if (!chunk->isolated && chunk->free_bytes == pcpu_unit_size) {

mm/percpu.c

2272

if (pos != chunk) {

mm/percpu.c

2276

} else if (pcpu_should_reclaim_chunk(chunk)) {

mm/percpu.c

2277

pcpu_isolate_chunk(chunk);

mm/percpu.c

2281

trace_percpu_free_percpu(chunk->base_addr, off, ptr);

mm/percpu.c

242

static int pcpu_chunk_slot(const struct pcpu_chunk *chunk)

mm/percpu.c

244

const struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu.c

246

if (chunk->free_bytes < PCPU_MIN_ALLOC_SIZE ||

mm/percpu.c

275

static unsigned long pcpu_chunk_addr(struct pcpu_chunk *chunk,

mm/percpu.c

278

return (unsigned long)chunk->base_addr +

mm/percpu.c

286

static unsigned long *pcpu_index_alloc_map(struct pcpu_chunk *chunk, int index)

mm/percpu.c

288

return chunk->alloc_map +

mm/percpu.c

365

static void pcpu_next_md_free_region(struct pcpu_chunk *chunk, int *bit_off,

mm/percpu.c

373

for (block = chunk->md_blocks + i; i < pcpu_chunk_nr_blocks(chunk);

mm/percpu.c

420

static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits,

mm/percpu.c

428

for (block = chunk->md_blocks + i; i < pcpu_chunk_nr_blocks(chunk);

mm/percpu.c

468

*bit_off = pcpu_chunk_map_bits(chunk);

mm/percpu.c

477

#define pcpu_for_each_md_free_region(chunk, bit_off, bits) \

mm/percpu.c

478

for (pcpu_next_md_free_region((chunk), &(bit_off), &(bits)); \

mm/percpu.c

479

(bit_off) < pcpu_chunk_map_bits((chunk)); \

mm/percpu.c

481

pcpu_next_md_free_region((chunk), &(bit_off), &(bits)))

mm/percpu.c

483

#define pcpu_for_each_fit_region(chunk, alloc_bits, align, bit_off, bits) \

mm/percpu.c

484

for (pcpu_next_fit_region((chunk), (alloc_bits), (align), &(bit_off), \

mm/percpu.c

486

(bit_off) < pcpu_chunk_map_bits((chunk)); \

mm/percpu.c

488

pcpu_next_fit_region((chunk), (alloc_bits), (align), &(bit_off), \

mm/percpu.c

526

static void __pcpu_chunk_move(struct pcpu_chunk *chunk, int slot,

mm/percpu.c

529

if (chunk != pcpu_reserved_chunk) {

mm/percpu.c

531

list_move(&chunk->list, &pcpu_chunk_lists[slot]);

mm/percpu.c

533

list_move_tail(&chunk->list, &pcpu_chunk_lists[slot]);

mm/percpu.c

537

static void pcpu_chunk_move(struct pcpu_chunk *chunk, int slot)

mm/percpu.c

539

__pcpu_chunk_move(chunk, slot, true);

mm/percpu.c

555

static void pcpu_chunk_relocate(struct pcpu_chunk *chunk, int oslot)

mm/percpu.c

557

int nslot = pcpu_chunk_slot(chunk);

mm/percpu.c

560

if (chunk->isolated)

mm/percpu.c

564

__pcpu_chunk_move(chunk, nslot, oslot < nslot);

mm/percpu.c

567

static void pcpu_isolate_chunk(struct pcpu_chunk *chunk)

mm/percpu.c

571

if (!chunk->isolated) {

mm/percpu.c

572

chunk->isolated = true;

mm/percpu.c

573

pcpu_nr_empty_pop_pages -= chunk->nr_empty_pop_pages;

mm/percpu.c

575

list_move(&chunk->list, &pcpu_chunk_lists[pcpu_to_depopulate_slot]);

mm/percpu.c

578

static void pcpu_reintegrate_chunk(struct pcpu_chunk *chunk)

mm/percpu.c

582

if (chunk->isolated) {

mm/percpu.c

583

chunk->isolated = false;

mm/percpu.c

584

pcpu_nr_empty_pop_pages += chunk->nr_empty_pop_pages;

mm/percpu.c

585

pcpu_chunk_relocate(chunk, -1);

mm/percpu.c

598

static inline void pcpu_update_empty_pages(struct pcpu_chunk *chunk, int nr)

mm/percpu.c

600

chunk->nr_empty_pop_pages += nr;

mm/percpu.c

601

if (chunk != pcpu_reserved_chunk && !chunk->isolated)

mm/percpu.c

712

static void pcpu_block_update_scan(struct pcpu_chunk *chunk, int bit_off,

mm/percpu.c

724

block = chunk->md_blocks + s_index;

mm/percpu.c

727

l_bit = find_last_bit(pcpu_index_alloc_map(chunk, s_index), s_off);

mm/percpu.c

745

static void pcpu_chunk_refresh_hint(struct pcpu_chunk *chunk, bool full_scan)

mm/percpu.c

747

struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu.c

762

pcpu_for_each_md_free_region(chunk, bit_off, bits)

mm/percpu.c

774

static void pcpu_block_refresh_hint(struct pcpu_chunk *chunk, int index)

mm/percpu.c

776

struct pcpu_block_md *block = chunk->md_blocks + index;

mm/percpu.c

777

unsigned long *alloc_map = pcpu_index_alloc_map(chunk, index);

mm/percpu.c

808

static void pcpu_block_update_hint_alloc(struct pcpu_chunk *chunk, int bit_off,

mm/percpu.c

811

struct pcpu_block_md *chunk_md = &chunk->chunk_md;

mm/percpu.c

828

s_block = chunk->md_blocks + s_index;

mm/percpu.c

829

e_block = chunk->md_blocks + e_index;

mm/percpu.c

844

pcpu_index_alloc_map(chunk, s_index),

mm/percpu.c

862

pcpu_block_refresh_hint(chunk, s_index);

mm/percpu.c

885

pcpu_index_alloc_map(chunk, e_index),

mm/percpu.c

898

pcpu_block_refresh_hint(chunk, e_index);

mm/percpu.c

923

pcpu_update_empty_pages(chunk, -nr_empty_pages);

mm/percpu.c

942

pcpu_chunk_refresh_hint(chunk, false);

mm/percpu.c

963

static void pcpu_block_update_hint_free(struct pcpu_chunk *chunk, int bit_off,

mm/percpu.c

983

s_block = chunk->md_blocks + s_index;

mm/percpu.c

984

e_block = chunk->md_blocks + e_index;

net/bluetooth/af_bluetooth.c

463

int chunk;

net/bluetooth/af_bluetooth.c

489

chunk = min_t(unsigned int, skb->len, size);

net/bluetooth/af_bluetooth.c

490

if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {

net/bluetooth/af_bluetooth.c

496

copied += chunk;

net/bluetooth/af_bluetooth.c

497

size -= chunk;

net/bluetooth/af_bluetooth.c

504

if (chunk <= skb_len) {

net/bluetooth/af_bluetooth.c

505

__skb_pull(skb, chunk);

net/bluetooth/af_bluetooth.c

510

chunk -= skb_len;

net/bluetooth/af_bluetooth.c

513

if (chunk <= frag->len) {

net/bluetooth/af_bluetooth.c

515

skb->len -= chunk;

net/bluetooth/af_bluetooth.c

516

skb->data_len -= chunk;

net/bluetooth/af_bluetooth.c

517

__skb_pull(frag, chunk);

net/bluetooth/af_bluetooth.c

521

chunk -= frag->len;

net/core/datagram.c

891

int chunk = skb->len - hlen;

net/core/datagram.c

893

if (!chunk)

net/core/datagram.c

896

if (msg_data_left(msg) < chunk) {

net/core/datagram.c

899

if (skb_copy_datagram_msg(skb, hlen, msg, chunk))

net/core/datagram.c

904

chunk, &csum))

net/core/datagram.c

908

iov_iter_revert(&msg->msg_iter, chunk);

net/core/devmem.c

34

struct gen_pool_chunk *chunk,

net/core/devmem.c

37

struct dmabuf_genpool_chunk_owner *owner = chunk->owner;

net/core/skbuff.c

6759

unsigned long chunk;

net/core/skbuff.c

6793

chunk = min_t(unsigned long, data_len,

net/core/skbuff.c

6795

skb_fill_page_desc(skb, nr_frags, page, 0, chunk);

net/core/skbuff.c

6798

data_len -= chunk;

net/core/tso.c

282

unsigned int region_len, chunk;

net/core/tso.c

289

chunk = min(len, region_len - offset);

net/core/tso.c

290

len -= chunk;

net/core/tso.c

321

unsigned int region_len, chunk;

net/core/tso.c

339

chunk = min(seg_remaining, region_len - map->offset);

net/core/tso.c

343

chunk = min(seg_remaining, region_len - map->offset);

net/core/tso.c

348

*chunk_len = chunk;

net/core/tso.c

349

map->offset += chunk;

net/devlink/region.c

760

u8 *chunk, u32 chunk_size,

net/devlink/region.c

770

err = nla_put(msg, DEVLINK_ATTR_REGION_CHUNK_DATA, chunk_size, chunk);

net/devlink/region.c

788

typedef int devlink_chunk_fill_t(void *cb_priv, u8 *chunk, u32 chunk_size,

net/devlink/region.c

832

devlink_region_snapshot_fill(void *cb_priv, u8 *chunk, u32 chunk_size,

net/devlink/region.c

838

memcpy(chunk, &snapshot->data[curr_offset], chunk_size);

net/devlink/region.c

844

devlink_region_port_direct_fill(void *cb_priv, u8 *chunk, u32 chunk_size,

net/devlink/region.c

850

curr_offset, chunk_size, chunk);

net/devlink/region.c

854

devlink_region_direct_fill(void *cb_priv, u8 *chunk, u32 chunk_size,

net/devlink/region.c

860

curr_offset, chunk_size, chunk);

net/ipv4/tcp_output.c

2499

u32 chunk = min(tp->snd_wnd, tcp_snd_cwnd(tp) * tp->mss_cache);

net/ipv4/tcp_output.c

2504

chunk /= win_divisor;

net/ipv4/tcp_output.c

2505

if (limit >= chunk)

net/sctp/associola.c

1000

chunk->auth_chunk = skb_clone(chunk->skb,

net/sctp/associola.c

1002

chunk->auth = 1;

net/sctp/associola.c

1015

if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)

net/sctp/associola.c

1021

if (sctp_chunk_is_data(chunk))

net/sctp/associola.c

1022

asoc->peer.last_data_from = chunk->transport;

net/sctp/associola.c

1026

if (chunk->chunk_hdr->type == SCTP_CID_SACK)

net/sctp/associola.c

1030

if (chunk->transport)

net/sctp/associola.c

1031

chunk->transport->last_time_heard = ktime_get();

net/sctp/associola.c

1035

state, ep, asoc, chunk, GFP_ATOMIC);

net/sctp/associola.c

1044

if (error && chunk)

net/sctp/associola.c

1045

chunk->pdiscard = 1;

net/sctp/associola.c

911

struct sctp_chunk *chunk;

net/sctp/associola.c

933

list_for_each_entry(chunk, &active->transmitted,

net/sctp/associola.c

936

if (key == chunk->subh.data_hdr->tsn) {

net/sctp/associola.c

948

list_for_each_entry(chunk, &transport->transmitted,

net/sctp/associola.c

950

if (key == chunk->subh.data_hdr->tsn) {

net/sctp/associola.c

969

struct sctp_chunk *chunk;

net/sctp/associola.c

980

while (NULL != (chunk = sctp_inq_pop(inqueue))) {

net/sctp/associola.c

982

subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);

net/sctp/associola.c

987

if (first_time && subtype.chunk == SCTP_CID_AUTH) {

net/sctp/auth.c

388

struct sctp_chunk *chunk;

net/sctp/auth.c

415

list_for_each_entry(chunk, &asoc->outqueue.out_chunk_list, list) {

net/sctp/auth.c

416

if (sctp_auth_send_cid(chunk->chunk_hdr->type, asoc)) {

net/sctp/auth.c

417

chunk->auth = 1;

net/sctp/auth.c

418

if (!chunk->shkey) {

net/sctp/auth.c

419

chunk->shkey = asoc->shkey;

net/sctp/auth.c

420

sctp_auth_shkey_hold(chunk->shkey);

net/sctp/auth.c

547

static int __sctp_auth_cid(enum sctp_cid chunk, struct sctp_chunks_param *param)

net/sctp/auth.c

573

if (param->chunks[i] == chunk)

net/sctp/auth.c

583

int sctp_auth_send_cid(enum sctp_cid chunk, const struct sctp_association *asoc)

net/sctp/auth.c

591

return __sctp_auth_cid(chunk, asoc->peer.peer_chunks);

net/sctp/auth.c

595

int sctp_auth_recv_cid(enum sctp_cid chunk, const struct sctp_association *asoc)

net/sctp/auth.c

603

return __sctp_auth_cid(chunk,

net/sctp/chunk.c

104

ev = sctp_ulpevent_make_send_failed_event(asoc, chunk,

net/sctp/chunk.c

111

sctp_chunk_put(chunk);

net/sctp/chunk.c

132

static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk)

net/sctp/chunk.c

135

chunk->msg = msg;

net/sctp/chunk.c

154

struct sctp_chunk *chunk;

net/sctp/chunk.c

263

chunk = asoc->stream.si->make_datafrag(asoc, sinfo, len, frag,

net/sctp/chunk.c

265

if (!chunk) {

net/sctp/chunk.c

270

err = sctp_user_addto_chunk(chunk, len, from);

net/sctp/chunk.c

274

chunk->shkey = shkey;

net/sctp/chunk.c

277

__skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr -

net/sctp/chunk.c

278

chunk->skb->data);

net/sctp/chunk.c

280

sctp_datamsg_assign(msg, chunk);

net/sctp/chunk.c

281

list_add_tail(&chunk->frag_list, &msg->chunks);

net/sctp/chunk.c

287

sctp_chunk_free(chunk);

net/sctp/chunk.c

292

chunk = list_entry(pos, struct sctp_chunk, frag_list);

net/sctp/chunk.c

293

sctp_chunk_free(chunk);

net/sctp/chunk.c

301

int sctp_chunk_abandoned(struct sctp_chunk *chunk)

net/sctp/chunk.c

303

if (!chunk->asoc->peer.prsctp_capable)

net/sctp/chunk.c

306

if (chunk->msg->abandoned)

net/sctp/chunk.c

309

if (!chunk->has_tsn &&

net/sctp/chunk.c

310

!(chunk->chunk_hdr->flags & SCTP_DATA_FIRST_FRAG))

net/sctp/chunk.c

313

if (SCTP_PR_TTL_ENABLED(chunk->sinfo.sinfo_flags) &&

net/sctp/chunk.c

314

time_after(jiffies, chunk->msg->expires_at)) {

net/sctp/chunk.c

316

SCTP_SO(&chunk->asoc->stream,

net/sctp/chunk.c

317

chunk->sinfo.sinfo_stream);

net/sctp/chunk.c

319

if (chunk->sent_count) {

net/sctp/chunk.c

320

chunk->asoc->abandoned_sent[SCTP_PR_INDEX(TTL)]++;

net/sctp/chunk.c

323

chunk->asoc->abandoned_unsent[SCTP_PR_INDEX(TTL)]++;

net/sctp/chunk.c

326

chunk->msg->abandoned = 1;

net/sctp/chunk.c

328

} else if (SCTP_PR_RTX_ENABLED(chunk->sinfo.sinfo_flags) &&

net/sctp/chunk.c

329

chunk->sent_count > chunk->sinfo.sinfo_timetolive) {

net/sctp/chunk.c

331

SCTP_SO(&chunk->asoc->stream,

net/sctp/chunk.c

332

chunk->sinfo.sinfo_stream);

net/sctp/chunk.c

334

chunk->asoc->abandoned_sent[SCTP_PR_INDEX(RTX)]++;

net/sctp/chunk.c

336

chunk->msg->abandoned = 1;

net/sctp/chunk.c

338

} else if (!SCTP_PR_POLICY(chunk->sinfo.sinfo_flags) &&

net/sctp/chunk.c

339

chunk->msg->expires_at &&

net/sctp/chunk.c

340

time_after(jiffies, chunk->msg->expires_at)) {

net/sctp/chunk.c

341

chunk->msg->abandoned = 1;

net/sctp/chunk.c

350

void sctp_chunk_fail(struct sctp_chunk *chunk, int error)

net/sctp/chunk.c

352

chunk->msg->send_failed = 1;

net/sctp/chunk.c

353

chunk->msg->send_error = error;

net/sctp/chunk.c

60

struct sctp_chunk *chunk;

net/sctp/chunk.c

65

list_for_each_entry(chunk, &msg->chunks, frag_list)

net/sctp/chunk.c

66

sctp_chunk_free(chunk);

net/sctp/chunk.c

76

struct sctp_chunk *chunk;

net/sctp/chunk.c

83

chunk = list_entry(pos, struct sctp_chunk, frag_list);

net/sctp/chunk.c

86

sctp_chunk_put(chunk);

net/sctp/chunk.c

90

asoc = chunk->asoc;

net/sctp/chunk.c

92

sent = chunk->has_tsn ? SCTP_DATA_SENT : SCTP_DATA_UNSENT;

net/sctp/chunk.c

96

ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent,

net/sctp/debug.c

50

if (cid.chunk <= SCTP_CID_BASE_MAX)

net/sctp/debug.c

51

return sctp_cid_tbl[cid.chunk];

net/sctp/debug.c

53

switch (cid.chunk) {

net/sctp/endpointola.c

335

struct sctp_chunk *chunk;

net/sctp/endpointola.c

350

while (NULL != (chunk = sctp_inq_pop(inqueue))) {

net/sctp/endpointola.c

351

subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);

net/sctp/endpointola.c

356

if (first_time && (subtype.chunk == SCTP_CID_AUTH)) {

net/sctp/endpointola.c

369

chunk->auth_chunk = skb_clone(chunk->skb,

net/sctp/endpointola.c

371

chunk->auth = 1;

net/sctp/endpointola.c

382

if (NULL == chunk->asoc) {

net/sctp/endpointola.c

384

sctp_source(chunk),

net/sctp/endpointola.c

386

chunk->asoc = asoc;

net/sctp/endpointola.c

387

chunk->transport = transport;

net/sctp/endpointola.c

391

if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)

net/sctp/endpointola.c

397

if (asoc && sctp_chunk_is_data(chunk))

net/sctp/endpointola.c

398

asoc->peer.last_data_from = chunk->transport;

net/sctp/endpointola.c

405

if (chunk->transport)

net/sctp/endpointola.c

406

chunk->transport->last_time_heard = ktime_get();

net/sctp/endpointola.c

409

ep, asoc, chunk, GFP_ATOMIC);

net/sctp/endpointola.c

411

if (error && chunk)

net/sctp/endpointola.c

412

chunk->pdiscard = 1;

net/sctp/input.c

197

chunk = sctp_chunkify(skb, asoc, sk, GFP_ATOMIC);

net/sctp/input.c

198

if (!chunk)

net/sctp/input.c

200

SCTP_INPUT_CB(skb)->chunk = chunk;

net/sctp/input.c

203

chunk->rcvr = rcvr;

net/sctp/input.c

206

chunk->sctp_hdr = sctp_hdr(skb);

net/sctp/input.c

209

sctp_init_addrs(chunk, &src, &dest);

net/sctp/input.c

212

chunk->transport = transport;

net/sctp/input.c

236

sctp_chunk_free(chunk);

net/sctp/input.c

243

sctp_inq_push(&chunk->rcvr->inqueue, chunk);

net/sctp/input.c

278

struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;

net/sctp/input.c

279

struct sctp_inq *inqueue = &chunk->rcvr->inqueue;

net/sctp/input.c

280

struct sctp_transport *t = chunk->transport;

net/sctp/input.c

284

rcvr = chunk->rcvr;

net/sctp/input.c

291

sctp_chunk_free(chunk);

net/sctp/input.c

313

sctp_chunk_free(chunk);

net/sctp/input.c

317

sctp_inq_push(inqueue, chunk);

net/sctp/input.c

329

sctp_chunk_free(chunk);

net/sctp/input.c

331

sctp_inq_push(inqueue, chunk);

net/sctp/input.c

349

struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;

net/sctp/input.c

350

struct sctp_transport *t = chunk->transport;

net/sctp/input.c

351

struct sctp_ep_common *rcvr = chunk->rcvr;

net/sctp/input.c

95

struct sctp_chunk *chunk;

net/sctp/inqueue.c

100

chunk->end_of_packet ||

net/sctp/inqueue.c

101

chunk->pdiscard)

net/sctp/inqueue.c

104

ch = (struct sctp_chunkhdr *)chunk->chunk_end;

net/sctp/inqueue.c

117

struct sctp_chunk *chunk;

net/sctp/inqueue.c

124

chunk = queue->in_progress;

net/sctp/inqueue.c

125

if (chunk) {

net/sctp/inqueue.c

129

if (chunk->singleton ||

net/sctp/inqueue.c

130

chunk->end_of_packet ||

net/sctp/inqueue.c

131

chunk->pdiscard) {

net/sctp/inqueue.c

132

if (chunk->head_skb == chunk->skb) {

net/sctp/inqueue.c

133

chunk->skb = skb_shinfo(chunk->skb)->frag_list;

net/sctp/inqueue.c

136

if (chunk->skb->next) {

net/sctp/inqueue.c

137

chunk->skb = chunk->skb->next;

net/sctp/inqueue.c

141

sctp_inq_chunk_free(chunk);

net/sctp/inqueue.c

142

chunk = queue->in_progress = NULL;

net/sctp/inqueue.c

145

ch = (struct sctp_chunkhdr *)chunk->chunk_end;

net/sctp/inqueue.c

147

skb_pull(chunk->skb, chunk->chunk_end - chunk->skb->data);

net/sctp/inqueue.c

153

if (!chunk) {

net/sctp/inqueue.c

162

chunk = list_entry(entry, struct sctp_chunk, list);

net/sctp/inqueue.c

164

if (skb_is_gso(chunk->skb) && skb_is_gso_sctp(chunk->skb)) {

net/sctp/inqueue.c

168

if (skb_shinfo(chunk->skb)->frag_list)

net/sctp/inqueue.c

169

chunk->head_skb = chunk->skb;

net/sctp/inqueue.c

172

if (chunk->head_skb && chunk->skb->data_len == chunk->skb->len) {

net/sctp/inqueue.c

173

if (WARN_ON(!skb_shinfo(chunk->skb)->frag_list)) {

net/sctp/inqueue.c

174

__SCTP_INC_STATS(dev_net(chunk->skb->dev),

net/sctp/inqueue.c

176

sctp_chunk_free(chunk);

net/sctp/inqueue.c

179

chunk->skb = skb_shinfo(chunk->skb)->frag_list;

net/sctp/inqueue.c

183

if (chunk->asoc)

net/sctp/inqueue.c

184

sock_rps_save_rxhash(chunk->asoc->base.sk, chunk->skb);

net/sctp/inqueue.c

186

queue->in_progress = chunk;

net/sctp/inqueue.c

190

ch = (struct sctp_chunkhdr *)chunk->skb->data;

net/sctp/inqueue.c

191

chunk->singleton = 1;

net/sctp/inqueue.c

192

chunk->data_accepted = 0;

net/sctp/inqueue.c

193

chunk->pdiscard = 0;

net/sctp/inqueue.c

194

chunk->auth = 0;

net/sctp/inqueue.c

195

chunk->has_asconf = 0;

net/sctp/inqueue.c

196

chunk->end_of_packet = 0;

net/sctp/inqueue.c

197

if (chunk->head_skb) {

net/sctp/inqueue.c

199

*cb = SCTP_INPUT_CB(chunk->skb),

net/sctp/inqueue.c

200

*head_cb = SCTP_INPUT_CB(chunk->head_skb);

net/sctp/inqueue.c

202

cb->chunk = head_cb->chunk;

net/sctp/inqueue.c

208

chunk->chunk_hdr = ch;

net/sctp/inqueue.c

209

chunk->chunk_end = ((__u8 *)ch) + SCTP_PAD4(ntohs(ch->length));

net/sctp/inqueue.c

210

skb_pull(chunk->skb, sizeof(*ch));

net/sctp/inqueue.c

211

chunk->subh.v = NULL; /* Subheader is no longer valid. */

net/sctp/inqueue.c

213

if (chunk->chunk_end + sizeof(*ch) <= skb_tail_pointer(chunk->skb)) {

net/sctp/inqueue.c

215

chunk->singleton = 0;

net/sctp/inqueue.c

216

} else if (chunk->chunk_end > skb_tail_pointer(chunk->skb)) {

net/sctp/inqueue.c

218

chunk->pdiscard = 1;

net/sctp/inqueue.c

219

chunk->chunk_end = skb_tail_pointer(chunk->skb);

net/sctp/inqueue.c

224

chunk->end_of_packet = 1;

net/sctp/inqueue.c

228

chunk, sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)),

net/sctp/inqueue.c

229

ntohs(chunk->chunk_hdr->length), chunk->skb->len);

net/sctp/inqueue.c

231

return chunk;

net/sctp/inqueue.c

42

static inline void sctp_inq_chunk_free(struct sctp_chunk *chunk)

net/sctp/inqueue.c

44

if (chunk->head_skb)

net/sctp/inqueue.c

45

chunk->skb = chunk->head_skb;

net/sctp/inqueue.c

46

sctp_chunk_free(chunk);

net/sctp/inqueue.c

52

struct sctp_chunk *chunk, *tmp;

net/sctp/inqueue.c

55

list_for_each_entry_safe(chunk, tmp, &queue->in_chunk_list, list) {

net/sctp/inqueue.c

56

list_del_init(&chunk->list);

net/sctp/inqueue.c

57

sctp_chunk_free(chunk);

net/sctp/inqueue.c

72

void sctp_inq_push(struct sctp_inq *q, struct sctp_chunk *chunk)

net/sctp/inqueue.c

75

if (chunk->rcvr->dead) {

net/sctp/inqueue.c

76

sctp_chunk_free(chunk);

net/sctp/inqueue.c

85

list_add_tail(&chunk->list, &q->in_chunk_list);

net/sctp/inqueue.c

86

if (chunk->asoc)

net/sctp/inqueue.c

87

chunk->asoc->stats.ipackets++;

net/sctp/inqueue.c

94

struct sctp_chunk *chunk;

net/sctp/inqueue.c

97

chunk = queue->in_progress;

net/sctp/inqueue.c

99

if (chunk->singleton ||

net/sctp/objcnt.c

37

SCTP_DBG_OBJCNT(chunk);

net/sctp/objcnt.c

50

SCTP_DBG_OBJCNT_ENTRY(chunk),

net/sctp/output.c

122

struct sctp_chunk *chunk = sctp_get_ecne_prepend(asoc);

net/sctp/output.c

124

if (chunk)

net/sctp/output.c

125

sctp_packet_append_chunk(packet, chunk);

net/sctp/output.c

163

struct sctp_chunk *chunk, *tmp;

net/sctp/output.c

167

list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {

net/sctp/output.c

168

list_del_init(&chunk->list);

net/sctp/output.c

169

sctp_chunk_free(chunk);

net/sctp/output.c

181

struct sctp_chunk *chunk,

net/sctp/output.c

187

packet, packet->size, chunk, chunk->skb ? chunk->skb->len : -1);

net/sctp/output.c

189

switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {

net/sctp/output.c

196

chunk->skb->sk->sk_err = -error;

net/sctp/output.c

203

chunk);

net/sctp/output.c

217

static enum sctp_xmit sctp_packet_bundle_pad(struct sctp_packet *pkt, struct sctp_chunk *chunk)

net/sctp/output.c

223

if (!chunk->pmtu_probe)

net/sctp/output.c

235

chunk->transport = t;

net/sctp/output.c

242

struct sctp_chunk *chunk)

net/sctp/output.c

255

if (chunk->chunk_hdr->type == SCTP_CID_AUTH || pkt->has_auth)

net/sctp/output.c

261

if (!chunk->auth)

net/sctp/output.c

264

auth = sctp_make_auth(asoc, chunk->shkey->key_id);

net/sctp/output.c

268

auth->shkey = chunk->shkey;

net/sctp/output.c

281

struct sctp_chunk *chunk)

net/sctp/output.c

288

if (sctp_chunk_is_data(chunk) && !pkt->has_sack &&

net/sctp/output.c

329

struct sctp_chunk *chunk)

net/sctp/output.c

331

__u16 chunk_len = SCTP_PAD4(ntohs(chunk->chunk_hdr->length));

net/sctp/output.c

335

retval = sctp_packet_will_fit(packet, chunk, chunk_len);

net/sctp/output.c

340

switch (chunk->chunk_hdr->type) {

net/sctp/output.c

344

sctp_packet_append_data(packet, chunk);

net/sctp/output.c

352

chunk->sent_at = jiffies;

net/sctp/output.c

354

chunk->sent_count++;

net/sctp/output.c

362

if (chunk->asoc)

net/sctp/output.c

363

chunk->asoc->stats.osacks++;

net/sctp/output.c

368

packet->auth = chunk;

net/sctp/output.c

373

list_add_tail(&chunk->list, &packet->chunk_list);

net/sctp/output.c

375

chunk->transport = packet->transport;

net/sctp/output.c

384

struct sctp_chunk *chunk)

net/sctp/output.c

388

pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk);

net/sctp/output.c

394

if (sctp_chunk_is_data(chunk)) {

net/sctp/output.c

395

retval = sctp_packet_can_append_data(packet, chunk);

net/sctp/output.c

401

retval = sctp_packet_bundle_auth(packet, chunk);

net/sctp/output.c

406

retval = sctp_packet_bundle_sack(packet, chunk);

net/sctp/output.c

410

retval = __sctp_packet_append_chunk(packet, chunk);

net/sctp/output.c

414

retval = sctp_packet_bundle_pad(packet, chunk);

net/sctp/output.c

441

struct sctp_chunk *chunk, *tmp;

net/sctp/output.c

459

list_for_each_entry_safe(chunk, tmp, &packet->chunk_list,

net/sctp/output.c

46

struct sctp_chunk *chunk);

net/sctp/output.c

461

int padded = SCTP_PAD4(chunk->skb->len);

net/sctp/output.c

463

if (chunk == packet->auth)

net/sctp/output.c

48

struct sctp_chunk *chunk);

net/sctp/output.c

480

list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {

net/sctp/output.c

483

list_del_init(&chunk->list);

net/sctp/output.c

484

if (sctp_chunk_is_data(chunk)) {

net/sctp/output.c

485

if (!sctp_chunk_retransmitted(chunk) &&

net/sctp/output.c

487

chunk->rtt_in_progress = 1;

net/sctp/output.c

492

padding = SCTP_PAD4(chunk->skb->len) - chunk->skb->len;

net/sctp/output.c

494

skb_put_zero(chunk->skb, padding);

net/sctp/output.c

496

if (chunk == packet->auth)

net/sctp/output.c

50

struct sctp_chunk *chunk);

net/sctp/output.c

500

skb_put_data(nskb, chunk->skb->data, chunk->skb->len);

net/sctp/output.c

503

chunk,

net/sctp/output.c

504

sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)),

net/sctp/output.c

505

chunk->has_tsn ? "TSN" : "No TSN",

net/sctp/output.c

506

chunk->has_tsn ? ntohl(chunk->subh.data_hdr->tsn) : 0,

net/sctp/output.c

507

ntohs(chunk->chunk_hdr->length), chunk->skb->len,

net/sctp/output.c

508

chunk->rtt_in_progress);

net/sctp/output.c

510

pkt_size -= SCTP_PAD4(chunk->skb->len);

net/sctp/output.c

512

if (!sctp_chunk_is_data(chunk) && chunk != packet->auth)

net/sctp/output.c

513

sctp_chunk_free(chunk);

net/sctp/output.c

52

struct sctp_chunk *chunk,

net/sctp/output.c

573

struct sctp_chunk *chunk, *tmp;

net/sctp/output.c

582

chunk = list_entry(packet->chunk_list.next, struct sctp_chunk, list);

net/sctp/output.c

583

sk = chunk->skb->sk;

net/sctp/output.c

585

if (packet->size > tp->pathmtu && !packet->ipfragok && !chunk->pmtu_probe) {

net/sctp/output.c

658

list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {

net/sctp/output.c

659

list_del_init(&chunk->list);

net/sctp/output.c

660

if (!sctp_chunk_is_data(chunk))

net/sctp/output.c

661

sctp_chunk_free(chunk);

net/sctp/output.c

673

struct sctp_chunk *chunk)

net/sctp/output.c

697

datasize = sctp_data_size(chunk);

net/sctp/output.c

717

if (chunk->fast_retransmit != SCTP_NEED_FRTX &&

net/sctp/output.c

742

if (chunk->skb->len + q->out_qlen > transport->pathmtu -

net/sctp/output.c

743

packet->overhead - sctp_datachk_len(&chunk->asoc->stream) - 4)

net/sctp/output.c

748

if (!chunk->msg->can_delay)

net/sctp/output.c

757

struct sctp_chunk *chunk)

net/sctp/output.c

760

size_t datasize = sctp_data_size(chunk);

net/sctp/output.c

777

sctp_chunk_assign_tsn(chunk);

net/sctp/output.c

778

asoc->stream.si->assign_number(chunk);

net/sctp/output.c

782

struct sctp_chunk *chunk,

net/sctp/output.c

793

if ((packet->auth && chunk->shkey != packet->auth->shkey) ||

net/sctp/output.c

794

(!packet->auth && chunk->shkey &&

net/sctp/output.c

795

chunk->chunk_hdr->type != SCTP_CID_AUTH))

net/sctp/output.c

814

(!packet->has_data && chunk->auth)) {

net/sctp/output.c

840

if (!sctp_chunk_is_data(chunk) && packet->has_data)

net/sctp/outqueue.c

1040

struct sctp_chunk *chunk;

net/sctp/outqueue.c

1084

while ((chunk = sctp_outq_dequeue_data(ctx->q)) != NULL) {

net/sctp/outqueue.c

1085

__u32 sid = ntohs(chunk->subh.data_hdr->stream);

net/sctp/outqueue.c

1089

if (sctp_chunk_abandoned(chunk)) {

net/sctp/outqueue.c

1090

sctp_sched_dequeue_done(ctx->q, chunk);

net/sctp/outqueue.c

1091

sctp_chunk_fail(chunk, 0);

net/sctp/outqueue.c

1092

sctp_chunk_free(chunk);

net/sctp/outqueue.c

1097

sctp_outq_head_data(ctx->q, chunk);

net/sctp/outqueue.c

1101

sctp_outq_select_transport(ctx, chunk);

net/sctp/outqueue.c

1104

__func__, ctx->q, chunk, chunk && chunk->chunk_hdr ?

net/sctp/outqueue.c

1105

sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :

net/sctp/outqueue.c

1106

"illegal chunk", ntohl(chunk->subh.data_hdr->tsn),

net/sctp/outqueue.c

1107

chunk->skb ? chunk->skb->head : NULL, chunk->skb ?

net/sctp/outqueue.c

1108

refcount_read(&chunk->skb->users) : -1);

net/sctp/outqueue.c

1111

status = sctp_packet_transmit_chunk(ctx->packet, chunk, 0,

net/sctp/outqueue.c

1118

__func__, ntohl(chunk->subh.data_hdr->tsn),

net/sctp/outqueue.c

1121

sctp_outq_head_data(ctx->q, chunk);

net/sctp/outqueue.c

1130

chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM;

net/sctp/outqueue.c

1131

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)

net/sctp/outqueue.c

1139

sctp_sched_dequeue_done(ctx->q, chunk);

net/sctp/outqueue.c

1141

list_add_tail(&chunk->transmitted_list,

net/sctp/outqueue.c

1248

int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk)

net/sctp/outqueue.c

1251

struct sctp_sackhdr *sack = chunk->subh.sack_hdr;

net/sctp/outqueue.c

1339

transport, &chunk->source, sack,

net/sctp/outqueue.c

1379

SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))

net/sctp/outqueue.c

1714

struct sctp_chunk *chunk;

net/sctp/outqueue.c

1720

list_for_each_entry(chunk, transmitted_queue, transmitted_list) {

net/sctp/outqueue.c

1722

tsn = ntohl(chunk->subh.data_hdr->tsn);

net/sctp/outqueue.c

1731

if (chunk->fast_retransmit == SCTP_CAN_FRTX &&

net/sctp/outqueue.c

1732

!chunk->tsn_gap_acked &&

net/sctp/outqueue.c

1739

chunk->transport,

net/sctp/outqueue.c

1741

chunk->tsn_missing_report++;

net/sctp/outqueue.c

1744

__func__, tsn, chunk->tsn_missing_report);

net/sctp/outqueue.c

1754

if (chunk->tsn_missing_report >= 3) {

net/sctp/outqueue.c

1755

chunk->fast_retransmit = SCTP_NEED_FRTX;

net/sctp/outqueue.c

1829

struct sctp_chunk *chunk;

net/sctp/outqueue.c

1866

chunk = list_entry(lchunk, struct sctp_chunk,

net/sctp/outqueue.c

1868

tsn = ntohl(chunk->subh.data_hdr->tsn);

net/sctp/outqueue.c

1875

sctp_chunk_free(chunk);

net/sctp/outqueue.c

1879

if (chunk->chunk_hdr->flags &

net/sctp/outqueue.c

1884

chunk->subh.data_hdr->stream);

net/sctp/outqueue.c

1886

chunk->subh.data_hdr->stream;

net/sctp/outqueue.c

1888

chunk->subh.data_hdr->ssn;

net/sctp/outqueue.c

210

struct sctp_chunk *chunk, *tmp;

net/sctp/outqueue.c

216

chunk = list_entry(lchunk, struct sctp_chunk,

net/sctp/outqueue.c

219

sctp_chunk_fail(chunk, q->error);

net/sctp/outqueue.c

220

sctp_chunk_free(chunk);

net/sctp/outqueue.c

227

chunk = list_entry(lchunk, struct sctp_chunk,

net/sctp/outqueue.c

229

sctp_chunk_fail(chunk, q->error);

net/sctp/outqueue.c

230

sctp_chunk_free(chunk);

net/sctp/outqueue.c

236

chunk = list_entry(lchunk, struct sctp_chunk,

net/sctp/outqueue.c

238

sctp_chunk_fail(chunk, q->error);

net/sctp/outqueue.c

239

sctp_chunk_free(chunk);

net/sctp/outqueue.c

245

chunk = list_entry(lchunk, struct sctp_chunk,

net/sctp/outqueue.c

247

sctp_chunk_fail(chunk, q->error);

net/sctp/outqueue.c

248

sctp_chunk_free(chunk);

net/sctp/outqueue.c

252

while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {

net/sctp/outqueue.c

253

sctp_sched_dequeue_done(q, chunk);

net/sctp/outqueue.c

256

sctp_chunk_fail(chunk, q->error);

net/sctp/outqueue.c

257

sctp_chunk_free(chunk);

net/sctp/outqueue.c

261

list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {

net/sctp/outqueue.c

262

list_del_init(&chunk->list);

net/sctp/outqueue.c

263

sctp_chunk_free(chunk);

net/sctp/outqueue.c

281

void sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp)

net/sctp/outqueue.c

285

pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk,

net/sctp/outqueue.c

286

chunk && chunk->chunk_hdr ?

net/sctp/outqueue.c

287

sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :

net/sctp/outqueue.c

293

if (sctp_chunk_is_data(chunk)) {

net/sctp/outqueue.c

295

__func__, q, chunk, chunk && chunk->chunk_hdr ?

net/sctp/outqueue.c

296

sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :

net/sctp/outqueue.c

299

sctp_outq_tail_data(q, chunk);

net/sctp/outqueue.c

300

if (chunk->asoc->peer.prsctp_capable &&

net/sctp/outqueue.c

301

SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))

net/sctp/outqueue.c

302

chunk->asoc->sent_cnt_removable++;

net/sctp/outqueue.c

303

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)

net/sctp/outqueue.c

308

list_add_tail(&chunk->list, &q->control_chunk_list);

net/sctp/outqueue.c

455

struct sctp_chunk *chunk;

net/sctp/outqueue.c

459

chunk = list_entry(lchunk, struct sctp_chunk,

net/sctp/outqueue.c

463

if (sctp_chunk_abandoned(chunk)) {

net/sctp/outqueue.c

472

if (!chunk->tsn_gap_acked) {

net/sctp/outqueue.c

473

if (chunk->transport)

net/sctp/outqueue.c

474

chunk->transport->flight_size -=

net/sctp/outqueue.c

475

sctp_data_size(chunk);

net/sctp/outqueue.c

476

q->outstanding_bytes -= sctp_data_size(chunk);

net/sctp/outqueue.c

477

q->asoc->peer.rwnd += sctp_data_size(chunk);

net/sctp/outqueue.c

487

(chunk->fast_retransmit == SCTP_NEED_FRTX)) ||

net/sctp/outqueue.c

488

(reason != SCTP_RTXR_FAST_RTX && !chunk->tsn_gap_acked)) {

net/sctp/outqueue.c

497

q->asoc->peer.rwnd += sctp_data_size(chunk);

net/sctp/outqueue.c

498

q->outstanding_bytes -= sctp_data_size(chunk);

net/sctp/outqueue.c

499

if (chunk->transport)

net/sctp/outqueue.c

500

transport->flight_size -= sctp_data_size(chunk);

net/sctp/outqueue.c

507

chunk->tsn_missing_report = 0;

net/sctp/outqueue.c

515

if (chunk->rtt_in_progress) {

net/sctp/outqueue.c

516

chunk->rtt_in_progress = 0;

net/sctp/outqueue.c

602

struct sctp_chunk *chunk, *chunk1;

net/sctp/outqueue.c

636

list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {

net/sctp/outqueue.c

638

if (sctp_chunk_abandoned(chunk)) {

net/sctp/outqueue.c

639

list_del_init(&chunk->transmitted_list);

net/sctp/outqueue.c

641

&chunk->transmitted_list);

net/sctp/outqueue.c

650

if (chunk->tsn_gap_acked) {

net/sctp/outqueue.c

651

list_move_tail(&chunk->transmitted_list,

net/sctp/outqueue.c

659

if (fast_rtx && !chunk->fast_retransmit)

net/sctp/outqueue.c

664

status = sctp_packet_append_chunk(pkt, chunk);

net/sctp/outqueue.c

716

list_move_tail(&chunk->transmitted_list,

net/sctp/outqueue.c

722

if (chunk->fast_retransmit == SCTP_NEED_FRTX)

net/sctp/outqueue.c

723

chunk->fast_retransmit = SCTP_DONT_FRTX;

net/sctp/outqueue.c

768

struct sctp_chunk *chunk, gfp_t gfp)

net/sctp/outqueue.c

778

if (sctp_packet_append_chunk(&singleton, chunk) != SCTP_XMIT_OK) {

net/sctp/outqueue.c

779

list_del_init(&chunk->list);

net/sctp/outqueue.c

780

sctp_chunk_free(chunk);

net/sctp/outqueue.c

801

struct sctp_chunk *chunk)

net/sctp/outqueue.c

803

struct sctp_transport *new_transport = chunk->transport;

net/sctp/outqueue.c

806

if (!sctp_chunk_is_data(chunk)) {

net/sctp/outqueue.c

816

if (ctx->transport && sctp_cmp_addr_exact(&chunk->dest,

net/sctp/outqueue.c

821

&chunk->dest);

net/sctp/outqueue.c

849

type = chunk->chunk_hdr->type;

net/sctp/outqueue.c

881

struct sctp_chunk *chunk, *tmp;

net/sctp/outqueue.c

885

list_for_each_entry_safe(chunk, tmp, &ctx->q->control_chunk_list, list) {

net/sctp/outqueue.c

895

chunk->chunk_hdr->type != SCTP_CID_ASCONF)

net/sctp/outqueue.c

898

list_del_init(&chunk->list);

net/sctp/outqueue.c

903

sctp_outq_select_transport(ctx, chunk);

net/sctp/outqueue.c

905

switch (chunk->chunk_hdr->type) {

net/sctp/outqueue.c

914

error = sctp_packet_singleton(ctx->transport, chunk,

net/sctp/outqueue.c

924

if (sctp_test_T_bit(chunk))

net/sctp/outqueue.c

944

if (chunk->pmtu_probe) {

net/sctp/outqueue.c

946

chunk, ctx->gfp);

net/sctp/outqueue.c

959

status = sctp_packet_transmit_chunk(ctx->packet, chunk,

net/sctp/outqueue.c

963

list_add(&chunk->list, &ctx->q->control_chunk_list);

net/sctp/outqueue.c

972

if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN ||

net/sctp/outqueue.c

973

chunk->chunk_hdr->type == SCTP_CID_I_FWD_TSN) {

net/sctp/outqueue.c

978

if (chunk == ctx->asoc->strreset_chunk)

net/sctp/sm_make_chunk.c

100

struct sk_buff *skb = chunk->skb;

net/sctp/sm_make_chunk.c

1044

static void *sctp_addto_param(struct sctp_chunk *chunk, int len,

net/sctp/sm_make_chunk.c

1047

int chunklen = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_make_chunk.c

1050

target = skb_put(chunk->skb, len);

net/sctp/sm_make_chunk.c

1058

chunk->chunk_hdr->length = htons(chunklen + len);

net/sctp/sm_make_chunk.c

1059

chunk->chunk_end = skb_tail_pointer(chunk->skb);

net/sctp/sm_make_chunk.c

1067

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1074

retval = sctp_make_abort(asoc, chunk, sizeof(struct sctp_errhdr) +

net/sctp/sm_make_chunk.c

1082

phdr.type = htons(chunk->chunk_hdr->type);

net/sctp/sm_make_chunk.c

1083

phdr.length = chunk->chunk_hdr->length;

net/sctp/sm_make_chunk.c

109

if (chunk->auth) {

net/sctp/sm_make_chunk.c

1093

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

110

chunk->shkey = asoc->shkey;

net/sctp/sm_make_chunk.c

1101

retval = sctp_make_abort(asoc, chunk, payload_len);

net/sctp/sm_make_chunk.c

111

sctp_auth_shkey_hold(chunk->shkey);

net/sctp/sm_make_chunk.c

1116

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1122

retval = sctp_make_abort(asoc, chunk, payload_len);

net/sctp/sm_make_chunk.c

1134

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1139

retval = sctp_make_abort(asoc, chunk,

net/sctp/sm_make_chunk.c

114

skb_shinfo(skb)->destructor_arg = chunk;

net/sctp/sm_make_chunk.c

1145

nep.cur_port = SCTP_INPUT_CB(chunk->skb)->encap_port;

net/sctp/sm_make_chunk.c

1146

nep.new_port = chunk->transport->encap_port;

net/sctp/sm_make_chunk.c

1187

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1209

if (chunk)

net/sctp/sm_make_chunk.c

1210

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

1247

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1266

if (chunk)

net/sctp/sm_make_chunk.c

1267

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

1282

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1294

return sctp_make_op_error_space(asoc, chunk, size);

net/sctp/sm_make_chunk.c

1299

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1305

retval = sctp_make_op_error_space(asoc, chunk, paylen + reserve_tail);

net/sctp/sm_make_chunk.c

135

int sctp_init_cause(struct sctp_chunk *chunk, __be16 cause_code,

net/sctp/sm_make_chunk.c

1390

SCTP_DBG_OBJCNT_INC(chunk);

net/sctp/sm_make_chunk.c

1398

void sctp_init_addrs(struct sctp_chunk *chunk, union sctp_addr *src,

net/sctp/sm_make_chunk.c

1401

memcpy(&chunk->source, src, sizeof(union sctp_addr));

net/sctp/sm_make_chunk.c

1402

memcpy(&chunk->dest, dest, sizeof(union sctp_addr));

net/sctp/sm_make_chunk.c

1406

const union sctp_addr *sctp_source(const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1409

if (chunk->transport) {

net/sctp/sm_make_chunk.c

1410

return &chunk->transport->ipaddr;

net/sctp/sm_make_chunk.c

1413

return &chunk->source;

net/sctp/sm_make_chunk.c

146

if (skb_tailroom(chunk->skb) < len)

net/sctp/sm_make_chunk.c

1480

struct sctp_chunk *chunk;

net/sctp/sm_make_chunk.c

1482

chunk = _sctp_make_chunk(asoc, type, flags, paylen, gfp);

net/sctp/sm_make_chunk.c

1483

if (chunk)

net/sctp/sm_make_chunk.c

1484

sctp_control_set_owner_w(chunk);

net/sctp/sm_make_chunk.c

1486

return chunk;

net/sctp/sm_make_chunk.c

149

chunk->subh.err_hdr = sctp_addto_chunk(chunk, sizeof(err), &err);

net/sctp/sm_make_chunk.c

1490

static void sctp_chunk_destroy(struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1492

BUG_ON(!list_empty(&chunk->list));

net/sctp/sm_make_chunk.c

1493

list_del_init(&chunk->transmitted_list);

net/sctp/sm_make_chunk.c

1495

consume_skb(chunk->skb);

net/sctp/sm_make_chunk.c

1496

consume_skb(chunk->auth_chunk);

net/sctp/sm_make_chunk.c

1498

SCTP_DBG_OBJCNT_DEC(chunk);

net/sctp/sm_make_chunk.c

1499

kmem_cache_free(sctp_chunk_cachep, chunk);

net/sctp/sm_make_chunk.c

1503

void sctp_chunk_free(struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1506

if (chunk->msg)

net/sctp/sm_make_chunk.c

1507

sctp_datamsg_put(chunk->msg);

net/sctp/sm_make_chunk.c

1509

sctp_chunk_put(chunk);

net/sctp/sm_make_chunk.c

1528

void *sctp_addto_chunk(struct sctp_chunk *chunk, int len, const void *data)

net/sctp/sm_make_chunk.c

1530

int chunklen = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_make_chunk.c

1534

skb_put_zero(chunk->skb, padlen);

net/sctp/sm_make_chunk.c

1535

target = skb_put_data(chunk->skb, data, len);

net/sctp/sm_make_chunk.c

1538

chunk->chunk_hdr->length = htons(chunklen + padlen + len);

net/sctp/sm_make_chunk.c

1539

chunk->chunk_end = skb_tail_pointer(chunk->skb);

net/sctp/sm_make_chunk.c

1548

int sctp_user_addto_chunk(struct sctp_chunk *chunk, int len,

net/sctp/sm_make_chunk.c

1554

target = skb_put(chunk->skb, len);

net/sctp/sm_make_chunk.c

1561

chunk->chunk_hdr->length =

net/sctp/sm_make_chunk.c

1562

htons(ntohs(chunk->chunk_hdr->length) + len);

net/sctp/sm_make_chunk.c

1563

chunk->chunk_end = skb_tail_pointer(chunk->skb);

net/sctp/sm_make_chunk.c

1571

void sctp_chunk_assign_ssn(struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1578

if (chunk->has_ssn)

net/sctp/sm_make_chunk.c

1582

sid = ntohs(chunk->subh.data_hdr->stream);

net/sctp/sm_make_chunk.c

1583

stream = &chunk->asoc->stream;

net/sctp/sm_make_chunk.c

1588

msg = chunk->msg;

net/sctp/sm_make_chunk.c

1607

void sctp_chunk_assign_tsn(struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

1609

if (!chunk->has_tsn) {

net/sctp/sm_make_chunk.c

1613

chunk->subh.data_hdr->tsn =

net/sctp/sm_make_chunk.c

1614

htonl(sctp_association_get_next_tsn(chunk->asoc));

net/sctp/sm_make_chunk.c

1615

chunk->has_tsn = 1;

net/sctp/sm_make_chunk.c

1621

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1629

scope = sctp_scope(sctp_source(chunk));

net/sctp/sm_make_chunk.c

1634

skb = chunk->skb;

net/sctp/sm_make_chunk.c

1725

struct sctp_chunk *chunk, gfp_t gfp,

net/sctp/sm_make_chunk.c

1731

struct sk_buff *skb = chunk->skb;

net/sctp/sm_make_chunk.c

1744

bodysize = ntohs(chunk->chunk_hdr->length) - headersize;

net/sctp/sm_make_chunk.c

1751

len = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_make_chunk.c

1760

cookie = chunk->subh.cookie_hdr;

net/sctp/sm_make_chunk.c

1794

if (ntohl(chunk->sctp_hdr->vtag) != bear_cookie->my_vtag) {

net/sctp/sm_make_chunk.c

1799

if (chunk->sctp_hdr->source != bear_cookie->peer_addr.v4.sin_port ||

net/sctp/sm_make_chunk.c

1800

ntohs(chunk->sctp_hdr->dest) != bear_cookie->my_port) {

net/sctp/sm_make_chunk.c

1830

*errp = sctp_make_op_error(asoc, chunk,

net/sctp/sm_make_chunk.c

1842

scope = sctp_scope(sctp_source(chunk));

net/sctp/sm_make_chunk.c

1850

retval->peer.port = ntohs(chunk->sctp_hdr->source);

net/sctp/sm_make_chunk.c

1863

sctp_add_bind_addr(&retval->base.bind_addr, &chunk->dest,

net/sctp/sm_make_chunk.c

1864

sizeof(chunk->dest), SCTP_ADDR_SRC,

net/sctp/sm_make_chunk.c

1907

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1919

*errp = sctp_make_op_error_space(asoc, chunk, len);

net/sctp/sm_make_chunk.c

1935

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1941

*errp = sctp_make_op_error_space(asoc, chunk, 0);

net/sctp/sm_make_chunk.c

1952

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1962

*errp = sctp_make_violation_paramlen(asoc, chunk, param);

net/sctp/sm_make_chunk.c

1973

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

1986

*errp = sctp_make_op_error(asoc, chunk, SCTP_ERROR_DNS_FAILED,

net/sctp/sm_make_chunk.c

2094

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

2113

*errp = sctp_make_op_error_limited(asoc, chunk);

net/sctp/sm_make_chunk.c

2149

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

2186

chunk, err_chunk);

net/sctp/sm_make_chunk.c

2193

sctp_process_hn_param(asoc, param, chunk, err_chunk);

net/sctp/sm_make_chunk.c

2214

chunk, err_chunk);

net/sctp/sm_make_chunk.c

2230

chunk, err_chunk);

net/sctp/sm_make_chunk.c

2255

sctp_process_inv_paramlength(asoc, param.p, chunk,

net/sctp/sm_make_chunk.c

2265

retval = sctp_process_unk_param(asoc, param, chunk, err_chunk);

net/sctp/sm_make_chunk.c

2275

struct sctp_chunk *chunk, struct sctp_chunk **errp)

net/sctp/sm_make_chunk.c

2289

return sctp_process_inv_mandatory(asoc, chunk, errp);

net/sctp/sm_make_chunk.c

2305

return sctp_process_inv_paramlength(asoc, param.p, chunk, errp);

net/sctp/sm_make_chunk.c

2312

chunk, errp);

net/sctp/sm_make_chunk.c

2317

chunk, errp);

net/sctp/sm_make_chunk.c

2338

int sctp_process_init(struct sctp_association *asoc, struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

2359

asoc->encap_port = SCTP_INPUT_CB(chunk->skb)->encap_port;

net/sctp/sm_make_chunk.c

2363

if (sctp_cmp_addr_exact(sctp_source(chunk), peer_addr))

net/sctp/sm_make_chunk.c

2373

chunk->sctp_hdr->source, 0))

net/sctp/sm_make_chunk.c

2375

if (sctp_cmp_addr_exact(sctp_source(chunk), &addr))

net/sctp/sm_make_chunk.c

2997

static void sctp_add_asconf_response(struct sctp_chunk *chunk, __be32 crr_id,

net/sctp/sm_make_chunk.c

3023

sctp_addto_chunk(chunk, sizeof(ack_param), &ack_param);

net/sctp/sm_make_chunk.c

3031

sctp_addto_chunk(chunk, err_param_len, &err_param);

net/sctp/sm_make_chunk.c

3035

sctp_addto_chunk(chunk, asconf_param_len, asconf_param);

net/sctp/sm_make_chunk.c

3192

struct sctp_chunk *chunk, bool addr_param_needed,

net/sctp/sm_make_chunk.c

3199

addip = (struct sctp_addip_chunk *)chunk->chunk_hdr;

net/sctp/sm_make_chunk.c

3251

if (param.v != chunk->chunk_end)

net/sctp/sm_make_chunk.c

372

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

3867

struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

3875

hdr = (struct sctp_reconf_chunk *)chunk->chunk_hdr;

net/sctp/sm_make_chunk.c

403

cookie = sctp_pack_cookie(asoc->ep, asoc, chunk, &cookie_len,

net/sctp/sm_make_chunk.c

477

if (chunk->transport)

net/sctp/sm_make_chunk.c

480

&chunk->transport->ipaddr);

net/sctp/sm_make_chunk.c

560

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

586

if (chunk)

net/sctp/sm_make_chunk.c

587

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

612

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

627

if (retval && chunk && chunk->transport)

net/sctp/sm_make_chunk.c

630

&chunk->transport->ipaddr);

net/sctp/sm_make_chunk.c

660

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

67

static void *sctp_addto_param(struct sctp_chunk *chunk, int len,

net/sctp/sm_make_chunk.c

685

if (chunk)

net/sctp/sm_make_chunk.c

686

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

73

struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;

net/sctp/sm_make_chunk.c

75

if (chunk->shkey) {

net/sctp/sm_make_chunk.c

76

struct sctp_shared_key *shkey = chunk->shkey;

net/sctp/sm_make_chunk.c

77

struct sctp_association *asoc = chunk->asoc;

net/sctp/sm_make_chunk.c

847

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

864

if (chunk)

net/sctp/sm_make_chunk.c

865

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

871

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

887

if (retval && chunk)

net/sctp/sm_make_chunk.c

888

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

895

const struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

918

if (retval && chunk)

net/sctp/sm_make_chunk.c

919

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

928

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

93

sctp_auth_shkey_release(chunk->shkey);

net/sctp/sm_make_chunk.c

938

if (chunk && chunk->chunk_hdr &&

net/sctp/sm_make_chunk.c

939

chunk->chunk_hdr->type == SCTP_CID_INIT)

net/sctp/sm_make_chunk.c

957

if (retval && chunk)

net/sctp/sm_make_chunk.c

958

retval->transport = chunk->transport;

net/sctp/sm_make_chunk.c

966

const struct sctp_chunk *chunk,

net/sctp/sm_make_chunk.c

97

static void sctp_control_set_owner_w(struct sctp_chunk *chunk)

net/sctp/sm_make_chunk.c

972

retval = sctp_make_abort(asoc, chunk,

net/sctp/sm_make_chunk.c

99

struct sctp_association *asoc = chunk->asoc;

net/sctp/sm_make_chunk.c

992

if (chunk)

net/sctp/sm_make_chunk.c

993

retval->transport = chunk->transport;

net/sctp/sm_sideeffect.c

1116

struct sctp_chunk *chunk;

net/sctp/sm_sideeffect.c

1118

list_for_each_entry(chunk, &msg->chunks, frag_list)

net/sctp/sm_sideeffect.c

1119

sctp_outq_tail(&asoc->outqueue, chunk, gfp);

net/sctp/sm_sideeffect.c

119

repl = sctp_make_cwr(asoc, asoc->last_cwr_tsn, chunk);

net/sctp/sm_sideeffect.c

1214

event_type, subtype.chunk);

net/sctp/sm_sideeffect.c

1242

state, subtype.chunk);

net/sctp/sm_sideeffect.c

1247

state, event_type, subtype.chunk);

net/sctp/sm_sideeffect.c

1252

state, event_type, subtype.chunk);

net/sctp/sm_sideeffect.c

1258

status, state, event_type, subtype.chunk);

net/sctp/sm_sideeffect.c

1286

struct sctp_chunk *chunk = NULL, *new_obj;

net/sctp/sm_sideeffect.c

1298

chunk = event_arg;

net/sctp/sm_sideeffect.c

1357

cmd->obj.chunk);

net/sctp/sm_sideeffect.c

1373

cmd->obj.chunk);

net/sctp/sm_sideeffect.c

1378

new_obj = sctp_make_init_ack(asoc, chunk, GFP_ATOMIC,

net/sctp/sm_sideeffect.c

1395

error = sctp_cmd_process_init(commands, asoc, chunk,

net/sctp/sm_sideeffect.c

1401

new_obj = sctp_make_cookie_echo(asoc, chunk);

net/sctp/sm_sideeffect.c

1403

if (cmd->obj.chunk)

net/sctp/sm_sideeffect.c

1404

sctp_chunk_free(cmd->obj.chunk);

net/sctp/sm_sideeffect.c

1414

if (cmd->obj.chunk)

net/sctp/sm_sideeffect.c

1416

SCTP_CHUNK(cmd->obj.chunk));

net/sctp/sm_sideeffect.c

1452

new_obj = sctp_make_shutdown(asoc, chunk);

net/sctp/sm_sideeffect.c

1464

__func__, cmd->obj.chunk, &asoc->ulpq);

net/sctp/sm_sideeffect.c

1467

cmd->obj.chunk,

net/sctp/sm_sideeffect.c

1487

sctp_outq_tail(&asoc->outqueue, cmd->obj.chunk, gfp);

net/sctp/sm_sideeffect.c

1517

chunk);

net/sctp/sm_sideeffect.c

1529

sctp_cmd_setup_t2(commands, asoc, cmd->obj.chunk);

net/sctp/sm_sideeffect.c

1571

chunk = cmd->obj.chunk;

net/sctp/sm_sideeffect.c

1575

chunk->transport = t;

net/sctp/sm_sideeffect.c

1627

subtype, chunk, cmd->obj.u16);

net/sctp/sm_sideeffect.c

1672

sctp_cmd_transport_on(commands, asoc, t, chunk);

net/sctp/sm_sideeffect.c

1704

chunk->subh.sack_hdr = &sackh;

net/sctp/sm_sideeffect.c

1706

SCTP_CHUNK(chunk));

net/sctp/sm_sideeffect.c

1714

chunk->pdiscard = 1;

net/sctp/sm_sideeffect.c

1732

cmd->obj.chunk,

net/sctp/sm_sideeffect.c

1737

sctp_cmd_setup_t4(commands, asoc, cmd->obj.chunk);

net/sctp/sm_sideeffect.c

1741

sctp_cmd_process_operr(commands, asoc, chunk);

net/sctp/sm_sideeffect.c

1809

sctp_chunk_free(cmd->obj.chunk);

net/sctp/sm_sideeffect.c

1820

if (asoc && SCTP_EVENT_T_CHUNK == event_type && chunk) {

net/sctp/sm_sideeffect.c

1821

if (chunk->end_of_packet || chunk->singleton)

net/sctp/sm_sideeffect.c

658

struct sctp_chunk *chunk,

net/sctp/sm_sideeffect.c

667

if (event_type == SCTP_EVENT_T_CHUNK && subtype.chunk == SCTP_CID_ABORT)

net/sctp/sm_sideeffect.c

669

(__u16)error, 0, 0, chunk,

net/sctp/sm_sideeffect.c

680

abort = sctp_make_violation_max_retrans(asoc, chunk);

net/sctp/sm_sideeffect.c

701

struct sctp_chunk *chunk,

net/sctp/sm_sideeffect.c

712

if (!sctp_process_init(asoc, chunk, sctp_source(chunk), peer_init, gfp))

net/sctp/sm_sideeffect.c

766

struct sctp_chunk *chunk)

net/sctp/sm_sideeffect.c

822

hbinfo = (struct sctp_sender_hb_info *)chunk->skb->data;

net/sctp/sm_sideeffect.c

836

struct sctp_chunk *chunk)

net/sctp/sm_sideeffect.c

840

if (sctp_outq_sack(&asoc->outqueue, chunk)) {

net/sctp/sm_sideeffect.c

856

struct sctp_chunk *chunk)

net/sctp/sm_sideeffect.c

860

if (chunk->transport)

net/sctp/sm_sideeffect.c

861

t = chunk->transport;

net/sctp/sm_sideeffect.c

865

chunk->transport = t;

net/sctp/sm_sideeffect.c

87

struct sctp_chunk *chunk)

net/sctp/sm_sideeffect.c

961

struct sctp_chunk *chunk)

net/sctp/sm_sideeffect.c

965

t = sctp_assoc_choose_alter_transport(asoc, chunk->transport);

net/sctp/sm_sideeffect.c

967

chunk->transport = t;

net/sctp/sm_sideeffect.c

973

struct sctp_chunk *chunk)

net/sctp/sm_sideeffect.c

978

while (chunk->chunk_end > chunk->skb->data) {

net/sctp/sm_sideeffect.c

979

err_hdr = (struct sctp_errhdr *)(chunk->skb->data);

net/sctp/sm_sideeffect.c

981

ev = sctp_ulpevent_make_remote_error(asoc, chunk, 0,

net/sctp/sm_statefuns.c

100

static struct sctp_sackhdr *sctp_sm_pull_sack(struct sctp_chunk *chunk);

net/sctp/sm_statefuns.c

1189

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

1193

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

1197

if (!sctp_chunk_length_valid(chunk,

net/sctp/sm_statefuns.c

1206

chunk->subh.hb_hdr = (struct sctp_heartbeathdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

1207

param_hdr = (struct sctp_paramhdr *)chunk->subh.hb_hdr;

net/sctp/sm_statefuns.c

1208

paylen = ntohs(chunk->chunk_hdr->length) - sizeof(struct sctp_chunkhdr);

net/sctp/sm_statefuns.c

1214

if (!pskb_pull(chunk->skb, paylen))

net/sctp/sm_statefuns.c

1217

reply = sctp_make_heartbeat_ack(asoc, chunk, param_hdr, paylen);

net/sctp/sm_statefuns.c

1264

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

1269

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

1273

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr) +

net/sctp/sm_statefuns.c

1278

hbinfo = (struct sctp_sender_hb_info *)chunk->skb->data;

net/sctp/sm_statefuns.c

152

struct sctp_chunk *chunk);

net/sctp/sm_statefuns.c

1537

struct sctp_chunk *chunk = arg, *repl, *err_chunk;

net/sctp/sm_statefuns.c

1553

if (!chunk->singleton)

net/sctp/sm_statefuns.c

1557

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_init_chunk)))

net/sctp/sm_statefuns.c

1563

if (chunk->sctp_hdr->vtag != 0)

net/sctp/sm_statefuns.c

1566

if (SCTP_INPUT_CB(chunk->skb)->encap_port != chunk->transport->encap_port)

net/sctp/sm_statefuns.c

1570

chunk->subh.init_hdr = (struct sctp_inithdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

1573

chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(struct sctp_inithdr));

net/sctp/sm_statefuns.c

1577

if (ntohl(chunk->subh.init_hdr->init_tag) == asoc->peer.i.init_tag)

net/sctp/sm_statefuns.c

1583

if (!sctp_verify_init(net, ep, asoc, chunk->chunk_hdr->type,

net/sctp/sm_statefuns.c

1584

(struct sctp_init_chunk *)chunk->chunk_hdr, chunk,

net/sctp/sm_statefuns.c

1618

new_asoc = sctp_make_temp_asoc(ep, chunk, GFP_ATOMIC);

net/sctp/sm_statefuns.c

1623

if (security_sctp_assoc_request(new_asoc, chunk->skb)) {

net/sctp/sm_statefuns.c

1631

sctp_scope(sctp_source(chunk)), GFP_ATOMIC) < 0)

net/sctp/sm_statefuns.c

1638

if (!sctp_process_init(new_asoc, chunk, sctp_source(chunk),

net/sctp/sm_statefuns.c

1639

(struct sctp_init_chunk *)chunk->chunk_hdr,

net/sctp/sm_statefuns.c

1649

if (!sctp_sf_check_restart_addrs(new_asoc, asoc, chunk,

net/sctp/sm_statefuns.c

1669

repl = sctp_make_init_ack(new_asoc, chunk, GFP_ATOMIC, len);

net/sctp/sm_statefuns.c

175

static inline bool sctp_chunk_length_valid(struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

178

__u16 chunk_length = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_statefuns.c

181

if (unlikely(chunk->pdiscard))

net/sctp/sm_statefuns.c

1886

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

1899

peer_init = (struct sctp_init_chunk *)(chunk->subh.cookie_hdr + 1);

net/sctp/sm_statefuns.c

190

static inline bool sctp_err_chunk_valid(struct sctp_chunk *chunk)

net/sctp/sm_statefuns.c

1900

if (!sctp_process_init(new_asoc, chunk, sctp_source(chunk), peer_init,

net/sctp/sm_statefuns.c

1907

if (!sctp_auth_chunk_verify(net, chunk, new_asoc))

net/sctp/sm_statefuns.c

1914

if (!sctp_sf_check_restart_addrs(new_asoc, asoc, chunk, commands))

net/sctp/sm_statefuns.c

1925

SCTP_ST_CHUNK(chunk->chunk_hdr->type),

net/sctp/sm_statefuns.c

1926

chunk, commands);

net/sctp/sm_statefuns.c

1930

err = sctp_make_op_error(asoc, chunk,

net/sctp/sm_statefuns.c

194

sctp_walk_errors(err, chunk->chunk_hdr);

net/sctp/sm_statefuns.c

1959

repl = sctp_make_cookie_ack(asoc, chunk);

net/sctp/sm_statefuns.c

196

return (void *)err == (void *)chunk->chunk_end;

net/sctp/sm_statefuns.c

2009

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

2019

peer_init = (struct sctp_init_chunk *)(chunk->subh.cookie_hdr + 1);

net/sctp/sm_statefuns.c

2020

if (!sctp_process_init(new_asoc, chunk, sctp_source(chunk), peer_init,

net/sctp/sm_statefuns.c

2027

if (!sctp_auth_chunk_verify(net, chunk, new_asoc))

net/sctp/sm_statefuns.c

2040

repl = sctp_make_cookie_ack(asoc, chunk);

net/sctp/sm_statefuns.c

2093

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

2116

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

2130

if (!sctp_auth_chunk_verify(net, chunk, asoc))

net/sctp/sm_statefuns.c

2180

repl = sctp_make_cookie_ack(asoc, chunk);

net/sctp/sm_statefuns.c

2235

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2246

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr))) {

net/sctp/sm_statefuns.c

2247

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

2255

chunk->subh.cookie_hdr = (struct sctp_signed_cookie *)chunk->skb->data;

net/sctp/sm_statefuns.c

2256

if (!pskb_pull(chunk->skb, ntohs(chunk->chunk_hdr->length) -

net/sctp/sm_statefuns.c

2265

new_asoc = sctp_unpack_cookie(ep, asoc, chunk, GFP_ATOMIC, &error,

net/sctp/sm_statefuns.c

2283

sctp_send_stale_cookie_err(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

2307

(chunk->subh.cookie_hdr + 1);

net/sctp/sm_statefuns.c

2310

!sctp_verify_init(net, ep, asoc, cid, peer_init, chunk,

net/sctp/sm_statefuns.c

2324

chunk->head_skb ?: chunk->skb)) {

net/sctp/sm_statefuns.c

2333

retval = sctp_sf_do_dupcook_a(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

2338

retval = sctp_sf_do_dupcook_b(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

2343

retval = sctp_sf_do_dupcook_c(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

2348

retval = sctp_sf_do_dupcook_d(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

2386

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2388

if (!sctp_vtag_verify_either(chunk, asoc))

net/sctp/sm_statefuns.c

240

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2401

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_abort_chunk)))

net/sctp/sm_statefuns.c

2410

sctp_bind_addr_state(&asoc->base.bind_addr, &chunk->dest))

net/sctp/sm_statefuns.c

2413

if (!sctp_err_chunk_valid(chunk))

net/sctp/sm_statefuns.c

243

if (!sctp_vtag_verify_either(chunk, asoc))

net/sctp/sm_statefuns.c

2432

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2434

if (!sctp_vtag_verify_either(chunk, asoc))

net/sctp/sm_statefuns.c

2447

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_abort_chunk)))

net/sctp/sm_statefuns.c

2456

sctp_bind_addr_state(&asoc->base.bind_addr, &chunk->dest))

net/sctp/sm_statefuns.c

2459

if (!sctp_err_chunk_valid(chunk))

net/sctp/sm_statefuns.c

251

if (!chunk->singleton)

net/sctp/sm_statefuns.c

2514

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2517

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

2523

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_operr_chunk)))

net/sctp/sm_statefuns.c

2532

sctp_walk_errors(err, chunk->chunk_hdr) {

net/sctp/sm_statefuns.c

255

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

2702

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2704

if (!sctp_vtag_verify_either(chunk, asoc))

net/sctp/sm_statefuns.c

2717

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_abort_chunk)))

net/sctp/sm_statefuns.c

2726

sctp_bind_addr_state(&asoc->base.bind_addr, &chunk->dest))

net/sctp/sm_statefuns.c

2729

if (!sctp_err_chunk_valid(chunk))

net/sctp/sm_statefuns.c

2744

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2748

len = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_statefuns.c

2750

error = ((struct sctp_errhdr *)chunk->skb->data)->cause;

net/sctp/sm_statefuns.c

2775

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2778

if (!sctp_vtag_verify_either(chunk, asoc))

net/sctp/sm_statefuns.c

2791

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_abort_chunk)))

net/sctp/sm_statefuns.c

2795

len = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_statefuns.c

2797

error = ((struct sctp_errhdr *)chunk->skb->data)->cause;

net/sctp/sm_statefuns.c

2800

chunk->transport);

net/sctp/sm_statefuns.c

2905

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2910

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

2914

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_shutdown_chunk)))

net/sctp/sm_statefuns.c

2919

sdh = (struct sctp_shutdownhdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

2920

skb_pull(chunk->skb, sizeof(*sdh));

net/sctp/sm_statefuns.c

2921

chunk->subh.shutdown_hdr = sdh;

net/sctp/sm_statefuns.c

2972

SCTP_BE32(chunk->subh.shutdown_hdr->cum_tsn_ack));

net/sctp/sm_statefuns.c

2994

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

2998

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3002

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_shutdown_chunk)))

net/sctp/sm_statefuns.c

3006

sdh = (struct sctp_shutdownhdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

3046

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3050

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

3058

reply = sctp_make_shutdown_ack(asoc, chunk);

net/sctp/sm_statefuns.c

3084

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3086

if (!chunk->singleton)

net/sctp/sm_statefuns.c

3089

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_init_chunk)))

net/sctp/sm_statefuns.c

3092

if (chunk->sctp_hdr->vtag != 0)

net/sctp/sm_statefuns.c

3130

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3134

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3137

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_ecne_chunk)))

net/sctp/sm_statefuns.c

3141

cwr = (struct sctp_cwrhdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

3142

skb_pull(chunk->skb, sizeof(*cwr));

net/sctp/sm_statefuns.c

3185

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3188

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3191

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_ecne_chunk)))

net/sctp/sm_statefuns.c

3195

ecne = (struct sctp_ecnehdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

3196

skb_pull(chunk->skb, sizeof(*ecne));

net/sctp/sm_statefuns.c

3243

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3246

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

3252

if (!sctp_chunk_length_valid(chunk, sctp_datachk_len(&asoc->stream)))

net/sctp/sm_statefuns.c

3256

error = sctp_eat_data(asoc, chunk, commands);

net/sctp/sm_statefuns.c

326

struct sctp_chunk *chunk = arg, *repl, *err_chunk;

net/sctp/sm_statefuns.c

3271

return sctp_sf_abort_violation(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

3272

(u8 *)chunk->subh.data_hdr,

net/sctp/sm_statefuns.c

3278

if (chunk->chunk_hdr->flags & SCTP_DATA_SACK_IMM)

net/sctp/sm_statefuns.c

3308

if (chunk->end_of_packet)

net/sctp/sm_statefuns.c

3328

if (chunk->end_of_packet)

net/sctp/sm_statefuns.c

3333

if (chunk->end_of_packet)

net/sctp/sm_statefuns.c

3363

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3366

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

3372

if (!sctp_chunk_length_valid(chunk, sctp_datachk_len(&asoc->stream)))

net/sctp/sm_statefuns.c

3376

error = sctp_eat_data(asoc, chunk, commands);

net/sctp/sm_statefuns.c

3387

return sctp_sf_abort_violation(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

3388

(u8 *)chunk->subh.data_hdr,

net/sctp/sm_statefuns.c

3402

if (chunk->end_of_packet) {

net/sctp/sm_statefuns.c

341

if (!chunk->singleton)

net/sctp/sm_statefuns.c

3454

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3458

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3462

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_sack_chunk)))

net/sctp/sm_statefuns.c

3467

sackh = sctp_sm_pull_sack(chunk);

net/sctp/sm_statefuns.c

3471

chunk->subh.sack_hdr = sackh;

net/sctp/sm_statefuns.c

3481

trace_sctp_probe(ep, asoc, chunk);

net/sctp/sm_statefuns.c

349

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_init_chunk)))

net/sctp/sm_statefuns.c

3497

sctp_add_cmd_sf(commands, SCTP_CMD_PROCESS_SACK, SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

3532

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3535

packet = sctp_ootb_pkt_new(net, asoc, chunk);

net/sctp/sm_statefuns.c

3542

abort = sctp_make_abort(asoc, chunk, 0);

net/sctp/sm_statefuns.c

3550

packet->vtag = ntohl(chunk->sctp_hdr->vtag);

net/sctp/sm_statefuns.c

3579

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3582

packet = sctp_ootb_pkt_new(net, asoc, chunk);

net/sctp/sm_statefuns.c

3586

abort = sctp_make_new_encap_port(asoc, chunk);

net/sctp/sm_statefuns.c

3620

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3623

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3627

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_operr_chunk)))

net/sctp/sm_statefuns.c

363

if (chunk->sctp_hdr->vtag != 0)

net/sctp/sm_statefuns.c

3630

sctp_walk_errors(err, chunk->chunk_hdr);

net/sctp/sm_statefuns.c

3631

if ((void *)err != (void *)chunk->chunk_end)

net/sctp/sm_statefuns.c

3636

SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

3658

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3662

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3666

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

3680

reply = sctp_make_shutdown_complete(asoc, chunk);

net/sctp/sm_statefuns.c

3740

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3741

struct sk_buff *skb = chunk->skb;

net/sctp/sm_statefuns.c

3750

if (asoc && !sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3753

ch = (struct sctp_chunkhdr *)chunk->chunk_hdr;

net/sctp/sm_statefuns.c

377

if (!sctp_verify_init(net, ep, asoc, chunk->chunk_hdr->type,

net/sctp/sm_statefuns.c

378

(struct sctp_init_chunk *)chunk->chunk_hdr, chunk,

net/sctp/sm_statefuns.c

3838

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3841

packet = sctp_ootb_pkt_new(net, asoc, chunk);

net/sctp/sm_statefuns.c

3848

shut = sctp_make_shutdown_complete(asoc, chunk);

net/sctp/sm_statefuns.c

3856

packet->vtag = ntohl(chunk->sctp_hdr->vtag);

net/sctp/sm_statefuns.c

3893

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3895

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

3899

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

3923

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

3927

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

3934

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_addip_chunk)))

net/sctp/sm_statefuns.c

3945

(!net->sctp.addip_noauth && !chunk->auth))

net/sctp/sm_statefuns.c

3948

hdr = (struct sctp_addiphdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

3952

if (!sctp_verify_asconf(asoc, chunk, true, &err_param))

net/sctp/sm_statefuns.c

3964

if (!chunk->has_asconf)

net/sctp/sm_statefuns.c

3976

asoc, chunk);

net/sctp/sm_statefuns.c

4017

asconf_ack->dest = chunk->source;

net/sctp/sm_statefuns.c

407

chunk->subh.init_hdr = (struct sctp_inithdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

410

chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(struct sctp_inithdr));

net/sctp/sm_statefuns.c

412

new_asoc = sctp_make_temp_asoc(ep, chunk, GFP_ATOMIC);

net/sctp/sm_statefuns.c

417

if (security_sctp_assoc_request(new_asoc, chunk->skb)) {

net/sctp/sm_statefuns.c

4178

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4182

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

4189

if (!sctp_chunk_length_valid(chunk, sizeof(*hdr)))

net/sctp/sm_statefuns.c

4193

if (!sctp_verify_reconf(asoc, chunk, &err_param))

net/sctp/sm_statefuns.c

4197

hdr = (struct sctp_reconf_chunk *)chunk->chunk_hdr;

net/sctp/sm_statefuns.c

425

sctp_scope(sctp_source(chunk)),

net/sctp/sm_statefuns.c

4255

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4259

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

4269

if (!sctp_chunk_length_valid(chunk, sctp_ftsnchk_len(&asoc->stream)))

net/sctp/sm_statefuns.c

4273

fwdtsn_hdr = (struct sctp_fwdtsn_hdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

4274

chunk->subh.fwdtsn_hdr = fwdtsn_hdr;

net/sctp/sm_statefuns.c

4275

len = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_statefuns.c

4277

skb_pull(chunk->skb, len);

net/sctp/sm_statefuns.c

4288

if (!asoc->stream.si->validate_ftsn(chunk))

net/sctp/sm_statefuns.c

4294

SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

430

if (!sctp_process_init(new_asoc, chunk, sctp_source(chunk),

net/sctp/sm_statefuns.c

431

(struct sctp_init_chunk *)chunk->chunk_hdr,

net/sctp/sm_statefuns.c

4322

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4326

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

4336

if (!sctp_chunk_length_valid(chunk, sctp_ftsnchk_len(&asoc->stream)))

net/sctp/sm_statefuns.c

4340

fwdtsn_hdr = (struct sctp_fwdtsn_hdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

4341

chunk->subh.fwdtsn_hdr = fwdtsn_hdr;

net/sctp/sm_statefuns.c

4342

len = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_statefuns.c

4344

skb_pull(chunk->skb, len);

net/sctp/sm_statefuns.c

4355

if (!asoc->stream.si->validate_ftsn(chunk))

net/sctp/sm_statefuns.c

4361

SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

4403

struct sctp_chunk *chunk)

net/sctp/sm_statefuns.c

4413

auth_hdr = (struct sctp_authhdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

4414

chunk->subh.auth_hdr = auth_hdr;

net/sctp/sm_statefuns.c

4415

skb_pull(chunk->skb, sizeof(*auth_hdr));

net/sctp/sm_statefuns.c

4436

sig_len = ntohs(chunk->chunk_hdr->length) -

net/sctp/sm_statefuns.c

445

repl = sctp_make_init_ack(new_asoc, chunk, GFP_ATOMIC, len);

net/sctp/sm_statefuns.c

4450

skb_pull(chunk->skb, sig_len);

net/sctp/sm_statefuns.c

4458

sctp_auth_calculate_hmac(asoc, chunk->skb,

net/sctp/sm_statefuns.c

4459

(struct sctp_auth_chunk *)chunk->chunk_hdr,

net/sctp/sm_statefuns.c

4469

chunk->auth = 1;

net/sctp/sm_statefuns.c

4482

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4491

if (!sctp_vtag_verify(chunk, asoc)) {

net/sctp/sm_statefuns.c

4498

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_auth_chunk)))

net/sctp/sm_statefuns.c

4502

auth_hdr = (struct sctp_authhdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

4503

error = sctp_sf_authenticate(asoc, chunk);

net/sctp/sm_statefuns.c

4509

err_chunk = sctp_make_op_error(asoc, chunk,

net/sctp/sm_statefuns.c

4583

pr_debug("%s: processing unknown chunk id:%d\n", __func__, type.chunk);

net/sctp/sm_statefuns.c

4596

switch (type.chunk & SCTP_CID_ACTION_MASK) {

net/sctp/sm_statefuns.c

4659

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4661

if (asoc && !sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

4668

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

4672

pr_debug("%s: chunk:%d is discarded\n", __func__, type.chunk);

net/sctp/sm_statefuns.c

4729

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4731

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

4735

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

4755

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4773

abort = sctp_make_abort_violation(asoc, chunk, payload, paylen);

net/sctp/sm_statefuns.c

4779

if (chunk->chunk_hdr->type == SCTP_CID_INIT_ACK &&

net/sctp/sm_statefuns.c

4783

initack = (struct sctp_initack_chunk *)chunk->chunk_hdr;

net/sctp/sm_statefuns.c

4784

if (!sctp_chunk_length_valid(chunk, sizeof(*initack)))

net/sctp/sm_statefuns.c

4813

packet = sctp_ootb_pkt_new(net, asoc, chunk);

net/sctp/sm_statefuns.c

4819

packet->vtag = ntohl(chunk->sctp_hdr->vtag);

net/sctp/sm_statefuns.c

4892

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

4898

abort = sctp_make_violation_paramlen(asoc, chunk, param);

net/sctp/sm_statefuns.c

529

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

533

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

540

if (!chunk->singleton)

net/sctp/sm_statefuns.c

544

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_initack_chunk)))

net/sctp/sm_statefuns.c

548

chunk->subh.init_hdr = (struct sctp_inithdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

552

if (!sctp_verify_init(net, ep, asoc, chunk->chunk_hdr->type,

net/sctp/sm_statefuns.c

553

(struct sctp_init_chunk *)chunk->chunk_hdr, chunk,

net/sctp/sm_statefuns.c

5577

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

5579

sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

5582

sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

5594

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

5596

sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

56

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

5739

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

5749

if (chunk) {

net/sctp/sm_statefuns.c

5750

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

5756

chunk, sizeof(struct sctp_shutdown_chunk)))

net/sctp/sm_statefuns.c

5764

reply = sctp_make_shutdown_ack(asoc, chunk);

net/sctp/sm_statefuns.c

59

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

596

asoc, chunk->transport);

net/sctp/sm_statefuns.c

602

chunk->param_hdr.v = skb_pull(chunk->skb, sizeof(struct sctp_inithdr));

net/sctp/sm_statefuns.c

604

initchunk = (struct sctp_init_chunk *)chunk->chunk_hdr;

net/sctp/sm_statefuns.c

6147

struct sctp_chunk *chunk = asoc->addip_last_asconf;

net/sctp/sm_statefuns.c

6148

struct sctp_transport *transport = chunk->transport;

net/sctp/sm_statefuns.c

6161

sctp_add_cmd_sf(commands, SCTP_CMD_SETUP_T4, SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

6336

pr_debug("%s: timer %d ignored\n", __func__, type.chunk);

net/sctp/sm_statefuns.c

6346

static struct sctp_sackhdr *sctp_sm_pull_sack(struct sctp_chunk *chunk)

net/sctp/sm_statefuns.c

6356

sack = (struct sctp_sackhdr *) chunk->skb->data;

net/sctp/sm_statefuns.c

6362

if (len > chunk->skb->len)

net/sctp/sm_statefuns.c

6365

skb_pull(chunk->skb, len);

net/sctp/sm_statefuns.c

6377

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

6383

packet = sctp_ootb_pkt_new(net, asoc, chunk);

net/sctp/sm_statefuns.c

6389

abort = sctp_make_abort(asoc, chunk, paylen);

net/sctp/sm_statefuns.c

6397

packet->vtag = ntohl(chunk->sctp_hdr->vtag);

net/sctp/sm_statefuns.c

64

const struct sctp_chunk *chunk);

net/sctp/sm_statefuns.c

640

static bool sctp_auth_chunk_verify(struct net *net, struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

6418

const struct sctp_chunk *chunk)

net/sctp/sm_statefuns.c

6426

sport = ntohs(chunk->sctp_hdr->dest);

net/sctp/sm_statefuns.c

6427

dport = ntohs(chunk->sctp_hdr->source);

net/sctp/sm_statefuns.c

6436

switch (chunk->chunk_hdr->type) {

net/sctp/sm_statefuns.c

6442

initack = (struct sctp_initack_chunk *)chunk->chunk_hdr;

net/sctp/sm_statefuns.c

645

if (!chunk->auth_chunk)

net/sctp/sm_statefuns.c

6454

switch (chunk->chunk_hdr->type) {

net/sctp/sm_statefuns.c

6459

init = (struct sctp_init_chunk *)chunk->chunk_hdr;

net/sctp/sm_statefuns.c

646

return !sctp_auth_recv_cid(chunk->chunk_hdr->type, asoc);

net/sctp/sm_statefuns.c

6464

vtag = ntohl(chunk->sctp_hdr->vtag);

net/sctp/sm_statefuns.c

6470

transport = sctp_transport_new(net, sctp_source(chunk), GFP_ATOMIC);

net/sctp/sm_statefuns.c

6474

transport->encap_port = SCTP_INPUT_CB(chunk->skb)->encap_port;

net/sctp/sm_statefuns.c

6479

sctp_transport_route(transport, (union sctp_addr *)&chunk->dest,

net/sctp/sm_statefuns.c

6502

const struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

6509

packet = sctp_ootb_pkt_new(net, asoc, chunk);

net/sctp/sm_statefuns.c

6514

cookie = chunk->subh.cookie_hdr;

net/sctp/sm_statefuns.c

6531

struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

6544

data_hdr = (struct sctp_datahdr *)chunk->skb->data;

net/sctp/sm_statefuns.c

6545

chunk->subh.data_hdr = data_hdr;

net/sctp/sm_statefuns.c

6546

skb_pull(chunk->skb, sctp_datahdr_len(&asoc->stream));

net/sctp/sm_statefuns.c

6563

if (asoc->peer.ecn_capable && !chunk->ecn_ce_done) {

net/sctp/sm_statefuns.c

6564

struct sctp_af *af = SCTP_INPUT_CB(chunk->skb)->af;

net/sctp/sm_statefuns.c

6565

chunk->ecn_ce_done = 1;

net/sctp/sm_statefuns.c

6567

if (af->is_ce(sctp_gso_headskb(chunk->skb))) {

net/sctp/sm_statefuns.c

6579

if (chunk->asoc)

net/sctp/sm_statefuns.c

6580

chunk->asoc->stats.outofseqtsns++;

net/sctp/sm_statefuns.c

6593

datalen = ntohs(chunk->chunk_hdr->length);

net/sctp/sm_statefuns.c

660

auth.skb = chunk->auth_chunk;

net/sctp/sm_statefuns.c

661

auth.asoc = chunk->asoc;

net/sctp/sm_statefuns.c

6612

if ((!chunk->data_accepted) && (!asoc->rwnd || asoc->rwnd_over ||

net/sctp/sm_statefuns.c

662

auth.sctp_hdr = chunk->sctp_hdr;

net/sctp/sm_statefuns.c

664

skb_push(chunk->auth_chunk,

net/sctp/sm_statefuns.c

6658

err = sctp_make_abort_no_data(asoc, chunk, tsn);

net/sctp/sm_statefuns.c

666

skb_pull(chunk->auth_chunk, sizeof(struct sctp_chunkhdr));

net/sctp/sm_statefuns.c

667

auth.transport = chunk->transport;

net/sctp/sm_statefuns.c

6676

chunk->data_accepted = 1;

net/sctp/sm_statefuns.c

6681

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {

net/sctp/sm_statefuns.c

6683

if (chunk->asoc)

net/sctp/sm_statefuns.c

6684

chunk->asoc->stats.iuodchunks++;

net/sctp/sm_statefuns.c

6687

if (chunk->asoc)

net/sctp/sm_statefuns.c

6688

chunk->asoc->stats.iodchunks++;

net/sctp/sm_statefuns.c

6703

err = sctp_make_op_error(asoc, chunk, SCTP_ERROR_INV_STRM,

net/sctp/sm_statefuns.c

6720

if (!asoc->stream.si->validate_data(chunk))

net/sctp/sm_statefuns.c

6727

sctp_add_cmd_sf(commands, deliver, SCTP_CHUNK(chunk));

net/sctp/sm_statefuns.c

68

const struct sctp_chunk *chunk,

net/sctp/sm_statefuns.c

714

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

720

if (asoc && !sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

736

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statefuns.c

752

chunk->subh.cookie_hdr =

net/sctp/sm_statefuns.c

753

(struct sctp_signed_cookie *)chunk->skb->data;

net/sctp/sm_statefuns.c

754

if (!pskb_pull(chunk->skb, ntohs(chunk->chunk_hdr->length) -

net/sctp/sm_statefuns.c

762

new_asoc = sctp_unpack_cookie(ep, asoc, chunk, GFP_ATOMIC, &error,

net/sctp/sm_statefuns.c

780

sctp_send_stale_cookie_err(net, ep, asoc, chunk, commands,

net/sctp/sm_statefuns.c

790

peer_init = (struct sctp_init_chunk *)(chunk->subh.cookie_hdr + 1);

net/sctp/sm_statefuns.c

793

!sctp_verify_init(net, ep, asoc, cid, peer_init, chunk,

net/sctp/sm_statefuns.c

803

if (security_sctp_assoc_request(new_asoc, chunk->head_skb ?: chunk->skb)) {

net/sctp/sm_statefuns.c

816

if (!sctp_process_init(new_asoc, chunk,

net/sctp/sm_statefuns.c

817

&chunk->subh.cookie_hdr->c.peer_addr,

net/sctp/sm_statefuns.c

829

if (!sctp_auth_chunk_verify(net, chunk, new_asoc)) {

net/sctp/sm_statefuns.c

834

repl = sctp_make_cookie_ack(new_asoc, chunk);

net/sctp/sm_statefuns.c

945

struct sctp_chunk *chunk = arg;

net/sctp/sm_statefuns.c

948

if (!sctp_vtag_verify(chunk, asoc))

net/sctp/sm_statefuns.c

953

chunk->head_skb ?: chunk->skb))

net/sctp/sm_statefuns.c

959

if (!sctp_chunk_length_valid(chunk, sizeof(struct sctp_chunkhdr)))

net/sctp/sm_statetable.c

73

return sctp_chunk_event_lookup(net, event_subtype.chunk, state);

net/sctp/socket.c

125

static inline void sctp_set_owner_w(struct sctp_chunk *chunk)

net/sctp/socket.c

127

struct sctp_association *asoc = chunk->asoc;

net/sctp/socket.c

133

if (chunk->shkey)

net/sctp/socket.c

134

sctp_auth_shkey_hold(chunk->shkey);

net/sctp/socket.c

136

skb_set_owner_w(chunk->skb, sk);

net/sctp/socket.c

138

chunk->skb->destructor = sctp_wfree;

net/sctp/socket.c

140

skb_shinfo(chunk->skb)->destructor_arg = chunk;

net/sctp/socket.c

143

asoc->sndbuf_used += chunk->skb->truesize + sizeof(struct sctp_chunk);

net/sctp/socket.c

144

sk_wmem_queued_add(sk, chunk->skb->truesize + sizeof(struct sctp_chunk));

net/sctp/socket.c

145

sk_mem_charge(sk, chunk->skb->truesize);

net/sctp/socket.c

148

static void sctp_clear_owner_w(struct sctp_chunk *chunk)

net/sctp/socket.c

150

skb_orphan(chunk->skb);

net/sctp/socket.c

1524

struct sctp_chunk *chunk;

net/sctp/socket.c

1526

chunk = sctp_make_abort_user(asoc, NULL, 0);

net/sctp/socket.c

1527

sctp_primitive_ABORT(net, asoc, chunk);

net/sctp/socket.c

155

msg = chunk->msg; \

net/sctp/socket.c

173

struct sctp_chunk *chunk, *c;

net/sctp/socket.c

177

list_for_each_entry(chunk, &t->transmitted, transmitted_list)

net/sctp/socket.c

1773

struct sctp_chunk *chunk;

net/sctp/socket.c

1775

chunk = sctp_make_abort_user(asoc, msg, msg_len);

net/sctp/socket.c

1776

if (!chunk)

net/sctp/socket.c

1780

sctp_primitive_ABORT(net, asoc, chunk);

net/sctp/socket.c

1799

struct sctp_chunk *chunk;

net/sctp/socket.c

180

list_for_each_entry(chunk, &q->retransmit, transmitted_list)

net/sctp/socket.c

183

list_for_each_entry(chunk, &q->sacked, transmitted_list)

net/sctp/socket.c

186

list_for_each_entry(chunk, &q->abandoned, transmitted_list)

net/sctp/socket.c

1866

list_for_each_entry(chunk, &datamsg->chunks, frag_list) {

net/sctp/socket.c

1867

sctp_chunk_hold(chunk);

net/sctp/socket.c

1868

sctp_set_owner_w(chunk);

net/sctp/socket.c

1869

chunk->transport = transport;

net/sctp/socket.c

189

list_for_each_entry(chunk, &q->out_chunk_list, list)

net/sctp/socket.c

2146

if (event->chunk && event->chunk->head_skb)

net/sctp/socket.c

2147

head_skb = event->chunk->head_skb;

net/sctp/socket.c

3326

struct sctp_chunk *chunk;

net/sctp/socket.c

3369

chunk = sctp_make_asconf_set_prim(asoc,

net/sctp/socket.c

3371

if (!chunk)

net/sctp/socket.c

3374

err = sctp_send_asconf(asoc, chunk);

net/sctp/socket.c

470

struct sctp_chunk *chunk)

net/sctp/socket.c

478

list_add_tail(&chunk->list, &asoc->addip_chunk_list);

net/sctp/socket.c

483

sctp_chunk_hold(chunk);

net/sctp/socket.c

484

retval = sctp_primitive_ASCONF(asoc->base.net, asoc, chunk);

net/sctp/socket.c

486

sctp_chunk_free(chunk);

net/sctp/socket.c

488

asoc->addip_last_asconf = chunk;

net/sctp/socket.c

564

struct sctp_chunk *chunk;

net/sctp/socket.c

621

chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,

net/sctp/socket.c

623

if (!chunk) {

net/sctp/socket.c

657

retval = sctp_send_asconf(asoc, chunk);

net/sctp/socket.c

767

struct sctp_chunk *chunk;

net/sctp/socket.c

776

chunk = NULL;

net/sctp/socket.c

868

chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,

net/sctp/socket.c

870

if (!chunk) {

net/sctp/socket.c

89

struct sctp_chunk *chunk);

net/sctp/socket.c

903

retval = sctp_send_asconf(asoc, chunk);

net/sctp/socket.c

9215

struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;

net/sctp/socket.c

9216

struct sctp_association *asoc = chunk->asoc;

net/sctp/socket.c

9225

if (chunk->shkey) {

net/sctp/socket.c

9226

struct sctp_shared_key *shkey = chunk->shkey;

net/sctp/socket.c

9242

sctp_auth_shkey_release(chunk->shkey);

net/sctp/stream.c

230

struct sctp_chunk *chunk)

net/sctp/stream.c

234

retval = sctp_primitive_RECONF(asoc->base.net, asoc, chunk);

net/sctp/stream.c

236

sctp_chunk_free(chunk);

net/sctp/stream.c

270

struct sctp_chunk *chunk;

net/sctp/stream.c

335

chunk = sctp_make_strreset_req(asoc, str_nums, nstr_list, out, in);

net/sctp/stream.c

339

if (!chunk) {

net/sctp/stream.c

354

asoc->strreset_chunk = chunk;

net/sctp/stream.c

357

retval = sctp_send_reconf(asoc, chunk);

net/sctp/stream.c

384

struct sctp_chunk *chunk = NULL;

net/sctp/stream.c

398

chunk = sctp_make_strreset_tsnreq(asoc);

net/sctp/stream.c

399

if (!chunk)

net/sctp/stream.c

406

asoc->strreset_chunk = chunk;

net/sctp/stream.c

409

retval = sctp_send_reconf(asoc, chunk);

net/sctp/stream.c

429

struct sctp_chunk *chunk = NULL;

net/sctp/stream.c

461

chunk = sctp_make_strreset_addstrm(asoc, out, in);

net/sctp/stream.c

462

if (!chunk) {

net/sctp/stream.c

467

asoc->strreset_chunk = chunk;

net/sctp/stream.c

470

retval = sctp_send_reconf(asoc, chunk);

net/sctp/stream.c

487

struct sctp_chunk *chunk = asoc->strreset_chunk;

net/sctp/stream.c

491

if (!chunk)

net/sctp/stream.c

494

hdr = (struct sctp_reconf_chunk *)chunk->chunk_hdr;

net/sctp/stream.c

614

struct sctp_chunk *chunk = NULL;

net/sctp/stream.c

659

chunk = sctp_make_strreset_req(asoc, nums, str_p, 1, 0);

net/sctp/stream.c

660

if (!chunk)

net/sctp/stream.c

671

asoc->strreset_chunk = chunk;

net/sctp/stream.c

680

if (!chunk)

net/sctp/stream.c

681

chunk = sctp_make_strreset_resp(asoc, result, request_seq);

net/sctp/stream.c

683

return chunk;

net/sctp/stream.c

861

struct sctp_chunk *chunk = NULL;

net/sctp/stream.c

897

chunk = sctp_make_strreset_addstrm(asoc, out, 0);

net/sctp/stream.c

898

if (!chunk)

net/sctp/stream.c

901

asoc->strreset_chunk = chunk;

net/sctp/stream.c

912

if (!chunk)

net/sctp/stream.c

913

chunk = sctp_make_strreset_resp(asoc, result, request_seq);

net/sctp/stream.c

915

return chunk;

net/sctp/stream_interleave.c

100

ssn = ntohs(chunk->subh.data_hdr->ssn);

net/sctp/stream_interleave.c

105

static bool sctp_validate_idata(struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

1105

struct sctp_chunk *chunk;

net/sctp/stream_interleave.c

111

if (chunk->chunk_hdr->type != SCTP_CID_I_DATA)

net/sctp/stream_interleave.c

1115

chunk = list_entry(lchunk, struct sctp_chunk, transmitted_list);

net/sctp/stream_interleave.c

1116

tsn = ntohl(chunk->subh.data_hdr->tsn);

net/sctp/stream_interleave.c

1120

sctp_chunk_free(chunk);

net/sctp/stream_interleave.c

1122

__be16 sid = chunk->subh.idata_hdr->stream;

net/sctp/stream_interleave.c

1123

__be32 mid = chunk->subh.idata_hdr->mid;

net/sctp/stream_interleave.c

1126

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)

net/sctp/stream_interleave.c

114

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)

net/sctp/stream_interleave.c

1155

#define _sctp_walk_ifwdtsn(pos, chunk, end) \

net/sctp/stream_interleave.c

1156

for (pos = (void *)(chunk->subh.ifwdtsn_hdr + 1); \

net/sctp/stream_interleave.c

1157

(void *)pos <= (void *)(chunk->subh.ifwdtsn_hdr + 1) + (end) - \

net/sctp/stream_interleave.c

1164

static bool sctp_validate_fwdtsn(struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

1169

if (chunk->chunk_hdr->type != SCTP_CID_FWD_TSN)

net/sctp/stream_interleave.c

117

stream = &chunk->asoc->stream;

net/sctp/stream_interleave.c

1172

incnt = chunk->asoc->stream.incnt;

net/sctp/stream_interleave.c

1173

sctp_walk_fwdtsn(skip, chunk)

net/sctp/stream_interleave.c

118

sid = sctp_chunk_stream_no(chunk);

net/sctp/stream_interleave.c

1180

static bool sctp_validate_iftsn(struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

1185

if (chunk->chunk_hdr->type != SCTP_CID_I_FWD_TSN)

net/sctp/stream_interleave.c

1188

incnt = chunk->asoc->stream.incnt;

net/sctp/stream_interleave.c

1189

sctp_walk_ifwdtsn(skip, chunk)

net/sctp/stream_interleave.c

119

mid = ntohl(chunk->subh.idata_hdr->mid);

net/sctp/stream_interleave.c

1242

static void sctp_handle_fwdtsn(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

1247

sctp_walk_fwdtsn(skip, chunk)

net/sctp/stream_interleave.c

1279

static void sctp_handle_iftsn(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

1284

sctp_walk_ifwdtsn(skip, chunk)

net/sctp/stream_interleave.c

48

static void sctp_chunk_assign_mid(struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

55

if (chunk->has_mid)

net/sctp/stream_interleave.c

58

sid = sctp_chunk_stream_no(chunk);

net/sctp/stream_interleave.c

59

stream = &chunk->asoc->stream;

net/sctp/stream_interleave.c

61

list_for_each_entry(lchunk, &chunk->msg->chunks, frag_list) {

net/sctp/stream_interleave.c

820

struct sctp_chunk *chunk, gfp_t gfp)

net/sctp/stream_interleave.c

826

event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp);

net/sctp/stream_interleave.c

830

event->mid = ntohl(chunk->subh.idata_hdr->mid);

net/sctp/stream_interleave.c

832

event->ppid = chunk->subh.idata_hdr->ppid;

net/sctp/stream_interleave.c

834

event->fsn = ntohl(chunk->subh.idata_hdr->fsn);

net/sctp/stream_interleave.c

87

static bool sctp_validate_data(struct sctp_chunk *chunk)

net/sctp/stream_interleave.c

92

if (chunk->chunk_hdr->type != SCTP_CID_DATA)

net/sctp/stream_interleave.c

95

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)

net/sctp/stream_interleave.c

954

static void sctp_renege_events(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,

net/sctp/stream_interleave.c

961

needed = ntohs(chunk->chunk_hdr->length) -

net/sctp/stream_interleave.c

974

if (freed >= needed && sctp_ulpevent_idata(ulpq, chunk, gfp) <= 0)

net/sctp/stream_interleave.c

98

stream = &chunk->asoc->stream;

net/sctp/stream_interleave.c

99

sid = sctp_chunk_stream_no(chunk);

net/sctp/stream_sched.c

82

struct sctp_chunk *chunk)

net/sctp/ulpevent.c

1133

sctp_chunk_put(event->chunk);

net/sctp/ulpevent.c

1156

sctp_chunk_put(event->chunk);

net/sctp/ulpevent.c

117

__u16 inbound, struct sctp_chunk *chunk, gfp_t gfp)

net/sctp/ulpevent.c

126

if (chunk) {

net/sctp/ulpevent.c

130

skb = skb_copy_expand(chunk->skb,

net/sctp/ulpevent.c

145

ntohs(chunk->chunk_hdr->length) -

net/sctp/ulpevent.c

375

struct sctp_chunk *chunk, __u16 flags,

net/sctp/ulpevent.c

385

ch = (struct sctp_errhdr *)(chunk->skb->data);

net/sctp/ulpevent.c

390

skb_pull(chunk->skb, sizeof(*ch));

net/sctp/ulpevent.c

395

skb = skb_copy_expand(chunk->skb, sizeof(*sre), 0, gfp);

net/sctp/ulpevent.c

398

skb_pull(chunk->skb, elen);

net/sctp/ulpevent.c

431

const struct sctp_association *asoc, struct sctp_chunk *chunk,

net/sctp/ulpevent.c

439

int len = ntohs(chunk->chunk_hdr->length);

net/sctp/ulpevent.c

442

skb = skb_copy_expand(chunk->skb,

net/sctp/ulpevent.c

509

memcpy(&ssf->ssf_info, &chunk->sinfo, sizeof(struct sctp_sndrcvinfo));

net/sctp/ulpevent.c

514

ssf->ssf_info.sinfo_flags = chunk->chunk_hdr->flags;

net/sctp/ulpevent.c

534

const struct sctp_association *asoc, struct sctp_chunk *chunk,

net/sctp/ulpevent.c

542

skb = skb_copy_expand(chunk->skb, sizeof(*ssf), 0, gfp);

net/sctp/ulpevent.c

546

len = ntohs(chunk->chunk_hdr->length);

net/sctp/ulpevent.c

560

ssf->ssfe_info.snd_sid = chunk->sinfo.sinfo_stream;

net/sctp/ulpevent.c

561

ssf->ssfe_info.snd_ppid = chunk->sinfo.sinfo_ppid;

net/sctp/ulpevent.c

562

ssf->ssfe_info.snd_context = chunk->sinfo.sinfo_context;

net/sctp/ulpevent.c

563

ssf->ssfe_info.snd_assoc_id = chunk->sinfo.sinfo_assoc_id;

net/sctp/ulpevent.c

564

ssf->ssfe_info.snd_flags = chunk->chunk_hdr->flags;

net/sctp/ulpevent.c

676

struct sctp_chunk *chunk,

net/sctp/ulpevent.c

680

struct sk_buff *skb = chunk->skb;

net/sctp/ulpevent.c

695

datalen = ntohs(chunk->chunk_hdr->length);

net/sctp/ulpevent.c

701

skb = skb_clone(chunk->skb, gfp);

net/sctp/ulpevent.c

709

ntohl(chunk->subh.data_hdr->tsn),

net/sctp/ulpevent.c

710

chunk->transport))

net/sctp/ulpevent.c

728

skb_trim(skb, chunk->chunk_end - padding - skb->data);

net/sctp/ulpevent.c

742

sctp_chunk_hold(chunk);

net/sctp/ulpevent.c

743

event->chunk = chunk;

net/sctp/ulpevent.c

747

event->stream = ntohs(chunk->subh.data_hdr->stream);

net/sctp/ulpevent.c

748

if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {

net/sctp/ulpevent.c

752

event->tsn = ntohl(chunk->subh.data_hdr->tsn);

net/sctp/ulpevent.c

753

event->msg_flags |= chunk->chunk_hdr->flags;

net/sctp/ulpevent.c

79

struct sctp_chunk *chunk = event->chunk;

net/sctp/ulpevent.c

90

if (chunk && chunk->head_skb && !chunk->head_skb->sk)

net/sctp/ulpevent.c

91

chunk->head_skb->sk = asoc->base.sk;

net/sctp/ulpqueue.c

1069

void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,

net/sctp/ulpqueue.c

1076

needed = ntohs(chunk->chunk_hdr->length) -

net/sctp/ulpqueue.c

1085

if (sk_rmem_schedule(asoc->base.sk, chunk->skb, needed) &&

net/sctp/ulpqueue.c

1087

int retval = sctp_ulpq_tail_data(ulpq, chunk, gfp);

net/sctp/ulpqueue.c

82

int sctp_ulpq_tail_data(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,

net/sctp/ulpqueue.c

90

event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp);

net/sctp/ulpqueue.c

94

event->ssn = ntohs(chunk->subh.data_hdr->ssn);

net/sctp/ulpqueue.c

95

event->ppid = chunk->subh.data_hdr->ppid;

net/smc/smc_rx.c

360

int readable, chunk;

net/smc/smc_rx.c

474

for (chunk = 0; chunk < 2; chunk++) {

net/smc/smc_tx.c

191

int rc, chunk;

net/smc/smc_tx.c

248

for (chunk = 0; chunk < 2; chunk++) {

net/sunrpc/xprtrdma/svc_rdma_pcl.c

109

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

120

chunk = pcl_alloc_chunk(segcount, position);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

121

if (!chunk)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

123

pcl_insert_position(pcl, chunk);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

125

chunk = list_first_entry(&pcl->cl_chunks,

net/sunrpc/xprtrdma/svc_rdma_pcl.c

130

pcl_set_read_segment(rctxt, chunk, handle, length, offset);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

163

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

173

chunk = pcl_lookup_position(pcl, position);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

174

if (!chunk) {

net/sunrpc/xprtrdma/svc_rdma_pcl.c

175

chunk = pcl_alloc_chunk(segcount, position);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

176

if (!chunk)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

178

pcl_insert_position(pcl, chunk);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

181

pcl_set_read_segment(rctxt, chunk, handle, length, offset);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

20

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

205

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

213

chunk = pcl_alloc_chunk(segcount, 0);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

214

if (!chunk)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

216

list_add_tail(&chunk->ch_list, &pcl->cl_chunks);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

219

segment = &chunk->ch_segments[j];

net/sunrpc/xprtrdma/svc_rdma_pcl.c

22

chunk = pcl_first_chunk(pcl);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

223

trace_svcrdma_decode_wseg(&rctxt->rc_cid, chunk, j);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

225

chunk->ch_length += segment->rs_length;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

226

chunk->ch_segcount++;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

23

list_del(&chunk->ch_list);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

24

kfree(chunk);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

270

struct svc_rdma_chunk *chunk, *next;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

274

chunk = pcl_first_chunk(pcl);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

277

if (!chunk || !chunk->ch_payload_length)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

281

ret = pcl_process_region(xdr, 0, chunk->ch_position, actor, data);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

286

while ((next = pcl_next_chunk(pcl, chunk))) {

net/sunrpc/xprtrdma/svc_rdma_pcl.c

290

start = pcl_chunk_end_offset(chunk);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

296

chunk = next;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

30

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

300

start = pcl_chunk_end_offset(chunk);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

32

chunk = kmalloc_flex(*chunk, ch_segments, segcount);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

33

if (!chunk)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

36

chunk->ch_position = position;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

37

chunk->ch_length = 0;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

38

chunk->ch_payload_length = 0;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

39

chunk->ch_segcount = 0;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

40

return chunk;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

56

struct svc_rdma_chunk *chunk)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

61

if (pos->ch_position > chunk->ch_position)

net/sunrpc/xprtrdma/svc_rdma_pcl.c

64

__list_add(&chunk->ch_list, pos->ch_list.prev, &pos->ch_list);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

69

struct svc_rdma_chunk *chunk,

net/sunrpc/xprtrdma/svc_rdma_pcl.c

74

segment = &chunk->ch_segments[chunk->ch_segcount];

net/sunrpc/xprtrdma/svc_rdma_pcl.c

79

trace_svcrdma_decode_rseg(&rctxt->rc_cid, chunk, segment);

net/sunrpc/xprtrdma/svc_rdma_pcl.c

81

chunk->ch_length += length;

net/sunrpc/xprtrdma/svc_rdma_pcl.c

82

chunk->ch_segcount++;

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

622

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

631

pcl_for_each_chunk(chunk, &ctxt->rc_call_pcl) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

632

pcl_for_each_segment(segment, chunk) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

639

pcl_for_each_chunk(chunk, &ctxt->rc_read_pcl) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

640

pcl_for_each_segment(segment, chunk) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

647

pcl_for_each_chunk(chunk, &ctxt->rc_write_pcl) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

648

pcl_for_each_segment(segment, chunk) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

655

pcl_for_each_chunk(chunk, &ctxt->rc_reply_pcl) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

656

pcl_for_each_segment(segment, chunk) {

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

801

struct svc_rdma_chunk *chunk = pcl_first_chunk(&ctxt->rc_read_pcl);

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

810

buf->tail[0].iov_base = buf->head[0].iov_base + chunk->ch_position;

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

811

buf->tail[0].iov_len = buf->head[0].iov_len - chunk->ch_position;

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

812

buf->head[0].iov_len = chunk->ch_position;

net/sunrpc/xprtrdma/svc_rdma_recvfrom.c

824

length = xdr_align_size(chunk->ch_length);

net/sunrpc/xprtrdma/svc_rdma_rw.c

1000

pcl_for_each_segment(segment, chunk) {

net/sunrpc/xprtrdma/svc_rdma_rw.c

1041

struct svc_rdma_chunk *chunk, *next;

net/sunrpc/xprtrdma/svc_rdma_rw.c

1049

chunk = pcl_first_chunk(pcl);

net/sunrpc/xprtrdma/svc_rdma_rw.c

1050

length = chunk->ch_position;

net/sunrpc/xprtrdma/svc_rdma_rw.c

1056

pcl_for_each_chunk(chunk, pcl) {

net/sunrpc/xprtrdma/svc_rdma_rw.c

1057

ret = svc_rdma_build_read_chunk(rqstp, head, chunk);

net/sunrpc/xprtrdma/svc_rdma_rw.c

1061

next = pcl_next_chunk(pcl, chunk);

net/sunrpc/xprtrdma/svc_rdma_rw.c

223

const struct svc_rdma_chunk *chunk)

net/sunrpc/xprtrdma/svc_rdma_rw.c

233

info->wi_chunk = chunk;

net/sunrpc/xprtrdma/svc_rdma_rw.c

642

const struct svc_rdma_chunk *chunk,

net/sunrpc/xprtrdma/svc_rdma_rw.c

650

if (xdr_buf_subsegment(xdr, &payload, chunk->ch_position,

net/sunrpc/xprtrdma/svc_rdma_rw.c

651

chunk->ch_payload_length))

net/sunrpc/xprtrdma/svc_rdma_rw.c

654

info = svc_rdma_write_info_alloc(rdma, chunk);

net/sunrpc/xprtrdma/svc_rdma_rw.c

693

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_rw.c

696

pcl_for_each_chunk(chunk, &rctxt->rc_write_pcl) {

net/sunrpc/xprtrdma/svc_rdma_rw.c

697

if (!chunk->ch_payload_length)

net/sunrpc/xprtrdma/svc_rdma_rw.c

699

ret = svc_rdma_prepare_write_chunk(rdma, sctxt, chunk, xdr);

net/sunrpc/xprtrdma/svc_rdma_rw.c

831

const struct svc_rdma_chunk *chunk)

net/sunrpc/xprtrdma/svc_rdma_rw.c

837

pcl_for_each_segment(segment, chunk) {

net/sunrpc/xprtrdma/svc_rdma_rw.c

919

struct svc_rdma_chunk *chunk, *next;

net/sunrpc/xprtrdma/svc_rdma_rw.c

924

chunk = pcl_first_chunk(pcl);

net/sunrpc/xprtrdma/svc_rdma_rw.c

925

length = chunk->ch_position;

net/sunrpc/xprtrdma/svc_rdma_rw.c

930

pcl_for_each_chunk(chunk, pcl) {

net/sunrpc/xprtrdma/svc_rdma_rw.c

931

ret = svc_rdma_build_read_chunk(rqstp, head, chunk);

net/sunrpc/xprtrdma/svc_rdma_rw.c

935

next = pcl_next_chunk(pcl, chunk);

net/sunrpc/xprtrdma/svc_rdma_rw.c

993

const struct svc_rdma_chunk *chunk,

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1226

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1228

chunk = rctxt->rc_cur_result_payload;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1229

if (!length || !chunk)

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1232

pcl_next_chunk(&rctxt->rc_write_pcl, chunk);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1234

if (length > chunk->ch_length)

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1236

chunk->ch_position = offset;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

1237

chunk->ch_payload_length = length;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

556

const struct svc_rdma_chunk *chunk,

net/sunrpc/xprtrdma/svc_rdma_sendto.c

559

const struct svc_rdma_segment *segment = &chunk->ch_segments[segno];

net/sunrpc/xprtrdma/svc_rdma_sendto.c

592

const struct svc_rdma_chunk *chunk)

net/sunrpc/xprtrdma/svc_rdma_sendto.c

594

u32 remaining = chunk->ch_payload_length;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

604

ret = xdr_stream_encode_u32(&sctxt->sc_stream, chunk->ch_segcount);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

609

for (segno = 0; segno < chunk->ch_segcount; segno++) {

net/sunrpc/xprtrdma/svc_rdma_sendto.c

610

ret = svc_rdma_encode_write_segment(sctxt, chunk, &remaining, segno);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

632

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

636

pcl_for_each_chunk(chunk, &rctxt->rc_write_pcl) {

net/sunrpc/xprtrdma/svc_rdma_sendto.c

637

ret = svc_rdma_encode_write_chunk(sctxt, chunk);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

668

struct svc_rdma_chunk *chunk;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

673

chunk = pcl_first_chunk(&rctxt->rc_reply_pcl);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

674

if (length > chunk->ch_length)

net/sunrpc/xprtrdma/svc_rdma_sendto.c

677

chunk->ch_payload_length = length;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

678

return svc_rdma_encode_write_chunk(sctxt, chunk);

net/tls/tls_strp.c

163

int chunk, len, offset;

net/tls/tls_strp.c

175

chunk = iter->len - offset;

net/tls/tls_strp.c

183

len -= chunk;

net/tls/tls_strp.c

215

size_t len, chunk;

net/tls/tls_strp.c

230

chunk = min_t(size_t, len, PAGE_SIZE - skb_frag_size(frag));

net/tls/tls_strp.c

234

chunk));

net/tls/tls_strp.c

236

skb->len += chunk;

net/tls/tls_strp.c

237

skb->data_len += chunk;

net/tls/tls_strp.c

238

skb_frag_size_add(frag, chunk);

net/tls/tls_strp.c

248

WARN_ON_ONCE(over > chunk);

net/tls/tls_strp.c

253

chunk -= over;

net/tls/tls_strp.c

257

len -= chunk;

net/tls/tls_strp.c

258

offset += chunk;

net/tls/tls_strp.c

267

chunk = min_t(size_t, len, strp->stm.full_len - skb->len);

net/tls/tls_strp.c

268

chunk = min_t(size_t, chunk, PAGE_SIZE - skb_frag_size(frag));

net/tls/tls_strp.c

272

chunk));

net/tls/tls_strp.c

274

skb->len += chunk;

net/tls/tls_strp.c

275

skb->data_len += chunk;

net/tls/tls_strp.c

276

skb_frag_size_add(frag, chunk);

net/tls/tls_strp.c

278

len -= chunk;

net/tls/tls_strp.c

279

offset += chunk;

net/tls/tls_strp.c

292

size_t chunk;

net/tls/tls_strp.c

296

chunk = strp->stm.full_len - skb->len;

net/tls/tls_strp.c

298

chunk = TLS_MAX_PAYLOAD_SIZE + PAGE_SIZE;

net/tls/tls_strp.c

299

chunk = min(chunk, in_len);

net/tls/tls_strp.c

301

nskb = tls_strp_skb_copy(strp, in_skb, offset, chunk);

net/tls/tls_strp.c

316

skb->len += chunk;

net/tls/tls_strp.c

317

skb->data_len += chunk;

net/tls/tls_strp.c

328

WARN_ON_ONCE(over > chunk);

net/tls/tls_strp.c

333

chunk -= over;

net/tls/tls_strp.c

339

return chunk;

net/tls/tls_sw.c

108

chunk = end - offset;

net/tls/tls_sw.c

109

if (chunk > 0) {

net/tls/tls_sw.c

110

if (chunk > len)

net/tls/tls_sw.c

111

chunk = len;

net/tls/tls_sw.c

113

len -= chunk;

net/tls/tls_sw.c

116

offset += chunk;

net/tls/tls_sw.c

128

chunk = end - offset;

net/tls/tls_sw.c

129

if (chunk > 0) {

net/tls/tls_sw.c

130

if (chunk > len)

net/tls/tls_sw.c

131

chunk = len;

net/tls/tls_sw.c

132

ret = __skb_nsg(frag_iter, offset - start, chunk,

net/tls/tls_sw.c

137

len -= chunk;

net/tls/tls_sw.c

140

offset += chunk;

net/tls/tls_sw.c

1650

int chunk = min_t(unsigned int, rxm->full_len - skip, len);

net/tls/tls_sw.c

1659

msg, chunk);

net/tls/tls_sw.c

1663

len = len - chunk;

net/tls/tls_sw.c

1664

copied = copied + chunk;

net/tls/tls_sw.c

1668

rxm->offset = rxm->offset + chunk;

net/tls/tls_sw.c

1669

rxm->full_len = rxm->full_len - chunk;

net/tls/tls_sw.c

1843

int to_decrypt, chunk;

net/tls/tls_sw.c

1896

chunk = rxm->full_len;

net/tls/tls_sw.c

1900

bool partially_consumed = chunk > len;

net/tls/tls_sw.c

1907

chunk = min_t(int, to_decrypt, len);

net/tls/tls_sw.c

1908

async_copy_bytes += chunk;

net/tls/tls_sw.c

1910

decrypted += chunk;

net/tls/tls_sw.c

1911

len -= chunk;

net/tls/tls_sw.c

1919

chunk = len;

net/tls/tls_sw.c

1922

msg, chunk);

net/tls/tls_sw.c

1927

peeked += chunk;

net/tls/tls_sw.c

1932

rxm->offset += chunk;

net/tls/tls_sw.c

1933

rxm->full_len -= chunk;

net/tls/tls_sw.c

1940

decrypted += chunk;

net/tls/tls_sw.c

1941

len -= chunk;

net/tls/tls_sw.c

1994

int chunk;

net/tls/tls_sw.c

2030

chunk = min_t(unsigned int, rxm->full_len, len);

net/tls/tls_sw.c

2031

copied = skb_splice_bits(skb, sk, rxm->offset, pipe, chunk, flags);

net/tls/tls_sw.c

85

int i, chunk = start - offset;

net/tls/tls_sw.c

92

if (chunk > 0) {

net/tls/tls_sw.c

93

if (chunk > len)

net/tls/tls_sw.c

94

chunk = len;

net/tls/tls_sw.c

96

len -= chunk;

net/tls/tls_sw.c

99

offset += chunk;

net/unix/af_unix.c

2762

int chunk = 1;

net/unix/af_unix.c

2791

chunk = state->recv_actor(oob_skb, 0, chunk, state);

net/unix/af_unix.c

2800

if (chunk < 0)

net/unix/af_unix.c

2954

int chunk;

net/unix/af_unix.c

3040

chunk = min_t(unsigned int, unix_skb_len(skb) - skip, size);

net/unix/af_unix.c

3041

chunk = state->recv_actor(skb, skip, chunk, state);

net/unix/af_unix.c

3042

if (chunk < 0) {

net/unix/af_unix.c

3047

copied += chunk;

net/unix/af_unix.c

3048

size -= chunk;

net/unix/af_unix.c

3052

UNIXCB(skb).consumed += chunk;

net/unix/af_unix.c

3054

sk_peek_offset_bwd(sk, chunk);

net/unix/af_unix.c

3062

WRITE_ONCE(u->inq_len, u->inq_len - chunk);

net/unix/af_unix.c

3080

sk_peek_offset_fwd(sk, chunk);

net/unix/af_unix.c

3116

int skip, int chunk,

net/unix/af_unix.c

3122

state->msg, chunk);

net/unix/af_unix.c

3123

return ret ?: chunk;

net/unix/af_unix.c

3162

int skip, int chunk,

net/unix/af_unix.c

3167

state->pipe, chunk, state->splice_flags);

security/apparmor/include/policy_unpack.h

204

size_t aa_unpack_u16_chunk(struct aa_ext *e, char **chunk);

security/apparmor/policy_unpack.c

192

VISIBLE_IF_KUNIT size_t aa_unpack_u16_chunk(struct aa_ext *e, char **chunk)

security/apparmor/policy_unpack.c

203

*chunk = e->pos;

security/apparmor/policy_unpack_test.c

387

char *chunk = NULL;

security/apparmor/policy_unpack_test.c

398

size = aa_unpack_u16_chunk(puf->e, &chunk);

security/apparmor/policy_unpack_test.c

400

KUNIT_EXPECT_PTR_EQ(test, chunk,

security/apparmor/policy_unpack_test.c

403

KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, (chunk + TEST_U16_DATA));

security/apparmor/policy_unpack_test.c

410

char *chunk = NULL;

security/apparmor/policy_unpack_test.c

415

size = aa_unpack_u16_chunk(puf->e, &chunk);

security/apparmor/policy_unpack_test.c

418

KUNIT_EXPECT_NULL(test, chunk);

security/apparmor/policy_unpack_test.c

426

char *chunk = NULL;

security/apparmor/policy_unpack_test.c

437

size = aa_unpack_u16_chunk(puf->e, &chunk);

security/apparmor/policy_unpack_test.c

440

KUNIT_EXPECT_NULL(test, chunk);

security/keys/keyring.c

271

unsigned long chunk = 0;

security/keys/keyring.c

273

int desc_len = index_key->desc_len, n = sizeof(chunk);

security/keys/keyring.c

298

chunk <<= 8;

security/keys/keyring.c

299

chunk |= *--d;

security/keys/keyring.c

301

return chunk;

sound/core/memalloc.c

717

size_t chunk;

sound/core/memalloc.c

733

chunk = size;

sound/core/memalloc.c

736

chunk = min(size, chunk);

sound/core/memalloc.c

737

p = do_alloc_pages(dmab->dev.dev, chunk, &addr, wc);

sound/core/memalloc.c

739

if (chunk <= PAGE_SIZE)

sound/core/memalloc.c

741

chunk >>= 1;

sound/core/memalloc.c

742

chunk = PAGE_SIZE << get_order(chunk);

sound/core/memalloc.c

746

size -= chunk;

sound/core/memalloc.c

748

npages = chunk >> PAGE_SHIFT;

sound/hda/core/stream.c

460

int chunk;

sound/hda/core/stream.c

470

chunk = snd_sgbuf_get_chunk_size(dmab, ofs, size);

sound/hda/core/stream.c

475

if (chunk > remain)

sound/hda/core/stream.c

476

chunk = remain;

sound/hda/core/stream.c

478

bdl[2] = cpu_to_le32(chunk);

sound/hda/core/stream.c

482

size -= chunk;

sound/hda/core/stream.c

486

ofs += chunk;

sound/pci/es1968.c

1323

struct esm_memory *chunk = kmalloc_obj(*chunk);

sound/pci/es1968.c

1324

if (chunk == NULL)

sound/pci/es1968.c

1326

chunk->buf = buf->buf;

sound/pci/es1968.c

1327

chunk->buf.bytes -= size;

sound/pci/es1968.c

1328

chunk->buf.area += size;

sound/pci/es1968.c

1329

chunk->buf.addr += size;

sound/pci/es1968.c

1330

chunk->empty = 1;

sound/pci/es1968.c

1332

list_add(&chunk->list, &buf->list);

sound/pci/es1968.c

1341

struct esm_memory *chunk;

sound/pci/es1968.c

1346

chunk = list_entry(buf->list.prev, struct esm_memory, list);

sound/pci/es1968.c

1347

if (chunk->empty) {

sound/pci/es1968.c

1348

chunk->buf.bytes += buf->buf.bytes;

sound/pci/es1968.c

1351

buf = chunk;

sound/pci/es1968.c

1355

chunk = list_entry(buf->list.next, struct esm_memory, list);

sound/pci/es1968.c

1356

if (chunk->empty) {

sound/pci/es1968.c

1357

buf->buf.bytes += chunk->buf.bytes;

sound/pci/es1968.c

1358

list_del(&chunk->list);

sound/pci/es1968.c

1359

kfree(chunk);

sound/pci/es1968.c

1372

struct esm_memory *chunk = list_entry(p, struct esm_memory, list);

sound/pci/es1968.c

1374

kfree(chunk);

sound/pci/es1968.c

1382

struct esm_memory *chunk;

sound/pci/es1968.c

1401

chunk = kmalloc_obj(*chunk);

sound/pci/es1968.c

1402

if (chunk == NULL) {

sound/pci/es1968.c

1407

chunk->buf = chip->dma;

sound/pci/es1968.c

1408

chunk->buf.area += ESM_MEM_ALIGN;

sound/pci/es1968.c

1409

chunk->buf.addr += ESM_MEM_ALIGN;

sound/pci/es1968.c

1410

chunk->buf.bytes -= ESM_MEM_ALIGN;

sound/pci/es1968.c

1411

chunk->empty = 1;

sound/pci/es1968.c

1412

list_add(&chunk->list, &chip->buf_list);

sound/pci/lola/lola_pcm.c

307

int chunk;

sound/pci/lola/lola_pcm.c

317

chunk = snd_pcm_sgbuf_get_chunk_size(substream, ofs, size);

sound/pci/lola/lola_pcm.c

318

bdl[2] = cpu_to_le32(chunk);

sound/pci/lola/lola_pcm.c

322

size -= chunk;

sound/pci/lola/lola_pcm.c

326

ofs += chunk;

sound/soc/codecs/ntpfw.c

113

chunk = (struct ntpfw_chunk *)data;

sound/soc/codecs/ntpfw.c

115

if (!ntpfw_verify_chunk(dev, chunk, leftover)) {

sound/soc/codecs/ntpfw.c

120

ret = ntpfw_send_chunk(i2c, chunk);

sound/soc/codecs/ntpfw.c

124

data += be16_to_cpu(chunk->length) + sizeof(*chunk);

sound/soc/codecs/ntpfw.c

125

leftover -= be16_to_cpu(chunk->length) + sizeof(*chunk);

sound/soc/codecs/ntpfw.c

43

static bool ntpfw_verify_chunk(struct device *dev, const struct ntpfw_chunk *chunk, size_t buf_size)

sound/soc/codecs/ntpfw.c

47

if (buf_size <= sizeof(*chunk)) {

sound/soc/codecs/ntpfw.c

52

if (chunk->step != 2 && chunk->step != 5) {

sound/soc/codecs/ntpfw.c

53

dev_err(dev, "Failed to load firmware: invalid chunk step: %d\n", chunk->step);

sound/soc/codecs/ntpfw.c

57

chunk_size = be16_to_cpu(chunk->length);

sound/soc/codecs/ntpfw.c

63

if (chunk_size % chunk->step) {

sound/soc/codecs/ntpfw.c

71

static int ntpfw_send_chunk(struct i2c_client *i2c, const struct ntpfw_chunk *chunk)

sound/soc/codecs/ntpfw.c

75

size_t length = be16_to_cpu(chunk->length);

sound/soc/codecs/ntpfw.c

77

for (i = 0; i < length; i += chunk->step) {

sound/soc/codecs/ntpfw.c

78

ret = i2c_master_send(i2c, &chunk->data[i], chunk->step);

sound/soc/codecs/ntpfw.c

79

if (ret != chunk->step) {

sound/soc/codecs/ntpfw.c

91

const struct ntpfw_chunk *chunk;

sound/soc/codecs/sigmadsp.c

203

const struct sigma_fw_chunk *chunk, unsigned int length)

sound/soc/codecs/sigmadsp.c

215

ctrl_chunk = (const struct sigma_fw_chunk_control *)chunk;

sound/soc/codecs/sigmadsp.c

248

ctrl->samplerates = le32_to_cpu(chunk->samplerates);

sound/soc/codecs/sigmadsp.c

261

const struct sigma_fw_chunk *chunk, unsigned int length)

sound/soc/codecs/sigmadsp.c

269

data_chunk = (struct sigma_fw_chunk_data *)chunk;

sound/soc/codecs/sigmadsp.c

279

data->samplerates = le32_to_cpu(chunk->samplerates);

sound/soc/codecs/sigmadsp.c

287

const struct sigma_fw_chunk *chunk, unsigned int length)

sound/soc/codecs/sigmadsp.c

294

rate_chunk = (const struct sigma_fw_chunk_samplerate *)chunk;

sound/soc/codecs/sigmadsp.c

321

struct sigma_fw_chunk *chunk;

sound/soc/codecs/sigmadsp.c

329

if (fw->size < sizeof(*chunk) + sizeof(struct sigma_firmware_header))

sound/soc/codecs/sigmadsp.c

334

while (pos < fw->size - sizeof(*chunk)) {

sound/soc/codecs/sigmadsp.c

335

chunk = (struct sigma_fw_chunk *)(fw->data + pos);

sound/soc/codecs/sigmadsp.c

337

length = le32_to_cpu(chunk->length);

sound/soc/codecs/sigmadsp.c

339

if (length > fw->size - pos || length < sizeof(*chunk))

sound/soc/codecs/sigmadsp.c

342

switch (le32_to_cpu(chunk->tag)) {

sound/soc/codecs/sigmadsp.c

344

ret = sigma_fw_load_data(sigmadsp, chunk, length);

sound/soc/codecs/sigmadsp.c

347

ret = sigma_fw_load_control(sigmadsp, chunk, length);

sound/soc/codecs/sigmadsp.c

350

ret = sigma_fw_load_samplerates(sigmadsp, chunk, length);

sound/soc/codecs/sigmadsp.c

354

chunk->tag);

sound/soc/codecs/sigmadsp.c

56

struct sigma_fw_chunk chunk;

sound/soc/codecs/sigmadsp.c

62

struct sigma_fw_chunk chunk;

sound/soc/codecs/sigmadsp.c

70

struct sigma_fw_chunk chunk;

sound/soc/intel/avs/cldma.c

216

int chunk;

sound/soc/intel/avs/cldma.c

221

chunk = snd_sgbuf_get_chunk_size(dmab, offset, bdle_size);

sound/soc/intel/avs/cldma.c

222

bdl[2] = cpu_to_le32(chunk);

sound/soc/intel/avs/cldma.c

224

remaining -= chunk;

sound/soc/intel/avs/cldma.c

229

offset += chunk;

sound/soc/intel/avs/trace.c

25

u32 chunk;

sound/soc/intel/avs/trace.c

27

chunk = min_t(size_t, remaining, MAX_CHUNK_SIZE);

sound/soc/intel/avs/trace.c

28

trace_avs_ipc_msg_payload(data, chunk, offset, size);

sound/soc/intel/avs/trace.c

30

remaining -= chunk;

sound/soc/intel/avs/trace.c

31

offset += chunk;

sound/soc/intel/catpt/trace.c

19

u32 chunk;

sound/soc/intel/catpt/trace.c

21

chunk = min_t(size_t, remaining, MAX_CHUNK_SIZE);

sound/soc/intel/catpt/trace.c

22

trace_catpt_ipc_payload_chunk(data, chunk, offset, size);

sound/soc/intel/catpt/trace.c

24

remaining -= chunk;

sound/soc/intel/catpt/trace.c

25

offset += chunk;

sound/soc/sof/intel/hda-stream.c

101

offset += chunk;

sound/soc/sof/intel/hda-stream.c

75

int chunk;

sound/soc/sof/intel/hda-stream.c

87

chunk = snd_sgbuf_get_chunk_size(dmab, offset, size);

sound/soc/sof/intel/hda-stream.c

92

if (chunk > remain)

sound/soc/sof/intel/hda-stream.c

93

chunk = remain;

sound/soc/sof/intel/hda-stream.c

95

bdl->size = cpu_to_le32(chunk);

sound/soc/sof/intel/hda-stream.c

97

size -= chunk;

sound/usb/line6/midi.c

43

unsigned char chunk[LINE6_FALLBACK_MAXPACKETSIZE];

sound/usb/line6/midi.c

49

done = snd_rawmidi_transmit_peek(substream, chunk, req);

sound/usb/line6/midi.c

54

line6_midibuf_write(mb, chunk, done);

sound/usb/line6/midi.c

59

done = line6_midibuf_read(mb, chunk,

sound/usb/line6/midi.c

66

send_midi_async(line6, chunk, done);

tools/objtool/check.c

4790

struct insn_chunk *chunks = NULL, *chunk;

tools/objtool/check.c

4794

chunk = malloc(sizeof(*chunk));

tools/objtool/check.c

4795

chunk->addr = insn;

tools/objtool/check.c

4796

chunk->next = chunks;

tools/objtool/check.c

4797

chunks = chunk;

tools/objtool/check.c

4801

for (chunk = chunks; chunk; chunk = chunk->next)

tools/objtool/check.c

4802

free(chunk->addr);

tools/sched_ext/scx_sdt.bpf.c

130

struct sdt_chunk __arena *chunk;

tools/sched_ext/scx_sdt.bpf.c

134

chunk = scx_alloc_from_pool(&chunk_pool);

tools/sched_ext/scx_sdt.bpf.c

135

if (!chunk)

tools/sched_ext/scx_sdt.bpf.c

152

desc->chunk = chunk;

tools/sched_ext/scx_sdt.bpf.c

269

struct sdt_chunk __arena *chunk;

tools/sched_ext/scx_sdt.bpf.c

301

chunk = desc->chunk;

tools/sched_ext/scx_sdt.bpf.c

303

desc_children = (sdt_desc_t * __arena *)chunk->descs;

tools/sched_ext/scx_sdt.bpf.c

310

chunk = desc->chunk;

tools/sched_ext/scx_sdt.bpf.c

313

data = chunk->data[pos];

tools/sched_ext/scx_sdt.bpf.c

401

struct sdt_chunk __arena *chunk;

tools/sched_ext/scx_sdt.bpf.c

430

chunk = desc->chunk;

tools/sched_ext/scx_sdt.bpf.c

431

desc_children = (sdt_desc_t * __arena *)chunk->descs;

tools/sched_ext/scx_sdt.bpf.c

470

struct sdt_chunk __arena *chunk;

tools/sched_ext/scx_sdt.bpf.c

486

chunk = desc->chunk;

tools/sched_ext/scx_sdt.bpf.c

490

data = chunk->data[pos];

tools/sched_ext/scx_sdt.bpf.c

500

chunk->data[pos] = data;

tools/sched_ext/scx_sdt.h

65

struct sdt_chunk __arena *chunk;

tools/testing/radix-tree/main.c

15

void __gang_check(unsigned long middle, long down, long up, int chunk, int hop)

tools/testing/radix-tree/main.c

30

if (chunk > 0) {

tools/testing/radix-tree/main.c

32

chunk, hop);

tools/testing/radix-tree/main.c

33

item_full_scan(&tree, middle - down, down + up, chunk);

tools/testing/radix-tree/test.c

118

int chunk, int hop)

tools/testing/radix-tree/test.c

120

struct item *items[chunk];

tools/testing/radix-tree/test.c

125

int nr_to_find = chunk;

tools/testing/radix-tree/test.c

144

unsigned long nr, int chunk)

tools/testing/radix-tree/test.c

146

struct item *items[chunk];

tools/testing/radix-tree/test.c

155

chunk))) {

tools/testing/radix-tree/test.c

165

if (chunk)

tools/testing/radix-tree/test.c

168

this_index, chunk);

tools/testing/radix-tree/test.h

25

int chunk, int hop);

tools/testing/radix-tree/test.h

27

unsigned long nr, int chunk);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

137

int idx_set_allocated(struct buddy_chunk __arena *chunk, u64 idx, bool allocated)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

147

already_allocated = chunk->allocated[idx / 8] & (1 << (idx % 8));

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

151

idx, chunk);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

156

chunk->allocated[idx / 8] |= 1 << (idx % 8);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

158

chunk->allocated[idx / 8] &= ~(1 << (idx % 8));

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

163

static int idx_is_allocated(struct buddy_chunk __arena *chunk, u64 idx, bool *allocated)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

171

*allocated = chunk->allocated[idx / 8] & (1 << (idx % 8));

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

176

int idx_set_order(struct buddy_chunk __arena *chunk, u64 idx, u8 order)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

195

prev_order = chunk->orders[idx / 2];

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

204

chunk->orders[idx / 2] = order;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

209

static u8 idx_get_order(struct buddy_chunk __arena *chunk, u64 idx)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

221

result = chunk->orders[idx / 2];

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

226

static void __arena *idx_to_addr(struct buddy_chunk __arena *chunk, size_t idx)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

244

address = (u64)chunk + (idx * BUDDY_MIN_ALLOC_BYTES);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

249

static struct buddy_header __arena *idx_to_header(struct buddy_chunk __arena *chunk, size_t idx)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

254

if (unlikely(idx_is_allocated(chunk, idx, &allocated))) {

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

264

address = (u64)idx_to_addr(chunk, idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

289

static void header_add_freelist(struct buddy_chunk __arena *chunk, struct buddy_header __arena *header,

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

294

idx_set_order(chunk, idx, order);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

296

header->next_index = chunk->freelists[order];

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

300

tmp_header = idx_to_header(chunk, header->next_index);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

304

chunk->freelists[order] = idx;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

307

static void header_remove_freelist(struct buddy_chunk __arena *chunk,

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

313

tmp_header = idx_to_header(chunk, header->prev_index);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

318

tmp_header = idx_to_header(chunk, header->next_index);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

323

if (idx_to_header(chunk, chunk->freelists[order]) == header)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

324

chunk->freelists[order] = header->next_index;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

359

int add_leftovers_to_freelist(struct buddy_chunk __arena *chunk, u32 cur_idx,

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

370

header = idx_to_header(chunk, idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

378

header_add_freelist(chunk, header, idx, ord);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

387

struct buddy_chunk __arena *chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

412

chunk = bpf_arena_alloc_pages(&arena, (void __arena *)vaddr,

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

414

if (!chunk) {

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

431

asan_poison(chunk, BUDDY_POISONED, BUDDY_CHUNK_PAGES * __PAGE_SIZE);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

434

asan_unpoison(chunk, sizeof(*chunk));

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

438

chunk->freelists[ord] = BUDDY_CHUNK_ITEMS;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

505

left = sizeof(*chunk);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

522

sizeof(*chunk), left);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

533

if (idx_set_allocated(chunk, idx, true)) {

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

549

if (add_leftovers_to_freelist(chunk, idx, min_order, max_order)) {

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

561

return chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

566

struct buddy_chunk __arena *chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

580

chunk = buddy_chunk_get(buddy);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

583

bpf_arena_free_pages(&arena, chunk, BUDDY_CHUNK_PAGES);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

588

if (chunk)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

589

chunk->next = buddy->first_chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

592

buddy->first_chunk = chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

596

return chunk ? 0 : -ENOMEM;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

607

struct buddy_chunk __arena *chunk, *next;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

616

for (chunk = buddy->first_chunk; chunk && can_loop; chunk = next) {

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

617

next = chunk->next;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

620

asan_poison(chunk, BUDDY_POISONED,

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

622

bpf_arena_free_pages(&arena, chunk, BUDDY_CHUNK_PAGES);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

634

__weak u64 buddy_chunk_alloc(struct buddy_chunk __arena *chunk, int order_req)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

643

if (chunk->freelists[order] != BUDDY_CHUNK_ITEMS)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

650

retidx = chunk->freelists[order];

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

651

header = idx_to_header(chunk, retidx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

655

chunk->freelists[order] = header->next_index;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

658

next_header = idx_to_header(chunk, header->next_index);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

664

if (idx_set_order(chunk, retidx, order_req))

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

667

if (idx_set_allocated(chunk, retidx, true))

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

674

address = (u64)idx_to_addr(chunk, retidx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

687

header = idx_to_header(chunk, idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

691

if (idx_set_order(chunk, idx, i))

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

695

tmpidx = chunk->freelists[i];

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

701

tmp_header = idx_to_header(chunk, tmpidx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

705

chunk->freelists[i] = idx;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

714

struct buddy_chunk __arena *chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

717

for (chunk = buddy->first_chunk; chunk != NULL && can_loop;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

718

chunk = chunk->next) {

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

719

address = buddy_chunk_alloc(chunk, order);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

731

static u64 buddy_alloc_from_new_chunk(struct buddy __arena *buddy, struct buddy_chunk __arena *chunk, int order)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

743

chunk->next = buddy->first_chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

744

buddy->first_chunk = chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

756

struct buddy_chunk __arena *chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

777

chunk = buddy_chunk_get(buddy);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

778

if (chunk)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

779

address = (u8 __arena *)buddy_alloc_from_new_chunk(buddy, chunk, order);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

804

struct buddy_chunk __arena *chunk;

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

818

chunk = (void __arena *)(addr & ~BUDDY_CHUNK_OFFSET_MASK);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

822

ret = idx_set_allocated(chunk, idx, false);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

826

order = idx_get_order(chunk, idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

827

header = idx_to_header(chunk, idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

843

idx_is_allocated(chunk, buddy_idx, &allocated);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

851

if (idx_get_order(chunk, buddy_idx) != order)

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

854

buddy_header = idx_to_header(chunk, buddy_idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

855

header_remove_freelist(chunk, buddy_header, order);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

865

idx_set_order(chunk, buddy_idx, order);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

867

buddy_header = idx_to_header(chunk, buddy_idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

873

idx_set_order(chunk, idx, order);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

875

header = idx_to_header(chunk, idx);

tools/testing/selftests/bpf/libarena/src/buddy.bpf.c

876

header_add_freelist(chunk, header, idx, order);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

383

ssize_t chunk, res;

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

396

chunk = min_t(ssize_t, cfg_payload_len, to_send);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

397

res = send(fd, src, chunk, 0);

tools/testing/selftests/kvm/include/x86/processor.h

720

const u32 *chunk = (const u32 *)vendor;

tools/testing/selftests/kvm/include/x86/processor.h

724

return (ebx == chunk[0] && edx == chunk[1] && ecx == chunk[2]);

tools/testing/selftests/kvm/memslot_perf_test.c

722

u64 chunk)

tools/testing/selftests/kvm/memslot_perf_test.c

737

for (ctr = 0; ctr < guest_pages / 2; ctr += chunk)

tools/testing/selftests/kvm/memslot_perf_test.c

738

test_memslot_do_unmap(data, ctr, chunk);

tools/testing/selftests/kvm/memslot_perf_test.c

743

for (ctr = guest_pages / 2; ctr < guest_pages; ctr += chunk)

tools/testing/selftests/kvm/memslot_perf_test.c

744

test_memslot_do_unmap(data, ctr, chunk);

tools/testing/selftests/net/tcp_ao/lib/repair.c

138

int chunk = len;

tools/testing/selftests/net/tcp_ao/lib/repair.c

150

ret = send(sk, buf + off, chunk, 0);

tools/testing/selftests/net/tcp_ao/lib/repair.c

152

if (chunk > 1024) {

tools/testing/selftests/net/tcp_ao/lib/repair.c

153

chunk >>= 1;

tools/testing/selftests/net/tls.c

923

int chunk = TLS_PAYLOAD_MAX_LEN / 4;

tools/testing/selftests/net/tls.c

930

EXPECT_EQ(send(self->fd, &mem_send[chunk * i], chunk, 0),

tools/testing/selftests/net/tls.c

931

chunk);

tools/testing/selftests/net/tls.c

933

EXPECT_EQ(recv(self->cfd, mem_recv, chunk * 5 / 2,

tools/testing/selftests/net/tls.c

935

chunk * 5 / 2);

tools/testing/selftests/net/tls.c

936

EXPECT_EQ(memcmp(mem_send, mem_recv, chunk * 5 / 2), 0);

tools/testing/selftests/powerpc/nx-gzip/gzfht_test.c

193

uint32_t flushlen, chunk;

tools/testing/selftests/powerpc/nx-gzip/gzfht_test.c

227

chunk = atoi(buf);

tools/testing/selftests/powerpc/nx-gzip/gzfht_test.c

231

chunk = 1<<22;

tools/testing/selftests/powerpc/nx-gzip/gzfht_test.c

252

srclen = NX_MIN(chunk, inlen);

tools/testing/vsock/vsock_test.c

1751

char *chunk;

tools/testing/vsock/vsock_test.c

1783

chunk = malloc(chunk_size);

tools/testing/vsock/vsock_test.c

1784

if (!chunk) {

tools/testing/vsock/vsock_test.c

1788

memset(chunk, 0, chunk_size);

tools/testing/vsock/vsock_test.c

1795

msg.msg_control = chunk;