From 40cbc3f043eeea8b8f27ece943f42437a264239b Mon Sep 17 00:00:00 2001 From: Miguel Ojeda Date: Tue, 24 Sep 2019 01:14:15 +0200 Subject: Initial Rust support MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Currently we have several lines of work:   - Integrating with the kernel tree and build system (Nick's & mine, both uploaded as branches, based on `rustc`; and another one I have been working on, based on `cargo`).   - Bindings and the first bits of functionality (Alex's & Geoffrey's, based on `cargo`). This patch effectively merges the work we have been doing and integrates it in the latest mainline kernel tree. This does *not* mean anything needs to stay as-is, but this gives us a working, common base to work and experiment upon. Hopefully, it will also attract external people to join! As a summary, I added: - `cargo` integration with the kernel `Makefile`s:   + Virtual `cargo` workspace to have a single lock file and to share deps between `cargo` jobs. + Picks the same optimization level as configured for C. + Verbose output on `V=1`. + A `cargoclean` target to clean all the Rust-related artifacts. - Initial support for built-in modules (i.e. `Y` as well as `M`): + It is a hack, we need to implement a few things (see the `TODO`s), but it is enough to start playing with things that depend on `MODULE`. + Passes `--cfg module` to built-in modules to be able to compile conditionally inside Rust. + Increased `KSYM_NAME_LEN` length to avoid warnings due to Rust long mangled symbols.   - Rust infrastructure in a new top level folder `rust/`: + A `kernel` package which contains the sources from Alex & Geoffrey's work plus some changes:     * Adapted `build.rs`. * Removed the `THIS_MODULE` emulation until it is implemented.     * Removed `Makefile` logic and the code that `cfg`-depended on kernel version (no need in mainline). * Moved the helpers to be triggered via normal compilation, renamed them under `rust_*` and exported via `EXPORT_SYMBOL` instead. * Added a prelude. + A `shlex` package which serves as an example of an "inline" dependency (i.e. package checked out copy to avoid the network) - The example driver was setup at `drivers/char/rust_example/`. - Misc + The beginning of `Documentation/rust/` with a quick start guide. + `MAINTAINERS` entry. + SPDXs for all files. Other notes that aren't in `TODO`s:   - We could minimize the network requirements (use `bindgen` binary, use more inline dependencies...), but it is not clear it would be a good idea for the moment due to `core`/`alloc`/`compiler-builtins`. - The intention of `rust/` is to have a place to put extra dependencies and split the `kernel` package into several in the future if it grows. It could resemble the usual kernel tree structure. - With several drivers being built-in, `cargo` recompiles `kernel` and triggers duplicate symbol errors when merging thin archives. We need to make it only compile `kernel` once.   - When the above works, then `make`'s `-j` calling concurrent `cargo`s (e.g. several drivers at the same time) should be OK, I think. According to https://github.com/rust-lang/cargo/pull/2486 it shouldn't miscompile anything, but if they start locking on each other we will have make jobs waiting that could have been doing something else. Signed-off-by: Miguel Ojeda --- rust/kernel/src/types.rs | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 rust/kernel/src/types.rs (limited to 'rust/kernel/src/types.rs') diff --git a/rust/kernel/src/types.rs b/rust/kernel/src/types.rs new file mode 100644 index 000000000000..ea5f8d7c2ebb --- /dev/null +++ b/rust/kernel/src/types.rs @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: GPL-2.0 + +use core::ops::Deref; + +use crate::bindings; + +pub struct Mode(bindings::umode_t); + +impl Mode { + pub fn from_int(m: u16) -> Mode { + Mode(m) + } + + pub fn as_int(&self) -> u16 { + self.0 + } +} + +/// A string that is guaranteed to have exactly one NUL byte, which is at the +/// end. Used for interoperability with kernel APIs that take C strings. +#[repr(transparent)] +pub struct CStr(str); + +impl CStr { + /// Creates a new CStr from a str without performing any additional checks. + /// # Safety + /// + /// `data` _must_ end with a NUL byte, and should only have only a single + /// NUL byte, or the string will be truncated. + pub const unsafe fn new_unchecked(data: &str) -> &CStr { + &*(data as *const str as *const CStr) + } +} + +impl Deref for CStr { + type Target = str; + + fn deref(&self) -> &str { + &self.0 + } +} + +/// Creates a new `CStr` from a string literal. The string literal should not contain any NUL +/// bytes. Example usage: +/// ``` +/// const MY_CSTR: &CStr = cstr!("My awesome CStr!"); +/// ``` +#[macro_export] +macro_rules! cstr { + ($str:expr) => {{ + let s = concat!($str, "\x00"); + unsafe { $crate::CStr::new_unchecked(s) } + }}; +} -- cgit v1.2.3