Re: [PATCH RFC 04/11] rust: siphash: Add a simple siphash abstraction

Gary Guo
2023-07-15T14:52:38Z

On Fri, 14 Jul 2023 18:13:56 +0900
Asahi Lina <lina@asahilina.net> wrote:

> This simple wrapper allows Rust code to use the Hasher interface with
> the kernel siphash implementation. No fancy features supported for now,
> just basic bag-of-bytes hashing. No guarantee that hash outputs will
> remain stable in the future either.
>
> Signed-off-by: Asahi Lina <lina@asahilina.net>
> ---
> rust/bindings/bindings_helper.h | 1 +
> rust/helpers.c | 8 ++++++++
> rust/kernel/lib.rs | 1 +
> rust/kernel/siphash.rs | 39 +++++++++++++++++++++++++++++++++++++++
> 4 files changed, 49 insertions(+)
>
> diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
> index 3e601ce2548d..52f32e423b04 100644
> --- a/rust/bindings/bindings_helper.h
> +++ b/rust/bindings/bindings_helper.h
> @@ -10,6 +10,7 @@
> #include <linux/slab.h>
> #include <linux/refcount.h>
> #include <linux/wait.h>
> +#include <linux/siphash.h>
> #include <linux/sched.h>
>
> /* `bindgen` gets confused at certain things. */
> diff --git a/rust/helpers.c b/rust/helpers.c
> index bb594da56137..1ed71315d1eb 100644
> --- a/rust/helpers.c
> +++ b/rust/helpers.c
> @@ -24,6 +24,7 @@
> #include <linux/errname.h>
> #include <linux/refcount.h>
> #include <linux/mutex.h>
> +#include <linux/siphash.h>
> #include <linux/spinlock.h>
> #include <linux/sched/signal.h>
> #include <linux/wait.h>
> @@ -135,6 +136,13 @@ void rust_helper_put_task_struct(struct task_struct *t)
> }
> EXPORT_SYMBOL_GPL(rust_helper_put_task_struct);
>
> +u64 rust_helper_siphash(const void *data, size_t len,
> + const siphash_key_t *key)
> +{
> + return siphash(data, len, key);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_siphash);
> +
> /*
> * We use `bindgen`'s `--size_t-is-usize` option to bind the C `size_t` type
> * as the Rust `usize` type, so we can use it in contexts where Rust
> diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
> index 85b261209977..8fb39078b85c 100644
> --- a/rust/kernel/lib.rs
> +++ b/rust/kernel/lib.rs
> @@ -36,6 +36,7 @@
> pub mod ioctl;
> pub mod prelude;
> pub mod print;
> +pub mod siphash;
> mod static_assert;
> #[doc(hidden)]
> pub mod std_vendor;
> diff --git a/rust/kernel/siphash.rs b/rust/kernel/siphash.rs
> new file mode 100644
> index 000000000000..e13a17cd5a93
> --- /dev/null
> +++ b/rust/kernel/siphash.rs
> @@ -0,0 +1,39 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +//! A core::hash::Hasher wrapper for the kernel siphash implementation.
> +//!
> +//! This module allows Rust code to use the kernel's siphash implementation
> +//! to hash Rust objects.
> +
> +use core::hash::Hasher;
> +
> +/// A Hasher implementation that uses the kernel siphash implementation.
> +#[derive(Default)]
> +pub struct SipHasher {
> + // SipHash state is 4xu64, but the Linux implementation
> + // doesn't expose incremental hashing so let's just chain
> + // individual SipHash calls for now, which return a u64
> + // hash.

This is actually quite a big difference, which makes me think that this
hasher probably shouldn't be called `SipHasher`.

Actually, do we need a strong hash? Given that lock dep is only for
debugging purposes, I think we can use fnv, or even just fx hash?
They're all simple enough to be implemented in a couple of lines in
Rust and wouldn't need to call into FFI.

> + state: u64,
> +}
> +
> +impl SipHasher {
> + /// Create a new SipHasher with zeroed state.
> + pub fn new() -> Self {
> + SipHasher { state: 0 }
> + }
> +}
> +
> +impl Hasher for SipHasher {
> + fn finish(&self) -> u64 {
> + self.state
> + }
> +
> + fn write(&mut self, bytes: &[u8]) {
> + let key = bindings::siphash_key_t {
> + key: [self.state, 0],
> + };
> +
> + self.state = unsafe { bindings::siphash(bytes.as_ptr() as *const _, bytes.len(), &key) };
> + }
> +}
>