kvmalloc
image = kvmalloc(size, GFP_KERNEL);
inst = kvmalloc(len, GFP_KERNEL);
image = kvmalloc(size, GFP_KERNEL);
rw_image = kvmalloc(size, GFP_KERNEL);
image = kvmalloc(size, GFP_KERNEL);
mc = kvmalloc(mc_size, GFP_KERNEL);
rw_image = kvmalloc(size, GFP_KERNEL);
ctx = kvmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
ctx = kvmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
rbd_dev->object_map = kvmalloc(object_map_bytes, GFP_KERNEL);
buf = kvmalloc(bufsize, GFP_KERNEL | __GFP_NORETRY);
kbuf = kvmalloc(count, GFP_KERNEL);
ptr = kvmalloc(len, GFP_KERNEL);
buf = kvmalloc(patch_length, GFP_KERNEL);
mem->pages = kvmalloc(size, GFP_KERNEL);
log->bios_event_log = kvmalloc(len, GFP_KERNEL);
scratch->lz4s = kvmalloc(QAT_ZSTD_SCRATCH_SIZE, GFP_KERNEL);
scratch->literals = kvmalloc(QAT_ZSTD_SCRATCH_SIZE, GFP_KERNEL);
scratch->workspace = kvmalloc(cctx_size, GFP_KERNEL | __GFP_ZERO);
kvmalloc(cxl_mbox->payload_size, GFP_KERNEL);
mds->poison.list_out = kvmalloc(cxl_mbox->payload_size, GFP_KERNEL);
ret = kvmalloc(cxl_mbox->payload_size, GFP_KERNEL);
log = kvmalloc(size, GFP_KERNEL);
buf = kvmalloc(cxl_mbox->payload_size, GFP_KERNEL);
header = kvmalloc(header_storage_size, GFP_KERNEL);
occ->buffer = kvmalloc(OCC_MAX_RESP_WORDS * 4, GFP_KERNEL);
client->buffer = kvmalloc(OCC_SRAM_BYTES, GFP_KERNEL);
adev->psp.vbflash_tmp_buf = kvmalloc(AMD_VBIOS_FILE_MAX_SIZE_B, GFP_KERNEL);
adev->uvd.inst[j].saved_bo = kvmalloc(size, GFP_KERNEL);
adev->vcn.inst[i].saved_bo = kvmalloc(size, GFP_KERNEL);
adev->vce.saved_bo = kvmalloc(size, GFP_KERNEL);
pcrat_image = kvmalloc(dyn_size, GFP_KERNEL);
pcrat_image = kvmalloc(VCRAT_SIZE_FOR_GPU, GFP_KERNEL);
lt8713sx->fw_buffer = kvmalloc(SZ_256K, GFP_KERNEL);
buf = kvmalloc(buf_size, GFP_KERNEL);
et = kvmalloc(mem_size, GFP_KERNEL);
buf = kvmalloc(buffer_size, GFP_KERNEL);
state_bo->data = kvmalloc(size, GFP_KERNEL);
buf = kvmalloc(max_t(u32, rpc->length, expected), GFP_KERNEL);
iobj->suspend = kvmalloc(size, GFP_KERNEL);
stage_buffer.pixels = kvmalloc(line_width * pixel_size, GFP_KERNEL);
output_buffer.pixels = kvmalloc(line_width * pixel_size, GFP_KERNEL);
ss->read.buffer = kvmalloc(XE_DEVCOREDUMP_CHUNK_MAX,
ss->read.buffer = kvmalloc(ss->read.size, GFP_USER);
snapshot->lrc_snapshot = kvmalloc(snapshot->lrc_size, GFP_KERNEL);
snap->snap[i].data = kvmalloc(snap->snap[i].len, GFP_USER);
ctx->ffdc = kvmalloc(resp_len, GFP_KERNEL);
u8* fw_buf __free(kvfree) = kvmalloc(SZ_64K, GFP_KERNEL);
data = kvmalloc(len + 1, GFP_KERNEL);
(fifo)->data = kvmalloc(_bytes, (gfp) & GFP_KERNEL); \
(heap)->data = kvmalloc(_bytes, (gfp) & GFP_KERNEL); \
cmd->region_map = kvmalloc(bitmap_size(cmd->nr_regions), GFP_KERNEL);
recalc_tags = kvmalloc(recalc_tags_size, GFP_NOIO);
ic->journal_tree = kvmalloc(journal_tree_size, GFP_KERNEL);
dmi = kvmalloc(param_kernel->data_size, GFP_NOIO | __GFP_HIGH);
serial = kvmalloc(sizeof(struct serial_in_rdev) * serial_nums,
vec = kvmalloc(size, GFP_KERNEL);
buf->cfg = kvmalloc(params->vfmt.fmt.meta.buffersize, GFP_KERNEL);
buf->config = kvmalloc(v4l2_isp_params_buffer_size(MALI_C55_PARAMS_MAX_SIZE),
params_buf->cfg = kvmalloc(params->metafmt->buffersize,
state->ref_frame.buf = kvmalloc(total_planes_size, GFP_KERNEL);
new_comp_frame = kvmalloc(ctx->comp_max_size, GFP_KERNEL);
tmp = kvmalloc(elems * ref->ctrl->elem_size, GFP_KERNEL);
array_buf = kvmalloc(array_size, GFP_KERNEL);
cb->buf.data = kvmalloc(roundup(length, MEI_SLOT_SIZE), GFP_KERNEL);
datbuf = kvmalloc(datbuf_len, GFP_KERNEL);
oobbuf = kvmalloc(oobbuf_len, GFP_KERNEL);
datbuf = kvmalloc(datbuf_len, GFP_KERNEL);
oobbuf = kvmalloc(oobbuf_len, GFP_KERNEL);
crspace_data = kvmalloc(cr_res_size, GFP_KERNEL);
health_data = kvmalloc(HEALTH_BUFFER_SIZE, GFP_KERNEL);
cr_data = kvmalloc(crdump_size, GFP_KERNEL);
nfp_prog->prog = kvmalloc(nfp_prog->__prog_alloc_len, GFP_KERNEL);
rx_ring->rx_buffer_info = kvmalloc(size, GFP_KERNEL);
tx_ring->tx_buffer_info = kvmalloc(size, GFP_KERNEL);
h = kvmalloc(size, GFP_KERNEL);
ctrl->ana_log_buf = kvmalloc(ana_log_size, GFP_KERNEL);
fdt = kvmalloc(fdt_size, GFP_KERNEL);
dev_status_mem = kvmalloc(ZCRYPT_DEV_STATUS_EXT_SIZE, GFP_KERNEL);
dev_status_mem = kvmalloc(ZCRYPT_DEV_STATUS_EXT_SIZE, GFP_KERNEL);
asd->params.metadata_user[i] = kvmalloc(
kvmalloc(sizeof(struct ia_css_refcount_entry) * size, GFP_KERNEL);
me->data_ptr = kvmalloc(isp_stats->size, GFP_KERNEL);
all_binaries = kvmalloc(num_of_isp_binaries * sizeof(*all_binaries),
pool->handles = kvmalloc(bytes_needed, GFP_KERNEL);
me->address = kvmalloc(size, GFP_KERNEL);
histogram->run = kvmalloc(length * sizeof(*histogram->run),
histogram->stall = kvmalloc(length * sizeof(*histogram->stall),
histogram->msink = kvmalloc(length * sizeof(*histogram->msink),
dvs_config->xcoords_y = kvmalloc(array3_size(width_y, height_y, sizeof(uint32_t)),
dvs_config->ycoords_y = kvmalloc(array3_size(width_y, height_y, sizeof(uint32_t)),
dvs_config->xcoords_uv = kvmalloc(array3_size(width_uv, height_uv,
dvs_config->ycoords_uv = kvmalloc(array3_size(width_uv, height_uv,
kvmalloc(array3_size(width, height,
me->coordinates_x[i] = kvmalloc(array3_size(height, width,
me->coordinates_y[i] = kvmalloc(array3_size(height, width,
me->data_ptr = kvmalloc(isp_stats->size, GFP_KERNEL);
me->data = kvmalloc(grid_size * sizeof(*me->data), GFP_KERNEL);
me->rgby_data = kvmalloc(sizeof_hmem(HMEM0_ID), GFP_KERNEL);
me->hor_proj = kvmalloc(array3_size(grid->height,
me->ver_proj = kvmalloc(array3_size(grid->width,
me->hor_coefs = kvmalloc(grid->num_hor_coefs *
me->ver_coefs = kvmalloc(grid->num_ver_coefs *
me->hor_prod.odd_real = kvmalloc(grid->aligned_width *
me->hor_prod.odd_imag = kvmalloc(grid->aligned_width *
me->hor_prod.even_real = kvmalloc(grid->aligned_width *
me->hor_prod.even_imag = kvmalloc(grid->aligned_width *
me->ver_prod.odd_real = kvmalloc(grid->aligned_width *
me->ver_prod.odd_imag = kvmalloc(grid->aligned_width *
me->ver_prod.even_real = kvmalloc(grid->aligned_width *
me->ver_prod.even_imag = kvmalloc(grid->aligned_width *
me->hor_coefs.odd_real = kvmalloc(grid->num_hor_coefs *
me->hor_coefs.odd_imag = kvmalloc(grid->num_hor_coefs *
me->hor_coefs.even_real = kvmalloc(grid->num_hor_coefs *
me->hor_coefs.even_imag = kvmalloc(grid->num_hor_coefs *
me->ver_coefs.odd_real = kvmalloc(grid->num_ver_coefs *
me->ver_coefs.odd_imag = kvmalloc(grid->num_ver_coefs *
me->ver_coefs.even_real = kvmalloc(grid->num_ver_coefs *
me->ver_coefs.even_imag = kvmalloc(grid->num_ver_coefs *
dvs_config->xcoords_y = kvmalloc(array3_size(width_y, height_y,
dvs_config->ycoords_y = kvmalloc(array3_size(width_y, height_y,
dvs_config->xcoords_uv = kvmalloc(array3_size(width_uv, height_uv,
dvs_config->ycoords_uv = kvmalloc(array3_size(width_uv, height_uv,
params->fpn_config.data = kvmalloc(array3_size(height, width, sizeof(short)),
buf_chunk = kvmalloc(chunk, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
net->buffer = kvmalloc(PAGE_SIZE, GFP_KERNEL);
bounce_buf = kvmalloc(len, GFP_KERNEL);
data = kvmalloc(size, GFP_KERNEL);
ws->sample = kvmalloc(MAX_SAMPLE_SIZE, GFP_KERNEL);
workspace->mem = kvmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL | __GFP_NOWARN);
workspace->buf = kvmalloc(workspace_buf_length(fs_info), GFP_KERNEL | __GFP_NOWARN);
workspace->cbuf = kvmalloc(workspace_cbuf_length(fs_info), GFP_KERNEL | __GFP_NOWARN);
buf = kvmalloc(fs_info->nodesize, GFP_KERNEL);
buf = kvmalloc(buf_len, GFP_KERNEL);
sctx->verity_descriptor = kvmalloc(FS_VERITY_MAX_DESCRIPTOR_SIZE,
tmp_buf = kvmalloc(fs_info->nodesize, GFP_KERNEL);
sctx->send_buf = kvmalloc(sctx->send_max_size, GFP_KERNEL);
clone_sources_tmp = kvmalloc(alloc_size, GFP_KERNEL);
workspace->mem = kvmalloc(workspace->size, GFP_KERNEL | __GFP_NOWARN);
wksp = kvmalloc(wkspsz, GFP_KERNEL);
n_group_desc = kvmalloc((gdb_num + 1) * sizeof(struct buffer_head *),
n_group_desc = kvmalloc((gdb_num + 1) * sizeof(struct buffer_head *),
char *buf = kvmalloc(sb->s_blocksize, GFP_NOFS | __GFP_ZERO);
ea_data = kvmalloc(value_len, GFP_NOFS);
buffer = kvmalloc(value_size, GFP_NOFS);
return kvmalloc(size, flags);
data = kvmalloc(max_t(size_t,
ks->seq.buf = kvmalloc(seq_size, GFP_KERNEL_ACCOUNT);
bv = kvmalloc(bv_size, GFP_KERNEL);
valp = kvmalloc(len, GFP_KERNEL);
buf = kvmalloc(len, GFP_KERNEL);
buf = kvmalloc(len, GFP_KERNEL);
data = kvmalloc(bmp_ni->data_size, GFP_NOFS);
ucs = kvmalloc((max_name_len + 2) * sizeof(__le16),
le = kvmalloc(al_aligned(lsize), GFP_KERNEL);
le = kvmalloc(al_aligned(lsize), GFP_KERNEL);
frame_ondisk = kvmalloc(ondisk_size, GFP_KERNEL);
frame_ondisk = kvmalloc(frame_size, GFP_KERNEL);
struct ntfs_run *new_ptr = kvmalloc(bytes, GFP_KERNEL);
new_ptr = kvmalloc(bytes, GFP_KERNEL);
sbi->def_table = t = kvmalloc(bytes, GFP_KERNEL);
sbi->upcase = kvmalloc(0x10000 * sizeof(short), GFP_KERNEL);
new = kvmalloc(size, GFP_KERNEL);
zstream.workspace = kvmalloc(zlib_inflate_workspacesize(),
bits = kvmalloc(alloc_size, GFP_KERNEL);
return kvmalloc(size, GFP_KERNEL_ACCOUNT);
src = kvmalloc(src_len, KSMBD_DEFAULT_GFP);
out = kvmalloc(out_size + 4 + 1, KSMBD_DEFAULT_GFP);
conn->request_buf = kvmalloc(size, KSMBD_DEFAULT_GFP);
kvmalloc(rpc_resp->payload_sz, KSMBD_DEFAULT_GFP);
aux_payload_buf = kvmalloc(ALIGN(length, 8), KSMBD_DEFAULT_GFP);
new_xattr = kvmalloc(len, GFP_KERNEL_ACCOUNT);
klist = kvmalloc(size, GFP_KERNEL);
tmpbuffer = kvmalloc(args->geo->blksize, GFP_KERNEL | __GFP_NOFAIL);
tmpbuffer = kvmalloc(args->geo->blksize, GFP_KERNEL | __GFP_NOFAIL);
args->value = kvmalloc(valuelen, GFP_KERNEL | __GFP_NOLOCKDEP);
ab->name = kvmalloc(XATTR_NAME_MAX + 1, XCHK_GFP_FLAGS);
new_val = kvmalloc(value_size, XCHK_GFP_FLAGS);
ab->usedmap = kvmalloc(bmp_sz, XCHK_GFP_FLAGS);
ab->freemap = kvmalloc(bmp_sz, XCHK_GFP_FLAGS);
rp->xattr_name = kvmalloc(XATTR_NAME_MAX + 1, XCHK_GFP_FLAGS);
new_val = kvmalloc(bufsize, XCHK_GFP_FLAGS);
buf = kvmalloc(bufsize, XCHK_GFP_FLAGS);
rtg->rtg_rsum_cache = kvmalloc(rbmblocks, GFP_KERNEL);
__alloc_objs(kvmalloc, default_gfp(__VA_ARGS__), typeof(P), 1)
__alloc_objs(kvmalloc, default_gfp(__VA_ARGS__), typeof(P), COUNT)
__alloc_flex(kvmalloc, default_gfp(__VA_ARGS__), typeof(P), FAM, COUNT)
#define kvzalloc(_size, _flags) kvmalloc(_size, (_flags)|__GFP_ZERO)
seq->buf = kvmalloc(seq->size, GFP_KERNEL);
data = kvmalloc(attr->btf_size, GFP_KERNEL | __GFP_NOWARN);
*rw_header = kvmalloc(size, GFP_KERNEL);
value = kvmalloc(value_size, GFP_USER | __GFP_NOWARN);
next_key = kvmalloc(map->key_size, GFP_USER);
key = kvmalloc(map->key_size, GFP_USER | __GFP_NOWARN);
key = kvmalloc(map->key_size, GFP_USER | __GFP_NOWARN);
value = kvmalloc(value_size, GFP_USER | __GFP_NOWARN);
buf_prevkey = kvmalloc(map->key_size, GFP_USER | __GFP_NOWARN);
buf = kvmalloc(map->key_size + value_size, GFP_USER | __GFP_NOWARN);
value = kvmalloc(value_size, GFP_USER | __GFP_NOWARN);
fn_dup->counters = kvmalloc(cv_size, GFP_KERNEL);
dci_ptr->values = kvmalloc(cv_size, GFP_KERNEL);
s.workspace = kvmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
wksp = kvmalloc(wksp_size, GFP_KERNEL);
kvmalloc((alloc_pages) * PAGE_SIZE, gfp), \
orig = kvmalloc(prev_size, gfp); \
DEFINE_ALLOC_SIZE_TEST_PAIR(kvmalloc)
DEFINE_TEST_ALLOC(kvmalloc, kvfree, 0, 1, 0);
check_allocation_overflow(kvmalloc);
p = kvmalloc(len, gfp);
m->private = kvmalloc(PATH_MAX, GFP_KERNEL);
buf = kvmalloc(len + 1, GFP_KERNEL);
fc->sdata = kvmalloc(alloc_msize, GFP_NOFS);
fc->sdata = kvmalloc(alloc_msize, GFP_NOFS);
b->vec.iov_base = kvmalloc(len, gfp);
m->front.iov_base = kvmalloc(front_len, flags);
buf = kvmalloc(len, GFP_NOIO);
state = kvmalloc(array_size(max, sizeof(*state)), GFP_NOFS);
weight = kvmalloc(array_size(max, sizeof(*weight)), GFP_NOFS);
addr = kvmalloc(array_size(max, sizeof(*addr)), GFP_NOFS);
affinity = kvmalloc(array_size(max, sizeof(*affinity)),
map->osd_primary_affinity = kvmalloc(
work = kvmalloc(work_size, GFP_NOIO);
table = kvmalloc(sz, GFP_KERNEL);
new_batch = kvmalloc(sizeof(*new_batch) * new_batch_sz,
blob = kvmalloc(size, GFP_KERNEL_ACCOUNT);
info = kvmalloc(sz, GFP_KERNEL_ACCOUNT);
data = kvmalloc(head_size, GFP_KERNEL);
return kvmalloc(sz, GFP_KERNEL);
write_buf = kvmalloc(count + 1, GFP_KERNEL);
new_batch = kvmalloc(sizeof(*new_batch) * new_batch_sz,
h64 = kvmalloc(len, GFP_KERNEL);
buf = kvmalloc(enclen, GFP_KERNEL);
buf = kvmalloc(enclen, GFP_KERNEL);
payload = kvmalloc(plen, GFP_KERNEL);
payload = kvmalloc(plen, GFP_KERNEL);
payload = kvmalloc(plen, GFP_KERNEL);
key_data = kvmalloc(key_data_len, GFP_KERNEL);
addr = kvmalloc(val_sz, GFP_KERNEL);