Technology

Linux Rust Reinforce

From: [email protected]
To: Linus Torvalds ,
	Greg Kroah-Hartman 
Cc: [email protected], [email protected],
	[email protected], [email protected],
	Miguel Ojeda 
Field: [PATCH 00/17] Rust support
Date: Solar,  4 Jul 2021 22: 27: 39 +0200
Message-ID: <[email protected]> (raw)

From: Miguel Ojeda 

Rust support

This is the patch collection to add support for Rust as a 2nd language
to the Linux kernel.

Whenever you're inviting about following this effort, please be a part of us in
the mailing checklist at:

    [email protected]

and use a watch on the mission itself at:

    https://github.com/Rust-for-Linux

Cheers,
Miguel

--

# Rust support

This quilt letter explains the most crucial adjustments and updates completed since
the RFC sent in the outdated merge window support in April, plus just a few
further notes and bulletins. For the RFC, please detect:

    https://lore.kernel.org/lkml/[email protected]/


## Rust infrastructure updates

There had been several predominant enhancements to the overall Rust
support. The next subsections quilt these.


### Removed panicking allocations

We now comprise removed infallible allocations. In expose to total so, we now comprise
integrated a subset of the `alloc` long-established library crate, with some
additions on high. This allows us to customize things to our desires,
whereas giving upstream the time they comprise to review our adjustments.

Sooner or later, the goal is to comprise every little thing the kernel desires in
upstream `alloc` and fall it from the kernel tree. We now comprise already
started this direction of and a few adjustments had been already permitted
upstream.

On high of that, `alloc` is now compiled with panicking allocation
ideas disabled, thus they can no longer be light at some level of the kernel by
mistake both.

Furthermore, the documentation for this customized `alloc`  crate (as successfully
as for `core`) is now generated alongside the the relaxation of the Rust kernel
documentation. Thus kernel developers can now without issues browse the subset
that is available at some level of the kernel. Like last time, that that you just may perhaps well use
a watch at a preview of the documentation at:

     https://rust-for-linux.github.io/medical doctors/alloc/

Showcase that the `compiler_builtins` panicking intrinsics are mild
there, but these will seemingly be solved by partitioning `core` by approach of goal
gates. The most crucial one, for disabling floating-level efficiency,
has appropriate been permitted upstream.


### Beta compiler supported

Up except now, we now had been the utilize of nightly releases of `rustc` attributable to
we want just a few of primarily the most stylish fixes and unstable functions.

Nonetheless, the kernel can now be compiled with beta and genuine `rustc`
releases. Within the meantime, we're the utilize of the 1.54-beta1 version as our
reference compiler. At the pinnacle of this month, `rustc` 1.54 will seemingly be
released, and we can circulation to that version as our reference.

Showcase that the kernel mild requires unstable functions, even if it is
compiled with a genuine `rustc` birth, thus we can no longer guarantee that
future `rustc` versions will work without adjustments to the kernel tree.

Thus, except your entire unstable functions we need are stabilized, we can
support a single `rustc` version for every kernel birth.


### Attempting out support

One other sizable addition has been the support for making an try out. We now support
the long-established Rust `#[test]` attribute to without issues write assessments, e.g.:

    #[test]
    fn f() {
        let a = 20;
        let b = 22;
        assert_eq!(a + b, 42);
    }

Furthermore, we're in actuality also supporting Rust documentation assessments
("doctests"). These enable us to confirm that our examples stay up to
date, and also double as assessments too, e.g.:

    /// ```
    /// assert_eq!(foo::f(), 42);
    /// ```
    pub fn f() -> i32 {
        42
    }

For the moment, both forms of assessments are bustle in the host simplest, but
the goal is to comprise them working in kernel web shriek, in divulge that we can
test code that is dependent on kernel functions, and to enable any kernel
module to show and utilize them.


### Architectures and compiler support

`arm` (i.e. 32-bit) and `riscv` are in actuality also supported.

On compilers, we would fancy to level to your entire work that has been
going in GCC Rust (a GCC frontend for the Rust language) and
`rustc_codegen_gcc` (a `rustc` backend for GCC). The latter now passes
all `core` assessments, and the worn is now engaged on traits. We continue
to tune their progress as they would perhaps changed into the top seemingly manner to comprise
GCC-built kernels with Rust support enabled. Their most stylish reports
will seemingly be found at:

    https://blog.antoyo.xyz/rustc_codegen_gcc-progress-yarn-1
    https://thephilbert.io/2021/06/28/gcc-rust-weekly-space-yarn-20/

On high of that, we requested Compiler Explorer to add support to all
the replacement compilers. At the time of writing, they comprise already
added `mrustc` and GCC Rust; and `rustc_codegen_gcc` is coming quickly.
Explore a are residing example at:

    https://godbolt.org/z/8o74c57Yj


## Rust abstractions and driver updates

We now comprise developed new Rust abstractions that utilize the kernel C
implementations: purple-sunless trees, reference-counted objects, file
descriptor introduction, tasks, information, io vectors...

Furthermore, we now comprise improved driver support: enhancements to
`file_operations` (more operations supported, arbitrary sigh),
diminished boiler-plate code, improved `module!` macro, registration
macros, rudimentary (`probe` and `take`) platform drivers...

On Binder, there is now support for transferring information descriptors
and LSM hooks; and we're engaged on preliminary efficiency numbers.

Furthermore, there is ongoing work on a Rust example driver,
`bcm2835-rng`. This is the hardware random-number generator contemporary
on Raspberry Pi Zero(W), Classic, Two, and Three.

There are other small enhancements, equivalent to drivers being restricted
on what unstable functions they can utilize.


## Patch collection space

Love it turned into once mentioned in the RFC, the Rust support is mild to be
belief of experimental. Nonetheless, as neatly-known support in April, support is
appropriate ample that kernel developers can birth engaged on the Rust
abstractions for subsystems and write drivers and other modules.

Please expose that the contemporary collection comprise appropriate arrived in `linux-next`,
thus the most crucial bustle will happen on Tuesday.


## Industry and academia support

We now had been eager with a dwelling of companies and academia people
that may perhaps perhaps perhaps fancy to utilize Rust as a 2nd language in the kernel. Some
of them comprise already began to ponder Rust for his or her desires the utilize of
the infrastructure we now comprise already in web shriek.

Specifically, we now comprise just a few statements from predominant companies.
In no particular expose:

  Microsoft's Linux Methods Neighborhood is inviting about contributing to
  getting Rust into Linux kernel. With any luck we are going to seemingly be in a position to post
  use out Hyper-V drivers written in Rust in the upcoming months.

  Arm recognises the Rust price proposition and is actively working
  with the Rust crew to support Rust for Arm primarily based entirely programs.
  A appropriate example is Arm’s RFC contribution to the Rust language which
  made Linux on 64-bit Arm programs a Tier-1 Rust supported platform.
  Rustaceans at Arm are brooding relating to the Rust for Linux initiative
  and never sleep for assisting on this effort.

  Google supports and contributes directly to the Rust for Linux
  mission. Our Android crew is evaluating a new Binder implementation
  and brooding about other drivers the achieve Rust will seemingly be adopted.

To boot, IBM contributed the Rust kernel support for PowerPC
which turned into once already incorporated in the RFC.

To boot, from academia, there are already several projects around
Rust for Linux going on. To illustrate, people of LSE (Methods
Be taught Laboratory) at EPITA (École pour l'informatique et les
tactics avancées) are growing an SPI Rust driver.

And, obviously, special thanks saunter to ISRG (Cyber web Safety Be taught
Neighborhood) and Google for his or her financial support on this endeavor.


## Conferences and talks

We now comprise submitted talk proposals for LPC (Linux Plumbers Convention).

The most crucial one will inform the work we now comprise completed to this level and ideally
can even support as an introduction for other kernel developers
inviting relating to the utilize of Rust in the kernel. This can quilt an introduction
of the language at some level of the context of the kernel, how the overall Rust
support works, how code is documented, how assessments are written, a tour
of out there tooling, an clarification of coding pointers, how kernel
driver code looks fancy, etc.

To boot, we would fancy to divulge that we're organizing a new
convention that specializes in Rust and the Linux kernel. The most crucial
version will seemingly be digital and can mild happen sooner than LPC. Well-known facets will
be announced quickly.


## Acknowledgements

The signatures in the most crucial commits correspond to the these who
wrote code that has ended up in them on the contemporary time. For vital facets
on contributions to code and discussions, please detect our repository:

    https://github.com/Rust-for-Linux/linux

Nonetheless, we would fancy to present credit score to every person that has contributed
in one manner or one other to the Rust for Linux mission. For the reason that RFC:

  - bjorn3 on your entire enter on Rust compiler vital facets and all
    the opinions and ideas.

  - Arthur Cohen, Esteban Blanc and Martin Schmidt for his or her ongoing
    work on the SPI abstractions and driver.

  - Dan Robertson for his ongoing work on softdeps in the `module!`
    macro and the addition of just a few safety comments.

  - Paul Römer for his ongoing experiment on the utilize of `NonNull` as necessary
    as that that that you just may perhaps well imagine.

  - Sladyn Nunes for his ongoing sorting of error constants.

  - Jonathan Corbet and the LPC organizers for lending us the Linux
    Plumbers Convention infrastructure in divulge that we can comprise a easy
    time organising the brand new convention.

  - John Ericson for hasty implementing the `no_global_oom_handling`
    `cfg` goal in upstream `alloc` to without issues disable all
    efficiency that depends on panicking allocations.

  - Josh Triplett and John Ericson for his or her enter on `alloc` which
    helped us technique to a decision what to total with it (i.e. fully custom vs.
    slightly custom in-tree reproduction vs. upstream), besides to offering
    to support transferring forward some mandatory functions on the Rust aspect.

  - Designate Rousskov for answering some questions on beta backports
    and scheduling, besides to engaged on unsticking `1.54.0-beta.1`.

  - Philipp Krones for his enter on Clippy lints and discussing
    extensions for growing custom lints.

  - Antoni Boucher for his work on `rustc_codegen_gcc`.

  - Philip Herrons (and his supporters Open Provide Safety and
    Embecosm) for his work on GCC Rust.

  - Marc Poulhiès for his work on Compiler Explorer to add the
    replacement Rust compilers we requested.

  - Many these who comprise reported issues, examined the mission,
    helped spread the note, joined discussions and contributed in
    different ways! In no particular expose: Chenguang Wang, Greg Morenz,
    John Baublitz, Leah Leshchinsky, Caedin Cook dinner, Liam Arzola,
    Fabio Aiuto, Hanqing Zhao, Robin Randhawa, Michal Rostecki,
    Wei Liu...

For further acknowledgements, please detect the RFC from April.

Miguel Ojeda (17):
  kallsyms: support sizable kernel symbols (2-byte lengths)
  kallsyms: expand maximum kernel image length to 512
  Makefile: generate `CLANG_FLAGS` even in GCC builds
  vsprintf: add new `%pA` format specifier
  rust: add C helpers
  rust: add `compiler_builtins` crate
  rust: add `alloc` crate
  rust: add `build_error` crate
  rust: add `macros` crate
  rust: add `kernel` crate
  rust: export generated symbols
  Kbuild: add Rust support
  medical doctors: add Rust documentation
  samples: add Rust examples
  scripts: add `generate_rust_analyzer.py`
  MAINTAINERS: Rust
  Android: Binder IPC in Rust (WIP)

 .gitignore                                  |    5 +
 .rustfmt.toml                               |   12 +
 Documentation/doc-information/kernel-doc.rst      |    3 +
 Documentation/index.rst                     |    1 +
 Documentation/kbuild/kbuild.rst             |    4 +
 Documentation/direction of/adjustments.rst           |   13 +
 Documentation/rust/arch-support.rst         |   35 +
 Documentation/rust/sources/favicon-16x16.png |  Bin 0 -> 798 bytes
 Documentation/rust/sources/favicon-32x32.png |  Bin 0 -> 2076 bytes
 Documentation/rust/sources/rust-logo.png     |  Bin 0 -> 53976 bytes
 Documentation/rust/coding.rst               |   92 +
 Documentation/rust/medical doctors.rst                 |  110 +
 Documentation/rust/index.rst                |   20 +
 Documentation/rust/posthaste-birth.rst          |  222 ++
 MAINTAINERS                                 |   14 +
 Makefile                                    |  176 +-
 arch/arm/rust/target.json                   |   28 +
 arch/arm64/rust/target.json                 |   35 +
 arch/powerpc/rust/target.json               |   30 +
 arch/riscv/Makefile                         |    1 +
 arch/riscv/rust/rv32ima.json                |   37 +
 arch/riscv/rust/rv32imac.json               |   37 +
 arch/riscv/rust/rv64ima.json                |   37 +
 arch/riscv/rust/rv64imac.json               |   37 +
 arch/x86/rust/target.json                   |   37 +
 drivers/android/Kconfig                     |    7 +
 drivers/android/Makefile                    |    2 +
 drivers/android/allocation.rs               |  264 ++
 drivers/android/context.rs                  |   80 +
 drivers/android/defs.rs                     |   99 +
 drivers/android/node.rs                     |  476 +++
 drivers/android/direction of.rs                  |  972 ++++++
 drivers/android/range_alloc.rs              |  189 ++
 drivers/android/rust_binder.rs              |  114 +
 drivers/android/thread.rs                   |  857 +++++
 drivers/android/transaction.rs              |  328 ++
 embody/linux/kallsyms.h                    |    2 +-
 embody/linux/spinlock.h                    |   17 +-
 embody/uapi/linux/android/binder.h         |   28 +-
 init/Kconfig                                |   28 +
 kernel/kallsyms.c                           |    7 +
 kernel/livepatch/core.c                     |    4 +-
 kernel/printk/printk.c                      |    5 +-
 lib/Kconfig.debug                           |  144 +
 lib/vsprintf.c                              |   12 +
 rust/.gitignore                             |    6 +
 rust/Makefile                               |  316 ++
 rust/alloc/README.md                        |   32 +
 rust/alloc/alloc.rs                         |  425 +++
 rust/alloc/borrow.rs                        |  493 +++
 rust/alloc/boxed.rs                         | 1728 ++++++++++
 rust/alloc/collections/mod.rs               |  116 +
 rust/alloc/fmt.rs                           |  587 ++++
 rust/alloc/lib.rs                           |  197 ++
 rust/alloc/macros.rs                        |  128 +
 rust/alloc/prelude/mod.rs                   |   17 +
 rust/alloc/prelude/v1.rs                    |   16 +
 rust/alloc/raw_vec.rs                       |  612 ++++
 rust/alloc/rc.rs                            | 2539 +++++++++++++++
 rust/alloc/slice.rs                         | 1271 ++++++++
 rust/alloc/str.rs                           |  614 ++++
 rust/alloc/string.rs                        | 2847 ++++++++++++++++
 rust/alloc/sync.rs                          | 2631 +++++++++++++++
 rust/alloc/vec/drain.rs                     |  157 +
 rust/alloc/vec/drain_filter.rs              |  145 +
 rust/alloc/vec/into_iter.rs                 |  296 ++
 rust/alloc/vec/is_zero.rs                   |  106 +
 rust/alloc/vec/mod.rs                       | 3255 +++++++++++++++++++
 rust/alloc/vec/partial_eq.rs                |   49 +
 rust/alloc/vec/set_len_on_drop.rs           |   30 +
 rust/alloc/vec/spec_extend.rs               |  170 +
 rust/bindgen_parameters                     |   13 +
 rust/build_error.rs                         |   33 +
 rust/compiler_builtins.rs                   |  146 +
 rust/exports.c                              |   16 +
 rust/helpers.c                              |  235 ++
 rust/kernel/allocator.rs                    |   63 +
 rust/kernel/bindings.rs                     |   28 +
 rust/kernel/bindings_helper.h               |   24 +
 rust/kernel/buffer.rs                       |   39 +
 rust/kernel/build_assert.rs                 |   80 +
 rust/kernel/c_types.rs                      |  119 +
 rust/kernel/chrdev.rs                       |  212 ++
 rust/kernel/error.rs                        |  272 ++
 rust/kernel/file.rs                         |  130 +
 rust/kernel/file_operations.rs              |  698 ++++
 rust/kernel/io_buffer.rs                    |  153 +
 rust/kernel/iov_iter.rs                     |   95 +
 rust/kernel/lib.rs                          |  220 ++
 rust/kernel/linked_list.rs                  |  245 ++
 rust/kernel/miscdev.rs                      |  113 +
 rust/kernel/module_param.rs                 |  497 +++
 rust/kernel/of.rs                           |  101 +
 rust/kernel/pages.rs                        |  176 +
 rust/kernel/platdev.rs                      |  166 +
 rust/kernel/prelude.rs                      |   28 +
 rust/kernel/print.rs                        |  412 +++
 rust/kernel/random.rs                       |   50 +
 rust/kernel/raw_list.rs                     |  361 ++
 rust/kernel/rbtree.rs                       |  570 ++++
 rust/kernel/security.rs                     |   79 +
 rust/kernel/static_assert.rs                |   39 +
 rust/kernel/str.rs                          |  259 ++
 rust/kernel/sync/arc.rs                     |  227 ++
 rust/kernel/sync/condvar.rs                 |  136 +
 rust/kernel/sync/guard.rs                   |   82 +
 rust/kernel/sync/locked_by.rs               |  112 +
 rust/kernel/sync/mod.rs                     |   84 +
 rust/kernel/sync/mutex.rs                   |  101 +
 rust/kernel/sync/spinlock.rs                |  109 +
 rust/kernel/sysctl.rs                       |  198 ++
 rust/kernel/project.rs                         |  193 ++
 rust/kernel/traits.rs                       |   26 +
 rust/kernel/kinds.rs                        |  249 ++
 rust/kernel/user_ptr.rs                     |  191 ++
 rust/macros/lib.rs                          |  127 +
 rust/macros/module.rs                       |  754 +++++
 samples/Kconfig                             |    2 +
 samples/Makefile                            |    1 +
 samples/rust/Kconfig                        |  113 +
 samples/rust/Makefile                       |   12 +
 samples/rust/rust_chrdev.rs                 |   51 +
 samples/rust/rust_minimal.rs                |   38 +
 samples/rust/rust_miscdev.rs                |  150 +
 samples/rust/rust_module_parameters.rs      |   72 +
 samples/rust/rust_print.rs                  |   57 +
 samples/rust/rust_random.rs                 |   61 +
 samples/rust/rust_semaphore.rs              |  177 +
 samples/rust/rust_semaphore_c.c             |  212 ++
 samples/rust/rust_stack_probing.rs          |   40 +
 samples/rust/rust_sync.rs                   |   81 +
 scripts/Makefile.comprise                      |   22 +
 scripts/Makefile.lib                        |   12 +
 scripts/generate_rust_analyzer.py           |  143 +
 scripts/kallsyms.c                          |   33 +-
 scripts/kconfig/confdata.c                  |   67 +-
 scripts/rust-version.sh                     |   31 +
 instruments/embody/linux/kallsyms.h              |    2 +-
 instruments/embody/linux/lockdep.h               |    2 +-
 instruments/lib/perf/embody/perf/match.h         |    2 +-
 instruments/lib/image/kallsyms.h                 |    2 +-
 141 information changed, 33003 insertions(+), 45 deletions(-)
 build mode 100644 .rustfmt.toml
 build mode 100644 Documentation/rust/arch-support.rst
 build mode 100644 Documentation/rust/sources/favicon-16x16.png
 build mode 100644 Documentation/rust/sources/favicon-32x32.png
 build mode 100644 Documentation/rust/sources/rust-logo.png
 build mode 100644 Documentation/rust/coding.rst
 build mode 100644 Documentation/rust/medical doctors.rst
 build mode 100644 Documentation/rust/index.rst
 build mode 100644 Documentation/rust/posthaste-birth.rst
 build mode 100644 arch/arm/rust/target.json
 build mode 100644 arch/arm64/rust/target.json
 build mode 100644 arch/powerpc/rust/target.json
 build mode 100644 arch/riscv/rust/rv32ima.json
 build mode 100644 arch/riscv/rust/rv32imac.json
 build mode 100644 arch/riscv/rust/rv64ima.json
 build mode 100644 arch/riscv/rust/rv64imac.json
 build mode 100644 arch/x86/rust/target.json
 build mode 100644 drivers/android/allocation.rs
 build mode 100644 drivers/android/context.rs
 build mode 100644 drivers/android/defs.rs
 build mode 100644 drivers/android/node.rs
 build mode 100644 drivers/android/direction of.rs
 build mode 100644 drivers/android/range_alloc.rs
 build mode 100644 drivers/android/rust_binder.rs
 build mode 100644 drivers/android/thread.rs
 build mode 100644 drivers/android/transaction.rs
 build mode 100644 rust/.gitignore
 build mode 100644 rust/Makefile
 build mode 100644 rust/alloc/README.md
 build mode 100644 rust/alloc/alloc.rs
 build mode 100644 rust/alloc/borrow.rs
 build mode 100644 rust/alloc/boxed.rs
 build mode 100644 rust/alloc/collections/mod.rs
 build mode 100644 rust/alloc/fmt.rs
 build mode 100644 rust/alloc/lib.rs
 build mode 100644 rust/alloc/macros.rs
 build mode 100644 rust/alloc/prelude/mod.rs
 build mode 100644 rust/alloc/prelude/v1.rs
 build mode 100644 rust/alloc/raw_vec.rs
 build mode 100644 rust/alloc/rc.rs
 build mode 100644 rust/alloc/slice.rs
 build mode 100644 rust/alloc/str.rs
 build mode 100644 rust/alloc/string.rs
 build mode 100644 rust/alloc/sync.rs
 build mode 100644 rust/alloc/vec/drain.rs
 build mode 100644 rust/alloc/vec/drain_filter.rs
 build mode 100644 rust/alloc/vec/into_iter.rs
 build mode 100644 rust/alloc/vec/is_zero.rs
 build mode 100644 rust/alloc/vec/mod.rs
 build mode 100644 rust/alloc/vec/partial_eq.rs
 build mode 100644 rust/alloc/vec/set_len_on_drop.rs
 build mode 100644 rust/alloc/vec/spec_extend.rs
 build mode 100644 rust/bindgen_parameters
 build mode 100644 rust/build_error.rs
 build mode 100644 rust/compiler_builtins.rs
 build mode 100644 rust/exports.c
 build mode 100644 rust/helpers.c
 build mode 100644 rust/kernel/allocator.rs
 build mode 100644 rust/kernel/bindings.rs
 build mode 100644 rust/kernel/bindings_helper.h
 build mode 100644 rust/kernel/buffer.rs
 build mode 100644 rust/kernel/build_assert.rs
 build mode 100644 rust/kernel/c_types.rs
 build mode 100644 rust/kernel/chrdev.rs
 build mode 100644 rust/kernel/error.rs
 build mode 100644 rust/kernel/file.rs
 build mode 100644 rust/kernel/file_operations.rs
 build mode 100644 rust/kernel/io_buffer.rs
 build mode 100644 rust/kernel/iov_iter.rs
 build mode 100644 rust/kernel/lib.rs
 build mode 100644 rust/kernel/linked_list.rs
 build mode 100644 rust/kernel/miscdev.rs
 build mode 100644 rust/kernel/module_param.rs
 build mode 100644 rust/kernel/of.rs
 build mode 100644 rust/kernel/pages.rs
 build mode 100644 rust/kernel/platdev.rs
 build mode 100644 rust/kernel/prelude.rs
 build mode 100644 rust/kernel/print.rs
 build mode 100644 rust/kernel/random.rs
 build mode 100644 rust/kernel/raw_list.rs
 build mode 100644 rust/kernel/rbtree.rs
 build mode 100644 rust/kernel/security.rs
 build mode 100644 rust/kernel/static_assert.rs
 build mode 100644 rust/kernel/str.rs
 build mode 100644 rust/kernel/sync/arc.rs
 build mode 100644 rust/kernel/sync/condvar.rs
 build mode 100644 rust/kernel/sync/guard.rs
 build mode 100644 rust/kernel/sync/locked_by.rs
 build mode 100644 rust/kernel/sync/mod.rs
 build mode 100644 rust/kernel/sync/mutex.rs
 build mode 100644 rust/kernel/sync/spinlock.rs
 build mode 100644 rust/kernel/sysctl.rs
 build mode 100644 rust/kernel/project.rs
 build mode 100644 rust/kernel/traits.rs
 build mode 100644 rust/kernel/kinds.rs
 build mode 100644 rust/kernel/user_ptr.rs
 build mode 100644 rust/macros/lib.rs
 build mode 100644 rust/macros/module.rs
 build mode 100644 samples/rust/Kconfig
 build mode 100644 samples/rust/Makefile
 build mode 100644 samples/rust/rust_chrdev.rs
 build mode 100644 samples/rust/rust_minimal.rs
 build mode 100644 samples/rust/rust_miscdev.rs
 build mode 100644 samples/rust/rust_module_parameters.rs
 build mode 100644 samples/rust/rust_print.rs
 build mode 100644 samples/rust/rust_random.rs
 build mode 100644 samples/rust/rust_semaphore.rs
 build mode 100644 samples/rust/rust_semaphore_c.c
 build mode 100644 samples/rust/rust_stack_probing.rs
 build mode 100644 samples/rust/rust_sync.rs
 build mode 100755 scripts/generate_rust_analyzer.py
 build mode 100755 scripts/rust-version.sh

-- 
2.32.0


next             acknowledge index

Thread overview: 37+ messages / create bigger[flat|nested]  mbox.gz  Atom feed  high
2021-07-04 20: 27 ojeda [this message]
2021-07-04 20: 27 ` [PATCH 01/17] kallsyms: support sizable kernel symbols (2-byte lengths) ojeda
2021-07-04 20: 52   ` Linus Torvalds
2021-07-04 21: 15     ` Miguel Ojeda
2021-07-04 21: 28       ` Linus Torvalds
2021-07-04 21: 04   ` Matthew Wilcox
2021-07-04 21: 17     ` Miguel Ojeda
2021-07-04 21: 33       ` Matthew Wilcox
2021-07-04 21: 49         ` Matthew Wilcox
2021-07-04 22: 07           ` Miguel Ojeda
2021-07-04 22: 20         ` Gary Guo
2021-07-04 22: 42           ` Matthew Wilcox
2021-07-04 23: 14             ` Gary Guo
2021-07-04 21: 20     ` Gary Guo
2021-07-05  4: 35       ` Willy Tarreau
2021-07-04 20: 27 ` [PATCH 02/17] kallsyms: expand maximum kernel image length to 512 ojeda
2021-07-04 20: 27 ` [PATCH 03/17] Makefile: generate `CLANG_FLAGS` even in GCC builds ojeda
2021-07-04 20: 27 ` [PATCH 04/17] vsprintf: add new `%pA` format specifier ojeda
2021-07-04 20: 27 ` [PATCH 05/17] rust: add C helpers ojeda
2021-07-04 20: 27 ` [PATCH 06/17] rust: add `compiler_builtins` crate ojeda
2021-07-04 20: 27 ` [PATCH 08/17] rust: add `build_error` crate ojeda
2021-07-04 20: 27 ` [PATCH 09/17] rust: add `macros` crate ojeda
2021-07-04 20: 27 ` [PATCH 10/17] rust: add `kernel` crate ojeda
2021-07-04 20: 27 ` [PATCH 11/17] rust: export generated symbols ojeda
2021-07-04 20: 27 ` [PATCH 12/17] Kbuild: add Rust support ojeda
2021-07-04 20: 27 ` [PATCH 13/17] medical doctors: add Rust documentation ojeda
2021-07-05  5: 02   ` Willy Tarreau
2021-07-06  0: 06     ` Miguel Ojeda
2021-07-06  2: 09       ` Willy Tarreau
2021-07-04 20: 27 ` [PATCH 14/17] samples: add Rust examples ojeda
2021-07-04 20: 27 ` [PATCH 15/17] scripts: add `generate_rust_analyzer.py` ojeda
2021-07-05  5: 05   ` Willy Tarreau
2021-07-05 23: 41     ` Miguel Ojeda
2021-07-04 20: 27 ` [PATCH 16/17] MAINTAINERS: Rust ojeda
2021-07-06  0: 26   ` Pedro Tammela
2021-07-04 20: 27 ` [RFC PATCH 17/17] Android: Binder IPC in Rust (WIP) ojeda
2021-07-04 23: 11 ` [PATCH 00/17] Rust support Miguel Ojeda

Acknowledge directions: 

You may perhaps well acknowledge publicly to this message by approach of boring-text email
the utilize of any one of the next ideas:

Attach the next mbox file, import it into your mail shopper,
  and acknowledge-to-all from there: mbox

  Steer clear of high-posting and desire interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

Acknowledge the utilize of the --to, --cc, and --in-acknowledge-to
  switches of git-send-email(1):

  git send-email 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    /direction/to/YOUR_REPLY

  https://kernel.org/pub/application/scm/git/medical doctors/git-send-email.html

If your mail shopper supports surroundings the In-Acknowledge-To header
  by approach of mailto: hyperlinks, strive the mailto: link

LKML Archive on lore.kernel.org

Archives are clonable:
	git clone --believe https://lore.kernel.org/lkml/0 lkml/git/0.git
	git clone --believe https://lore.kernel.org/lkml/1 lkml/git/1.git
	git clone --believe https://lore.kernel.org/lkml/2 lkml/git/2.git
	git clone --believe https://lore.kernel.org/lkml/3 lkml/git/3.git
	git clone --believe https://lore.kernel.org/lkml/4 lkml/git/4.git
	git clone --believe https://lore.kernel.org/lkml/5 lkml/git/5.git
	git clone --believe https://lore.kernel.org/lkml/6 lkml/git/6.git
	git clone --believe https://lore.kernel.org/lkml/7 lkml/git/7.git
	git clone --believe https://lore.kernel.org/lkml/8 lkml/git/8.git
	git clone --believe https://lore.kernel.org/lkml/9 lkml/git/9.git
	git clone --believe https://lore.kernel.org/lkml/10 lkml/git/10.git

	# Whenever you comprise public-inbox 1.1+ set in, that that you just may perhaps well
	# initialize and index your believe the utilize of the next commands:
	public-inbox-init -V2 lkml lkml/ https://lore.kernel.org/lkml 
		[email protected]
	public-inbox-index lkml

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-kernel


AGPL code for this location: git clone https://public-inbox.org/public-inbox.git

Related Articles

Back to top button
%d bloggers like this: