{"id":20690,"date":"2026-08-16T08:34:41","date_gmt":"2026-08-16T06:34:41","guid":{"rendered":"https:\/\/webhosting.de\/bpftool-einstieg-moderne-kernelanalyse-linux-ebpf-observability-tracing-core\/"},"modified":"2026-08-16T08:34:41","modified_gmt":"2026-08-16T06:34:41","slug":"bpftool-instap-moderne-kernelanalyse-linux-ebpf-observability-tracing-core","status":"publish","type":"post","link":"https:\/\/webhosting.de\/nl\/bpftool-einstieg-moderne-kernelanalyse-linux-ebpf-observability-tracing-core\/","title":{"rendered":"bpftool \u2013 Een inleiding tot moderne kernelanalyse met eBPF"},"content":{"rendered":"<p>Ik laat je zien hoe je kunt werken met <strong>bpftool<\/strong> gericht in actieve Linux-systemen kunt kijken, eBPF-programma\u2019s kunt aansturen en daarbij zinvolle telemetrie kunt verkrijgen zonder de kernel opnieuw te hoeven compileren. Dit artikel leidt je stap voor stap door de installatie, de kernconcepten, typische toepassingen en nuttige routines, zodat je <strong>Kernelanalyse<\/strong> veilig inzet bij de exploitatie en ontwikkeling.<\/p>\n\n<h2>Centrale punten<\/h2>\n\n<p>Om te beginnen vat ik de belangrijkste aspecten samen, zodat je de volgende hoofdstukken gericht kunt plaatsen en <strong>Prioriteiten<\/strong> kunt instellen.<\/p>\n<ul>\n  <li><strong>nabijheid van de kern<\/strong>: Directe toegang tot eBPF-programma's, maps en statistieken<\/li>\n  <li><strong>Transparantie<\/strong>: Verifier-logs, bytecode en JIT-dumps voor foutopsporing<\/li>\n  <li><strong>productierijpheid<\/strong>: JSON-uitvoer, scriptbaarheid, reproduceerbare processen<\/li>\n  <li><strong>Breedte<\/strong>: netwerk, systeemaanroepen, scheduler, cgroups, perf_events<\/li>\n  <li><strong>Ecosysteem<\/strong>: Een aanvulling op geavanceerde tools zoals BCC en bpftrace<\/li>\n<\/ul>\n<p>Ik gebruik de genoemde punten om praktische stappen te laten zien en <strong>Beslissingen<\/strong> te vergemakkelijken. Zo zie je snel waar bpftool direct nut biedt en waar andere tools beter geschikt zijn. De lijst dient als leidraad voor de voorbeelden in de volgende hoofdstukken en houdt de focus op <strong>Meetbaarheid<\/strong>. Houd tijdens het lezen je doel voor ogen, want de configuratie en de kernelversie bepalen de beschikbare opties. Hoe duidelijker je je doel formuleert, hoe sneller eBPF en bpftool resultaten opleveren <strong>Signaal<\/strong> in plaats van ruis.<\/p>\n\n<h2>eBPF als veilige runtime in de kernel<\/h2>\n\n<p>eBPF biedt een veilige uitvoeringsomgeving in de <strong>Kernel<\/strong> die de kleine programma's aan bepaalde gebeurtenissen koppelt en ze v\u00f3\u00f3r de uitvoering grondig controleert. De verifier voorkomt ongeoorloofde geheugentoegangen en lussen, waardoor systemen beheersbaar blijven en <strong>operationeel<\/strong>. Ik koppel programma\u2019s aan Kprobes, Tracepoints, XDP of cgroups en krijg zo nauwkeurige contextgegevens. Deze nauwe integratie levert meetwaarden op zonder dure syscall-overgangen en zonder dat ik modules hoef te bouwen. Zo ontstaat een flexibele telemetrielaag die ik met <strong>bpftool<\/strong> zichtbaar, testbaar en beheersbaar maak.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/kernelanalyse-arbeitsplatz-9283.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Installatie en vereisten<\/h2>\n\n<p>Ik controleer eerst de kernelversie en de functies, want veel functies komen pas tot hun recht vanaf <strong>5.x<\/strong> volledig. Op distributies installeer ik bpftool als pakket of bouw ik het vanuit de kernelbroncode onder tools\/bpf\/bpftool, afhankelijk van de onderhoudsstatus van het systeem. Voor de build heb ik Clang\/LLVM, libelf, make en de juiste headers nodig, zodat de toolchain met de kernel <strong>past op<\/strong>. Na de installatie controleer ik met \u201cbpftool version\u201d of de functie beschikbaar is en vergelijk ik deze met mijn vereisten. Als de kernel-mogelijkheden kloppen, start ik tests op een apart systeem voordat ik productieve hosts <strong>volgen<\/strong>.<\/p>\n\n<h2>bpffs en pinning: de levenscyclus van objecten in beeld<\/h2>\n\n<p>Om de processen reproduceerbaar te maken, koppel ik eerst het BPF-bestandssysteem onder \u201c\/sys\/fs\/bpf\u201d. Als dit ontbreekt, richt ik het in met \u201cmount -t bpf bpf \/sys\/fs\/bpf\u201d en controleer ik de namespaces als er containers bij betrokken zijn. Vervolgens koppel ik geladen objecten aan stabiele paden, bijvoorbeeld \u201cbpftool prog pin id X \/sys\/fs\/bpf\/myapp\/xdp_ingress\u201d of \u201cbpftool map pin id M \/sys\/fs\/bpf\/myapp\/counters\u201d. Zo overleven programma\u2019s, links en maps het herstarten van processen, blijven ze vindbaar en zijn ze eenduidig. <strong>adresseerbaar<\/strong>.<\/p>\n<p>Ik structureer de pinning-hi\u00ebrarchie op basis van service, hook en versie, bijvoorbeeld \u201c\/sys\/fs\/bpf\/<em>dienst<\/em>\/<em>hook<\/em>\/<em>versie<\/em>\u201d. Dat maakt rollbacks en side-by-side-tests eenvoudiger. Voor bijlagen geef ik de voorkeur aan de link-aanpak: \u201cbpftool link list\u201d toont me stabiele handles, \u201cbpftool link pin id L \/sys\/fs\/bpf\/myapp\/link_xdp\u201d legt de koppeling vast. Bij het opschonen verwijder ik eerst de pins (rm), waarna de objecten worden vrijgegeven. Zo voorkom ik <strong>Wezen<\/strong>-programma's die onopgemerkt blijven draaien.<\/p>\n\n<h2>Centrale subcommando's en concepten<\/h2>\n\n<p>bpftool groepeert commando's op basis van objecttypen, zoals <strong>prog<\/strong>, map, cgroup of feature, waardoor werkprocessen logisch kunnen worden gestructureerd. Ik gebruik \u201cprog list\u201d en \u201cprog show\u201d voor het overzicht, \u201cdump xlated\/jited\u201d voor diepgaande inzichten en \u201cmap dump\/lookup\u201d voor analyses van de gegevensstroom. Het subcommando \u201cfeature\u201d toont de geactiveerde helpers en map-typen, wat fouten achteraf voorkomt. JSON-uitvoer vergemakkelijkt de automatisering in CI\/CD en configuratiebeheer. De volgende tabel geeft een overzicht van typische taken en voorbeelden <strong>compact<\/strong> samen.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th>Object<\/th>\n      <th>Taak<\/th>\n      <th>Voorbeeld<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td>prog<\/td>\n      <td>Programma's opsommen en beschrijven<\/td>\n      <td>bpftool prog list | bpftool prog show id X<\/td>\n    <\/tr>\n    <tr>\n      <td>prog<\/td>\n      <td>Bytecode\/JIT bekijken<\/td>\n      <td>bpftool prog dump xlated id X | dump jited id X<\/td>\n    <\/tr>\n    <tr>\n      <td>prog<\/td>\n      <td>Laden en toevoegen<\/td>\n      <td>bpftool prog load file.o \/sys\/fs\/bpf\/p &amp;&amp; \u2026 attach<\/td>\n    <\/tr>\n    <tr>\n      <td>kaart<\/td>\n      <td>Inhoud en sleutels controleren<\/td>\n      <td>bpftool map dump id M | map lookup id M key HEX<\/td>\n    <\/tr>\n    <tr>\n      <td>functie<\/td>\n      <td>Kernel-mogelijkheden weergeven<\/td>\n      <td>bpftool feature probe<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<h2>BTF, CO-RE en skeletten in het dagelijks leven<\/h2>\n\n<p>Ik zorg ervoor dat BTF in de kernel beschikbaar is, omdat dit CO-RE (Compile Once \u2013 Run Everywhere) en handige debug-uitvoer mogelijk maakt. Met \u201cbpftool feature probe\u201d kan ik zien of BTF actief is, en indien nodig bekijk ik de type-informatie met \u201cbpftool btf dump file \/sys\/kernel\/btf\/vmlinux\u201d. Voor de ontwikkeling genereer ik op basis van de kernel-typen een geschikt headerbestand via \u201cbpftool gen vmlinux\u201d, waardoor ik veilig naar structuren kan verwijzen. Dit vermindert het aantal breekpunten bij kernel-updates aanzienlijk.<\/p>\n<p>Bij het programmeren maak ik gebruik van skeletons: \u201cbpftool gen skeleton obj.o\u201d genereert een C-wrapper die het laden, toevoegen, map-toegang en opschonen inkapselen. Hierdoor wordt mijn glue-code korter en houd ik de interactie tussen de gebruikersruimte en het eBPF-programma <strong>robuust<\/strong>. CO-RE helpt me om dezelfde artefacten op verschillende kernels te gebruiken, zolang er helpers en hooks beschikbaar zijn \u2013 dat controleer ik al in een vroeg stadium met \u201cfeature probe\u201d.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/Konferenz_eBPF_Kernelanalyse_8392.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Prestatieanalyse met bpftool<\/h2>\n\n<p>Voor vragen over prestaties gebruik ik bpftool om de <strong>oproepen<\/strong> van afzonderlijke programma\u2019s, meet ik de looptijden en vergelijk ik deze met pieken in de werklast. Zo kan ik vaststellen welke traces veel rekenkracht verbruiken of dat een XDP-filter op drukke paden te veel CPU-capaciteit in beslag neemt. Vervolgens beoordeel ik of sampling of strakkere filters logischer zijn. Bij afwijkingen bekijk ik JIT-dumps om codepaden te begrijpen en onnodige instructies te vermijden. Uiteindelijk worden de cijfers in dashboards verwerkt, zodat beheerders blijvend <strong>Transparantie<\/strong> behouden.<\/p>\n\n<h2>Telwaarden, per-CPU-kaarten en statistieken<\/h2>\n\n<p>Ik analyseer \u201cbpftool prog show id X\u201d om \u201crun_time_ns\u201d en \u201crun_cnt\u201d te controleren. Hun verhouding geeft mij de gemiddelde looptijden weer; uitschieters interpreteer ik aan de hand van workload-statistieken. Bij map-tellers let ik op varianten per CPU: sommige dumps tonen waarden per CPU, andere zijn geaggregeerd. Voor nauwkeurige analyses gebruik ik machinaal leesbare uitvoer en bereken ik bewust aggregaties, zodat pieken op afzonderlijke CPU's niet <strong>ten onder gaan<\/strong>.<\/p>\n<p>Voor een snel overzicht van trace-uitvoer gebruik ik \u201cbpftool prog tracelog\u201d. Hiermee lees ik de uitvoer uit de tracing-buffer zonder aparte tools te hoeven gebruiken. In productieomgevingen beperk ik dergelijke afdrukken sterk en vervang ik ze door tellers in maps of ringbuffer-events om overhead en ruis te voorkomen.<\/p>\n\n<h2>Netwerkobservabiliteit: pakketten, stromen, fouten<\/h2>\n\n<p>In de netwerkomgeving controleer ik XDP- en TC-programma\u2019s, lees ik kaarten met meterstanden uit en identificeer ik <strong>Hotspots<\/strong> langs de gegevenspaden. Ik gebruik bpftool om weggelaten regels zichtbaar te maken en datastromen te karakteriseren. Als er foutieve beslissingen bij filters optreden, tonen map-dumps de werkelijke sleutels en waarden. Zo ontdek ik snel verschillen tussen de verwachte en de daadwerkelijke verwerking. Dit overzicht helpt me bij het maken van een weloverwogen keuze van tools om <a href=\"https:\/\/webhosting.de\/nl\/ebpf-linux-analysetools-servermonitoring-inzichten\/\">eBPF-analysetools<\/a>, die wordt ingezet in de hostingomgeving <strong>beton<\/strong> indeleert.<\/p>\n\n<h2>XDP\/TC-varianten en zichtbaarheid met bpftool net<\/h2>\n\n<p>Wat het netwerkpad betreft, controleer ik met \u201cbpftool net\u201d welke programma\u2019s aan de interfaces zijn gekoppeld. Zo kan ik zien of XDP in de Generic-, Native- of Offload-modus draait en welke TC-hooks (ingress\/egress) bezet zijn. Als de modi niet kloppen, pas ik de attach-opties of stuurprogramma-parameters aan. Ik documenteer de uitvoer regelmatig als artefact, zodat wijzigingen aan netwerkpaden <strong>begrijpelijk<\/strong> blijven.<\/p>\n<p>Voor hotpaths streef ik naar korte paden: XDP-programma\u2019s moeten vroeg een beslissing nemen (pass\/drop\/redirect), TC-programma\u2019s consolideren regels en voorkomen redundante lookups. Met mapstatistieken beoordeel ik de kwaliteit van de treffers, en JIT-dumps geven inzicht of sprongpatronen ongunstig zijn. Als er wachtrij- of checksum-kosten zichtbaar worden, pas ik filters aan en heroverweeg ik de plaatsing tussen XDP en TC.<\/p>\n\n<h2>Beveiligingstoezicht en naleving<\/h2>\n\n<p>Ik gebruik eBPF-programma's voor <strong>Proces<\/strong>-Opstarten, bestandstoegang en netwerkgebeurtenissen om veiligheidsrelevante patronen te herkennen. Met bpftool controleer ik welke programma\u2019s actief zijn, waar ze worden gekoppeld en of de regels van kracht zijn. Als de koppelpunten kloppen, controleer ik de inhoud van de map om de toepassing van de richtlijnen gedocumenteerd vast te leggen. Bij verdachte gevallen maak ik gebruik van Verifier-logs en bytecode om de logica te controleren. Dit inzicht versnelt audits en maakt het gedrag van agents inzichtelijk voor teams <strong>begrijpelijk<\/strong>.<\/p>\n\n<h2>Rechten, isolatie en beveiligingsmodellen<\/h2>\n\n<p>Tijdens het gebruik let ik op duidelijke machtigingen. Op veel systemen zijn eBPF-functies zonder speciale rechten uitgeschakeld; daarom werk ik met speciale serviceaccounts en specifieke capabilities. Afhankelijk van de kernelversie worden CAP_BPF, CAP_PERFMON en CAP_NET_ADMIN gebruikt, terwijl CAP_SYS_ADMIN alleen wordt ingezet wanneer dit onvermijdelijk is. Ik isoleer bpffs per naamruimte wanneer containers eigen traces nodig hebben, en baken cgroups zo af dat attachments <strong>gericht<\/strong> effect hebben.<\/p>\n<p>Om aan de compliance-eisen te voldoen, zet ik gevoelige maps na het vullen op \u201cread-only\u201d met \u201cbpftool map freeze\u201d. Hierdoor worden de richtlijnen alleen-lezen gemaakt, terwijl programma\u2019s ze nog steeds kunnen lezen. Bij audits documenteer ik de programmadag en de attach-punten, zodat beslissingen reproduceerbaar blijven, zelfs als artefacten opnieuw worden gebouwd.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/kernel-analysis-modern-tools-4638.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Eigen eBPF-programma's: laden, toevoegen, debuggen<\/h2>\n\n<p>Tijdens de ontwikkeling compileer ik C-broncodes met Clang tot eBPF-objecten, laad ik ze met bpftool en koppel ik ze aan <strong>Haken<\/strong>. Als de verifier een fout signaleert, sla ik het logboek op en beperk ik stap voor stap risicovolle paden. Ik controleer de vertaalde bytecode en de JIT-uitvoer om instructiereeksen te evalueren. Als de resultaten kloppen, schrijf en lees ik testgegevens via maps en controleer ik randgevallen. Dit verkort de feedbacklussen en houdt mijn toolchain geschikt voor zowel experimenten als productie. <strong>gestandaardiseerd<\/strong>.<\/p>\n\n<h2>CO-RE-strategie en stabiele artefacten<\/h2>\n\n<p>Om ervoor te zorgen dat builds langer meegaan, vertrouw ik op CO-RE. Ik integreer BTF-informatie, gebruik \u201cgen vmlinux\u201d en controleer de relocaties tijdens het laden. Als er afwijkingen in de kernelstructuren optreden, worden de betreffende plaatsen in het verifier-logboek weergegeven. Ik houd de programma\u2019s zo generiek mogelijk en sla beleidsregels op in maps. Het voordeel: bij wijzigingen in het schema hoef ik alleen de gegevens bij te werken, niet de <strong>Code<\/strong>. Met Skeletons automatiseer ik de setup, het vastzetten en het opschonen, wat vooral in CI\/CD-pijplijnen het foutenpercentage aanzienlijk verlaagt.<\/p>\n\n<h2>Integratie met geavanceerde tools<\/h2>\n\n<p>Om snel resultaat te boeken, zet ik in eerste instantie in op <strong>BCC<\/strong>-scripts en gebruik ze als uitgangspunt voor diepgaandere analyses. Zodra een script nuttige signalen oplevert, inspecteer ik met bpftool de onderliggende programma\u2019s en maps. Deze wisseling laat me zien wat er werkelijk in de kernel is geladen en welke gegevensstructuren actief zijn. Zo maak ik een duidelijk onderscheid tussen de gebruiksvriendelijke laag en de daadwerkelijke objecten. Voor het overzicht is het de moeite waard om deze compacte <a href=\"https:\/\/webhosting.de\/nl\/bcc-tools-linux-prestaties-ebpf-observabiliteit-focus\/\">BCC-tools<\/a>, waarin veelgestelde vragen met slechts enkele commando\u2019s worden beantwoord <strong>cover<\/strong>.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/tech_office_kernelanalyse_7492.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Beste werkmethoden<\/h2>\n\n<p>Ik houd test- en productieomgevingen strikt gescheiden, verzamel Verifier-logs in een vroeg stadium en zorg ervoor dat <strong>Terugdraaien<\/strong> Klaar. Voor elke rollout controleer ik \u201cbpftool feature\u201d om te zorgen dat het programmatype, de helper en de map-varianten bij het doel passen. Ik integreer de statistieken van de programma\u2019s in de bestaande monitoring om de overhead zichtbaar te houden. Ik documenteer alle koppelpunten doorlopend, want alleen zo behouden teams het overzicht. Wie zich hier verder in wil verdiepen, vindt bij de <a href=\"https:\/\/webhosting.de\/nl\/ebpf-linux-analysetools-servermonitoring-inzichten\/\">eBPF-analysetools<\/a> verdere impulsen voor <strong>Werkstromen<\/strong>.<\/p>\n\n<h2>Beheer van bronnen, opschoning en terugdraaien<\/h2>\n\n<p>Ik gebruik pins om bepaalde toestanden te cre\u00ebren en ruim deze actief op. Voor rollbacks houd ik de vorige versie in dezelfde naamruimte beschikbaar (bijv. \u201c\/sys\/fs\/bpf\/myapp\/v1\u201d en \u201c\/sys\/fs\/bpf\/myapp\/v2\u201d). Het omschakelen gebeurt door opnieuw te koppelen of de link te wijzigen, met minimale uitvaltijd. Vervolgens verwijder ik oude links en maps, zodat er geen bronnen <strong>lik<\/strong>. Voordat ik iets verwijder, controleer ik of er nog verwijzingen bestaan (\u201cprog show\u201d, \u201clink list\u201d, \u201cmap show\u201d).<\/p>\n<p>Om configuratieafwijkingen te voorkomen, zet ik maps die policies bevatten op hold en breng ik wijzigingen uitsluitend aan via gedefinieerde deployments. Ik plan batch-updates buiten de piekuren, houd de looptijd en foutenteller in de gaten en bevestig succesvolle updates met een tweede \u201cmap dump\u201d.<\/p>\n\n<h2>Automatisering en JSON-uitvoer<\/h2>\n\n<p>De JSON-vlag en machinaal leesbare formaten maken bpftool zo goed <strong>scriptbaar<\/strong> voor CI\/CD, CMDB\u2019s en audits. Ik verzegel builds op een reproduceerbare manier, documenteer hashes van de objectbestanden en sla bpffs-paden op. Zo koppel ik implementaties aan specifieke programma\u2019s en maps. Eenvoudige wrapper-scripts schrijven na elke wijziging statusrapporten naar de console en in artefacten. Hierdoor blijft het eBPF-landschap permanent <strong>toetsbaar<\/strong>.<\/p>\n\n<h2>Vertrouwen opbouwen: tags, hashtags en artefacten<\/h2>\n\n<p>Na het laden lees ik de programmatag uit (\u201cbpftool prog show id X\u201d), die is afgeleid van de bytecode. Ik koppel deze tag aan het buildnummer en de commit-hash in mijn CMDB. Bij latere controles vergelijk ik de verwachte en de huidige tag \u2013 zo detecteer ik afwijkingen zonder toegang tot de originele binaire bestanden. Voor maps registreer ik het type, de grootte van de sleutels en waarden en de vlaggen, zodat structuurwijzigingen bij updates <strong>tijdig<\/strong> show.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/entwicklerdesk_kernel_1234.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>bpftrace in de praktijk<\/h2>\n\n<p>Voor ad-hoc-traces gebruik ik <strong>bpftrace<\/strong>, wanneer een paar regels syntaxis snel antwoorden moeten opleveren. Vervolgens controleer ik het bereikte effect met bpftool om programma\u2019s, aanknopingspunten en maps precies te kunnen zien. Zo combineer ik expressiviteit met een focus op de kern en houd ik beide perspectieven synchroon. Als startpunt is dit korte overzicht over <a href=\"https:\/\/webhosting.de\/nl\/bpftrace-serverproblemen-bij-hosting-sneller-opsporen-en-diagnosticeren\/\">bpftrace<\/a>, die typische zoekopdrachten goed <strong>omlijst<\/strong>. Zodra een patroon goed werkt, zet ik het indien nodig om in compacte C-programma\u2019s.<\/p>\n\n<h2>Foutanalyse met Verifier-logs<\/h2>\n\n<p>Als de verifier mijn aanvraag afwijst, ga ik eerst op zoek naar mogelijke <strong>Nul<\/strong>-dereferenties, ontbrekende bounds-checks of te lange paden. Ik vereenvoudig de logica, isoleer twijfelachtige hulpfunctie-aanroepen en valideer offsets. Het helpt om grote maps te verkleinen en hotpaths op te splitsen in duidelijk afgebakende blokken. JIT-dumps laten me zien of lussen ongewild uitdijen of dat sprongen ineffici\u00ebnt zijn. Met elke stap nemen de foutmeldingen af, totdat het programma betrouwbaar <strong>ladingen<\/strong>.<\/p>\n\n<h2>Typische foutpatronen snel herkennen<\/h2>\n\n<p>Als ik meldingen zie zoals \u201cinvalid mem access\u201d of \u201cR.. unbounded loop\u201d, controleer ik de grenzen van arrays, de validatie van pointers en de grenzen van lussen. Bij CO-RE-problemen wijzen aanwijzingen op ontbrekende of onjuiste BTF-gegevens; ik controleer \u201c\/sys\/kernel\/btf\/vmlinux\u201d en pas de doelstructuren aan. Als het laden mislukt vanwege ontbrekende helpers, toont \u201cfeature probe\u201d de beschikbare helpers en map-typen. Als er tijdens het dumpen JIT-problemen optreden, controleer ik of JIT is ingeschakeld en of hardening-opties de uitvoer <strong>verbieden<\/strong>.<\/p>\n<p>Als bijlagen vastlopen, is er vaak nog een vastgezette link. Ik maak een lijst van de links, maak ze doelgericht los en verwijder vervolgens de pinnen. Bij \u201cEBUSY\u201d controleer ik of een andere instantie van de dienst objecten openhoudt en plan ik een korte, geco\u00f6rdineerde omschakeling.<\/p>\n\n<h2>Vooruitblik: bpftool en moderne kernelanalyse<\/h2>\n\n<p>Met nieuwe kernelreleases nemen het aantal programmatypen, helperfuncties en <strong>Statistieken<\/strong>, en bpftool speelt snel in op deze ontwikkelingen. Ik reserveer daarom tijd voor regelmatige updates, zodat de tooling en documentatie up-to-date blijven. Verbeteringen aan JSON en nieuwe subcommando\u2019s openen nieuwe mogelijkheden voor automatisering. Tegelijkertijd wordt de integratie met high-level-stacks steeds beter, wat de onboarding vereenvoudigt. Wie deze ontwikkeling actief volgt, profiteert hiervan bij diagnose, tuning en <strong>Beveiliging<\/strong> Snelheid.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/kernelanalyse-bpftool-8295.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Kort samengevat<\/h2>\n\n<p>bpftool geeft me direct <strong>Toegang<\/strong> op eBPF-programma\u2019s en hun gegevensstructuren en maakt processen in de kernel zichtbaar. Ik identificeer knelpunten, controleer beveiligingsregels en ontwikkel eigen traces zonder de kernel aan te passen. Dankzij een nette installatie, duidelijke tests en scripting blijft het gebruik reproduceerbaar. High-level-tools versnellen de opstartfase, terwijl bpftool de daadwerkelijke objecten betrouwbaar documenteert. Zo breng ik observability en diagnose naar een robuust niveau dat in de dagelijkse bedrijfsvoering <strong>draagt<\/strong>.<\/p>","protected":false},"excerpt":{"rendered":"<p>Leer hoe je bpftool kunt gebruiken voor moderne kernelanalyse met eBPF: basisprincipes, de belangrijkste commando\u2019s en praktijkvoorbeelden voor observability in de Linux-kernel, met de nadruk op bpftool.<\/p>","protected":false},"author":1,"featured_media":20683,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[922],"tags":[],"class_list":["post-20690","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-technologie"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"litespeed-optimize-size":null,"litespeed-optimize-set":null,"_elementor_source_image_hash":null,"_wp_attachment_image_alt":null,"stockpack_author_name":null,"stockpack_author_url":null,"stockpack_provider":null,"stockpack_image_url":null,"stockpack_license":null,"stockpack_license_url":null,"stockpack_modification":null,"color":null,"original_id":null,"original_url":null,"original_link":null,"unsplash_location":null,"unsplash_sponsor":null,"unsplash_exif":null,"unsplash_attachment_metadata":null,"_elementor_is_screenshot":null,"surfer_file_name":null,"surfer_file_original_url":null,"envato_tk_source_kit":null,"envato_tk_source_index":null,"envato_tk_manifest":null,"envato_tk_folder_name":null,"envato_tk_builder":null,"envato_elements_download_event":null,"_menu_item_type":null,"_menu_item_menu_item_parent":null,"_menu_item_object_id":null,"_menu_item_object":null,"_menu_item_target":null,"_menu_item_classes":null,"_menu_item_xfn":null,"_menu_item_url":null,"_trp_menu_languages":null,"rank_math_primary_category":null,"rank_math_title":null,"inline_featured_image":null,"_yoast_wpseo_primary_category":null,"rank_math_schema_blogposting":null,"rank_math_schema_videoobject":null,"_oembed_049c719bc4a9f89deaead66a7da9fddc":null,"_oembed_time_049c719bc4a9f89deaead66a7da9fddc":null,"_yoast_wpseo_focuskw":null,"_yoast_wpseo_linkdex":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_trp_translated_slug_en_us":null,"_wp_desired_post_slug":null,"_yoast_wpseo_title":null,"tldname":null,"tldpreis":null,"tldrubrik":null,"tldpolicylink":null,"tldsize":null,"tldregistrierungsdauer":null,"tldtransfer":null,"tldwhoisprivacy":null,"tldregistrarchange":null,"tldregistrantchange":null,"tldwhoisupdate":null,"tldnameserverupdate":null,"tlddeletesofort":null,"tlddeleteexpire":null,"tldumlaute":null,"tldrestore":null,"tldsubcategory":null,"tldbildname":null,"tldbildurl":null,"tldclean":null,"tldcategory":null,"tldpolicy":null,"tldbesonderheiten":null,"tld_bedeutung":null,"_oembed_d167040d816d8f94c072940c8009f5f8":null,"_oembed_b0a0fa59ef14f8870da2c63f2027d064":null,"_oembed_4792fa4dfb2a8f09ab950a73b7f313ba":null,"_oembed_33ceb1fe54a8ab775d9410abf699878d":null,"_oembed_fd7014d14d919b45ec004937c0db9335":null,"_oembed_21a029d076783ec3e8042698c351bd7e":null,"_oembed_be5ea8a0c7b18e658f08cc571a909452":null,"_oembed_a9ca7a298b19f9b48ec5914e010294d2":null,"_oembed_f8db6b27d08a2bb1f920e7647808899a":null,"_oembed_168ebde5096e77d8a89326519af9e022":null,"_oembed_cdb76f1b345b42743edfe25481b6f98f":null,"_oembed_87b0613611ae54e86e8864265404b0a1":null,"_oembed_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_oembed_time_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_tldname":null,"_tldclean":null,"_tldpreis":null,"_tldcategory":null,"_tldsubcategory":null,"_tldpolicy":null,"_tldpolicylink":null,"_tldsize":null,"_tldregistrierungsdauer":null,"_tldtransfer":null,"_tldwhoisprivacy":null,"_tldregistrarchange":null,"_tldregistrantchange":null,"_tldwhoisupdate":null,"_tldnameserverupdate":null,"_tlddeletesofort":null,"_tlddeleteexpire":null,"_tldumlaute":null,"_tldrestore":null,"_tldbildname":null,"_tldbildurl":null,"_tld_bedeutung":null,"_tldbesonderheiten":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_eael_widget_elements":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_acf_changed":null,"_wpcode_auto_insert":null,"_edit_last":null,"_edit_lock":null,"_oembed_e7b913c6c84084ed9702cb4feb012ddd":null,"_oembed_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_time_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_03514b67990db061d7c4672de26dc514":null,"_oembed_time_03514b67990db061d7c4672de26dc514":null,"rank_math_news_sitemap_robots":null,"rank_math_robots":null,"_eael_post_view_count":"136","_trp_automatically_translated_slug_ru_ru":null,"_trp_automatically_translated_slug_et":null,"_trp_automatically_translated_slug_lv":null,"_trp_automatically_translated_slug_fr_fr":null,"_trp_automatically_translated_slug_en_us":null,"_wp_old_slug":null,"_trp_automatically_translated_slug_da_dk":null,"_trp_automatically_translated_slug_pl_pl":null,"_trp_automatically_translated_slug_es_es":null,"_trp_automatically_translated_slug_hu_hu":null,"_trp_automatically_translated_slug_fi":null,"_trp_automatically_translated_slug_ja":null,"_trp_automatically_translated_slug_lt_lt":null,"_elementor_edit_mode":null,"_elementor_template_type":null,"_elementor_version":null,"_elementor_pro_version":null,"_wp_page_template":null,"_elementor_page_settings":null,"_elementor_data":null,"_elementor_css":null,"_elementor_conditions":null,"_happyaddons_elements_cache":null,"_oembed_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_time_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_time_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_59808117857ddf57e478a31d79f76e4d":null,"_oembed_time_59808117857ddf57e478a31d79f76e4d":null,"_oembed_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_time_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_81002f7ee3604f645db4ebcfd1912acf":null,"_oembed_time_81002f7ee3604f645db4ebcfd1912acf":null,"_elementor_screenshot":null,"_oembed_7ea3429961cf98fa85da9747683af827":null,"_oembed_time_7ea3429961cf98fa85da9747683af827":null,"_elementor_controls_usage":null,"_elementor_page_assets":[],"_elementor_screenshot_failed":null,"theplus_transient_widgets":null,"_eael_custom_js":null,"_wp_old_date":null,"_trp_automatically_translated_slug_it_it":null,"_trp_automatically_translated_slug_pt_pt":null,"_trp_automatically_translated_slug_zh_cn":null,"_trp_automatically_translated_slug_nl_nl":null,"_trp_automatically_translated_slug_pt_br":null,"_trp_automatically_translated_slug_sv_se":null,"rank_math_analytic_object_id":null,"rank_math_internal_links_processed":"1","_trp_automatically_translated_slug_ro_ro":null,"_trp_automatically_translated_slug_sk_sk":null,"_trp_automatically_translated_slug_bg_bg":null,"_trp_automatically_translated_slug_sl_si":null,"litespeed_vpi_list":null,"litespeed_vpi_list_mobile":null,"rank_math_seo_score":null,"rank_math_contentai_score":null,"ilj_limitincominglinks":null,"ilj_maxincominglinks":null,"ilj_limitoutgoinglinks":null,"ilj_maxoutgoinglinks":null,"ilj_limitlinksperparagraph":null,"ilj_linksperparagraph":null,"ilj_blacklistdefinition":null,"ilj_linkdefinition":null,"_eb_reusable_block_ids":null,"rank_math_focus_keyword":"bpftool","rank_math_og_content_image":null,"_yoast_wpseo_metadesc":null,"_yoast_wpseo_content_score":null,"_yoast_wpseo_focuskeywords":null,"_yoast_wpseo_keywordsynonyms":null,"_yoast_wpseo_estimated-reading-time-minutes":null,"rank_math_description":null,"surfer_last_post_update":null,"surfer_last_post_update_direction":null,"surfer_keywords":null,"surfer_location":null,"surfer_draft_id":null,"surfer_permalink_hash":null,"surfer_scrape_ready":null,"_thumbnail_id":"20683","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/posts\/20690","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/comments?post=20690"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/posts\/20690\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/media\/20683"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/media?parent=20690"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/categories?post=20690"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/nl\/wp-json\/wp\/v2\/tags?post=20690"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}