arch/alpha/kernel/srm_env.c

69

page = (char *)__get_free_page(GFP_USER);

arch/alpha/kernel/srm_env.c

94

char *buf = (char *) __get_free_page(GFP_USER);

arch/parisc/kernel/unwind.c

160

table = kmalloc_obj(struct unwind_table, GFP_USER);

arch/powerpc/perf/hv-24x7.c

1010

void *page = kmem_cache_alloc(hv_page_cache, GFP_USER);

arch/powerpc/perf/hv-24x7.c

1085

void *page = kmem_cache_alloc(hv_page_cache, GFP_USER); \

block/bdev.c

470

mapping_set_gfp_mask(&inode->i_data, GFP_USER);

drivers/accel/habanalabs/common/command_buffer.c

143

GFP_USER | __GFP_ZERO);

drivers/dax/super.c

541

mapping_set_gfp_mask(&inode->i_data, GFP_USER);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/mem.c

155

gfp_t gfp = GFP_USER | __GFP_ZERO;

drivers/gpu/drm/omapdrm/omap_gem.c

1358

mapping_set_gfp_mask(mapping, GFP_USER | __GFP_DMA32);

drivers/gpu/drm/ttm/ttm_pool.c

784

gfp_t gfp_flags = GFP_USER;

drivers/gpu/drm/xe/xe_devcoredump.c

307

GFP_USER);

drivers/gpu/drm/xe/xe_devcoredump.c

315

ss->read.buffer = kvmalloc(ss->read.size, GFP_USER);

drivers/gpu/drm/xe/xe_vm.c

4567

snap->snap[i].data = kvmalloc(snap->snap[i].len, GFP_USER);

drivers/infiniband/hw/qedr/verbs.c

743

q->db_rec_data = (void *)get_zeroed_page(GFP_USER);

drivers/message/fusion/mptctl.c

1032

buflist = kzalloc(i, GFP_USER);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

1432

p = s = kzalloc(count + 1, GFP_USER);

drivers/net/ethernet/netronome/nfp/bpf/offload.c

383

nfp_map = kzalloc(sizeof(*nfp_map) + use_map_size, GFP_USER);

drivers/net/ethernet/sfc/tc.c

129

ped = kzalloc_obj(*ped, GFP_USER);

drivers/net/ethernet/sfc/tc.c

1508

rule = kzalloc_obj(*rule, GFP_USER);

drivers/net/ethernet/sfc/tc.c

1621

rule = kzalloc_obj(*rule, GFP_USER);

drivers/net/ethernet/sfc/tc.c

1797

rule = kzalloc_obj(*rule, GFP_USER);

drivers/net/ethernet/sfc/tc.c

1818

act = kzalloc_obj(*act, GFP_USER);

drivers/net/ethernet/sfc/tc.c

1904

act = kzalloc_obj(*act, GFP_USER);

drivers/net/ethernet/sfc/tc.c

2019

rule = kzalloc_obj(*rule, GFP_USER);

drivers/net/ethernet/sfc/tc.c

2180

rule = kzalloc_obj(*rule, GFP_USER);

drivers/net/ethernet/sfc/tc.c

2202

act = kzalloc_obj(*act, GFP_USER);

drivers/net/ethernet/sfc/tc.c

2343

act = kzalloc_obj(*act, GFP_USER);

drivers/net/ethernet/sfc/tc.c

2383

act = kzalloc_obj(*act, GFP_USER);

drivers/net/ethernet/sfc/tc.c

574

encap = kzalloc_obj(*encap, GFP_USER);

drivers/net/ethernet/sfc/tc.c

697

rid = kzalloc_obj(*rid, GFP_USER);

drivers/net/ethernet/sfc/tc.c

719

rc = ida_alloc_range(&efx->tc->recirc_ida, 1, U8_MAX, GFP_USER);

drivers/net/ethernet/sfc/tc_conntrack.c

368

conn = kzalloc_obj(*conn, GFP_USER);

drivers/net/ethernet/sfc/tc_conntrack.c

565

ct_zone = kzalloc_obj(*ct_zone, GFP_USER);

drivers/net/ethernet/sfc/tc_counters.c

138

cnt = kzalloc_obj(*cnt, GFP_USER);

drivers/net/ethernet/sfc/tc_counters.c

229

ctr = kzalloc_obj(*ctr, GFP_USER);

drivers/scsi/scsi_ioctl.c

549

buffer = kzalloc(bytes, GFP_NOIO | GFP_USER | __GFP_NOWARN);

drivers/staging/media/av7110/av7110_ca.c

141

u8 *page = (u8 *)__get_free_page(GFP_USER);

drivers/tty/vt/vt.c

1211

newscreen = kzalloc(new_screen_size, GFP_USER);

drivers/usb/core/devio.c

255

size, GFP_USER | __GFP_NOWARN, &dma_handle);

drivers/xen/balloon.c

595

st = decrease_reservation(nr_pages, GFP_USER);

fs/aio.c

579

GFP_USER | __GFP_ZERO);

fs/ecryptfs/crypto.c

1285

page_virt = kmem_cache_alloc(ecryptfs_header_cache, GFP_USER);

fs/ecryptfs/crypto.c

350

enc_extent_page = alloc_page(GFP_USER);

fs/inode.c

2828

mapping_set_gfp_mask(inode->i_mapping, GFP_USER);

fs/isofs/namei.c

154

page = alloc_page(GFP_USER);

fs/jffs2/fs.c

62

mdata = kmalloc(f->metadata->size, GFP_USER);

fs/nfs/dir.c

2651

folio = folio_alloc(GFP_USER, 0);

fs/nfs/namespace.c

298

buffer = kmalloc(4096, GFP_USER);

fs/splice.c

342

npages = alloc_pages_bulk(GFP_USER, npages, pages);

include/linux/bpf.h

2828

gfp_t flags = GFP_USER | __GFP_NOWARN;

include/linux/bpfptr.h

70

void *p = kvmalloc_node_align_noprof(len, 1, GFP_USER | __GFP_NOWARN, NUMA_NO_NODE);

include/linux/gfp_types.h

385

#define GFP_HIGHUSER (GFP_USER | __GFP_HIGHMEM)

include/linux/sockptr.h

122

void *p = kmalloc_track_caller_noprof(len, GFP_USER | __GFP_NOWARN);

include/trace/events/mmflags.h

93

gfpflag_string(GFP_USER), \

kernel/bpf/arraymap.c

40

GFP_USER | __GFP_NOWARN);

kernel/bpf/arraymap.c

707

value_buf = kmalloc(buf_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/bpf_iter.c

551

link = kzalloc_obj(*link, GFP_USER | __GFP_NOWARN);

kernel/bpf/bpf_local_storage.c

792

sizeof(*smap->buckets), GFP_USER | __GFP_NOWARN);

kernel/bpf/bpf_struct_ops.c

1416

link = kzalloc_obj(*link, GFP_USER);

kernel/bpf/bpf_struct_ops.c

814

link = kzalloc_obj(*link, GFP_USER);

kernel/bpf/bpf_struct_ops.c

828

ksym = kzalloc_obj(*ksym, GFP_USER);

kernel/bpf/bpf_struct_ops.c

957

value = kmalloc(map->value_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/cgroup.c

1529

link = kzalloc_obj(*link, GFP_USER);

kernel/bpf/cgroup.c

2010

ctx->optval = kzalloc(max_optlen, GFP_USER);

kernel/bpf/cgroup.c

2103

void *p = kmalloc(ctx.optlen, GFP_USER);

kernel/bpf/core.c

1565

clone = bpf_prog_clone_create(prog, GFP_USER);

kernel/bpf/core.c

2853

ids = kcalloc(cnt, sizeof(u32), GFP_USER | __GFP_NOWARN);

kernel/bpf/core.c

485

GFP_USER);

kernel/bpf/fixups.c

1093

func[i] = bpf_prog_alloc_no_stats(bpf_prog_size(len), GFP_USER);

kernel/bpf/hashtab.c

1837

keys = kvmalloc_array(key_size, bucket_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

1838

values = kvmalloc_array(value_size, bucket_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

2231

value_buf = kmalloc(buf_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

3281

keys = kvmalloc_array(max_count, key_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

3282

values = kvmalloc_array(max_count, value_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

3285

GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

3286

cursor = kmalloc(key_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

340

GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

395

GFP_USER | __GFP_NOWARN);

kernel/bpf/local_storage.c

506

const gfp_t gfp = __GFP_ZERO | GFP_USER;

kernel/bpf/map_in_map.c

33

inner_map_meta = kzalloc(inner_map_meta_size, GFP_USER);

kernel/bpf/net_namespace.c

497

net_link = kzalloc_obj(*net_link, GFP_USER);

kernel/bpf/offload.c

185

offload = kzalloc_obj(*offload, GFP_USER);

kernel/bpf/syscall.c

1812

value = kvmalloc(value_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

1977

next_key = kvmalloc(map->key_size, GFP_USER);

kernel/bpf/syscall.c

2030

key = kvmalloc(map->key_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

2086

key = kvmalloc(map->key_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

2090

value = kvmalloc(value_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

2145

buf_prevkey = kvmalloc(map->key_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

2149

buf = kvmalloc(map->key_size + value_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

2261

value = kvmalloc(value_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/syscall.c

3097

prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER);

kernel/bpf/syscall.c

3756

link = kzalloc_obj(*link, GFP_USER);

kernel/bpf/syscall.c

399

area = kmalloc_node(size, gfp | GFP_USER | __GFP_NORETRY,

kernel/bpf/syscall.c

4315

link = kzalloc_obj(*link, GFP_USER);

kernel/bpf/syscall.c

4398

link = kzalloc_obj(*link, GFP_USER);

kernel/bpf/syscall.c

5073

GFP_USER);

kernel/bpf/tcx.c

324

tcx = kzalloc_obj(*tcx, GFP_USER);

kernel/bpf/token.c

175

token = kzalloc_obj(*token, GFP_USER);

kernel/bpf/trampoline.c

1030

shim_link = kzalloc_obj(*shim_link, GFP_USER);

kernel/cgroup/cgroup.c

2445

char *agent = kstrdup("/sbin/cpuset_release_agent", GFP_USER);

kernel/sysctl-test.c

126

GFP_USER);

kernel/sysctl-test.c

160

GFP_USER);

kernel/sysctl-test.c

196

char *buffer = kunit_kzalloc(test, len, GFP_USER);

kernel/sysctl-test.c

227

char *buffer = kunit_kzalloc(test, len, GFP_USER);

kernel/sysctl-test.c

257

char *buffer = kunit_kzalloc(test, len, GFP_USER);

kernel/sysctl-test.c

287

char *buffer = kunit_kzalloc(test, len, GFP_USER);

kernel/sysctl-test.c

318

char *buffer = kunit_kzalloc(test, max_len, GFP_USER);

kernel/sysctl-test.c

356

char *buffer = kunit_kzalloc(test, max_len, GFP_USER);

kernel/sysctl-test.c

37

GFP_USER);

kernel/sysctl-test.c

83

GFP_USER);

kernel/trace/bpf_trace.c

2056

ids = kcalloc(ids_len, sizeof(u32), GFP_USER | __GFP_NOWARN);

kernel/trace/ring_buffer.c

7481

page = alloc_page(GFP_USER | __GFP_ZERO);

lib/fonts/fonts.c

93

font_data = kmalloc(alloc_size, GFP_USER);

mm/gup.c

2362

.gfp_mask = GFP_USER | __GFP_NOWARN,

mm/khugepaged.c

3077

if (zone_idx(zone) > gfp_zone(GFP_USER))

mm/memory-failure.c

2791

.gfp_mask = GFP_USER | __GFP_MOVABLE | __GFP_RETRY_MAYFAIL,

mm/migrate_device.c

1475

dfolio = folio_alloc(GFP_USER | __GFP_NOWARN, 0);

mm/mincore.c

315

tmp = (void *) __get_free_page(GFP_USER);

mm/page_alloc.c

5590

return nr_free_zone_pages(gfp_zone(GFP_USER));

mm/util.c

221

p = kmem_buckets_alloc_track_caller(user_buckets, len, GFP_USER | __GFP_NOWARN);

mm/util.c

247

p = kmem_buckets_valloc(user_buckets, len, GFP_USER);

mm/util.c

303

p = kmem_buckets_alloc_track_caller(user_buckets, len + 1, GFP_USER | __GFP_NOWARN);

mm/vmalloc.c

3956

GFP_USER | __GFP_NOLOCKDEP | __GFP_SKIP_KASAN)

net/bpf/bpf_dummy_struct_ops.c

167

link = kzalloc_obj(*link, GFP_USER);

net/bpf/test_run.c

1106

sk = sk_alloc(net, AF_UNSPEC, GFP_USER, &bpf_dummy_proto, 1);

net/bpf/test_run.c

1232

if (pskb_expand_head(skb, nhead, 0, GFP_USER)) {

net/bpf/test_run.c

673

data = kzalloc(size + headroom + tailroom, GFP_USER);

net/bpf/test_run.c

865

data = kzalloc(max_size, GFP_USER);

net/bridge/br_ioctl.c

69

buf = kmalloc(size, GFP_USER);

net/core/dev.c

10690

link = kzalloc_obj(*link, GFP_USER);

net/core/sock_map.c

1894

sockmap_link = kzalloc_obj(*sockmap_link, GFP_USER);

net/ethtool/common.c

775

rxfh.indir = kzalloc_objs(rxfh.indir[0], dev_size, GFP_USER);

net/ethtool/ioctl.c

1270

GFP_USER);

net/ethtool/ioctl.c

1344

rxfh.indir = kcalloc(rxfh.indir_size, sizeof(rxfh.indir[0]), GFP_USER);

net/ethtool/ioctl.c

1390

sizeof(rxfh_dev.indir[0]), GFP_USER);

net/ethtool/ioctl.c

1478

rss_config = kzalloc(total_size, GFP_USER);

net/ethtool/ioctl.c

1609

rss_config = kzalloc(indir_bytes + dev_key_size, GFP_USER);

net/ethtool/ioctl.c

2009

data = kzalloc(PAGE_SIZE, GFP_USER);

net/ethtool/ioctl.c

2078

data = kzalloc(PAGE_SIZE, GFP_USER);

net/ethtool/ioctl.c

2369

data = kcalloc(test_len, sizeof(u64), GFP_USER);

net/ethtool/ioctl.c

2976

data = kzalloc(tuna.len, GFP_USER);

net/ethtool/ioctl.c

3175

data = kzalloc(tuna.len, GFP_USER);

net/ethtool/ioctl.c

817

info_buf = kcalloc(n_bits, sizeof(u32), GFP_USER);

net/hsr/prp_dup_discard_test.c

21

sizeof(struct prp_test_data), GFP_USER);

net/ipv4/sysctl_net_ipv4.c

245

tbl.data = kmalloc(tbl.maxlen, GFP_USER);

net/ipv4/sysctl_net_ipv4.c

261

tbl.data = kmalloc(tbl.maxlen, GFP_USER);

net/ipv4/sysctl_net_ipv4.c

384

tbl.data = kmalloc(tbl.maxlen, GFP_USER);

net/ipv4/tcp_cong.c

375

saved_clone = clone = kstrdup(val, GFP_USER);

net/ipv4/tcp_ipv4.c

3148

GFP_USER);

net/ipv4/tcp_ipv4.c

3587

err = bpf_iter_tcp_realloc_batch(iter, INIT_BATCH_SZ, GFP_USER);

net/ipv4/udp.c

3407

GFP_USER);

net/ipv4/udp.c

3833

ret = bpf_iter_udp_realloc_batch(iter, INIT_BATCH_SZ, GFP_USER);

net/mptcp/ctrl.c

164

tbl.data = kmalloc(tbl.maxlen, GFP_USER);

net/mptcp/ctrl.c

270

tbl.data = kmalloc(tbl.maxlen, GFP_USER);

net/mptcp/token_test.c

11

GFP_USER);

net/mptcp/token_test.c

37

GFP_USER);

net/mptcp/token_test.c

47

GFP_USER);

net/mptcp/token_test.c

57

msk = kunit_kzalloc(test, sizeof(struct mptcp_sock), GFP_USER);

net/netfilter/nf_bpf_link.c

224

link = kzalloc_obj(*link, GFP_USER);

net/nfc/llcp_commands.c

679

msg_data = kmalloc(len, GFP_USER | __GFP_NOWARN);

net/nfc/llcp_commands.c

745

msg_data = kmalloc(len, GFP_USER | __GFP_NOWARN);

net/sctp/socket.c

2255

GFP_USER | __GFP_NOWARN);

net/sctp/socket.c

4287

GFP_USER | __GFP_NOWARN);

net/sctp/socket.c

6350

addrs = kmalloc(space_left, GFP_USER | __GFP_NOWARN);

net/sctp/socket.c

7212

ids = kmalloc(len, GFP_USER | __GFP_NOWARN);

net/unix/af_unix.c

3664

GFP_USER | __GFP_NOWARN);

net/xfrm/xfrm_compat.c

654

data64 = kmalloc_track_caller(optlen + 4, GFP_USER | __GFP_NOWARN);

security/apparmor/policy_unpack_test.c

118

puf = kunit_kmalloc(test, sizeof(*puf), GFP_USER);

security/apparmor/policy_unpack_test.c

62

buf = kunit_kzalloc(test, buf_size, GFP_USER);

security/apparmor/policy_unpack_test.c

65

e = kunit_kmalloc(test, sizeof(*e), GFP_USER);

security/selinux/netlink.c

77

skb = nlmsg_new(len, GFP_USER);

security/selinux/netlink.c

88

netlink_broadcast(selnl, skb, 0, SELNLGRP_AVC, GFP_USER);

tools/include/linux/gfp_types.h

385

#define GFP_HIGHUSER (GFP_USER | __GFP_HIGHMEM)