| Message ID | 20230714-classless_lockdep-v1-4-229b9671ce31@asahilina.net (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | rust: Implicit lock class creation & Arc Lockdep integration | expand |
On 7/14/23 06:13, Asahi Lina 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> > --- > [...] > --- /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. Isn't this detail relevant to mention in the doc comment? At least to explain the difference between them. > + state: u64, > +} > [...]
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) }; > + } > +} >
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. + 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) }; + } +}
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(+)