include/uapi/linux/bpf.h

134

__u32 map_fd;

include/uapi/linux/bpf.h

1560

__u32 map_fd;

include/uapi/linux/bpf.h

1581

__u32 map_fd;

include/uapi/linux/bpf.h

1791

__u32 map_fd; /* struct_ops to attach */

include/uapi/linux/bpf.h

1903

__u32 map_fd;

include/uapi/linux/bpf.h

1920

__u32 map_fd;

kernel/bpf/bpf_struct_ops.c

1367

map = bpf_map_get(attr->link_create.map_fd);

kernel/bpf/map_iter.c

109

if (!linfo->map.map_fd)

kernel/bpf/map_iter.c

112

map = bpf_map_get_with_uref(linfo->map.map_fd);

kernel/bpf/preload/iterators/iterators.lskel-big-endian.h

69

skel_closenz(skel->maps.rodata.map_fd);

kernel/bpf/preload/iterators/iterators.lskel-little-endian.h

69

skel_closenz(skel->maps.rodata.map_fd);

kernel/bpf/syscall.c

1723

CLASS(fd, f)(attr->map_fd);

kernel/bpf/syscall.c

1785

CLASS(fd, f)(attr->map_fd);

kernel/bpf/syscall.c

1836

CLASS(fd, f)(attr->map_fd);

kernel/bpf/syscall.c

1890

CLASS(fd, f)(attr->map_fd);

kernel/bpf/syscall.c

2157

CLASS(fd, f)(attr->map_fd);

kernel/bpf/syscall.c

2231

#define BPF_MAP_FREEZE_LAST_FIELD map_fd

kernel/bpf/syscall.c

2241

CLASS(fd, f)(attr->map_fd);

kernel/bpf/syscall.c

5669

CLASS(fd, f)(attr->batch.map_fd);

kernel/bpf/syscall.c

6084

map = bpf_map_get(attr->prog_bind_map.map_fd);

kernel/bpf/syscall.c

6190

map = bpf_map_get(attr->prog_assoc_struct_ops.map_fd);

net/core/bpf_sk_storage.c

509

int map_fd = nla_get_u32(nla);

net/core/bpf_sk_storage.c

510

struct bpf_map *map = bpf_map_get(map_fd);

net/core/bpf_sk_storage.c

859

if (!linfo->map.map_fd)

net/core/bpf_sk_storage.c

862

map = bpf_map_get_with_uref(linfo->map.map_fd);

net/core/sock_map.c

1909

if (!linfo->map.map_fd)

net/core/sock_map.c

1912

map = bpf_map_get_with_uref(linfo->map.map_fd);

samples/bpf/cookie_uid_helper_example.c

100

BPF_LD_MAP_FD(BPF_REG_1, map_fd),

samples/bpf/cookie_uid_helper_example.c

135

BPF_LD_MAP_FD(BPF_REG_1, map_fd),

samples/bpf/cookie_uid_helper_example.c

203

while (bpf_map_get_next_key(map_fd, &curN, &nextN) > -1) {

samples/bpf/cookie_uid_helper_example.c

205

res = bpf_map_lookup_elem(map_fd, &curN, &curEntry);

samples/bpf/cookie_uid_helper_example.c

245

res = bpf_map_lookup_elem(map_fd, &cookie, &dataEntry);

samples/bpf/cookie_uid_helper_example.c

264

res = bpf_map_lookup_elem(map_fd, &cookie, &dataEntry);

samples/bpf/cookie_uid_helper_example.c

330

close(map_fd);

samples/bpf/cookie_uid_helper_example.c

64

static int map_fd, prog_fd;

samples/bpf/cookie_uid_helper_example.c

70

map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(uint32_t),

samples/bpf/cookie_uid_helper_example.c

72

if (map_fd < 0)

samples/bpf/ibumad_user.c

128

map_fd[0] = bpf_object__find_map_fd_by_name(obj, "read_count");

samples/bpf/ibumad_user.c

129

map_fd[1] = bpf_object__find_map_fd_by_name(obj, "write_count");

samples/bpf/ibumad_user.c

130

if (map_fd[0] < 0 || map_fd[1] < 0) {

samples/bpf/ibumad_user.c

31

static int map_fd[2];

samples/bpf/ibumad_user.c

52

dump_counts(map_fd[0]);

samples/bpf/ibumad_user.c

54

dump_counts(map_fd[1]);

samples/bpf/lathist_user.c

102

map_fd = bpf_object__find_map_fd_by_name(obj, "my_lat");

samples/bpf/lathist_user.c

103

if (map_fd < 0) {

samples/bpf/lathist_user.c

119

get_data(map_fd);

samples/bpf/lathist_user.c

87

int map_fd, i = 0;

samples/bpf/lwt_len_hist_user.c

36

int i, map_fd;

samples/bpf/lwt_len_hist_user.c

38

map_fd = bpf_obj_get(map_filename);

samples/bpf/lwt_len_hist_user.c

39

if (map_fd < 0) {

samples/bpf/lwt_len_hist_user.c

45

while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {

samples/bpf/lwt_len_hist_user.c

51

bpf_map_lookup_elem(map_fd, &next_key, values);

samples/bpf/lwt_len_hist_user.c

74

close(map_fd);

samples/bpf/map_perf_test_user.c

134

int outer_fd = map_fd[array_of_lru_hashs_idx];

samples/bpf/map_perf_test_user.c

387

r = bpf_map_update_elem(map_fd[hash_map_alloc_idx],

samples/bpf/map_perf_test_user.c

399

r = bpf_map_update_elem(map_fd[hash_map_alloc_idx], key, &value, 0);

samples/bpf/map_perf_test_user.c

475

map_fd[0] = bpf_object__find_map_fd_by_name(obj, "array_of_lru_hashs");

samples/bpf/map_perf_test_user.c

476

map_fd[1] = bpf_object__find_map_fd_by_name(obj, "hash_map_alloc");

samples/bpf/map_perf_test_user.c

477

map_fd[2] = bpf_object__find_map_fd_by_name(obj, "lru_hash_lookup_map");

samples/bpf/map_perf_test_user.c

478

if (map_fd[0] < 0 || map_fd[1] < 0 || map_fd[2] < 0) {

samples/bpf/map_perf_test_user.c

69

static int map_fd[NR_IDXES];

samples/bpf/map_perf_test_user.c

96

int fd = map_fd[lru_hash_lookup_idx];

samples/bpf/offwaketime_user.c

122

map_fd[0] = bpf_object__find_map_fd_by_name(obj, "counts");

samples/bpf/offwaketime_user.c

123

map_fd[1] = bpf_object__find_map_fd_by_name(obj, "stackmap");

samples/bpf/offwaketime_user.c

124

if (map_fd[0] < 0 || map_fd[1] < 0) {

samples/bpf/offwaketime_user.c

145

print_stacks(map_fd[0]);

samples/bpf/offwaketime_user.c

18

static int map_fd[2];

samples/bpf/offwaketime_user.c

54

if (bpf_map_lookup_elem(map_fd[1], &key->tret, ip) != 0) {

samples/bpf/offwaketime_user.c

61

if (bpf_map_lookup_elem(map_fd[1], &key->wret, ip) != 0) {

samples/bpf/offwaketime_user.c

91

print_stacks(map_fd[0]);

samples/bpf/sampleip_user.c

135

print_ip_map(map_fd);

samples/bpf/sampleip_user.c

207

map_fd = bpf_object__find_map_fd_by_name(obj, "ip_map");

samples/bpf/sampleip_user.c

208

if (map_fd < 0) {

samples/bpf/sampleip_user.c

229

print_ip_map(map_fd);

samples/bpf/sampleip_user.c

25

static int map_fd;

samples/bpf/sock_example.c

38

int sock = -1, map_fd, prog_fd, i, key;

samples/bpf/sock_example.c

41

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, sizeof(key), sizeof(value),

samples/bpf/sock_example.c

43

if (map_fd < 0) {

samples/bpf/sock_example.c

54

BPF_LD_MAP_FD(BPF_REG_1, map_fd),

samples/bpf/sock_example.c

85

assert(bpf_map_lookup_elem(map_fd, &key, &tcp_cnt) == 0);

samples/bpf/sock_example.c

88

assert(bpf_map_lookup_elem(map_fd, &key, &udp_cnt) == 0);

samples/bpf/sock_example.c

91

assert(bpf_map_lookup_elem(map_fd, &key, &icmp_cnt) == 0);

samples/bpf/sockex1_user.c

15

int map_fd, prog_fd;

samples/bpf/sockex1_user.c

34

map_fd = bpf_object__find_map_fd_by_name(obj, "my_map");

samples/bpf/sockex1_user.c

49

assert(bpf_map_lookup_elem(map_fd, &key, &tcp_cnt) == 0);

samples/bpf/sockex1_user.c

52

assert(bpf_map_lookup_elem(map_fd, &key, &udp_cnt) == 0);

samples/bpf/sockex1_user.c

55

assert(bpf_map_lookup_elem(map_fd, &key, &icmp_cnt) == 0);

samples/bpf/sockex2_user.c

20

int map_fd, prog_fd;

samples/bpf/sockex2_user.c

38

map_fd = bpf_object__find_map_fd_by_name(obj, "hash_map");

samples/bpf/sockex2_user.c

52

while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {

samples/bpf/sockex2_user.c

53

bpf_map_lookup_elem(map_fd, &next_key, &value);

samples/bpf/spintest_user.c

16

int map_fd, i, j = 0;

samples/bpf/spintest_user.c

39

map_fd = bpf_object__find_map_fd_by_name(obj, "my_map");

samples/bpf/spintest_user.c

40

if (map_fd < 0) {

samples/bpf/spintest_user.c

58

while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {

samples/bpf/spintest_user.c

59

bpf_map_lookup_elem(map_fd, &next_key, &value);

samples/bpf/spintest_user.c

73

while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0)

samples/bpf/spintest_user.c

74

bpf_map_delete_elem(map_fd, &next_key);

samples/bpf/test_lru_dist.c

102

lru->map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL,

samples/bpf/test_lru_dist.c

106

assert(lru->map_fd != -1);

samples/bpf/test_lru_dist.c

119

close(lru->map_fd);

samples/bpf/test_lru_dist.c

130

if (!bpf_map_lookup_elem(lru->map_fd, &key, &node)) {

samples/bpf/test_lru_dist.c

147

bpf_map_update_elem(lru->map_fd, &node->key, &null_node, BPF_EXIST);

samples/bpf/test_lru_dist.c

155

assert(!bpf_map_update_elem(lru->map_fd, &key, &node, BPF_EXIST));

samples/bpf/test_lru_dist.c

158

assert(!bpf_map_update_elem(lru->map_fd, &key, &node, BPF_NOEXIST));

samples/bpf/test_lru_dist.c

207

int map_fd;

samples/bpf/test_lru_dist.c

209

map_fd = bpf_map_create(map_type, NULL, sizeof(unsigned long long),

samples/bpf/test_lru_dist.c

212

if (map_fd == -1)

samples/bpf/test_lru_dist.c

215

return map_fd;

samples/bpf/test_lru_dist.c

338

int map_fd;

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

350

assert(map_fd != -1);

samples/bpf/test_lru_dist.c

357

assert(bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST) == 0);

samples/bpf/test_lru_dist.c

363

bpf_map_lookup_elem(map_fd, &start_key, value);

samples/bpf/test_lru_dist.c

369

if (bpf_map_lookup_elem(map_fd, &key, value)) {

samples/bpf/test_lru_dist.c

379

close(map_fd);

samples/bpf/test_lru_dist.c

389

int map_fd;

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

402

assert(map_fd != -1);

samples/bpf/test_lru_dist.c

407

assert(!bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST));

samples/bpf/test_lru_dist.c

410

if (bpf_map_lookup_elem(map_fd, &key, value))

samples/bpf/test_lru_dist.c

414

close(map_fd);

samples/bpf/test_lru_dist.c

424

int map_fd = *(int *)data;

samples/bpf/test_lru_dist.c

435

assert(bpf_map_update_elem(map_fd, &next_ins_key, value,

samples/bpf/test_lru_dist.c

447

bpf_map_lookup_elem(map_fd, &key, value);

samples/bpf/test_lru_dist.c

449

bpf_map_update_elem(map_fd, &next_ins_key, value,

samples/bpf/test_lru_dist.c

457

if (bpf_map_lookup_elem(map_fd, &key, value))

samples/bpf/test_lru_dist.c

467

int map_fd;

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

480

assert(map_fd != -1);

samples/bpf/test_lru_dist.c

482

run_parallel(nr_tasks, do_test_parallel_lru_loss, &map_fd);

samples/bpf/test_lru_dist.c

484

close(map_fd);

samples/bpf/test_lru_dist.c

96

int map_fd;

samples/bpf/test_map_in_map_user.c

142

map_fd[0] = bpf_object__find_map_fd_by_name(obj, "port_a");

samples/bpf/test_map_in_map_user.c

143

map_fd[1] = bpf_object__find_map_fd_by_name(obj, "port_h");

samples/bpf/test_map_in_map_user.c

144

map_fd[2] = bpf_object__find_map_fd_by_name(obj, "reg_result_h");

samples/bpf/test_map_in_map_user.c

145

map_fd[3] = bpf_object__find_map_fd_by_name(obj, "inline_result_h");

samples/bpf/test_map_in_map_user.c

146

map_fd[4] = bpf_object__find_map_fd_by_name(obj, "a_of_port_a");

samples/bpf/test_map_in_map_user.c

147

map_fd[5] = bpf_object__find_map_fd_by_name(obj, "h_of_port_a");

samples/bpf/test_map_in_map_user.c

148

map_fd[6] = bpf_object__find_map_fd_by_name(obj, "h_of_port_h");

samples/bpf/test_map_in_map_user.c

149

if (map_fd[0] < 0 || map_fd[1] < 0 || map_fd[2] < 0 ||

samples/bpf/test_map_in_map_user.c

150

map_fd[3] < 0 || map_fd[4] < 0 || map_fd[5] < 0 || map_fd[6] < 0) {

samples/bpf/test_map_in_map_user.c

17

static int map_fd[7];

samples/bpf/test_map_in_map_user.c

19

#define PORT_A (map_fd[0])

samples/bpf/test_map_in_map_user.c

20

#define PORT_H (map_fd[1])

samples/bpf/test_map_in_map_user.c

21

#define REG_RESULT_H (map_fd[2])

samples/bpf/test_map_in_map_user.c

22

#define INLINE_RESULT_H (map_fd[3])

samples/bpf/test_map_in_map_user.c

23

#define A_OF_PORT_A (map_fd[4]) /* Test case #0 */

samples/bpf/test_map_in_map_user.c

24

#define H_OF_PORT_A (map_fd[5]) /* Test case #1 */

samples/bpf/test_map_in_map_user.c

25

#define H_OF_PORT_H (map_fd[6]) /* Test case #2 */

samples/bpf/trace_event_user.c

105

int error = 1, fd = map_fd[0], stack_map = map_fd[1];

samples/bpf/trace_event_user.c

23

static int map_fd[2];

samples/bpf/trace_event_user.c

330

map_fd[0] = bpf_object__find_map_fd_by_name(obj, "counts");

samples/bpf/trace_event_user.c

331

map_fd[1] = bpf_object__find_map_fd_by_name(obj, "stackmap");

samples/bpf/trace_event_user.c

332

if (map_fd[0] < 0 || map_fd[1] < 0) {

samples/bpf/trace_event_user.c

68

if (bpf_map_lookup_elem(map_fd[1], &key->kernstack, ip) != 0) {

samples/bpf/trace_event_user.c

75

if (bpf_map_lookup_elem(map_fd[1], &key->userstack, ip) != 0) {

samples/bpf/trace_output_user.c

50

int map_fd, ret = 0;

samples/bpf/trace_output_user.c

67

map_fd = bpf_object__find_map_fd_by_name(obj, "my_map");

samples/bpf/trace_output_user.c

68

if (map_fd < 0) {

samples/bpf/trace_output_user.c

86

pb = perf_buffer__new(map_fd, 8, print_bpf_output, NULL, NULL, NULL);

samples/bpf/tracex3_user.c

113

int map_fd, i, j = 0;

samples/bpf/tracex3_user.c

141

map_fd = bpf_object__find_map_fd_by_name(obj, "lat_map");

samples/bpf/tracex3_user.c

142

if (map_fd < 0) {

samples/bpf/tracex3_user.c

173

print_hist(map_fd);

samples/bpf/tracex4_user.c

54

int map_fd, j = 0;

samples/bpf/tracex4_user.c

69

map_fd = bpf_object__find_map_fd_by_name(obj, "my_map");

samples/bpf/tracex4_user.c

70

if (map_fd < 0) {

samples/bpf/tracex4_user.c

86

print_old_objects(map_fd);

samples/bpf/tracex6_user.c

196

map_fd[0] = bpf_object__find_map_fd_by_name(obj, "counters");

samples/bpf/tracex6_user.c

197

map_fd[1] = bpf_object__find_map_fd_by_name(obj, "values");

samples/bpf/tracex6_user.c

198

map_fd[2] = bpf_object__find_map_fd_by_name(obj, "values2");

samples/bpf/tracex6_user.c

199

if (map_fd[0] < 0 || map_fd[1] < 0 || map_fd[2] < 0) {

samples/bpf/tracex6_user.c

23

static int map_fd[3];

samples/bpf/tracex6_user.c

43

assert(bpf_map_update_elem(map_fd[0], &cpu, &pmu_fd, BPF_ANY) == 0);

samples/bpf/tracex6_user.c

46

bpf_map_get_next_key(map_fd[1], &cpu, NULL);

samples/bpf/tracex6_user.c

48

if (bpf_map_lookup_elem(map_fd[1], &cpu, &value)) {

samples/bpf/tracex6_user.c

56

if (bpf_map_lookup_elem(map_fd[2], &cpu, &value2)) {

samples/bpf/tracex6_user.c

66

assert(bpf_map_delete_elem(map_fd[0], &cpu) == 0 || error);

samples/bpf/tracex6_user.c

69

assert(bpf_map_delete_elem(map_fd[1], &cpu) == 0 || error);

samples/bpf/xdp_adjust_tail_user.c

164

map_fd = bpf_object__find_map_fd_by_name(obj, "xdp_adju.data");

samples/bpf/xdp_adjust_tail_user.c

165

if (map_fd < 0) {

samples/bpf/xdp_adjust_tail_user.c

169

bpf_map_update_elem(map_fd, &key, &max_pckt_size, BPF_ANY);

samples/bpf/xdp_adjust_tail_user.c

173

map_fd = bpf_object__find_map_fd_by_name(obj, "icmpcnt");

samples/bpf/xdp_adjust_tail_user.c

174

if (map_fd < 0) {

samples/bpf/xdp_adjust_tail_user.c

194

poll_stats(map_fd, kill_after_s);

samples/bpf/xdp_adjust_tail_user.c

52

static void poll_stats(unsigned int map_fd, unsigned int kill_after_s)

samples/bpf/xdp_adjust_tail_user.c

62

assert(bpf_map_lookup_elem(map_fd, &key, &value) == 0);

samples/bpf/xdp_adjust_tail_user.c

89

int i, prog_fd, map_fd, opt;

samples/bpf/xdp_fwd_user.c

125

int prog_fd = -1, map_fd = -1;

samples/bpf/xdp_fwd_user.c

197

map_fd = bpf_map__fd(bpf_object__find_map_by_name(obj,

samples/bpf/xdp_fwd_user.c

199

if (map_fd < 0) {

samples/bpf/xdp_fwd_user.c

200

printf("map not found: %s\n", strerror(map_fd));

samples/bpf/xdp_fwd_user.c

219

err = do_attach(idx, prog_fd, map_fd, argv[i]);

samples/bpf/xdp_fwd_user.c

32

static int do_attach(int idx, int prog_fd, int map_fd, const char *name)

samples/bpf/xdp_fwd_user.c

43

err = bpf_map_update_elem(map_fd, &idx, &idx, 0);

samples/bpf/xdp_sample_user.c

380

static int map_collect_percpu_devmap(int map_fd, struct stats_record *rec)

samples/bpf/xdp_sample_user.c

401

ret = bpf_map_lookup_batch(map_fd, init ? &batch : NULL, &batch,

tools/bpf/bpftool/iter.c

22

int err = -1, map_fd = -1;

tools/bpf/bpftool/iter.c

40

map_fd = map_parse_fd(&argc, &argv, BPF_F_RDONLY);

tools/bpf/bpftool/iter.c

41

if (map_fd < 0)

tools/bpf/bpftool/iter.c

45

linfo.map.map_fd = map_fd;

tools/bpf/bpftool/iter.c

95

if (map_fd >= 0)

tools/bpf/bpftool/iter.c

96

close(map_fd);

tools/bpf/bpftool/map_perf_ring.c

128

int err, map_fd;

tools/bpf/bpftool/map_perf_ring.c

131

map_fd = map_parse_fd_and_info(&argc, &argv, &map_info, &map_info_len,

tools/bpf/bpftool/map_perf_ring.c

133

if (map_fd < 0)

tools/bpf/bpftool/map_perf_ring.c

190

pb = perf_buffer__new_raw(map_fd, MMAP_PAGE_CNT, &perf_attr,

tools/bpf/bpftool/map_perf_ring.c

218

close(map_fd);

tools/bpf/bpftool/map_perf_ring.c

225

close(map_fd);

tools/bpf/bpftool/prog.c

229

int map_fd;

tools/bpf/bpftool/prog.c

2364

static int profile_open_perf_event(int mid, int cpu, int map_fd)

tools/bpf/bpftool/prog.c

2380

if (bpf_map_update_elem(map_fd,

tools/bpf/bpftool/prog.c

2395

int map_fd;

tools/bpf/bpftool/prog.c

2404

map_fd = bpf_map__fd(obj->maps.events);

tools/bpf/bpftool/prog.c

2405

if (map_fd < 0) {

tools/bpf/bpftool/prog.c

2414

if (profile_open_perf_event(m, cpu, map_fd)) {

tools/bpf/bpftool/prog.c

257

map_fd = bpf_map_get_fd_by_id(map_ids[i]);

tools/bpf/bpftool/prog.c

258

if (map_fd < 0)

tools/bpf/bpftool/prog.c

263

ret = bpf_map_get_info_by_fd(map_fd, map_info, &map_info_len);

tools/bpf/bpftool/prog.c

265

close(map_fd);

tools/bpf/bpftool/prog.c

274

close(map_fd);

tools/bpf/bpftool/prog.c

280

close(map_fd);

tools/bpf/bpftool/prog.c

284

if (bpf_map_lookup_elem(map_fd, &key, value)) {

tools/bpf/bpftool/prog.c

285

close(map_fd);

tools/bpf/bpftool/prog.c

291

close(map_fd);

tools/include/uapi/linux/bpf.h

134

__u32 map_fd;

tools/include/uapi/linux/bpf.h

1560

__u32 map_fd;

tools/include/uapi/linux/bpf.h

1581

__u32 map_fd;

tools/include/uapi/linux/bpf.h

1791

__u32 map_fd; /* struct_ops to attach */

tools/include/uapi/linux/bpf.h

1903

__u32 map_fd;

tools/include/uapi/linux/bpf.h

1920

__u32 map_fd;

tools/lib/bpf/bpf.c

1213

int bpf_map_get_info_by_fd(int map_fd, struct bpf_map_info *info, __u32 *info_len)

tools/lib/bpf/bpf.c

1215

return bpf_obj_get_info_by_fd(map_fd, info, info_len);

tools/lib/bpf/bpf.c

1346

int bpf_prog_bind_map(int prog_fd, int map_fd,

tools/lib/bpf/bpf.c

1358

attr.prog_bind_map.map_fd = map_fd;

tools/lib/bpf/bpf.c

1402

int bpf_prog_assoc_struct_ops(int prog_fd, int map_fd,

tools/lib/bpf/bpf.c

1413

attr.prog_assoc_struct_ops.map_fd = map_fd;

tools/lib/bpf/bpf.c

398

attr.map_fd = fd;

tools/lib/bpf/bpf.c

414

attr.map_fd = fd;

tools/lib/bpf/bpf.c

429

attr.map_fd = fd;

tools/lib/bpf/bpf.c

445

attr.map_fd = fd;

tools/lib/bpf/bpf.c

460

attr.map_fd = fd;

tools/lib/bpf/bpf.c

476

attr.map_fd = fd;

tools/lib/bpf/bpf.c

490

attr.map_fd = fd;

tools/lib/bpf/bpf.c

505

attr.map_fd = fd;

tools/lib/bpf/bpf.c

515

const size_t attr_sz = offsetofend(union bpf_attr, map_fd);

tools/lib/bpf/bpf.c

520

attr.map_fd = fd;

tools/lib/bpf/bpf.c

539

attr.batch.map_fd = fd;

tools/lib/bpf/bpf.h

563

LIBBPF_API int bpf_map_get_info_by_fd(int map_fd, struct bpf_map_info *info, __u32 *info_len);

tools/lib/bpf/bpf.h

670

LIBBPF_API int bpf_prog_bind_map(int prog_fd, int map_fd,

tools/lib/bpf/bpf.h

762

LIBBPF_API int bpf_prog_assoc_struct_ops(int prog_fd, int map_fd,

tools/lib/bpf/features.c

512

int prog_fd, map_fd;

tools/lib/bpf/features.c

530

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "arr", sizeof(int), 1, 1, &map_opts);

tools/lib/bpf/features.c

531

if (map_fd < 0) {

tools/lib/bpf/features.c

537

insns[0].imm = map_fd;

tools/lib/bpf/features.c

543

close(map_fd);

tools/lib/bpf/gen_loader.c

1198

move_blob2blob(gen, attr_field(map_update_attr, map_fd), 4,

tools/lib/bpf/gen_loader.c

1224

move_blob2blob(gen, attr_field(map_update_attr, map_fd), 4,

tools/lib/bpf/gen_loader.c

1239

int attr_size = offsetofend(union bpf_attr, map_fd);

tools/lib/bpf/gen_loader.c

1247

move_blob2blob(gen, attr_field(map_freeze_attr, map_fd), 4,

tools/lib/bpf/gen_loader.c

397

offsetof(struct bpf_map_desc, map_fd), 4,

tools/lib/bpf/libbpf.c

13196

bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd)

tools/lib/bpf/libbpf.c

13198

return bpf_program_attach_fd(prog, map_fd, "sockmap", NULL);

tools/lib/bpf/libbpf.c

13457

int map_fd;

tools/lib/bpf/libbpf.c

13467

if (st_link->map_fd < 0)

tools/lib/bpf/libbpf.c

13511

link->map_fd = -1;

tools/lib/bpf/libbpf.c

13522

link->map_fd = map->fd;

tools/lib/bpf/libbpf.c

13546

if (st_ops_link->map_fd < 0)

tools/lib/bpf/libbpf.c

13562

st_ops_link->map_fd = map->fd;

tools/lib/bpf/libbpf.c

13687

bpf_map_delete_elem(pb->map_fd, &cpu_buf->map_key);

tools/lib/bpf/libbpf.c

13747

static struct perf_buffer *__perf_buffer__new(int map_fd, size_t page_cnt,

tools/lib/bpf/libbpf.c

13750

struct perf_buffer *perf_buffer__new(int map_fd, size_t page_cnt,

tools/lib/bpf/libbpf.c

13780

return libbpf_ptr(__perf_buffer__new(map_fd, page_cnt, &p));

tools/lib/bpf/libbpf.c

13783

struct perf_buffer *perf_buffer__new_raw(int map_fd, size_t page_cnt,

tools/lib/bpf/libbpf.c

13803

return libbpf_ptr(__perf_buffer__new(map_fd, page_cnt, &p));

tools/lib/bpf/libbpf.c

13806

static struct perf_buffer *__perf_buffer__new(int map_fd, size_t page_cnt,

tools/lib/bpf/libbpf.c

13825

err = bpf_map_get_info_by_fd(map_fd, &map, &map_info_len);

tools/lib/bpf/libbpf.c

13833

map_fd, errstr(err));

tools/lib/bpf/libbpf.c

13837

map_fd);

tools/lib/bpf/libbpf.c

13857

pb->map_fd = map_fd;

tools/lib/bpf/libbpf.c

13919

err = bpf_map_update_elem(pb->map_fd, &map_key,

tools/lib/bpf/libbpf.c

14172

int prog_fd, map_fd;

tools/lib/bpf/libbpf.c

14186

map_fd = bpf_map__fd(map);

tools/lib/bpf/libbpf.c

14187

if (map_fd < 0) {

tools/lib/bpf/libbpf.c

14197

return bpf_prog_assoc_struct_ops(prog_fd, map_fd, opts);

tools/lib/bpf/libbpf.c

5166

static bool map_is_reuse_compat(const struct bpf_map *map, int map_fd)

tools/lib/bpf/libbpf.c

5173

err = bpf_map_get_info_by_fd(map_fd, &map_info, &map_info_len);

tools/lib/bpf/libbpf.c

5175

err = bpf_get_map_info_from_fdinfo(map_fd, &map_info);

tools/lib/bpf/libbpf.c

5177

pr_warn("failed to get map info for map FD %d: %s\n", map_fd,

tools/lib/bpf/libbpf.c

5312

int err = 0, map_fd;

tools/lib/bpf/libbpf.c

5401

map_fd = map->fd;

tools/lib/bpf/libbpf.c

5403

map_fd = bpf_map_create(def->type, map_name,

tools/lib/bpf/libbpf.c

5407

if (map_fd < 0 && (create_attr.btf_key_type_id || create_attr.btf_value_type_id)) {

tools/lib/bpf/libbpf.c

5416

map_fd = bpf_map_create(def->type, map_name,

tools/lib/bpf/libbpf.c

5428

if (map_fd < 0)

tools/lib/bpf/libbpf.c

5429

return map_fd;

tools/lib/bpf/libbpf.c

5432

if (map->fd == map_fd)

tools/lib/bpf/libbpf.c

5440

return reuse_fd(map->fd, map_fd);

tools/lib/bpf/libbpf.c

6217

static int add_jt_map(struct bpf_object *obj, struct bpf_program *prog, unsigned int sym_off, int map_fd)

tools/lib/bpf/libbpf.c

6230

obj->jumptable_maps[cnt].fd = map_fd;

tools/lib/bpf/libbpf.c

6257

int map_fd, err;

tools/lib/bpf/libbpf.c

6262

map_fd = find_jt_map(obj, prog, sym_off);

tools/lib/bpf/libbpf.c

6263

if (map_fd >= 0)

tools/lib/bpf/libbpf.c

6264

return map_fd;

tools/lib/bpf/libbpf.c

6278

map_fd = bpf_map_create(BPF_MAP_TYPE_INSN_ARRAY, ".jumptables",

tools/lib/bpf/libbpf.c

6280

if (map_fd < 0)

tools/lib/bpf/libbpf.c

6281

return map_fd;

tools/lib/bpf/libbpf.c

6330

err = bpf_map_update_elem(map_fd, &i, &val, 0);

tools/lib/bpf/libbpf.c

6335

err = bpf_map_freeze(map_fd);

tools/lib/bpf/libbpf.c

6339

err = add_jt_map(obj, prog, sym_off, map_fd);

tools/lib/bpf/libbpf.c

6343

return map_fd;

tools/lib/bpf/libbpf.c

6346

close(map_fd);

tools/lib/bpf/libbpf.c

6446

int map_fd;

tools/lib/bpf/libbpf.c

6448

map_fd = create_jt_map(obj, prog, relo);

tools/lib/bpf/libbpf.c

6449

if (map_fd < 0) {

tools/lib/bpf/libbpf.c

6452

return map_fd;

tools/lib/bpf/libbpf.c

6455

insn->imm = map_fd;

tools/lib/bpf/libbpf.h

1426

ring_buffer__new(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx,

tools/lib/bpf/libbpf.h

1429

LIBBPF_API int ring_buffer__add(struct ring_buffer *rb, int map_fd,

tools/lib/bpf/libbpf.h

1535

user_ring_buffer__new(int map_fd, const struct user_ring_buffer_opts *opts);

tools/lib/bpf/libbpf.h

1660

perf_buffer__new(int map_fd, size_t page_cnt,

tools/lib/bpf/libbpf.h

853

bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd);

tools/lib/bpf/ringbuf.c

117

r->map_fd = map_fd;

tools/lib/bpf/ringbuf.c

123

tmp = mmap(NULL, rb->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, map_fd, 0);

tools/lib/bpf/ringbuf.c

127

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

142

tmp = mmap(NULL, (size_t)mmap_sz, PROT_READ, MAP_SHARED, map_fd, rb->page_size);

tools/lib/bpf/ringbuf.c

146

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

157

if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, e) < 0) {

tools/lib/bpf/ringbuf.c

160

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

190

ring_buffer__new(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx,

tools/lib/bpf/ringbuf.c

212

err = ring_buffer__add(rb, map_fd, sample_cb, ctx);

tools/lib/bpf/ringbuf.c

32

int map_fd;

tools/lib/bpf/ringbuf.c

403

return r->map_fd;

tools/lib/bpf/ringbuf.c

447

static int user_ringbuf_map(struct user_ring_buffer *rb, int map_fd)

tools/lib/bpf/ringbuf.c

458

err = bpf_map_get_info_by_fd(map_fd, &info, &len);

tools/lib/bpf/ringbuf.c

462

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

467

pr_warn("user ringbuf: map fd=%d is not BPF_MAP_TYPE_USER_RINGBUF\n", map_fd);

tools/lib/bpf/ringbuf.c

471

rb->map_fd = map_fd;

tools/lib/bpf/ringbuf.c

475

tmp = mmap(NULL, rb->page_size, PROT_READ, MAP_SHARED, map_fd, 0);

tools/lib/bpf/ringbuf.c

479

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

495

map_fd, rb->page_size);

tools/lib/bpf/ringbuf.c

499

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

50

int map_fd;

tools/lib/bpf/ringbuf.c

508

if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, rb_epoll) < 0) {

tools/lib/bpf/ringbuf.c

510

pr_warn("user ringbuf: failed to epoll add map fd=%d: %s\n", map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

518

user_ring_buffer__new(int map_fd, const struct user_ring_buffer_opts *opts)

tools/lib/bpf/ringbuf.c

539

err = user_ringbuf_map(rb, map_fd);

tools/lib/bpf/ringbuf.c

75

int ring_buffer__add(struct ring_buffer *rb, int map_fd,

tools/lib/bpf/ringbuf.c

88

err = bpf_map_get_info_by_fd(map_fd, &info, &len);

tools/lib/bpf/ringbuf.c

92

map_fd, errstr(err));

tools/lib/bpf/ringbuf.c

98

map_fd);

tools/lib/bpf/skel_internal.h

261

attr.map_fd = fd;

tools/lib/bpf/skel_internal.h

275

attr.map_fd = fd;

tools/lib/bpf/skel_internal.h

339

const size_t attr_sz = offsetofend(union bpf_attr, map_fd);

tools/lib/bpf/skel_internal.h

343

attr.map_fd = fd;

tools/lib/bpf/skel_internal.h

357

int map_fd = -1, prog_fd = -1, key = 0, err;

tools/lib/bpf/skel_internal.h

360

err = map_fd = skel_map_create(BPF_MAP_TYPE_ARRAY, "__loader.map", 4, opts->data_sz, 1,

tools/lib/bpf/skel_internal.h

362

if (map_fd < 0) {

tools/lib/bpf/skel_internal.h

368

err = skel_map_update_elem(map_fd, &key, opts->data, 0);

tools/lib/bpf/skel_internal.h

376

err = skel_map_freeze(map_fd);

tools/lib/bpf/skel_internal.h

382

err = skel_obj_get_info_by_fd(map_fd);

tools/lib/bpf/skel_internal.h

404

attr.fd_array = (long) &map_fd;

tools/lib/bpf/skel_internal.h

436

if (map_fd >= 0)

tools/lib/bpf/skel_internal.h

437

close(map_fd);

tools/lib/bpf/skel_internal.h

44

int map_fd;

tools/perf/util/bpf-event.c

185

int map_fd;

tools/perf/util/bpf-event.c

195

map_fd = bpf_map_get_fd_by_id(map_id);

tools/perf/util/bpf-event.c

196

if (map_fd < 0)

tools/perf/util/bpf-event.c

201

if (bpf_obj_get_info_by_fd(map_fd, &map_info, &map_info_len) < 0)

tools/perf/util/bpf-event.c

241

if (bpf_map_lookup_elem(map_fd, &key, rodata)) {

tools/perf/util/bpf-event.c

245

close(map_fd);

tools/perf/util/bpf-event.c

257

close(map_fd);

tools/perf/util/bpf_counter.c

380

int map_fd, err;

tools/perf/util/bpf_counter.c

390

map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL,

tools/perf/util/bpf_counter.c

394

if (map_fd < 0)

tools/perf/util/bpf_counter.c

397

err = bpf_obj_pin(map_fd, path);

tools/perf/util/bpf_counter.c

400

close(map_fd);

tools/perf/util/bpf_counter.c

401

map_fd = bpf_obj_get(path);

tools/perf/util/bpf_counter.c

402

if (map_fd < 0)

tools/perf/util/bpf_counter.c

406

map_fd = bpf_obj_get(path);

tools/perf/util/bpf_counter.c

407

if (map_fd < 0)

tools/perf/util/bpf_counter.c

411

if (!bperf_attr_map_compatible(map_fd)) {

tools/perf/util/bpf_counter.c

412

close(map_fd);

tools/perf/util/bpf_counter.c

416

err = flock(map_fd, LOCK_EX);

tools/perf/util/bpf_counter.c

418

close(map_fd);

tools/perf/util/bpf_counter.c

421

return map_fd;

tools/perf/util/bpf_counter_cgroup.c

104

int map_fd, prog_fd, err;

tools/perf/util/bpf_counter_cgroup.c

157

map_fd = bpf_map__fd(skel->maps.events);

tools/perf/util/bpf_counter_cgroup.c

162

bpf_map_update_elem(map_fd, &idx, &fd, BPF_ANY);

tools/perf/util/bpf_counter_cgroup.c

178

map_fd = bpf_map__fd(skel->maps.cgrp_idx);

tools/perf/util/bpf_counter_cgroup.c

179

err = bpf_map_update_elem(map_fd, &cgrp->id, &i, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

442

static void update_lock_stat(int map_fd, int pid, u64 end_ts,

tools/perf/util/bpf_lock_contention.c

472

if (bpf_map_lookup_elem(map_fd, &stat_key, &stat_data) < 0)

tools/perf/util/bpf_lock_contention.c

483

bpf_map_update_elem(map_fd, &stat_key, &stat_data, BPF_EXIST);

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

40

int map_fd, i, max_entries;

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

59

map_fd = bpf_map__fd(ctx.skel->maps.hash_map_bench);

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

62

bpf_map_update_elem(map_fd, &i, &i, BPF_ANY);

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

154

int map_fd;

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

187

map_fd = bpf_map__fd(ctx.skel->maps.hash_map_bench);

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

190

bpf_map_update_elem(map_fd, ctx.skel->bss->key, &i, BPF_ANY);

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

151

static void fill_map(int map_fd)

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

160

err = bpf_map_update_batch(map_fd, keys, vals, &args.nr_entries, &opts);

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

168

static void empty_map(int map_fd)

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

177

err = bpf_map_delete_batch(map_fd, keys, &args.nr_entries, &opts);

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

225

int map_fd;

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

229

map_fd = bpf_map__fd(ctx->skel->maps.ringbuf);

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

230

ctx->ringbuf = ring_buffer__new(map_fd, buf_process_sample, NULL, NULL);

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

261

int map_fd;

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

297

r->map_fd = bpf_map__fd(ctx->skel->maps.ringbuf);

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

302

r->map_fd, 0);

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

311

r->map_fd, page_size);

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

320

err = epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, r->map_fd, &ctx->event);

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

525

int map_fd; /* BPF_MAP_TYPE_PERF_EVENT_ARRAY BPF map FD */

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

101

map_batch_update(map_fd, max_entries, keys, values, is_pcpu);

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

112

err = bpf_map_lookup_batch(map_fd,

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

141

close(map_fd);

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

15

static void map_batch_update(int map_fd, __u32 max_entries, int *keys,

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

36

err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);

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

72

int map_fd, *keys, *visited;

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

83

map_fd = bpf_map_create(is_pcpu ? BPF_MAP_TYPE_PERCPU_ARRAY : BPF_MAP_TYPE_ARRAY,

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

85

CHECK(map_fd == -1,

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

109

err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,

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

115

map_batch_update(map_fd, max_entries, keys, values, is_pcpu);

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

119

err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,

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

127

err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,

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

136

err = bpf_map_get_next_key(map_fd, NULL, &key);

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

14

static void map_batch_update(int map_fd, __u32 max_entries, int *keys,

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

142

map_batch_update(map_fd, max_entries, keys, values, is_pcpu);

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

152

err = bpf_map_lookup_batch(map_fd,

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

188

err = bpf_map_delete_batch(map_fd,

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

201

err = bpf_map_get_next_key(map_fd, NULL, &key);

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

208

map_batch_update(map_fd, max_entries, keys, values, is_pcpu);

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

215

err = bpf_map_lookup_and_delete_batch(map_fd,

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

246

err = bpf_map_get_next_key(map_fd, NULL, &key);

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

259

close(map_fd);

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

37

err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);

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

81

int map_fd, *keys, *visited, key;

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

92

map_fd = bpf_map_create(is_pcpu ? BPF_MAP_TYPE_PERCPU_HASH : BPF_MAP_TYPE_HASH,

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

94

CHECK(map_fd == -1,

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

446

int map_fd;

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

452

map_fd = bpf_map_create(BPF_MAP_TYPE_LPM_TRIE, NULL,

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

455

assert(map_fd >= 0);

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

472

assert(bpf_map_update_elem(map_fd, key, &value, 0) == 0);

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

477

assert(bpf_map_update_elem(map_fd, key, &value, 0) == 0);

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

482

assert(bpf_map_update_elem(map_fd, key, &value, 0) == 0);

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

487

assert(bpf_map_update_elem(map_fd, key, &value, 0) == 0);

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

492

assert(bpf_map_lookup_elem(map_fd, key, &value) == -ENOENT);

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

496

assert(bpf_map_delete_elem(map_fd, key) == -ENOENT);

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

500

assert(bpf_map_delete_elem(map_fd, key) == -ENOENT);

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

505

assert(bpf_map_lookup_elem(map_fd, key, &value) == 0);

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

511

assert(bpf_map_delete_elem(map_fd, key) == 0);

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

515

assert(bpf_map_lookup_elem(map_fd, key, &value) == 0);

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

521

assert(bpf_map_delete_elem(map_fd, key) == 0);

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

525

assert(bpf_map_lookup_elem(map_fd, key, &value) == 0);

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

531

assert(bpf_map_delete_elem(map_fd, key) == 0);

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

535

assert(bpf_map_lookup_elem(map_fd, key, &value) == 0);

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

541

assert(bpf_map_delete_elem(map_fd, key) == 0);

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

545

assert(bpf_map_lookup_elem(map_fd, key, &value) == -ENOENT);

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

547

close(map_fd);

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

556

int map_fd;

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

562

map_fd = bpf_map_create(BPF_MAP_TYPE_LPM_TRIE, NULL, key_size, sizeof(value), 100, &opts);

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

563

assert(map_fd >= 0);

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

566

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == -ENOENT);

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

571

assert(bpf_map_update_elem(map_fd, key_p, &value, 0) == 0);

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

574

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == 0);

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

578

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == -ENOENT);

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

582

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == 0);

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

589

assert(bpf_map_update_elem(map_fd, key_p, &value, 0) == 0);

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

592

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == 0);

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

597

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

602

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == -ENOENT);

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

607

assert(bpf_map_update_elem(map_fd, key_p, &value, 0) == 0);

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

610

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == 0);

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

615

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

620

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

625

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == -ENOENT);

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

630

assert(bpf_map_update_elem(map_fd, key_p, &value, 0) == 0);

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

633

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == 0);

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

638

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

643

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

648

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

653

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == -ENOENT);

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

658

assert(bpf_map_update_elem(map_fd, key_p, &value, 0) == 0);

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

661

assert(bpf_map_get_next_key(map_fd, NULL, key_p) == 0);

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

666

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

672

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

677

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

682

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

687

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == -ENOENT);

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

692

assert(bpf_map_get_next_key(map_fd, key_p, next_key_p) == 0);

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

696

close(map_fd);

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

703

int map_fd;

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

729

assert(bpf_map_update_elem(info->map_fd, key_p, &value, 0) == 0);

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

731

ret = bpf_map_delete_elem(info->map_fd, key_p);

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

735

ret = bpf_map_lookup_elem(info->map_fd, key_p, &value);

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

739

ret = bpf_map_get_next_key(info->map_fd, key_p, next_key_p);

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

748

static void setup_lpm_mt_test_info(struct lpm_mt_test_info *info, int map_fd)

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

751

info->map_fd = map_fd;

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

768

int i, map_fd;

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

774

map_fd = bpf_map_create(BPF_MAP_TYPE_LPM_TRIE, NULL, key_size, value_size, 100, &opts);

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

777

setup_lpm_mt_test_info(&info[0], map_fd);

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

788

close(map_fd);

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

105

err = bpf_map_lookup_batch(map_fd,

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

127

err = bpf_map_delete_batch(map_fd, keys + total, &count,

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

139

err = bpf_map_get_next_key(map_fd, NULL, &key);

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

154

close(map_fd);

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

22

static void map_batch_update(int map_fd, __u32 max_entries,

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

40

err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);

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

70

int map_fd, *values, *visited;

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

80

map_fd = bpf_map_create(BPF_MAP_TYPE_LPM_TRIE, "lpm_trie_map",

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

83

CHECK(map_fd == -1, "bpf_map_create()", "error:%s\n",

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

94

map_batch_update(map_fd, max_entries, keys, values);

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

108

close(map_fd);

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

27

int map_fd;

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

41

bpf_map_get_next_key(ctx->map_fd, &ctx->key, &next_key);

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

67

int map_fd;

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

75

map_fd = bpf_map_create(BPF_MAP_TYPE_LPM_TRIE, "lpm_trie_map",

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

78

CHECK(map_fd == -1, "bpf_map_create()", "error:%s\n",

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

83

err = bpf_map_update_elem(map_fd, &key, &val, BPF_ANY);

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

90

ctx.map_fd = map_fd;

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

15

static __u32 get_map_id_from_fd(int map_fd)

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

21

ret = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);

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

34

int map_fd, map_index, ret;

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

41

map_fd = bpf_map_create(map_type, map_name, sizeof(__u32),

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

43

CHECK(map_fd < 0,

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

51

inner_map_fds[map_index] = map_fd;

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

57

map_id = get_map_id_from_fd(map_fd);

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

58

ret = bpf_map_update_elem(map_fd, &map_key, &map_id, 0);

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

100

for (n = 0; !bpf_map_get_next_key(map_fd, &key, &key); n++)

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

108

delete_and_lookup_batch(map_fd, keys, n);

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

115

ret = bpf_map_delete_elem(map_fd, keyp);

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

119

ret = bpf_map_lookup_and_delete_elem(map_fd, keyp, val);

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

143

int map_fd;

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

150

int map_fd;

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

152

map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, "small", 4, 4, 4, NULL);

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

153

CHECK(map_fd < 0, "bpf_map_create()", "error:%s (name=%s)\n",

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

156

return map_fd;

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

187

ret = map_update_retriable(opts->map_fd, &i, val_ptr, 0,

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

190

ret = bpf_map_update_elem(opts->map_fd, &i, val_ptr, 0);

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

22

static void map_info(int map_fd, struct bpf_map_info *info)

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

264

static void check_expected_number_elements(__u32 n_inserted, int map_fd,

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

273

n_real = map_count_elements(info->type, map_fd);

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

29

ret = bpf_obj_get_info_by_fd(map_fd, info, &len);

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

292

static void __test(int map_fd)

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

295

.map_fd = map_fd,

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

299

map_info(map_fd, &info);

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

324

check_expected_number_elements(opts.n, map_fd, &info);

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

325

delete_all_elements(info.type, map_fd, !BATCH);

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

326

check_expected_number_elements(0, map_fd, &info);

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

330

check_expected_number_elements(opts.n, map_fd, &info);

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

331

delete_all_elements(info.type, map_fd, BATCH);

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

332

check_expected_number_elements(0, map_fd, &info);

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

334

close(map_fd);

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

342

int map_fd;

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

349

map_fd = bpf_map_create(type, name, key_size, val_size, max_entries, map_opts);

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

350

CHECK(map_fd < 0, "bpf_map_create()", "error:%s (name=%s)\n",

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

353

return map_fd;

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

51

static __u32 map_count_elements(__u32 type, int map_fd)

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

56

while (!bpf_map_get_next_key(map_fd, &key, &key))

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

63

static void delete_and_lookup_batch(int map_fd, void *keys, __u32 count)

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

70

ret = bpf_map_lookup_and_delete_batch(map_fd,

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

89

static void delete_all_elements(__u32 type, int map_fd, bool batch)

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

144

int btf_fd, map_fd;

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

151

map_fd = bpf_map_create(BPF_MAP_TYPE_SK_STORAGE, "sk_storage_map", 4, 8, 0, &map_opts);

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

154

CHECK(map_fd == -1,

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

157

return map_fd;

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

166

int i, map_fd, err, *sk_fds;

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

181

map_fd = READ_ONCE(sk_storage_map);

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

189

err = bpf_map_update_elem(map_fd, &sk_fds[i], &value,

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

225

int i, map_fd = -1, err = 0, nr_threads_created = 0;

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

246

map_fd = create_sk_storage_map();

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

247

WRITE_ONCE(sk_storage_map, map_fd);

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

253

close(map_fd);

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

254

map_fd = -1;

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

271

if (map_fd != -1)

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

272

close(map_fd);

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

283

int map_fd = READ_ONCE(sk_storage_map);

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

288

err = bpf_map_update_elem(map_fd, &sk_fd, &value, 0);

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

307

int map_fd = READ_ONCE(sk_storage_map);

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

312

err = bpf_map_delete_elem(map_fd, &sk_fd);

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

331

int i, sk_fd, map_fd = -1, err = 0, nr_threads_created = 0;

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

347

map_fd = create_sk_storage_map();

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

348

WRITE_ONCE(sk_storage_map, map_fd);

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

379

close(map_fd);

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

463

int btf_fd, map_fd, sk_fd, err;

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

474

map_fd = bpf_map_create(BPF_MAP_TYPE_SK_STORAGE, "sk_storage_map", 4, 8, 0, &map_opts);

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

475

CHECK(map_fd == -1, "bpf_map_create(good_xattr)",

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

476

"map_fd:%d errno:%d\n", map_fd, errno);

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

480

err = bpf_map_update_elem(map_fd, &sk_fd, &value,

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

484

err = bpf_map_lookup_elem_flags(map_fd, &sk_fd, &lookup_value,

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

494

err = bpf_map_update_elem(map_fd, &sk_fd, &value,

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

498

err = bpf_map_lookup_elem_flags(map_fd, &sk_fd, &lookup_value,

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

508

err = bpf_map_update_elem(map_fd, &sk_fd, &value, BPF_EXIST);

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

511

err = bpf_map_lookup_elem_flags(map_fd, &sk_fd, &lookup_value,

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

521

err = bpf_map_update_elem(map_fd, &sk_fd, &value,

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

526

err = bpf_map_update_elem(map_fd, &sk_fd, &value, BPF_NOEXIST);

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

530

err = bpf_map_lookup_elem_flags(map_fd, &sk_fd, &lookup_value,

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

540

err = bpf_map_update_elem(map_fd, &sk_fd, &value, 0);

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

543

err = bpf_map_lookup_elem_flags(map_fd, &sk_fd, &lookup_value,

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

551

err = bpf_map_delete_elem(map_fd, &sk_fd);

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

554

err = bpf_map_lookup_elem_flags(map_fd, &sk_fd, &lookup_value,

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

559

err = bpf_map_delete_elem(map_fd, &sk_fd);

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

587

close(map_fd);

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

100

close(map_fd);

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

106

close(map_fd);

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

111

close(map_fd);

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

270

int map_fd, ret;

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

272

map_fd = create_jt_map(max_entries);

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

273

if (!ASSERT_GE(map_fd, 0, "create_jt_map"))

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

275

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze")) {

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

276

close(map_fd);

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

280

insns[0].imm = map_fd;

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

284

close(map_fd);

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

325

int map_fd, ret, i;

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

327

map_fd = create_jt_map(max_entries);

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

328

if (!ASSERT_GE(map_fd, 0, "create_jt_map"))

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

333

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &i, &val, 0), 0,

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

335

close(map_fd);

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

340

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze")) {

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

341

close(map_fd);

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

346

insns[0].imm = map_fd;

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

353

close(map_fd);

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

74

int prog_fd, map_fd;

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

92

map_fd = bpf_map_get_fd_by_id(map_ids[i]);

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

93

if (!ASSERT_GE(map_fd, 0, "bpf_map_get_fd_by_id"))

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

98

ret = bpf_obj_get_info_by_fd(map_fd, &map_info, &len);

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

163

int prog_fd, map_fd;

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

167

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, 1);

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

168

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

173

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &key, &val, 0), 0, "bpf_map_update_elem"))

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

176

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

179

prog_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

186

close(map_fd);

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

198

int prog_fd, map_fd;

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

202

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, 1);

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

203

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

208

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &key, &val, 0), 0, "bpf_map_update_elem"))

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

211

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

214

prog_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

221

close(map_fd);

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

275

int prog_fd = -1, map_fd;

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

280

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, ARRAY_SIZE(insns));

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

281

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

286

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &i, &val, 0), 0, "bpf_map_update_elem"))

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

29

int prog_fd = -1, map_fd, i;

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

290

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

299

prog_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

306

if (!ASSERT_EQ(bpf_map_lookup_elem(map_fd, &i, &val), 0, "bpf_map_lookup_elem"))

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

31

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, insn_cnt);

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

319

close(map_fd);

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

32

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

329

int prog_fd = -1, map_fd;

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

333

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, ARRAY_SIZE(insns));

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

334

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

339

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &i, &val, 0), 0, "bpf_map_update_elem"))

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

343

prog_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

349

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

352

prog_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

357

if (!ASSERT_EQ(bpf_map_lookup_elem(map_fd, &i, &val), 0, "bpf_map_lookup_elem"))

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

365

close(map_fd);

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

37

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &i, &val, 0), 0, "bpf_map_update_elem"))

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

375

int prog_fd = -1, map_fd, extra_fd = -1;

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

379

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, ARRAY_SIZE(insns));

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

380

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

385

if (!ASSERT_EQ(bpf_map_update_elem(map_fd, &i, &val, 0), 0, "bpf_map_update_elem"))

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

389

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

392

prog_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

397

if (!ASSERT_EQ(bpf_map_lookup_elem(map_fd, &i, &val), 0, "bpf_map_lookup_elem"))

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

403

extra_fd = prog_load(insns, ARRAY_SIZE(insns), &map_fd, 1);

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

41

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

415

close(map_fd);

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

428

int prog_fd = -1, map_fd;

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

430

map_fd = map_create(BPF_MAP_TYPE_INSN_ARRAY, 1);

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

431

if (!ASSERT_GE(map_fd, 0, "map_create"))

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

434

insns[0].imm = map_fd;

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

436

if (!ASSERT_EQ(bpf_map_freeze(map_fd), 0, "bpf_map_freeze"))

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

44

prog_fd = prog_load(insns, insn_cnt, &map_fd, 1);

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

444

close(map_fd);

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

445

map_fd = map_create(BPF_MAP_TYPE_ARRAY, 1);

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

446

insns[0].imm = map_fd;

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

453

close(map_fd);

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

51

if (!ASSERT_EQ(bpf_map_lookup_elem(map_fd, &i, &val), 0, "bpf_map_lookup_elem"))

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

60

close(map_fd);

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

1023

int err, i, map_fd, hash_fd, iter_fd;

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

1034

map_fd = bpf_map__fd(skel->maps.arraymap1);

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

1043

err = bpf_map_update_elem(map_fd, &i, &val, BPF_ANY);

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

1049

linfo.map.map_fd = map_fd;

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

1081

err = bpf_map_lookup_elem(map_fd, &i, &val);

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

1123

int err, i, j, map_fd, iter_fd;

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

1143

map_fd = bpf_map__fd(skel->maps.arraymap1);

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

1152

err = bpf_map_update_elem(map_fd, &i, val, BPF_ANY);

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

1158

linfo.map.map_fd = map_fd;

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

1196

int err, len, map_fd, iter_fd;

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

1206

map_fd = bpf_map__fd(skel->maps.sk_stg_map);

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

1212

err = bpf_map_update_elem(map_fd, &sock_fd, &val, BPF_NOEXIST);

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

1217

linfo.map.map_fd = map_fd;

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

1236

err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);

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

1265

int err, map_fd, val = -1;

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

1280

map_fd = bpf_map__fd(skel->maps.sk_stg_map);

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

1282

err = bpf_map_update_elem(map_fd, &sock_fd, &val, BPF_NOEXIST);

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

1288

err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);

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

1295

err = bpf_map_lookup_elem(map_fd, &sock_fd, &val);

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

1322

int err, i, len, map_fd, iter_fd, num_sockets;

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

1334

map_fd = bpf_map__fd(skel->maps.sk_stg_map);

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

1344

err = bpf_map_update_elem(map_fd, &sock_fd[i], &val,

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

1351

linfo.map.map_fd = map_fd;

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

1385

err = bpf_map_lookup_elem(map_fd, &sock_fd[i], &val);

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

1415

linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap1);

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

846

int err, i, len, map_fd, iter_fd;

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

869

linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap2);

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

876

linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap3);

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

88

linfo.map.map_fd = bpf_map__fd(map);

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

882

map_fd = bpf_map__fd(skel->maps.hashmap1);

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

892

err = bpf_map_update_elem(map_fd, &key, &val, BPF_ANY);

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

898

linfo.map.map_fd = map_fd;

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

903

linfo.map.map_fd = map_fd;

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

939

int err, i, j, len, map_fd, iter_fd;

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

965

map_fd = bpf_map__fd(skel->maps.hashmap1);

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

978

err = bpf_map_update_elem(map_fd, &key, val, BPF_ANY);

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

984

linfo.map.map_fd = map_fd;

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

147

int map_fd;

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

152

map_fd = bpf_map__fd(skel->maps.map1);

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

154

if (!ASSERT_GE(map_fd, 0, "bpf_map__fd"))

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

159

int err = bpf_map_update_elem(map_fd, &key, &val, BPF_NOEXIST);

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

169

int err = bpf_map_lookup_elem(map_fd, &key, &val);

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

210

int map_fd, cmp_res;

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

214

map_fd = bpf_map_get_fd_by_id(next_id);

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

215

if (map_fd < 0 && errno == ENOENT)

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

218

if (!ASSERT_GE(map_fd, 0, "bpf_map_get_fd_by_id"))

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

230

err = bpf_map_lookup_elem(map_fd, &array_key, &array_value);

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

234

err = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);

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

241

close(map_fd);

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

106

if (map_fd >= 0)

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

107

ASSERT_OK(close(map_fd), "close_map_fd");

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

123

static void validate_pin(int map_fd, const char *map_name, int src_value,

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

155

err = bpf_obj_pin_opts(map_fd, pin_path, &pin_opts);

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

169

err = bpf_map_update_elem(map_fd, &zero, &src_value, 0);

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

183

static void validate_get(int map_fd, const char *map_name, int src_value,

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

193

err = bpf_obj_pin(map_fd, abs_path);

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

230

err = bpf_map_update_elem(map_fd, &zero, &src_value, 0);

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

247

int map_fd;

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

250

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, map_name, 4, 4, 1, NULL);

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

251

if (!ASSERT_GE(map_fd, 0, "map_fd"))

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

254

validate_pin(map_fd, map_name, 100 + (int)path_kind, path_kind);

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

255

validate_get(map_fd, map_name, 200 + (int)path_kind, path_kind);

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

256

ASSERT_OK(close(map_fd), "close_map_fd");

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

41

int map_fd = -1, map_fd2 = -1;

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

75

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, map_name, 4, 4, 1, NULL);

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

76

if (!ASSERT_GE(map_fd, 0, "map_fd"))

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

82

err = bpf_obj_pin_opts(map_fd, map_name, &pin_opts);

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

95

err = bpf_map_update_elem(map_fd, &zero, &src_value, 0);

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

128

err = bpf_map_update_elem(cb_opts->map_fd, &fd,

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

163

cb_opts.map_fd = bpf_map__fd(dctcp_skel->maps.sk_stg_map);

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

167

err = bpf_map_lookup_elem(cb_opts.map_fd, &fd, &tmp_stg);

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

24

int map_fd;

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

4401

int map_fd = -1, btf_fd = -1;

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

4447

map_fd = bpf_map_create(test->map_type, test->map_name,

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

4450

err = ((map_fd < 0) != test->map_create_err);

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

4452

map_fd, test->map_create_err);

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

4459

if (map_fd >= 0)

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

4460

close(map_fd);

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

4612

int btf_fd[2] = {-1, -1}, map_fd = -1;

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

4676

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_btf_id",

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

4678

if (CHECK(map_fd < 0, "errno:%d", errno)) {

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

4684

err = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);

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

4709

close(map_fd);

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

4710

map_fd = -1;

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

4719

if (map_fd >= 0)

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

4720

close(map_fd);

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

5467

int map_fd = -1, btf_fd = -1;

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

5500

map_fd = bpf_map_create(test->map_type, test->map_name,

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

5502

if (CHECK(map_fd < 0, "errno:%d", errno)) {

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

5516

err = bpf_obj_pin(map_fd, pin_path);

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

5531

bpf_map_update_elem(map_fd, &key, mapv, 0);

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

5639

if (map_fd >= 0)

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

5640

close(map_fd);

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

26

int map_fd;

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

28

map_fd = bpf_map__fd(map);

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

30

if (CHECK(bpf_map_lookup_elem(map_fd, key, &value) < 0,

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

43

int map_fd;

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

45

map_fd = bpf_map__fd(map);

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

47

if (CHECK(bpf_map_lookup_elem(map_fd, key, &value) == 0,

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

11

static int map_fd = -1;

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

151

CHECK_FAIL(bpf_map_lookup_elem(map_fd, &key, &value));

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

17

if (map_fd < 0)

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

18

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, 4, 8, 1, NULL);

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

188

CHECK_FAIL(bpf_map_update_elem(map_fd, &key, &value, 0));

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

19

if (map_fd < 0) {

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

190

CHECK_FAIL(bpf_map_lookup_elem(map_fd, &key, &value));

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

241

CHECK_FAIL(bpf_map_update_elem(map_fd, &key, &value, 0));

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

243

CHECK_FAIL(bpf_map_lookup_elem(map_fd, &key, &value));

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

256

CHECK_FAIL(bpf_map_update_elem(map_fd, &key, &value, 0));

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

258

CHECK_FAIL(bpf_map_lookup_elem(map_fd, &key, &value));

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

267

CHECK_FAIL(bpf_map_update_elem(map_fd, &key, &value, 0));

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

269

CHECK_FAIL(bpf_map_lookup_elem(map_fd, &key, &value));

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

44

BPF_LD_MAP_FD(BPF_REG_1, map_fd),

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

242

static void subtest_dmabuf_iter_check_open_coded(struct dmabuf_iter *skel, int map_fd)

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

258

if (!ASSERT_OK(bpf_map_get_next_key(map_fd, NULL, key), "get next key"))

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

262

ASSERT_OK(bpf_map_lookup_elem(map_fd, key, &found), "lookup");

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

264

} while (bpf_map_get_next_key(map_fd, key, key));

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

270

int map_fd;

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

277

map_fd = bpf_map__fd(skel->maps.testbuf_hash);

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

278

if (!ASSERT_OK_FD(map_fd, "map_fd"))

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

281

if (!ASSERT_OK(bpf_map_update_elem(map_fd, udmabuf_test_buffer_name, &f, BPF_ANY),

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

284

if (!ASSERT_OK(bpf_map_update_elem(map_fd, sysheap_test_buffer_name, &f, BPF_ANY),

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

316

subtest_dmabuf_iter_check_open_coded(skel, map_fd);

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

102

BPF_LD_MAP_FD(BPF_REG_1, map_fd),

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

120

int map_fd;

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

123

map_fd = new_map();

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

124

if (!ASSERT_GE(map_fd, 0, "new_map"))

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

125

return map_fd;

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

127

ret = __load_test_prog(map_fd, fd_array, fd_array_cnt);

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

128

close(map_fd);

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

98

static int __load_test_prog(int map_fd, const int *fd_array, int fd_array_cnt)

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

627

int i, err, map_fd, prog_fd;

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

631

map_fd = bpf_map__fd(prog_array);

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

632

if (map_fd < 0)

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

646

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

503

int main_prog_fd, sub_prog_fd, map_fd, i, err;

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

515

map_fd = bpf_map__fd(prog_array);

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

516

if (map_fd < 0)

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

517

return map_fd;

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

530

err = bpf_map_update_elem(map_fd, &i, &sub_prog_fd, BPF_ANY);

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

10

map_fd = bpf_find_map(__func__, obj, "result_number");

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

105

int err = -ENOMEM, map_fd, zero = 0;

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

11

if (CHECK_FAIL(map_fd < 0))

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

120

map_fd = bpf_map__fd(map);

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

121

if (CHECK_FAIL(map_fd < 0))

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

126

err = bpf_map_update_elem(map_fd, &zero, buff, 0);

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

33

err = bpf_map_lookup_elem(map_fd, &tests[i].key, &num);

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

42

int i, err, map_fd;

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

45

map_fd = bpf_find_map(__func__, obj, "result_string");

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

46

if (CHECK_FAIL(map_fd < 0))

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

62

err = bpf_map_lookup_elem(map_fd, &tests[i].key, str);

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

7

int i, err, map_fd;

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

77

int i, err, map_fd;

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

80

map_fd = bpf_find_map(__func__, obj, "result_struct");

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

81

if (CHECK_FAIL(map_fd < 0))

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

96

err = bpf_map_lookup_elem(map_fd, &tests[i].key, &val);

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

42

map_fd = bpf_map__fd(map);

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

43

if (CHECK_FAIL(map_fd < 0))

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

48

err = bpf_map_lookup_elem(map_fd, &zero, buff);

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

7

int err = -ENOMEM, map_fd, zero = 0;

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

12

map_fd = bpf_find_map(__func__, obj, map_name);

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

13

if (CHECK(map_fd < 0, "bpf_find_map", "cannot find BPF map %s: %s\n",

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

33

err = bpf_map_lookup_elem(map_fd, &i, &actual_value);

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

9

int err, i, map_fd, actual_value;

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

33

int map_fd;

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

46

map_fd = bpf_map__fd(skel->maps.slab_result);

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

55

int ret = bpf_map_lookup_elem(map_fd, &seen, &r);

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

26

int err, i, prog_fd, map_fd;

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

41

map_fd = bpf_find_map(__func__, obj, "vip_map");

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

42

if (map_fd < 0)

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

44

bpf_map_update_elem(map_fd, &key, &value, 0);

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

46

map_fd = bpf_find_map(__func__, obj, "ch_rings");

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

47

if (map_fd < 0)

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

49

bpf_map_update_elem(map_fd, &ch_key, &real_num, 0);

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

51

map_fd = bpf_find_map(__func__, obj, "reals");

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

52

if (map_fd < 0)

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

54

bpf_map_update_elem(map_fd, &real_num, &real_def, 0);

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

75

map_fd = bpf_find_map(__func__, obj, "stats");

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

76

if (map_fd < 0)

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

78

bpf_map_lookup_elem(map_fd, &stats_key, stats);

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

24

map_fd = bpf_map__fd(skel->maps.my_pid_map);

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

25

err = bpf_map_update_elem(map_fd, &zero, &my_pid, BPF_ANY);

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

28

err = bpf_map_lookup_elem(map_fd, &zero, &res);

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

40

map_fd = bpf_map__fd(skel->maps.res_map);

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

41

err = bpf_map_lookup_elem(map_fd, &zero, &res);

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

9

int err, zero = 0, my_pid = getpid(), res, map_fd;

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

12

int server_fd, cgroup_fd, prog_fd, map_fd, client_fd;

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

39

map_fd = bpf_map__fd(test_result);

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

40

if (map_fd < 0)

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

57

err = bpf_map_lookup_elem(map_fd, &map_key, &map_value);

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

102

int map_fd, err;

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

105

skel = setup_prog(BPF_MAP_TYPE_HASH, &map_fd);

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

109

err = fill_values(map_fd);

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

126

err = bpf_map_lookup_elem(map_fd, &key, &value);

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

13

static int fill_values(int map_fd)

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

138

int map_fd, err, i;

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

141

skel = setup_prog(BPF_MAP_TYPE_PERCPU_HASH, &map_fd);

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

145

err = fill_values_percpu(map_fd);

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

166

err = bpf_map_lookup_elem(map_fd, &key, value);

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

178

int map_fd, err;

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

181

skel = setup_prog(BPF_MAP_TYPE_LRU_HASH, &map_fd);

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

185

err = fill_values(map_fd);

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

19

err = bpf_map_update_elem(map_fd, &key, &value, BPF_NOEXIST);

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

207

err = bpf_map_lookup_elem(map_fd, &key, &value);

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

212

err = bpf_map_lookup_elem(map_fd, &key, &value);

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

224

int map_fd, err, i, cpucnt = 0;

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

227

skel = setup_prog(BPF_MAP_TYPE_LRU_PERCPU_HASH, &map_fd);

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

231

err = fill_values_percpu(map_fd);

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

266

err = bpf_map_lookup_elem(map_fd, &key, &value);

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

27

static int fill_values_percpu(int map_fd)

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

271

err = bpf_map_lookup_elem(map_fd, &key, &value);

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

36

err = bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST);

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

45

int *map_fd)

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

66

*map_fd = bpf_map__fd(skel->maps.hash_map);

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

67

if (!ASSERT_GE(*map_fd, 0, "bpf_map__fd"))

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

133

int map_fd, err;

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

137

skel = setup(BPF_MAP_TYPE_PERCPU_HASH, 1, &map_fd, 1);

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

143

err = bpf_map_delete_elem(map_fd, &key);

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

153

err = bpf_map_lookup_elem(map_fd, &key, value);

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

173

int map_fd, err;

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

179

skel = setup(BPF_MAP_TYPE_LRU_PERCPU_HASH, 2, &map_fd, 2);

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

190

err = bpf_map_lookup_elem(map_fd, &key, value);

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

20

static int map_populate(int map_fd, int num)

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

30

err = bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST);

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

39

int *map_fd, int populate)

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

60

*map_fd = bpf_map__fd(skel->maps.hashmap1);

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

61

if (CHECK(*map_fd < 0, "bpf_map__fd", "failed\n"))

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

64

err = map_populate(*map_fd, populate);

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

71

close(*map_fd);

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

13

if (!ASSERT_OK(bpf_map_get_info_by_fd(map_fd, &info, &len), "get_map_info"))

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

8

static int get_map_id(int map_fd)

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

23

int err, map_fd = *(u32 *) arg;

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

27

err = bpf_map_lookup_elem_flags(map_fd, &key, vars, BPF_F_LOCK);

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

53

int prog_fd, map_fd[2], vars[17] = {};

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

64

map_fd[0] = bpf_find_map(__func__, obj, "hash_map");

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

65

if (CHECK_FAIL(map_fd[0] < 0))

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

67

map_fd[1] = bpf_find_map(__func__, obj, "array_map");

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

68

if (CHECK_FAIL(map_fd[1] < 0))

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

71

bpf_map_update_elem(map_fd[0], &key, vars, BPF_F_LOCK);

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

80

&map_fd[i - 4])))

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

88

ret != (void *)&map_fd[i - 4]))

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

16

static int prog_holds_map(int prog_fd, int map_fd)

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

28

ret = bpf_map_get_info_by_fd(map_fd, &map_info, &map_info_len);

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

123

static int verify_msk(int map_fd, int client_fd, __u32 token)

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

134

err = bpf_map_lookup_elem(map_fd, &cfd, &val);

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

158

int client_fd, prog_fd, map_fd, err;

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

170

map_fd = bpf_map__fd(sock_skel->maps.socket_storage_map);

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

181

err += is_mptcp ? verify_msk(map_fd, client_fd, sock_skel->bss->token) :

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

182

verify_tsk(map_fd, client_fd);

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

85

static int verify_tsk(int map_fd, int client_fd)

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

90

err = bpf_map_lookup_elem(map_fd, &cfd, &val);

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

15

int map_fd, percpu_map_fd;

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

45

map_fd = bpf_map__fd(skel->maps.netcnt);

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

46

if (!ASSERT_OK(bpf_map_get_next_key(map_fd, NULL, &key), "bpf_map_get_next_key"))

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

49

if (!ASSERT_OK(bpf_map_lookup_elem(map_fd, &key, &netcnt), "bpf_map_lookup_elem(netcnt)"))

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

125

int i, j, cpu, map_fd, err;

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

145

map_fd = bpf_map__fd(map);

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

147

err = bpf_map_lookup_elem_flags(map_fd, keys, values, flags);

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

151

err = bpf_map_update_elem(map_fd, keys, values, flags);

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

156

err = bpf_map_lookup_elem_flags(map_fd, keys, values, flags);

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

161

err = bpf_map_lookup_elem_flags(map_fd, keys, values, flags);

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

166

err = bpf_map_update_elem(map_fd, keys, values, flags);

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

171

err = bpf_map_update_elem(map_fd, keys, values, flags);

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

179

err = bpf_map_lookup_elem_flags(map_fd, keys, values, flags);

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

226

err = bpf_map_update_batch(map_fd, keys, values, &count, &batch_opts);

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

236

err = bpf_map_update_batch(map_fd, keys, values, &count, &batch_opts);

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

248

err = bpf_map_update_batch(map_fd, keys, values, &count, &batch_opts);

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

258

err = bpf_map_lookup_batch(map_fd, NULL, &batch, keys, values, &count, &batch_opts);

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

274

err = bpf_map_lookup_batch(map_fd, NULL, &batch, keys, values_percpu, &count,

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

404

int err, map_fd, key = 0;

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

407

map_fd = bpf_map_create(map_type, "test_cpu_flag", sizeof(int), sizeof(u64), max_entries,

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

409

if (!ASSERT_GE(map_fd, 0, "bpf_map_create"))

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

413

err = bpf_map_update_elem(map_fd, &key, &val, flags);

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

417

err = bpf_map_update_batch(map_fd, &key, &val, &count, &batch_opts);

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

421

err = bpf_map_lookup_elem_flags(map_fd, &key, &val, flags);

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

425

err = bpf_map_lookup_batch(map_fd, NULL, &batch, &key, &val, &count, &batch_opts);

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

428

close(map_fd);

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

244

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, sizeof(__u32),

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

246

if (CHECK(map_fd < 0, "create pinmap manually", "fd %d\n", map_fd))

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

253

err = bpf_map__reuse_fd(map, map_fd);

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

271

close(map_fd);

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

40

int err, map_fd;

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

107

rb_fd = skel->maps.ringbuf.map_fd;

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

151

int map_fd;

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

164

rb_fd = skel->maps.ringbuf.map_fd;

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

213

ringbuf = ring_buffer__new(skel->maps.ringbuf.map_fd,

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

228

map_fd = ring__map_fd(ring);

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

229

ASSERT_EQ(map_fd, skel->maps.ringbuf.map_fd, "ring_map_fd");

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

420

ringbuf = ring_buffer__new(skel_n->maps.ringbuf.map_fd,

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

456

err = bpf_map_lookup_elem(skel_map_key->maps.hash_map.map_fd,

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

481

ringbuf = ring_buffer__new(skel_map_key->maps.ringbuf.map_fd,

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

1164

int map_fd, server_fd, client_fd;

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

1169

map_fd = bpf_map__fd(t->run_map);

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

1173

err = bpf_map_update_elem(map_fd, &prog_idx, &done, BPF_ANY);

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

1177

err = bpf_map_update_elem(map_fd, &prog_idx, &done, BPF_ANY);

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

1214

err = bpf_map_lookup_elem(map_fd, &prog_idx, &done);

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

1220

err = bpf_map_lookup_elem(map_fd, &prog_idx, &done);

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

435

int err, map_fd;

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

438

map_fd = bpf_map__fd(map);

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

439

if (CHECK(map_fd < 0, "bpf_map__fd", "failed\n")) {

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

440

errno = -map_fd;

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

446

err = bpf_map_update_elem(map_fd, &index, &value, BPF_NOEXIST);

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

12

int sk_fd = -1, map_fd, err, value;

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

18

map_fd = bpf_map__fd(skel->maps.sk_storage);

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

33

err = bpf_map_update_elem(map_fd, &sk_fd, &value, 0);

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

38

err = bpf_map_update_elem(map_fd, &sk_fd, &value, 0);

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

338

linfo.map.map_fd = src_fd;

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

455

int err, map_fd, verdict_fd;

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

464

map_fd = bpf_map__fd(skel->maps.sock_map);

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

471

err = bpf_prog_query(map_fd, attach_type, 0 /* query flags */,

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

477

err = bpf_prog_attach(verdict_fd, map_fd, attach_type, 0);

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

482

err = bpf_prog_query(map_fd, attach_type, 0 /* query flags */,

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

490

bpf_prog_detach2(verdict_fd, map_fd, attach_type);

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

169

int prog_fd, map_fd;

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

183

map_fd = bpf_map__fd(skel->maps.sock_map);

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

185

err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);

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

189

err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);

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

250

int prog_fd, map_fd;

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

269

map_fd = bpf_map__fd(skel->maps.sock_map);

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

271

err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);

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

275

err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);

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

279

err = bpf_map_update_elem(map_fd, &two, &p, BPF_NOEXIST);

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

322

int prog_fd, map_fd;

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

336

map_fd = bpf_map__fd(skel->maps.sock_map);

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

338

err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);

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

342

err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);

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

1315

int map_fd;

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

1320

map_fd = bpf_map__fd(map);

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

1332

t->fn(skel, family, sotype, map_fd);

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

10

int map_fd;

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

39

ASSERT_GT(ctx.map_fd, 0, "ctx.map_fd");

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

44

err = bpf_map_lookup_elem(ctx.map_fd, &key, &value);

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

51

if (ctx.map_fd > 0)

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

52

close(ctx.map_fd);

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

1017

int err, map_fd, prog_fd, data_fd, i, val;

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

1039

map_fd = bpf_map__fd(prog_array);

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

1040

if (!ASSERT_FALSE(map_fd < 0, "find jmp_table map fd"))

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

1052

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

1122

__u32 zero = 0, prog1_fd, prog2_fd, map_fd;

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

1125

map_fd = bpf_map__fd(call->maps.jmp_table);

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

1130

bpf_map_update_elem(map_fd, &zero, &prog1_fd, BPF_ANY);

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

1131

bpf_map_update_elem(map_fd, &zero, &prog2_fd, BPF_ANY);

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

114

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

1199

int err, map_fd, prog_fd, main_data_fd, fentry_data_fd = 0, fexit_data_fd = 0, i, val;

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

1258

map_fd = bpf_map__fd(prog_array);

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

1259

if (!ASSERT_GE(map_fd, 0, "map_fd"))

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

126

err = bpf_map_delete_elem(map_fd, &i);

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

1263

err = bpf_map_update_elem(map_fd, &i, &fentry_prog_fd, BPF_ANY);

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

1277

map_fd = bpf_map__fd(prog_array);

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

1278

if (!ASSERT_GE(map_fd, 0, "map_fd"))

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

1282

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

136

err = bpf_map_delete_elem(map_fd, &i);

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

1388

err = bpf_map_delete_elem(map_fd, &i);

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

1510

int prog_fd, tc_prog_fd, map_fd;

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

1539

map_fd = bpf_map__fd(freplace_skel->maps.jmp_table);

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

1542

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

155

int err, map_fd, prog_fd, main_fd, i;

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

1550

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

1569

int prog_fd, map_fd;

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

1611

map_fd = bpf_map__fd(freplace_skel->maps.jmp_table);

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

1612

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

1616

err = bpf_map_delete_elem(map_fd, &key);

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

1622

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

1631

err = bpf_map_delete_elem(map_fd, &key);

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

1642

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

1666

int prog_fd, map_fd;

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

1703

map_fd = bpf_map__fd(skel->maps.jmp_table);

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

1704

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

184

map_fd = bpf_map__fd(prog_array);

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

185

if (CHECK_FAIL(map_fd < 0))

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

19

int err, map_fd, prog_fd, main_fd, i, j;

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

199

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

209

err = bpf_map_delete_elem(map_fd, &i);

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

218

err = bpf_map_delete_elem(map_fd, &i);

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

234

int err, map_fd, prog_fd, main_fd, data_fd, i, val;

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

261

map_fd = bpf_map__fd(prog_array);

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

262

if (CHECK_FAIL(map_fd < 0))

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

274

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

378

err = bpf_map_delete_elem(map_fd, &i);

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

415

int err, map_fd, prog_fd, main_fd, data_fd, i;

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

445

map_fd = bpf_map__fd(prog_array);

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

446

if (CHECK_FAIL(map_fd < 0))

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

468

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

48

map_fd = bpf_map__fd(prog_array);

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

488

err = bpf_map_delete_elem(map_fd, &i);

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

49

if (CHECK_FAIL(map_fd < 0))

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

505

int err, map_fd, prog_fd, main_fd, data_fd, i, key[] = { 1111, 1234, 5678 };

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

535

map_fd = bpf_map__fd(prog_array);

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

536

if (CHECK_FAIL(map_fd < 0))

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

558

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

578

err = bpf_map_delete_elem(map_fd, &i);

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

595

int err, map_fd, prog_fd, main_fd, i;

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

623

map_fd = bpf_map__fd(prog_array);

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

624

if (CHECK_FAIL(map_fd < 0))

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

63

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

639

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

650

err = bpf_map_delete_elem(map_fd, &i);

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

662

err = bpf_map_delete_elem(map_fd, &i);

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

679

int err, map_fd, prog_fd, main_fd, data_fd, i, val;

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

707

map_fd = bpf_map__fd(prog_array);

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

708

if (CHECK_FAIL(map_fd < 0))

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

720

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

73

err = bpf_map_delete_elem(map_fd, &i);

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

742

err = bpf_map_delete_elem(map_fd, &i);

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

759

int err, map_fd, prog_fd, main_fd, i;

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

787

map_fd = bpf_map__fd(prog_array);

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

788

if (CHECK_FAIL(map_fd < 0))

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

802

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

812

err = bpf_map_delete_elem(map_fd, &i);

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

821

err = bpf_map_delete_elem(map_fd, &i);

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

853

int err, map_fd, prog_fd, main_fd, data_fd, i;

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

882

map_fd = bpf_map__fd(prog_array);

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

883

if (CHECK_FAIL(map_fd < 0))

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

897

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

93

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

938

int err, map_fd, prog_fd, main_fd, data_fd, i, val;

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

953

map_fd = bpf_map__fd(obj->maps.jmp_table);

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

954

if (!ASSERT_GE(map_fd, 0, "jmp_table map fd"))

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

962

err = bpf_map_update_elem(map_fd, &i, &prog_fd, BPF_ANY);

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

153

static int __tld_init_data_p(int map_fd)

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

200

err = bpf_map_update_elem(map_fd, &tid_fd, &map_val, 0);

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

351

static void *tld_get_data(int map_fd, tld_key_t key)

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

357

if (!tld_data_p && __tld_init_data_p(map_fd))

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

117

map_fd = bpf_map__fd(skel->maps.map_a);

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

118

err = bpf_map_lookup_elem(map_fd, &task_fd, &value);

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

123

map_fd = bpf_map__fd(skel->maps.map_b);

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

124

err = bpf_map_lookup_elem(map_fd, &task_fd, &value);

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

258

int map_fd, parent_task_fd, ev_fd;

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

280

map_fd = bpf_map__fd(skel->maps.datamap);

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

283

err = bpf_map_update_elem(map_fd, &parent_task_fd, &value, BPF_NOEXIST);

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

328

err = bpf_map_update_elem(map_fd, &parent_task_fd, &value, BPF_EXIST);

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

335

err = bpf_map_update_elem(map_fd, &parent_task_fd, &value, BPF_EXIST);

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

343

err = bpf_map_update_elem(map_fd, &parent_task_fd, &value, BPF_EXIST);

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

352

err = bpf_map_lookup_elem(map_fd, &parent_task_fd, &value);

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

359

err = bpf_map_delete_elem(map_fd, &parent_task_fd);

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

366

err = bpf_map_update_elem(map_fd, &parent_task_fd, &value, BPF_NOEXIST);

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

380

int err, task_fd, map_fd;

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

398

map_fd = bpf_map__fd(skel->maps.datamap);

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

400

err = bpf_map_update_elem(map_fd, &task_fd, &value, 0);

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

406

err = bpf_map_update_elem(map_fd, &task_fd, &value, 0);

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

419

int err, task_fd, map_fd;

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

429

map_fd = bpf_map__fd(skel->maps.datamap);

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

432

err = bpf_map_update_elem(map_fd, &task_fd, &value, BPF_F_LOCK);

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

437

err = bpf_map_update_elem(map_fd, &task_fd, &value, BPF_EXIST);

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

442

err = bpf_map_update_elem(map_fd, &task_fd, &value, BPF_NOEXIST);

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

447

err = bpf_map_update_elem(map_fd, &task_fd, &value, BPF_NOEXIST);

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

463

int map_fd, err;

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

479

map_fd = bpf_map_create(bpf_map__type(map), map_name,

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

482

if (ASSERT_ERR_FD(map_fd, "map_create"))

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

485

close(map_fd);

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

90

int err, map_fd, prog_fd, task_fd;

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

110

int map_fd;

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

117

map_fd = bpf_map__fd(skel->maps.socket_storage_map);

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

132

err += verify_sk(map_fd, client_fd, "syn-ack",

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

146

err += verify_sk(map_fd, client_fd, "first payload byte",

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

50

static int verify_sk(int map_fd, int client_fd, const char *msg, __u32 invoked,

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

57

if (!ASSERT_GE(bpf_map_lookup_elem(map_fd, &client_fd, &val), 0, "read socket storage"))

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

295

static void block_link(int map_fd, const char *src, const char *dst)

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

303

bpf_map_update_elem(map_fd, &key, &val, BPF_ANY);

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

329

int rc, map_fd;

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

339

map_fd = bpf_map__fd(skel->maps.smc_policy_ip);

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

340

if (!ASSERT_OK_FD(map_fd, "bpf_map__fd"))

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

350

block_link(map_fd, CLIENT_IP, SERVER_IP_VIA_RISK_PATH);

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

351

block_link(map_fd, SERVER_IP, SERVER_IP);

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

16

static int update_storage(int map_fd, int secureexec)

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

24

ret = bpf_map_update_elem(map_fd, &task_fd, &secureexec, BPF_NOEXIST);

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

32

static int run_set_secureexec(int map_fd, int secureexec)

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

49

ret = update_storage(map_fd, secureexec);

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

54

static bool check_syscall_operations(int map_fd, int obj_fd)

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

61

err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val, 0);

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

66

err = bpf_map_update_elem(map_fd, &obj_fd, &val, BPF_NOEXIST);

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

71

err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val, 0);

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

79

err = bpf_map_delete_elem(map_fd, &obj_fd);

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

84

err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val, 0);

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

122

int map_fd, prog_fd;

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

129

map_fd = bpf_map__fd(skel->maps.jmp_table);

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

130

if (CHECK_FAIL(map_fd < 0))

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

138

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

146

err = bpf_map_update_elem(map_fd, &key, &prog_fd, BPF_ANY);

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

257

int map_fd;

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

276

map_fd = bpf_map__fd(xdp_redirect_map->maps.tx_port);

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

277

if (!ASSERT_OK_FD(map_fd, "open redirect map"))

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

296

err = bpf_map_update_elem(map_fd, &i, &interface_id, BPF_ANY);

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

503

int err, token_fd = -1, map_fd = -1;

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

524

map_fd = bpf_map_create(BPF_MAP_TYPE_STACK, "wo_token_wo_bpf", 0, 8, 1, &map_opts);

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

525

if (!ASSERT_LT(map_fd, 0, "stack_map_wo_token_wo_cap_bpf_should_fail")) {

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

533

map_fd = bpf_map_create(BPF_MAP_TYPE_STACK, "w_token_wo_bpf", 0, 8, 1, &map_opts);

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

534

if (!ASSERT_LT(map_fd, 0, "stack_map_w_token_wo_cap_bpf_should_fail")) {

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

547

map_fd = bpf_map_create(BPF_MAP_TYPE_STACK, "wo_token_w_bpf", 0, 8, 1, &map_opts);

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

548

if (!ASSERT_LT(map_fd, 0, "stack_map_wo_token_w_cap_bpf_should_fail")) {

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

556

map_fd = bpf_map_create(BPF_MAP_TYPE_STACK, "w_token_w_bpf", 0, 8, 1, &map_opts);

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

557

if (!ASSERT_GT(map_fd, 0, "stack_map_w_token_w_cap_bpf")) {

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

564

zclose(map_fd);

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

49

int ret, err, map_fd;

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

61

map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "map_no_btf", sizeof(__u32), sizeof(__u64), 100,

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

63

if (!ASSERT_GT(map_fd, -1, "map create"))

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

66

err = bpf_map__reuse_fd(skel->maps.array, map_fd);

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

68

close(map_fd);

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

16

int err, prog_fd, map_fd;

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

29

map_fd = bpf_find_map(__func__, obj, "vip2tnl");

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

30

if (map_fd < 0)

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

32

bpf_map_update_elem(map_fd, &key4, &value4, 0);

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

33

bpf_map_update_elem(map_fd, &key6, &value6, 0);

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

348

int map_fd = bpf_map__fd(skeletons->xdp_redirect_multi_kern->maps.map_all);

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

353

err = bpf_map_update_elem(map_fd, &ifindex, &ifindex, 0);

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

105

int err, pkt_fd, map_fd;

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

121

map_fd = bpf_map__fd(pkt_skel->maps.vip2tnl);

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

122

bpf_map_update_elem(map_fd, &key4, &value4, 0);

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

105

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

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

122

int err, frags_prog_fd, map_fd;

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

130

map_fd = bpf_map__fd(skel->maps.cpu_map);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

136

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

139

err = bpf_map_lookup_elem(map_fd, &idx, &val);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

150

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

21

int err, prog_fd, prog_redir_fd, map_fd, bad_fd;

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

41

map_fd = bpf_map__fd(skel->maps.cpu_map);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

47

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

50

err = bpf_map_lookup_elem(map_fd, &idx, &val);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

81

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

89

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_cpumap_attach.c

96

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

142

int err, dm_fd_frags, map_fd;

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

150

map_fd = bpf_map__fd(skel->maps.dm_ports);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

156

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

159

err = bpf_map_lookup_elem(map_fd, &idx, &val);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

170

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

184

int err, dm_fd, dm_fd_redir, map_fd, ifindex_dst;

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

213

map_fd = bpf_map__fd(skel->maps.dm_ports);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

219

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

222

err = bpf_map_lookup_elem(map_fd, &idx, &val);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

25

int err, dm_fd, dm_fd_redir, map_fd;

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

46

map_fd = bpf_map__fd(skel->maps.dm_ports);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

52

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

55

err = bpf_map_lookup_elem(map_fd, &idx, &val);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

82

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/prog_tests/xdp_devmap_attach.c

91

err = bpf_map_update_elem(map_fd, &idx, &val, 0);

tools/testing/selftests/bpf/progs/syscall.c

118

static union bpf_attr map_update_attr = { .map_fd = 1, };

tools/testing/selftests/bpf/progs/syscall.c

144

ctx->map_fd = ret;

tools/testing/selftests/bpf/progs/syscall.c

147

map_update_attr.map_fd = ret;

tools/testing/selftests/bpf/progs/syscall.c

188

attr->map_fd = outer_fd;

tools/testing/selftests/bpf/progs/syscall.c

196

attr->map_fd = outer_fd;

tools/testing/selftests/bpf/progs/syscall.c

23

int map_fd;

tools/testing/selftests/bpf/test_lru_map.c

31

int map_fd;

tools/testing/selftests/bpf/test_lru_map.c

33

map_fd = bpf_map_create(map_type, NULL, sizeof(unsigned long long),

tools/testing/selftests/bpf/test_lru_map.c

36

if (map_fd == -1)

tools/testing/selftests/bpf/test_lru_map.c

39

return map_fd;

tools/testing/selftests/bpf/test_lru_map.c

547

static void do_test_lru_sanity5(unsigned long long last_key, int map_fd)

tools/testing/selftests/bpf/test_lru_map.c

552

assert(!bpf_map_lookup_elem_with_ref_bit(map_fd, last_key, value));

tools/testing/selftests/bpf/test_lru_map.c

556

assert(!bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST));

tools/testing/selftests/bpf/test_lru_map.c

557

assert(!bpf_map_lookup_elem_with_ref_bit(map_fd, key, value));

tools/testing/selftests/bpf/test_lru_map.c

560

assert(bpf_map_lookup_elem(map_fd, &last_key, value) == -ENOENT);

tools/testing/selftests/bpf/test_lru_map.c

568

int map_fd;

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

577

assert(map_fd != -1);

tools/testing/selftests/bpf/test_lru_map.c

581

assert(!bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST));

tools/testing/selftests/bpf/test_lru_map.c

588

do_test_lru_sanity5(key, map_fd);

tools/testing/selftests/bpf/test_lru_map.c

603

close(map_fd);

tools/testing/selftests/bpf/test_maps.c

1406

int map_update_retriable(int map_fd, const void *key, const void *value, int flags, int attempts,

tools/testing/selftests/bpf/test_maps.c

1411

while (bpf_map_update_elem(map_fd, key, value, flags)) {

tools/testing/selftests/bpf/test_maps.c

1425

static int map_delete_retriable(int map_fd, const void *key, int attempts)

tools/testing/selftests/bpf/test_maps.c

1429

while (bpf_map_delete_elem(map_fd, key)) {

tools/testing/selftests/bpf/test_maps.c

1631

static void prepare_reuseport_grp(int type, int map_fd, size_t map_elem_size,

tools/testing/selftests/bpf/test_maps.c

1671

err = bpf_map_update_elem(map_fd, &index0, value, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1699

err = bpf_map_update_elem(map_fd, &index0, value,

tools/testing/selftests/bpf/test_maps.c

1725

int map_fd, err, t, f;

tools/testing/selftests/bpf/test_maps.c

1729

map_fd = bpf_map_create(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, NULL,

tools/testing/selftests/bpf/test_maps.c

1731

CHECK(map_fd < 0, "reuseport array create",

tools/testing/selftests/bpf/test_maps.c

1732

"map_fd:%d, errno:%d\n", map_fd, errno);

tools/testing/selftests/bpf/test_maps.c

1735

err = bpf_map_delete_elem(map_fd, &bad_index);

tools/testing/selftests/bpf/test_maps.c

1739

err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1744

err = bpf_map_lookup_elem(map_fd, &bad_index, &map_cookie);

tools/testing/selftests/bpf/test_maps.c

1750

err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);

tools/testing/selftests/bpf/test_maps.c

1754

err = bpf_map_delete_elem(map_fd, &index3);

tools/testing/selftests/bpf/test_maps.c

1762

prepare_reuseport_grp(type, map_fd, sizeof(__u64), grpa_fds64,

tools/testing/selftests/bpf/test_maps.c

1767

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1776

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1785

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1793

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1802

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1812

err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1818

err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1825

err = bpf_map_delete_elem(map_fd, &index3);

tools/testing/selftests/bpf/test_maps.c

1831

err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1837

err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);

tools/testing/selftests/bpf/test_maps.c

1846

err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);

tools/testing/selftests/bpf/test_maps.c

1857

err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1863

close(map_fd);

tools/testing/selftests/bpf/test_maps.c

1866

map_fd = bpf_map_create(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, NULL,

tools/testing/selftests/bpf/test_maps.c

1868

CHECK(map_fd < 0, "reuseport array create",

tools/testing/selftests/bpf/test_maps.c

1869

"map_fd:%d, errno:%d\n", map_fd, errno);

tools/testing/selftests/bpf/test_maps.c

1870

prepare_reuseport_grp(SOCK_STREAM, map_fd, sizeof(__u32), &fd64,

tools/testing/selftests/bpf/test_maps.c

1873

err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1876

err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);

tools/testing/selftests/bpf/test_maps.c

1881

close(map_fd);

tools/testing/selftests/bpf/test_maps.h

21

int map_update_retriable(int map_fd, const void *key, const void *value, int flags, int attempts,

tools/testing/selftests/bpf/test_sockmap.c

1060

links[0] = bpf_program__attach_sockmap(progs[0], map_fd[0]);

tools/testing/selftests/bpf/test_sockmap.c

1064

bpf_program__fd(progs[0]), map_fd[0], strerror(errno));

tools/testing/selftests/bpf/test_sockmap.c

1069

links[1] = bpf_program__attach_sockmap(progs[1], map_fd[0]);

tools/testing/selftests/bpf/test_sockmap.c

1079

links[2] = bpf_program__attach_sockmap(progs[0], map_fd[8]);

tools/testing/selftests/bpf/test_sockmap.c

1083

bpf_program__fd(progs[0]), map_fd[8], strerror(errno));

tools/testing/selftests/bpf/test_sockmap.c

1088

links[3] = bpf_program__attach_sockmap(progs[2], map_fd[8]);

tools/testing/selftests/bpf/test_sockmap.c

1128

links[4] = bpf_program__attach_sockmap(tx_prog, map_fd[1]);

tools/testing/selftests/bpf/test_sockmap.c

1138

err = bpf_map_update_elem(map_fd[1], &i, &c1, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1151

err = bpf_map_update_elem(map_fd[2], &i, &redir_fd, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1160

err = bpf_map_update_elem(map_fd[3],

tools/testing/selftests/bpf/test_sockmap.c

1171

err = bpf_map_update_elem(map_fd[4],

tools/testing/selftests/bpf/test_sockmap.c

1182

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1194

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1206

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1218

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1230

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1240

bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1246

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1256

bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1265

err = bpf_map_update_elem(map_fd[6], &i, &in, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1272

err = bpf_map_update_elem(map_fd[1], &i, &p1, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1278

err = bpf_map_update_elem(map_fd[2], &i, &p1, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1286

err = bpf_map_update_elem(map_fd[2], &i, &p2, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1298

err = bpf_map_update_elem(map_fd[8], &i, &p2, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1307

err = bpf_map_update_elem(map_fd[7],

tools/testing/selftests/bpf/test_sockmap.c

1318

err = bpf_map_update_elem(map_fd[7], &i, &i, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1328

err = bpf_map_update_elem(map_fd[7],

tools/testing/selftests/bpf/test_sockmap.c

1337

err = bpf_map_update_elem(map_fd[0], &i, &skb_fd, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1348

err = bpf_map_update_elem(map_fd[7], &i, &skb_use_parser, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1383

for (i = 0; i < ARRAY_SIZE(map_fd); i++) {

tools/testing/selftests/bpf/test_sockmap.c

1385

bpf_map_update_elem(map_fd[i], &key, &zero, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1386

while (bpf_map_get_next_key(map_fd[i], &key, &next_key) == 0) {

tools/testing/selftests/bpf/test_sockmap.c

1387

bpf_map_update_elem(map_fd[i], &key, &zero, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1969

for (i = 0; i < ARRAY_SIZE(map_fd); i++) {

tools/testing/selftests/bpf/test_sockmap.c

1971

map_fd[i] = bpf_map__fd(maps[i]);

tools/testing/selftests/bpf/test_sockmap.c

1972

if (map_fd[i] < 0) {

tools/testing/selftests/bpf/test_sockmap.c

1974

map_fd[i], strerror(errno));

tools/testing/selftests/bpf/test_sockmap.c

66

int map_fd[9];

tools/testing/selftests/bpf/xdp_synproxy.c

312

int map_fd;

tools/testing/selftests/bpf/xdp_synproxy.c

319

map_fd = err;

tools/testing/selftests/bpf/xdp_synproxy.c

322

err = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);

tools/testing/selftests/bpf/xdp_synproxy.c

326

close(map_fd);

tools/testing/selftests/bpf/xdp_synproxy.c

330

*values_map_fd = map_fd;

tools/testing/selftests/bpf/xdp_synproxy.c

334

*ports_map_fd = map_fd;

tools/testing/selftests/bpf/xdp_synproxy.c

337

close(map_fd);

tools/testing/selftests/bpf/xdping.c

189

map_fd = bpf_map__fd(map);

tools/testing/selftests/bpf/xdping.c

190

if (!map || map_fd < 0) {

tools/testing/selftests/bpf/xdping.c

209

close(map_fd);

tools/testing/selftests/bpf/xdping.c

224

if (bpf_map_update_elem(map_fd, &raddr, &pinginfo, BPF_ANY)) {

tools/testing/selftests/bpf/xdping.c

243

ret = get_stats(map_fd, count, raddr);

tools/testing/selftests/bpf/xdping.c

250

if (map_fd > 0)

tools/testing/selftests/bpf/xdping.c

251

close(map_fd);

tools/testing/selftests/bpf/xdping.c

95

int prog_fd = -1, map_fd = -1;

tools/testing/selftests/bpf/xsk.c

442

int map_fd;

tools/testing/selftests/bpf/xsk.c

444

map_fd = bpf_map__fd(map);

tools/testing/selftests/bpf/xsk.c

445

bpf_map_delete_elem(map_fd, &index);

tools/testing/selftests/bpf/xsk.c

450

int map_fd, sock_fd;

tools/testing/selftests/bpf/xsk.c

452

map_fd = bpf_map__fd(map);

tools/testing/selftests/bpf/xsk.c

455

return bpf_map_update_elem(map_fd, &index, &sock_fd, 0);