Rust PuzzleFS filesystem driver

new file mode 100644
index 000000000000..ff7a3b5c16bd
@@ -0,0 +1,59 @@
+use core::fmt;
+
+/// The error type for decoding a hex string into `Vec<u8>` or `[u8; N]`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum FromHexError {
+    /// An invalid character was found. Valid ones are: `0...9`, `a...f`
+    /// or `A...F`.
+    InvalidHexCharacter { c: char, index: usize },
+
+    /// A hex string's length needs to be even, as two digits correspond to
+    /// one byte.
+    OddLength,
+
+    /// If the hex string is decoded into a fixed sized container, such as an
+    /// array, the hex string's length * 2 has to match the container's
+    /// length.
+    InvalidStringLength,
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for FromHexError {}
+
+impl fmt::Display for FromHexError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            FromHexError::InvalidHexCharacter { c, index } => {
+                write!(f, "Invalid character {:?} at position {}", c, index)
+            }
+            FromHexError::OddLength => write!(f, "Odd number of digits"),
+            FromHexError::InvalidStringLength => write!(f, "Invalid string length"),
+        }
+    }
+}
+
+#[cfg(test)]
+// this feature flag is here to suppress unused
+// warnings of `super::*` and `pretty_assertions::assert_eq`
+#[cfg(feature = "alloc")]
+mod tests {
+    use super::*;
+    #[cfg(feature = "alloc")]
+    use alloc::string::ToString;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test_display() {
+        assert_eq!(
+            FromHexError::InvalidHexCharacter { c: '\n', index: 5 }.to_string(),
+            "Invalid character '\\n' at position 5"
+        );
+
+        assert_eq!(FromHexError::OddLength.to_string(), "Odd number of digits");
+        assert_eq!(
+            FromHexError::InvalidStringLength.to_string(),
+            "Invalid string length"
+        );
+    }
+}

525 lines not on this page · raw message

102 lines not on this page · raw message

index ff7a3b5c16bd..e553a046c9ed 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
 use core::fmt;
 
 /// The error type for decoding a hex string into `Vec<u8>` or `[u8; N]`.

index ec48961b9ffe..a23def3f80db 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
 // Copyright (c) 2013-2014 The Rust Project Developers.
 // Copyright (c) 2015-2020 The rust-hex Developers.
 //

index 335a15132a27..40ab1edb2bc8 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
 //! Hex encoding with `serde`.
 #[cfg_attr(
     all(feature = "alloc", feature = "serde"),

index a23def3f80db..3abf61ccbfc3 100644
@@ -57,43 +57,18 @@
 #[cfg(all(feature = "alloc", feature = "serde"))]
 pub use crate::serde::{serialize, serialize_upper};
 
-/// Encoding values as hex string.
-///
-/// This trait is implemented for all `T` which implement `AsRef<[u8]>`. This
-/// includes `String`, `str`, `Vec<u8>` and `[u8]`.
-///
-/// # Example
-///
-/// ```
-/// use hex::ToHex;
-///
-/// println!("{}", "Hello world!".encode_hex::<String>());
-/// # assert_eq!("Hello world!".encode_hex::<String>(), "48656c6c6f20776f726c6421".to_string());
-/// ```
-///
-/// *Note*: instead of using this trait, you might want to use [`encode()`].
-pub trait ToHex {
-    /// Encode the hex strict representing `self` into the result. Lower case
-    /// letters are used (e.g. `f9b4ca`)
-    fn encode_hex<T: iter::FromIterator<char>>(&self) -> T;
-
-    /// Encode the hex strict representing `self` into the result. Upper case
-    /// letters are used (e.g. `F9B4CA`)
-    fn encode_hex_upper<T: iter::FromIterator<char>>(&self) -> T;
-}
-
 const HEX_CHARS_LOWER: &[u8; 16] = b"0123456789abcdef";
 const HEX_CHARS_UPPER: &[u8; 16] = b"0123456789ABCDEF";
 
-struct BytesToHexChars<'a> {
+struct BytesToHexByteSequence<'a> {
     inner: ::core::slice::Iter<'a, u8>,
     table: &'static [u8; 16],
-    next: Option<char>,
+    next: Option<u8>,
 }
 
-impl<'a> BytesToHexChars<'a> {
-    fn new(inner: &'a [u8], table: &'static [u8; 16]) -> BytesToHexChars<'a> {
-        BytesToHexChars {
+impl<'a> BytesToHexByteSequence<'a> {
+    fn new(inner: &'a [u8], table: &'static [u8; 16]) -> BytesToHexByteSequence<'a> {
+        BytesToHexByteSequence {
             inner: inner.iter(),
             table,
             next: None,

@@ -101,15 +76,15 @@ impl<'a> BytesToHexChars<'a> {
     }
 }
 
-impl<'a> Iterator for BytesToHexChars<'a> {
-    type Item = char;
+impl<'a> Iterator for BytesToHexByteSequence<'a> {
+    type Item = u8;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.next.take() {
             Some(current) => Some(current),
             None => self.inner.next().map(|byte| {
-                let current = self.table[(byte >> 4) as usize] as char;
-                self.next = Some(self.table[(byte & 0x0F) as usize] as char);
+                let current = self.table[(byte >> 4) as usize];
+                self.next = Some(self.table[(byte & 0x0F) as usize]);
                 current
             }),
         }

@@ -121,7 +96,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
     }
 }
 
-impl<'a> iter::ExactSizeIterator for BytesToHexChars<'a> {
+impl<'a> iter::ExactSizeIterator for BytesToHexByteSequence<'a> {
     fn len(&self) -> usize {
         let mut length = self.inner.len() * 2;
         if self.next.is_some() {

@@ -131,19 +106,12 @@ fn len(&self) -> usize {
     }
 }
 
-#[inline]
-fn encode_to_iter<T: iter::FromIterator<char>>(table: &'static [u8; 16], source: &[u8]) -> T {
-    BytesToHexChars::new(source, table).collect()
+pub fn encode_hex_iter<'a>(source: &'a [u8]) -> impl iter::Iterator<Item = u8> + 'a {
+    BytesToHexByteSequence::new(source, HEX_CHARS_LOWER).into_iter()
 }
 
-impl<T: AsRef<[u8]>> ToHex for T {
-    fn encode_hex<U: iter::FromIterator<char>>(&self) -> U {
-        encode_to_iter(HEX_CHARS_LOWER, self.as_ref())
-    }
-
-    fn encode_hex_upper<U: iter::FromIterator<char>>(&self) -> U {
-        encode_to_iter(HEX_CHARS_UPPER, self.as_ref())
-    }
+pub fn encode_hex_upper_iter<'a>(source: &'a [u8]) -> impl iter::Iterator<Item = u8> + 'a {
+    BytesToHexByteSequence::new(source, HEX_CHARS_UPPER).into_iter()
 }
 
 /// Types that can be decoded from a hex string.

new file mode 100644
index 000000000000..c49216cd031e
@@ -0,0 +1,313 @@
+// Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
+// Licensed under the MIT License:
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//! Untyped pointer that can be cast to any struct, list, or capability type.
+
+#[cfg(feature = "alloc")]
+use alloc::{boxed::Box, vec::Vec};
+
+#[cfg(feature = "alloc")]
+use crate::capability::FromClientHook;
+#[cfg(feature = "alloc")]
+use crate::private::capability::{ClientHook, PipelineHook, PipelineOp};
+use crate::private::layout::{PointerBuilder, PointerReader};
+use crate::traits::{FromPointerBuilder, FromPointerReader, SetPointerBuilder};
+use crate::Result;
+
+#[derive(Copy, Clone)]
+pub struct Owned(());
+
+impl crate::traits::Owned for Owned {
+    type Reader<'a> = Reader<'a>;
+    type Builder<'a> = Builder<'a>;
+}
+
+impl crate::introspect::Introspect for Owned {
+    fn introspect() -> crate::introspect::Type {
+        crate::introspect::TypeVariant::AnyPointer.into()
+    }
+}
+
+impl crate::traits::Pipelined for Owned {
+    type Pipeline = Pipeline;
+}
+
+#[derive(Copy, Clone)]
+pub struct Reader<'a> {
+    pub(crate) reader: PointerReader<'a>,
+}
+
+impl<'a> Reader<'a> {
+    pub fn new(reader: PointerReader<'_>) -> Reader<'_> {
+        Reader { reader }
+    }
+
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        self.reader.is_null()
+    }
+
+    /// Gets the total size of the target and all of its children. Does not count far pointer overhead.
+    pub fn target_size(&self) -> Result<crate::MessageSize> {
+        self.reader.total_size()
+    }
+
+    #[inline]
+    pub fn get_as<T: FromPointerReader<'a>>(&self) -> Result<T> {
+        FromPointerReader::get_from_pointer(&self.reader, None)
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn get_as_capability<T: FromClientHook>(&self) -> Result<T> {
+        Ok(FromClientHook::new(self.reader.get_capability()?))
+    }
+
+    //# Used by RPC system to implement pipelining. Applications
+    //# generally shouldn't use this directly.
+    #[cfg(feature = "alloc")]
+    pub fn get_pipelined_cap(&self, ops: &[PipelineOp]) -> Result<Box<dyn ClientHook>> {
+        let mut pointer = self.reader;
+
+        for op in ops {
+            match *op {
+                PipelineOp::Noop => {}
+                PipelineOp::GetPointerField(idx) => {
+                    pointer = pointer.get_struct(None)?.get_pointer_field(idx as usize);
+                }
+            }
+        }
+
+        pointer.get_capability()
+    }
+}
+
+impl<'a> FromPointerReader<'a> for Reader<'a> {
+    fn get_from_pointer(
+        reader: &PointerReader<'a>,
+        default: Option<&'a [crate::Word]>,
+    ) -> Result<Reader<'a>> {
+        if default.is_some() {
+            panic!("Unsupported: any_pointer with a default value.");
+        }
+        Ok(Reader { reader: *reader })
+    }
+}
+
+impl<'a> crate::traits::SetPointerBuilder for Reader<'a> {
+    fn set_pointer_builder<'b>(
+        mut pointer: crate::private::layout::PointerBuilder<'b>,
+        value: Reader<'a>,
+        canonicalize: bool,
+    ) -> Result<()> {
+        pointer.copy_from(value.reader, canonicalize)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'a> crate::traits::Imbue<'a> for Reader<'a> {
+    fn imbue(&mut self, cap_table: &'a crate::private::layout::CapTable) {
+        self.reader
+            .imbue(crate::private::layout::CapTableReader::Plain(cap_table));
+    }
+}
+
+pub struct Builder<'a> {
+    builder: PointerBuilder<'a>,
+}
+
+impl<'a> Builder<'a> {
+    pub fn new(builder: PointerBuilder<'a>) -> Builder<'a> {
+        Builder { builder }
+    }
+
+    pub fn reborrow(&mut self) -> Builder<'_> {
+        Builder {
+            builder: self.builder.reborrow(),
+        }
+    }
+
+    pub fn is_null(&self) -> bool {
+        self.builder.is_null()
+    }
+
+    /// Gets the total size of the target and all of its children. Does not count far pointer overhead.
+    pub fn target_size(&self) -> Result<crate::MessageSize> {
+        self.builder.as_reader().total_size()
+    }
+
+    pub fn get_as<T: FromPointerBuilder<'a>>(self) -> Result<T> {
+        FromPointerBuilder::get_from_pointer(self.builder, None)
+    }
+
+    pub fn init_as<T: FromPointerBuilder<'a>>(self) -> T {
+        FromPointerBuilder::init_pointer(self.builder, 0)
+    }
+
+    pub fn initn_as<T: FromPointerBuilder<'a>>(self, size: u32) -> T {
+        FromPointerBuilder::init_pointer(self.builder, size)
+    }
+
+    pub fn set_as<From: SetPointerBuilder>(&mut self, value: From) -> Result<()> {
+        SetPointerBuilder::set_pointer_builder(self.builder.reborrow(), value, false)
+    }
+
+    // XXX value should be a user client.
+    #[cfg(feature = "alloc")]
+    pub fn set_as_capability(&mut self, value: Box<dyn ClientHook>) {
+        self.builder.set_capability(value);
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.builder.clear()
+    }
+
+    pub fn into_reader(self) -> Reader<'a> {
+        Reader {
+            reader: self.builder.into_reader(),
+        }
+    }
+}
+
+impl<'a> FromPointerBuilder<'a> for Builder<'a> {
+    fn init_pointer(mut builder: PointerBuilder<'a>, _len: u32) -> Builder<'a> {
+        if !builder.is_null() {
+            builder.clear();
+        }
+        Builder { builder }
+    }
+    fn get_from_pointer(
+        builder: PointerBuilder<'a>,
+        default: Option<&'a [crate::Word]>,
+    ) -> Result<Builder<'a>> {
+        if default.is_some() {
+            panic!("AnyPointer defaults are unsupported")
+        }
+        Ok(Builder { builder })
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'a> crate::traits::ImbueMut<'a> for Builder<'a> {
+    fn imbue_mut(&mut self, cap_table: &'a mut crate::private::layout::CapTable) {
+        self.builder
+            .imbue(crate::private::layout::CapTableBuilder::Plain(cap_table));
+    }
+}
+
+pub struct Pipeline {
+    // XXX this should not be public
+    #[cfg(feature = "alloc")]
+    pub hook: Box<dyn PipelineHook>,
+
+    #[cfg(feature = "alloc")]
+    ops: Vec<PipelineOp>,
+}
+
+impl Pipeline {
+    #[cfg(feature = "alloc")]
+    pub fn new(hook: Box<dyn PipelineHook>) -> Self {
+        Self {
+            hook,
+            ops: Vec::new(),
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn noop(&self) -> Self {
+        Self {
+            hook: self.hook.add_ref(),
+            ops: self.ops.clone(),
+        }
+    }
+
+    #[cfg(not(feature = "alloc"))]
+    pub fn noop(&self) -> Self {
+        Self {}
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn get_pointer_field(&self, pointer_index: u16) -> Self {
+        let mut new_ops = Vec::with_capacity(self.ops.len() + 1);
+        for op in &self.ops {
+            new_ops.push(*op)
+        }
+        new_ops.push(PipelineOp::GetPointerField(pointer_index));
+        Self {
+            hook: self.hook.add_ref(),
+            ops: new_ops,
+        }
+    }
+
+    #[cfg(not(feature = "alloc"))]
+    pub fn get_pointer_field(&self, _pointer_index: u16) -> Self {
+        Self {}
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn as_cap(&self) -> Box<dyn ClientHook> {
+        self.hook.get_pipelined_cap(&self.ops)
+    }
+}
+
+impl crate::capability::FromTypelessPipeline for Pipeline {
+    fn new(typeless: Pipeline) -> Self {
+        typeless
+    }
+}
+
+impl<'a> From<Reader<'a>> for crate::dynamic_value::Reader<'a> {
+    fn from(a: Reader<'a>) -> crate::dynamic_value::Reader<'a> {
+        crate::dynamic_value::Reader::AnyPointer(a)
+    }
+}
+
+impl<'a> From<Builder<'a>> for crate::dynamic_value::Builder<'a> {
+    fn from(a: Builder<'a>) -> crate::dynamic_value::Builder<'a> {
+        crate::dynamic_value::Builder::AnyPointer(a)
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn init_clears_value() {
+    let mut message = crate::message::Builder::new_default();
+    {
+        let root: crate::any_pointer::Builder = message.init_root();
+        let mut list: crate::primitive_list::Builder<u16> = root.initn_as(10);
+        for idx in 0..10 {
+            list.set(idx, idx as u16);
+        }
+    }
+
+    {
+        let root: crate::any_pointer::Builder = message.init_root();
+        assert!(root.is_null());
+    }
+
+    let mut output: Vec<u8> = Vec::new();
+    crate::serialize::write_message(&mut output, &message).unwrap();
+    assert_eq!(output.len(), 40);
+    for byte in &output[8..] {
+        // Everything not in the message header is zero.
+        assert_eq!(*byte, 0u8);
+    }
+}

208 lines not on this page · raw message

363 lines not on this page · raw message

297 lines not on this page · raw message

54 lines not on this page · raw message

95 lines not on this page · raw message

218 lines not on this page · raw message

408 lines not on this page · raw message

782 lines not on this page · raw message

262 lines not on this page · raw message

237 lines not on this page · raw message

282 lines not on this page · raw message

202 lines not on this page · raw message

651 lines not on this page · raw message

296 lines not on this page · raw message

878 lines not on this page · raw message

279 lines not on this page · raw message

417 lines not on this page · raw message

155 lines not on this page · raw message

4,210 lines not on this page · raw message

192 lines not on this page · raw message

62 lines not on this page · raw message

new file mode 100644
index 000000000000..1e6bcdab6d6e

Lines of this file are not shown. View the raw message.

119 lines not on this page · raw message

113 lines not on this page · raw message

68 lines not on this page · raw message

46 lines not on this page · raw message

69 lines not on this page · raw message

430 lines not on this page · raw message

14,448 lines not on this page · raw message

961 lines not on this page · raw message

627 lines not on this page · raw message

618 lines not on this page · raw message

181 lines not on this page · raw message

300 lines not on this page · raw message

294 lines not on this page · raw message

216 lines not on this page · raw message

233 lines not on this page · raw message

index c49216cd031e..83ae07a20a09 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 1c4e9e40c879..f7f4fae5678c 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2018 the capnproto-rust contributors
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy

index 7cff20bbbcb9..fbe778791c38 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 083794e073d1..b139d566a58d 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2017 David Renshaw and contributors
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy

index fdd1edf487ff..9f174366d89d 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2017 Sandstorm Development Group, Inc. and contributors
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy

index 89e0c6c19ea4..d777f1d626b0 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index f5fee2575fd2..7771ea4bb04d 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index f2c93e1cbe16..0b60674cdeab 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 //! Dynamically-typed lists.
 
 use crate::dynamic_value;

index d0244fc29f40..9da5a1e5df33 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 //! Dynamically-typed structs.
 
 use crate::introspect::TypeVariant;

index 83646e26de31..aaca4d82453f 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 //! Dynamically typed values.
 
 use crate::introspect::{self, TypeVariant};

index 8fa713029250..0192732fe16b 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index d994b180c93a..a3494935b4d5 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 //! Traits and types to support run-time type introspection, i.e. reflection.
 
 use crate::private::layout::ElementSize;

index 59d149b37c26..82c429f8c263 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 //! Custom I/O traits that roughly mirror `std::io::{Read, BufRead, Write}`.
 //! This extra layer of indirection enables support of no-std environments.
 

index daafc23c19d5..d3aa0f9f3451 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 7c31560958d3..ec7e830df7e1 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index fe40e0a7c313..595f6975c489 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 4ea31a7b50eb..a761320788b5 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 46626c1f0ce3..40c539d72142 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2017 Sandstorm Development Group, Inc. and contributors
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy

index ba725fb60535..522d0b1b0418 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 02ecb6e7bfb5..dbfe97235cd9 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 8715e9edab43..fb5a8de9bb44 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index dfa211521ca7..70937b802bf6 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 1e6bcdab6d6e..2126235199fe 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 00e41ce40f08..f70f3a7486f3 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 pub trait Primitive {
     type Raw;
 

index 0bb6a7a8415c..f4f0cf348af1 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 90fbf663f777..37782edeef56 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 00769cfebafc..12e4a723105a 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 5883b1207be9..3127b6adc0fc 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2018 the capnproto-rust contributors
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy

index 4120868f4051..b7677056cc10 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 //! Convenience wrappers of the datatypes defined in schema.capnp.
 
 use crate::dynamic_value;

index 4f92ee288821..820a1187bf59 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // @generated by the capnpc-rust plugin to the Cap'n Proto schema compiler.
 // DO NOT EDIT.
 // source: schema.capnp

index ad9e130e5ed7..025bcd45ee61 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index d3837738d702..de902a0ee4d4 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 use core::convert::TryInto;
 
 use crate::message::ReaderOptions;

index 286a36950981..63ed7264848e 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index d11bfbeb7b14..426025fea0e8 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 use crate::dynamic_value;
 use core::fmt::{self, Formatter};
 

index 5c2775ddc1fd..7133e69560bc 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index fa2a72701444..406ddb5ba8ac 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 72cbd2647ba9..222521a6741e 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 39e050ab4abf..e12c38346d56 100644
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: MIT
+
 // Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //

index 426025fea0e8..f93e3521ce0b 100644
@@ -71,8 +71,12 @@ pub(crate) fn print(
         dynamic_value::Reader::UInt16(x) => formatter.write_fmt(format_args!("{x}")),
         dynamic_value::Reader::UInt32(x) => formatter.write_fmt(format_args!("{x}")),
         dynamic_value::Reader::UInt64(x) => formatter.write_fmt(format_args!("{x}")),
+        #[cfg(not(feature = "kernel"))]
         dynamic_value::Reader::Float32(x) => formatter.write_fmt(format_args!("{x}")),
+        #[cfg(not(feature = "kernel"))]
         dynamic_value::Reader::Float64(x) => formatter.write_fmt(format_args!("{x}")),
+        #[cfg(feature = "kernel")]
+        dynamic_value::Reader::Float32(_) | dynamic_value::Reader::Float64(_) => Err(fmt::Error),
         dynamic_value::Reader::Enum(e) => match cvt(e.get_enumerant())? {
             Some(enumerant) => {
                 formatter.write_str(cvt(cvt(enumerant.get_proto().get_name())?.to_str())?)

index 629fce394dbe..2d87bb9f87c9 100644
@@ -16,6 +16,7 @@
 #include <linux/iomap.h>
 #include <linux/jiffies.h>
 #include <linux/mdio.h>
+#include <linux/namei.h>
 #include <linux/pagemap.h>
 #include <linux/phy.h>
 #include <linux/refcount.h>

index 445599d4bff6..7f0d89b902ce 100644
@@ -37,6 +37,7 @@
 #[cfg(CONFIG_KUNIT)]
 pub mod kunit;
 pub mod mem_cache;
+pub mod mount;
 #[cfg(CONFIG_NET)]
 pub mod net;
 pub mod prelude;

73 lines not on this page · raw message

index 2d87bb9f87c9..0491bb05270c 100644
@@ -13,6 +13,7 @@
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/fs_context.h>
+#include <linux/fs_parser.h>
 #include <linux/iomap.h>
 #include <linux/jiffies.h>
 #include <linux/mdio.h>

index c26aa07cb20f..90acf9677aa6 100644
@@ -28,6 +28,7 @@
 #include <linux/err.h>
 #include <linux/errname.h>
 #include <linux/fs.h>
+#include <linux/fs_parser.h>
 #include <linux/highmem.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>

@@ -353,6 +354,21 @@ void rust_helper_set_delayed_call(struct delayed_call *call,
 }
 EXPORT_SYMBOL_GPL(rust_helper_set_delayed_call);
 
+struct inode *rust_helper_d_inode(const struct dentry *dentry)
+{
+	return d_inode(dentry);
+}
+EXPORT_SYMBOL_GPL(rust_helper_d_inode);
+
+int rust_helper_fs_parse(struct fs_context *fc,
+		const struct fs_parameter_spec *desc,
+		struct fs_parameter *param,
+		struct fs_parse_result *result)
+{
+	return fs_parse(fc, desc, param, result);
+}
+EXPORT_SYMBOL_GPL(rust_helper_fs_parse);
+
 /*
  * `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can
  * use it in contexts where Rust expects a `usize` like slice (array) indices.

176 lines not on this page · raw message

index 7f0d89b902ce..ea1411a25ee4 100644
@@ -30,6 +30,7 @@
 pub mod block;
 mod build_assert;
 pub mod error;
+pub mod file;
 pub mod folio;
 pub mod fs;
 pub mod init;

index edada157879a..3cf916bc884f 100644
@@ -263,7 +263,7 @@ pub fn to_result(err: core::ffi::c_int) -> Result {
 ///     from_err_ptr(unsafe { bindings::devm_platform_ioremap_resource(pdev.to_ptr(), index) })
 /// }
 /// ```
-pub(crate) fn from_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
+pub fn from_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
     // CAST: Casting a pointer to `*const core::ffi::c_void` is always valid.
     let const_ptr: *const core::ffi::c_void = ptr.cast();
     // SAFETY: The FFI function does not deref the pointer.

140 lines not on this page · raw message

new file mode 100644
index 000000000000..e74a248c39ff
@@ -0,0 +1,5 @@
+pub(crate) mod error;
+pub(crate) mod types;
+pub(crate) use types::{manifest_capnp, metadata_capnp};
+pub(crate) mod inode;
+pub(crate) mod oci;

105 lines not on this page · raw message

100 lines not on this page · raw message

70 lines not on this page · raw message

377 lines not on this page · raw message

757 lines not on this page · raw message

1,473 lines not on this page · raw message

227 lines not on this page · raw message

index 3cf916bc884f..f8c9aa485844 100644

Lines of this file are not shown. View the raw message.

index 6ad0b6da45d3..cbc8b06183d7 100644
@@ -132,6 +132,18 @@ fn resize(&mut self, new_len: usize, value: T, flags: Flags) -> Result<(), Alloc
     {
         self.resize_with(new_len, flags, || value.clone())
     }
+
+    /// See https://doc.rust-lang.org/std/vec/struct.Vec.html#examples-31
+    fn from_iter_fallible(
+        iter: impl Iterator<Item = T>,
+        flags: Flags,
+    ) -> Result<Vec<T>, AllocError> {
+        let mut vec = Vec::new();
+        for value in iter {
+            vec.push(value, flags)?;
+        }
+        Ok(vec)
+    }
 }
 
 impl<T> VecExt<T> for Vec<T> {

index a062bf0249f6..9622ea71eda0 100644
@@ -107,8 +107,8 @@ fn fill_super(
         _: Option<inode::Mapper>,
     ) -> Result<Box<PuzzleFS>> {
         let puzzlefs = PuzzleFS::open(
-            c_str!("/home/puzzlefs_oci"),
-            c_str!("83aa96c40a20671edc4490cfefadbb487b2ab23dfc0570049b56f0cc49b56eaf"),
+            c_str!("/home/puzzlefs_xattr"),
+            c_str!("ed63ace21eccceabab08d89afb75e94dae47973f82a17a172396a19ea953c8ab"),
         );
 
         if let Err(ref e) = puzzlefs {

@@ -124,6 +124,36 @@ fn init_root(sb: &sb::SuperBlock<Self>) -> Result<dentry::Root<Self>> {
         let inode = Self::iget(sb, 1)?;
         dentry::Root::try_new(inode)
     }
+
+    fn read_xattr(
+        _dentry: &DEntry<Self>,
+        inode: &INode<Self>,
+        name: &CStr,
+        outbuf: &mut [u8],
+    ) -> Result<usize> {
+        let inode = inode.data();
+        let readonly = outbuf.len() == 0;
+        // pr_info!("outbuf len {}\n", outbuf.len());
+
+        if let Some(add) = &inode.additional {
+            let xattr = add
+                .xattrs
+                .iter()
+                .find(|elem| elem.key == name.as_bytes())
+                .ok_or(ENODATA)?;
+            if readonly {
+                return Ok(xattr.val.len());
+            }
+
+            if xattr.val.len() > outbuf.len() {
+                return Err(ERANGE);
+            }
+
+            outbuf[0..xattr.val.len()].copy_from_slice(xattr.val.as_slice());
+            return Ok(xattr.val.len());
+        }
+        Err(ENODATA)
+    }
 }
 
 #[vtable]

@@ -143,6 +173,22 @@ fn lookup(
         }
     }
 
+    fn listxattr(
+        inode: &INode<Self>,
+        mut add_entry: impl FnMut(&[i8]) -> Result<()>,
+    ) -> Result<()> {
+        let inode = inode.data();
+
+        if let Some(add) = &inode.additional {
+            for xattr in &add.xattrs {
+                // convert a u8 slice into an i8 slice
+                let i8slice = unsafe { &*(xattr.key.as_slice() as *const _ as *const [i8]) };
+                add_entry(i8slice)?;
+            }
+        }
+        Ok(())
+    }
+
     fn get_link<'a>(
         dentry: Option<&DEntry<PuzzleFsModule>>,
         inode: &'a INode<PuzzleFsModule>,

90 lines not on this page · raw message

index 3673496c2363..9023479281f0 100644
@@ -356,26 +356,35 @@ pub fn into_unique_or_drop(self) -> Option<Pin<UniqueArc<T>>> {
 
 impl<T: 'static> ForeignOwnable for Arc<T> {
     type Borrowed<'a> = ArcBorrow<'a, T>;
+    // Mutable access to the `Arc` does not give any extra abilities over
+    // immutable access.
+    type BorrowedMut<'a> = ArcBorrow<'a, T>;
 
     fn into_foreign(self) -> *const core::ffi::c_void {
         ManuallyDrop::new(self).ptr.as_ptr() as _
     }
 
+    unsafe fn from_foreign(ptr: *const core::ffi::c_void) -> Self {
+        // SAFETY: By the safety requirement of this function, we know that `ptr` came from
+        // a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and
+        // holds a reference count increment that is transferrable to us.
+        unsafe { Self::from_inner(NonNull::new_unchecked(ptr as _)) }
+    }
+
     unsafe fn borrow<'a>(ptr: *const core::ffi::c_void) -> ArcBorrow<'a, T> {
         // SAFETY: By the safety requirement of this function, we know that `ptr` came from
         // a previous call to `Arc::into_foreign`.
-        let inner = NonNull::new(ptr as *mut ArcInner<T>).unwrap();
+        let inner = unsafe { NonNull::new_unchecked(ptr as *mut ArcInner<T>) };
 
-        // SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive
-        // for the lifetime of the returned value.
+        // SAFETY: The safety requirements ensure that we will not give up our
+        // foreign-owned refcount while the `ArcBorrow` is still live.
         unsafe { ArcBorrow::new(inner) }
     }
 
-    unsafe fn from_foreign(ptr: *const core::ffi::c_void) -> Self {
-        // SAFETY: By the safety requirement of this function, we know that `ptr` came from
-        // a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and
-        // holds a reference count increment that is transferrable to us.
-        unsafe { Self::from_inner(NonNull::new(ptr as _).unwrap()) }
+    unsafe fn borrow_mut<'a>(ptr: *const core::ffi::c_void) -> ArcBorrow<'a, T> {
+        // SAFETY: The safety requirements for `borrow_mut` are a superset of the safety
+        // requirements for `borrow`.
+        unsafe { Self::borrow(ptr) }
     }
 }
 

140 lines not on this page · raw message

index c45612900fe2..b0a35d71bd49 100644
@@ -197,6 +197,25 @@ pub unsafe fn from_char_ptr<'a>(ptr: *const core::ffi::c_char) -> &'a Self {
         unsafe { Self::from_bytes_with_nul_unchecked(bytes) }
     }
 
+    /// Like from_char_ptr, but returns a mutable reference
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be a valid pointer to a `NUL`-terminated C string, and it must
+    /// last at least `'a`. When `CStr` is alive, the memory pointed by `ptr`
+    /// must not be mutated.
+    #[inline]
+    pub unsafe fn from_char_ptr_mut<'a>(ptr: *const core::ffi::c_char) -> &'a mut Self {
+        // SAFETY: The safety precondition guarantees `ptr` is a valid pointer
+        // to a `NUL`-terminated C string.
+        let len = unsafe { bindings::strlen(ptr) } + 1;
+        // SAFETY: Lifetime guaranteed by the safety precondition.
+        let bytes = unsafe { core::slice::from_raw_parts_mut(ptr as _, len as _) };
+        // SAFETY: As `len` is returned by `strlen`, `bytes` does not contain interior `NUL`.
+        // As we have added 1 to `len`, the last byte is known to be `NUL`.
+        unsafe { Self::from_bytes_with_nul_unchecked_mut(bytes) }
+    }
+
     /// Creates a [`CStr`] from a `[u8]`.
     ///
     /// The provided slice must be `NUL`-terminated, does not contain any

@@ -901,6 +920,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 
 impl ForeignOwnable for CString {
     type Borrowed<'a> = &'a CStr;
+    type BorrowedMut<'a> = &'a mut CStr;
 
     fn into_foreign(self) -> *const core::ffi::c_void {
         Box::into_raw(self.buf) as _

@@ -910,6 +930,10 @@ unsafe fn borrow<'a>(ptr: *const core::ffi::c_void) -> Self::Borrowed<'a> {
         unsafe { CStr::from_char_ptr(ptr.cast::<core::ffi::c_char>()) }
     }
 
+    unsafe fn borrow_mut<'a>(ptr: *const core::ffi::c_void) -> Self::BorrowedMut<'a> {
+        unsafe { CStr::from_char_ptr_mut(ptr.cast::<core::ffi::c_char>()) }
+    }
+
     unsafe fn from_foreign(ptr: *const core::ffi::c_void) -> Self {
         // SAFETY: The safety requirements of this function satisfy those of `Self::borrow`.
         let str = unsafe { Self::borrow(ptr) };

index 9622ea71eda0..f4e94568c9cc 100644
@@ -103,6 +103,7 @@ impl fs::FileSystem for PuzzleFsModule {
     const NAME: &'static CStr = c_str!("puzzlefs");
 
     fn fill_super(
+        _data: (),
         sb: &mut sb::SuperBlock<Self, sb::New>,
         _: Option<inode::Mapper>,
     ) -> Result<Box<PuzzleFS>> {

index 0491bb05270c..3f18e5abcc5c 100644
@@ -27,6 +27,7 @@
 #include <linux/wait.h>
 #include <linux/workqueue.h>
 #include <linux/xattr.h>
+#include <linux/fs_parser.h>
 
 /* `bindgen` gets confused at certain things. */
 const size_t RUST_CONST_HELPER_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;

296 lines not on this page · raw message

576 lines not on this page · raw message

index ea1411a25ee4..59253f5390cd 100644
@@ -12,11 +12,13 @@
 //! do so first instead of bypassing this crate.
 
 #![no_std]
+#![feature(associated_type_defaults)]
 #![feature(coerce_unsized)]
 #![feature(dispatch_from_dyn)]
 #![feature(new_uninit)]
 #![feature(receiver_trait)]
 #![feature(unsize)]
+#![feature(const_mut_refs)]
 
 // Ensure conditional compilation based on the kernel configuration works;
 // otherwise we may silently break things like initcall handling.

@@ -62,6 +64,11 @@
 #[doc(hidden)]
 pub use build_error::build_error;
 
+/// Page size defined in terms of the `PAGE_SHIFT` macro from C.
+///
+/// [`PAGE_SHIFT`]: ../../../include/asm-generic/page.h
+pub const PAGE_SIZE: usize = 1 << bindings::PAGE_SHIFT;
+
 /// Prefix to appear before log messages printed from within the `kernel` crate.
 const __LOG_PREFIX: &[u8] = b"rust_kernel\0";
 

index 5d0d1936459d..d81ea8fdf174 100644
@@ -55,6 +55,31 @@ struct Entry {
 const DIR_IOPS: inode::Ops<RoFs> = inode::Ops::new::<RoFs>();
 const FILE_AOPS: address_space::Ops<RoFs> = address_space::Ops::new::<RoFs>();
 
+#[vtable]
+impl fs::Context<Self> for RoFs {
+    type Data = ();
+
+    kernel::define_fs_params! {(),
+        {flag, "flag", |_, v| { pr_info!("flag passed-in: {v}\n"); Ok(()) } },
+        {flag_no, "flagno", |_, v| { pr_info!("flagno passed-in: {v}\n"); Ok(()) } },
+        {bool, "bool", |_, v| { pr_info!("bool passed-in: {v}\n"); Ok(()) } },
+        {u32, "u32", |_, v| { pr_info!("u32 passed-in: {v}\n"); Ok(()) } },
+        {u32oct, "u32oct", |_, v| { pr_info!("u32oct passed-in: {v}\n"); Ok(()) } },
+        {u32hex, "u32hex", |_, v| { pr_info!("u32hex passed-in: {v}\n"); Ok(()) } },
+        {s32, "s32", |_, v| { pr_info!("s32 passed-in: {v}\n"); Ok(()) } },
+        {u64, "u64", |_, v| { pr_info!("u64 passed-in: {v}\n"); Ok(()) } },
+        {string, "string", |_, v| { pr_info!("string passed-in: {v}\n"); Ok(()) } },
+        {enum, "enum", [("first", 10), ("second", 20)], |_, v| {
+            pr_info!("enum passed-in: {v}\n"); Ok(()) }
+        },
+    }
+
+    fn try_new() -> Result {
+        pr_info!("context created!\n");
+        Ok(())
+    }
+}
+
 struct RoFs;
 
 impl RoFs {

@@ -103,11 +128,16 @@ fn iget(sb: &sb::SuperBlock<Self>, e: &'static Entry) -> Result<ARef<INode<Self>
 }
 
 impl fs::FileSystem for RoFs {
+    type Context = Self;
     type Data = ();
     type INodeData = &'static Entry;
     const NAME: &'static CStr = c_str!("rust_rofs");
 
-    fn fill_super(sb: &mut sb::SuperBlock<Self, sb::New>, _: Option<inode::Mapper>) -> Result {
+    fn fill_super(
+        _data: (),
+        sb: &mut sb::SuperBlock<Self, sb::New>,
+        _: Option<inode::Mapper>,
+    ) -> Result {
         sb.set_magic(0x52555354);
         Ok(())
     }

index f4e94568c9cc..932f31917992 100644
@@ -36,6 +36,32 @@ fn mode_to_fs_type(inode: &Inode) -> Result<DirEntryType> {
     })
 }
 
+#[derive(Default)]
+struct PuzzleFsParams {
+    oci_root_dir: Option<CString>,
+    image_manifest: Option<CString>,
+}
+
+#[vtable]
+impl fs::Context<Self> for PuzzleFsModule {
+    type Data = Box<PuzzleFsParams>;
+
+    kernel::define_fs_params! {Box<PuzzleFsParams>,
+        {string, "oci_root_dir", |s, v| {
+                                      s.oci_root_dir = Some(CString::try_from_fmt(format_args!("{v}"))?);
+                                      Ok(())
+                                  }},
+        {string, "image_manifest", |s, v| {
+                                      s.image_manifest = Some(CString::try_from_fmt(format_args!("{v}"))?);
+                                      Ok(())
+                                  }},
+    }
+
+    fn try_new() -> Result<Self::Data> {
+        Ok(Box::new(PuzzleFsParams::default(), GFP_KERNEL)?)
+    }
+}
+
 const DIR_FOPS: file::Ops<PuzzleFsModule> = file::Ops::new::<PuzzleFsModule>();
 const DIR_IOPS: inode::Ops<PuzzleFsModule> = inode::Ops::new::<PuzzleFsModule>();
 const FILE_AOPS: address_space::Ops<PuzzleFsModule> = address_space::Ops::new::<PuzzleFsModule>();

@@ -98,24 +124,37 @@ fn iget(sb: &sb::SuperBlock<Self>, ino: u64) -> Result<ARef<INode<Self>>> {
 }
 
 impl fs::FileSystem for PuzzleFsModule {
+    type Context = Self;
     type Data = Box<PuzzleFS>;
     type INodeData = Inode;
     const NAME: &'static CStr = c_str!("puzzlefs");
 
     fn fill_super(
-        _data: (),
+        data: Box<PuzzleFsParams>,
         sb: &mut sb::SuperBlock<Self, sb::New>,
         _: Option<inode::Mapper>,
     ) -> Result<Box<PuzzleFS>> {
-        let puzzlefs = PuzzleFS::open(
-            c_str!("/home/puzzlefs_xattr"),
-            c_str!("ed63ace21eccceabab08d89afb75e94dae47973f82a17a172396a19ea953c8ab"),
-        );
+        let Some(oci_root_dir) = data.oci_root_dir else {
+            pr_err!("missing oci_root_dir parameter!\n");
+            return Err(ENOTSUPP);
+        };
 
+        let Some(image_manifest) = data.image_manifest else {
+            pr_err!("missing image_manifest parameter!\n");
+            return Err(ENOTSUPP);
+        };
+
+        let puzzlefs = PuzzleFS::open(&oci_root_dir, &image_manifest);
         if let Err(ref e) = puzzlefs {
             pr_info!("error opening puzzlefs {e}\n");
         }
 
+        pr_info!(
+            "opened puzzlefs [{}]:[{}]\n",
+            &*oci_root_dir,
+            &*image_manifest
+        );
+
         let puzzlefs = puzzlefs?;
         sb.set_magic(0x7a7a7570);
         Ok(Box::new(puzzlefs, GFP_KERNEL)?)

index 318edbdc5163..a34f1064b632 100644
@@ -14,6 +14,8 @@
 pub(crate) struct PuzzleFS {
     pub(crate) oci: Image,
     layers: Vec<format::MetadataBlob>,
+    pub(crate) total_inodes: u64,
+    pub(crate) total_block_size: u64,
 }
 
 impl PuzzleFS {

@@ -22,13 +24,33 @@ pub(crate) fn open(oci_root_dir: &CStr, rootfs_path: &CStr) -> Result<PuzzleFS>
         let oci = Image::open(vfs_mount)?;
         let rootfs = oci.open_rootfs_blob(rootfs_path)?;
 
+        let mut total_block_size = 0;
+        let mut total_inodes: u64 = 0;
         let mut layers = Vec::new();
         for md in rootfs.metadatas.iter() {
             let digest = Digest::try_from(md)?;
-            layers.push(oci.open_metadata_blob(&digest)?, GFP_KERNEL)?;
+            let layer = oci.open_metadata_blob(&digest)?;
+
+            // This may take up too much time, but we need to implement statfs if we want to use
+            // puzzlefs as a lower filesystem in overlayfs
+            let inodes = layer.get_inode_vector()?;
+            total_inodes += u64::from(inodes.len());
+            for inode_number in 0..inodes.len() {
+                let inode = Inode::from_capnp(inodes.get(inode_number))?;
+                if let InodeMode::File { chunks } = inode.mode {
+                    total_block_size += chunks.iter().map(|chunk| chunk.len).sum::<u64>();
+                }
+            }
+
+            layers.push(layer, GFP_KERNEL)?;
         }
 
-        Ok(PuzzleFS { oci, layers })
+        Ok(PuzzleFS {
+            oci,
+            layers,
+            total_inodes,
+            total_block_size,
+        })
     }
 
     pub(crate) fn find_inode(&self, ino: u64) -> Result<Inode> {

index 932f31917992..633f60983849 100644
@@ -4,7 +4,7 @@
 
 use kernel::fs::{
     address_space, dentry, dentry::DEntry, file, file::DirEntryType, file::File, inode,
-    inode::INode, sb, Offset,
+    inode::INode, sb, Offset, Stat,
 };
 use kernel::prelude::*;
 use kernel::types::{ARef, Either, Locked};

@@ -23,6 +23,10 @@
     license: "GPL",
 }
 
+const PUZZLEFS_BSIZE: u64 = 1 << PUZZLEFS_BSIZE_BITS;
+const PUZZLEFS_BSIZE_BITS: u8 = 12;
+const PUZZLEFS_MAGIC: usize = 0x7a7a7570;
+
 fn mode_to_fs_type(inode: &Inode) -> Result<DirEntryType> {
     Ok(match inode.mode {
         InodeMode::File { .. } => DirEntryType::Reg,

@@ -156,7 +160,7 @@ fn fill_super(
         );
 
         let puzzlefs = puzzlefs?;
-        sb.set_magic(0x7a7a7570);
+        sb.set_magic(PUZZLEFS_MAGIC);
         Ok(Box::new(puzzlefs, GFP_KERNEL)?)
     }
 

@@ -194,6 +198,19 @@ fn read_xattr(
         }
         Err(ENODATA)
     }
+
+    fn statfs(dentry: &DEntry<Self>) -> Result<Stat> {
+        let puzzlefs = dentry.super_block().data();
+
+        Ok(Stat {
+            magic: PUZZLEFS_MAGIC,
+            namelen: isize::MAX,
+            bsize: PUZZLEFS_BSIZE as _,
+            // Round total_block_size up
+            blocks: (puzzlefs.total_block_size + PUZZLEFS_BSIZE - 1) / PUZZLEFS_BSIZE,
+            files: puzzlefs.total_inodes,
+        })
+    }
 }
 
 #[vtable]