Blame view
kernel/bpf/bpf_iter.c
14.7 KB
ae24345da bpf: Implement an... |
1 2 3 4 |
// SPDX-License-Identifier: GPL-2.0-only /* Copyright (c) 2020 Facebook */ #include <linux/fs.h> |
ac51d99bf bpf: Create anony... |
5 |
#include <linux/anon_inodes.h> |
ae24345da bpf: Implement an... |
6 7 8 9 10 |
#include <linux/filter.h> #include <linux/bpf.h> struct bpf_iter_target_info { struct list_head list; |
15172a46f bpf: net: Refacto... |
11 |
const struct bpf_iter_reg *reg_info; |
15d83c4d7 bpf: Allow loadin... |
12 |
u32 btf_id; /* cached value */ |
ae24345da bpf: Implement an... |
13 |
}; |
de4e05cac bpf: Support bpf ... |
14 15 |
struct bpf_iter_link { struct bpf_link link; |
a5cbe05a6 bpf: Implement bp... |
16 |
struct bpf_iter_aux_info aux; |
de4e05cac bpf: Support bpf ... |
17 18 |
struct bpf_iter_target_info *tinfo; }; |
ac51d99bf bpf: Create anony... |
19 20 |
struct bpf_iter_priv_data { struct bpf_iter_target_info *tinfo; |
a5cbe05a6 bpf: Implement bp... |
21 |
const struct bpf_iter_seq_info *seq_info; |
ac51d99bf bpf: Create anony... |
22 23 24 25 26 27 |
struct bpf_prog *prog; u64 session_id; u64 seq_num; bool done_stop; u8 target_private[] __aligned(8); }; |
ae24345da bpf: Implement an... |
28 29 |
static struct list_head targets = LIST_HEAD_INIT(targets); static DEFINE_MUTEX(targets_mutex); |
2057c92bc bpf: Support bpf ... |
30 31 |
/* protect bpf_iter_link changes */ static DEFINE_MUTEX(link_mutex); |
ac51d99bf bpf: Create anony... |
32 33 |
/* incremented on every opened seq_file */ static atomic64_t session_id; |
a5cbe05a6 bpf: Implement bp... |
34 35 |
static int prepare_seq_file(struct file *file, struct bpf_iter_link *link, const struct bpf_iter_seq_info *seq_info); |
367ec3e48 bpf: Create file ... |
36 |
|
e5158d987 bpf: Implement co... |
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
static void bpf_iter_inc_seq_num(struct seq_file *seq) { struct bpf_iter_priv_data *iter_priv; iter_priv = container_of(seq->private, struct bpf_iter_priv_data, target_private); iter_priv->seq_num++; } static void bpf_iter_dec_seq_num(struct seq_file *seq) { struct bpf_iter_priv_data *iter_priv; iter_priv = container_of(seq->private, struct bpf_iter_priv_data, target_private); iter_priv->seq_num--; } static void bpf_iter_done_stop(struct seq_file *seq) { struct bpf_iter_priv_data *iter_priv; iter_priv = container_of(seq->private, struct bpf_iter_priv_data, target_private); iter_priv->done_stop = true; } |
e679654a7 bpf: Fix a rcu_sc... |
63 64 |
/* maximum visited objects before bailing out */ #define MAX_ITER_OBJECTS 1000000 |
fd4f12bc3 bpf: Implement bp... |
65 66 67 68 69 70 71 72 73 74 75 76 |
/* bpf_seq_read, a customized and simpler version for bpf iterator. * no_llseek is assumed for this file. * The following are differences from seq_read(): * . fixed buffer size (PAGE_SIZE) * . assuming no_llseek * . stop() may call bpf program, handling potential overflow there */ static ssize_t bpf_seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos) { struct seq_file *seq = file->private_data; size_t n, offs, copied = 0; |
e679654a7 bpf: Fix a rcu_sc... |
77 |
int err = 0, num_objs = 0; |
fd4f12bc3 bpf: Implement bp... |
78 79 80 81 82 |
void *p; mutex_lock(&seq->lock); if (!seq->buf) { |
af6532094 bpf: Bump iter se... |
83 84 |
seq->size = PAGE_SIZE << 3; seq->buf = kvmalloc(seq->size, GFP_KERNEL); |
fd4f12bc3 bpf: Implement bp... |
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
if (!seq->buf) { err = -ENOMEM; goto done; } } if (seq->count) { n = min(seq->count, size); err = copy_to_user(buf, seq->buf + seq->from, n); if (err) { err = -EFAULT; goto done; } seq->count -= n; seq->from += n; copied = n; goto done; } seq->from = 0; p = seq->op->start(seq, &seq->index); if (!p) goto stop; if (IS_ERR(p)) { err = PTR_ERR(p); seq->op->stop(seq, p); seq->count = 0; goto done; } err = seq->op->show(seq, p); if (err > 0) { |
e5158d987 bpf: Implement co... |
117 118 119 120 |
/* object is skipped, decrease seq_num, so next * valid object can reuse the same seq_num. */ bpf_iter_dec_seq_num(seq); |
fd4f12bc3 bpf: Implement bp... |
121 122 123 124 125 126 127 128 129 130 131 |
seq->count = 0; } else if (err < 0 || seq_has_overflowed(seq)) { if (!err) err = -E2BIG; seq->op->stop(seq, p); seq->count = 0; goto done; } while (1) { loff_t pos = seq->index; |
e679654a7 bpf: Fix a rcu_sc... |
132 |
num_objs++; |
fd4f12bc3 bpf: Implement bp... |
133 134 135 136 137 138 139 140 141 142 143 144 |
offs = seq->count; p = seq->op->next(seq, p, &seq->index); if (pos == seq->index) { pr_info_ratelimited("buggy seq_file .next function %ps " "did not updated position index ", seq->op->next); seq->index++; } if (IS_ERR_OR_NULL(p)) break; |
e5158d987 bpf: Implement co... |
145 146 |
/* got a valid next object, increase seq_num */ bpf_iter_inc_seq_num(seq); |
fd4f12bc3 bpf: Implement bp... |
147 148 |
if (seq->count >= size) break; |
e679654a7 bpf: Fix a rcu_sc... |
149 150 151 152 153 154 155 156 |
if (num_objs >= MAX_ITER_OBJECTS) { if (offs == 0) { err = -EAGAIN; seq->op->stop(seq, p); goto done; } break; } |
fd4f12bc3 bpf: Implement bp... |
157 158 |
err = seq->op->show(seq, p); if (err > 0) { |
e5158d987 bpf: Implement co... |
159 |
bpf_iter_dec_seq_num(seq); |
fd4f12bc3 bpf: Implement bp... |
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 |
seq->count = offs; } else if (err < 0 || seq_has_overflowed(seq)) { seq->count = offs; if (offs == 0) { if (!err) err = -E2BIG; seq->op->stop(seq, p); goto done; } break; } } stop: offs = seq->count; /* bpf program called if !p */ seq->op->stop(seq, p); |
e5158d987 bpf: Implement co... |
176 177 178 179 180 181 182 183 184 |
if (!p) { if (!seq_has_overflowed(seq)) { bpf_iter_done_stop(seq); } else { seq->count = offs; if (offs == 0) { err = -E2BIG; goto done; } |
fd4f12bc3 bpf: Implement bp... |
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 |
} } n = min(seq->count, size); err = copy_to_user(buf, seq->buf, n); if (err) { err = -EFAULT; goto done; } copied = n; seq->count -= n; seq->from = n; done: if (!copied) copied = err; else *ppos += copied; mutex_unlock(&seq->lock); return copied; } |
a5cbe05a6 bpf: Implement bp... |
205 206 207 208 209 210 211 212 213 214 215 216 217 |
static const struct bpf_iter_seq_info * __get_seq_info(struct bpf_iter_link *link) { const struct bpf_iter_seq_info *seq_info; if (link->aux.map) { seq_info = link->aux.map->ops->iter_seq_info; if (seq_info) return seq_info; } return link->tinfo->reg_info->seq_info; } |
367ec3e48 bpf: Create file ... |
218 219 220 |
static int iter_open(struct inode *inode, struct file *file) { struct bpf_iter_link *link = inode->i_private; |
a5cbe05a6 bpf: Implement bp... |
221 |
return prepare_seq_file(file, link, __get_seq_info(link)); |
367ec3e48 bpf: Create file ... |
222 |
} |
ac51d99bf bpf: Create anony... |
223 224 225 226 227 228 229 230 231 232 233 |
static int iter_release(struct inode *inode, struct file *file) { struct bpf_iter_priv_data *iter_priv; struct seq_file *seq; seq = file->private_data; if (!seq) return 0; iter_priv = container_of(seq->private, struct bpf_iter_priv_data, target_private); |
a5cbe05a6 bpf: Implement bp... |
234 235 |
if (iter_priv->seq_info->fini_seq_private) iter_priv->seq_info->fini_seq_private(seq->private); |
ac51d99bf bpf: Create anony... |
236 237 238 239 240 241 |
bpf_prog_put(iter_priv->prog); seq->private = iter_priv; return seq_release_private(inode, file); } |
367ec3e48 bpf: Create file ... |
242 243 |
const struct file_operations bpf_iter_fops = { .open = iter_open, |
ac51d99bf bpf: Create anony... |
244 245 246 247 |
.llseek = no_llseek, .read = bpf_seq_read, .release = iter_release, }; |
15172a46f bpf: net: Refacto... |
248 249 250 251 252 253 |
/* The argument reg_info will be cached in bpf_iter_target_info. * The common practice is to declare target reg_info as * a const static variable and passed as an argument to * bpf_iter_reg_target(). */ int bpf_iter_reg_target(const struct bpf_iter_reg *reg_info) |
ae24345da bpf: Implement an... |
254 255 256 257 258 259 |
{ struct bpf_iter_target_info *tinfo; tinfo = kmalloc(sizeof(*tinfo), GFP_KERNEL); if (!tinfo) return -ENOMEM; |
15172a46f bpf: net: Refacto... |
260 |
tinfo->reg_info = reg_info; |
ae24345da bpf: Implement an... |
261 262 263 264 265 266 267 268 |
INIT_LIST_HEAD(&tinfo->list); mutex_lock(&targets_mutex); list_add(&tinfo->list, &targets); mutex_unlock(&targets_mutex); return 0; } |
ab2ee4fcb bpf: Change func ... |
269 |
void bpf_iter_unreg_target(const struct bpf_iter_reg *reg_info) |
ae24345da bpf: Implement an... |
270 271 272 273 274 275 |
{ struct bpf_iter_target_info *tinfo; bool found = false; mutex_lock(&targets_mutex); list_for_each_entry(tinfo, &targets, list) { |
ab2ee4fcb bpf: Change func ... |
276 |
if (reg_info == tinfo->reg_info) { |
ae24345da bpf: Implement an... |
277 278 279 280 281 282 283 284 285 286 |
list_del(&tinfo->list); kfree(tinfo); found = true; break; } } mutex_unlock(&targets_mutex); WARN_ON(found == false); } |
15d83c4d7 bpf: Allow loadin... |
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 |
static void cache_btf_id(struct bpf_iter_target_info *tinfo, struct bpf_prog *prog) { tinfo->btf_id = prog->aux->attach_btf_id; } bool bpf_iter_prog_supported(struct bpf_prog *prog) { const char *attach_fname = prog->aux->attach_func_name; u32 prog_btf_id = prog->aux->attach_btf_id; const char *prefix = BPF_ITER_FUNC_PREFIX; struct bpf_iter_target_info *tinfo; int prefix_len = strlen(prefix); bool supported = false; if (strncmp(attach_fname, prefix, prefix_len)) return false; mutex_lock(&targets_mutex); list_for_each_entry(tinfo, &targets, list) { if (tinfo->btf_id && tinfo->btf_id == prog_btf_id) { supported = true; break; } |
15172a46f bpf: net: Refacto... |
312 |
if (!strcmp(attach_fname + prefix_len, tinfo->reg_info->target)) { |
15d83c4d7 bpf: Allow loadin... |
313 314 315 316 317 318 |
cache_btf_id(tinfo, prog); supported = true; break; } } mutex_unlock(&targets_mutex); |
3c32cc1bc bpf: Enable bpf_i... |
319 320 321 322 |
if (supported) { prog->aux->ctx_arg_info_size = tinfo->reg_info->ctx_arg_info_size; prog->aux->ctx_arg_info = tinfo->reg_info->ctx_arg_info; } |
15d83c4d7 bpf: Allow loadin... |
323 324 |
return supported; } |
de4e05cac bpf: Support bpf ... |
325 326 327 |
static void bpf_iter_link_release(struct bpf_link *link) { |
a5cbe05a6 bpf: Implement bp... |
328 329 |
struct bpf_iter_link *iter_link = container_of(link, struct bpf_iter_link, link); |
5e7b30205 bpf: Change uapi ... |
330 331 |
if (iter_link->tinfo->reg_info->detach_target) iter_link->tinfo->reg_info->detach_target(&iter_link->aux); |
de4e05cac bpf: Support bpf ... |
332 333 334 335 336 337 338 339 340 |
} static void bpf_iter_link_dealloc(struct bpf_link *link) { struct bpf_iter_link *iter_link = container_of(link, struct bpf_iter_link, link); kfree(iter_link); } |
2057c92bc bpf: Support bpf ... |
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 |
static int bpf_iter_link_replace(struct bpf_link *link, struct bpf_prog *new_prog, struct bpf_prog *old_prog) { int ret = 0; mutex_lock(&link_mutex); if (old_prog && link->prog != old_prog) { ret = -EPERM; goto out_unlock; } if (link->prog->type != new_prog->type || link->prog->expected_attach_type != new_prog->expected_attach_type || link->prog->aux->attach_btf_id != new_prog->aux->attach_btf_id) { ret = -EINVAL; goto out_unlock; } old_prog = xchg(&link->prog, new_prog); bpf_prog_put(old_prog); out_unlock: mutex_unlock(&link_mutex); return ret; } |
6b0a249a3 bpf: Implement li... |
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 |
static void bpf_iter_link_show_fdinfo(const struct bpf_link *link, struct seq_file *seq) { struct bpf_iter_link *iter_link = container_of(link, struct bpf_iter_link, link); bpf_iter_show_fdinfo_t show_fdinfo; seq_printf(seq, "target_name:\t%s ", iter_link->tinfo->reg_info->target); show_fdinfo = iter_link->tinfo->reg_info->show_fdinfo; if (show_fdinfo) show_fdinfo(&iter_link->aux, seq); } static int bpf_iter_link_fill_link_info(const struct bpf_link *link, struct bpf_link_info *info) { struct bpf_iter_link *iter_link = container_of(link, struct bpf_iter_link, link); char __user *ubuf = u64_to_user_ptr(info->iter.target_name); bpf_iter_fill_link_info_t fill_link_info; u32 ulen = info->iter.target_name_len; const char *target_name; u32 target_len; if (!ulen ^ !ubuf) return -EINVAL; target_name = iter_link->tinfo->reg_info->target; target_len = strlen(target_name); info->iter.target_name_len = target_len + 1; if (ubuf) { if (ulen >= target_len + 1) { if (copy_to_user(ubuf, target_name, target_len + 1)) return -EFAULT; } else { char zero = '\0'; if (copy_to_user(ubuf, target_name, ulen - 1)) return -EFAULT; if (put_user(zero, ubuf + ulen - 1)) return -EFAULT; return -ENOSPC; } } fill_link_info = iter_link->tinfo->reg_info->fill_link_info; if (fill_link_info) return fill_link_info(&iter_link->aux, info); return 0; } |
de4e05cac bpf: Support bpf ... |
423 424 425 |
static const struct bpf_link_ops bpf_iter_link_lops = { .release = bpf_iter_link_release, .dealloc = bpf_iter_link_dealloc, |
2057c92bc bpf: Support bpf ... |
426 |
.update_prog = bpf_iter_link_replace, |
6b0a249a3 bpf: Implement li... |
427 428 |
.show_fdinfo = bpf_iter_link_show_fdinfo, .fill_link_info = bpf_iter_link_fill_link_info, |
de4e05cac bpf: Support bpf ... |
429 |
}; |
367ec3e48 bpf: Create file ... |
430 431 432 433 |
bool bpf_link_is_iter(struct bpf_link *link) { return link->ops == &bpf_iter_link_lops; } |
de4e05cac bpf: Support bpf ... |
434 435 |
int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) { |
5e7b30205 bpf: Change uapi ... |
436 |
union bpf_iter_link_info __user *ulinfo; |
de4e05cac bpf: Support bpf ... |
437 438 |
struct bpf_link_primer link_primer; struct bpf_iter_target_info *tinfo; |
5e7b30205 bpf: Change uapi ... |
439 |
union bpf_iter_link_info linfo; |
de4e05cac bpf: Support bpf ... |
440 |
struct bpf_iter_link *link; |
5e7b30205 bpf: Change uapi ... |
441 |
u32 prog_btf_id, linfo_len; |
de4e05cac bpf: Support bpf ... |
442 |
bool existed = false; |
de4e05cac bpf: Support bpf ... |
443 |
int err; |
5e7b30205 bpf: Change uapi ... |
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 |
if (attr->link_create.target_fd || attr->link_create.flags) return -EINVAL; memset(&linfo, 0, sizeof(union bpf_iter_link_info)); ulinfo = u64_to_user_ptr(attr->link_create.iter_info); linfo_len = attr->link_create.iter_info_len; if (!ulinfo ^ !linfo_len) return -EINVAL; if (ulinfo) { err = bpf_check_uarg_tail_zero(ulinfo, sizeof(linfo), linfo_len); if (err) return err; linfo_len = min_t(u32, linfo_len, sizeof(linfo)); if (copy_from_user(&linfo, ulinfo, linfo_len)) return -EFAULT; } |
de4e05cac bpf: Support bpf ... |
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 |
prog_btf_id = prog->aux->attach_btf_id; mutex_lock(&targets_mutex); list_for_each_entry(tinfo, &targets, list) { if (tinfo->btf_id == prog_btf_id) { existed = true; break; } } mutex_unlock(&targets_mutex); if (!existed) return -ENOENT; link = kzalloc(sizeof(*link), GFP_USER | __GFP_NOWARN); if (!link) return -ENOMEM; bpf_link_init(&link->link, BPF_LINK_TYPE_ITER, &bpf_iter_link_lops, prog); link->tinfo = tinfo; err = bpf_link_prime(&link->link, &link_primer); if (err) { kfree(link); return err; } |
5e7b30205 bpf: Change uapi ... |
487 488 |
if (tinfo->reg_info->attach_target) { err = tinfo->reg_info->attach_target(prog, &linfo, &link->aux); |
a5cbe05a6 bpf: Implement bp... |
489 |
if (err) { |
5e7b30205 bpf: Change uapi ... |
490 491 |
bpf_link_cleanup(&link_primer); return err; |
a5cbe05a6 bpf: Implement bp... |
492 |
} |
a5cbe05a6 bpf: Implement bp... |
493 |
} |
de4e05cac bpf: Support bpf ... |
494 495 |
return bpf_link_settle(&link_primer); } |
ac51d99bf bpf: Create anony... |
496 497 498 |
static void init_seq_meta(struct bpf_iter_priv_data *priv_data, struct bpf_iter_target_info *tinfo, |
a5cbe05a6 bpf: Implement bp... |
499 |
const struct bpf_iter_seq_info *seq_info, |
ac51d99bf bpf: Create anony... |
500 501 502 |
struct bpf_prog *prog) { priv_data->tinfo = tinfo; |
a5cbe05a6 bpf: Implement bp... |
503 |
priv_data->seq_info = seq_info; |
ac51d99bf bpf: Create anony... |
504 505 506 507 508 |
priv_data->prog = prog; priv_data->session_id = atomic64_inc_return(&session_id); priv_data->seq_num = 0; priv_data->done_stop = false; } |
a5cbe05a6 bpf: Implement bp... |
509 510 |
static int prepare_seq_file(struct file *file, struct bpf_iter_link *link, const struct bpf_iter_seq_info *seq_info) |
ac51d99bf bpf: Create anony... |
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 |
{ struct bpf_iter_priv_data *priv_data; struct bpf_iter_target_info *tinfo; struct bpf_prog *prog; u32 total_priv_dsize; struct seq_file *seq; int err = 0; mutex_lock(&link_mutex); prog = link->link.prog; bpf_prog_inc(prog); mutex_unlock(&link_mutex); tinfo = link->tinfo; total_priv_dsize = offsetof(struct bpf_iter_priv_data, target_private) + |
a5cbe05a6 bpf: Implement bp... |
526 527 |
seq_info->seq_priv_size; priv_data = __seq_open_private(file, seq_info->seq_ops, |
15172a46f bpf: net: Refacto... |
528 |
total_priv_dsize); |
ac51d99bf bpf: Create anony... |
529 530 531 532 |
if (!priv_data) { err = -ENOMEM; goto release_prog; } |
a5cbe05a6 bpf: Implement bp... |
533 534 |
if (seq_info->init_seq_private) { err = seq_info->init_seq_private(priv_data->target_private, &link->aux); |
ac51d99bf bpf: Create anony... |
535 536 537 |
if (err) goto release_seq_file; } |
a5cbe05a6 bpf: Implement bp... |
538 |
init_seq_meta(priv_data, tinfo, seq_info, prog); |
ac51d99bf bpf: Create anony... |
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 |
seq = file->private_data; seq->private = priv_data->target_private; return 0; release_seq_file: seq_release_private(file->f_inode, file); file->private_data = NULL; release_prog: bpf_prog_put(prog); return err; } int bpf_iter_new_fd(struct bpf_link *link) { |
a5cbe05a6 bpf: Implement bp... |
554 |
struct bpf_iter_link *iter_link; |
ac51d99bf bpf: Create anony... |
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 |
struct file *file; unsigned int flags; int err, fd; if (link->ops != &bpf_iter_link_lops) return -EINVAL; flags = O_RDONLY | O_CLOEXEC; fd = get_unused_fd_flags(flags); if (fd < 0) return fd; file = anon_inode_getfile("bpf_iter", &bpf_iter_fops, NULL, flags); if (IS_ERR(file)) { err = PTR_ERR(file); goto free_fd; } |
a5cbe05a6 bpf: Implement bp... |
572 573 |
iter_link = container_of(link, struct bpf_iter_link, link); err = prepare_seq_file(file, iter_link, __get_seq_info(iter_link)); |
ac51d99bf bpf: Create anony... |
574 575 576 577 578 579 580 581 582 583 584 585 |
if (err) goto free_file; fd_install(fd, file); return fd; free_file: fput(file); free_fd: put_unused_fd(fd); return err; } |
e5158d987 bpf: Implement co... |
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 |
struct bpf_prog *bpf_iter_get_info(struct bpf_iter_meta *meta, bool in_stop) { struct bpf_iter_priv_data *iter_priv; struct seq_file *seq; void *seq_priv; seq = meta->seq; if (seq->file->f_op != &bpf_iter_fops) return NULL; seq_priv = seq->private; iter_priv = container_of(seq_priv, struct bpf_iter_priv_data, target_private); if (in_stop && iter_priv->done_stop) return NULL; meta->session_id = iter_priv->session_id; meta->seq_num = iter_priv->seq_num; return iter_priv->prog; } int bpf_iter_run_prog(struct bpf_prog *prog, void *ctx) { int ret; rcu_read_lock(); migrate_disable(); ret = BPF_PROG_RUN(prog, ctx); migrate_enable(); rcu_read_unlock(); |
2e3ed68bf bpf: Add comments... |
619 620 621 622 623 624 |
/* bpf program can only return 0 or 1: * 0 : okay * 1 : retry the same object * The bpf_iter_run_prog() return value * will be seq_ops->show() return value. */ |
e5158d987 bpf: Implement co... |
625 626 |
return ret == 0 ? 0 : -EAGAIN; } |