drivers/hv/mshv_regions.c

258

u32 map_flags,

drivers/hv/mshv_regions.c

261

return mshv_region_process_range(region, map_flags,

drivers/hv/mshv_regions.c

268

u32 map_flags = region->hv_map_flags;

drivers/hv/mshv_regions.c

270

return mshv_region_remap_pages(region, map_flags,

drivers/hv/mshv_root_hv_call.c

224

input_page->map_flags = flags;

drivers/hv/mshv_trace.h

394

TP_PROTO(u64 partition_id, u64 start_uaddr, u64 start_gfn, u64 nr_pages, u32 map_flags,

drivers/hv/mshv_trace.h

396

TP_ARGS(partition_id, start_uaddr, start_gfn, nr_pages, map_flags, ret),

drivers/hv/mshv_trace.h

402

__field(u32, map_flags)

drivers/hv/mshv_trace.h

410

__entry->map_flags = map_flags;

drivers/hv/mshv_trace.h

418

__entry->map_flags,

drivers/infiniband/core/iwpm_util.c

109

u8 nl_client, u32 map_flags)

drivers/infiniband/core/iwpm_util.c

125

map_info->map_flags = map_flags;

drivers/infiniband/core/iwpm_util.c

687

&map_info->map_flags,

drivers/infiniband/core/iwpm_util.h

80

u32 map_flags;

drivers/iommu/iommufd/ioas.c

186

static int conv_iommu_prot(u32 map_flags)

drivers/iommu/iommufd/ioas.c

197

if (map_flags & IOMMU_IOAS_MAP_WRITEABLE)

drivers/iommu/iommufd/ioas.c

199

if (map_flags & IOMMU_IOAS_MAP_READABLE)

drivers/iommu/virtio-iommu.c

1186

viommu->map_flags = VIRTIO_IOMMU_MAP_F_READ | VIRTIO_IOMMU_MAP_F_WRITE;

drivers/iommu/virtio-iommu.c

1217

viommu->map_flags |= VIRTIO_IOMMU_MAP_F_MMIO;

drivers/iommu/virtio-iommu.c

53

u32 map_flags;

drivers/iommu/virtio-iommu.c

67

u32 map_flags;

drivers/iommu/virtio-iommu.c

692

vdomain->map_flags = viommu->map_flags;

drivers/iommu/virtio-iommu.c

857

if (flags & ~vdomain->map_flags)

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

101

req->map_flags = 0;

drivers/net/ethernet/netronome/nfp/bpf/fw.h

84

__be32 map_flags; /* reserved */

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

339

if (offmap->map.map_flags ||

drivers/net/netdevsim/bpf.c

495

if (offmap->map.map_flags)

drivers/usb/usbip/usbip_common.c

409

unsigned int map_flags = 0;

drivers/usb/usbip/usbip_common.c

414

map_flags |= flag_map[loop].usbip_flag;

drivers/usb/usbip/usbip_common.c

417

return map_flags;

drivers/usb/usbip/usbip_common.c

422

unsigned int map_flags = 0;

drivers/usb/usbip/usbip_common.c

427

map_flags |= flag_map[loop].urb_flag;

drivers/usb/usbip/usbip_common.c

430

return map_flags;

fs/ceph/file.c

2406

u32 map_flags;

fs/ceph/file.c

2455

map_flags = osdc->osdmap->flags;

fs/ceph/file.c

2458

if ((map_flags & CEPH_OSDMAP_FULL) ||

fs/ceph/file.c

2559

if ((map_flags & CEPH_OSDMAP_NEARFULL) ||

fs/ext4/inode.c

1050

ext4_lblk_t block, int map_flags)

fs/ext4/inode.c

1055

bh = ext4_getblk(handle, inode, block, map_flags);

fs/ext4/inode.c

978

ext4_lblk_t block, int map_flags)

fs/ext4/inode.c

982

int create = map_flags & EXT4_GET_BLOCKS_CREATE;

fs/ext4/inode.c

983

bool nowait = map_flags & EXT4_GET_BLOCKS_CACHED_NOWAIT;

fs/ext4/inode.c

992

err = ext4_map_blocks(handle, inode, &map, map_flags);

fs/xfs/xfs_healthmon.c

710

return map_flags(shutdown_map, in);

include/hyperv/hvhdk_mini.h

299

u32 map_flags;

include/linux/bpf.h

2412

u32 access_flags = map->map_flags & (BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG);

include/linux/bpf.h

3035

void *key, void *value, u64 map_flags);

include/linux/bpf.h

3038

void *key, void *value, u64 map_flags);

include/linux/bpf.h

3090

return (attr->map_flags & BPF_F_NUMA_NODE) ?

include/linux/bpf.h

313

u32 map_flags;

include/linux/bpf.h

3791

void *value, u64 map_flags);

include/linux/bpf.h

3806

u64 map_flags)

include/linux/bpf_local_storage.h

203

void *value, u64 map_flags, bool swap_uptrs);

include/rdma/iw_portmap.h

60

u32 map_flags);

include/uapi/linux/bpf.h

1533

__u32 map_flags; /* BPF_MAP_CREATE related

include/uapi/linux/bpf.h

6738

__u32 map_flags;

kernel/bpf/arena.c

275

!(attr->map_flags & BPF_F_MMAPABLE) ||

kernel/bpf/arena.c

277

(attr->map_flags & ~(BPF_F_SEGV_ON_FAULT | BPF_F_MMAPABLE | BPF_F_NO_USER_CONV)))

kernel/bpf/arena.c

501

if (arena->map.map_flags & BPF_F_SEGV_ON_FAULT)

kernel/bpf/arraymap.c

123

if (attr->map_flags & BPF_F_MMAPABLE) {

kernel/bpf/arraymap.c

1303

if (map->map_flags & BPF_F_PRESERVE_ELEMS)

kernel/bpf/arraymap.c

1317

if (map->map_flags & BPF_F_PRESERVE_ELEMS)

kernel/bpf/arraymap.c

132

if (attr->map_flags & BPF_F_MMAPABLE) {

kernel/bpf/arraymap.c

227

if (map->map_flags & BPF_F_INNER_MAP)

kernel/bpf/arraymap.c

271

if (map->map_flags & BPF_F_INNER_MAP)

kernel/bpf/arraymap.c

308

int bpf_percpu_array_copy(struct bpf_map *map, void *key, void *value, u64 map_flags)

kernel/bpf/arraymap.c

326

if (map_flags & BPF_F_CPU) {

kernel/bpf/arraymap.c

327

cpu = map_flags >> 32;

kernel/bpf/arraymap.c

362

u64 map_flags)

kernel/bpf/arraymap.c

368

if (unlikely((map_flags & ~BPF_F_LOCK) > BPF_EXIST))

kernel/bpf/arraymap.c

376

if (unlikely(map_flags & BPF_NOEXIST))

kernel/bpf/arraymap.c

380

if (unlikely((map_flags & BPF_F_LOCK) &&

kernel/bpf/arraymap.c

391

if (map_flags & BPF_F_LOCK)

kernel/bpf/arraymap.c

401

u64 map_flags)

kernel/bpf/arraymap.c

410

if (unlikely((map_flags & BPF_F_LOCK) || (u32)map_flags > BPF_F_ALL_CPUS))

kernel/bpf/arraymap.c

418

if (unlikely(map_flags == BPF_NOEXIST))

kernel/bpf/arraymap.c

431

if (map_flags & BPF_F_CPU) {

kernel/bpf/arraymap.c

432

cpu = map_flags >> 32;

kernel/bpf/arraymap.c

440

val = (map_flags & BPF_F_ALL_CPUS) ? value : value + size * cpu;

kernel/bpf/arraymap.c

499

if (array->map.map_flags & BPF_F_MMAPABLE)

kernel/bpf/arraymap.c

581

if (!(map->map_flags & BPF_F_MMAPABLE))

kernel/bpf/arraymap.c

597

return meta0->map_flags & BPF_F_INNER_MAP ? true :

kernel/bpf/arraymap.c

61

attr->map_flags & ~ARRAY_CREATE_FLAG_MASK ||

kernel/bpf/arraymap.c

62

!bpf_map_flags_access_ok(attr->map_flags) ||

kernel/bpf/arraymap.c

67

attr->map_flags & (BPF_F_MMAPABLE | BPF_F_INNER_MAP))

kernel/bpf/arraymap.c

71

attr->map_flags & BPF_F_PRESERVE_ELEMS)

kernel/bpf/arraymap.c

790

if (map->map_flags & BPF_F_MMAPABLE) {

kernel/bpf/arraymap.c

855

if (attr->map_flags & (BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG))

kernel/bpf/arraymap.c

899

void *key, void *value, u64 map_flags)

kernel/bpf/arraymap.c

905

if (map_flags != BPF_ANY)

kernel/bpf/bloom_filter.c

103

attr->map_flags & ~BLOOM_CREATE_FLAG_MASK ||

kernel/bpf/bloom_filter.c

104

!bpf_map_flags_access_ok(attr->map_flags) ||

kernel/bpf/bloom_filter.c

156

if (!(attr->map_flags & BPF_F_ZERO_SEED))

kernel/bpf/bpf_cgrp_storage.c

67

void *value, u64 map_flags)

kernel/bpf/bpf_cgrp_storage.c

79

value, map_flags, false);

kernel/bpf/bpf_inode_storage.c

101

value, map_flags, false);

kernel/bpf/bpf_inode_storage.c

89

void *value, u64 map_flags)

kernel/bpf/bpf_insn_array.c

31

attr->value_size != value_size || attr->map_flags != 0)

kernel/bpf/bpf_insn_array.c

59

insn_array->map.map_flags |= BPF_F_RDONLY_PROG;

kernel/bpf/bpf_insn_array.c

75

static long insn_array_update_elem(struct bpf_map *map, void *key, void *value, u64 map_flags)

kernel/bpf/bpf_insn_array.c

84

if (unlikely(map_flags & BPF_NOEXIST))

kernel/bpf/bpf_local_storage.c

463

u64 map_flags)

kernel/bpf/bpf_local_storage.c

465

if (old_sdata && (map_flags & ~BPF_F_LOCK) == BPF_NOEXIST)

kernel/bpf/bpf_local_storage.c

469

if (!old_sdata && (map_flags & ~BPF_F_LOCK) == BPF_EXIST)

kernel/bpf/bpf_local_storage.c

548

void *value, u64 map_flags, bool swap_uptrs)

kernel/bpf/bpf_local_storage.c

559

if (unlikely((map_flags & ~BPF_F_LOCK) > BPF_EXIST) ||

kernel/bpf/bpf_local_storage.c

561

unlikely((map_flags & BPF_F_LOCK) &&

kernel/bpf/bpf_local_storage.c

569

err = check_flags(NULL, map_flags);

kernel/bpf/bpf_local_storage.c

587

if ((map_flags & BPF_F_LOCK) && !(map_flags & BPF_NOEXIST)) {

kernel/bpf/bpf_local_storage.c

594

err = check_flags(old_sdata, map_flags);

kernel/bpf/bpf_local_storage.c

627

err = check_flags(old_sdata, map_flags);

kernel/bpf/bpf_local_storage.c

631

if (old_sdata && (map_flags & BPF_F_LOCK)) {

kernel/bpf/bpf_local_storage.c

704

if (attr->map_flags & ~BPF_LOCAL_STORAGE_CREATE_FLAG_MASK ||

kernel/bpf/bpf_local_storage.c

705

!(attr->map_flags & BPF_F_NO_PREALLOC) ||

kernel/bpf/bpf_struct_ops.c

1025

(attr->map_flags & ~(BPF_F_LINK | BPF_F_VTYPE_BTF_OBJ_FD)) ||

kernel/bpf/bpf_struct_ops.c

1055

if (attr->map_flags & BPF_F_VTYPE_BTF_OBJ_FD) {

kernel/bpf/bpf_struct_ops.c

1249

map->map_flags & BPF_F_LINK &&

kernel/bpf/bpf_struct_ops.c

874

if (st_map->map.map_flags & BPF_F_LINK) {

kernel/bpf/bpf_struct_ops.c

928

if (st_map->map.map_flags & BPF_F_LINK)

kernel/bpf/bpf_task_storage.c

101

if ((map_flags & BPF_F_LOCK) && btf_record_has_field(map->record, BPF_UPTR))

kernel/bpf/bpf_task_storage.c

120

task, (struct bpf_local_storage_map *)map, value, map_flags,

kernel/bpf/bpf_task_storage.c

93

void *value, u64 map_flags)

kernel/bpf/cpumap.c

582

u64 map_flags)

kernel/bpf/cpumap.c

592

if (unlikely(map_flags > BPF_EXIST))

kernel/bpf/cpumap.c

596

if (unlikely(map_flags == BPF_NOEXIST))

kernel/bpf/cpumap.c

94

attr->map_flags & ~BPF_F_NUMA_NODE)

kernel/bpf/devmap.c

1011

if (unlikely(map_flags > BPF_EXIST || !val.ifindex))

kernel/bpf/devmap.c

1017

if (old_dev && (map_flags & BPF_NOEXIST))

kernel/bpf/devmap.c

1052

u64 map_flags)

kernel/bpf/devmap.c

1055

map, key, value, map_flags);

kernel/bpf/devmap.c

122

attr->map_flags & ~DEV_CREATE_FLAG_MASK)

kernel/bpf/devmap.c

141

attr->map_flags |= BPF_F_RDONLY_PROG;

kernel/bpf/devmap.c

950

void *key, void *value, u64 map_flags)

kernel/bpf/devmap.c

957

if (unlikely(map_flags > BPF_EXIST))

kernel/bpf/devmap.c

961

if (unlikely(map_flags == BPF_NOEXIST))

kernel/bpf/devmap.c

992

u64 map_flags)

kernel/bpf/devmap.c

995

map, key, value, map_flags);

kernel/bpf/devmap.c

999

void *key, void *value, u64 map_flags)

kernel/bpf/fixups.c

1519

(((struct bpf_map *)env->prog->aux->arena)->map_flags & BPF_F_NO_USER_CONV)) {

kernel/bpf/hashtab.c

1017

void *value, bool onallcpus, u64 map_flags)

kernel/bpf/hashtab.c

1031

if (map_flags & BPF_F_CPU) {

kernel/bpf/hashtab.c

1032

cpu = map_flags >> 32;

kernel/bpf/hashtab.c

1041

val = (map_flags & BPF_F_ALL_CPUS) ? value : value + size * cpu;

kernel/bpf/hashtab.c

1049

void *value, bool onallcpus, u64 map_flags)

kernel/bpf/hashtab.c

1067

pcpu_copy_value(htab, pptr, value, onallcpus, map_flags);

kernel/bpf/hashtab.c

1079

struct htab_elem *old_elem, u64 map_flags)

kernel/bpf/hashtab.c

1137

pcpu_init_value(htab, pptr, value, onallcpus, map_flags);

kernel/bpf/hashtab.c

1144

} else if (map_flags & BPF_F_LOCK) {

kernel/bpf/hashtab.c

1160

u64 map_flags)

kernel/bpf/hashtab.c

1162

if (l_old && (map_flags & ~BPF_F_LOCK) == BPF_NOEXIST)

kernel/bpf/hashtab.c

1166

if (!l_old && (map_flags & ~BPF_F_LOCK) == BPF_EXIST)

kernel/bpf/hashtab.c

1175

u64 map_flags)

kernel/bpf/hashtab.c

1185

if (unlikely((map_flags & ~BPF_F_LOCK) > BPF_EXIST))

kernel/bpf/hashtab.c

1198

if (unlikely(map_flags & BPF_F_LOCK)) {

kernel/bpf/hashtab.c

1204

ret = check_flags(htab, l_old, map_flags);

kernel/bpf/hashtab.c

1226

ret = check_flags(htab, l_old, map_flags);

kernel/bpf/hashtab.c

1230

if (unlikely(l_old && (map_flags & BPF_F_LOCK))) {

kernel/bpf/hashtab.c

1245

l_old, map_flags);

kernel/bpf/hashtab.c

1282

u64 map_flags)

kernel/bpf/hashtab.c

1292

if (unlikely(map_flags > BPF_EXIST))

kernel/bpf/hashtab.c

1321

ret = check_flags(htab, l_old, map_flags);

kernel/bpf/hashtab.c

1347

static int htab_map_check_update_flags(bool onallcpus, u64 map_flags)

kernel/bpf/hashtab.c

1349

if (unlikely(!onallcpus && map_flags > BPF_EXIST))

kernel/bpf/hashtab.c

1351

if (unlikely(onallcpus && ((map_flags & BPF_F_LOCK) || (u32)map_flags > BPF_F_ALL_CPUS)))

kernel/bpf/hashtab.c

1357

void *value, u64 map_flags,

kernel/bpf/hashtab.c

136

return !(htab->map.map_flags & BPF_F_NO_PREALLOC);

kernel/bpf/hashtab.c

1369

ret = htab_map_check_update_flags(onallcpus, map_flags);

kernel/bpf/hashtab.c

1388

ret = check_flags(htab, l_old, map_flags);

kernel/bpf/hashtab.c

1396

value, onallcpus, map_flags);

kernel/bpf/hashtab.c

1405

hash, percpu, onallcpus, NULL, map_flags);

kernel/bpf/hashtab.c

1420

void *value, u64 map_flags,

kernel/bpf/hashtab.c

1431

ret = htab_map_check_update_flags(onallcpus, map_flags);

kernel/bpf/hashtab.c

1449

if (map_flags != BPF_EXIST) {

kernel/bpf/hashtab.c

1461

ret = check_flags(htab, l_old, map_flags);

kernel/bpf/hashtab.c

1470

value, onallcpus, map_flags);

kernel/bpf/hashtab.c

1473

value, onallcpus, map_flags);

kernel/bpf/hashtab.c

1489

void *value, u64 map_flags)

kernel/bpf/hashtab.c

1491

return htab_map_update_elem_in_place(map, key, value, map_flags, true, false);

kernel/bpf/hashtab.c

1495

void *value, u64 map_flags)

kernel/bpf/hashtab.c

1497

return __htab_lru_percpu_map_update_elem(map, key, value, map_flags,

kernel/bpf/hashtab.c

1785

u64 elem_map_flags, map_flags, allowed_flags;

kernel/bpf/hashtab.c

1804

map_flags = attr->batch.flags;

kernel/bpf/hashtab.c

1805

if (map_flags)

kernel/bpf/hashtab.c

2476

int bpf_percpu_hash_copy(struct bpf_map *map, void *key, void *value, u64 map_flags)

kernel/bpf/hashtab.c

2498

if (map_flags & BPF_F_CPU) {

kernel/bpf/hashtab.c

2499

cpu = map_flags >> 32;

kernel/bpf/hashtab.c

2515

u64 map_flags)

kernel/bpf/hashtab.c

2523

map_flags, true);

kernel/bpf/hashtab.c

2525

ret = htab_map_update_elem_in_place(map, key, value, map_flags,

kernel/bpf/hashtab.c

2654

void *key, void *value, u64 map_flags)

kernel/bpf/hashtab.c

2668

ret = htab_map_update_elem_in_place(map, key, &ptr, map_flags, false, false);

kernel/bpf/hashtab.c

2847

if (!(attr->map_flags & BPF_F_NO_PREALLOC))

kernel/bpf/hashtab.c

2850

if (attr->map_flags & BPF_F_ZERO_SEED)

kernel/bpf/hashtab.c

3008

u64 map_flags)

kernel/bpf/hashtab.c

3013

if (map_flags & BPF_NOEXIST)

kernel/bpf/hashtab.c

3016

if (map_flags & BPF_F_LOCK)

kernel/bpf/hashtab.c

3034

static long rhtab_map_update_elem(struct bpf_map *map, void *key, void *value, u64 map_flags)

kernel/bpf/hashtab.c

3039

if (unlikely((map_flags & ~BPF_F_LOCK) > BPF_EXIST))

kernel/bpf/hashtab.c

3042

if ((map_flags & BPF_F_LOCK) && !btf_record_has_field(map->record, BPF_SPIN_LOCK))

kernel/bpf/hashtab.c

3048

return rhtab_map_update_existing(map, elem, value, map_flags);

kernel/bpf/hashtab.c

3050

if (map_flags & BPF_EXIST)

kernel/bpf/hashtab.c

3088

return rhtab_map_update_existing(map, tmp, value, map_flags);

kernel/bpf/hashtab.c

3259

u64 elem_map_flags, map_flags;

kernel/bpf/hashtab.c

3267

map_flags = attr->batch.flags;

kernel/bpf/hashtab.c

3268

if (map_flags)

kernel/bpf/hashtab.c

351

htab->map.map_flags & BPF_F_NO_COMMON_LRU,

kernel/bpf/hashtab.c

423

bool percpu_lru = (attr->map_flags & BPF_F_NO_COMMON_LRU);

kernel/bpf/hashtab.c

424

bool prealloc = !(attr->map_flags & BPF_F_NO_PREALLOC);

kernel/bpf/hashtab.c

425

bool zero_seed = (attr->map_flags & BPF_F_ZERO_SEED);

kernel/bpf/hashtab.c

435

if (attr->map_flags & ~HTAB_CREATE_FLAG_MASK ||

kernel/bpf/hashtab.c

436

!bpf_map_flags_access_ok(attr->map_flags))

kernel/bpf/hashtab.c

554

bool percpu_lru = (attr->map_flags & BPF_F_NO_COMMON_LRU);

kernel/bpf/hashtab.c

555

bool prealloc = !(attr->map_flags & BPF_F_NO_PREALLOC);

kernel/bpf/hashtab.c

608

if (htab->map.map_flags & BPF_F_ZERO_SEED)

kernel/bpf/local_storage.c

183

void *value, u64 map_flags)

kernel/bpf/local_storage.c

201

if (map_flags & BPF_F_CPU) {

kernel/bpf/local_storage.c

202

cpu = map_flags >> 32;

kernel/bpf/local_storage.c

217

void *value, u64 map_flags)

kernel/bpf/local_storage.c

225

if ((u32)map_flags & ~(BPF_ANY | BPF_EXIST | BPF_F_CPU | BPF_F_ALL_CPUS))

kernel/bpf/local_storage.c

241

if (map_flags & BPF_F_CPU) {

kernel/bpf/local_storage.c

242

cpu = map_flags >> 32;

kernel/bpf/local_storage.c

248

val = (map_flags & BPF_F_ALL_CPUS) ? value : value + size * cpu;

kernel/bpf/local_storage.c

319

if (attr->map_flags & ~LOCAL_STORAGE_CREATE_FLAG_MASK ||

kernel/bpf/local_storage.c

320

!bpf_map_flags_access_ok(attr->map_flags))

kernel/bpf/lpm_trie.c

579

!(attr->map_flags & BPF_F_NO_PREALLOC) ||

kernel/bpf/lpm_trie.c

580

attr->map_flags & ~LPM_CREATE_FLAG_MASK ||

kernel/bpf/lpm_trie.c

581

!bpf_map_flags_access_ok(attr->map_flags) ||

kernel/bpf/map_in_map.c

40

inner_map_meta->map_flags = inner_map->map_flags;

kernel/bpf/map_in_map.c

91

meta0->map_flags == meta1->map_flags &&

kernel/bpf/queue_stack_maps.c

52

attr->map_flags & ~QUEUE_STACK_CREATE_FLAG_MASK ||

kernel/bpf/queue_stack_maps.c

53

!bpf_map_flags_access_ok(attr->map_flags))

kernel/bpf/reuseport_array.c

192

u32 map_flags)

kernel/bpf/reuseport_array.c

194

if (osk && map_flags == BPF_NOEXIST)

kernel/bpf/reuseport_array.c

197

if (!osk && map_flags == BPF_EXIST)

kernel/bpf/reuseport_array.c

233

void *value, u64 map_flags)

kernel/bpf/reuseport_array.c

243

if (map_flags > BPF_EXIST)

kernel/bpf/reuseport_array.c

273

map_flags);

kernel/bpf/reuseport_array.c

289

err = reuseport_array_update_check(array, nsk, osk, reuse, map_flags);

kernel/bpf/ringbuf.c

199

if (attr->map_flags & ~RINGBUF_CREATE_FLAG_MASK)

kernel/bpf/ringbuf.c

202

if (attr->map_flags & BPF_F_RB_OVERWRITE) {

kernel/bpf/stackmap.c

100

if (attr->map_flags & ~STACK_CREATE_FLAG_MASK)

kernel/bpf/stackmap.c

109

if (attr->map_flags & BPF_F_STACK_BUILD_ID) {

kernel/bpf/stackmap.c

37

return (map->map_flags & BPF_F_STACK_BUILD_ID);

kernel/bpf/stackmap.c

989

u64 map_flags)

kernel/bpf/syscall.c

1033

map->map_flags,

kernel/bpf/syscall.c

1109

if (map->map_flags & BPF_F_RDONLY_PROG) {

kernel/bpf/syscall.c

1278

if (map->map_flags & (BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG)) {

kernel/bpf/syscall.c

1391

token_flag = attr->map_flags & BPF_F_TOKEN_FD;

kernel/bpf/syscall.c

1392

attr->map_flags &= ~BPF_F_TOKEN_FD;

kernel/bpf/syscall.c

1652

f_flags = bpf_get_file_flag(attr->map_flags);

kernel/bpf/syscall.c

443

map->map_flags = bpf_map_flags_retain_permanent(attr->map_flags);

kernel/bpf/syscall.c

5469

info.map_flags = map->map_flags;

kernel/bpf/verifier.c

10105

if (map->map_flags & BPF_F_INNER_MAP)

kernel/bpf/verifier.c

5568

return (map->map_flags & BPF_F_RDONLY_PROG) &&

kernel/bpf/verifier.c

9891

if ((map->map_flags & BPF_F_RDONLY_PROG) &&

mm/mremap.c

949

unsigned long map_flags = 0;

mm/mremap.c

957

map_flags |= MAP_FIXED;

mm/mremap.c

959

map_flags |= MAP_SHARED;

mm/mremap.c

962

map_flags);

net/core/bpf_sk_storage.c

109

map_flags, false);

net/core/bpf_sk_storage.c

173

if (!smap || !(smap->map.map_flags & BPF_F_CLONE))

net/core/bpf_sk_storage.c

98

void *value, u64 map_flags)

net/core/sock_map.c

1107

attr->map_flags & ~SOCK_CREATE_FLAG_MASK)

net/core/sock_map.c

47

attr->map_flags & ~SOCK_CREATE_FLAG_MASK)

net/xdp/xskmap.c

162

u64 map_flags)

net/xdp/xskmap.c

172

if (unlikely(map_flags > BPF_EXIST))

net/xdp/xskmap.c

204

} else if (old_xs && map_flags == BPF_NOEXIST) {

net/xdp/xskmap.c

207

} else if (!old_xs && map_flags == BPF_EXIST) {

net/xdp/xskmap.c

72

attr->map_flags & ~(BPF_F_NUMA_NODE | BPF_F_RDONLY | BPF_F_WRONLY))

samples/bpf/map_perf_test.bpf.c

36

__uint(map_flags, BPF_F_NO_COMMON_LRU);

samples/bpf/map_perf_test.bpf.c

44

__uint(map_flags, BPF_F_NUMA_NODE);

samples/bpf/map_perf_test.bpf.c

70

__uint(map_flags, BPF_F_NO_PREALLOC);

samples/bpf/map_perf_test.bpf.c

78

__uint(map_flags, BPF_F_NO_PREALLOC);

samples/bpf/map_perf_test.bpf.c

86

__uint(map_flags, BPF_F_NO_PREALLOC);

samples/bpf/map_perf_test_user.c

137

.map_flags = BPF_F_NUMA_NODE,

samples/bpf/tcp_dumpstats_kern.c

17

__u32 map_flags;

samples/bpf/tcp_dumpstats_kern.c

22

.map_flags = BPF_F_NO_PREALLOC,

samples/bpf/test_lru_dist.c

202

static int create_map(int map_type, int map_flags, unsigned int size)

samples/bpf/test_lru_dist.c

205

.map_flags = map_flags,

samples/bpf/test_lru_dist.c

307

static void test_parallel_lru_dist(int map_type, int map_flags,

samples/bpf/test_lru_dist.c

314

map_flags);

samples/bpf/test_lru_dist.c

316

if (map_flags & BPF_F_NO_COMMON_LRU)

samples/bpf/test_lru_dist.c

317

lru_map_fd = create_map(map_type, map_flags,

samples/bpf/test_lru_dist.c

320

lru_map_fd = create_map(map_type, map_flags,

samples/bpf/test_lru_dist.c

332

static void test_lru_loss0(int map_type, int map_flags)

samples/bpf/test_lru_dist.c

341

map_flags);

samples/bpf/test_lru_dist.c

345

if (map_flags & BPF_F_NO_COMMON_LRU)

samples/bpf/test_lru_dist.c

346

map_fd = create_map(map_type, map_flags, 900 * nr_cpus);

samples/bpf/test_lru_dist.c

348

map_fd = create_map(map_type, map_flags, 900);

samples/bpf/test_lru_dist.c

386

static void test_lru_loss1(int map_type, int map_flags)

samples/bpf/test_lru_dist.c

393

map_flags);

samples/bpf/test_lru_dist.c

397

if (map_flags & BPF_F_NO_COMMON_LRU)

samples/bpf/test_lru_dist.c

398

map_fd = create_map(map_type, map_flags, 1000 * nr_cpus);

samples/bpf/test_lru_dist.c

400

map_fd = create_map(map_type, map_flags, 1000);

samples/bpf/test_lru_dist.c

465

static void test_parallel_lru_loss(int map_type, int map_flags, int nr_tasks)

samples/bpf/test_lru_dist.c

470

map_flags);

samples/bpf/test_lru_dist.c

473

if (map_flags & BPF_F_NO_COMMON_LRU)

samples/bpf/test_lru_dist.c

474

map_fd = create_map(map_type, map_flags,

samples/bpf/test_lru_dist.c

477

map_fd = create_map(map_type, map_flags,

samples/bpf/test_lru_dist.c

489

int map_flags[] = {0, BPF_F_NO_COMMON_LRU};

samples/bpf/test_lru_dist.c

521

for (f = 0; f < ARRAY_SIZE(map_flags); f++) {

samples/bpf/test_lru_dist.c

522

test_lru_loss0(BPF_MAP_TYPE_LRU_HASH, map_flags[f]);

samples/bpf/test_lru_dist.c

523

test_lru_loss1(BPF_MAP_TYPE_LRU_HASH, map_flags[f]);

samples/bpf/test_lru_dist.c

524

test_parallel_lru_loss(BPF_MAP_TYPE_LRU_HASH, map_flags[f],

samples/bpf/test_lru_dist.c

526

test_parallel_lru_dist(BPF_MAP_TYPE_LRU_HASH, map_flags[f],

samples/bpf/xdp_router_ipv4.bpf.c

47

__uint(map_flags, BPF_F_NO_PREALLOC);

samples/bpf/xdp_sample.bpf.h

21

__uint(map_flags, BPF_F_MMAPABLE);

tools/bpf/bpftool/map.c

1300

if (parse_u32_arg(&argc, &argv, &attr.map_flags,

tools/bpf/bpftool/map.c

465

jsonw_printf(wtr, "%u", info->map_flags);

tools/bpf/bpftool/map.c

556

printf("flags 0x%x", info->map_flags);

tools/include/uapi/linux/bpf.h

1533

__u32 map_flags; /* BPF_MAP_CREATE related

tools/include/uapi/linux/bpf.h

6738

__u32 map_flags;

tools/lib/bpf/bpf.c

241

attr.map_flags = OPTS_GET(opts, map_flags, 0);

tools/lib/bpf/bpf.h

61

__u32 map_flags;

tools/lib/bpf/features.c

214

.map_flags = BPF_F_MMAPABLE | (token_fd ? BPF_F_TOKEN_FD : 0),

tools/lib/bpf/features.c

273

.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,

tools/lib/bpf/features.c

516

.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,

tools/lib/bpf/features.c

57

.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,

tools/lib/bpf/gen_loader.c

526

attr.map_flags = tgt_endian(map_attr->map_flags);

tools/lib/bpf/libbpf.c

10848

return map->def.map_flags;

tools/lib/bpf/libbpf.c

10855

map->def.map_flags = flags;

tools/lib/bpf/libbpf.c

14081

if (err && (!(map->def.map_flags & BPF_F_LINK) || err != -EBUSY)) {

tools/lib/bpf/libbpf.c

14088

if (!(map->def.map_flags & BPF_F_LINK)) {

tools/lib/bpf/libbpf.c

1464

map->def.map_flags = strcmp(sec_name, STRUCT_OPS_LINK_SEC) == 0 ? BPF_F_LINK : 0;

tools/lib/bpf/libbpf.c

1990

def->map_flags = type == LIBBPF_MAP_RODATA || type == LIBBPF_MAP_KCONFIG

tools/lib/bpf/libbpf.c

1997

def->map_flags |= BPF_F_MMAPABLE;

tools/lib/bpf/libbpf.c

2000

map->name, map->sec_idx, map->sec_offset, def->map_flags);

tools/lib/bpf/libbpf.c

2605

if (!get_map_field_int(map_name, btf, m, &map_def->map_flags))

tools/lib/bpf/libbpf.c

2842

map->def.map_flags = def->map_flags;

tools/lib/bpf/libbpf.c

2871

pr_debug("map '%s': found map_flags = 0x%x.\n", map->name, def->map_flags);

tools/lib/bpf/libbpf.c

4989

info->map_flags = val;

tools/lib/bpf/libbpf.c

5075

map->def.map_flags = info.map_flags;

tools/lib/bpf/libbpf.c

5249

map_info.map_flags &= ~BPF_F_RDONLY_PROG;

tools/lib/bpf/libbpf.c

5255

map_info.map_flags == map->def.map_flags &&

tools/lib/bpf/libbpf.c

5340

if (map->def.map_flags & BPF_F_MMAPABLE) {

tools/lib/bpf/libbpf.c

5344

if (map->def.map_flags & BPF_F_RDONLY_PROG)

tools/lib/bpf/libbpf.c

5376

create_attr.map_flags = def->map_flags;

tools/lib/bpf/libbpf.c

5381

create_attr.map_flags |= BPF_F_TOKEN_FD;

tools/lib/bpf/libbpf.c

5395

create_attr.map_flags |= BPF_F_VTYPE_BTF_OBJ_FD;

tools/lib/bpf/libbpf.c

565

unsigned int map_flags;

tools/lib/bpf/libbpf.c

8589

m->def.map_flags &= ~BPF_F_MMAPABLE;

tools/lib/bpf/libbpf_internal.h

289

__u32 map_flags;

tools/lib/bpf/libbpf_probes.c

310

opts.map_flags = BPF_F_NO_PREALLOC;

tools/lib/bpf/libbpf_probes.c

313

opts.map_flags = BPF_F_NO_PREALLOC;

tools/lib/bpf/libbpf_probes.c

333

opts.map_flags = BPF_F_NO_PREALLOC;

tools/lib/bpf/libbpf_probes.c

359

opts.map_flags = BPF_F_MMAPABLE;

tools/lib/bpf/linker.c

1729

if (main_def->map_flags != extra_def->map_flags) {

tools/perf/bench/numa.c

424

static u8 *alloc_data(ssize_t bytes0, int map_flags,

tools/perf/bench/numa.c

445

buf = (void *)mmap(0, bytes, PROT_READ|PROT_WRITE, MAP_ANON|map_flags, -1, 0);

tools/perf/bench/numa.c

448

if (map_flags == MAP_PRIVATE) {

tools/perf/util/bpf_skel/bperf_follower.bpf.c

29

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/perf/util/bpf_skel/bperf_leader.bpf.c

11

__uint(map_flags, BPF_F_PRESERVE_ELEMS);

tools/perf/util/bpf_skel/kwork_top.bpf.c

52

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/perf/util/bpf_skel/off_cpu.bpf.c

71

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/sched_ext/scx_flatcg.bpf.c

127

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/sched_ext/scx_flatcg.bpf.c

96

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/sched_ext/scx_qmap.bpf.c

183

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/sched_ext/scx_qmap.bpf.c

83

__uint(map_flags, BPF_F_MMAPABLE);

tools/sched_ext/scx_sdt.bpf.c

28

__uint(map_flags, BPF_F_MMAPABLE);

tools/sched_ext/scx_sdt.bpf.c

526

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/sched_ext/scx_userland.bpf.c

90

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

154

__u32 map_flags;

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

167

map_flags = args.map_flags;

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

169

map_flags |= BPF_F_NO_PREALLOC;

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

175

bpf_map__set_map_flags(ctx.skel->maps.hash_map_bench, map_flags);

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

22

__u32 map_flags;

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

28

.map_flags = 0,

tools/testing/selftests/bpf/benchs/bench_bpf_hashmap_lookup.c

75

args.map_flags = ret;

tools/testing/selftests/bpf/benchs/bench_local_storage.c

123

create_opts.map_flags = BPF_F_NO_PREALLOC;

tools/testing/selftests/bpf/libarena/include/libarena/common.h

31

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

228

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

351

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

443

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

552

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

764

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_basic_ops.c

796

opts.map_flags = BPF_F_NO_PREALLOC;

tools/testing/selftests/bpf/map_tests/lpm_trie_map_batch_ops.c

68

LIBBPF_OPTS(bpf_map_create_opts, create_opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/lpm_trie_map_get_next_key.c

64

.map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

289

n_iter, n_real, map_type_to_s(info->type), info->map_flags);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

316

opts.retry_for_nomem = is_percpu(opts.map_type) && (info.map_flags & BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

363

LIBBPF_OPTS(bpf_map_create_opts, map_opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

370

LIBBPF_OPTS(bpf_map_create_opts, map_opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

385

static int create_lru_hash(__u32 type, __u32 map_flags)

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

387

LIBBPF_OPTS(bpf_map_create_opts, map_opts, .map_flags = map_flags);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

395

.map_flags = BPF_F_NO_PREALLOC,

tools/testing/selftests/bpf/map_tests/sk_storage_map.c

27

.map_flags = BPF_F_NO_PREALLOC,

tools/testing/selftests/bpf/map_tests/sk_storage_map.c

580

bad_xattr.map_flags = 0;

tools/testing/selftests/bpf/prog_tests/arena_direct_value.c

27

map_opts.map_flags = BPF_F_MMAPABLE;

tools/testing/selftests/bpf/prog_tests/bloom_filter_map.c

40

opts.map_flags = BPF_F_NO_PREALLOC;

tools/testing/selftests/bpf/prog_tests/bloom_filter_map.c

75

opts.map_flags = BPF_F_ZERO_SEED | BPF_F_NUMA_NODE;

tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c

90

!ASSERT_EQ(map_infos[i].map_flags, 0, "map_flags") ||

tools/testing/selftests/bpf/prog_tests/lru_lock_nmi.c

144

static void run_variant(enum bpf_map_type type, __u32 map_flags, const char *name)

tools/testing/selftests/bpf/prog_tests/lru_lock_nmi.c

178

err = bpf_map__set_map_flags(skel->maps.lru_map, map_flags);

tools/testing/selftests/bpf/prog_tests/map_init.c

289

.map_flags = BPF_F_NUMA_NODE,

tools/testing/selftests/bpf/prog_tests/map_init.c

308

.map_flags = BPF_F_TOKEN_FD,

tools/testing/selftests/bpf/prog_tests/obj_name.c

58

attr.map_flags = 0;

tools/testing/selftests/bpf/prog_tests/rhash.c

49

.map_flags = BPF_F_NO_PREALLOC,

tools/testing/selftests/bpf/prog_tests/signed_loader.c

798

opts.map_flags = flags;

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

482

create_attr.map_flags = bpf_map__map_flags(map);

tools/testing/selftests/bpf/prog_tests/token.c

528

map_opts.map_flags = 0;

tools/testing/selftests/bpf/prog_tests/token.c

537

map_opts.map_flags = BPF_F_TOKEN_FD;

tools/testing/selftests/bpf/prog_tests/token.c

551

map_opts.map_flags = 0;

tools/testing/selftests/bpf/prog_tests/token.c

560

map_opts.map_flags = BPF_F_TOKEN_FD;

tools/testing/selftests/bpf/progs/arena_atomics.c

14

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/arena_htab.c

12

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/arena_list.c

12

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/arena_spin_lock.c

12

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/arena_strsearch.c

8

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/bench_local_storage_create.c

19

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bench_local_storage_create.c

26

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bpf_dctcp.c

33

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bpf_iter_bpf_rhash_map.c

10

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bpf_iter_bpf_sk_storage_helpers.c

11

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bpf_iter_bpf_sk_storage_map.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bpf_smc.c

78

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/bprm_opts.c

16

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_attach_cgroup.c

18

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_negative.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_recursion.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_recursion.c

19

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_sleepable.c

13

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_sleepable.c

131

void *value, u64 map_flags, bool swap_uptrs,

tools/testing/selftests/bpf/progs/cgrp_ls_tp_btf.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/cgrp_ls_tp_btf.c

19

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/compute_live_registers.c

18

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/connect_force_port4.c

26

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/connect_force_port6.c

25

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/htab_mem_bench.c

20

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/htab_reuse.c

18

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/htab_reuse.c

34

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/local_storage.c

28

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/local_storage.c

35

__uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_CLONE);

tools/testing/selftests/bpf/progs/local_storage.c

42

__uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_CLONE);

tools/testing/selftests/bpf/progs/local_storage.c

49

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/local_storage.c

56

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/local_storage_bench.c

17

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/local_storage_rcu_tasks_trace_bench.c

10

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/lpm_trie_bench.c

24

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/lpm_trie_map.c

17

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr.c

45

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr.c

53

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr.c

72

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr.c

79

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr.c

86

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr.c

93

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr_race.c

14

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr_race.c

22

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_kptr_race.c

30

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_ptr_kern.c

100

__uint(map_flags, BPF_F_NO_PREALLOC); /* to test bpf_htab.count */

tools/testing/selftests/bpf/progs/map_ptr_kern.c

325

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/map_ptr_kern.c

617

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/mmap_inner_array.c

13

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/mptcp_sock.c

23

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/nested_trust_failure.c

15

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/nested_trust_success.c

15

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/net_timestamping.c

36

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/netns_cookie_prog.c

11

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/netns_cookie_prog.c

18

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/percpu_alloc_cgrp_local_storage.c

14

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/rcu_read_lock.c

24

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/rhash.c

24

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/sk_storage_omem_uncharge.c

16

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/socket_cookie_prog.c

19

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/sockopt_inherit.c

20

__uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_CLONE);

tools/testing/selftests/bpf/progs/sockopt_inherit.c

27

__uint(map_flags, BPF_F_NO_PREALLOC | BPF_F_CLONE);

tools/testing/selftests/bpf/progs/sockopt_inherit.c

34

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/sockopt_sk.c

24

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/stream.c

23

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/task_local_data.bpf.h

123

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_local_data.bpf.h

130

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_local_storage.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_local_storage.c

71

void *value, u64 map_flags, bool swap_uptrs,

tools/testing/selftests/bpf/progs/task_local_storage_exit_creds.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_ls_recursion.c

18

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_ls_recursion.c

25

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_ls_uptr.c

14

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_storage_nodeadlock.c

16

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_work.c

23

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_work_fail.c

22

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/task_work_stress.c

27

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/tcp_rtt.c

20

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_btf_map_in_map.c

46

__uint(map_flags, BPF_F_INNER_MAP);

tools/testing/selftests/bpf/progs/test_btf_map_in_map.c

55

__uint(map_flags, BPF_F_INNER_MAP);

tools/testing/selftests/bpf/progs/test_btf_map_in_map.c

68

__uint(map_flags, BPF_F_INNER_MAP);

tools/testing/selftests/bpf/progs/test_map_in_map.c

11

__uint(map_flags, 0);

tools/testing/selftests/bpf/progs/test_map_in_map.c

19

__uint(map_flags, 0);

tools/testing/selftests/bpf/progs/test_mmap.c

12

__uint(map_flags, BPF_F_MMAPABLE | BPF_F_RDONLY_PROG);

tools/testing/selftests/bpf/progs/test_mmap.c

19

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/test_pe_preserve_elems.c

19

__uint(map_flags, BPF_F_PRESERVE_ELEMS);

tools/testing/selftests/bpf/progs/test_pinning_htab.c

24

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_queue_stack_map.h

14

__uint(map_flags, 0);

tools/testing/selftests/bpf/progs/test_queue_stack_map.h

22

__uint(map_flags, 0);

tools/testing/selftests/bpf/progs/test_ringbuf_overwrite.c

12

__uint(map_flags, BPF_F_RB_OVERWRITE);

tools/testing/selftests/bpf/progs/test_sk_storage_trace_itself.c

10

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c

17

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c

25

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_skmsg_load_helpers.c

22

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_sock_fields.c

32

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_sock_fields.c

39

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_stacktrace_build_id.c

30

__uint(map_flags, BPF_F_STACK_BUILD_ID);

tools/testing/selftests/bpf/progs/test_tcp_hdr_options.c

37

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

178

__uint(map_flags, 1U << 1);

tools/testing/selftests/bpf/progs/timer.c

30

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/type_cast.c

11

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/udp_limit.c

11

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/update_map_in_htab.c

23

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/uptr_failure.c

12

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/uptr_map_failure.c

10

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/uptr_map_failure.c

17

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/uptr_map_failure.c

24

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/uptr_update_failure.c

10

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/verifier_arena.c

17

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/verifier_arena_globals1.c

17

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/verifier_arena_globals2.c

16

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/verifier_arena_large.c

16

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/verifier_array_access.c

20

__uint(map_flags, BPF_F_RDONLY_PROG);

tools/testing/selftests/bpf/progs/verifier_array_access.c

28

__uint(map_flags, BPF_F_WRONLY_PROG);

tools/testing/selftests/bpf/progs/verifier_ldsx.c

16

__uint(map_flags, BPF_F_MMAPABLE);

tools/testing/selftests/bpf/progs/verifier_map_in_map.c

28

__uint(map_flags, BPF_F_INNER_MAP);

tools/testing/selftests/bpf/progs/verifier_sock.c

46

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/verifier_xdp.c

13

__uint(map_flags, BPF_F_RDONLY_PROG);

tools/testing/selftests/bpf/progs/wq.c

28

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/progs/xdpwall.c

62

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/test_lru_map.c

161

static void test_lru_sanity0(int map_type, int map_flags)

tools/testing/selftests/bpf/test_lru_map.c

168

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

172

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

173

lru_map_fd = create_map(map_type, map_flags, 2 * nr_cpus);

tools/testing/selftests/bpf/test_lru_map.c

175

lru_map_fd = create_map(map_type, map_flags, 2);

tools/testing/selftests/bpf/test_lru_map.c

252

static void test_lru_sanity1(int map_type, int map_flags, unsigned int tgt_free)

tools/testing/selftests/bpf/test_lru_map.c

260

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

265

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

273

lru_map_fd = create_map(map_type, map_flags, map_size);

tools/testing/selftests/bpf/test_lru_map.c

28

static int create_map(int map_type, int map_flags, unsigned int size)

tools/testing/selftests/bpf/test_lru_map.c

30

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = map_flags);

tools/testing/selftests/bpf/test_lru_map.c

320

static void test_lru_sanity2(int map_type, int map_flags, unsigned int tgt_free)

tools/testing/selftests/bpf/test_lru_map.c

329

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

334

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

342

lru_map_fd = create_map(map_type, map_flags, map_size);

tools/testing/selftests/bpf/test_lru_map.c

426

static void test_lru_sanity3(int map_type, int map_flags, unsigned int tgt_free)

tools/testing/selftests/bpf/test_lru_map.c

434

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

439

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

446

lru_map_fd = create_map(map_type, map_flags, map_size);

tools/testing/selftests/bpf/test_lru_map.c

487

static void test_lru_sanity4(int map_type, int map_flags, unsigned int tgt_free)

tools/testing/selftests/bpf/test_lru_map.c

495

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

499

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

500

lru_map_fd = create_map(map_type, map_flags,

tools/testing/selftests/bpf/test_lru_map.c

503

lru_map_fd = create_map(map_type, map_flags,

tools/testing/selftests/bpf/test_lru_map.c

564

static void test_lru_sanity5(int map_type, int map_flags)

tools/testing/selftests/bpf/test_lru_map.c

570

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

574

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

576

map_fd = create_map(map_type, map_flags, 1);

tools/testing/selftests/bpf/test_lru_map.c

611

static void test_lru_sanity6(int map_type, int map_flags, int tgt_free)

tools/testing/selftests/bpf/test_lru_map.c

618

if (!(map_flags & BPF_F_NO_COMMON_LRU))

tools/testing/selftests/bpf/test_lru_map.c

622

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

629

lru_map_fd = create_map(map_type, map_flags, map_size * nr_cpus);

tools/testing/selftests/bpf/test_lru_map.c

678

static void test_lru_sanity7(int map_type, int map_flags)

tools/testing/selftests/bpf/test_lru_map.c

685

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

689

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

690

lru_map_fd = create_map(map_type, map_flags, 2 * nr_cpus);

tools/testing/selftests/bpf/test_lru_map.c

692

lru_map_fd = create_map(map_type, map_flags, 2);

tools/testing/selftests/bpf/test_lru_map.c

769

static void test_lru_sanity8(int map_type, int map_flags)

tools/testing/selftests/bpf/test_lru_map.c

776

map_flags);

tools/testing/selftests/bpf/test_lru_map.c

780

if (map_flags & BPF_F_NO_COMMON_LRU)

tools/testing/selftests/bpf/test_lru_map.c

781

lru_map_fd = create_map(map_type, map_flags, 2 * nr_cpus);

tools/testing/selftests/bpf/test_lru_map.c

783

lru_map_fd = create_map(map_type, map_flags, 2);

tools/testing/selftests/bpf/test_lru_map.c

855

int map_flags[] = {0, BPF_F_NO_COMMON_LRU};

tools/testing/selftests/bpf/test_lru_map.c

867

for (f = 0; f < ARRAY_SIZE(map_flags); f++) {

tools/testing/selftests/bpf/test_lru_map.c

868

unsigned int tgt_free = (map_flags[f] & BPF_F_NO_COMMON_LRU) ?

tools/testing/selftests/bpf/test_lru_map.c

872

test_lru_sanity0(map_types[t], map_flags[f]);

tools/testing/selftests/bpf/test_lru_map.c

873

test_lru_sanity1(map_types[t], map_flags[f], tgt_free);

tools/testing/selftests/bpf/test_lru_map.c

874

test_lru_sanity2(map_types[t], map_flags[f], tgt_free);

tools/testing/selftests/bpf/test_lru_map.c

875

test_lru_sanity3(map_types[t], map_flags[f], tgt_free);

tools/testing/selftests/bpf/test_lru_map.c

876

test_lru_sanity4(map_types[t], map_flags[f], tgt_free);

tools/testing/selftests/bpf/test_lru_map.c

877

test_lru_sanity5(map_types[t], map_flags[f]);

tools/testing/selftests/bpf/test_lru_map.c

878

test_lru_sanity6(map_types[t], map_flags[f], tgt_free);

tools/testing/selftests/bpf/test_lru_map.c

879

test_lru_sanity7(map_types[t], map_flags[f]);

tools/testing/selftests/bpf/test_lru_map.c

880

test_lru_sanity8(map_types[t], map_flags[f]);

tools/testing/selftests/bpf/test_maps.c

1539

old_flags = map_opts.map_flags;

tools/testing/selftests/bpf/test_maps.c

1540

map_opts.map_flags |= BPF_F_RDONLY;

tools/testing/selftests/bpf/test_maps.c

1543

map_opts.map_flags = old_flags;

tools/testing/selftests/bpf/test_maps.c

1568

old_flags = map_opts.map_flags;

tools/testing/selftests/bpf/test_maps.c

1569

map_opts.map_flags |= BPF_F_WRONLY;

tools/testing/selftests/bpf/test_maps.c

1572

map_opts.map_flags = old_flags;

tools/testing/selftests/bpf/test_maps.c

1599

old_flags = map_opts.map_flags;

tools/testing/selftests/bpf/test_maps.c

1600

map_opts.map_flags |= BPF_F_WRONLY;

tools/testing/selftests/bpf/test_maps.c

1602

map_opts.map_flags = old_flags;

tools/testing/selftests/bpf/test_maps.c

1604

if (map_opts.map_flags & BPF_F_NO_PREALLOC) {

tools/testing/selftests/bpf/test_maps.c

1927

map_opts.map_flags = 0;

tools/testing/selftests/bpf/test_maps.c

1930

map_opts.map_flags = BPF_F_NO_PREALLOC;

tools/testing/selftests/bpf/test_maps.c

269

map_opts.map_flags == BPF_F_NO_PREALLOC));

tools/testing/selftests/bpf/test_maps.c

283

"err: %s, flags: 0x%x\n", strerror(errno), map_opts.map_flags);

tools/testing/selftests/bpf/test_maps.c

340

old_flags = map_opts.map_flags;

tools/testing/selftests/bpf/test_maps.c

341

map_opts.map_flags |= BPF_F_ZERO_SEED;

tools/testing/selftests/bpf/test_maps.c

363

map_opts.map_flags = old_flags;

tools/testing/selftests/bpf/test_maps.c

562

if (map_opts.map_flags & BPF_F_NO_PREALLOC) {

tools/testing/selftests/bpf/test_maps.c

618

if (map_opts.map_flags & BPF_F_NO_PREALLOC) {

tools/testing/selftests/bpf/test_tag.c

187

LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = BPF_F_NO_PREALLOC);

tools/testing/selftests/bpf/test_verifier.c

548

opts.map_flags = (type == BPF_MAP_TYPE_HASH ? BPF_F_NO_PREALLOC : 0) | extra_flags;

tools/testing/selftests/bpf/test_verifier.c

820

.map_flags = BPF_F_NO_PREALLOC,

tools/testing/selftests/sched_ext/dequeue.bpf.c

87

__uint(map_flags, BPF_F_NO_PREALLOC);

tools/testing/selftests/sched_ext/select_cpu_dfl_nodispatch.bpf.c

25

__uint(map_flags, BPF_F_NO_PREALLOC);