GFP_KERNEL_ACCOUNT

arch/arm64/kvm/arm.c

245

if (!zalloc_cpumask_var(&kvm->arch.supported_cpus, GFP_KERNEL_ACCOUNT)) {

arch/arm64/kvm/arm.c

520

return kzalloc(sz, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/arm.c

522

return kvzalloc(sz, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/arm.c

897

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/hyp_trace.c

162

start = alloc_pages_exact(backing_size, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/hypercalls.c

150

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/hypercalls.c

157

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/hypercalls.c

205

xa_mk_value(filter.action), GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/mmu.c

1008

pgt = kzalloc_obj(*pgt, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/mmu.c

1164

addr = (void *)__get_free_page(GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/mmu.c

1187

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/mmu.c

211

return alloc_pages_exact(size, GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/arm64/kvm/nested.c

1335

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/nested.c

1804

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/nested.c

80

vcpu->arch.ctxt.vncr_array = (u64 *)__get_free_page(GFP_KERNEL_ACCOUNT |

arch/arm64/kvm/nested.c

95

tmp = kvcalloc(num_mmus, sizeof(*tmp), GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/pkvm.c

116

hyp_vcpu = alloc_pages_exact(hyp_vcpu_sz, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/pkvm.c

155

pgd = alloc_pages_exact(pgd_sz, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/pkvm.c

163

hyp_vm = alloc_pages_exact(hyp_vm_sz, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/pmu-emul.c

1182

kvm->arch.pmu_filter = bitmap_alloc(nr_events, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/ptdump.c

122

st = kzalloc_obj(struct kvm_ptdump_guest_state, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/reset.c

114

buf = kzalloc(reg_sz, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/sys_regs.c

472

ccsidr = kmalloc_array(CSSELR_MAX, sizeof(u32), GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-init.c

214

dist->spis = kzalloc_objs(struct vgic_irq, nr_spis, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-init.c

334

GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-irqfd.c

149

entries = kzalloc_objs(*entries, nr, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

1021

ite = kzalloc_obj(*ite, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

1148

device = kzalloc_obj(*device, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

1863

its = kzalloc_obj(struct vgic_its, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

585

old = xa_store(&its->translation_cache, cache_key, irq, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

88

irq = kzalloc_obj(struct vgic_irq, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

92

ret = xa_reserve_irq(&dist->lpi_xa, intid, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-its.c

977

collection = kzalloc_obj(*collection, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-mmio-v3.c

932

rdreg = kzalloc_obj(*rdreg, GFP_KERNEL_ACCOUNT);

arch/arm64/kvm/vgic/vgic-v4.c

260

GFP_KERNEL_ACCOUNT);

arch/loongarch/include/asm/pgalloc.h

67

ptdesc = pagetable_alloc(GFP_KERNEL_ACCOUNT, 0);

arch/loongarch/kvm/vm.c

72

GFP_KERNEL_ACCOUNT);

arch/mips/include/asm/pgalloc.h

60

ptdesc = pagetable_alloc(GFP_KERNEL_ACCOUNT, PMD_TABLE_ORDER);

arch/powerpc/mm/book3s64/pgtable.c

396

gfp_t gfp = GFP_KERNEL_ACCOUNT | __GFP_ZERO;

arch/powerpc/platforms/pseries/papr-hvpipe.c

491

src_info = kzalloc_obj(*src_info, GFP_KERNEL_ACCOUNT);

arch/powerpc/platforms/pseries/papr-phy-attest.c

228

params = kzalloc_obj(*params, GFP_KERNEL_ACCOUNT);

arch/powerpc/platforms/pseries/papr-platform-dump.c

325

GFP_KERNEL_ACCOUNT);

arch/powerpc/platforms/pseries/papr-rtas-common.c

55

new_ptr = kvrealloc(old_ptr, new_len, GFP_KERNEL_ACCOUNT);

arch/powerpc/platforms/pseries/papr-rtas-common.c

86

blob = kzalloc_obj(*blob, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/dat.c

36

o = (void *)__get_free_pages(GFP_KERNEL_ACCOUNT | __GFP_COMP, CRST_ALLOC_ORDER);

arch/s390/kvm/dat.c

42

o = (void *)__get_free_page(GFP_KERNEL_ACCOUNT);

arch/s390/kvm/dat.c

48

o = kzalloc_obj(struct vsie_rmap, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/dat.c

81

page = alloc_pages(GFP_KERNEL_ACCOUNT | __GFP_COMP, CRST_ALLOC_ORDER);

arch/s390/kvm/dat.h

928

mc = kzalloc_obj(*mc, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/gmap.c

60

gmap = kzalloc_obj(*gmap, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/guestdbg.c

187

wp_info->old_data = kmalloc(bp_data->len, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/guestdbg.c

235

wp_info = kmalloc_objs(*wp_info, nr_wp, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/guestdbg.c

242

bp_info = kmalloc_objs(*bp_info, nr_bp, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/guestdbg.c

348

temp = kmalloc(wp_info->len, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/intercept.c

441

sctns = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/s390/kvm/interrupt.c

1762

tmp_inti = kzalloc_obj(*inti, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/interrupt.c

2388

inti = kzalloc_obj(*inti, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/interrupt.c

2441

adapter = kzalloc_obj(*adapter, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/interrupt.c

2506

map = kzalloc_obj(*map, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/interrupt.c

2768

inti = kzalloc_obj(*inti, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/interrupt.c

3694

gib = (struct kvm_s390_gib *)get_zeroed_page(GFP_KERNEL_ACCOUNT | GFP_DMA);

arch/s390/kvm/kvm-s390.c

1509

proc = kzalloc_obj(*proc, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

1709

proc = kzalloc_obj(*proc, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

1737

mach = kzalloc_obj(*mach, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

2196

keys = kvmalloc_array(args->count, sizeof(*keys), GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

2233

keys = kvmalloc_array(args->count, sizeof(*keys), GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

2940

inti = kzalloc_obj(*inti, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

3264

gfp_t alloc_flags = GFP_KERNEL_ACCOUNT | __GFP_ZERO;

arch/s390/kvm/kvm-s390.c

3299

(struct sie_page2 *) get_zeroed_page(GFP_KERNEL_ACCOUNT | GFP_DMA);

arch/s390/kvm/kvm-s390.c

3683

void *cbrlo_page = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

3804

sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/s390/kvm/kvm-s390.c

4481

inti_mem = kzalloc_obj(*inti_mem, GFP_KERNEL_ACCOUNT);

arch/s390/kvm/priv.c

913

mem = get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/s390/kvm/priv.c

922

mem = get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/s390/kvm/pv.c

293

vcpu->arch.pv.stor_base = __get_free_pages(GFP_KERNEL_ACCOUNT,

arch/s390/kvm/pv.c

305

sida_addr = (void *)__get_free_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/s390/kvm/pv.c

353

kvm->arch.pv.stor_base = __get_free_pages(GFP_KERNEL_ACCOUNT, get_order(base));

arch/s390/kvm/vsie.c

1511

vsie_page = (void *)__get_free_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO | GFP_DMA);

arch/s390/kvm/vsie.c

1616

INIT_RADIX_TREE(&kvm->arch.vsie.addr_to_page, GFP_KERNEL_ACCOUNT);

arch/s390/mm/pgalloc.c

119

gfp_t gfp = GFP_KERNEL_ACCOUNT;

arch/s390/mm/pgalloc.c

19

gfp_t gfp = GFP_KERNEL_ACCOUNT;

arch/x86/coco/sev/core.c

1496

page = alloc_pages(GFP_KERNEL_ACCOUNT, get_order(sz));

arch/x86/coco/sev/core.c

745

p = alloc_pages_node(cpu_to_node(cpu), GFP_KERNEL_ACCOUNT | __GFP_ZERO, 1);

arch/x86/include/asm/kvm_host.h

2078

return kvzalloc(kvm_x86_ops.vm_size, GFP_KERNEL_ACCOUNT);

arch/x86/kernel/ldt.c

157

new_ldt = kmalloc_obj(struct ldt_struct, GFP_KERNEL_ACCOUNT);

arch/x86/kernel/ldt.c

171

new_ldt->entries = __vmalloc(alloc_size, GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/x86/kernel/ldt.c

173

new_ldt->entries = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/cpuid.c

605

e2 = kvmalloc_objs(*e2, cpuid->nent, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/hyperv.c

2733

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/hyperv.c

971

hv_vcpu = kzalloc_obj(struct kvm_vcpu_hv, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/i8254.c

743

pit = kzalloc_obj(struct kvm_pit, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/i8259.c

591

s = kzalloc_obj(struct kvm_pic, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/ioapic.c

722

ioapic = kzalloc_obj(struct kvm_ioapic, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/kvm_onhyperv.h

26

*p_hv_pa_pg = kzalloc(PAGE_SIZE, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/lapic.c

3111

apic = kzalloc_obj(*apic, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/lapic.c

3120

apic->regs = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/lapic.c

453

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/mmu.c

4029

h = kvzalloc_objs(*h, KVM_NUM_MMU_PAGES, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/mmu.c

4268

pae_root = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/mmu.c

4273

pml4_root = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/mmu.c

4278

pml5_root = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/mmu.c

6779

page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_DMA32);

arch/x86/kvm/mmu/page_track.c

55

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/tdp_mmu.c

1464

sp = kmem_cache_zalloc(mmu_page_header_cache, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/mmu/tdp_mmu.c

1468

sp->spt = (void *)__get_free_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/pmu.c

1265

filter = kzalloc(size, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/avic.c

298

kvm_svm->avic_physical_id_table = (void *)__get_free_pages(GFP_KERNEL_ACCOUNT | __GFP_ZERO,

arch/x86/kvm/svm/avic.c

334

kvm_svm->avic_logical_id_table = (void *)get_zeroed_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

1169

blob = kzalloc(params.len, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

1521

blob = kzalloc(params.len, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

1601

session_data = kzalloc(params.session_len, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

2167

if (!zalloc_cpumask_var(&dst_sev->have_run_cpus, GFP_KERNEL_ACCOUNT)) {

arch/x86/kvm/svm/sev.c

2227

context = snp_alloc_firmware_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

2564

data = kzalloc_obj(*data, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

2751

region = kzalloc_obj(*region, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

2864

if (!zalloc_cpumask_var(&mirror_sev->have_run_cpus, GFP_KERNEL_ACCOUNT)) {

arch/x86/kvm/svm/sev.c

3644

scratch_va = kvzalloc(min_len, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/sev.c

459

req_page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/x86/kvm/svm/sev.c

463

sev->guest_resp_buf = snp_alloc_firmware_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/x86/kvm/svm/sev.c

546

if (!zalloc_cpumask_var(&sev->have_run_cpus, GFP_KERNEL_ACCOUNT)) {

arch/x86/kvm/svm/sev.c

793

pages = kvzalloc_objs(*pages, npages, GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

arch/x86/kvm/svm/svm.h

1023

return snp_safe_alloc_page_node(numa_node_id(), GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/svm.h

795

return svm_alloc_permissions_map(MSRPM_SIZE, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/svm/svm.h

996

return snp_safe_alloc_page_node(numa_node_id(), GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/nested.c

5418

vmx->nested.cached_vmcs12 = kzalloc(VMCS12_SIZE, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/nested.c

5423

vmx->nested.cached_shadow_vmcs12 = kzalloc(VMCS12_SIZE, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/tdx.c

2462

tdr_page = alloc_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/tdx.c

2470

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/tdx.c

2475

tdcs_pages[i] = alloc_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/tdx.c

2954

page = alloc_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/tdx.c

2967

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/tdx.c

2974

page = alloc_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/vmx.c

3082

__get_free_page(GFP_KERNEL_ACCOUNT);

arch/x86/kvm/vmx/vmx.c

4851

pages = alloc_pages(GFP_KERNEL_ACCOUNT | __GFP_ZERO,

arch/x86/kvm/vmx/vmx.c

7692

vmx->pml_pg = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/x86/kvm/vmx/vmx.c

7748

page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/x86/kvm/vmx/vmx.h

679

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/x86.c

12799

page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

arch/x86/kvm/x86.c

12805

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/x86.c

12807

GFP_KERNEL_ACCOUNT);

arch/x86/kvm/x86.c

12813

GFP_KERNEL_ACCOUNT))

arch/x86/kvm/x86.c

13516

slot->arch.rmap[i] = __vcalloc(lpages, sz, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/x86.c

13553

linfo = __vcalloc(lpages, sizeof(*linfo), GFP_KERNEL_ACCOUNT);

arch/x86/kvm/x86.c

7001

msr_filter = kzalloc_obj(*msr_filter, GFP_KERNEL_ACCOUNT);

arch/x86/kvm/x86.c

9012

ctxt = kmem_cache_zalloc(x86_emulator_cache, GFP_KERNEL_ACCOUNT);

drivers/crypto/ccp/sev-dev-tio.c

758

data_pg = snp_alloc_firmware_page(GFP_KERNEL_ACCOUNT);

drivers/crypto/ccp/sev-dev.c

1500

page = __snp_alloc_firmware_pages(GFP_KERNEL_ACCOUNT | __GFP_ZERO,

drivers/crypto/ccp/sev-dev.c

2381

status_page = alloc_page(GFP_KERNEL_ACCOUNT);

drivers/crypto/ccp/sev-dev.c

691

page = alloc_pages(GFP_KERNEL_ACCOUNT, get_order(desc->len));

drivers/fwctl/main.c

117

void *inbuf __free(kvfree) = kvzalloc(cmd->in_len, GFP_KERNEL_ACCOUNT);

drivers/fwctl/main.c

218

kzalloc(fwctl->ops->uctx_size, GFP_KERNEL_ACCOUNT);

drivers/gpu/drm/drm_property.c

565

blob = kvzalloc(sizeof(struct drm_property_blob) + length, GFP_KERNEL_ACCOUNT);

drivers/hv/mshv_debugfs.c

160

GFP_KERNEL_ACCOUNT);

drivers/hv/mshv_debugfs.c

332

GFP_KERNEL_ACCOUNT);

drivers/hv/mshv_debugfs.c

475

GFP_KERNEL_ACCOUNT);

drivers/hv/mshv_eventfd.c

449

rp = kzalloc_obj(*rp, GFP_KERNEL_ACCOUNT);

drivers/hv/mshv_irq.c

41

GFP_KERNEL_ACCOUNT);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-iommufd.c

264

nested_domain = kzalloc_obj(*nested_domain, GFP_KERNEL_ACCOUNT);

drivers/iommu/intel/nested.c

221

domain = kzalloc_obj(*domain, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/driver.c

235

GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/io_pagetable.c

1472

GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/io_pagetable.c

248

area = kzalloc_obj(*area, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/io_pagetable.c

718

elm = kzalloc_obj(*elm, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/io_pagetable.c

901

reserved = kzalloc_obj(*reserved, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/ioas.c

135

allowed = kzalloc_obj(*allowed, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/main.c

299

ictx = kzalloc_obj(*ictx, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/main.c

41

obj = kzalloc(size, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/main.c

57

GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/pages.c

1375

pages = kzalloc_obj(*pages, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/pages.c

2470

access = kzalloc_obj(*access, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/pages.c

492

GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/pages.c

543

GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/selftest.c

1420

staccess = kzalloc_obj(*staccess, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/selftest.c

1564

pages = kvzalloc_objs(*pages, npages, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/selftest.c

1594

item = kzalloc_obj(*item, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/selftest.c

1646

tmp = kvzalloc(length, GFP_KERNEL_ACCOUNT);

drivers/iommu/iommufd/selftest.c

1710

GFP_KERNEL_ACCOUNT);

drivers/iommu/riscv/iommu.c

78

GFP_KERNEL_ACCOUNT, size);

drivers/net/ethernet/sfc/tc_encap_actions.c

123

neigh = kzalloc_obj(*neigh, GFP_KERNEL_ACCOUNT);

drivers/net/ethernet/sfc/tc_encap_actions.c

126

neigh->net = get_net_track(net, &neigh->ns_tracker, GFP_KERNEL_ACCOUNT);

drivers/net/ethernet/sfc/tc_encap_actions.c

160

GFP_KERNEL_ACCOUNT);

drivers/net/ethernet/sfc/tc_encap_actions.c

183

GFP_KERNEL_ACCOUNT);

drivers/net/ethernet/sfc/tc_encap_actions.c

634

encap = kzalloc_obj(*encap, GFP_KERNEL_ACCOUNT);

drivers/net/netdevsim/bpf.c

352

GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

drivers/net/netdevsim/bpf.c

356

GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

drivers/net/netdevsim/bpf.c

498

nmap = kzalloc_obj(*nmap, GFP_KERNEL_ACCOUNT);

drivers/net/netdevsim/netdev.c

1007

ns->rq = kzalloc_objs(*ns->rq, dev->num_rx_queues, GFP_KERNEL_ACCOUNT);

drivers/net/netdevsim/netdev.c

715

rq = kzalloc_obj(*rq, GFP_KERNEL_ACCOUNT);

drivers/net/netkit.c

1015

nkl = kzalloc_obj(*nkl, GFP_KERNEL_ACCOUNT);

drivers/net/veth.c

1441

GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);

drivers/tty/tty_io.c

3102

tty = kzalloc_obj(*tty, GFP_KERNEL_ACCOUNT);

drivers/vdpa/vdpa_user/vduse_dev.c

1256

GFP_KERNEL_ACCOUNT);

drivers/vfio/cdx/main.c

37

GFP_KERNEL_ACCOUNT);

drivers/vfio/container.c

363

container = kzalloc_obj(*container, GFP_KERNEL_ACCOUNT);

drivers/vfio/fsl-mc/vfio_fsl_mc.c

31

GFP_KERNEL_ACCOUNT);

drivers/vfio/fsl-mc/vfio_fsl_mc_intr.c

32

mc_irq = kzalloc_objs(*mc_irq, irq_count, GFP_KERNEL_ACCOUNT);

drivers/vfio/fsl-mc/vfio_fsl_mc_intr.c

80

irq->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-irq[%d](%s)",

drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.c

801

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.c

918

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/mlx5/cmd.c

1253

qp = kzalloc_obj(*qp, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/mlx5/cmd.c

332

in = kvzalloc(inlen, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/mlx5/cmd.c

502

kvzalloc_objs(struct page *, npages, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/mlx5/cmd.c

507

filled = alloc_pages_bulk(GFP_KERNEL_ACCOUNT, npages - done,

drivers/vfio/pci/mlx5/cmd.c

535

buf = kzalloc_obj(*buf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/mlx5/main.c

1016

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/mlx5/main.c

635

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_config.c

1268

vdev->msi_perm = kmalloc_obj(struct perm_bits, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_config.c

1761

map = kmalloc(pdev->cfg_size, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_config.c

1765

vconfig = kmalloc(pdev->cfg_size, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_core.c

1021

GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_core.c

231

dummy_res = kzalloc_obj(*dummy_res, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_core.c

62

new = kzalloc_obj(*new, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_igd.c

183

opregionvbt = kzalloc_obj(*opregionvbt, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_intrs.c

265

name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-intx(%s)", pci_name(pdev));

drivers/vfio/pci/vfio_pci_intrs.c

484

ctx->name = kasprintf(GFP_KERNEL_ACCOUNT, "vfio-msi%s[%d](%s)",

drivers/vfio/pci/vfio_pci_intrs.c

72

ctx = kzalloc_obj(*ctx, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_intrs.c

76

ret = xa_insert(&vdev->ctx, index, ctx, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/vfio_pci_rdwr.c

461

ioeventfd = kzalloc_obj(*ioeventfd, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/virtio/migrate.c

1048

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/virtio/migrate.c

127

buf = kzalloc_obj(*buf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/virtio/migrate.c

658

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/virtio/migrate.c

74

page_list = kvzalloc_objs(*page_list, to_fill, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/virtio/migrate.c

79

filled = alloc_pages_bulk(GFP_KERNEL_ACCOUNT, to_fill,

drivers/vfio/pci/virtio/migrate.c

88

SG_MAX_SINGLE_ALLOC, GFP_KERNEL_ACCOUNT);

drivers/vfio/pci/xe/main.c

267

migf = kzalloc_obj(*migf, GFP_KERNEL_ACCOUNT);

drivers/vfio/platform/vfio_platform_common.c

145

GFP_KERNEL_ACCOUNT);

drivers/vfio/platform/vfio_platform_irq.c

295

GFP_KERNEL_ACCOUNT);

drivers/vfio/platform/vfio_platform_irq.c

321

vdev->irqs[i].name = kasprintf(GFP_KERNEL_ACCOUNT,

drivers/vfio/vfio_iommu_type1.c

1562

GFP_KERNEL_ACCOUNT);

drivers/vfio/vfio_iommu_type1.c

1879

GFP_KERNEL_ACCOUNT);

drivers/vfio/vfio_main.c

513

df = kzalloc_obj(*df, GFP_KERNEL_ACCOUNT);

drivers/vfio/virqfd.c

121

virqfd = kzalloc_obj(*virqfd, GFP_KERNEL_ACCOUNT);

drivers/vhost/vdpa.c

1014

GFP_KERNEL_ACCOUNT);

drivers/vhost/vhost.c

835

worker = kzalloc_obj(*worker, GFP_KERNEL_ACCOUNT);

drivers/virt/coco/sev-guest/sev-guest.c

134

derived_key_resp = kzalloc(resp_len, GFP_KERNEL_ACCOUNT);

drivers/virt/coco/sev-guest/sev-guest.c

138

derived_key_req = kzalloc_obj(*derived_key_req, GFP_KERNEL_ACCOUNT);

drivers/virt/coco/sev-guest/sev-guest.c

184

report_req = kzalloc_obj(*report_req, GFP_KERNEL_ACCOUNT);

drivers/virt/coco/sev-guest/sev-guest.c

215

GFP_KERNEL_ACCOUNT | __GFP_ZERO);

drivers/virt/coco/sev-guest/sev-guest.c

234

report_resp = kzalloc(resp_len, GFP_KERNEL_ACCOUNT);

drivers/virt/coco/sev-guest/sev-guest.c

78

report_req = kzalloc_obj(*report_req, GFP_KERNEL_ACCOUNT);

drivers/virt/coco/sev-guest/sev-guest.c

91

report_resp = kzalloc(resp_len, GFP_KERNEL_ACCOUNT);

fs/binfmt_misc.c

365

e = kmalloc(memsize, GFP_KERNEL_ACCOUNT);

fs/binfmt_misc.c

477

char *masked = kmalloc(e->size, GFP_KERNEL_ACCOUNT);

fs/dcache.c

1921

GFP_KERNEL_ACCOUNT | __GFP_RECLAIMABLE);

fs/file.c

215

fdt = kmalloc_obj(struct fdtable, GFP_KERNEL_ACCOUNT);

fs/file.c

219

data = kvmalloc_objs(struct file *, nr, GFP_KERNEL_ACCOUNT);

fs/file.c

226

GFP_KERNEL_ACCOUNT);

fs/fs_context.c

267

fc = kzalloc_obj(struct fs_context, GFP_KERNEL_ACCOUNT);

fs/fuse/dax.c

1280

fi->dax = kzalloc_obj(*fi->dax, GFP_KERNEL_ACCOUNT);

fs/fuse/dev.c

223

return kzalloc_obj(struct fuse_forget_link, GFP_KERNEL_ACCOUNT);

fs/fuse/dev_uring.c

1153

ent = kzalloc_obj(*ent, GFP_KERNEL_ACCOUNT);

fs/fuse/dev_uring.c

244

ring = kzalloc_obj(*ring, GFP_KERNEL_ACCOUNT);

fs/fuse/dev_uring.c

249

GFP_KERNEL_ACCOUNT);

fs/fuse/dev_uring.c

291

queue = kzalloc_obj(*queue, GFP_KERNEL_ACCOUNT);

fs/fuse/dir.c

475

GFP_KERNEL_ACCOUNT | __GFP_RECLAIMABLE);

fs/fuse/file.c

58

ff = kzalloc_obj(struct fuse_file, GFP_KERNEL_ACCOUNT);

fs/fuse/file.c

64

ff->args = kzalloc_obj(*ff->args, GFP_KERNEL_ACCOUNT);

fs/fuse/inode.c

70

sl = kzalloc_obj(struct fuse_submount_lookup, GFP_KERNEL_ACCOUNT);

fs/hostfs/hostfs_kern.c

216

hi = alloc_inode_sb(sb, hostfs_inode_cache, GFP_KERNEL_ACCOUNT);

fs/mnt_idmapping.c

251

GFP_KERNEL_ACCOUNT);

fs/mnt_idmapping.c

257

GFP_KERNEL_ACCOUNT);

fs/mnt_idmapping.c

292

idmap = kzalloc_obj(struct mnt_idmap, GFP_KERNEL_ACCOUNT);

fs/namespace.c

297

GFP_KERNEL_ACCOUNT);

fs/namespace.c

4205

new_ns = kzalloc_obj(struct mnt_namespace, GFP_KERNEL_ACCOUNT);

fs/namespace.c

5881

ks->seq.buf = kvmalloc(seq_size, GFP_KERNEL_ACCOUNT);

fs/namespace.c

5995

ks = kmalloc(sizeof(*ks), GFP_KERNEL_ACCOUNT);

fs/namespace.c

6110

GFP_KERNEL_ACCOUNT);

fs/nfs/delegation.c

452

delegation = kmalloc_obj(*delegation, GFP_KERNEL_ACCOUNT);

fs/nfs/dir.c

82

ctx = kzalloc_obj(*ctx, GFP_KERNEL_ACCOUNT);

fs/nfs/fscache.c

291

netfs = kzalloc_obj(*netfs, GFP_KERNEL_ACCOUNT);

fs/nfs/inode.c

1116

new = kmalloc_obj(*new, GFP_KERNEL_ACCOUNT);

fs/nfs/inode.c

1194

ctx = kmalloc_obj(*ctx, GFP_KERNEL_ACCOUNT);

fs/nfs/nfs4state.c

615

state = kzalloc_obj(*state, GFP_KERNEL_ACCOUNT);

fs/nfs/nfs4state.c

818

lsp = kzalloc_obj(*lsp, GFP_KERNEL_ACCOUNT);

fs/notify/fanotify/fanotify.c

751

gfp_t gfp = GFP_KERNEL_ACCOUNT;

fs/notify/fanotify/fanotify_user.c

1551

oevent = kmalloc_obj(*oevent, GFP_KERNEL_ACCOUNT);

fs/notify/fanotify/fanotify_user.c

1566

GFP_KERNEL_ACCOUNT);

fs/notify/group.c

148

gfp_t gfp = (flags & FSNOTIFY_GROUP_USER) ? GFP_KERNEL_ACCOUNT :

fs/notify/inotify/inotify_fsnotify.c

96

event = kmalloc(alloc_len, GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);

fs/notify/inotify/inotify_user.c

664

oevent = kmalloc_obj(struct inotify_event_info, GFP_KERNEL_ACCOUNT);

fs/overlayfs/params.c

355

l = krealloc_array(ctx->lower, nr, sizeof(*l), GFP_KERNEL_ACCOUNT);

fs/overlayfs/params.c

473

buf = kmalloc(PATH_MAX, GFP_KERNEL_ACCOUNT);

fs/overlayfs/params.c

802

ctx = kzalloc_obj(*ctx, GFP_KERNEL_ACCOUNT);

fs/overlayfs/params.c

810

ctx->lower = kmalloc_objs(*ctx->lower, 3, GFP_KERNEL_ACCOUNT);

fs/pipe.c

1398

bufs = kzalloc_objs(*bufs, nr_slots, GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

fs/pipe.c

898

pipe = kzalloc_obj(struct pipe_inode_info, GFP_KERNEL_ACCOUNT);

fs/pipe.c

916

GFP_KERNEL_ACCOUNT);

fs/proc/proc_sysctl.c

1379

sizeof(struct ctl_node)*table_size, GFP_KERNEL_ACCOUNT);

fs/proc/task_mmu.c

1624

priv = kzalloc_obj(*priv, GFP_KERNEL_ACCOUNT);

fs/seq_file.c

39

return kvmalloc(size, GFP_KERNEL_ACCOUNT);

fs/seq_file.c

576

struct seq_operations *op = kmalloc_obj(*op, GFP_KERNEL_ACCOUNT);

fs/seq_file.c

638

private = kzalloc(psize, GFP_KERNEL_ACCOUNT);

fs/xattr.c

1271

new_xattr = kvmalloc(len, GFP_KERNEL_ACCOUNT);

fs/xattr.c

1444

new_xattr->name = kstrdup(name, GFP_KERNEL_ACCOUNT);

include/linux/kvm_host.h

1679

return kzalloc_obj(struct kvm, GFP_KERNEL_ACCOUNT);

include/linux/thread_info.h

95

#define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_ZERO | __GFP_SKIP_KASAN)

include/trace/events/mmflags.h

94

gfpflag_string(GFP_KERNEL_ACCOUNT), \

io_uring/bpf_filter.c

155

filters = kzalloc_obj(*filters, GFP_KERNEL_ACCOUNT);

io_uring/bpf_filter.c

160

GFP_KERNEL_ACCOUNT);

io_uring/bpf_filter.c

404

filter = kzalloc_obj(*filter, GFP_KERNEL_ACCOUNT);

io_uring/filetable.c

48

table->bitmap = bitmap_zalloc(nr_files, GFP_KERNEL_ACCOUNT);

io_uring/futex.c

191

GFP_KERNEL_ACCOUNT);

io_uring/io_uring.c

1344

de = kmalloc_obj(*de, GFP_KERNEL_ACCOUNT);

io_uring/io_uring.c

201

GFP_KERNEL_ACCOUNT);

io_uring/kbuf.c

565

buf = kmalloc_obj(*buf, GFP_KERNEL_ACCOUNT);

io_uring/kbuf.c

592

bl = kzalloc_obj(*bl, GFP_KERNEL_ACCOUNT);

io_uring/kbuf.c

665

bl = kzalloc_obj(*bl, GFP_KERNEL_ACCOUNT);

io_uring/memmap.c

156

gfp_t gfp = GFP_KERNEL_ACCOUNT | __GFP_ZERO | __GFP_NOWARN;

io_uring/memmap.c

59

pages = kvmalloc_objs(struct page *, nr_pages, GFP_KERNEL_ACCOUNT);

io_uring/mock_file.c

245

mf = kzalloc_obj(*mf, GFP_KERNEL_ACCOUNT);

io_uring/register.c

229

res = kzalloc_obj(*res, GFP_KERNEL_ACCOUNT);

io_uring/register.c

261

res = kzalloc_obj(*res, GFP_KERNEL_ACCOUNT);

io_uring/rsrc.c

1462

gfp_t gfp = GFP_KERNEL_ACCOUNT | __GFP_NOWARN;

io_uring/rsrc.c

291

GFP_KERNEL_ACCOUNT | __GFP_ZERO);

io_uring/rsrc.c

48

ret = xa_reserve(&ctx->hpage_acct, key, GFP_KERNEL_ACCOUNT);

io_uring/rsrc.c

54

xa_store(&ctx->hpage_acct, key, xa_mk_value(count), GFP_KERNEL_ACCOUNT);

io_uring/rsrc.c

74

xa_store(&ctx->hpage_acct, key, xa_mk_value(count - 1), GFP_KERNEL_ACCOUNT);

io_uring/tctx.c

417

res = kzalloc_obj(*res, GFP_KERNEL_ACCOUNT);

io_uring/zcrx.c

221

GFP_KERNEL_ACCOUNT);

io_uring/zcrx.c

491

GFP_KERNEL_ACCOUNT | __GFP_ZERO);

io_uring/zcrx.c

496

GFP_KERNEL_ACCOUNT | __GFP_ZERO);

io_uring/zcrx.c

501

GFP_KERNEL_ACCOUNT | __GFP_ZERO);

ipc/msg.c

151

msq = kmalloc_obj(*msq, GFP_KERNEL_ACCOUNT);

ipc/msgutil.c

76

seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT);

ipc/namespace.c

61

ns = kzalloc_obj(struct ipc_namespace, GFP_KERNEL_ACCOUNT);

ipc/sem.c

1856

undo_list = kzalloc_obj(*undo_list, GFP_KERNEL_ACCOUNT);

ipc/sem.c

1941

new = kvzalloc_flex(*new, semadj, nsems, GFP_KERNEL_ACCOUNT);

ipc/sem.c

517

sma = kvzalloc_flex(*sma, sems, nsems, GFP_KERNEL_ACCOUNT);

ipc/shm.c

727

shp = kmalloc_obj(*shp, GFP_KERNEL_ACCOUNT);

kernel/bpf/arraymap.c

1177

aux = kzalloc_obj(*aux, GFP_KERNEL_ACCOUNT);

kernel/bpf/backtrack.c

39

p = krealloc(cur->jmp_history, alloc_size, GFP_KERNEL_ACCOUNT);

kernel/bpf/btf.c

3638

GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/bpf/btf.c

4136

rec = kzalloc_flex(*rec, fields, cnt, GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/bpf/btf.c

9485

new_cands = kmemdup(cands, sizeof_cands(cands->cnt), GFP_KERNEL_ACCOUNT);

kernel/bpf/btf.c

9493

new_cands->name = kmemdup_nul(cands->name, cands->name_len, GFP_KERNEL_ACCOUNT);

kernel/bpf/btf.c

9577

new_cands = kmalloc(sizeof_cands(cands->cnt + 1), GFP_KERNEL_ACCOUNT);

kernel/bpf/btf.c

9694

specs = kzalloc_objs(*specs, 3, GFP_KERNEL_ACCOUNT);

kernel/bpf/btf.c

9720

GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

180

new = kvrealloc(old, new_size, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

569

GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

574

GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

661

postorder = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

662

state = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

663

stack = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

730

stack = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

731

pre = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

732

low = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

733

dfs = kvcalloc(insn_cnt, sizeof(*dfs), GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

871

GFP_KERNEL_ACCOUNT);

kernel/bpf/check_btf.c

167

GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/bpf/check_btf.c

241

GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/bpf/check_btf.c

66

krecord = kvcalloc(nfuncs, krec_size, GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/bpf/const_fold.c

251

ci_in = kvzalloc_objs(*ci_in, insn_cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/fixups.c

1014

new_aux = __vmalloc(size, GFP_KERNEL_ACCOUNT);

kernel/bpf/fixups.c

257

GFP_KERNEL_ACCOUNT | __GFP_ZERO);

kernel/bpf/fixups.c

992

starts = kvmalloc_objs(u32, env->subprog_cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/inode.c

434

link = kstrdup(target, GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/bpf/inode.c

947

new_xattr->name = kasprintf(GFP_KERNEL_ACCOUNT,

kernel/bpf/liveness.c

122

env->liveness = kvzalloc_obj(*env->liveness, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

1638

at_in = kvmalloc_objs(*at_in, len, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

1642

at_stack_in = kvmalloc_objs(*at_stack_in, len, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

1646

at_stack_out = kvmalloc_objs(*at_stack_out, MAX_ARG_SPILL_SLOTS, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

170

GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

1742

MAX_ARG_SPILL_SLOTS, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

1818

f = kvzalloc_obj(*f, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

2001

info = kvzalloc_objs(*info, env->subprog_cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

2006

GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

2234

state = kvzalloc_objs(*state, insn_cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

555

sorted_instances = kvmalloc_objs(*sorted_instances, cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/liveness.c

88

f = kvzalloc(sizeof(*f), GFP_KERNEL_ACCOUNT);

kernel/bpf/ringbuf.c

95

const gfp_t flags = GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL |

kernel/bpf/states.c

128

info = kvrealloc(env->scc_info[scc], new_sz, GFP_KERNEL_ACCOUNT);

kernel/bpf/states.c

1495

GFP_KERNEL_ACCOUNT);

kernel/bpf/states.c

1559

new_sl = kzalloc_obj(struct bpf_verifier_state_list, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1297

new_arr = krealloc(arr, alloc_size, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1314

sizeof(struct bpf_reference_state), GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1333

GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1344

GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1624

GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1653

dst = kzalloc_obj(*dst, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1754

elem = kzalloc_obj(struct bpf_verifier_stack_elem, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

18367

state = kzalloc_obj(struct bpf_verifier_state, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

18374

state->frame[0] = kzalloc_obj(struct bpf_func_state, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

18622

prog->aux->ctx_arg_info = kmemdup_array(info, cnt, sizeof(*info), GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

19789

env = kvzalloc_obj(struct bpf_verifier_env, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

19853

GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

19997

GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

20012

GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

2278

elem = kzalloc_obj(struct bpf_verifier_stack_elem, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

2301

frame = kzalloc_obj(*frame, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

2712

tab = kzalloc_obj(*tab, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

2728

btf_tab = kzalloc_obj(*btf_tab, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

2914

color = kvzalloc_objs(*color, cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

2915

dfs_stack = kvmalloc_objs(*dfs_stack, cnt, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

5281

dinfo = kvcalloc(env->subprog_cnt, sizeof(*dinfo), GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

9101

callee = kzalloc_obj(*callee, GFP_KERNEL_ACCOUNT);

kernel/cgroup/namespace.c

27

new_ns = kzalloc_obj(struct cgroup_namespace, GFP_KERNEL_ACCOUNT);

kernel/cred.c

155

if (security_cred_alloc_blank(new, GFP_KERNEL_ACCOUNT) < 0)

kernel/cred.c

215

if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)

kernel/cred.c

597

if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)

kernel/fork.c

1141

if (percpu_counter_init_many(mm->rss_stat, 0, GFP_KERNEL_ACCOUNT,

kernel/futex/core.c

1824

GFP_KERNEL_ACCOUNT | __GFP_NOWARN);

kernel/groups.c

18

gi = kvmalloc_flex(*gi, gid, gidsetsize, GFP_KERNEL_ACCOUNT);

kernel/time/namespace.c

94

ns = kzalloc_obj(*ns, GFP_KERNEL_ACCOUNT);

kernel/time/namespace_vdso.c

150

ns->vvar_page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

kernel/trace/trace_events_user.c

1141

field = kmalloc_obj(*field, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

1160

validator = kmalloc_obj(*validator, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

1452

print_fmt = kmalloc(len, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

1800

name = kstrdup(raw_command, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

1987

multi_name = kasprintf(GFP_KERNEL_ACCOUNT, "%s.%llx",

kernel/trace/trace_events_user.c

2133

user = kzalloc_obj(*user, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

2343

info = kzalloc_obj(*info, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

2394

new_refs = kzalloc(size, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

734

user_mm = kzalloc_obj(*user_mm, GFP_KERNEL_ACCOUNT);

kernel/trace/trace_events_user.c

920

enabler = kzalloc_obj(*enabler, GFP_KERNEL_ACCOUNT);

lib/tests/slub_kunit.c

355

gfp_t gfp = (i % 2) ? GFP_KERNEL : GFP_KERNEL_ACCOUNT;

mm/memcontrol-v1.c

1132

event = kzalloc_obj(*event, GFP_KERNEL_ACCOUNT);

mm/memcontrol-v1.c

2253

GFP_KERNEL_ACCOUNT);

mm/memcontrol-v1.c

806

new = kmalloc_flex(*new, entries, size, GFP_KERNEL_ACCOUNT);

mm/memcontrol-v1.c

969

event = kmalloc_obj(*event, GFP_KERNEL_ACCOUNT);

mm/memcontrol.c

4040

GFP_KERNEL_ACCOUNT, node);

mm/memcontrol.c

4045

GFP_KERNEL_ACCOUNT);

mm/memcontrol.c

4105

memcg->vmstats = kzalloc_obj(struct memcg_vmstats, GFP_KERNEL_ACCOUNT);

mm/memcontrol.c

4110

GFP_KERNEL_ACCOUNT);

mm/shmem.c

4204

new_xattr->name = kasprintf(GFP_KERNEL_ACCOUNT,

mm/vmalloc.c

3955

GFP_NOFS | GFP_NOIO | GFP_KERNEL_ACCOUNT |\

net/8021q/vlan.c

69

array = kzalloc(size, GFP_KERNEL_ACCOUNT);

net/bridge/netfilter/ebtables.c

1138

newinfo = __vmalloc(sizeof(*newinfo) + countersize, GFP_KERNEL_ACCOUNT);

net/bridge/netfilter/ebtables.c

1145

newinfo->entries = __vmalloc(tmp.entries_size, GFP_KERNEL_ACCOUNT);

net/core/dev.c

11167

rx = kvzalloc(sz, GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);

net/core/dev.c

11234

tx = kvzalloc(sz, GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);

net/core/dev.c

12055

GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);

net/core/dev.c

12128

dev->ethtool = kzalloc_obj(*dev->ethtool, GFP_KERNEL_ACCOUNT);

net/core/dev.c

12132

dev->cfg = kzalloc_obj(*dev->cfg, GFP_KERNEL_ACCOUNT);

net/core/dev.c

12139

dev->napi_config = kvzalloc(napi_config_sz, GFP_KERNEL_ACCOUNT);

net/core/fib_rules.c

600

nlrule = kzalloc(ops->rule_size, GFP_KERNEL_ACCOUNT);

net/core/fib_rules.c

61

r = kzalloc(ops->rule_size, GFP_KERNEL_ACCOUNT);

net/core/neighbour.c

3854

t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL_ACCOUNT);

net/core/rtnetlink.c

4345

alt_ifname = nla_strdup(attr, GFP_KERNEL_ACCOUNT);

net/core/scm.c

415

GFP_KERNEL_ACCOUNT);

net/core/scm.c

86

fpl = kmalloc_obj(struct scm_fp_list, GFP_KERNEL_ACCOUNT);

net/ethtool/common.c

897

ctx = kzalloc(size, GFP_KERNEL_ACCOUNT);

net/ethtool/ioctl.c

1687

XA_LIMIT(1, limit - 1), GFP_KERNEL_ACCOUNT);

net/ethtool/netlink.c

938

GFP_KERNEL_ACCOUNT);

net/ethtool/rss.c

1072

XA_LIMIT(1, limit - 1), GFP_KERNEL_ACCOUNT);

net/ethtool/rss.c

1075

req.rss_context, ctx, GFP_KERNEL_ACCOUNT);

net/ipv4/devinet.c

212

ifa = kzalloc_obj(*ifa, GFP_KERNEL_ACCOUNT);

net/ipv4/devinet.c

2734

t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL_ACCOUNT);

net/ipv4/inet_hashtables.c

1359

GFP_KERNEL_ACCOUNT);

net/ipv4/udp.c

3700

GFP_KERNEL_ACCOUNT);

net/ipv6/addrconf.c

348

idev->stats.ipv6 = alloc_percpu_gfp(struct ipstats_mib, GFP_KERNEL_ACCOUNT);

net/ipv6/addrconf.c

363

GFP_KERNEL_ACCOUNT);

net/ipv6/addrconf.c

388

ndev = kzalloc_obj(*ndev, GFP_KERNEL_ACCOUNT);

net/ipv6/addrconf.c

7348

table = kmemdup(addrconf_sysctl, sizeof(addrconf_sysctl), GFP_KERNEL_ACCOUNT);

net/ipv6/sit.c

327

kzalloc_objs(*kp, cmax, GFP_KERNEL_ACCOUNT | __GFP_NOWARN) :

net/mptcp/pm_kernel.c

1029

entry = kmemdup(&addr, sizeof(addr), GFP_KERNEL_ACCOUNT);

net/netfilter/core.c

54

e = kvzalloc(alloc, GFP_KERNEL_ACCOUNT);

net/netfilter/ipset/ip_set_core.c

261

return kvzalloc(size, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_conntrack_helper.c

423

new_helper = kzalloc_obj(*new_helper, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_conntrack_helper.c

527

new_helper = kzalloc_obj(*new_helper, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_flow_table_xdp.c

57

ft_elem = kzalloc_obj(*ft_elem, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_flow_table_xdp.c

73

elem = kzalloc_obj(*elem, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

1615

table = kzalloc_obj(*table, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

1620

table->name = nla_strdup(attr, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

1625

table->udata = nla_memdup(nla[NFTA_TABLE_USERDATA], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2401

hook = kzalloc_obj(struct nft_hook, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2422

ops = kzalloc_obj(struct nf_hook_ops, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2674

blob = kvmalloc(size, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2773

basechain = kzalloc_obj(*basechain, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2805

chain = kzalloc_obj(*chain, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2818

chain->name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2826

chain->name = kstrdup(name, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2835

chain->udata = nla_memdup(nla[NFTA_CHAIN_USERDATA], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

3039

name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

3676

expr = kzalloc(expr_info.ops->size, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

4438

rule = kzalloc(sizeof(*rule) + size + usize, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

4887

set->name = kasprintf(GFP_KERNEL_ACCOUNT, name, min + n);

net/netfilter/nf_tables_api.c

5655

set = kvzalloc(alloc_size, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

5661

name = nla_strdup(nla[NFTA_SET_NAME], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

6926

expr = kzalloc(set->exprs[i]->ops->size, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

6930

err = nft_expr_clone(expr, set->exprs[i], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

6969

err = nft_expr_clone(expr, expr_array[i], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

7024

catchall = kmalloc_obj(*catchall, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

7526

timeout, expiration, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

7882

GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

8186

obj = kzalloc(sizeof(*obj) + ops->size, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

8372

obj->key.name = nla_strdup(nla[NFTA_OBJ_NAME], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

8379

obj->udata = nla_memdup(nla[NFTA_OBJ_USERDATA], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

9245

flowtable = kzalloc_obj(*flowtable, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

9255

flowtable->name = nla_strdup(nla[NFTA_FLOWTABLE_NAME], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

9794

GFP_KERNEL_ACCOUNT);

net/netfilter/nfnetlink_cthelper.c

233

nfcth = kzalloc_obj(*nfcth, GFP_KERNEL_ACCOUNT);

net/netfilter/nfnetlink_cthelper.c

237

helper = kzalloc_obj(*helper, GFP_KERNEL_ACCOUNT);

net/netfilter/nfnetlink_queue.c

139

inst = kzalloc_obj(*inst, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_chain_filter.c

353

GFP_KERNEL_ACCOUNT);

net/netfilter/nft_compat.c

564

priv->info = kmalloc(XT_ALIGN(m->matchsize), GFP_KERNEL_ACCOUNT);

net/netfilter/nft_compat.c

851

ops = kzalloc_obj(struct nft_expr_ops, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_compat.c

940

ops = kzalloc_obj(struct nft_expr_ops, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_connlimit.c

74

priv->list = kmalloc_obj(*priv->list, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_counter.c

72

cpu_stats = alloc_percpu_gfp(struct nft_counter, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_last.c

33

last = kzalloc_obj(*last, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_limit.c

113

priv->limit = kmalloc_obj(*priv->limit, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_log.c

110

priv->prefix = kmalloc(nla_len(nla) + 1, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_meta.c

966

priv->ctx = nla_strdup(tb[NFTA_SECMARK_CTX], GFP_KERNEL_ACCOUNT);

net/netfilter/nft_numgen.c

69

priv->counter = kmalloc_obj(*priv->counter, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_quota.c

99

priv->consumed = kmalloc_obj(*priv->consumed, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_pipapo.c

1223

GFP_KERNEL_ACCOUNT, cpu_to_node(i));

net/netfilter/nft_set_pipapo.c

1437

new = kmalloc_flex(*new, f, old->field_count, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_pipapo.c

1469

new_lt = kvzalloc(lt_size, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_pipapo.c

1485

GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_pipapo.c

655

new_mt = kvmalloc_objs(*new_mt, rules_alloc, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_pipapo.c

740

new_lt = kvzalloc(lt_size, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_pipapo.c

956

new_lt = kvzalloc(lt_size, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_rbtree.c

547

GFP_KERNEL_ACCOUNT);

net/netfilter/nft_set_rbtree.c

564

array = kzalloc_obj(*array, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_tunnel.c

484

GFP_KERNEL_ACCOUNT);

net/netfilter/nft_tunnel.c

490

err = dst_cache_init(&md->u.tun_info.dst_cache, GFP_KERNEL_ACCOUNT);

net/netfilter/x_tables.c

1286

info = kvmalloc(sz, GFP_KERNEL_ACCOUNT);

net/openvswitch/conntrack.c

1690

ct_limit = kmalloc_obj(*ct_limit, GFP_KERNEL_ACCOUNT);

net/openvswitch/meter.c

349

meter = kzalloc_flex(*meter, bands, n_bands, GFP_KERNEL_ACCOUNT);

net/psp/psp_sock.c

54

GFP_KERNEL_ACCOUNT);

net/unix/af_unix.c

1109

sk->sk_allocation = GFP_KERNEL_ACCOUNT;

net/unix/garbage.c

299

GFP_KERNEL_ACCOUNT);

rust/bindings/bindings_helper.h

115

const gfp_t RUST_CONST_HELPER_GFP_KERNEL_ACCOUNT = GFP_KERNEL_ACCOUNT;

samples/vfio-mdev/mtty.c

1089

migf = kzalloc(sizeof(*migf), GFP_KERNEL_ACCOUNT);

samples/vfio-mdev/mtty.c

981

migf = kzalloc(sizeof(*migf), GFP_KERNEL_ACCOUNT);

security/landlock/domain.c

98

kzalloc_flex(*details, exe_path, path_size, GFP_KERNEL_ACCOUNT);

security/landlock/object.c

28

new_object = kzalloc_obj(*new_object, GFP_KERNEL_ACCOUNT);

security/landlock/ruleset.c

127

GFP_KERNEL_ACCOUNT);

security/landlock/ruleset.c

37

GFP_KERNEL_ACCOUNT);

security/landlock/ruleset.c

570

kzalloc_obj(*new_dom->hierarchy, GFP_KERNEL_ACCOUNT);

security/landlock/tsync.c

541

GFP_KERNEL_ACCOUNT);

virt/kvm/coalesced_mmio.c

131

dev = kzalloc_obj(struct kvm_coalesced_mmio_dev, GFP_KERNEL_ACCOUNT);

virt/kvm/coalesced_mmio.c

99

page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

virt/kvm/eventfd.c

386

irqfd = kzalloc_obj(*irqfd, GFP_KERNEL_ACCOUNT);

virt/kvm/eventfd.c

434

resampler = kzalloc_obj(*resampler, GFP_KERNEL_ACCOUNT);

virt/kvm/eventfd.c

874

p = kzalloc_obj(*p, GFP_KERNEL_ACCOUNT);

virt/kvm/irqchip.c

186

new = kzalloc_flex(*new, map, nr_rt_entries, GFP_KERNEL_ACCOUNT);

virt/kvm/irqchip.c

197

e = kzalloc_obj(*e, GFP_KERNEL_ACCOUNT);

virt/kvm/irqchip.c

249

new = kzalloc_flex(*new, map, 1, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

1028

GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

1034

stat_data = kzalloc_obj(*stat_data, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

1049

stat_data = kzalloc_obj(*stat_data, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

1171

kzalloc_obj(struct kvm_io_bus, GFP_KERNEL_ACCOUNT));

virt/kvm/kvm_main.c

1425

memslot->dirty_bitmap = __vcalloc(2, dirty_bytes, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

1924

invalid_slot = kzalloc_obj(*invalid_slot, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

2097

new = kzalloc_obj(*new, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

2576

r = xa_reserve(&kvm->mem_attr_array, i, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

2587

GFP_KERNEL_ACCOUNT));

virt/kvm/kvm_main.c

366

gfp_t gfp = mc->gfp_custom ? mc->gfp_custom : GFP_KERNEL_ACCOUNT;

virt/kvm/kvm_main.c

4185

vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

4192

page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);

virt/kvm/kvm_main.c

4220

r = xa_insert(&kvm->vcpu_array, vcpu->vcpu_idx, vcpu, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

4825

dev = kzalloc_obj(*dev, GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

5995

GFP_KERNEL_ACCOUNT);

virt/kvm/kvm_main.c

6042

GFP_KERNEL_ACCOUNT);

virt/kvm/vfio.c

164

kvf = kzalloc_obj(*kvf, GFP_KERNEL_ACCOUNT);

virt/kvm/vfio.c

339

kv = kzalloc_obj(*kv, GFP_KERNEL_ACCOUNT);

Linux

arch/arm64/kvm/arm.c

arch/arm64/kvm/arm.c

arch/arm64/kvm/arm.c

arch/arm64/kvm/arm.c

arch/arm64/kvm/hyp_trace.c

arch/arm64/kvm/hypercalls.c

arch/arm64/kvm/hypercalls.c

arch/arm64/kvm/hypercalls.c

arch/arm64/kvm/mmu.c

arch/arm64/kvm/mmu.c

arch/arm64/kvm/mmu.c

arch/arm64/kvm/mmu.c

arch/arm64/kvm/nested.c

arch/arm64/kvm/nested.c

arch/arm64/kvm/nested.c

arch/arm64/kvm/nested.c

arch/arm64/kvm/pkvm.c

arch/arm64/kvm/pkvm.c

arch/arm64/kvm/pkvm.c

arch/arm64/kvm/pmu-emul.c

arch/arm64/kvm/ptdump.c

arch/arm64/kvm/reset.c

arch/arm64/kvm/sys_regs.c

arch/arm64/kvm/vgic/vgic-init.c

arch/arm64/kvm/vgic/vgic-init.c

arch/arm64/kvm/vgic/vgic-irqfd.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-its.c

arch/arm64/kvm/vgic/vgic-mmio-v3.c

arch/arm64/kvm/vgic/vgic-v4.c

arch/loongarch/include/asm/pgalloc.h

arch/loongarch/kvm/vm.c

arch/mips/include/asm/pgalloc.h

arch/powerpc/mm/book3s64/pgtable.c

arch/powerpc/platforms/pseries/papr-hvpipe.c

arch/powerpc/platforms/pseries/papr-phy-attest.c

arch/powerpc/platforms/pseries/papr-platform-dump.c

arch/powerpc/platforms/pseries/papr-rtas-common.c

arch/powerpc/platforms/pseries/papr-rtas-common.c

arch/s390/kvm/dat.c

arch/s390/kvm/dat.c

arch/s390/kvm/dat.c

arch/s390/kvm/dat.c

arch/s390/kvm/dat.h

arch/s390/kvm/gmap.c

arch/s390/kvm/guestdbg.c

arch/s390/kvm/guestdbg.c

arch/s390/kvm/guestdbg.c

arch/s390/kvm/guestdbg.c

arch/s390/kvm/intercept.c

arch/s390/kvm/interrupt.c

arch/s390/kvm/interrupt.c

arch/s390/kvm/interrupt.c

arch/s390/kvm/interrupt.c

arch/s390/kvm/interrupt.c

arch/s390/kvm/interrupt.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/kvm-s390.c

arch/s390/kvm/priv.c

arch/s390/kvm/priv.c

arch/s390/kvm/pv.c

arch/s390/kvm/pv.c

arch/s390/kvm/pv.c

arch/s390/kvm/vsie.c

arch/s390/kvm/vsie.c