Linux Rust Beef up

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

From: Miguel Ojeda 

Rust reinforce

That is the patch sequence to add reinforce for Rust as a 2nd language
to the Linux kernel.

When you occur to shall be attracted to following this effort, please join us in
the mailing checklist at:

    [email protected]

and take a look at out the mission itself at:

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

Cheers,
Miguel

--

# Rust reinforce

This duvet letter explains the fundamental changes and updates done since
the RFC sent in the earlier merge window relief in April, plus just a few
additional notes and announcements. For the RFC, please scrutinize:

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


## Rust infrastructure updates

There had been a whole lot of major enhancements to the general Rust
reinforce. The following subsections duvet these.


### Removed panicking allocations

Now we maintain removed infallible allocations. In expose to produce so, now we maintain
integrated a subset of the `alloc` typical library crate, with some
additions on high. This allows us to customize issues to our wants,
whereas giving upstream the time they need to take into fable our changes.

In the waste, the aim is to maintain the whole lot the kernel wants in
upstream `alloc` and drop it from the kernel tree. Now we maintain already
started this direction of and some changes had been already permitted
upstream.

On high of that, `alloc` is now compiled with panicking allocation
techniques disabled, thus they can no longer be gentle within the kernel by
mistake both.

Moreover, the documentation for this personalized `alloc`  crate (as properly
as for `core`) is now generated alongside the the leisure of the Rust kernel
documentation. Thus kernel builders can now with out danger browse the subset
that is accessible within the kernel. Bask in closing time, that you might take
a seek at a preview of the documentation at:

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

Existing that the `compiler_builtins` panicking intrinsics are unexcited
there, but these will seemingly be solved by partitioning `core` via characteristic
gates. The first one, for disabling floating-point functionality,
has truthful been permitted upstream.


### Beta compiler supported

Up unless now, now we had been the utilization of nightly releases of `rustc` because of
we need some of the important most fresh fixes and unstable aspects.

Nonetheless, the kernel can now be compiled with beta and exact `rustc`
releases. For the time being, we're the utilization of the 1.54-beta1 model as our
reference compiler. On the end of this month, `rustc` 1.54 will seemingly be
launched, and we are going to transfer to that model as our reference.

Existing that the kernel unexcited requires unstable aspects, despite the proven truth that it is
compiled with a exact `rustc` originate, thus we cannot guarantee that
future `rustc` versions will work with out changes to the kernel tree.

Thus, unless the total unstable aspects we need are stabilized, we are going to
reinforce a single `rustc` model for every kernel originate.


### Trying out reinforce

Any other colossal addition has been the reinforce for attempting out. We now reinforce
the average Rust `#[test]` attribute to with out danger write checks, e.g.:

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

Moreover, we're in actuality also supporting Rust documentation checks
("doctests"). These allow us to be particular our examples remain up to
date, and also double as checks too, e.g.:

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

For the moment, every kinds of checks are fade in the host handiest, but
the aim is to maintain them working in kernel dwelling, so that we are going to
take a look at code that is dependent on kernel aspects, and to allow any kernel
module to notify and utilize them.


### Architectures and compiler reinforce

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

On compilers, we would take care of to show the total 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` checks, and the frail is now engaged on traits. We continue
to be aware their development as they can also merely change into the wonderful manner to maintain
GCC-built kernels with Rust reinforce enabled. Their most modern experiences
shall be chanced on at:

    https://weblog.antoyo.xyz/rustc_codegen_gcc-development-portray-1
    https://thephilbert.io/2021/06/28/gcc-rust-weekly-web jabber online-portray-20/

On high of that, we requested Compiler Explorer to add reinforce to all
the choice compilers. On the time of writing, they maintain already
added `mrustc` and GCC Rust; and `rustc_codegen_gcc` is coming soon.
Search a are dwelling instance at:

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


## Rust abstractions and driver updates

Now we maintain developed unique Rust abstractions that utilize the kernel C
implementations: red-sunless trees, reference-counted objects, file
descriptor creation, obligations, files, io vectors...

Additionally, now we maintain improved driver reinforce: enhancements to
`file_operations` (more operations supported, arbitrary state),
reduced boiler-plate code, improved `module!` macro, registration
macros, rudimentary (`probe` and `need`) platform drivers...

On Binder, there would possibly be now reinforce for transferring files descriptors
and LSM hooks; and we're engaged on preliminary efficiency numbers.

Moreover, there would possibly be ongoing work on a Rust instance driver,
`bcm2835-rng`. That is the hardware random-number generator fresh
on Raspberry Pi Zero(W), Classic, Two, and Three.

There are other minute enhancements, such as drivers being restricted
on what unstable aspects they can utilize.


## Patch sequence web jabber online

Bask in it turn out to be as soon as mentioned in the RFC, the Rust reinforce is unexcited to be
even handed as experimental. Nonetheless, as eminent relief in April, reinforce is
correct adequate that kernel builders can originate engaged on the Rust
abstractions for subsystems and write drivers and other modules.

Please impress that the fresh sequence maintain truthful arrived in `linux-next`,
thus the main fade will occur on Tuesday.


## Alternate and academia reinforce

Now we had been in contact with a dwelling of corporations and academia members
that will take care of to make utilize of Rust as a 2nd language in the kernel. Some
of them maintain already began to take into fable Rust for their wants the utilization of
the infrastructure now we maintain already in put of dwelling.

Specifically, now we maintain bought just a few statements from major corporations.
In no particular expose:

  Microsoft's Linux Systems Neighborhood is attracted to contributing to
  getting Rust into Linux kernel. Optimistically we are going to have the choice to publish
  capture out Hyper-V drivers written in Rust in the impending months.

  Arm recognises the Rust worth proposition and is actively working
  with the Rust neighborhood to toughen Rust for Arm primarily based techniques.
  A correct instance is Arm’s RFC contribution to the Rust language which
  made Linux on 64-bit Arm techniques a Tier-1 Rust supported platform.
  Rustaceans at Arm are smitten by the Rust for Linux initiative
  and scrutinize ahead to aiding on this effort.

  Google helps and contributes on to the Rust for Linux
  mission. Our Android group is evaluating a brand unique Binder implementation
  and thinking about other drivers the put Rust will seemingly be adopted.

Moreover, IBM contributed the Rust kernel reinforce for PowerPC
which turn out to be as soon as already integrated in the RFC.

Moreover, from academia, there are already a whole lot of projects around
Rust for Linux going on. As an illustration, members of LSE (Systems
Research Laboratory) at EPITA (École pour l'informatique et les
tactics avancées) are constructing an SPI Rust driver.

And, obviously, particular thanks bolt to ISRG (Web Security Research
Neighborhood) and Google for their financial reinforce on this endeavor.


## Conferences and talks

Now we maintain submitted bid proposals for LPC (Linux Plumbers Conference).

The principle one will portray the work now we maintain done previously and ideally
would possibly per chance even relieve as an introduction for other kernel builders
attracted to the utilization of Rust in the kernel. This would possibly per chance even merely duvet an introduction
of the language within the context of the kernel, how the general Rust
reinforce works, how code is documented, how checks are written, a tour
of accessible tooling, an explanation of coding tips, how kernel
driver code looks take care of, and so forth.

Moreover, we would take care of to whisper that we're organizing a brand unique
convention that specializes in Rust and the Linux kernel. The first
model will seemingly be digital and ought to occur sooner than LPC. Cramped print will
be launched soon.


## Acknowledgements

The signatures in the main commits correspond to the individuals that
wrote code that has ended up in them at the fresh time. For facts
on contributions to code and discussions, please scrutinize our repository:

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

Nonetheless, we would take care of to present credit score to everyone that has contributed
in one manner or one other to the Rust for Linux mission. For the explanation that RFC:

  - bjorn3 for the total enter on Rust compiler facts and all
    the critiques and suggestions.

  - Arthur Cohen, Esteban Blanc and Martin Schmidt for their 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 utilization of `NonNull` as powerful
    as that you might think.

  - Sladyn Nunes for his ongoing sorting of error constants.

  - Jonathan Corbet and the LPC organizers for lending us the Linux
    Plumbers Conference infrastructure so that we are going to maintain a straightforward
    time constructing the unique convention.

  - John Ericson for swiftly imposing the `no_global_oom_handling`
    `cfg` characteristic in upstream `alloc` to with out danger disable all
    functionality that relies on panicking allocations.

  - Josh Triplett and John Ericson for their enter on `alloc` which
    helped us think what to produce with it (i.e. fully custom vs.
    rather custom in-tree reproduction vs. upstream), as properly as providing
    to support transferring forward some wished aspects on the Rust aspect.

  - Designate Rousskov for answering some questions about beta backports
    and scheduling, as properly as engaged on unsticking `1.54.0-beta.1`.

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

  - Antoni Boucher for his work on `rustc_codegen_gcc`.

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

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

  - Many individuals which maintain reported considerations, examined the mission,
    helped spread the observe, joined discussions and contributed in
    alternative techniques! In no particular expose: Chenguang Wang, Greg Morenz,
    John Baublitz, Leah Leshchinsky, Caedin Cook, Liam Arzola,
    Fabio Aiuto, Hanqing Zhao, Robin Randhawa, Michal Rostecki,
    Wei Liu...

For additional acknowledgements, please scrutinize the RFC from April.

Miguel Ojeda (17):
  kallsyms: reinforce colossal kernel symbols (2-byte lengths)
  kallsyms: prolong maximum kernel image dimension to 512
  Makefile: generate `CLANG_FLAGS` even in GCC builds
  vsprintf: add unique `%pA` structure 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 reinforce
  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-data/kernel-doc.rst      |    3 +
 Documentation/index.rst                     |    1 +
 Documentation/kbuild/kbuild.rst             |    4 +
 Documentation/direction of/changes.rst           |   13 +
 Documentation/rust/arch-reinforce.rst         |   35 +
 Documentation/rust/belongings/favicon-16x16.png |  Bin 0 -> 798 bytes
 Documentation/rust/belongings/favicon-32x32.png |  Bin 0 -> 2076 bytes
 Documentation/rust/belongings/rust-logo.png     |  Bin 0 -> 53976 bytes
 Documentation/rust/coding.rst               |   92 +
 Documentation/rust/doctors.rst                 |  110 +
 Documentation/rust/index.rst                |   20 +
 Documentation/rust/rapid-originate.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 ++
 encompass/linux/kallsyms.h                    |    2 +-
 encompass/linux/spinlock.h                    |   17 +-
 encompass/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/nick.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.perform                      |   22 +
 scripts/Makefile.lib                        |   12 +
 scripts/generate_rust_analyzer.py           |  143 +
 scripts/kallsyms.c                          |   33 +-
 scripts/kconfig/confdata.c                  |   67 +-
 scripts/rust-model.sh                     |   31 +
 instruments/encompass/linux/kallsyms.h              |    2 +-
 instruments/encompass/linux/lockdep.h               |    2 +-
 instruments/lib/perf/encompass/perf/tournament.h         |    2 +-
 instruments/lib/image/kallsyms.h                 |    2 +-
 141 files changed, 33003 insertions(+), 45 deletions(-)
 make mode 100644 .rustfmt.toml
 make mode 100644 Documentation/rust/arch-reinforce.rst
 make mode 100644 Documentation/rust/belongings/favicon-16x16.png
 make mode 100644 Documentation/rust/belongings/favicon-32x32.png
 make mode 100644 Documentation/rust/belongings/rust-logo.png
 make mode 100644 Documentation/rust/coding.rst
 make mode 100644 Documentation/rust/doctors.rst
 make mode 100644 Documentation/rust/index.rst
 make mode 100644 Documentation/rust/rapid-originate.rst
 make mode 100644 arch/arm/rust/target.json
 make mode 100644 arch/arm64/rust/target.json
 make mode 100644 arch/powerpc/rust/target.json
 make mode 100644 arch/riscv/rust/rv32ima.json
 make mode 100644 arch/riscv/rust/rv32imac.json
 make mode 100644 arch/riscv/rust/rv64ima.json
 make mode 100644 arch/riscv/rust/rv64imac.json
 make mode 100644 arch/x86/rust/target.json
 make mode 100644 drivers/android/allocation.rs
 make mode 100644 drivers/android/context.rs
 make mode 100644 drivers/android/defs.rs
 make mode 100644 drivers/android/node.rs
 make mode 100644 drivers/android/direction of.rs
 make mode 100644 drivers/android/range_alloc.rs
 make mode 100644 drivers/android/rust_binder.rs
 make mode 100644 drivers/android/thread.rs
 make mode 100644 drivers/android/transaction.rs
 make mode 100644 rust/.gitignore
 make mode 100644 rust/Makefile
 make mode 100644 rust/alloc/README.md
 make mode 100644 rust/alloc/alloc.rs
 make mode 100644 rust/alloc/borrow.rs
 make mode 100644 rust/alloc/boxed.rs
 make mode 100644 rust/alloc/collections/mod.rs
 make mode 100644 rust/alloc/fmt.rs
 make mode 100644 rust/alloc/lib.rs
 make mode 100644 rust/alloc/macros.rs
 make mode 100644 rust/alloc/prelude/mod.rs
 make mode 100644 rust/alloc/prelude/v1.rs
 make mode 100644 rust/alloc/raw_vec.rs
 make mode 100644 rust/alloc/rc.rs
 make mode 100644 rust/alloc/nick.rs
 make mode 100644 rust/alloc/str.rs
 make mode 100644 rust/alloc/string.rs
 make mode 100644 rust/alloc/sync.rs
 make mode 100644 rust/alloc/vec/drain.rs
 make mode 100644 rust/alloc/vec/drain_filter.rs
 make mode 100644 rust/alloc/vec/into_iter.rs
 make mode 100644 rust/alloc/vec/is_zero.rs
 make mode 100644 rust/alloc/vec/mod.rs
 make mode 100644 rust/alloc/vec/partial_eq.rs
 make mode 100644 rust/alloc/vec/set_len_on_drop.rs
 make mode 100644 rust/alloc/vec/spec_extend.rs
 make mode 100644 rust/bindgen_parameters
 make mode 100644 rust/build_error.rs
 make mode 100644 rust/compiler_builtins.rs
 make mode 100644 rust/exports.c
 make mode 100644 rust/helpers.c
 make mode 100644 rust/kernel/allocator.rs
 make mode 100644 rust/kernel/bindings.rs
 make mode 100644 rust/kernel/bindings_helper.h
 make mode 100644 rust/kernel/buffer.rs
 make mode 100644 rust/kernel/build_assert.rs
 make mode 100644 rust/kernel/c_types.rs
 make mode 100644 rust/kernel/chrdev.rs
 make mode 100644 rust/kernel/error.rs
 make mode 100644 rust/kernel/file.rs
 make mode 100644 rust/kernel/file_operations.rs
 make mode 100644 rust/kernel/io_buffer.rs
 make mode 100644 rust/kernel/iov_iter.rs
 make mode 100644 rust/kernel/lib.rs
 make mode 100644 rust/kernel/linked_list.rs
 make mode 100644 rust/kernel/miscdev.rs
 make mode 100644 rust/kernel/module_param.rs
 make mode 100644 rust/kernel/of.rs
 make mode 100644 rust/kernel/pages.rs
 make mode 100644 rust/kernel/platdev.rs
 make mode 100644 rust/kernel/prelude.rs
 make mode 100644 rust/kernel/print.rs
 make mode 100644 rust/kernel/random.rs
 make mode 100644 rust/kernel/raw_list.rs
 make mode 100644 rust/kernel/rbtree.rs
 make mode 100644 rust/kernel/security.rs
 make mode 100644 rust/kernel/static_assert.rs
 make mode 100644 rust/kernel/str.rs
 make mode 100644 rust/kernel/sync/arc.rs
 make mode 100644 rust/kernel/sync/condvar.rs
 make mode 100644 rust/kernel/sync/guard.rs
 make mode 100644 rust/kernel/sync/locked_by.rs
 make mode 100644 rust/kernel/sync/mod.rs
 make mode 100644 rust/kernel/sync/mutex.rs
 make mode 100644 rust/kernel/sync/spinlock.rs
 make mode 100644 rust/kernel/sysctl.rs
 make mode 100644 rust/kernel/project.rs
 make mode 100644 rust/kernel/traits.rs
 make mode 100644 rust/kernel/kinds.rs
 make mode 100644 rust/kernel/user_ptr.rs
 make mode 100644 rust/macros/lib.rs
 make mode 100644 rust/macros/module.rs
 make mode 100644 samples/rust/Kconfig
 make mode 100644 samples/rust/Makefile
 make mode 100644 samples/rust/rust_chrdev.rs
 make mode 100644 samples/rust/rust_minimal.rs
 make mode 100644 samples/rust/rust_miscdev.rs
 make mode 100644 samples/rust/rust_module_parameters.rs
 make mode 100644 samples/rust/rust_print.rs
 make mode 100644 samples/rust/rust_random.rs
 make mode 100644 samples/rust/rust_semaphore.rs
 make mode 100644 samples/rust/rust_semaphore_c.c
 make mode 100644 samples/rust/rust_stack_probing.rs
 make mode 100644 samples/rust/rust_sync.rs
 make mode 100755 scripts/generate_rust_analyzer.py
 make mode 100755 scripts/rust-model.sh

-- 
2.32.0

next             reply index

Thread overview: 37+ messages / amplify[flat|nested]  mbox.gz  Atom feed  high
2021-07-04 20: 27 ojeda [this message]
2021-07-04 20: 27 ` [PATCH 01/17] kallsyms: reinforce colossal 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: prolong maximum kernel image dimension 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 unique `%pA` structure 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 reinforce ojeda
2021-07-04 20: 27 ` [PATCH 13/17] 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 reinforce Miguel Ojeda

Reply instructions: 

That you would be capable to well also merely reply publicly to this message via undeniable-text e mail
the utilization of any definitely one of many next techniques:

Put the next mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Keep away from high-posting and desire interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

Reply the utilization of the --to, --cc, and --in-reply-to
  switches of git-ship-e mail(1):

  git ship-e mail 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    [email protected] 
    /direction/to/YOUR_REPLY

  https://kernel.org/pub/machine/scm/git/doctors/git-ship-e mail.html

In case your mail client helps environment the In-Reply-To header
  via mailto: links, strive the mailto: hyperlink

LKML Archive on lore.kernel.org

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

	# When you occur to've got got public-inbox 1.1+ build in, that you might well also merely
	# initialize and index your mirror the utilization of the next instructions:
	public-inbox-init -V2 lkml lkml/ https://lore.kernel.org/lkml 
		[email protected]
	public-inbox-index lkml

Instance config snippet for mirrors

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


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