Explore Projects

<p>By completing the iptables-translate tool we can let people know the benefits of using nftables and make the adoption of nftables easier.</p>

The host to host ipsec transport mode works on Linux but does not work on any of the BSDs. The problem is a lack of IKE socket bypass , transport mode policies actually catch IKE traffic itself, which causes problems in establishing and tearing down connections. I will add a socket bypass for all three BSD also the API is different on each one. I will fix the SA mode labeling in the PFKEYv2 backend, add proper teardown and on demand testing to the existing test suite, and make sure everything works as expected on FreeBSD, NetBSD, and OpenBSD.

Latency Tolerance Reporting is used to help manage ASPM (Active State Power Management). Some of the LTR values are platform-dependent and must be learned from platform firmware. Linux currently does not ask firmware for this information. I don't know exactly how this information needs to be incorporated into the ASPM support, but I think it's something we should figure out. See the PCI Firmware Spec, r3.2, sec 4.6.6.

Programming Protocol-independent Packet Processors (P4) is a domain-specific language for network devices, specifying how data plane devices (switches, NICs, routers, filters, etc.) process packets. BMv2 is a P4 software switch. Currently the BMv2 simulator supports v1model and Portable Switch Architecture (PSA). As the P4 use cases on the NIC side increases, so does the need for a P4 simulator that supports Portable NIC Architecture (PNA). In this project, I will focus on adding PNA support to BMv2. This proposal includes adding core subset of PNA to the BMv2 simulator; extending p4c BMv2 backend to target the updated BMv2 simulator; Identifying and Implementing various functionalities required by PNA as externs.

<p>Click boards are a flagship hardware product line of MikroElektronika with over 600 add-on boards ranging from wireless connectivity clicks to Human Machine Interface clicks for interfacing with peripheral sensors or transceivers. Most of the Click boards use the common protocols like SPI,I2C or UART to communicate with the Beaglebone and thus the support for them now is accomplished via device tree overlays via the bb.org-overlays repository. This requires /boot/uEnv.txt to be modified to load the drivers at boot, requiring at least one reboot to enable the support in a potentially error-prone way.</p> <p>The Greybus Simulator is a tool which simulates an AP Bridge, SVC, and an arbitrary set of modules plugged into Greybus. Greybus already provides most of the interfaces used on click boards and utilises manifest files to enumerate hardware at run-time.This project aims to enable Click Board Support via Greybus Simulator by writing suitable Manifests according to the Click board Specifications and by simply copying the manifest to a hotplug-directory a click board can be loaded,which would make the interfacing a lot easier.</p>

<p>The aim of the project is to create easy-to-use APIs for the hardware on the BB Blue. This would consist of developing/improving kernel drivers for the on-board devices and then re-implementing the Strawson APIs to use these kernel drivers. These APIs will then be used by real-time applications which can be run on BB Blue. In the later phase of the project, support for BB Blue will be added in Ardupilot and ROS will be ported to BB Blue using these APIs.</p>

This proposal lays out plans to bring native MPLS support into the FreeBSD kernel. MPLS—Multi-Protocol Label Switching—is a fast packet-forwarding method you’ll find everywhere in big service provider and data center networks. Instead of making routers do complex IP lookups at every hop, MPLS uses simple label swapping. The magic happens with a tiny 32-bit shim header that holds a 20-bit label, a few bits for traffic class, a stack indicator, and an 8-bit TTL. This header sits snugly between Layer 2 and Layer 3 headers, letting routers in the core do blazing-fast forwarding while pushing tough routing decisions to the network edge. FreeBSD is famous for its solid IPv4 and IPv6 networking stack, but it’s been missing native Layer 2.5 switching. That gap has made it hard for FreeBSD to get traction in provider core networks. Meanwhile, OpenBSD and NetBSD have shipped MPLS support for ages, and Linux has had MPLS built in since kernel 4.3. FreeBSD’s overdue update doesn’t just catch up—it leapfrogs the other BSDs. This project stands out in two big ways: it adds ECMP multipath support using the modern nhgrp (Nexthop Group) subsystem, and it swaps out the old, hard-to-extend rtsock interface for a much more flexible Netlink-based control plane.

This project aims to enable testing of Guarded Control Stack (GCS) functionality within CRIU (Checkpoint/Restore In Userspace) on AArch64 by integrating the Armv9.4-A GCS feature into CRIU’s ZDTM test suite through a dedicated test case that confirms whether TPIDR2_EL0 is preserved and still readable in user space after restore. The project leverages recent upstream additions to glibc and Linux kernel that enable GCS support in user space, using Yocto and Arm's Fixed Virtual Platform (FVP) to emulate and test the architecture-specific functionality. This is a first step in exploring how CRIU might need to change to handle GCS systems, starting with test coverage Project Deliverables June 2 (coding begins) - GCS-enabled Environment Verified. Yocto + FVP setup is confirmed working. Compiling and running GCS-marked binaries with glibc tunables active. July 12-16 (Midterm Evaluation) - First GCS ZDTM test added. A basic test that reads verifies TPIDR2_EL0, and explores stack/register consistency across the restore boundary. Integration with --nocr working. Investigation of parasite.c and restorer.c to identify the point at which TLS or control state (e.g., TPIDR2_EL0) could be saved or restored. August 16-August 23 (Final Evaluation) - Full round-trip test of checkpointing and restoring a GCS-using process. All tunables, toolchain flags, and kernel glibc dependencies documented. August 31 (Final Results Announced) - Final cleanup and documentation. Tutorial-style instructions provided on how to replicate setup, test flow, and next steps. Post GSOC - I will remain available to support further maintenance, and help any future contributors pick up.

Adding UVC hardware timestamp support to libcamera by replacing the timestamp sampled by the linux kernel when it completes a buffer. The goal would be to capture the device's hardware frame clock information in the UVC pipeline handler and convert this to the host PC's time. The conversion function will be based off of one used by V4L2 in the Linux kernel. The expected result is to report accurate timestamps for completed frames obtained directly from the device.

This project aims to add VMM acceleration support to QEMU on FreeBSD, bridging the gap between QEMU’s userspace emulation and FreeBSD’s kernel-based VMM hypervisor. Currently, QEMU on FreeBSD lacks hardware acceleration, forcing users to rely on slower TCG emulation or switch to bhyve. I plan to modify QEMU’s memory management to work with VMM’s kernel-allocated guest memory. Additionally, I will adapt VMM to make non-critical devices (HPET, RTC) optional, letting QEMU handle them in user space. This would enable a hybrid interrupt model (kernel vLAPIC + emulated IOAPIC). The deliverables for this project would be a working -accel=vmm backend for QEMU. I will also add some changes to VMM, allowing some of the in-kernel devices to be made optional. Finally, I will add comprehensive documentation and benchmarks for the libvmmapi interface. This will enable near-native performance for QEMU on FreeBSD, expanding virtualization options while maintaining compatibility with existing QEMU tooling.

CRIU currently does not support checkpoint/restore for UDP sockets with the UDP_CORK socket option. In order for CRIU to support the UDP_CORK socket option, we need to read back the data in the UDP socket send queue at the checkpoint, and restore the send queue data along with the UDP_CORK socket option to the new UDP socket at the restore. In order to implement reading back UDP socket send queues, we need to find a way to extend the Linux kernel that is accepted by the kernel community. In this proposal I proposed 6 technical paths that can be used to implement dumping of UDP socket send queue and analyzed their advantages and disadvantages, including an innovative approach to dumping kernel information using eBPF.

Currently, Bluetooth HID support in FreeBSD is limited to the bthidd daemon. The daemon, while functional, uses its own custom userspace drivers rather than the existing HID drivers in the kernel. Of these userspace drivers, only keyboards and mice are supported. This project proposes a more integrated design via a new Netgraph node type: ng_bthid. This node will hook to ng_l2cap and function as a virtual transport layer that interfaces directly with hidbus. The aim is to make HID support more transport-agnostic, moving away from the previous approach of maintaining separate, redundant drivers for devices over Bluetooth.

<p>The GStreamer libcamera element allows libcamera to be used in GStreamer pipelines. libcamera supports simultaneous streaming, for example having lower quality one stream for preview, while another higher quality one is used for recording. We would like to extend support for the GStreamer libcamera element to support this multistreaming.</p>

<p>This project adds support for dump and restore of io_uring instances. The three main goals of this project is to handle dump/restore of empty io_uring, dump/restore of io_uring with completed events and no inflight events, and dump/restore of io_uring with in flight as well as completed events. The ring buffer needs to replay unconsumed entries on restore in a way that is transparent to the application. This project achieves these objectives.</p>

XFS is a file system that was designed for computer systems with large numbers of CPUs and large disk arrays. It focuses on supporting large files and good streaming I/O performance. Haiku Currently has XFS version 4 read support. The goal of this project is to get XFS version 5, Extended Attributes, Symbolic links and write support for Haiku.

<p>Btrfs (B-tree filesystem) is a filesystem uses Btrees as its main on-disk data structure. It is based on Copy-on-Write (CoW) principle which means it does copy only when a write request is sent or a modification is necessary. Btree is used most in filesystem, database system. In Haiku, Btrfs is currently support read-only, the codebase only shows the basic structure, read operations, it lacks of core tree manipulation code, write supports, and other features. The project ideas request supporting write features for Btrfs. This will be accomplished in the following steps: Setting up userland friendly development mode for Btrfs, implementing tree operations (splittings, CoW, etc), adding more Btrfs structures if necessary, implementing write-feature functions.</p>

Currently, OpenAFS provides the afsio command that supports read, writes, and locks to both files and directories in the AFS environment without going through the cache manager. However, it does not support mount point control, ACL manipulation, or directory operations, which would allow a fully functional cell to be created without the cache manager; This would be convenient for administrators, as it avoids the kernel module having to be installed on the machine setup is being performed from, as well as allowing setup in environments not compatible with the kernel module. To address this problem, I will implement all three types of subcommands of afsio; Key deliverables include the code for all of these types of commands, as well as documentation such that administrators know how to use them.

<p>Keyhole Markup Language (KML) is an XML notation for expressing geographic annotation and visualization within two-dimensional maps and three-dimensional Earth browsers. The MSS software currently supports in a very crude manner the overlay of KML files on the shown maps to support flight planning.</p> <p>In this project, I will redesign and implement a better UI to display multiple KML files simultaneously. I will also be focussing on enhancing useful features from KML specification and implementing them in the MSS frontend.</p>

NetBSD with the thin in-kernel ABI layer COMPAT_LINUX enables support for running Linux binaries by means of emulation on NetBSD systems. As newer features are added to the Linux kernel, newer system calls are also added when they are deemed essential. This project attempts to identify some of the such critical newer system calls that currently have no emulation support by means of the Linux Test Project and add support for them in the emulation layer by following a mix of some of the strategies like limited support, native support, empty subs, etc. This extends the NetBSD kernel emulation completeness, trying to tackle the Linux2NetBSD binary execution problem, one system call at a time.

<p>The project goal is boot up to mainline kernel on STM32F7-discovery ARM Cortex-M7 microcontroller evaluation board and to implement code to utilize some of its features.</p> <p>ARM Cortex-M7 that is powerful microcontroller core, it has D&amp;I cache, 6-stage pipeline, super-scaler and so on. Several ARM Cortex-M7 development boards(e.g. STM32F7-discovery) has enough memory to boot linux kernel, but the mainline kernel has not supported. If ARM Cortex-M7 supported, then we will be more easy to develop applications.</p>

<p>Kworkflow is a kernel developer workflow tool with the simple mission of reducing the overhead with infrastructure setup for Linux development. In order to accomplish this goal, Kworkflow (or kw as it is commonly called by the community) must support a wide range of different setups. However, kw currently only supports two families of Linux distributions (Debian and Arch) and one bootloader(GRUB2). To help Kworkflow better accomplish its mission, the first half of this project will be dedicated to expanding support to some key bootloaders/bootmanager such as: U-boot (widely used by embedded systems and by ChromiumOS), rEFInd and the RaspberryPi bootloader. The second half of this project will build upon the work previously done by adding support to other Linux distributions, such as the RHET family and the ChromiumOS (through the newly supported U-boot).</p>

<p>Testing is an integral and important part of any software development cycle, open or closed. Given a fully automated test system, we can run a broad variety of tests with high frequency, and find problems soon after they are introduced.<br> Kernel Crash Dumping mechanism that allows us to save the contents of the system’s memory for later analysis. The FreeBSD core dump facility preserves a copy of the contents of system memory to a special disk partition at the time of a fatal error for later debugging. This copy or “dump” can be a machine-readable form of the complete contents of system memory or just the set of kernel pages that are active at the time of the crash. The state can be recovered by saving it to a file under /var/crash. Kernel core dumps allow us to examine the state of the kernel after a kernel panic or hang. Currently, there is no automated test suite in FreeBSD to verify if all the code paths work. The aim of the project is to create a framework for recovering and testing those kernel dumps for a different set of configuration variables or code paths while logging every test case separately in a log file and later analyzing which code paths failed.</p>

<p>The goal of this project is to enable the Trace Compass to analyze and display some basic information using Event Recording infrastructure. Trace Compass is a software for viewing and analyzing any type of logs or traces. The basic information to analyze and display information may include CPU usage, IRQ analysis(IRQ Statistics, IRQ Table, IRQ vs Count, IRQ vs Time), Linux Kernel(Control Flow, Resources) etc. The advanced support for Trace Compass could include dynamic memory traces, stack usage, network packet flow etc.</p> <p>If successful in the generation of trace data(LTTng) then, it can be transferred via TCP/UDP(TCP already available) method from target running RTEMS application to the host.</p>