GrantSeltzer

I try to follow the bpf-next mailing list closely, but I always miss things.

You can find all the code displayed in this post in my repo here.

The bpf verifier is tasked with ensuring that bpf programs that are loaded will predictably halt and run safely.

In a couple of my posts from a few years ago (1, 2) I explored the idea of attaching bpf programs to Go functions via uprobes.

I recently ran into a hard to find bug in my Go code when using slices.

BPF has a helper function called bpf_get_attach_cookie.

There are times when developing your BPF projects when you need to ensure safe access to shared memory.

One of the main projects that I work on is libbpfgo.

libbpf is the standard implementation of the userspace library for loading and interacting with bpf programs.

The Linux kernel is the biggest open source project in existence.

Listen on Changelog.com

Skip to 3:11:00 for my talk (or watch the whole thing, it was a great conference!)

If you’re used to developing software in a high level language like Go or Java you likely haven’t thought about supporting different operating system versions.

In my previous posts on the subject of bpf I used a project called BCC to compile, load, and interact with my bpf programs.

A version of this post was also uploaded to Aqua's blog here If you’ve been reading much bpf code recently, you’ve probably seen this: #include "vmlinux.h" vmlinux.h is generated code. it contains all of the type definitions that your running Linux kernel

In my very first blog post, Dissecting Go Binaries, I began to explore ELF files.

Code can be found here

Listen on Changelog.com

In part 1 of this series we learned about how to attach uprobes and eBPF programs to specific functions in Go programs.

In the past year I’ve decided that I haven’t perpetuated enough Brooklyn stereotypes and have taken up fermentation as a hobby.

eBPF is a virtual machine, similar in concept to the JVM, except it’s inside the Linux kernel.

Karn aims to provide for Linux what entitlements provide for iOS, or what pledge provides for OpenBSD.

I love the procfs because it provides an intuitive and easy to use interface for interacting with the kernel.

Remember back to when your teacher in grade school would write on sheets of clear plastic, stack them, and display them with an overhead projector?

This post discusses building go test binaries and walking through them with delve I recently was working on debugging a unit test I wrote in Go.

In this post we discuss how standardized streams (`stdin`/`stdout`/`stderr`) work on Linux, especially related to shells.

This post highlights a linker directive in Go.

In this post we explore best practices of defining interfaces in Go.

This post will introduce you to cgroups.

This post will introduce you to the basic concepts of disassembly and walk through writing a simple disassembler in Go.