OpenAFS Workshop

Google Summer of Code 2025 Final Report

By: Sushil Pandey

Title: Investigating Multi-page Folio Support in the OpenAFS Linux Kernel Module

This project investigates enhancing the OpenAFS Linux kernel module by integrating multi-page folio support, addressing a critical performance limitation in the current system. OpenAFS currently uses single-page operations to interact with the Linux kernel's memory management system, despite newer kernel versions offering folio APIs that can manage multiple contiguous pages as a single unit. The goal is to transition OpenAFS to utilize multi-page folios, which will allow the system to handle larger memory regions more efficiently and reduce unnecessary overhead.

Key objectives include:

• Implementing dynamic multi-folio support to adapt to varying I/O patterns, particularly for large file operations that are aligned with OpenAFS's 64KB chunk architecture.
• Optimizing performance, especially for sequential read and write operations commonly seen in application deployments, which will significantly improve throughput and resource utilization.
• Ensuring compatibility with older kernel versions through autoconf detection and conditional compilation, allowing the system to gracefully fall back to traditional page-based operations where folios are not supported.

Organization: OpenAFS Project

Mentor: Cheyenne Wills

Contributor: Sushil Pandey

Motivation

OpenAFS has been working with compatibility issues in newer Linux kernel versions. Specifically, with the introduction of folios (Linux 5.16+) and changes in memory management paradigms, OpenAFS's reliance on small page units has become a performance bottleneck. This project focuses on modernizing OpenAFS's memory handling by integrating folios, enhancing the efficiency of large file operations, and ensuring compatibility with the latest Linux kernels.

Community Bonding Period: May 2025 - June 2025

During this phase, I analyzed the OpenAFS codebase to understand the memory management logic, focusing on areas where compatibility with newer kernel features was lacking. I also researched folios and their potential benefits for OpenAFS. This period was primarily dedicated to:

• Reviewing the code for existing page management techniques.
• Researching Linux kernel APIs related to folios.
• Setting up a development environment for testing across multiple kernel versions.

Coding Phase: June 2, 2025 - August 28, 2025

Focus: Folio Integration, Performance Optimization, and Large Page Research

During this combined phase, I focused on implementing the core compatibility layer to support folio-based operations and integrating multi-page folios for better memory management.

Key achievements:

• Folio Integration: Replaced traditional single-page memory operations with support for dynamic multi-folio memory management.
• Page Cache Management: Implemented folio-aware page cache allocation to handle larger memory units efficiently.
• Kernel Version Compatibility: Ensured compatibility of folio-based functions with Linux kernel versions 4.x to 6.x.
• Optimized Multi-Page Folios: Explored multi-page folio support for aligning with OpenAFS's 64KB chunk size, improving I/O efficiency for large file operations.
• Readahead Mechanisms: Enhanced read-ahead functions to work seamlessly with folios, improving sequential file access.
• Background Page Copying: Modified the page-copying mechanism to support folios while maintaining backward compatibility for single-page operations.
• Address Space Operations: Updated address space operations to utilize folio-based functions when available.

Future Improvements

Although the primary goals of the project were met, there are several areas where further improvements can be made:

• Large Page Implementation: Investigating Linux's transparent huge pages to improve performance for large file operations.
• Inode Optimization: Researching ways to optimize inode handling for folio-based memory management.
• Folio Sizing: Further development on intelligent folio order selection based on file access patterns, system memory, and network characteristics.

The focus of this GSoC project was on folio-based caching, and I plan to continue working on optimizing the performance and further developing inode optimizations and large page support.

Acknowledgment

I would like to extend my gratitude to the OpenAFS development community for providing me with the opportunity to contribute to this important open-source project. Special thanks to my mentor, Cheyenne Wills, for his invaluable guidance and support. Her expertise in both OpenAFS internals and Linux kernel development was instrumental in overcoming the project's challenges.

This work sets the foundation for future OpenAFS development, ensuring it will stay compatible with modern Linux kernels and provide efficient, scalable solutions for distributed file systems. I look forward to continuing this research and development to further modernize OpenAFS's memory management system.