awslabs/mountpoint-s3

Mountpoint for Amazon S3 is a high-throughput file client that allows users to mount Amazon S3 buckets as a local file system using FUSE. It provides a Rust-based implementation featuring configurable memory management, multi-level caching (including local disk and S3 Express One Zone), and robust support for both reading and writing objects with checksum validation. The system includes a dedicated S3 client library, comprehensive benchmarking tools for performance analysis, and packaging infrastructure for distributing binaries across various Linux distributions.

27 changes.

This period marks the initial release of Mountpoint for Amazon S3, establishing the core Rust crates, AWS Common Runtime bindings, and the high-performance S3 client library. It also introduces essential build, packaging, and testing infrastructure, including Docker support and comprehensive integration tests, to enable stable deployment and benchmarking.

36 changes.

This period focused on establishing the core Mountpoint S3 filesystem library, introducing critical features such as multi-level caching with S3 Express One Zone, backpressure-driven prefetching, and robust memory management. Concurrently, a comprehensive benchmarking and testing infrastructure was built, including automated experiment runners, stress tests, and property-based verification to ensure performance and stability.

Users can now run Mountpoint for Amazon S3 inside Docker containers. The change introduces two Dockerfiles: a primary \Dockerfile\ that installs the official \mount-s3\ binary from Amazon Linux 2023, and a \Dockerfile.source\ that builds the binary from source. A \README.md\ provides instructions for building the images and running the container, including necessary privileges (\--cap-add SYS\_ADMIN\, \--device /dev/fuse\) and credential configuration for AWS.

docker · high confidence

New fio benchmark definition files have been added to the benchmark/fio directory, introducing global settings and specific profiles for sequential read and sequential write operations. These configurations allow users to run standardized I/O benchmarks with parameters such as block size, run time, and thread count, supporting the initial version of the benchmark experiment runner.

benchmark/fio · high confidence

The \mountpoint-s3-crt-sys\ crate now includes a new logging shim (\logging\_shim.c\ and \logging\_shim.rs\) that enables the underlying AWS Common Runtime (CRT) to emit log messages into the Rust application. Because the CRT uses C variadic arguments for its logging format strings, this shim provides a C trampoline to handle the variadic data and pass it to a Rust function pointer, allowing users to capture and process CRT log output within their Rust code.

mountpoint-s3-crt-sys/src · high confidence

The benchmark website now includes the Chart.js library (version 2.9.2) and its associated CSS, enabling the rendering of charts and data visualizations on the page.

_benchmark\website · high confidence

The \examples/fuse-fd-mount-point\ directory now includes a Go helper script (\mounthelper.go\) that demonstrates how to mount a filesystem using a FUSE file descriptor. This example opens \/dev/fuse\, performs the mount syscall with the file descriptor, and spawns the \mount-s3\ binary in the foreground to facilitate log access, providing a concrete reference for integrating FUSE fd-based mounting.

examples/fuse-fd-mount-point · high confidence

This change introduces a new Python-based tool in \package/spec\ that automatically generates distribution-specific RPM spec files. The \generate\_spec.py\ script extracts version information from \Cargo.toml\ and \rust-toolchain.toml\, scans git submodules for bundled library declarations, and renders the \amzn2023.spec.template\ using Jinja2. This allows users to produce ready-to-build \.spec\ files for Amazon Linux 2023 by running the generator script, with support for custom templates and GitHub source URLs.

package/spec · high confidence

The \mountpoint-s3-crt\ crate now provides Rust wrappers for the AWS Common Runtime (CRT) libraries, including auth, HTTP, I/O, and S3 components. This introduces a demand-driven initialization model where each CRT subsystem is initialized on first use, with automatic cleanup registered at process exit to ensure worker threads are joined safely. The bindings expose core primitives such as allocators, byte buffers, error handling, and logging adapters, forming the foundational layer for subsequent S3 client and upload functionality.

mountpoint-s3-crt/src · high confidence

This change introduces the initial version of Mountpoint for Amazon S3, a high-throughput file client that allows users to mount Amazon S3 buckets as a local file system. The repository now includes the core Rust crates (including \mountpoint-s3-crt-sys\, \mountpoint-s3-fs\, and the main \mountpoint-s3\ binary), a Makefile for building and testing, and configuration files for the Rust toolchain (v1.98), code formatting, and license compliance. It also sets up the build infrastructure with vendored AWS Common Runtime dependencies and a FUSE fork, along with documentation for installation on Amazon Linux 2023, Ubuntu, and other RPM-based distributions.

(repo-wide) · high confidence

The \mountpoint-s3-crt-sys\ crate is introduced to provide automatically generated Rust FFI bindings to the AWS Common Runtime (CRT). This change adds the foundational build infrastructure (\build.rs\) that compiles CRT C libraries (such as \aws-lc\, \s2n-tls\, and \aws-c-s3\) from git submodules and generates Rust bindings for specific headers. It also includes documentation (\README.md\, \UPDATING\_CRT.md\) and a changelog (\CHANGELOG.md\) to support the maintenance and release process of these low-level bindings.

mountpoint-s3-crt-sys · high confidence

This change introduces the \mountpoint-s3-client\ crate, providing a high-performance Amazon S3 client built on the AWS Common Runtime (CRT). The library exposes a generic \ObjectClient\ trait supporting standard object operations (Get, Put, Head, List, Copy, Delete, Rename) and includes concrete implementations such as \S3CrtClient\ for real AWS S3 access and \MockClient\ for testing. Key features include configurable endpoint resolution, authentication via the CRT, CRC64-NVME/CRC32C/CRC32/SHA checksumming support, backpressure handling for GET requests, and an Instance Metadata Service (IMDS) client for retrieving EC2 instance information.

mountpoint-s3-client/src · high confidence

Mountpoint now supports caching data to S3 Express One Zone directory buckets via a new ExpressDataCache implementation, allowing for lower-latency access to cached blocks. A MultilevelDataCache has been added to combine local disk caching with S3 Express caching, automatically populating the local disk cache from the Express cache on cache misses to optimize performance. This change introduces the necessary infrastructure for shared, high-performance caching across Mountpoint instances while maintaining local disk caching as the primary storage tier.

_mountpoint-s3-fs/src/data\cache · high confidence

This change adds the core Rust wrapper components for the AWS Common Runtime (CRT) S3 client within the \mountpoint-s3-crt/src/s3\ module. It introduces \buffer.rs\ to manage data buffers and ownership tickets, \pool.rs\ to bridge custom asynchronous memory pool implementations to the CRT interface, \endpoint\_resolver.rs\ to handle endpoint resolution via rule engines, and \client.rs\ to provide the high-level \Client\ and \ClientConfig\ builders for configuring S3 connections, signing, and network interfaces.

mountpoint-s3-crt/src/s3 · high confidence

The \mountpoint-s3-crt/src/common\ module now provides safe Rust abstractions for core AWS Common Runtime (CRT) components, including memory allocation (\Allocator\ with tracing support), byte buffers (\ByteBuf\), error handling (\Error\), logging infrastructure (\Logger\ with a \RustLogAdapter\ for the \log\ facade), string management (\AwsString\), URI parsing (\Uri\), and asynchronous task scheduling (\Task\ and \TaskScheduler\). This change establishes the foundational common layer that other parts of the crate rely on for safe interaction with the underlying C library.

mountpoint-s3-crt/src/common · high confidence

The \mountpoint-s3-crt/src/http\ module now includes a new \request\_response.rs\ file that provides a Rust-native wrapper for managing HTTP headers. This introduces \Header\ and \Headers\ structs with methods to add, retrieve, check for existence, and erase headers, along with a \HeadersError\ enum for error handling. This change establishes the foundational API for HTTP header manipulation within the S3 CRT client layer.

mountpoint-s3-crt/src/http · high confidence

Added a new example in the \examples/pytorch\ directory that demonstrates how to use Mountpoint as a PyTorch data loader via the torchdata library. The example trains a ResNet-50 model using PyTorch Lightning on synthetic ImageNet-style data stored in S3 as WebDataset shards or individual files. It supports multiple data loading strategies via the \--source-kind\ argument, including Mountpoint (accessing S3 as a local filesystem), S3IO (using torchdata's S3FileLoader), and FSSpec, allowing users to compare performance and ease of use.

examples/pytorch · high confidence

The \mountpoint-s3-crt/src/auth\ module now provides Rust wrappers for the AWS CRT's authentication subsystem, introducing \CredentialsProvider\ (supporting default chains, profiles with caching, static keys, and anonymous access), an \ImdsClient\ for retrieving EC2 instance metadata, and \SigningConfig\ for configuring AWS SigV4, SigV4A, and S3 Express One Zone request signing. This enables the application to authenticate and sign S3 requests using modern AWS credential sources and signing algorithms.

mountpoint-s3-crt/src/auth · high confidence

The examples directory now includes three new command-line utilities: \client\_benchmark\ for measuring S3 download throughput with support for concurrent requests, backpressure control, and JSON output; \download\ for fetching objects with optional byte-range support; and \list\ for listing bucket contents with prefix and delimiter filtering. These examples demonstrate modern usage patterns of the Mountpoint S3 client, including the new \GetObjectParams\ API and backpressure handling.

mountpoint-s3-client/examples · high confidence

The S3 client implementation in this location has been replaced with a new \S3CrtClient\ that provides full support for S3 operations including GetObject (with streaming, backpressure, and checksum support), PutObject (single and multipart with trailing checksums and custom headers), CopyObject, DeleteObject, HeadObject (with SSE and restore status parsing), HeadBucket, ListObjectsV2 (with checksum algorithms), GetObjectAttributes, and RenameObject (for S3 Express One Zone). The new client uses the AWS CRT for async I/O, implements proper error parsing for S3 XML responses, and includes tests for error handling scenarios.

_mountpoint-s3-client/src/s3\_crt\client · high confidence

A new \smart\_benchmark\ sweeper plugin has been added to the benchmarking tools, allowing users to automatically generate and execute parameter combinations for specific benchmark types. By specifying a \benchmark\_type\ override (defaulting to 'fio'), the sweeper loads corresponding configuration parameters from YAML files in \conf/hydra/sweeper/\, merges them with base parameters, and launches the resulting job combinations via the configured launcher. This simplifies running structured benchmark suites by handling the combinatorial logic and configuration loading internally.

_benchmark/hydra\plugins · high confidence

Added a new Python script, autogroup.py, to the benchmark analysis tools. This script automatically parses benchmark output files (supporting CRT, Client/Prefetch, and FIO formats) and Hydra configuration directories to extract throughput metrics. It groups results by varying parameters, calculates statistics, and allows users to export the summarized data to CSV or JSON formats for easier review and reporting.

benchmark/analysis-scripts · high confidence

The benchmark directory now includes a new experiment runner (\benchmark.py\) that uses Hydra for configuration management and supports running fio, prefetch, client, and crt benchmark types. The runner automatically collects resource monitoring data (CPU via mpstat, bandwidth via bwm-ng, perf stat counters, and flamegraphs) during execution and can optionally upload results to an S3 bucket. It also captures EC2 instance metadata for experiment tracking.

benchmark · high confidence

The mountpoint-s3-crt crate now includes native Rust wrappers for CRC32, CRC32C, CRC64-NVME, SHA1, and SHA256 checksums, exposing both simple one-shot computation functions and incremental Hasher APIs for streaming data. CRC64-NVME also provides a combine function to merge checksums from consecutive data blocks, supporting efficient multipart upload scenarios.

mountpoint-s3-crt/src/checksums · high confidence

Three new binaries are added to the \mountpoint-s3\ crate to support testing and performance analysis. The \mock-mount-s3\ binary allows developers to run the mount client against an in-memory mock S3 backend, enabling safe testing with simulated network throughput limits and pre-populated test data without contacting real AWS services. The \file-system-benchmarks\ binary provides a tool for measuring Linux file system operation latencies (open, write, flush) on mounted S3 buckets, outputting results as JSON. Additionally, the \mount-s3-log-analyzer\ binary helps parse Mountpoint logs to extract peak memory usage (RSS) and specific memory pool metrics, supporting CI jobs that enforce memory limits.

mountpoint-s3/src/bin · high confidence

Developers on macOS can now run integration tests against a Linux environment using a new Docker-based development container. This setup includes a pre-configured Linux image with FUSE support, Rust toolchain management, and persistent caching for Cargo and build artifacts to speed up iterations. A Python helper script (\dev.py\) simplifies building, running, and cleaning up the container, while supporting credential injection via environment variables or AWS config files to facilitate local testing of S3-related features.

dev-container · high confidence

Added a new example (\download\_crt.rs\) that shows how to use the underlying CRT S3 client directly for \GetObject\ requests. This example illustrates manual configuration of the event loop, host resolver, retry strategy, and credentials provider, providing a reference for advanced users who need fine-grained control over the S3 connection layer beyond the high-level SDK.

mountpoint-s3-crt/examples · high confidence

The examples directory now includes a suite of new utilities to help users generate S3 object manifests, mount buckets using a structured JSON configuration file, and benchmark read/write performance. The \create\_manifest\ example provides a CLI tool to generate CSV manifests with CRC32C checksums for bucket contents. The \mount\_from\_config\ example demonstrates mounting S3 buckets using a versioned JSON configuration file that supports settings for disk caching, memory limits, and throughput. Additionally, \fs\_benchmark\, \prefetch\_benchmark\, and \upload\_benchmark\ examples offer configurable tools to measure read throughput, prefetcher performance, and upload speeds, respectively, with options for memory targeting and throughput constraints.

mountpoint-s3-fs/examples · high confidence

Added a comprehensive set of fio job definitions and orchestration scripts (fs\_bench.sh, fs\_cache\_bench.sh, fs\_latency\_bench.sh) to benchmark Mountpoint's filesystem performance. The suite covers sequential and random read/write throughput, mixed read/write workloads, and latency metrics including time-to-first-byte and one-byte file creation. It supports configurable parameters such as direct I/O, multi-threading, small vs. large file sizes, and memory limits, and includes specific tests for cache behavior and readdir operations across varying directory sizes.

mountpoint-s3/scripts · high confidence

The \mountpoint-s3-fs\ library crate is introduced, providing the core FUSE filesystem implementation (\S3Filesystem\), FUSE bindings (\S3FuseFilesystem\), and configuration (\MountpointConfig\). This release adds automatic network throughput detection for EC2 instances via the \autoconfigure\ module, which queries the AWS EC2 API and generates a Rust lookup table (\instance\_throughput.rs\). It also introduces data integrity validation for downloaded data using CRC32C checksums (\ChecksummedBytes\), automatic content-type detection for uploaded objects based on file extensions, and a new \Runtime\ abstraction for async task spawning.

mountpoint-s3-fs/src · high confidence

The \mountpoint-s3-crt/src/io\ module now exposes Rust wrappers for core AWS Common Runtime networking primitives. Users can now construct \ClientBootstrap\ instances to manage network channels, configure \HostResolver\ for asynchronous DNS resolution, and set up \TlsContext\ and \TlsConnectionOptions\ for secure connections, including support for custom CA bundles via \override\_default\_trust\_store\_from\_path\. The module also introduces \EventLoop\ and \EventLoopGroup\ for scheduling asynchronous tasks, a \FutureSpawner\ trait to integrate Rust futures with the CRT's event loops, and a \RetryStrategy\ for handling request retries with exponential backoff.

mountpoint-s3-crt/src/io · high confidence

A new \ThroughputMockClient\ has been added to the mock client module, allowing users to simulate specific S3 download throughput limits (in gigabits per second) without the jitter or latency of a real service. This is implemented using a new \LeakyBucket\ rate limiter that controls the rate at which data is delivered via the \GetObject\ stream, enabling more realistic performance testing of applications that read from S3.

_mountpoint-s3-client/src/mock\client · high confidence

The \package\ directory now provides a complete build system for generating Mountpoint release packages. It includes a Dockerfile based on CentOS 7 (updated to use vault.centos.org for EOL support) that installs necessary build tools, Rust toolchain, and \cargo-about\ for license generation. A new Python script (\package.py\) orchestrates the build process, producing RPM, DEB, and tar.gz artifacts with correct naming conventions (e.g., \arm64\ for aarch64). Additionally, a dedicated script (\generate\_amzn2023\_srpm.sh\) and spec files (\mount-s3.spec\, \mount-s3-suse.spec\, \mount-s3.debian-control\) enable building Source RPMs for Amazon Linux 2023 and SUSE, as well as standard RPMs and DEBs for other distributions.

package · high confidence

Added a new \package/validate\ directory containing a Python driver script and OS-specific shell scripts to validate Mountpoint release artifacts. This tool verifies RPM, DEB, and gzip packages by downloading them, verifying GPG signatures, installing them in Docker containers (Ubuntu, Amazon Linux 2, SUSE, CentOS 8), and running a test mount to ensure functionality.

package/validate · high confidence

The \s3io\_benchmark\ example tool is now available to benchmark the Mountpoint S3 prefetcher and uploader components. It accepts a TOML configuration file to define global settings (such as bucket, region, memory target, and checksum algorithms like CRC64NVME) and specific read/write jobs with configurable access patterns (sequential or random), object sizes, and parallelism. The tool automatically generates test objects for read workloads, executes the defined jobs concurrently, and reports detailed results including throughput, duration, and peak memory usage in JSON format.

_mountpoint-s3-fs/examples/s3io\benchmark · high confidence

Mountpoint now includes a structured error logger that writes FUSE operation failures to a JSON-formatted file, enabling automated detection of specific issues like throttling (HTTP 503) or permission errors (HTTP 403/AccessDenied). Additionally, a new toggleable logging layer allows users to dynamically cycle through log levels (e.g., error, debug, info) at runtime, and a syslog subscriber has been added to forward logs to the system logger via a Unix socket.

mountpoint-s3-fs/src/logging · high confidence

Mountpoint now accepts command-line arguments in a format compatible with /etc/fstab, allowing users to define S3 bucket mounts in system configuration files. The new \fstab.rs\ module parses comma-separated options (with backslash escaping) and maps standard fstab flags like \ro\ to their Mountpoint equivalents, while ignoring irrelevant system flags such as \nofail\ or \auto\. This enables persistent, automated mounting of S3 buckets via standard system tools without requiring custom wrapper scripts.

mountpoint-s3/src · high confidence

The \metablock\ module has been introduced to centralize the management of inodes, S3 object locations, and file system state. This change adds new types for handling inode statistics (\InodeStat\), path resolution (\S3Location\, \ValidKey\), and lookup results (\Lookup\), along with error handling (\InodeError\) and expiration logic. It also implements a \PendingUploadHook\ to ensure local buffered data is uploaded to S3 before file handles are released or overridden, improving data consistency during concurrent write operations.

mountpoint-s3-fs/src/metablock · high confidence

The mountpoint-s3-fuser component now includes a dedicated fork of the fuser Rust crate, bringing in the upstream library's source code, build scripts (build.rs), and a comprehensive CI pipeline (GitHub Actions and Cirrus CI) that validates compilation and testing across Linux (libfuse/libfuse3), macOS, and FreeBSD. This change establishes the foundational build and testing environment for the fork, including license compliance checks and example filesystem implementations, without altering the core FUSE behavior itself.

mountpoint-s3-fuser · high confidence

The object client now uses a dedicated \ETag\ struct to represent S3 entity tags, replacing raw string handling. This new type provides type safety for ETag values and includes utilities for conversion from strings and bytes (using MD5 for mock testing), ensuring consistent handling of object identifiers in API responses.

_mountpoint-s3-client/src/object\client · medium confidence

This release introduces a new \--memory-target\ CLI argument that allows users to set a target for total memory usage, enabling Mountpoint to manage data buffers, slow down I/O under pressure, and reclaim buffers. As a consequence, a breaking change limits the number of files open for writing simultaneously based on this target and write part size, failing with \ENOMEM\ when the limit is reached. Additionally, the \--read-only\ flag is now enforced in the S3 filesystem, refusing modification operations on read-only mounts with \EROFS\, and startup now fails if \--read-part-size\ exceeds available memory buffers when a target is explicitly set. The release also adds experimental metrics for memory pressure and updates internal memory pool metrics.

mountpoint-s3 · high confidence

The S3 module now introduces dedicated configuration and path-handling types to improve how Mountpoint connects to and identifies S3 resources. A new \ClientConfig\ struct centralizes client settings, including region, endpoint URL, addressing style, dual-stack support, transfer acceleration, authentication, requester-pays, expected bucket owner, target throughput, network binding, part sizes, user agent, and optional TLS configuration. Part sizes are managed via a \PartConfig\ that validates read part sizes against the memory budget, clamping them if necessary or failing if the user explicitly set conflicting values. Path handling is refactored into \S3Path\, \Bucket\, and \Prefix\ types, enabling parsing of \s3://\ URIs (with support for bucket names and prefixes) and validating bucket names against length and character constraints, while also supporting ARNs for access points. These changes provide a more robust and configurable foundation for S3 connectivity and resource identification.

mountpoint-s3-fs/src/s3 · high confidence

The prefetcher now uses a backpressure mechanism to control memory usage and S3 request sizes. A new \BackpressureController\ and \BackpressureLimiter\ pair coordinate between the consumer and producer, allowing the read window size to scale dynamically based on consumption and queue stalls. Users can configure the initial read window size, minimum/maximum window sizes, and a multiplier for scaling up. The read window end can optionally be aligned to S3 part boundaries to improve memory tracking accuracy. This change replaces the previous static prefetching behavior with a more adaptive approach that better manages memory and network resources.

mountpoint-s3-fs/src/prefetch · high confidence

Replaced the previous memory management with a custom \PagedPool\ that enforces a configurable memory target (via \--memory-target\) and implements a priority-ordered allocation queue to serve active reads and uploads before speculative prefetches. The pool includes a background maintenance thread that prunes idle read cursors or clears seek windows under memory pressure to prevent starvation. Additionally, a \WriteHandleLimiter\ enforces a hard cap on the number of concurrently open-for-write file handles based on the available write buffer budget, rejecting new opens with \ENOMEM\ if the limit is reached to prevent out-of-memory conditions during uploads.

mountpoint-s3-fs/src/memory · high confidence

The filesystem module now includes a dedicated configuration structure (S3FilesystemConfig) that exposes user-facing options such as read-only mode, upload checksum algorithms (CRC32C and CRC64NVME), content-type detection, and background request limits, alongside cache and permission settings. This is supported by a new error-handling system that maps internal filesystem errors to standard POSIX errno values for FUSE compatibility and introduces structured error metadata for improved observability.

mountpoint-s3-fs/src/fs · high confidence

The FUSE session logic has been reorganized into distinct \config.rs\ and \session.rs\ modules. \FuseSessionConfig\ now centralizes mount options (such as read-only, auto-unmount, and access controls) and mount point definitions (supporting both standard directories and Linux file descriptors for autofs compatibility). The \FuseSession\ struct manages a multi-threaded worker pool for handling FUSE requests, providing a \join\ method that blocks until the filesystem is unmounted or an interrupt signal is received, while also supporting custom close handlers.

mountpoint-s3-fs/src/fuse · high confidence

The benchmark infrastructure has been restructured to use a unified \BaseBenchmark\ abstract class, standardizing the setup, execution, and post-processing lifecycle for all benchmark types (Client, CRT, FIO, and Prefetch). This change introduces native support for flamegraph profiling by passing a \with\_flamegraph\ flag through the setup phase, which configures the Rust build environment with specific compiler flags (\-fno-omit-frame-pointer\ and \-C force-frame-pointers=yes\). Additionally, the refactoring consolidates command execution and environment handling into dedicated helper classes, ensuring consistent argument construction and environment variable management across all benchmark implementations.

benchmark/benchmarks · high confidence

The superblock module has been restructured to enhance performance and reliability. File handle tracking has been extracted into a dedicated \InodeHandleMap\ to manage reader and writer states more robustly, preventing conflicts during concurrent access. Inode state management now uses explicit read/write locks (\InodeLockedForReading\/\InodeLockedForWriting\) to ensure thread safety and prevent deadlocks during hierarchical operations. A new \NegativeCache\ has been introduced to cache failed lookups with configurable TTL and size limits, reducing redundant S3 requests for non-existent files. Additionally, the \readdir\ implementation has been refined to better handle local and remote entry merging, sorting, and buffering, ensuring consistent directory listings even when local and remote states diverge.

mountpoint-s3-fs/src/superblock · high confidence

The upload implementation in \mountpoint-s3-fs/src/upload\ has been restructured into separate \atomic.rs\ and \incremental.rs\ modules, each managing its own request lifecycle and error handling. This change introduces specific checksum handling via new \hasher.rs\ logic (supporting CRC32C and CRC64NVME for atomic uploads) and enforces sequential writes with offset validation in both paths. Users benefit from clearer separation of single-part (atomic) and multi-part (incremental) upload behaviors, with improved internal robustness against race conditions and out-of-order writes.

mountpoint-s3-fs/src/upload · high confidence

The client library has undergone significant API changes in version 0.22.0. The experimental \MemoryPool\ trait is redesigned: the synchronous \get\_buffer\ method is removed and replaced by a required \get\_buffer\_async\ method, allowing implementations to defer allocation when memory is not immediately available. Additionally, a new \TlsConfig\ type and \S3ClientConfig::tls\_config()\ builder are introduced, enabling users to configure a custom CA trust store. The \libgit2-sys\ build dependency is also bumped to 0.18.7+1.9.6.

mountpoint-s3-client · high confidence

Add cache block serialization benchmark; Added CLI and integration tests for mount-s3; Added benchmarks for CRT checksums and event loop futures; Added fstab-based integration tests for Mountpoint S3; Added integration test for OTLP metrics export; Added integration tests for FUSE filesystem behavior and direct I/O caching; Added property-based reference tests for Mountpoint S3 FS; Added stress-test harness and scenarios for mountpoint-s3-fs; Added tests for SmartBenchmarkSweeper parameter matching and isolation; Consolidated test credential helpers and S3 configuration utilities; Expanded FUSE integration test coverage for caching, permissions, and manifest handling; Expanded integration test coverage for S3 client operations; New shared test infrastructure for integration testing; New test infrastructure for credentials, memory pools, and tracing.

The AWS Common Runtime (CRT) submodules have been updated to their latest releases. This location specifically tracks the git submodules for the underlying C libraries (aws-c-auth, aws-c-cal, aws-c-common, aws-c-compression, aws-c-http, aws-c-io, aws-c-s3, aws-c-sdkutils, aws-checksums, aws-lc, and s2n-tls), ensuring the binding layer uses the most recent upstream versions for security, stability, and feature parity.

mountpoint-s3-crt-sys/crt · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 65 (+5.1)
• Rubric changed (rubric-2026.09.10 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 90 → 91 (+0.0)
• Architecture 97 → 93 (-3.5)
• Maturity 68 → 68 (+0.0)
• Readiness 85 → 85 (-0.1)
• Security 49 → 64 (+14.5)
• Accessibility 57 → 57 (+0.0)
• Performance 94 (new)

• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Documentation: no usage examples (README.md)
• Hotspot: mountpoint-s3-client/src/s3_crt_client.rs (mountpoint-s3-client/src/s3_crt_client.rs)
• Hotspot: mountpoint-s3-fs/src/superblock.rs (mountpoint-s3-fs/src/superblock.rs)
• Off-boarding risk: anonymized user #1

• Dependency hygiene PARTLY measured — Cargo dependencies read, dependency currency not (crates.io unreachable)
• Documentation: no installation or build instructions (doc/TROUBLESHOOTING.md)
• Duplicated block (6–10 lines × 2) (examples/pytorch/resnet.py)
• Hotspot: benchmark/benchmarks/mountpoint.py (benchmark/benchmarks/mountpoint.py)
• Low cohesion: KernelConfig (LCOM4 5) (mountpoint-s3-fuser/src/lib.rs)
• Off the main sequence: mountpoint-s3-fuser
• Off-boarding risk: anonymized user #1
• Projects may be oversized for their cohesion

• 16 commits — 14 feature/other, 2 fixes

• .github/workflows — 10 commits
• (root) — 1 commit
• .github/actions — 1 commit
• mountpoint-s3-client/CHANGELOG.md — 1 commit
• mountpoint-s3-crt-sys/crt — 1 commit
• mountpoint-s3-fs/CHANGELOG.md — 1 commit
• mountpoint-s3-fs/src — 1 commit

• fix: Fix directory lookup after empty S3 list pages (#1954)
• fix: Fix warnings setting in setup-rust-toolchain (#1962)
• change: Add override to otel-collector version (#1963)
• change: Bump actions-rust-lang/setup-rust-toolchain from 1.17.0 to 2.0.0 (#1958)
• change: Bump astral-sh/setup-uv from 10.0.1 to 10.1.0 (#1966)
• change: Bump astral-sh/setup-uv from 10.1.0 to 10.2.0 (#1971)
• change: Bump aws-actions/configure-aws-credentials from 6.2.4 to 6.3.0 (#1975)
• change: Bump benchmark-action/github-action-benchmark from 1.22.1 to 1.22.2 (#1972)
• change: Bump docker/build-push-action from 7.3.0 to 7.4.0 (#1973)
• change: Bump taiki-e/install-action from 2.87.12 to 2.87.17 (#1974)
• change: Bump taiki-e/install-action from 2.87.2 to 2.87.8 (#1959)
• change: Bump taiki-e/install-action from 2.87.8 to 2.87.12 (#1965)
• change: Update CRT submodules to latest releases (#1967)
• change: Update changelogs in preparation of mountpoint-s3-client release (#1968)
• change: Update rustls to 0.23.45 (#1960)
• change: Upgrade Rust toolchain to 1.98 (#1961)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

awslabs/mountpoint-s3 was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.