chunks
data->chunks, sizeof(cbor_item_t *), new_chunk_capacity);
data->chunks = new_chunks_data;
data->chunks[data->chunk_count++] = cbor_incref(chunk);
.chunks = NULL,
return ((struct cbor_indefinite_string_data *)item->data)->chunks;
((struct cbor_indefinite_string_data *)item->data)->chunks);
((struct cbor_indefinite_string_data *)item->data)->chunks);
cbor_item_t** chunks;
cbor_item_t **chunks = cbor_string_chunks_handle(item);
indef_string_size, cbor_serialized_size(chunks[i]));
cbor_item_t **chunks = cbor_bytestring_chunks_handle(item);
chunks[i], buffer + written, buffer_size - written);
cbor_item_t **chunks = cbor_string_chunks_handle(item);
size_t chunk_written = cbor_serialize_string(chunks[i], buffer + written,
cbor_item_t **chunks = cbor_bytestring_chunks_handle(item);
indef_bytestring_size, cbor_serialized_size(chunks[i]));
data->chunks = new_chunks_data;
data->chunks[data->chunk_count++] = cbor_incref(chunk);
.chunks = NULL,
return ((struct cbor_indefinite_string_data *)item->data)->chunks;
data->chunks, sizeof(cbor_item_t *), new_chunk_capacity);
static struct diskchunk chunks[MAXPARTITIONS + 2];
chunks[0].start = starting_sector;
chunks[0].stop = ending_sector;
chunks[1].start = chunks[1].stop = 0;
return chunks;
chunks[0].start = starting_sector;
chunks[0].stop = DL_GETPOFFSET(spp[0]);
chunks[numchunks].start = start;
chunks[numchunks].stop = stop;
chunks[numchunks].start = chunks[numchunks].stop = 0;
return chunks;
struct chunks chunks_xi_rv2p[] = {
struct chunks chunks_xi90_rv2p[] = {
struct chunks *chunks, u_int nchunks)
hswapn(chunks[i].start, *chunks[i].len);
rlen = write(fd, chunks[i].start, *chunks[i].len);
if (rlen != *chunks[i].len) {
struct chunks chunks_b06[] = {
struct chunks chunks_b09[] = {
struct chunks chunks_rv2p[] = {
kvfree(parser->chunks[i].kdata);
kvfree(parser->chunks);
chunk_array = memdup_array_user(u64_to_user_ptr(cs->in.chunks),
p->chunks = kvmalloc_array(p->nchunks, sizeof(struct amdgpu_cs_chunk),
if (!p->chunks) {
p->chunks[i].chunk_id = user_chunk.chunk_id;
p->chunks[i].length_dw = user_chunk.length_dw;
size = p->chunks[i].length_dw;
p->chunks[i].kdata = vmemdup_array_user(u64_to_user_ptr(user_chunk.chunk_data),
if (IS_ERR(p->chunks[i].kdata)) {
ret = PTR_ERR(p->chunks[i].kdata);
switch (p->chunks[i].chunk_id) {
ret = amdgpu_cs_p1_ib(p, p->chunks[i].kdata, num_ibs);
ret = amdgpu_cs_p1_user_fence(p, p->chunks[i].kdata,
ret = amdgpu_cs_p1_bo_handles(p, p->chunks[i].kdata);
kvfree(p->chunks[i].kdata);
kvfree(p->chunks);
p->chunks = NULL;
chunk = &p->chunks[i];
struct amdgpu_cs_chunk *chunks;
struct dcp_chunks chunks;
if (dcp->chunks.data != NULL) {
dcp->chunks.length = *length;
dcp->chunks.data = devm_kzalloc(dcp->dev, *length, GFP_KERNEL);
if (!dcp->chunks.data) {
if (!dcp->chunks.data) {
if (req->offset + req->length > dcp->chunks.length) {
memcpy(dcp->chunks.data + req->offset, req->data, req->length);
if (!dcp->chunks.data) {
ret = parse(dcp->chunks.data, dcp->chunks.length, &ctx);
devm_kfree(dcp->dev, dcp->chunks.data);
dcp->chunks.data = NULL;
__u64 chunks;
__u64 chunks;
struct radeon_cs_chunk *chunks;
chunk_array_ptr = (uint64_t *)(unsigned long)(cs->chunks);
p->chunks = kvcalloc(p->nchunks, sizeof(struct radeon_cs_chunk), GFP_KERNEL);
if (p->chunks == NULL) {
p->chunks[i].length_dw = user_chunk.length_dw;
p->chunk_relocs = &p->chunks[i];
p->chunk_ib = &p->chunks[i];
if (p->chunks[i].length_dw == 0)
p->chunk_const_ib = &p->chunks[i];
if (p->chunks[i].length_dw == 0)
p->chunk_flags = &p->chunks[i];
if (p->chunks[i].length_dw == 0)
size = p->chunks[i].length_dw;
p->chunks[i].user_ptr = cdata;
p->chunks[i].kdata = kvmalloc_array(size, sizeof(uint32_t), GFP_KERNEL);
if (p->chunks[i].kdata == NULL) {
if (copy_from_user(p->chunks[i].kdata, cdata, size)) {
p->cs_flags = p->chunks[i].kdata[0];
if (p->chunks[i].length_dw > 1)
ring = p->chunks[i].kdata[1];
if (p->chunks[i].length_dw > 2)
priority = (s32)p->chunks[i].kdata[2];
kvfree(parser->chunks[i].kdata);
kvfree(parser->chunks);
struct sr_chunk **chunks;
chunks = mallocarray(sd->sd_meta->ssdi.ssd_chunk_no,
chunks[c] = sd->sd_vol.sv_chunks[c];
ch_prev = chunks[c - 1];
chunks[c] = ch_entry;
sd->sd_vol.sv_chunks = chunks;
struct hibernate_disk_chunk *chunks;
chunks = (struct hibernate_disk_chunk *)(pva + HIBERNATE_CHUNK_SIZE);
hibernate_process_chunk(local_hib, &chunks[fchunks[i]],
image_cur += chunks[fchunks[i]].compressed_size;
struct hibernate_disk_chunk *chunks;
chunks = (struct hibernate_disk_chunk *)(hib->piglet_va +
chunks[hib->chunk_ctr].base = inaddr;
chunks[hib->chunk_ctr].end = inaddr +
chunks[hib->chunk_ctr].end = range_end;
range_base = chunks[i].base;
range_end = chunks[i].end;
chunks[i].offset = blkctr;
chunks[i].compressed_size = dbtob(blkctr - chunks[i].offset);
struct hibernate_disk_chunk *chunks;
chunks = (struct hibernate_disk_chunk *)chunktable;
if (compressed_size + chunks[i].compressed_size <
compressed_size += chunks[i].compressed_size;
chunks)) {
struct hibernate_disk_chunk *chunks)
chunks[i].flags = 0;
if (chunks[i].end <= pig_start || chunks[i].base >= pig_end) {
chunks[i].flags |= HIBERNATE_CHUNK_PLACED;
if (chunks[i].flags != HIBERNATE_CHUNK_PLACED) {
chunks[i].flags = HIBERNATE_CHUNK_PLACED;
blkctr = chunks[fchunks[i]].offset + hib->image_offset;
compressed_size = chunks[fchunks[i]].compressed_size;
int chunks, log_chunks, chunkperbucket = 1, hashshift = 0;
chunks = roundup((unsigned int)slots, UVM_AMAP_CHUNK) / UVM_AMAP_CHUNK;
for (log_chunks = 1; (chunks >> log_chunks) > 0; log_chunks++)
buckets = howmany(chunks, chunkperbucket);
_mm256_shuffle_epi8(t, simd->chunks[0]), simd->chunks[0]);
_mm256_shuffle_epi8(t, simd->chunks[1]), simd->chunks[1]);
typedef struct { __m256i chunks[1]; } simd_8x_t;
typedef struct { __m128i chunks[1]; } simd_8x16_t;
typedef struct { __m256i chunks[2]; } simd_8x64_t;
simd->chunks[0] = _mm256_loadu_si256((const __m256i *)(address));
_mm256_storeu_si256((__m256i *)address, simd->chunks[0]);
const __m256i r = _mm256_cmpeq_epi8(simd->chunks[0], k);
_mm256_shuffle_epi8(t, simd->chunks[0]), simd->chunks[0]);
simd->chunks[0] = _mm_loadu_si128((const __m128i *)address);
const __m128i r = _mm_cmpeq_epi8(simd->chunks[0], k);
simd->chunks[0] = _mm256_loadu_si256((const __m256i *)(address));
simd->chunks[1] = _mm256_loadu_si256((const __m256i *)(address+32));
const __m256i r0 = _mm256_cmpeq_epi8(simd->chunks[0], k);
const __m256i r1 = _mm256_cmpeq_epi8(simd->chunks[1], k);
const __m128i r0 = _mm_cmpeq_epi8(simd->chunks[0], k);
const __m128i r1 = _mm_cmpeq_epi8(simd->chunks[1], k);
const __m128i r2 = _mm_cmpeq_epi8(simd->chunks[2], k);
const __m128i r3 = _mm_cmpeq_epi8(simd->chunks[3], k);
_mm_shuffle_epi8(t, simd->chunks[0]), simd->chunks[0]);
_mm_shuffle_epi8(t, simd->chunks[1]), simd->chunks[1]);
_mm_shuffle_epi8(t, simd->chunks[2]), simd->chunks[2]);
_mm_shuffle_epi8(t, simd->chunks[3]), simd->chunks[3]);
typedef struct { __m128i chunks[1]; } simd_8x_t;
typedef struct { __m128i chunks[2]; } simd_8x32_t;
typedef struct { __m128i chunks[4]; } simd_8x64_t;
simd->chunks[0] = _mm_loadu_si128((const __m128i *)address);
_mm_storeu_si128((__m128i *)address, simd->chunks[0]);
const __m128i r = _mm_cmpeq_epi8(simd->chunks[0], k);
_mm_shuffle_epi8(t, simd->chunks[0]), simd->chunks[0]);
simd->chunks[0] = _mm_loadu_si128((const __m128i *)(address));
simd->chunks[1] = _mm_loadu_si128((const __m128i *)(address+16));
_mm_storeu_si128((__m128i *)(address), simd->chunks[0]);
_mm_storeu_si128((__m128i *)(address+16), simd->chunks[1]);
const __m128i r0 = _mm_cmpeq_epi8(simd->chunks[0], k);
const __m128i r1 = _mm_cmpeq_epi8(simd->chunks[1], k);
simd->chunks[0] = _mm_loadu_si128((const __m128i *)(address));
simd->chunks[1] = _mm_loadu_si128((const __m128i *)(address+16));
simd->chunks[2] = _mm_loadu_si128((const __m128i *)(address+32));
simd->chunks[3] = _mm_loadu_si128((const __m128i *)(address+48));