KernelScript 0.1: Complete Guide to the New Language for eBPF Development

Introduction to KernelScript

KernelScript 0.1 is the first public release of a new open-source programming language, specifically designed for eBPF-based development in the Linux kernel. Published under the Apache 2.0 license, KernelScript is a type-safe language that unifies eBPF, userspace, and kernelspace development in a single codebase.

This tool is particularly useful for developers working with eBPF, a Linux kernel technology that allows the execution of small verified programs in kernel context without modifying the kernel itself. eBPF is widely used for networking, tracing, observability, security, and performance analysis, but its development requires in-depth knowledge of verifier constraints, BPF helpers, maps, program loading, and libbpf-based userspace coordination.

KernelScript simplifies this process by offering a high-level syntax suitable for eBPF workflows. It supports the main types of eBPF programs, including XDP for packet processing, TC for traffic control, probes for kernel function tracing, and perf event programs for performance counters.

Additionally, KernelScript includes built-in support for eBPF maps, such as hash maps, per-CPU arrays, LRU maps, and pinned maps, available as language-level variables. This allows eBPF programs and userspace code to share state without manually writing libbpf boilerplate.

KernelScript also supports advanced eBPF features, such as automatic tail call orchestration, transparent dynptr management, program lifecycle checks, struct_ops support, and integrated kfunc integration.

This version is experimental. The repository indicates that KernelScript is beta software and warns that syntax, API, and features may change without backward compatibility. At this stage, developers discourage production use.

For more details, visit the project's GitHub repository.

Prerequisites

• Operating System: Linux
• C Compiler: GCC version 9.0 or higher
• Make: Version 4.0 or higher

PROCEDURE: Installing and Using KernelScript 0.1

By the end of this guide, you will have installed KernelScript 0.1 and be able to use this new programming language for eBPF-focused development in the Linux kernel.

• Step 1: Clone the KernelScript Repository

  git clone https://github.com/multikernel/kernelscript.git

• Step 2: Access the Project Directory

  cd kernelscript

• Step 3: Compile KernelScript

  make

• Step 4: Verify the Installation

  Verify that KernelScript has been compiled correctly by running:

  ./kernelscript --version

  You should see the software version, for example KernelScript 0.1.

• Step 5: Create a Sample File

  touch example.ks

• Step 6: Write a Sample Program

  Add the following sample code to the file example.ks:

  // Define a hash map

  map mymap : hash;

  // Define an eBPF function

  int myfunc(int key, int value) {

  my_map[key] = value;

  return 0;

  }

• Step 8: Verify the Generated Files

  ls

  You should see generated files such as example.c, Makefile, and others.

Verification and Troubleshooting

By the end of this section, you will be able to test the correct functioning of KernelScript and resolve any issues that may arise during use.

Functionality Test

• Code Compilation: Verify that the KernelScript code is compiled correctly, generating the necessary C code, userspace programs, Makefiles, and kernel module integration. Use the compilation command provided in the documentation.
• Program Execution: Run the generated program and check for any errors during execution. Ensure the program behaves as expected.
• eBPF Features Verification: Check that all eBPF features supported by KernelScript, such as XDP, TC, probes, and perf event programs, work correctly. Use debugging tools like bpftool to verify the status of loaded eBPF programs.
• eBPF Maps Verification: Ensure that eBPF maps, such as hash maps, per-CPU arrays, LRU maps, and pinned maps, are accessible by both eBPF programs and userspace code. Check that shared state works correctly.

Troubleshooting

• Compilation Errors: If compilation fails, check the error messages and ensure the KernelScript code syntax is correct. Verify that all necessary dependencies are installed.
• Runtime Errors: If the generated program does not start or crashes, check the kernel logs and error messages. Use debugging tools like strace or gdb to identify the issue.
• eBPF Maps Issues: If eBPF maps do not work as expected, verify that they are correctly defined in the KernelScript code. Check that read and write operations are performed correctly.
• Compatibility Issues: Since KernelScript is still in beta, you may encounter compatibility issues with specific versions of the Linux kernel or other libraries. Ensure you are using supported versions and consult the documentation for any compatibility notes.

Educational Summary

• KernelScript is an open-source language under the Apache 2.0 license.
• It unifies eBPF, userspace, and kernelspace in a single codebase.
• It automatically generates C code, userspace programs, Makefiles, and kernel integration.
• It supports main eBPF program types, such as XDP, TC, probe, and perf event.
• It integrates eBPF maps as language-level variables.
• It supports advanced features like tail call, dynptr, lifecycle checks, and kfunc.
• It is currently in beta and not recommended for production use.

Call to Practice

To further explore KernelScript, visit the official GitHub repository and start experimenting with this innovative eBPF development solution.