GSoC Proposal

Project Proposal: Enhancing OpenAFS with Multi-Page Folio Support

General Information

• Name: Utkarsh Maurya
• Email: projects.utkarshMaurya@gmail.com
• IRC Nickname: [Your libera.chat nickname]

Biography

I am a computer science student with a robust background in systems programming and Linux kernel development. My expertise includes kernel module development, memory management, and working with distributed file systems. I have contributed to various open-source projects and am experienced in debugging kernel modules using tools like GDB, ftrace, and perf. I am proficient in C programming and have a thorough understanding of kernel internals and the Linux Virtual File System (VFS).

To further strengthen my understanding, I plan to dive deeper into OpenAFS’s cache management subsystem, especially how it interacts with the Linux page cache and memory allocation mechanisms. I will also study recent changes to the folio API in the Linux kernel, particularly multi-page folio support, and ensure compatibility across different kernel versions.

I have worked on several low-level systems projects that demonstrate my skills:

myOwnOS: A bare-metal operating system built for Raspberry Pi 3B, where I implemented memory-mapped I/O routines, stack initialization, and startup code using gcc-arm-none-eabi.

baking-pi-3: A reimplementation of the Baking Pi course adapted for Raspberry Pi 3B, covering peripheral control, boot sequence debugging, and interrupt-driven programming.

Kernel-Carnival: A toy kernel with user-kernel mode separation, a memory allocator, and custom system calls, which helped me gain insight into syscall handling, memory protection, and userspace integration.

These experiences have provided me with a solid foundation for working on the OpenAFS Linux kernel module and contributing meaningful improvements.

Availability

I am fully committed to this project, dedicating approximately 40 hours per week during the GSoC period. While I have some minor personal and academic responsibilities, my primary focus will be this project.

Project Title

Enhancing OpenAFS with Multi-Page Folio Support

Project Description

OpenAFS is a distributed file system that leverages the Linux kernel’s page cache for efficient file access and caching. Currently, OpenAFS treats folios as single-page structures, which limits its performance potential. With the introduction of multi-page folios in the Linux kernel, there is an opportunity to improve memory efficiency and I/O performance by handling contiguous memory blocks larger than a single page.

The primary objectives of this project are to:

• Extend OpenAFS’s support to multi-page folios.
• Reduce operational overhead by minimizing locking operations and function calls.
• Improve TLB and cache efficiency through enhanced spatial locality.
• Enable more efficient batching of I/O operations for faster read/write performance.

This upgrade will modernize OpenAFS’s memory management, aligning it with current kernel standards and improving overall system performance.

Architecture Diagram

This diagram highlights the transition from single-page folio allocation to multi-page folio support in OpenAFS.

Project Deliverables

Milestone 1 (Weeks 1-3)

• Analysis: Study OpenAFS’s existing page cache and cache management implementations.
• Identification: Pinpoint key areas where multi-page folio support will yield performance benefits.
• Environment Setup: Establish a comprehensive testing and benchmarking environment.

Milestone 2 (Weeks 4-6)

• Initial Integration: Replace alloc_page() calls with folio_alloc() where applicable.
• Metadata Handling: Ensure correct handling of folio metadata (e.g., folio_set_private(), folio_address()).
• Benchmarking: Implement initial performance tests to gauge improvements in I/O operations.

Milestone 3 (Weeks 7-9)

• Optimization: Refine data structures and optimize lock management for multi-page folio usage.
• Compatibility: Add fallback mechanisms for backward compatibility with older kernel versions.
• Testing: Conduct extensive functional testing and debugging.

Milestone 4 (Weeks 10-12)

• Finalization: Complete stress testing and performance profiling.
• Documentation: Prepare comprehensive documentation and submit upstream patches.
• Handoff: Ensure the implementation is well-documented for future maintenance.

Test Plan

Unit Testing

• Framework: Use KUnit to test folio allocation, deallocation, and metadata management.

Functional Testing

• Operations: Validate read/write operations under various workloads.
• Integrity: Verify memory integrity and cache correctness.

Performance Benchmarking

• Metrics: Compare I/O latency, CPU utilization, memory footprint, and cache hit ratios before and after implementation.
• Tools: Utilize standard benchmarking tools and custom test suites.

Regression Testing

• Test Suite: Run the existing OpenAFS test suite.
• Compatibility: Ensure no regressions occur on older or LTS kernel versions.

Project Schedule

Initial Code Snippet

Below is an example of how multi-page folio allocation and basic read operation can be integrated:

#include <linux/mm.h>
#include <linux/folio.h>
#include "osi_file.h" // OpenAFS-specific headers

/* Allocate a multi-page folio */
struct folio *afs_alloc_folio(gfp_t gfp_mask, unsigned int order)
{
    struct folio *folio = folio_alloc(gfp_mask, order);
    if (!folio)
        return NULL;
    // Additional initialization if necessary
    return folio;
}

/* Read operation using a multi-page folio */
int afs_linux_read_folio(struct file *file, struct folio *folio)
{
    void *kaddr = kmap_local_folio(folio, 0);
    if (!kaddr)
        return -ENOMEM;

    // Simulated read: Replace with actual OpenAFS read logic
    memset(kaddr, 0, folio_size(folio));

    folio_mark_uptodate(folio);
    folio_unlock(folio);
    kunmap_local(kaddr);

    return 0;
}

Graph: Projected Performance Improvements

These benchmark expectations are based on preliminary analyses and will be refined during testing.

Conclusion

By implementing multi-page folio support in OpenAFS, this project aims to significantly improve memory management, reduce I/O latency, and enhance overall system performance. The proposed changes not only align OpenAFS with modern Linux kernel practices but also set the stage for more efficient and scalable distributed file system operations.

I am excited about the opportunity to contribute to OpenAFS and the broader Linux ecosystem through this project. I look forward to your feedback and the chance to discuss further details.

Thank you for considering my proposal!