kernel/bpf/helpers.c

59

BPF_CALL_4(bpf_map_update_elem, struct bpf_map *, map, void *, key,

kernel/bpf/helpers.c

67

.func = bpf_map_update_elem,

samples/bpf/fds_example.c

98

ret = bpf_map_update_elem(fd, &key, &value, 0);

samples/bpf/hbm.c

193

if (bpf_map_update_elem(queue_stats_fd, &key, &qstats, BPF_ANY)) {

samples/bpf/hbm.c

300

if (bpf_map_update_elem(queue_stats_fd, &key, &qstats, BPF_ANY))

samples/bpf/ibumad_kern.c

107

bpf_map_update_elem(&read_count, &class, &zero, BPF_NOEXIST);

samples/bpf/ibumad_kern.c

127

bpf_map_update_elem(&write_count, &class, &zero, BPF_NOEXIST);

samples/bpf/ibumad_kern.c

87

bpf_map_update_elem(&read_count, &class, &zero, BPF_NOEXIST);

samples/bpf/lwt_len_hist.bpf.c

57

bpf_map_update_elem(&lwt_len_hist_map, &key, &init_val, BPF_ANY);

samples/bpf/map_perf_test.bpf.c

112

bpf_map_update_elem(&hash_map, &key, &init_val, BPF_ANY);

samples/bpf/map_perf_test.bpf.c

130

bpf_map_update_elem(&percpu_hash_map, &key, &init_val, BPF_ANY);

samples/bpf/map_perf_test.bpf.c

147

bpf_map_update_elem(&hash_map_alloc, &key, &init_val, BPF_ANY);

samples/bpf/map_perf_test.bpf.c

164

bpf_map_update_elem(&percpu_hash_map_alloc, &key, &init_val, BPF_ANY);

samples/bpf/map_perf_test.bpf.c

210

ret = bpf_map_update_elem(&lru_hash_map, &key, &val, BPF_ANY);

samples/bpf/map_perf_test.bpf.c

212

ret = bpf_map_update_elem(&nocommon_lru_hash_map, &key, &val,

samples/bpf/map_perf_test.bpf.c

225

ret = bpf_map_update_elem(nolocal_lru_map, &key, &val,

samples/bpf/map_perf_test_user.c

112

ret = bpf_map_update_elem(fd, &key, &val, BPF_NOEXIST);

samples/bpf/map_perf_test_user.c

158

ret = bpf_map_update_elem(outer_fd, &cpu,

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/offwaketime.bpf.c

123

bpf_map_update_elem(&start, &pid, &ts, BPF_ANY);

samples/bpf/offwaketime.bpf.c

72

bpf_map_update_elem(&wokeby, &pid, &woke, BPF_ANY);

samples/bpf/offwaketime.bpf.c

96

bpf_map_update_elem(&counts, &key, &zero, BPF_NOEXIST);

samples/bpf/sampleip_kern.c

34

bpf_map_update_elem(&ip_map, &ip, &init_val, BPF_NOEXIST);

samples/bpf/sockex2_kern.c

217

bpf_map_update_elem(&hash_map, &key, &val, BPF_ANY);

samples/bpf/sockex3_kern.c

102

bpf_map_update_elem(&hash_map, &key, &val, BPF_ANY);

samples/bpf/spintest.bpf.c

42

bpf_map_update_elem(&my_map, &v, &v, BPF_ANY); \

samples/bpf/spintest.bpf.c

43

bpf_map_update_elem(&my_map2, &v, &v, BPF_ANY); \

samples/bpf/syscall_tp_kern.c

55

bpf_map_update_elem(map, &key, &init_val, BPF_NOEXIST);

samples/bpf/syscall_tp_user.c

42

if (bpf_map_update_elem(map_id, &key, &val, BPF_ANY) != 0) {

samples/bpf/tc_l2_redirect_user.c

60

ret = bpf_map_update_elem(array_fd, &array_key, &ifindex, 0);

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

287

if (bpf_map_update_elem(lru_map_fd, &key, &value, BPF_NOEXIST)) {

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

407

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

samples/bpf/test_lru_dist.c

435

assert(bpf_map_update_elem(map_fd, &next_ins_key, value,

samples/bpf/test_lru_dist.c

449

bpf_map_update_elem(map_fd, &next_ins_key, value,

samples/bpf/test_map_in_map.bpf.c

165

bpf_map_update_elem(&reg_result_h, &ret_key, &ret, BPF_ANY);

samples/bpf/test_map_in_map.bpf.c

166

bpf_map_update_elem(&inline_result_h, &ret_key, &inline_ret, BPF_ANY);

samples/bpf/test_map_in_map_user.c

53

ret = bpf_map_update_elem(PORT_A, &port_key, &magic_result, BPF_ANY);

samples/bpf/test_map_in_map_user.c

56

ret = bpf_map_update_elem(PORT_H, &port_key, &magic_result,

samples/bpf/test_map_in_map_user.c

60

ret = bpf_map_update_elem(A_OF_PORT_A, &port_key, &PORT_A, BPF_ANY);

samples/bpf/test_map_in_map_user.c

64

ret = bpf_map_update_elem(H_OF_PORT_A, &port_key, &PORT_A, BPF_NOEXIST);

samples/bpf/test_map_in_map_user.c

68

ret = bpf_map_update_elem(H_OF_PORT_H, &port_key, &PORT_H, BPF_NOEXIST);

samples/bpf/trace_event_kern.c

75

bpf_map_update_elem(&counts, &key, &one, BPF_NOEXIST);

samples/bpf/tracex3.bpf.c

35

bpf_map_update_elem(&my_map, &key, &val, BPF_ANY);

samples/bpf/tracex3_user.c

25

bpf_map_update_elem(fd, &key, values, BPF_ANY);

samples/bpf/tracex4.bpf.c

50

bpf_map_update_elem(&my_map, &ptr, &v, BPF_ANY);

samples/bpf/tracex5_user.c

84

bpf_map_update_elem(progs_fd, &key, &fd, BPF_ANY);

samples/bpf/tracex6.bpf.c

44

bpf_map_update_elem(&values, &key, &count, BPF_NOEXIST);

samples/bpf/tracex6.bpf.c

75

bpf_map_update_elem(&values2, &key, &buf, BPF_NOEXIST);

samples/bpf/tracex6_user.c

43

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

samples/bpf/xdp_adjust_tail_user.c

169

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

samples/bpf/xdp_fwd_user.c

43

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

samples/bpf/xdp_router_ipv4_user.c

154

assert(bpf_map_update_elem(tx_port_map_fd,

samples/bpf/xdp_router_ipv4_user.c

183

assert(bpf_map_update_elem(exact_match_map_fd,

samples/bpf/xdp_router_ipv4_user.c

200

assert(bpf_map_update_elem(lpm_map_fd,

samples/bpf/xdp_router_ipv4_user.c

234

assert(bpf_map_update_elem(lpm_map_fd,

samples/bpf/xdp_router_ipv4_user.c

366

assert(bpf_map_update_elem(exact_match_map_fd,

samples/bpf/xdp_router_ipv4_user.c

376

assert(bpf_map_update_elem(arp_table_map_fd,

samples/bpf/xdp_sample.bpf.c

255

bpf_map_update_elem(&devmap_xmit_cnt_multi, &idx, &empty, BPF_NOEXIST);

samples/bpf/xdp_tx_iptunnel_user.c

286

if (bpf_map_update_elem(vip2tnl_map_fd, &vip, &tnl,

tools/bpf/bpftool/map.c

1016

err = bpf_map_update_elem(fd, key, value, flags);

tools/bpf/bpftool/prog.c

2380

if (bpf_map_update_elem(map_fd,

tools/lib/bpf/bpf.h

169

LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,

tools/lib/bpf/libbpf.c

11276

return bpf_map_update_elem(map->fd, key, value, flags);

tools/lib/bpf/libbpf.c

14075

err = bpf_map_update_elem(map->fd, &zero, map->st_ops->kern_vdata, 0);

tools/lib/bpf/libbpf.c

14129

err = bpf_map_update_elem(map->fd, &zero, map->st_ops->kern_vdata, 0);

tools/lib/bpf/libbpf.c

14499

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

tools/lib/bpf/libbpf.c

5311

err = bpf_map_update_elem(map->fd, &zero, map->mmaped, 0);

tools/lib/bpf/libbpf.c

5520

err = bpf_map_update_elem(map->fd, &i, &fd, 0);

tools/lib/bpf/libbpf.c

5554

err = bpf_map_update_elem(map->fd, &i, &fd, 0);

tools/lib/bpf/libbpf.c

6390

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

tools/lib/bpf/usdt.c

1106

if (is_new && bpf_map_update_elem(spec_map_fd, &spec_id, &target->spec, BPF_ANY)) {

tools/lib/bpf/usdt.c

1113

bpf_map_update_elem(ip_map_fd, &target->abs_ip, &spec_id, BPF_NOEXIST)) {

tools/perf/builtin-trace.c

4070

err = bpf_map_update_elem(map_enter_fd, &key, &prog_fd, BPF_ANY);

tools/perf/builtin-trace.c

4074

err = bpf_map_update_elem(map_exit_fd, &key, &prog_fd, BPF_ANY);

tools/perf/builtin-trace.c

4083

err = bpf_map_update_elem(beauty_map_fd, &key, beauty_array, BPF_ANY);

tools/perf/builtin-trace.c

4147

err = bpf_map_update_elem(map_enter_fd, &key, &prog_fd, BPF_ANY);

tools/perf/util/bpf-filter.c

312

bpf_map_update_elem(fd, &id, &the_id, BPF_ANY);

tools/perf/util/bpf-filter.c

367

if (bpf_map_update_elem(fd, &filter_idx, entry, BPF_NOEXIST) == 0)

tools/perf/util/bpf-filter.c

428

if (bpf_map_update_elem(fd, &key, &filter_idx, BPF_ANY) < 0) {

tools/perf/util/bpf-filter.c

487

bpf_map_update_elem(fd, &ret, &zero, BPF_ANY);

tools/perf/util/bpf-filter.c

523

if (bpf_map_update_elem(fd, &i, entry, BPF_ANY) < 0) {

tools/perf/util/bpf_counter.c

348

ret = bpf_map_update_elem(bpf_map__fd(skel->maps.events),

tools/perf/util/bpf_counter.c

490

err = bpf_map_update_elem(attr_map_fd, &evsel->core.attr, entry, BPF_ANY);

tools/perf/util/bpf_counter.c

560

err = bpf_map_update_elem(attr_map_fd, &evsel->core.attr, &entry, BPF_ANY);

tools/perf/util/bpf_counter.c

634

bpf_map_update_elem(filter_map_fd, &key, &fval, BPF_ANY);

tools/perf/util/bpf_counter.c

662

return bpf_map_update_elem(bpf_map__fd(skel->maps.events),

tools/perf/util/bpf_counter_cgroup.c

168

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

tools/perf/util/bpf_counter_cgroup.c

185

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

tools/perf/util/bpf_ftrace.c

103

bpf_map_update_elem(fd, &pid, &val, BPF_ANY);

tools/perf/util/bpf_ftrace.c

91

bpf_map_update_elem(fd, &cpu, &val, BPF_ANY);

tools/perf/util/bpf_kwork.c

177

bpf_map_update_elem(fd, &cpu.cpu, &val, BPF_ANY);

tools/perf/util/bpf_kwork.c

198

bpf_map_update_elem(fd, &key, kwork->profile_name, BPF_ANY);

tools/perf/util/bpf_kwork_top.c

152

bpf_map_update_elem(fd, &cpu.cpu, &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

338

bpf_map_update_elem(fd, &cpu, &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

350

bpf_map_update_elem(fd, &pid, &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

359

bpf_map_update_elem(fd, &pid, &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

368

bpf_map_update_elem(fd, &con->filters->types[i], &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

377

bpf_map_update_elem(fd, &con->filters->addrs[i], &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

386

bpf_map_update_elem(fd, &con->filters->cgrps[i], &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

393

bpf_map_update_elem(fd, &con->delays[i].addr, &con->delays[i].time, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

424

bpf_map_update_elem(fd, &key, &val, BPF_ANY);

tools/perf/util/bpf_lock_contention.c

490

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

tools/perf/util/bpf_off_cpu.c

242

bpf_map_update_elem(fd, &cpu, &val, BPF_ANY);

tools/perf/util/bpf_off_cpu.c

261

bpf_map_update_elem(fd, &tgid, &val, BPF_ANY);

tools/perf/util/bpf_off_cpu.c

271

bpf_map_update_elem(fd, &pid, &val, BPF_ANY);

tools/perf/util/bpf_off_cpu.c

293

bpf_map_update_elem(fd, &cgrp->id, &val, BPF_ANY);

tools/perf/util/bpf_off_cpu.c

81

bpf_map_update_elem(fd, &pid, &val, BPF_ANY);

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

169

bpf_map_update_elem(&prev_readings, &key, &val, BPF_ANY);

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

201

bpf_map_update_elem(&cgrp_readings, &key,

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

133

bpf_map_update_elem(&filter, &child_key, &child_fval, BPF_NOEXIST);

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

141

bpf_map_update_elem(&functime, &key, &now, BPF_ANY);

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

177

bpf_map_update_elem(&functime, &key, &now, BPF_ANY);

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

119

bpf_map_update_elem(&kwork_top_tasks, &key, &data, BPF_ANY);

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

135

bpf_map_update_elem(&kwork_top_works, key, &new_data, BPF_ANY);

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

223

bpf_map_update_elem(&kwork_top_irq_time, &key, &data, BPF_ANY);

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

295

bpf_map_update_elem(&kwork_top_irq_time, &key, &data, BPF_ANY);

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

129

bpf_map_update_elem(map, key, &zero, BPF_NOEXIST);

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

150

bpf_map_update_elem(map, key, &ts, BPF_ANY);

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

168

bpf_map_update_elem(map, key, name, BPF_ANY);

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

1048

bpf_map_update_elem(&slab_caches, &s, &d, BPF_NOEXIST);

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

343

if (bpf_map_update_elem(&task_data, &pid, &data, BPF_NOEXIST) == -E2BIG)

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

483

if (bpf_map_update_elem(&tstamp, &pid, &zero, BPF_NOEXIST) < 0) {

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

508

bpf_map_update_elem(&owner_stacks, stacktrace, &new_id, BPF_NOEXIST);

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

579

bpf_map_update_elem(&owner_stat, &key, &first, BPF_NOEXIST);

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

651

bpf_map_update_elem(&owner_data, &pelem->lock, &first, BPF_ANY);

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

883

err = bpf_map_update_elem(&lock_stat, &key, &first, BPF_NOEXIST);

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

950

bpf_map_update_elem(&lock_syms, &lock_addr, &lock_flag, BPF_ANY);

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

973

bpf_map_update_elem(&lock_syms, &lock_addr, &lock_flag, BPF_ANY);

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

998

bpf_map_update_elem(&lock_syms, &lock_addr, &lock_flag, BPF_ANY);

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

315

bpf_map_update_elem(&off_cpu, &key, &delta, BPF_ANY);

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

347

bpf_map_update_elem(&task_filter, &pid, &val, BPF_NOEXIST);

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

116

bpf_map_update_elem(&syscall_trace_map, &tid, &st, BPF_ANY);

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

80

bpf_map_update_elem(&syscall_stats_map, &key, &zero, BPF_NOEXIST);

tools/sched_ext/scx_flatcg.bpf.c

862

ret = bpf_map_update_elem(&cgv_node_stash, &cgid, &empty_stash,

tools/sched_ext/scx_pair.bpf.c

573

if (bpf_map_update_elem(&cgrp_q_idx_hash, &cgid, &q_idx, BPF_ANY)) {

tools/sched_ext/scx_pair.c

153

SCX_BUG_ON(bpf_map_update_elem(outer_fd, &i, &inner_fd, BPF_ANY),

tools/sched_ext/scx_userland.c

158

err = bpf_map_update_elem(dispatched_fd, NULL, &pid, 0);

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

160

err = bpf_map_update_elem(ctx.hashmap_fd, val, val, BPF_NOEXIST);

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

175

err = bpf_map_update_elem(ctx.array_map_fd, &i, val, 0);

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

186

err = bpf_map_update_elem(ctx.bloom_fd, NULL, val, 0);

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

72

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

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

196

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

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

108

if (bpf_map_update_elem(fd, &key, &val, 0)) {

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

160

err = bpf_map_update_elem(mim_fd, &i, &fd, 0);

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

273

return bpf_map_update_elem(map, &zero, &ctx.c2, BPF_NOEXIST);

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

275

err = bpf_map_update_elem(map, &zero, &ctx.p1, BPF_NOEXIST);

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

281

err = bpf_map_update_elem(map, &one, &ctx.c2, BPF_NOEXIST);

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

283

err = bpf_map_update_elem(map, &one, &ctx.p2, BPF_NOEXIST);

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

307

err = bpf_map_update_elem(map, &zero, &ctx.p1, BPF_NOEXIST);

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

308

err |= bpf_map_update_elem(map, &one, &ctx.p2, BPF_NOEXIST);

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

311

err = bpf_map_update_elem(map, &zero, &ctx.p2, BPF_NOEXIST);

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

312

err |= bpf_map_update_elem(map, &one, &ctx.c2, BPF_NOEXIST);

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

523

err = bpf_map_update_elem(bpf_map__fd(skel->maps.vip_map), &key, &val, BPF_ANY);

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

553

err = bpf_map_update_elem(outer_fd, &cpu, &inner_fd, BPF_ANY);

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

589

err = bpf_map_update_elem(lru_inner_fds[i], &fk, &lru, BPF_ANY);

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

613

err = bpf_map_update_elem(ch_fd, &k, &real_idx, BPF_ANY);

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

622

err = bpf_map_update_elem(bpf_map__fd(skel->maps.ctl_array), &key, &cval, BPF_ANY);

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

631

err = bpf_map_update_elem(bpf_map__fd(skel->maps.reals), &key, &real_v4, BPF_ANY);

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

640

err = bpf_map_update_elem(bpf_map__fd(skel->maps.reals), &key, &real_v6, BPF_ANY);

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

667

err = bpf_map_update_elem(bpf_map__fd(skel->maps.vip_miss_stats),

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

795

bpf_map_update_elem(stats_fd, &key, zeros, BPF_ANY);

tools/testing/selftests/bpf/flow_dissector_load.h

60

bpf_map_update_elem(prog_array_fd, &i, &fd, BPF_ANY);

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

1025

err = bpf_map_update_elem(fd, &key, &value, flags);

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

1033

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

1039

err = bpf_map_update_elem(fd, &key, &value, flags);

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

1059

err = bpf_map_update_elem(fd, &key, &value, 0);

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

1131

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

271

r = bpf_map_update_elem(map, key, value, 0);

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

379

assert(bpf_map_update_elem(map_fd_ipv4, key_ipv4, &value, 0) == 0);

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

384

assert(bpf_map_update_elem(map_fd_ipv4, key_ipv4, &value, 0) == 0);

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

389

assert(bpf_map_update_elem(map_fd_ipv4, key_ipv4, &value, 0) == 0);

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

394

assert(bpf_map_update_elem(map_fd_ipv4, key_ipv4, &value, 0) == 0);

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

399

assert(bpf_map_update_elem(map_fd_ipv4, key_ipv4, &value, 0) == 0);

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

404

assert(bpf_map_update_elem(map_fd_ipv6, key_ipv6, &value, 0) == 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

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

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

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

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

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

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

816

err = bpf_map_update_elem(fd, &key, &value, BPF_F_LOCK);

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

823

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST | BPF_EXIST);

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

830

err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);

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

837

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

845

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

850

err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);

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

859

err = bpf_map_update_elem(fd, &key, &value, BPF_ANY);

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

872

err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);

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

876

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

887

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

896

err = bpf_map_update_elem(fd, &key, &value, BPF_ANY);

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

911

err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);

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

929

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

940

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

951

err = bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST);

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

962

err = bpf_map_update_elem(fd, &key, &value, BPF_ANY);

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

969

err = bpf_map_update_elem(fd, &key, &value, BPF_EXIST);

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

980

err = bpf_map_update_elem(fd, &key, &value, BPF_ANY);

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/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

190

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

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

288

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

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

494

err = bpf_map_update_elem(map_fd, &sk_fd, &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

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

540

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

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

125

ret = bpf_map_update_elem(fd_map, &zero, &fd_val, BPF_NOEXIST);

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

122

err = bpf_map_update_elem(inner_map_fd, NULL, rand_vals + i, BPF_ANY);

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

129

err = bpf_map_update_elem(outer_map_fd, &key, &inner_map_fd, BPF_ANY);

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

181

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

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

185

err = bpf_map_update_elem(bloom_fd, NULL, &val, BPF_ANY);

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

50

err = bpf_map_update_elem(fd, NULL, &value, -1);

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

53

err = bpf_map_update_elem(fd, NULL, &value, BPF_EXIST);

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

56

err = bpf_map_update_elem(fd, NULL, &value, BPF_F_LOCK);

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

59

err = bpf_map_update_elem(fd, NULL, &value, BPF_NOEXIST);

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

62

err = bpf_map_update_elem(fd, NULL, &value, 10000);

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

82

err = bpf_map_update_elem(fd, NULL, &value, 0);

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_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

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

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

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

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

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_iter.c

1043

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

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

1212

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

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

1344

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

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

978

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

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_obj_id.c

64

err = bpf_map_update_elem(map_fds[i], &array_key,

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

230

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

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

132

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

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

5560

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

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

119

err = bpf_map_update_elem(bpf_map__fd(skel->maps.outer_sockarr), &zero,

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

125

err = bpf_map_update_elem(bpf_map__fd(skel->maps.outer_arr), &zero,

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

48

bpf_map_update_elem(outer_arr_fd, &key, &map1_fd, 0);

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

49

bpf_map_update_elem(outer_hash_fd, &key, &map2_fd, 0);

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

50

bpf_map_update_elem(outer_arr_dyn_fd, &key, &map3_fd, 0);

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

61

bpf_map_update_elem(outer_arr_fd, &key, &map2_fd, 0);

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

62

bpf_map_update_elem(outer_hash_fd, &key, &map1_fd, 0);

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

63

bpf_map_update_elem(outer_arr_dyn_fd, &key, &map4_fd, 0);

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

74

bpf_map_update_elem(outer_arr_dyn_fd, &key, &map5_fd, 0);

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

82

err = bpf_map_update_elem(outer_hash_fd, &key, &val, 0);

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

87

err = bpf_map_update_elem(outer_arr_fd, &key, &val, 0);

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

93

err = bpf_map_update_elem(outer_arr_dyn_fd, &key, &val, 0);

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

241

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

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

267

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

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

50

err = bpf_map_update_elem(bpf_map__fd(skel->maps.map_b), &cgroup_fd, &val1, BPF_ANY);

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/exceptions.c

36

if (!ASSERT_OK(bpf_map_update_elem(bpf_map__fd(skel->maps.jmp_table), &(int){0},

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

112

err = bpf_map_update_elem(inner_fd, &zero, &key, 0);

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

118

err = bpf_map_update_elem(fd, &key, &inner_fd, 0);

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

80

err = bpf_map_update_elem(inner_fd, &zero, &key, 0);

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

87

err = bpf_map_update_elem(ctx->fd, &key, &inner_fd, BPF_EXIST);

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

45

ret = bpf_map_update_elem(bpf_map__fd(data_map), &zero, result, 0);

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

582

err = bpf_map_update_elem(bpf_map__fd(skel->maps.cpu_map),

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

530

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

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/hash_large_key.c

30

err = bpf_map_update_elem(hash_map_fd, &key, &value, BPF_ANY);

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

143

bpf_map_update_elem(ctx->fd, &key, &value,

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

165

bpf_map_update_elem(ctx->fd, &key, &value, BPF_ANY | BPF_F_LOCK);

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

220

err = bpf_map_update_elem(ctx.fd, &key, &seed, BPF_ANY);

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

49

bpf_map_update_elem(ctx->fd, &key, &value, BPF_F_LOCK);

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

55

bpf_map_update_elem(ctx->fd, &key, &value, BPF_F_LOCK);

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

46

err = bpf_map_update_elem(bpf_map__fd(skel->maps.htab), &key, value, BPF_ANY);

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

58

err = bpf_map_update_elem(bpf_map__fd(skel->maps.htab), &key, value, BPF_ANY);

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

84

err = bpf_map_update_elem(ctx->fd, &key, &value, 0);

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

23

bpf_map_update_elem(map1_fd, &key, &val, 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

49

bpf_map_update_elem(map_fd, &ch_key, &real_num, 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/legacy_printk.c

25

err = bpf_map_update_elem(map_fd, &zero, &my_pid, BPF_ANY);

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

58

ret = bpf_map_update_elem(fd, &zero, &len, BPF_ANY);

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

63

ret = bpf_map_update_elem(bpf_map__fd(skel->maps.data_input), &zero,

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

36

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

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

74

bpf_map_update_elem(a->map_fd, &key, val, BPF_ANY);

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

94

if (bpf_map_update_elem(a->map_fd, &key, val, BPF_ANY))

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

83

err = bpf_map_update_elem(outer_fd, &key, &excl_fd, 0);

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

140

err = bpf_map_update_elem(outer_fd, &key, &inner_fd, BPF_NOEXIST);

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

158

err = bpf_map_update_elem(outer_fd, &key, &inner_fd, BPF_NOEXIST);

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

167

err = bpf_map_update_elem(outer_fd, &key, &inner_fd, BPF_EXIST);

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

187

err = bpf_map_update_elem(outer_fd, &key, &inner_fd, BPF_NOEXIST);

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

210

err = bpf_map_update_elem(outer_fd, &keys[0], &inner_fd, BPF_NOEXIST);

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

218

err = bpf_map_update_elem(outer_fd, &keys[1], &inner_fd, BPF_NOEXIST);

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

46

if (bpf_map_update_elem(ctx->outer_map_fd, &zero, &fd, 0) < 0)

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_lock.c

71

bpf_map_update_elem(map_fd[0], &key, vars, BPF_F_LOCK);

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

37

ret = bpf_map_update_elem(bpf_map__fd(skel->maps.percpu_array_map), &key, buf, 0);

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

40

ret = bpf_map_update_elem(bpf_map__fd(skel->maps.percpu_hash_map), &key, buf, 0);

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

43

ret = bpf_map_update_elem(bpf_map__fd(skel->maps.percpu_lru_hash_map), &key, buf, 0);

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

338

err = bpf_map_update_elem(reuseport_map_fd, &i, &value,

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

347

err = bpf_map_update_elem(migrate_map_fd, &value, &migrated_to,

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

107

CHECK_FAIL(bpf_map_update_elem(data_map_fd, &zero, &val, 0));

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

516

err = bpf_map_update_elem(bpf_map__fd(skel->maps.sock_map),

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

522

err = bpf_map_update_elem(bpf_map__fd(skel->maps.sock_map),

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

159

err = bpf_map_update_elem(map, &key, &client_fd, BPF_ANY);

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

25

err = bpf_map_update_elem(mfd, &key, &pfd, BPF_ANY);

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

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

413

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

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

29

err = bpf_map_update_elem(outer_fd, &zero, &tmpl_fd, 0);

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

39

err = bpf_map_update_elem(outer_fd, &zero, &good_fd, 0);

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

49

err = bpf_map_update_elem(outer_fd, &zero, &bad_fd, 0);

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

74

err = bpf_map_update_elem(bpf_map__fd(skel->maps.my_pid_map), &zero, &my_pid, 0);

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

51

err = bpf_map_update_elem(map_in_fd, NULL, &vals[i], 0);

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

56

err = bpf_map_update_elem(bpf_map__fd(bss_map), &zero, &bss, 0);

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

119

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

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

76

if (!ASSERT_OK(bpf_map_update_elem(fd, &key, &val, BPF_NOEXIST),

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

507

err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero,

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

632

err = bpf_map_update_elem(reuseport_array, &i, &sk_fds[i],

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

665

err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero, &ovr,

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

674

err = bpf_map_update_elem(outer_map, &index_zero, &reuseport_array,

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

687

err = bpf_map_update_elem(result_map, &i, &zero, BPF_ANY);

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

692

err = bpf_map_update_elem(linum_map, &zero, &zero, BPF_ANY);

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

812

ASSERT_OK(bpf_map_update_elem(fd, &key, val, 0), "update");

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

82

if (bpf_map_update_elem(map_fd, &key, data, 0)) {

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

832

ASSERT_OK(bpf_map_update_elem(fd, &key, val, 0), "update");

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

834

ASSERT_EQ(bpf_map_update_elem(fd, &key, val, 0), -EPERM,

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

889

ASSERT_OK(bpf_map_update_elem(fd, &key, val, 0), "update");

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

929

ASSERT_OK(bpf_map_update_elem(fd, &i, v, 0), "update");

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

956

ASSERT_OK(bpf_map_update_elem(fd, &key, val, 0), "update");

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

999

if (bpf_map_update_elem(fd, &key, f->blob, 0) || bpf_map_freeze(fd)) {

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

274

err = bpf_map_update_elem(server_map, &zero, &server, BPF_ANY);

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

446

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

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/sk_storage_tracing.c

63

err = bpf_map_update_elem(bpf_map__fd(skel->maps.del_sk_stg_map),

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

259

err = bpf_map_update_elem(sk_pkt_out_cnt_fd, &sk_fd, &scnt,

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

265

err = bpf_map_update_elem(sk_pkt_out_cnt10_fd, &sk_fd, &scnt,

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

1012

err = bpf_map_update_elem(map, &zero, &stream[0], BPF_ANY);

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

1016

err = bpf_map_update_elem(map, &zero, &dgram, BPF_ANY);

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

1020

err = bpf_map_update_elem(map, &zero, &udp, BPF_ANY);

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

1024

err = bpf_map_update_elem(map, &zero, &tcp, BPF_ANY);

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

1062

err = bpf_map_update_elem(map, &zero, &conn, BPF_ANY);

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

1104

ASSERT_ERR(bpf_map_update_elem(map, &zero, &s, BPF_ANY), "map_update");

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

1137

err = bpf_map_update_elem(map, &zero, &p0, BPF_ANY);

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

114

err = bpf_map_update_elem(map, &zero, &s, BPF_NOEXIST);

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

1141

err = bpf_map_update_elem(map, &one, &p1, BPF_ANY);

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

1216

err = bpf_map_update_elem(map, &zero, &p0, BPF_ANY);

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

1220

err = bpf_map_update_elem(map, &one, &p1, BPF_ANY);

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

1319

err = bpf_map_update_elem(map, &zero, &p0, BPF_ANY);

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

1323

err = bpf_map_update_elem(map, &one, &p1, BPF_ANY);

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

1395

err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);

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

146

err = bpf_map_update_elem(map, &zero, &c, BPF_NOEXIST);

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

267

err = bpf_map_update_elem(src, &zero, &sk, BPF_NOEXIST);

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

334

err = bpf_map_update_elem(src_fd, &i, &sock_fd[i], BPF_NOEXIST);

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

521

err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);

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

588

err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);

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

642

err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);

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

694

err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);

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

725

err = bpf_map_update_elem(map, &zero, &c1, BPF_NOEXIST);

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

819

err = bpf_map_update_elem(map, &zero, &stream, BPF_ANY);

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

823

err = bpf_map_update_elem(map, &zero, &dgram, BPF_ANY);

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

870

err = bpf_map_update_elem(map, &entry, &stream[0], BPF_ANY);

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

874

err = bpf_map_update_elem(map, &entry, &dgram, BPF_ANY);

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

878

err = bpf_map_update_elem(map, &entry, &udp, BPF_ANY);

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

882

err = bpf_map_update_elem(map, &entry, &tcp, BPF_ANY);

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

939

err = bpf_map_update_elem(map[i], &entry, &stream[0], BPF_ANY);

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

943

err = bpf_map_update_elem(map[i], &entry, &dgram, BPF_ANY);

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

947

err = bpf_map_update_elem(map[i], &entry, &udp, BPF_ANY);

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

951

err = bpf_map_update_elem(map[i], &entry, &tcp, BPF_ANY);

tools/testing/selftests/bpf/prog_tests/sockmap_helpers.h

31

int __ret = bpf_map_update_elem((fd), (key), (val), (flags)); \

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

107

err = bpf_map_update_elem(map, &zero, &s, BPF_ANY);

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

164

err = bpf_map_update_elem(map, &zero, &s, BPF_ANY);

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

42

err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);

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

47

err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);

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

629

err = bpf_map_update_elem(mapfd, &zero, &value, BPF_NOEXIST);

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

65

err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);

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

92

err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);

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

118

err = bpf_map_update_elem(map, &zero, &p0, BPF_NOEXIST);

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

122

err = bpf_map_update_elem(map, &one, &p1, BPF_NOEXIST);

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

185

err = bpf_map_update_elem(map, &zero, &p, BPF_NOEXIST);

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

246

err = bpf_map_update_elem(map, &zero, &p, BPF_NOEXIST);

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

315

err = bpf_map_update_elem(map, &zero, &p, BPF_NOEXIST);

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

389

err = bpf_map_update_elem(map, &zero, &p0, BPF_NOEXIST);

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

393

err = bpf_map_update_elem(map, &one, &p1, BPF_NOEXIST);

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

39

bpf_map_update_elem(control_map_fd, &key, &val, 0);

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

66

bpf_map_update_elem(control_map_fd, &key, &val, 0);

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

31

bpf_map_update_elem(control_map_fd, &key, &val, 0);

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

46

bpf_map_update_elem(control_map_fd, &key, &val, 0);

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

1055

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

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

1133

bpf_map_update_elem(map_fd, &zero, &prog1_fd, BPF_ANY);

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

1134

bpf_map_update_elem(map_fd, &zero, &prog2_fd, BPF_ANY);

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

117

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

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

1266

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

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

1285

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

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

1545

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

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

1553

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

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

1615

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

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

1625

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

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

1645

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

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

1690

err = bpf_map_update_elem(prog_array_fd, &key, &prog_fd, BPF_ANY);

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

1768

err = bpf_map_update_elem(prog_array_fd, &key, &prog_fd, BPF_ANY);

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

1773

err = bpf_map_update_elem(prog_array_fd, &key, &prog_fd, BPF_ANY);

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

1813

err = bpf_map_update_elem(prog_array_fd, &key, &prog_fd, BPF_ANY);

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

1880

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

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

202

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

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

277

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

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

471

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

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

477

err = bpf_map_update_elem(data_fd, &zero, &i, BPF_ANY);

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

487

err = bpf_map_update_elem(data_fd, &zero, &i, BPF_ANY);

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

561

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

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

567

err = bpf_map_update_elem(data_fd, &zero, &key[i], BPF_ANY);

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

577

err = bpf_map_update_elem(data_fd, &zero, &key[i], BPF_ANY);

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

642

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

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

66

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

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

723

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

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

805

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

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

900

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

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

916

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

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

96

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

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

965

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

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

194

err = bpf_map_update_elem(map_fd, &tid_fd, &map_val, 0);

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

290

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

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

342

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

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

350

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

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

373

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

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

407

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

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

413

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

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

439

err = bpf_map_update_elem(map_fd, &task_fd, &value, BPF_F_LOCK);

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

444

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

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

449

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

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

454

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

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

305

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

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_local_storage.c

66

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

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

116

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

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

124

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

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

581

err = bpf_map_update_elem(local_ip_map_fd, &key, &local_ip, BPF_ANY);

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

636

err = bpf_map_update_elem(local_ip_map_fd, &key, &local_ip, BPF_ANY);

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/test_xdp_veth.c

376

err = bpf_map_update_elem(flags_map, &protocol, &redirect_flags, BPF_NOEXIST);

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

403

err = bpf_map_update_elem(group_map, &ifindex, &devmap_val, 0);

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

523

err = bpf_map_update_elem(mac_map, &ifindex, &mac, 0);

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

530

err = bpf_map_update_elem(egress_map, &ifindex, &devmap_val, 0);

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

657

err = bpf_map_update_elem(mac_map, &ifindex, &mac, 0);

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

670

err = bpf_map_update_elem(egress_map, &key, &devmap_val, 0);

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

683

err = bpf_map_update_elem(res_map, &key, &sentinel_mac, 0);

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

103

ASSERT_OK(bpf_map_update_elem(map_fds[i], &key, vals, 0), "map_update_elem");

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

296

err = bpf_map_update_elem(bpf_map__fd(map), &key, &value, 0);

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

296

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data, BPF_ANY);

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

305

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data, BPF_ANY);

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

314

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data, BPF_ANY);

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

325

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data, BPF_ANY);

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

339

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data, BPF_ANY);

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

347

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data, BPF_ANY);

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

360

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data,

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

367

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data,

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

374

ret = bpf_map_update_elem(bpf_map__fd(map), &zero, &data,

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

358

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

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

136

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

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

47

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

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

156

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

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

219

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

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

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/prog_tests/xdp_metadata.c

455

ret = bpf_map_update_elem(bpf_map__fd(bpf_obj->maps.xsk), &queue_id, &sock_fd, 0);

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

44

bpf_map_update_elem(bpf_map__fd(skel->maps.vip_map), &key, &value, 0);

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

45

bpf_map_update_elem(bpf_map__fd(skel->maps.ch_rings), &ch_key, &real_num, 0);

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

46

bpf_map_update_elem(bpf_map__fd(skel->maps.reals), &real_num, &real_def, 0);

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

66

bpf_map_update_elem(inner_map, &key, &value, 0);

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

82

bpf_map_update_elem(&last_dissection, &key, &val, BPF_ANY);

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

26

bpf_map_update_elem(&hash_map_bench, key, &init_val, BPF_ANY);

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

46

bpf_map_update_elem(&hashmap1, val, val, BPF_ANY);

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

71

ret = bpf_map_update_elem(&hashmap1, &tmp_key, &tmp_val, 0);

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

54

return bpf_map_update_elem(&dst, &tmp, sk, 0) != 0;

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

87

bpf_map_update_elem(&sockmap, &(int){0}, sk, 0);

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

172

bpf_map_update_elem(&map1, &key, &val, BPF_ANY);

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

247

ret = bpf_map_update_elem(flow_map, &hash, &tmp, 0);

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

250

bpf_map_update_elem(&fq_nonprio_flows, &hash, &tmp, 0);

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

53

return bpf_map_update_elem(&percpu_attach_counters, &cg_id,

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

61

return bpf_map_update_elem(&attach_counters, &cg_id,

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

62

bpf_map_update_elem(&lru_map, &key, cgroup_val, BPF_ANY);

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

54

status = bpf_map_update_elem(&__cgrps_kfunc_map, &id, &local, BPF_NOEXIST);

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

219

status = bpf_map_update_elem(&__cgrps_kfunc_map, &id, &local, BPF_NOEXIST);

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

108

status = bpf_map_update_elem(&__cpumask_map, &key, &local, 0);

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

45

err = bpf_map_update_elem(&__crypto_ctx_map, &key, &local, 0);

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

96

bpf_map_update_elem(&testbuf_hash, name, &t, BPF_EXIST);

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

204

bpf_map_update_elem(&array_map1, &key, &ptr, 0);

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

222

bpf_map_update_elem(&array_map2, &key, &x, 0);

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

66

bpf_map_update_elem(&array_map3, &key, &val, 0);

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

872

: __imm(bpf_map_update_elem),

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

977

: __imm(bpf_map_update_elem),

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

81

bpf_map_update_elem(&array_map, &key, &val, 0);

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

18

bpf_map_update_elem(map, key, val, 0);

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

62

bpf_map_update_elem(&map, (void *)&key, &zero, BPF_ANY);

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

28

ret = bpf_map_update_elem(&sock_map, &zero, sk, 0);

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

31

bpf_map_update_elem(&htab, &ctx->from, zeroed_value, flags);

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

34

update_err = bpf_map_update_elem(&htab, &key, &value, BPF_ANY);

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

64

bpf_map_update_elem(&slab_hash, &s, r->name, BPF_NOEXIST);

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

52

bpf_map_update_elem(&map1, &key_struct, &val_struct, 0);

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

53

bpf_map_update_elem(&map2, &key, &val, 0);

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

54

bpf_map_update_elem(&map_weak, &key, &val, 0);

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

46

bpf_map_update_elem(&map1, &key_struct, &val_struct, 0);

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

47

bpf_map_update_elem(&map2, &key, &val, 0);

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

48

bpf_map_update_elem(&map_weak, &key, &val, 0);

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

45

bpf_map_update_elem(&test_result, &map_key, &test_passed, BPF_ANY);

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

130

err = bpf_map_update_elem(&trie_map, &key, &val, BPF_NOEXIST);

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

153

err = bpf_map_update_elem(&trie_map, &key, &val, BPF_EXIST);

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

26

bpf_map_update_elem(&lru_map, &(int){0}, &v, 0);

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

36

bpf_map_update_elem(&lru_map, &(int){0}, &val, 0);

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

26

bpf_map_update_elem(&lru_map, &key, &val, BPF_ANY);

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

58

bpf_map_update_elem(&verity_devices, &dev, &zero, BPF_NOEXIST);

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

23

bpf_map_update_elem(&excl_map, &key, &value, 0);

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

32

bpf_map_update_elem(&excl_map, &key, &value, 0);

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

409

bpf_map_update_elem(&hash_map, &key, &val, 0);

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

410

bpf_map_update_elem(&hash_malloc_map, &key, &val, 0);

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

411

bpf_map_update_elem(&lru_hash_map, &key, &val, 0);

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

413

bpf_map_update_elem(&pcpu_hash_map, &key, &val, 0);

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

414

bpf_map_update_elem(&pcpu_hash_malloc_map, &key, &val, 0);

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

415

bpf_map_update_elem(&lru_pcpu_hash_map, &key, &val, 0);

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

557

ret = bpf_map_update_elem(&array_map, &key, &init, BPF_EXIST);

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

570

ret = bpf_map_update_elem(&map, &key, &init, BPF_NOEXIST); \

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

582

ret = bpf_map_update_elem(&map, &key, &init, BPF_EXIST); \

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

49

if (bpf_map_update_elem(&race_hash_map, &key, &val, BPF_ANY))

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

96

if (bpf_map_update_elem(&race_percpu_hash_map, &key, &val, BPF_ANY))

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

126

if (bpf_map_update_elem(hash, &key, &val, 0))

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

49

bpf_map_update_elem(&mptcp_sf, &key, &init, BPF_ANY);

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

149

bpf_map_update_elem(&time_map, &key, &dinfo, BPF_ANY);

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

203

bpf_map_update_elem(&percpu, &key, &value, BPF_ANY);

tools/testing/selftests/bpf/progs/profiler.inc.h

410

bpf_map_update_elem(&var_tpid_to_data, &tpid,

tools/testing/selftests/bpf/progs/profiler.inc.h

439

bpf_map_update_elem(&var_tpid_to_data, &tpid, arr_struct, 0);

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

192

bpf_map_update_elem(&symbolmap, sym, &zero, 0);

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

319

bpf_map_update_elem(&symbolmap, &sym, &zero, 0);

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

103

err = bpf_map_update_elem(&rhmap, &key, &empty, BPF_NOEXIST);

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

143

ret = bpf_map_update_elem(&rhmap, &key, &val1, BPF_EXIST);

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

148

ret = bpf_map_update_elem(&rhmap, &key, &val1, BPF_NOEXIST);

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

158

ret = bpf_map_update_elem(&rhmap, &key, &val2, BPF_EXIST);

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

185

ret = bpf_map_update_elem(&rhmap, &key, &val1, BPF_ANY);

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

194

ret = bpf_map_update_elem(&rhmap, &key, &val2, BPF_ANY);

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

218

ret = bpf_map_update_elem(&rhmap, &key, &val, BPF_NOEXIST);

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

223

ret = bpf_map_update_elem(&rhmap, &key, &val, BPF_NOEXIST);

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

42

err = bpf_map_update_elem(&rhmap, &key, &empty, BPF_NOEXIST);

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

68

err = bpf_map_update_elem(&rhmap, &key, &empty, BPF_NOEXIST);

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

66

bpf_map_update_elem(&prot_map, &key, &val1, BPF_ANY);

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

67

bpf_map_update_elem(&not_prot_map, &key, &val2, BPF_ANY);

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

39

bpf_map_update_elem(&tcp_conn_sockets, &key, &sock_cookie, 0);

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

41

bpf_map_update_elem(&udp_conn_sockets, &keyc, &sock_cookie, 0);

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

69

bpf_map_update_elem(&stackid_hmap, &key, &val, 0);

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

52

bpf_map_update_elem(&stackid_hmap, &key, &val, 0);

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

54

status = bpf_map_update_elem(&__tasks_kfunc_map, &pid, &local, BPF_NOEXIST);

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

207

status = bpf_map_update_elem(&__tasks_kfunc_map, &pid, &local, BPF_NOEXIST);

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

62

err = bpf_map_update_elem(&hmap, &key, &empty_work, BPF_NOEXIST);

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

98

err = bpf_map_update_elem(&lrumap, &key, &empty_work, BPF_NOEXIST);

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

49

bpf_map_update_elem(&hmap, &key, &empty_work, BPF_NOEXIST);

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

42

bpf_map_update_elem(&hashmap1, &key, &val, 0);

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

133

bpf_map_update_elem(inner_map, &key, &val, 0);

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

139

bpf_map_update_elem(inner_map, &key, &val, 0);

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

145

bpf_map_update_elem(inner_map, &key, &val, 0);

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

38

bpf_map_update_elem(&results, &zero, &tgid, 0);

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

68

bpf_map_update_elem(&result_##map, &key, var, 0); \

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

22

bpf_map_update_elem(&values, &index, &value, 0);

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

39

if (bpf_map_update_elem(&hash_map, key, &value, BPF_ANY))

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

21

bpf_map_update_elem(&hash_map, &set_key, &set_value, BPF_NOEXIST);

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

62

bpf_map_update_elem(map, &key, &value, 0);

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

71

bpf_map_update_elem(map, &key, &value, 0);

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

28

bpf_map_update_elem(&hashmap1, &inKey, &inValue, BPF_NOEXIST);

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

114

bpf_map_update_elem(&array_map, &key, &val, flags);

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

132

bpf_map_update_elem(&array_map, &key, &val, flags);

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

46

err = bpf_map_update_elem(&hash_map, &key, &val, BPF_NOEXIST);

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

36

bpf_map_update_elem(&data_map, &two, (const void *)&in_val, 0);

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

42

bpf_map_update_elem(&data_map, &one, &val, 0);

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

47

bpf_map_update_elem(&data_map, &far, &val, 0);

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

62

bpf_map_update_elem(&hash_map, sample, &sample->seq, BPF_ANY);

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

176

bpf_map_update_elem(&linum_map, &index_zero, &linum, BPF_ANY);

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

177

bpf_map_update_elem(&data_check_map, &index_zero, &data_check, BPF_ANY);

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

602

bpf_map_update_elem(&run_map, &KEY_PROG1, &PROG_DONE, BPF_ANY);

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

609

bpf_map_update_elem(&run_map, &KEY_PROG2, &PROG_DONE, BPF_ANY);

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

616

bpf_map_update_elem(&run_map, &KEY_PROG1, &PROG_DONE, BPF_ANY);

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

623

bpf_map_update_elem(&run_map, &KEY_PROG2, &PROG_DONE, BPF_ANY);

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

648

bpf_map_update_elem(&run_map, &KEY_PROG1, &PROG_DONE, BPF_ANY);

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

656

bpf_map_update_elem(&run_map, &KEY_PROG2, &PROG_DONE, BPF_ANY);

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

93

bpf_map_update_elem(&my_map, &zero_key, &zero_value, BPF_ANY);

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

120

bpf_map_update_elem(&linum_map, &linum_idx, &linum, BPF_ANY); \

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

19

bpf_map_update_elem(&map, &key, skops->sk, 0);

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

38

if (bpf_map_update_elem(&dst_sock_map, &key, sk, 0))

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

41

if (bpf_map_update_elem(&dst_sock_hash, &key, sk, 0))

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

62

bpf_map_update_elem(&hmap, &key, &zero, 0);

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

57

bpf_map_update_elem(&stackid_hmap, &key, &val, 0);

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

49

bpf_map_update_elem(&map2, &key, &value, BPF_ANY);

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

45

if (bpf_map_update_elem(&flow_map, &key, &tstamp, BPF_ANY))

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

58

if (bpf_map_update_elem(&flow_map, &key, &next_tstamp, BPF_EXIST))

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

244

bpf_map_update_elem(&ev_record_map, &key, &ev, BPF_ANY);

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

79

bpf_map_update_elem(&global_map, &key, &g,

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

568

bpf_map_update_elem(lru_map, &pckt->flow, &new_dst_lru, 0);

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

123

bpf_map_update_elem(map, &lru_key, &init, 0);

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

155

bpf_map_update_elem(&lru, &lru_key, &init, 0);

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

288

bpf_map_update_elem(&hmap, &key, &init, 0);

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

293

bpf_map_update_elem(&hmap, &key, &init, 0);

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

295

bpf_map_update_elem(&hmap_malloc, &key_malloc, &init, 0);

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

300

bpf_map_update_elem(&hmap_malloc, &key_malloc, &init, 0);

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

306

bpf_map_update_elem(&hmap, &key, &init, 0);

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

311

bpf_map_update_elem(&hmap, &key, &init, 0);

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

318

bpf_map_update_elem(&hmap_malloc, &key_malloc, &init, 0);

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

323

bpf_map_update_elem(&hmap_malloc, &key_malloc, &init, 0);

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

438

bpf_map_update_elem(map, key, &init, BPF_ANY);

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

466

bpf_map_update_elem(&race_array, &key, &init, BPF_ANY);

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

40

bpf_map_update_elem(map, &(int){0}, &value, 0);

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

77

bpf_map_update_elem(inner_map, &hash_key, &init, 0);

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

63

bpf_map_update_elem(inner_map, &hash_key, &init, 0);

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

155

: __imm(bpf_map_update_elem),

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

33

: __imm(bpf_map_update_elem),

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

1019

__imm(bpf_map_update_elem),

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

1045

__imm(bpf_map_update_elem),

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

49

bpf_map_update_elem(&sockmap, &zero, sk, BPF_ANY);

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

50

bpf_map_update_elem(&sockhash, &zero, sk, BPF_ANY);

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

213

: __imm(bpf_map_update_elem),

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

67

bpf_map_update_elem(map, key, &init, 0))

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

99

if (bpf_map_update_elem(map, key, &init, 0))

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

358

bpf_map_update_elem(lru_map, flow, &new_lru, BPF_ANY);

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

100

bpf_map_update_elem(&rx_mac, &key, &mac, 0);

tools/testing/selftests/bpf/test_lru_map.c

186

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

tools/testing/selftests/bpf/test_lru_map.c

187

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

191

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST) == -EEXIST);

tools/testing/selftests/bpf/test_lru_map.c

194

assert(bpf_map_update_elem(lru_map_fd, &key, value, -1) == -EINVAL);

tools/testing/selftests/bpf/test_lru_map.c

203

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_EXIST) == -ENOENT);

tools/testing/selftests/bpf/test_lru_map.c

206

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

tools/testing/selftests/bpf/test_lru_map.c

222

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

tools/testing/selftests/bpf/test_lru_map.c

223

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

284

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

291

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

303

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

305

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

353

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

368

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

372

assert(bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

382

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

386

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

399

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

405

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

407

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

457

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

464

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

472

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

474

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

514

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

518

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST));

tools/testing/selftests/bpf/test_lru_map.c

522

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

533

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

535

assert(!bpf_map_update_elem(expected_map_fd, &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

581

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

tools/testing/selftests/bpf/test_lru_map.c

635

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

637

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

650

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

655

assert(!bpf_map_update_elem(lru_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

657

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

703

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

tools/testing/selftests/bpf/test_lru_map.c

704

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

708

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST) == -EEXIST);

tools/testing/selftests/bpf/test_lru_map.c

718

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_EXIST) == -ENOENT);

tools/testing/selftests/bpf/test_lru_map.c

721

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

tools/testing/selftests/bpf/test_lru_map.c

744

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

tools/testing/selftests/bpf/test_lru_map.c

745

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

794

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

tools/testing/selftests/bpf/test_lru_map.c

797

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_NOEXIST) == -EEXIST);

tools/testing/selftests/bpf/test_lru_map.c

807

assert(bpf_map_update_elem(lru_map_fd, &key, value, BPF_EXIST) == -ENOENT);

tools/testing/selftests/bpf/test_lru_map.c

810

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

tools/testing/selftests/bpf/test_lru_map.c

811

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_lru_map.c

835

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

tools/testing/selftests/bpf/test_lru_map.c

836

assert(!bpf_map_update_elem(expected_map_fd, &key, value,

tools/testing/selftests/bpf/test_maps.c

1021

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1027

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1033

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);

tools/testing/selftests/bpf/test_maps.c

1063

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1069

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1075

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);

tools/testing/selftests/bpf/test_maps.c

1090

bpf_map_update_elem(map_fd_tx, &i,

tools/testing/selftests/bpf/test_maps.c

1092

bpf_map_update_elem(map_fd_rx, &i,

tools/testing/selftests/bpf/test_maps.c

1216

err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);

tools/testing/selftests/bpf/test_maps.c

1233

err = bpf_map_update_elem(mim_fd, &pos, &fd, 0);

tools/testing/selftests/bpf/test_maps.c

1335

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

tools/testing/selftests/bpf/test_maps.c

1339

assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

1413

while (bpf_map_update_elem(map_fd, key, value, flags)) {

tools/testing/selftests/bpf/test_maps.c

1500

assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

1553

assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) < 0 &&

tools/testing/selftests/bpf/test_maps.c

1582

assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

1614

assert(bpf_map_update_elem(fd, NULL, &value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

1673

err = bpf_map_update_elem(map_fd, &index0, value, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

169

assert(bpf_map_update_elem(fd, &key, value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

1701

err = bpf_map_update_elem(map_fd, &index0, value,

tools/testing/selftests/bpf/test_maps.c

1741

err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1769

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1778

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1787

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

179

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

tools/testing/selftests/bpf/test_maps.c

1795

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1804

err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],

tools/testing/selftests/bpf/test_maps.c

1814

err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

1820

err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

183

assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

1833

err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1859

err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

1875

err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);

tools/testing/selftests/bpf/test_maps.c

188

assert(bpf_map_update_elem(fd, &key, value, -1) < 0 &&

tools/testing/selftests/bpf/test_maps.c

203

assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

209

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

tools/testing/selftests/bpf/test_maps.c

216

assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

244

assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);

tools/testing/selftests/bpf/test_maps.c

318

assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);

tools/testing/selftests/bpf/test_maps.c

382

assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

385

assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

399

assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

440

assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

443

assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

458

assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

47

assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

503

assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

51

assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

56

assert(bpf_map_update_elem(fd, &key, &value, -1) < 0 &&

tools/testing/selftests/bpf/test_maps.c

573

assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);

tools/testing/selftests/bpf/test_maps.c

576

assert(bpf_map_update_elem(fd, NULL, &val, 0) < 0 &&

tools/testing/selftests/bpf/test_maps.c

584

assert(bpf_map_update_elem(fd, NULL, &vals[i], BPF_EXIST) == 0);

tools/testing/selftests/bpf/test_maps.c

629

assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);

tools/testing/selftests/bpf/test_maps.c

632

assert(bpf_map_update_elem(fd, NULL, &val, 0) < 0 &&

tools/testing/selftests/bpf/test_maps.c

640

assert(bpf_map_update_elem(fd, NULL, &vals[i], BPF_EXIST) == 0);

tools/testing/selftests/bpf/test_maps.c

65

assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

74

assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

765

err = bpf_map_update_elem(fd, &(int){0}, &udp, BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

774

err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

79

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

tools/testing/selftests/bpf/test_maps.c

85

assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

90

assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == 0);

tools/testing/selftests/bpf/test_maps.c

92

assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);

tools/testing/selftests/bpf/test_maps.c

937

err = bpf_map_update_elem(map_fd_rx, &i, &sfd[i], BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

94

assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&

tools/testing/selftests/bpf/test_maps.c

943

err = bpf_map_update_elem(map_fd_tx, &i, &sfd[i], BPF_ANY);

tools/testing/selftests/bpf/test_maps.c

969

err = bpf_map_update_elem(map_fd_msg, &i, &sfd[2], BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1011

err = bpf_map_update_elem(map_fd[1], &i, &c1, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1024

err = bpf_map_update_elem(map_fd[2], &i, &redir_fd, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1033

err = bpf_map_update_elem(map_fd[3],

tools/testing/selftests/bpf/test_sockmap.c

1044

err = bpf_map_update_elem(map_fd[4],

tools/testing/selftests/bpf/test_sockmap.c

1055

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1067

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1079

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1091

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1103

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1113

bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1119

err = bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1129

bpf_map_update_elem(map_fd[5],

tools/testing/selftests/bpf/test_sockmap.c

1138

err = bpf_map_update_elem(map_fd[6], &i, &in, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1145

err = bpf_map_update_elem(map_fd[1], &i, &p1, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1151

err = bpf_map_update_elem(map_fd[2], &i, &p1, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1159

err = bpf_map_update_elem(map_fd[2], &i, &p2, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1173

err = bpf_map_update_elem(map_fd[7],

tools/testing/selftests/bpf/test_sockmap.c

1182

err = bpf_map_update_elem(map_fd[0], &i, &skb_fd, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1193

err = bpf_map_update_elem(map_fd[7], &i, &skb_use_parser, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1230

bpf_map_update_elem(map_fd[i], &key, &zero, BPF_ANY);

tools/testing/selftests/bpf/test_sockmap.c

1232

bpf_map_update_elem(map_fd[i], &key, &zero, BPF_ANY);

tools/testing/selftests/bpf/test_tcp_hdr_options.h

145

bpf_map_update_elem(&lport_linum_map, &__lport, &__linum_err, BPF_NOEXIST); \

tools/testing/selftests/bpf/test_verifier.c

572

assert(!bpf_map_update_elem(fd, &index, &value, 0));

tools/testing/selftests/bpf/test_verifier.c

619

if (bpf_map_update_elem(mfd, &p1key, &p1fd, BPF_ANY) < 0)

tools/testing/selftests/bpf/test_verifier.c

621

if (bpf_map_update_elem(mfd, &p2key, &p2fd, BPF_ANY) < 0)

tools/testing/selftests/bpf/test_verifier.c

623

if (bpf_map_update_elem(mfd, &p3key, &p3fd, BPF_ANY) < 0) {

tools/testing/selftests/bpf/xdp_hw_metadata.c

869

ret = bpf_map_update_elem(bpf_map__fd(bpf_obj->maps.xsk), &queue_id, &sock_fd, 0);

tools/testing/selftests/bpf/xdp_synproxy.c

408

err = bpf_map_update_elem(ports_map_fd, &port_idx, &port, BPF_ANY);

tools/testing/selftests/bpf/xdp_synproxy.c

418

err = bpf_map_update_elem(ports_map_fd, &port_idx, &port_last, BPF_ANY);

tools/testing/selftests/bpf/xdp_synproxy.c

432

err = bpf_map_update_elem(values_map_fd, &key, &tcpipopts, BPF_ANY);

tools/testing/selftests/bpf/xsk.c

455

return bpf_map_update_elem(map_fd, &index, &sock_fd, 0);

tools/testing/selftests/hid/progs/hid.c

494

if (bpf_map_update_elem(&hmap, key, &init, 0))

tools/testing/selftests/net/lib/xdp_metadata.bpf.c

149

bpf_map_update_elem(&map_rss, &key, &hash, BPF_ANY);

tools/testing/selftests/net/lib/xdp_metadata.bpf.c

153

bpf_map_update_elem(&map_rss, &key, &val, BPF_ANY);

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

220

bpf_map_update_elem(&peek_results, &key, &pid, BPF_ANY);

tools/tracing/rtla/src/timerlat.bpf.c

76

bpf_map_update_elem(map, &key, &value, BPF_ANY);

tools/tracing/rtla/tests/bpf/bpf_action_map.c

22

bpf_map_update_elem(&rtla_test_map, &key, &value, BPF_ANY);