Class: LibBPFRuby::Program

Inherits:
Object
  • Object
show all
Defined in:
ext/libbpf_ruby/libbpf_ruby.c

Instance Method Summary collapse

Instance Method Details

#attach ⇒ Object 



337
338
339
340
341
342
343
344
345
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 337

static VALUE rb_cProgram_attach(VALUE self) {
  nogvl_attach_ctx_t ctx = { .bpf_program = libbpf_ruby_program_bpf(self) };
  rb_nogvl(nogvl_bpf_program__attach, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_cgroup(cgroup) ⇒ Object 



471
472
473
474
475
476
477
478
479
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 471

static VALUE rb_cProgram_attach_cgroup(VALUE self, VALUE cgroup) {
  nogvl_attach_int_ctx_t ctx = { .bpf_program = libbpf_ruby_program_bpf(self), .int_arg = rb_io_descriptor(cgroup) };
  rb_nogvl(nogvl_bpf_program__attach_cgroup, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_cgroup failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_kprobe(*args) ⇒ Object 



369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 369

static VALUE rb_cProgram_attach_kprobe(int argc, VALUE *argv, VALUE self) {
  VALUE func_name, kwargs;
  rb_scan_args(argc, argv, "1:", &func_name, &kwargs);
  bool retprobe = false;
  if (!NIL_P(kwargs)) {
    VALUE value = rb_hash_lookup2(kwargs, ID2SYM(id_kwarg_retprobe), Qundef);
    if (value != Qundef) retprobe = RTEST(value);
  }
  StringValueCStr(func_name);
  VALUE frozen_func_name = rb_str_new_frozen(func_name);

  nogvl_attach_kprobe_ctx_t ctx = {
    .bpf_program = libbpf_ruby_program_bpf(self),
    .retprobe = retprobe,
    .func_name = RSTRING_PTR(frozen_func_name)
  };
  rb_nogvl(nogvl_bpf_program__attach_kprobe, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_kprobe failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_perf_event(perf_event) ⇒ Object 



481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 481

static VALUE rb_cProgram_attach_perf_event(VALUE self, VALUE perf_event) {
  struct bpf_program *program = libbpf_ruby_program_bpf(self);
  int perf_fd = dup(rb_io_descriptor(perf_event));
  if (perf_fd < 0) {
    rb_raise(rb_eRuntimeError, "dup failed: %s", strerror(errno));
  }
  nogvl_attach_int_ctx_t ctx = { .bpf_program = program, .int_arg = perf_fd };
  rb_nogvl(nogvl_bpf_program__attach_perf_event, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    close(perf_fd);
    rb_raise(rb_eRuntimeError, "bpf_program__attach_perf_event failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_raw_tracepoint(name) ⇒ Object 



455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 455

static VALUE rb_cProgram_attach_raw_tracepoint(VALUE self, VALUE name) {
  StringValueCStr(name);
  VALUE frozen_name = rb_str_new_frozen(name);

  nogvl_attach_raw_tracepoint_ctx_t ctx = {
    .bpf_program = libbpf_ruby_program_bpf(self),
    .name = RSTRING_PTR(frozen_name)
  };
  rb_nogvl(nogvl_bpf_program__attach_raw_tracepoint, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_raw_tracepoint failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_tcx(ifindex) ⇒ Object 



358
359
360
361
362
363
364
365
366
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 358

static VALUE rb_cProgram_attach_tcx(VALUE self, VALUE ifindex) {
  nogvl_attach_int_ctx_t ctx = { .bpf_program = libbpf_ruby_program_bpf(self), .int_arg = NUM2INT(ifindex) };
  rb_nogvl(nogvl_bpf_program__attach_tcx, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_tcx failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_tracepoint(category, name) ⇒ Object 



436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 436

static VALUE rb_cProgram_attach_tracepoint(VALUE self, VALUE category, VALUE name) {
  StringValueCStr(category);
  StringValueCStr(name);
  VALUE frozen_category = rb_str_new_frozen(category);
  VALUE frozen_name = rb_str_new_frozen(name);

  nogvl_attach_tracepoint_ctx_t ctx = {
    .bpf_program = libbpf_ruby_program_bpf(self),
    .category = RSTRING_PTR(frozen_category),
    .name = RSTRING_PTR(frozen_name)
  };
  rb_nogvl(nogvl_bpf_program__attach_tracepoint, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_tracepoint failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_uprobe(*args) ⇒ Object 



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
423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 393

static VALUE rb_cProgram_attach_uprobe(int argc, VALUE *argv, VALUE self) {
  VALUE binary_path, kwargs;
  rb_scan_args(argc, argv, "1:", &binary_path, &kwargs);
  VALUE frozen_func_name = Qnil;
  size_t offset = 0;
  pid_t pid = -1;
  bool retprobe = false;
  if (!NIL_P(kwargs)) {
    VALUE value;
    value = rb_hash_lookup2(kwargs, ID2SYM(id_kwarg_func_name), Qundef);
    if (value != Qundef) {
      StringValueCStr(value);
      frozen_func_name = rb_str_new_frozen(value);
    }
    value = rb_hash_lookup2(kwargs, ID2SYM(id_kwarg_offset), Qundef);
    if (value != Qundef) offset = NUM2SIZET(value);
    value = rb_hash_lookup2(kwargs, ID2SYM(id_kwarg_pid), Qundef);
    if (value != Qundef) pid = NUM2INT(value);
    value = rb_hash_lookup2(kwargs, ID2SYM(id_kwarg_retprobe), Qundef);
    if (value != Qundef) retprobe = RTEST(value);
  }
  StringValueCStr(binary_path);
  VALUE frozen_binary_path = rb_str_new_frozen(binary_path);

  LIBBPF_OPTS(bpf_uprobe_opts, uopts,
    .retprobe = retprobe,
    .func_name = NIL_P(frozen_func_name) ? NULL : RSTRING_PTR(frozen_func_name)
  );
  nogvl_attach_uprobe_ctx_t ctx = {
    .bpf_program = libbpf_ruby_program_bpf(self),
    .pid = pid,
    .binary_path = RSTRING_PTR(frozen_binary_path),
    .offset = offset,
    .opts = &uopts
  };
  rb_nogvl(nogvl_bpf_program__attach_uprobe_opts, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_uprobe_opts failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#attach_xdp(ifindex) ⇒ Object 



347
348
349
350
351
352
353
354
355
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 347

static VALUE rb_cProgram_attach_xdp(VALUE self, VALUE ifindex) {
  nogvl_attach_int_ctx_t ctx = { .bpf_program = libbpf_ruby_program_bpf(self), .int_arg = NUM2INT(ifindex) };
  rb_nogvl(nogvl_bpf_program__attach_xdp, &ctx, NULL, NULL, 0);
  long err = libbpf_get_error(ctx.bpf_link);
  if (err) {
    rb_raise(rb_eRuntimeError, "bpf_program__attach_xdp failed: %s", strerror(-err));
  }
  return libbpf_ruby_link_wrap(self, ctx.bpf_link);
}

#fd ⇒ Object 



329
330
331
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 329

static VALUE rb_cProgram_fd(VALUE self) {
  return INT2NUM(bpf_program__fd(libbpf_ruby_program_bpf(self)));
}

#name ⇒ Object 



333
334
335
 
# File 'ext/libbpf_ruby/libbpf_ruby.c', line 333

static VALUE rb_cProgram_name(VALUE self) {
  return rb_str_new_cstr(bpf_program__name(libbpf_ruby_program_bpf(self)));
}